roma-debug 0.1.0__py3-none-any.whl

roma_debug/tracing/dependency_graph.py

@@ -0,0 +1,298 @@
+"""Dependency graph builder for project analysis.
+
+Builds a graph of module dependencies for understanding code relationships.
+"""
+
+from collections import defaultdict
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Optional, List, Dict, Set
+
+from roma_debug.core.models import Language, Import, FileContext
+
+
+@dataclass
+class DependencyNode:
+    """A node in the dependency graph representing a file/module."""
+    filepath: str
+    language: Language
+    imports: List[Import] = field(default_factory=list)
+    imported_by: List[str] = field(default_factory=list)  # Files that import this one
+    symbols: List[str] = field(default_factory=list)  # Exported symbols
+
+    @property
+    def filename(self) -> str:
+        return Path(self.filepath).name
+
+    @property
+    def module_name(self) -> str:
+        """Derive module name from filepath."""
+        path = Path(self.filepath)
+        # Remove extension and convert to module format
+        stem = path.stem
+        if stem == '__init__':
+            return path.parent.name
+        return stem
+
+
+class DependencyGraph:
+    """Graph of module dependencies in a project.
+
+    Tracks which files import which other files, allowing us to:
+    - Find all files that depend on a given file
+    - Find all dependencies of a file
+    - Identify potential root cause locations
+    """
+
+    def __init__(self, project_root: Optional[str] = None):
+        """Initialize the dependency graph.
+
+        Args:
+            project_root: Root directory of the project
+        """
+        self.project_root = Path(project_root) if project_root else Path.cwd()
+        self._nodes: Dict[str, DependencyNode] = {}
+        self._edges: Dict[str, Set[str]] = defaultdict(set)  # from -> to
+        self._reverse_edges: Dict[str, Set[str]] = defaultdict(set)  # to -> from
+
+    def add_file(self, filepath: str, language: Language, imports: List[Import]):
+        """Add a file to the dependency graph.
+
+        Args:
+            filepath: Path to the file
+            language: Language of the file
+            imports: List of imports from the file
+        """
+        filepath = str(Path(filepath).resolve())
+
+        if filepath not in self._nodes:
+            self._nodes[filepath] = DependencyNode(
+                filepath=filepath,
+                language=language,
+            )
+
+        node = self._nodes[filepath]
+        node.imports = imports
+
+        # Add edges for resolved imports
+        for imp in imports:
+            if imp.resolved_path:
+                resolved = str(Path(imp.resolved_path).resolve())
+                self._edges[filepath].add(resolved)
+                self._reverse_edges[resolved].add(filepath)
+
+                # Ensure the target node exists
+                if resolved not in self._nodes:
+                    # Infer language from extension
+                    target_lang = Language.from_extension(Path(resolved).suffix)
+                    self._nodes[resolved] = DependencyNode(
+                        filepath=resolved,
+                        language=target_lang,
+                    )
+
+                # Update imported_by
+                self._nodes[resolved].imported_by.append(filepath)
+
+    def add_file_context(self, context: FileContext):
+        """Add a FileContext to the graph.
+
+        Args:
+            context: FileContext object with imports
+        """
+        self.add_file(context.filepath, context.language, context.imports)
+
+    def get_dependencies(self, filepath: str) -> List[str]:
+        """Get all files that the given file imports.
+
+        Args:
+            filepath: Path to the file
+
+        Returns:
+            List of file paths that are imported
+        """
+        filepath = str(Path(filepath).resolve())
+        return list(self._edges.get(filepath, set()))
+
+    def get_dependents(self, filepath: str) -> List[str]:
+        """Get all files that import the given file.
+
+        Args:
+            filepath: Path to the file
+
+        Returns:
+            List of file paths that import this file
+        """
+        filepath = str(Path(filepath).resolve())
+        return list(self._reverse_edges.get(filepath, set()))
+
+    def get_transitive_dependencies(self, filepath: str, max_depth: int = 10) -> List[str]:
+        """Get all transitive dependencies of a file.
+
+        Args:
+            filepath: Path to the file
+            max_depth: Maximum recursion depth
+
+        Returns:
+            List of all files that the given file depends on (directly or indirectly)
+        """
+        filepath = str(Path(filepath).resolve())
+        visited = set()
+        result = []
+
+        def visit(path: str, depth: int):
+            if depth > max_depth or path in visited:
+                return
+            visited.add(path)
+
+            for dep in self._edges.get(path, set()):
+                if dep not in visited:
+                    result.append(dep)
+                    visit(dep, depth + 1)
+
+        visit(filepath, 0)
+        return result
+
+    def get_transitive_dependents(self, filepath: str, max_depth: int = 10) -> List[str]:
+        """Get all files that transitively depend on the given file.
+
+        Args:
+            filepath: Path to the file
+            max_depth: Maximum recursion depth
+
+        Returns:
+            List of all files that depend on this file (directly or indirectly)
+        """
+        filepath = str(Path(filepath).resolve())
+        visited = set()
+        result = []
+
+        def visit(path: str, depth: int):
+            if depth > max_depth or path in visited:
+                return
+            visited.add(path)
+
+            for dep in self._reverse_edges.get(path, set()):
+                if dep not in visited:
+                    result.append(dep)
+                    visit(dep, depth + 1)
+
+        visit(filepath, 0)
+        return result
+
+    def get_path_between(self, source: str, target: str) -> Optional[List[str]]:
+        """Find the import path between two files.
+
+        Args:
+            source: Starting file
+            target: Target file
+
+        Returns:
+            List of files forming the path, or None if no path exists
+        """
+        source = str(Path(source).resolve())
+        target = str(Path(target).resolve())
+
+        if source == target:
+            return [source]
+
+        # BFS to find shortest path
+        visited = {source}
+        queue = [(source, [source])]
+
+        while queue:
+            current, path = queue.pop(0)
+
+            for neighbor in self._edges.get(current, set()):
+                if neighbor == target:
+                    return path + [neighbor]
+
+                if neighbor not in visited:
+                    visited.add(neighbor)
+                    queue.append((neighbor, path + [neighbor]))
+
+        return None
+
+    def find_common_dependencies(self, files: List[str]) -> List[str]:
+        """Find files that are imported by all given files.
+
+        Args:
+            files: List of file paths
+
+        Returns:
+            List of files that are common dependencies
+        """
+        if not files:
+            return []
+
+        # Get dependencies of first file
+        common = set(self.get_transitive_dependencies(files[0]))
+
+        # Intersect with dependencies of other files
+        for filepath in files[1:]:
+            deps = set(self.get_transitive_dependencies(filepath))
+            common &= deps
+
+        return list(common)
+
+    def get_node(self, filepath: str) -> Optional[DependencyNode]:
+        """Get the node for a file.
+
+        Args:
+            filepath: Path to the file
+
+        Returns:
+            DependencyNode or None
+        """
+        filepath = str(Path(filepath).resolve())
+        return self._nodes.get(filepath)
+
+    def get_all_files(self) -> List[str]:
+        """Get all files in the graph.
+
+        Returns:
+            List of all file paths
+        """
+        return list(self._nodes.keys())
+
+    def get_summary(self) -> str:
+        """Get a text summary of the dependency graph.
+
+        Returns:
+            Human-readable summary string
+        """
+        lines = [
+            f"Dependency Graph Summary:",
+            f"  Files: {len(self._nodes)}",
+            f"  Direct Dependencies: {sum(len(deps) for deps in self._edges.values())}",
+        ]
+
+        # Top imported files
+        import_counts = [(f, len(deps)) for f, deps in self._reverse_edges.items()]
+        import_counts.sort(key=lambda x: x[1], reverse=True)
+
+        if import_counts:
+            lines.append("\n  Most Imported Files:")
+            for filepath, count in import_counts[:5]:
+                lines.append(f"    {Path(filepath).name}: imported by {count} files")
+
+        return "\n".join(lines)
+
+    def to_dict(self) -> dict:
+        """Serialize the graph to a dictionary.
+
+        Returns:
+            Dictionary representation of the graph
+        """
+        return {
+            "project_root": str(self.project_root),
+            "nodes": {
+                path: {
+                    "filepath": node.filepath,
+                    "language": node.language.value,
+                    "imports": [imp.module_name for imp in node.imports],
+                    "imported_by": node.imported_by,
+                }
+                for path, node in self._nodes.items()
+            },
+            "edges": {k: list(v) for k, v in self._edges.items()},
+        }

