audacity-cli 0.1.0

package/dist/index.js

@@ -0,0 +1,1805 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import path3 from "path";
+import { Command } from "commander";
+
+// src/ui.ts
+var useColor = () => process.stdout.isTTY === true && !process.env.NO_COLOR;
+var wrap = (code, s) => useColor() ? `${code}${s}\x1B[0m` : s;
+var cyan = (s) => wrap("\x1B[36m", s);
+var dim = (s) => wrap("\x1B[2m", s);
+var bold = (s) => wrap("\x1B[1m", s);
+var yellow = (s) => wrap("\x1B[33m", s);
+var italic = (s) => wrap("\x1B[3m", s);
+var underline = (s) => wrap("\x1B[4m", s);
+var ART = [
+  " \u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2557   \u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2557  \u2588\u2588\u2588\u2588\u2588\u2557  \u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2557   \u2588\u2588\u2557",
+  "\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2551   \u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D\u2588\u2588\u2551\u255A\u2550\u2550\u2588\u2588\u2554\u2550\u2550\u255D\u255A\u2588\u2588\u2557 \u2588\u2588\u2554\u255D",
+  "\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2551\u2588\u2588\u2551   \u2588\u2588\u2551\u2588\u2588\u2551  \u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2551\u2588\u2588\u2551     \u2588\u2588\u2551   \u2588\u2588\u2551    \u255A\u2588\u2588\u2588\u2588\u2554\u255D ",
+  "\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2551\u2588\u2588\u2551   \u2588\u2588\u2551\u2588\u2588\u2551  \u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2551\u2588\u2588\u2551     \u2588\u2588\u2551   \u2588\u2588\u2551     \u255A\u2588\u2588\u2554\u255D  ",
+  "\u2588\u2588\u2551  \u2588\u2588\u2551\u255A\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D\u2588\u2588\u2551  \u2588\u2588\u2551\u255A\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2551   \u2588\u2588\u2551      \u2588\u2588\u2551   ",
+  "\u255A\u2550\u255D  \u255A\u2550\u255D \u255A\u2550\u2550\u2550\u2550\u2550\u255D \u255A\u2550\u2550\u2550\u2550\u2550\u255D \u255A\u2550\u255D  \u255A\u2550\u255D \u255A\u2550\u2550\u2550\u2550\u2550\u255D\u255A\u2550\u255D   \u255A\u2550\u255D      \u255A\u2550\u255D   "
+];
+function frameWidth() {
+  const max = ART[0]?.length ?? 60;
+  const cols = process.stdout.columns ?? max;
+  return Math.max(20, Math.min(max, cols - 1));
+}
+function printBanner() {
+  console.log("");
+  for (const row of ART) console.log(`  ${cyan(row)}`);
+  console.log("");
+}
+function hRule() {
+  return dim("\u2500".repeat(frameWidth()));
+}
+function promptString(badge = "") {
+  return `${badge}${cyan("\u276F")} `;
+}
+
+// src/markdown.ts
+var defaultStyle = { bold, cyan, dim, italic, underline };
+var FENCE = /^\s*```/;
+var HEADING = /^(#{1,6})\s+(.*)$/;
+var HR = /^\s*([-*_])\1{2,}\s*$/;
+var BLOCKQUOTE = /^(\s*)>\s?(.*)$/;
+var UL = /^(\s*)[-*+]\s+(.*)$/;
+var OL = /^(\s*)(\d+)\.\s+(.*)$/;
+var NUL = String.fromCharCode(0);
+var RESTORE = new RegExp(`${NUL}(\\d+)${NUL}`, "g");
+function inline(text, style = defaultStyle) {
+  const spans = [];
+  let out = text.replace(/`([^`]+)`/g, (_m, code) => {
+    spans.push(style.cyan(code));
+    return `${NUL}${spans.length - 1}${NUL}`;
+  });
+  out = out.replace(
+    /\[([^\]]+)\]\(([^)]+)\)/g,
+    (_m, label, url) => `${style.underline(label)}${style.dim(` (${url})`)}`
+  );
+  out = out.replace(/\*\*([^*]+)\*\*/g, (_m, s) => style.bold(s));
+  out = out.replace(/__([^_]+)__/g, (_m, s) => style.bold(s));
+  out = out.replace(/\*([^*]+)\*/g, (_m, s) => style.italic(s));
+  out = out.replace(/(?<![A-Za-z0-9])_([^_]+)_(?![A-Za-z0-9])/g, (_m, s) => style.italic(s));
+  out = out.replace(RESTORE, (_m, i) => spans[Number(i)] ?? "");
+  return out;
+}
+function renderer(write = (s) => void process.stdout.write(s), style = defaultStyle) {
+  let buf = "";
+  let insideFence = false;
+  const renderLine = (line, newline) => {
+    let rendered;
+    if (FENCE.test(line)) {
+      insideFence = !insideFence;
+      return;
+    }
+    if (insideFence) {
+      rendered = `${style.dim("\u2502 ")}${line}`;
+    } else {
+      const heading = HEADING.exec(line);
+      const hr = HR.exec(line);
+      const quote = BLOCKQUOTE.exec(line);
+      const ul = UL.exec(line);
+      const ol = OL.exec(line);
+      if (heading) {
+        rendered = style.bold(style.cyan(heading[2] ?? ""));
+      } else if (hr) {
+        rendered = style.dim("\u2500".repeat(frameWidth()));
+      } else if (quote) {
+        rendered = style.dim(`\u258F ${inline(quote[2] ?? "", style)}`);
+      } else if (ul) {
+        rendered = `${ul[1] ?? ""}\u2022 ${inline(ul[2] ?? "", style)}`;
+      } else if (ol) {
+        rendered = `${ol[1] ?? ""}${ol[2]}. ${inline(ol[3] ?? "", style)}`;
+      } else {
+        rendered = inline(line, style);
+      }
+    }
+    write(newline ? `${rendered}
+` : rendered);
+  };
+  return {
+    write(delta) {
+      buf += delta;
+      let nl = buf.indexOf("\n");
+      while (nl !== -1) {
+        renderLine(buf.slice(0, nl), true);
+        buf = buf.slice(nl + 1);
+        nl = buf.indexOf("\n");
+      }
+    },
+    end() {
+      if (buf.length) renderLine(buf, false);
+      buf = "";
+      insideFence = false;
+    }
+  };
+}
+function createMarkdownStream(write = (s) => void process.stdout.write(s)) {
+  if (!useColor()) {
+    return { write: (d) => write(d), end: () => {
+    } };
+  }
+  return renderer(write);
+}
+
+// src/model.ts
+var ModelError = class extends Error {
+  constructor(status, message) {
+    super(message);
+    this.status = status;
+    this.name = "ModelError";
+  }
+};
+function extractErrorMessage(body, status) {
+  try {
+    const parsed = JSON.parse(body);
+    if (parsed.error?.message) return parsed.error.message;
+  } catch {
+  }
+  return body.trim() || `Request failed with status ${status}`;
+}
+async function streamCompletion(params, cfg) {
+  const base = cfg.apiUrl.replace(/\/+$/, "");
+  const path4 = params.rag ? "/v1/agent/chat/completions" : "/v1/chat/completions";
+  const body = {
+    model: params.model,
+    messages: params.messages,
+    stream: true,
+    stream_options: { include_usage: true }
+  };
+  if (!params.rag && params.tools?.length) {
+    body.tools = params.tools;
+    body.tool_choice = "auto";
+  }
+  if (params.rag && params.conversationId) {
+    body.conversation_id = params.conversationId;
+  }
+  const headers = {
+    Authorization: `Bearer ${cfg.apiKey}`,
+    "Content-Type": "application/json",
+    Accept: "text/event-stream"
+  };
+  if (params.rag && params.conversationId) {
+    headers["X-Conversation-Id"] = params.conversationId;
+  }
+  let res;
+  try {
+    res = await fetch(`${base}${path4}`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(body)
+    });
+  } catch (err) {
+    const reason = err instanceof Error ? err.message : String(err);
+    throw new ModelError(0, `Could not reach ${base}: ${reason}`);
+  }
+  if (!res.ok) {
+    const text = await res.text().catch(() => "");
+    throw new ModelError(res.status, extractErrorMessage(text, res.status));
+  }
+  if (!res.body) {
+    throw new ModelError(502, "Upstream returned no response body.");
+  }
+  const conversationId = res.headers.get("x-conversation-id") ?? params.conversationId;
+  let content = "";
+  const toolCallsByIndex = /* @__PURE__ */ new Map();
+  let finishReason = null;
+  let usage;
+  const reader = res.body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  const handleChunk = (chunk) => {
+    if (chunk.usage) usage = chunk.usage;
+    const choice = chunk.choices?.[0];
+    if (!choice) return;
+    const delta = choice.delta ?? {};
+    if (typeof delta.content === "string" && delta.content.length > 0) {
+      content += delta.content;
+      params.onText(delta.content);
+    }
+    if (Array.isArray(delta.tool_calls)) {
+      for (const tc of delta.tool_calls) {
+        const idx = tc.index ?? 0;
+        const cur = toolCallsByIndex.get(idx) ?? { id: "", name: "", args: "" };
+        if (tc.id) cur.id = tc.id;
+        if (tc.function?.name) cur.name = tc.function.name;
+        if (tc.function?.arguments) cur.args += tc.function.arguments;
+        toolCallsByIndex.set(idx, cur);
+      }
+    }
+    if (choice.finish_reason) finishReason = choice.finish_reason;
+  };
+  const processLine = (line) => {
+    const trimmed = line.trim();
+    if (!trimmed.startsWith("data:")) return;
+    const data = trimmed.slice(5).trim();
+    if (!data || data === "[DONE]") return;
+    try {
+      handleChunk(JSON.parse(data));
+    } catch {
+    }
+  };
+  for (; ; ) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    buffer += decoder.decode(value, { stream: true });
+    const lines = buffer.split("\n");
+    buffer = lines.pop() ?? "";
+    for (const line of lines) processLine(line);
+  }
+  if (buffer.trim()) processLine(buffer);
+  const toolCalls = [...toolCallsByIndex.entries()].sort((a, b) => a[0] - b[0]).map(([, v]) => ({
+    id: v.id,
+    type: "function",
+    function: { name: v.name, arguments: v.args }
+  }));
+  return { content, toolCalls, finishReason, usage, conversationId: conversationId ?? void 0 };
+}
+
+// src/models.ts
+var DEFAULT_MODEL = "gemini-2.5-flash";
+var COMPACT_MODEL = "gemini-2.5-flash";
+var AVAILABLE_MODELS = [
+  // Google (tool-capable, good defaults)
+  "gemini-2.5-flash",
+  "gemini-2.5-pro",
+  "gemini-3-flash-preview",
+  // Anthropic
+  "claude-opus-4-8",
+  "claude-opus-4-7",
+  "claude-opus-4-6",
+  "claude-sonnet-4-6",
+  "claude-haiku-4-5-20251001",
+  // OpenAI
+  "gpt-5.5",
+  "gpt-5.4",
+  "gpt-5.4-mini",
+  "gpt-4o",
+  "gpt-4o-mini",
+  "gpt-4-turbo",
+  // xAI
+  "grok-4-3",
+  "grok-4-1-fast-reasoning",
+  "grok-4-1-fast-non-reasoning",
+  "grok-3",
+  "grok-3-mini",
+  // DeepSeek
+  "deepseek-chat",
+  "deepseek-reasoner",
+  // Moonshot / Kimi
+  "moonshot-v1-8k",
+  "moonshot-v1-32k",
+  "moonshot-v1-128k",
+  // Mistral
+  "mistral-large",
+  "mistral-small",
+  // Meta Llama
+  "llama-4-maverick",
+  "llama-4-scout",
+  // Perplexity Sonar (note: no tool-calling support — weak for the coding agent)
+  "sonar-pro",
+  "sonar",
+  "sonar-reasoning-pro",
+  "sonar-deep-research"
+];
+
+// src/modes.ts
+var AGENT_MODES = [
+  { id: "normal", label: "normal", description: "approve each tool action", autoApprove: false, gate: "executing" },
+  {
+    id: "plan",
+    label: "plan",
+    description: "no project changes without approval; draft a plan",
+    autoApprove: false,
+    gate: "planning"
+  },
+  { id: "auto", label: "auto-approve", description: "run tool actions without asking", autoApprove: true, gate: "executing" }
+];
+var DEFAULT_MODE_ID = "normal";
+function initialModeIndex(autoApprove) {
+  const i = AGENT_MODES.findIndex((m) => m.autoApprove === autoApprove);
+  return i >= 0 ? i : 0;
+}
+function currentMode(session) {
+  return AGENT_MODES[session.modeIndex] ?? AGENT_MODES[0];
+}
+function setMode(session, index) {
+  const n = AGENT_MODES.length;
+  const i = (index % n + n) % n;
+  const mode = AGENT_MODES[i];
+  session.modeIndex = i;
+  session.autoApprove = mode.autoApprove;
+  return mode;
+}
+function cycleMode(session) {
+  return setMode(session, session.modeIndex + 1);
+}
+
+// src/tools.ts
+import { spawn } from "child_process";
+import { mkdir, readdir, readFile, stat, writeFile } from "fs/promises";
+import path from "path";
+var MAX_OUTPUT = 3e4;
+var READ_ONLY = /* @__PURE__ */ new Set(["read_file", "list_files", "grep"]);
+var CONTROL = /* @__PURE__ */ new Set(["present_plan", "ask_choice"]);
+function isControlTool(name) {
+  return CONTROL.has(name);
+}
+function cap(text) {
+  if (text.length <= MAX_OUTPUT) return text;
+  return `${text.slice(0, MAX_OUTPUT)}
+\u2026[truncated ${text.length - MAX_OUTPUT} chars]`;
+}
+function safeResolve(cwd, p) {
+  const resolved = path.resolve(cwd, p || ".");
+  const rel = path.relative(cwd, resolved);
+  if (rel.startsWith("..") || path.isAbsolute(rel)) {
+    throw new Error(`Path escapes the working directory: ${p}`);
+  }
+  return resolved;
+}
+function str(v) {
+  return typeof v === "string" ? v : v == null ? "" : String(v);
+}
+function getToolSchemas() {
+  return [
+    {
+      type: "function",
+      function: {
+        name: "read_file",
+        description: "Read a UTF-8 text file relative to the working directory.",
+        parameters: {
+          type: "object",
+          properties: { path: { type: "string", description: "File path relative to cwd." } },
+          required: ["path"]
+        }
+      }
+    },
+    {
+      type: "function",
+      function: {
+        name: "list_files",
+        description: "List entries in a directory (directories shown with a trailing /).",
+        parameters: {
+          type: "object",
+          properties: { path: { type: "string", description: "Directory path relative to cwd. Defaults to '.'." } }
+        }
+      }
+    },
+    {
+      type: "function",
+      function: {
+        name: "grep",
+        description: "Search file contents for a regex pattern. Returns `path:line: text` matches.",
+        parameters: {
+          type: "object",
+          properties: {
+            pattern: { type: "string", description: "Regular expression to search for." },
+            path: { type: "string", description: "File or directory to search. Defaults to '.'." }
+          },
+          required: ["pattern"]
+        }
+      }
+    },
+    {
+      type: "function",
+      function: {
+        name: "edit_file",
+        description: "Replace an exact string in a file. old_str must occur exactly once or the edit fails.",
+        parameters: {
+          type: "object",
+          properties: {
+            path: { type: "string" },
+            old_str: { type: "string", description: "Exact text to replace (must be unique in the file)." },
+            new_str: { type: "string", description: "Replacement text." }
+          },
+          required: ["path", "old_str", "new_str"]
+        }
+      }
+    },
+    {
+      type: "function",
+      function: {
+        name: "write_file",
+        description: "Create or overwrite a file with the given content.",
+        parameters: {
+          type: "object",
+          properties: {
+            path: { type: "string" },
+            content: { type: "string" }
+          },
+          required: ["path", "content"]
+        }
+      }
+    },
+    {
+      type: "function",
+      function: {
+        name: "run_bash",
+        description: "Run a shell command in the working directory (60s timeout). Returns combined stdout+stderr.",
+        parameters: {
+          type: "object",
+          properties: { command: { type: "string" } },
+          required: ["command"]
+        }
+      }
+    },
+    {
+      type: "function",
+      function: {
+        name: "present_plan",
+        description: "Call when exploration is complete and you have a concrete plan. Ends plan mode and requests user approval before any change is made. Do not call any mutating tool before this is approved. If open_questions is non-empty, prefer resolving them with ask_choice first.",
+        parameters: {
+          type: "object",
+          properties: {
+            title: { type: "string", description: "Short imperative title, e.g. 'Add retry to IAM token refresh'." },
+            summary: { type: "string", description: "1-3 sentences on the approach and why." },
+            steps: {
+              type: "array",
+              items: { type: "string" },
+              description: "Ordered, concrete steps. Each references specific files/functions."
+            },
+            files_to_change: {
+              type: "array",
+              items: { type: "string" },
+              description: "Relative paths this plan will create or modify."
+            },
+            open_questions: {
+              type: "array",
+              items: { type: "string" },
+              description: "Anything still unresolved. If non-empty, prefer ask_choice first."
+            }
+          },
+          required: ["title", "summary", "steps"]
+        }
+      }
+    },
+    {
+      type: "function",
+      function: {
+        name: "ask_choice",
+        description: "Ask the user to choose between options when you lack the information to proceed confidently. Use this instead of guessing or asking in prose. Provide 2-5 concrete, mutually exclusive options. Two extra options ('Type something else' and 'Chat about this') are added automatically \u2014 do not include them yourself.",
+        parameters: {
+          type: "object",
+          properties: {
+            question: { type: "string", description: "One clear question." },
+            options: {
+              type: "array",
+              minItems: 2,
+              maxItems: 5,
+              items: {
+                type: "object",
+                properties: {
+                  label: { type: "string", description: "Short, scannable." },
+                  detail: { type: "string", description: "Optional one-liner shown under the label." }
+                },
+                required: ["label"]
+              },
+              description: "2-5 concrete, mutually exclusive options."
+            }
+          },
+          required: ["question", "options"]
+        }
+      }
+    }
+  ];
+}
+function describeToolCall(name, args) {
+  switch (name) {
+    case "run_bash":
+      return `$ ${str(args.command)}`;
+    case "write_file":
+      return `write ${str(args.path)} (${Buffer.byteLength(str(args.content))} bytes)`;
+    case "edit_file":
+      return `edit ${str(args.path)}
+    - ${preview(str(args.old_str))}
+    + ${preview(str(args.new_str))}`;
+    default:
+      return `${name}(${JSON.stringify(args)})`;
+  }
+}
+function preview(s) {
+  const oneLine = s.replace(/\n/g, "\u23CE");
+  return oneLine.length > 80 ? `${oneLine.slice(0, 80)}\u2026` : oneLine;
+}
+async function executeTool(name, args, cwd) {
+  switch (name) {
+    case "read_file":
+      return cap(await readFile(safeResolve(cwd, str(args.path)), "utf8"));
+    case "list_files": {
+      const dir = safeResolve(cwd, str(args.path) || ".");
+      const entries = await readdir(dir, { withFileTypes: true });
+      const listed = entries.map((e) => e.isDirectory() ? `${e.name}/` : e.name).sort((a, b) => a.localeCompare(b));
+      return listed.length ? listed.join("\n") : "(empty directory)";
+    }
+    case "grep": {
+      const pattern = str(args.pattern);
+      const target = safeResolve(cwd, str(args.path) || ".");
+      const viaRg = await ripgrep(pattern, target, cwd);
+      return viaRg ?? await jsGrep(pattern, target, cwd);
+    }
+    case "edit_file": {
+      const file = safeResolve(cwd, str(args.path));
+      const oldStr = str(args.old_str);
+      const newStr = str(args.new_str);
+      if (!oldStr) throw new Error("old_str must not be empty");
+      const content = await readFile(file, "utf8");
+      const occurrences = content.split(oldStr).length - 1;
+      if (occurrences === 0) throw new Error("old_str not found in file");
+      if (occurrences > 1) {
+        throw new Error(`old_str matches ${occurrences} times; it must match exactly once`);
+      }
+      await writeFile(file, content.replace(oldStr, newStr), "utf8");
+      return `Edited ${path.relative(cwd, file)} (1 replacement)`;
+    }
+    case "write_file": {
+      const file = safeResolve(cwd, str(args.path));
+      const content = str(args.content);
+      await mkdir(path.dirname(file), { recursive: true });
+      await writeFile(file, content, "utf8");
+      return `Wrote ${Buffer.byteLength(content)} bytes to ${path.relative(cwd, file)}`;
+    }
+    case "run_bash":
+      return runBash(str(args.command), cwd);
+    default:
+      throw new Error(`Unknown tool: ${name}`);
+  }
+}
+function ripgrep(pattern, target, cwd) {
+  const rel = path.relative(cwd, target) || ".";
+  return new Promise((resolve) => {
+    const child = spawn("rg", ["--line-number", "--no-heading", "--color", "never", pattern, rel], {
+      cwd
+    });
+    let out = "";
+    child.stdout.on("data", (d) => {
+      out += d.toString();
+    });
+    child.on("error", () => resolve(null));
+    child.on("close", (code) => {
+      if (code === 0) resolve(cap(out) || "(no matches)");
+      else if (code === 1) resolve("(no matches)");
+      else resolve(null);
+    });
+  });
+}
+async function jsGrep(pattern, target, cwd) {
+  let regex = null;
+  try {
+    regex = new RegExp(pattern);
+  } catch {
+    regex = null;
+  }
+  const skipDirs = /* @__PURE__ */ new Set(["node_modules", ".git", "dist", ".next", "build", ".cache", ".turbo"]);
+  const matches = [];
+  const MAX = 300;
+  const scanFile = async (full) => {
+    let text;
+    try {
+      text = await readFile(full, "utf8");
+    } catch {
+      return;
+    }
+    if (text.includes("\0")) return;
+    const lines = text.split("\n");
+    for (let i = 0; i < lines.length && matches.length < MAX; i++) {
+      const line = lines[i] ?? "";
+      const hit = regex ? regex.test(line) : line.includes(pattern);
+      if (hit) matches.push(`${path.relative(cwd, full)}:${i + 1}: ${line.trim()}`);
+    }
+  };
+  const walk = async (dir) => {
+    if (matches.length >= MAX) return;
+    let entries;
+    try {
+      entries = await readdir(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const e of entries) {
+      if (matches.length >= MAX) return;
+      const full = path.join(dir, e.name);
+      if (e.isDirectory()) {
+        if (!skipDirs.has(e.name)) await walk(full);
+      } else if (e.isFile()) {
+        await scanFile(full);
+      }
+    }
+  };
+  const info = await stat(target).catch(() => null);
+  if (info?.isFile()) await scanFile(target);
+  else await walk(target);
+  return matches.length ? cap(matches.join("\n")) : "(no matches)";
+}
+function runBash(command, cwd) {
+  if (!command.trim()) return Promise.resolve("ERROR: empty command");
+  return new Promise((resolve) => {
+    const child = spawn(command, { cwd, shell: true });
+    let out = "";
+    const onData = (d) => {
+      out += d.toString();
+      if (out.length > MAX_OUTPUT * 2) {
+        out = out.slice(0, MAX_OUTPUT * 2);
+        child.kill("SIGKILL");
+      }
+    };
+    child.stdout.on("data", onData);
+    child.stderr.on("data", onData);
+    const timer = setTimeout(() => {
+      child.kill("SIGKILL");
+      out += "\n[timed out after 60s]";
+    }, 6e4);
+    child.on("error", (e) => {
+      clearTimeout(timer);
+      resolve(`ERROR: ${e.message}`);
+    });
+    child.on("close", (code) => {
+      clearTimeout(timer);
+      resolve(`${cap(out)}
+[exit ${code ?? "killed"}]`);
+    });
+  });
+}
+
+// src/policy.ts
+function decideTool(name, session) {
+  if (isControlTool(name)) return { kind: "control_flow" };
+  const planning = currentMode(session).gate === "planning";
+  if (planning) {
+    if (READ_ONLY.has(name)) return { kind: "execute", approval: "none" };
+    if (name === "run_bash") return { kind: "execute", approval: "ask" };
+    return {
+      kind: "block",
+      message: `${name} modifies the project and is not allowed in plan mode. Explore with read_file/list_files/grep (and run_bash, which will ask first), then call present_plan to propose changes for approval.`
+    };
+  }
+  if (READ_ONLY.has(name)) return { kind: "execute", approval: "none" };
+  return { kind: "execute", approval: session.autoApprove ? "auto" : "ask" };
+}
+
+// src/agent.ts
+var MAX_ITERATIONS = 50;
+var MAX_MESSAGES = 100;
+var KEEP_RECENT = 2;
+var SUMMARY_INSTRUCTION = `Summarize the conversation so far into a compact briefing so you (the assistant) can keep working seamlessly after older turns are dropped. Capture: the user's goals, key decisions, files read or changed, important facts discovered, and any open or pending tasks. Be thorough on anything needed to continue; skip pleasantries. Output only the summary.`;
+function trimContext(messages) {
+  if (messages.length <= MAX_MESSAGES) return;
+  const head = messages[0];
+  const system = head && head.role === "system" ? [head] : [];
+  const tail = messages.slice(-(MAX_MESSAGES - system.length));
+  while (tail.length && tail[0]?.role === "tool") tail.shift();
+  messages.splice(0, messages.length, ...system, ...tail);
+}
+function buildCompacted(messages, summary, keepRecent = KEEP_RECENT) {
+  const system = messages[0]?.role === "system" ? [messages[0]] : [];
+  const body = messages.slice(system.length);
+  let recent = keepRecent > 0 ? body.slice(-keepRecent) : [];
+  while (recent.length && recent[0]?.role === "tool") recent = recent.slice(1);
+  const summaryMsg = {
+    role: "user",
+    content: `[Summary of earlier conversation]
+${summary}`
+  };
+  return [...system, summaryMsg, ...recent];
+}
+async function compactSession(session, cfg, keepRecent = KEEP_RECENT) {
+  const msgs = session.messages;
+  const bodyLen = msgs.length - (msgs[0]?.role === "system" ? 1 : 0);
+  if (bodyLen <= keepRecent) return null;
+  const model = cfg.compactModel || COMPACT_MODEL;
+  const turn = await streamCompletion(
+    {
+      messages: [...msgs, { role: "user", content: SUMMARY_INSTRUCTION }],
+      model,
+      rag: false,
+      onText: () => {
+      }
+    },
+    cfg
+  );
+  const summary = turn.content.trim();
+  if (!summary) return null;
+  const before = msgs.length;
+  session.messages = buildCompacted(msgs, summary, keepRecent);
+  return { before, after: session.messages.length, summary, model };
+}
+function modeReminder(session) {
+  if (currentMode(session).gate === "planning") {
+    return "You are in PLAN MODE. Do not modify the project \u2014 edit_file/write_file are blocked, and run_bash requires the user's approval per command. Explore freely with read_file, list_files, and grep; resolve open questions with ask_choice. When you have a concrete plan, call present_plan \u2014 do not attempt any change before it is approved.";
+  }
+  if (session.activePlan) {
+    const steps = session.activePlan.steps.map((s, i) => `${i + 1}. ${s}`).join("\n");
+    return `APPROVED PLAN \u2014 "${session.activePlan.title}"
+${session.activePlan.summary}
+
+${steps}
+
+Execute this approved plan, following the steps above.`;
+  }
+  return null;
+}
+function summarize(args) {
+  const key = args.path ?? args.command ?? args.pattern;
+  return key != null ? String(key) : JSON.stringify(args);
+}
+function parseArgs(tc) {
+  try {
+    return tc.function.arguments ? JSON.parse(tc.function.arguments) : {};
+  } catch {
+    return null;
+  }
+}
+async function runToolCall(tc, session, approve) {
+  const args = parseArgs(tc);
+  if (args === null) return `ERROR: tool arguments were not valid JSON: ${tc.function.arguments}`;
+  process.stdout.write(`
+  \u23FA ${tc.function.name}(${summarize(args)})
+`);
+  const decision = decideTool(tc.function.name, session);
+  if (decision.kind === "block") {
+    console.log(`  \u2717 ${decision.message}`);
+    return decision.message;
+  }
+  if (decision.kind === "control_flow") {
+    return "ERROR: control-flow tool was routed to the executor.";
+  }
+  if (decision.approval === "ask") {
+    const ok = await approve(tc.function.name, describeToolCall(tc.function.name, args));
+    if (!ok) {
+      console.log("  \u2717 denied");
+      return "ERROR: the user denied permission to run this action.";
+    }
+  }
+  try {
+    const result = await executeTool(tc.function.name, args, session.cwd);
+    const firstLine = result.split("\n")[0] ?? "";
+    const more = result.length > firstLine.length ? " \u2026" : "";
+    console.log(`  \u21B3 ${firstLine.slice(0, 200)}${more}`);
+    return result;
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    console.log(`  \u2717 ${msg}`);
+    return `ERROR: ${msg}`;
+  }
+}
+async function runControlTool(tc, session, control) {
+  const args = parseArgs(tc);
+  if (args === null) {
+    return { toolResult: `ERROR: tool arguments were not valid JSON: ${tc.function.arguments}`, next: "continue" };
+  }
+  if (tc.function.name === "present_plan") {
+    return control.presentPlan(args, session);
+  }
+  return control.askChoice(args, session);
+}
+async function runTurn(session, cfg, approve, control) {
+  const tools = getToolSchemas();
+  for (let i = 0; i < MAX_ITERATIONS; i++) {
+    trimContext(session.messages);
+    const reminder = modeReminder(session);
+    const outgoing = reminder ? [...session.messages, { role: "system", content: reminder }] : session.messages;
+    const md = createMarkdownStream();
+    let turn;
+    try {
+      turn = await streamCompletion(
+        {
+          messages: outgoing,
+          tools,
+          model: session.model,
+          rag: false,
+          onText: (delta) => md.write(delta)
+        },
+        cfg
+      );
+    } catch (err) {
+      if (err instanceof ModelError) {
+        console.error(`
+[audacity] request failed (${err.status}): ${err.message}`);
+        if (err.status === 401) {
+          console.error("[audacity] run /key and enter a valid API key.");
+        }
+        return;
+      }
+      throw err;
+    }
+    md.end();
+    session.messages.push({
+      role: "assistant",
+      content: turn.content || null,
+      ...turn.toolCalls.length ? { tool_calls: turn.toolCalls } : {}
+    });
+    process.stdout.write("\n");
+    if (turn.finishReason !== "tool_calls" || turn.toolCalls.length === 0) {
+      return;
+    }
+    let stop = false;
+    for (const tc of turn.toolCalls) {
+      let content;
+      if (stop) {
+        content = "Skipped \u2014 returning to the prompt.";
+      } else if (isControlTool(tc.function.name)) {
+        const outcome = await runControlTool(tc, session, control);
+        content = outcome.toolResult;
+        if (outcome.next === "stop") stop = true;
+      } else {
+        content = await runToolCall(tc, session, approve);
+      }
+      session.messages.push({ role: "tool", tool_call_id: tc.id, content });
+    }
+    if (stop) return;
+  }
+  console.log(`
+[audacity] Reached the ${MAX_ITERATIONS}-iteration limit \u2014 stopping.`);
+}
+
+// src/config.ts
+import { chmod, mkdir as mkdir2, readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
+import { homedir } from "os";
+import { join } from "path";
+
+// src/interactive.ts
+import { emitKeypressEvents } from "readline";
+import { createInterface } from "readline/promises";
+
+// src/prompt.ts
+async function askHidden(rl2, question) {
+  const iface = rl2;
+  const output = iface.output;
+  const original = iface._writeToOutput?.bind(rl2);
+  output.write(question);
+  let muted = true;
+  iface._writeToOutput = (s) => {
+    if (!muted) output.write(s);
+  };
+  try {
+    const answer = await rl2.question("");
+    return answer.trim();
+  } finally {
+    iface._writeToOutput = original ?? ((s) => output.write(s));
+    muted = false;
+    output.write("\n");
+  }
+}
+async function pickFromList(rl2, title, items, current) {
+  console.log(title);
+  items.forEach((item, i) => {
+    const marker = item === current ? "  \u2190 current" : "";
+    console.log(`  ${String(i + 1).padStart(2)}. ${item}${marker}`);
+  });
+  const answer = (await rl2.question("Number (blank to cancel): ")).trim();
+  if (!answer) return void 0;
+  const n = Number(answer);
+  if (!Number.isInteger(n) || n < 1 || n > items.length) {
+    console.log("Invalid selection.");
+    return void 0;
+  }
+  return items[n - 1];
+}
+
+// src/interactive.ts
+var stdin = process.stdin;
+var stdout = process.stdout;
+var interactive = () => Boolean(stdin.isTTY && stdout.isTTY);
+var ANSI_SGR = new RegExp(`${String.fromCharCode(27)}\\[[0-9;]*m`, "g");
+var visibleLen = (s) => s.replace(ANSI_SGR, "").length;
+var keypressReady = false;
+function ensureKeypress() {
+  if (!keypressReady) {
+    emitKeypressEvents(stdin);
+    keypressReady = true;
+  }
+}
+function rawSession(handler) {
+  ensureKeypress();
+  return new Promise((resolve) => {
+    const onKey = (str2, key) => handler(key, str2, finish);
+    const finish = (value) => {
+      stdin.off("keypress", onKey);
+      if (stdin.isTTY) stdin.setRawMode(false);
+      stdin.pause();
+      resolve(value);
+    };
+    if (stdin.isTTY) stdin.setRawMode(true);
+    stdin.resume();
+    stdin.on("keypress", onKey);
+  });
+}
+var isPrintable = (str2, key) => Boolean(str2) && !key.ctrl && !key.meta && str2 !== "\r" && str2 !== "\n" && str2 >= " ";
+function wrapText(text, firstWidth, restWidth) {
+  const lines = [];
+  let cur = "";
+  const cap2 = () => Math.max(1, lines.length === 0 ? firstWidth : restWidth);
+  for (let word of text.split(" ")) {
+    const sep = cur.length > 0 ? " " : "";
+    if (cur.length + sep.length + word.length <= cap2()) {
+      cur += sep + word;
+      continue;
+    }
+    if (cur.length > 0) {
+      lines.push(cur);
+      cur = "";
+    }
+    while (word.length > cap2()) {
+      lines.push(word.slice(0, cap2()));
+      word = word.slice(cap2());
+    }
+    cur = word;
+  }
+  lines.push(cur);
+  return lines;
+}
+function deleteWord(text) {
+  return text.replace(/\s+$/, "").replace(/\S+$/, "");
+}
+async function readPromptLine(opts) {
+  if (!interactive()) return fallbackLine();
+  const { commands } = opts;
+  let buf = "";
+  let sel = 0;
+  let prevContentRows = 0;
+  const prompt = () => {
+    const label = opts.modeLabel?.() ?? "";
+    const badge = label ? `${yellow(`\u23F5 ${label}`)} ` : "";
+    return promptString(badge);
+  };
+  const promptW = () => visibleLen(prompt());
+  const matches = () => {
+    if (!buf.startsWith("/") || buf.includes(" ")) return [];
+    const token = buf.slice(1);
+    return commands.filter((c) => c.name.startsWith(token));
+  };
+  const wrapBuf = () => wrapText(buf, frameWidth() - promptW(), frameWidth() - 2);
+  const clearBox = () => {
+    if (prevContentRows > 0) stdout.write(`\x1B[${prevContentRows}A`);
+    stdout.write("\r\x1B[0J");
+  };
+  const render = () => {
+    clearBox();
+    const p = prompt();
+    const lines = wrapBuf();
+    const rows = [hRule(), ...lines.map((seg, i) => (i === 0 ? p : "  ") + seg), hRule()];
+    const items = matches();
+    if (items.length) {
+      if (sel >= items.length) sel = items.length - 1;
+      for (let i = 0; i < items.length; i++) {
+        const cmd = items[i];
+        const active = i === sel;
+        const marker = active ? cyan("\u203A") : " ";
+        const label = active ? bold(`/${cmd.name}`) : `/${cmd.name}`;
+        rows.push(`${marker} ${label}  ${dim(cmd.desc)}`);
+      }
+    }
+    stdout.write(rows.join("\n"));
+    const below = 1 + items.length;
+    stdout.write(`\x1B[${below}A\r`);
+    const lastPrefixW = lines.length === 1 ? promptW() : 2;
+    const col = lastPrefixW + (lines[lines.length - 1]?.length ?? 0);
+    if (col > 0) stdout.write(`\x1B[${col}C`);
+    prevContentRows = lines.length;
+  };
+  const finishRender = () => {
+    clearBox();
+    const p = prompt();
+    const lines = wrapBuf();
+    const rows = [hRule(), ...lines.map((seg, i) => (i === 0 ? p : "  ") + seg), hRule()];
+    stdout.write(`${rows.join("\n")}
+`);
+  };
+  render();
+  return rawSession((key, str2, done) => {
+    const items = matches();
+    const name = key.name;
+    const exitBelowBox = () => {
+      stdout.write("\x1B[1B\r\n");
+    };
+    if (key.ctrl && name === "c") {
+      if (buf) {
+        buf = "";
+        sel = 0;
+        render();
+        return;
+      }
+      exitBelowBox();
+      done(null);
+      return;
+    }
+    if (key.ctrl && name === "d") {
+      if (!buf) {
+        exitBelowBox();
+        done(null);
+      }
+      return;
+    }
+    if (name === "return" || name === "enter") {
+      if (items.length && buf.length > 1) buf = `/${items[sel].name}`;
+      finishRender();
+      done(buf);
+      return;
+    }
+    if (name === "tab" && key.shift) {
+      opts.onCycleMode?.();
+      render();
+      return;
+    }
+    if (name === "tab") {
+      if (items.length) {
+        buf = `/${items[sel].name} `;
+        sel = 0;
+        render();
+      }
+      return;
+    }
+    if (name === "up") {
+      if (items.length) {
+        sel = (sel - 1 + items.length) % items.length;
+        render();
+      }
+      return;
+    }
+    if (name === "down") {
+      if (items.length) {
+        sel = (sel + 1) % items.length;
+        render();
+      }
+      return;
+    }
+    if (key.meta && name === "backspace" || str2 === "\x1B\x7F") {
+      if (buf) {
+        buf = deleteWord(buf);
+        sel = 0;
+        render();
+      }
+      return;
+    }
+    if (name === "backspace") {
+      if (buf) {
+        buf = buf.slice(0, -1);
+        sel = 0;
+        render();
+      }
+      return;
+    }
+    if (name === "escape") {
+      if (buf) {
+        buf = "";
+        sel = 0;
+        render();
+      }
+      return;
+    }
+    if (isPrintable(str2, key)) {
+      buf += str2;
+      sel = 0;
+      render();
+    }
+  });
+}
+async function selectMenu(title, items, current) {
+  if (!items.length) return void 0;
+  if (!interactive()) return fallbackPick(title, items, current);
+  let sel = current ? items.indexOf(current) : 0;
+  if (sel < 0) sel = 0;
+  const rowsAvail = stdout.rows ? Math.max(3, stdout.rows - 6) : 12;
+  const view = Math.min(items.length, rowsAvail, 12);
+  let top = Math.min(Math.max(0, sel - Math.floor(view / 2)), Math.max(0, items.length - view));
+  console.log(title);
+  console.log(dim("  \u2191/\u2193 navigate \xB7 enter select \xB7 esc cancel"));
+  let drawn = 0;
+  const render = () => {
+    if (drawn > 0) stdout.write(`\x1B[${drawn}A`);
+    stdout.write("\r\x1B[0J");
+    if (sel < top) top = sel;
+    if (sel >= top + view) top = sel - view + 1;
+    for (let i = top; i < top + view; i++) {
+      const item = items[i];
+      const active = i === sel;
+      const prefix = active ? cyan("\u276F ") : "  ";
+      const label = active ? bold(item) : item;
+      const marker = item === current ? dim(" (current)") : "";
+      stdout.write(`${prefix}${label}${marker}
+`);
+    }
+    const footer = items.length > view ? dim(`  ${sel + 1}/${items.length}`) : "";
+    stdout.write(`${footer}
+`);
+    drawn = view + 1;
+  };
+  const cleanup = () => {
+    if (drawn > 0) stdout.write(`\x1B[${drawn + 2}A\r\x1B[0J`);
+  };
+  render();
+  return rawSession((key, _str, done) => {
+    const name = key.name;
+    if (name === "up") {
+      sel = (sel - 1 + items.length) % items.length;
+      render();
+      return;
+    }
+    if (name === "down") {
+      sel = (sel + 1) % items.length;
+      render();
+      return;
+    }
+    if (name === "return" || name === "enter") {
+      cleanup();
+      done(items[sel]);
+      return;
+    }
+    if (name === "escape" || key.ctrl && name === "c") {
+      cleanup();
+      done(void 0);
+    }
+  });
+}
+async function rawIndexMenu(header, entries, sepBefore) {
+  const n = entries.length;
+  let sel = 0;
+  console.log("");
+  console.log(header);
+  console.log(dim("  \u2191/\u2193 navigate \xB7 enter select"));
+  let drawn = 0;
+  const render = () => {
+    if (drawn > 0) stdout.write(`\x1B[${drawn}A`);
+    stdout.write("\r\x1B[0J");
+    let lines = 0;
+    entries.forEach((e, i) => {
+      if (sepBefore === i) {
+        stdout.write(`  ${dim("\u2500".repeat(24))}
+`);
+        lines++;
+      }
+      const active = i === sel;
+      const prefix = active ? cyan("\u276F ") : "  ";
+      stdout.write(`${prefix}${active ? bold(e.label) : e.label}
+`);
+      lines++;
+      if (e.detail) {
+        stdout.write(`      ${dim(e.detail)}
+`);
+        lines++;
+      }
+    });
+    drawn = lines;
+  };
+  const cleanup = () => {
+    if (drawn > 0) stdout.write(`\x1B[${drawn + 3}A\r\x1B[0J`);
+  };
+  render();
+  return rawSession((key, _str, done) => {
+    const name = key.name;
+    if (name === "up") {
+      sel = (sel - 1 + n) % n;
+      render();
+      return;
+    }
+    if (name === "down") {
+      sel = (sel + 1) % n;
+      render();
+      return;
+    }
+    if (name === "return" || name === "enter") {
+      cleanup();
+      done(sel);
+      return;
+    }
+    if (name === "escape" || key.ctrl && name === "c") {
+      cleanup();
+      done(null);
+    }
+  });
+}
+var TYPE_LABEL = "\u270E Type something else\u2026";
+var CHAT_LABEL = "\u{1F4AC} Chat about this";
+function choiceFromIndex(options, idx) {
+  if (idx >= 0 && idx < options.length) {
+    const o = options[idx];
+    return { kind: "option", index: idx, label: o.label, detail: o.detail };
+  }
+  return idx === options.length ? { kind: "free" } : { kind: "chat" };
+}
+async function pickChoice(question, options) {
+  const toResult = (idx2) => choiceFromIndex(options, idx2);
+  if (!interactive()) {
+    const labels = [...options.map((o) => o.label), TYPE_LABEL, CHAT_LABEL];
+    const chosen = await pickFromList(rl(), `? ${question}`, labels);
+    const idx2 = chosen ? labels.indexOf(chosen) : labels.length - 1;
+    return toResult(idx2 < 0 ? labels.length - 1 : idx2);
+  }
+  const entries = [
+    ...options.map((o) => ({ label: o.label, detail: o.detail })),
+    { label: TYPE_LABEL },
+    { label: CHAT_LABEL }
+  ];
+  const idx = await rawIndexMenu(`? ${bold(question)}`, entries, options.length);
+  return toResult(idx ?? options.length + 1);
+}
+var APPROVAL_ENTRIES = [
+  { label: "Approve \u2014 auto-approve edits", detail: "run the plan to completion without asking per edit" },
+  { label: "Approve \u2014 approve each edit", detail: "unblock changes, but confirm each one (y/N)" },
+  { label: "Approve with comments\u2026", detail: "auto-approve and pass extra guidance to the agent" },
+  { label: "Request changes\u2026", detail: "send feedback; the agent drafts a new plan" },
+  { label: "Chat about this", detail: "discuss instead \u2014 return to the prompt in normal mode" }
+];
+function approvalFromIndex(idx) {
+  switch (idx) {
+    case 0:
+      return { kind: "approve", autoApprove: true };
+    case 1:
+      return { kind: "approve", autoApprove: false };
+    case 2:
+      return { kind: "approveWithComments" };
+    case 3:
+      return { kind: "requestChanges" };
+    default:
+      return { kind: "chat" };
+  }
+}
+async function approvalPicker() {
+  const toChoice = (idx2) => approvalFromIndex(idx2);
+  if (!interactive()) {
+    const labels = APPROVAL_ENTRIES.map((e) => e.label);
+    const chosen = await pickFromList(rl(), "Review this plan:", labels);
+    const idx2 = chosen ? labels.indexOf(chosen) : labels.length - 1;
+    return toChoice(idx2 < 0 ? labels.length - 1 : idx2);
+  }
+  const idx = await rawIndexMenu(bold("Review this plan:"), APPROVAL_ENTRIES, 3);
+  return toChoice(idx ?? APPROVAL_ENTRIES.length - 1);
+}
+async function confirm(question) {
+  if (!interactive()) return fallbackConfirm(question);
+  stdout.write(question);
+  return rawSession((key, str2, done) => {
+    const c = (str2 ?? "").toLowerCase();
+    if (c === "y") {
+      stdout.write("y\n");
+      done(true);
+      return;
+    }
+    if (c === "n" || key.name === "return" || key.name === "enter" || key.ctrl && key.name === "c") {
+      stdout.write("n\n");
+      done(false);
+    }
+  });
+}
+async function readSecret(question) {
+  if (!interactive()) return fallbackSecret(question);
+  stdout.write(question);
+  let buf = "";
+  return rawSession((key, str2, done) => {
+    const name = key.name;
+    if (name === "return" || name === "enter") {
+      stdout.write("\n");
+      done(buf.trim());
+      return;
+    }
+    if (key.ctrl && name === "c") {
+      stdout.write("\n");
+      done("");
+      return;
+    }
+    if (name === "backspace") {
+      buf = buf.slice(0, -1);
+      return;
+    }
+    if (str2 && !key.ctrl && !key.meta && str2 >= " ") buf += str2;
+  });
+}
+var sharedRl = null;
+function rl() {
+  if (!sharedRl) sharedRl = createInterface({ input: stdin, output: stdout });
+  return sharedRl;
+}
+function fallbackLine() {
+  return new Promise((resolve) => {
+    const r = rl();
+    let settled = false;
+    const onClose = () => {
+      if (!settled) {
+        settled = true;
+        resolve(null);
+      }
+    };
+    r.once("close", onClose);
+    r.question(promptString()).then(
+      (ans) => {
+        if (!settled) {
+          settled = true;
+          r.off("close", onClose);
+          resolve(ans);
+        }
+      },
+      () => {
+        if (!settled) {
+          settled = true;
+          resolve(null);
+        }
+      }
+    );
+  });
+}
+function fallbackPick(title, items, current) {
+  return pickFromList(rl(), title, items, current);
+}
+async function fallbackConfirm(question) {
+  const a = (await rl().question(question)).trim().toLowerCase();
+  return a === "y" || a === "yes";
+}
+function fallbackSecret(question) {
+  return askHidden(rl(), question);
+}
+
+// src/config.ts
+var PROD_URL = "https://portal.audacityinvestments.com";
+var CONFIG_DIR = join(homedir(), ".audacity");
+var CONFIG_PATH = join(CONFIG_DIR, "config.json");
+async function readConfigFile() {
+  try {
+    const raw = await readFile2(CONFIG_PATH, "utf8");
+    const parsed = JSON.parse(raw);
+    return {
+      apiUrl: typeof parsed.apiUrl === "string" ? parsed.apiUrl : void 0,
+      apiKey: typeof parsed.apiKey === "string" ? parsed.apiKey : void 0,
+      model: typeof parsed.model === "string" ? parsed.model : void 0,
+      compactModel: typeof parsed.compactModel === "string" ? parsed.compactModel : void 0
+    };
+  } catch {
+    return {};
+  }
+}
+async function saveConfig(cfg) {
+  await mkdir2(CONFIG_DIR, { recursive: true });
+  await writeFile2(CONFIG_PATH, `${JSON.stringify(cfg, null, 2)}
+`, "utf8");
+  await chmod(CONFIG_PATH, 384);
+}
+async function loadConfig() {
+  return readConfigFile();
+}
+function resolveNonInteractive(partial) {
+  const apiKey = partial.apiKey;
+  if (!apiKey) {
+    throw new Error(
+      "No API key saved. Run `audacity` once (no arguments) to enter your audacity_api_\u2026 key \u2014 it will be saved to ~/.audacity/config.json and remembered."
+    );
+  }
+  return {
+    apiUrl: partial.apiUrl || PROD_URL,
+    apiKey,
+    model: partial.model || DEFAULT_MODEL
+  };
+}
+async function resolveInteractive(partial) {
+  let { apiUrl, apiKey, model } = partial;
+  let changed = false;
+  if (!apiUrl) {
+    apiUrl = PROD_URL;
+    changed = true;
+  }
+  if (!apiKey) {
+    apiKey = await readSecret("Paste your production audacity_api_ key: ");
+    if (!apiKey.startsWith("audacity_api_")) {
+      console.log("\u26A0  That doesn't look like an audacity_api_ key \u2014 using it anyway.");
+    }
+    changed = true;
+  }
+  if (!model) {
+    model = await selectMenu("Pick a model:", [...AVAILABLE_MODELS], DEFAULT_MODEL) ?? DEFAULT_MODEL;
+    changed = true;
+  }
+  const cfg = { apiUrl, apiKey, model };
+  if (changed) {
+    await saveConfig(cfg);
+    console.log(`\u2713 Saved to ${CONFIG_PATH} (chmod 600).`);
+  }
+  return cfg;
+}
+
+// src/plan.ts
+import { access, mkdir as mkdir3, readFile as readFile3, writeFile as writeFile3 } from "fs/promises";
+import path2 from "path";
+var PLANS_DIR = [".audacity", "plans"];
+function slugify(title) {
+  const slug = title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 50).replace(/-+$/g, "");
+  return slug || "plan";
+}
+function timestampPrefix(now) {
+  const p = (n, w = 2) => String(n).padStart(w, "0");
+  const date = `${now.getFullYear()}-${p(now.getMonth() + 1)}-${p(now.getDate())}`;
+  const time = `${p(now.getHours())}${p(now.getMinutes())}${p(now.getSeconds())}`;
+  return `${date}-${time}`;
+}
+function renderBody(input) {
+  const parts = [`## Summary
+${input.summary}`];
+  const steps = input.steps.map((s, i) => `${i + 1}. ${s}`).join("\n");
+  parts.push(`## Steps
+${steps}`);
+  if (input.files_to_change?.length) {
+    parts.push(`## Files to change
+${input.files_to_change.map((f) => `- \`${f}\``).join("\n")}`);
+  }
+  if (input.open_questions?.length) {
+    parts.push(`## Open questions
+${input.open_questions.map((q) => `- ${q}`).join("\n")}`);
+  }
+  return parts.join("\n\n");
+}
+function renderFrontmatter(input, status, created) {
+  const files = (input.files_to_change ?? []).map((f) => `  - ${f}`).join("\n");
+  return [
+    "---",
+    `title: ${input.title}`,
+    `status: ${status}`,
+    `created: ${created}`,
+    "approved: null",
+    files ? `files:
+${files}` : "files: []",
+    "---"
+  ].join("\n");
+}
+async function exists(p) {
+  try {
+    await access(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function writePlan(cwd, input, now = /* @__PURE__ */ new Date()) {
+  const dir = path2.join(cwd, ...PLANS_DIR);
+  const firstTime = !await exists(dir);
+  await mkdir3(dir, { recursive: true });
+  const file = path2.join(dir, `${timestampPrefix(now)}-${slugify(input.title)}.md`);
+  const created = now.toISOString();
+  const contents = `${renderFrontmatter(input, "proposed", created)}
+
+${renderBody(input)}
+`;
+  await writeFile3(file, contents, "utf8");
+  if (firstTime) {
+    console.log(
+      dim(
+        "  note: plans are written to .audacity/plans/ (not gitignored \u2014 useful in PRs/history). Add .audacity/ to .gitignore if you'd rather keep them local."
+      )
+    );
+  }
+  return file;
+}
+async function updatePlanStatus(file, status, now = /* @__PURE__ */ new Date()) {
+  const contents = await readFile3(file, "utf8");
+  let updated = contents.replace(/^status:.*$/m, `status: ${status}`);
+  const approvedValue = status === "approved" ? now.toISOString() : "null";
+  updated = updated.replace(/^approved:.*$/m, `approved: ${approvedValue}`);
+  await writeFile3(file, updated, "utf8");
+}
+
+// src/index.ts
+var modeIndexById = (id) => Math.max(0, AGENT_MODES.findIndex((m) => m.id === id));
+var SLASH_COMMANDS = [
+  { name: "model", desc: "switch the model (arrow-key picker)" },
+  { name: "rag", desc: "toggle RAG mode \u2014 /rag true | /rag false" },
+  { name: "plan", desc: "toggle plan mode \u2014 no changes without approval; draft a plan" },
+  { name: "auto", desc: "toggle auto-approve of tool actions" },
+  { name: "key", desc: "paste & save a new audacity_api_ key" },
+  { name: "cwd", desc: "print the working directory" },
+  { name: "compact", desc: "summarize older turns, keep recent context" },
+  { name: "clear", desc: "clear the conversation & screen" },
+  { name: "exit", desc: "quit audacity" }
+];
+var SYSTEM_PROMPT = `You are audacity, a command-line coding agent operating inside a user's project directory.
+You have tools to read, list, and search files, edit and write files, and run shell commands.
+Prefer reading before editing. Make minimal, correct changes. When you use edit_file, old_str must
+match exactly once \u2014 read the file first if unsure. Keep prose concise; let tool results speak.`;
+function newSession(cfg, cwd, autoApprove, plan = false) {
+  const modeIndex = plan ? modeIndexById("plan") : initialModeIndex(autoApprove);
+  return {
+    messages: [{ role: "system", content: SYSTEM_PROMPT }],
+    model: cfg.model,
+    cwd,
+    autoApprove: AGENT_MODES[modeIndex].autoApprove,
+    modeIndex,
+    ragMode: false
+  };
+}
+function renderPlan(input) {
+  const md = createMarkdownStream();
+  md.write(`
+# ${input.title}
+
+${input.summary}
+
+## Steps
+`);
+  input.steps.forEach((s, i) => md.write(`${i + 1}. ${s}
+`));
+  if (input.files_to_change?.length) {
+    md.write(`
+## Files to change
+`);
+    input.files_to_change.forEach((f) => md.write(`- \`${f}\`
+`));
+  }
+  if (input.open_questions?.length) {
+    md.write(`
+## Open questions
+`);
+    input.open_questions.forEach((q) => md.write(`- ${q}
+`));
+  }
+  md.end();
+  process.stdout.write("\n");
+}
+async function readLine() {
+  const raw = await readPromptLine({ commands: [] });
+  return (raw ?? "").trim();
+}
+function interactiveControls() {
+  return {
+    async presentPlan(input, session) {
+      const path4 = await writePlan(session.cwd, input);
+      session.activePlan = { path: path4, title: input.title, summary: input.summary, steps: input.steps };
+      renderPlan(input);
+      const choice = await approvalPicker();
+      switch (choice.kind) {
+        case "approve": {
+          await updatePlanStatus(path4, "approved");
+          setMode(session, initialModeIndex(choice.autoApprove));
+          console.log(
+            `  \u2713 plan approved \u2014 ${choice.autoApprove ? "auto-approving edits" : "approving each edit"}.`
+          );
+          return { toolResult: "Plan approved \u2014 proceed with execution.", next: "continue" };
+        }
+        case "approveWithComments": {
+          const comment = await readLine();
+          await updatePlanStatus(path4, "approved");
+          setMode(session, initialModeIndex(true));
+          console.log("  \u2713 plan approved (auto) with comments.");
+          return {
+            toolResult: `Plan approved (auto). Apply with these comments: ${comment || "(none)"}`,
+            next: "continue"
+          };
+        }
+        case "requestChanges": {
+          const feedback = await readLine();
+          await updatePlanStatus(path4, "rejected");
+          session.activePlan = void 0;
+          console.log("  \u21BB requesting changes \u2014 the agent will revise.");
+          return {
+            toolResult: `Plan rejected \u2014 revise per this feedback and call present_plan again: ${feedback || "(no feedback given)"}`,
+            next: "continue"
+          };
+        }
+        case "chat":
+        default: {
+          setMode(session, initialModeIndex(false));
+          session.activePlan = void 0;
+          console.log("  \u{1F4AC} switched to chat \u2014 plan left as proposed.");
+          return { toolResult: "User switched to chat to discuss instead of approving.", next: "stop" };
+        }
+      }
+    },
+    async askChoice(input) {
+      const options = Array.isArray(input.options) ? input.options : [];
+      if (options.length < 2) {
+        return { toolResult: "ERROR: ask_choice needs at least 2 options.", next: "continue" };
+      }
+      const result = await pickChoice(input.question, options);
+      switch (result.kind) {
+        case "option": {
+          const detail = result.detail ? ` (${result.detail})` : "";
+          console.log(`  \u2192 ${result.label}`);
+          return { toolResult: `Selected: "${result.label}"${detail}`, next: "continue" };
+        }
+        case "free": {
+          const text = await readLine();
+          return { toolResult: text || "(no input given)", next: "continue" };
+        }
+        case "chat":
+        default: {
+          const labels = options.map((o) => o.label).join(", ");
+          return {
+            toolResult: `User chose to discuss instead. Question was "${input.question}"; options were: ${labels}.`,
+            next: "stop"
+          };
+        }
+      }
+    }
+  };
+}
+function autoControls(yes) {
+  return {
+    async presentPlan(input, session) {
+      const path4 = await writePlan(session.cwd, input);
+      if (yes) {
+        session.activePlan = { path: path4, title: input.title, summary: input.summary, steps: input.steps };
+        await updatePlanStatus(path4, "approved");
+        setMode(session, initialModeIndex(true));
+        return { toolResult: "Plan approved (non-interactive -y) \u2014 proceed with execution.", next: "continue" };
+      }
+      return {
+        toolResult: "Plan not approved: this is a non-interactive run. Re-run with -y to auto-approve.",
+        next: "stop"
+      };
+    },
+    async askChoice() {
+      return {
+        toolResult: "ERROR: cannot ask the user a question in a non-interactive run. Make a reasonable assumption and proceed, stating it explicitly.",
+        next: "continue"
+      };
+    }
+  };
+}
+function banner(session, cfg) {
+  const host = (() => {
+    try {
+      return new URL(cfg.apiUrl).host;
+    } catch {
+      return cfg.apiUrl;
+    }
+  })();
+  printBanner();
+  console.log(`  coding agent \xB7 model ${session.model} \xB7 ${host}`);
+  console.log(`  cwd: ${session.cwd}`);
+  console.log(dim("  type / for commands \xB7 \u2191/\u2193 to pick \xB7 shift+tab cycles mode"));
+  console.log(dim(`  mode: ${currentMode(session).label}  (${AGENT_MODES.map((m) => m.label).join(" \u2192 ")})`));
+  console.log("");
+}
+async function handleSlash(line, session, cfg) {
+  const parts = line.slice(1).split(/\s+/);
+  const cmd = parts[0] ?? "";
+  const arg = parts.slice(1).join(" ").trim();
+  switch (cmd) {
+    case "exit":
+    case "quit":
+      return "exit";
+    case "clear":
+      session.messages = [{ role: "system", content: SYSTEM_PROMPT }];
+      session.conversationId = void 0;
+      console.clear();
+      banner(session, cfg);
+      console.log("Context cleared.");
+      return "continue";
+    case "cwd":
+      console.log(session.cwd);
+      return "continue";
+    case "compact": {
+      const summarizer = cfg.compactModel || COMPACT_MODEL;
+      process.stdout.write(dim(`Compacting conversation\u2026 (summarizer: ${summarizer})
+`));
+      try {
+        const res = await compactSession(session, cfg);
+        if (!res) {
+          console.log("Nothing to compact yet.");
+          return "continue";
+        }
+        console.log(dim(res.summary));
+        console.log(
+          `
+\u2713 Compacted ${res.before} \u2192 ${res.after} messages (summary + last ${KEEP_RECENT}).`
+        );
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        console.log(`[audacity] compact failed: ${msg}`);
+      }
+      return "continue";
+    }
+    case "plan": {
+      const target = currentMode(session).id === "plan" ? "normal" : "plan";
+      const mode = setMode(session, modeIndexById(target));
+      console.log(`Mode \u2192 ${mode.label}.`);
+      return "continue";
+    }
+    case "auto": {
+      const mode = setMode(session, initialModeIndex(!session.autoApprove));
+      console.log(`Mode \u2192 ${mode.label}.`);
+      return "continue";
+    }
+    case "key": {
+      const key = await readSecret("Paste your audacity_api_ key: ");
+      if (key) {
+        cfg.apiKey = key;
+        await saveConfig(cfg);
+        console.log("\u2713 key updated & saved.");
+      }
+      return "continue";
+    }
+    case "model": {
+      const chosen = arg || await selectMenu("Pick a model:", [...AVAILABLE_MODELS], session.model);
+      if (chosen) {
+        session.model = chosen;
+        cfg.model = chosen;
+        await saveConfig(cfg);
+        console.log(`Model \u2192 ${chosen} (saved).`);
+      }
+      return "continue";
+    }
+    case "rag": {
+      const v = arg.toLowerCase();
+      if (v === "true" || v === "on") {
+        session.ragMode = true;
+        console.log(
+          "RAG mode ON. Note: the agent/RAG endpoint (/v1/agent/chat/completions) arrives in Phase 2 \u2014 messages won't be sent until then. Use `/rag false` to resume the coding agent."
+        );
+      } else if (v === "false" || v === "off") {
+        session.ragMode = false;
+        console.log("RAG mode OFF \u2014 coding agent active.");
+      } else {
+        console.log(`RAG mode is ${session.ragMode ? "ON" : "OFF"}. Usage: /rag true | /rag false`);
+      }
+      return "continue";
+    }
+    default:
+      console.log(`Unknown command: /${cmd}. Try /model /rag /auto /key /cwd /compact /clear /exit`);
+      return "continue";
+  }
+}
+async function runRepl(cfg, cwd, autoApprove, plan) {
+  const session = newSession(cfg, cwd, autoApprove, plan);
+  banner(session, cfg);
+  const approve = async (_name, preview2) => {
+    console.log(`  \u26A0 approve:
+    ${preview2.replace(/\n/g, "\n    ")}`);
+    return confirm("  Allow? (y/N) ");
+  };
+  const control = interactiveControls();
+  for (; ; ) {
+    const raw = await readPromptLine({
+      commands: SLASH_COMMANDS,
+      // Default mode renders no badge; others show their label in the prompt.
+      modeLabel: () => currentMode(session).id === DEFAULT_MODE_ID ? "" : currentMode(session).label,
+      onCycleMode: () => cycleMode(session)
+    });
+    if (raw === null) break;
+    const line = raw.trim();
+    if (!line) continue;
+    if (line.startsWith("/")) {
+      if (await handleSlash(line, session, cfg) === "exit") break;
+      continue;
+    }
+    if (session.ragMode) {
+      console.log(
+        "[audacity] RAG mode (/rag true) arrives in Phase 2. Use `/rag false` to chat with the coding agent."
+      );
+      continue;
+    }
+    session.messages.push({ role: "user", content: line });
+    await runTurn(session, cfg, approve, control);
+  }
+}
+async function runOneShot(cfg, cwd, prompt, yes, plan) {
+  const session = newSession(cfg, cwd, yes, plan);
+  session.messages.push({ role: "user", content: prompt });
+  const approve = async () => yes;
+  await runTurn(session, cfg, approve, autoControls(yes));
+}
+var program = new Command();
+program.name("audacity").description("Audacity coding-agent CLI \u2014 talks only to your Audacity endpoints").argument("[prompt...]", "run a single prompt to completion, then exit").option("--cwd <path>", "working directory", process.cwd()).option("--model <id>", "model id (overrides config for this run)").option("-y, --yes", "auto-approve all tool actions", false).option("--plan", "start in plan mode (no changes without approval)", false).action(async (promptParts, opts) => {
+  const cwd = path3.resolve(opts.cwd);
+  const partial = await loadConfig();
+  if (opts.model) partial.model = opts.model;
+  const oneShotPrompt = promptParts.join(" ").trim();
+  if (oneShotPrompt) {
+    let cfg2;
+    try {
+      cfg2 = resolveNonInteractive(partial);
+    } catch (err) {
+      console.error(`[audacity] ${err.message}`);
+      process.exitCode = 1;
+      return;
+    }
+    await runOneShot(cfg2, cwd, oneShotPrompt, opts.yes, opts.plan);
+    return;
+  }
+  let cfg;
+  try {
+    cfg = await resolveInteractive(partial);
+  } catch (err) {
+    console.error(`[audacity] ${err.message}`);
+    process.exitCode = 1;
+    return;
+  }
+  await runRepl(cfg, cwd, opts.yes, opts.plan);
+});
+await program.parseAsync(process.argv);