fapony 0.3.0 → 0.3.4

package/src/init-mem.ts

@@ -4,32 +4,10 @@
 // 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 {
-  copyFileSync,
-  existsSync,
-  mkdirSync,
-  readdirSync,
-  readFileSync,
-  rmSync,
-} from "node:fs";
+import { existsSync, readdirSync, readFileSync, rmSync } from "node:fs";
 import { join } from "node:path";
-import { DEFAULT_MEM_DIR, FAPONY_DIR, loadConfig } from "./db/index.js";
-
-export function copyDir(src: string, dest: string): string[] {
-  mkdirSync(dest, { recursive: true });
-  const copied: string[] = [];
-  for (const entry of readdirSync(src, { withFileTypes: true })) {
-    const s = join(src, entry.name);
-    const d = join(dest, entry.name);
-    if (entry.isDirectory()) {
-      copied.push(...copyDir(s, d));
-    } else {
-      copyFileSync(s, d);
-      copied.push(d);
-    }
-  }
-  return copied;
-}
+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");
@@ -52,27 +30,18 @@ export function cmdInitMem(args: string[]): void {
   const root = gitRoot || worktree;
 
   // 1) Find and delete .memory/ directories (legacy layout)
-  const memoryDirs: string[] = [];
-  const walk = (dir: string, depth = 0) => {
-    if (depth > 4) return;
-    if (existsSync(`${dir}/.memory`)) {
-      memoryDirs.push(`${dir}/.memory`);
-    }
-    try {
-      for (const entry of readdirSync(dir, { withFileTypes: true })) {
-        if (
-          entry.isDirectory() &&
-          entry.name !== "node_modules" &&
-          (!entry.name.startsWith(".") || entry.name === FAPONY_DIR)
-        ) {
-          walk(join(dir, entry.name), depth + 1);
-        }
-      }
-    } catch {
-      // ignore
-    }
-  };
-  walk(root);
+  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");
@@ -90,6 +59,39 @@ export function cmdInitMem(args: string[]): void {
       } 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(", ")}`,
@@ -116,42 +118,26 @@ export function cmdInitMem(args: string[]): void {
   }
 
   // 2) Warn about package.json call sites still referencing .memory/mem.ts
-  const warnAboutCallSites = (dir: string, depth = 0) => {
-    if (depth > 4) return;
+  for (const dir of walkDir(root)) {
     const pkg = join(dir, "package.json");
-    if (existsSync(pkg)) {
-      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
-      }
-    }
+    if (!existsSync(pkg)) continue;
     try {
-      for (const entry of readdirSync(dir, { withFileTypes: true })) {
-        if (
-          entry.isDirectory() &&
-          !entry.name.startsWith(".") &&
-          entry.name !== "node_modules"
-        ) {
-          warnAboutCallSites(join(dir, entry.name), depth + 1);
-        }
+      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
     }
-  };
-  warnAboutCallSites(root);
+  }
 
   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 now");
+  console.log("  fapony mem done | stale");
 }

package/src/init.ts

@@ -21,7 +21,7 @@ import {
   memoryDir,
   planDir,
   specDir,
-} from "./db/index.js";
+} from "./core/config.js";
 import { isAffirmative } from "./util.js";
 
 const FAPONY_README = `# .fapony/ — fapony project dir (plans, specs, memory)
@@ -95,10 +95,9 @@ work done. Cut at chunk boundaries instead:
 Finish a chunk, before starting the next:
 1. Tick its checkbox + stamp the TL;DR in the plan file
 2. Commit — separate from other chunks
