codegraph-cli 2.0.0__py3-none-any.whl

codegraph_cli/performance_analyzer.py

@@ -0,0 +1,223 @@
+"""Performance issue analyzer."""
+
+from __future__ import annotations
+
+import ast
+from typing import Dict, List, Set
+
+from .storage import GraphStore
+
+
+class PerformanceAnalyzer:
+    """Analyze code for performance issues."""
+
+    def __init__(self, store: GraphStore):
+        self.store = store
+
+        # Database-related method names that indicate queries
+        self.query_methods = {
+            "execute", "executemany", "query", "get", "filter",
+            "all", "first", "one", "fetch", "fetchone", "fetchall",
+            "select", "insert", "update", "delete"
+        }
+
+    def analyze_file(self, file_path: str) -> List[Dict]:
+        """Analyze file for performance issues.
+        
+        Args:
+            file_path: Path to file to analyze
+            
+        Returns:
+            List of performance issue dictionaries
+        """
+        issues = []
+
+        nodes = [n for n in self.store.get_nodes() if n["file_path"] == file_path]
+        # Skip module-level node when function/class nodes exist to avoid dupes
+        has_children = any(n["node_type"] != "module" for n in nodes)
+        if has_children:
+            nodes = [n for n in nodes if n["node_type"] != "module"]
+
+        seen: set = set()  # (line, type) dedup
+
+        for node in nodes:
+            try:
+                tree = ast.parse(node["code"])
+            except SyntaxError:
+                continue
+
+            for issue in (
+                self._detect_n_plus_one(tree, node)
+                + self._detect_inefficient_algorithms(tree, node)
+                + self._detect_memory_issues(tree, node)
+            ):
+                key = (issue["line"], issue["type"])
+                if key not in seen:
+                    seen.add(key)
+                    issues.append(issue)
+
+        return issues
+
+    def _detect_n_plus_one(self, tree: ast.AST, node: Dict) -> List[Dict]:
+        """Detect N+1 query patterns."""
+        issues = []
+
+        for ast_node in ast.walk(tree):
+            # Look for loops with database queries inside
+            if isinstance(ast_node, (ast.For, ast.While)):
+                # Check for query calls inside the loop
+                for inner_node in ast.walk(ast_node):
+                    if isinstance(inner_node, ast.Call):
+                        # Check for query-like method names
+                        if isinstance(inner_node.func, ast.Attribute):
+                            if inner_node.func.attr in self.query_methods:
+                                issues.append({
+                                    "type": "n_plus_one_query",
+                                    "severity": "high",
+                                    "line": node["start_line"] + inner_node.lineno - 1,
+                                    "message": "Potential N+1 query pattern: database query inside loop",
+                                    "suggestion": "Use bulk queries, eager loading, or prefetch_related()",
+                                    "code_snippet": ast.unparse(inner_node)[:100]
+                                })
+                                break  # Only report once per loop
+
+        return issues
+
+    def _detect_inefficient_algorithms(self, tree: ast.AST, node: Dict) -> List[Dict]:
+        """Detect inefficient algorithm patterns."""
+        issues = []
+
+        # Track nested loops for O(n²) detection
+        loop_depth = {}
+        
+        for ast_node in ast.walk(tree):
+            if isinstance(ast_node, (ast.For, ast.While)):
+                # Check for nested loops
+                nested_loops = []
+                for inner in ast.walk(ast_node):
+                    if inner != ast_node and isinstance(inner, (ast.For, ast.While)):
+                        nested_loops.append(inner)
+                
+                if nested_loops:
+                    # Report the innermost nested loop
+                    innermost = nested_loops[0]
+                    issues.append({
+                        "type": "nested_loop",
+                        "severity": "medium",
+                        "line": node["start_line"] + innermost.lineno - 1,
+                        "message": "Nested loop detected (O(n²) complexity)",
+                        "suggestion": "Consider using hash maps, sets, or optimizing algorithm",
+                        "code_snippet": f"for ... in ...: for ... in ..."
+                    })
+
+            # Detect list operations in loops (inefficient)
+            if isinstance(ast_node, ast.For):
+                for inner in ast.walk(ast_node):
+                    # Check for list.append in loop with large iterations
+                    if isinstance(inner, ast.Call):
+                        if isinstance(inner.func, ast.Attribute):
+                            # Detect repeated string concatenation
+                            if inner.func.attr == "append":
+                                # Check if it's appending to a list that's later joined
+                                # This is actually efficient, so skip
+                                pass
+                            
+                            # Detect list.insert(0, ...) which is O(n)
+                            elif inner.func.attr == "insert":
+                                if inner.args and isinstance(inner.args[0], ast.Constant):
+                                    if inner.args[0].value == 0:
+                                        issues.append({
+                                            "type": "inefficient_operation",
+                                            "severity": "medium",
+                                            "line": node["start_line"] + inner.lineno - 1,
+                                            "message": "list.insert(0, ...) in loop is O(n²)",
+                                            "suggestion": "Use collections.deque or append and reverse",
+                                            "code_snippet": ast.unparse(inner)[:100]
+                                        })
+
+        # Detect string concatenation in loops
+        for ast_node in ast.walk(tree):
+            if isinstance(ast_node, (ast.For, ast.While)):
+                for inner in ast.walk(ast_node):
+                    # Look for += on strings
+                    if isinstance(inner, ast.AugAssign):
+                        if isinstance(inner.op, ast.Add):
+                            # Check if target is likely a string
+                            if isinstance(inner.target, ast.Name):
+                                issues.append({
+                                    "type": "string_concatenation_loop",
+                                    "severity": "low",
+                                    "line": node["start_line"] + inner.lineno - 1,
+                                    "message": "String concatenation in loop (inefficient)",
+                                    "suggestion": "Use list.append() and ''.join() instead",
+                                    "code_snippet": ast.unparse(inner)[:100]
+                                })
+
+        return issues
+
+    def _detect_memory_issues(self, tree: ast.AST, node: Dict) -> List[Dict]:
+        """Detect memory inefficiencies."""
+        issues = []
+        seen_lines: set = set()
+
+        for ast_node in ast.walk(tree):
+            report_line = node["start_line"] + ast_node.lineno - 1 if hasattr(ast_node, 'lineno') else None
+
+            # Detect large list comprehensions that could be generators
+            if isinstance(ast_node, ast.ListComp):
+                if report_line and report_line not in seen_lines:
+                    seen_lines.add(report_line)
+                    issues.append({
+                        "type": "memory_inefficiency",
+                        "severity": "low",
+                        "line": report_line,
+                        "message": "List comprehension could be a generator expression",
+                        "suggestion": "Use (...) instead of [...] if you only iterate once",
+                        "code_snippet": ast.unparse(ast_node)[:100]
+                    })
+
+            # Detect reading entire file into memory
+            if isinstance(ast_node, ast.Call):
+                if isinstance(ast_node.func, ast.Attribute):
+                    # file.read() without size limit
+                    if ast_node.func.attr == "read" and not ast_node.args:
+                        issues.append({
+                            "type": "memory_inefficiency",
+                            "severity": "medium",
+                            "line": node["start_line"] + ast_node.lineno - 1,
+                            "message": "Reading entire file into memory",
+                            "suggestion": "Read in chunks or iterate line by line",
+                            "code_snippet": ast.unparse(ast_node)[:100]
+                        })
+                    
+                    # .readlines() also loads entire file
+                    elif ast_node.func.attr == "readlines":
+                        issues.append({
+                            "type": "memory_inefficiency",
+                            "severity": "medium",
+                            "line": node["start_line"] + ast_node.lineno - 1,
+                            "message": "readlines() loads entire file into memory",
+                            "suggestion": "Iterate over file object directly: for line in file:",
+                            "code_snippet": ast.unparse(ast_node)[:100]
+                        })
+
+        return issues
+
+    def analyze_project(self) -> Dict[str, List[Dict]]:
+        """Analyze entire project for performance issues.
+        
+        Returns:
+            Dictionary mapping file paths to lists of performance issues
+        """
+        results = {}
+
+        # Get all unique file paths
+        all_nodes = self.store.get_nodes()
+        file_paths = set(node["file_path"] for node in all_nodes)
+
+        for file_path in file_paths:
+            issues = self.analyze_file(file_path)
+            if issues:
+                results[file_path] = issues
+
+        return results

