@morphllm/morphsdk 0.2.83 → 0.2.85

package/dist/tools/warp_grep/anthropic.d.ts

@@ -1,9 +1,10 @@
 import { Tool } from '@anthropic-ai/sdk/resources/messages';
 export { formatResult } from './client.js';
 export { getSystemPrompt } from './agent/prompt.js';
-import { d as WarpGrepToolConfig, b as WarpGrepResult } from '../../types-Cv4LpqVl.js';
-import './providers/types.js';
+import { d as WarpGrepToolConfig, b as WarpGrepResult } from '../../types-BMowL9iZ.js';
+import './agent/types.js';
 import '../utils/resilience.js';
+import './providers/types.js';
 
 /**
  * Anthropic SDK adapter for morph-warp-grep tool

package/dist/tools/warp_grep/anthropic.js

@@ -2,14 +2,14 @@ import {
   createWarpGrepTool,
   execute,
   warpGrepTool
-} from "../../chunk-RL4JBZ3T.js";
+} from "../../chunk-AJEE5RRB.js";
 import "../../chunk-KW7OEGZK.js";
 import {
   formatResult
-} from "../../chunk-HRK53IKL.js";
-import "../../chunk-QOYI77CN.js";
+} from "../../chunk-37SJ3IOY.js";
+import "../../chunk-HJOMBO2A.js";
 import "../../chunk-PUGSTXLO.js";
-import "../../chunk-P2O5JKE5.js";
+import "../../chunk-KRDIR7GG.js";
 import "../../chunk-APP75CBN.js";
 import "../../chunk-5QRN3JNB.js";
 import {

package/dist/tools/warp_grep/client.cjs

@@ -648,14 +648,23 @@ async function toolRead(provider, args) {
 
 // tools/warp_grep/agent/tools/list_directory.ts
 async function toolListDirectory(provider, args) {
-  const list = await provider.listDirectory({
-    path: args.path,
-    pattern: args.pattern ?? null,
-    maxResults: args.maxResults ?? AGENT_CONFIG.MAX_OUTPUT_LINES,
-    maxDepth: args.maxDepth ?? AGENT_CONFIG.MAX_LIST_DEPTH
-  });
+  const maxResults = args.maxResults ?? AGENT_CONFIG.MAX_OUTPUT_LINES;
+  const initialDepth = args.maxDepth ?? AGENT_CONFIG.MAX_LIST_DEPTH;
+  async function getListRecursive(currentDepth) {
+    const entries = await provider.listDirectory({
+      path: args.path,
+      pattern: args.pattern ?? null,
+      maxResults,
+      maxDepth: currentDepth
+    });
+    if (entries.length >= maxResults && currentDepth > 0) {
+      return getListRecursive(currentDepth - 1);
+    }
+    return { entries };
+  }
+  const { entries: list } = await getListRecursive(initialDepth);
   if (!list.length) return "empty";
-  if (list.length >= AGENT_CONFIG.MAX_OUTPUT_LINES) {
+  if (list.length >= maxResults) {
     return "query not specific enough, tool called tried to return too much context and failed";
   }
   return list.map((e) => {
@@ -1149,6 +1158,156 @@ async function runWarpGrep(config) {
     timings
   };
 }
+async function* runWarpGrepStreaming(config) {
+  const totalStart = Date.now();
+  const timeoutMs = config.timeout ?? AGENT_CONFIG.TIMEOUT_MS;
+  const timings = { turns: [], timeout_ms: timeoutMs };
+  const repoRoot = import_path2.default.resolve(config.repoRoot || process.cwd());
+  const messages = [];
+  messages.push({ role: "system", content: getSystemPrompt() });
+  const initialStateStart = Date.now();
+  const initialState = await buildInitialState(repoRoot, config.query, config.provider);
+  timings.initial_state_ms = Date.now() - initialStateStart;
+  messages.push({ role: "user", content: initialState });
+  const maxTurns = AGENT_CONFIG.MAX_TURNS;
+  const model = config.model || DEFAULT_MODEL;
+  const provider = config.provider;
+  const errors = [];
+  let finishMeta;
+  let terminationReason = "terminated";
+  for (let turn = 1; turn <= maxTurns; turn += 1) {
+    const turnMetrics = { turn, morph_api_ms: 0, local_tools_ms: 0 };
+    enforceContextLimit(messages);
+    const modelCallStart = Date.now();
+    const assistantContent = await callModel(messages, model, {
+      morphApiKey: config.morphApiKey,
+      morphApiUrl: config.morphApiUrl,
+      retryConfig: config.retryConfig,
+      timeout: timeoutMs
+    }).catch((e) => {
+      errors.push({ message: e instanceof Error ? e.message : String(e) });
+      return "";
+    });
+    turnMetrics.morph_api_ms = Date.now() - modelCallStart;
+    if (!assistantContent) {
+      timings.turns.push(turnMetrics);
+      break;
+    }
+    messages.push({ role: "assistant", content: assistantContent });
+    const toolCalls = parser.parse(assistantContent);
+    if (toolCalls.length === 0) {
+      errors.push({ message: "No tool calls produced by the model. Your MCP is likely out of date! Update it by running: rm -rf ~/.npm/_npx && npm cache clean --force && npx -y @morphllm/morphmcp@latest" });
+      terminationReason = "terminated";
+      timings.turns.push(turnMetrics);
+      break;
+    }
+    yield {
+      turn,
+      toolCalls: toolCalls.map((c) => ({
+        name: c.name,
+        arguments: c.arguments ?? {}
+      }))
+    };
+    const finishCalls = toolCalls.filter((c) => c.name === "finish");
+    const grepCalls = toolCalls.filter((c) => c.name === "grep");
+    const listDirCalls = toolCalls.filter((c) => c.name === "list_directory");
+    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 allPromises = [];
+    for (const c of grepCalls) {
+      const args = c.arguments ?? {};
+      allPromises.push(
+        toolGrep(provider, args).then(
+          ({ output }) => formatAgentToolOutput("grep", args, output, { isError: false }),
+          (err) => formatAgentToolOutput("grep", args, String(err), { isError: true })
+        )
+      );
+    }
+    for (const c of listDirCalls) {
+      const args = c.arguments ?? {};
+      allPromises.push(
+        toolListDirectory(provider, args).then(
+          (p) => formatAgentToolOutput("list_directory", args, p, { isError: false }),
+          (err) => formatAgentToolOutput("list_directory", args, String(err), { isError: true })
+        )
+      );
+    }
+    for (const c of readCalls) {
+      const args = c.arguments ?? {};
+      allPromises.push(
+        toolRead(provider, args).then(
+          (p) => formatAgentToolOutput("read", args, p, { isError: false }),
+          (err) => formatAgentToolOutput("read", args, String(err), { isError: true })
+        )
+      );
+    }
+    const toolExecStart = Date.now();
+    const allResults = await Promise.all(allPromises);
+    turnMetrics.local_tools_ms = Date.now() - toolExecStart;
+    for (const result of allResults) {
+      formatted.push(result);
+    }
+    if (formatted.length > 0) {
+      const turnMessage = formatTurnMessage(turn, maxTurns);
+      const contextBudget = calculateContextBudget(messages);
+      messages.push({ role: "user", content: formatted.join("\n") + turnMessage + "\n" + contextBudget });
+    }
+    timings.turns.push(turnMetrics);
+    if (finishCalls.length) {
+      const fc = finishCalls[0];
+      const files = fc.arguments?.files ?? [];
+      finishMeta = { files };
+      terminationReason = "completed";
+      break;
+    }
+  }
+  if (terminationReason !== "completed" || !finishMeta) {
+    timings.total_ms = Date.now() - totalStart;
+    return { terminationReason, messages, errors, timings };
+  }
+  const parts = ["Relevant context found:"];
+  for (const f of finishMeta.files) {
+    const ranges = f.lines === "*" ? "*" : Array.isArray(f.lines) ? f.lines.map(([s, e]) => `${s}-${e}`).join(", ") : "*";
+    parts.push(`- ${f.path}: ${ranges}`);
+  }
+  const payload = parts.join("\n");
+  const finishResolutionStart = Date.now();
+  const fileReadErrors = [];
+  const resolved = await readFinishFiles(
+    repoRoot,
+    finishMeta.files,
+    async (p, s, e) => {
+      try {
+        const rr = await provider.read({ path: p, start: s, end: e });
+        return rr.lines.map((l) => {
+          const idx = l.indexOf("|");
+          return idx >= 0 ? l.slice(idx + 1) : l;
+        });
+      } catch (err) {
+        const errorMsg = err instanceof Error ? err.message : String(err);
+        fileReadErrors.push({ path: p, error: errorMsg });
+        console.error(`[warp_grep] Failed to read file: ${p} - ${errorMsg}`);
+        return [`[couldn't find: ${p}]`];
+      }
+    }
+  );
+  timings.finish_resolution_ms = Date.now() - finishResolutionStart;
+  if (fileReadErrors.length > 0) {
+    errors.push(...fileReadErrors.map((e) => ({ message: `File read error: ${e.path} - ${e.error}` })));
+  }
+  timings.total_ms = Date.now() - totalStart;
+  return {
+    terminationReason: "completed",
+    messages,
+    finish: { payload, metadata: finishMeta, resolved },
+    timings
+  };
+}
 
 // tools/warp_grep/providers/local.ts
 var import_promises2 = __toESM(require("fs/promises"), 1);
@@ -1742,48 +1901,31 @@ var WarpGrepClient = class {
       retryConfig: config.retryConfig
     };
   }
-  /**
-   * Execute a code search query
-   * 
-   * @param input - Search parameters including query, repoRoot, and optional provider
-   * @returns Search results with relevant code contexts
-   * 
-   * @example
-   * ```typescript
-   * const result = await client.execute({
-   *   query: 'Find authentication middleware',
-   *   repoRoot: '.'
-   * });
-   * 
-   * if (result.success) {
-   *   for (const ctx of result.contexts) {
-   *     console.log(`File: ${ctx.file}`);
-   *     console.log(ctx.content);
-   *   }
-   * }
-   * ```
-   */
-  async execute(input) {
-    return executeToolCall(
-      { query: input.query },
-      {
-        repoRoot: input.repoRoot,
-        remoteCommands: input.remoteCommands,
-        provider: input.provider,
-        excludes: input.excludes,
-        includes: input.includes,
-        debug: input.debug ?? this.config.debug,
-        morphApiKey: this.config.morphApiKey,
-        morphApiUrl: this.config.morphApiUrl,
-        retryConfig: this.config.retryConfig,
-        timeout: this.config.timeout
-      }
-    );
+  execute(input) {
+    const toolConfig = {
+      repoRoot: input.repoRoot,
+      remoteCommands: input.remoteCommands,
+      provider: input.provider,
+      excludes: input.excludes,
+      includes: input.includes,
+      debug: input.debug ?? this.config.debug,
+      morphApiKey: this.config.morphApiKey,
+      morphApiUrl: this.config.morphApiUrl,
+      retryConfig: this.config.retryConfig,
+      timeout: this.config.timeout
+    };
+    if (input.streamSteps) {
+      return executeToolCallStreaming({ query: input.query }, toolConfig);
+    }
+    return executeToolCall({ query: input.query }, toolConfig);
   }
 };
