nemonix-cli 1.0.0

package/src/config/claude-code-config/scripts/statusline/src/tests/spend-v2.test.ts

@@ -0,0 +1,377 @@
+import { Database } from "bun:sqlite";
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { existsSync, rmSync } from "node:fs";
+import { join } from "node:path";
+
+const TEST_DB_PATH = join(import.meta.dir, "..", "..", "data", "test.db");
+
+describe("SQLite Delta Tracking", () => {
+	let db: Database;
+
+	beforeEach(() => {
+		if (existsSync(TEST_DB_PATH)) {
+			rmSync(TEST_DB_PATH);
+		}
+
+		db = new Database(TEST_DB_PATH);
+
+		db.run(`
+			CREATE TABLE sessions (
+				session_id TEXT PRIMARY KEY,
+				total_cost REAL NOT NULL DEFAULT 0,
+				cwd TEXT NOT NULL,
+				date TEXT NOT NULL,
+				duration_ms INTEGER NOT NULL DEFAULT 0,
+				lines_added INTEGER NOT NULL DEFAULT 0,
+				lines_removed INTEGER NOT NULL DEFAULT 0,
+				last_resets_at TEXT
+			)
+		`);
+
+		db.run(`
+			CREATE TABLE session_period_tracking (
+				session_id TEXT NOT NULL,
+				period_id TEXT NOT NULL,
+				counted_cost REAL NOT NULL DEFAULT 0,
+				last_session_cost REAL NOT NULL DEFAULT 0,
+				PRIMARY KEY (session_id, period_id)
+			)
+		`);
+
+		db.run(`
+			CREATE TABLE periods (
+				period_id TEXT PRIMARY KEY,
+				total_cost REAL NOT NULL DEFAULT 0,
+				utilization INTEGER NOT NULL DEFAULT 0,
+				date TEXT NOT NULL
+			)
+		`);
+	});
+
+	afterEach(() => {
+		db.close();
+		if (existsSync(TEST_DB_PATH)) {
+			rmSync(TEST_DB_PATH);
+		}
+	});
+
+	test("New session: full cost added to period", () => {
+		const sessionId = "session-1";
+		const periodId = "2025-12-09T10:00:00.000Z";
+		const sessionCost = 10.0;
+
+		db.run(
+			"INSERT INTO sessions (session_id, total_cost, cwd, date, last_resets_at) VALUES (?, ?, ?, ?, ?)",
+			[sessionId, sessionCost, "/test", "2025-12-09", periodId],
+		);
+
+		db.run(
+			"INSERT INTO session_period_tracking (session_id, period_id, counted_cost, last_session_cost) VALUES (?, ?, ?, ?)",
+			[sessionId, periodId, sessionCost, sessionCost],
+		);
+
+		db.run(
+			"INSERT INTO periods (period_id, total_cost, utilization, date) VALUES (?, ?, ?, ?)",
+			[periodId, sessionCost, 0, "2025-12-09"],
+		);
+
+		const period = db
+			.query<{ total_cost: number }, [string]>(
+				"SELECT total_cost FROM periods WHERE period_id = ?",
+			)
+			.get(periodId);
+
+		expect(period?.total_cost).toBe(10.0);
+	});
+
+	test("Continued session: only delta added to period", () => {
+		const sessionId = "session-1";
+		const periodId = "2025-12-09T10:00:00.000Z";
+
+		db.run(
+			"INSERT INTO sessions (session_id, total_cost, cwd, date, last_resets_at) VALUES (?, ?, ?, ?, ?)",
+			[sessionId, 10.0, "/test", "2025-12-09", periodId],
+		);
+
+		db.run(
+			"INSERT INTO session_period_tracking (session_id, period_id, counted_cost, last_session_cost) VALUES (?, ?, ?, ?)",
+			[sessionId, periodId, 10.0, 10.0],
+		);
+
+		db.run(
+			"INSERT INTO periods (period_id, total_cost, utilization, date) VALUES (?, ?, ?, ?)",
+			[periodId, 10.0, 0, "2025-12-09"],
+		);
+
+		const newSessionCost = 24.0;
+		const delta = newSessionCost - 10.0;
+
+		db.run("UPDATE sessions SET total_cost = ? WHERE session_id = ?", [
+			newSessionCost,
+			sessionId,
+		]);
+
+		const tracking = db
+			.query<
+				{ counted_cost: number; last_session_cost: number },
+				[string, string]
+			>(
+				"SELECT counted_cost, last_session_cost FROM session_period_tracking WHERE session_id = ? AND period_id = ?",
+			)
+			.get(sessionId, periodId);
+
+		const newCountedCost = (tracking?.counted_cost ?? 0) + delta;
+
+		db.run(
+			"UPDATE session_period_tracking SET counted_cost = ?, last_session_cost = ? WHERE session_id = ? AND period_id = ?",
+			[newCountedCost, newSessionCost, sessionId, periodId],
+		);
+
+		db.run(
+			"UPDATE periods SET total_cost = total_cost + ? WHERE period_id = ?",
+			[delta, periodId],
+		);
+
+		const period = db
+			.query<{ total_cost: number }, [string]>(
+				"SELECT total_cost FROM periods WHERE period_id = ?",
+			)
+			.get(periodId);
+		const updatedTracking = db
+			.query<{ counted_cost: number }, [string, string]>(
+				"SELECT counted_cost FROM session_period_tracking WHERE session_id = ? AND period_id = ?",
+			)
+			.get(sessionId, periodId);
+
+		expect(period?.total_cost).toBe(24.0);
+		expect(updatedTracking?.counted_cost).toBe(24.0);
+	});
+
+	test("Session spanning periods: only new delta in new period", () => {
+		const sessionId = "session-1";
+		const periodA = "2025-12-09T05:00:00.000Z";
+		const periodB = "2025-12-09T10:00:00.000Z";
+
+		db.run(
+			"INSERT INTO sessions (session_id, total_cost, cwd, date, last_resets_at) VALUES (?, ?, ?, ?, ?)",
+			[sessionId, 10.0, "/test", "2025-12-09", periodA],
+		);
+
+		db.run(
+			"INSERT INTO session_period_tracking (session_id, period_id, counted_cost, last_session_cost) VALUES (?, ?, ?, ?)",
+			[sessionId, periodA, 10.0, 10.0],
+		);
+
+		db.run(
+			"INSERT INTO periods (period_id, total_cost, utilization, date) VALUES (?, ?, ?, ?)",
+			[periodA, 10.0, 0, "2025-12-09"],
+		);
+
+		const newSessionCost = 24.0;
+		const session = db
+			.query<{ total_cost: number }, [string]>(
+				"SELECT total_cost FROM sessions WHERE session_id = ?",
+			)
+			.get(sessionId);
+		const delta = newSessionCost - (session?.total_cost ?? 0);
+
+		db.run(
+			"UPDATE sessions SET total_cost = ?, last_resets_at = ? WHERE session_id = ?",
+			[newSessionCost, periodB, sessionId],
+		);
+
+		db.run(
+			"INSERT INTO session_period_tracking (session_id, period_id, counted_cost, last_session_cost) VALUES (?, ?, ?, ?)",
+			[sessionId, periodB, delta, newSessionCost],
+		);
+
+		db.run(
+			"INSERT OR IGNORE INTO periods (period_id, total_cost, utilization, date) VALUES (?, ?, ?, ?)",
+			[periodB, 0, 0, "2025-12-09"],
+		);
+		db.run(
+			"UPDATE periods SET total_cost = total_cost + ? WHERE period_id = ?",
+			[delta, periodB],
+		);
+
+		const periodACost = db
+			.query<{ total_cost: number }, [string]>(
+				"SELECT total_cost FROM periods WHERE period_id = ?",
+			)
+			.get(periodA);
+		const periodBCost = db
+			.query<{ total_cost: number }, [string]>(
+				"SELECT total_cost FROM periods WHERE period_id = ?",
+			)
+			.get(periodB);
+		const trackingA = db
+			.query<{ counted_cost: number }, [string, string]>(
+				"SELECT counted_cost FROM session_period_tracking WHERE session_id = ? AND period_id = ?",
+			)
+			.get(sessionId, periodA);
+		const trackingB = db
+			.query<{ counted_cost: number }, [string, string]>(
+				"SELECT counted_cost FROM session_period_tracking WHERE session_id = ? AND period_id = ?",
+			)
+			.get(sessionId, periodB);
+
+		expect(periodACost?.total_cost).toBe(10.0);
+		expect(periodBCost?.total_cost).toBe(14.0);
+		expect(trackingA?.counted_cost).toBe(10.0);
+		expect(trackingB?.counted_cost).toBe(14.0);
+
+		expect(
+			(periodACost?.total_cost ?? 0) + (periodBCost?.total_cost ?? 0),
+		).toBe(24.0);
+	});
+
+	test("Multiple sessions in same period: costs sum correctly", () => {
+		const periodId = "2025-12-09T10:00:00.000Z";
+
+		db.run(
+			"INSERT INTO periods (period_id, total_cost, utilization, date) VALUES (?, ?, ?, ?)",
+			[periodId, 0, 0, "2025-12-09"],
+		);
+
+		const sessions = [
+			{ id: "session-1", cost: 10.0 },
+			{ id: "session-2", cost: 15.0 },
+			{ id: "session-3", cost: 8.0 },
+		];
+
+		for (const session of sessions) {
+			db.run(
+				"INSERT INTO sessions (session_id, total_cost, cwd, date, last_resets_at) VALUES (?, ?, ?, ?, ?)",
+				[session.id, session.cost, "/test", "2025-12-09", periodId],
+			);
+
+			db.run(
+				"INSERT INTO session_period_tracking (session_id, period_id, counted_cost, last_session_cost) VALUES (?, ?, ?, ?)",
+				[session.id, periodId, session.cost, session.cost],
+			);
+
+			db.run(
+				"UPDATE periods SET total_cost = total_cost + ? WHERE period_id = ?",
+				[session.cost, periodId],
+			);
+		}
+
+		const period = db
+			.query<{ total_cost: number }, [string]>(
+				"SELECT total_cost FROM periods WHERE period_id = ?",
+			)
+			.get(periodId);
+
+		expect(period?.total_cost).toBe(33.0);
+	});
+
+	test("No double counting: continuing old session after restart", () => {
+		const sessionId = "session-1";
+		const periodId = "2025-12-09T10:00:00.000Z";
+
+		db.run(
+			"INSERT INTO sessions (session_id, total_cost, cwd, date, last_resets_at) VALUES (?, ?, ?, ?, ?)",
+			[sessionId, 10.0, "/test", "2025-12-09", periodId],
+		);
+
+		db.run(
+			"INSERT INTO session_period_tracking (session_id, period_id, counted_cost, last_session_cost) VALUES (?, ?, ?, ?)",
+			[sessionId, periodId, 10.0, 10.0],
+		);
+
+		db.run(
+			"INSERT INTO periods (period_id, total_cost, utilization, date) VALUES (?, ?, ?, ?)",
+			[periodId, 10.0, 0, "2025-12-09"],
+		);
+
+		const tracking = db
+			.query<{ last_session_cost: number }, [string, string]>(
+				"SELECT last_session_cost FROM session_period_tracking WHERE session_id = ? AND period_id = ?",
+			)
+			.get(sessionId, periodId);
+
+		const currentSessionCost = 10.0;
+		const delta = currentSessionCost - (tracking?.last_session_cost ?? 0);
+
+		expect(delta).toBe(0);
+
+		const period = db
+			.query<{ total_cost: number }, [string]>(
+				"SELECT total_cost FROM periods WHERE period_id = ?",
+			)
+			.get(periodId);
+
+		expect(period?.total_cost).toBe(10.0);
+	});
+});
+
+describe("Smart Detection Logic", () => {
+	// Tests for the /clear vs independent session detection
+	// Key insight:
+	// - /clear creates NEW session with HIGH cost (billing continues)
+	// - Independent terminal creates NEW session with LOW cost
+
+	test("isClearContinuation: NEW session with cost > projectMax", () => {
+		const sessionCumulativeCounted = 0; // NEW session
+		const projectMaxCost = 5.0;
+		const newTotalCost = 10.0;
+
+		const isNewSession = sessionCumulativeCounted === 0;
+		const isClearContinuation = isNewSession && newTotalCost > projectMaxCost;
+
+		expect(isClearContinuation).toBe(true);
+
+		// Delta should be based on project max
+		const deltaCost = newTotalCost - projectMaxCost;
+		expect(deltaCost).toBe(5.0);
+	});
+
+	test("Independent terminal: NEW session with cost <= projectMax", () => {
+		const sessionCumulativeCounted = 0; // NEW session
+		const projectMaxCost = 5.0;
+		const newTotalCost = 3.0;
+
+		const isNewSession = sessionCumulativeCounted === 0;
+		const isClearContinuation = isNewSession && newTotalCost > projectMaxCost;
+
+		expect(isClearContinuation).toBe(false);
+
+		// Delta should be based on session tracking (which is 0 for new)
+		const deltaCost = Math.max(0, newTotalCost - sessionCumulativeCounted);
+		expect(deltaCost).toBe(3.0);
+	});
+
+	test("Continuing session: uses session-level tracking even when surpassing projectMax", () => {
+		// This is the edge case that was bugged before
+		// Session B started with $3, now reports $8, projectMax is $5
+		const sessionCumulativeCounted = 3.0; // NOT new, has history
+		const projectMaxCost = 5.0;
+		const newTotalCost = 8.0;
+
+		const isNewSession = sessionCumulativeCounted === 0;
+		const isClearContinuation = isNewSession && newTotalCost > projectMaxCost;
+
+		// Should NOT be treated as /clear continuation because session has history
+		expect(isClearContinuation).toBe(false);
+
+		// Delta should be session-based: $8 - $3 = $5
+		const deltaCost = Math.max(0, newTotalCost - sessionCumulativeCounted);
+		expect(deltaCost).toBe(5.0);
+
+		// NOT the buggy project-based delta: $8 - $5 = $3
+	});
+
+	test("Normal session continuation: uses session-level delta", () => {
+		const sessionCumulativeCounted = 10.0;
+		const projectMaxCost = 10.0;
+		const newTotalCost = 15.0;
+
+		const isNewSession = sessionCumulativeCounted === 0;
+		const isClearContinuation = isNewSession && newTotalCost > projectMaxCost;
+
+		expect(isClearContinuation).toBe(false);
+
+		const deltaCost = Math.max(0, newTotalCost - sessionCumulativeCounted);
+		expect(deltaCost).toBe(5.0);
+	});
+});

