@morphllm/morphsdk 0.2.162 → 0.2.163

package/dist/tools/warp_grep/openai.js

@@ -5,13 +5,13 @@ import {
   execute,
   openai_default,
   warpGrepTool
-} from "../../chunk-UETFIUIG.js";
+} from "../../chunk-5BMWOPYW.js";
 import "../../chunk-Q6QCHAMD.js";
 import {
   formatResult
-} from "../../chunk-OGMHU4PJ.js";
+} from "../../chunk-LSHQISAX.js";
 import "../../chunk-63VHBANJ.js";
-import "../../chunk-7QMX45QD.js";
+import "../../chunk-ZMCDGAGF.js";
 import "../../chunk-GVGJIXV2.js";
 import "../../chunk-B3AKP3RA.js";
 import "../../chunk-VNAGVCSP.js";
@@ -19,7 +19,8 @@ import "../../chunk-FBRNUWEB.js";
 import "../../chunk-I3J46TSB.js";
 import "../../chunk-GLQWEINZ.js";
 import "../../chunk-SCVWDNQP.js";
-import "../../chunk-ZG3YLRR5.js";
+import "../../chunk-5AM23TC7.js";
+import "../../chunk-LST7MZOZ.js";
 import "../../chunk-PZ5AY32C.js";
 export {
   createGitHubReadFileTool,

package/dist/tools/warp_grep/vercel.cjs

@@ -220,7 +220,7 @@ function toRepoRelative(repoRoot, absPath) {
 }
 function isSymlink(p) {
   try {
-    const st = import_fs.default.lstatSync(p);
+    const st = import_fs2.default.lstatSync(p);
     return st.isSymbolicLink();
   } catch {
     return false;
@@ -243,13 +243,13 @@ function fixPathRepetition(fullPath) {
 }
 function isTextualFile(filePath, maxBytes = 2e6) {
   try {
-    const st = import_fs.default.statSync(filePath);
+    const st = import_fs2.default.statSync(filePath);
     if (!st.isFile()) return false;
     if (st.size > maxBytes) return false;
-    const fd = import_fs.default.openSync(filePath, "r");
+    const fd = import_fs2.default.openSync(filePath, "r");
     const buf = Buffer.alloc(512);
-    const read = import_fs.default.readSync(fd, buf, 0, buf.length, 0);
-    import_fs.default.closeSync(fd);
+    const read = import_fs2.default.readSync(fd, buf, 0, buf.length, 0);
+    import_fs2.default.closeSync(fd);
     for (let i = 0; i < read; i++) {
       const c = buf[i];
       if (c === 0) return false;
@@ -259,11 +259,11 @@ function isTextualFile(filePath, maxBytes = 2e6) {
     return false;
   }
 }
-var import_fs, import_path4;
+var import_fs2, import_path4;
 var init_paths = __esm({
   "tools/warp_grep/utils/paths.ts"() {
     "use strict";
-    import_fs = __toESM(require("fs"), 1);
+    import_fs2 = __toESM(require("fs"), 1);
     import_path4 = __toESM(require("path"), 1);
   }
 });
@@ -942,7 +942,7 @@ var import_openai = __toESM(require("openai"), 1);
 // package.json
 var package_default = {
   name: "@morphllm/morphsdk",
-  version: "0.2.162",
+  version: "0.2.163",
   description: "TypeScript SDK and CLI for Morph Fast Apply integration",
   type: "module",
   main: "./dist/index.cjs",
@@ -954,6 +954,11 @@ var package_default = {
       import: "./dist/index.js",
       require: "./dist/index.cjs"
     },
+    "./logger": {
+      types: "./dist/logger.d.ts",
+      import: "./dist/logger.js",
+      require: "./dist/logger.cjs"
+    },
     "./edge": {
       types: "./dist/edge.d.ts",
       import: "./dist/edge.js",
@@ -1182,6 +1187,46 @@ var SDK_VERSION = package_default.version;
 
 // tools/warp_grep/agent/runner.ts
 var import_path3 = __toESM(require("path"), 1);
+
+// logger.ts
+var import_fs = require("fs");
+var MorphLogger = class {
+  enabled;
+  fileStream;
+  constructor() {
+    this.enabled = process.env.MORPH_DEBUG === "1" || !!process.env.MORPH_LOG_FILE;
+    const f = process.env.MORPH_LOG_FILE;
+    this.fileStream = f ? (0, import_fs.createWriteStream)(f, { flags: "a" }) : null;
+  }
+  debug(component, msg, data) {
+    this._log("debug", component, msg, data);
+  }
+  info(component, msg, data) {
+    this._log("info", component, msg, data);
+  }
+  warn(component, msg, data) {
+    this._log("warn", component, msg, data);
+  }
+  error(component, msg, data) {
+    this._log("error", component, msg, data);
+  }
+  enable() {
+    this.enabled = true;
+  }
+  get isEnabled() {
+    return this.enabled;
+  }
+  _log(level, component, msg, data) {
+    if (level !== "error" && !this.enabled) return;
+    const ts = (/* @__PURE__ */ new Date()).toISOString();
+    const prefix = `[${ts}] [${level.toUpperCase()}] [${component}]`;
+    console.error(data ? `${prefix} ${msg} ${JSON.stringify(data)}` : `${prefix} ${msg}`);
+    this.fileStream?.write(JSON.stringify({ ts, level, component, msg, ...data && { data } }) + "\n");
+  }
+};
+var logger = new MorphLogger();
+
+// tools/warp_grep/agent/runner.ts
 var DEFAULT_API_URL = "https://api.morphllm.com";
 var TOOL_SPECS = [
   {
@@ -1304,6 +1349,8 @@ async function callModel(messages, model, options = {}) {
     defaultHeaders: { "X-Morph-SDK-Version": SDK_VERSION }
   });
   const MAX_EMPTY_RETRIES = 1;
+  logger.debug("WarpGrep", "model_call", { url: baseURL, model, message_count: messages.length });
+  const callStartTime = Date.now();
   for (let attempt = 0; attempt <= MAX_EMPTY_RETRIES; attempt++) {
     let data;
     try {
@@ -1316,10 +1363,16 @@ async function callModel(messages, model, options = {}) {
         ...options.search_type ? { search_type: options.search_type } : {}
       });
     } catch (error) {
-      if (error instanceof import_openai.default.APIError && error.status === 404) {
-        const defaultMsg = "The endpoint you are trying to call is likely deprecated. Please update with: npm cache clean --force && npx -y @morphllm/morphmcp@latest or visit: https://morphllm.com/mcp";
-        const errorText = error.message?.trim();
-        throw new Error(errorText || defaultMsg);
+      const callLatencyMs = Date.now() - callStartTime;
+      if (error instanceof import_openai.default.APIError) {
+        logger.error("WarpGrep", "model_call_error", { status: error.status, error: error.message, latency_ms: callLatencyMs });
+        if (error.status === 404) {
+          const defaultMsg = "The endpoint you are trying to call is likely deprecated. Please update with: npm cache clean --force && npx -y @morphllm/morphmcp@latest or visit: https://morphllm.com/mcp";
+          const errorText = error.message?.trim();
+          throw new Error(errorText || defaultMsg);
+        }
+      } else {
+        logger.error("WarpGrep", "model_call_error", { status: void 0, error: error instanceof Error ? error.message : String(error), latency_ms: callLatencyMs });
       }
       throw error;
     }
@@ -1338,6 +1391,7 @@ async function callModel(messages, model, options = {}) {
       function: { name: tc.function.name, arguments: tc.function.arguments }
     }));
     if (message.content || toolCalls.length > 0) {
+      logger.debug("WarpGrep", "model_call_complete", { latency_ms: Date.now() - callStartTime, tool_calls_count: toolCalls.length, finish_reason: choice?.finish_reason ?? "unknown" });
       return { content: message.content ?? null, tool_calls: toolCalls };
     }
     if (attempt === MAX_EMPTY_RETRIES) {
@@ -1408,9 +1462,11 @@ async function* runWarpGrepStreaming(config) {
   const model = config.model || DEFAULT_MODEL;
   const messages = [];
   const maxTurns = AGENT_CONFIG.MAX_TURNS;
+  logger.debug("WarpGrep", "session_start", { search_term: config.searchTerm, model, max_turns: maxTurns });
   const initialStateStart = Date.now();
   const initialState = await buildInitialState(repoRoot, config.searchTerm, config.provider, { search_type: config.search_type });
   timings.initial_state_ms = Date.now() - initialStateStart;
+  logger.debug("WarpGrep", "initial_state", { system_prompt_len: initialState.length, user_message_len: initialState.length });
   messages.push({ role: "user", content: initialState });
   const provider = config.provider;
   const errors = [];
@@ -1418,7 +1474,13 @@ async function* runWarpGrepStreaming(config) {
   let terminationReason = "terminated";
   for (let turn = 1; turn <= maxTurns; turn += 1) {
     const turnMetrics = { turn, morph_api_ms: 0, local_tools_ms: 0 };
+    logger.debug("WarpGrep", "turn_start", { turn, message_count: messages.length });
+    const beforeChars = messages.reduce((sum, m) => sum + (typeof m.content === "string" ? m.content.length : 0), 0);
     enforceContextLimit(messages);
+    const afterChars = messages.reduce((sum, m) => sum + (typeof m.content === "string" ? m.content.length : 0), 0);
+    if (afterChars < beforeChars) {
+      logger.debug("WarpGrep", "context_truncated", { before_chars: beforeChars, after_chars: afterChars });
+    }
     const modelCallStart = Date.now();
     const response = await callModel(messages, model, {
       morphApiKey: config.morphApiKey,
@@ -1429,6 +1491,7 @@ async function* runWarpGrepStreaming(config) {
     }).catch((e) => {
       const errMsg = e instanceof Error ? e.message : String(e);
       console.error(`[warp_grep] Morph API call failed on turn ${turn}:`, errMsg);
+      logger.error("WarpGrep", "error", { turn, error: errMsg, phase: "model_call" });
       errors.push({ message: errMsg });
       return null;
     });
@@ -1438,6 +1501,7 @@ async function* runWarpGrepStreaming(config) {
       break;
     }
     const toolCalls = response.tool_calls;
+    logger.debug("WarpGrep", "model_response", { turn, tool_calls: toolCalls.map((tc) => tc.function.name), latency_ms: turnMetrics.morph_api_ms });
     messages.push({
       role: "assistant",
       content: response.content,
@@ -1464,6 +1528,7 @@ async function* runWarpGrepStreaming(config) {
       const files = parseFinishFiles(filesStr);
       finishMeta = { files };
       terminationReason = "completed";
+      logger.debug("WarpGrep", "finish", { turns: turn, files: files.map((f) => f.path) });
       if (files.length === 0) {
         const payload2 = filesStr || "No relevant code found.";
         timings.turns.push(turnMetrics);
@@ -1482,7 +1547,11 @@ async function* runWarpGrepStreaming(config) {
     const results = await Promise.all(
       toolCalls.map(async (tc) => {
         const args = safeParseJSON(tc.function.arguments);
+        const argsSummary = Object.fromEntries(Object.entries(args).map(([k, v]) => [k, typeof v === "string" && v.length > 100 ? v.slice(0, 100) + "..." : v]));
+        logger.debug("WarpGrep", "tool_exec", { turn, tool: tc.function.name, args_summary: argsSummary });
+        const toolStart = Date.now();
         const output = await executeTool(provider, tc.function.name, args, repoRoot).catch((err) => String(err));
+        logger.debug("WarpGrep", "tool_result", { turn, tool: tc.function.name, result_len: output.length, latency_ms: Date.now() - toolStart });
         return { tool_call_id: tc.id, content: output };
       })
     );
@@ -1990,12 +2059,16 @@ var WarpGrepClient = class {
   async _resolveGitHubRepo(input) {
     const { owner, repo } = parseGitHubUrl(input.github);
     const baseUrl = this.config.codeSearchUrl || DEFAULT_CODE_SEARCH_URL;
+    logger.debug("WarpGrep", "github_resolve", { owner_repo: `${owner}/${repo}`, branch: input.branch });
+    const resolveStart = Date.now();
     const importRes = await fetch(`${baseUrl}/api/code-search/get-or-create?url=${encodeURIComponent(`${owner}/${repo}`)}`);
     if (!importRes.ok) {
       const text = await importRes.text().catch(() => importRes.statusText);
+      logger.error("WarpGrep", "github_resolve_failed", { owner_repo: `${owner}/${repo}`, status: importRes.status, error: text });
       throw new Error(`Failed to import repo ${owner}/${repo}: ${text}`);
     }
     const { repoId, defaultBranch } = await importRes.json();
+    logger.debug("WarpGrep", "github_repo_fetched", { repo_id: repoId, default_branch: defaultBranch, latency_ms: Date.now() - resolveStart });
     return {
       repo,
       remoteCommands: createCodeStorageHttpCommands({ baseUrl, repoId, branch: input.branch || defaultBranch })