@tokz/cli 0.0.1 → 0.2.0

package/dist/chunk-MO4Y7IF6.js

@@ -0,0 +1,404 @@
+#!/usr/bin/env node
+
+// src/pricing.ts
+var PRICES = {
+  // Anthropic (cache write 1.25x input, cache read 0.1x)
+  "claude-fable-5": { inputPerMTok: 10, outputPerMTok: 50 },
+  "claude-opus-4-8": { inputPerMTok: 5, outputPerMTok: 25 },
+  "claude-opus-4-7": { inputPerMTok: 5, outputPerMTok: 25 },
+  "claude-opus-4-6": { inputPerMTok: 5, outputPerMTok: 25 },
+  "claude-sonnet-5": { inputPerMTok: 3, outputPerMTok: 15 },
+  "claude-sonnet-4-6": { inputPerMTok: 3, outputPerMTok: 15 },
+  "claude-haiku-4-5": { inputPerMTok: 1, outputPerMTok: 5 },
+  // OpenAI (no cache-write charge; cached input 0.1x)
+  "gpt-5-codex": { inputPerMTok: 1.25, outputPerMTok: 10, cacheWriteMult: 0 },
+  "gpt-5-mini": { inputPerMTok: 0.25, outputPerMTok: 2, cacheWriteMult: 0 },
+  "gpt-5-nano": { inputPerMTok: 0.05, outputPerMTok: 0.4, cacheWriteMult: 0 },
+  "gpt-5": { inputPerMTok: 1.25, outputPerMTok: 10, cacheWriteMult: 0 },
+  "gpt-4.1-mini": { inputPerMTok: 0.4, outputPerMTok: 1.6, cacheWriteMult: 0, cacheReadMult: 0.25 },
+  "gpt-4.1": { inputPerMTok: 2, outputPerMTok: 8, cacheWriteMult: 0, cacheReadMult: 0.25 },
+  "codex-mini": { inputPerMTok: 1.5, outputPerMTok: 6, cacheWriteMult: 0, cacheReadMult: 0.25 },
+  "o4-mini": { inputPerMTok: 1.1, outputPerMTok: 4.4, cacheWriteMult: 0, cacheReadMult: 0.25 },
+  o3: { inputPerMTok: 2, outputPerMTok: 8, cacheWriteMult: 0, cacheReadMult: 0.25 },
+  // Google
+  "gemini-2.5-pro": { inputPerMTok: 1.25, outputPerMTok: 10, cacheWriteMult: 0 },
+  "gemini-2.5-flash": { inputPerMTok: 0.3, outputPerMTok: 2.5, cacheWriteMult: 0 }
+};
+var DEFAULT_CACHE_READ_MULT = 0.1;
+var DEFAULT_CACHE_WRITE_MULT = 1.25;
+var CLAUDE_FALLBACK = PRICES["claude-opus-4-8"];
+var UNKNOWN = { inputPerMTok: 0, outputPerMTok: 0 };
+function resolvePrice(modelId) {
+  let best;
+  let bestLen = -1;
+  for (const [prefix, price] of Object.entries(PRICES)) {
+    if (modelId.startsWith(prefix) && prefix.length > bestLen) {
+      best = price;
+      bestLen = prefix.length;
+    }
+  }
+  if (best) return best;
+  return modelId.startsWith("claude") ? CLAUDE_FALLBACK : UNKNOWN;
+}
+function emptyUsage() {
+  return { inputTokens: 0, cacheReadTokens: 0, cacheCreationTokens: 0, outputTokens: 0, turns: 0 };
+}
+function costUsd(usage, modelId) {
+  const p = resolvePrice(modelId);
+  const readMult = p.cacheReadMult ?? DEFAULT_CACHE_READ_MULT;
+  const writeMult = p.cacheWriteMult ?? DEFAULT_CACHE_WRITE_MULT;
+  const input = usage.inputTokens / 1e6 * p.inputPerMTok;
+  const cacheRead = usage.cacheReadTokens / 1e6 * p.inputPerMTok * readMult;
+  const cacheWrite = usage.cacheCreationTokens / 1e6 * p.inputPerMTok * writeMult;
+  const output = usage.outputTokens / 1e6 * p.outputPerMTok;
+  return { input, cacheRead, cacheWrite, output, total: input + cacheRead + cacheWrite + output };
+}
+
+// src/attribute.ts
+var DAY_MS = 864e5;
+function addUsage(acc, u) {
+  acc.inputTokens += u.inputTokens;
+  acc.cacheReadTokens += u.cacheReadTokens;
+  acc.cacheCreationTokens += u.cacheCreationTokens;
+  acc.outputTokens += u.outputTokens;
+  acc.turns += u.turns;
+}
+function cacheSavings(usageByModel) {
+  let saved = 0;
+  for (const [model, u] of Object.entries(usageByModel)) {
+    const p = resolvePrice(model);
+    saved += u.cacheReadTokens / 1e6 * p.inputPerMTok * (1 - (p.cacheReadMult ?? 0.1));
+  }
+  return saved;
+}
+function cacheHitRate(usageByModel) {
+  let read = 0;
+  let input = 0;
+  for (const u of Object.values(usageByModel)) {
+    read += u.cacheReadTokens;
+    input += u.inputTokens;
+  }
+  const denom = read + input;
+  return denom > 0 ? read / denom : 0;
+}
+function buildDaily(dailyUsage) {
+  return Object.entries(dailyUsage).map(([date, byModel]) => {
+    const stat = {
+      date,
+      costUsd: 0,
+      inputTokens: 0,
+      cacheReadTokens: 0,
+      cacheCreationTokens: 0,
+      outputTokens: 0,
+      turns: 0
+    };
+    for (const [model, u] of Object.entries(byModel)) {
+      stat.costUsd += costUsd(u, model).total;
+      stat.inputTokens += u.inputTokens;
+      stat.cacheReadTokens += u.cacheReadTokens;
+      stat.cacheCreationTokens += u.cacheCreationTokens;
+      stat.outputTokens += u.outputTokens;
+      stat.turns += u.turns;
+    }
+    return stat;
+  }).sort((a, b) => a.date < b.date ? -1 : 1);
+}
+function summarizeSession(s) {
+  const byCost = Object.entries(s.usageByModel).map(([model, u]) => ({ model, cost: costUsd(u, model).total, turns: u.turns })).sort((a, b) => b.cost - a.cost);
+  return {
+    file: s.file,
+    start: s.firstTs,
+    end: s.lastTs,
+    costUsd: byCost.reduce((sum, m) => sum + m.cost, 0),
+    turns: byCost.reduce((sum, m) => sum + m.turns, 0),
+    toolCallCount: Object.values(s.toolCalls).reduce((sum, n) => sum + n, 0),
+    models: byCost.map((m) => m.model)
+  };
+}
+function clampSession(s, from, to) {
+  const days = Object.entries(s.dailyUsage ?? {}).filter(([d]) => d >= from && d <= to);
+  if (days.length === 0) return null;
+  const usageByModel = {};
+  for (const [, byModel] of days) {
+    for (const [model, u] of Object.entries(byModel)) {
+      addUsage(usageByModel[model] ??= emptyUsage(), u);
+    }
+  }
+  const lo = `${from}T00:00:00Z`;
+  const hi = `${to}T23:59:59.999Z`;
+  const firstTs = s.firstTs && s.firstTs > lo ? s.firstTs : lo;
+  const lastTs = s.lastTs && s.lastTs < hi ? s.lastTs : hi;
+  return { ...s, firstTs, lastTs, usageByModel, dailyUsage: Object.fromEntries(days) };
+}
+function buildReport(sessions, servers, range) {
+  if (range) {
+    sessions = sessions.map((s) => clampSession(s, range.from, range.to)).filter((s) => s !== null);
+  }
+  const usageByModel = {};
+  const toolCalls = {};
+  const toolCostUsd = {};
+  const dailyUsage = {};
+  let earliest = Infinity;
+  let latest = -Infinity;
+  for (const s of sessions) {
+    for (const [model, u] of Object.entries(s.usageByModel)) {
+      addUsage(usageByModel[model] ??= emptyUsage(), u);
+    }
+    for (const [name, n] of Object.entries(s.toolCalls)) {
+      toolCalls[name] = (toolCalls[name] ?? 0) + n;
+    }
+    for (const [name, c] of Object.entries(s.toolCostUsd ?? {})) {
+      toolCostUsd[name] = (toolCostUsd[name] ?? 0) + c;
+    }
+    for (const [date, byModel] of Object.entries(s.dailyUsage ?? {})) {
+      const day = dailyUsage[date] ??= {};
+      for (const [model, u] of Object.entries(byModel)) {
+        addUsage(day[model] ??= emptyUsage(), u);
+      }
+    }
+    if (s.firstTs) earliest = Math.min(earliest, Date.parse(s.firstTs));
+    if (s.lastTs) latest = Math.max(latest, Date.parse(s.lastTs));
+  }
+  const costByModel = {};
+  let totalCostUsd = 0;
+  let totalTurns = 0;
+  for (const [model, u] of Object.entries(usageByModel)) {
+    costByModel[model] = costUsd(u, model);
+    totalCostUsd += costByModel[model].total;
+    totalTurns += u.turns;
+  }
+  const spanDays = Number.isFinite(earliest) && Number.isFinite(latest) ? Math.max(1, Math.round((latest - earliest) / DAY_MS)) : 1;
+  const mcpSum = (record, server) => Object.entries(record).filter(([name]) => name.startsWith(`mcp__${server}__`)).reduce((sum, [, n]) => sum + n, 0);
+  const serverAudits = servers.map((srv) => {
+    const callsObserved = mcpSum(toolCalls, srv.name);
+    return {
+      ...srv,
+      callsObserved,
+      unused: callsObserved === 0,
+      estCostUsd: mcpSum(toolCostUsd, srv.name),
+      configured: true
+    };
+  });
+  const configured = new Set(servers.map((s) => s.name));
+  const observed = new Set(
+    Object.keys(toolCalls).map((name) => /^mcp__(.+)__[^_]/.exec(name)?.[1]).filter((s) => !!s)
+  );
+  for (const name of [...observed].sort()) {
+    if ([...configured].some((c) => name === c || name.startsWith(`${c}__`))) continue;
+    serverAudits.push({
+      name,
+      source: "observed in transcripts (plugin or external config)",
+      callsObserved: mcpSum(toolCalls, name),
+      unused: false,
+      estCostUsd: mcpSum(toolCostUsd, name),
+      configured: false
+    });
+  }
+  const isoDate = (ms) => new Date(ms).toISOString().slice(0, 10);
+  return {
+    sessionCount: sessions.length,
+    spanDays,
+    spanStart: Number.isFinite(earliest) ? isoDate(earliest) : void 0,
+    spanEnd: Number.isFinite(latest) ? isoDate(latest) : void 0,
+    usageByModel,
+    costByModel,
+    totalCostUsd,
+    monthlyProjectionUsd: totalCostUsd / spanDays * 30,
+    toolCalls,
+    toolCostUsd,
+    servers: serverAudits,
+    daily: buildDaily(dailyUsage),
+    sessions: sessions.map(summarizeSession).sort((a, b) => b.costUsd - a.costUsd),
+    cacheSavingsUsd: cacheSavings(usageByModel),
+    cacheHitRate: cacheHitRate(usageByModel),
+    totalTurns
+  };
+}
+
+// src/discover.ts
+import { homedir } from "os";
+import { join } from "path";
+import { glob } from "tinyglobby";
+function sanitizeProjectPath(p) {
+  return p.replace(/[^a-zA-Z0-9]/g, "-");
+}
+function transcriptDir(projectPath, home = homedir()) {
+  return join(home, ".claude", "projects", sanitizeProjectPath(projectPath));
+}
+async function findTranscripts(projectPath, home = homedir()) {
+  const cwd = projectPath ? transcriptDir(projectPath, home) : join(home, ".claude", "projects");
+  return glob(["**/*.jsonl"], { cwd, absolute: true }).catch(() => []);
+}
+
+// src/mcp.ts
+import { readFile } from "fs/promises";
+import { homedir as homedir2 } from "os";
+import { join as join2 } from "path";
+async function readJson(file) {
+  try {
+    return JSON.parse(await readFile(file, "utf8"));
+  } catch {
+    return void 0;
+  }
+}
+function serverNames(obj) {
+  if (obj && typeof obj === "object" && !Array.isArray(obj)) return Object.keys(obj);
+  return [];
+}
+async function findMcpServers(projectPath, home = homedir2()) {
+  const out = /* @__PURE__ */ new Map();
+  const add = (names, source) => {
+    for (const name of names) if (!out.has(name)) out.set(name, { name, source });
+  };
+  const projectFile = join2(projectPath, ".mcp.json");
+  const projectCfg = await readJson(projectFile);
+  add(serverNames(projectCfg?.mcpServers), projectFile);
+  const globalFile = join2(home, ".claude.json");
+  const globalCfg = await readJson(globalFile);
+  add(serverNames(globalCfg?.mcpServers), globalFile);
+  const projects = globalCfg?.projects;
+  if (projects && typeof projects === "object") {
+    const entry = projects[projectPath];
+    add(serverNames(entry?.mcpServers), `${globalFile} (project entry)`);
+  }
+  return [...out.values()];
+}
+
+// src/transcript.ts
+import { createReadStream } from "fs";
+import { createInterface } from "readline";
+import { z } from "zod";
+var AssistantLine = z.object({
+  type: z.literal("assistant"),
+  cwd: z.string().optional(),
+  timestamp: z.string().optional(),
+  message: z.object({
+    id: z.string().optional(),
+    model: z.string().optional(),
+    usage: z.object({
+      input_tokens: z.number().catch(0).default(0),
+      cache_creation_input_tokens: z.number().catch(0).default(0),
+      cache_read_input_tokens: z.number().catch(0).default(0),
+      output_tokens: z.number().catch(0).default(0)
+    }).optional(),
+    content: z.array(z.object({ type: z.string(), id: z.string().optional(), name: z.string().optional() }).passthrough()).optional()
+  })
+});
+async function parseTranscript(file, seenMessageIds = /* @__PURE__ */ new Set(), seenToolIds = /* @__PURE__ */ new Set()) {
+  const stats = { file, usageByModel: {}, toolCalls: {}, toolCostUsd: {}, dailyUsage: {} };
+  const rl = createInterface({ input: createReadStream(file, "utf8"), crlfDelay: Infinity });
+  for await (const line of rl) {
+    if (!line.trim()) continue;
+    let raw;
+    try {
+      raw = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    const parsed = AssistantLine.safeParse(raw);
+    if (!parsed.success) continue;
+    const { message, timestamp, cwd } = parsed.data;
+    if (cwd && !stats.cwd) stats.cwd = cwd;
+    if (timestamp) {
+      if (!stats.firstTs) stats.firstTs = timestamp;
+      stats.lastTs = timestamp;
+    }
+    const model = message.model ?? "unknown";
+    const firstSeen = !message.id || !seenMessageIds.has(message.id);
+    if (message.id) seenMessageIds.add(message.id);
+    let turnCost = 0;
+    if (message.usage && firstSeen && model !== "<synthetic>") {
+      const accs = [stats.usageByModel[model] ??= emptyUsage()];
+      if (timestamp) {
+        const day = stats.dailyUsage[timestamp.slice(0, 10)] ??= {};
+        accs.push(day[model] ??= emptyUsage());
+      }
+      for (const u of accs) {
+        u.inputTokens += message.usage.input_tokens;
+        u.cacheCreationTokens += message.usage.cache_creation_input_tokens;
+        u.cacheReadTokens += message.usage.cache_read_input_tokens;
+        u.outputTokens += message.usage.output_tokens;
+        u.turns += 1;
+      }
+      turnCost = costUsd(
+        {
+          inputTokens: message.usage.input_tokens,
+          cacheCreationTokens: message.usage.cache_creation_input_tokens,
+          cacheReadTokens: message.usage.cache_read_input_tokens,
+          outputTokens: message.usage.output_tokens,
+          turns: 1
+        },
+        model
+      ).total;
+    }
+    const turnTools = [];
+    for (const block of message.content ?? []) {
+      if (block.type !== "tool_use" || !block.name) continue;
+      if (block.id) {
+        if (seenToolIds.has(block.id)) continue;
+        seenToolIds.add(block.id);
+      }
+      stats.toolCalls[block.name] = (stats.toolCalls[block.name] ?? 0) + 1;
+      turnTools.push(block.name);
+    }
+    if (turnCost > 0 && turnTools.length > 0) {
+      const share = turnCost / turnTools.length;
+      for (const name of turnTools) {
+        stats.toolCostUsd[name] = (stats.toolCostUsd[name] ?? 0) + share;
+      }
+    }
+  }
+  return stats;
+}
+
+// src/format.ts
+var usd = (n) => `$${n.toFixed(2)}`;
+var tok = (n) => n.toLocaleString("en-US");
+function compact(n) {
+  if (n >= 1e9) return `${(n / 1e9).toFixed(1)}B`;
+  if (n >= 1e6) return `${(n / 1e6).toFixed(1)}M`;
+  if (n >= 1e3) return `${(n / 1e3).toFixed(1)}k`;
+  return String(n);
+}
+var pct = (fraction) => `${Math.round(fraction * 100)}%`;
+var pct1 = (fraction) => `${(fraction * 100).toFixed(1)}%`;
+var shortModel = (id) => id.replace(/^claude-/, "").replace(/-\d{8}$/, "");
+function duration(startIso, endIso) {
+  if (!startIso || !endIso) return "\u2014";
+  const mins = Math.round((Date.parse(endIso) - Date.parse(startIso)) / 6e4);
+  if (mins < 1) return "<1m";
+  if (mins < 60) return `${mins}m`;
+  const h = Math.floor(mins / 60);
+  const m = mins % 60;
+  return m > 0 ? `${h}h ${m}m` : `${h}h`;
+}
+function relativeDate(iso, now = Date.now()) {
+  if (!iso) return "\u2014";
+  const date = iso.slice(0, 10);
+  const days = Math.floor((now - Date.parse(date)) / 864e5);
+  if (days <= 0) return "today";
+  if (days === 1) return "yesterday";
+  if (days < 30) return `${days}d ago`;
+  return date;
+}
+
+export {
+  emptyUsage,
+  costUsd,
+  addUsage,
+  cacheSavings,
+  cacheHitRate,
+  buildReport,
+  sanitizeProjectPath,
+  findTranscripts,
+  findMcpServers,
+  usd,
+  tok,
+  compact,
+  pct,
+  pct1,
+  shortModel,
+  duration,
+  relativeDate,
+  parseTranscript
+};

package/dist/cli.js

@@ -0,0 +1,108 @@
+#!/usr/bin/env node
+import {
+  buildReport,
+  findMcpServers,
+  findTranscripts,
+  parseTranscript,
+  pct1,
+  tok,
+  usd
+} from "./chunk-MO4Y7IF6.js";
+
+// src/cli.ts
+import { Command } from "commander";
+
+// src/report.ts
+import Table from "cli-table3";
+import pc from "picocolors";
+function renderReport(report) {
+  const parts = [];
+  const span = report.spanStart && report.spanEnd ? `${report.spanStart} \u2192 ${report.spanEnd}` : `${report.spanDays} days`;
+  parts.push(
+    pc.bold(
+      `tokz audit \u2014 ${report.sessionCount} sessions, ${span}: ${usd(report.totalCostUsd)} API-equivalent cost, projected ${usd(report.monthlyProjectionUsd)}/month`
+    )
+  );
+  parts.push(
+    pc.dim(
+      "Cost = what these tokens would bill at Anthropic API pay-as-you-go rates. On a Pro/Max subscription you pay a flat fee, not this \u2014 treat it as value received, not a bill."
+    )
+  );
+  parts.push(
+    `Cache hit rate ${pct1(report.cacheHitRate)} \u2014 prompt caching saved ${usd(report.cacheSavingsUsd)} vs uncached input pricing.`
+  );
+  const costTable = new Table({ head: ["Model", "Input", "Cache read", "Cache write", "Output", "Cost"] });
+  for (const [model, u] of Object.entries(report.usageByModel)) {
+    const c = report.costByModel[model];
+    costTable.push([model, tok(u.inputTokens), tok(u.cacheReadTokens), tok(u.cacheCreationTokens), tok(u.outputTokens), usd(c.total)]);
+  }
+  parts.push(costTable.toString());
+  if (report.servers.length > 0) {
+    const serverTable = new Table({ head: ["MCP server", "Calls observed", "Status", "Configured in"] });
+    for (const s of report.servers) {
+      serverTable.push([
+        s.name,
+        String(s.callsObserved),
+        s.unused ? pc.red("UNUSED \u2014 schema loaded every turn for nothing") : pc.green("used"),
+        s.source
+      ]);
+    }
+    parts.push(serverTable.toString());
+  }
+  const topTools = Object.entries(report.toolCalls).sort(([, a], [, b]) => b - a).slice(0, 10);
+  if (topTools.length > 0) {
+    const toolTable = new Table({ head: ["Tool", "Calls"] });
+    for (const [name, n] of topTools) toolTable.push([name, String(n)]);
+    parts.push(toolTable.toString());
+  }
+  return parts.join("\n\n");
+}
+
+// src/cli.ts
+var program = new Command();
+program.name("tokz").description("Audit where your coding agent's context window and API dollars go.").version("0.1.0");
+program.command("audit").argument("[project]", "project path (default: current directory)").option("--all", "scan all projects under ~/.claude/projects").option("--json", "output raw JSON report").option("--days <n>", "only include the last N days of activity").action(async (project, opts) => {
+  const projectPath = project ?? process.cwd();
+  const transcripts = await findTranscripts(opts.all ? void 0 : projectPath);
+  if (transcripts.length === 0) {
+    console.error(`No Claude Code transcripts found for ${opts.all ? "any project" : projectPath}.`);
+    process.exitCode = 1;
+    return;
+  }
+  const seenMessageIds = /* @__PURE__ */ new Set();
+  const seenToolIds = /* @__PURE__ */ new Set();
+  const sessions = await Promise.all(
+    transcripts.map((f) => parseTranscript(f, seenMessageIds, seenToolIds))
+  );
+  const servers = opts.all ? [] : await findMcpServers(projectPath);
+  const days = opts.days ? Number.parseInt(opts.days, 10) : void 0;
+  const isoDay = (offset) => new Date(Date.now() - offset * 864e5).toISOString().slice(0, 10);
+  const range = days && days > 0 ? { from: isoDay(days - 1), to: isoDay(0) } : void 0;
+  const report = buildReport(sessions, servers, range);
+  console.log(opts.json ? JSON.stringify(report, null, 2) : renderReport(report));
+});
+program.action(async () => {
+  if (!process.stdout.isTTY) {
+    const transcripts = await findTranscripts(void 0);
+    if (transcripts.length === 0) {
+      console.error("No Claude Code transcripts found.");
+      process.exitCode = 1;
+      return;
+    }
+    const seenMessageIds = /* @__PURE__ */ new Set();
+    const seenToolIds = /* @__PURE__ */ new Set();
+    const sessions = await Promise.all(
+      transcripts.map((f) => parseTranscript(f, seenMessageIds, seenToolIds))
+    );
+    console.log(renderReport(buildReport(sessions, [])));
+    return;
+  }
+  const [{ render }, React, { Root }, { Fullscreen }] = await Promise.all([
+    import("ink"),
+    import("react"),
+    import("./Root-T6AZELSZ.js"),
+    import("./Fullscreen-GK2ZYXHV.js")
+  ]);
+  render(React.createElement(Fullscreen, null, React.createElement(Root)));
+});
+program.parseAsync();

package/package.json

@@ -1,8 +1,35 @@
-{
-  "name": "@tokz/cli",
-  "version": "0.0.1",
-  "description": "Audit where your coding agent's context window goes. Full release coming soon.",
-  "bin": { "tokz": "./cli.js" },
-  "license": "MIT",
-  "publishConfig": { "access": "public" }
-}
+{
+  "name": "@tokz/cli",
+  "version": "0.2.0",
+  "description": "Audit where your coding agent's context window and API dollars go.",
+  "type": "module",
+  "license": "MIT",
+  "engines": { "node": ">=22.0.0" },
+  "bin": { "tokz": "./dist/cli.js" },
+  "files": ["dist"],
+  "publishConfig": { "access": "public" },
+  "scripts": {
+    "build": "tsup",
+    "test": "vitest run",
+    "dev": "tsx src/cli.ts"
+  },
+  "dependencies": {
+    "cli-table3": "^0.6.5",
+    "commander": "^13.0.0",
+    "ink": "^5.0.1",
+    "ink-select-input": "^6.0.0",
+    "picocolors": "^1.1.0",
+    "react": "^18.3.1",
+    "tinyglobby": "^0.2.10",
+    "zod": "^3.24.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "@types/react": "^18.3.12",
+    "ink-testing-library": "^4.0.0",
+    "tsup": "^8.3.0",
+    "tsx": "^4.19.0",
+    "typescript": "^5.7.0",
+    "vitest": "^3.0.0"
+  }
+}

package/cli.js

@@ -1 +0,0 @@
-console.log("tokz: context-window audit for coding agents. v0 coming soon - https://tokz.dev");