genesis-ai-cli 7.4.5

package/dist/src/hooks/index.d.ts

@@ -0,0 +1,135 @@
+/**
+ * Genesis v7.4.5 - Hooks System
+ *
+ * Execute custom shell commands in response to Genesis events.
+ * Similar to git hooks or Claude Code hooks.
+ *
+ * Configuration (in ~/.genesis/hooks.json or .genesis-hooks.json):
+ * ```json
+ * {
+ *   "hooks": {
+ *     "pre-message": "echo 'Processing: $GENESIS_MESSAGE'",
+ *     "post-message": "./scripts/log-response.sh",
+ *     "pre-tool": "echo 'Calling tool: $GENESIS_TOOL_NAME'",
+ *     "post-tool": "./scripts/audit-tool.sh",
+ *     "session-start": "notify-send 'Genesis session started'",
+ *     "session-end": "./scripts/summarize-session.sh"
+ *   }
+ * }
+ * ```
+ *
+ * Environment variables passed to hooks:
+ * - GENESIS_EVENT: Event name
+ * - GENESIS_MESSAGE: User message (for message events)
+ * - GENESIS_RESPONSE: AI response (for post-message)
+ * - GENESIS_TOOL_NAME: Tool name (for tool events)
+ * - GENESIS_TOOL_RESULT: Tool result (for post-tool)
+ * - GENESIS_SESSION_ID: Current session ID
+ * - GENESIS_WORKING_DIR: Working directory
+ */
+/**
+ * Available hook events
+ */
+export type HookEvent = 'session-start' | 'session-end' | 'pre-message' | 'post-message' | 'pre-tool' | 'post-tool' | 'pre-subagent' | 'post-subagent' | 'error' | 'prompt-submit';
+/**
+ * Hook configuration
+ */
+export interface HookConfig {
+    command: string;
+    blocking?: boolean;
+    timeout?: number;
+    silent?: boolean;
+    env?: Record<string, string>;
+}
+/**
+ * Full hooks configuration file
+ */
+export interface HooksConfig {
+    hooks: Partial<Record<HookEvent, string | HookConfig>>;
+    defaults?: {
+        timeout?: number;
+        silent?: boolean;
+    };
+}
+/**
+ * Context passed to hook execution
+ */
+export interface HookContext {
+    event: HookEvent;
+    message?: string;
+    response?: string;
+    toolName?: string;
+    toolResult?: string;
+    subagentType?: string;
+    subagentResult?: string;
+    sessionId?: string;
+    workingDir?: string;
+    error?: string;
+    [key: string]: string | undefined;
+}
+/**
+ * Result of hook execution
+ */
+export interface HookResult {
+    event: HookEvent;
+    success: boolean;
+    blocked: boolean;
+    output?: string;
+    error?: string;
+    duration: number;
+}
+export declare class HooksManager {
+    private config;
+    private configPath;
+    private enabled;
+    constructor();
+    /**
+     * Load hooks configuration from file
+     * Priority: .genesis-hooks.json (local) > ~/.genesis/hooks.json (global)
+     */
+    private loadConfig;
+    /**
+     * Reload configuration
+     */
+    reload(): void;
+    /**
+     * Enable/disable hooks
+     */
+    setEnabled(enabled: boolean): void;
+    /**
+     * Check if hooks are configured
+     */
+    hasHooks(): boolean;
+    /**
+     * Get configured hooks
+     */
+    getConfiguredHooks(): HookEvent[];
+    /**
+     * Get config path
+     */
+    getConfigPath(): string | null;
+    /**
+     * Execute hook for an event
+     * @param event - The event that triggered the hook
+     * @param context - Context data to pass to the hook
+     * @returns HookResult or null if no hook configured
+     */
+    execute(event: HookEvent, context: HookContext): Promise<HookResult | null>;
+    /**
+     * Execute multiple hooks for an event (if configured as array)
+     * Currently just executes single hook, but structure allows expansion
+     */
+    executeAll(event: HookEvent, context: HookContext): Promise<HookResult[]>;
+}
+export declare function getHooksManager(): HooksManager;
+/**
+ * Create a sample hooks configuration file
+ */
+export declare function createSampleHooksConfig(filePath?: string): void;
+/**
+ * Validate hooks configuration
+ */
+export declare function validateHooksConfig(config: unknown): {
+    valid: boolean;
+    errors: string[];
+};

package/dist/src/hooks/index.js

