aiblueprint-cli 1.4.12 → 1.4.13

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

@@ -1,48 +1,386 @@
-import type { StatuslineConfig } from "../../statusline.config";
+import { homedir } from "node:os";
+import { sep } from "node:path";
+import pc from "picocolors";
+import type {
+	CostFormat,
+	ProgressBarBackground,
+	ProgressBarColor,
+	ProgressBarStyle,
+	StatuslineConfig,
+} from "./config-types";
+import type { GitStatus } from "./git";
+
+type ColorFunction = (text: string | number) => string;
+
+const pico = pc.createColors(true);
 
 export const colors = {
-	GRAY: "\x1b[0;90m",
-	LIGHT_GRAY: "\x1b[0;37m",
-	RESET: "\x1b[0m",
+	green: pico.green as ColorFunction,
+	red: pico.red as ColorFunction,
+	purple: pico.magenta as ColorFunction,
+	yellow: pico.yellow as ColorFunction,
+	orange: ((text: string | number) =>
+		`\x1b[38;5;208m${text}\x1b[0m`) as ColorFunction,
+	peach: ((text: string | number) =>
+		`\x1b[38;2;222;115;86m${text}\x1b[0m`) as ColorFunction,
+	bgPeach: ((text: string | number) =>
+		`\x1b[48;2;222;115;86m${text}\x1b[0m`) as ColorFunction,
+	black: ((text: string | number) =>
+		`\x1b[38;2;0;0;0m${text}\x1b[39m`) as ColorFunction,
+	white: ((text: string | number) =>
+		`\x1b[38;2;255;255;255m${text}\x1b[39m`) as ColorFunction,
+	gray: pico.gray as ColorFunction,
+	dimWhite: ((text: string | number) =>
+		`\x1b[37m${text}\x1b[39m`) as ColorFunction,
+	lightGray: pico.whiteBright as ColorFunction,
+	cyan: pico.cyan as ColorFunction,
+	blue: pico.blue as ColorFunction,
+	bgBlack: pico.bgBlack as ColorFunction,
+	bgBlackBright: pico.bgBlackBright as ColorFunction,
+	bgWhite: pico.bgWhite as ColorFunction,
+	bgBlue: pico.bgBlue as ColorFunction,
+	bgMagenta: pico.bgMagenta as ColorFunction,
+	bgCyan: pico.bgCyan as ColorFunction,
+	dim: pico.dim as ColorFunction,
+	bold: pico.bold as ColorFunction,
+	hidden: pico.hidden as ColorFunction,
+	italic: pico.italic as ColorFunction,
+	underline: pico.underline as ColorFunction,
+	strikethrough: pico.strikethrough as ColorFunction,
+	reset: pico.reset as ColorFunction,
+	inverse: pico.inverse as ColorFunction,
 } as const;
 
