weavatrix 0.3.14 → 1.1.0

package/src/mcp/tools-impact-precision.mjs

@@ -1,89 +0,0 @@
-import {isStructuralRelation} from '../graph/relations.js'
-import {querySymbolsPrecision} from '../precision/symbol-query.js'
-
-export function graphWithExactDirectReferences(g, targetId, overlay) {
-    const exact = (overlay?.links || []).filter((link) => String(link?.target || '') === targetId
-        && link.provenance === 'EXACT_LSP')
-    const provenEmpty = overlay?.state === 'COMPLETE'
-        && (overlay?.noReferenceSymbols || []).some((id) => String(id) === targetId)
-    if (overlay?.state !== 'COMPLETE' || (!exact.length && !provenEmpty)) return null
-    const inn = new Map(g.inn)
-    const structural = (g.inn.get(targetId) || []).filter((edge) => isStructuralRelation(edge.relation))
-    inn.set(targetId, [...structural, ...exact.map((link) => ({
-        id: String(link.source),
-        relation: link.relation || 'references',
-        provenance: 'EXACT_LSP',
-        ...(link.typeOnly === true ? {typeOnly: true} : {}),
-        ...(link.compileOnly === true ? {compileOnly: true} : {}),
-    }))])
-    return {...g, inn}
-}
-
-export function refineChangeImpact(g, args, ctx, baseline, computeImpact) {
-    const requested = ['auto', 'graph', 'lsp'].includes(args?.precision) ? args.precision : 'auto'
-    if (requested === 'graph' || !baseline?.result?.seeds?.ids || !ctx?.repoRoot || !ctx?.graphPath
-        || (requested === 'auto' && g.graphPrecisionMode === 'off')) return baseline
-    const targets = baseline.result.seeds.ids.filter((id) => {
-        const node = g.byId.get(String(id))
-        return node?.selection_start && /\.(?:[cm]?[jt]sx?)$/i.test(String(node.source_file || ''))
-    }).slice(0, 16)
-    if (!targets.length) return baseline
-    return (async () => {
-        try {
-            const precision = await querySymbolsPrecision({
-                repoRoot: ctx.repoRoot,
-                graphPath: ctx.graphPath,
-                targetIds: targets,
-                maxReferences: Math.max(100, Math.min(16_384, Number(args.max_references) || 5_000)),
-                timeoutMs: Math.max(1_000, Math.min(60_000, Number(args.timeout_ms) || 45_000)),
-                clientFactory: ctx.precisionClientFactory,
-            })
-            let exactGraph = g
-            const verified = []
-            for (const target of targets) {
-                const next = graphWithExactDirectReferences(exactGraph, String(target), precision.overlay)
-                if (!next) continue
-                exactGraph = next
-                verified.push(String(target))
-            }
-            const value = verified.length ? computeImpact(exactGraph, args, ctx) : baseline
-            const allVerified = verified.length === targets.length
-            const status = allVerified ? 'DIRECT_EXACT_TRANSITIVE_GRAPH' : 'PARTIAL'
-            value.text = [
-                value.text.split('\n')[0],
-                `Semantic precision: ${status}; EXACT_LSP verified direct references for ${verified.length}/${targets.length} changed JavaScript/TypeScript symbol(s). Transitive hops remain graph-backed.`,
-                ...value.text.split('\n').slice(1),
-            ].join('\n')
-            value.result.semanticPrecision = {
-                status,
-                requestedTargets: targets,
-                verifiedTargets: verified,
-                exactDirectEdges: (precision.overlay?.links || []).filter((link) => verified.includes(String(link?.target || ''))).length,
-                transitiveEvidence: 'GRAPH',
-                provider: precision.overlay?.engines?.[0]?.provider || null,
-                elapsedMs: precision.elapsedMs,
-            }
-            if (!allVerified) value.warnings.push({
-                code: 'CHANGE_IMPACT_PRECISION_PARTIAL',
-                message: precision.overlay?.reason || 'Not every changed symbol had complete exact direct-reference evidence.',
-            })
-            return value
-        } catch (error) {
-            const reason = error?.message || 'batch point query failed'
-            baseline.result.semanticPrecision = {
-                status: 'UNAVAILABLE', requestedTargets: targets, verifiedTargets: [],
-                exactDirectEdges: 0, transitiveEvidence: 'GRAPH', reason,
-            }
-            baseline.warnings.push({
-                code: 'CHANGE_IMPACT_PRECISION_UNAVAILABLE',
-                message: `Exact changed-symbol references were unavailable; graph evidence was retained (${reason}).`,
-            })
-            baseline.text = [
-                baseline.text.split('\n')[0],
-                `Semantic precision: UNAVAILABLE; graph evidence retained (${reason}).`,
-                ...baseline.text.split('\n').slice(1),
-            ].join('\n')
-            return baseline
-        }
-    })()
-}

