@namzu/cli 38.0.0 → 38.1.1

package/dist/chunks/{chunk-7XBUFSLG.js → chunk-XBCEWEQN.js}

@@ -5,7 +5,7 @@ import {
   has,
   interactive,
   parseArgs
-} from "./chunk-KOOSFKHR.js";
+} from "./chunk-XNY2DD22.js";
 import {
   isBrowserProfileName
 } from "./chunk-WHODOMXA.js";
@@ -23,7 +23,7 @@ import {
 import {
   canonicalizeBrowserUrl,
   resolveNamzuHome
-} from "./chunk-LA7SHC2B.js";
+} from "./chunk-XM3W7NMM.js";
 import {
   __name
 } from "./chunk-76FLAFCG.js";
@@ -396,4 +396,4 @@ export {
   defaultBrowserCommandDeps,
   browserCommand
 };
-//# sourceMappingURL=chunk-7XBUFSLG.js.map
+//# sourceMappingURL=chunk-XBCEWEQN.js.map

package/dist/chunks/{chunk-LA7SHC2B.js → chunk-XM3W7NMM.js}

@@ -25303,6 +25303,175 @@ function measureContent(content) {
 }
 __name(measureContent, "measureContent");
 
+// ../sdk/dist/tools/builtins/edit-match.js
+var LEFT_SINGLE_QUOTE = "\u2018";
+var RIGHT_SINGLE_QUOTE = "\u2019";
+var LEFT_DOUBLE_QUOTE = "\u201C";
+var RIGHT_DOUBLE_QUOTE = "\u201D";
+var HAS_UNICODE_ESCAPE = /\\u[0-9a-fA-F]{4}/;
+var HAS_NON_ASCII = /[\u0080-￿]/;
+function straightenQuotes(text9) {
+  return text9.replaceAll(LEFT_SINGLE_QUOTE, "'").replaceAll(RIGHT_SINGLE_QUOTE, "'").replaceAll(LEFT_DOUBLE_QUOTE, '"').replaceAll(RIGHT_DOUBLE_QUOTE, '"');
+}
+__name(straightenQuotes, "straightenQuotes");
+function decodeUnicodeEscapes(text9) {
+  return text9.replace(/(\\\\)|\\u([0-9a-fA-F]{4})/g, (whole, backslashes, hex2) => backslashes !== void 0 ? whole : String.fromCharCode(Number.parseInt(hex2, 16)));
+}
+__name(decodeUnicodeEscapes, "decodeUnicodeEscapes");
+function escapedLength(text9) {
+  let nonAscii = 0;
+  for (let i = 0; i < text9.length; i++)
+    if (text9.charCodeAt(i) >= 128)
+      nonAscii++;
+  return text9.length + 5 * nonAscii;
+}
+__name(escapedLength, "escapedLength");
+function trailingBackslashes2(text9, at) {
+  let count7 = 0;
+  while (text9[at - 1 - count7] === "\\")
+    count7++;
+  return count7;
+}
+__name(trailingBackslashes2, "trailingBackslashes");
+function escapeRegExp(text9) {
+  return text9.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+__name(escapeRegExp, "escapeRegExp");
+function buildEscapeTolerantPattern(model) {
+  let pattern = "";
+  for (let i = 0; i < model.length; i++) {
+    const code = model.charCodeAt(i);
+    if (code >= 128) {
+      pattern += "\\\\u";
+      for (const digit of code.toString(16).padStart(4, "0"))
+        pattern += digit >= "a" ? `[${digit}${digit.toUpperCase()}]` : digit;
+    } else {
+      pattern += escapeRegExp(model[i]);
+    }
+  }
+  return pattern;
+}
+__name(buildEscapeTolerantPattern, "buildEscapeTolerantPattern");
+function findEscapedForm(model, file) {
+  if (trailingBackslashes2(model, model.length) % 2 === 1)
+    return null;
+  const sensitiveOffsets = model[0] === "\\" ? [0] : [];
+  let offset = 0;
+  for (let i = 0; i < model.length; i++) {
+    if (model.charCodeAt(i) >= 128) {
+      sensitiveOffsets.push(offset);
+      offset += 6;
+    } else {
+      offset += 1;
+    }
+  }
+  let regex;
+  try {
+    regex = new RegExp(buildEscapeTolerantPattern(model), "g");
+  } catch {
+    return null;
+  }
+  for (let match2 = regex.exec(file); match2 !== null; match2 = regex.exec(file)) {
+    const at = match2.index;
+    if (sensitiveOffsets.every((o) => trailingBackslashes2(file, at + o) % 2 === 0)) {
+      return file.indexOf(match2[0]) === at ? match2[0] : null;
+    }
+    regex.lastIndex = at + 1;
+  }
+  return null;
+}
+__name(findEscapedForm, "findEscapedForm");
+function resolveOldString(content, oldString) {
+  if (content.includes(oldString))
+    return oldString;
+  const straight = straightenQuotes(oldString);
+  const quoteIndex = straightenQuotes(content).indexOf(straight);
+  if (quoteIndex !== -1)
+    return content.substring(quoteIndex, quoteIndex + oldString.length);
+  if (HAS_UNICODE_ESCAPE.test(oldString)) {
+    const decoded = decodeUnicodeEscapes(oldString);
+    if (decoded !== oldString && content.includes(decoded))
+      return decoded;
+  }
+  if (HAS_NON_ASCII.test(oldString)) {
+    if (escapedLength(oldString) > content.length || !content.includes("\\u"))
+      return null;
+    return findEscapedForm(oldString, content);
+  }
+  return null;
+}
+__name(resolveOldString, "resolveOldString");
+function isOpeningPosition(chars, index) {
+  if (index === 0)
+    return true;
+  const before = chars[index - 1];
+  return before === " " || before === "	" || before === "\n" || before === "\r" || before === "(" || before === "[" || before === "{" || before === "\u2014" || before === "\u2013";
+}
+__name(isOpeningPosition, "isOpeningPosition");
+function curlifyDoubleQuotes(text9) {
+  const chars = [...text9];
+  return chars.map((char, index) => char === '"' ? isOpeningPosition(chars, index) ? LEFT_DOUBLE_QUOTE : RIGHT_DOUBLE_QUOTE : char).join("");
+}
+__name(curlifyDoubleQuotes, "curlifyDoubleQuotes");
+function curlifySingleQuotes(text9) {
+  const chars = [...text9];
+  return chars.map((char, index) => {
+    if (char !== "'")
+      return char;
+    const before = index > 0 ? chars[index - 1] : void 0;
+    const after = index < chars.length - 1 ? chars[index + 1] : void 0;
+    const betweenLetters = before !== void 0 && new RegExp("\\p{L}", "u").test(before) && after !== void 0 && new RegExp("\\p{L}", "u").test(after);
+    if (betweenLetters)
+      return RIGHT_SINGLE_QUOTE;
+    return isOpeningPosition(chars, index) ? LEFT_SINGLE_QUOTE : RIGHT_SINGLE_QUOTE;
+  }).join("");
+}
+__name(curlifySingleQuotes, "curlifySingleQuotes");
+function reconcileNewString(oldString, resolved2, newString) {
+  if (resolved2 === oldString)
+    return newString;
+  if (HAS_NON_ASCII.test(oldString) && escapedLength(oldString) === resolved2.length && findEscapedForm(oldString, resolved2) !== null) {
+    const perChar = /* @__PURE__ */ new Map();
+    let upper = 0;
+    let lower = 0;
+    for (let oldIndex = 0, resolvedIndex = 0; oldIndex < oldString.length; oldIndex++) {
+      const code = oldString.charCodeAt(oldIndex);
+      if (code >= 128) {
+        const hex2 = resolved2.slice(resolvedIndex + 2, resolvedIndex + 6);
+        perChar.set(code, hex2);
+        for (const digit of hex2)
+          if (digit >= "a" && digit <= "f")
+            lower++;
+          else if (digit >= "A" && digit <= "F")
+            upper++;
+        resolvedIndex += 6;
+      } else {
+        resolvedIndex += 1;
+      }
+    }
+    return newString.replace(/[\u0080-￿]/g, (char) => {
+      const code = char.charCodeAt(0);
+      const known = perChar.get(code);
+      if (known !== void 0)
+        return `\\u${known}`;
+      const hex2 = code.toString(16).padStart(4, "0");
+      return `\\u${upper > lower ? hex2.toUpperCase() : hex2}`;
+    });
+  }
+  if (HAS_UNICODE_ESCAPE.test(oldString) && decodeUnicodeEscapes(oldString) === resolved2) {
+    return decodeUnicodeEscapes(newString);
+  }
+  const hasCurlyDouble = resolved2.includes(LEFT_DOUBLE_QUOTE) || resolved2.includes(RIGHT_DOUBLE_QUOTE);
+  const hasCurlySingle = resolved2.includes(LEFT_SINGLE_QUOTE) || resolved2.includes(RIGHT_SINGLE_QUOTE);
+  let reconciled = newString;
+  if (hasCurlyDouble)
+    reconciled = curlifyDoubleQuotes(reconciled);
+  if (hasCurlySingle)
+    reconciled = curlifySingleQuotes(reconciled);
+  return reconciled;
+}
+__name(reconcileNewString, "reconcileNewString");
+
 // ../sdk/dist/tools/builtins/edit-apply.js
 function normalizeEditInput(input) {
   if (input.edits !== void 0) {
@@ -25398,23 +25567,35 @@ function applyOne(content, input) {
     return applyLineInsert(content, input);
   }
   const replacement = normalizeLineEndings(content, input);
-  if (!content.includes(replacement.oldString)) {
-    return {
-      success: false,
-      error: "old_string/oldStr not found in file. Make sure the string matches exactly, including whitespace and indentation."
-    };
+  let oldString = replacement.oldString;
+  let newString = replacement.newString;
+  if (!content.includes(oldString)) {
+    const resolved2 = resolveOldString(content, oldString);
+    if (resolved2 === null) {
+      return {
+        success: false,
+        error: "old_string/oldStr not found in file. Make sure the string matches exactly, including whitespace and indentation."
+      };
+    }
+    newString = reconcileNewString(oldString, resolved2, newString);
+    oldString = resolved2;
+  }
+  if (newString === "" && !oldString.endsWith("\n") && content.includes(`${oldString}
+`)) {
+    oldString = `${oldString}
+`;
   }
   if (replacement.replace_all) {
-    const parts = content.split(replacement.oldString);
+    const parts = content.split(oldString);
     const replacements = parts.length - 1;
     return {
       success: true,
-      content: parts.join(replacement.newString),
+      content: parts.join(newString),
       replacements
     };
   }
-  const firstIndex = content.indexOf(replacement.oldString);
-  const secondIndex = content.indexOf(replacement.oldString, firstIndex + 1);
+  const firstIndex = content.indexOf(oldString);
+  const secondIndex = content.indexOf(oldString, firstIndex + 1);
   if (secondIndex !== -1) {
     const lineNumber = content.slice(0, firstIndex).split("\n").length;
     const secondLine = content.slice(0, secondIndex).split("\n").length;
@@ -25425,7 +25606,7 @@ function applyOne(content, input) {
   }
   return {
     success: true,
-    content: content.slice(0, firstIndex) + replacement.newString + content.slice(firstIndex + replacement.oldString.length),
+    content: content.slice(0, firstIndex) + newString + content.slice(firstIndex + oldString.length),
     replacements: 1
   };
 }
@@ -61072,7 +61253,7 @@ async function resolveMcpEra(input) {
 __name(resolveMcpEra, "resolveMcpEra");
 
 // ../sdk/dist/version.js
-var VERSION2 = "52.5.0";
+var VERSION2 = "52.6.0";
 
 // ../sdk/dist/connector/mcp/client.js
 var MAX_LIST_PAGES = 100;
@@ -92467,6 +92648,7 @@ export {
   acceptsStrictSchema,
   toSchemaDialect,
   renderToolSchema,
+  toolWireSchema,
   isInvocableBy,
   isTerminalStatus,
   toToolResultBlocks,
@@ -92720,4 +92902,4 @@ export {
   buildResidentToolEvidenceTools,
   createPalMessagingTools
 };
-//# sourceMappingURL=chunk-LA7SHC2B.js.map
+//# sourceMappingURL=chunk-XM3W7NMM.js.map