scip-cli 2.10.0__tar.gz → 2.11.0__tar.gz

{scip_cli-2.10.0 → scip_cli-2.11.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: scip-cli
-Version: 2.10.0
+Version: 2.11.0
 Summary: Fast code intelligence via SCIP indexes
 Project-URL: Homepage, https://github.com/flesler/scip-cli
 Author: Ariel Flesler
@@ -266,6 +266,7 @@ scip-cli reindex --tsconfig tsconfig.app.json --tsconfig tsconfig.spec.json
 scip-cli reindex --exclude '**/*.test.ts' '**/*.spec.ts'
 scip-cli reindex --exclude          # clear persisted excludes
 scip-cli reindex --fresh            # full index; clear metadata.json
+scip-cli reindex --incremental      # reuse unchanged project shards (see SKILL for language support)
 ```
 
 `--path` limits which discovered tsconfig **directories** are indexed (prefix match, same idea as query `--path`). `--tsconfig` skips discovery and indexes those `tsconfig*.json` **files** (repeatable; globs are expanded inside the tool). File-based runs default to one `scip-typescript` process per file so each gets its own heap (`SCIP_CLI_TS_INDEX_BATCH_SIZE` still overrides). Cannot combine `--path` and `--tsconfig`. **TypeScript only.** Scope and exclude defaults are saved in `metadata.json` next to `index.db` and reused on later `reindex` runs; use `reindex --fresh` to clear them and restore a full index. `--exclude` updates the persisted exclude list; a lone bare `--exclude` clears it.

{scip_cli-2.10.0 → scip_cli-2.11.0}/README.md

@@ -245,6 +245,7 @@ scip-cli reindex --tsconfig tsconfig.app.json --tsconfig tsconfig.spec.json
 scip-cli reindex --exclude '**/*.test.ts' '**/*.spec.ts'
 scip-cli reindex --exclude          # clear persisted excludes
 scip-cli reindex --fresh            # full index; clear metadata.json
+scip-cli reindex --incremental      # reuse unchanged project shards (see SKILL for language support)
 ```
 
 `--path` limits which discovered tsconfig **directories** are indexed (prefix match, same idea as query `--path`). `--tsconfig` skips discovery and indexes those `tsconfig*.json` **files** (repeatable; globs are expanded inside the tool). File-based runs default to one `scip-typescript` process per file so each gets its own heap (`SCIP_CLI_TS_INDEX_BATCH_SIZE` still overrides). Cannot combine `--path` and `--tsconfig`. **TypeScript only.** Scope and exclude defaults are saved in `metadata.json` next to `index.db` and reused on later `reindex` runs; use `reindex --fresh` to clear them and restore a full index. `--exclude` updates the persisted exclude list; a lone bare `--exclude` clears it.

scip_cli-2.11.0/docs/incremental-reindex-roadmap.md

@@ -0,0 +1,42 @@
+# Incremental reindex roadmap
+
+Phased plan to avoid full `scip-typescript` runs on every `reindex`. Shard reuse first; file-level and upstream TSC incremental follow.
+
+## Phase 1 — scip-cli shard reuse (shipped)
+
+Per-tsconfig shard cache with content fingerprints. **Shippable:** unit + integration tests in-repo; large monorepos can be validated manually outside the repo (not checked in).
+
+- [x] Roadmap doc
+- [x] `shards/manifest.json` in cache dir (fingerprint + part DB path per tsconfig project)
+- [x] `compute_shard_fingerprint()` — tsconfig chain + included source file content hashes + exclude globs
+- [x] `reindex --incremental` — per-project shards (batch size 1), reuse unchanged part DBs
+- [x] Persist shard part DBs under `cache/shards/*.db`
+- [x] Full `reindex` clears shard cache (avoid stale reuse after non-incremental rebuild)
+- [x] `reindex --fresh` clears shard cache
+- [x] Unit tests for fingerprint, manifest merge, and warm `index_typescript` reuse
+- [x] Reindex CLI flag tests (`--incremental`, rejects with `--fresh` / Python)
+- [x] Stderr stats: `Incremental: N shard(s) reused, M reindexed`
+- [x] Update `scip_cli/SKILL.md` and README flag list
+
+## Phase 2 — scip-typescript fork: TSC incremental program
+
+- [ ] Fork `sourcegraph/scip-typescript`
+- [ ] `--incremental` / `--ts-build-info-file` CLI flags
+- [ ] `createIncrementalProgram` + `createIncrementalCompilerHost` in `ProjectIndexer`
+- [ ] Default `tsBuildInfoFile` under scip-cli cache dir (not repo root)
+- [ ] scip-cli passes `--ts-build-info-file` when shard is dirty
+- [ ] Benchmark dirty shard: program build time before/after
+
+## Phase 3 — File-level incremental inside a shard
+
+- [ ] Document-level upsert in SQLite (replace rows for changed paths; merge is insert-only today)
+- [ ] `reindex --incremental` accepts optional changed-file list (content-hash manifest in cache)
+- [ ] Invalidation: changed files ∪ direct importers (from existing index `mentions`)
+- [ ] scip-typescript fork: skip unchanged files in `ProjectIndexer` loop (`--files` or internal dirty set)
+- [ ] Optional git input via env / scip-atlas (`last_index_commit`, `git diff --name-only`) — not a hard scip-cli dependency
+
+## Phase 4 — Polish
+
+- [ ] Dogfood on this repo + optional large-monorepo validation (manual, outside CI)
+- [ ] Submit scip-typescript fork as upstream PR (phase 2, then 3 indexer pieces)
+- [ ] `scripts/bench.sh` scenario for incremental reindex

{scip_cli-2.10.0 → scip_cli-2.11.0}/scip_cli/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: scip-cli
-description: Read when needing symbols, definitions, refs, members, or SQL health dashboards in TS/JS, Python, Go, or Rust
+description: Read when needing symbol lookup or SQL health dashboards in code.
 ---
 
 TypeScript/JavaScript (.ts, .tsx, .js, .jsx), Python (.py), Go (.go), and Rust (.rs) — not GraphQL, CSS, or other files.
@@ -168,3 +168,5 @@ reindex [--path DIR ...] [--tsconfig FILE_OR_GLOB ...] [--exclude [GLOB ...]] [-
 `--exclude GLOB` omits matching files from the SQLite index after conversion (repeatable; merged with `excludeGlobs` in `.scip-cli.json`). Passing `--exclude` updates the persisted exclude list; a lone bare `--exclude` (no globs on that flag) clears it — `--exclude foo --exclude` keeps `foo`. Patterns without `/` match basenames (`*.test.ts`); patterns with `/` match repo-relative paths (`tests/**`, `**/__tests__/**`). Indexers still parse excluded files when production code imports them — post-process removal is authoritative.
 
 `--fresh` ignores persisted `metadata.json` and clears it before indexing unless `--path`, `--tsconfig`, or `--exclude` are set on the same command (use `reindex --fresh` to restore a full index).
+
+`--incremental` reuses cached per-project part DBs under `shards/` in the project cache dir (`~/.cache/scip-cli/projects/<slug>/`, alongside `index.db` and `metadata.json`) when inputs are unchanged. **Currently TypeScript only** (Python reindex rejects the flag). Forces one indexer run per discovered project. A plain `reindex` clears the incremental cache; run `reindex --incremental` after an initial full index to benefit. Cannot combine with `--fresh`.

{scip_cli-2.10.0 → scip_cli-2.11.0}/scip_cli/__init__.py

@@ -1,3 +1,3 @@
 """scip-cli: Fast code intelligence via SCIP indexes."""
 
-__version__ = "2.10.0"
+__version__ = "2.11.0"

{scip_cli-2.10.0 → scip_cli-2.11.0}/scip_cli/__main__.py

@@ -195,6 +195,13 @@ def main() -> None:
         action="store_true",
         help="Ignore persisted metadata.json; clear it unless scope/exclude flags are set on this run",
     )
+    reindex_parser.add_argument(
+        "--incremental",
+        action="store_true",
+        help=(
+            "Reuse cached per-project index parts when inputs are unchanged (full reindex clears the incremental cache)"
+        ),
+    )
     reindex_parser.add_argument(
         "--with-external",
         action="store_true",

{scip_cli-2.10.0 → scip_cli-2.11.0}/scip_cli/commands/reindex.py

@@ -11,6 +11,7 @@ from ..cache import (
     promote_next_index,
 )
 from ..indexing import index_project, log_index_complete
+from ..indexing.shards import clear_shard_cache
 from ..metadata import UNSET, apply_metadata_updates
 from ..paths import normalize_path_scope
 from ..project import Language, find_project_root_and_language
@@ -27,6 +28,13 @@ def main(args):
     tsconfig_args = getattr(args, "tsconfig", None) or []
     exclude_groups = getattr(args, "exclude", None)
     fresh = getattr(args, "fresh", False)
+    incremental = getattr(args, "incremental", False)
+    if incremental and fresh:
+        print("Error: reindex --incremental and --fresh cannot be combined", file=sys.stderr)
+        sys.exit(1)
+    if incremental and lang is not None and lang != Language.TYPESCRIPT:
+        print("Error: reindex --incremental is only supported for TypeScript projects", file=sys.stderr)
+        sys.exit(1)
     if path_args and tsconfig_args:
         print("Error: reindex --path and --tsconfig cannot be combined", file=sys.stderr)
         sys.exit(1)
@@ -92,6 +100,8 @@ def main(args):
             exclude_globs=exclude_update,
         )
         cleanup_in_progress_index(cache_dir)
+        if fresh or not incremental:
+            clear_shard_cache(cache_dir)
         try:
             # Pass --with-external flag to indexer via environment
             if getattr(args, "with_external", False):
@@ -100,7 +110,14 @@ def main(args):
                 os.environ["SCIP_CLI_KEEP_EXTERNAL"] = "1"
 
             started = time.perf_counter()
-            _output_db, skipped, total = index_project(root, lang, cache_dir, replace=True, log=False)
+            _output_db, skipped, total = index_project(
+                root,
+                lang,
+                cache_dir,
+                replace=True,
+                log=False,
+                incremental=incremental,
+            )
             elapsed_seconds = time.perf_counter() - started
         except RuntimeError as e:
             cleanup_in_progress_index(cache_dir)

{scip_cli-2.10.0 → scip_cli-2.11.0}/scip_cli/indexing/core.py

@@ -97,7 +97,7 @@ def indexer_env(project_root=None):
     return env
 
 
-def index_project(root, lang, cache_dir, *, replace=False, log=True):
+def index_project(root, lang, cache_dir, *, replace=False, log=True, incremental=False):
     """Run the language-specific indexer and convert to DB."""
     from ..project import Language
 
@@ -110,7 +110,13 @@ def index_project(root, lang, cache_dir, *, replace=False, log=True):
     if lang == Language.TYPESCRIPT:
         projects = typescript_projects(root)
         output_db, _indexed, skipped, total = index_typescript(
-            root, cache_dir, projects, env, replace=replace, exclude_globs=exclude_globs
+            root,
+            cache_dir,
+            projects,
+            env,
+            replace=replace,
+            exclude_globs=exclude_globs,
+            incremental=incremental,
         )
         if log:
             log_index_complete(

scip_cli-2.11.0/scip_cli/indexing/shards.py

@@ -0,0 +1,195 @@
+"""Per-tsconfig shard fingerprints and cached part DBs for incremental reindex."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import shutil
+from pathlib import Path
+
+from ..exclude import path_matches_glob
+from ..tsconfig import resolved_exclude, resolved_include_or_files, tsconfig_for_project, walk_tsconfig_chain
+
+MANIFEST_VERSION = 1
+MANIFEST_FILENAME = "manifest.json"
+SHARDS_DIRNAME = "shards"
+
+_SOURCE_SUFFIXES = frozenset({".ts", ".tsx", ".js", ".jsx", ".mts", ".cts", ".mjs", ".cjs"})
+
+
+def shards_dir(cache_dir: Path) -> Path:
+    return Path(cache_dir) / SHARDS_DIRNAME
+
+
+def manifest_path(cache_dir: Path) -> Path:
+    return shards_dir(cache_dir) / MANIFEST_FILENAME
+
+
+def shard_key(project: Path) -> str:
+    """Stable manifest key for a TypeScript project path."""
+    return project.as_posix()
+
+
+def shard_db_filename(project: Path) -> str:
+    stem = shard_key(project).replace("/", "__").replace("\\", "__")
+    return f"{stem}.db"
+
+
+def shard_db_path(cache_dir: Path, project: Path) -> Path:
+    return shards_dir(cache_dir) / shard_db_filename(project)
+
+
+def clear_shard_cache(cache_dir: Path) -> None:
+    """Remove persisted shard part DBs and manifest."""
+    root = shards_dir(cache_dir)
+    if root.is_dir():
+        shutil.rmtree(root)
+
+
+def load_shard_manifest(cache_dir: Path) -> dict[str, dict[str, str]]:
+    """Return shard key → {fingerprint, part_db} from manifest.json."""
+    path = manifest_path(cache_dir)
+    if not path.is_file():
+        return {}
+    try:
+        data = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError):
+        return {}
+    if not isinstance(data, dict):
+        return {}
+    raw_shards = data.get("shards")
+    if not isinstance(raw_shards, dict):
+        return {}
+    out: dict[str, dict[str, str]] = {}
+    for key, entry in raw_shards.items():
+        if not isinstance(key, str) or not isinstance(entry, dict):
+            continue
+        fingerprint = entry.get("fingerprint")
+        part_db = entry.get("part_db")
+        if isinstance(fingerprint, str) and isinstance(part_db, str):
+            out[key] = {"fingerprint": fingerprint, "part_db": part_db}
+    return out
+
+
+def save_shard_manifest(cache_dir: Path, shards: dict[str, dict[str, str]]) -> None:
+    """Merge shard entries into manifest.json (full reindex clears stale entries)."""
+    root = shards_dir(cache_dir)
+    root.mkdir(parents=True, exist_ok=True)
+    merged = {**load_shard_manifest(cache_dir), **shards}
+    payload = {
+        "version": MANIFEST_VERSION,
+        "shards": {
+            key: {"fingerprint": entry["fingerprint"], "part_db": entry["part_db"]}
+            for key, entry in sorted(merged.items())
+        },
+    }
+    manifest_path(cache_dir).write_text(json.dumps(payload, indent=2) + "\n", encoding="utf-8")
+
+
+def _hash_file(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as handle:
+        for chunk in iter(lambda: handle.read(1024 * 1024), b""):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def _glob_source_files(base_dir: Path, patterns: list[str]) -> list[Path]:
+    found: set[Path] = set()
+    for pattern in patterns:
+        if Path(pattern).is_absolute():
+            candidate = Path(pattern)
+            if candidate.is_file() and candidate.suffix.lower() in _SOURCE_SUFFIXES:
+                found.add(candidate.resolve())
+            continue
+        for match in base_dir.glob(pattern):
+            if match.is_file() and match.suffix.lower() in _SOURCE_SUFFIXES:
+                found.add(match.resolve())
+    return sorted(found)
+
+
+def _tsconfig_excludes_path(tsconfig: Path, file_path: Path) -> bool:
+    """Return True when a file is excluded by the leaf tsconfig exclude list."""
+    exclude_patterns = resolved_exclude(tsconfig)
+    if not exclude_patterns:
+        return False
+    try:
+        relative = file_path.relative_to(tsconfig.parent).as_posix()
+    except ValueError:
+        return False
+    return any(path_matches_glob(relative, pattern) for pattern in exclude_patterns)
+
+
+def list_project_source_files(root: Path, project: Path) -> list[Path]:
+    """Source files that contribute to a shard fingerprint (tsconfig include/files)."""
+    root = Path(root).resolve()
+    tsconfig = tsconfig_for_project(root, project)
+    if tsconfig is None:
+        return []
+
+    include, files = resolved_include_or_files(tsconfig)
+    base_dir = tsconfig.parent
+    if files is not None:
+        candidates = _glob_source_files(base_dir, files)
+    elif include is not None:
+        candidates = _glob_source_files(base_dir, include)
+    else:
+        candidates = _glob_source_files(base_dir, ["**/*"])
+    return [path for path in candidates if not _tsconfig_excludes_path(tsconfig, path)]
+
+
+def compute_shard_fingerprint(
+    root: Path,
+    project: Path,
+    *,
+    exclude_globs: tuple[str, ...] = (),
+) -> str:
+    """Hash tsconfig chain + indexed sources + exclude globs for one project shard."""
+    root = Path(root).resolve()
+    tsconfig = tsconfig_for_project(root, project)
+    digest = hashlib.sha256()
+    digest.update(shard_key(project).encode())
+    digest.update(b"\0")
+
+    if tsconfig is not None:
+        for path, _data in walk_tsconfig_chain(tsconfig):
+            digest.update(path.as_posix().encode())
+            digest.update(b"\0")
+            digest.update(path.read_bytes())
+            digest.update(b"\0")
+
+    for path in list_project_source_files(root, project):
+        try:
+            relative = path.relative_to(root).as_posix()
+        except ValueError:
+            relative = path.as_posix()
+        digest.update(relative.encode())
+        digest.update(b"\0")
+        digest.update(_hash_file(path).encode())
+        digest.update(b"\0")
+
+    for glob in exclude_globs:
+        digest.update(glob.encode())
+        digest.update(b"\0")
+
+    return digest.hexdigest()
+
+
+def resolve_cached_shard_db(
+    cache_dir: Path,
+    project: Path,
+    fingerprint: str,
+    manifest: dict[str, dict[str, str]],
+) -> Path | None:
+    """Return a reusable shard part DB when fingerprint and file both match."""
+    key = shard_key(project)
+    entry = manifest.get(key)
+    if entry is None or entry.get("fingerprint") != fingerprint:
+        return None
+    candidate = shards_dir(cache_dir) / Path(entry["part_db"]).name
+    if candidate.is_file():
+        return candidate
+    fallback = shard_db_path(cache_dir, project)
+    if fallback.is_file():
+        return fallback
+    return None

{scip_cli-2.10.0 → scip_cli-2.11.0}/scip_cli/indexing/typescript.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import json
+import shutil
 import sys
 import tempfile
 from concurrent.futures import ThreadPoolExecutor, as_completed
@@ -24,6 +25,16 @@ from .orchestrate import (
     ts_batch_limit_display,
 )
 from .runners import run_indexer_with_fallback
+from .shards import (
+    SHARDS_DIRNAME,
+    compute_shard_fingerprint,
+    load_shard_manifest,
+    resolve_cached_shard_db,
+    save_shard_manifest,
+    shard_db_filename,
+    shard_db_path,
+    shard_key,
+)
 
 
 def typescript_projects(root: Path) -> list[Path]:
@@ -125,15 +136,60 @@ def index_ts_projects(
     return label, db_path, None
 
 
-def index_typescript(root, cache_dir, projects, env, *, replace=False, exclude_globs: tuple[str, ...] = ()):
+def _persist_shard_db(cache_dir: Path, project: Path, source_db: Path) -> Path:
+    """Copy a part DB into the shard cache for incremental reuse."""
+    dest = shard_db_path(cache_dir, project)
+    dest.parent.mkdir(parents=True, exist_ok=True)
+    shutil.copy2(source_db, dest)
+    return dest
+
+
+def _index_shard_batch(
+    root: Path,
+    cache_dir: Path,
+    batch: list[Path],
+    work_dir: Path,
+    env,
+    *,
+    exclude_globs: tuple[str, ...],
+    output_db: Path | None,
+) -> tuple[str, Path | None, str | None]:
+    label, db_path, error = index_ts_projects(
+        root,
+        batch,
+        work_dir,
+        env,
+        output_db=output_db,
+        exclude_globs=exclude_globs,
+    )
+    if db_path is None:
+        return label, None, error
+    if len(batch) == 1:
+        _persist_shard_db(cache_dir, batch[0], db_path)
+    return label, db_path, None
+
+
+def index_typescript(
+    root,
+    cache_dir,
+    projects,
+    env,
+    *,
+    replace=False,
+    exclude_globs: tuple[str, ...] = (),
+    incremental: bool = False,
+):
     """Index one or more TypeScript projects and write the merged index.db."""
     root = Path(root)
     cache_dir = Path(cache_dir)
     output_db = index_db_path(cache_dir, replace=replace)
     workers = index_workers()
-    batch_size = effective_ts_batch_size(projects)
+    batch_size = 1 if incremental else effective_ts_batch_size(projects)
     batches = batch_projects(projects, batch_size)
     use_parallel = len(batches) > 1 and workers > 1
+    manifest = load_shard_manifest(cache_dir) if incremental else {}
+    updated_shards: dict[str, dict[str, str]] = {}
+    reused = 0
 
     with tempfile.TemporaryDirectory() as tmpdir:
         tmpdir_path = Path(tmpdir)
@@ -142,14 +198,99 @@ def index_typescript(root, cache_dir, projects, env, *, replace=False, exclude_g
         total = len(projects)
         show_progress = total > PROGRESS_LOG_MIN_PROJECTS
 
-        if show_progress and use_parallel:
+        if incremental and show_progress:
+            print(f"Incremental reindex: {total} project shard(s)...", file=sys.stderr)
+
+        if show_progress and use_parallel and not incremental:
             batch_desc = ts_batch_limit_display(batch_size, total)
             print(
                 f"Indexing {total} TypeScript projects ({workers} workers, {batch_desc}; merge is serial)...",
                 file=sys.stderr,
             )
 
-        if use_parallel:
+        def _record_shard(project: Path, fingerprint: str) -> None:
+            relative = shard_db_filename(project)
+            updated_shards[shard_key(project)] = {
+                "fingerprint": fingerprint,
+                "part_db": f"{SHARDS_DIRNAME}/{relative}",
+            }
+
+        def _try_reuse_shard(project: Path) -> Path | None:
+            nonlocal reused
+            fingerprint = compute_shard_fingerprint(root, project, exclude_globs=exclude_globs)
+            cached = resolve_cached_shard_db(cache_dir, project, fingerprint, manifest)
+            if cached is None:
+                return None
+            reused += 1
+            _record_shard(project, fingerprint)
+            if show_progress:
+                print(f"Reused shard: {shard_key(project)}", file=sys.stderr)
+            return cached
+
+        if incremental:
+            ordered_parts: list[tuple[int, Path]] = []
+            pending: list[tuple[int, list[Path]]] = []
+            for index, batch in enumerate(batches, start=1):
+                project = batch[0]
+                cached = _try_reuse_shard(project)
+                if cached is not None:
+                    ordered_parts.append((index, cached))
+                    continue
+                pending.append((index, batch))
+
+            if pending:
+                if use_parallel and len(pending) > 1:
+                    with ThreadPoolExecutor(max_workers=workers) as pool:
+                        futures = {
+                            pool.submit(
+                                _index_shard_batch,
+                                root,
+                                cache_dir,
+                                batch,
+                                tmpdir_path / f"part-{index}",
+                                env,
+                                exclude_globs=exclude_globs,
+                                output_db=None,
+                            ): (index, batch)
+                            for index, batch in pending
+                        }
+                        for future in as_completed(futures):
+                            batch_index, batch = futures[future]
+                            label, db_path, error = future.result()
+                            if db_path is None:
+                                skipped += len(batch)
+                                print(f"Warning: skipped {label}: {error}", file=sys.stderr)
+                            else:
+                                project = batch[0]
+                                fingerprint = compute_shard_fingerprint(root, project, exclude_globs=exclude_globs)
+                                _record_shard(project, fingerprint)
+                                ordered_parts.append((batch_index, db_path))
+                                if show_progress:
+                                    print(f"Indexed shard: {shard_key(project)}", file=sys.stderr)
+                else:
+                    for index, batch in pending:
+                        project = batch[0]
+                        if show_progress:
+                            print(f"Indexing shard: {shard_key(project)}", file=sys.stderr)
+                        label, db_path, error = _index_shard_batch(
+                            root,
+                            cache_dir,
+                            batch,
+                            tmpdir_path / f"part-{index}",
+                            env,
+                            exclude_globs=exclude_globs,
+                            output_db=None,
+                        )
+                        if db_path is None:
+                            skipped += len(batch)
+                            print(f"Warning: skipped {label}: {error}", file=sys.stderr)
+                            continue
+                        fingerprint = compute_shard_fingerprint(root, project, exclude_globs=exclude_globs)
+                        _record_shard(project, fingerprint)
+                        ordered_parts.append((index, db_path))
+
+            part_dbs = [db for _, db in sorted(ordered_parts, key=lambda item: item[0])]
+        elif use_parallel:
             completed = 0
             with ThreadPoolExecutor(max_workers=workers) as pool:
                 futures = {
@@ -204,4 +345,12 @@ def index_typescript(root, cache_dir, projects, env, *, replace=False, exclude_g
 
         finalize_part_dbs(part_dbs, output_db)
 
+        if incremental:
+            save_shard_manifest(cache_dir, updated_shards)
+            if show_progress or reused:
+                print(
+                    f"Incremental: {reused} shard(s) reused, {len(updated_shards) - reused} reindexed",
+                    file=sys.stderr,
+                )
+
         return output_db, len(part_dbs), skipped, total

{scip_cli-2.10.0 → scip_cli-2.11.0}/scip_cli/tsconfig.py

@@ -140,6 +140,18 @@ def resolved_allow_js(path: Path) -> bool:
     return False
 
 
+def resolved_exclude(path: Path) -> list[str]:
+    """`exclude` from the leaf tsconfig (first entry in the extends chain)."""
+    chain = walk_tsconfig_chain(path.resolve())
+    if not chain:
+        return []
+    _file, data = chain[0]
+    exclude = data.get("exclude")
+    if isinstance(exclude, list) and all(isinstance(item, str) for item in exclude):
+        return list(exclude)
+    return []
+
+
 def resolved_include_or_files(path: Path) -> tuple[list[str] | None, list[str] | None]:
     """First `include` or `files` found walking leaf → base. The other is None."""
     for _file, data in walk_tsconfig_chain(path):