srcodex 0.2.0__py3-none-any.whl

srcodex/indexer/reference_resolver.py

@@ -0,0 +1,544 @@
+#!/usr/bin/env python3
+"""
+Reference Resolver - Convert raw references to semantic graph edges
+Resolves (file, function) names → symbol IDs and stores typed edges in symbol_edges
+"""
+
+import sqlite3
+import re
+from pathlib import Path
+from typing import Optional, List, Tuple, Dict
+from dataclasses import dataclass
+from collections import Counter
+from tqdm import tqdm
+
+
+@dataclass
+class ResolutionStats:
+    """Statistics for resolution process"""
+    total_raw_refs: int = 0
+    resolved_edges: int = 0
+    unresolved_src: int = 0
+    unresolved_dst: int = 0
+    ambiguous_dst: int = 0
+    skipped_parsing: int = 0
+
+
+class ReferenceResolver:
+    """Resolves raw cscope references into semantic graph edges with symbol IDs"""
+
+    # C keywords to exclude from callee extraction
+    C_KEYWORDS = {
+        'if', 'for', 'while', 'switch', 'return', 'sizeof', 'typeof',
+        'do', 'else', 'case', 'break', 'continue', 'goto', 'default'
+    }
+
+    def __init__(self, db_conn: sqlite3.Connection):
+        """
+        Initialize reference resolver
+
+        Args:
+            db_conn: SQLite database connection (must have raw_references and symbols tables)
+        """
+        self.conn = db_conn
+        self.stats = ResolutionStats()
+
+        # Symbol lookup caches for performance
+        self.symbol_cache = {}  # (name, type) → [(id, file_path), ...]
+        self._build_symbol_cache()
+
+    def _build_symbol_cache(self):
+        """Build in-memory cache of all symbols for fast lookup"""
+        print("Building symbol lookup cache...")
+        cursor = self.conn.cursor()
+        cursor.execute("SELECT id, name, type, file_path FROM symbols")
+
+        for row in cursor.fetchall():
+            sym_id, name, sym_type, file_path = row['id'], row['name'], row['type'], row['file_path']
+            key = (name, sym_type)
+            if key not in self.symbol_cache:
+                self.symbol_cache[key] = []
+            self.symbol_cache[key].append((sym_id, file_path))
+
+        print(f"   Cached {len(self.symbol_cache)} unique (name, type) pairs")
+
+    def _extract_callee_from_line(self, line_text: str) -> Optional[str]:
+        """
+        Extract callee function name from line_text using IDENT( pattern
+
+        Looks for patterns like: function_name(...)
+        Excludes: keywords, macro-ish ALL_CAPS (optional)
+
+        Args:
+            line_text: Raw line content from cscope
+
+        Returns:
+            Callee function name or None if not found/excluded
+        """
+        # Pattern: identifier followed by '('
+        # Match: alphanumeric + underscore, then opening paren
+        pattern = r'\b([a-zA-Z_][a-zA-Z0-9_]*)\s*\('
+
+        matches = re.findall(pattern, line_text)
+
+        for match in matches:
+            # Exclude C keywords
+            if match in self.C_KEYWORDS:
+                continue
+
+            # Optional: exclude macro-ish ALL_CAPS
+            # Uncomment to enable:
+            # if match.isupper() and len(match) > 2:
+            #     continue
+
+            # Return first valid match
+            return match
+
+        return None
+
+    def _resolve_src_symbol(self, query_symbol: str, source_file: str) -> Optional[int]:
+        """
+        Resolve source symbol (caller) by query_symbol name
+
+        Args:
+            query_symbol: Function name that was queried (caller)
+            source_file: File where caller is defined (for disambiguation)
+
+        Returns:
+            symbol_id or None if not found/ambiguous
+        """
+        # Fast lookup in cache (no database query)
+        results = self.symbol_cache.get((query_symbol, 'function'), [])
+
+        if len(results) == 0:
+            return None  # Not found
+
+        if len(results) == 1:
+            return results[0][0]  # Unique match
+
+        # Multiple matches: prefer same file
+        for row in results:
+            if row[1] == source_file:
+                return row[0]
+
+        # Still ambiguous: return None (could pick first, but being strict)
+        return None
+
+    def _resolve_dst_symbol(self, callee_name: str, source_file: str) -> Optional[int]:
+        """
+        Resolve destination symbol (callee) by function name with disambiguation
+
+        Disambiguation rules:
+        1. Accept if unique
+        2. Prefer same file
+        3. Prefer .c file over .h (definition vs declaration)
+        4. If still multiple: return None (unresolved)
+
+        Args:
+            callee_name: Function name being called
+            source_file: File where call occurs (for disambiguation)
+
+        Returns:
+            symbol_id or None if not found/ambiguous
+        """
+        # Fast lookup in cache (no database query)
+        results = self.symbol_cache.get((callee_name, 'function'), [])
+
+        if len(results) == 0:
+            return None  # Not found
+
+        if len(results) == 1:
+            return results[0][0]  # Unique match
+
+        # Multiple matches: prefer same file first
+        for row in results:
+            if row[1] == source_file:
+                return row[0]
+
+        # Still ambiguous: prefer .c file over .h (definition vs declaration)
+        c_files = [row for row in results if row[1].endswith('.c')]
+        if len(c_files) == 1:
+            return c_files[0][0]
+
+        # Still ambiguous: unresolved
+        return None
+
+    def resolve_callees(self, clear_existing: bool = False) -> Dict[str, int]:
+        """
+        Resolve callgraph edges: raw_references (query_type='callees') → symbol_edges
+
+        For each raw reference:
+        1. Extract callee from line_text (IDENT( pattern)
+        2. Resolve src_symbol_id (query_symbol → symbol.id)
+        3. Resolve dst_symbol_id (callee → symbol.id)
+        4. Insert into symbol_edges with edge_type='CALLS'
+
+        Args:
+            clear_existing: If True, delete existing CALLS edges before resolution
+
+        Returns:
+            Dictionary with resolution statistics
+        """
+        if clear_existing:
+            print("Clearing existing CALLS edges...")
+            self.conn.execute("DELETE FROM symbol_edges WHERE edge_type = 'CALLS'")
+            self.conn.commit()
+
+        # Fetch all raw references with query_type='callees'
+        cursor = self.conn.cursor()
+        cursor.execute(
+            """SELECT id, query_symbol, source_file, source_function, line_number, line_text
+               FROM raw_references
+               WHERE query_type = 'callees'
+               ORDER BY id"""
+        )
+
+        raw_refs = cursor.fetchall()
+        self.stats.total_raw_refs = len(raw_refs)
+
+        print(f"Found {self.stats.total_raw_refs} raw references to resolve")
+
+        if not raw_refs:
+            print("Warning: No raw references found")
+            return self._stats_dict()
+
+        # Prepare batch insert for resolved edges
+        edges_batch = []
+        batch_size = 10000  # Commit every 10k edges for safety
+
+        # Track unresolved reasons for reporting
+        unresolved_reasons = Counter()
+
+        print("Resolving symbol IDs...")
+        for i, row in enumerate(tqdm(raw_refs, desc="Resolving edges")):
+            raw_id, query_symbol, source_file, source_function, line_number, line_text = row
+
+            # Step 1: Extract callee from line_text
+            callee_name = self._extract_callee_from_line(line_text)
+            if not callee_name:
+                self.stats.skipped_parsing += 1
+                unresolved_reasons['no_callee_in_line'] += 1
+                continue
+
+            # Step 2: Resolve src_symbol_id (caller)
+            src_symbol_id = self._resolve_src_symbol(query_symbol, source_file)
+            if not src_symbol_id:
+                self.stats.unresolved_src += 1
+                unresolved_reasons['src_not_found'] += 1
+                continue
+
+            # Step 3: Resolve dst_symbol_id (callee)
+            dst_symbol_id = self._resolve_dst_symbol(callee_name, source_file)
+            if not dst_symbol_id:
+                self.stats.unresolved_dst += 1
+                unresolved_reasons['dst_not_found_or_ambiguous'] += 1
+                continue
+
+            # Both resolved: add to batch
+            edges_batch.append((
+                'CALLS',            # edge_type
+                src_symbol_id,      # src_symbol_id (caller)
+                dst_symbol_id,      # dst_symbol_id (callee)
+                source_file,        # source_file (where edge occurs)
+                line_number,        # line_number
+            ))
+
+            # Batch commit every N edges for safety (prevents losing all progress)
+            if len(edges_batch) >= batch_size:
+                cursor.executemany(
+                    """INSERT OR IGNORE INTO symbol_edges
+                       (edge_type, src_symbol_id, dst_symbol_id, source_file, line_number)
+                       VALUES (?, ?, ?, ?, ?)""",
+                    edges_batch
+                )
+                self.conn.commit()
+                self.stats.resolved_edges += len(edges_batch)
+                edges_batch.clear()
+
+        # Insert remaining edges
+        if edges_batch:
+            cursor.executemany(
+                """INSERT OR IGNORE INTO symbol_edges
+                   (edge_type, src_symbol_id, dst_symbol_id, source_file, line_number)
+                   VALUES (?, ?, ?, ?, ?)""",
+                edges_batch
+            )
+            self.conn.commit()
+            self.stats.resolved_edges += len(edges_batch)
+
+        print(f"Inserted {self.stats.resolved_edges} CALLS edges")
+
+        # Print resolution statistics
+        self._print_stats(unresolved_reasons)
+
+        return self._stats_dict()
+
+    def _stats_dict(self) -> Dict[str, int]:
+        """Convert stats to dictionary"""
+        return {
+            'total_raw_refs': self.stats.total_raw_refs,
+            'resolved_edges': self.stats.resolved_edges,
+            'unresolved_src': self.stats.unresolved_src,
+            'unresolved_dst': self.stats.unresolved_dst,
+            'skipped_parsing': self.stats.skipped_parsing,
+        }
+
+    def _print_stats(self, unresolved_reasons: Counter):
+        """Print resolution statistics"""
+        print()
+        print("=" * 60)
+        print("Resolution Statistics")
+        print("=" * 60)
+        print(f"Total raw references:     {self.stats.total_raw_refs}")
+        print(f"Resolved edges:         {self.stats.resolved_edges}")
+        print(f"Unresolved (src):       {self.stats.unresolved_src}")
+        print(f"Unresolved (dst):       {self.stats.unresolved_dst}")
+        print(f"Skipped (no callee):   {self.stats.skipped_parsing}")
+
+        if unresolved_reasons:
+            print()
+            print("Unresolved breakdown:")
+            for reason, count in unresolved_reasons.most_common():
+                print(f"  {reason}: {count}")
+
+        # Calculate resolution rate
+        if self.stats.total_raw_refs > 0:
+            rate = (self.stats.resolved_edges / self.stats.total_raw_refs) * 100
+            print()
+            print(f"Resolution rate: {rate:.1f}%")
+
+    def resolve_includes(self, clear_existing: bool = False) -> Dict[str, int]:
+        """
+        Resolve raw includes references into file_edges (file-to-file INCLUDES relationships)
+
+        For each raw_references row with query_type='includes':
+        - source_file: file that includes the header
+        - query_symbol: header basename (e.g., "power.h")
+        - Resolve query_symbol → canonical repo-relative header path
+        - Insert INCLUDES edge into file_edges
+
+        Args:
+            clear_existing: If True, delete existing INCLUDES edges before resolution
+
+        Returns:
+            Dictionary with resolution statistics
+        """
+        if clear_existing:
+            print("Clearing existing INCLUDES file edges...")
+            self.conn.execute("DELETE FROM file_edges WHERE edge_type = 'INCLUDES'")
+            self.conn.commit()
+
+        # Get all includes raw references
+        cursor = self.conn.cursor()
+        cursor.execute(
+            """SELECT id, query_symbol, source_file, line_number
+               FROM raw_references
+               WHERE query_type = 'includes'
+               ORDER BY id"""
+        )
+        raw_refs = cursor.fetchall()
+
+        print(f"Found {len(raw_refs)} raw includes references to resolve")
+
+        if not raw_refs:
+            return {'total_raw_refs': 0, 'resolved_edges': 0, 'unresolved': 0, 'ambiguous': 0}
+
+        # Resolution statistics
+        stats = {
+            'total_raw_refs': len(raw_refs),
+            'resolved_edges': 0,
+            'unresolved': 0,
+            'ambiguous': 0
+        }
+
+        edges_batch = []
+        batch_size = 5000  # Commit every 5k edges
+        unresolved_headers = Counter()
+
+        print("Resolving header paths...")
+        for i, row in enumerate(tqdm(raw_refs, desc="Resolving includes")):
+            query_symbol = row['query_symbol']  # e.g., "power.h" or "common/power.h"
+            source_file = row['source_file']
+            line_number = row['line_number']
+
+            # Resolve header basename to canonical repo-relative path using directory proximity
+            resolved_path = self._resolve_header_path(query_symbol, source_file)
+
+            if resolved_path is None:
+                stats['unresolved'] += 1
+                unresolved_headers[query_symbol] += 1
+                continue
+            elif isinstance(resolved_path, list):
+                # Ambiguous: multiple matches (even after proximity heuristic)
+                stats['ambiguous'] += 1
+                unresolved_headers[f"{query_symbol} (ambiguous: {len(resolved_path)} matches)"] += 1
+                continue
+
+            # Valid resolution: add to batch
+            edges_batch.append((
+                'INCLUDES',      # edge_type
+                source_file,     # src_file (includer)
+                resolved_path,   # dst_file (included header)
+                line_number      # line_number
+            ))
+
+            # Batch commit every N edges
+            if len(edges_batch) >= batch_size:
+                cursor.executemany(
+                    """INSERT OR IGNORE INTO file_edges
+                       (edge_type, src_file, dst_file, line_number)
+                       VALUES (?, ?, ?, ?)""",
+                    edges_batch
+                )
+                self.conn.commit()
+                stats['resolved_edges'] += len(edges_batch)
+                edges_batch.clear()
+
+        # Insert remaining edges
+        if edges_batch:
+            cursor.executemany(
+                """INSERT OR IGNORE INTO file_edges
+                   (edge_type, src_file, dst_file, line_number)
+                   VALUES (?, ?, ?, ?)""",
+                edges_batch
+            )
+            self.conn.commit()
+            stats['resolved_edges'] += len(edges_batch)
+
+        print(f"Inserted {stats['resolved_edges']} INCLUDES edges")
+
+        # Print resolution statistics
+        print()
+        print("=" * 60)
+        print("Includes Resolution Statistics")
+        print("=" * 60)
+        print(f"Total raw includes:       {stats['total_raw_refs']}")
+        print(f"Resolved edges:         {stats['resolved_edges']}")
+        print(f"Unresolved headers:     {stats['unresolved']}")
+        print(f"Ambiguous headers:      {stats['ambiguous']}")
+
+        if unresolved_headers:
+            print()
+            print("Unresolved breakdown:")
+            for header, count in unresolved_headers.most_common(10):
+                print(f"  {header}: {count}")
+
+        # Calculate resolution rate
+        if stats['total_raw_refs'] > 0:
+            rate = (stats['resolved_edges'] / stats['total_raw_refs']) * 100
+            print()
+            print(f"Resolution rate: {rate:.1f}%")
+
+        return stats
+
+    def _resolve_header_path(self, query_symbol: str, source_file: str) -> Optional[str]:
+        """
+        Resolve header basename to canonical repo-relative path using directory proximity
+
+        Args:
+            query_symbol: Header name (e.g., "power.h" or "common/power.h")
+            source_file: Source file that includes this header (e.g., "mp1/src/app/acpi.c")
+
+        Returns:
+            - Canonical path string if exactly 1 match or best proximity match
+            - None if 0 matches (unresolved)
+            - List of paths if >1 match and can't disambiguate (ambiguous)
+        """
+        # If query_symbol contains '/', treat as path candidate
+        if '/' in query_symbol:
+            # Check if this exact path exists
+            cursor = self.conn.cursor()
+            cursor.execute("SELECT path FROM files WHERE path = ?", (query_symbol,))
+            result = cursor.fetchone()
+            if result:
+                return result['path']
+            else:
+                return None  # Path with '/' but doesn't exist
+
+        # Otherwise, search for basename match
+        cursor = self.conn.cursor()
+        cursor.execute(
+            """SELECT path FROM files
+               WHERE path LIKE ? OR path = ?
+               ORDER BY path""",
+            (f'%/{query_symbol}', query_symbol)
+        )
+        matches = cursor.fetchall()
+
+        if len(matches) == 0:
+            return None  # Unresolved
+        elif len(matches) == 1:
+            return matches[0]['path']  # Exact match
+        else:
+            # Ambiguous: use directory proximity heuristic
+            candidates = [row['path'] for row in matches]
+            best_match = self._pick_closest_header(source_file, candidates)
+            return best_match if best_match else candidates  # Return best or list if can't decide
+
+    def _pick_closest_header(self, source_file: str, candidates: List[str]) -> Optional[str]:
+        """
+        Pick the closest header file using directory proximity heuristic
+
+        Mimics C compiler include resolution:
+        1. Same directory (highest priority)
+        2. Subdirectory of source
+        3. Parent directory
+        4. Closest common ancestor
+
+        Args:
+            source_file: Source file path (e.g., "mp1/src/app/acpi.c")
+            candidates: List of candidate header paths
+
+        Returns:
+            Best match path, or None if can't disambiguate
+        """
+        from pathlib import Path
+
+        source_dir = str(Path(source_file).parent)  # e.g., "mp1/src/app"
+
+        # Priority 1: Same directory
+        for candidate in candidates:
+            candidate_dir = str(Path(candidate).parent)
+            if candidate_dir == source_dir:
+                return candidate
+
+        # Priority 2: Subdirectory of source directory
+        for candidate in candidates:
+            if candidate.startswith(source_dir + "/"):
+                return candidate
+
+        # Priority 3: Parent directory
+        source_parent = str(Path(source_dir).parent)
+        for candidate in candidates:
+            candidate_dir = str(Path(candidate).parent)
+            if candidate_dir == source_parent:
+                return candidate
+
+        # Priority 4: Closest common ancestor (minimum path distance)
+        def path_distance(path1: str, path2: str) -> int:
+            """Calculate directory distance between two paths"""
+            parts1 = path1.split('/')
+            parts2 = path2.split('/')
+
+            # Find common prefix length
+            common = 0
+            for p1, p2 in zip(parts1, parts2):
+                if p1 == p2:
+                    common += 1
+                else:
+                    break
+
+            # Distance = steps up + steps down
+            return (len(parts1) - common) + (len(parts2) - common)
+
+        best = None
+        min_distance = float('inf')
+
+        for candidate in candidates:
+            candidate_dir = str(Path(candidate).parent)
+            distance = path_distance(source_dir, candidate_dir)
+            if distance < min_distance:
+                min_distance = distance
+                best = candidate
+
+        return best

