pi-open-tui 0.1.0

package/extensions/open-tui/git.ts

@@ -0,0 +1,154 @@
+import { execFile } from "node:child_process";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { promisify } from "node:util";
+
+const execFileAsync = promisify(execFile);
+const GIT_TIMEOUT_MS = 2000;
+
+export interface GitCommitInfo {
+	oid: string | null;
+	detached: boolean;
+	tag: string | null;
+}
+
+export interface GitStatus {
+	branch: string | undefined;
+	ahead: number;
+	behind: number;
+	modified: number;
+	untracked: number;
+	staged: number;
+	stashed: number;
+	conflicted: number;
+	renamed: number;
+	deleted: number;
+	commit: GitCommitInfo | null;
+}
+
+export function emptyGitStatus(): GitStatus {
+	return {
+		branch: undefined,
+		ahead: 0,
+		behind: 0,
+		modified: 0,
+		untracked: 0,
+		staged: 0,
+		stashed: 0,
+		conflicted: 0,
+		renamed: 0,
+		deleted: 0,
+		commit: null,
+	};
+}
+
+async function gitExec(args: string[], cwd: string): Promise<string | null> {
+	try {
+		const { stdout } = await execFileAsync("git", args, {
+			cwd,
+			timeout: GIT_TIMEOUT_MS,
+			maxBuffer: 1024 * 1024,
+		});
+		return stdout;
+	} catch {
+		return null;
+	}
+}
+
+export async function readGitStatus(
+	cwd: string,
+	options: { readCommit?: boolean; readTag?: boolean } = {},
+): Promise<GitStatus> {
+	if (!existsSync(join(cwd, ".git"))) {
+		return emptyGitStatus();
+	}
+
+	const stdout = await gitExec(
+		["status", "--porcelain=v1", "--branch", "--show-stash"],
+		cwd,
+	);
+	if (stdout === null) {
+		return emptyGitStatus();
+	}
+
+	const status = emptyGitStatus();
+	const lines = stdout.split("\n");
+	let stashSupported = true;
+
+	for (const line of lines) {
+		if (line.startsWith("## ")) {
+			const branchPart = line.slice(3);
+			const detached = branchPart.startsWith("HEAD (no branch)");
+			if (detached) {
+				status.branch = undefined;
+				status.commit = { oid: null, detached: true, tag: null };
+			} else {
+				const branchMatch = branchPart.match(/^(\S+?)(?:\.\.\.(\S+))?(?:\s+\[(ahead|behind) (\d+)\])?/);
+				if (branchMatch) {
+					status.branch = branchMatch[1];
+					if (branchMatch[3] === "ahead") status.ahead = parseInt(branchMatch[4]!, 10);
+					if (branchMatch[3] === "behind") status.behind = parseInt(branchMatch[4]!, 10);
+				}
+			}
+			continue;
+		}
+
+		if (line.startsWith("# stash ")) {
+			const stashCount = parseInt(line.slice(8).trim(), 10);
+			if (!Number.isNaN(stashCount)) {
+				status.stashed = stashCount;
+				stashSupported = true;
+			}
+			continue;
+		}
+
+		if (line.length < 3) continue;
+		const x = line[0]!;
+		const y = line[1]!;
+
+		if (x === "U" || y === "U" || (x === "C" && y === "C")) status.conflicted++;
+		else if (x === "?" && y === "?") status.untracked++;
+		else if (x === "R") status.renamed++;
+		else if (x === "D" || y === "D") status.deleted++;
+		else {
+			if (x !== " " && x !== "?") status.staged++;
+			if (y === "M" || y === "D") status.modified++;
+		}
+	}
+
+	if (stashSupported && status.stashed === 0 && !stdout.includes("# stash")) {
+		const stashOut = await gitExec(["stash", "list", "--count"], cwd);
+		if (stashOut !== null) {
+			const count = parseInt(stashOut.trim(), 10);
+			if (!Number.isNaN(count)) status.stashed = count;
+		}
+	}
+
+	if (options.readCommit && status.commit?.detached) {
+		const oid = await gitExec(["rev-parse", "HEAD"], cwd);
+		if (oid) {
+			status.commit.oid = oid.trim();
+		}
+		if (options.readTag) {
+			const tag = await gitExec(["describe", "--tags", "--exact-match", "HEAD"], cwd);
+			if (tag) {
+				status.commit.tag = tag.trim();
+			}
+		}
+	}
+
+	return status;
+}
+
+export function hasGitChanges(s: GitStatus): boolean {
+	return (
+		s.modified > 0 ||
+		s.untracked > 0 ||
+		s.staged > 0 ||
+		s.conflicted > 0 ||
+		s.renamed > 0 ||
+		s.deleted > 0 ||
+		s.ahead > 0 ||
+		s.behind > 0
+	);
+}

