@rosetears/aili-pi 0.1.0 → 0.1.1

package/extensions/zentui/git.ts

@@ -0,0 +1,384 @@
+import { execFile } from "node:child_process";
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { promisify } from "node:util";
+
+const execFileAsync = promisify(execFile);
+const GIT_COMMAND_TIMEOUT_MS = 2_000;
+
+export type GitOperationState =
+	| "REBASING"
+	| "MERGING"
+	| "CHERRY-PICKING"
+	| "REVERTING"
+	| "BISECTING";
+
+/**
+ * Starship `git_commit`-style info derived from the existing porcelain probe.
+ *
+ * `oid` is the full `branch.oid` from `git status --porcelain=2 --branch`
+ * (free — no extra git call). `detached` mirrors `branch.head === "(detached)"`.
+ * `tag` is populated only when the caller opts into the exact-tag probe
+ * (`readGitStatus({ readExactTag: true })`); `null` means no exact-match tag
+ * or the probe was skipped.
+ */
+export type GitCommitInfo = {
+	oid: string | null;
+	detached: boolean;
+	tag: string | null;
+};
+
+/**
+ * Starship `git_metrics`-style aggregate line-change counts.
+ * See https://starship.rs/config/#git-metrics
+ */
+export type GitMetricsInfo = {
+	added: number;
+	deleted: number;
+};
+
+export type GitStatusSummary = {
+	branch?: string;
+	dirty: boolean;
+	ahead: number;
+	behind: number;
+	conflicted: number;
+	untracked: number;
+	stashed: number;
+	modified: number;
+	staged: number;
+	renamed: number;
+	deleted: number;
+	typechanged: number;
+	gitState?: GitOperationState;
+	gitStateLabel?: string;
+	commit?: GitCommitInfo;
+	metrics?: GitMetricsInfo | null;
+};
+
+export type GitReadResult =
+	| { kind: "ok"; status: GitStatusSummary }
+	| { kind: "not_a_repo" }
+	| { kind: "error" };
+
+export type GitStatePaths = {
+	rebaseMerge?: string;
+	rebaseApply?: string;
+	mergeHead?: string;
+	cherryPickHead?: string;
+	revertHead?: string;
+	bisectLog?: string;
+	rebaseMsgnum?: string;
+	rebaseEnd?: string;
+};
+
+export function emptyGitStatus(): GitStatusSummary {
+	return {
+		branch: undefined,
+		dirty: false,
+		ahead: 0,
+		behind: 0,
+		conflicted: 0,
+		untracked: 0,
+		stashed: 0,
+		modified: 0,
+		staged: 0,
+		renamed: 0,
+		deleted: 0,
+		typechanged: 0,
+		gitState: undefined,
+		gitStateLabel: undefined,
+		commit: undefined,
+		metrics: undefined,
+	};
+}
+
+export function parseGitStatusPorcelain(stdoutText: string, stashCount: number): GitStatusSummary {
+	const status = emptyGitStatus();
+	status.stashed = stashCount;
+
+	let oid: string | null = null;
+	let sawBranchHead = false;
+	let detached = false;
+
+	for (const line of stdoutText.split(/\r?\n/)) {
+		if (!line) continue;
+		if (line.startsWith("# branch.oid ")) {
+			const value = line.slice("# branch.oid ".length).trim();
+			if (value && value !== "(initial)") oid = value;
+			continue;
+		}
+		if (line.startsWith("# branch.head ")) {
+			sawBranchHead = true;
+			const branch = line.slice("# branch.head ".length).trim();
+			if (branch === "(detached)") {
+				detached = true;
+				status.branch = undefined;
+			} else if (branch) {
+				status.branch = branch;
+			}
+			continue;
+		}
+		if (line.startsWith("# branch.ab ")) {
+			const match = line.match(/\+(\d+)\s+-(\d+)/);
+			if (match) {
+				status.ahead = Number(match[1] ?? 0);
+				status.behind = Number(match[2] ?? 0);
+			}
+			continue;
+		}
+		if (line.startsWith("#")) continue;
+
+		status.dirty = true;
+
+		if (line.startsWith("? ")) {
+			status.untracked += 1;
+			continue;
+		}
+		if (line.startsWith("u ")) {
+			status.conflicted += 1;
+			continue;
+		}
+		if (!(line.startsWith("1 ") || line.startsWith("2 "))) continue;
+
+		const xy = line.split(" ")[1] ?? "..";
+		const x = xy[0] ?? ".";
+		const y = xy[1] ?? ".";
+
+		if (x === "R") status.renamed += 1;
+		else if (x === "D") status.deleted += 1;
+		else if (x === "T") status.typechanged += 1;
+		else if (x !== "." && x !== " ") status.staged += 1;
+
+		if (y === "M") status.modified += 1;
+		else if (y === "D") status.deleted += 1;
+		else if (y === "T") status.typechanged += 1;
+	}
+
+	// Only populate commit info when we actually saw branch headers (inside
+	// a repo with commits). An unborn branch has no oid.
+	if (sawBranchHead) {
+		status.commit = { oid, detached, tag: null };
+	}
+
+	return status;
+}
+
+/**
+ * Parse `git diff --numstat` output into aggregate added/deleted counts.
+ *
+ * Each line is `added\tdeleted\tpath` (or `added\tdeleted\told\tnew` for
+ * renames). Binary rows carry `-` in both numeric columns and are skipped.
+ * Malformed/unparseable lines are ignored rather than aborting the sum.
+ *
+ * See https://git-scm.com/docs/git-diff#Documentation/git-diff.txt---numstat
+ */
+export function parseGitNumstat(stdoutText: string): GitMetricsInfo {
+	let added = 0;
+	let deleted = 0;
+	for (const line of stdoutText.split(/\r?\n/)) {
+		if (!line) continue;
+		const parts = line.split("\t");
+		// `added\tdeleted\tpath...` — need at least 3 tab-delimited fields.
+		if (parts.length < 3) continue;
+		const a = parts[0];
+		const d = parts[1];
+		// Binary files report `-` for both; skip.
+		if (a === "-" || d === "-") continue;
+		const na = Number(a);
+		const nd = Number(d);
+		if (!Number.isFinite(na) || !Number.isFinite(nd)) continue;
+		if (na < 0 || nd < 0) continue;
+		added += na;
+		deleted += nd;
+	}
+	return { added, deleted };
+}
+
+function readOptionalText(path: string | undefined): string | undefined {
+	if (!path || !existsSync(path)) return undefined;
+	try {
+		return readFileSync(path, "utf8").trim();
+	} catch {
+		return undefined;
+	}
+}
+
+/**
+ * Pure git operation-state detector. Paths that exist (truthy strings that
+ * callers verified with `existsSync`) select the active state in Starship order.
+ */
+export function detectGitState(paths: GitStatePaths): {
+	gitState?: GitOperationState;
+	gitStateLabel?: string;
+} {
+	if (paths.rebaseMerge || paths.rebaseApply) {
+		const msgnum = readOptionalText(paths.rebaseMsgnum);
+		const end = readOptionalText(paths.rebaseEnd);
+		if (msgnum && end) {
+			return { gitState: "REBASING", gitStateLabel: `REBASING ${msgnum}/${end}` };
+		}
+		return { gitState: "REBASING", gitStateLabel: "REBASING" };
+	}
+	if (paths.mergeHead) return { gitState: "MERGING", gitStateLabel: "MERGING" };
+	if (paths.cherryPickHead) {
+		return { gitState: "CHERRY-PICKING", gitStateLabel: "CHERRY-PICKING" };
+	}
+	if (paths.revertHead) return { gitState: "REVERTING", gitStateLabel: "REVERTING" };
+	if (paths.bisectLog) return { gitState: "BISECTING", gitStateLabel: "BISECTING" };
+	return {};
+}
+
+async function resolveGitPath(cwd: string, pathSpec: string): Promise<string | undefined> {
+	try {
+		const { stdout } = await execFileAsync("git", ["rev-parse", "--git-path", pathSpec], {
+			cwd,
+			timeout: GIT_COMMAND_TIMEOUT_MS,
+		});
+		const resolved = (typeof stdout === "string" ? stdout : String(stdout)).trim();
+		if (!resolved) return undefined;
+		return resolved.startsWith("/") ? resolved : join(cwd, resolved);
+	} catch {
+		return undefined;
+	}
+}
+
+async function readGitOperationState(cwd: string): Promise<{
+	gitState?: GitOperationState;
+	gitStateLabel?: string;
+}> {
+	const [rebaseMerge, rebaseApply, mergeHead, cherryPickHead, revertHead, bisectLog] =
+		await Promise.all([
+			resolveGitPath(cwd, "rebase-merge"),
+			resolveGitPath(cwd, "rebase-apply"),
+			resolveGitPath(cwd, "MERGE_HEAD"),
+			resolveGitPath(cwd, "CHERRY_PICK_HEAD"),
+			resolveGitPath(cwd, "REVERT_HEAD"),
+			resolveGitPath(cwd, "BISECT_LOG"),
+		]);
+
+	const existing = (path: string | undefined) => (path && existsSync(path) ? path : undefined);
+	const rebaseDir = existing(rebaseMerge) ?? existing(rebaseApply);
+
+	return detectGitState({
+		rebaseMerge: existing(rebaseMerge),
+		rebaseApply: existing(rebaseApply),
+		mergeHead: existing(mergeHead),
+		cherryPickHead: existing(cherryPickHead),
+		revertHead: existing(revertHead),
+		bisectLog: existing(bisectLog),
+		rebaseMsgnum: rebaseDir ? join(rebaseDir, "msgnum") : undefined,
+		rebaseEnd: rebaseDir ? join(rebaseDir, "end") : undefined,
+	});
+}
+
+function isNotARepoError(error: unknown): boolean {
+	const message =
+		error instanceof Error
+			? `${error.message}\n${"stderr" in error ? String((error as { stderr?: unknown }).stderr ?? "") : ""}`
+			: String(error);
+	return /not a git repository|outside repository|not a git repo/i.test(message);
+}
+
+/**
+ * Options for the optional probes that piggyback on the existing git refresh.
+ * Both default to `false` so no extra git process is spawned unless a segment
+ * is enabled and needs the data.
+ */
+export type ReadGitStatusOptions = {
+	/** Run `git describe --tags --exact-match HEAD` for the git_commit segment. */
+	readExactTag?: boolean;
+	/**
+	 * Run `git diff HEAD --numstat` for the git_metrics segment. Uses the
+	 * Starship-like “total dirty” view (staged + unstaged combined).
+	 */
+	readMetrics?: boolean;
+	/** Add `--ignore-submodules=all` to the metrics diff when requested. */
+	ignoreSubmodules?: boolean;
+};
+
+export async function readGitStatus(
+	cwd: string,
+	options: ReadGitStatusOptions = {},
+): Promise<GitReadResult> {
+	const readExactTag = options.readExactTag === true;
+	const readMetrics = options.readMetrics === true;
+	try {
+		const numstatArgs = ["diff", "HEAD", "--numstat"];
+		if (options.ignoreSubmodules) numstatArgs.push("--ignore-submodules=all");
+		const [{ stdout: statusStdout }, stashResult, tagResult, metricsResult] = await Promise.all([
+			execFileAsync("git", ["status", "--porcelain=2", "--branch"], {
+				cwd,
+				timeout: GIT_COMMAND_TIMEOUT_MS,
+			}),
+			execFileAsync("git", ["stash", "list"], {
+				cwd,
+				timeout: GIT_COMMAND_TIMEOUT_MS,
+			}).catch(() => ({ stdout: "" })),
+			readExactTag
+				? execFileAsync("git", ["describe", "--tags", "--exact-match", "HEAD"], {
+						cwd,
+						timeout: GIT_COMMAND_TIMEOUT_MS,
+					}).then(
+						(r) => ({ stdout: typeof r.stdout === "string" ? r.stdout : String(r.stdout) }),
+						() => ({ stdout: "" }),
+					)
+				: Promise.resolve({ stdout: "" }),
+			readMetrics
+				? execFileAsync("git", numstatArgs, {
+						cwd,
+						timeout: GIT_COMMAND_TIMEOUT_MS,
+					}).then(
+						(r) => ({ stdout: typeof r.stdout === "string" ? r.stdout : String(r.stdout) }),
+						() => ({ stdout: "", failed: true as const }),
+					)
+				: Promise.resolve({ stdout: "", failed: true as const }),
+		]);
+		const stdoutText = typeof statusStdout === "string" ? statusStdout : String(statusStdout);
+		const stashStdout =
+			typeof stashResult.stdout === "string" ? stashResult.stdout : String(stashResult.stdout);
+		const stashCount = stashStdout.split(/\r?\n/).filter((line) => line.trim().length > 0).length;
+		const status = parseGitStatusPorcelain(stdoutText, stashCount);
+		if (status.commit) {
+			const tagStdout =
+				typeof tagResult.stdout === "string" ? tagResult.stdout : String(tagResult.stdout);
+			const tag = tagStdout.trim();
+			status.commit = { ...status.commit, tag: tag || null };
+		}
+		if (readMetrics) {
+			if ("failed" in metricsResult && metricsResult.failed) {
+				status.metrics = null;
+			} else {
+				const metricsStdout =
+					typeof metricsResult.stdout === "string"
+						? metricsResult.stdout
+						: String(metricsResult.stdout);
+				status.metrics = parseGitNumstat(metricsStdout);
+			}
+		}
+		const operation = await readGitOperationState(cwd);
+		return {
+			kind: "ok",
+			status: {
+				...status,
+				...operation,
+			},
+		};
+	} catch (error) {
+		if (isNotARepoError(error)) return { kind: "not_a_repo" };
+
+		// Distinguish not-a-repo vs transient with a cheap rev-parse on the error path.
+		try {
+			const { stdout } = await execFileAsync("git", ["rev-parse", "--is-inside-work-tree"], {
+				cwd,
+				timeout: GIT_COMMAND_TIMEOUT_MS,
+			});
+			const inside = (typeof stdout === "string" ? stdout : String(stdout)).trim();
+			if (inside !== "true") return { kind: "not_a_repo" };
+			return { kind: "error" };
+		} catch (inner) {
+			if (isNotARepoError(inner)) return { kind: "not_a_repo" };
+			return { kind: "error" };
+		}
+	}
+}

