pi-open-tui 0.1.0

package/extensions/open-tui/index.ts

@@ -0,0 +1,241 @@
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { type OpenTuiConfig, DEFAULT_CONFIG, ensureConfigExists, loadConfig, saveConfig } from "./config.ts";
+import { installEditor } from "./editor.ts";
+import { installFooter } from "./footer.ts";
+import { installHeader } from "./header.ts";
+import { readGitStatus } from "./git.ts";
+import { readRuntimeInfo } from "./runtime.ts";
+import { SessionLifecycle } from "./session-lifecycle.ts";
+import { registerSettingsCommand } from "./settings-command.ts";
+import {
+	createInitialState,
+	getModelMeta,
+	invalidateUsageCache,
+	type FooterState,
+} from "./state.ts";
+
+function isInteractiveLaunch(): boolean {
+	if (!process.stdout.isTTY) return false;
+	const args = process.argv.slice(2);
+	const nonInteractiveFlags = ["-p", "--print", "--help", "-h", "--version", "-v", "--list-models", "--export"];
+	for (const arg of args) {
+		if (nonInteractiveFlags.includes(arg)) return false;
+		if (arg.startsWith("--mode")) return false;
+	}
+	return true;
+}
+
+function clearVisibleScreen(): void {
+	if (process.stdout.isTTY) {
+		process.stdout.write("\x1b[2J\x1b[H");
+	}
+}
+
+function isTuiContext(ctx: ExtensionContext): boolean {
+	try {
+		const mode = (ctx as ExtensionContext & { mode?: string }).mode;
+		return ctx.hasUI && (mode === undefined || mode === "tui");
+	} catch {
+		return false;
+	}
+}
+
+export default function (pi: ExtensionAPI) {
+	const sessionLifecycle = new SessionLifecycle();
+	const state: FooterState = createInitialState();
+
+	let config: OpenTuiConfig = structuredClone(DEFAULT_CONFIG);
+	let active = false;
+	let lastCtx: ExtensionContext | undefined;
+	let requestFooterRender: (() => void) | undefined;
+	let workingTimer: ReturnType<typeof setInterval> | undefined;
+	let cleanupHeader: (() => void) | undefined;
+	let cleanupFooter: (() => void) | undefined;
+	let cleanupEditor: (() => void) | undefined;
+
+	const getThinkingLevel = () => (sessionLifecycle.isCurrent() ? pi.getThinkingLevel() : "off");
+
+	const applyUi = (ctx: ExtensionContext) => {
+		if (!isTuiContext(ctx)) return;
+		if (!config.enabled) {
+			uninstallUi(ctx);
+			return;
+		}
+		if (!active) {
+			cleanupHeader = installHeader(pi, ctx);
+			cleanupFooter = installFooter(
+				ctx,
+				() => state,
+				() => config,
+				() => getModelMeta(ctx, getThinkingLevel),
+				{
+					setRequestRender: (fn) => {
+						requestFooterRender = fn ?? undefined;
+					},
+					scheduleGitRefresh: () => {
+						void scheduleGitRefresh(ctx);
+					},
+				},
+			);
+			cleanupEditor = installEditor(pi, ctx);
+			active = true;
+		}
+	};
+
+	const uninstallUi = (ctx: ExtensionContext) => {
+		if (!isTuiContext(ctx)) return;
+		if (active) {
+			cleanupHeader?.();
+			cleanupFooter?.();
+			cleanupEditor?.();
+			cleanupHeader = undefined;
+			cleanupFooter = undefined;
+			cleanupEditor = undefined;
+			requestFooterRender = undefined;
+			active = false;
+		}
+	};
+
+	const scheduleGitRefresh = async (ctx: ExtensionContext) => {
+		if (!sessionLifecycle.isCurrent()) return;
+		const generation = sessionLifecycle.currentGeneration();
+		const cwd = ctx.cwd;
+		const git = await readGitStatus(cwd, {
+			readCommit: config.footerSegments.gitCommit,
+			readTag: config.footerSegments.gitCommit,
+		});
+		if (!sessionLifecycle.isCurrent(generation)) return;
+		state.git = git;
+		requestFooterRender?.();
+	};
+
+	const refreshRuntime = async (ctx: ExtensionContext) => {
+		if (!sessionLifecycle.isCurrent()) return;
+		const generation = sessionLifecycle.currentGeneration();
+		const cwd = ctx.cwd;
+		const runtime = await readRuntimeInfo(cwd);
+		if (!sessionLifecycle.isCurrent(generation)) return;
+		state.runtime = runtime;
+		requestFooterRender?.();
+	};
+
+	const refreshInteractiveState = (ctx: ExtensionContext, project = false) => {
+		if (!sessionLifecycle.isCurrent() || !ctx.hasUI) return;
+		if (project) {
+			void scheduleGitRefresh(ctx);
+			void refreshRuntime(ctx);
+		}
+		requestFooterRender?.();
+	};
+
+	const startWorkingTimer = () => {
+		stopWorkingTimer();
+		const tick = () => {
+			if (!sessionLifecycle.isCurrent() || !active) return;
+			requestFooterRender?.();
+		};
+		tick();
+		workingTimer = setInterval(tick, 250);
+		workingTimer.unref?.();
+	};
+
+	const stopWorkingTimer = () => {
+		if (workingTimer) {
+			clearInterval(workingTimer);
+			workingTimer = undefined;
+		}
+	};
+
+	pi.on("session_start", async (_event, ctx) => {
+		sessionLifecycle.start();
+		lastCtx = ctx;
+		state.sessionStartEpoch = Date.now();
+		state.workingSince = undefined;
+		state.lastDoneIn = undefined;
+		invalidateUsageCache();
+
+		ensureConfigExists();
+		config = loadConfig((msg, level) => ctx.ui.notify(msg, level));
+
+		if (isInteractiveLaunch() && config.enabled) {
+			clearVisibleScreen();
+		}
+
+		applyUi(ctx);
+
+		refreshInteractiveState(ctx, true);
+	});
+
+	pi.on("session_shutdown", async (_event, ctx) => {
+		sessionLifecycle.shutdown();
+		stopWorkingTimer();
+		if (active) {
+			uninstallUi(ctx);
+		}
+		lastCtx = undefined;
+	});
+
+	pi.on("agent_start", (_event, _ctx) => {
+		if (!sessionLifecycle.isCurrent()) return;
+		state.workingSince = Date.now();
+		state.lastDoneIn = undefined;
+		startWorkingTimer();
+	});
+
+	pi.on("agent_end", (_event, _ctx) => {
+		if (!sessionLifecycle.isCurrent()) return;
+		stopWorkingTimer();
+		if (state.workingSince !== undefined) {
+			state.lastDoneIn = Date.now() - state.workingSince;
+			state.workingSince = undefined;
+		}
+		requestFooterRender?.();
+	});
+
+	pi.on("model_select", (_event, ctx) => {
+		refreshInteractiveState(ctx);
+	});
+
+	pi.on("thinking_level_select", (_event, ctx) => {
+		refreshInteractiveState(ctx);
+	});
+
+	pi.on("message_end", (_event, ctx) => {
+		if (!sessionLifecycle.isCurrent()) return;
+		invalidateUsageCache();
+		refreshInteractiveState(ctx);
+	});
+
+	pi.on("tool_execution_end", (_event, ctx) => {
+		refreshInteractiveState(ctx);
+	});
+
+	pi.on("session_compact", (_event, ctx) => {
+		if (!sessionLifecycle.isCurrent()) return;
+		invalidateUsageCache();
+		refreshInteractiveState(ctx);
+	});
+
+	pi.on("session_tree", (_event, ctx) => {
+		if (!sessionLifecycle.isCurrent()) return;
+		invalidateUsageCache();
+		refreshInteractiveState(ctx);
+	});
+
+	registerSettingsCommand(pi, {
+		getConfig: () => config,
+		onConfigChanged: (newConfig) => {
+			const wasEnabled = config.enabled;
+			saveConfig(newConfig);
+			config = newConfig;
+			if (lastCtx && wasEnabled !== newConfig.enabled) {
+				if (newConfig.enabled) {
+					applyUi(lastCtx);
+				} else {
+					uninstallUi(lastCtx);
+				}
+			}
+			requestFooterRender?.();
+		},
+	});
+}

