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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: scip-cli
-Version: 2.9.1
+Version: 2.11.0
 Summary: Fast code intelligence via SCIP indexes
 Project-URL: Homepage, https://github.com/flesler/scip-cli
 Author: Ariel Flesler
@@ -153,7 +153,7 @@ scip-cli <command> [arguments]
 - `rdeps <file>` - Find files that depend on a file (`--path`)
 - `deps <symbol|file>` - Find outbound dependencies (what a symbol or file calls) (`--path`, `--paths-only`)
 - `members <symbol>` - List members of a class/interface (`--path`)
-- `analyze [target]` - SQL health dashboards (`--limit`, `--priority`, `--check`, `--include-tests`). No target: project-wide; directory or file path; symbol name. See [Finding easy wins with `analyze`](#finding-easy-wins-with-analyze).
+- `analyze [target]` - SQL health dashboards (`--limit`, `--per-check-limit`, `--priority`, `--check`, `--include-tests`). No target: project-wide; directory or file path; symbol name. See [Finding easy wins with `analyze`](#finding-easy-wins-with-analyze).
 - `reindex` - Force re-indexing of the current project (`--path` to limit scope; repeatable)
 - `skill [path]` - Install or dump the SKILL.md
 
@@ -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.
@@ -282,16 +283,19 @@ Use `analyze` on the repo itself before broad refactors or agent review — it s
 
 ```bash
 scip-cli analyze --limit 25
+scip-cli analyze --limit 40 --per-check-limit 5   # spread the global budget across checks
 scip-cli analyze --priority high --limit 25   # dead exports & cycles only
 scip-cli analyze --check cycles --limit 25    # one named section
 scip-cli analyze --check dead_files --limit 25
 ```
 
+`--limit` is a **global** finding-row budget (truncation markers do not count). `--per-check-limit` (default unlimited) caps each section. Directory analyze spends that same budget on per-file dumps after dashboards.
+
 Sections are tagged `[high]`, `[medium]`, `[low]` and listed in that order.
 
 |Tier|Project sections|Action|
 |---|---|---|
-|**high**|Cycles, unreferenced, dead exports, dead files, stale types|Nuke or fix cycles; delete unused; `_` prefix|
+|**high**|Cycles, dead exports, dead files, stale types (unreferenced is omitted when dead exports is on)|Nuke or fix cycles; delete unused; `_` prefix|
 |**medium**|Same-file only, change surface (file target)|Module-private by usage|
 |**low**|Test-only consumers, coupling, bottlenecks, hotspots|Noisy on Python (index omits many same-file calls); verify with `rg`|
 
@@ -302,7 +306,7 @@ Use `--priority high` for a quick gate; `--priority high,medium` adds context. F
 |Section|Easy pickings|
 |---|---|
 |**Cycles**|Import/mention cycles between production files — break the edge or extract shared code|
-|**Unreferenced**|No usage in the index at all — delete|
+|**Unreferenced**|Same survivors as dead exports; omitted unless `--check unreferenced`. Empty `rdeps` is usually a SCIP miss — verify with `rg -F STEM` (file basename in `(...)`)|
 |**Dead exports**|No external refs — delete or `_` prefix|
 |**Stale types**|Classes/types with no external consumer in the index — verify in-file or type-only use before removing|
 |**Same-file only**|Used only inside defining file — rename to `_`|

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

@@ -132,7 +132,7 @@ scip-cli <command> [arguments]
 - `rdeps <file>` - Find files that depend on a file (`--path`)
 - `deps <symbol|file>` - Find outbound dependencies (what a symbol or file calls) (`--path`, `--paths-only`)
 - `members <symbol>` - List members of a class/interface (`--path`)
-- `analyze [target]` - SQL health dashboards (`--limit`, `--priority`, `--check`, `--include-tests`). No target: project-wide; directory or file path; symbol name. See [Finding easy wins with `analyze`](#finding-easy-wins-with-analyze).
+- `analyze [target]` - SQL health dashboards (`--limit`, `--per-check-limit`, `--priority`, `--check`, `--include-tests`). No target: project-wide; directory or file path; symbol name. See [Finding easy wins with `analyze`](#finding-easy-wins-with-analyze).
 - `reindex` - Force re-indexing of the current project (`--path` to limit scope; repeatable)
 - `skill [path]` - Install or dump the SKILL.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.
@@ -261,16 +262,19 @@ Use `analyze` on the repo itself before broad refactors or agent review — it s
 
 ```bash
 scip-cli analyze --limit 25
+scip-cli analyze --limit 40 --per-check-limit 5   # spread the global budget across checks
 scip-cli analyze --priority high --limit 25   # dead exports & cycles only
 scip-cli analyze --check cycles --limit 25    # one named section
 scip-cli analyze --check dead_files --limit 25
 ```
 
+`--limit` is a **global** finding-row budget (truncation markers do not count). `--per-check-limit` (default unlimited) caps each section. Directory analyze spends that same budget on per-file dumps after dashboards.
+
 Sections are tagged `[high]`, `[medium]`, `[low]` and listed in that order.
 
 |Tier|Project sections|Action|
 |---|---|---|
-|**high**|Cycles, unreferenced, dead exports, dead files, stale types|Nuke or fix cycles; delete unused; `_` prefix|
+|**high**|Cycles, dead exports, dead files, stale types (unreferenced is omitted when dead exports is on)|Nuke or fix cycles; delete unused; `_` prefix|
 |**medium**|Same-file only, change surface (file target)|Module-private by usage|
 |**low**|Test-only consumers, coupling, bottlenecks, hotspots|Noisy on Python (index omits many same-file calls); verify with `rg`|
 
@@ -281,7 +285,7 @@ Use `--priority high` for a quick gate; `--priority high,medium` adds context. F
 |Section|Easy pickings|
 |---|---|
 |**Cycles**|Import/mention cycles between production files — break the edge or extract shared code|
-|**Unreferenced**|No usage in the index at all — delete|
+|**Unreferenced**|Same survivors as dead exports; omitted unless `--check unreferenced`. Empty `rdeps` is usually a SCIP miss — verify with `rg -F STEM` (file basename in `(...)`)|
 |**Dead exports**|No external refs — delete or `_` prefix|
 |**Stale types**|Classes/types with no external consumer in the index — verify in-file or type-only use before removing|
 |**Same-file only**|Used only inside defining file — rename to `_`|

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.9.1 → scip_cli-2.11.0}/pyproject.toml

@@ -54,9 +54,10 @@ testpaths = ["tests"]
 python_files = ["test_*.py"]
 python_classes = ["Test*"]
 python_functions = ["test_*"]
-addopts = "-q --tb=line --no-header"
+addopts = "-q --tb=line --no-header -m 'not benchmark'"
 markers = [
     "integration: uses the shared indexed TS fixture (requires npx / scip-typescript)",
+    "benchmark: scaled :memory: query timings (run via scripts/bench.sh only)",
 ]
 
 [tool.basedpyright]

{scip_cli-2.9.1 → 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.
@@ -64,7 +64,7 @@ Commands emit one record per line on stdout; warnings and progress go to stderr.
 |Goal|Pipeline|
 |---|---|
 |Blast radius of a file|`scip-cli rdeps file.ts \|xargs -I{} scip-cli symbols {}`|
-|Pre-change / health briefing|`scip-cli analyze` or `scip-cli analyze path/to/file.ts` or `scip-cli analyze SymbolName`|
+|Pre-change / health briefing|`scip-cli analyze --limit 40 --per-check-limit 5` (or a file / symbol)|
 |Files that import a symbol|`scip-cli refs Foo --paths-only`|
 |Symbols in referencing files|`scip-cli refs Foo --paths-only \|xargs -I{} scip-cli symbols {}` (barrel files may have no symbols; prefer `search Foo --paths-only` for definition files)|
 |Find classes, list members|`scip-cli search Handler --kind class --names-only \|xargs -I{} scip-cli members {}`|
@@ -133,7 +133,7 @@ Returns `startLine:endLine kind name` for each member. Members are found via SCI
 ### analyze
 
 ```bash
-analyze [--limit N] [--path PATH] [--include-tests] [--priority LEVEL] [--check NAME] [target]
+analyze [--limit N] [--per-check-limit N] [--path PATH] [--include-tests] [--priority LEVEL] [--check NAME] [target]
 ```
 
 |Target|Output|
@@ -143,9 +143,11 @@ analyze [--limit N] [--path PATH] [--include-tests] [--priority LEVEL] [--check
 |**file**|Scoped project dashboards for that file + per-file sections + top symbols by external consumers|
 |**symbol**|Symbol pressure, consumers, dependencies, affected|
 
-Sections are ordered **high → medium → low**. `[high]` cycles, unreferenced, dead exports, dead files, stale types; `[medium]` same-file-only, change surface (file); `[low]` test-only consumers (noisy on Python), coupling, bottlenecks, hotspots.
+Sections are ordered **high → medium → low**. `[high]` cycles, dead exports, dead files, stale types (unreferenced is skipped when dead exports is on — same survivors; file-target unreferenced-in-file is skipped when dead-in-file is on); `[medium]` same-file-only, change surface (file); `[low]` test-only consumers (noisy on Python), coupling, bottlenecks, hotspots.
 
-`--limit` caps **result rows across the whole run** (default 20); remaining checks are skipped once the cap is reached. `(none)` sections and section headers do not count.
+`--limit` caps **result rows across the whole run** (default 20); remaining checks are skipped once the cap is reached. `(none)` sections, headers, and `… truncated` / `[note]` lines do not count as findings. `--per-check-limit N` additionally caps each section (default: unlimited) so one noisy check cannot spend the whole budget. Agents: `analyze --limit 40 --per-check-limit 5`.
+
+Directory `analyze some/dir` spends the **same global `--limit`** on per-file sections after dashboards (max 30 files). Prefer project/dir dashboards, then `analyze` one file.
 
 `--priority high` or `--priority high,medium` (also `1`/`2`/`3`) skips lower tiers.
 
@@ -153,9 +155,7 @@ Sections are ordered **high → medium → low**. `[high]` cycles, unreferenced,
 
 Directory detection uses the filesystem when present, otherwise an indexed path prefix. `--path` narrows ambiguous file/symbol resolution only (not directory scope — pass the dir as `target`).
 
-**Dogfood loop:** `reindex` → `analyze --limit 25` → `analyze scip_cli` or `analyze scip_cli/queries.py` on suspects. Skips test paths in project-wide and directory runs (`tests/`, `*.test.*`, `*.spec.*`); `--include-tests` to include them. File-target analyze always includes that file.
-
-**Easy pickings:** **Cycles**, **dead exports**, and **dead files** (production paths) — cross-file cleanup. **Stale types** — types with no external refs in the index. Ignore `analyze/*` section helpers in dead exports. “Dead” = no refs from _other_ files in the index (empty `rdeps` for files), not `vulture`. Sections with hits print a short false-positive caveat; `export const` arrows often look like dead files because SCIP indexes the module only.
+**Easy pickings:** **Cycles**, **dead exports**, and **dead files** (production paths) — cross-file cleanup. **Stale types** — types with no external refs in the index. Ignore `analyze/*` section helpers in dead exports. “Dead” = no refs from _other_ files in the index, not `vulture`. Empty `scip-cli rdeps` on a hit is usually a SCIP miss (`require()`, named imports, barrels), not proof unused. Unreferenced is omitted when dead exports is on (same survivors). Sections with hits print one `Warn:`; for each row run `rg -F STEM` where STEM is the **file basename inside `(...)`**, no extension — ignore hits in that same file. Do not `rg` the symbol name.
 
 ### reindex
 
@@ -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.9.1 → scip_cli-2.11.0}/scip_cli/__init__.py

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

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

@@ -11,7 +11,13 @@ import sys
 from collections.abc import Callable
 
 from . import __version__
-from .cli_args import add_limit_argument, add_names_only_argument, add_path_argument, add_paths_only_argument
+from .cli_args import (
+    add_limit_argument,
+    add_names_only_argument,
+    add_path_argument,
+    add_paths_only_argument,
+    positive_int,
+)
 from .commands import analyze, code, deps, members, rdeps, refs, reindex, search, skill, symbols
 from .symbols import SymbolKind
 
@@ -131,6 +137,13 @@ def main() -> None:
     )
     add_path_argument(analyze_parser)
     add_limit_argument(analyze_parser, default=20, help_suffix="result rows total")
+    analyze_parser.add_argument(
+        "--per-check-limit",
+        type=positive_int(),
+        default=None,
+        metavar="N",
+        help="Max rows per check (default: unlimited). --limit remains the global row budget",
+    )
     analyze_parser.add_argument(
         "--include-tests",
         action="store_true",
@@ -182,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.11.0/scip_cli/analyze/common.py

@@ -0,0 +1,243 @@
+"""Shared SQL helpers and formatting for analyze checks."""
+
+from __future__ import annotations
+
+import re
+from collections.abc import Callable, Iterable
+
+from ..sql import debug_execute
+from ..symbols import extract_leaf_name, is_module_symbol
+
+DEFAULT_LIMIT = 20
+# Cap rows scanned when post-filtering SQL (filters drop many SCIP false hits).
+ANALYZE_MAX_SCAN_ROWS = 10_000
+
+
+def collect_until_limit(
+    limit: int,
+    fetch_page: Callable[[int, int], list[object]],
+    accept: Callable[[object], str | None],
+    *,
+    page_size: int | None = None,
+    max_scan: int = ANALYZE_MAX_SCAN_ROWS,
+) -> list[str]:
+    """Fetch SQL pages until `limit` rows pass `accept`, or data is exhausted.
+
+    Use only when a check post-filters SQL rows (analyze_noise, live heuristics, …).
+    Checks that format every SQL row as-is should use a single ``LIMIT ?`` instead.
+    """
+    batch = page_size or max(limit, 50)
+    lines: list[str] = []
+    offset = 0
+    scanned = 0
+    while len(lines) < limit:
+        rows = fetch_page(batch, offset)
+        if not rows:
+            break
+        for row in rows:
+            scanned += 1
+            if scanned > max_scan:
+                return lines
+            line = accept(row)
+            if line is None:
+                continue
+            lines.append(line)
+            if len(lines) >= limit:
+                return lines
+        if len(rows) < batch:
+            break
+        offset += len(rows)
+    return lines
+
+
+def collect_from_producer(
+    limit: int,
+    produce: Callable[[int], list[str]],
+    accept: Callable[[str], str | None],
+    *,
+    max_scan: int = ANALYZE_MAX_SCAN_ROWS,
+) -> list[str]:
+    """Fill ``limit`` rows from a capped producer that can return more candidates on retry.
+
+    Used when results are not SQL-paginated (e.g. graph cycle search). ``produce(cap)``
+    must return a deterministic prefix as ``cap`` grows; already-seen strings are skipped.
+    """
+    lines: list[str] = []
+    seen: set[str] = set()
+    scanned = 0
+    fetch_cap = limit
+    while len(lines) < limit and fetch_cap <= max_scan:
+        candidates = produce(fetch_cap)
+        if not candidates:
+            break
+        for candidate in candidates:
+            if candidate in seen:
+                continue
+            seen.add(candidate)
+            scanned += 1
+            if scanned > max_scan:
+                return lines
+            line = accept(candidate)
+            if line is None:
+                continue
+            lines.append(line)
+            if len(lines) >= limit:
+                return lines
+        if len(candidates) < fetch_cap:
+            break
+        fetch_cap += limit
+    return lines
+
+
+def collect_from_iterable(
+    limit: int,
+    candidates: Iterable[str],
+    accept: Callable[[str], str | None],
+    *,
+    max_scan: int = ANALYZE_MAX_SCAN_ROWS,
+) -> list[str]:
+    """Filter an in-memory candidate list until ``limit`` rows pass ``accept``."""
+    lines: list[str] = []
+    scanned = 0
+    for candidate in candidates:
+        scanned += 1
+        if scanned > max_scan:
+            break
+        line = accept(candidate)
+        if line is None:
+            continue
+        lines.append(line)
+        if len(lines) >= limit:
+            break
+    return lines
+
+
+# Definition document for a symbol (our trimmed schema uses defn_enclosing_ranges).
+SYM_DEF_JOIN = """
+    JOIN defn_enclosing_ranges sym_def ON sym_def.symbol_id = gs.id
+    JOIN documents def_d ON sym_def.document_id = def_d.id
+"""
+
+
+def fetch_all(db, sql: str, params=()):
+    return debug_execute(db, sql, params).fetchall()
+
+
+def fetch_one(db, sql: str, params=()):
+    return debug_execute(db, sql, params).fetchone()
+
+
+def short_name(symbol: str) -> str:
+    if is_module_symbol(symbol):
+        return "(module)"
+    leaf = extract_leaf_name(symbol)
+    if leaf:
+        return leaf
+    if symbol.endswith("/"):
+        return "(module)"
+    return symbol.split("/")[-1][:60]
+
+
+def is_test_path(relative_path: str) -> bool:
+    """True for common test layout paths and test-like filenames."""
+    p = relative_path.replace("\\", "/")
+    lower = p.lower()
+    if lower.startswith(("tests/", "test/")):
+        return True
+    if "/tests/" in lower or "/test/" in lower or "/__tests__/" in lower:
+        return True
+    if "/__fixtures__/" in lower or "/__mocks__/" in lower:
+        return True
+    name = lower.rsplit("/", 1)[-1]
+    if ".test." in name or ".spec." in name or ".mocha." in name:
+        return True
+    stem = name.rsplit(".", 1)[0]
+    if stem.endswith("_test") or stem.endswith("_spec"):
+        return True
+    if "test-fixture" in name or "test_fixture" in name or "test-mocks" in name:
+        return True
+    if name.startswith("test_") and name.endswith(".py"):
+        return True
+    return name == "conftest.py"
+
+
+def is_dynamic_loader_path(relative_path: str) -> bool:
+    """True for migration files typically loaded by filename; SCIP has no import edge."""
+    p = relative_path.replace("\\", "/").lower()
+    return "/migrations/" in p
+
+
+def is_python_main_entrypoint(relative_path: str, symbol: str) -> bool:
+    """True for main() in __main__.py — argparse entrypoints SCIP does not link to callers."""
+    if short_name(symbol) != "main":
+        return False
+    return relative_path.replace("\\", "/").endswith("__main__.py")
+
+
+def analyze_noise(relative_path: str, symbol: str, *, include_tests: bool = False) -> bool:
+    """True for rows that clutter analyze dashboards (test paths, module-private helpers)."""
+    if not include_tests and is_test_path(relative_path):
+        return True
+    if short_name(symbol).startswith("_"):
+        return True
+    if is_python_main_entrypoint(relative_path, symbol):
+        return True
+    if is_dynamic_loader_path(relative_path):
+        return True
+    if short_name(symbol) in {"<constructor>", "constructor"}:
+        return True
+    return is_analyze_dashboard_export(relative_path, symbol)
+
+
+_ANALYZE_DASHBOARD_SUFFIXES = (
+    "analyze/project.py",
+    "analyze/file.py",
+    "analyze/symbol.py",
+)
+
+
+def is_analyze_dashboard_export(relative_path: str, symbol: str) -> bool:
+    """Section runner functions in analyze/* (same-file only, look like dead exports)."""
+    path = relative_path.replace("\\", "/")
+    if not any(path.endswith(suffix) for suffix in _ANALYZE_DASHBOARD_SUFFIXES):
+        return False
+    name = short_name(symbol)
+    return "()." in symbol or name.endswith(")")
+
+
+def is_component_props_type(symbol: str) -> bool:
+    """React-style Props interfaces — rarely referenced outside the component file."""
+    name = short_name(symbol)
+    return bool(name and name.endswith("Props") and "#" in symbol.split("/")[-1])
+
+
+def stale_type_noise(relative_path: str, symbol: str, consumers: int) -> bool:
+    """Dataclass-style types with no SCIP consumers (typing-only)."""
+    if is_component_props_type(symbol):
+        return True
+    if consumers > 0:
+        return False
+    name = short_name(symbol)
+    if not name or name == "(module)" or not name[0].isupper():
+        return False
+    path = relative_path.replace("\\", "/")
+    return path.endswith(("config.py", "scope.py", "analyze/targets.py"))
+
+
+def file_pair_noise(file1: str, file2: str, *, include_tests: bool = False) -> bool:
+    if include_tests:
+        return False
+    return is_test_path(file1) or is_test_path(file2)
+
+
+def cycle_path_noise(cycle_line: str, *, include_tests: bool = False) -> bool:
+    if include_tests:
+        return False
+    parts = re.split(r"\s<->\s|\s->\s", cycle_line)
+    return any(is_test_path(part.strip()) for part in parts if part.strip())
+
+
+def section(title: str, lines: list[str], *, preface: str | None = None) -> tuple[str, list[str], str | None]:
+    if not lines:
+        return title, ["(none)"], None
+    return title, lines, preface