fapony 0.3.0 → 0.3.4

package/src/price/resolve.ts

@@ -1,213 +1,12 @@
-// src/price/resolve.ts — normalize model id + compute list-price equivalent
-//
-// Hard rule: an unmappable model must be unpriced, never silently counted as 0 (the main failure mode
-// of this feature) · free only applies to things that truly cost 0 (local / :free rows in the table)
-
-import type { ModelBreakdown, PassiveUsageResult } from "../session/types.js";
-import type { ModelRates, PriceTable } from "./fetch.js";
-
-export type PriceStatus = "priced" | "free" | "unpriced";
-
-export interface PriceResolution {
-  status: PriceStatus;
-  rates: ModelRates | null;
-}
-
-/** client prefix prepended to every model id — strip it, then look up again */
-const CLIENT_PREFIXES = ["openrouter/", "opencode-go/", "opencode/"];
-
-/** OpenRouter's trailing tier — :free is a genuinely free endpoint, :batch is a discount */
-function stripTier(id: string): string {
-  return id.endsWith(":free") || id.endsWith(":batch")
-    ? id.slice(0, id.lastIndexOf(":"))
-    : id;
-}
-
-/**
- * Candidate ids ordered by specificity: exact first, broad later
- * (an exact match always wins — the bare slug is the broadest match and goes last)
- */
-export function candidateIds(provider: string, model: string): string[] {
-  const full = provider ? `${provider}/${model}` : model;
-  const out: string[] = [full];
-  let rest = full;
-  for (const p of CLIENT_PREFIXES) {
-    if (rest.startsWith(p)) {
-      rest = rest.slice(p.length);
-      out.push(rest);
-      break;
-    }
-  }
-  // opencode appends -free to the slug of a free model (deepseek-v4-flash-free)
-  if (rest.endsWith("-free")) out.push(rest.slice(0, -"-free".length));
-  return out;
-}
-
-/**
- * Find rates for one model — null only for local, which skips the table
- * (local never had a price to begin with, it is not "not found")
- */
-function isLocalProvider(provider: string): boolean {
-  return provider === "lmstudio_local";
-}
-
-export function resolvePrice(
-  provider: string,
-  model: string,
-  table: PriceTable,
-): PriceResolution {
-  if (!model || model === "(no model id)" || model === "(unknown)")
-    return { status: "unpriced", rates: null };
-  if (isLocalProvider(provider)) return { status: "free", rates: null };
-  // ends with :free or -free = used a free endpoint / the client's free model
-  // the real price is 0 (not list price), whether or not OpenRouter maps it
-  if (model.endsWith(":free") || model.endsWith("-free"))
-    return { status: "free", rates: null };
-  for (const id of candidateIds(provider, model)) {
-    const rates = table.models[id] ?? table.models[stripTier(id)];
-    if (rates) {
-      // an all-zero rate row (:free / free model) = genuinely free, not unpriced
-      if (
-        rates.input === 0 &&
-        rates.output === 0 &&
-        rates.cacheRead === 0 &&
-        (rates.cacheWrite ?? 0) === 0
-      )
-        return { status: "free", rates };
-      return { status: "priced", rates };
-    }
-  }
-  // zcode stores only the slug with no vendor (GLM-5.3-Flash) — compare the suffix / exact
-  // case-insensitive match (exact, not fuzzy: the whole string must be equal in length)
-  // the table side strips the tier (:free/:batch) before comparing — so a bare slug hits the :free
-  // row that is truly 0 (e.g. ling-3.0-flash-fin) and becomes free, not unpriced
-  const slug = stripTier(
-    candidateIds(provider, model).at(-1) ?? "",
-  ).toLowerCase();
-  if (slug) {
-    const ids = Object.keys(table.models).sort();
-    for (const id of ids) {
-      const rawSuffix = id.includes("/")
-        ? id.slice(id.lastIndexOf("/") + 1)
-        : id;
-      if (stripTier(rawSuffix).toLowerCase() === slug) {
-        const rates = table.models[id];
-        if (
-          rates.input === 0 &&
-          rates.output === 0 &&
-          rates.cacheRead === 0 &&
-          (rates.cacheWrite ?? 0) === 0
-        )
-          return { status: "free", rates };
-        return { status: "priced", rates };
-      }
-    }
-  }
-  return { status: "unpriced", rates: null };
-}
-
-export interface TokenCounts {
-  input: number;
-  cacheRead: number;
-  cacheWrite: number;
-  output: number;
-}
-
-/**
- * Pure costing: separate rates for input / cache-read / cache-write — never one rate for all
- *
- * reasoning is not multiplied separately: Anthropic-family thinking is already included in output
- * (the reader keeps it separately just for visibility); multiplying separately = double counting · cache_write absent from the table
- * → fall back to the input rate (writing cache costs more than or equal to a fresh read, never less)
- */
-export function calcCost(t: TokenCounts, rates: ModelRates): number {
-  return (
-    t.input * rates.input +
-    t.cacheRead * rates.cacheRead +
-    t.cacheWrite * (rates.cacheWrite ?? rates.input) +
-    t.output * rates.output
-  );
-}
-
-export interface ImputedModel {
-  provider: string;
-  model: string;
-  session_count: number;
-  tokens_input: number;
-  tokens_output: number;
-  tokens_cache_read: number;
-  tokens_cache_write: number;
-  status: PriceStatus;
-  /** dollars at list-price — 0 when free/unpriced (check status, do not read the number alone) */
-  imputed_cost: number;
-}
-
-export interface ImputeSummary {
-  total_imputed: number;
-  priced_sessions: number;
-  free_sessions: number;
-  unpriced_sessions: number;
-  unpriced_tokens: number;
-  by_model: ImputedModel[];
-}
-
-/**
- * Price an entire PassiveUsageResult — works on live results (stats/usage) or cache rows
- * (usage-web) alike, because it only takes tokens per model
- */
-export function imputeResult(
-  result: PassiveUsageResult,
-  table: PriceTable,
-): ImputeSummary {
-  const by_model: ImputedModel[] = [];
-  let total_imputed = 0;
-  let priced_sessions = 0;
-  let free_sessions = 0;
-  let unpriced_sessions = 0;
-  let unpriced_tokens = 0;
-  for (const m of result.by_model as ModelBreakdown[]) {
-    const r = resolvePrice(m.provider, m.model, table);
-    let cost = 0;
-    if (r.status === "priced" && r.rates) {
-      cost = calcCost(
-        {
-          input: m.tokens_input,
-          cacheRead: m.tokens_cache_read,
-          cacheWrite: m.tokens_cache_write,
-          output: m.tokens_output,
-        },
-        r.rates,
-      );
-      total_imputed += cost;
-      priced_sessions += m.session_count;
-    } else if (r.status === "free") {
-      free_sessions += m.session_count;
-    } else {
-      unpriced_sessions += m.session_count;
-      unpriced_tokens +=
-        m.tokens_input +
-        m.tokens_output +
-        m.tokens_cache_read +
-        m.tokens_cache_write;
-    }
-    by_model.push({
-      provider: m.provider,
-      model: m.model,
-      session_count: m.session_count,
-      tokens_input: m.tokens_input,
-      tokens_output: m.tokens_output,
-      tokens_cache_read: m.tokens_cache_read,
-      tokens_cache_write: m.tokens_cache_write,
-      status: r.status,
-      imputed_cost: cost,
-    });
-  }
-  return {
-    total_imputed,
-    priced_sessions,
-    free_sessions,
-    unpriced_sessions,
-    unpriced_tokens,
-    by_model,
-  };
-}
+// shim — moved to src/core/pricing.ts
+export {
+  calcCost,
+  candidateIds,
+  type ImputedModel,
+  type ImputeSummary,
+  imputeResult,
+  type PriceResolution,
+  type PriceStatus,
+  resolvePrice,
+  type TokenCounts,
+} from "../core/pricing.js";