package/extensions/zentui/gradient.ts

@@ -0,0 +1,70 @@
+import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+
+export type RGB = readonly [number, number, number];
+
+export const SAKURA_MACARON_GRADIENT = "sakura-macaron-gradient";
+export const SAKURA_MACARON_STOPS: readonly RGB[] = [
+	[136, 184, 255], // sakura pink  #88B8FF
+	[125, 228, 255], // sakura-iro   #7DE4FF
+	[188, 167, 255], // petal        #BCA7FF
+	[188, 167, 255], // lavender     #BCA7FF
+	[125, 228, 255], // sky macaron  #7DE4FF
+];
+
+const RESET = "\x1b[0m";
+const GRADIENT_CACHE_LIMIT = 128;
+const gradientCache = new Map<string, string>();
+
+function mix(from: RGB, to: RGB, amount: number): RGB {
+	const t = Math.max(0, Math.min(1, amount));
+	return [
+		Math.round(from[0] + (to[0] - from[0]) * t),
+		Math.round(from[1] + (to[1] - from[1]) * t),
+		Math.round(from[2] + (to[2] - from[2]) * t),
+	];
+}
+
+function sampleGradient(position: number): RGB {
+	const stops = SAKURA_MACARON_STOPS;
+	const normalized = Math.max(0, Math.min(1, position));
+	const scaled = normalized * (stops.length - 1);
+	const index = Math.min(stops.length - 2, Math.floor(scaled));
+	const from = stops[index] ?? SAKURA_MACARON_STOPS[0] ?? [136, 184, 255];
+	const to = stops[index + 1] ?? from;
+	return mix(from, to, scaled - index);
+}
+
+function foreground(color: RGB, text: string): string {
+	return `\x1b[38;2;${color[0]};${color[1]};${color[2]}m${text}`;
+}
+
+/** Render the stable Sakura → sky gradient used by the editor and sent prompts. */
+export function renderSakuraGradient(text: string): string {
+	const cached = gradientCache.get(text);
+	if (cached !== undefined) return cached;
+	const chars = [...text];
+	if (chars.length === 0) return text;
+	const span = Math.max(1, chars.length - 1);
+	const rendered = `${chars.map((char, index) => foreground(sampleGradient(index / span), char)).join("")}${RESET}`;
+	if (gradientCache.size >= GRADIENT_CACHE_LIMIT) {
+		gradientCache.delete(gradientCache.keys().next().value ?? "");
+	}
+	gradientCache.set(text, rendered);
+	return rendered;
+}
+
+/** Add symmetric colored side rails while preserving the terminal width contract. */
+export function renderBoxedLine(
+	line: string,
+	width: number,
+	leftRail: string,
+	rightRail: string,
+): string {
+	if (width <= 0) return "";
+	const leftWidth = visibleWidth(leftRail);
+	const rightWidth = visibleWidth(rightRail);
+	const innerWidth = Math.max(0, width - leftWidth - rightWidth);
+	const content = truncateToWidth(line, innerWidth, "");
+	const padding = " ".repeat(Math.max(0, innerWidth - visibleWidth(content)));
+	return truncateToWidth(`${leftRail}${content}${padding}${rightRail}`, width, "");
+}

