claude-flow 3.28.0 → 3.30.0

package/v3/@claude-flow/shared/dist/hooks/executor.js

@@ -0,0 +1,267 @@
+/**
+ * V3 Hooks System - Hook Executor
+ *
+ * Executes hooks in priority order with timeout handling and error recovery.
+ * Integrates with event bus for coordination and monitoring.
+ *
+ * @module v3/shared/hooks/executor
+ */
+/**
+ * Hook executor implementation
+ */
+export class HookExecutor {
+    registry;
+    eventBus;
+    constructor(registry, eventBus) {
+        this.registry = registry;
+        this.eventBus = eventBus;
+    }
+    /**
+     * Execute all hooks for an event
+     *
+     * @param event - Hook event type
+     * @param context - Hook context
+     * @param options - Execution options
+     * @returns Aggregated results
+     */
+    async execute(event, context, options = {}) {
+        const startTime = Date.now();
+        const results = [];
+        let aborted = false;
+        let finalContext = {};
+        // Get enabled hooks for this event
+        const hooks = this.registry.getHandlers(event, false);
+        // Emit pre-execution event
+        this.eventBus?.emit('hooks:pre-execute', {
+            event,
+            hookCount: hooks.length,
+            context,
+        });
+        // Execute hooks in priority order
+        for (const hook of hooks) {
+            if (aborted) {
+                break;
+            }
+            try {
+                const result = await this.executeSingleHook(hook.handler, context, hook.timeout || options.timeout);
+                results.push(result);
+                // Record execution statistics
+                this.registry.recordExecution(result.success, result.executionTime || 0);
+                // Merge context modifications
+                if (result.data) {
+                    finalContext = { ...finalContext, ...result.data };
+                    // Update context for next hooks
+                    Object.assign(context, result.data);
+                }
+                // Check if we should abort
+                if (result.abort) {
+                    aborted = true;
+                    break;
+                }
+                // Check if we should stop the chain
+                if (result.continueChain === false) {
+                    break;
+                }
+                // Check if we should stop on error
+                if (!result.success && !options.continueOnError) {
+                    aborted = true;
+                    break;
+                }
+            }
+            catch (error) {
+                const errorResult = {
+                    success: false,
+                    error: error instanceof Error ? error : new Error(String(error)),
+                    continueChain: options.continueOnError,
+                };
+                results.push(errorResult);
+                this.registry.recordExecution(false, 0);
+                // Emit error event
+                this.eventBus?.emit('hooks:error', {
+                    event,
+                    hookId: hook.id,
+                    error,
+                });
+                if (!options.continueOnError) {
+                    aborted = true;
+                    break;
+                }
+            }
+        }
+        const totalExecutionTime = Date.now() - startTime;
+        const hooksFailed = results.filter(r => !r.success).length;
+        // Build aggregated result
+        const aggregatedResult = {
+            success: hooksFailed === 0 && !aborted,
+            results: options.collectResults ? results : [],
+            totalExecutionTime,
+            hooksExecuted: results.length,
+            hooksFailed,
+            aborted,
+            finalContext,
+        };
+        // Emit post-execution event
+        this.eventBus?.emit('hooks:post-execute', {
+            event,
+            ...aggregatedResult,
+        });
+        return aggregatedResult;
+    }
+    /**
+     * Execute hooks with timeout
+     *
+     * @param event - Hook event type
+     * @param context - Hook context
+     * @param timeout - Timeout in ms
+     * @returns Aggregated results
+     */
+    async executeWithTimeout(event, context, timeout) {
+        return this.withTimeout(this.execute(event, context, { timeout }), timeout);
+    }
+    /**
+     * Execute a single hook with timeout and error handling
+     *
+     * @param handler - Hook handler function
+     * @param context - Hook context
+     * @param timeout - Optional timeout in ms
+     * @returns Hook result
+     */
+    async executeSingleHook(handler, context, timeout) {
+        const startTime = Date.now();
+        try {
+            let resultPromise = Promise.resolve(handler(context));
+            // Apply timeout if specified
+            if (timeout && timeout > 0) {
+                resultPromise = this.withTimeout(resultPromise, timeout);
+            }
+            const result = await resultPromise;
+            const executionTime = Date.now() - startTime;
+            return {
+                ...result,
+                executionTime,
+            };
+        }
+        catch (error) {
+            const executionTime = Date.now() - startTime;
+            return {
+                success: false,
+                error: error instanceof Error ? error : new Error(String(error)),
+                executionTime,
+            };
+        }
+    }
+    /**
+     * Execute multiple hooks in parallel
+     *
+     * @param events - Array of hook events
+     * @param contexts - Array of contexts (matched by index)
+     * @param options - Execution options
+     * @returns Array of aggregated results
+     */
+    async executeParallel(events, contexts, options = {}) {
+        if (events.length !== contexts.length) {
+            throw new Error('Events and contexts arrays must have same length');
+        }
+        const maxParallel = options.maxParallel || events.length;
+        const results = [];
+        // Execute in batches
+        for (let i = 0; i < events.length; i += maxParallel) {
+            const batch = events.slice(i, i + maxParallel);
+            const batchContexts = contexts.slice(i, i + maxParallel);
+            const batchResults = await Promise.allSettled(batch.map((event, index) => this.execute(event, batchContexts[index], options)));
+            for (const result of batchResults) {
+                if (result.status === 'fulfilled') {
+                    results.push(result.value);
+                }
+                else {
+                    // Create error result for rejected promises
+                    results.push({
+                        success: false,
+                        results: [{
+                                success: false,
+                                error: result.reason instanceof Error
+                                    ? result.reason
+                                    : new Error(String(result.reason)),
+                            }],
+                        totalExecutionTime: 0,
+                        hooksExecuted: 0,
+                        hooksFailed: 1,
+                        aborted: true,
+                    });
+                }
+            }
+        }
+        return results;
+    }
+    /**
+     * Execute hooks sequentially with context chaining
+     *
+     * @param events - Array of hook events
+     * @param initialContext - Initial context
+     * @param options - Execution options
+     * @returns Final aggregated result with chained context
+     */
+    async executeSequential(events, initialContext, options = {}) {
+        const results = [];
+        let currentContext = { ...initialContext };
+        let totalExecutionTime = 0;
+        let totalHooksExecuted = 0;
+        let totalHooksFailed = 0;
+        let aborted = false;
+        for (const event of events) {
+            if (aborted) {
+                break;
+            }
+            const result = await this.execute(event, currentContext, options);
+            results.push(...result.results);
+            totalExecutionTime += result.totalExecutionTime;
+            totalHooksExecuted += result.hooksExecuted;
+            totalHooksFailed += result.hooksFailed;
+            // Merge context for next event
+            if (result.finalContext) {
+                currentContext = { ...currentContext, ...result.finalContext };
+            }
+            if (result.aborted || !result.success) {
+                aborted = true;
+                break;
+            }
+        }
+        return {
+            success: totalHooksFailed === 0 && !aborted,
+            results: options.collectResults ? results : [],
+            totalExecutionTime,
+            hooksExecuted: totalHooksExecuted,
+            hooksFailed: totalHooksFailed,
+            aborted,
+            finalContext: currentContext,
+        };
+    }
+    /**
+     * Wrap a promise with timeout
+     */
+    async withTimeout(promise, timeout) {
+        return Promise.race([
+            promise,
+            new Promise((_, reject) => setTimeout(() => reject(new Error(`Hook execution timeout after ${timeout}ms`)), timeout)),
+        ]);
+    }
+    /**
+     * Set event bus for coordination
+     */
+    setEventBus(eventBus) {
+        this.eventBus = eventBus;
+    }
+    /**
+     * Get hook registry
+     */
+    getRegistry() {
+        return this.registry;
+    }
+}
+/**
+ * Create a new hook executor
+ */
+export function createHookExecutor(registry, eventBus) {
+    return new HookExecutor(registry, eventBus);
+}
+//# sourceMappingURL=executor.js.map

