pi-condense 2.0.0

package/src/thinking-strip.test.ts

@@ -0,0 +1,175 @@
+import { describe, expect, test } from "bun:test";
+import { stripOldThinking } from "./thinking-strip.js";
+import type { ThinkingStripConfig } from "./types.js";
+
+const cfg = (enabled: boolean, keepLastTurns: number): ThinkingStripConfig => ({ enabled, keepLastTurns });
+
+function userMsg(ts: number): any {
+  return { role: "user", content: [{ type: "text", text: "go" }], timestamp: ts };
+}
+
+function assistantToolsThinking(ts: number, toolCallIds: string[], thinkingBlocks = 1): any {
+  const content: any[] = [];
+  for (let i = 0; i < thinkingBlocks; i++) {
+    content.push({ type: "thinking", thinking: `t${ts}-${i}`, thinkingSignature: `sig${ts}-${i}` });
+  }
+  content.push({ type: "text", text: "working" });
+  for (const id of toolCallIds) content.push({ type: "toolCall", id, name: "bash", arguments: { cmd: "ls" } });
+  return { role: "assistant", content, timestamp: ts, usage: {}, stopReason: "toolUse" };
+}
+
+function assistantTextThinking(ts: number): any {
+  return {
+    role: "assistant",
+    content: [
+      { type: "thinking", thinking: "final reasoning", thinkingSignature: "sigf" },
+      { type: "text", text: "done" },
+    ],
+    timestamp: ts,
+    usage: {},
+    stopReason: "stop",
+  };
+}
+
+function toolResult(ts: number, toolCallId: string): any {
+  return {
+    role: "toolResult",
+    toolCallId,
+    toolName: "bash",
+    content: [{ type: "text", text: "out" }],
+    isError: false,
+    timestamp: ts,
+  };
+}
+
+function hasThinking(msg: any): boolean {
+  return Array.isArray(msg.content) && msg.content.some((c: any) => c.type === "thinking");
+}
+
+function countThinking(msg: any): number {
+  return Array.isArray(msg.content) ? msg.content.filter((c: any) => c.type === "thinking").length : 0;
+}
+
+/** user, then (n-1) tool-using assistant turns each followed by a toolResult, then 1 final text assistant. */
+function convo(nAssistantTurns: number): any[] {
+  const msgs: any[] = [userMsg(1)];
+  let ts = 2;
+  for (let i = 0; i < nAssistantTurns - 1; i++) {
+    const id = `tc${i}`;
+    msgs.push(assistantToolsThinking(ts++, [id]));
+    msgs.push(toolResult(ts++, id));
+  }
+  msgs.push(assistantTextThinking(ts++));
+  return msgs;
+}
+
+describe("stripOldThinking", () => {
+  test("disabled → same reference", () => {
+    const msgs = convo(20);
+    expect(stripOldThinking(msgs, cfg(false, 16))).toBe(msgs);
+  });
+
+  test("fewer assistant turns than keepLastTurns → same reference", () => {
+    const msgs = convo(10);
+    expect(stripOldThinking(msgs, cfg(true, 16))).toBe(msgs);
+  });
+
+  test("exactly keepLastTurns assistant turns → same reference (nothing older)", () => {
+    const msgs = convo(16);
+    expect(stripOldThinking(msgs, cfg(true, 16))).toBe(msgs);
+  });
+
+  test("strips thinking from turns older than the last K, keeps the last K", () => {
+    const msgs = convo(20);
+    const out = stripOldThinking(msgs, cfg(true, 16));
+    expect(out).not.toBe(msgs);
+    const assistants = out.filter((m) => m.role === "assistant");
+    expect(assistants.length).toBe(20);
+    for (const a of assistants.slice(-16)) expect(hasThinking(a)).toBe(true);
+    for (const a of assistants.slice(0, 4)) expect(hasThinking(a)).toBe(false);
+  });
+
+  test("keepLastTurns=1 keeps only the most-recent assistant turn's thinking", () => {
+    const msgs = convo(5);
+    const out = stripOldThinking(msgs, cfg(true, 1));
+    const assistants = out.filter((m) => m.role === "assistant");
+    expect(hasThinking(assistants[assistants.length - 1])).toBe(true);
+    for (const a of assistants.slice(0, -1)) expect(hasThinking(a)).toBe(false);
+  });
+
+  test("keepLastTurns=0 is clamped to 1 (never strips the last assistant turn)", () => {
+    const msgs = convo(5);
+    const out = stripOldThinking(msgs, cfg(true, 0));
+    const assistants = out.filter((m) => m.role === "assistant");
+    expect(hasThinking(assistants[assistants.length - 1])).toBe(true);
+    expect(hasThinking(assistants[0])).toBe(false);
+  });
+
+  test("trailing tool-use assistant awaiting results keeps its thinking", () => {
+    const msgs: any[] = [userMsg(1)];
+    let ts = 2;
+    for (let i = 0; i < 4; i++) {
+      const id = `x${i}`;
+      msgs.push(assistantToolsThinking(ts++, [id]));
+      msgs.push(toolResult(ts++, id));
+    }
+    const out = stripOldThinking(msgs, cfg(true, 1));
+    const assistants = out.filter((m) => m.role === "assistant");
+    const last = assistants[assistants.length - 1];
+    expect(hasThinking(last)).toBe(true);
+    expect(last.content.some((c: any) => c.type === "toolCall")).toBe(true);
+  });
+
+  test("stripped assistant keeps its text and toolCall blocks", () => {
+    const msgs = convo(20);
+    const out = stripOldThinking(msgs, cfg(true, 16));
+    const firstAssistant = out.find((m) => m.role === "assistant");
+    expect(hasThinking(firstAssistant)).toBe(false);
+    expect(firstAssistant.content.some((c: any) => c.type === "text")).toBe(true);
+    expect(firstAssistant.content.some((c: any) => c.type === "toolCall")).toBe(true);
+  });
+
+  test("strips all thinking blocks from a message (all-or-nothing)", () => {
+    const msgs: any[] = [userMsg(1), assistantToolsThinking(2, ["a"], 2), toolResult(3, "a")];
+    let ts = 4;
+    for (let i = 0; i < 3; i++) {
+      const id = `b${i}`;
+      msgs.push(assistantToolsThinking(ts++, [id], 2));
+      msgs.push(toolResult(ts++, id));
+    }
+    msgs.push(assistantTextThinking(ts++));
+    const out = stripOldThinking(msgs, cfg(true, 2));
+    expect(countThinking(out[1])).toBe(0);
+  });
+
+  test("no thinking anywhere → same reference", () => {
+    const msgs: any[] = [userMsg(1)];
+    let ts = 2;
+    for (let i = 0; i < 20; i++) {
+      const id = `n${i}`;
+      msgs.push({
+        role: "assistant",
+        content: [{ type: "text", text: "x" }, { type: "toolCall", id, name: "bash", arguments: {} }],
+        timestamp: ts++,
+        usage: {},
+        stopReason: "toolUse",
+      });
+      msgs.push(toolResult(ts++, id));
+    }
+    expect(stripOldThinking(msgs, cfg(true, 4))).toBe(msgs);
+  });
+
+  test("idempotent: second pass returns same reference", () => {
+    const msgs = convo(20);
+    const once = stripOldThinking(msgs, cfg(true, 16));
+    const twice = stripOldThinking(once, cfg(true, 16));
+    expect(twice).toBe(once);
+  });
+
+  test("preserves message order and length", () => {
+    const msgs = convo(20);
+    const out = stripOldThinking(msgs, cfg(true, 16));
+    expect(out.length).toBe(msgs.length);
+    out.forEach((m, i) => expect(m.role).toBe(msgs[i].role));
+  });
+});

