ultimate-pi 0.1.2 → 0.1.4

package/.pi/extensions/custom-footer.ts

@@ -0,0 +1,308 @@
+/**
+ * Custom Footer Extension — single-line footer with context bar, session cost,
+ * model name, provider, thinking level, working directory, and git branch.
+ *
+ * ~/project (main)  ↑12k ↓8k  $0.042  [████████░░] 72%  anthropic • claude-sonnet-4-20250514 • xhigh
+ */
+
+import type { ExtensionAPI, ExtensionContext } from "@mariozechner/pi-coding-agent";
+import type { TUI } from "@mariozechner/pi-tui";
+import { Box, Text, truncateToWidth, visibleWidth } from "@mariozechner/pi-tui";
+
+// ── token formatting ──────────────────────────────────────────────
+
+function fmtTokens(count: number): string {
+	if (count < 1000) return count.toString();
+	if (count < 10000) return `${(count / 1000).toFixed(1)}k`;
+	if (count < 1_000_000) return `${Math.round(count / 1000)}k`;
+	if (count < 10_000_000) return `${(count / 1_000_000).toFixed(1)}M`;
+	return `${Math.round(count / 1_000_000)}M`;
+}
+
+// ── bar builder ───────────────────────────────────────────────────
+
+const BAR_FILLED = "█";
+const BAR_EMPTY = "░";
+const BAR_COUNT = 10;
+
+type BarColor = "success" | "warning" | "error";
+
+function barColor(percent: number): BarColor {
+	if (percent < 50) return "success";
+	if (percent < 80) return "warning";
+	return "error";
+}
+
+/** Build colored bar segment — returns filled and empty strings separately. */
+function buildBar(percent: number): { filled: string; empty: string } {
+	const filled = Math.round((Math.min(percent, 100) / 100) * BAR_COUNT);
+	const empty = BAR_COUNT - filled;
+	return {
+		filled: BAR_FILLED.repeat(filled),
+		empty: BAR_EMPTY.repeat(empty),
+	};
+}
+
+// ── cost computation ──────────────────────────────────────────────
+
+interface CostSnapshot {
+	input: number;
+	output: number;
+	cacheRead: number;
+	cacheWrite: number;
+	cost: number;
+}
+
+function computeCost(ctx: ExtensionContext): CostSnapshot {
+	let input = 0;
+	let output = 0;
+	let cacheRead = 0;
+	let cacheWrite = 0;
+	let cost = 0;
+
+	for (const entry of ctx.sessionManager.getEntries()) {
+		if (entry.type === "message" && entry.message.role === "assistant") {
+			const u = entry.message.usage;
+			input += u.input ?? 0;
+			output += u.output ?? 0;
+			cacheRead += u.cacheRead ?? 0;
+			cacheWrite += u.cacheWrite ?? 0;
+			cost += u.cost?.total ?? 0;
+		}
+	}
+
+	return { input, output, cacheRead, cacheWrite, cost };
+}
+
+// ── model info ────────────────────────────────────────────────────
+
+interface ModelInfo {
+	id: string;
+	provider: string;
+	reasoning: boolean;
+}
+
+function modelInfo(ctx: ExtensionContext): ModelInfo {
+	const m = ctx.model;
+	if (!m) return { id: "no-model", provider: "unknown", reasoning: false };
+	return { id: m.id, provider: m.provider, reasoning: m.reasoning };
+}
+
+// ── thinking label ────────────────────────────────────────────────
+
+/** Returns thinking level display string, or null if model doesn't support reasoning. */
+function thinkingLabel(level: string | null, reasoning: boolean): string | null {
+	if (!reasoning || level == null) return null;
+	if (level === "minimal") return "off";
+	return level;
+}
+
+// ── cwd + branch ──────────────────────────────────────────────────
+
+function pathLabel(cwd: string, branch: string | null): { cwd: string; branch: string | null } {
+	let pwd = cwd;
+	const home = process.env.HOME || process.env.USERPROFILE;
+	if (home && pwd.startsWith(home)) {
+		pwd = `~${pwd.slice(home.length)}`;
+	}
+	return { cwd: pwd, branch };
+}
+
+// ── extension ─────────────────────────────────────────────────────
+
+export default function customFooter(pi: ExtensionAPI) {
+	let unsubBranch: (() => void) | null = null;
+
+	const state: {
+		tui: TUI | null;
+		box: Box | null;
+		textLine: Text | null;
+		percent: number | null;
+		cost: CostSnapshot;
+		cwd: string;
+		modelId: string;
+		modelProvider: string;
+		modelReasoning: boolean;
+		thinkingLevel: string | null;
+		branch: string | null;
+	} = {
+		tui: null,
+		box: null,
+		textLine: null,
+		percent: null,
+		cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0 },
+		cwd: process.cwd(),
+		modelId: "…",
+		modelProvider: "…",
+		modelReasoning: false,
+		thinkingLevel: null,
+		branch: null,
+	};
+
+	function invalidate() {
+		state.box?.invalidate();
+		state.textLine?.invalidate();
+		state.tui?.requestRender();
+	}
+
+	function refreshModelAndThinking(ctx: ExtensionContext) {
+		const mi = modelInfo(ctx);
+		state.modelId = mi.id;
+		state.modelProvider = mi.provider;
+		state.modelReasoning = mi.reasoning;
+		state.thinkingLevel = pi.getThinkingLevel();
+	}
+
+	pi.on("session_start", (_event, ctx) => {
+		state.cwd = ctx.cwd;
+		refreshModelAndThinking(ctx);
+		state.cost = computeCost(ctx);
+
+		ctx.ui.setFooter((tui, theme, footerData) => {
+			if (unsubBranch) { unsubBranch(); unsubBranch = null; }
+
+			state.tui = tui;
+			state.branch = footerData.getGitBranch();
+
+			unsubBranch = footerData.onBranchChange(() => {
+				state.branch = footerData.getGitBranch();
+				invalidate();
+			});
+
+			const box = new Box(1, 0);
+			const textLine = new Text("", 0, 0);
+			box.addChild(textLine);
+
+			state.box = box;
+			state.textLine = textLine;
+
+			return {
+				dispose() {
+					if (unsubBranch) { unsubBranch(); unsubBranch = null; }
+					state.tui = null;
+					state.box = null;
+					state.textLine = null;
+				},
+
+				invalidate() {
+					box.invalidate();
+					textLine.invalidate();
+				},
+
+				render(width: number): string[] {
+					const dim = (s: string) => theme.fg("dim", s);
+					const c = state.cost;
+					const pct = state.percent;
+
+					// Available text width: Box paddingX=1 on each side → subtract 2,
+					// then subtract safety margin so we never overflow on edge-case terminals
+					const SAFETY_MARGIN = 2;
+					const innerW = Math.max(1, width - 2 - SAFETY_MARGIN);
+
+					// ── left: cwd/branch  tokens  cost ──
+					const { cwd: cwdPath, branch: gitBranch } = pathLabel(state.cwd, state.branch);
+					const pathDisplay = gitBranch
+						? `${cwdPath} (${theme.fg("error", gitBranch)})`
+						: cwdPath;
+					const leftParts: string[] = [pathDisplay];
+					if (c.input > 0 || c.output > 0) {
+						leftParts.push(`↑${fmtTokens(c.input)} ↓${fmtTokens(c.output)}`);
+					}
+					if (c.cost > 0) {
+						leftParts.push(`$${c.cost.toFixed(4)}`);
+					}
+					const leftStr = leftParts.join("  ");
+
+					// ── bar: [████████░░] 72% ──
+					const safePct = pct ?? 0;
+					const { filled, empty } = buildBar(safePct);
+					const barColorName = barColor(safePct);
+					const barInner = theme.fg(barColorName, filled) + empty;
+					const barFull = `[${barInner}] ${Math.round(safePct)}%`;
+
+					// ── right: provider • modelId thinkingLevel ──
+					const tl = thinkingLabel(state.thinkingLevel, state.modelReasoning);
+					const modelDisplay = tl ? `${state.modelId} ${tl}` : state.modelId;
+					const rightParts: string[] = [state.modelProvider, modelDisplay];
+					const rightStr = rightParts.join(" • ");
+
+					// ── compose single line ──
+					const colLeft = leftStr;
+					const dimRight = dim(rightStr);
+					const lw = visibleWidth(colLeft);
+					const rw = visibleWidth(dimRight);
+					const bw = visibleWidth(barFull);
+					const gap = 2;
+
+					if (lw + gap + bw + gap + rw <= innerW) {
+						const pad = innerW - lw - gap - bw - gap - rw;
+						const line = colLeft + " ".repeat(gap + pad) + barFull + " ".repeat(gap) + dimRight;
+						textLine.setText(truncateToWidth(line, innerW));
+					} else {
+						// Priority: keep bar visible, keep left (cwd) intact, truncate modelId first
+						const tlNow = thinkingLabel(state.thinkingLevel, state.modelReasoning);
+						const buildRight = (mid: string) => {
+							const modelPart = tlNow ? `${mid} ${tlNow}` : mid;
+							const parts: string[] = [state.modelProvider];
+							if (modelPart) parts.push(modelPart);
+							return dim(parts.join(" • "));
+						};
+
+						let truncMid = state.modelId;
+						let dimR = buildRight(truncMid);
+						let rwNow = visibleWidth(dimR);
+
+						while (truncMid.length > 0 && lw + gap + bw + gap + rwNow > innerW) {
+							truncMid = truncMid.slice(0, -1);
+							dimR = buildRight(truncMid);
+							rwNow = visibleWidth(dimR);
+						}
+
+						if (lw + gap + bw + gap + rwNow <= innerW) {
+							const pad = innerW - lw - gap - bw - gap - rwNow;
+							const line = colLeft + " ".repeat(gap + pad) + barFull + " ".repeat(gap) + dimR;
+							textLine.setText(truncateToWidth(line, innerW));
+						} else {
+							// ModelId gone, still overflows: truncate leftStr
+							const avail = innerW - bw - rwNow - gap - gap;
+							if (avail < 1) {
+								textLine.setText(truncateToWidth(dimR, innerW));
+							} else {
+								const truncLeft = truncateToWidth(colLeft, Math.max(1, avail));
+								const line = truncLeft + " ".repeat(gap) + barFull + " ".repeat(gap) + dimR;
+								textLine.setText(truncateToWidth(line, innerW));
+							}
+						}
+					}
+
+					return box.render(width);
+				},
+			};
+		});
+	});
+
+	// Update context usage + cost before each LLM call
+	pi.on("context", (_event, ctx) => {
+		const usage = ctx.getContextUsage();
+		state.percent = usage?.percent ?? null;
+		state.cost = computeCost(ctx);
+		refreshModelAndThinking(ctx);
+		invalidate();
+	});
+
+	// Track model changes
+	pi.on("model_select", (event) => {
+		state.modelId = event.model?.id ?? "…";
+		state.modelProvider = event.model?.provider ?? "…";
+		state.modelReasoning = event.model?.reasoning ?? false;
+		state.thinkingLevel = pi.getThinkingLevel();
+		invalidate();
+	});
+
+	// Catch thinking level changes between turns (e.g. /thinking command)
+	pi.on("turn_start", (_event, ctx) => {
+		state.thinkingLevel = pi.getThinkingLevel();
+		refreshModelAndThinking(ctx);
+		invalidate();
+	});
+}

