@morphllm/morphsdk 0.2.84 → 0.2.85

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

@@ -1,9 +1,10 @@
 import { FunctionDeclaration } from '@google/generative-ai';
 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';
 
 /**
  * Google Gemini SDK adapter for morph-warp-grep tool

package/dist/tools/warp_grep/gemini.js

@@ -5,8 +5,8 @@ import {
 import {
   executeToolCall,
   formatResult
-} from "../../chunk-D4EQYM6O.js";
-import "../../chunk-LF2X6YNP.js";
+} from "../../chunk-37SJ3IOY.js";
+import "../../chunk-HJOMBO2A.js";
 import "../../chunk-PUGSTXLO.js";
 import "../../chunk-KRDIR7GG.js";
 import "../../chunk-APP75CBN.js";

package/dist/tools/warp_grep/index.cjs

@@ -44,6 +44,7 @@ __export(warp_grep_exports, {
   normalizeFinishFiles: () => normalizeFinishFiles,
   readFinishFiles: () => readFinishFiles,
   runWarpGrep: () => runWarpGrep,
+  runWarpGrepStreaming: () => runWarpGrepStreaming,
   toolGrep: () => toolGrep,
   toolListDirectory: () => toolListDirectory,
   toolRead: () => toolRead,
@@ -1181,6 +1182,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);
@@ -1774,48 +1925,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;
@@ -1842,6 +1976,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}`;
@@ -1889,6 +2060,7 @@ var warpGrepInputSchema = import_zod.z.object({
   normalizeFinishFiles,
   readFinishFiles,
   runWarpGrep,
+  runWarpGrepStreaming,
   toolGrep,
   toolListDirectory,
   toolRead,