fapony 0.6.2 → 0.7.1

package/src/mem/index.ts

@@ -1,201 +0,0 @@
-// src/mem/index.ts — CLI dispatch for `fapony mem <sub>`
-//
-// Moved from templates/mem/mem.ts (2026-09-19) as part of PLAN-agent-one-call chunk 1.
-// Now an export function called by fapony.ts, not a standalone script.
-
-import { existsSync } from "node:fs";
-import { basename, join } from "node:path";
-import { levenshtein } from "../commands.js";
-import { cmdPlanCheck, cmdPlanSweep } from "./commands/plan.js";
-import { cmdDone, cmdFind, cmdKickoff, cmdStale } from "./commands/read.js";
-import { cmdRotate } from "./commands/rotate.js";
-import { cmdWhere } from "./commands/where.js";
-import {
-  cmdAdd,
-  cmdClaim,
-  cmdClose,
-  cmdHook,
-  cmdRelease,
-  cmdSynced,
-} from "./commands/write.js";
-import { doneDir, planDir } from "./store.js";
-
-const MEM_HELP = `usage: fapony mem [--mem-dir <path>] <sub> [args]
-
-subcommands:
-  where                       show the resolved mem dir and which step won
-  kickoff [<plan.md>] [--pick <n>]   open a session + a next-up list
-  add <kind> "<text>" --files f1,f2 [--key k] [spec.md]
-  close <id> "<msg>"          close a bug
-  find ["<text>"] [--kind a,b] [--files f1,f2] [--since <N>d|YYYY-MM-DD] [--limit n] [--key k]
-                          substring-search every row (archives included)
-  done | stale              views
-  claim <id> | release <id> | synced   bookkeeping
-  plan-sweep [<plan.md> [--apply]]     move shipped plans + fix links
-  plan-check <plan.md>        validate a plan's frontmatter/sections
-  rotate                      archive the live log when it grows
-  hook                        Stop-hook payload reader (installed, not run by hand)
-
---mem-dir <path> wins over config and the walk-up (global to every sub)
-example: fapony mem add note "decided X because Y" --files src/a.ts`;
-
-const HELP: Record<string, string> = {
-  where: `usage: fapony mem where [--from <dir>]
-show the .fapony/.memory dir the resolver picks and which step won — writes nothing
-  --from <dir>    resolve as if cwd were here
-example: fapony mem where`,
-  kickoff: `usage: fapony mem kickoff [<plan.md>] [--pick <n>]
-open a session and print a "next up" list (priority plans, unchecked chunks, open bugs)
-  <plan.md>   plan whose first unchecked chunk is offered as a context line
-  --pick <n>  run suggestion [n] non-interactively; refuses context/template items
-example: fapony mem kickoff .fapony/plan/PLAN-x.md`,
-  add: `usage: fapony mem add <next|bug|decision|note|hold> "<text>" --files f1,f2 [--key k] [spec.md]
-append one row to the mem log
-  --files f1,f2   repo-relative paths this row is about (required)
-  --key k         problem identity, [a-z0-9-]{3,40} — same problem = same key (optional)
-  --stdin         read <text> from stdin (avoids shell metachar)
-example: fapony mem add decision "chose X because Y" --files src/a.ts,src/b.ts --key unify-mem-engine`,
-  close: `usage: fapony mem close <id> "<what was done | commit>"
-tombstone a bug so it stops showing as open work
-  --stdin         read the message from stdin
-example: fapony mem close mt14 "fixed in a2c6beb"`,
-  find: `usage: fapony mem find ["<text>"] [--kind a,b] [--files f1,f2] [--since <N>d|YYYY-MM-DD] [--limit n] [--key k]
-substring search over every row's text/spec/ref (rotated archives included) — bookkeeping kinds (close/synced/claim/release) hidden unless --kind names them
-  --kind a,b    include only these kinds (overrides the bookkeeping default)
-  --files f1,f2 rows about these paths (stored files[] first, text/spec/ref fallback)
-  --key k       exact problem-identity match — a miss prints the known keys
-  --since 7d    only rows at or after this time (<N>d or YYYY-MM-DD)
-  --limit n     max rows returned (default 20, newest first)
-example: fapony mem find "usage-web" --kind bug,decision --limit 5`,
-  done: `usage: fapony mem done
-closed rows with their tombstone message
-example: fapony mem done`,
-  stale: `usage: fapony mem stale
-decisions that never made it into their spec
-example: fapony mem stale`,
-  claim: `usage: fapony mem claim <id>
-claim an open next|bug before working it
-example: fapony mem claim mt14`,
-  release: `usage: fapony mem release <id> [--stdin]
-give back a claimed row without closing it
-example: fapony mem release mt14`,
-  synced: `usage: fapony mem synced [<spec.md>]
-mark a spec as carried into the log
-example: fapony mem synced .fapony/spec/SPEC-x.md`,
-  "plan-sweep": `usage: fapony mem plan-sweep [<plan.md>] [--apply]
-find shipped plans (or move one) and fix the links that point at it
-  --apply   perform the git mv + link fixes (default = dry run)
-example: fapony mem plan-sweep .fapony/plan/PLAN-x.md --apply`,
-  "plan-check": `usage: fapony mem plan-check <plan.md>
-validate a plan's frontmatter and required sections
-example: fapony mem plan-check .fapony/plan/PLAN-x.md`,
-  rotate: `usage: fapony mem rotate
-archive the live log to log.YYYY-MM-DD.jsonl once it crosses the threshold
-example: fapony mem rotate`,
-  hook: `usage: fapony mem hook
-reads the Stop-hook payload on stdin — installed by fapony, not run by hand
-example: (installed hook only)`,
-};
-
-// Subcommand names for top-level did-you-mean (src/commands.ts) — derived
-// from HELP keys so the list cannot drift from the dispatch below.
-export const MEM_SUBCOMMANDS: string[] = Object.keys(HELP);
-
-// Chunk 7 (PLAN-seed-and-surface, bug muc85pml): `fapony mem now` used to fall
-// through to kickoff and print an overview ("N entries") instead of an error —
-// a typo that looks like success. Three rules, in order:
-//   1. a known subcommand → dispatch (unchanged)
-//   2. looks like a plan path (.md suffix, a slash, or a file with that name
-//      in planDir/doneDir) → kickoff — this is `fapony mem PLAN-x.md`, which
-//      must keep working without the `kickoff` word
-//   3. anything else → error, exit 1 (a typo is never a kickoff)
-//
-// `exists` is injectable so tests hit this directly without a store on disk —
-// production passes nothing and reads planDir/doneDir live.
-export function classifyMemArg(
-  arg: string,
-  exists?: (name: string) => boolean,
-): "subcommand" | "plan" | "unknown" {
-  // hasOwn, not `in` or indexing — prototype props ("toString") are not
-  // subcommands.
-  if (Object.hasOwn(HELP, arg)) return "subcommand";
-  if (arg.endsWith(".md") || arg.includes("/")) return "plan";
-  const has =
-    exists ??
-    ((name: string): boolean => {
-      const base = basename(name);
-      const candidates = [name, base, `${name}.md`, `${base}.md`];
-      return candidates.some(
-        (c) => existsSync(join(planDir, c)) || existsSync(join(doneDir, c)),
-      );
-    });
-  if (has(arg)) return "plan";
-  return "unknown";
-}
-
-export async function cmdMem(a: string[], memDir?: string): Promise<void> {
-  const [cmd, ...rest] = a;
-
-  // SPEC §2: every subcommand answers --help with signature + flags + one runnable
-  // example, because the reader is an agent that gets one call to get it right.
-  if (cmd === "-h" || cmd === "--help") {
-    console.log(MEM_HELP);
-    return;
-  }
-  if (rest.includes("-h") || rest.includes("--help")) {
-    console.log(HELP[cmd] ?? MEM_HELP);
-    return;
-  }
-
-  if (cmd === "add") {
-    await cmdAdd(rest);
-  } else if (cmd === "close") {
-    await cmdClose(rest);
-  } else if (cmd === "claim") {
-    cmdClaim(rest);
-  } else if (cmd === "release") {
-    await cmdRelease(rest);
-  } else if (cmd === "synced") {
-    cmdSynced(rest);
-  } else if (cmd === "hook") {
-    await cmdHook();
-  } else if (cmd === "done") {
-    cmdDone();
-  } else if (cmd === "stale") {
-    cmdStale();
-  } else if (cmd === "find") {
-    cmdFind(rest);
-  } else if (cmd === "kickoff") {
-    cmdKickoff(rest);
-  } else if (cmd === "where") {
-    cmdWhere(rest, memDir);
-  } else if (cmd === "plan-sweep") {
-    cmdPlanSweep(rest);
-  } else if (cmd === "plan-check") {
-    cmdPlanCheck(rest);
-  } else if (cmd === "rotate") {
-    cmdRotate(rest);
-  } else if (cmd === undefined) {
-    // bare `fapony mem` → kickoff (ranked session overview)
-    cmdKickoff(rest);
-  } else if (classifyMemArg(cmd) === "plan") {
-    // `fapony mem PLAN-x.md` — the plan arg rides along (the old else-branch
-    // dropped it and printed the no-arg overview instead).
-    cmdKickoff([cmd, ...rest]);
-  } else {
-    console.error(`fapony mem: unknown subcommand "${cmd}"`);
-    const scored = MEM_SUBCOMMANDS.map((s) => ({
-      s,
-      d: levenshtein(cmd, s),
-    }))
-      .filter((x) => x.d <= 2)
-      .sort((x, y) => x.d - y.d || (x.s < y.s ? -1 : 1))
-      .slice(0, 3)
-      .map((x) => `"fapony mem ${x.s}"`);
-    if (scored.length > 0) {
-      console.error(`did you mean ${scored.join(" or ")}?`);
-    }
-    console.error(`subcommands: ${MEM_SUBCOMMANDS.join(" ")}`);
-    process.exit(1);
-  }
-}

