fapony 0.3.5 → 0.4.0

package/src/mem/engine.ts

@@ -0,0 +1,249 @@
+// src/mem/engine.ts — the single validation+write engine for mem add/close.
+//
+// Both entry points call it: CLI (commands/write.ts cmdAdd/cmdClose) and MCP
+// (adapters/mcp/tools/mem.ts memAdd/memClose). Every domain rule lives here
+// exactly once — kind check, files[] required, hold-requires-spec, open
+// next/hold caps. Wrappers own only their surface: argv parsing +
+// console.error/exit (CLI), worktree-shape checks + JSON results (MCP).
+//
+// Precondition: the store is initialized (initStore) before calling — cli.ts
+// does it at dispatch, the MCP wrapper does it per call with its worktree.
+// (PLAN-unify-mem-engine chunk 1)
+
+import { openRows } from "./selectors.js";
+import { KINDS, nextId, put, rows, type WorkKind } from "./store.js";
+
+export const CAP_NEXT = 15;
+export const CAP_HOLD = 10;
+
+/**
+ * Thrown when an open next/hold cap is full. Carries which cap so the CLI
+ * wrapper can append its MEM_FORCE hint while MCP passes the bare message
+ * (the two surfaces keep their exact legacy strings — PLAN §4).
+ */
+export class CapError extends Error {
+  readonly cap: "next" | "hold";
+  constructor(cap: "next" | "hold", message: string) {
+    super(message);
+    this.name = "CapError";
+    this.cap = cap;
+  }
+}
+
+export interface EngineAddArgs {
+  kind: string;
+  text: string;
+  files: string[];
+  spec?: string;
+}
+
+export interface EngineAddResult {
+  id: string;
+  kind: string;
+  text: string;
+  files: string[];
+  spec?: string;
+  ts: string;
+}
+
+export function engineAdd(a: EngineAddArgs): EngineAddResult {
+  if (!KINDS.includes(a.kind as WorkKind)) {
+    throw new Error(`kind must be one of ${KINDS.join("|")} — got "${a.kind}"`);
+  }
+  if (a.files.length === 0) {
+    throw new Error("files must contain at least one path");
+  }
+  if (!a.text.trim()) {
+    throw new Error("text is required and must not be empty");
+  }
+  // Without a spec a hold can never be resolved by rotate — reject at write.
+  if (a.kind === "hold" && !a.spec) {
+    throw new Error("hold requires a spec — pass spec: <path/to/SPEC.md>");
+  }
+
+  const all = rows();
+  if (a.kind === "next" && !process.env.MEM_FORCE) {
+    const openNext = openRows(all).filter((r) => r.kind === "next").length;
+    if (openNext >= CAP_NEXT) {
+      throw new CapError(
+        "next",
+        `open next ${openNext}/${CAP_NEXT} is full — close an old one first`,
+      );
+    }
+  }
+  if (a.kind === "hold" && !process.env.MEM_FORCE) {
+    const openHold = openRows(all).filter((r) => r.kind === "hold").length;
+    if (openHold >= CAP_HOLD) {
+      throw new CapError(
+        "hold",
+        `open hold ${openHold}/${CAP_HOLD} is full — close/release an old one first`,
+      );
+    }
+  }
+
+  const id = nextId(all);
+  const ts = new Date().toISOString();
+  put({
+    id,
+    kind: a.kind as WorkKind,
+    text: a.text,
+    spec: a.spec,
+    files: a.files,
+  });
+  return { id, kind: a.kind, text: a.text, files: a.files, spec: a.spec, ts };
+}
+
+export interface EngineCloseArgs {
+  id: string;
+  text: string;
+}
+
+export interface EngineCloseResult {
+  ref: string;
+  text: string;
+  ts: string;
+}
+
+export function engineClose(a: EngineCloseArgs): EngineCloseResult {
+  if (!a.id.trim()) {
+    throw new Error("id is required");
+  }
+  if (!a.text.trim()) {
+    throw new Error("text is required and must not be empty");
+  }
+
+  const all = rows();
+  if (!all.some((r) => "id" in r && r.id === a.id)) {
+    throw new Error(`no id "${a.id}" in the log`);
+  }
+
+  const ts = new Date().toISOString();
+  put({ kind: "close", ref: a.id, text: a.text });
+
+  return { ref: a.id, text: a.text, ts };
+}
+
+// --- find ---
+//
+// The single query engine for mem find. Both entry points call it with rows
+// they already read — CLI (commands/read.ts cmdFind, via allRows() which
+// includes rotated archives) and MCP (adapters/mcp/tools/mem.ts memFind, via
+// readMemLog whose loose log*.jsonl regex includes log.YYYY-MM-DD.jsonl too).
+// Archive scope is therefore identical on both sides with no parameter for it
+// (PLAN-unify-mem-engine chunk 2 §4.1: the "MCP reads live only" premise was
+// wrong — both see archives, base rate 0 archive files vs 211 live rows).
+//
+// The engine is pure: it takes rows + typed params, never touches argv
+// strings or the store. Wrappers own their surface — CLI parses
+// --kind/--files/--since/--limit/--open at the argv layer, MCP validates its JSON
+// shape — and each passes its own kind default (PLAN §5 escape):
+// MCP passes no exclude (contract: "every kind, no default filter", locked by
+// test), CLI passes the bookkeeping exclude to keep its legacy output.
+
+export const FIND_DEFAULT_LIMIT = 20;
+
+/** Bookkeeping rows the CLI hides unless explicitly asked via --kind. */
+export const CLI_FIND_EXCLUDE = ["close", "synced", "claim", "release"];
+
+export interface EngineFindArgs {
+  /** Substring over text/spec/ref, case-insensitive. Omit = no text filter. */
+  text?: string;
+  /** Repo-relative paths — stored files[] first, text/spec/ref fallback. */
+  files?: string[];
+  /** Include filter — when non-empty, wins over excludeKind. */
+  kind?: string[];
+  /** Exclude filter — applied only when kind is empty. */
+  excludeKind?: string[];
+  /** ISO timestamp — only rows at or after this time (inclusive). */
+  sinceIso?: string;
+  /** Max rows returned (total still counts all matches). Default 20. */
+  limit?: number;
+  /**
+   * true = unresolved work only: drops bookkeeping kinds
+   * (close/claim/release/synced) plus work rows a close row points at.
+   * Mirrors selectors.openRows but stays generic (no store types) so MCP rows
+   * qualify. Default false — recall shows closed rows too.
+   */
+  open?: boolean;
+}
+
+export interface EngineFindResult<T> {
+  rows: T[];
+  total: number;
+}
+
+export type FindableRow = {
+  kind: string;
+  text?: string;
+  spec?: string;
+  ref?: string;
+  files?: string[];
+  ts: string;
+};
+
+export function engineFind<T extends FindableRow>(
+  all: T[],
+  a: EngineFindArgs,
+): EngineFindResult<T> {
+  let out = [...all];
+
+  if (a.open === true) {
+    const dead = new Set(
+      all
+        .filter((r) => r.kind === "close" && typeof r.ref === "string")
+        .map((r) => r.ref as string),
+    );
+    const BOOKKEEPING = new Set(["close", "claim", "release", "synced"]);
+    out = out.filter(
+      (r) =>
+        !BOOKKEEPING.has(r.kind) &&
+        !("id" in r && typeof r.id === "string" && dead.has(r.id)),
+    );
+  }
+
+  if (a.sinceIso) {
+    const since = a.sinceIso;
+    out = out.filter((r) => !(r.ts < since));
+  }
+
+  if (a.kind && a.kind.length > 0) {
+    const keep = new Set(a.kind);
+    out = out.filter((r) => keep.has(r.kind));
+  } else if (a.excludeKind && a.excludeKind.length > 0) {
+    const drop = new Set(a.excludeKind);
+    out = out.filter((r) => !drop.has(r.kind));
+  }
+
+  if (a.text?.trim()) {
+    const needle = a.text.toLowerCase();
+    out = out.filter((r) =>
+      `${r.text ?? ""}\n${r.spec ?? ""}\n${r.ref ?? ""}`
+        .toLowerCase()
+        .includes(needle),
+    );
+  }
+
+  if (a.files && a.files.length > 0) {
+    // Rows written by `mem add --files` carry files[] — match that first.
+    // Older rows (and any row whose author skipped --files) have none, so the
+    // text/spec/ref substring stays as the fallback: low recall by nature,
+    // a limit of the data rather than of the query.
+    const paths = a.files.map((f) => f.toLowerCase());
+    out = out.filter((r) => {
+      const stored = (r.files ?? []).map((f) => f.toLowerCase());
+      if (stored.some((f) => paths.some((p) => f === p || f.endsWith(`/${p}`))))
+        return true;
+      const hay =
+        `${r.text ?? ""}\n${r.spec ?? ""}\n${r.ref ?? ""}`.toLowerCase();
+      return paths.some((p) => hay.includes(p));
+    });
+  }
+
+  // Newest first — the canonical order. The CLI wrapper reprints oldest-first
+  // to keep its legacy output byte-identical (same set, legacy order).
+  out.sort((x, y) => y.ts.localeCompare(x.ts));
+
+  const total = out.length;
+  const limit = Math.max(0, a.limit ?? FIND_DEFAULT_LIMIT);
+  return { rows: out.slice(0, limit), total };
+}

