@morphllm/morphsdk 0.2.50 → 0.2.52

package/dist/client.cjs

@@ -1103,12 +1103,6 @@ function getSystemPrompt() {
 }
 
 // tools/warp_grep/agent/parser.ts
-var LLMResponseParseError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "LLMResponseParseError";
-  }
-};
 var VALID_COMMANDS = ["analyse", "grep", "read", "finish"];
 function preprocessText(text) {
   let processed = text.replace(/<think>[\s\S]*?<\/think>/gi, "");
@@ -1159,24 +1153,23 @@ var LLMResponseParser = class {
     const lines = preprocessText(text);
     const commands = [];
     let finishAccumulator = null;
-    lines.forEach((line, idx) => {
+    lines.forEach((line) => {
       if (!line || line.startsWith("#")) return;
-      const ctx = { lineNumber: idx + 1, raw: line };
-      const parts = this.splitLine(line, ctx);
+      const parts = this.splitLine(line);
       if (parts.length === 0) return;
       const cmd = parts[0];
       switch (cmd) {
         case "analyse":
-          this.handleAnalyse(parts, ctx, commands);
+          this.handleAnalyse(parts, line, commands);
           break;
         case "grep":
-          this.handleGrep(parts, ctx, commands);
+          this.handleGrep(parts, line, commands);
           break;
         case "read":
-          this.handleRead(parts, ctx, commands);
+          this.handleRead(parts, line, commands);
           break;
         case "finish":
-          finishAccumulator = this.handleFinish(parts, ctx, finishAccumulator);
+          finishAccumulator = this.handleFinish(parts, line, commands, finishAccumulator);
           break;
         default:
           break;
@@ -1193,53 +1186,68 @@ var LLMResponseParser = class {
     }
     return commands;
   }
-  splitLine(line, ctx) {
-    try {
-      const parts = [];
-      let current = "";
-      let inSingle = false;
-      for (let i = 0; i < line.length; i++) {
-        const ch = line[i];
-        if (ch === "'" && line[i - 1] !== "\\") {
-          inSingle = !inSingle;
-          current += ch;
-        } else if (!inSingle && /\s/.test(ch)) {
-          if (current) {
-            parts.push(current);
-            current = "";
-          }
-        } else {
-          current += ch;
+  splitLine(line) {
+    const parts = [];
+    let current = "";
+    let inSingle = false;
+    for (let i = 0; i < line.length; i++) {
+      const ch = line[i];
+      if (ch === "'" && line[i - 1] !== "\\") {
+        inSingle = !inSingle;
+        current += ch;
+      } else if (!inSingle && /\s/.test(ch)) {
+        if (current) {
+          parts.push(current);
+          current = "";
         }
+      } else {
+        current += ch;
       }
-      if (current) parts.push(current);
-      return parts;
-    } catch {
-      throw new LLMResponseParseError(`Line ${ctx.lineNumber}: Unable to parse line.`);
     }
+    if (current) parts.push(current);
+    return parts;
+  }
+  /** Helper to create a _skip tool call with an error message */
+  skip(message) {
+    return { name: "_skip", arguments: { message } };
   }
-  handleAnalyse(parts, ctx, commands) {
+  handleAnalyse(parts, rawLine, commands) {
     if (parts.length < 2) {
-      throw new LLMResponseParseError(`Line ${ctx.lineNumber}: analyse requires <path>`);
+      commands.push(this.skip(
+        `[SKIPPED] Your command "${rawLine}" is missing a path. Correct format: analyse <path> [pattern]. Example: analyse src/`
+      ));
+      return;
     }
     const path4 = parts[1];
     const pattern = parts[2]?.replace(/^"|"$/g, "") ?? null;
     commands.push({ name: "analyse", arguments: { path: path4, pattern } });
   }
   // no glob tool in MCP
-  handleGrep(parts, ctx, commands) {
+  handleGrep(parts, rawLine, commands) {
     if (parts.length < 3) {
-      throw new LLMResponseParseError(`Line ${ctx.lineNumber}: grep requires '<pattern>' and <path>`);
+      commands.push(this.skip(
+        `[SKIPPED] Your command "${rawLine}" is missing arguments. Correct format: grep '<pattern>' <path>. Example: grep 'TODO' src/`
+      ));
+      return;
     }
-    const pat = parts[1];
-    if (!pat.startsWith("'") || !pat.endsWith("'")) {
-      throw new LLMResponseParseError(`Line ${ctx.lineNumber}: grep pattern must be single-quoted`);
+    let pat = parts[1];
+    if (pat.startsWith("'") && pat.endsWith("'")) {
+      pat = pat.slice(1, -1);
     }
-    commands.push({ name: "grep", arguments: { pattern: pat.slice(1, -1), path: parts[2] } });
+    if (!pat) {
+      commands.push(this.skip(
+        `[SKIPPED] Your command "${rawLine}" has an empty pattern. Provide a non-empty search pattern. Example: grep 'function' src/`
+      ));
+      return;
+    }
+    commands.push({ name: "grep", arguments: { pattern: pat, path: parts[2] } });
   }
-  handleRead(parts, ctx, commands) {
+  handleRead(parts, rawLine, commands) {
     if (parts.length < 2) {
-      throw new LLMResponseParseError(`Line ${ctx.lineNumber}: read requires <path> or <path>:<start-end>`);
+      commands.push(this.skip(
+        `[SKIPPED] Your command "${rawLine}" is missing a path. Correct format: read <path> or read <path>:<start>-<end>. Example: read src/index.ts:1-50`
+      ));
+      return;
     }
     const spec = parts[1];
     const rangeIdx = spec.indexOf(":");
@@ -1247,31 +1255,38 @@ var LLMResponseParser = class {
       commands.push({ name: "read", arguments: { path: spec } });
       return;
     }
-    const path4 = spec.slice(0, rangeIdx);
+    const filePath = spec.slice(0, rangeIdx);
     const range = spec.slice(rangeIdx + 1);
     const [s, e] = range.split("-").map((v) => parseInt(v, 10));
     if (!Number.isFinite(s) || !Number.isFinite(e)) {
-      throw new LLMResponseParseError(`Line ${ctx.lineNumber}: invalid read range '${range}'`);
+      commands.push({ name: "read", arguments: { path: filePath } });
+      return;
     }
-    commands.push({ name: "read", arguments: { path: path4, start: s, end: e } });
+    commands.push({ name: "read", arguments: { path: filePath, start: s, end: e } });
   }
-  handleFinish(parts, ctx, acc) {
+  handleFinish(parts, rawLine, commands, acc) {
     const map = acc ?? /* @__PURE__ */ new Map();
     const args = parts.slice(1);
     for (const token of args) {
-      const [path4, rangesText] = token.split(":", 2);
-      if (!path4 || !rangesText) {
-        throw new LLMResponseParseError(`Line ${ctx.lineNumber}: invalid finish token '${token}'`);
+      const [filePath, rangesText] = token.split(":", 2);
+      if (!filePath || !rangesText) {
+        commands.push(this.skip(
+          `[SKIPPED] Invalid finish token "${token}". Correct format: finish <path>:<start>-<end>. Example: finish src/index.ts:1-50`
+        ));
+        continue;
       }
       const rangeSpecs = rangesText.split(",").filter(Boolean);
       for (const spec of rangeSpecs) {
         const [s, e] = spec.split("-").map((v) => parseInt(v, 10));
         if (!Number.isFinite(s) || !Number.isFinite(e) || e < s) {
-          throw new LLMResponseParseError(`Line ${ctx.lineNumber}: invalid range '${spec}'`);
+          commands.push(this.skip(
+            `[SKIPPED] Invalid range "${spec}" in "${token}". Ranges must be <start>-<end> where start <= end. Example: 1-50`
+          ));
+          continue;
         }
-        const arr = map.get(path4) ?? [];
+        const arr = map.get(filePath) ?? [];
         arr.push([s, e]);
-        map.set(path4, arr);
+        map.set(filePath, arr);
       }
     }
     return map;
@@ -1281,6 +1296,10 @@ var LLMResponseParser = class {
 // tools/warp_grep/tools/read.ts
 async function toolRead(provider, args) {
   const res = await provider.read({ path: args.path, start: args.start, end: args.end });
+  if (res.error) {
+    return res.error;
+  }
+  if (!res.lines.length) return "(empty file)";
   return res.lines.join("\n");
 }
 
@@ -1592,14 +1611,7 @@ async function runWarpGrep(config) {
     });
     if (!assistantContent) break;
     messages.push({ role: "assistant", content: assistantContent });
-    let toolCalls = [];
-    try {
-      toolCalls = parser.parse(assistantContent);
-    } catch (e) {
-      errors.push({ message: e instanceof Error ? e.message : String(e) });
-      terminationReason = "terminated";
-      break;
-    }
+    const toolCalls = parser.parse(assistantContent);
     if (toolCalls.length === 0) {
       errors.push({ message: "No tool calls produced by the model." });
       terminationReason = "terminated";
@@ -1609,7 +1621,12 @@ async function runWarpGrep(config) {
     const grepCalls = toolCalls.filter((c) => c.name === "grep");
     const analyseCalls = toolCalls.filter((c) => c.name === "analyse");
     const readCalls = toolCalls.filter((c) => c.name === "read");
+    const skipCalls = toolCalls.filter((c) => c.name === "_skip");
     const formatted = [];
+    for (const c of skipCalls) {
+      const msg = c.arguments?.message || "Command skipped due to parsing error";
+      formatted.push(msg);
+    }
     const otherPromises = [];
     for (const c of analyseCalls) {
       const args = c.arguments ?? {};
@@ -1635,6 +1652,15 @@ async function runWarpGrep(config) {
       const args = c.arguments ?? {};
       try {
         const grepRes = await provider.grep({ pattern: args.pattern, path: args.path });
+        if (grepRes.error) {
+          errors.push({ message: grepRes.error });
+          terminationReason = "terminated";
+          return {
+            terminationReason: "terminated",
+            messages,
+            errors
+          };
+        }
         const rawOutput = Array.isArray(grepRes.lines) ? grepRes.lines.join("\n") : "";
         const newMatches = parseAndFilterGrepOutput(rawOutput, grepState);
         let formattedPayload = formatTurnGrepOutput(newMatches);
@@ -1846,10 +1872,22 @@ var LocalRipgrepProvider = class {
     ];
     const res = await runRipgrep(args, { cwd: this.repoRoot });
     if (res.exitCode === -1) {
-      throw new Error(res.stderr || "ripgrep (rg) execution failed.");
+      return {
+        lines: [],
+        error: `[RIPGREP NOT AVAILABLE] ripgrep (rg) is required but failed to execute. Please install it:
+  \u2022 macOS: brew install ripgrep
+  \u2022 Ubuntu/Debian: apt install ripgrep
+  \u2022 Windows: choco install ripgrep
+  \u2022 Or visit: https://github.com/BurntSushi/ripgrep#installation
+Exit code: ${res.exitCode}${res.stderr ? `
+Details: ${res.stderr}` : ""}`
+      };
     }
     if (res.exitCode !== 0 && res.exitCode !== 1) {
-      throw new Error(res.stderr || `ripgrep failed with code ${res.exitCode}`);
+      return {
+        lines: [],
+        error: `[RIPGREP ERROR] grep failed with exit code ${res.exitCode}${res.stderr ? `: ${res.stderr}` : ""}`
+      };
     }
     const lines = (res.stdout || "").trim().split(/\r?\n/).filter((l) => l.length > 0);
     return { lines };
@@ -1867,7 +1905,8 @@ var LocalRipgrepProvider = class {
     ];
     const res = await runRipgrep(args, { cwd: this.repoRoot });
     if (res.exitCode === -1) {
-      throw new Error(res.stderr || "ripgrep (rg) execution failed.");
+      console.warn(`[warp_grep] ripgrep not available for glob: ${res.stderr || "execution failed"}`);
+      return { files: [] };
     }
     const files = (res.stdout || "").trim().split(/\r?\n/).filter((l) => l.length > 0);
     return { files };
@@ -1876,13 +1915,22 @@ var LocalRipgrepProvider = class {
     const abs = resolveUnderRepo(this.repoRoot, params.path);
     const stat = await import_promises4.default.stat(abs).catch(() => null);
     if (!stat || !stat.isFile()) {
-      throw new Error(`Path is not a file: ${params.path}`);
+      return {
+        lines: [],
+        error: `[FILE NOT FOUND] You tried to read "${params.path}" but there is no file at this path. Double-check the path exists and is spelled correctly.`
+      };
     }
     if (isSymlink(abs)) {
-      throw new Error(`Refusing to read symlink: ${params.path}`);
+      return {
+        lines: [],
+        error: `[SYMLINK] You tried to read "${params.path}" but this is a symlink. Try reading the actual file it points to instead.`
+      };
     }
     if (!isTextualFile(abs)) {
-      throw new Error(`Non-text or too-large file: ${params.path}`);
+      return {
+        lines: [],
+        error: `[UNREADABLE FILE] You tried to read "${params.path}" but this file is either too large or not a text file, so it cannot be read. Try a different file.`
+      };
     }
     const lines = await readAllLines(abs);
     const total = lines.length;