pi-extensions-tool-display 0.1.1 → 0.2.0

package/src/config-store.ts

@@ -0,0 +1,303 @@
+import { resolvePiAgentDir } from "./agent-dir.js";
+import { existsSync, mkdirSync, readFileSync, renameSync, statSync, unlinkSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import {
+	BUILT_IN_TOOL_OVERRIDE_NAMES,
+	BASH_OUTPUT_MODES,
+	CUSTOM_TOOL_OUTPUT_MODES,
+	CUSTOM_TOOL_OVERRIDE_KINDS,
+	DEFAULT_TOOL_DISPLAY_CONFIG,
+	type ConfigLoadResult,
+	type ConfigSaveResult,
+	type CustomToolOverrideConfig,
+	DIFF_INDICATOR_MODES,
+	DIFF_VIEW_MODES,
+	MCP_OUTPUT_MODES,
+	READ_OUTPUT_MODES,
+	SEARCH_OUTPUT_MODES,
+	type ToolDisplayConfig,
+	type ToolOverrideOwnership,
+} from "./types.js";
+import { toRecord } from "./tool-metadata.js";
+
+const CONFIG_DIR = join(resolvePiAgentDir(), "extensions", "pi-tool-display");
+const CONFIG_FILE = join(CONFIG_DIR, "config.json");
+
+interface LegacyToolDisplayConfigSource extends Partial<ToolDisplayConfig> {
+	registerReadToolOverride?: unknown;
+}
+
+function clampNumber(value: unknown, min: number, max: number, fallback: number): number {
+	if (typeof value !== "number" || Number.isNaN(value)) {
+		return fallback;
+	}
+	const rounded = Math.floor(value);
+	if (rounded < min) return min;
+	if (rounded > max) return max;
+	return rounded;
+}
+
+function toBoolean(value: unknown, fallback: boolean): boolean {
+	return typeof value === "boolean" ? value : fallback;
+}
+
+function toReadOutputMode(value: unknown): ToolDisplayConfig["readOutputMode"] {
+	return READ_OUTPUT_MODES.includes(value as ToolDisplayConfig["readOutputMode"])
+		? (value as ToolDisplayConfig["readOutputMode"])
+		: DEFAULT_TOOL_DISPLAY_CONFIG.readOutputMode;
+}
+
+function toSearchOutputMode(value: unknown): ToolDisplayConfig["searchOutputMode"] {
+	return SEARCH_OUTPUT_MODES.includes(value as ToolDisplayConfig["searchOutputMode"])
+		? (value as ToolDisplayConfig["searchOutputMode"])
+		: DEFAULT_TOOL_DISPLAY_CONFIG.searchOutputMode;
+}
+
+function toMcpOutputMode(value: unknown): ToolDisplayConfig["mcpOutputMode"] {
+	return MCP_OUTPUT_MODES.includes(value as ToolDisplayConfig["mcpOutputMode"])
+		? (value as ToolDisplayConfig["mcpOutputMode"])
+		: DEFAULT_TOOL_DISPLAY_CONFIG.mcpOutputMode;
+}
+
+function toBashOutputMode(value: unknown): ToolDisplayConfig["bashOutputMode"] {
+	return BASH_OUTPUT_MODES.includes(value as ToolDisplayConfig["bashOutputMode"])
+		? (value as ToolDisplayConfig["bashOutputMode"])
+		: DEFAULT_TOOL_DISPLAY_CONFIG.bashOutputMode;
+}
+
+function toDiffViewMode(value: unknown): ToolDisplayConfig["diffViewMode"] {
+	if (value === "stacked") {
+		// Backward compatibility with older config naming.
+		return "unified";
+	}
+
+	return DIFF_VIEW_MODES.includes(value as ToolDisplayConfig["diffViewMode"])
+		? (value as ToolDisplayConfig["diffViewMode"])
+		: DEFAULT_TOOL_DISPLAY_CONFIG.diffViewMode;
+}
+
+function toDiffIndicatorMode(value: unknown): ToolDisplayConfig["diffIndicatorMode"] {
+	return DIFF_INDICATOR_MODES.includes(value as ToolDisplayConfig["diffIndicatorMode"])
+		? (value as ToolDisplayConfig["diffIndicatorMode"])
+		: DEFAULT_TOOL_DISPLAY_CONFIG.diffIndicatorMode;
+}
+
+export function cloneCustomToolOverrides(
+	overrides: Record<string, CustomToolOverrideConfig>,
+): Record<string, CustomToolOverrideConfig> {
+	return Object.fromEntries(
+		Object.entries(overrides).map(([toolName, override]) => [
+			toolName,
+			{ ...override },
+		]),
+	);
+}
+
+function cloneDefaultConfig(): ToolDisplayConfig {
+	return {
+		...DEFAULT_TOOL_DISPLAY_CONFIG,
+		registerToolOverrides: { ...DEFAULT_TOOL_DISPLAY_CONFIG.registerToolOverrides },
+		customToolOverrides: cloneCustomToolOverrides(DEFAULT_TOOL_DISPLAY_CONFIG.customToolOverrides),
+	};
+}
+
+let cachedConfigFile: string | undefined;
+let cachedConfigFingerprint: string | undefined;
+let cachedConfigResult: ConfigLoadResult | undefined;
+
+function cloneConfig(config: ToolDisplayConfig): ToolDisplayConfig {
+	return normalizeToolDisplayConfig(config);
+}
+
+function cloneLoadResult(result: ConfigLoadResult): ConfigLoadResult {
+	return {
+		...result,
+		config: cloneConfig(result.config),
+	};
+}
+
+function getConfigFingerprint(configFile: string): string {
+	try {
+		const stats = statSync(configFile);
+		return `${stats.mtimeMs}:${stats.size}`;
+	} catch {
+		return "missing";
+	}
+}
+
+function normalizeToolOverrideOwnership(
+	rawOverrides: unknown,
+	legacyRegisterReadToolOverride: unknown,
+): ToolOverrideOwnership {
+	const source = toRecord(rawOverrides);
+	const defaults = DEFAULT_TOOL_DISPLAY_CONFIG.registerToolOverrides;
+	const legacyReadDefault = toBoolean(legacyRegisterReadToolOverride, defaults.read);
+
+	const overrides = { ...defaults };
+	for (const toolName of BUILT_IN_TOOL_OVERRIDE_NAMES) {
+		const fallback = toolName === "read" ? legacyReadDefault : defaults[toolName];
+		overrides[toolName] = toBoolean(source[toolName], fallback);
+	}
+
+	return overrides;
+}
+
+function isBuiltInToolOverrideName(toolName: string): boolean {
+	return (BUILT_IN_TOOL_OVERRIDE_NAMES as readonly string[]).includes(toolName);
+}
+
+export function toCustomToolOverrideKind(value: unknown): CustomToolOverrideConfig["kind"] {
+	return CUSTOM_TOOL_OVERRIDE_KINDS.includes(value as CustomToolOverrideConfig["kind"])
+		? (value as CustomToolOverrideConfig["kind"])
+		: "generic";
+}
+
+export function toCustomToolOutputMode(value: unknown): CustomToolOverrideConfig["outputMode"] {
+	return CUSTOM_TOOL_OUTPUT_MODES.includes(value as CustomToolOverrideConfig["outputMode"])
+		? (value as CustomToolOverrideConfig["outputMode"])
+		: "summary";
+}
+
+export function normalizeCustomToolOverrideEntry(rawEntry: unknown): CustomToolOverrideConfig | undefined {
+	if (typeof rawEntry === "boolean") {
+		return {
+			enabled: rawEntry,
+			kind: "generic",
+			outputMode: "summary",
+		};
+	}
+
+	if (!rawEntry || typeof rawEntry !== "object" || Array.isArray(rawEntry)) {
+		return undefined;
+	}
+
+	const source = toRecord(rawEntry);
+	return {
+		enabled: toBoolean(source.enabled, true),
+		kind: toCustomToolOverrideKind(source.kind),
+		outputMode: toCustomToolOutputMode(source.outputMode),
+	};
+}
+
+function normalizeCustomToolOverrides(rawOverrides: unknown): Record<string, CustomToolOverrideConfig> {
+	const source = toRecord(rawOverrides);
+	const overrides: Record<string, CustomToolOverrideConfig> = {};
+
+	for (const [rawToolName, rawEntry] of Object.entries(source)) {
+		const toolName = rawToolName.trim();
+		if (!toolName || isBuiltInToolOverrideName(toolName)) {
+			continue;
+		}
+
+		const normalized = normalizeCustomToolOverrideEntry(rawEntry);
+		if (!normalized) {
+			continue;
+		}
+
+		overrides[toolName] = normalized;
+	}
+
+	return overrides;
+}
+
+export function normalizeToolDisplayConfig(raw: unknown): ToolDisplayConfig {
+	const source =
+		typeof raw === "object" && raw !== null ? (raw as LegacyToolDisplayConfigSource) : ({} as LegacyToolDisplayConfigSource);
+
+	return {
+		enabled: toBoolean(source.enabled, DEFAULT_TOOL_DISPLAY_CONFIG.enabled),
+		registerToolOverrides: normalizeToolOverrideOwnership(
+			source.registerToolOverrides,
+			source.registerReadToolOverride,
+		),
+		customToolOverrides: normalizeCustomToolOverrides(source.customToolOverrides),
+		enableNativeUserMessageBox: toBoolean(
+			source.enableNativeUserMessageBox,
+			DEFAULT_TOOL_DISPLAY_CONFIG.enableNativeUserMessageBox,
+		),
+		readOutputMode: toReadOutputMode(source.readOutputMode),
+		searchOutputMode: toSearchOutputMode(source.searchOutputMode),
+		mcpOutputMode: toMcpOutputMode(source.mcpOutputMode),
+		previewLines: clampNumber(source.previewLines, 1, 80, DEFAULT_TOOL_DISPLAY_CONFIG.previewLines),
+		expandedPreviewMaxLines: clampNumber(
+			source.expandedPreviewMaxLines,
+			0,
+			20_000,
+			DEFAULT_TOOL_DISPLAY_CONFIG.expandedPreviewMaxLines,
+		),
+		bashOutputMode: toBashOutputMode(source.bashOutputMode),
+		bashCollapsedLines: clampNumber(source.bashCollapsedLines, 0, 80, DEFAULT_TOOL_DISPLAY_CONFIG.bashCollapsedLines),
+		diffViewMode: toDiffViewMode(source.diffViewMode),
+		diffIndicatorMode: toDiffIndicatorMode(source.diffIndicatorMode),
+		diffSplitMinWidth: clampNumber(source.diffSplitMinWidth, 70, 240, DEFAULT_TOOL_DISPLAY_CONFIG.diffSplitMinWidth),
+		diffCollapsedLines: clampNumber(source.diffCollapsedLines, 4, 240, DEFAULT_TOOL_DISPLAY_CONFIG.diffCollapsedLines),
+		diffWordWrap: toBoolean(source.diffWordWrap, DEFAULT_TOOL_DISPLAY_CONFIG.diffWordWrap),
+		showTruncationHints: toBoolean(source.showTruncationHints, DEFAULT_TOOL_DISPLAY_CONFIG.showTruncationHints),
+		showRtkCompactionHints: toBoolean(
+			source.showRtkCompactionHints,
+			DEFAULT_TOOL_DISPLAY_CONFIG.showRtkCompactionHints,
+		),
+	};
+}
+
+export function loadToolDisplayConfig(configFile = CONFIG_FILE): ConfigLoadResult {
+	const fingerprint = getConfigFingerprint(configFile);
+	if (cachedConfigResult && cachedConfigFile === configFile && cachedConfigFingerprint === fingerprint) {
+		return cloneLoadResult(cachedConfigResult);
+	}
+
+	let result: ConfigLoadResult;
+	if (!existsSync(configFile)) {
+		result = { config: cloneDefaultConfig() };
+	} else {
+		try {
+			const rawText = readFileSync(configFile, "utf-8");
+			const rawConfig = JSON.parse(rawText) as unknown;
+			result = { config: normalizeToolDisplayConfig(rawConfig) };
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			result = {
+				config: cloneDefaultConfig(),
+				error: `Failed to parse ${configFile}: ${message}`,
+			};
+		}
+	}
+
+	cachedConfigFile = configFile;
+	cachedConfigFingerprint = fingerprint;
+	cachedConfigResult = cloneLoadResult(result);
+	return result;
+}
+
+export function saveToolDisplayConfig(config: ToolDisplayConfig, configFile = CONFIG_FILE): ConfigSaveResult {
+	const normalized = normalizeToolDisplayConfig(config);
+	const tmpFile = `${configFile}.tmp`;
+
+	try {
+		mkdirSync(dirname(configFile), { recursive: true });
+		writeFileSync(tmpFile, `${JSON.stringify(normalized, null, 2)}\n`, "utf-8");
+		renameSync(tmpFile, configFile);
+		cachedConfigFile = undefined;
+		cachedConfigFingerprint = undefined;
+		cachedConfigResult = undefined;
+		return { success: true };
+	} catch (error) {
+		try {
+			if (existsSync(tmpFile)) {
+				unlinkSync(tmpFile);
+			}
+		} catch (cleanupError) {
+			// Ignore cleanup errors.
+			void cleanupError;
+		}
+		const message = error instanceof Error ? error.message : String(error);
+		return {
+			success: false,
+			error: `Failed to save ${configFile}: ${message}`,
+		};
+	}
+}
+
+export function getToolDisplayConfigPath(): string {
+	return CONFIG_FILE;
+}

package/src/debug-logger.ts

@@ -0,0 +1,150 @@
+import { existsSync, mkdirSync, readFileSync, statSync } from "node:fs";
+import { appendFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { toRecord } from "./tool-metadata.js";
+
+const EXTENSION_ROOT = join(dirname(fileURLToPath(import.meta.url)), "..");
+const DEFAULT_DEBUG_CONFIG_FILE = join(EXTENSION_ROOT, "config.json");
+const DEFAULT_DEBUG_DIR = join(EXTENSION_ROOT, "debug");
+const DEFAULT_DEBUG_LOG_FILE = join(DEFAULT_DEBUG_DIR, "debug.log");
+
+const DEFAULT_DEBUG_CONFIG_CACHE_TTL_MS = 1_000;
+
+const SECRET_VALUE_PATTERN = /\b(?:sk-[A-Za-z0-9_-]{12,}|[A-Za-z0-9_-]{24,}\.[A-Za-z0-9_-]{6,}\.[A-Za-z0-9_-]{12,})\b/g;
+
+interface ToolDisplayDebugLoggerFileSystem {
+  existsSync: typeof existsSync;
+  mkdirSync: typeof mkdirSync;
+  readFileSync: typeof readFileSync;
+  statSync: typeof statSync;
+  appendFile: typeof appendFile;
+}
+
+export interface ToolDisplayDebugLoggerOptions {
+  configFile?: string;
+  debugDir?: string;
+  debugLogFile?: string;
+  cacheTtlMs?: number;
+  now?: () => number;
+  createDate?: () => Date;
+  fileSystem?: ToolDisplayDebugLoggerFileSystem;
+}
+
+export interface ToolDisplayDebugLogger {
+  log(message: string, error?: unknown): void;
+  flush(): Promise<void>;
+}
+
+const DEFAULT_FILE_SYSTEM: ToolDisplayDebugLoggerFileSystem = {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  statSync,
+  appendFile,
+};
+
+function redactMessage(value: string): string {
+  return value.replace(SECRET_VALUE_PATTERN, "[REDACTED]");
+}
+
+export function createToolDisplayDebugLogger(options: ToolDisplayDebugLoggerOptions = {}): ToolDisplayDebugLogger {
+  const configFile = options.configFile ?? DEFAULT_DEBUG_CONFIG_FILE;
+  const debugDir = options.debugDir ?? DEFAULT_DEBUG_DIR;
+  const debugLogFile = options.debugLogFile ?? DEFAULT_DEBUG_LOG_FILE;
+  const cacheTtlMs = options.cacheTtlMs ?? DEFAULT_DEBUG_CONFIG_CACHE_TTL_MS;
+  const now = options.now ?? Date.now;
+  const createDate = options.createDate ?? (() => new Date());
+  const fileSystem = options.fileSystem ?? DEFAULT_FILE_SYSTEM;
+
+  let cachedDebugFingerprint: string | undefined;
+  let cachedDebugEnabled = false;
+  let cachedDebugCheckedAt = 0;
+  let debugDirectoryReady = false;
+  let writeQueue: Promise<void> = Promise.resolve();
+
+  function getDebugConfigFingerprint(): string {
+    try {
+      const stats = fileSystem.statSync(configFile);
+      return `${stats.mtimeMs}:${stats.size}`;
+    } catch {
+      return "missing";
+    }
+  }
+
+  function isDebugEnabled(): boolean {
+    const checkedAt = now();
+    if (cachedDebugFingerprint !== undefined && checkedAt - cachedDebugCheckedAt < cacheTtlMs) {
+      return cachedDebugEnabled;
+    }
+
+    cachedDebugCheckedAt = checkedAt;
+    const fingerprint = getDebugConfigFingerprint();
+    if (fingerprint === cachedDebugFingerprint) {
+      return cachedDebugEnabled;
+    }
+
+    cachedDebugFingerprint = fingerprint;
+    cachedDebugEnabled = false;
+    try {
+      if (!fileSystem.existsSync(configFile)) {
+        return cachedDebugEnabled;
+      }
+
+      const rawConfig = JSON.parse(fileSystem.readFileSync(configFile, "utf8") as string) as unknown;
+      cachedDebugEnabled = toRecord(rawConfig).debug === true;
+      return cachedDebugEnabled;
+    } catch {
+      return cachedDebugEnabled;
+    }
+  }
+
+  function ensureDebugDirectory(): void {
+    if (debugDirectoryReady) {
+      return;
+    }
+
+    fileSystem.mkdirSync(debugDir, { recursive: true });
+    debugDirectoryReady = true;
+  }
+
+  function appendLine(line: string): Promise<void> {
+    return fileSystem.appendFile(debugLogFile, line, "utf8");
+  }
+
+  return {
+    log(message: string, error?: unknown): void {
+      if (!isDebugEnabled()) {
+        return;
+      }
+
+      try {
+        ensureDebugDirectory();
+        const errorText = error instanceof Error
+          ? `${error.name}: ${error.message}`
+          : error === undefined
+            ? ""
+            : String(error);
+        const suffix = errorText ? ` ${redactMessage(errorText)}` : "";
+        const line = `${createDate().toISOString()} ${redactMessage(message)}${suffix}\n`;
+        writeQueue = writeQueue.then(
+          () => appendLine(line),
+          () => appendLine(line),
+        );
+        void writeQueue.catch(() => undefined);
+      } catch (logError) {
+        // Debug logging must never affect extension behavior.
+        void logError;
+      }
+    },
+    flush(): Promise<void> {
+      return writeQueue.catch(() => undefined);
+    },
+  };
+}
+
+const defaultDebugLogger = createToolDisplayDebugLogger();
+
+export function logToolDisplayDebug(message: string, error?: unknown): void {
+  defaultDebugLogger.log(message, error);
+}

package/src/diff-presentation.ts

@@ -0,0 +1,72 @@
+import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+import { pluralize } from "./render-utils.js";
+import type { ToolDisplayConfig } from "./types.js";
+
+export interface DiffSummaryStats {
+	added: number;
+	removed: number;
+	hunks: number;
+	files: number;
+}
+
+export type DiffPresentationMode = "split" | "unified" | "compact" | "summary";
+
+const MIN_COMPACT_DIFF_WIDTH = 8;
+const MIN_UNIFIED_DIFF_WIDTH = 18;
+
+export function normalizeDiffRenderWidth(width: number): number {
+	if (!Number.isFinite(width)) {
+		return 0;
+	}
+	return Math.max(0, Math.floor(width));
+}
+
+export function resolveDiffPresentationMode(
+	config: Pick<ToolDisplayConfig, "diffViewMode" | "diffSplitMinWidth">,
+	width: number,
+	canRenderSplitLayout: boolean,
+): DiffPresentationMode {
+	const safeWidth = normalizeDiffRenderWidth(width);
+	if (safeWidth < MIN_COMPACT_DIFF_WIDTH) {
+		return "summary";
+	}
+	if (safeWidth < MIN_UNIFIED_DIFF_WIDTH) {
+		return "compact";
+	}
+
+	switch (config.diffViewMode) {
+		case "split":
+			return canRenderSplitLayout ? "split" : "unified";
+		case "unified":
+			return "unified";
+		case "auto":
+		default:
+			return safeWidth >= config.diffSplitMinWidth && canRenderSplitLayout
+				? "split"
+				: "unified";
+	}
+}
+
+export function buildDiffSummaryText(stats: DiffSummaryStats, width: number): string {
+	const safeWidth = normalizeDiffRenderWidth(width);
+	if (safeWidth === 0) {
+		return "";
+	}
+
+	const summaryCandidates = [
+		`↳ diff +${stats.added} -${stats.removed} • ${stats.hunks} ${pluralize(stats.hunks, "hunk")} • ${stats.files} ${pluralize(stats.files, "file")}`,
+		`↳ diff +${stats.added} -${stats.removed} • ${stats.hunks}h • ${stats.files}f`,
+		`↳ diff +${stats.added} -${stats.removed}`,
+		`+${stats.added} -${stats.removed}`,
+		"diff",
+		"…",
+	];
+
+	for (const candidate of summaryCandidates) {
+		if (visibleWidth(candidate) <= safeWidth) {
+			return candidate;
+		}
+	}
+
+	return truncateToWidth(summaryCandidates[summaryCandidates.length - 1] ?? "", safeWidth, "");
+}