@pi-unipi/compactor 0.1.1

package/src/compaction/normalize.ts

@@ -0,0 +1,68 @@
+/**
+ * Stage 1: Normalize — Message[] → NormalizedBlock[]
+ */
+
+import type { Message } from "@mariozechner/pi-ai";
+import type { NormalizedBlock } from "../types.js";
+import { textOf } from "./content.js";
+import { sanitize } from "./sanitize.js";
+
+const normalizeOne = (msg: Message, msgIndex: number): NormalizedBlock[] => {
+  if (msg.role === "user") {
+    const blocks: NormalizedBlock[] = [];
+    const text = sanitize(textOf(msg.content));
+    if (text) blocks.push({ kind: "user", text, sourceIndex: msgIndex });
+    if (msg.content && typeof msg.content !== "string") {
+      for (const part of msg.content) {
+        if (part.type === "image") {
+          blocks.push({ kind: "user", text: `[image: ${part.mimeType}]`, sourceIndex: msgIndex });
+        }
+      }
+    }
+    return blocks.length > 0 ? blocks : [{ kind: "user", text: "", sourceIndex: msgIndex }];
+  }
+
+  if (msg.role === "toolResult") {
+    return [{
+      kind: "tool_result",
+      name: msg.toolName,
+      text: sanitize(textOf(msg.content)),
+      isError: msg.isError,
+      sourceIndex: msgIndex,
+    }];
+  }
+
+  if (msg.role === "assistant") {
+    if (!msg.content) return [];
+    if (typeof msg.content === "string") {
+      return [{ kind: "assistant", text: sanitize(msg.content), sourceIndex: msgIndex }];
+    }
+
+    const blocks: NormalizedBlock[] = [];
+    for (const part of msg.content) {
+      if (part.type === "text") {
+        blocks.push({ kind: "assistant", text: sanitize(part.text), sourceIndex: msgIndex });
+      } else if (part.type === "thinking") {
+        blocks.push({
+          kind: "thinking",
+          text: sanitize(part.thinking),
+          redacted: part.redacted ?? false,
+          sourceIndex: msgIndex,
+        });
+      } else if (part.type === "toolCall") {
+        blocks.push({
+          kind: "tool_call",
+          name: part.name,
+          args: part.arguments,
+          sourceIndex: msgIndex,
+        });
+      }
+    }
+    return blocks;
+  }
+
+  return [];
+};
+
+export const normalizeMessages = (messages: Message[]): NormalizedBlock[] =>
+  messages.flatMap((msg, i) => normalizeOne(msg, i));

package/src/compaction/recall-scope.ts

@@ -0,0 +1,32 @@
+/**
+ * Recall scope — lineage filtering for vcc_recall
+ */
+
+export interface LineageRange {
+  startIndex: number;
+  endIndex: number;
+}
+
+/**
+ * Determine the valid message index range for recall based on
+ * the most recent compaction boundary.
+ */
+export function getRecallScope(
+  branchEntries: any[],
+  opts?: { expand?: boolean },
+): LineageRange {
+  let lastCompactionIdx = -1;
+  for (let i = branchEntries.length - 1; i >= 0; i--) {
+    if (branchEntries[i].type === "compaction") {
+      lastCompactionIdx = i;
+      break;
+    }
+  }
+
+  // If expand is true, include everything; otherwise only post-compaction
+  const startIndex = opts?.expand ? 0 : lastCompactionIdx + 1;
+  return {
+    startIndex: Math.max(0, startIndex),
+    endIndex: branchEntries.length,
+  };
+}

package/src/compaction/sanitize.ts

@@ -0,0 +1,12 @@
+/**
+ * Sanitize message text — strip control chars, normalize whitespace
+ */
+
+export function sanitize(text: string): string {
+  if (!text) return "";
+  return text
+    .replace(/[\x00-\x08\x0b-\x0c\x0e-\x1f]/g, "")
+    .replace(/\r\n/g, "\n")
+    .replace(/\s+/g, " ")
+    .trim();
+}

package/src/compaction/search-entries.ts

