fapony 0.6.2 → 0.7.1

package/src/analyze/cache.ts

@@ -1,162 +0,0 @@
-// src/analyze/cache.ts — session-scoped graph cache.
-//
-// buildGraph is cheap on this repo (~50ms/150 files) but the Edit hint calls it
-// on every Edit — and a Claude Code PreToolUse hook is a *fresh process per
-// tool call*, so an in-process cache alone never survives to the next edit. The
-// graph is therefore mirrored to <faponyDir>/graph-cache/<key>.json:
-//   - auto-build: every build is written through, best-effort (never blocks)
-//   - auto-invalidate: a fingerprint over the source-file set (rel path + size
-//     + mtimeMs) is stored beside the graph; a mismatch means rebuild
-//   - cost: the cache file is only stat-ed when there is one to validate, so a
-//     first-ever call pays build + write; later calls pay a walk + stat + parse,
-//     well under a rebuild on any repo large enough for this to matter
-// Everything here is derived state — an unreadable, corrupt, stale or
-// unwritable cache falls back to a live build and no code path trusts it.
-
-import {
-  existsSync,
-  mkdirSync,
-  readFileSync,
-  renameSync,
-  statSync,
-  writeFileSync,
-} from "node:fs";
-import { join, resolve } from "node:path";
-
-import { faponyDir } from "../core/config.js";
-import { collectSourceFiles } from "./discover.js";
-import { buildGraph } from "./graph.js";
-import type { ImportGraph } from "./types.js";
-
-const GRAPH_CACHE_VERSION = 1;
-const GRAPH_CACHE_DIR = "graph-cache";
-
-interface SerializedGraph {
-  v: number;
-  fp: string;
-  files: string[];
-  deps: Record<string, string[]>;
-  dependents: Record<string, string[]>;
-  unresolved: number;
-  external: number;
-  barrels: string[];
-}
-
-let _graphCache: { dir: string; fp: string; graph: ImportGraph } | null = null;
-
-/** Drop the in-process graph cache (tests simulate a fresh hook process). */
-export function resetGraphCache(): void {
-  _graphCache = null;
-}
-
-/** Absolute path of a worktree's graph-cache file — may not exist. */
-export function graphCachePath(dir: string): string {
-  const abs = resolve(dir);
-  const slug = abs.replace(/[^A-Za-z0-9]+/g, "-").slice(0, 60);
-  return join(
-    faponyDir(),
-    GRAPH_CACHE_DIR,
-    `${slug}-${Bun.hash(abs).toString(36)}.json`,
-  );
-}
-
-// The graph changes only when the set of source files or their bytes change —
-// size/mtime/ctime catch that without reading any file. ctime rides the same
-// stat call for free and cannot be forged like mtime can (only the system
-// moves it), so an mtime-preserving rewrite still invalidates.
-function graphFingerprint(absDir: string): string {
-  const parts: string[] = [];
-  for (const rel of collectSourceFiles(absDir)) {
-    try {
-      const st = statSync(join(absDir, rel));
-      parts.push(
-        `${rel}\u0000${st.size}\u0000${st.mtimeMs}\u0000${st.ctimeMs}`,
-      );
-    } catch {
-      parts.push(`${rel}\u0000?\u0000?\u0000?`);
-    }
-  }
-  return Bun.hash(parts.join("\n")).toString(36);
-}
-
-function serializeGraph(graph: ImportGraph, fp: string): SerializedGraph {
-  const rec = (m: Map<string, Set<string>>): Record<string, string[]> => {
-    const out: Record<string, string[]> = {};
-    for (const [k, v] of m) out[k] = [...v];
-    return out;
-  };
-  return {
-    v: GRAPH_CACHE_VERSION,
-    fp,
-    files: graph.files,
-    deps: rec(graph.deps),
-    dependents: rec(graph.dependents),
-    unresolved: graph.unresolved,
-    external: graph.external,
-    barrels: [...graph.barrels],
-  };
-}
-
-function hydrateGraph(c: SerializedGraph): ImportGraph {
-  const toMap = (r: Record<string, string[]>): Map<string, Set<string>> => {
-    const m = new Map<string, Set<string>>();
-    for (const [k, v] of Object.entries(r)) m.set(k, new Set(v));
-    return m;
-  };
-  return {
-    files: c.files,
-    deps: toMap(c.deps),
-    dependents: toMap(c.dependents),
-    unresolved: c.unresolved,
-    external: c.external,
-    barrels: new Set(c.barrels),
-  };
-}
-
-function readCachedGraph(path: string, fp: string): ImportGraph | null {
-  try {
-    const cached = JSON.parse(readFileSync(path, "utf-8")) as SerializedGraph;
-    if (cached.v !== GRAPH_CACHE_VERSION || cached.fp !== fp) return null;
-    return hydrateGraph(cached);
-  } catch {
-    return null;
-  }
-}
-
-function writeCachedGraph(path: string, graph: ImportGraph, fp: string): void {
-  try {
-    if (!existsSync(join(faponyDir(), GRAPH_CACHE_DIR))) {
-      mkdirSync(join(faponyDir(), GRAPH_CACHE_DIR), { recursive: true });
-    }
-    // pid-suffixed temp + rename: a reader never sees a half-written file even
-    // when two hook processes race.
-    const tmp = `${path}.${process.pid}.tmp`;
-    writeFileSync(tmp, JSON.stringify(serializeGraph(graph, fp)), "utf-8");
-    renameSync(tmp, path);
-  } catch {
-    // best-effort — a cache that cannot be written must not break the caller
-  }
-}
-
-export function buildGraphCached(dir: string): ImportGraph {
-  const abs = resolve(dir);
-  // One walk per call: the fingerprint doubles as the in-process validity
-  // check, so a same-process second call after an edit rebuilds instead of
-  // serving the stale graph. A drift between this fp and the built graph
-  // self-heals — the next call recomputes and rebuilds again.
-  const fp = graphFingerprint(abs);
-  if (_graphCache?.dir === abs && _graphCache.fp === fp)
-    return _graphCache.graph;
-  const path = graphCachePath(abs);
-  if (existsSync(path)) {
-    const cached = readCachedGraph(path, fp);
-    if (cached) {
-      _graphCache = { dir: abs, fp, graph: cached };
-      return cached;
-    }
-  }
-  const graph = buildGraph(abs);
-  _graphCache = { dir: abs, fp, graph };
-  writeCachedGraph(path, graph, fp);
-  return graph;
-}

