fapony 0.1.0

package/src/price/fetch.ts

@@ -0,0 +1,146 @@
+// src/price/fetch.ts — ดึงตารางราคา OpenRouter + cache เป็น prices.json
+//
+// ราคาเป็น cache ไม่ใช่ state: เก็บที่ ~/.config/fapony/prices.json (เคารพ
+// FAPONY_STATE_DIR) ห้ามเพิ่มตาราง SQLite (กฎ DB Schema: 2 ตารางเท่านั้น)
+// refresh เกิดตอนคนสั่ง `fapony price-scan` เท่านั้น — query ไม่ fetch เอง
+// (วินัยเดียวกับ usage-scan) offline แล้วอ่าน cache เดิม
+
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  renameSync,
+  writeFileSync,
+} from "node:fs";
+import { dirname, join } from "node:path";
+import { faponyDir } from "../db/load.js";
+import type { Config } from "../db/types.js";
+
+const PRICES_FILENAME = "prices.json";
+const MODELS_URL = "https://openrouter.ai/api/v1/models";
+
+/** เรตราย token (ดอลลาร์) — ทุกเรตมาจาก OpenRouter ตรง ๆ ไม่เดา */
+export interface ModelRates {
+  input: number;
+  output: number;
+  cacheRead: number;
+  /** null = ตารางไม่ให้มา → ใช้เรต input แทน (ดู 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);
+}
+
+/** อ่าน cache — คืน null เมื่อไม่มีไฟล์หรือพัง (caller แสดง — + hint) */
+export function loadPrices(config?: Config): PriceTable | null {
+  const p = pricesPath(config);
+  if (!existsSync(p)) return null;
+  try {
+    const raw = JSON.parse(readFileSync(p, "utf-8")) as Partial<PriceTable>;
+    if (!raw || typeof raw.models !== "object" || !raw.models) return null;
+    return {
+      fetched_at: typeof raw.fetched_at === "string" ? raw.fetched_at : "",
+      models: raw.models,
+    };
+  } catch {
+    return null;
+  }
+}
+
+/** เขียนแบบ atomic (tmp + rename) สร้าง state dir เมื่อยังไม่มี */
+export function writePrices(table: PriceTable, config?: Config): void {
+  const p = pricesPath(config);
+  mkdirSync(dirname(p), { recursive: true });
+  const tmp = `${p}.tmp`;
+  writeFileSync(tmp, JSON.stringify(table, null, 2), "utf-8");
+  renameSync(tmp, p);
+}
+
+function toRate(v: unknown): number | null {
+  if (typeof v === "number") return Number.isFinite(v) ? v : null;
+  if (typeof v === "string" && v.trim() !== "") {
+    const n = Number(v);
+    return Number.isFinite(n) ? n : null;
+  }
+  return null;
+}
+
+/**
+ * แปลง response ดิบของ OpenRouter เป็นตารางเรต (pure — เทสต์ได้โดยไม่ยิงเน็ต)
+ *
+ * ฟิลด์จริง (ยืนยัน 2026-09-14, 445 models): pricing.prompt / .completion /
+ * .input_cache_read / .input_cache_write (optional) / .input_cache_write_1h
+ * (เรต 1h TTL ของบางรุ่น — ใช้เรต 5m มาตรฐานพอ เพราะ log ไม่บอก TTL)
+ * เมิน pricing.web_search / pricing.overrides (tier ตาม min_prompt_tokens /
+ * utc_days — ใช้ base rate แล้วประกาศข้อจำกัด) · id ขึ้นต้น ~ (alias) ตัดทิ้ง
+ * id ลงท้าย :free / :batch เก็บตามนั้น (เป็นแถวราคาของมันเอง)
+ */
+export function parsePricesResponse(json: unknown): Record<string, ModelRates> {
+  const out: Record<string, ModelRates> = {};
+  const data = (json as { data?: unknown })?.data;
+  if (!Array.isArray(data)) return out;
+  for (const m of data) {
+    const rec = m as { id?: unknown; pricing?: unknown };
+    if (typeof rec.id !== "string" || !rec.id) continue;
+    const pricing = rec.pricing as Record<string, unknown> | undefined;
+    if (!pricing || typeof pricing !== "object") continue;
+    const input = toRate(pricing.prompt);
+    const output = toRate(pricing.completion);
+    if (input === null || output === null) continue;
+    const cacheRead = toRate(pricing.input_cache_read) ?? 0;
+    const cacheWrite = toRate(pricing.input_cache_write);
+    const id = rec.id.startsWith("~") ? rec.id.slice(1) : rec.id;
+    out[id] = { input, output, cacheRead, cacheWrite };
+  }
+  return out;
+}
+
+/**
+ * รวมตารางใหม่เข้ากับ cache เดิม — merge ไม่ replace: id ที่หายไปจาก
+ * response รอบนี้ (รุ่นเก่าหลุดตาราง) ต้องยังคิดราคาได้ด้วยเรตเดิม
+ */
+export function mergePriceTables(
+  old: PriceTable | null,
+  fresh: Record<string, ModelRates>,
+): PriceTable {
+  return {
+    fetched_at: new Date().toISOString(),
+    models: { ...(old?.models ?? {}), ...fresh },
+  };
+}
+
+/** ดึงตารางจาก OpenRouter (public, ไม่ต้อง auth) — fetcher แทรกได้ไว้เทสต์ */
+export async function fetchPriceTable(
+  fetcher: typeof fetch = fetch,
+): Promise<Record<string, ModelRates>> {
+  const res = await fetcher(MODELS_URL);
+  if (!res.ok) throw new Error(`OpenRouter ${res.status}`);
+  return parsePricesResponse(await res.json());
+}
+
+export async function cmdPriceScan(rawArgs: string[]): Promise<void> {
+  if (rawArgs.length > 0) {
+    console.error("usage: fapony price-scan");
+    process.exit(1);
+  }
+  let fresh: Record<string, ModelRates>;
+  try {
+    fresh = await fetchPriceTable();
+  } catch (err) {
+    console.error(
+      `fapony price-scan: fetch failed (${String(err)}) — cache เดิมยังอยู่ ใช้ราคาที่มีได้`,
+    );
+    process.exit(1);
+  }
+  const merged = mergePriceTables(loadPrices(), fresh);
+  writePrices(merged);
+  console.log(
+    `prices: ${Object.keys(fresh).length} models fetched, ${Object.keys(merged.models).length} cached → ${pricesPath()}`,
+  );
+}

package/src/price/index.ts

@@ -0,0 +1,8 @@
+// src/price/index.ts — barrel re-export
+
+export { cmdPriceScan, loadPrices, type PriceTable } from "./fetch.js";
+export {
+  type ImputedModel,
+  type ImputeSummary,
+  imputeResult,
+} from "./resolve.js";

package/src/price/resolve.ts

@@ -0,0 +1,213 @@
+// src/price/resolve.ts — normalize model id + คิด list-price equivalent
+//
+// กฎเหล็ก: map ไม่ได้ต้องเป็น unpriced ห้ามตีเป็น 0 เงียบ ๆ (failure mode หลัก
+// ของฟีเจอร์นี้) · free มีแต่ของที่ราคา 0 จริง (local / แถว :free ในตาราง)
+
+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;
+}
+
+/** prefix ของ client ที่แปะหน้าทุก model id — ตัดทิ้งแล้ว lookup ใหม่ */
+const CLIENT_PREFIXES = ["openrouter/", "opencode-go/", "opencode/"];
+
+/** tier ต่อท้ายของ OpenRouter — :free คือ endpoint ฟรีจริง :batch คือส่วนลด */
+function stripTier(id: string): string {
+  return id.endsWith(":free") || id.endsWith(":batch")
+    ? id.slice(0, id.lastIndexOf(":"))
+    : id;
+}
+
+/**
+ * รายชื่อ candidate id ตามลำดับความเฉพาะ: ตรงตัวก่อน กว้างทีหลัง
+ * (ตรงตัวชนก่อนเสมอ — bare slug แมตช์กว้างสุดอยู่ท้าย)
+ */
+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 ต่อ -free ท้าย slug ของรุ่นฟรี (deepseek-v4-flash-free)
+  if (rest.endsWith("-free")) out.push(rest.slice(0, -"-free".length));
+  return out;
+}
+
+/**
+ * หาเรตให้ model หนึ่งตัว — คืน null เฉพาะของ local เท่านั้นที่ข้ามตาราง
+ * (local ไม่เคยมีราคาตั้งแต่แรก ไม่ใช่ "หาไม่เจอ")
+ */
+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 };
+  // ลงท้าย :free หรือ -free = เรียกผ่าน free endpoint / รุ่นฟรีของ client มา
+  // ราคาจริงคือ 0 (ไม่ใช่ list price) ไม่ว่าจะ map OpenRouter ได้หรือไม่
+  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) {
+      // แถวราคา 0 ทั้งแถว (:free / รุ่นฟรี) = free จริง ไม่ใช่ unpriced
+      if (
+        rates.input === 0 &&
+        rates.output === 0 &&
+        rates.cacheRead === 0 &&
+        (rates.cacheWrite ?? 0) === 0
+      )
+        return { status: "free", rates };
+      return { status: "priced", rates };
+    }
+  }
+  // zcode เก็บแค่ slug ไม่มี vendor (GLM-5.3-Flash) — เทียบส่วนหลัง / ตรงตัว
+  // แบบ case-insensitive (exact ไม่ใช่ fuzzy: ยาวเท่ากันทั้งสตริง)
+  // ฝั่งตารางตัด tier (:free/:batch) ก่อนเทียบ — slug เปลือยจะได้ชนแถว :free
+  // ที่ราคา 0 จริง (เช่น ling-3.0-flash-fin) กลายเป็น free ไม่ใช่ 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: แยกเรต input / cache-read / cache-write — ห้ามใช้เรตเดียวรวบ
+ *
+ * reasoning ไม่คูณแยก: ของ Anthropic-family thinking รวมอยู่ใน output อยู่แล้ว
+ * (reader แยกเก็บไว้ดูเฉย ๆ) คูณแยก = double count · cache_write ไม่มีในตาราง
+ * → fallback เรต input (เขียน cache แพงกว่า/เท่าอ่านสด ไม่มีทางถูกกว่า)
+ */
+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;
+  /** ดอลลาร์ list-price — 0 เมื่อ free/unpriced (ดู status อย่าอ่านเลขอย่างเดียว) */
+  imputed_cost: number;
+}
+
+export interface ImputeSummary {
+  total_imputed: number;
+  priced_sessions: number;
+  free_sessions: number;
+  unpriced_sessions: number;
+  unpriced_tokens: number;
+  by_model: ImputedModel[];
+}
+
+/**
+ * ตีราคาทั้ง PassiveUsageResult — ใช้กับผลสด (stats/usage) หรือแถว cache
+ * (usage-web) ก็ได้เพราะรับแค่ token ต่อ 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,
+  };
+}

package/src/report/cli.ts

@@ -0,0 +1,92 @@
+// src/report/cli.ts — CLI commands for fapony report / report-web
+
+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 { getStatsData } from "../stats/data.js";
+import { renderReportHtml } from "./render.js";
+
+export function cmdReport(args: string[]): void {
+  const runId = parseInt(args[0], 10);
+  if (!runId || Number.isNaN(runId)) {
+    console.error("usage: fapony report <run-id>");
+    process.exit(1);
+  }
+
+  const result = toolVerificationReport({ run_id: runId });
+  if (result.isError) {
+    const data = parseToolResult(result) as { error?: unknown };
+    console.error(
+      `fapony report: ${typeof data.error === "string" ? data.error : "unknown error"}`,
+    );
+    process.exit(1);
+  }
+  console.log(result.content[0].text);
+}
+
+/**
+ * True when `abs` sits in a git repo and is NOT gitignored — writing the report
+ * there means the generated HTML turns up in `git status` and rides along in
+ * someone's next commit.
+ *
+ * Replaces the rule-5 refusal (dropped 2026-09-17). That check blocked any path
+ * inside a *configured* worktree, which got it wrong three ways: it refused
+ * paths the user had typed themselves, it missed every repo not listed in the
+ * config, and it fired even when the path was already gitignored. The hazard was
+ * never "inside a worktree" — it is "would be committed".
+ */
+export function wouldBeCommitted(abs: string): boolean {
+  // check-ignore exits 0 = ignored, 1 = not ignored, 128 = not a repo.
+  // A missing git, or a dir that does not exist, leaves status null — stay quiet.
+  const probe = spawnSync("git", ["check-ignore", "-q", abs], {
+    cwd: dirname(abs),
+    stdio: "ignore",
+  });
+  return probe.status === 1;
+}
+
+export function cmdReportWeb(args: string[]): void {
+  const config = loadConfig();
+  // Accept optional --worktree <path> to scope the report to one project.
+  const wtIdx = args.indexOf("--worktree");
+  const worktree =
+    wtIdx !== -1 && args[wtIdx + 1] ? args[wtIdx + 1] : undefined;
+  // --force overrides the rule-5c refusal when the path would be committed.
+  const force = args.includes("--force");
+  // First positional arg is still the output file (legacy).
+  const outFile =
+    wtIdx !== -1
+      ? args.filter((_a, i) => i !== wtIdx && i !== wtIdx + 1)[0]
+      : args[0];
+
+  // Rule 5c: refuse when the output would end up in git status. The user
+  // typed the path — that makes it a commit hazard, not a prohibition case.
+  // --force overrides this (for scripts that accept the risk).
+  if (outFile && wouldBeCommitted(resolve(outFile))) {
+    if (!force) {
+      console.error(
+        `fapony report-web: ${outFile} is in a git repo and not gitignored — the generated HTML would show up in git status. Add it to .gitignore, write outside the repo, or pass --force to override.`,
+      );
+      process.exit(1);
+    }
+    console.error(
+      `fapony report-web: ${outFile} is in a git repo and not gitignored — --force written anyway.`,
+    );
+  }
+
+  const uw = config.usageWeb ?? {};
+
+  const ownerName = uw.ownerName?.trim() ? uw.ownerName.trim() : undefined;
+  const stats = getStatsData(worktree);
+  const html = renderReportHtml(stats, new Date().toISOString(), ownerName);
+
+  if (outFile) {
+    writeFileSync(outFile, html, "utf-8");
+    console.log(`report written to ${outFile}`);
+  } else {
+    console.log(html);
+  }
+}

