@morphllm/morphsdk 0.2.162 → 0.2.163

package/dist/index.cjs

@@ -36,7 +36,7 @@ var init_package = __esm({
   "package.json"() {
     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",
@@ -48,6 +48,11 @@ var init_package = __esm({
           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",
@@ -283,6 +288,50 @@ var init_version = __esm({
   }
 });
 
+// logger.ts
+var import_fs, MorphLogger, logger;
+var init_logger = __esm({
+  "logger.ts"() {
+    "use strict";
+    import_fs = require("fs");
+    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");
+      }
+    };
+    logger = new MorphLogger();
+  }
+});
+
 // tools/fastapply/apply.ts
 var apply_exports = {};
 __export(apply_exports, {
@@ -335,11 +384,14 @@ async function callMorphAPI(originalCode, codeEdit, instructions, filepath, conf
   const message = `<instruction>${instructions}</instruction>
 <code>${originalCode}</code>
 <update>${codeEdit}</update>`;
-  if (debug) {
-    console.log(`[FastApply] Calling ${apiUrl}/v1/chat/completions`);
-    console.log(`[FastApply] File: ${filepath}, Instructions: ${instructions.slice(0, 60)}...`);
-    console.log(`[FastApply] Original: ${originalCode.length} chars, Edit: ${codeEdit.length} chars`);
-  }
+  logger.debug("FastApply", "http_request", {
+    url: `${apiUrl}/v1/chat/completions`,
+    model,
+    filepath,
+    instruction_len: instructions.length,
+    original_len: originalCode.length,
+    code_edit_len: codeEdit.length
+  });
   const startTime = Date.now();
   const client = new import_openai.default({
     apiKey,
@@ -348,30 +400,32 @@ async function callMorphAPI(originalCode, codeEdit, instructions, filepath, conf
     maxRetries: config.retryConfig?.maxRetries ?? 3,
     defaultHeaders: { "X-Morph-SDK-Version": SDK_VERSION }
   });
-  if (debug) {
-    console.log(`[FastApply] Using model: ${model}`);
-  }
-  const completion = await client.chat.completions.create({
-    model,
-    messages: [{ role: "user", content: message }]
-  });
-  const content = completion.choices[0]?.message?.content;
-  if (!content) {
-    throw new Error("Morph API returned empty response");
-  }
-  const elapsed = Date.now() - startTime;
-  if (debug) {
-    console.log(`[FastApply] Success in ${elapsed}ms, merged: ${content.length} chars`);
+  try {
+    const completion = await client.chat.completions.create({
+      model,
+      messages: [{ role: "user", content: message }]
+    });
+    const content = completion.choices[0]?.message?.content;
+    if (!content) {
+      throw new Error("Morph API returned empty response");
+    }
+    const elapsed = Date.now() - startTime;
+    logger.debug("FastApply", "http_response", { status: 200, completion_id: completion.id, content_len: content.length, latency_ms: elapsed });
+    return { content, completionId: completion.id };
+  } catch (error) {
+    const elapsed = Date.now() - startTime;
+    logger.error("FastApply", "http_error", {
+      status: error?.status || error?.response?.status,
+      error: error?.message,
+      latency_ms: elapsed
+    });
+    throw error;
   }
-  return { content, completionId: completion.id };
 }
 async function applyEdit(input, config = {}) {
-  const debug = config.debug || false;
   const filepath = input.filepath || "file";
   try {
-    if (debug) {
-      console.log(`[FastApply] Applying edit to code (${input.originalCode.length} chars)`);
-    }
+    logger.debug("FastApply", "apply_edit_start", { original_len: input.originalCode.length, code_edit_len: input.codeEdit.length });
     const instruction = input.instruction ?? input.instructions ?? "";
     const { content: mergedCode, completionId } = await callMorphAPI(
       input.originalCode,
@@ -391,7 +445,7 @@ async function applyEdit(input, config = {}) {
     };
   } catch (error) {
     const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
-    if (debug) console.error(`[FastApply] Error: ${errorMessage}`);
+    logger.error("FastApply", "apply_edit_error", { error: errorMessage });
     return {
       success: false,
       changes: { linesAdded: 0, linesRemoved: 0, linesModified: 0 },
@@ -406,6 +460,7 @@ var init_apply = __esm({
     import_diff = require("diff");
     import_openai = __toESM(require("openai"), 1);
     init_version();
+    init_logger();
     DEFAULT_API_URL = "https://api.morphllm.com";
     DEFAULT_TIMEOUT = 3e4;
   }
@@ -601,7 +656,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;
@@ -624,13 +679,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;
@@ -640,11 +695,11 @@ function isTextualFile(filePath, maxBytes = 2e6) {
     return false;
   }
 }
-var import_fs, import_path5;
+var import_fs2, import_path5;
 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_path5 = __toESM(require("path"), 1);
   }
 });
@@ -1027,8 +1082,12 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 init_version();
 
+// client.ts
+init_logger();
+
 // tools/fastapply/core.ts
 var import_path = require("path");
+init_logger();
 init_apply();
 var DEFAULT_CONFIG = {
   morphApiUrl: "https://api.morphllm.com",
@@ -1089,9 +1148,10 @@ var FastApplyClient = class {
 async function executeEditFile(input, config = {}) {
   const baseDir = config.baseDir || DEFAULT_CONFIG.baseDir;
   const fullPath = (0, import_path.resolve)((0, import_path.join)(baseDir, input.target_filepath));
-  const debug = config.debug || false;
+  logger.debug("FastApply", "execute_start", { target_filepath: input.target_filepath, baseDir, autoWrite: config.autoWrite !== false });
   const relativePath = (0, import_path.relative)(baseDir, fullPath);
   if (relativePath.startsWith("..") || fullPath === baseDir) {
+    logger.warn("FastApply", "security_check_failed", { target_filepath: input.target_filepath, relative: relativePath });
     return {
       success: false,
       filepath: input.target_filepath,
@@ -1099,27 +1159,33 @@ async function executeEditFile(input, config = {}) {
       error: `Invalid filepath: '${input.target_filepath}' is outside baseDir`
     };
   }
+  logger.debug("FastApply", "security_check", { resolved: fullPath, relative: relativePath });
   try {
-    if (debug) console.log(`[FastApply] Reading file: ${input.target_filepath}`);
     const { readFile, writeFile } = await import("fs/promises");
     const { callMorphAPI: callMorphAPI2, generateUdiff: generateUdiff2, countChanges: countChanges2 } = await Promise.resolve().then(() => (init_apply(), apply_exports));
     let originalCode = "";
+    let fileExists = true;
     try {
       originalCode = await readFile(fullPath, "utf-8");
+      logger.debug("FastApply", "file_read", { path: fullPath, exists: true, size_bytes: originalCode.length });
     } catch (error) {
       if (error.code !== "ENOENT") {
         throw error;
       }
-      if (debug) console.log(`[FastApply] File doesn't exist, will create new file`);
+      fileExists = false;
+      logger.debug("FastApply", "file_read", { path: fullPath, exists: false });
     }
     const instruction = input.instruction ?? input.instructions ?? "";
+    logger.debug("FastApply", "api_call", { instruction_len: instruction.length, code_edit_len: input.code_edit.length, original_len: originalCode.length });
     const { content: mergedCode, completionId } = await callMorphAPI2(originalCode, input.code_edit, instruction, input.target_filepath, config);
+    logger.debug("FastApply", "api_response", { completion_id: completionId, merged_len: mergedCode.length });
     const udiff = config.generateUdiff !== false ? generateUdiff2(originalCode, mergedCode, input.target_filepath) : void 0;
     if (config.autoWrite !== false) {
       await writeFile(fullPath, mergedCode, "utf-8");
-      if (debug) console.log(`[FastApply] Wrote ${mergedCode.length} chars to ${input.target_filepath}`);
+      logger.debug("FastApply", "file_write", { path: fullPath, size_bytes: mergedCode.length });
     }
     const changes = countChanges2(originalCode, mergedCode);
+    logger.debug("FastApply", "changes", { added: changes.linesAdded, removed: changes.linesRemoved, modified: changes.linesModified });
     return {
       success: true,
       filepath: input.target_filepath,
@@ -1129,7 +1195,7 @@ async function executeEditFile(input, config = {}) {
     };
   } catch (error) {
     const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
-    if (debug) console.error(`[FastApply] Error: ${errorMessage}`);
+    logger.error("FastApply", "execute_error", { error: errorMessage, target_filepath: input.target_filepath, stack: error instanceof Error ? error.stack : void 0 });
     return {
       success: false,
       filepath: input.target_filepath,
@@ -1216,6 +1282,7 @@ function sleep(ms) {
 }
 
 // tools/codebase_search/core.ts
+init_logger();
 var CodebaseSearchClient = class {
   config;
   constructor(config = {}) {
@@ -1253,11 +1320,7 @@ async function executeCodebaseSearch(input, config) {
   }
   const searchUrl = config.searchUrl || process.env.MORPH_SEARCH_URL || "https://repos.morphllm.com";
   const timeout = config.timeout || 3e4;
-  const debug = config.debug || false;
-  if (debug) {
-    console.log(`[CodebaseSearch] Query: "${input.query.slice(0, 60)}..." repo=${config.repoId}`);
-    console.log(`[CodebaseSearch] URL: ${searchUrl}/v1/codebase_search`);
-  }
+  logger.debug("CodebaseSearch", "request", { query: input.query.slice(0, 100), repo_id: config.repoId, url: `${searchUrl}/v1/codebase_search` });
   const startTime = Date.now();
   try {
     const fetchPromise = fetchWithRetry(
@@ -1281,7 +1344,7 @@ async function executeCodebaseSearch(input, config) {
     const response = await withTimeout(fetchPromise, timeout, `Codebase search timed out after ${timeout}ms`);
     if (!response.ok) {
       const errorText = await response.text();
-      if (debug) console.error(`[CodebaseSearch] Error: ${response.status} - ${errorText}`);
+      logger.error("CodebaseSearch", "response_error", { status: response.status, error: errorText, latency_ms: Date.now() - startTime });
       return {
         success: false,
         results: [],
@@ -1291,16 +1354,14 @@ async function executeCodebaseSearch(input, config) {
     }
     const data = await response.json();
     const elapsed = Date.now() - startTime;
-    if (debug) {
-      console.log(`[CodebaseSearch] \u2705 ${data.results?.length || 0} results in ${elapsed}ms`);
-    }
+    logger.debug("CodebaseSearch", "response", { results_count: data.results?.length || 0, latency_ms: elapsed });
     return {
       success: true,
       results: data.results || [],
       stats: data.stats || { totalResults: 0, candidatesRetrieved: 0, searchTimeMs: elapsed }
     };
   } catch (error) {
-    if (debug) console.error(`[CodebaseSearch] Exception: ${error instanceof Error ? error.message : error}`);
+    logger.error("CodebaseSearch", "exception", { error: error instanceof Error ? error.message : String(error), latency_ms: Date.now() - startTime });
     return {
       success: false,
       results: [],
@@ -1310,6 +1371,9 @@ async function executeCodebaseSearch(input, config) {
   }
 }
 
+// tools/browser/core.ts
+init_logger();
+
 // tools/browser/live.ts
 var LIVE_PRESETS = {
   /** Read-only monitoring (no interaction) */
@@ -2006,11 +2070,7 @@ var BrowserClient = class {
     if (!hasTask && !hasDiff) {
       throw new Error('Browser task requires either "task" (natural language) or "diff" (PR-review planning)');
     }
-    if (debug) {
-      const preview = (input.task ?? "").slice(0, 60);
-      console.log(`[Browser] createTask: "${preview}..." url=${input.url || "none"}`);
-      console.log(`[Browser] Calling async endpoint: ${apiUrl}/browser-task/async`);
-    }
+    logger.debug("Browser", "create_task", { task: (input.task ?? "").slice(0, 100), url: input.url, endpoint: `${apiUrl}/browser-task/async` });
     const headers = { "Content-Type": "application/json" };
     if (this.config.apiKey) headers["Authorization"] = `Bearer ${this.config.apiKey}`;
     const response = await fetch(`${apiUrl}/browser-task/async`, {
@@ -2040,14 +2100,11 @@ var BrowserClient = class {
     });
     if (!response.ok) {
       const errorText = await response.text().catch(() => response.statusText);
-      if (debug) console.error(`[Browser] Error: ${response.status} - ${errorText}`);
+      logger.error("Browser", "create_task_error", { status: response.status, error: errorText });
       throw new Error(`HTTP ${response.status}: ${errorText}`);
     }
     const result = mapTaskResult(await response.json());
-    if (debug) {
-      const debugUrl = result.debugUrl;
-      console.log(`[Browser] \u2705 Task created: recordingId=${result.recordingId ?? "none"} debugUrl=${debugUrl ? "available" : "none"}`);
-    }
+    logger.debug("Browser", "task_created", { recording_id: result.recordingId, task_id: result.taskId, debug_url: !!result.debugUrl });
     if ("schema" in input) {
       return wrapTaskResponseWithSchema(result, this.config, input.schema);
     } else {
@@ -2107,10 +2164,7 @@ async function executeBrowserTask(input, config = {}) {
       error: "maxSteps must be between 1 and 50. Use more steps for complex multi-page flows."
     };
   }
-  if (debug) {
-    console.log(`[Browser] Task: "${input.task.slice(0, 60)}..." url=${input.url || "none"} maxSteps=${input.maxSteps ?? 10}`);
-    console.log(`[Browser] Recording: ${input.recordVideo ? "yes" : "no"} | Calling ${apiUrl}/browser-task`);
-  }
+  logger.debug("Browser", "execute_start", { task: input.task.slice(0, 100), url: input.url, max_steps: input.maxSteps ?? 10, record_video: input.recordVideo ?? false });
   const startTime = Date.now();
   try {
     const headers = { "Content-Type": "application/json" };
@@ -2149,14 +2203,12 @@ async function executeBrowserTask(input, config = {}) {
     );
     if (!response.ok) {
       const errorText = await response.text().catch(() => response.statusText);
-      if (debug) console.error(`[Browser] Error: ${response.status} - ${errorText}`);
+      logger.error("Browser", "execute_error", { status: response.status, error: errorText });
       throw new Error(`HTTP ${response.status}: ${errorText}`);
     }
     const result = mapTaskResult(await response.json());
     const elapsed = Date.now() - startTime;
-    if (debug) {
-      console.log(`[Browser] \u2705 ${result.success ? "Success" : "Failed"} in ${elapsed}ms | steps=${result.stepsTaken ?? 0} recordingId=${result.recordingId ?? "none"}`);
-    }
+    logger.debug("Browser", "execute_complete", { success: result.success, latency_ms: elapsed, steps: result.stepsTaken ?? 0, recording_id: result.recordingId });
     return result;
   } catch (error) {
     if (error instanceof Error) {
@@ -2867,6 +2919,7 @@ function enforceContextLimit(messages, maxChars = AGENT_CONFIG.MAX_CONTEXT_CHARS
 var import_openai2 = __toESM(require("openai"), 1);
 init_version();
 var import_path4 = __toESM(require("path"), 1);
+init_logger();
 var DEFAULT_API_URL3 = "https://api.morphllm.com";
 var TOOL_SPECS = [
   {
@@ -2989,6 +3042,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 {
@@ -3001,10 +3056,16 @@ async function callModel(messages, model, options = {}) {
         ...options.search_type ? { search_type: options.search_type } : {}
       });
     } catch (error) {
-      if (error instanceof import_openai2.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_openai2.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;
     }
@@ -3023,6 +3084,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) {
@@ -3093,9 +3155,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 = [];
@@ -3103,7 +3167,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,
@@ -3114,6 +3184,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;
     });
@@ -3123,6 +3194,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,
@@ -3149,6 +3221,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);
@@ -3167,7 +3240,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 };
       })
     );
@@ -3236,6 +3313,9 @@ async function runWarpGrep(config) {
   return result.value;
 }
 
+// tools/warp_grep/client.ts
+init_logger();
+
 // tools/warp_grep/providers/remote.ts
 init_config();
 var SKIP_NAMES = /* @__PURE__ */ new Set([
@@ -3675,12 +3755,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 })
@@ -4221,7 +4305,7 @@ var GitHubClient = class {
 // git/client.ts
 var import_isomorphic_git = __toESM(require("isomorphic-git"), 1);
 var import_node = __toESM(require("isomorphic-git/http/node"), 1);
-var import_fs2 = __toESM(require("fs"), 1);
+var import_fs3 = __toESM(require("fs"), 1);
 var DEFAULT_PROXY_URL = "https://repos.morphllm.com";
 var MorphGit = class {
   apiKey;
@@ -4278,12 +4362,12 @@ var MorphGit = class {
       throw new Error(`Failed to create repository: ${error}`);
     }
     await import_isomorphic_git.default.init({
-      fs: import_fs2.default,
+      fs: import_fs3.default,
       dir,
       defaultBranch
     });
     await import_isomorphic_git.default.addRemote({
-      fs: import_fs2.default,
+      fs: import_fs3.default,
       dir,
       remote: "origin",
       url: `${this.proxyUrl}/v1/repos/${repoId}`
@@ -4304,7 +4388,7 @@ var MorphGit = class {
   async clone(options) {
     const { repoId, dir, branch = "main", depth, singleBranch = true } = options;
     await import_isomorphic_git.default.clone({
-      fs: import_fs2.default,
+      fs: import_fs3.default,
       http: import_node.default,
       dir,
       url: `${this.proxyUrl}/v1/repos/${repoId}`,
@@ -4333,9 +4417,9 @@ var MorphGit = class {
         'branch is required for push operations. Specify the branch explicitly: { dir: "./my-project", branch: "main" }'
       );
     }
-    const commitHash = await import_isomorphic_git.default.resolveRef({ fs: import_fs2.default, dir, ref: "HEAD" });
+    const commitHash = await import_isomorphic_git.default.resolveRef({ fs: import_fs3.default, dir, ref: "HEAD" });
     let repoId;
-    const remotes = await import_isomorphic_git.default.listRemotes({ fs: import_fs2.default, dir });
+    const remotes = await import_isomorphic_git.default.listRemotes({ fs: import_fs3.default, dir });
     const originRemote = remotes.find((r) => r.remote === remote);
     if (originRemote) {
       const match = originRemote.url.match(/\/repos\/([^\/]+)$/);
@@ -4344,7 +4428,7 @@ var MorphGit = class {
       }
     }
     await import_isomorphic_git.default.push({
-      fs: import_fs2.default,
+      fs: import_fs3.default,
       http: import_node.default,
       dir,
       remote,
@@ -4399,7 +4483,7 @@ var MorphGit = class {
       );
     }
     await import_isomorphic_git.default.pull({
-      fs: import_fs2.default,
+      fs: import_fs3.default,
       http: import_node.default,
       dir,
       remote,
@@ -4468,7 +4552,7 @@ var MorphGit = class {
   async add(options) {
     const { dir, filepath } = options;
     await import_isomorphic_git.default.add({
-      fs: import_fs2.default,
+      fs: import_fs3.default,
       dir,
       filepath
     });
@@ -4487,7 +4571,7 @@ var MorphGit = class {
   async remove(options) {
     const { dir, filepath } = options;
     await import_isomorphic_git.default.remove({
-      fs: import_fs2.default,
+      fs: import_fs3.default,
       dir,
       filepath
     });
@@ -4520,7 +4604,7 @@ var MorphGit = class {
       email: "sdk@morphllm.com"
     };
     const sha = await import_isomorphic_git.default.commit({
-      fs: import_fs2.default,
+      fs: import_fs3.default,
       dir,
       message,
       author: commitAuthor
@@ -4533,7 +4617,7 @@ var MorphGit = class {
         _version: 1
       };
       await import_isomorphic_git.default.addNote({
-        fs: import_fs2.default,
+        fs: import_fs3.default,
         dir,
         ref: "refs/notes/morph-metadata",
         oid: sha,
@@ -4561,7 +4645,7 @@ var MorphGit = class {
       throw new Error("filepath is required for status check");
     }
     const status = await import_isomorphic_git.default.status({
-      fs: import_fs2.default,
+      fs: import_fs3.default,
       dir,
       filepath
     });
@@ -4581,7 +4665,7 @@ var MorphGit = class {
   async log(options) {
     const { dir, depth, ref } = options;
     const commits = await import_isomorphic_git.default.log({
-      fs: import_fs2.default,
+      fs: import_fs3.default,
       dir,
       depth,
       ref
@@ -4602,7 +4686,7 @@ var MorphGit = class {
   async checkout(options) {
     const { dir, ref } = options;
     await import_isomorphic_git.default.checkout({
-      fs: import_fs2.default,
+      fs: import_fs3.default,
       dir,
       ref
     });
@@ -4622,7 +4706,7 @@ var MorphGit = class {
   async branch(options) {
     const { dir, name, checkout = false } = options;
     await import_isomorphic_git.default.branch({
-      fs: import_fs2.default,
+      fs: import_fs3.default,
       dir,
       ref: name,
       checkout
@@ -4641,7 +4725,7 @@ var MorphGit = class {
   async listBranches(options) {
     const { dir } = options;
     const branches = await import_isomorphic_git.default.listBranches({
-      fs: import_fs2.default,
+      fs: import_fs3.default,
       dir
     });
     return branches;
@@ -4659,7 +4743,7 @@ var MorphGit = class {
   async currentBranch(options) {
     const { dir } = options;
     const branch = await import_isomorphic_git.default.currentBranch({
-      fs: import_fs2.default,
+      fs: import_fs3.default,
       dir
     });
     return branch || void 0;
@@ -4677,7 +4761,7 @@ var MorphGit = class {
   async statusMatrix(options) {
     const { dir } = options;
     const matrix = await import_isomorphic_git.default.statusMatrix({
-      fs: import_fs2.default,
+      fs: import_fs3.default,
       dir
     });
     return matrix.map(([filepath, HEADStatus, workdirStatus, stageStatus]) => {
@@ -4719,7 +4803,7 @@ var MorphGit = class {
   async resolveRef(options) {
     const { dir, ref } = options;
     const oid = await import_isomorphic_git.default.resolveRef({
-      fs: import_fs2.default,
+      fs: import_fs3.default,
       dir,
       ref
     });
@@ -4745,7 +4829,7 @@ var MorphGit = class {
   async getCommitMetadata(options) {
     try {
       const note = await import_isomorphic_git.default.readNote({
-        fs: import_fs2.default,
+        fs: import_fs3.default,
         dir: options.dir,
         ref: "refs/notes/morph-metadata",
         oid: options.commitSha
@@ -4763,6 +4847,7 @@ var import_isomorphic_git2 = __toESM(require("isomorphic-git"), 1);
 var import_node2 = __toESM(require("isomorphic-git/http/node"), 1);
 
 // modelrouter/core.ts
+init_logger();
 var DEFAULT_CONFIG3 = {
   apiUrl: "https://api.morphllm.com",
   timeout: 5e3,
@@ -4798,12 +4883,7 @@ var BaseRouter = class {
       input: input.input,
       mode
     };
-    if (this.config.debug) {
-      console.log(`[ModelRouter] Requesting ${this.provider} model selection:`, {
-        mode,
-        inputLength: input.input.length
-      });
-    }
+    logger.debug("ModelRouter", "request", { provider: this.provider, mode, input_len: input.input.length, url });
     try {
       const fetchPromise = fetchWithRetry(
         url,
@@ -4832,14 +4912,10 @@ var BaseRouter = class {
       const result = {
         model: apiResult.model
       };
-      if (this.config.debug) {
-        console.log(`[ModelRouter] Selected model: ${apiResult.model}, Confidence: ${apiResult.confidence?.toFixed(3)}`);
-      }
+      logger.debug("ModelRouter", "selected", { provider: this.provider, model: apiResult.model, confidence: apiResult.confidence });
       return result;
     } catch (error) {
-      if (this.config.debug) {
-        console.error(`[ModelRouter] Error selecting model:`, error);
-      }
+      logger.error("ModelRouter", "error", { provider: this.provider, error: error instanceof Error ? error.message : String(error) });
       throw error;
     }
   }
@@ -4909,12 +4985,7 @@ var RawRouter = class extends BaseRouter {
       input: input.input,
       mode
     };
-    if (this.config.debug) {
-      console.log(`[RawRouter] Requesting raw difficulty classification:`, {
-        mode,
-        inputLength: input.input.length
-      });
-    }
+    logger.debug("RawRouter", "request", { mode, input_len: input.input.length, url });
     try {
       const fetchPromise = fetchWithRetry(
         url,
@@ -4949,14 +5020,10 @@ var RawRouter = class extends BaseRouter {
       const result = {
         difficulty
       };
-      if (this.config.debug) {
-        console.log(`[RawRouter] Classified as: ${difficulty}`);
-      }
+      logger.debug("RawRouter", "classified", { difficulty });
       return result;
     } catch (error) {
-      if (this.config.debug) {
-        console.error(`[RawRouter] Error classifying:`, error);
-      }
+      logger.error("RawRouter", "error", { error: error instanceof Error ? error.message : String(error) });
       throw error;
     }
   }
@@ -6382,6 +6449,10 @@ var MorphClient = class {
    */
   constructor(config = {}) {
     this.config = config;
+    if (config.debug) {
+      logger.enable();
+    }
+    logger.debug("MorphClient", "initialized", { debug: !!config.debug, timeout: config.timeout });
     this.fastApply = new FastApplyClient({
       apiKey: config.apiKey,
       debug: config.debug,