fapony 0.2.1 → 0.3.3

package/src/math.ts

@@ -1,13 +0,0 @@
-// src/math.ts — pure numeric helpers shared across modules
-
-/** Minutes between two ISO-like timestamps (space separator, UTC assumed). */
-export function minutesBetween(a: string, b: string): number {
-  const t0 = new Date(`${a.replace(" ", "T")}Z`).getTime();
-  const t1 = new Date(`${b.replace(" ", "T")}Z`).getTime();
-  return (t1 - t0) / 60000;
-}
-
-/** Arithmetic mean of a numeric array. 0 for empty arrays. */
-export function avg(xs: number[]): number {
-  return xs.length ? xs.reduce((s, x) => s + x, 0) / xs.length : 0;
-}

package/src/mcp/tools/usage.ts

@@ -1,211 +0,0 @@
-// src/mcp/tools/usage.ts — fapony_usage tool
-
-import {
-  type ImputeSummary,
-  imputeResult,
-  loadPrices,
-  type PriceTable,
-} from "../../price/index.js";
-import {
-  CLIENTS,
-  mergeBytesByTool,
-  type PassiveUsageResult,
-} from "../../session/index.js";
-import { jsonResult, type ToolResult } from "../types.js";
-
-/** list-price summary per client — additive, leaves existing lines untouched */
-function imputationOf(
-  result: PassiveUsageResult,
-  prices: PriceTable | null,
-): (ImputeSummary & { prices_fetched_at: string }) | null {
-  if (result.session_count === 0 || !prices) return null;
-  return {
-    ...imputeResult(result, prices),
-    prices_fetched_at: prices.fetched_at,
-  };
-}
-
-function imputedTextLines(
-  label: string,
-  result: PassiveUsageResult,
-  prices: PriceTable | null,
-): string[] {
-  if (result.session_count === 0) return [];
-  const imp = imputationOf(result, prices);
-  if (!imp)
-    return [`  ${label}list-price equivalent: — (run \`fapony price-scan\`)`];
-  const parts = [
-    `~$${imp.total_imputed.toFixed(4)} over ${imp.priced_sessions} priced sessions`,
-  ];
-  if (imp.free_sessions > 0) parts.push(`${imp.free_sessions} free`);
-  if (imp.unpriced_sessions > 0)
-    parts.push(
-      `unpriced: ${imp.unpriced_sessions} sessions / ${imp.unpriced_tokens.toLocaleString()} tokens`,
-    );
-  return [`  ${label}list-price equivalent: ${parts.join(" · ")}`];
-}
-
-/** list price per model appended to the model name — only rows where the client records no cost */
-function imputedSuffix(
-  provider: string,
-  model: string,
-  imp: (ImputeSummary & { prices_fetched_at: string }) | null,
-): string {
-  if (!imp) return "";
-  const m = imp.by_model.find(
-    (b) => b.provider === provider && b.model === model,
-  );
-  if (m && m.status === "priced")
-    return ` (~$${m.imputed_cost.toFixed(4)} list-price)`;
-  return "";
-}
-
-export function toolPassiveUsage(args: Record<string, unknown>): ToolResult {
-  const worktree =
-    typeof args.worktree === "string" ? args.worktree : undefined;
-  const since = typeof args.since === "number" ? args.since : undefined;
-  const until = typeof args.until === "number" ? args.until : undefined;
-  const detail = args.detail === true;
-
-  const primary = CLIENTS.find((c) => c.primary)!;
-  const others = CLIENTS.filter((c) => !c.primary);
-
-  const data: PassiveUsageResult = primary.read(worktree, since, until, detail);
-
-  // Every non-primary client is always fetched when its own log exists.
-  const otherResults = others.map((client) => ({
-    client,
-    result: client.read(worktree, since, until, detail),
-  }));
-
-  // list prices from the cache only — read once per call, not per section
-  const prices = loadPrices();
-
-  if (args.json === true) {
-    const json: Record<string, unknown> = {
-      ...data,
-      imputation: imputationOf(data, prices),
-    };
-    for (const { client, result } of otherResults) {
-      json[client.key] =
-        result.session_count > 0
-          ? { ...result, imputation: imputationOf(result, prices) }
-          : null;
-    }
-    return jsonResult(json);
-  }
-
-  const lines: string[] = [];
-  lines.push("Passive Usage Report");
-  lines.push("====================");
-  lines.push(`Sessions: ${data.session_count}`);
-  lines.push(`Total Input Tokens: ${data.total_tokens_input.toLocaleString()}`);
-  lines.push(
-    `Total Output Tokens: ${data.total_tokens_output.toLocaleString()}`,
-  );
-  lines.push(
-    `Total Reasoning Tokens: ${data.total_tokens_reasoning.toLocaleString()}`,
-  );
-  lines.push(`Cache Read: ${data.total_tokens_cache_read.toLocaleString()}`);
-  lines.push(`Cache Write: ${data.total_tokens_cache_write.toLocaleString()}`);
-  lines.push(`Total Cost: $${data.total_cost.toFixed(4)}`);
-  lines.push(...imputedTextLines("", data, prices));
-
-  if (data.by_model.length > 0) {
-    lines.push("");
-    lines.push("By Model:");
-    lines.push("--------");
-    for (const m of data.by_model) {
-      const prefix = m.provider ? `${m.provider}/` : "";
-      lines.push(
-        `  ${prefix}${m.model}: ${m.session_count} sessions, ` +
-          `${m.tokens_input.toLocaleString()} in / ${m.tokens_output.toLocaleString()} out, ` +
-          `$${m.cost.toFixed(4)}`,
-      );
-    }
-  }
-
-  // detail:true is opt-in — default text above is byte-identical to before.
-  if (detail && data.detail) {
-    lines.push("");
-    lines.push("Detail (tool activity — signal, not quality):");
-    lines.push(`  steps: ${data.detail.steps.toLocaleString()}`);
-    const tools = Object.entries(data.detail.tool_breakdown).sort(
-      (a, b) => b[1] - a[1],
-    );
-    if (tools.length > 0) {
-      lines.push("  by tool:");
-      for (const [tool, count] of tools.slice(0, 20)) {
-        lines.push(`    ${tool}: ${count.toLocaleString()}`);
-      }
-      if (tools.length > 20) {
-        lines.push(`    ... +${tools.length - 20} more (see json:true)`);
-      }
-    }
-    // Context bytes by tool — proportion of context window consumed per tool.
-    // Bytes are a proxy for tokens; shown as % of total, never as "tokens".
-    // Merged across all clients: OpenCode/ZCode (state.output), Claude Code
-    // and Codex (tool_result) each populate bytes_by_tool, so reading the
-    // top-level (opencode) detail alone would miss the other clients.
-    const bytes = mergeBytesByTool(
-      data.detail,
-      ...otherResults.map((r) => r.result.detail),
-    );
-    if (bytes) {
-      const entries = Object.entries(bytes).sort((a, b) => b[1] - a[1]);
-      const total = entries.reduce((s, e) => s + e[1], 0);
-      if (entries.length > 0 && total > 0) {
-        lines.push("  context bytes by tool (% of total):");
-        for (const [tool, b] of entries.slice(0, 10)) {
-          const pct = ((b / total) * 100).toFixed(1);
-          lines.push(`    ${tool}: ${pct}%`);
-        }
-        if (entries.length > 10) {
-          lines.push(`    ... +${entries.length - 10} more (see json:true)`);
-        }
-      }
-    }
-    lines.push(`  sessions with activity: ${data.detail.by_session.length}`);
-    const top = data.detail.by_session.slice(0, 10);
-    for (const s of top) {
-      const topTool = Object.entries(s.tools).sort((a, b) => b[1] - a[1])[0];
-      lines.push(
-        `    ${s.session_id}: ${s.steps} steps` +
-          (topTool ? `, top tool ${topTool[0]}×${topTool[1]}` : ""),
-      );
-    }
-    if (data.detail.by_session.length > 10) {
-      lines.push(
-        `    ... +${data.detail.by_session.length - 10} more (see json:true)`,
-      );
-    }
-  }
-
-  // One text section per non-primary client — same shape for every client,
-  // new ones need no new formatting code, only a registry.ts entry.
-  for (const { client, result } of otherResults) {
-    if (result.session_count === 0) continue;
-    const imp = imputationOf(result, prices);
-    const label = client.reportLabel ?? client.key;
-    lines.push("");
-    lines.push(`${label} usage:`);
-    lines.push(
-      `  total: ${result.total_tokens_input.toLocaleString()} in / ${result.total_tokens_output.toLocaleString()} out / ${result.total_tokens_reasoning.toLocaleString()} reasoning tokens over ${result.session_count} sessions`,
-    );
-    lines.push(
-      `  cache: ${result.total_tokens_cache_read.toLocaleString()} read / ${result.total_tokens_cache_write.toLocaleString()} write`,
-    );
-    if (result.by_model.length > 0) {
-      lines.push("  by model:");
-      for (const m of result.by_model) {
-        const prefix = m.provider ? `${m.provider}/` : "";
-        lines.push(
-          `    ${prefix}${m.model}: ${m.tokens_input.toLocaleString()} in / ${m.tokens_output.toLocaleString()} out (cache r/w: ${(m.tokens_cache_read ?? 0).toLocaleString()} / ${(m.tokens_cache_write ?? 0).toLocaleString()})${imputedSuffix(m.provider, m.model, imp)}`,
-        );
-      }
-    }
-    lines.push(...imputedTextLines("", result, prices));
-  }
-
-  return { content: [{ type: "text", text: lines.join("\n") }] };
-}

