weavatrix 0.3.14 → 1.0.0

package/src/mcp/extension-api.mjs

@@ -1,77 +0,0 @@
-const EXTENSION_NAME = /^[a-z0-9][a-z0-9._-]{0,127}$/
-const TOOL_NAME = /^[a-z][a-z0-9_]{0,127}$/
-
-const asArray = (value, field) => {
-    if (value == null) return []
-    if (!Array.isArray(value)) throw new TypeError(`${field} must be an array`)
-    return value
-}
-
-const validateProfiles = (profiles = {}) => {
-    if (!profiles || typeof profiles !== 'object' || Array.isArray(profiles)) throw new TypeError('extension profiles must be an object')
-    const normalized = {}
-    for (const [name, capabilities] of Object.entries(profiles)) {
-        if (!EXTENSION_NAME.test(name)) throw new TypeError(`invalid extension profile name: ${name}`)
-        normalized[name] = asArray(capabilities, `profile ${name}`).map(String)
-    }
-    return Object.freeze(normalized)
-}
-
-const validateTools = (tools = []) => Object.freeze(asArray(tools, 'extension tools').map((tool) => {
-    if (!tool || typeof tool !== 'object') throw new TypeError('each extension tool must be an object')
-    if (!TOOL_NAME.test(String(tool.name || ''))) throw new TypeError(`invalid extension tool name: ${tool.name || '(missing)'}`)
-    if (!EXTENSION_NAME.test(String(tool.cap || ''))) throw new TypeError(`invalid extension tool capability: ${tool.cap || '(missing)'}`)
-    if (typeof tool.run !== 'function') throw new TypeError(`extension tool ${tool.name} must provide run()`)
-    return Object.freeze({...tool})
-}))
-
-const validateAuditProviders = (providers = []) => Object.freeze(asArray(providers, 'auditProviders').map((provider) => {
-    if (!provider || typeof provider !== 'object') throw new TypeError('each audit provider must be an object')
-    if (!EXTENSION_NAME.test(String(provider.id || ''))) throw new TypeError(`invalid audit provider id: ${provider.id || '(missing)'}`)
-    if (typeof provider.run !== 'function') throw new TypeError(`audit provider ${provider.id} must provide run()`)
-    if (provider.network !== undefined && provider.network !== 'none') throw new TypeError(`audit provider ${provider.id} must be local (network: "none")`)
-    return Object.freeze({...provider, network: 'none'})
-}))
-
-const validateSkills = (skills = []) => Object.freeze(asArray(skills, 'skills').map((skill) => {
-    if (!skill || typeof skill !== 'object') throw new TypeError('each extension skill must be an object')
-    if (!EXTENSION_NAME.test(String(skill.name || ''))) throw new TypeError(`invalid extension skill name: ${skill.name || '(missing)'}`)
-    if (!String(skill.path || '').trim()) throw new TypeError(`extension skill ${skill.name} must provide a package-relative path`)
-    return Object.freeze({...skill, name: String(skill.name), path: String(skill.path)})
-}))
-
-// Public composition contract for packages layered on top of the MIT core. Extensions may add
-// tools, local audit providers and packaged skills, but cannot replace core tools or profiles.
-export function defineWeavatrixExtension(spec) {
-    if (!spec || typeof spec !== 'object') throw new TypeError('extension definition must be an object')
-    const name = String(spec.name || '')
-    const version = String(spec.version || '')
-    if (!EXTENSION_NAME.test(name)) throw new TypeError(`invalid extension name: ${name || '(missing)'}`)
-    if (!version.trim()) throw new TypeError(`extension ${name} must provide a version`)
-    return Object.freeze({
-        name,
-        version,
-        tools: validateTools(spec.tools),
-        profiles: validateProfiles(spec.profiles),
-        auditProviders: validateAuditProviders(spec.auditProviders),
-        skills: validateSkills(spec.skills),
-    })
-}
-
-export function normalizeWeavatrixExtensions(extensions = []) {
-    const normalized = asArray(extensions, 'extensions').map((extension) => defineWeavatrixExtension(extension))
-    const names = new Set()
-    for (const extension of normalized) {
-        if (names.has(extension.name)) throw new TypeError(`duplicate extension name: ${extension.name}`)
-        names.add(extension.name)
-    }
-    return Object.freeze(normalized)
-}
-
-export const extensionRuntimeSummary = (extensions = []) => extensions.map((extension) => ({
-    name: extension.name,
-    version: extension.version,
-    tools: extension.tools.length,
-    auditProviders: extension.auditProviders.length,
-    skills: extension.skills.map((skill) => skill.name),
-}))

