306 lines
No EOL
11 KiB
Python
306 lines
No EOL
11 KiB
Python
from typing import Dict, Any, Optional
|
|
import logging
|
|
import uuid
|
|
from datetime import datetime, UTC
|
|
|
|
from modules.workflow.methodBase import MethodBase, ActionResult, action
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
class MethodCoder(MethodBase):
|
|
"""Coder method implementation for code operations"""
|
|
|
|
def __init__(self, serviceContainer: Any):
|
|
super().__init__(serviceContainer)
|
|
self.name = "coder"
|
|
self.description = "Handle code operations like analysis and generation"
|
|
|
|
@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"
|
|
)
|
|
|
|
chatDocuments = self.serviceContainer.getChatDocumentsFromDocumentReference(documentList)
|
|
if not chatDocuments:
|
|
return self._createResult(
|
|
success=False,
|
|
data={},
|
|
error="No documents found for the provided reference"
|
|
)
|
|
|
|
# Extract content from all documents
|
|
all_code_content = []
|
|
|
|
for chatDocument in chatDocuments:
|
|
fileId = chatDocument.fileId
|
|
code = self.serviceContainer.getFileData(fileId)
|
|
file_info = self.serviceContainer.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.serviceContainer.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"
|
|
)
|
|
|
|
# Combine all code content for analysis
|
|
combined_code = "\n\n--- CODE SEPARATOR ---\n\n".join(all_code_content)
|
|
|
|
# Create analysis prompt
|
|
analysis_prompt = f"""
|
|
Analyze this {language} code for quality, structure, and potential issues.
|
|
|
|
Code to analyze:
|
|
{combined_code}
|
|
|
|
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.serviceContainer.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={
|
|
"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.serviceContainer.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"
|
|
)
|
|
|
|
chatDocuments = self.serviceContainer.getChatDocumentsFromDocumentReference(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.serviceContainer.getFileData(fileId)
|
|
file_info = self.serviceContainer.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.serviceContainer.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)
|
|
) |