cognify-code 0.2.0__py3-none-any.whl

ai_code_assistant/refactor/__init__.py

@@ -0,0 +1,20 @@
+"""Multi-file refactoring module for AI Code Assistant."""
+
+from ai_code_assistant.refactor.change_plan import (
+    ChangePlan,
+    FileChange,
+    ChangeType,
+    RefactorResult,
+)
+from ai_code_assistant.refactor.multi_file_editor import MultiFileEditor
+from ai_code_assistant.refactor.analyzer import RefactorAnalyzer
+
+__all__ = [
+    "ChangePlan",
+    "FileChange",
+    "ChangeType",
+    "RefactorResult",
+    "MultiFileEditor",
+    "RefactorAnalyzer",
+]
+

ai_code_assistant/refactor/analyzer.py

@@ -0,0 +1,189 @@
+"""Analyzer for determining refactoring scope and impact."""
+
+import json
+import re
+from pathlib import Path
+from typing import List, Optional
+
+from ai_code_assistant.config import Config, get_language_by_extension
+from ai_code_assistant.llm import LLMManager
+from ai_code_assistant.refactor.prompts import ANALYZE_REFACTOR_PROMPT
+from ai_code_assistant.refactor.change_plan import ChangePlan, FileChange, ChangeType
+
+
+class RefactorAnalyzer:
+    """Analyzes codebase to determine refactoring scope."""
+    
+    def __init__(self, config: Config, llm_manager: LLMManager):
+        """Initialize the refactor analyzer.
+        
+        Args:
+            config: Application configuration
+            llm_manager: LLM manager for AI interactions
+        """
+        self.config = config
+        self.llm = llm_manager
+    
+    def analyze(
+        self,
+        instruction: str,
+        files: List[Path],
+        max_files: int = 20,
+    ) -> ChangePlan:
+        """Analyze files to create a refactoring plan.
+        
+        Args:
+            instruction: Refactoring instruction
+            files: List of files to analyze
+            max_files: Maximum number of files to include
+            
+        Returns:
+            ChangePlan with proposed changes
+        """
+        # Limit files to analyze
+        files = files[:max_files]
+        
+        # Read file contents
+        file_contents = self._read_files(files)
+        
+        if not file_contents:
+            return ChangePlan(
+                instruction=instruction,
+                summary="No files to analyze",
+                changes=[],
+            )
+        
+        # Format file contents for prompt
+        formatted_contents = self._format_file_contents(file_contents)
+        
+        # Get analysis from LLM
+        try:
+            response = self.llm.invoke_with_template(
+                ANALYZE_REFACTOR_PROMPT,
+                instruction=instruction,
+                file_contents=formatted_contents,
+            )
+            
+            return self._parse_analysis(instruction, response)
+            
+        except Exception as e:
+            return ChangePlan(
+                instruction=instruction,
+                summary=f"Analysis failed: {str(e)}",
+                changes=[],
+            )
+    
+    def _read_files(self, files: List[Path]) -> dict:
+        """Read contents of files.
+        
+        Args:
+            files: List of file paths
+            
+        Returns:
+            Dict mapping file path to content
+        """
+        contents = {}
+        max_size = getattr(self.config, 'refactor', None)
+        max_size_kb = max_size.max_file_size_kb if max_size else 500
+        
+        for file_path in files:
+            if not file_path.exists():
+                continue
+            
+            # Check file size
+            if file_path.stat().st_size > max_size_kb * 1024:
+                continue
+            
+            try:
+                contents[str(file_path)] = file_path.read_text(encoding="utf-8")
+            except Exception:
+                continue
+        
+        return contents
+    
+    def _format_file_contents(self, contents: dict) -> str:
+        """Format file contents for prompt.
+        
+        Args:
+            contents: Dict mapping file path to content
+            
+        Returns:
+            Formatted string with all file contents
+        """
+        parts = []
+        for file_path, content in contents.items():
+            language = self._detect_language(file_path)
+            parts.append(f"### {file_path}\n```{language}\n{content}\n```\n")
+        return "\n".join(parts)
+    
+    def _detect_language(self, file_path: str) -> str:
+        """Detect language from file path."""
+        path = Path(file_path)
+        lang = get_language_by_extension(self.config, path)
+        return lang or "text"
+    
+    def _parse_analysis(self, instruction: str, response: str) -> ChangePlan:
+        """Parse LLM analysis response into ChangePlan.
+        
+        Args:
+            instruction: Original instruction
+            response: LLM response
+            
+        Returns:
+            Parsed ChangePlan
+        """
+        # Try to extract JSON from response
+        json_data = self._extract_json(response)
+        
+        if not json_data:
+            return ChangePlan(
+                instruction=instruction,
+                summary="Could not parse analysis response",
+                changes=[],
+            )
+        
+        # Parse changes
+        changes = []
+        for file_data in json_data.get("affected_files", []):
+            change_type_str = file_data.get("change_type", "modify").lower()
+            try:
+                change_type = ChangeType(change_type_str)
+            except ValueError:
+                change_type = ChangeType.MODIFY
+            
+            changes.append(FileChange(
+                file_path=file_data.get("file_path", ""),
+                change_type=change_type,
+                description=file_data.get("description", ""),
+                priority=file_data.get("priority", "medium"),
+                depends_on=file_data.get("depends_on", []),
+            ))
+        
+        return ChangePlan(
+            instruction=instruction,
+            summary=json_data.get("summary", ""),
+            changes=changes,
+            risks=json_data.get("risks", []),
+            complexity=json_data.get("estimated_complexity", "medium"),
+        )
+    
+    def _extract_json(self, text: str) -> Optional[dict]:
+        """Extract JSON from text response."""
+        # Try to find JSON in code block
+        match = re.search(r"```(?:json)?\s*\n?(.*?)\n?```", text, re.DOTALL)
+        if match:
+            try:
+                return json.loads(match.group(1))
+            except json.JSONDecodeError:
+                pass
+        
+        # Try to find raw JSON
+        match = re.search(r"\{.*\}", text, re.DOTALL)
+        if match:
+            try:
+                return json.loads(match.group())
+            except json.JSONDecodeError:
+                pass
+        
+        return None
+

