fapony 0.3.5 → 0.4.0

package/src/adapters/mcp/tools/mem.ts

@@ -6,15 +6,14 @@
 // file is unfindable when you touch that file (fill rate 26% CLI-flag vs 88%
 // MCP-required — schema wins over prose every time, see CLAUDE.md rule 9).
 
-import { openRows } from "../../../mem/selectors.js";
 import {
-  initStore,
-  KINDS,
-  nextId,
-  put,
-  rows,
-  type WorkKind,
-} from "../../../mem/store.js";
+  type EngineAddResult,
+  type EngineCloseResult,
+  engineAdd,
+  engineClose,
+  engineFind,
+} from "../../../mem/engine.js";
+import { initStore, KINDS, type WorkKind } from "../../../mem/store.js";
 import { type MemRow, readMemLog, resolveMemDir } from "../../../memory.js";
 import { errorResult, jsonResult, type ToolResult } from "../types.js";
 
@@ -33,37 +32,24 @@ export function memFind(args: {
   kind?: string[];
   since?: string;
   limit?: number;
+  open?: boolean;
 }): MemFindResult {
-  const read = readMemLog(args.worktree, args.since);
-
-  let rows = read.rows;
-  if (args.kind && args.kind.length > 0) {
-    const kinds = new Set(args.kind);
-    rows = rows.filter((r) => kinds.has(r.kind));
-  }
-  if (args.text) {
-    const needle = args.text.toLowerCase();
-    rows = rows.filter((r) => r.text.toLowerCase().includes(needle));
-  }
-  if (args.files && args.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 (spec §5.4).
-    const paths = args.files.map((f) => f.toLowerCase());
-    rows = rows.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));
-    });
-  }
-
-  const total = rows.length;
-  const limit = Math.max(0, args.limit ?? 20);
+  // Query logic lives in the shared engine (src/mem/engine.ts) — this wrapper
+  // owns only the read (readMemLog sees live + rotated archives via its loose
+  // log*.jsonl regex) and the result shape. No kind default here by contract:
+  // omitting kind returns every kind (locked by test). CLI cmdFind calls the
+  // same engine with its own bookkeeping exclude.
+  const read = readMemLog(args.worktree);
+  const { rows: matched, total } = engineFind(read.rows, {
+    text: args.text,
+    files: args.files,
+    kind: args.kind,
+    sinceIso: args.since,
+    limit: args.limit,
+    open: args.open,
+  });
   return {
-    rows: rows.slice(0, limit),
+    rows: matched,
     total,
     filesFound: read.filesFound,
     skipped: read.skipped,
@@ -100,24 +86,25 @@ export function toolMemFind(args: Record<string, unknown>): ToolResult {
     : undefined;
   const text = typeof args.text === "string" ? args.text : undefined;
   const since = typeof args.since === "string" ? args.since : undefined;
+  if (since !== undefined && Number.isNaN(Date.parse(since))) {
+    return errorResult(
+      `since must be an ISO date (e.g. 2026-09-19T00:00:00.000Z), got: "${since}" — CLI accepts <N>d/YYYY-MM-DD, MCP takes ISO only`,
+    );
+  }
   const limit = typeof args.limit === "number" ? args.limit : undefined;
+  const open = typeof args.open === "boolean" ? args.open : undefined;
 
-  return jsonResult(memFind({ worktree, files, text, kind, since, limit }));
+  return jsonResult(
+    memFind({ worktree, files, text, kind, since, limit, open }),
+  );
 }
 
 // --- mem_add ---
+//
+// Domain rules live in the shared engine (src/mem/engine.ts) — this wrapper
+// owns only store init for its worktree. CLI cmdAdd calls the same engine.
 
-export interface MemAddResult {
-  id: string;
-  kind: string;
-  text: string;
-  files: string[];
-  spec?: string;
-  ts: string;
-}
-
-const CAP_NEXT = 15;
-const CAP_HOLD = 10;
+export type MemAddResult = EngineAddResult;
 
 export function memAdd(args: {
   worktree: string;
@@ -126,62 +113,13 @@ export function memAdd(args: {
   files: string[];
   spec?: string;
 }): MemAddResult {
-  if (!KINDS.includes(args.kind as WorkKind)) {
-    throw new Error(
-      `kind must be one of ${KINDS.join("|")} — got "${args.kind}"`,
-    );
-  }
-  if (args.files.length === 0) {
-    throw new Error("files must contain at least one path");
-  }
-  if (!args.text.trim()) {
-    throw new Error("text is required and must not be empty");
-  }
-  // CLI cmdAdd rejects hold without a spec (write.ts) — keep the two writers
-  // in lockstep: without a spec a hold can never be resolved by rotate.
-  if (args.kind === "hold" && !args.spec) {
-    throw new Error("hold requires a spec — pass spec: <path/to/SPEC.md>");
-  }
-
   initStore(args.worktree);
-  const all = rows();
-
-  // Cap check — matches CLI cmdAdd behaviour
-  if (args.kind === "next" && !process.env.MEM_FORCE) {
-    const openNext = openRows(all).filter((r) => r.kind === "next").length;
-    if (openNext >= CAP_NEXT) {
-      throw new Error(
-        `open next ${openNext}/${CAP_NEXT} is full — close an old one first`,
-      );
-    }
-  }
-  if (args.kind === "hold" && !process.env.MEM_FORCE) {
-    const openHold = openRows(all).filter((r) => r.kind === "hold").length;
-    if (openHold >= CAP_HOLD) {
-      throw new Error(
-        `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: args.kind as WorkKind,
-    text: args.text,
-    spec: args.spec,
-    files: args.files,
-  });
-
-  return {
-    id,
+  return engineAdd({
     kind: args.kind,
     text: args.text,
     files: args.files,
     spec: args.spec,
-    ts,
-  };
+  });
 }
 
 export function toolMemAdd(args: Record<string, unknown>): ToolResult {
@@ -246,34 +184,15 @@ export function toolMemAdd(args: Record<string, unknown>): ToolResult {
 // (commands/write.ts cmdClose): the id must exist; the tombstone voids the
 // claim by itself.
 
-export interface MemCloseResult {
-  ref: string;
-  text: string;
-  ts: string;
-}
+export type MemCloseResult = EngineCloseResult;
 
 export function memClose(args: {
   worktree: string;
   id: string;
   text: string;
 }): MemCloseResult {
-  if (!args.id.trim()) {
-    throw new Error("id is required");
-  }
-  if (!args.text.trim()) {
-    throw new Error("text is required and must not be empty");
-  }
-
   initStore(args.worktree);
-  const all = rows();
-  if (!all.some((r) => "id" in r && r.id === args.id)) {
-    throw new Error(`no id "${args.id}" in the log`);
-  }
-
-  const ts = new Date().toISOString();
-  put({ kind: "close", ref: args.id, text: args.text });
-
-  return { ref: args.id, text: args.text, ts };
+  return engineClose({ id: args.id, text: args.text });
 }
 
 export function toolMemClose(args: Record<string, unknown>): ToolResult {

package/src/core/debt-format.ts

@@ -77,7 +77,7 @@ export function formatDebt(report: DebtReport, showAll = false): string {
     for (let i = 0; i < cap; i++) {
       const [zone, zoneFiles] = zoneEntries[i];
       const pad = " ".repeat(Math.max(0, 42 - zone.length));
-      lines.push(`\n  ${zone}${pad}${zoneFiles.length} ไฟล์`);
+      lines.push(`\n  ${zone}${pad}${zoneFiles.length} files`);
       lines.push(`    ${zoneFiles.map((f) => f.split("/").pop()).join(" · ")}`);
       totalCapped += zoneFiles.length;
     }
@@ -85,7 +85,7 @@ export function formatDebt(report: DebtReport, showAll = false): string {
       const remaining = e.files.length - totalCapped;
       const remainingZones = zoneEntries.length - cap;
       lines.push(
-        `\n  … อีก ${remainingZones} โซน (${remaining} ไฟล์) — fapony debt --id ${e.conv.id} --all`,
+        `\n  … ${remainingZones} more zones (${remaining} files) — fapony debt --id ${e.conv.id} --all`,
       );
     }
   }

package/src/core/since.ts

@@ -0,0 +1,26 @@
+// src/core/since.ts — parse `--since` (Nd | YYYY-MM-DD) into an ISO timestamp.
+//
+// Pure date math, no imports. Two callers share it: digest/collect.ts and
+// mem find (CLI --since + MCP sinceIso passthrough). It lives in core because
+// both are features and core never imports back up (PLAN-unify-mem-engine
+// chunk 2 — digest/collect.ts used to own this, but importing it from mem
+// would drag db/store + hook.js into the mem load path).
+
+export function parseSince(
+  raw: string | undefined,
+  now?: number,
+): { iso: string; label: string } {
+  const def = "7d";
+  const s = raw ?? def;
+  const dMatch = /^(\d+)d$/.exec(s);
+  if (dMatch) {
+    const days = Number(dMatch[1]);
+    const dt = new Date((now ?? Date.now()) - days * 86400000);
+    return { iso: dt.toISOString(), label: `${days}d` };
+  }
+  const dateMatch = /^\d{4}-\d{2}-\d{2}$/.exec(s);
+  if (dateMatch) {
+    return { iso: `${s}T00:00:00.000Z`, label: s };
+  }
+  throw new Error(`invalid --since format: "${s}" — use <N>d or YYYY-MM-DD`);
+}

package/src/debt/cli.ts

@@ -6,7 +6,7 @@ import { existsSync, realpathSync, statSync } from "node:fs";
 import { dirname, isAbsolute, join, resolve } from "node:path";
 import { CONVENTIONS_FILE } from "../core/config.js";
 import { formatDebt } from "./format.js";
-import { loadConventions } from "./load.js";
+import { resolveDebtScope } from "./load.js";
 import { findPromotions, formatPromotions } from "./promotion.js";
 import { debtForFile, debtScan } from "./scan.js";
 import { ZONE_CAP } from "./types.js";
@@ -119,12 +119,26 @@ export function cmdDebt(args: string[]): void {
     }
   }
 
-  const worktree = worktreeOf(path);
-  const loaded = loadConventions(worktree);
+  // Scan scope: the git root (convention `where` values are repo-relative)
+  // paired with the nearest conventions file — scanning from the app dir
+  // dropped repo-relative conventions and hid files outside the app
+  // (bug mucvfiv5). Evidence (mem/ledger) keeps the old neighborhood scope.
+  // Physical path (symlinks resolved) so --files resolution below compares
+  // like with like against scope.scanRoot (/var → /private/var on macOS).
+  let base = resolve(path ?? ".");
+  try {
+    base = realpathSync(base);
+  } catch {
+    // nonexistent — the not-found notes below handle it
+  }
+  const scope = resolveDebtScope(base);
+  const worktree = scope.scanRoot;
+  const loaded = scope.loaded;
+  const evidenceDir = worktreeOf(path);
 
   if (filesMode) {
     const out = filesMode.map((f) => {
-      const abs = isAbsolute(f) ? f : resolve(worktree, f);
+      const abs = isAbsolute(f) ? f : resolve(base, f);
       if (!existsSync(abs) || !statSync(abs).isFile()) {
         return { file: f, debt: [], note: "not found" as const };
       }
@@ -178,7 +192,7 @@ export function cmdDebt(args: string[]): void {
   if (json) {
     console.log(
       JSON.stringify(
-        { ...report, promotions: findPromotions(worktree, report) },
+        { ...report, promotions: findPromotions(evidenceDir, report) },
         null,
         2,
       ),
@@ -187,7 +201,7 @@ export function cmdDebt(args: string[]): void {
   }
   console.log(formatDebt(report, showAll));
   for (const w of loaded.warnings) console.log(`⚠ ${w}`);
-  for (const l of formatPromotions(findPromotions(worktree, report))) {
+  for (const l of formatPromotions(findPromotions(evidenceDir, report))) {
     console.log(l);
   }
 }

package/src/debt/load.ts

@@ -4,8 +4,14 @@
 // (<repo>/.fapony/conventions.json — via the same resolver as the mem log).
 // Missing file = empty + no error.
 
-import { existsSync, readFileSync } from "node:fs";
-import { join } from "node:path";
+import {
+  existsSync,
+  readdirSync,
+  readFileSync,
+  realpathSync,
+  statSync,
+} from "node:fs";
+import { dirname, join, resolve } from "node:path";
 import {
   CONVENTIONS_FILE,
   CONVENTIONS_FILENAME,
@@ -28,6 +34,134 @@ export function resolveConventionsPath(worktree: string): string | null {
   return existsSync(root) ? root : null;
 }
 
+export interface DebtScope {
+  /**
+   * The dir `where` clauses and debt rel-paths are measured against — the git
+   * root inside a repo (convention `where` values are repo-relative), the
+   * resolved start dir outside one.
+   */
+  scanRoot: string;
+  /** Conventions in scope: nearest file walking up, else the lone file under the root. */
+  loaded: LoadedConventions;
+}
+
+// Dirs that never hold a conventions.json and are expensive to walk — same
+// prune set as the mem-log ambiguity scan (src/core/mem-log.ts).
+const SCOPE_SKIP = new Set([
+  "node_modules",
+  ".git",
+  "dist",
+  "build",
+  "coverage",
+  "vendor",
+  "out",
+  "target",
+  ".next",
+  ".turbo",
+  ".cache",
+]);
+
+/** Every `.fapony/conventions.json` under root — bounded walk, pruned dirs skipped. */
+function findConventionsUnder(root: string): string[] {
+  const found: string[] = [];
+  const walk = (dir: string, depth: number): void => {
+    if (depth > 6) return;
+    let entries: import("node:fs").Dirent[];
+    try {
+      entries = readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const e of entries) {
+      if (!e.isDirectory()) continue;
+      if (e.name === FAPONY_DIR) {
+        const f = join(dir, FAPONY_DIR, CONVENTIONS_FILENAME);
+        if (existsSync(f)) found.push(f);
+        continue;
+      }
+      if (e.name.startsWith(".") || SCOPE_SKIP.has(e.name)) continue;
+      walk(join(dir, e.name), depth + 1);
+    }
+  };
+  walk(root, 0);
+  return found;
+}
+
+/**
+ * The single debt-scope resolver — hint (`readContextData`), the precision
+ * instrument (`computeHintImpact`), and `fapony debt` all pair the same
+ * scan root with the same conventions (bugs mucvfaxk + mucvfiv5).
+ *
+ * Each caller previously resolved differently: the hint and the instrument
+ * anchored `loadConventions` at the git root (silent whenever conventions are
+ * app-scoped), while the CLI scanned from the app dir (so repo-relative
+ * `where` values never matched and files outside the app were invisible).
+ * The scan root here is always the git root — `where` is repo-relative —
+ * and the conventions are the nearest file walking up from `fromDir`
+ * (the app case); when the walk misses — a file outside any app dir, or the
+ * repo root itself — the lone `conventions.json` under the root wins.
+ * Two or more files under the root stay ambiguous (null, don't guess).
+ */
+export function resolveDebtScope(fromDir: string): DebtScope {
+  let start = resolve(fromDir);
+  try {
+    if (!statSync(start).isDirectory()) start = dirname(start);
+  } catch {
+    // nonexistent path — keep the lexical form, resolution below still applies
+  }
+  try {
+    // Physical path so the walk, the boundary check, and scanRoot compare
+    // like with like (/var → /private/var on macOS).
+    start = realpathSync(start);
+  } catch {
+    // vanished mid-call — keep the lexical form
+  }
+  // `git rev-parse` returns a physical path (/var → /private/var on macOS),
+  // so the boundary check compares realpaths, same as worktreeOf in cli.ts.
+  const physical = (d: string): string => {
+    try {
+      return realpathSync(d);
+    } catch {
+      return d;
+    }
+  };
+  let gitRoot: string | null = null;
+  try {
+    const p = Bun.spawnSync(["git", "rev-parse", "--show-toplevel"], {
+      cwd: start,
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+    if (p.exitCode === 0) gitRoot = p.stdout.toString().trim() || null;
+  } catch {
+    // not a repo — start is all we have
+  }
+  const scanRoot = gitRoot ? physical(gitRoot) : start;
+  const boundary = gitRoot ? physical(gitRoot) : null;
+
+  // Nearest conventions.json walking up (the app case) — bounded by the root.
+  let dir = start;
+  while (true) {
+    if (existsSync(join(dir, CONVENTIONS_FILE))) {
+      return { scanRoot, loaded: loadConventions(dir) };
+    }
+    if (boundary && physical(dir) === boundary) break;
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+
+  // Sibling-app case: the file sits outside any app dir (e.g. packages/*),
+  // but the repo holds exactly one conventions file — use it.
+  if (gitRoot) {
+    const found = findConventionsUnder(scanRoot);
+    if (found.length === 1) {
+      return { scanRoot, loaded: loadConventions(dirname(dirname(found[0]))) };
+    }
+  }
+  return { scanRoot, loaded: loadConventions(scanRoot) };
+}
+
 function asString(v: unknown): string | undefined {
   return typeof v === "string" && v.length > 0 ? v : undefined;
 }

package/src/digest/collect.ts

@@ -14,6 +14,7 @@ import {
   type Run,
 } from "../core/config.js";
 import { type HintImpact, hintLogPath } from "../core/hint-log.js";
+import { parseSince } from "../core/since.js";
 import { openDb } from "../db/store.js";
 import { computeHintImpact } from "../hook.js";
 import { type MemRow, readMemLog } from "../memory.js";
@@ -100,25 +101,6 @@ export interface CollectOpts {
 
 // --- helpers ---
 
-function parseSince(
-  raw: string | undefined,
-  now?: number,
-): { iso: string; label: string } {
-  const def = "7d";
-  const s = raw ?? def;
-  const dMatch = /^(\d+)d$/.exec(s);
-  if (dMatch) {
-    const days = Number(dMatch[1]);
-    const dt = new Date((now ?? Date.now()) - days * 86400000);
-    return { iso: dt.toISOString(), label: `${days}d` };
-  }
-  const dateMatch = /^\d{4}-\d{2}-\d{2}$/.exec(s);
-  if (dateMatch) {
-    return { iso: `${s}T00:00:00.000Z`, label: s };
-  }
-  throw new Error(`invalid --since format: "${s}" — use <N>d or YYYY-MM-DD`);
-}
-
 function resolveWorktree(override?: string): string {
   if (override) return override;
   try {

package/src/hook.ts

@@ -6,6 +6,7 @@
 // from this path.
 
 export {
+  BUG_MARKERS,
   bugSignalFromTranscript,
   COMMIT_HINT_MIN_COMMITS,
   type CommitHintInput,
@@ -36,9 +37,11 @@ export {
   gitAutonomyStatus,
   type HintFireRow,
   type HintImpact,
+  hasBugMarker,
   hintLogDir,
   hintLogPath,
   hookTsMs,
+  isBugfixCommit,
   isCodexPayload,
   isCursorPayload,
   mvGuardDecision,