codegraphcontext 0.3.3__py3-none-any.whl → 0.3.5__py3-none-any.whl

codegraphcontext/cli/cli_helpers.py

@@ -359,16 +359,40 @@ def visualize_helper(repo_path: Optional[str] = None, port: int = 8000):
     
     # Determine the static directory (built React app)
     # This points to src/codegraphcontext/viz/dist where we build the website
-    static_dir = Path(__file__).parent.parent / "viz" / "dist"
+    # (relative to src/codegraphcontext/cli/cli_helpers.py)
+    # Using .resolve() is more robust for path comparison and existence checks
+    this_file = Path(__file__).resolve()
+    package_root = this_file.parent.parent
+    static_dir = package_root / "viz" / "dist"
     
     # Fallback for development if not yet built in viz/dist
     if not static_dir.exists():
-        dev_static_dir = Path.cwd() / "website" / "dist"
+        # Look for website/dist in the project root (3 levels up from cli/cli_helpers.py, 4 parents)
+        # 1: cli/, 2: codegraphcontext/, 3: src/, 4: project_root/
+        project_root = this_file.parent.parent.parent.parent
+        dev_static_dir = project_root / "website" / "dist"
+        
+        # Also try one level up from package_root just in case of different layouts
+        alt_dev_dir = package_root.parent.parent / "website" / "dist"
+        
         if dev_static_dir.exists():
             static_dir = dev_static_dir
+        elif alt_dev_dir.exists():
+            static_dir = alt_dev_dir
         else:
-            console.print("[yellow]Warning: Visualization assets not found. Please run 'cd website && npm run build' first.[/yellow]")
-            # We continue anyway to let the server start (helpful for dev)
+            # Last resort: try current working directory
+            cwd_static_dir = Path.cwd() / "website" / "dist"
+            if cwd_static_dir.exists():
+                static_dir = cwd_static_dir
+            else:
+                console.print(f"[yellow]Warning: Visualization assets not found.[/yellow]")
+                console.print(f"[dim]Checked paths:[/dim]")
+                console.print(f"  [dim]- {static_dir}[/dim]")
+                console.print(f"  [dim]- {dev_static_dir}[/dim]")
+                console.print(f"  [dim]- {alt_dev_dir}[/dim]")
+                console.print(f"  [dim]- {cwd_static_dir}[/dim]")
+                console.print("[dim]Please run 'cd website && npm run build' first.[/dim]")
+                # We continue anyway to let the server start (helpful for dev)
     
     # Construct the URL
     backend_url = f"http://localhost:{port}"

codegraphcontext/tools/graph_builder.py

@@ -703,8 +703,7 @@ class GraphBuilder:
                     'args': call.get('args', []),
                     'full_call_name': call.get('full_name', called_name)
                 }
-                
-                # Try Function caller -> Function callee
+                 # Try Function caller -> Function callee
                 if not self._safe_run_create(session, """
                     OPTIONAL MATCH (caller:Function {name: $caller_name, path: $caller_file_path})
                     OPTIONAL MATCH (called:Function {name: $called_name, path: $called_file_path})
@@ -713,51 +712,73 @@ class GraphBuilder:
                     MERGE (caller)-[:CALLS {line_number: $line_number, args: $args, full_call_name: $full_call_name}]->(called)
                     RETURN count(*) as created
                 """, call_params):
-                
-                    # Try Function caller -> Class callee (with __init__ resolution)
+
+                    # Try Function caller -> Class.__init__ / constructor
                     if not self._safe_run_create(session, """
                         OPTIONAL MATCH (caller:Function {name: $caller_name, path: $caller_file_path})
                         OPTIONAL MATCH (called:Class {name: $called_name, path: $called_file_path})
                         OPTIONAL MATCH (called)-[:CONTAINS]->(init:Function)
                         WHERE init.name IN ["__init__", "constructor"]
-                        WITH caller, COALESCE(init, called) as final_target
-                        WHERE caller IS NOT NULL AND final_target IS NOT NULL
-                        MERGE (caller)-[:CALLS {line_number: $line_number, args: $args, full_call_name: $full_call_name}]->(final_target)
+                        WITH caller, init
+                        WHERE caller IS NOT NULL AND init IS NOT NULL
+                        MERGE (caller)-[:CALLS {line_number: $line_number, args: $args, full_call_name: $full_call_name}]->(init)
                         RETURN count(*) as created
                     """, call_params):
