@mauribadnights/clooks 0.1.0 → 0.2.0

package/dist/index.js

@@ -1,7 +1,7 @@
 "use strict";
 // clooks — public API exports
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.LOG_FILE = exports.METRICS_FILE = exports.PID_FILE = exports.MANIFEST_PATH = exports.CONFIG_DIR = exports.DEFAULT_PORT = exports.executeHandlers = exports.runDoctor = exports.getSettingsPath = exports.restore = exports.migrate = exports.MetricsCollector = exports.createDefaultManifest = exports.validateManifest = exports.loadManifest = exports.isDaemonRunning = exports.stopDaemon = exports.startDaemon = exports.createServer = void 0;
+exports.LLM_PRICING = exports.DEFAULT_LLM_MAX_TOKENS = exports.DEFAULT_LLM_TIMEOUT = exports.COSTS_FILE = exports.LOG_FILE = exports.METRICS_FILE = exports.PID_FILE = exports.MANIFEST_PATH = exports.CONFIG_DIR = exports.DEFAULT_PORT = exports.renderPromptTemplate = exports.prefetchContext = exports.resetClient = exports.calculateCost = exports.executeLLMHandlersBatched = exports.executeLLMHandler = exports.evaluateFilter = exports.executeHandlers = exports.runDoctor = exports.getSettingsPath = exports.restore = exports.migrate = exports.MetricsCollector = exports.createDefaultManifest = exports.validateManifest = exports.loadManifest = exports.isDaemonRunning = exports.stopDaemon = exports.startDaemon = exports.createServer = void 0;
 var server_js_1 = require("./server.js");
 Object.defineProperty(exports, "createServer", { enumerable: true, get: function () { return server_js_1.createServer; } });
 Object.defineProperty(exports, "startDaemon", { enumerable: true, get: function () { return server_js_1.startDaemon; } });
@@ -21,6 +21,16 @@ var doctor_js_1 = require("./doctor.js");
 Object.defineProperty(exports, "runDoctor", { enumerable: true, get: function () { return doctor_js_1.runDoctor; } });
 var handlers_js_1 = require("./handlers.js");
 Object.defineProperty(exports, "executeHandlers", { enumerable: true, get: function () { return handlers_js_1.executeHandlers; } });
+var filter_js_1 = require("./filter.js");
+Object.defineProperty(exports, "evaluateFilter", { enumerable: true, get: function () { return filter_js_1.evaluateFilter; } });
+var llm_js_1 = require("./llm.js");
+Object.defineProperty(exports, "executeLLMHandler", { enumerable: true, get: function () { return llm_js_1.executeLLMHandler; } });
+Object.defineProperty(exports, "executeLLMHandlersBatched", { enumerable: true, get: function () { return llm_js_1.executeLLMHandlersBatched; } });
+Object.defineProperty(exports, "calculateCost", { enumerable: true, get: function () { return llm_js_1.calculateCost; } });
+Object.defineProperty(exports, "resetClient", { enumerable: true, get: function () { return llm_js_1.resetClient; } });
+var prefetch_js_1 = require("./prefetch.js");
+Object.defineProperty(exports, "prefetchContext", { enumerable: true, get: function () { return prefetch_js_1.prefetchContext; } });
+Object.defineProperty(exports, "renderPromptTemplate", { enumerable: true, get: function () { return prefetch_js_1.renderPromptTemplate; } });
 var constants_js_1 = require("./constants.js");
 Object.defineProperty(exports, "DEFAULT_PORT", { enumerable: true, get: function () { return constants_js_1.DEFAULT_PORT; } });
 Object.defineProperty(exports, "CONFIG_DIR", { enumerable: true, get: function () { return constants_js_1.CONFIG_DIR; } });
