@pi-unipi/unipi 3.0.0-alpha.2 → 3.0.0-alpha.21

package/packages/compactor/src/card.ts

@@ -0,0 +1,90 @@
+/**
+ * The compaction card — one line in the transcript after each compaction,
+ * details on ctrl+o. A custom entry: rendered, never sent to the model.
+ *
+ * Pi draws its own `[compaction] Compacted from N tokens` block (expands to
+ * the summary); this card adds what Pi does not say: the size after, the
+ * method, what triggered it, and what was kept.
+ */
+
+import { truncateToWidth, type Component } from "@earendil-works/pi-tui";
+import { formatTokens, rail, type KitTheme } from "@pi-unipi/core";
+import type { CompactionMethod } from "./types.js";
+
+export const CARD_TYPE = "unipi-compaction";
+
+export type CompactionTrigger = "manual" | "threshold" | "overflow" | "percent";
+
+export interface CompactionCardData {
+  method: CompactionMethod;
+  trigger: CompactionTrigger;
+  /** The command that ran it (manual only), e.g. "unipi:compact-vcc". */
+  command?: string;
+  tokensBefore: number;
+  tokensAfter?: number;
+  summaryTokens?: number;
+  keptTurns?: number;
+  totalTurns?: number;
+  keptTokens?: number;
+  sections?: string[];
+  percent?: number;
+  threshold?: number;
+}
+
+const METHOD_NAME: Record<CompactionMethod, string> = {
+  vcc: "lossless",
+  llm: "model summary",
+};
+
+const COLOR = "customMessageLabel";
+
+function triggerShort(d: CompactionCardData): string {
+  if (d.trigger === "percent") return d.percent != null ? `at ${Math.round(d.percent)}%` : "at threshold";
+  if (d.trigger === "threshold") return "context limit";
+  if (d.trigger === "overflow") return "overflow";
+  return d.command ? `/${d.command}` : "manual";
+}
+
+function triggerLong(d: CompactionCardData): string {
+  if (d.trigger === "percent") return `${d.percent != null ? `${Math.round(d.percent)}%` : "threshold"} of context${d.threshold != null ? ` (setting: ${d.threshold}%)` : ""}`;
+  if (d.trigger === "threshold") return "Pi's context limit";
+  if (d.trigger === "overflow") return "context overflow — the request did not fit";
+  return d.command ? `/${d.command}` : "manual /compact";
+}
+
+/** The collapsed line: sizes, method, notable outcome, trigger. */
+export function cardHeadline(d: CompactionCardData): string {
+  const size = d.tokensAfter != null ? `${formatTokens(d.tokensBefore)} → ${formatTokens(d.tokensAfter)}` : `from ${formatTokens(d.tokensBefore)}`;
+  const parts = [`Compacted ${size} tokens`, METHOD_NAME[d.method]];
+  parts.push(triggerShort(d));
+  return parts.join(" · ");
+}
+
+/** Label/value rows for the expanded card. */
+export function cardDetails(d: CompactionCardData): Array<[string, string]> {
+  const rows: Array<[string, string]> = [
+    ["Method", METHOD_NAME[d.method]],
+    ["Trigger", triggerLong(d)],
+  ];
+  if (d.keptTurns != null && d.totalTurns != null) {
+    rows.push(["Kept", `last ${d.keptTurns} of ${d.totalTurns} turns${d.keptTokens != null ? ` · ~${formatTokens(d.keptTokens)} tokens verbatim` : ""}`]);
+  }
+  if (d.summaryTokens != null) {
+    rows.push(["Summary", `~${formatTokens(d.summaryTokens)} tokens${d.sections?.length ? ` · ${d.sections.join(", ")}` : ""}`]);
+  }
+  rows.push(["Recall", "everything before stays searchable: /unipi:session-recall"]);
+  return rows;
+}
+
+export function renderCompactionCard(d: CompactionCardData, expanded: boolean, theme: KitTheme): Component {
+  const lines = (width: number): string[] => {
+    const out = [rail(theme, COLOR, cardHeadline(d), expanded ? "" : theme.fg("dim", "ctrl+o"), width)];
+    if (expanded) {
+      for (const [label, value] of cardDetails(d)) {
+        out.push(rail(theme, COLOR, `${theme.fg("dim", label.padEnd(8))} ${theme.fg("muted", value)}`, "", width));
+      }
+    }
+    return out.map((l) => truncateToWidth(l, width));
+  };
+  return { invalidate() {}, render: lines };
+}