package/.pi/extensions/custom-header.ts

@@ -0,0 +1,116 @@
+/**
+ * Custom Startup Header Extension for Ultimate Pi
+ *
+ * Renders .github/banner-v2.png as true-color block ASCII art using Jimp.
+ * Uses Unicode lower-half-block characters with per-pixel ANSI 24-bit color,
+ * doubling vertical resolution in the same terminal footprint.
+ */
+
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import { truncateToWidth } from "@mariozechner/pi-tui";
+import Jimp from "jimp";
+import { join } from "node:path";
+
+const imagePath = join(process.cwd(), ".pi", "extensions", "banner.png");
+
+// Terminal footprint — keep a safety margin so we never crash on narrow terminals
+const SAFETY_MARGIN = 2;
+const TERM_WIDTH = 120;
+const TERM_HEIGHT = 24;
+
+// Pixel grid: 1 char wide × 2 pixels tall (half-block)
+const PIXEL_WIDTH = TERM_WIDTH;
+const PIXEL_HEIGHT = TERM_HEIGHT * 2;
+
+const HALF_BLOCK = "\u2584"; // lower half block: fg = bottom, bg = top
+
+let cachedBanner: string[] | null = null;
+let loadPromise: Promise<string[]> | null = null;
+
+function ansiCell(
+	top: { r: number; g: number; b: number; a: number },
+	bottom: { r: number; g: number; b: number; a: number }
+): string {
+	const topTransparent = top.a < 128;
+	const bottomTransparent = bottom.a < 128;
+	if (topTransparent && bottomTransparent) {
+		return " ";
+	}
+	if (topTransparent) {
+		return `\x1b[38;2;${bottom.r};${bottom.g};${bottom.b};48;2;${bottom.r};${bottom.g};${bottom.b}m${HALF_BLOCK}\x1b[0m`;
+	}
+	if (bottomTransparent) {
+		return `\x1b[38;2;${top.r};${top.g};${top.b};48;2;${top.r};${top.g};${top.b}m${HALF_BLOCK}\x1b[0m`;
+	}
+	return `\x1b[38;2;${bottom.r};${bottom.g};${bottom.b};48;2;${top.r};${top.g};${top.b}m${HALF_BLOCK}\x1b[0m`;
+}
+
+async function loadBanner(): Promise<string[]> {
+	const image = await Jimp.read(imagePath);
+	image.resize(PIXEL_WIDTH, PIXEL_HEIGHT);
+
+	const lines: string[] = [];
+	for (let row = 0; row < PIXEL_HEIGHT; row += 2) {
+		let line = "";
+		for (let col = 0; col < PIXEL_WIDTH; col++) {
+			const top = Jimp.intToRGBA(image.getPixelColor(col, row));
+			const bottom = Jimp.intToRGBA(image.getPixelColor(col, row + 1));
+			line += ansiCell(top, bottom);
+		}
+		lines.push(line);
+	}
+	return lines;
+}
+
+function getBanner(): Promise<string[]> {
+	if (cachedBanner) {
+		return Promise.resolve(cachedBanner);
+	}
+	if (loadPromise) {
+		return loadPromise;
+	}
+	loadPromise = loadBanner()
+		.then((lines) => {
+			cachedBanner = lines;
+			return lines;
+		})
+		.catch((err) => {
+			console.error("Failed to render banner:", err);
+			cachedBanner = [];
+			return [];
+		});
+	return loadPromise;
+}
+
+export default function (pi: ExtensionAPI) {
+	pi.on("session_start", async (_event, ctx) => {
+		if (!ctx.hasUI) {
+			return;
+		}
+
+		await getBanner();
+
+		ctx.ui.setHeader((_tui, _theme) => {
+			return {
+				render(width: number): string[] {
+					if (!cachedBanner || cachedBanner.length === 0) {
+						return [];
+					}
+					const maxW = Math.max(0, width - SAFETY_MARGIN);
+					return cachedBanner.map((line) => truncateToWidth(line, maxW));
+				},
+				invalidate() {
+					return false;
+				},
+			};
+		});
+	});
+
+	pi.registerCommand("builtin-header", {
+		description: "Restore built-in header with keybinding hints",
+		handler: async (_args, ctx) => {
+			ctx.ui.setHeader(undefined);
+			ctx.ui.notify("Built-in header restored", "info");
+		},
+	});
+}

