@pi-unipi/compactor 0.1.1

package/src/display/diff-renderer.ts

@@ -0,0 +1,255 @@
+/**
+ * Diff rendering engine — LCS-based diff with 3 layouts, 3 indicators,
+ * syntax highlighting, and Nerd Font detection
+ */
+
+export type DiffLayout = "auto" | "split" | "unified";
+export type DiffIndicator = "bars" | "classic" | "nerd" | "none";
+
+// --- Nerd Font Detection ---
+
+let nerdFontDetected: boolean | null = null;
+
+/** Detect if terminal supports Nerd Font icons */
+export function detectNerdFont(): boolean {
+  if (nerdFontDetected !== null) return nerdFontDetected;
+  // Check common Nerd Font env vars or terminal emulators
+  const term = process.env.TERM_PROGRAM ?? "";
+  const termFont = process.env.TERM_FONT ?? "";
+  nerdFontDetected =
+    termFont.toLowerCase().includes("nerd") ||
+    process.env.NERD_FONT === "1" ||
+    term === "WezTerm" ||
+    term === "iTerm.app" ||
+    (process.env.TERMINAL_EMULATOR ?? "").includes("JetBrains") ||
+    false;
+  return nerdFontDetected;
+}
+
+/** Nerd Font indicator chars */
+const NERD_INDICATORS = {
+  add: "\uf055 ",   // nf-fa-plus_circle
+  remove: "\uf056 ", // nf-fa-minus_circle
+  same: "  ",
+} as const;
+
+// --- Syntax Highlighting ---
+
+const KEYWORDS: Record<string, Set<string>> = {
+  js: new Set(["const", "let", "var", "function", "return", "if", "else", "for", "while", "class", "import", "export", "from", "async", "await", "try", "catch", "throw", "new", "this", "typeof", "instanceof", "in", "of", "switch", "case", "break", "continue", "default", "yield", "void", "delete", "null", "undefined", "true", "false"]),
+  py: new Set(["def", "class", "import", "from", "return", "if", "elif", "else", "for", "while", "try", "except", "finally", "raise", "with", "as", "yield", "lambda", "pass", "break", "continue", "and", "or", "not", "in", "is", "None", "True", "False", "self", "async", "await"]),
+  ts: new Set(["const", "let", "var", "function", "return", "if", "else", "for", "while", "class", "import", "export", "from", "async", "await", "try", "catch", "throw", "new", "this", "typeof", "instanceof", "interface", "type", "enum", "namespace", "module", "declare", "implements", "extends", "public", "private", "protected", "readonly", "static", "abstract", "override", "keyof", "infer", "never", "unknown", "any", "void", "string", "number", "boolean", "null", "undefined", "true", "false"]),
+  sh: new Set(["if", "then", "else", "elif", "fi", "for", "while", "do", "done", "case", "esac", "function", "return", "local", "export", "readonly", "declare", "unset", "shift", "source", "exit", "echo", "printf", "read", "test", "true", "false"]),
+};
+
+/** Apply basic syntax highlighting to a line */
+function highlightLine(line: string, lang?: string): string {
+  if (!lang) return line;
+  const keywords = KEYWORDS[lang] ?? KEYWORDS.js;
+  // Highlight keywords (simple word boundary match)
+  return line.replace(/\b([a-zA-Z_]\w*)\b/g, (match) => {
+    if (keywords.has(match)) return `\x1b[34m${match}\x1b[0m`; // blue
+    return match;
+  });
+}
+
+/** Detect language from file extension or content */
+function detectLanguage(filePath?: string, content?: string): string | undefined {
+  if (filePath) {
+    const ext = filePath.split(".").pop()?.toLowerCase();
+    const extMap: Record<string, string> = {
+      js: "js", mjs: "js", cjs: "js", jsx: "js",
+      ts: "ts", mts: "ts", cts: "ts", tsx: "ts",
+      py: "py", pyw: "py",
+      sh: "sh", bash: "sh", zsh: "sh",
+    };
+    if (ext && extMap[ext]) return extMap[ext];
+  }
+  if (content) {
+    if (content.includes("def ") || content.includes("import ")) return "py";
+    if (content.includes("function ") || content.includes("const ")) return "js";
+    if (content.includes("#!/bin/")) return "sh";
+  }
+  return undefined;
+}
+
+interface DiffLine {
+  type: "same" | "add" | "remove";
+  text: string;
+}
+
+function lcs<T>(a: T[], b: T[]): T[] {
+  const m = a.length;
+  const n = b.length;
+  const dp: number[][] = Array.from({ length: m + 1 }, () => Array(n + 1).fill(0));
+
+  for (let i = 1; i <= m; i++) {
+    for (let j = 1; j <= n; j++) {
+      if (a[i - 1] === b[j - 1]) {
+        dp[i][j] = dp[i - 1][j - 1] + 1;
+      } else {
+        dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
+      }
+    }
+  }
+
+  const result: T[] = [];
+  let i = m, j = n;
+  while (i > 0 && j > 0) {
+    if (a[i - 1] === b[j - 1]) {
+      result.unshift(a[i - 1]);
+      i--;
+      j--;
+    } else if (dp[i - 1][j] > dp[i][j - 1]) {
+      i--;
+    } else {
+      j--;
+    }
+  }
+
+  return result;
+}
+
+function computeDiff(before: string[], after: string[]): DiffLine[] {
+  const common = lcs(before, after);
+  const result: DiffLine[] = [];
+  let i = 0, j = 0, k = 0;
+
+  while (i < before.length || j < after.length) {
+    if (k < common.length && before[i] === common[k] && after[j] === common[k]) {
+      result.push({ type: "same", text: after[j] });
+      i++;
+      j++;
+      k++;
+    } else if (i < before.length && (k >= common.length || before[i] !== common[k])) {
+      result.push({ type: "remove", text: before[i] });
+      i++;
+    } else if (j < after.length && (k >= common.length || after[j] !== common[k])) {
+      result.push({ type: "add", text: after[j] });
+      j++;
+    } else {
+      break;
+    }
+  }
+
+  return result;
+}
+
+function indicatorChar(type: DiffLine["type"], style: DiffIndicator): string {
+  if (style === "none") return "  ";
+  if (style === "nerd") {
+    if (type === "add") return `\x1b[32m${NERD_INDICATORS.add}\x1b[0m`;
+    if (type === "remove") return `\x1b[31m${NERD_INDICATORS.remove}\x1b[0m`;
+    return NERD_INDICATORS.same;
+  }
+  if (style === "bars") {
+    if (type === "add") return `\x1b[32m│ \x1b[0m`;
+    if (type === "remove") return `\x1b[31m│ \x1b[0m`;
+    return "  ";
+  }
+  return type === "add" ? "+ " : type === "remove" ? "- " : "  ";
+}
+
+function renderUnified(diff: DiffLine[], indicator: DiffIndicator): string {
+  return diff.map((line) => {
+    const prefix = indicator === "bars"
+      ? (line.type === "add" ? "│ " : line.type === "remove" ? "│ " : "  ")
+      : indicatorChar(line.type, indicator);
+    return prefix + line.text;
+  }).join("\n");
+}
+
+function renderSplit(diff: DiffLine[], indicator: DiffIndicator): string {
+  const left: string[] = [];
+  const right: string[] = [];
+
+  for (const line of diff) {
+    if (line.type === "same") {
+      left.push("  " + line.text);
+      right.push("  " + line.text);
+    } else if (line.type === "remove") {
+      left.push(indicatorChar("remove", indicator) + line.text);
+      right.push("");
+    } else if (line.type === "add") {
+      left.push("");
+      right.push(indicatorChar("add", indicator) + line.text);
+    }
+  }
+
+  const maxWidth = Math.max(...left.map((l) => l.length), 40);
+  const result: string[] = [];
+  for (let i = 0; i < left.length; i++) {
+    const l = left[i].padEnd(maxWidth);
+    const sep = left[i] && right[i] ? " │ " : "   ";
+    result.push(l + sep + right[i]);
+  }
+
+  return result.join("\n");
+}
+
+export function renderDiff(
+  before: string,
+  after: string,
+  opts?: { layout?: DiffLayout; indicator?: DiffIndicator; maxWidth?: number; filePath?: string; highlight?: boolean },
+): string {
+  const layout = opts?.layout ?? "auto";
+  let indicator = opts?.indicator ?? "bars";
+  const maxWidth = opts?.maxWidth ?? 120;
+  const doHighlight = opts?.highlight ?? true;
+
+  // Auto-detect Nerd Font for indicator selection
+  if (indicator === "bars" && detectNerdFont()) {
+    indicator = "nerd";
+  }
+
+  const beforeLines = before.split("\n");
+  const afterLines = after.split("\n");
+  const diff = computeDiff(beforeLines, afterLines);
+
+  const effectiveLayout = layout === "auto"
+    ? (maxWidth >= 100 ? "split" : "unified")
+    : layout;
+
+  let effectiveIndicator = indicator;
+  // Auto mode: use classic indicator for unified to keep output clean
+  if (layout === "auto" && effectiveLayout === "unified" && indicator !== "nerd") {
+    effectiveIndicator = "classic";
+  }
+
+  // Apply syntax highlighting if enabled
+  let highlightedDiff = diff;
+  if (doHighlight) {
+    const lang = detectLanguage(opts?.filePath, after);
+    if (lang) {
+      highlightedDiff = diff.map((line) => ({
+        ...line,
+        text: highlightLine(line.text, lang),
+      }));
+    }
+  }
+
+  if (effectiveLayout === "split") {
+    return renderSplit(highlightedDiff, effectiveIndicator);
+  }
+
+  return renderUnified(highlightedDiff, effectiveIndicator);
+}
+
+export function renderEditDiffResult(
+  previousContent: string,
+  newContent: string,
+  opts?: { layout?: DiffLayout; indicator?: DiffIndicator; maxWidth?: number },
+): string {
+  return renderDiff(previousContent, newContent, opts);
+}
+
+export function renderWriteDiffResult(
+  previousContent: string | undefined,
+  newContent: string,
+  opts?: { layout?: DiffLayout; indicator?: DiffIndicator; maxWidth?: number },
+): string {
+  if (!previousContent) {
+    return "[New file created]\n" + newContent.split("\n").map((l) => "+ " + l).join("\n");
+  }
+  return renderDiff(previousContent, newContent, opts);
+}