package/src/thinking-strip.ts

@@ -0,0 +1,42 @@
+import { withoutThinkingBlocks } from "./chain-range-prune.js";
+import type { ThinkingStripConfig } from "./types.js";
+
+/**
+ * Rolling main-loop thinking strip.
+ *
+ * Keeps `thinking` blocks on the last `keepLastTurns` assistant turns and
+ * strips them from all older assistant messages, preserving each message's
+ * `text` and `toolCall` blocks. "Turn" counts ASSISTANT messages, not
+ * user-bounded spans — the target failure mode is a single long open chain
+ * (zero subagents, near-zero user turns) where a span-based window keeps
+ * everything.
+ *
+ * Provider safety (Anthropic): during tool use only the LAST assistant turn's
+ * thinking is required; prior turns may be omitted, and a message's thinking
+ * blocks must be dropped all-or-nothing. `keepLastTurns` is clamped to >= 1 so
+ * the most-recent assistant turn always keeps its thinking. Stripping reuses
+ * `withoutThinkingBlocks` (drops the whole block incl. signature).
+ *
+ * Returns the original array reference unchanged when nothing is stripped, so
+ * `pruneMessages` can skip reconstruction.
+ */
+export function stripOldThinking(messages: any[], config: ThinkingStripConfig): any[] {
+  if (!config.enabled) return messages;
+  const keep = Math.max(1, config.keepLastTurns);
+
+  const assistantIdx: number[] = [];
+  for (let i = 0; i < messages.length; i++) {
+    if (messages[i]?.role === "assistant") assistantIdx.push(i);
+  }
+  if (assistantIdx.length <= keep) return messages;
+
+  const firstKeptAssistant = assistantIdx[assistantIdx.length - keep];
+  let changed = false;
+  const out = messages.map((msg, i) => {
+    if (i >= firstKeptAssistant || msg?.role !== "assistant") return msg;
+    if (!Array.isArray(msg.content) || !msg.content.some((c: any) => c.type === "thinking")) return msg;
+    changed = true;
+    return withoutThinkingBlocks(msg);
+  });
+  return changed ? out : messages;
+}