package/src/mem/render.ts

@@ -1,66 +0,0 @@
-// render.ts — formatting and display helpers for the memory log
-
-import { claimsOf, openRows } from "./selectors.js";
-import type { ClaimRow, CloseRow, LogRow, WorkRow } from "./store.js";
-
-export const fmtRow = (r: WorkRow, claims?: Map<string, ClaimRow>) => {
-  let s = `- [${r.id}]`;
-  if (claims?.has(r.id)) s += ` (${claims.get(r.id)?.agent})`;
-  s += ` ${r.kind}`;
-  // key only when present — rows without one stay byte-identical
-  if (r.key) s += ` #${r.key}`;
-  s += ` ${r.text}`;
-  if (r.spec) s += ` → ${r.spec}`;
-  return s;
-};
-
-export const printOpenRows = (all: LogRow[], opts?: { showHold?: boolean }) => {
-  const open = openRows(all);
-  const claims = claimsOf(all);
-
-  // in-progress (claimed items)
-  const inProg = open.filter(
-    (r) => claims.has(r.id) && (r.kind === "next" || r.kind === "bug"),
-  );
-  if (inProg.length) {
-    console.log(
-      `\n## in-progress\n${inProg.map((r) => fmtRow(r, claims)).join("\n")}`,
-    );
-  }
-
-  // next (unclaimed only)
-  const nexts = open.filter((r) => r.kind === "next" && !claims.has(r.id));
-  if (nexts.length) {
-    console.log(`\n## next\n${nexts.map((r) => fmtRow(r)).join("\n")}`);
-  }
-
-  // bug (unclaimed only)
-  const bugs = open.filter((r) => r.kind === "bug" && !claims.has(r.id));
-  if (bugs.length) {
-    console.log(`\n## bug\n${bugs.map((r) => fmtRow(r)).join("\n")}`);
-  }
-
-  // hold — sorted by spec for per-plan visibility
-  if (opts?.showHold) {
-    const holds = open
-      .filter((r) => r.kind === "hold")
-      .sort((a, b) => (a.spec ?? "").localeCompare(b.spec ?? ""));
-    if (holds.length) {
-      console.log(`\n## hold\n${holds.map((r) => fmtRow(r)).join("\n")}`);
-    }
-  }
-};
-
-export const fmtClose = (c: CloseRow, byId: Map<string, WorkRow>) => {
-  const o = byId.get(c.ref);
-  const agentStr = c.agent && c.agent !== "unknown" ? ` (${c.agent})` : "";
-  return `- ${c.ts.slice(0, 10)}${agentStr} ${o && "text" in o ? o.text : c.ref} → ${c.text}`;
-};
-
-export const doneLines = (all: LogRow[], limit?: number) => {
-  const workAll = all.filter((r): r is WorkRow => "id" in r);
-  const byId = new Map(workAll.map((r) => [r.id, r] as const));
-  const closes = all.filter((r): r is CloseRow => r.kind === "close").reverse();
-  const slice = limit ? closes.slice(0, limit) : closes;
-  return slice.map((c) => fmtClose(c, byId));
-};

