@selesai/code 0.10.2 → 0.11.0

package/dist/extensions/pi-tool-display/package.json

@@ -0,0 +1,86 @@
+{
+  "name": "pi-tool-display",
+  "version": "0.5.0",
+  "description": "Compact tool call rendering, diff visualization, and output truncation extension for Pi coding agent. Hides, collapses, and truncates verbose tool output for cleaner TUI display.",
+  "type": "module",
+  "main": "./index.ts",
+  "exports": {
+    ".": "./index.ts",
+    "./tool-display-api-consumer": {
+      "types": "./tool-display-api-consumer.d.ts",
+      "default": "./tool-display-api-consumer.js"
+    }
+  },
+  "files": [
+    "index.ts",
+    "tool-display-api-consumer.js",
+    "tool-display-api-consumer.d.ts",
+    "src",
+    "config/config.example.json",
+    "README.md",
+    "CHANGELOG.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "lint": "npm run typecheck",
+    "test": "tsx --test tests/*.test.ts",
+    "check": "npm run lint && npm run test",
+    "typecheck": "tsc -p tsconfig.json",
+    "postinstall": "node -e \"const fs=require('fs'),cp=require('child_process'),p=require('path');const cwd=process.cwd();const normalized=cwd.split(p.sep).join('/');if(!normalized.includes('/.pi/agent/extensions/'))process.exit(0);const s=p.resolve(cwd,'../../scripts/patch-vulnerable-deps.mjs');if(!fs.existsSync(s))process.exit(0);const r=cp.spawnSync(process.execPath,[s,'--target',cwd,'--quiet'],{stdio:'inherit'});process.exit(r.status||0)\""
+  },
+  "keywords": [
+    "pi-package",
+    "pi",
+    "pi-extension",
+    "pi-coding-agent",
+    "pi-tui",
+    "coding-agent",
+    "tui",
+    "tool-rendering",
+    "tool-output",
+    "diff-visualization",
+    "output-truncation",
+    "hide",
+    "collapse",
+    "truncate",
+    "compact",
+    "diff",
+    "output-mode"
+  ],
+  "author": "MasuRii",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/MasuRii/pi-tool-display.git"
+  },
+  "bugs": {
+    "url": "https://github.com/MasuRii/pi-tool-display/issues"
+  },
+  "homepage": "https://github.com/MasuRii/pi-tool-display#readme",
+  "engines": {
+    "node": ">=20"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "pi": {
+    "extensions": [
+      "./index.ts"
+    ]
+  },
+  "peerDependencies": {
+    "@earendil-works/pi-coding-agent": "^0.74.0 || ^0.75.0 || ^0.77.0 || ^0.78.0 || ^0.79.0 || ^0.80.0",
+    "@earendil-works/pi-tui": "^0.74.0 || ^0.75.0 || ^0.77.0 || ^0.78.0 || ^0.79.0 || ^0.80.0"
+  },
+  "overrides": {
+    "file-type": ">=21.3.1",
+    "protobufjs": "7.6.3",
+    "ws": "8.21.0"
+  },
+  "devDependencies": {
+    "tsx": "4.22.4",
+    "typescript": "6.0.3",
+    "@earendil-works/pi-coding-agent": "^0.80.3"
+  }
+}

package/dist/extensions/pi-tool-display/src/agent-dir.ts