@@ -0,0 +1,101 @@
+/**
+ * BM25-lite search over normalized message blocks
+ */
+
+import type { NormalizedBlock } from "../types.js";
+
+interface SearchDoc {
+  id: number;
+  text: string;
+  kind: string;
+}
+
+function tokenize(text: string): string[] {
+  return text
+    .toLowerCase()
+    .replace(/[^\p{L}\p{N}\s]/gu, " ")
+    .split(/\s+/)
+    .filter((w) => w.length > 1);
+}
+
+function buildIndex(docs: SearchDoc[]): Map<string, number[]> {
+  const index = new Map<string, number[]>();
+  for (const doc of docs) {
+    const tokens = new Set(tokenize(doc.text));
+    for (const t of tokens) {
+      const arr = index.get(t) ?? [];
+      arr.push(doc.id);
+      index.set(t, arr);
+    }
+  }
+  return index;
+}
+
+function bm25Score(
+  queryTokens: string[],
+  docId: number,
+  index: Map<string, number[]>,
+  docCount: number,
+  avgDocLen: number,
+  docLens: Map<number, number>,
+): number {
+  const k1 = 1.5;
+  const b = 0.75;
+  let score = 0;
+  const docLen = docLens.get(docId) ?? 1;
+
+  for (const token of queryTokens) {
+    const postings = index.get(token) ?? [];
+    const df = new Set(postings).size;
+    if (df === 0) continue;
+    const tf = postings.filter((id) => id === docId).length;
+    const idf = Math.log((docCount - df + 0.5) / (df + 0.5) + 1);
+    score += idf * ((tf * (k1 + 1)) / (tf + k1 * (1 - b + b * (docLen / avgDocLen))));
+  }
+
+  return score;
+}
+
+export interface SearchHit {
+  docId: number;
+  score: number;
+  text: string;
+  kind: string;
+}
+
+export function searchEntries(
+  blocks: NormalizedBlock[],
+  query: string,
+  opts?: { limit?: number; offset?: number },
+): SearchHit[] {
+  const docs: SearchDoc[] = blocks.map((b, i) => ({
+    id: i,
+    text: b.kind === "tool_call" ? `${b.name} ${JSON.stringify(b.args)}` : b.kind === "tool_result" ? `${b.name} ${b.text}` : b.text,
+    kind: b.kind,
+  }));
+
+  const index = buildIndex(docs);
+  const docCount = docs.length;
+  const docLens = new Map(docs.map((d) => [d.id, tokenize(d.text).length]));
+  const avgDocLen = docCount > 0 ? [...docLens.values()].reduce((a, b) => a + b, 0) / docCount : 1;
+
+  const queryTokens = tokenize(query);
+  if (queryTokens.length === 0) return [];
+
+  const scores = new Map<number, number>();
+  for (const doc of docs) {
+    const score = bm25Score(queryTokens, doc.id, index, docCount, avgDocLen, docLens);
+    if (score > 0) scores.set(doc.id, score);
+  }
+
+  const sorted = [...scores.entries()]
+    .sort((a, b) => b[1] - a[1])
+    .map(([docId, score]) => {
+      const doc = docs[docId];
+      return { docId, score, text: doc.text.slice(0, 300), kind: doc.kind };
+    });
+
+  const offset = opts?.offset ?? 0;
+  const limit = opts?.limit ?? 10;
+  return sorted.slice(offset, offset + limit);
+}

package/src/compaction/sections.ts

@@ -0,0 +1,15 @@
+/**
+ * Section data type for compaction pipeline
+ */
+
+import type { TranscriptEntry } from "../types.js";
+
+export interface SectionData {
+  sessionGoal: string[];
+  filesAndChanges: string[];
+  commits: string[];
+  outstandingContext: string[];
+  userPreferences: string[];
+  briefTranscript: string;
+  transcriptEntries: TranscriptEntry[];
+}

package/src/compaction/summarize.ts

