@mauribadnights/clooks 0.1.0 → 0.2.0

package/README.md

@@ -1,50 +1,61 @@
 # clooks
 
-Persistent hook runtime for Claude Code — eliminate cold starts, get observability.
+**Persistent hook runtime for Claude Code.** Eliminate cold starts. Get observability.
 
-## The Problem
+[![npm version](https://img.shields.io/npm/v/@mauribadnights/clooks.svg)](https://www.npmjs.com/package/@mauribadnights/clooks)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
 
-Claude Code spawns a fresh process for every hook invocation. Power users with multiple hooks (safety guards, context injectors, custom scripts) accumulate **100+ process spawns per session**. Each Node.js cold start costs 50-100ms. That's 6-11 seconds of pure overhead per session — and you get zero visibility into what your hooks are doing.
+## Performance
 
-## How clooks Fixes It
+| Metric | Without clooks | With clooks | Improvement |
+|--------|---------------|-------------|-------------|
+| Single hook invocation | ~34.6ms | ~0.31ms | **112x faster** |
+| Full session (120 invocations) | ~3,986ms | ~23ms | **99% time saved** |
+| 5 parallel handlers | ~424ms | ~96ms | **4.4x faster** |
 
-One persistent HTTP server handles all your hooks. Claude Code's [built-in HTTP hook support](https://docs.anthropic.com/en/docs/claude-code/hooks) POSTs to `localhost:7890` instead of spawning processes. **One process instead of hundreds.**
+> Benchmarked on Apple Silicon (M-series), Node v24.4.1. Run `npm run bench` to reproduce.
 
-```
-┌─────────────┐     POST /hooks/PreToolUse     ┌──────────────────┐
-│             │ ──────────────────────────────► │                  │
-│ Claude Code │     POST /hooks/Stop           │  clooks daemon  │
-│             │ ──────────────────────────────► │  (persistent)    │
-│             │     POST /hooks/...            │                  │
-│             │ ──────────────────────────────► │  ┌────────────┐ │
-│             │                                │  │ handler A  │ │
-│             │ ◄────────────── JSON ───────── │  │ handler B  │ │
-│             │                                │  │ handler C  │ │
-└─────────────┘                                │  └────────────┘ │
-                                               │  metrics.jsonl  │
-                                               └──────────────────┘
-```
+## The Problem
+
+Claude Code spawns a fresh process for every hook invocation. Each Node.js cold start costs 30-40ms. Power users with multiple hooks accumulate 100+ process spawns per session -- that is 4-6 seconds of pure overhead, with zero visibility into what your hooks are doing or how they fail.
 
 ## Quick Start
 
 ```bash
-npm install -g clooks
+npm install -g @mauribadnights/clooks
+
+# Option A: Migrate existing hooks automatically
+clooks migrate     # converts command hooks to HTTP hooks + manifest
+clooks start       # starts the daemon
+
+# Option B: Start fresh
+clooks init        # creates ~/.clooks/manifest.yaml
+clooks start
+```
 
-# If you have existing hooks in settings.json:
-clooks migrate    # converts command hooks → HTTP hooks + manifest
+That is it. Claude Code will now POST to your daemon instead of spawning processes.
 
-# Or start fresh:
-clooks init       # creates ~/.clooks/manifest.yaml
+## How It Works
 
-clooks start      # starts the daemon
 ```
+Claude Code                          clooks daemon (localhost:7890)
+    |                                        |
+    |-- SessionStart ------> POST /hooks/SessionStart ------> [handler1, handler2]
+    |-- UserPromptSubmit --> POST /hooks/UserPromptSubmit --> [handler3]
+    |-- PreToolUse (x50) --> POST /hooks/PreToolUse --------> [handler4, handler5]
+    |-- Stop --------------> POST /hooks/Stop ---------------> [handler6]
+    |                                        |
+    |<-------------- JSON responses ---------|
+```
+
+One persistent process. Zero cold starts. Full observability.
 
-That's it. Claude Code will now POST to your daemon instead of spawning processes.
+After `clooks migrate`, your `settings.json` is rewritten so that `SessionStart` runs a single command hook (`clooks ensure-running`) and all other hooks become HTTP POSTs. The daemon loads handlers from `~/.clooks/manifest.yaml` and dispatches them in parallel per event. Handlers that fail 3 times consecutively are auto-disabled to prevent cascading failures.
 
 ## Commands
 
 | Command | Description |
-|---|---|
+|---------|-------------|
 | `clooks start` | Start the daemon (background by default, `--foreground` for debug) |
 | `clooks stop` | Stop the daemon |
 | `clooks status` | Show daemon status, uptime, and handler count |
@@ -53,7 +64,7 @@ That's it. Claude Code will now POST to your daemon instead of spawning processe
 | `clooks restore` | Restore original `settings.json` from backup |
 | `clooks doctor` | Run diagnostic health checks |
 | `clooks init` | Create default config directory and example manifest |
-| `clooks ensure-running` | Start daemon if not running (used by SessionStart hook) |
+| `clooks ensure-running` | Start daemon if not already running (used by SessionStart hook) |
 
 ## Manifest Format
 
@@ -63,13 +74,13 @@ Handlers are defined in `~/.clooks/manifest.yaml`:
 handlers:
   PreToolUse:
     - id: safety-guard
-      type: script
+      type: script                    # runs a shell command
       command: node ~/hooks/guard.js
       timeout: 3000
       enabled: true
 
     - id: context-injector
-      type: inline
+      type: inline                    # imports a JS module directly (no subprocess)
       module: ~/hooks/context.js
       timeout: 2000
 
@@ -84,10 +95,12 @@ settings:
 ```
 
 **Handler types:**
-- `script` — runs a shell command, pipes hook JSON to stdin, reads JSON from stdout
-- `inline` — imports a JS module and calls its default export (faster, no subprocess)
+- `script` -- runs a shell command, pipes hook JSON to stdin, reads JSON from stdout.
+- `inline` -- imports a JS module and calls its default export. Faster; no subprocess overhead.
+
+## Observability
 
-## Stats
+### Execution Metrics
 
 ```
 $ clooks stats
@@ -101,53 +114,130 @@ UserPromptSubmit    12        1         1.8         0.9         4.2
 Total fires: 71 | Total errors: 1 | Spawns saved: ~71
 ```
 
-## How It Works with Claude Code
-
-After `clooks migrate`, your `settings.json` looks like this:
-
-```json
-{
-  "hooks": {
-    "SessionStart": [{ "hooks": [
-      { "type": "command", "command": "clooks ensure-running" }
-    ]}],
-    "PreToolUse": [{ "hooks": [
-      { "type": "http", "url": "http://localhost:7890/hooks/PreToolUse" }
-    ]}]
-  }
-}
-```
-
-The `SessionStart` command hook ensures the daemon is running (fast no-op if already up). All other hooks are HTTP POSTs — no process spawning, no cold starts.
-
-Handlers that fail 3 times consecutively are auto-disabled to prevent cascading failures.
-
-## Configuration
+### Diagnostics
 
-| Item | Default |
-|---|---|
-| Port | `7890` |
-| Config directory | `~/.clooks/` |
-| Manifest | `~/.clooks/manifest.yaml` |
-| Metrics | `~/.clooks/metrics.jsonl` |
-| Daemon log | `~/.clooks/daemon.log` |
-| PID file | `~/.clooks/daemon.pid` |
+```
+$ clooks doctor
+
+[pass] Daemon is running (PID 44721, uptime 2h 13m)
+[pass] Port 7890 is responding
+[pass] Manifest loaded: 4 handlers across 3 events
+[pass] settings.json has HTTP hooks pointing to clooks
+[pass] No handlers in circuit-breaker state
+[warn] 1 handler error in last 24h (session-logger on Stop)
+```
 
 ## Comparison
 
-|  | Without clooks | With clooks |
+| | Without clooks | With clooks |
 |---|---|---|
 | **Process model** | New process per hook invocation | One persistent HTTP server |
-| **Cold start** | 50-100ms per invocation | 0ms (already running) |
-| **State** | Stateless — each invocation starts fresh | Persistent — share state across invocations |
+| **Cold start overhead** | 30-40ms per invocation | 0ms (already running) |
+| **State management** | Stateless -- each invocation starts fresh | Persistent -- share state across invocations |
 | **Observability** | None | Metrics, stats, logs, doctor diagnostics |
-| **Failure handling** | Silent | Auto-disable after 3 consecutive failures |
+| **Error handling** | Silent failures | Auto-disable after 3 consecutive failures |
 
-## License
+## Configuration Reference
 
-MIT
+| Option | Default | Description |
+|--------|---------|-------------|
+| Port | `7890` | HTTP server port |
+| Config directory | `~/.clooks/` | Root configuration directory |
+| Manifest | `~/.clooks/manifest.yaml` | Handler definitions |
+| Metrics | `~/.clooks/metrics.jsonl` | Execution metrics log |
+| Daemon log | `~/.clooks/daemon.log` | Server output log |
+| PID file | `~/.clooks/daemon.pid` | Process ID file |
+
+## v0.2 Features
+
+### LLM Handlers
+
+Call the Anthropic Messages API directly from your manifest. Handlers with the same `batchGroup` are combined into a single API call, saving tokens and latency.
+
+```yaml
+handlers:
+  PreToolUse:
+    - id: code-review
+      type: llm
+      model: claude-haiku-4-5
+      prompt: "Review this tool call for $TOOL_NAME with args: $ARGUMENTS"
+      batchGroup: analysis
+      timeout: 15000
+
+    - id: security-check
+      type: llm
+      model: claude-haiku-4-5
+      prompt: "Check for security issues in $TOOL_NAME call: $ARGUMENTS"
+      batchGroup: analysis    # batched with code-review into one API call
+```
+
+Requires `@anthropic-ai/sdk` as a peer dependency and `ANTHROPIC_API_KEY` env var.
+
+### Intelligent Filtering
+
+Skip handlers based on keywords. Supports OR (`|`) and NOT (`!`) operators. Matching is case-insensitive against the full hook input JSON.
+
+```yaml
+handlers:
+  PreToolUse:
+    - id: bash-guard
+      type: script
+      command: node ~/hooks/guard.js
+      filter: "Bash|Execute|!Read"   # runs for Bash/Execute, never for Read
+```
+
+### Shared Context Pre-fetch
+
+Fetch transcript, git status, or git diff once per hook event and share across all handlers. Avoids redundant I/O when multiple handlers need the same data. Use `$VARIABLE` interpolation in LLM prompts.
+
+```yaml
+prefetch:
+  - transcript
+  - git_status
+  - git_diff
+
+handlers:
+  Stop:
+    - id: session-summary
+      type: llm
+      model: claude-haiku-4-5
+      prompt: "Summarize this session:\n$TRANSCRIPT\n\nGit changes:\n$GIT_DIFF"
+```
+
+### Cost Tracking
+
+Track LLM token usage and costs per handler and model. Pricing is built-in for Haiku 4.5, Sonnet 4.6, and Opus 4.6.
+
+```
+$ clooks costs
+
+LLM Cost Summary
+  Total: $0.0142 (4,280 tokens)
+
+  By Model:
+    claude-haiku-4-5       $0.0142 (4,280 tokens)
+
+  By Handler:
+    code-review            $0.0089 (12 calls, avg 178 tokens)
+    security-check         $0.0053 (12 calls, avg 178 tokens)
+```
+
+Cost data also appears in `clooks stats` when LLM handlers have been used.
 
 ## Roadmap
 
-- **v0.2:** Matcher support in manifest, LLM call batching, token cost tracking
 - **v0.3:** Plugin ecosystem, dependency resolution between handlers
+- **v0.4:** Visual dashboard for hook management and metrics
+
+## Contributing
+
+Issues and pull requests are welcome. Run the test suite before submitting:
+
+```bash
+npm test
+npm run bench
+```
+
+## License
+
+MIT

package/dist/cli.js

@@ -14,7 +14,7 @@ const program = new commander_1.Command();
 program
     .name('clooks')
     .description('Persistent hook runtime for Claude Code')
-    .version('0.1.0');
+    .version('0.2.0');
 // --- start ---
 program
     .command('start')
@@ -113,6 +113,20 @@ program
     .action(() => {
     const metrics = new metrics_js_1.MetricsCollector();
     console.log(metrics.formatStatsTable());
+    // Append cost summary if LLM data exists
+    const costStats = metrics.getCostStats();
+    if (costStats.totalCost > 0) {
+        console.log('');
+        console.log(metrics.formatCostTable());
+    }
+});
+// --- costs ---
+program
+    .command('costs')
+    .description('Show LLM cost breakdown')
+    .action(() => {
+    const metrics = new metrics_js_1.MetricsCollector();
+    console.log(metrics.formatCostTable());
 });
 // --- migrate ---
 program

package/dist/constants.d.ts

@@ -7,4 +7,12 @@ export declare const LOG_FILE: string;
 export declare const SETTINGS_BACKUP: string;
 export declare const MAX_CONSECUTIVE_FAILURES = 3;
 export declare const DEFAULT_HANDLER_TIMEOUT = 5000;
+export declare const COSTS_FILE: string;
+export declare const DEFAULT_LLM_TIMEOUT = 30000;
+export declare const DEFAULT_LLM_MAX_TOKENS = 1024;
+/** Pricing per million tokens (USD) — as of March 2026 */
+export declare const LLM_PRICING: Record<string, {
+    input: number;
+    output: number;
+}>;
 export declare const HOOK_EVENTS: string[];

package/dist/constants.js

@@ -1,7 +1,7 @@
 "use strict";
 // clooks constants
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.HOOK_EVENTS = exports.DEFAULT_HANDLER_TIMEOUT = exports.MAX_CONSECUTIVE_FAILURES = exports.SETTINGS_BACKUP = exports.LOG_FILE = exports.METRICS_FILE = exports.PID_FILE = exports.MANIFEST_PATH = exports.CONFIG_DIR = exports.DEFAULT_PORT = void 0;
+exports.HOOK_EVENTS = exports.LLM_PRICING = exports.DEFAULT_LLM_MAX_TOKENS = exports.DEFAULT_LLM_TIMEOUT = exports.COSTS_FILE = exports.DEFAULT_HANDLER_TIMEOUT = exports.MAX_CONSECUTIVE_FAILURES = exports.SETTINGS_BACKUP = exports.LOG_FILE = exports.METRICS_FILE = exports.PID_FILE = exports.MANIFEST_PATH = exports.CONFIG_DIR = exports.DEFAULT_PORT = void 0;
 const os_1 = require("os");
 const path_1 = require("path");
 exports.DEFAULT_PORT = 7890;
@@ -13,6 +13,15 @@ exports.LOG_FILE = (0, path_1.join)(exports.CONFIG_DIR, 'daemon.log');
 exports.SETTINGS_BACKUP = (0, path_1.join)(exports.CONFIG_DIR, 'settings.backup.json');
 exports.MAX_CONSECUTIVE_FAILURES = 3;
 exports.DEFAULT_HANDLER_TIMEOUT = 5000; // ms
+exports.COSTS_FILE = (0, path_1.join)(exports.CONFIG_DIR, 'costs.jsonl');
+exports.DEFAULT_LLM_TIMEOUT = 30000; // ms
+exports.DEFAULT_LLM_MAX_TOKENS = 1024;
+/** Pricing per million tokens (USD) — as of March 2026 */
+exports.LLM_PRICING = {
+    'claude-haiku-4-5': { input: 0.80, output: 4.00 },
+    'claude-sonnet-4-6': { input: 3.00, output: 15.00 },
+    'claude-opus-4-6': { input: 15.00, output: 75.00 },
+};
 exports.HOOK_EVENTS = [
     'SessionStart',
     'UserPromptSubmit',

package/dist/doctor.js

@@ -93,7 +93,9 @@ function checkHandlerCommands() {
         const manifest = (0, manifest_js_1.loadManifest)();
         for (const [_event, handlers] of Object.entries(manifest.handlers)) {
             for (const handler of handlers) {
-                if (handler.type !== 'script' || !handler.command)
+                if (handler.type !== 'script')
+                    continue;
+                if (!handler.command)
                     continue;
                 // Extract the base command (first word)
                 const baseCmd = handler.command.split(/\s+/)[0];

package/dist/filter.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Evaluate a keyword filter against input text.
+ *
+ * Filter syntax:
+ *   "word1|word2|word3"  — match if ANY keyword found (OR)
+ *   "!word"              — exclude if keyword found (NOT)
+ *   Mixed: "word1|word2|!word3" — match word1 OR word2, but NOT if word3 present
+ *
+ * Returns true if handler should execute, false if filtered out.
+ */
+export declare function evaluateFilter(filter: string, input: string): boolean;

package/dist/filter.js

@@ -0,0 +1,42 @@
+"use strict";
+// clooks filter engine — keyword-based handler filtering
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.evaluateFilter = evaluateFilter;
+/**
+ * Evaluate a keyword filter against input text.
+ *
+ * Filter syntax:
+ *   "word1|word2|word3"  — match if ANY keyword found (OR)
+ *   "!word"              — exclude if keyword found (NOT)
+ *   Mixed: "word1|word2|!word3" — match word1 OR word2, but NOT if word3 present
+ *
+ * Returns true if handler should execute, false if filtered out.
+ */
+function evaluateFilter(filter, input) {
+    const terms = filter.split('|').map((t) => t.trim()).filter(Boolean);
+    if (terms.length === 0)
+        return true;
+    const positive = [];
+    const negative = [];
+    for (const term of terms) {
+        if (term.startsWith('!')) {
+            negative.push(term.slice(1));
+        }
+        else {
+            positive.push(term);
+        }
+    }
+    const lowerInput = input.toLowerCase();
+    // If ANY negative term is found → blocked
+    for (const neg of negative) {
+        if (lowerInput.includes(neg.toLowerCase())) {
+            return false;
+        }
+    }
+    // If there are positive terms, at least ONE must match
+    if (positive.length > 0) {
+        return positive.some((pos) => lowerInput.includes(pos.toLowerCase()));
+    }
+    // Only negative terms and none matched → allow
+    return true;
+}

package/dist/handlers.d.ts

@@ -1,4 +1,4 @@
-import type { HandlerConfig, HandlerResult, HandlerState, HookEvent, HookInput } from './types.js';
+import type { HandlerConfig, HandlerResult, HandlerState, HookEvent, HookInput, PrefetchContext } from './types.js';
 /** Reset all handler states (useful for testing) */
 export declare function resetHandlerStates(): void;
 /** Get a copy of the handler states map */
@@ -6,8 +6,9 @@ export declare function getHandlerStates(): Map<string, HandlerState>;
 /**
  * Execute all handlers for an event in parallel.
  * Returns merged results array.
+ * Optionally accepts pre-fetched context for LLM prompt rendering.
  */
-export declare function executeHandlers(_event: HookEvent, input: HookInput, handlers: HandlerConfig[]): Promise<HandlerResult[]>;
+export declare function executeHandlers(_event: HookEvent, input: HookInput, handlers: HandlerConfig[], context?: PrefetchContext): Promise<HandlerResult[]>;
 /**
  * Execute a script handler: spawn a child process, pipe input JSON to stdin,
  * read stdout as JSON response.

package/dist/handlers.js

@@ -10,6 +10,8 @@ const child_process_1 = require("child_process");
 const url_1 = require("url");
 const path_1 = require("path");
 const constants_js_1 = require("./constants.js");
+const filter_js_1 = require("./filter.js");
+const llm_js_1 = require("./llm.js");
 /** Runtime state per handler ID */
 const handlerStates = new Map();
 function getState(id) {
@@ -31,50 +33,76 @@ function getHandlerStates() {
 /**
  * Execute all handlers for an event in parallel.
  * Returns merged results array.
+ * Optionally accepts pre-fetched context for LLM prompt rendering.
  */
-async function executeHandlers(_event, input, handlers) {
-    const promises = handlers.map(async (handler) => {
+async function executeHandlers(_event, input, handlers, context) {
+    // Separate LLM handlers from script/inline, applying shared pre-checks
+    const llmHandlers = [];
+    const otherPromises = [];
+    const skippedResults = [];
+    for (const handler of handlers) {
         // Skip disabled handlers (both manifest-disabled and auto-disabled)
         if (handler.enabled === false) {
-            return { id: handler.id, ok: true, output: undefined, duration_ms: 0 };
+            skippedResults.push({ id: handler.id, ok: true, output: undefined, duration_ms: 0 });
+            continue;
         }
         const state = getState(handler.id);
         if (state.disabled) {
-            return {
+            skippedResults.push({
                 id: handler.id,
                 ok: false,
                 error: `Auto-disabled after ${constants_js_1.MAX_CONSECUTIVE_FAILURES} consecutive failures`,
                 duration_ms: 0,
-            };
+            });
+            continue;
         }
-        state.totalFires++;
-        const start = performance.now();
-        let result;
-        try {
-            if (handler.type === 'script') {
-                result = await executeScriptHandler(handler, input);
-            }
-            else if (handler.type === 'inline') {
-                result = await executeInlineHandler(handler, input);
-            }
-            else {
-                result = {
+        // Evaluate keyword filter before execution
+        if (handler.filter) {
+            const inputStr = JSON.stringify(input);
+            if (!(0, filter_js_1.evaluateFilter)(handler.filter, inputStr)) {
+                skippedResults.push({
                     id: handler.id,
-                    ok: false,
-                    error: `Unknown handler type: ${handler.type}`,
+                    ok: true,
+                    output: undefined,
                     duration_ms: 0,
-                };
+                    filtered: true,
+                });
+                continue;
             }
         }
+        state.totalFires++;
+        if (handler.type === 'llm') {
+            llmHandlers.push(handler);
+        }
+        else {
+            // Execute script/inline handlers in parallel
+            otherPromises.push(executeOtherHandler(handler, input));
+        }
+    }
+    // Execute script/inline handlers in parallel
+    const otherResults = otherPromises.length > 0
+        ? await Promise.all(otherPromises)
+        : [];
+    // Execute LLM handlers with batching (graceful — never crashes)
+    let llmResults = [];
+    if (llmHandlers.length > 0) {
+        try {
+            llmResults = await (0, llm_js_1.executeLLMHandlersBatched)(llmHandlers, input, context ?? {});
+        }
         catch (err) {
-            result = {
-                id: handler.id,
+            // Graceful degradation: if LLM execution entirely fails, return error results
+            const errorMsg = err instanceof Error ? err.message : String(err);
+            llmResults = llmHandlers.map(h => ({
+                id: h.id,
                 ok: false,
-                error: err instanceof Error ? err.message : String(err),
-                duration_ms: performance.now() - start,
-            };
+                error: `LLM execution failed: ${errorMsg}`,
+                duration_ms: 0,
+            }));
         }
-        // Update failure tracking
+    }
+    // Update failure tracking for all executed results
+    for (const result of [...otherResults, ...llmResults]) {
+        const state = getState(result.id);
         if (result.ok) {
             state.consecutiveFailures = 0;
         }
@@ -85,19 +113,49 @@ async function executeHandlers(_event, input, handlers) {
                 state.disabled = true;
             }
         }
-        return result;
-    });
-    return Promise.all(promises);
+    }
+    return [...skippedResults, ...otherResults, ...llmResults];
+}
+/**
+ * Execute a single script or inline handler with error handling.
+ */
+async function executeOtherHandler(handler, input) {
+    const start = performance.now();
+    try {
+        if (handler.type === 'script') {
+            return await executeScriptHandler(handler, input);
+        }
+        else if (handler.type === 'inline') {
+            return await executeInlineHandler(handler, input);
+        }
+        else {
+            return {
+                id: handler.id,
+                ok: false,
+                error: `Unknown handler type: ${handler.type}`,
+                duration_ms: 0,
+            };
+        }
+    }
+    catch (err) {
+        return {
+            id: handler.id,
+            ok: false,
+            error: err instanceof Error ? err.message : String(err),
+            duration_ms: performance.now() - start,
+        };
+    }
 }
 /**
  * Execute a script handler: spawn a child process, pipe input JSON to stdin,
  * read stdout as JSON response.
  */
 function executeScriptHandler(handler, input) {
-    const timeout = handler.timeout ?? constants_js_1.DEFAULT_HANDLER_TIMEOUT;
+    const h = handler;
+    const timeout = h.timeout ?? constants_js_1.DEFAULT_HANDLER_TIMEOUT;
     return new Promise((resolve) => {
         const start = performance.now();
-        const child = (0, child_process_1.spawn)('sh', ['-c', handler.command], {
+        const child = (0, child_process_1.spawn)('sh', ['-c', h.command], {
             stdio: ['pipe', 'pipe', 'pipe'],
             timeout,
         });
@@ -155,17 +213,18 @@ function executeScriptHandler(handler, input) {
  * Execute an inline handler: dynamically import a JS module and call its default export.
  */
 async function executeInlineHandler(handler, input) {
-    const timeout = handler.timeout ?? constants_js_1.DEFAULT_HANDLER_TIMEOUT;
+    const h = handler;
+    const timeout = h.timeout ?? constants_js_1.DEFAULT_HANDLER_TIMEOUT;
     const start = performance.now();
     try {
-        const modulePath = (0, path_1.resolve)(handler.module);
+        const modulePath = (0, path_1.resolve)(h.module);
         const moduleUrl = (0, url_1.pathToFileURL)(modulePath).href;
         const mod = await import(moduleUrl);
         if (typeof mod.default !== 'function') {
             return {
-                id: handler.id,
+                id: h.id,
                 ok: false,
-                error: `Module "${handler.module}" does not export a default function`,
+                error: `Module "${h.module}" does not export a default function`,
                 duration_ms: performance.now() - start,
             };
         }

package/dist/index.d.ts

@@ -5,5 +5,8 @@ export { migrate, restore, getSettingsPath } from './migrate.js';
 export type { MigratePathOptions } from './migrate.js';
 export { runDoctor } from './doctor.js';
 export { executeHandlers } from './handlers.js';
-export { DEFAULT_PORT, CONFIG_DIR, MANIFEST_PATH, PID_FILE, METRICS_FILE, LOG_FILE } from './constants.js';
-export type { HookEvent, HookInput, HandlerType, HandlerConfig, Manifest, HandlerResult, MetricEntry, HandlerState, DiagnosticResult, } from './types.js';
+export { evaluateFilter } from './filter.js';
+export { executeLLMHandler, executeLLMHandlersBatched, calculateCost, resetClient } from './llm.js';
+export { prefetchContext, renderPromptTemplate } from './prefetch.js';
+export { DEFAULT_PORT, CONFIG_DIR, MANIFEST_PATH, PID_FILE, METRICS_FILE, LOG_FILE, COSTS_FILE, DEFAULT_LLM_TIMEOUT, DEFAULT_LLM_MAX_TOKENS, LLM_PRICING } from './constants.js';
+export type { HookEvent, HookInput, HandlerType, HandlerConfig, ScriptHandlerConfig, InlineHandlerConfig, LLMHandlerConfig, LLMModel, Manifest, HandlerResult, MetricEntry, HandlerState, DiagnosticResult, PrefetchKey, PrefetchContext, TokenUsage, CostEntry, } from './types.js';