package/src/tree-browser.ts

@@ -0,0 +1,382 @@
+import type { Component } from "@earendil-works/pi-tui";
+import { Markdown, getKeybindings, matchesKey, truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+import { getMarkdownTheme } from "@earendil-works/pi-coding-agent";
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import type { ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
+import type { ToolCallRecord } from "./types.js";
+import { CUSTOM_TYPE_SUMMARY } from "./types.js";
+import { normalizeSummaryToolCallRefs } from "./summary-refs.js";
+import type { ToolCallIndexer } from "./indexer.js";
+
+// ── Tree node types ─────────────────────────────────────────────────────────
+
+export interface TreeNode {
+  id: string;
+  label: string;
+  children: TreeNode[];
+  expanded: boolean;
+  depth: number;
+  isLeaf: boolean;
+  /** Optional extra detail shown when expanded (e.g. result preview) */
+  detail?: string;
+  /** Character count of this node's content (result text for tools, summary text for summaries) */
+  charCount?: number;
+}
+
+interface VisibleRow {
+  node: TreeNode;
+  index: number;
+}
+
+interface SummaryOverlayState {
+  title: string;
+  text: string;
+  scrollOffset: number;
+}
+
+// ── Formatting helpers ──────────────────────────────────────────────────────
+
+function formatChars(n: number): string {
+  if (n >= 1_000_000) return `${(n / 1_000_000).toFixed(1)}M`;
+  if (n >= 1_000) return `${(n / 1_000).toFixed(1)}k`;
+  return `${n}`;
+}
+
+function padToWidth(str: string, width: number): string {
+  const vis = visibleWidth(str);
+  if (vis >= width) return str;
+  return str + " ".repeat(width - vis);
+}
+
+function isCtrlO(data: string): boolean {
+  return matchesKey(data, "ctrl+o") || data === "\u000f";
+}
+
+// ── Box drawing ─────────────────────────────────────────────────────────────
+
+function boxLines(
+  lines: string[],
+  width: number,
+  title: string,
+  theme: Theme,
+): string[] {
+  const innerWidth = Math.max(0, width - 2);
+  const result: string[] = [];
+
+  // Top border with title
+  const titlePrefix = title ? `─ ${title} ` : "";
+  const titleVis = visibleWidth(titlePrefix);
+  const topFill = "─".repeat(Math.max(0, innerWidth - titleVis));
+  result.push("┌" + titlePrefix + topFill + "┐");
+
+  // Content lines
+  for (const line of lines) {
+    result.push("│" + padToWidth(line, innerWidth) + "│");
+  }
+
+  // Bottom border
+  result.push("└" + "─".repeat(innerWidth) + "┘");
+
+  return result;
+}
+
+// ── Tree data builder ───────────────────────────────────────────────────────
+
+/**
+ * Scans the current session branch for prune-summary entries and builds a
+ * foldable tree where each summary is a parent node and its pruned tool calls
+ * are children.  Tool call records are looked up via the indexer.
+ *
+ * Each node carries a `charCount` so the UI can show how many characters the
+ * summary replaced (making it obvious whether pruning is saving space).
+ */
+export function buildPruneTree(
+  ctx: ExtensionCommandContext,
+  indexer: ToolCallIndexer,
+): TreeNode[] {
+  const branch = ctx.sessionManager.getBranch();
+  const roots: TreeNode[] = [];
+  let summaryIndex = 0;
+
+  for (const entry of branch) {
+    if (entry.type !== "custom_message") continue;
+    const customEntry = entry as any;
+    if (customEntry.customType !== CUSTOM_TYPE_SUMMARY) continue;
+
+    const details = customEntry.details as {
+      toolCallRefs?: { shortId: string; toolCallId: string }[];
+      toolCallIds?: string[];
+      toolNames: string[];
+      turnIndex: number;
+      timestamp: number;
+    } | undefined;
+
+    const toolCallRefs = normalizeSummaryToolCallRefs(details);
+    const turnIndex = details?.turnIndex ?? "?";
+    const timestamp = details?.timestamp
+      ? new Date(details.timestamp).toLocaleString()
+      : "";
+
+    const children: TreeNode[] = [];
+    for (const ref of toolCallRefs) {
+      const record = indexer.getRecord(ref.toolCallId);
+      if (!record) continue;
+      children.push(toolCallNode(record, 1));
+    }
+
+    const summaryText =
+      typeof customEntry.content === "string" ? customEntry.content : "";
+    const summaryChars = summaryText.length;
+    const totalOriginalChars = children.reduce(
+      (sum, c) => sum + (c.charCount ?? 0),
+      0,
+    );
+
+    const header = `[pruner] Turn ${turnIndex} summary (${children.length} tool${children.length === 1 ? "" : "s"} · ${formatChars(summaryChars)} chars · original ${formatChars(totalOriginalChars)})`;
+    const label = timestamp ? `${header} · ${timestamp}` : header;
+
+    roots.push({
+      id: `summary-${summaryIndex++}`,
+      label,
+      children,
+      expanded: false,
+      depth: 0,
+      isLeaf: children.length === 0,
+      detail: summaryText || undefined,
+      charCount: summaryChars,
+    });
+  }
+
+  return roots;
+}
+
+function toolCallNode(record: ToolCallRecord, depth: number): TreeNode {
+  const argsText = Object.entries(record.args)
+    .map(([k, v]) => `${k}=${JSON.stringify(v)}`)
+    .join(", ");
+  const charCount = record.resultText.length || record.spillBytes || 0;
+  const unit = record.resultText.length ? "chars" : (record.spillBytes ? "bytes" : "chars");
+  const label = `${record.toolName}(${argsText}) · ${formatChars(charCount)} ${unit}${record.isError ? " [error]" : ""}`;
+  const previewSource = record.resultText || record.resultPreview || "";
+  const resultPreview = previewSource.slice(0, 200).replace(/\s+/g, " ");
+  return {
+    id: record.toolCallId,
+    label,
+    children: [],
+    expanded: false,
+    depth,
+    isLeaf: true,
+    detail: resultPreview,
+    charCount,
+  };
+}
+
+// ── TreeBrowser component ───────────────────────────────────────────────────
+
+export class TreeBrowser implements Component {
+  private flatRows: VisibleRow[] = [];
+  private selectedIndex = 0;
+  private theme: Theme;
+  private onDone: () => void;
+  private summaryOverlay: SummaryOverlayState | null = null;
+
+  constructor(
+    private readonly roots: TreeNode[],
+    theme: Theme,
+    onDone: () => void,
+  ) {
+    this.theme = theme;
+    this.onDone = onDone;
+    this.rebuildFlatRows();
+  }
+
+  invalidate(): void {
+    this.rebuildFlatRows();
+  }
+
+  private rebuildFlatRows(): void {
+    this.flatRows = [];
+    let index = 0;
+    const walk = (nodes: TreeNode[]) => {
+      for (const node of nodes) {
+        this.flatRows.push({ node, index: index++ });
+        if (node.expanded && node.children.length > 0) {
+          walk(node.children);
+        }
+      }
+    };
+    walk(this.roots);
+    if (this.selectedIndex >= this.flatRows.length) {
+      this.selectedIndex = Math.max(0, this.flatRows.length - 1);
+    }
+  }
+
+  handleInput(data: string): void {
+    const kb = getKeybindings();
+
+    if (this.summaryOverlay) {
+      if (kb.matches(data, "tui.select.up")) {
+        this.summaryOverlay.scrollOffset = Math.max(0, this.summaryOverlay.scrollOffset - 1);
+      } else if (kb.matches(data, "tui.select.down")) {
+        this.summaryOverlay.scrollOffset += 1;
+      } else if (kb.matches(data, "tui.select.cancel") || data === "q" || isCtrlO(data)) {
+        this.summaryOverlay = null;
+      }
+      return;
+    }
+
+    if (kb.matches(data, "tui.select.up")) {
+      this.selectedIndex =
+        this.selectedIndex === 0
+          ? this.flatRows.length - 1
+          : this.selectedIndex - 1;
+    } else if (kb.matches(data, "tui.select.down")) {
+      this.selectedIndex =
+        this.selectedIndex === this.flatRows.length - 1
+          ? 0
+          : this.selectedIndex + 1;
+    } else if (kb.matches(data, "tui.select.confirm") || data === " ") {
+      const row = this.flatRows[this.selectedIndex];
+      if (row && !row.node.isLeaf) {
+        row.node.expanded = !row.node.expanded;
+        this.rebuildFlatRows();
+      }
+    } else if (isCtrlO(data)) {
+      this.openSelectedSummary();
+    } else if (kb.matches(data, "tui.select.cancel") || data === "q") {
+      this.onDone();
+    }
+  }
+
+  render(width: number): string[] {
+    const innerWidth = Math.max(0, width - 2);
+
+    let baseLines: string[];
+    if (this.flatRows.length === 0) {
+      const msg = this.theme.fg("muted", "(no pruned tool calls in this session)");
+      baseLines = boxLines([msg], width, "Pruned Tool Calls", this.theme);
+    } else {
+      const contentLines: string[] = [
+        this.theme.fg("dim", "Enter/Space expand • Ctrl-O open summary • Esc/q close"),
+        "",
+      ];
+      for (let i = 0; i < this.flatRows.length; i++) {
+        const row = this.flatRows[i];
+        const line = this.renderRow(row.node, innerWidth, i === this.selectedIndex);
+        contentLines.push(line);
+      }
+
+      baseLines = boxLines(contentLines, width, "Pruned Tool Calls", this.theme);
+    }
+
+    if (!this.summaryOverlay) {
+      return baseLines;
+    }
+
+    return this.renderWithSummaryOverlay(baseLines, width);
+  }
+
+  private openSelectedSummary(): void {
+    const row = this.flatRows[this.selectedIndex];
+    if (!row || row.node.isLeaf || !row.node.detail) {
+      return;
+    }
+
+    this.summaryOverlay = {
+      title: row.node.label,
+      text: row.node.detail,
+      scrollOffset: 0,
+    };
+  }
+
+  private renderWithSummaryOverlay(baseLines: string[], width: number): string[] {
+    const overlay = this.summaryOverlay;
+    if (!overlay) return baseLines;
+
+    const overlayWidth = Math.max(60, width - 2);
+    const overlayInnerWidth = Math.max(1, overlayWidth - 2);
+    const markdown = new Markdown(overlay.text, 1, 0, getMarkdownTheme());
+    const markdownLines = markdown.render(Math.max(1, overlayInnerWidth));
+    const reservedLines = 5;
+    const maxContentHeight = Math.max(12, Math.min(markdownLines.length, baseLines.length + 8));
+    const maxScroll = Math.max(0, markdownLines.length - maxContentHeight);
+    overlay.scrollOffset = Math.min(overlay.scrollOffset, maxScroll);
+
+    const visibleContent = markdownLines.slice(
+      overlay.scrollOffset,
+      overlay.scrollOffset + maxContentHeight,
+    );
+
+    const footer = this.theme.fg(
+      "dim",
+      `↑/↓ scroll • Ctrl-O/Esc/q close${maxScroll > 0 ? ` • ${overlay.scrollOffset + 1}-${Math.min(overlay.scrollOffset + maxContentHeight, markdownLines.length)} / ${markdownLines.length}` : ""}`,
+    );
+    const overlayLines = boxLines(
+      [
+        this.theme.fg("accent", truncateToWidth(overlay.title, overlayInnerWidth, "…", false)),
+        this.theme.fg("dim", "Pruned summary message"),
+        "",
+        ...visibleContent,
+        "",
+        footer,
+      ],
+      overlayWidth,
+      "Pruned Summary",
+      this.theme,
+    );
+
+    const canvasHeight = Math.max(baseLines.length, overlayLines.length + 2);
+    const blankLine = " ".repeat(width);
+    const composed = Array.from({ length: canvasHeight }, (_, index) => baseLines[index] ?? blankLine);
+    const startRow = Math.max(0, Math.floor((canvasHeight - overlayLines.length) / 2));
+    const leftPad = Math.max(0, Math.floor((width - overlayWidth) / 2));
+    const rightPad = Math.max(0, width - leftPad - overlayWidth);
+
+    for (let i = 0; i < overlayLines.length && startRow + i < composed.length; i++) {
+      composed[startRow + i] = " ".repeat(leftPad) + overlayLines[i] + " ".repeat(rightPad);
+    }
+
+    return composed;
+  }
+
+  private renderRow(
+    node: TreeNode,
+    width: number,
+    isSelected: boolean,
+  ): string {
+    const indent = "  ".repeat(node.depth);
+    const prefix = node.isLeaf
+      ? "  "
+      : node.expanded
+        ? "▾ "
+        : "▸ ";
+
+    let text: string;
+    if (node.isLeaf) {
+      text = this.theme.fg("text", node.label);
+    } else {
+      text = this.theme.fg("accent", node.label);
+    }
+
+    const fullLine = indent + prefix + text;
+    const plainText = indent + prefix + node.label;
+    const visibleLen = visibleWidth(plainText);
+
+    let rendered: string;
+    if (visibleLen > width) {
+      rendered = truncateToWidth(fullLine, width, "…", false);
+    } else {
+      rendered = fullLine;
+    }
+
+    if (isSelected) {
+      const padLen = width - visibleWidth(rendered);
+      if (padLen > 0) {
+        rendered += " ".repeat(padLen);
+      }
+      rendered = this.theme.bg("selectedBg", rendered);
+    }
+
+    return rendered;
+  }
+}