aiblueprint-cli 1.4.12 → 1.4.13

package/claude-code-config/scripts/statusline/defaults.json

@@ -0,0 +1,75 @@
+{
+	"oneLine": true,
+	"showSonnetModel": false,
+	"pathDisplayMode": "truncated",
+	"git": {
+		"enabled": true,
+		"showBranch": true,
+		"showDirtyIndicator": true,
+		"showChanges": false,
+		"showStaged": true,
+		"showUnstaged": true
+	},
+	"separator": "•",
+	"session": {
+		"infoSeparator": null,
+		"cost": { "enabled": true, "format": "decimal1" },
+		"duration": { "enabled": true },
+		"tokens": { "enabled": true, "showMax": false, "showDecimals": false },
+		"percentage": {
+			"enabled": true,
+			"showValue": true,
+			"progressBar": {
+				"enabled": true,
+				"length": 10,
+				"style": "braille",
+				"color": "progressive",
+				"background": "none"
+			}
+		}
+	},
+	"context": {
+		"usePayloadContextWindow": true,
+		"maxContextTokens": 200000,
+		"autocompactBufferTokens": 45000,
+		"useUsableContextOnly": true,
+		"overheadTokens": 0
+	},
+	"limits": {
+		"enabled": true,
+		"showTimeLeft": true,
+		"showPacingDelta": true,
+		"cost": { "enabled": false, "format": "decimal1" },
+		"percentage": {
+			"enabled": true,
+			"showValue": true,
+			"progressBar": {
+				"enabled": true,
+				"length": 10,
+				"style": "braille",
+				"color": "progressive",
+				"background": "none"
+			}
+		}
+	},
+	"weeklyUsage": {
+		"enabled": "90%",
+		"showTimeLeft": true,
+		"showPacingDelta": true,
+		"cost": { "enabled": false, "format": "decimal1" },
+		"percentage": {
+			"enabled": true,
+			"showValue": true,
+			"progressBar": {
+				"enabled": true,
+				"length": 10,
+				"style": "braille",
+				"color": "progressive",
+				"background": "none"
+			}
+		}
+	},
+	"dailySpend": {
+		"cost": { "enabled": true, "format": "decimal1" }
+	}
+}

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

@@ -1,38 +1,115 @@
 #!/usr/bin/env bun
 
-import { defaultConfig } from "../statusline.config";
+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, formatPath, formatSession } from "./lib/formatters";
+import {
+	colors,
+	formatBranch,
+	formatCost,
+	formatDuration,
+	formatPath,
+} from "./lib/formatters";
+import { getGitStatus } from "./lib/git";
+import {
+	renderStatusline,
+	type StatuslineData,
+} from "./lib/render-pure";
 import type { HookInput } from "./lib/types";
 
+// Re-export from render-pure for backwards compatibility
+export {
+	renderStatusline,
+	type StatuslineData,
+} 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",
+);
+
+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();
 
-		const dirPath = formatPath(
-			input.workspace.current_dir,
-			defaultConfig.pathDisplayMode,
-		);
-
-		const contextData = await getContextData({
-			transcriptPath: input.transcript_path,
-			maxContextTokens: defaultConfig.context.maxContextTokens,
-		});
-
-		const sessionInfo = formatSession(
-			contextData.tokens,
-			contextData.percentage,
-			defaultConfig.session,
-		);
-
-		const sep = ` ${colors.GRAY}${defaultConfig.separator}${colors.LIGHT_GRAY} `;
-		console.log(`${colors.LIGHT_GRAY}${dirPath}${sep}${sessionInfo}${colors.RESET}`);
-		console.log("");
+		// Save last payload for debugging
+		await writeFile(LAST_PAYLOAD_PATH, JSON.stringify(input, null, 2));
+
+		const config = await loadConfig();
+		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;
+		}
+
+		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,
+		};
+
+		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:${colors.LIGHT_GRAY} ${errorMessage}${colors.RESET}`,
-		);
+		console.log(`${colors.red("Error:")} ${errorMessage}`);
+		console.log(colors.gray("Check statusline configuration"));
 	}
 }
 

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

@@ -0,0 +1,100 @@
+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";
+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 {
+	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;
+	};
+}

package/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/claude-code-config/scripts/statusline/src/lib/context.ts

@@ -1,12 +1,13 @@
 import { existsSync } from "node:fs";
 
-interface TokenUsage {
+export interface TokenUsage {
 	input_tokens: number;
+	output_tokens: number;
 	cache_creation_input_tokens?: number;
 	cache_read_input_tokens?: number;
 }
 
-interface TranscriptLine {
+export interface TranscriptLine {
 	message?: { usage?: TokenUsage };
 	timestamp?: string;
 	isSidechain?: boolean;
@@ -18,14 +19,16 @@ export interface ContextResult {
 	percentage: number;
 }
 
-async function getContextLength(transcriptPath: string): Promise<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 mostRecentEntry: TranscriptLine | null = null;
+		let mostRecentMainChainEntry: TranscriptLine | null = null;
 		let mostRecentTimestamp: Date | null = null;
 
 		for (const line of lines) {
@@ -41,16 +44,16 @@ async function getContextLength(transcriptPath: string): Promise<number> {
 
 				if (!mostRecentTimestamp || entryTime > mostRecentTimestamp) {
 					mostRecentTimestamp = entryTime;
-					mostRecentEntry = data;
+					mostRecentMainChainEntry = data;
 				}
 			} catch {}
 		}
 
-		if (!mostRecentEntry?.message?.usage) {
+		if (!mostRecentMainChainEntry?.message?.usage) {
 			return 0;
 		}
 
-		const usage = mostRecentEntry.message.usage;
+		const usage = mostRecentMainChainEntry.message.usage;
 
 		return (
 			(usage.input_tokens || 0) +
@@ -62,21 +65,39 @@ async function getContextLength(transcriptPath: string): Promise<number> {
 	}
 }
 
-interface ContextDataParams {
+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 tokens = await getContextLength(transcriptPath);
-	const percentage = Math.min(100, Math.round((tokens / maxContextTokens) * 100));
+	const contextLength = await getContextLength(transcriptPath);
+	let totalTokens = contextLength + overheadTokens;
 
-	return { tokens, percentage };
+	// 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),
+	};
 }