@@ -0,0 +1,35 @@
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { CONFIG_DIR_NAME } from "@earendil-works/pi-coding-agent";
+
+const PI_AGENT_DIR_ENV_VAR = "PI_CODING_AGENT_DIR";
+// ponytail: keep the upstream default too; SELESAI_CODING_AGENT_DIR is the host fork's override.
+const SELESAI_AGENT_DIR_ENV_VAR = "SELESAI_CODING_AGENT_DIR";
+
+interface AgentDirEnvironment {
+	[name: string]: string | undefined;
+}
+
+function expandHomeDirectory(configuredDir: string, homeDirectory: string): string {
+	if (configuredDir === "~") {
+		return homeDirectory;
+	}
+
+	if (configuredDir.startsWith("~/") || configuredDir.startsWith("~\\")) {
+		return join(homeDirectory, configuredDir.slice(2));
+	}
+
+	return configuredDir;
+}
+
+export function resolvePiAgentDir(
+	env: AgentDirEnvironment = process.env,
+	homeDirectory = homedir(),
+): string {
+	const configuredDir = env[PI_AGENT_DIR_ENV_VAR] ?? env[SELESAI_AGENT_DIR_ENV_VAR];
+	if (!configuredDir) {
+		return join(homeDirectory, CONFIG_DIR_NAME, "agent");
+	}
+
+	return expandHomeDirectory(configuredDir, homeDirectory);
+}

package/dist/extensions/pi-tool-display/src/ansi-utils.ts

