@mauribadnights/clooks 0.1.0 → 0.2.2

package/dist/metrics.js

@@ -6,15 +6,43 @@ const fs_1 = require("fs");
 const path_1 = require("path");
 const constants_js_1 = require("./constants.js");
 class MetricsCollector {
+    static MAX_ENTRIES = 1000;
     entries = [];
-    /** Record a metric entry in memory and append to disk. */
+    ringIndex = 0;
+    totalRecorded = 0;
+    static METRICS_MAX_BYTES = 5 * 1024 * 1024; // 5MB
+    static COSTS_MAX_BYTES = 1 * 1024 * 1024; // 1MB
+    /** Rotate a log file if it exceeds maxBytes. Keeps one backup (.1). */
+    rotateIfNeeded(filePath, maxBytes) {
+        try {
+            if (!(0, fs_1.existsSync)(filePath))
+                return;
+            const stat = (0, fs_1.statSync)(filePath);
+            if (stat.size >= maxBytes) {
+                (0, fs_1.renameSync)(filePath, filePath + '.1');
+            }
+        }
+        catch {
+            // Non-critical — rotation failure is not fatal
+        }
+    }
+    /** Record a metric entry in memory (ring buffer) and append to disk. */
     record(entry) {
-        this.entries.push(entry);
+        // Ring buffer: overwrite oldest when full
+        if (this.entries.length < MetricsCollector.MAX_ENTRIES) {
+            this.entries.push(entry);
+        }
+        else {
+            this.entries[this.ringIndex] = entry;
+            this.ringIndex = (this.ringIndex + 1) % MetricsCollector.MAX_ENTRIES;
+        }
+        this.totalRecorded++;
         try {
             const dir = (0, path_1.dirname)(constants_js_1.METRICS_FILE);
             if (!(0, fs_1.existsSync)(dir)) {
                 (0, fs_1.mkdirSync)(dir, { recursive: true });
             }
+            this.rotateIfNeeded(constants_js_1.METRICS_FILE, MetricsCollector.METRICS_MAX_BYTES);
             (0, fs_1.appendFileSync)(constants_js_1.METRICS_FILE, JSON.stringify(entry) + '\n', 'utf-8');
         }
         catch {
@@ -46,10 +74,7 @@ class MetricsCollector {
     }
     /** Get stats for a specific session. */
     getSessionStats(sessionId) {
-        const all = this.loadAll().filter((e) => {
-            // MetricEntry doesn't have session_id, but we stored it in the entry if available
-            return e.session_id === sessionId;
-        });
+        const all = this.loadAll().filter((e) => e.session_id === sessionId);
         const byEvent = new Map();
         for (const entry of all) {
             const existing = byEvent.get(entry.event) ?? [];
@@ -100,6 +125,103 @@ 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 });
+            }
+            this.rotateIfNeeded(constants_js_1.COSTS_FILE, MetricsCollector.COSTS_MAX_BYTES);
+            (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 +238,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/migrate.js

@@ -129,10 +129,14 @@ function migrate(options) {
         }
         // Add HTTP hook
         if (hadHandlers > 0) {
-            hookEntries.push({
+            const httpHook = {
                 type: 'http',
                 url: `http://localhost:${constants_js_1.DEFAULT_PORT}/hooks/${eventName}`,
-            });
+            };
+            if (manifest.settings?.authToken) {
+                httpHook.headers = { Authorization: `Bearer ${manifest.settings.authToken}` };
+            }
+            hookEntries.push(httpHook);
         }
         if (hookEntries.length > 0) {
             // Wrap in a single rule group (no matcher — clooks handles dispatch)

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.d.ts

@@ -1,4 +1,5 @@
 import { type Server } from 'http';
+import type { FSWatcher } from 'fs';
 import { MetricsCollector } from './metrics.js';
 import type { Manifest } from './types.js';
 export interface ServerContext {
@@ -6,6 +7,7 @@ export interface ServerContext {
     metrics: MetricsCollector;
     startTime: number;
     manifest: Manifest;
+    watcher?: FSWatcher;
 }
 /**
  * Create the HTTP server for hook handling.
@@ -14,7 +16,9 @@ export declare function createServer(manifest: Manifest, metrics: MetricsCollect
 /**
  * Start the daemon: bind the server and write PID file.
  */
-export declare function startDaemon(manifest: Manifest, metrics: MetricsCollector): Promise<ServerContext>;
+export declare function startDaemon(manifest: Manifest, metrics: MetricsCollector, options?: {
+    noWatch?: boolean;
+}): Promise<ServerContext>;
 /**
  * Stop a running daemon by reading PID file and sending SIGTERM.
  */
@@ -26,4 +30,6 @@ export declare function isDaemonRunning(): boolean;
 /**
  * Start daemon as a detached background process.
  */
-export declare function startDaemonBackground(): void;
+export declare function startDaemonBackground(options?: {
+    noWatch?: boolean;
+}): void;

package/dist/server.js

@@ -10,7 +10,11 @@ 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 watcher_js_1 = require("./watcher.js");
+const auth_js_1 = require("./auth.js");
 const constants_js_1 = require("./constants.js");
+const manifest_js_1 = require("./manifest.js");
 function log(msg) {
     const line = `[${new Date().toISOString()}] ${msg}\n`;
     try {
@@ -78,21 +82,32 @@ function sendJson(res, status, data) {
  */
 function createServer(manifest, metrics) {
     const startTime = Date.now();
+    const ctx = { server: null, metrics, startTime, manifest };
+    const authToken = manifest.settings?.authToken ?? '';
     const server = (0, http_1.createServer)(async (req, res) => {
         const url = req.url ?? '/';
         const method = req.method ?? 'GET';
-        // Health check endpoint
+        // Health check endpoint — no auth required for monitoring
         if (method === 'GET' && url === '/health') {
-            const handlerCount = Object.values(manifest.handlers)
+            const handlerCount = Object.values(ctx.manifest.handlers)
                 .reduce((sum, arr) => sum + (arr?.length ?? 0), 0);
             sendJson(res, 200, {
                 status: 'ok',
                 uptime: Math.floor((Date.now() - startTime) / 1000),
                 handlers_loaded: handlerCount,
-                port: manifest.settings?.port ?? constants_js_1.DEFAULT_PORT,
+                port: ctx.manifest.settings?.port ?? constants_js_1.DEFAULT_PORT,
             });
             return;
         }
+        // Auth check for all POST requests
+        if (method === 'POST' && authToken) {
+            const authHeader = req.headers['authorization'];
+            if (!(0, auth_js_1.validateAuth)(authHeader, authToken)) {
+                log(`Auth failure from ${req.socket.remoteAddress}`);
+                sendJson(res, 401, { error: 'Unauthorized' });
+                return;
+            }
+        }
         // Hook endpoint: POST /hooks/:eventName
         const hookMatch = url.match(/^\/hooks\/([A-Za-z]+)$/);
         if (method === 'POST' && hookMatch) {
@@ -102,7 +117,14 @@ function createServer(manifest, metrics) {
                 return;
             }
             const event = eventName;
-            const handlers = manifest.handlers[event] ?? [];
+            // On SessionStart, reset session-isolated handlers across ALL events
+            if (event === 'SessionStart') {
+                const allHandlers = Object.values(ctx.manifest.handlers)
+                    .flat()
+                    .filter((h) => h != null);
+                (0, handlers_js_1.resetSessionIsolatedHandlers)(allHandlers);
+            }
+            const handlers = ctx.manifest.handlers[event] ?? [];
             if (handlers.length === 0) {
                 sendJson(res, 200, {});
                 return;
@@ -119,8 +141,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 (ctx.manifest.prefetch && ctx.manifest.prefetch.length > 0) {
+                    context = await (0, prefetch_js_1.prefetchContext)(ctx.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 +156,28 @@ 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,
+                        session_id: input.session_id,
                     });
+                    // 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)'}`);
@@ -144,12 +192,13 @@ function createServer(manifest, metrics) {
         // 404 for everything else
         sendJson(res, 404, { error: 'Not found' });
     });
-    return { server, metrics, startTime, manifest };
+    ctx.server = server;
+    return ctx;
 }
 /**
  * Start the daemon: bind the server and write PID file.
  */
-function startDaemon(manifest, metrics) {
+function startDaemon(manifest, metrics, options) {
     return new Promise((resolve, reject) => {
         const ctx = createServer(manifest, metrics);
         const port = manifest.settings?.port ?? constants_js_1.DEFAULT_PORT;
@@ -169,12 +218,28 @@ function startDaemon(manifest, metrics) {
                 (0, fs_1.mkdirSync)(constants_js_1.CONFIG_DIR, { recursive: true });
             }
             (0, fs_1.writeFileSync)(constants_js_1.PID_FILE, String(process.pid), 'utf-8');
+            // Start file watcher unless disabled
+            if (!options?.noWatch) {
+                ctx.watcher = (0, watcher_js_1.startWatcher)(constants_js_1.MANIFEST_PATH, () => {
+                    try {
+                        const newManifest = (0, manifest_js_1.loadManifest)();
+                        ctx.manifest = newManifest;
+                        log('Manifest reloaded successfully');
+                    }
+                    catch (err) {
+                        log(`Manifest reload failed (keeping previous config): ${err instanceof Error ? err.message : err}`);
+                    }
+                }, (err) => {
+                    log(`Watcher error: ${err.message}`);
+                }) ?? undefined;
+            }
             log(`Daemon started on 127.0.0.1:${port} (pid ${process.pid})`);
             resolve(ctx);
         });
         // Graceful shutdown
         const shutdown = () => {
             log('Shutting down...');
+            (0, watcher_js_1.stopWatcher)(ctx.watcher ?? null);
             ctx.server.close(() => {
                 try {
                     if ((0, fs_1.existsSync)(constants_js_1.PID_FILE))
@@ -257,8 +322,12 @@ function isDaemonRunning() {
 /**
  * Start daemon as a detached background process.
  */
-function startDaemonBackground() {
-    const child = (0, child_process_1.spawn)(process.execPath, [process.argv[1], 'start', '--foreground'], {
+function startDaemonBackground(options) {
+    const args = [process.argv[1], 'start', '--foreground'];
+    if (options?.noWatch) {
+        args.push('--no-watch');
+    }
+    const child = (0, child_process_1.spawn)(process.execPath, args, {
         detached: true,
         stdio: 'ignore',
     });

package/dist/types.d.ts

@@ -14,34 +14,81 @@ export interface HookInput {
     stop_hook_active?: boolean;
     [key: string]: unknown;
 }
-/** Handler types in manifest */
-export type HandlerType = 'script' | 'inline';
-/** Configuration for a single handler */
-export interface HandlerConfig {
+/** Supported LLM models */
+export type LLMModel = 'claude-haiku-4-5' | 'claude-sonnet-4-6' | 'claude-opus-4-6';
+/** Handler types — extended with 'llm' */
+export type HandlerType = 'script' | 'inline' | 'llm';
+/** LLM-specific handler config fields */
+export interface LLMHandlerConfig {
     id: string;
-    type: HandlerType;
-    command?: string;
-    module?: string;
+    type: 'llm';
+    model: LLMModel;
+    prompt: string;
+    batchGroup?: string;
+    maxTokens?: number;
+    temperature?: number;
+    filter?: string;
     timeout?: number;
     enabled?: boolean;
+    sessionIsolation?: boolean;
 }
-/** The full manifest structure */
+/** Script handler config */
+export interface ScriptHandlerConfig {
+    id: string;
+    type: 'script';
+    command: string;
+    filter?: string;
+    timeout?: number;
+    enabled?: boolean;
+    sessionIsolation?: boolean;
+}
+/** Inline handler config */
+export interface InlineHandlerConfig {
+    id: string;
+    type: 'inline';
+    module: string;
+    filter?: string;
+    timeout?: number;
+    enabled?: boolean;
+    sessionIsolation?: boolean;
+}
+/** Union of all handler configs */
+export type HandlerConfig = ScriptHandlerConfig | InlineHandlerConfig | LLMHandlerConfig;
+/** Prefetchable context keys */
+export type PrefetchKey = 'transcript' | 'git_status' | 'git_diff';
+/** Pre-fetched context data */
+export interface PrefetchContext {
+    transcript?: string;
+    git_status?: string;
+    git_diff?: string;
+}
+/** Extended manifest with prefetch and LLM settings */
 export interface Manifest {
     handlers: Partial<Record<HookEvent, HandlerConfig[]>>;
+    prefetch?: PrefetchKey[];
     settings?: {
         port?: number;
         logLevel?: 'debug' | 'info' | 'warn' | 'error';
+        anthropicApiKey?: string;
+        authToken?: string;
     };
 }
-/** Result from executing a single handler */
-export interface HandlerResult {
-    id: string;
-    ok: boolean;
-    output?: unknown;
-    error?: string;
-    duration_ms: number;
+/** Token usage from API response */
+export interface TokenUsage {
+    input_tokens: number;
+    output_tokens: number;
 }
-/** A single metrics entry */
+/** Cost entry for tracking */
+export interface CostEntry {
+    ts: string;
+    event: HookEvent;
+    handler: string;
+    model: LLMModel;
+    usage: TokenUsage;
+    cost_usd: number;
+    batched: boolean;
+}
+/** Extended metrics entry with optional cost fields */
 export interface MetricEntry {
     ts: string;
     event: HookEvent;
@@ -49,6 +96,21 @@ export interface MetricEntry {
     duration_ms: number;
     ok: boolean;
     error?: string;
+    filtered?: boolean;
+    usage?: TokenUsage;
+    cost_usd?: number;
+    session_id?: string;
+}
+/** Extended handler result with cost info */
+export interface HandlerResult {
+    id: string;
+    ok: boolean;
+    output?: unknown;
+    error?: string;
+    duration_ms: number;
+    filtered?: boolean;
+    usage?: TokenUsage;
+    cost_usd?: number;
 }
 /** Runtime state for tracking consecutive failures */
 export interface HandlerState {

package/dist/watcher.d.ts

@@ -0,0 +1,18 @@
+import { type FSWatcher } from 'fs';
+type ReloadCallback = () => void;
+type ErrorCallback = (err: Error) => void;
+export interface WatcherOptions {
+    onReload: ReloadCallback;
+    onError?: ErrorCallback;
+}
+/**
+ * Watch manifest.yaml for changes.
+ * Calls onReload when changes detected (debounced).
+ * If the manifest file doesn't exist, watches the config directory for its creation.
+ */
+export declare function startWatcher(manifestPath: string, onReload: ReloadCallback, onError?: ErrorCallback): FSWatcher | null;
+/**
+ * Stop watching for file changes.
+ */
+export declare function stopWatcher(watcher: FSWatcher | null): void;
+export {};