nemonix-cli 1.0.0

package/src/config/claude-code-config/scripts/statusline/src/debug-payloads.ts

@@ -0,0 +1,195 @@
+#!/usr/bin/env bun
+
+import {
+	getPayloadsGroupedBySession,
+	getTodayPayloads,
+	type PayloadLogEntry,
+	readPayloadLogs,
+	rotatePayloadLogs,
+} from "./lib/features/spend/payload-logger";
+import { colors } from "./lib/formatters";
+
+function formatCost(cost: number): string {
+	return `$${cost.toFixed(4)}`;
+}
+
+function formatDuration(ms: number): string {
+	const minutes = Math.floor(ms / 60000);
+	const hours = Math.floor(minutes / 60);
+	if (hours > 0) {
+		return `${hours}h${minutes % 60}m`;
+	}
+	return `${minutes}m`;
+}
+
+function analyzeSessionProgression(entries: PayloadLogEntry[]): void {
+	if (entries.length === 0) return;
+
+	const sorted = [...entries].sort(
+		(a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime(),
+	);
+
+	console.log(
+		`  ${colors.gray("Events:")} ${sorted.length} | ${colors.gray("First:")} ${sorted[0].timestamp.split("T")[1].split(".")[0]} | ${colors.gray("Last:")} ${sorted[sorted.length - 1].timestamp.split("T")[1].split(".")[0]}`,
+	);
+
+	let prevCost = 0;
+	let anomalies = 0;
+
+	for (const entry of sorted) {
+		const costDelta = entry.total_cost_usd - prevCost;
+		const ctx = entry.context;
+
+		if (ctx) {
+			const flags = [];
+			if (ctx.is_new_session) flags.push(colors.yellow("NEW"));
+			if (ctx.is_clear_continuation) flags.push(colors.red("CLEAR"));
+			if (ctx.delta_cost && ctx.delta_cost < 0) {
+				flags.push(colors.red("NEG_DELTA"));
+				anomalies++;
+			}
+			if (costDelta < 0) {
+				flags.push(colors.red("COST_DROP"));
+				anomalies++;
+			}
+
+			if (flags.length > 0 || costDelta > 1) {
+				console.log(
+					`    ${entry.timestamp.split("T")[1].split(".")[0]} | ${formatCost(entry.total_cost_usd)} (Δ${formatCost(costDelta)}) | ctx_delta: ${formatCost(ctx.delta_cost ?? 0)} | ${flags.join(" ")}`,
+				);
+			}
+		}
+
+		prevCost = entry.total_cost_usd;
+	}
+
+	if (anomalies > 0) {
+		console.log(colors.red(`  ⚠ ${anomalies} anomalies detected`));
+	}
+}
+
+function showTodaySummary(): void {
+	const entries = getTodayPayloads();
+
+	console.log(`\n${colors.lightGray("Today's Payload Summary")}\n`);
+	console.log(`${colors.gray("Total events:")} ${entries.length}`);
+
+	if (entries.length === 0) {
+		console.log(colors.yellow("No payloads logged today yet."));
+		return;
+	}
+
+	const grouped = new Map<string, PayloadLogEntry[]>();
+	for (const entry of entries) {
+		const existing = grouped.get(entry.session_id) || [];
+		existing.push(entry);
+		grouped.set(entry.session_id, existing);
+	}
+
+	console.log(`${colors.gray("Unique sessions:")} ${grouped.size}\n`);
+
+	const sessions = Array.from(grouped.entries())
+		.map(([id, entries]) => ({
+			id,
+			entries,
+			lastCost: entries[entries.length - 1].total_cost_usd,
+			eventCount: entries.length,
+		}))
+		.sort((a, b) => b.lastCost - a.lastCost);
+
+	console.log(colors.gray("Sessions by cost (descending):"));
+
+	for (const session of sessions.slice(0, 20)) {
+		const firstEntry = session.entries[0];
+		const cwdShort = firstEntry.cwd.split("/").slice(-2).join("/");
+
+		console.log(
+			`\n${colors.lightGray(session.id.slice(0, 8))} | ${colors.gray(cwdShort)} | ${formatCost(session.lastCost)}`,
+		);
+		analyzeSessionProgression(session.entries);
+	}
+}
+
+function showAllSessions(): void {
+	const grouped = getPayloadsGroupedBySession();
+
+	console.log(`\n${colors.lightGray("All Sessions Analysis")}\n`);
+	console.log(`${colors.gray("Total unique sessions:")} ${grouped.size}`);
+
+	const totalEntries = readPayloadLogs().length;
+	console.log(`${colors.gray("Total logged events:")} ${totalEntries}\n`);
+
+	const sessions = Array.from(grouped.entries())
+		.map(([id, entries]) => ({
+			id,
+			entries,
+			lastCost: entries[entries.length - 1].total_cost_usd,
+			firstTimestamp: entries[0].timestamp,
+		}))
+		.sort(
+			(a, b) =>
+				new Date(b.firstTimestamp).getTime() -
+				new Date(a.firstTimestamp).getTime(),
+		);
+
+	console.log(colors.gray("Recent sessions:"));
+
+	for (const session of sessions.slice(0, 10)) {
+		const firstEntry = session.entries[0];
+		const cwdShort = firstEntry.cwd.split("/").slice(-2).join("/");
+		const date = session.firstTimestamp.split("T")[0];
+
+		console.log(
+			`\n${colors.lightGray(session.id.slice(0, 8))} | ${date} | ${colors.gray(cwdShort)} | ${formatCost(session.lastCost)}`,
+		);
+		analyzeSessionProgression(session.entries);
+	}
+}
+
+function showHelp(): void {
+	console.log(`
+${colors.lightGray("Statusline Payload Debug Tool")}
+
+${colors.gray("Usage:")}
+  bun run statusline:debug [command]
+
+${colors.gray("Commands:")}
+  today     Show today's payload summary (default)
+  all       Show all sessions analysis
+  rotate    Rotate log file (keep last 10000 entries)
+  help      Show this help
+
+${colors.gray("Examples:")}
+  bun run statusline:debug
+  bun run statusline:debug today
+  bun run statusline:debug all
+  bun run statusline:debug rotate
+`);
+}
+
+async function main(): Promise<void> {
+	const command = process.argv[2] || "today";
+
+	switch (command) {
+		case "today":
+			showTodaySummary();
+			break;
+		case "all":
+			showAllSessions();
+			break;
+		case "rotate":
+			rotatePayloadLogs();
+			console.log(colors.green("✓ Log file rotated"));
+			break;
+		case "help":
+		case "--help":
+		case "-h":
+			showHelp();
+			break;
+		default:
+			console.log(colors.red(`Unknown command: ${command}`));
+			showHelp();
+	}
+}
+
+main();

package/src/config/claude-code-config/scripts/statusline/src/index.ts

@@ -0,0 +1,224 @@
+#!/usr/bin/env bun
+
+import { readFile, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { defaultConfig, type StatuslineConfig } from "./lib/config";
+import { getContextData } from "./lib/context";
+import {
+	colors,
+	formatBranch,
+	formatCost,
+	formatDuration,
+	formatPath,
+} from "./lib/formatters";
+import { getGitStatus } from "./lib/git";
+import {
+	renderStatusline,
+	type StatuslineData,
+	type UsageLimit,
+} from "./lib/render-pure";
+import type { HookInput } from "./lib/types";
+
+// Optional feature imports - just delete the folder to disable!
+let getUsageLimits: any = null;
+let normalizeResetsAt: any = null;
+let getPeriodCost: any = null;
+let getTodayCostV2: any = null;
+let saveSessionV2: any = null;
+
+try {
+	const limitsModule = await import("./lib/features/limits");
+	getUsageLimits = limitsModule.getUsageLimits;
+} catch {
+	// Limits feature not available - that's OK!
+}
+
+try {
+	const utilsModule = await import("./lib/utils");
+	normalizeResetsAt = utilsModule.normalizeResetsAt;
+} catch {
+	// Fallback normalizeResetsAt
+	normalizeResetsAt = (resetsAt: string) => resetsAt;
+}
+
+let getTodayRealCost: (() => number) | null = null;
+try {
+	const spendModule = await import("./lib/features/spend");
+	getPeriodCost = spendModule.getPeriodCost;
+	getTodayCostV2 = spendModule.getTodayCostV2;
+	saveSessionV2 = spendModule.saveSessionV2;
+} catch {
+	// Spend tracking feature not available - that's OK!
+}
+
+try {
+	const loggerModule = await import("./lib/features/spend/payload-logger");
+	getTodayRealCost = loggerModule.getTodayRealCost;
+} catch {
+	// Payload logger not available
+}
+
+// Re-export from render-pure for backwards compatibility
+export {
+	renderStatusline,
+	type StatuslineData,
+	type UsageLimit,
+} from "./lib/render-pure";
+
+const CONFIG_FILE_PATH = join(import.meta.dir, "..", "statusline.config.json");
+const LAST_PAYLOAD_PATH = join(
+	import.meta.dir,
+	"..",
+	"data",
+	"last_payload.txt",
+);
+const CLAUDE_SETTINGS_PATH = join(
+	process.env.HOME || "",
+	".claude",
+	"settings.json",
+);
+
+interface ClaudeSettings {
+	alwaysThinkingEnabled?: boolean;
+}
+
+async function loadClaudeSettings(): Promise<ClaudeSettings> {
+	try {
+		const content = await readFile(CLAUDE_SETTINGS_PATH, "utf-8");
+		return JSON.parse(content);
+	} catch {
+		return {};
+	}
+}
+
+async function loadConfig(): Promise<StatuslineConfig> {
+	try {
+		const content = await readFile(CONFIG_FILE_PATH, "utf-8");
+		return JSON.parse(content);
+	} catch {
+		return defaultConfig;
+	}
+}
+
+async function main() {
+	try {
+		const input: HookInput = await Bun.stdin.json();
+
+		// Save last payload for debugging
+		await writeFile(LAST_PAYLOAD_PATH, JSON.stringify(input, null, 2));
+
+		const config = await loadConfig();
+		const claudeSettings = await loadClaudeSettings();
+
+		// Get usage limits (if feature exists)
+		const usageLimits = getUsageLimits
+			? await getUsageLimits()
+			: { five_hour: null, seven_day: null };
+		const currentResetsAt = usageLimits.five_hour?.resets_at ?? undefined;
+
+		// Save session with current period context (if feature exists)
+		if (saveSessionV2) {
+			await saveSessionV2(input, currentResetsAt);
+		}
+
+		const git = await getGitStatus();
+
+		let contextTokens: number | null;
+		let contextPercentage: number | null;
+
+		const usePayloadContext =
+			config.context.usePayloadContextWindow && input.context_window;
+
+		if (usePayloadContext) {
+			const current = input.context_window?.current_usage;
+			if (current) {
+				contextTokens =
+					(current.input_tokens || 0) +
+					(current.cache_creation_input_tokens || 0) +
+					(current.cache_read_input_tokens || 0);
+				const maxTokens =
+					input.context_window?.context_window_size ||
+					config.context.maxContextTokens;
+				contextPercentage = Math.min(
+					100,
+					Math.round((contextTokens / maxTokens) * 100),
+				);
+			} else {
+				// No context data yet - session not started
+				contextTokens = null;
+				contextPercentage = null;
+			}
+		} else {
+			const contextData = await getContextData({
+				transcriptPath: input.transcript_path,
+				maxContextTokens: config.context.maxContextTokens,
+				autocompactBufferTokens: config.context.autocompactBufferTokens,
+				useUsableContextOnly: config.context.useUsableContextOnly,
+				overheadTokens: config.context.overheadTokens,
+			});
+			contextTokens = contextData.tokens;
+			contextPercentage = contextData.percentage;
+		}
+
+		// Get period cost from SQLite (if feature exists)
+		let periodCost: number | undefined;
+		let todayCost: number | undefined;
+
+		if (getPeriodCost && normalizeResetsAt) {
+			const normalizedPeriodId = currentResetsAt
+				? normalizeResetsAt(currentResetsAt)
+				: null;
+			periodCost = normalizedPeriodId ? getPeriodCost(normalizedPeriodId) : 0;
+		}
+
+		// Get today's cost from payloads (more accurate than DB)
+		if (getTodayRealCost) {
+			todayCost = getTodayRealCost();
+		} else if (getTodayCostV2) {
+			todayCost = getTodayCostV2();
+		}
+
+		const data: StatuslineData = {
+			branch: formatBranch(git, config.git),
+			dirPath: formatPath(input.workspace.current_dir, config.pathDisplayMode),
+			modelName: input.model.display_name,
+			sessionCost: formatCost(
+				input.cost.total_cost_usd,
+				config.session.cost.format,
+			),
+			sessionDuration: formatDuration(input.cost.total_duration_ms),
+			contextTokens,
+			contextPercentage,
+			...(getUsageLimits && {
+				usageLimits: {
+					five_hour: usageLimits.five_hour
+						? {
+								utilization: usageLimits.five_hour.utilization,
+								resets_at: usageLimits.five_hour.resets_at,
+							}
+						: null,
+					seven_day: usageLimits.seven_day
+						? {
+								utilization: usageLimits.seven_day.utilization,
+								resets_at: usageLimits.seven_day.resets_at,
+							}
+						: null,
+				},
+			}),
+			...((getPeriodCost || getTodayCostV2) && { periodCost, todayCost }),
+			thinkingEnabled: claudeSettings.alwaysThinkingEnabled ?? true,
+		};
+
+		const output = renderStatusline(data, config);
+		console.log(output);
+		if (config.oneLine) {
+			console.log("");
+		}
+	} catch (error) {
+		const errorMessage = error instanceof Error ? error.message : String(error);
+		console.log(`${colors.red("Error:")} ${errorMessage}`);
+		console.log(colors.gray("Check statusline configuration"));
+	}
+}
+
+main();

package/src/config/claude-code-config/scripts/statusline/src/lib/config-types.ts

@@ -0,0 +1,110 @@
+export type Separator =
+	| "|"
+	| "•"
+	| "·"
+	| "⋅"
+	| "●"
+	| "◆"
+	| "▪"
+	| "▸"
+	| "›"
+	| "→";
+
+export type CostFormat = "integer" | "decimal1" | "decimal2";
+export type ProgressBarStyle = "filled" | "rectangle" | "braille";
+export type ProgressBarColor =
+	| "progressive"
+	| "green"
+	| "yellow"
+	| "red"
+	| "peach"
+	| "black"
+	| "white"
+	| "purple"
+	| "blue"
+	| "cyan";
+export type ProgressBarBackground =
+	| "none"
+	| "dark"
+	| "gray"
+	| "light"
+	| "blue"
+	| "purple"
+	| "cyan"
+	| "peach";
+
+export interface CostConfig {
+	enabled: boolean;
+	format: CostFormat;
+}
+
+export interface ProgressBarConfig {
+	enabled: boolean;
+	length: 5 | 10 | 15;
+	style: ProgressBarStyle;
+	color: ProgressBarColor;
+	background: ProgressBarBackground;
+}
+
+export interface PercentageConfig {
+	enabled: boolean;
+	showValue: boolean;
+	progressBar: ProgressBarConfig;
+}
+
+export interface StatuslineConfig {
+	features?: {
+		usageLimits?: boolean;
+		spendTracking?: boolean;
+	};
+	oneLine: boolean;
+	showSonnetModel: boolean;
+	pathDisplayMode: "full" | "truncated" | "basename";
+	git: {
+		enabled: boolean;
+		showBranch: boolean;
+		showDirtyIndicator: boolean;
+		showChanges: boolean;
+		showStaged: boolean;
+		showUnstaged: boolean;
+	};
+	separator: Separator;
+	session: {
+		infoSeparator: Separator | null;
+		cost: CostConfig;
+		duration: { enabled: boolean };
+		tokens: {
+			enabled: boolean;
+			showMax: boolean;
+			showDecimals: boolean;
+		};
+		percentage: PercentageConfig;
+	};
+	context: {
+		usePayloadContextWindow: boolean;
+		maxContextTokens: number;
+		autocompactBufferTokens: number;
+		useUsableContextOnly: boolean;
+		overheadTokens: number;
+	};
+	limits: {
+		enabled: boolean;
+		showTimeLeft: boolean;
+		showPacingDelta: boolean;
+		cost: CostConfig;
+		percentage: PercentageConfig;
+	};
+	weeklyUsage: {
+		enabled: boolean | "90%";
+		showTimeLeft: boolean;
+		showPacingDelta: boolean;
+		cost: CostConfig;
+		percentage: PercentageConfig;
+	};
+	dailySpend: {
+		cost: CostConfig;
+	};
+	thinking: {
+		showDisabledWarning: boolean;
+	};
+}

package/src/config/claude-code-config/scripts/statusline/src/lib/config.ts

@@ -0,0 +1,21 @@
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import type { StatuslineConfig } from "./config-types";
+
+const CONFIG_DIR = join(import.meta.dir, "..", "..");
+const DEFAULTS_PATH = join(CONFIG_DIR, "defaults.json");
+const CONFIG_PATH = join(CONFIG_DIR, "statusline.config.json");
+
+export const defaultConfig: StatuslineConfig = JSON.parse(
+	readFileSync(DEFAULTS_PATH, "utf-8"),
+);
+
+export function loadConfig(): StatuslineConfig {
+	try {
+		return JSON.parse(readFileSync(CONFIG_PATH, "utf-8"));
+	} catch {
+		return JSON.parse(JSON.stringify(defaultConfig));
+	}
+}
+
+export type { StatuslineConfig } from "./config-types";

package/src/config/claude-code-config/scripts/statusline/src/lib/context.ts

@@ -0,0 +1,103 @@
+import { existsSync } from "node:fs";
+
+export interface TokenUsage {
+	input_tokens: number;
+	output_tokens: number;
+	cache_creation_input_tokens?: number;
+	cache_read_input_tokens?: number;
+}
+
+export interface TranscriptLine {
+	message?: { usage?: TokenUsage };
+	timestamp?: string;
+	isSidechain?: boolean;
+	isApiErrorMessage?: boolean;
+}
+
+export interface ContextResult {
+	tokens: number;
+	percentage: number;
+}
+
+export async function getContextLength(
+	transcriptPath: string,
+): Promise<number> {
+	try {
+		const content = await Bun.file(transcriptPath).text();
+		const lines = content.trim().split("\n");
+
+		if (lines.length === 0) return 0;
+
+		let mostRecentMainChainEntry: TranscriptLine | null = null;
+		let mostRecentTimestamp: Date | null = null;
+
+		for (const line of lines) {
+			try {
+				const data = JSON.parse(line) as TranscriptLine;
+
+				if (!data.message?.usage) continue;
+				if (data.isSidechain === true) continue;
+				if (data.isApiErrorMessage === true) continue;
+				if (!data.timestamp) continue;
+
+				const entryTime = new Date(data.timestamp);
+
+				if (!mostRecentTimestamp || entryTime > mostRecentTimestamp) {
+					mostRecentTimestamp = entryTime;
+					mostRecentMainChainEntry = data;
+				}
+			} catch {}
+		}
+
+		if (!mostRecentMainChainEntry?.message?.usage) {
+			return 0;
+		}
+
+		const usage = mostRecentMainChainEntry.message.usage;
+
+		return (
+			(usage.input_tokens || 0) +
+			(usage.cache_read_input_tokens ?? 0) +
+			(usage.cache_creation_input_tokens ?? 0)
+		);
+	} catch {
+		return 0;
+	}
+}
+
+export interface ContextDataParams {
+	transcriptPath: string;
+	maxContextTokens: number;
+	autocompactBufferTokens: number;
+	useUsableContextOnly?: boolean;
+	overheadTokens?: number;
+}
+
+export async function getContextData({
+	transcriptPath,
+	maxContextTokens,
+	autocompactBufferTokens,
+	useUsableContextOnly = false,
+	overheadTokens = 0,
+}: ContextDataParams): Promise<ContextResult> {
+	if (!transcriptPath || !existsSync(transcriptPath)) {
+		return { tokens: 0, percentage: 0 };
+	}
+
+	const contextLength = await getContextLength(transcriptPath);
+	let totalTokens = contextLength + overheadTokens;
+
+	// If useUsableContextOnly is true, add the autocompact buffer to displayed tokens
+	if (useUsableContextOnly) {
+		totalTokens += autocompactBufferTokens;
+	}
+
+	// Always calculate percentage based on max context window
+	// (matching /context display behavior)
+	const percentage = Math.min(100, (totalTokens / maxContextTokens) * 100);
+
+	return {
+		tokens: totalTokens,
+		percentage: Math.round(percentage),
+	};
+}