@aexol/spectral 0.9.58 → 0.9.59

package/dist/memory/tool-output-compressor.js

@@ -28,17 +28,10 @@
  *    - Log output: deduplicate repeated lines
  *    - Docker/build output: collapse progress lines
  */
+import { DEFAULT_COMPACTION_POLICY, } from "../sdk/coding-agent/core/compaction/policy.js";
 import { debugLog } from "./debug-log.js";
 export const DEFAULT_COMPRESSOR_CONFIG = {
-    enabled: true,
-    maxResultChars: 8000,
-    maxReadLines: 500,
-    maxLsLines: 100,
-    maxSearchLines: 200,
-    stripAnsi: true,
-    stripComments: true,
-    testFailuresOnly: true,
-    compactGit: true,
+    ...DEFAULT_COMPACTION_POLICY.toolOutputCompressor,
 };
 // ============================================================================
 // ANSI Stripping
@@ -91,19 +84,41 @@ function stripComments(content, ext) {
     const result = [];
     let inBlockComment = false;
     for (const line of lines) {
-        const trimmed = line.trim();
-        // Handle block comments
+        let processed = line;
+        // Remove only block-comment segments so inline code before/after survives.
         if (patterns.blockStart && patterns.blockEnd) {
-            if (!inBlockComment && trimmed.includes(patterns.blockStart)) {
-                inBlockComment = true;
-            }
-            if (inBlockComment) {
-                if (trimmed.includes(patterns.blockEnd)) {
+            let remaining = processed;
+            let withoutBlocks = "";
+            while (remaining) {
+                if (inBlockComment) {
+                    const endIdx = remaining.indexOf(patterns.blockEnd);
+                    if (endIdx < 0) {
+                        remaining = "";
+                        break;
+                    }
+                    remaining = remaining.slice(endIdx + patterns.blockEnd.length);
                     inBlockComment = false;
+                    continue;
+                }
+                const startIdx = remaining.indexOf(patterns.blockStart);
+                if (startIdx < 0) {
+                    withoutBlocks += remaining;
+                    remaining = "";
+                    break;
                 }
-                continue;
+                withoutBlocks += remaining.slice(0, startIdx);
+                remaining = remaining.slice(startIdx + patterns.blockStart.length);
+                const endIdx = remaining.indexOf(patterns.blockEnd);
+                if (endIdx < 0) {
+                    inBlockComment = true;
+                    remaining = "";
+                    break;
+                }
+                remaining = remaining.slice(endIdx + patterns.blockEnd.length);
             }
+            processed = withoutBlocks;
         }
+        const trimmed = processed.trim();
         // Skip line comments
         if (patterns.line && trimmed.startsWith(patterns.line)) {
             continue;
@@ -112,7 +127,7 @@ function stripComments(content, ext) {
         if (!trimmed)
             continue;
         // Remove trailing whitespace
-        result.push(line.replace(/\s+$/, ""));
+        result.push(processed.replace(/\s+$/, ""));
     }
     return result.join("\n");
 }
@@ -218,17 +233,24 @@ function compressReadOutput(event, config) {
 // Bash Compressor
 // ============================================================================
 /** Commands whose output should be filtered to failures only */
-const TEST_COMMANDS = [
-    "jest", "vitest", "pytest", "go test", "cargo test",
-    "rspec", "rake test", "playwright test", "npx playwright",
-    "npm test", "npm run test", "yarn test", "pnpm test",
-    "bun test",
+const TEST_COMMAND_PATTERNS = [
+    /(?:^|[;&|()]\s*)(?:npx\s+|pnpm\s+(?:exec|dlx)\s+|yarn\s+(?:exec\s+)?|bunx\s+)?(?:jest|vitest|pytest|rspec)\b/,
+    /(?:^|[;&|()]\s*)(?:go|cargo)\s+test\b/,
+    /(?:^|[;&|()]\s*)rake\s+test\b/,
+    /(?:^|[;&|()]\s*)(?:npx\s+)?playwright\s+test\b/,
+    /(?:^|[;&|()]\s*)(?:npm|yarn|pnpm|bun)\s+(?:run\s+)?test(?::[\w.-]+)?\b/,
+    /(?:^|[;&|()]\s*)deno\s+(?:task\s+)?test\b/,
 ];
 /** Commands where git-like compacting should apply */
-const GIT_COMMANDS = [
-    "git status", "git diff", "git log", "git show",
-    "git push", "git pull", "git fetch", "git add",
-    "git commit", "git branch", "git stash",
+const GIT_COMMAND_PATTERNS = [
+    /(?:^|[;&|()]\s*)git\s+(?:status|diff|log|show|push|pull|fetch|add|commit|branch|stash)\b/,
+];
+/** Commands where repeated progress-line dedupe is especially useful */
+const BUILD_COMMAND_PATTERNS = [
+    /(?:^|[;&|()]\s*)(?:npm|yarn|pnpm|bun)\s+(?:run\s+)?(?:build|compile)\b/,
+    /(?:^|[;&|()]\s*)(?:npx\s+)?(?:tsc|esbuild|webpack)\b/,
+    /(?:^|[;&|()]\s*)(?:npx\s+)?(?:vite|next)\s+build\b/,
+    /(?:^|[;&|()]\s*)deno\s+(?:task\s+)?(?:build|compile)\b/,
 ];
 /** Patterns to strip from git output */
 const GIT_NOISE_PATTERNS = [
@@ -241,19 +263,17 @@ const GIT_NOISE_PATTERNS = [
     /^\(use "git/,
     /^\(create\/copy files/,
 ];
+function normalizeShellCommand(command) {
+    return command.toLowerCase().replace(/\s+/g, " ").trim();
+}
 function detectCommandType(command) {
-    const base = command.split(/\s+/).slice(0, 3).join(" ").toLowerCase();
-    for (const testCmd of TEST_COMMANDS) {
-        if (base.startsWith(testCmd))
-            return "test";
-    }
-    for (const gitCmd of GIT_COMMANDS) {
-        if (base.startsWith(gitCmd))
-            return "git";
-    }
-    if (/\b(build|compile|tsc|esbuild|webpack|vite build|next build)\b/.test(base)) {
+    const normalized = normalizeShellCommand(command);
+    if (TEST_COMMAND_PATTERNS.some((pattern) => pattern.test(normalized)))
+        return "test";
+    if (GIT_COMMAND_PATTERNS.some((pattern) => pattern.test(normalized)))
+        return "git";
+    if (BUILD_COMMAND_PATTERNS.some((pattern) => pattern.test(normalized)))
         return "build";
-    }
     return "other";
 }
 function filterGitOutput(content) {
@@ -277,13 +297,19 @@ function filterTestOutput(content) {
     const result = [];
     let failureSection = false;
     let summarySection = false;
+    let sawRecognizedSignal = false;
+    const failurePattern = /^\s*(?:FAIL\b|FAILED\b|AssertionError\b|Error:|●|❯|×|\d+\))/i;
+    const summaryPattern = /^\s*(?:Test Suites|Test Files|Tests|Snapshots|Time|Duration|Ran all|Ran):/i;
+    const vitestSummaryPattern = /^\s*(?:Test Files|Tests|Duration)\s+\d|^\s*(?:Start at)\b/i;
     for (const line of lines) {
         // Start of failure section
-        if (/^FAIL|^\s*●|^\s*\d+\)|^\s*FAILED|^AssertionError|^Error:/i.test(line)) {
+        if (failurePattern.test(line)) {
+            sawRecognizedSignal = true;
             failureSection = true;
         }
         // Start of summary section
-        if (/^(Test Suites|Tests|Snapshots|Time|Ran all):/i.test(line)) {
+        if (summaryPattern.test(line) || vitestSummaryPattern.test(line)) {
+            sawRecognizedSignal = true;
             summarySection = true;
             failureSection = false;
         }
@@ -292,16 +318,162 @@ function filterTestOutput(content) {
             result.push(line);
         }
     }
-    // If no failures found, just return a summary
+    // If no failures found, keep only recognized summaries. If the output has no
+    // known failure/summary signal, preserve it rather than inventing success.
     if (result.length === 0) {
-        const summaryLines = lines.filter((l) => /^(Tests|Test Suites|Snapshots|Time|Ran):/i.test(l.trim()));
+        const summaryLines = lines.filter((l) => summaryPattern.test(l) || vitestSummaryPattern.test(l));
         if (summaryLines.length > 0) {
             return summaryLines.join("\n");
         }
-        return "All tests passed.";
+        return sawRecognizedSignal ? "No recognized test failure details found." : content;
     }
     return result.join("\n");
 }
+// ============================================================================
+// Structured Output Summarization
+// ============================================================================
+const STRUCTURED_SUMMARY_MIN_CHARS = 500;
+const STRUCTURED_SUMMARY_MAX_KEYS = 10;
+const STRUCTURED_SUMMARY_MAX_FIELDS = 8;
+const STRUCTURED_SUMMARY_MAX_RECORDS_TO_INSPECT = 200;
+const SAFE_LABEL_MAX_CHARS = 48;
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function safeLabel(label) {
+    if (label.length <= SAFE_LABEL_MAX_CHARS)
+        return label;
+    return `${label.slice(0, SAFE_LABEL_MAX_CHARS - 1)}…`;
+}
+function describeJsonType(value) {
+    if (value === null)
+        return "null";
+    if (Array.isArray(value))
+        return `array(${value.length})`;
+    if (isRecord(value))
+        return `object(${Object.keys(value).length} keys)`;
+    return typeof value;
+}
+function summarizeKeyCounts(records) {
+    const keyCounts = new Map();
+    for (const record of records.slice(0, STRUCTURED_SUMMARY_MAX_RECORDS_TO_INSPECT)) {
+        for (const key of Object.keys(record)) {
+            keyCounts.set(key, (keyCounts.get(key) ?? 0) + 1);
+        }
+    }
+    return [...keyCounts.entries()]
+        .sort(([leftKey, leftCount], [rightKey, rightCount]) => rightCount - leftCount || leftKey.localeCompare(rightKey))
+        .slice(0, STRUCTURED_SUMMARY_MAX_KEYS)
+        .map(([key, count]) => `${safeLabel(key)}(${count})`)
+        .join(", ");
+}
+function summarizeRecordShape(record) {
+    return Object.keys(record)
+        .sort((left, right) => left.localeCompare(right))
+        .slice(0, STRUCTURED_SUMMARY_MAX_FIELDS)
+        .map((key) => `${safeLabel(key)}:${describeJsonType(record[key])}`)
+        .join(", ");
+}
+function summarizeJsonValue(value) {
+    if (Array.isArray(value)) {
+        const itemTypes = new Map();
+        const records = [];
+        for (const item of value) {
+            const type = describeJsonType(item);
+            itemTypes.set(type, (itemTypes.get(type) ?? 0) + 1);
+            if (isRecord(item))
+                records.push(item);
+        }
+        const lines = [
+            "JSON summary:",
+            "- type: array",
+            `- items: ${value.length}`,
+            `- item types: ${[...itemTypes.entries()].map(([type, count]) => `${type}=${count}`).join(", ")}`,
+        ];
+        if (records.length > 0) {
+            const inspected = Math.min(records.length, STRUCTURED_SUMMARY_MAX_RECORDS_TO_INSPECT);
+            lines.push(`- object keys inspected: ${inspected}/${records.length}`);
+            const keyCounts = summarizeKeyCounts(records);
+            if (keyCounts)
+                lines.push(`- top keys: ${keyCounts}`);
+            lines.push(`- sample shape: ${summarizeRecordShape(records[0])}`);
+        }
+        return lines.join("\n");
+    }
+    if (isRecord(value)) {
+        const keys = Object.keys(value).sort((left, right) => left.localeCompare(right));
+        const lines = [
+            "JSON summary:",
+            "- type: object",
+            `- keys: ${keys.length}`,
+            `- key preview: ${keys.slice(0, STRUCTURED_SUMMARY_MAX_KEYS).map(safeLabel).join(", ")}${keys.length > STRUCTURED_SUMMARY_MAX_KEYS ? `, … +${keys.length - STRUCTURED_SUMMARY_MAX_KEYS} more` : ""}`,
+            `- field types: ${summarizeRecordShape(value)}`,
+        ];
+        return lines.join("\n");
+    }
+    return undefined;
+}
+function tryParseJson(input) {
+    try {
+        return JSON.parse(input);
+    }
+    catch {
+        return undefined;
+    }
+}
+function summarizeNdjson(trimmed) {
+    const lines = trimmed.split("\n").filter((line) => line.trim());
+    if (lines.length < 2)
+        return undefined;
+    const parsedRecords = [];
+    for (let index = 0; index < lines.length; index++) {
+        const line = lines[index];
+        const parsed = tryParseJson(line);
+        if (parsed === undefined)
+            return undefined;
+        if (index < STRUCTURED_SUMMARY_MAX_RECORDS_TO_INSPECT) {
+            parsedRecords.push(parsed);
+        }
+    }
+    const typeCounts = new Map();
+    const records = [];
+    for (const record of parsedRecords) {
+        const type = describeJsonType(record);
+        typeCounts.set(type, (typeCounts.get(type) ?? 0) + 1);
+        if (isRecord(record))
+            records.push(record);
+    }
+    const linesOut = [
+        "NDJSON summary:",
+        `- records: ${lines.length}`,
+        `- inspected: ${parsedRecords.length}`,
+        `- record types: ${[...typeCounts.entries()].map(([type, count]) => `${type}=${count}`).join(", ")}`,
+    ];
+    if (records.length > 0) {
+        const keyCounts = summarizeKeyCounts(records);
+        if (keyCounts)
+            linesOut.push(`- top keys: ${keyCounts}`);
+        linesOut.push(`- sample shape: ${summarizeRecordShape(records[0])}`);
+    }
+    return linesOut.join("\n");
+}
+function summarizeStructuredOutput(content) {
+    const trimmed = content.trim();
+    if (trimmed.length < STRUCTURED_SUMMARY_MIN_CHARS)
+        return undefined;
+    if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
+        const parsed = tryParseJson(trimmed);
+        if (parsed !== undefined) {
+            const summary = summarizeJsonValue(parsed);
+            if (summary && summary.length < content.length)
+                return summary;
+        }
+    }
+    const ndjsonSummary = summarizeNdjson(trimmed);
+    if (ndjsonSummary && ndjsonSummary.length < content.length)
+        return ndjsonSummary;
+    return undefined;
+}
 function compressBashOutput(event, config) {
     let content = event.content
         .filter((c) => c.type === "text")
@@ -335,6 +507,10 @@ function compressBashOutput(event, config) {
             }
             break;
     }
+    const structuredSummary = summarizeStructuredOutput(content);
+    if (structuredSummary) {
+        content = structuredSummary;
+    }
     // Deduplicate repeated lines for all outputs
     {
         const deduped = deduplicateRepeatedLines(content);
@@ -348,6 +524,101 @@ function compressBashOutput(event, config) {
     }
     return content;
 }
+const PATH_TREE_MAX_DEPTH = 3;
+const PATH_TREE_MAX_CHILDREN = 8;
+const PATH_TREE_MAX_FILE_PREVIEW = 4;
+function createPathTreeNode() {
+    return { totalPaths: 0, files: [], children: new Map() };
+}
+function comparePathPart(left, right) {
+    return left.localeCompare(right, undefined, { numeric: true });
+}
+function normalizeListedPath(path) {
+    let normalized = path.trim();
+    while (normalized.startsWith("./"))
+        normalized = normalized.slice(2);
+    return normalized.replace(/\/+$/, "");
+}
+function addPathToTree(root, path) {
+    const normalized = normalizeListedPath(path);
+    if (!normalized)
+        return;
+    const parts = normalized.split("/").filter(Boolean);
+    if (parts.length === 0)
+        return;
+    root.totalPaths++;
+    let node = root;
+    for (let index = 0; index < parts.length; index++) {
+        const part = parts[index];
+        const isLeaf = index === parts.length - 1;
+        if (isLeaf) {
+            node.files.push(part);
+            continue;
+        }
+        let child = node.children.get(part);
+        if (!child) {
+            child = createPathTreeNode();
+            node.children.set(part, child);
+        }
+        child.totalPaths++;
+        node = child;
+    }
+}
+function formatPreview(items, omittedLabel) {
+    const sorted = [...items].sort(comparePathPart);
+    const preview = sorted.slice(0, PATH_TREE_MAX_FILE_PREVIEW).map(safeLabel).join(", ");
+    const omitted = sorted.length - PATH_TREE_MAX_FILE_PREVIEW;
+    if (omitted <= 0)
+        return preview;
+    return `${preview}, … +${omitted} ${omittedLabel}`;
+}
+function renderPathTreeNode(name, node, depth, lines) {
+    const indent = "  ".repeat(depth - 1);
+    const fileSuffix = node.files.length > 0 ? `, ${node.files.length} files` : "";
+    lines.push(`${indent}${name}/ (${node.totalPaths} paths${fileSuffix})`);
+    const childEntries = [...node.children.entries()].sort(([left], [right]) => comparePathPart(left, right));
+    if (depth >= PATH_TREE_MAX_DEPTH) {
+        if (childEntries.length > 0) {
+            const childPreview = childEntries
+                .slice(0, PATH_TREE_MAX_FILE_PREVIEW)
+                .map(([childName, child]) => `${safeLabel(childName)}/(${child.totalPaths})`);
+            const omitted = childEntries.length - PATH_TREE_MAX_FILE_PREVIEW;
+            lines.push(`${indent}  dirs: ${childPreview.join(", ")}${omitted > 0 ? `, … +${omitted} more` : ""}`);
+        }
+        if (node.files.length > 0)
+            lines.push(`${indent}  files: ${formatPreview(node.files, "more")}`);
+        return;
+    }
+    for (const [childName, child] of childEntries.slice(0, PATH_TREE_MAX_CHILDREN)) {
+        renderPathTreeNode(childName, child, depth + 1, lines);
+    }
+    const omittedChildren = childEntries.length - PATH_TREE_MAX_CHILDREN;
+    if (omittedChildren > 0) {
+        lines.push(`${indent}  … +${omittedChildren} more dirs`);
+    }
+    if (node.files.length > 0)
+        lines.push(`${indent}  files: ${formatPreview(node.files, "more")}`);
+}
+function summarizePathTree(content) {
+    const paths = content.split("\n").map(normalizeListedPath).filter(Boolean);
+    if (paths.length === 0)
+        return undefined;
+    const root = createPathTreeNode();
+    for (const path of paths)
+        addPathToTree(root, path);
+    const lines = [`${root.totalPaths} paths grouped by directory:`];
+    const topEntries = [...root.children.entries()].sort(([left], [right]) => comparePathPart(left, right));
+    for (const [name, node] of topEntries.slice(0, PATH_TREE_MAX_CHILDREN)) {
+        renderPathTreeNode(name, node, 1, lines);
+    }
+    const omittedTop = topEntries.length - PATH_TREE_MAX_CHILDREN;
+    if (omittedTop > 0)
+        lines.push(`… +${omittedTop} more top-level dirs`);
+    if (root.files.length > 0)
+        lines.push(`./ (${root.files.length} files: ${formatPreview(root.files, "more")})`);
+    const summary = lines.join("\n");
+    return summary.length < content.length ? summary : undefined;
+}
 // ============================================================================
 // Ls Compressor
 // ============================================================================
@@ -363,21 +634,7 @@ function compressLsOutput(event, config) {
     }
     const lines = content.split("\n");
     if (lines.length > config.maxLsLines) {
-        // Group by directory when listing many files
-        const groups = new Map();
-        for (const line of lines) {
-            const trimmed = line.trim();
-            if (!trimmed)
-                continue;
-            const slashIdx = trimmed.lastIndexOf("/");
-            const dir = slashIdx >= 0 ? trimmed.slice(0, slashIdx) : ".";
-            groups.set(dir, (groups.get(dir) ?? 0) + 1);
-        }
-        const grouped = [];
-        for (const [dir, count] of [...groups.entries()].sort(([a], [b]) => a.localeCompare(b))) {
-            grouped.push(`${dir}/  (${count} files)`);
-        }
-        return grouped.join("\n");
+        return summarizePathTree(content) ?? content;
     }
     return content;
 }
@@ -436,36 +693,82 @@ function compressFindOutput(event, config) {
     // Group by directory
     const lines = content.split("\n").filter((l) => l.trim());
     if (lines.length > config.maxSearchLines) {
-        const groups = new Map();
-        for (const line of lines) {
-            const trimmed = line.trim();
-            if (!trimmed)
-                continue;
-            const slashIdx = trimmed.lastIndexOf("/");
-            const dir = slashIdx >= 0 ? trimmed.slice(0, slashIdx) : ".";
-            if (!groups.has(dir))
-                groups.set(dir, []);
-            groups.get(dir).push(slashIdx >= 0 ? trimmed.slice(slashIdx + 1) : trimmed);
-        }
-        const grouped = [];
-        for (const [dir, files] of [...groups.entries()].sort(([a], [b]) => a.localeCompare(b))) {
-            if (files.length === 1) {
-                grouped.push(`${dir}/${files[0]}`);
-            }
-            else if (files.length <= 5) {
-                grouped.push(`${dir}/  (${files.length} files: ${files.join(", ")})`);
-            }
-            else {
-                grouped.push(`${dir}/  (${files.length} files: ${files.slice(0, 3).join(", ")}... +${files.length - 3} more)`);
-            }
-        }
-        return grouped.join("\n");
+        return summarizePathTree(content) ?? content;
     }
     return content;
 }
+const statsByRuntime = new WeakMap();
+function createTelemetry() {
+    return { events: 0, originalChars: 0, compressedChars: 0, byTool: {} };
+}
+function cloneTelemetry(stats) {
+    const byTool = {};
+    for (const [toolName, toolStats] of Object.entries(stats.byTool)) {
+        byTool[toolName] = { ...toolStats };
+    }
+    return {
+        events: stats.events,
+        originalChars: stats.originalChars,
+        compressedChars: stats.compressedChars,
+        byTool,
+    };
+}
+function getMutableTelemetry(runtime) {
+    let stats = statsByRuntime.get(runtime);
+    if (!stats) {
+        stats = createTelemetry();
+        statsByRuntime.set(runtime, stats);
+    }
+    return stats;
+}
+export function getToolOutputCompressionTelemetry(runtime) {
+    return cloneTelemetry(getMutableTelemetry(runtime));
+}
+export function resetToolOutputCompressionTelemetry(runtime) {
+    statsByRuntime.set(runtime, createTelemetry());
+}
+function recordCompression(runtime, toolName, originalChars, compressedChars) {
+    const stats = getMutableTelemetry(runtime);
+    stats.events++;
+    stats.originalChars += originalChars;
+    stats.compressedChars += compressedChars;
+    const toolStats = stats.byTool[toolName] ?? { events: 0, originalChars: 0, compressedChars: 0 };
+    toolStats.events++;
+    toolStats.originalChars += originalChars;
+    toolStats.compressedChars += compressedChars;
+    stats.byTool[toolName] = toolStats;
+    return {
+        toolName,
+        originalChars,
+        compressedChars,
+        savingsPercent: Math.round((1 - compressedChars / Math.max(1, originalChars)) * 10_000) / 100,
+    };
+}
+function formatCompressionHeader(stats) {
+    return `[tool-output-compressor tool=${stats.toolName} originalChars=${stats.originalChars} bodyChars=${stats.compressedChars} savings=${stats.savingsPercent}%]`;
+}
+function resolveCompressorConfig(ctx) {
+    const manager = ctx.settingsManager;
+    return manager?.getCompactionPolicy?.().toolOutputCompressor ?? DEFAULT_COMPRESSOR_CONFIG;
+}
+function compressedContentResult(runtime, event, toolName, original, compressed) {
+    if (!compressed || compressed === original)
+        return undefined;
+    const stats = recordCompression(runtime, toolName, original.length, compressed.length);
+    debugLog("compressor.event", {
+        toolName: stats.toolName,
+        originalChars: stats.originalChars,
+        compressedChars: stats.compressedChars,
+        savingsPercent: stats.savingsPercent,
+    });
+    const replacementText = `${formatCompressionHeader(stats)}\n${compressed}`;
+    return {
+        content: [...event.content.filter((c) => c.type !== "text"), { type: "text", text: replacementText }],
+    };
+}
 export function registerToolOutputCompressor(ext, runtime) {
-    const config = { ...DEFAULT_COMPRESSOR_CONFIG };
     ext.on("tool_result", (_event, _ctx) => {
+        const config = resolveCompressorConfig(_ctx);
         if (!config.enabled)
             return;
         // Only apply compression for known tool types
@@ -476,17 +779,7 @@ export function registerToolOutputCompressor(ext, runtime) {
                 .map((c) => c.text)
                 .join("\n");
             const compressed = compressReadOutput(event, config);
-            if (compressed && compressed !== original) {
-                debugLog("compressor.read", {
-                    originalLen: original.length,
-                    compressedLen: compressed.length,
-                    savings: ((1 - compressed.length / Math.max(1, original.length)) * 100).toFixed(1) + "%",
-                });
-                return {
-                    content: [...event.content.filter((c) => c.type !== "text"), { type: "text", text: compressed }],
-                };
-            }
-            return;
+            return compressedContentResult(runtime, event, "read", original, compressed);
         }
         if (_event.toolName === "bash") {
             const event = _event;
@@ -495,19 +788,7 @@ export function registerToolOutputCompressor(ext, runtime) {
                 .map((c) => c.text)
                 .join("\n");
             const compressed = compressBashOutput(event, config);
-            if (compressed && compressed !== original) {
-                const command = event.input?.command ?? "";
-                debugLog("compressor.bash", {
-                    command: command.slice(0, 80),
-                    originalLen: original.length,
-                    compressedLen: compressed.length,
-                    savings: ((1 - compressed.length / Math.max(1, original.length)) * 100).toFixed(1) + "%",
-                });
-                return {
-                    content: [...event.content.filter((c) => c.type !== "text"), { type: "text", text: compressed }],
-                };
-            }
-            return;
+            return compressedContentResult(runtime, event, "bash", original, compressed);
         }
         if (_event.toolName === "ls") {
             const event = _event;
@@ -516,16 +797,7 @@ export function registerToolOutputCompressor(ext, runtime) {
                 .map((c) => c.text)
                 .join("\n");
             const compressed = compressLsOutput(event, config);
-            if (compressed && compressed !== original) {
-                debugLog("compressor.ls", {
-                    originalLen: original.length,
-                    compressedLen: compressed.length,
-                });
-                return {
-                    content: [...event.content.filter((c) => c.type !== "text"), { type: "text", text: compressed }],
-                };
-            }
-            return;
+            return compressedContentResult(runtime, event, "ls", original, compressed);
         }
         if (_event.toolName === "grep") {
             const event = _event;
@@ -534,16 +806,7 @@ export function registerToolOutputCompressor(ext, runtime) {
                 .map((c) => c.text)
                 .join("\n");
             const compressed = compressGrepOutput(event, config);
-            if (compressed && compressed !== original) {
-                debugLog("compressor.grep", {
-                    originalLen: original.length,
-                    compressedLen: compressed.length,
-                });
-                return {
-                    content: [...event.content.filter((c) => c.type !== "text"), { type: "text", text: compressed }],
-                };
-            }
-            return;
+            return compressedContentResult(runtime, event, "grep", original, compressed);
         }
         if (_event.toolName === "find") {
             const event = _event;
@@ -552,16 +815,7 @@ export function registerToolOutputCompressor(ext, runtime) {
                 .map((c) => c.text)
                 .join("\n");
             const compressed = compressFindOutput(event, config);
-            if (compressed && compressed !== original) {
-                debugLog("compressor.find", {
-                    originalLen: original.length,
-                    compressedLen: compressed.length,
-                });
-                return {
-                    content: [...event.content.filter((c) => c.type !== "text"), { type: "text", text: compressed }],
-                };
-            }
-            return;
+            return compressedContentResult(runtime, event, "find", original, compressed);
         }
         // Unknown tool types: do nothing
         return;

package/dist/memory/tools/compact-context.d.ts

@@ -0,0 +1,5 @@
+import { type ExtensionAPI } from "../../sdk/coding-agent/index.js";
+import type { Runtime } from "../runtime.js";
+export declare const COMPACT_CONTEXT_TOOL_NAME = "compact_context";
+export declare function registerCompactContextTool(ext: ExtensionAPI, runtime: Runtime): void;
+//# sourceMappingURL=compact-context.d.ts.map

package/dist/memory/tools/compact-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compact-context.d.ts","sourceRoot":"","sources":["../../../src/memory/tools/compact-context.ts"],"names":[],"mappings":"AAYA,OAAO,EAAc,KAAK,YAAY,EAAyB,MAAM,iCAAiC,CAAC;AAIvG,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAE7C,eAAO,MAAM,yBAAyB,oBAAoB,CAAC;AAkmB3D,wBAAgB,0BAA0B,CAAC,GAAG,EAAE,YAAY,EAAE,OAAO,EAAE,OAAO,GAAG,IAAI,CAmQpF"}