context-compress 2026.3.21 → 2026.3.22

package/dist/server.bundle.mjs

@@ -11061,7 +11061,7 @@ function debug(...args) {
 }
 
 // src/server.ts
-import { readFileSync as readFileSync2, realpathSync, statSync } from "node:fs";
+import { readFileSync as readFileSync3, realpathSync, statSync } from "node:fs";
 import { dirname, join as join4, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 
@@ -21217,6 +21217,129 @@ import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join as join2 } from "node:path";
 
+// src/filters.ts
+function applyCommandFilter(code, stdout) {
+  const cmd = code.trim().split(/\s+/)[0];
+  const fullCmd = code.trim();
+  if (cmd === "git") return filterGit(fullCmd, stdout);
+  if (cmd === "npm" || cmd === "yarn" || cmd === "pnpm" || cmd === "bun")
+    return filterPackageManager(fullCmd, stdout);
+  if (fullCmd.includes("test") || fullCmd.includes("jest") || fullCmd.includes("vitest") || fullCmd.includes("pytest") || fullCmd.includes("cargo test")) {
+    return filterTestOutput(stdout);
+  }
+  if (cmd === "cargo" || cmd === "make" || cmd === "gradle")
+    return filterBuildOutput(fullCmd, stdout);
+  if (cmd === "docker" || cmd === "kubectl") return filterContainerOutput(fullCmd, stdout);
+  if (cmd === "ls" || cmd === "find" || cmd === "tree") return filterFileList(fullCmd, stdout);
+  return { output: stdout, filtered: false };
+}
+function filterGit(cmd, stdout) {
+  if (/git\s+(push|pull|fetch|clone)/.test(cmd)) {
+    const lines = stdout.split("\n");
+    const filtered = lines.filter(
+      (l) => !l.startsWith("remote: Counting") && !l.startsWith("remote: Compressing") && !l.startsWith("remote: Total") && !l.includes("Unpacking objects:") && !l.includes("Receiving objects:") && !l.includes("Resolving deltas:") && !/^\s*\d+%/.test(l)
+    );
+    return { output: filtered.join("\n"), filtered: true };
+  }
+  if (/git\s+status/.test(cmd)) {
+    const lines = stdout.split("\n");
+    const filtered = lines.filter((l) => !l.startsWith("  (use ") && l.trim() !== "");
+    return { output: filtered.join("\n"), filtered: true };
+  }
+  return { output: stdout, filtered: false };
+}
+function filterPackageManager(cmd, stdout) {
+  if (/\b(install|add|i)\b/.test(cmd)) {
+    const lines = stdout.split("\n");
+    const filtered = lines.filter(
+      (l) => !l.startsWith("npm warn") && !l.includes("packages are looking for funding") && !l.includes("run `npm fund`") && !l.startsWith("npm notice") && !/^[\s\u2502\u251C\u2514\u2500]+$/.test(l) && // tree-drawing characters
+      !/^\s*$/.test(l)
+    );
+    return { output: filtered.join("\n"), filtered: true };
+  }
+  if (/\btest\b/.test(cmd)) {
+    return filterTestOutput(stdout);
+  }
+  return { output: stdout, filtered: false };
+}
+var FAIL_MARKER_RE = /^\s*[\u2717\u2718\u00D7]\s/;
+var FAIL_WORD_RE = /\bFAIL\b/;
+var FAILED_RE = /\bfailed?\b/i;
+var ERROR_RE = /\bERROR\b/;
+var SUMMARY_RE = /^\s*(Tests?|Suites?|Test Suites)\s*:|^\s*(pass|fail|skip|pending|todo)\s|\b\d+\s+(passing|failing|pending|skipped)\b|^(ok|not ok)\s|^\u2139\s|^(PASS|FAIL)\s/i;
+function isFailMarker(line) {
+  return FAIL_MARKER_RE.test(line) || FAIL_WORD_RE.test(line) || FAILED_RE.test(line) || ERROR_RE.test(line);
+}
+function isSummaryLine(line) {
+  return SUMMARY_RE.test(line);
+}
+function filterTestOutput(stdout) {
+  const lines = stdout.split("\n");
+  const failures = [];
+  const summary = [];
+  let inFailure = false;
+  let failCount = 0;
+  for (const line of lines) {
+    if (isFailMarker(line)) {
+      inFailure = true;
+      failCount++;
+    }
+    if (inFailure) {
+      failures.push(line);
+      if (line.trim() === "" && failures.length > 3) inFailure = false;
+    }
+    if (isSummaryLine(line)) {
+      summary.push(line);
+    }
+  }
+  if (failCount === 0 && summary.length > 0) {
+    return { output: summary.join("\n"), filtered: true };
+  }
+  if (failures.length > 0) {
+    const result = [...failures, "", ...summary].join("\n");
+    return { output: result, filtered: true };
+  }
+  return { output: stdout, filtered: false };
+}
+function filterBuildOutput(cmd, stdout) {
+  const lines = stdout.split("\n");
+  const filtered = lines.filter(
+    (l) => !l.includes("Downloading") && !l.includes("Downloaded") && !/Compiling\s+\d+\s+of\s+\d+/.test(l) && !l.includes("Blocking waiting for file lock") && !/^\s*$/.test(l)
+  );
+  return { output: filtered.join("\n"), filtered: filtered.length < lines.length };
+}
+function filterContainerOutput(cmd, stdout) {
+  if (/docker\s+build/.test(cmd)) {
+    const lines = stdout.split("\n");
+    const filtered = lines.filter(
+      (l) => !l.startsWith(" ---> ") && !l.startsWith("Sending build context")
+    );
+    return { output: filtered.join("\n"), filtered: true };
+  }
+  return { output: stdout, filtered: false };
+}
+function filterFileList(cmd, stdout) {
+  const lines = stdout.split("\n").filter((l) => l.trim() !== "");
+  if (lines.length <= 30) return { output: stdout, filtered: false };
+  if (cmd.includes("-R") || cmd.startsWith("find")) {
+    const dirs = /* @__PURE__ */ new Map();
+    for (const line of lines) {
+      const parts = line.split("/");
+      const dir = parts.length > 1 ? parts.slice(0, -1).join("/") : ".";
+      dirs.set(dir, (dirs.get(dir) ?? 0) + 1);
+    }
+    if (dirs.size > 5 && lines.length > 50) {
+      const summary = Array.from(dirs.entries()).sort((a, b) => b[1] - a[1]).map(([dir, count]) => `  ${dir}/ (${count} files)`).join("\n");
+      return {
+        output: `${lines.length} files found:
+${summary}`,
+        filtered: true
+      };
+    }
+  }
+  return { output: stdout, filtered: false };
+}
+
 // src/utils.ts
 function detectInjectionPatterns(content) {
   const warnings = [];
@@ -21265,6 +21388,10 @@ function formatBytes(bytes) {
 
 // src/executor.ts
 var DEFAULT_TIMEOUT = 3e4;
+var ANSI_RE = /\x1b\[[0-9;]*[a-zA-Z]/;
+function stripAnsi(str) {
+  return str.replace(new RegExp(ANSI_RE.source, "g"), "");
+}
 var SAFE_ENV_KEYS = [
   "PATH",
   "HOME",
@@ -21317,6 +21444,21 @@ function killProcessTree(pid) {
     }
   }
 }
+function stripProgressLines(output) {
+  const lines = output.split("\n");
+  const filtered = lines.filter((l) => {
+    const trimmed = l.trim();
+    if (ANSI_RE.test(l) && trimmed.replace(new RegExp(ANSI_RE.source, "g"), "").trim() === "")
+      return false;
+    if (/^[\s\[│├└─═━▓░█▒▏▎▍▌▋▊▉\]>=#\-.\d%]+$/.test(trimmed) && trimmed.length > 3) return false;
+    if (/^[⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏\-\\|/]\s/.test(trimmed)) return false;
+    if (/(?:downloading|uploading|fetching|resolving)\s+[\d.]+\s*[kmg]?b/i.test(trimmed))
+      return false;
+    if (/\d+\.?\d*\s*[kmg]?b\/s/i.test(trimmed) && /eta|remaining/i.test(trimmed)) return false;
+    return true;
+  });
+  return filtered.join("\n");
+}
 function deduplicateLines(output) {
   const lines = output.split("\n");
   if (lines.length < 3) return output;
@@ -21348,12 +21490,12 @@ function deduplicateLines(output) {
 function groupErrorLines(output) {
   const lines = output.split("\n");
   if (lines.length < 5) return output;
-  const ERROR_RE = /^(.*?(?:error|warning|Error|Warning|ERR|WARN)[:\s])\s*(.+?)(?:\s+(?:at|in|on)\s+(?:line\s+)?(\d+))?$/i;
+  const ERROR_RE2 = /^(.*?(?:error|warning|Error|Warning|ERR|WARN)[:\s])\s*(.+?)(?:\s+(?:at|in|on)\s+(?:line\s+)?(\d+))?$/i;
   const errorGroups = /* @__PURE__ */ new Map();
   const resultLines = [];
   let groupedCount = 0;
   for (const line of lines) {
-    const match = line.match(ERROR_RE);
+    const match = line.match(ERROR_RE2);
     if (match) {
       const prefix = match[1].trim();
       const msg = match[2].trim();
@@ -21505,7 +21647,8 @@ var SubprocessExecutor = class {
         tmpDir,
         timeout,
         maxOutput,
-        plugin.needsShell
+        plugin.needsShell,
+        opts.language === "shell" ? opts.code : void 0
       );
     } finally {
       setTimeout(() => this.cleanupTempDir(tmpDir), 100).unref();
@@ -21532,7 +21675,7 @@ var SubprocessExecutor = class {
     }
     return this.execute({ ...opts, code });
   }
-  spawnAndCapture(cmd, args, cwd, timeout, maxOutput, useShell) {
+  spawnAndCapture(cmd, args, cwd, timeout, maxOutput, useShell, shellCode) {
     return new Promise((resolve2) => {
       const hardCap = this.config.hardCapBytes;
       const stdoutChunks = [];
@@ -21597,7 +21740,15 @@ var SubprocessExecutor = class {
           stdout += `
 [output capped at ${formatBytes(hardCap)} \u2014 process killed]`;
         }
+        if (shellCode && stdout) {
+          const filtered = applyCommandFilter(shellCode, stdout);
+          if (filtered.filtered) {
+            stdout = filtered.output;
+          }
+        }
+        stdout = stripAnsi(stdout);
         if (stdout.length > 1e4) {
+          stdout = stripProgressLines(stdout);
           stdout = deduplicateLines(stdout);
           stdout = groupErrorLines(stdout);
         }
@@ -22013,6 +22164,7 @@ function hasBun(runtimes) {
 }
 
 // src/stats.ts
+import { readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "node:fs";
 var BAR_WIDTH = 20;
 function asciiBar(ratio, width = BAR_WIDTH) {
   const filled = Math.round(ratio * width);
@@ -22032,6 +22184,10 @@ var SessionTracker = class {
     bytesSandboxed: 0,
     sessionStart: Date.now()
   };
+  cumulativeFile;
+  constructor(cumulativeFile) {
+    this.cumulativeFile = cumulativeFile ?? null;
+  }
   trackCall(toolName, responseBytes) {
     this.stats.calls[toolName] = (this.stats.calls[toolName] ?? 0) + 1;
     this.stats.bytesReturned[toolName] = (this.stats.bytesReturned[toolName] ?? 0) + responseBytes;
@@ -22045,6 +22201,47 @@ var SessionTracker = class {
   getSnapshot() {
     return { ...this.stats };
   }
+  /** Load cumulative stats from disk */
+  loadCumulative() {
+    if (!this.cumulativeFile) return null;
+    try {
+      const data = readFileSync2(this.cumulativeFile, "utf-8");
+      return JSON.parse(data);
+    } catch {
+      return null;
+    }
+  }
+  /** Save current session stats to cumulative file */
+  saveCumulative() {
+    if (!this.cumulativeFile) return;
+    const snap = this.stats;
+    const keptOut = snap.bytesIndexed + snap.bytesSandboxed;
+    const totalReturned = Object.values(snap.bytesReturned).reduce((a, b) => a + b, 0);
+    const cumulative = this.loadCumulative() ?? {
+      totalBytesSaved: 0,
+      totalBytesProcessed: 0,
+      totalCalls: 0,
+      totalSessions: 0,
+      firstSeen: (/* @__PURE__ */ new Date()).toISOString(),
+      lastSeen: (/* @__PURE__ */ new Date()).toISOString(),
+      perCommand: {}
+    };
+    cumulative.totalBytesSaved += keptOut;
+    cumulative.totalBytesProcessed += keptOut + totalReturned;
+    cumulative.totalCalls += Object.values(snap.calls).reduce((a, b) => a + b, 0);
+    cumulative.totalSessions += 1;
+    cumulative.lastSeen = (/* @__PURE__ */ new Date()).toISOString();
+    for (const [name, calls] of Object.entries(snap.calls)) {
+      if (!cumulative.perCommand[name]) {
+        cumulative.perCommand[name] = { calls: 0, bytesSaved: 0 };
+      }
+      cumulative.perCommand[name].calls += calls;
+    }
+    try {
+      writeFileSync2(this.cumulativeFile, JSON.stringify(cumulative, null, 2));
+    } catch {
+    }
+  }
   formatReport() {
     const snap = this.stats;
     const elapsed = Date.now() - snap.sessionStart;
@@ -22105,6 +22302,18 @@ var SessionTracker = class {
       `
 Context-compress kept ${formatBytes(keptOut)} out of context (${reductionPct}% savings).`
     );
+    const cumulative = this.loadCumulative();
+    if (cumulative) {
+      lines.push("\n## Cumulative Savings (All Sessions)\n");
+      lines.push("| Metric | Value |");
+      lines.push("|--------|-------|");
+      lines.push(`| Sessions tracked | ${cumulative.totalSessions} |`);
+      lines.push(`| Total data processed | ${formatBytes(cumulative.totalBytesProcessed)} |`);
+      lines.push(`| Total kept out of context | ${formatBytes(cumulative.totalBytesSaved)} |`);
+      const cumTokensMid = Math.round(cumulative.totalBytesSaved / 4);
+      lines.push(`| Est. total tokens saved | ~${cumTokensMid.toLocaleString()} |`);
+      lines.push(`| Tracking since | ${cumulative.firstSeen.split("T")[0]} |`);
+    }
     return lines.join("\n");
   }
 };
@@ -22722,7 +22931,7 @@ function getVersion() {
   try {
     const __dirname = dirname(fileURLToPath(import.meta.url));
     const pkgPath = join4(__dirname, "..", "package.json");
-    const pkg = JSON.parse(readFileSync2(pkgPath, "utf-8"));
+    const pkg = JSON.parse(readFileSync3(pkgPath, "utf-8"));
     return pkg.version ?? "1.0.0";
   } catch {
     return "1.0.0";
@@ -22757,7 +22966,8 @@ async function createServer(config3) {
     store = new ContentStore(":memory:");
     dbFallback = true;
   }
-  const tracker = new SessionTracker();
+  const cumulativeFile = config3.persistDb ? join4(config3.dbDir ?? join4(projectDir, ".context-compress"), "stats.json") : void 0;
+  const tracker = new SessionTracker(cumulativeFile);
   let activeExecutions = 0;
   const MAX_CONCURRENT_EXECUTIONS = 8;
   const EXECUTION_LIMIT_ERROR = "Error: too many concurrent executions. Try again shortly.";
@@ -22796,6 +23006,10 @@ Searchable terms: ${terms.join(", ")}
     return compactLabel(filtered, config3.compressionLevel);
   }
   const shutdown = () => {
+    try {
+      tracker.saveCumulative();
+    } catch {
+    }
     try {
       executor.shutdown();
     } catch {
@@ -22974,7 +23188,7 @@ ${result.stderr}`;
               ]
             };
           }
-          text = readFileSync2(absPath, "utf-8");
+          text = readFileSync3(absPath, "utf-8");
           label = source ?? filePath;
         } catch (e) {
           const msg = e instanceof Error ? e.message : String(e);
@@ -23255,6 +23469,7 @@ Searchable terms: ${terms.join(", ")}`;
     "Returns context consumption statistics for the current session. Shows total bytes returned to context, breakdown by tool, call counts, estimated token usage, context savings ratio, and visual charts.",
     {},
     async () => {
+      tracker.saveCumulative();
       const report = tracker.formatReport();
       tracker.trackCall("stats", Buffer.byteLength(report));
       return { content: [{ type: "text", text: report }] };