package/v3/@claude-flow/shared/dist/hooks/hooks.test.d.ts

@@ -0,0 +1,9 @@
+/**
+ * V3 Hooks System - Tests
+ *
+ * Comprehensive tests for hook registry and executor.
+ *
+ * @module v3/shared/hooks/hooks.test
+ */
+export {};
+//# sourceMappingURL=hooks.test.d.ts.map

package/v3/@claude-flow/shared/dist/hooks/hooks.test.js

@@ -0,0 +1,322 @@
+/**
+ * V3 Hooks System - Tests
+ *
+ * Comprehensive tests for hook registry and executor.
+ *
+ * @module v3/shared/hooks/hooks.test
+ */
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { createHookRegistry } from './registry.js';
+import { createHookExecutor } from './executor.js';
+import { HookEvent, HookPriority } from './types.js';
+import { createEventBus } from '../core/event-bus.js';
+describe('HookRegistry', () => {
+    let registry;
+    beforeEach(() => {
+        registry = createHookRegistry();
+    });
+    it('should register a hook', () => {
+        const handler = vi.fn();
+        const id = registry.register(HookEvent.PreToolUse, handler);
+        expect(id).toBeDefined();
+        expect(registry.has(id)).toBe(true);
+        expect(registry.count()).toBe(1);
+    });
+    it('should unregister a hook', () => {
+        const handler = vi.fn();
+        const id = registry.register(HookEvent.PreToolUse, handler);
+        const result = registry.unregister(id);
+        expect(result).toBe(true);
+        expect(registry.has(id)).toBe(false);
+        expect(registry.count()).toBe(0);
+    });
+    it('should return false when unregistering non-existent hook', () => {
+        const result = registry.unregister('non-existent');
+        expect(result).toBe(false);
+    });
+    it('should get handlers sorted by priority', () => {
+        const handler1 = vi.fn();
+        const handler2 = vi.fn();
+        const handler3 = vi.fn();
+        registry.register(HookEvent.PreToolUse, handler1, HookPriority.Normal);
+        registry.register(HookEvent.PreToolUse, handler2, HookPriority.High);
+        registry.register(HookEvent.PreToolUse, handler3, HookPriority.Low);
+        const handlers = registry.getHandlers(HookEvent.PreToolUse);
+        expect(handlers).toHaveLength(3);
+        expect(handlers[0].handler).toBe(handler2); // High priority first
+        expect(handlers[1].handler).toBe(handler1); // Normal priority second
+        expect(handlers[2].handler).toBe(handler3); // Low priority last
+    });
+    it('should filter disabled hooks', () => {
+        const handler = vi.fn();
+        const id = registry.register(HookEvent.PreToolUse, handler, HookPriority.Normal, {
+            enabled: false,
+        });
+        const handlers = registry.getHandlers(HookEvent.PreToolUse);
+        const allHandlers = registry.getHandlers(HookEvent.PreToolUse, true);
+        expect(handlers).toHaveLength(0);
+        expect(allHandlers).toHaveLength(1);
+    });
+    it('should enable and disable hooks', () => {
+        const handler = vi.fn();
+        const id = registry.register(HookEvent.PreToolUse, handler);
+        registry.disable(id);
+        expect(registry.getHandlers(HookEvent.PreToolUse)).toHaveLength(0);
+        registry.enable(id);
+        expect(registry.getHandlers(HookEvent.PreToolUse)).toHaveLength(1);
+    });
+    it('should list hooks with filters', () => {
+        registry.register(HookEvent.PreToolUse, vi.fn(), HookPriority.High);
+        registry.register(HookEvent.PostToolUse, vi.fn(), HookPriority.Normal);
+        registry.register(HookEvent.PreEdit, vi.fn(), HookPriority.Low);
+        const allHooks = registry.listHooks();
+        expect(allHooks).toHaveLength(3);
+        const preToolHooks = registry.listHooks({ event: HookEvent.PreToolUse });
+        expect(preToolHooks).toHaveLength(1);
+        const highPriorityHooks = registry.listHooks({ minPriority: HookPriority.Normal });
+        expect(highPriorityHooks).toHaveLength(2);
+    });
+    it('should get event types', () => {
+        registry.register(HookEvent.PreToolUse, vi.fn());
+        registry.register(HookEvent.PostToolUse, vi.fn());
+        registry.register(HookEvent.PreEdit, vi.fn());
+        const eventTypes = registry.getEventTypes();
+        expect(eventTypes).toContain(HookEvent.PreToolUse);
+        expect(eventTypes).toContain(HookEvent.PostToolUse);
+        expect(eventTypes).toContain(HookEvent.PreEdit);
+    });
+    it('should track statistics', () => {
+        registry.register(HookEvent.PreToolUse, vi.fn());
+        registry.register(HookEvent.PostToolUse, vi.fn());
+        registry.recordExecution(true, 10);
+        registry.recordExecution(true, 20);
+        registry.recordExecution(false, 5);
+        const stats = registry.getStats();
+        expect(stats.totalHooks).toBe(2);
+        expect(stats.totalExecutions).toBe(3);
+        expect(stats.totalFailures).toBe(1);
+        expect(stats.avgExecutionTime).toBe((10 + 20 + 5) / 3);
+    });
+    it('should reset statistics', () => {
+        registry.recordExecution(true, 10);
+        registry.resetStats();
+        const stats = registry.getStats();
+        expect(stats.totalExecutions).toBe(0);
+        expect(stats.totalFailures).toBe(0);
+    });
+    it('should clear all hooks', () => {
+        registry.register(HookEvent.PreToolUse, vi.fn());
+        registry.register(HookEvent.PostToolUse, vi.fn());
+        registry.clear();
+        expect(registry.count()).toBe(0);
+        expect(registry.getEventTypes()).toHaveLength(0);
+    });
+});
+describe('HookExecutor', () => {
+    let registry;
+    let executor;
+    let eventBus;
+    beforeEach(() => {
+        registry = createHookRegistry();
+        eventBus = createEventBus();
+        executor = createHookExecutor(registry, eventBus);
+    });
+    it('should execute single hook successfully', async () => {
+        const handler = vi.fn(async () => ({ success: true }));
+        registry.register(HookEvent.PreToolUse, handler);
+        const context = {
+            event: HookEvent.PreToolUse,
+            timestamp: new Date(),
+            tool: { name: 'Read', parameters: { path: 'file.ts' } },
+        };
+        const result = await executor.execute(HookEvent.PreToolUse, context);
+        expect(result.success).toBe(true);
+        expect(result.hooksExecuted).toBe(1);
+        expect(result.hooksFailed).toBe(0);
+        expect(handler).toHaveBeenCalledWith(context);
+    });
+    it('should execute multiple hooks in priority order', async () => {
+        const executionOrder = [];
+        const handler1 = vi.fn(async () => {
+            executionOrder.push(1);
+            return { success: true };
+        });
+        const handler2 = vi.fn(async () => {
+            executionOrder.push(2);
+            return { success: true };
+        });
+        const handler3 = vi.fn(async () => {
+            executionOrder.push(3);
+            return { success: true };
+        });
+        registry.register(HookEvent.PreToolUse, handler1, HookPriority.Normal);
+        registry.register(HookEvent.PreToolUse, handler2, HookPriority.High);
+        registry.register(HookEvent.PreToolUse, handler3, HookPriority.Low);
+        const context = {
+            event: HookEvent.PreToolUse,
+            timestamp: new Date(),
+        };
+        await executor.execute(HookEvent.PreToolUse, context);
+        expect(executionOrder).toEqual([2, 1, 3]); // High, Normal, Low
+    });
+    it('should handle hook errors gracefully', async () => {
+        const handler1 = vi.fn(async () => ({ success: true }));
+        const handler2 = vi.fn(async () => {
+            throw new Error('Hook failed');
+        });
+        const handler3 = vi.fn(async () => ({ success: true }));
+        registry.register(HookEvent.PreToolUse, handler1, HookPriority.High);
+        registry.register(HookEvent.PreToolUse, handler2, HookPriority.Normal);
+        registry.register(HookEvent.PreToolUse, handler3, HookPriority.Low);
+        const context = {
+            event: HookEvent.PreToolUse,
+            timestamp: new Date(),
+        };
+        const result = await executor.execute(HookEvent.PreToolUse, context, {
+            continueOnError: true,
+        });
+        expect(result.hooksExecuted).toBe(3);
+        expect(result.hooksFailed).toBe(1);
+        expect(handler3).toHaveBeenCalled(); // Should continue despite error
+    });
+    it('should abort on error when continueOnError is false', async () => {
+        const handler1 = vi.fn(async () => ({ success: true }));
+        const handler2 = vi.fn(async () => {
+            throw new Error('Hook failed');
+        });
+        const handler3 = vi.fn(async () => ({ success: true }));
+        registry.register(HookEvent.PreToolUse, handler1, HookPriority.High);
+        registry.register(HookEvent.PreToolUse, handler2, HookPriority.Normal);
+        registry.register(HookEvent.PreToolUse, handler3, HookPriority.Low);
+        const context = {
+            event: HookEvent.PreToolUse,
+            timestamp: new Date(),
+        };
+        const result = await executor.execute(HookEvent.PreToolUse, context);
+        expect(result.aborted).toBe(true);
+        expect(result.hooksExecuted).toBe(2);
+        expect(handler3).not.toHaveBeenCalled(); // Should not execute after error
+    });
+    it('should abort when hook returns abort flag', async () => {
+        const handler1 = vi.fn(async () => ({ success: true }));
+        const handler2 = vi.fn(async () => ({ success: true, abort: true }));
+        const handler3 = vi.fn(async () => ({ success: true }));
+        registry.register(HookEvent.PreToolUse, handler1, HookPriority.High);
+        registry.register(HookEvent.PreToolUse, handler2, HookPriority.Normal);
+        registry.register(HookEvent.PreToolUse, handler3, HookPriority.Low);
+        const context = {
+            event: HookEvent.PreToolUse,
+            timestamp: new Date(),
+        };
+        const result = await executor.execute(HookEvent.PreToolUse, context);
+        expect(result.aborted).toBe(true);
+        expect(result.hooksExecuted).toBe(2);
+        expect(handler3).not.toHaveBeenCalled();
+    });
+    it('should merge context modifications', async () => {
+        const handler1 = vi.fn(async () => ({
+            success: true,
+            data: { metadata: { modified: true } },
+        }));
+        const handler2 = vi.fn(async (context) => {
+            expect(context.metadata?.modified).toBe(true);
+            return { success: true };
+        });
+        registry.register(HookEvent.PreToolUse, handler1, HookPriority.High);
+        registry.register(HookEvent.PreToolUse, handler2, HookPriority.Normal);
+        const context = {
+            event: HookEvent.PreToolUse,
+            timestamp: new Date(),
+        };
+        const result = await executor.execute(HookEvent.PreToolUse, context);
+        expect(result.finalContext?.metadata).toEqual({ modified: true });
+    });
+    it('should handle timeout', async () => {
+        const handler = vi.fn(async () => {
+            await new Promise(resolve => setTimeout(resolve, 200));
+            return { success: true };
+        });
+        registry.register(HookEvent.PreToolUse, handler);
+        const context = {
+            event: HookEvent.PreToolUse,
+            timestamp: new Date(),
+        };
+        const result = await executor.executeWithTimeout(HookEvent.PreToolUse, context, 100);
+        expect(result.success).toBe(false);
+        expect(result.hooksFailed).toBe(1);
+    });
+    it('should execute hooks in parallel', async () => {
+        const handler1 = vi.fn(async () => ({ success: true }));
+        const handler2 = vi.fn(async () => ({ success: true }));
+        registry.register(HookEvent.PreToolUse, handler1);
+        registry.register(HookEvent.PostToolUse, handler2);
+        const contexts = [
+            { event: HookEvent.PreToolUse, timestamp: new Date() },
+            { event: HookEvent.PostToolUse, timestamp: new Date() },
+        ];
+        const results = await executor.executeParallel([HookEvent.PreToolUse, HookEvent.PostToolUse], contexts);
+        expect(results).toHaveLength(2);
+        expect(results[0].success).toBe(true);
+        expect(results[1].success).toBe(true);
+    });
+    it('should execute hooks sequentially with context chaining', async () => {
+        const handler1 = vi.fn(async () => ({
+            success: true,
+            data: { metadata: { step: 1 } },
+        }));
+        const handler2 = vi.fn(async () => ({
+            success: true,
+            data: { metadata: { step: 2 } },
+        }));
+        registry.register(HookEvent.PreToolUse, handler1);
+        registry.register(HookEvent.PostToolUse, handler2);
+        const initialContext = {
+            event: HookEvent.PreToolUse,
+            timestamp: new Date(),
+        };
+        const result = await executor.executeSequential([HookEvent.PreToolUse, HookEvent.PostToolUse], initialContext);
+        expect(result.success).toBe(true);
+        expect(result.hooksExecuted).toBe(2);
+    });
+    it('should emit events to event bus', async () => {
+        const preExecuteHandler = vi.fn();
+        const postExecuteHandler = vi.fn();
+        eventBus.on('hooks:pre-execute', preExecuteHandler);
+        eventBus.on('hooks:post-execute', postExecuteHandler);
+        const handler = vi.fn(async () => ({ success: true }));
+        registry.register(HookEvent.PreToolUse, handler);
+        const context = {
+            event: HookEvent.PreToolUse,
+            timestamp: new Date(),
+        };
+        await executor.execute(HookEvent.PreToolUse, context);
+        expect(preExecuteHandler).toHaveBeenCalled();
+        expect(postExecuteHandler).toHaveBeenCalled();
+    });
+    it('should skip disabled hooks', async () => {
+        const handler = vi.fn(async () => ({ success: true }));
+        const id = registry.register(HookEvent.PreToolUse, handler, HookPriority.Normal, {
+            enabled: false,
+        });
+        const context = {
+            event: HookEvent.PreToolUse,
+            timestamp: new Date(),
+        };
+        const result = await executor.execute(HookEvent.PreToolUse, context);
+        expect(result.hooksExecuted).toBe(0);
+        expect(handler).not.toHaveBeenCalled();
+    });
+    it('should record execution statistics', async () => {
+        const handler = vi.fn(async () => ({ success: true }));
+        registry.register(HookEvent.PreToolUse, handler);
+        const context = {
+            event: HookEvent.PreToolUse,
+            timestamp: new Date(),
+        };
+        await executor.execute(HookEvent.PreToolUse, context);
+        const stats = registry.getStats();
+        expect(stats.totalExecutions).toBe(1);
+        expect(stats.totalFailures).toBe(0);
+    });
+});
+//# sourceMappingURL=hooks.test.js.map