package/packages/compactor/src/commands/index.ts

@@ -1,182 +1,125 @@
 /**
- * All /unipi:compact-* commands
+ * Compactor commands
  *
- * Commands perform real work by calling tool implementations directly.
- * Dependencies (sessionDB, sessionId) are injected at registration time.
+ *   /unipi:compact-vcc [keep:N]      lossless zero-LLM compaction
+ *   /unipi:compact-by-llm [focus]    model-written summary (Pi's summarizer)
+ *   /unipi:session-recall <query>    search the full session history
+ *   /unipi:compact-stats | -doctor | -help
  */
 
 import type { ExtensionAPI, ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
-import { loadConfig, saveConfig } from "../config/manager.js";
-import { applyPreset } from "../config/presets.js";
-import { COMPACTOR_INSTRUCTION, formatTokens, registerCommandRunner } from "@pi-unipi/core";
-import { getLastCompactionStats, formatCompactionStats } from "../compaction/hooks.js";
+import { COMPACTOR_INSTRUCTION, formatTokens, harnessMetadata } from "@pi-unipi/core";
+import { loadConfig } from "../config/manager.js";
+import { setPendingCompaction } from "../compaction/hooks.js";
 import { vccRecall } from "../tools/vcc-recall.js";
-import { ctxStats } from "../tools/ctx-stats.js";
 import { ctxDoctor } from "../tools/ctx-doctor.js";
 import { recallBlocksFromContext } from "../session/recall-blocks.js";
 import { filterNoise } from "../compaction/filter-noise.js";
 import { parseRecallScope } from "../compaction/recall-scope.js";
-import type { SessionDB } from "../session/db.js";
-import type { NormalizedBlock, RuntimeCounters } from "../types.js";
+import { methodBreakdown, sessionCompactionStats } from "../stats.js";
+import type { CompactionMethod } from "../types.js";
 
-export interface CommandDeps {
-  sessionDB: SessionDB | null;
-  getSessionId: () => string;
-  getBlocks: () => NormalizedBlock[];
-  getCounters?: () => RuntimeCounters;
+function runCompaction(ctx: ExtensionCommandContext, method: CompactionMethod, args: string, command: string): void {
+  const trimmed = args.trim();
+  setPendingCompaction(method, true, command);
+  ctx.compact({
+    customInstructions: method === "llm" ? trimmed || undefined : trimmed ? `${COMPACTOR_INSTRUCTION} ${trimmed}` : COMPACTOR_INSTRUCTION,
+    // Success shows as the compaction card in the transcript.
+    onComplete: () => setPendingCompaction(null),
+    onError: (err: Error) => {
+      setPendingCompaction(null);
+      // Pi already reports "Nothing to compact (session too small)".
+      if (/too small/i.test(err.message)) return;
+      if (err.message === "Compaction cancelled" || err.message === "Already compacted") ctx.ui.notify("Nothing to compact.", "info");
+      else ctx.ui.notify(`Compaction failed: ${err.message}`, "error");
+    },
+  });
 }
 
-export function registerCommands(pi: ExtensionAPI, deps?: CommandDeps): void {
-  // ── /unipi:lossless-compact ──────────────────────────
-  const losslessCompactHandler = async (_args: string, ctx: ExtensionCommandContext) => {
-    ctx.compact({
-      customInstructions: COMPACTOR_INSTRUCTION,
-      onComplete: () => {
-        const stats = getLastCompactionStats();
-        if (stats) {
-          ctx.ui.notify(formatCompactionStats(stats), "info");
-        } else {
-          ctx.ui.notify("Compaction completed.", "info");
-        }
-      },
-      onError: (err: Error) => {
-        if (err.message === "Compaction cancelled" || err.message === "Already compacted") {
-          ctx.ui.notify("Nothing to compact.", "info");
-        } else {
-          ctx.ui.notify(`Compaction failed: ${err.message}`, "error");
-        }
-      },
-    });
-  };
-  pi.registerCommand("unipi:lossless-compact", {
-    description: "Immediate zero-LLM compaction — structured summary with full recall",
-    handler: losslessCompactHandler,
+export function registerCommands(pi: ExtensionAPI): void {
+  pi.registerCommand("unipi:compact-vcc", {
+    description: "Lossless compaction now — instant structured summary, no model call (keep:N keeps N recent turns)",
+    handler: async (args: string, ctx: ExtensionCommandContext) => runCompaction(ctx, "vcc", args, "unipi:compact-vcc"),
   });
-  pi.registerCommand("unipi:compact", {
-    description: "Alias for /unipi:lossless-compact",
-    handler: losslessCompactHandler,
+  pi.registerCommand("unipi:compact-by-llm", {
+    description: "Compact now with a model-written summary (optional text focuses the summary)",
+    handler: async (args: string, ctx: ExtensionCommandContext) => runCompaction(ctx, "llm", args, "unipi:compact-by-llm"),
   });
-
-  // ── /unipi:session-recall (new) ─────────────────────
-  // pi-vcc parity: results are sent as a visible custom message AND fed to the
-  // agent as context (triggerTurn), so recall results drive the next turn.
-  const sessionRecallHandler = async (args: string, ctx: ExtensionCommandContext, commandName = "/unipi:session-recall") => {
+  // pi-vcc parity: results are shown AND fed to the agent (triggerTurn).
+  const sessionRecallHandler = async (args: string, ctx: ExtensionCommandContext) => {
     const raw = args.trim();
-    const suffix = commandName === "/unipi:compact-recall" ? " (deprecated; use /unipi:session-recall <query>)" : "";
+    const usage = "Usage: /unipi:session-recall <query>";
     if (!raw) {
-      ctx.ui.notify(`Usage: ${commandName} <query>${suffix}`, "warning");
+      ctx.ui.notify(usage, "warning");
       return;
     }
-
-    // Parse scope:all and page:N inline (pi-vcc parity)
     const parsed = parseRecallScope(raw);
     const pageMatch = parsed.text.match(/\bpage:(\d+)\b/i);
     const page = pageMatch ? Math.max(1, parseInt(pageMatch[1], 10)) : 1;
     const query = parsed.text.replace(/\bpage:\d+\b/i, "").trim();
-
     if (!query) {
-      ctx.ui.notify(`Usage: ${commandName} <query>${suffix}`, "warning");
+      ctx.ui.notify(usage, "warning");
       return;
     }
-
-    // Prefer the live session branch over cached blocks. The branch includes raw
-    // pre-compaction messages that are omitted from the compacted LLM context.
-    const config = loadConfig((ctx as any).cwd ?? process.cwd());
-    const liveBlocks = filterNoise(recallBlocksFromContext(ctx), config.pipeline?.customNoisePatterns);
-    const blocks = liveBlocks.length > 0 ? liveBlocks : (deps?.getBlocks() ?? []);
+    const blocks = filterNoise(recallBlocksFromContext(ctx));
     if (blocks.length === 0) {
       ctx.ui.notify("No session history available for search.", "warning");
       return;
     }
     const result = vccRecall(blocks, { query, scope: parsed.scope, page });
-    pi.sendMessage(
-      { customType: "compactor-recall", content: result.text, display: true },
-      { triggerTurn: true },
-    );
+    pi.sendMessage({
+      customType: "compactor-recall",
+      content: result.text,
+      display: true,
+      details: { unipiHarness: harnessMetadata({ source: "Compactor", title: "Session recall", synopsis: "Results from /unipi:session-recall" }, "direct") },
+    }, { triggerTurn: true });
   };
   pi.registerCommand("unipi:session-recall", {
     description: "Recall earlier parts of this session. Plain keywords work best; add scope:all to reach edited or retried turns.",
     handler: sessionRecallHandler,
   });
-  // Deprecated alias
-  pi.registerCommand("unipi:compact-recall", {
-    description: "(DEPRECATED) Search session history — use /unipi:session-recall instead",
-    handler: async (args: string, ctx: ExtensionCommandContext) => {
-      return sessionRecallHandler(args, ctx, "/unipi:compact-recall");
-    },
-  });
-
-  // ── /unipi:compact-stats ─────────────────────────────
   pi.registerCommand("unipi:compact-stats", {
-    description: "Show context savings dashboard",
+    description: "Show this session's compaction savings",
     handler: async (_args: string, ctx: ExtensionCommandContext) => {
-      if (!deps?.sessionDB) {
-        ctx.ui.notify("Compactor services not initialized.", "error");
-        return;
-      }
-      try {
-        const stats = await ctxStats(deps.sessionDB, deps.getSessionId(), deps.getCounters?.());
-        const lines = [
-          "📊 Compactor Stats",
-          `Session events: ${stats.sessionEvents}`,
-          `Compactions: ${stats.compactions}`,
-          `Tokens saved: ${stats.tokensSaved}`,
-          `Sandbox runs: ${stats.sandboxRuns}`,
-          `Search queries: ${stats.searchQueries}`,
-        ];
-        ctx.ui.notify(lines.join("\n"), "info");
-      } catch (err) {
-        ctx.ui.notify(`Stats error: ${err}`, "error");
-      }
+      const stats = sessionCompactionStats(ctx.sessionManager.getBranch() as any[]);
+      const usage = ctx.getContextUsage?.();
+      const lines = [
+        "Compactor — this session",
+        `Compactions: ${stats.compactions.length}${stats.compactions.length ? ` (${methodBreakdown(stats)})` : ""}`,
+        `Tokens: ${stats.tokensBefore ? `${formatTokens(stats.tokensBefore)} → ${formatTokens(stats.tokensAfter)} (−${formatTokens(stats.tokensSaved)})` : "nothing compacted yet"}`,
+        usage?.tokens != null && usage.contextWindow ? `Context now: ~${formatTokens(usage.tokens)} / ${formatTokens(usage.contextWindow)}` : "",
+      ].filter(Boolean);
+      ctx.ui.notify(lines.join("\n"), "info");
     },
   });
 
-  // ── /unipi:compact-doctor ────────────────────────────
   pi.registerCommand("unipi:compact-doctor", {
-    description: "Run diagnostics checklist",
+    description: "Check compaction settings and leftovers",
     handler: async (_args: string, ctx: ExtensionCommandContext) => {
-      if (!deps?.sessionDB) {
-        ctx.ui.notify("Compactor services not initialized.", "error");
-        return;
-      }
-      try {
-        const result = await ctxDoctor(deps.sessionDB);
-        const icon = (s: string) => (s === "pass" ? "✅" : s === "warn" ? "⚠️" : "❌");
-        const lines = [
-          result.healthy ? "🩺 All checks passed" : "🩺 Issues found",
-          "",
-          ...result.checks.map((c) => `${icon(c.status)} ${c.name}: ${c.message}`),
-        ];
-        ctx.ui.notify(lines.join("\n"), result.healthy ? "info" : "warning");
-      } catch (err) {
-        ctx.ui.notify(`Doctor error: ${err}`, "error");
-      }
+      const result = ctxDoctor(loadConfig(ctx.cwd), { hasModel: Boolean(ctx.model) });
+      const icon = (s: string) => (s === "pass" ? "✓" : s === "warn" ? "!" : "✗");
+      const lines = [
+        result.healthy ? "Compactor: all checks passed" : "Compactor: issues found",
+        ...result.checks.map((c) => `${icon(c.status)} ${c.name}: ${c.message}`),
+      ];
+      ctx.ui.notify(lines.join("\n"), result.healthy ? "info" : "warning");
     },
   });
 
-  // Hub action runners — "Apply preset: X" rows in /unipi:settings. These
-  // mirror the removed slash-command preset flow (applyPreset + save).
-  for (const name of ["precise", "balanced", "thorough", "lean"] as const) {
-    registerCommandRunner(`unipi:compact-apply-${name}`, () => {
-      saveConfig(applyPreset(name));
-    });
-  }
-
-  // ── /unipi:compact-help ──────────────────────────────
   pi.registerCommand("unipi:compact-help", {
-    description: "Show detailed compactor documentation (tier-2 skill)",
+    description: "Show compactor help",
     handler: async (_args: string, ctx: ExtensionCommandContext) => {
       ctx.ui.notify(
-        "🗜️ Compactor Help\n" +
-        "Quick commands:\n" +
-        "  /unipi:lossless-compact — trigger immediate compaction\n" +
-        "  /unipi:session-recall <query> — search session history\n" +
-        "  /unipi:compact-stats — view stats\n" +
-        "  /unipi:compact-doctor — run diagnostics\n" +
-        "  auto-compaction settings — /unipi:settings (Compactor group)\n" +
-              "\n" +
-        "Percentage trigger:\n" +
-        "  Disabled by default. Enable it in /unipi:settings (Compactor › Auto) to compact at a context % before Pi's reserve-token limit.",
+        [
+          "Compactor",
+          "  /unipi:compact-vcc [keep:N]    lossless compaction now (no model call)",
+          "  /unipi:compact-by-llm [focus]  compact now with a model-written summary",
+          "  /unipi:session-recall <query>  search everything in this session, including compacted parts",
+          "  /unipi:compact-stats           this session's savings",
+          "  /unipi:compact-doctor          check settings",
+          "",
+          "Settings: /unipi:settings → Compactor (method, what Pi's /compact does, when to compact).",
+        ].join("\n"),
         "info",
       );
     },

package/packages/compactor/src/compaction/compact-args.ts

@@ -65,9 +65,11 @@ export const parseCompactionInstructions = (
     return { isCompactor: true, keepUserTurns: 1, keepUserTurnsExplicit: false, followUpPrompt: null };
   }
 
-  const keepPrefix = `${COMPACTOR_INSTRUCTION} `;
-  if (trimmed?.startsWith(keepPrefix)) {
-    const parsed = parseKeepAndPrompt(trimmed.slice(keepPrefix.length));
+  // Marker + anything after whitespace (space or newline, e.g. ask-user's
+  // handoff text) is ours; only a keep:N is honored — the caller delivers
+  // its own follow-up, so no prompt is replayed from here.
+  if (trimmed?.startsWith(COMPACTOR_INSTRUCTION) && /^\s/.test(trimmed.slice(COMPACTOR_INSTRUCTION.length))) {
+    const parsed = parseKeepAndPrompt(trimmed.slice(COMPACTOR_INSTRUCTION.length).trim().split(/\n/)[0]);
     return {
       isCompactor: true,
       keepUserTurns: parsed.keepUserTurns ?? 1,

package/packages/compactor/src/compaction/filter-noise.ts

@@ -38,7 +38,7 @@ export const filterNoise = (blocks: NormalizedBlock[], extraPatterns?: string[])
       if (isNoiseUserBlock(b.text, extraPatterns)) continue;
       const cleaned = cleanUserText(b.text);
       if (!cleaned) continue;
-      out.push({ kind: "user", text: cleaned });
+      out.push({ ...b, text: cleaned });
       continue;
     }
     out.push(b);