@tuttiai/cli 0.14.0 → 0.16.0

package/dist/index.js

@@ -2,7 +2,7 @@
 
 // src/index.ts
 import { config } from "dotenv";
-import { createLogger as createLogger15 } from "@tuttiai/core";
+import { createLogger as createLogger16 } from "@tuttiai/core";
 import { Command } from "commander";
 
 // src/commands/init.ts
@@ -2603,8 +2603,8 @@ async function replayCommand(sessionId, opts = {}) {
   const rl = createInterface3({ input: process.stdin, output: process.stdout });
   try {
     while (true) {
-      const prompt3 = chalk17.cyan("replay [" + cursor + "/" + (messages.length - 1) + "]> ");
-      const raw = await rl.question(prompt3);
+      const prompt5 = chalk17.cyan("replay [" + cursor + "/" + (messages.length - 1) + "]> ");
+      const raw = await rl.question(prompt5);
       const input = raw.trim();
       if (!input) continue;
       const [cmd, ...args] = input.split(/\s+/);
@@ -3182,15 +3182,639 @@ function reviveSpanDates(span) {
   };
 }
 
+// src/commands/memory.ts
+import { writeFileSync as writeFileSync2 } from "fs";
+import chalk22 from "chalk";
+import Enquirer3 from "enquirer";
+import {
+  MemoryUserMemoryStore,
+  PostgresUserMemoryStore,
+  SecretsManager as SecretsManager10,
+  createLogger as createLogger15
+} from "@tuttiai/core";
+
+// src/commands/memory-render.ts
+import chalk21 from "chalk";
+function visibleLen2(s) {
+  return s.replace(/\u001b\[[0-9;]*m/g, "").length;
+}
+function pad5(s, len) {
+  const v = visibleLen2(s);
+  return v >= len ? s : s + " ".repeat(len - v);
+}
+function truncate(text, max) {
+  const oneLine = text.replace(/\s+/g, " ").trim();
+  return oneLine.length > max ? oneLine.slice(0, max - 1) + "\u2026" : oneLine;
+}
+function importanceStars(importance) {
+  if (importance === 3) return "\u2605\u2605\u2605";
+  if (importance === 2) return "\u2605\u2605\u2606";
+  return "\u2605\u2606\u2606";
+}
+function formatDate(d) {
+  const iso = d.toISOString();
+  return iso.slice(0, 10) + " " + iso.slice(11, 16);
+}
+function sortMemoriesForList(memories) {
+  return [...memories].sort((a, b) => {
+    if (a.importance !== b.importance) return b.importance - a.importance;
+    return b.created_at.getTime() - a.created_at.getTime();
+  });
+}
+function renderTable(memories, emptyMessage) {
+  if (memories.length === 0) return chalk21.dim(emptyMessage);
+  const lines = [];
+  lines.push("");
+  lines.push(
+    chalk21.dim(
+      "  " + pad5("ID", 10) + pad5("CONTENT", 62) + pad5("SOURCE", 12) + pad5("IMPORTANCE", 14) + "CREATED"
+    )
+  );
+  lines.push(chalk21.dim("  " + "\u2500".repeat(110)));
+  for (const m of memories) {
+    const idShort = m.id.slice(0, 8);
+    const content = truncate(m.content, 60);
+    const sourceColored = m.source === "explicit" ? chalk21.green("explicit") : chalk21.yellow("inferred");
+    const importance = importanceStars(m.importance);
+    const created = formatDate(m.created_at);
+    lines.push(
+      "  " + chalk21.bold(pad5(idShort, 10)) + pad5(content, 62) + pad5(sourceColored, 12) + pad5(importance, 14) + chalk21.dim(created)
+    );
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+function renderMemoryList(memories, userId) {
+  return renderTable(
+    sortMemoriesForList(memories),
+    'No memories stored for user "' + userId + '".'
+  );
+}
+function renderMemorySearch(memories, userId, query) {
+  const header = chalk21.dim(
+    "Search for " + chalk21.bold('"' + query + '"') + ' in user "' + userId + '" \u2014 ' + memories.length + " result" + (memories.length === 1 ? "" : "s")
+  );
+  const body = renderTable(
+    memories,
+    'No memories matching "' + query + '" for user "' + userId + '".'
+  );
+  return header + body;
+}
+function renderMemoryAdded(memory) {
+  return chalk21.green("\u2713") + " Stored memory " + chalk21.bold(memory.id.slice(0, 8)) + chalk21.dim(" (" + memory.source + ", " + importanceStars(memory.importance) + ")");
+}
+function renderMemoryDeleted(memoryId) {
+  return chalk21.green("\u2713") + " Deleted memory " + chalk21.bold(memoryId.slice(0, 8));
+}
+function renderMemoryCleared(userId, count) {
+  return chalk21.green("\u2713") + " Deleted " + chalk21.bold(String(count)) + " memor" + (count === 1 ? "y" : "ies") + ' for user "' + userId + '"';
+}
+function exportMemoriesJson(memories) {
+  return JSON.stringify(memories, null, 2) + "\n";
+}
+function exportMemoriesCsv(memories) {
+  const headers = [
+    "id",
+    "user_id",
+    "content",
+    "source",
+    "importance",
+    "tags",
+    "created_at",
+    "last_accessed_at",
+    "expires_at"
+  ];
+  const rows = [headers.join(",")];
+  for (const m of memories) {
+    rows.push(
+      [
+        m.id,
+        m.user_id,
+        m.content,
+        m.source,
+        String(m.importance),
+        m.tags?.join(";") ?? "",
+        m.created_at.toISOString(),
+        m.last_accessed_at?.toISOString() ?? "",
+        m.expires_at?.toISOString() ?? ""
+      ].map(csvEscape).join(",")
+    );
+  }
+  return rows.join("\n") + "\n";
+}
+function csvEscape(field) {
+  if (/[",\n\r]/.test(field)) {
+    return '"' + field.replace(/"/g, '""') + '"';
+  }
+  return field;
+}
+
+// src/commands/memory.ts
+var logger15 = createLogger15("tutti-cli");
+var { prompt: prompt3 } = Enquirer3;
+function resolveStore3() {
+  const pgUrl = SecretsManager10.optional("TUTTI_PG_URL");
+  if (pgUrl) {
+    return new PostgresUserMemoryStore({ connection_string: pgUrl });
+  }
+  logger15.warn(
+    "TUTTI_PG_URL not set \u2014 using in-memory store (memories are ephemeral; this command will appear to do nothing useful)"
+  );
+  return new MemoryUserMemoryStore();
+}
+async function closeStore2(store) {
+  if (typeof store.close === "function") {
+    await store.close();
+  }
+}
+function requireUser(opts) {
+  if (!opts.user || opts.user.trim() === "") {
+    console.error(chalk22.red("--user <user-id> is required"));
+    process.exit(1);
+  }
+  return opts.user.trim();
+}
+function parseImportance(raw) {
+  if (raw === void 0) return 2;
+  if (raw === "1") return 1;
+  if (raw === "2") return 2;
+  if (raw === "3") return 3;
+  console.error(chalk22.red("--importance must be 1, 2, or 3"));
+  process.exit(1);
+}
+async function memoryListCommand(opts) {
+  const userId = requireUser(opts);
+  const store = resolveStore3();
+  try {
+    const memories = await store.list(userId);
+    console.log(renderMemoryList(memories, userId));
+  } finally {
+    await closeStore2(store);
+  }
+}
+async function memorySearchCommand(query, opts) {
+  const userId = requireUser(opts);
+  if (query.trim() === "") {
+    console.error(chalk22.red("Search query is required"));
+    process.exit(1);
+  }
+  const store = resolveStore3();
+  try {
+    const memories = await store.search(userId, query);
+    console.log(renderMemorySearch(memories, userId, query));
+  } finally {
+    await closeStore2(store);
+  }
+}
+async function memoryAddCommand(content, opts) {
+  const userId = requireUser(opts);
+  if (content.trim() === "") {
+    console.error(chalk22.red("Memory content is required"));
+    process.exit(1);
+  }
+  const importance = parseImportance(opts.importance);
+  const store = resolveStore3();
+  try {
+    const stored = await store.store(userId, content.trim(), {
+      source: "explicit",
+      importance
+    });
+    console.log(renderMemoryAdded(stored));
+  } finally {
+    await closeStore2(store);
+  }
+}
+async function memoryDeleteCommand(memoryId, opts) {
+  requireUser(opts);
+  const store = resolveStore3();
+  try {
+    await store.delete(memoryId);
+    console.log(renderMemoryDeleted(memoryId));
+  } finally {
+    await closeStore2(store);
+  }
+}
+async function memoryClearCommand(opts) {
+  const userId = requireUser(opts);
+  const store = resolveStore3();
+  try {
+    const memories = await store.list(userId);
+    if (memories.length === 0) {
+      console.log(chalk22.dim('No memories stored for user "' + userId + '".'));
+      return;
+    }
+    const { confirm } = await prompt3({
+      type: "confirm",
+      name: "confirm",
+      message: "Delete all " + memories.length + ' memories for user "' + userId + '"?',
+      initial: false
+    });
+    if (!confirm) {
+      console.log(chalk22.dim("  Cancelled."));
+      return;
+    }
+    await store.deleteAll(userId);
+    console.log(renderMemoryCleared(userId, memories.length));
+  } finally {
+    await closeStore2(store);
+  }
+}
+async function memoryExportCommand(opts) {
+  const userId = requireUser(opts);
+  const format = (opts.format ?? "json").toLowerCase();
+  if (format !== "json" && format !== "csv") {
+    console.error(chalk22.red("--format must be 'json' or 'csv'"));
+    process.exit(1);
+  }
+  const store = resolveStore3();
+  try {
+    const memories = await store.list(userId);
+    const body = format === "json" ? exportMemoriesJson(memories) : exportMemoriesCsv(memories);
+    if (opts.out) {
+      writeFileSync2(opts.out, body, "utf8");
+      console.log(
+        chalk22.green("\u2713") + " Wrote " + chalk22.bold(String(memories.length)) + " memor" + (memories.length === 1 ? "y" : "ies") + " to " + chalk22.bold(opts.out)
+      );
+    } else {
+      process.stdout.write(body);
+    }
+  } finally {
+    await closeStore2(store);
+  }
+}
+
+// src/commands/interrupts.ts
+import chalk24 from "chalk";
+import Enquirer4 from "enquirer";
+import { SecretsManager as SecretsManager11 } from "@tuttiai/core";
+
+// src/commands/interrupts-render.ts
+import chalk23 from "chalk";
+function visibleLen3(s) {
+  return s.replace(/\u001b\[[0-9;]*m/g, "").length;
+}
+function pad6(s, len) {
+  const v = visibleLen3(s);
+  return v >= len ? s : s + " ".repeat(len - v);
+}
+function truncate2(text, max) {
+  const oneLine = text.replace(/\s+/g, " ").trim();
+  return oneLine.length > max ? oneLine.slice(0, max - 1) + "\u2026" : oneLine;
+}
+function formatIsoShort(d) {
+  const iso = d.toISOString();
+  return iso.slice(0, 10) + " " + iso.slice(11, 19);
+}
+function formatRelativeTime(requested_at, now = /* @__PURE__ */ new Date()) {
+  const diffMs = now.getTime() - requested_at.getTime();
+  if (diffMs < 0) return "now";
+  const s = Math.floor(diffMs / 1e3);
+  if (s < 60) return s + "s ago";
+  const m = Math.floor(s / 60);
+  if (m < 60) return m + "m ago";
+  const h = Math.floor(m / 60);
+  if (h < 24) return h + "h ago";
+  const d = Math.floor(h / 24);
+  return d + "d ago";
+}
+function truncateArgs(tool_args, max = 80) {
+  let json;
+  try {
+    json = JSON.stringify(tool_args);
+  } catch {
+    json = String(tool_args);
+  }
+  if (json === void 0) return "";
+  return truncate2(json, max);
+}
+function renderInterruptsList(interrupts, now = /* @__PURE__ */ new Date()) {
+  if (interrupts.length === 0) {
+    return chalk23.dim("No pending interrupts.");
+  }
+  const lines = [];
+  lines.push("");
+  lines.push(
+    chalk23.dim(
+      "  " + pad6("ID", 10) + pad6("SESSION", 14) + pad6("TOOL", 22) + pad6("ARGS", 52) + "AGE"
+    )
+  );
+  lines.push(chalk23.dim("  " + "\u2500".repeat(110)));
+  for (const r of interrupts) {
+    const idShort = r.interrupt_id.slice(0, 8);
+    const sessionShort = r.session_id.slice(0, 12);
+    const toolName = truncate2(r.tool_name, 20);
+    const argsPreview = truncateArgs(r.tool_args, 50);
+    const age = formatRelativeTime(r.requested_at, now);
+    lines.push(
+      "  " + chalk23.bold(pad6(idShort, 10)) + pad6(sessionShort, 14) + pad6(chalk23.cyan(toolName), 22) + pad6(chalk23.dim(argsPreview), 52) + chalk23.dim(age)
+    );
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+function renderInterruptDetail(interrupt, now = /* @__PURE__ */ new Date()) {
+  const lines = [];
+  lines.push("");
+  lines.push(chalk23.bold("Interrupt ") + chalk23.dim(interrupt.interrupt_id));
+  lines.push(chalk23.dim("\u2500".repeat(60)));
+  lines.push(chalk23.dim("Session:     ") + interrupt.session_id);
+  lines.push(chalk23.dim("Tool:        ") + chalk23.cyan(interrupt.tool_name));
+  lines.push(
+    chalk23.dim("Requested:   ") + formatIsoShort(interrupt.requested_at) + chalk23.dim(" (" + formatRelativeTime(interrupt.requested_at, now) + ")")
+  );
+  lines.push(chalk23.dim("Status:      ") + colorStatus2(interrupt.status));
+  if (interrupt.resolved_at) {
+    lines.push(chalk23.dim("Resolved:    ") + formatIsoShort(interrupt.resolved_at));
+  }
+  if (interrupt.resolved_by) {
+    lines.push(chalk23.dim("Resolved by: ") + interrupt.resolved_by);
+  }
+  if (interrupt.denial_reason) {
+    lines.push(chalk23.dim("Reason:      ") + interrupt.denial_reason);
+  }
+  lines.push("");
+  lines.push(chalk23.dim("Arguments:"));
+  lines.push(prettyJson(interrupt.tool_args));
+  lines.push("");
+  return lines.join("\n");
+}
+function prettyJson(value) {
+  try {
+    return JSON.stringify(value, null, 2);
+  } catch {
+    return String(value);
+  }
+}
+function colorStatus2(status) {
+  if (status === "approved") return chalk23.green("approved");
+  if (status === "denied") return chalk23.red("denied");
+  return chalk23.yellow("pending");
+}
+function renderApproved(interrupt) {
+  return chalk23.green("\u2713") + " Approved " + chalk23.bold(interrupt.interrupt_id.slice(0, 8)) + chalk23.dim(" (" + interrupt.tool_name + ")") + (interrupt.resolved_by ? chalk23.dim(" by " + interrupt.resolved_by) : "");
+}
+function renderDenied(interrupt) {
+  return chalk23.red("\u2717") + " Denied " + chalk23.bold(interrupt.interrupt_id.slice(0, 8)) + chalk23.dim(" (" + interrupt.tool_name + ")") + (interrupt.denial_reason ? chalk23.dim(' \u2014 "' + interrupt.denial_reason + '"') : "");
+}
+
+// src/commands/interrupts.ts
+var { prompt: prompt4 } = Enquirer4;
+var DEFAULT_SERVER_URL2 = "http://127.0.0.1:3847";
+var POLL_INTERVAL_MS = 2e3;
+function resolveUrl2(opts) {
+  return opts.url ?? SecretsManager11.optional("TUTTI_SERVER_URL") ?? DEFAULT_SERVER_URL2;
+}
+function resolveAuthHeader2(opts) {
+  const key = opts.apiKey ?? SecretsManager11.optional("TUTTI_API_KEY");
+  return key ? { Authorization: "Bearer " + key } : {};
+}
+function explainConnectionError2(err, baseUrl) {
+  const msg = err instanceof Error ? err.message : String(err);
+  console.error(chalk24.red("Failed to reach Tutti server at " + baseUrl));
+  console.error(chalk24.dim("  " + msg));
+  console.error(
+    chalk24.dim("  Is `tutti-ai serve` running? Set --url or TUTTI_SERVER_URL to override.")
+  );
+  process.exit(1);
+}
+function reviveInterrupt(wire) {
+  const req = {
+    interrupt_id: wire["interrupt_id"],
+    session_id: wire["session_id"],
+    tool_name: wire["tool_name"],
+    tool_args: wire["tool_args"],
+    requested_at: new Date(wire["requested_at"]),
+    status: wire["status"]
+  };
+  if (typeof wire["resolved_at"] === "string") {
+    req.resolved_at = new Date(wire["resolved_at"]);
+  }
+  if (typeof wire["resolved_by"] === "string") {
+    req.resolved_by = wire["resolved_by"];
+  }
+  if (typeof wire["denial_reason"] === "string") {
+    req.denial_reason = wire["denial_reason"];
+  }
+  return req;
+}
+async function httpJson(opts, method, path, body) {
+  const baseUrl = resolveUrl2(opts);
+  const url = baseUrl.replace(/\/$/, "") + path;
+  let res;
+  try {
+    res = await fetch(url, {
+      method,
+      headers: {
+        "Content-Type": "application/json",
+        ...resolveAuthHeader2(opts)
+      },
+      ...body !== void 0 ? { body: JSON.stringify(body) } : {}
+    });
+  } catch (err) {
+    explainConnectionError2(err, baseUrl);
+  }
+  const text = await res.text();
+  const parsed = text === "" ? null : JSON.parse(text);
+  return { status: res.status, body: parsed };
+}
+async function fetchPending(opts) {
+  const { status, body } = await httpJson(
+    opts,
+    "GET",
+    "/interrupts/pending"
+  );
+  if (status === 401) {
+    console.error(chalk24.red("Unauthorized \u2014 set --api-key or TUTTI_API_KEY."));
+    process.exit(1);
+  }
+  if (status === 503) {
+    console.error(
+      chalk24.red(
+        "The server has no InterruptStore configured. Start `tutti-ai serve` with an interrupt store attached."
+      )
+    );
+    process.exit(1);
+  }
+  if (status < 200 || status >= 300 || !("interrupts" in body)) {
+    console.error(chalk24.red("Unexpected server response: " + status));
+    process.exit(1);
+  }
+  return body.interrupts.map(reviveInterrupt);
+}
+async function postResolve(opts, interruptId, action, payload) {
+  const { status, body } = await httpJson(
+    opts,
+    "POST",
+    "/interrupts/" + encodeURIComponent(interruptId) + "/" + action,
+    payload
+  );
+  if (status === 401) {
+    console.error(chalk24.red("Unauthorized \u2014 set --api-key or TUTTI_API_KEY."));
+    process.exit(1);
+  }
+  if (status === 404) {
+    console.error(chalk24.red('Interrupt "' + interruptId + '" not found.'));
+    process.exit(1);
+  }
+  if (status === 409) {
+    const current = body.current;
+    const currentStatus = current && typeof current["status"] === "string" ? current["status"] : "resolved";
+    console.error(
+      chalk24.red("Interrupt already " + currentStatus + " \u2014 refusing to override.")
+    );
+    process.exit(1);
+  }
+  if (status < 200 || status >= 300) {
+    console.error(chalk24.red("Unexpected server response: " + status));
+    process.exit(1);
+  }
+  return reviveInterrupt(body);
+}
+async function interruptsListCommand(opts) {
+  const pending = await fetchPending(opts);
+  console.log(renderInterruptsList(pending));
+}
+async function interruptsApproveCommand(interruptId, opts) {
+  const resolved = await postResolve(opts, interruptId, "approve", {
+    ...opts.resolvedBy !== void 0 ? { resolved_by: opts.resolvedBy } : {}
+  });
+  console.log(renderApproved(resolved));
+}
+async function interruptsDenyCommand(interruptId, opts) {
+  const resolved = await postResolve(opts, interruptId, "deny", {
+    ...opts.reason !== void 0 ? { reason: opts.reason } : {},
+    ...opts.resolvedBy !== void 0 ? { resolved_by: opts.resolvedBy } : {}
+  });
+  console.log(renderDenied(resolved));
+}
+function clearScreen() {
+  process.stdout.write("\x1B[2J\x1B[H");
+}
+function readKey() {
+  const input = process.stdin;
+  if (!input.isTTY) return Promise.resolve(null);
+  return new Promise((resolve18) => {
+    input.setRawMode(true);
+    input.resume();
+    input.setEncoding("utf8");
+    const onData = (data) => {
+      input.removeListener("data", onData);
+      input.setRawMode(false);
+      input.pause();
+      resolve18(data);
+    };
+    input.on("data", onData);
+  });
+}
+async function readKeyOrTimeout(ms) {
+  let timer;
+  const timeout = new Promise((resolve18) => {
+    timer = setTimeout(() => resolve18(null), ms);
+  });
+  try {
+    const winner = await Promise.race([readKey(), timeout]);
+    return winner;
+  } finally {
+    if (timer) clearTimeout(timer);
+  }
+}
+async function interruptsTUICommand(opts) {
+  if (!process.stdin.isTTY) {
+    await interruptsListCommand(opts);
+    return;
+  }
+  const sigint = () => {
+    if (process.stdin.isTTY) process.stdin.setRawMode(false);
+    process.stdout.write("\n");
+    process.exit(0);
+  };
+  process.on("SIGINT", sigint);
+  try {
+    for (; ; ) {
+      const pending = await fetchPending(opts);
+      clearScreen();
+      console.log(
+        chalk24.bold("Tutti \u2014 pending interrupts") + chalk24.dim("   (auto-refresh every " + POLL_INTERVAL_MS / 1e3 + "s)")
+      );
+      console.log(renderInterruptsList(pending));
+      if (pending.length > 0) {
+        console.log(
+          chalk24.dim(
+            "Press a number to inspect, 'r' to refresh, 'q' to quit."
+          )
+        );
+      } else {
+        console.log(chalk24.dim("Press 'r' to refresh, 'q' to quit."));
+      }
+      const indexed = pending.slice(0, 9);
+      const key = await readKeyOrTimeout(POLL_INTERVAL_MS);
+      if (key === null) continue;
+      if (key === "q" || key === "") return;
+      if (key === "r") continue;
+      const digit = parseInt(key, 10);
+      if (!Number.isNaN(digit) && digit >= 1 && digit <= indexed.length) {
+        const chosen = indexed[digit - 1];
+        const shouldContinue = await runDetailView(opts, chosen);
+        if (!shouldContinue) return;
+      }
+    }
+  } finally {
+    process.off("SIGINT", sigint);
+    if (process.stdin.isTTY) process.stdin.setRawMode(false);
+  }
+}
+async function runDetailView(opts, interrupt) {
+  clearScreen();
+  console.log(renderInterruptDetail(interrupt));
+  console.log(
+    chalk24.dim(
+      "Press 'a' to approve, 'd' to deny, 'q' to go back to the list."
+    )
+  );
+  const key = await readKey();
+  if (key === null || key === "q" || key === "") return true;
+  if (key === "a") {
+    const resolved = await postResolve(opts, interrupt.interrupt_id, "approve", {});
+    clearScreen();
+    console.log(renderApproved(resolved));
+    await pause();
+    return true;
+  }
+  if (key === "d") {
+    const { reason } = await prompt4({
+      type: "input",
+      name: "reason",
+      message: "Reason (optional):"
+    });
+    const payload = {};
+    if (reason && reason.trim() !== "") payload["reason"] = reason.trim();
+    const resolved = await postResolve(
+      opts,
+      interrupt.interrupt_id,
+      "deny",
+      payload
+    );
+    clearScreen();
+    console.log(renderDenied(resolved));
+    await pause();
+    return true;
+  }
+  return true;
+}
+async function pause() {
+  console.log(chalk24.dim("\nPress any key to continue..."));
+  await readKey();
+}
+
 // src/index.ts
 config();
-var logger15 = createLogger15("tutti-cli");
+var logger16 = createLogger16("tutti-cli");
 process.on("unhandledRejection", (reason) => {
-  logger15.error({ error: reason instanceof Error ? reason.message : String(reason) }, "Unhandled rejection");
+  logger16.error({ error: reason instanceof Error ? reason.message : String(reason) }, "Unhandled rejection");
   process.exit(1);
 });
 process.on("uncaughtException", (err) => {
-  logger15.error({ error: err.message }, "Fatal error");
+  logger16.error({ error: err.message }, "Fatal error");
   process.exit(1);
 });
 var program = new Command();
@@ -3306,5 +3930,60 @@ tracesCmd.command("tail").description("Live-tail spans as they are emitted (Ctrl
   };
   await tracesTailCommand(resolved);
 });
+var memoryCmd = program.command("memory").description("Manage per-user memories (uses TUTTI_PG_URL like the runtime)");
+memoryCmd.command("list").description("Show every memory for a user, sorted by importance + recency").requiredOption("--user <user-id>", "End-user identifier").action(async (opts) => {
+  await memoryListCommand({ user: opts.user });
+});
+memoryCmd.command("search <query>").description("Search a user's memories by relevance").requiredOption("--user <user-id>", "End-user identifier").action(async (query, opts) => {
+  await memorySearchCommand(query, { user: opts.user });
+});
+memoryCmd.command("add <content>").description("Manually store a memory for a user").requiredOption("--user <user-id>", "End-user identifier").option("--importance <n>", "Importance: 1 (low), 2 (normal), 3 (high)", "2").action(async (content, opts) => {
+  await memoryAddCommand(content, {
+    user: opts.user,
+    ...opts.importance !== void 0 ? { importance: opts.importance } : {}
+  });
+});
+memoryCmd.command("delete <memory-id>").description("Delete a specific memory by id").requiredOption("--user <user-id>", "End-user identifier").action(async (memoryId, opts) => {
+  await memoryDeleteCommand(memoryId, { user: opts.user });
+});
+memoryCmd.command("clear").description("Delete every memory for a user (prompts for confirmation)").requiredOption("--user <user-id>", "End-user identifier").action(async (opts) => {
+  await memoryClearCommand({ user: opts.user });
+});
+memoryCmd.command("export").description("Export every memory for a user as JSON or CSV").requiredOption("--user <user-id>", "End-user identifier").option("--format <fmt>", "Output format: json | csv", "json").option("-o, --out <path>", "Write to file instead of stdout").action(async (opts) => {
+  await memoryExportCommand({
+    user: opts.user,
+    ...opts.format !== void 0 ? { format: opts.format } : {},
+    ...opts.out !== void 0 ? { out: opts.out } : {}
+  });
+});
+function toInterruptsOptions(raw) {
+  return {
+    ...raw.url !== void 0 ? { url: raw.url } : {},
+    ...raw.apiKey !== void 0 ? { apiKey: raw.apiKey } : {}
+  };
+}
+var interruptsCmd = program.command("interrupts").description("Review and resolve approval-gated tool calls");
+interruptsCmd.option("-u, --url <url>", "Server URL (default: http://127.0.0.1:3847)").option("-k, --api-key <key>", "Bearer token (default: TUTTI_API_KEY env)").action(async (opts) => {
+  await interruptsTUICommand(toInterruptsOptions(opts));
+});
+interruptsCmd.command("list").description("Print pending interrupts as a table and exit (script-friendly)").option("-u, --url <url>", "Server URL (default: http://127.0.0.1:3847)").option("-k, --api-key <key>", "Bearer token (default: TUTTI_API_KEY env)").action(async (opts) => {
+  await interruptsListCommand(toInterruptsOptions(opts));
+});
+interruptsCmd.command("approve <interrupt-id>").description("Approve an interrupt directly").option("-u, --url <url>", "Server URL (default: http://127.0.0.1:3847)").option("-k, --api-key <key>", "Bearer token (default: TUTTI_API_KEY env)").option("--by <name>", "Reviewer identifier (resolved_by field)").action(async (id, opts) => {
+  await interruptsApproveCommand(id, {
+    ...toInterruptsOptions(opts),
+    ...opts.by !== void 0 ? { resolvedBy: opts.by } : {}
+  });
+});
+interruptsCmd.command("deny <interrupt-id>").description("Deny an interrupt directly").option("-u, --url <url>", "Server URL (default: http://127.0.0.1:3847)").option("-k, --api-key <key>", "Bearer token (default: TUTTI_API_KEY env)").option("--reason <text>", "Free-text denial reason").option("--by <name>", "Reviewer identifier (resolved_by field)").action(async (id, opts) => {
+  await interruptsDenyCommand(id, {
+    ...toInterruptsOptions(opts),
+    ...opts.reason !== void 0 ? { reason: opts.reason } : {},
+    ...opts.by !== void 0 ? { resolvedBy: opts.by } : {}
+  });
+});
+program.command("approve").description("Alias for `tutti-ai interrupts` \u2014 interactive approval TUI").option("-u, --url <url>", "Server URL (default: http://127.0.0.1:3847)").option("-k, --api-key <key>", "Bearer token (default: TUTTI_API_KEY env)").action(async (opts) => {
+  await interruptsTUICommand(toInterruptsOptions(opts));
+});
 program.parse();
 //# sourceMappingURL=index.js.map