package/.pi/extensions/dotenv-loader.ts

@@ -0,0 +1,170 @@
+/**
+ * dotenv-loader — loads .env files into process.env before other extensions read config.
+ *
+ * Runs synchronously in the extension factory so vars are available immediately.
+ * Also reloads on session_start (reload/resume) to pick up file changes.
+ *
+ * Config (env vars, since .env isn't loaded yet):
+ *   ENV_LOADER_FILES     — comma-separated .env paths, default: ".env"
+ *   ENV_LOADER_OVERRIDE  — "true" to overwrite existing vars, default: "false"
+ *   ENV_LOADER_SILENT    — "true" to suppress all output, default: "false"
+ *   ENV_LOADER_ENCODING  — file encoding, default: "utf-8"
+ */
+
+import { existsSync, readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+
+// ── .env parser ──────────────────────────────────────────────────
+
+function parseEnv(content: string): Map<string, string> {
+	const vars = new Map<string, string>();
+	for (const raw of content.split("\n")) {
+		const line = raw.trim();
+		if (!line || line.startsWith("#")) continue;
+
+		const eq = line.indexOf("=");
+		if (eq === -1) continue;
+
+		const key = line.slice(0, eq).trim();
+		let val = line.slice(eq + 1).trim();
+
+		// Strip surrounding quotes
+		if (
+			(val.startsWith('"') && val.endsWith('"')) ||
+			(val.startsWith("'") && val.endsWith("'"))
+		) {
+			val = val.slice(1, -1);
+		}
+
+		// Expand ${VAR} and $VAR references from current process.env
+		val = val.replace(/\$\{([^}]+)\}/g, (_, name) => process.env[name] ?? "");
+		val = val.replace(
+			/\$([A-Za-z_][A-Za-z0-9_]*)/g,
+			(_, name) => process.env[name] ?? "",
+		);
+
+		if (key.length > 0) {
+			vars.set(key, val);
+		}
+	}
+	return vars;
+}
+
+// ── Load & apply ─────────────────────────────────────────────────
+
+interface LoadResult {
+	loaded: number;
+	skipped: number;
+	files: Array<{ path: string; existed: boolean; vars: number }>;
+}
+
+function loadEnvFiles(cwd: string): LoadResult {
+	const filesStr = process.env.ENV_LOADER_FILES || ".env";
+	const override = process.env.ENV_LOADER_OVERRIDE === "true";
+	const encoding =
+		(process.env.ENV_LOADER_ENCODING as BufferEncoding) || "utf-8";
+
+	const filePaths = filesStr.split(",").map((f) => resolve(cwd, f.trim()));
+	const result: LoadResult = { loaded: 0, skipped: 0, files: [] };
+
+	for (const fp of filePaths) {
+		const existed = existsSync(fp);
+		let varsCount = 0;
+
+		if (!existed) {
+			result.files.push({ path: fp, existed: false, vars: 0 });
+			continue;
+		}
+
+		try {
+			const content = readFileSync(fp, { encoding });
+			const vars = parseEnv(content);
+
+			for (const [key, value] of vars) {
+				if (!override && key in process.env) {
+					result.skipped++;
+					continue;
+				}
+				process.env[key] = value;
+				result.loaded++;
+				varsCount++;
+			}
+
+			result.files.push({ path: fp, existed: true, vars: varsCount });
+		} catch (_err) {
+			result.files.push({ path: fp, existed: true, vars: 0 });
+		}
+	}
+
+	return result;
+}
+
+// ── Extension ────────────────────────────────────────────────────
+
+export default function dotenvLoader(pi: ExtensionAPI) {
+	const silent = process.env.ENV_LOADER_SILENT === "true";
+	const cwd = process.cwd();
+
+	// Load immediately in factory — before other extensions' factories run.
+	const result = loadEnvFiles(cwd);
+
+	if (!silent) {
+		const summary = result.files
+			.filter((f) => f.existed)
+			.map((f) => `  ${f.path}: ${f.vars} vars applied`)
+			.join("\n");
+
+		if (summary) {
+			console.log(
+				`[dotenv-loader] Loaded ${result.loaded} vars, skipped ${result.skipped} (override=false).\n${summary}`,
+			);
+		} else {
+			const missing = result.files
+				.filter((f) => !f.existed)
+				.map((f) => f.path)
+				.join(", ");
+			console.log(`[dotenv-loader] No .env files found. Checked: ${missing}`);
+		}
+	}
+
+	// Reload on session_start (covers reload/resume/new)
+	pi.on("session_start", () => {
+		const reloadResult = loadEnvFiles(cwd);
+
+		// Only log if something changed
+		if (!silent && reloadResult.loaded > 0) {
+			console.log(
+				`[dotenv-loader] Reloaded ${reloadResult.loaded} vars from .env files.`,
+			);
+		}
+	});
+
+	// Status command
+	pi.registerCommand("env-loader-status", {
+		description: "Show dotenv-loader status and loaded .env files",
+		handler: async (_args, ctx) => {
+			const filesStr = process.env.ENV_LOADER_FILES || ".env";
+			const override = process.env.ENV_LOADER_OVERRIDE === "true";
+			const paths = filesStr.split(",").map((f) => resolve(cwd, f.trim()));
+
+			const lines = [
+				"dotenv-loader status:",
+				`  cwd: ${cwd}`,
+				`  files: ${paths.join(", ")}`,
+				`  override: ${override}`,
+				`  silent: ${silent}`,
+				`  encoding: ${process.env.ENV_LOADER_ENCODING || "utf-8"}`,
+				"",
+				"Last load result:",
+				`  loaded: ${result.loaded}`,
+				`  skipped: ${result.skipped}`,
+				...result.files.map(
+					(f) => `  ${f.path}: ${f.existed ? `${f.vars} vars` : "not found"}`,
+				),
+			];
+
+			ctx.ui.notify(lines.join("\n"), "info");
+		},
+	});
+}

