fix(json-parse): scope code-context guard to candidate path suffix

jrusz · jrusz · commit 1d654c4f0e39 · 2026-07-20T21:26:40.000+02:00
Narrows the looksLikeWindowsPathPrefix code-context rejection from scanning the entire 160-character tail to checking only the candidate drive-path match and its immediate predecessor: 1. Reject when the non-alphanumeric separator before the drive letter is a bracket or brace — real paths never start with (X: or {X:. 2. Reject when a block-opening keyword (as, if, in, for, def, etc.) immediately precedes the candidate — 'as f:', 'if r:', 'in d:' are code colons, not drive letters. This preserves Windows path repair when code punctuation appears earlier in the same string value (e.g. python -c 'x'; C:\new). The keyword boundary check uses (?:^|[^A-Za-z0-9]|\\[nrt]) instead of \b because stringValuePrefix tracks prior escapes in their literal textual form — a decoded \n is stored as the two characters \ and n, so keywords starting a new line (like 'if' after a newline) are preceded by 'n' (alphanumeric), not whitespace. Adds regression coverage for code-before-path ordering. Refs #93139 Signed-off-by: Jakub Rusz <jrusz@proton.me>
diff --git a/packages/ai/src/utils/json-parse.ts b/packages/ai/src/utils/json-parse.ts
@@ -110,16 +110,47 @@ export function parseJsonWithRepair(json: string): unknown {
 
 function looksLikeWindowsPathPrefix(prefix: string): boolean {
   const tail = prefix.slice(-160);
-  // Reject obvious code-context markers (parentheses, braces, equals,
-  // semicolons, single-quotes, commas, shell redirects/pipes). A Windows
-  // path tail will not contain these, but a Python/JS/shell block opener
-  // like "if x:" or "for x:" or "def foo(x):" will — and without this
-  // guard we treat the next \n as a path separator and emit a literal
-  // backslash-n instead of a real newline. See issue #93139.
-  if (/[()=;{}',<>|]/.test(tail)) {
+  const m = tail.match(/(^|[^A-Za-z0-9])([A-Za-z]):(?:[\\/][^"\\/:*?<>|\r\n]*)*$/);
+  if (!m) {
     return false;
   }
-  return /(?:^|[^A-Za-z0-9])[A-Za-z]:(?:[\\/][^"\\/:*?<>|\r\n]*)*$/.test(tail);
+
+  // The Windows-path heuristic matches any tail ending in
+  // `<non-alphanum><letter>:` — which also matches Python/shell block
+  // openers like `if x:`, `for x:`, `try:`, `def foo(x):`. Without a
+  // guard we'd treat the next \n as a path separator and emit a literal
+  // backslash-n instead of a real newline. The guard is scoped to the
+  // matched candidate and its immediate predecessor (not the whole tail)
+  // so that code punctuation appearing earlier in the same string — e.g.
+  // `python -c 'x'; C:\new` — doesn't cause a real Windows path later in
+  // the tail to be rejected. See issue #93139.
+
+  // (1) Reject if the separator character before the drive letter is a
+  // bracket or brace — real paths never start with (X: or {X:
+  const sep = m[1] ?? "";
+  if (sep && /[(){}]/.test(sep)) {
+    return false;
+  }
+
+  // (2) Reject if a block-opening keyword immediately precedes the
+  // candidate — "as f:", "if r:", "in d:" are code, not paths. The prefix
+  // tracks prior escapes in their literal textual form (a decoded \n is
+  // stored as the two characters \ and n, not an actual newline), so a
+  // keyword that starts a new line is preceded by a trailing letter
+  // (n/r/t) from that escape, not real whitespace. Treat \n, \r, and \t
+  // as boundaries too, in addition to \b, so "if"/"in"/etc. are still
+  // recognized right after a converted newline/tab/carriage-return.
+  const matchIndex = m.index ?? 0;
+  const beforeCandidate = tail.slice(0, matchIndex + sep.length);
+  if (
+    /(?:^|[^A-Za-z0-9]|\\[nrt])(?:as|if|in|for|def|not|try|else|elif|while|class|with|return|except|finally|match|case)\s*$/.test(
+      beforeCandidate,
+    )
+  ) {
+    return false;
+  }
+
+  return true;
 }
 
 function asStreamingJsonRecord(value: unknown): Record<string, unknown> {
diff --git a/src/llm/utils/json-parse.test.ts b/src/llm/utils/json-parse.test.ts
@@ -81,6 +81,12 @@ describe("json-parse repairJson Windows-path false positives (issue #93139)", ()
       '{"command": "for f in *.py:\\n  echo $f"}',
       "for f in *.py:\n  echo $f",
     ],
+    ["Python match statement", '{"command": "match x:\\n    pass"}', "match x:\n    pass"],
+    [
+      "Python case clause",
+      '{"command": "match x:\\n    case 1:\\n        pass"}',
+      "match x:\n    case 1:\n        pass",
+    ],
   ])("preserves real newlines after Python/shell block openers: %s", (_name, input, expected) => {
     expect(parseJsonWithRepair(input)).toEqual({ command: expected });
     expect(parseStreamingJson(input)).toEqual({ command: expected });
@@ -94,4 +100,13 @@ describe("json-parse repairJson Windows-path false positives (issue #93139)", ()
       text: "see C:\\Users for path; if x:\n    do_stuff()",
     });
   });
+
+  it("preserves a Windows path after code-like command text", () => {
+    // Regression: code punctuation appears before a legitimate Windows
+    // path in the same string. The guard must not reject the whole tail.
+    const input = '{"cmd": "python -c \'x\'; C:\\\\new\\\\file.txt"}';
+    expect(parseJsonWithRepair(input)).toEqual({
+      cmd: "python -c 'x'; C:\\new\\file.txt",
+    });
+  });
 });
