@llmist/cli 16.0.1 → 16.0.2

package/dist/index.js

@@ -34,18 +34,22 @@ import { createGadget } from "llmist";
 import { z } from "zod";
 
 // src/builtins/filesystem/editfile/matcher.ts
+import DiffMatchPatch from "diff-match-patch";
+var dmp = new DiffMatchPatch();
 var DEFAULT_OPTIONS = {
   fuzzyThreshold: 0.8,
   maxSuggestions: 3,
   contextLines: 5
 };
 function findMatch(content, search, options = {}) {
+  if (!search) return null;
   const opts = { ...DEFAULT_OPTIONS, ...options };
   const strategies = [
     { name: "exact", fn: exactMatch },
     { name: "whitespace", fn: whitespaceMatch },
     { name: "indentation", fn: indentationMatch },
-    { name: "fuzzy", fn: (c, s) => fuzzyMatch(c, s, opts.fuzzyThreshold) }
+    { name: "fuzzy", fn: (c, s) => fuzzyMatch(c, s, opts.fuzzyThreshold) },
+    { name: "dmp", fn: (c, s) => dmpMatch(c, s, opts.fuzzyThreshold) }
   ];
   for (const { name, fn } of strategies) {
     const result = fn(content, search);
@@ -111,7 +115,8 @@ function indentationMatch(content, search) {
   const stripIndent = (s) => s.split("\n").map((line) => line.trimStart()).join("\n");
   const strippedSearch = stripIndent(search);
   const contentLines = content.split("\n");
-  const searchLineCount = search.split("\n").length;
+  const searchLines = search.split("\n");
+  const searchLineCount = searchLines.length;
   for (let i = 0; i <= contentLines.length - searchLineCount; i++) {
     const windowLines = contentLines.slice(i, i + searchLineCount);
     const strippedWindow = stripIndent(windowLines.join("\n"));
@@ -120,6 +125,7 @@ function indentationMatch(content, search) {
       const matchedContent = windowLines.join("\n");
       const endIndex = startIndex + matchedContent.length;
       const { startLine, endLine } = getLineNumbers(content, startIndex, endIndex);
+      const indentationDelta = computeIndentationDelta(searchLines, windowLines);
       return {
         found: true,
         strategy: "indentation",
@@ -128,7 +134,8 @@ function indentationMatch(content, search) {
         startIndex,
         endIndex,
         startLine,
-        endLine
+        endLine,
+        indentationDelta
       };
     }
   }
@@ -166,6 +173,94 @@ function fuzzyMatch(content, search, threshold) {
     endLine
   };
 }
+function dmpMatch(content, search, threshold) {
+  if (!search || !content) return null;
+  if (search.length > 1e3) return null;
+  if (search.split("\n").length > 20) return null;
+  const matchIndex = search.length <= 32 ? dmpMatchShortPattern(content, search, threshold) : dmpMatchLongPattern(content, search, threshold);
+  if (matchIndex === -1) return null;
+  const matchedContent = findBestMatchExtent(content, matchIndex, search, threshold);
+  if (!matchedContent) return null;
+  const startIndex = matchIndex;
+  const endIndex = matchIndex + matchedContent.length;
+  const { startLine, endLine } = getLineNumbers(content, startIndex, endIndex);
+  const similarity = stringSimilarity(search, matchedContent);
+  return {
+    found: true,
+    strategy: "dmp",
+    confidence: similarity,
+    matchedContent,
+    startIndex,
+    endIndex,
+    startLine,
+    endLine
+  };
+}
+function dmpMatchShortPattern(content, search, threshold) {
+  dmp.Match_Threshold = 1 - threshold;
+  dmp.Match_Distance = 1e3;
+  const index = dmp.match_main(content, search, 0);
+  return index;
+}
+function dmpMatchLongPattern(content, search, threshold) {
+  const prefix = search.slice(0, 32);
+  dmp.Match_Threshold = 1 - threshold;
+  dmp.Match_Distance = 1e3;
+  const prefixIndex = dmp.match_main(content, prefix, 0);
+  if (prefixIndex === -1) return -1;
+  const windowPadding = Math.max(50, Math.floor(search.length / 2));
+  const windowStart = Math.max(0, prefixIndex - windowPadding);
+  const windowEnd = Math.min(content.length, prefixIndex + search.length + windowPadding);
+  const window = content.slice(windowStart, windowEnd);
+  let bestIndex = -1;
+  let bestSimilarity = 0;
+  for (let i = 0; i <= window.length - search.length; i++) {
+    const candidate = window.slice(i, i + search.length);
+    const similarity = stringSimilarity(search, candidate);
+    if (similarity >= threshold && similarity > bestSimilarity) {
+      bestSimilarity = similarity;
+      bestIndex = windowStart + i;
+    }
+  }
+  return bestIndex;
+}
+function findBestMatchExtent(content, matchIndex, search, threshold) {
+  const exactLength = content.slice(matchIndex, matchIndex + search.length);
+  if (stringSimilarity(search, exactLength) >= threshold) {
+    return exactLength;
+  }
+  const searchLines = search.split("\n").length;
+  const contentFromMatch = content.slice(matchIndex);
+  const contentLines = contentFromMatch.split("\n");
+  if (contentLines.length >= searchLines) {
+    const lineBasedMatch = contentLines.slice(0, searchLines).join("\n");
+    if (stringSimilarity(search, lineBasedMatch) >= threshold) {
+      return lineBasedMatch;
+    }
+  }
+  return null;
+}
+function findAllMatches(content, search, options = {}) {
+  const results = [];
+  let searchStart = 0;
+  while (searchStart < content.length) {
+    const remainingContent = content.slice(searchStart);
+    const match = findMatch(remainingContent, search, options);
+    if (!match) break;
+    results.push({
+      ...match,
+      startIndex: searchStart + match.startIndex,
+      endIndex: searchStart + match.endIndex,
+      // Recalculate line numbers for original content
+      ...getLineNumbers(content, searchStart + match.startIndex, searchStart + match.endIndex)
+    });
+    searchStart = searchStart + match.endIndex;
+    if (match.endIndex === 0) {
+      searchStart++;
+    }
+  }
+  return results;
+}
 function findSuggestions(content, search, maxSuggestions, minSimilarity) {
   const searchLines = search.split("\n");
   const contentLines = content.split("\n");
@@ -282,6 +377,78 @@ function getContext(content, lineNumber, contextLines) {
   });
   return contextWithNumbers.join("\n");
 }
+function getLeadingWhitespace(line) {
+  const match = line.match(/^[ \t]*/);
+  return match ? match[0] : "";
+}
+function computeIndentationDelta(searchLines, matchedLines) {
+  for (let i = 0; i < Math.min(searchLines.length, matchedLines.length); i++) {
+    const searchLine = searchLines[i];
+    const matchedLine = matchedLines[i];
+    if (searchLine.trim() === "" && matchedLine.trim() === "") continue;
+    const searchIndent = getLeadingWhitespace(searchLine);
+    const matchedIndent = getLeadingWhitespace(matchedLine);
+    if (matchedIndent.length > searchIndent.length) {
+      return matchedIndent.slice(searchIndent.length);
+    }
+    return "";
+  }
+  return "";
+}
+function adjustIndentation(replacement, delta) {
+  if (!delta) return replacement;
+  return replacement.split("\n").map((line, index) => {
+    if (line.trim() === "") return line;
+    return delta + line;
+  }).join("\n");
+}
+function formatEditContext(originalContent, match, replacement, contextLines = 5) {
+  const lines = originalContent.split("\n");
+  const startLine = match.startLine - 1;
+  const endLine = match.endLine;
+  const contextStart = Math.max(0, startLine - contextLines);
+  const contextEnd = Math.min(lines.length, endLine + contextLines);
+  const output = [];
+  output.push(`=== Edit (lines ${match.startLine}-${match.endLine}) ===`);
+  output.push("");
+  for (let i = contextStart; i < startLine; i++) {
+    output.push(`  ${String(i + 1).padStart(4)} | ${lines[i]}`);
+  }
+  for (let i = startLine; i < endLine; i++) {
+    output.push(`< ${String(i + 1).padStart(4)} | ${lines[i]}`);
+  }
+  const replacementLines = replacement.split("\n");
+  for (let i = 0; i < replacementLines.length; i++) {
+    const lineNum = startLine + i + 1;
+    output.push(`> ${String(lineNum).padStart(4)} | ${replacementLines[i]}`);
+  }
+  for (let i = endLine; i < contextEnd; i++) {
+    output.push(`  ${String(i + 1).padStart(4)} | ${lines[i]}`);
+  }
+  return output.join("\n");
+}
+function formatMultipleMatches(content, matches, maxMatches = 5) {
+  const lines = content.split("\n");
+  const output = [];
+  output.push(`Found ${matches.length} matches:`);
+  output.push("");
+  const displayMatches = matches.slice(0, maxMatches);
+  for (let i = 0; i < displayMatches.length; i++) {
+    const match = displayMatches[i];
+    output.push(`Match ${i + 1} (lines ${match.startLine}-${match.endLine}):`);
+    const contextStart = Math.max(0, match.startLine - 2);
+    const contextEnd = Math.min(lines.length, match.endLine + 1);
+    for (let j = contextStart; j < contextEnd; j++) {
+      const marker = j >= match.startLine - 1 && j < match.endLine ? ">" : " ";
+      output.push(`${marker}${String(j + 1).padStart(4)} | ${lines[j]}`);
+    }
+    output.push("");
+  }
+  if (matches.length > maxMatches) {
+    output.push(`... and ${matches.length - maxMatches} more matches`);
+  }
+  return output.join("\n");
+}
 
 // src/builtins/filesystem/edit-file.ts
 function formatFailure(filePath, search, failure, fileContent) {
@@ -323,22 +490,30 @@ Uses layered matching strategies (in order):
 2. Whitespace-insensitive - ignores differences in spaces/tabs
 3. Indentation-preserving - matches structure ignoring leading whitespace
 4. Fuzzy match - similarity-based matching (80% threshold)
+5. DMP (diff-match-patch) - handles heavily refactored code
 
 For multiple edits to the same file, call this gadget multiple times.
-Each call provides immediate feedback, allowing you to adjust subsequent edits.`,
+Each call provides immediate feedback, allowing you to adjust subsequent edits.
+
+Options:
+- replaceAll: Replace all occurrences instead of just the first
+- expectedCount: Validate exact number of matches before applying`,
   maxConcurrent: 1,
   // Sequential execution to prevent race conditions
   schema: z.object({
     filePath: z.string().describe("Path to the file to edit (relative or absolute)"),
     search: z.string().describe("The content to search for in the file"),
-    replace: z.string().describe("The content to replace it with (empty string to delete)")
+    replace: z.string().describe("The content to replace it with (empty string to delete)"),
+    replaceAll: z.boolean().optional().default(false).describe("Replace all occurrences instead of just the first match"),
+    expectedCount: z.number().int().positive().optional().describe("Expected number of matches. Edit fails if actual count differs")
   }),
   examples: [
     {
       params: {
         filePath: "src/config.ts",
         search: "const DEBUG = false;",
-        replace: "const DEBUG = true;"
+        replace: "const DEBUG = true;",
+        replaceAll: false
       },
       output: "path=src/config.ts status=success strategy=exact lines=5-5\n\nReplaced content successfully.\n\nUPDATED FILE CONTENT:\n```\n// config.ts\nconst DEBUG = true;\nexport default { DEBUG };\n```",
       comment: "Simple single-line edit"
@@ -351,7 +526,8 @@ Each call provides immediate feedback, allowing you to adjust subsequent edits.`
 }`,
         replace: `function newHelper() {
   return 2;
-}`
+}`,
+        replaceAll: false
       },
       output: "path=src/utils.ts status=success strategy=exact lines=10-12\n\nReplaced content successfully.\n\nUPDATED FILE CONTENT:\n```\n// utils.ts\nfunction newHelper() {\n  return 2;\n}\n```",
       comment: "Multi-line replacement"
@@ -360,14 +536,25 @@ Each call provides immediate feedback, allowing you to adjust subsequent edits.`
       params: {
         filePath: "src/app.ts",
         search: "unusedImport",
-        replace: ""
+        replace: "",
+        replaceAll: false
       },
       output: 'path=src/app.ts status=success strategy=exact lines=3-3\n\nReplaced content successfully.\n\nUPDATED FILE CONTENT:\n```\n// app.ts\nimport { usedImport } from "./lib";\n```',
       comment: "Delete content by replacing with empty string"
+    },
+    {
+      params: {
+        filePath: "src/constants.ts",
+        search: "OLD_VALUE",
+        replace: "NEW_VALUE",
+        replaceAll: true
+      },
+      output: "path=src/constants.ts status=success matches=3 lines=[2-2, 5-5, 8-8]\n\nReplaced 3 occurrences\n\nUPDATED FILE CONTENT:\n```\n// constants.ts\nexport const A = NEW_VALUE;\nexport const B = NEW_VALUE;\nexport const C = NEW_VALUE;\n```",
+      comment: "Replace all occurrences with replaceAll=true"
     }
   ],
   timeoutMs: 3e4,
-  execute: ({ filePath, search, replace }) => {
+  execute: ({ filePath, search, replace, replaceAll, expectedCount }) => {
     if (search.trim() === "") {
       return `path=${filePath} status=error
 
@@ -397,12 +584,43 @@ Error: File not found: ${filePath}`;
 
 Error reading file: ${message}`;
     }
-    const match = findMatch(content, search);
-    if (!match) {
+    const allMatches = findAllMatches(content, search);
+    if (allMatches.length === 0) {
       const failure = getMatchFailure(content, search);
       return formatFailure(filePath, search, failure, content);
     }
-    const newContent = applyReplacement(content, match, replace);
+    if (expectedCount !== void 0 && allMatches.length !== expectedCount) {
+      return `path=${filePath} status=error
+
+Error: Expected ${expectedCount} match(es) but found ${allMatches.length}.
+
+${formatMultipleMatches(content, allMatches)}`;
+    }
+    if (allMatches.length > 1 && !replaceAll) {
+      const matchSummary = formatMultipleMatches(content, allMatches);
+      return `path=${filePath} status=error
+
+Error: Found ${allMatches.length} matches. Please either:
+1. Add more context to your search to make it unique
+2. Use replaceAll=true to replace all occurrences
+
+${matchSummary}`;
+    }
+    let newContent;
+    let editSummary;
+    if (replaceAll && allMatches.length > 1) {
+      newContent = executeReplaceAll(content, allMatches, replace);
+      const MAX_DISPLAYED_RANGES = 5;
+      const displayMatches = allMatches.slice(0, MAX_DISPLAYED_RANGES);
+      const lineRanges = displayMatches.map((m) => `${m.startLine}-${m.endLine}`).join(", ");
+      const suffix = allMatches.length > MAX_DISPLAYED_RANGES ? `, +${allMatches.length - MAX_DISPLAYED_RANGES} more` : "";
+      editSummary = `matches=${allMatches.length} lines=[${lineRanges}${suffix}]`;
+    } else {
+      const match = allMatches[0];
+      const finalReplace = prepareReplacement(match, replace);
+      newContent = applyReplacement(content, match, finalReplace);
+      editSummary = `strategy=${match.strategy} lines=${match.startLine}-${match.endLine}`;
+    }
     try {
       writeFileSync(validatedPath, newContent, "utf-8");
     } catch (error) {
@@ -411,9 +629,10 @@ Error reading file: ${message}`;
 
 Error writing file: ${message}`;
     }
-    return `path=${filePath} status=success strategy=${match.strategy} lines=${match.startLine}-${match.endLine}
+    const diffContext = allMatches.length === 1 ? formatEditContext(content, allMatches[0], prepareReplacement(allMatches[0], replace)) : `Replaced ${allMatches.length} occurrences`;
+    return `path=${filePath} status=success ${editSummary}
 
-Replaced content successfully.
+${diffContext}
 
 UPDATED FILE CONTENT:
 \`\`\`
@@ -421,6 +640,21 @@ ${newContent}
 \`\`\``;
   }
 });
+function prepareReplacement(match, replace) {
+  if (match.strategy === "indentation" && match.indentationDelta) {
+    return adjustIndentation(replace, match.indentationDelta);
+  }
+  return replace;
+}
+function executeReplaceAll(content, matches, replace) {
+  const sortedMatches = [...matches].sort((a, b) => b.startIndex - a.startIndex);
+  let result = content;
+  for (const match of sortedMatches) {
+    const finalReplace = prepareReplacement(match, replace);
+    result = applyReplacement(result, match, finalReplace);
+  }
+  return result;
+}
 
 // src/builtins/filesystem/list-directory.ts
 import fs2 from "fs";