noumen 0.1.0 → 0.2.0

package/dist/cli/index.js

@@ -0,0 +1,868 @@
+#!/usr/bin/env node
+import {
+  startSpinner
+} from "../chunk-KXDB56YW.js";
+import {
+  isOllamaRunning,
+  ollamaBaseURL
+} from "../chunk-JX7CLUCV.js";
+import {
+  createRenderState,
+  isVisibleEvent,
+  promptPermission,
+  renderEvent
+} from "../chunk-OGXNFXFA.js";
+import {
+  Agent,
+  LocalSandbox,
+  UnsandboxedLocal
+} from "../chunk-NBDFQYUZ.js";
+import {
+  DEFAULT_MODELS,
+  SUPPORTED_PROVIDERS,
+  detectProvider,
+  resolveProvider
+} from "../chunk-7ZMN7XJE.js";
+import "../chunk-KY6ZPWHO.js";
+import "../chunk-42PHHZUA.js";
+import "../chunk-BGG2E6JD.js";
+import "../chunk-QTJ7VTJY.js";
+import "../chunk-5GEX6ZSB.js";
+import "../chunk-4SQA2UCV.js";
+import "../chunk-JACGEMTF.js";
+import "../chunk-DGUM43GV.js";
+
+// src/cli/index.ts
+import { Command } from "commander";
+import chalk3 from "chalk";
+
+// src/cli/config.ts
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+function loadGlobalConfig() {
+  const globalPath = path.join(os.homedir(), ".noumen", "config.json");
+  try {
+    const raw = fs.readFileSync(globalPath, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return {};
+  }
+}
+function loadProjectConfig(cwd) {
+  let dir = path.resolve(cwd);
+  const root = path.parse(dir).root;
+  while (true) {
+    const candidate = path.join(dir, ".noumen", "config.json");
+    try {
+      const raw = fs.readFileSync(candidate, "utf-8");
+      return JSON.parse(raw);
+    } catch {
+    }
+    const parent = path.dirname(dir);
+    if (parent === dir || dir === root) break;
+    dir = parent;
+  }
+  return {};
+}
+function loadCliConfig(cwd) {
+  const global = loadGlobalConfig();
+  const project = loadProjectConfig(cwd);
+  return { ...global, ...project };
+}
+function mergeConfig(config, flags) {
+  const cwd = flags.cwd ?? process.cwd();
+  return {
+    ...config,
+    ...flags.provider !== void 0 && { provider: flags.provider },
+    ...flags.model !== void 0 && { model: flags.model },
+    ...flags.apiKey !== void 0 && { apiKey: flags.apiKey },
+    ...flags.baseUrl !== void 0 && { baseURL: flags.baseUrl },
+    ...flags.permission !== void 0 && { permissions: flags.permission },
+    ...flags.thinking !== void 0 && { thinking: flags.thinking },
+    ...flags.maxTurns !== void 0 && { maxTurns: flags.maxTurns },
+    ...flags.systemPrompt !== void 0 && { systemPrompt: flags.systemPrompt },
+    cwd,
+    json: flags.json,
+    quiet: flags.quiet,
+    verbose: flags.verbose,
+    headless: flags.headless,
+    prompt: flags.prompt,
+    noSandbox: flags.sandbox === false ? true : void 0,
+    sandboxAllowWrite: flags.sandboxAllowWrite,
+    sandboxAllowDomain: flags.sandboxAllowDomain
+  };
+}
+
+// src/cli/repl.ts
+import * as readline from "readline/promises";
+import chalk from "chalk";
+async function startRepl(code, config) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stderr,
+    terminal: true
+  });
+  let thread = code.createThread({
+    userInputHandler: (q) => promptPermission(rl, "agent", q).then((ok) => ok ? "yes" : "no")
+  });
+  let runningTurn = false;
+  let currentThread = thread;
+  const sigintHandler = () => {
+    if (runningTurn) {
+      currentThread.abort();
+      runningTurn = false;
+      process.stderr.write(chalk.yellow("\n  Cancelled.\n\n"));
+    } else {
+      process.stderr.write(chalk.dim("\nGoodbye.\n"));
+      rl.close();
+      process.exit(0);
+    }
+  };
+  process.on("SIGINT", sigintHandler);
+  printWelcome(config);
+  try {
+    while (true) {
+      let input;
+      try {
+        input = await rl.question(chalk.blue("> "));
+      } catch {
+        break;
+      }
+      if (!input.trim()) continue;
+      if (input.startsWith("/")) {
+        const result = await handleSlashCommand(
+          input,
+          thread,
+          code,
+          config,
+          rl
+        );
+        if (result === "quit") break;
+        if (result === "new") {
+          thread = code.createThread({
+            userInputHandler: (q) => promptPermission(rl, "agent", q).then((ok) => ok ? "yes" : "no")
+          });
+          currentThread = thread;
+        }
+        continue;
+      }
+      const state = createRenderState();
+      const runOpts = config.maxTurns ? { maxTurns: config.maxTurns } : void 0;
+      const spinner = !config.json && !config.quiet ? startSpinner("Thinking") : null;
+      runningTurn = true;
+      try {
+        for await (const event of thread.run(input, runOpts)) {
+          if (!state.showedActivity && spinner && isVisibleEvent(event, config)) {
+            spinner.stop();
+            state.showedActivity = true;
+          }
+          renderEvent(event, config, state);
+        }
+      } catch (err) {
+        if (err?.name === "AbortError") {
+        } else {
+          throw err;
+        }
+      } finally {
+        spinner?.stop();
+        runningTurn = false;
+      }
+      if (state.accumulatedText && !state.accumulatedText.endsWith("\n")) {
+        process.stdout.write("\n");
+      }
+    }
+  } finally {
+    process.removeListener("SIGINT", sigintHandler);
+    rl.close();
+  }
+}
+function printWelcome(config) {
+  const provider = config.provider ?? "auto";
+  const model = config.model ?? DEFAULT_MODELS[provider] ?? "default";
+  process.stderr.write(
+    chalk.bold("noumen") + chalk.dim(` \u2014 ${provider}/${model}`) + "\n" + chalk.dim("Type a message to begin. /help for commands, Ctrl+C to cancel.") + "\n\n"
+  );
+}
+async function handleSlashCommand(input, thread, code, config, _rl) {
+  const [cmd] = input.trim().split(/\s+/);
+  switch (cmd) {
+    case "/quit":
+    case "/exit":
+    case "/q":
+      process.stderr.write(chalk.dim("Goodbye.\n"));
+      return "quit";
+    case "/new":
+      process.stderr.write(chalk.dim("Starting new conversation.\n\n"));
+      return "new";
+    case "/session":
+      process.stderr.write(chalk.dim(`Session: ${thread.sessionId}
+`));
+      return "continue";
+    case "/cost": {
+      const summary = code.getCostSummary();
+      if (summary) {
+        process.stderr.write(
+          chalk.dim(
+            `Cost: $${summary.totalCostUSD.toFixed(4)} | Input: ${summary.totalInputTokens} tokens | Output: ${summary.totalOutputTokens} tokens
+`
+          )
+        );
+      } else {
+        process.stderr.write(chalk.dim("Cost tracking not enabled.\n"));
+      }
+      return "continue";
+    }
+    case "/sessions": {
+      const sessions = await code.listSessions();
+      if (sessions.length === 0) {
+        process.stderr.write(chalk.dim("No saved sessions.\n"));
+      } else {
+        for (const s of sessions.slice(0, 20)) {
+          process.stderr.write(
+            chalk.dim(
+              `  ${s.sessionId.slice(0, 8)}  ${s.createdAt ?? ""}  ${s.messageCount ?? 0} messages
+`
+            )
+          );
+        }
+      }
+      return "continue";
+    }
+    case "/model": {
+      const arg = input.trim().split(/\s+/).slice(1).join(" ");
+      if (!arg) {
+        process.stderr.write(chalk.dim(`Current model: ${thread.getModel()}
+`));
+      } else {
+        thread.setModel(arg);
+        process.stderr.write(chalk.dim(`Model set to ${arg}
+`));
+      }
+      return "continue";
+    }
+    case "/provider": {
+      const parts = input.trim().split(/\s+/).slice(1);
+      const providerName = parts[0];
+      const modelArg = parts[1];
+      if (!providerName) {
+        process.stderr.write(
+          chalk.dim(`Current: ${config.provider ?? "auto"}/${thread.getModel()}
+`) + chalk.dim(`Available: ${SUPPORTED_PROVIDERS.join(", ")}
+`)
+        );
+        return "continue";
+      }
+      if (!SUPPORTED_PROVIDERS.includes(providerName)) {
+        process.stderr.write(chalk.red(`Unknown provider: ${providerName}. Available: ${SUPPORTED_PROVIDERS.join(", ")}
+`));
+        return "continue";
+      }
+      try {
+        const model = modelArg ?? DEFAULT_MODELS[providerName];
+        const provider = await resolveProvider(providerName, {
+          apiKey: config.apiKey,
+          model,
+          baseURL: config.baseURL
+        });
+        thread.setProvider(provider, model);
+        config.provider = providerName;
+        config.model = model;
+        process.stderr.write(chalk.dim(`Switched to ${providerName}/${model}
+`));
+      } catch (err) {
+        process.stderr.write(chalk.red(`Failed to switch: ${err.message}
+`));
+      }
+      return "continue";
+    }
+    case "/verbose":
+      config.verbose = !config.verbose;
+      process.stderr.write(
+        chalk.dim(`Verbose mode: ${config.verbose ? "on" : "off"}
+`)
+      );
+      return "continue";
+    case "/help":
+      process.stderr.write(
+        chalk.dim(
+          [
+            "Commands:",
+            "  /quit, /exit        Exit the REPL",
+            "  /new                Start a new conversation",
+            "  /model [name]       Show or change the model",
+            "  /provider [name]    Show or switch provider (and model)",
+            "  /session            Show current session ID",
+            "  /sessions           List saved sessions",
+            "  /cost               Show token usage and cost",
+            "  /verbose            Toggle verbose output",
+            "  /help               Show this help",
+            "",
+            "Shortcuts:",
+            "  Ctrl+C              Cancel current turn / exit when idle",
+            ""
+          ].join("\n")
+        )
+      );
+      return "continue";
+    default:
+      process.stderr.write(
+        chalk.yellow(`Unknown command: ${cmd}. Try /help
+`)
+      );
+      return "continue";
+  }
+}
+
+// src/cli/init.ts
+import * as fs2 from "fs";
+import * as path2 from "path";
+import * as readline2 from "readline/promises";
+import chalk2 from "chalk";
+var PERMISSION_MODES = ["default", "plan", "acceptEdits", "auto", "bypassPermissions"];
+async function runInit() {
+  const rl = readline2.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  try {
+    process.stdout.write(chalk2.bold("noumen init") + "\n\n");
+    const provider = await askChoice(
+      rl,
+      "Provider",
+      SUPPORTED_PROVIDERS,
+      "anthropic"
+    );
+    let defaultModel = DEFAULT_MODELS[provider] ?? "";
+    if (provider === "ollama") {
+      const ollamaModels = await listOllamaModels();
+      if (ollamaModels.length > 0) {
+        process.stdout.write(chalk2.dim(`  Available models: ${ollamaModels.join(", ")}
+`));
+        if (ollamaModels.includes(defaultModel)) {
+        } else {
+          defaultModel = ollamaModels[0];
+        }
+      } else {
+        process.stdout.write(
+          chalk2.yellow(
+            `
+  Ollama doesn't appear to be running at ${ollamaBaseURL()}.
+  Install it from https://ollama.com, then run:
+    ollama pull ${defaultModel}
+    ollama serve
+
+`
+          )
+        );
+      }
+    }
+    const model = await askDefault(rl, "Model", defaultModel);
+    const permissions = await askChoice(
+      rl,
+      "Permission mode",
+      PERMISSION_MODES,
+      "default"
+    );
+    const config = { provider };
+    if (model !== defaultModel) config.model = model;
+    if (permissions !== "default") config.permissions = permissions;
+    const dir = path2.join(process.cwd(), ".noumen");
+    fs2.mkdirSync(dir, { recursive: true });
+    const configPath = path2.join(dir, "config.json");
+    fs2.writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
+    process.stdout.write(chalk2.green(`  Created ${configPath}
+`));
+    const noumenMdPath = path2.join(process.cwd(), "NOUMEN.md");
+    if (!fs2.existsSync(noumenMdPath)) {
+      const create = await askDefault(rl, "Create NOUMEN.md?", "Y");
+      if (create.toLowerCase() === "y" || create.toLowerCase() === "yes") {
+        fs2.writeFileSync(noumenMdPath, NOUMEN_MD_TEMPLATE);
+        process.stdout.write(chalk2.green(`  Created ${noumenMdPath}
+`));
+      }
+    }
+    process.stdout.write(
+      "\n" + chalk2.dim("Run `noumen` to start a session.") + "\n"
+    );
+  } finally {
+    rl.close();
+  }
+}
+async function listOllamaModels() {
+  if (!await isOllamaRunning()) return [];
+  try {
+    const res = await fetch(`${ollamaBaseURL()}/api/tags`, {
+      signal: AbortSignal.timeout(2e3)
+    });
+    if (!res.ok) return [];
+    const data = await res.json();
+    return (data.models ?? []).map((m) => m.name);
+  } catch {
+    return [];
+  }
+}
+async function askChoice(rl, label, choices, defaultValue) {
+  const hint = choices.join(", ");
+  const answer = await rl.question(
+    `  ${label} (${hint}) [${chalk2.bold(defaultValue)}]: `
+  );
+  const trimmed = answer.trim();
+  if (!trimmed) return defaultValue;
+  if (choices.includes(trimmed)) return trimmed;
+  process.stdout.write(chalk2.yellow(`  Invalid choice, using ${defaultValue}
+`));
+  return defaultValue;
+}
+async function askDefault(rl, label, defaultValue) {
+  const answer = await rl.question(
+    `  ${label} [${chalk2.bold(defaultValue)}]: `
+  );
+  return answer.trim() || defaultValue;
+}
+var NOUMEN_MD_TEMPLATE = `# Project Instructions
+
+Add project-specific instructions for the AI agent here.
+These instructions are loaded automatically when running noumen in this directory.
+
+## Guidelines
+
+- Describe your project's coding conventions
+- Note important architectural decisions
+- List files or patterns the agent should be aware of
+`;
+
+// src/cli/index.ts
+import * as os2 from "os";
+var VERSION = "0.1.0";
+async function listLocalOllamaModels(baseURL) {
+  try {
+    const res = await fetch(`${baseURL}/api/tags`, {
+      signal: AbortSignal.timeout(2e3)
+    });
+    if (!res.ok) return [];
+    const data = await res.json();
+    return (data.models ?? []).map((m) => m.name);
+  } catch {
+    return [];
+  }
+}
+function parseThinking(level) {
+  if (!level || level === "off") return { type: "disabled" };
+  const budgets = {
+    low: 1024,
+    medium: 10240,
+    high: 32768
+  };
+  const budget = budgets[level];
+  if (budget) return { type: "enabled", budgetTokens: budget };
+  return void 0;
+}
+function createCliSandbox(config) {
+  if (config.noSandbox) {
+    return UnsandboxedLocal({ cwd: config.cwd });
+  }
+  const sandboxOpts = {
+    cwd: config.cwd
+  };
+  const allowWrite = config.sandboxAllowWrite ? config.sandboxAllowWrite.split(",").map((s) => s.trim()) : void 0;
+  const allowDomains = config.sandboxAllowDomain ? config.sandboxAllowDomain.split(",").map((s) => s.trim()) : void 0;
+  if (allowWrite || allowDomains) {
+    sandboxOpts.sandbox = {
+      filesystem: allowWrite ? { allowWrite: [config.cwd, ...allowWrite] } : void 0,
+      network: allowDomains ? { allowedDomains: allowDomains } : void 0
+    };
+  }
+  return LocalSandbox(sandboxOpts);
+}
+async function readStdin() {
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(chunk);
+  }
+  return Buffer.concat(chunks).toString("utf-8").trim();
+}
+async function main() {
+  const program = new Command("noumen").version(VERSION).description("AI coding agent \u2014 bring your own provider").option("-p, --provider <name>", "openai | anthropic | gemini | openrouter | bedrock | vertex | ollama").option("-m, --model <model>", "model name").option("--api-key <key>", "API key (overrides env vars)").option("--base-url <url>", "override provider base URL").option("--cwd <dir>", "working directory").option("--permission <mode>", "permission mode (default, plan, acceptEdits, auto, bypassPermissions, dontAsk)").option("--thinking <level>", "thinking level: off, low, medium, high").option("--max-turns <n>", "max agent turns", parseInt).option("--json", "emit JSONL stream events to stdout").option("--quiet", "only output final text").option("--verbose", "show tool calls and thinking").option("--headless", "NDJSON stdin/stdout protocol for programmatic control").option("--no-sandbox", "disable OS-level sandboxing (use UnsandboxedLocal)").option("--sandbox-allow-write <paths>", "comma-separated paths to allow writing in sandbox").option("--sandbox-allow-domain <domains>", "comma-separated domains to allow in sandbox").option("-c, --prompt <text>", "one-shot prompt (non-interactive)").argument("[prompt...]", "inline prompt").allowExcessArguments(true).action(async (args) => {
+    const opts = program.opts();
+    if (args.length > 0 && !opts.prompt) {
+      opts.prompt = args.join(" ");
+    }
+    if (!process.stdin.isTTY && !opts.prompt) {
+      opts.prompt = await readStdin();
+      if (!opts.prompt) {
+        process.stderr.write(chalk3.red("No input provided.\n"));
+        process.exit(1);
+      }
+    }
+    const cwd = opts.cwd ?? process.cwd();
+    const config = loadCliConfig(cwd);
+    const merged = mergeConfig(config, opts);
+    await runAgent(merged);
+  });
+  program.command("init").description("create .noumen/config.json in the current directory").action(async () => {
+    await runInit();
+    process.exit(0);
+  });
+  program.command("sessions").description("list past sessions").action(async () => {
+    await listSessions();
+    process.exit(0);
+  });
+  program.command("resume <session-id>").description("resume a previous session").action(async (sessionId) => {
+    await resumeSession(sessionId);
+  });
+  program.command("doctor").description("run health checks on provider, sandbox, MCP, and LSP").action(async () => {
+    await runDoctor();
+  });
+  await program.parseAsync(process.argv);
+}
+async function runAgent(config) {
+  const providerName = config.provider ?? await detectProvider();
+  if (!providerName) {
+    if (!process.stdin.isTTY) {
+      process.stderr.write(chalk3.red("No provider specified.\n"));
+      process.exit(1);
+    }
+    process.stderr.write(
+      chalk3.bold("Welcome to noumen!\n\n") + chalk3.dim("No provider detected. Let's set one up.\n\n")
+    );
+    const { createInterface: createInterface3 } = await import("readline/promises");
+    const rl = createInterface3({ input: process.stdin, output: process.stderr, terminal: true });
+    try {
+      const { SUPPORTED_PROVIDERS: SUPPORTED_PROVIDERS2, isOllamaRunning: isOllamaRunning2, ollamaBaseURL: ollamaBaseURL2 } = await import("../provider-factory-34MSWJZ3.js");
+      const providerAnswer = await rl.question(
+        `  Provider (${SUPPORTED_PROVIDERS2.join(", ")}) [${chalk3.bold("ollama")}]: `
+      );
+      const picked = providerAnswer.trim() || "ollama";
+      if (!SUPPORTED_PROVIDERS2.includes(picked)) {
+        process.stderr.write(chalk3.red(`Unknown provider: ${picked}
+`));
+        process.exit(1);
+      }
+      if (picked === "ollama") {
+        if (!await isOllamaRunning2()) {
+          process.stderr.write(
+            chalk3.yellow(`
+  Ollama doesn't appear to be running at ${ollamaBaseURL2()}.
+`) + chalk3.yellow(`  Install it from https://ollama.com, then run:
+
+`) + `    ${chalk3.cyan("ollama pull qwen2.5-coder:32b")}
+    ${chalk3.cyan("ollama serve")}
+
+` + chalk3.yellow(`  Then re-run noumen.
+`)
+          );
+          rl.close();
+          process.exit(1);
+        }
+        const models = await listLocalOllamaModels(ollamaBaseURL2());
+        if (models.length > 0) {
+          process.stderr.write(chalk3.dim(`  Available models: ${models.join(", ")}
+`));
+          const defaultModel = models.includes("qwen2.5-coder:32b") ? "qwen2.5-coder:32b" : models[0];
+          const modelAnswer = await rl.question(
+            `  Model [${chalk3.bold(defaultModel)}]: `
+          );
+          config.model = modelAnswer.trim() || defaultModel;
+        }
+      }
+      const needsKey = !["bedrock", "vertex", "ollama"].includes(picked);
+      let apiKey;
+      if (needsKey) {
+        const keyAnswer = await rl.question(`  API key: `);
+        apiKey = keyAnswer.trim();
+        if (!apiKey) {
+          process.stderr.write(chalk3.red("API key is required.\n"));
+          process.exit(1);
+        }
+      }
+      rl.close();
+      config.provider = picked;
+      if (apiKey) config.apiKey = apiKey;
+    } catch {
+      rl.close();
+      process.exit(1);
+    }
+    return runAgent(config);
+  }
+  if (!config.model) {
+    const { DEFAULT_MODELS: DEFAULT_MODELS2 } = await import("../provider-factory-34MSWJZ3.js");
+    if (providerName === "ollama") {
+      const { ollamaBaseURL: ollamaBaseURL2 } = await import("../provider-factory-34MSWJZ3.js");
+      const models = await listLocalOllamaModels(ollamaBaseURL2());
+      const preferred = DEFAULT_MODELS2[providerName];
+      config.model = models.includes(preferred) ? preferred : models[0] ?? preferred;
+    } else {
+      config.model = DEFAULT_MODELS2[providerName];
+    }
+  }
+  const provider = await resolveProvider(providerName, {
+    apiKey: config.apiKey,
+    model: config.model,
+    baseURL: config.baseURL
+  });
+  const thinking = parseThinking(config.thinking);
+  const permissionMode = config.permissions ?? "default";
+  const agent = new Agent({
+    provider,
+    sandbox: createCliSandbox(config),
+    options: {
+      cwd: config.cwd,
+      model: config.model,
+      systemPrompt: config.systemPrompt,
+      permissions: {
+        mode: permissionMode
+      },
+      thinking,
+      autoCompact: config.autoCompact ?? true,
+      enableSubagents: config.enableSubagents ?? true,
+      enableTasks: config.enableTasks ?? false,
+      enablePlanMode: config.enablePlanMode ?? true,
+      enableWorktrees: config.enableWorktrees ?? false,
+      mcpServers: config.mcpServers,
+      lsp: config.lsp,
+      hooks: config.hooks,
+      webSearch: config.webSearch,
+      sessionDir: config.sessionDir ?? ".noumen/sessions",
+      projectContext: { cwd: config.cwd, homeDir: os2.homedir() },
+      costTracking: { enabled: true },
+      retry: true
+    }
+  });
+  if (config.headless) {
+    const { runHeadless } = await import("../headless-Q7XHHZIW.js");
+    await runHeadless(agent, config);
+    return;
+  }
+  await agent.init();
+  if (config.prompt) {
+    await runOneShot(agent, config);
+  } else {
+    if (!process.stdin.isTTY) {
+      process.stderr.write(
+        chalk3.red("Interactive mode requires a TTY. Use -c or pipe input.\n")
+      );
+      process.exit(1);
+    }
+    await startRepl(agent, config);
+  }
+  await agent.close();
+}
+async function runOneShot(agent, config) {
+  const { startSpinner: startSpinner2 } = await import("../spinner-OJNR6NFO.js");
+  const { isVisibleEvent: isVisibleEvent2 } = await import("../render-GRN4ZSSW.js");
+  const thread = agent.createThread();
+  const state = createRenderState();
+  const runOpts = config.maxTurns ? { maxTurns: config.maxTurns } : void 0;
+  const spinner = !config.json && !config.quiet ? startSpinner2("Thinking") : null;
+  try {
+    for await (const event of thread.run(config.prompt, runOpts)) {
+      if (!state.showedActivity && spinner && isVisibleEvent2(event, config)) {
+        spinner.stop();
+        state.showedActivity = true;
+      }
+      renderEvent(event, config, state);
+    }
+  } finally {
+    spinner?.stop();
+  }
+  if (config.quiet && state.accumulatedText) {
+    process.stdout.write(state.accumulatedText);
+    if (!state.accumulatedText.endsWith("\n")) {
+      process.stdout.write("\n");
+    }
+  } else if (state.accumulatedText && !state.accumulatedText.endsWith("\n")) {
+    process.stdout.write("\n");
+  }
+}
+async function listSessions() {
+  const cwd = process.cwd();
+  const config = loadCliConfig(cwd);
+  const merged = mergeConfig(config, { cwd });
+  const providerName = merged.provider ?? await detectProvider();
+  if (!providerName) {
+    process.stderr.write(chalk3.red("No provider configured. Run `noumen init` first.\n"));
+    process.exit(1);
+  }
+  const provider = await resolveProvider(providerName, {
+    apiKey: merged.apiKey,
+    model: merged.model,
+    baseURL: merged.baseURL
+  });
+  const agent = new Agent({
+    provider,
+    sandbox: UnsandboxedLocal({ cwd }),
+    options: { cwd, sessionDir: merged.sessionDir ?? ".noumen/sessions" }
+  });
+  const sessions = await agent.listSessions();
+  if (sessions.length === 0) {
+    process.stdout.write(chalk3.dim("No saved sessions.\n"));
+    return;
+  }
+  process.stdout.write(chalk3.bold("Sessions:\n"));
+  for (const s of sessions) {
+    const title = s.title ? chalk3.white(` ${s.title}`) : "";
+    process.stdout.write(
+      `  ${chalk3.cyan(s.sessionId.slice(0, 8))}  ${chalk3.dim(s.createdAt)}  ${chalk3.dim(`${s.messageCount} msgs`)}${title}
+`
+    );
+  }
+}
+async function resumeSession(sessionId) {
+  const cwd = process.cwd();
+  const config = loadCliConfig(cwd);
+  const merged = mergeConfig(config, { cwd });
+  const providerName = merged.provider ?? await detectProvider();
+  if (!providerName) {
+    process.stderr.write(chalk3.red("No provider configured. Run `noumen init` first.\n"));
+    process.exit(1);
+  }
+  const provider = await resolveProvider(providerName, {
+    apiKey: merged.apiKey,
+    model: merged.model,
+    baseURL: merged.baseURL
+  });
+  const thinking = parseThinking(merged.thinking);
+  const permissionMode = merged.permissions ?? "default";
+  const agent = new Agent({
+    provider,
+    sandbox: createCliSandbox(merged),
+    options: {
+      cwd,
+      model: merged.model,
+      permissions: { mode: permissionMode },
+      thinking,
+      autoCompact: merged.autoCompact ?? true,
+      enableSubagents: merged.enableSubagents ?? true,
+      enablePlanMode: merged.enablePlanMode ?? true,
+      mcpServers: merged.mcpServers,
+      lsp: merged.lsp,
+      hooks: merged.hooks,
+      sessionDir: merged.sessionDir ?? ".noumen/sessions",
+      projectContext: { cwd, homeDir: os2.homedir() },
+      costTracking: { enabled: true },
+      retry: true
+    }
+  });
+  await agent.init();
+  const sessions = await agent.listSessions();
+  const match = sessions.find(
+    (s) => s.sessionId === sessionId || s.sessionId.startsWith(sessionId)
+  );
+  if (!match) {
+    process.stderr.write(chalk3.red(`Session not found: ${sessionId}
+`));
+    process.exit(1);
+  }
+  process.stderr.write(
+    chalk3.dim(`Resuming session ${match.sessionId.slice(0, 8)}...
+
+`)
+  );
+  const { createInterface: createInterface3 } = await import("readline/promises");
+  const rl = createInterface3({ input: process.stdin, output: process.stderr, terminal: true });
+  const thread = agent.resumeThread(match.sessionId);
+  const { renderEvent: render, createRenderState: makeState } = await import("../render-GRN4ZSSW.js");
+  process.stderr.write(chalk3.dim("Session resumed. Type a message to continue.\n\n"));
+  try {
+    while (true) {
+      let input;
+      try {
+        input = await rl.question(chalk3.blue("> "));
+      } catch {
+        break;
+      }
+      if (!input.trim()) continue;
+      if (input.trim() === "/quit" || input.trim() === "/exit") break;
+      const state = makeState();
+      for await (const event of thread.run(input)) {
+        render(event, merged, state);
+      }
+      if (state.accumulatedText && !state.accumulatedText.endsWith("\n")) {
+        process.stdout.write("\n");
+      }
+    }
+  } finally {
+    rl.close();
+    await agent.close();
+  }
+}
+async function runDoctor() {
+  const cwd = process.cwd();
+  const config = loadCliConfig(cwd);
+  const merged = mergeConfig(config, { cwd });
+  const providerName = merged.provider ?? await detectProvider();
+  if (!providerName) {
+    process.stderr.write(chalk3.red("No provider configured. Run `noumen init` first.\n"));
+    process.exit(1);
+  }
+  const provider = await resolveProvider(providerName, {
+    apiKey: merged.apiKey,
+    model: merged.model,
+    baseURL: merged.baseURL
+  });
+  const agent = new Agent({
+    provider,
+    sandbox: createCliSandbox(merged),
+    options: {
+      cwd,
+      model: merged.model,
+      mcpServers: merged.mcpServers,
+      lsp: merged.lsp,
+      sessionDir: merged.sessionDir ?? ".noumen/sessions"
+    }
+  });
+  await agent.init();
+  process.stderr.write(chalk3.bold("\nnoumen doctor\n\n"));
+  const result = await agent.diagnose();
+  printDiagnoseResult(result);
+  await agent.close();
+  process.exit(result.overall ? 0 : 1);
+}
+function formatCheckLine(label, check, extra) {
+  const icon = check.ok ? chalk3.green("\u2713") : chalk3.red("\u2717");
+  const timing = check.latencyMs > 0 ? chalk3.dim(` (${check.latencyMs}ms)`) : "";
+  const suffix = extra ? chalk3.dim(` ${extra}`) : "";
+  const errMsg = check.error ? chalk3.red(`  ${check.error}`) : "";
+  const warnMsg = !check.error && check.warning ? chalk3.yellow(`  ${check.warning}`) : "";
+  return `  ${icon} ${label}${timing}${suffix}${errMsg}${warnMsg}
+`;
+}
+function printDiagnoseResult(r) {
+  const modelLabel = r.provider.model ? ` (${r.provider.model})` : "";
+  process.stderr.write(formatCheckLine(`Provider${modelLabel}`, r.provider));
+  process.stderr.write(formatCheckLine("Sandbox: filesystem", r.sandbox.fs));
+  process.stderr.write(formatCheckLine("Sandbox: shell", r.sandbox.computer));
+  process.stderr.write(formatCheckLine(
+    "Sandbox: OS-level (sandbox-runtime)",
+    r.sandboxRuntime,
+    r.sandboxRuntime.platform
+  ));
+  for (const [name, check] of Object.entries(r.mcp)) {
+    const parts = [];
+    if (check.status) parts.push(check.status);
+    if (check.toolCount != null) parts.push(`${check.toolCount} tools`);
+    const extra = parts.length ? parts.join(", ") : void 0;
+    process.stderr.write(formatCheckLine(`MCP: ${name}`, check, extra));
+  }
+  for (const [name, check] of Object.entries(r.lsp)) {
+    const extra = check.state ?? void 0;
+    process.stderr.write(formatCheckLine(`LSP: ${name}`, check, extra));
+  }
+  process.stderr.write("\n");
+  if (r.overall) {
+    process.stderr.write(`  ${chalk3.green("Overall: healthy")}
+
+`);
+  } else {
+    process.stderr.write(`  ${chalk3.red("Overall: unhealthy")}
+
+`);
+  }
+}
+main().catch((err) => {
+  process.stderr.write(chalk3.red(`Fatal: ${err.message}
+`));
+  process.exit(1);
+});
+//# sourceMappingURL=index.js.map