fapony 0.7.0 → 0.7.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,227 +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;
-};
-
-// Eviction (PLAN-mem-core chunk 5): rows whose files[] no longer resolve on
-// disk. Local only — the caller passes existence, this module never touches
-// fs or git (plan §4: eviction ไม่เรียก git เลย). Append-only: these selectors
-// report and redirect, they never delete rows.
-export const evictedRows = (
-  all: LogRow[],
-  exists: (rel: string) => boolean,
-): WorkRow[] =>
-  openRows(all).filter(
-    (r) =>
-      (r.files ?? []).length > 0 && (r.files ?? []).every((f) => !exists(f)),
-  );
-
-// Follow a move by basename: a missing path whose basename names exactly one
-// file on disk is treated as moved there. Two files sharing the basename =
-// ambiguous → no entry (silent, never guessed). A rename that changes the
-// basename itself is out of reach — said plainly, not guessed at.
-export const movedTargets = (
-  missing: string[],
-  onDisk: string[],
-): Map<string, string> => {
-  const byBase = new Map<string, string[]>();
-  for (const f of onDisk) {
-    const b = f.slice(f.lastIndexOf("/") + 1);
-    const list = byBase.get(b) ?? [];
-    list.push(f);
-    byBase.set(b, list);
-  }
-  const out = new Map<string, string>();
-  for (const old of missing) {
-    const b = old.slice(old.lastIndexOf("/") + 1);
-    const cands = (byBase.get(b) ?? []).filter((f) => f !== old);
-    if (cands.length === 1) out.set(old, cands[0]);
-  }
-  return out;
-};
-
-// One report for `mem stale`: EVICTED for open rows whose files[] are all
-// gone, MOVED for rows rescued by a unique-basename match. Rows with ≥1 file
-// still on disk stay silent — mem find --files still reaches them.
-export const evictionReport = (
-  all: LogRow[],
-  exists: (rel: string) => boolean,
-  onDisk: string[],
-): string[] => {
-  const open = openRows(all);
-  const gone = (files: string[]): string[] => files.filter((f) => !exists(f));
-  const moved = movedTargets(
-    [...new Set(open.flatMap((r) => gone(r.files ?? [])))],
-    onDisk,
-  );
-  const out: string[] = [];
-  for (const r of evictedRows(all, exists)) {
-    const missing = gone(r.files ?? []);
-    const rescued = missing.filter((f) => moved.has(f));
-    if (rescued.length === missing.length) {
-      const hops = rescued.map((f) => `${f} → ${moved.get(f)}`).join(", ");
-      out.push(`MOVED [${r.id}] ${r.kind} ${hops} — "${r.text}"`);
-    } else {
-      out.push(
-        `EVICTED [${r.id}] ${r.kind} files gone: ${missing.join(", ")} — "${r.text}"`,
-      );
-    }
-  }
-  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];
-};

package/src/mem/store.ts

