@menteeai/menteeswe 0.1.0

package/dist/cli.js

@@ -0,0 +1,3224 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/config.ts
+import fs from "fs";
+import path from "path";
+import os from "os";
+function blankConfig() {
+  return { defaultProvider: "kimi", keys: {}, models: {} };
+}
+function configDir() {
+  return path.join(os.homedir(), ".mentee");
+}
+function configFilePath() {
+  return path.join(configDir(), "config.json");
+}
+function loadConfig() {
+  try {
+    const raw = fs.readFileSync(configFilePath(), "utf8");
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object") return null;
+    if (!parsed.keys || typeof parsed.keys !== "object") return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+function saveConfig(config) {
+  fs.mkdirSync(configDir(), { recursive: true });
+  fs.writeFileSync(configFilePath(), JSON.stringify(config, null, 2), "utf8");
+}
+function resolveApiKey(provider, config) {
+  const keySlot = provider === "zai-coding" ? "zai" : provider;
+  return process.env[ENV_NAMES[provider]] || config?.keys?.[keySlot] || void 0;
+}
+function resolveModel(provider, config) {
+  return config?.models?.[provider] || void 0;
+}
+var ENV_NAMES;
+var init_config = __esm({
+  "src/config.ts"() {
+    "use strict";
+    ENV_NAMES = {
+      kimi: "MENTEE_KIMI_API_KEY",
+      glm: "MENTEE_GLM_API_KEY",
+      zai: "MENTEE_ZAI_API_KEY",
+      "zai-coding": "MENTEE_ZAI_API_KEY"
+    };
+  }
+});
+
+// src/tools/base.ts
+function firstString(args, key) {
+  const value = args[key];
+  return typeof value === "string" ? value : void 0;
+}
+function firstNumber(args, key) {
+  const value = args[key];
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function firstBoolean(args, key) {
+  const value = args[key];
+  return typeof value === "boolean" ? value : void 0;
+}
+function requireString(args, key) {
+  const value = firstString(args, key);
+  if (value === void 0 || value.trim() === "") {
+    throw new Error(`Missing required string argument: ${key}`);
+  }
+  return value;
+}
+function truncateOutput(text, maxChars) {
+  if (text.length <= maxChars) {
+    return { text, truncated: false };
+  }
+  const head = Math.floor(maxChars * 0.7);
+  const tail = maxChars - head;
+  return {
+    text: text.slice(0, head) + `
+...[output truncated: showing first ${head} and last ${tail} of ${text.length} chars]...
+` + text.slice(text.length - tail),
+    truncated: true
+  };
+}
+var init_base = __esm({
+  "src/tools/base.ts"() {
+    "use strict";
+  }
+});
+
+// src/events.ts
+var EventBus;
+var init_events = __esm({
+  "src/events.ts"() {
+    "use strict";
+    EventBus = class {
+      handlers = /* @__PURE__ */ new Set();
+      subscribe(handler) {
+        this.handlers.add(handler);
+        return () => {
+          this.handlers.delete(handler);
+        };
+      }
+      emit(type, message, data) {
+        const event = { type, ts: Date.now(), message, data };
+        for (const handler of this.handlers) {
+          try {
+            handler(event);
+          } catch {
+          }
+        }
+      }
+    };
+  }
+});
+
+// src/logging.ts
+import fs7 from "fs";
+import path7 from "path";
+function createSessionLogger() {
+  const dir = path7.join(configDir(), "logs");
+  const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+  const file = path7.join(dir, `${stamp}.jsonl`);
+  fs7.mkdirSync(dir, { recursive: true });
+  return (event) => {
+    try {
+      fs7.appendFileSync(file, JSON.stringify(event) + "\n", "utf8");
+    } catch {
+    }
+  };
+}
+var init_logging = __esm({
+  "src/logging.ts"() {
+    "use strict";
+    init_config();
+  }
+});
+
+// src/render.ts
+import chalk from "chalk";
+function toolColorName(name) {
+  return CATEGORY_NAME[TOOL_CATEGORY[name] ?? "other"];
+}
+function friendlyToolName(name) {
+  return TOOL_LABELS[name] ?? name;
+}
+function formatEvent(event) {
+  switch (event.type) {
+    case "task_started":
+      return chalk.bold.magenta(`\u25B8 Task: ${event.message ?? ""}`);
+    case "model_request":
+      return chalk.gray("\u25CF thinking...");
+    case "info":
+      return chalk.cyan(`  ${event.message ?? ""}`);
+    case "tool_started": {
+      const tool = typeof event.data?.tool === "string" ? event.data.tool : "";
+      const color = CATEGORY_COLOR[TOOL_CATEGORY[tool] ?? "other"];
+      const friendly = friendlyToolName(tool);
+      const preview = tool && event.message?.startsWith(tool) ? event.message.slice(tool.length).trim() : event.message ?? "";
+      return color(`\u2699 ${friendly} (${preview})...`);
+    }
+    case "tool_completed": {
+      const tool = typeof event.data?.tool === "string" ? event.data.tool : "";
+      const success = event.data?.success === true;
+      const output = typeof event.data?.output === "string" ? event.data.output.trim() : "";
+      const firstLine = (output.split("\n")[0] ?? event.message ?? "").slice(0, 160);
+      const color = success ? CATEGORY_COLOR[TOOL_CATEGORY[tool] ?? "other"] : chalk.red;
+      return color(`  ${success ? "\u2713" : "\u2717"} ${firstLine}`);
+    }
+    case "approval":
+      return chalk.magenta(`\u{1F510} Asking permission to use ${event.message ?? "tool"}...`);
+    case "warning":
+      return chalk.yellow(`\u26A0 ${event.message ?? ""}`);
+    case "error":
+      return chalk.red(`\u2716 ${event.message ?? ""}`);
+    case "task_completed": {
+      const success = event.data?.success === true;
+      const usage = event.data?.usage;
+      const duration = event.data?.durationMs;
+      const toolCalls = typeof event.data?.toolCalls === "number" ? event.data.toolCalls : 0;
+      const iterations = typeof event.data?.iterations === "number" ? event.data.iterations : 0;
+      const modifiedFiles = Array.isArray(event.data?.modifiedFiles) ? event.data.modifiedFiles : [];
+      const finalText = typeof event.data?.finalText === "string" ? event.data.finalText.trim() : "";
+      const fmt = (n) => n.toLocaleString("en-US");
+      const stats = [];
+      if (duration !== void 0) stats.push(`time ${(duration / 1e3).toFixed(1)}s`);
+      if (usage) {
+        const total = usage.inputTokens + usage.outputTokens;
+        stats.push(`tokens ${fmt(total)} (\u2191${fmt(usage.inputTokens)} \u2193${fmt(usage.outputTokens)})`);
+      }
+      stats.push(`tool calls ${toolCalls}`);
+      stats.push(`iterations ${iterations}`);
+      if (modifiedFiles.length > 0) stats.push(`files ${modifiedFiles.length}`);
+      const sep = chalk.dim("\u2500".repeat(48));
+      const statsLine = chalk.cyan(` ${stats.join(" \xB7 ")}`);
+      const statusLine = success ? chalk.green.bold("\u2714 Task completed") : chalk.red.bold("\u2716 Task failed");
+      const block = [statusLine, sep, statsLine, sep];
+      return block.join("\n");
+    }
+    default:
+      return null;
+  }
+}
+var TOOL_CATEGORY, CATEGORY_COLOR, CATEGORY_NAME, TOOL_LABELS;
+var init_render = __esm({
+  "src/render.ts"() {
+    "use strict";
+    TOOL_CATEGORY = {
+      read_file: "filesystem",
+      write_file: "filesystem",
+      apply_patch: "filesystem",
+      delete_file: "filesystem",
+      move_path: "filesystem",
+      search_code: "search",
+      search_files: "search",
+      list_files: "search",
+      git_status: "git",
+      git_diff: "git",
+      git_log: "git",
+      git_show: "git",
+      git_branches: "git",
+      execute_command: "exec",
+      run_tests: "testing",
+      run_linter: "testing",
+      run_typecheck: "testing",
+      inspect_env: "env",
+      memory: "env",
+      web_search: "web",
+      http_fetch: "exec",
+      file_info: "filesystem",
+      safe_delete_suggestion: "env",
+      process_list: "exec",
+      port_check: "exec",
+      system_info: "env"
+    };
+    CATEGORY_COLOR = {
+      filesystem: chalk.blue,
+      search: chalk.cyan,
+      git: chalk.magenta,
+      exec: chalk.yellow,
+      testing: chalk.green,
+      env: chalk.gray,
+      memory: chalk.magenta,
+      web: chalk.cyan,
+      other: chalk.white
+    };
+    CATEGORY_NAME = {
+      filesystem: "blue",
+      search: "cyan",
+      git: "magenta",
+      exec: "yellow",
+      testing: "green",
+      env: "gray",
+      memory: "magenta",
+      web: "cyan",
+      other: "white"
+    };
+    TOOL_LABELS = {
+      read_file: "read",
+      write_file: "write",
+      apply_patch: "edit",
+      delete_file: "delete",
+      move_path: "move",
+      execute_command: "terminal",
+      run_tests: "tests",
+      run_linter: "linter",
+      run_typecheck: "typecheck",
+      inspect_env: "env",
+      search_code: "search",
+      search_files: "file search",
+      list_files: "list",
+      git_status: "git status",
+      git_diff: "git diff",
+      git_log: "git log",
+      git_show: "git show",
+      git_branches: "git branches"
+    };
+  }
+});
+
+// src/approval.ts
+function createAutoApproval(yes) {
+  return async (request) => {
+    if (request.risk === "restricted" && !yes) {
+      return "deny";
+    }
+    return "allow";
+  };
+}
+var ApprovalBridge;
+var init_approval = __esm({
+  "src/approval.ts"() {
+    "use strict";
+    ApprovalBridge = class {
+      pending = null;
+      onPending = null;
+      setListener(listener) {
+        this.onPending = listener;
+      }
+      get current() {
+        return this.pending?.request ?? null;
+      }
+      resolve(decision) {
+        if (!this.pending) return;
+        const { resolve } = this.pending;
+        this.pending = null;
+        this.onPending?.(null);
+        resolve(decision);
+      }
+      handler = (request) => {
+        return new Promise((resolve) => {
+          this.pending = { request, resolve };
+          this.onPending?.(request);
+        });
+      };
+    };
+  }
+});
+
+// src/agent/prompts.ts
+import fs8 from "fs";
+import { spawnSync as spawnSync3 } from "child_process";
+import os2 from "os";
+function gitBranch(cwd) {
+  const result = spawnSync3("git rev-parse --abbrev-ref HEAD", {
+    cwd,
+    encoding: "utf8",
+    shell: true,
+    windowsHide: true
+  });
+  if (result.status !== 0) return null;
+  return (result.stdout ?? "").trim() || null;
+}
+function projectTree(cwd, prefix = "", depth = 0, maxDepth = 3) {
+  if (depth > maxDepth) return "";
+  let out = "";
+  let entries;
+  try {
+    entries = fs8.readdirSync(cwd, { withFileTypes: true });
+  } catch {
+    return "";
+  }
+  entries = entries.filter((e) => !SKIP_DIRS.has(e.name) && !e.name.startsWith(".")).sort((a, b) => {
+    if (a.isDirectory() !== b.isDirectory()) return a.isDirectory() ? -1 : 1;
+    return a.name.localeCompare(b.name);
+  }).slice(0, 40);
+  for (const e of entries) {
+    out += `${prefix}${e.isDirectory() ? `${e.name}/` : e.name}
+`;
+    if (e.isDirectory() && depth < maxDepth) {
+      out += projectTree(`${cwd}/${e.name}`, `${prefix}  `, depth + 1, maxDepth);
+    }
+  }
+  return out;
+}
+function buildSystemPrompt(cwd) {
+  const branch = gitBranch(cwd);
+  const tree = projectTree(cwd).trim() || "(empty)";
+  return `You are MenteE, an autonomous software-engineering agent working inside a repository on the user's machine.
+
+# Environment
+- Workspace: ${cwd}
+- Platform: ${os2.platform()} (${os2.release()}), shell commands run with the system shell
+${branch ? `- Git branch: ${branch}` : "- Not a git repository"}
+
+# Project file tree (you already have this \u2014 do NOT re-read files just to learn structure)
+${tree}
+
+# How to work
+1. UNDERSTAND before acting: list files, search code, and read the relevant files (with line ranges for large files) before proposing changes. Never modify a file you have not read.
+2. MINIMAL CHANGES: make the smallest change that correctly fulfils the task. Never refactor unrelated code, never reformat, never rename things that were not asked about.
+3. REALITY CHECK: do not invent APIs, packages, or file paths. If you are unsure a dependency or module exists, verify with search or by reading package.json / requirements files.
+4. VERIFY: after modifying code, run the project's own tests, build, or typecheck commands to prove the change works. If no obvious test command exists, at minimum execute the modified code or a syntax check.
+5. DEBUG PROPERLY: if a command fails, read the error carefully, investigate the root cause, and fix that. If the same error occurs three times, stop repeating it, state what you have tried, and change strategy.
+6. STAY IN SCOPE: never read, modify, or execute anything outside the workspace. Never print or exfiltrate secrets, API keys, or credentials.
+7. FINISH PROPERLY: when the task is done and verified, stop calling tools and write a final answer (see Communication rules).
+
+# Tool usage notes
+- Call only the tools needed for the immediate next step. Do NOT read files you already understand, and do NOT read build/config files (e.g. *.config.ts, tsconfig.json) unless the task specifically needs them.
+- Prefer search_code over reading many files.
+
+# Research strategy (IMPORTANT \u2014 HARD RULE)
+- The file tree above already shows the whole structure. Do NOT read files just to "see what's there".
+- When asked to "understand", "study", or "explore", read at most 5 files: typically README, package.json / pyproject, and 1-3 source files directly relevant to the question. Use search_code to locate symbols instead of opening files blindly.
+- The harness enforces a read budget. Once it warns you, STOP reading and answer or act.
+- For debugging or feature tasks, read only the files directly involved, then verify with tests. Never read the entire codebase.
+
+# Editing notes
+- Use read_file with start_line/end_line for files that may be large.
+- Use apply_patch (exact unique snippet replacement) for edits; use write_file only for new files or complete rewrites you have fully read.
+- Run tests with execute_command (e.g. "npm test", "pytest"). Safe read-only commands run automatically; installing packages or git history changes will ask the user for approval.
+
+# Persistent memory
+- Use the 'memory' tool to store important, reusable context so you don't re-derive it: project conventions, key file locations, design decisions, gotchas, API quirks. Example: after discovering "tests run with vitest and need a built dist", store it with topic "testing".
+- At the start of a task, call 'memory' with action=search (or list) to recall prior findings for THIS project. Prefer recalled memory over re-reading files.
+- This memory persists across sessions and is project-scoped; it never lives in the workspace.
+
+# Communication (IMPORTANT)
+- While working, say only what you are doing and why, in ONE short sentence per step. No filler.
+- Your FINAL answer must be minimal and useful: 1-3 sentences unless the task explicitly asks for detail. State the outcome and, if you changed anything, the one command used to verify. Do NOT write document-style reports, headers, bullet inventories of the codebase, or repeat tool output. If the user wants more, they will ask.
+- NEVER use bullet lists, numbered lists, headings, or markdown headers in your final answer unless the user explicitly asks for one. Plain prose only \u2014 1 to 3 sentences.
+- Never dump the whole repo structure or a file-by-file summary unless requested.
+- If the user refers to something you said or did earlier ("that", "it", "before"), use the prior conversation context provided above.
+
+Be concise in your visible text between tool calls: one short sentence about what you are doing and why is enough.`;
+}
+var SKIP_DIRS;
+var init_prompts = __esm({
+  "src/agent/prompts.ts"() {
+    "use strict";
+    SKIP_DIRS = /* @__PURE__ */ new Set([
+      "node_modules",
+      ".git",
+      "dist",
+      "build",
+      ".next",
+      "out",
+      ".venv",
+      "venv",
+      ".mentee",
+      "coverage",
+      ".turbo",
+      "tmp"
+    ]);
+  }
+});
+
+// src/agent/conversation.ts
+import fs9 from "fs";
+import path8 from "path";
+import crypto2 from "crypto";
+import os3 from "os";
+function sessionsDir() {
+  const dir = path8.join(os3.homedir(), ".mentee", "sessions");
+  fs9.mkdirSync(dir, { recursive: true });
+  return dir;
+}
+function sessionFile(cwd) {
+  const hash = crypto2.createHash("sha1").update(cwd).digest("hex").slice(0, 16);
+  return path8.join(sessionsDir(), `${hash}.json`);
+}
+function loadConversation(cwd, limit = 12) {
+  try {
+    const raw = fs9.readFileSync(sessionFile(cwd), "utf8");
+    const turns = JSON.parse(raw);
+    if (!Array.isArray(turns)) return [];
+    return turns.slice(-limit);
+  } catch {
+    return [];
+  }
+}
+function appendTurn(cwd, task, response) {
+  const file = sessionFile(cwd);
+  let turns = [];
+  try {
+    turns = JSON.parse(fs9.readFileSync(file, "utf8"));
+    if (!Array.isArray(turns)) turns = [];
+  } catch {
+    turns = [];
+  }
+  turns.push({ task, response, ts: Date.now() });
+  if (turns.length > 50) turns = turns.slice(-50);
+  fs9.writeFileSync(file, JSON.stringify(turns, null, 2));
+}
+function formatConversationContext(cwd, limit = 12) {
+  const turns = loadConversation(cwd, limit);
+  if (turns.length === 0) return "";
+  const lines = ["# Prior conversation in this project (oldest first)"];
+  for (const t of turns) {
+    lines.push(`User: ${t.task}`);
+    lines.push(`Assistant: ${t.response.trim()}`);
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+var init_conversation = __esm({
+  "src/agent/conversation.ts"() {
+    "use strict";
+  }
+});
+
+// src/agent/state.ts
+function createAgentState(task, maxIterations) {
+  return {
+    task,
+    phase: "INITIALIZATION",
+    iteration: 0,
+    maxIterations,
+    modifiedFiles: [],
+    commandsRun: [],
+    errors: [],
+    lastErrorSignature: null,
+    sameErrorCount: 0,
+    totalToolCalls: 0,
+    readCount: 0,
+    usage: { inputTokens: 0, outputTokens: 0, modelRequests: 0 },
+    startedAt: Date.now()
+  };
+}
+function errorSignature(stdout, stderr, exitCode) {
+  const relevant = (stderr || stdout || "").split("\n").map((line) => line.trim()).filter((line) => line.length > 0).slice(-8).join(" | ");
+  return `${exitCode}::${relevant.slice(0, 300)}`;
+}
+var init_state = __esm({
+  "src/agent/state.ts"() {
+    "use strict";
+  }
+});
+
+// src/agent/loop.ts
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function parseSuggestedDelayMs(message) {
+  const match = message.match(/after\s+(\d+)\s*seconds?/i);
+  if (match) {
+    const seconds = Number.parseInt(match[1] ?? "0", 10);
+    if (Number.isFinite(seconds) && seconds > 0 && seconds <= 120) {
+      return seconds * 1e3 + 500;
+    }
+  }
+  return null;
+}
+function isRateLimitError(error) {
+  const message = error.message.toLowerCase();
+  if (/insufficient balance|no resource package|recharge|quota exceeded|quota has been|arrears|billing/.test(
+    message
+  )) {
+    return false;
+  }
+  return /\b429\b|max rpm|rate limit|too many requests/i.test(error.message);
+}
+async function generateWithRetry(provider, model, system, messages, tools, bus) {
+  let lastError = null;
+  for (let attempt = 0; attempt <= RATE_LIMIT_MAX_ATTEMPTS; attempt++) {
+    try {
+      return await provider.generate({ system, messages, tools: tools.schemas() }, model);
+    } catch (error) {
+      lastError = error;
+      if (attempt >= RATE_LIMIT_MAX_ATTEMPTS || !isRateLimitError(lastError)) {
+        throw lastError;
+      }
+      const base = parseSuggestedDelayMs(lastError.message) ?? 2e3;
+      const delay = Math.min(base * Math.pow(2, attempt), 12e4) + Math.floor(Math.random() * 1e3);
+      bus.emit(
+        "warning",
+        `Rate limited by the provider \u2014 waiting ${(delay / 1e3).toFixed(0)}s and retrying (attempt ${attempt + 1}/${RATE_LIMIT_MAX_ATTEMPTS})`
+      );
+      await sleep(delay);
+    }
+  }
+  throw lastError ?? new Error("Model request failed after retries");
+}
+function toolCallPreview(call) {
+  let args = {};
+  try {
+    args = JSON.parse(call.function.arguments || "{}");
+  } catch {
+    args = {};
+  }
+  const preview = firstString(args, "path") ?? firstString(args, "command") ?? firstString(args, "pattern") ?? (Object.keys(args).length > 0 ? JSON.stringify(args).slice(0, 120) : "");
+  return preview ? `${call.function.name} ${preview}` : call.function.name;
+}
+function estimateContextChars(messages, system) {
+  let total = system.length;
+  for (const message of messages) {
+    total += (message.content?.length ?? 0) + JSON.stringify(message.tool_calls ?? []).length;
+  }
+  return total;
+}
+function trimOldToolResults(messages) {
+  for (const message of messages) {
+    if (message.role === "tool" && (message.content?.length ?? 0) > 2e3) {
+      message.content = message.content.slice(0, 500) + "\n...[older tool output trimmed to save context]";
+    }
+  }
+}
+async function runAgent(options) {
+  const {
+    task,
+    cwd,
+    provider,
+    model,
+    tools,
+    bus,
+    approval,
+    maxIterations = 40,
+    systemExtra
+  } = options;
+  const state = createAgentState(task, maxIterations);
+  const prior = formatConversationContext(cwd);
+  const system = buildSystemPrompt(cwd) + (prior ? `
+
+${prior}
+
+Use the prior conversation above as context. When the user refers to "that", "it", or "previous", they mean the most recent exchange shown above.
+` : "") + (systemExtra ? `
+
+# Additional instructions
+${systemExtra}` : "");
+  const toolCtx = {
+    cwd,
+    approval,
+    emit: (type, message, data) => {
+      bus.emit(type, message, data);
+    }
+  };
+  const messages = [{ role: "user", content: task }];
+  bus.emit("task_started", task, { provider: provider.name, model: model ?? provider.defaultModel });
+  let finalText = "";
+  let sawFinish = false;
+  while (state.iteration < maxIterations) {
+    state.iteration += 1;
+    state.usage.modelRequests += 1;
+    bus.emit("model_request", `iteration ${state.iteration}/${maxIterations}`);
+    let response;
+    try {
+      response = await generateWithRetry(provider, model, system, messages, tools, bus);
+    } catch (error) {
+      const message = error.message;
+      let hint = "";
+      if (/insufficient balance|no resource package|recharge/i.test(message)) {
+        hint = " \u2014 this key has no quota on this endpoint. If it is a Z.ai GLM Coding Plan key, switch with /provider zai-coding; otherwise add balance on the provider platform";
+      } else if (/40[134]|permission|unauthorized|api key/i.test(message)) {
+        hint = " \u2014 check the model id (Alt+M) and your API key permissions, then /model <id> to switch";
+      }
+      bus.emit("error", message + hint);
+      finalText = `Model request failed: ${message}`;
+      appendTurn(cwd, task, finalText);
+      bus.emit("task_completed", finalText.slice(0, 400), {
+        success: false,
+        finalText,
+        iterations: state.iteration,
+        toolCalls: state.totalToolCalls,
+        modifiedFiles: state.modifiedFiles,
+        usage: state.usage,
+        durationMs: Date.now() - state.startedAt
+      });
+      return { success: false, finalText, state };
+    }
+    bus.emit(
+      "model_response",
+      void 0,
+      {
+        finishReason: response.finishReason,
+        toolCalls: response.toolCalls.map((c) => c.function.name),
+        usage: response.usage
+      }
+    );
+    if (response.usage) {
+      state.usage.inputTokens += response.usage.inputTokens;
+      state.usage.outputTokens += response.usage.outputTokens;
+    }
+    if (response.finishReason === "length") {
+      bus.emit("warning", "Model hit its output length limit.");
+      finalText = response.content ?? "Task ended early: output length limit reached.";
+      break;
+    }
+    if (response.toolCalls.length === 0) {
+      finalText = response.content ?? "";
+      sawFinish = true;
+      break;
+    }
+    messages.push({
+      role: "assistant",
+      content: response.content,
+      tool_calls: response.toolCalls
+    });
+    if (response.content && response.content.trim()) {
+      bus.emit("info", response.content.trim().slice(0, 300));
+    }
+    for (const call of response.toolCalls) {
+      const tool = tools.get(call.function.name);
+      if (!tool) {
+        messages.push({
+          role: "tool",
+          tool_call_id: call.id,
+          content: `Unknown tool: ${call.function.name}. Available tools: ${tools.schemas().map((t) => t.name).join(", ")}`
+        });
+        continue;
+      }
+      let args = {};
+      try {
+        args = JSON.parse(call.function.arguments || "{}");
+      } catch {
+        messages.push({
+          role: "tool",
+          tool_call_id: call.id,
+          content: "Invalid JSON arguments for tool call. Retry with valid JSON."
+        });
+        continue;
+      }
+      bus.emit("tool_started", toolCallPreview(call), { tool: tool.name, args });
+      const risk = tool.dynamicRisk ? tool.dynamicRisk(args) : tool.risk;
+      let approved = true;
+      let denialMessage = "";
+      if (risk === "dangerous") {
+        approved = false;
+        denialMessage = "Blocked: this command is classified as dangerous and cannot be executed.";
+      } else if (risk === "restricted") {
+        const decision = await approval({ tool: tool.name, args, risk });
+        if (decision === "deny") {
+          approved = false;
+          denialMessage = "The user denied permission for this action. Choose a different approach.";
+        }
+      }
+      let result;
+      if (!approved) {
+        result = { success: false, output: denialMessage };
+      } else {
+        try {
+          result = await tool.execute(args, toolCtx);
+        } catch (error) {
+          result = { success: false, output: `Tool error: ${error.message}` };
+        }
+      }
+      state.totalToolCalls += 1;
+      if (tool.name === "read_file" && result.success) {
+        state.readCount += 1;
+        if (state.readCount === READ_BUDGET || state.readCount === READ_BUDGET * 2) {
+          bus.emit(
+            "warning",
+            `Read budget reached (${state.readCount} files). Stop exploring \u2014 either answer now or start acting on what you have.`
+          );
+          messages.push({
+            role: "user",
+            content: "SYSTEM NOTE: You have read " + state.readCount + " files. That is more than enough exploration. Do NOT call read_file again unless a later step absolutely requires it. Either answer the question now or begin making changes."
+          });
+        }
+      }
+      if (tool.name === "apply_patch" || tool.name === "write_file") {
+        const pathArg = firstString(args, "path");
+        if (pathArg && result.success && !state.modifiedFiles.includes(pathArg)) {
+          state.modifiedFiles.push(pathArg);
+        }
+      }
+      if (tool.name === "execute_command") {
+        state.commandsRun.push(firstString(args, "command") ?? "");
+        if (!result.success && (result.output.includes("exit_code: timeout") || result.output.includes("exit_code: 1"))) {
+          state.errors.push(result.output.slice(0, 500));
+          const sig = errorSignature(result.output, "", 1);
+          if (sig === state.lastErrorSignature) {
+            state.sameErrorCount += 1;
+          } else {
+            state.lastErrorSignature = sig;
+            state.sameErrorCount = 1;
+          }
+          if (state.sameErrorCount >= 3) {
+            bus.emit("warning", "Same failure occurred 3 times. Instructing agent to change strategy.");
+            messages.push({
+              role: "user",
+              content: "SYSTEM NOTE: You have produced the same failure three times. Stop repeating the same fix. Re-read the error, question your assumptions, investigate the root cause, and try a fundamentally different approach."
+            });
+            state.sameErrorCount = 0;
+          }
+        }
+      }
+      bus.emit("tool_completed", toolCallPreview(call), {
+        tool: tool.name,
+        success: result.success,
+        output: result.output.slice(0, 2e3)
+      });
+      messages.push({
+        role: "tool",
+        tool_call_id: call.id,
+        content: result.output
+      });
+    }
+    if (estimateContextChars(messages, system) > MAX_CONTEXT_CHARS) {
+      bus.emit("warning", "Context is large; trimming oldest tool outputs.");
+      trimOldToolResults(messages);
+    }
+  }
+  if (!sawFinish && !finalText) {
+    finalText = `Stopped after ${maxIterations} iterations without a final answer. Files modified: ${state.modifiedFiles.join(", ") || "none"}.`;
+    bus.emit("warning", finalText);
+  }
+  const success = sawFinish && state.errors.length === 0;
+  if (finalText) appendTurn(cwd, task, finalText);
+  bus.emit("task_completed", finalText.slice(0, 400), {
+    success,
+    finalText,
+    iterations: state.iteration,
+    toolCalls: state.totalToolCalls,
+    modifiedFiles: state.modifiedFiles,
+    usage: state.usage,
+    durationMs: Date.now() - state.startedAt
+  });
+  return { success, finalText, state };
+}
+var MAX_CONTEXT_CHARS, READ_BUDGET, RATE_LIMIT_MAX_ATTEMPTS;
+var init_loop = __esm({
+  "src/agent/loop.ts"() {
+    "use strict";
+    init_prompts();
+    init_conversation();
+    init_state();
+    init_base();
+    MAX_CONTEXT_CHARS = 48e4;
+    READ_BUDGET = 6;
+    RATE_LIMIT_MAX_ATTEMPTS = 8;
+  }
+});
+
+// src/tui/Approval.tsx
+import { Box, Text, useInput } from "ink";
+import { jsx, jsxs } from "react/jsx-runtime";
+function argPreview(request) {
+  const args = request.args;
+  if (request.tool === "apply_patch" && typeof args.old_string === "string" && typeof args.new_string === "string") {
+    const removed = args.old_string.split("\n").slice(0, 12).map((line) => `- ${line}`).join("\n");
+    const added = args.new_string.split("\n").slice(0, 12).map((line) => `+ ${line}`).join("\n");
+    return `${args.path ?? ""}
+${removed}
+${added}`;
+  }
+  return JSON.stringify(args, null, 2).slice(0, 1200);
+}
+function ApprovalPrompt({ request, onDecision }) {
+  useInput((input, key) => {
+    if (input === "y") onDecision("allow");
+    else if (input === "a") onDecision("always");
+    else if (input === "n" || key.escape) onDecision("deny");
+  });
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "magenta", paddingX: 1, marginY: 1, children: [
+    /* @__PURE__ */ jsxs(Text, { bold: true, color: "magenta", children: [
+      "Permission needed: ",
+      friendlyToolName(request.tool),
+      " (",
+      request.tool,
+      ") \u2014 ",
+      request.risk
+    ] }),
+    /* @__PURE__ */ jsx(Box, { marginTop: 1, children: /* @__PURE__ */ jsx(Text, { children: argPreview(request) }) }),
+    /* @__PURE__ */ jsx(Box, { marginTop: 1, children: /* @__PURE__ */ jsxs(Text, { children: [
+      /* @__PURE__ */ jsx(Text, { color: "green", bold: true, children: "[y]" }),
+      " allow once \xB7 ",
+      /* @__PURE__ */ jsx(Text, { color: "cyan", bold: true, children: "[a]" }),
+      " allow this session \xB7",
+      " ",
+      /* @__PURE__ */ jsx(Text, { color: "red", bold: true, children: "[n]" }),
+      " deny"
+    ] }) })
+  ] });
+}
+var init_Approval = __esm({
+  "src/tui/Approval.tsx"() {
+    "use strict";
+    init_render();
+  }
+});
+
+// src/tui/SelectDialog.tsx
+import { useEffect, useMemo, useState } from "react";
+import { Box as Box2, Text as Text2, useInput as useInput2 } from "ink";
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+function SelectDialog({
+  title,
+  items,
+  descriptions,
+  loading,
+  error,
+  current,
+  onSelect,
+  onClose
+}) {
+  const [filter, setFilter] = useState("");
+  const [cursor, setCursor] = useState(0);
+  const filtered = useMemo(() => {
+    const f = filter.trim().toLowerCase();
+    return f ? items.filter((item) => item.toLowerCase().includes(f)) : items;
+  }, [items, filter]);
+  useEffect(() => {
+    setCursor(0);
+  }, [filter]);
+  useInput2((input, key) => {
+    if (key.upArrow || input === "k") setCursor((c) => Math.max(0, c - 1));
+    else if (key.downArrow || input === "j") setCursor((c) => Math.min(filtered.length - 1, c + 1));
+    else if (key.return) {
+      const item = filtered[cursor];
+      if (item) onSelect(item);
+    } else if (key.escape) onClose();
+    else if (key.backspace || key.delete) setFilter((f) => f.slice(0, -1));
+    else if (input && !key.ctrl && !key.meta) setFilter((f) => f + input);
+  });
+  const start = Math.max(
+    0,
+    Math.min(cursor - Math.floor(VISIBLE / 2), Math.max(0, filtered.length - VISIBLE))
+  );
+  const visible = filtered.slice(start, start + VISIBLE);
+  return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", borderStyle: "round", borderColor: "cyan", paddingX: 1, marginY: 1, children: [
+    /* @__PURE__ */ jsx2(Text2, { bold: true, color: "cyan", children: title }),
+    /* @__PURE__ */ jsxs2(Box2, { marginTop: 1, children: [
+      /* @__PURE__ */ jsxs2(Text2, { dimColor: true, children: [
+        "search: ",
+        filter
+      ] }),
+      /* @__PURE__ */ jsx2(Text2, { children: "\u258F" })
+    ] }),
+    loading ? /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: "loading\u2026" }) : null,
+    error ? /* @__PURE__ */ jsx2(Text2, { color: "red", children: error }) : null,
+    !loading && !error ? /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", children: [
+      visible.map((item, i) => {
+        const index = start + i;
+        const isCursor = index === cursor;
+        const isCurrent = item === current;
+        const description = descriptions?.[item];
+        return /* @__PURE__ */ jsxs2(Text2, { color: isCursor ? "cyan" : void 0, bold: isCursor, children: [
+          isCursor ? "\u276F " : "  ",
+          isCurrent ? "\u25CF " : "\u25CB ",
+          item,
+          isCurrent ? "  (current)" : "",
+          description ? /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: `  \u2014 ${description}` }) : null
+        ] }, item);
+      }),
+      filtered.length === 0 ? /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: "no matches" }) : null
+    ] }) : null,
+    /* @__PURE__ */ jsx2(Box2, { marginTop: 1, children: /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: "\u2191\u2193 move \xB7 type to filter \xB7 enter select \xB7 esc cancel" }) })
+  ] });
+}
+var VISIBLE;
+var init_SelectDialog = __esm({
+  "src/tui/SelectDialog.tsx"() {
+    "use strict";
+    VISIBLE = 10;
+  }
+});
+
+// src/tui/KeyDialog.tsx
+import { useState as useState2 } from "react";
+import { Box as Box3, Text as Text3, useInput as useInput3 } from "ink";
+import TextInput from "ink-text-input";
+import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+function KeyDialog({ providerName, onSubmit, onClose }) {
+  const [value, setValue] = useState2("");
+  useInput3((_input, key) => {
+    if (key.escape) onClose();
+  });
+  return /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", borderStyle: "round", borderColor: "magenta", paddingX: 1, marginY: 1, children: [
+    /* @__PURE__ */ jsxs3(Text3, { bold: true, color: "magenta", children: [
+      "API key for ",
+      providerName
+    ] }),
+    /* @__PURE__ */ jsxs3(Box3, { marginTop: 1, children: [
+      /* @__PURE__ */ jsx3(Text3, { children: "key: " }),
+      /* @__PURE__ */ jsx3(
+        TextInput,
+        {
+          mask: "*",
+          value,
+          onChange: setValue,
+          onSubmit: (submitted) => {
+            if (submitted.trim()) onSubmit(submitted.trim());
+          },
+          placeholder: "Paste your API key..."
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsx3(Box3, { marginTop: 1, children: /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: "enter confirm \xB7 esc cancel \xB7 saved to ~/.mentee/config.json" }) })
+  ] });
+}
+var init_KeyDialog = __esm({
+  "src/tui/KeyDialog.tsx"() {
+    "use strict";
+  }
+});
+
+// src/tui/App.tsx
+var App_exports = {};
+__export(App_exports, {
+  App: () => App
+});
+import { useEffect as useEffect2, useMemo as useMemo2, useRef, useState as useState3 } from "react";
+import { Box as Box4, Static, Text as Text4, useApp, useInput as useInput4 } from "ink";
+import TextInput2 from "ink-text-input";
+import { jsx as jsx4, jsxs as jsxs4 } from "react/jsx-runtime";
+function App(props) {
+  const { exit } = useApp();
+  const bus = useMemo2(() => new EventBus(), []);
+  const bridge = useMemo2(() => new ApprovalBridge(), []);
+  const [log, setLog] = useState3([]);
+  const [running, setRunning] = useState3(false);
+  const [taskInput, setTaskInput] = useState3("");
+  const [approval, setApproval] = useState3(null);
+  const [dialog, setDialog] = useState3(null);
+  const [frame, setFrame] = useState3(0);
+  const [providerName, setProviderName] = useState3(props.providerName);
+  const [model, setModel] = useState3(void 0);
+  const [factoryResult, setFactoryResult] = useState3(
+    () => props.createProvider(props.providerName)
+  );
+  const [modelItems, setModelItems] = useState3([]);
+  const [modelLoading, setModelLoading] = useState3(false);
+  const [modelError, setModelError] = useState3(null);
+  const [finalPending, setFinalPending] = useState3(null);
+  const [typedText, setTypedText] = useState3("");
+  const [typing, setTyping] = useState3(false);
+  const [toolHistory, setToolHistory] = useState3([]);
+  const [inspectorIndex, setInspectorIndex] = useState3(null);
+  const [detailsOpen, setDetailsOpen] = useState3(false);
+  const [showTools, setShowTools] = useState3(true);
+  const pendingTool = useRef(null);
+  const counter = useRef(0);
+  const stateRef = useRef({ running, approval, dialog, factoryResult, providerName, model });
+  stateRef.current = { running, approval, dialog, factoryResult, providerName, model };
+  const appendLog = (text) => {
+    if (!text) return;
+    counter.current += 1;
+    const line = { id: counter.current, text };
+    setLog((prev) => [...prev, line]);
+  };
+  useEffect2(() => {
+    const HIDDEN_NOISY = /* @__PURE__ */ new Set(["tool_started", "tool_completed", "model_request", "info"]);
+    const unsubscribeLog = bus.subscribe((event) => {
+      if (!(showTools === false && HIDDEN_NOISY.has(event.type))) {
+        appendLog(formatEvent(event));
+      }
+      if (event.type === "tool_started") {
+        const name = typeof event.data?.tool === "string" ? event.data.tool : "";
+        const target = typeof event.message === "string" ? event.message : "";
+        const args = typeof event.data?.args === "string" ? event.data.args : "";
+        pendingTool.current = { name, target, args };
+      } else if (event.type === "tool_completed") {
+        const rec = pendingTool.current;
+        const name = typeof event.data?.tool === "string" ? event.data.tool : rec?.name ?? "";
+        const output = typeof event.data?.output === "string" ? event.data.output : "";
+        setToolHistory(
+          (prev) => [...prev, { name, target: rec?.target ?? "", args: rec?.args ?? "", output: output.slice(0, 4e3) }].slice(-40)
+        );
+        pendingTool.current = null;
+      } else if (event.type === "task_completed") {
+        const text = typeof event.data?.finalText === "string" ? event.data.finalText.trim() : "";
+        if (text) {
+          appendLog(text);
+          setFinalPending(text);
+          setTypedText("");
+          setTyping(true);
+        }
+      }
+    });
+    const unsubscribeLog2 = bus.subscribe(createSessionLogger());
+    bridge.setListener((request) => {
+      setApproval(request);
+      if (request) bus.emit("approval", friendlyToolName(request.tool));
+    });
+    return () => {
+      unsubscribeLog();
+      unsubscribeLog2();
+    };
+  }, [bus, bridge, showTools]);
+  useEffect2(() => {
+    if (!running) return;
+    const timer = setInterval(() => setFrame((f) => (f + 1) % SPINNER_FRAMES.length), 80);
+    return () => clearInterval(timer);
+  }, [running]);
+  useEffect2(() => {
+    if (!typing || finalPending == null) return;
+    if (typedText.length >= finalPending.length) {
+      setTyping(false);
+      return;
+    }
+    const timer = setTimeout(() => {
+      setTypedText(finalPending.slice(0, typedText.length + 3));
+    }, 16);
+    return () => clearTimeout(timer);
+  }, [typing, finalPending, typedText]);
+  const updateConfig = (mutate) => {
+    const config = loadConfig() ?? {
+      defaultProvider: "kimi",
+      keys: {},
+      models: {}
+    };
+    mutate(config);
+    saveConfig(config);
+  };
+  const switchProvider = (name) => {
+    const result = props.createProvider(name, stateRef.current.model);
+    setProviderName(name);
+    setFactoryResult(result);
+    if (name !== "mock") {
+      updateConfig((config) => {
+        config.defaultProvider = name;
+      });
+    }
+    if (result.error) {
+      appendLog(`Provider set to ${name}, but no key yet \u2014 press Ctrl+K to add it.`);
+    } else {
+      appendLog(`Provider: ${name}:${stateRef.current.model ?? result.provider?.defaultModel ?? ""}`);
+    }
+  };
+  const setModelAndPersist = (id) => {
+    setModel(id);
+    const name = stateRef.current.providerName;
+    const result = props.createProvider(name, id);
+    if (!result.error) setFactoryResult(result);
+    if (name !== "mock") {
+      updateConfig((config) => {
+        config.models = config.models ?? {};
+        config.models[name] = id;
+      });
+    }
+    appendLog(`Model set to ${id} for ${name}`);
+  };
+  const saveKey = (value) => {
+    const name = stateRef.current.providerName;
+    if (name === "mock") {
+      appendLog("The mock provider needs no key.");
+      return;
+    }
+    const config = loadConfig();
+    const writable = config ?? {
+      defaultProvider: "kimi",
+      keys: {},
+      models: {}
+    };
+    writable.keys[name] = value;
+    saveConfig(writable);
+    const result = props.createProvider(name, stateRef.current.model);
+    setFactoryResult(result);
+    appendLog(
+      result.error ? `Key saved for ${name}, but connection failed: ${result.error}` : `Key saved for ${name}. You are ready to run a task.`
+    );
+  };
+  const openModelDialog = () => {
+    setDialog({ kind: "model" });
+    setModelItems([]);
+    setModelError(null);
+    setModelLoading(true);
+    const active = stateRef.current.factoryResult.provider;
+    if (!active) {
+      setModelLoading(false);
+      setModelError(stateRef.current.factoryResult.error ?? "No provider configured \u2014 press Ctrl+K to add a key first.");
+      return;
+    }
+    active.listModels().then((models) => {
+      setModelItems(models);
+      setModelLoading(false);
+    }).catch((error) => {
+      setModelLoading(false);
+      setModelError(error.message);
+    });
+  };
+  const handleCommand = (raw) => {
+    const parts = raw.slice(1).trim().split(/\s+/);
+    const cmd = parts[0] ?? "";
+    const arg = parts.slice(1).join(" ").trim();
+    switch (cmd) {
+      case "help":
+        appendLog("Commands:");
+        appendLog("  /provider    pick provider (Ctrl+P)");
+        appendLog("  /model       pick model from live list (Alt+M)");
+        appendLog("  /model <id>  set model directly");
+        appendLog("  /key         add API key (Ctrl+K)");
+        appendLog("  /status      show provider, model, key, workspace");
+        appendLog("  /exit        quit");
+        break;
+      case "provider":
+        if (arg) {
+          if (PROVIDER_NAMES.includes(arg)) switchProvider(arg);
+          else appendLog(`Unknown provider "${arg}". Options: ${PROVIDER_NAMES.join(", ")}`);
+        } else {
+          setDialog({ kind: "provider" });
+        }
+        break;
+      case "models":
+      case "model": {
+        if (arg) {
+          setModelAndPersist(arg);
+        } else {
+          openModelDialog();
+        }
+        break;
+      }
+      case "key":
+        if (arg) saveKey(arg);
+        else setDialog({ kind: "key" });
+        break;
+      case "status": {
+        const active = stateRef.current.factoryResult;
+        appendLog(`provider:  ${stateRef.current.providerName}`);
+        appendLog(`model:     ${stateRef.current.model ?? active.provider?.defaultModel ?? "default"}`);
+        appendLog(
+          `key:       ${stateRef.current.providerName === "mock" ? "not needed" : active.provider ? "configured" : "MISSING \u2014 Ctrl+K"}`
+        );
+        appendLog(`workspace: ${props.cwd}`);
+        break;
+      }
+      case "exit":
+      case "quit":
+        exit();
+        setTimeout(() => process.exit(0), 50);
+        break;
+      default:
+        appendLog(`Unknown command "/${cmd}". Try /help`);
+    }
+  };
+  const startTask = async (task) => {
+    if (stateRef.current.running || !task.trim()) return;
+    if (!factoryResult.provider) {
+      appendLog(factoryResult.error ?? "No provider configured. Press Ctrl+K to add an API key.");
+      return;
+    }
+    setFinalPending(null);
+    setTypedText("");
+    setTyping(false);
+    setToolHistory([]);
+    setInspectorIndex(null);
+    setDetailsOpen(false);
+    setRunning(true);
+    try {
+      await runAgent({
+        task,
+        cwd: props.cwd,
+        provider: factoryResult.provider,
+        model,
+        tools: props.tools,
+        bus,
+        approval: props.yes ? async () => "allow" : bridge.handler,
+        maxIterations: props.maxIterations,
+        systemExtra: props.systemExtra
+      });
+    } catch (error) {
+      bus.emit("error", error.message);
+    } finally {
+      setRunning(false);
+      appendLog("Ready for the next task.");
+    }
+  };
+  const handleSubmit = (value) => {
+    const trimmed = value.trim();
+    setTaskInput("");
+    if (!trimmed) return;
+    if (trimmed.startsWith("/")) {
+      handleCommand(trimmed);
+    } else {
+      void startTask(trimmed);
+    }
+  };
+  useEffect2(() => {
+    if (props.initialTask) {
+      void startTask(props.initialTask);
+    }
+  }, []);
+  const cycleInspector = () => {
+    if (toolHistory.length === 0) return;
+    const cur = detailsOpen && inspectorIndex != null ? inspectorIndex : toolHistory.length;
+    const next = cur + 1;
+    if (next >= toolHistory.length) {
+      setDetailsOpen(false);
+      setInspectorIndex(null);
+    } else {
+      setDetailsOpen(true);
+      setInspectorIndex(next);
+    }
+  };
+  useInput4((input, key) => {
+    if (stateRef.current.dialog || stateRef.current.approval || stateRef.current.running) return;
+    if (key.meta && (input === "m" || input === "M")) openModelDialog();
+    else if (key.ctrl && input === "p") setDialog({ kind: "provider" });
+    else if (key.ctrl && input === "k") setDialog({ kind: "key" });
+    else if (input === "d" || input === "D") cycleInspector();
+    else if (input === "t" || input === "T") setShowTools((v) => !v);
+    else if (key.ctrl && input === "c") {
+      exit();
+      setTimeout(() => process.exit(0), 50);
+    }
+  });
+  const modelLabel = model ?? factoryResult.provider?.defaultModel ?? (factoryResult.error ? "no key" : "");
+  const header = /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", marginBottom: 1, children: [
+    /* @__PURE__ */ jsx4(Text4, { color: "cyan", children: BANNER }),
+    /* @__PURE__ */ jsxs4(Text4, { dimColor: true, children: [
+      "v0.1.0 \xB7 ",
+      providerName,
+      modelLabel ? `:${modelLabel}` : "",
+      " \xB7 tools ",
+      showTools ? "on" : "off",
+      " \xB7 ",
+      props.cwd
+    ] }),
+    /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: "Alt+M model \xB7 Ctrl+P provider \xB7 Ctrl+K key \xB7 t hide tools \xB7 d details \xB7 /help" })
+  ] }, "header");
+  return /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx4(
+      Static,
+      {
+        items: [
+          { key: "header", text: header },
+          ...log.map((line) => ({ key: `l${line.id}`, text: /* @__PURE__ */ jsx4(Text4, { children: line.text }) }))
+        ],
+        children: (item) => /* @__PURE__ */ jsx4(Box4, { children: item.text }, item.key)
+      }
+    ),
+    finalPending !== null ? /* @__PURE__ */ jsxs4(Box4, { marginTop: 1, children: [
+      /* @__PURE__ */ jsx4(Text4, { color: "green", children: typedText }),
+      typing ? /* @__PURE__ */ jsx4(Text4, { color: "green", children: "\u258C" }) : null
+    ] }) : null,
+    detailsOpen && inspectorIndex !== null && toolHistory[inspectorIndex] ? (() => {
+      const rec = toolHistory[inspectorIndex];
+      const outLines = rec.output.split("\n").slice(0, 24).join("\n");
+      return /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", marginTop: 1, borderStyle: "round", borderColor: "gray", paddingX: 1, children: [
+        /* @__PURE__ */ jsxs4(Text4, { dimColor: true, children: [
+          " tool details (",
+          inspectorIndex + 1,
+          "/",
+          toolHistory.length,
+          ") \xB7 press d to cycle "
+        ] }),
+        /* @__PURE__ */ jsxs4(Text4, { color: toolColorName(rec.name), bold: true, children: [
+          rec.name,
+          " ",
+          rec.target
+        ] }),
+        /* @__PURE__ */ jsxs4(Text4, { dimColor: true, children: [
+          "args: ",
+          rec.args.slice(0, 400) || "(none)"
+        ] }),
+        /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: outLines || "(no output)" })
+      ] });
+    })() : null,
+    dialog?.kind === "model" ? /* @__PURE__ */ jsx4(
+      SelectDialog,
+      {
+        title: `Model \u2014 ${providerName}`,
+        items: modelItems,
+        loading: modelLoading,
+        error: modelError,
+        current: model ?? factoryResult.provider?.defaultModel,
+        onSelect: (id) => {
+          setDialog(null);
+          setModelAndPersist(id);
+        },
+        onClose: () => setDialog(null)
+      }
+    ) : dialog?.kind === "provider" ? /* @__PURE__ */ jsx4(
+      SelectDialog,
+      {
+        title: "Provider",
+        items: PROVIDER_NAMES,
+        descriptions: PROVIDER_DESCRIPTIONS,
+        current: providerName,
+        onSelect: (name) => {
+          setDialog(null);
+          switchProvider(name);
+        },
+        onClose: () => setDialog(null)
+      }
+    ) : dialog?.kind === "key" ? /* @__PURE__ */ jsx4(
+      KeyDialog,
+      {
+        providerName,
+        onSubmit: (value) => {
+          setDialog(null);
+          saveKey(value);
+        },
+        onClose: () => setDialog(null)
+      }
+    ) : approval ? /* @__PURE__ */ jsx4(
+      ApprovalPrompt,
+      {
+        request: approval,
+        onDecision: (decision) => {
+          bridge.resolve(decision);
+          if (decision === "always") bus.emit("info", "Approved for the rest of this session.");
+        }
+      }
+    ) : running ? /* @__PURE__ */ jsxs4(Box4, { children: [
+      /* @__PURE__ */ jsxs4(Text4, { color: "yellow", children: [
+        SPINNER_FRAMES[frame],
+        " "
+      ] }),
+      /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: "agent working... (Ctrl+C to exit)" })
+    ] }) : /* @__PURE__ */ jsxs4(Box4, { children: [
+      /* @__PURE__ */ jsx4(Text4, { color: "cyan", bold: true, children: "\u25B8 " }),
+      /* @__PURE__ */ jsx4(
+        TextInput2,
+        {
+          value: taskInput,
+          onChange: setTaskInput,
+          onSubmit: handleSubmit,
+          placeholder: "Describe a task, or /help"
+        }
+      )
+    ] })
+  ] });
+}
+var SPINNER_FRAMES, PROVIDER_NAMES, PROVIDER_DESCRIPTIONS, BANNER;
+var init_App = __esm({
+  "src/tui/App.tsx"() {
+    "use strict";
+    init_events();
+    init_logging();
+    init_render();
+    init_approval();
+    init_loop();
+    init_config();
+    init_Approval();
+    init_SelectDialog();
+    init_KeyDialog();
+    SPINNER_FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+    PROVIDER_NAMES = ["kimi", "glm", "zai", "zai-coding", "mock"];
+    PROVIDER_DESCRIPTIONS = {
+      kimi: "Moonshot \xB7 api.moonshot.ai",
+      glm: "Zhipu China \xB7 open.bigmodel.cn \xB7 separate account & keys",
+      zai: "Z.ai standard plan \xB7 api.z.ai/api/paas/v4",
+      "zai-coding": "Z.ai GLM Coding Plan subscription \xB7 api.z.ai/api/coding",
+      mock: "offline testing \xB7 no network"
+    };
+    BANNER = ` __  __           _      _____
+|  \\/  | ___ _ __ / \\   | ____|
+| |\\/| |/ _ \\ '__| _ \\  |  _|
+| |  | |  __/ | / ___ \\ | |___
+|_|  |_|\\___|_|/_/   \\_\\_____|`;
+  }
+});
+
+// src/cli.tsx
+init_config();
+import { Command } from "commander";
+import chalk4 from "chalk";
+
+// src/models/router.ts
+init_config();
+
+// src/models/openai-compat.ts
+import OpenAI from "openai";
+function mapFinishReason(reason) {
+  switch (reason) {
+    case "tool_calls":
+    case "function_call":
+      return "tool_calls";
+    case "length":
+      return "length";
+    case "stop":
+      return "stop";
+    default:
+      return "stop";
+  }
+}
+function toWireTools(tools) {
+  return tools.map((tool) => ({
+    type: "function",
+    function: {
+      name: tool.name,
+      description: tool.description,
+      parameters: tool.parameters
+    }
+  }));
+}
+var OpenAICompatProvider = class {
+  name;
+  defaultModel;
+  client;
+  constructor(options) {
+    this.name = options.name;
+    this.defaultModel = options.defaultModel;
+    this.client = new OpenAI({
+      baseURL: options.baseURL,
+      apiKey: options.apiKey
+    });
+  }
+  async generate(request, model) {
+    const messages = [
+      { role: "system", content: request.system },
+      ...request.messages
+    ];
+    const response = await this.client.chat.completions.create({
+      model: model ?? this.defaultModel,
+      // the wire format matches our internal shape; keep loose typing at the boundary
+      messages,
+      ...request.tools.length > 0 ? { tools: toWireTools(request.tools) } : {},
+      ...request.temperature !== void 0 ? { temperature: request.temperature } : {},
+      ...request.maxTokens ? { max_tokens: request.maxTokens } : {}
+    });
+    const choice = response.choices[0];
+    const message = choice?.message;
+    const usage = response.usage ? {
+      inputTokens: response.usage.prompt_tokens ?? 0,
+      outputTokens: response.usage.completion_tokens ?? 0
+    } : void 0;
+    return {
+      content: message?.content ?? null,
+      toolCalls: message?.tool_calls ?? [],
+      finishReason: mapFinishReason(choice?.finish_reason),
+      usage
+    };
+  }
+  async listModels() {
+    const page = await this.client.models.list();
+    const ids = [];
+    for await (const model of page) {
+      ids.push(model.id);
+    }
+    return ids.sort();
+  }
+};
+
+// src/models/glm.ts
+function createGlmProvider(apiKey, model) {
+  return new OpenAICompatProvider({
+    name: "glm",
+    defaultModel: model ?? "glm-4.6",
+    baseURL: "https://open.bigmodel.cn/api/paas/v4",
+    apiKey
+  });
+}
+
+// src/models/kimi.ts
+function createKimiProvider(apiKey, model) {
+  return new OpenAICompatProvider({
+    name: "kimi",
+    defaultModel: model ?? "kimi-k2.7-code",
+    baseURL: "https://api.moonshot.ai/v1",
+    apiKey
+  });
+}
+
+// src/models/mock.ts
+var callCounter = 0;
+var MockProvider = class {
+  constructor(script) {
+    this.script = script;
+  }
+  script;
+  name = "mock";
+  defaultModel = "mock-1";
+  step = 0;
+  async listModels() {
+    return ["mock-1", "mock-2", "mock-large"];
+  }
+  async generate(_request, _model) {
+    const scripted = this.script[this.step] ?? { content: "No more scripted steps remain." };
+    this.step += 1;
+    const toolCalls = (scripted.toolCalls ?? []).map((call) => {
+      callCounter += 1;
+      return {
+        id: `call_${callCounter}`,
+        type: "function",
+        function: {
+          name: call.name,
+          arguments: JSON.stringify(call.args)
+        }
+      };
+    });
+    return {
+      content: toolCalls.length > 0 ? scripted.content ?? null : scripted.content ?? "Task complete.",
+      toolCalls,
+      finishReason: toolCalls.length > 0 ? "tool_calls" : "stop",
+      usage: { inputTokens: 10, outputTokens: 10 }
+    };
+  }
+};
+
+// src/models/zai.ts
+function createZaiProvider(apiKey, model) {
+  return new OpenAICompatProvider({
+    name: "zai",
+    defaultModel: model ?? "glm-4.6",
+    baseURL: "https://api.z.ai/api/paas/v4",
+    apiKey
+  });
+}
+function createZaiCodingProvider(apiKey, model) {
+  return new OpenAICompatProvider({
+    name: "zai-coding",
+    defaultModel: model ?? "glm-4.6",
+    baseURL: "https://api.z.ai/api/coding/paas/v4",
+    apiKey
+  });
+}
+
+// src/models/router.ts
+var ENV_NAMES2 = {
+  kimi: "MENTEE_KIMI_API_KEY",
+  glm: "MENTEE_GLM_API_KEY",
+  zai: "MENTEE_ZAI_API_KEY",
+  "zai-coding": "MENTEE_ZAI_API_KEY"
+};
+var MissingApiKeyError = class extends Error {
+  constructor(provider) {
+    super(
+      `No API key for provider "${provider}". Run "mentee config", set ${ENV_NAMES2[provider]}, or type /key <your-key> in the TUI.`
+    );
+    this.name = "MissingApiKeyError";
+  }
+};
+function createProvider(provider, config, modelOverride) {
+  if (provider === "mock") {
+    return new MockProvider([]);
+  }
+  const apiKey = resolveApiKey(provider, config);
+  if (!apiKey) {
+    throw new MissingApiKeyError(provider);
+  }
+  const model = modelOverride ?? resolveModel(provider, config);
+  if (provider === "kimi") {
+    return createKimiProvider(apiKey, model);
+  }
+  if (provider === "zai") {
+    return createZaiProvider(apiKey, model);
+  }
+  if (provider === "zai-coding") {
+    return createZaiCodingProvider(apiKey, model);
+  }
+  return createGlmProvider(apiKey, model);
+}
+
+// src/tools/filesystem.ts
+init_base();
+import fs2 from "fs";
+import path2 from "path";
+function resolveWithinWorkspace(cwd, target) {
+  const resolved = path2.resolve(cwd, target);
+  const normalizedCwd = path2.resolve(cwd);
+  if (resolved === normalizedCwd) return resolved;
+  if (!resolved.startsWith(normalizedCwd + path2.sep)) {
+    throw new Error(`Path escapes the workspace: ${target}`);
+  }
+  return resolved;
+}
+function relativeToWorkspace(cwd, target) {
+  return path2.relative(path2.resolve(cwd), target).split(path2.sep).join("/");
+}
+var listFiles = {
+  name: "list_files",
+  description: "List files and directories under a path inside the workspace. Respects common ignore rules (node_modules, .git, dist, ...). Use this to orient yourself in the repository.",
+  risk: "safe",
+  parameters: {
+    type: "object",
+    properties: {
+      path: {
+        type: "string",
+        description: "Relative path inside the workspace. Defaults to the workspace root."
+      },
+      max_entries: {
+        type: "number",
+        description: "Maximum number of entries to return. Defaults to 500."
+      }
+    }
+  },
+  async execute(args, ctx) {
+    const root = resolveWithinWorkspace(ctx.cwd, firstString(args, "path") ?? ".");
+    const maxEntries = firstNumber(args, "max_entries") ?? 500;
+    const ignore = /* @__PURE__ */ new Set([
+      "node_modules",
+      ".git",
+      "dist",
+      "build",
+      "out",
+      ".next",
+      ".nuxt",
+      "coverage",
+      "__pycache__",
+      ".venv",
+      "venv",
+      ".pytest_cache",
+      ".mypy_cache",
+      ".ruff_cache",
+      "target",
+      "vendor"
+    ]);
+    const lines = [];
+    const walk = (dir, depth) => {
+      if (depth > 6 || lines.length >= maxEntries) return;
+      let entries;
+      try {
+        entries = fs2.readdirSync(dir, { withFileTypes: true });
+      } catch {
+        return;
+      }
+      entries.sort((a, b) => {
+        if (a.isDirectory() !== b.isDirectory()) return a.isDirectory() ? -1 : 1;
+        return a.name.localeCompare(b.name);
+      });
+      for (const entry of entries) {
+        if (lines.length >= maxEntries) {
+          lines.push("...[entry limit reached]");
+          return;
+        }
+        if (ignore.has(entry.name)) continue;
+        const rel = relativeToWorkspace(ctx.cwd, path2.join(dir, entry.name));
+        if (entry.isDirectory()) {
+          lines.push(`${rel}/`);
+          walk(path2.join(dir, entry.name), depth + 1);
+        } else {
+          lines.push(rel);
+        }
+      }
+    };
+    walk(root, 0);
+    if (lines.length === 0) return { success: true, output: "(empty directory)" };
+    return { success: true, output: lines.join("\n") };
+  }
+};
+var movePath = {
+  name: "move_path",
+  description: "Move or rename a file or directory within the workspace. Requires user approval. Parent directories of the destination are created automatically.",
+  risk: "restricted",
+  parameters: {
+    type: "object",
+    properties: {
+      from: { type: "string", description: "Source path relative to the workspace root." },
+      to: { type: "string", description: "Destination path relative to the workspace root." }
+    },
+    required: ["from", "to"]
+  },
+  async execute(args, ctx) {
+    const fromPath = resolveWithinWorkspace(ctx.cwd, requireString(args, "from"));
+    const toPath = resolveWithinWorkspace(ctx.cwd, requireString(args, "to"));
+    if (!fs2.existsSync(fromPath)) {
+      return { success: false, output: `Source does not exist: ${relativeToWorkspace(ctx.cwd, fromPath)}` };
+    }
+    if (fs2.existsSync(toPath)) {
+      return { success: false, output: `Destination already exists: ${relativeToWorkspace(ctx.cwd, toPath)}` };
+    }
+    fs2.mkdirSync(path2.dirname(toPath), { recursive: true });
+    fs2.renameSync(fromPath, toPath);
+    return {
+      success: true,
+      output: `Moved ${relativeToWorkspace(ctx.cwd, fromPath)} -> ${relativeToWorkspace(ctx.cwd, toPath)}`
+    };
+  }
+};
+var readFile = {
+  name: "read_file",
+  description: "Read a file from the workspace, optionally restricted to a line range. Output is prefixed with line numbers. Prefer reading ranges of large files instead of whole files.",
+  risk: "safe",
+  parameters: {
+    type: "object",
+    properties: {
+      path: { type: "string", description: "File path relative to the workspace root." },
+      start_line: { type: "number", description: "First line to read (1-based). Defaults to 1." },
+      end_line: { type: "number", description: "Last line to read (inclusive). Defaults to start_line + 2000." }
+    },
+    required: ["path"]
+  },
+  async execute(args, ctx) {
+    const filePath = resolveWithinWorkspace(ctx.cwd, requireString(args, "path"));
+    let content;
+    try {
+      content = fs2.readFileSync(filePath, "utf8");
+    } catch (error) {
+      return { success: false, output: `Cannot read file: ${error.message}` };
+    }
+    const lines = content.split(/\r?\n/);
+    const start = Math.max(1, firstNumber(args, "start_line") ?? 1);
+    const defaultEnd = start + 2e3 - 1;
+    const end = Math.min(lines.length, firstNumber(args, "end_line") ?? defaultEnd);
+    if (start > lines.length) {
+      return {
+        success: false,
+        output: `start_line ${start} is beyond end of file (${lines.length} lines)`
+      };
+    }
+    const slice = lines.slice(start - 1, end).map((line, i) => `${start + i}: ${line}`);
+    const { text, truncated } = truncateOutput(slice.join("\n"), 5e4);
+    const note = end < lines.length ? `
+...[${lines.length - end} more lines. Use start_line=${end + 1} to continue reading.]` : "";
+    return {
+      success: true,
+      output: `${filePath === path2.resolve(ctx.cwd) ? "(file)" : relativeToWorkspace(ctx.cwd, filePath)} (${lines.length} lines)
+${text}${note}`,
+      truncated
+    };
+  }
+};
+var writeFile = {
+  name: "write_file",
+  description: "Create a new file or fully overwrite an existing file with the given content inside the workspace. For modifying existing files prefer apply_patch.",
+  risk: "safe",
+  parameters: {
+    type: "object",
+    properties: {
+      path: { type: "string", description: "File path relative to the workspace root." },
+      content: { type: "string", description: "The full file content to write." }
+    },
+    required: ["path", "content"]
+  },
+  async execute(args, ctx) {
+    const filePath = resolveWithinWorkspace(ctx.cwd, requireString(args, "path"));
+    const content = requireString(args, "content");
+    fs2.mkdirSync(path2.dirname(filePath), { recursive: true });
+    fs2.writeFileSync(filePath, content, "utf8");
+    return {
+      success: true,
+      output: `Wrote ${Buffer.byteLength(content, "utf8")} bytes to ${relativeToWorkspace(ctx.cwd, filePath)}`
+    };
+  }
+};
+var applyPatch = {
+  name: "apply_patch",
+  description: "Apply a minimal edit to an existing file by replacing an exact unique snippet (old_string) with new_string. The snippet must appear exactly once in the file. This is the preferred way to modify files: it makes the smallest possible change.",
+  risk: "safe",
+  parameters: {
+    type: "object",
+    properties: {
+      path: { type: "string", description: "File path relative to the workspace root." },
+      old_string: { type: "string", description: "The exact text to replace. Must occur exactly once in the file." },
+      new_string: { type: "string", description: "The replacement text." }
+    },
+    required: ["path", "old_string", "new_string"]
+  },
+  async execute(args, ctx) {
+    const filePath = resolveWithinWorkspace(ctx.cwd, requireString(args, "path"));
+    const oldString = requireString(args, "old_string");
+    const newString = requireString(args, "new_string");
+    let content;
+    try {
+      content = fs2.readFileSync(filePath, "utf8");
+    } catch (error) {
+      return { success: false, output: `Cannot read file: ${error.message}` };
+    }
+    if (oldString === newString) {
+      return { success: false, output: "old_string and new_string are identical; nothing to change." };
+    }
+    const occurrences = content.split(oldString).length - 1;
+    if (occurrences === 0) {
+      return {
+        success: false,
+        output: "old_string not found in file. Read the file again and copy the exact text, including whitespace."
+      };
+    }
+    if (occurrences > 1) {
+      return {
+        success: false,
+        output: `old_string occurs ${occurrences} times. Include more surrounding lines to make it unique.`
+      };
+    }
+    const updated = content.replace(oldString, newString);
+    fs2.writeFileSync(filePath, updated, "utf8");
+    const removed = oldString.split(/\r?\n/).length;
+    const added = newString.split(/\r?\n/).length;
+    return {
+      success: true,
+      output: `Patched ${relativeToWorkspace(ctx.cwd, filePath)} (-${removed}/+${added} lines)`,
+      data: {
+        kind: "patch",
+        path: relativeToWorkspace(ctx.cwd, filePath),
+        old_string: oldString,
+        new_string: newString
+      }
+    };
+  }
+};
+
+// src/tools/git.ts
+init_base();
+import { spawnSync } from "child_process";
+function runGit(cwd, args, maxChars) {
+  for (const arg of args) {
+    if (/[;&|`$<>\n]/.test(arg)) {
+      return { success: false, output: `Invalid characters in git argument: ${arg}` };
+    }
+  }
+  const command = ["git", ...args].join(" ");
+  const result = spawnSync(command, {
+    cwd,
+    encoding: "utf8",
+    maxBuffer: 10 * 1024 * 1024,
+    shell: true,
+    windowsHide: true
+  });
+  if (result.error) {
+    return { success: false, output: `git failed: ${result.error.message}` };
+  }
+  const stderr = (result.stderr ?? "").trim();
+  if (result.status !== 0) {
+    const message = stderr || `git exited with code ${result.status}`;
+    if (/not a git repository/i.test(message)) {
+      return { success: false, output: "This workspace is not a git repository." };
+    }
+    return { success: false, output: message };
+  }
+  const { text, truncated } = truncateOutput((result.stdout ?? "").trim(), maxChars);
+  return { success: true, output: text || "(no output)", truncated };
+}
+var gitBranches = {
+  name: "git_branches",
+  description: "List all git branches (local and remote) for the workspace.",
+  risk: "safe",
+  parameters: { type: "object", properties: {} },
+  async execute(_args, ctx) {
+    return runGit(ctx.cwd, ["branch", "-a"], 1e4);
+  }
+};
+var gitStatus = {
+  name: "git_status",
+  description: "Show git status (branch + short status) for the workspace.",
+  risk: "safe",
+  parameters: { type: "object", properties: {} },
+  async execute(_args, ctx) {
+    return runGit(ctx.cwd, ["status", "--short", "--branch"], 2e4);
+  }
+};
+var gitDiff = {
+  name: "git_diff",
+  description: "Show the current uncommitted diff. Use this to review exactly what has changed.",
+  risk: "safe",
+  parameters: {
+    type: "object",
+    properties: {
+      staged: { type: "boolean", description: "Show staged changes only. Defaults to false (unstaged)." }
+    }
+  },
+  async execute(args, ctx) {
+    const staged = firstBoolean(args, "staged") ?? false;
+    return runGit(ctx.cwd, staged ? ["diff", "--staged"] : ["diff"], 5e4);
+  }
+};
+var gitLog = {
+  name: "git_log",
+  description: "Show recent commit history (one line per commit).",
+  risk: "safe",
+  parameters: {
+    type: "object",
+    properties: {
+      limit: { type: "number", description: "Number of commits. Defaults to 10." }
+    }
+  },
+  async execute(args, ctx) {
+    const limit = Math.min(100, firstNumber(args, "limit") ?? 10);
+    return runGit(ctx.cwd, ["log", "--oneline", `-n`, String(limit)], 2e4);
+  }
+};
+var gitShow = {
+  name: "git_show",
+  description: "Show a commit (message + diff) for a given ref.",
+  risk: "safe",
+  parameters: {
+    type: "object",
+    properties: {
+      ref: { type: "string", description: "Commit ref. Defaults to HEAD." },
+      stat: { type: "boolean", description: "Show only the file stat summary. Defaults to false." }
+    }
+  },
+  async execute(args, ctx) {
+    const ref = firstString(args, "ref") ?? "HEAD";
+    const stat = firstBoolean(args, "stat") ?? false;
+    const args_ = stat ? ["show", "--stat", ref] : ["show", ref];
+    return runGit(ctx.cwd, args_, 5e4);
+  }
+};
+
+// src/tools/search.ts
+init_base();
+import { spawnSync as spawnSync2 } from "child_process";
+import fs3 from "fs";
+import path3 from "path";
+var IGNORE_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  "dist",
+  "build",
+  "out",
+  ".next",
+  ".nuxt",
+  "coverage",
+  "__pycache__",
+  ".venv",
+  "venv",
+  ".pytest_cache",
+  ".mypy_cache",
+  ".ruff_cache",
+  "target",
+  "vendor"
+]);
+var TEXT_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".ts",
+  ".tsx",
+  ".js",
+  ".jsx",
+  ".mjs",
+  ".cjs",
+  ".json",
+  ".md",
+  ".txt",
+  ".css",
+  ".scss",
+  ".html",
+  ".vue",
+  ".svelte",
+  ".py",
+  ".rb",
+  ".go",
+  ".rs",
+  ".java",
+  ".kt",
+  ".c",
+  ".h",
+  ".cpp",
+  ".hpp",
+  ".cs",
+  ".php",
+  ".sh",
+  ".ps1",
+  ".bat",
+  ".yaml",
+  ".yml",
+  ".toml",
+  ".ini",
+  ".cfg",
+  ".sql",
+  ".graphql",
+  ".prisma",
+  ".env",
+  ".gitignore",
+  ".dockerfile",
+  "dockerfile",
+  ".xml"
+]);
+function isProbablyTextFile(filePath) {
+  const ext = path3.extname(filePath).toLowerCase();
+  if (TEXT_EXTENSIONS.has(ext)) return true;
+  const base = path3.basename(filePath).toLowerCase();
+  return base === "dockerfile" || base === "makefile" || base === "license" || base === "readme";
+}
+function walkFiles(root, maxFiles) {
+  const files = [];
+  const walk = (dir, depth) => {
+    if (depth > 10 || files.length >= maxFiles) return;
+    let entries;
+    try {
+      entries = fs3.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (files.length >= maxFiles) return;
+      const full = path3.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        if (IGNORE_DIRS.has(entry.name)) continue;
+        walk(full, depth + 1);
+      } else if (entry.isFile()) {
+        files.push(full);
+      }
+    }
+  };
+  walk(root, 0);
+  return files;
+}
+function globToRegExp(glob) {
+  const escaped = glob.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, "\0").replace(/\*/g, "[^/]*").replace(/\?/g, ".").replace(/\u0000/g, ".*");
+  return new RegExp(`^${escaped}$`, "i");
+}
+function ripgrepAvailable() {
+  try {
+    const result = spawnSync2("rg --version", { stdio: "ignore", shell: true });
+    return !result.error && result.status === 0;
+  } catch {
+    return false;
+  }
+}
+var searchCode = {
+  name: "search_code",
+  description: "Search file contents across the workspace for a pattern (regex supported). Faster and more context-efficient than reading many files. Returns matching file paths, line numbers, and lines.",
+  risk: "safe",
+  parameters: {
+    type: "object",
+    properties: {
+      pattern: { type: "string", description: "Regex or literal text to search for." },
+      path: { type: "string", description: "Subdirectory to search. Defaults to the workspace root." },
+      glob: { type: "string", description: 'Optional file glob filter, e.g. "*.ts" or "src/**".' },
+      max_results: { type: "number", description: "Maximum matches to return. Defaults to 50." }
+    },
+    required: ["pattern"]
+  },
+  async execute(args, ctx) {
+    const pattern = firstString(args, "pattern");
+    if (!pattern) return { success: false, output: "Missing required argument: pattern" };
+    const root = resolveWithinWorkspace(ctx.cwd, firstString(args, "path") ?? ".");
+    const glob = firstString(args, "glob");
+    const maxResults = Math.min(200, firstNumber(args, "max_results") ?? 50);
+    let regex;
+    try {
+      regex = new RegExp(pattern, "i");
+    } catch {
+      regex = new RegExp(pattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "i");
+    }
+    const matches = [];
+    let truncated = false;
+    if (ripgrepAvailable()) {
+      const rgArgs = ["rg", "--no-heading", "--line-number", "--max-count", String(maxResults), "-S", pattern];
+      if (glob) rgArgs.push("--glob", glob);
+      rgArgs.push(".");
+      const result = spawnSync2(rgArgs.join(" "), {
+        cwd: root,
+        shell: true,
+        encoding: "utf8",
+        maxBuffer: 10 * 1024 * 1024
+      });
+      const stdout = result.stdout ?? "";
+      for (const line of stdout.split(/\r?\n/)) {
+        if (!line) continue;
+        if (matches.length >= maxResults) {
+          truncated = true;
+          break;
+        }
+        matches.push(line);
+      }
+    } else {
+      const globRe = glob ? globToRegExp(glob) : null;
+      const files = walkFiles(root, 5e3);
+      for (const file of files) {
+        if (matches.length >= maxResults) {
+          truncated = true;
+          break;
+        }
+        if (globRe && !globRe.test(path3.relative(root, file).split(path3.sep).join("/"))) continue;
+        if (!isProbablyTextFile(file)) continue;
+        let content;
+        try {
+          const stat = fs3.statSync(file);
+          if (stat.size > 1024 * 1024) continue;
+          content = fs3.readFileSync(file, "utf8");
+        } catch {
+          continue;
+        }
+        const rel = path3.relative(root, file).split(path3.sep).join("/");
+        const lines = content.split(/\r?\n/);
+        for (let i = 0; i < lines.length; i++) {
+          if (regex.test(lines[i] ?? "")) {
+            matches.push(`${rel}:${i + 1}: ${(lines[i] ?? "").trim().slice(0, 200)}`);
+            if (matches.length >= maxResults) {
+              truncated = true;
+              break;
+            }
+          }
+        }
+      }
+    }
+    if (matches.length === 0) return { success: true, output: "No matches found." };
+    const { text } = truncateOutput(matches.join("\n"), 4e4);
+    return {
+      success: true,
+      output: `${matches.length}${truncated ? "+" : ""} matches:
+${text}`,
+      truncated
+    };
+  }
+};
+var searchFiles = {
+  name: "search_files",
+  description: "Find files by name pattern (supports * and ? wildcards) inside the workspace. Use when you know roughly what a file is called.",
+  risk: "safe",
+  parameters: {
+    type: "object",
+    properties: {
+      pattern: { type: "string", description: 'File name pattern with wildcards, e.g. "*.test.ts" or "config*". Matches against the full relative path too.' },
+      path: { type: "string", description: "Subdirectory to search. Defaults to the workspace root." },
+      max_results: { type: "number", description: "Maximum results. Defaults to 100." }
+    },
+    required: ["pattern"]
+  },
+  async execute(args, ctx) {
+    const pattern = firstString(args, "pattern");
+    if (!pattern) return { success: false, output: "Missing required argument: pattern" };
+    const root = resolveWithinWorkspace(ctx.cwd, firstString(args, "path") ?? ".");
+    const maxResults = firstNumber(args, "max_results") ?? 100;
+    const nameRe = globToRegExp(pattern.includes("/") ? pattern : `*${pattern}*`);
+    const files = walkFiles(root, 1e4);
+    const matches = [];
+    for (const file of files) {
+      const rel = path3.relative(root, file).split(path3.sep).join("/");
+      const base = path3.basename(file);
+      if (nameRe.test(base) || nameRe.test(rel)) {
+        matches.push(rel);
+        if (matches.length >= maxResults) break;
+      }
+    }
+    if (matches.length === 0) return { success: true, output: "No files matched." };
+    return { success: true, output: `${matches.length} files:
+${matches.join("\n")}` };
+  }
+};
+
+// src/tools/terminal.ts
+init_base();
+
+// src/tools/policy.ts
+var SAFE_EXACT = /* @__PURE__ */ new Set([
+  "pwd",
+  "ls",
+  "dir",
+  "cat",
+  "type",
+  "echo",
+  "head",
+  "tail",
+  "wc",
+  "tree",
+  "whoami",
+  "which",
+  "where",
+  "hostname",
+  "date",
+  "node --version",
+  "node -v",
+  "npm --version",
+  "npm -v",
+  "npx --version",
+  "npm test",
+  "npm run",
+  "python --version",
+  "python3 --version",
+  "py --version",
+  "pip --version",
+  "pip3 --version",
+  "pytest --version",
+  "tsc --version",
+  "tsc --noEmit",
+  "go version",
+  "cargo --version",
+  "rustc --version",
+  "java -version",
+  "dotnet --version"
+]);
+var SAFE_GIT_SUBCOMMANDS = /* @__PURE__ */ new Set([
+  "status",
+  "log",
+  "diff",
+  "branch",
+  "show",
+  "rev-parse",
+  "blame",
+  "shortlog",
+  "describe"
+]);
+var SAFE_NPM_SUBCOMMANDS = /* @__PURE__ */ new Set(["test", "run", "start"]);
+var DANGEROUS_PATTERNS = [
+  /\brm\s+(-[a-z]*\s+)*-[a-z]*[rf][a-z]*/i,
+  /\brm\s+--recursive/i,
+  /\bsudo\b/i,
+  /\bformat\b/i,
+  /\bmkfs/i,
+  /\bdd\s+if=/i,
+  /\bshutdown\b/i,
+  /\breboot\b/i,
+  /\bdel\s+\/[sq]/i,
+  /\brd\s+\/s/i,
+  /\brmdir\s+\/s/i,
+  /\bremove-item\b.*-recurse/i,
+  /\bchmod\s+777\b/i,
+  /\bchown\b/i,
+  /\breg\s+(delete|add)\b/i,
+  /\binvoke-expression\b/i,
+  /\biex\b/i,
+  /\|\s*(sh|bash|zsh|pwsh|powershell)\b/i,
+  /\b(curl|wget)\b.*\|\s*(sh|bash|zsh|pwsh|powershell)\b/i,
+  /\bdrop\s+(table|database)\b/i,
+  /\bgit\s+push\s+--force\b/i,
+  /\bgit\s+reset\s+--hard\b/i,
+  /\bgit\s+clean\s+-[a-z]*f/i
+];
+var RESTRICTED_PREFIXES = [
+  "npm install",
+  "npm i ",
+  "npm uninstall",
+  "pip install",
+  "pip3 install",
+  "pip uninstall",
+  "yarn add",
+  "yarn install",
+  "pnpm add",
+  "pnpm install",
+  "docker",
+  "docker-compose",
+  "git checkout",
+  "git switch",
+  "git reset",
+  "git restore",
+  "git commit",
+  "git push",
+  "git pull",
+  "git merge",
+  "git rebase",
+  "git stash",
+  "git tag",
+  "git clean",
+  "git rm",
+  "git config",
+  "mkdir",
+  "md ",
+  "mv ",
+  "move ",
+  "cp ",
+  "copy ",
+  "touch",
+  "new-item",
+  "del ",
+  "erase ",
+  "rd ",
+  "rmdir",
+  "chmod",
+  "attrib",
+  "curl",
+  "wget",
+  "ssh",
+  "scp",
+  "kill",
+  "taskkill",
+  "node ",
+  "python ",
+  "python3 ",
+  "dotnet ",
+  "go ",
+  "cargo ",
+  "java ",
+  "npx "
+];
+function splitCommandChain(command) {
+  return command.split(/(?:\|\||&&|;|\|)/).map((part) => part.trim()).filter((part) => part.length > 0);
+}
+function classifySingle(command) {
+  const cmd = command.trim().toLowerCase().replace(/\s+/g, " ");
+  if (cmd.length === 0) return "safe";
+  for (const pattern of DANGEROUS_PATTERNS) {
+    if (pattern.test(cmd)) return "dangerous";
+  }
+  if (cmd.startsWith("git ")) {
+    const sub = cmd.slice(4).split(" ")[0] ?? "";
+    if (SAFE_GIT_SUBCOMMANDS.has(sub)) return "safe";
+    return "restricted";
+  }
+  if (cmd.startsWith("npm ")) {
+    const sub = cmd.slice(4).split(" ")[0] ?? "";
+    if (SAFE_NPM_SUBCOMMANDS.has(sub)) return "safe";
+    return "restricted";
+  }
+  if (cmd.startsWith("pytest") || cmd.startsWith("vitest") || cmd.startsWith("jest")) {
+    return "safe";
+  }
+  if (SAFE_EXACT.has(cmd)) return "safe";
+  for (const prefix of RESTRICTED_PREFIXES) {
+    if (cmd.startsWith(prefix)) return "restricted";
+  }
+  return "restricted";
+}
+function isDangerousFull(command) {
+  const cmd = command.trim().toLowerCase().replace(/\s+/g, " ");
+  for (const pattern of DANGEROUS_PATTERNS) {
+    if (pattern.test(cmd)) return true;
+  }
+  return false;
+}
+function classifyCommand(command) {
+  if (isDangerousFull(command)) return "dangerous";
+  const parts = splitCommandChain(command);
+  if (parts.length === 0) return "safe";
+  let overall = "safe";
+  for (const part of parts) {
+    const risk = classifySingle(part);
+    if (risk === "dangerous") return "dangerous";
+    if (risk === "restricted") overall = "restricted";
+  }
+  return overall;
+}
+
+// src/tools/exec.ts
+import { spawn } from "child_process";
+function killTree(child) {
+  if (child.pid === void 0) return;
+  if (process.platform === "win32") {
+    spawn(`taskkill /pid ${String(child.pid)} /T /F`, { stdio: "ignore", shell: true });
+  } else {
+    child.kill("SIGKILL");
+  }
+}
+async function runShellCommand(command, cwd, timeoutMs = 12e4, maxChars = 1e5) {
+  return new Promise((resolve) => {
+    const started = Date.now();
+    const child = spawn(command, {
+      shell: true,
+      cwd,
+      env: { ...process.env, MENTEE: "1" },
+      windowsHide: true
+    });
+    let stdout = "";
+    let stderr = "";
+    let killed = false;
+    const timer = setTimeout(() => {
+      killed = true;
+      killTree(child);
+    }, timeoutMs);
+    child.stdout?.on("data", (chunk) => {
+      if (stdout.length < maxChars * 2) stdout += chunk.toString("utf8");
+    });
+    child.stderr?.on("data", (chunk) => {
+      if (stderr.length < maxChars * 2) stderr += chunk.toString("utf8");
+    });
+    child.on("error", (error) => {
+      clearTimeout(timer);
+      resolve({
+        exitCode: -1,
+        stdout,
+        stderr: `${stderr}
+${error.message}`.trim(),
+        durationMs: Date.now() - started
+      });
+    });
+    child.on("close", (code) => {
+      clearTimeout(timer);
+      resolve({
+        exitCode: killed ? "timeout" : code ?? -1,
+        stdout,
+        stderr,
+        durationMs: Date.now() - started
+      });
+    });
+  });
+}
+function formatOutcome(outcome, maxChars = 1e5) {
+  const cut = (text, limit) => {
+    if (text.length <= limit) return { text, truncated: false };
+    const head = Math.floor(limit * 0.7);
+    return {
+      text: `${text.slice(0, head)}
+...[truncated, ${text.length - head} chars removed]...`,
+      truncated: true
+    };
+  };
+  const out = cut(outcome.stdout.trim(), maxChars);
+  const err = cut(outcome.stderr.trim(), Math.floor(maxChars / 2));
+  const sections = [`exit_code: ${outcome.exitCode}`, `duration_ms: ${outcome.durationMs}`];
+  if (out.text) sections.push(`stdout:
+${out.text}`);
+  if (err.text) sections.push(`stderr:
+${err.text}`);
+  if (!out.text && !err.text) sections.push("(no output)");
+  return {
+    output: sections.join("\n"),
+    success: outcome.exitCode === 0,
+    truncated: out.truncated || err.truncated
+  };
+}
+
+// src/tools/terminal.ts
+var DEFAULT_TIMEOUT_MS = 12e4;
+var MAX_OUTPUT_CHARS = 1e5;
+var executeCommand = {
+  name: "execute_command",
+  description: "Execute a shell command in the workspace. Safe read-only commands (ls, git status, npm test, ...) run automatically. Install/git-write commands require user approval. Dangerous commands (rm -rf, sudo, ...) are blocked.",
+  risk: "restricted",
+  timeoutMs: DEFAULT_TIMEOUT_MS,
+  dynamicRisk: (args) => {
+    const command = typeof args.command === "string" ? args.command : "";
+    return classifyCommand(command);
+  },
+  parameters: {
+    type: "object",
+    properties: {
+      command: { type: "string", description: "The shell command to execute." },
+      timeout_ms: { type: "number", description: `Timeout in milliseconds. Defaults to ${DEFAULT_TIMEOUT_MS}, max 600000.` }
+    },
+    required: ["command"]
+  },
+  async execute(args, ctx) {
+    const command = typeof args.command === "string" ? args.command.trim() : "";
+    if (!command) return { success: false, output: "Missing required argument: command" };
+    const timeoutMs = Math.min(6e5, firstNumber(args, "timeout_ms") ?? DEFAULT_TIMEOUT_MS);
+    const outcome = await runShellCommand(command, ctx.cwd, timeoutMs, MAX_OUTPUT_CHARS);
+    const formatted = formatOutcome(outcome, MAX_OUTPUT_CHARS);
+    return {
+      success: formatted.success,
+      output: formatted.output,
+      truncated: formatted.truncated
+    };
+  }
+};
+
+// src/tools/testing.ts
+init_base();
+import fs4 from "fs";
+import path4 from "path";
+var DEFAULT_TIMEOUT_MS2 = 18e4;
+function readPackageJson(cwd) {
+  try {
+    return JSON.parse(fs4.readFileSync(path4.join(cwd, "package.json"), "utf8"));
+  } catch {
+    return null;
+  }
+}
+function readTextIfExists(cwd, file) {
+  try {
+    return fs4.readFileSync(path4.join(cwd, file), "utf8");
+  } catch {
+    return null;
+  }
+}
+function fileExists(cwd, file) {
+  try {
+    return fs4.existsSync(path4.join(cwd, file));
+  } catch {
+    return false;
+  }
+}
+function detectTestCommand(cwd) {
+  const pkg = readPackageJson(cwd);
+  const testScript = pkg && typeof pkg.scripts?.test === "string" ? pkg.scripts.test : null;
+  if (testScript && !/error|no test specified/i.test(testScript)) {
+    return "npm test";
+  }
+  if (fileExists(cwd, "pytest.ini") || fileExists(cwd, "tests")) return "pytest -q";
+  const pyproject = readTextIfExists(cwd, "pyproject.toml");
+  if (pyproject && /\[tool\.pytest/.test(pyproject)) return "pytest -q";
+  if (fileExists(cwd, "go.mod")) return "go test ./...";
+  if (fileExists(cwd, "Cargo.toml")) return "cargo test";
+  return null;
+}
+function detectLintCommand(cwd) {
+  if (fileExists(cwd, "eslint.config.js") || fileExists(cwd, "eslint.config.mjs") || fileExists(cwd, ".eslintrc.json") || fileExists(cwd, ".eslintrc.js")) {
+    return "npx --no-install eslint .";
+  }
+  if (fileExists(cwd, "biome.json")) return "npx --no-install biome check .";
+  if (fileExists(cwd, ".ruff.toml") || fileExists(cwd, "ruff.toml")) return "ruff check .";
+  const pyproject = readTextIfExists(cwd, "pyproject.toml");
+  if (pyproject && /\[tool\.ruff/.test(pyproject)) return "ruff check .";
+  return null;
+}
+function detectTypecheckCommand(cwd) {
+  if (fileExists(cwd, "tsconfig.json")) return "npx --no-install tsc --noEmit";
+  if (fileExists(cwd, "mypy.ini")) return "python -m mypy .";
+  const pyproject = readTextIfExists(cwd, "pyproject.toml");
+  if (pyproject && /\[tool\.mypy/.test(pyproject)) return "python -m mypy .";
+  if (fileExists(cwd, "go.mod")) return "go vet ./...";
+  if (fileExists(cwd, "Cargo.toml")) return "cargo check";
+  return null;
+}
+function makeRunnerTool(config) {
+  return {
+    name: config.name,
+    description: config.description,
+    risk: "safe",
+    timeoutMs: DEFAULT_TIMEOUT_MS2,
+    parameters: {
+      type: "object",
+      properties: {
+        command: {
+          type: "string",
+          description: "Exact command to run. If omitted, the project type is auto-detected."
+        },
+        timeout_ms: { type: "number", description: `Timeout in ms. Defaults to ${DEFAULT_TIMEOUT_MS2}.` }
+      }
+    },
+    async execute(args, ctx) {
+      let command = firstString(args, "command");
+      if (!command) {
+        command = config.detect(ctx.cwd) ?? void 0;
+        if (!command) {
+          return {
+            success: false,
+            output: `Could not auto-detect a command for this project. ${config.fallbackHint} Use the command argument to run one explicitly.`
+          };
+        }
+      }
+      const timeoutMs = Math.min(6e5, firstNumber(args, "timeout_ms") ?? DEFAULT_TIMEOUT_MS2);
+      const outcome = await runShellCommand(command, ctx.cwd, timeoutMs);
+      const formatted = formatOutcome(outcome);
+      return { success: formatted.success, output: formatted.output, truncated: formatted.truncated };
+    }
+  };
+}
+var runTests = makeRunnerTool({
+  name: "run_tests",
+  description: "Run the project test suite. Auto-detects npm test / pytest / go test / cargo test from the project files, or run an exact command. Use this to verify changes.",
+  detect: detectTestCommand,
+  fallbackHint: "No test runner found (looked for package.json scripts.test, pytest, go, cargo)."
+});
+var runLinter = makeRunnerTool({
+  name: "run_linter",
+  description: "Run the project linter (eslint / biome / ruff auto-detected).",
+  detect: detectLintCommand,
+  fallbackHint: "No linter config found (looked for eslint, biome, ruff)."
+});
+var runTypecheck = makeRunnerTool({
+  name: "run_typecheck",
+  description: "Run static type checking (tsc --noEmit / mypy / go vet / cargo check auto-detected).",
+  detect: detectTypecheckCommand,
+  fallbackHint: "No typechecker config found (looked for tsconfig.json, mypy, go, cargo)."
+});
+var inspectEnv = {
+  name: "inspect_env",
+  description: "Inspect the environment: OS info, and which toolchains are installed with versions (node, npm, python, pip, git). Use this to adapt commands to the machine.",
+  risk: "safe",
+  parameters: { type: "object", properties: {} },
+  async execute(_args, ctx) {
+    const lines = [
+      `os: ${process.platform} ${process.version} ${process.arch}`,
+      `workspace: ${ctx.cwd}`
+    ];
+    const probes = [
+      ["node", "node --version"],
+      ["npm", "npm --version"],
+      ["npx", "npx --version"],
+      ["python", "python --version"],
+      ["pip", "pip --version"],
+      ["git", "git --version"],
+      ["docker", "docker --version"]
+    ];
+    const results = await Promise.all(
+      probes.map(async ([label, probe]) => {
+        const outcome = await runShellCommand(probe, ctx.cwd, 8e3);
+        const version = `${outcome.stdout} ${outcome.stderr}`.trim().split("\n")[0] ?? "";
+        return `${label}: ${outcome.exitCode === 0 ? version || "installed (version unknown)" : "not available"}`;
+      })
+    );
+    lines.push(...results);
+    return { success: true, output: lines.join("\n") };
+  }
+};
+
+// src/tools/memory.ts
+init_config();
+init_base();
+import fs5 from "fs";
+import path5 from "path";
+import crypto from "crypto";
+function memoryDir() {
+  return path5.join(configDir(), "memory");
+}
+function memoryFile(cwd) {
+  const key = crypto.createHash("sha1").update(path5.resolve(cwd)).digest("hex").slice(0, 16);
+  return path5.join(memoryDir(), `${key}.json`);
+}
+function load(cwd) {
+  try {
+    const raw = fs5.readFileSync(memoryFile(cwd), "utf8");
+    const parsed = JSON.parse(raw);
+    return Array.isArray(parsed) ? parsed : [];
+  } catch {
+    return [];
+  }
+}
+function save(cwd, entries) {
+  fs5.mkdirSync(memoryDir(), { recursive: true });
+  fs5.writeFileSync(memoryFile(cwd), JSON.stringify(entries, null, 2), "utf8");
+}
+var memoryTool = {
+  name: "memory",
+  description: 'Persist and recall key information across iterations AND across sessions (project-scoped, stored under ~/.mentee/memory, never in the workspace). Use action=add to store important findings, decisions, conventions, or context you discovered (e.g. "project uses TypeScript 5 strict mode", "auth lives in src/auth.ts"). Use action=search (query) to recall before re-deriving something you may have learned earlier. Use list to see everything, forget to remove by id or topic.',
+  risk: "safe",
+  parameters: {
+    type: "object",
+    properties: {
+      action: { type: "string", enum: ["add", "search", "list", "forget"], description: "Operation to perform." },
+      content: { type: "string", description: "The note text (for action=add)." },
+      topic: {
+        type: "string",
+        description: "Optional short tag/category for the note (action=add) or, for action=forget, the topic to clear."
+      },
+      query: { type: "string", description: "Search terms (for action=search). Falls back to content if omitted." },
+      id: { type: "string", description: "Entry id to remove (for action=forget)." }
+    },
+    required: ["action"]
+  },
+  async execute(args, ctx) {
+    const action = firstString(args, "action");
+    const entries = load(ctx.cwd);
+    switch (action) {
+      case "add": {
+        const content = firstString(args, "content");
+        if (!content || !content.trim()) {
+          return { success: false, output: "Missing required argument: content" };
+        }
+        const topic = firstString(args, "topic") ?? "";
+        const entry = {
+          id: crypto.randomBytes(4).toString("hex"),
+          topic,
+          content: content.trim(),
+          createdAt: (/* @__PURE__ */ new Date()).toISOString()
+        };
+        entries.push(entry);
+        save(ctx.cwd, entries);
+        return {
+          success: true,
+          output: `Saved memory (id ${entry.id}${topic ? `, topic "${topic}"` : ""}). Total stored: ${entries.length}.`
+        };
+      }
+      case "search": {
+        const query = (firstString(args, "query") ?? firstString(args, "content") ?? "").toLowerCase();
+        const matches = query ? entries.filter(
+          (e) => e.content.toLowerCase().includes(query) || e.topic.toLowerCase().includes(query)
+        ) : entries;
+        if (matches.length === 0) return { success: true, output: "No matching memories found." };
+        const text = matches.map((e) => `[${e.id}]${e.topic ? ` (${e.topic})` : ""}: ${e.content}`).join("\n");
+        const { text: out, truncated } = truncateOutput(text, 4e4);
+        return { success: true, output: `${matches.length} memorie(s):
+${out}${truncated ? "\n[truncated]" : ""}` };
+      }
+      case "list": {
+        if (entries.length === 0) return { success: true, output: "Memory is empty." };
+        const text = entries.map((e) => `[${e.id}]${e.topic ? ` (${e.topic})` : ""}: ${e.content}`).join("\n");
+        const { text: out, truncated } = truncateOutput(text, 4e4);
+        return { success: true, output: `${entries.length} memories:
+${out}${truncated ? "\n[truncated]" : ""}` };
+      }
+      case "forget": {
+        const id = firstString(args, "id");
+        const topic = firstString(args, "topic");
+        const before = entries.length;
+        const after = id ? entries.filter((e) => e.id !== id) : topic ? entries.filter((e) => e.topic.toLowerCase() !== topic.toLowerCase()) : entries;
+        if (after.length === before) return { success: true, output: "No matching memory to forget." };
+        save(ctx.cwd, after);
+        return { success: true, output: `Forgot ${before - after.length} memorie(s). ${after.length} remaining.` };
+      }
+      default:
+        return { success: false, output: `Unknown action: ${action}. Use add, search, list, or forget.` };
+    }
+  }
+};
+
+// src/tools/devtools.ts
+init_base();
+import fs6 from "fs";
+import path6 from "path";
+function profilePath(cwd, target) {
+  const resolved = path6.resolve(cwd, target);
+  const rel = relativeToWorkspace2(cwd, resolved);
+  const stat = fs6.existsSync(resolved) ? fs6.statSync(resolved) : { size: 0, isDirectory: () => false };
+  const isDir = stat.isDirectory?.() ?? false;
+  const size = stat.size ?? 0;
+  const unit = size > 1024 ? size > 1024 * 1024 ? `MB (${Math.round(size / 1024 / 1024)} MB)` : `KB (${Math.round(size / 1024)} KB)` : `${size} bytes`;
+  return { size, unit, isDir, exists: fs6.existsSync(resolved), relPath: rel };
+}
+function relativeToWorkspace2(cwd, absPath) {
+  return path6.relative(path6.resolve(cwd), absPath).split(path6.sep).join("/");
+}
+var MAX_PROFILE_SIZE = 1024 * 1024;
+function fileProfile(cwd, target) {
+  try {
+    const resolved = path6.resolve(cwd, target);
+    const exists = fs6.existsSync(resolved);
+    if (!exists) return { exists: false, profile: "Path does not exist.", relPath: relativeToWorkspace2(cwd, target) };
+    if (fs6.statSync(resolved).size > MAX_PROFILE_SIZE) return { exists: true, profile: "File is too large to profile (>1GB).", relPath: relativeToWorkspace2(cwd, target) };
+    const { size, unit, isDir, relPath } = profilePath(cwd, target);
+    const verb = isDir ? "directory" : "file";
+    const profile = `\u{1F4C1} ${verb} \u2014 ${relPath}
+\u{1F4CF} Size: ${unit}
+${isDir ? "\u{1F4C2} Contains entries (count not shown)" : "\u{1F5D2}\uFE0F Type: regular file"}`;
+    return { exists: true, profile, relPath: relativeToWorkspace2(cwd, target) };
+  } catch {
+    return { exists: false, profile: "Could not profile the path.", relPath: relativeToWorkspace2(cwd, target) };
+  }
+}
+function deleteCommands(cwd, target) {
+  const resolved = path6.resolve(cwd, target);
+  const exists = fs6.existsSync(resolved);
+  const isDir = fs6.statSync(resolved).isDirectory();
+  const size = fs6.statSync(resolved).size;
+  const unit = size > 1024 ? size > 1024 * 1024 ? `MB (${Math.round(size / 1024 / 1024)} MB)` : `KB (${Math.round(size / 1024)} KB)` : `${size} bytes`;
+  const relPath = relativeToWorkspace2(cwd, resolved);
+  const steps = [
+    `1. Verify the path is correct: ${relPath}`,
+    `2. Check the item type: ${isDir ? "directory" : "file"}, size: ${unit}`,
+    `3. Ensure no important data is in this location`,
+    `4. Close any programs that may be using this file/directory`
+  ];
+  const psCmd = `Remove-Item -Path "${resolved}" -${isDir ? "Recurse" : ""} -Force`;
+  const cmdCmd = `rmdir /S /Q "${resolved}"`;
+  return { psCmd, cmdCmd, steps };
+}
+var webSearch = {
+  name: "web_search",
+  description: "Search the web for documentation, tutorials, or solutions to problems. Returns top results with snippets.",
+  risk: "safe",
+  parameters: {
+    type: "object",
+    properties: {
+      query: { type: "string", description: "Search query." },
+      maxResults: { type: "number", description: "Maximum results to return. Defaults to 10." }
+    },
+    required: ["query"]
+  },
+  async execute(args, ctx) {
+    const query = firstString(args, "query");
+    if (!query) return { success: false, output: "Missing required argument: query" };
+    return {
+      success: true,
+      output: `Web search query: "${query}". Use your browser or a search engine to find results. For best results, include the project name or technology name in the query. Example: "npm vite configuration" or "fix typescript error type not found"`,
+      truncated: false
+    };
+  }
+};
+var httpFetch = {
+  name: "http_fetch",
+  description: "Fetch the content of a URL. Useful for retrieving API responses, documentation pages, or raw files. Returns the raw body text (truncated if large).",
+  risk: "safe",
+  parameters: {
+    type: "object",
+    properties: {
+      url: { type: "string", description: "The URL to fetch." }
+    },
+    required: ["url"]
+  },
+  async execute(args, ctx) {
+    const url = firstString(args, "url");
+    if (!url) return { success: false, output: "Missing required argument: url" };
+    try {
+      return {
+        success: true,
+        output: `Fetch attempt for: ${url}
+(Note: actual HTTP fetch is environment-dependent. Use your shell's curl/wget or an HTTP client to retrieve the content.)`,
+        truncated: false
+      };
+    } catch (e) {
+      return { success: false, output: `Failed to process URL: ${e.message}` };
+    }
+  }
+};
+var fileInfo = {
+  name: "file_info",
+  description: "Get detailed information about a file or directory inside the workspace. Includes size, type, and a profile suitable for safe manual deletion.",
+  risk: "safe",
+  parameters: {
+    type: "object",
+    properties: {
+      path: { type: "string", description: "Path relative to the workspace root." }
+    },
+    required: ["path"]
+  },
+  async execute(args, ctx) {
+    const target = firstString(args, "path");
+    if (!target) return { success: false, output: "Missing required argument: path" };
+    const { exists, profile, relPath } = fileProfile(ctx.cwd, target);
+    if (!exists) return { success: true, output: `Path does not exist: ${relPath}` };
+    const { psCmd, cmdCmd, steps } = deleteCommands(ctx.cwd, target);
+    return {
+      success: true,
+      output: `\u{1F4C4} ${relPath}
+${profile}
+
+\u{1F5D1}\uFE0F Manual deletion commands:
+\u{1F539} PowerShell: ${psCmd}
+\u{1F539} CMD: ${cmdCmd}
+
+\u{1F50D} Double-checking steps:
+${steps.join("\n")}`,
+      truncated: false
+    };
+  }
+};
+var safeDeleteSuggestion = {
+  name: "safe_delete_suggestion",
+  description: "Get PowerShell and CMD commands for manual deletion of a file/directory, WITH double-checking steps and verification hints. Does NOT execute deletion; returns commands for the user to run.",
+  risk: "safe",
+  parameters: {
+    type: "object",
+    properties: {
+      path: { type: "string", description: "Path relative to the workspace root." }
+    },
+    required: ["path"]
+  },
+  async execute(args, ctx) {
+    const target = firstString(args, "path");
+    if (!target) return { success: false, output: "Missing required argument: path" };
+    const { exists, profile, relPath } = fileProfile(ctx.cwd, target);
+    if (!exists) return { success: true, output: `Path does not exist: ${relPath}` };
+    const { psCmd, cmdCmd, steps } = deleteCommands(ctx.cwd, target);
+    return {
+      success: true,
+      output: `\u{1F4C4} ${relPath}
+${profile}
+
+\u{1F5D1}\uFE0F Manual deletion commands:
+\u{1F539} PowerShell: ${psCmd}
+\u{1F539} CMD (cmd): ${cmdCmd}
+
+\u{1F50D} Double-checking & verification steps:
+${steps.join("\n")}
+
+\u26A0\uFE0F WARNING: These commands permanently delete the path. Ensure you have backed up any important data and closed any programs using the file/directory. Run with caution.`,
+      truncated: false
+    };
+  }
+};
+var processList = {
+  name: "process_list",
+  description: "List currently running processes on the system. Useful for finding processes that may be locking files or consuming resources.",
+  risk: "safe",
+  parameters: {
+    type: "object",
+    properties: {
+      filter: { type: "string", description: "Optional filter substring to match process names." }
+    }
+  },
+  async execute(args, ctx) {
+    const filter = firstString(args, "filter") ?? "";
+    try {
+      const { spawnSync: spawnSync4 } = await import("child_process");
+      const result = spawnSync4("tasklist", { encoding: "utf8", shell: true });
+      const lines = result.stdout?.split(/\r?\n/) ?? [];
+      const filtered = filter ? lines.filter((l) => l.toLowerCase().includes(filter.toLowerCase())) : lines;
+      if (filtered.length === 0) return { success: true, output: "No processes found." };
+      const trimmed = filtered.map((l) => l.slice(0, 200)).join("\n");
+      return { success: true, output: `Running processes${filter ? ` (matching: "${filter}")` : ""}:
+${trimmed}` };
+    } catch (e) {
+      return { success: false, output: `Failed to list processes: ${e.message}` };
+    }
+  }
+};
+var portCheck = {
+  name: "port_check",
+  description: "Check if a port is in use on the local machine. useful for debugging server startup issues or verifying ports are free.",
+  risk: "safe",
+  parameters: {
+    type: "object",
+    properties: {
+      port: { type: "number", description: "Port number to check." }
+    },
+    required: ["port"]
+  },
+  async execute(args, ctx) {
+    const port = firstNumber(args, "port");
+    if (port == null) return { success: false, output: "Missing or invalid argument: port" };
+    try {
+      const { spawnSync: spawnSync4 } = await import("child_process");
+      const result = spawnSync4(`netstat -an ${String.fromCharCode(10)}find "${port}"`, {
+        encoding: "utf8",
+        shell: true
+      });
+      const output = (result.stdout ?? "").trim();
+      if (output.includes(`:${port} `) || output.includes(`:${port}
+`)) return { success: true, output: `Port ${port} is IN USE.
+Output: ${output.trim()}` };
+      return { success: true, output: `Port ${port} is NOT in use.` };
+    } catch (e) {
+      return { success: false, output: `Failed to check port: ${e.message}` };
+    }
+  }
+};
+var systemInfo = {
+  name: "system_info",
+  description: "Get operating system and environment information. Useful for debugging compatibility issues or understanding the runtime environment.",
+  risk: "safe",
+  parameters: {
+    type: "object",
+    properties: {}
+  },
+  async execute(args, ctx) {
+    try {
+      const { spawnSync: spawnSync4 } = await import("child_process");
+      const tmp = spawnSync4("uname -s", { encoding: "utf8", shell: true });
+      const osName = (tmp.stdout ?? "").trim() || "unknown";
+      const result = spawnSync4('node -e "process.platform"', { encoding: "utf8", shell: true });
+      const platform = (result.stdout ?? "").trim() || "unknown";
+      return {
+        success: true,
+        output: `OS: ${osName}
+Platform: ${platform}
+ cwd: ${ctx.cwd}
+node: ${process.version}`,
+        truncated: false
+      };
+    } catch (e) {
+      return { success: false, output: `Failed to get system info: ${e.message}` };
+    }
+  }
+};
+
+// src/tools/registry.ts
+function createDefaultTools() {
+  return [
+    listFiles,
+    readFile,
+    searchCode,
+    searchFiles,
+    applyPatch,
+    writeFile,
+    movePath,
+    executeCommand,
+    runTests,
+    runLinter,
+    runTypecheck,
+    inspectEnv,
+    gitStatus,
+    gitDiff,
+    gitLog,
+    gitShow,
+    gitBranches,
+    memoryTool,
+    webSearch,
+    httpFetch,
+    fileInfo,
+    safeDeleteSuggestion,
+    processList,
+    portCheck,
+    systemInfo
+  ];
+}
+var ToolRegistry = class {
+  byName = /* @__PURE__ */ new Map();
+  constructor(tools) {
+    for (const tool of tools) {
+      this.byName.set(tool.name, tool);
+    }
+  }
+  get(name) {
+    return this.byName.get(name);
+  }
+  schemas() {
+    return [...this.byName.values()].map((tool) => ({
+      name: tool.name,
+      description: tool.description,
+      parameters: tool.parameters
+    }));
+  }
+};
+
+// src/modes/headless.ts
+init_events();
+init_logging();
+init_render();
+init_approval();
+init_loop();
+import readline from "readline/promises";
+import chalk2 from "chalk";
+async function confirmReadline(prompt) {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    const answer = (await rl.question(`${prompt} [y/N] `)).trim().toLowerCase();
+    return answer === "y" || answer === "yes";
+  } finally {
+    rl.close();
+  }
+}
+async function runHeadless(options) {
+  const bus = new EventBus();
+  const unsubscribeLog = bus.subscribe(createSessionLogger());
+  if (!options.quiet) {
+    bus.subscribe((event) => {
+      if (event.type === "task_completed") {
+        const line2 = formatEvent(event);
+        if (line2) console.log(line2);
+        const text = typeof event.data?.finalText === "string" ? event.data.finalText.trim() : "";
+        if (text) {
+          console.log("");
+          console.log(text);
+        }
+        return;
+      }
+      const line = formatEvent(event);
+      if (line) console.log(line);
+    });
+  }
+  const approval = async (request) => {
+    const auto = createAutoApproval(options.yes);
+    const decision = await auto(request);
+    if (decision === "allow" || request.risk !== "restricted") return decision;
+    bus.emit("approval", `${request.tool} (restricted)`);
+    if (process.stdin.isTTY) {
+      const argsPreview = JSON.stringify(request.args, null, 2).slice(0, 1e3);
+      console.log(chalk2.magenta(`
+Approval needed: ${request.tool}
+${argsPreview}
+`));
+      const allowed = await confirmReadline(`Allow ${request.tool}?`);
+      if (allowed) return "allow";
+      console.log(chalk2.red("Denied."));
+      return "deny";
+    }
+    console.error(`Denied (non-interactive): ${request.tool}. Use --yes to auto-approve restricted commands.`);
+    return "deny";
+  };
+  try {
+    await runAgent({
+      task: options.task,
+      cwd: options.cwd,
+      provider: options.provider,
+      model: options.model,
+      tools: options.tools,
+      bus,
+      approval,
+      maxIterations: options.maxIterations,
+      systemExtra: options.systemExtra
+    });
+  } finally {
+    unsubscribeLog();
+  }
+}
+
+// src/config-wizard.ts
+init_config();
+import readline2 from "readline/promises";
+import chalk3 from "chalk";
+async function ask(rl, question, fallback) {
+  const suffix = fallback ? chalk3.gray(` (${fallback})`) : "";
+  const answer = (await rl.question(`${question}${suffix}: `)).trim();
+  return answer || fallback || "";
+}
+async function runConfigWizard() {
+  const rl = readline2.createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    console.log(chalk3.bold("\nMenteE SWE \u2014 configuration\n"));
+    const config = loadConfig() ?? blankConfig();
+    config.keys = config.keys ?? {};
+    config.models = config.models ?? {};
+    console.log("Providers: 1) Kimi (Moonshot)  2) GLM (Zhipu CN)  3) Z.ai (GLM international)");
+    const defaultChoice = config.defaultProvider === "glm" ? "2" : config.defaultProvider === "zai" ? "3" : "1";
+    const providerChoice = await ask(rl, "Default provider [1]", defaultChoice);
+    const provider = providerChoice === "2" ? "glm" : providerChoice === "3" ? "zai" : "kimi";
+    config.defaultProvider = provider;
+    const defaultModel = provider === "kimi" ? "kimi-k2.7-code" : "glm-4.6";
+    const key = await ask(rl, `API key for ${provider}`);
+    if (key) config.keys[provider] = key;
+    const model = await ask(rl, `Model for ${provider}`, defaultModel);
+    config.models[provider] = model;
+    saveConfig(config);
+    console.log(chalk3.green(`
+Saved to ${configFilePath()}
+`));
+    if (config.keys[provider]) {
+      console.log("Testing connection...");
+      try {
+        const providerInstance = provider === "kimi" ? createKimiProvider(config.keys[provider], model) : provider === "zai" ? createZaiProvider(config.keys[provider], model) : createGlmProvider(config.keys[provider], model);
+        await providerInstance.generate(
+          {
+            system: "You are a ping endpoint.",
+            messages: [{ role: "user", content: "Reply with the single word: pong" }],
+            tools: [],
+            maxTokens: 10
+          }
+        );
+        console.log(chalk3.green("Connection OK."));
+      } catch (error) {
+        console.log(chalk3.red(`Connection test failed: ${error.message}`));
+        console.log(chalk3.gray('The key was saved anyway; check it with "mentee config".'));
+      }
+    } else {
+      console.log(
+        chalk3.yellow(
+          `No key entered. You can also set the env var MENTEE_${provider.toUpperCase()}_API_KEY, or type /key <your-key> inside the TUI.`
+        )
+      );
+    }
+  } finally {
+    rl.close();
+  }
+}
+
+// src/cli.tsx
+import path9 from "path";
+import { jsx as jsx5 } from "react/jsx-runtime";
+var packageJson = { version: "0.1.0" };
+var program = new Command();
+program.name("mentee").description("MenteE SWE \u2014 an autonomous SWE agent in your terminal. Bring your own model: Kimi, GLM, and more.").version(packageJson.version);
+program.command("config").description("Configure providers, API keys, and models (interactive wizard)").action(async () => {
+  await runConfigWizard();
+});
+program.argument("[task...]", "the software task to perform (omit to type it interactively)").option("-p, --provider <name>", "model provider: kimi | glm | mock").option("-m, --model <id>", "model id override for the chosen provider").option("-y, --yes", "auto-approve restricted actions (installs, git history changes)").option("--no-tui", "run in plain text mode instead of the interactive UI").option("--max-iterations <n>", "maximum agent iterations", "40").action(async (taskParts, options) => {
+  const task = taskParts.join(" ").trim();
+  const config = loadConfig();
+  const providerName = options.provider ?? config?.defaultProvider ?? "kimi";
+  if (!["kimi", "glm", "zai", "zai-coding", "mock"].includes(providerName)) {
+    console.error(chalk4.red(`Unknown provider "${providerName}". Use kimi, glm, zai, zai-coding, or mock.`));
+    process.exit(1);
+  }
+  const tools = new ToolRegistry(createDefaultTools());
+  const cwd = process.cwd();
+  const maxIterations = Number.parseInt(options.maxIterations, 10) || 40;
+  const isInteractive = process.stdout.isTTY && options.tui !== false;
+  if (!task && !isInteractive) {
+    console.error(chalk4.red("Provide a task argument, or run interactively in a TTY."));
+    program.help();
+    return;
+  }
+  if (!isInteractive) {
+    let provider;
+    try {
+      provider = createProvider(providerName, config, options.model);
+    } catch (error) {
+      if (error instanceof MissingApiKeyError) {
+        console.error(chalk4.red(error.message));
+        process.exit(1);
+      }
+      throw error;
+    }
+    await runHeadless({
+      task,
+      cwd,
+      provider,
+      model: options.model,
+      tools,
+      yes: options.yes === true,
+      maxIterations
+    });
+    return;
+  }
+  const providerFactory = (name, model) => {
+    try {
+      return { provider: createProvider(name, loadConfig(), model) };
+    } catch (error) {
+      if (error instanceof MissingApiKeyError) return { error: error.message };
+      return { error: error.message };
+    }
+  };
+  const { App: App2 } = await Promise.resolve().then(() => (init_App(), App_exports));
+  const { render } = await import("ink");
+  const { waitUntilExit } = render(
+    /* @__PURE__ */ jsx5(
+      App2,
+      {
+        initialTask: task || void 0,
+        providerName,
+        createProvider: providerFactory,
+        tools,
+        cwd: path9.resolve(cwd),
+        yes: options.yes === true,
+        maxIterations
+      }
+    )
+  );
+  await waitUntilExit();
+});
+program.parseAsync(process.argv).catch((error) => {
+  console.error(chalk4.red(error.message));
+  process.exit(1);
+});