@@ -0,0 +1,116 @@
+const ANSI_SGR_PATTERN = /\x1b\[([0-9;]*)m/g;
+const STYLE_RESET_PARAMS = [39, 22, 23, 24, 25, 27, 28, 29, 59] as const;
+
+export { ANSI_SGR_PATTERN, STYLE_RESET_PARAMS };
+
+export function expandSgrReset(param: number): readonly number[] | undefined {
+  return param === 0 ? STYLE_RESET_PARAMS : undefined;
+}
+
+export function toSgrParams(rawParams: string): number[] {
+  if (!rawParams.trim()) {
+    return [0];
+  }
+
+  const parsed = rawParams
+    .split(";")
+    .map((token) => Number.parseInt(token, 10))
+    .filter((value) => Number.isFinite(value));
+
+  return parsed.length > 0 ? parsed : [];
+}
+
+export function isFiniteSgrParam(value: number | undefined): value is number {
+  return typeof value === "number" && Number.isFinite(value);
+}
+
+export function readSgrColorSequence(params: number[], index: number): number[] | undefined {
+  const param = params[index];
+  if (param !== 38 && param !== 48) {
+    return undefined;
+  }
+
+  const colorMode = params[index + 1];
+  if (colorMode === 5) {
+    const colorValue = params[index + 2];
+    return isFiniteSgrParam(colorValue) ? [param, colorMode, colorValue] : undefined;
+  }
+
+  if (colorMode === 2) {
+    const red = params[index + 2];
+    const green = params[index + 3];
+    const blue = params[index + 4];
+    return isFiniteSgrParam(red) && isFiniteSgrParam(green) && isFiniteSgrParam(blue)
+      ? [param, colorMode, red, green, blue]
+      : undefined;
+  }
+
+  return undefined;
+}
+
+export function stripBackgroundSgrParams(params: readonly number[]): number[] {
+  const sanitized: number[] = [];
+
+  for (let index = 0; index < params.length; index++) {
+    const param = params[index] ?? 0;
+
+    if (param === 0) {
+      sanitized.push(...expandSgrReset(param)!);
+      continue;
+    }
+
+    if (param === 49 || (param >= 40 && param <= 47) || (param >= 100 && param <= 107)) {
+      continue;
+    }
+
+    if (param === 38 || param === 48) {
+      const sequence = readSgrColorSequence(params as number[], index);
+      if (sequence) {
+        if (param === 38) {
+          sanitized.push(...sequence);
+        }
+        index += sequence.length - 1;
+        continue;
+      }
+      const advance = params[index + 1] === 5 ? 2 : params[index + 1] === 2 ? 4 : 0;
+      if (advance > 0) {
+        index += advance;
+        if (param === 38) {
+          sanitized.push(param);
+        }
+        continue;
+      }
+    }
+
+    sanitized.push(param);
+  }
+
+  return sanitized;
+}
+
+export function filterSgrSequences(
+  text: string,
+  filter: (params: number[]) => number[],
+): string {
+  if (!text || !text.includes("\x1b[")) {
+    return text;
+  }
+
+  return text.replace(ANSI_SGR_PATTERN, (_sequence, rawParams: string) => {
+    const parsed = toSgrParams(rawParams);
+    if (parsed.length === 0) {
+      return "";
+    }
+
+    const sanitized = filter(parsed);
+    if (sanitized.length === 0) {
+      return "";
+    }
+
+    return `\x1b[${sanitized.join(";")}m`;
+  });
+}
+
+export function sanitizeAnsiForThemedOutput(text: string): string {
+  return filterSgrSequences(text, stripBackgroundSgrParams);
+}

package/dist/extensions/pi-tool-display/src/bash-display.ts

@@ -0,0 +1,213 @@
+import { Text } from "@earendil-works/pi-tui";
+import { registerCleanup, registerTimer } from "./disposable.js";
+
+const BASH_SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"] as const;
+// Slow enough to stay visually alive without making the full transcript re-render five times a second.
+const BASH_SPINNER_INTERVAL_MS = 750;
+const BASH_SPINNER_STATE_KEY = "__piToolDisplayBashSpinner";
+const BASH_SPINNER_TOOL_CALL_ID_KEY = "__piToolDisplayBashSpinnerToolCallId";
+
+interface BashCallArgs {
+	command?: string;
+	commandPrefix?: string;
+	shellPath?: string;
+	timeout?: number;
+}
+
+interface BashCallRenderTheme {
+	fg(color: string, text: string): string;
+	bold(text: string): string;
+}
+
+interface BashSpinnerState {
+	frameIndex: number;
+	startedAt?: number;
+	timer?: ReturnType<typeof setInterval>;
+}
+
+interface BashSpinnerStateCarrier {
+	[BASH_SPINNER_STATE_KEY]?: BashSpinnerState;
+	[BASH_SPINNER_TOOL_CALL_ID_KEY]?: string;
+}
+
+interface BashCallRenderContextLike {
+	executionStarted: boolean;
+	isPartial: boolean;
+	invalidate?: () => void;
+	lastComponent?: unknown;
+	state?: unknown;
+	toolCallId?: string;
+}
+
+const spinnerStatesByToolCallId = new Map<string, BashSpinnerState>();
+let nextSyntheticToolCallId = 0;
+
+function toStateCarrier(value: unknown): BashSpinnerStateCarrier | undefined {
+	if (!value || typeof value !== "object") {
+		return undefined;
+	}
+	return value as BashSpinnerStateCarrier;
+}
+
+function getSyntheticToolCallId(carrier: BashSpinnerStateCarrier | undefined): string | undefined {
+	if (!carrier) {
+		return undefined;
+	}
+
+	if (!carrier[BASH_SPINNER_TOOL_CALL_ID_KEY]) {
+		carrier[BASH_SPINNER_TOOL_CALL_ID_KEY] = `state:${++nextSyntheticToolCallId}`;
+	}
+	return carrier[BASH_SPINNER_TOOL_CALL_ID_KEY];
+}
+
+function getToolCallId(context: BashCallRenderContextLike): string | undefined {
+	if (typeof context.toolCallId === "string" && context.toolCallId.trim().length > 0) {
+		return context.toolCallId;
+	}
+	return getSyntheticToolCallId(toStateCarrier(context.state));
+}
+
+function getOrCreateSpinnerState(
+	toolCallId: string | undefined,
+	carrier: BashSpinnerStateCarrier | undefined,
+): BashSpinnerState | undefined {
+	if (!toolCallId) {
+		return undefined;
+	}
+
+	let state = spinnerStatesByToolCallId.get(toolCallId);
+	if (!state) {
+		state = { frameIndex: 0 };
+		spinnerStatesByToolCallId.set(toolCallId, state);
+	}
+	if (carrier) {
+		carrier[BASH_SPINNER_STATE_KEY] = state;
+	}
+	return state;
+}
+
+function stopSpinner(toolCallId: string | undefined, state: BashSpinnerState | undefined): void {
+	if (!state) {
+		return;
+	}
+
+	if (state.timer) {
+		clearInterval(state.timer);
+		state.timer = undefined;
+	}
+	state.frameIndex = 0;
+	state.startedAt = undefined;
+	if (toolCallId) {
+		spinnerStatesByToolCallId.delete(toolCallId);
+	}
+}
+
+function formatElapsed(elapsedMs: number): string {
+	const totalSeconds = Math.max(0, Math.floor(elapsedMs / 1000));
+	if (totalSeconds < 60) {
+		return `${totalSeconds}s`;
+	}
+
+	const totalMinutes = Math.floor(totalSeconds / 60);
+	const seconds = totalSeconds % 60;
+	if (totalMinutes < 60) {
+		return `${totalMinutes}m ${seconds}s`;
+	}
+
+	const hours = Math.floor(totalMinutes / 60);
+	const minutes = totalMinutes % 60;
+	return `${hours}h ${minutes}m`;
+}
+
+function isDefaultShellPath(shellPath: string): boolean {
+	const normalized = shellPath.trim().replace(/\\/g, "/").toLowerCase();
+	const basename = normalized.split("/").pop() || normalized;
+	return basename === "bash" || basename === "cmd.exe";
+}
+
+function buildCommandDisplay(args: BashCallArgs): string {
+	const command =
+		typeof args.command === "string" && args.command.trim().length > 0
+			? args.command
+			: "...";
+	const prefix =
+		typeof args.commandPrefix === "string" && args.commandPrefix.trim().length > 0
+			? args.commandPrefix.trim()
+			: "";
+	return prefix ? `${prefix} ${command}` : command;
+}
+
+function buildBashCallText(
+	args: BashCallArgs,
+	theme: BashCallRenderTheme,
+	spinnerFrame?: string,
+	elapsedMs?: number,
+): string {
+	const commandDisplay = buildCommandDisplay(args);
+	const shellSuffix =
+		typeof args.shellPath === "string" &&
+		args.shellPath.trim().length > 0 &&
+		!isDefaultShellPath(args.shellPath)
+			? theme.fg("muted", ` [shell: ${args.shellPath}]`)
+			: "";
+	const timeoutSuffix = args.timeout
+		? theme.fg("muted", ` (timeout ${args.timeout}s)`)
+		: "";
+	const spinnerPrefix = spinnerFrame ? `${theme.fg("warning", `${spinnerFrame} `)}` : "";
+	const elapsedSuffix =
+		spinnerFrame && elapsedMs !== undefined
+			? theme.fg("muted", ` · ${formatElapsed(elapsedMs)}`)
+			: "";
+
+	return `${spinnerPrefix}${theme.fg("toolTitle", theme.bold("$"))} ${theme.fg("accent", commandDisplay)}${shellSuffix}${timeoutSuffix}${elapsedSuffix}`;
+}
+
+export function renderBashCall(
+	args: BashCallArgs,
+	theme: BashCallRenderTheme,
+	context: BashCallRenderContextLike,
+): Text {
+	const text = context.lastComponent instanceof Text ? context.lastComponent : new Text("", 0, 0);
+	const carrier = toStateCarrier(context.state);
+	const toolCallId = getToolCallId(context);
+	const spinnerState = getOrCreateSpinnerState(toolCallId, carrier);
+	const shouldSpin = context.executionStarted && context.isPartial;
+
+	if (!shouldSpin) {
+		stopSpinner(toolCallId, spinnerState);
+		text.setText(buildBashCallText(args, theme));
+		return text;
+	}
+
+	if (spinnerState) {
+		spinnerState.startedAt ??= Date.now();
+		if (!spinnerState.timer && typeof context.invalidate === "function") {
+			const timer = setInterval(() => {
+				spinnerState.frameIndex = (spinnerState.frameIndex + 1) % BASH_SPINNER_FRAMES.length;
+				text.setText(
+					buildBashCallText(
+						args,
+						theme,
+						BASH_SPINNER_FRAMES[spinnerState.frameIndex],
+						Date.now() - (spinnerState.startedAt ?? Date.now()),
+					),
+				);
+				context.invalidate?.();
+			}, BASH_SPINNER_INTERVAL_MS);
+			spinnerState.timer = timer;
+			registerTimer(timer);
+			registerCleanup(() => {
+				if (spinnerStatesByToolCallId.get(toolCallId || "") === spinnerState) {
+					stopSpinner(toolCallId, spinnerState);
+				}
+			});
+		}
+	}
+
+	const spinnerFrame = spinnerState ? BASH_SPINNER_FRAMES[spinnerState.frameIndex] : undefined;
+	const elapsedMs = spinnerState?.startedAt !== undefined
+		? Date.now() - spinnerState.startedAt
+		: undefined;
+	text.setText(buildBashCallText(args, theme, spinnerFrame, elapsedMs));
+	return text;
+}

package/dist/extensions/pi-tool-display/src/capabilities.ts

@@ -0,0 +1,88 @@
+import { CONFIG_DIR_NAME, type ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { resolvePiAgentDir } from "./agent-dir.js";
+import { existsSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { logToolDisplayDebug } from "./debug-logger.js";
+import { isMcpToolCandidate } from "./tool-metadata.js";
+import type { ToolDisplayConfig } from "./types.js";
+
+export interface ToolDisplayCapabilities {
+	hasMcpTooling: boolean;
+	hasRtkOptimizer: boolean;
+}
+
+function hasMcpTooling(pi: ExtensionAPI): boolean {
+	try {
+		const allTools = pi.getAllTools();
+		return allTools.some((tool) => isMcpToolCandidate(tool));
+	} catch (error) {
+		logToolDisplayDebug("MCP capability detection failed.", error);
+		return false;
+	}
+}
+
+function hasRtkCommand(pi: ExtensionAPI): boolean {
+	try {
+		const commands = pi.getCommands();
+		return commands.some((command) => typeof command.name === "string" && (command.name === "rtk" || command.name.startsWith("rtk-")));
+	} catch (error) {
+		logToolDisplayDebug("RTK command capability detection failed.", error);
+		return false;
+	}
+}
+
+const rtkPathProbeCache = new Map<string, { fingerprint: string; exists: boolean }>();
+
+function getPathFingerprint(path: string): string {
+	try {
+		const stats = statSync(path);
+		return `${stats.mtimeMs}:${stats.size}`;
+	} catch {
+		return "missing";
+	}
+}
+
+function cachedPathExists(path: string): boolean {
+	const fingerprint = getPathFingerprint(path);
+	const cached = rtkPathProbeCache.get(path);
+	if (cached && cached.fingerprint === fingerprint) {
+		return cached.exists;
+	}
+
+	let exists = false;
+	try {
+		exists = existsSync(path);
+	} catch (error) {
+		logToolDisplayDebug(`RTK capability path probe failed for ${path}.`, error);
+	}
+	rtkPathProbeCache.set(path, { fingerprint, exists });
+	return exists;
+}
+
+function hasRtkExtensionPath(cwd: string): boolean {
+	const candidates = [
+		join(resolvePiAgentDir(), "extensions", "pi-rtk-optimizer"),
+		join(cwd, CONFIG_DIR_NAME, "extensions", "pi-rtk-optimizer"),
+	];
+
+	return candidates.some((candidate) => cachedPathExists(candidate));
+}
+
+export function detectToolDisplayCapabilities(pi: ExtensionAPI, cwd: string): ToolDisplayCapabilities {
+	return {
+		hasMcpTooling: hasMcpTooling(pi),
+		hasRtkOptimizer: hasRtkCommand(pi) || hasRtkExtensionPath(cwd),
+	};
+}
+
+export function applyCapabilityConfigGuards(
+	config: ToolDisplayConfig,
+	capabilities: ToolDisplayCapabilities,
+): ToolDisplayConfig {
+	return {
+		...config,
+		registerToolOverrides: { ...config.registerToolOverrides },
+		mcpOutputMode: config.mcpOutputMode,
+		showRtkCompactionHints: capabilities.hasRtkOptimizer ? config.showRtkCompactionHints : false,
+	};
+}