srcodex/tui/app.py

@@ -0,0 +1,103 @@
+from pathlib import Path
+from textual.app import App
+from textual.widgets import Label, DirectoryTree
+from textual.containers import Container
+import asyncio
+import sys
+
+# Add parent directory to path for imports
+sys.path.insert(0, str(Path(__file__).parent))
+# Add backend to path for config loader
+backend_path = Path(__file__).parent.parent / "backend"
+sys.path.insert(0, str(backend_path))
+
+from components.panels.side_panel import SidePanel
+from components.panels.code_panel import CodePanel
+from components.panels.chat_panel import ChatPanel
+from components.views.search_view import SearchView
+from components.bars.footer_bar import FooterBar
+from services.config_loader import get_config
+
+
+
+class SrcodexApp(App):
+    CSS_PATH = "app.tcss"
+
+    # Panel width state (fractional units: left=0.8, middle=2, right=1.4, sum=4.2)
+    left_width = 0.8
+    middle_width = 2
+    right_width = 1.4
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        # Load project configuration at runtime
+        config = get_config()
+        self.SOURCE_ROOT = str(config.source_root)
+        self.PROJECT_ROOT = str(config.project_root)
+
+    def compose(self):
+        yield SidePanel(self.SOURCE_ROOT, id="left")
+        yield CodePanel(self.SOURCE_ROOT, id="middle")
+        yield ChatPanel(id="right")
+        yield FooterBar(self.PROJECT_ROOT)
+
+    def on_key(self, event):
+        """Handle keyboard shortcuts for panel resizing"""
+        # Ctrl+Shift+Left: Grow chat panel, shrink code viewer
+        if event.key == "ctrl+shift+left":
+            if self.middle_width > 0.5:
+                self.right_width += 0.1
+                self.middle_width -= 0.1
+                self._update_panel_widths()
+                event.prevent_default()
+
+        # Ctrl+Shift+Right: Shrink chat panel, grow code viewer
+        elif event.key == "ctrl+shift+right":
+            if self.right_width > 0.5:
+                self.right_width -= 0.1
+                self.middle_width += 0.1
+                self._update_panel_widths()
+                event.prevent_default()
+
+    def _update_panel_widths(self):
+        """Update panel widths dynamically"""
+        left_panel = self.query_one("#left")
+        middle_panel = self.query_one("#middle")
+        right_panel = self.query_one("#right")
+
+        # Update styles with new fractional widths
+        left_panel.styles.width = f"{self.left_width}fr"
+        middle_panel.styles.width = f"{self.middle_width}fr"
+        right_panel.styles.width = f"{self.right_width}fr"
+
+    def on_directory_tree_file_selected(self, event: DirectoryTree.FileSelected):
+        """Handle file selection from FileBrowser explorer view"""
+        code_panel = self.query_one("#middle", CodePanel)
+
+        absolute_path = Path(event.path)
+        source_root = Path(self.SOURCE_ROOT)
+
+        try:
+            relative_path = absolute_path.relative_to(source_root)
+            code_panel.open_file(str(relative_path))
+        except ValueError:
+            self.notify(f"Cannot open file outside source root: {event.path}", severity="error")
+
+    async def on_search_view_symbol_selected(self, event: SearchView.SymbolSelected):
+        """Handle symbol selection from search results"""
+        code_panel = self.query_one("#middle", CodePanel)
+        side_panel = self.query_one("#left", SidePanel)
+
+        # Open file directly with line number
+        code_panel.open_file(event.file_path, line_number=event.line_number)
+
+        # Also navigate tree (async) for visual feedback
+        await side_panel.on_search_view_file_selected(
+            SearchView.FileSelected(event.file_path)
+        )
+
+
+
+if __name__ == "__main__":
+    app = SrcodexApp()
+    app.run()

srcodex/tui/app.tcss

@@ -0,0 +1,24 @@
+/* Main screen layout - 3 columns */
+Screen {
+    layout: horizontal;
+}
+
+/* Left panel - File Browser */
+#left {
+    width: 0.8fr;
+    height: 100%;
+    border: grey;
+    overflow-y: auto;
+}
+
+/* Middle panel - Code Viewer */
+#middle {
+    width: 2fr;
+    border: grey;
+}
+
+/* Right panel - AI Chat */
+#right {
+    width: 1.4fr;
+    border: grey;
+}