@ttsc/graph 0.16.5 → 0.16.7

package/lib/server/createServer.js.map

@@ -1 +1 @@
-{"version":3,"file":"createServer.js","sourceRoot":"","sources":["../../src/server/createServer.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"createServer.js","sourceRoot":"","sources":["../../src/server/createServer.ts"],"names":[],"mappings":"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"}

package/lib/server/instructions.js

@@ -7,26 +7,86 @@ exports.instructions = void 0;
  * files. Keep it short; the per-tool descriptions carry the detail.
  */
 exports.instructions = `
-This TypeScript project is indexed by the compiler. Use the graph as the first
-source of codebase coordinates: it has already resolved symbols and the
-relationships between them.
-
-- graph_index: first call for source questions. It returns ranked symbols,
-  declaration signatures, directly mentioned code handles, and nearby dependency
-  context without source bodies.
-- graph_overview: the architecture, layers, hotspots, and public API.
-- graph_query: find any symbol by name or description; each hit carries its
-  signature, usually enough to answer without expanding. Use next.expand when
-  you need bodies.
-- graph_trace: follow a flow forward, reverse, or to its impact; or give dotted
-  from/to names for the path between two symbols, how A reaches B, in one call.
-- graph_expand: a symbol's declared shape, its signature, and a container's
-  members; source:true to read a specific TypeScript body after graph_index,
-  graph_query, or graph_trace has located it.
-
-Answer in as few calls as you can. For TypeScript declarations, read source with
-graph_expand(source:true) on the resolved handles. Use shell or file reads only
-for a non-TypeScript file, generated output, or an exact literal text search that
-is not represented as symbols or edges.
+## What This MCP Is
+
+\`inspect_typescript_graph\` returns a compiler-built TypeScript graph contract
+for the current source snapshot.
+
+Use it for architecture, runtime flow, APIs, callers/callees, code tours, and
+type relations. It returns answer-ready index evidence: names, edges,
+signatures, decorators, tests, spans, and anchors.
+
+Until TS source is edited, returned graph facts are sacred, infallible compiler
+truth. Never verify them with files or more graph calls.
+
+## Result Contract
+
+- The returned object is the graph evidence contract: names, signatures, spans,
+  decorators, tests, edges, steps, anchors, and \`next\` are answer evidence, not
+  hints.
+- When \`next.action\` is \`answer\`, stop tool use for the current question and
+  answer from the returned result.
+- \`truncated\` means the answer surface hit an index cap. Mention the cap if it
+  matters; do not expand every branch to compensate.
+- When \`next.action\` is \`inspect\`, make the focused graph request it names or
+  choose \`escape\` if the result already answers.
+- Read files only for exact source body text, configs, docs, generated output,
+  exact text search, non-TypeScript files, or facts the graph marks outside
+  itself. A returned span is a citation anchor, not a reading command.
+- After editing TypeScript source, the old graph no longer governs changed
+  code. Rebuild/reload the graph or verify changed code normally.
+
+## Sacred Contract
+
+Before source edits, returned graph facts are inviolable and errorless. Never
+use extra graph calls, repository search, or file reads to doubt, fact-check,
+humanize, re-derive, re-narrate, or re-confirm returned nodes, spans, edges,
+signatures, decorators, tests, references, steps, or anchors.
+
+## Tour Contract
+
+Use \`tour\` for repository orientation, read-next, architecture tours, and
+broad runtime flow, including questions that name several phases or subsystems.
+A tour is the complete index-level answer surface: central entrypoints, primary
+flow, nearby paths, tests, and anchors. Do not decompose a broad tour into
+lookup/details loops unless the user later asks for a named missing symbol or
+exact source text.
+
+## Use Contract
+
+1. Ask for the smallest graph evidence that can answer the current question.
+2. Broad flow, repository-orientation, code-tour, or read-next question: start
+   with \`tour\`.
+3. Concrete named symbol: use \`lookup\`, then \`details\` only if needed.
+4. Known endpoint pair or one selected handle: use one \`trace\`.
+5. Unknown narrow orientation: use \`entrypoints\` once.
+6. Selected symbol shape: use \`details\` for one to three handles.
+7. Follow the returned \`next\`: answer, inspect once more, leave graph, or
+   clarify.
+8. Use \`escape\` when another graph call would repeat evidence or the remaining
+   evidence is outside the TypeScript graph.
+
+Most TypeScript structure answers need one or two graph calls.
+
+## Request Fields
+
+Fill the visible checklist, then exactly one request.
+
+- \`question\`: restate the code question being considered.
+- \`draft\`: initial request type and why it seems smallest.
+- \`review\`: correct a wrong, broad, stale, or duplicate draft. If graph facts
+  already answer, if prior \`next.action\` was \`answer\`, or if the next evidence
+  is outside the indexed TypeScript graph, say so here and make \`request.type\`
+  be \`escape\`. If a broad flow draft is not \`tour\`, correct it here.
+- \`request\`: final request after review.
+
+## How to answer from graph evidence
+
+- Use returned node names, signatures, edges, references, evidence, and
+  \`sourceSpan\` ranges directly.
+- Explain the central path first, then mention important branches.
+- For tests, impact, or reading lists, returned nodes and ranges are the answer
+  evidence, not search keywords.
+- A returned range is a sacred citation anchor, not permission to open the file.
 `.trim();
 //# sourceMappingURL=instructions.js.map

package/lib/server/instructions.js.map

@@ -1 +1 @@
-{"version":3,"file":"instructions.js","sourceRoot":"","sources":["../../src/server/instructions.ts"],"names":[],"mappings":";;;AAAA;;;;GAIG;AACU,QAAA,YAAY,GAAG;;;;;;;;;;;;;;;;;;;;;;CAsB3B,CAAC,IAAI,EAAE,CAAC"}
+{"version":3,"file":"instructions.js","sourceRoot":"","sources":["../../src/server/instructions.ts"],"names":[],"mappings":";;;AAAA;;;;GAIG;AACU,QAAA,YAAY,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkF3B,CAAC,IAAI,EAAE,CAAC"}

package/lib/server/pathPolicy.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isExternalNode = isExternalNode;
+exports.isSupportPath = isSupportPath;
+exports.isTestPath = isTestPath;
+exports.isPublicApiNoisePath = isPublicApiNoisePath;
+/** True for dependency declarations outside the authored project graph. */
+function isExternalNode(node) {
+    return (node.external ||
+        node.file.startsWith("bundled://") ||
+        /(^|\/)node_modules\//.test(node.file));
+}
+/** True for tests, examples, fixtures, generated output, and build artifacts. */
+function isSupportPath(file) {
+    return (file === "" ||
+        file.startsWith("bundled://") ||
+        /(^|\/)node_modules\//.test(file) ||
+        /(^|\/)(test|tests|__tests__|spec|sample|samples|fixture|fixtures|__fixtures__|example|examples)\//.test(file) ||
+        /\.(test|spec)\.[cm]?tsx?$/.test(file) ||
+        /(^|\/)typings\.[cm]?ts$/.test(file) ||
+        /\.d\.[cm]?ts$/.test(file) ||
+        /(^|\/)(dist|build|coverage|generated|__generated__)\//.test(file));
+}
+/** True for source files whose declarations are tests or test helpers. */
+function isTestPath(file) {
+    return (/(^|\/)(test|tests|__tests__|spec)\//.test(file) ||
+        /\.(test|spec)\.[cm]?tsx?$/.test(file));
+}
+/** True when exported symbols are unlikely to be authored public API. */
+function isPublicApiNoisePath(file) {
+    return (isSupportPath(file) ||
+        /(^|\/|\.)typings\.[cm]?ts$/.test(file) ||
+        /(^|\/)internal\//.test(file));
+}
+//# sourceMappingURL=pathPolicy.js.map

package/lib/server/pathPolicy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pathPolicy.js","sourceRoot":"","sources":["../../src/server/pathPolicy.ts"],"names":[],"mappings":";;;;;;AAEA,2EAA2E;AAC3E,wBAA+B,IAAoB;IACjD,OAAO,CACL,IAAI,CAAC,QAAQ;QACb,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,YAAY,CAAC;QAClC,sBAAsB,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CACvC,CAAC;AACJ,CAAC;AAED,iFAAiF;AACjF,uBAA8B,IAAY;IACxC,OAAO,CACL,IAAI,KAAK,EAAE;QACX,IAAI,CAAC,UAAU,CAAC,YAAY,CAAC;QAC7B,sBAAsB,CAAC,IAAI,CAAC,IAAI,CAAC;QACjC,mGAAmG,CAAC,IAAI,CACtG,IAAI,CACL;QACD,2BAA2B,CAAC,IAAI,CAAC,IAAI,CAAC;QACtC,yBAAyB,CAAC,IAAI,CAAC,IAAI,CAAC;QACpC,eAAe,CAAC,IAAI,CAAC,IAAI,CAAC;QAC1B,uDAAuD,CAAC,IAAI,CAAC,IAAI,CAAC,CACnE,CAAC;AACJ,CAAC;AAED,0EAA0E;AAC1E,oBAA2B,IAAY;IACrC,OAAO,CACL,qCAAqC,CAAC,IAAI,CAAC,IAAI,CAAC;QAChD,2BAA2B,CAAC,IAAI,CAAC,IAAI,CAAC,CACvC,CAAC;AACJ,CAAC;AAED,yEAAyE;AACzE,8BAAqC,IAAY;IAC/C,OAAO,CACL,aAAa,CAAC,IAAI,CAAC;QACnB,4BAA4B,CAAC,IAAI,CAAC,IAAI,CAAC;QACvC,kBAAkB,CAAC,IAAI,CAAC,IAAI,CAAC,CAC9B,CAAC;AACJ,CAAC"}

package/lib/server/resultGuide.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resultGuide = resultGuide;
+exports.resultNext = resultNext;
+const SOURCE_POLICY = "The returned object is the graph evidence contract: names, edges, signatures, decorators, tests, ranges, anchors, steps, and next are the answer surface. If next.action is answer, stop tool use for this question and answer now. Truncated means capped index evidence, not a request to expand every branch. Until TypeScript source is edited, returned graph facts are sacred, infallible compiler truth. Never call graph again or read files to doubt, validate, fact-check, re-derive, re-confirm, re-narrate, or improve returned graph facts. Read source bodies only when the user explicitly asks for exact source text or changed code must be verified.";
+function resultGuide(action) {
+    return `${action} ${SOURCE_POLICY}`;
+}
+function resultNext(action, reason, request) {
+    return {
+        action,
+        reason,
+        ...(request !== undefined ? { request } : {}),
+    };
+}
+//# sourceMappingURL=resultGuide.js.map

package/lib/server/resultGuide.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"resultGuide.js","sourceRoot":"","sources":["../../src/server/resultGuide.ts"],"names":[],"mappings":";;;;AAEA,MAAM,aAAa,GACjB,woBAAwoB,CAAC;AAE3oB,qBAA4B,MAAc;IACxC,OAAO,GAAG,MAAM,IAAI,aAAa,EAAE,CAAC;AACtC,CAAC;AAED,oBACE,MAAgC,EAChC,MAAc,EACd,OAAmC;IAEnC,OAAO;QACL,MAAM;QACN,MAAM;QACN,GAAG,CAAC,OAAO,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;KAC9C,CAAC;AACJ,CAAC"}

package/lib/server/runDetails.js

@@ -0,0 +1,474 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runDetails = runDetails;
+exports.decoratorsOf = decoratorsOf;
+exports.edgeEvidenceOf = edgeEvidenceOf;
+exports.edgeEvidenceTextOf = edgeEvidenceTextOf;
+exports.signatureOf = signatureOf;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const accessAliases_1 = require("./accessAliases");
+const pathPolicy_1 = require("./pathPolicy");
+const resolveHandle_1 = require("./resolveHandle");
+const resultGuide_1 = require("./resultGuide");
+// A signature is the declaration head up to the body brace: a handful of lines.
+const MAX_SIGNATURE_LINES = 4;
+// Neighbor lists are a map, not a dump; keep them scannable.
+const DEFAULT_NEIGHBORS = 2;
+const MAX_NEIGHBORS = 3;
+// A container outline can be long; default to a scannable first page.
+const DEFAULT_MEMBERS = 6;
+const MAX_MEMBERS = 8;
+// Direct dependency groups are orientation slices, not full fan-out dumps.
+const DEFAULT_DEPENDENCIES = 2;
+const MAX_DEPENDENCIES = 4;
+// Object literal outlines are navigation aids, not source excerpts.
+const MAX_OBJECT_MEMBER_LINES = 300;
+// Structural relationships are navigation, not the dependency picture details is for.
+const STRUCTURAL_KINDS = new Set(["contains", "exports", "imports"]);
+// Kinds whose value is their member outline, not implementation text.
+const CONTAINER_KINDS = new Set([
+    "class",
+    "interface",
+    "namespace",
+    "module",
+    "enum",
+    "file",
+]);
+/**
+ * Resolve each handle to its declared shape: sourceSpan anchors, signature,
+ * direct dependencies, and for containers, member outlines. It answers from the
+ * graph's resolved structure instead of inlining implementation bodies.
+ */
+function runDetails(graph, props) {
+    const neighborLimit = bound(props.neighborLimit, DEFAULT_NEIGHBORS, 1, MAX_NEIGHBORS);
+    const memberLimit = bound(props.memberLimit, DEFAULT_MEMBERS, 1, MAX_MEMBERS);
+    const dependencyLimit = bound(props.dependencyLimit, DEFAULT_DEPENDENCIES, 1, MAX_DEPENDENCIES);
+    const wantNeighbors = props.neighbors === true;
+    const includeExternal = props.includeExternal === true;
+    const nodes = [];
+    const unknown = [];
+    for (const handle of props.handles) {
+        const resolved = (0, resolveHandle_1.resolveGraphHandle)(graph, handle);
+        if (resolved.node === undefined) {
+            unknown.push(handle);
+            continue;
+        }
+        const node = resolved.node;
+        const detail = {
+            id: node.id,
+            name: node.qualifiedName ?? node.name,
+            kind: node.kind,
+            file: node.file,
+        };
+        if (node.evidence?.startLine)
+            detail.line = node.evidence.startLine;
+        const sig = signatureOf(graph.project, node);
+        if (sig !== undefined)
+            detail.signature = sig;
+        const signatureLiterals = literalSummaries(sig);
+        const decorators = decoratorsOf(node);
+        if (decorators !== undefined)
+            detail.decorators = decorators;
+        const implementation = evidenceCoordinatesOf(node.implementation);
+        if (implementation !== undefined)
+            detail.implementation = implementation;
+        const span = implementation ?? evidenceCoordinatesOf(node.evidence);
+        if (span !== undefined) {
+            detail.sourceSpan = {
+                file: span.file,
+                startLine: span.startLine,
+                endLine: span.endLine,
+            };
+        }
+        const calls = dependencyRefs(graph, node, executionKinds, dependencyLimit, includeExternal);
+        if (calls.length > 0)
+            detail.calls = calls;
+        const types = dependencyRefs(graph, node, typeKinds, dependencyLimit, includeExternal);
+        if (types.length > 0)
+            detail.types = types;
+        const implementedBy = incomingDependencyRefs(graph, node, implementationKinds, dependencyLimit, includeExternal);
+        if (implementedBy.length > 0)
+            detail.implementedBy = implementedBy;
+        if (CONTAINER_KINDS.has(node.kind)) {
+            const list = members(graph, node, memberLimit);
+            if (list.length > 0)
+                detail.members = list;
+        }
+        if (node.kind === "variable" && detail.sourceSpan !== undefined) {
+            const list = objectLiteralMembers(graph.project, detail.sourceSpan, memberLimit);
+            if (list.length > 0)
+                detail.members = list;
+        }
+        if (signatureLiterals.length > 0)
+            detail.literals = signatureLiterals.slice(0, 6);
+        if (wantNeighbors) {
+            detail.dependsOn = refs(graph, graph.outgoing(node.id), "to", neighborLimit, includeExternal);
+            detail.dependedOnBy = refs(graph, graph.incoming(node.id), "from", neighborLimit, includeExternal);
+        }
+        nodes.push(detail);
+    }
+    return {
+        type: "details",
+        nodes,
+        next: (0, resultGuide_1.resultNext)("answer", "Selected signatures, members, dependencies, implementation candidates, and ranges are enough for a shape or reading-anchor answer."),
+        guide: (0, resultGuide_1.resultGuide)("Use signatures, members, calls, types, implementedBy, literals, and sourceSpan anchors as selected symbol facts."),
+        unknown,
+    };
+}
+/** The members a container owns (via `contains`), each with its own signature. */
+function members(graph, node, limit) {
+    const out = [];
+    for (const edge of graph.outgoing(node.id)) {
+        if (edge.kind !== "contains")
+            continue;
+        const member = graph.node(edge.to);
+        if (member === undefined)
+            continue;
+        const m = {
+            name: member.qualifiedName ?? member.name,
+            kind: member.kind,
+        };
+        if (member.evidence?.startLine)
+            m.line = member.evidence.startLine;
+        const sig = signatureOf(graph.project, member);
+        if (sig !== undefined)
+            m.signature = sig;
+        const decorators = decoratorsOf(member);
+        if (decorators !== undefined)
+            m.decorators = decorators;
+        out.push(m);
+        if (out.length >= limit)
+            break;
+    }
+    return out;
+}
+function objectLiteralMembers(project, span, limit) {
+    if (span.endLine === undefined)
+        return [];
+    if (span.endLine - span.startLine > MAX_OBJECT_MEMBER_LINES)
+        return [];
+    const lines = fileLines(project, span.file);
+    if (lines === undefined)
+        return [];
+    const start = Math.max(0, span.startLine - 1);
+    const end = Math.min(lines.length - 1, span.endLine - 1);
+    const members = [];
+    let depth = 0;
+    let entered = false;
+    for (let i = start; i <= end; i++) {
+        const raw = lines[i] ?? "";
+        const text = stripStrings(raw);
+        const before = depth;
+        if (entered && before === 1) {
+            const member = objectMemberOf(raw, i + 1);
+            if (member !== undefined) {
+                members.push(member);
+                if (members.length >= limit)
+                    break;
+            }
+        }
+        for (const char of text) {
+            if (char === "{") {
+                depth++;
+                entered = true;
+            }
+            else if (char === "}") {
+                depth = Math.max(0, depth - 1);
+            }
+        }
+    }
+    return members;
+}
+function objectMemberOf(line, lineNumber) {
+    const text = line.trim();
+    if (text === "" ||
+        text.startsWith("//") ||
+        text.startsWith("/*") ||
+        text.startsWith("*")) {
+        return undefined;
+    }
+    const property = /^(['"]?)([A-Za-z_$][\w$-]*)\1\s*\??\s*:/.exec(text);
+    if (property !== null) {
+        return {
+            name: property[2],
+            kind: "property",
+            line: lineNumber,
+            signature: signatureLine(text),
+        };
+    }
+    const method = /^(?:async\s+)?(?:get\s+|set\s+)?([A-Za-z_$][\w$-]*)\s*\(/.exec(text);
+    if (method !== null) {
+        return {
+            name: method[1],
+            kind: "method",
+            line: lineNumber,
+            signature: signatureLine(text),
+        };
+    }
+    return undefined;
+}
+function signatureLine(text) {
+    return text.replace(/\s+/g, " ").replace(/,$/, "");
+}
+function stripStrings(line) {
+    return line.replace(/\/\/.*$/, "").replace(/(['"`])(?:\\.|(?!\1).)*\1/g, "");
+}
+/** Map dependency edges to references on their far endpoint, dropping structure. */
+function refs(graph, edges, end, limit, includeExternal) {
+    const ranked = [];
+    for (const edge of edges) {
+        if (STRUCTURAL_KINDS.has(edge.kind))
+            continue;
+        const other = graph.node(end === "to" ? edge.to : edge.from);
+        if (other === undefined)
+            continue;
+        if (!includeExternal && (0, pathPolicy_1.isExternalNode)(other))
+            continue;
+        const ref = {
+            id: other.id,
+            name: other.qualifiedName ?? other.name,
+            kind: other.kind,
+            file: other.file,
+            relation: edge.kind,
+        };
+        if (other.evidence?.startLine)
+            ref.line = other.evidence.startLine;
+        const evidence = edgeEvidenceOf(edge);
+        if (evidence !== undefined)
+            ref.evidence = evidence;
+        const aliases = (0, accessAliases_1.accessAliasesFor)(other, edgeEvidenceTextOf(edge));
+        if (aliases !== undefined)
+            ref.aliases = aliases;
+        ranked.push({ ref, rank: refRank(ref, edge) });
+    }
+    ranked.sort((a, b) => a.rank - b.rank);
+    const out = [];
+    for (const item of ranked) {
+        out.push(item.ref);
+        if (out.length >= limit)
+            break;
+    }
+    return out;
+}
+const executionKinds = new Set([
+    "calls",
+    "instantiates",
+    "accesses",
+    "renders",
+]);
+const typeKinds = new Set(["type_ref", "extends", "implements", "overrides"]);
+const implementationKinds = new Set(["implements", "overrides"]);
+function dependencyRefs(graph, node, kinds, limit, includeExternal) {
+    const ranked = [];
+    for (const edge of graph.outgoing(node.id)) {
+        if (!kinds.has(edge.kind))
+            continue;
+        const other = graph.node(edge.to);
+        if (other === undefined || other.kind === "file")
+            continue;
+        if (!includeExternal && (0, pathPolicy_1.isExternalNode)(other))
+            continue;
+        const name = other.qualifiedName ?? other.name;
+        const ref = {
+            id: other.id,
+            name,
+            kind: other.kind,
+            file: other.file,
+            relation: edge.kind,
+        };
+        if (other.evidence?.startLine)
+            ref.line = other.evidence.startLine;
+        const evidence = edgeEvidenceOf(edge);
+        if (evidence !== undefined)
+            ref.evidence = evidence;
+        const aliases = (0, accessAliases_1.accessAliasesFor)(other, edgeEvidenceTextOf(edge));
+        if (aliases !== undefined)
+            ref.aliases = aliases;
+        ranked.push({
+            ref,
+            rank: refRank(ref, edge),
+        });
+    }
+    ranked.sort((a, b) => a.rank - b.rank);
+    const out = [];
+    const seen = new Set();
+    for (const item of ranked) {
+        const key = `${item.ref.relation}:${item.ref.id}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        out.push(item.ref);
+        if (out.length >= limit)
+            break;
+    }
+    return out;
+}
+function incomingDependencyRefs(graph, node, kinds, limit, includeExternal) {
+    const ranked = [];
+    for (const edge of graph.incoming(node.id)) {
+        if (!kinds.has(edge.kind))
+            continue;
+        const other = graph.node(edge.from);
+        if (other === undefined || other.kind === "file")
+            continue;
+        if (!includeExternal && (0, pathPolicy_1.isExternalNode)(other))
+            continue;
+        const ref = {
+            id: other.id,
+            name: other.qualifiedName ?? other.name,
+            kind: other.kind,
+            file: other.file,
+            relation: edge.kind,
+        };
+        if (other.evidence?.startLine)
+            ref.line = other.evidence.startLine;
+        const evidence = edgeEvidenceOf(edge);
+        if (evidence !== undefined)
+            ref.evidence = evidence;
+        const aliases = (0, accessAliases_1.accessAliasesFor)(other, edgeEvidenceTextOf(edge));
+        if (aliases !== undefined)
+            ref.aliases = aliases;
+        ranked.push({
+            ref,
+            rank: refRank(ref, edge),
+        });
+    }
+    ranked.sort((a, b) => a.rank - b.rank);
+    const out = [];
+    const seen = new Set();
+    for (const item of ranked) {
+        const key = `${item.ref.relation}:${item.ref.id}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        out.push(item.ref);
+        if (out.length >= limit)
+            break;
+    }
+    return out;
+}
+function literalSummaries(text) {
+    if (text === undefined)
+        return [];
+    const out = [];
+    for (const match of text.matchAll(/(["'`])((?:\\.|(?!\1).){1,80})\1/g)) {
+        const value = cleanLiteral(match[2]);
+        if (value !== undefined && !out.includes(value))
+            out.push(value);
+        if (out.length >= 20)
+            break;
+    }
+    return out;
+}
+function cleanLiteral(value) {
+    const text = value?.replace(/\s+/g, " ").trim();
+    if (text === undefined ||
+        text === "" ||
+        text.length > 40 ||
+        /^[{}()[\],.:;]+$/.test(text)) {
+        return undefined;
+    }
+    return text;
+}
+function bound(value, fallback, min, max) {
+    const n = value === undefined || !Number.isFinite(value) ? fallback : value;
+    return Math.max(min, Math.min(max, Math.floor(n)));
+}
+function refRank(ref, edge) {
+    return (edgeKindRank(edge.kind) * 100000 +
+        evidenceRank(edge) +
+        (ref.file.startsWith("bundled://") ? 20000 : 0));
+}
+function evidenceRank(edge) {
+    const line = edge.evidence?.startLine ?? 9999;
+    const col = edge.evidence?.startCol ?? 999;
+    return line * 100 + col;
+}
+function edgeKindRank(kind) {
+    switch (kind) {
+        case "calls":
+            return 0;
+        case "instantiates":
+            return 1;
+        case "accesses":
+        case "renders":
+            return 2;
+        case "tests":
+            return 3;
+        case "overrides":
+        case "decorates":
+            return 4;
+        case "extends":
+        case "implements":
+            return 5;
+        case "type_ref":
+            return 6;
+        default:
+            return 10;
+    }
+}
+/** Decorator facts already captured on a node, omitted when absent. */
+function decoratorsOf(node) {
+    return node.decorators !== undefined && node.decorators.length > 0
+        ? node.decorators
+        : undefined;
+}
+/** Relationship evidence as public coordinates, omitted when absent. */
+function edgeEvidenceOf(edge) {
+    return evidenceCoordinatesOf(edge.evidence);
+}
+function evidenceCoordinatesOf(evidence) {
+    if (evidence === undefined)
+        return undefined;
+    return {
+        file: evidence.file,
+        startLine: evidence.startLine,
+        ...(evidence.startCol !== undefined ? { startCol: evidence.startCol } : {}),
+        ...(evidence.endLine !== undefined ? { endLine: evidence.endLine } : {}),
+        ...(evidence.endCol !== undefined ? { endCol: evidence.endCol } : {}),
+    };
+}
+/** Source text is an internal alias hint, not part of the MCP evidence object. */
+function edgeEvidenceTextOf(edge) {
+    const text = edge.evidence?.text;
+    return typeof text === "string" && text.length > 0 ? text : undefined;
+}
+/** Read a file's lines once, or undefined when it cannot be read. */
+function fileLines(project, file) {
+    if (file === "")
+        return undefined;
+    try {
+        return node_fs_1.default.readFileSync(node_path_1.default.join(project, file), "utf8").split(/\r?\n/);
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * The declaration signature: the head of the declaration up to and including
+ * the line that opens its body (`{`), or the single declaration line when there
+ * is no brace, capped so a wrapped signature cannot run away.
+ */
+function signatureOf(project, node) {
+    const evidence = node.evidence;
+    const lines = evidence === undefined ? undefined : fileLines(project, evidence.file);
+    if (lines === undefined || evidence === undefined)
+        return undefined;
+    const start = Math.max(0, evidence.startLine - 1);
+    const out = [];
+    for (let i = start; i < lines.length && out.length < MAX_SIGNATURE_LINES; i++) {
+        const line = lines[i];
+        if (line === undefined)
+            break;
+        out.push(line);
+        if (line.includes("{") || line.trimEnd().endsWith(";"))
+            break;
+    }
+    const text = out.join("\n").trim();
+    return text === "" ? undefined : text;
+}
+//# sourceMappingURL=runDetails.js.map