cc-costline 0.1.0

package/dist/cache.d.ts

@@ -0,0 +1,14 @@
+declare const CACHE_DIR: string;
+export interface CacheData {
+    cost7d: number;
+    cost30d: number;
+    updatedAt: string;
+}
+export interface ConfigData {
+    period: "7d" | "30d" | "both";
+}
+export declare function readCache(): CacheData | null;
+export declare function writeCache(data: CacheData): void;
+export declare function readConfig(): ConfigData;
+export declare function writeConfig(data: ConfigData): void;
+export { CACHE_DIR };

package/dist/cache.js

@@ -0,0 +1,33 @@
+import { readFileSync, writeFileSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+const CACHE_DIR = join(homedir(), ".cc-costline");
+const CACHE_FILE = join(CACHE_DIR, "cache.json");
+const CONFIG_FILE = join(CACHE_DIR, "config.json");
+export function readCache() {
+    try {
+        const raw = readFileSync(CACHE_FILE, "utf-8");
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+export function writeCache(data) {
+    mkdirSync(CACHE_DIR, { recursive: true });
+    writeFileSync(CACHE_FILE, JSON.stringify(data, null, 2) + "\n");
+}
+export function readConfig() {
+    try {
+        const raw = readFileSync(CONFIG_FILE, "utf-8");
+        return JSON.parse(raw);
+    }
+    catch {
+        return { period: "7d" };
+    }
+}
+export function writeConfig(data) {
+    mkdirSync(CACHE_DIR, { recursive: true });
+    writeFileSync(CONFIG_FILE, JSON.stringify(data, null, 2) + "\n");
+}
+export { CACHE_DIR };

package/dist/calculator.d.ts

@@ -0,0 +1,9 @@
+interface ModelPricing {
+    input: number;
+    output: number;
+    cacheCreation: number;
+    cacheRead: number;
+}
+export declare function getPricing(model: string): ModelPricing;
+export declare function calculateCost(model: string, inputTokens: number, outputTokens: number, cacheCreationTokens: number, cacheReadTokens: number): number;
+export {};

package/dist/calculator.js

@@ -0,0 +1,39 @@
+// Per-million-token pricing in USD (source: Anthropic pricing page)
+const MODEL_PRICING = {
+    // Opus family
+    "claude-opus-4-6": { input: 5, output: 25, cacheCreation: 6.25, cacheRead: 0.5 },
+    "claude-opus-4-5-20251101": { input: 5, output: 25, cacheCreation: 6.25, cacheRead: 0.5 },
+    "claude-opus-4-1-20250805": { input: 15, output: 75, cacheCreation: 18.75, cacheRead: 1.5 },
+    // Sonnet family
+    "claude-sonnet-4-5-20250929": { input: 3, output: 15, cacheCreation: 3.75, cacheRead: 0.3 },
+    "claude-sonnet-4-20250514": { input: 3, output: 15, cacheCreation: 3.75, cacheRead: 0.3 },
+    "claude-3-5-sonnet-20241022": { input: 3, output: 15, cacheCreation: 3.75, cacheRead: 0.3 },
+    // Haiku family
+    "claude-haiku-4-5-20251001": { input: 1, output: 5, cacheCreation: 1.25, cacheRead: 0.1 },
+    "claude-3-5-haiku-20241022": { input: 0.8, output: 4, cacheCreation: 1, cacheRead: 0.08 },
+};
+// Family fallbacks for unknown model IDs
+const FAMILY_FALLBACK = {
+    opus: MODEL_PRICING["claude-opus-4-6"],
+    sonnet: MODEL_PRICING["claude-sonnet-4-5-20250929"],
+    haiku: MODEL_PRICING["claude-haiku-4-5-20251001"],
+};
+export function getPricing(model) {
+    if (MODEL_PRICING[model])
+        return MODEL_PRICING[model];
+    // Try family fallback
+    const lower = model.toLowerCase();
+    for (const [family, pricing] of Object.entries(FAMILY_FALLBACK)) {
+        if (lower.includes(family))
+            return pricing;
+    }
+    // Default to sonnet pricing
+    return FAMILY_FALLBACK.sonnet;
+}
+export function calculateCost(model, inputTokens, outputTokens, cacheCreationTokens, cacheReadTokens) {
+    const pricing = getPricing(model);
+    return (inputTokens * pricing.input +
+        outputTokens * pricing.output +
+        cacheCreationTokens * pricing.cacheCreation +
+        cacheReadTokens * pricing.cacheRead) / 1e6;
+}

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,162 @@
+#!/usr/bin/env node
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { collectCosts } from "./collector.js";
+import { writeCache, writeConfig, readConfig, CACHE_DIR } from "./cache.js";
+import { render } from "./statusline.js";
+const SETTINGS_PATH = join(homedir(), ".claude", "settings.json");
+const RENDER_COMMAND = "cc-costline render";
+const REFRESH_COMMAND = "cc-costline refresh";
+// ─── Helpers ──────────────────────────────────────────────
+function readSettings() {
+    try {
+        return JSON.parse(readFileSync(SETTINGS_PATH, "utf-8"));
+    }
+    catch {
+        return {};
+    }
+}
+function saveSettings(settings) {
+    writeFileSync(SETTINGS_PATH, JSON.stringify(settings, null, 2) + "\n");
+}
+function readStdin() {
+    try {
+        return readFileSync("/dev/stdin", "utf-8");
+    }
+    catch {
+        return "";
+    }
+}
+// ─── Commands ─────────────────────────────────────────────
+function cmdInstall() {
+    const settings = readSettings();
+    // 1. Set statusLine command
+    settings.statusLine = {
+        type: "command",
+        command: RENDER_COMMAND,
+    };
+    // 2. Add SessionEnd hook for refresh
+    if (!settings.hooks)
+        settings.hooks = {};
+    for (const event of ["SessionEnd", "Stop"]) {
+        if (!settings.hooks[event])
+            settings.hooks[event] = [];
+        // Remove any old cc-costline / cc-statusline hooks first
+        settings.hooks[event] = settings.hooks[event].filter((h) => !h.hooks?.some((hh) => hh.command?.includes("cc-costline") || hh.command?.includes("cc-statusline")));
+        // Add fresh hook
+        settings.hooks[event].push({
+            matcher: "",
+            hooks: [
+                {
+                    type: "command",
+                    command: REFRESH_COMMAND,
+                    timeout: 60,
+                    async: true,
+                },
+            ],
+        });
+    }
+    saveSettings(settings);
+    // 3. Create config dir + default config
+    mkdirSync(CACHE_DIR, { recursive: true });
+    if (!existsSync(join(CACHE_DIR, "config.json"))) {
+        writeConfig({ period: "7d" });
+    }
+    // 4. Initial refresh
+    console.log("✓ settings.json updated (statusLine + hooks)");
+    console.log("✓ Config directory created: " + CACHE_DIR);
+    console.log("  Running initial cost calculation...");
+    cmdRefresh();
+    console.log("✓ Installation complete!");
+}
+function cmdUninstall() {
+    const settings = readSettings();
+    // Remove statusLine if it's ours
+    if (settings.statusLine?.command?.includes("cc-costline") ||
+        settings.statusLine?.command?.includes("cc-statusline")) {
+        delete settings.statusLine;
+    }
+    // Remove our hooks from SessionEnd and Stop
+    for (const event of ["SessionEnd", "Stop"]) {
+        if (!settings.hooks?.[event])
+            continue;
+        settings.hooks[event] = settings.hooks[event].filter((h) => !h.hooks?.some((hh) => hh.command?.includes("cc-costline") || hh.command?.includes("cc-statusline")));
+        if (settings.hooks[event].length === 0) {
+            delete settings.hooks[event];
+        }
+    }
+    saveSettings(settings);
+    console.log("✓ Removed cc-costline from settings.json");
+    console.log("  Cache directory preserved at: " + CACHE_DIR);
+}
+function cmdConfig(args) {
+    const periodIdx = args.indexOf("--period");
+    if (periodIdx === -1 || !args[periodIdx + 1]) {
+        const config = readConfig();
+        console.log("Current config:", JSON.stringify(config, null, 2));
+        console.log("\nUsage: cc-costline config --period <7d|30d|both>");
+        return;
+    }
+    const period = args[periodIdx + 1];
+    if (!["7d", "30d", "both"].includes(period)) {
+        console.error("Invalid period. Use: 7d, 30d, or both");
+        process.exit(1);
+    }
+    writeConfig({ period: period });
+    console.log(`✓ Period set to: ${period}`);
+}
+function cmdRefresh() {
+    const result = collectCosts();
+    writeCache({
+        cost7d: result.cost7d,
+        cost30d: result.cost30d,
+        updatedAt: new Date().toISOString(),
+    });
+    console.log(`✓ Cache updated — 7d: $${result.cost7d.toFixed(2)} | 30d: $${result.cost30d.toFixed(2)}`);
+}
+function cmdRender() {
+    const input = readStdin();
+    if (!input.trim())
+        return;
+    const output = render(input);
+    if (output)
+        process.stdout.write(output);
+}
+// ─── Main ─────────────────────────────────────────────────
+const args = process.argv.slice(2);
+const command = args[0];
+switch (command) {
+    case "install":
+        cmdInstall();
+        break;
+    case "uninstall":
+        cmdUninstall();
+        break;
+    case "config":
+        cmdConfig(args.slice(1));
+        break;
+    case "refresh":
+        cmdRefresh();
+        break;
+    case "render":
+        cmdRender();
+        break;
+    default:
+        console.log(`cc-costline v0.1.0 — Enhanced statusline for Claude Code
+
+Commands:
+  install     Configure Claude Code to use cc-costline
+  uninstall   Remove cc-costline from Claude Code settings
+  config      View/update display settings
+  refresh     Manually recalculate cost cache
+  render      Output statusline (reads stdin from Claude Code)
+
+Examples:
+  npx @ventuss/cc-costline install
+  npx @ventuss/cc-costline config --period 7d
+  npx @ventuss/cc-costline config --period 30d
+  npx @ventuss/cc-costline config --period both
+  npx @ventuss/cc-costline refresh`);
+        break;
+}

package/dist/collector.d.ts

@@ -0,0 +1,6 @@
+interface CollectResult {
+    cost7d: number;
+    cost30d: number;
+}
+export declare function collectCosts(): CollectResult;
+export {};

package/dist/collector.js

@@ -0,0 +1,93 @@
+import { readFileSync, readdirSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { calculateCost } from "./calculator.js";
+const CLAUDE_PROJECTS_DIR = ".claude/projects";
+/** Recursively find all .jsonl files under a directory */
+function findJsonlFiles(dir) {
+    const results = [];
+    let entries;
+    try {
+        entries = readdirSync(dir);
+    }
+    catch {
+        return results;
+    }
+    for (const entry of entries) {
+        const full = join(dir, entry);
+        let stat;
+        try {
+            stat = statSync(full);
+        }
+        catch {
+            continue;
+        }
+        if (stat.isDirectory()) {
+            results.push(...findJsonlFiles(full));
+        }
+        else if (entry.endsWith(".jsonl")) {
+            results.push(full);
+        }
+    }
+    return results;
+}
+export function collectCosts() {
+    const projectsDir = join(homedir(), CLAUDE_PROJECTS_DIR);
+    const files = findJsonlFiles(projectsDir);
+    if (files.length === 0) {
+        return { cost7d: 0, cost30d: 0 };
+    }
+    const now = Date.now();
+    const cutoff7d = now - 7 * 24 * 60 * 60 * 1000;
+    const cutoff30d = now - 30 * 24 * 60 * 60 * 1000;
+    let cost7d = 0;
+    let cost30d = 0;
+    // Deduplication set (same as ccclub)
+    const seen = new Set();
+    for (const file of files) {
+        let content;
+        try {
+            content = readFileSync(file, "utf-8");
+        }
+        catch {
+            continue;
+        }
+        const lines = content.split("\n");
+        for (const line of lines) {
+            if (!line.trim())
+                continue;
+            let parsed;
+            try {
+                parsed = JSON.parse(line);
+            }
+            catch {
+                continue;
+            }
+            if (parsed.type !== "assistant" || !parsed.message?.usage)
+                continue;
+            const ts = new Date(parsed.timestamp).getTime();
+            if (isNaN(ts) || ts < cutoff30d)
+                continue;
+            const usage = parsed.message.usage;
+            const requestId = parsed.requestId || "";
+            const sessionId = parsed.sessionId || "";
+            const dedupeKey = requestId
+                ? `${sessionId}:${requestId}`
+                : `${sessionId}:${parsed.timestamp}:${usage.input_tokens}:${usage.output_tokens}`;
+            if (seen.has(dedupeKey))
+                continue;
+            seen.add(dedupeKey);
+            const model = parsed.message.model || "unknown";
+            const inputTokens = usage.input_tokens || 0;
+            const outputTokens = usage.output_tokens || 0;
+            const cacheCreationTokens = usage.cache_creation_input_tokens || 0;
+            const cacheReadTokens = usage.cache_read_input_tokens || 0;
+            const cost = calculateCost(model, inputTokens, outputTokens, cacheCreationTokens, cacheReadTokens);
+            cost30d += cost;
+            if (ts >= cutoff7d) {
+                cost7d += cost;
+            }
+        }
+    }
+    return { cost7d, cost30d };
+}

package/dist/statusline.d.ts

@@ -0,0 +1 @@
+export declare function render(input: string): string;

package/dist/statusline.js

@@ -0,0 +1,102 @@
+import { readFileSync } from "node:fs";
+import { readCache, readConfig } from "./cache.js";
+// ANSI colors (matching original statusline.sh)
+const FG_GRAY = "\x1b[38;5;245m";
+const FG_GRAY_DIM = "\x1b[38;5;102m";
+const FG_YELLOW = "\x1b[38;2;229;192;123m";
+const FG_GREEN = "\x1b[38;5;29m";
+const FG_ORANGE = "\x1b[38;5;208m";
+const FG_RED = "\x1b[38;5;167m";
+const FG_MODEL = "\x1b[38;2;202;124;94m";
+const FG_CYAN = "\x1b[38;5;109m";
+const RESET = "\x1b[0m";
+function formatTokens(t) {
+    if (t >= 1_000_000)
+        return (t / 1_000_000).toFixed(1) + "M";
+    if (t >= 1_000)
+        return (t / 1_000).toFixed(1) + "k";
+    return String(t);
+}
+function formatCost(n) {
+    if (n >= 1000)
+        return "$" + Math.round(n).toLocaleString("en-US");
+    if (n >= 100)
+        return "$" + n.toFixed(0);
+    if (n >= 10)
+        return "$" + n.toFixed(1);
+    return "$" + n.toFixed(2);
+}
+function ctxColor(pct) {
+    if (pct >= 80)
+        return FG_RED;
+    if (pct >= 60)
+        return FG_ORANGE;
+    return FG_GREEN;
+}
+export function render(input) {
+    let data;
+    try {
+        data = JSON.parse(input);
+    }
+    catch {
+        return "";
+    }
+    // Session data from Claude Code stdin
+    const cost = data.cost?.total_cost_usd ?? 0;
+    const linesAdd = data.cost?.total_lines_added ?? 0;
+    const linesDel = data.cost?.total_lines_removed ?? 0;
+    const model = data.model?.display_name ?? "—";
+    const contextPct = Math.floor(data.context_window?.used_percentage ?? 0);
+    // Token stats from transcript
+    let inTokens = 0;
+    let outTokens = 0;
+    const transcriptPath = data.transcript_path ?? "";
+    if (transcriptPath) {
+        try {
+            const content = readFileSync(transcriptPath, "utf-8");
+            const lines = content.split("\n");
+            for (const line of lines) {
+                if (!line.trim())
+                    continue;
+                try {
+                    const entry = JSON.parse(line);
+                    if (entry.type === "assistant" && entry.message?.usage) {
+                        inTokens += entry.message.usage.input_tokens || 0;
+                        outTokens += entry.message.usage.output_tokens || 0;
+                    }
+                }
+                catch {
+                    // skip malformed lines
+                }
+            }
+        }
+        catch {
+            // transcript not readable
+        }
+    }
+    const inFmt = formatTokens(inTokens);
+    const outFmt = formatTokens(outTokens);
+    // Cached cost data
+    const cache = readCache();
+    const config = readConfig();
+    let costSuffix = "";
+    if (cache) {
+        const { period } = config;
+        if (period === "7d") {
+            costSuffix = ` ${FG_CYAN}(7d:${formatCost(cache.cost7d)})${RESET}`;
+        }
+        else if (period === "30d") {
+            costSuffix = ` ${FG_CYAN}(30d:${formatCost(cache.cost30d)})${RESET}`;
+        }
+        else {
+            costSuffix = ` ${FG_CYAN}(7d:${formatCost(cache.cost7d)} 30d:${formatCost(cache.cost30d)})${RESET}`;
+        }
+    }
+    const parts = [
+        `${FG_GRAY_DIM}Token: ↑${inFmt} ↓${outFmt}${RESET}`,
+        `${FG_YELLOW}${formatCost(cost)}${costSuffix}${RESET}`,
+        `${FG_GRAY_DIM}Code: ${FG_GREEN}+${linesAdd}${RESET} ${FG_GRAY_DIM}-${linesDel}${RESET}`,
+        `${ctxColor(contextPct)}${contextPct}%${RESET} ${FG_GRAY_DIM}by${RESET} ${FG_MODEL}${model}${RESET}`,
+    ];
+    return "\n " + parts.join(` ${FG_GRAY}|${RESET} `) + "\n";
+}

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "cc-costline",
+  "version": "0.1.0",
+  "description": "Enhanced statusline for Claude Code with 7d/30d cost tracking",
+  "type": "module",
+  "bin": {
+    "cc-costline": "dist/cli.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch"
+  },
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=22"
+  },
+  "keywords": [
+    "claude-code",
+    "statusline",
+    "cost-tracking"
+  ],
+  "author": "ventuss",
+  "license": "MIT",
+  "devDependencies": {
+    "typescript": "^5.7.0"
+  }
+}