package/src/mcp/git-output.mjs

@@ -1,7 +0,0 @@
-import {runGit} from '../git-exec.js'
-
-export function gitLines(repoRoot, args) {
-    const result = runGit(repoRoot, args)
-    if (result.status !== 0) return null
-    return String(result.stdout || '').split(/\r?\n/).map((line) => line.trim()).filter(Boolean)
-}

package/src/mcp/graph/context-core.mjs

@@ -1,111 +0,0 @@
-import {readFileSync} from 'node:fs'
-import {isStructuralRelation} from '../../graph/relations.js'
-import {edgeProvenance} from '../../graph/edge-provenance.js'
-import {mergePrecisionOverlay, precisionSemanticInputsMatch, readPrecisionOverlay} from '../../precision/lsp-overlay.js'
-
-export function loadGraph(path, {repoRoot = null} = {}) {
-    const saved = JSON.parse(readFileSync(path, 'utf8'))
-    const overlay = readPrecisionOverlay(path, saved)
-    const safeOverlay = repoRoot && typeof overlay?.semanticInputFingerprint === 'string'
-        && !precisionSemanticInputsMatch(overlay, repoRoot, saved) ? null : overlay
-    const raw = mergePrecisionOverlay(saved, safeOverlay)
-    const nodes = Array.isArray(raw.nodes) ? raw.nodes : []
-    const links = Array.isArray(raw.links) ? raw.links : []
-    const byId = new Map()
-    const byLabel = new Map()
-    for (const n of nodes) {
-        if (!n || n.id == null) continue
-        byId.set(String(n.id), n)
-        const key = String(n.label ?? n.id).toLowerCase()
-        if (!byLabel.has(key)) byLabel.set(key, [])
-        byLabel.get(key).push(n)
-    }
-    const out = new Map()
-    const inn = new Map()
-    const push = (map, k, v) => {
-        if (!map.has(k)) map.set(k, [])
-        map.get(k).push(v)
-    }
-    for (const e of links) {
-        if (!e || e.source == null || e.target == null) continue
-        const s = String(e.source), t = String(e.target)
-        const metadata = {
-            relation: e.relation,
-            confidence: e.confidence,
-            provenance: edgeProvenance(e),
-            ...(e.typeOnly === true ? {typeOnly: true} : {}),
-            ...(e.compileOnly === true ? {compileOnly: true} : {}),
-            ...(Number.isInteger(e.line) ? {line: e.line} : {}),
-            ...(typeof e.specifier === 'string' ? {specifier: e.specifier} : {}),
-            ...(e.barrelProxy === true ? {barrelProxy: true} : {}),
-            ...(e.semanticOrigin === true ? {semanticOrigin: true} : {}),
-            ...(typeof e.viaBarrel === 'string' ? {viaBarrel: e.viaBarrel} : {}),
-        }
-        push(out, s, {id: t, ...metadata})
-        push(inn, t, {id: s, ...metadata})
-    }
-    return {
-        nodes, links, byId, byLabel, out, inn,
-        repoBoundaryV: Number(raw.repoBoundaryV) || 0,
-        edgeTypesV: Number(raw.edgeTypesV) || 0,
-        edgeProvenanceV: Number(raw.edgeProvenanceV) || 0,
-        barrelResolutionV: Number(raw.barrelResolutionV) || 0,
-        reExportOccurrencesV: Number(raw.reExportOccurrencesV) || 0,
-        symbolSpacesV: Number(raw.symbolSpacesV) || 0,
-        reExportOccurrences: Array.isArray(raw.reExportOccurrences) ? raw.reExportOccurrences : [],
-        jsExportRecords: raw.jsExportRecords && typeof raw.jsExportRecords === 'object' ? raw.jsExportRecords : {},
-        extractorSchemaV: Number(raw.extractorSchemaV) || 0,
-        extImportsV: Number(raw.extImportsV) || 0,
-        complexityV: Number(raw.complexityV) || 0,
-        physicalFileLocV: Number(raw.physicalFileLocV) || 0,
-        graphBuildMode: ['full', 'no-tests', 'tests-only'].includes(raw.graphBuildMode) ? raw.graphBuildMode : 'full',
-        graphBuildScope: typeof raw.graphBuildScope === 'string' ? raw.graphBuildScope : null,
-        graphRevision: typeof raw.graphRevision === 'string' ? raw.graphRevision : null,
-        repositoryFreshnessProbeV: Number(raw.repositoryFreshnessProbeV) || 0,
-        repositoryFreshnessBuilderSchemaV: Number(raw.repositoryFreshnessBuilderSchemaV) || 0,
-        repositoryFreshnessBuilderVersion: typeof raw.repositoryFreshnessBuilderVersion === 'string' ? raw.repositoryFreshnessBuilderVersion : null,
-        repositoryFreshnessProbe: typeof raw.repositoryFreshnessProbe === 'string' ? raw.repositoryFreshnessProbe : null,
-        repositoryFreshnessMode: typeof raw.repositoryFreshnessMode === 'string' ? raw.repositoryFreshnessMode : null,
-        graphPrecisionMode: raw.graphPrecisionMode === 'off' ? 'off' : 'lsp',
-        precisionOverlayV: Number(raw.precisionOverlayV) || 0,
-        precision: raw.precision || null,
-    }
-}
-
-export const isSymbol = (id) => String(id).includes('#')
-export const labelOf = (g, id) => {
-    const n = g.byId.get(String(id))
-    return n ? String(n.label ?? n.id) : String(id)
-}
-export const connList = (list) => (list || []).filter((e) => !isStructuralRelation(e.relation) && e.barrelProxy !== true)
-export const degreeOf = (g, id) => connList(g.out.get(id)).length + connList(g.inn.get(id)).length
-export const uniqueConnCount = (list) => new Set(connList(list).map((e) => String(e.id))).size
-
-export function resolveNodeInfo(g, query) {
-    const q = String(query ?? '').trim()
-    if (!q) return {node: null, matches: 0, alternates: []}
-    if (g.byId.has(q)) return {node: g.byId.get(q), matches: 1, alternates: []}
-    const exactLabel = g.byLabel.get(q.toLowerCase())
-    if (exactLabel?.length) return pickBest(g, exactLabel)
-    const hits = []
-    for (const n of g.nodes) {
-        if (String(n.id).toLowerCase().includes(q.toLowerCase()) || String(n.label ?? '').toLowerCase().includes(q.toLowerCase())) hits.push(n)
-        if (hits.length > 500) break
-    }
-    return hits.length ? pickBest(g, hits) : {node: null, matches: 0, alternates: []}
-}
-
-export const resolveNode = (g, query) => resolveNodeInfo(g, query).node
-const bestByDegree = (g, list) => list.reduce((best, n) => (degreeOf(g, n.id) > degreeOf(g, best.id) ? n : best), list[0])
-function pickBest(g, list) {
-    const node = bestByDegree(g, list)
-    const alternates = list.filter((n) => n !== node).sort((a, b) => degreeOf(g, b.id) - degreeOf(g, a.id))
-        .slice(0, 4).map((n) => `${n.label ?? n.id} [${n.id}]`)
-    return {node, matches: list.length, alternates}
-}
-
-export function ambiguityNote(query, info) {
-    if (!info.node || info.matches <= 1) return null
-    const more = info.matches - 1 - info.alternates.length
-    return `Note: "${query}" matched ${info.matches} nodes; using the best-connected. Others: ${info.alternates.join(', ')}${more > 0 ? ` (+${more} more)` : ''}`
-}

