@tuttiai/cli 0.14.0 → 0.15.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 prompt4 = chalk17.cyan("replay [" + cursor + "/" + (messages.length - 1) + "]> ");
+      const raw = await rl.question(prompt4);
       const input = raw.trim();
       if (!input) continue;
       const [cmd, ...args] = input.split(/\s+/);
@@ -3182,15 +3182,276 @@ 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/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 +3567,31 @@ 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 } : {}
+  });
+});
 program.parse();
 //# sourceMappingURL=index.js.map