roma_debug/tracing/error_analyzer.py

@@ -0,0 +1,399 @@
+"""Error analyzer for understanding errors without explicit tracebacks.
+
+Analyzes error messages to:
+- Identify error type and category
+- Find relevant files in the project
+- Provide targeted context for AI fixing
+"""
+
+import re
+from dataclasses import dataclass, field
+from typing import Optional, List, Dict, Tuple
+
+from roma_debug.core.models import Language, FileContext
+from roma_debug.tracing.project_scanner import ProjectScanner, ProjectInfo, ProjectFile
+
+
+@dataclass
+class ErrorAnalysis:
+    """Result of analyzing an error message."""
+    error_type: str  # 'http', 'runtime', 'syntax', 'import', 'config', 'unknown'
+    error_category: str  # More specific: '404', 'type_error', 'module_not_found', etc.
+    error_message: str
+    suggested_language: Optional[Language] = None
+    relevant_files: List[ProjectFile] = field(default_factory=list)
+    affected_routes: List[str] = field(default_factory=list)
+    keywords: List[str] = field(default_factory=list)
+    confidence: float = 0.0  # 0-1 confidence in analysis
+
+    def to_context_string(self) -> str:
+        """Format analysis as context string for AI."""
+        lines = [
+            "## ERROR ANALYSIS",
+            f"Type: {self.error_type}",
+            f"Category: {self.error_category}",
+            f"Message: {self.error_message}",
+        ]
+
+        if self.suggested_language:
+            lines.append(f"Language: {self.suggested_language.value}")
+
+        if self.affected_routes:
+            lines.append(f"Affected Routes: {', '.join(self.affected_routes)}")
+
+        if self.relevant_files:
+            lines.append("\n### Relevant Files:")
+            for f in self.relevant_files:
+                lines.append(f"- {f.path}")
+
+        return "\n".join(lines)
+
+
+# Error pattern matchers
+ERROR_PATTERNS = {
+    # HTTP/Web errors
+    'http_404': [
+        (r'cannot\s+(?:get|post|put|delete|patch)\s+[/\w]+', 0.9),
+        (r'404\s+(?:not\s+found|\(not\s+found\))', 0.95),
+        (r'get\s+http://.*\s+404', 0.95),
+        (r'route\s+not\s+found', 0.9),
+        (r'no\s+route\s+matches', 0.9),
+    ],
+    'http_500': [
+        (r'500\s+internal\s+server\s+error', 0.95),
+        (r'internal\s+server\s+error', 0.8),
+    ],
+    'http_400': [
+        (r'400\s+bad\s+request', 0.95),
+        (r'bad\s+request', 0.7),
+    ],
+    'http_401': [
+        (r'401\s+unauthorized', 0.95),
+        (r'authentication\s+required', 0.85),
+        (r'not\s+authenticated', 0.8),
+    ],
+    'http_403': [
+        (r'403\s+forbidden', 0.95),
+        (r'permission\s+denied', 0.8),
+        (r'access\s+denied', 0.8),
+    ],
+    'static_file': [
+        (r'cannot\s+(?:get|find|serve)\s+.*\.(?:html|css|js|png|jpg|svg)', 0.9),
+        (r'static\s+file\s+not\s+found', 0.9),
+        (r'failed\s+to\s+load\s+resource', 0.85),
+        (r'enoent.*index\.html', 0.95),
+        (r'enoent.*public', 0.9),
+        (r'enoent.*static', 0.9),
+        (r'no\s+such\s+file.*\.html', 0.95),
+        (r'no\s+such\s+file.*public', 0.9),
+    ],
+    'file_not_found': [
+        (r'enoent', 0.9),
+        (r'no\s+such\s+file\s+or\s+directory', 0.95),
+        (r'file\s+not\s+found', 0.9),
+        (r'cannot\s+find\s+(?:file|path)', 0.85),
+    ],
+
+    # Python errors
+    'python_import': [
+        (r'modulenotfounderror', 0.95),
+        (r'importerror', 0.9),
+        (r'no\s+module\s+named', 0.95),
+        (r'cannot\s+import\s+name', 0.9),
+    ],
+    'python_attribute': [
+        (r'attributeerror', 0.95),
+        (r'has\s+no\s+attribute', 0.9),
+    ],
+    'python_type': [
+        (r'typeerror', 0.95),
+        (r'expected\s+\w+\s+got\s+\w+', 0.8),
+    ],
+    'python_value': [
+        (r'valueerror', 0.95),
+        (r'invalid\s+value', 0.7),
+    ],
+    'python_key': [
+        (r'keyerror', 0.95),
+    ],
+    'python_index': [
+        (r'indexerror', 0.95),
+        (r'list\s+index\s+out\s+of\s+range', 0.95),
+    ],
+    'python_name': [
+        (r'nameerror', 0.95),
+        (r'name\s+[\'"]?\w+[\'"]?\s+is\s+not\s+defined', 0.9),
+    ],
+    'python_syntax': [
+        (r'syntaxerror', 0.95),
+        (r'invalid\s+syntax', 0.9),
+    ],
+
+    # JavaScript/Node errors
+    'js_reference': [
+        (r'referenceerror', 0.95),
+        (r'is\s+not\s+defined', 0.8),
+    ],
+    'js_type': [
+        (r'typeerror.*undefined', 0.9),
+        (r'cannot\s+read\s+propert', 0.9),
+        (r'is\s+not\s+a\s+function', 0.9),
+    ],
+    'js_syntax': [
+        (r'syntaxerror.*javascript', 0.9),
+        (r'unexpected\s+token', 0.85),
+    ],
+    'js_module': [
+        (r'cannot\s+find\s+module', 0.95),
+        (r'module\s+not\s+found', 0.9),
+    ],
+
+    # Go errors
+    'go_panic': [
+        (r'panic:', 0.95),
+        (r'runtime\s+error:', 0.9),
+    ],
+    'go_nil': [
+        (r'nil\s+pointer', 0.95),
+        (r'invalid\s+memory\s+address', 0.9),
+    ],
+
+    # Rust errors
+    'rust_panic': [
+        (r'thread\s+.*\s+panicked', 0.95),
+        (r'called\s+`option::unwrap\(\)`', 0.9),
+    ],
+
+    # Database errors
+    'database': [
+        (r'database\s+error', 0.85),
+        (r'sql\s+error', 0.9),
+        (r'connection\s+refused.*(?:5432|3306|27017)', 0.9),  # Common DB ports
+        (r'operationalerror.*database', 0.9),
+    ],
+
+    # Config/Environment errors
+    'config': [
+        (r'api\s*key\s+(?:not\s+(?:set|found|valid)|invalid)', 0.9),
+        (r'missing\s+(?:env|environment)\s+variable', 0.9),
+        (r'configuration\s+error', 0.85),
+        (r'\.env\s+(?:not\s+found|missing)', 0.9),
+    ],
+
+    # Connection errors
+    'connection': [
+        (r'connection\s+refused', 0.9),
+        (r'econnrefused', 0.95),
+        (r'connection\s+timed?\s*out', 0.9),
+        (r'network\s+error', 0.8),
+    ],
+}
+
+# Map error categories to error types
+CATEGORY_TO_TYPE = {
+    'http_404': 'http',
+    'http_500': 'http',
+    'http_400': 'http',
+    'http_401': 'http',
+    'http_403': 'http',
+    'static_file': 'static',
+    'file_not_found': 'filesystem',
+    'python_import': 'import',
+    'python_attribute': 'runtime',
+    'python_type': 'runtime',
+    'python_value': 'runtime',
+    'python_key': 'runtime',
+    'python_index': 'runtime',
+    'python_name': 'runtime',
+    'python_syntax': 'syntax',
+    'js_reference': 'runtime',
+    'js_type': 'runtime',
+    'js_syntax': 'syntax',
+    'js_module': 'import',
+    'go_panic': 'runtime',
+    'go_nil': 'runtime',
+    'rust_panic': 'runtime',
+    'database': 'database',
+    'config': 'config',
+    'connection': 'connection',
+}
+
+# Language hints from error patterns
+CATEGORY_TO_LANGUAGE = {
+    'python_import': Language.PYTHON,
+    'python_attribute': Language.PYTHON,
+    'python_type': Language.PYTHON,
+    'python_value': Language.PYTHON,
+    'python_key': Language.PYTHON,
+    'python_index': Language.PYTHON,
+    'python_name': Language.PYTHON,
+    'python_syntax': Language.PYTHON,
+    'js_reference': Language.JAVASCRIPT,
+    'js_type': Language.JAVASCRIPT,
+    'js_syntax': Language.JAVASCRIPT,
+    'js_module': Language.JAVASCRIPT,
+    'go_panic': Language.GO,
+    'go_nil': Language.GO,
+    'rust_panic': Language.RUST,
+}
+
+
+class ErrorAnalyzer:
+    """Analyzes errors to extract meaning and find relevant files."""
+
+    def __init__(self, project_scanner: Optional[ProjectScanner] = None):
+        """Initialize the analyzer.
+
+        Args:
+            project_scanner: Optional project scanner for file discovery
+        """
+        self.scanner = project_scanner
+
+    def analyze(self, error_message: str) -> ErrorAnalysis:
+        """Analyze an error message.
+
+        Args:
+            error_message: The error message or log to analyze
+
+        Returns:
+            ErrorAnalysis with extracted information
+        """
+        error_lower = error_message.lower()
+
+        # Detect error category
+        category, confidence = self._detect_category(error_lower)
+        error_type = CATEGORY_TO_TYPE.get(category, 'unknown')
+        suggested_lang = CATEGORY_TO_LANGUAGE.get(category)
+
+        # Extract routes from HTTP errors
+        affected_routes = self._extract_routes(error_message)
+
+        # Extract keywords
+        keywords = self._extract_keywords(error_message)
+
+        # Find relevant files if scanner available
+        relevant_files = []
+        if self.scanner:
+            relevant_files = self.scanner.find_relevant_files(error_message, limit=5)
+
+            # If no language detected, use project's primary language
+            if not suggested_lang:
+                info = self.scanner.scan()
+                suggested_lang = info.primary_language
+
+        return ErrorAnalysis(
+            error_type=error_type,
+            error_category=category,
+            error_message=error_message[:500],  # Truncate long messages
+            suggested_language=suggested_lang,
+            relevant_files=relevant_files,
+            affected_routes=affected_routes,
+            keywords=keywords,
+            confidence=confidence,
+        )
+
+    def _detect_category(self, error_lower: str) -> Tuple[str, float]:
+        """Detect error category from message.
+
+        Returns:
+            Tuple of (category, confidence)
+        """
+        best_category = 'unknown'
+        best_confidence = 0.0
+
+        for category, patterns in ERROR_PATTERNS.items():
+            for pattern, conf in patterns:
+                if re.search(pattern, error_lower):
+                    if conf > best_confidence:
+                        best_category = category
+                        best_confidence = conf
+
+        return best_category, best_confidence
+
+    def _extract_routes(self, error_message: str) -> List[str]:
+        """Extract URL routes from error message."""
+        routes = []
+
+        # Pattern for routes in "Cannot GET /path" style
+        route_patterns = [
+            r'cannot\s+(?:get|post|put|delete|patch)\s+([/\w\-\.]+)',
+            r'(?:get|post|put|delete|patch)\s+([/\w\-\.]+)\s+(?:404|failed)',
+            r'route\s+[\'"]?([/\w\-\.]+)[\'"]?',
+            r'path\s+[\'"]?([/\w\-\.]+)[\'"]?',
+        ]
+
+        for pattern in route_patterns:
+            matches = re.findall(pattern, error_message, re.IGNORECASE)
+            routes.extend(matches)
+
+        # Deduplicate
+        return list(dict.fromkeys(routes))
+
+    def _extract_keywords(self, error_message: str) -> List[str]:
+        """Extract relevant keywords from error."""
+        keywords = []
+
+        # Extract quoted strings
+        quoted = re.findall(r'[\'"]([^\'"]{2,30})[\'"]', error_message)
+        keywords.extend(quoted)
+
+        # Extract identifiers
+        identifiers = re.findall(r'\b([A-Z][a-z]+(?:[A-Z][a-z]+)+)\b', error_message)
+        keywords.extend(identifiers)
+
+        identifiers = re.findall(r'\b([a-z]+(?:_[a-z]+)+)\b', error_message)
+        keywords.extend(identifiers)
+
+        # Extract file references
+        files = re.findall(r'[\w\-]+\.(?:py|js|ts|go|rs|java)', error_message)
+        keywords.extend(files)
+
+        # Deduplicate and limit
+        return list(dict.fromkeys(keywords))[:20]
+
+    def get_fix_context(
+        self,
+        error_message: str,
+        include_project_structure: bool = True,
+        include_file_contents: bool = True,
+        max_files: int = 3,
+    ) -> str:
+        """Get comprehensive context for AI to fix the error.
+
+        Args:
+            error_message: The error message
+            include_project_structure: Include project structure info
+            include_file_contents: Include relevant file contents
+            max_files: Maximum file contents to include
+
+        Returns:
+            Formatted context string for AI
+        """
+        analysis = self.analyze(error_message)
+        parts = []
+
+        # Error analysis
+        parts.append(analysis.to_context_string())
+
+        # Project structure
+        if include_project_structure and self.scanner:
+            parts.append("")
+            parts.append(self.scanner.get_project_context(max_files=2))
+
+        # Relevant file contents
+        if include_file_contents and self.scanner and analysis.relevant_files:
+            parts.append("")
+            parts.append("## RELEVANT SOURCE FILES")
+
+            for pf in analysis.relevant_files[:max_files]:
+                content = self.scanner.get_file_content(pf.path)
+                if content:
+                    parts.append(f"\n### {pf.path}")
+                    parts.append(f"```{pf.language.value}")
+                    # Truncate long files
+                    if len(content) > 3000:
+                        content = content[:3000] + "\n... (truncated)"
+                    parts.append(content)
+                    parts.append("```")
+
+        return "\n".join(parts)