@selesai/code 0.10.1 → 0.11.0

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

@@ -0,0 +1,117 @@
+import { cloneCustomToolOverrides } from "./config-store.js";
+import { DEFAULT_TOOL_DISPLAY_CONFIG, type CustomToolOverrideConfig, type ToolDisplayConfig } from "./types.js";
+
+export const TOOL_DISPLAY_PRESETS = ["opencode", "balanced", "verbose", "boxed"] as const;
+export type ToolDisplayPreset = (typeof TOOL_DISPLAY_PRESETS)[number];
+
+const TOOL_DISPLAY_PRESET_CONFIGS: Record<ToolDisplayPreset, ToolDisplayConfig> = {
+	opencode: {
+		...DEFAULT_TOOL_DISPLAY_CONFIG,
+		registerToolOverrides: { ...DEFAULT_TOOL_DISPLAY_CONFIG.registerToolOverrides },
+		boxedToolCalls: false,
+	},
+	balanced: {
+		...DEFAULT_TOOL_DISPLAY_CONFIG,
+		registerToolOverrides: { ...DEFAULT_TOOL_DISPLAY_CONFIG.registerToolOverrides },
+		boxedToolCalls: false,
+		readOutputMode: "summary",
+		searchOutputMode: "count",
+		mcpOutputMode: "summary",
+		bashOutputMode: "summary",
+	},
+	verbose: {
+		...DEFAULT_TOOL_DISPLAY_CONFIG,
+		registerToolOverrides: { ...DEFAULT_TOOL_DISPLAY_CONFIG.registerToolOverrides },
+		boxedToolCalls: false,
+		readOutputMode: "preview",
+		searchOutputMode: "preview",
+		mcpOutputMode: "preview",
+		bashOutputMode: "preview",
+		previewLines: 12,
+		bashCollapsedLines: 20,
+	},
+	boxed: {
+		...DEFAULT_TOOL_DISPLAY_CONFIG,
+		registerToolOverrides: { ...DEFAULT_TOOL_DISPLAY_CONFIG.registerToolOverrides },
+		boxedToolCalls: true,
+	},
+};
+
+function toolOverrideOwnershipEqual(a: ToolDisplayConfig, b: ToolDisplayConfig): boolean {
+	return (
+		a.registerToolOverrides.read === b.registerToolOverrides.read &&
+		a.registerToolOverrides.grep === b.registerToolOverrides.grep &&
+		a.registerToolOverrides.find === b.registerToolOverrides.find &&
+		a.registerToolOverrides.ls === b.registerToolOverrides.ls &&
+		a.registerToolOverrides.bash === b.registerToolOverrides.bash &&
+		a.registerToolOverrides.edit === b.registerToolOverrides.edit &&
+		a.registerToolOverrides.write === b.registerToolOverrides.write
+	);
+}
+
+function customToolOverridesEqual(a: ToolDisplayConfig, b: ToolDisplayConfig): boolean {
+	const aEntries = Object.entries(a.customToolOverrides).sort(([left], [right]) => left.localeCompare(right));
+	const bEntries = Object.entries(b.customToolOverrides).sort(([left], [right]) => left.localeCompare(right));
+	if (aEntries.length !== bEntries.length) {
+		return false;
+	}
+
+	return aEntries.every(([toolName, override], index) => {
+		const [otherToolName, otherOverride] = bEntries[index];
+		return (
+			toolName === otherToolName &&
+			override.enabled === otherOverride.enabled &&
+			override.kind === otherOverride.kind &&
+			override.outputMode === otherOverride.outputMode
+		);
+	});
+}
+
+function configsEqual(a: ToolDisplayConfig, b: ToolDisplayConfig): boolean {
+	return (
+		toolOverrideOwnershipEqual(a, b) &&
+		customToolOverridesEqual(a, b) &&
+		a.enableNativeUserMessageBox === b.enableNativeUserMessageBox &&
+		a.readOutputMode === b.readOutputMode &&
+		a.searchOutputMode === b.searchOutputMode &&
+		a.mcpOutputMode === b.mcpOutputMode &&
+		a.previewLines === b.previewLines &&
+		a.expandedPreviewMaxLines === b.expandedPreviewMaxLines &&
+		a.bashOutputMode === b.bashOutputMode &&
+		a.bashCollapsedLines === b.bashCollapsedLines &&
+		a.diffViewMode === b.diffViewMode &&
+		a.diffIndicatorMode === b.diffIndicatorMode &&
+		a.diffSplitMinWidth === b.diffSplitMinWidth &&
+		a.diffCollapsedLines === b.diffCollapsedLines &&
+		a.diffWordWrap === b.diffWordWrap &&
+		a.showTruncationHints === b.showTruncationHints &&
+		a.showRtkCompactionHints === b.showRtkCompactionHints &&
+		a.boxedToolCalls === b.boxedToolCalls
+	);
+}
+
+export function getToolDisplayPresetConfig(preset: ToolDisplayPreset): ToolDisplayConfig {
+	const config = TOOL_DISPLAY_PRESET_CONFIGS[preset];
+	return {
+		...config,
+		registerToolOverrides: { ...config.registerToolOverrides },
+		customToolOverrides: cloneCustomToolOverrides(config.customToolOverrides),
+	};
+}
+
+export function detectToolDisplayPreset(config: ToolDisplayConfig): ToolDisplayPreset | "custom" {
+	for (const preset of TOOL_DISPLAY_PRESETS) {
+		if (configsEqual(config, TOOL_DISPLAY_PRESET_CONFIGS[preset])) {
+			return preset;
+		}
+	}
+	return "custom";
+}
+
+export function parseToolDisplayPreset(raw: string): ToolDisplayPreset | undefined {
+	const normalized = raw.trim().toLowerCase();
+	if (!normalized) {
+		return undefined;
+	}
+	return TOOL_DISPLAY_PRESETS.find((preset) => preset === normalized);
+}

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