package/src/mcp/graph/context-seeds.mjs

@@ -1,207 +0,0 @@
-import {PATH_CLASS_NAMES, PATH_CLASS_QUERY_TERMS, createPathClassifier, hasPathClass} from '../../path-classification.js'
-import {degreeOf, isSymbol, uniqueConnCount} from './context-core.mjs'
-
-const QUERY_STOP = new Set('a an and are around architecture best code do does exact explain find focus focused for from how identify in inspect inspection is logic me of or path production project repository request requests rest show symbol symbols the through to trace what where which with'.split(' '))
-const QUERY_INTENTS = [
-    ['bootstrap', ['bootstrap', 'startup', 'entrypoint', 'entry', 'main', 'root', 'app', 'application', 'applications', 'index', 'server', 'cli']],
-    ['tool-execution', ['tool', 'tools', 'tooling', 'mcp', 'execution', 'execute', 'invocation', 'invoke', 'dispatch', 'dispatcher', 'handler', 'catalog', 'registry']],
-    ['auth', ['auth', 'authentication', 'authorization', 'login', 'session', 'authgate']],
-    ['routing', ['routing', 'router', 'routes', 'route', 'navigation']],
-    ['layout', ['layout', 'layouts', 'shell']],
-    ['api', ['api', 'apis', 'endpoint', 'endpoints', 'client']],
-    ['state', ['state', 'store', 'stores', 'reducer', 'context']],
-]
-const INTENT_BY_TERM = new Map(QUERY_INTENTS.filter(([id]) => id !== 'tool-execution')
-    .flatMap(([id, terms]) => terms.map((term) => [term, {id, terms}])))
-const TOOL_EXECUTION_TERMS = QUERY_INTENTS.find(([id]) => id === 'tool-execution')[1]
-const TOOL_EXECUTION_TRIGGERS = new Set(['tool', 'tools', 'tooling', 'mcp'])
-const wordsOf = (value) => String(value ?? '').replace(/([a-z0-9])([A-Z])/g, '$1 $2').toLowerCase().split(/[^a-z0-9_]+/).filter(Boolean)
-const normPath = (value) => String(value ?? '').replace(/\\/g, '/').replace(/^\.\//, '').toLowerCase()
-const CODE_FILE_RE = /\.(?:[cm]?[jt]sx?|py|go|java|rs|kt|kts|cs|rb|php|sol|sql)$/i
-const DATA_OR_PROSE_RE = /\.(?:json|ya?ml|toml|ini|md|mdx|rst|adoc|html?|css|scss|less|svg)$/i
-const LANGUAGE_EXTENSIONS = Object.freeze({
-    rust: ['rs'], python: ['py', 'pyi'], typescript: ['ts', 'tsx', 'mts', 'cts'],
-    javascript: ['js', 'jsx', 'mjs', 'cjs'], go: ['go'], java: ['java'], csharp: ['cs'],
-    solidity: ['sol'], sql: ['sql'],
-})
-
-function requestedLanguages(query) {
-    const raw = String(query || ''), words = new Set(wordsOf(query)), requested = new Set()
-    if (words.has('rust')) requested.add('rust')
-    if (words.has('python') || words.has('py')) requested.add('python')
-    if (words.has('typescript') || words.has('ts') || /typescript/i.test(raw)) requested.add('typescript')
-    if (words.has('javascript') || words.has('js') || words.has('nodejs') || /javascript|node\.?js/i.test(raw)) requested.add('javascript')
-    if (words.has('golang') || /(?:^|[^A-Za-z])Go(?:[^A-Za-z]|$)/.test(raw)) requested.add('go')
-    if (words.has('java')) requested.add('java')
-    if (words.has('csharp') || words.has('dotnet') || /csharp|(?:^|[^A-Za-z])C#(?:[^A-Za-z]|$)/i.test(raw)) requested.add('csharp')
-    if (words.has('solidity') || words.has('contract') || words.has('contracts')) requested.add('solidity')
-    if (words.has('sql') || words.has('schema') || words.has('migration') || words.has('migrations')) requested.add('sql')
-    return new Set([...requested].flatMap((language) => LANGUAGE_EXTENSIONS[language]))
-}
-
-const sourceFileOf = (node) => normPath(node?.source_file || String(node?.id ?? '').split('#', 1)[0])
-const matchesLanguage = (node, extensions) => {
-    if (!extensions.size) return true
-    const match = /\.([^.\/]+)$/.exec(sourceFileOf(node))
-    return !!match && extensions.has(match[1].toLowerCase())
-}
-
-export function requestedPathClasses(query) {
-    const words = new Set(wordsOf(query)), requested = new Set()
-    for (const [category, terms] of Object.entries(PATH_CLASS_QUERY_TERMS)) if (terms.some((term) => words.has(term))) requested.add(category)
-    if (requested.has('test')) requested.add('e2e')
-    if (requested.has('e2e')) requested.add('test')
-    return requested
-}
-
-function isQueryEligible(node, requestedClasses, classificationCache, classifier) {
-    if (node?.test_surface === true && !requestedClasses.has('test')) return false
-    const source = sourceFileOf(node)
-    if (!source) return true
-    if (!classificationCache.has(source)) classificationCache.set(source, classifier.explain(source, {content: ''}))
-    const info = classificationCache.get(source)
-    const classified = PATH_CLASS_NAMES.filter((category) => hasPathClass(info, category))
-    return classified.length === 0 || classified.some((category) => requestedClasses.has(category))
-}
-
-function entrypointSignal(g, node, source, stem) {
-    if (isSymbol(node.id) || !CODE_FILE_RE.test(source)) return 0
-    const depth = source.split('/').length
-    let score = 0
-    if (node.entrypoint === true || node.is_entrypoint === true || node.declared_entry === true) score = 72
-    if (/^bin\//.test(source) || /\/(?:bin|cmd)\//.test(source)) score = Math.max(score, 62)
-    if (depth <= 2 && /^(?:index|main|app|server|cli|bootstrap|entry|run)$/.test(stem)) score = Math.max(score, 60)
-    if (depth <= 2 && /(?:^|[-_.])(?:main|server|cli|bootstrap|entry)(?:$|[-_.])/.test(stem)) score = Math.max(score, 57)
-    if (depth <= 3 && /^(?:main|app|server|cli|bootstrap|entry|run)$/.test(stem)) score = Math.max(score, 52)
-    const incoming = uniqueConnCount(g.inn.get(String(node.id))), outgoing = uniqueConnCount(g.out.get(String(node.id)))
-    if (score && incoming === 0 && outgoing > 0) score += Math.min(7, 2 + outgoing)
-    return score
-}
-
-function toolExecutionSignal(node, source, words, stem) {
-    if (!CODE_FILE_RE.test(source)) return 0
-    let score = 0
-    if (/(^|\/)(?:mcp(?:[-_.][^/]*)?|tools?)(?:\/|[-_.])/.test(source)) score = Math.max(score, 51)
-    if (/^(?:catalog|dispatch(?:er)?|registry)$/.test(stem)) score = Math.max(score, 68)
-    if (/^(?:tool[-_.]?(?:handler|runner|executor)|tools?[-_.])/.test(stem)) score = Math.max(score, 55)
-    if ([...words].some((word) => /^(?:dispatch|dispatcher|toolcall|toolhandler|executetool|invoketool|calltool)$/.test(word))) score = Math.max(score, 64)
-    if (source.includes('/mcp/') || stem.includes('mcp-server')) score = Math.max(score, 48)
-    return score
-}
-
-// relaxStop is the last-resort fallback: when EVERY token is a stop word (e.g. a bare
-// "architecture" query), keep them as concepts so the query still seeds instead of
-// misreporting "No nodes matched" for a concept the repository clearly contains.
-function queryConcepts(query, {relaxStop = false} = {}) {
-    const tokens = wordsOf(query)
-    const toolExecution = tokens.some((token) => TOOL_EXECUTION_TRIGGERS.has(token))
-    const explanatoryWork = tokens.some((token) => token === 'how' || token === 'explain')
-    const seen = new Set(), concepts = []
-    for (const raw of tokens) {
-        if (raw.length < 2 || (!relaxStop && QUERY_STOP.has(raw))) continue
-        if (explanatoryWork && (raw === 'work' || raw === 'works' || raw === 'working')) continue
-        if (toolExecution && TOOL_EXECUTION_TERMS.includes(raw)) {
-            if (seen.has('tool-execution')) continue
-            const trigger = tokens.find((token) => TOOL_EXECUTION_TRIGGERS.has(token)) || raw
-            seen.add('tool-execution')
-            concepts.push({id: 'tool-execution', raw: trigger, terms: [trigger, ...TOOL_EXECUTION_TERMS.filter((term) => term !== trigger)]})
-            continue
-        }
-        const intent = INTENT_BY_TERM.get(raw), id = intent?.id || raw
-        if (seen.has(id)) continue
-        seen.add(id)
-        concepts.push({id, raw, terms: intent ? [raw, ...intent.terms.filter((term) => term !== raw)] : [raw]})
-    }
-    return concepts
-}
-
-function exactIdentifierSeeds(g, query, limit, {repoRoot = null} = {}) {
-    const identifiers = [...new Set((String(query || '').match(/[A-Za-z_$][A-Za-z0-9_$]*/g) || [])
-        .filter((item) => /(?:[a-z0-9][A-Z]|_)/.test(item)).map((item) => item.toLowerCase()))]
-    if (!identifiers.length) return []
-    const requestedClasses = requestedPathClasses(query), languageExtensions = effectiveLanguages(g, query)
-    const classifier = createPathClassifier(repoRoot), classificationCache = new Map(), matches = []
-    for (const identifier of identifiers) {
-        const candidates = g.nodes.filter((node) => String(node.label || '').replace(/\(\)$/, '').toLowerCase() === identifier
-            && matchesLanguage(node, languageExtensions) && isQueryEligible(node, requestedClasses, classificationCache, classifier))
-            .sort((left, right) => degreeOf(g, right.id) - degreeOf(g, left.id) || String(left.id).localeCompare(String(right.id)))
-        for (const node of candidates) {
-            if (!matches.some((existing) => String(existing.id) === String(node.id))) matches.push(node)
-            if (matches.length >= limit) return matches
-        }
-    }
-    return matches
-}
-
-function conceptScore(g, node, concept, queryContext) {
-    const id = normPath(node.id), label = String(node.label ?? '').toLowerCase(), source = sourceFileOf(node)
-    const stem = (label.split('/').pop() || '').replace(/\.[^.]+$/, '')
-    const words = new Set(wordsOf(`${node.id} ${node.label ?? ''} ${node.source_file ?? ''}`))
-    const segments = new Set(source.split('/').flatMap((part) => wordsOf(part.replace(/\.[^.]+$/, ''))))
-    let match = 0
-    concept.terms.forEach((term, index) => {
-        const primary = index === 0
-        if (label === term || stem === term) match = Math.max(match, primary ? 60 : 42)
-        else if (segments.has(term)) match = Math.max(match, primary ? 48 : 36)
-        else if (words.has(term)) match = Math.max(match, primary ? 36 : 25)
-        else if (term.length >= 4 && term !== 'tool' && term !== 'tools' && (id.includes(term) || label.includes(term))) match = Math.max(match, primary ? 12 : 7)
-    })
-    const extension = (/\.([^.\/]+)$/.exec(source) || [])[1] || ''
-    const languageConcept = {rust: ['rs'], python: ['py', 'pyi'], py: ['py', 'pyi'], typescript: ['ts', 'tsx', 'mts', 'cts'], ts: ['ts', 'tsx', 'mts', 'cts'], javascript: ['js', 'jsx', 'mjs', 'cjs'], js: ['js', 'jsx', 'mjs', 'cjs'], nodejs: ['js', 'jsx', 'mjs', 'cjs'], golang: ['go'], go: ['go'], java: ['java'], csharp: ['cs'], dotnet: ['cs'], solidity: ['sol'], sql: ['sql'], schema: ['sql']}[concept.raw]
-    if (languageConcept?.includes(extension) && queryContext.languageExtensions.has(extension)) match = Math.max(match, 58)
-    const fileNode = !isSymbol(node.id), depth = source ? source.split('/').length : 9
-    if (concept.id === 'bootstrap') match = Math.max(match, entrypointSignal(g, node, source, stem))
-    if (concept.id === 'tool-execution') match = Math.max(match, toolExecutionSignal(node, source, words, stem))
-    if (!match) return 0
-    let score = match + (fileNode ? 7 : 0) + Math.max(0, 4 - depth) + Math.min(2, degreeOf(g, node.id) / 40)
-    if ((concept.id === 'bootstrap' || concept.id === 'tool-execution') && DATA_OR_PROSE_RE.test(source)) score -= 34
-    if ((concept.id === 'bootstrap' || concept.id === 'tool-execution') && !fileNode) score -= 18
-    if (queryContext.runtimeIntent && !queryContext.maintenanceIntent && /^(?:scripts?|tools?\/scripts?)\//.test(source)) score -= 32
-    if (queryContext.runtimeIntent && /^(?:site|website|public|static|assets)\//.test(source)) score -= 28
-    return Math.max(0, score)
-}
-
-// A requested language that matches ZERO nodes in this graph is over-eager inference (e.g.
-// "contract" inferring Solidity in a repo with no .sol files); drop the filter rather than
-// eliminate every candidate and return nothing.
-function effectiveLanguages(g, query) {
-    const languageExtensions = requestedLanguages(query)
-    if (languageExtensions.size && !g.nodes.some((node) => matchesLanguage(node, languageExtensions))) return new Set()
-    return languageExtensions
-}
-
-export function findSeeds(g, query, limit = 8, {repoRoot = null} = {}) {
-    const exact = exactIdentifierSeeds(g, query, limit, {repoRoot})
-    if (exact.length) return exact
-    let concepts = queryConcepts(query)
-    if (!concepts.length) concepts = queryConcepts(query, {relaxStop: true})
-    if (!concepts.length || limit <= 0) return []
-    const requestedClasses = requestedPathClasses(query), languageExtensions = effectiveLanguages(g, query)
-    const queryContext = {runtimeIntent: concepts.some((concept) => concept.id === 'bootstrap' || concept.id === 'tool-execution'), maintenanceIntent: wordsOf(query).some((word) => ['script', 'scripts', 'build', 'release', 'publish', 'packaging'].includes(word)), languageExtensions}
-    const classifier = createPathClassifier(repoRoot), classificationCache = new Map()
-    const rows = g.nodes.filter((node) => matchesLanguage(node, languageExtensions) && isQueryEligible(node, requestedClasses, classificationCache, classifier)).map((node) => {
-        const scores = concepts.map((concept) => conceptScore(g, node, concept, queryContext))
-        return {node, scores, total: Math.max(...scores) + scores.reduce((sum, score) => sum + score, 0) / 10}
-    })
-    const chosen = [], used = new Set()
-    for (let index = 0; index < concepts.length && chosen.length < limit; index++) {
-        const best = rows.filter((row) => !used.has(String(row.node.id)) && row.scores[index] > 0)
-            .sort((a, b) => b.scores[index] - a.scores[index] || String(a.node.id).localeCompare(String(b.node.id)))[0]
-        if (best) { chosen.push(best.node); used.add(String(best.node.id)) }
-    }
-    rows.filter((row) => row.total > 0 && !used.has(String(row.node.id)))
-        .sort((a, b) => b.total - a.total || String(a.node.id).localeCompare(String(b.node.id)))
-        .slice(0, Math.max(0, limit - chosen.length)).forEach((row) => chosen.push(row.node))
-    return chosen
-}
-
-export function resolveSeedFiles(g, requested, limit = 12) {
-    const files = Array.isArray(requested) ? requested.slice(0, limit) : [], seeds = [], missing = []
-    for (const raw of files) {
-        const wanted = normPath(raw)
-        const node = g.nodes.find((candidate) => !isSymbol(candidate.id) && (normPath(candidate.id) === wanted || normPath(candidate.source_file) === wanted))
-        if (!node) missing.push(String(raw))
-        else if (!seeds.some((seed) => String(seed.id) === String(node.id))) seeds.push(node)
-    }
-    return {seeds, missing}
-}

package/src/mcp/graph/context-state.mjs

@@ -1,85 +0,0 @@
-import {readFileSync, statSync} from 'node:fs'
-import {join} from 'node:path'
-import {runGit} from '../../git-exec.js'
-import {resolveRepoPath} from '../../repo-path.js'
-import {mergePrecisionOverlay, precisionSemanticInputsMatch, readPrecisionOverlay} from '../../precision/lsp-overlay.js'
-
-let stalenessCache = {key: '', checkedAt: 0, info: null}
-
-export function graphStaleness(ctx) {
-    const now = Date.now()
-    if (stalenessCache.info && stalenessCache.key === ctx.graphPath && now - stalenessCache.checkedAt < 60_000) return stalenessCache.info
-    const info = {builtAt: null, headAt: null, stale: false, behind: null}
-    try { info.builtAt = statSync(ctx.graphPath).mtime } catch { /* no graph file */ }
-    if (ctx.repoRoot && info.builtAt) {
-        try {
-            const head = runGit(ctx.repoRoot, ['log', '-1', '--format=%cI'], {timeout: 4000})
-            const iso = (head.stdout || '').trim()
-            if (head.status === 0 && iso) {
-                info.headAt = new Date(iso)
-                if (info.headAt > info.builtAt) {
-                    info.stale = true
-                    const count = runGit(ctx.repoRoot, ['rev-list', '--count', `--since=${info.builtAt.toISOString()}`, 'HEAD'], {timeout: 4000})
-                    if (count.status === 0) info.behind = Number(count.stdout.trim()) || null
-                }
-            }
-        } catch { /* git unavailable */ }
-        try {
-            const status = runGit(ctx.repoRoot, ['status', '--porcelain'], {timeout: 4000})
-            if (status.status === 0) {
-                let newer = 0
-                for (const line of String(status.stdout || '').split(/\r?\n/).filter(Boolean).slice(0, 200)) {
-                    const path = line.slice(3).trim().replace(/^"|"$/g, '')
-                    try { if (statSync(join(ctx.repoRoot, path)).mtime > info.builtAt) newer++ } catch { newer++ }
-                }
-                info.dirtyNewer = newer
-                if (newer > 0) info.stale = true
-            }
-        } catch { /* git unavailable */ }
-    }
-    stalenessCache = {key: ctx.graphPath, checkedAt: now, info}
-    return info
-}
-
-export const resetStalenessCache = () => { stalenessCache = {key: '', checkedAt: 0, info: null} }
-
-export function stalenessLine(ctx) {
-    const state = graphStaleness(ctx)
-    if (!state.stale) return null
-    const bits = []
-    if (state.headAt && state.headAt > state.builtAt) bits.push(`${state.behind != null ? `${state.behind} commit${state.behind === 1 ? '' : 's'}` : 'commits'} newer than the graph`)
-    if (state.dirtyNewer) bits.push(`${state.dirtyNewer} uncommitted file(s) edited after the build`)
-    return `Warning: graph may be stale — the repo has ${bits.join(' and ')} (built ${state.builtAt.toISOString()}). Line numbers may have drifted; call rebuild_graph.`
-}
-
-export function fileStalenessNote(ctx, sourceFile) {
-    if (!ctx?.repoRoot || !sourceFile) return null
-    const state = graphStaleness(ctx)
-    if (!state.builtAt) return null
-    try {
-        const resolved = resolveRepoPath(ctx.repoRoot, String(sourceFile))
-        if (resolved.ok && statSync(resolved.path).mtime > state.builtAt) {
-            return `Note: ${sourceFile} changed after the graph was built — line numbers above may have drifted (rebuild_graph refreshes them).`
-        }
-    } catch { /* missing file */ }
-    return null
-}
-
-let rawGraphCache = {path: '', mtimeMs: 0, data: null}
-
-export function rawGraph(ctx) {
-    const mtimeMs = statSync(ctx.graphPath).mtimeMs
-    if (!rawGraphCache.data || rawGraphCache.path !== ctx.graphPath || rawGraphCache.mtimeMs !== mtimeMs) {
-        rawGraphCache = {path: ctx.graphPath, mtimeMs, data: JSON.parse(readFileSync(ctx.graphPath, 'utf8'))}
-    }
-    return rawGraphCache.data
-}
-
-export function effectiveRawGraph(ctx) {
-    const raw = rawGraph(ctx)
-    const overlay = readPrecisionOverlay(ctx.graphPath, raw)
-    const safeOverlay = ctx?.repoRoot && typeof overlay?.semanticInputFingerprint === 'string'
-        && !precisionSemanticInputsMatch(overlay, ctx.repoRoot, raw)
-        ? null : overlay
-    return mergePrecisionOverlay(raw, safeOverlay)
-}

package/src/mcp/graph/reverse-reach.mjs

@@ -1,42 +0,0 @@
-import {isStructuralRelation} from '../../graph/relations.js'
-
-// Shared reverse dependency walk for get_dependents and change_impact. Keep one
-// representation so runtime/compile-time depth and edge provenance cannot drift
-// between the two public tools.
-export function reverseReach(g, seeds, maxDepth) {
-    const states = new Map([...seeds].map((id) => [String(id), {
-        runtimeDepth: 0, runtimeRelation: null, runtimeProvenance: null,
-        compileDepth: null, compileRelation: null, compileProvenance: null,
-    }]))
-    const frontier = [...seeds].map((id) => ({id: String(id), depth: 0, compileOnly: false}))
-    for (let cursor = 0; cursor < frontier.length; cursor++) {
-        const current = frontier[cursor]
-        if (current.depth >= maxDepth) continue
-        for (const edge of g.inn.get(current.id) || []) {
-            if (isStructuralRelation(edge.relation) || edge.barrelProxy === true) continue
-            const id = String(edge.id)
-            const compileOnly = current.compileOnly || edge.typeOnly === true || edge.compileOnly === true
-            const depth = current.depth + 1
-            const entry = states.get(id) || {
-                runtimeDepth: null, runtimeRelation: null, runtimeProvenance: null,
-                compileDepth: null, compileRelation: null, compileProvenance: null,
-            }
-            const depthKey = compileOnly ? 'compileDepth' : 'runtimeDepth'
-            const relationKey = compileOnly ? 'compileRelation' : 'runtimeRelation'
-            const provenanceKey = compileOnly ? 'compileProvenance' : 'runtimeProvenance'
-            if (entry[depthKey] != null && entry[depthKey] <= depth) continue
-            entry[depthKey] = depth
-            entry[relationKey] = edge.relation || 'rel'
-            entry[provenanceKey] = edge.provenance || 'UNKNOWN'
-            states.set(id, entry)
-            frontier.push({id, depth, compileOnly})
-        }
-    }
-    return new Map([...states].map(([id, entry]) => [id, {
-        ...entry,
-        depth: entry.runtimeDepth ?? entry.compileDepth ?? 0,
-        compileOnly: entry.runtimeDepth == null,
-        relation: entry.runtimeDepth != null ? entry.runtimeRelation : entry.compileRelation,
-        provenance: entry.runtimeDepth != null ? entry.runtimeProvenance : entry.compileProvenance,
-    }]))
-}