@wrongstack/core 0.9.19 → 0.9.20

package/dist/utils/index.d.ts

@@ -1,4 +1,4 @@
-import { N as TodoItem, M as Message, J as JSONSchema } from '../context-BRNbHmRM.js';
+import { N as TodoItem, M as Message, J as JSONSchema } from '../context-zkZeILpr.js';
 export { W as WstackPathOptions, a as WstackPaths, p as projectHash, r as resolveWstackPaths } from '../wstack-paths-BCgmTNlG.js';
 
 interface AtomicWriteOptions {
@@ -255,12 +255,24 @@ declare function compileUserRegex(pattern: string, flags: string): CompileResult
 
 /**
  * Attempt to close an incomplete JSON object string by auto-closing braces
- * and completing any unclosed double-quoted string values. This handles the
- * common streaming truncation case where the JSON stream ends mid-object
- * (e.g. `{"old_string": "line1\nline2` without the closing `"}` and `}`).
+ * and completing any unclosed double-quoted string values.
  *
- * Returns the completed string on best-effort, or the original if no useful
- * salvage was possible.
+ * Strategy:
+ * 1. Compute origOpen from the ORIGINAL input (how many braces are unclosed).
+ * 2. Add that many closing braces. If result is now valid JSON → return it.
+ * 3. If still invalid: trim trailing whitespace, strip trailing backslash.
+ * 4. Walk backwards to detect an unclosed string value.
+ *    - Quote followed by `:` → key-name, skip
+ *    - Quote followed by `,` `}` or end-of-string → toggle in/out of string
+ * 5. If we end INSIDE a string (unclosed opening `"`), append `"` + origOpen `}`.
+ *
+ * Known limitations:
+ * - Strings whose content ends with a `"` character cannot be repaired
+ *   (algorithm can't distinguish content-`"` from string-terminator `"`).
+ * - Input ending in bare `:` (incomplete value expression) can't be meaningfully repaired.
+ * - Bare `{` returns unchanged.
+ * - If origOpen=0 (braces balanced) but string is unclosed, repair is skipped
+ *   (the input would be valid JSON per JSON.parse, so it's returned as-is).
  */
 declare function completePartialObject(s: string): string;
 

package/dist/utils/index.js

@@ -959,80 +959,85 @@ function compileUserRegex(pattern, flags) {
 
 // src/utils/json-repair.ts
 function completePartialObject(s) {
-  let result = s;
-  const trimmed = result.trim();
-  if (!trimmed.startsWith("{")) return s;
-  for (let pass = 0; pass < 3; pass++) {
-    let braceDepth = 0;
-    let inString2 = false;
-    let escaped2 = false;
-    let foundClose = false;
-    for (const ch of result) {
-      if (escaped2) {
-        escaped2 = false;
+  if (!s.trim().startsWith("{")) return s;
+  if (tryParse(s).ok) return s;
+  const stack = [];
+  let inString = false;
+  let escaped = false;
+  let sawKey = false;
+  let prevSig = "";
+  let contentEnd = 0;
+  let stringBraceDepth = 0;
+  for (let i = 0; i < s.length; i++) {
+    const ch = s[i];
+    if (inString) {
+      contentEnd = i + 1;
+      if (escaped) {
+        escaped = false;
         continue;
       }
       if (ch === "\\") {
-        escaped2 = true;
+        escaped = true;
         continue;
       }
       if (ch === '"') {
-        inString2 = !inString2;
+        inString = false;
+        prevSig = '"';
+        stringBraceDepth = 0;
         continue;
       }
-      if (inString2) continue;
-      if (ch === "{") {
-        braceDepth++;
-        foundClose = false;
-      } else if (ch === "}") {
-        braceDepth--;
-        if (braceDepth === 0) foundClose = true;
-      }
-    }
-    if (foundClose || braceDepth <= 0) break;
-    result += "}".repeat(braceDepth);
-  }
-  if (tryParse(result).ok) return result;
-  let inString = false;
-  let escaped = false;
-  for (let i = result.length - 1; i >= 0; i--) {
-    const ch = result[i];
-    if (escaped) {
-      escaped = false;
-      continue;
-    }
-    if (ch === "\\") {
-      escaped = true;
+      if (ch === "{") stringBraceDepth++;
+      else if (ch === "}" && stringBraceDepth > 0) stringBraceDepth--;
       continue;
     }
+    if (ch === " " || ch === "	" || ch === "\n" || ch === "\r") continue;
+    contentEnd = i + 1;
     if (ch === '"') {
-      let nextNonWs;
-      for (let j = i + 1; j < result.length; j++) {
-        const nc = result[j];
-        if (nc === " " || nc === "	" || nc === "\n" || nc === "\r") continue;
-        nextNonWs = result[j];
-        break;
-      }
-      if (nextNonWs === ":") {
-        continue;
-      } else {
-        inString = !inString;
-        continue;
-      }
+      inString = true;
+      sawKey = true;
+      stringBraceDepth = 0;
+      prevSig = '"';
+    } else if (ch === "{" || ch === "[") {
+      stack.push(ch);
+      prevSig = ch;
+    } else if (ch === "}" || ch === "]") {
+      stack.pop();
+      prevSig = ch;
+    } else {
+      prevSig = ch;
     }
   }
+  if (!sawKey && !inString) return s;
+  let result = s.slice(0, contentEnd);
   if (inString) {
-    result = result.trimEnd();
-    if (result.endsWith("\\")) result = result.slice(0, -1);
-    let depth = 0;
-    for (const ch of result) {
-      if (ch === "{") depth++;
-      else if (ch === "}") depth = Math.max(0, depth - 1);
+    if (escaped) {
+      result = result.slice(0, -1);
+    } else if (endsWithInvalidEscape(result)) {
+      result = result.slice(0, -2);
     }
-    result += '"' + "}".repeat(Math.max(1, depth));
+    if (stringBraceDepth > 0) result += "}".repeat(stringBraceDepth);
+    result += '"';
+  } else if (prevSig === ":") {
+    result += "null";
+  }
+  for (let k = stack.length - 1; k >= 0; k--) {
+    result += stack[k] === "{" ? "}" : "]";
+  }
+  if (!tryParse(result).ok) {
+    const patched = result.replace(/:(\s*)([}\]])/g, ":null$2");
+    if (tryParse(patched).ok) result = patched;
   }
   return result;
 }
+var VALID_ESCAPE = /* @__PURE__ */ new Set(['"', "\\", "/", "b", "f", "n", "r", "t", "u"]);
+function endsWithInvalidEscape(str) {
+  const last = str[str.length - 1];
+  if (str[str.length - 2] !== "\\" || last === void 0) return false;
+  if (VALID_ESCAPE.has(last)) return false;
+  let backslashes = 0;
+  for (let k = str.length - 2; k >= 0 && str[k] === "\\"; k--) backslashes++;
+  return backslashes % 2 === 1;
+}
 function tryParse(s) {
   try {
     return { ok: true, value: JSON.parse(s) };