@morphllm/morphsdk 0.2.44 → 0.2.46

package/dist/tools/warp_grep/vercel.cjs

@@ -30,7 +30,10 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // tools/warp_grep/vercel.ts
 var vercel_exports = {};
 __export(vercel_exports, {
-  createMorphWarpGrepTool: () => createMorphWarpGrepTool
+  createMorphWarpGrepTool: () => createMorphWarpGrepTool,
+  execute: () => execute,
+  formatResult: () => formatResult,
+  getSystemPrompt: () => getSystemPrompt
 });
 module.exports = __toCommonJS(vercel_exports);
 var import_ai = require("ai");
@@ -42,84 +45,207 @@ var AGENT_CONFIG = {
   MAX_ROUNDS: 10,
   TIMEOUT_MS: 3e4
 };
-var DEFAULT_EXCLUDES = (process.env.MORPH_WARP_GREP_EXCLUDE || "").split(",").map((s) => s.trim()).filter(Boolean).concat(["node_modules", ".git", "dist", "build", ".cache", "venv", "target"]);
+var BUILTIN_EXCLUDES = [
+  // Version control
+  ".git",
+  ".svn",
+  ".hg",
+  ".bzr",
+  // Dependencies
+  "node_modules",
+  "bower_components",
+  ".pnpm",
+  ".yarn",
+  "vendor",
+  "packages",
+  "Pods",
+  ".bundle",
+  // Python
+  "__pycache__",
+  ".pytest_cache",
+  ".mypy_cache",
+  ".ruff_cache",
+  ".venv",
+  "venv",
+  ".tox",
+  ".nox",
+  ".eggs",
+  "*.egg-info",
+  // Build outputs
+  "dist",
+  "build",
+  "out",
+  "output",
+  "target",
+  "_build",
+  ".next",
+  ".nuxt",
+  ".output",
+  ".vercel",
+  ".netlify",
+  // Cache directories
+  ".cache",
+  ".parcel-cache",
+  ".turbo",
+  ".nx",
+  ".gradle",
+  // IDE/Editor
+  ".idea",
+  ".vscode",
+  ".vs",
+  // Coverage
+  "coverage",
+  ".coverage",
+  "htmlcov",
+  ".nyc_output",
+  // Temporary
+  "tmp",
+  "temp",
+  ".tmp",
+  ".temp",
+  // Lock files
+  "package-lock.json",
+  "yarn.lock",
+  "pnpm-lock.yaml",
+  "bun.lockb",
+  "Cargo.lock",
+  "Gemfile.lock",
+  "poetry.lock",
+  // Binary/minified
+  "*.min.js",
+  "*.min.css",
+  "*.bundle.js",
+  "*.wasm",
+  "*.so",
+  "*.dll",
+  "*.pyc",
+  "*.map",
+  "*.js.map",
+  // Hidden directories catch-all
+  ".*"
+];
+var DEFAULT_EXCLUDES = (process.env.MORPH_WARP_GREP_EXCLUDE || "").split(",").map((s) => s.trim()).filter(Boolean).concat(BUILTIN_EXCLUDES);
 var DEFAULT_MODEL = "morph-warp-grep";
 
 // tools/warp_grep/agent/prompt.ts
-var SYSTEM_PROMPT = `You are a code search agent. Your task is to find relevant code snippets based on a search query.
+var SYSTEM_PROMPT = `You are a code search agent. Your task is to find all relevant code for a given query.
 
 <workflow>
