weavatrix 0.3.8 → 0.3.10

package/src/mcp/tools-graph-hubs.mjs

@@ -12,6 +12,7 @@ export function tGodNodes(g, {top_n = 10, include_classified = false} = {}, ctx
     const classificationByFile = new Map()
     const isNonProduct = (node) => {
         if (include_classified === true) return false
+        if (node?.test_surface === true) return true
         const file = sourceFileOf(node)
         if (!file) return false
         if (!classificationByFile.has(file)) classificationByFile.set(file, classifier.explain(file))

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

@@ -1,7 +1,6 @@
 // Symbol-aware change_impact implementation, isolated from the other hot impact tools so its
 // classifier/evidence contract can be tested without perturbing get_dependents or graph_diff.
-import {spawnSync} from 'node:child_process'
-import {childProcessEnv} from '../child-env.js'
+import {runGit} from '../git-exec.js'
 import {fileOfId} from '../graph/node-id.js'
 import {classifyChangeImpact} from '../analysis/change-classification.js'
 import {readCoverageForRepo} from '../analysis/coverage-reports.js'
@@ -12,7 +11,7 @@ import {gitLines} from './git-output.mjs'
 import {toolResult} from './tool-result.mjs'
 
 function gitValue(repoRoot, args) {
-    const result = spawnSync('git', ['-C', repoRoot, ...args], {encoding: 'utf8', timeout: 8000, env: childProcessEnv()})
+    const result = runGit(repoRoot, args)
     if (result.status !== 0) return null
     return String(result.stdout || '').trim() || null
 }

package/src/mcp/tools-impact.mjs

@@ -87,10 +87,18 @@ export function tGetDependents(g, args = {}, ctx = {}) {
                     `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,
-                `Semantic precision: ${result.overlay?.state || 'UNAVAILABLE'}; exact absence was not proven, so graph edges are retained (${result.overlay?.reason || 'incomplete project coverage'}).`,
+                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(

package/src/mcp-rg.mjs

@@ -1,9 +1,7 @@
 import { readdirSync, existsSync } from 'node:fs'
 import { join } from 'node:path'
-import { spawnSync } from 'node:child_process'
-import { childProcessEnv } from './child-env.js'
 import { createRequire } from 'node:module'
-import process from 'node:process'
+import { runCommandSync } from './process.js'
 
 const rgInInstall = (base) => [
     join(base, 'resources', 'app', 'node_modules', '@vscode', 'ripgrep', 'bin', 'rg.exe'),
@@ -43,7 +41,7 @@ export function createRgResolver(selfDir) {
         } catch { /* optional packaged ripgrep path */ }
         for (const c of editorRgCandidates()) if (existsSync(c)) return (rgPath = c)
         try {
-            const probe = spawnSync(process.platform === 'win32' ? 'where' : 'which', ['rg'], {encoding: 'utf8', env: childProcessEnv(), timeout: 3000, windowsHide: true})
+            const probe = runCommandSync(process.platform === 'win32' ? 'where' : 'which', ['rg'], {timeout: 3000})
             const p = probe.status === 0 ? probe.stdout.split(/\r?\n/)[0].trim() : ''
             if (p && existsSync(p)) return (rgPath = p)
         } catch { /* optional PATH probe */ }

package/src/mcp-source-tools.mjs

@@ -1,8 +1,7 @@
 import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs'
-import { spawnSync } from 'node:child_process'
 import { extname, isAbsolute, join, relative, resolve } from 'node:path'
 import { resolveRepoPath } from './repo-path.js'
-import { childProcessEnv } from './child-env.js'
+import { runCommandSync } from './process.js'
 import { toolResult } from './mcp/tool-result.mjs'
 
 const SEARCH_SKIP = new Set(['.git', 'node_modules', 'dist', 'build', 'out', '.next', 'coverage', 'vendor', '.venv', 'venv', 'env', 'target', '__pycache__', '.idea', '.vscode', '.cache', 'bin', 'obj', 'weavatrix-graphs'])
@@ -11,7 +10,7 @@ const MAX_SEARCH_FILE_BYTES = 1024 * 1024
 const MAX_SOURCE_FILE_BYTES = 2 * 1024 * 1024
 const MAX_SOURCE_CONTEXT_LINES = 1000
 
-function rgSearch(repoRoot, resolveRg, query, { isRegex, glob, maxResults }, spawnRg = spawnSync) {
+function rgSearch(repoRoot, resolveRg, query, { isRegex, glob, maxResults }, spawnRg = runCommandSync) {
     const rg = resolveRg()
     if (!rg) return null
     // Exclude node_modules explicitly: --hidden + the default gitignore stack is the only thing that
@@ -24,7 +23,7 @@ function rgSearch(repoRoot, resolveRg, query, { isRegex, glob, maxResults }, spa
     // against repository-relative paths on Windows too. Passing an absolute search root makes rg
     // compare the glob with a drive-prefixed path and silently return no matches.
     args.push('--', query, '.')
-    const res = spawnRg(rg, args, { cwd: repoRoot, encoding: 'utf8', maxBuffer: 16 * 1024 * 1024, timeout: 15000, env: childProcessEnv() })
+    const res = spawnRg(rg, args, { cwd: repoRoot, encoding: 'utf8', maxBuffer: 16 * 1024 * 1024, timeout: 15000 })
     if (res.status !== 0 && res.status !== 1) return null
     const out = []
     for (const line of (res.stdout || '').split(/\r?\n/)) {
@@ -93,7 +92,7 @@ function nodeGrep(repoRoot, query, { isRegex, glob, maxResults }) {
     return out
 }
 
-export function searchCode({ repoRoot, resolveRg, spawnRg = spawnSync }, { query, is_regex = false, max_results = 40, glob } = {}) {
+export function searchCode({ repoRoot, resolveRg, spawnRg = runCommandSync }, { query, is_regex = false, max_results = 40, glob } = {}) {
     if (!query) return 'Provide a "query" string.'
     if (!repoRoot || !existsSync(repoRoot)) return 'Source search unavailable: repo root not provided to this MCP server.'
     const max = Math.max(1, Math.min(200, Number(max_results) || 40))

package/src/precision/lsp-overlay/build.js

@@ -39,7 +39,9 @@ function coverage(session, verifiedEdges = session.links.length) {
 }
 
 function completedOverlay(session) {
-  const state = session.errors || session.truncated || session.unclassifiedReferences
+  // Coherence guard: COMPLETE must mean every selected target was actually probed.
+  const underQueried = session.queried < session.targets.length
+  const state = session.errors || session.truncated || session.unclassifiedReferences || underQueried
     ? 'PARTIAL' : 'COMPLETE'
   return baseOverlay(session.graph, state, {
     request: session.request,
@@ -67,7 +69,9 @@ function completedOverlay(session) {
     ...(session.errors ? {reason: `${session.errors} semantic request(s) failed or were refused`}
       : session.truncated ? {reason: 'semantic precision stopped at a configured safety limit'}
         : session.unclassifiedReferences
-          ? {reason: 'some exact references could not be classified as runtime or type-only'} : {}),
+          ? {reason: 'some exact references could not be classified as runtime or type-only'}
+          : underQueried
+            ? {reason: 'semantic precision stopped before probing every selected target'} : {}),
   })
 }
 
@@ -185,14 +189,15 @@ export async function buildLspPrecisionOverlay({
   }
   if (graphPath) {
     const cached = readPrecisionOverlay(graphPath, graph)
-    if (cached?.state === 'COMPLETE'
+    // NONE (no eligible targets) is as stable as COMPLETE for an unchanged fingerprint.
+    if ((cached?.state === 'COMPLETE' || cached?.state === 'NONE')
       && precisionOverlayMatches(cached, graph, {request: session.request})
       && cached.semanticInputFingerprint === session.semanticInputs.fingerprint) return cached
   }
   session.eligible = eligibleTargets(graph, session.boundedMax, targetIds)
   session.targets = session.eligible.targets
   if (!session.targets.length) {
-    return persist(session, baseOverlay(graph, 'COMPLETE', {
+    return persist(session, baseOverlay(graph, 'NONE', {
       request: session.request,
       semanticInputFingerprint: session.semanticInputs.fingerprint,
       pluginPolicy: {

package/src/precision/lsp-overlay/contract.js

@@ -1,6 +1,6 @@
 import {typeScriptLspContract} from '../typescript-lsp-provider.js'
 
-export const PRECISION_OVERLAY_V = 4
+export const PRECISION_OVERLAY_V = 5
 export const PRECISION_FILE = 'precision.json'
 export const JS_TS_FILE = /\.(?:[cm]?[jt]sx?)$/i
 export const endpoint = (value) => String(value && typeof value === 'object' ? value.id : value)

package/src/precision/lsp-overlay/target-index.js

@@ -99,10 +99,15 @@ export function eligibleTargets(graph, limit, requestedIds = null) {
   const byId = new Map((graph.nodes || []).map((node) => [String(node.id), node]))
   if (Array.isArray(requestedIds) && requestedIds.length) {
     const ids = [...new Set(requestedIds.map(String))]
-    const targets = ids.map((id) => byId.get(id))
+    const eligible = ids.map((id) => byId.get(id))
       .filter((node) => node?.selection_start && JS_TS_FILE.test(String(node.source_file || '')))
-      .slice(0, limit)
-    return {targets, total: ids.length, orphanIds: new Set()}
+    // total counts only eligible targets so coverage fractions stay honest when ids were dropped.
+    return {
+      targets: eligible.slice(0, limit),
+      total: eligible.length,
+      droppedRequested: ids.length - eligible.length,
+      orphanIds: new Set(),
+    }
   }
   const ranked = new Map()
   const inbound = new Set()

package/src/precision/symbol-query.js

@@ -75,7 +75,8 @@ async function storeEntry(path, entry) {
 }
 
 function cacheable(overlay) {
-    if (overlay?.state === 'COMPLETE') return true
+    // NONE is stable for the fingerprint, but only COMPLETE ever proves absence (see reader below).
+    if (overlay?.state === 'COMPLETE' || overlay?.state === 'NONE') return true
     return overlay?.state === 'PARTIAL'
         && overlay?.reason === 'semantic precision stopped at a configured safety limit'
 }

package/src/process.js

@@ -1,5 +1,5 @@
 // Subprocess runner shared by the search engines and security sweeps.
-import { spawn } from "node:child_process";
+import { spawn, spawnSync } from "node:child_process";
 import { childProcessEnv } from "./child-env.js";
 
 // Windows: .cmd/.ps1 shims (npx, etc.) can't be spawned directly by Node — they need a
@@ -76,3 +76,20 @@ export function runCommand(command, args = [], options = {}) {
     child.on("close", (code) => finish(() => (timedOut ? reject(new Error("Command timed out")) : resolve({ stdout, stderr, exitCode: code }))));
   });
 }
+
+// Synchronous run-and-collect variant for callers that resolve a real binary and read its output in
+// one shot (ripgrep resolution/search, tar extraction). These launch a resolved .exe or bare binary
+// directly, so no shell quoting is needed; the child env is stripped of connector secrets and a
+// bounded timeout/buffer applies. Returns the raw spawnSync result ({status, stdout, stderr, error}).
+export function runCommandSync(command, args = [], options = {}) {
+  const spawnOptions = {
+    cwd: options.cwd || undefined,
+    encoding: options.encoding ?? "utf8",
+    env: childProcessEnv(options.env),
+    windowsHide: true,
+  };
+  if (options.timeout != null) spawnOptions.timeout = options.timeout;
+  if (options.maxBuffer != null) spawnOptions.maxBuffer = options.maxBuffer;
+  if (options.stdio != null) spawnOptions.stdio = options.stdio;
+  return spawnSync(command, args, spawnOptions);
+}