package/src/report/cli.ts

@@ -3,9 +3,9 @@
 import { spawnSync } from "node:child_process";
 import { writeFileSync } from "node:fs";
 import { dirname, resolve } from "node:path";
-import { loadConfig } from "../db/index.js";
-import { toolVerificationReport } from "../mcp/tools/report.js";
-import { parseToolResult } from "../mcp/types.js";
+import { toolVerificationReport } from "../adapters/mcp/tools/report.js";
+import { loadConfig } from "../core/config.js";
+import { parseToolResult } from "../core/types.js";
 import { getStatsData } from "../stats/data.js";
 import { renderReportHtml } from "./render.js";
 

package/src/safety.ts

@@ -1,18 +1,2 @@
-// src/safety.ts — deny-list for dangerous git commands.
-// Rule: assertSafe() must be called on every command before spawn, including
-// ones built from config templates (memory claim/close/add, evidence
-// collector commands, install's `claude mcp add`).
-// Patterns come from config.safety.deny (regex sources); built-in default
-// covers the 4 known-destructive git invocations.
-
-import { DEFAULT_SAFETY_DENY } from "./db/index.js";
-
-export function assertSafe(argv: string[], denySources?: string[]): void {
-  const sources = denySources ?? DEFAULT_SAFETY_DENY;
-  const joined = argv.join(" ");
-  for (const src of sources) {
-    if (new RegExp(src).test(joined)) {
-      throw new Error(`refusing to run dangerous command: ${joined}`);
-    }
-  }
-}
+// shim — moved to src/core/safety.ts
+export { assertSafe } from "./core/safety.js";