-You operate in exactly 3 rounds of tool exploration, followed by a final answer:
+You have exactly 4 turns. The 4th turn MUST be a \`finish\` call. Each turn allows up to 8 parallel tool calls.
 
-1. In each round, you can make MULTIPLE tool calls (up to 8) to search in parallel. All tool results will be returned together after each round.
-2. After your third round of tool calls, your next turn MUST be a single call to the \`finish\` tool with all the context you have found.
-</workflow>
+- Turn 1: Map the territory OR dive deep (based on query specificity)
+- Turn 2-3: Refine based on findings
+- Turn 4: MUST call \`finish\` with all relevant code locations
+- You MAY call \`finish\` early if confident\u2014but never before at least 1 search turn.
 
-<tool_calling>
-You have tools at your disposal to solve the coding task. Follow these rules regarding tool calls:
+Remember, if the task feels easy to you, it is strongly desirable to call \`finish\` early using fewer turns, but quality over speed.
+</workflow>
 
-### 1. \`analyse\` - Explore Directories
-Explore directory structure in a tree-like format.
-**Syntax:** \`analyse <path> [pattern]\`
-- \`<path>\`: Directory path to analyze (defaults to \`.\`)
-- \`[pattern]\`: Optional regex pattern to filter names
+<tools>
+### \`analyse <path> [pattern]\`
+Directory tree or file search. Shows structure of a path, optionally filtered by regex pattern.
+- \`path\`: Required. Directory or file path (use \`.\` for repo root)
+- \`pattern\`: Optional regex to filter results
 
-For example:
+Examples:
 \`\`\`
+analyse .
 analyse src/api
-analyse . "test"
+analyse . ".*\\.ts$"
+analyse src "test.*"
 \`\`\`
 
-### 2. \`read\` - Read File Contents
-Read entire files or specific line ranges.
-**Syntax:** \`read <path>[:start-end]\`
-- \`<path>\`: File path to read
-- \`[:start-end]\`: Optional 1-based, inclusive line range
+### \`read <path>[:start-end]\`
+Read file contents. Line range is 1-based, inclusive.
+- Returns numbered lines for easy reference
+- Omit range to read entire file
 
-For example:
+Examples:
 \`\`\`
 read src/main.py
-read src/database/connection.py:10-50
+read src/db/conn.py:10-50
+read package.json:1-20
 \`\`\`
 
-### 3. \`grep\` - Search with Regex
-Search for regex patterns across files using ripgrep.
-**Syntax:** \`grep '<pattern>' <path>\`
-- \`'<pattern>'\`: Regex pattern (always wrap in single quotes)
-- \`<path>\`: Directory or file to search (use \`.\` for the repo root)
+### \`grep '<pattern>' <path>\`
+Ripgrep search. Finds pattern matches across files.
+- \`'<pattern>'\`: Required. Regex pattern wrapped in single quotes
+- \`<path>\`: Required. Directory or file to search (use \`.\` for repo root)
 
-For example:
+Examples:
 \`\`\`
-grep 'create_user' .
-grep 'import.*requests' src/api
-grep 'class\\\\s+AuthService' controllers/auth.py
+grep 'class.*Service' src/
+grep 'def authenticate' .
+grep 'import.*from' src/components/
+grep 'TODO' .
 \`\`\`
 
-### 4. \`finish\` - Submit Final Answer
-Submit your findings when complete.
-**Syntax:** \`finish <file1:range1,range2...> [file2:range3...]\`
-- Provide file paths with colon-separated, comma-separated line ranges
+### \`finish <file1:ranges> [file2:ranges ...]\`
+Submit final answer with all relevant code locations.
+- Include generous line ranges\u2014don't be stingy with context
+- Ranges are comma-separated: \`file.py:10-30,50-60\`
+- ALWAYS include import statements at the top of files (usually lines 1-20)
+- If code spans multiple files, include ALL of them
+- Small files can be returned in full
 
-For example:
+Examples:
 \`\`\`
-finish src/api/auth.py:25-50,75-80 src/models/user.py:10-15
+finish src/auth.py:1-15,25-50,75-80 src/models/user.py:1-10,20-45
+finish src/index.ts:1-100
 \`\`\`
-</tool_calling>
+</tools>
 
 <strategy>
-- Use the \`analyse\`, \`grep\`, and \`read\` tools to gather information about the codebase.
-- Leverage the tools smartly to make full use of their potential
-- Make parallel tool calls within each round to investigate multiple paths or files efficiently
-- Be systematic and thorough within your 3-round limit
+**Before your first tool call, classify the query:**
+
+| Query Type | Turn 1 Strategy | Early Finish? |
+|------------|-----------------|---------------|
+| **Specific** (function name, error string, unique identifier) | 8 parallel greps on likely paths | Often by turn 2 |
+| **Conceptual** (how does X work, where is Y handled) | analyse + 2-3 broad greps | Rarely early |
+| **Exploratory** (find all tests, list API endpoints) | analyse at multiple depths | Usually needs 3 turns |
+
+**Parallel call patterns:**
+- **Shotgun grep**: Same pattern, 8 different directories\u2014fast coverage
+- **Variant grep**: 8 pattern variations (synonyms, naming conventions)\u2014catches inconsistent codebases
+- **Funnel**: 1 analyse + 7 greps\u2014orient and search simultaneously
+- **Deep read**: 8 reads on files you already identified\u2014gather full context fast
 </strategy>
 
 <output_format>
-- Only output tool calls themselves
-- Do not include explanatory text, reasoning, or commentary
-- Each tool call should be on its own line
-- After 3 rounds of exploration, call \`finish\` with all relevant code snippets you found
+EVERY response MUST follow this exact format:
+
+1. First, wrap your reasoning in \`<think>...</think>\` tags containing:
+   - Query classification (specific/conceptual/exploratory)
+   - Confidence estimate (can I finish in 1-2 turns?)
+   - This turn's parallel strategy
+   - What signals would let me finish early?
+
+2. Then, output tool calls wrapped in \`<tool_call>...</tool_call>\` tags, one per line.
+
+Example:
+\`\`\`
+<think>
+This is a specific query about authentication. I'll grep for auth-related patterns.
+High confidence I can finish in 2 turns if I find the auth module.
+Strategy: Shotgun grep across likely directories.
+</think>
+<tool_call>grep 'authenticate' src/</tool_call>
+<tool_call>grep 'login' src/</tool_call>
+<tool_call>analyse src/auth</tool_call>
+\`\`\`
+
+No commentary outside \`<think>\`. No explanations after tool calls.
 </output_format>
 
+<finishing_requirements>
+When calling \`finish\`:
+- Include the import section (typically lines 1-20) of each file
+- Include all function/class definitions that are relevant
+- Include any type definitions, interfaces, or constants used
+- Better to over-include than leave the user missing context
+- If unsure about boundaries, include more rather than less
+</finishing_requirements>
+
 Begin your exploration now to find code relevant to the query.`;
 function getSystemPrompt() {
   return SYSTEM_PROMPT;
@@ -132,13 +258,54 @@ var LLMResponseParseError = class extends Error {
     this.name = "LLMResponseParseError";
   }
 };
