scip-query 0.24.0 → 0.26.0

package/skills/scip-query/SKILL.md

@@ -1,103 +1,50 @@
 ---
 name: scip-query
-description: Use FIRST for codebase work when compiler-resolved identity, runtime boundaries, callers, dependencies, consumers, architecture, change impact, or cleanup relationships can affect the answer. It exposes exact referents, explicit typed-graph projections, and source evidence; it does not infer task relevance. Pair it with scip-explore when the task is to understand a repository system end to end.
-metadata:
-  commands:
-    - template: 'scip-query watch --daemon'
-      when: 'When the user explicitly asks to use scip-query, make sure the background watcher for the exact target worktree is running before the first exploration command.'
-    - template: 'scip-query watch --status'
-      when: 'Check whether the watcher for the current worktree is running, refreshing, idle, or failed.'
-    - template: 'scip-query watch --stop'
-      when: 'Stop the watcher owned by the current worktree when the user asks to turn it off.'
-    - template: 'scip-query search <text>'
-      when: 'Locate exact repository text, a runtime key, or a compiler symbol; use `scip-query search -- <text>` when the literal starts with a dash.'
-    - template: 'scip-query outline <file>'
-      when: 'Locate compiler-owned constructs in a known file.'
-    - template: 'scip-query entrypoints <text>'
-      when: 'Locate an external callable root when its entry surface is known.'
-    - template: 'scip-query evidence --symbol <symbol> --edge <family> --direction <direction> --depth <n> --max-edges <n>'
-      when: 'Project explicitly selected typed relationships from one exact root.'
-    - template: 'scip-query inspect --at <file:line> --view behavior'
-      when: 'Read connected behavior for a named implementation gap.'
-    - template: 'scip-query code <selector>'
-      when: 'Read exact source only when syntax itself can change the decision.'
-    - template: 'scip-query diff-impact'
-      when: 'Map changed symbols and downstream consumers after an edit.'
-    - template: 'scip-query architecture'
-      when: 'Validate declared structural boundaries.'
-    - template: 'scip-query health --full'
-      when: 'Run configured cleanup and quality detectors.'
+description: Use code relationships, module structure, quality findings and change impact to plan and review changes alongside ordinary source-reading tools.
 ---
 
-# scip-query
+# SCIP Query
 
-<!-- BEGIN GENERATED SKILL COMMANDS -->
-## Command and question manual
+scip-query connects code locations through observed relationships and measured quality findings. Use ordinary search and file tools to read source. Use scip-query when the question concerns consumers, execution, value flow, dependencies, reuse or maintenance problems.
 