package/src/{plan-seed.ts → seed/plan-seed.ts}

@@ -1,4 +1,4 @@
-// src/plan-seed.ts — `fapony plan-seed <name> [--spec] [--scope <path>]...`
+// src/seed/plan-seed.ts — `fapony plan-seed <name> [--spec] [--scope <path>]...`
 //
 // Writes PLAN + SPEC straight into planDir/specDir. What it pre-fills is the
 // structure (frontmatter, the 8 sections, prior art, ledger context) — the
@@ -25,7 +25,6 @@
 //
 // Composes existing producers — no new parsing, no new table, no MCP tool.
 
-import { execSync } from "node:child_process";
 import {
   existsSync,
   mkdirSync,
@@ -35,15 +34,20 @@ import {
   writeFileSync,
 } from "node:fs";
 import { basename, join, relative, resolve, sep } from "node:path";
-import { collectSourceFiles, isSkippedDir, SCAN_EXTS } from "./analyze.js";
-import { computeModelFit } from "./context/projectHealth.js";
-import { doneDir, planDir, specDir } from "./db/getters.js";
-import { CONFIG_FILENAME } from "./db/index.js";
-import { loadConfig } from "./db/load.js";
-import type { Config } from "./db/types.js";
-import { extractExports } from "./map.js";
-import { readRecentMemDecisions } from "./memory.js";
-import { getStatsData } from "./stats/data.js";
+import { collectSourceFiles, isSkippedDir, SCAN_EXTS } from "../analyze.js";
+import { computeModelFit } from "../context/projectHealth.js";
+import {
+  CONFIG_FILENAME,
+  type Config,
+  doneDir,
+  loadConfig,
+  planDir,
+  specDir,
+} from "../core/config.js";
+import { extractExports } from "../map.js";
+import { readRecentMemDecisions } from "../memory.js";
+import { getStatsData } from "../stats/data.js";
+import { capLines, execGit, SIG_MAX } from "./primitives.js";
 
 // One chunk = one module's signatures — past ~40 lines a module is its own
 // reading task, and the whole-SPEC cap below does the final trim.
@@ -56,7 +60,6 @@ const SCOPE_WARN_FILES = 300;
 // Shipped plans/specs that already touched this scope. Capped low on purpose:
 // this is a "go read that first" pointer, not a bibliography.
 const MAX_PRIOR_ART = 5;
-const SIG_MAX = 90;
 // Anchor-safe slug: lowercase, non-alphanumerics → dash.
 const slug = (s: string): string =>
   s
@@ -224,7 +227,7 @@ next step in the same session is what rule 9 forbids.
 1. _(agent fills in — each step must be verifiable)_
 
 **Closing a step:** tick its TL;DR box with the sha · \`git commit\` this step's
-files only · \`verdict_submit\` (MCP) with this step's \`regime\` · then hand off:
+files only · then hand off:
 
 \`\`\`bash
 fapony mem add note "<what chunk N+1 must know>" --files <f1,f2> ${planRel}
@@ -257,16 +260,6 @@ interface Chunk {
   body: string;
 }
 
-// review-seed's cap shape: keep the head, always say how much was cut — a
-// silent cut is indistinguishable from "that was everything".
-function capLines(lines: string[], cap: number, what: string): string[] {
-  if (lines.length <= cap) return lines;
-  const rest = lines.length - (cap - 1);
-  const kept = lines.slice(0, cap - 1);
-  kept.push(`… +${rest} more ${what}`);
-  return kept;
-}
-
 function capChunk(c: Chunk): Chunk {
   return {
     ...c,
@@ -530,15 +523,8 @@ export function cmdPlanSeed(args: string[]): void {
   // state.db uses (git rev-parse --show-toplevel). Running from a subdir
   // would otherwise mismatch: stats return empty, Context (fapony) always
   // prints "(not enough graded history yet)".
-  let worktree: string;
-  try {
-    worktree = execSync("git rev-parse --show-toplevel", {
-      encoding: "utf-8",
-      stdio: ["pipe", "pipe", "pipe"],
-    }).trim();
-  } catch {
-    worktree = cwd;
-  }
+  const root = execGit("git rev-parse --show-toplevel", cwd);
+  const worktree = root.ok ? root.output.split("\n")[0] : cwd;
 
   // Scope: explicit paths win; default is the cwd. Resolved absolutes,
   // deduped — the same path twice is one scope. Nested roots are pruned:

package/src/seed/primitives.ts

@@ -0,0 +1,60 @@
+// src/seed/primitives.ts — shared helpers for plan-seed + review-seed
+//
+// Git execution, output capping, signature formatting — the pieces both
+// commands need. §0 rule: add-only — never remove or rename exported symbols.
+
+import { execSync } from "node:child_process";
+
+// --- Error class ---
+
+export class SeedError extends Error {}
+
+// --- Git helpers ---
+
+export function execGit(
+  cmd: string,
+  cwd: string,
+): { ok: boolean; output: string; error?: string } {
+  try {
+    const output = execSync(cmd, {
+      cwd,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"],
+      timeout: 15_000,
+    });
+    return { ok: true, output: output.trim() };
+  } catch (e: unknown) {
+    const err = e as { stderr?: string; message?: string };
+    return {
+      ok: false,
+      output: "",
+      error: (err.stderr ?? err.message ?? "").trim(),
+    };
+  }
+}
+
+export function gitOk(r: { ok: boolean; error?: string }, cmd: string): void {
+  if (!r.ok)
+    throw new SeedError(`git failed: ${cmd}\n${r.error ?? "unknown error"}`);
+}
+
+// Values interpolated into a git command line must be plain refs/paths —
+// blocks shell metacharacters before execSync ever sees them.
+const GIT_VALUE_RE = /^[A-Za-z0-9._/{}^~+-]+$/;
+
+export function gitValue(kind: string, value: string): string {
+  if (!GIT_VALUE_RE.test(value)) {
+    throw new SeedError(`invalid ${kind}: ${value}`);
+  }
+  return value;
+}
+
+// --- Output capping ---
+
+// Keep the head, always say how much was cut — a silent cut is
+// indistinguishable from "that was everything".
+export { capLines } from "../core/util.js";
+
+// --- Signature formatting ---
+
+export const SIG_MAX = 90;

package/src/{review-seed.ts → seed/review-seed.ts}

@@ -1,4 +1,4 @@
-// src/review-seed.ts — `fapony review-seed [--staged|--commit <sha>|--range <a...b>|--files f1,f2,dir|--plan <PLAN.md>]`
+// src/seed/review-seed.ts — `fapony review-seed [--staged|--commit <sha>|--range <a...b>|--files f1,f2,dir|--plan <PLAN.md>]`
 //
 // Seeds a code review with the deterministic facts of the scope the agent
 // asked about: which files changed (per the exact git expression, echoed),
@@ -12,14 +12,13 @@
 // cite rule 5 "never write into a target worktree", dropped 2026-09-17 because
 // four commands broke it; being read-only was always a property of this
 // command, never of that rule. Facts only: nothing here says broken/fixed
-// — judgment lives in the reviewer and the ledger (verdict_submit), never in
+// — judgment lives in the reviewer and mem log, never in
 // this output. Deterministic: same input, same bytes, no LLM.
 //
 // Composes existing producers — buildGraph (analyze.ts) for importers/untested,
 // extractExports (map.ts) for signatures. One flag = one declared git call;
 // no magic parsing.
 
-import { execSync } from "node:child_process";
 import type { Stats } from "node:fs";
 import { existsSync, readFileSync, statSync } from "node:fs";
 import { join } from "node:path";
@@ -30,9 +29,10 @@ import {
   isTestedThroughBarrels,
   isTestFile,
   SCAN_EXTS,
-} from "./analyze.js";
-import { extractBody, extractExports } from "./map.js";
-import { assertSafe } from "./safety.js";
+} from "../analyze.js";
+import { extractBody, extractExports } from "../map.js";
+import { assertSafe } from "../safety.js";
+import { execGit, gitOk, gitValue, SeedError, SIG_MAX } from "./primitives.js";
 
 const WRAP_WIDTH = 88;
 // The changed list is the review's scope boundary, not context: a file hidden
@@ -58,7 +58,6 @@ const LOOKUP_OUTPUT_CAP = 120;
 // files is already past "this component area" into "the whole tree" — cut
 // there and say so, a folder-shaped wall is not an answer either.
 // Signature text cap per symbol (same trim as map.ts's file view).
-const SIG_MAX = 90;
 const DISCLAIMER =
   "static graph only — seed is where to enter, not what is verified";
 const USAGE =
@@ -70,52 +69,6 @@ const MAX_BODY_LINES = 80;
 const MAX_CALLER_FILES = 12;
 const MAX_CALLER_HITS = 20;
 
-export class SeedError extends Error {}
-
-// --- Git helpers (same shape as collect.ts execGitSafe) ---
-
-function execGit(
-  cmd: string,
-  cwd: string,
-): { ok: boolean; output: string; error?: string } {
-  try {
-    const output = execSync(cmd, {
-      cwd,
-      encoding: "utf-8",
-      stdio: ["pipe", "pipe", "pipe"],
-      timeout: 15_000,
-    });
-    return { ok: true, output: output.trim() };
-  } catch (e: unknown) {
-    const err = e as { stderr?: string; message?: string };
-    return {
-      ok: false,
-      output: "",
-      error: (err.stderr ?? err.message ?? "").trim(),
-    };
-  }
-}
-
-// A scope's primary git call failing must never masquerade as "nothing
-// changed" — surface it. merge-base failures are tolerated (label fallback).
-function gitOk(r: { ok: boolean; error?: string }, cmd: string): void {
-  if (!r.ok)
-    throw new SeedError(
-      `review-seed: git failed: ${cmd}\n${r.error ?? "unknown error"}`,
-    );
-}
-
-// Values interpolated into a git command line must be plain refs/paths —
-// blocks shell metacharacters before execSync ever sees them.
-const GIT_VALUE_RE = /^[A-Za-z0-9._/{}^~+-]+$/;
-
-function gitValue(kind: string, value: string): string {
-  if (!GIT_VALUE_RE.test(value)) {
-    throw new SeedError(`review-seed: invalid ${kind}: ${value}`);
-  }
-  return value;
-}
-
 // --- Scope flags: exactly one source of scope ---
 
 type Scope =
@@ -233,7 +186,7 @@ function parseScope(args: string[]): Scope {
 
 // --- Scope resolution: one flag = one declared git call ---
 
-interface FileEntry {
+export interface FileEntry {
   path: string;
   ins: number | null;
   del: number | null;

package/src/session/types.ts

@@ -1,128 +1,14 @@
-// src/session/types.ts — shared types + constants for session usage providers
-
-export interface ModelBreakdown {
-  provider: string;
-  model: string;
-  session_count: number;
-  tokens_input: number;
-  tokens_output: number;
-  tokens_reasoning: number;
-  tokens_cache_read: number;
-  tokens_cache_write: number;
-  cost: number;
-}
-
-export interface SessionDetail {
-  session_id: string;
-  model: string;
-  steps: number;
-  tools: Record<string, number>;
-}
-
-export interface ToolLatencyStat {
-  count: number;
-  avgMs: number;
-}
-
-export interface StepTimingSummary {
-  /** step-finish row count (mirrors UsageDetail.steps for SQLite providers). */
-  steps: number;
-  /** Mean per-part duration from embedded data.time (row-timestamp fallback when absent). */
-  avgStepMs: number | null;
-  /** How many durations were actually measured (vs. steps with no time signal). */
-  stepSamples: number;
-  /** Mean per-step tokens — averages only, never summed (sums overlap). */
-  avgStepInput: number | null;
-  avgStepOutput: number | null;
-  avgStepCost: number | null;
-  /** Mean tool latency grouped by tool name (from data.state.time). */
-  toolLatencyMsByType: Record<string, ToolLatencyStat>;
-  note: string;
-}
-
-export interface StaleReadFile {
-  file: string;
-  /** How many distinct sessions read this file (diversity, not just count). */
-  sessions: number;
-  /** Total Read calls across those sessions. */
-  reads: number;
-}
-
-export interface UsageDetail {
-  /** Global tool-call counts across the filtered sessions (activity signal, not quality). */
-  tool_breakdown: Record<string, number>;
-  /** Context bytes per tool — size of tool_result content blocks. */
-  bytes_by_tool?: Record<string, number>;
-  /** Total step-finish parts across the filtered sessions. */
-  steps: number;
-  /** Per-session breakdown (SQL-aggregated, never raw part rows). */
-  by_session: SessionDetail[];
-  /**
-   * Files read across 2+ sessions in this window and never edited/written —
-   * candidates for pasting into CLAUDE.md instead of re-reading every
-   * session. Top 20 by session count. Needs a wide `since` window (many
-   * sessions) before the pattern means anything — noise below that.
-   */
-  stale_reads?: StaleReadFile[];
-  /**
-   * Step-token sums are NOT reported: per-step tokens overlap (each step
-   * carries the full context window), so SUM(step tokens) >> session tokens.
-   * Verified on real data — see testSessionDetailStepTokensNotSummed.
-   */
-  note: string;
-  /** Per-step timing/token/latency signal — present only when detail:true was requested. */
-  timing?: StepTimingSummary | null;
-}
-
-export interface PassiveUsageResult {
-  total_tokens_input: number;
-  total_tokens_output: number;
-  total_tokens_reasoning: number;
-  total_tokens_cache_read: number;
-  total_tokens_cache_write: number;
-  total_cost: number;
-  session_count: number;
-  by_model: ModelBreakdown[];
-  /** Present only when detail:true was requested (additive, default absent). */
-  detail?: UsageDetail | null;
-  /** ZCode sessions, when available. Absent when ZCode DB not found. */
-  zcode?: PassiveUsageResult | null;
-  /** Claude Code sessions, when available. Absent when projects dir not found. */
-  claude_code?: PassiveUsageResult | null;
-  /**
-   * Why this read came back short, when it did. Absent on success.
-   *
-   * Zeros with no `error` mean "no sessions matched"; zeros WITH an error mean
-   * "could not read the client's log" — most often schema drift after the
-   * client updated. The two used to be indistinguishable: a renamed column
-   * made the query throw, the catch-all swallowed it, and the numbers just
-   * quietly went missing.
-   */
-  error?: string;
-}
-
-export const EMPTY_RESULT: PassiveUsageResult = {
-  total_tokens_input: 0,
-  total_tokens_output: 0,
-  total_tokens_reasoning: 0,
-  total_tokens_cache_read: 0,
-  total_tokens_cache_write: 0,
-  total_cost: 0,
-  session_count: 0,
-  by_model: [],
-};
-
-/** Common shape every client reader implements — see registry.ts. */
-export type PassiveUsageReader = (
-  worktree?: string,
-  since?: number,
-  until?: number,
-  detail?: boolean,
-  full?: boolean,
-) => PassiveUsageResult;
-
-export const STEP_TOKENS_NOTE =
-  "step tokens overlap (per-step context window) — SUM(step tokens) != session tokens; steps is a count only";
-
-export const TIMING_NOTE =
-  "timing from embedded part fields only (data.time/data.state.time/step-finish tokens) with row-timestamp fallback; averages, never raw I/O";
+// shim — moved to src/core/types.ts
+export {
+  EMPTY_RESULT,
+  type ModelBreakdown,
+  type PassiveUsageReader,
+  type PassiveUsageResult,
+  type SessionDetail,
+  STEP_TOKENS_NOTE,
+  type StaleReadFile,
+  type StepTimingSummary,
+  TIMING_NOTE,
+  type ToolLatencyStat,
+  type UsageDetail,
+} from "../core/types.js";

package/src/setup.ts

@@ -6,7 +6,7 @@ import { existsSync, statSync, writeFileSync } from "node:fs";
 import { join, resolve } from "node:path";
 import { createInterface } from "node:readline";
 import { seedConventionsFile } from "./conventions-seed.js";
-import { CONFIG_FILENAME, FAPONY_DIR } from "./db/index.js";
+import { CONFIG_FILENAME, FAPONY_DIR } from "./core/config.js";
 import { initProject } from "./init.js";
 import { isAffirmative } from "./util.js";