pi-compact-tools 0.8.1 → 0.8.3

package/README.md

@@ -2,11 +2,11 @@
 
 Compact, expandable rendering for Pi's built-in tools, with a GitHub Dark theme.
 
-![Compact tool workflow](https://raw.githubusercontent.com/nedleeds/pi-compact-tools/main/assets/nerd-font-workflow-optimized.gif)
+![Compact rows for every built-in tool](https://raw.githubusercontent.com/nedleeds/pi-compact-tools/main/assets/compact-workflow.gif)
 
-![Spinner and elapsed-time display](https://raw.githubusercontent.com/nedleeds/pi-compact-tools/main/assets/spinner-duration-optimized.gif)
+![Syntax-highlighted edit diff](https://raw.githubusercontent.com/nedleeds/pi-compact-tools/main/assets/edit-diff.gif)
 
-![Edit diff](https://raw.githubusercontent.com/nedleeds/pi-compact-tools/main/assets/edit-diff.gif)
+![Numbered read code view](https://raw.githubusercontent.com/nedleeds/pi-compact-tools/main/assets/code-aware-results.gif)
 
 ## Features
 

package/extensions/compact-tools-color.ts

@@ -25,16 +25,29 @@ function ansi256ToRgb(index: number): Rgb {
 	return { r: gray, g: gray, b: gray };
 }
 
+const ANSI_256_RGB: readonly Rgb[] = Array.from({ length: 256 }, (_, index) => ansi256ToRgb(index));
+
+/**
+ * The nearest-color search runs per character on 256-color terminals, so both the
+ * palette and the answers are kept. Callers interpolate between a handful of theme
+ * colors, so the memo holds tens of entries rather than growing with output size.
+ */
+const ansi256ByRgb = new Map<number, number>();
+
 function rgbToAnsi256(rgb: Rgb): number {
+	const key = (rgb.r << 16) | (rgb.g << 8) | rgb.b;
+	const memoized = ansi256ByRgb.get(key);
+	if (memoized !== undefined) return memoized;
 	let bestIndex = 0;
 	let bestDistance = Number.POSITIVE_INFINITY;
 	for (let index = 0; index < 256; index++) {
-		const candidate = ansi256ToRgb(index);
+		const candidate = ANSI_256_RGB[index]!;
 		const distance = (rgb.r - candidate.r) ** 2 + (rgb.g - candidate.g) ** 2 + (rgb.b - candidate.b) ** 2;
 		if (distance >= bestDistance) continue;
 		bestIndex = index;
 		bestDistance = distance;
 	}
+	ansi256ByRgb.set(key, bestIndex);
 	return bestIndex;
 }
 
@@ -57,11 +70,17 @@ export function interpolateRgb(from: Rgb, to: Rgb, amount: number): Rgb {
 	};
 }
 
-export function colorizeRgb(theme: Theme, color: Rgb, text: string): string {
+/** Shared by the foreground (38/39) and background (48/49) SGR pairs. */
+function paintRgb(theme: Theme, color: Rgb, text: string, set: 38 | 48): string {
+	const reset = set === 38 ? 39 : 49;
 	if (typeof theme.getColorMode === "function" && theme.getColorMode() === "256color") {
-		return `\x1b[38;5;${rgbToAnsi256(color)}m${text}\x1b[39m`;
+		return `\x1b[${set};5;${rgbToAnsi256(color)}m${text}\x1b[${reset}m`;
 	}
-	return `\x1b[38;2;${color.r};${color.g};${color.b}m${text}\x1b[39m`;
+	return `\x1b[${set};2;${color.r};${color.g};${color.b}m${text}\x1b[${reset}m`;
+}
+
+export function colorizeRgb(theme: Theme, color: Rgb, text: string): string {
+	return paintRgb(theme, color, text, 38);
 }
 
 function isDarkTheme(theme: Theme): boolean {
@@ -82,8 +101,5 @@ export function diffTintRgb(theme: Theme, color: ThemeForeground, amount = 0.16)
 }
 
 export function fillRgb(theme: Theme, color: Rgb, text: string): string {
-	if (typeof theme.getColorMode === "function" && theme.getColorMode() === "256color") {
-		return `\x1b[48;5;${rgbToAnsi256(color)}m${text}\x1b[49m`;
-	}
-	return `\x1b[48;2;${color.r};${color.g};${color.b}m${text}\x1b[49m`;
+	return paintRgb(theme, color, text, 48);
 }

package/extensions/compact-tools-core.ts

@@ -38,6 +38,16 @@ export function classifyCallStatus(isError: boolean, executionStarted: boolean,
 	return executionStarted ? "running" : "pending";
 }
 
+/**
+ * Sub-minute durations keep millisecond precision; longer runs switch to the
+ * minute and hour grouping Pi's own bash and powershell renderers use.
+ */
 export function formatDurationMs(elapsedMs: number): string {
-	return `${(elapsedMs / 1000).toFixed(3)}s`;
+	const seconds = elapsedMs / 1000;
+	if (seconds < 60) return `${seconds.toFixed(3)}s`;
+	const totalSeconds = Math.floor(seconds);
+	const minutes = Math.floor(totalSeconds / 60);
+	const remainderSeconds = totalSeconds % 60;
+	if (minutes < 60) return `${minutes}m ${remainderSeconds}s`;
+	return `${Math.floor(minutes / 60)}h ${minutes % 60}m ${remainderSeconds}s`;
 }

package/extensions/compact-tools-language.ts

@@ -0,0 +1,146 @@
+import { getLanguageFromPath } from "@earendil-works/pi-coding-agent";
+
+/**
+ * Pi resolves a language from the file extension and deliberately never falls back to
+ * content auto-detection, because highlight.js guesses confidently and wrongly on the
+ * things people read most: prose scores as AppleScript or LiveCode, logs and `git log`
+ * output as Apache, a one-line TypeScript statement as AutoIt. Relevance scores do not
+ * separate those from real matches, and the library is not reachable from this package
+ * anyway — Pi keeps it nested.
+ *
+ * So this module only widens the deterministic signals: names that identify a file
+ * without an extension, extensions Pi's table omits, and an interpreter the file
+ * declares itself. Anything still unknown stays unhighlighted rather than guessed.
+ */
+
+/** Files whose name, not extension, states the language. Keyed by lowercased basename. */
+const FILENAME_LANGUAGES: Readonly<Record<string, string>> = {
+	dockerfile: "dockerfile",
+	containerfile: "dockerfile",
+	makefile: "makefile",
+	gnumakefile: "makefile",
+	"cmakelists.txt": "cmake",
+	rakefile: "ruby",
+	gemfile: "ruby",
+	guardfile: "ruby",
+	podfile: "ruby",
+	brewfile: "ruby",
+	vagrantfile: "ruby",
+	jenkinsfile: "groovy",
+	".bashrc": "bash",
+	".bash_profile": "bash",
+	".bash_aliases": "bash",
+	".zshrc": "bash",
+	".zprofile": "bash",
+	".profile": "bash",
+	".editorconfig": "ini",
+	".npmrc": "ini",
+	".yarnrc": "ini",
+};
+
+/** Extensions Pi's own table does not cover. Unsupported names degrade to plain text. */
+const EXTENSION_LANGUAGES: Readonly<Record<string, string>> = {
+	mts: "typescript",
+	cts: "typescript",
+	jsonc: "json",
+	json5: "json",
+	bat: "dos",
+	cmd: "dos",
+	psm1: "powershell",
+	psd1: "powershell",
+	ini: "ini",
+	cfg: "ini",
+	conf: "ini",
+	properties: "properties",
+	diff: "diff",
+	patch: "diff",
+	svg: "xml",
+	gradle: "groovy",
+	groovy: "groovy",
+	dart: "dart",
+	nix: "nix",
+	zig: "zig",
+	mm: "objectivec",
+	pl: "perl",
+	pm: "perl",
+	rake: "ruby",
+	kts: "kotlin",
+	sc: "scala",
+	vb: "vbnet",
+	jl: "julia",
+	cr: "crystal",
+	awk: "awk",
+	tcl: "tcl",
+	f90: "fortran",
+	f95: "fortran",
+};
+
+/** Interpreters seen after `#!`, with any version suffix already stripped. */
+const INTERPRETER_LANGUAGES: Readonly<Record<string, string>> = {
+	bash: "bash",
+	sh: "bash",
+	zsh: "bash",
+	dash: "bash",
+	ksh: "bash",
+	fish: "fish",
+	python: "python",
+	node: "javascript",
+	deno: "typescript",
+	bun: "typescript",
+	ruby: "ruby",
+	perl: "perl",
+	php: "php",
+	lua: "lua",
+	awk: "awk",
+	gawk: "awk",
+	rscript: "r",
+	pwsh: "powershell",
+	powershell: "powershell",
+	tclsh: "tcl",
+};
+
+function basename(path: string): string {
+	const separator = Math.max(path.lastIndexOf("/"), path.lastIndexOf("\\"));
+	return separator === -1 ? path : path.slice(separator + 1);
+}
+
+/** `python3.12` and `ruby2.7` name the same languages as `python` and `ruby`. */
+function stripVersion(interpreter: string): string {
+	return interpreter.replace(/[\d.]+$/u, "");
+}
+
+/** Read the language a `#!` line declares, e.g. `#!/usr/bin/env -S python3 -u`. */
+export function languageFromShebang(line: string): string | undefined {
+	const shebang = line.match(/^#!\s*(\S+)((?:\s+\S+)*)$/u);
+	if (!shebang) return undefined;
+	const command = basename(shebang[1]!).toLowerCase();
+	if (command !== "env") return INTERPRETER_LANGUAGES[stripVersion(command)];
+	// `env` forwards to the first argument that is not one of its own flags.
+	for (const argument of shebang[2]!.trim().split(/\s+/u)) {
+		if (!argument || argument.startsWith("-") || argument.includes("=")) continue;
+		return INTERPRETER_LANGUAGES[stripVersion(basename(argument).toLowerCase())];
+	}
+	return undefined;
+}
+
+/** Resolve a language from the path alone, without looking at file contents. */
+export function languageFromPath(path: string): string | undefined {
+	const fromPi = getLanguageFromPath(path);
+	if (fromPi) return fromPi;
+	const name = basename(path).toLowerCase();
+	const byName = FILENAME_LANGUAGES[name];
+	if (byName) return byName;
+	// `.env`, `.env.local`, and `.env.production` all hold the same KEY=value shape.
+	if (name === ".env" || name.startsWith(".env.")) return "ini";
+	const extension = name.includes(".") ? name.slice(name.lastIndexOf(".") + 1) : undefined;
+	return extension ? EXTENSION_LANGUAGES[extension] : undefined;
+}
+
+/**
+ * Resolve a language for a file view. `firstLine` is only consulted when it is genuinely
+ * the file's first line, so a `read` starting at an offset never mistakes a comment for
+ * a shebang.
+ */
+export function resolveLanguage(path: string, firstLine?: string): string | undefined {
+	return languageFromPath(path) ?? (firstLine === undefined ? undefined : languageFromShebang(firstLine));
+}

package/extensions/compact-tools-layout.ts

@@ -1,4 +1,4 @@
-import { getLanguageFromPath, highlightCode, type Theme } from "@earendil-works/pi-coding-agent";
+import { highlightCode, type Theme } from "@earendil-works/pi-coding-agent";
 import type { Component } from "@earendil-works/pi-tui";
 import {
 	Container,
@@ -9,6 +9,7 @@ import {
 } from "@earendil-works/pi-tui";
 import { diffTintRgb, fillRgb } from "./compact-tools-color.ts";
 import { normalizeLineEndings } from "./compact-tools-core.ts";
+import { resolveLanguage } from "./compact-tools-language.ts";
 import { highlightMarkdown } from "./compact-tools-markdown.ts";
 import type { ToolArgs } from "./compact-tools-types.ts";
 
@@ -304,7 +305,11 @@ type CodeRowsOptions = {
 
 /** Render numbered, syntax-highlighted code rows shared by edit diffs and read/write file views. */
 function renderCodeRows(lines: CodeDiffLine[], path: string, theme: Theme, options: CodeRowsOptions): Component {
-	const highlighted = highlightCodeLines(lines, getLanguageFromPath(path), theme);
+	// A shebang only speaks for the file when the first row really is line 1, so a
+	// read at an offset or a diff hunk never reads one out of a comment.
+	const first = lines[0];
+	const shebangLine = first?.lineNumber === 1 && first.kind !== "separator" ? first.content : undefined;
+	const highlighted = highlightCodeLines(lines, resolveLanguage(path, shebangLine), theme);
 	const numberWidth = Math.max(1, ...lines.map((line) => String(line.lineNumber ?? "").length));
 	const prefix = theme.fg("border", " \u2502 ");
 	const prefixWidth = visibleWidth(prefix);

package/extensions/compact-tools-markdown.ts

@@ -1,4 +1,5 @@
-import { getLanguageFromPath, highlightCode, type Theme } from "@earendil-works/pi-coding-agent";
+import { highlightCode, type Theme } from "@earendil-works/pi-coding-agent";
+import { languageFromPath } from "./compact-tools-language.ts";
 
 type Fence = { char: string; length: number; language: string | undefined; start: number };
 
@@ -14,7 +15,7 @@ const INLINE = /(`+)(.+?)\1|\[([^\]\n]+)\]\(([^)\s]+)\)|\*\*(?=\S)(.+?)\*\*|__(?
 function fenceLanguage(info: string): string | undefined {
 	const name = info.toLowerCase();
 	if (!name) return undefined;
-	return getLanguageFromPath(`fence.${name}`) ?? name;
+	return languageFromPath(`fence.${name}`) ?? name;
 }
 
 function highlightInline(text: string, theme: Theme): string {

package/extensions/compact-tools-progress.ts

@@ -80,24 +80,34 @@ export class ProgressController {
 	private timer: ReturnType<typeof setInterval> | undefined;
 
 	constructor(pi: ExtensionAPI) {
-		pi.on("agent_start", () => this.setMessage("Thinking…"));
+		// Every handler leaves early while unbound. Pi keeps dispatching to this
+		// extension in non-TUI modes, and guarding at the top keeps that work — and
+		// any future handler added here — out of the detached path.
+		pi.on("agent_start", () => {
+			if (!this.context) return;
+			this.setMessage("Thinking…");
+		});
 		pi.on("message_update", (event) => {
+			if (!this.context) return;
 			const type = event.assistantMessageEvent.type;
 			if (type === "thinking_start" || type === "thinking_delta") this.setMessage("Thinking…");
 			else if (type === "text_start" || type === "text_delta") this.setMessage("Responding…");
 			else if (type === "toolcall_start" || type === "toolcall_delta") this.setMessage("Preparing tools…");
 		});
 		pi.on("tool_execution_start", (event) => {
+			if (!this.context) return;
 			const message = formatToolProgress(event.toolName, event.args ?? {});
 			this.activeTools.set(event.toolCallId, message);
 			this.setMessage(message);
 		});
 		pi.on("tool_execution_end", (event) => {
+			if (!this.context) return;
 			this.activeTools.delete(event.toolCallId);
 			const remaining = [...this.activeTools.values()].at(-1);
 			this.setMessage(remaining ?? "Processing results…");
 		});
 		pi.on("agent_end", () => {
+			if (!this.context) return;
 			this.activeTools.clear();
 			this.clearMessage();
 		});

package/extensions/compact-tools.ts

@@ -356,6 +356,14 @@ function configure(pi: ExtensionAPI, cwd?: string, projectTrusted = false): void
 }
 
 export default function compactTools(pi: ExtensionAPI): void {
+	// Pi caches this factory and re-invokes it with a fresh `pi` for every session
+	// replacement (/resume, /new, /fork) as well as /reload, each time starting from
+	// an empty tool registry. The module itself survives those invocations, so the
+	// memo below has to be dropped here or configure() mistakes the previous
+	// instance's registration for this one and never installs the renderers.
+	registeredConfiguration = undefined;
+	registeredTools.clear();
+
 	const thinkingCycle = new ThinkingCycleController(pi);
 	const progress = new ProgressController(pi);
 	// Register once while the extension runtime is being built. In particular, this
@@ -376,8 +384,5 @@ export default function compactTools(pi: ExtensionAPI): void {
 		thinkingCycle.dispose();
 		progress.dispose();
 		runtime.reset(event.reason !== "reload");
-		// Some Pi hosts rebuild the active tool registry during reload while keeping
-		// this module instance. Force the next session to restore our renderers.
-		if (event.reason === "reload") registeredConfiguration = undefined;
 	});
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-compact-tools",
-  "version": "0.8.1",
+  "version": "0.8.3",
   "description": "Compact, expandable UI for pi's built-in tools, bundled with a polished GitHub Dark theme.",
   "type": "module",
   "license": "MIT",
@@ -42,15 +42,15 @@
     "themes": [
       "./themes/github-dark-pro.json"
     ],
-    "image": "https://raw.githubusercontent.com/nedleeds/pi-compact-tools/main/assets/nerd-font-workflow-optimized.gif"
+    "image": "https://raw.githubusercontent.com/nedleeds/pi-compact-tools/main/assets/compact-workflow.gif"
   },
   "peerDependencies": {
-    "@earendil-works/pi-coding-agent": "*",
-    "@earendil-works/pi-tui": "*"
+    "@earendil-works/pi-coding-agent": ">=0.85.1",
+    "@earendil-works/pi-tui": ">=0.85.1"
   },
   "devDependencies": {
-    "@earendil-works/pi-coding-agent": "0.85.1",
-    "@earendil-works/pi-tui": "0.85.1",
+    "@earendil-works/pi-coding-agent": "0.86.0",
+    "@earendil-works/pi-tui": "0.86.0",
     "@types/node": "^24.0.0",
     "tsx": "^4.23.13",
     "typescript": "^5.9.0"