-| Command syntax | Question it answers |
-| --- | --- |
-| `scip-query watch --daemon` | When the user explicitly asks to use scip-query, make sure the background watcher for the exact target worktree is running before the first exploration command. |
-| `scip-query watch --status` | Check whether the watcher for the current worktree is running, refreshing, idle, or failed. |
-| `scip-query watch --stop` | Stop the watcher owned by the current worktree when the user asks to turn it off. |
-| `scip-query search <text>` | Locate exact repository text, a runtime key, or a compiler symbol; use \`scip-query search -- <text>\` when the literal starts with a dash. |
-| `scip-query outline <file>` | Locate compiler-owned constructs in a known file. |
-| `scip-query entrypoints <text>` | Locate an external callable root when its entry surface is known. |
-| `scip-query evidence --symbol <symbol> --edge <family> --direction <direction> --depth <n> --max-edges <n>` | Project explicitly selected typed relationships from one exact root. |
-| `scip-query inspect --at <file:line> --view behavior` | Read connected behavior for a named implementation gap. |
-| `scip-query code <selector>` | Read exact source only when syntax itself can change the decision. |
-| `scip-query diff-impact` | Map changed symbols and downstream consumers after an edit. |
-| `scip-query architecture` | Validate declared structural boundaries. |
-| `scip-query health --full` | Run configured cleanup and quality detectors. |
+An owner is the implementation responsible for a rule or resource, established from behavior and consumers. A finding identifies concrete code with evidence of a possible problem. Candidates require confirmation; names, folders and matching text alone do not establish ownership or interchangeable behavior.
 
-These commands are controls, not a checklist. Use every capability needed by the task, but make each query answer a distinct question. There is no required sequence or query limit. Run a command's `--help` when you need a flag not shown in its template.
-<!-- END GENERATED SKILL COMMANDS -->
+## Choose the work
 
-## Watcher lifecycle
+| Situation                   | Analysis to use                                                                            | Workflow                    |
+| --------------------------- | ------------------------------------------------------------------------------------------ | --------------------------- |
+| Understand a subsystem      | `system --source`, then selected module dependencies or `evidence`                         | `$scip-explore`             |
+| Plan a substantial change   | `context <target>` for reuse candidates; incoming/outgoing execution and relevant handoffs | `$scip-plan`                |
+| Evaluate architecture       | Module dependencies, cycles and `architecture` for configured rules                        | `$scip-architecture-review` |
+| Clean up code               | `health` for complexity/duplication/dependencies; relevant specialist detectors            | `$scip-architecture-review` |
+| Check a feature's integrity | Live consumers and distinguishing behavior; relevant incomplete-implementation detectors   | `$scip-integrity-audit`     |
+| Review actual edits         | `review --base HEAD`, `diff-impact`, and architecture if dependencies changed              | This guide                  |
+| Install or repair the tool  | `status`, then the diagnosed operation                                                     | `$scip-setup`               |
 
-The scip-query watcher is a project-scoped background refresh service: one process owned by one worktree that observes that worktree's configured compiler inputs and keeps its index current after relevant changes. It is not a global service, and starting it in one worktree must not start watchers for sibling worktrees.
+Load only the needed workflow. Simple local lookups need no workflow ceremony. These are task boundaries, not a command battery. Use the relevant section of the [command guide](references/command-guide.md) when a more specific question needs a specialist command.
 
-When the user explicitly names scip-query, invokes `$scip-query`, or asks the agent to use it, run `scip-query watch --daemon` from the exact target project root before the first exploration command. Treat both a newly started watcher and an already-running watcher as success; reuse the existing process instead of starting another. This automatic start applies only to an explicit request to use scip-query. Merely opening a repository or shell must not start it.
+## Ask for relationships
 
-Use the normal command without `CHOKIDAR_USEPOLLING` or another forced polling override. If startup fails, report the exact failure; do not silently start a watcher in another worktree, force polling, or substitute an unbounded full rebuild.
+Existing `file:line` locations are graph roots. Symbol lookup, `outline`, and `entrypoints` are useful when compiler identity, nesting or external roots are unclear. `code` and `inspect` are optional symbol-aware source tools; ordinary reads are usually sufficient for implementation details.
 
-Run `scip-query watch --status` from the same project root to inspect the watcher. Run `scip-query watch --stop` from that root when the user asks to stop it. The stop command targets only that worktree's watcher; do not stop watchers owned by other worktrees unless the user names them.
+For example, `scip-query evidence --at src/service.ts:42 --edge execution --direction incoming --depth 1 --max-edges 30` asks for caller evidence. Repeat `--at` or `--symbol` to batch participants. Use outgoing execution for callees, dataflow for value origins/destinations, runtime for handoffs and dependencies for imports. Select state, temporal, contract, identity or containment relationships only when they answer a concrete question. Execution and supported runtime handoffs establish reachability; other relationship families do not become call claims.
 
-<!-- BEGIN GENERATED EXPLORATION MANUAL -->
-### Choose a relationship deliberately
+Before a substantial change, establish the existing central path, comparable features and reuse opportunities. A relationship query should settle an uncertainty about that path or the consequences of changing it. Read the relevant implementation with ordinary tools to verify decisions, errors, state changes and ordering.
 
-| Question | Evidence family | Direction |
-|---|---|---|
-| Who can call or reach this? | `execution` | `incoming` |
-| What can this call or reach? | `execution` | `outgoing` |
-| Where can this value come from? | `dataflow` | `incoming` |
-| Where can this value go? | `dataflow` | `outgoing` |
-| Which producer and consumer rendezvous? | `runtime` | `both` |
-| What resource is observed or changed? | `state` | `both` |
-| What occurs before or after this? | `temporal` | `both` |
-| What interface constrains this? | `contract` | `both` |
-| Are these observations the same entity? | `identity` | `both` |
-| What contains or owns this? | `ownership` | `both` |
-| What does this statically rely on? | `dependencies` | `outgoing` |
+## Keep useful evidence
 
-Use exact evidence as an observed fact only within its coverage. Derived evidence is deterministically computed; candidate evidence is a lead; mixed evidence must retain its constituent strengths; unknown evidence cannot support a stronger claim. Missing output is not evidence of absence.
+Exact is directly observed; derived is deterministically computed; candidates need confirmation; unknown cannot support a stronger claim. Respect material stale, unsupported or incomplete results. A saved result is the complete output of its query, not proof that every possible relationship was analyzed. Missing or bounded evidence cannot establish absence.
 
-The controls above are complete for ordinary exploration. Run `scip-query capabilities --matrix` only when a named claim depends on uncertain provider support; do not run it for routine orientation.
-<!-- END GENERATED EXPLORATION MANUAL -->
+Prefer concise human output. Read saved results selectively using normal search/read tools. Use `--json --json-output <path>` when programmatic filtering helps. Do not paste large raw JSON or rerun an already answered query. Optional compatibility cursors are useful only when an omitted detail could change the decision; there is no requirement to drain every page or read every saved byte.
 
-scip-query is a repository exploration surface: an indexed code reader that joins exact current text to compiler-owned identities and typed relationships. Native text and file tools expose matches and slices; scip-query additionally exposes how code units call, carry data, cross runtime boundaries, observe or change state, occur in order, satisfy contracts, share identity, contain one another, and depend on one another. It performs the control you select; it does not infer task relevance or decide what the user meant.
+Source `health`, `review` and `system --source` use current files. Indexed relationships require a fresh index. Respect disabled watching and configured rebuild policy. Check `capabilities --matrix` only for uncertain support that matters to the question.
 
-For end-to-end system understanding, load `$scip-explore` alongside this skill. `scip-explore` owns the material-fact model, evidence integration, answer audit, and stopping judgment; this skill remains the calibrated sensing and source-reading surface.
+## Review changes
 
-Use scip-query as the primary exploration surface for tracked repository text. Treat its commands as controls, not a checklist. Use every capability needed by the task, but make each query answer a distinct repository question. There is no mandatory sequence, required anchor phase, or query-count limit. Thoroughness means understanding the relevant system end to end, not exhausting the repository.
+After a nontrivial edit, run `scip-query review --base <commit>` and fresh `scip-query diff-impact` against the same base. Normally use HEAD before committing. Review includes new/untracked functions and repository peers; scope the displayed findings to the change when useful. Check `architecture` when module dependencies or policy changed. Use `health --indexed` only for a needed specialist question.
 
-Use one discriminating exact `search`, `outline`, or `entrypoints` locator, then reuse every returned symbol or `file:line` as an `evidence` root. Do not repeat generic synonym searches after usable candidates exist. Locator ordering does not establish relevance. When several implementations match the same vocabulary, do not select one by path, naming, apparent recency, or result order. Compare their entry surfaces, incoming execution, ownership, callers, or runtime connections; if the repository does not establish one as authoritative, explain the alternatives and their scopes.
+Confirm findings with source and behavioral checks before fixing them. Preserve existing owners, authorization, errors, state identity, ordering, concurrency and cleanup. Do not lower thresholds, widen rules or suppress findings to make a report pass.
 
-An evidence projection accepts repeated `--symbol`, `--at`, or `--search` roots and repeated `--edge <family>` flags; always choose `--direction incoming|outgoing|both`, `--depth <n>`, and `--max-edges <n>` explicitly. Use `--subtype <subtype>` to narrow a family, `--connecting` when the selected roots themselves must be connected, and `--inventory-only` when counts alone can choose the next bounded projection.
+CRAP combines complexity with actual test coverage. Use `scripts/record-review-coverage.mjs` with the real test command when this measure matters; missing or stale coverage is unavailable, never zero. See [review rules](../../docs/REVIEW.md).
 
-Read each command's request, observed facts, evidence calibration, coverage, and recovery together. Exact observations are facts only within their reported coverage. Derived observations are deterministic computations. Candidate observations require confirmation. Missing or bounded output is not evidence of absence.
-
-An emitted `Continue exactly:` command is a cursor: a next-page read from one immutable rendered result. It is required transport, not optional evidence expansion. Run the emitted command unchanged and repeat until no continuation remains before interpreting that command's complete result. Do not rerun the original query or alter cursor flags. Continuation reads saved output without repository preparation, reindexing, or watcher startup. Printed recovery and expansion commands are different: run those only when their omitted evidence matters.
-
-Prefer human output for agent reading. If a model-facing consumer genuinely needs JSON, add `--json --agent-output`; add `--result-only` only when the common envelope is unnecessary, and drain every emitted cursor before interpreting the result. Never send raw `--json` output through a model-facing terminal or tool. When a program needs the exhaustive machine payload, use `--json --json-output <path>` and inspect that file programmatically instead of injecting its complete contents into model context.
-
-`inspect --view behavior` returns connected behavior for named units; `code` returns exact source. Treat source rendered by either command as already read. Batch independent roots and source gaps when practical. Use native tools only for edits, checks, binary content, or a specific unsupported gap reported by scip-query. After edits, use `diff-impact` when downstream consumers matter, `architecture` for declared boundaries, and `health` for configured quality or cleanup detectors.
+Report changes, actual checks, justified retained findings and material limits. An empty report or passing mocked test alone does not establish correct behavior.

package/skills/scip-query/agents/openai.yaml

@@ -1,4 +1,4 @@
 interface:
   display_name: "SCIP Query"
-  short_description: "Explore code through exact identities and relationships"
-  default_prompt: "Use $scip-query as the primary repository exploration surface. Treat commands as controls rather than a checklist, reuse locator results as graph roots, distinguish competing implementations by their entry surfaces and callers, and use exact identities, relationships, behavior, source, coverage, and recovery to understand the requested system accurately."
+  short_description: "Inspect relationships, smells, and changes."
+  default_prompt: "Use $scip-query to choose evidence and the workflow needed for this task."

package/skills/scip-query/references/command-guide.md

@@ -0,0 +1,169 @@
+# Choosing a scip-query command
+
+Use this reference when the workflow names a question but you need to choose its command. Read the relevant section, then run `scip-query <command> --help` for flags. Do not run every row. This guide covers all 81 public commands; the five internal controls are explained separately.
+
+An index is a saved database of code declarations and references produced by language tools. The **Index** column describes the current CLI prerequisite, not whether the answer is read from old source bytes. **Yes** requires a prepared index; additional language parsers or compiler services may still be needed. **No** requires no saved index; other requirements are stated in the row. **Mode** depends on the selected operation.
+
+Current limitation: `files`, `search`, `code`, and `inspect` read current text but still pass through index preparation. Do not promise those commands work in a never-indexed checkout. `system --source`, source `health`, and `review` do. Their current-source analysis scans eligible files on each invocation; the incremental index watcher is a separate mechanism.
+
+`<value>` is required; `[value]` is optional. Prefix the commands below with `scip-query`. Use exact identities returned by the tool, and preserve quoted paths. Every result is limited by its stated coverage. A candidate is a location worth investigating because it matches a disclosed pattern; it is not an instruction to change that code.
+
+## Orientation and change review
+
+Source `health` shows separate finding categories; `--limit` bounds each category so duplication cannot crowd out complexity. Unmatched suppression decisions are summarized after findings; `--full` retains their identities and reasons. Use `system --source <path-or-group>` for module files, dependencies and consumers. Indexed health has no overall grade. Its combined pair weight is the sum of existing detector weights; the raw pair count remains separate.
+
+Use these for first-use assessment, planning around existing code, and checking an actual diff. Load `$scip-plan` for implementation order and preserved behavior.
+
+| Command | Use when / why this control | Index | Interpretation and limits |
+| --- | --- | --- | --- |
+| `system [module]` | Inventory module groups, or examine the files, exports, imports, consumers and findings around one group. Start with `system --source`; select an exact path or printed group ID. | Mode | Source mode needs no index and covers eligible TS/JS. Bare indexed mode requires a module selector. Directories are provisional groups; exports are not complete interface contracts. |
+| `health` | Find current TS/JS complexity, duplication and dependency findings on first use. Choose `--indexed` for the specialist framework, drift and cleanup report. | Mode | Default source mode needs no index. `--baseline` compares saved indexed finding identities; `--write-baseline` writes them. Both require an index and reject source-only options. No mode establishes overall design quality or runs every integrity detector. |
+| `review` | Compare current TS/JS changes, including new/untracked functions, against `--base HEAD` or another commit. Use before committing. | No | Requires Git. Scope filters output while peer analysis remains broader. Read uncomparable functions manually. CRAP needs source-matched test coverage; missing coverage is unavailable. |
+| `context <target>` | Gather indexed reuse and impact candidates around an already identified symbol, file or module before choosing an implementation owner. | Yes | A briefing of candidates; matching names and nearby code do not establish the live owner. Use source and consumers to decide. |
+| `change-surface <file>` | Plan a change to one file: see its consumers, published interface, operational roots and explained risk. | Yes | Broader pre-change context than a reverse-import list. Risk signals do not predict which consumers will break. |
+| `affected <symbol>` | Before editing a particular symbol, follow its reverse caller/reference relationships to possible consumers. | Yes | A conservative set of potentially affected symbols. It does not predict actual failures or cover unknown runtime connections. |
+| `diff-impact` | After editing, map the actual Git diff to changed symbols and downstream consumers. Select the same `--base` used for review. | Yes | Complements source review with symbol relationships. Check unindexed paths and each evidence tier; a source fallback is not complete compiler-reference coverage. |
+
+## Exploration
+
+Use ordinary repository search and file tools for source text. Load `$scip-explore` when cross-file relationships or behavior need investigation. `context`, `call-graph`, `evidence` and dependency commands add structure beyond source reads; the locators and symbol-aware reads below are optional specialist controls.
+
+| Command | Use when / why this control | Index | Interpretation and limits |
+| --- | --- | --- | --- |
+| `files <pattern>` | The missing fact is a file path rather than a text occurrence. Match current project paths. | Yes | Current CLI prerequisite despite source-based file discovery. File membership does not establish compiler coverage. |
+| `search <exact-text>` | Locate a literal or deliberately bounded `--regexp`, optionally within `--scope`. | Yes | Counts current text; compiler ownership is an aligned overlay. Preview ordering is not task relevance. Insert `--` before a literal beginning with a dash. |
+| `outline <file>` | See indexed symbols and nesting in one known file before selecting a definition. | Yes | Compiler-owned structure, not evidence that a function runs. |
+| `code <selectors...>` | Read exact definitions, file:line ranges, or file surfaces. Batch known selectors. | Yes | Text is current. File mode defaults to exported members; `--members all` requests the complete file. Source alone does not establish consumers. |
+| `inspect` | Read several related implementation gaps together using repeated `--symbol`, `--at`, or `--search`; use `--view behavior` when behavior is the gap. | Yes | Deduplicated source and relationship context with explicit bounds. A preview cannot establish what every invocation passes. |
+| `entrypoints [text]` | Find detected external roots or entry-surface candidates when the initiating implementation is unknown. | Yes | Visibility and few callers do not prove runtime ingress. Confirm registration and live consumers. |
+| `entry-map <entry>` | View the indexed call structure from one detected entry, grouped by file. | Yes | Useful for the broad static path; does not prove runtime execution or capture every framework handoff. |
+| `methods <className>` | Enumerate methods of one exact class rather than all constructs in its file. | Yes | Ambiguous/missing class selectors fail. Methods being present does not establish invocation. |
+| `members <symbol>` | Enumerate children of a known symbol, including fields and nested types. | Yes | Broader than methods; structural containment does not establish responsibility or lifetime. |
+| `hierarchy <symbol>` | Walk upward from a symbol to its indexed lexical containers. | Yes | Containers are code structure; runtime sharing and business ownership require separate evidence. |
+| `by-kind <kind>` | Locate constructs by SCIP kind, such as classes or interfaces. | Yes | Kind is a compiler classification, not an architectural role. |
+| `kind-counts` | Get a histogram of indexed construct kinds when composition is the question. | Yes | Index inventory counts; neither a repository quality measure nor a code-behavior review. |
+| `refs <symbol>` | Locate references to one exact declaration, including non-call uses. | Yes | Distinguish compiler-bound references from candidates. References are broader than calls; limits and unsupported consumers prevent absence claims. |
+| `call-graph <symbol>` | Follow incoming/outgoing static call relationships around one symbol. | Yes | Read exact/candidate labels and blind spots. A possible call is not an observed execution. |
+| `evidence` | Project explicitly chosen execution, dataflow, runtime, state, temporal, contract, identity, ownership or dependency relationships. | Yes | Supply roots, `--edge`, direction, depth and edge bound. Only supported relationships are established; data/state edges do not become calls. |
+| `dependence-slice <file:line>` | Trace a particular variable occurrence backward to its local prerequisites, or forward with `--forward`. Use `--variable`/`--column` to disambiguate. | Yes | Function-local value and control relationships. Does not prove whole-program flow, safe extraction, or heap identity across calls. |
+| `session` | Check which evidence has already been delivered in an explicit `SCIP_QUERY_SESSION`; `--reset` clears that ledger. | Yes | The current handler opens the index. Delivered evidence is not a measure of task completion; no explicit session means the ledger is unavailable. |
+
+## Architecture and dependencies
+
+Load `$scip-architecture-review` to connect these observations to maintenance consequences. Review implementations and consumers before assigning responsibility or changing boundaries.
+
+| Command | Use when / why this control | Index | Interpretation and limits |
+| --- | --- | --- | --- |
+| `deps <file>` | List the internal files one file relies on. | Yes | File-level dependency view; use imports for imported symbol detail. Static reliance is not execution. |
+| `rdeps <file>` | Find files depending on one file/module. | Yes | File consumers, not complete symbol invocations. Use affected for broader symbol impact. |
+| `imports <file>` | Inspect the imported symbols used to connect a file to other implementations. | Yes | An import does not prove invocation. Dynamic/runtime registration may need separate evidence. |
+| `imported-by <symbol>` | Identify files importing one symbol. | Yes | Narrower than refs: non-import uses are not this command's question. |
+| `surface <module>` | Find indexed symbols with observed consumers outside the selected module. | Yes | Shows observed use, not every exported declaration or all consumers outside this repository. |
+| `architecture` | Check declared file boundaries, allowed dependency directions and configured structural constraints. | Yes | Requires meaningful project rules. Read unmapped files and missing policy rows; compliance does not establish sound design. |
+| `cycles` | Find cyclic file-dependency groups and a witness path through each. | Yes | All participating components are the unit of coverage, not every possible cycle path. A grouped-module cycle may differ from a file cycle. |
+| `dependency-depth` | Examine long dependency paths after cyclic files are treated as one group. | Yes | Depth describes graph structure; it does not prescribe implementation order or measure runtime cost. |
+| `coupling [file1] [file2]` | Compare two files, or rank file pairs, by shared-symbol relationships. | Yes | Shared symbols indicate structural connection, not a common business responsibility. |
+| `co-change [file]` | Investigate files that repeatedly change together without a recorded dependency. | Yes | Also needs Git history. Co-change suggests hidden coordination; repository-wide edits and history gaps can mislead. |
+| `hotspots` | Locate highly referenced symbols when choosing where to investigate broad impact. | Yes | Ranks referencing chunks or disclosed incoming evidence rows. Counts are not runtime frequency or architectural importance. |
+| `fan-in [symbol]` | Count distinct referencing files for one symbol, or rank symbols by that count. | Yes | Different unit from hotspots; many consumers can indicate useful reuse. |
+| `fan-out [file]` | Count external symbols used by one file, or rank files by that count. | Yes | Here external means outside the file. Counts do not establish excessive responsibilities. |
+| `bottlenecks` | Locate potential coordination hubs using incoming files and outgoing cross-file callable targets. | Yes | Structural product, not measured runtime contention, throughput or failure risk. |
+| `locality-candidates [symbol-or-file]` | Investigate placement when consumers cluster under a directory or ancestor. | Yes | Directory proximity suggests a question; it does not identify the correct conceptual owner. |
+| `drift [module]` | Obtain a module-oriented shortlist of unused imports and architecture violations; add `--architecture` for policy context. | Yes | `--patterns` additionally reports unusual sibling dependencies and has weaker precision. Different dependencies can be intentional. |
+
+## Simplification and cleanup
+
+These are optional investigations within architecture/maintainability review. Begin with source health/review when their findings answer the question. Test the strongest reason the existing code might be necessary.
+
+| Command | Use when / why this control | Index | Interpretation and limits |
+| --- | --- | --- | --- |
+| `complexity <symbol>` | Inspect one indexed symbol's branch/cyclomatic estimate alongside fan-in/out and callees. | Yes | For before/after source cognitive complexity and CRAP, use review. Metric definitions differ; do not treat every complexity value as interchangeable. |
+| `slice-cohesion [symbol]` | Investigate a function whose outputs may depend on separate sets of statements. | Yes | Local backward-slice candidates for separation. Shared state, effects, control, exceptions and lifecycle may require keeping the code together. |
+| `passthrough-candidates` | Locate wrappers that mostly forward to one callee. | Yes | Adapters can enforce a contract or isolate change; forwarding alone does not justify deletion. |
+| `similar [symbol] [other]` | Find or compare functions with similar callee fingerprints. | Yes | Similar callees do not prove equivalent behavior; inspect inputs, effects and consumers. |
+| `similar-files [file]` | Find files with similar dependency profiles. | Yes | Structural neighbors, not proven duplicate implementations. |
+| `recent-duplicates` | Look for duplication candidates associated with recently added files. | Yes | Uses Git file age; it does not know when each function was created. |
+| `duplicate-bodies` | Locate exact small-body duplication candidates across files. | Yes | Matching bodies can operate under different contracts or state; source health supplies a different whole-function token comparison. |
+| `similar-signatures` | Locate functions with similar normalized signature text as a lead for shared concepts. | Yes | Text resemblance does not prove identical resolved types, responsibilities or behavior. |
+| `dead [scope]` | Distinguish repository-dead candidates, file-internal-only symbols and implicit-usage signals. | Yes | Examine the category and semantic coverage. External consumers, framework calls or incomplete indexing can invalidate a deletion. |
+| `unused-imports <file>` | Inspect imports with no observed same-file references. | Yes | Confirm side effects, generated/framework uses and supported syntax before removal. |
+| `unused-params` | Find trailing parameters whose bodies do not use them. | Yes | Public interfaces, callbacks, overrides and future-compatible contracts may still require them. |
+| `redundant-reexports` | Investigate re-exports without resolved local source import/re-export consumers. | Yes | External package consumers remain unknown. A barrel can be a deliberate public interface. |
+| `cleanup-plan` | Order unused-code deletion candidates and the further candidates their removal may expose. | Yes | `--verify` executes a project checker in an isolated HEAD snapshot; `--patch` prints that checked patch. Neither proves runtime behavior or validates uncommitted source as HEAD. |
+| `doc-drift [doc]` | Find documentation whose referenced or historically co-changing code changed later. | Yes | Also needs Git history. Age is a lead, not proof that the documentation is wrong. |
+
+## Framework investigations
+
+Use the relevant framework rows after a concrete React/Vue concern, or after `health --indexed` points to one. Do not run both framework families on unrelated code. These reports require an index and their supported parser/compiler providers.
+
+| Command | Use when / why this control | Index | Interpretation and limits |
+| --- | --- | --- | --- |
+| `react-component-duplicates [file]` | Compare repeated JSX structure, props, events and bindings. | Yes | Similar component structure can conceal different behavior and ownership. |
+| `react-hook-candidates [file]` | Investigate repeated state, effects, requests and handlers for a possible shared hook. | Yes | Preserve hook ordering, state lifetime, dependencies and cleanup. Shared syntax does not prove a valid hook contract. |
+| `react-large-component-pressure [file]` | Find components with concentrated source, JSX and hook behavior. | Yes | Size and counts locate review candidates; they do not prove the component should split. |
+| `vue-component-duplicates [file]` | Compare repeated template tags, bindings, slots and directives. | Yes | Verify script behavior and consumers; template resemblance is insufficient for consolidation. |
+| `vue-composable-candidates [file]` | Investigate repeated state, effects, requests and template bindings for a possible shared composable. | Yes | A composable is a reusable function that organizes Vue reactive behavior. Preserve state ownership, subscriptions and cleanup. |
+| `vue-large-view-pressure [file]` | Locate concentrated template/script/style behavior, including external script lines. | Yes | A large view may own one coherent operation; counts alone do not establish multiple responsibilities. |
+
+## Implementation integrity
+
+Load `$scip-integrity-audit` when the question is whether a feature fulfills its promise. Each detector below supplies candidates; verify live routing and independently expected behavior through a real consumer.
+
+| Command | Use when / why this control | Index | Interpretation and limits |
+| --- | --- | --- | --- |
+| `not-implemented` | Look for consumed or externally exposed placeholders: throw-stubs, TODO/default returns or empty bodies. | Yes | A legitimate no-op, abstract contract or deliberate unsupported operation may match. A clean scan does not establish feature completeness. |
+| `decorative-checkers` | Investigate checker-named functions lacking detected explicit failure syntax. | Yes | Delegated checks, implicit exceptions and property effects may still reject bad input. Test both valid and invalid cases. |
+| `test-quality` | Find assertion-free tests, skipped tests with history, and tests asserting the same literal supplied by their mocks. | Yes | These patterns do not prove a test is useless; execution, delegated assertions and the tested contract matter. |
+| `incomplete-migration` | After extraction, find new helpers used at some sites while similar old sites remain. Choose `--base` deliberately. | Yes | Also needs Git. Similar call patterns are candidates; distinct contracts or a staged migration can explain coexistence. |
+| `twin-drift` | Compare same/near-name functions across files whose bodies have diverged. | Yes | Names and divergence do not establish that implementations should agree. Compare their contracts and live consumers. |
+
+Source suppression comments apply to their named analysis: `ignore-extract` to slice-cohesion, `ignore-similar` to similarity/duplicate-body checks, `ignore-twin` to twin drift, and `ignore-passthrough` to forwarding candidates. Legacy `ignore-wrapper` means passthrough and `ignore-stale` means dead-code exclusions. An unrelated annotation must not hide a placeholder or unused parameter. Bare `ignore` is an explicit blanket opt-out; unknown category names do not become blanket opt-outs. Inventory totals count annotations and unexpired records, not suppressed findings or detector precision. Revisit the recorded reason when behavior changes.
+
+## Tool operations
+
+Load `$scip-setup` when the tool itself needs attention. Configuration and integration writes are actions; use them for an authorized setup, repair or accepted decision, not routine orientation. A configured watcher can be stopped, and `autoStart: false` prevents automatic startup.
+
+| Command | Use when / why this control | Index | Interpretation and limits |
+| --- | --- | --- | --- |
+| `status` | Inspect freshness, the active index, watcher state and cache ownership. | No | Can report a missing index. Freshness does not prove every provider is available. |
+| `doctor` | Diagnose a reported configuration, freshness, dependency or capability problem. | No | Follow the specific diagnosis; diagnostic success is not a behavioral code audit. |
+| `capabilities` | Check whether a named claim has provider/language support; use `--matrix` for detail. | No | Describes tool support and limits. Do not run the matrix as a routine orientation step. |
+| `stats` | Inspect index row counts, database size and modification time. | Yes | Inventory and storage measurements, not code quality or proof of freshness. |
+| `check-deps` | Check whether scip-query and the detected language indexers are runnable. | No | An executable being present does not establish a successful project index. |
+| `init` | Create a starter `.scipquery.json` when configuration is wanted. | No | Writes configuration; it does not evaluate or discover correct architectural responsibilities. |
+| `config-validate` | Validate configuration and structured suppression/architecture/coupling records after editing them. | No | Valid syntax and consistency do not establish that the chosen policy is good. |
+| `setup` | Bootstrap skills, agent guidance, parsers, indexing and readiness checks for a project. | No | Creates local/project state and needs suitable language tools. `--health` adds indexed specialists; plain source health is a separate operation. |
+| `reindex` | Create or refresh the saved compiler index after a diagnosed need. | No | Needs the language indexers. Ordinary updates can use the running incremental service; `--allow-expensive-rebuild` explicitly permits a whole-project fallback. `--force` requests a rebuild even when inputs are unchanged and also permits the whole-project fallback. |
+| `watch` | Inspect (`--status`), start (`--daemon`), stop or prune the project service; bare invocation watches in the foreground. | Mode | Status/control can work without an index. Successful incremental refresh needs a baseline, providers and applicable project configuration; an initial rebuild must be permitted. |
+| `augment-sources` | Add source documents skipped by the upstream indexer after confirming that coverage gap. | Yes | Mutates index documents; adding source text does not manufacture compiler-resolved relationships. |
+| `augment-vue` | Add compiler-resolved Vue references for a specific `--project` configuration. | Yes | Mutates the index and needs Vue tooling. Inspect unresolved/skipped reasons rather than interpreting omitted references as absent. |
+| `install-skills` | Install or repair the six workflow links in user-level agent roots. | No | Writes package-owned links; `--all` has the same result. Existing user-owned replacements are preserved. |
+| `setup-agent` | Write/update managed project guidance in AGENTS.md and CLAUDE.md. | No | Writes instructions; it does not by itself establish a fresh index or agent compliance. |
+| `uninstall` | Remove selected package-owned global skill links or project guidance. | No | Start with `--dry-run` when choosing scope. `--global` and `--project` address different integrations; unrelated user files are retained. |
+| `suppress <id>` | Record a reviewed finding that should be retained, with a reason, reason code and counterevidence. | No | Writes a decision; saving a graph claim does not itself verify that claim. Commit relevant suppression records. Replacing a decision requires its exact revision. |
+
+## Internal controls
+
+These five registered controls are not additional analysis choices. Run an emitted continuation unchanged; do not invent worker invocations.
+
+| Control | Purpose |
+| --- | --- |
+| `continue <cursor>` | Optional compatibility transport for a saved output page. Recover omitted details only when they can change the decision; one page cannot establish an exhaustive result. |
+| `hook-architecture-stop` | Checkout-local architecture Stop hook installed by setup when its conditions are met. |
+| `__diff-impact-batch` | Private diff-impact worker protocol. |
+| `__health-phase` | Private indexed-health phase worker protocol. |
+| `__health-semantic-prewarm` | Private health provider-preparation protocol. |
+
+## Choosing between similar controls
+
+- **Map, policy or behavior:** system inventories groups; architecture checks declared rules; evidence/inspect establish selected relationships and behavior. None supplies an overall design grade.
+- **Before versus after an edit:** context/change-surface/affected support planning; review and diff-impact evaluate the actual diff and answer different questions about it.
+- **File, import, reference or call:** deps/rdeps connect files; imports/imported-by describe imports; refs includes non-call references; call-graph describes possible calls. Select the relationship needed for the claim.
+- **Inventory versus observed interface:** system/outline show declarations; surface shows observed outside-module use. Neither proves a complete external package API.
+- **Measurement versus equivalence:** complexity and connectivity counts locate pressure; similarity detectors use different comparisons. Matching counts, signatures or bodies do not establish safe replacement.
+- **Slice versus split:** dependence-slice explains one variable occurrence; slice-cohesion suggests separated local computations. Both still require behavior and effect checks before extraction.
+- **Candidate list versus deletion procedure:** dead classifies usage signals; cleanup-plan orders possible deletions and offers an isolated checker run. Neither authorizes deletion by itself.
+
+Full flag documentation is in [the command reference](../../../docs/COMMAND_REFERENCE.md). When this guide and a runtime packet disagree, preserve the packet's limits and report the mismatch; do not strengthen the claim to fit the guide.
+
+Ordinary oversized human results are saved to a temporary file with a short preview. Search displays the selected matching windows once; `--full` requests all source windows. The `system --source` inventory shows groups and dependencies; select a group for file/export/import detail. `evidence --detail` adds provider contracts and limitations to the selected relationship projection. `code --bindings` and `inspect --bindings` explicitly add referenced literal values; source reads omit those additions by default.

package/skills/scip-setup/SKILL.md

@@ -5,6 +5,8 @@ description: Install, diagnose, index, watch, repair, or clean up scip-query for
 
 # SCIP Setup
 
+Load `$scip-query` for shared mechanics. The [tool-operations command guide](../scip-query/references/command-guide.md#tool-operations) distinguishes configuration, indexing, augmentation, watcher control, skill installation, suppression records and removal. Use its prerequisites and effects to select the specific operation needed.
+
 Use this skill when the exploration surface itself is unavailable, stale, slow, or consuming unexpected disk or CPU. An operational diagnosis identifies the concrete state transition that prevented a checkout-local index from becoming or remaining fresh; it does not infer failure from elapsed time alone.
 
 1. Run `scip-query status` to inspect the active checkout, index generation, freshness, watcher, and cache ownership.
@@ -13,6 +15,6 @@ Use this skill when the exploration surface itself is unavailable, stale, slow,
 4. Run `scip-query watch` only when the repository needs a long-lived incremental watcher and setup did not establish one.
 5. Use the exact recovery command printed by status or doctor. Do not delete caches, force a full rebuild, or reinstall globally merely because an index is stale; first identify whether configuration, project membership, toolchain identity, or an ordinary changed file caused the transition.
 
-Each worktree owns its mutable generation and may reuse an immutable baseline from a related checkout. A full rebuild is justified when configuration, toolchain identity, or project membership invalidates the prior compiler graph. Ordinary edits should use the incremental path. Cache cleanup must retain active checkout generations and remove only records whose owning roots are gone or whose retention window has expired.
+Each worktree owns its mutable generation and may reuse an immutable baseline from a related checkout. A full rebuild is justified when configuration, toolchain identity, or project membership invalidates the prior compiler graph. Ordinary edits should use the incremental path. The bundled TypeScript compiler and incremental emitter share declaration-based identifiers for anonymous types and inferred object properties. Upgrading an index from the older numbered identifiers requires one clean build; those generations cannot be mixed. If rebuild policy forbids recovery, the previous accepted generation remains intact but stale. Follow the printed recovery command without weakening resource policy. Cache cleanup must retain active checkout generations and remove only records whose owning roots are gone or whose retention window has expired.
 
-After a repair, prove the requested outcome directly: status is fresh, an ordinary source edit updates incrementally, simultaneous worktrees remain isolated, deleted worktree caches age out, or repeated cleanup reaches a disk plateau. Do not run `health` as proof of index freshness and do not run exploration commands as a substitute for lifecycle diagnostics.
+After a repair, prove the requested outcome directly: status is fresh, a supported source edit updates incrementally, an unsupported subset recovers through a clean build or preserves the accepted generation with an explicit stale-state reason, simultaneous worktrees remain isolated, deleted worktree caches age out, or repeated cleanup reaches a disk plateau. Do not run `health` as proof of index freshness and do not run exploration commands as a substitute for lifecycle diagnostics.

package/skills/scip-setup/agents/openai.yaml

@@ -1,4 +1,4 @@
 interface:
-  display_name: 'SCIP Setup'
-  short_description: 'Set up and diagnose SCIP Query indexing'
-  default_prompt: 'Use $scip-setup to install or diagnose scip-query for this repository.'
+  display_name: "SCIP Setup"
+  short_description: "Install, diagnose, and repair scip-query."
+  default_prompt: "Use $scip-setup to identify and repair the concrete tool lifecycle problem."

package/dist/by-kind-H3P6BR5G.js

@@ -1,2 +0,0 @@
-import{a,b}from"./chunk-NGKBOT6G.js";import"./chunk-MTDBHTSF.js";import"./chunk-2VAHDDLM.js";import"./chunk-YXPUP5G2.js";import"./chunk-BL6DCHQP.js";import"./chunk-ATXPTSEI.js";import"./chunk-CKBUBRYD.js";import"./chunk-IW5XQG5G.js";import"./chunk-H5EXS3HM.js";import"./chunk-HGFDYOVB.js";import"./chunk-7HXT6YLU.js";import"./chunk-7F45LJKI.js";export{a as byKind,b as kindCounts};
-//# sourceMappingURL=by-kind-H3P6BR5G.js.map

package/dist/call-graph-VTG2CUOQ.js

@@ -1,2 +0,0 @@
-import{a}from"./chunk-ZGIHTH27.js";import"./chunk-7KCZELVM.js";import"./chunk-BGBBVSH4.js";import"./chunk-AADQLOQ4.js";import"./chunk-MTDBHTSF.js";import"./chunk-WDSFQDPN.js";import"./chunk-ANLNLY66.js";import"./chunk-JCSAZ35V.js";import"./chunk-FI7VGOR4.js";import"./chunk-WRQXLNYE.js";import"./chunk-L7KTFEAV.js";import"./chunk-2USA3S3P.js";import"./chunk-BJT7LSPK.js";import"./chunk-5BIKR67W.js";import"./chunk-CZW5MZ5B.js";import"./chunk-F4FNK44D.js";import"./chunk-ODPDP7A4.js";import"./chunk-MOKUWRHO.js";import"./chunk-FVFDOIM3.js";import"./chunk-2VAHDDLM.js";import"./chunk-YXPUP5G2.js";import"./chunk-BL6DCHQP.js";import"./chunk-EHYDXE3Z.js";import"./chunk-2OOY75BW.js";import"./chunk-U6KCHXJ4.js";import"./chunk-T3I6NHBH.js";import"./chunk-ATXPTSEI.js";import"./chunk-CKBUBRYD.js";import"./chunk-IW5XQG5G.js";import"./chunk-T3CZAZSI.js";import"./chunk-B3PYOSCX.js";import"./chunk-H5EXS3HM.js";import"./chunk-HGFDYOVB.js";import"./chunk-JFMEXGFE.js";import"./chunk-7HXT6YLU.js";import"./chunk-7F45LJKI.js";export{a as callGraph};
-//# sourceMappingURL=call-graph-VTG2CUOQ.js.map

package/dist/chunk-26CT72HM.js

@@ -1,2 +0,0 @@
-function e(o){return o+1}export{e as a};
-//# sourceMappingURL=chunk-26CT72HM.js.map

package/dist/chunk-2BMSSRBH.js

@@ -1,2 +0,0 @@
-import{a as L}from"./chunk-BGBBVSH4.js";import{a as I}from"./chunk-BJWFVAA5.js";import{i as fe}from"./chunk-U3SXIMII.js";import{b as te,d as oe,e as re,f as ae,g as se,h as le,j as T,k as ce,l as _}from"./chunk-SKKXTABJ.js";import{d as ie}from"./chunk-KK7GPALL.js";import{f as ee,h as ne}from"./chunk-NJQISBL4.js";import{b as C}from"./chunk-FLMTCX5R.js";import{b as Q}from"./chunk-BOW7SSQH.js";import{a as U,e as W,i as P,j as A,l as X,m as Y,v,w as J,x as Z,y as $,z as N}from"./chunk-C7C6AKAT.js";import{t as z,v as S}from"./chunk-RBAD4GJ2.js";import{A as y,B as O,O as H,a as M}from"./chunk-ZLMXIQLC.js";import{h as B,m as D}from"./chunk-ETC674NS.js";import{d as w,y as G}from"./chunk-KNLQGXVH.js";function j(n,e,t={}){let i=new Map;if(e&&e.length===0)return i;let r=M(n,{includeIgnored:!1}),o=ae(n),a=e??J(n),f=new Set(a.map(m=>m.symbolId)),c=Ce(a);return ge(n,i,r,o,f,c),he(n,i,a,f),ve(n,i,r,o,f,c),t.semantic!==!1&&t.semanticEvidence&&Le(i,t.semanticEvidence.callerMap(n,Ie(a))),i}function ge(n,e,t,i,r,o){for(let a of t){if(!y(a))continue;let f=z(n,a);if(f)for(let c of f){if(o&&!o.has(c.calleeLeaf))continue;let m=oe(a,i.get(c.calleeLeaf)??[]);if(!m||m.length===0)continue;let s=re(n,a,m,c.memberAccess,c.calleeQualifier);s&&r.has(s.symbolId)&&s.file!==a&&K(e,s.symbolId,a)}}}function he(n,e,t,i){let r=Me(t);for(let o of Re(n,i))n.isIgnored(o.relative_path)||De(o,r.get(o.symbol_id))||K(e,o.symbol_id,o.relative_path)}function Re(n,e){return ie(n,e?[...e]:void 0)}function Me(n){let e=new Map;for(let t of n)e.set(t.symbolId,{docId:t.documentId,startLine:t.startLine,endLine:t.endLine});return e}function De(n,e){return!!e&&e.docId===n.document_id&&n.chunk_start>=e.startLine&&n.chunk_end<=e.endLine}function ve(n,e,t,i,r,o){for(let a of t){if(y(a)!=="rust")continue;let f=S(n,a,{includeRustAttributeNames:!0});if(f.length!==0)for(let{name:c}of f){if(o&&!o.has(c))continue;let m=i.get(c);if(m)for(let s of m)r.has(s.symbolId)&&s.file!==a&&K(e,s.symbolId,a)}}}function K(n,e,t){let i=n.get(e);i||(i=new Set,n.set(e,i)),i.add(t)}function Ce(n){let e=new Set;for(let t of n){let i="leaf"in t&&typeof t.leaf=="string"?t.leaf:"symbol"in t&&typeof t.symbol=="string"?W(t.symbol):"";i&&e.add(i)}return e.size>0?e:null}function Ie(n){return n.filter(e=>"relativePath"in e&&"symbol"in e&&"leaf"in e)}function Le(n,e){for(let[t,i]of e){let r=n.get(t);r||(r=new Set,n.set(t,r));for(let o of i)r.add(o)}}var Fe=w("cross-file-caller-files",{clearGroups:["whole-project","source-file"]}),xe=w("source-fallback-caller-files",{clearGroups:["whole-project","source-file"]});function ue(n,e,t){let i=e.filter(o=>!n.has(o.symbolId));if(i.length>0){let o=t(i);for(let a of i)n.set(a.symbolId,o.get(a.symbolId)??new Set)}let r=new Map;for(let o of e){let a=n.get(o.symbolId);a&&a.size>0&&r.set(o.symbolId,new Set(a))}return r}function q(n,e,t={}){if(e===void 0)return j(n,e,t);let i=ue(Fe.get(n,()=>new Map),e,r=>j(n,r,{semantic:!1}));return t.semantic===!1||!t.semanticEvidence?i:me(i,t.semanticEvidence.callerMap(n,e.filter(r=>"relativePath"in r&&"symbol"in r&&"leaf"in r)))}function V(n,e,t={}){return t.skipPath?_(n,e,t):ue(xe.get(n,()=>new Map),e,i=>_(n,i))}function de(n,e,t={}){let i=q(n,e,{semantic:t.semantic,semanticEvidence:t.semanticEvidence});return t.sourceFallback===!1?i:me(i,V(n,e))}function me(n,e){let t=new Map;for(let[i,r]of n)t.set(i,new Set(r));for(let[i,r]of e){let o=t.get(i)??new Set;for(let a of r)o.add(a);t.set(i,o)}return t}function be(n,e,t){let i=e.identifierResolution==="strict"?T:ce,r=e.candidateNames?se(e.candidateNames):null,o=0,a=0,f=0,c=0,m="";for(let s of e.paths)if(o+=1,m=s,!(!y(s)&&!(e.includeVueSfc&&O(s)))&&!n.isIgnored(s)&&!e.skipPath?.(s))try{if(r&&!le(B(n,s),r))continue;a+=1;let h=(u,b,k,g)=>{if(e.candidateNames&&!e.candidateNames.has(u))return;f+=1;let R=e.resolveTargets?e.resolveTargets({sourceFile:s,name:u,kind:b,defaultTargets:g}):g();for(let E of R)c+=1,t({sourceFile:s,name:u,target:E,occurrences:k,kind:b})},x=te(n,s);for(let[u,b]of x)h(u,"identifier",b.length,()=>i(n,s,u));for(let u of S(n,s,{includeCrossLanguageDispatchNames:e.includeCrossLanguageDispatchNames,includeRustAttributeNames:e.includeRustAttributeNames})){let b=u.kind==="cross-language-dispatch"?()=>T(n,s,u.name):()=>i(n,s,u.name);h(u.name,u.kind,u.occurrences,b)}}finally{e.afterPath?.(s),o%10===0&&G("source-reference-scan.progress",()=>{},()=>({scannedPaths:o,currentPath:m,candidateMatchedPaths:a,visitedNames:f,visitedHits:c}))}}function pe(n,e={}){let{scope:t,files:i,minLoc:r=1,maxLoc:o=Number.POSITIVE_INFINITY,excludeSymbol:a,excludeEntrySurfaces:f=!1,excludeTypesFiles:c=!1,excludeRootedSymbols:m=!1,requireFunctionLikeSymbol:s=!1,requireCallableSymbol:F=!1,excludeRustTraitImplMembers:h=!1,includeSuppressed:x=!1,sortByLocDesc:u=!1}=e,b=[],k=ke(n,{scope:t,files:i,requireFunctionLikeSymbol:s,requireCallableSymbol:F}),g=new Map,R=new Map,E=l=>{let d=g.get(l);if(d!==void 0)return d;let p=ee(n,l);return g.set(l,p),p},Se=l=>{let d=R.get(l);if(d!==void 0)return d;let p=C(l);return R.set(l,p),p};for(let l of k){let d=l.relativePath;if(n.isIgnored(d)||f&&E(d)||!Ee(l,{requireFunctionLikeSymbol:s,requireCallableSymbol:F})||a!==void 0&&l.symbol===a)continue;let p=L(l);p<r||p>o||c&&we(d)||m&&ne(n,l.symbol,d)||h&&X(l.symbol)||Se(d)!=="test"&&(Y(l.symbol)||!x&&D(n,d,l.startLine)||b.push(l))}return u?b.sort((l,d)=>L(d)-L(l)):b}function ke(n,e){return e.files!==void 0?[...new Set(e.files.map(i=>i.replace(/\\/g,"/")))].sort().filter(i=>!e.scope||i.includes(e.scope)).flatMap(i=>v(n,i)):e.requireCallableSymbol?N(n,{scope:e.scope,symbolMatches:P,sqlPrefilter:"callable"}):e.requireFunctionLikeSymbol?N(n,{scope:e.scope,symbolMatches:A,sqlPrefilter:"function-like"}):$(n,e.scope)}function Ee(n,e){return e.requireCallableSymbol?P(n.symbol):e.requireFunctionLikeSymbol?A(n.symbol):n.isFunctionLike}function we(n){return(n.split("/").pop()??"").includes("types")}var ye=class{constructor(e){this.db=e}db;scopedDefinitions(e){return Z(this.db,e)}definitionsForFile(e){return v(this.db,e)}productionCallableDefinitions(e={}){return pe(this.db,e)}calleeMap(e,t={}){return fe(this.db,e,{...t,semanticEvidence:I})}crossFileCallerMap(e,t={}){return q(this.db,e,{...t,semanticEvidence:I})}sourceFallbackCallerFiles(e,t={}){return V(this.db,e,t)}callerFileMap(e,t={}){return de(this.db,e,{...t,semanticEvidence:I})}frameworkReferencedSymbolIds(e){let t=new Map;for(let r of e){if(!r.leaf)continue;let o=t.get(r.leaf)??[];o.push(r.symbolId),t.set(r.leaf,o)}let i=new Set;for(let r of M(this.db,{includeIgnored:!1}))if(y(r)==="rust")for(let{name:o}of S(this.db,r,{includeRustAttributeNames:!0}))for(let a of t.get(o)??[])i.add(a);return i}symbolsWithNonSelfCallees(e,t={}){if(e.length===0)return new Set;let i=new Map(e.map(o=>[o.symbolId,o.symbol])),r=this.calleeMap(e,t);return new Set([...r.entries()].filter(([o,a])=>{let f=i.get(o);return a.some(c=>c.symbol!==f)}).map(([o])=>o))}fileDependencyGraph(e){return Q(this.db,e)}fileKind(e){return C(e)}hasSuppressionComment(e){return D(this.db,e.relativePath,e.startLine)}sourceFiles(){return H(this.db)}scanSourceReferences(e,t){be(this.db,e,t)}callableSignature(e){let t=U(this.db).forFile(e.relativePath,{facts:!0}).facts?.callables.find(i=>i.startLine===e.startLine&&i.endLine===e.endLine);return t?{paramCount:t.paramCount}:null}};export{V as a,me as b,ye as c};
-//# sourceMappingURL=chunk-2BMSSRBH.js.map

package/dist/chunk-2M2LSIMY.js

@@ -1,7 +0,0 @@
-import{a as z}from"./chunk-GHNPACNP.js";import{b as C}from"./chunk-6MFXCMZC.js";import{c as W}from"./chunk-RVZC6TJE.js";import{b as U}from"./chunk-POBJ6FR2.js";import{h as D}from"./chunk-AADQLOQ4.js";import{a as _}from"./chunk-HX4X7KG3.js";import{a as k,b as j,e as A}from"./chunk-2USA3S3P.js";import{C as I,K as O,T as p,Y as T,i as F,k as M,l as B}from"./chunk-2VAHDDLM.js";import{c as S,d as w,l as $}from"./chunk-BL6DCHQP.js";import{m as P}from"./chunk-7HXT6YLU.js";import{basename as me,extname as K}from"path";var oe=12,se=280;function y(n,e,t,o){let i=ae(n,e,t,o);if(i.size===0)return ce();let r=[],a=new Set,u=(l,d,c,f)=>{if(d===e&&c<=o&&f>=t)return;let m=`${d}:${c}:${f}:${l}`;a.has(m)||(a.add(m),r.push({name:l,relativePath:d,startLine:c,endLine:f}))};for(let l of p(n,e))i.has(l.leaf)&&u(l.leaf,l.relativePath,l.startLine,l.endLine);for(let l of O(n,e)){let d=l.localName;if(!d||!i.has(d)||!l.sourcePath||l.kind==="namespace")continue;let c=l.importedName==="default"?d:l.importedName;for(let f of _(n,l.sourcePath,c,{maxReexportDepth:3}))u(d,f.relativePath,f.startLine,f.endLine)}r.sort(H);let s=r.map(l=>{let d=le(n,l);return d?{...l,source:d}:null}).filter(l=>l!==null).slice(0,oe);return x(s)}function X(n,e=[]){return x(ue(n.flatMap(t=>t?.inline??[]),e))}function ae(n,e,t,o){let i=I(n,e),r=new Set;if(!i)return r;for(let a=t;a<=o;a+=1)for(let u of i.identifiersByLine[a]??[])r.add(u);return r}function le(n,e){if(e.startLine!==e.endLine)return null;let t=(B(n,e.relativePath)[e.startLine]??"").trim();if(!t||t.length>se)return null;let o=t.indexOf("=");if(o<0||t[o+1]===">")return null;let i=t.slice(o+1).replace(/(?:\/\/|#).*$/u,"").trim();if(!i||i.includes("${")||/\b(?:function|class|struct|interface|trait|enum|lambda)\b/u.test(i))return null;let a=i.replace(/(['"`])(?:\\.|(?!\1).)*\1/gu,"").replace(/\b(?:0[xX][\dA-Fa-f_]+|0[bB][01_]+|0[oO][0-7_]+|\d[\d_]*(?:\.\d[\d_]*)?(?:[eE][+-]?\d+)?)n?\b/gu,""),u=new Set(["true","false","null","undefined","None","True","False"]);return(a.match(/[A-Za-z_][A-Za-z0-9_]*/gu)??[]).some(l=>!u.has(l))?null:t}function ue(n,e){let t=new Map;for(let o of n){if(de(o,e))continue;let i=`${o.relativePath}:${o.startLine}:${o.endLine}:${o.name}`;t.has(i)||t.set(i,{...o})}return[...t.values()].sort(H)}function de(n,e){return e.some(t=>t.relativePath===n.relativePath&&t.startLine<=n.startLine&&t.endLine>=n.endLine)}function H(n,e){return n.relativePath.localeCompare(e.relativePath)||n.startLine-e.startLine||n.name.localeCompare(e.name)}function x(n){return{coverage:"indexed-project-literal-values",inline:n}}function ce(){return x([])}function G(n,e){let t=W(n,e);if(!t)return[];let o=T(n,[t],{sort:!0});if(o.length===0)return[];let i=Math.max(0,M(F(n,t)).length-1),r=o.map(s=>({symbol:s.symbol,shortName:s.shortName,startLine:s.startLine,endLine:Math.min(s.endLine,i),signature:s.signature,children:[]})),a=new Map;for(let s of r)a.set(s.symbol,s);let u=[];for(let s=0;s<o.length;s++){let l=o[s],d=r[s];if(l.enclosingSymbol&&a.has(l.enclosingSymbol)){a.get(l.enclosingSymbol).children.push(d);continue}let c=null,f=1/0;for(let m of r)if(m!==d&&m.startLine<=d.startLine&&m.endLine>=d.endLine){if(m.startLine===d.startLine&&m.endLine===d.endLine&&!$(m.symbol,d.symbol))continue;let g=m.endLine-m.startLine;g<f&&(f=g,c=m)}c?c.children.push(d):u.push(d)}return u}function Je(n,e,t={}){let{context:o=0}=t,i=ie(e);if(i)return re(n,i.filePath,i.startLine,i.endLine,o);let r=ne(n,e);if(r)return Y(n,r);let a=k(n,e);return a?h(n,a,o):null}function Qe(n,e,t={}){if(e.length===0)throw new RangeError("code requires at least one selector.");if(e.length>24)throw new RangeError(`code accepts at most ${24} selectors per complete packet; received ${e.length}.`);let o=t.context??0,i=t.members??"exported",r=e.map(s=>ge(n,s,o,i)),a=r.flatMap(s=>s.results),u=a.map(s=>({relativePath:s.relativePath,startLine:s.startLine,endLine:s.endLine}));return{requested:e.length,matched:r.filter(s=>s.status==="matched").length,ambiguous:r.filter(s=>s.status==="ambiguous").length,missing:r.filter(s=>s.status==="missing").length,entries:r,bindingClosure:X(a.map(s=>s.bindingClosure),u)}}function ge(n,e,t,o){let i=ie(e);if(i){let d=re(n,i.filePath,i.startLine,i.endLine,t);return d?pe(n,e,d,t):R(n,e,"definition-source-unreadable")}let r=ne(n,e);if(r)return be(n,e,r,t,o);let a=j(n,e);if(!a.match)return R(n,e,"definition-not-found");let u=Ne(n,a),s=u.map(te);if(a.total>1){let d=a.total<=4&&u.length===a.total;return{selector:e,status:"ambiguous",kind:"source",totalCandidates:a.total,results:d?u.flatMap(c=>{let f=h(n,c,t);return f?[f]:[]}):[],definitions:[],candidates:s,omittedCandidates:Math.max(0,a.total-s.length),suggestions:[]}}let l=h(n,a.match,t);return l?Re(e,l):R(n,e,"definition-source-unreadable")}function pe(n,e,t,o){let i=p(n,t.relativePath).filter(l=>!Z(l,t.relativePath)),r=he(n,t,i),a=V(r.map(l=>h(n,l,o)).filter(l=>l!==null)).filter(l=>!ee(t,l)),u=new Set(a.map(l=>l.symbol)),s=r.filter(l=>!u.has(l.symbol)&&!(t.startLine<=l.startLine&&t.endLine>=l.endLine)).map(te);return{selector:e,status:"matched",kind:"source",totalCandidates:1,results:[t,...a],definitions:[],candidates:[],omittedCandidates:0,suggestions:[],rangeCoverage:{basis:"requested-range-and-same-file-call-closure",referencedDefinitions:r.length,returnedDefinitions:r.length-s.length,returnedBodies:a.length,omittedDefinitions:s.length,omittedLedger:s}}}function he(n,e,t){if(!b(e.freshness))return[];if(t.length===0)return[];let o=D(n,t,{additive:!1,semantic:!1}),i=new Map;for(let a of t){let u=i.get(a.symbol)??[];u.push(a),i.set(a.symbol,u)}let r=new Map;for(let a of t)if(!(a.endLine<e.startLine||a.startLine>e.endLine)){for(let u of o.get(a.symbolId)??[])if(u.file===e.relativePath&&!((u.source==="ast-callsite"||u.source==="scip-occurrence")&&(u.chunkId<e.startLine||u.chunkId>e.endLine)))for(let s of i.get(u.symbol)??[])r.set(s.symbolId,s)}return Q(n,[...r.values()],t)}function be(n,e,t,o,i){let r=t.relativePath,a=ye(n,r),u=b(t.freshness)?p(n,r).filter(g=>!Z(g,r)):[],s=u.filter(g=>z(n,g)),l=s.length>0?s:Ce(a,u),d=i==="all"?[]:Q(n,l,u),c=i==="all"||u.length===0?[Y(n,t)]:V(d.map(g=>h(n,g,o)).filter(g=>g!==null)),f=ve(a,c),m=Se(r,a,c),v=De(a);return{selector:e,status:"matched",kind:"file-source",totalCandidates:1,results:c,definitions:[],candidates:[],omittedCandidates:0,suggestions:[],fileCoverage:{members:i,basis:i==="all"||u.length===0?"complete-file-source":s.length>0?"explicit-exports-and-same-file-reference-closure":"top-level-and-same-file-reference-closure",totalDefinitions:v,returnedDefinitions:f,returnedBodies:c.length,omittedDefinitions:Math.max(0,v-f),omittedLedger:m}}}function Ce(n,e){let t=new Set(n.map(o=>o.symbol));return e.filter(o=>t.has(o.symbol))}function ye(n,e){return G(n,e).flatMap(t=>Le(t,e)?t.children:[t])}function Z(n,e){return J(e).has(n.leaf)}function Le(n,e){return J(e).has(w(n.symbol))}function J(n){let e=me(n);return new Set([e,e.slice(0,Math.max(0,e.length-K(e).length))])}function Q(n,e,t){if(e.length===0)return[];let o=D(n,t,{additive:!0,semantic:!1}),i=new Map;for(let u of t){let s=i.get(u.symbol)??[];s.push(u),i.set(u.symbol,s)}let r=new Map,a=[...e];for(;a.length>0;){let u=a.shift();if(!r.has(u.symbolId)){r.set(u.symbolId,u);for(let s of o.get(u.symbolId)??[])for(let l of i.get(s.symbol)??[])r.has(l.symbolId)||a.push(l)}}return[...r.values()].sort(xe)}function V(n){let e=[...n].sort((o,i)=>o.relativePath.localeCompare(i.relativePath)||o.startLine-i.startLine||i.endLine-o.endLine),t=[];for(let o of e)t.some(i=>ee(i,o))||t.push(o);return t}function Y(n,e){let t=e.text.split(`
-`);return{symbol:e.relativePath,shortName:e.relativePath,relativePath:e.relativePath,startLine:0,endLine:Math.max(0,t.length-1),language:n.get("SELECT language FROM documents WHERE relative_path = ?",e.relativePath)?.language??E(e.relativePath),source:e.text,freshness:e.freshness,...b(e.freshness)?{bindingClosure:y(n,e.relativePath,0,Math.max(0,t.length-1))}:{}}}function ve(n,e){return L(n).filter(t=>e.some(o=>N(t,o))).length}function Se(n,e,t){let o=[];return q(o,n,e,t,0),o}function q(n,e,t,o,i){for(let r of t){if(o.some(u=>N(r,u)))continue;let a=L(r.children).filter(u=>!o.some(s=>N(u,s))).length;n.push({symbol:r.symbol,shortName:r.shortName,relativePath:e,startLine:r.startLine,endLine:r.endLine,signature:r.signature,depth:i,nestedDefinitions:a}),q(n,e,r.children,o,i+1)}}function L(n){return n.flatMap(e=>[e,...L(e.children)])}function De(n){return L(n).length}function N(n,e){return e.startLine<=n.startLine&&e.endLine>=n.endLine}function ee(n,e){return n.relativePath===e.relativePath&&n.startLine<=e.startLine&&n.endLine>=e.endLine}function xe(n,e){return n.startLine-e.startLine||e.endLine-n.endLine||n.symbol.localeCompare(e.symbol)}function Re(n,e){return{selector:n,status:"matched",kind:"source",totalCandidates:1,results:[e],definitions:[],candidates:[],omittedCandidates:0,suggestions:[]}}function R(n,e,t){return{selector:e,status:"missing",kind:"source",totalCandidates:0,results:[],definitions:[],candidates:[],omittedCandidates:0,suggestions:A(n,e,5),reason:t}}function ne(n,e){try{return C(n,e)}catch(t){if(t instanceof P)return null;throw t}}function Ne(n,e){if(!e.match)return[];let t=[e.match];for(let i of e.candidates){let r=p(n,i.relativePath).find(a=>a.symbol===i.symbol&&a.startLine===i.startLine);r&&t.push(r)}let o=new Set;return t.filter(i=>{let r=`${i.relativePath}:${i.startLine}:${i.endLine}:${i.symbol}`;return o.has(r)?!1:(o.add(r),!0)})}function te(n){return{symbol:n.symbol,shortName:S(n.symbol),relativePath:n.relativePath,startLine:n.startLine,endLine:n.endLine}}function ie(n){let e=n.match(/^(.+):(\d+)-(\d+)$/);if(!e)return null;let t=Number(e[2]),o=Number(e[3]);if(!Number.isSafeInteger(t)||t<1)throw new RangeError(`Source range start line must be a positive integer, got "${e[2]}".`);if(!Number.isSafeInteger(o)||o<t)throw new RangeError(`Source range end line must be an integer at or after ${t}, got "${e[3]}".`);return{filePath:e[1],startLine:t,endLine:o}}function h(n,e,t){let o=n.get("SELECT language FROM documents WHERE relative_path = ?",e.relativePath),i=C(n,e.relativePath);if(!i)return null;let a=i.text.split(`
-`),u=e.endLine<=e.startLine?U(n,e.relativePath,e.startLine,Number.MAX_SAFE_INTEGER):null,s=u?.unitType?u.unitStartLine:e.startLine,l=u?.unitType?u.unitEndLine:e.endLine,d=Math.max(0,s-t),c=Math.min(a.length-1,l+t),f=a.slice(d,c+1).join(`
-`);return{symbol:e.symbol,shortName:S(e.symbol),relativePath:e.relativePath,startLine:d,endLine:c,language:o?.language??E(e.relativePath),source:f,freshness:i.freshness,...b(i.freshness)?{bindingClosure:y(n,e.relativePath,d,c)}:{}}}function re(n,e,t,o,i){let r=C(n,e);if(!r)return null;let a=n.get("SELECT language FROM documents WHERE relative_path = ?",r.relativePath),s=r.text.split(`
-`);if(t>s.length)return null;let l=Math.max(0,t-1-i),d=Math.min(s.length-1,o-1+i),c=s.slice(l,d+1).join(`
-`);return{symbol:`${r.relativePath}:${t}-${o}`,shortName:`${r.relativePath}:${t}-${o}`,relativePath:r.relativePath,startLine:l,endLine:d,language:a?.language??E(r.relativePath),source:c,freshness:r.freshness,...b(r.freshness)?{bindingClosure:y(n,r.relativePath,l,d)}:{}}}function b(n){return!!(n&&n.semantic.state!=="stale"&&n.semantic.basis!=="no-compiler-document")}function E(n){switch(K(n).toLowerCase()){case".ts":case".tsx":case".mts":case".cts":return"typescript";case".js":case".jsx":case".mjs":case".cjs":return"javascript";case".py":case".pyi":return"python";case".rs":return"rust";case".go":return"go";case".java":return"java";case".kt":case".kts":return"kotlin";case".scala":return"scala";case".rb":return"ruby";case".php":return"php";case".cs":return"csharp";case".vb":return"vb";case".dart":return"dart";case".c":case".h":return"c";case".cc":case".cpp":case".cxx":case".hpp":case".hh":case".hxx":return"cpp";case".vue":return"vue";default:return null}}export{G as a,Je as b,Qe as c};
-//# sourceMappingURL=chunk-2M2LSIMY.js.map

