weavatrix 0.3.0 → 0.3.1

package/README.md

@@ -413,6 +413,19 @@ metrics are not persisted or transmitted by Weavatrix. If a source checkout's pa
 while an old daemon remains alive, `initialize`, `tools/list`, and tool calls fail loudly with
 `STALE_RUNTIME` until the client reconnects; the opt-out is reserved for deliberate development.
 
+### 0.3.1 exact impact over oversized diffs
+
+- `change_impact` now recovers a bounded per-file unified diff when one large asset exceeds the
+  aggregate diff budget. Normal source files retain line/symbol classification; only the files that
+  individually exceed the budget stay conservative `unknown`.
+- Real Hosted dogfood recovered all 27 changed paths, mapped 57 changed symbols, reduced the
+  conservative seed set from 1,000 to 72, and verified exact direct references for 16/16 selected
+  JavaScript/TypeScript symbols. Transitive hops remain explicitly graph-backed.
+- The global LSP overlay remains a bounded prewarm and can honestly be `PARTIAL`; `get_dependents`,
+  `inspect_symbol`, and `change_impact` run revision-bound exact point/batch queries beyond that cap.
+
+Full patch notes: [docs/releases/v0.3.1.md](docs/releases/v0.3.1.md).
+
 ### 0.3.0 network-free core and exact dependency evidence
 
 - The MIT package now contains 34 local tools and no outbound HTTP implementation. Online OSV,
@@ -423,8 +436,8 @@ while an old daemon remains alive, `initialize`, `tools/list`, and tool calls fa
 - Maven/Gradle imports map to exact class ownership from already installed JARs. Missing JARs,
   unresolved build expressions and heuristic fallbacks are `PARTIAL`, never a false `COMPLETE`.
 - Real self-dogfood produced persisted `EXACT_LSP` edges and an exact direct caller for
-  `startMcpServer`; GraphQL, gRPC and event/Kafka contract joins remain explicit about dynamic
-  `UNKNOWN` targets.
+  `startMcpServer`. GraphQL, gRPC and event/Kafka joins use static evidence plus revision-bound
+  runtime/OTLP observations; unobserved dynamic targets remain explicit `UNKNOWN`.
 
 Full patch notes: [docs/releases/v0.3.0.md](docs/releases/v0.3.0.md).
 

package/docs/releases/v0.3.1.md

@@ -0,0 +1,30 @@
+# Weavatrix 0.3.1
+
+0.3.1 fixes a dogfood-discovered blind spot in symbol-aware change impact when
+one generated or snapshot asset makes the aggregate Git diff exceed its byte
+budget.
+
+## Bounded large-diff recovery
+
+- `change_impact` first keeps its normal bounded zero-context diff.
+- If that aggregate diff is oversized, it obtains the complete bounded changed-
+  file list and recovers zero-context diffs one file at a time under the same
+  global byte and time budgets.
+- Source files that fit retain line and symbol classification. Only individual
+  oversized, timed-out or otherwise unreadable files become conservative
+  `unknown` seeds.
+- The result remains `PARTIAL/HIGH` while any file lacks textual evidence; the
+  fallback improves useful evidence without turning unknown into clean.
+
+## Exact semantic evidence
+
+The global TypeScript/JavaScript LSP overlay is a bounded prewarm and may report
+`PARTIAL` on large repositories. Exact workflows are not limited by that global
+cap: `get_dependents` and `inspect_symbol` use revision-bound point queries, and
+`change_impact` uses one bounded exact batch for changed symbols.
+
+On the Hosted 0.3 release commit, the repaired fallback recovered 27/27 changed
+paths and 57 mapped symbol changes, reduced the conservative seed set from the
+1,000 cap to 72, and produced `DIRECT_EXACT_TRANSITIVE_GRAPH` with 16/16 selected
+JS/TS symbols verified by `typescript-language-server`. The remaining large
+snapshot assets stayed explicit `unknown`; transitive hops stayed graph-backed.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "weavatrix",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "type": "module",
   "description": "Local repository intelligence MCP for AI coding agents: reusable architecture graph for fast application understanding, Health, dead code, clones, history, blast radius and architecture safeguards.",
   "author": "Sergii Ziborov <sergii.ziborov@gmail.com>",
