project-athena 0.2.1 → 0.4.0

package/dist/memory-VSVNLEJC.js

@@ -0,0 +1,393 @@
+#!/usr/bin/env node
+import {
+  MEMORY_FILES,
+  MEMORY_KINDS,
+  MEMORY_STATUSES,
+  addMemory,
+  confirmMemory,
+  forgetMemory,
+  getMemory,
+  listMemory,
+  recallMemory,
+  searchMemory,
+  supersedeMemory,
+  updateMemory
+} from "./chunk-TDNZ2RYA.js";
+import "./chunk-3IS2X2Z7.js";
+import {
+  c,
+  dim,
+  heading,
+  isJson,
+  json,
+  line,
+  ok,
+  relativeTime,
+  sym,
+  warn
+} from "./chunk-Z6QWMJLK.js";
+import {
+  requireProjectRoot
+} from "./chunk-XFN7UZCS.js";
+import "./chunk-KBO7XRBW.js";
+import "./chunk-SVTEJYMS.js";
+import "./chunk-QCC4VJUH.js";
+import "./chunk-JCGDR4UV.js";
+import "./chunk-673EPYYH.js";
+import "./chunk-FQEGEVLY.js";
+import "./chunk-2DY4PUR4.js";
+import "./chunk-IQQBAWSM.js";
+import {
+  AthenaError
+} from "./chunk-AD4OZCU2.js";
+import "./chunk-XW3MLHI2.js";
+import "./chunk-EUPETUWA.js";
+
+// src/cli/commands/memory.ts
+import { createInterface } from "readline/promises";
+var ID_RE = /^m-[a-z0-9]{4,16}$/;
+function parseKind(k) {
+  if (k === void 0) return void 0;
+  if (!MEMORY_KINDS.includes(k)) throw new AthenaError(`Unknown memory kind: ${k}`, `Use one of: ${MEMORY_KINDS.join(", ")}`);
+  return k;
+}
+function parseStatus(s) {
+  if (s === void 0) return void 0;
+  if (!MEMORY_STATUSES.includes(s)) throw new AthenaError(`Unknown memory status: ${s}`, `Use one of: ${MEMORY_STATUSES.join(", ")}`);
+  return s;
+}
+function checkIds(ids) {
+  for (const id of ids) if (!ID_RE.test(id)) throw new AthenaError(`Invalid memory id: ${id}`, "Ids look like m-1a2b3c; list them with `athena memory list`.");
+}
+async function readStdin() {
+  if (process.stdin.isTTY) throw new AthenaError("`--details -` reads the details from stdin, but stdin is a terminal.", "Pipe the text in, e.g. `cat notes.txt | athena memory add \u2026 --details -`.");
+  const chunks = [];
+  for await (const chunk of process.stdin) chunks.push(chunk);
+  return Buffer.concat(chunks).toString("utf8");
+}
+var plural = (n, word, many = `${word}s`) => `${n} ${n === 1 ? word : many}`;
+var trunc = (s, n) => s.length > n ? `${s.slice(0, n - 1)}\u2026` : s;
+var pad = (s, n) => s + " ".repeat(Math.max(0, n - s.length));
+function labelOf(v) {
+  if (v.status === "superseded") return dim(pad("history", 8));
+  return v.label === "FACT" ? c.green(pad("FACT", 8)) : c.yellow(pad("INFERRED", 8));
+}
+function statusOf(v) {
+  const s = pad(v.status, 10);
+  return v.status === "unreviewed" ? c.yellow(s) : v.status === "superseded" ? dim(s) : s;
+}
+function row(v) {
+  const markers = `${v.stale ? c.yellow("stale") : "     "} ${v.flags.length ? c.red(sym.warn) : " "}`;
+  const title = v.status === "superseded" ? dim(trunc(v.title, 60)) : trunc(v.title, 60);
+  return `${c.bold(pad(v.id, 9))} ${pad(v.kind, 10)} ${labelOf(v)} ${statusOf(v)} ${markers} ${title} ${dim(`\xB7 ${v.source}`)}`;
+}
+function table(views) {
+  line(dim(`${pad("ID", 9)} ${pad("KIND", 10)} ${pad("LABEL", 8)} ${pad("STATUS", 10)} ${pad("", 7)} TITLE \xB7 SOURCE`));
+  for (const v of views) line(row(v));
+}
+function countMemory(views) {
+  return {
+    total: views.length,
+    unreviewed: views.filter((v) => v.status === "unreviewed").length,
+    confirmed: views.filter((v) => v.status === "confirmed").length,
+    superseded: views.filter((v) => v.status === "superseded").length,
+    stale: views.filter((v) => v.stale).length,
+    flagged: views.filter((v) => v.flags.length && v.status !== "superseded").length
+  };
+}
+async function memorySummary(root) {
+  try {
+    return countMemory(await listMemory(root));
+  } catch {
+    return null;
+  }
+}
+function countsLine(c2) {
+  const parts = [plural(c2.total, "entry", "entries"), `${c2.confirmed} confirmed`, `${c2.unreviewed} unreviewed`];
+  if (c2.superseded) parts.push(`${c2.superseded} superseded`);
+  if (c2.stale) parts.push(`${c2.stale} stale`);
+  if (c2.flagged) parts.push(`${c2.flagged} flagged`);
+  return parts.join(" \xB7 ");
+}
+function flagsBlock(v) {
+  if (!v.flags.length) return;
+  warn(c.red("Possible prompt injection \u2014 this entry addresses the agent instead of describing the project:"));
+  for (const f of v.flags) line(`    ${dim("-")} ${f}`);
+  line(dim("    Flagged entries are never recalled automatically. Read it before confirming; forget it if it is not a real project fact."));
+}
+function detail(v) {
+  line(`${c.bold(v.id)}  ${c.bold(v.title)}`);
+  line(`${dim("Kind:")}     ${v.kind} ${dim(`(.athena/memory/${MEMORY_FILES[v.kind]})`)}`);
+  line(`${dim("Label:")}    ${v.status === "superseded" ? dim("history (superseded)") : v.label === "FACT" ? c.green("FACT") : c.yellow("INFERRED")} ${dim(`\xB7 ${v.status}`)}`);
+  line(`${dim("Source:")}   ${v.source}`);
+  line(`${dim("Created:")}  ${v.createdAt} ${dim(`(${relativeTime(v.createdAt)})`)}`);
+  if (v.confirmedAt) line(`${dim("Confirmed:")} ${v.confirmedAt}`);
+  if (v.supersedes) line(`${dim("Replaces:")} ${v.supersedes}`);
+  if (v.supersededBy) line(`${dim("Superseded by:")} ${v.supersededBy}`);
+  if (v.tags.length) line(`${dim("Tags:")}     ${v.tags.map((t) => `#${t}`).join(" ")}`);
+  if (v.evidence) line(`${dim("Evidence:")} ${v.evidence}`);
+  if (v.files.length) {
+    line(dim("Files:"));
+    for (const f of v.files) {
+      const state = v.changedFiles.includes(f) ? c.yellow("changed since recorded") : f in v.anchors ? c.green("unchanged") : dim("not anchored (file did not exist when recorded)");
+      line(`  ${f} ${dim("\u2014")} ${state}`);
+    }
+  }
+  if (v.details) {
+    line();
+    for (const l of v.details.split("\n")) line(`  ${l}`);
+  }
+  if (v.stale) {
+    line();
+    warn(`Stale: ${v.changedFiles.join(", ")} changed since this was recorded.`);
+  }
+  if (v.flags.length) {
+    line();
+    flagsBlock(v);
+  }
+}
+async function memoryListCommand(opts) {
+  const root = await requireProjectRoot(opts);
+  const kind = parseKind(opts.kind);
+  const status = parseStatus(opts.status);
+  const all = await listMemory(root);
+  const views = all.filter((v) => (!kind || v.kind === kind) && (!status || v.status === status) && (!opts.stale || v.stale));
+  const counts = countMemory(all);
+  if (isJson()) {
+    json({ entries: views, counts });
+    return 0;
+  }
+  if (!all.length) {
+    line(dim('No project memory yet. Record one with `athena memory add --kind decision --title "\u2026"`, or let your agent use the `remember` MCP tool.'));
+    return 0;
+  }
+  if (!views.length) line(dim("No entries match."));
+  else table(views);
+  line();
+  line(dim(`${countsLine(counts)} \xB7 source: .athena/memory/`));
+  if (counts.unreviewed) line(dim(`${plural(counts.unreviewed, "entry", "entries")} written by agents ${counts.unreviewed === 1 ? "is" : "are"} INFERRED until reviewed: run \`athena memory review\`.`));
+  if (counts.stale && !opts.stale) line(dim("Some entries are stale (their linked files changed): run `athena memory stale`."));
+  return 0;
+}
+async function memoryShowCommand(id, opts) {
+  checkIds([id]);
+  const root = await requireProjectRoot(opts);
+  const v = await getMemory(root, id);
+  if (isJson()) json(v);
+  else detail(v);
+}
+async function memoryAddCommand(opts) {
+  const root = await requireProjectRoot(opts);
+  if (!opts.kind) throw new AthenaError("Missing --kind.", `Use one of: ${MEMORY_KINDS.join(", ")}`);
+  const kind = parseKind(opts.kind);
+  if (!opts.title) throw new AthenaError("Missing --title.", 'A memory needs a short title, e.g. --title "Money is stored in cents".');
+  if (opts.supersedes) checkIds([opts.supersedes]);
+  const details = opts.details === "-" ? await readStdin() : opts.details;
+  const v = await addMemory(root, { kind, title: opts.title, details, files: opts.file, tags: opts.tag, evidence: opts.evidence, supersedes: opts.supersedes }, "developer");
+  if (isJson()) {
+    json({ ok: true, entry: v });
+    return;
+  }
+  ok(`Recorded ${c.bold(v.id)} ${dim(`(${v.kind}, FACT) in .athena/memory/${MEMORY_FILES[v.kind]}`)}`);
+  if (v.supersedes) line(dim(`  ${v.supersedes} is now superseded by ${v.id}.`));
+  const unanchored = v.files.filter((f) => !(f in v.anchors));
+  if (unanchored.length) warn(`Not found, so not tracked for staleness: ${unanchored.join(", ")}`);
+  if (v.flags.length) flagsBlock(v);
+}
+async function memorySearchCommand(query, opts) {
+  const root = await requireProjectRoot(opts);
+  const views = await searchMemory(root, query);
+  if (isJson()) {
+    json({ query, entries: views });
+    return;
+  }
+  if (!views.length) {
+    line(dim(`No memory mentions "${query}".`));
+    return;
+  }
+  table(views);
+  line();
+  line(dim(`${plural(views.length, "match", "matches")} \xB7 details: athena memory show <id>`));
+}
+async function memoryRecallCommand(task, opts) {
+  const root = await requireProjectRoot(opts);
+  const text = task.join(" ").trim();
+  const limit = opts.limit === void 0 ? void 0 : Number(opts.limit);
+  if (limit !== void 0 && (!Number.isInteger(limit) || limit < 1)) throw new AthenaError(`Invalid --limit: ${opts.limit}`);
+  const hits = await recallMemory(root, { task: text, files: opts.file, tags: opts.tag, limit });
+  if (isJson()) {
+    json({ task: text, files: opts.file ?? [], hits });
+    return;
+  }
+  if (!hits.length) {
+    line(dim("No relevant memory for this task."));
+    return;
+  }
+  heading(`Memory relevant to "${trunc(text, 60)}"`);
+  line();
+  hits.forEach((h, i) => {
+    const v = h.entry;
+    line(`${dim(`${String(i + 1).padStart(2)}.`)} ${c.bold(v.id)} ${labelOf(v)} ${v.kind} ${dim("\u2014")} ${v.title}`);
+    line(`    ${dim(`score ${h.score} \xB7 ${h.why.join("; ")}`)}`);
+  });
+  line();
+  line(dim("Flagged (possible prompt-injection) and superseded entries are not recalled. Details: athena memory show <id>"));
+}
+async function memoryConfirmCommand(ids, opts) {
+  checkIds(ids);
+  const root = await requireProjectRoot(opts);
+  for (const id of ids) await getMemory(root, id);
+  const out = [];
+  for (const id of ids) out.push(await confirmMemory(root, id));
+  if (isJson()) {
+    json({ ok: true, entries: out });
+    return;
+  }
+  for (const v of out) {
+    ok(`Confirmed ${c.bold(v.id)} ${dim(`\u2014 ${trunc(v.title, 60)} (now FACT${v.files.length ? ", re-anchored to current files" : ""})`)}`);
+    if (v.flags.length) flagsBlock(v);
+  }
+}
+async function memorySupersedeCommand(id, opts) {
+  if (!opts.by) throw new AthenaError("Missing --by <id>.", "Name the newer memory that replaces this one: athena memory supersede <old-id> --by <new-id>");
+  checkIds([id, opts.by]);
+  const root = await requireProjectRoot(opts);
+  const v = await supersedeMemory(root, id, opts.by);
+  if (isJson()) json({ ok: true, entry: v });
+  else ok(`${c.bold(id)} is now superseded by ${c.bold(opts.by)} ${dim("(kept as history; no longer recalled)")}`);
+}
+async function ask(question) {
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    return /^y(es)?$/i.test((await rl.question(`${question} ${dim("[y/N]")} `)).trim());
+  } finally {
+    rl.close();
+  }
+}
+async function memoryForgetCommand(ids, opts) {
+  checkIds(ids);
+  const root = await requireProjectRoot(opts);
+  const views = [];
+  for (const id of ids) views.push(await getMemory(root, id));
+  if (!opts.yes) {
+    if (!process.stdin.isTTY || isJson()) throw new AthenaError(`Refusing to forget ${plural(ids.length, "memory", "memories")} without confirmation.`, "Re-run with --yes in non-interactive environments.");
+    line("This permanently removes from .athena/memory/:");
+    for (const v of views) line(`  ${c.bold(v.id)} ${v.kind} ${dim("\u2014")} ${v.title}`);
+    line(dim("If .athena/memory/ is committed to Git you can restore entries from history. To keep an outdated entry as history, use `athena memory supersede` instead."));
+    if (!await ask("Forget?")) {
+      line("Cancelled.");
+      return;
+    }
+  }
+  for (const id of ids) await forgetMemory(root, id);
+  if (isJson()) json({ ok: true, forgotten: ids });
+  else for (const v of views) ok(`Forgot ${c.bold(v.id)} ${dim(`\u2014 ${trunc(v.title, 60)}`)}`);
+}
+async function memoryEditCommand(id, opts) {
+  checkIds([id]);
+  const root = await requireProjectRoot(opts);
+  const details = opts.details === "-" ? await readStdin() : opts.details;
+  const patch = { title: opts.title, details, files: opts.file, tags: opts.tag, evidence: opts.evidence };
+  if (Object.values(patch).every((v2) => v2 === void 0)) throw new AthenaError("Nothing to change.", "Pass at least one of --title, --details, --file, --tag, --evidence.");
+  const v = await updateMemory(root, id, patch);
+  if (isJson()) {
+    json({ ok: true, entry: v });
+    return;
+  }
+  ok(`Updated ${c.bold(v.id)} ${dim(`\u2014 ${trunc(v.title, 60)}`)}`);
+  if (v.status === "unreviewed") line(dim(`  Still INFERRED (unreviewed). Confirm it with \`athena memory confirm ${v.id}\`.`));
+  if (v.flags.length) flagsBlock(v);
+}
+async function memoryStaleCommand(opts) {
+  const root = await requireProjectRoot(opts);
+  const views = await listMemory(root, { stale: true });
+  if (isJson()) {
+    json({ entries: views });
+    return 0;
+  }
+  if (!views.length) {
+    ok("No stale memory: no linked file changed since its entry was recorded or confirmed.");
+    return 0;
+  }
+  heading(`${plural(views.length, "stale entry", "stale entries")}`);
+  line();
+  for (const v of views) {
+    line(`${c.bold(v.id)} ${labelOf(v)} ${v.kind} ${dim("\u2014")} ${v.title}`);
+    line(`    ${c.yellow("changed:")} ${v.changedFiles.join(", ")}`);
+  }
+  line();
+  line(dim("For each: still true \u2192 `athena memory confirm <id>` (re-anchors to the current files);"));
+  line(dim("partly wrong \u2192 `athena memory edit <id> --details \u2026`; no longer true \u2192 `athena memory forget <id>`."));
+  return 0;
+}
+async function memoryReviewCommand(opts) {
+  const root = await requireProjectRoot(opts);
+  const pending = (await listMemory(root, { status: "unreviewed" })).sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+  const interactive = Boolean(process.stdin.isTTY) && Boolean(process.stdout.isTTY) && !isJson();
+  if (!interactive) {
+    if (isJson()) json({ interactive: false, entries: pending });
+    else if (!pending.length) ok("Nothing to review: no unreviewed memory.");
+    else {
+      table(pending);
+      line();
+      line(dim(`${plural(pending.length, "unreviewed entry", "unreviewed entries")}. \`athena memory review\` is interactive in a terminal;`));
+      line(dim("here, use `athena memory confirm <id\u2026>` or `athena memory forget <id\u2026> --yes`."));
+    }
+    return 0;
+  }
+  if (!pending.length) {
+    ok("Nothing to review: no unreviewed memory.");
+    return 0;
+  }
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  const tally = { confirmed: 0, forgotten: 0, skipped: 0 };
+  try {
+    for (let i = 0; i < pending.length; i++) {
+      const v = pending[i];
+      line();
+      line(dim(`\u2500\u2500 ${i + 1}/${pending.length} \u2500\u2500`));
+      detail(v);
+      line();
+      let answer = "";
+      for (; ; ) {
+        answer = (await rl.question(`${c.bold("[c]")}onfirm  ${c.bold("[e]")}dit later  ${c.bold("[f]")}orget  ${c.bold("[s]")}kip  ${c.bold("[q]")}uit ${dim("\u203A")} `).catch(() => "q")).trim().toLowerCase();
+        if (/^[cefsq]/.test(answer)) break;
+      }
+      const a = answer[0];
+      if (a === "q") break;
+      if (a === "c") {
+        await confirmMemory(root, v.id);
+        tally.confirmed++;
+        ok(`Confirmed ${v.id} (now FACT)`);
+      } else if (a === "f") {
+        await forgetMemory(root, v.id);
+        tally.forgotten++;
+        ok(`Forgot ${v.id}`);
+      } else {
+        tally.skipped++;
+        if (a === "e") line(dim(`  Skipped. Edit it with \`athena memory edit ${v.id} --title \u2026 --details \u2026\`, then confirm it.`));
+      }
+    }
+  } finally {
+    rl.close();
+  }
+  line();
+  line(`${tally.confirmed} confirmed \xB7 ${tally.forgotten} forgotten \xB7 ${tally.skipped} skipped`);
+  return 0;
+}
+export {
+  countMemory,
+  memoryAddCommand,
+  memoryConfirmCommand,
+  memoryEditCommand,
+  memoryForgetCommand,
+  memoryListCommand,
+  memoryRecallCommand,
+  memoryReviewCommand,
+  memorySearchCommand,
+  memoryShowCommand,
+  memoryStaleCommand,
+  memorySummary,
+  memorySupersedeCommand
+};
+//# sourceMappingURL=memory-VSVNLEJC.js.map