package/src/report/format.ts

@@ -0,0 +1,37 @@
+// src/report/format.ts — pure formatting helpers for the HTML report
+
+export const MIN_SAMPLE_SIZE = 5;
+
+export function fmtRate(r: number): string {
+  return `${(r * 100).toFixed(0)}%`;
+}
+
+export function fmtMinutes(m: number): string {
+  if (m < 1) return "<1m";
+  return `${m.toFixed(0)}m`;
+}
+
+export function insufficientData(total: number, label: string): string {
+  if (total < MIN_SAMPLE_SIZE) {
+    return `<div class="insufficient">⚠ Insufficient data: ${total} ${label} (need ≥${MIN_SAMPLE_SIZE} for meaningful comparison)</div>`;
+  }
+  return "";
+}
+
+/** Freshness label from an ISO-like timestamp. */
+function freshness(createdAt: string): string {
+  const now = Date.now();
+  const then = new Date(`${createdAt.replace(" ", "T")}Z`).getTime();
+  const days = Math.floor((now - then) / 86400000);
+  if (days === 0) return "today";
+  if (days === 1) return "yesterday";
+  if (days < 7) return `${days}d ago`;
+  if (days < 30) return `${Math.floor(days / 7)}w ago`;
+  return `${Math.floor(days / 30)}mo ago`;
+}
+
+/** Freshness label from a StatsData.latestRunAt string. */
+export function latestRunFreshness(latestRunAt: string): string {
+  if (!latestRunAt) return "never";
+  return freshness(latestRunAt);
+}

package/src/report/index.ts

@@ -0,0 +1,4 @@
+// src/report/index.ts — barrel re-export
+
+export { cmdReport, cmdReportWeb } from "./cli.js";
+export { renderReportHtml } from "./render.js";