package/dist/chunk-2N6WBNDC.js

@@ -1,29 +0,0 @@
-import{b as a}from"./chunk-RVZC6TJE.js";import{e as l}from"./chunk-JFMI5SGB.js";import{c as o,f as i}from"./chunk-BL6DCHQP.js";function _(e,t){let r=a(e,t);return r.length===0?[]:u([...c(e,r),...f(e,r)]).filter(s=>!e.isIgnored(s.relative_path)).map(d)}function R(e,t){let r=a(e,t);return r.length===0?[]:u(c(e,r)).filter(s=>!e.isIgnored(s.relative_path)).map(s=>({...d(s),basis:"external-reference"}))}function c(e,t){let r=t.map(()=>"?").join(", ");return e.all(`SELECT DISTINCT d1.relative_path, gs.symbol
-    FROM mentions m
-    JOIN chunks c ON m.chunk_id = c.id
-    JOIN documents d1 ON c.document_id = d1.id
-    JOIN global_symbols gs ON m.symbol_id = gs.id
-    WHERE d1.relative_path NOT IN (${r})
-      AND (
-        EXISTS (
-          SELECT 1
-          FROM defn_enclosing_ranges der
-          JOIN documents d2 ON der.document_id = d2.id
-          WHERE der.symbol_id = gs.id
-            AND d2.relative_path IN (${r})
-        )
-        OR EXISTS (
-          SELECT 1
-          FROM mentions def_m
-          JOIN chunks def_c ON def_m.chunk_id = def_c.id
-          JOIN documents d2 ON def_c.document_id = d2.id
-          WHERE def_m.symbol_id = gs.id
-            AND def_m.role = 1
-            AND d2.relative_path IN (${r})
-        )
-      )
-      AND m.role != 1
-      AND ${e.localSymbolPredicate}
-      ${e.pathExclusionsFor("d1")}
-    ORDER BY d1.relative_path`,...t,...t,...t)}function f(e,t){let r=new l(e);return t.flatMap(s=>r.definitionsForFile(s).filter(n=>i(n.symbol)).map(n=>({relative_path:s,symbol:n.symbol})))}function u(e){let t=new Set;return e.filter(r=>{let s=`${r.relative_path}|${r.symbol}`;return t.has(s)?!1:(t.add(s),!0)})}function d(e){return{consumer:e.relative_path,symbol:e.symbol,shortName:o(e.symbol)}}export{_ as a,R as b};
-//# sourceMappingURL=chunk-2N6WBNDC.js.map

