fapony 0.1.0

package/src/conventions-seed.ts

@@ -0,0 +1,420 @@
+// src/conventions-seed.ts — `fapony init` fill-signal (PLAN-convention-debt chunk 2).
+//
+// คำถาม: "การ fill signal ตอน init ทำได้แค่ไหน" (SPEC-convention-debt §2.2) —
+// วัดสองรอบ คำตอบรอบแรกผิด: eslint คือของที่ทีมส่วนใหญ่ปล่อย default ตอนติดตั้ง,
+// pair-mining พังกับ commit ก้อนใหญ่และ cap ผ่อนไม่ได้ (วัดแล้ว) — ของที่**ทุกรีโปมี**
+// คือโค้ดตัวเอง ฐานจึงเป็น wrapper detector (อ่าน snapshot อย่างเดียว ไม่แตะ history),
+// eslint เป็น bonus เมื่อมี, pair-mining ยังไม่ทำ (chunk 7 วัด precision ก่อน)
+//
+// เขียนได้ที่เดียว: <target>/.fapony/conventions.json — นิยาม convention อยู่ในรีโปที่
+// ถูกวัด (SPEC §2.1), commit ได้เพราะทุก field เป็น repo-relative · มีอยู่แล้ว = ไม่แตะ
+// (rule 5c) · fapony ไม่เดา convention ที่ไม่มีร่องรอย — อันที่ยังไม่เคย migrate และ
+// ไม่มี wrapper ไม่มีร่องรอยทั้งใน snapshot และ history ช่องนั้นเหลือให้คนเติม (stale)
+
+import { mkdirSync, readdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join, relative } from "node:path";
+import { pathToFileURL } from "node:url";
+import { collectSourceFiles, isSkippedDir, isTestFile } from "./analyze.js";
+import { extractBody, extractExports } from "./map.js";
+
+const RESTRICTED_RULES = new Set([
+  "no-restricted-imports",
+  "no-restricted-syntax",
+  "no-restricted-properties",
+]);
+// Flat-config era + eslint.rules.js companions — where the measured entries live.
+// Legacy .eslintrc (JSON/YAML) is not importable and is skipped on purpose.
+const CONFIG_IMPORTABLE_RE = /^(eslint\.config|eslint\.rules)\.(js|mjs|cjs)$/;
+const RESTRICTED_TEXT_RE = /no-restricted-(imports|syntax|properties)/;
+
+export interface SeedResult {
+  file: string;
+  /** Conventions derived from eslint no-restricted-* entries (they carry checker). */
+  eslintRows: number;
+  /** Wrapper-derived candidates (checker null — no checker exists yet). */
+  wrapperRows: number;
+  configs: string[];
+  /** Config found but not importable (missing deps of that repo) — said, never silent. */
+  skipped: string[];
+  /** conventions.json already existed — left untouched (rule 5c). */
+  kept?: boolean;
+}
+
+export interface SeedRow {
+  id: string;
+  rule: string;
+  where: string;
+  stale: string | null;
+  ok?: string;
+  guard?: string;
+  checker: string | null;
+  decided?: null;
+}
+
+function slug(s: string): string {
+  return (
+    s
+      .replace(/[^A-Za-z0-9._-]+/g, "-")
+      .replace(/^-+|-+$/g, "")
+      .toLowerCase() || "x"
+  );
+}
+
+function flatText(s: unknown): string | null {
+  if (typeof s !== "string") return null;
+  const t = s.replace(/\s+/g, " ").trim();
+  return t.length > 0 ? t : null;
+}
+
+function escapeRe(s: string): string {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+// "src/**/*.{ts,tsx}" → "src" · "**\/x" → "." · "src/routes/**/*.tsx" → "src/routes"
+function globDir(glob: unknown): string | null {
+  if (typeof glob !== "string" || glob.length === 0) return null;
+  const cut = glob.replace(/[\\/]\*\*.*$/, "").replace(/\*\*.*$/, "");
+  const dir = cut.replace(/\/+$/, "");
+  return dir === "" ? "." : dir;
+}
+
+// --- eslint config extraction ---
+
+interface Block {
+  files?: unknown;
+  rules?: Record<string, unknown>;
+}
+
+function* walkBlocks(node: unknown, depth = 0): Generator<Block> {
+  if (depth > 6 || !node || typeof node !== "object") return;
+  if (Array.isArray(node)) {
+    for (const n of node) yield* walkBlocks(n, depth + 1);
+    return;
+  }
+  const o = node as Record<string, unknown>;
+  if (o.rules && typeof o.rules === "object") yield o as Block;
+  for (const v of Object.values(o)) {
+    if (Array.isArray(v) || (v && typeof v === "object")) {
+      yield* walkBlocks(v, depth + 1);
+    }
+  }
+}
+
+function rowsFromBlock(block: Block, whereBase: string): SeedRow[] {
+  const out: SeedRow[] = [];
+  const whereGlob = Array.isArray(block.files) ? globDir(block.files[0]) : null;
+  const dir = whereBase === "." ? "" : `${whereBase}/`;
+  const where =
+    whereGlob && whereGlob !== "." ? `${dir}${whereGlob}` : whereBase || ".";
+  const push = (message: unknown, stale: string | null, ruleId: string) => {
+    const text = flatText(message);
+    if (!text) return; // checker โดยไม่มีข้อความ = ไม่รู้ว่ากฎคืออะไร
+    out.push({ id: "", rule: text, where, stale, checker: ruleId });
+  };
+  for (const [ruleId, value] of Object.entries(block.rules ?? {})) {
+    if (!RESTRICTED_RULES.has(ruleId) || !Array.isArray(value)) continue;
+    const [, ...entries] = value;
+    if (ruleId === "no-restricted-imports") {
+      // ["error", { paths: [{name, message, importNames?}], patterns: [{group, message}] }]
+      for (const opt of entries) {
+        if (!opt || typeof opt !== "object") continue;
+        const o = opt as Record<string, unknown>;
+        for (const p of Array.isArray(o.paths) ? o.paths : []) {
+          const e = p as Record<string, unknown>;
+          if (!e || typeof e !== "object") continue;
+          const name = typeof e.name === "string" ? e.name : null;
+          const stale =
+            name && !Array.isArray(e.importNames)
+              ? `["']${escapeRe(name)}["']`
+              : null; // named-import bans are not one text pattern
+          push(e.message, stale, ruleId);
+        }
+        for (const p of Array.isArray(o.patterns) ? o.patterns : []) {
+          const e = p as Record<string, unknown>;
+          if (!e || typeof e !== "object") continue;
+          push(e.message, null, ruleId); // gitignore-style group — no text regex
+        }
+      }
+      continue;
+    }
+    // no-restricted-syntax / -properties: ["error", entry, entry, ...]
+    for (const e of entries) {
+      if (!e || typeof e !== "object") continue;
+      const o = e as Record<string, unknown>;
+      let stale: string | null = null;
+      if (ruleId === "no-restricted-properties") {
+        const prop = typeof o.property === "string" ? o.property : null;
+        if (prop) {
+          stale =
+            typeof o.object === "string"
+              ? `${escapeRe(o.object)}\\.${escapeRe(prop)}\\(`
+              : `\\.${escapeRe(prop)}\\(`;
+        }
+      }
+      // no-restricted-syntax: the selector is AST-shaped — no honest text
+      // regex. The row still lands (checker set → the debt detector stays
+      // silent anyway; the row's value is the rule text in one place).
+      push(o.message, stale, ruleId);
+    }
+  }
+  return out;
+}
+
+function findConfigFiles(root: string): string[] {
+  const out: string[] = [];
+  const stack = [root];
+  while (stack.length > 0) {
+    const dir = stack.pop() as string;
+    let entries: import("node:fs").Dirent[];
+    try {
+      entries = readdirSync(dir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const e of entries) {
+      if (e.isSymbolicLink()) continue;
+      if (e.isDirectory()) {
+        if (isSkippedDir(e.name, dir)) continue;
+        stack.push(join(dir, e.name));
+      } else if (e.isFile() && CONFIG_IMPORTABLE_RE.test(e.name)) {
+        out.push(join(dir, e.name));
+      }
+    }
+  }
+  return out.sort();
+}
+
+async function eslintRows(
+  root: string,
+): Promise<{ rows: SeedRow[]; configs: string[]; skipped: string[] }> {
+  const rows: SeedRow[] = [];
+  const configs: string[] = [];
+  const skipped: string[] = [];
+  const seen = new Set<string>();
+  for (const abs of findConfigFiles(root)) {
+    let raw: string;
+    try {
+      raw = readFileSync(abs, "utf-8");
+    } catch {
+      continue;
+    }
+    if (!RESTRICTED_TEXT_RE.test(raw)) continue;
+    configs.push(relative(root, abs));
+    let mod: Record<string, unknown>;
+    try {
+      // The config is code from the measured repo — same trust as running its
+      // own eslint. Import (not text-parse) so shared constants and .map()
+      // computed entries resolve to real values.
+      mod = (await import(pathToFileURL(abs).href)) as Record<string, unknown>;
+    } catch (e) {
+      skipped.push(
+        `${relative(root, abs)} — import failed: ${
+          e instanceof Error ? e.message.split("\n")[0] : "?"
+        }`,
+      );
+      continue;
+    }
+    const cfgDir = dirname(relative(root, abs));
+    for (const block of walkBlocks(mod.default ?? mod)) {
+      rows.push(...rowsFromBlock(block, cfgDir === "." ? "." : cfgDir));
+    }
+  }
+  // Dedupe identical (checker, message) pairs that flat-config supersets repeat,
+  // then hand out unique ids.
+  const byMessage = new Map<string, SeedRow>();
+  for (const r of rows) {
+    const key = `${r.checker}\n${r.rule}`;
+    if (!byMessage.has(key)) byMessage.set(key, r);
+  }
+  const usedId = new Set<string>();
+  const final: SeedRow[] = [];
+  for (const r of byMessage.values()) {
+    let id = `eslint-${slug(r.rule).slice(0, 40)}`;
+    for (let n = 2; usedId.has(id); n++)
+      id = `eslint-${slug(r.rule).slice(0, 40)}-${n}`;
+    usedId.add(id);
+    final.push({ ...r, id });
+  }
+  return { rows: final, configs, skipped };
+}
+
+// --- wrapper detector (snapshot only — no history, no eslint) ---
+
+const KEYWORDS = new Set([
+  "if",
+  "for",
+  "while",
+  "switch",
+  "catch",
+  "function",
+  "return",
+  "new",
+  "typeof",
+  "delete",
+  "void",
+  "in",
+  "of",
+  "do",
+  "else",
+  "super",
+  "import",
+  "await",
+  "async",
+  "yield",
+  "case",
+  "throw",
+]);
+const MAX_WRAPPER_CANDIDATES = 40;
+const MIN_USERS = 3;
+const MIN_DIRECT = 2;
+const MAX_DIRECT = 100;
+
+interface Candidate {
+  wrapper: string;
+  file: string;
+  callText: string; // regex source, e.g. \.toLocaleString\( or newId\(
+  display: string; // e.g. .toLocaleString( / newId(
+}
+
+function callsInBody(body: string, local: Set<string>): Set<string> {
+  const found = new Set<string>();
+  for (const m of body.matchAll(/(?<![.\w$])([A-Za-z_$][\w$]*)\s*\(/g)) {
+    const name = m[1];
+    if (!KEYWORDS.has(name) && !local.has(name)) found.add(name);
+  }
+  for (const m of body.matchAll(/\.([A-Za-z_$][\w$]*)\s*\(/g)) {
+    found.add(`.${m[1]}`);
+  }
+  return found;
+}
+
+function detectWrappers(root: string): SeedRow[] {
+  const files = collectSourceFiles(root);
+  const candidates: Candidate[] = [];
+  for (const rel of files) {
+    if (candidates.length >= MAX_WRAPPER_CANDIDATES) break;
+    if (isTestFile(rel)) continue; // test fixtures are not convention sources
+    let source: string;
+    try {
+      source = readFileSync(join(root, rel), "utf-8");
+    } catch {
+      continue;
+    }
+    const scan = extractExports(source);
+    if (scan.error) continue;
+    for (const sym of scan.symbols) {
+      if (sym.kind !== "const" && sym.kind !== "fn") continue;
+      const body = extractBody(source, sym.line).join("\n");
+      if (body.length < 10 || body.length > 2000) continue;
+      const local = new Set(scan.symbols.map((s) => s.name));
+      for (const call of callsInBody(body, local)) {
+        const ident = call.startsWith(".") ? call.slice(1) : call;
+        if (ident === sym.name) continue;
+        candidates.push({
+          wrapper: sym.name,
+          file: rel,
+          callText: call.startsWith(".")
+            ? `\\.${escapeRe(ident)}\\(`
+            : `\\b${escapeRe(ident)}\\(`,
+          display: call.startsWith(".") ? `.${ident}(` : `${ident}(`,
+        });
+        if (candidates.length >= MAX_WRAPPER_CANDIDATES) break;
+      }
+      if (candidates.length >= MAX_WRAPPER_CANDIDATES) break;
+    }
+  }
+  if (candidates.length === 0) return [];
+
+  // One pass over the tree counting, per candidate: files still calling the
+  // wrapped thing directly (never referencing the wrapper) vs files using the
+  // wrapper. Both directions must be real for this to be a live migration.
+  const direct = new Map<Candidate, number>();
+  const users = new Map<Candidate, number>();
+  const wrapperRe = new Map<Candidate, RegExp>();
+  for (const c of candidates) {
+    wrapperRe.set(c, new RegExp(`\\b${escapeRe(c.wrapper)}\\b`));
+    direct.set(c, 0);
+    users.set(c, 0);
+  }
+  for (const rel of files) {
+    let content: string;
+    try {
+      content = readFileSync(join(root, rel), "utf-8");
+    } catch {
+      continue;
+    }
+    for (const c of candidates) {
+      if (rel === c.file) continue;
+      const uses = wrapperRe.get(c)!.test(content);
+      if (uses) users.set(c, users.get(c)! + 1);
+      if (!uses && new RegExp(c.callText).test(content)) {
+        direct.set(c, direct.get(c)! + 1);
+      }
+    }
+  }
+
+  const out: SeedRow[] = [];
+  const seenId = new Set<string>();
+  for (const c of candidates) {
+    const d = direct.get(c) ?? 0;
+    const u = users.get(c) ?? 0;
+    if (d < MIN_DIRECT || d > MAX_DIRECT || u < MIN_USERS) continue;
+    const id = `wrap-${slug(c.wrapper)}`;
+    if (seenId.has(id)) continue;
+    seenId.add(id);
+    out.push({
+      id,
+      rule: `use ${c.wrapper}() instead of ${c.display} directly (${d} file(s) still call it raw, ${u} file(s) already use the wrapper)`,
+      where: ".",
+      stale: c.callText,
+      ok: `\\b${escapeRe(c.wrapper)}\\b`,
+      checker: null,
+    });
+  }
+  return out;
+}
+
+// --- entry ---
+
+export async function seedConventionsFile(target: string): Promise<SeedResult> {
+  const file = join(target, ".fapony", "conventions.json");
+  const base: SeedResult = {
+    file,
+    eslintRows: 0,
+    wrapperRows: 0,
+    configs: [],
+    skipped: [],
+  };
+  try {
+    JSON.parse(readFileSync(file, "utf-8"));
+    return { ...base, kept: true }; // exists → never overwrite (rule 5c)
+  } catch {
+    // no file yet — proceed
+  }
+  const rows: SeedRow[] = [];
+  let configs: string[] = [];
+  const skipped: string[] = [];
+  try {
+    const es = await eslintRows(target);
+    rows.push(...es.rows);
+    configs = es.configs;
+    skipped.push(...es.skipped);
+  } catch {
+    // eslint extraction must never fail the scaffold
+  }
+  try {
+    rows.push(...detectWrappers(target));
+  } catch {
+    // a wrapper scan failure is not an init failure
+  }
+  const payload = `${JSON.stringify({ conventions: rows }, null, 2)}\n`;
+  mkdirSync(join(target, ".fapony"), { recursive: true });
+  writeFileSync(file, payload);
+  return {
+    file,
+    eslintRows: rows.filter((r) => r.checker !== null).length,
+    wrapperRows: rows.filter((r) => r.checker === null).length,
+    configs,
+    skipped,
+  };
+}

package/src/db/defaults.ts

@@ -0,0 +1,26 @@
+import type { Config } from "./types.js";
+
+export const DEFAULT_SAFETY_DENY = [
+  "reset\\s+--hard",
+  "clean\\s+-[a-z]*f",
+  "checkout\\s+--\\s",
+  "git\\s+stash",
+];
+export const DEFAULT_PLAN_DIR = ".fapony/plan";
+export const DEFAULT_SPEC_DIR = ".fapony/spec";
+// Archive sits beside plan/, not inside it, so archiving never changes a file's
+// depth and its relative links survive the move untouched.
+export const DEFAULT_DONE_DIR = ".fapony/done";
+export const DEFAULT_MEMORY_ENTRY = ".fapony/.memory/mem.ts";
+export const DEFAULT_EVIDENCE_FILE = ".fapony/evidence.json";
+
+export const DEFAULT_CONFIG: Config = {
+  worktrees: {},
+  review: {
+    maxRounds: 2,
+  },
+  memory: null,
+  telemetry: null,
+  paths: null,
+  safety: null,
+};

package/src/db/getters.ts

@@ -0,0 +1,33 @@
+import {
+  DEFAULT_DONE_DIR,
+  DEFAULT_EVIDENCE_FILE,
+  DEFAULT_MEMORY_ENTRY,
+  DEFAULT_PLAN_DIR,
+  DEFAULT_SAFETY_DENY,
+  DEFAULT_SPEC_DIR,
+} from "./defaults.js";
+import type { Config } from "./types.js";
+
+export function safetyDeny(config?: Config): string[] {
+  return config?.safety?.deny ?? DEFAULT_SAFETY_DENY;
+}
+
+export function planDir(config?: Config): string {
+  return config?.paths?.planDir ?? DEFAULT_PLAN_DIR;
+}
+
+export function specDir(config?: Config): string {
+  return config?.paths?.specDir ?? DEFAULT_SPEC_DIR;
+}
+
+export function doneDir(config?: Config): string {
+  return config?.paths?.doneDir ?? DEFAULT_DONE_DIR;
+}
+
+export function memoryEntry(config?: Config): string {
+  return config?.paths?.memoryEntry ?? DEFAULT_MEMORY_ENTRY;
+}
+
+export function evidenceFile(config?: Config): string {
+  return config?.paths?.evidenceFile ?? DEFAULT_EVIDENCE_FILE;
+}

package/src/db/index.ts

@@ -0,0 +1,7 @@
+// barrel — re-export ทุกอย่างจาก db/* ให้ import เดิมจาก "./db/index.js" ใช้ได้
+
+export * from "./defaults.js";
+export * from "./getters.js";
+export * from "./load.js";
+export * from "./store.js";
+export * from "./types.js";

package/src/db/load.ts

@@ -0,0 +1,57 @@
+import { existsSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { DEFAULT_CONFIG } from "./defaults.js";
+import type { Config } from "./types.js";
+
+// XDG Base Directory convention (macOS ignores Apple's ~/Library/Application Support
+// for CLI tools by common practice — gh, ripgrep-adjacent tools, etc. use ~/.config too)
+// Override order: $FAPONY_STATE_DIR > config.paths.stateDir > $XDG_CONFIG_HOME > ~/.config
+export function faponyDir(config?: Config): string {
+  if (process.env.FAPONY_STATE_DIR) return process.env.FAPONY_STATE_DIR;
+  if (config?.paths?.stateDir) return config.paths.stateDir;
+  const base = process.env.XDG_CONFIG_HOME || join(homedir(), ".config");
+  return join(base, "fapony");
+}
+
+function _dbPath(config?: Config): string {
+  return join(faponyDir(config), "state.db");
+}
+
+export function configFilePath(): string {
+  if (process.env.FAPONY_CONFIG) return process.env.FAPONY_CONFIG;
+  return join(process.cwd(), "fapony.config.json");
+}
+
+function freshDefaultConfig(): Config {
+  return {
+    ...DEFAULT_CONFIG,
+    worktrees: { ...DEFAULT_CONFIG.worktrees },
+    review: {
+      ...DEFAULT_CONFIG.review,
+    },
+  };
+}
+
+export function loadConfig(configPath?: string): Config {
+  const resolved = configPath ?? configFilePath();
+  if (!existsSync(resolved)) return freshDefaultConfig();
+
+  try {
+    const raw = readFileSync(resolved, "utf-8");
+    const file = JSON.parse(raw) as Partial<Config>;
+
+    return {
+      ...DEFAULT_CONFIG,
+      ...file,
+      review: {
+        ...DEFAULT_CONFIG.review,
+        ...file.review,
+      },
+      paths: file.paths ? { ...file.paths } : DEFAULT_CONFIG.paths,
+      safety: file.safety ? { ...file.safety } : DEFAULT_CONFIG.safety,
+    };
+  } catch {
+    return freshDefaultConfig();
+  }
+}