clodds 1.1.0

package/dist/hooks/index.js

@@ -0,0 +1,739 @@
+"use strict";
+/**
+ * Hooks System - Clawdbot-style event hooks with full lifecycle support
+ *
+ * Features:
+ * - Register hooks for events (message, response, tool, agent, gateway, etc.)
+ * - Sync and async hooks
+ * - Hook priorities (higher runs first)
+ * - Hook filtering by channel/user
+ * - Result-returning hooks (can modify events)
+ * - Tool interception (before/after tool calls)
+ * - Message modification capability
+ * - Gateway and agent lifecycle hooks
+ * - Hook discovery from filesystem
+ * - Eligibility checking (requirements validation)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hooks = void 0;
+exports.createHooksService = createHooksService;
+exports.createToolHook = createToolHook;
+exports.createMessageFilter = createMessageFilter;
+exports.createSystemPromptInjector = createSystemPromptInjector;
+exports.getHooksDir = getHooksDir;
+exports.getHooksStatePath = getHooksStatePath;
+exports.getHookStateStorePath = getHookStateStorePath;
+exports.resolveHookStateKey = resolveHookStateKey;
+exports.loadHookStateStore = loadHookStateStore;
+exports.saveHookStateStore = saveHookStateStore;
+exports.loadHooksState = loadHooksState;
+exports.saveHooksState = saveHooksState;
+exports.getHookSourceEnabled = getHookSourceEnabled;
+exports.setHookSourceEnabled = setHookSourceEnabled;
+exports.removeHookSourceState = removeHookSourceState;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const os_1 = require("os");
+const id_1 = require("../utils/id");
+const logger_1 = require("../utils/logger");
+// =============================================================================
+// HOOK EXECUTION MODES BY EVENT
+// =============================================================================
+const EVENT_EXECUTION_MODES = {
+    // Sequential (can modify)
+    'message:before': 'sequential',
+    'message:sending': 'sequential',
+    'response:before': 'sequential',
+    'agent:before_start': 'sequential',
+    'compaction:before': 'sequential',
+    'tool:before_call': 'sequential',
+    'tool:result_persist': 'sequential',
+    // Parallel (fire-and-forget)
+    'message:after': 'parallel',
+    'message:received': 'parallel',
+    'message:sent': 'parallel',
+    'response:after': 'parallel',
+    'session:start': 'parallel',
+    'session:end': 'parallel',
+    'session:reset': 'parallel',
+    'session:created': 'parallel',
+    'agent:end': 'parallel',
+    'compaction:after': 'parallel',
+    'tool:after_call': 'parallel',
+    'gateway:start': 'parallel',
+    'gateway:stop': 'parallel',
+    'error': 'parallel',
+};
+// =============================================================================
+// IMPLEMENTATION
+// =============================================================================
+function createHooksService() {
+    const hooks = new Map();
+    let idCounter = 0;
+    const hooksDir = getHooksDir();
+    let currentSourcePath = null;
+    let tracingEnabled = process.env.CLODDS_HOOK_TRACE === '1';
+    let traceLimit = Math.max(10, Number.parseInt(process.env.CLODDS_HOOK_TRACE_LIMIT || '200', 10));
+    const traces = [];
+    const traceFilePath = process.env.CLODDS_HOOK_TRACE_FILE || (0, path_1.join)(hooksDir, 'trace.log');
+    const activeRuns = new Map();
+    const stateStorePath = getHookStateStorePath();
+    let stateStore = loadHookStateStore(stateStorePath);
+    // Ensure hooks directory exists
+    if (!(0, fs_1.existsSync)(hooksDir)) {
+        (0, fs_1.mkdirSync)(hooksDir, { recursive: true });
+    }
+    /**
+     * Check if requirements are met
+     */
+    function checkRequirements(requirements) {
+        const missing = [];
+        // Check required binaries
+        if (requirements.bins) {
+            for (const bin of requirements.bins) {
+                try {
+                    // Use execFileSync to prevent command injection
+                    require('child_process').execFileSync('which', [bin], { stdio: 'ignore' });
+                }
+                catch {
+                    missing.push(`bin:${bin}`);
+                }
+            }
+        }
+        // Check required env vars
+        if (requirements.env) {
+            for (const envVar of requirements.env) {
+                if (!process.env[envVar]) {
+                    missing.push(`env:${envVar}`);
+                }
+            }
+        }
+        // Check OS
+        if (requirements.os) {
+            const platform = process.platform;
+            if (!requirements.os.includes(platform)) {
+                missing.push(`os:${platform}`);
+            }
+        }
+        return { met: missing.length === 0, missing };
+    }
+    /**
+     * Get matching hooks for an event
+     */
+    function getMatchingHooks(event, ctx) {
+        return Array.from(hooks.values())
+            .filter((h) => h.event === event && h.enabled)
+            .filter((h) => {
+            if (!h.filter)
+                return true;
+            if (h.filter.channels && ctx.message && !h.filter.channels.includes(ctx.message.platform))
+                return false;
+            if (h.filter.users && ctx.message && !h.filter.users.includes(ctx.message.userId))
+                return false;
+            if (h.filter.tools && ctx.toolName && !h.filter.tools.includes(ctx.toolName))
+                return false;
+            if (h.filter.tools && !ctx.toolName)
+                return false;
+            return true;
+        })
+            .filter((h) => {
+            if (!h.when)
+                return true;
+            return evaluateHookCondition(h.when, ctx);
+        })
+            .filter((h) => {
+            if (!h.requirements)
+                return true;
+            return checkRequirements(h.requirements).met;
+        })
+            .sort((a, b) => b.priority - a.priority);
+    }
+    const service = {
+        register(event, fn, opts = {}) {
+            const id = `hook_${++idCounter}`;
+            const execution = opts.execution ?? EVENT_EXECUTION_MODES[event] ?? 'parallel';
+            const sourcePath = opts.sourcePath ?? currentSourcePath ?? undefined;
+            const hook = {
+                id,
+                name: opts.name,
+                event,
+                fn: fn,
+                priority: opts.priority ?? 0,
+                execution,
+                syncOnly: opts.syncOnly,
+                filter: opts.filter,
+                when: opts.when,
+                requirements: opts.requirements,
+                enabled: true,
+                sourcePath,
+            };
+            const persistedEnabled = sourcePath ? getHookSourceEnabled(sourcePath) : undefined;
+            if (persistedEnabled === false) {
+                hook.enabled = false;
+            }
+            hooks.set(id, hook);
+            if (sourcePath && persistedEnabled === undefined) {
+                setHookSourceEnabled(sourcePath, true);
+            }
+            logger_1.logger.debug({ id, event, name: opts.name }, 'Hook registered');
+            return id;
+        },
+        unregister(id) {
+            const existed = hooks.delete(id);
+            if (existed) {
+                logger_1.logger.debug({ id }, 'Hook unregistered');
+            }
+            return existed;
+        },
+        setEnabled(id, enabled) {
+            const hook = hooks.get(id);
+            if (!hook)
+                return false;
+            hook.enabled = enabled;
+            if (hook.sourcePath) {
+                setHookSourceEnabled(hook.sourcePath, enabled);
+            }
+            logger_1.logger.debug({ id, enabled }, 'Hook enabled state changed');
+            return true;
+        },
+        async trigger(event, partialCtx) {
+            const { ctx, runId, controller } = createRunContext(event, partialCtx);
+            const matching = getMatchingHooks(event, ctx);
+            const execution = EVENT_EXECUTION_MODES[event] ?? 'parallel';
+            if (execution === 'parallel') {
+                // Fire all hooks in parallel, don't wait
+                await Promise.all(matching.map(async (hook) => {
+                    const startedAt = Date.now();
+                    try {
+                        if (ctx.abortSignal?.aborted || ctx.cancelled)
+                            return;
+                        const hookCtx = bindHookState(ctx, hook);
+                        await hook.fn(hookCtx);
+                        recordTrace(hook, event, startedAt, 'ok');
+                    }
+                    catch (error) {
+                        logger_1.logger.error({ hookId: hook.id, error }, 'Hook error');
+                        recordTrace(hook, event, startedAt, 'error', error);
+                    }
+                }));
+            }
+            else {
+                // Sequential execution
+                for (const hook of matching) {
+                    if (ctx.cancelled || ctx.abortSignal?.aborted)
+                        break;
+                    const startedAt = Date.now();
+                    try {
+                        const hookCtx = bindHookState(ctx, hook);
+                        await hook.fn(hookCtx);
+                        recordTrace(hook, event, startedAt, 'ok');
+                    }
+                    catch (error) {
+                        logger_1.logger.error({ hookId: hook.id, error }, 'Hook error');
+                        recordTrace(hook, event, startedAt, 'error', error);
+                    }
+                }
+            }
+            finalizeRun(runId, controller);
+            return ctx;
+        },
+        async triggerWithResult(event, partialCtx, mergeResults) {
+            const { ctx, runId, controller } = createRunContext(event, partialCtx);
+            const matching = getMatchingHooks(event, ctx);
+            const results = [];
+            // Always sequential for result-returning hooks
+            for (const hook of matching) {
+                if (ctx.cancelled || ctx.abortSignal?.aborted)
+                    break;
+                const startedAt = Date.now();
+                try {
+                    const hookCtx = bindHookState(ctx, hook);
+                    const result = await hook.fn(hookCtx);
+                    if (result !== undefined) {
+                        results.push(result);
+                    }
+                    recordTrace(hook, event, startedAt, 'ok');
+                }
+                catch (error) {
+                    logger_1.logger.error({ hookId: hook.id, error }, 'Hook error');
+                    recordTrace(hook, event, startedAt, 'error', error);
+                }
+            }
+            // Merge results if merger provided
+            const finalResult = mergeResults && results.length > 0
+                ? mergeResults(results)
+                : results[results.length - 1]; // Default: last result wins
+            finalizeRun(runId, controller);
+            return { ctx, result: finalResult };
+        },
+        triggerSync(event, partialCtx) {
+            const { ctx, runId, controller } = createRunContext(event, partialCtx);
+            const matching = getMatchingHooks(event, ctx).filter(h => h.syncOnly !== false);
+            for (const hook of matching) {
+                if (ctx.cancelled || ctx.abortSignal?.aborted)
+                    break;
+                const startedAt = Date.now();
+                try {
+                    const hookCtx = bindHookState(ctx, hook);
+                    // Call synchronously (ignoring promises)
+                    hook.fn(hookCtx);
+                    recordTrace(hook, event, startedAt, 'ok');
+                }
+                catch (error) {
+                    logger_1.logger.error({ hookId: hook.id, error }, 'Sync hook error');
+                    recordTrace(hook, event, startedAt, 'error', error);
+                }
+            }
+            finalizeRun(runId, controller);
+            return ctx;
+        },
+        list() {
+            return Array.from(hooks.values());
+        },
+        get(id) {
+            return hooks.get(id);
+        },
+        checkRequirements,
+        async discover(directories) {
+            let count = 0;
+            for (const dir of directories) {
+                if (!(0, fs_1.existsSync)(dir))
+                    continue;
+                const entries = (0, fs_1.readdirSync)(dir, { withFileTypes: true });
+                for (const entry of entries) {
+                    if (!entry.isDirectory())
+                        continue;
+                    const hookDir = (0, path_1.join)(dir, entry.name);
+                    const metadataPath = (0, path_1.join)(hookDir, 'HOOK.md');
+                    const indexPath = (0, path_1.join)(hookDir, 'index.js');
+                    // Check for HOOK.md metadata
+                    if (!(0, fs_1.existsSync)(metadataPath) && !(0, fs_1.existsSync)(indexPath))
+                        continue;
+                    try {
+                        // Try to load the hook
+                        if ((0, fs_1.existsSync)(indexPath)) {
+                            currentSourcePath = hookDir;
+                            const hookModule = require(indexPath);
+                            if (typeof hookModule.register === 'function') {
+                                hookModule.register(service);
+                                count++;
+                                logger_1.logger.info({ hook: entry.name }, 'Hook discovered and registered');
+                            }
+                        }
+                    }
+                    catch (error) {
+                        logger_1.logger.warn({ hook: entry.name, error }, 'Failed to load hook');
+                    }
+                    finally {
+                        currentSourcePath = null;
+                    }
+                }
+            }
+            return count;
+        },
+        async install(hookPath) {
+            const hookName = (0, path_1.basename)(hookPath);
+            const destDir = (0, path_1.join)(hooksDir, hookName);
+            // Copy hook to hooks directory
+            if (!(0, fs_1.existsSync)(destDir)) {
+                (0, fs_1.mkdirSync)(destDir, { recursive: true });
+            }
+            // Simple copy (in production, would handle npm packages, git repos, etc.)
+            const indexPath = (0, path_1.join)(hookPath, 'index.js');
+            if ((0, fs_1.existsSync)(indexPath)) {
+                const content = (0, fs_1.readFileSync)(indexPath, 'utf-8');
+                (0, fs_1.writeFileSync)((0, path_1.join)(destDir, 'index.js'), content);
+            }
+            // Try to register
+            await this.discover([hooksDir]);
+            return hookName;
+        },
+        setTracingEnabled(enabled) {
+            tracingEnabled = enabled;
+        },
+        setTraceLimit(limit) {
+            traceLimit = Math.max(10, limit);
+            if (traces.length > traceLimit) {
+                traces.splice(0, traces.length - traceLimit);
+            }
+        },
+        listTraces(limit) {
+            if (!tracingEnabled)
+                return [];
+            if (!limit || limit >= traces.length) {
+                return [...traces];
+            }
+            return traces.slice(Math.max(0, traces.length - limit));
+        },
+        clearTraces() {
+            traces.length = 0;
+        },
+        cancel(runId, reason) {
+            const run = activeRuns.get(runId);
+            if (!run)
+                return false;
+            run.ctx.cancelled = true;
+            run.ctx.cancelledReason = reason;
+            run.controller.abort(reason);
+            return true;
+        },
+        listActiveRuns() {
+            return Array.from(activeRuns.entries()).map(([runId, run]) => ({
+                runId,
+                event: run.ctx.event,
+                startedAt: new Date(run.startedAt).toISOString(),
+                cancelled: Boolean(run.ctx.cancelled || run.ctx.abortSignal?.aborted),
+                reason: run.ctx.cancelledReason,
+            }));
+        },
+        getState(hookKey, key) {
+            const entry = stateStore.data[hookKey];
+            if (!entry)
+                return undefined;
+            if (!key)
+                return { ...entry };
+            return entry[key];
+        },
+        setState(hookKey, key, value) {
+            if (!stateStore.data[hookKey]) {
+                stateStore.data[hookKey] = {};
+            }
+            stateStore.data[hookKey][key] = value;
+            persistHookStateStore();
+        },
+        clearState(hookKey, key) {
+            if (!stateStore.data[hookKey])
+                return;
+            if (key) {
+                delete stateStore.data[hookKey][key];
+            }
+            else {
+                delete stateStore.data[hookKey];
+            }
+            persistHookStateStore();
+        },
+    };
+    function createRunContext(event, partialCtx) {
+        const runId = (0, id_1.generateId)('hookrun');
+        const controller = new AbortController();
+        const ctx = {
+            event,
+            data: {},
+            ...partialCtx,
+            runId,
+            abortSignal: controller.signal,
+        };
+        activeRuns.set(runId, { ctx, controller, startedAt: Date.now() });
+        controller.signal.addEventListener('abort', () => {
+            ctx.cancelled = true;
+            ctx.cancelledReason = ctx.cancelledReason ?? 'cancelled';
+        }, { once: true });
+        return { ctx, runId, controller };
+    }
+    function finalizeRun(runId, _controller) {
+        activeRuns.delete(runId);
+    }
+    function recordTrace(hook, event, startedAtMs, status, error) {
+        if (!tracingEnabled)
+            return;
+        const entry = {
+            id: (0, id_1.generateId)('trace'),
+            hookId: hook.id,
+            hookName: hook.name,
+            event,
+            execution: hook.execution,
+            startedAt: new Date(startedAtMs).toISOString(),
+            durationMs: Math.max(0, Date.now() - startedAtMs),
+            status,
+            error: error instanceof Error ? error.message : error ? String(error) : undefined,
+        };
+        traces.push(entry);
+        if (traces.length > traceLimit) {
+            traces.splice(0, traces.length - traceLimit);
+        }
+        writeTraceToFile(entry);
+    }
+    function writeTraceToFile(entry) {
+        if (!traceFilePath)
+            return;
+        try {
+            const line = `${JSON.stringify(entry)}\n`;
+            (0, fs_1.appendFileSync)(traceFilePath, line);
+            rotateTraceFileIfNeeded();
+        }
+        catch (error) {
+            logger_1.logger.warn({ error }, 'Failed to write hook trace file');
+        }
+    }
+    function rotateTraceFileIfNeeded() {
+        try {
+            const stats = (0, fs_1.statSync)(traceFilePath);
+            const maxBytes = 5 * 1024 * 1024; // 5MB
+            if (stats.size < maxBytes)
+                return;
+            const rotated = `${traceFilePath}.${Date.now()}`;
+            (0, fs_1.renameSync)(traceFilePath, rotated);
+        }
+        catch {
+            // ignore rotation errors
+        }
+    }
+    function bindHookState(ctx, hook) {
+        const hookStateKey = resolveHookStateKey(hook.sourcePath || hook.name || hook.id);
+        const bound = ctx;
+        bound.hookId = hook.id;
+        bound.hookName = hook.name;
+        bound.hookStateKey = hookStateKey;
+        bound.getState = (key, defaultValue) => {
+            const entry = stateStore.data[hookStateKey];
+            if (entry && Object.prototype.hasOwnProperty.call(entry, key)) {
+                return entry[key];
+            }
+            return defaultValue;
+        };
+        bound.setState = (key, value) => {
+            if (!stateStore.data[hookStateKey]) {
+                stateStore.data[hookStateKey] = {};
+            }
+            stateStore.data[hookStateKey][key] = value;
+            persistHookStateStore();
+        };
+        bound.clearState = (key) => {
+            if (!stateStore.data[hookStateKey])
+                return;
+            if (key) {
+                delete stateStore.data[hookStateKey][key];
+            }
+            else {
+                delete stateStore.data[hookStateKey];
+            }
+            persistHookStateStore();
+        };
+        return bound;
+    }
+    function persistHookStateStore() {
+        stateStore.updatedAt = new Date().toISOString();
+        saveHookStateStore(stateStorePath, stateStore);
+    }
+    function evaluateHookCondition(condition, ctx) {
+        if ('any' in condition || 'all' in condition || 'not' in condition) {
+            const anyResult = condition.any ? condition.any.some((c) => evaluateHookCondition(c, ctx)) : undefined;
+            const allResult = condition.all ? condition.all.every((c) => evaluateHookCondition(c, ctx)) : undefined;
+            const notResult = condition.not ? !evaluateHookCondition(condition.not, ctx) : undefined;
+            const results = [anyResult, allResult, notResult].filter((v) => v !== undefined);
+            return results.length > 0 ? results.every(Boolean) : true;
+        }
+        const fieldCondition = condition;
+        const fieldValue = getConditionFieldValue(fieldCondition.field, ctx);
+        if (fieldValue === undefined || fieldValue === null)
+            return false;
+        switch (fieldCondition.op) {
+            case 'eq':
+                return fieldValue === fieldCondition.value;
+            case 'neq':
+                return fieldValue !== fieldCondition.value;
+            case 'in':
+                return Array.isArray(fieldCondition.value) && fieldCondition.value.includes(String(fieldValue));
+            case 'contains':
+                return String(fieldValue).includes(String(fieldCondition.value));
+            case 'startsWith':
+                return String(fieldValue).startsWith(String(fieldCondition.value));
+            case 'endsWith':
+                return String(fieldValue).endsWith(String(fieldCondition.value));
+            case 'regex':
+                try {
+                    const pattern = Array.isArray(fieldCondition.value)
+                        ? fieldCondition.value.join('|')
+                        : fieldCondition.value;
+                    return new RegExp(pattern).test(String(fieldValue));
+                }
+                catch {
+                    return false;
+                }
+            default:
+                return false;
+        }
+    }
+    function getConditionFieldValue(field, ctx) {
+        switch (field) {
+            case 'channel':
+                return ctx.message?.platform;
+            case 'userId':
+                return ctx.message?.userId;
+            case 'agentId':
+                return ctx.agentId;
+            case 'toolName':
+                return ctx.toolName;
+            case 'messageText':
+                return ctx.message?.text;
+            case 'event':
+                return ctx.event;
+            default:
+                return undefined;
+        }
+    }
+    return service;
+}
+// =============================================================================
+// HELPER FUNCTIONS FOR COMMON HOOK PATTERNS
+// =============================================================================
+/**
+ * Create a tool interception hook
+ */
+function createToolHook(service, toolName, handlers) {
+    const ids = [];
+    const matchTool = (name) => typeof toolName === 'string' ? name === toolName : toolName.test(name);
+    if (handlers.before) {
+        ids.push(service.register('tool:before_call', async (ctx) => {
+            if (!matchTool(ctx.toolName))
+                return;
+            return handlers.before(ctx);
+        }, { name: `tool_hook_before_${toolName}` }));
+    }
+    if (handlers.after) {
+        ids.push(service.register('tool:after_call', async (ctx) => {
+            if (!matchTool(ctx.toolName))
+                return;
+            return handlers.after(ctx);
+        }, { name: `tool_hook_after_${toolName}` }));
+    }
+    return ids;
+}
+/**
+ * Create a message filter hook
+ */
+function createMessageFilter(service, filter, transform) {
+    return service.register('message:sending', (ctx) => {
+        if (!filter(ctx)) {
+            return { cancel: true };
+        }
+        if (transform) {
+            return { content: transform(ctx.content, ctx) };
+        }
+        return;
+    }, { name: 'message_filter' });
+}
+/**
+ * Create an agent system prompt injector
+ */
+function createSystemPromptInjector(service, inject) {
+    return service.register('agent:before_start', (ctx) => {
+        const extra = inject(ctx);
+        if (extra) {
+            return {
+                systemPrompt: ctx.systemPrompt ? `${ctx.systemPrompt}\n\n${extra}` : extra,
+            };
+        }
+        return;
+    }, { name: 'system_prompt_injector' });
+}
+// =============================================================================
+// EXPORTS
+// =============================================================================
+exports.hooks = createHooksService();
+function getHooksDir() {
+    return (0, path_1.join)((0, os_1.homedir)(), '.clodds', 'hooks');
+}
+function getHooksStatePath() {
+    return (0, path_1.join)(getHooksDir(), 'hooks.json');
+}
+function getHookStateStorePath() {
+    return (0, path_1.join)(getHooksDir(), 'hook-state.json');
+}
+function resolveHookStateKey(input) {
+    if (!input)
+        return input;
+    if (input.startsWith('~')) {
+        return (0, path_1.join)((0, os_1.homedir)(), input.slice(1));
+    }
+    if (input.includes('/') || input.includes('\\')) {
+        return input;
+    }
+    return (0, path_1.join)(getHooksDir(), input);
+}
+function loadHookStateStore(pathOverride) {
+    const path = pathOverride || getHookStateStorePath();
+    if (!(0, fs_1.existsSync)(path)) {
+        return { version: 1, data: {} };
+    }
+    try {
+        const parsed = JSON.parse((0, fs_1.readFileSync)(path, 'utf-8'));
+        if (!parsed.data) {
+            return { version: 1, data: {} };
+        }
+        return parsed;
+    }
+    catch (error) {
+        logger_1.logger.warn({ error }, 'Failed to load hook state store');
+        return { version: 1, data: {} };
+    }
+}
+function saveHookStateStore(pathOverride, store) {
+    const path = pathOverride || getHookStateStorePath();
+    try {
+        if (!(0, fs_1.existsSync)(getHooksDir())) {
+            (0, fs_1.mkdirSync)(getHooksDir(), { recursive: true });
+        }
+        (0, fs_1.writeFileSync)(path, JSON.stringify({
+            version: store.version || 1,
+            data: store.data || {},
+            updatedAt: store.updatedAt,
+        }, null, 2));
+    }
+    catch (error) {
+        logger_1.logger.warn({ error }, 'Failed to save hook state store');
+    }
+}
+function loadHooksState() {
+    const statePath = getHooksStatePath();
+    if (!(0, fs_1.existsSync)(statePath)) {
+        return { version: 1, sources: {} };
+    }
+    try {
+        const parsed = JSON.parse((0, fs_1.readFileSync)(statePath, 'utf-8'));
+        if (!parsed.sources) {
+            return { version: 1, sources: {} };
+        }
+        return parsed;
+    }
+    catch (error) {
+        logger_1.logger.warn({ error }, 'Failed to load hooks state');
+        return { version: 1, sources: {} };
+    }
+}
+function saveHooksState(state) {
+    try {
+        const statePath = getHooksStatePath();
+        if (!(0, fs_1.existsSync)(getHooksDir())) {
+            (0, fs_1.mkdirSync)(getHooksDir(), { recursive: true });
+        }
+        (0, fs_1.writeFileSync)(statePath, JSON.stringify({
+            version: state.version || 1,
+            sources: state.sources || {},
+        }, null, 2));
+    }
+    catch (error) {
+        logger_1.logger.warn({ error }, 'Failed to save hooks state');
+    }
+}
+function getHookSourceEnabled(sourcePath) {
+    const state = loadHooksState();
+    const entry = state.sources[sourcePath];
+    return entry ? entry.enabled : undefined;
+}
+function setHookSourceEnabled(sourcePath, enabled) {
+    const state = loadHooksState();
+    state.sources[sourcePath] = {
+        enabled,
+        updatedAt: new Date().toISOString(),
+    };
+    saveHooksState(state);
+}
+function removeHookSourceState(sourcePath) {
+    const state = loadHooksState();
+    if (state.sources[sourcePath]) {
+        delete state.sources[sourcePath];
+        saveHooksState(state);
+    }
+}
+//# sourceMappingURL=index.js.map