-                
-                        # Try Class caller -> Function callee
+                        # No __init__ found - link directly to the Class node
+                        self._safe_run_create(session, """
+                            OPTIONAL MATCH (caller:Function {name: $caller_name, path: $caller_file_path})
+                            OPTIONAL MATCH (called:Class {name: $called_name, path: $called_file_path})
+                            WITH caller, called
+                            WHERE caller IS NOT NULL AND called IS NOT NULL
+                            MERGE (caller)-[:CALLS {line_number: $line_number, args: $args, full_call_name: $full_call_name}]->(called)
+                            RETURN count(*) as created
+                        """, call_params)
+
+                # Try Class caller -> Function callee
+                if not self._safe_run_create(session, """
+                    OPTIONAL MATCH (caller:Class {name: $caller_name, path: $caller_file_path})
+                    OPTIONAL MATCH (called:Function {name: $called_name, path: $called_file_path})
+                    WITH caller, called
+                    WHERE caller IS NOT NULL AND called IS NOT NULL
+                    MERGE (caller)-[:CALLS {line_number: $line_number, args: $args, full_call_name: $full_call_name}]->(called)
+                    RETURN count(*) as created
+                """, call_params):
+
+                    # Try Class caller -> Class.__init__ / constructor
+                    if not self._safe_run_create(session, """
+                        OPTIONAL MATCH (caller:Class {name: $caller_name, path: $caller_file_path})
+                        OPTIONAL MATCH (called:Class {name: $called_name, path: $called_file_path})
+                        OPTIONAL MATCH (called)-[:CONTAINS]->(init:Function)
+                        WHERE init.name IN ["__init__", "constructor"]
+                        WITH caller, init
+                        WHERE caller IS NOT NULL AND init IS NOT NULL
+                        MERGE (caller)-[:CALLS {line_number: $line_number, args: $args, full_call_name: $full_call_name}]->(init)
+                        RETURN count(*) as created
+                    """, call_params):
+                        # No __init__ - link directly to the Class node
                         if not self._safe_run_create(session, """
                             OPTIONAL MATCH (caller:Class {name: $caller_name, path: $caller_file_path})
-                            OPTIONAL MATCH (called:Function {name: $called_name, path: $called_file_path})
+                            OPTIONAL MATCH (called:Class {name: $called_name, path: $called_file_path})
                             WITH caller, called
                             WHERE caller IS NOT NULL AND called IS NOT NULL
                             MERGE (caller)-[:CALLS {line_number: $line_number, args: $args, full_call_name: $full_call_name}]->(called)
                             RETURN count(*) as created
                         """, call_params):
-                
-                            # Try Class caller -> Class callee
+                            # Fallback: Relaxed Global Search (Function caller -> any Function callee)
                             if not self._safe_run_create(session, """
-                                OPTIONAL MATCH (caller:Class {name: $caller_name, path: $caller_file_path})
-                                OPTIONAL MATCH (called:Class {name: $called_name, path: $called_file_path})
-                                OPTIONAL MATCH (called)-[:CONTAINS]->(init:Function)
-                                WHERE init.name IN ["__init__", "constructor"]
-                                WITH caller, COALESCE(init, called) as final_target
-                                WHERE caller IS NOT NULL AND final_target IS NOT NULL
-                                MERGE (caller)-[:CALLS {line_number: $line_number, args: $args, full_call_name: $full_call_name}]->(final_target)
-                                RETURN count(*) as created
+                                OPTIONAL MATCH (caller:Function {name: $caller_name, path: $caller_file_path})
+                                OPTIONAL MATCH (called:Function {name: $called_name})
+                                WITH caller, called
+                                WHERE caller IS NOT NULL AND called IS NOT NULL
+                                MERGE (caller)-[:CALLS {line_number: $line_number, args: $args, full_call_name: $full_call_name}]->(called)
                             """, call_params):