package/src/config/claude-code-config/scripts/statusline/src/tools/fixed-cost-calc.ts

@@ -0,0 +1,317 @@
+#!/usr/bin/env bun
+/**
+ * Fixed cost calculator - uses last chunk per message (fixes ccusage bug)
+ * Usage: bun run src/tools/fixed-cost-calc.ts [YYYY-MM-DD]
+ */
+
+import { readdirSync, readFileSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+// Pricing per million tokens
+const PRICING: Record<
+	string,
+	{ input: number; output: number; cacheCreate: number; cacheRead: number }
+> = {
+	"claude-sonnet-4-20250514": {
+		input: 3,
+		output: 15,
+		cacheCreate: 3.75,
+		cacheRead: 0.3,
+	},
+	"claude-opus-4-20250514": {
+		input: 15,
+		output: 75,
+		cacheCreate: 18.75,
+		cacheRead: 1.5,
+	},
+	"claude-opus-4-5-20251101": {
+		input: 5,
+		output: 25,
+		cacheCreate: 6.25,
+		cacheRead: 0.5,
+	},
+	"claude-haiku-4-5-20251001": {
+		input: 1,
+		output: 5,
+		cacheCreate: 1.25,
+		cacheRead: 0.1,
+	},
+	"claude-3-5-sonnet-20241022": {
+		input: 3,
+		output: 15,
+		cacheCreate: 3.75,
+		cacheRead: 0.3,
+	},
+};
+
+const DEFAULT_PRICING = {
+	input: 3,
+	output: 15,
+	cacheCreate: 3.75,
+	cacheRead: 0.3,
+};
+
+interface UsageData {
+	input_tokens?: number;
+	output_tokens?: number;
+	cache_creation_input_tokens?: number;
+	cache_read_input_tokens?: number;
+}
+
+interface MessageEntry {
+	timestamp: string;
+	type: string;
+	message?: {
+		id?: string;
+		model?: string;
+		usage?: UsageData;
+	};
+	requestId?: string;
+}
+
+function findJsonlFiles(dir: string, targetDate: string): string[] {
+	const files: string[] = [];
+
+	function walk(currentDir: string) {
+		try {
+			const entries = readdirSync(currentDir);
+			for (const entry of entries) {
+				const fullPath = join(currentDir, entry);
+				try {
+					const stat = statSync(fullPath);
+					if (stat.isDirectory()) {
+						walk(fullPath);
+					} else if (entry.endsWith(".jsonl")) {
+						// Check if file was modified on target date
+						const mtime = stat.mtime.toISOString().split("T")[0];
+						if (mtime === targetDate) {
+							files.push(fullPath);
+						}
+					}
+				} catch {
+					// Skip inaccessible files
+				}
+			}
+		} catch {
+			// Skip inaccessible directories
+		}
+	}
+
+	walk(dir);
+	return files;
+}
+
+function parseJsonlFile(filePath: string): MessageEntry[] {
+	try {
+		const content = readFileSync(filePath, "utf-8");
+		const lines = content.split("\n").filter((line) => line.trim());
+		return lines
+			.map((line) => {
+				try {
+					return JSON.parse(line) as MessageEntry;
+				} catch {
+					return null;
+				}
+			})
+			.filter((entry): entry is MessageEntry => entry !== null);
+	} catch {
+		return [];
+	}
+}
+
+function createUniqueHash(entry: MessageEntry): string | null {
+	const messageId = entry.message?.id;
+	const requestId = entry.requestId;
+	if (!messageId || !requestId) return null;
+	return `${messageId}:${requestId}`;
+}
+
+interface TokenTotals {
+	input: number;
+	output: number;
+	cacheCreate: number;
+	cacheRead: number;
+	cost: number;
+}
+
+function main() {
+	const targetDate = process.argv[2] || new Date().toISOString().split("T")[0];
+	const projectFilter = process.argv[3]; // Optional: filter to specific project
+	const claudeDir = join(homedir(), ".claude", "projects");
+
+	console.log(`\n📊 Fixed Cost Calculator (Last-Chunk Method)`);
+	console.log(`📅 Date: ${targetDate}`);
+
+	let scanDir = claudeDir;
+	if (projectFilter) {
+		// Find matching project directory
+		const entries = readdirSync(claudeDir);
+		const match = entries.find((e) =>
+			e.toLowerCase().includes(projectFilter.toLowerCase()),
+		);
+		if (match) {
+			scanDir = join(claudeDir, match);
+			console.log(`📁 Project: ${match}`);
+		}
+	}
+	console.log(`📁 Scanning: ${scanDir}\n`);
+
+	const files = findJsonlFiles(scanDir, targetDate);
+	console.log(`Found ${files.length} JSONL files modified on ${targetDate}\n`);
+
+	// Track last entry per unique hash (THE FIX)
+	const lastEntryPerHash = new Map<
+		string,
+		{ entry: MessageEntry; model: string }
+	>();
+
+	// Also track buggy first-entry for comparison
+	const firstEntryPerHash = new Map<
+		string,
+		{ entry: MessageEntry; model: string }
+	>();
+
+	for (const file of files) {
+		const entries = parseJsonlFile(file);
+
+		for (const entry of entries) {
+			if (entry.type !== "assistant" || !entry.message?.usage) continue;
+
+			const hash = createUniqueHash(entry);
+			if (!hash) continue;
+
+			const model = entry.message.model || "unknown";
+
+			// FIXED: Keep LAST entry (overwrite)
+			lastEntryPerHash.set(hash, { entry, model });
+
+			// BUGGY: Keep FIRST entry (skip if exists)
+			if (!firstEntryPerHash.has(hash)) {
+				firstEntryPerHash.set(hash, { entry, model });
+			}
+		}
+	}
+
+	// Calculate totals per model - FIXED
+	const fixedTotals = new Map<string, TokenTotals>();
+	for (const { entry, model } of lastEntryPerHash.values()) {
+		const usage = entry.message?.usage;
+		if (!usage) continue;
+
+		if (!fixedTotals.has(model)) {
+			fixedTotals.set(model, {
+				input: 0,
+				output: 0,
+				cacheCreate: 0,
+				cacheRead: 0,
+				cost: 0,
+			});
+		}
+
+		const totals = fixedTotals.get(model)!;
+		totals.input += usage.input_tokens || 0;
+		totals.output += usage.output_tokens || 0;
+		totals.cacheCreate += usage.cache_creation_input_tokens || 0;
+		totals.cacheRead += usage.cache_read_input_tokens || 0;
+	}
+
+	// Calculate totals per model - BUGGY
+	const buggyTotals = new Map<string, TokenTotals>();
+	for (const { entry, model } of firstEntryPerHash.values()) {
+		const usage = entry.message?.usage;
+		if (!usage) continue;
+
+		if (!buggyTotals.has(model)) {
+			buggyTotals.set(model, {
+				input: 0,
+				output: 0,
+				cacheCreate: 0,
+				cacheRead: 0,
+				cost: 0,
+			});
+		}
+
+		const totals = buggyTotals.get(model)!;
+		totals.input += usage.input_tokens || 0;
+		totals.output += usage.output_tokens || 0;
+		totals.cacheCreate += usage.cache_creation_input_tokens || 0;
+		totals.cacheRead += usage.cache_read_input_tokens || 0;
+	}
+
+	// Calculate costs
+	function calcCost(totals: Map<string, TokenTotals>): number {
+		let totalCost = 0;
+		for (const [model, t] of totals) {
+			const pricing = PRICING[model] || DEFAULT_PRICING;
+			t.cost =
+				(t.input * pricing.input +
+					t.output * pricing.output +
+					t.cacheCreate * pricing.cacheCreate +
+					t.cacheRead * pricing.cacheRead) /
+				1_000_000;
+			totalCost += t.cost;
+		}
+		return totalCost;
+	}
+
+	const fixedTotal = calcCost(fixedTotals);
+	const buggyTotal = calcCost(buggyTotals);
+
+	// Display results
+	console.log("═".repeat(70));
+	console.log("FIXED CALCULATION (Last Chunk - Correct)");
+	console.log("═".repeat(70));
+
+	for (const [model, t] of fixedTotals) {
+		const shortModel = model
+			.replace("claude-", "")
+			.replace("-20251001", "")
+			.replace("-20251101", "")
+			.replace("-20250514", "")
+			.replace("-20241022", "");
+		console.log(`\n  ${shortModel}:`);
+		console.log(
+			`    Input:        ${t.input.toLocaleString().padStart(12)} tokens`,
+		);
+		console.log(
+			`    Output:       ${t.output.toLocaleString().padStart(12)} tokens`,
+		);
+		console.log(
+			`    Cache Create: ${t.cacheCreate.toLocaleString().padStart(12)} tokens`,
+		);
+		console.log(
+			`    Cache Read:   ${t.cacheRead.toLocaleString().padStart(12)} tokens`,
+		);
+		console.log(`    Cost:         $${t.cost.toFixed(2)}`);
+	}
+
+	console.log(`\n  ${"─".repeat(40)}`);
+	console.log(`  TOTAL: $${fixedTotal.toFixed(2)}`);
+
+	// Comparison
+	console.log("\n");
+	console.log("═".repeat(70));
+	console.log("COMPARISON");
+	console.log("═".repeat(70));
+
+	let totalFixedOutput = 0;
+	let totalBuggyOutput = 0;
+	for (const t of fixedTotals.values()) totalFixedOutput += t.output;
+	for (const t of buggyTotals.values()) totalBuggyOutput += t.output;
+
+	console.log(`\n  Fixed (correct):  $${fixedTotal.toFixed(2)}`);
+	console.log(`  Buggy (ccusage):  $${buggyTotal.toFixed(2)}`);
+	console.log(
+		`  Difference:       $${(fixedTotal - buggyTotal).toFixed(2)} (${((1 - buggyTotal / fixedTotal) * 100).toFixed(1)}% underreported)`,
+	);
+	console.log(`\n  Output tokens:`);
+	console.log(`    Fixed: ${totalFixedOutput.toLocaleString()}`);
+	console.log(`    Buggy: ${totalBuggyOutput.toLocaleString()}`);
+	console.log(
+		`    Ratio: ${(totalFixedOutput / totalBuggyOutput).toFixed(1)}x undercount`,
+	);
+	console.log();
+}
+
+main();