cognify-code 0.2.0__py3-none-any.whl

ai_code_assistant/agent/file_manager.py

@@ -0,0 +1,300 @@
+"""File Context Manager for reading/writing project files."""
+
+import fnmatch
+import os
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Dict, List, Optional, Set
+
+
+# Common patterns to ignore
+DEFAULT_IGNORE_PATTERNS = [
+    ".git", ".git/*", "__pycache__", "__pycache__/*", "*.pyc",
+    ".venv", ".venv/*", "venv", "venv/*", "env", "env/*",
+    "node_modules", "node_modules/*", ".next", ".next/*",
+    "dist", "dist/*", "build", "build/*", ".cache", ".cache/*",
+    "*.egg-info", "*.egg-info/*", ".eggs", ".eggs/*",
+    ".pytest_cache", ".pytest_cache/*", ".mypy_cache", ".mypy_cache/*",
+    ".tox", ".tox/*", ".coverage", "htmlcov", "htmlcov/*",
+    "*.log", "*.tmp", "*.temp", ".DS_Store", "Thumbs.db",
+    "*.min.js", "*.min.css", "*.map",
+]
+
+# File extensions we can work with
+CODE_EXTENSIONS = {
+    ".py", ".js", ".ts", ".jsx", ".tsx", ".java", ".go", ".rs",
+    ".c", ".cpp", ".h", ".hpp", ".cs", ".rb", ".php", ".swift",
+    ".kt", ".scala", ".r", ".sql", ".sh", ".bash", ".zsh",
+    ".yaml", ".yml", ".json", ".toml", ".xml", ".html", ".css",
+    ".scss", ".sass", ".less", ".md", ".rst", ".txt",
+}
+
+
+@dataclass
+class FileInfo:
+    """Information about a file."""
+    path: Path
+    relative_path: str
+    extension: str
+    size: int
+    is_code: bool
+    
+    @property
+    def language(self) -> str:
+        """Detect language from extension."""
+        ext_to_lang = {
+            ".py": "python", ".js": "javascript", ".ts": "typescript",
+            ".jsx": "javascript", ".tsx": "typescript", ".java": "java",
+            ".go": "go", ".rs": "rust", ".c": "c", ".cpp": "cpp",
+            ".h": "c", ".hpp": "cpp", ".cs": "csharp", ".rb": "ruby",
+            ".php": "php", ".swift": "swift", ".kt": "kotlin",
+            ".scala": "scala", ".r": "r", ".sql": "sql",
+            ".sh": "bash", ".bash": "bash", ".zsh": "zsh",
+            ".yaml": "yaml", ".yml": "yaml", ".json": "json",
+            ".toml": "toml", ".xml": "xml", ".html": "html",
+            ".css": "css", ".scss": "scss", ".md": "markdown",
+        }
+        return ext_to_lang.get(self.extension, "text")
+
+
+@dataclass
+class ProjectContext:
+    """Context about the current project."""
+    root_path: Path
+    files: List[FileInfo] = field(default_factory=list)
+    structure: str = ""
+    languages: Set[str] = field(default_factory=set)
+    total_files: int = 0
+    total_code_files: int = 0
+    
+    def get_files_by_language(self, language: str) -> List[FileInfo]:
+        """Get all files of a specific language."""
+        return [f for f in self.files if f.language == language]
+    
+    def get_files_by_pattern(self, pattern: str) -> List[FileInfo]:
+        """Get files matching a glob pattern."""
+        return [f for f in self.files if fnmatch.fnmatch(f.relative_path, pattern)]
+
+
+class FileContextManager:
+    """Manages file operations and project context."""
+    
+    def __init__(self, root_path: Optional[Path] = None, 
+                 ignore_patterns: Optional[List[str]] = None):
+        self.root_path = Path(root_path or os.getcwd()).resolve()
+        self.ignore_patterns = ignore_patterns or DEFAULT_IGNORE_PATTERNS
+        self._context: Optional[ProjectContext] = None
+    
+    def _should_ignore(self, path: Path) -> bool:
+        """Check if a path should be ignored."""
+        rel_path = str(path.relative_to(self.root_path))
+        name = path.name
+        
+        for pattern in self.ignore_patterns:
+            if fnmatch.fnmatch(name, pattern) or fnmatch.fnmatch(rel_path, pattern):
+                return True
+        return False
+    
+    def _is_code_file(self, path: Path) -> bool:
+        """Check if a file is a code file."""
+        return path.suffix.lower() in CODE_EXTENSIONS
+    
+    def get_project_context(self, refresh: bool = False) -> ProjectContext:
+        """Get or build project context."""
+        if self._context and not refresh:
+            return self._context
+        
+        context = ProjectContext(root_path=self.root_path)
+        structure_lines = []
+        
+        for root, dirs, files in os.walk(self.root_path):
+            root_path = Path(root)
+            
+            # Filter out ignored directories
+            dirs[:] = [d for d in dirs if not self._should_ignore(root_path / d)]
+            
+            # Calculate depth for indentation
+            rel_root = root_path.relative_to(self.root_path)
+            depth = len(rel_root.parts)
+            indent = "  " * depth
+            
+            if depth > 0:
+                structure_lines.append(f"{indent[:-2]}📁 {root_path.name}/")
+            
+            for file in sorted(files):
+                file_path = root_path / file
+                
+                if self._should_ignore(file_path):
+                    continue
+                
+                rel_path = str(file_path.relative_to(self.root_path))
+                is_code = self._is_code_file(file_path)
+                
+                try:
+                    size = file_path.stat().st_size
+                except OSError:
+                    size = 0
+                
+                file_info = FileInfo(
+                    path=file_path,
+                    relative_path=rel_path,
+                    extension=file_path.suffix.lower(),
+                    size=size,
+                    is_code=is_code,
+                )
+                
+                context.files.append(file_info)
+                context.total_files += 1
+                
+                if is_code:
+                    context.total_code_files += 1
+                    context.languages.add(file_info.language)
+                
+                icon = "📄" if is_code else "📋"
+                structure_lines.append(f"{indent}{icon} {file}")
+        
+        context.structure = "\n".join(structure_lines)
+        self._context = context
+        return context
+    
+    def read_file(self, path: str) -> Optional[str]:
+        """Read a file's content."""
+        file_path = self._resolve_path(path)
+        
+        if not file_path.exists():
+            return None
+        
+        try:
+            return file_path.read_text(encoding="utf-8")
+        except Exception:
+            return None
+    
+    def write_file(self, path: str, content: str, create_dirs: bool = True) -> bool:
+        """Write content to a file."""
+        file_path = self._resolve_path(path)
+        
+        try:
+            if create_dirs:
+                file_path.parent.mkdir(parents=True, exist_ok=True)
+            
+            file_path.write_text(content, encoding="utf-8")
+            
+            # Invalidate context cache
+            self._context = None
+            return True
+        except Exception:
+            return False
+    
+    def file_exists(self, path: str) -> bool:
+        """Check if a file exists."""
+        return self._resolve_path(path).exists()
+    
+    def delete_file(self, path: str) -> bool:
+        """Delete a file."""
+        file_path = self._resolve_path(path)
+        
+        try:
+            if file_path.exists():
+                file_path.unlink()
+                self._context = None
+                return True
+            return False
+        except Exception:
+            return False
+    
+    def find_files(self, pattern: str) -> List[str]:
+        """Find files matching a glob pattern."""
+        context = self.get_project_context()
+        matches = []
+        
+        for file_info in context.files:
+            if fnmatch.fnmatch(file_info.relative_path, pattern):
+                matches.append(file_info.relative_path)
+            elif fnmatch.fnmatch(file_info.path.name, pattern):
+                matches.append(file_info.relative_path)
+        
+        return matches
+    
+    def get_file_info(self, path: str) -> Optional[FileInfo]:
+        """Get information about a specific file."""
+        file_path = self._resolve_path(path)
+        
+        if not file_path.exists():
+            return None
+        
+        rel_path = str(file_path.relative_to(self.root_path))
+        
+        return FileInfo(
+            path=file_path,
+            relative_path=rel_path,
+            extension=file_path.suffix.lower(),
+            size=file_path.stat().st_size,
+            is_code=self._is_code_file(file_path),
+        )
+    
+    def get_related_files(self, path: str, max_files: int = 5) -> List[str]:
+        """Find files related to the given file (same directory, imports, etc.)."""
+        file_path = self._resolve_path(path)
+        related = []
+        
+        # Same directory files
+        if file_path.parent.exists():
+            for sibling in file_path.parent.iterdir():
+                if sibling.is_file() and sibling != file_path:
+                    if self._is_code_file(sibling) and not self._should_ignore(sibling):
+                        related.append(str(sibling.relative_to(self.root_path)))
+        
+        # TODO: Parse imports and find imported files
+        
+        return related[:max_files]
+    
+    def _resolve_path(self, path: str) -> Path:
+        """Resolve a path relative to root."""
+        p = Path(path)
+        if p.is_absolute():
+            return p
+        return self.root_path / path
+    
+    def get_structure_summary(self, max_depth: int = 3) -> str:
+        """Get a summarized project structure."""
+        lines = [f"📁 {self.root_path.name}/"]
+        
+        def walk_dir(dir_path: Path, depth: int = 1):
+            if depth > max_depth:
+                return
+            
+            try:
+                items = sorted(dir_path.iterdir(), key=lambda x: (x.is_file(), x.name))
+            except PermissionError:
+                return
+            
+            dirs = []
+            files = []
+            
+            for item in items:
+                if self._should_ignore(item):
+                    continue
+                
+                if item.is_dir():
+                    dirs.append(item)
+                elif item.is_file():
+                    files.append(item)
+            
+            indent = "  " * depth
+            
+            for d in dirs[:10]:  # Limit directories shown
+                lines.append(f"{indent}�� {d.name}/")
+                walk_dir(d, depth + 1)
+            
+            if len(dirs) > 10:
+                lines.append(f"{indent}... and {len(dirs) - 10} more directories")
+            
+            for f in files[:10]:  # Limit files shown
+                icon = "📄" if self._is_code_file(f) else "📋"
+                lines.append(f"{indent}{icon} {f.name}")
+            
+            if len(files) > 10:
+                lines.append(f"{indent}... and {len(files) - 10} more files")
+        
+        walk_dir(self.root_path)
+        return "\n".join(lines)

