@selesai/code 0.10.1 → 0.11.0

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

@@ -0,0 +1,34 @@
+// Track cleanup callbacks for reload safety
+let cleanupCallbacks: Array<() => void> = [];
+let isDisposed = false;
+
+export function registerCleanup(callback: () => void): void {
+  if (isDisposed) {
+    callback();
+    return;
+  }
+  cleanupCallbacks.push(callback);
+}
+
+export function registerTimer(timer: ReturnType<typeof setInterval> | ReturnType<typeof setTimeout>): void {
+  registerCleanup(() => clearInterval(timer as ReturnType<typeof setInterval>));
+}
+
+export function disposeAll(): void {
+  if (isDisposed) return;
+  isDisposed = true;
+  // Run in reverse order (LIFO)
+  for (let i = cleanupCallbacks.length - 1; i >= 0; i--) {
+    try { cleanupCallbacks[i](); } catch (cleanupError) { void cleanupError; }
+  }
+  cleanupCallbacks = [];
+}
+
+export function resetDisposed(): void {
+  isDisposed = false;
+  cleanupCallbacks = [];
+}
+
+export function getCleanupCount(): number {
+  return cleanupCallbacks.length;
+}

package/dist/extensions/pi-tool-display/src/extension-lifecycle.ts

@@ -0,0 +1,14 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+
+/**
+ * Register a session_shutdown handler that runs cleanup only when the
+ * session is shutting down for a reload. Centralizes the reload-detection
+ * check shared by extension registration modules.
+ */
+export function onReloadShutdown(pi: ExtensionAPI, cleanup: () => void): void {
+  pi.on("session_shutdown", async (event: { reason?: string }) => {
+    if (event?.reason === "reload") {
+      cleanup();
+    }
+  });
+}

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

@@ -0,0 +1,109 @@
+import type {
+  ExtensionAPI,
+  ExtensionCommandContext,
+} from "@earendil-works/pi-coding-agent";
+import {
+  loadToolDisplayConfig,
+  normalizeToolDisplayConfig,
+  saveToolDisplayConfig,
+} from "./config-store.js";
+import {
+  applyCapabilityConfigGuards,
+  detectToolDisplayCapabilities,
+  type ToolDisplayCapabilities,
+} from "./capabilities.js";
+import { registerToolDisplayOverrides } from "./tool-overrides.js";
+import { disposeAll, resetDisposed } from "./disposable.js";
+import { registerThinkingLabeling } from "./thinking-label.js";
+import registerNativeUserMessageBox from "./user-message-box-native.js";
+import {
+  BUILT_IN_TOOL_OVERRIDE_NAMES,
+  type ToolDisplayConfig,
+} from "./types.js";
+
+function ownershipChanged(
+  previous: ToolDisplayConfig,
+  next: ToolDisplayConfig,
+): boolean {
+  return BUILT_IN_TOOL_OVERRIDE_NAMES.some(
+    (toolName) =>
+      previous.registerToolOverrides[toolName] !==
+      next.registerToolOverrides[toolName],
+  );
+}
+
+export default function toolDisplayExtension(pi: ExtensionAPI): void {
+  const initial = loadToolDisplayConfig();
+  if (!initial.config.enabled) {
+    return;
+  }
+
+  resetDisposed();
+
+  pi.on("session_shutdown", (event: { reason: string }) => {
+    if (event.reason === "reload") {
+      disposeAll();
+    }
+  });
+
+  let config: ToolDisplayConfig = initial.config;
+  let pendingLoadError = initial.error;
+  let capabilities: ToolDisplayCapabilities = {
+    hasMcpTooling: false,
+    hasRtkOptimizer: false,
+  };
+
+  const refreshCapabilities = (): void => {
+    capabilities = detectToolDisplayCapabilities(pi, process.cwd());
+  };
+
+  const getConfig = (): ToolDisplayConfig => config;
+  const getCapabilities = (): ToolDisplayCapabilities => capabilities;
+  const getEffectiveConfig = (): ToolDisplayConfig =>
+    applyCapabilityConfigGuards(config, capabilities);
+
+  const setConfig = (
+    next: ToolDisplayConfig,
+    ctx: ExtensionCommandContext,
+  ): void => {
+    const normalized = normalizeToolDisplayConfig(next);
+    const requiresReload = ownershipChanged(config, normalized);
+    config = normalized;
+
+    const saved = saveToolDisplayConfig(normalized);
+    if (!saved.success && saved.error) {
+      ctx.ui.notify(saved.error, "error");
+    }
+
+    if (requiresReload) {
+      ctx.ui.notify(
+        "Tool ownership updates apply after /reload.",
+        "warning",
+      );
+    }
+  };
+
+  registerToolDisplayOverrides(pi, getEffectiveConfig);
+  registerNativeUserMessageBox(pi, getConfig);
+  registerThinkingLabeling(pi);
+
+  pi.registerCommand("tool-display", {
+    description: "Configure tool output rendering (OpenCode/boxed styles)",
+    handler: async (args, ctx) => {
+      const { runToolDisplayCommandHandler } = await import("./config-modal.js");
+      await runToolDisplayCommandHandler(args, ctx, { getConfig, setConfig, getCapabilities });
+    },
+  });
+
+  pi.on("session_start", async (_event, ctx) => {
+    refreshCapabilities();
+    if (pendingLoadError) {
+      ctx.ui.notify(pendingLoadError, "warning");
+      pendingLoadError = undefined;
+    }
+  });
+
+  pi.on("before_agent_start", async () => {
+    refreshCapabilities();
+  });
+}

package/dist/extensions/pi-tool-display/src/line-width-safety.ts

