@pi-unipi/compactor 0.1.7 → 0.2.2

package/src/config/presets.ts

@@ -2,6 +2,7 @@
  * Preset definitions + detection for compactor config
  */
 
+import { createHash } from "node:crypto";
 import type { CompactorConfig, CompactorPreset } from "../types.js";
 import { DEFAULT_COMPACTOR_CONFIG } from "./schema.js";
 
@@ -22,15 +23,43 @@ const preset = (
   toolDisplay: { ...DEFAULT_COMPACTOR_CONFIG.toolDisplay, ...(overrides.toolDisplay as any) },
 });
 
+// Pipeline feature defaults per preset:
+// precise: ttlCache+mmap on, rest off
+// balanced: all on
+// thorough: all on
+// lean: all off
+
 export const PRESET_CONFIGS: Record<CompactorPreset, CompactorConfig> = {
-  opencode: preset({
+  // New preset names
+  precise: preset({
     toolDisplay: { ...DEFAULT_COMPACTOR_CONFIG.toolDisplay, mode: "opencode" },
   }),
+  thorough: preset({
+    briefTranscript: { ...DEFAULT_COMPACTOR_CONFIG.briefTranscript, mode: "full" },
+    toolDisplay: { ...DEFAULT_COMPACTOR_CONFIG.toolDisplay, mode: "verbose" },
+  }),
+  lean: preset({
+    sessionGoals: { ...DEFAULT_COMPACTOR_CONFIG.sessionGoals, enabled: true, mode: "brief" },
+    filesAndChanges: { ...DEFAULT_COMPACTOR_CONFIG.filesAndChanges, enabled: true, mode: "modified-only" },
+    commits: { ...DEFAULT_COMPACTOR_CONFIG.commits, enabled: false, mode: "off" },
+    outstandingContext: { ...DEFAULT_COMPACTOR_CONFIG.outstandingContext, enabled: true, mode: "critical-only" },
+    userPreferences: { ...DEFAULT_COMPACTOR_CONFIG.userPreferences, enabled: false, mode: "off" },
+    briefTranscript: { ...DEFAULT_COMPACTOR_CONFIG.briefTranscript, enabled: true, mode: "minimal" },
+    sessionContinuity: { ...DEFAULT_COMPACTOR_CONFIG.sessionContinuity, enabled: false, mode: "off" },
+    fts5Index: { ...DEFAULT_COMPACTOR_CONFIG.fts5Index, enabled: false, mode: "off" },
+    sandboxExecution: { ...DEFAULT_COMPACTOR_CONFIG.sandboxExecution, enabled: false, mode: "off" },
+    toolDisplay: { ...DEFAULT_COMPACTOR_CONFIG.toolDisplay, enabled: true, mode: "opencode" },
+  }),
   balanced: preset({
     briefTranscript: { ...DEFAULT_COMPACTOR_CONFIG.briefTranscript, mode: "compact" },
     toolDisplay: { ...DEFAULT_COMPACTOR_CONFIG.toolDisplay, mode: "balanced" },
     fts5Index: { ...DEFAULT_COMPACTOR_CONFIG.fts5Index, mode: "auto" },
   }),
+
+  // Backward-compat aliases — map old names to new
+  opencode: preset({
+    toolDisplay: { ...DEFAULT_COMPACTOR_CONFIG.toolDisplay, mode: "opencode" },
+  }),
   verbose: preset({
     briefTranscript: { ...DEFAULT_COMPACTOR_CONFIG.briefTranscript, mode: "full" },
     toolDisplay: { ...DEFAULT_COMPACTOR_CONFIG.toolDisplay, mode: "verbose" },
@@ -50,7 +79,24 @@ export const PRESET_CONFIGS: Record<CompactorPreset, CompactorConfig> = {
   custom: structuredClone(DEFAULT_COMPACTOR_CONFIG),
 };
 
+// Pre-computed identity hashes for fast preset detection
+const presetHashes = new Map<string, string>();
+
+function presetHash(config: CompactorConfig): string {
+  return createHash("sha256").update(JSON.stringify(config)).digest("hex");
+}
+
+// Compute hashes once at module load
+for (const name of ["precise", "balanced", "thorough", "lean"] as const) {
+  presetHashes.set(name, presetHash(PRESET_CONFIGS[name]));
+}
+
 function configsEqual(a: CompactorConfig, b: CompactorConfig): boolean {
+  // Fast path: hash comparison
+  const aHash = presetHash(a);
+  const bHash = presetHash(b);
+  if (aHash !== bHash) return false;
+  // Defensive: confirm with full comparison
   return JSON.stringify(a) === JSON.stringify(b);
 }
 
@@ -58,8 +104,11 @@ function configsEqual(a: CompactorConfig, b: CompactorConfig): boolean {
  * Detect which preset a config matches, or "custom".
  */
 export function detectPreset(config: CompactorConfig): CompactorPreset {
-  for (const name of ["opencode", "balanced", "verbose", "minimal"] as const) {
-    if (configsEqual(config, PRESET_CONFIGS[name])) return name;
+  const configHash = presetHash(config);
+  for (const name of ["precise", "balanced", "thorough", "lean"] as const) {
+    if (presetHashes.get(name) === configHash && configsEqual(config, PRESET_CONFIGS[name])) {
+      return name;
+    }
   }
   return "custom";
 }
@@ -71,13 +120,28 @@ export function applyPreset(name: CompactorPreset): CompactorConfig {
   return structuredClone(PRESET_CONFIGS[name]);
 }
 
+// Old → new preset name mapping for backward compatibility
+const OLD_TO_NEW: Record<string, CompactorPreset> = {
+  opencode: "precise",
+  verbose: "thorough",
+  minimal: "lean",
+};
+
 /**
- * Parse a preset name (case-insensitive).
+ * Parse a preset name (case-insensitive). Old names are mapped to new with deprecation.
  */
 export function parsePreset(raw: string): CompactorPreset | undefined {
   const normalized = raw.trim().toLowerCase();
-  if (normalized === "opencode" || normalized === "balanced" || normalized === "verbose" || normalized === "minimal" || normalized === "custom") {
+
+  // Check new names first
+  if (normalized === "precise" || normalized === "balanced" || normalized === "thorough" || normalized === "lean" || normalized === "custom") {
     return normalized;
   }
+
+  // Map old names to new (backward compat)
+  if (OLD_TO_NEW[normalized]) {
+    return OLD_TO_NEW[normalized];
+  }
+
   return undefined;
 }

package/src/config/schema.ts

@@ -49,7 +49,16 @@ export const DEFAULT_COMPACTOR_CONFIG: CompactorConfig = {
     showBashSpinner: true,
     showPendingPreviews: true,
   },
-  overrideDefaultCompaction: false,
+  pipeline: {
+    ttlCache: false,
+    autoInjection: false,
+    proximityReranking: false,
+    timelineSort: false,
+    progressiveThrottling: false,
+    mmapPragma: false,
+    customNoisePatterns: [],
+  },
+  overrideDefaultCompaction: true,
   debug: false,
   showTruncationHints: true,
 };

package/src/display/diff-presentation.ts

@@ -3,6 +3,7 @@
  */
 
 import type { DiffLayout } from "../types.js";
+import { visibleWidth, truncateToWidth } from "@mariozechner/pi-tui";
 
 export function selectDiffLayout(
   terminalWidth: number,
@@ -12,9 +13,13 @@ export function selectDiffLayout(
   return terminalWidth >= 100 ? "split" : "unified";
 }
 
+/** Clamp text to maxWidth visible columns, ANSI-aware */
 export function clampWidth(text: string, maxWidth: number): string {
   return text
     .split("\n")
-    .map((line) => (line.length > maxWidth ? line.slice(0, maxWidth - 3) + "..." : line))
+    .map((line) => {
+      if (visibleWidth(line) <= maxWidth) return line;
+      return truncateToWidth(line, maxWidth, "…");
+    })
     .join("\n");
 }

package/src/display/diff-renderer.ts

@@ -3,6 +3,8 @@
  * syntax highlighting, and Nerd Font detection
  */
 
+import { visibleWidth, truncateToWidth } from "@mariozechner/pi-tui";
+
 export type DiffLayout = "auto" | "split" | "unified";
 export type DiffIndicator = "bars" | "classic" | "nerd" | "none";
 
@@ -150,16 +152,28 @@ function indicatorChar(type: DiffLine["type"], style: DiffIndicator): string {
   return type === "add" ? "+ " : type === "remove" ? "- " : "  ";
 }
 
-function renderUnified(diff: DiffLine[], indicator: DiffIndicator): string {
+function renderUnified(
+  diff: DiffLine[],
+  indicator: DiffIndicator,
+  maxWidth?: number,
+): string {
   return diff.map((line) => {
     const prefix = indicator === "bars"
       ? (line.type === "add" ? "│ " : line.type === "remove" ? "│ " : "  ")
       : indicatorChar(line.type, indicator);
-    return prefix + line.text;
+    const rendered = prefix + line.text;
+    if (maxWidth && visibleWidth(rendered) > maxWidth) {
+      return truncateToWidth(rendered, maxWidth, "…");
+    }
+    return rendered;
   }).join("\n");
 }
 
-function renderSplit(diff: DiffLine[], indicator: DiffIndicator): string {
+function renderSplit(
+  diff: DiffLine[],
+  indicator: DiffIndicator,
+  maxW?: number,
+): string {
   const left: string[] = [];
   const right: string[] = [];
 
@@ -176,12 +190,24 @@ function renderSplit(diff: DiffLine[], indicator: DiffIndicator): string {
     }
   }
 
-  const maxWidth = Math.max(...left.map((l) => l.length), 40);
+  const halfW = maxW ? Math.floor(maxW / 2) - 2 : 40;
+  const colW = Math.max(
+    ...left.map((l) => visibleWidth(l)),
+    ...right.map((l) => visibleWidth(l)),
+    Math.min(halfW, 40),
+  );
   const result: string[] = [];
   for (let i = 0; i < left.length; i++) {
-    const l = left[i].padEnd(maxWidth);
+    const lTrunc = visibleWidth(left[i]) > colW
+      ? truncateToWidth(left[i], colW, "…")
+      : left[i].padEnd(colW);
     const sep = left[i] && right[i] ? " │ " : "   ";
-    result.push(l + sep + right[i]);
+    let rLine = right[i];
+    if (maxW && visibleWidth(lTrunc + sep + rLine) > maxW) {
+      const rBudget = maxW - visibleWidth(lTrunc + sep);
+      rLine = truncateToWidth(rLine, Math.max(1, rBudget), "…");
+    }
+    result.push(lTrunc + sep + rLine);
   }
 
   return result.join("\n");
@@ -229,10 +255,10 @@ export function renderDiff(
   }
 
   if (effectiveLayout === "split") {
-    return renderSplit(highlightedDiff, effectiveIndicator);
+    return renderSplit(highlightedDiff, effectiveIndicator, maxWidth);
   }
 
-  return renderUnified(highlightedDiff, effectiveIndicator);
+  return renderUnified(highlightedDiff, effectiveIndicator, maxWidth);
 }
 
 export function renderEditDiffResult(

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

@@ -0,0 +1,83 @@
+/**
+ * Diff width safety — truncate diff lines to terminal width
+ *
+ * Pi's renderDiff() in diff.js produces lines without width
+ * truncation. When a diff line's visible content exceeds the
+ * terminal width, the TUI crashes with:
+ *   "Rendered line N exceeds terminal width (X > Y)"
+ *
+ * This module provides clampDiffToWidth() which truncates
+ * each diff line to a safe width, preventing TUI crashes.
+ *
+ * The diff format from pi's generateDiffString() is:
+ *   [+/-/ ]LINE_NUM CONTENT
+ * e.g.: "+       38 │ The root cause is a **compound failure**..."
+ *
+ * We detect the terminal width from process.stdout and clamp
+ * each line, accounting for the rendering overhead of the
+ * edit tool's Box nesting (approx 4-6 chars of padding).
+ */
+
+import { visibleWidth, truncateToWidth } from "@mariozechner/pi-tui";
+
+/** Rendering overhead from Box nesting in edit tool components */
+const RENDER_OVERHEAD = 6;
+
+/** Minimum useful line width (don't clamp below this) */
+const MIN_LINE_WIDTH = 20;
+
+/**
+ * Get the terminal width with fallback.
+ * Uses process.stdout.columns (updated on resize).
+ */
+function getTerminalWidth(): number {
+  return process.stdout?.columns ?? 80;
+}
+
+/**
+ * Clamp a diff string so every line fits within terminal width.
+ * Preserves the diff prefix (+/-/ ) and line number while
+ * truncating the content portion.
+ *
+ * @param diff - The diff string from generateDiffString()
+ * @param maxWidth - Override for terminal width (for testing)
+ * @returns The clamped diff string (may be same reference if no clamping needed)
+ */
+export function clampDiffToWidth(
+  diff: string,
+  maxWidth?: number,
+): string {
+  const termW = maxWidth ?? getTerminalWidth();
+  const safeW = Math.max(MIN_LINE_WIDTH, termW - RENDER_OVERHEAD);
+
+  const lines = diff.split("\n");
+  let changed = false;
+
+  const result = lines.map((line) => {
+    const vw = visibleWidth(line);
+    if (vw <= safeW) return line;
+
+    changed = true;
+
+    // Try to preserve the diff prefix (+/-/ ) and line number
+    // Format: [+/-/ ]LINE_NUM CONTENT
+    // The prefix and line number are critical for readability
+    const prefixMatch = line.match(/^([+\- ])\s*(\d*)\s/);
+    if (prefixMatch) {
+      const prefixLen = prefixMatch[0].length;
+      // Calculate how much content we can keep
+      const contentBudget = safeW - prefixLen;
+      if (contentBudget >= MIN_LINE_WIDTH) {
+        const prefix = line.slice(0, prefixLen);
+        const content = line.slice(prefixLen);
+        const truncated = truncateToWidth(content, contentBudget, "…");
+        return prefix + truncated;
+      }
+    }
+
+    // Fallback: truncate the entire line
+    return truncateToWidth(line, safeW, "…");
+  });
+
+  return changed ? result.join("\n") : diff;
+}

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

@@ -1,11 +1,23 @@
 /**
  * Line width safety — width clamping with collapsed hints
+ *
+ * Uses ANSI-aware visibleWidth measurement from pi-tui to properly
+ * handle lines containing escape codes. Falls back to raw-length
+ * measurement when pi-tui is unavailable.
  */
 
+import { visibleWidth, truncateToWidth } from "@mariozechner/pi-tui";
+
+/**
+ * Clamp each line to maxWidth visible columns.
+ * Uses pi-tui's visibleWidth() for ANSI-aware measurement and
+ * truncateToWidth() for ANSI-safe truncation.
+ */
 export function clampLineWidth(lines: string[], maxWidth: number): string[] {
   return lines.map((line) => {
-    if (line.length <= maxWidth) return line;
-    return line.slice(0, maxWidth - 3) + "...";
+    const vw = visibleWidth(line);
+    if (vw <= maxWidth) return line;
+    return truncateToWidth(line, maxWidth, "…");
   });
 }