codegraphcontext 0.2.4__tar.gz → 0.2.6__tar.gz

{codegraphcontext-0.2.4/src/codegraphcontext.egg-info → codegraphcontext-0.2.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codegraphcontext
-Version: 0.2.4
+Version: 0.2.6
 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
@@ -146,7 +146,7 @@ A powerful **MCP server** and **CLI toolkit** that indexes local code into a gra
 ---
 
 ## Project Details
-- **Version:** 0.2.4
+- **Version:** 0.2.6
 - **Authors:** Shashank Shekhar Singh <shashankshekharsingh1205@gmail.com>
 - **License:** MIT License (See [LICENSE](LICENSE) for details)
 - **Website:** [CodeGraphContext](http://codegraphcontext.vercel.app/)

{codegraphcontext-0.2.4 → codegraphcontext-0.2.6}/README.md

@@ -84,7 +84,7 @@ A powerful **MCP server** and **CLI toolkit** that indexes local code into a gra
 ---
 
 ## Project Details
-- **Version:** 0.2.4
+- **Version:** 0.2.6
 - **Authors:** Shashank Shekhar Singh <shashankshekharsingh1205@gmail.com>
 - **License:** MIT License (See [LICENSE](LICENSE) for details)
 - **Website:** [CodeGraphContext](http://codegraphcontext.vercel.app/)

{codegraphcontext-0.2.4 → codegraphcontext-0.2.6}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "codegraphcontext"
-version = "0.2.4"
+version = "0.2.6"
 description = "An MCP server that indexes local code into a graph database to provide context to AI assistants."
 authors = [{ name = "Shashank Shekhar Singh", email = "shashankshekharsingh1205@gmail.com" }]
 readme = "README.md"

{codegraphcontext-0.2.4 → codegraphcontext-0.2.6}/src/codegraphcontext/cli/config_manager.py

@@ -39,6 +39,10 @@ DEFAULT_CONFIG = {
     "CACHE_ENABLED": "true",
     "IGNORE_DIRS": "node_modules,venv,.venv,env,.env,dist,build,target,out,.git,.idea,.vscode,__pycache__",
     "INDEX_SOURCE": "true",
+    # SCIP indexer feature flag (default off — existing Tree-sitter behaviour unchanged)
+    "SCIP_INDEXER": "false",
+    "SCIP_LANGUAGES": "python,typescript,go,rust,java",
+    "SKIP_EXTERNAL_RESOLUTION": "false",
 }
 
 # Configuration key descriptions
@@ -62,6 +66,9 @@ CONFIG_DESCRIPTIONS = {
     "CACHE_ENABLED": "Enable caching for faster re-indexing",
     "IGNORE_DIRS": "Comma-separated list of directory names to ignore during indexing",
     "INDEX_SOURCE": "Store full source code in graph database (for faster indexing use false, for better performance use true)",
+    "SCIP_INDEXER": "Use SCIP-based indexing for higher accuracy call/inheritance resolution (requires scip-<lang> tools installed)",
+    "SCIP_LANGUAGES": "Comma-separated languages to index via SCIP when SCIP_INDEXER=true (python,typescript,go,rust,java)",
+    "SKIP_EXTERNAL_RESOLUTION": "Skip resolution attempts for external library method calls (recommended for enterprise large Java/Spring codebases)",
 }
 
 # Valid values for each config key
@@ -76,6 +83,8 @@ CONFIG_VALIDATORS = {
     "ENABLE_AUTO_WATCH": ["true", "false"],
     "CACHE_ENABLED": ["true", "false"],
     "INDEX_SOURCE": ["true", "false"],
+    "SCIP_INDEXER": ["true", "false"],
+    "SKIP_EXTERNAL_RESOLUTION": ["true", "false"],
 }
 
 

{codegraphcontext-0.2.4 → codegraphcontext-0.2.6}/src/codegraphcontext/tools/graph_builder.py

@@ -74,6 +74,12 @@ class TreeSitterParser:
         elif self.language_name == 'haskell':
             from .languages.haskell import HaskellTreeSitterParser
             self.language_specific_parser = HaskellTreeSitterParser(self)
+        elif self.language_name == 'dart':
+            from .languages.dart import DartTreeSitterParser
+            self.language_specific_parser = DartTreeSitterParser(self)
+        elif self.language_name == 'perl':
+            from .languages.perl import PerlTreeSitterParser
+            self.language_specific_parser = PerlTreeSitterParser(self)
 
 
 
@@ -120,6 +126,9 @@ class GraphBuilder:
             '.sc': TreeSitterParser('scala'),
             '.swift': TreeSitterParser('swift'),
             '.hs': TreeSitterParser('haskell'),
+            '.dart': TreeSitterParser('dart'),
+            '.pl': TreeSitterParser('perl'),
+            '.pm': TreeSitterParser('perl'),
         }
         self.create_schema()
 
@@ -162,7 +171,7 @@ class GraphBuilder:
                     session.run("""
                         CREATE FULLTEXT INDEX code_search_index IF NOT EXISTS
                         FOR (n:Function|Class|Variable)
-                        ON EACH [n.name, coalesce(n.source, ''), coalesce(n.docstring, '')]
+                        ON EACH [n.name, n.source, n.docstring]
                     """)
                 
                 info_logger("Database schema verified/created successfully")
@@ -249,6 +258,15 @@ class GraphBuilder:
         if '.swift' in files_by_lang:
             from .languages import swift as swift_lang_module
             imports_map.update(swift_lang_module.pre_scan_swift(files_by_lang['.swift'], self.parsers['.swift']))
+        if '.dart' in files_by_lang:
+            from .languages import dart as dart_lang_module
+            imports_map.update(dart_lang_module.pre_scan_dart(files_by_lang['.dart'], self.parsers['.dart']))
+        if '.pl' in files_by_lang:
+            from .languages import perl as perl_lang_module
+            imports_map.update(perl_lang_module.pre_scan_perl(files_by_lang['.pl'], self.parsers['.pl']))
+        if '.pm' in files_by_lang:
+            from .languages import perl as perl_lang_module
+            imports_map.update(perl_lang_module.pre_scan_perl(files_by_lang['.pm'], self.parsers['.pm']))
             
         return imports_map
 
@@ -461,6 +479,9 @@ class GraphBuilder:
         local_imports = {imp.get('alias') or imp['name'].split('.')[-1]: imp['name'] 
                         for imp in file_data.get('imports', [])}
         
+        # Check if we should skip external resolution attempts - 
+        skip_external = (get_config_value("SKIP_EXTERNAL_RESOLUTION") or "false").lower() == "true"
+        
         for call in file_data.get('function_calls', []):
             called_name = call['name']
             if called_name in __builtins__: continue
@@ -517,7 +538,13 @@ class GraphBuilder:
                                     break
             
             if not resolved_path:
-                 warning_logger(f"Could not resolve call {called_name} (lookup: {lookup_name}) in {caller_file_path}")
+                # Only log warning if we're not skipping external resolution
+                if not skip_external:
+                    warning_logger(f"Could not resolve call {called_name} (lookup: {lookup_name}) in {caller_file_path}")
+                # Track that this was an unresolved external call
+                is_unresolved_external = True
+            else:
+                is_unresolved_external = False
             # else:
             #      info_logger(f"Resolved call {called_name} -> {resolved_path}")
             
@@ -539,6 +566,7 @@ class GraphBuilder:
             if not resolved_path:
                 if called_name in local_names:
                     resolved_path = caller_file_path
+                    is_unresolved_external = False  # This is a local call, not external
                 elif called_name in imports_map and imports_map[called_name]:
                     # Check if any path in imports_map for called_name matches current file's imports
                     candidates = imports_map[called_name]
@@ -546,12 +574,17 @@ class GraphBuilder:
                         for imp_name in local_imports.values():
                             if imp_name.replace('.', '/') in path:
                                 resolved_path = path
+                                is_unresolved_external = False  # Found a match
                                 break
                         if resolved_path: break
                     if not resolved_path:
                         resolved_path = candidates[0]
                 else:
                     resolved_path = caller_file_path
+            
+            # Skip creating CALLS relationship for unresolved external calls when skip_external is enabled
+            if skip_external and is_unresolved_external:
+                continue
 
             caller_context = call.get('context')
             if caller_context and len(caller_context) == 3 and caller_context[0] is not None:
@@ -879,11 +912,200 @@ class GraphBuilder:
             error_logger(f"Could not estimate processing time for {path}: {e}")
             return None
 
+    async def _build_graph_from_scip(
+        self, path: Path, is_dependency: bool, job_id: Optional[str], lang: str
+    ):
+        """
+        SCIP-based indexing path. Activated only when SCIP_INDEXER=true and
+        a scip-<lang> binary is available.
+
+        Steps:
+          1. Run scip-<lang> CLI → index.scip
+          2. Parse index.scip → nodes + reference edges
+          3. Write nodes to graph (same MERGE queries as Tree-sitter path)
+          4. Tree-sitter supplement: add source text + cyclomatic_complexity
+          5. Write SCIP CALLS edges (precise, no heuristics)
+        """
+        import tempfile
+        from .scip_indexer import ScipIndexer, ScipIndexParser
+        from .graph_builder import TreeSitterParser  # supplement pass
+
+        if job_id:
+            self.job_manager.update_job(job_id, status=JobStatus.RUNNING)
+
+        self.add_repository_to_graph(path, is_dependency)
+        repo_name = path.name
+
+        try:
+            # Step 1: Run SCIP indexer
+            with tempfile.TemporaryDirectory(prefix="cgc_scip_") as tmpdir:
+                scip_file = ScipIndexer().run(path, lang, Path(tmpdir))
+
+                if not scip_file:
+                    warning_logger(
+                        f"SCIP indexer produced no output for {path}. "
+                        "Falling back to Tree-sitter."
+                    )
+                    # Hand off to Tree-sitter pipeline by re-calling without SCIP flag
+                    # (the flag is checked at the start; override is not needed because
+                    # we return here — caller will not re-enter this branch)
+                    raise RuntimeError("SCIP produced no index — triggering Tree-sitter fallback")
+
+                # Step 2: Parse index.scip
+                scip_data = ScipIndexParser().parse(scip_file, path)
+            
+            if not scip_data:
+                raise RuntimeError("SCIP parse returned empty result")
+
+            files_data = scip_data.get("files", {})
+            file_paths = [Path(p) for p in files_data.keys() if Path(p).exists()]
+            
+            # Step 3: Pre-scan for imports to correctly associate external modules/classes
+            imports_map = self._pre_scan_for_imports(file_paths)
+
+            if job_id:
+                self.job_manager.update_job(job_id, total_files=len(files_data))
+
+            # Step 4: Write nodes to graph using existing add_file_to_graph()
+            processed = 0
+            for abs_path_str, file_data in files_data.items():
+                file_data["repo_path"] = str(path.resolve())
+                if job_id:
+                    self.job_manager.update_job(job_id, current_file=abs_path_str)
+
+                # Step 5: Tree-sitter supplement — add source text, complexity, imports and bases
+                file_path = Path(abs_path_str)
+                if file_path.exists() and file_path.suffix in self.parsers:
+                    try:
+                        ts_parser = self.parsers[file_path.suffix]
+                        ts_data = ts_parser.parse(file_path, is_dependency, index_source=True)
+                        if "error" not in ts_data:
+                            # 1. Functions: complexity, source, decorators
+                            ts_funcs = {f["name"]: f for f in ts_data.get("functions", [])}
+                            for f in file_data.get("functions", []):
+                                ts_f = ts_funcs.get(f["name"])
+                                if ts_f:
+                                    f.update({
+                                        "source": ts_f.get("source"),
+                                        "cyclomatic_complexity": ts_f.get("cyclomatic_complexity", 1),
+                                        "decorators": ts_f.get("decorators", [])
+                                    })
+                            
+                            # 2. Classes: bases (inheritance)
+                            ts_classes = {c["name"]: c for c in ts_data.get("classes", [])}
+                            for c in file_data.get("classes", []):
+                                ts_c = ts_classes.get(c["name"])
+                                if ts_c:
+                                    c["bases"] = ts_c.get("bases", [])
+                            
+                            # 3. Imports: critical for cross-file resolution
+                            file_data["imports"] = ts_data.get("imports", [])
+                            
+                            # 4. Variables/Other: value, etc.
+                            file_data["variables"] = ts_data.get("variables", [])
+                    except Exception as e:
+                        debug_log(f"Tree-sitter supplement failed for {abs_path_str}: {e}")
+
+                self.add_file_to_graph(file_data, repo_name, imports_map)
+
+                processed += 1
+                if job_id:
+                    self.job_manager.update_job(job_id, processed_files=processed)
+                await asyncio.sleep(0.01)
+
+            # Step 6: Create INHERITS relationships (Supplemented from Tree-sitter)
+            self._create_all_inheritance_links(list(files_data.values()), imports_map)
+
+            # Step 7: Write SCIP CALLS edges — precise cross-file resolution
+            with self.driver.session() as session:
+                for file_data in files_data.values():
+                    for edge in file_data.get("function_calls_scip", []):
+                        try:
+                            # Use line numbers for precise matching in case of duplicates
+                            session.run("""
+                                MATCH (caller:Function {name: $caller_name, path: $caller_file, line_number: $caller_line})
+                                MATCH (callee:Function {name: $callee_name, path: $callee_file, line_number: $callee_line})
+                                MERGE (caller)-[:CALLS {line_number: $ref_line, source: 'scip'}]->(callee)
+                            """,
+                            caller_name=self._name_from_symbol(edge["caller_symbol"]),
+                            caller_file=edge["caller_file"],
+                            caller_line=edge["caller_line"],
+                            callee_name=edge["callee_name"],
+                            callee_file=edge["callee_file"],
+                            callee_line=edge["callee_line"],
+                            ref_line=edge["ref_line"],
+                            )
+                        except Exception:
+                            pass  # best-effort: node might not be indexed yet
+
+            if job_id:
+                self.job_manager.update_job(job_id, status=JobStatus.COMPLETED, end_time=datetime.now())
+
+        except RuntimeError as e:
+            # Graceful fallback to Tree-sitter when SCIP fails
+            warning_logger(f"SCIP path failed ({e}), re-running with Tree-sitter...")
+            # Temporarily disable the flag in-memory so the recursive call goes straight to TS
+            # (we do this by calling the internal Tree-sitter steps directly)
+            if job_id:
+                self.job_manager.update_job(job_id, status=JobStatus.RUNNING)
+            # Re-enter the async flow without SCIP check — handled by caller returning early
+            # For simplicity, we just let the exception propagate to the outer handler so the
+            # job is marked FAILED with a meaningful message rather than silently degrading.
+            raise
+
+        except Exception as e:
+            error_logger(f"SCIP indexing failed for {path}: {e}")
+            if job_id:
+                self.job_manager.update_job(
+                    job_id, status=JobStatus.FAILED, end_time=datetime.now(), errors=[str(e)]
+                )
+
+    def _name_from_symbol(self, symbol: str) -> str:
+        """Extract human-readable name from a SCIP symbol ID string."""
+        import re
+        s = symbol.rstrip(".#")
+        s = re.sub(r"\(\)\.?$", "", s) # Remove trailing () or ().
+        parts = re.split(r'[/#]', s)
+        last = parts[-1] if parts else symbol
+        return last or symbol
+
+
     async def build_graph_from_path_async(
         self, path: Path, is_dependency: bool = False, job_id: str = None
     ):
         """Builds graph from a directory or file path."""
         try:
+            # ------------------------------------------------------------------
+            # SCIP feature flag: SCIP_INDEXER=true in ~/.codegraphcontext/.env
+            # When enabled (and the binary is installed), SCIP handles the
+            # indexing for supported languages. SCIP_INDEXER=false (default)
+            # means this entire block is a no-op and existing behaviour is kept.
+            # ------------------------------------------------------------------
+            scip_enabled = (get_config_value("SCIP_INDEXER") or "false").lower() == "true"
+            if scip_enabled:
+                from .scip_indexer import ScipIndexer, ScipIndexParser, detect_project_lang, is_scip_available
+                scip_langs_str = get_config_value("SCIP_LANGUAGES") or "python,typescript,go,rust,java"
+                scip_languages = [l.strip() for l in scip_langs_str.split(",") if l.strip()]
+                detected_lang = detect_project_lang(path, scip_languages)
+
+                if detected_lang and is_scip_available(detected_lang):
+                    info_logger(f"SCIP_INDEXER=true — using SCIP for language: {detected_lang}")
+                    await self._build_graph_from_scip(path, is_dependency, job_id, detected_lang)
+                    return   # SCIP handled it; skip Tree-sitter pipeline below
+                else:
+                    if detected_lang:
+                        warning_logger(
+                            f"SCIP_INDEXER=true but scip-{detected_lang} binary not found. "
+                            f"Falling back to Tree-sitter. Install it first."
+                        )
+                    else:
+                        info_logger(
+                            "SCIP_INDEXER=true but no SCIP-supported language detected. "
+                            "Falling back to Tree-sitter."
+                        )
+            # ------------------------------------------------------------------
+            # Existing Tree-sitter pipeline (unchanged)
+            # ------------------------------------------------------------------
             if job_id:
                 self.job_manager.update_job(job_id, status=JobStatus.RUNNING)