@@ -0,0 +1,93 @@
+import { normalizeDiffRenderWidth } from "./diff-presentation.js";
+import { pluralize } from "./render-utils.js";
+
+export interface WidthMeasurementOps {
+	measure(text: string): number;
+	truncate(text: string, maxWidth: number): string;
+}
+
+export interface CollapsedDiffHintOptions {
+	remainingLines: number;
+	hiddenHunks: number;
+}
+
+function guardSafeWidth(width: number): number | undefined {
+	const safe = normalizeDiffRenderWidth(width);
+	return safe === 0 ? undefined : safe;
+}
+
+function renderWithSafeWidth<T>(
+	width: number,
+	fallback: T,
+	render: (safeWidth: number) => T,
+): T {
+	const safeWidth = guardSafeWidth(width);
+	if (safeWidth === undefined) {
+		return fallback;
+	}
+	return render(safeWidth);
+}
+
+export function clampRenderedLineToWidth(
+	text: string,
+	width: number,
+	ops: WidthMeasurementOps,
+): string {
+	return renderWithSafeWidth(width, "", (safeWidth) => {
+		if (ops.measure(text) <= safeWidth) {
+			return text;
+		}
+
+		for (let targetWidth = safeWidth; targetWidth >= 0; targetWidth--) {
+			const candidate = ops.truncate(text, targetWidth);
+			if (ops.measure(candidate) <= safeWidth) {
+				return candidate;
+			}
+		}
+
+		return "";
+	});
+}
+
+export function clampRenderedLinesToWidth(
+	lines: string[],
+	width: number,
+	ops: WidthMeasurementOps,
+): string[] {
+	return lines.map((line) => clampRenderedLineToWidth(line, width, ops));
+}
+
+export function buildCollapsedDiffHintText(
+	options: CollapsedDiffHintOptions,
+	width: number,
+	ops: WidthMeasurementOps,
+): string {
+	return renderWithSafeWidth(width, "", (safeWidth) => {
+		const remainingText = `${options.remainingLines} more ${pluralize(options.remainingLines, "diff line")}`;
+		const hiddenHunksText = options.hiddenHunks > 0
+			? `${options.hiddenHunks} more ${pluralize(options.hiddenHunks, "hunk")}`
+			: undefined;
+		const shortRemainingText = `${options.remainingLines} more ${pluralize(options.remainingLines, "line")}`;
+		const shortHiddenHunksText = options.hiddenHunks > 0
+			? `${options.hiddenHunks} ${pluralize(options.hiddenHunks, "hunk")}`
+			: undefined;
+
+		const candidates = [
+			`… (${[remainingText, hiddenHunksText, "Ctrl+O to expand"].filter(Boolean).join(" • ")})`,
+			`… (${[remainingText, hiddenHunksText].filter(Boolean).join(" • ")})`,
+			`… (${[shortRemainingText, shortHiddenHunksText].filter(Boolean).join(" • ")})`,
+			options.hiddenHunks > 0
+				? `… (+${options.remainingLines} • +${options.hiddenHunks}h)`
+				: `… (+${options.remainingLines})`,
+			"…",
+		];
+
+		for (const candidate of candidates) {
+			if (ops.measure(candidate) <= safeWidth) {
+				return candidate;
+			}
+		}
+
+		return clampRenderedLineToWidth(candidates[candidates.length - 1] ?? "", safeWidth, ops);
+	});
+}

package/dist/extensions/pi-tool-display/src/modal-icons.ts

@@ -0,0 +1,57 @@
+export interface ModalIconSet {
+	search: string;
+}
+
+const NERD_MODAL_ICONS: ModalIconSet = {
+	search: "\uF002",
+};
+
+const EMOJI_MODAL_ICONS: ModalIconSet = {
+	search: "🔍",
+};
+
+const NERD_FONT_TERMINAL_HINTS = [
+	"iterm",
+	"wezterm",
+	"kitty",
+	"ghostty",
+	"alacritty",
+	"xfce4-terminal",
+	"gnome-terminal",
+	"tilix",
+	"terminator",
+	"konsole",
+] as const;
+
+function parseBooleanEnv(value: string | undefined): boolean | undefined {
+	if (value === "1" || value?.toLowerCase() === "true") {
+		return true;
+	}
+
+	if (value === "0" || value?.toLowerCase() === "false") {
+		return false;
+	}
+
+	return undefined;
+}
+
+function detectNerdFonts(): boolean {
+	const explicitPreference =
+		parseBooleanEnv(process.env.PI_NERD_FONTS) ?? parseBooleanEnv(process.env.POWERLINE_NERD_FONTS);
+	if (explicitPreference !== undefined) {
+		return explicitPreference;
+	}
+
+	if (process.env.GHOSTTY_RESOURCES_DIR) {
+		return true;
+	}
+
+	const termProgram = (process.env.TERM_PROGRAM || "").toLowerCase();
+	const term = (process.env.TERM || "").toLowerCase();
+	const fingerprint = `${termProgram} ${term}`;
+	return NERD_FONT_TERMINAL_HINTS.some((terminal) => fingerprint.includes(terminal));
+}
+
+export function getModalIcons(): ModalIconSet {
+	return detectNerdFonts() ? NERD_MODAL_ICONS : EMOJI_MODAL_ICONS;
+}

package/dist/extensions/pi-tool-display/src/pending-diff-preview.ts

@@ -0,0 +1,370 @@
+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(safeRealpath(workspacePath), safeRealpath(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);
+  const resolvedPath = resolvePreviewPath(cwd, rawPath);
+
+  if (!isWithinWorkspace(workspacePath, resolvedPath)) {
+    return {
+      resolvedPath,
+      error: "Preview unavailable because the target path is outside the current workspace.",
+    };
+  }
+
+  if (!existsSync(resolvedPath)) {
+    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",
+  };
+}