@@ -0,0 +1,29 @@
+/**
+ * Main compile() orchestrator — all 6 stages
+ */
+
+import type { Message } from "@mariozechner/pi-ai";
+import type { CompileInput, FileOps } from "../types.js";
+import { normalizeMessages } from "./normalize.js";
+import { filterNoise } from "./filter-noise.js";
+import { buildSections } from "./build-sections.js";
+import { formatSummary, RECALL_NOTE } from "./format.js";
+import { mergePrevious } from "./merge.js";
+
+export const compile = (input: CompileInput): string => {
+  const blocks = filterNoise(normalizeMessages(input.messages));
+  const data = buildSections({ blocks });
+  const fresh = formatSummary(data);
+  const prev = input.previousSummary
+    ? stripRecallNote(input.previousSummary)
+    : undefined;
+  const merged = prev ? mergePrevious(prev, fresh) : fresh;
+  if (!merged) return "";
+  return merged + "\n\n---\n\n" + RECALL_NOTE;
+};
+
+const stripRecallNote = (text: string): string => {
+  const idx = text.lastIndexOf(RECALL_NOTE);
+  if (idx < 0) return text;
+  return text.slice(0, idx).replace(/\s*(?:\n\n---\n\n)?\s*$/, "").trimEnd();
+};

package/src/config/manager.ts

@@ -0,0 +1,89 @@
+/**
+ * Config manager — load, save, migrate compactor settings
+ */
+
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import type { CompactorConfig } from "../types.js";
+import { DEFAULT_COMPACTOR_CONFIG } from "./schema.js";
+
+export const COMPACTOR_CONFIG_PATH = join(homedir(), ".unipi", "config", "compactor", "config.json");
+
+const readJson = (path: string): Record<string, unknown> | null => {
+  try {
+    return JSON.parse(readFileSync(path, "utf-8"));
+  } catch {
+    return null;
+  }
+};
+
+/**
+ * Load compactor config from disk with defaults fallback.
+ */
+export function loadConfig(): CompactorConfig {
+  const parsed = readJson(COMPACTOR_CONFIG_PATH);
+  if (!parsed || typeof parsed !== "object") return structuredClone(DEFAULT_COMPACTOR_CONFIG);
+  return migrateConfig(parsed as Partial<CompactorConfig>);
+}
+
+/**
+ * Save config to disk with schema validation.
+ */
+export function saveConfig(config: CompactorConfig): { success: boolean; error?: string } {
+  try {
+    const dir = dirname(COMPACTOR_CONFIG_PATH);
+    if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+    writeFileSync(COMPACTOR_CONFIG_PATH, `${JSON.stringify(config, null, 2)}\n`);
+    return { success: true };
+  } catch (err) {
+    return { success: false, error: String(err) };
+  }
+}
+
+/**
+ * Migrate partial config to full schema, filling missing keys from defaults.
+ */
+export function migrateConfig(partial: Partial<CompactorConfig>): CompactorConfig {
+  const defaults = structuredClone(DEFAULT_COMPACTOR_CONFIG);
+
+  function mergeStrategy<K extends keyof CompactorConfig>(
+    key: K,
+    defaultVal: CompactorConfig[K],
+    partialVal: CompactorConfig[K] | undefined,
+  ): CompactorConfig[K] {
+    if (!partialVal || typeof partialVal !== "object") return defaultVal;
+    return { ...(defaultVal as any), ...(partialVal as any) };
+  }
+
+  return {
+    sessionGoals: mergeStrategy("sessionGoals", defaults.sessionGoals, partial.sessionGoals),
+    filesAndChanges: mergeStrategy("filesAndChanges", defaults.filesAndChanges, partial.filesAndChanges),
+    commits: mergeStrategy("commits", defaults.commits, partial.commits),
+    outstandingContext: mergeStrategy("outstandingContext", defaults.outstandingContext, partial.outstandingContext),
+    userPreferences: mergeStrategy("userPreferences", defaults.userPreferences, partial.userPreferences),
+    briefTranscript: mergeStrategy("briefTranscript", defaults.briefTranscript, partial.briefTranscript),
+    sessionContinuity: mergeStrategy("sessionContinuity", defaults.sessionContinuity, partial.sessionContinuity),
+    fts5Index: mergeStrategy("fts5Index", defaults.fts5Index, partial.fts5Index),
+    sandboxExecution: mergeStrategy("sandboxExecution", defaults.sandboxExecution, partial.sandboxExecution),
+    toolDisplay: mergeStrategy("toolDisplay", defaults.toolDisplay, partial.toolDisplay),
+    overrideDefaultCompaction: partial.overrideDefaultCompaction ?? defaults.overrideDefaultCompaction,
+    debug: partial.debug ?? defaults.debug,
+    showTruncationHints: partial.showTruncationHints ?? defaults.showTruncationHints,
+  };
+}
+
+/**
+ * Scaffold config file on first run.
+ */
+export function scaffoldConfig(): void {
+  try {
+    const dir = dirname(COMPACTOR_CONFIG_PATH);
+    if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+    if (!existsSync(COMPACTOR_CONFIG_PATH)) {
+      writeFileSync(COMPACTOR_CONFIG_PATH, `${JSON.stringify(DEFAULT_COMPACTOR_CONFIG, null, 2)}\n`);
+    }
+  } catch {
+    // best-effort
+  }
+}