package/src/mem/selectors.ts

@@ -1,160 +0,0 @@
-// selectors.ts — derive open/claimed/stale views from the append-only log
-
-import type {
-  ClaimRow,
-  CloseRow,
-  LogRow,
-  ReleaseRow,
-  WorkRow,
-} from "./store.js";
-
-// ponytail: reducer = filter + tombstone set. 50k lines = 9.6MB/26ms — the file is not the bottleneck
-// the real ceiling = too many open rows for the view to make sense → rotate then: git mv + append openRows(old) into a new file
-export const openRows = (all: LogRow[]): WorkRow[] => {
-  const dead = new Set(
-    all.filter((r): r is CloseRow => r.kind === "close").map((r) => r.ref),
-  );
-  return all.filter(
-    (r): r is WorkRow =>
-      r.kind !== "close" &&
-      r.kind !== "claim" &&
-      r.kind !== "release" &&
-      r.kind !== "synced" &&
-      "id" in r &&
-      !dead.has(r.id),
-  );
-};
-
-// Distinct keys on open work rows, sorted — the important-index ingredient
-// (PLAN-mem-keys chunk 3). A key is open while ≥1 keyed row survives the
-// tombstone set; computed live like every other selector, never persisted.
-// Decisions are skipped: nobody closes them, so a keyed decision would sit in
-// the index forever as a fake "open problem".
-export const openKeys = (all: LogRow[]): { key: string; open: number }[] => {
-  const counts = new Map<string, number>();
-  for (const r of openRows(all)) {
-    if (r.key && r.kind !== "decision")
-      counts.set(r.key, (counts.get(r.key) ?? 0) + 1);
-  }
-  return [...counts.entries()]
-    .map(([key, open]) => ({ key, open }))
-    .sort((a, b) => a.key.localeCompare(b.key));
-};
-
-// C) claimsOf: returns Map ref → latest claim row still active
-// active = the latest claim|release row is a claim and ref is not in dead (close)
-export const claimsOf = (all: LogRow[]): Map<string, ClaimRow> => {
-  const dead = new Set(
-    all.filter((r): r is CloseRow => r.kind === "close").map((r) => r.ref),
-  );
-  const latest = new Map<string, ClaimRow | ReleaseRow>();
-  for (const r of all) {
-    if (r.kind === "claim" || r.kind === "release") {
-      latest.set(r.ref, r);
-    }
-  }
-  const active = new Map<string, ClaimRow>();
-  for (const [ref, r] of latest) {
-    if (r.kind === "claim" && !dead.has(ref)) {
-      active.set(ref, r);
-    }
-  }
-  return active;
-};
-
-// a decision newer than both the spec's latest commit and the synced marker = spec not updated to match
-// + next/hold whose spec was edited after creation = may be done already but nobody closed it — real case: msbnndmt
-// + an active claim older than 4h = the agent may have died mid-task
-export const staleReport = (all: LogRow[]): string[] => {
-  const out: string[] = [];
-  const mark: Record<string, number> = {};
-  for (const r of all) {
-    if (r.kind === "synced") mark[r.spec] = Date.parse(r.ts);
-  }
-
-  // batch: collect unique spec paths, spawn one git per path
-  const specPaths = new Set<string>();
-  for (const r of all) {
-    if (r.kind === "decision" && r.spec) specPaths.add(r.spec);
-  }
-  for (const r of openRows(all)) {
-    if ((r.kind === "next" || r.kind === "hold") && r.spec)
-      specPaths.add(r.spec);
-  }
-  const gitDates = new Map<string, number>();
-  for (const spec of specPaths) {
-    // --follow: a spec path that was git mv'd (e.g. moved into plan/done/) can still follow its history
-    const git = Bun.spawnSync([
-      "git",
-      "log",
-      "-1",
-      "--follow",
-      "--format=%cI",
-      "--",
-      spec,
-    ])
-      .stdout.toString()
-      .trim();
-    if (git) gitDates.set(spec, Date.parse(git));
-  }
-
-  for (const r of all) {
-    if (r.kind === "decision" && r.spec) {
-      const base = Math.max(gitDates.get(r.spec) ?? 0, mark[r.spec] ?? 0);
-      if (base < Date.parse(r.ts))
-        out.push(
-          `STALE ${r.spec}: decision ${r.ts.slice(0, 10)} never made it into the spec — "${r.text}"`,
-        );
-    }
-  }
-  for (const r of openRows(all)) {
-    if ((r.kind === "next" || r.kind === "hold") && r.spec) {
-      const gitDate = gitDates.get(r.spec);
-      // ponytail: 24h grace — "log next then write/commit the plan the same day" is normal workflow
-      // not a signal that the work finished and was forgotten (the real case to catch, msbnndmt, is days apart) —
-      // without grace = SUSPECT fires on every freshly written plan, and everyone learns to skim past the whole stale block
-      if (gitDate && gitDate > Date.parse(r.ts) + 86_400_000)
-        out.push(
-          `SUSPECT [${r.id}] ${r.spec} changed after this ${r.kind} (${r.ts.slice(0, 10)}) — check whether it is already done`,
-        );
-    }
-  }
-  const claims = claimsOf(all);
-  for (const [ref, c] of claims) {
-    const ageH = (Date.now() - Date.parse(c.ts)) / 3_600_000;
-    if (ageH > 4) {
-      out.push(
-        `SUSPECT claim [${ref}] by ${c.agent} ${c.ts.slice(0, 10)} never closed/released — the agent may have died mid-task`,
-      );
-    }
-  }
-  return out;
-};
-
-// rotate: rows that must carry over into the new log file after archiving
-// - open next/bug/hold + still-active claims on those rows (close/claim of already-closed refs = discardable)
-// - decision/note has no "close" of its own (permanent history by design) but resolves indirectly via synced:
-//   spec was synced *after* this row = the info really made it into the spec, archive (git) is enough, no need to carry it in the hot file
-//   (same logic as staleReport's decision check — no spec or not yet synced by this row = still considered relevant, keep it)
-// ponytail: a decision/note with no spec gives no way to know if it is resolved — keep it forever (the real ceiling is
-// attaching a spec at log time if you want rotate to be able to drop it later, not rotate's own problem)
-export const rotateKeep = (all: LogRow[]): LogRow[] => {
-  const open = openRows(all);
-  const workOpen = open.filter(
-    (r) => r.kind === "next" || r.kind === "bug" || r.kind === "hold",
-  );
-  const claims = claimsOf(all);
-  const openIds = new Set(workOpen.map((r) => r.id));
-  const keepClaims = [...claims.values()].filter((c) => openIds.has(c.ref));
-
-  const syncedAt: Record<string, number> = {};
-  for (const r of all)
-    if (r.kind === "synced") syncedAt[r.spec] = Date.parse(r.ts);
-  const keepDecisionNote = open.filter(
-    (r) =>
-      (r.kind === "decision" || r.kind === "note") &&
-      (!r.spec || !(r.spec in syncedAt) || syncedAt[r.spec] < Date.parse(r.ts)),
-  );
-
-  return [...workOpen, ...keepDecisionNote, ...keepClaims];
-};