@@ -0,0 +1,186 @@
+import { homedir } from "node:os";
+import { sanitizeAnsiForThemedOutput } from "./ansi-utils.js";
+
+export { sanitizeAnsiForThemedOutput };
+
+interface TextLikeContent {
+  type: string;
+  text?: string;
+}
+
+interface ToolResultLike {
+  content?: unknown;
+}
+
+const QUIET_COMMAND_PREFIXES = [
+  "cd",
+  "mkdir",
+  "rmdir",
+  "rm",
+  "mv",
+  "cp",
+  "touch",
+  "chmod",
+  "chown",
+  "git add",
+  "git checkout",
+  "git switch",
+  "git restore",
+  "git reset",
+  "git clean",
+  "npm install",
+  "pnpm install",
+  "yarn install",
+  "bun install",
+  "pip install",
+  "poetry install",
+  "cargo fetch",
+  "go mod tidy",
+  "Set-Location",
+  "New-Item",
+  "Remove-Item",
+  "Move-Item",
+  "Copy-Item",
+] as const;
+
+interface CompactOutputOptions {
+  expanded: boolean;
+  maxCollapsedConsecutiveEmptyLines?: number;
+}
+
+function trimTrailingEmptyLines(lines: string[]): string[] {
+  const next = [...lines];
+  while (next.length > 0 && next[next.length - 1]?.trim().length === 0) {
+    next.pop();
+  }
+  return next;
+}
+
+function collapseConsecutiveEmptyLines(
+  lines: string[],
+  maxConsecutiveEmptyLines: number,
+): string[] {
+  const maxAllowed = Math.max(0, maxConsecutiveEmptyLines);
+  if (maxAllowed === 0) {
+    return lines.filter((line) => line.trim().length > 0);
+  }
+
+  const compacted: string[] = [];
+  let consecutiveEmpty = 0;
+
+  for (const line of lines) {
+    if (line.trim().length === 0) {
+      consecutiveEmpty++;
+      if (consecutiveEmpty > maxAllowed) {
+        continue;
+      }
+    } else {
+      consecutiveEmpty = 0;
+    }
+    compacted.push(line);
+  }
+
+  return compacted;
+}
+
+export function shortenPath(inputPath: string | undefined): string {
+  if (!inputPath) {
+    return "";
+  }
+  const home = homedir();
+  return inputPath.startsWith(home)
+    ? `~${inputPath.slice(home.length)}`
+    : inputPath;
+}
+
+export function extractTextOutput(result: ToolResultLike): string {
+  const rawBlocks = Array.isArray(result.content) ? result.content : [];
+  const blocks = rawBlocks.filter(
+    (block): block is TextLikeContent =>
+      typeof block === "object" &&
+      block !== null &&
+      "type" in block &&
+      (block as TextLikeContent).type === "text" &&
+      typeof (block as TextLikeContent).text === "string",
+  );
+  return blocks.map((block) => block.text ?? "").join("\n");
+}
+
+export function splitLines(text: string): string[] {
+  if (!text) {
+    return [];
+  }
+  return text
+    .replace(/\r/g, "")
+    .split("\n")
+    .map((line) => line.replace(/\t/g, "    "));
+}
+
+export function compactOutputLines(
+  lines: string[],
+  options: CompactOutputOptions,
+): string[] {
+  const trimmed = trimTrailingEmptyLines(lines);
+  if (options.expanded) {
+    return trimmed;
+  }
+
+  return collapseConsecutiveEmptyLines(
+    trimmed,
+    options.maxCollapsedConsecutiveEmptyLines ?? 1,
+  );
+}
+
+export function isLikelyQuietCommand(command: string | undefined): boolean {
+  if (!command) {
+    return false;
+  }
+
+  const normalized = command.trim().toLowerCase();
+  if (!normalized) {
+    return false;
+  }
+
+  const primarySegment = normalized
+    .split(/&&|\|\||;/)
+    .map((segment) => segment.trim())
+    .find((segment) => segment.length > 0);
+
+  if (!primarySegment) {
+    return false;
+  }
+
+  for (const prefix of QUIET_COMMAND_PREFIXES) {
+    const normalizedPrefix = prefix.toLowerCase();
+    if (
+      primarySegment === normalizedPrefix ||
+      primarySegment.startsWith(`${normalizedPrefix} `)
+    ) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+export function countNonEmptyLines(lines: string[]): number {
+  return lines.filter((line) => line.trim().length > 0).length;
+}
+
+export function pluralize(
+  count: number,
+  singular: string,
+  plural = `${singular}s`,
+): string {
+  return count === 1 ? singular : plural;
+}
+
+export function previewLines(
+  lines: string[],
+  maxLines: number,
+): { shown: string[]; remaining: number } {
+  const limit = Math.max(0, maxLines);
+  const shown = lines.slice(0, limit);
+  const remaining = Math.max(0, lines.length - shown.length);
+  return { shown, remaining };
+}