scip-query 0.7.2 → 0.8.0

package/README.md

@@ -1,107 +1,204 @@
-# scip-query
+<p align="center">
+  <img src="docs/assets/scip-query-logo.png" alt="scip-query logo" width="120">
+</p>
 
-Language-agnostic code intelligence CLI powered by [SCIP](https://github.com/sourcegraph/scip) indexes. Index a codebase once, then ask direct questions about symbols, references, dependencies, dead code, similarity, coupling, impact, and health without keeping an IDE or language server running.
+<h1 align="center">scip-query</h1>
 
-Works with every language that has a SCIP indexer: TypeScript, JavaScript, Vue, Java, Scala, Kotlin, Rust, Python, Ruby, Go, C/C++, C#, Visual Basic, Dart, PHP.
+<p align="center">
+  <strong>Structural code intelligence for AI agents and engineers.</strong>
+</p>
 
-## Purpose
+<p align="center">
+  Ask compiler-backed questions about how a codebase is wired together, find what's rotting, and delete it with a compiler proof in hand.
+</p>
 
-`scip-query` exists to make codebase understanding operational. A large codebase is a collection of source files, symbols, and dependency paths that people need to change without accidentally breaking users. This project turns compiler-produced code intelligence into terminal commands that answer the questions engineers and agents ask before they edit:
+<p align="center">
+  <a href="https://www.npmjs.com/package/scip-query"><img alt="npm version" src="https://img.shields.io/npm/v/scip-query.svg"></a>
+  <a href="https://www.npmjs.com/package/scip-query"><img alt="npm downloads" src="https://img.shields.io/npm/dm/scip-query.svg"></a>
+  <a href="package.json"><img alt="Node version" src="https://img.shields.io/node/v/scip-query.svg"></a>
+  <a href="https://www.apache.org/licenses/LICENSE-2.0"><img alt="License" src="https://img.shields.io/npm/l/scip-query.svg"></a>
+</p>
 
-- What is defined here?
-- Who uses this symbol?
-- What depends on this file?
-- What changes if I modify this API?
-- Which cleanup findings are backed by real reference evidence?
-- Where is the architecture drifting, duplicating work, or hiding complexity?
+<p align="center">
+  <a href="https://www.npmjs.com/package/scip-query"><img alt="Install from npm" src="https://img.shields.io/badge/install-npm-cb3837?style=for-the-badge&logo=npm&logoColor=white"></a>
+  <a href="docs/AGENT_GUIDE.md"><img alt="Agent guide" src="https://img.shields.io/badge/agent-guide-2563eb?style=for-the-badge"></a>
+  <a href="docs/COMMAND_REFERENCE.md"><img alt="Command reference" src="https://img.shields.io/badge/command-reference-111827?style=for-the-badge"></a>
+</p>
 
-The vision is a reliable code-intelligence layer for both humans and coding agents: fast enough to use during ordinary development, accurate enough to trust for planning, and explicit about confidence when an analysis moves beyond compiler-backed facts.
+`scip-query` answers precise questions about how a codebase is wired together — where a symbol is defined, who references it, what calls it, what breaks if it changes — and turns those answers into something rarer: **cleanup you can trust**. Findings are ranked by evidence quality, validated against your repo's own git history, and (for deletions) proven safe by your own compiler before you touch anything.
 
-## Problems It Solves
+Works with every language that has a [SCIP](https://github.com/sourcegraph/scip) indexer: TypeScript, JavaScript, Vue, Java, Scala, Kotlin, Rust, Python, Ruby, Go, C/C++, C#, Visual Basic, Dart, PHP.
 
-- **Navigation without IDE state.** Query definitions, references, outlines, members, call graphs, and source snippets from a terminal or automation loop.
-- **Change planning.** Use `affected`, `change-surface`, and `diff-impact` to identify downstream consumers before and after a change.
-- **Architecture visibility.** Use `deps`, `rdeps`, `system`, `surface`, `coupling`, `cycles`, and `deep-chains` to see how modules actually relate.
-- **Codebase cleanup.** Use `dead`, `stale-abstractions`, `wrapper-candidates`, `passthrough-candidates`, `similar`, `similar-signatures`, `extract-candidates`, and `drift` to find removal or consolidation opportunities.
-- **Health reporting.** Use `health` to aggregate cleanup signals into one prioritized report instead of running dozens of commands by hand.
-- **Agent workflows.** Install the bundled Codex/Claude skills so agents can explore, plan, de-bloat, and verify changes with a consistent command vocabulary.
+## Install
 
-## Accuracy Model
+```bash
+npm install -g scip-query@latest
+scip-query reindex          # index the current project
+scip-query health           # see where you stand
+```
+
+Or without a global install: `npx scip-query@latest reindex`.
 
-A SCIP index is a database-shaped record of code facts produced by language-aware indexers: the source files they read, the symbols they define, and the references they resolve. Because these facts come from compilers, type checkers, or language servers, direct definition and reference queries are much stronger evidence than text search.
+## The Problem
 
-`scip-query` separates three kinds of evidence:
+Two problems, actually.
 
-- **Compiler-backed facts** come from the SCIP database. Commands like `symbols`, `refs`, `trace`, `deps`, `rdeps`, `surface`, and most symbol-level counts start here.
-- **Semantic augmentation** adds language-specific checks when available. TypeScript projects use `ts-morph` to verify references, import usage, callers, callees, and signatures when SCIP alone is incomplete.
-- **Source-backed heuristics** use parsed source text or ASTs to keep higher-level cleanup commands useful when an indexer omits call-site details. These findings are designed as investigation leads, not blind deletion instructions.
+**Agents lose the thread.** A codebase is files connected by definitions, references, imports, calls, and dependency paths. Reading files gives local text, not verified structure. Search finds matching words, not real references. Before editing one unit you need to know what it is, who uses it, and what depends on it — with evidence, not vibes.
 
-The goal is not to replace compiler facts with regexes. The goal is to use the strongest available evidence first, fall back only when needed, and keep cleanup commands conservative enough that speed does not trade away accuracy.
+**AI-generated code rots in specific ways.** Agents re-implement helpers they didn't know existed. They leave parallel half-wired implementations behind. They add parameters and options "for later" that never come. And the standards docs you write *for* them drift away from the code — so the next agent implements against a dead spec. Generic linters don't see any of this, because none of it is visible in a single file.
 
-## Workflows
+`scip-query` attacks both: structural questions with evidence-backed answers, and rot detectors tuned to how code actually decays — each one validated, and each one honest about its own confidence.
 
-For goal-oriented usage guides (not just command reference), see **[Agent Guide](docs/AGENT_GUIDE.md)**:
+## Three Sources of Evidence
 
-- **[Understand a system](docs/AGENT_GUIDE.md#workflow-1-understand-a-system-before-making-changes)** — map a module, trace symbols, check blast radius
-- **[Write an implementation plan](docs/AGENT_GUIDE.md#workflow-2-write-a-concrete-implementation-plan)** — identify contracts, map dependencies, find reusable code
-- **[De-bloat a codebase](docs/AGENT_GUIDE.md#workflow-3-clean-up-and-de-bloat-a-codebase)** — prioritized cleanup from dead code to pattern drift
-- **[Assess code quality](docs/AGENT_GUIDE.md#workflow-4-assess-code-quality-and-risk)** — health score, complexity hotspots, coupling risks
-- **[Verify change impact](docs/AGENT_GUIDE.md#workflow-5-understand-impact-after-making-changes)** — diff impact, transitive blast radius, consumer blast radius
+Most code tools have one lens. `scip-query` has three, and tells you which one each answer came from:
 
-Historical implementation plans and completed cleanup notes live in [`docs/plans/`](docs/plans/).
+```mermaid
+flowchart LR
+  A["Reference graph<br/>(SCIP: compilers & language servers)"] --> D["scip-query"]
+  B["Change graph<br/>(git history: co-change, churn, fix density)"] --> D
+  C["Verification oracles<br/>(tsc / cargo check / ts-morph)"] --> D
+  D --> E["Evidence-ranked answers<br/>graph-fact · change-graph · heuristic · compiler-verified"]
+```
 
-## Install From npm
+1. **The reference graph** — who defines, references, calls, imports what. Built from SCIP indexes produced by real compilers and language servers, not text search.
+2. **The change graph** — what git history knows that no compiler can: files that always change together without any dependency edge (one concept scattered across artifacts), churn-weighted complexity (gnarly code nobody touches costs nothing), and whether flagged files actually attract fix commits.
+3. **Verification oracles** — your own toolchain as ground truth. Deletion plans are applied in a throwaway worktree and run through `tsc`/`cargo check` before being stamped `COMPILER-VERIFIED`. The tool even audits *itself*: `self-audit` scores its cheap evidence paths against the TypeScript compiler and reports precision/recall as a tracked number.
 
-Install the published CLI globally from npm:
+## At a Glance
+
+| Ask this | Run this |
+|---|---|
+| What is in this module? | `scip-query system src/auth` |
+| Who uses this symbol? | `scip-query trace login` |
+| What might break if I change it? | `scip-query affected login` |
+| Everything I need before editing this | `scip-query plan-context login` |
+| What did my git diff affect? | `scip-query diff-impact` |
+| How healthy is this codebase, really? | `scip-query health` |
+| What can I delete — *prove it* | `scip-query cleanup-plan --verify` |
+| What new code duplicates old code? | `scip-query recent-duplicates` |
+| Which docs lie about the code now? | `scip-query doc-drift` |
+| What changes together but isn't linked? | `scip-query co-change` |
+| Gate an agent's diff before merging | `scip-query diff-gate` |
+| Did the findings get worse? (CI gate) | `scip-query health --baseline` |
+
+## Cleaning Up AI-Generated Code
+
+This is the workflow the tool is built around. Each detector targets a specific way AI-assisted development rots a codebase:
+
+**1. Find the echoes.** Agents re-implement helpers they didn't know existed. `recent-duplicates` makes similarity *directional* using git file ages — which side is the established original, which is the recent echo:
 
-```bash
-npm install -g scip-query@latest
-scip-query --version
+```
+91%  ECHO  src/components/ProjectCardVisual.tsx  ProjectCardVisual()  (added 62 commits ago)
+     duplicates established  src/pages/HomePage.tsx  RecentProjectRow()
+100% TWIN  src/workflows/a.ts ensureAccessible() / src/workflows/b.ts ensureAccessible()
+     (both new — one agent session duplicated itself; consolidate before they diverge)
 ```
 
-You can also run it without a global install:
+**2. Catch your standards docs lying.** If you keep in-repo standards for agents to read before implementing, a stale standard is worse than none. `doc-drift` reads every doc's file citations *and* its co-change history, then flags docs whose code moved on without them — including **broken references** to files that no longer exist:
+
+```
+staleness 94  product/domain-model.md
+  BROKEN REFERENCE: cites src/api/servicePlans.ts — that file no longer exists
+  22 change(s) since doc update  src/workflows/serviceTasks.ts  (referenced by doc)
+```
+
+**3. Delete with proof.** `cleanup-plan` runs dead-code analysis to a *fixpoint* — deleting batch 0 makes batch 1 dead, and the plan shows the cascade. `--verify` applies each batch in a throwaway git worktree and runs your own compiler (differentially, so pre-existing errors don't drown the signal):
+
+```
+── Batch 0: deletable now (graph-fact, 67 LOC) ──
+── Batch 1: dead once batch 0 lands (cascade, 21 LOC) ──
+Batch 0: COMPILER-VERIFIED
+```
+
+When verification *fails*, the errors name the exact references the static evidence missed — that failure has caught real detector mistakes and stopped build-breaking deletions.
+
+**4. Trim speculative generality.** `unused-params` finds trailing parameters no body ever uses (the classic "options for later"), scoped to removals that are type-safe by construction.
+
+**5. Surface hidden coupling.** `co-change` finds file pairs that repeatedly change in the same commits with *no* dependency edge — schema ↔ generated inventory ↔ doc triangles, backend schemas ↔ frontend stores, `.env.example` ↔ its parser. The reference graph cannot see these; the change graph can.
+
+**6. Gate every diff.** `diff-gate` runs the whole suite scoped to what a change *introduces* — echoes of established code, missing co-change partners, docs that cite the changed files, fresh unused params, new dead symbols, baseline regressions — in seconds, exit-code friendly, with a remediation per finding an agent can act on without human triage:
+
+```
+[co-change-partner] schema.prisma changed, but scripts/scope-inventory.mjs did not — they change together 12x (86% of the time)
+  -> Update scripts/scope-inventory.mjs alongside this change, or confirm the coupling no longer holds.
+```
+
+**7. Ratchet it in CI.** `health --write-baseline` snapshots finding identities into a committable file; `health --baseline` exits 1 on any *new* finding. "Don't get worse" is an objective gate that no score arithmetic can game.
+
+Before any edit, `plan-context <target>` bundles the structural picture — definitions, references, call graph, blast radius — plus a HISTORY section: churn, fix-commit density, and the files that usually change together with the target ("editing this usually means editing these").
+
+## A Health Score You Can Argue With
+
+`scip-query health` refuses to be a vanity number:
+
+```
+Codebase Health Score: 95/100
+  Risk:    95/100  (validated predictors: graph facts + change graph)
+  Hygiene: 100/100 (tidiness candidates)
+
+Score Breakdown (100 minus the following):
+  - 5  hidden-coupling: 5 co-changing pair(s) without a dependency edge
+
+Axes:
+  Deletable:            1,027 LOC across 89 symbols
+  Change amplification: 5 files/commit median, 23 p90
+  Evidence quality:     5 graph-fact, 150 heuristic, 0 user-suppressed
+  Validation:           flagged fix-density 0.12 vs baseline 0.20 (0.6x)
+```
+
+- **Risk vs. Hygiene** are separate claims: risk components are empirically fix-predictive; hygiene components are tidiness. Blending them is how scores become meaningless.
+- **Every deduction is itemized** — the scalar is auditable, not vibes.
+- **The validation axis is a falsifiability loop**: it measures whether flagged files actually attract more fix commits than the rest *in your repo*, per detector. On some codebases passthrough findings predict fixes at 6× baseline; on others they're noise — the tool reports which, instead of assuming.
+- **Suppressions are data**: every `// scip-query: ignore-*` comment is a precision label, counted and reported.
+
+## Accuracy Model
+
+Evidence tiers are kept explicit, strongest first:
+
+1. **Compiler-backed facts** from the SCIP database (`trace`, `refs`, `deps`, `outline`, ...).
+2. **Semantic augmentation** via `ts-morph` for TypeScript — verified references, callers, callees when SCIP alone is incomplete.
+3. **Source-backed heuristics** (AST/text) for cleanup signals. Always labeled: *"these are candidates, not exact compiler facts."*
+4. **Compiler verification** for deletions — the only tier that earns the word "safe."
+
+And because accuracy you don't measure is a feeling, `self-audit` samples symbols and scores the cheap paths against the TypeScript compiler:
 
-```bash
-npx scip-query@latest --version
-npx scip-query@latest reindex
 ```
+references  precision 1.0  recall 0.9   (the cheap path doesn't fabricate; it occasionally misses)
+```
+
+Heuristic detectors carry guardrails learned from real codebases: published `package.json` surfaces are exempt from "unused" advice, `contracts/` and `types/` modules are exempt from "definer never uses it," test files and component-sibling files don't count as hidden coupling, and changelogs-by-policy aren't drift.
+
+## Agent Skills
 
-The npm package is published at [`scip-query`](https://www.npmjs.com/package/scip-query). `@latest` should resolve to the newest published version.
+`scip-query install-skills` symlinks ready-made skills into Claude Code, Codex, and shared agent roots — workflows for exploring (`scip-explore`), debloating (`scip-debloat`), maintainability review (`scip-maintainability`), claim verification (`scip-verify`), per-language guidance (`scip-language-playbook`), and grounded planning (`concrete-plan`).
 
 ## Quick Start
 
 ```bash
-# Install
-npm install -g scip-query@latest
-scip-query --version
-scip-query check-deps                # verify optional indexers and parser support
-scip-query install-skills            # install built-in Codex/Claude skills
-
-# Index your project (auto-detects language)
+scip-query check-deps        # verify indexers are runnable
+scip-query install-skills    # optional: agent skills
 scip-query reindex
 
-# Start querying
 scip-query stats
-scip-query health                        # full codebase health report
-scip-query symbols src/auth.service.ts
-scip-query refs login
-scip-query affected login                # transitive blast radius
-scip-query dead --min-loc 10
-scip-query similar --min-similarity 0.5
-scip-query diff-impact                   # what did my changes affect?
+scip-query system src/auth
+scip-query plan-context login
+scip-query health
+scip-query cleanup-plan --verify
+scip-query health --write-baseline   # start the ratchet
 ```
 
 ## Prerequisites
 
-- **Node.js** >= 18
-- **scip** CLI - [Install from releases](https://github.com/sourcegraph/scip/releases) (converts index data to SQLite)
-- A language-specific SCIP indexer for your project:
+- Node.js >= 18
+- `scip` CLI, from [Sourcegraph SCIP releases](https://github.com/sourcegraph/scip/releases)
+- A language-specific SCIP indexer for your project
 
 | Language | Indexer | Install |
 |---|---|---|
 | TypeScript / JavaScript / Vue | scip-typescript | `npm install -g @sourcegraph/scip-typescript` |
 | Java / Scala / Kotlin | scip-java | [releases](https://github.com/sourcegraph/scip-java/releases) |
-| Rust | rust-analyzer | Ships with rust-analyzer (`rust-analyzer scip`) |
+| Rust | rust-analyzer | Ships with rust-analyzer: `rust-analyzer scip` |
 | Python | scip-python-plus | `npm install -g scip-python-plus` |
 | Go | scip-go | `go install github.com/sourcegraph/scip-go@latest` |
 | Ruby | scip-ruby | [releases](https://github.com/sourcegraph/scip-ruby/releases) |
@@ -110,23 +207,27 @@ scip-query diff-impact                   # what did my changes affect?
 | Dart | scip-dart | [releases](https://github.com/nicovince/scip-dart/releases) |
 | PHP | scip-php | [releases](https://github.com/nicovince/scip-php/releases) |
 
-For Python, the npm package is `scip-python-plus`. Depending on which version you installed, the executable on your `PATH` may be `scip-python`, `scip-python-plus`, or both. `scip-query` accepts either name.
+For Python, the executable may be `scip-python`, `scip-python-plus`, or both. `scip-query` accepts either name.
 
-Vue single-file components (`.vue`) are handled by the JavaScript/TypeScript indexer. `scip-query` extracts the `<script>` block (or `<script setup>`, picking the language from the `lang=` attribute) and parses it as TS/JS so symbol, reference, and import queries cover Vue components alongside regular `.ts`/`.js` files.
+Vue single-file components are handled through the JavaScript/TypeScript indexer. `scip-query` also extracts the `<script>` or `<script setup>` block so symbol, reference, and import queries cover Vue components alongside regular `.ts` and `.js` files.
 
 ## How It Works
 
-1. A SCIP indexer analyzes your source code using the actual compiler/type checker and produces a `index.scip` protobuf file containing symbols, definitions, and references.
-2. The `scip` CLI converts the protobuf to a SQLite database (`index.db`).
-3. `scip-query` runs SQL queries and language-aware source augmentation against that database to answer questions about your codebase.
+1. A SCIP indexer analyzes source code with the actual compiler, type checker, or language server and produces `index.scip`.
+2. The `scip` CLI converts that protobuf file to a SQLite database: `index.db`.
+3. `scip-query` runs SQL queries, language-aware source augmentation, and git-history analysis against it.
 
-Because the index comes from real language tooling, direct symbol, definition, and reference queries are precise, not grep-based approximations. When a language index is missing enough call-site detail for higher-level analyses, `scip-query` can fall back to AST parsing, semantic providers, and identifier recovery so those commands stay useful while still reporting conservative results.
+By default, indexes live in `~/.cache/scip-query/projects/<hash>/`, keeping project directories clean. Override paths with `.scipquery.json` or `SCIP_QUERY_*` environment variables.
 
 ## Configuration
 
-### Per-project config
+Run this in a project root:
 
-Run `scip-query init` to generate a `.scipquery.json` in your project root:
+```bash
+scip-query init
+```
+
+It creates `.scipquery.json`:
 
 ```json
 {
@@ -144,7 +245,7 @@ Run `scip-query init` to generate a `.scipquery.json` in your project root:
 }
 ```
 
-### Environment variables
+Useful environment variables:
 
 | Variable | Purpose |
 |---|---|
@@ -153,157 +254,14 @@ Run `scip-query init` to generate a `.scipquery.json` in your project root:
 | `SCIP_QUERY_INDEX_SCIP` | Override the SCIP protobuf path |
 | `SCIP_QUERY_CACHE_DIR` | Override the cache directory |
 
-### Index storage
-
-By default, indexes are stored in `~/.cache/scip-query/projects/<hash>/` (following XDG conventions). This keeps your project directory clean. Override with the `dbPath` field in `.scipquery.json` or the `SCIP_QUERY_CACHE_DIR` environment variable.
-
-### Gitignore integration
-
-All query results are filtered through your project's `.gitignore`. Build artifacts (`dist/`, `target/`, `__pycache__/`), dependency directories (`node_modules/`, `vendor/`), and virtual environments (`.venv/`) are automatically excluded. If no `.gitignore` exists, sensible defaults are applied.
-
----
-
-## Command Reference
-
-<!-- BEGIN GENERATED COMMAND REFERENCE -->
+Query results are filtered through the project's `.gitignore`. If none exists, common generated directories such as `dist/`, `target/`, `node_modules/`, and `.venv/` are excluded by default.
 
-This syntax summary is generated from the CLI command descriptors. Keep workflow guidance hand-authored, but keep command syntax, descriptions, and option flags descriptor-owned.
+## Documentation
 
-### Indexing
-
-| Command | Description | Options |
-|---|---|---|
-| `reindex` | Index the codebase and convert to SQLite | `-l, --language <lang>`<br>`--pnpm-workspaces`<br>`--force`<br>`--allow-partial`<br>`--indexer-concurrency <n>` |
-| `augment-sources` | Add source files skipped by upstream SCIP indexers to the SQLite documents table | - |
-| `augment-vue` | Add compiler-resolved Vue SFC references to the SQLite index using Volar | `--project <tsconfig>` |
-
-### Core
-
-| Command | Description | Options |
-|---|---|---|
-| `stats` | Show index statistics | - |
-
-### Navigation
-
-| Command | Description | Options |
-|---|---|---|
-| `files <pattern>` | Find files matching a pattern | - |
-| `symbols <file>` | List symbols defined in a file (with line ranges + signatures) | - |
-| `methods <className>` | List methods of a class (with line ranges) | - |
-| `refs <symbol>` | Find all files referencing a symbol | `--full` |
-| `trace <symbol>` | Trace a symbol: definition + all references | `--full` |
-| `deps <file>` | Files this file depends on (internal) | - |
-| `rdeps <file>` | Files that depend on this file/module | - |
-| `system <module>` | Full module map: files, symbols, deps in/out | - |
-| `surface <module>` | What symbols consumers actually use from this module | - |
-| `imports <file>` | What symbols does this file import? | `--full` |
-| `imported-by <symbol>` | Which files import this symbol? | - |
-| `outline <file>` | Tree view of symbols in a file (using nesting hierarchy) | - |
-| `members <symbol>` | All children of a symbol (methods, fields, nested types) | - |
-| `by-kind <kind>` | Find symbols by SCIP kind (class, interface, enum, function, etc.) | `-s, --scope <path>`<br>`-n, --limit <n>` |
-| `kind-counts` | Histogram of symbol kinds in the codebase | `-s, --scope <path>` |
-| `hierarchy <symbol>` | Show a symbol's ancestry chain (method → class → module) | - |
-| `code <symbol>` | Read the source code for a symbol (bounded to its definition range) | `-C, --context <n>` |
-| `dataflow <symbol>` | Reference-level dataflow: definition sites, usage sites, producers, consumers | `--full` |
-| `slice <symbol>` | Reference-level program slice: what affects this (backward) or what this affects (forward) | `--forward`<br>`--depth <n>`<br>`--full` |
-
-### Cleanup
-
-| Command | Description | Options |
-|---|---|---|
-| `dead [scope]` | Find dead code and file-internal symbols (no cross-file consumers) | `--min-loc <n>`<br>`--include-tests`<br>`--skip-barrels`<br>`--include-members`<br>`--only-dead`<br>`--only-internal`<br>`--full` |
-| `unused-imports <file>` | Find imports not referenced in the same file | `--full` |
-| `isolated` | Find completely orphaned symbols (no references at all) | `-s, --scope <path>`<br>`--min-loc <n>`<br>`--full` |
-| `similar [symbol]` | Find heuristic function similarity candidates from callee fingerprints | `--min-similarity <n>`<br>`-n, --limit <n>`<br>`-s, --scope <path>`<br>`--min-callees <n>`<br>`--cross-file-only`<br>`--full` |
-| `similar-files [file]` | Find heuristic similar-file candidates from dependency profiles | `--min-similarity <n>`<br>`-n, --limit <n>`<br>`-s, --scope <path>`<br>`--min-deps <n>` |
-| `similar-chains` | Find heuristic similar-chain candidates from dependency flows | `--min-similarity <n>`<br>`-n, --limit <n>`<br>`-s, --scope <path>`<br>`--min-length <n>`<br>`--max-length <n>` |
-| `extract-candidates` | Find heuristic extraction candidates from isolated callee clusters | `-s, --scope <path>`<br>`--min-loc <n>`<br>`--min-callees <n>`<br>`-n, --limit <n>`<br>`--full` |
-| `drift [module]` | Detect heuristic drift candidates: unused imports, layer violations, and pattern deviations | `--min-deviation <n>`<br>`--full` |
-| `wrapper-candidates` | Find heuristic wrapper candidates only called by one consumer | `-s, --scope <path>`<br>`--max-loc <n>`<br>`-n, --limit <n>`<br>`--full` |
-| `passthrough-candidates` | Find heuristic passthrough candidates that forward to one callee | `-s, --scope <path>`<br>`--max-loc <n>`<br>`-n, --limit <n>`<br>`--full` |
-| `stale-abstractions` | Find heuristic stale abstraction candidates with 0-1 consumers | `-s, --scope <path>`<br>`--min-loc <n>`<br>`-n, --limit <n>`<br>`--include-low-confidence`<br>`--full` |
-| `complexity-hotspots` | Find heuristic complexity hotspot candidates from LOC x fan-in x fan-out | `-s, --scope <path>`<br>`--min-loc <n>`<br>`-n, --limit <n>`<br>`--full` |
-| `convergence <symbol1> <symbol2>` | Show what a consolidated version of two similar functions would look like | `--full` |
-| `redundant-reexports` | Find barrel re-exports that nobody imports through | `-s, --scope <path>`<br>`-n, --limit <n>` |
-| `similar-signatures` | Find functions with near-identical type signatures (same shape) | `-s, --scope <path>`<br>`--min-loc <n>`<br>`-n, --limit <n>`<br>`--full` |
-
-### Graph
-
-| Command | Description | Options |
-|---|---|---|
-| `hotspots` | Most-referenced symbols in the codebase (choke points) | `-n, --limit <n>`<br>`-s, --scope <path>` |
-| `fan-in [symbol]` | How many files reference a symbol (or top fan-in across codebase) | `-n, --limit <n>`<br>`-s, --scope <path>` |
-| `fan-out [file]` | How many external symbols a file uses (or top fan-out across codebase) | `-n, --limit <n>`<br>`-s, --scope <path>` |
-| `coupling [file1] [file2]` | Coupling between two files, or top coupled pairs in codebase | `-n, --limit <n>`<br>`-s, --scope <path>` |
-| `cycles` | Detect circular dependency chains between files | `-s, --scope <path>`<br>`--max-depth <n>` |
-| `bottlenecks` | Find coupling hubs: high fan-in AND high fan-out | `-n, --limit <n>`<br>`-s, --scope <path>`<br>`--min-fan-in <n>`<br>`--min-fan-out <n>`<br>`--full` |
-| `deep-chains` | Find the longest transitive dependency chains | `-n, --limit <n>`<br>`-s, --scope <path>`<br>`--min-depth <n>` |
-| `call-graph <symbol>` | Show incoming callers and outgoing callees for a symbol | `--full` |
-
-### Impact
-
-| Command | Description | Options |
-|---|---|---|
-| `affected <symbol>` | Transitive closure of symbols that could break if this symbol changes | `--max-depth <n>`<br>`-s, --scope <path>` |
-| `change-surface <file>` | Pre-change briefing: exports, consumers, and blast-radius risk | `--full` |
-| `diff-impact` | Compute changed symbols and downstream consumers from current git diff | `--base <ref>` |
-
-### Health
-
-| Command | Description | Options |
-|---|---|---|
-| `health` | Composite codebase health report with prioritized action list | `-s, --scope <path>`<br>`--full`<br>`--json` |
-| `complexity <symbol>` | Per-symbol complexity: branches, cyclomatic estimate, fan-in/out, callees | `--full` |
-
-### Maintenance
-
-| Command | Description | Options |
-|---|---|---|
-| `install-skills` | Install skills (concrete-plan, scip-explore, scip-debloat, scip-verify, scip-language-playbook) into Claude Code and Codex | - |
-| `check-deps` | Check whether scip-query and the detected language indexers are actually runnable | - |
-| `init` | Create a .scipquery.json config file for this project | - |
-| `watch` | Watch for file changes and reindex automatically | `--debounce <ms>`<br>`--cooldown <ms>` |
-| `status` | Show index status for this project | - |
-
-<!-- END GENERATED COMMAND REFERENCE -->
-
-
-## Programmatic API
-
-Every CLI command is also a TypeScript function. The `queries` namespace exports cover all of them — including the `top*` variants of `fan-in`, `fan-out`, and `coupling`, plus `similarAll` for the cross-codebase mode of `similar`:
-
-```typescript
-import {
-  ScipDatabase, createGitignoreFilter,
-} from 'scip-query';
-import {
-  health, affected, changeSurface, diffImpact,
-  hotspots, similar, dead, convergence,
-} from 'scip-query/queries';
-
-const filter = createGitignoreFilter('/path/to/project');
-const db = new ScipDatabase({
-  dbPath: '/path/to/index.db',
-  indexPath: '/path/to/index.scip',
-  projectRoot: '/path/to/project',
-}, filter);
-
-// Full health report
-const report = health(db);
-console.log(`Score: ${report.score}/100`);
-console.log(`Actions: ${report.actions.length}`);
-
-// Impact analysis
-const blast = affected(db, 'login', { maxDepth: 3 });
-const brief = changeSurface(db, 'auth.service.ts');
-const impact = diffImpact(db, { base: 'main' });
-
-// Consolidation
-const pairs = similar(db, 'myFunction', { minSimilarity: 0.5 });
-const recipe = convergence(db, 'funcA', 'funcB');
-
-db.close();
-```
+- [Agent Guide](docs/AGENT_GUIDE.md): goal-oriented workflows for tracing, planning, cleanup, quality checks, and change verification.
+- [Command Reference](docs/COMMAND_REFERENCE.md): generated command syntax, descriptions, and options.
+- [Programmatic API](docs/API.md): using the query functions from TypeScript.
+- [Historical plans](docs/plans/): implementation notes and completed cleanup plans.
 
 ## License
 

package/dist/augment-vue-worker.js

@@ -1,2 +1,2 @@
-import{c as t}from"./chunk-6QH2L26C.js";import{writeFileSync as o}from"fs";import{workerData as s}from"worker_threads";var e=s;try{let r=t({projectRoot:e.projectRoot,dbPath:e.dbPath,tsconfig:e.tsconfig,vueFiles:e.vueFiles,tasks:e.tasks});o(e.resultPath,JSON.stringify({ok:!0,result:r}))}catch(r){o(e.resultPath,JSON.stringify({ok:!1,error:r instanceof Error?r.message:String(r)}))}finally{let r=new Int32Array(e.sharedBuffer);Atomics.add(r,0,1),Atomics.notify(r,0)}
+import{c as t}from"./chunk-TH4JVC34.js";import{writeFileSync as o}from"fs";import{workerData as s}from"worker_threads";var e=s;try{let r=t({projectRoot:e.projectRoot,dbPath:e.dbPath,tsconfig:e.tsconfig,vueFiles:e.vueFiles,tasks:e.tasks});o(e.resultPath,JSON.stringify({ok:!0,result:r}))}catch(r){o(e.resultPath,JSON.stringify({ok:!1,error:r instanceof Error?r.message:String(r)}))}finally{let r=new Int32Array(e.sharedBuffer);Atomics.add(r,0,1),Atomics.notify(r,0)}
 //# sourceMappingURL=augment-vue-worker.js.map

package/dist/{chunk-OPWOX7NT.js → chunk-2EC4JTHC.js}

@@ -1,4 +1,4 @@
-import{a as m}from"./chunk-NBUINPSH.js";import{a as S}from"./chunk-NKJKI6SE.js";import{b as h}from"./chunk-5RGK4YA5.js";import{b as d}from"./chunk-RCJEFQOK.js";import{a as y}from"./chunk-NN3O7TPH.js";import f from"path";function l(e){let n=e.replace(/\\/g,"/").split("/").filter(Boolean);return n.length<=1?"(root)":n.length>=3&&["src","lib","app","server","client"].includes(n[0])?`${n[0]}/${n[1]}`:n[0]}function p(e,t){if(e===t)return"ok";let n=g(e),i=g(t);return n&&i?v(n,i)?"ok":"violation":w(e,t)}function D(e,t){let n=g(l(e)),i=g(l(t));return!!n&&!!i}function g(e){return/^src\/([^/]+)$/.exec(e)?.[1]??null}function v(e,t){return t==="domain"?!0:e==="domain"?!1:{analysis:new Set(["domain","source","storage","symbols"]),core:new Set(["analysis","domain","resolution","source","storage","symbols"]),"language-parsers":new Set(["domain","resolution","source","storage"]),queries:new Set(["analysis","core","domain","language-parsers","resolution","semantic","source","storage","symbols"]),reindex:new Set(["domain","language-parsers","resolution","runtime","semantic","source","storage","symbols"]),resolution:new Set(["domain","source","storage","symbols"]),runtime:new Set(["domain","queries","reindex","resolution","semantic","source","storage","symbols"]),semantic:new Set(["domain","resolution","storage","symbols"]),source:new Set(["domain","storage"]),storage:new Set(["domain","source"]),symbols:new Set(["analysis","domain","language-parsers","resolution","semantic","source","storage"])}[e]?.has(t)??!1}function w(e,t){if(t==="shared")return"ok";let n={app:new Set(["core","shared","ui"]),core:new Set(["shared"]),infra:new Set(["core","shared"]),ui:new Set(["core","shared"])};return n[e]?n[e].has(t)?"ok":"violation":null}function G(e,t){let{scope:n,minDeviation:i=5}=t??{},r=t?.semantic!==!1,c=new m(e).fileDependencyGraph(n),a=O(e,n);return _([...R(e,c,a,{semantic:r}),...k(c),...I(c,i)])}function R(e,t,n,i){let r=[];for(let[s,c]of t){if(u(s))continue;let a=n.get(s)??new Set;for(let o of c)if(!u(o)&&!a.has(o)){if(i.semantic&&L(e,s,o)||A(e,s,o)||T(e,s,o)||F(o)||j(e,s,o)||V(o))continue;r.push({file:s,kind:"unused-import",description:`Depends on ${o} but references none of its symbols`,dep:o})}}return r}function k(e){let t=[],n=$(e);for(let[i,r]of e){if(u(i))continue;let s=l(i);for(let c of r){if(u(c))continue;let a=l(c);if(s===a)continue;(p(s,a)??n.get(`${s}->${a}`))==="violation"&&t.push({file:i,kind:"layer-violation",description:`Imports from ${a}/ (${c}) \u2014 may cross architectural boundary`,dep:c,detail:`${s}/ should not depend on ${a}/`})}}return t}function I(e,t){let n=[];for(let[i,r]of M(e)){let s=r.filter(a=>!u(a));if(s.length<t)continue;let c=x(e,s);for(let a of s)for(let o of e.get(a)??[])u(o)||(c.get(o)??0)===1&&f.dirname(o)!==i&&f.dirname(o)!==f.dirname(i)&&(D(a,o)||n.push({file:a,kind:"pattern-deviation",description:`Only file in ${i}/ that depends on ${o}`,dep:o}))}return n}function _(e){return{results:e,unusedImports:e.filter(t=>t.kind==="unused-import").length,layerViolations:e.filter(t=>t.kind==="layer-violation").length,patternDeviations:e.filter(t=>t.kind==="pattern-deviation").length}}function M(e){let t=new Map;for(let n of e.keys()){let i=f.dirname(n),r=t.get(i);r||(r=[],t.set(i,r)),r.push(n)}return t}function x(e,t){let n=new Map;for(let i of t)for(let r of e.get(i)??[])u(r)||n.set(r,(n.get(r)??0)+1);return n}function O(e,t){let n=new Map;return E(e,n,t),P(e,n),n}function E(e,t,n){for(let i of N(e,n))b(e,t,i.from_file,i.to_file)}function N(e,t){let n=t?`AND d1.relative_path LIKE '%${t}%'`:"";return e.all(`SELECT DISTINCT d1.relative_path AS from_file, d2.relative_path AS to_file
+import{a as m}from"./chunk-NOVKLH2F.js";import{a as S}from"./chunk-TQTVM27C.js";import{b as h}from"./chunk-64UY7VTR.js";import{b as d}from"./chunk-APLCSDXL.js";import{a as y}from"./chunk-NN3O7TPH.js";import f from"path";function l(e){let n=e.replace(/\\/g,"/").split("/").filter(Boolean);return n.length<=1?"(root)":n.length>=3&&["src","lib","app","server","client"].includes(n[0])?`${n[0]}/${n[1]}`:n[0]}function p(e,t){if(e===t)return"ok";let n=g(e),i=g(t);return n&&i?v(n,i)?"ok":"violation":w(e,t)}function D(e,t){let n=g(l(e)),i=g(l(t));return!!n&&!!i}function g(e){return/^src\/([^/]+)$/.exec(e)?.[1]??null}function v(e,t){return t==="domain"?!0:e==="domain"?!1:{analysis:new Set(["domain","source","storage","symbols"]),core:new Set(["analysis","domain","resolution","source","storage","symbols"]),"language-parsers":new Set(["domain","resolution","source","storage"]),queries:new Set(["analysis","core","domain","language-parsers","resolution","semantic","source","storage","symbols"]),reindex:new Set(["domain","language-parsers","resolution","runtime","semantic","source","storage","symbols"]),resolution:new Set(["domain","source","storage","symbols"]),runtime:new Set(["domain","queries","reindex","resolution","semantic","source","storage","symbols"]),semantic:new Set(["domain","resolution","storage","symbols"]),source:new Set(["domain","storage"]),storage:new Set(["domain","source"]),symbols:new Set(["analysis","domain","language-parsers","resolution","semantic","source","storage"])}[e]?.has(t)??!1}function w(e,t){if(t==="shared")return"ok";let n={app:new Set(["core","shared","ui"]),core:new Set(["shared"]),infra:new Set(["core","shared"]),ui:new Set(["core","shared"])};return n[e]?n[e].has(t)?"ok":"violation":null}function G(e,t){let{scope:n,minDeviation:i=5}=t??{},r=t?.semantic!==!1,c=new m(e).fileDependencyGraph(n),a=O(e,n);return _([...R(e,c,a,{semantic:r}),...k(c),...I(c,i)])}function R(e,t,n,i){let r=[];for(let[s,c]of t){if(u(s))continue;let a=n.get(s)??new Set;for(let o of c)if(!u(o)&&!a.has(o)){if(i.semantic&&L(e,s,o)||A(e,s,o)||T(e,s,o)||F(o)||j(e,s,o)||V(o))continue;r.push({file:s,kind:"unused-import",description:`Depends on ${o} but references none of its symbols`,dep:o})}}return r}function k(e){let t=[],n=$(e);for(let[i,r]of e){if(u(i))continue;let s=l(i);for(let c of r){if(u(c))continue;let a=l(c);if(s===a)continue;(p(s,a)??n.get(`${s}->${a}`))==="violation"&&t.push({file:i,kind:"layer-violation",description:`Imports from ${a}/ (${c}) \u2014 may cross architectural boundary`,dep:c,detail:`${s}/ should not depend on ${a}/`})}}return t}function I(e,t){let n=[];for(let[i,r]of M(e)){let s=r.filter(a=>!u(a));if(s.length<t)continue;let c=x(e,s);for(let a of s)for(let o of e.get(a)??[])u(o)||(c.get(o)??0)===1&&f.dirname(o)!==i&&f.dirname(o)!==f.dirname(i)&&(D(a,o)||n.push({file:a,kind:"pattern-deviation",description:`Only file in ${i}/ that depends on ${o}`,dep:o}))}return n}function _(e){return{results:e,unusedImports:e.filter(t=>t.kind==="unused-import").length,layerViolations:e.filter(t=>t.kind==="layer-violation").length,patternDeviations:e.filter(t=>t.kind==="pattern-deviation").length}}function M(e){let t=new Map;for(let n of e.keys()){let i=f.dirname(n),r=t.get(i);r||(r=[],t.set(i,r)),r.push(n)}return t}function x(e,t){let n=new Map;for(let i of t)for(let r of e.get(i)??[])u(r)||n.set(r,(n.get(r)??0)+1);return n}function O(e,t){let n=new Map;return E(e,n,t),P(e,n),n}function E(e,t,n){for(let i of N(e,n))b(e,t,i.from_file,i.to_file)}function N(e,t){let n=t?`AND d1.relative_path LIKE '%${t}%'`:"";return e.all(`SELECT DISTINCT d1.relative_path AS from_file, d2.relative_path AS to_file
      FROM mentions m
      JOIN chunks c ON m.chunk_id = c.id
      JOIN documents d1 ON c.document_id = d1.id
@@ -15,4 +15,4 @@ import{a as m}from"./chunk-NBUINPSH.js";import{a as S}from"./chunk-NKJKI6SE.js";
        AND m.role != 1
        ${e.pathExclusionsFor("d1","d2")}
        ${n}`)}function P(e,t){new m(e).scanSourceReferences({paths:y(e,{includeIgnored:!1}),includeRustAttributeNames:!0,identifierResolution:"permissive"},i=>{i.target.relativePath!==i.sourceFile&&(e.isIgnored(i.target.relativePath)||b(e,t,i.sourceFile,i.target.relativePath))})}function b(e,t,n,i){if(e.isIgnored(n)||e.isIgnored(i))return;let r=t.get(n);r||(r=new Set,t.set(n,r)),r.add(i)}function $(e){let t=new Map;for(let[i,r]of e){if(u(i))continue;let s=l(i);for(let c of r){if(u(c))continue;let a=l(c);if(s===a||p(s,a))continue;let o=`${s}->${a}`;t.set(o,(t.get(o)??0)+1)}}let n=new Map;for(let[i,r]of t)n.set(i,r<=2?"violation":"ok");return n}function F(e){return e.includes("types")||e.endsWith(".d.ts")}function L(e,t,n){let i=h(e,t).filter(r=>r.sourcePath===n);return i.length>0&&i.some(r=>r.isUsed)}function A(e,t,n){let i=d(e,t).filter(r=>r.sourcePath===n);return i.length>0&&i.some(r=>r.used)}function T(e,t,n){let i=d(e,t).filter(r=>r.sourcePath===n);return i.length>0&&i.every(r=>r.isTypeOnly===!0)}function V(e){return e.endsWith(".vue")}function j(e,t,n){let i=d(e,t).filter(r=>r.sourcePath===n);return i.length===0?!1:i.every(r=>r.kind==="side-effect"||r.kind==="namespace"&&r.usedMembers.length===0&&!r.used)}function u(e){let t=S(e);return!!(t==="entry"||t==="barrel"||t==="test"||t==="worker"||J(f.basename(e)))}function J(e){return!!(e==="index.ts"||e==="index.js"||e==="cli.ts"||e==="main.ts"||e==="main.rs"||e.includes("worker.")||e.includes("postinstall.")||e==="health.ts"||e==="health.js")}export{G as a};
-//# sourceMappingURL=chunk-OPWOX7NT.js.map
+//# sourceMappingURL=chunk-2EC4JTHC.js.map

package/dist/{chunk-SVSLAUSJ.js → chunk-46ILZVMX.js}

@@ -1,4 +1,4 @@
-import{a as t}from"./chunk-SDPP5KVQ.js";function r(e,n,o){let d=t(e,n)??n,s=t(e,o)??o,m=e.get(`SELECT COUNT(DISTINCT gs.id) AS shared
+import{a as t}from"./chunk-WC43FMAB.js";function r(e,n,o){let d=t(e,n)??n,s=t(e,o)??o,m=e.get(`SELECT COUNT(DISTINCT gs.id) AS shared
     FROM global_symbols gs
     WHERE (
       -- Defined in file1, referenced in file2
@@ -53,4 +53,4 @@ import{a as t}from"./chunk-SDPP5KVQ.js";function r(e,n,o){let d=t(e,n)??n,s=t(e,
     GROUP BY def_d.id, ref_d.id
     ORDER BY shared DESC
     LIMIT ?`,o).filter(i=>!e.isIgnored(i.file1)&&!e.isIgnored(i.file2)).map(i=>({file1:i.file1,file2:i.file2,sharedSymbols:i.shared}))}export{r as a,c as b};
-//# sourceMappingURL=chunk-SVSLAUSJ.js.map
+//# sourceMappingURL=chunk-46ILZVMX.js.map

package/dist/chunk-4A4JFNWG.js

@@ -0,0 +1,2 @@
+import{a as p,f as h}from"./chunk-N5D5ZCBW.js";import{a as c}from"./chunk-TQTVM27C.js";import{a as d}from"./chunk-RIXOMSOR.js";import{existsSync as A}from"fs";import{join as S}from"path";function T(e){return m.test(e)}var m=/(?:^|\/)(?:package-lock\.json|pnpm-lock\.yaml|yarn\.lock|Cargo\.lock|CHANGELOG(?:\.[a-z]+)?|.*\.map)$|(?:^|\/)(?:dist|build|out|node_modules)\//i;function j(e,i,t={}){let{minTogether:o=4,minConfidence:r=.6,limit:a=30}=t,u=p(e),s=i!==void 0,f=h(e,{minTogether:s?Math.min(o,2):o,minConfidence:s?0:r});if(!u||!f)return{available:!1,commitsAnalyzed:0,findings:[]};let C=d(e),y=t.includeLinked===!0||s,l=[];for(let n of f){if(m.test(n.fileA)||m.test(n.fileB)||!b(e,n.fileA)||!b(e,n.fileB)||s&&!n.fileA.includes(i)&&!n.fileB.includes(i)||!s&&(c(n.fileA)==="test"||c(n.fileB)==="test"||k(n.fileA,n.fileB)))continue;let g=x(C,n.fileA,n.fileB);if(!(!y&&g)&&(l.push({...n,structurallyLinked:g}),l.length>=a))break}return{available:!0,commitsAnalyzed:u.commits.length,findings:l}}function b(e,i){return A(S(e.config.projectRoot,i))}function k(e,i){let t=e.lastIndexOf("/"),o=i.lastIndexOf("/");if(e.slice(0,t)!==i.slice(0,o))return!1;let r=e.slice(t+1).split(".")[0],a=i.slice(o+1).split(".")[0];return r!==""&&r===a}function x(e,i,t){return e.get(i)?.has(t)===!0||e.get(t)?.has(i)===!0}export{T as a,j as b};
+//# sourceMappingURL=chunk-4A4JFNWG.js.map

package/dist/{chunk-QBXTQODK.js → chunk-4B7YLRXX.js}

@@ -1,4 +1,4 @@
-import{a as f}from"./chunk-SDPP5KVQ.js";import{a as d}from"./chunk-NBUINPSH.js";import{d as c}from"./chunk-5RGK4YA5.js";import{c as u}from"./chunk-4VYIZV3S.js";function L(e,n,i={}){let t=f(e,n);if(!t)return null;let r=h(e,t);if(!r||e.isIgnored(r.relative_path))return null;let s=[],m=0,l=g(e,r.relative_path),p=i.semantic===!1?new Map:c(e,l);for(let o of l){let a=S(e,r,o,p.get(o.symbolId)??new Set);m+=a,s.push({symbol:o.symbol,shortName:u(o.symbol),startLine:o.startLine,endLine:o.endLine,externalConsumers:a,riskLevel:b(a)})}return{file:r.relative_path,symbols:s,totalExternalConsumers:m}}function h(e,n){return e.get(`SELECT id, relative_path FROM documents
+import{a as f}from"./chunk-WC43FMAB.js";import{a as d}from"./chunk-NOVKLH2F.js";import{d as c}from"./chunk-64UY7VTR.js";import{c as u}from"./chunk-SOGLYIJ4.js";function L(e,n,i={}){let t=f(e,n);if(!t)return null;let r=h(e,t);if(!r||e.isIgnored(r.relative_path))return null;let s=[],m=0,l=g(e,r.relative_path),p=i.semantic===!1?new Map:c(e,l);for(let o of l){let a=S(e,r,o,p.get(o.symbolId)??new Set);m+=a,s.push({symbol:o.symbol,shortName:u(o.symbol),startLine:o.startLine,endLine:o.endLine,externalConsumers:a,riskLevel:b(a)})}return{file:r.relative_path,symbols:s,totalExternalConsumers:m}}function h(e,n){return e.get(`SELECT id, relative_path FROM documents
      WHERE relative_path = ?
        ${e.pathExclusionsFor("documents")}
      LIMIT 1`,n)??null}function g(e,n){return new d(e).definitionsForFile(n).sort((i,t)=>i.startLine-t.startLine||i.endLine-t.endLine)}function S(e,n,i,t){let r=e.all(`SELECT DISTINCT consumer_d.relative_path
@@ -8,4 +8,4 @@ import{a as f}from"./chunk-SDPP5KVQ.js";import{a as d}from"./chunk-NBUINPSH.js";
     WHERE m.symbol_id = ?
       AND m.role != 1
       AND c.document_id != ?`,i.symbolId,n.id);return new Set([...r.map(s=>s.relative_path),...[...t].filter(s=>s!==n.relative_path)]).size}function b(e){return e>10?"high":e>0?"medium":"low"}export{L as a};
-//# sourceMappingURL=chunk-QBXTQODK.js.map
+//# sourceMappingURL=chunk-4B7YLRXX.js.map