-async function executeWarpGrep(input, config) {
+function executeWarpGrep(input, config) {
   const client = new WarpGrepClient(config);
-  return client.execute(input);
+  if (input.streamSteps) {
+    return client.execute({ ...input, streamSteps: true });
+  }
+  return client.execute({ ...input, streamSteps: false });
 }
 async function executeToolCall(input, config) {
   const parsed = typeof input === "string" ? JSON.parse(input) : input;
@@ -1810,6 +1952,43 @@ async function executeToolCall(input, config) {
   }));
   return { success: true, contexts, summary: finish.payload };
 }
+function processAgentResult(result) {
+  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 };
+}
+async function* executeToolCallStreaming(input, config) {
+  const parsed = typeof input === "string" ? JSON.parse(input) : input;
+  const provider = config.remoteCommands ? new RemoteCommandsProvider(config.repoRoot, config.remoteCommands) : config.provider ?? new LocalRipgrepProvider(config.repoRoot, config.excludes);
+  const generator = runWarpGrepStreaming({
+    query: parsed.query,
+    repoRoot: config.repoRoot,
+    provider,
+    excludes: config.excludes,
+    includes: config.includes,
+    debug: config.debug ?? false,
+    morphApiKey: config.morphApiKey,
+    morphApiUrl: config.morphApiUrl,
+    retryConfig: config.retryConfig,
+    timeout: config.timeout
+  });
+  let agentResult;
+  for (; ; ) {
+    const { value, done } = await generator.next();
+    if (done) {
+      agentResult = value;
+      break;
+    }
+    yield value;
+  }
+  return processAgentResult(agentResult);
+}
 function formatResult(result) {
   if (!result.success) {
     return `Search failed: ${result.error}`;