pi-extensions-tool-display 0.1.1 → 0.2.1

package/src/pending-diff-preview.ts

@@ -0,0 +1,371 @@
+import { existsSync, readFileSync, realpathSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { isAbsolute, relative, resolve } from "node:path";
+
+export interface PendingDiffPreviewData {
+  filePath: string;
+  previousContent?: string;
+  nextContent?: string;
+  fileExistedBeforeWrite: boolean;
+  headerLabel: string;
+  notice?: string;
+}
+
+type EditPreviewInput = {
+  path?: unknown;
+  file_path?: unknown;
+  oldText?: unknown;
+  newText?: unknown;
+  edits?: unknown;
+};
+
+type EditReplacement = {
+  oldText: string;
+  newText: string;
+};
+
+type FileReadResult = {
+  exists: boolean;
+  content?: string;
+  error?: string;
+};
+
+const MAX_PREVIEW_READ_BYTES = 1_000_000;
+
+type ProjectedEditResult =
+  | {
+      ok: true;
+      content: string;
+    }
+  | {
+      ok: false;
+      reason: string;
+    };
+
+function trimPath(value: unknown): string | undefined {
+  if (typeof value !== "string") {
+    return undefined;
+  }
+
+  const trimmed = value.trim();
+  return trimmed ? trimmed : undefined;
+}
+
+function resolvePreviewPath(cwd: string, rawPath: string): string {
+  const trimmed = rawPath.trim();
+  if (!trimmed) {
+    return cwd;
+  }
+
+  const expandedHome = trimmed === "~"
+    ? homedir()
+    : trimmed.startsWith("~/") || trimmed.startsWith("~\\")
+      ? `${homedir()}${trimmed.slice(1)}`
+      : trimmed;
+
+  return isAbsolute(expandedHome) ? expandedHome : resolve(cwd, expandedHome);
+}
+
+function isWithinWorkspace(workspacePath: string, targetPath: string): boolean {
+  const relativePath = relative(workspacePath, targetPath);
+  return relativePath === "" || (!relativePath.startsWith("..") && !isAbsolute(relativePath));
+}
+
+function safeRealpath(path: string): string {
+  try {
+    return realpathSync(path);
+  } catch {
+    return resolve(path);
+  }
+}
+
+function resolveWorkspaceReadPath(cwd: string, rawPath: string): { resolvedPath: string; error?: string } {
+  const workspacePath = safeRealpath(cwd);
+  // 相对路径必须基于规范化后的 workspace 解析。macOS 上 /var 通常会被
+  // realpath 展开为 /private/var，混用两种表示会把 workspace 内文件误判为越界。
+  const resolvedPath = resolvePreviewPath(workspacePath, rawPath);
+
+  if (!existsSync(resolvedPath)) {
+    if (!isWithinWorkspace(workspacePath, resolvedPath)) {
+      return {
+        resolvedPath,
+        error: "Preview unavailable because the target path is outside the current workspace.",
+      };
+    }
+    return { resolvedPath };
+  }
+
+  try {
+    const targetPath = realpathSync(resolvedPath);
+    if (!isWithinWorkspace(workspacePath, targetPath)) {
+      return {
+        resolvedPath,
+        error: "Preview unavailable because the target path resolves outside the current workspace.",
+      };
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+      resolvedPath,
+      error: `Unable to resolve '${resolvedPath}': ${message}`,
+    };
+  }
+
+  return { resolvedPath };
+}
+
+export function readWorkspaceUtf8File(cwd: string, rawPath: string): FileReadResult {
+  const safePath = resolveWorkspaceReadPath(cwd, rawPath);
+  if (safePath.error) {
+    return { exists: false, error: safePath.error };
+  }
+
+  if (!existsSync(safePath.resolvedPath)) {
+    return { exists: false };
+  }
+
+  try {
+    const stats = statSync(safePath.resolvedPath);
+    if (!stats.isFile()) {
+      return {
+        exists: true,
+        error: `Preview unavailable because '${safePath.resolvedPath}' is not a regular file.`,
+      };
+    }
+    if (stats.size > MAX_PREVIEW_READ_BYTES) {
+      return {
+        exists: true,
+        error: `Preview unavailable because '${safePath.resolvedPath}' exceeds the ${MAX_PREVIEW_READ_BYTES} byte preview read limit.`,
+      };
+    }
+
+    return {
+      exists: true,
+      content: readFileSync(safePath.resolvedPath, "utf8"),
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+      exists: true,
+      error: `Unable to read '${safePath.resolvedPath}': ${message}`,
+    };
+  }
+}
+
+function countSubstringMatches(haystack: string, needle: string): number {
+  if (!needle) {
+    return 0;
+  }
+
+  let count = 0;
+  let cursor = 0;
+  while (cursor <= haystack.length) {
+    const index = haystack.indexOf(needle, cursor);
+    if (index === -1) {
+      break;
+    }
+    count++;
+    cursor = index + 1;
+  }
+  return count;
+}
+
+function stripBom(content: string): { bom: string; text: string } {
+  return content.startsWith("\uFEFF")
+    ? { bom: "\uFEFF", text: content.slice(1) }
+    : { bom: "", text: content };
+}
+
+function detectLineEnding(content: string): "\r\n" | "\n" {
+  const crlfIndex = content.indexOf("\r\n");
+  const lfIndex = content.indexOf("\n");
+  if (lfIndex === -1 || crlfIndex === -1) {
+    return "\n";
+  }
+  return crlfIndex < lfIndex ? "\r\n" : "\n";
+}
+
+function normalizeToLf(content: string): string {
+  return content.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+}
+
+function restoreLineEndings(content: string, ending: "\r\n" | "\n"): string {
+  return ending === "\r\n" ? content.replace(/\n/g, "\r\n") : content;
+}
+
+function toEditInput(value: unknown): EditPreviewInput {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return {};
+  }
+
+  return value as EditPreviewInput;
+}
+
+function getToolPath(input: unknown, preferFilePath: boolean): string | undefined {
+  const record = toEditInput(input);
+  const filePath = trimPath(record.file_path);
+  const path = trimPath(record.path);
+  return preferFilePath ? filePath ?? path : path ?? filePath;
+}
+
+function getWriteContent(input: unknown): string | undefined {
+  const record = toEditInput(input);
+  return typeof record.newText === "string"
+    ? undefined
+    : typeof (record as { content?: unknown }).content === "string"
+      ? (record as { content: string }).content
+      : undefined;
+}
+
+function getEditReplacements(input: unknown): EditReplacement[] {
+  const record = toEditInput(input);
+  if (Array.isArray(record.edits)) {
+    return record.edits.flatMap((entry) => {
+      if (!entry || typeof entry !== "object" || Array.isArray(entry)) {
+        return [];
+      }
+      const edit = entry as { oldText?: unknown; newText?: unknown };
+      return typeof edit.oldText === "string" && typeof edit.newText === "string"
+        ? [{ oldText: edit.oldText, newText: edit.newText }]
+        : [];
+    });
+  }
+
+  return typeof record.oldText === "string" && typeof record.newText === "string"
+    ? [{ oldText: record.oldText, newText: record.newText }]
+    : [];
+}
+
+function buildProjectedEditContent(originalContent: string, replacements: readonly EditReplacement[]): ProjectedEditResult {
+  if (replacements.length === 0) {
+    return {
+      ok: false,
+      reason: "Preview not shown: the edit request did not include exact replacement blocks.",
+    };
+  }
+
+  const { bom, text } = stripBom(originalContent);
+  const originalLineEnding = detectLineEnding(text);
+  const normalizedContent = normalizeToLf(text);
+  const normalizedReplacements = replacements.map((replacement) => ({
+    oldText: normalizeToLf(replacement.oldText),
+    newText: normalizeToLf(replacement.newText),
+  }));
+
+  const ranges: Array<{ start: number; end: number; replacement: string }> = [];
+  for (const [index, replacement] of normalizedReplacements.entries()) {
+    if (!replacement.oldText) {
+      return {
+        ok: false,
+        reason: `Preview not shown: edit #${index + 1} has an empty oldText block.`,
+      };
+    }
+
+    const matchCount = countSubstringMatches(normalizedContent, replacement.oldText);
+    if (matchCount !== 1) {
+      return {
+        ok: false,
+        reason: matchCount === 0
+          ? `Preview not shown: edit #${index + 1} did not match the current file contents.`
+          : `Preview not shown: edit #${index + 1} matched ${matchCount} regions instead of exactly one.`,
+      };
+    }
+
+    const start = normalizedContent.indexOf(replacement.oldText);
+    ranges.push({
+      start,
+      end: start + replacement.oldText.length,
+      replacement: replacement.newText,
+    });
+  }
+
+  ranges.sort((left, right) => left.start - right.start);
+  for (let index = 1; index < ranges.length; index++) {
+    const previous = ranges[index - 1];
+    const current = ranges[index];
+    if (previous && current && current.start < previous.end) {
+      return {
+        ok: false,
+        reason: "Preview not shown: the requested edits overlap in the original file.",
+      };
+    }
+  }
+
+  let cursor = 0;
+  let output = "";
+  for (const range of ranges) {
+    output += normalizedContent.slice(cursor, range.start);
+    output += range.replacement;
+    cursor = range.end;
+  }
+  output += normalizedContent.slice(cursor);
+
+  return {
+    ok: true,
+    content: `${bom}${restoreLineEndings(output, originalLineEnding)}`,
+  };
+}
+
+export function buildPendingWritePreviewData(input: unknown, cwd: string): PendingDiffPreviewData | undefined {
+  const filePath = getToolPath(input, false);
+  const nextContent = getWriteContent(input);
+  if (!filePath || typeof nextContent !== "string") {
+    return undefined;
+  }
+
+  const existing = readWorkspaceUtf8File(cwd, filePath);
+  return {
+    filePath,
+    previousContent: existing.content,
+    nextContent,
+    fileExistedBeforeWrite: existing.exists,
+    headerLabel: existing.exists ? "pending overwrite" : "pending create",
+    notice: existing.error,
+  };
+}
+
+export function buildPendingEditPreviewData(input: unknown, cwd: string): PendingDiffPreviewData | undefined {
+  const filePath = getToolPath(input, true);
+  if (!filePath) {
+    return undefined;
+  }
+
+  const existing = readWorkspaceUtf8File(cwd, filePath);
+  if (existing.error) {
+    return {
+      filePath,
+      fileExistedBeforeWrite: false,
+      headerLabel: "pending edit",
+      notice: existing.error,
+    };
+  }
+
+  if (!existing.exists || typeof existing.content !== "string") {
+    return {
+      filePath,
+      fileExistedBeforeWrite: false,
+      headerLabel: "pending edit",
+      notice: "Preview unavailable because the target file does not exist yet.",
+    };
+  }
+
+  const projected = buildProjectedEditContent(existing.content, getEditReplacements(input));
+  if (!projected.ok) {
+    const failedProjection = projected as Extract<ProjectedEditResult, { ok: false }>;
+    return {
+      filePath,
+      previousContent: existing.content,
+      fileExistedBeforeWrite: true,
+      headerLabel: "pending edit",
+      notice: failedProjection.reason,
+    };
+  }
+
+  return {
+    filePath,
+    previousContent: existing.content,
+    nextContent: projected.content,
+    fileExistedBeforeWrite: true,
+    headerLabel: "pending edit",
+  };
+}

package/src/presets.ts

@@ -0,0 +1,108 @@
+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"] 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 },
+	},
+	balanced: {
+		...DEFAULT_TOOL_DISPLAY_CONFIG,
+		registerToolOverrides: { ...DEFAULT_TOOL_DISPLAY_CONFIG.registerToolOverrides },
+		readOutputMode: "summary",
+		searchOutputMode: "count",
+		mcpOutputMode: "summary",
+		bashOutputMode: "summary",
+	},
+	verbose: {
+		...DEFAULT_TOOL_DISPLAY_CONFIG,
+		registerToolOverrides: { ...DEFAULT_TOOL_DISPLAY_CONFIG.registerToolOverrides },
+		readOutputMode: "preview",
+		searchOutputMode: "preview",
+		mcpOutputMode: "preview",
+		bashOutputMode: "preview",
+		previewLines: 12,
+		bashCollapsedLines: 20,
+	},
+};
+
+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
+	);
+}
+
+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/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 };
+}