package/extensions/zentui/icons.ts

@@ -0,0 +1,252 @@
+/**
+ * Icon mode defaults and resolvers.
+ *
+ * Nerd defaults must stay byte-identical to historical `defaultConfig.icons`,
+ * except where intentionally changed to match the Starship Nerd Font preset.
+ * User string overrides always win over mode defaults.
+ */
+
+export type IconMode = "auto" | "nerd" | "ascii";
+
+export type IconGlyphs = {
+	cwd: string;
+	git: string;
+	ahead: string;
+	behind: string;
+	diverged: string;
+	conflicted: string;
+	untracked: string;
+	stashed: string;
+	modified: string;
+	staged: string;
+	renamed: string;
+	deleted: string;
+	typechanged: string;
+	cacheHit: string;
+	editorPrompt: string;
+	rail: string;
+	username: string;
+	time: string;
+	os: string;
+	package: string;
+};
+
+export type ResolvedIcons = IconGlyphs & { mode: IconMode };
+
+export const ICON_GLYPH_KEYS = [
+	"cwd",
+	"git",
+	"ahead",
+	"behind",
+	"diverged",
+	"conflicted",
+	"untracked",
+	"stashed",
+	"modified",
+	"staged",
+	"renamed",
+	"deleted",
+	"typechanged",
+	"cacheHit",
+	"editorPrompt",
+	"rail",
+	"username",
+	"time",
+	"os",
+	"package",
+] as const satisfies readonly (keyof IconGlyphs)[];
+
+/**
+ * Nerd Font defaults.
+ *
+ * The `cwd` icon is intentionally empty — Starship's `directory` module
+ * has no default symbol. Other defaults match historical values; new
+ * additions (e.g. `package`) come from the Starship Nerd Font preset
+ * (https://starship.rs/presets/nerd-font).
+ */
+export const NERD_DEFAULT_ICONS: IconGlyphs = {
+	cwd: "",
+	git: "",
+	ahead: "↑",
+	behind: "↓",
+	diverged: "⇕",
+	conflicted: "=",
+	untracked: "?",
+	stashed: "$",
+	modified: "!",
+	staged: "+",
+	renamed: "»",
+	deleted: "✘",
+	typechanged: "T",
+	cacheHit: "󰆼",
+	editorPrompt: "",
+	rail: "│",
+	username: "",
+	time: "",
+	os: "",
+	// Starship Nerd Font preset — `package` module glyph.
+	package: "",
+};
+
+export const ASCII_DEFAULT_ICONS: IconGlyphs = {
+	cwd: "",
+	git: "*",
+	ahead: "^",
+	behind: "v",
+	diverged: "^v",
+	conflicted: "=",
+	untracked: "?",
+	stashed: "$",
+	modified: "!",
+	staged: "+",
+	renamed: ">",
+	deleted: "x",
+	typechanged: "T",
+	cacheHit: "c",
+	editorPrompt: "",
+	rail: "|",
+	username: "@",
+	time: "t",
+	os: "o",
+	package: "pkg",
+};
+
+export const OS_PLATFORM_ICONS_NERD: Record<string, string> = {
+	darwin: "\uf179",
+	linux: "\uf17c",
+	win32: "\uf17a",
+};
+
+export const OS_PLATFORM_ICONS_ASCII: Record<string, string> = {
+	darwin: "mac",
+	linux: "linux",
+	win32: "win",
+};
+
+/** Short ASCII labels keyed by runtime `name`. */
+export const RUNTIME_ASCII_SYMBOLS: Record<string, string> = {
+	xmake: "xm",
+	maven: "mvn",
+	gradle: "grd",
+	bun: "bun",
+	deno: "deno",
+	lua: "lua",
+	nodejs: "node",
+	python: "py",
+	golang: "go",
+	rust: "rs",
+	java: "java",
+	ruby: "rb",
+	php: "php",
+	buf: "buf",
+	cmake: "cmake",
+	cpp: "c++",
+	c: "c",
+	cobol: "cob",
+	conda: "conda",
+	crystal: "cr",
+	dart: "dart",
+	dotnet: ".net",
+	elixir: "ex",
+	elm: "elm",
+	erlang: "erl",
+	fennel: "fnl",
+	fortran: "f90",
+	gleam: "glm",
+	guix_shell: "guix",
+	haskell: "hs",
+	haxe: "hx",
+	helm: "helm",
+	julia: "jl",
+	kotlin: "kt",
+	meson: "meson",
+	mojo: "mojo",
+	nim: "nim",
+	nix_shell: "nix",
+	ocaml: "ml",
+	odin: "odin",
+	opa: "opa",
+	perl: "pl",
+	pixi: "pixi",
+	pulumi: "pul",
+	purescript: "purs",
+	raku: "raku",
+	red: "red",
+	rlang: "R",
+	scala: "scala",
+	solidity: "sol",
+	spack: "spack",
+	swift: "swift",
+	terraform: "tf",
+	typst: "typ",
+	vagrant: "vag",
+	vlang: "v",
+	zig: "zig",
+};
+
+export function isIconMode(value: unknown): value is IconMode {
+	return value === "auto" || value === "nerd" || value === "ascii";
+}
+
+export function normalizeIconMode(value: unknown): IconMode {
+	return isIconMode(value) ? value : "auto";
+}
+
+export function modeDefaultIcons(mode: IconMode): IconGlyphs {
+	return mode === "ascii" ? { ...ASCII_DEFAULT_ICONS } : { ...NERD_DEFAULT_ICONS };
+}
+
+export function resolveConfiguredIcons(
+	mode: IconMode,
+	overrides: Partial<IconGlyphs> = {},
+): ResolvedIcons {
+	const base = modeDefaultIcons(mode);
+	const rail =
+		typeof overrides.rail === "string" && overrides.rail.trim().length > 0
+			? overrides.rail
+			: base.rail;
+	return {
+		mode,
+		...base,
+		...overrides,
+		rail,
+	};
+}
+
+/**
+ * Honor a custom `icons.os` when it differs from the mode default.
+ * Otherwise map by platform for the active mode.
+ */
+export function resolveOsIcon(
+	configuredOsIcon: string,
+	mode: IconMode = "auto",
+	platform: string = process.platform,
+): string {
+	const modeDefault = modeDefaultIcons(mode).os;
+	if (configuredOsIcon !== modeDefault) return configuredOsIcon;
+	const platformMap = mode === "ascii" ? OS_PLATFORM_ICONS_ASCII : OS_PLATFORM_ICONS_NERD;
+	return platformMap[platform] ?? configuredOsIcon;
+}
+
+export function resolveRuntimeSymbol(
+	name: string,
+	nerdSymbol: string,
+	mode: IconMode = "auto",
+): string {
+	if (mode !== "ascii") return nerdSymbol;
+	return RUNTIME_ASCII_SYMBOLS[name] ?? (name.slice(0, 3) || "*");
+}
+
+/**
+ * Resolve the package-version segment icon for the active mode.
+ *
+ * Honors a configured `icons.package` override; otherwise falls back to the
+ * mode default (Nerd Font preset / ASCII label).
+ */
+export function resolvePackageIcon(configuredPackageIcon: string, mode: IconMode = "auto"): string {
+	const modeDefault = modeDefaultIcons(mode).package;
+	if (typeof configuredPackageIcon === "string" && configuredPackageIcon.length > 0) {
+		return configuredPackageIcon;
+	}
+	return modeDefault;
+}