@asterxsk/kiln 0.1.0

package/agent/extensions/trim-context/index.ts

@@ -0,0 +1,487 @@
+/**
+ * trim-context — pi extension for crush / amp / lsp style context management
+ *
+ * Does three things:
+ *  1. CACHING: forces PI_CACHE_RETENTION=long (1h Anthropic, 24h OpenAI) + ensures
+ *     Anthropic/OpenAI cache_control breakpoints on system + last messages.
+ *     Without this pi uses 5m cache which misses on long tasks.
+ *
+ *  2. OUTPUT COMPRESSION: intercepts tool_result for read/bash/grep/find/ls/edit/write
+ *     and aggressively truncates large outputs before they are persisted to history.
+ *     Built-in pi truncates at 50KB/2000 lines - this extension compresses at
+ *     30KB/400 lines for recent, and 8KB/100 lines for older via context hook.
+ *     Full output is saved to temp file and referenced in the compressed result.
+ *
+ *  3. TRIM CONTEXT (crush/amp/lsp): via `context` event, before every LLM call:
+ *     - keeps last KEEP_RECENT_TURNS (6) turns verbatim
+ *     - for older turns: truncates tool results to 800 chars, strips thinking blocks,
+ *       deduplicates repeated file reads (keeps only last read of same file),
+ *       compresses old bash outputs to tail-only
+ *     - if total estimated tokens > SOFT_LIMIT (80k), prunes oldest tool results first
+ *
+ * Install: lives in ~/.pi/agent/extensions/trim-context/ (auto-discovered)
+ * Reload: /reload
+ * Command: /trimContext — show stats / toggle
+ */
+
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { mkdtempSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+// ---------------------------------------------------------------------------
+// Config — tune here
+// ---------------------------------------------------------------------------
+const CONFIG = {
+  // amp strict — keep only last 3 turns verbatim (amp keeps 2-3)
+  KEEP_RECENT_TURNS: 3,
+
+  // output compression thresholds for tool_result hook (immediate)
+  IMMEDIATE_MAX_BYTES: 12 * 1024, // 12KB for read/grep/etc (amp strict)
+  IMMEDIATE_MAX_LINES: 150,
+  // bash is the leak — amp strict: 750 tokens max
+  BASH_IMMEDIATE_MAX_BYTES: 3 * 1024, // 3KB ~750 tokens hard cap
+  BASH_IMMEDIATE_MAX_LINES: 30,
+
+  // context hook thresholds for OLD messages (older than KEEP_RECENT_TURNS)
+  OLD_MAX_CHARS: 500, // was 800
+  OLD_MAX_LINES: 20, // was 30
+  OLD_BASH_TAIL_LINES: 8, // was 12 — amp strict tail-only
+
+  // soft token limit before we start pruning oldest tool results entirely
+  SOFT_TOKEN_LIMIT: 50_000, // amp strict ~200KB chars, prune earlier
+  HARD_TOKEN_LIMIT: 80_000,
+
+  // dedupe repeated read()s
+  DEDUPE_READS: true,
+
+  // strip old thinking blocks
+  STRIP_OLD_THINKING: true,
+
+  // caching
+  CACHE_RETENTION: "long" as const, // "long" = 1h anthropic, 24h openai
+};
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function estimateTokens(text: string): number {
+  return Math.ceil(text.length / 4);
+}
+
+function getTextContent(blocks: Array<{ type: string; text?: string }>): string {
+  return blocks
+    .filter((b) => b.type === "text" && typeof b.text === "string")
+    .map((b) => b.text)
+    .join("\n");
+}
+
+function truncateToLimits(
+  text: string,
+  maxChars: number,
+  maxLines: number,
+  label = "truncated"
+): { text: string; truncated: boolean; savedChars: number } {
+  const lines = text.split("\n");
+  let truncated = false;
+  let result = text;
+
+  if (lines.length > maxLines) {
+    // keep head + tail pattern for bash/logs, head-only for reads
+    const head = lines.slice(0, Math.floor(maxLines * 0.75));
+    const tail = lines.slice(-Math.floor(maxLines * 0.25));
+    result = [...head, `\n[... ${lines.length - maxLines} lines ${label} ...]\n`, ...tail].join("\n");
+    truncated = true;
+  }
+  if (result.length > maxChars) {
+    const headChars = Math.floor(maxChars * 0.8);
+    result =
+      result.slice(0, headChars) +
+      `\n[... ${result.length - headChars} chars ${label} ...]\n` +
+      result.slice(-Math.floor(maxChars * 0.2));
+    truncated = true;
+  }
+  return { text: result, truncated, savedChars: truncated ? text.length - result.length : 0 };
+}
+
+function saveFullOutput(fullText: string, toolName: string): string {
+  try {
+    const dir = mkdtempSync(join(tmpdir(), `pi-trim-${toolName}-`));
+    const file = join(dir, "full-output.txt");
+    writeFileSync(file, fullText, "utf8");
+    return file;
+  } catch {
+    return "(failed to save)";
+  }
+}
+
+// Track compression stats across session
+let stats = {
+  toolResultsCompressed: 0,
+  charsSaved: 0,
+  readsDeduped: 0,
+  thinkingStripped: 0,
+  contextTrims: 0,
+};
+
+let trimEnabled = true;
+
+// ---------------------------------------------------------------------------
+// Extension
+// ---------------------------------------------------------------------------
+export default function (pi: ExtensionAPI) {
+  // Force long cache retention before any provider is created
+  if (process.env.PI_CACHE_RETENTION !== "long") {
+    process.env.PI_CACHE_RETENTION = CONFIG.CACHE_RETENTION;
+  }
+
+  pi.on("session_start", async (_event, ctx) => {
+    stats = { toolResultsCompressed: 0, charsSaved: 0, readsDeduped: 0, thinkingStripped: 0, contextTrims: 0 };
+    // clear legacy statusline from previous version
+    ctx.ui.setStatus("trim-context", undefined);
+  });
+
+  pi.on("session_shutdown", async () => {
+    stats = { toolResultsCompressed: 0, charsSaved: 0, readsDeduped: 0, thinkingStripped: 0, contextTrims: 0 };
+  });
+
+  // -------------------------------------------------------------------------
+  // 1) OUTPUT COMPRESSION — tool_result hook (immediate, before persistence)
+  // -------------------------------------------------------------------------
+  pi.on("tool_result", async (event, _ctx) => {
+    if (!trimEnabled) return;
+    const content = event.content as Array<{ type: string; text?: string }>;
+    const textBlocks = content.filter((c) => c.type === "text" && typeof c.text === "string");
+    if (textBlocks.length === 0) return;
+
+    const fullText = getTextContent(content as any);
+    if (!fullText) return;
+
+    const lines = fullText.split("\n").length;
+    const bytes = Buffer.byteLength(fullText, "utf8");
+
+    // bash/powershell get much tighter limits — that's your 1-2k leak
+    const isBash = event.toolName === "bash" || event.toolName === "powershell";
+    const maxBytes = isBash ? CONFIG.BASH_IMMEDIATE_MAX_BYTES : CONFIG.IMMEDIATE_MAX_BYTES;
+    const maxLines = isBash ? CONFIG.BASH_IMMEDIATE_MAX_LINES : CONFIG.IMMEDIATE_MAX_LINES;
+
+    // Also strip ANSI + collapse for bash before measuring (saves 10-20% tokens)
+    let textForCheck = fullText;
+    if (isBash) {
+      // strip ANSI escape codes, collapse 3+ blank lines, trim trailing whitespace per line
+      textForCheck = textForCheck.replace(/\x1B\[[0-9;]*[A-Za-z]/g, "").replace(/\n{3,}/g, "\n\n");
+    }
+    const checkLines = textForCheck.split("\n").length;
+    const checkBytes = Buffer.byteLength(textForCheck, "utf8");
+    if (checkBytes <= maxBytes && checkLines <= maxLines) {
+      // if we stripped ANSI but still under limit, still persist the cleaned version
+      if (isBash && textForCheck !== fullText) {
+        return { content: [{ type: "text", text: textForCheck }] };
+      }
+      return;
+    }
+    // use cleaned text for compression if bash
+    const sourceText = isBash ? textForCheck : fullText;
+    const sourceLines = sourceText.split("\n").length;
+    const sourceBytes = Buffer.byteLength(sourceText, "utf8");
+
+    const { text: compressed, savedChars } = truncateToLimits(
+      sourceText,
+      maxBytes,
+      maxLines,
+      `output compressed by trim-context (${toolNameLabel(event.toolName)})`
+    );
+
+    const fullPath = saveFullOutput(fullText, event.toolName);
+    const notice =
+      compressed +
+      `\n\n[trim-context: ${isBash ? "bash" : event.toolName} compressed from ${(sourceBytes / 1024).toFixed(1)}KB/${sourceLines} lines ` +
+      `to ${(Buffer.byteLength(compressed, "utf8") / 1024).toFixed(1)}KB. Full saved to: ${fullPath} — limit ${maxBytes / 1024}KB/${maxLines} lines]`;
+
+    stats.toolResultsCompressed++;
+    stats.charsSaved += savedChars;
+
+    // Return patch — pi chains these, so we only override content
+    return {
+      content: [{ type: "text", text: notice }],
+    };
+  });
+
+  function toolNameLabel(name: string): string {
+    return name || "tool";
+  }
+
+  // -------------------------------------------------------------------------
+  // 2) TRIM CONTEXT — context hook (crush/amp/lsp style, before each LLM call)
+  // -------------------------------------------------------------------------
+  pi.on("context", async (event, _ctx) => {
+    if (!trimEnabled) return;
+    const messages: any[] = event.messages;
+    if (messages.length === 0) return;
+
+    // Identify turn boundaries: each user message starts a turn
+    const userIndices: number[] = [];
+    for (let i = 0; i < messages.length; i++) {
+      if (messages[i].role === "user") userIndices.push(i);
+    }
+
+    // Determine cutoff: keep last KEEP_RECENT_TURNS user turns verbatim
+    const keepFromUserIdx = Math.max(0, userIndices.length - CONFIG.KEEP_RECENT_TURNS);
+    const keepFromMsgIdx = keepFromUserIdx < userIndices.length ? userIndices[keepFromUserIdx] : 0;
+
+    // For dedupe: find last read of each file path among ALL messages
+    const lastReadIndexByPath = new Map<string, number>();
+    if (CONFIG.DEDUPE_READS) {
+      for (let i = 0; i < messages.length; i++) {
+        const m = messages[i];
+        if (m.role === "assistant" && Array.isArray(m.content)) {
+          for (const block of m.content) {
+            if (block.type === "toolCall" && block.name === "read" && block.arguments?.path) {
+              const p = String(block.arguments.path);
+              lastReadIndexByPath.set(p, i);
+            }
+          }
+        }
+      }
+    }
+
+    let totalChars = 0;
+    for (const m of messages) {
+      totalChars += JSON.stringify(m).length;
+    }
+    const needsPruning = estimateTokens(JSON.stringify(messages)) > CONFIG.SOFT_TOKEN_LIMIT;
+
+    let prunedCount = 0;
+    let dedupedCount = 0;
+    let thinkingStripped = 0;
+
+    const trimmed = messages.map((msg, idx) => {
+      const isRecent = idx >= keepFromMsgIdx;
+
+      // Recent turns: keep verbatim (already compressed by tool_result hook)
+      if (isRecent) return msg;
+
+      // Old turns: apply aggressive trimming
+
+      // 1) Strip thinking blocks from old assistant messages
+      if (CONFIG.STRIP_OLD_THINKING && msg.role === "assistant" && Array.isArray(msg.content)) {
+        const origLen = msg.content.length;
+        const filtered = msg.content.filter((b: any) => b.type !== "thinking");
+        if (filtered.length !== origLen) {
+          thinkingStripped++;
+          // If we stripped all content and only thinking remained, keep a placeholder
+          if (filtered.length === 0) {
+            return { ...msg, content: [{ type: "text", text: "[thinking stripped by trim-context]" }] };
+          }
+          return { ...msg, content: filtered };
+        }
+      }
+
+      // 2) Deduplicate old reads: if this read is not the last read of that file, replace toolResult
+      if (CONFIG.DEDUPE_READS && msg.role === "assistant" && Array.isArray(msg.content)) {
+        for (const block of msg.content) {
+          if (block.type === "toolCall" && block.name === "read" && block.arguments?.path) {
+            const p = String(block.arguments.path);
+            const lastIdx = lastReadIndexByPath.get(p);
+            if (lastIdx !== undefined && lastIdx !== idx) {
+              // This is an old superseded read — we mark for later toolResult compression
+              // We tag the assistant message so the following toolResult can be identified
+              (msg as any).__trimReadPath = p;
+            }
+          }
+        }
+      }
+
+      // 3) Compress old toolResults
+      if (msg.role === "toolResult" && Array.isArray(msg.content)) {
+        const prevMsg = idx > 0 ? messages[idx - 1] : null;
+        const isSupersededRead =
+          !!(prevMsg as any)?.__trimReadPath ||
+          (msg.toolName === "read" && (() => {
+            // Check if there's a later read of same file
+            const toolInput = (msg as any).toolName === "read" ? (msg as any).input : null;
+            // Fallback: check details if available
+            return false;
+          })());
+
+        const text = getTextContent(msg.content as any);
+        if (!text) return msg;
+
+        // If superseded read, replace entirely
+        if (isSupersededRead || (msg.toolName === "read" && CONFIG.DEDUPE_READS)) {
+          // Check if a later read exists for same file by scanning forward for toolCall read with same path
+          // We already mapped lastReadIndex — if current toolResult is before last, it's superseded
+          // We need to correlate toolResult to its toolCall. Use toolCallId matching.
+          // Simpler: if total messages has a later read, compress heavily
+          const isOld = true;
+          if (isOld && text.length > 200) {
+            // Check if any later assistant has a read toolCall
+            let hasLaterRead = false;
+            for (let j = idx + 1; j < messages.length; j++) {
+              const later = messages[j];
+              if (later.role === "assistant" && Array.isArray(later.content)) {
+                for (const b of later.content) {
+                  if (b.type === "toolCall" && b.name === "read") {
+                    // We can't perfectly match path without toolCallId link, but assume if ANY later read exists
+                    // and this is an old read, it's likely dedupable. Be conservative: only if many reads.
+                    hasLaterRead = true;
+                    break;
+                  }
+                }
+              }
+              if (hasLaterRead) break;
+            }
+            if (hasLaterRead && lastReadIndexByPath.size > 1) {
+              // Don't aggressively dedupe single-file sessions
+              // Instead compress to tiny placeholder
+              dedupedCount++;
+              return {
+                ...msg,
+                content: [{ type: "text", text: `[trim-context: superseded read — latest version kept later in context]` }],
+              };
+            }
+          }
+        }
+
+        // General old-result compression
+        if (text.length > CONFIG.OLD_MAX_CHARS || text.split("\n").length > CONFIG.OLD_MAX_LINES) {
+          let compressed: string;
+          if (msg.toolName === "bash" || msg.toolName === "powershell") {
+            // For bash, keep tail (most recent output matters)
+            const lines = text.split("\n");
+            const tail = lines.slice(-CONFIG.OLD_BASH_TAIL_LINES);
+            const headNote = `[trim-context: old bash output compressed from ${lines.length} lines / ${(text.length / 1024).toFixed(1)}KB to ${tail.length} lines]`;
+            compressed = headNote + "\n" + tail.join("\n");
+          } else {
+            const { text: t } = truncateToLimits(text, CONFIG.OLD_MAX_CHARS, CONFIG.OLD_MAX_LINES, "old result compressed");
+            compressed = t + `\n[trim-context: compressed old ${msg.toolName} result]`;
+          }
+          prunedCount++;
+          return { ...msg, content: [{ type: "text", text: compressed }] };
+        }
+      }
+
+      return msg;
+    });
+
+    // 4) If still over soft limit, hard-prune oldest toolResults entirely (keep marker)
+    if (needsPruning) {
+      let estimated = estimateTokens(JSON.stringify(trimmed));
+      for (let i = 0; i < trimmed.length && estimated > CONFIG.SOFT_TOKEN_LIMIT; i++) {
+        const m = trimmed[i];
+        if (m.role === "toolResult" && i < keepFromMsgIdx) {
+          const text = getTextContent(m.content as any[]);
+          if (text && !text.startsWith("[trim-context:")) {
+            trimmed[i] = {
+              ...m,
+              content: [{ type: "text", text: `[trim-context: pruned to save context — was ${(text.length / 1024).toFixed(1)}KB]` }],
+            };
+            estimated -= estimateTokens(text);
+            prunedCount++;
+          }
+        }
+      }
+    }
+
+    if (prunedCount > 0 || dedupedCount > 0 || thinkingStripped > 0) {
+      stats.contextTrims++;
+      stats.readsDeduped += dedupedCount;
+      stats.thinkingStripped += thinkingStripped;
+    }
+
+    // Clean up temp markers
+    for (const m of trimmed as any[]) delete m.__trimReadPath;
+    for (const m of messages as any[]) delete m.__trimReadPath;
+
+    if (prunedCount > 0 || dedupedCount > 0 || thinkingStripped > 0 || needsPruning) {
+      // Only return if we changed something — otherwise pi keeps original
+      return { messages: trimmed };
+    }
+  });
+
+  // -------------------------------------------------------------------------
+  // 3) CACHING — ensure cache_control on payload (backup to env var)
+  // -------------------------------------------------------------------------
+  pi.on("before_provider_request", async (event, _ctx) => {
+    const payload: any = event.payload;
+
+    // Anthropic: ensure system and last message have cache_control
+    // Pi already does this when PI_CACHE_RETENTION != "none", but we reinforce
+    // for proxies / custom providers that may not respect env.
+    try {
+      if (payload.system && Array.isArray(payload.system)) {
+        const lastSystem = payload.system[payload.system.length - 1];
+        if (lastSystem && !lastSystem.cache_control) {
+          lastSystem.cache_control = { type: "ephemeral", ttl: "1h" };
+        }
+      }
+      if (payload.messages && Array.isArray(payload.messages) && payload.messages.length > 0) {
+        // Add cache breakpoint to last user message if missing
+        for (let i = payload.messages.length - 1; i >= 0; i--) {
+          const m = payload.messages[i];
+          if (m.role === "user" && Array.isArray(m.content)) {
+            const lastBlock = m.content[m.content.length - 1];
+            if (lastBlock && !lastBlock.cache_control) {
+              lastBlock.cache_control = { type: "ephemeral", ttl: "1h" };
+              break;
+            }
+          } else if (m.role === "user" && typeof m.content === "string") {
+            // Convert string to cached block
+            payload.messages[i] = {
+              role: "user",
+              content: [{ type: "text", text: m.content, cache_control: { type: "ephemeral", ttl: "1h" } }],
+            };
+            break;
+          }
+        }
+      }
+      // For OpenAI-compatible: ensure prompt_cache_key / prompt_cache_retention
+      if (payload.model && typeof payload.model === "string") {
+        if (!payload.prompt_cache_retention && CONFIG.CACHE_RETENTION === "long") {
+          // Only set if provider supports it — harmless otherwise
+          payload.prompt_cache_retention = "24h";
+        }
+      }
+    } catch {
+      // never break the request
+    }
+  });
+
+  // -------------------------------------------------------------------------
+  // Command: /trim
+  // -------------------------------------------------------------------------
+  pi.registerCommand("trim", {
+    description: "Toggle trim-context (amp strict) — /trim, /trim on, /trim off, /trim show",
+    handler: async (args, ctx) => {
+      const arg = (args || "").trim().toLowerCase();
+      if (arg === "show") {
+        const totalSavedKB = (stats.charsSaved / 1024).toFixed(1);
+        ctx.ui.notify(
+          `trim-context [${trimEnabled ? "ON" : "OFF"}] amp-strict\n` +
+            `  toolResults compressed: ${stats.toolResultsCompressed}\n` +
+            `  context trims: ${stats.contextTrims}\n` +
+            `  reads deduped: ${stats.readsDeduped}\n` +
+            `  thinking stripped: ${stats.thinkingStripped}\n` +
+            `  chars saved: ~${totalSavedKB}KB\n` +
+            `  config: keep ${CONFIG.KEEP_RECENT_TURNS}t, old→${CONFIG.OLD_MAX_CHARS}ch/${CONFIG.OLD_MAX_LINES}ln, bash ${CONFIG.BASH_IMMEDIATE_MAX_BYTES / 1024}KB/${CONFIG.BASH_IMMEDIATE_MAX_LINES}ln (tail ${CONFIG.OLD_BASH_TAIL_LINES}), generic ${CONFIG.IMMEDIATE_MAX_BYTES / 1024}KB/${CONFIG.IMMEDIATE_MAX_LINES}ln\n` +
+            `  soft limit: ${CONFIG.SOFT_TOKEN_LIMIT} tokens`,
+          "info"
+        );
+        return;
+      }
+      if (arg === "on" || arg === "enable" || arg === "enabled") {
+        trimEnabled = true;
+        ctx.ui.notify("trim-context: ON (amp strict)", "info");
+        return;
+      }
+      if (arg === "off" || arg === "disable" || arg === "disabled") {
+        trimEnabled = false;
+        ctx.ui.notify("trim-context: OFF — no compression/trimming", "warning");
+        return;
+      }
+      // toggle
+      trimEnabled = !trimEnabled;
+      ctx.ui.notify(`trim-context: ${trimEnabled ? "ON" : "OFF"}`, trimEnabled ? "info" : "warning");
+    },
+  });
+}

package/agent/extensions/trim-context/install.ps1

@@ -0,0 +1,23 @@
+#!/usr/bin/env pwsh
+# Per-extension installer — Windows / PowerShell
+# Installs npm dependencies for this extension. No-op if no package.json.
+$ErrorActionPreference = "Stop"
+$extDir = $PSScriptRoot
+if (-not $extDir) { $extDir = Split-Path -Parent $MyInvocation.MyCommand.Path }
+if (-not (Test-Path "$extDir/package.json")) {
+  Write-Host "  - no package.json — skipping" -ForegroundColor DarkGray
+  exit 0
+}
+if (-not (Get-Command npm -ErrorAction SilentlyContinue)) {
+  Write-Host "  x npm not found — install Node.js 22+" -ForegroundColor Red
+  exit 1
+}
+if (Test-Path "$extDir/package-lock.json") {
+  Write-Host "  - npm ci" -ForegroundColor DarkGray
+  npm --prefix $extDir ci --no-audit --no-fund
+} else {
+  Write-Host "  - npm install" -ForegroundColor DarkGray
+  npm --prefix $extDir install --no-audit --no-fund
+}
+if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
+Write-Host "  + done" -ForegroundColor Green

package/agent/extensions/trim-context/install.sh

@@ -0,0 +1,21 @@
+#!/bin/sh
+# Per-extension installer — macOS / Linux
+# Installs npm dependencies for this extension. No-op if no package.json.
+set -eu
+EXT_DIR="$(cd "$(dirname "$0")" && pwd)"
+if [ ! -f "$EXT_DIR/package.json" ]; then
+  echo "  · no package.json — skipping"
+  exit 0
+fi
+if ! command -v npm >/dev/null 2>&1; then
+  echo "  ✖ npm not found — install Node.js 22+" >&2
+  exit 1
+fi
+if [ -f "$EXT_DIR/package-lock.json" ]; then
+  echo "  · npm ci"
+  npm --prefix "$EXT_DIR" ci --no-audit --no-fund
+else
+  echo "  · npm install"
+  npm --prefix "$EXT_DIR" install --no-audit --no-fund
+fi
+echo "  ✓ done"