gitnexus 1.6.12-rc.27 → 1.6.12-rc.29

package/dist/mcp/local/local-backend.js

@@ -25,7 +25,7 @@ import { isWalCorruptionError, WAL_RECOVERY_SUGGESTION } from '../../core/lbug/l
 // at MCP server startup — crashes on unsupported Node ABI versions (#89)
 // git utilities available if needed
 // import { isGitRepo, getCurrentCommit, getGitRoot } from '../../storage/git.js';
-import { parseDiffHunks, coalesceHunksByPath, hunksOverlapRange, findGitRootByDotGit, getCanonicalRepoRoot, getGitRoot, } from '../../storage/git.js';
+import { parseDiffHunksResult, coalesceHunksByPath, hunksOverlapRange, findGitRootByDotGit, getCanonicalRepoRoot, getGitRoot, } from '../../storage/git.js';
 import { realpathSync } from 'fs';
 import { listRegisteredRepos, cleanupOldKuzuFiles, canonicalizePath, getStoragePaths, loadMeta, RegistryAmbiguousTargetError, } from '../../storage/repo-manager.js';
 import { GroupService, } from '../../core/group/service.js';
@@ -795,6 +795,12 @@ export function buildDetectChangesDiffArgs(scope, baseRef) {
     // not `--default-prefix`, which needs git >= 2.42. `--no-ext-diff` stops a
     // configured external diff driver from replacing the unified output we parse.
     const args = [
+        // Before the subcommand: default core.quotePath C-quotes non-ASCII so
+        // `diff --git` / `+++` tokens no longer match the unquoted `a/` `b/` forms
+        // the parser also accepts. The parser still decodes quoted tokens; this
+        // pin keeps production git from emitting them.
+        '-c',
+        'core.quotePath=false',
         'diff',
         '--ignore-cr-at-eol',
         '--no-ext-diff',
@@ -4464,10 +4470,10 @@ export class LocalBackend {
         catch (err) {
             return { error: `Git diff failed: ${err.message}` };
         }
-        const fileDiffs = parseDiffHunks(diffOutput);
+        const { files: fileDiffs, unparsedGitHeaders } = parseDiffHunksResult(diffOutput);
         if (fileDiffs.length === 0) {
-            // Git printed a diff but none of it parsed: the `+++ b/` headers were not
-            // where `parseDiffHunks` looks. That is a PARSE failure, not a clean tree,
+            // Git printed a diff but none of it parsed: no `diff --git` / `+++`
+            // file header was recognised. That is a PARSE failure, not a clean tree,
             // and the clean branch below would report it to the pre-commit gate as
             // `risk_level:'none'`, no `partial`, exit 0 — a false all-clear (#2915).
             const parseFailed = diffOutput.trim().length > 0;
@@ -4499,7 +4505,9 @@ export class LocalBackend {
         const changedSymbols = new Map();
         // Set if a swallowed graph query fails below — surfaces `partial:true` so a
         // degraded run cannot report a false-clean `risk_level:'low'` (#2283).
-        let queryDegraded = false;
+        // An unparsed `diff --git` is the same class: later hunks must not make
+        // the gate look complete.
+        let queryDegraded = unparsedGitHeaders > 0;
         // Hunks arrive grouped per path and already in the graph's 0-based line
         // space, so every comparison below is base-neutral (#2377).
         const hunksByPath = coalesceHunksByPath(fileDiffs);

package/dist/storage/git.d.ts

@@ -268,10 +268,20 @@ export interface FileDiff {
     filePath: string;
     hunks: DiffHunk[];
 }
+/** `parseDiffHunks` plus how many `diff --git` headers could not be decoded. */
+export interface DiffHunkParseResult {
+    files: FileDiff[];
+    unparsedGitHeaders: number;
+}
 /**
  * Parse unified diff output (with -U0) into per-file hunk ranges.
  * Extracts the new-file line ranges from @@ hunk headers.
  *
+ * The `diff --git` header is also retained as a file entry. This matters for
+ * binary, rename-only, and mode-only changes, which have no `+++ b/` header.
+ * Such entries intentionally have no hunks: callers can count the changed
+ * path without pretending that a symbol line range was touched.
+ *
  * A pure deletion adds no new lines, and unified diff spells that empty range
  * as the line BEFORE it: `@@ -4,2 +3,0 @@` removed old lines 4–5 from between
  * new lines 3 and 4 (git emits `+0,0` when the deletion is at the head of the
@@ -287,6 +297,13 @@ export interface FileDiff {
  * gap — the widening {@link coalesceHunks} is careful never to do.
  */
 export declare function parseDiffHunks(diffOutput: string): FileDiff[];
+/**
+ * Same as {@link parseDiffHunks}, plus a count of `diff --git` lines that
+ * could not be decoded. `detect_changes` uses the count to fail closed
+ * (`partial` + `risk_level:'unknown'`) instead of attaching later hunks to a
+ * previous file.
+ */
+export declare function parseDiffHunksResult(diffOutput: string): DiffHunkParseResult;
 /**
  * Merge a file's hunks into sorted, non-touching ranges.
  *

package/dist/storage/git.js

@@ -696,10 +696,183 @@ export const parseRepoNameFromUrl = (url) => {
 export const getInferredRepoName = (repoPath) => {
     return parseRepoNameFromUrl(getRemoteOriginUrl(repoPath));
 };
+const DIFF_GIT_PREFIX = 'diff --git ';
+/**
+ * Decode one Git C-quoted token (`"a/\\344\\270\\255.png"`). Returns
+ * `undefined` when the quotes are unbalanced or a trailing escape is bare.
+ */
+function unquoteCStyleGitToken(quoted) {
+    if (quoted.length < 2 || quoted[0] !== '"' || quoted[quoted.length - 1] !== '"') {
+        return undefined;
+    }
+    // Git C-quotes are byte-oriented: non-ASCII is `\nnn` octal of the UTF-8
+    // code units, not JS UTF-16 characters.
+    const bytes = [];
+    const pushChar = (ch) => {
+        const code = ch.charCodeAt(0);
+        if (code < 0x80)
+            bytes.push(code);
+        else
+            bytes.push(...new TextEncoder().encode(ch));
+    };
+    for (let i = 1; i < quoted.length - 1; i++) {
+        const ch = quoted[i];
+        if (ch !== '\\') {
+            pushChar(ch);
+            continue;
+        }
+        const next = quoted[++i];
+        if (next === undefined)
+            return undefined;
+        switch (next) {
+            case '\\':
+            case '"':
+                pushChar(next);
+                break;
+            case 'n':
+                bytes.push(0x0a);
+                break;
+            case 't':
+                bytes.push(0x09);
+                break;
+            case 'r':
+                bytes.push(0x0d);
+                break;
+            case 'a':
+                bytes.push(0x07);
+                break;
+            case 'b':
+                bytes.push(0x08);
+                break;
+            case 'v':
+                bytes.push(0x0b);
+                break;
+            case 'f':
+                bytes.push(0x0c);
+                break;
+            default: {
+                if (next < '0' || next > '7') {
+                    pushChar(next);
+                    break;
+                }
+                let oct = next;
+                while (oct.length < 3 && i + 1 < quoted.length - 1) {
+                    const digit = quoted[i + 1];
+                    if (digit < '0' || digit > '7')
+                        break;
+                    oct += digit;
+                    i++;
+                }
+                bytes.push(parseInt(oct, 8));
+            }
+        }
+    }
+    return new TextDecoder('utf-8').decode(Uint8Array.from(bytes));
+}
+function takeCQuotedToken(source, start) {
+    if (source[start] !== '"')
+        return undefined;
+    for (let i = start + 1; i < source.length; i++) {
+        if (source[i] === '\\') {
+            i++;
+            continue;
+        }
+        if (source[i] === '"')
+            return { token: source.slice(start, i + 1), end: i + 1 };
+    }
+    return undefined;
+}
+function stripGitDstPrefix(raw) {
+    return raw.startsWith('b/') ? raw.slice(2) : undefined;
+}
+/** Unified-diff paths end at the first TAB (timestamp / empty terminator). */
+function stripUnifiedDiffTab(pathWithOptionalTab) {
+    const tab = pathWithOptionalTab.indexOf('\t');
+    return tab === -1 ? pathWithOptionalTab : pathWithOptionalTab.slice(0, tab);
+}
+function decodeGitPathToken(raw) {
+    const trimmed = stripUnifiedDiffTab(raw);
+    if (trimmed.startsWith('"'))
+        return unquoteCStyleGitToken(trimmed);
+    return trimmed;
+}
+/**
+ * Destination path from `diff --git a/<src> b/<dst>`.
+ *
+ * Same-path headers recover `name` from `a/${name} b/${name}` so a dest that
+ * itself contains ` b/` is not split at the last occurrence. C-quoted tokens
+ * (default `core.quotePath`) are decoded. Renames that the greedy split would
+ * mis-parse stay a best-effort dest; `rename to` / `+++` correct them.
+ */
+function takeGitHeaderPathToken(source, start) {
+    if (start >= source.length)
+        return undefined;
+    if (source[start] === '"') {
+        const tok = takeCQuotedToken(source, start);
+        if (!tok)
+            return undefined;
+        const path = unquoteCStyleGitToken(tok.token);
+        if (path === undefined)
+            return undefined;
+        return { path, end: tok.end };
+    }
+    if (source.startsWith('b/', start)) {
+        return { path: stripUnifiedDiffTab(source.slice(start)), end: source.length };
+    }
+    if (source.startsWith('a/', start)) {
+        for (let i = start + 2; i < source.length; i++) {
+            if (source.startsWith(' b/', i) || source.startsWith(' "', i)) {
+                return { path: source.slice(start, i), end: i };
+            }
+        }
+    }
+    return undefined;
+}
+function filePathFromGitHeader(line) {
+    if (!line.startsWith(DIFF_GIT_PREFIX))
+        return undefined;
+    const rest = line.slice(DIFF_GIT_PREFIX.length);
+    if (rest.startsWith('a/')) {
+        for (let i = 2; i < rest.length; i++) {
+            if (!rest.startsWith(' b/', i))
+                continue;
+            const nameA = rest.slice(2, i);
+            const nameB = rest.slice(i + 3);
+            if (nameA.length > 0 && nameA === nameB)
+                return nameA;
+        }
+    }
+    const src = takeGitHeaderPathToken(rest, 0);
+    if (!src)
+        return undefined;
+    let i = src.end;
+    while (rest[i] === ' ')
+        i++;
+    const dest = takeGitHeaderPathToken(rest, i);
+    return dest ? stripGitDstPrefix(dest.path) : undefined;
+}
+function pathFromPlusPlusPlus(line) {
+    if (!line.startsWith('+++ '))
+        return undefined;
+    const raw = decodeGitPathToken(line.slice(4));
+    if (!raw || raw === '/dev/null')
+        return undefined;
+    return stripGitDstPrefix(raw);
+}
+function pathFromRenameTo(line) {
+    if (!line.startsWith('rename to '))
+        return undefined;
+    return decodeGitPathToken(line.slice('rename to '.length));
+}
 /**
  * Parse unified diff output (with -U0) into per-file hunk ranges.
  * Extracts the new-file line ranges from @@ hunk headers.
  *
+ * The `diff --git` header is also retained as a file entry. This matters for
+ * binary, rename-only, and mode-only changes, which have no `+++ b/` header.
+ * Such entries intentionally have no hunks: callers can count the changed
+ * path without pretending that a symbol line range was touched.
+ *
  * A pure deletion adds no new lines, and unified diff spells that empty range
  * as the line BEFORE it: `@@ -4,2 +3,0 @@` removed old lines 4–5 from between
  * new lines 3 and 4 (git emits `+0,0` when the deletion is at the head of the
@@ -715,14 +888,58 @@ export const getInferredRepoName = (repoPath) => {
  * gap — the widening {@link coalesceHunks} is careful never to do.
  */
 export function parseDiffHunks(diffOutput) {
+    return parseDiffHunksResult(diffOutput).files;
+}
+/**
+ * Same as {@link parseDiffHunks}, plus a count of `diff --git` lines that
+ * could not be decoded. `detect_changes` uses the count to fail closed
+ * (`partial` + `risk_level:'unknown'`) instead of attaching later hunks to a
+ * previous file.
+ */
+export function parseDiffHunksResult(diffOutput) {
     const files = [];
     let current = null;
+    let unparsedGitHeaders = 0;
+    // `+++` after the first `@@` of a file is hunk body (`+` plus source text
+    // that itself starts `++ …`), not another file header.
+    let inHunk = false;
     for (const line of diffOutput.split('\n')) {
-        if (line.startsWith('+++ b/')) {
-            current = { filePath: line.slice(6), hunks: [] };
-            files.push(current);
+        if (line.startsWith(DIFF_GIT_PREFIX)) {
+            // Drop the previous file first: an unparsed header must not leave
+            // `current` live for a later `@@` / quoted `+++` to steal.
+            current = null;
+            inHunk = false;
+            const filePath = filePathFromGitHeader(line);
+            if (filePath) {
+                current = { filePath, hunks: [] };
+                files.push(current);
+            }
+            else {
+                unparsedGitHeaders++;
+            }
+        }
+        else if (line.startsWith('rename to ')) {
+            const filePath = pathFromRenameTo(line);
+            if (!filePath)
+                continue;
+            if (current)
+                current.filePath = filePath;
+            else {
+                current = { filePath, hunks: [] };
+                files.push(current);
+            }
+        }
+        else if (!inHunk && line.startsWith('+++ ')) {
+            const filePath = pathFromPlusPlusPlus(line);
+            if (!filePath)
+                continue;
+            if (!current || current.filePath !== filePath) {
+                current = { filePath, hunks: [] };
+                files.push(current);
+            }
         }
         else if (line.startsWith('@@') && current) {
+            inHunk = true;
             const match = line.match(/@@ -\d+(?:,\d+)? \+(\d+)(?:,(\d+))? @@/);
             if (match) {
                 const start = parseInt(match[1], 10);
@@ -739,7 +956,7 @@ export function parseDiffHunks(diffOutput) {
             }
         }
     }
-    return files;
+    return { files, unparsedGitHeaders };
 }
 /**
  * Merge a file's hunks into sorted, non-touching ranges.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gitnexus",
-  "version": "1.6.12-rc.27",
+  "version": "1.6.12-rc.29",
   "description": "Graph-powered code intelligence for AI agents. Index any codebase, query via MCP or CLI.",
   "author": "Abhigyan Patwari",
   "license": "PolyForm-Noncommercial-1.0.0",