@llmist/cli 13.0.0 → 15.0.0

package/dist/index.js

@@ -1,64 +1,257 @@
 // src/builtins/filesystem/edit-file.ts
-import { z } from "zod";
+import { readFileSync, writeFileSync } from "fs";
 import { createGadget } from "llmist";
+import { z } from "zod";
 
-// src/spawn.ts
-import { spawn as nodeSpawn } from "child_process";
-function nodeStreamToReadableStream(nodeStream) {
-  if (!nodeStream) return null;
-  return new ReadableStream({
-    start(controller) {
-      nodeStream.on("data", (chunk) => {
-        controller.enqueue(new Uint8Array(chunk));
-      });
-      nodeStream.on("end", () => {
-        controller.close();
-      });
-      nodeStream.on("error", (err) => {
-        controller.error(err);
-      });
-    },
-    cancel() {
-      nodeStream.destroy();
+// src/builtins/filesystem/editfile/matcher.ts
+var DEFAULT_OPTIONS = {
+  fuzzyThreshold: 0.8,
+  maxSuggestions: 3,
+  contextLines: 5
+};
+function findMatch(content, search, options = {}) {
+  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) }
+  ];
+  for (const { name, fn } of strategies) {
+    const result = fn(content, search);
+    if (result) {
+      return { ...result, strategy: name };
     }
-  });
+  }
+  return null;
 }
