pi-lens 4.2.1 → 4.4.0

package/dist/clients/review-graph/query.js

@@ -1,244 +0,0 @@
-import { detectFileRole } from "../file-role.js";
-import { normalizeMapKey } from "../path-utils.js";
-import { findModuleForPath, getDownstreamModules, getModuleSourceFiles, } from "./workspace-modules.js";
-function dedupe(items) {
-    return [...new Set(items)].sort((a, b) => a.localeCompare(b));
-}
-function filePathFromNode(graph, nodeId) {
-    return graph.nodes.get(nodeId)?.filePath;
-}
-function collectIncomingEdges(graph, nodeIds, kind) {
-    const edges = [];
-    for (const nodeId of nodeIds) {
-        for (const edge of graph.edgesByTo.get(nodeId) ?? []) {
-            if (edge.kind === kind)
-                edges.push(edge);
-        }
-    }
-    return edges;
-}
-const DEFAULT_IMPACT_RELATIONS = [
-    "calls",
-    "references",
-    "imports",
-];
-/**
- * Transitive, depth-bounded impact of a file: "what depends on this, directly
- * and indirectly". Unlike {@link computeImpactCascade} (one hop), this walks
- * INCOMING edges (callers/referencers/importers) breadth-first up to `maxDepth`,
- * returning each reached dependent with the depth and the relation that first
- * reached it. Read-only graph traversal — the graphify-style symbol impact
- * query, over the edges the review graph already carries (#162 mental model).
- */
-export function computeTransitiveImpact(graph, seedFile, options) {
-    const normalized = normalizeMapKey(seedFile);
-    const maxDepth = Math.max(1, options?.maxDepth ?? 3);
-    const maxHits = Math.max(1, options?.maxHits ?? 200);
-    const relations = new Set(options?.relations ?? DEFAULT_IMPACT_RELATIONS);
-    // Seed from every symbol node in the file plus the file node itself (import
-    // edges point at the file node).
-    const seeds = [...(graph.symbolNodesByFile.get(normalized) ?? [])];
-    const fileNodeId = graph.fileNodes.get(normalized);
-    if (fileNodeId)
-        seeds.push(fileNodeId);
-    const visited = new Set(seeds);
-    let frontier = seeds.map((id) => ({ id, depth: 0 }));
-    const hits = [];
-    let maxDepthReached = 0;
-    for (let depth = 0; depth < maxDepth && frontier.length > 0; depth += 1) {
-        const next = [];
-        for (const node of frontier) {
-            for (const edge of graph.edgesByTo.get(node.id) ?? []) {
-                if (!relations.has(edge.kind))
-                    continue;
-                if (visited.has(edge.from))
-                    continue;
-                if (hits.length >= maxHits) {
-                    return {
-                        seedFile: normalized,
-                        hits,
-                        truncated: true,
-                        maxDepthReached,
-                    };
-                }
-                visited.add(edge.from);
-                const dependent = graph.nodes.get(edge.from);
-                const hitDepth = node.depth + 1;
-                maxDepthReached = Math.max(maxDepthReached, hitDepth);
-                hits.push({
-                    symbol: dependent?.symbolName ?? "",
-                    file: dependent?.filePath ?? "",
-                    depth: hitDepth,
-                    relation: edge.kind,
-                });
-                next.push({ id: edge.from, depth: hitDepth });
-            }
-        }
-        frontier = next;
-    }
-    return { seedFile: normalized, hits, truncated: false, maxDepthReached };
-}
-/**
- * #1550: evidence for a `missing_node` verdict — the node id sought and the
- * nearest thing the graph actually held. Runs ONLY on the miss path (one pass
- * over `fileNodes`, which the same call already consulted), so the hot path is
- * untouched. Keys are compared as the graph keys them (`normalizeMapKey`), so a
- * key-shape divergence shows up as "nearest is the same path" rather than
- * hiding behind a bare "missing".
- */
-function describeMissingNode(graph, normalizedFile) {
-    const lastSlash = normalizedFile.lastIndexOf("/");
-    const dir = lastSlash === -1 ? "" : normalizedFile.slice(0, lastSlash);
-    const base = normalizedFile.slice(lastSlash + 1);
-    const stem = base.replace(/\.[^./]*$/, "");
-    let sameDirFileCount = 0;
-    let sameDirSibling;
-    let sameStemTwin;
-    for (const known of graph.fileNodes.keys()) {
-        const knownLastSlash = known.lastIndexOf("/");
-        const knownDir = knownLastSlash === -1 ? "" : known.slice(0, knownLastSlash);
-        const knownBase = known.slice(knownLastSlash + 1);
-        if (knownDir === dir) {
-            sameDirFileCount += 1;
-            sameDirSibling ??= known;
-            // A same-stem twin in the same directory is the strongest hint —
-            // an extension/compiled-twin resolution miss rather than an absent file.
-            if (sameStemTwin === undefined &&
-                knownBase.replace(/\.[^./]*$/, "") === stem) {
-                sameStemTwin = known;
-            }
-        }
-    }
-    return {
-        soughtNodeId: `file:${normalizedFile}`,
-        graphFileCount: graph.fileNodes.size,
-        symbolNodeCount: graph.symbolNodesByFile.get(normalizedFile)?.length ?? 0,
-        sameDirFileCount,
-        nearestFile: sameStemTwin ?? sameDirSibling,
-    };
-}
-export function computeImpactCascade(graph, changedFile, moduleGraph) {
-    const normalizedFile = normalizeMapKey(changedFile);
-    const fileNodeId = graph.fileNodes.get(normalizedFile);
-    if (!fileNodeId) {
-        // #1445: a missing node has two causes that look identical here but mean
-        // opposite things — "the graph SHOULD know this file but doesn't" (a real
-        // gap) versus "this file's role is excluded from the graph by design"
-        // (test files, #260 — every graph-admission chokepoint in builder.ts
-        // guards on this exact condition, `detectFileRole(file) === "test"`;
-        // reused verbatim here rather than a second role list). A test edit not
-        // cascading is expected behavior, not a graph failure, so it must not
-        // produce the "review graph was unavailable" advisory that misled agents
-        // into distrusting a healthy graph 19% of the time in dogfooding.
-        if (detectFileRole(normalizedFile) === "test") {
-            return {
-                filePath: normalizedFile,
-                changedSymbols: [],
-                directImporters: [],
-                directCallers: [],
-                neighborFiles: [],
-                riskFlags: [],
-                indeterminate: {
-                    reason: "excluded_by_role",
-                    detail: "test-role file — excluded from the review graph by design (#260)",
-                },
-            };
-        }
-        // #1023: the changed file has no node in the graph — we CANNOT enumerate
-        // its dependents, so this empty result is "couldn't compute", NOT "nothing
-        // depends on it". Mark it indeterminate so callers surface an honest
-        // advisory instead of an all-clear (#533).
-        return {
-            filePath: normalizedFile,
-            changedSymbols: [],
-            directImporters: [],
-            directCallers: [],
-            neighborFiles: [],
-            riskFlags: [],
-            indeterminate: {
-                reason: "missing_node",
-                // #1550: the reason alone forced a manual re-derivation on every
-                // occurrence. Attach the evidence (log-only — see the type doc).
-                diagnostic: describeMissingNode(graph, normalizedFile),
-            },
-        };
-    }
-    const changedSymbols = graph.changedSymbolsByFile.get(normalizedFile) ?? [];
-    const symbolNodeIds = (graph.symbolNodesByFile.get(normalizedFile) ?? []).filter((nodeId) => {
-        const symbolName = graph.nodes.get(nodeId)?.symbolName;
-        return (!changedSymbols.length ||
-            (symbolName && changedSymbols.includes(symbolName)));
-    });
-    const effectiveSymbolNodeIds = symbolNodeIds.length > 0
-        ? symbolNodeIds
-        : (graph.symbolNodesByFile.get(normalizedFile) ?? []);
-    const importerFiles = dedupe((graph.edgesByTo.get(fileNodeId) ?? [])
-        .filter((edge) => edge.kind === "imports")
-        .flatMap((edge) => filePathFromNode(graph, edge.from) ?? []));
-    let callerFiles = dedupe(collectIncomingEdges(graph, effectiveSymbolNodeIds, "calls").flatMap((edge) => filePathFromNode(graph, edge.from) ?? []));
-    if (callerFiles.length === 0 &&
-        changedSymbols.length > 0 &&
-        importerFiles.length > 0) {
-        callerFiles = importerFiles;
-    }
-    // For non-jsts languages, import/call edges are absent but resolved
-    // `references` edges exist. Include them as supplemental neighbors.
-    const referenceFiles = dedupe(collectIncomingEdges(graph, effectiveSymbolNodeIds, "references").flatMap((edge) => filePathFromNode(graph, edge.from) ?? []));
-    let neighborFiles = dedupe([
-        ...importerFiles,
-        ...callerFiles,
-        ...referenceFiles,
-    ]).filter((candidate) => normalizeMapKey(candidate) !== normalizedFile);
-    // Module-level downstream expansion for monorepos
-    const downstreamModuleFiles = [];
-    if (moduleGraph) {
-        const changedModule = findModuleForPath(moduleGraph, normalizedFile);
-        if (changedModule) {
-            const downstream = getDownstreamModules(moduleGraph, changedModule.name);
-            for (const depName of downstream) {
-                const depMod = moduleGraph.modules.get(depName);
-                if (depMod) {
-                    // Add representative source files from downstream modules
-                    downstreamModuleFiles.push(...getModuleSourceFiles(depMod.root));
-                }
-            }
-        }
-    }
-    if (downstreamModuleFiles.length > 0) {
-        neighborFiles = dedupe([...neighborFiles, ...downstreamModuleFiles]);
-    }
-    const directImports = dedupe((graph.edgesByFrom.get(fileNodeId) ?? [])
-        .filter((edge) => edge.kind === "imports")
-        .flatMap((edge) => filePathFromNode(graph, edge.to) ?? []));
-    const riskFlags = new Set();
-    for (const nodeId of effectiveSymbolNodeIds) {
-        const node = graph.nodes.get(nodeId);
-        if (!node)
-            continue;
-        if (node.exported)
-            riskFlags.add("exported symbol changed");
-        const fanout = (graph.edgesByFrom.get(nodeId) ?? []).filter((edge) => edge.kind === "calls").length;
-        if (fanout >= 4)
-            riskFlags.add("high fanout");
-        const complexity = Number(node.metadata?.cyclomaticComplexity ?? 0);
-        if (complexity >= 8)
-            riskFlags.add("high complexity");
-        if (node.metadata?.isBoundaryWrapper)
-            riskFlags.add("boundary wrapper changed");
-    }
-    if (importerFiles.some((file) => directImports.includes(file))) {
-        riskFlags.add("cycle-adjacent file");
-    }
-    const riskFlagList = dedupe(riskFlags);
-    if (downstreamModuleFiles.length > 0) {
-        riskFlagList.push(`${downstreamModuleFiles.length} downstream module file(s)`);
-    }
-    return {
-        filePath: normalizedFile,
-        changedSymbols,
-        directImporters: importerFiles,
-        directCallers: callerFiles,
-        neighborFiles,
-        riskFlags: riskFlagList,
-    };
-}

