weavatrix 0.2.2 → 0.2.4

package/src/mcp/tools-health.mjs

@@ -1,7 +1,7 @@
 // Health tools: clone detection, the internal audit, community/module overviews, coverage mapping
 // and the HTTP endpoint inventory. Hot-reloadable (re-imported by catalog.mjs on change).
 import {spawnSync} from 'node:child_process'
-import {degreeOf, rawGraph} from './graph-context.mjs'
+import {degreeOf, rawGraph, effectiveRawGraph} from './graph-context.mjs'
 import {computeDuplicates} from '../analysis/duplicates.js'
 import {runInternalAudit} from '../analysis/internal-audit.js'
 import {classifyChangeImpact} from '../analysis/change-classification.js'
@@ -17,8 +17,9 @@ import {buildInternalGraph} from '../graph/internal-builder.js'
 import {resolveGitCommit, withGitRefCheckout} from '../analysis/git-ref-graph.js'
 import {childProcessEnv} from '../child-env.js'
 import {toolResult} from './tool-result.mjs'
-import {createPathClassifier} from '../path-classification.js'
+import {createPathClassifier, hasPathClass} from '../path-classification.js'
 import {createRepoBoundary} from '../repo-path.js'
+import {filterGraphForMode} from '../graph/graph-filter.js'
 
 const NON_PRODUCT_DUPLICATE_CLASSES = new Set(['generated', 'mock', 'story', 'docs', 'benchmark', 'temp'])
 const fragmentEligible = (fragment, {tokMin, skipTests, includeClassified}) => {
@@ -117,7 +118,7 @@ export function tFindDuplicates(g, args, ctx) {
 // candidates. It never returns an automatic-delete verdict.
 export function tFindDeadCode(g, args, ctx) {
     if (!ctx.repoRoot) return 'Dead-code review needs the repo root (not provided to this server).'
-    const graph = rawGraph(ctx)
+    const graph = effectiveRawGraph(ctx)
     const boundary = createRepoBoundary(ctx.repoRoot)
     const pkg = readRepoJson(boundary, 'package.json') || {}
     const rules = readRepoJson(boundary, '.weavatrix-deps.json') || {}
@@ -323,7 +324,12 @@ async function runAuditWithBaseline(args, ctx, currentGraph) {
     }
 
     const baseline = await withGitRefCheckout(ctx.repoRoot, resolved.commit, async (checkout) => {
-        const graph = await buildInternalGraph(checkout)
+        let graph = await buildInternalGraph(checkout)
+        const currentMode = ['full', 'no-tests', 'tests-only'].includes(currentGraph?.graphBuildMode)
+            ? currentGraph.graphBuildMode : 'full'
+        if (currentMode !== 'full') graph = filterGraphForMode(graph, currentMode, {repoRoot: checkout})
+        graph.graphBuildMode = currentMode
+        graph.graphBuildScope = ''
         return runInternalAudit(checkout, {graph, skipMalwareScan: true})
     })
     if (!baseline.ok || !baseline.value?.ok) {
@@ -385,7 +391,7 @@ export async function tRunAudit(g, args, ctx) {
     if (!ctx.repoRoot) return 'Audit needs the repo root (not provided to this server).'
     if (args.base_ref) return runAuditWithBaseline(args, ctx, rawGraph(ctx))
     const audit = await runInternalAudit(ctx.repoRoot, {
-        graph: rawGraph(ctx),
+        graph: effectiveRawGraph(ctx),
         skipMalwareScan: !args.include_malware_scan, // greps installed packages — slow, so opt-in
     })
     if (!audit.ok) return `Audit failed: ${audit.error}`
@@ -440,7 +446,36 @@ export function tListCommunities(g, args, ctx) {
 // Folder-level architecture map: modules (top-two path segments) with file/symbol counts and the
 // strongest module→module dependencies. Pure graph aggregation — no filesystem reads.
 export function tModuleMap(g, args, ctx) {
-    const agg = aggregateGraph(rawGraph(ctx), null)
+    const graph = rawGraph(ctx)
+    const testsOnly = graph.graphBuildMode === 'tests-only'
+    const includeNonProduct = args.include_non_product === true || testsOnly
+    const classifier = createPathClassifier(ctx?.repoRoot || null)
+    const nonProductFiles = new Set()
+    const classifiedFiles = new Set()
+    if (!includeNonProduct) {
+        for (const node of graph.nodes || []) {
+            if (!node?.source_file) continue
+            const sourceFile = String(node.source_file)
+            if (classifiedFiles.has(sourceFile)) continue
+            classifiedFiles.add(sourceFile)
+            const explanation = classifier.explain(sourceFile)
+            if (explanation.excluded || hasPathClass(explanation, 'test', 'e2e', 'generated', 'mock', 'story', 'docs', 'benchmark', 'temp')) {
+                nonProductFiles.add(sourceFile)
+            }
+        }
+    }
+    const visibleGraph = includeNonProduct || nonProductFiles.size === 0 ? graph : (() => {
+        const keep = new Set((graph.nodes || [])
+            .filter((node) => !node?.source_file || !nonProductFiles.has(String(node.source_file)))
+            .map((node) => String(node.id)))
+        const endpoint = (value) => String(value && typeof value === 'object' ? value.id : value)
+        return {
+            ...graph,
+            nodes: (graph.nodes || []).filter((node) => keep.has(String(node.id))),
+            links: (graph.links || []).filter((link) => keep.has(endpoint(link.source)) && keep.has(endpoint(link.target))),
+        }
+    })()
+    const agg = aggregateGraph(visibleGraph, null)
     const topN = Math.max(1, Math.min(60, Number(args.top_n) || 25))
     const mods = agg.modules.slice(0, topN)
     const edges = agg.moduleEdges.slice(0, Math.min(50, topN * 2))
@@ -458,6 +493,11 @@ export function tModuleMap(g, args, ctx) {
     collectCompileEdges(agg.compileOnlyModuleEdges, 'compileOnly')
     const compiled = [...compileEdges.values()].sort((a, b) => b.count - a.count).slice(0, Math.min(50, topN * 2))
     return [
+        testsOnly
+            ? 'Scope: tests-only graph; classified test/e2e/fixture surfaces are retained automatically.'
+            : includeNonProduct
+            ? 'Scope: all indexed files, including classified non-product surfaces.'
+            : `Scope: production-only (default); excluded ${nonProductFiles.size} classified test/fixture/benchmark/generated/docs file(s). Pass include_non_product:true for the complete graph.`,
         `Module map: ${agg.totals.files} files in ${agg.modules.length} folder-modules, ${agg.totals.moduleEdges} runtime module dependencies and ${agg.totals.compileTimeModuleEdges || 0} compile-time dependencies (${agg.totals.typeOnlyModuleEdges || 0} type-only, ${agg.totals.compileOnlyModuleEdges || 0} compile-only). Top ${mods.length}:`,
         ...mods.map((m) => `  ${m.name} — ${m.fileCount} files, ${m.symbolCount} symbols`),
         ``,

package/src/mcp/tools-impact.mjs

@@ -31,9 +31,11 @@ function reverseReach(g, seeds, maxDepth) {
             }
             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] = e.relation || 'rel'
+            entry[provenanceKey] = e.provenance || 'UNKNOWN'
             states.set(id, entry)
             frontier.push({id, depth, compileOnly})
         }
@@ -43,6 +45,7 @@ function reverseReach(g, seeds, maxDepth) {
         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,
     }]))
 }
 
@@ -86,17 +89,21 @@ export function tGetDependents(g, {label, depth = 3, max_nodes = 40} = {}) {
         note,
         `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)}.` : null,
-        ...shown.map((r) => `  [d${r.d} ${impactKind(r.entry)}] ${r.entry.relation || 'rel'}  ${labelOf(g, r.id)}  (deg ${r.deg})  [${r.id}]`),
+        ...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')
 }
 
 // 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)
+        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)})`
@@ -106,7 +113,17 @@ export async function tGraphDiff(g, args, ctx) {
             return `No previous graph state at ${prevPath} — pass base_ref (for example HEAD~1 or main), or run rebuild_graph to save one automatically.`
         }
     }
-    const current = rawGraph(ctx)
+    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)),
@@ -118,6 +135,7 @@ export async function tGraphDiff(g, args, ctx) {
     } : graph
     return [
         `Graph diff (${baselineLabel} → current)${filter ? `, scoped to ${filter}` : ''}:`,
+        `Build mode: ${currentMode}`,
         formatGraphDiff(diffGraphs(scope(prev), scope(current)))
     ].join('\n')
 }

package/src/mcp-server.mjs

@@ -7,9 +7,10 @@
 // Spawned by Claude Code / Codex as a plain Node child (node mcp-server.mjs <graph.json> <repoRoot>).
 // Speaks newline-delimited JSON-RPC 2.0 over stdio (the MCP stdio transport).
 //
-// .mjs on purpose: guarantees ESM parsing regardless of the nearest package.json. The server itself
-// resolves nothing from node_modules at runtime (ripgrep is probed, with a pure-Node fallback); only
-// the graph BUILDER pulls in web-tree-sitter + its WASM grammars when a build is requested.
+// .mjs on purpose: guarantees ESM parsing regardless of the nearest package.json. Runtime analyzers
+// resolve only dependencies bundled with Weavatrix: web-tree-sitter grammars for graph builds and the
+// pinned TypeScript language server for bounded JS/TS semantic evidence. Repository packages/scripts
+// are never executed to provide either analyzer.
 //
 // STDOUT is the protocol channel — nothing but JSON-RPC frames may be written there. All diagnostics
 // go to stderr. Two argv forms:
@@ -24,8 +25,10 @@ import {graphOutDirForRepo} from './graph/layout.js'
 import {createRequire} from 'node:module'
 import {createStalenessNoticeGate} from './mcp/staleness-notice.mjs'
 import {normalizeToolResult} from './mcp/tool-result.mjs'
-import {buildGraphForRepo} from './build-graph.js'
+import {buildGraphForRepo, defaultPrecisionMode} from './build-graph.js'
 import {persistedFreshnessMatches, repositoryFreshnessProbe} from './graph/freshness-probe.js'
+import {activeLspClientCount, beginLspClientShutdown, shutdownActiveLspClients} from './precision/lsp-client.js'
+import {PRECISION_OVERLAY_V, precisionSemanticInputsMatch, readPrecisionOverlay} from './precision/lsp-overlay.js'
 
 // version comes from package.json so serverInfo can never drift from the published package again
 const PKG_VERSION = (() => { try { return createRequire(import.meta.url)('../package.json').version } catch { return '0.0.0' } })()
@@ -33,6 +36,16 @@ const SERVER_INFO = {name: 'weavatrix', version: PKG_VERSION}
 const DEFAULT_PROTOCOL = '2024-11-05'
 const log = (...a) => process.stderr.write(`[weavatrix] ${a.join(' ')}\n`)
 
+async function settleWithin(promise, timeoutMs) {
+    let timer
+    const settled = await Promise.race([
+        Promise.resolve(promise).then(() => true, () => true),
+        new Promise((resolveSettled) => { timer = setTimeout(() => resolveSettled(false), timeoutMs) }),
+    ])
+    if (timer) clearTimeout(timer)
+    return settled
+}
+
 // argv[2] is a repo DIRECTORY in the npx form — derive the graph location from the standard layout;
 // otherwise it is the graph.json path and the repo root follows it.
 let GRAPH_PATH = process.argv[2]
@@ -77,7 +90,7 @@ async function main() {
     // ctx owns the CURRENT target: rebuild_graph reloads it, open_repo retargets graphPath/repoRoot
     // at runtime. loadInto always reads ctx.graphPath so both paths share one loader.
     const ctx = {graphPath: GRAPH_PATH, repoRoot: REPO_ROOT, reload: null}
-    const loadInto = () => { graph = loadGraph(ctx.graphPath); graphError = null; return graph }
+    const loadInto = () => { graph = loadGraph(ctx.graphPath, {repoRoot: ctx.repoRoot}); graphError = null; return graph }
     ctx.reload = () => { api.resetStalenessCache(); try { return loadInto() } catch (e) { graphError = e.message; return null } }
     try {
         if (!ctx.graphPath) throw new Error('no graph.json path given (argv[2])')
@@ -96,6 +109,8 @@ async function main() {
     // ordinary tools use a per-call graph/context snapshot, so an explicitly retargetable registration
     // cannot mix one repo's in-memory graph with another repo's source root under concurrent MCP calls.
     let targetMutation = Promise.resolve()
+    let shuttingDown = false
+    let shutdownPromise = null
     const refreshProbeCache = new Map()
     const configuredDebounce = process.env.WEAVATRIX_AUTO_REFRESH_DEBOUNCE_MS == null
         ? 2_000
@@ -103,13 +118,31 @@ async function main() {
     const refreshDebounceMs = Math.max(0, Math.min(5_000, Number.isFinite(configuredDebounce) ? configuredDebounce : 2_000))
     const autoRefresh = async (callCtx, currentGraph) => {
         if (!callCtx?.repoRoot || !callCtx?.graphPath) return {graph: null, refresh: null}
-        const probeKey = `${callCtx.graphPath}\0${currentGraph?.graphBuildMode || 'full'}`
+        const activePrecision = currentGraph?.graphPrecisionMode || defaultPrecisionMode()
+        const probeKey = `${callCtx.graphPath}\0${currentGraph?.graphBuildMode || 'full'}\0${activePrecision}`
+        // Semantic inputs include ignored configs and configured project files that Git status does
+        // not see. Check their bounded fingerprint before the ordinary source freshness debounce;
+        // exact evidence must have no stale window, even on back-to-back tool calls.
+        let semanticInputsChanged = false
+        if (activePrecision === 'lsp' && currentGraph) {
+            try {
+                const overlay = readPrecisionOverlay(callCtx.graphPath, currentGraph)
+                semanticInputsChanged = typeof overlay?.semanticInputFingerprint === 'string'
+                    && !precisionSemanticInputsMatch(overlay, callCtx.repoRoot, currentGraph)
+            } catch {
+                semanticInputsChanged = true
+            }
+        }
         const cachedProbe = refreshProbeCache.get(probeKey)
-        if (currentGraph && cachedProbe && Date.now() - cachedProbe.checkedAt < refreshDebounceMs) {
+        if (!semanticInputsChanged && currentGraph && cachedProbe && Date.now() - cachedProbe.checkedAt < refreshDebounceMs) {
             return {graph: currentGraph, refresh: {kind: 'none', revision: currentGraph.graphRevision || null, changedFiles: 0}}
         }
         const beforeProbe = repositoryFreshnessProbe(callCtx.repoRoot)
-        if (beforeProbe && currentGraph && (
+        const precisionMissing = activePrecision === 'lsp' && (
+            Number(currentGraph?.precisionOverlayV) !== PRECISION_OVERLAY_V
+            || semanticInputsChanged
+        )
+        if (!precisionMissing && beforeProbe && currentGraph && (
             cachedProbe?.probe === beforeProbe
             || persistedFreshnessMatches(currentGraph, beforeProbe, currentGraph.graphBuildMode || 'full')
         )) {
@@ -118,12 +151,13 @@ async function main() {
         }
         const result = await buildGraphForRepo(callCtx.repoRoot, {
             mode: currentGraph?.graphBuildMode || 'full',
+            precision: activePrecision,
             scope: '',
             outDir: dirname(callCtx.graphPath),
         })
         if (!result.ok) throw new Error(result.error || 'automatic graph refresh failed')
         api.resetStalenessCache()
-        const fresh = loadGraph(callCtx.graphPath)
+        const fresh = loadGraph(callCtx.graphPath, {repoRoot: callCtx.repoRoot})
         const afterProbe = repositoryFreshnessProbe(callCtx.repoRoot)
         if (afterProbe && afterProbe === beforeProbe) refreshProbeCache.set(probeKey, {probe: afterProbe, checkedAt: Date.now()})
         else refreshProbeCache.delete(probeKey)
@@ -138,10 +172,53 @@ async function main() {
             },
         }
     }
-    const send = (msg) => process.stdout.write(JSON.stringify(msg) + '\n')
+    const send = (msg) => {
+        // A request that was already running when the client disconnected may complete during the
+        // bounded drain. Do not write a late reply into a closed protocol pipe.
+        if (shuttingDown || process.stdout.destroyed || !process.stdout.writable) return false
+        try {
+            return process.stdout.write(JSON.stringify(msg) + '\n')
+        } catch (error) {
+            if (error?.code === 'EPIPE' || error?.code === 'ERR_STREAM_DESTROYED') return false
+            throw error
+        }
+    }
     const reply = (id, result) => send({jsonrpc: '2.0', id, result})
     const fail = (id, code, message) => send({jsonrpc: '2.0', id, error: {code, message}})
 
+    const requestShutdown = (reason, exitCode = 0) => {
+        if (shutdownPromise) return shutdownPromise
+        shuttingDown = true
+        // This is synchronous and deliberately precedes every await: a graph build that reaches its
+        // precision phase during the drain must not create a fresh TLS/tsserver process tree.
+        beginLspClientShutdown()
+        process.stdin.pause()
+        const activeAtStart = activeLspClientCount()
+        log(`shutdown requested (${reason}); draining graph work and ${activeAtStart} semantic provider(s)`)
+        shutdownPromise = (async () => {
+            // Give an ordinary auto-refresh a chance to commit and close its provider itself. A wedged
+            // parse/query is bounded; active semantic children are then closed or tree-killed, after
+            // which the mutation gets a final window to observe that cancellation and release locks.
+            const initiallyDrained = await settleWithin(targetMutation, 2_500)
+            const semantic = await shutdownActiveLspClients({timeoutMs: 3_000})
+            const fullyDrained = initiallyDrained || await settleWithin(targetMutation, 1_500)
+            log(`shutdown cleanup: graph=${fullyDrained ? 'drained' : 'bounded-timeout'}, semantic=${semantic.requested} requested/${semantic.remaining} remaining${semantic.timedOut ? ' (forced)' : ''}`)
+        })().catch((error) => {
+            log(`shutdown cleanup failed: ${error.stack || error.message}`)
+        }).finally(() => {
+            process.exit(exitCode)
+        })
+        return shutdownPromise
+    }
+    process.stdout.on('error', (error) => {
+        if (error?.code === 'EPIPE' || error?.code === 'ERR_STREAM_DESTROYED') {
+            void requestShutdown('stdout disconnected')
+            return
+        }
+        log(`stdout error: ${error.stack || error.message}`)
+        void requestShutdown('stdout error', 1)
+    })
+
     let loadedVersion = hotVersion(catalog.HOT_FILES)
     let lastFailedVersion = 0
     const maybeHotReload = async () => {
@@ -164,6 +241,10 @@ async function main() {
     const handle = async (msg) => {
         const {id, method, params} = msg
         const isNotification = id === undefined || id === null
+        if (shuttingDown) {
+            if (!isNotification) fail(id, -32000, 'MCP server is shutting down')
+            return
+        }
         if (method === 'initialize') {
             if (params?.protocolVersion) protocolVersion = String(params.protocolVersion)
             return reply(id, {protocolVersion, capabilities: {tools: {listChanged: true}}, serverInfo: SERVER_INFO})
@@ -172,10 +253,14 @@ async function main() {
         if (method === 'ping') return reply(id, {})
         if (method === 'tools/list') {
             await maybeHotReload()
+            if (shuttingDown) return
             return reply(id, {tools: api.tools.map(({name, description, inputSchema, outputSchema}) => ({name, description, inputSchema, outputSchema}))})
         }
         if (method === 'tools/call') {
             await maybeHotReload()
+            // EOF can arrive while the hot-reload import is pending. Do not enqueue a graph mutation
+            // after requestShutdown captured the mutation chain it is responsible for draining.
+            if (shuttingDown) return
             const tool = api.byName.get(params?.name)
             if (!tool) return reply(id, {content: [{type: 'text', text: `Unknown tool: ${params?.name}`}], isError: true})
             const refreshesGraph = tool.cap === 'graph' || tool.cap === 'health' || tool.refreshGraph === true
@@ -236,6 +321,7 @@ async function main() {
     let buf = ''
     process.stdin.setEncoding('utf8')
     process.stdin.on('data', (chunk) => {
+        if (shuttingDown) return
         buf += chunk
         let nl
         while ((nl = buf.indexOf('\n')) >= 0) {
@@ -256,7 +342,9 @@ async function main() {
             })
         }
     })
-    process.stdin.on('end', () => process.exit(0))
+    process.stdin.on('end', () => { void requestShutdown('stdin EOF') })
+    process.on('SIGTERM', () => { void requestShutdown('SIGTERM') })
+    process.on('SIGINT', () => { void requestShutdown('SIGINT') })
     log('ready')
 }
 

package/src/path-classification.js

@@ -80,8 +80,8 @@ const DEFAULT_RULES = [
   },
   {
     category: "temp",
-    pattern: "__temp working/generated root",
-    regex: /(^|\/)__temp(\/|$)/i,
+    pattern: "__temp or .tmp-* working/generated root",
+    regex: /(^|\/)(?:__temp|\.tmp(?:[-_][^/]*)?)(\/|$)/i,
   },
 ];