@aiwg/cli 0.0.0-bootstrap.0 → 2026.7.18

package/dist/src/cli/hooks/executor.js

@@ -0,0 +1,96 @@
+/**
+ * Hook Executor
+ *
+ * Executes hook handlers in priority order, handles blocking, modification,
+ * and error propagation. Provides the runtime for the hook system.
+ *
+ * @implements @.aiwg/requirements/use-cases/UC-004-extension-system.md
+ * @architecture @src/extensions/types.ts
+ * @tests @test/unit/cli/hooks/executor.test.ts
+ * @issue #58
+ */
+/**
+ * Hook Executor
+ *
+ * Executes registered hooks for lifecycle events. Handles priority ordering,
+ * blocking, modification accumulation, and error handling.
+ */
+export class HookExecutor {
+    registry;
+    constructor(registry) {
+        this.registry = registry;
+    }
+    /**
+     * Execute all hooks for a lifecycle event
+     *
+     * Executes hooks in priority order (ascending). Stops execution if any
+     * hook blocks. Accumulates modifications from all executed hooks.
+     *
+     * @param event - Lifecycle event
+     * @param ctx - Hook execution context
+     * @returns Aggregated execution result
+     */
+    async execute(event, ctx) {
+        const result = {
+            blocked: false,
+            executed: [],
+            errors: [],
+            modifications: {},
+        };
+        // Get handlers for this event and command
+        const handlers = this.registry.getHandlers(event, ctx.command);
+        // Execute handlers in priority order
+        for (const handler of handlers) {
+            try {
+                // Execute handler
+                const hookResult = await handler.execute(ctx);
+                // Track execution
+                result.executed.push(handler.id);
+                // Handle result action
+                switch (hookResult.action) {
+                    case 'block':
+                        result.blocked = true;
+                        result.blockingHook = handler.id;
+                        result.message = hookResult.message;
+                        return result; // Stop execution
+                    case 'modify':
+                        if (hookResult.data) {
+                            // Accumulate modifications
+                            Object.assign(result.modifications, hookResult.data);
+                            // Update context with modifications for next hook
+                            ctx.data = { ...ctx.data, ...hookResult.data };
+                        }
+                        break;
+                    case 'continue':
+                        // Continue to next hook
+                        break;
+                }
+            }
+            catch (error) {
+                // Record error but continue execution
+                result.errors.push({
+                    hook: handler.id,
+                    error: error instanceof Error ? error : new Error(String(error)),
+                });
+                // Still track as executed even if errored
+                if (!result.executed.includes(handler.id)) {
+                    result.executed.push(handler.id);
+                }
+            }
+        }
+        return result;
+    }
+    /**
+     * Execute hooks for a specific command
+     *
+     * Convenience method that extracts command from context.
+     *
+     * @param event - Lifecycle event
+     * @param ctx - Hook execution context
+     * @returns Aggregated execution result
+     */
+    async executeForCommand(event, ctx) {
+        return this.execute(event, ctx);
+    }
+}
+//# sourceMappingURL=executor.js.map

package/dist/src/cli/hooks/index.js

@@ -0,0 +1,15 @@
+/**
+ * Hook System
+ *
+ * Exports the complete hook system: types, registry, and executor.
+ * Provides lifecycle hooks for CLI command execution.
+ *
+ * @implements @.aiwg/requirements/use-cases/UC-004-extension-system.md
+ * @architecture @src/extensions/types.ts
+ * @issue #58
+ */
+// Registry
+export { HookRegistry } from './registry.js';
+// Executor
+export { HookExecutor } from './executor.js';
+//# sourceMappingURL=index.js.map

package/dist/src/cli/hooks/registry.js