package/src/display/line-width-safety.ts

@@ -0,0 +1,16 @@
+/**
+ * Line width safety — width clamping with collapsed hints
+ */
+
+export function clampLineWidth(lines: string[], maxWidth: number): string[] {
+  return lines.map((line) => {
+    if (line.length <= maxWidth) return line;
+    return line.slice(0, maxWidth - 3) + "...";
+  });
+}
+
+export function collapseHint(originalCount: number, shownCount: number): string {
+  const omitted = originalCount - shownCount;
+  if (omitted <= 0) return "";
+  return `...(${omitted} more lines)...`;
+}

package/src/display/pending-diff-preview.ts

@@ -0,0 +1,51 @@
+/**
+ * Pending diff previews during streaming
+ */
+
+export interface PendingDiffPreviewData {
+  type: "edit" | "write" | "create";
+  filePath: string;
+  previousContent?: string;
+  newContent: string;
+  confidence: number;
+}
+
+export function buildPendingEditPreviewData(
+  filePath: string,
+  oldText: string,
+  newText: string,
+): PendingDiffPreviewData {
+  return {
+    type: "edit",
+    filePath,
+    previousContent: oldText,
+    newContent: newText,
+    confidence: 1.0,
+  };
+}
+
+export function buildPendingWritePreviewData(
+  filePath: string,
+  content: string,
+  fileExisted: boolean,
+): PendingDiffPreviewData {
+  return {
+    type: fileExisted ? "write" : "create",
+    filePath,
+    newContent: content,
+    confidence: 1.0,
+  };
+}
+
+export function renderPendingDiffPreview(data: PendingDiffPreviewData, opts?: { maxLines?: number }): string {
+  const maxLines = opts?.maxLines ?? 20;
+  const lines = data.newContent.split("\n").slice(0, maxLines);
+  const header = data.type === "edit" ? `✏️  Edit: ${data.filePath}`
+    : data.type === "write" ? `📝 Write: ${data.filePath}`
+    : `📄 Create: ${data.filePath}`;
+
+  const omitted = data.newContent.split("\n").length - lines.length;
+  const hint = omitted > 0 ? `\n...(${omitted} more lines)...` : "";
+
+  return `${header}\n${"─".repeat(header.length)}\n${lines.join("\n")}${hint}`;
+}

