@astudioplus/compressor 0.1.0

package/dist/hook/post-tool-use.d.ts

@@ -0,0 +1,5 @@
+import type { MarkerStyle, Mode } from '../engine/types.ts';
+export interface HookResult {
+    output: string | null;
+}
+export declare function handlePostToolUse(payloadJson: string, mode: Mode, markerStyle?: MarkerStyle): HookResult;

package/dist/hook/post-tool-use.js

@@ -0,0 +1,57 @@
+import { compressCall, isRecord, pickLeaf, rebuildWithLeaf, recordCompression } from "./core.js";
+function toolKindFor(toolName) {
+    switch (toolName) {
+        case 'Read':
+            return 'read';
+        case 'Bash':
+            return 'bash';
+        case 'Grep':
+        case 'Glob':
+            return 'search';
+        default:
+            return 'other';
+    }
+}
+export function handlePostToolUse(payloadJson, mode, markerStyle) {
+    try {
+        if (mode === 'full') {
+            return { output: null };
+        }
+        const payload = JSON.parse(payloadJson);
+        if (!isRecord(payload)) {
+            return { output: null };
+        }
+        const toolName = typeof payload['tool_name'] === 'string' ? payload['tool_name'] : '';
+        const toolInput = isRecord(payload['tool_input']) ? payload['tool_input'] : {};
+        const tool = toolKindFor(toolName);
+        const leaf = pickLeaf(payload['tool_response'], tool);
+        if (leaf === null) {
+            return { output: null };
+        }
+        const call = {
+            toolKind: tool,
+            targeted: tool === 'read' && (toolInput['offset'] != null || toolInput['limit'] != null),
+            text: leaf.text,
+        };
+        if (tool === 'read' && typeof toolInput['file_path'] === 'string') {
+            call.filePath = toolInput['file_path'];
+        }
+        const compressed = compressCall(call, mode, markerStyle);
+        if (!compressed.worthwhile) {
+            return { output: null };
+        }
+        recordCompression('claude-code', call, compressed, mode);
+        const updatedToolOutput = rebuildWithLeaf(payload['tool_response'], leaf.path, compressed.text);
+        return {
+            output: JSON.stringify({
+                hookSpecificOutput: {
+                    hookEventName: 'PostToolUse',
+                    updatedToolOutput,
+                },
+            }),
+        };
+    }
+    catch {
+        return { output: null };
+    }
+}

package/dist/hook-entry.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/hook-entry.js

@@ -0,0 +1,35 @@
+import process from 'node:process';
+import { settleThenExit } from "./hook/exit.js";
+import { handlePostToolUse } from "./hook/post-tool-use.js";
+// PostToolUse hook entry, bundled to dist/hook.js. Fail-open: any failure
+// means emit nothing and exit 0 so the original tool output passes through.
+function parseMode(argv) {
+    const idx = argv.indexOf('--mode');
+    const value = idx === -1 ? undefined : argv[idx + 1];
+    return value === 'full' || value === 'optimized' || value === 'slim' ? value : 'optimized';
+}
+/** Fail-open: unknown or missing style falls back to the policy default. */
+function parseMarkerStyle(argv) {
+    const idx = argv.indexOf('--marker-style');
+    const value = idx === -1 ? undefined : argv[idx + 1];
+    return value === 'plain' || value === 'deterrent' || value === 'informative'
+        ? value
+        : undefined;
+}
+async function main() {
+    const chunks = [];
+    for await (const chunk of process.stdin) {
+        chunks.push(typeof chunk === 'string' ? Buffer.from(chunk) : chunk);
+    }
+    const payload = Buffer.concat(chunks).toString('utf8');
+    return handlePostToolUse(payload, parseMode(process.argv), parseMarkerStyle(process.argv))
+        .output;
+}
+// Exit path shared with the copilot entry and the CLI subcommands
+// (src/hook/exit.ts): stdout first, ledger settle capped at 250ms, SIGKILL
+// on timeout so a stuck filesystem can never hang the agent.
+main().then((output) => {
+    settleThenExit(output).catch(() => process.exit(0));
+}, () => {
+    settleThenExit(null).catch(() => process.exit(0));
+});