package/.pi/internal/cursor-sdk-transcript-parser.ts

@@ -0,0 +1,59 @@
+type ToolLike = { name: string };
+type ContextLike = { tools?: ToolLike[] };
+
+export function parseCursorTranscriptToolCalls(
+	text: string,
+	context: ContextLike,
+): Array<{ name: string; arguments: Record<string, unknown> }> {
+	const tools = context.tools;
+	if (!tools || tools.length === 0) {
+		return [];
+	}
+
+	const normalizeToolName = (raw: string): string | undefined => {
+		const trimmed = raw.trim().toLowerCase();
+		const aliases: Record<string, string[]> = {
+			read: ["ReadFile", "Read", "readfile", "read"],
+			write: ["Write", "write"],
+			edit: ["Edit", "edit", "ApplyPatch", "applypatch"],
+			glob: ["Glob", "glob"],
+			grep: ["rg", "RG", "Grep", "grep"],
+			shell: ["Shell", "shell", "bash", "Bash"],
+			bash: ["Shell", "shell", "bash", "Bash"],
+		};
+		const candidates = aliases[trimmed] ?? [raw];
+		for (const candidate of candidates) {
+			const exact = tools.find((tool) => tool.name === candidate);
+			if (exact) return exact.name;
+			const insensitive = tools.find((tool) => tool.name.toLowerCase() === candidate.toLowerCase());
+			if (insensitive) return insensitive.name;
+		}
+		return undefined;
+	};
+
+	const blockRegex = /⏺\s*([a-zA-Z0-9._-]+)[\s\S]*?```json\s*([\s\S]*?)```/g;
+	let match: RegExpExecArray | null = null;
+	const parsedCalls: Array<{ name: string; arguments: Record<string, unknown> }> = [];
+	while ((match = blockRegex.exec(text)) !== null) {
+		const rawToolName = match[1] ?? "";
+		const mappedName = normalizeToolName(rawToolName);
+		if (!mappedName) continue;
+		const rawArgs = (match[2] ?? "").trim();
+		if (!rawArgs) {
+			parsedCalls.push({ name: mappedName, arguments: {} });
+			continue;
+		}
+		try {
+			const parsed = JSON.parse(rawArgs);
+			if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+				parsedCalls.push({ name: mappedName, arguments: {} });
+				continue;
+			}
+			parsedCalls.push({ name: mappedName, arguments: parsed as Record<string, unknown> });
+		} catch {
+			parsedCalls.push({ name: mappedName, arguments: {} });
+		}
+	}
+
+	return parsedCalls;
+}