-
-                                 # Fallback: Relaxed Global Search (Caller: Function/Class -> Callee: Function)
-                                 # Used when path resolution failed or was ambiguous
-                                 self._safe_run_create(session, """
-                                    OPTIONAL MATCH (caller:Function {name: $caller_name, path: $caller_file_path}) 
-                                    OPTIONAL MATCH (callerClass:Class {name: $caller_name, path: $caller_file_path})
-                                    WITH COALESCE(caller, callerClass) as final_caller
+                                # Fallback: Class caller -> any Function callee
+                                self._safe_run_create(session, """
+                                    OPTIONAL MATCH (caller:Class {name: $caller_name, path: $caller_file_path})
                                     OPTIONAL MATCH (called:Function {name: $called_name})
-                                    WITH final_caller, called
-                                    WHERE final_caller IS NOT NULL AND called IS NOT NULL
-                                    MERGE (final_caller)-[:CALLS {line_number: $line_number, args: $args, full_call_name: $full_call_name}]->(called)
+                                    WITH caller, called
+                                    WHERE caller IS NOT NULL AND called IS NOT NULL
+                                    MERGE (caller)-[:CALLS {line_number: $line_number, args: $args, full_call_name: $full_call_name}]->(called)
                                 """, call_params)
             else:
                 # File-level calls: Try Function first, then Class
@@ -769,7 +790,7 @@ class GraphBuilder:
                     'args': call.get('args', []),
                     'full_call_name': call.get('full_name', called_name)
                 }
-                
+
                 if not self._safe_run_create(session, """
                     OPTIONAL MATCH (caller:File {path: $caller_file_path})
                     OPTIONAL MATCH (called:Function {name: $called_name, path: $called_file_path})
@@ -778,26 +799,35 @@ class GraphBuilder:
                     MERGE (caller)-[:CALLS {line_number: $line_number, args: $args, full_call_name: $full_call_name}]->(called)
                     RETURN count(*) as created
                 """, call_params):
-                
+
+                    # Try File caller -> Class.__init__ / constructor
                     if not self._safe_run_create(session, """
                         OPTIONAL MATCH (caller:File {path: $caller_file_path})
                         OPTIONAL MATCH (called:Class {name: $called_name, path: $called_file_path})
                         OPTIONAL MATCH (called)-[:CONTAINS]->(init:Function)
                         WHERE init.name IN ["__init__", "constructor"]
-                        WITH caller, COALESCE(init, called) as final_target
-                        WHERE caller IS NOT NULL AND final_target IS NOT NULL
-                        MERGE (caller)-[:CALLS {line_number: $line_number, args: $args, full_call_name: $full_call_name}]->(final_target)
+                        WITH caller, init
+                        WHERE caller IS NOT NULL AND init IS NOT NULL
+                        MERGE (caller)-[:CALLS {line_number: $line_number, args: $args, full_call_name: $full_call_name}]->(init)
                         RETURN count(*) as created
                     """, call_params):
-
-                         # Fallback: Relaxed Global Search (Caller: File -> Callee: Function)
-                         self._safe_run_create(session, """
+                        # No __init__ - link directly to the Class node
+                        if not self._safe_run_create(session, """
                             OPTIONAL MATCH (caller:File {path: $caller_file_path})
-                            OPTIONAL MATCH (called:Function {name: $called_name})
+                            OPTIONAL MATCH (called:Class {name: $called_name, path: $called_file_path})
                             WITH caller, called
                             WHERE caller IS NOT NULL AND called IS NOT NULL
                             MERGE (caller)-[:CALLS {line_number: $line_number, args: $args, full_call_name: $full_call_name}]->(called)
-                        """, call_params)
+                            RETURN count(*) as created
+                        """, call_params):
+                            # Fallback: Relaxed Global Search (File -> any Function)
+                            self._safe_run_create(session, """
+                                OPTIONAL MATCH (caller:File {path: $caller_file_path})
+                                OPTIONAL MATCH (called:Function {name: $called_name})
+                                WITH caller, called
+                                WHERE caller IS NOT NULL AND called IS NOT NULL
+                                MERGE (caller)-[:CALLS {line_number: $line_number, args: $args, full_call_name: $full_call_name}]->(called)
+                            """, call_params)
 
     def _create_all_function_calls(self, all_file_data: list[Dict], imports_map: dict):
         """Create CALLS relationships for all functions after all files have been processed."""
@@ -1278,20 +1308,22 @@ class GraphBuilder:
 
             # Search for .cgcignore upwards
             cgcignore_path = None
-            ignore_root = path.resolve()
-            
+            # ignore_root is always the indexed path itself so that file paths
+            # are matched relative to the project being indexed.  A parent
+            # .cgcignore is still loaded (for monorepo support), but anchoring
+            # to its directory would make patterns like "website/" incorrectly
+            # filter out every file when indexing the website sub-directory.
+            ignore_root = path.resolve() if path.is_dir() else path.resolve().parent
+
             # Start search from path (or parent if path is file)
-            curr = path.resolve()
-            if not curr.is_dir():
-                curr = curr.parent
+            curr = ignore_root
 
             # Walk up looking for .cgcignore
             while True:
                 candidate = curr / ".cgcignore"
                 if candidate.exists():
                     cgcignore_path = candidate
-                    ignore_root = curr
-                    debug_log(f"Found .cgcignore at {ignore_root}")
+                    debug_log(f"Found .cgcignore at {curr} (filtering relative to {ignore_root})")
                     break
                 if curr.parent == curr: # Root hit
                     break

codegraphcontext/viz/server.py

@@ -6,6 +6,7 @@ from pathlib import Path
 import uvicorn
 import json
 import os
+import sys
 from typing import Optional, List, Dict, Any
 
 from ..core.database import DatabaseManager
@@ -36,27 +37,50 @@ async def get_graph(repo_path: Optional[str] = None, cypher_query: Optional[str]
         raise HTTPException(status_code=500, detail="Database not initialized")
     
     def get_eid(element):
-        if not element: return None
+        if element is None: return None
         if isinstance(element, (int, str)):
             return str(element)
-        # Try various ways to get ID (Neo4j, FalkorDB, etc.)
+        
+        # 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: return str(val)
+                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:
-                # Direct user query (filtered view)
+                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())
-                # Optimized subgraph query
+                print(f"DEBUG: Fetching subgraph for: {repo_path}", flush=True)
                 query = """
                 MATCH (r:Repository {path: $repo_path})
                 OPTIONAL MATCH (r)-[:CONTAINS*0..]->(n)
@@ -67,77 +91,146 @@ async def get_graph(repo_path: Optional[str] = None, cypher_query: Optional[str]
                 """
                 result = session.run(query, repo_path=repo_path)
             else:
-                query = "MATCH (n) OPTIONAL MATCH (n)-[rel]->(m) RETURN n, rel, m LIMIT 5000"
+                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']:
-                    node = record[key]
-                    if node:
-                        eid = get_eid(node)
-                        if eid not in nodes_dict:
-                            # FalkorDB / Neo4j labels compatibility
-                            labels = []
-                            if hasattr(node, 'labels'):
-                                labels = list(node.labels)
-                            
-                            # FalkorDB / Neo4j properties compatibility
-                            props = {}
-                            if hasattr(node, 'properties'):
-                                props = node.properties
-                            elif hasattr(node, 'items'):
-                                props = dict(node.items())
+                    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
                                 
-                            nodes_dict[eid] = {
-                                "id": eid,
-                                "label": props.get('name', props.get('label', 'Unknown')),
-                                "type": labels[0].capitalize() if labels else "Other",
-                                "file": props.get('path', props.get('file', '')),
-                                "properties": props
-                            }
+                                # 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
                 
-                rel = record['rel']
-                if rel:
-                    rid = get_eid(rel)
-                    
-                    # FalkorDB / Neo4j compatibility for source/target nodes
-                    start_node = getattr(rel, 'start_node', getattr(rel, 'src_node', None))
-                    end_node = getattr(rel, 'end_node', getattr(rel, 'dest_node', None))
-                    
-                    source = get_eid(start_node)
-                    target = get_eid(end_node)
-                    
-                    if source and target:
-                        # relationship type/relation
-                        rel_type = "related"
-                        if hasattr(rel, 'type'):
-                            rel_type = rel.type
-                        elif hasattr(rel, 'relation'):
-                            rel_type = rel.relation
+                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'))
                             
-                        edges.append({
-                            "id": rid,
-                            "source": source,
-                            "target": target,
-                            "type": str(rel_type).upper()
-                        })
+                            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 = sorted(set(
-            n["file"] for n in nodes_dict.values()
-            if n.get("file") and n.get("type", "").lower() == "file"
-        ))
+        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)))
 
-        return {
+        response_data = {
             "nodes": list(nodes_dict.values()), 
-            "edges": edges,
+            "links": edges,
             "files": file_paths,
         }
+        
+        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")

{codegraphcontext-0.3.3.dist-info → codegraphcontext-0.3.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codegraphcontext
-Version: 0.3.3
+Version: 0.3.5
 Summary: An MCP server that indexes local code into a graph database to provide context to AI assistants.
 Author-email: Shashank Shekhar Singh <shashankshekharsingh1205@gmail.com>
 License: MIT License
@@ -41,10 +41,11 @@ Requires-Dist: watchdog>=3.0.0
 Requires-Dist: stdlibs>=2023.11.18
 Requires-Dist: typer[all]>=0.9.0
 Requires-Dist: rich>=13.7.0
-Requires-Dist: inquirerpy>=0.3.4
+Requires-Dist: inquirerpy>=0.3.5
 Requires-Dist: python-dotenv>=1.0.0
 Requires-Dist: tree-sitter>=0.21.0
 Requires-Dist: tree-sitter-language-pack>=0.6.0
+Requires-Dist: tree-sitter-c-sharp>=0.21.0
 Requires-Dist: pyyaml
 Requires-Dist: nbformat
 Requires-Dist: nbconvert>=7.16.6
@@ -56,6 +57,7 @@ Requires-Dist: uvicorn>=0.22.0
 Provides-Extra: parsing
 Requires-Dist: tree-sitter>=0.21.0; extra == "parsing"
 Requires-Dist: tree-sitter-language-pack>=0.6.0; extra == "parsing"
+Requires-Dist: tree-sitter-c-sharp>=0.21.0; extra == "parsing"
 Provides-Extra: dev
 Requires-Dist: pytest>=7.4.0; extra == "dev"
 Requires-Dist: black>=23.11.0; extra == "dev"
@@ -160,7 +162,7 @@ A powerful **MCP server** and **CLI toolkit** that indexes local code into a gra
 ---
 
 ## Project Details
-- **Version:** 0.3.3
+- **Version:** 0.3.5
 - **Authors:** Shashank Shekhar Singh <shashankshekharsingh1205@gmail.com>
 - **License:** MIT License (See [LICENSE](LICENSE) for details)
 - **Website:** [CodeGraphContext](http://codegraphcontext.vercel.app/)
@@ -247,7 +249,7 @@ _If you’re using CodeGraphContext in your project, feel free to open a PR and
 - `stdlibs>=2023.11.18`
 - `typer[all]>=0.9.0`
 - `rich>=13.7.0`
-- `inquirerpy>=0.3.4`
+- `inquirerpy>=0.3.5`
 - `python-dotenv>=1.0.0`
 - `tree-sitter>=0.21.0`
 - `tree-sitter-language-pack>=0.6.0`

{codegraphcontext-0.3.3.dist-info → codegraphcontext-0.3.5.dist-info}/RECORD

@@ -4,7 +4,7 @@ codegraphcontext/prompts.py,sha256=E5P55paM0oHfBcNVfxkxpXRGZnya1kr_mKDg9i49FwM,6
 codegraphcontext/server.py,sha256=gcb6V4x0Oh8haBOCm2WBjTCO9FDukrSalAMMApL-oc8,12806
 codegraphcontext/tool_definitions.py,sha256=_0ahezQSURX_ewWydT2sFcvC6OFGdMoPA7KwgWNVcks,11482
 codegraphcontext/cli/__init__.py,sha256=v6CMDVKM5d_sXn3S5nZNf0phXn0IdrnhLazUoen9k9w,38
-codegraphcontext/cli/cli_helpers.py,sha256=8T7oMy6bBvQtfDjhQik5kKKkkyqWxeG4sXzeM8n-uxI,28374
+codegraphcontext/cli/cli_helpers.py,sha256=QcpEV9VRFuPiiIEUwiXCr_nm7Z7amzphXv9zQY0aWIU,29646
 codegraphcontext/cli/config_manager.py,sha256=MK7GMGZ4hd8-ZOShXBd_KDtNqHQ3ngdbef5KM_naPrQ,15899
 codegraphcontext/cli/main.py,sha256=89jWaO8Gr3nRdLQtfwF434wpU77d5bJwt016f_lLnGg,86486
 codegraphcontext/cli/registry_commands.py,sha256=30rJm4SeS0n1jax4JVuhuv4zYLzyMmlHcCSnsDDhgc8,19964
@@ -24,7 +24,7 @@ codegraphcontext/core/watcher.py,sha256=42AWDv7LUE5v_HlY_Rvvlk8deDdlUBvM3hI-DMDW
 codegraphcontext/tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 codegraphcontext/tools/advanced_language_query_tool.py,sha256=APtC-KSkXXSrVLwiw3kgi6Q-xaqXl6skLWHPyuNh358,3670
 codegraphcontext/tools/code_finder.py,sha256=2wd05dMrPW8xZDBUixS4BaipNbrE4rttqSD6JYEeQM4,55552
-codegraphcontext/tools/graph_builder.py,sha256=tKg_unJ3NumOpxv4WEdC0b9_pk6YXrxtBOY8v0eXJNs,78876
+codegraphcontext/tools/graph_builder.py,sha256=FaEeXQP5gdDclrXKjhWiwbmWXBEPadmqdeHZ2bWLK5A,81339
 codegraphcontext/tools/package_resolver.py,sha256=KtbdMReTezszjdsqYniL-Xb-QUsrAJWtf1NSiyIPkLI,18704
 codegraphcontext/tools/scip_indexer.py,sha256=gxe5-f090wonHEWYDT1CV6b3SpSTQtwng6A1SfPX_LA,19970
 codegraphcontext/tools/scip_pb2.py,sha256=dwOMNKlu6VyLq5h8kTPZRDqxrwfVL8yw7I7ziokFG48,98229
@@ -71,10 +71,10 @@ codegraphcontext/tools/query_tool_languages/typescript_toolkit.py,sha256=3S4hpmO
 codegraphcontext/utils/debug_log.py,sha256=Qg7jwyeg7x2h3Ur_2S34bdMCkHdlk_ngHfPwa97A9vE,2836
 codegraphcontext/utils/tree_sitter_manager.py,sha256=bIuKYN1aj1Zi6BnksGjZSLZzgBwuFRselZzyUpbToAU,9180
 codegraphcontext/utils/visualize_graph.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-codegraphcontext/viz/server.py,sha256=f2xjgkjMOBgrZd5fZ6kCEO-lzH9hNfPPCcSwfitH4io,6719
-codegraphcontext-0.3.3.dist-info/licenses/LICENSE,sha256=Btzdu2kIoMbdSp6OyCLupB1aRgpTCJ_szMimgEnpkkE,1056
-codegraphcontext-0.3.3.dist-info/METADATA,sha256=pw9ykqFiZCaX1PioazQoU9S_Kmb7BRRAuPjveWyykk4,21579
-codegraphcontext-0.3.3.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
-codegraphcontext-0.3.3.dist-info/entry_points.txt,sha256=LCxWCWMshdvYGoHBPuQZ8C-e4CiNSHCLXofrNSGHkoE,103
-codegraphcontext-0.3.3.dist-info/top_level.txt,sha256=CBgc6LAPZIO5FS0nSYYkylDifHsZTIqw3Gf5UwDxeGI,17
-codegraphcontext-0.3.3.dist-info/RECORD,,
+codegraphcontext/viz/server.py,sha256=Yu4fwMC2FsE6KUt7oYNlcE3GpCrblstkwUIVaGXTPYI,12767
+codegraphcontext-0.3.5.dist-info/licenses/LICENSE,sha256=Btzdu2kIoMbdSp6OyCLupB1aRgpTCJ_szMimgEnpkkE,1056
+codegraphcontext-0.3.5.dist-info/METADATA,sha256=rkKzmh5bAjIJNVO_ShCsjn54nCb2dCOySSpT9Ptlo_Y,21685
+codegraphcontext-0.3.5.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+codegraphcontext-0.3.5.dist-info/entry_points.txt,sha256=LCxWCWMshdvYGoHBPuQZ8C-e4CiNSHCLXofrNSGHkoE,103
+codegraphcontext-0.3.5.dist-info/top_level.txt,sha256=CBgc6LAPZIO5FS0nSYYkylDifHsZTIqw3Gf5UwDxeGI,17
+codegraphcontext-0.3.5.dist-info/RECORD,,