package/src/display/render-utils.ts

@@ -0,0 +1,52 @@
+/**
+ * Shared display rendering utilities
+ */
+
+export function splitLines(text: string): string[] {
+  return text.split(/\r?\n/);
+}
+
+export function countNonEmptyLines(text: string): number {
+  return splitLines(text).filter((l) => l.trim()).length;
+}
+
+export function compactOutputLines(text: string, maxLines: number): string {
+  const lines = splitLines(text);
+  if (lines.length <= maxLines) return text;
+  const omitted = lines.length - maxLines;
+  return `...(${omitted} lines omitted)...\n${lines.slice(-maxLines).join("\n")}`;
+}
+
+export function previewLines(text: string, lines: number): string {
+  const all = splitLines(text);
+  if (all.length <= lines) return text;
+  return all.slice(0, lines).join("\n") + `\n...(${all.length - lines} more lines)`;
+}
+
+export function pluralize(count: number, singular: string, plural?: string): string {
+  return count === 1 ? `${count} ${singular}` : `${count} ${plural ?? singular + "s"}`;
+}
+
+export function shortenPath(path: string, maxLen: number = 60): string {
+  if (path.length <= maxLen) return path;
+  const parts = path.split("/");
+  if (parts.length <= 2) return "..." + path.slice(-(maxLen - 3));
+  return parts[0] + "/.../" + parts.slice(-2).join("/");
+}
+
+export function extractTextOutput(result: any): string {
+  if (typeof result === "string") return result;
+  if (result?.output) return String(result.output);
+  if (result?.stdout) return String(result.stdout);
+  return "";
+}
+
+export function isLikelyQuietCommand(command: string): boolean {
+  const quietPatterns = [/^\s*cd\s/, /^\s*mkdir\s+-p/, /^\s*touch\s/, /^\s*rm\s+/];
+  return quietPatterns.some((re) => re.test(command));
+}
+
+export function sanitizeAnsiForThemedOutput(text: string): string {
+  // Strip ANSI escape sequences for clean themed rendering
+  return text.replace(/\x1b\[[0-9;]*m/g, "");
+}

package/src/display/thinking-label.ts

@@ -0,0 +1,18 @@
+/**
+ * Thinking labels during streaming
+ */
+
+export function formatThinkingLabel(text: string, opts?: { prefix?: string }): string {
+  const prefix = opts?.prefix ?? "🤔";
+  const lines = text.split("\n");
+  if (lines.length === 1) return `${prefix} ${lines[0]}`;
+  return `${prefix} Thinking...\n${text}`;
+}
+
+export function sanitizeThinkingArtifacts(text: string): string {
+  // Remove thinking blocks from context before LLM turn
+  return text
+    .replace(/<thinking>[\s\S]*?<\/thinking>/g, "")
+    .replace(/\[thinking\][\s\S]*?\[\/thinking\]/g, "")
+    .trim();
+}

package/src/display/tool-overrides.ts

@@ -0,0 +1,136 @@
+/**
+ * Tool override renderers — mode-aware output for built-in tools
+ */
+
+import type { OutputMode } from "../types.js";
+import { previewLines, countNonEmptyLines, shortenPath } from "./render-utils.js";
+
+export interface ToolOverrideConfig {
+  readOutputMode?: OutputMode;
+  searchOutputMode?: OutputMode;
+  bashOutputMode?: OutputMode;
+  previewLines?: number;
+  bashCollapsedLines?: number;
+  showTruncationHints?: boolean;
+}
+
+export function renderReadResult(
+  content: string,
+  filePath: string,
+  config: ToolOverrideConfig,
+): string {
+  switch (config.readOutputMode) {
+    case "hidden":
+      return `[Read: ${shortenPath(filePath)}]`;
+    case "summary":
+      return `[Read: ${shortenPath(filePath)} — ${countNonEmptyLines(content)} lines]`;
+    case "preview":
+      return previewLines(content, config.previewLines ?? 20);
+    default:
+      return content;
+  }
+}
+
+export function renderSearchResult(
+  results: string,
+  config: ToolOverrideConfig,
+): string {
+  switch (config.searchOutputMode) {
+    case "hidden":
+      return `[Search results hidden]`;
+    case "count":
+      return `[Search: ${countNonEmptyLines(results)} matches]`;
+    case "preview":
+      return previewLines(results, config.previewLines ?? 20);
+    default:
+      return results;
+  }
+}
+
+export function renderBashResult(
+  output: string,
+  command: string,
+  config: ToolOverrideConfig,
+): string {
+  switch (config.bashOutputMode) {
+    case "hidden":
+      return `[Bash: ${command.slice(0, 60)}]`;
+    case "summary":
+      return `[Bash: ${command.slice(0, 60)} — ${countNonEmptyLines(output)} lines]`;
+    case "preview":
+      return previewLines(output, config.bashCollapsedLines ?? 5);
+    default:
+      return output;
+  }
+}
+
+/**
+ * Apply display overrides for built-in tool results.
+ * Returns modified event result if override applies, undefined otherwise.
+ *
+ * Call this from the `tool_result` event handler to intercept and transform
+ * tool output before it enters the LLM context.
+ */
+export function applyToolDisplayOverride(
+  toolName: string,
+  event: Record<string, unknown>,
+  config: ToolOverrideConfig,
+): { content?: Array<{ type: string; text: string }> } | undefined {
+  const content = (event as any).content as Array<{ type: string; text: string }> | undefined;
+  if (!content || !Array.isArray(content) || content.length === 0) return undefined;
+
+  const textContent = content[0]?.text ?? "";
+  const previewLinesCount = config.previewLines ?? 20;
+  const collapsedLines = config.bashCollapsedLines ?? 5;
+
+  let overridden: string | undefined;
+
+  switch (toolName) {
+    case "read": {
+      const filePath = String((event as any).args?.path ?? "");
+      const mode = config.readOutputMode ?? "full";
+      if (mode === "hidden") {
+        overridden = `[Read: ${shortenPath(filePath)}]`;
+      } else if (mode === "summary") {
+        overridden = `[Read: ${shortenPath(filePath)} — ${countNonEmptyLines(textContent)} lines]`;
+      } else if (mode === "preview") {
+        overridden = previewLines(textContent, previewLinesCount);
+      }
+      break;
+    }
+    case "grep":
+    case "find":
+    case "ls": {
+      const mode = config.searchOutputMode ?? "full";
+      if (mode === "hidden") {
+        overridden = `[${toolName} results hidden]`;
+      } else if (mode === "count") {
+        overridden = `[${toolName}: ${countNonEmptyLines(textContent)} matches]`;
+      } else if (mode === "preview") {
+        overridden = previewLines(textContent, previewLinesCount);
+      }
+      break;
+    }
+    case "bash": {
+      const command = String((event as any).args?.command ?? "");
+      const mode = config.bashOutputMode ?? "full";
+      if (mode === "hidden") {
+        overridden = `[Bash: ${command.slice(0, 60)}]`;
+      } else if (mode === "summary") {
+        overridden = `[Bash: ${command.slice(0, 60)} — ${countNonEmptyLines(textContent)} lines]`;
+      } else if (mode === "preview") {
+        overridden = previewLines(textContent, collapsedLines);
+      }
+      break;
+    }
+    default:
+      return undefined;
+  }
+
+  if (overridden !== undefined) {
+    return {
+      content: [{ type: "text", text: overridden }],
+    };
+  }
+  return undefined;
+}

package/src/display/user-message-box.ts

@@ -0,0 +1,16 @@
+/**
+ * User message box — bordered display for user messages
+ */
+
+export function renderUserMessageBox(text: string, opts?: { maxWidth?: number }): string {
+  const maxWidth = opts?.maxWidth ?? 80;
+  const lines = text.split("\n");
+  const clamped = lines.map((l) => (l.length > maxWidth - 4 ? l.slice(0, maxWidth - 7) + "..." : l));
+  const width = Math.min(maxWidth, Math.max(...clamped.map((l) => l.length), 10) + 4);
+
+  const top = `╭${"─".repeat(width - 2)}╮`;
+  const bottom = `╰${"─".repeat(width - 2)}╯`;
+  const middle = clamped.map((l) => `│ ${l.padEnd(width - 4)} │`);
+
+  return [top, ...middle, bottom].join("\n");
+}