fapony 0.3.3 → 0.3.5

package/src/memory.ts

@@ -1,15 +1,27 @@
-// src/memory.ts — memory domain: config.memory.* shell adapter helpers +
-// the shared mem-log reader (digest and project_health_context both need it).
-// ponytail: dedupe close-command logic that was copy-pasted in run.ts + stop.ts
+// src/memory.ts — memory domain: config.memory.* shell adapter helpers.
+// The shared mem-log reader now lives in src/core/mem-log.ts (PLAN-lib-layer chunk 2b).
 
 import { execSync } from "node:child_process";
-import { existsSync, readdirSync, readFileSync, realpathSync } from "node:fs";
-import { dirname, isAbsolute, join, resolve } from "node:path";
-import { CONFIG_FILENAME, DEFAULT_MEM_DIR, FAPONY_DIR } from "./db/defaults.js";
-import { type Config, loadConfig, safetyDeny } from "./db/index.js";
+import type { Config } from "./core/config.js";
 import { assertSafe } from "./safety.js";
 import { templateArgs } from "./util.js";
 
+// Re-export mem-log reader for existing callers (gate, hook, digest, mcp, seed, mem).
+export {
+  type MemDirResult,
+  type MemRow,
+  readMemLog,
+  readRecentMemDecisions,
+  resolveMemDir,
+  whereMemDir,
+} from "./core/mem-log.js";
+
+// Internal import used by resolveMemoryConfig below.
+import {
+  resolveMemDir as _resolveMemDir,
+  walkUpForMemDir,
+} from "./core/mem-log.js";
+
 /** Default memory commands — built into fapony via `fapony mem <sub>`. */
 export const DEFAULT_MEMORY: Config["memory"] = {
   claim: ["fapony", "mem", "claim", "{id}"],
@@ -23,10 +35,6 @@ export const DEFAULT_MEMORY: Config["memory"] = {
  * - explicit config.memory wins if set
  * - fallback: a mem log dir exists (any `.fapony/.memory/`) → DEFAULT_MEMORY
  * - otherwise null (no memory)
- *
- * Since PLAN-agent-one-call the code is built into fapony (`fapony mem`), so the
- * old gate on `.fapony/.memory/mem.ts` no longer means anything — that file is
- * not scaffolded and `init-mem` deletes it. Gate on the dir the writer needs.
  */
 export function resolveMemoryConfig(
   config: Config,
@@ -34,9 +42,8 @@ export function resolveMemoryConfig(
 ): Config["memory"] {
   if (config.memory) return config.memory;
   // A real log is not required for wiring: `fapony init` scaffolds an empty
-  // `.fapony/.memory/` and the writer creates the first log there. Resolution
-  // proper (above) still skips empty dirs, so it cannot pick the wrong one.
-  if (resolveMemDir(worktree) || walkUpForMemDir(worktree, true)) {
+  // `.fapony/.memory/` and the writer creates the first log there.
+  if (_resolveMemDir(worktree) || walkUpForMemDir(worktree, true)) {
     return DEFAULT_MEMORY;
   }
   return null;
@@ -52,7 +59,7 @@ export function closeMemory(
   if (!mem) return;
   try {
     const cmd = templateArgs(mem.close, { id: memId, msg });
-    assertSafe(cmd, safetyDeny(config));
+    assertSafe(cmd, config.safety?.deny ?? []);
     execSync(cmd.join(" "), {
       cwd: worktree,
       stdio: "ignore",
@@ -67,16 +74,17 @@ export function claimMemory(
   config: Config,
   worktree: string,
   memId: string,
+  timeoutMs = 15_000,
 ): boolean {
   const mem = resolveMemoryConfig(config, worktree);
   if (!mem) return false;
   try {
     const cmd = templateArgs(mem.claim, { id: memId });
-    assertSafe(cmd, safetyDeny(config));
+    assertSafe(cmd, config.safety?.deny ?? []);
     execSync(cmd.join(" "), {
       cwd: worktree,
       stdio: ["pipe", "pipe", "pipe"],
-      timeout: 15_000,
+      timeout: timeoutMs,
     });
     return true;
   } catch {
@@ -89,7 +97,7 @@ export function kickoffMemory(config: Config, worktree: string): string | null {
   const mem = resolveMemoryConfig(config, worktree);
   if (!mem?.kickoff) return null;
   try {
-    assertSafe(mem.kickoff, safetyDeny(config));
+    assertSafe(mem.kickoff, config.safety?.deny ?? []);
     return execSync(mem.kickoff.join(" "), {
       cwd: worktree,
       encoding: "utf-8",
@@ -99,373 +107,3 @@ export function kickoffMemory(config: Config, worktree: string): string | null {
     return null;
   }
 }
-
-// --- mem log reading ---
-//
-// Shared by `fapony digest` and `project_health_context`: both need the same
-// directory discovery (new `.fapony/.memory`, legacy `.memory/` fallback) and
-// the same rotated-file handling. Kept here so the two callers cannot drift.
-
-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[];
-}
-
-interface RawMemRow {
-  ts?: string;
-  agent?: string;
-  kind?: string;
-  text?: string;
-  spec?: string;
-  id?: string;
-  ref?: string;
-  files?: 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 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.
- */
-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";
-  /**
-   * `.fapony/.memory/` dirs under the repo root that hold logs but are not in
-   * scope from `fromDir`. Set for "ambiguous" (two or more, the refusal) and
-   * also for "repo-root"/"none" (one) — a caller that reports "nothing
-   * recorded here" is lying when a single app-scoped log exists one level
-   * down, and the honest line needs the path to say where.
-   */
-  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/`
- *
- * `.memory/` (outside `.fapony/`) and the monorepo app-guess (`wt-<app>`,
- * `MEM_APP`) are both dead — they are not in the order and never return.
- */
-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 (FAPONY_CONFIG is not a
-  // path source here — spec §1 pins this to fapony.config.json)
-  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): nothing at/above cwd holds a log, but the repo
-  // has two or more app-scoped ones — refuse instead of silently creating a
-  // third log at the root that no app-scoped reader will ever see.
-  // One candidate is not ambiguous, so resolution is unchanged — but it still
-  // travels back with the result: out-of-scope is not the same as absent.
-  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/ — where a new log is created
-  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 };
-
-  // Every log*.jsonl, rotated archives (log.YYYY-MM-DD.jsonl) included. They
-  // used to be excluded, which meant the day a repo crossed the rotate
-  // threshold mem_find silently forgot everything already closed — the rows
-  // most worth recalling. Rotate exists to keep the live file small, not to
-  // decide what is still remembered.
-  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") }
-          : {}),
-      });
-    }
-  }
-
-  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`.
- *
- * `keywords` (usual suspects: the files about to be touched) are a
- * *preference*, not a filter: decisions mentioning one surface first, but when
- * nothing matches the newest decisions still come back. A summary that goes
- * silent because a path never appeared in a decision is worse than a recent one.
- */
-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/parse.ts

@@ -1,71 +1,9 @@
-// src/parse.ts — grades, scores, and gate-event JSON parsing.
-// Marker-text parsers (parseGateVerdict/parsePlanUpdate) were removed with the
-// CLI loop: nothing produces VERDICT:/NEXT-PROMPT/FILE_DONE stdout anymore —
-// gate events are JSON, read via parseGateEventData.
-
-/** Locked grade vocabulary — additive-only (append, never rename/remove). */
-export type VerdictGrade =
-  | "pass-excellent"
-  | "pass-good"
-  | "pass-adequate"
-  | "pass"
-  | "fail"
-  | "uncertain";
-
-export const VERDICT_GRADES: ReadonlySet<string> = new Set<VerdictGrade>([
-  "pass-excellent",
-  "pass-good",
-  "pass-adequate",
-  "pass",
-  "fail",
-  "uncertain",
-]);
-
-/** True when verdict belongs to the pass family (any pass-* variant). */
-export function isPassFamily(v: string): v is VerdictGrade {
-  return v.startsWith("pass");
-}
-
-/**
- * Locked qualityScore mapping — read-time only (never written to events).
- * Values from SPEC-verdict-protocol §qualityScore (additive-only, never change).
- */
-const SCORE_MAP: Record<VerdictGrade, number> = {
-  "pass-excellent": 5,
-  "pass-good": 4,
-  "pass-adequate": 3,
-  pass: 3,
-  fail: 0,
-  uncertain: 1,
-};
-
-export function qualityScore(grade: VerdictGrade): number {
-  return SCORE_MAP[grade] ?? 0;
-}
-
-export interface GateVerdict {
-  verdict: VerdictGrade;
-  note: string;
-}
-
-/**
- * Read a verdict back from a stored gate event (`kind='gate'`).
- * Gate events are JSON (`{verdict, note, round}` from gateOnce) — NOT
- * reviewer stdout. Returns null for missing/unparseable data or unknown grades.
- */
-export function parseGateEventData(data: string | null): GateVerdict | null {
-  if (!data) return null;
-  let parsed: unknown;
-  try {
-    parsed = JSON.parse(data);
-  } catch {
-    return null;
-  }
-  if (!parsed || typeof parsed !== "object") return null;
-  const { verdict, note } = parsed as { verdict?: unknown; note?: unknown };
-  if (typeof verdict !== "string" || !VERDICT_GRADES.has(verdict)) return null;
-  return {
-    verdict: verdict as VerdictGrade,
-    note: typeof note === "string" ? note : "",
-  };
-}
+// shim — moved to src/core/parse.ts
+export {
+  type GateVerdict,
+  isPassFamily,
+  parseGateEventData,
+  qualityScore,
+  VERDICT_GRADES,
+  type VerdictGrade,
+} from "./core/parse.js";

package/src/price/fetch.ts

@@ -13,26 +13,14 @@ import {
   writeFileSync,
 } from "node:fs";
 import { dirname, join } from "node:path";
-import { faponyDir } from "../db/load.js";
-import type { Config } from "../db/types.js";
+import { type Config, faponyDir } from "../core/config.js";
+import type { ModelRates, PriceTable } from "../core/types.js";
+
+export type { ModelRates, PriceTable } from "../core/types.js";
 
 const PRICES_FILENAME = "prices.json";
 const MODELS_URL = "https://openrouter.ai/api/v1/models";
 
-/** per-token rates (dollars) — every rate comes straight from OpenRouter, no guessing */
-export interface ModelRates {
-  input: number;
-  output: number;
-  cacheRead: number;
-  /** null = the table does not provide it → use the input rate instead (see calcCost) */
-  cacheWrite: number | null;
-}
-
-export interface PriceTable {
-  fetched_at: string;
-  models: Record<string, ModelRates>;
-}
-
 export function pricesPath(config?: Config): string {
   return join(faponyDir(config), PRICES_FILENAME);
 }