@hasna/economy 0.2.7 → 0.2.8

package/dist/index.js

@@ -0,0 +1,1010 @@
+// @bun
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+
+// src/lib/pricing.ts
+var exports_pricing = {};
+__export(exports_pricing, {
+  normalizeModelName: () => normalizeModelName,
+  getPricingFromDb: () => getPricingFromDb,
+  getPricing: () => getPricing,
+  ensurePricingSeeded: () => ensurePricingSeeded,
+  computeCostFromDb: () => computeCostFromDb,
+  computeCost: () => computeCost,
+  DEFAULT_PRICING: () => DEFAULT_PRICING
+});
+function normalizeModelName(raw) {
+  return raw.replace(/-\d{8}$/, "").replace(/-\d{4}-\d{2}-\d{2}$/, "").toLowerCase();
+}
+function ensurePricingSeeded(db) {
+  seedModelPricing(db, DEFAULT_PRICING);
+}
+function getPricingFromDb(db, model) {
+  const normalized = normalizeModelName(model);
+  const row = getModelPricing(db, normalized);
+  if (row) {
+    return {
+      inputPer1M: row.input_per_1m,
+      outputPer1M: row.output_per_1m,
+      cacheReadPer1M: row.cache_read_per_1m,
+      cacheWritePer1M: row.cache_write_per_1m
+    };
+  }
+  const allRows = db.prepare(`SELECT * FROM model_pricing`).all();
+  for (const r of allRows) {
+    if (normalized.startsWith(r.model)) {
+      return { inputPer1M: r.input_per_1m, outputPer1M: r.output_per_1m, cacheReadPer1M: r.cache_read_per_1m, cacheWritePer1M: r.cache_write_per_1m };
+    }
+  }
+  return null;
+}
+function getPricing(model) {
+  const normalized = normalizeModelName(model);
+  if (DEFAULT_PRICING[normalized])
+    return DEFAULT_PRICING[normalized] ?? null;
+  for (const key of Object.keys(DEFAULT_PRICING)) {
+    if (normalized.startsWith(key))
+      return DEFAULT_PRICING[key] ?? null;
+  }
+  return null;
+}
+function computeCost(model, inputTokens, outputTokens, cacheReadTokens = 0, cacheWriteTokens = 0) {
+  const pricing = getPricing(model);
+  if (!pricing)
+    return 0;
+  return (inputTokens * pricing.inputPer1M + outputTokens * pricing.outputPer1M + cacheReadTokens * pricing.cacheReadPer1M + cacheWriteTokens * pricing.cacheWritePer1M) / 1e6;
+}
+function computeCostFromDb(db, model, inputTokens, outputTokens, cacheReadTokens = 0, cacheWriteTokens = 0) {
+  const pricing = getPricingFromDb(db, model) ?? getPricing(model);
+  if (!pricing)
+    return 0;
+  return (inputTokens * pricing.inputPer1M + outputTokens * pricing.outputPer1M + cacheReadTokens * pricing.cacheReadPer1M + cacheWriteTokens * pricing.cacheWritePer1M) / 1e6;
+}
+var DEFAULT_PRICING;
+var init_pricing = __esm(() => {
+  init_database();
+  DEFAULT_PRICING = {
+    "claude-opus-4-6": { inputPer1M: 5, outputPer1M: 25, cacheReadPer1M: 0.5, cacheWritePer1M: 6.25 },
+    "claude-opus-4-5": { inputPer1M: 5, outputPer1M: 25, cacheReadPer1M: 0.5, cacheWritePer1M: 6.25 },
+    "claude-sonnet-4-6": { inputPer1M: 3, outputPer1M: 15, cacheReadPer1M: 0.3, cacheWritePer1M: 3.75 },
+    "claude-sonnet-4-5": { inputPer1M: 3, outputPer1M: 15, cacheReadPer1M: 0.3, cacheWritePer1M: 3.75 },
+    "claude-haiku-4-5": { inputPer1M: 1, outputPer1M: 5, cacheReadPer1M: 0.1, cacheWritePer1M: 1.25 },
+    "claude-3-5-sonnet": { inputPer1M: 3, outputPer1M: 15, cacheReadPer1M: 0.3, cacheWritePer1M: 3.75 },
+    "claude-3-5-haiku": { inputPer1M: 1, outputPer1M: 5, cacheReadPer1M: 0.1, cacheWritePer1M: 1.25 },
+    "claude-3-opus": { inputPer1M: 15, outputPer1M: 75, cacheReadPer1M: 1.5, cacheWritePer1M: 18.75 },
+    "claude-3-sonnet": { inputPer1M: 3, outputPer1M: 15, cacheReadPer1M: 0.3, cacheWritePer1M: 3.75 },
+    "claude-3-haiku": { inputPer1M: 0.25, outputPer1M: 1.25, cacheReadPer1M: 0.03, cacheWritePer1M: 0.3 },
+    "gemini-2.0-flash": { inputPer1M: 0.075, outputPer1M: 0.3, cacheReadPer1M: 0, cacheWritePer1M: 0 },
+    "gemini-2.5-pro": { inputPer1M: 1.25, outputPer1M: 10, cacheReadPer1M: 0, cacheWritePer1M: 0 },
+    "gemini-1.5-pro": { inputPer1M: 1.25, outputPer1M: 5, cacheReadPer1M: 0, cacheWritePer1M: 0 },
+    "gemini-1.5-flash": { inputPer1M: 0.075, outputPer1M: 0.3, cacheReadPer1M: 0, cacheWritePer1M: 0 },
+    "gpt-5.3-codex": { inputPer1M: 1.75, outputPer1M: 14, cacheReadPer1M: 0.44, cacheWritePer1M: 0 },
+    "gpt-5.2-codex": { inputPer1M: 1.75, outputPer1M: 14, cacheReadPer1M: 0.44, cacheWritePer1M: 0 },
+    "gpt-5-codex": { inputPer1M: 1.75, outputPer1M: 14, cacheReadPer1M: 0.44, cacheWritePer1M: 0 },
+    "gpt-4o": { inputPer1M: 2.5, outputPer1M: 10, cacheReadPer1M: 1.25, cacheWritePer1M: 0 },
+    "gpt-4o-mini": { inputPer1M: 0.15, outputPer1M: 0.6, cacheReadPer1M: 0.075, cacheWritePer1M: 0 },
+    o1: { inputPer1M: 15, outputPer1M: 60, cacheReadPer1M: 7.5, cacheWritePer1M: 0 },
+    "o1-mini": { inputPer1M: 3, outputPer1M: 12, cacheReadPer1M: 1.5, cacheWritePer1M: 0 },
+    o3: { inputPer1M: 10, outputPer1M: 40, cacheReadPer1M: 2.5, cacheWritePer1M: 0 },
+    "o3-mini": { inputPer1M: 1.1, outputPer1M: 4.4, cacheReadPer1M: 0.55, cacheWritePer1M: 0 },
+    "o4-mini": { inputPer1M: 1.1, outputPer1M: 4.4, cacheReadPer1M: 0.275, cacheWritePer1M: 0 }
+  };
+});
+
+// src/db/database.ts
+import { SqliteAdapter as Database } from "@hasna/cloud";
+import { copyFileSync, existsSync, mkdirSync, readdirSync, statSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+function getDataDir() {
+  const home = process.env["HOME"] || process.env["USERPROFILE"] || homedir();
+  const newDir = join(home, ".hasna", "economy");
+  const oldDir = join(home, ".economy");
+  if (existsSync(oldDir) && !existsSync(newDir)) {
+    mkdirSync(newDir, { recursive: true });
+    for (const file of readdirSync(oldDir)) {
+      const oldPath = join(oldDir, file);
+      if (statSync(oldPath).isFile()) {
+        copyFileSync(oldPath, join(newDir, file));
+      }
+    }
+  }
+  mkdirSync(newDir, { recursive: true });
+  return newDir;
+}
+function getDbPath() {
+  if (process.env["HASNA_ECONOMY_DB_PATH"])
+    return process.env["HASNA_ECONOMY_DB_PATH"];
+  if (process.env["ECONOMY_DB"])
+    return process.env["ECONOMY_DB"];
+  return join(getDataDir(), "economy.db");
+}
+function openDatabase(dbPath, skipSeed = false) {
+  const path = dbPath ?? getDbPath();
+  if (path !== ":memory:") {
+    const dir = path.substring(0, path.lastIndexOf("/"));
+    if (dir && !existsSync(dir))
+      mkdirSync(dir, { recursive: true });
+  }
+  const db = new Database(path);
+  db.exec("PRAGMA journal_mode = WAL");
+  db.exec("PRAGMA foreign_keys = ON");
+  initSchema(db);
+  if (!skipSeed) {
+    Promise.resolve().then(() => (init_pricing(), exports_pricing)).then(({ ensurePricingSeeded: ensurePricingSeeded2 }) => ensurePricingSeeded2(db)).catch(() => {});
+  }
+  return db;
+}
+function initSchema(db) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS requests (
+      id TEXT PRIMARY KEY,
+      agent TEXT NOT NULL,
+      session_id TEXT NOT NULL,
+      model TEXT NOT NULL,
+      input_tokens INTEGER DEFAULT 0,
+      output_tokens INTEGER DEFAULT 0,
+      cache_read_tokens INTEGER DEFAULT 0,
+      cache_create_tokens INTEGER DEFAULT 0,
+      cost_usd REAL NOT NULL DEFAULT 0,
+      duration_ms INTEGER DEFAULT 0,
+      timestamp TEXT NOT NULL,
+      source_request_id TEXT
+    );
+
+    CREATE TABLE IF NOT EXISTS sessions (
+      id TEXT PRIMARY KEY,
+      agent TEXT NOT NULL,
+      project_path TEXT DEFAULT '',
+      project_name TEXT DEFAULT '',
+      started_at TEXT NOT NULL,
+      ended_at TEXT,
+      total_cost_usd REAL DEFAULT 0,
+      total_tokens INTEGER DEFAULT 0,
+      request_count INTEGER DEFAULT 0
+    );
+
+    CREATE TABLE IF NOT EXISTS projects (
+      id TEXT PRIMARY KEY,
+      path TEXT UNIQUE NOT NULL,
+      name TEXT NOT NULL,
+      description TEXT,
+      tags TEXT DEFAULT '[]',
+      created_at TEXT NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS budgets (
+      id TEXT PRIMARY KEY,
+      project_path TEXT,
+      agent TEXT,
+      period TEXT NOT NULL,
+      limit_usd REAL NOT NULL,
+      alert_at_percent INTEGER DEFAULT 80,
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS goals (
+      id TEXT PRIMARY KEY,
+      period TEXT NOT NULL,
+      project_path TEXT,
+      agent TEXT,
+      limit_usd REAL NOT NULL,
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS ingest_state (
+      source TEXT NOT NULL,
+      key TEXT NOT NULL,
+      value TEXT NOT NULL,
+      PRIMARY KEY (source, key)
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_requests_session ON requests(session_id);
+    CREATE INDEX IF NOT EXISTS idx_requests_timestamp ON requests(timestamp);
+    CREATE INDEX IF NOT EXISTS idx_requests_agent ON requests(agent);
+    CREATE INDEX IF NOT EXISTS idx_sessions_agent ON sessions(agent);
+    CREATE INDEX IF NOT EXISTS idx_sessions_project ON sessions(project_path);
+    CREATE INDEX IF NOT EXISTS idx_sessions_started ON sessions(started_at);
+
+    CREATE TABLE IF NOT EXISTS model_pricing (
+      model TEXT PRIMARY KEY,
+      input_per_1m REAL NOT NULL DEFAULT 0,
+      output_per_1m REAL NOT NULL DEFAULT 0,
+      cache_read_per_1m REAL NOT NULL DEFAULT 0,
+      cache_write_per_1m REAL NOT NULL DEFAULT 0,
+      updated_at TEXT NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS feedback (
+      id TEXT PRIMARY KEY DEFAULT (lower(hex(randomblob(16)))),
+      message TEXT NOT NULL,
+      email TEXT,
+      category TEXT DEFAULT 'general',
+      version TEXT,
+      machine_id TEXT,
+      created_at TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+  `);
+}
+function periodWhere(period) {
+  switch (period) {
+    case "today":
+      return `DATE(timestamp) = DATE('now')`;
+    case "yesterday":
+      return `DATE(timestamp) = DATE('now', '-1 day')`;
+    case "week":
+      return `timestamp >= DATE('now', '-7 days')`;
+    case "month":
+      return `timestamp >= DATE('now', '-30 days')`;
+    case "year":
+      return `timestamp >= DATE('now', '-365 days')`;
+    case "all":
+      return "1=1";
+  }
+}
+function sessionPeriodWhere(period) {
+  switch (period) {
+    case "today":
+      return `DATE(started_at) = DATE('now')`;
+    case "yesterday":
+      return `DATE(started_at) = DATE('now', '-1 day')`;
+    case "week":
+      return `started_at >= DATE('now', '-7 days')`;
+    case "month":
+      return `started_at >= DATE('now', '-30 days')`;
+    case "year":
+      return `started_at >= DATE('now', '-365 days')`;
+    case "all":
+      return "1=1";
+  }
+}
+function upsertRequest(db, req) {
+  db.prepare(`
+    INSERT OR REPLACE INTO requests
+      (id, agent, session_id, model, input_tokens, output_tokens,
+       cache_read_tokens, cache_create_tokens, cost_usd, duration_ms,
+       timestamp, source_request_id)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `).run(req.id, req.agent, req.session_id, req.model, req.input_tokens, req.output_tokens, req.cache_read_tokens, req.cache_create_tokens, req.cost_usd, req.duration_ms, req.timestamp, req.source_request_id);
+}
+function upsertSession(db, session) {
+  db.prepare(`
+    INSERT OR REPLACE INTO sessions
+      (id, agent, project_path, project_name, started_at, ended_at,
+       total_cost_usd, total_tokens, request_count)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `).run(session.id, session.agent, session.project_path, session.project_name, session.started_at, session.ended_at ?? null, session.total_cost_usd, session.total_tokens, session.request_count);
+}
+function rollupSession(db, sessionId) {
+  db.prepare(`
+    UPDATE sessions SET
+      total_cost_usd = (SELECT COALESCE(SUM(cost_usd), 0) FROM requests WHERE session_id = ?),
+      total_tokens   = (SELECT COALESCE(SUM(input_tokens + output_tokens + cache_read_tokens + cache_create_tokens), 0) FROM requests WHERE session_id = ?),
+      request_count  = (SELECT COUNT(*) FROM requests WHERE session_id = ?),
+      ended_at       = (SELECT MAX(timestamp) FROM requests WHERE session_id = ?),
+      started_at     = CASE WHEN started_at = '' OR started_at IS NULL
+                            THEN (SELECT MIN(timestamp) FROM requests WHERE session_id = ?)
+                            ELSE started_at END
+    WHERE id = ?
+  `).run(sessionId, sessionId, sessionId, sessionId, sessionId, sessionId);
+}
+function querySessions(db, filter = {}) {
+  const conditions = [];
+  const params = [];
+  if (filter.agent) {
+    conditions.push("agent = ?");
+    params.push(filter.agent);
+  }
+  if (filter.project) {
+    conditions.push("project_path LIKE ?");
+    params.push(`%${filter.project}%`);
+  }
+  if (filter.since) {
+    conditions.push("started_at >= ?");
+    params.push(filter.since);
+  }
+  if (filter.search) {
+    const q = `%${filter.search}%`;
+    conditions.push("(project_name LIKE ? OR agent LIKE ? OR id LIKE ?)");
+    params.push(q, q, `${filter.search}%`);
+  }
+  const where = conditions.length ? `WHERE ${conditions.join(" AND ")}` : "";
+  const limit = filter.limit ?? 50;
+  const offset = filter.offset ?? 0;
+  return db.prepare(`
+    SELECT * FROM sessions ${where} ORDER BY started_at DESC LIMIT ? OFFSET ?
+  `).all(...params, limit, offset);
+}
+function queryTopSessions(db, n = 10, agent) {
+  if (agent) {
+    return db.prepare(`SELECT * FROM sessions WHERE agent = ? ORDER BY total_cost_usd DESC LIMIT ?`).all(agent, n);
+  }
+  return db.prepare(`SELECT * FROM sessions ORDER BY total_cost_usd DESC LIMIT ?`).all(n);
+}
+function querySummary(db, period) {
+  const rWhere = periodWhere(period);
+  const sWhere = sessionPeriodWhere(period);
+  const r = db.prepare(`
+    SELECT COALESCE(SUM(cost_usd), 0) as total_usd,
+           COUNT(*) as requests,
+           COALESCE(SUM(input_tokens + output_tokens + cache_read_tokens + cache_create_tokens), 0) as tokens
+    FROM requests WHERE ${rWhere}
+  `).get();
+  const codexTotals = db.prepare(`
+    SELECT COALESCE(SUM(total_cost_usd), 0) as cost_usd,
+           COALESCE(SUM(total_tokens), 0) as tokens,
+           COUNT(*) as sessions
+    FROM sessions
+    WHERE ${sWhere}
+    AND id NOT IN (SELECT DISTINCT session_id FROM requests)
+  `).get();
+  const sessionCount = db.prepare(`SELECT COUNT(*) as sessions FROM sessions WHERE ${sWhere}`).get();
+  return {
+    total_usd: r.total_usd + codexTotals.cost_usd,
+    requests: r.requests,
+    tokens: r.tokens + codexTotals.tokens,
+    sessions: sessionCount.sessions,
+    period
+  };
+}
+function queryModelBreakdown(db) {
+  return db.prepare(`
+    SELECT model, agent,
+           COUNT(*) as requests,
+           COALESCE(SUM(input_tokens), 0) as input_tokens,
+           COALESCE(SUM(output_tokens), 0) as output_tokens,
+           COALESCE(SUM(input_tokens + output_tokens + cache_read_tokens + cache_create_tokens), 0) as total_tokens,
+           COALESCE(SUM(cost_usd), 0) as cost_usd
+    FROM requests GROUP BY model, agent ORDER BY cost_usd DESC
+  `).all();
+}
+function queryProjectBreakdown(db) {
+  return db.prepare(`
+    SELECT
+      s.project_path,
+      COALESCE(p.name, s.project_name) as project_name,
+      COUNT(DISTINCT s.id) as sessions,
+      COUNT(r.id) as requests,
+      COALESCE(SUM(r.cost_usd), COALESCE(SUM(s.total_cost_usd), 0)) as cost_usd,
+      COALESCE(SUM(r.input_tokens + r.output_tokens + r.cache_read_tokens + r.cache_create_tokens), 0) as total_tokens,
+      MAX(s.started_at) as last_active
+    FROM sessions s
+    LEFT JOIN projects p ON p.path = s.project_path OR p.name = s.project_name
+    LEFT JOIN requests r ON r.session_id = s.id
+    WHERE s.project_path != '' OR s.project_name != ''
+    GROUP BY s.project_path
+    ORDER BY cost_usd DESC
+  `).all();
+}
+function queryDailyBreakdown(db, days = 30) {
+  return db.prepare(`
+    SELECT DATE(timestamp) as date, agent, COALESCE(SUM(cost_usd), 0) as cost_usd
+    FROM requests
+    WHERE timestamp >= DATE('now', ? || ' days')
+    GROUP BY DATE(timestamp), agent
+    ORDER BY date ASC
+  `).all(`-${days}`);
+}
+function upsertProject(db, project) {
+  db.prepare(`
+    INSERT OR REPLACE INTO projects (id, path, name, description, tags, created_at)
+    VALUES (?, ?, ?, ?, ?, ?)
+  `).run(project.id, project.path, project.name, project.description ?? null, JSON.stringify(project.tags), project.created_at);
+}
+function getProject(db, path) {
+  const row = db.prepare(`SELECT * FROM projects WHERE path = ?`).get(path);
+  if (!row)
+    return null;
+  return { ...row, tags: JSON.parse(row["tags"] ?? "[]") };
+}
+function listProjects(db) {
+  return db.prepare(`SELECT * FROM projects ORDER BY created_at DESC`).all().map((row) => ({ ...row, tags: JSON.parse(row["tags"] ?? "[]") }));
+}
+function deleteProject(db, path) {
+  db.prepare(`DELETE FROM projects WHERE path = ?`).run(path);
+}
+function upsertBudget(db, budget) {
+  db.prepare(`
+    INSERT OR REPLACE INTO budgets
+      (id, project_path, agent, period, limit_usd, alert_at_percent, created_at, updated_at)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+  `).run(budget.id, budget.project_path ?? null, budget.agent ?? null, budget.period, budget.limit_usd, budget.alert_at_percent, budget.created_at, budget.updated_at);
+}
+function listBudgets(db) {
+  return db.prepare(`SELECT * FROM budgets ORDER BY created_at DESC`).all();
+}
+function deleteBudget(db, id) {
+  db.prepare(`DELETE FROM budgets WHERE id = ?`).run(id);
+}
+function getBudgetStatuses(db) {
+  const budgets = listBudgets(db);
+  return budgets.map((b) => {
+    const periodStart = b.period === "daily" ? "DATE('now')" : b.period === "weekly" ? "DATE('now', '-7 days')" : "DATE('now', '-30 days')";
+    let spendQuery = `SELECT COALESCE(SUM(cost_usd), 0) as spend FROM requests WHERE timestamp >= ${periodStart}`;
+    const params = [];
+    if (b.project_path) {
+      spendQuery += ` AND session_id IN (SELECT id FROM sessions WHERE project_path = ?)`;
+      params.push(b.project_path);
+    }
+    if (b.agent) {
+      spendQuery += ` AND agent = ?`;
+      params.push(b.agent);
+    }
+    const row = db.prepare(spendQuery).get(...params);
+    const spend = row.spend;
+    const percent = b.limit_usd > 0 ? spend / b.limit_usd * 100 : 0;
+    return {
+      ...b,
+      current_spend_usd: spend,
+      percent_used: percent,
+      is_over_limit: percent >= 100,
+      is_over_alert: percent >= b.alert_at_percent
+    };
+  });
+}
+function upsertGoal(db, goal) {
+  db.prepare(`
+    INSERT OR REPLACE INTO goals
+      (id, period, project_path, agent, limit_usd, created_at, updated_at)
+    VALUES (?, ?, ?, ?, ?, ?, ?)
+  `).run(goal.id, goal.period, goal.project_path ?? null, goal.agent ?? null, goal.limit_usd, goal.created_at, goal.updated_at);
+}
+function deleteGoal(db, id) {
+  db.prepare(`DELETE FROM goals WHERE id = ?`).run(id);
+}
+function listGoals(db) {
+  return db.prepare(`SELECT * FROM goals ORDER BY created_at DESC`).all();
+}
+function getGoalStatuses(db) {
+  const goals = listGoals(db);
+  return goals.map((g) => {
+    const periodStart = g.period === "day" ? "DATE('now')" : g.period === "week" ? "DATE('now', '-7 days')" : g.period === "month" ? "DATE('now', '-30 days')" : "DATE('now', '-365 days')";
+    let spendQuery = `SELECT COALESCE(SUM(cost_usd), 0) as spend FROM requests WHERE timestamp >= ${periodStart}`;
+    const params = [];
+    if (g.project_path) {
+      spendQuery += ` AND session_id IN (SELECT id FROM sessions WHERE project_path = ?)`;
+      params.push(g.project_path);
+    }
+    if (g.agent) {
+      spendQuery += ` AND agent = ?`;
+      params.push(g.agent);
+    }
+    const row = db.prepare(spendQuery).get(...params);
+    const spend = row.spend;
+    const percent = g.limit_usd > 0 ? spend / g.limit_usd * 100 : 0;
+    return {
+      ...g,
+      current_spend_usd: spend,
+      percent_used: percent,
+      is_on_track: percent < 70,
+      is_at_risk: percent >= 70 && percent <= 100,
+      is_over: percent > 100
+    };
+  });
+}
+function getIngestState(db, source, key) {
+  const row = db.prepare(`SELECT value FROM ingest_state WHERE source = ? AND key = ?`).get(source, key);
+  return row?.value ?? null;
+}
+function setIngestState(db, source, key, value) {
+  db.prepare(`INSERT OR REPLACE INTO ingest_state (source, key, value) VALUES (?, ?, ?)`).run(source, key, value);
+}
+function queryRequestsSince(db, since) {
+  return db.prepare(`SELECT * FROM requests WHERE timestamp > ? ORDER BY timestamp ASC`).all(since);
+}
+function upsertModelPricing(db, p) {
+  db.prepare(`
+    INSERT OR REPLACE INTO model_pricing
+      (model, input_per_1m, output_per_1m, cache_read_per_1m, cache_write_per_1m, updated_at)
+    VALUES (?, ?, ?, ?, ?, ?)
+  `).run(p.model, p.input_per_1m, p.output_per_1m, p.cache_read_per_1m, p.cache_write_per_1m, p.updated_at);
+}
+function getModelPricing(db, model) {
+  return db.prepare(`SELECT * FROM model_pricing WHERE model = ?`).get(model);
+}
+function listModelPricing(db) {
+  return db.prepare(`SELECT * FROM model_pricing ORDER BY model ASC`).all();
+}
+function deleteModelPricing(db, model) {
+  db.prepare(`DELETE FROM model_pricing WHERE model = ?`).run(model);
+}
+function seedModelPricing(db, defaults) {
+  const existing = db.prepare(`SELECT COUNT(*) as count FROM model_pricing`).get();
+  if (existing.count > 0)
+    return;
+  const now = new Date().toISOString();
+  for (const [model, p] of Object.entries(defaults)) {
+    upsertModelPricing(db, {
+      model,
+      input_per_1m: p.inputPer1M,
+      output_per_1m: p.outputPer1M,
+      cache_read_per_1m: p.cacheReadPer1M,
+      cache_write_per_1m: p.cacheWritePer1M,
+      updated_at: now
+    });
+  }
+}
+var init_database = () => {};
+
+// src/index.ts
+init_database();
+init_pricing();
+
+// src/lib/gatherer.ts
+init_database();
+var SYSTEM_PROMPT = "You are a cost-aware AI assistant that tracks API usage, identifies expensive patterns, and helps optimize spending.";
+var gatherTrainingData = async (options = {}) => {
+  const limit = options.limit ?? 500;
+  const examples = [];
+  try {
+    const db = openDatabase();
+    const periods = ["today", "week", "month", "all"];
+    for (const period of periods) {
+      try {
+        const s = querySummary(db, period);
+        examples.push({
+          messages: [
+            { role: "system", content: SYSTEM_PROMPT },
+            { role: "user", content: `What did I spend on AI ${period === "all" ? "in total" : period}?` },
+            {
+              role: "assistant",
+              content: `${period === "all" ? "Total" : period.charAt(0).toUpperCase() + period.slice(1)} AI spending: $${s.total_usd.toFixed(4)} across ${s.sessions} session(s), ${s.requests} request(s), ${s.tokens.toLocaleString()} tokens.`
+            }
+          ]
+        });
+      } catch {}
+    }
+    const sessions = querySessions(db, {
+      limit: Math.min(Math.floor(limit / 4), 50),
+      since: options.since?.toISOString().substring(0, 10)
+    });
+    for (const s of sessions) {
+      examples.push({
+        messages: [
+          { role: "system", content: SYSTEM_PROMPT },
+          {
+            role: "user",
+            content: `How much did the session "${s.id.substring(0, 12)}" cost?`
+          },
+          {
+            role: "assistant",
+            content: `Session ${s.id.substring(0, 12)} (${s.agent}, project: ${s.project_name || "unknown"}): $${s.total_cost_usd.toFixed(4)}, ${s.total_tokens.toLocaleString()} tokens, ${s.request_count} requests. Started: ${s.started_at.substring(0, 16)}.`
+          }
+        ]
+      });
+      examples.push({
+        messages: [
+          { role: "system", content: SYSTEM_PROMPT },
+          {
+            role: "user",
+            content: `What was the token usage for session ${s.id.substring(0, 12)}?`
+          },
+          {
+            role: "assistant",
+            content: `Session ${s.id.substring(0, 12)} used ${s.total_tokens.toLocaleString()} tokens across ${s.request_count} requests on project "${s.project_name || "unknown"}" (${s.agent}).`
+          }
+        ]
+      });
+      if (examples.length >= limit)
+        break;
+    }
+    const modelBreakdown = queryModelBreakdown(db);
+    if (modelBreakdown.length > 0) {
+      const topModels = modelBreakdown.slice(0, 5);
+      examples.push({
+        messages: [
+          { role: "system", content: SYSTEM_PROMPT },
+          { role: "user", content: "Which AI models have I spent the most on?" },
+          {
+            role: "assistant",
+            content: `Model cost breakdown (top ${topModels.length}):
+${topModels.map((m) => `- ${m.model} (${m.agent}): $${m.cost_usd.toFixed(4)}, ${m.requests} requests, ${m.total_tokens.toLocaleString()} tokens`).join(`
+`)}`
+          }
+        ]
+      });
+      for (const m of topModels) {
+        examples.push({
+          messages: [
+            { role: "system", content: SYSTEM_PROMPT },
+            { role: "user", content: `How much have I spent on ${m.model}?` },
+            {
+              role: "assistant",
+              content: `${m.model} (${m.agent}): $${m.cost_usd.toFixed(4)} total across ${m.requests.toLocaleString()} requests and ${m.total_tokens.toLocaleString()} tokens.`
+            }
+          ]
+        });
+      }
+    }
+    const projectBreakdown = queryProjectBreakdown(db);
+    if (projectBreakdown.length > 0) {
+      const topProjects = projectBreakdown.slice(0, 5);
+      examples.push({
+        messages: [
+          { role: "system", content: SYSTEM_PROMPT },
+          { role: "user", content: "Which projects are costing the most?" },
+          {
+            role: "assistant",
+            content: `Project cost breakdown (top ${topProjects.length}):
+${topProjects.map((p) => `- ${p.project_name || "unknown"}: $${p.cost_usd.toFixed(4)}, ${p.sessions} sessions`).join(`
+`)}`
+          }
+        ]
+      });
+      for (const p of topProjects.slice(0, 3)) {
+        examples.push({
+          messages: [
+            { role: "system", content: SYSTEM_PROMPT },
+            { role: "user", content: `What is the AI spend for project "${p.project_name}"?` },
+            {
+              role: "assistant",
+              content: `Project "${p.project_name}": $${p.cost_usd.toFixed(4)} across ${p.sessions} session(s) and ${p.requests.toLocaleString()} requests. Last active: ${p.last_active?.substring(0, 10) ?? "unknown"}.`
+            }
+          ]
+        });
+      }
+    }
+    try {
+      const budgets = getBudgetStatuses(db);
+      if (budgets.length > 0) {
+        examples.push({
+          messages: [
+            { role: "system", content: SYSTEM_PROMPT },
+            { role: "user", content: "How am I tracking against my AI spending budgets?" },
+            {
+              role: "assistant",
+              content: `Budget status:
+${budgets.map((b) => `- ${b.project_path ?? "global"} (${b.period}): $${b.current_spend_usd.toFixed(4)} / $${b.limit_usd.toFixed(2)} (${b.percent_used.toFixed(1)}%) \u2014 ${b.is_over_limit ? "OVER LIMIT" : b.is_over_alert ? "ALERT" : "OK"}`).join(`
+`)}`
+            }
+          ]
+        });
+      }
+    } catch {}
+    try {
+      const goals = getGoalStatuses(db);
+      if (goals.length > 0) {
+        examples.push({
+          messages: [
+            { role: "system", content: SYSTEM_PROMPT },
+            { role: "user", content: "Am I on track with my AI cost reduction goals?" },
+            {
+              role: "assistant",
+              content: `Goal progress:
+${goals.map((g) => `- ${g.period} goal (${g.project_path ?? g.agent ?? "global"}): $${g.current_spend_usd.toFixed(4)} / $${g.limit_usd.toFixed(2)} (${g.percent_used.toFixed(1)}%) \u2014 ${g.is_over ? "OVER" : g.is_at_risk ? "AT RISK" : "ON TRACK"}`).join(`
+`)}`
+            }
+          ]
+        });
+      }
+    } catch {}
+    const weekSummary = querySummary(db, "week");
+    const monthSummary = querySummary(db, "month");
+    if (weekSummary.total_usd > 0) {
+      const projectedMonthly = weekSummary.total_usd / 7 * 30;
+      examples.push({
+        messages: [
+          { role: "system", content: SYSTEM_PROMPT },
+          { role: "user", content: "Based on my usage, what will I spend this month?" },
+          {
+            role: "assistant",
+            content: `Based on your last 7 days ($${weekSummary.total_usd.toFixed(4)}), projected monthly spend is approximately $${projectedMonthly.toFixed(2)}. Current month-to-date: $${monthSummary.total_usd.toFixed(4)}.`
+          }
+        ]
+      });
+    }
+    if (modelBreakdown.length > 1) {
+      const expensive = modelBreakdown[0];
+      const cheaper = modelBreakdown[modelBreakdown.length - 1];
+      examples.push({
+        messages: [
+          { role: "system", content: SYSTEM_PROMPT },
+          { role: "user", content: "How can I reduce my AI API costs?" },
+          {
+            role: "assistant",
+            content: `Your most expensive model is ${expensive.model} at $${expensive.cost_usd.toFixed(4)}. Consider switching some workloads to ${cheaper.model} ($${cheaper.cost_usd.toFixed(4)}) for cost savings. Cache frequently repeated prompts to reduce cache-miss costs.`
+          }
+        ]
+      });
+    }
+  } catch {}
+  const finalExamples = examples.slice(0, limit);
+  return { source: "economy", examples: finalExamples, count: finalExamples.length };
+};
+// src/lib/model-config.ts
+init_database();
+import { existsSync as existsSync2, readFileSync, writeFileSync, mkdirSync as mkdirSync2 } from "fs";
+import { join as join2 } from "path";
+var DEFAULT_MODEL = "gpt-4o-mini";
+var CONFIG_PATH = join2(getDataDir(), "config.json");
+function loadConfig() {
+  try {
+    if (existsSync2(CONFIG_PATH)) {
+      return JSON.parse(readFileSync(CONFIG_PATH, "utf-8"));
+    }
+  } catch {}
+  return {};
+}
+function saveConfig(config) {
+  const dir = getDataDir();
+  if (!existsSync2(dir))
+    mkdirSync2(dir, { recursive: true });
+  writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2) + `
+`);
+}
+function getActiveModel() {
+  return loadConfig().activeModel ?? DEFAULT_MODEL;
+}
+function setActiveModel(id) {
+  const config = loadConfig();
+  config.activeModel = id;
+  saveConfig(config);
+}
+function clearActiveModel() {
+  const config = loadConfig();
+  delete config.activeModel;
+  saveConfig(config);
+}
+// src/ingest/claude.ts
+init_database();
+init_pricing();
+import { readdirSync as readdirSync2, readFileSync as readFileSync2, existsSync as existsSync3, statSync as statSync2 } from "fs";
+import { homedir as homedir2 } from "os";
+import { join as join3, basename } from "path";
+function autoDetectProject(cwd, projects) {
+  return projects.find((p) => cwd === p.path || cwd.startsWith(p.path + "/"));
+}
+var PROJECTS_DIR = join3(homedir2(), ".claude", "projects");
+function dirNameToPath(dirName) {
+  return dirName.replace(/^-/, "/").replace(/-/g, "/").replace(/\/\//g, "/-");
+}
+function collectJsonlFiles(projectDir) {
+  const files = [];
+  function walk(dir) {
+    try {
+      for (const entry of readdirSync2(dir, { withFileTypes: true })) {
+        if (entry.isDirectory())
+          walk(join3(dir, entry.name));
+        else if (entry.name.endsWith(".jsonl"))
+          files.push(join3(dir, entry.name));
+      }
+    } catch {}
+  }
+  walk(projectDir);
+  return files;
+}
+async function ingestClaude(db, verbose = false, _telemetryDir) {
+  if (!existsSync3(PROJECTS_DIR)) {
+    if (verbose)
+      console.log("Claude projects dir not found:", PROJECTS_DIR);
+    return { files: 0, requests: 0, sessions: 0 };
+  }
+  let totalFiles = 0;
+  let totalRequests = 0;
+  const touchedSessions = new Set;
+  const registeredProjects = db.prepare(`SELECT path, name FROM projects ORDER BY LENGTH(path) DESC`).all();
+  const projectDirs = readdirSync2(PROJECTS_DIR, { withFileTypes: true }).filter((d) => d.isDirectory());
+  for (const projectDirEntry of projectDirs) {
+    const projectDirPath = join3(PROJECTS_DIR, projectDirEntry.name);
+    const projectPath = dirNameToPath(projectDirEntry.name);
+    const jsonlFiles = collectJsonlFiles(projectDirPath);
+    for (const filePath of jsonlFiles) {
+      const stateKey = filePath.replace(PROJECTS_DIR, "");
+      let fileMtime = "0";
+      try {
+        fileMtime = statSync2(filePath).mtimeMs.toString();
+      } catch {
+        continue;
+      }
+      const processed = getIngestState(db, "claude", stateKey);
+      if (processed === fileMtime)
+        continue;
+      let lines;
+      try {
+        lines = readFileSync2(filePath, "utf-8").split(`
+`).filter((l) => l.trim());
+      } catch {
+        continue;
+      }
+      const fileBasename = basename(filePath, ".jsonl");
+      const isUuid = /^[0-9a-f-]{36}$/.test(fileBasename);
+      let sessionId = isUuid ? fileBasename : fileBasename.replace(/^agent-/, "");
+      let sessionCwd = projectPath;
+      for (const line of lines) {
+        let entry;
+        try {
+          entry = JSON.parse(line);
+        } catch {
+          continue;
+        }
+        if (entry.sessionId)
+          sessionId = entry.sessionId;
+        if (entry.cwd)
+          sessionCwd = entry.cwd;
+        if (entry.message?.role !== "assistant")
+          continue;
+        const usage = entry.message.usage;
+        if (!usage)
+          continue;
+        const model = entry.message.model;
+        if (!model)
+          continue;
+        const inputTokens = usage.input_tokens ?? 0;
+        const outputTokens = usage.output_tokens ?? 0;
+        const cacheWriteTokens = usage.cache_creation_input_tokens ?? 0;
+        const cacheReadTokens = usage.cache_read_input_tokens ?? 0;
+        const timestamp = entry.timestamp ?? new Date().toISOString();
+        if (inputTokens + outputTokens + cacheWriteTokens === 0)
+          continue;
+        const costUsd = computeCostFromDb(db, model, inputTokens, outputTokens, cacheReadTokens, cacheWriteTokens);
+        const reqId = `claude-${sessionId}-${timestamp}`;
+        upsertRequest(db, {
+          id: reqId,
+          agent: "claude",
+          session_id: sessionId,
+          model,
+          input_tokens: inputTokens,
+          output_tokens: outputTokens,
+          cache_read_tokens: cacheReadTokens,
+          cache_create_tokens: cacheWriteTokens,
+          cost_usd: costUsd,
+          duration_ms: 0,
+          timestamp,
+          source_request_id: reqId
+        });
+        if (!touchedSessions.has(sessionId)) {
+          const existing = db.prepare(`SELECT id FROM sessions WHERE id = ?`).get(sessionId);
+          if (!existing) {
+            const effectiveCwd = sessionCwd || projectPath;
+            const detectedProject = autoDetectProject(effectiveCwd, registeredProjects);
+            const session = {
+              id: sessionId,
+              agent: "claude",
+              project_path: detectedProject ? detectedProject.path : effectiveCwd,
+              project_name: detectedProject ? detectedProject.name : "",
+              started_at: timestamp,
+              ended_at: null,
+              total_cost_usd: 0,
+              total_tokens: 0,
+              request_count: 0
+            };
+            upsertSession(db, session);
+          }
+          touchedSessions.add(sessionId);
+        }
+        totalRequests++;
+      }
+      setIngestState(db, "claude", stateKey, fileMtime);
+      totalFiles++;
+    }
+  }
+  for (const sessionId of touchedSessions) {
+    rollupSession(db, sessionId);
+  }
+  return { files: totalFiles, requests: totalRequests, sessions: touchedSessions.size };
+}
+// src/ingest/codex.ts
+init_database();
+import { existsSync as existsSync4, readFileSync as readFileSync3 } from "fs";
+import { homedir as homedir3 } from "os";
+import { join as join4, basename as basename2 } from "path";
+import { Database as Database2 } from "bun:sqlite";
+var CODEX_DB_PATH = join4(homedir3(), ".codex", "state_5.sqlite");
+var CODEX_CONFIG_PATH = join4(homedir3(), ".codex", "config.toml");
+function readCodexModel() {
+  if (!existsSync4(CODEX_CONFIG_PATH))
+    return "gpt-5.3-codex";
+  try {
+    const content = readFileSync3(CODEX_CONFIG_PATH, "utf-8");
+    const match = content.match(/^model\s*=\s*"([^"]+)"/m);
+    return match?.[1] ?? "gpt-5.3-codex";
+  } catch {
+    return "gpt-5.3-codex";
+  }
+}
+async function ingestCodex(db, verbose = false) {
+  if (!existsSync4(CODEX_DB_PATH)) {
+    if (verbose)
+      console.log("Codex DB not found:", CODEX_DB_PATH);
+    return { sessions: 0 };
+  }
+  let codexDb = null;
+  let ingested = 0;
+  try {
+    codexDb = new Database2(CODEX_DB_PATH, { readonly: true });
+    const threads = codexDb.prepare(`SELECT id, cwd, created_at, updated_at, tokens_used, title FROM threads WHERE tokens_used > 0`).all();
+    for (const thread of threads) {
+      const stateKey = thread.id;
+      const processed = getIngestState(db, "codex", stateKey);
+      if (processed === "done")
+        continue;
+      const costUsd = 0;
+      const projectPath = thread.cwd ?? "";
+      const projectName = projectPath ? basename2(projectPath) : "unknown";
+      const startedAt = thread.created_at ? new Date(thread.created_at * 1000).toISOString() : new Date().toISOString();
+      const endedAt = thread.updated_at ? new Date(thread.updated_at * 1000).toISOString() : null;
+      upsertSession(db, {
+        id: `codex-${thread.id}`,
+        agent: "codex",
+        project_path: projectPath,
+        project_name: projectName,
+        started_at: startedAt,
+        ended_at: endedAt,
+        total_cost_usd: costUsd,
+        total_tokens: thread.tokens_used,
+        request_count: 1
+      });
+      setIngestState(db, "codex", stateKey, "done");
+      ingested++;
+      if (verbose)
+        console.log(`Codex session ${thread.id}: ${thread.tokens_used} tokens \u2192 $${costUsd.toFixed(4)}`);
+    }
+  } finally {
+    codexDb?.close();
+  }
+  return { sessions: ingested };
+}
+export {
+  upsertSession,
+  upsertRequest,
+  upsertProject,
+  upsertModelPricing,
+  upsertGoal,
+  upsertBudget,
+  setIngestState,
+  setActiveModel,
+  seedModelPricing,
+  rollupSession,
+  readCodexModel,
+  queryTopSessions,
+  querySummary,
+  querySessions,
+  queryRequestsSince,
+  queryProjectBreakdown,
+  queryModelBreakdown,
+  queryDailyBreakdown,
+  openDatabase,
+  normalizeModelName,
+  listProjects,
+  listModelPricing,
+  listGoals,
+  listBudgets,
+  ingestCodex,
+  ingestClaude,
+  getProject,
+  getPricingFromDb,
+  getPricing,
+  getModelPricing,
+  getIngestState,
+  getGoalStatuses,
+  getDbPath,
+  getDataDir,
+  getBudgetStatuses,
+  getActiveModel,
+  gatherTrainingData,
+  ensurePricingSeeded,
+  deleteProject,
+  deleteModelPricing,
+  deleteGoal,
+  deleteBudget,
+  computeCostFromDb,
+  computeCost,
+  clearActiveModel,
+  DEFAULT_PRICING,
+  DEFAULT_MODEL
+};