-export function formatPath(path: string, _mode: "full"): string {
-	const home = process.env.HOME || "";
+export function formatBranch(
+	git: GitStatus,
+	gitConfig: StatuslineConfig["git"],
+): string {
+	let result = "";
+
+	if (gitConfig.showBranch) {
+		result = colors.lightGray(git.branch);
+	}
+
+	if (git.hasChanges) {
+		const changes: string[] = [];
+
+		if (gitConfig.showDirtyIndicator) {
+			result += colors.purple("*");
+		}
+
+		if (gitConfig.showChanges) {
+			const totalAdded = git.staged.added + git.unstaged.added;
+			const totalDeleted = git.staged.deleted + git.unstaged.deleted;
+
+			if (totalAdded > 0) {
+				changes.push(colors.green(`+${totalAdded}`));
+			}
+			if (totalDeleted > 0) {
+				changes.push(colors.red(`-${totalDeleted}`));
+			}
+		}
+
+		if (gitConfig.showStaged && git.staged.files > 0) {
+			changes.push(colors.gray(`~${git.staged.files}`));
+		}
+
+		if (gitConfig.showUnstaged && git.unstaged.files > 0) {
+			changes.push(colors.yellow(`~${git.unstaged.files}`));
+		}
+
+		if (changes.length > 0) {
+			result += ` ${changes.join(" ")}`;
+		}
+	}
+
+	return result;
+}
+
+export function formatPath(
+	path: string,
+	mode: "full" | "truncated" | "basename" = "truncated",
+): string {
+	const home = homedir();
+	let formattedPath = path;
+
 	if (home && path.startsWith(home)) {
-		return `~${path.slice(home.length)}`;
+		formattedPath = `~${path.slice(home.length)}`;
+	}
+
+	if (mode === "basename") {
+		const segments = path.split(/[/\\]/).filter((s) => s.length > 0);
+		return segments[segments.length - 1] || path;
 	}
-	return path;
+
+	if (mode === "truncated") {
+		const segments = formattedPath.split(/[/\\]/).filter((s) => s.length > 0);
+		if (segments.length > 2) {
+			return `…${sep}${segments.slice(-2).join(sep)}`;
+		}
+	}
+
+	return formattedPath;
+}
+
+export function formatCost(
+	cost: number,
+	format: CostFormat = "decimal1",
+): string {
+	if (format === "integer") return Math.round(cost).toString();
+	if (format === "decimal1") return cost.toFixed(1);
+	return cost.toFixed(2);
 }
 
-function formatTokens(tokens: number): string {
+export function formatTokens(tokens: number, showDecimals = true): string {
 	if (tokens >= 1000000) {
-		const value = Math.round(tokens / 1000000);
-		return `${value}${colors.GRAY}m${colors.LIGHT_GRAY}`;
+		const value = tokens / 1000000;
+		const number = showDecimals
+			? value.toFixed(1)
+			: Math.round(value).toString();
+		return `${colors.lightGray(number)}${colors.gray("m")}`;
 	}
 	if (tokens >= 1000) {
-		const value = Math.round(tokens / 1000);
-		return `${value}${colors.GRAY}k${colors.LIGHT_GRAY}`;
+		const value = tokens / 1000;
+		const number = showDecimals
+			? value.toFixed(1)
+			: Math.round(value).toString();
+		return `${colors.lightGray(number)}${colors.gray("k")}`;
+	}
+	return colors.lightGray(tokens.toString());
+}
+
+export function formatDuration(ms: number): string {
+	const minutes = Math.floor(ms / 60000);
+	const hours = Math.floor(minutes / 60);
+	const mins = minutes % 60;
+
+	if (hours > 0) {
+		return `${hours}h ${mins}m`;
+	}
+	return `${mins}m`;
+}
+
+export function formatResetTime(resetsAt: string): string {
+	try {
+		const resetDate = new Date(resetsAt);
+		if (Number.isNaN(resetDate.getTime())) {
+			return "N/A";
+		}
+
+		const now = new Date();
+		const diffMs = resetDate.getTime() - now.getTime();
+
+		if (diffMs <= 0) {
+			return "now";
+		}
+
+		const hours = Math.floor(diffMs / 3600000);
+		const minutes = Math.floor((diffMs % 3600000) / 60000);
+
+		if (hours > 0) {
+			return `${hours}h${minutes}m`;
+		}
+		return `${minutes}m`;
+	} catch {
+		return "N/A";
+	}
+}
+
+function getProgressBarColor(
+	percentage: number,
+	colorMode: ProgressBarColor,
+): ColorFunction {
+	if (colorMode === "progressive") {
+		if (percentage < 50) return colors.gray;
+		if (percentage < 70) return colors.yellow;
+		if (percentage < 90) return colors.orange;
+		return colors.red;
 	}
-	return tokens.toString();
+	if (colorMode === "green") return colors.green;
+	if (colorMode === "yellow") return colors.yellow;
+	if (colorMode === "peach") return colors.peach;
+	if (colorMode === "black") return colors.black;
+	if (colorMode === "white") return colors.white;
+	return colors.red;
+}
+
+function getProgressBarBackground(
+	background: ProgressBarBackground,
+): ColorFunction | null {
+	if (background === "none") return null;
+	if (background === "dark") return colors.bgBlack;
+	if (background === "gray") return colors.bgBlackBright;
+	if (background === "light") return colors.bgWhite;
+	if (background === "blue") return colors.bgBlue;
+	if (background === "purple") return colors.bgMagenta;
+	if (background === "cyan") return colors.bgCyan;
+	if (background === "peach") return colors.bgPeach;
+	return null;
+}
+
+export function formatProgressBarFilled(
+	percentage: number,
+	length: number,
+	colorMode: ProgressBarColor,
+	background: ProgressBarBackground,
+): string {
+	const filled = Math.round((percentage / 100) * length);
+	const empty = length - filled;
+
+	const filledBar = "█".repeat(filled);
+	const emptyBar = "░".repeat(empty);
+	const colorFn = getProgressBarColor(percentage, colorMode);
+	const bgFn = getProgressBarBackground(background);
+
+	const coloredFilled = bgFn ? bgFn(colorFn(filledBar)) : colorFn(filledBar);
+	const coloredEmpty = bgFn ? bgFn(colorFn(emptyBar)) : colorFn(emptyBar);
+
+	return `${coloredFilled}${coloredEmpty}`;
+}
+
+export function formatProgressBarRectangle(
+	percentage: number,
+	length: number,
+	colorMode: ProgressBarColor,
+	background: ProgressBarBackground,
+): string {
+	const filled = Math.round((percentage / 100) * length);
+	const empty = length - filled;
+
+	const filledBar = "▰".repeat(filled);
+	const emptyBar = "▱".repeat(empty);
+	const colorFn = getProgressBarColor(percentage, colorMode);
+	const bgFn = getProgressBarBackground(background);
+
+	const coloredFilled = bgFn ? bgFn(colorFn(filledBar)) : colorFn(filledBar);
+	const coloredEmpty = bgFn ? bgFn(colorFn(emptyBar)) : colorFn(emptyBar);
+
+	return `${coloredFilled}${coloredEmpty}`;
+}
+
+export function formatProgressBarBraille(
+	percentage: number,
+	length: number,
+	colorMode: ProgressBarColor,
+	background: ProgressBarBackground,
+): string {
+	const brailleChars = ["⣀", "⣄", "⣤", "⣦", "⣶", "⣷", "⣿"];
+
+	const totalSteps = length * (brailleChars.length - 1);
+	const currentStep = Math.round((percentage / 100) * totalSteps);
+
+	const fullBlocks = Math.floor(currentStep / (brailleChars.length - 1));
+	const partialIndex = currentStep % (brailleChars.length - 1);
+	const emptyBlocks = length - fullBlocks - (partialIndex > 0 ? 1 : 0);
+
+	const colorFn = getProgressBarColor(percentage, colorMode);
+	const bgFn = getProgressBarBackground(background);
+
+	const fullPart = bgFn
+		? bgFn(colorFn("⣿".repeat(fullBlocks)))
+		: colorFn("⣿".repeat(fullBlocks));
+	const partialPart =
+		partialIndex > 0
+			? bgFn
+				? bgFn(colorFn(brailleChars[partialIndex]))
+				: colorFn(brailleChars[partialIndex])
+			: "";
+	const emptyPart =
+		emptyBlocks > 0
+			? bgFn
+				? bgFn(colorFn("⣀".repeat(emptyBlocks)))
+				: colorFn("⣀".repeat(emptyBlocks))
+			: "";
+
+	return `${fullPart}${partialPart}${emptyPart}`;
+}
+
+export function formatProgressBar({
+	percentage,
+	length,
+	style,
+	colorMode,
+	background,
+}: {
+	percentage: number;
+	length: 5 | 10 | 15;
+	style: ProgressBarStyle;
+	colorMode: ProgressBarColor;
+	background: ProgressBarBackground;
+}): string {
+	if (style === "rectangle") {
+		return formatProgressBarRectangle(
+			percentage,
+			length,
+			colorMode,
+			background,
+		);
+	}
+	if (style === "braille") {
+		return formatProgressBarBraille(percentage, length, colorMode, background);
+	}
+	return formatProgressBarFilled(percentage, length, colorMode, background);
 }
 
 export function formatSession(
-	tokens: number,
+	cost: string,
+	duration: string,
+	tokensUsed: number,
+	tokensMax: number,
 	percentage: number,
 	config: StatuslineConfig["session"],
 ): string {
-	const items: string[] = [];
+	const sessionItems: string[] = [];
+
+	if (config.cost.enabled) {
+		sessionItems.push(`${colors.gray("$")}${colors.dimWhite(cost)}`);
+	}
 
-	if (config.showTokens) {
-		items.push(formatTokens(tokens));
+	if (config.tokens.enabled) {
+		const formattedUsed = formatTokens(tokensUsed, config.tokens.showDecimals);
+		if (config.tokens.showMax) {
+			const formattedMax = formatTokens(tokensMax, config.tokens.showDecimals);
+			sessionItems.push(`${formattedUsed}${colors.gray("/")}${formattedMax}`);
+		} else {
+			sessionItems.push(formattedUsed);
+		}
 	}
-	if (config.showPercentage) {
-		items.push(`${percentage}${colors.GRAY}%${colors.LIGHT_GRAY}`);
+
+	if (config.percentage.enabled) {
+		const parts: string[] = [];
+
+		if (config.percentage.progressBar.enabled) {
+			const bar = formatProgressBar({
+				percentage,
+				length: config.percentage.progressBar.length,
+				style: config.percentage.progressBar.style,
+				colorMode: config.percentage.progressBar.color,
+				background: config.percentage.progressBar.background,
+			});
+			parts.push(bar);
+		}
+
+		if (config.percentage.showValue) {
+			parts.push(
+				`${colors.lightGray(percentage.toString())}${colors.gray("%")}`,
+			);
+		}
+
+		if (parts.length > 0) {
+			sessionItems.push(parts.join(" "));
+		}
+	}
+
+	if (config.duration.enabled) {
+		sessionItems.push(colors.gray(`(${duration})`));
 	}
 
-	if (items.length === 0) {
+	if (sessionItems.length === 0) {
 		return "";
 	}
 
-	return `${colors.LIGHT_GRAY}${items.join(" ")}`;
+	const infoSep = config.infoSeparator
+		? ` ${colors.gray(config.infoSeparator)} `
+		: " ";
+	return `${colors.gray("S:")} ${sessionItems.join(infoSep)}`;
 }

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

@@ -0,0 +1,100 @@
+import { $ } from "bun";
+
+export interface GitStatus {
+	branch: string;
+	hasChanges: boolean;
+	staged: {
+		added: number;
+		deleted: number;
+		files: number;
+	};
+	unstaged: {
+		added: number;
+		deleted: number;
+		files: number;
+	};
+}
+
+export async function getGitStatus(): Promise<GitStatus> {
+	try {
+		const isGitRepo = await $`git rev-parse --git-dir`.quiet().nothrow();
+		if (isGitRepo.exitCode !== 0) {
+			return {
+				branch: "no-git",
+				hasChanges: false,
+				staged: { added: 0, deleted: 0, files: 0 },
+				unstaged: { added: 0, deleted: 0, files: 0 },
+			};
+		}
+
+		const branchResult = await $`git branch --show-current`.quiet().text();
+		const branch = branchResult.trim() || "detached";
+
+		const diffCheck = await $`git diff-index --quiet HEAD --`.quiet().nothrow();
+		const cachedCheck = await $`git diff-index --quiet --cached HEAD --`
+			.quiet()
+			.nothrow();
+
+		if (diffCheck.exitCode !== 0 || cachedCheck.exitCode !== 0) {
+			const unstagedDiff = await $`git diff --numstat`.quiet().text();
+			const stagedDiff = await $`git diff --cached --numstat`.quiet().text();
+			const stagedFilesResult = await $`git diff --cached --name-only`
+				.quiet()
+				.text();
+			const unstagedFilesResult = await $`git diff --name-only`.quiet().text();
+
+			const parseStats = (diff: string) => {
+				let added = 0;
+				let deleted = 0;
+				for (const line of diff.split("\n")) {
+					if (!line.trim()) continue;
+					const [a, d] = line
+						.split("\t")
+						.map((n) => Number.parseInt(n, 10) || 0);
+					added += a;
+					deleted += d;
+				}
+				return { added, deleted };
+			};
+
+			const unstagedStats = parseStats(unstagedDiff);
+			const stagedStats = parseStats(stagedDiff);
+
+			const stagedFilesCount = stagedFilesResult
+				.split("\n")
+				.filter((f) => f.trim()).length;
+			const unstagedFilesCount = unstagedFilesResult
+				.split("\n")
+				.filter((f) => f.trim()).length;
+
+			return {
+				branch,
+				hasChanges: true,
+				staged: {
+					added: stagedStats.added,
+					deleted: stagedStats.deleted,
+					files: stagedFilesCount,
+				},
+				unstaged: {
+					added: unstagedStats.added,
+					deleted: unstagedStats.deleted,
+					files: unstagedFilesCount,
+				},
+			};
+		}
+
+		return {
+			branch,
+			hasChanges: false,
+			staged: { added: 0, deleted: 0, files: 0 },
+			unstaged: { added: 0, deleted: 0, files: 0 },
+		};
+	} catch {
+		return {
+			branch: "no-git",
+			hasChanges: false,
+			staged: { added: 0, deleted: 0, files: 0 },
+			unstaged: { added: 0, deleted: 0, files: 0 },
+		};
+	}
+}

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

@@ -0,0 +1,177 @@
+/**
+ * Pure statusline renderer - no I/O, no side effects
+ *
+ * ARCHITECTURE: Raw data in, formatted string out.
+ * ALL config decisions happen here, not in data preparation.
+ *
+ * FREE VERSION: Simplified - No limits, weekly, or daily tracking
+ */
+
+import type { StatuslineConfig } from "./config-types";
+import {
+	colors,
+	formatCost,
+	formatDuration,
+	formatPath,
+	formatProgressBar,
+	formatTokens,
+} from "./formatters";
+
+// ─────────────────────────────────────────────────────────────
+// DATA TYPES - Simplified for free version
+// ─────────────────────────────────────────────────────────────
+
+export interface StatuslineData {
+	branch: string;
+	dirPath: string;
+	modelName: string;
+	sessionCost: string;
+	sessionDuration: string;
+	contextTokens: number | null;
+	contextPercentage: number | null;
+}
+
+// ─────────────────────────────────────────────────────────────
+// FORMATTING - All config-aware formatting in one place
+// ─────────────────────────────────────────────────────────────
+
+function formatSessionPart(
+	cost: number,
+	durationMs: number,
+	contextTokens: number | null,
+	contextPercentage: number | null,
+	maxTokens: number,
+	config: StatuslineConfig["session"],
+): string {
+	// No context data yet - show placeholder
+	if (contextTokens === null || contextPercentage === null) {
+		return `${colors.gray("S:")} ${colors.gray("-")}`;
+	}
+
+	const items: string[] = [];
+
+	if (config.cost.enabled) {
+		const formattedCost = formatCost(cost, config.cost.format);
+		items.push(`${colors.gray("$")}${colors.dimWhite(formattedCost)}`);
+	}
+
+	if (config.tokens.enabled) {
+		const formattedUsed = formatTokens(
+			contextTokens,
+			config.tokens.showDecimals,
+		);
+		if (config.tokens.showMax) {
+			const formattedMax = formatTokens(maxTokens, config.tokens.showDecimals);
+			items.push(`${formattedUsed}${colors.gray("/")}${formattedMax}`);
+		} else {
+			items.push(formattedUsed);
+		}
+	}
+
+	if (config.percentage.enabled) {
+		const pctParts: string[] = [];
+
+		if (config.percentage.progressBar.enabled) {
+			pctParts.push(
+				formatProgressBar({
+					percentage: contextPercentage,
+					length: config.percentage.progressBar.length,
+					style: config.percentage.progressBar.style,
+					colorMode: config.percentage.progressBar.color,
+					background: config.percentage.progressBar.background,
+				}),
+			);
+		}
+
+		if (config.percentage.showValue) {
+			pctParts.push(
+				`${colors.lightGray(contextPercentage.toString())}${colors.gray("%")}`,
+			);
+		}
+
+		if (pctParts.length > 0) {
+			items.push(pctParts.join(" "));
+		}
+	}
+
+	if (config.duration.enabled) {
+		items.push(colors.gray(`(${formatDuration(durationMs)})`));
+	}
+
+	if (items.length === 0) return "";
+
+	const sep = config.infoSeparator
+		? ` ${colors.gray(config.infoSeparator)} `
+		: " ";
+	return `${colors.gray("S:")} ${items.join(sep)}`;
+}
+
+// ─────────────────────────────────────────────────────────────
+// MAIN RENDER FUNCTION - Simple version
+// ─────────────────────────────────────────────────────────────
+
+export function renderStatusline(
+	data: StatuslineData,
+	config: StatuslineConfig,
+): string {
+	const sep = colors.gray(config.separator);
+	const sections: string[] = [];
+
+	// Line 1: Git + Path + Model
+	const line1Parts: string[] = [];
+
+	// Git branch
+	if (data.branch) {
+		line1Parts.push(colors.lightGray(data.branch));
+	}
+
+	// Path
+	const pathPart = formatPath(data.dirPath, config.pathDisplayMode);
+	line1Parts.push(colors.gray(pathPart));
+
+	// Model name (hide Sonnet if configured)
+	const isSonnet = data.modelName.toLowerCase().includes("sonnet");
+	if (!isSonnet || config.showSonnetModel) {
+		line1Parts.push(colors.peach(data.modelName));
+	}
+
+	sections.push(line1Parts.join(` ${sep} `));
+
+	// Line 2: Session info (cost, tokens, percentage, duration)
+	const cost = parseFloat(data.sessionCost.replace(/[$,]/g, "")) || 0;
+	const durationMs = parseDurationToMs(data.sessionDuration);
+
+	const sessionPart = formatSessionPart(
+		cost,
+		durationMs,
+		data.contextTokens,
+		data.contextPercentage,
+		config.context.maxContextTokens,
+		config.session,
+	);
+
+	if (sessionPart) sections.push(sessionPart);
+
+	const output = sections.join(` ${sep} `);
+
+	if (config.oneLine) return output;
+
+	// Two-line mode: break after line1
+	const line1 = sections[0];
+	const rest = sections.slice(1).join(` ${sep} `);
+	return rest ? `${line1}\n${rest}` : line1;
+}
+
+// ─────────────────────────────────────────────────────────────
+// HELPERS
+// ─────────────────────────────────────────────────────────────
+
+// Helper to parse "12m" or "1h 30m" back to ms
+function parseDurationToMs(duration: string): number {
+	let ms = 0;
+	const hourMatch = duration.match(/(\d+)h/);
+	const minMatch = duration.match(/(\d+)m/);
+	if (hourMatch) ms += parseInt(hourMatch[1], 10) * 3600000;
+	if (minMatch) ms += parseInt(minMatch[1], 10) * 60000;
+	return ms || 720000; // Default 12 minutes
+}

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

@@ -21,5 +21,16 @@ export interface HookInput {
 		total_lines_added: number;
 		total_lines_removed: number;
 	};
+	context_window?: {
+		total_input_tokens: number;
+		total_output_tokens: number;
+		context_window_size: number;
+		current_usage?: {
+			input_tokens: number;
+			output_tokens: number;
+			cache_creation_input_tokens?: number;
+			cache_read_input_tokens?: number;
+		};
+	};
 	exceeds_200k_tokens?: boolean;
 }