workermill 0.1.0

package/dist/index.js

@@ -0,0 +1,971 @@
+#!/usr/bin/env node
+import {
+  exitTerminal,
+  initTerminal,
+  setStatusBar,
+  showStatusBar
+} from "./chunk-LVCJZJJH.js";
+import {
+  CostTracker,
+  PermissionManager,
+  createModel,
+  createToolDefinitions,
+  getProviderForPersona,
+  killActiveProcess,
+  loadConfig,
+  printError,
+  printHeader,
+  printStatusBar,
+  printToolCall,
+  printToolResult,
+  saveConfig
+} from "./chunk-3KIFXIBC.js";
+import "./chunk-2NTK7H4W.js";
+
+// src/index.ts
+import { Command } from "commander";
+
+// src/setup.js
+import readline from "readline";
+import { execSync } from "child_process";
+import chalk from "chalk";
+var PROVIDERS = [
+  { name: "ollama", display: "Ollama (local, no API key needed)", needsKey: false, defaultModel: "qwen3-coder:30b" },
+  { name: "anthropic", display: "Anthropic (Claude)", needsKey: true, defaultModel: "claude-sonnet-4-6", envVar: "ANTHROPIC_API_KEY" },
+  { name: "openai", display: "OpenAI (GPT)", needsKey: true, defaultModel: "gpt-4o", envVar: "OPENAI_API_KEY" },
+  { name: "google", display: "Google (Gemini)", needsKey: true, defaultModel: "gemini-2.5-pro", envVar: "GOOGLE_API_KEY" }
+];
+function ask(rl, question) {
+  return new Promise((resolve) => rl.question(question, resolve));
+}
+async function runSetup() {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  console.log();
+  console.log(chalk.bold("  WorkerMill CLI") + chalk.dim(" \u2014 AI coding agent"));
+  console.log();
+  console.log(chalk.dim("  No provider configured. Let's set one up."));
+  console.log();
+  console.log("  Provider:");
+  PROVIDERS.forEach((p, i) => {
+    console.log(`    ${chalk.cyan(`${i + 1}`)}. ${p.display}`);
+  });
+  console.log();
+  const choiceStr = await ask(rl, chalk.dim("  Choose (1-4): "));
+  const choice = parseInt(choiceStr.trim(), 10) - 1;
+  const selected = PROVIDERS[choice] || PROVIDERS[0];
+  console.log();
+  console.log(chalk.dim(`  Selected: ${selected.display}`));
+  const providerConfig = { model: selected.defaultModel };
+  if (selected.needsKey) {
+    const envValue = selected.envVar ? process.env[selected.envVar] : void 0;
+    if (envValue) {
+      console.log(chalk.green(`  \u2713 Found ${selected.envVar} in environment`));
+      providerConfig.apiKey = `{env:${selected.envVar}}`;
+    } else {
+      const key = await ask(rl, chalk.dim(`  API key: `));
+      providerConfig.apiKey = key.trim();
+    }
+  }
+  if (selected.name === "ollama") {
+    const hostsToTry = ["http://localhost:11434"];
+    try {
+      const gateway = execSync("ip route show default 2>/dev/null | awk '{print $3}'", { encoding: "utf-8" }).trim();
+      if (gateway) {
+        hostsToTry.push(`http://${gateway}:11434`);
+      }
+    } catch {
+    }
+    if (process.env.OLLAMA_HOST) {
+      const envHost = process.env.OLLAMA_HOST.startsWith("http") ? process.env.OLLAMA_HOST : `http://${process.env.OLLAMA_HOST}`;
+      hostsToTry.unshift(envHost);
+    }
+    let connectedHost = null;
+    let models = [];
+    for (const host of hostsToTry) {
+      try {
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), 3e3);
+        const response = await globalThis.fetch(`${host}/api/tags`, { signal: controller.signal });
+        clearTimeout(timeout);
+        if (response.ok) {
+          const data = await response.json();
+          connectedHost = host;
+          models = data.models || [];
+          break;
+        }
+      } catch {
+        continue;
+      }
+    }
+    if (connectedHost) {
+      providerConfig.host = connectedHost;
+      console.log(chalk.green(`  \u2713 Connected to Ollama at ${connectedHost}`));
+      if (models.length > 0) {
+        console.log(chalk.dim(`  Available models: ${models.map((m) => m.name).join(", ")}`));
+      }
+    } else {
+      providerConfig.host = "http://localhost:11434";
+      console.log(chalk.yellow("  \u26A0 Could not connect to Ollama. Make sure it's running."));
+      console.log(chalk.dim("    Tried: " + hostsToTry.join(", ")));
+    }
+  }
+  console.log();
+  const modelOverride = await ask(rl, chalk.dim(`  Model (press Enter for ${selected.defaultModel}): `));
+  if (modelOverride.trim()) {
+    providerConfig.model = modelOverride.trim();
+  }
+  rl.close();
+  const config = {
+    providers: { [selected.name]: providerConfig },
+    default: selected.name
+  };
+  saveConfig(config);
+  console.log();
+  console.log(chalk.green("  \u2713 Config saved to ~/.workermill/cli.json"));
+  console.log();
+  return config;
+}
+
+// src/agent.js
+import readline2 from "readline";
+import fs4 from "fs";
+import pathModule from "path";
+import chalk3 from "chalk";
+import ora2 from "ora";
+import { execSync as execSync3 } from "child_process";
+import { streamText, stepCountIs } from "ai";
+
+// src/commands.js
+import chalk2 from "chalk";
+import ora from "ora";
+import fs2 from "fs";
+import os from "os";
+import path2 from "path";
+import { execSync as execSync2 } from "child_process";
+
+// src/compaction.js
+import { generateText } from "ai";
+var CONTEXT_LIMITS = {
+  // Anthropic
+  "claude-opus": 2e5,
+  "claude-sonnet": 2e5,
+  "claude-haiku": 2e5,
+  // OpenAI
+  "gpt-4o": 128e3,
+  "gpt-4o-mini": 128e3,
+  "o3": 2e5,
+  "o3-mini": 128e3,
+  // Google
+  "gemini-2.5-pro": 1e6,
+  "gemini-2.5-flash": 1e6,
+  // Ollama (conservative default)
+  "default": 32e3
+};
+function getContextLimit(model) {
+  for (const [prefix, limit] of Object.entries(CONTEXT_LIMITS)) {
+    if (model.includes(prefix))
+      return limit;
+  }
+  return CONTEXT_LIMITS["default"];
+}
+function shouldCompact(totalTokens, model) {
+  const limit = getContextLimit(model);
+  if (totalTokens >= limit * 0.95)
+    return "hard";
+  if (totalTokens >= limit * 0.8)
+    return "soft";
+  return "none";
+}
+async function compactMessages(model, messages, mode) {
+  if (messages.length <= 4)
+    return messages;
+  const keepCount = mode === "hard" ? 2 : 4;
+  const toCompact = messages.slice(0, -keepCount);
+  const toKeep = messages.slice(-keepCount);
+  if (toCompact.length === 0)
+    return messages;
+  const summaryText = toCompact.map((m) => `${m.role}: ${m.content.slice(0, 500)}`).join("\n\n");
+  try {
+    const result = await generateText({
+      model,
+      system: "Summarize this conversation history concisely. Focus on: what was discussed, what decisions were made, what files were modified, and what the current state of work is. Be brief but preserve all important context.",
+      prompt: summaryText
+    });
+    return [
+      { role: "assistant", content: `[Conversation summary]
+${result.text}` },
+      ...toKeep
+    ];
+  } catch {
+    return toKeep;
+  }
+}
+
+// src/session.js
+import fs from "fs";
+import path from "path";
+import crypto from "crypto";
+var SESSIONS_DIR = path.join(process.cwd(), ".workermill", "sessions");
+function ensureSessionsDir() {
+  if (!fs.existsSync(SESSIONS_DIR)) {
+    fs.mkdirSync(SESSIONS_DIR, { recursive: true });
+  }
+}
+function createSession(provider, model) {
+  return {
+    id: crypto.randomUUID(),
+    messages: [],
+    provider,
+    model,
+    startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    totalTokens: 0
+  };
+}
+function saveSession(session) {
+  ensureSessionsDir();
+  const filePath = path.join(SESSIONS_DIR, `${session.id}.json`);
+  fs.writeFileSync(filePath, JSON.stringify(session, null, 2), "utf-8");
+}
+function loadLatestSession() {
+  ensureSessionsDir();
+  try {
+    const files = fs.readdirSync(SESSIONS_DIR).filter((f) => f.endsWith(".json")).map((f) => ({
+      name: f,
+      mtime: fs.statSync(path.join(SESSIONS_DIR, f)).mtimeMs
+    })).sort((a, b) => b.mtime - a.mtime);
+    if (files.length === 0)
+      return null;
+    const content = fs.readFileSync(path.join(SESSIONS_DIR, files[0].name), "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+function addMessage(session, role, content) {
+  session.messages.push({
+    role,
+    content,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  });
+}
+function listSessions(max = 20) {
+  ensureSessionsDir();
+  try {
+    const files = fs.readdirSync(SESSIONS_DIR).filter((f) => f.endsWith(".json")).map((f) => ({
+      name: f,
+      mtime: fs.statSync(path.join(SESSIONS_DIR, f)).mtimeMs
+    })).sort((a, b) => b.mtime - a.mtime).slice(0, max);
+    return files.map((f) => {
+      const content = JSON.parse(fs.readFileSync(path.join(SESSIONS_DIR, f.name), "utf-8"));
+      const firstUserMsg = content.messages.find((m) => m.role === "user");
+      return {
+        id: content.id,
+        name: content.name,
+        startedAt: content.startedAt,
+        messageCount: content.messages.length,
+        totalTokens: content.totalTokens,
+        preview: firstUserMsg ? firstUserMsg.content.slice(0, 50) : "(empty)"
+      };
+    });
+  } catch {
+    return [];
+  }
+}
+function loadSessionById(id) {
+  ensureSessionsDir();
+  try {
+    const filePath = path.join(SESSIONS_DIR, `${id}.json`);
+    if (fs.existsSync(filePath)) {
+      return JSON.parse(fs.readFileSync(filePath, "utf-8"));
+    }
+    const files = fs.readdirSync(SESSIONS_DIR).filter((f) => f.startsWith(id));
+    if (files.length === 1) {
+      return JSON.parse(fs.readFileSync(path.join(SESSIONS_DIR, files[0]), "utf-8"));
+    }
+  } catch {
+  }
+  return null;
+}
+function deleteSession(id) {
+  ensureSessionsDir();
+  try {
+    const filePath = path.join(SESSIONS_DIR, `${id}.json`);
+    if (fs.existsSync(filePath)) {
+      fs.unlinkSync(filePath);
+      return true;
+    }
+  } catch {
+  }
+  return false;
+}
+
+// src/commands.js
+async function handleCommand(cmd, ctx) {
+  const parts = cmd.slice(1).split(" ");
+  const command = parts[0];
+  switch (command) {
+    case "help":
+      console.log();
+      console.log(chalk2.bold("  Commands:"));
+      console.log(chalk2.dim("  /help      ") + "Show this help");
+      console.log(chalk2.dim("  /clear     ") + "Clear conversation history");
+      console.log(chalk2.dim("  /compact   ") + "Manually compact conversation");
+      console.log(chalk2.dim("  /status    ") + "Show session status");
+      console.log(chalk2.dim("  /model     ") + "Show current model");
+      console.log(chalk2.dim("  /cost      ") + "Show token cost breakdown");
+      console.log(chalk2.dim("  /git       ") + "Show git status");
+      console.log(chalk2.dim("  /sessions  ") + "List/switch sessions");
+      console.log(chalk2.dim("  /editor    ") + "Open $EDITOR for input");
+      console.log(chalk2.dim("  /plan      ") + "Toggle plan mode (read-only)");
+      console.log(chalk2.dim("  /quit      ") + "Exit");
+      console.log();
+      console.log(chalk2.dim("  Prefix ! for bash: ") + chalk2.white("!git status"));
+      console.log(chalk2.dim("  Multiline: ``` to start/end, or \\ at end of line"));
+      console.log();
+      break;
+    case "clear":
+      ctx.session.messages = [];
+      saveSession(ctx.session);
+      console.log(chalk2.green("\n  Conversation cleared\n"));
+      break;
+    case "compact": {
+      const { provider, model: modelName, host } = getProviderForPersona(ctx.config);
+      const model = createModel(provider, modelName, host);
+      const plainMessages = ctx.session.messages.map((m) => ({ role: m.role, content: m.content }));
+      if (plainMessages.length <= 4) {
+        console.log(chalk2.dim("\n  Not enough messages to compact.\n"));
+        break;
+      }
+      const spinner = ora({ stream: process.stdout, text: "Compacting conversation...", prefixText: "  " }).start();
+      const compacted = await compactMessages(model, plainMessages, "soft");
+      ctx.session.messages = compacted.map((m) => ({
+        role: m.role,
+        content: m.content,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      }));
+      saveSession(ctx.session);
+      spinner.succeed(`Compacted to ${ctx.session.messages.length} messages`);
+      console.log();
+      break;
+    }
+    case "status":
+      console.log();
+      console.log(chalk2.bold("  Session Status:"));
+      console.log(chalk2.dim("  Messages: ") + ctx.session.messages.length);
+      console.log(chalk2.dim("  Tokens: ") + ctx.session.totalTokens.toLocaleString());
+      console.log(chalk2.dim("  Cost: ") + `$${ctx.costTracker.getTotalCost().toFixed(4)}`);
+      console.log(chalk2.dim("  Mode: ") + (ctx.planMode ? chalk2.cyan("PLAN (read-only)") : "normal"));
+      console.log();
+      break;
+    case "model": {
+      const { provider, model } = getProviderForPersona(ctx.config);
+      console.log(chalk2.dim(`
+  ${provider}/${model}
+`));
+      break;
+    }
+    case "cost":
+      console.log(chalk2.dim(`
+  ${ctx.costTracker.getSummary()}
+`));
+      break;
+    case "git": {
+      try {
+        const status = execSync2("git status --short", { cwd: ctx.workingDir, encoding: "utf-8" });
+        const branch = execSync2("git branch --show-current", { cwd: ctx.workingDir, encoding: "utf-8" }).trim();
+        console.log(chalk2.dim(`
+  Branch: `) + chalk2.white(branch));
+        if (status.trim()) {
+          console.log(chalk2.dim("  Changes:"));
+          for (const line of status.trim().split("\n").slice(0, 15)) {
+            console.log(chalk2.dim(`    ${line}`));
+          }
+        } else {
+          console.log(chalk2.dim("  Working tree clean"));
+        }
+        console.log();
+      } catch {
+        console.log(chalk2.dim("\n  Not a git repository.\n"));
+      }
+      break;
+    }
+    case "sessions": {
+      const args = parts.slice(1).join(" ").trim();
+      if (args.startsWith("delete ")) {
+        const deleteId = args.slice(7).trim();
+        if (deleteSession(deleteId)) {
+          console.log(chalk2.green(`
+  Session ${deleteId.slice(0, 8)} deleted.
+`));
+        } else {
+          console.log(chalk2.red(`
+  Session not found: ${deleteId}
+`));
+        }
+        break;
+      }
+      if (args) {
+        const targetId = args;
+        let loaded = loadSessionById(targetId);
+        if (!loaded) {
+          const sessions2 = listSessions();
+          const idx = parseInt(targetId, 10) - 1;
+          if (idx >= 0 && idx < sessions2.length) {
+            loaded = loadSessionById(sessions2[idx].id);
+          }
+        }
+        if (loaded) {
+          Object.assign(ctx.session, loaded);
+          console.log(chalk2.green(`
+  Switched to session ${loaded.id.slice(0, 8)} (${loaded.messages.length} messages)
+`));
+        } else {
+          console.log(chalk2.red(`
+  Session not found: ${targetId}
+`));
+        }
+        break;
+      }
+      const sessions = listSessions();
+      if (sessions.length === 0) {
+        console.log(chalk2.dim("\n  No saved sessions.\n"));
+        break;
+      }
+      console.log(chalk2.bold("\n  Recent Sessions:"));
+      sessions.forEach((s, i) => {
+        const date = new Date(s.startedAt).toLocaleDateString();
+        const current = s.id === ctx.session.id ? chalk2.green(" <- current") : "";
+        console.log(chalk2.dim(`  ${i + 1}. `) + chalk2.white(`${s.name || s.preview}`) + chalk2.dim(` (${s.messageCount} msgs, ${date})`) + current);
+      });
+      console.log(chalk2.dim(`
+  Use /sessions <n> to switch, /sessions delete <id> to delete.
+`));
+      break;
+    }
+    case "editor": {
+      const editor = process.env.EDITOR || process.env.VISUAL || "vi";
+      const tmpFile = path2.join(os.tmpdir(), `workermill-${Date.now()}.md`);
+      fs2.writeFileSync(tmpFile, "", "utf-8");
+      try {
+        execSync2(`${editor} ${tmpFile}`, { stdio: "inherit" });
+        const content = fs2.readFileSync(tmpFile, "utf-8").trim();
+        fs2.unlinkSync(tmpFile);
+        if (content) {
+          ctx.processInput(content);
+        } else {
+          console.log(chalk2.dim("\n  Empty input, cancelled.\n"));
+        }
+      } catch {
+        console.log(chalk2.red("\n  Editor failed.\n"));
+      }
+      break;
+    }
+    case "plan": {
+      const arg = parts[1];
+      if (arg === "off" || ctx.planMode) {
+        ctx.setPlanMode(false);
+        console.log(chalk2.green("\n  Plan mode off. Full tools available.\n"));
+      } else {
+        ctx.setPlanMode(true);
+        console.log(chalk2.cyan("\n  [PLAN MODE] Read-only tools only. Use /plan off to exit.\n"));
+      }
+      break;
+    }
+    case "quit":
+    case "exit": {
+      const { exitTerminal: exitTerminal2 } = await import("./terminal-ILMO7Z3P.js");
+      exitTerminal2();
+      console.log(chalk2.dim("  Goodbye!"));
+      process.exit(0);
+      break;
+    }
+    default:
+      console.log(chalk2.yellow(`
+  Unknown command: /${command}. Type /help for available commands.
+`));
+  }
+}
+
+// src/logger.js
+import fs3 from "fs";
+import path3 from "path";
+var LOG_DIR = path3.join(process.cwd(), ".workermill");
+var LOG_FILE = path3.join(LOG_DIR, "cli.log");
+var logStream = null;
+function ensureLogDir() {
+  if (!fs3.existsSync(LOG_DIR)) {
+    fs3.mkdirSync(LOG_DIR, { recursive: true });
+  }
+}
+function getStream() {
+  if (!logStream) {
+    ensureLogDir();
+    logStream = fs3.createWriteStream(LOG_FILE, { flags: "a" });
+  }
+  return logStream;
+}
+function timestamp() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function log(level, message, data) {
+  const entry = data ? `[${timestamp()}] ${level}: ${message} ${JSON.stringify(data)}` : `[${timestamp()}] ${level}: ${message}`;
+  getStream().write(entry + "\n");
+}
+function info(message, data) {
+  log("INFO", message, data);
+}
+function error(message, data) {
+  log("ERROR", message, data);
+}
+function debug(message, data) {
+  log("DEBUG", message, data);
+}
+function flush() {
+  if (logStream) {
+    logStream.end();
+    logStream = null;
+  }
+}
+
+// src/agent.js
+var HISTORY_FILE = pathModule.join(process.env.HOME || "~", ".workermill", "history");
+var MAX_HISTORY = 1e3;
+function loadHistory() {
+  try {
+    if (fs4.existsSync(HISTORY_FILE)) {
+      const lines = fs4.readFileSync(HISTORY_FILE, "utf-8").split("\n").filter(Boolean);
+      return lines.slice(-MAX_HISTORY);
+    }
+  } catch {
+  }
+  return [];
+}
+function appendHistory(line) {
+  try {
+    const dir = pathModule.dirname(HISTORY_FILE);
+    if (!fs4.existsSync(dir))
+      fs4.mkdirSync(dir, { recursive: true });
+    fs4.appendFileSync(HISTORY_FILE, line + "\n", "utf-8");
+  } catch {
+  }
+}
+var SLASH_COMMANDS = [
+  "/help",
+  "/clear",
+  "/compact",
+  "/status",
+  "/model",
+  "/quit",
+  "/cost",
+  "/git",
+  "/editor",
+  "/plan",
+  "/sessions",
+  "/exit"
+];
+function completer(line) {
+  if (line.startsWith("/")) {
+    const hits = SLASH_COMMANDS.filter((c) => c.startsWith(line));
+    return [hits.length ? hits : SLASH_COMMANDS, line];
+  }
+  return [[], line];
+}
+async function runAgent(config, trustAll, resume, startInPlanMode, fullDisk) {
+  const { provider, model: modelName, apiKey, host } = getProviderForPersona(config);
+  if (apiKey) {
+    const envMap = {
+      anthropic: "ANTHROPIC_API_KEY",
+      openai: "OPENAI_API_KEY",
+      google: "GOOGLE_API_KEY"
+    };
+    const envVar = envMap[provider];
+    if (envVar && !process.env[envVar]) {
+      process.env[envVar] = apiKey;
+    }
+  }
+  const aiProvider = provider;
+  const model = createModel(aiProvider, modelName, host);
+  const workingDir = process.cwd();
+  const sandboxed = !fullDisk;
+  const tools = createToolDefinitions(workingDir, model, sandboxed);
+  const permissions = new PermissionManager(trustAll);
+  let session;
+  if (resume) {
+    const loaded = loadLatestSession();
+    if (loaded) {
+      session = loaded;
+      console.log(chalk3.green(`  Resumed session ${session.id.slice(0, 8)}... (${session.messages.length} messages)
+`));
+    } else {
+      session = createSession(provider, modelName);
+      console.log(chalk3.dim("  No previous session found, starting fresh.\n"));
+    }
+  } else {
+    session = createSession(provider, modelName);
+  }
+  let agentState = "idle";
+  let currentAbortController = null;
+  let lastCtrlCTime = 0;
+  let planMode = startInPlanMode || false;
+  const costTracker = new CostTracker();
+  const READ_ONLY_TOOLS = /* @__PURE__ */ new Set(["read_file", "glob", "grep", "ls", "sub_agent"]);
+  function getActiveTools() {
+    if (!planMode)
+      return permissionedTools;
+    const filtered = {};
+    for (const [name, def] of Object.entries(permissionedTools)) {
+      if (READ_ONLY_TOOLS.has(name)) {
+        filtered[name] = def;
+      }
+    }
+    return filtered;
+  }
+  const permissionedTools = {};
+  for (const [name, toolDef] of Object.entries(tools)) {
+    const td = toolDef;
+    permissionedTools[name] = {
+      ...td,
+      execute: async (input) => {
+        const prevState = agentState;
+        agentState = "permission_waiting";
+        const allowed = await permissions.checkPermission(name, input);
+        if (!allowed) {
+          agentState = prevState;
+          debug("Tool denied by user", { tool: name });
+          return "Tool execution denied by user.";
+        }
+        info("Tool call", { tool: name, input: JSON.stringify(input).slice(0, 200) });
+        printToolCall(name, input);
+        agentState = "tool_executing";
+        const result = await td.execute(input);
+        agentState = "streaming";
+        const resultStr = typeof result === "string" ? result : JSON.stringify(result);
+        debug("Tool result", { tool: name, result: resultStr.slice(0, 200) });
+        printToolResult(name, resultStr);
+        return result;
+      }
+    };
+  }
+  info("Session started", { provider, model: modelName, workingDir, trustAll });
+  initTerminal();
+  printHeader("0.1.0", provider, modelName, workingDir);
+  const statusText = printStatusBar(provider, modelName, 0, planMode ? "PLAN" : trustAll ? "trust all" : "ask", 0);
+  setStatusBar(statusText);
+  const rl = readline2.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    prompt: chalk3.cyan("\u276F "),
+    completer
+  });
+  function promptWithStatus() {
+    showStatusBar();
+    rl.prompt();
+  }
+  const history = loadHistory();
+  rl.history = history.reverse();
+  permissions.setReadline(rl);
+  process.on("SIGINT", () => {
+    if (agentState === "streaming") {
+      if (currentAbortController)
+        currentAbortController.abort();
+      console.log(chalk3.yellow("\n  [cancelled]"));
+      agentState = "idle";
+      currentAbortController = null;
+      processing = false;
+      rl.resume();
+      promptWithStatus();
+    } else if (agentState === "tool_executing") {
+      console.log(chalk3.yellow("\n  [cancelling...]"));
+      killActiveProcess();
+      if (currentAbortController)
+        currentAbortController.abort();
+      agentState = "idle";
+      currentAbortController = null;
+      processing = false;
+      rl.resume();
+      promptWithStatus();
+    } else if (agentState === "permission_waiting") {
+      permissions.cancelPrompt();
+      console.log(chalk3.yellow("\n  [cancelled]"));
+      agentState = "idle";
+      currentAbortController = null;
+      processing = false;
+      rl.resume();
+      promptWithStatus();
+    } else {
+      const now = Date.now();
+      if (now - lastCtrlCTime < 500) {
+        saveSession(session);
+        exitTerminal();
+        console.log(chalk3.dim("  Goodbye!"));
+        process.exit(0);
+      }
+      lastCtrlCTime = now;
+      console.log(chalk3.dim("\n  Press Ctrl+C again to exit."));
+      promptWithStatus();
+    }
+  });
+  const systemPrompt = `You are WorkerMill, an AI coding agent running in the user's terminal.
+You have access to tools for reading, writing, and editing files, running bash commands, searching code, and fetching web content.
+
+Working directory: ${workingDir}
+
+Guidelines:
+- Be concise and direct in your responses
+- Use tools proactively to explore the codebase before making changes
+- When editing files, read them first to understand context
+- Prefer editing existing files over creating new ones
+- Run tests after making changes when test infrastructure exists
+- Use glob and grep to find relevant files before reading them
+
+Focus on writing clean, production-ready code.`;
+  promptWithStatus();
+  let processing = false;
+  let multilineBacktick = false;
+  let multilineBackslash = false;
+  let multilineBuffer = [];
+  const cmdCtx = {
+    config,
+    session,
+    costTracker,
+    workingDir,
+    planMode,
+    setPlanMode: (mode) => {
+      planMode = mode;
+      cmdCtx.planMode = mode;
+    },
+    processInput
+  };
+  function processInput(input) {
+    processing = true;
+    rl.pause();
+    (async () => {
+      try {
+        addMessage(session, "user", input);
+        appendHistory(input);
+        if (!session.name) {
+          session.name = input.slice(0, 50).replace(/\n/g, " ");
+        }
+        info("User message", { length: input.length, preview: input.slice(0, 100) });
+        if (session.messages.length <= 1) {
+          const { classifyComplexity, runOrchestration } = await import("./orchestrator-NMTZUS23.js");
+          console.log(chalk3.dim("\n  Analyzing task complexity..."));
+          info("Running complexity classifier");
+          const classification = await classifyComplexity(config, input);
+          info("Classification result", { isMulti: classification.isMulti, reason: classification.reason });
+          if (classification.isMulti) {
+            console.log(chalk3.dim(`  \u2192 multi-expert (${classification.reason})
+`));
+            await runOrchestration(config, input, trustAll, sandboxed, rl);
+            processing = false;
+            rl.resume();
+            promptWithStatus();
+            return;
+          } else {
+            console.log(chalk3.dim(`  \u2192 single agent (${classification.reason})
+`));
+          }
+        }
+        info("Starting streamText", { model: modelName, messageCount: session.messages.length });
+        const thinkingSpinner = ora2({ stream: process.stdout, text: chalk3.dim("Thinking..."), prefixText: " " }).start();
+        currentAbortController = new AbortController();
+        const timeoutId = setTimeout(() => currentAbortController?.abort(), 10 * 60 * 1e3);
+        agentState = "streaming";
+        const stream = streamText({
+          model,
+          system: systemPrompt,
+          messages: session.messages.map((m) => ({
+            role: m.role,
+            content: m.content
+          })),
+          tools: getActiveTools(),
+          stopWhen: stepCountIs(100),
+          abortSignal: currentAbortController.signal
+        });
+        let fullText = "";
+        let spinnerStopped = false;
+        for await (const chunk of stream.textStream) {
+          if (!spinnerStopped) {
+            thinkingSpinner.stop();
+            spinnerStopped = true;
+            process.stdout.write("\n");
+          }
+          process.stdout.write(chalk3.white(chunk));
+          fullText += chunk;
+        }
+        clearTimeout(timeoutId);
+        agentState = "idle";
+        currentAbortController = null;
+        if (!spinnerStopped) {
+          thinkingSpinner.stop();
+          process.stdout.write("\n");
+        }
+        if (fullText.trim()) {
+          process.stdout.write("\n");
+        }
+        const usage = await stream.totalUsage;
+        const tokens = (usage?.inputTokens || 0) + (usage?.outputTokens || 0);
+        session.totalTokens += tokens;
+        costTracker.addUsage("agent", provider, modelName, usage?.inputTokens || 0, usage?.outputTokens || 0);
+        const finalText = await stream.text;
+        info("Response complete", { tokens, textLength: finalText.length });
+        addMessage(session, "assistant", finalText);
+        saveSession(session);
+        const compactionLevel = shouldCompact(session.totalTokens, modelName);
+        if (compactionLevel !== "none") {
+          const spinner = ora2({ stream: process.stdout, text: `Compacting conversation (${compactionLevel})...`, prefixText: "  " }).start();
+          const plainMessages = session.messages.map((m) => ({ role: m.role, content: m.content }));
+          const compacted = await compactMessages(model, plainMessages, compactionLevel);
+          session.messages = compacted.map((m) => ({
+            role: m.role,
+            content: m.content,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          }));
+          saveSession(session);
+          spinner.succeed("Conversation compacted");
+        }
+        const bar = printStatusBar(provider, modelName, session.totalTokens, planMode ? "PLAN" : trustAll ? "trust all" : "ask", costTracker.getTotalCost());
+        setStatusBar(bar);
+      } catch (err) {
+        agentState = "idle";
+        currentAbortController = null;
+        if (err instanceof Error && err.name === "AbortError") {
+        } else {
+          error("Agent error", { error: err instanceof Error ? err.message : String(err) });
+          printError(err instanceof Error ? err.message : String(err));
+        }
+      }
+      processing = false;
+      rl.resume();
+      promptWithStatus();
+    })();
+  }
+  rl.on("line", (input) => {
+    if (permissions.questionActive)
+      return;
+    if (input.trim() === "```" && !multilineBacktick && !multilineBackslash) {
+      multilineBacktick = true;
+      multilineBuffer = [];
+      process.stdout.write(chalk3.dim("  ... "));
+      return;
+    }
+    if (input.trim() === "```" && multilineBacktick) {
+      multilineBacktick = false;
+      const fullInput = multilineBuffer.join("\n");
+      multilineBuffer = [];
+      if (!fullInput.trim() || processing) {
+        rl.prompt();
+        return;
+      }
+      processInput(fullInput);
+      return;
+    }
+    if (multilineBacktick) {
+      multilineBuffer.push(input);
+      process.stdout.write(chalk3.dim("  ... "));
+      return;
+    }
+    if (input.endsWith("\\") && !input.endsWith("\\\\")) {
+      if (!multilineBackslash) {
+        multilineBackslash = true;
+        multilineBuffer = [input.slice(0, -1)];
+      } else {
+        multilineBuffer.push(input.slice(0, -1));
+      }
+      process.stdout.write(chalk3.dim("  ... "));
+      return;
+    }
+    if (multilineBackslash) {
+      multilineBackslash = false;
+      multilineBuffer.push(input);
+      const fullInput = multilineBuffer.join("\n");
+      multilineBuffer = [];
+      if (!fullInput.trim() || processing) {
+        rl.prompt();
+        return;
+      }
+      processInput(fullInput);
+      return;
+    }
+    const trimmed = input.trim();
+    if (!trimmed || processing) {
+      if (!processing)
+        rl.prompt();
+      return;
+    }
+    if (trimmed.startsWith("!")) {
+      const cmd = trimmed.slice(1).trim();
+      if (cmd) {
+        try {
+          const output = execSync3(cmd, { cwd: workingDir, encoding: "utf-8", timeout: 3e4 });
+          if (output.trim())
+            console.log(output);
+        } catch (err) {
+          console.log(chalk3.red(err.stderr || err.message));
+        }
+      }
+      rl.prompt();
+      return;
+    }
+    if (trimmed.startsWith("/")) {
+      processing = true;
+      rl.pause();
+      handleCommand(trimmed, cmdCtx).then(() => {
+        processing = false;
+        rl.resume();
+        promptWithStatus();
+      });
+      return;
+    }
+    processInput(trimmed);
+  });
+  rl.on("close", () => {
+    info("Session ended", { totalTokens: session.totalTokens, messages: session.messages.length });
+    flush();
+    const cleanup = () => {
+      saveSession(session);
+      exitTerminal();
+      console.log(chalk3.dim("  Goodbye!"));
+      process.exit(0);
+    };
+    if (processing) {
+      const checkDone = setInterval(() => {
+        if (!processing) {
+          clearInterval(checkDone);
+          cleanup();
+        }
+      }, 500);
+    } else {
+      cleanup();
+    }
+  });
+}
+
+// src/index.ts
+var VERSION = "0.1.0";
+var program = new Command().name("workermill").description("AI coding agent with multi-expert orchestration").version(VERSION).option("--provider <provider>", "Override default provider").option("--model <model>", "Override model").option("--trust", "Skip all tool permission prompts").option("--resume", "Resume the last conversation").option("--plan", "Start in plan mode (read-only tools)").option("--auto-revise", "Auto-revise on failed reviews without prompting").option("--max-revisions <n>", "Max review\u2192revise cycles (default: 2)", parseInt).option("--critic", "Run separate critic pass on plan before execution").option("--full-disk", "Allow tools to access files outside working directory (default: restricted to cwd)").action(async (options) => {
+  let config = loadConfig();
+  if (!config) {
+    config = await runSetup();
+  }
+  if (options.provider) {
+    config.default = options.provider;
+  }
+  if (options.model) {
+    const providerConfig = config.providers[config.default];
+    if (providerConfig) {
+      providerConfig.model = options.model;
+    }
+  }
+  if (options.autoRevise || options.maxRevisions || options.critic) {
+    config.review = {
+      ...config.review,
+      ...options.autoRevise ? { autoRevise: true } : {},
+      ...options.maxRevisions ? { maxRevisions: options.maxRevisions } : {},
+      ...options.critic ? { useCritic: true } : {}
+    };
+  }
+  const fullDisk = options.fullDisk || false;
+  await runAgent(config, options.trust || false, options.resume || false, options.plan || false, fullDisk);
+});
+program.parse();