@@ -34,6 +34,7 @@
     "docs/agent-task-benchmark.md",
     "docs/adr/0001-v0.3-offline-online-split.md",
     "docs/releases/v0.3.0.md",
+    "docs/releases/v0.3.1.md",
     "docs/releases/v0.2.19.md",
     "README.md",
     "SECURITY.md",

package/src/analysis/change-classification.js

@@ -22,6 +22,34 @@ export {CHANGE_CLASSIFICATION_LIMITS} from './change-classification/options.js'
 
 const VERDICT_RANK = Object.freeze({LOW: 0, MEDIUM: 1, HIGH: 2})
 
+function recoverBoundedDiff(repoRoot, base, files, limits) {
+    const deadline = Date.now() + 12_000
+    let text = ''
+    const fallbackFiles = []
+    for (let index = 0; index < files.length; index++) {
+        const remainingMs = deadline - Date.now()
+        const remainingBytes = limits.maxDiffBytes - Buffer.byteLength(text)
+        if (remainingMs <= 0 || remainingBytes < 1_024) {
+            fallbackFiles.push(...files.slice(index))
+            break
+        }
+        const result = spawnSync('git', [
+            '-C', repoRoot, 'diff', '--no-ext-diff', '--find-renames', '--no-color',
+            '--unified=0', String(base), '--', files[index],
+        ], {
+            encoding: 'utf8', windowsHide: true, timeout: Math.min(2_000, remainingMs),
+            maxBuffer: remainingBytes + 1, env: childProcessEnv(),
+        })
+        const chunk = String(result.stdout || '')
+        if (result.status !== 0 || !chunk || Buffer.byteLength(chunk) > remainingBytes) {
+            fallbackFiles.push(files[index])
+            continue
+        }
+        text += chunk
+    }
+    return {text, fallbackFiles}
+}
+
 function runGitDiff(repoRoot, base, limits) {
     const args = ['-C', repoRoot, 'diff', '--no-ext-diff', '--find-renames', '--no-color', '--unified=0', String(base), '--']
     const result = spawnSync('git', args, {
@@ -30,10 +58,32 @@ function runGitDiff(repoRoot, base, limits) {
     })
     if (result.status === 0) return {available: true, text: String(result.stdout || ''), error: null}
     const oversized = result.error?.code === 'ENOBUFS' || Buffer.byteLength(String(result.stdout || '')) > limits.maxDiffBytes
+    let fallbackFiles = []
+    let fallbackTruncated = false
+    let recoveredText = ''
+    if (oversized) {
+        const names = spawnSync('git', [
+            '-C', repoRoot, 'diff', '--name-only', '-z', '--no-ext-diff', '--find-renames', String(base), '--',
+        ], {
+            encoding: 'utf8', windowsHide: true, timeout: 12_000,
+            maxBuffer: Math.max(64 * 1024, limits.maxFiles * 4_096), env: childProcessEnv(),
+        })
+        if (names.status === 0) {
+            const all = String(names.stdout || '').split('\0').map(normalizeChangePath).filter(Boolean)
+            const boundedFiles = [...new Set(all)].sort((a, b) => a.localeCompare(b)).slice(0, limits.maxFiles)
+            fallbackTruncated = all.length > limits.maxFiles
+            const recovered = recoverBoundedDiff(repoRoot, base, boundedFiles, limits)
+            recoveredText = recovered.text
+            fallbackFiles = recovered.fallbackFiles
+        }
+    }
     return {
-        available: false,
-        text: String(result.stdout || ''),
+        available: recoveredText.length > 0,
+        text: recoveredText,
         oversized,
+        partialFallback: recoveredText.length > 0,
+        fallbackFiles,
+        fallbackTruncated,
         error: oversized
             ? 'git diff exceeded the byte limit'
             : String(result.stderr || result.error?.message || 'git diff unavailable').trim(),
@@ -49,11 +99,17 @@ function collectDiffInput({diffText, repoRoot, base, explicitFiles, limits}) {
     if (typeof diffText === 'string') return {source: 'provided-diff', available: true, text: diffText, reason: '', oversized: false}
     if (repoRoot && base) {
         const result = runGitDiff(repoRoot, base, limits)
-        return {source: 'git-diff', available: result.available, text: result.text, reason: result.error || '', oversized: result.oversized === true}
+        return {
+            source: 'git-diff', available: result.available, text: result.text,
+            reason: result.error || '', oversized: result.oversized === true,
+            fallbackFiles: result.fallbackFiles || [], fallbackTruncated: result.fallbackTruncated === true,
+            partialFallback: result.partialFallback === true,
+        }
     }
     return {
         source: 'files-only', available: false, text: '', oversized: false,
         reason: 'no unified diff was provided and no repoRoot/base pair was available',
+        fallbackFiles: [], fallbackTruncated: false, partialFallback: false,
     }
 }
 
@@ -78,6 +134,7 @@ export function classifyChangeImpact({
     const limits = changeLimits(requestedLimits)
     const explicitFiles = validExplicitFiles(files)
     const input = collectDiffInput({diffText, repoRoot, base, explicitFiles, limits})
+    const fallbackFiles = validExplicitFiles([...explicitFiles, ...(input.fallbackFiles || [])]).slice(0, limits.maxFiles)
     const indexed = indexChangeGraph(graph, limits)
     const pathClassifier = createPathClassifier(repoRoot)
     const parsed = input.available
@@ -85,15 +142,16 @@ export function classifyChangeImpact({
         : {files: [], changedLines: 0, byteLength: 0, truncated: input.oversized, oversized: input.oversized, limits}
     const analyzed = parsed.files.map((file) => classifyTestSurface(analyzeParsedFile(file, indexed, {includeAddedSeeds}), pathClassifier))
     const represented = new Set(analyzed.flatMap((file) => [file.oldPath, file.newPath].filter(Boolean)))
-    for (const file of explicitFiles) if (!represented.has(file)) analyzed.push(classifyTestSurface(
+    for (const file of fallbackFiles) if (!represented.has(file)) analyzed.push(classifyTestSurface(
         unknownChangedFile(file, indexed, input.available ? 'explicitly changed file had no textual hunk' : input.reason),
         pathClassifier,
     ))
-    if (!input.available && !explicitFiles.length) analyzed.push(unknownChangedFile('(diff unavailable)', indexed, input.reason))
+    if (!input.available && !fallbackFiles.length) analyzed.push(unknownChangedFile('(diff unavailable)', indexed, input.reason))
     analyzed.sort((a, b) => a.path.localeCompare(b.path))
 
-    const incomplete = parsed.truncated || parsed.oversized || input.oversized
-    if (incomplete) for (const file of analyzed) {
+    const incomplete = parsed.truncated || parsed.oversized || input.oversized || input.fallbackTruncated
+    const parsedEvidenceIncomplete = parsed.truncated || parsed.oversized || (input.oversized && !input.partialFallback)
+    if (parsedEvidenceIncomplete) for (const file of analyzed) {
         if (file.classification === 'test-only') continue
         file.classification = 'unknown'
         file.reason = 'diff was truncated/oversized; symbol-level classification is incomplete'
@@ -108,11 +166,11 @@ export function classifyChangeImpact({
             ? 'HIGH' : file.classification === 'body-changed' ? 'MEDIUM' : 'LOW'
         if (VERDICT_RANK[next] > VERDICT_RANK[verdict]) verdict = next
     }
-    if (!input.available || parsed.truncated || seeds.truncated) verdict = 'HIGH'
+    if (!input.available || input.oversized || parsed.truncated || seeds.truncated) verdict = 'HIGH'
     const counts = Object.fromEntries(Object.keys(CHANGE_CLASS_RANK)
         .map((name) => [name, analyzed.filter((file) => file.classification === name).length]))
     return {
-        ok: input.available && !parsed.truncated && !seeds.truncated,
+        ok: input.available && !input.oversized && !parsed.truncated && !seeds.truncated,
         source: input.source,
         verdict,
         reasons: classificationReasons(counts, {
@@ -130,6 +188,10 @@ export function classifyChangeImpact({
             seeds: seeds.items.length,
             totalSeedsBeforeCap: seeds.total,
         },
-        bounds: {...limits, diffBytes: parsed.byteLength, changedLines: parsed.changedLines, truncated: !!parsed.truncated || seeds.truncated},
+        bounds: {
+            ...limits, diffBytes: parsed.byteLength, changedLines: parsed.changedLines,
+            fallbackFiles: input.fallbackFiles?.length || 0,
+            truncated: input.oversized === true || !!parsed.truncated || seeds.truncated || input.fallbackTruncated === true,
+        },
     }
 }