package/src/config/presets.ts

@@ -0,0 +1,83 @@
+/**
+ * Preset definitions + detection for compactor config
+ */
+
+import type { CompactorConfig, CompactorPreset } from "../types.js";
+import { DEFAULT_COMPACTOR_CONFIG } from "./schema.js";
+
+const preset = (
+  overrides: Partial<CompactorConfig>,
+): CompactorConfig => ({
+  ...structuredClone(DEFAULT_COMPACTOR_CONFIG),
+  ...overrides,
+  sessionGoals: { ...DEFAULT_COMPACTOR_CONFIG.sessionGoals, ...(overrides.sessionGoals as any) },
+  filesAndChanges: { ...DEFAULT_COMPACTOR_CONFIG.filesAndChanges, ...(overrides.filesAndChanges as any) },
+  commits: { ...DEFAULT_COMPACTOR_CONFIG.commits, ...(overrides.commits as any) },
+  outstandingContext: { ...DEFAULT_COMPACTOR_CONFIG.outstandingContext, ...(overrides.outstandingContext as any) },
+  userPreferences: { ...DEFAULT_COMPACTOR_CONFIG.userPreferences, ...(overrides.userPreferences as any) },
+  briefTranscript: { ...DEFAULT_COMPACTOR_CONFIG.briefTranscript, ...(overrides.briefTranscript as any) },
+  sessionContinuity: { ...DEFAULT_COMPACTOR_CONFIG.sessionContinuity, ...(overrides.sessionContinuity as any) },
+  fts5Index: { ...DEFAULT_COMPACTOR_CONFIG.fts5Index, ...(overrides.fts5Index as any) },
+  sandboxExecution: { ...DEFAULT_COMPACTOR_CONFIG.sandboxExecution, ...(overrides.sandboxExecution as any) },
+  toolDisplay: { ...DEFAULT_COMPACTOR_CONFIG.toolDisplay, ...(overrides.toolDisplay as any) },
+});
+
+export const PRESET_CONFIGS: Record<CompactorPreset, CompactorConfig> = {
+  opencode: preset({
+    toolDisplay: { ...DEFAULT_COMPACTOR_CONFIG.toolDisplay, 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" },
+  }),
+  verbose: preset({
+    briefTranscript: { ...DEFAULT_COMPACTOR_CONFIG.briefTranscript, mode: "full" },
+    toolDisplay: { ...DEFAULT_COMPACTOR_CONFIG.toolDisplay, mode: "verbose" },
+  }),
+  minimal: 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" },
+  }),
+  custom: structuredClone(DEFAULT_COMPACTOR_CONFIG),
+};
+
+function configsEqual(a: CompactorConfig, b: CompactorConfig): boolean {
+  return JSON.stringify(a) === JSON.stringify(b);
+}
+
+/**
+ * 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;
+  }
+  return "custom";
+}
+
+/**
+ * Apply a preset to a config.
+ */
+export function applyPreset(name: CompactorPreset): CompactorConfig {
+  return structuredClone(PRESET_CONFIGS[name]);
+}
+
+/**
+ * Parse a preset name (case-insensitive).
+ */
+export function parsePreset(raw: string): CompactorPreset | undefined {
+  const normalized = raw.trim().toLowerCase();
+  if (normalized === "opencode" || normalized === "balanced" || normalized === "verbose" || normalized === "minimal" || normalized === "custom") {
+    return normalized;
+  }
+  return undefined;
+}