-function spawn(argv, options = {}) {
-  const [command, ...args] = argv;
-  const proc = nodeSpawn(command, args, {
-    cwd: options.cwd,
-    stdio: [
-      options.stdin === "pipe" ? "pipe" : options.stdin ?? "ignore",
-      options.stdout === "pipe" ? "pipe" : options.stdout ?? "ignore",
-      options.stderr === "pipe" ? "pipe" : options.stderr ?? "ignore"
-    ]
-  });
-  const exited = new Promise((resolve, reject) => {
-    proc.on("exit", (code) => {
-      resolve(code ?? 1);
-    });
-    proc.on("error", (err) => {
-      reject(err);
-    });
-  });
-  const stdin = proc.stdin ? {
-    write(data) {
-      proc.stdin?.write(data);
-    },
-    end() {
-      proc.stdin?.end();
-    }
-  } : null;
+function applyReplacement(content, match, replacement) {
+  return content.slice(0, match.startIndex) + replacement + content.slice(match.endIndex);
+}
+function getMatchFailure(content, search, options = {}) {
+  const opts = { ...DEFAULT_OPTIONS, ...options };
+  const suggestions = findSuggestions(content, search, opts.maxSuggestions, opts.fuzzyThreshold);
+  const nearbyContext = suggestions.length > 0 ? getContext(content, suggestions[0].lineNumber, opts.contextLines) : "";
   return {
-    exited,
-    stdout: nodeStreamToReadableStream(proc.stdout),
-    stderr: nodeStreamToReadableStream(proc.stderr),
-    stdin,
-    kill() {
-      proc.kill();
+    reason: "Search content not found in file",
+    suggestions,
+    nearbyContext
+  };
+}
+function exactMatch(content, search) {
+  const index = content.indexOf(search);
+  if (index === -1) return null;
+  const { startLine, endLine } = getLineNumbers(content, index, index + search.length);
+  return {
+    found: true,
+    strategy: "exact",
+    confidence: 1,
+    matchedContent: search,
+    startIndex: index,
+    endIndex: index + search.length,
+    startLine,
+    endLine
+  };
+}
+function whitespaceMatch(content, search) {
+  const normalizeWs = (s) => s.replace(/[ \t]+/g, " ");
+  const normalizedContent = normalizeWs(content);
+  const normalizedSearch = normalizeWs(search);
+  const normalizedIndex = normalizedContent.indexOf(normalizedSearch);
+  if (normalizedIndex === -1) return null;
+  const { originalStart, originalEnd } = mapNormalizedToOriginal(
+    content,
+    normalizedIndex,
+    normalizedSearch.length
+  );
+  const matchedContent = content.slice(originalStart, originalEnd);
+  const { startLine, endLine } = getLineNumbers(content, originalStart, originalEnd);
+  return {
+    found: true,
+    strategy: "whitespace",
+    confidence: 0.95,
+    matchedContent,
+    startIndex: originalStart,
+    endIndex: originalEnd,
+    startLine,
+    endLine
+  };
+}
+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;
+  for (let i = 0; i <= contentLines.length - searchLineCount; i++) {
+    const windowLines = contentLines.slice(i, i + searchLineCount);
+    const strippedWindow = stripIndent(windowLines.join("\n"));
+    if (strippedWindow === strippedSearch) {
+      const startIndex = contentLines.slice(0, i).join("\n").length + (i > 0 ? 1 : 0);
+      const matchedContent = windowLines.join("\n");
+      const endIndex = startIndex + matchedContent.length;
+      const { startLine, endLine } = getLineNumbers(content, startIndex, endIndex);
+      return {
+        found: true,
+        strategy: "indentation",
+        confidence: 0.9,
+        matchedContent,
+        startIndex,
+        endIndex,
+        startLine,
+        endLine
+      };
+    }
+  }
+  return null;
+}
+function fuzzyMatch(content, search, threshold) {
+  const searchLines = search.split("\n");
+  const contentLines = content.split("\n");
+  if (searchLines.length > contentLines.length) return null;
+  let bestMatch = null;
+  for (let i = 0; i <= contentLines.length - searchLines.length; i++) {
+    const windowLines = contentLines.slice(i, i + searchLines.length);
+    const similarity = calculateLineSimilarity(searchLines, windowLines);
+    if (similarity >= threshold && (!bestMatch || similarity > bestMatch.similarity)) {
+      bestMatch = {
+        startLineIndex: i,
+        endLineIndex: i + searchLines.length,
+        similarity
+      };
     }
+  }
+  if (!bestMatch) return null;
+  const startIndex = contentLines.slice(0, bestMatch.startLineIndex).join("\n").length + (bestMatch.startLineIndex > 0 ? 1 : 0);
+  const matchedContent = contentLines.slice(bestMatch.startLineIndex, bestMatch.endLineIndex).join("\n");
+  const endIndex = startIndex + matchedContent.length;
+  const { startLine, endLine } = getLineNumbers(content, startIndex, endIndex);
+  return {
+    found: true,
+    strategy: "fuzzy",
+    confidence: bestMatch.similarity,
+    matchedContent,
+    startIndex,
+    endIndex,
+    startLine,
+    endLine
   };
 }
+function findSuggestions(content, search, maxSuggestions, minSimilarity) {
+  const searchLines = search.split("\n");
+  const contentLines = content.split("\n");
+  const suggestions = [];
+  const suggestionThreshold = Math.max(0.5, minSimilarity - 0.2);
+  for (let i = 0; i <= contentLines.length - searchLines.length; i++) {
+    const windowLines = contentLines.slice(i, i + searchLines.length);
+    const similarity = calculateLineSimilarity(searchLines, windowLines);
+    if (similarity >= suggestionThreshold) {
+      suggestions.push({
+        lineIndex: i,
+        similarity,
+        content: windowLines.join("\n")
+      });
+    }
+  }
+  suggestions.sort((a, b) => b.similarity - a.similarity);
+  return suggestions.slice(0, maxSuggestions).map((s) => ({
+    content: s.content,
+    lineNumber: s.lineIndex + 1,
+    // 1-based
+    similarity: s.similarity
+  }));
+}
+function calculateLineSimilarity(a, b) {
+  if (a.length !== b.length) return 0;
+  if (a.length === 0) return 1;
+  let totalSimilarity = 0;
+  let totalWeight = 0;
+  for (let i = 0; i < a.length; i++) {
+    const lineA = a[i];
+    const lineB = b[i];
+    const weight = Math.max(lineA.length, lineB.length, 1);
+    const similarity = stringSimilarity(lineA, lineB);
+    totalSimilarity += similarity * weight;
+    totalWeight += weight;
+  }
+  return totalWeight > 0 ? totalSimilarity / totalWeight : 0;
+}
+function stringSimilarity(a, b) {
+  if (a === b) return 1;
+  if (a.length === 0 || b.length === 0) return 0;
+  const distance = levenshteinDistance(a, b);
+  const maxLen = Math.max(a.length, b.length);
+  return 1 - distance / maxLen;
+}
+function levenshteinDistance(a, b) {
+  const matrix = [];
+  for (let i = 0; i <= b.length; i++) {
+    matrix[i] = [i];
+  }
+  for (let j = 0; j <= a.length; j++) {
+    matrix[0][j] = j;
+  }
+  for (let i = 1; i <= b.length; i++) {
+    for (let j = 1; j <= a.length; j++) {
+      if (b.charAt(i - 1) === a.charAt(j - 1)) {
+        matrix[i][j] = matrix[i - 1][j - 1];
+      } else {
+        matrix[i][j] = Math.min(
+          matrix[i - 1][j - 1] + 1,
+          // substitution
+          matrix[i][j - 1] + 1,
+          // insertion
+          matrix[i - 1][j] + 1
+          // deletion
+        );
+      }
+    }
+  }
+  return matrix[b.length][a.length];
+}
+function getLineNumbers(content, startIndex, endIndex) {
+  const beforeStart = content.slice(0, startIndex);
+  const beforeEnd = content.slice(0, endIndex);
+  const startLine = (beforeStart.match(/\n/g) || []).length + 1;
+  const endLine = (beforeEnd.match(/\n/g) || []).length + 1;
+  return { startLine, endLine };
+}
+function isHorizontalWhitespace(char) {
+  return char === " " || char === "	";
+}
+function mapNormalizedToOriginal(original, normalizedStart, normalizedLength) {
+  const originalStart = findOriginalIndex(original, normalizedStart);
+  const originalEnd = findOriginalIndex(original, normalizedStart + normalizedLength);
+  return { originalStart, originalEnd: originalEnd === -1 ? original.length : originalEnd };
+}
+function findOriginalIndex(original, targetNormalizedPos) {
+  let normalizedPos = 0;
+  let inWhitespace = false;
+  for (let i = 0; i < original.length; i++) {
+    if (normalizedPos === targetNormalizedPos) {
+      return i;
+    }
+    const isWs = isHorizontalWhitespace(original[i]);
+    if (isWs && !inWhitespace) {
+      normalizedPos++;
+      inWhitespace = true;
+    } else if (!isWs) {
+      normalizedPos++;
+      inWhitespace = false;
+    }
+  }
+  return normalizedPos === targetNormalizedPos ? original.length : -1;
+}
+function getContext(content, lineNumber, contextLines) {
+  const lines = content.split("\n");
+  const start = Math.max(0, lineNumber - 1 - contextLines);
+  const end = Math.min(lines.length, lineNumber + contextLines);
+  const contextWithNumbers = lines.slice(start, end).map((line, i) => {
+    const num = start + i + 1;
+    const marker = num === lineNumber ? ">" : " ";
+    return `${marker}${String(num).padStart(4)} | ${line}`;
+  });
+  return contextWithNumbers.join("\n");
+}
 
 // src/builtins/filesystem/utils.ts
 import fs from "fs";
@@ -91,110 +284,139 @@ function validatePathIsWithinCwd(inputPath) {
 }
 
 // src/builtins/filesystem/edit-file.ts
-function filterDangerousCommands(commands) {
-  return commands.split("\n").filter((line) => !line.trimStart().startsWith("!")).join("\n");
+function formatFailure(filePath, search, failure, fileContent) {
+  const lines = [
+    `path=${filePath} status=failed`,
+    "",
+    `Error: ${failure.reason}`,
+    "",
+    "SEARCH CONTENT:",
+    "```",
+    search,
+    "```"
+  ];
+  if (failure.suggestions.length > 0) {
+    lines.push("", "SUGGESTIONS (similar content found):");
+    for (const suggestion of failure.suggestions) {
+      const percent = Math.round(suggestion.similarity * 100);
+      lines.push(
+        "",
+        `Line ${suggestion.lineNumber} (${percent}% similar):`,
+        "```",
+        suggestion.content,
+        "```"
+      );
+    }
+    if (failure.nearbyContext) {
+      lines.push("", "CONTEXT:", failure.nearbyContext);
+    }
+  }
+  lines.push("", "CURRENT FILE CONTENT:", "```", fileContent, "```");
+  return lines.join("\n");
 }
 var editFile = createGadget({
   name: "EditFile",
-  description: "Edit a file using ed commands. Ed is a line-oriented text editor - pipe commands to it for precise file modifications. Commands are executed in sequence. Remember to end with 'w' (write) and 'q' (quit). Shell escape commands (!) are filtered for security.",
+  description: `Edit a file by searching for content and replacing it.
+
+Uses layered matching strategies (in order):
+1. Exact match - byte-for-byte comparison
+2. Whitespace-insensitive - ignores differences in spaces/tabs
+3. Indentation-preserving - matches structure ignoring leading whitespace
+4. Fuzzy match - similarity-based matching (80% threshold)
+
+For multiple edits to the same file, call this gadget multiple times.
+Each call provides immediate feedback, allowing you to adjust subsequent edits.`,
   schema: z.object({
     filePath: z.string().describe("Path to the file to edit (relative or absolute)"),
-    commands: z.string().describe("Ed commands to execute, one per line")
+    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)")
   }),
   examples: [
     {
       params: {
-        filePath: "config.txt",
-        commands: `1,$p
-q`
+        filePath: "src/config.ts",
+        search: "const DEBUG = false;",
+        replace: "const DEBUG = true;"
       },
-      output: "path=config.txt\n\n32\nkey=value\noption=true",
-      comment: "Print entire file contents (ed shows byte count, then content)"
+      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"
     },
     {
       params: {
-        filePath: "data.txt",
-        commands: `1,$s/foo/bar/g
-w
-q`
+        filePath: "src/utils.ts",
+        search: `function oldHelper() {
+  return 1;
+}`,
+        replace: `function newHelper() {
+  return 2;
+}`
       },
-      output: "path=data.txt\n\n42\n42",
-      comment: "Replace all 'foo' with 'bar' (ed shows bytes read, then bytes written)"
+      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"
     },
     {
       params: {
-        filePath: "list.txt",
-        commands: `3d
-w
-q`
+        filePath: "src/app.ts",
+        search: "unusedImport",
+        replace: ""
       },
-      output: "path=list.txt\n\n45\n28",
-      comment: "Delete line 3, save and quit"
-    },
-    {
-      params: {
-        filePath: "readme.txt",
-        commands: `$a
-New last line
-.
-w
-q`
-      },
-      output: "path=readme.txt\n\n40\n56",
-      comment: "Append text after last line ($ = last line, . = end input mode)"
+      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"
     }
   ],
   timeoutMs: 3e4,
-  execute: async ({ filePath, commands }) => {
-    const validatedPath = validatePathIsWithinCwd(filePath);
-    const safeCommands = filterDangerousCommands(commands);
+  execute: ({ filePath, search, replace }) => {
+    if (search.trim() === "") {
+      return `path=${filePath} status=error
+
+Error: Search content cannot be empty.`;
+    }
+    let validatedPath;
     try {
-      const proc = spawn(["ed", validatedPath], {
-        stdin: "pipe",
-        stdout: "pipe",
-        stderr: "pipe"
-      });
-      if (!proc.stdin) {
-        return `path=${filePath}
+      validatedPath = validatePathIsWithinCwd(filePath);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      return `path=${filePath} status=error
 
-error: Failed to open stdin for ed process`;
-      }
-      proc.stdin.write(`${safeCommands}
-`);
-      proc.stdin.end();
-      let timeoutId;
-      const timeoutPromise = new Promise((_, reject) => {
-        timeoutId = setTimeout(() => {
-          proc.kill();
-          reject(new Error("ed command timed out after 30000ms"));
-        }, 3e4);
-      });
-      const [exitCode, stdout, stderr] = await Promise.race([
-        Promise.all([
-          proc.exited,
-          new Response(proc.stdout).text(),
-          new Response(proc.stderr).text()
-        ]),
-        timeoutPromise
-      ]);
-      if (timeoutId) {
-        clearTimeout(timeoutId);
-      }
-      const output = [stdout, stderr].filter(Boolean).join("\n").trim();
-      if (exitCode !== 0) {
-        return `path=${filePath}
+Error: ${message}`;
+    }
+    let content;
+    try {
+      content = readFileSync(validatedPath, "utf-8");
+    } catch (error) {
+      const nodeError = error;
+      if (nodeError.code === "ENOENT") {
+        return `path=${filePath} status=error
 
-${output || "ed exited with non-zero status"}`;
+Error: File not found: ${filePath}`;
       }
-      return `path=${filePath}
+      const message = error instanceof Error ? error.message : String(error);
+      return `path=${filePath} status=error
 
-${output || "(no output)"}`;
+Error reading file: ${message}`;
+    }
+    const match = findMatch(content, search);
+    if (!match) {
+      const failure = getMatchFailure(content, search);
+      return formatFailure(filePath, search, failure, content);
+    }
+    const newContent = applyReplacement(content, match, replace);
+    try {
+      writeFileSync(validatedPath, newContent, "utf-8");
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
-      return `path=${filePath}
+      return `path=${filePath} status=error
 
-error: ${message}`;
+Error writing file: ${message}`;
     }
+    return `path=${filePath} status=success strategy=${match.strategy} lines=${match.startLine}-${match.endLine}
+
+Replaced content successfully.
+
+UPDATED FILE CONTENT:
+\`\`\`
+${newContent}
+\`\`\``;
   }
 });
 
@@ -409,6 +631,66 @@ Wrote ${bytesWritten} bytes${dirNote}`;
 // src/builtins/run-command.ts
 import { z as z5 } from "zod";
 import { createGadget as createGadget5 } from "llmist";
+
+// src/spawn.ts
+import { spawn as nodeSpawn } from "child_process";
+function nodeStreamToReadableStream(nodeStream) {
+  if (!nodeStream) return null;
+  return new ReadableStream({
+    start(controller) {
+      nodeStream.on("data", (chunk) => {
+        controller.enqueue(new Uint8Array(chunk));
+      });
+      nodeStream.on("end", () => {
+        controller.close();
+      });
+      nodeStream.on("error", (err) => {
+        controller.error(err);
+      });
+    },
+    cancel() {
+      nodeStream.destroy();
+    }
+  });
+}
+function spawn(argv, options = {}) {
+  const [command, ...args] = argv;
+  const proc = nodeSpawn(command, args, {
+    cwd: options.cwd,
+    stdio: [
+      options.stdin === "pipe" ? "pipe" : options.stdin ?? "ignore",
+      options.stdout === "pipe" ? "pipe" : options.stdout ?? "ignore",
+      options.stderr === "pipe" ? "pipe" : options.stderr ?? "ignore"
+    ]
+  });
+  const exited = new Promise((resolve, reject) => {
+    proc.on("exit", (code) => {
+      resolve(code ?? 1);
+    });
+    proc.on("error", (err) => {
+      reject(err);
+    });
+  });
+  const stdin = proc.stdin ? {
+    write(data) {
+      proc.stdin?.write(data);
+    },
+    end() {
+      proc.stdin?.end();
+    }
+  } : null;
+  return {
+    exited,
+    stdout: nodeStreamToReadableStream(proc.stdout),
+    stderr: nodeStreamToReadableStream(proc.stderr),
+    stdin,
+    kill() {
+      proc.kill();
+    }
+  };
+}
+
+// src/builtins/run-command.ts
 var runCommand = createGadget5({
   name: "RunCommand",
   description: "Execute a command with arguments and return its output. Uses argv array to bypass shell - arguments are passed directly without interpretation. Returns stdout/stderr combined with exit status.",