@@ -28,3 +38,7 @@ Object.defineProperty(exports, "MANIFEST_PATH", { enumerable: true, get: functio
 Object.defineProperty(exports, "PID_FILE", { enumerable: true, get: function () { return constants_js_1.PID_FILE; } });
 Object.defineProperty(exports, "METRICS_FILE", { enumerable: true, get: function () { return constants_js_1.METRICS_FILE; } });
 Object.defineProperty(exports, "LOG_FILE", { enumerable: true, get: function () { return constants_js_1.LOG_FILE; } });
+Object.defineProperty(exports, "COSTS_FILE", { enumerable: true, get: function () { return constants_js_1.COSTS_FILE; } });
+Object.defineProperty(exports, "DEFAULT_LLM_TIMEOUT", { enumerable: true, get: function () { return constants_js_1.DEFAULT_LLM_TIMEOUT; } });
+Object.defineProperty(exports, "DEFAULT_LLM_MAX_TOKENS", { enumerable: true, get: function () { return constants_js_1.DEFAULT_LLM_MAX_TOKENS; } });
+Object.defineProperty(exports, "LLM_PRICING", { enumerable: true, get: function () { return constants_js_1.LLM_PRICING; } });

package/dist/llm.d.ts

@@ -0,0 +1,19 @@
+import type { LLMHandlerConfig, HandlerResult, HookInput, PrefetchContext, TokenUsage } from './types.js';
+/** Reset client (for testing) */
+export declare function resetClient(): void;
+/**
+ * Calculate cost in USD from token usage and model.
+ */
+export declare function calculateCost(model: string, usage: TokenUsage): number;
+/**
+ * Execute a single LLM handler: render prompt, call Messages API, return result.
+ */
+export declare function executeLLMHandler(handler: LLMHandlerConfig, input: HookInput, context: PrefetchContext): Promise<HandlerResult>;
+/**
+ * Execute multiple LLM handlers, batching those with the same batchGroup.
+ *
+ * Strategy: handlers with the same batchGroup get their prompts combined into
+ * a single API call with a structured multi-task prompt. Handlers without a
+ * batchGroup are executed individually.
+ */
+export declare function executeLLMHandlersBatched(handlers: LLMHandlerConfig[], input: HookInput, context: PrefetchContext): Promise<HandlerResult[]>;

package/dist/llm.js

@@ -0,0 +1,225 @@
+"use strict";
+// clooks LLM handler execution — Anthropic Messages API with batching
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resetClient = resetClient;
+exports.calculateCost = calculateCost;
+exports.executeLLMHandler = executeLLMHandler;
+exports.executeLLMHandlersBatched = executeLLMHandlersBatched;
+const prefetch_js_1 = require("./prefetch.js");
+const constants_js_1 = require("./constants.js");
+/** Lazy-loaded Anthropic SDK client */
+let anthropicClient = null;
+async function getClient() {
+    if (!anthropicClient) {
+        if (!process.env.ANTHROPIC_API_KEY) {
+            throw new Error('ANTHROPIC_API_KEY environment variable is not set. ' +
+                'LLM handlers require a valid API key.');
+        }
+        try {
+            // Dynamic import with variable to avoid TypeScript resolving the module at compile time
+            const sdkModule = '@anthropic-ai/sdk';
+            const { default: Anthropic } = await import(/* webpackIgnore: true */ sdkModule);
+            anthropicClient = new Anthropic();
+        }
+        catch (err) {
+            throw new Error('Anthropic SDK not installed. Run: npm install @anthropic-ai/sdk\n' +
+                'Then set ANTHROPIC_API_KEY environment variable.');
+        }
+    }
+    return anthropicClient;
+}
+/** Reset client (for testing) */
+function resetClient() {
+    anthropicClient = null;
+}
+/**
+ * Calculate cost in USD from token usage and model.
+ */
+function calculateCost(model, usage) {
+    const pricing = constants_js_1.LLM_PRICING[model];
+    if (!pricing)
+        return 0;
+    const inputCost = (usage.input_tokens / 1_000_000) * pricing.input;
+    const outputCost = (usage.output_tokens / 1_000_000) * pricing.output;
+    return inputCost + outputCost;
+}
+/**
+ * Execute a single LLM handler: render prompt, call Messages API, return result.
+ */
+async function executeLLMHandler(handler, input, context) {
+    const start = performance.now();
+    const timeout = handler.timeout ?? constants_js_1.DEFAULT_LLM_TIMEOUT;
+    const maxTokens = handler.maxTokens ?? constants_js_1.DEFAULT_LLM_MAX_TOKENS;
+    try {
+        const client = await getClient();
+        const prompt = (0, prefetch_js_1.renderPromptTemplate)(handler.prompt, input, context);
+        const apiCall = client.messages.create({
+            model: handler.model,
+            max_tokens: maxTokens,
+            messages: [{ role: 'user', content: prompt }],
+        });
+        const timeoutPromise = new Promise((_resolve, reject) => setTimeout(() => reject(new Error(`LLM handler timed out after ${timeout}ms`)), timeout));
+        const response = await Promise.race([apiCall, timeoutPromise]);
+        const text = response.content?.[0]?.text ?? '';
+        const usage = {
+            input_tokens: response.usage?.input_tokens ?? 0,
+            output_tokens: response.usage?.output_tokens ?? 0,
+        };
+        const cost_usd = calculateCost(handler.model, usage);
+        return {
+            id: handler.id,
+            ok: true,
+            output: { additionalContext: text },
+            duration_ms: performance.now() - start,
+            usage,
+            cost_usd,
+        };
+    }
+    catch (err) {
+        return {
+            id: handler.id,
+            ok: false,
+            error: err instanceof Error ? err.message : String(err),
+            duration_ms: performance.now() - start,
+        };
+    }
+}
+/**
+ * Execute a batched group of LLM handlers: combine prompts into a single
+ * multi-task API call, parse JSON response back into individual results.
+ */
+async function executeBatchGroup(handlers, input, context) {
+    const start = performance.now();
+    // Use model from first handler; warn if others differ
+    const model = handlers[0].model;
+    for (let i = 1; i < handlers.length; i++) {
+        if (handlers[i].model !== model) {
+            console.warn(`[clooks] Batch group "${handlers[0].batchGroup}": handler "${handlers[i].id}" ` +
+                `uses model "${handlers[i].model}" but batch uses "${model}". Using "${model}".`);
+        }
+    }
+    // Use highest maxTokens and timeout among group members
+    const maxTokens = Math.max(...handlers.map(h => h.maxTokens ?? constants_js_1.DEFAULT_LLM_MAX_TOKENS));
+    const timeout = Math.max(...handlers.map(h => h.timeout ?? constants_js_1.DEFAULT_LLM_TIMEOUT));
+    // Build combined prompt
+    const taskSections = handlers.map((h, i) => {
+        const rendered = (0, prefetch_js_1.renderPromptTemplate)(h.prompt, input, context);
+        return `TASK "${h.id}":\n${rendered}`;
+    });
+    const combinedPrompt = 'You must complete multiple analysis tasks. Respond with a JSON object where each key is the task ID and the value is your analysis for that task.\n\n' +
+        taskSections.join('\n\n') +
+        '\n\nRespond ONLY with valid JSON in this format:\n' +
+        '{' + handlers.map(h => `"${h.id}": <your analysis>`).join(', ') + '}';
+    try {
+        const client = await getClient();
+        const apiCall = client.messages.create({
+            model,
+            max_tokens: maxTokens,
+            messages: [{ role: 'user', content: combinedPrompt }],
+        });
+        const timeoutPromise = new Promise((_resolve, reject) => setTimeout(() => reject(new Error(`Batched LLM call timed out after ${timeout}ms`)), timeout));
+        const response = await Promise.race([apiCall, timeoutPromise]);
+        const text = response.content?.[0]?.text ?? '';
+        const totalUsage = {
+            input_tokens: response.usage?.input_tokens ?? 0,
+            output_tokens: response.usage?.output_tokens ?? 0,
+        };
+        // Try to parse as JSON and split results
+        let parsed = {};
+        try {
+            // Strip markdown code fences if present
+            const cleaned = text.replace(/^```(?:json)?\s*\n?/m, '').replace(/\n?```\s*$/m, '').trim();
+            parsed = JSON.parse(cleaned);
+        }
+        catch {
+            // If JSON parsing fails, give all handlers the raw text
+            const duration = performance.now() - start;
+            return handlers.map(h => ({
+                id: h.id,
+                ok: true,
+                output: { additionalContext: text },
+                duration_ms: duration,
+                usage: splitUsage(totalUsage, handlers.length),
+                cost_usd: calculateCost(model, splitUsage(totalUsage, handlers.length)),
+            }));
+        }
+        // Distribute results to each handler
+        const duration = performance.now() - start;
+        const perHandlerUsage = splitUsage(totalUsage, handlers.length);
+        return handlers.map(h => {
+            const handlerResult = parsed[h.id];
+            const resultText = typeof handlerResult === 'string'
+                ? handlerResult
+                : JSON.stringify(handlerResult ?? '');
+            return {
+                id: h.id,
+                ok: true,
+                output: { additionalContext: resultText },
+                duration_ms: duration,
+                usage: perHandlerUsage,
+                cost_usd: calculateCost(model, perHandlerUsage),
+            };
+        });
+    }
+    catch (err) {
+        const duration = performance.now() - start;
+        const errorMsg = err instanceof Error ? err.message : String(err);
+        return handlers.map(h => ({
+            id: h.id,
+            ok: false,
+            error: errorMsg,
+            duration_ms: duration,
+        }));
+    }
+}
+/**
+ * Split total token usage evenly across N handlers (for cost attribution in batches).
+ */
+function splitUsage(total, count) {
+    if (count <= 0)
+        return { input_tokens: 0, output_tokens: 0 };
+    return {
+        input_tokens: Math.ceil(total.input_tokens / count),
+        output_tokens: Math.ceil(total.output_tokens / count),
+    };
+}
+/**
+ * Execute multiple LLM handlers, batching those with the same batchGroup.
+ *
+ * Strategy: handlers with the same batchGroup get their prompts combined into
+ * a single API call with a structured multi-task prompt. Handlers without a
+ * batchGroup are executed individually.
+ */
+async function executeLLMHandlersBatched(handlers, input, context) {
+    // Group by batchGroup
+    const grouped = new Map();
+    const ungrouped = [];
+    for (const handler of handlers) {
+        if (handler.batchGroup) {
+            const existing = grouped.get(handler.batchGroup) ?? [];
+            existing.push(handler);
+            grouped.set(handler.batchGroup, existing);
+        }
+        else {
+            ungrouped.push(handler);
+        }
+    }
+    // Execute all in parallel: individual calls + batch groups
+    const promises = [];
+    // Individual (ungrouped) handlers
+    for (const handler of ungrouped) {
+        promises.push(executeLLMHandler(handler, input, context).then(r => [r]));
+    }
+    // Batch groups
+    for (const [_groupId, groupHandlers] of grouped) {
+        if (groupHandlers.length === 1) {
+            // Single handler in group — no point batching
+            promises.push(executeLLMHandler(groupHandlers[0], input, context).then(r => [r]));
+        }
+        else {
+            promises.push(executeBatchGroup(groupHandlers, input, context));
+        }
+    }
+    const resultArrays = await Promise.all(promises);
+    return resultArrays.flat();
+}

package/dist/manifest.js

@@ -48,15 +48,40 @@ function validateManifest(manifest) {
                 throw new Error(`Duplicate handler id: "${handler.id}"`);
             }
             seenIds.add(handler.id);
-            if (!handler.type || !['script', 'inline'].includes(handler.type)) {
-                throw new Error(`Handler "${handler.id}" must have type "script" or "inline"`);
+            if (!handler.type || !['script', 'inline', 'llm'].includes(handler.type)) {
+                throw new Error(`Handler "${handler.id}" must have type "script", "inline", or "llm"`);
             }
-            if (handler.type === 'script' && !handler.command) {
+            if (handler.type === 'script' && !('command' in handler && handler.command)) {
                 throw new Error(`Script handler "${handler.id}" must have a "command" field`);
             }
-            if (handler.type === 'inline' && !handler.module) {
+            if (handler.type === 'inline' && !('module' in handler && handler.module)) {
                 throw new Error(`Inline handler "${handler.id}" must have a "module" field`);
             }
+            if (handler.type === 'llm') {
+                const llm = handler;
+                if (!llm.model) {
+                    throw new Error(`LLM handler "${handler.id}" must have a "model" field`);
+                }
+                if (!llm.prompt) {
+                    throw new Error(`LLM handler "${handler.id}" must have a "prompt" field`);
+                }
+                const validModels = ['claude-haiku-4-5', 'claude-sonnet-4-6', 'claude-opus-4-6'];
+                if (!validModels.includes(llm.model)) {
+                    throw new Error(`LLM handler "${handler.id}" model must be one of: ${validModels.join(', ')}`);
+                }
+            }
+        }
+    }
+    // Validate prefetch if present
+    if (manifest.prefetch !== undefined) {
+        if (!Array.isArray(manifest.prefetch)) {
+            throw new Error('prefetch must be an array');
+        }
+        const validKeys = ['transcript', 'git_status', 'git_diff'];
+        for (const key of manifest.prefetch) {
+            if (!validKeys.includes(key)) {
+                throw new Error(`Invalid prefetch key: "${key}". Valid keys: ${validKeys.join(', ')}`);
+            }
         }
     }
     // Validate settings if present

package/dist/metrics.d.ts

@@ -1,4 +1,4 @@
-import type { MetricEntry } from './types.js';
+import type { MetricEntry, CostEntry } from './types.js';
 interface AggregatedStats {
     event: string;
     fires: number;
@@ -21,6 +21,26 @@ export declare class MetricsCollector {
     formatStatsTable(): string;
     /** Estimate how many process spawns were saved. */
     estimateSpawnsSaved(): number;
+    /** Track a cost entry — appends to costs.jsonl. */
+    trackCost(entry: CostEntry): void;
+    /** Get cost statistics from persisted cost entries. */
+    getCostStats(): {
+        totalCost: number;
+        totalTokens: number;
+        byModel: Record<string, {
+            cost: number;
+            tokens: number;
+        }>;
+        byHandler: Record<string, {
+            cost: number;
+            tokens: number;
+            calls: number;
+        }>;
+    };
+    /** Format cost data as a CLI-friendly table. */
+    formatCostTable(): string;
+    /** Load cost entries from disk. */
+    private loadCosts;
     /** Load all entries from disk + memory (deduped by combining disk file). */
     private loadAll;
 }

package/dist/metrics.js

@@ -100,6 +100,102 @@ class MetricsCollector {
         const all = this.loadAll();
         return all.length;
     }
+    // --- Cost tracking ---
+    /** Track a cost entry — appends to costs.jsonl. */
+    trackCost(entry) {
+        try {
+            const dir = (0, path_1.dirname)(constants_js_1.COSTS_FILE);
+            if (!(0, fs_1.existsSync)(dir)) {
+                (0, fs_1.mkdirSync)(dir, { recursive: true });
+            }
+            (0, fs_1.appendFileSync)(constants_js_1.COSTS_FILE, JSON.stringify(entry) + '\n', 'utf-8');
+        }
+        catch {
+            // Non-critical — cost tracking should not crash the daemon
+        }
+    }
+    /** Get cost statistics from persisted cost entries. */
+    getCostStats() {
+        const entries = this.loadCosts();
+        let totalCost = 0;
+        let totalTokens = 0;
+        const byModel = {};
+        const byHandler = {};
+        for (const entry of entries) {
+            totalCost += entry.cost_usd;
+            const tokens = entry.usage.input_tokens + entry.usage.output_tokens;
+            totalTokens += tokens;
+            // By model
+            if (!byModel[entry.model]) {
+                byModel[entry.model] = { cost: 0, tokens: 0 };
+            }
+            byModel[entry.model].cost += entry.cost_usd;
+            byModel[entry.model].tokens += tokens;
+            // By handler
+            if (!byHandler[entry.handler]) {
+                byHandler[entry.handler] = { cost: 0, tokens: 0, calls: 0 };
+            }
+            byHandler[entry.handler].cost += entry.cost_usd;
+            byHandler[entry.handler].tokens += tokens;
+            byHandler[entry.handler].calls++;
+        }
+        return { totalCost, totalTokens, byModel, byHandler };
+    }
+    /** Format cost data as a CLI-friendly table. */
+    formatCostTable() {
+        const entries = this.loadCosts();
+        if (entries.length === 0) {
+            return 'No LLM cost data recorded yet.';
+        }
+        const stats = this.getCostStats();
+        const lines = [];
+        lines.push('LLM Cost Summary');
+        lines.push(`  Total: $${stats.totalCost.toFixed(4)} (${formatTokenCount(stats.totalTokens)} tokens)`);
+        lines.push('');
+        // By Model
+        lines.push('  By Model:');
+        for (const [model, data] of Object.entries(stats.byModel)) {
+            lines.push(`    ${model.padEnd(22)} $${data.cost.toFixed(4)} (${formatTokenCount(data.tokens)} tokens)`);
+        }
+        lines.push('');
+        // By Handler
+        lines.push('  By Handler:');
+        for (const [handler, data] of Object.entries(stats.byHandler)) {
+            const avgTokens = data.calls > 0 ? Math.round(data.tokens / data.calls) : 0;
+            lines.push(`    ${handler.padEnd(22)} $${data.cost.toFixed(4)} (${data.calls} calls, avg ${avgTokens} tokens)`);
+        }
+        // Batching savings estimate
+        const batchedCount = entries.filter(e => e.batched).length;
+        const unbatchedCount = entries.length - batchedCount;
+        if (batchedCount > 0) {
+            // Estimate: batched calls saved roughly (batchedCount - unique_batch_calls) API calls
+            // Simple heuristic: batched entries share cost, individual would each cost input overhead
+            const batchedCost = entries.filter(e => e.batched).reduce((s, e) => s + e.cost_usd, 0);
+            // Rough estimate: without batching, each would have its own input tokens overhead
+            const estimatedIndividualCost = batchedCost * 2; // conservative 2x estimate
+            const saved = estimatedIndividualCost - batchedCost;
+            if (saved > 0) {
+                const pct = Math.round((saved / (stats.totalCost + saved)) * 100);
+                lines.push('');
+                lines.push(`  Batching saved: ~$${saved.toFixed(4)} (~${pct}% of what individual calls would cost)`);
+            }
+        }
+        return lines.join('\n');
+    }
+    /** Load cost entries from disk. */
+    loadCosts() {
+        if (!(0, fs_1.existsSync)(constants_js_1.COSTS_FILE)) {
+            return [];
+        }
+        try {
+            const raw = (0, fs_1.readFileSync)(constants_js_1.COSTS_FILE, 'utf-8');
+            const lines = raw.trim().split('\n').filter(Boolean);
+            return lines.map((line) => JSON.parse(line));
+        }
+        catch {
+            return [];
+        }
+    }
     /** Load all entries from disk + memory (deduped by combining disk file). */
     loadAll() {
         if (!(0, fs_1.existsSync)(constants_js_1.METRICS_FILE)) {
@@ -116,6 +212,13 @@ class MetricsCollector {
     }
 }
 exports.MetricsCollector = MetricsCollector;
+function formatTokenCount(tokens) {
+    if (tokens >= 1_000_000)
+        return `${(tokens / 1_000_000).toFixed(1)}M`;
+    if (tokens >= 1_000)
+        return `${(tokens / 1_000).toFixed(1)}k`;
+    return String(tokens);
+}
 function padRow(cols) {
     const widths = [20, 8, 8, 10, 10, 10];
     return cols.map((col, i) => col.padEnd(widths[i])).join('  ');

package/dist/prefetch.d.ts

@@ -0,0 +1,11 @@
+import type { PrefetchKey, PrefetchContext, HookInput } from './types.js';
+/**
+ * Pre-fetch requested context data. Each key is fetched once and cached.
+ * Errors are caught per-key (a failed git_status doesn't block transcript).
+ */
+export declare function prefetchContext(keys: PrefetchKey[], input: HookInput): Promise<PrefetchContext>;
+/**
+ * Render a prompt template by replacing $VARIABLES with actual values.
+ * Supported: $TRANSCRIPT, $GIT_STATUS, $GIT_DIFF, $ARGUMENTS, $TOOL_NAME, $PROMPT, $CWD
+ */
+export declare function renderPromptTemplate(template: string, input: HookInput, context: PrefetchContext): string;

package/dist/prefetch.js

@@ -0,0 +1,71 @@
+"use strict";
+// clooks prefetch — shared context pre-fetching for handlers
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prefetchContext = prefetchContext;
+exports.renderPromptTemplate = renderPromptTemplate;
+const fs_1 = require("fs");
+const child_process_1 = require("child_process");
+const MAX_TRANSCRIPT_BYTES = 50 * 1024; // 50KB
+const MAX_GIT_DIFF_BYTES = 20 * 1024; // 20KB
+/**
+ * Pre-fetch requested context data. Each key is fetched once and cached.
+ * Errors are caught per-key (a failed git_status doesn't block transcript).
+ */
+async function prefetchContext(keys, input) {
+    const ctx = {};
+    for (const key of keys) {
+        try {
+            switch (key) {
+                case 'transcript': {
+                    if (input.transcript_path && (0, fs_1.existsSync)(input.transcript_path)) {
+                        const raw = (0, fs_1.readFileSync)(input.transcript_path, 'utf-8');
+                        // Truncate to last 50KB to avoid memory issues
+                        ctx.transcript = raw.length > MAX_TRANSCRIPT_BYTES
+                            ? raw.slice(-MAX_TRANSCRIPT_BYTES)
+                            : raw;
+                    }
+                    break;
+                }
+                case 'git_status': {
+                    const status = (0, child_process_1.execSync)('git status --porcelain', {
+                        cwd: input.cwd,
+                        encoding: 'utf-8',
+                        timeout: 5000,
+                    });
+                    ctx.git_status = status;
+                    break;
+                }
+                case 'git_diff': {
+                    const diff = (0, child_process_1.execSync)('git diff --no-ext-diff --stat', {
+                        cwd: input.cwd,
+                        encoding: 'utf-8',
+                        timeout: 5000,
+                    });
+                    // Truncate to 20KB
+                    ctx.git_diff = diff.length > MAX_GIT_DIFF_BYTES
+                        ? diff.slice(0, MAX_GIT_DIFF_BYTES)
+                        : diff;
+                    break;
+                }
+            }
+        }
+        catch {
+            // Errors are silently caught per-key — a failed git_status doesn't block transcript
+        }
+    }
+    return ctx;
+}
+/**
+ * Render a prompt template by replacing $VARIABLES with actual values.
+ * Supported: $TRANSCRIPT, $GIT_STATUS, $GIT_DIFF, $ARGUMENTS, $TOOL_NAME, $PROMPT, $CWD
+ */
+function renderPromptTemplate(template, input, context) {
+    return template
+        .replace(/\$TRANSCRIPT/g, context.transcript ?? '')
+        .replace(/\$GIT_STATUS/g, context.git_status ?? '')
+        .replace(/\$GIT_DIFF/g, context.git_diff ?? '')
+        .replace(/\$ARGUMENTS/g, input.tool_input ? JSON.stringify(input.tool_input) : '')
+        .replace(/\$TOOL_NAME/g, input.tool_name ?? '')
+        .replace(/\$PROMPT/g, input.prompt ?? '')
+        .replace(/\$CWD/g, input.cwd ?? '');
+}

package/dist/server.js

@@ -10,6 +10,7 @@ const http_1 = require("http");
 const fs_1 = require("fs");
 const child_process_1 = require("child_process");
 const handlers_js_1 = require("./handlers.js");
+const prefetch_js_1 = require("./prefetch.js");
 const constants_js_1 = require("./constants.js");
 function log(msg) {
     const line = `[${new Date().toISOString()}] ${msg}\n`;
@@ -119,8 +120,13 @@ function createServer(manifest, metrics) {
             }
             log(`Hook: ${eventName} (${handlers.length} handler${handlers.length > 1 ? 's' : ''})`);
             try {
-                const results = await (0, handlers_js_1.executeHandlers)(event, input, handlers);
-                // Record metrics
+                // Pre-fetch shared context if configured
+                let context;
+                if (manifest.prefetch && manifest.prefetch.length > 0) {
+                    context = await (0, prefetch_js_1.prefetchContext)(manifest.prefetch, input);
+                }
+                const results = await (0, handlers_js_1.executeHandlers)(event, input, handlers, context);
+                // Record metrics and costs
                 for (const result of results) {
                     metrics.record({
                         ts: new Date().toISOString(),
@@ -129,7 +135,27 @@ function createServer(manifest, metrics) {
                         duration_ms: result.duration_ms,
                         ok: result.ok,
                         error: result.error,
+                        filtered: result.filtered,
+                        usage: result.usage,
+                        cost_usd: result.cost_usd,
                     });
+                    // Track cost for LLM handlers
+                    if (result.usage && result.cost_usd !== undefined && result.cost_usd > 0) {
+                        // Find the handler config to get model info
+                        const handlerConfig = handlers.find(h => h.id === result.id);
+                        if (handlerConfig && handlerConfig.type === 'llm') {
+                            const llmConfig = handlerConfig;
+                            metrics.trackCost({
+                                ts: new Date().toISOString(),
+                                event,
+                                handler: result.id,
+                                model: llmConfig.model,
+                                usage: result.usage,
+                                cost_usd: result.cost_usd,
+                                batched: !!llmConfig.batchGroup,
+                            });
+                        }
+                    }
                 }
                 const merged = mergeResults(results);
                 log(`  -> ${results.filter((r) => r.ok).length}/${results.length} ok, response keys: ${Object.keys(merged).join(', ') || '(empty)'}`);