@hasna/economy 0.1.1 → 0.2.1

package/dist/cli/index.js

@@ -639,6 +639,115 @@ var init_codex = __esm(() => {
   CODEX_CONFIG_PATH = join3(homedir3(), ".codex", "config.toml");
 });
 
+// src/lib/config.ts
+var exports_config = {};
+__export(exports_config, {
+  setConfigValue: () => setConfigValue,
+  saveConfig: () => saveConfig,
+  loadConfig: () => loadConfig,
+  getConfigValue: () => getConfigValue
+});
+import { existsSync as existsSync4, readFileSync as readFileSync3, writeFileSync, mkdirSync as mkdirSync2 } from "fs";
+import { homedir as homedir4 } from "os";
+import { join as join4 } from "path";
+function loadConfig() {
+  try {
+    if (existsSync4(CONFIG_PATH)) {
+      const raw = readFileSync3(CONFIG_PATH, "utf-8");
+      return { ...DEFAULTS, ...JSON.parse(raw) };
+    }
+  } catch {}
+  return { ...DEFAULTS };
+}
+function saveConfig(config) {
+  const dir = CONFIG_PATH.substring(0, CONFIG_PATH.lastIndexOf("/"));
+  if (!existsSync4(dir))
+    mkdirSync2(dir, { recursive: true });
+  writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2) + `
+`);
+}
+function getConfigValue(key) {
+  const config = loadConfig();
+  return config[key] ?? null;
+}
+function setConfigValue(key, value) {
+  const config = loadConfig();
+  let parsed = value;
+  if (value === "true")
+    parsed = true;
+  else if (value === "false")
+    parsed = false;
+  else if (value === "null")
+    parsed = null;
+  else if (!isNaN(Number(value)))
+    parsed = Number(value);
+  else if (value.startsWith("[")) {
+    try {
+      parsed = JSON.parse(value);
+    } catch {}
+  }
+  config[key] = parsed;
+  saveConfig(config);
+}
+var CONFIG_PATH, DEFAULTS;
+var init_config = __esm(() => {
+  CONFIG_PATH = join4(homedir4(), ".economy", "config.json");
+  DEFAULTS = {
+    port: 3456,
+    "default-period": "today",
+    "auto-sync": true,
+    "sync-interval": 30,
+    "alert-thresholds": [5, 10, 25, 50, 100],
+    "webhook-url": null
+  };
+});
+
+// src/lib/webhooks.ts
+var exports_webhooks = {};
+__export(exports_webhooks, {
+  checkAndFireWebhooks: () => checkAndFireWebhooks
+});
+async function checkAndFireWebhooks(db) {
+  const config = loadConfig();
+  const url = config["webhook-url"];
+  if (!url)
+    return;
+  const statuses = getBudgetStatuses(db);
+  for (const b of statuses) {
+    if (!b.is_over_alert)
+      continue;
+    const key = `webhook-budget-${b.id}-${b.period}`;
+    const lastFired = getIngestState(db, "webhook", key);
+    const pctBucket = Math.floor(b.percent_used / 10) * 10;
+    if (lastFired === String(pctBucket))
+      continue;
+    await fireWebhook(url, {
+      event: "budget_alert",
+      budget_id: b.id,
+      project: b.project_path ?? "global",
+      period: b.period,
+      spend: b.current_spend_usd,
+      limit: b.limit_usd,
+      percent: Math.round(b.percent_used * 10) / 10
+    });
+    setIngestState(db, "webhook", key, String(pctBucket));
+  }
+}
+async function fireWebhook(url, payload) {
+  try {
+    await fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(payload),
+      signal: AbortSignal.timeout(5000)
+    });
+  } catch {}
+}
+var init_webhooks = __esm(() => {
+  init_config();
+  init_database();
+});
+
 // src/cli/commands/watch.ts
 var exports_watch = {};
 __export(exports_watch, {
@@ -867,15 +976,15 @@ function startServer(port = 3456) {
         return apiHandler(req);
       }
       try {
-        const { existsSync: existsSync4 } = await import("fs");
-        if (existsSync4(dashboardDir)) {
+        const { existsSync: existsSync5 } = await import("fs");
+        if (existsSync5(dashboardDir)) {
           let filePath = url.pathname === "/" ? "/index.html" : url.pathname;
           const fullPath = dashboardDir + filePath;
-          if (existsSync4(fullPath)) {
+          if (existsSync5(fullPath)) {
             return new Response(Bun.file(fullPath));
           }
           const indexPath = dashboardDir + "/index.html";
-          if (existsSync4(indexPath)) {
+          if (existsSync5(indexPath)) {
             return new Response(Bun.file(indexPath));
           }
         }
@@ -917,7 +1026,22 @@ import chalk2 from "chalk";
 import { randomUUID as randomUUID2 } from "crypto";
 import { execSync } from "child_process";
 var program = new Command;
-program.name("economy").description("AI coding cost tracker \u2014 Claude Code, Codex, and Gemini").version("0.1.0");
+program.name("economy").description("AI coding cost tracker \u2014 Claude Code, Codex, and Gemini").version("0.1.1");
+async function autoSync() {
+  const db = openDatabase();
+  ensurePricingSeeded(db);
+  await ingestClaude(db);
+  await ingestCodex(db);
+}
+function sparkline(values) {
+  const chars = "\u2581\u2582\u2583\u2584\u2585\u2586\u2587\u2588";
+  if (values.length === 0)
+    return "";
+  const max = Math.max(...values);
+  if (max === 0)
+    return chars[0].repeat(values.length);
+  return values.map((v) => chars[Math.min(Math.round(v / max * 7), 7)]).join("");
+}
 function fmt2(usd) {
   let formatted;
   if (usd >= 0.01) {
@@ -970,9 +1094,47 @@ function printSummary(label, period) {
   ]);
   console.log();
 }
-program.command("sync").description("Ingest cost data from Claude Code and Codex").option("--claude", "Only ingest Claude Code telemetry").option("--codex", "Only ingest Codex sessions").option("-v, --verbose", "Verbose output").action(async (opts) => {
+program.action(async () => {
+  await autoSync();
+  const db = openDatabase();
+  const t = querySummary(db, "today");
+  const w = querySummary(db, "week");
+  const m = querySummary(db, "month");
+  const projects = queryProjectBreakdown(db).slice(0, 3);
+  const daily = queryDailyBreakdown(db, 14).reduce((acc, d) => {
+    acc[d.date] = (acc[d.date] ?? 0) + d.cost_usd;
+    return acc;
+  }, {});
+  const dailyValues = Object.values(daily);
+  console.log();
+  console.log(chalk2.bold.cyan("  Economy"));
+  console.log();
+  printTable(["Period", "Cost", "Sessions", "Requests", "Tokens"], [
+    ["Today", fmt2(t.total_usd), fmtCount(t.sessions), fmtCount(t.requests), fmtTokens(t.tokens)],
+    ["This Week", fmt2(w.total_usd), fmtCount(w.sessions), fmtCount(w.requests), fmtTokens(w.tokens)],
+    ["This Month", fmt2(m.total_usd), fmtCount(m.sessions), fmtCount(m.requests), fmtTokens(m.tokens)]
+  ]);
+  if (dailyValues.length > 0) {
+    console.log(`
+  ${chalk2.dim("14-day trend:")} ${sparkline(dailyValues)}`);
+  }
+  if (projects.length > 0) {
+    console.log(`
+  ${chalk2.dim("Top projects:")}`);
+    for (const p of projects) {
+      console.log(`    ${chalk2.white(p.project_name.padEnd(25))} ${fmt2(p.cost_usd)}`);
+    }
+  }
+  console.log();
+});
+program.command("sync").description("Ingest cost data from Claude Code and Codex").option("--claude", "Only ingest Claude Code telemetry").option("--codex", "Only ingest Codex sessions").option("-v, --verbose", "Verbose output").option("--force", "Force re-process all files (ignore mtime cache)").action(async (opts) => {
   const db = openDatabase();
   ensurePricingSeeded(db);
+  if (opts.force) {
+    db.exec(`DELETE FROM ingest_state WHERE source = 'claude'`);
+    if (opts.verbose)
+      console.log(chalk2.dim("Cleared ingest cache"));
+  }
   const doClaude = opts.claude || !opts.claude && !opts.codex;
   const doCodex = opts.codex || !opts.claude && !opts.codex;
   if (doClaude) {
@@ -985,13 +1147,27 @@ program.command("sync").description("Ingest cost data from Claude Code and Codex
     const r = await ingestCodex(db, opts.verbose);
     console.log(chalk2.green(`\u2713 ${r.sessions} sessions`));
   }
+  try {
+    const { checkAndFireWebhooks: checkAndFireWebhooks2 } = await Promise.resolve().then(() => (init_webhooks(), exports_webhooks));
+    await checkAndFireWebhooks2(db);
+  } catch {}
   console.log(chalk2.bold.green(`
 \u2713 Sync complete`));
 });
-program.command("today").description("Cost summary for today").action(() => printSummary("Today", "today"));
-program.command("week").description("Cost summary for this week").action(() => printSummary("This Week", "week"));
-program.command("month").description("Cost summary for this month").action(() => printSummary("This Month", "month"));
-program.command("sessions").description("List coding sessions with costs").option("--agent <agent>", "Filter by agent (claude|codex)").option("--project <path>", "Filter by project path").option("--limit <n>", "Number of sessions", "20").action((opts) => {
+program.command("today").description("Cost summary for today").action(async () => {
+  await autoSync();
+  printSummary("Today", "today");
+});
+program.command("week").description("Cost summary for this week").action(async () => {
+  await autoSync();
+  printSummary("This Week", "week");
+});
+program.command("month").description("Cost summary for this month").action(async () => {
+  await autoSync();
+  printSummary("This Month", "month");
+});
+program.command("sessions").description("List coding sessions with costs").option("--agent <agent>", "Filter by agent (claude|codex)").option("--project <path>", "Filter by project path").option("--limit <n>", "Number of sessions", "20").action(async (opts) => {
+  await autoSync();
   const db = openDatabase();
   const sessions = querySessions(db, {
     agent: opts.agent,
@@ -1154,6 +1330,79 @@ projectCmd.command("rename <path> <name>").description("Rename a project").actio
   upsertProject(db, { ...existing, name });
   console.log(chalk2.green(`\u2713 Renamed to: ${name}`));
 });
+projectCmd.command("show <nameOrPath>").description("Detailed project breakdown with sparkline").action(async (nameOrPath) => {
+  await autoSync();
+  const db = openDatabase();
+  const sessions = db.prepare(`SELECT * FROM sessions WHERE project_name LIKE ? OR project_path LIKE ? ORDER BY started_at DESC`).all(`%${nameOrPath}%`, `%${nameOrPath}%`);
+  if (sessions.length === 0) {
+    console.log(chalk2.yellow(`No sessions found for: ${nameOrPath}`));
+    return;
+  }
+  const projectName = sessions[0]["project_name"] || nameOrPath;
+  const projectPath = sessions[0]["project_path"] || "";
+  const totalCost = sessions.reduce((s, r) => s + r["total_cost_usd"], 0);
+  const totalTokens = sessions.reduce((s, r) => s + r["total_tokens"], 0);
+  const daily = db.prepare(`
+      SELECT DATE(r.timestamp) as d, SUM(r.cost_usd) as cost
+      FROM requests r JOIN sessions s ON r.session_id = s.id
+      WHERE (s.project_name LIKE ? OR s.project_path LIKE ?)
+        AND r.timestamp >= DATE('now', '-14 days')
+      GROUP BY d ORDER BY d ASC
+    `).all(`%${nameOrPath}%`, `%${nameOrPath}%`);
+  const dailyValues = daily.map((d) => d.cost);
+  const models = db.prepare(`
+      SELECT r.model, COUNT(*) as reqs, SUM(r.cost_usd) as cost
+      FROM requests r JOIN sessions s ON r.session_id = s.id
+      WHERE s.project_name LIKE ? OR s.project_path LIKE ?
+      GROUP BY r.model ORDER BY cost DESC LIMIT 5
+    `).all(`%${nameOrPath}%`, `%${nameOrPath}%`);
+  console.log();
+  console.log(chalk2.bold.cyan(`  ${projectName}`));
+  console.log(chalk2.dim(`  ${projectPath}`));
+  console.log();
+  printTable(["Metric", "Value"], [
+    ["Total cost", fmt2(totalCost)],
+    ["Sessions", fmtCount(sessions.length)],
+    ["Total tokens", fmtTokens(totalTokens)]
+  ]);
+  if (dailyValues.length > 0) {
+    console.log(`
+  ${chalk2.dim("14-day trend:")} ${sparkline(dailyValues)}`);
+  }
+  if (models.length > 0) {
+    console.log(`
+  ${chalk2.dim("Model breakdown:")}`);
+    for (const m of models) {
+      console.log(`    ${chalk2.white(m.model.padEnd(30))} ${fmt2(m.cost)} (${fmtCount(m.reqs)} reqs)`);
+    }
+  }
+  const topSessions = sessions.sort((a, b) => b["total_cost_usd"] - a["total_cost_usd"]).slice(0, 5);
+  if (topSessions.length > 0) {
+    console.log(`
+  ${chalk2.dim("Top sessions:")}`);
+    for (const s of topSessions) {
+      console.log(`    ${chalk2.dim(s["id"].substring(0, 12))}  ${fmt2(s["total_cost_usd"])}  ${chalk2.dim(String(s["started_at"]).substring(0, 16))}`);
+    }
+  }
+  console.log();
+});
+var configCmd = program.command("config").description("Manage economy configuration");
+configCmd.command("set <key> <value>").description("Set a config value").action(async (_key, _value) => {
+  const { setConfigValue: setConfigValue2 } = await Promise.resolve().then(() => (init_config(), exports_config));
+  setConfigValue2(_key, _value);
+  console.log(chalk2.green(`\u2713 ${_key} = ${_value}`));
+});
+configCmd.command("get <key>").description("Get a config value").action(async (key) => {
+  const { getConfigValue: getConfigValue2 } = await Promise.resolve().then(() => (init_config(), exports_config));
+  console.log(getConfigValue2(key) ?? chalk2.dim("(not set)"));
+});
+configCmd.action(async () => {
+  const { loadConfig: loadConfig2 } = await Promise.resolve().then(() => (init_config(), exports_config));
+  const config = loadConfig2();
+  console.log();
+  printTable(["Key", "Value"], Object.entries(config).map(([k, v]) => [k, String(v)]));
+  console.log();
+});
 var pricingCmd = program.command("pricing").description("Manage model pricing rates");
 pricingCmd.command("list").description("List all model prices").action(() => {
   const db = openDatabase();
@@ -1256,4 +1505,197 @@ Codex (~/.codex/config.toml):`));
   }
   console.log();
 });
+program.command("session <id>").description("Show detailed breakdown of a single session").action(async (id) => {
+  await autoSync();
+  const db = openDatabase();
+  const session = db.prepare(`SELECT * FROM sessions WHERE id = ? OR id LIKE ?`).get(id, `%${id}%`);
+  if (!session) {
+    console.log(chalk2.red(`Session not found: ${id}`));
+    process.exit(1);
+  }
+  const requests = db.prepare(`SELECT * FROM requests WHERE session_id = ? ORDER BY timestamp ASC`).all(session["id"]);
+  console.log();
+  console.log(chalk2.bold.cyan(`  Session: ${session["id"].substring(0, 16)}...`));
+  console.log();
+  printTable(["Field", "Value"], [
+    ["Agent", String(session["agent"])],
+    ["Project", String(session["project_name"] || session["project_path"] || "\u2014")],
+    ["Started", String(session["started_at"]).substring(0, 19)],
+    ["Ended", session["ended_at"] ? String(session["ended_at"]).substring(0, 19) : "\u2014"],
+    ["Total cost", fmt2(session["total_cost_usd"])],
+    ["Total tokens", fmtTokens(session["total_tokens"])],
+    ["Requests", fmtCount(session["request_count"])]
+  ]);
+  if (requests.length > 0) {
+    console.log(chalk2.dim(`
+  Requests (${requests.length}):
+`));
+    printTable(["Time", "Model", "Input", "Output", "Cache R", "Cache W", "Cost"], requests.slice(0, 50).map((r) => [
+      chalk2.dim(String(r["timestamp"]).substring(11, 19)),
+      chalk2.white(String(r["model"]).substring(0, 22)),
+      fmtTokens(r["input_tokens"]),
+      fmtTokens(r["output_tokens"]),
+      fmtTokens(r["cache_read_tokens"]),
+      fmtTokens(r["cache_create_tokens"]),
+      fmt2(r["cost_usd"])
+    ]));
+    if (requests.length > 50)
+      console.log(chalk2.dim(`  ... and ${requests.length - 50} more requests`));
+  }
+  console.log();
+});
+program.command("export").description("Export data as CSV").option("--type <type>", "Data type: sessions or requests", "sessions").option("--period <period>", "Period: today|week|month|all", "month").option("--output <file>", "Output file path (default: stdout)").action(async (opts) => {
+  await autoSync();
+  const db = openDatabase();
+  let csv;
+  if (opts.type === "requests") {
+    const where = opts.period === "today" ? `DATE(timestamp) = DATE('now')` : opts.period === "week" ? `timestamp >= DATE('now', '-7 days')` : opts.period === "all" ? "1=1" : `timestamp >= DATE('now', '-30 days')`;
+    const rows = db.prepare(`SELECT * FROM requests WHERE ${where} ORDER BY timestamp ASC`).all();
+    csv = `id,agent,session_id,model,input_tokens,output_tokens,cache_read_tokens,cache_create_tokens,cost_usd,duration_ms,timestamp
+`;
+    for (const r of rows) {
+      csv += `${r["id"]},${r["agent"]},${r["session_id"]},${r["model"]},${r["input_tokens"]},${r["output_tokens"]},${r["cache_read_tokens"]},${r["cache_create_tokens"]},${r["cost_usd"]},${r["duration_ms"]},${r["timestamp"]}
+`;
+    }
+  } else {
+    const where = opts.period === "today" ? `DATE(started_at) = DATE('now')` : opts.period === "week" ? `started_at >= DATE('now', '-7 days')` : opts.period === "all" ? "1=1" : `started_at >= DATE('now', '-30 days')`;
+    const rows = db.prepare(`SELECT * FROM sessions WHERE ${where} ORDER BY started_at DESC`).all();
+    csv = `id,agent,project_path,project_name,started_at,ended_at,total_cost_usd,total_tokens,request_count
+`;
+    for (const r of rows) {
+      csv += `${r["id"]},${r["agent"]},"${r["project_path"]}","${r["project_name"]}",${r["started_at"]},${r["ended_at"] ?? ""},${r["total_cost_usd"]},${r["total_tokens"]},${r["request_count"]}
+`;
+    }
+  }
+  if (opts.output) {
+    const { writeFileSync: writeFileSync2 } = await import("fs");
+    writeFileSync2(opts.output, csv);
+    console.log(chalk2.green(`\u2713 Exported to ${opts.output}`));
+  } else {
+    process.stdout.write(csv);
+  }
+});
+program.command("compare <period1> <period2>").description("Compare two periods (today/yesterday/week/lastweek/month/lastmonth)").action(async (p1, p2) => {
+  await autoSync();
+  const db = openDatabase();
+  function dateRange(period) {
+    const now = new Date;
+    const today = now.toISOString().substring(0, 10);
+    switch (period) {
+      case "today":
+        return [today, today];
+      case "yesterday": {
+        const d = new Date(now);
+        d.setDate(d.getDate() - 1);
+        const s = d.toISOString().substring(0, 10);
+        return [s, s];
+      }
+      case "week": {
+        const d = new Date(now);
+        d.setDate(d.getDate() - 7);
+        return [d.toISOString().substring(0, 10), today];
+      }
+      case "lastweek": {
+        const d1 = new Date(now);
+        d1.setDate(d1.getDate() - 14);
+        const d2 = new Date(now);
+        d2.setDate(d2.getDate() - 7);
+        return [d1.toISOString().substring(0, 10), d2.toISOString().substring(0, 10)];
+      }
+      case "month": {
+        const d = new Date(now);
+        d.setDate(d.getDate() - 30);
+        return [d.toISOString().substring(0, 10), today];
+      }
+      case "lastmonth": {
+        const d1 = new Date(now);
+        d1.setDate(d1.getDate() - 60);
+        const d2 = new Date(now);
+        d2.setDate(d2.getDate() - 30);
+        return [d1.toISOString().substring(0, 10), d2.toISOString().substring(0, 10)];
+      }
+      default:
+        return [today, today];
+    }
+  }
+  function queryRange(from, to) {
+    const r = db.prepare(`SELECT COALESCE(SUM(cost_usd),0) as cost, COUNT(*) as requests, COALESCE(SUM(input_tokens+output_tokens+cache_read_tokens+cache_create_tokens),0) as tokens FROM requests WHERE DATE(timestamp) BETWEEN ? AND ?`).get(from, to);
+    const s = db.prepare(`SELECT COUNT(*) as sessions FROM sessions WHERE DATE(started_at) BETWEEN ? AND ?`).get(from, to);
+    return { ...r, sessions: s.sessions };
+  }
+  const [f1, t1] = dateRange(p1);
+  const [f2, t2] = dateRange(p2);
+  const a = queryRange(f1, t1);
+  const b = queryRange(f2, t2);
+  function delta(v1, v2) {
+    const d = v1 - v2;
+    const pct = v2 > 0 ? (d / v2 * 100).toFixed(1) : "\u2014";
+    const sign = d >= 0 ? "+" : "";
+    const color = d > 0 ? chalk2.red : d < 0 ? chalk2.green : chalk2.dim;
+    return color(`${sign}${pct}%`);
+  }
+  console.log();
+  console.log(chalk2.bold.cyan(`  ${p1} vs ${p2}`));
+  console.log();
+  printTable(["Metric", p1, p2, "Change"], [
+    ["Cost", fmt2(a.cost), fmt2(b.cost), delta(a.cost, b.cost)],
+    ["Sessions", fmtCount(a.sessions), fmtCount(b.sessions), delta(a.sessions, b.sessions)],
+    ["Requests", fmtCount(a.requests), fmtCount(b.requests), delta(a.requests, b.requests)],
+    ["Tokens", fmtTokens(a.tokens), fmtTokens(b.tokens), delta(a.tokens, b.tokens)]
+  ]);
+  console.log();
+});
+program.command("forecast").description("Project end-of-month cost based on current burn rate").action(async () => {
+  await autoSync();
+  const db = openDatabase();
+  const now = new Date;
+  const daysInMonth = new Date(now.getFullYear(), now.getMonth() + 1, 0).getDate();
+  const dayOfMonth = now.getDate();
+  const monthStart = `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, "0")}-01`;
+  const today = now.toISOString().substring(0, 10);
+  const monthSoFar = db.prepare(`SELECT COALESCE(SUM(cost_usd),0) as cost FROM requests WHERE DATE(timestamp) >= ?`).get(monthStart);
+  const dailyAvg = dayOfMonth > 0 ? monthSoFar.cost / dayOfMonth : 0;
+  const projected = dailyAvg * daysInMonth;
+  const sevenDaysAgo = new Date(now);
+  sevenDaysAgo.setDate(sevenDaysAgo.getDate() - 7);
+  const last7 = db.prepare(`SELECT COALESCE(SUM(cost_usd),0) as cost FROM requests WHERE DATE(timestamp) >= ?`).get(sevenDaysAgo.toISOString().substring(0, 10));
+  const last7DailyAvg = last7.cost / 7;
+  const last7Projected = last7DailyAvg * daysInMonth;
+  const dailyCosts = db.prepare(`SELECT DATE(timestamp) as d, SUM(cost_usd) as cost FROM requests WHERE DATE(timestamp) >= ? GROUP BY d ORDER BY cost ASC`).all(monthStart);
+  const cheapest = dailyCosts[0];
+  const mostExpensive = dailyCosts[dailyCosts.length - 1];
+  console.log();
+  console.log(chalk2.bold.cyan(`  Forecast (${dayOfMonth} of ${daysInMonth} days)`));
+  console.log();
+  printTable(["Metric", "Value"], [
+    ["Spent so far", fmt2(monthSoFar.cost)],
+    ["Daily average", fmt2(dailyAvg)],
+    [chalk2.bold("Projected total"), chalk2.bold(fmt2(projected).replace(chalk2.green(""), ""))],
+    ["Last 7-day rate", `${fmt2(last7DailyAvg)}/day \u2192 ${fmt2(last7Projected)}`],
+    ["Cheapest day", cheapest ? `${fmt2(cheapest.cost)} (${cheapest.d})` : "\u2014"],
+    ["Most expensive", mostExpensive ? `${fmt2(mostExpensive.cost)} (${mostExpensive.d})` : "\u2014"]
+  ]);
+  console.log();
+});
+program.command("efficiency").description("Show output/input token ratio per model").action(async () => {
+  await autoSync();
+  const db = openDatabase();
+  const models = db.prepare(`
+      SELECT model, SUM(input_tokens) as input, SUM(output_tokens) as output,
+             SUM(cache_read_tokens) as cache_read, SUM(cache_create_tokens) as cache_write,
+             COUNT(*) as requests, SUM(cost_usd) as cost
+      FROM requests GROUP BY model ORDER BY cost DESC
+    `).all();
+  console.log();
+  console.log(chalk2.bold.cyan("  Token Efficiency"));
+  console.log();
+  printTable(["Model", "Output/Input", "Cache Hit%", "Cost/1k Output", "Requests"], models.map((m) => {
+    const ratio = m.input > 0 ? (m.output / m.input).toFixed(2) : "\u2014";
+    const totalInput = m.input + m.cache_read + m.cache_write;
+    const cacheHit = totalInput > 0 ? (m.cache_read / totalInput * 100).toFixed(1) + "%" : "\u2014";
+    const costPer1kOutput = m.output > 0 ? fmt2(m.cost / m.output * 1000) : "\u2014";
+    return [chalk2.white(m.model), ratio, cacheHit, costPer1kOutput, fmtCount(m.requests)];
+  }));
+  console.log();
+});
 program.parse();

package/dist/mcp/index.js

@@ -666,7 +666,10 @@ server.setRequestHandler(CallToolRequestSchema, async (req) => {
       case "get_cost_summary": {
         const period = a["period"] ?? "today";
         const summary = querySummary(db, period);
-        return { content: [{ type: "text", text: JSON.stringify(summary, null, 2) }] };
+        const fmtUsd = (n) => "$" + n.toLocaleString("en-US", { minimumFractionDigits: 2, maximumFractionDigits: 2 });
+        const fmtTok = (n) => n >= 1e9 ? `${(n / 1e9).toFixed(1)}B` : n >= 1e6 ? `${(n / 1e6).toFixed(1)}M` : n >= 1000 ? `${(n / 1000).toFixed(1)}k` : String(n);
+        const result = { ...summary, summary: `You've spent ${fmtUsd(summary.total_usd)} ${period === "all" ? "total" : period} across ${summary.sessions} sessions (${summary.requests.toLocaleString()} requests, ${fmtTok(summary.tokens)} tokens)` };
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
       }
       case "get_sessions": {
         const sessions = querySessions(db, {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hasna/economy",
-  "version": "0.1.1",
+  "version": "0.2.1",
   "description": "AI coding cost tracker — CLI + MCP server + REST API + web dashboard for Claude Code, Codex, and Gemini",
   "type": "module",
   "main": "dist/index.js",