codespine 0.1.4__tar.gz → 0.1.7__tar.gz

{codespine-0.1.4 → codespine-0.1.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codespine
-Version: 0.1.4
+Version: 0.1.7
 Summary: Local Java code intelligence indexer backed by a graph database
 Author: CodeSpine contributors
 License: MIT License

{codespine-0.1.4 → codespine-0.1.7}/codespine/__init__.py

@@ -1,4 +1,4 @@
 """CodeSpine package."""
 
 __all__ = ["__version__"]
-__version__ = "0.1.0"
+__version__ = "0.1.7"

{codespine-0.1.4 → codespine-0.1.7}/codespine/cli.py

@@ -78,7 +78,8 @@ def main() -> None:
 @main.command()
 @click.argument("path", type=click.Path(exists=True))
 @click.option("--full/--incremental", default=True, show_default=True)
-def analyse(path: str, full: bool) -> None:
+@click.option("--deep/--no-deep", default=False, show_default=True, help="Run expensive global analyses.")
+def analyse(path: str, full: bool, deep: bool) -> None:
     """Index a local Java project."""
     if _is_running():
         click.secho("Stop MCP first ('codespine stop') to index.", fg="yellow")
@@ -88,31 +89,101 @@ def analyse(path: str, full: bool) -> None:
     abs_path = os.path.abspath(path)
     store = GraphStore(read_only=False)
     indexer = JavaIndexer(store)
-
-    result = indexer.index_project(abs_path, full=full)
-    _phase("Walking files...", f"{result.files_found} files found")
-    _phase("Parsing code...", f"{result.files_indexed}/{result.files_found}")
-    _phase("Tracing calls...", f"{result.calls_resolved} calls resolved")
-    _phase("Analyzing types...", f"{result.type_relationships} type relationships")
-
-    communities = detect_communities(store)
-    _phase("Detecting communities...", f"{len(communities)} clusters found")
-
-    flows = trace_execution_flows(store)
-    _phase("Detecting execution flows...", f"{len(flows)} processes found")
-
-    dead = detect_dead_code(store, limit=500)
-    _phase("Finding dead code...", f"{len(dead)} unreachable symbols")
-
-    coupling_pairs = compute_coupling(
-        store,
-        abs_path,
-        result.project_id,
-        months=SETTINGS.default_coupling_months,
-        min_strength=SETTINGS.default_min_coupling_strength,
-        min_cochanges=SETTINGS.default_min_cochanges,
-    )
-    _phase("Analyzing git history...", f"{len(coupling_pairs)} coupled file pairs")
+    parse_state = {"shown": False, "indexed": 0, "total": 0, "last_ts": 0.0}
+    call_state = {"shown": False, "count": 0, "last_ts": 0.0}
+
+    def _progress(event: str, payload: dict) -> None:
+        now = time.perf_counter()
+        if event == "scan_done":
+            _phase("Walking files...", f"{int(payload.get('files_found', 0))} files found")
+            return
+        if event == "plan_done":
+            to_index = int(payload.get("files_to_index", 0))
+            deleted = int(payload.get("deleted_files", 0))
+            mode = str(payload.get("mode", "incremental"))
+            parse_state["total"] = to_index
+            _phase("Index mode...", f"{mode} ({to_index} files to index, {deleted} deleted)")
+            if to_index == 0:
+                _phase("Parsing code...", "0/0")
+            return
+        if event == "parse_progress":
+            indexed = int(payload.get("indexed", 0))
+            total = int(payload.get("total", 0))
+            parse_state["indexed"] = indexed
+            parse_state["total"] = total
+            if total == 0:
+                return
+            if indexed == total or (now - parse_state["last_ts"]) >= 0.2:
+                click.echo(f"\rParsing code...                {indexed}/{total}", nl=False)
+                parse_state["shown"] = True
+                parse_state["last_ts"] = now
+            return
+        if event == "resolve_calls_start" and parse_state["shown"]:
+            click.echo()
+            parse_state["shown"] = False
+            _phase("Tracing calls...", "running")
+            return
+        if event == "resolve_calls_start":
+            _phase("Tracing calls...", "running")
+            return
+        if event == "resolve_calls_progress":
+            call_state["count"] = int(payload.get("calls_resolved", 0))
+            if (now - call_state["last_ts"]) >= 0.25:
+                click.echo(f"\rTracing calls...               {call_state['count']} resolved", nl=False)
+                call_state["shown"] = True
+                call_state["last_ts"] = now
+            return
+        if event == "resolve_calls_done":
+            if call_state["shown"]:
+                click.echo()
+            call_state["shown"] = False
+            _phase("Tracing calls...", f"{int(payload.get('calls_resolved', 0))} calls resolved")
+            return
+        if event == "resolve_types_start":
+            _phase("Analyzing types...", "running")
+            return
+        if event == "resolve_types_done":
+            _phase("Analyzing types...", f"{int(payload.get('type_relationships', 0))} type relationships")
+            return
+
+    result = indexer.index_project(abs_path, full=full, progress=_progress)
+    if parse_state["shown"]:
+        click.echo()
+    if parse_state["total"] == 0:
+        _phase("Parsing code...", "0/0")
+    elif parse_state["indexed"] < parse_state["total"]:
+        _phase("Parsing code...", f"{parse_state['indexed']}/{parse_state['total']}")
+
+    communities: list[dict] = []
+    flows: list[dict] = []
+    dead: list[dict] = []
+    coupling_pairs: list[dict] = []
+
+    should_run_deep = deep or result.files_found <= 1200
+    if should_run_deep:
+        communities = detect_communities(store)
+        _phase("Detecting communities...", f"{len(communities)} clusters found")
+
+        flows = trace_execution_flows(store)
+        _phase("Detecting execution flows...", f"{len(flows)} processes found")
+
+        dead = detect_dead_code(store, limit=500)
+        _phase("Finding dead code...", f"{len(dead)} unreachable symbols")
+
+        coupling_pairs = compute_coupling(
+            store,
+            abs_path,
+            result.project_id,
+            months=SETTINGS.default_coupling_months,
+            min_strength=SETTINGS.default_min_coupling_strength,
+            min_cochanges=SETTINGS.default_min_cochanges,
+        )
+        _phase("Analyzing git history...", f"{len(coupling_pairs)} coupled file pairs")
+    else:
+        _phase("Detecting communities...", "skipped (large repo; rerun with --deep)")
+        _phase("Detecting execution flows...", "skipped (large repo; rerun with --deep)")
+        _phase("Finding dead code...", "skipped (large repo; rerun with --deep)")
+        _phase("Analyzing git history...", "skipped (large repo; rerun with --deep)")
 
     vector_count = store.query_records(
         """

{codespine-0.1.4 → codespine-0.1.7}/codespine/indexer/call_resolver.py

@@ -1,9 +1,12 @@
 from __future__ import annotations
 
 from collections import defaultdict
+from typing import Iterator
 
 from codespine.noise.blocklist import NOISE_METHOD_NAMES
 
+MAX_FUZZY_TARGETS = 12
+
 
 def _simple_type_name(type_name: str | None) -> str:
     if not type_name:
@@ -53,10 +56,10 @@ def resolve_calls(
     calls: dict[str, list],
     method_context: dict[str, dict],
     class_catalog: dict[str, list[str]],
-) -> list[tuple[str, str, float, str]]:
+) -> Iterator[tuple[str, str, float, str]]:
     """Resolve call names to known method ids.
 
-    Returns tuples: (source_method_id, target_method_id, confidence, reason)
+    Yields tuples: (source_method_id, target_method_id, confidence, reason)
     """
     name_arity_to_method_ids: dict[tuple[str, int], list[str]] = defaultdict(list)
     class_method_index: dict[str, dict[tuple[str, int], list[str]]] = defaultdict(lambda: defaultdict(list))
@@ -65,7 +68,6 @@ def resolve_calls(
         name_arity_to_method_ids[key].append(method_id)
         class_method_index[meta["class_fqcn"]][key].append(method_id)
 
-    edges: list[tuple[str, str, float, str]] = []
     for source_id, call_sites in calls.items():
         src_meta = method_catalog.get(source_id, {})
         src_ctx = method_context.get(source_id, {})
@@ -126,12 +128,13 @@ def resolve_calls(
                     confidence = 1.0
                     reason = "exact_name_arity_unique"
                 elif len(targets) > 1:
+                    if len(targets) > MAX_FUZZY_TARGETS:
+                        # Avoid exploding low-confidence edges in large repos.
+                        continue
                     confidence = 0.5
                     reason = "fuzzy_name_arity_ambiguous"
 
             if not targets:
                 continue
-            for target_id in targets:
-                edges.append((source_id, target_id, confidence, reason))
-
-    return edges
+            for target_id in set(targets):
+                yield source_id, target_id, confidence, reason

{codespine-0.1.4 → codespine-0.1.7}/codespine/indexer/engine.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import os
 from dataclasses import dataclass
+from typing import Callable
 
 from codespine.indexer.call_resolver import resolve_calls
 from codespine.indexer.java_parser import parse_java_source
@@ -25,12 +26,18 @@ class JavaIndexer:
     def __init__(self, store):
         self.store = store
 
-    def index_project(self, root_path: str, full: bool = True) -> IndexResult:
+    def index_project(
+        self,
+        root_path: str,
+        full: bool = True,
+        progress: Callable[[str, dict], None] | None = None,
+    ) -> IndexResult:
         root_path = os.path.abspath(root_path)
         project_id = os.path.basename(root_path)
         current_files = self._collect_java_files(root_path)
-        current_hashes = self._hash_files(project_id, root_path, current_files)
+        self._emit(progress, "scan_done", files_found=len(current_files))
         db_files = self.store.project_file_hashes(project_id) if not full else {}
+        current_hashes = self._hash_files(project_id, root_path, current_files) if not full else {}
 
         if full:
             to_reindex = current_files
@@ -45,6 +52,13 @@ class JavaIndexer:
                 old = db_files.get(fid, {}).get("hash")
                 if old != digest:
                     to_reindex.append(file_path)
+        self._emit(
+            progress,
+            "plan_done",
+            files_to_index=len(to_reindex),
+            deleted_files=len(deleted_file_ids),
+            mode="full" if full else "incremental",
+        )
 
         files_indexed = 0
         classes_indexed = 0
@@ -151,12 +165,25 @@ class JavaIndexer:
                         }
                         class_methods[cls.fqcn][method.signature] = m_id
                 files_indexed += 1
+                self._emit(
+                    progress,
+                    "parse_progress",
+                    indexed=files_indexed,
+                    total=len(to_reindex),
+                    file_path=file_path,
+                )
 
+            self._emit(progress, "resolve_calls_start")
             for src, dst, confidence, reason in resolve_calls(method_catalog, method_calls, method_context, class_catalog):
                 self.store.add_call(src, dst, confidence, reason)
                 calls_resolved += 1
+                if calls_resolved % 2000 == 0:
+                    self._emit(progress, "resolve_calls_progress", calls_resolved=calls_resolved)
+            self._emit(progress, "resolve_calls_done", calls_resolved=calls_resolved)
 
+            self._emit(progress, "resolve_types_start")
             type_relationships += self._build_inheritance_edges(class_meta, class_catalog, class_methods)
+            self._emit(progress, "resolve_types_done", type_relationships=type_relationships)
 
         return IndexResult(
             project_id=project_id,
@@ -172,10 +199,11 @@ class JavaIndexer:
     @staticmethod
     def _collect_java_files(root_path: str) -> list[str]:
         out: list[str] = []
-        for root, _, files in os.walk(root_path):
-            if "src" not in root:
-                continue
-            if any(skip in root for skip in ["target", "build", "out", ".git"]):
+        skip_dirs = {".git", "target", "build", "out", ".idea", ".gradle", ".mvn", "node_modules"}
+        for root, dirs, files in os.walk(root_path, topdown=True):
+            dirs[:] = [d for d in dirs if d not in skip_dirs]
+            normalized = root.replace("\\", "/")
+            if "/src/" not in normalized and not normalized.endswith("/src"):
                 continue
             for filename in files:
                 if filename.endswith(".java"):
@@ -303,3 +331,9 @@ class JavaIndexer:
                             self.store.add_reference("OVERRIDES", "Method", method_id, "Method", iface_method, 1.0)
                             rel_count += 1
         return rel_count
+
+    @staticmethod
+    def _emit(progress: Callable[[str, dict], None] | None, event: str, **payload: object) -> None:
+        if progress is None:
+            return
+        progress(event, payload)

{codespine-0.1.4 → codespine-0.1.7}/codespine.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codespine
-Version: 0.1.4
+Version: 0.1.7
 Summary: Local Java code intelligence indexer backed by a graph database
 Author: CodeSpine contributors
 License: MIT License

{codespine-0.1.4 → codespine-0.1.7}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "codespine"
-version = "0.1.4"
+version = "0.1.7"
 description = "Local Java code intelligence indexer backed by a graph database"
 readme = "README.md"
 requires-python = ">=3.10"