package/src/config/schema.ts

@@ -0,0 +1,55 @@
+/**
+ * Compactor configuration schema with defaults
+ */
+
+import type { CompactorConfig, CompactorStrategyConfig } from "../types.js";
+
+const strategy = (enabled: boolean, mode: string): CompactorStrategyConfig => ({
+  enabled,
+  mode,
+});
+
+export const DEFAULT_COMPACTOR_CONFIG: CompactorConfig = {
+  sessionGoals: { ...strategy(true, "full"), mode: "full" },
+  filesAndChanges: { ...strategy(true, "all"), mode: "all", maxPerCategory: 10 },
+  commits: { ...strategy(true, "full"), mode: "full", maxCommits: 8 },
+  outstandingContext: { ...strategy(true, "full"), mode: "full", maxItems: 5 },
+  userPreferences: { ...strategy(true, "all"), mode: "all", maxPreferences: 10 },
+  briefTranscript: {
+    ...strategy(true, "full"),
+    mode: "full",
+    userTokenLimit: 256,
+    assistantTokenLimit: 200,
+    toolCallLimit: 8,
+  },
+  sessionContinuity: {
+    ...strategy(true, "full"),
+    mode: "full",
+    eventCategories: [],
+  },
+  fts5Index: {
+    ...strategy(true, "manual"),
+    mode: "manual",
+    chunkSize: 4096,
+    cacheTtlHours: 24,
+  },
+  sandboxExecution: {
+    ...strategy(true, "all"),
+    mode: "all",
+    allowedLanguages: ["javascript", "typescript", "python", "shell"],
+    outputLimit: 100 * 1024 * 1024,
+  },
+  toolDisplay: {
+    ...strategy(true, "opencode"),
+    mode: "opencode",
+    diffLayout: "auto",
+    diffIndicator: "bars",
+    showThinkingLabels: true,
+    showUserMessageBox: true,
+    showBashSpinner: true,
+    showPendingPreviews: true,
+  },
+  overrideDefaultCompaction: false,
+  debug: false,
+  showTruncationHints: true,
+};

package/src/display/bash-display.ts

@@ -0,0 +1,28 @@
+/**
+ * Bash display — spinner + elapsed time
+ */
+
+const SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+
+export function getSpinnerFrame(index: number): string {
+  return SPINNER_FRAMES[index % SPINNER_FRAMES.length];
+}
+
+export function formatElapsedTime(ms: number): string {
+  if (ms < 1000) return `${ms}ms`;
+  if (ms < 60000) return `${(ms / 1000).toFixed(1)}s`;
+  const mins = Math.floor(ms / 60000);
+  const secs = ((ms % 60000) / 1000).toFixed(0);
+  return `${mins}m${secs}s`;
+}
+
+export function renderBashCall(command: string, opts?: { collapsed?: boolean }): string {
+  if (opts?.collapsed) {
+    const firstLine = command.split("\n")[0]?.trim() ?? command;
+    if (firstLine.length > 80) {
+      return firstLine.slice(0, 77) + "...";
+    }
+    return firstLine;
+  }
+  return command;
+}

package/src/display/diff-presentation.ts

@@ -0,0 +1,20 @@
+/**
+ * Diff presentation — layout selection based on terminal width
+ */
+
+import type { DiffLayout } from "../types.js";
+
+export function selectDiffLayout(
+  terminalWidth: number,
+  preferred: DiffLayout = "auto",
+): "split" | "unified" {
+  if (preferred !== "auto") return preferred;
+  return terminalWidth >= 100 ? "split" : "unified";
+}
+
+export function clampWidth(text: string, maxWidth: number): string {
+  return text
+    .split("\n")
+    .map((line) => (line.length > maxWidth ? line.slice(0, maxWidth - 3) + "..." : line))
+    .join("\n");
+}