codegraph_cli/project_context.py

@@ -0,0 +1,230 @@
+"""Project context manager with real file system access."""
+
+from __future__ import annotations
+
+from datetime import datetime
+from pathlib import Path
+from typing import Dict, List, Optional
+
+from .storage import GraphStore, ProjectManager
+
+
+class ProjectContext:
+    """Unified context for project with real file access and code graph."""
+    
+    def __init__(self, project_name: str, project_manager: ProjectManager):
+        """Initialize project context.
+        
+        Args:
+            project_name: Name of the project
+            project_manager: ProjectManager instance
+        """
+        self.project_name = project_name
+        self.project_manager = project_manager
+        self.project_dir = project_manager.project_dir(project_name)
+        self.store = GraphStore(self.project_dir)
+        self.metadata = self.store.get_metadata()
+        
+        # Get source path from metadata
+        source_path_str = self.metadata.get("source_path")
+        if source_path_str:
+            self.source_path = Path(source_path_str)
+            if not self.source_path.exists():
+                # Source path moved or deleted
+                self.source_path = None
+        else:
+            # Old project without source_path
+            self.source_path = None
+    
+    @property
+    def has_source_access(self) -> bool:
+        """Check if we have access to the original source directory."""
+        return self.source_path is not None and self.source_path.exists()
+    
+    # File System Operations
+    
+    def list_directory(self, rel_path: str = ".") -> List[Dict]:
+        """List files and directories in project.
+        
+        Args:
+            rel_path: Relative path from project root
+            
+        Returns:
+            List of file/directory info dicts
+            
+        Raises:
+            RuntimeError: If source path not available
+        """
+        if not self.has_source_access:
+            raise RuntimeError(
+                f"Source path not available for project '{self.project_name}'. "
+                "Re-index the project to enable file access."
+            )
+        
+        full_path = self.source_path / rel_path
+        if not full_path.exists():
+            return []
+        
+        if not full_path.is_dir():
+            raise ValueError(f"Path is not a directory: {rel_path}")
+        
+        items = []
+        for item in sorted(full_path.iterdir()):
+            try:
+                stat = item.stat()
+                items.append({
+                    "name": item.name,
+                    "type": "dir" if item.is_dir() else "file",
+                    "size": stat.st_size if item.is_file() else None,
+                    "path": str(item.relative_to(self.source_path)),
+                    "modified": datetime.fromtimestamp(stat.st_mtime).isoformat()
+                })
+            except (OSError, PermissionError):
+                # Skip files we can't access
+                continue
+        
+        return items
+    
+    def read_file(self, rel_path: str) -> str:
+        """Read file contents from project.
+        
+        Args:
+            rel_path: Relative path to file
+            
+        Returns:
+            File contents as string
+            
+        Raises:
+            RuntimeError: If source path not available
+            FileNotFoundError: If file doesn't exist
+        """
+        if not self.has_source_access:
+            raise RuntimeError(
+                f"Source path not available for project '{self.project_name}'. "
+                "Re-index the project to enable file access."
+            )
+        
+        full_path = self.source_path / rel_path
+        if not full_path.exists():
+            raise FileNotFoundError(f"File not found: {rel_path}")
+        
+        if not full_path.is_file():
+            raise ValueError(f"Path is not a file: {rel_path}")
+        
+        try:
+            return full_path.read_text(encoding="utf-8")
+        except UnicodeDecodeError:
+            # Try reading as binary for non-text files
+            return f"[Binary file: {full_path.suffix}]"
+    
+    def write_file(self, rel_path: str, content: str, create_dirs: bool = True) -> bool:
+        """Write or create a file in the project.
+        
+        Args:
+            rel_path: Relative path to file
+            content: File content
+            create_dirs: Whether to create parent directories
+            
+        Returns:
+            True if successful
+            
+        Raises:
+            RuntimeError: If source path not available
+        """
+        if not self.has_source_access:
+            raise RuntimeError(
+                f"Source path not available for project '{self.project_name}'. "
+                "Re-index the project to enable file access."
+            )
+        
+        full_path = self.source_path / rel_path
+        
+        if create_dirs:
+            full_path.parent.mkdir(parents=True, exist_ok=True)
+        
+        full_path.write_text(content, encoding="utf-8")
+        return True
+    
+    def file_exists(self, rel_path: str) -> bool:
+        """Check if a file exists in the project.
+        
+        Args:
+            rel_path: Relative path to file
+            
+        Returns:
+            True if file exists
+        """
+        if not self.has_source_access:
+            return False
+        
+        return (self.source_path / rel_path).exists()
+    
+    def get_file_info(self, rel_path: str) -> Optional[Dict]:
+        """Get information about a file.
+        
+        Args:
+            rel_path: Relative path to file
+            
+        Returns:
+            File info dict or None if not found
+        """
+        if not self.has_source_access:
+            return None
+        
+        full_path = self.source_path / rel_path
+        if not full_path.exists():
+            return None
+        
+        try:
+            stat = full_path.stat()
+            return {
+                "name": full_path.name,
+                "path": rel_path,
+                "type": "dir" if full_path.is_dir() else "file",
+                "size": stat.st_size if full_path.is_file() else None,
+                "modified": datetime.fromtimestamp(stat.st_mtime).isoformat(),
+                "created": datetime.fromtimestamp(stat.st_ctime).isoformat()
+            }
+        except (OSError, PermissionError):
+            return None
+    
+    # Code Graph Operations
+    
+    def get_indexed_files(self) -> List[str]:
+        """Get list of indexed Python files.
+        
+        Returns:
+            List of file paths that were indexed
+        """
+        nodes = self.store.get_nodes()
+        return sorted(set(node["file_path"] for node in nodes))
+    
+    def get_project_summary(self) -> Dict:
+        """Get summary of project.
+        
+        Returns:
+            Dictionary with project statistics
+        """
+        nodes = self.store.get_nodes()
+        edges = self.store.get_edges()
+        
+        # Count by type
+        node_types = {}
+        for node in nodes:
+            node_type = node["node_type"]
+            node_types[node_type] = node_types.get(node_type, 0) + 1
+        
+        return {
+            "project_name": self.project_name,
+            "source_path": str(self.source_path) if self.source_path else None,
+            "has_source_access": self.has_source_access,
+            "indexed_at": self.metadata.get("indexed_at"),
+            "total_nodes": len(nodes),
+            "total_edges": len(edges),
+            "node_types": node_types,
+            "indexed_files": len(self.get_indexed_files())
+        }
+    
+    def close(self):
+        """Close the graph store connection."""
+        self.store.close()