package/dist/chunk-2OOY75BW.js

@@ -1,2 +0,0 @@
-import{b as f,c as m}from"./chunk-JFMEXGFE.js";import{execFileSync as b}from"child_process";import{platform as S}from"os";var w=1e3,T=2*1024*1024,I=25;function N(e,n,r=M){let t=r.readIdentity(e),o=new Map;return t&&o.set(e,t),{rootPid:e,rootIdentity:t,ownsProcessGroup:n,knownMembers:o}}async function k(e,n,r=M){if(!e.rootIdentity){let a=await l(e,n.gracefulMs+n.forceMs,r);return{reaped:a,reason:a?"terminated":"identity-unavailable",detail:a?void 0:`Could not establish the birth identity of process ${e.rootPid}.`}}let t=h(e,r);if(t==="mismatch")return{reaped:!1,reason:"identity-mismatch",detail:`Process ${e.rootPid} no longer has the identity owned by this runner.`};if(t==="exited"&&!g(e,r))return{reaped:!0,reason:"terminated"};if(r.platform==="win32"){try{r.terminateWindowsTree(e.rootPid)}catch(u){let c=await l(e,n.forceMs,r);return{reaped:c,reason:c?"terminated":"signal-failed",detail:c?void 0:p(u)}}let a=await l(e,n.forceMs,r);return{reaped:a,reason:a?"terminated":"deadline"}}let o=P(e,"SIGTERM",r);if(await l(e,n.gracefulMs,r))return{reaped:!0,reason:"terminated"};let s=P(e,"SIGKILL",r);return await l(e,n.forceMs,r)?{reaped:!0,reason:"terminated"}:s?{reaped:!1,reason:s.reason,detail:s.detail}:o?{reaped:!1,reason:o.reason,detail:o.detail}:{reaped:!1,reason:"deadline",detail:`Process tree ${e.rootPid} did not exit before its termination deadline.`}}function h(e,n){let r=n.readIdentity(e.rootPid);if(!r)return"exited";if(!e.rootIdentity||!f(e.rootIdentity,r))return"mismatch";e.knownMembers.set(e.rootPid,r);for(let t of n.listDescendantPids(e.rootPid)){let o=n.readIdentity(t);o&&e.knownMembers.set(t,o)}return"owned"}function P(e,n,r){let t=h(e,r);if(t==="mismatch")return{reason:"identity-mismatch",detail:`Process ${e.rootPid} changed identity before ${n}.`};if(t==="owned"&&e.ownsProcessGroup)try{return r.signal(-e.rootPid,n),null}catch(i){if(!y(i))return{reason:"signal-failed",detail:p(i)}}let o=null;for(let i of e.knownMembers.values()){let s=r.readIdentity(i.pid);if(!(!s||!f(i,s)))try{r.signal(i.pid,n)}catch(d){!y(d)&&o===null&&(o=p(d))}}return o===null?null:{reason:"signal-failed",detail:o}}async function l(e,n,r){let t=r.now()+n;for(;g(e,r);){if(r.now()>=t)return!1;await r.sleep(Math.min(I,Math.max(1,t-r.now())))}return!0}function g(e,n){if(!e.rootIdentity&&n.isProcessAlive(e.rootPid))return!0;for(let r of e.knownMembers.values()){let t=n.readIdentity(r.pid);if(t&&f(r,t))return!0}return!!(e.ownsProcessGroup&&n.isProcessGroupAlive(e.rootPid))}function x(e){let n=R(!1),r=new Map;for(let s of n.split(/\r?\n/)){let d=/^\s*(\d+)\s+(\d+)\s*$/.exec(s);if(!d)continue;let a=Number(d[1]),u=Number(d[2]),c=r.get(u)??[];c.push(a),r.set(u,c)}let t=[],o=[...r.get(e)??[]],i=new Set;for(;o.length>0;){let s=o.pop();i.has(s)||(i.add(s),t.push(s),o.push(...r.get(s)??[]))}return t}function R(e){return b("ps",["-axo",e?"pid=,ppid=,rss=":"pid=,ppid="],{encoding:"utf8",timeout:w,maxBuffer:T,env:{...process.env,LC_ALL:"C",LANG:"C"},stdio:["ignore","pipe","ignore"]})}function y(e){return typeof e=="object"&&e!==null&&"code"in e&&e.code==="ESRCH"}function p(e){return e instanceof Error?e.message:String(e)}var M={platform:S(),now:Date.now,readIdentity:m,isProcessAlive(e){try{return process.kill(e,0),!0}catch(n){return typeof n=="object"&&n!==null&&"code"in n&&n.code==="EPERM"}},isProcessGroupAlive(e){if(this.platform==="win32")return!1;try{return process.kill(-e,0),!0}catch(n){return typeof n=="object"&&n!==null&&"code"in n&&n.code==="EPERM"}},listDescendantPids(e){if(this.platform==="win32")return[];try{return x(e)}catch{return[]}},signal(e,n){process.kill(e,n)},terminateWindowsTree(e){b("taskkill.exe",["/PID",String(e),"/T","/F"],{timeout:w,maxBuffer:T,stdio:"ignore",windowsHide:!0})},async sleep(e){await new Promise(n=>setTimeout(n,e))}};export{N as a,k as b};
-//# sourceMappingURL=chunk-2OOY75BW.js.map