package/dist/clients/review-graph/revision-drift.js

@@ -1,21 +0,0 @@
-/**
- * Revision-drift evidence for a served review-graph snapshot, and the one
- * wording every consumer renders it with (#1961).
- *
- * A separate module on purpose. `project-report.ts` and `module-report.ts`
- * import the builder DYNAMICALLY, to keep that large module (and its
- * tree-sitter dependencies) off their eager load path. Both still need this
- * caveat's wording synchronously, and two hand-written copies of a warning
- * sentence drift apart. This file imports nothing, so depending on it costs
- * nothing.
- */
-/**
- * The one wording for the drift caveat, so `project_report`'s trust note and
- * `module_report`'s warning cannot say different things about the same fact.
- * Short commit ids only.
- */
-export function formatReviewGraphRevisionDriftNote(drift) {
-    return (`Graph was built at commit ${drift.stampedHead.slice(0, 8)}; HEAD is now ` +
-        `${drift.currentHead.slice(0, 8)}. Results below reflect the earlier ` +
-        "revision — run pilens_rebuild or re-analyze to refresh.");
-}

package/dist/clients/review-graph/service.js

@@ -1,96 +0,0 @@
-import { recordDegradationOnce } from "../degradation-ledger.js";
-import { isAbsoluteFilePath, normalizeMapKey } from "../path-utils.js";
-import { computeImpactCascade as computeImpactCascadeImpl, computeTransitiveImpact as computeTransitiveImpactImpl, } from "./query.js";
-import { buildOrUpdateGraph as buildOrUpdateGraphImpl, } from "./builder.js";
-import { formatImpactCascade as formatImpactCascadeImpl } from "./format.js";
-import { buildModuleGraph } from "./workspace-modules.js";
-const CHANGED_SYMBOLS_PREFIX = "session.reviewGraph.changedSymbols:";
-const ENTITY_SNAPSHOT_PREFIX = "session.reviewGraph.entitySnapshot:";
-export async function buildOrUpdateGraph(cwd, changedFiles, facts, seqHint) {
-    return buildOrUpdateGraphImpl(cwd, changedFiles, facts, seqHint);
-}
-export function computeImpactCascade(graph, changedFile, cwd) {
-    const moduleGraph = cwd ? buildModuleGraph(cwd) : null;
-    return computeImpactCascadeImpl(graph, changedFile, moduleGraph);
-}
-export function formatImpactCascade(result, maxFiles) {
-    return formatImpactCascadeImpl(result, maxFiles);
-}
-/** Transitive (depth-bounded) dependents of a file — see query.computeTransitiveImpact. */
-export function computeTransitiveImpact(graph, seedFile, options) {
-    return computeTransitiveImpactImpl(graph, seedFile, options);
-}
-export function recordEntitySnapshotDiff(facts, filePath, nextSnapshot) {
-    // #2477 round 2 (reviewer F1/F2): folding `cwd` into this key was REVERTED.
-    // The writer (`clients/dispatch/runners/tree-sitter.ts`) passes `ctx.cwd`,
-    // which `createDispatchContext` (`clients/dispatch/dispatcher.ts:324-326`)
-    // sets to the file's NEAREST LANGUAGE-ROOT (`resolveLanguageRootForFile`),
-    // while the reader (`upsertChangedSymbols`, `clients/review-graph/builder.ts`,
-    // reached via `computeCascadeForFile` → `buildOrUpdateGraph`) keys off the
-    // WORKSPACE cwd. In a monorepo/cargo-workspace/go-module layout those two
-    // cwd values diverge, so a folded `(cwd, path)` key the builder reader can
-    // never hit zeroed `graphChangedSymbolCount` on every build — reproduced:
-    // master returns `["alpha","beta"]`, the folded-key version returns `[]`
-    // — and made the cascade over-fan to every symbol (`query.ts:230-238`
-    // treats an empty `changedSymbols` as "no narrowing").
-    //
-    // The #2477 cross-project collision this was meant to close cannot reach
-    // this function in production: the sole writer always passes `ctx.filePath`,
-    // which `createDispatchContext` sets via `resolveRunnerPath` to an
-    // ALWAYS-ABSOLUTE path (the #2016 invariant, `dispatcher.ts:320,327,346`).
-    // A relative `filePath` here can only happen through a caller regression.
-    // Enforce that instead of re-keying: reject a non-absolute `filePath` with
-    // a visible, bounded ledger record (never silently, per AGENTS.md) and
-    // skip the diff rather than compute one under a key the real reader could
-    // never reach anyway. `recordDegradationOnce` (not a thrown error) is used
-    // because the sole call site's surrounding try/catch
-    // (`tree-sitter.ts` — "entity snapshot / blast-radius enrichment is
-    // best-effort") is a BARE, UNLOGGED catch: a thrown error there vanishes
-    // with no trace, which is strictly worse than a ledger record.
-    if (!isAbsoluteFilePath(filePath)) {
-        recordDegradationOnce({
-            kind: "review-graph-non-absolute-entity-path",
-            subject: filePath,
-            reason: "recordEntitySnapshotDiff requires an absolute filePath (refs #2477)",
-        });
-        return { added: [], removed: [], modified: [] };
-    }
-    // Normalize once at this boundary, then reuse the folded path for both
-    // per-file facts. An unnormalized write is a key the builder reader can never
-    // hit, and an unnormalized snapshot forks a second empty diff (#2355).
-    const normalizedFilePath = normalizeMapKey(filePath);
-    const snapshotKey = `${ENTITY_SNAPSHOT_PREFIX}${normalizedFilePath}`;
-    const changedSymbolsKey = `${CHANGED_SYMBOLS_PREFIX}${normalizedFilePath}`;
-    const stored = facts.getBoundedSessionFact(snapshotKey);
-    // An evicted snapshot is unknown, not empty. Diffing against an empty Map
-    // puts every entity in `added`, which reads downstream as "the whole file
-    // changed" and schedules a blast-radius run for a file that did not change.
-    // Re-seed the snapshot and report no diff instead (#2282 review F1).
-    if (stored === undefined && facts.wasBoundedSessionFactEvicted(snapshotKey)) {
-        facts.setBoundedSessionFact(snapshotKey, new Map(nextSnapshot));
-        facts.setBoundedSessionFact(changedSymbolsKey, []);
-        return { added: [], removed: [], modified: [] };
-    }
-    const prev = stored ?? new Map();
-    const added = [];
-    const removed = [];
-    const modified = [];
-    for (const [key, value] of nextSnapshot.entries()) {
-        if (!prev.has(key))
-            added.push(key);
-        else if (prev.get(key) !== value)
-            modified.push(key);
-    }
-    for (const key of prev.keys()) {
-        if (!nextSnapshot.has(key))
-            removed.push(key);
-    }
-    const changedSymbols = [
-        ...new Set([...added, ...modified, ...removed]
-            .map((key) => key.split(":")[1])
-            .filter(Boolean)),
-    ];
-    facts.setBoundedSessionFact(snapshotKey, new Map(nextSnapshot));
-    facts.setBoundedSessionFact(changedSymbolsKey, changedSymbols);
-    return { added, removed, modified };
-}