package/extensions/open-tui/runtime.ts

@@ -0,0 +1,174 @@
+import { execFile } from "node:child_process";
+import { existsSync, readdirSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { promisify } from "node:util";
+
+const execFileAsync = promisify(execFile);
+const VERSION_TIMEOUT_MS = 2500;
+
+export interface RuntimeInfo {
+	name: string;
+	version?: string;
+}
+
+interface RuntimeDef {
+	name: string;
+	files: readonly string[];
+	folders?: readonly string[];
+	extensions?: readonly string[];
+	env?: string;
+	versionCommand?: { cmd: string; args?: string[]; pattern?: RegExp };
+}
+
+const RUNTIMES: readonly RuntimeDef[] = [
+	{ name: "nodejs", files: ["package.json", ".nvmrc", ".node-version"], versionCommand: { cmd: "node", args: ["--version"], pattern: /v(\d+\.\d+\.\d+)/ } },
+	{ name: "rust", files: ["Cargo.toml"], versionCommand: { cmd: "rustc", args: ["--version"], pattern: /rustc\s+(\d+\.\d+\.\d+)/ } },
+	{ name: "go", files: ["go.mod"], versionCommand: { cmd: "go", args: ["version"], pattern: /go(\d+\.\d+\.\d+)/ } },
+	{ name: "python", files: ["pyproject.toml", "requirements.txt", "setup.py", "Pipfile", ".python-version"], versionCommand: { cmd: "python3", args: ["--version"], pattern: /Python\s+(\d+\.\d+\.\d+)/ } },
+	{ name: "ruby", files: ["Gemfile", ".ruby-version"], versionCommand: { cmd: "ruby", args: ["--version"], pattern: /ruby\s+(\d+\.\d+\.\d+)/ } },
+	{ name: "java", files: ["pom.xml", "build.gradle", "build.gradle.kts", ".java-version"], versionCommand: { cmd: "java", args: ["-version"], pattern: /version\s+"(\d+\.\d+[\.\d]*)"/ } },
+	{ name: "swift", files: ["Package.swift"], versionCommand: { cmd: "swift", args: ["--version"], pattern: /Swift\s+(\d+\.\d+)/ } },
+	{ name: "kotlin", files: ["build.gradle.kts", "settings.gradle.kts"] },
+	{ name: "cpp", files: ["CMakeLists.txt", "Makefile"] },
+	{ name: "c", files: ["Makefile", "CMakeLists.txt"] },
+	{ name: "deno", files: ["deno.json", "deno.jsonc", "deno.lock"], versionCommand: { cmd: "deno", args: ["--version"], pattern: /deno\s+(\d+\.\d+\.\d+)/ } },
+	{ name: "bun", files: ["bun.lock", "bun.lockb"], versionCommand: { cmd: "bun", args: ["--version"], pattern: /(\d+\.\d+\.\d+)/ } },
+	{ name: "php", files: ["composer.json"], versionCommand: { cmd: "php", args: ["--version"], pattern: /PHP\s+(\d+\.\d+\.\d+)/ } },
+	{ name: "haskell", files: ["stack.yaml", "cabal.project", ".cabal"], versionCommand: { cmd: "ghc", args: ["--version"], pattern: /(\d+\.\d+\.\d+)/ } },
+	{ name: "julia", files: ["Project.toml", "Manifest.toml"], versionCommand: { cmd: "julia", args: ["--version"], pattern: /julia\s+(\d+\.\d+\.\d+)/ } },
+	{ name: "lua", files: ["stylua.toml", ".luarc.json"], versionCommand: { cmd: "lua", args: ["-v"], pattern: /Lua\s+(\d+\.\d+)/ } },
+	{ name: "elixir", files: ["mix.exs"], versionCommand: { cmd: "elixir", args: ["--version"], pattern: /Elixir\s+(\d+\.\d+\.\d+)/ } },
+	{ name: "erlang", files: ["rebar.config", "erlang.mk"] },
+	{ name: "gleam", files: ["gleam.toml"], versionCommand: { cmd: "gleam", args: ["--version"], pattern: /gleam\s+(\d+\.\d+\.\d+)/ } },
+	{ name: "crystal", files: ["shard.yml"], versionCommand: { cmd: "crystal", args: ["--version"], pattern: /Crystal\s+(\d+\.\d+\.\d+)/ } },
+	{ name: "dart", files: ["pubspec.yaml"], versionCommand: { cmd: "dart", args: ["--version"], pattern: /Dart\s+SDK\s+version:\s+(\d+\.\d+\.\d+)/ } },
+	{ name: "nim", files: ["nim.cfg", ".nimble"] },
+	{ name: "zig", files: ["build.zig"], versionCommand: { cmd: "zig", args: ["version"], pattern: /(\d+\.\d+\.\d+)/ } },
+	{ name: "ocaml", files: [".opam", "dune", "dune-project"] },
+	{ name: "clojure", files: ["project.clj", "deps.edn"] },
+	{ name: "scala", files: ["build.sbt", ".scala", ".metals"] },
+	{ name: "perl", files: ["Makefile.PL", "cpanfile"] },
+	{ name: "r", files: [".Rproj", "DESCRIPTION"] },
+	{ name: "elm", files: ["elm.json"] },
+	{ name: "haxe", files: ["haxelib.json", ".haxerc"] },
+	{ name: "vagrant", files: ["Vagrantfile"] },
+	{ name: "terraform", files: ["main.tf", "variables.tf"], folders: [".terraform"] },
+	{ name: "helm", files: ["Chart.yaml", "helmfile.yaml"] },
+	{ name: "solidity", files: [], extensions: [".sol"] },
+	{ name: "fortran", files: ["fpm.toml"], extensions: [".f", ".f90", ".f95"] },
+	{ name: "mojo", files: [], extensions: [".mojo"] },
+	{ name: "red", files: [], extensions: [".red", ".reds"] },
+	{ name: "raku", files: ["META6.json"], extensions: [".raku", ".rakumod"] },
+	{ name: "purescript", files: ["spago.dhall", "spago.yaml"] },
+	{ name: "fennel", files: [], extensions: [".fnl"] },
+	{ name: "odin", files: [], extensions: [".odin"] },
+	{ name: "v", files: ["v.mod", "vpkg.json"], extensions: [".v"] },
+	{ name: "xmake", files: ["xmake.lua"] },
+	{ name: "gradle", files: ["build.gradle", "build.gradle.kts"], folders: ["gradle"] },
+	{ name: "maven", files: ["pom.xml"] },
+	{ name: "cmake", files: ["CMakeLists.txt", "CMakeCache.txt"] },
+	{ name: "meson", files: ["meson.build"], env: "MESON_DEVENV" },
+	{ name: "nix", files: ["flake.nix", "shell.nix"], env: "IN_NIX_SHELL" },
+	{ name: "guix", files: [], env: "GUIX_ENVIRONMENT" },
+	{ name: "conda", files: [], env: "CONDA_DEFAULT_ENV" },
+	{ name: "pixi", files: ["pixi.toml", "pixi.lock"], env: "PIXI_ENVIRONMENT_NAME" },
+	{ name: "spack", files: [], env: "SPACK_ENV" },
+	{ name: "pulumi", files: ["Pulumi.yaml", "Pulumi.yml"] },
+	{ name: "typst", files: ["template.typ"], extensions: [".typ"] },
+	{ name: "buf", files: ["buf.yaml", "buf.gen.yaml", "buf.work.yaml"] },
+	{ name: "dotnet", files: [".csproj", ".fsproj", "global.json", "Directory.Build.props"] },
+	{ name: "cobol", files: [], extensions: [".cbl", ".cob"] },
+];
+
+interface CacheEntry {
+	fingerprint: string;
+	runtime: RuntimeInfo | null;
+}
+
+const cache = new Map<string, CacheEntry>();
+const CACHE_MAX = 32;
+
+function fingerprint(cwd: string, def: RuntimeDef): string {
+	const parts: string[] = [];
+	for (const f of def.files) {
+		try {
+			const stat = statSync(join(cwd, f));
+			parts.push(`${f}:${stat.mtimeMs}`);
+		} catch { /* ignore */ }
+	}
+	if (def.extensions || def.folders) {
+		try {
+			const entries = readdirSync(cwd);
+			parts.push(...entries.slice().sort());
+		} catch { /* ignore */ }
+	}
+	if (def.env && process.env[def.env]) {
+		parts.push(`${def.env}=${process.env[def.env]}`);
+	}
+	return parts.join("\0");
+}
+
+function matchesDef(cwd: string, def: RuntimeDef): boolean {
+	if (def.env && process.env[def.env]) return true;
+	if (def.files.some((f) => existsSync(join(cwd, f)))) return true;
+	if (def.folders?.some((f) => existsSync(join(cwd, f)))) return true;
+	if (def.extensions) {
+		try {
+			const entries = readdirSync(cwd);
+			if (entries.some((e) => def.extensions!.some((ext) => e.endsWith(ext)))) return true;
+		} catch { /* ignore */ }
+	}
+	return false;
+}
+
+async function fetchVersion(def: RuntimeDef, cwd: string): Promise<string | undefined> {
+	if (!def.versionCommand) return undefined;
+	try {
+		const { stdout } = await execFileAsync(def.versionCommand.cmd, def.versionCommand.args ?? [], {
+			cwd,
+			timeout: VERSION_TIMEOUT_MS,
+			maxBuffer: 64 * 1024,
+		});
+		if (def.versionCommand.pattern) {
+			const match = stdout.match(def.versionCommand.pattern);
+			return match?.[1];
+		}
+		return stdout.trim() || undefined;
+	} catch {
+		return undefined;
+	}
+}
+
+export async function readRuntimeInfo(cwd: string): Promise<RuntimeInfo | null> {
+	for (const def of RUNTIMES) {
+		if (!matchesDef(cwd, def)) continue;
+		const fp = fingerprint(cwd, def);
+		const cacheKey = `${cwd}\0${def.name}`;
+		const cached = cache.get(cacheKey);
+		if (cached && cached.fingerprint === fp) {
+			return cached.runtime;
+		}
+
+		for (const key of cache.keys()) {
+			if (key === cacheKey || key.startsWith(`${cwd}\0`)) cache.delete(key);
+		}
+
+		const version = await fetchVersion(def, cwd);
+		const info: RuntimeInfo = {
+			name: def.name,
+			version,
+		};
+		cache.set(cacheKey, { fingerprint: fp, runtime: info });
+		while (cache.size > CACHE_MAX) {
+			const oldest = cache.keys().next().value;
+			if (oldest === undefined) break;
+			cache.delete(oldest);
+		}
+		return info;
+	}
+	return null;
+}
+
+export function clearRuntimeCache(): void {
+	cache.clear();
+}

package/extensions/open-tui/session-lifecycle.ts

@@ -0,0 +1,43 @@
+export class SessionLifecycle {
+	private current = 0;
+	private deferred: Array<() => void> = [];
+	private shutDown = false;
+
+	start(): void {
+		this.current++;
+		this.shutDown = false;
+		this.flushDeferred();
+	}
+
+	shutdown(): void {
+		this.shutDown = true;
+		this.deferred = [];
+	}
+
+	isCurrent(generation?: number): boolean {
+		if (this.shutDown) return false;
+		if (generation === undefined) return true;
+		return generation === this.current;
+	}
+
+	currentGeneration(): number {
+		return this.current;
+	}
+
+	defer(fn: () => void): void {
+		if (this.shutDown) return;
+		this.deferred.push(fn);
+	}
+
+	private flushDeferred(): void {
+		const pending = this.deferred;
+		this.deferred = [];
+		for (const fn of pending) {
+			try {
+				fn();
+			} catch {
+				// ponytail: silent fallback — deferred tasks are best-effort
+			}
+		}
+	}
+}