@@ -1,356 +0,0 @@
-// store.ts — types + config + read/write primitives for the append-only memory log
-//
-// Moved from templates/mem/store.ts (2026-09-19) as part of PLAN-agent-one-call chunk 1.
-// The template was copied into every repo via `fapony init-mem`; now fapony owns the code
-// and calls it directly via `fapony mem <sub>`. Path resolution is no longer based on
-// import.meta.dir — initStore() receives the worktree explicitly from the CLI dispatch.
-
-import { createHash } from "node:crypto";
-import {
-  appendFileSync,
-  existsSync,
-  mkdirSync,
-  readdirSync,
-  readFileSync,
-} from "node:fs";
-import { hostname, networkInterfaces } from "node:os";
-import { basename, dirname, join, relative } from "node:path";
-import {
-  CONFIG_FILENAME,
-  DEFAULT_MEM_DIR,
-  FAPONY_DIR,
-} from "../core/config.js";
-import { whereMemDir } from "../memory.js";
-
-// --- types ---
-
-type WorkKind = "next" | "bug" | "decision" | "note" | "hold";
-
-type WorkRow = {
-  ts: string;
-  agent: string;
-  id: string;
-  kind: WorkKind;
-  text: string;
-  spec?: string;
-  files?: string[];
-  key?: string;
-  v?: number;
-};
-
-type CloseRow = {
-  ts: string;
-  agent: string;
-  kind: "close";
-  ref: string;
-  text: string;
-};
-
-type ClaimRow = {
-  ts: string;
-  agent: string;
-  kind: "claim";
-  ref: string;
-};
-
-type ReleaseRow = {
-  ts: string;
-  agent: string;
-  kind: "release";
-  ref: string;
-  text?: string;
-};
-
-type SyncedRow = {
-  ts: string;
-  agent: string;
-  kind: "synced";
-  spec: string;
-};
-
-type LogRow = WorkRow | CloseRow | ClaimRow | ReleaseRow | SyncedRow;
-
-// --- identity ---
-//
-// `agent` goes in every row, `person` names the file. Both used to end in
-// "unknown", which is not a fallback: two machines with no git and no $USER
-// wrote the same filename and their rows interleaved with no way to tell them
-// apart. Generic OS accounts collide the same way — `admin`/`user`/`owner` are
-// what a fresh install offers, so treat them as absent rather than as a name.
-// git user.email is unique by construction; the machine tag is the last resort,
-// hashed because this file is committed and a raw MAC address is not ours to
-// publish. user.email is only spawned when the cheap sources fail — initStore
-// sits on the mem_add hot path (git config ≈ 12ms).
-
-const GENERIC_NAMES = new Set([
-  "admin",
-  "user",
-  "owner",
-  "root",
-  "ubuntu",
-  "ec2-user",
-  "vagrant",
-  "dev",
-  "developer",
-  "node",
-  "unknown",
-]);
-
-const usable = (v: string | null | undefined): string | null => {
-  const s = (v ?? "").trim();
-  return s && !GENERIC_NAMES.has(s.toLowerCase()) ? s : null;
-};
-
-// `env: process.env` is not redundant: Bun.spawnSync snapshots the environment
-// at startup, so a variable set at runtime (GIT_CONFIG_GLOBAL in a test, MEM_*
-// set by a wrapper) never reaches the child without passing it explicitly.
-const gitConfig = (key: string, cwd: string): string | null =>
-  Bun.spawnSync(["git", "config", key], { cwd, env: process.env })
-    .stdout.toString()
-    .trim() || null;
-
-function machineSeed(): string {
-  try {
-    const id = readFileSync("/etc/machine-id", "utf8").trim();
-    if (id) return id;
-  } catch {
-    // no /etc/machine-id (macOS) — fall through to the interface list
-  }
-  for (const ifaces of Object.values(networkInterfaces()))
-    for (const i of ifaces ?? [])
-      if (!i.internal && i.mac && i.mac !== "00:00:00:00:00:00") return i.mac;
-  return hostname();
-}
-
-const machineTag = (): string =>
-  `m-${createHash("sha256").update(machineSeed()).digest("hex").slice(0, 8)}`;
-
-const slug = (v: string): string =>
-  v
-    .toLowerCase()
-    .replace(/[^a-z0-9._-]+/g, "-")
-    .replace(/^-+|-+$/g, "");
-
-// --- mutable state (populated by initStore) ---
-
-let root = "";
-let dir = "";
-let planDir = "";
-let doneDir = "";
-let agent = "";
-let person = "";
-let LOG = "";
-let memCmd = "";
-let planBase = "";
-let app = "";
-// Non-empty when the resolver found two or more app-scoped mem dirs and no
-// single one at/above cwd — a write must die rather than start a third log.
-let blockWrite = "";
-
-// --- init ---
-
-/**
- * Initialize the store for a given worktree. Must be called before using any
- * export. The CLI dispatch layer calls this with the resolved worktree path.
- *
- * `overrideMemDir` (from --mem-dir flag) skips resolution entirely.
- * Otherwise whereMemDir() walks up from cwd — the same dir the reader
- * (src/memory.ts) uses, so writer and reader cannot drift apart.
- */
-export function initStore(worktree: string, overrideMemDir?: string): void {
-  root = Bun.spawnSync(["git", "rev-parse", "--show-toplevel"], {
-    cwd: worktree,
-  })
-    .stdout.toString()
-    .trim();
-  if (!root) root = worktree;
-
-  // An explicit --mem-dir is a promise: never silently fall back to the
-  // default when the path is wrong, or the row lands in a log nobody reads.
-  if (overrideMemDir && !existsSync(overrideMemDir)) {
-    throw new Error(`--mem-dir path does not exist: ${overrideMemDir}`);
-  }
-
-  // Resolution and the CLI's `mem where` share one function, so the path a row
-  // is written to is the path `mem where` reports.
-  blockWrite = "";
-  const resolved = whereMemDir(worktree, overrideMemDir);
-  if (resolved.step === "ambiguous") {
-    const list = (resolved.candidates ?? []).map((c) => `  ${c}`).join("\n");
-    blockWrite =
-      `two or more .fapony/.memory dirs under ${root} — refusing to guess:\n` +
-      `${list}\ncd into one, set paths.memDir, or pass --mem-dir`;
-  }
-  dir = resolved.dir ?? join(root, DEFAULT_MEM_DIR);
-
-  // planBase: the .fapony dir — plan/done/conventions live here.
-  // Derive from dir by going up from .fapony/.memory → .fapony
-  planBase = dirname(dir);
-
-  // app name for display — the directory containing .fapony
-  app = dirname(planBase);
-
-  // Read fapony.config.json
-  const configDir =
-    planBase === `${root}/${FAPONY_DIR}` ? root : dirname(planBase);
-  const configPaths = ((): Record<string, string> => {
-    try {
-      const raw = readFileSync(`${configDir}/${CONFIG_FILENAME}`, "utf8");
-      return (JSON.parse(raw)?.paths ?? {}) as Record<string, string>;
-    } catch {
-      return {};
-    }
-  })();
-  const fromConfig = (key: string): string | null =>
-    typeof configPaths[key] === "string"
-      ? join(configDir, configPaths[key])
-      : null;
-
-  planDir = `${planBase}/plan`;
-
-  // done/ sits beside plan/ (same depth, relative links survive)
-  doneDir =
-    fromConfig("doneDir") ??
-    (!existsSync(`${planBase}/done`) && existsSync(`${planDir}/done`)
-      ? `${planDir}/done`
-      : `${planBase}/done`);
-
-  let emailCache: string | null | undefined;
-  const email = (): string | null =>
-    emailCache !== undefined
-      ? emailCache
-      : (emailCache = gitConfig("user.email", root));
-
-  agent =
-    process.env.MEM_AGENT?.trim() ||
-    usable(process.env.USER) ||
-    usable(email()) ||
-    machineTag();
-
-  // filename = *person*, not client — naming by MEM_AGENT would collide
-  person = slug(
-    usable(gitConfig("user.name", root)) ||
-      usable(process.env.USER) ||
-      usable(email()) ||
-      machineTag(),
-  );
-
-  LOG = `${dir}/log.${person}.jsonl`;
-  memCmd = `fapony mem`;
-}
-
-// --- log file helpers ---
-
-const isLogFile = (f: string): boolean =>
-  f === "log.jsonl" ||
-  (/^log\.[A-Za-z0-9._-]+\.jsonl$/.test(f) &&
-    !/^log\.\d{4}-\d{2}-\d{2}\.jsonl$/.test(f));
-
-const listLogs = (match: (f: string) => boolean): string[] =>
-  existsSync(dir)
-    ? readdirSync(dir)
-        .filter(match)
-        .sort()
-        .map((f) => join(dir, f))
-    : [];
-
-const logFiles = (): string[] => listLogs(isLogFile);
-
-const archivedFiles = (): string[] =>
-  listLogs((f) => /^log\.\d{4}-\d{2}-\d{2}\.jsonl$/.test(f));
-
-// --- core ---
-
-const parseLog = (f: string): LogRow[] =>
-  readFileSync(f, "utf8")
-    .split("\n")
-    .filter(Boolean)
-    .flatMap((l: string, i: number) => {
-      try {
-        return [JSON.parse(l) as LogRow];
-      } catch {
-        console.error(`[mem] skipped ${basename(f)} line ${i + 1} (bad JSON)`);
-        return [];
-      }
-    });
-
-const byTs = (a: LogRow, b: LogRow) => a.ts.localeCompare(b.ts);
-
-// The live view: what `rotate` counts and what open-work commands read. It must
-// stay archive-free or rotate re-imports the rows it just moved out and never
-// gets under its own threshold.
-const rows = (): LogRow[] => logFiles().flatMap(parseLog).sort(byTs);
-
-// The recall view: rotated rows included. A bug closed six months ago is exactly
-// what `find` exists to surface — rotate shrinks the live file, it does not
-// decide what is still worth remembering.
-const allRows = (): LogRow[] =>
-  [...logFiles(), ...archivedFiles()].flatMap(parseLog).sort(byTs);
-
-function put(r: Omit<WorkRow, "ts" | "agent">): void;
-function put(r: Omit<CloseRow, "ts" | "agent">): void;
-function put(r: Omit<ClaimRow, "ts" | "agent">): void;
-function put(r: Omit<ReleaseRow, "ts" | "agent">): void;
-function put(r: Omit<SyncedRow, "ts" | "agent">): void;
-function put(
-  r:
-    | Omit<WorkRow, "ts" | "agent">
-    | Omit<CloseRow, "ts" | "agent">
-    | Omit<ClaimRow, "ts" | "agent">
-    | Omit<ReleaseRow, "ts" | "agent">
-    | Omit<SyncedRow, "ts" | "agent">,
-) {
-  if (blockWrite) throw new Error(blockWrite);
-  mkdirSync(dir, { recursive: true });
-  appendFileSync(
-    LOG,
-    `${JSON.stringify({ ts: new Date().toISOString(), agent, ...r })}\n`,
-  );
-}
-
-function nextId(all: LogRow[]): string {
-  const used = new Set(all.map((r) => ("id" in r ? r.id : "")));
-  let base = Date.now();
-  let id = base.toString(36);
-  while (used.has(id)) {
-    id = base.toString(36) + Math.random().toString(36).slice(2, 4);
-    base++;
-  }
-  return id;
-}
-
-const appendRaw = (path: string, r: LogRow): void =>
-  appendFileSync(path, `${JSON.stringify(r)}\n`);
-
-const rel = (p: string) => relative(root, p) || ".";
-
-const KINDS: WorkKind[] = ["next", "bug", "decision", "note", "hold"];
-
-export type {
-  ClaimRow,
-  CloseRow,
-  LogRow,
-  ReleaseRow,
-  SyncedRow,
-  WorkKind,
-  WorkRow,
-};
-export {
-  agent,
-  allRows,
-  app,
-  appendRaw,
-  dir,
-  doneDir,
-  KINDS,
-  LOG,
-  memCmd,
-  nextId,
-  person,
-  planBase,
-  planDir,
-  put,
-  rel,
-  root,
-  rows,
-};