codegraphcontext-rust 0.5.5__cp311-cp311-win_amd64.whl

codegraphcontext/utils/tree_sitter_manager.py

@@ -0,0 +1,285 @@
+"""
+Tree-sitter language and parser management module.
+
+This module provides thread-safe, cached access to tree-sitter languages and parsers.
+It handles the migration from tree-sitter-languages to tree-sitter-language-pack.
+
+Key design principles:
+1. Cache languages, not parsers (parsers are NOT thread-safe)
+2. Handle language name aliasing
+3. Provide clear error messages for missing languages
+4. Support optional tree-sitter dependency
+"""
+
+from typing import Dict, Optional
+import threading
+
+from tree_sitter import Language, Parser
+from tree_sitter_language_pack import get_language
+
+
+# Language name aliases for compatibility
+LANGUAGE_ALIASES = {
+    # Common aliases
+    "py": "python",
+    "js": "javascript",
+    "ts": "typescript",
+    "c++": "cpp",
+    "c#": "c_sharp",
+    "csharp": "c_sharp",
+    "cs": "c_sharp",
+    "rb": "ruby",
+    "rs": "rust",
+    "go": "go",
+    "php": "php",
+    ".php": "php",
+    
+    # Canonical names (map to themselves for consistency)
+    "python": "python",
+    "javascript": "javascript",
+    "typescript": "typescript",
+    "tsx": "tsx",
+    "cpp": "cpp",
+    "c_sharp": "c_sharp",
+    "c": "c",
+    "java": "java",
+    "haskell": "haskell",
+    "ruby": "ruby",
+    "rust": "rust",
+    "kt": "kotlin",
+    "kotlin": "kotlin",
+    "scala": "scala",
+    ".scala": "scala",
+    "swift": "swift",
+    ".swift": "swift",
+    "dart": "dart",
+    "perl": "perl",
+    "pl": "perl",
+    "pm": "perl",
+    "elixir": "elixir",
+    "ex": "elixir",
+    "exs": "elixir",
+}
+
+# Canonical names that differ from tree-sitter-language-pack names
+LANGUAGE_PACK_NAMES = {
+    "c_sharp": "csharp",
+}
+
+
+class TreeSitterManager:
+    """
+    Manages tree-sitter language loading and parser creation.
+    
+    This class provides:
+    - Thread-safe language caching
+    - Language name aliasing
+    - Parser lifecycle management
+    - Clear error handling
+    """
+    
+    def __init__(self):
+        """Initialize the tree-sitter manager."""
+        self._language_cache: Dict[str, Language] = {}
+        self._cache_lock = threading.Lock()
+    
+    def _normalize_language_name(self, lang: str) -> str:
+        """
+        Normalize a language name to its canonical form.
+        
+        Args:
+            lang: Language name (e.g., "py", "python", "c++")
+            
+        Returns:
+            Canonical language name (e.g., "python", "cpp")
+            
+        Raises:
+            ValueError: If language name is not recognized
+        """
+        normalized = LANGUAGE_ALIASES.get(lang.lower())
+        if normalized is None:
+            raise ValueError(
+                f"Unknown language: {lang}. "
+                f"Supported languages: {', '.join(sorted(set(LANGUAGE_ALIASES.values())))}"
+            )
+        return normalized
+    
+    def get_language_safe(self, lang: str) -> Language:
+        """
+        Get a cached Language object for the specified language.
+        
+        This method is thread-safe and caches languages to avoid repeated loading.
+        
+        Args:
+            lang: Language name (supports aliases like "py", "c++", etc.)
+            
+        Returns:
+            Tree-sitter Language object
+            
+        Raises:
+            ValueError: If language is not supported
+            Exception: If language loading fails
+        """
+        # Normalize the language name
+        canonical_name = self._normalize_language_name(lang)
+        
+        # Check cache first (fast path, no lock needed for reads)
+        if canonical_name in self._language_cache:
+            return self._language_cache[canonical_name]
+        
+        # Load language with lock (slow path)
+        with self._cache_lock:
+            # Double-check after acquiring lock
+            if canonical_name in self._language_cache:
+                return self._language_cache[canonical_name]
+            
+            try:
+                # Map canonical name to language-pack name where they differ
+                pack_name = LANGUAGE_PACK_NAMES.get(canonical_name, canonical_name)
+                language = get_language(pack_name)
+                
+                self._language_cache[canonical_name] = language
+                return language
+            except (KeyError, ModuleNotFoundError):
+                raise ValueError(
+                    f"Language '{canonical_name}' is not available in tree-sitter-language-pack. "
+                    f"This may be due to a missing or experimental grammar."
+                )
+            except Exception as e:
+                raise Exception(
+                    f"Failed to load language '{canonical_name}': {e}"
+                )
+    
+    def create_parser(self, lang: str) -> Parser:
+        """
+        Create a new Parser instance for the specified language.
+        
+        IMPORTANT: Parsers are NOT thread-safe and should not be shared across threads.
+        Each thread should create its own parser using this method.
+        
+        Args:
+            lang: Language name (supports aliases)
+            
+        Returns:
+            A new Parser instance configured for the language
+            
+        Raises:
+            ValueError: If language is not supported
+            Exception: If parser creation fails
+        """
+        language = self.get_language_safe(lang)
+        # In tree-sitter 0.25+, Parser takes language in constructor
+        parser = Parser(language)
+        return parser
+    
+    def is_language_available(self, lang: str) -> bool:
+        """
+        Check if a language is available without raising exceptions.
+        
+        Args:
+            lang: Language name
+            
+        Returns:
+            True if language is available, False otherwise
+        """
+        try:
+            self.get_language_safe(lang)
+            return True
+        except (ValueError, Exception):
+            return False
+    
+    def get_supported_languages(self) -> list[str]:
+        """
+        Get a list of all supported language names.
+        
+        Returns:
+            Sorted list of canonical language names
+        """
+        return sorted(set(LANGUAGE_ALIASES.values()))
+
+
+# Global singleton instance
+_manager_instance: Optional[TreeSitterManager] = None
+_instance_lock = threading.Lock()
+
+
+def get_tree_sitter_manager() -> TreeSitterManager:
+    """
+    Get the global TreeSitterManager instance (singleton pattern).
+    
+    Returns:
+        The global TreeSitterManager instance
+    """
+    global _manager_instance
+    
+    if _manager_instance is not None:
+        return _manager_instance
+    
+    with _instance_lock:
+        if _manager_instance is None:
+            _manager_instance = TreeSitterManager()
+        return _manager_instance
+
+
+# Convenience functions for backward compatibility
+def get_language_safe(lang: str) -> Language:
+    """Get a cached Language object. Thread-safe."""
+    return get_tree_sitter_manager().get_language_safe(lang)
+
+
+def create_parser(lang: str) -> Parser:
+    """Create a new Parser for the language. Each call returns a new parser."""
+    return get_tree_sitter_manager().create_parser(lang)
+
+
+def execute_query(language: Language, query_string: str, node):
+    """
+    Execute a tree-sitter query and return captures in backward-compatible format.
+    
+    This function provides compatibility with the old tree-sitter 0.20.x API where
+    you could call query.captures(node). The new 0.25+ API uses QueryCursor.
+    
+    Args:
+        language: Tree-sitter Language object
+        query_string: Query string in tree-sitter query syntax
+        node: Tree-sitter Node to query
+        
+    Returns:
+        List of (node, capture_name) tuples, compatible with old API
+        
+    Example:
+        >>> from tree_sitter_language_pack import get_language
+        >>> lang = get_language('python')
+        >>> parser = Parser(lang)
+        >>> tree = parser.parse(b'def hello(): pass')
+        >>> captures = execute_query(lang, '(function_definition) @func', tree.root_node)
+        >>> for node, name in captures:
+        ...     print(f'{name}: {node.type}')
+    """
+    from tree_sitter import Query, QueryCursor
+    
+    try:
+        # Create query and cursor
+        query = Query(language, query_string)
+        cursor = QueryCursor(query)
+        
+        # Execute query and convert to old format
+        captures = []
+        
+        # Use matches() which returns (pattern_index, captures_dict) tuples
+        for pattern_index, captures_dict in cursor.matches(node):
+            # captures_dict is {capture_name: [nodes]}
+            for capture_name, nodes in captures_dict.items():
+                for captured_node in nodes:
+                    # Old format: (node, capture_name)
+                    captures.append((captured_node, capture_name))
+        
+        return captures
+        
+    except Exception as e:
+        # Provide helpful error message
+        raise Exception(
+            f"Failed to execute query: {e}\n"
+            f"Query string: {query_string[:100]}..."
+        )
+