codegraph_cli/rag.py

@@ -0,0 +1,200 @@
+"""Retrieval-Augmented components for semantic code search.
+
+Uses LanceDB hybrid search (vector + metadata filters) for fast,
+accurate code retrieval.  Falls back to brute-force cosine similarity
+when the vector store is unavailable.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+from typing import Any, Dict, List, Optional, Union
+
+from .embeddings import HashEmbeddingModel, NeuralEmbedder, cosine_similarity
+from .models import SearchResult
+from .storage import GraphStore
+
+logger = logging.getLogger(__name__)
+
+
+class RAGRetriever:
+    """Retrieve relevant code nodes from graph memory via semantic similarity.
+
+    Supports two modes:
+
+    1. **Vector store mode** (fast, preferred) – delegates to LanceDB via
+       ``GraphStore.vector_store``.
+    2. **Brute-force mode** (fallback) – scans all SQLite rows and computes
+       cosine similarity in Python.
+
+    The ``embedding_model`` argument accepts either a
+    :class:`~codegraph_cli.embeddings.NeuralEmbedder` or the legacy
+    :class:`~codegraph_cli.embeddings.HashEmbeddingModel`.
+    """
+
+    def __init__(
+        self,
+        store: GraphStore,
+        embedding_model: Union[NeuralEmbedder, HashEmbeddingModel, Any],
+    ) -> None:
+        self.store = store
+        self.embedding_model = embedding_model
+        self.use_vector_store: bool = store.vector_store is not None
+
+    # ------------------------------------------------------------------
+    # Primary search
+    # ------------------------------------------------------------------
+
+    def search(
+        self,
+        query: str,
+        top_k: int = 5,
+        node_type: Optional[str] = None,
+        file_filter: Optional[str] = None,
+    ) -> List[SearchResult]:
+        """Semantic search for code nodes.
+
+        Args:
+            query:       Natural-language or code query.
+            top_k:       Number of results.
+            node_type:   Optional filter (``function``, ``class``, ``module``).
+            file_filter: Optional file-path SQL pattern,
+                         e.g. ``"src/%"`` to restrict to files under *src/*.
+
+        Returns:
+            List of :class:`SearchResult` sorted by relevance (highest first).
+        """
+        query_emb: List[float] = self.embedding_model.embed_text(query)
+
+        if self.use_vector_store:
+            return self._search_vector_store(
+                query_emb, top_k, node_type, file_filter,
+            )
+        return self._search_brute_force(query_emb, top_k, node_type)
+
+    # ------------------------------------------------------------------
+    # LanceDB path (fast)
+    # ------------------------------------------------------------------
+
+    def _search_vector_store(
+        self,
+        query_emb: List[float],
+        top_k: int,
+        node_type: Optional[str],
+        file_filter: Optional[str],
+    ) -> List[SearchResult]:
+        assert self.store.vector_store is not None
+
+        # Build SQL WHERE clause for hybrid search
+        clauses: List[str] = []
+        if node_type:
+            clauses.append(f'node_type = "{node_type}"')
+        if file_filter:
+            clauses.append(f'file_path LIKE "{file_filter}"')
+        where_sql = " AND ".join(clauses) if clauses else None
+
+        raw_results = self.store.vector_store.hybrid_search(
+            query_embedding=query_emb,
+            n_results=top_k,
+            where_sql=where_sql,
+        )
+
+        results: List[SearchResult] = []
+        for row in raw_results:
+            distance = row.get("_distance", 0.0)
+            # LanceDB returns L2 distance by default; convert to a similarity
+            # score in [0, 1].  For cosine distance the relationship is
+            # score = 1 - distance  (since embeddings are unit-normalised).
+            score = max(0.0, 1.0 - distance)
+
+            # Enrich from SQLite if full node data is needed
+            node_row = self.store.get_node(row.get("id", ""))
+
+            if node_row is not None:
+                results.append(SearchResult(
+                    node_id=node_row["node_id"],
+                    score=score,
+                    node_type=node_row["node_type"],
+                    qualname=node_row["qualname"],
+                    file_path=node_row["file_path"],
+                    start_line=node_row["start_line"],
+                    end_line=node_row["end_line"],
+                    snippet=node_row["code"],
+                ))
+            else:
+                # Use data straight from LanceDB
+                results.append(SearchResult(
+                    node_id=row.get("id", ""),
+                    score=score,
+                    node_type=row.get("node_type", ""),
+                    qualname=row.get("qualname", ""),
+                    file_path=row.get("file_path", ""),
+                    start_line=0,
+                    end_line=0,
+                    snippet=row.get("document", ""),
+                ))
+
+        return results
+
+    # ------------------------------------------------------------------
+    # Brute-force fallback
+    # ------------------------------------------------------------------
+
+    def _search_brute_force(
+        self,
+        query_emb: List[float],
+        top_k: int,
+        node_type: Optional[str],
+    ) -> List[SearchResult]:
+        results: List[SearchResult] = []
+        for row in self.store.get_nodes():
+            if node_type and row["node_type"] != node_type:
+                continue
+            embedding = json.loads(row["embedding"] or "[]")
+            score = cosine_similarity(query_emb, embedding)
+            if score <= 0:
+                continue
+            results.append(SearchResult(
+                node_id=row["node_id"],
+                score=score,
+                node_type=row["node_type"],
+                qualname=row["qualname"],
+                file_path=row["file_path"],
+                start_line=row["start_line"],
+                end_line=row["end_line"],
+                snippet=row["code"],
+            ))
+
+        return sorted(results, key=lambda r: r.score, reverse=True)[:top_k]
+
+    # ------------------------------------------------------------------
+    # Convenience
+    # ------------------------------------------------------------------
+
+    def retrieve_context(
+        self,
+        query: str,
+        top_k: int = 5,
+        node_type: Optional[str] = None,
+        file_filter: Optional[str] = None,
+    ) -> str:
+        """Return a formatted string of the top search results.
+
+        Useful for injecting relevant code context into LLM prompts.
+        """
+        matches = self.search(
+            query, top_k=top_k, node_type=node_type, file_filter=file_filter,
+        )
+        if not matches:
+            return "No relevant nodes found."
+
+        blocks: List[str] = []
+        for item in matches:
+            blocks.append(
+                f"[{item.node_type}] {item.qualname} "
+                f"({item.file_path}:{item.start_line})\n"
+                f"Score: {item.score:.3f}\n"
+                f"```python\n{item.snippet[:1200]}\n```"
+            )
+        return "\n\n".join(blocks)