package/v3/@claude-flow/shared/dist/hooks/index.d.ts

@@ -0,0 +1,52 @@
+/**
+ * V3 Hooks System - Main Export
+ *
+ * Provides extensible hook points for tool execution, file operations,
+ * and session lifecycle events. Integrates with event bus for coordination.
+ *
+ * Example usage:
+ *
+ * ```typescript
+ * import { createHookRegistry, createHookExecutor, HookEvent, HookPriority } from '@claude-flow/shared/hooks';
+ *
+ * const registry = createHookRegistry();
+ * const executor = createHookExecutor(registry, eventBus);
+ *
+ * // Register a hook
+ * const hookId = registry.register(
+ *   HookEvent.PreToolUse,
+ *   async (context) => {
+ *     console.log('Before tool use:', context.tool?.name);
+ *     return { success: true };
+ *   },
+ *   HookPriority.High
+ * );
+ *
+ * // Execute hooks
+ * const result = await executor.execute(
+ *   HookEvent.PreToolUse,
+ *   {
+ *     event: HookEvent.PreToolUse,
+ *     timestamp: new Date(),
+ *     tool: { name: 'Read', parameters: { path: 'file.ts' } }
+ *   }
+ * );
+ *
+ * // Unregister hook
+ * registry.unregister(hookId);
+ * ```
+ *
+ * @module v3/shared/hooks
+ */
+export type { HookContext, HookResult, HookHandler, HookDefinition, HookStats, HookExecutionOptions, ToolInfo, CommandInfo, FileOperationInfo, SessionInfo, AgentInfo, TaskInfo, MemoryInfo, ErrorInfo, } from './types.js';
+export { HookEvent, HookPriority, } from './types.js';
+export { HookRegistry, createHookRegistry, } from './registry.js';
+export type { AggregatedHookResult, } from './executor.js';
+export { HookExecutor, createHookExecutor, } from './executor.js';
+export { TaskHooksManager, createTaskHooksManager, } from './task-hooks.js';
+export type { PreTaskHookResult, PostTaskHookResult, AgentSuggestion, TaskPattern, TaskOutcome, LearningUpdate, } from './task-hooks.js';
+export { SessionHooksManager, createSessionHooksManager, InMemorySessionStorage, } from './session-hooks.js';
+export type { SessionState, SessionEndHookResult, SessionRestoreHookResult, SessionSummary, SessionStorage, } from './session-hooks.js';
+export { BashSafetyHook, createBashSafetyHook, FileOrganizationHook, createFileOrganizationHook, GitCommitHook, createGitCommitHook, } from './safety/index.js';
+export type { BashSafetyResult, CommandRisk, FileOrganizationResult, FormatterRecommendation, LinterRecommendation, OrganizationIssue, GitCommitResult, CommitType, CommitValidationIssue, } from './safety/index.js';
+//# sourceMappingURL=index.d.ts.map