package/src/mcp/tools/verdict.ts

@@ -1,161 +0,0 @@
-// src/mcp/tools/verdict.ts — verdict_submit tool
-
-import {
-  findOpenRun,
-  findOpenRunWithNullPlan,
-  getRun,
-  newRun,
-  openDb,
-  patchLastGateEvent,
-} from "../../db/index.js";
-import { gateOnce } from "../../gate.js";
-import { VERDICT_GRADES, type VerdictGrade } from "../../parse.js";
-import {
-  errorResult,
-  jsonResult,
-  REASON_CODES,
-  REGIME_CODES,
-  type ReasonCode,
-  type RegimeCode,
-  type ToolResult,
-} from "../types.js";
-import { resolveWorktreeArg } from "../worktree.js";
-
-// --- Tool implementation ---
-
-export function toolVerdictSubmit(args: Record<string, unknown>): ToolResult {
-  const {
-    run_id,
-    verdict,
-    reason_code,
-    regime,
-    note,
-    worktree,
-    plan,
-    session_id,
-    files,
-  } = args;
-
-  if (typeof verdict !== "string" || !VERDICT_GRADES.has(verdict)) {
-    return errorResult(
-      `verdict must be one of: ${[...VERDICT_GRADES].join(", ")}`,
-    );
-  }
-  const grade = verdict as VerdictGrade;
-  if (!REASON_CODES.includes(reason_code as ReasonCode)) {
-    return errorResult(
-      `reason_code must be one of: ${REASON_CODES.join(", ")}`,
-    );
-  }
-  if (reason_code === "other" && (!note || typeof note !== "string")) {
-    return errorResult("reason_code 'other' requires a note");
-  }
-  if (!REGIME_CODES.includes(regime as RegimeCode)) {
-    return errorResult(`regime must be one of: ${REGIME_CODES.join(", ")}`);
-  }
-  const regimeCode = regime as RegimeCode;
-
-  const db = openDb();
-
-  // Resolve or create run_id
-  let resolvedRunId: number;
-  if (typeof run_id === "number" && Number.isInteger(run_id)) {
-    const run = getRun(db, run_id);
-    if (!run) {
-      return jsonResult({ stored: false, error: "run not found" });
-    }
-    resolvedRunId = run_id;
-  } else {
-    // Bind to the latest still-open run for the same worktree+plan so a
-    // round-2+ verdict lands on the original row (round keeps counting and
-    // review.maxRounds can actually trigger). Only when no open run matches
-    // is a fresh row created. plan=null always opens a new run (no guess).
-    // Free-text plans are normalized (trim+lowercase) so "Fix Login" and
-    // "fix login" bind to the same run. When no exact match exists, falls
-    // back to any open run with plan=null (the "no PLAN file" flow).
-    const resolvedWorktree =
-      typeof worktree === "string" && worktree
-        ? resolveWorktreeArg(worktree)
-        : "mcp-external";
-    const resolvedPlan =
-      typeof plan === "string" && plan ? plan.trim().toLowerCase() : null;
-    // BEGIN IMMEDIATE makes the find-then-create below atomic across
-    // concurrent MCP processes: without it, two agents closing the same
-    // worktree+plan at once can both see "no open run" and each insert a
-    // row. The write lock taken here blocks (busy_timeout, not throws) the
-    // second caller until the first commits, so it re-reads and finds the
-    // row already there instead of duplicating it.
-    db.run("BEGIN IMMEDIATE");
-    try {
-      let open = resolvedPlan
-        ? findOpenRun(db, resolvedWorktree, resolvedPlan)
-        : null;
-      // Fallback: if no exact match and plan is non-null, try any open run with
-      // plan=null.  This lets a verdict with free-text intent bind to a run that
-      // was created without a plan (the common "no PLAN file" flow).
-      if (!open && resolvedPlan) {
-        open = findOpenRunWithNullPlan(db, resolvedWorktree);
-      }
-      if (open) {
-        resolvedRunId = open.id;
-      } else {
-        // worktree/plan let callers (e.g. move-to-done) attribute the verdict
-        // so byReasonCode/bestPassing aggregate correctly instead of collapsing
-        // into "mcp-external".
-        resolvedRunId = newRun(db, resolvedWorktree, resolvedPlan, null, "mcp");
-      }
-      db.run("COMMIT");
-    } catch (e) {
-      db.run("ROLLBACK");
-      throw e;
-    }
-  }
-
-  // Normalize files: must be a non-empty array of strings.
-  const resolvedFiles =
-    Array.isArray(files) && files.length > 0
-      ? files.filter((f): f is string => typeof f === "string" && f.length > 0)
-      : undefined;
-
-  // Route through gateOnce for consistent status/round/memory handling.
-  const mcpNote =
-    typeof note === "string" && note
-      ? `[${reason_code}] ${note}`
-      : `[${reason_code}]`;
-  const result = gateOnce(resolvedRunId, grade, mcpNote, resolvedFiles);
-
-  if (result.error) {
-    return jsonResult({
-      stored: false,
-      error: result.error,
-      run_id: resolvedRunId,
-      status: result.status,
-      round: result.round,
-    });
-  }
-
-  // Patch the gate event with MCP-specific fields (reason_code, source).
-  // session_id lets gates.ts resolve model from client session logs when the
-  // window has no spawn events (the old execute→review loop that wrote spawns
-  // is gone). Optional — agents that can't expose it just omit it.
-  const patch: Record<string, unknown> = {
-    reason_code,
-    regime: regimeCode,
-    source: "mcp",
-  };
-  if (typeof session_id === "string" && session_id) {
-    patch.session_id = session_id;
-  }
-  patchLastGateEvent(db, resolvedRunId, patch);
-
-  return jsonResult({
-    stored: true,
-    run_id: resolvedRunId,
-    verdict: grade,
-    reason_code,
-    regime: regimeCode,
-    status: result.status,
-    round: result.round,
-    ...(resolvedFiles ? { files: resolvedFiles } : {}),
-  });
-}