ai_code_assistant/refactor/change_plan.py

@@ -0,0 +1,172 @@
+"""Data structures for multi-file refactoring plans."""
+
+from dataclasses import dataclass, field
+from enum import Enum
+from pathlib import Path
+from typing import Dict, List, Literal, Optional
+
+from ai_code_assistant.editor.diff_handler import DiffResult
+
+
+class ChangeType(str, Enum):
+    """Type of file change."""
+    MODIFY = "modify"
+    CREATE = "create"
+    DELETE = "delete"
+    RENAME = "rename"
+
+
+@dataclass
+class FileChange:
+    """Represents a planned change to a single file."""
+    file_path: str
+    change_type: ChangeType
+    description: str
+    priority: Literal["high", "medium", "low"] = "medium"
+    depends_on: List[str] = field(default_factory=list)
+    original_content: str = ""
+    new_content: str = ""
+    new_path: Optional[str] = None  # For rename operations
+    diff: Optional[DiffResult] = None
+    applied: bool = False
+    error: Optional[str] = None
+    
+    @property
+    def success(self) -> bool:
+        return self.error is None
+    
+    @property
+    def has_changes(self) -> bool:
+        if self.change_type == ChangeType.DELETE:
+            return True
+        if self.change_type == ChangeType.CREATE:
+            return bool(self.new_content)
+        return self.original_content != self.new_content
+    
+    def to_dict(self) -> dict:
+        return {
+            "file_path": self.file_path,
+            "change_type": self.change_type.value,
+            "description": self.description,
+            "priority": self.priority,
+            "depends_on": self.depends_on,
+            "has_changes": self.has_changes,
+            "applied": self.applied,
+            "error": self.error,
+            "new_path": self.new_path,
+            "diff": self.diff.to_dict() if self.diff else None,
+        }
+
+
+@dataclass
+class ChangePlan:
+    """A plan for multi-file refactoring."""
+    instruction: str
+    summary: str
+    changes: List[FileChange] = field(default_factory=list)
+    risks: List[str] = field(default_factory=list)
+    complexity: Literal["low", "medium", "high"] = "medium"
+    
+    @property
+    def total_files(self) -> int:
+        return len(self.changes)
+    
+    @property
+    def files_to_modify(self) -> List[FileChange]:
+        return [c for c in self.changes if c.change_type == ChangeType.MODIFY]
+    
+    @property
+    def files_to_create(self) -> List[FileChange]:
+        return [c for c in self.changes if c.change_type == ChangeType.CREATE]
+    
+    @property
+    def files_to_delete(self) -> List[FileChange]:
+        return [c for c in self.changes if c.change_type == ChangeType.DELETE]
+    
+    @property
+    def files_to_rename(self) -> List[FileChange]:
+        return [c for c in self.changes if c.change_type == ChangeType.RENAME]
+    
+    def get_ordered_changes(self) -> List[FileChange]:
+        """Get changes ordered by dependencies and priority."""
+        priority_order = {"high": 0, "medium": 1, "low": 2}
+        
+        # Simple topological sort based on dependencies
+        ordered = []
+        remaining = list(self.changes)
+        applied_paths = set()
+        
+        while remaining:
+            # Find changes with no unmet dependencies
+            ready = [
+                c for c in remaining
+                if all(dep in applied_paths for dep in c.depends_on)
+            ]
+            
+            if not ready:
+                # Circular dependency or missing dependency - add remaining
+                ready = remaining
+            
+            # Sort by priority
+            ready.sort(key=lambda c: priority_order.get(c.priority, 1))
+            
+            # Add first ready change
+            change = ready[0]
+            ordered.append(change)
+            applied_paths.add(change.file_path)
+            remaining.remove(change)
+        
+        return ordered
+    
+    def to_dict(self) -> dict:
+        return {
+            "instruction": self.instruction,
+            "summary": self.summary,
+            "total_files": self.total_files,
+            "complexity": self.complexity,
+            "risks": self.risks,
+            "changes": [c.to_dict() for c in self.changes],
+        }
+
+
+@dataclass
+class RefactorResult:
+    """Result of a multi-file refactoring operation."""
+    plan: ChangePlan
+    applied: bool = False
+    backup_dir: Optional[str] = None
+    error: Optional[str] = None
+    
+    @property
+    def success(self) -> bool:
+        return self.error is None
+    
+    @property
+    def files_changed(self) -> int:
+        return sum(1 for c in self.plan.changes if c.applied)
+    
+    @property
+    def files_failed(self) -> int:
+        return sum(1 for c in self.plan.changes if c.error)
+    
+    @property
+    def total_additions(self) -> int:
+        return sum(c.diff.additions for c in self.plan.changes if c.diff)
+    
+    @property
+    def total_deletions(self) -> int:
+        return sum(c.diff.deletions for c in self.plan.changes if c.diff)
+    
+    def to_dict(self) -> dict:
+        return {
+            "success": self.success,
+            "applied": self.applied,
+            "files_changed": self.files_changed,
+            "files_failed": self.files_failed,
+            "total_additions": self.total_additions,
+            "total_deletions": self.total_deletions,
+            "backup_dir": self.backup_dir,
+            "error": self.error,
+            "plan": self.plan.to_dict(),
+        }
+