package/extensions/open-tui/header.ts

@@ -0,0 +1,177 @@
+import { VERSION, type ExtensionAPI, type ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { Component, TUI } from "@earendil-works/pi-tui";
+import { center, truncateToWidth } from "./utils.ts";
+
+const LOGO_CELL = "███";
+const LOGO_ANIMATION_MS = 80;
+
+type LogoColor = "panel" | "cyan" | "red" | "green" | "orange" | "white" | "flash" | "brand";
+type LogoFrame = { phase: number; active: "left" | "top" | "right" | "none"; ax: number; ay: number; flash: boolean; white: boolean };
+
+const LOGO_FRAMES: LogoFrame[] = [
+	...Array.from({ length: 4 }, (_, ay) => ({ phase: 0, active: "left" as const, ax: 2, ay, flash: false, white: false })),
+	...Array.from({ length: 3 }, (_, ay) => ({ phase: 1, active: "top" as const, ax: 2, ay, flash: false, white: false })),
+	...Array.from({ length: 5 }, (_, ay) => ({ phase: 2, active: "right" as const, ax: 5, ay, flash: false, white: false })),
+	{ phase: 3, active: "none", ax: 0, ay: 0, flash: false, white: false },
+	{ phase: 3, active: "none", ax: 0, ay: 0, flash: true, white: false },
+	{ phase: 3, active: "none", ax: 0, ay: 0, flash: false, white: false },
+	{ phase: 3, active: "none", ax: 0, ay: 0, flash: true, white: false },
+	{ phase: 4, active: "none", ax: 0, ay: 0, flash: false, white: false },
+	{ phase: 5, active: "none", ax: 0, ay: 0, flash: false, white: false },
+	{ phase: 5, active: "none", ax: 0, ay: 0, flash: false, white: true },
+	{ phase: 5, active: "none", ax: 0, ay: 0, flash: false, white: false },
+	{ phase: 5, active: "none", ax: 0, ay: 0, flash: false, white: true },
+	{ phase: 6, active: "none", ax: 0, ay: 0, flash: false, white: false },
+];
+
+function hasCell(y: number, x: number, cells: string): boolean {
+	return cells.split(" ").includes(`${y},${x}`);
+}
+
+function hasPiece(y: number, x: number, py: number, px: number, cells: string): boolean {
+	return cells.split(" ").some((item) => {
+		const [dy, dx] = item.split(",").map(Number);
+		return y === py + dy && x === px + dx;
+	});
+}
+
+function logoCellColor(frame: LogoFrame, y: number, x: number): LogoColor {
+	if (frame.white) {
+		return hasCell(y, x, "3,2 3,3 3,4 4,2 4,4 5,2 5,3 5,5 6,2 6,5") ? "white" : "panel";
+	}
+	if (frame.flash && y === 6 && x >= 1 && x <= 6) return "flash";
+
+	switch (frame.active) {
+		case "left":
+			if (hasPiece(y, x, frame.ay, frame.ax, "0,0 1,0 1,1 2,0")) return "red";
+			break;
+		case "top":
+			if (hasPiece(y, x, frame.ay, frame.ax, "0,0 0,1 0,2 1,2")) return "cyan";
+			break;
+		case "right":
+			if (hasPiece(y, x, frame.ay, frame.ax, "0,0 1,0 2,0 2,1")) return "green";
+			break;
+	}
+
+	if (frame.phase === 6) {
+		return hasCell(y, x, "3,2 3,3 3,4 4,4 4,2 5,2 5,3 5,5 6,2 6,5") ? "brand" : "panel";
+	}
+	if (frame.phase === 4) {
+		if (hasCell(y, x, "2,2 2,3 2,4 3,4")) return "cyan";
+		if (hasCell(y, x, "3,2 4,2 4,3 5,2")) return "red";
+		if (hasCell(y, x, "4,5 5,5")) return "green";
+		return "panel";
+	}
+	if (frame.phase >= 5) {
+		if (hasCell(y, x, "3,2 3,3 3,4 4,4")) return "cyan";
+		if (hasCell(y, x, "4,2 5,2 5,3 6,2")) return "red";
+		if (hasCell(y, x, "5,5 6,5")) return "green";
+		return "panel";
+	}
+	if (frame.phase <= 3 && hasCell(y, x, "6,1 6,2 6,3 6,4")) return "orange";
+	if (frame.phase >= 2 && hasCell(y, x, "2,2 2,3 2,4 3,4")) return "cyan";
+	if (frame.phase >= 1 && hasCell(y, x, "3,2 4,2 4,3 5,2")) return "red";
+	if (frame.phase >= 3 && hasCell(y, x, "4,5 5,5 6,5 6,6")) return "green";
+	return "panel";
+}
+
+function colorCell(color: LogoColor, paintBrand: (text: string) => string): string {
+	switch (color) {
+		case "cyan": return `\x1b[36m${LOGO_CELL}\x1b[39m`;
+		case "red": return `\x1b[31m${LOGO_CELL}\x1b[39m`;
+		case "green": return `\x1b[32m${LOGO_CELL}\x1b[39m`;
+		case "orange":
+		case "flash": return `\x1b[33m${LOGO_CELL}\x1b[39m`;
+		case "white": return `\x1b[39m${LOGO_CELL}`;
+		case "brand": return paintBrand(LOGO_CELL);
+		default: return " ".repeat(LOGO_CELL.length);
+	}
+}
+
+function renderLogo(frameIndex: number, paintBrand: (text: string) => string): string[] {
+	const frame = LOGO_FRAMES[frameIndex % LOGO_FRAMES.length]!;
+	const grid: LogoColor[][] = [];
+	for (let y = 1; y <= 7; y++) {
+		const row: LogoColor[] = [];
+		for (let x = 1; x <= 8; x++) row.push(logoCellColor(frame, y, x));
+		grid.push(row);
+	}
+
+	let minX = 7;
+	let maxX = 0;
+	for (const row of grid) {
+		row.forEach((cell, x) => {
+			if (cell !== "panel") {
+				minX = Math.min(minX, x);
+				maxX = Math.max(maxX, x);
+			}
+		});
+	}
+	if (maxX < minX) { minX = 0; maxX = 7; }
+
+	return grid.map((row) => {
+		let line = "";
+		for (let x = minX; x <= maxX; x++) line += colorCell(row[x]!, paintBrand);
+		return line;
+	});
+}
+
+export class OpenTuiHeader implements Component {
+	private frame = 0;
+	private readonly timer: ReturnType<typeof setInterval>;
+	private readonly ctx: ExtensionContext;
+
+	constructor(_pi: ExtensionAPI, ctx: ExtensionContext, tui: TUI) {
+		this.ctx = ctx;
+		this.timer = setInterval(() => {
+			if (this.frame < LOGO_FRAMES.length - 1) {
+				this.frame++;
+				tui.requestRender();
+			} else {
+				clearInterval(this.timer);
+			}
+		}, LOGO_ANIMATION_MS);
+		this.timer.unref?.();
+	}
+
+	render(width: number): string[] {
+		const theme = this.ctx.ui.theme;
+		const paint = (s: string) => theme.fg("accent", s);
+		const muted = (s: string) => theme.fg("muted", s);
+		const bold = (s: string) => theme.bold(s);
+
+		if (width < 24) return [paint(`Pi v${VERSION}`)];
+
+		const lines: string[] = [];
+		lines.push(bold(theme.fg("accent", "pi")) + " " + muted(`v${VERSION}`));
+		lines.push("");
+
+		for (const logoLine of renderLogo(this.frame, paint)) {
+			lines.push(center(logoLine, width));
+		}
+
+		lines.push(center(bold("Let's build something great"), width));
+
+		return lines.map((line) => truncateToWidth(line, width, ""));
+	}
+
+	invalidate(): void {}
+
+	dispose(): void {
+		clearInterval(this.timer);
+	}
+}
+
+export function installHeader(pi: ExtensionAPI, ctx: ExtensionContext): () => void {
+	let header: OpenTuiHeader | undefined;
+	ctx.ui.setHeader((tui) => {
+		header?.dispose();
+		header = new OpenTuiHeader(pi, ctx, tui);
+		return header;
+	});
+	return () => {
+		header?.dispose();
+		header = undefined;
+		ctx.ui.setHeader(undefined);
+	};
+}

package/extensions/open-tui/icons.ts

@@ -0,0 +1,194 @@
+export type IconMode = "auto" | "nerd" | "ascii";
+
+export interface IconGlyphs {
+	cwd: string;
+	git: string;
+	working: string;
+	done: string;
+	context: string;
+	model: string;
+	thinking: string;
+	input: string;
+	output: string;
+	cacheHit: string;
+	cost: string;
+	extensions: string;
+	ahead: string;
+	behind: string;
+	diverged: string;
+	conflicted: string;
+	stashed: string;
+	modified: string;
+	staged: string;
+	untracked: string;
+	renamed: string;
+	deleted: string;
+}
+
+const NERD_GLYPHS: IconGlyphs = {
+	cwd: "",
+	git: "",
+	working: "",
+	done: "",
+	context: "",
+	model: "",
+	thinking: "",
+	input: "",
+	output: "",
+	cacheHit: "",
+	cost: "",
+	extensions: "",
+	ahead: "↑",
+	behind: "↓",
+	diverged: "⇕",
+	conflicted: "=",
+	stashed: "$",
+	modified: "!",
+	staged: "+",
+	untracked: "?",
+	renamed: "»",
+	deleted: "✘",
+};
+
+// ponytail: ASCII fallback uses compact symbols (not English words) to keep
+// the footer's icon-like feel on non-Nerd-Font terminals. Symbols chosen to
+// avoid collisions with the git-status set {= S ! A ? r x ^ v}.
+const ASCII_GLYPHS: IconGlyphs = {
+	cwd: "@",
+	git: "*",
+	working: "o",
+	done: "+",
+	context: "%",
+	model: "M",
+	thinking: "~",
+	input: "↑",
+	output: "↓",
+	cacheHit: "c",
+	cost: "$",
+	extensions: "&",
+	ahead: "^",
+	behind: "v",
+	diverged: "^v",
+	conflicted: "=",
+	stashed: "S",
+	modified: "!",
+	staged: "A",
+	untracked: "?",
+	renamed: "r",
+	deleted: "x",
+};
+
+const NERD_FONT_TERMINALS = new Set([
+	"iTerm.app",
+	"Ghostty",
+	"WezTerm",
+	"kitty",
+	"rio",
+	"tabby",
+	"WindowsTerminal",
+	"vscode",
+]);
+
+export function detectNerdFont(): boolean {
+	const termProgram = process.env.TERM_PROGRAM;
+	if (termProgram && NERD_FONT_TERMINALS.has(termProgram)) return true;
+
+	const lcTerminal = process.env.LC_TERMINAL;
+	if (lcTerminal && NERD_FONT_TERMINALS.has(lcTerminal)) return true;
+
+	if (process.env.TERM === "xterm-kitty") return true;
+
+	// Windows Terminal sets WT_SESSION (not TERM_PROGRAM)
+	if (process.env.WT_SESSION) return true;
+
+	// VS Code integrated terminal
+	if (process.env.TERM_PROGRAM === "vscode") return true;
+
+	return false;
+}
+
+export function resolveIconMode(mode: IconMode): "nerd" | "ascii" {
+	if (mode === "nerd") return "nerd";
+	if (mode === "ascii") return "ascii";
+	return detectNerdFont() ? "nerd" : "ascii";
+}
+
+export function resolveGlyphs(mode: IconMode): IconGlyphs {
+	const resolved = resolveIconMode(mode);
+	return resolved === "nerd" ? NERD_GLYPHS : ASCII_GLYPHS;
+}
+
+const RUNTIME_SYMBOLS: Record<string, string> = {
+	nodejs: "\uE718",
+	rust: "\uE7A8",
+	go: "\uE626",
+	python: "\uE73C",
+	ruby: "\uE739",
+	java: "\uE256",
+	cpp: "\uE61D",
+	c: "\uE61E",
+	swift: "\uE755",
+	kotlin: "\uE634",
+	deno: "\uE7FB",
+	bun: "\uE6FB",
+	php: "\uE73D",
+	haskell: "\uE777",
+	julia: "\uE624",
+	lua: "\uE620",
+	elixir: "\uE62B",
+	erlang: "\uE7B1",
+	gleam: "\uE6B4",
+	crystal: "\uE62F",
+	dart: "\uE7C0",
+	nim: "\uE677",
+	zig: "\uE6A9",
+	ocaml: "\uE67A",
+	clojure: "\uE76A",
+	scala: "\uE747",
+	perl: "\uE769",
+	r: "\uE68A",
+	elm: "\uE62C",
+	haxe: "\uE7B7",
+	vagrant: "\uE21A",
+	terraform: "\uE1A5",
+};
+
+const RUNTIME_ASCII_SYMBOLS: Record<string, string> = {
+	nodejs: "node",
+	rust: "rs",
+	go: "go",
+	python: "py",
+	ruby: "rb",
+	java: "java",
+	swift: "swift",
+	kotlin: "kt",
+	cpp: "c++",
+	c: "c",
+	deno: "deno",
+	bun: "bun",
+	php: "php",
+	haskell: "hs",
+	julia: "jl",
+	lua: "lua",
+	elixir: "ex",
+	erlang: "erl",
+	gleam: "gleam",
+	crystal: "cr",
+	dart: "dart",
+	nim: "nim",
+	zig: "zig",
+	ocaml: "ml",
+	clojure: "clj",
+	scala: "scala",
+	perl: "pl",
+	r: "R",
+	elm: "elm",
+	haxe: "hx",
+	vagrant: "vag",
+	terraform: "tf",
+};
+
+export function runtimeSymbol(name: string, mode: IconMode): string {
+	if (resolveIconMode(mode) === "ascii") return RUNTIME_ASCII_SYMBOLS[name] ?? name;
+	return RUNTIME_SYMBOLS[name] ?? "";
+}