package/src/mcp/tools-impact.mjs

@@ -1,169 +0,0 @@
-// Impact tools: transitive blast radius of one node (get_dependents), the structural diff of the
-// last rebuild (graph_diff), and the blast radius of the current change set (change_impact).
-// Hot-reloadable (re-imported by catalog.mjs on change).
-import {readFileSync} from 'node:fs'
-import {
-    isSymbol, degreeOf, labelOf, resolveNodeInfo, ambiguityNote,
-    rawGraph, prevGraphPathFor, edgeEndpoint, diffGraphs, formatGraphDiff,
-} from './graph-context.mjs'
-import {querySymbolPrecision} from '../precision/symbol-query.js'
-import {graphWithExactDirectReferences, refineChangeImpact} from './tools-impact-precision.mjs'
-import {reverseReach} from './graph/reverse-reach.mjs'
-import {tChangeImpactV2} from './tools-impact-change.mjs'
-import {buildGraphAtGitRef} from '../analysis/git-ref-graph.js'
-
-const impactKind = (entry) => {
-    if (entry?.runtimeDepth != null) {
-        return entry.compileDepth != null ? `runtime + compile-time(d${entry.compileDepth})` : 'runtime'
-    }
-    return 'compile-time'
-}
-
-// Transitive blast-radius: who is affected if this node changes. Walks REVERSE dependency edges
-// (calls/imports/inherits — not structural `contains`) out to `depth`. For a symbol, also seeds its
-// containing file, because importers depend on the file rather than the individual symbol.
-function getDependentsFromGraph(g, {label, depth = 3, max_nodes = 40, include_container_importers = false} = {}, precisionNote = null) {
-    const info = resolveNodeInfo(g, label)
-    const n = info.node
-    if (!n) return `No node found matching "${label}".`
-    const note = ambiguityNote(label, info)
-    const maxDepth = Math.max(1, Math.min(6, Number(depth) || 3))
-    const cap = Math.max(5, Math.min(120, Number(max_nodes) || 40))
-    const id = String(n.id)
-    const seeds = new Set([id])
-    let containingFile = null
-    if (include_container_importers === true && isSymbol(id)) {
-        const container = (g.inn.get(id) || []).find((e) => e.relation === 'contains')
-        if (container) {
-            containingFile = String(container.id)
-            seeds.add(containingFile)
-        }
-    }
-    const reached = reverseReach(g, seeds, maxDepth)
-    const ranked = [...reached.entries()]
-        .filter(([nid]) => !seeds.has(nid))
-        .map(([nid, entry]) => ({id: nid, d: entry.depth, entry, deg: degreeOf(g, nid)}))
-        .sort((a, b) => a.d - b.d || Number(a.entry.compileOnly) - Number(b.entry.compileOnly) || b.deg - a.deg)
-    if (!ranked.length) return [note, precisionNote, `No dependents found for ${n.label ?? id} within depth ${maxDepth} — nothing in the graph calls, imports, or inherits it.`].filter(Boolean).join('\n')
-    const shown = ranked.slice(0, cap)
-    const runtimeCount = ranked.filter((entry) => !entry.entry.compileOnly).length
-    const compileCount = ranked.length - runtimeCount
-    return [
-        note,
-        precisionNote,
-        `Dependents of ${n.label ?? id} (reverse calls/imports/inherits, depth ≤${maxDepth}): ${ranked.length} found (${runtimeCount} runtime, ${compileCount} compile-time-only), showing ${shown.length} by proximity + connectivity.`,
-        containingFile ? `Includes importers of its containing file ${labelOf(g, containingFile)} by explicit request.` : null,
-        ...shown.map((r) => `  [d${r.d} ${impactKind(r.entry)}] ${r.entry.relation || 'rel'} [${r.entry.provenance || 'UNKNOWN'}]  ${labelOf(g, r.id)}  (deg ${r.deg})  [${r.id}]`),
-    ].filter(Boolean).join('\n')
-}
-
-export function tGetDependents(g, args = {}, ctx = {}) {
-    const info = resolveNodeInfo(g, args.label)
-    const id = String(info.node?.id || '')
-    const requested = ['auto', 'graph', 'lsp'].includes(args.precision) ? args.precision : 'auto'
-    const canQuery = isSymbol(id) && ctx.repoRoot && ctx.graphPath
-        && (requested === 'lsp' || (requested === 'auto' && g.graphPrecisionMode !== 'off'))
-    if (!canQuery) {
-        const note = isSymbol(id) && requested !== 'graph'
-            ? 'Semantic precision: graph-only; an exact point query was unavailable or disabled.' : null
-        return getDependentsFromGraph(g, args, note)
-    }
-    return (async () => {
-        try {
-            const result = await querySymbolPrecision({
-                repoRoot: ctx.repoRoot,
-                graphPath: ctx.graphPath,
-                targetId: id,
-                maxReferences: Math.max(100, Math.min(5_000, Number(args.max_references) || 1_000)),
-                timeoutMs: Math.max(1_000, Math.min(60_000, Number(args.timeout_ms) || 30_000)),
-                clientFactory: ctx.precisionClientFactory,
-            })
-            const exactGraph = graphWithExactDirectReferences(g, id, result.overlay)
-            if (exactGraph) {
-                const count = (result.overlay.links || []).filter((link) => String(link?.target || '') === id).length
-                return getDependentsFromGraph(
-                    exactGraph,
-                    args,
-                    `Semantic precision: EXACT_LSP point query${result.cached ? ' (cache hit)' : ''}; ${count} classified direct reference edge(s).`,
-                )
-            }
-            // Never echo COMPLETE here ('COMPLETE; exact absence was not proven' is a contradiction),
-            // but keep NONE/UNAVAILABLE truthful — PARTIAL implies probing actually began.
-            const fallbackState = result.overlay?.state === 'NONE' ? 'NONE'
-                : result.overlay?.state === 'UNAVAILABLE' ? 'UNAVAILABLE' : 'PARTIAL'
-            return getDependentsFromGraph(
-                g,
-                args,
-                fallbackState === 'NONE'
-                    ? `Semantic precision: NONE; exact references are not available for this language/target, so graph edges are retained (${result.overlay?.reason || 'no eligible JavaScript/TypeScript semantic targets'}).`
-                    : fallbackState === 'UNAVAILABLE'
-                        ? `Semantic precision: UNAVAILABLE; graph evidence retained (${result.overlay?.reason || 'semantic point query unavailable'}).`
-                        : `Semantic precision: PARTIAL; exact absence was not proven, so graph edges are retained (${result.overlay?.reason || 'incomplete project coverage'}).`,
-            )
-        } catch (error) {
-            return getDependentsFromGraph(
-                g,
-                args,
-                `Semantic precision: UNAVAILABLE; graph evidence retained (${error?.message || 'point query failed'}).`,
-            )
-        }
-    })()
-}
-
-// Re-query the last rebuild's before/after pair (graph.prev.json vs graph.json), optionally scoped.
-export async function tGraphDiff(g, args, ctx) {
-    const current = rawGraph(ctx)
-    const currentMode = ['full', 'no-tests', 'tests-only'].includes(current?.graphBuildMode)
-        ? current.graphBuildMode
-        : 'full'
-    let prev
-    let baselineLabel = 'previous rebuild state'
-    if (args.base_ref) {
-        if (!ctx.repoRoot) return 'A Git-ref graph diff needs the active repository root.'
-        const built = await buildGraphAtGitRef(ctx.repoRoot, args.base_ref, {mode: currentMode})
-        if (!built.ok) return `Could not build the baseline graph: ${built.error}`
-        prev = built.graph
-        baselineLabel = `${built.ref} (${built.commit.slice(0, 12)})`
-    } else {
-        const prevPath = prevGraphPathFor(ctx.graphPath)
-        try { prev = JSON.parse(readFileSync(prevPath, 'utf8')) } catch {
-            return `No previous graph state at ${prevPath} — pass base_ref (for example HEAD~1 or main), or run rebuild_graph to save one automatically.`
-        }
-    }
-    if (!args.base_ref) {
-        const previousMode = ['full', 'no-tests', 'tests-only'].includes(prev?.graphBuildMode)
-            ? prev.graphBuildMode
-            : 'full'
-        if (previousMode !== currentMode) {
-            return [
-                `Graph diff unavailable: previous graph mode is ${previousMode}, current graph mode is ${currentMode}.`,
-                'Those node/edge universes are not comparable. Run rebuild_graph once more in the same mode, or pass base_ref to build a mode-matched immutable baseline.',
-            ].join('\n')
-        }
-    }
-    const filter = args.path ? String(args.path).replace(/\\/g, '/') : null
-    const scope = (graph) => filter ? {
-        nodes: (graph.nodes || []).filter((n) => String(n.id).startsWith(filter)),
-        links: (graph.links || []).filter((l) => String(edgeEndpoint(l.source)).startsWith(filter) || String(edgeEndpoint(l.target)).startsWith(filter)),
-        edgeTypesV: graph.edgeTypesV || 0,
-        edgeProvenanceV: graph.edgeProvenanceV || 0,
-        barrelResolutionV: graph.barrelResolutionV || 0,
-        extractorSchemaV: graph.extractorSchemaV || 0,
-    } : graph
-    return [
-        `Graph diff (${baselineLabel} → current)${filter ? `, scoped to ${filter}` : ''}:`,
-        `Build mode: ${currentMode}`,
-        formatGraphDiff(diffGraphs(scope(prev), scope(current)))
-    ].join('\n')
-}
-
-// ---- change impact -------------------------------------------------------------------------------
-// Blast radius of a change, without any GitHub API: diff the CURRENT change (branch
-// commits since the merge-base + staged/unstaged + untracked) against a base ref, map the changed
-// files and their symbols onto the graph, and walk REVERSE dependency edges — everything the change
-// can break, ranked by proximity + connectivity, with file-level test coverage attached so the
-// untested part of the blast radius stands out. The pre-PR review, in one call.
-export function tChangeImpact(g, args, ctx) {
-    const baseline = tChangeImpactV2(g, args, ctx)
-    return refineChangeImpact(g, args, ctx, baseline, tChangeImpactV2)
-}

