pi-condense 2.0.0

package/src/config.ts

@@ -0,0 +1,126 @@
+import { readFile, writeFile, mkdir, rename } from "node:fs/promises";
+import { randomBytes } from "node:crypto";
+import { join, dirname } from "node:path";
+import { getAgentDir } from "@earendil-works/pi-coding-agent";
+import type { ContextPruneConfig, PruneOn, SummarizerThinking } from "./types.js";
+import { DEFAULT_CONFIG, PRUNE_ON_MODES, SUMMARIZER_THINKING_LEVELS } from "./types.js";
+
+/**
+ * Settings location: the active pi agent's main `settings.json` under the
+ * `contextPrune` namespace, mirroring pi's own conventions for `compaction`,
+ * `retry`, `branchSummary`, etc. Pi's SettingsManager preserves unknown
+ * top-level keys when it rewrites settings, so the namespace coexists safely
+ * with pi's own settings.
+ *
+ * Resolved against `getAgentDir()` so it honors `PI_CODING_AGENT_DIR`
+ * (defaults to `~/.pi/agent`). Each pi preset directory therefore gets its
+ * own context-prune config — including its own summarizer model.
+ */
+export const SETTINGS_PATH = join(getAgentDir(), "settings.json");
+
+/** Top-level key under which context-prune state lives in `settings.json`. */
+export const SETTINGS_KEY = "contextPrune" as const;
+
+function isPruneOn(value: unknown): value is PruneOn {
+  return typeof value === "string" && PRUNE_ON_MODES.some((mode) => mode.value === value);
+}
+
+function isSummarizerThinking(value: unknown): value is SummarizerThinking {
+  return typeof value === "string" && SUMMARIZER_THINKING_LEVELS.some((level) => level.value === value);
+}
+
+function normalize(existing: Partial<ContextPruneConfig>): ContextPruneConfig {
+  const merged = { ...DEFAULT_CONFIG, ...existing };
+  return {
+    ...merged,
+    enabled: typeof merged.enabled === "boolean" ? merged.enabled : DEFAULT_CONFIG.enabled,
+    showPruneStatusLine:
+      typeof merged.showPruneStatusLine === "boolean"
+        ? merged.showPruneStatusLine
+        : DEFAULT_CONFIG.showPruneStatusLine,
+    pruneOn: isPruneOn(merged.pruneOn) ? merged.pruneOn : DEFAULT_CONFIG.pruneOn,
+    summarizerThinking: isSummarizerThinking(merged.summarizerThinking)
+      ? merged.summarizerThinking
+      : DEFAULT_CONFIG.summarizerThinking,
+    quietOversizedSkips:
+      typeof merged.quietOversizedSkips === "boolean"
+        ? merged.quietOversizedSkips
+        : DEFAULT_CONFIG.quietOversizedSkips,
+    minBatchChars:
+      typeof merged.minBatchChars === "number" &&
+      Number.isFinite(merged.minBatchChars) &&
+      merged.minBatchChars >= 0
+        ? Math.floor(merged.minBatchChars)
+        : DEFAULT_CONFIG.minBatchChars,
+    dedupByContentHash:
+      typeof merged.dedupByContentHash === "boolean"
+        ? merged.dedupByContentHash
+        : DEFAULT_CONFIG.dedupByContentHash,
+    autoBudgetThreshold:
+      typeof merged.autoBudgetThreshold === "number" &&
+      Number.isFinite(merged.autoBudgetThreshold) &&
+      merged.autoBudgetThreshold > 0 &&
+      merged.autoBudgetThreshold <= 1
+        ? merged.autoBudgetThreshold
+        : DEFAULT_CONFIG.autoBudgetThreshold,
+    spillThreshold:
+      typeof merged.spillThreshold === "number" &&
+      Number.isFinite(merged.spillThreshold) &&
+      merged.spillThreshold > 0
+        ? Math.floor(merged.spillThreshold)
+        : DEFAULT_CONFIG.spillThreshold,
+    spillPreviewBytes:
+      typeof merged.spillPreviewBytes === "number" &&
+      Number.isFinite(merged.spillPreviewBytes) &&
+      merged.spillPreviewBytes >= 0
+        ? Math.floor(merged.spillPreviewBytes)
+        : DEFAULT_CONFIG.spillPreviewBytes,
+    budgetTurnDelta:
+      typeof merged.budgetTurnDelta === "number" &&
+      Number.isFinite(merged.budgetTurnDelta) &&
+      merged.budgetTurnDelta > 0 &&
+      merged.budgetTurnDelta <= 1
+        ? merged.budgetTurnDelta
+        : DEFAULT_CONFIG.budgetTurnDelta,
+  };
+}
+
+async function readJsonObject(path: string): Promise<Record<string, unknown> | undefined> {
+  try {
+    const raw = await readFile(path, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+      return parsed as Record<string, unknown>;
+    }
+    return undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+/** Reads `<agent-dir>/settings.json` and returns the `contextPrune` block, or defaults. */
+export async function loadConfig(): Promise<ContextPruneConfig> {
+  const main = await readJsonObject(SETTINGS_PATH);
+  const namespaced = main?.[SETTINGS_KEY];
+  if (namespaced && typeof namespaced === "object" && !Array.isArray(namespaced)) {
+    return normalize(namespaced as Partial<ContextPruneConfig>);
+  }
+  return { ...DEFAULT_CONFIG };
+}
+
+/**
+ * Writes the full config back to `<agent-dir>/settings.json` under
+ * {@link SETTINGS_KEY}, preserving every other top-level key in the file. Uses
+ * a tmp-file + atomic rename so concurrent pi writes (e.g. theme changes via
+ * `/settings`) cannot observe a partial file. We do not coordinate with pi's
+ * own internal lock since both writers do whole-file replacements and a
+ * last-write-wins race only loses a single change, never corrupts the file.
+ */
+export async function saveConfig(config: ContextPruneConfig): Promise<void> {
+  const current = (await readJsonObject(SETTINGS_PATH)) ?? {};
+  const next = { ...current, [SETTINGS_KEY]: config };
+  await mkdir(dirname(SETTINGS_PATH), { recursive: true });
+  const tmpPath = `${SETTINGS_PATH}.${randomBytes(8).toString("hex")}.tmp`;
+  await writeFile(tmpPath, `${JSON.stringify(next, null, 2)}\n`);
+  await rename(tmpPath, SETTINGS_PATH);
+}

package/src/content-hash.ts

@@ -0,0 +1,35 @@
+/**
+ * Content-hash helper for the dedup pre-flush pass.
+ *
+ * Hashes (toolName, normalize(resultText)) via SHA-1 into a hex digest.
+ * Normalization is intentionally conservative: line-ending normalization
+ * (`\r\n` → `\n`), per-line trailing whitespace stripping, and a final
+ * whole-string trim. Internal whitespace, tabs, and capitalization are
+ * preserved so two genuinely different outputs do NOT collide.
+ *
+ * SHA-1 is overkill at this scale (~10⁵ records per long session at most)
+ * but is fast, built into Node's `crypto` module, and trivially readable.
+ *
+ * The `\0` separator between toolName and resultText prevents pathological
+ * collisions where two `(name, payload)` pairs concatenate to the same
+ * string (e.g. `("ab", "c")` vs `("a", "bc")`).
+ */
+
+import { createHash } from "node:crypto";
+
+function normalize(resultText: string): string {
+  const lf = resultText.replace(/\r\n/g, "\n");
+  return lf
+    .split("\n")
+    .map((line) => line.replace(/[ \t]+$/g, ""))
+    .join("\n")
+    .trim();
+}
+
+export function hashToolResult(toolName: string, resultText: string): string {
+  return createHash("sha1")
+    .update(toolName)
+    .update("\0")
+    .update(normalize(resultText))
+    .digest("hex");
+}

package/src/error-purge.test.ts

@@ -0,0 +1,186 @@
+import { describe, expect, it } from "bun:test";
+import { purgeErroredArgs } from "./error-purge.js";
+import type { ErrorPurgeConfig } from "./types.js";
+
+const defaultConfig: ErrorPurgeConfig = {
+  enabled: true,
+  cooldownTurns: 2,
+  minArgChars: 10,
+};
+
+function makeAssistant(toolCallId: string, argsObj: Record<string, any>, turnN?: number) {
+  return {
+    role: "assistant",
+    content: [
+      {
+        type: "toolCall",
+        id: toolCallId,
+        name: "bash",
+        arguments: argsObj,
+      },
+    ],
+    timestamp: turnN ?? 1,
+  };
+}
+
+function makeToolResult(toolCallId: string, isError: boolean) {
+  return {
+    role: "toolResult",
+    toolCallId,
+    toolName: "bash",
+    content: [{ type: "text", text: isError ? "Error: file not found" : "ok" }],
+    isError,
+    timestamp: 2,
+  };
+}
+
+describe("purgeErroredArgs", () => {
+  it("returns input array reference unchanged when no errored tool results", () => {
+    const messages = [
+      makeAssistant("tc1", { cmd: "ls" }),
+      makeToolResult("tc1", false),
+    ];
+    const result = purgeErroredArgs(messages, defaultConfig);
+    expect(result).toBe(messages);
+  });
+
+  it("does not purge while still within cooldown", () => {
+    // Error at turn 1, current = turn 2, age = 1 < cooldownTurns 2
+    const messages = [
+      makeAssistant("tc1", { content: "a very long argument body here" }),
+      makeToolResult("tc1", true),
+      makeAssistant("tc2", { cmd: "ls" }),
+      makeToolResult("tc2", false),
+    ];
+    const result = purgeErroredArgs(messages, { ...defaultConfig, cooldownTurns: 2 });
+    expect(result).toBe(messages);
+    const asstMsg = result[0] as any;
+    expect(asstMsg.content[0].arguments).toEqual({ content: "a very long argument body here" });
+  });
+
+  it("purges args after cooldown when args meet minArgChars", () => {
+    const largeArgs = { content: "a very long argument body here" };
+    const messages = [
+      makeAssistant("tc1", largeArgs),
+      makeToolResult("tc1", true),
+      makeAssistant("tc2", { cmd: "ls" }),
+      makeToolResult("tc2", false),
+      makeAssistant("tc3", { cmd: "pwd" }),
+      makeToolResult("tc3", false),
+    ];
+    const result = purgeErroredArgs(messages, { ...defaultConfig, cooldownTurns: 2, minArgChars: 10 });
+    expect(result).not.toBe(messages);
+    const purgedAsst = result[0] as any;
+    const originalArgLen = JSON.stringify(largeArgs).length;
+    expect(purgedAsst.content[0].arguments).toEqual({
+      _purged: `<purged-errored-args size="${originalArgLen}"/>`,
+    });
+    // toolResult stays unchanged
+    expect((result[1] as any).content[0].text).toBe("Error: file not found");
+  });
+
+  it("does not purge when args are below minArgChars", () => {
+    const messages = [
+      makeAssistant("tc1", { x: "hi" }), // JSON is only ~10 chars
+      makeToolResult("tc1", true),
+      makeAssistant("tc2", { cmd: "ls" }),
+      makeToolResult("tc2", false),
+      makeAssistant("tc3", { cmd: "pwd" }),
+      makeToolResult("tc3", false),
+    ];
+    const result = purgeErroredArgs(messages, { ...defaultConfig, cooldownTurns: 2, minArgChars: 1000 });
+    expect(result).toBe(messages);
+  });
+
+  it("does not purge when isError is false", () => {
+    const messages = [
+      makeAssistant("tc1", { content: "a very long argument body here" }),
+      makeToolResult("tc1", false), // NOT an error
+      makeAssistant("tc2", { cmd: "ls" }),
+      makeToolResult("tc2", false),
+      makeAssistant("tc3", { cmd: "pwd" }),
+      makeToolResult("tc3", false),
+    ];
+    const result = purgeErroredArgs(messages, defaultConfig);
+    expect(result).toBe(messages);
+  });
+
+  it("only purges errored toolCalls in a multi-toolCall assistant message", () => {
+    const largeArgs = { content: "a very long argument body here that is big" };
+    const okArgs = { cmd: "ls" };
+    const messages = [
+      // One assistant with two toolCalls: tc-err is errored, tc-ok is not
+      {
+        role: "assistant",
+        content: [
+          { type: "toolCall", id: "tc-err", name: "write", arguments: largeArgs },
+          { type: "toolCall", id: "tc-ok", name: "bash", arguments: okArgs },
+        ],
+        timestamp: 1,
+      },
+      makeToolResult("tc-err", true),
+      makeToolResult("tc-ok", false),
+      makeAssistant("tc2", { cmd: "pwd" }),
+      makeToolResult("tc2", false),
+      makeAssistant("tc3", { cmd: "date" }),
+      makeToolResult("tc3", false),
+    ];
+    const result = purgeErroredArgs(messages, { ...defaultConfig, cooldownTurns: 2, minArgChars: 5 });
+    expect(result).not.toBe(messages);
+    const asst = result[0] as any;
+    // errored one is purged
+    const originalArgLen = JSON.stringify(largeArgs).length;
+    expect(asst.content[0].arguments).toEqual({
+      _purged: `<purged-errored-args size="${originalArgLen}"/>`,
+    });
+    // non-errored one is untouched
+    expect(asst.content[1].arguments).toEqual(okArgs);
+  });
+
+  it("does not mutate the input messages array or any message object", () => {
+    const largeArgs = { content: "a very long argument body here" };
+    const messages = [
+      makeAssistant("tc1", largeArgs),
+      makeToolResult("tc1", true),
+      makeAssistant("tc2", { cmd: "ls" }),
+      makeToolResult("tc2", false),
+      makeAssistant("tc3", { cmd: "pwd" }),
+      makeToolResult("tc3", false),
+    ];
+    const originalAsst = messages[0];
+    const originalArgs = (messages[0] as any).content[0].arguments;
+    purgeErroredArgs(messages, { ...defaultConfig, cooldownTurns: 2, minArgChars: 10 });
+    // Input array unchanged
+    expect(messages[0]).toBe(originalAsst);
+    expect((messages[0] as any).content[0].arguments).toBe(originalArgs);
+  });
+
+  it("exactly-at-cooldown boundary: age === cooldownTurns is purged", () => {
+    // Error at turn 1, 2 more assistant turns → age = 2 = cooldownTurns (should purge)
+    const largeArgs = { content: "argument body that is long enough to purge" };
+    const messages = [
+      makeAssistant("tc1", largeArgs),
+      makeToolResult("tc1", true),
+      makeAssistant("tc2", { cmd: "ls" }),
+      makeToolResult("tc2", false),
+      makeAssistant("tc3", { cmd: "pwd" }),
+      makeToolResult("tc3", false),
+    ];
+    const result = purgeErroredArgs(messages, { ...defaultConfig, cooldownTurns: 2, minArgChars: 5 });
+    expect(result).not.toBe(messages);
+    expect((result[0] as any).content[0].arguments._purged).toBeDefined();
+  });
+
+  it("one-below-cooldown boundary: age === cooldownTurns - 1 is NOT purged", () => {
+    // Error at turn 1, 1 more assistant turn → age = 1 < cooldownTurns 2
+    const largeArgs = { content: "argument body that is long enough to purge" };
+    const messages = [
+      makeAssistant("tc1", largeArgs),
+      makeToolResult("tc1", true),
+      makeAssistant("tc2", { cmd: "ls" }),
+      makeToolResult("tc2", false),
+    ];
+    const result = purgeErroredArgs(messages, { ...defaultConfig, cooldownTurns: 2, minArgChars: 5 });
+    expect(result).toBe(messages);
+  });
+});

package/src/error-purge.ts

@@ -0,0 +1,71 @@
+import type { ErrorPurgeConfig } from "./types.js";
+
+/**
+ * Replaces the `arguments` body of failed toolCall blocks with a compact stub
+ * once the error is old enough to be beyond the cooldown window.
+ *
+ * Why only the arguments, not the whole toolCall or its toolResult:
+ *   - The toolResult content (e.g. "Error: file not found") is small and carries
+ *     the failure signal the model needs to understand what went wrong.
+ *   - The toolCall block itself must remain so the provider can pair it with its
+ *     result and avoid injecting a synthetic "No result provided" error.
+ *   - The arguments body is what grows large — failed `write` / `edit` calls
+ *     embed the full file content that will never be acted on again.
+ *
+ * Why the cooldown:
+ *   - Gives the model 1–2 turns to retry before context is mutated. Purging
+ *     immediately would remove the call detail before the model has had a
+ *     chance to see the error and adapt.
+ *
+ * Turn index is computed internally by counting AssistantMessages in the input.
+ * This avoids threading a turn counter through index.ts.
+ */
+export function purgeErroredArgs(messages: any[], config: ErrorPurgeConfig): any[] {
+  // Pass 1: collect errored toolCallIds → the turn index at which the error occurred.
+  // Turn index = number of AssistantMessages seen up to and including the one that
+  // issued the tool call (ToolResultMessages follow immediately after).
+  const erroredAtTurn = new Map<string, number>();
+  let turnCount = 0;
+  for (const msg of messages) {
+    if (msg.role === "assistant") {
+      // Count each assistant turn; toolResults referencing the turn come next.
+      turnCount++;
+    } else if (msg.role === "toolResult" && msg.isError === true) {
+      // Record the turn this errored call belongs to for cooldown comparison.
+      erroredAtTurn.set(msg.toolCallId, turnCount);
+    }
+  }
+
+  if (erroredAtTurn.size === 0) return messages;
+
+  const currentTurnIndex = turnCount;
+
+  // Pass 2: rewrite AssistantMessages whose toolCall args should be purged.
+  let anyModified = false;
+  const result = messages.map((msg) => {
+    if (msg.role !== "assistant") return msg;
+
+    let contentModified = false;
+    const newContent = (msg.content as any[]).map((block) => {
+      if (block.type !== "toolCall") return block;
+
+      const errorTurn = erroredAtTurn.get(block.id);
+      if (errorTurn === undefined) return block;
+
+      const age = currentTurnIndex - errorTurn;
+      if (age < config.cooldownTurns) return block;
+
+      const argBody = JSON.stringify(block.arguments);
+      if (argBody.length < config.minArgChars) return block;
+
+      contentModified = true;
+      return { ...block, arguments: { _purged: `<purged-errored-args size="${argBody.length}"/>` } };
+    });
+
+    if (!contentModified) return msg;
+    anyModified = true;
+    return { ...msg, content: newContent };
+  });
+
+  return anyModified ? result : messages;
+}

package/src/frontier.ts

@@ -0,0 +1,62 @@
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { PruneFrontier } from "./types.js";
+import { CUSTOM_TYPE_FRONTIER } from "./types.js";
+
+/**
+ * Tracks the most recent completed prune-attempt boundary.
+ *
+ * The frontier advances when a prune attempt finishes, regardless of whether it
+ * produced a persisted summary or was skipped because the summary was larger
+ * than the raw tool outputs. It does not advance on operational failures.
+ */
+export class PruneFrontierTracker {
+  private frontier: PruneFrontier | null = null;
+
+  reset(): void {
+    this.frontier = null;
+  }
+
+  get(): PruneFrontier | null {
+    return this.frontier ? { ...this.frontier } : null;
+  }
+
+  fromJSON(data: PruneFrontier): void {
+    if (!data?.lastAttemptedToolCallId) return;
+    this.frontier = {
+      lastAttemptedToolCallId: data.lastAttemptedToolCallId,
+      lastAttemptedToolName: data.lastAttemptedToolName ?? "unknown",
+      lastAttemptedTurnIndex: data.lastAttemptedTurnIndex ?? 0,
+      lastAttemptedTimestamp: data.lastAttemptedTimestamp ?? 0,
+      attemptedBatchCount: data.attemptedBatchCount ?? 0,
+      attemptedToolCallCount: data.attemptedToolCallCount ?? 0,
+      rawCharCount: data.rawCharCount ?? 0,
+      summaryCharCount: data.summaryCharCount ?? 0,
+      outcome: data.outcome ?? "summarized",
+    };
+  }
+
+  reconstructFromSession(ctx: ExtensionContext): void {
+    this.reset();
+    const branch = ctx.sessionManager.getBranch();
+    for (const entry of branch) {
+      if (
+        entry.type === "custom" &&
+        (entry as any).customType === CUSTOM_TYPE_FRONTIER
+      ) {
+        const data = (entry as any).data as PruneFrontier;
+        if (data) {
+          this.fromJSON(data);
+        }
+      }
+    }
+  }
+
+  advance(frontier: PruneFrontier): void {
+    this.frontier = { ...frontier };
+  }
+
+  persist(pi: ExtensionAPI): void {
+    if (!this.frontier) return;
+    pi.appendEntry(CUSTOM_TYPE_FRONTIER, this.frontier);
+  }
+}