package/src/core/mem-log.ts

@@ -1,375 +0,0 @@
-// src/core/mem-log.ts — mem-log reader: directory discovery + JSONL parsing (pure, no feature imports)
-//
-// Extracted from src/memory.ts (PLAN-lib-layer chunk 2b). Shell adapter
-// helpers (closeMemory, kickoffMemory, claimMemory) stay in memory.ts.
-
-import { existsSync, readdirSync, readFileSync, realpathSync } from "node:fs";
-import { dirname, isAbsolute, join, resolve } from "node:path";
-import {
-  CONFIG_FILENAME,
-  DEFAULT_MEM_DIR,
-  FAPONY_DIR,
-  loadConfig,
-} from "./config.js";
-
-export interface MemRow {
-  ts: string;
-  agent: string;
-  kind: string;
-  text: string;
-  spec?: string;
-  id?: string;
-  ref?: string;
-  /** Files the row is about — written by `mem add --files` (PLAN-convention-debt chunk 3). */
-  files?: string[];
-  /** Problem identity, distinct from kind (action) and files[] (place) — written by `mem add --key` (PLAN-mem-keys chunk 1). */
-  key?: string;
-  /** Row schema version: 2 = may carry `key`; absent = v:1 legacy row, read as-is. */
-  v?: number;
-}
-
-/** One mem-row text budget for any hint/seed surface that shows a row (was context-data's private const). */
-export const MEM_TEXT_MAX = 120;
-
-/**
- * The only accepted shape of a mem row `key` — problem identity, not action
- * (kind) and not place (files[]). Lives here in core so CLI and MCP validate
- * through one regex (PLAN-unify-mem-engine: one engine, both surfaces).
- */
-export const KEY_RE = /^[a-z0-9-]{3,40}$/;
-
-interface RawMemRow {
-  ts?: string;
-  agent?: string;
-  kind?: string;
-  text?: string;
-  spec?: string;
-  id?: string;
-  ref?: string;
-  files?: unknown;
-  key?: unknown;
-  v?: unknown;
-}
-
-/**
- * A directory is a mem dir only when it holds a `log.jsonl` or a named
- * `log.<person>.jsonl` (rotated `log.YYYY-MM-DD.jsonl` archives count too).
- * A `.fapony/.memory/` scaffolded empty by `fapony init` is not a candidate —
- * otherwise it would shadow an ancestor that holds the real log (SPEC §1).
- */
-function hasMemLogs(dir: string): boolean {
-  try {
-    return readdirSync(dir).some(
-      (f) => f === "log.jsonl" || /^log\.[A-Za-z0-9._-]+\.jsonl$/.test(f),
-    );
-  } catch {
-    return false;
-  }
-}
-
-/** Physical path (symlinks resolved) so start and repo root compare like with
- *  like; falls back to a lexical resolve when the path does not exist yet. */
-function physical(p: string): string {
-  try {
-    return realpathSync(p);
-  } catch {
-    return resolve(p);
-  }
-}
-
-/** `git rev-parse --show-toplevel` from a directory, or null outside a repo. */
-function gitRootOf(fromDir: string): string | null {
-  try {
-    const { execSync } =
-      require("node:child_process") as typeof import("node:child_process");
-    const root = execSync("git rev-parse --show-toplevel", {
-      cwd: fromDir,
-      encoding: "utf-8",
-      stdio: ["pipe", "pipe", "pipe"],
-    }).trim();
-    return root || null;
-  } catch {
-    return null;
-  }
-}
-
-/**
- * The lexical ancestor of `fromDir` that is the git repo root, or null outside
- * a repo. `git rev-parse` returns a physical path (it resolves /var → /private/
- * var on macOS), so the walk compares `physical(dir)` against it and returns the
- * path in the caller's own lexical form — the returned dir must match what the
- * caller passed in, not a canonicalized stranger.
- */
-function repoRootOf(fromDir: string): string | null {
-  const start = resolve(fromDir);
-  const gitRoot = gitRootOf(start);
-  if (!gitRoot) return null;
-  const physicalRoot = physical(gitRoot);
-  let dir = start;
-  while (true) {
-    if (physical(dir) === physicalRoot) return dir;
-    const parent = dirname(dir);
-    if (parent === dir) return null;
-    dir = parent;
-  }
-}
-
-/**
- * Locate the nearest `.fapony/.memory/` by walking up from `fromDir`.
- *
- * The walk stops at the git repo root (SPEC §1) — a mem dir in a parent
- * checkout is never ours. Outside a repo it stops at the filesystem root.
- * `acceptEmpty` is for the default-wiring check, which only needs the dir the
- * writer will use (log or not); the resolver itself requires a real log.
- */
-export function walkUpForMemDir(
-  fromDir: string,
-  acceptEmpty: boolean,
-): string | null {
-  const start = resolve(fromDir);
-  const boundary = repoRootOf(start) ?? "/";
-  let dir = start;
-  while (true) {
-    const candidate = join(dir, DEFAULT_MEM_DIR);
-    if (existsSync(candidate) && (acceptEmpty || hasMemLogs(candidate))) {
-      return candidate;
-    }
-    if (dir === boundary) break;
-    const parent = dirname(dir);
-    if (parent === dir) break;
-    dir = parent;
-  }
-  return null;
-}
-
-export interface MemDirResult {
-  dir: string | null;
-  step: "flag" | "config" | "walk-up" | "repo-root" | "ambiguous" | "none";
-  candidates?: string[];
-}
-
-// Dirs that never hold a project mem log and are expensive to walk.
-const SCAN_SKIP = new Set([
-  "node_modules",
-  ".git",
-  "dist",
-  "build",
-  "coverage",
-  "vendor",
-  "out",
-  "target",
-  ".next",
-  ".turbo",
-  ".cache",
-]);
-
-/**
- * Every `.fapony/.memory/` under `root` that holds a real log, bounded to a
- * shallow walk. Used only to detect the ambiguous monorepo layout (SPEC §1
- * fail example): if two or more app-scoped logs exist and nothing at/above cwd
- * holds one, the caller must refuse rather than start a third log at the root.
- */
-function findMemDirsUnder(root: string): string[] {
-  const found: string[] = [];
-  const walk = (dir: string, depth: number): void => {
-    if (depth > 5) 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 candidate = join(dir, DEFAULT_MEM_DIR);
-        if (hasMemLogs(candidate)) found.push(candidate);
-        continue;
-      }
-      if (e.name.startsWith(".") || SCAN_SKIP.has(e.name)) continue;
-      walk(join(dir, e.name), depth + 1);
-    }
-  };
-  walk(root, 0);
-  return found;
-}
-
-/**
- * The single resolver: returns the mem dir and which step won.
- *
- * Resolution order (SPEC §1):
- *   1. `--mem-dir <path>` (wins over everything)
- *   2. `paths.memDir` in the **repo-root** `fapony.config.json` (relative to root)
- *   3. walk up from cwd for the first `.fapony/.memory/` that holds a real log
- *   4. `<repo root>/.fapony/.memory/`
- */
-function resolveMemDirFrom(
-  fromDir: string,
-  explicitOverride?: string,
-): MemDirResult {
-  // Step 1: --mem-dir flag
-  if (explicitOverride) {
-    return {
-      dir: existsSync(explicitOverride) ? resolve(explicitOverride) : null,
-      step: "flag",
-    };
-  }
-
-  const cwd = resolve(fromDir);
-  const root = repoRootOf(cwd);
-
-  // Step 2: paths.memDir in the repo-root config
-  const configDir = root ?? cwd;
-  try {
-    const configPath = join(configDir, CONFIG_FILENAME);
-    if (existsSync(configPath)) {
-      const config = loadConfig(configPath);
-      if (config?.paths?.memDir) {
-        const absCfg = isAbsolute(config.paths.memDir)
-          ? config.paths.memDir
-          : join(configDir, config.paths.memDir);
-        if (existsSync(absCfg)) return { dir: absCfg, step: "config" };
-      }
-    }
-  } catch {
-    // no config or unreadable — continue
-  }
-
-  // Step 3: walk up from cwd, only a dir with a real log counts
-  const walked = walkUpForMemDir(cwd, false);
-  if (walked) return { dir: walked, step: "walk-up" };
-
-  // Guard (SPEC §1 fail example)
-  const candidates = root ? findMemDirsUnder(root) : [];
-  if (candidates.length >= 2) {
-    return { dir: null, step: "ambiguous", candidates };
-  }
-  const outOfScope = candidates.length ? { candidates } : {};
-
-  // Step 4: <repo root>/.fapony/.memory/
-  if (root) {
-    const rootDir = join(root, DEFAULT_MEM_DIR);
-    if (existsSync(rootDir)) {
-      return { dir: rootDir, step: "repo-root", ...outOfScope };
-    }
-  }
-
-  return { dir: null, step: "none", ...outOfScope };
-}
-
-export function resolveMemDir(
-  worktree?: string,
-  explicitOverride?: string,
-): string | null {
-  return resolveMemDirFrom(worktree ?? process.cwd(), explicitOverride).dir;
-}
-
-/** Resolve and report which step won — for `fapony mem where`. */
-export function whereMemDir(
-  fromDir?: string,
-  explicitOverride?: string,
-): MemDirResult {
-  return resolveMemDirFrom(fromDir ?? process.cwd(), explicitOverride);
-}
-
-/**
- * Read every `log*.jsonl` row under the worktree's memory dir, newest first.
- * `sinceIso` (exclusive) drops older rows; omit it to read the whole log.
- * Malformed/unreadable rows are counted, never thrown — a corrupt line must
- * not take down the caller.
- */
-export function readMemLog(
-  worktree: string,
-  sinceIso?: string,
-): { rows: MemRow[]; skipped: number; filesFound: number } {
-  const dir = resolveMemDir(worktree);
-  if (!dir) return { rows: [], skipped: 0, filesFound: 0 };
-
-  const isLogFile = (f: string): boolean =>
-    f === "log.jsonl" || /^log\.[A-Za-z0-9._-]+\.jsonl$/.test(f);
-
-  let files: string[];
-  try {
-    files = readdirSync(dir)
-      .filter(isLogFile)
-      .sort()
-      .map((f) => join(dir, f));
-  } catch {
-    return { rows: [], skipped: 0, filesFound: 0 };
-  }
-
-  if (files.length === 0) return { rows: [], skipped: 0, filesFound: 0 };
-
-  let skipped = 0;
-  const all: MemRow[] = [];
-
-  for (const file of files) {
-    let raw: string;
-    try {
-      raw = readFileSync(file, "utf-8");
-    } catch {
-      continue;
-    }
-    const lines = raw.split("\n").filter(Boolean);
-    for (const line of lines) {
-      let parsed: RawMemRow;
-      try {
-        parsed = JSON.parse(line) as RawMemRow;
-      } catch {
-        skipped++;
-        continue;
-      }
-      if (!parsed.ts || !parsed.kind) {
-        skipped++;
-        continue;
-      }
-      if (sinceIso && parsed.ts < sinceIso) continue;
-      all.push({
-        ts: parsed.ts,
-        agent: parsed.agent ?? "unknown",
-        kind: parsed.kind,
-        text: parsed.text ?? "",
-        spec: parsed.spec,
-        id: parsed.id,
-        ref: parsed.ref,
-        ...(Array.isArray(parsed.files)
-          ? { files: parsed.files.filter((f) => typeof f === "string") }
-          : {}),
-        ...(typeof parsed.key === "string" ? { key: parsed.key } : {}),
-        ...(typeof parsed.v === "number" ? { v: parsed.v } : {}),
-      });
-    }
-  }
-
-  all.sort((a, b) => b.ts.localeCompare(a.ts)); // newest first
-  return { rows: all, skipped, filesFound: files.length };
-}
-
-/**
- * Decisions for the pre-edit context summary — newest first, capped at `limit`.
- */
-export function readRecentMemDecisions(
-  worktree: string,
-  limit: number,
-  keywords?: string[],
-): MemRow[] {
-  let decisions: MemRow[];
-  try {
-    decisions = readMemLog(worktree).rows.filter((r) => r.kind === "decision");
-  } catch {
-    return [];
-  }
-  if (decisions.length === 0) return [];
-
-  const kws = (keywords ?? [])
-    .map((k) => k.toLowerCase())
-    .filter((k) => k.length > 0);
-  if (kws.length > 0) {
-    const hits = decisions.filter((r) => {
-      const hay = `${r.text}\n${r.spec ?? ""}`.toLowerCase();
-      return kws.some((k) => hay.includes(k));
-    });
-    if (hits.length > 0) return hits.slice(0, limit);
-  }
-  return decisions.slice(0, limit);
-}