@@ -0,0 +1,143 @@
+/**
+ * Hook Registry
+ *
+ * Manages registration and discovery of hook handlers. Organizes hooks
+ * by lifecycle event and supports priority-based ordering.
+ *
+ * @implements @.aiwg/requirements/use-cases/UC-004-extension-system.md
+ * @architecture @src/extensions/types.ts
+ * @tests @test/unit/cli/hooks/registry.test.ts
+ * @issue #58
+ */
+/**
+ * Hook Registry
+ *
+ * Central registry for all hook handlers. Provides O(1) lookup by event
+ * and maintains priority ordering for execution.
+ */
+export class HookRegistry {
+    /** Map of hook ID to handler */
+    handlers = new Map();
+    /** Map of event to sorted list of handler IDs */
+    eventMap = new Map();
+    /**
+     * Register a hook handler
+     *
+     * @param handler - Hook handler to register
+     * @throws Error if hook ID is already registered
+     */
+    register(handler) {
+        if (this.handlers.has(handler.id)) {
+            throw new Error(`Hook ${handler.id} is already registered`);
+        }
+        // Store handler
+        this.handlers.set(handler.id, handler);
+        // Add to event map
+        const eventHandlers = this.eventMap.get(handler.event) || [];
+        eventHandlers.push(handler.id);
+        // Sort by priority (ascending)
+        eventHandlers.sort((aId, bId) => {
+            const a = this.handlers.get(aId);
+            const b = this.handlers.get(bId);
+            return a.priority - b.priority;
+        });
+        this.eventMap.set(handler.event, eventHandlers);
+    }
+    /**
+     * Unregister a hook handler
+     *
+     * @param id - Hook ID to unregister
+     */
+    unregister(id) {
+        const handler = this.handlers.get(id);
+        if (!handler) {
+            return;
+        }
+        // Remove from handlers map
+        this.handlers.delete(id);
+        // Remove from event map
+        const eventHandlers = this.eventMap.get(handler.event);
+        if (eventHandlers) {
+            const filtered = eventHandlers.filter((hId) => hId !== id);
+            if (filtered.length === 0) {
+                this.eventMap.delete(handler.event);
+            }
+            else {
+                this.eventMap.set(handler.event, filtered);
+            }
+        }
+    }
+    /**
+     * Get handlers for a specific event
+     *
+     * Returns handlers in priority order (ascending). Optionally filters
+     * by command name.
+     *
+     * @param event - Lifecycle event
+     * @param command - Optional command name for filtering
+     * @returns Array of matching handlers in priority order
+     */
+    getHandlers(event, command) {
+        const handlerIds = this.eventMap.get(event) || [];
+        return handlerIds
+            .map((id) => this.handlers.get(id))
+            .filter((handler) => {
+            // If no command specified, return all handlers
+            if (!command || !handler.filter) {
+                return true;
+            }
+            const filter = handler.filter;
+            // Check exclude list first
+            if (filter.exclude && filter.exclude.includes(command)) {
+                return false;
+            }
+            // If commands list is specified, command must be in it
+            if (filter.commands && !filter.commands.includes(command)) {
+                return false;
+            }
+            return true;
+        });
+    }
+    /**
+     * Check if a hook is registered
+     *
+     * @param id - Hook ID
+     * @returns True if hook is registered
+     */
+    has(id) {
+        return this.handlers.has(id);
+    }
+    /**
+     * Get a specific hook handler
+     *
+     * @param id - Hook ID
+     * @returns Handler or undefined if not found
+     */
+    get(id) {
+        return this.handlers.get(id);
+    }
+    /**
+     * Clear all registered hooks
+     */
+    clear() {
+        this.handlers.clear();
+        this.eventMap.clear();
+    }
+    /**
+     * Get all registered handlers
+     *
+     * @returns Array of all handlers
+     */
+    getAllHandlers() {
+        return Array.from(this.handlers.values());
+    }
+    /**
+     * Get count of registered hooks
+     *
+     * @returns Number of registered hooks
+     */
+    get size() {
+        return this.handlers.size;
+    }
+}
+//# sourceMappingURL=registry.js.map

package/dist/src/cli/hooks/types.js

@@ -0,0 +1,13 @@
+/**
+ * Hook System Types
+ *
+ * Type definitions for the hook execution system. Hooks allow users to
+ * intercept and modify CLI behavior at specific lifecycle points.
+ *
+ * @implements @.aiwg/requirements/use-cases/UC-004-extension-system.md
+ * @architecture @src/extensions/types.ts
+ * @tests @test/unit/cli/hooks/types.test.ts
+ * @issue #58
+ */
+export {};
+//# sourceMappingURL=types.js.map