package/dist/clients/review-graph/shared-extraction-ir.js

@@ -1,82 +0,0 @@
-import { createHash } from "node:crypto";
-import { BoundedFifoMap } from "../bounded-cache.js";
-import { normalizeMapKey } from "../path-utils.js";
-/**
- * THE producer/consumer hash contract, in one place (#955 review): scanner
- * publication and builder acceptance must produce byte-identical digests or
- * every lookup silently misses forever. Both sides hash the exact decoded
- * string they parsed.
- */
-export function reviewGraphIrContentHash(content) {
-    return createHash("sha256").update(content).digest("hex");
-}
-// Process-local handoff only. Values are compact extracted data: never source
-// strings, web-tree-sitter trees, or FactStores. Bounds (#955 review — the
-// #886 retention class): a small root bound, a per-root entry cap, and
-// consume-once semantics — an entry is DELETED when the graph accepts it, and
-// the full build clears the root's leftovers when it finishes, so the
-// registry's lifetime is the scan-to-build window, not the process lifetime.
-const MAX_ROOTS = 8;
-const MAX_FILES_PER_ROOT = 20_000;
-// Both levels are FIFO, matching the hand-rolled blocks these replaced: no
-// read on either map refreshed recency before #2442, and the consume-once
-// contract above means a read is normally a DELETE anyway.
-const roots = new BoundedFifoMap(MAX_ROOTS);
-let accepted = 0;
-let rejected = 0;
-function rootKey(cwd) {
-    return normalizeMapKey(cwd);
-}
-export function publishReviewGraphFileIr(cwd, entry) {
-    // Only consumable entries are worth storing: the builder rejects
-    // incomplete entries and has nothing to read without `structural`, so
-    // publishing them would be pure retention — and an incomplete late
-    // publication must never clobber a still-valid entry (#955 review).
-    if (!entry.complete || !entry.structural)
-        return;
-    const key = rootKey(cwd);
-    let files = roots.get(key);
-    if (!files) {
-        files = new BoundedFifoMap(MAX_FILES_PER_ROOT);
-        roots.set(key, files);
-    }
-    const fileKey = normalizeMapKey(entry.filePath);
-    files.delete(fileKey); // republish is a refresh: it becomes the newest
-    files.set(fileKey, { ...entry, filePath: fileKey });
-}
-/**
- * Consume-once: a hash-fresh entry is removed as it is returned. The graph is
- * about to ingest these arrays, so keeping a second registry copy alive would
- * both duplicate the heap and leave a write-through aliasing target (#955
- * review); a later build re-parses or waits for the next scan to republish.
- */
-export function getFreshReviewGraphFileIr(cwd, filePath, contentHash) {
-    const files = roots.get(rootKey(cwd));
-    const fileKey = normalizeMapKey(filePath);
-    const entry = files?.get(fileKey);
-    if (!entry)
-        return undefined;
-    if (entry.contentHash !== contentHash) {
-        // Present but stale — the only honest "rejected" (#955 review: absence
-        // is not rejection; counting it made the stat unusable).
-        rejected++;
-        return undefined;
-    }
-    files?.delete(fileKey);
-    accepted++;
-    return entry;
-}
-/** Build-end/session-reset seam; builds also work when this is never called. */
-export function clearReviewGraphFileIr(cwd) {
-    if (cwd === undefined)
-        roots.clear();
-    else
-        roots.delete(rootKey(cwd));
-}
-export function getReviewGraphIrStats() {
-    return { accepted, rejected };
-}
-export function resetReviewGraphIrStats() {
-    accepted = 0;
-    rejected = 0;
-}

