codespine 1.0.7__tar.gz → 1.0.9__tar.gz

{codespine-1.0.7 → codespine-1.0.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codespine
-Version: 1.0.7
+Version: 1.0.9
 Summary: Local Java code intelligence indexer backed by a graph database
 Author: CodeSpine contributors
 License: MIT License
@@ -124,8 +124,7 @@ Downloads and caches the embedding model. Only needed once. After this, `--embed
 codespine analyse /path/to/java-project
 
 # 2. (Optional) Run the expensive deep passes: communities, flows, dead code, coupling
-#    Auto-enabled for repos with ≤ 3,000 files; use --deep to force on larger repos.
-codespine analyse /path/to/java-project --deep
+codespine analyse /path/to/java-project --complete --deep
 
 # 3. (Optional) Add semantic embeddings for concept-level search
 codespine analyse /path/to/java-project --embed
@@ -313,8 +312,9 @@ Higher-level tools designed to answer full agent questions in a single call, wit
 # Indexing
 codespine analyse <path>                     # incremental index (default)
 codespine analyse <path> --full              # full re-index from scratch
-codespine analyse <path> --deep              # + communities, flows, dead code, coupling
-codespine analyse <path> --incremental-deep  # incremental index + force deep passes
+codespine analyse <path> --budget 90         # fast index with a resolver deadline
+codespine analyse <path> --complete --deep   # + communities, flows, dead code, coupling
+codespine analyse <path> --complete --incremental-deep
 codespine analyse <path> --embed             # + vector embeddings
 
 # Live watch
@@ -360,7 +360,7 @@ codespine force-reset                        # emergency: delete all data files
 
 `analyse` defaults to incremental mode. Repeat runs only process changed files and are fast.
 
-Deep analysis (`--deep`) now runs automatically for repos with ≤ 3,000 files. For larger repos, pass `--deep` explicitly. Use `--incremental-deep` when you want a fast file-only update but still want communities, flows, dead code, and coupling refreshed.
+`analyse` runs in fast mode by default: it indexes the core graph, publishes that read replica from a detached process, then continues communities, flows, dead code, coupling, and cross-module enrichment in the background. Use `--complete --deep` when you want those passes refreshed before the command returns.
 
 ---
 
@@ -546,12 +546,12 @@ The deep analysis phase covers four passes that are expensive but optional:
 | Dead code | Finds methods with no callers (Java-aware exemptions) | Cleanup audits |
 | Change coupling | Analyses git history for co-changed file pairs | `get_change_coupling`, `related` |
 
-**Auto-threshold:** deep analysis runs automatically when the project has ≤ 3,000 Java files. Larger repos get lightweight flow/dead-code passes; full deep analysis requires `--deep`.
+**Fast default:** `codespine analyse` prioritizes a queryable core index. Communities, flows, dead-code, git coupling, and cross-module links are queued in a detached background enrichment job unless you use `--complete`.
 
-**Incremental deep:** `--incremental-deep` combines incremental file indexing with a forced full deep pass — useful after large refactors where you want the call graph refreshed quickly but also want updated communities and coupling.
+**Complete deep:** `--complete --deep` runs the expensive enrichment passes before returning. `--complete --incremental-deep` combines incremental file indexing with a forced full deep pass.
 
 ```bash
-codespine analyse . --incremental-deep
+codespine analyse . --complete --incremental-deep
 ```
 
 **Embeddings** (`--embed`) are independent of deep analysis. Without them, BM25 + fuzzy search still works. Add embeddings when you need concept-level retrieval ("find retry logic", "find payment processing").

{codespine-1.0.7 → codespine-1.0.9}/README.md

@@ -59,8 +59,7 @@ Downloads and caches the embedding model. Only needed once. After this, `--embed
 codespine analyse /path/to/java-project
 
 # 2. (Optional) Run the expensive deep passes: communities, flows, dead code, coupling
-#    Auto-enabled for repos with ≤ 3,000 files; use --deep to force on larger repos.
-codespine analyse /path/to/java-project --deep
+codespine analyse /path/to/java-project --complete --deep
 
 # 3. (Optional) Add semantic embeddings for concept-level search
 codespine analyse /path/to/java-project --embed
@@ -248,8 +247,9 @@ Higher-level tools designed to answer full agent questions in a single call, wit
 # Indexing
 codespine analyse <path>                     # incremental index (default)
 codespine analyse <path> --full              # full re-index from scratch
-codespine analyse <path> --deep              # + communities, flows, dead code, coupling
-codespine analyse <path> --incremental-deep  # incremental index + force deep passes
+codespine analyse <path> --budget 90         # fast index with a resolver deadline
+codespine analyse <path> --complete --deep   # + communities, flows, dead code, coupling
+codespine analyse <path> --complete --incremental-deep
 codespine analyse <path> --embed             # + vector embeddings
 
 # Live watch
@@ -295,7 +295,7 @@ codespine force-reset                        # emergency: delete all data files
 
 `analyse` defaults to incremental mode. Repeat runs only process changed files and are fast.
 
-Deep analysis (`--deep`) now runs automatically for repos with ≤ 3,000 files. For larger repos, pass `--deep` explicitly. Use `--incremental-deep` when you want a fast file-only update but still want communities, flows, dead code, and coupling refreshed.
+`analyse` runs in fast mode by default: it indexes the core graph, publishes that read replica from a detached process, then continues communities, flows, dead code, coupling, and cross-module enrichment in the background. Use `--complete --deep` when you want those passes refreshed before the command returns.
 
 ---
 
@@ -481,12 +481,12 @@ The deep analysis phase covers four passes that are expensive but optional:
 | Dead code | Finds methods with no callers (Java-aware exemptions) | Cleanup audits |
 | Change coupling | Analyses git history for co-changed file pairs | `get_change_coupling`, `related` |
 
-**Auto-threshold:** deep analysis runs automatically when the project has ≤ 3,000 Java files. Larger repos get lightweight flow/dead-code passes; full deep analysis requires `--deep`.
+**Fast default:** `codespine analyse` prioritizes a queryable core index. Communities, flows, dead-code, git coupling, and cross-module links are queued in a detached background enrichment job unless you use `--complete`.
 
-**Incremental deep:** `--incremental-deep` combines incremental file indexing with a forced full deep pass — useful after large refactors where you want the call graph refreshed quickly but also want updated communities and coupling.
+**Complete deep:** `--complete --deep` runs the expensive enrichment passes before returning. `--complete --incremental-deep` combines incremental file indexing with a forced full deep pass.
 
 ```bash
-codespine analyse . --incremental-deep
+codespine analyse . --complete --incremental-deep
 ```
 
 **Embeddings** (`--embed`) are independent of deep analysis. Without them, BM25 + fuzzy search still works. Add embeddings when you need concept-level retrieval ("find retry logic", "find payment processing").

{codespine-1.0.7 → codespine-1.0.9}/codespine/__init__.py

@@ -1,4 +1,4 @@
 """CodeSpine package."""
 
 __all__ = ["__version__"]
-__version__ = "1.0.7"
+__version__ = "1.0.9"

{codespine-1.0.7 → codespine-1.0.9}/codespine/cli.py

@@ -66,6 +66,24 @@ def _open_store(read_only: bool = True) -> ShardedGraphStore:
     return ShardedGraphStore(read_only=read_only)
 
 
+def _spawn_background_enrichment(path: str) -> bool:
+    """Publish the fast index, then enrich it in a detached process."""
+    try:
+        subprocess.Popen(
+            [sys.executable, "-m", "codespine.cli", "enrich-background", path],
+            stdin=subprocess.DEVNULL,
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+            start_new_session=True,
+            cwd=os.getcwd(),
+            env=os.environ.copy(),
+        )
+        return True
+    except Exception as exc:  # noqa: BLE001
+        LOGGER.warning("Unable to spawn background enrichment: %s", exc)
+        return False
+
+
 def _db_size_bytes(path: str) -> int:
     if os.path.isfile(path):
         return os.path.getsize(path)
@@ -110,6 +128,7 @@ def _index_shard_group(
     sg,
     full: bool,
     embed: bool,
+    deadline: float | None,
     output_lock: threading.Lock,
     parallel: bool,
 ) -> tuple[int, list, int]:
@@ -145,6 +164,10 @@ def _index_shard_group(
         }
         call_state: dict = {"shown": False, "count": 0, "last_ts": 0.0,
                              "started_at": 0.0}
+        db_state: dict = {
+            "shown": False, "done": 0, "total": 0, "last_ts": 0.0,
+            "started_at": 0.0,
+        }
 
         def _progress(event: str, payload: dict) -> None:
             now = time.perf_counter()
@@ -237,11 +260,101 @@ def _index_shard_group(
                     parse_state["shown"] = True
                     parse_state["last_ts"] = now
                 return
-            if event in ("resolve_calls_start",):
+            if event == "db_write_start":
                 if parse_state["shown"]:
                     with output_lock:
                         click.echo()
                     parse_state["shown"] = False
+                total = int(payload.get("total", 0))
+                deleted = int(payload.get("deleted_files", 0))
+                db_state["done"] = 0
+                db_state["total"] = total
+                db_state["started_at"] = now
+                status = f"starting ({total} files"
+                if deleted:
+                    status += f", {deleted} deleted"
+                status += ")"
+                with output_lock:
+                    _phase(f"{prefix}Writing index...", status)
+                return
+            if event == "db_write_heartbeat":
+                done = int(payload.get("done", 0))
+                total = int(payload.get("total", 0))
+                classes = int(payload.get("classes", 0))
+                methods = int(payload.get("methods", 0))
+                phase = str(payload.get("phase", "writing"))
+                elapsed_s = float(payload.get("elapsed", 0.0))
+                db_state["done"] = done
+                db_state["total"] = total
+                if not parallel:
+                    click.echo(
+                        f"\r{_spinner_char()} {prefix}Writing index...   "
+                        f"{_bar(done, total)} {done}/{total}  "
+                        f"{classes} classes / {methods} methods  "
+                        f"{phase[:18]:<18} {elapsed_s:.0f}s  ",
+                        nl=False,
+                    )
+                else:
+                    with output_lock:
+                        click.echo(
+                            f"\r{prefix}Writing {done}/{total} "
+                            f"({classes} classes, {methods} methods, {elapsed_s:.0f}s)  ",
+                            nl=False,
+                        )
+                db_state["shown"] = True
+                db_state["last_ts"] = now
+                return
+            if event == "db_write_progress":
+                done = int(payload.get("done", 0))
+                total = int(payload.get("total", 0))
+                classes = int(payload.get("classes", 0))
+                methods = int(payload.get("methods", 0))
+                phase = str(payload.get("phase", "writing"))
+                db_state["done"] = done
+                db_state["total"] = total
+                if total == 0 and done == 0:
+                    return
+                if done == total or (now - db_state["last_ts"]) >= 0.25:
+                    elapsed_s = now - db_state["started_at"]
+                    if not parallel:
+                        click.echo(
+                            f"\r{_spinner_char()} {prefix}Writing index...   "
+                            f"{_bar(done, total)} {done}/{total}  "
+                            f"{classes} classes / {methods} methods  "
+                            f"{phase[:18]:<18} {elapsed_s:.0f}s  ",
+                            nl=False,
+                        )
+                    else:
+                        with output_lock:
+                            click.echo(
+                                f"\r{prefix}Writing {done}/{total} "
+                                f"({classes} classes, {methods} methods, {elapsed_s:.0f}s)  ",
+                                nl=False,
+                            )
+                    db_state["shown"] = True
+                    db_state["last_ts"] = now
+                return
+            if event == "db_write_done":
+                if db_state["shown"]:
+                    with output_lock:
+                        click.echo()
+                db_state["shown"] = False
+                files = int(payload.get("files_indexed", db_state["done"]))
+                classes = int(payload.get("classes", 0))
+                methods = int(payload.get("methods", 0))
+                elapsed_s = float(payload.get("elapsed", 0.0))
+                with output_lock:
+                    _phase(
+                        f"{prefix}Writing index...",
+                        f"{files} files, {classes} classes, {methods} methods  ({elapsed_s:.1f}s)",
+                    )
+                return
+            if event in ("resolve_calls_start",):
+                if parse_state["shown"] or db_state["shown"]:
+                    with output_lock:
+                        click.echo()
+                    parse_state["shown"] = False
+                    db_state["shown"] = False
                 call_state["started_at"] = now
                 with output_lock:
                     _phase(f"{prefix}Tracing calls...", "starting...")
@@ -287,8 +400,9 @@ def _index_shard_group(
                 call_state["shown"] = False
                 elapsed_s = (now - call_state["started_at"]) if call_state["started_at"] else 0.0
                 n = int(payload.get("calls_resolved", 0))
+                suffix = " partial" if payload.get("partial") else ""
                 with output_lock:
-                    _phase(f"{prefix}Tracing calls...", f"{n} calls resolved  ({elapsed_s:.1f}s)")
+                    _phase(f"{prefix}Tracing calls...", f"{n} calls resolved{suffix}  ({elapsed_s:.1f}s)")
                 return
             if event == "resolve_types_start":
                 with output_lock:
@@ -296,20 +410,26 @@ def _index_shard_group(
                 return
             if event == "resolve_types_done":
                 n = int(payload.get("type_relationships", 0))
+                suffix = " partial" if payload.get("partial") else ""
                 with output_lock:
-                    _phase(f"{prefix}Analyzing types...", f"{n} type relationships")
+                    _phase(f"{prefix}Analyzing types...", f"{n} type relationships{suffix}")
                 return
 
         shard_store = sg.shard(project_id)
         indexer = JavaIndexer(shard_store)
         result = indexer.index_project(
-            mod_path, full=full, progress=_progress, project_id=project_id, embed=embed
+            mod_path,
+            full=full,
+            progress=_progress,
+            project_id=project_id,
+            embed=embed,
+            deadline=deadline,
         )
         results.append(result)
         total_files += result.files_found
 
         # Flush any dangling progress line.
-        if parse_state["shown"]:
+        if parse_state["shown"] or db_state["shown"]:
             with output_lock:
                 click.echo()
 
@@ -372,7 +492,21 @@ def main() -> None:
 @main.command()
 @click.argument("path", type=click.Path(exists=True))
 @click.option("--full/--incremental", default=False, show_default=True)
-@click.option("--deep/--no-deep", default=False, show_default=True, help="Run expensive global analyses (auto-on for repos ≤3 k files).")
+@click.option("--deep/--no-deep", default=False, show_default=True, help="Run expensive global analyses when used with --complete.")
+@click.option(
+    "--fast/--complete",
+    default=True,
+    show_default=True,
+    help="Fast mode returns after the core index is queryable; complete mode runs enrichment in the foreground.",
+)
+@click.option(
+    "--budget",
+    "budget_seconds",
+    default=90.0,
+    show_default=True,
+    type=float,
+    help="Foreground time budget in seconds for fast mode; use 0 to disable the resolver deadline.",
+)
 @click.option(
     "--incremental-deep",
     is_flag=True,
@@ -381,17 +515,25 @@ def main() -> None:
 )
 @click.option(
     "--embed/--no-embed",
-    default=True,
+    default=False,
     show_default=True,
-    help="Generate vector embeddings. Uses sentence-transformers if installed (pip install codespine[ml]), otherwise falls back to hash-based vectors.",
+    help="Generate vector embeddings. Off by default so analyse stays fast; rerun with --embed when semantic vectors are needed.",
 )
 @click.option("--allow-running", is_flag=True, hidden=True, help="Skip MCP running check (used by MCP analyse_project tool).")
-def analyse(path: str, full: bool, deep: bool, incremental_deep: bool, embed: bool, allow_running: bool) -> None:
+def analyse(
+    path: str,
+    full: bool,
+    deep: bool,
+    fast: bool,
+    budget_seconds: float,
+    incremental_deep: bool,
+    embed: bool,
+    allow_running: bool,
+) -> None:
     """Index a local Java project (auto-detects workspace / Maven / Gradle layout).
 
-    Embeddings are generated by default. If sentence-transformers is installed
-    (pip install codespine[ml]), high-quality semantic vectors are used; otherwise
-    a fast hash-based fallback provides basic vector search.
+    Fast mode indexes the core Java graph and returns quickly. Use --complete
+    for foreground communities, flows, dead-code, and git-coupling enrichment.
     """
     if not allow_running and _is_running():
         click.secho("Stop MCP first ('codespine stop') to index.", fg="yellow")
@@ -400,6 +542,18 @@ def analyse(path: str, full: bool, deep: bool, incremental_deep: bool, embed: bo
     started = time.perf_counter()
     abs_path = os.path.abspath(path)
 
+    if fast and (deep or incremental_deep):
+        click.secho(
+            "Fast mode runs deep analysis in the background. Use --complete --deep to wait for it.",
+            fg="yellow",
+        )
+
+    budget_deadline = (
+        started + budget_seconds
+        if fast and budget_seconds and budget_seconds > 0
+        else None
+    )
+
     # Warn about hash fallback early so users know to install [ml]
     if embed:
         from codespine.search.vector import _load_model
@@ -516,7 +670,7 @@ def analyse(path: str, full: bool, deep: bool, incremental_deep: bool, embed: bo
             for s_idx, group in shard_groups.items():
                 f = ex.submit(
                     _index_shard_group,
-                    s_idx, group, sg, full, embed, output_lock, True,
+                    s_idx, group, sg, full, embed, budget_deadline, output_lock, True,
                 )
                 futures_map[f] = s_idx
 
@@ -538,7 +692,7 @@ def analyse(path: str, full: bool, deep: bool, incremental_deep: bool, embed: bo
         only_shard_idx = next(iter(shard_groups))
         only_group = shard_groups[only_shard_idx]
         _, all_results, total_files_found = _index_shard_group(
-            only_shard_idx, only_group, sg, full, embed, output_lock, False,
+            only_shard_idx, only_group, sg, full, embed, budget_deadline, output_lock, False,
         )
         if all_results:
             last_result = all_results[-1]
@@ -558,7 +712,9 @@ def analyse(path: str, full: bool, deep: bool, incremental_deep: bool, embed: bo
     root_shard_store = sg.shard(root_project_id)
 
     # ── Cross-module call linking ──────────────────────────────────────
-    if is_multi and len(modules_with_ids) > 1:
+    if fast and is_multi and len(modules_with_ids) > 1:
+        _phase("Cross-module linking...", "skipped (fast mode; use --complete)")
+    elif is_multi and len(modules_with_ids) > 1:
         xmod_label = "Cross-module linking..."
         _live_phase(xmod_label, "running")
         xmod_pids = [pid for _, pid in modules_with_ids]
@@ -575,7 +731,7 @@ def analyse(path: str, full: bool, deep: bool, incremental_deep: bool, embed: bo
     dead: list[dict] = []
     coupling_pairs: list[dict] = []
 
-    should_run_deep = deep or incremental_deep or total_files_found <= 3000
+    should_run_deep = (not fast) and (deep or incremental_deep or total_files_found <= 3000)
     if should_run_deep:
         comm_label = "Detecting communities..."
         _live_phase(comm_label, "running")
@@ -613,6 +769,11 @@ def analyse(path: str, full: bool, deep: bool, incremental_deep: bool, embed: bo
             progress=lambda s: _live_phase(coup_label, s),
         )
         _finish_phase(coup_label, f"{len(coupling_pairs)} coupled file pairs")
+    elif fast:
+        _phase("Detecting communities...", "queued in background")
+        _phase("Detecting execution flows...", "queued in background")
+        _phase("Finding dead code...", "queued in background")
+        _phase("Analyzing git history...", "queued in background")
     else:
         # Run lightweight versions of flow tracing and dead code from the call
         # graph already built — no community detection or coupling (those are
@@ -674,30 +835,121 @@ def analyse(path: str, full: bool, deep: bool, incremental_deep: bool, embed: bo
         fg="green",
     )
 
-    # Detect unresolved imports → hint about unindexed sibling projects
-    try:
-        unresolved = JavaIndexer.detect_unresolved_imports(root_shard_store)
-        if unresolved:
-            click.echo()
-            click.secho("⚠  Unresolved imports — consider indexing these projects:", fg="yellow")
-            for pkg, samples in sorted(unresolved.items())[:8]:
-                click.echo(f"   {pkg}  (e.g. {samples[0]})")
-    except Exception:
-        pass  # best-effort
+    # Detect unresolved imports → hint about unindexed sibling projects.
+    # This is useful, but it is still another global query, so fast mode leaves
+    # it out of the foreground path.
+    if not fast:
+        try:
+            unresolved = JavaIndexer.detect_unresolved_imports(root_shard_store)
+            if unresolved:
+                click.echo()
+                click.secho("⚠  Unresolved imports — consider indexing these projects:", fg="yellow")
+                for pkg, samples in sorted(unresolved.items())[:8]:
+                    click.echo(f"   {pkg}  (e.g. {samples[0]})")
+        except Exception:
+            pass  # best-effort
 
     # Publish a read replica so MCP and read-only CLI commands (search, stats…)
     # run against an isolated snapshot rather than competing with the write
     # process's buffer pool.  Snapshot all open shards concurrently.
     snap_label = "Publishing read replica..."
-    _live_phase(snap_label, "copying")
-    root_shard_store._recycle_conn()
-    sg.snapshot_all(background=False)
-    _finish_phase(snap_label, "MCP will reload automatically")
+    for store in sg.open_shards():
+        recycle = getattr(store, "_recycle_conn", None)
+        if callable(recycle):
+            recycle()
+    if fast and _spawn_background_enrichment(abs_path):
+        _phase(snap_label, "core snapshot now; enrichment continues in background")
+    else:
+        _live_phase(snap_label, "copying")
+        sg.snapshot_all(background=False)
+        _finish_phase(snap_label, "MCP will reload automatically")
 
     # Restore original SIGINT handler now that we've finished cleanly.
     signal.signal(signal.SIGINT, _old_sigint_handler)
 
 
+@main.command("publish-snapshot", hidden=True)
+def publish_snapshot() -> None:
+    """Publish sharded read replicas for a recently completed analyse run."""
+    sg = ShardedGraphStore(read_only=False)
+    sg.snapshot_all(background=False)
+
+
+@main.command("enrich-background", hidden=True)
+@click.argument("path", type=click.Path(exists=True))
+def enrich_background(path: str) -> None:
+    """Run expensive post-index graph enrichment outside the analyse foreground."""
+    abs_path = os.path.abspath(path)
+    LOGGER.info("Background enrichment starting for %s", abs_path)
+
+    project_roots = JavaIndexer.detect_projects_in_workspace(abs_path)
+    modules_with_ids: list[tuple[str, str]] = []
+    for proj_root in project_roots:
+        proj_name = os.path.basename(proj_root)
+        module_dirs = JavaIndexer.detect_modules(proj_root)
+        is_multi_module = not (len(module_dirs) == 1 and module_dirs[0] == proj_root)
+        if is_multi_module:
+            for m in module_dirs:
+                modules_with_ids.append((m, f"{proj_name}::{os.path.basename(m)}"))
+        else:
+            modules_with_ids.append((proj_root, proj_name))
+
+    root_basename = os.path.basename(abs_path)
+    root_project_id = modules_with_ids[-1][1] if modules_with_ids else root_basename
+    is_multi = len(modules_with_ids) > 1
+    xmod_pids = [pid for _, pid in modules_with_ids]
+
+    sg = ShardedGraphStore(read_only=False)
+    root_shard_store = sg.shard(root_project_id)
+
+    try:
+        # Publish the fast core graph first so MCP/search can use it while the
+        # more expensive enrichment keeps working.
+        sg.snapshot_all(background=False)
+
+        if is_multi and len(xmod_pids) > 1:
+            xmod_edges = link_cross_module_calls(
+                root_shard_store,
+                project_ids=xmod_pids,
+                progress=lambda s: LOGGER.info("Cross-module linking: %s", s),
+            )
+            LOGGER.info("Background cross-module linking wrote %d edges", xmod_edges)
+
+        communities = detect_communities(
+            root_shard_store,
+            progress=lambda s: LOGGER.info("Community detection: %s", s),
+        )
+        LOGGER.info("Background community detection found %d clusters", len(communities))
+
+        flows = trace_execution_flows(
+            root_shard_store,
+            progress=lambda s: LOGGER.info("Execution flow tracing: %s", s),
+        )
+        LOGGER.info("Background flow tracing found %d flows", len(flows))
+
+        dead = detect_dead_code(root_shard_store, limit=500)
+        LOGGER.info("Background dead-code scan found %d candidates", _dead_result_count(dead))
+
+        root_shard_store.clear_coupling()
+        coupling_project = root_basename if is_multi else root_project_id
+        coupling_pairs = compute_coupling(
+            root_shard_store,
+            abs_path,
+            coupling_project,
+            days=SETTINGS.default_coupling_days,
+            min_strength=SETTINGS.default_min_coupling_strength,
+            min_cochanges=SETTINGS.default_min_cochanges,
+            progress=lambda s: LOGGER.info("Git coupling: %s", s),
+        )
+        LOGGER.info("Background coupling analysis found %d pairs", len(coupling_pairs))
+
+        sg.snapshot_all(background=False)
+        LOGGER.info("Background enrichment finished for %s", abs_path)
+    except Exception as exc:  # noqa: BLE001
+        LOGGER.exception("Background enrichment failed for %s: %s", abs_path, exc)
+        raise
+
+
 @main.command()
 @click.argument("query")
 @click.option("--k", default=20, show_default=True, type=int)

{codespine-1.0.7 → codespine-1.0.9}/codespine/config.py

@@ -29,8 +29,10 @@ class Settings:
     rrf_k: int = 60
     semantic_candidate_pool: int = 2000
     write_batch_size: int = 500
-    index_file_batch_size: int = 20
-    edge_write_batch_size: int = 500
+    index_file_batch_size: int = 200
+    index_method_batch_size: int = 2000
+    index_symbol_batch_size: int = 2000
+    edge_write_batch_size: int = 5000
     default_coupling_days: int = 5
     default_min_coupling_strength: float = 0.3
     default_min_cochanges: int = 3

{codespine-1.0.7 → codespine-1.0.9}/codespine/indexer/call_resolver.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import time
 from collections import defaultdict
 from typing import Iterator
 
@@ -58,6 +59,7 @@ def resolve_calls(
     class_catalog: dict[str, list[str]],
     *,
     scan_counter: list[int] | None = None,
+    deadline: float | None = None,
 ) -> Iterator[tuple[str, str, float, str]]:
     """Resolve call names to known method ids.
 
@@ -84,6 +86,8 @@ def resolve_calls(
             class_method_index_by_fqcn[class_fqcn][key].append(method_id)
 
     for source_id, call_sites in calls.items():
+        if deadline is not None and time.perf_counter() >= deadline:
+            return
         if scan_counter is not None:
             scan_counter[0] += 1
         src_meta = method_catalog.get(source_id, {})
@@ -94,6 +98,8 @@ def resolve_calls(
         field_types = src_ctx.get("field_types", {}) or {}
 
         for call in call_sites:
+            if deadline is not None and time.perf_counter() >= deadline:
+                return
             call_name = call.name
 
             key = (call_name, int(call.arg_count))