package/src/mcp/tools-source.mjs

@@ -1,238 +0,0 @@
-import {readFileSync, statSync} from 'node:fs'
-import {boundedInteger} from '../bounds.js'
-import {resolveRepoPath} from '../repo-path.js'
-import {isStructuralRelation} from '../graph/relations.js'
-import {querySymbolPrecision} from '../precision/symbol-query.js'
-import {toolResult} from './tool-result.mjs'
-import {degreeOf, isSymbol, labelOf, resolveNodeInfo} from './graph-context.mjs'
-
-const MAX_EXCERPT_CHARS = 4_000
-const MAX_LOCATION_SAMPLES = 5
-const MAX_GRAPH_OCCURRENCES = 100
-
-const sourceLine = (node) => {
-    const match = /L(\d+)/.exec(String(node?.source_location || ''))
-    return match ? Number(match[1]) : 1
-}
-
-function candidateNodes(g, query, limit = 20) {
-    const text = String(query || '').trim().toLowerCase()
-    if (!text) return []
-    const exact = g.byLabel.get(text)
-    const nodes = exact?.length ? exact : g.nodes.filter((node) =>
-        String(node.id).toLowerCase().includes(text) || String(node.label || '').toLowerCase().includes(text))
-    return nodes.slice(0, limit).map((node) => ({
-        id: String(node.id), label: String(node.label || node.id), file: node.source_file || null,
-        ...(node.symbol_space ? {space: node.symbol_space} : {}),
-    }))
-}
-
-export function sourceExcerpt(repoRoot, file, focusLine, contextLines) {
-    const resolved = resolveRepoPath(repoRoot, file)
-    if (!resolved.ok) return null
-    let size
-    try { size = statSync(resolved.path).size } catch { return null }
-    if (size > 2 * 1024 * 1024) return null
-    let lines
-    try { lines = readFileSync(resolved.path, 'utf8').split(/\r?\n/) } catch { return null }
-    const focus = Math.max(1, Math.min(lines.length, Number(focusLine) || 1))
-    const startLine = Math.max(1, focus - contextLines)
-    const endLine = Math.min(lines.length, focus + contextLines)
-    const rawText = lines.slice(startLine - 1, endLine).join('\n')
-    return {
-        file,
-        focusLine: focus,
-        startLine,
-        endLine,
-        text: rawText.length > MAX_EXCERPT_CHARS ? `${rawText.slice(0, MAX_EXCERPT_CHARS)}\n… [excerpt truncated]` : rawText,
-        truncated: rawText.length > MAX_EXCERPT_CHARS,
-    }
-}
-
-function reverseImpact(g, targetId, depth = 3, cap = 40) {
-    const seen = new Map([[targetId, 0]])
-    const queue = [targetId]
-    for (let cursor = 0; cursor < queue.length; cursor++) {
-        const current = queue[cursor]
-        const currentDepth = seen.get(current)
-        if (currentDepth >= depth) continue
-        for (const edge of g.inn.get(current) || []) {
-            if (isStructuralRelation(edge.relation) || edge.barrelProxy === true) continue
-            const id = String(edge.id)
-            if (seen.has(id)) continue
-            seen.set(id, currentDepth + 1)
-            queue.push(id)
-        }
-    }
-    return [...seen.entries()]
-        .filter(([id]) => id !== targetId)
-        .map(([id, distance]) => ({id, label: labelOf(g, id), distance, degree: degreeOf(g, id)}))
-        .sort((left, right) => left.distance - right.distance || right.degree - left.degree)
-        .slice(0, cap)
-}
-
-function graphOccurrences(g, targetId) {
-    const all = (g.inn.get(targetId) || [])
-        .filter((edge) => !isStructuralRelation(edge.relation) && edge.barrelProxy !== true)
-        .map((edge) => ({
-            source: String(edge.id),
-            label: labelOf(g, edge.id),
-            relation: edge.relation || 'references',
-            provenance: edge.provenance || 'UNKNOWN',
-            ...(Number.isInteger(edge.line) ? {line: edge.line} : {}),
-            ...(edge.typeOnly === true ? {typeOnly: true} : {}),
-            ...(edge.compileOnly === true ? {compileOnly: true} : {}),
-        }))
-    return {total: all.length, shown: all.slice(0, MAX_GRAPH_OCCURRENCES)}
-}
-
-function groupLocations(g, locations, cap) {
-    const groups = new Map()
-    for (const location of locations) {
-        const source = String(location.source || location.file || '')
-        if (!source) continue
-        const node = g.byId.get(source)
-        const file = String(location.file || node?.source_file || (isSymbol(source) ? source.split('#')[0] : source))
-        let group = groups.get(source)
-        if (!group) {
-            group = {id: source, label: String(node?.label || source), file, count: 0, classifications: {}, locations: []}
-            groups.set(source, group)
-        }
-        group.count++
-        const classification = String(location.classification || 'unknown')
-        group.classifications[classification] = (group.classifications[classification] || 0) + 1
-        if (group.locations.length < MAX_LOCATION_SAMPLES) group.locations.push({
-          line: location.line,
-          character: location.character,
-          ...(Number.isInteger(location.endLine) ? {endLine: location.endLine} : {}),
-          ...(Number.isInteger(location.endCharacter) ? {endCharacter: location.endCharacter} : {}),
-          classification,
-        })
-    }
-    const all = [...groups.values()].sort((left, right) => right.count - left.count || left.file.localeCompare(right.file) || left.id.localeCompare(right.id))
-    return {all, shown: all.slice(0, cap)}
-}
-
-function textFor(result) {
-    if (result.status === 'NOT_FOUND') return `No symbol found matching "${result.query}".`
-    if (result.status === 'AMBIGUOUS') return [
-        `Symbol "${result.query}" is ambiguous (${result.candidates.length} candidate(s) shown). Supply an exact node ID:`,
-        ...result.candidates.map((candidate) => `  ${candidate.label}  [${candidate.id}]`),
-    ].join('\n')
-    const definition = result.definition
-    const lines = [
-        `Symbol inspection: ${definition.label}  [${definition.id}]`,
-        `Definition: ${definition.file}:${definition.line}`,
-        `Evidence: ${result.evidence.state}${result.evidence.cached ? ' (cache hit)' : ''}; ${result.exact.occurrences} exact reference occurrence(s) in ${result.exact.files} file(s) / ${result.exact.containers} container(s).`,
-        `Graph: ${result.graph.occurrenceTotal} direct occurrence edge(s) (${result.graph.occurrences.length} shown); ${result.graph.impact.length} dependent(s) shown.`,
-    ]
-    if (result.evidence.reason) lines.push(`Completeness: ${result.evidence.reason}`)
-    if (result.exact.zeroReferences) lines.push('Exact result: zero non-declaration references in the completely covered project universe.')
-    if (result.exact.groups.length) {
-        lines.push('Reference containers:')
-        for (const group of result.exact.groups) lines.push(`  ${group.count} site(s)  ${group.label}  [${group.id}]`)
-    }
-    if (result.source.definition) {
-        const source = result.source.definition
-        lines.push('', `Definition source (${source.file}:${source.startLine}-${source.endLine}):`, source.text)
-    }
-    for (const source of result.source.callers) {
-        lines.push('', `Caller source (${source.file}:${source.startLine}-${source.endLine}, focus ${source.focusLine}):`, source.text)
-    }
-    return lines.join('\n')
-}
-
-export async function tInspectSymbol(g, args = {}, ctx = {}) {
-    const query = String(args.label || '').trim()
-    const info = resolveNodeInfo(g, query)
-    if (!info.node) return toolResult(textFor({status: 'NOT_FOUND', query}), {status: 'NOT_FOUND', query})
-    if (info.matches > 1 && !g.byId.has(query)) {
-        const result = {status: 'AMBIGUOUS', query, candidates: candidateNodes(g, query)}
-        return toolResult(textFor(result), result, {completeness: {status: 'blocked', reason: 'ambiguous symbol'}})
-    }
-    const node = info.node
-    const targetId = String(node.id)
-    if (!isSymbol(targetId)) {
-        const result = {status: 'UNSUPPORTED', query, candidates: [{id: targetId, label: node.label || targetId, file: node.source_file || targetId}]}
-        return toolResult('inspect_symbol requires a symbol node, not a file node.', result)
-    }
-    const maxReferences = boundedInteger(args.max_references, 1_000, 1, 5_000)
-    const maxContainers = boundedInteger(args.max_containers, 15, 1, 50)
-    const contextLines = boundedInteger(args.context_lines, 8, 0, 40)
-    const timeoutMs = boundedInteger(args.timeout_ms, 30_000, 1_000, 60_000)
-    const precision = ['auto', 'graph', 'lsp'].includes(args.precision) ? args.precision : 'auto'
-    const shouldQuery = precision === 'lsp' || (precision === 'auto' && g.graphPrecisionMode !== 'off')
-    let overlay = null
-    let cached = false
-    let elapsedMs = 0
-    let queryError = null
-    if (shouldQuery) {
-        try {
-            const queryResult = await querySymbolPrecision({repoRoot: ctx.repoRoot, graphPath: ctx.graphPath, targetId, maxReferences, timeoutMs})
-            overlay = queryResult.overlay
-            cached = queryResult.cached
-            elapsedMs = queryResult.elapsedMs
-        } catch (error) {
-            queryError = error?.message || 'exact symbol query failed'
-        }
-    }
-    const locations = Array.isArray(overlay?.locations) ? overlay.locations : []
-    const grouped = groupLocations(g, locations, maxContainers)
-    const files = new Set(locations.map((location) => String(location.file || '')).filter(Boolean))
-    let state = 'GRAPH_ONLY'
-    if (overlay?.state === 'COMPLETE') state = 'EXACT'
-    else if (overlay?.state === 'PARTIAL') state = 'PARTIAL'
-    else if (overlay?.state === 'OFF') state = 'OFF'
-    else if (shouldQuery) state = 'UNAVAILABLE'
-    const reason = queryError || overlay?.reason || (shouldQuery ? null : 'semantic precision was not requested')
-    const graphRefs = graphOccurrences(g, targetId)
-    const impact = reverseImpact(g, targetId)
-    const definition = {
-        id: targetId,
-        label: String(node.label || targetId),
-        kind: String(node.symbol_kind || 'symbol'),
-        space: String(node.symbol_space || 'value'),
-        exported: node.exported === true,
-        file: String(node.source_file || targetId.split('#')[0]),
-        line: sourceLine(node),
-        ...(node.source_range ? {range: node.source_range} : {}),
-        ...(node.complexity ? {complexity: node.complexity} : {}),
-    }
-    const definitionSource = sourceExcerpt(ctx.repoRoot, definition.file, definition.line, contextLines)
-    const callerSources = grouped.shown.slice(0, 5).map((group) => sourceExcerpt(ctx.repoRoot, group.file, group.locations[0]?.line || 1, contextLines)).filter(Boolean)
-    const result = {
-        status: 'OK',
-        definition,
-        evidence: {state, cached, elapsedMs, reason, provider: overlay?.engines?.[0]?.provider || null},
-        exact: {
-            occurrences: locations.length,
-            occurrencesWithDefinition: locations.length + 1,
-            files: files.size,
-            containers: grouped.all.length,
-            groups: grouped.shown,
-            zeroReferences: overlay?.noReferenceSymbols?.includes(targetId) === true,
-            capped: overlay?.coverage?.truncated === true || grouped.all.length > grouped.shown.length,
-        },
-        graph: {
-            occurrences: graphRefs.shown,
-            occurrenceTotal: graphRefs.total,
-            occurrencesCapped: graphRefs.total > graphRefs.shown.length,
-            impact,
-        },
-        source: {definition: definitionSource, callers: callerSources},
-    }
-    const warnings = state === 'PARTIAL' || state === 'UNAVAILABLE'
-        ? [{code: 'SYMBOL_PRECISION_INCOMPLETE', message: reason || `semantic precision is ${state.toLowerCase()}`}]
-        : []
-    return toolResult(textFor(result), result, {
-        warnings,
-        completeness: {
-            status: state === 'EXACT' && !result.exact.capped ? 'complete' : state.toLowerCase(),
-            referenceLimit: maxReferences,
-            containerLimit: maxContainers,
-            returnedContainers: grouped.shown.length,
-            locationSamplesPerContainer: MAX_LOCATION_SAMPLES,
-            graphOccurrenceLimit: MAX_GRAPH_OCCURRENCES,
-        },
-    })
-}