package/src/init-mem.ts

@@ -1,143 +0,0 @@
-// src/init-mem.ts — cleanup old .memory/ directories and warn about stale call sites.
-//
-// Before PLAN-agent-one-call, this file scaffolded templates/mem/ into every repo.
-// Now fapony owns the mem code (src/mem/) and calls it directly via `fapony mem`.
-// This command's new job: delete legacy .memory/ dirs + warn about package.json refs.
-
-import { existsSync, readdirSync, readFileSync, rmSync } from "node:fs";
-import { join } from "node:path";
-import { DEFAULT_MEM_DIR, FAPONY_DIR, loadConfig } from "./core/config.js";
-import { walkDir } from "./util.js";
-
-export function cmdInitMem(args: string[]): void {
-  const force = args.includes("--force");
-  const worktreeKey = args.find((x) => !x.startsWith("-"));
-  const config = loadConfig();
-
-  // no key given = the repo you are standing in
-  const worktree = worktreeKey ? config.worktrees[worktreeKey] : process.cwd();
-  if (!worktree) {
-    console.error(`unknown worktree key: ${worktreeKey}`);
-    console.error(`available: ${Object.keys(config.worktrees).join(", ")}`);
-    process.exit(1);
-  }
-
-  const gitRoot = Bun.spawnSync(["git", "rev-parse", "--show-toplevel"], {
-    cwd: worktree,
-  })
-    .stdout.toString()
-    .trim();
-  const root = gitRoot || worktree;
-
-  // 1) Find and delete .memory/ directories (legacy layout)
-  const memoryDirs = walkDir(root, {
-    includeDotDirs: [FAPONY_DIR],
-    predicate: (dir) => existsSync(join(dir, ".memory")),
-  }).map((dir) => join(dir, ".memory"));
-
-  // Legacy filenames that may live alongside live logs inside .fapony/.memory/
-  const LEGACY_MEM_FILENAMES = [
-    "mem.ts",
-    "store.ts",
-    "selectors.ts",
-    "render.ts",
-  ];
-
-  if (memoryDirs.length === 0) {
-    console.log("no legacy .memory/ directories found — already clean");
-  } else {
-    let removed = 0;
-    let kept = 0;
-    for (const d of memoryDirs) {
-      // Any log*.jsonl is history — includes log.<person>.jsonl (the standard
-      // filename) and rotated log.YYYY-MM-DD.jsonl, not just log.jsonl.
-      let logs: string[] = [];
-      try {
-        logs = readdirSync(d).filter(
-          (f) => f === "log.jsonl" || /^log\..*\.jsonl$/.test(f),
-        );
-      } catch {
-        // unreadable dir — fall through and remove
-      }
-      // Inside .fapony/.memory/: remove known legacy .ts files while keeping
-      // live logs. The keep-if-logs guard would preserve the whole directory,
-      // but legacy scaffolding (mem.ts, store.ts, ...) is dead code that
-      // should not linger beside the active log.
-      const isFaponyMemory =
-        d.endsWith(`/${FAPONY_DIR}/.memory`) || d === `${FAPONY_DIR}/.memory`;
-      if (isFaponyMemory && logs.length > 0) {
-        let legacyRemoved = 0;
-        let commandsRemoved = 0;
-        for (const name of LEGACY_MEM_FILENAMES) {
-          const fp = join(d, name);
-          if (existsSync(fp)) {
-            rmSync(fp);
-            legacyRemoved++;
-          }
-        }
-        const commandsDir = join(d, "commands");
-        if (existsSync(commandsDir)) {
-          rmSync(commandsDir, { recursive: true, force: true });
-          commandsRemoved++;
-        }
-        if (legacyRemoved || commandsRemoved) {
-          console.log(
-            `cleaned ${d} — removed ${legacyRemoved} legacy file(s)${
-              commandsRemoved ? " + commands/" : ""
-            } (kept ${logs.length} log file(s): ${logs.join(", ")})`,
-          );
-        } else {
-          console.log(`${d} — already clean (logs: ${logs.join(", ")})`);
-        }
-        kept++;
-        continue;
-      }
-      if (logs.length > 0 && !force) {
-        console.log(
-          `keeping ${d} — has ${logs.length} log file(s): ${logs.join(", ")}`,
-        );
-        console.log(
-          `  move them under ${DEFAULT_MEM_DIR}/, or re-run with --force to delete`,
-        );
-        kept++;
-        continue;
-      }
-      console.log(
-        `deleting ${d}${logs.length > 0 ? ` (--force: ${logs.length} log file(s))` : ""}`,
-      );
-      rmSync(d, { recursive: true, force: true });
-      removed++;
-    }
-    console.log(
-      `\nremoved ${removed} legacy .memory/ director${removed === 1 ? "y" : "ies"}${
-        kept > 0
-          ? ` · kept ${kept} with logs — move them under ${DEFAULT_MEM_DIR}/, then re-run`
-          : ""
-      }`,
-    );
-  }
-
-  // 2) Warn about package.json call sites still referencing .memory/mem.ts
-  for (const dir of walkDir(root)) {
-    const pkg = join(dir, "package.json");
-    if (!existsSync(pkg)) continue;
-    try {
-      const raw = readFileSync(pkg, "utf8");
-      if (raw.includes(".memory/mem.ts")) {
-        console.log(`\n⚠ ${pkg} still references .memory/mem.ts`);
-        console.log(
-          `  update to: "fapony mem <sub>" (e.g. "fapony mem add", "fapony mem close")`,
-        );
-      }
-    } catch {
-      // ignore
-    }
-  }
-
-  console.log("\nmem commands are now built into fapony:");
-  console.log('  fapony mem add <kind> "<text>" --files <files>');
-  console.log('  fapony mem close <id> "<text>"');
-  console.log("  fapony mem find <word>");
-  console.log("  fapony mem kickoff [id|spec.md]");
-  console.log("  fapony mem done | stale");
-}