codegraphcontext/viz/server.py

@@ -0,0 +1,282 @@
+from fastapi import FastAPI, HTTPException, Query, Request
+from fastapi.staticfiles import StaticFiles
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import HTMLResponse, FileResponse
+from pathlib import Path
+import uvicorn
+import json
+import os
+import sys
+from typing import Optional, List, Dict, Any
+
+from ..core.database import DatabaseManager
+from ..utils.debug_log import debug_log
+
+app = FastAPI()
+
+# Enable CORS for development
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Global database manager (will be initialized when server starts)
+db_manager: Optional[DatabaseManager] = None
+# Path to static directory
+_static_dir: Optional[str] = None
+
+def set_db_manager(manager: DatabaseManager):
+    global db_manager
+    db_manager = manager
+
+@app.get("/api/graph")
+async def get_graph(repo_path: Optional[str] = None, cypher_query: Optional[str] = None):
+    if not db_manager:
+        raise HTTPException(status_code=500, detail="Database not initialized")
+    
+    def get_eid(element):
+        if element is None: return None
+        if isinstance(element, (int, str)):
+            return str(element)
+        
+        # If element is a dict (like Neo4j returned items or KuzuDB node/rel dicts)
+        if isinstance(element, dict):
+            # KuzuDB _src / _dst are directly {'offset': X, 'table': Y}
+            if 'offset' in element and 'table' in element:
+                return f"{element.get('table')}_{element.get('offset')}"
+                
+            for key in ['_id', 'id', 'element_id']:
+                if key in element:
+                    val = element[key]
+                    if val is not None:
+                        # KuzuDB returns dict IDs like {'offset': 1, 'table': 0} inside nodes
+                        if isinstance(val, dict):
+                            return f"{val.get('table', 0)}_{val.get('offset', 0)}"
+                        return str(val)
+            return str(id(element))
+            
+        # Try various ways to get ID (Neo4j, FalkorDB, etc. objects)
+        for attr in ['element_id', 'id', '_id']:
+            if hasattr(element, attr):
+                val = getattr(element, attr)
+                if val is not None: 
+                    # KuzuDB objects if any
+                    if isinstance(val, dict):
+                        return f"{val.get('table', 0)}_{val.get('offset', 0)}"
+                    return str(val)
+        return str(id(element))
+
+    try:
+        nodes_dict = {}
+        edges = []
+
+        print(f"DEBUG: Starting get_graph with repo_path={repo_path}", flush=True)
+
+        with db_manager.get_driver().session() as session:
+            if cypher_query:
+                print(f"DEBUG: Executing custom query: {cypher_query}", flush=True)
+                result = session.run(cypher_query)
+            elif repo_path:
+                repo_path = str(Path(repo_path).resolve())
+                print(f"DEBUG: Fetching subgraph for: {repo_path}", flush=True)
+                query = """
+                MATCH (r:Repository {path: $repo_path})
+                OPTIONAL MATCH (r)-[:CONTAINS*0..]->(n)
+                WITH DISTINCT n
+                WHERE n IS NOT NULL
+                OPTIONAL MATCH (n)-[rel]->(m)
+                RETURN n, rel, m
+                """
+                result = session.run(query, repo_path=repo_path)
+            else:
+                print("DEBUG: Fetching global graph", flush=True)
+                query = "MATCH (n) OPTIONAL MATCH (n)-[rel]->(m) RETURN n, rel, m LIMIT 50000"
+                result = session.run(query)
+
+            record_count = 0
+            for record in result:
+                record_count += 1
+                # Use .get() to avoid KeyError if the query doesn't return all fields (n, rel, m)
+                for key in ['n', 'm']:
+                    try:
+                        node = record.get(key)
+                        if node:
+                            eid = get_eid(node)
+                            if eid and eid not in nodes_dict:
+                                # Extract labels
+                                labels = []
+                                if isinstance(node, dict):
+                                    # KuzuDB node label is under '_label'
+                                    if '_label' in node:
+                                        labels = [node['_label']]
+                                    elif 'label' in node:
+                                        labels = [node['label']]
+                                else:
+                                    for label_attr in ['_labels', 'labels']:
+                                        if hasattr(node, label_attr):
+                                            attr_val = getattr(node, label_attr)
+                                            if attr_val:
+                                                labels = list(attr_val)
+                                                break
+                                
+                                # Extract properties
+                                props = {}
+                                if isinstance(node, dict):
+                                    props = {k: v for k, v in node.items() if not k.startswith('_')}
+                                else:
+                                    for prop_attr in ['properties', '_properties']:
+                                        if hasattr(node, prop_attr):
+                                            attr_val = getattr(node, prop_attr)
+                                            if attr_val:
+                                                props = dict(attr_val)
+                                                break
+                                                
+                                    # Fallback if props still empty but node acts like dict
+                                    if not props and hasattr(node, 'items'):
+                                        try:
+                                            props = dict(node.items())
+                                        except: pass
+                                
+                                # Extract name/label for frontend
+                                # Prefer 'name' property, fallback to 'label', then 'path' or 'Unknown'
+                                display_name = str(props.get('name', props.get('label', props.get('path', 'Unknown'))))
+                                
+                                nodes_dict[eid] = {
+                                    "id": eid,
+                                    "name": display_name,
+                                    "label": display_name,
+                                    "type": str(labels[0]).capitalize() if labels else "Other",
+                                    "file": str(props.get('path', props.get('file', ''))),
+                                    "val": 4 if (labels and labels[0] in ['Repository', 'Class', 'Interface', 'Trait']) else 2,
+                                    "properties": props
+                                }
+                    except Exception as e:
+                        print(f"DEBUG: Error parsing node: {e}", file=sys.stderr, flush=True)
+                        continue
+                
+                try:
+                    rel = record.get('rel')
+                    if rel is not None:
+                        # One-shot debug: print type and keys/attrs of first rel
+                        if not edges:
+                            if isinstance(rel, dict):
+                                print(f"DEBUG rel (dict): keys={list(rel.keys())}", file=sys.stderr, flush=True)
+                            else:
+                                print(f"DEBUG rel (obj): type={type(rel).__name__}, attrs={[a for a in dir(rel) if not a.startswith('__')]}", file=sys.stderr, flush=True)
+
+                        # FalkorDB / KuzuDB may return rels as dicts OR objects
+                        if isinstance(rel, dict):
+                            rid = get_eid(rel)
+                            # KuzuDB uses _src and _dst, FalkorDB uses src_node/dest_node
+                            src = rel.get('_src', rel.get('src_node'))
+                            dst = rel.get('_dst', rel.get('dest_node'))
+                            
+                            source = get_eid(src) if src is not None else None
+                            target = get_eid(dst) if dst is not None else None
+                            rel_type = str(rel.get('_label', rel.get('relation', rel.get('type', 'RELATED')))).upper()
+                        else:
+                            rid = get_eid(rel)
+                            start_node = None
+                            end_node = None
+                            for src_attr in ['start_node', 'src_node', '_src_node']:
+                                if hasattr(rel, src_attr):
+                                    start_node = getattr(rel, src_attr)
+                                    break
+                            for dest_attr in ['end_node', 'dest_node', '_dest_node']:
+                                if hasattr(rel, dest_attr):
+                                    end_node = getattr(rel, dest_attr)
+                                    break
+                            source = get_eid(start_node) if start_node is not None else None
+                            target = get_eid(end_node) if end_node is not None else None
+                            rel_type = "RELATED"
+                            for rel_attr in ['type', 'relation', '_relation']:
+                                if hasattr(rel, rel_attr):
+                                    rel_type = str(getattr(rel, rel_attr)).upper()
+                                    break
+
+                        if source and target:
+                            edges.append({
+                                "id": rid,
+                                "source": source,
+                                "target": target,
+                                "type": rel_type
+                            })
+                except Exception as e:
+                    print(f"DEBUG: Error parsing relationship: {e}", file=sys.stderr, flush=True)
+                    pass
+
+        print(f"DEBUG: Processed {record_count} records. extracted {len(nodes_dict)} nodes and {len(edges)} edges.", file=sys.stderr, flush=True)
+
+        # Build a list of unique file paths from File-type nodes for the tree
+        file_paths = []
+        for n in nodes_dict.values():
+            if n.get("file") and str(n.get("type", "")).lower() == "file":
+                file_paths.append(str(n["file"]))
+        file_paths = sorted(list(set(file_paths)))
+
+        # Read file contents so the frontend never needs a separate API call
+        file_contents: dict[str, str] = {}
+        for fp in file_paths:
+            try:
+                with open(fp, "r", encoding="utf-8", errors="replace") as f:
+                    file_contents[fp] = f.read()
+            except Exception:
+                pass
+
+        response_data = {
+            "nodes": list(nodes_dict.values()), 
+            "links": edges,
+            "files": file_paths,
+            "fileContents": file_contents,
+        }
+        
+        print(f"API SUCCESS: Returning graph with {len(response_data['nodes'])} nodes and {len(response_data['links'])} links.", file=sys.stderr, flush=True)
+        return response_data
+
+    except Exception as e:
+        debug_log(f"Error fetching graph: {str(e)}")
+        import traceback
+        traceback.print_exc()
+        # Still return a valid structure so the frontend doesn't crash, but with 500 status if raised
+        # Actually, let's just return a 500 error but with JSON body if possible
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.get("/api/file")
+async def get_file(path: str):
+    file_path = Path(path)
+    if not file_path.exists():
+        raise HTTPException(status_code=404, detail="File not found")
+    
+    try:
+        with open(file_path, "r", encoding="utf-8") as f:
+            return {"content": f.read()}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+# SPA fallback handler
+@app.get("/{full_path:path}")
+async def spa_fallback(request: Request, full_path: str):
+    global _static_dir
+    if not _static_dir:
+        return HTMLResponse("Static directory not configured", status_code=500)
+    
+    # Filesystem path
+    file_path = Path(_static_dir) / full_path
+    
+    # If the file exists and is a file, serve it normally
+    if file_path.exists() and file_path.is_file():
+        return FileResponse(file_path)
+    
+    # Otherwise serve index.html (Standard SPA routing)
+    index_path = Path(_static_dir) / "index.html"
+    if index_path.exists():
+        return FileResponse(index_path)
+    
+    return HTMLResponse("Not Found (Built UI not found in viz/dist)", status_code=404)
+
+def run_server(host: str = "127.0.0.1", port: int = 8000, static_dir: Optional[str] = None):
+    global _static_dir
+    _static_dir = static_dir
+    uvicorn.run(app, host=host, port=port)