package/dist/chunk-2USA3S3P.js

@@ -1,3 +0,0 @@
-import{$ as M,O as f,P as S,S as R}from"./chunk-2VAHDDLM.js";import{b as B}from"./chunk-YXPUP5G2.js";import{b as N,c as _,d as w,f as k,g as A,h as z}from"./chunk-BL6DCHQP.js";import{c as O}from"./chunk-IW5XQG5G.js";var T=O("symbol-resolution",{clearGroups:[]});function he(e,n){return G(e,n).match}function G(e,n){return T.get(e,n,()=>{let t=W(e,n.trim()).filter(i=>!e.isIgnored(i.relative_path));if(t.length>0)return L(e,t);let o=P(e,n);if(o&&!e.isIgnored(o.relative_path))return L(e,[o]);let r=H(e,n);if(r.length>0)return L(e,r);let s=U(e,n);return s.length>0?L(e,s):J(e,n)})}function H(e,n){let t=n.trim().replace(/\(\)$/u,""),o=t.lastIndexOf(":");if(o<=0||o===t.length-1||t.startsWith("local:"))return[];let r=t.slice(o+1);if(!/^[\p{L}_$][\p{L}\p{N}_$]*$/u.test(r))return[];let s=[`/${r}().`,`/${r}.`,`/${r}#`,`#${r}().`,`#${r}.`,`/${r}/`],i=`gs.display_name = ? OR ${s.map(()=>"instr(gs.symbol, ?) > 0").join(" OR ")}`,a=[r,...s],l=f(e,{where:i,params:a,orderBy:"d.relative_path, der.start_line",limit:200}),u=l.length>0?[]:S(e,{where:i,params:a,orderBy:"d.relative_path, start_line",limit:200}),p=R(l,u).filter(m=>!e.isIgnored(m.relative_path)).filter(m=>_(m.symbol).replace(/\(\)$/u,"")===t);return[...new Map(p.map(m=>[`${m.symbol}\0${m.relative_path}`,m])).values()]}function U(e,n){let t=Q(n),o=E(t);if(!o)return[];let r=`%${o.path}%`,s=o.leaf;return X(e,r,s,t)}function X(e,n,t,o){let r=R([],[...Y(e,n,t),...Z(e,n,t)]).filter(s=>!e.isIgnored(s.relative_path)).filter(s=>C(s,o)>1);return r.sort((s,i)=>C(i,o)-C(s,o)||s.end_line-s.start_line-(i.end_line-i.start_line)||s.start_line-i.start_line||s.symbol.localeCompare(i.symbol)),r}function Y(e,n,t){return f(e,{where:"d.relative_path LIKE ? AND (gs.display_name = ? OR gs.symbol LIKE ?)",params:[n,t,`%/${t}.%`]})}function Z(e,n,t){return S(e,{where:"d.relative_path LIKE ? AND (gs.display_name = ? OR gs.symbol LIKE ?)",params:[n,t,`%/${t}.%`]})}function J(e,n){let t=Q(n),o=ae(n),r=oe(e,o),s=se(r,n,t).filter(a=>!e.isIgnored(a.relative_path));if(s.length>0)return L(e,s);let i=[];for(let a of r){if(e.isIgnored(a.relative_path))continue;let l=re(a,n,t,o);l<=0||i.push({row:a,score:l})}return i.sort((a,l)=>l.score-a.score||a.row.end_line-a.row.start_line-(l.row.end_line-l.row.start_line)||a.row.relative_path.localeCompare(l.row.relative_path)||a.row.symbol.localeCompare(l.row.symbol)),L(e,i.map(a=>a.row))}function L(e,n){let t=n.map(r=>M(e,r)),o=t[0]??null;return{match:o,candidates:o?V(t,o):[],total:t.length}}function V(e,n){let t=new Set([`${n.symbolId}:${n.relativePath}:${n.startLine}`]),o=[];for(let r of e){let s=`${r.symbolId}:${r.relativePath}:${r.startLine}`;if(!t.has(s)&&(t.add(s),o.push({symbol:r.symbol,shortName:_(r.symbol),relativePath:r.relativePath,startLine:r.startLine}),o.length>=5))break}return o}function P(e,n){let t=n.match(/^(.+):(\d+)(?:-(\d+))?$/);if(!t)return;let[,o,r,s]=t,i=B(e,o,{allowMultiple:!1,requirePathMatch:!0})[0]?.relativePath;if(!i)return;let a=Math.max(0,parseInt(r,10)-1),l=s?Math.max(a,parseInt(s,10)-1):a;return ee(e,i,a,l)??te(e,i,a,l)}function ee(e,n,t,o){return f(e,{where:"d.relative_path = ? AND der.start_line <= ? AND der.end_line >= ?",params:[n,t,o],orderBy:"(der.end_line - der.start_line) ASC",limit:1})[0]}function te(e,n,t,o){return S(e,{where:"d.relative_path = ? AND c.start_line <= ? AND c.end_line >= ?",params:[n,t,o],orderBy:"(MAX(c.end_line) - MIN(c.start_line)) ASC",limit:1})[0]}function be(e,n){let t=W(e,n).find(o=>!e.isIgnored(o.relative_path));return t?M(e,t):null}function W(e,n){let t=f(e,{where:"gs.symbol = ?",params:[n],orderBy:"d.relative_path, der.start_line"}),o=t.length>0?[]:S(e,{where:"gs.symbol = ?",params:[n],orderBy:"d.relative_path, start_line"});return R(t,o)}function Se(e,n){if("symbol"in n&&"relativePath"in n)return n;let t=ne(e,n.symbolId)[0];return t?M(e,t):null}function ne(e,n){let t=f(e,{where:"gs.id = ?",params:[n],orderBy:"der.start_line, der.end_line"}),o=S(e,{where:"gs.id = ?",params:[n],orderBy:"start_line, end_line"});return R(t,o)}function oe(e,n){let t=n.map(()=>"(gs.symbol LIKE ? OR d.relative_path LIKE ? OR COALESCE(gs.display_name, '') LIKE ?)"),o=n.flatMap(a=>{let l=`%${a}%`;return[l,l,l]}),r=t.join(`
-       AND `),s=f(e,{where:r,params:o,limit:200}),i=S(e,{where:r,params:o,limit:200});return R(s,i)}function re(e,n,t,o){let r=n.trim(),s=t,i=s.replace(/\(\)$/,""),a=n.toLowerCase(),l=t.toLowerCase(),u=l.replace(/\(\)$/,""),p=e.symbol,m=_(e.symbol),y=w(e.symbol),g=e.display_name??"",$=e.symbol.toLowerCase(),d=m.toLowerCase(),h=y.toLowerCase(),x=g.toLowerCase(),b=e.relative_path.toLowerCase(),j=/[/:.]/.test(t),I=E(t),v=I?.leaf.toLowerCase(),c=0;return(p===r||p===s)&&(c+=1150),(m===r||m===s)&&(c+=1100),g===i&&(c+=1180),y===i&&(c+=1160),(`${y}()`===r||`${y}()`===s)&&(c+=955),($===a||$===l)&&(c+=1e3),(d===a||d===l)&&(c+=950),(b===a||b===l)&&(c+=925),(b.endsWith(`/${l}`)||b.endsWith(`/${a}`))&&(c+=875),x===u&&(c+=850),h===u&&(c+=825),(`${h}()`===a||`${h}()`===l)&&(c+=820),(d.endsWith(`:${l}`)||d.endsWith(`:${u}`)||d.endsWith(`:${u}()`))&&(c+=800),$.includes(l)&&(c+=120),d.includes(l)&&(c+=140),b.includes(l)&&(c+=140),x.includes(l)&&(c+=110),o.every(q=>{let D=q.toLowerCase();return $.includes(D)||d.includes(D)||b.includes(D)||x.includes(D)})&&(c+=100+o.length*15),I&&b.includes(I.path.toLowerCase())&&(c+=360,v&&(h===v||`${h}()`===v||`${h}()`==`${v}()`)&&(c+=700),k(e.symbol)&&(c+=180)),A(e.symbol)&&h===u&&(c+=60),!j&&z(e.symbol)&&(c-=160),c-=Math.min(50,Math.max(0,e.end_line-e.start_line)),c}function E(e){let n=e.trim().replace(/\\/g,"/"),t=n.lastIndexOf("/");if(t<=0||t===n.length-1)return null;let o=n.slice(t+1).replace(/\(\)$/,"");return!o||o.includes(".")?null:{path:n.slice(0,t),leaf:o}}function Q(e){return e.trim().replace(/\(\)$/,"").replace(/\(.*$/,"")}function ae(e){let n=Q(e),t=n.split(/[^A-Za-z0-9_]+/).map(o=>o.trim()).filter(o=>o.length>0);return t.length>0?[...new Set(t)]:[n]}function se(e,n,t){let o=n.trim(),r=e.filter(a=>{let l=_(a.symbol),u=w(a.symbol),p=(a.display_name??"").trim();return a.symbol===o||l===o||l===t||u===o||u===t||`${u}()`===o||p===o||p===t||`${p}()`===o||C(a,t)>1||a.relative_path===o});if(r.length===0)return[];let s=t.replace(/\(\)$/u,""),i=r.filter(a=>w(a.symbol)===s);if(i.length>0){i.sort((l,u)=>F(l,u,t));let a=i.filter(l=>A(l.symbol));return a.length>0?a:i}return r.sort((a,l)=>F(a,l,t)),r}function F(e,n,t){return C(n,t)-C(e,t)||e.end_line-e.start_line-(n.end_line-n.start_line)||e.relative_path.localeCompare(n.relative_path)||e.symbol.localeCompare(n.symbol)}function C(e,n){let t=E(n);if(!t)return 0;let o=e.relative_path.toLowerCase(),r=w(e.symbol).toLowerCase(),s=t.path.toLowerCase(),i=t.leaf.toLowerCase();return o.includes(s)?r!==i?1:k(e.symbol)?N(e.symbol)===null?5:4:N(e.symbol)===null?3:2:0}function ge(e,n,t=5){let o=K(n);if(!o)return[];let r=f(e,{where:"1 = 1",orderBy:"d.relative_path, der.start_line",limit:5e3}),s=new Map;for(let i of r){if(e.isIgnored(i.relative_path))continue;let a=_(i.symbol),l=w(i.symbol),u=i.display_name??l,p=[a,l,u].filter(g=>g.trim().length>0),m=Math.min(...p.map(g=>ie(K(g),o))),y=s.get(a);(!y||m<y.distance)&&s.set(a,{shortName:a,distance:m})}return[...s.values()].sort((i,a)=>i.distance-a.distance||i.shortName.localeCompare(a.shortName)).slice(0,t).map(i=>i.shortName)}function K(e){return Q(e).toLowerCase().replace(/[^a-z0-9_]+/g,"")}function ie(e,n){if(e===n)return 0;if(e.length===0)return n.length;if(n.length===0)return e.length;let t=Array.from({length:n.length+1},(o,r)=>r);for(let o=0;o<e.length;o++){let r=[o+1];for(let s=0;s<n.length;s++){let i=e[o]===n[s]?0:1;r[s+1]=Math.min(r[s]+1,t[s+1]+1,t[s]+i)}t=r}return t[n.length]}export{he as a,G as b,be as c,Se as d,ge as e};
-//# sourceMappingURL=chunk-2USA3S3P.js.map