+var VALID_COMMANDS = ["analyse", "grep", "read", "finish"];
+function preprocessText(text) {
+  let processed = text.replace(/<think>[\s\S]*?<\/think>/gi, "");
+  const openingTagRegex = /<tool_call>|<tool>/gi;
+  const closingTagRegex = /<\/tool_call>|<\/tool>/gi;
+  const openingMatches = processed.match(openingTagRegex) || [];
+  const closingMatches = processed.match(closingTagRegex) || [];
+  if (openingMatches.length > closingMatches.length) {
+    const lastClosingMatch = /<\/tool_call>|<\/tool>/gi;
+    let lastClosingIndex = -1;
+    let match;
+    while ((match = lastClosingMatch.exec(processed)) !== null) {
+      lastClosingIndex = match.index + match[0].length;
+    }
+    if (lastClosingIndex > 0) {
+      processed = processed.slice(0, lastClosingIndex);
+    }
+  }
+  const toolCallLines = [];
+  const toolTagRegex = /<tool_call>([\s\S]*?)<\/tool_call>|<tool>([\s\S]*?)<\/tool>/gi;
+  let tagMatch;
+  while ((tagMatch = toolTagRegex.exec(processed)) !== null) {
+    const content = (tagMatch[1] || tagMatch[2] || "").trim();
+    if (content) {
+      const lines = content.split(/\r?\n/).map((l) => l.trim()).filter((l) => l);
+      toolCallLines.push(...lines);
+    }
+  }
+  const allLines = processed.split(/\r?\n/).map((l) => l.trim());
+  for (const line of allLines) {
+    if (!line) continue;
+    if (line.startsWith("<")) continue;
+    const firstWord = line.split(/\s/)[0];
+    if (VALID_COMMANDS.includes(firstWord)) {
+      if (!toolCallLines.includes(line)) {
+        toolCallLines.push(line);
+      }
+    }
+  }
+  return toolCallLines;
+}
 var LLMResponseParser = class {
   finishSpecSplitRe = /,(?=[^,\s]+:)/;
   parse(text) {
     if (typeof text !== "string") {
       throw new TypeError("Command text must be a string.");
     }
-    const lines = text.split(/\r?\n/).map((l) => l.trim());
+    const lines = preprocessText(text);
     const commands = [];
     let finishAccumulator = null;
     lines.forEach((line, idx) => {
@@ -161,7 +328,7 @@ var LLMResponseParser = class {
           finishAccumulator = this.handleFinish(parts, ctx, finishAccumulator);
           break;
         default:
-          throw new LLMResponseParseError(`Line ${ctx.lineNumber}: Unsupported command '${cmd}'`);
+          break;
       }
     });
     if (finishAccumulator) {
@@ -703,7 +870,23 @@ async function runWarpGrep(config) {
       }
     }
     if (formatted.length > 0) {
-      messages.push({ role: "user", content: formatted.join("\n") });
+      const turnsUsed = round;
+      const turnsRemaining = 4 - turnsUsed;
+      let turnMessage;
+      if (turnsRemaining === 0) {
+        turnMessage = `
+
+[Turn ${turnsUsed}/4] This is your LAST turn. You MUST call the finish tool now.`;
+      } else if (turnsRemaining === 1) {
+        turnMessage = `
+
+[Turn ${turnsUsed}/4] You have 1 turn remaining. Next turn you MUST call the finish tool.`;
+      } else {
+        turnMessage = `
+
+[Turn ${turnsUsed}/4] You have ${turnsRemaining} turns remaining.`;
+      }
+      messages.push({ role: "user", content: formatted.join("\n") + turnMessage });
     }
     if (finishCalls.length) {
       const fc = finishCalls[0];
@@ -931,14 +1114,62 @@ var LocalRipgrepProvider = class {
   }
 };
 
+// tools/warp_grep/prompts.ts
+var WARP_GREP_DESCRIPTION = "A fast and accurate tool that can search for all relevant context in a codebase. You must use this tool to save time and avoid context pollution.";
+
+// tools/warp_grep/core.ts
+function formatResult(result) {
+  if (!result.success) {
+    return `Search failed: ${result.error}`;
+  }
+  if (!result.contexts || result.contexts.length === 0) {
+    return "No relevant code found. Try rephrasing your query.";
+  }
+  const lines = [];
+  lines.push(`Found ${result.contexts.length} relevant code sections:
+`);
+  result.contexts.forEach((ctx, i) => {
+    lines.push(`${i + 1}. ${ctx.file}`);
+    lines.push("```");
+    lines.push(ctx.content);
+    lines.push("```");
+    lines.push("");
+  });
+  if (result.summary) {
+    lines.push(`Summary: ${result.summary}`);
+  }
+  return lines.join("\n");
+}
+
 // tools/warp_grep/vercel.ts
-function createMorphWarpGrepTool(config) {
-  const schema = import_zod.z.object({
-    query: import_zod.z.string().describe("Free-form repository question")
+var warpGrepSchema = import_zod.z.object({
+  query: import_zod.z.string().describe("Free-form repository question")
+});
+async function execute(input, config) {
+  const provider = config.provider ?? new LocalRipgrepProvider(config.repoRoot, config.excludes);
+  const result = await runWarpGrep({
+    query: input.query,
+    repoRoot: config.repoRoot,
+    provider,
+    excludes: config.excludes,
+    includes: config.includes,
+    debug: config.debug ?? false,
+    apiKey: config.apiKey
   });
+  const finish = result.finish;
+  if (result.terminationReason !== "completed" || !finish?.metadata) {
+    return { success: false, error: "Search did not complete" };
+  }
+  const contexts = (finish.resolved ?? []).map((r) => ({
+    file: r.path,
+    content: r.content
+  }));
+  return { success: true, contexts, summary: finish.payload };
+}
+function createMorphWarpGrepTool(config) {
   return (0, import_ai.tool)({
-    description: config.description ?? "A fast and accurate tool that can search for all relevant context in a codebase. You must use this tool to save time and avoid context pollution.",
-    inputSchema: schema,
+    description: config.description ?? WARP_GREP_DESCRIPTION,
+    inputSchema: warpGrepSchema,
     execute: async (params) => {
       const provider = config.provider ?? new LocalRipgrepProvider(config.repoRoot, config.excludes);
       const result = await runWarpGrep({
@@ -952,7 +1183,7 @@ function createMorphWarpGrepTool(config) {
       });
       const finish = result.finish;
       if (result.terminationReason !== "completed" || !finish?.metadata) {
-        return { success: false, error: "Search did not complete", messages: result.messages };
+        return { success: false, error: "Search did not complete" };
       }
       const contexts = (finish.resolved ?? []).map((r) => ({
         file: r.path,
@@ -964,6 +1195,9 @@ function createMorphWarpGrepTool(config) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  createMorphWarpGrepTool
+  createMorphWarpGrepTool,
+  execute,
+  formatResult,
+  getSystemPrompt
 });
 //# sourceMappingURL=vercel.cjs.map