ai_code_assistant/agent/intent_classifier.py

@@ -0,0 +1,284 @@
+"""Intent Classifier for understanding user requests."""
+
+import re
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import List, Optional, Tuple
+
+
+class IntentType(Enum):
+    """Types of user intents."""
+    CODE_GENERATE = "code_generate"      # Create new code
+    CODE_EDIT = "code_edit"              # Modify existing code
+    CODE_REVIEW = "code_review"          # Review code for issues
+    CODE_EXPLAIN = "code_explain"        # Explain how code works
+    CODE_REFACTOR = "code_refactor"      # Refactor/improve code
+    TEST_GENERATE = "test_generate"      # Generate tests
+    FILE_CREATE = "file_create"          # Create a new file
+    FILE_DELETE = "file_delete"          # Delete a file
+    PROJECT_INFO = "project_info"        # Get project information
+    GENERAL_CHAT = "general_chat"        # General conversation
+
+
+@dataclass
+class Intent:
+    """Represents a classified intent."""
+    type: IntentType
+    confidence: float
+    file_paths: List[str] = field(default_factory=list)
+    target_description: str = ""
+    action_description: str = ""
+    language: Optional[str] = None
+    
+    @property
+    def requires_file_context(self) -> bool:
+        """Check if this intent needs file context."""
+        return self.type in {
+            IntentType.CODE_EDIT,
+            IntentType.CODE_REVIEW,
+            IntentType.CODE_EXPLAIN,
+            IntentType.CODE_REFACTOR,
+            IntentType.TEST_GENERATE,
+        }
+    
+    @property
+    def modifies_files(self) -> bool:
+        """Check if this intent will modify files."""
+        return self.type in {
+            IntentType.CODE_GENERATE,
+            IntentType.CODE_EDIT,
+            IntentType.CODE_REFACTOR,
+            IntentType.TEST_GENERATE,
+            IntentType.FILE_CREATE,
+            IntentType.FILE_DELETE,
+        }
+
+
+# Keyword patterns for intent detection
+INTENT_PATTERNS = {
+    IntentType.CODE_GENERATE: [
+        r"\b(create|write|generate|make|build|implement|add)\b.*\b(function|class|method|api|endpoint|component|module|service)\b",
+        r"\b(create|write|generate|make|build)\b.*\b(code|script|program)\b",
+        r"\bnew\b.*\b(function|class|file|component)\b",
+        r"\bimplement\b",
+    ],
+    IntentType.CODE_EDIT: [
+        r"\b(edit|modify|change|update|fix|patch)\b.*\b(code|file|function|class|line)\b",
+        r"\b(add|insert|append)\b.*\b(to|in|into)\b",
+        r"\b(remove|delete)\b.*\b(from|in)\b.*\b(code|file|function)\b",
+        r"\bfix\b.*\b(bug|error|issue|problem)\b",
+        r"\bchange\b.*\bto\b",
+    ],
+    IntentType.CODE_REVIEW: [
+        r"\b(review|check|analyze|audit|inspect)\b",
+        r"\b(find|look for|check for)\b.*\b(issues|bugs|problems|errors|vulnerabilities)\b",
+        r"\b(security|performance)\b.*\b(review|check|audit)\b",
+        r"\bcode\s*review\b",
+        r"\breview\b.*\.(py|js|ts|java|go|rs|rb|cpp|c)\b",
+    ],
+    IntentType.CODE_EXPLAIN: [
+        r"\b(explain|describe)\b",
+        r"\b(what does|how does|what is|how is)\b.*\b(code|function|class|file|this|it|work)\b",
+        r"\bwalk\s*(me\s*)?through\b",
+        r"\bunderstand\b.*\b(code|function|class)\b",
+        r"\bwhat\b.*\b(doing|happening|mean)\b",
+        r"\bexplain\b.*\.(py|js|ts|java|go|rs|rb|cpp|c)\b",
+    ],
+    IntentType.CODE_REFACTOR: [
+        r"\b(refactor|improve|optimize|clean|simplify|restructure)\b",
+        r"\bmake\b.*\b(better|cleaner|faster|more efficient|readable)\b",
+        r"\b(reduce|remove)\b.*\b(duplication|complexity)\b",
+    ],
+    IntentType.TEST_GENERATE: [
+        r"\b(create|write|generate|add)\b.*\b(test|tests|unit test|spec)\b",
+        r"\btest\b.*\b(for|coverage)\b",
+        r"\b(pytest|unittest|jest|mocha)\b",
+    ],
+    IntentType.FILE_CREATE: [
+        r"\b(create|make|new)\b.*\b(file|directory|folder)\b",
+        r"\btouch\b",
+    ],
+    IntentType.FILE_DELETE: [
+        r"\b(delete|remove|rm)\b.*\b(file|directory|folder)\b",
+    ],
+    IntentType.PROJECT_INFO: [
+        r"\b(show|list|what)\b.*\b(files|structure|project)\b",
+        r"\bproject\b.*\b(structure|info|overview)\b",
+        r"\bwhat\s*(files|languages)\b",
+    ],
+}
+
+# File path patterns
+FILE_PATH_PATTERNS = [
+    r'["\']([^"\']+\.[a-zA-Z]{1,10})["\']',  # Quoted paths with extension
+    r'\b(\S+\.(?:py|js|ts|jsx|tsx|java|go|rs|c|cpp|h|rb|php|swift|kt|scala|sql|yaml|yml|json|toml|xml|html|css|md))\b',  # Unquoted paths
+    r'\b(src/\S+)\b',  # src/ paths
+    r'\b(tests?/\S+)\b',  # test/ paths
+    r'\b(lib/\S+)\b',  # lib/ paths
+    r'\b(app/\S+)\b',  # app/ paths
+]
+
+# Language detection patterns
+LANGUAGE_PATTERNS = {
+    "python": [r"\bpython\b", r"\bpy\b", r"\.py\b", r"\bdjango\b", r"\bflask\b", r"\bfastapi\b"],
+    "javascript": [r"\bjavascript\b", r"\bjs\b", r"\.js\b", r"\bnode\b", r"\breact\b", r"\bvue\b"],
+    "typescript": [r"\btypescript\b", r"\bts\b", r"\.ts\b", r"\.tsx\b"],
+    "java": [r"\bjava\b", r"\.java\b", r"\bspring\b"],
+    "go": [r"\bgo\b", r"\bgolang\b", r"\.go\b"],
+    "rust": [r"\brust\b", r"\.rs\b", r"\bcargo\b"],
+    "ruby": [r"\bruby\b", r"\.rb\b", r"\brails\b"],
+    "php": [r"\bphp\b", r"\.php\b", r"\blaravel\b"],
+}
+
+
+class IntentClassifier:
+    """Classifies user messages into intents."""
+    
+    def __init__(self, llm_manager=None):
+        self.llm = llm_manager
+        self._compile_patterns()
+    
+    def _compile_patterns(self):
+        """Compile regex patterns for efficiency."""
+        self._intent_patterns = {
+            intent: [re.compile(p, re.IGNORECASE) for p in patterns]
+            for intent, patterns in INTENT_PATTERNS.items()
+        }
+        self._file_patterns = [re.compile(p) for p in FILE_PATH_PATTERNS]
+        self._language_patterns = {
+            lang: [re.compile(p, re.IGNORECASE) for p in patterns]
+            for lang, patterns in LANGUAGE_PATTERNS.items()
+        }
+    
+    def classify(self, message: str) -> Intent:
+        """Classify a user message into an intent."""
+        # Extract file paths
+        file_paths = self._extract_file_paths(message)
+        
+        # Detect language
+        language = self._detect_language(message)
+        
+        # Score each intent type
+        scores: List[Tuple[IntentType, float]] = []
+        
+        for intent_type, patterns in self._intent_patterns.items():
+            score = 0.0
+            for pattern in patterns:
+                if pattern.search(message):
+                    score += 1.0
+            
+            if score > 0:
+                # Normalize by number of patterns
+                score = score / len(patterns)
+                scores.append((intent_type, score))
+        
+        # Sort by score
+        scores.sort(key=lambda x: x[1], reverse=True)
+        
+        if scores:
+            best_intent, confidence = scores[0]
+        else:
+            best_intent = IntentType.GENERAL_CHAT
+            confidence = 0.5
+        
+        # Boost confidence if file paths found for file-related intents
+        if file_paths and best_intent.value.startswith("code_"):
+            confidence = min(confidence + 0.2, 1.0)
+        
+        return Intent(
+            type=best_intent,
+            confidence=confidence,
+            file_paths=file_paths,
+            target_description=self._extract_target(message, best_intent),
+            action_description=message,
+            language=language,
+        )
+    
+    def classify_with_llm(self, message: str) -> Intent:
+        """Use LLM for more accurate classification."""
+        if not self.llm:
+            return self.classify(message)
+        
+        # First do rule-based classification
+        rule_intent = self.classify(message)
+        
+        # Use LLM to refine
+        prompt = f"""Classify this user request into one of these categories:
+- code_generate: Create new code (function, class, API, etc.)
+- code_edit: Modify existing code
+- code_review: Review code for issues/bugs
+- code_explain: Explain how code works
+- code_refactor: Improve/optimize code
+- test_generate: Create tests
+- file_create: Create new file
+- file_delete: Delete file
+- project_info: Get project information
+- general_chat: General conversation
+
+User request: "{message}"
+
+Respond with ONLY the category name, nothing else."""
+
+        try:
+            response = self.llm.invoke(prompt).strip().lower()
+            
+            # Map response to IntentType
+            intent_map = {
+                "code_generate": IntentType.CODE_GENERATE,
+                "code_edit": IntentType.CODE_EDIT,
+                "code_review": IntentType.CODE_REVIEW,
+                "code_explain": IntentType.CODE_EXPLAIN,
+                "code_refactor": IntentType.CODE_REFACTOR,
+                "test_generate": IntentType.TEST_GENERATE,
+                "file_create": IntentType.FILE_CREATE,
+                "file_delete": IntentType.FILE_DELETE,
+                "project_info": IntentType.PROJECT_INFO,
+                "general_chat": IntentType.GENERAL_CHAT,
+            }
+            
+            if response in intent_map:
+                rule_intent.type = intent_map[response]
+                rule_intent.confidence = 0.9
+        except Exception:
+            pass  # Fall back to rule-based
+        
+        return rule_intent
+    
+    def _extract_file_paths(self, message: str) -> List[str]:
+        """Extract file paths from message."""
+        paths = []
+        
+        for pattern in self._file_patterns:
+            matches = pattern.findall(message)
+            paths.extend(matches)
+        
+        # Deduplicate while preserving order
+        seen = set()
+        unique_paths = []
+        for p in paths:
+            if p not in seen:
+                seen.add(p)
+                unique_paths.append(p)
+        
+        return unique_paths
+    
+    def _detect_language(self, message: str) -> Optional[str]:
+        """Detect programming language from message."""
+        for lang, patterns in self._language_patterns.items():
+            for pattern in patterns:
+                if pattern.search(message):
+                    return lang
+        return None
+    
+    def _extract_target(self, message: str, intent: IntentType) -> str:
+        """Extract the target of the action."""
+        # Simple extraction - could be improved with NLP
+        message_lower = message.lower()
+        
+        # Remove common action words
+        for word in ["create", "write", "generate", "make", "build", "implement",
+                     "edit", "modify", "change", "update", "fix", "review",
+                     "explain", "refactor", "improve", "optimize", "test"]:
+            message_lower = message_lower.replace(word, "")
+        
+        return message_lower.strip()

ai_code_assistant/chat/__init__.py

@@ -0,0 +1,11 @@
+"""Chat module for AI Code Assistant."""
+
+from ai_code_assistant.chat.session import ChatSession, Message
+from ai_code_assistant.chat.agent_session import AgentChatSession, AgentMessage
+
+__all__ = [
+    "ChatSession",
+    "Message",
+    "AgentChatSession",
+    "AgentMessage",
+]