package/src/mem/index.ts

@@ -27,7 +27,8 @@ subcommands:
   kickoff [<plan.md>] [--pick <n>]   open a session + a next-up list
   add <kind> "<text>" --files f1,f2 [spec.md]
   close <id> "<msg>"          close a bug
-  find "<text>"               substring-search every row
+  find ["<text>"] [--kind a,b] [--files f1,f2] [--since <N>d|YYYY-MM-DD] [--limit n]
+                          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
@@ -57,9 +58,13 @@ example: fapony mem add decision "chose X because Y" --files src/a.ts,src/b.ts`,
 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>"
-substring search over every row's text/spec/ref — all kinds, no default filter
-example: fapony mem find "usage-web"`,
+  find: `usage: fapony mem find ["<text>"] [--kind a,b] [--files f1,f2] [--since <N>d|YYYY-MM-DD] [--limit n]
+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)
+  --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`,

package/src/seed/review-seed.ts

@@ -21,7 +21,7 @@
 
 import type { Stats } from "node:fs";
 import { existsSync, readFileSync, statSync } from "node:fs";
-import { join } from "node:path";
+import { isAbsolute, join, resolve } from "node:path";
 import {
   buildGraph,
   collectSourceFiles,
@@ -357,9 +357,35 @@ function shortSha(cwd: string, ref: string): string | null {
   return r.ok ? r.output.split("\n")[0] : null;
 }
 
-function resolveScope(scope: Scope, cwd: string): ResolvedScope {
+// --plan paths arrive in three shapes: absolute, relative to the invocation
+// cwd (e.g. ../../.fapony/plan/X.md from a subdir), or relative to the
+// worktree root (e.g. .fapony/plan/X.md from anywhere). join(worktree, arg)
+// answers only the third — an absolute arg becomes worktree+abs garbage
+// (join, unlike resolve, does not reset on an absolute segment), and a
+// cwd-relative arg with .. escapes above the root. So: absolute as-is,
+// otherwise first-existing-wins between cwd and worktree (bug mucm1own).
+function resolvePlanPath(arg: string, cwd: string, worktree: string): string {
+  if (isAbsolute(arg)) {
+    if (existsSync(arg)) return arg;
+    throw new SeedError(`review-seed: plan file not found: ${arg}`);
+  }
+  const candidates = [resolve(cwd, arg), join(worktree, arg)];
+  for (const p of new Set(candidates)) {
+    if (existsSync(p)) return p;
+  }
+  throw new SeedError(`review-seed: plan file not found: ${arg}`);
+}
+
+function resolveScope(
+  scope: Scope,
+  cwd: string,
+  worktree: string,
+): ResolvedScope {
   if (scope.kind === "files") {
-    const { files, notes, dirExpanded } = expandFilesScope(scope.list, cwd);
+    const { files, notes, dirExpanded } = expandFilesScope(
+      scope.list,
+      worktree,
+    );
     return {
       label: dirExpanded ? "--files (dir-expanded)" : "--files (as given)",
       entries: files,
@@ -367,10 +393,7 @@ function resolveScope(scope: Scope, cwd: string): ResolvedScope {
     };
   }
   if (scope.kind === "plan") {
-    const planPath = join(cwd, scope.path);
-    if (!existsSync(planPath)) {
-      throw new SeedError(`review-seed: plan file not found: ${scope.path}`);
-    }
+    const planPath = resolvePlanPath(scope.path, cwd, worktree);
     const planFiles = planFrontFiles(readFileSync(planPath, "utf-8"));
     if (planFiles === null) {
       // No files[] to scope from — fall back to the default diff, say so.
@@ -567,6 +590,7 @@ function findCallers(
 function renderLookup(
   flags: LookupFlags,
   scope: Scope,
+  cwd: string,
   worktree: string,
 ): string {
   const lines: string[] = [];
@@ -574,7 +598,7 @@ function renderLookup(
 
   let resolved: ResolvedScope | null = null;
   if (flags.callers) {
-    resolved = resolveScope(scope, worktree);
+    resolved = resolveScope(scope, cwd, worktree);
   }
 
   const hasGraph = (f: string): boolean => {
@@ -686,10 +710,10 @@ export function renderSeed(args: string[], cwd: string): string {
   // the caller asked for one answer, not the review seed around it.
   const lookup = parseLookup(args);
   if (lookup.body.length > 0 || lookup.callers) {
-    return renderLookup(lookup, scope, worktree);
+    return renderLookup(lookup, scope, cwd, worktree);
   }
 
-  const resolved = resolveScope(scope, worktree);
+  const resolved = resolveScope(scope, cwd, worktree);
   const entries = [...resolved.entries].sort((a, b) =>
     a.path < b.path ? -1 : 1,
   );

package/src/update.ts

@@ -2,10 +2,12 @@
 // ROOT must be the repo root: import.meta.dir is src/, one level below it.
 // Shows old → new version, recent commits, and warns if uncommitted changes.
 
-import { execSync } from "node:child_process";
+import { execSync, spawnSync } from "node:child_process";
 import { existsSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
 import { join } from "node:path";
 import { createInterface } from "node:readline";
+import { opencodePluginFiles } from "./install/opencode.js";
 import { isAffirmative } from "./util.js";
 
 /** Repo root (parent of src/) — where package.json and bun.lock live.
@@ -27,12 +29,59 @@ function defaultInstall(): void {
   execSync("bun install", { cwd: ROOT, stdio: "pipe", timeout: 300_000 });
 }
 
+/** argv for the spawned plugin refresh — exported so tests can pin the flags:
+ *  a wrong flag fails silently (the child would just do a full install and
+ *  rewrite opencode.json, the exact bug `--plugins-only` exists to prevent). */
+export function refreshArgv(files: string[]): string[] {
+  const argv = [
+    join(ROOT, "fapony.ts"),
+    "install",
+    "--platform",
+    "opencode",
+    // Plugins only: a refresh touches fapony-owned plugin files, never the
+    // user's opencode.json (rule 6c).
+    "--plugins-only",
+  ];
+  // Opt-in plugin: refresh it when the user installed it, never create it.
+  if (files.includes("fapony-git-autonomy.ts")) argv.push("--git-autonomy");
+  return argv;
+}
+
+/**
+ * Refresh OpenCode's generated plugin bodies after the pull.
+ *
+ * OpenCode is the only client whose hooks are baked files — every other client
+ * writes a `fapony hook-*` command resolved at run time, so a pull alone keeps
+ * them current. Spawning a *fresh* process is the whole point: this one already
+ * loaded the pre-pull templates, so calling the installer in-process would
+ * rewrite the old body — the exact bug this exists to fix. `process.execPath`
+ * is the bun running fapony, so no PATH dependency. Runs `--plugins-only`, so
+ * the refresh never reads or writes opencode.json or the skills symlink.
+ * Best-effort: a refresh must never fail an update.
+ */
+function defaultRefreshPlugins(): void {
+  const getHome = (): string => homedir();
+  const files = opencodePluginFiles(getHome);
+  if (files.length === 0) return;
+  console.log("\n  Refreshing OpenCode plugins...");
+  const r = spawnSync(process.execPath, refreshArgv(files), {
+    stdio: "pipe",
+    timeout: 30_000,
+  });
+  if (r.error || r.status !== 0) {
+    console.log(
+      "  ⚠  plugin refresh failed — run manually: fapony install --platform opencode --plugins-only",
+    );
+  }
+}
+
 /** Minimal seam for cmdUpdate — git runner (map args→result, throws on failure),
- *  prompt, exit, and bun-install. Every field is used by both the default
- *  (production) path and the test path. */
+ *  prompt, exit, bun-install, and the post-pull OpenCode plugin refresh. Every
+ *  field is used by both the default (production) path and the test path. */
 export interface UpdateDeps {
   git?: (args: string) => string;
   install?: () => void;
+  refresh?: () => void;
   prompt?: (question: string, defaultVal?: string) => Promise<string>;
   exit?: (code: number) => never;
 }
@@ -88,6 +137,7 @@ function defaultPrompt(question: string, defaultVal?: string): Promise<string> {
 export async function cmdUpdate(deps: UpdateDeps = {}): Promise<void> {
   const git = deps.git ?? defaultGit;
   const installFn = deps.install ?? defaultInstall;
+  const refreshFn = deps.refresh ?? defaultRefreshPlugins;
   const promptFn = deps.prompt ?? defaultPrompt;
   const exitFn = deps.exit ?? ((code: number): never => process.exit(code));
   const gitQuiet = (args: string): string | null => {
@@ -173,6 +223,10 @@ export async function cmdUpdate(deps: UpdateDeps = {}): Promise<void> {
   // --- show what changed ---
   if (isUpToDate(oldSha, newSha)) {
     console.log(`\n  ✓  Already up to date (${oldVersion} @ ${oldSha}).`);
+    // The repo being current says nothing about the generated plugin bodies —
+    // a user who pulled by hand, or installed before the template changed, is
+    // exactly who needs this. Refresh is a no-op when nothing is stale.
+    refreshFn();
     return;
   }
 
@@ -201,6 +255,9 @@ export async function cmdUpdate(deps: UpdateDeps = {}): Promise<void> {
     }
   }
 
+  // --- refresh generated plugin bodies (after deps — the fresh process needs them) ---
+  refreshFn();
+
   console.log(`
   ┌──────────────────────────────────────────┐
   │  Update complete!                        │