from typing import Dict, Any, Optional, List import logging import uuid from datetime import datetime, UTC from modules.chat.methodBase import MethodBase, ActionResult, action logger = logging.getLogger(__name__) class MethodCoder(MethodBase): """Coder method implementation for code operations""" def __init__(self, serviceCenter: Any): """Initialize the coder method""" super().__init__(serviceCenter) self.name = "coder" self.description = "Handle code operations like analysis, generation, and refactoring" @action async def analyze(self, parameters: Dict[str, Any]) -> ActionResult: """ Analyze code quality and structure Parameters: documentList (str): Reference to the document list to analyze aiPrompt (str): AI prompt for code analysis language (str, optional): Programming language (default: "python") checks (List[str], optional): Types of checks to perform (default: ["complexity", "style", "security"]) """ try: documentList = parameters.get("documentList") aiPrompt = parameters.get("aiPrompt") language = parameters.get("language", "python") checks = parameters.get("checks", ["complexity", "style", "security"]) if not documentList: return self._createResult( success=False, data={}, error="Document list reference is required" ) if not aiPrompt: return self._createResult( success=False, data={}, error="AI prompt is required" ) # Handle new document list format (list of strings) chatDocuments = self.service.getChatDocumentsFromDocumentList(documentList) if not chatDocuments: return self._createResult( success=False, data={}, error="No documents found for the provided reference" ) # Process each document individually all_code_content = [] for chatDocument in chatDocuments: fileId = chatDocument.fileId code = self.service.getFileData(fileId) file_info = self.service.getFileInfo(fileId) if not code: logger.warning(f"Code file is empty for fileId: {fileId}") continue # Use AI prompt to extract relevant code content extracted_content = await self.service.extractContentFromFileData( prompt=aiPrompt, fileData=code, filename=file_info.get('name', 'code'), mimeType=file_info.get('mimeType', 'text/plain'), base64Encoded=False ) all_code_content.append(extracted_content) if not all_code_content: return self._createResult( success=False, data={}, error="No code content could be extracted from any documents" ) # Extract text content from ExtractedContent objects text_contents = [] for content_obj in all_code_content: if hasattr(content_obj, 'contents') and content_obj.contents: # Extract text from ContentItem objects for content_item in content_obj.contents: if hasattr(content_item, 'data') and content_item.data: text_contents.append(content_item.data) elif isinstance(content_obj, str): text_contents.append(content_obj) else: # Fallback: convert to string representation text_contents.append(str(content_obj)) # Combine all extracted text content for analysis combined_content = "\n\n--- CODE SEPARATOR ---\n\n".join(text_contents) # Create analysis prompt analysis_prompt = f""" Analyze this {language} code for quality, structure, and potential issues. Code to analyze: {combined_content} Please check for: {', '.join(checks)} Provide a detailed analysis including: 1. Code quality assessment 2. Potential issues and improvements 3. Security considerations 4. Performance optimizations 5. Best practices compliance 6. Summary of findings across all documents """ # Use AI service for analysis analysis_result = await self.service.interfaceAiCalls.callAiTextAdvanced(analysis_prompt) # Create result data result_data = { "documentCount": len(chatDocuments), "language": language, "checks": checks, "analysis": analysis_result, "timestamp": datetime.now(UTC).isoformat() } return self._createResult( success=True, data={ "documents": [ { "documentName": f"code_analysis_{datetime.now(UTC).strftime('%Y%m%d_%H%M%S')}.json", "documentData": result_data } ] } ) except Exception as e: logger.error(f"Error analyzing code: {str(e)}") return self._createResult( success=False, data={}, error=str(e) ) @action async def generate(self, parameters: Dict[str, Any]) -> ActionResult: """ Generate code based on requirements Parameters: requirements (str): Requirements for the code to generate language (str, optional): Programming language (default: "python") template (str, optional): Template or pattern to follow """ try: requirements = parameters.get("requirements") language = parameters.get("language", "python") template = parameters.get("template") if not requirements: return self._createResult( success=False, data={}, error="Requirements are required" ) # Create generation prompt generation_prompt = f""" Generate {language} code based on the following requirements: Requirements: {requirements} {f'Template to follow: {template}' if template else ''} Please provide: 1. Complete, working code 2. Clear comments and documentation 3. Error handling where appropriate 4. Best practices implementation """ # Use AI service for code generation generated_code = await self.service.interfaceAiCalls.callAiTextAdvanced(generation_prompt) # Create result data result_data = { "language": language, "requirements": requirements, "code": generated_code, "timestamp": datetime.now(UTC).isoformat() } return self._createResult( success=True, data={ "documentName": f"generated_code_{datetime.now(UTC).strftime('%Y%m%d_%H%M%S')}.{language}", "documentData": result_data } ) except Exception as e: logger.error(f"Error generating code: {str(e)}") return self._createResult( success=False, data={}, error=str(e) ) @action async def refactor(self, parameters: Dict[str, Any]) -> ActionResult: """ Refactor code for better quality Parameters: documentList (str): Reference to the document list to refactor aiImprovementPrompt (str): AI prompt for code improvements language (str, optional): Programming language (default: "python") """ try: documentList = parameters.get("documentList") aiImprovementPrompt = parameters.get("aiImprovementPrompt") language = parameters.get("language", "python") if not documentList: return self._createResult( success=False, data={}, error="Document list reference is required" ) if not aiImprovementPrompt: return self._createResult( success=False, data={}, error="AI improvement prompt is required" ) # Handle new document list format (list of strings) chatDocuments = self.service.getChatDocumentsFromDocumentList(documentList) if not chatDocuments: return self._createResult( success=False, data={}, error="No documents found for the provided reference" ) # Process each document individually refactored_results = [] for chatDocument in chatDocuments: fileId = chatDocument.fileId code = self.service.getFileData(fileId) file_info = self.service.getFileInfo(fileId) if not code: logger.warning(f"Code file is empty for fileId: {fileId}") continue # Create refactoring prompt for this specific document refactor_prompt = f""" Refactor this {language} code based on the following improvement requirements: Improvement requirements: {aiImprovementPrompt} Original code: {code} Please provide: 1. Refactored code with improvements 2. Explanation of changes made 3. Benefits of the refactoring 4. Any potential trade-offs """ # Use AI service for refactoring refactored_code = await self.service.interfaceAiCalls.callAiTextAdvanced(refactor_prompt) refactored_results.append({ "original_file": file_info.get('name', 'unknown'), "original_code": code, "refactored_code": refactored_code }) if not refactored_results: return self._createResult( success=False, data={}, error="No code could be refactored from any documents" ) # Create result data result_data = { "documentCount": len(chatDocuments), "language": language, "refactored_results": refactored_results, "timestamp": datetime.now(UTC).isoformat() } return self._createResult( success=True, data={ "documentName": f"refactored_code_{datetime.now(UTC).strftime('%Y%m%d_%H%M%S')}.{language}", "documentData": result_data } ) except Exception as e: logger.error(f"Error refactoring code: {str(e)}") return self._createResult( success=False, data={}, error=str(e) )