package/dist/clients/review-graph/symbol-id.js

@@ -1,103 +0,0 @@
-/**
- * Collision-safe review-graph symbol-node ID (refs #655 — narrow first slice).
- *
- * The pre-existing scheme (`${file}:${name}`) collapses distinct symbols that
- * share a name into ONE graph node: overloaded functions/methods, same-named
- * methods on different classes, and same-named nested functions all produce
- * the identical ID. That node backs `pilens_module_report`'s `usedBy` and
- * `blastRadius` sections today, so those two genuinely different symbols'
- * caller/reference edges silently merge onto one node.
- *
- * This adds the symbol's declaration KIND and start LINE — enough to give
- * every one of those concrete collision cases a distinct ID, since they are
- * always on different lines.
- *
- * Deliberately scoped DOWN from #655's full proposed shape
- * (`<file>:<qualified-name>:<kind>:<start-line>:<start-column>`):
- *
- * - No qualified ownership (e.g. `ClassName.method`). Full qualified-name
- *   tracking needs an owner-chain (class/namespace) computed uniformly across
- *   every tree-sitter grammar the graph ingests — real work, not needed to
- *   fix the concrete bug. Kind + line already disambiguates every case in
- *   scope without it; #655 leaves qualified ownership as later, broader work.
- * - No start COLUMN. Review-graph symbols for JS/TS come from a DIFFERENT
- *   extractor (`dispatch/facts/function-facts.ts`, keyed off the function-like
- *   node's own start) than module-report's own outline symbols
- *   (`tree-sitter-symbol-extractor.ts`, keyed off the declaration node's
- *   start). The two agree on start LINE for every function-like declaration
- *   but can diverge by a few columns for arrow functions — e.g.
- *   `const foo = () => {}`: function-facts measures from the `(` param list,
- *   the symbol extractor measures from the `foo` identifier. Keying on line
- *   only keeps IDs built by either extractor comparable; every collision case
- *   this slice targets (overloads, sibling-class methods, nested functions)
- *   already sits on a distinct line, so dropping column loses no precision
- *   this bug needs.
- *
- * Known residual gap: an arrow assigned across a line break (`const foo =\n
- * () => {}`) can still put function-facts' start row (the `(`) one line after
- * the symbol extractor's start row (`foo`). Rare in real code and fails SAFE —
- * module-report simply finds no graph node for that one symbol (falls back to
- * its existing "no usedBy data" path) rather than merging it with anything
- * else. Not worth a same-line-normalizing special case for this narrow slice.
- *
- * jsts callers also must not reuse `sym.kind` from module-report's own
- * tree-sitter-symbol-extractor outline unchanged: builder.ts's jsts graph
- * nodes come from a coarser extractor (function-facts.ts) that stamps every
- * function-like declaration — including class methods — as `"function"`,
- * never `"method"`. A jsts lookup must pass `"function"` regardless of the
- * outline's own finer-grained `sym.kind` (see module-report.ts's `toEntry`).
- *
- * ALL graph code that mints or looks up a real (non-placeholder) symbol node
- * ID must go through this helper — see `builder.ts` (mint) and
- * `module-report.ts` (lookup) — so the two independent extraction paths stay
- * in agreement on the ID shape.
- */
-export function buildSymbolId(filePath, name, kind, startLine) {
-    return `${filePath}:${name}:${kind}:${startLine}`;
-}
-/**
- * Structural shape of a kind token in a canonical symbol id: every kind this
- * repo mints — the fixed `buildSymbolId` vocabulary (`function`, `method`,
- * `class`, ...) AND the open-ended LSP-fallback vocabulary from
- * `lspSymbolKindName` (`enum`, `struct`, `type-parameter`, `enum-member`, the
- * `lsp-symbol-<n>` catch-all for unknown LSP `SymbolKind` numbers, ...) —
- * is a lowercase word optionally hyphen-segmented, never containing a colon.
- * Matching this SHAPE (rather than whitelisting specific kind strings) keeps
- * `parseSymbolKey` in agreement with whatever kind vocabulary either minter
- * uses, present or future, without needing a matching update here.
- */
-const KIND_TOKEN_RE = /^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/;
-/**
- * Parse both canonical symbol IDs and the legacy `file:name` compatibility
- * shape. Canonical IDs are recognized from their typed line suffix, so drive
- * letters and colons in POSIX filenames are data rather than separators. A
- * known file hint makes the legacy form lossless too; without it, legacy IDs
- * remain inherently ambiguous and use their historical final separator.
- */
-export function parseSymbolKey(key, knownFilePath) {
-    if (key.startsWith("file:")) {
-        return { filePath: key.slice("file:".length) };
-    }
-    const canonical = /^(.*):([^:]*):([^:]+):(\d+)$/.exec(key);
-    if (canonical && KIND_TOKEN_RE.test(canonical[3])) {
-        return {
-            filePath: canonical[1],
-            symbolName: canonical[2] || undefined,
-            kind: canonical[3],
-            line: Number(canonical[4]),
-        };
-    }
-    if (knownFilePath && key.startsWith(`${knownFilePath}:`)) {
-        return {
-            filePath: knownFilePath,
-            symbolName: key.slice(knownFilePath.length + 1) || undefined,
-        };
-    }
-    const separator = key.lastIndexOf(":");
-    return separator < 0
-        ? { filePath: key }
-        : {
-            filePath: key.slice(0, separator),
-            symbolName: key.slice(separator + 1) || undefined,
-        };
-}