open-memex 0.7.0-alpha.9 → 0.7.0

package/src/cli.ts

@@ -9,7 +9,8 @@ import { findDuplicates, supersede, setStatus } from "./store/lifecycle.ts";
 import { proposeMemories, promoteMemory, listConflicts, resolveConflict, formatReviewHistory } from "./review.ts";
 import { getSyncStatus, formatSyncStatus, submitMemories } from "./submit.ts";
 import { getPrStatus, formatPrStatus, applyPrStatus } from "./github.ts";
-import { search, list, hitStateLabel } from "./retrieve/search.ts";
+import { search, list, countList, hitStateLabel } from "./retrieve/search.ts";
+import { formatInventoryLine, truncationNote } from "./retrieve/display.ts";
 import {
   writeMemoryFile,
   readMemoryFile,
@@ -19,7 +20,7 @@ import {
   type Frontmatter,
 } from "./store/markdown.ts";
 import { loadConfig, configSource } from "./config.ts";
-import { paths, projectRoot } from "./paths.ts";
+import { paths, projectRoot, isInRepoMemoryFile } from "./paths.ts";
 import { redact } from "./redact.ts";
 import { resolveMcpCommand } from "./init.ts";
 import fs from "node:fs";
@@ -27,10 +28,22 @@ import path from "node:path";
 import { execFileSync } from "node:child_process";
 import { fileURLToPath } from "node:url";
 
-/** True when `target` sits inside a git working tree (D68 guard). */
+/**
+ * True when `target` sits inside a git working tree (D68 guard).
+ *
+ * D70: resolve the nearest EXISTING ancestor first. `git -C` on a
+ * directory that does not exist throws, and the old code turned that
+ * into "not in a worktree" — a fail-open guard on the one path where
+ * personal memories would ride a commit.
+ */
 function isInsideWorkTree(target: string): boolean {
   try {
-    const dir = path.dirname(path.resolve(target));
+    let dir = path.dirname(path.resolve(target));
+    while (!fs.existsSync(dir)) {
+      const parent = path.dirname(dir);
+      if (parent === dir) break;
+      dir = parent;
+    }
     const out = execFileSync("git", ["-C", dir, "rev-parse", "--is-inside-work-tree"], {
       stdio: ["ignore", "pipe", "ignore"],
       encoding: "utf8",
@@ -41,6 +54,31 @@ function isInsideWorkTree(target: string): boolean {
   }
 }
 
+/**
+ * D70: the one place that decides where a report may be written, for
+ * every `inventory` format. Returns an error message to print, or null
+ * when the path is safe. Kept single so the text/json/html paths cannot
+ * drift apart (they already had two copies, D68).
+ */
+function inventoryWriteRefusal(
+  target: string,
+  includesPersonal: boolean,
+  allowPersonal: boolean,
+): string | null {
+  // Personal content must not ride a commit (the design's hardest rule).
+  if (includesPersonal && !allowPersonal && isInsideWorkTree(target)) {
+    return (
+      `inventory: ${target} is inside a git working tree and this report includes personal memories. ` +
+      `Refusing to write it there. Pass --allow-personal if you really want that, or write outside the repo.`
+    );
+  }
+  const parent = path.dirname(path.resolve(target));
+  if (!fs.existsSync(parent)) {
+    return `inventory: the directory ${parent} does not exist — create it first, or choose another --out path.`;
+  }
+  return null;
+}
+
 /** Per-command help, printed by `open-memex <command> --help`.
     AI assistants discover the CLI through --help, so every command needs one. */
 const COMMAND_HELP: Record<string, string> = {
@@ -51,17 +89,21 @@ Usage: open-memex where
 Example:
   open-memex where`,
 
-  list: `List memories in a scope, newest first.
+  list: `List memories in a scope, newest first, as a numbered inventory.
 
 Usage: open-memex list [--scope project|personal|both] [--type T] [--limit N] [--include active|all]
 
 Flags:
   --scope    project (default), personal, or both
   --type     filter by memory type
-  --limit    max results
+  --limit    max results (default 20, max 100)
   --include  active (default: what is currently remembered) or all (audit
              view: superseded versions, retracted and archived included)
 
+A cut list says how many entries it left out. Numbers are unique within one
+listing, so "the third one" names exactly one memory - but they are only
+valid for the listing you just ran.
+
 Examples:
   open-memex list
   open-memex list --scope personal --limit 20`,
@@ -118,7 +160,8 @@ Example:
 
   forget: `Delete a memory by id. With --soft, hide it instead: the memory
 is retracted (out of lists and search, file kept). Retraction is one-way —
-save the content as a new memory to bring it back.
+save the content as a new memory to bring it back. If the memory lives in
+the repo, either action is only local until you commit and push it.
 
 Usage: open-memex forget <id> [--soft]
 
@@ -179,16 +222,18 @@ Example:
   inventory: `Show everything remembered — personal + this project — in the
 open: what each memory says, where it came from, and whether it has reached
 the repo yet. Read-only; deleting stays a confirmed conversation with your
-agent. Formats: text (default, diffable) and json (for agents).
+agent. Formats: text (default, diffable), json (for agents), html (a local
+page for your browser; default writes <data dir>/inventory.html).
 
-Usage: open-memex inventory [--format text|json] [--scope project|personal|both] [--out <path>] [--allow-personal]
+Usage: open-memex inventory [--format text|json|html] [--scope project|personal|both] [--out <path>] [--allow-personal]
 
-Default scope: both. Without --out the report goes to stdout. A report that
+Default scope: both. Without --out, text/json go to stdout. A report that
 includes personal memories is refused inside a git working tree unless
 --allow-personal is passed — personal content must not ride a commit.
 
 Example:
-  open-memex inventory --format json --out ~/inventory.json`,
+  open-memex inventory --format json --out ~/inventory.json
+  open-memex inventory --format html`,
 
   pull: `Pull shared project memories from the git remote: fetch + fast-forward
 only. Never auto-merges — a diverged branch fails with a clear message and is
@@ -414,7 +459,7 @@ Usage:
   open-memex promote <id> [--reject] [--resubmit] [--note "..."] [--by NAME]
   open-memex resolve [id-or-path]
   open-memex sync-status
-  open-memex inventory [--format text|json] [--scope project|personal|both] [--out <path>] [--allow-personal]
+  open-memex inventory [--format text|json|html] [--scope project|personal|both] [--out <path>] [--allow-personal]
   open-memex pull
   open-memex push
   open-memex export [--scope project|personal|both] [--type T] [--tag t] [--all] [-o <file>]
@@ -910,24 +955,41 @@ async function main() {
     // D66: --scope both, on par with the memory_list tool — prints each
     // scope's newest under its own header.
     const scopes =
-      flags.scope === "both" ? [project, PERSONAL_SCOPE] : [resolveCliScope(flags, project)];
+      flags.scope === "both" ? [PERSONAL_SCOPE, project] : [resolveCliScope(flags, project)];
+    const include = flags.include === "all" ? "all" : "active";
+    // D70: the CLI renders the SAME structured inventory the agent sees,
+    // numbering runs across the whole listing, and a cut list says how
+    // many entries it dropped — `open-memex list` is the surface a
+    // sceptical user runs first, so it may not look complete when it isn't.
+    let seq = 0;
     for (const s of scopes) {
       syncScope(s.key, "cli");
       const hits = list(s.key, {
         type: flags.type,
         limit: flags.limit ? Number(flags.limit) : undefined,
-        include: flags.include === "all" ? "all" : "active",
+        include,
       });
-      if (scopes.length > 1) console.log(`## ${s.kind} (${s.key})`);
+      const total = countList(s.key, { type: flags.type, include });
+      if (scopes.length > 1) {
+        console.log(
+          s.key === PERSONAL_SCOPE.key
+            ? "## About you (personal — stays on this machine, applies everywhere)"
+            : `## This project (${s.projectName || s.key})`,
+        );
+      }
       if (hits.length === 0) {
-        console.log(`(no memories in ${s.key})`);
+        console.log(
+          scopes.length > 1
+            ? "(nothing remembered in this scope yet)"
+            : `(no memories in ${s.key})`,
+        );
         continue;
       }
       for (const h of hits) {
-        const dep = h.status !== "active" ? ` [${h.status}]` : "";
-        const rev = hitStateLabel(h);
-        console.log(`[${h.type}]${dep}${rev} ${h.id}  ${h.snippet.replace(/\s+/g, " ").trim()}`);
+        console.log(formatInventoryLine(seq++, h, PERSONAL_SCOPE.key));
       }
+      const note = truncationNote(hits.length, total);
+      if (note) console.log(note);
     }
     return;
   }
@@ -1110,10 +1172,20 @@ async function main() {
     // D68: --soft hides (retracts) instead of deleting — same action as
     // the memory_forget tool's soft flag. One-way (D64).
     if (rest.includes("--soft")) {
+      const target = db().prepare(`SELECT file_path FROM memories WHERE id = ?`).get(id) as
+        | { file_path: string }
+        | undefined;
       try {
         const mf = setStatus(id, "retracted");
         upsertFromFile(mf);
         console.log(`hidden ${id} (retracted — out of lists and search; save it again as a new memory to bring it back)`);
+        // D70: same honesty as the hard delete — a retraction of an in-repo
+        // memory is a local working-tree edit until it is committed and pushed.
+        if (target && isInRepoMemoryFile(target.file_path)) {
+          console.log(
+            `note: that memory lives in the repo (.ai/open-memex/) — the retraction is only local until you commit and push it; until then the team still sees it.`,
+          );
+        }
       } catch (e) {
         console.error(`hide failed: ${(e as Error).message}`);
         process.exit(1);
@@ -1260,8 +1332,8 @@ function positionalArgs(argv: string[]): string[] {
     syncScope(PERSONAL_SCOPE.key, "cli");
     const flags = parseFlags(rest);
     const format = flags.format ?? "text";
-    if (format !== "text" && format !== "json") {
-      console.error(`inventory: unknown --format '${format}' (text|json; html arrives separately)`);
+    if (format !== "text" && format !== "json" && format !== "html") {
+      console.error(`inventory: unknown --format '${format}' (text|json|html)`);
       process.exit(2);
     }
     const scopeKeys =
@@ -1271,26 +1343,38 @@ function positionalArgs(argv: string[]): string[] {
           ? [project.key]
           : [PERSONAL_SCOPE.key, project.key];
     const outPath = flags["out"] ?? flags["output"];
-    // D68/3-C v2: the report contains personal content. Writing it into
-    // a git working tree would ride the next commit off this machine —
-    // refuse unless the user explicitly accepts that.
-    if (
-      outPath &&
-      scopeKeys.includes(PERSONAL_SCOPE.key) &&
-      flags["allow-personal"] !== "true" &&
-      isInsideWorkTree(outPath)
-    ) {
-      console.error(
-        `inventory: ${outPath} is inside a git working tree and this report includes personal memories. ` +
-          `Refusing to write it there. Pass --allow-personal if you really want that, or write outside the repo.`,
-      );
-      process.exit(2);
-    }
+    const includesPersonal = scopeKeys.includes(PERSONAL_SCOPE.key);
+    const allowPersonal = flags["allow-personal"] === "true";
     try {
       const { loadInventory, renderInventoryText, renderInventoryJson } = await import("./inventory.ts");
+      if (format === "html") {
+        const { renderInventoryHtml, defaultHtmlOutPath } = await import("./inventory-html.ts");
+        const target = outPath ?? defaultHtmlOutPath(paths().root);
+        // D70: one guard for every format (this path had its own copy).
+        const refusal = inventoryWriteRefusal(target, includesPersonal, allowPersonal);
+        if (refusal) {
+          console.error(refusal);
+          process.exit(2);
+        }
+        // D70: only the audit surface needs the hidden rows themselves;
+        // text/json report counts, so they must not pay to load them.
+        const data = loadInventory(scopeKeys, { hidden: "entries" });
+        fs.writeFileSync(target, renderInventoryHtml(data), "utf8");
+        console.log(`inventory: ${data.total} memories → ${target}`);
+        console.log(`open it in any browser; the report is read-only.`);
+        return;
+      }
       const data = loadInventory(scopeKeys);
       const rendered = format === "json" ? renderInventoryJson(data) : renderInventoryText(data);
       if (outPath) {
+        // D68/3-C v2: the report contains personal content. Writing it into
+        // a git working tree would ride the next commit off this machine —
+        // refuse unless the user explicitly accepts that.
+        const refusal = inventoryWriteRefusal(outPath, includesPersonal, allowPersonal);
+        if (refusal) {
+          console.error(refusal);
+          process.exit(2);
+        }
         fs.writeFileSync(outPath, rendered, "utf8");
         console.log(`inventory: ${data.total} memories → ${outPath}`);
       } else {

package/src/index.ts

@@ -3,8 +3,10 @@ import {
   PLUGIN_ID,
   bootstrapPlugin,
   captureFromText,
+  captureHandoff,
   injectOnce,
 } from "./plugin-core.ts";
+import { pickScopeRoot } from "./scope.ts";
 import { makeTools } from "./tools/memory.ts";
 import { v2Plugin } from "./opencode-v2.ts";
 
@@ -19,26 +21,32 @@ import { v2Plugin } from "./opencode-v2.ts";
  * type-only (D58), and v2's decode is structural.
  */
 const server: Plugin = async ({ worktree, directory }) => {
-  const roots = worktree || directory || process.cwd();
-  const state = bootstrapPlugin(roots);
+  // v1's `worktree` is the filesystem root for non-git folders — never seed a
+  // scope on it (D71). `pickScopeRoot` falls back to the opened `directory`.
+  const state = bootstrapPlugin(pickScopeRoot(worktree, directory));
   const tools = makeTools(() => state.scope, state.cfg);
 
   return {
     tool: tools,
 
-    async "chat.message"(_input, output) {
+    async "chat.message"(input, output) {
       const parts = (output.parts ?? []) as Array<{ type: string; text?: string }>;
       const text = parts
         .map((p) => (p?.type === "text" ? p.text ?? "" : ""))
         .filter(Boolean)
         .join("\n");
-      captureFromText(text, state);
+      captureFromText(text, state, input.sessionID ?? "");
     },
 
     async "experimental.chat.system.transform"(input, output) {
-      injectOnce(input.sessionID ?? "", state, (block) => {
+      const sessionID = input.sessionID ?? "";
+      injectOnce(sessionID, state, (block) => {
         output.system.push(block);
       });
+      // D73: runs on every request, so the note lands on the very turn whose
+      // message the hook just captured. Delivered once per capture.
+      const handoff = captureHandoff(sessionID, state);
+      if (handoff) output.system.push(handoff);
     },
   };
 };

package/src/inventory-html.ts

@@ -0,0 +1,191 @@
+/**
+ * HTML renderer for the inventory (D68 follow-up): a single local file
+ * a user opens in any browser to read what the store remembers. It
+ * renders the SAME data layer as the text/JSON formats
+ * (`src/inventory.ts`) — one source, three renderings, no drift.
+ *
+ * Design rules (3-C v2) enforced here:
+ * - Every byte of memory content is HTML-escaped. Memory text can come
+ *   from an imported bundle or a pasted web page; under file:// an
+ *   unescaped <script> would execute in the user's own browser.
+ * - The filter box is plain show/hide over server-rendered entries
+ *   (no innerHTML, no network, no external resources).
+ * - History (superseded versions, retracted, archived) is a folded
+ *   section with supersede-chain pointers — auditable, never mixed
+ *   into "what is remembered now". At scale (>50 current entries) the
+ *   scope sections fold too.
+ * - Read-only: no delete buttons, no server callback. Deletion stays a
+ *   confirmed conversation; the page says so, with the id to quote.
+ */
+
+import path from "node:path";
+
+import { PERSONAL_SCOPE } from "./scope.ts";
+import {
+  escapeHtml,
+  relativeTime,
+  reviewStateLabel,
+  sourceLabel,
+} from "./retrieve/display.ts";
+import type { InventoryData, InventoryRow } from "./inventory.ts";
+
+const FOLD_THRESHOLD = 50;
+
+function entryHtml(row: InventoryRow, now: number): string {
+  const meta: string[] = [escapeHtml(sourceLabel(row.source))];
+  const when = relativeTime(row.created_at, now);
+  if (when) meta.push(escapeHtml(when));
+  if (row.scope_key !== PERSONAL_SCOPE.key) {
+    meta.push(escapeHtml(reviewStateLabel(row.review_state)));
+    if (row.review_state !== "draft") {
+      meta.push(
+        row.file_path.replace(/\\/g, "/").includes("/.ai/open-memex/")
+          ? "file is in the repo"
+          : "file is not in the repo yet",
+      );
+    }
+  }
+  if (row.status !== "active") meta.push(escapeHtml(`marked ${row.status}`));
+  return `    <article class="entry">
+      <p class="body">${escapeHtml(row.content.trim())}</p>
+      <p class="meta">${meta.join(" · ")} · <span class="id">id ${escapeHtml(row.id)}</span></p>
+    </article>`;
+}
+
+function hiddenEntryHtml(row: InventoryRow, now: number): string {
+  const when = relativeTime(row.created_at, now);
+  const chain = row.superseded_by
+    ? ` · replaced by <span class="id">${escapeHtml(row.superseded_by)}</span>`
+    : "";
+  return `    <article class="entry hidden-entry">
+      <p class="body">${escapeHtml(row.content.trim())}</p>
+      <p class="meta">${escapeHtml(row.status)}${when ? ` · saved ${escapeHtml(when)}` : ""}${chain} · <span class="id">id ${escapeHtml(row.id)}</span></p>
+    </article>`;
+}
+
+function sectionHtml(
+  title: string,
+  blurb: string,
+  entries: string,
+  count: number,
+  fold: boolean,
+  open: boolean,
+): string {
+  if (fold) {
+    return `  <details${open ? " open" : ""}>
+    <summary>${escapeHtml(title)} <span class="count">${count}</span></summary>
+    <p class="blurb">${escapeHtml(blurb)}</p>
+${entries}
+  </details>`;
+  }
+  return `  <section>
+    <h2>${escapeHtml(title)} <span class="count">${count}</span></h2>
+    <p class="blurb">${escapeHtml(blurb)}</p>
+${entries || '    <p class="empty">(nothing here yet)</p>'}
+  </section>`;
+}
+
+export function renderInventoryHtml(data: InventoryData): string {
+  const now = Date.now();
+  const fold = data.total > FOLD_THRESHOLD;
+  const personalCount = data.scopes
+    .filter((s) => s.scopeKey === PERSONAL_SCOPE.key)
+    .reduce((n, s) => n + s.rows.length, 0);
+
+  const parts: string[] = [];
+  data.scopes.forEach((s, i) => {
+    const isPersonal = s.scopeKey === PERSONAL_SCOPE.key;
+    parts.push(
+      sectionHtml(
+        isPersonal ? "About you — personal" : `Project: ${s.projectName}`,
+        isPersonal
+          ? "These describe you, apply in every project, and never leave this machine."
+          : "Project memories. Each entry says whether it is still only on this machine (the outbox) or has reached the repo.",
+        s.rows.map((r) => entryHtml(r, now)).join("\n"),
+        s.rows.length,
+        fold,
+        isPersonal || i === 0,
+      ),
+    );
+  });
+  if (data.outbox.length > 0) {
+    parts.push(
+      sectionHtml(
+        "Not in the repo yet — outbox drafts",
+        "These drafts exist only on this machine. They reach the repo through review (submit → promote), never automatically.",
+        data.outbox.map((r) => entryHtml(r, now)).join("\n"),
+        data.outbox.length,
+        fold,
+        false,
+      ),
+    );
+  }
+  if (data.hiddenEntries.length > 0) {
+    const h = data.hiddenEntries.map((r) => hiddenEntryHtml(r, now)).join("\n");
+    parts.push(`  <details>
+    <summary>Replaced &amp; hidden history <span class="count">${data.hiddenEntries.length}</span></summary>
+    <p class="blurb">Older versions and withdrawn memories. Kept so you can audit how a fact changed; none of this is used for recall.</p>
+${h}
+  </details>`);
+  }
+
+  return `<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<!-- D70: the page claims it makes no network requests - enforce it. Inline
+     style/script are the only allowances; anything else (a stray <img
+     src>, a remote font) is blocked by the browser, not just by our promise. -->
+<meta http-equiv="Content-Security-Policy" content="default-src 'none'; style-src 'unsafe-inline'; script-src 'unsafe-inline'">
+<title>What OpenMemex remembers</title>
+<style>
+  body { font-family: system-ui, sans-serif; margin: 2rem auto; max-width: 44rem; padding: 0 1rem; color: #1a1a1a; background: #fdfdfb; }
+  h1 { font-size: 1.4rem; margin-bottom: 0.25rem; }
+  h2, summary { font-size: 1.1rem; font-weight: 600; }
+  summary { cursor: pointer; margin: 1.2rem 0 0.4rem; }
+  .sub { color: #666; font-size: 0.9rem; margin-top: 0; }
+  .count { color: #888; font-weight: normal; font-size: 0.85em; }
+  .blurb { color: #555; font-size: 0.9rem; }
+  .entry { border-top: 1px solid #e5e2d9; padding: 0.75rem 0; }
+  .hidden-entry { opacity: 0.75; }
+  .body { white-space: pre-wrap; margin: 0 0 0.35rem; }
+  .meta { color: #666; font-size: 0.82rem; margin: 0; }
+  .id { font-family: ui-monospace, monospace; font-size: 0.78rem; }
+  .empty { color: #888; }
+  .howto { background: #f4f1e8; border-radius: 6px; padding: 0.75rem 1rem; font-size: 0.9rem; }
+  input[type="search"] { width: 100%; padding: 0.5rem; font-size: 1rem; margin: 1rem 0; box-sizing: border-box; }
+  .hidden { display: none; }
+</style>
+</head>
+<body>
+<h1>What OpenMemex remembers about you</h1>
+<p class="sub">Generated ${escapeHtml(data.generatedAt)} · ${data.total} memories (${personalCount} personal, ${data.total - personalCount} project incl. outbox). Read-only report.</p>
+<input type="search" id="filter" placeholder="Filter memories…" aria-label="Filter memories">
+<div class="howto">
+  <strong>Checking my work:</strong> every entry shows where it came from.
+  “I inferred this” means I wrote it from context, not from your words — those are the ones to check.
+  To remove one, tell your agent <em>“forget the memory about …”</em> (quote the id if you like) and it will read the entry back before deleting it — deletion is permanent, there is no undo.
+  A memory that lives in a repo is only truly gone once the deletion is committed.
+</div>
+${parts.join("\n")}
+<script>
+  var input = document.getElementById('filter');
+  input.addEventListener('input', function () {
+    var q = input.value.trim().toLowerCase();
+    var entries = document.querySelectorAll('.entry');
+    for (var i = 0; i < entries.length; i++) {
+      var el = entries[i];
+      el.classList.toggle('hidden', q !== '' && el.textContent.toLowerCase().indexOf(q) === -1);
+    }
+  });
+</script>
+</body>
+</html>
+`;
+}
+
+/** Default report location: the data dir, never a working tree. */
+export function defaultHtmlOutPath(dataRoot: string): string {
+  return path.join(dataRoot, "inventory.html");
+}