@@ -0,0 +1,317 @@
+"use strict";
+/**
+ * Genesis v7.4.5 - Hooks System
+ *
+ * Execute custom shell commands in response to Genesis events.
+ * Similar to git hooks or Claude Code hooks.
+ *
+ * Configuration (in ~/.genesis/hooks.json or .genesis-hooks.json):
+ * ```json
+ * {
+ *   "hooks": {
+ *     "pre-message": "echo 'Processing: $GENESIS_MESSAGE'",
+ *     "post-message": "./scripts/log-response.sh",
+ *     "pre-tool": "echo 'Calling tool: $GENESIS_TOOL_NAME'",
+ *     "post-tool": "./scripts/audit-tool.sh",
+ *     "session-start": "notify-send 'Genesis session started'",
+ *     "session-end": "./scripts/summarize-session.sh"
+ *   }
+ * }
+ * ```
+ *
+ * Environment variables passed to hooks:
+ * - GENESIS_EVENT: Event name
+ * - GENESIS_MESSAGE: User message (for message events)
+ * - GENESIS_RESPONSE: AI response (for post-message)
+ * - GENESIS_TOOL_NAME: Tool name (for tool events)
+ * - GENESIS_TOOL_RESULT: Tool result (for post-tool)
+ * - GENESIS_SESSION_ID: Current session ID
+ * - GENESIS_WORKING_DIR: Working directory
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HooksManager = void 0;
+exports.getHooksManager = getHooksManager;
+exports.createSampleHooksConfig = createSampleHooksConfig;
+exports.validateHooksConfig = validateHooksConfig;
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os_1 = require("os");
+// ============================================================================
+// Hooks Manager
+// ============================================================================
+class HooksManager {
+    config = null;
+    configPath = null;
+    enabled = true;
+    constructor() {
+        this.loadConfig();
+    }
+    /**
+     * Load hooks configuration from file
+     * Priority: .genesis-hooks.json (local) > ~/.genesis/hooks.json (global)
+     */
+    loadConfig() {
+        const localPath = path.join(process.cwd(), '.genesis-hooks.json');
+        const globalPath = path.join((0, os_1.homedir)(), '.genesis', 'hooks.json');
+        // Try local first
+        if (fs.existsSync(localPath)) {
+            try {
+                const content = fs.readFileSync(localPath, 'utf-8');
+                this.config = JSON.parse(content);
+                this.configPath = localPath;
+                return;
+            }
+            catch (err) {
+                console.warn(`[Hooks] Error loading ${localPath}: ${err}`);
+            }
+        }
+        // Try global
+        if (fs.existsSync(globalPath)) {
+            try {
+                const content = fs.readFileSync(globalPath, 'utf-8');
+                this.config = JSON.parse(content);
+                this.configPath = globalPath;
+                return;
+            }
+            catch (err) {
+                console.warn(`[Hooks] Error loading ${globalPath}: ${err}`);
+            }
+        }
+        // No config found - that's OK
+        this.config = null;
+        this.configPath = null;
+    }
+    /**
+     * Reload configuration
+     */
+    reload() {
+        this.loadConfig();
+    }
+    /**
+     * Enable/disable hooks
+     */
+    setEnabled(enabled) {
+        this.enabled = enabled;
+    }
+    /**
+     * Check if hooks are configured
+     */
+    hasHooks() {
+        return this.config !== null && Object.keys(this.config.hooks || {}).length > 0;
+    }
+    /**
+     * Get configured hooks
+     */
+    getConfiguredHooks() {
+        if (!this.config?.hooks)
+            return [];
+        return Object.keys(this.config.hooks);
+    }
+    /**
+     * Get config path
+     */
+    getConfigPath() {
+        return this.configPath;
+    }
+    /**
+     * Execute hook for an event
+     * @param event - The event that triggered the hook
+     * @param context - Context data to pass to the hook
+     * @returns HookResult or null if no hook configured
+     */
+    async execute(event, context) {
+        if (!this.enabled || !this.config?.hooks)
+            return null;
+        const hookDef = this.config.hooks[event];
+        if (!hookDef)
+            return null;
+        const startTime = Date.now();
+        // Normalize hook definition
+        const hook = typeof hookDef === 'string'
+            ? { command: hookDef }
+            : hookDef;
+        // Determine if blocking
+        const isBlocking = hook.blocking ?? event.startsWith('pre-');
+        const timeout = hook.timeout ?? this.config.defaults?.timeout ?? 30000;
+        const silent = hook.silent ?? this.config.defaults?.silent ?? false;
+        // Build environment
+        const env = {
+            ...process.env,
+            GENESIS_EVENT: event,
+            GENESIS_WORKING_DIR: context.workingDir || process.cwd(),
+            ...(context.message && { GENESIS_MESSAGE: context.message }),
+            ...(context.response && { GENESIS_RESPONSE: context.response }),
+            ...(context.toolName && { GENESIS_TOOL_NAME: context.toolName }),
+            ...(context.toolResult && { GENESIS_TOOL_RESULT: context.toolResult }),
+            ...(context.subagentType && { GENESIS_SUBAGENT_TYPE: context.subagentType }),
+            ...(context.subagentResult && { GENESIS_SUBAGENT_RESULT: context.subagentResult }),
+            ...(context.sessionId && { GENESIS_SESSION_ID: context.sessionId }),
+            ...(context.error && { GENESIS_ERROR: context.error }),
+            ...hook.env,
+        };
+        try {
+            if (isBlocking) {
+                // Synchronous execution - waits for completion
+                const output = (0, child_process_1.execSync)(hook.command, {
+                    env,
+                    timeout,
+                    stdio: silent ? 'pipe' : 'inherit',
+                    encoding: 'utf-8',
+                    shell: '/bin/sh', // Use explicit shell path for type safety
+                });
+                return {
+                    event,
+                    success: true,
+                    blocked: false,
+                    output: output || undefined,
+                    duration: Date.now() - startTime,
+                };
+            }
+            else {
+                // Asynchronous execution - fire and forget
+                const child = (0, child_process_1.spawn)(hook.command, [], {
+                    env,
+                    stdio: silent ? 'ignore' : 'inherit',
+                    shell: '/bin/sh', // Use explicit shell path for type safety
+                    detached: true,
+                });
+                child.unref();
+                return {
+                    event,
+                    success: true,
+                    blocked: false,
+                    duration: Date.now() - startTime,
+                };
+            }
+        }
+        catch (err) {
+            const errorMessage = err instanceof Error ? err.message : String(err);
+            // Check if hook explicitly blocked (exit code 77 = blocked)
+            const blocked = err instanceof Error && 'status' in err && err.status === 77;
+            return {
+                event,
+                success: false,
+                blocked,
+                error: blocked ? 'Hook blocked the action' : errorMessage,
+                duration: Date.now() - startTime,
+            };
+        }
+    }
+    /**
+     * Execute multiple hooks for an event (if configured as array)
+     * Currently just executes single hook, but structure allows expansion
+     */
+    async executeAll(event, context) {
+        const result = await this.execute(event, context);
+        return result ? [result] : [];
+    }
+}
+exports.HooksManager = HooksManager;
+// ============================================================================
+// Singleton Instance
+// ============================================================================
+let _hooksManager = null;
+function getHooksManager() {
+    if (!_hooksManager) {
+        _hooksManager = new HooksManager();
+    }
+    return _hooksManager;
+}
+// ============================================================================
+// Helper Functions
+// ============================================================================
+/**
+ * Create a sample hooks configuration file
+ */
+function createSampleHooksConfig(filePath) {
+    const targetPath = filePath || path.join(process.cwd(), '.genesis-hooks.json');
+    const sampleConfig = {
+        hooks: {
+            'session-start': 'echo "Genesis session started at $(date)"',
+            'pre-message': {
+                command: 'echo "Processing message..."',
+                silent: true,
+            },
+            'post-tool': {
+                command: 'echo "Tool $GENESIS_TOOL_NAME executed"',
+                blocking: false,
+            },
+        },
+        defaults: {
+            timeout: 30000,
+            silent: false,
+        },
+    };
+    fs.writeFileSync(targetPath, JSON.stringify(sampleConfig, null, 2));
+}
+/**
+ * Validate hooks configuration
+ */
+function validateHooksConfig(config) {
+    const errors = [];
+    if (!config || typeof config !== 'object') {
+        errors.push('Config must be an object');
+        return { valid: false, errors };
+    }
+    const cfg = config;
+    if (!cfg.hooks || typeof cfg.hooks !== 'object') {
+        errors.push('Config must have a "hooks" object');
+        return { valid: false, errors };
+    }
+    const validEvents = [
+        'session-start', 'session-end',
+        'pre-message', 'post-message',
+        'pre-tool', 'post-tool',
+        'pre-subagent', 'post-subagent',
+        'error', 'prompt-submit',
+    ];
+    for (const [event, hook] of Object.entries(cfg.hooks)) {
+        if (!validEvents.includes(event)) {
+            errors.push(`Unknown hook event: ${event}`);
+        }
+        if (typeof hook !== 'string' && typeof hook !== 'object') {
+            errors.push(`Hook for ${event} must be a string or object`);
+        }
+        if (typeof hook === 'object' && hook !== null) {
+            const hookObj = hook;
+            if (!hookObj.command || typeof hookObj.command !== 'string') {
+                errors.push(`Hook for ${event} must have a "command" string`);
+            }
+        }
+    }
+    return { valid: errors.length === 0, errors };
+}

package/dist/src/index.d.ts

@@ -0,0 +1,23 @@
+#!/usr/bin/env node
+/**
+ * Genesis - System Creator CLI
+ *
+ * Create systems powered by 13 MCP servers:
+ *
+ * KNOWLEDGE:  arxiv, semantic-scholar, context7, wolfram
+ * RESEARCH:   gemini, brave-search, exa, firecrawl
+ * CREATION:   openai, github
+ * VISUAL:     stability-ai
+ * STORAGE:    memory, filesystem
+ *
+ * Usage:
+ *   genesis create <name> [options]     Create a new system
+ *   genesis research <topic>            Research a topic
+ *   genesis design <spec-file>          Design architecture
+ *   genesis generate <spec-file>        Generate code
+ *   genesis visualize <spec-file>       Create visuals
+ *   genesis publish <spec-file>         Publish to GitHub
+ *   genesis status                      Show MCP status
+ *   genesis help                        Show help
+ */
+export {};