-3. \`verdict_submit\` (fapony MCP), grading what actually happened
-4. \`fapony mem add note "what the next chunk needs" --files f1,f2 <path/to/PLAN-x.md>\`
+3. \`fapony mem add note "what the next chunk needs" --files f1,f2 <path/to/PLAN-x.md>\`
    — use the same plan path every time
-5. Stop. Do not continue to the next chunk in the same session unless told to.
+4. Stop. Do not continue to the next chunk in the same session unless told to.
 
 Next chunk, new session — open with \`fapony mem kickoff <path/to/PLAN-x.md>\` instead
 of carrying the old transcript forward. kickoff already filters to the rows for that plan,
@@ -196,16 +195,6 @@ export function initProject(targetPath: string, config?: Config): void {
 
 const AGENT_RULE_FILES = ["CLAUDE.md", "AGENTS.md"];
 
-function ask(question: string): Promise<string> {
-  const rl = createInterface({ input: process.stdin, output: process.stdout });
-  return new Promise((resolve) => {
-    rl.question(`${question} `, (answer) => {
-      rl.close();
-      resolve(answer.trim());
-    });
-  });
-}
-
 export async function cmdInit(args: string[]): Promise<void> {
   const targetPath = args[0];
   if (!targetPath) {
@@ -242,9 +231,16 @@ export async function cmdInit(args: string[]): Promise<void> {
   );
   if (found.length === 0) return;
 
-  const answer = await ask(
-    `\nAppend the memory-logging rules above to ${found.map((f) => relative(targetPath, f)).join(" and ")}? [y/N]`,
-  );
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  const answer = await new Promise<string>((resolve) => {
+    rl.question(
+      `\nAppend the memory-logging rules above to ${found.map((f) => relative(targetPath, f)).join(" and ")}? [y/N] `,
+      (a) => {
+        rl.close();
+        resolve(a.trim());
+      },
+    );
+  });
   if (!isAffirmative(answer)) return;
 
   const snippet = `\n\n${RULES_SNIPPET()}\n`;

package/src/install/antigravity.ts

@@ -0,0 +1,112 @@
+// src/install/antigravity.ts — Google Antigravity install provider
+//
+// Writes mcpServers.fapony to ~/.gemini/config/mcp_config.json (Antigravity's
+// global MCP config) and symlinks skills into ~/.agents/skills/ (Progressive
+// Skills path). No hooks in the first phase — Antigravity's hook surface is
+// still evolving.
+
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { agentsSkillsDir, linkSkills, reportSkills } from "./skills.js";
+import {
+  CURSOR_MCP_ENTRY,
+  defaultExit,
+  type InstallDeps,
+  MCP_KEY,
+} from "./types.js";
+
+/** ~/.gemini — created on first Antigravity launch. */
+export function findGeminiDir(getHome: () => string): string | null {
+  const dir = join(getHome(), ".gemini");
+  return existsSync(dir) ? dir : null;
+}
+
+function isFaponyEntry(entry: unknown): boolean {
+  if (!entry || typeof entry !== "object") return false;
+  const cfg = entry as Record<string, unknown>;
+  return (
+    cfg.command === CURSOR_MCP_ENTRY.command &&
+    JSON.stringify(cfg.args) === JSON.stringify(CURSOR_MCP_ENTRY.args)
+  );
+}
+
+function readJsonObject(path: string): Record<string, unknown> | null {
+  try {
+    const parsed: unknown = JSON.parse(readFileSync(path, "utf-8"));
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+      return null;
+    }
+    return parsed as Record<string, unknown>;
+  } catch {
+    return null;
+  }
+}
+
+export function cmdInstallAntigravity(
+  dryRun: boolean,
+  deps: InstallDeps = {},
+): void {
+  const exitFn = deps.exit ?? defaultExit;
+  const getHome = deps.homedir ?? homedir;
+  const geminiDir = findGeminiDir(getHome);
+
+  if (!geminiDir) {
+    console.error(
+      `Antigravity not found — open Antigravity at least once to create ~/.gemini`,
+    );
+    exitFn(1);
+    return;
+  }
+
+  // --- 1. MCP server (mcpServers.fapony in ~/.gemini/config/mcp_config.json) ---
+  const configDir = join(geminiDir, "config");
+  const mcpPath = join(configDir, "mcp_config.json");
+  let mcp: Record<string, unknown> = {};
+  let mcpIsNew = true;
+  if (existsSync(mcpPath)) {
+    const parsed = readJsonObject(mcpPath);
+    if (!parsed) {
+      console.error(`failed to parse ${mcpPath} — fix or remove it first`);
+      exitFn(1);
+      return;
+    }
+    mcp = parsed;
+    mcpIsNew = false;
+  }
+  const servers = (mcp.mcpServers ?? {}) as Record<string, unknown>;
+  const existing = servers[MCP_KEY];
+  if (existing !== undefined && !isFaponyEntry(existing)) {
+    console.error(
+      `an MCP server named "${MCP_KEY}" exists but points elsewhere — not overwriting.`,
+    );
+    console.error(`  inspect ${mcpPath} and remove it first`);
+    exitFn(1);
+    return;
+  }
+  if (existing !== undefined) {
+    console.error(
+      `✓ mcpServers.${MCP_KEY} already configured — no change needed`,
+    );
+    console.error(`  (${mcpPath})`);
+  } else {
+    const after = {
+      ...mcp,
+      mcpServers: { ...servers, [MCP_KEY]: CURSOR_MCP_ENTRY },
+    };
+    if (dryRun) {
+      console.error(
+        `── dry-run: would ${mcpIsNew ? "create" : "write"} ${mcpPath}${mcpIsNew ? "" : ` (mcpServers.${MCP_KEY})`} ──`,
+      );
+    } else {
+      writeFileSync(mcpPath, `${JSON.stringify(after, null, 2)}\n`, "utf-8");
+      console.error(`✓ added mcpServers.${MCP_KEY} to ${mcpPath}`);
+      console.error(`  restart Antigravity to load the MCP server`);
+    }
+  }
+
+  // --- 2. Skills (~/.agents/skills/) ---
+  const skillsDir = agentsSkillsDir(getHome);
+  const results = linkSkills(skillsDir, dryRun);
+  reportSkills(results, skillsDir, dryRun);
+}

package/src/install/claude.ts

@@ -2,14 +2,7 @@
 //
 // Shells out to `claude mcp add` (never parses/writes ~/.claude.json directly).
 
-import {
-  chmodSync,
-  copyFileSync,
-  existsSync,
-  mkdirSync,
-  readFileSync,
-  writeFileSync,
-} from "node:fs";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { assertSafe } from "../safety.js";
@@ -151,132 +144,18 @@ export function cmdInstallClaude(
   const skillsDir = claudeSkillsDir(deps.homedir ?? homedir);
   reportSkills(linkSkills(skillsDir, dryRun), skillsDir, dryRun);
 
-  // Wire statusline: copy script + update settings.json.
-  installStatusline(dryRun, deps);
-
   // Wire the Stop hook that refuses to end a turn with ungraded commits,
   // and the Read/Edit hints that annotate reads of large files and edits to
   // files with importers (both annotate-only).
   installClaudeHooks(dryRun, deps);
 }
 
-/**
- * Copy the statusline script to ~/.claude/statusline.sh and add the
- * statusLine field to ~/.claude/settings.json. Best-effort — never fails
- * the install if settings.json is unreadable or has unexpected shape.
- */
-function installStatusline(dryRun: boolean, deps: InstallDeps): void {
-  const home = deps.homedir ? deps.homedir() : homedir();
-  const claudeDir = join(home, ".claude");
-  const scriptSrc = join(INSTALL_ROOT, "statusline", "claude-statusline.sh");
-  const scriptDest = join(claudeDir, "statusline.sh");
-  const settingsPath = join(claudeDir, "settings.json");
-
-  // 1. Copy the statusline script — never overwrite someone else's.
-  // Mirrors the mcp-entry policy above: an existing script that isn't ours
-  // is left alone (the settings guard below will also refuse to repoint it).
-  if (!existsSync(scriptSrc)) {
-    console.error(`  statusline: script not found at ${scriptSrc} — skipping`);
-    return;
-  }
-  if (existsSync(scriptDest)) {
-    let current = "";
-    try {
-      current = readFileSync(scriptDest, "utf-8");
-    } catch {
-      current = "";
-    }
-    if (!current.includes("fapony")) {
-      console.error(
-        `  statusline: ${scriptDest} exists but isn't fapony's — not overwriting.`,
-      );
-      console.error(
-        `  inspect it first, then remove it to let fapony install its own.`,
-      );
-      return;
-    }
-  }
-  try {
-    if (!existsSync(claudeDir)) mkdirSync(claudeDir, { recursive: true });
-    if (!dryRun) copyFileSync(scriptSrc, scriptDest);
-    // Claude Code execs this file — the copy must stay executable.
-    if (!dryRun) chmodSync(scriptDest, 0o755);
-    console.error(
-      `  statusline: ${dryRun ? "would copy" : "copied"} ${scriptDest}`,
-    );
-  } catch (e) {
-    console.error(
-      `  statusline: failed to copy script — ${(e as Error).message}`,
-    );
-    return;
-  }
-
-  // 2. Update settings.json with statusLine field.
-  let settings: Record<string, unknown> = {};
-  if (existsSync(settingsPath)) {
-    try {
-      settings = JSON.parse(readFileSync(settingsPath, "utf-8")) as Record<
-        string,
-        unknown
-      >;
-    } catch {
-      console.error(
-        `  statusline: ${settingsPath} is unreadable or malformed — skipping settings update`,
-      );
-      return;
-    }
-  }
-
-  // Don't overwrite if already configured (same command path). A foreign
-  // statusLine (someone else's command) is left alone — same policy as the
-  // mcp-entry "points elsewhere" refusal above. Match on our exact dest:
-  // any *statusline.sh substring (e.g. another plugin's script) is not ours.
-  const existing = settings.statusLine as Record<string, unknown> | undefined;
-  if (
-    existing &&
-    existing.type === "command" &&
-    typeof existing.command === "string" &&
-    existing.command === scriptDest
-  ) {
-    console.error(
-      `  statusline: already configured in settings.json — no change`,
-    );
-    return;
-  }
-  if (existing && typeof existing === "object") {
-    console.error(
-      `  statusline: settings.json already has a statusLine that isn't fapony's — not overwriting.`,
-    );
-    console.error(
-      `  inspect it first, then remove it to let fapony wire its own.`,
-    );
-    return;
-  }
-
-  settings.statusLine = {
-    type: "command",
-    command: scriptDest,
-  };
-
-  if (!dryRun) {
-    writeFileSync(
-      settingsPath,
-      `${JSON.stringify(settings, null, 2)}\n`,
-      "utf-8",
-    );
-  }
-  console.error(
-    `  statusline: ${dryRun ? "would write" : "wrote"} statusLine → ${settingsPath}`,
-  );
-}
-
 /**
  * Shared append-to-settings.json hook installer. Both fapony hooks live
  * here now (Stop since PLAN-mem-mcp, PreToolUse read hint since the
  * large-file annotate feature) — the read/write/idempotence/append shape
  * is one implementation with two callers, not a scaffold.
- * Same policy as installStatusline: never touch a hook someone else
- * registered, never fail the install over it.
+ * Never touch a hook someone else registered, never fail the install over it.
  */
 function ensureClaudeHook(
   dryRun: boolean,
@@ -353,6 +232,7 @@ function installClaudeHooks(dryRun: boolean, deps: InstallDeps): void {
   installStopHook(dryRun, deps);
   installReadHintHook(dryRun, deps);
   installEditHintHook(dryRun, deps);
+  installMvGuardHook(dryRun, deps);
   installSessionStartHook(dryRun, deps);
 }
 
@@ -397,6 +277,22 @@ function installEditHintHook(dryRun: boolean, deps: InstallDeps): void {
   });
 }
 
+/**
+ * PreToolUse hook on Bash: denies a raw `git mv` of a plan file into a done/
+ * directory, pointing at `fapony mem plan-sweep --apply` instead — that
+ * command does the link rewrite a plain `git mv` skips. The one fapony hook
+ * that blocks besides Stop; matcher "Bash" keeps the spawn off every other
+ * tool call.
+ */
+function installMvGuardHook(dryRun: boolean, deps: InstallDeps): void {
+  ensureClaudeHook(dryRun, deps, {
+    event: "PreToolUse",
+    matcher: "Bash",
+    subcommand: "hook-mv-guard",
+    label: "plan-mv guard",
+  });
+}
+
 /**
  * SessionStart hook: injects `fapony mem kickoff` as context when the repo has
  * a mem log, and stays silent when it does not. Context only — SessionStart

package/src/install/detect.ts

@@ -1,14 +1,16 @@
 // src/install/detect.ts — detect which MCP clients are installed on this machine.
 //
 // Signal per client:
-//   claude   = `command -v claude` (CLI on PATH)
-//   cursor   = ~/.cursor exists (the app creates it on first run)
-//   opencode = ~/.config/opencode/{opencode.json,opencode.jsonc} exists
-//   zcode    = ~/.zcode/cli/config.json or ~/.agents/mcp.json exists
-//   codex    = ~/.codex/config.toml exists
+//   antigravity = ~/.gemini exists (the app creates it on first run)
+//   claude      = `command -v claude` (CLI on PATH)
+//   cursor      = ~/.cursor exists (the app creates it on first run)
+//   opencode    = ~/.config/opencode/{opencode.json,opencode.jsonc} exists
+//   zcode       = ~/.zcode/cli/config.json or ~/.agents/mcp.json exists
+//   codex       = ~/.codex/config.toml exists
 
 import { homedir } from "node:os";
 import { defaultCheckCmd } from "../setup.js";
+import { findGeminiDir } from "./antigravity.js";
 import { findCodexConfig } from "./codex.js";
 import { findCursorDir } from "./cursor.js";
 import { findOpencodeConfig } from "./opencode.js";
@@ -23,10 +25,10 @@ export interface DetectedClient {
 
 /**
  * Detect which MCP clients are available on this machine.
- * Returns one entry per platform, ordered: claude, cursor, opencode, zcode, codex.
+ * Returns one entry per platform, ordered: antigravity, claude, cursor, opencode, zcode, codex.
  *
  * Uses resolvers from each provider (file/dir-exists check) for
- * cursor/opencode/zcode/codex, and `command -v claude` for claude — all
+ * antigravity/cursor/opencode/zcode/codex, and `command -v claude` for claude — all
  * through injected deps for testability.
  */
 export function detectClients(deps: InstallDeps = {}): DetectedClient[] {
@@ -35,12 +37,20 @@ export function detectClients(deps: InstallDeps = {}): DetectedClient[] {
 
   const claude = checkCmd("claude");
 
+  const geminiDir = findGeminiDir(getHome);
   const cursorDir = findCursorDir(getHome);
   const opencodePath = findOpencodeConfig(getHome);
   const zcodeResult = findZcodeConfig(getHome);
   const codexPath = findCodexConfig(getHome);
 
   return [
+    {
+      platform: "antigravity",
+      installed: geminiDir !== null,
+      why: geminiDir
+        ? `dir at ${geminiDir}`
+        : "no ~/.gemini directory (open Antigravity once)",
+    },
     {
       platform: "claude",
       installed: claude,