pi-tui-footer 1.2.0

package/extensions/rounded-tools.ts

@@ -0,0 +1,269 @@
+/**
+ * Rounded tool frames (merged port) — rounded frames for tool calls and results.
+ *
+ * Merged 2026-08 from the standalone local extension rounded-tools.ts (a
+ * localized copy of npm:pi-rounded-tools@0.1.3, MIT, by OrionPax,
+ * https://github.com/orionpax1997/pi-rounded-tools), integrated into pi-tui
+ * (based on https://github.com/OldSuns/pi-open-tui v0.3.7, MIT, by
+ * OldSun) and gated behind `roundedTools` in pi-tui config
+ * (~/.pi/agent/pi-tui.json, default on).
+ *
+ * Re-registers the built-in tools (read, write, edit, bash, grep, find, ls)
+ * with `renderShell: "self"` and wraps each tool call / result in a frame
+ * drawn with Unicode rounded-corner characters (╭ ╮ ╰ ╯ ─ │).
+ *
+ * No left color bar, no theme matching — just the corners.
+ * Border color follows `theme.fg("border", …)` so it adapts to your theme.
+ *
+ * Implementation note: we don't reimplement the inner rendering — we just
+ * call the built-in `renderCall` / `renderResult` and wrap the returned
+ * component in a `RoundedFrame`. That way bash's preview, read's syntax
+ * highlighting, edit's diff stats, etc. all stay exactly as pi ships them.
+ *
+ * Disabling registers the plain built-in definitions again, restoring stock
+ * rendering in the current session without a /reload.
+ */
+
+import type { ExtensionAPI, ToolDefinition } from "@earendil-works/pi-coding-agent";
+import {
+	createBashToolDefinition,
+	createEditToolDefinition,
+	createFindToolDefinition,
+	createGrepToolDefinition,
+	createLsToolDefinition,
+	createReadToolDefinition,
+	createWriteToolDefinition,
+} from "@earendil-works/pi-coding-agent";
+import type { Component } from "@earendil-works/pi-tui";
+import { visibleWidth } from "@earendil-works/pi-tui";
+
+// ─── Rounded-corner frame ────────────────────────────────────────────────
+//
+// Three modes let call + result stack into one continuous frame:
+//   - "closed"      → ╭ ── ╮ / │ x │ / ╰ ── ╯ (standalone box)
+//   - "open-bottom" → ╭ ── ╮ / │ x │        (top of a stacked frame)
+//   - "open-top"    →        │ x │ / ╰ ── ╯ (bottom of a stacked frame)
+
+type FrameMode = "closed" | "open-bottom" | "open-top";
+
+class RoundedFrame implements Component {
+	constructor(
+		private readonly inner: Component,
+		private readonly border: (text: string) => string,
+		private readonly mode: FrameMode = "closed",
+	) {}
+
+	invalidate(): void {
+		this.inner.invalidate?.();
+		this.cachedWidth = undefined;
+		this.cachedInnerLines = undefined;
+		this.cachedLines = undefined;
+	}
+
+	// pi's built-in tool renderers cache the previously-returned component
+	// via `context.lastComponent` and call mutating methods on it
+	// (`Text.setText`, `Container.clear`/`addChild`, `invalidate`) so they
+	// can re-render in place during streaming. Once we wrap the inner in a
+	// RoundedFrame, pi hands our wrapper back to the inner renderer on the
+	// next render — but pi's try/catch around `callRenderer(...)` falls
+	// back to a plain `createCallFallback()` text node if the inner
+	// renderer throws, which would make the border vanish on every
+	// Ctrl+O toggle. Forward these methods to the inner so the original
+	// renderers work unchanged; calls on a wrapper whose inner lacks the
+	// method are no-ops thanks to optional chaining.
+	setText(text: string): void {
+		(this.inner as any).setText?.(text);
+	}
+
+	clear(): void {
+		(this.inner as any).clear?.();
+	}
+
+	addChild(child: any): void {
+		(this.inner as any).addChild?.(child);
+	}
+
+	render(width: number): string[] {
+		if (width < 4) {
+			return this.inner.render(width);
+		}
+
+		const innerWidth = Math.max(1, width - 4); // │ + space + content + space + │
+		const innerLines = this.inner.render(innerWidth);
+
+		// pi's TUI re-renders every transcript component on every render
+		// cycle (each keystroke), but built-in components below us (e.g.
+		// `Text`, `Box`) cache their rendered line arrays and return the
+		// same array reference when content and width haven't changed.
+		// Without a cache here, every keystroke re-runs `visibleWidth()`
+		// (ANSI parsing) and string building for every line of every
+		// framed tool entry — O(N_session) per keypress, visible as input
+		// lag on long sessions.
+		//
+		// Cache key: `width` plus the array reference returned by
+		// `inner.render()`. Built-in Text/Box return the same reference on
+		// cache hits and a fresh array whenever their content changes
+		// (e.g. Ctrl+O expand), so reference equality is a reliable change
+		// signal. `invalidate()` (theme changes etc.) clears the cache
+		// explicitly, and so does an actual `width` change.
+		if (
+			this.cachedLines &&
+			this.cachedWidth === width &&
+			this.cachedInnerLines === innerLines
+		) {
+			return this.cachedLines;
+		}
+
+		const horizontal = "─".repeat(Math.max(0, width - 2));
+		const side = this.border("│");
+
+		const out: string[] = [];
+
+		if (this.mode !== "open-top") {
+			out.push(this.border("╭" + horizontal + "╮"));
+		}
+
+		if (innerLines.length > 0) {
+			for (const line of innerLines) {
+				const vis = visibleWidth(line);
+				const pad = " ".repeat(Math.max(0, innerWidth - vis));
+				out.push(side + " " + line + pad + " " + side);
+			}
+		} else if (this.mode === "closed") {
+			// Standalone closed frame with no content: draw a placeholder row
+			// so the box still has visual presence. Skipped for open-top /
+			// open-bottom since they pair with another half-frame and a fake
+			// empty row would show up as a stray blank line in the middle.
+			out.push(side + " ".repeat(width - 2) + side);
+		}
+
+		if (this.mode !== "open-bottom") {
+			out.push(this.border("╰" + horizontal + "╯"));
+		}
+		this.cachedWidth = width;
+		this.cachedInnerLines = innerLines;
+		this.cachedLines = out;
+		return out;
+	}
+
+	private cachedWidth: number | undefined;
+	private cachedInnerLines: string[] | undefined;
+	private cachedLines: string[] | undefined;
+}
+
+const frame = (
+	inner: Component,
+	theme: { fg: (color: string, text: string) => string },
+	mode: FrameMode = "closed",
+	colorKey: string = "border",
+): Component => new RoundedFrame(inner, (t) => theme.fg(colorKey, t), mode);
+
+/**
+ * Pick a border color key based on the tool's runtime state.
+ *
+ *   - still running (`context.isPartial`) → warning (yellow)
+ *   - finished with an error (`context.isError`) → error (red)
+ *   - finished successfully → border (theme default)
+ *
+ * Both `renderCall` and `renderResult` go through this picker, so when
+ * they stack into one continuous frame, the borders match. pi re-renders
+ * the whole component on every state transition (args streaming → done,
+ * partial → final), and `context.isPartial` flips accordingly, so call
+ * and result always pick the same color at any given moment.
+ *
+ * Mirrors pi's own 3-state scheme (`toolPendingBg` / `toolSuccessBg` /
+ * `toolErrorBg`) — see `theme.js`.
+ */
+function borderColorFor(
+	context: { isPartial?: boolean; isError?: boolean } | undefined,
+): string {
+	if (context?.isPartial) return "warning";
+	if (context?.isError) return "error";
+	return "border";
+}
+
+// ─── Helpers ─────────────────────────────────────────────────────────────
+
+type ToolDef = ToolDefinition<any, any, any>;
+
+const EMPTY_COMPONENT: Component = { render: () => [], invalidate: () => {} };
+
+/**
+ * Wrap a built-in tool definition in rounded frames.
+ *
+ * We spread the original definition first so we preserve every metadata
+ * field (promptSnippet / promptGuidelines / prepareArguments /
+ * constrainedSampling / executionMode / …) — only the renderers and
+ * `renderShell` are overwritten. This keeps the tool's LLM-facing prompt
+ * data intact, edit's argument pre-processing intact, etc.
+ */
+function wrapBuiltin(def: ToolDef) {
+	return {
+		...def,
+		renderShell: "self" as const,
+		renderCall: (args: any, theme: any, context: any) => {
+			// Hide our (or any) previous wrapper from the inner renderer so it
+			// doesn't treat a RoundedFrame as its own lastComponent — that
+			// would either throw (`Text.setText` is missing) or nest frames
+			// (`inner = previous RoundedFrame` → we re-wrap it). Forcing the
+			// inner to allocate fresh costs one Text/Container per render but
+			// keeps every render independent and CC-protect against future
+			// tool changes.
+			const inner: Component = def.renderCall
+				? def.renderCall(args, theme, { ...context, lastComponent: undefined })
+				: EMPTY_COMPONENT;
+			// During execution pi re-renders every tick (e.g. bash's elapsed
+			// timer). Skip the frame then — keeping its borders stable avoids
+			// redraw flicker — and only wrap it once the tool settles.
+			if (context?.isPartial) return inner;
+			return frame(inner, theme, "open-bottom", borderColorFor(context));
+		},
+		renderResult: (result: any, options: any, theme: any, context: any) => {
+			const inner: Component = def.renderResult
+				? def.renderResult(result, options, theme, { ...context, lastComponent: undefined })
+				: EMPTY_COMPONENT;
+			if (context?.isPartial) return inner;
+			return frame(inner, theme, "open-top", borderColorFor(context));
+		},
+	};
+}
+
+/**
+ * Register the 7 built-in file/bash tools, either with rounded frames
+ * (`enabled`) or with their plain stock definitions (`!enabled`, restores
+ * original rendering). Registration refreshes the active tool set in the
+ * current session, so toggling the setting takes effect immediately.
+ */
+export function registerRoundedTools(pi: ExtensionAPI, enabled: boolean, cwd: string): void {
+	const tools: ToolDef[] = [
+		createReadToolDefinition(cwd),
+		createWriteToolDefinition(cwd),
+		createEditToolDefinition(cwd),
+		createBashToolDefinition(cwd),
+		createGrepToolDefinition(cwd),
+		createFindToolDefinition(cwd),
+		createLsToolDefinition(cwd),
+	];
+
+	for (const def of tools) {
+		pi.registerTool(enabled ? wrapBuiltin(def) : def);
+	}
+}
+
+/**
+ * Manager class encapsulating rounded tools registration and lifecycle updates.
+ */
+export class RoundedToolsManager {
+	constructor(private readonly pi: ExtensionAPI) {}
+
+	/** Register initial tools before session_start with fallback cwd. */
+	init(enabled: boolean, cwd = process.cwd()): void {
+		registerRoundedTools(this.pi, enabled, cwd);
+	}
+
+	/** Apply tools with current session cwd. */
+	apply(enabled: boolean, cwd: string): void {
+		registerRoundedTools(this.pi, enabled, cwd);
+	}
+}
+

package/extensions/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: "bun", files: ["bun.lock", "bun.lockb"], versionCommand: { cmd: "bun", args: ["--version"], pattern: /(\d+\.\d+\.\d+)/ } },
+	{ 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: "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/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
+			}
+		}
+	}
+}