@bluehawks/cli 1.0.0

package/src/core/hooks/types.ts

@@ -0,0 +1,116 @@
+/**
+ * Bluehawks CLI - Hooks Types
+ * Type definitions for the hooks system
+ */
+
+export type HookEvent =
+    | 'SessionStart'
+    | 'UserPromptSubmit'
+    | 'PreToolUse'
+    | 'PostToolUse'
+    | 'PostToolUseFailure'
+    | 'Stop'
+    | 'SessionEnd';
+
+export interface HookContext {
+    sessionId: string;
+    projectPath: string;
+    model: string;
+    timestamp: string;
+}
+
+export interface SessionStartInput extends HookContext {
+    cwd: string;
+}
+
+export interface UserPromptSubmitInput extends HookContext {
+    prompt: string;
+}
+
+export interface PreToolUseInput extends HookContext {
+    toolName: string;
+    toolInput: Record<string, unknown>;
+}
+
+export interface PostToolUseInput extends HookContext {
+    toolName: string;
+    toolInput: Record<string, unknown>;
+    toolOutput: string;
+    duration: number;
+}
+
+export interface PostToolUseFailureInput extends HookContext {
+    toolName: string;
+    toolInput: Record<string, unknown>;
+    error: string;
+}
+
+export interface StopInput extends HookContext {
+    reason: 'completed' | 'cancelled' | 'error';
+    messageCount: number;
+}
+
+export interface SessionEndInput extends HookContext {
+    duration: number;
+    tokensUsed: number;
+}
+
+export type HookInput =
+    | SessionStartInput
+    | UserPromptSubmitInput
+    | PreToolUseInput
+    | PostToolUseInput
+    | PostToolUseFailureInput
+    | StopInput
+    | SessionEndInput;
+
+export interface HookOutput {
+    // Block the action (for Pre* hooks)
+    block?: boolean;
+    blockReason?: string;
+
+    // Modify the input (for Pre* hooks)
+    modifiedInput?: Record<string, unknown>;
+
+    // Add content to the conversation
+    addContent?: string;
+
+    // Custom data to pass to the next hook
+    data?: Record<string, unknown>;
+}
+
+export interface HookHandler {
+    // Unique identifier for this handler
+    id: string;
+
+    // Human-readable name
+    name: string;
+
+    // Which event this hook handles
+    event: HookEvent;
+
+    // Command to execute (shell command)
+    command?: string;
+
+    // Inline handler function
+    handler?: (input: HookInput) => Promise<HookOutput | void>;
+
+    // Whether to run asynchronously (don't block)
+    async?: boolean;
+
+    // Timeout in milliseconds
+    timeout?: number;
+
+    // Matcher pattern (for tool-specific hooks)
+    matcher?: string | RegExp;
+}
+
+export interface HooksConfig {
+    SessionStart?: HookHandler[];
+    UserPromptSubmit?: HookHandler[];
+    PreToolUse?: HookHandler[];
+    PostToolUse?: HookHandler[];
+    PostToolUseFailure?: HookHandler[];
+    Stop?: HookHandler[];
+    SessionEnd?: HookHandler[];
+}

package/src/core/mcp/client.ts

@@ -0,0 +1,198 @@
+/**
+ * Bluehawks CLI - MCP Client
+ * Model Context Protocol client for connecting to external data sources
+ */
+
+import { spawn, type ChildProcess } from 'node:child_process';
+import * as readline from 'node:readline';
+
+export interface MCPServerConfig {
+    command: string;
+    args?: string[];
+    env?: Record<string, string>;
+}
+
+export interface MCPTool {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties?: Record<string, unknown>;
+        required?: string[];
+    };
+}
+
+export interface MCPResource {
+    uri: string;
+    name: string;
+    description?: string;
+    mimeType?: string;
+}
+
+interface JsonRpcRequest {
+    jsonrpc: '2.0';
+    id: number;
+    method: string;
+    params?: Record<string, unknown>;
+}
+
+interface JsonRpcResponse {
+    jsonrpc: '2.0';
+    id: number;
+    result?: unknown;
+    error?: { code: number; message: string };
+}
+
+export class MCPClient {
+    private serverName: string;
+    private process: ChildProcess | null = null;
+    private requestId = 0;
+    private pendingRequests = new Map<number, {
+        resolve: (value: unknown) => void;
+        reject: (error: Error) => void;
+    }>();
+    private tools: MCPTool[] = [];
+    private resources: MCPResource[] = [];
+    private reader: readline.Interface | null = null;
+
+    constructor(serverName: string) {
+        this.serverName = serverName;
+    }
+
+    async connect(config: MCPServerConfig): Promise<void> {
+        return new Promise((resolve, reject) => {
+            this.process = spawn(config.command, config.args || [], {
+                stdio: ['pipe', 'pipe', 'pipe'],
+                env: { ...process.env, ...config.env },
+            });
+
+            if (!this.process.stdout || !this.process.stdin) {
+                reject(new Error('Failed to create MCP process'));
+                return;
+            }
+
+            this.reader = readline.createInterface({
+                input: this.process.stdout,
+            });
+
+            this.reader.on('line', (line) => {
+                try {
+                    const response = JSON.parse(line) as JsonRpcResponse;
+                    const pending = this.pendingRequests.get(response.id);
+                    if (pending) {
+                        this.pendingRequests.delete(response.id);
+                        if (response.error) {
+                            pending.reject(new Error(response.error.message));
+                        } else {
+                            pending.resolve(response.result);
+                        }
+                    }
+                } catch {
+                    // Ignore non-JSON output
+                }
+            });
+
+            this.process.on('error', (err) => {
+                reject(err);
+            });
+
+            // Initialize the MCP connection
+            this.sendRequest('initialize', {
+                protocolVersion: '2024-11-05',
+                capabilities: {},
+                clientInfo: { name: 'bluehawks-cli', version: '1.0.0' },
+            }).then(() => {
+                // Send initialized notification
+                this.sendNotification('notifications/initialized');
+                resolve();
+            }).catch(reject);
+        });
+    }
+
+    private sendRequest(method: string, params?: Record<string, unknown>): Promise<unknown> {
+        return new Promise((resolve, reject) => {
+            if (!this.process?.stdin) {
+                reject(new Error('MCP process not connected'));
+                return;
+            }
+
+            const id = ++this.requestId;
+            const request: JsonRpcRequest = {
+                jsonrpc: '2.0',
+                id,
+                method,
+                params,
+            };
+
+            this.pendingRequests.set(id, { resolve, reject });
+            this.process.stdin.write(JSON.stringify(request) + '\n');
+
+            // Timeout after 30 seconds
+            setTimeout(() => {
+                if (this.pendingRequests.has(id)) {
+                    this.pendingRequests.delete(id);
+                    reject(new Error(`Request ${method} timed out`));
+                }
+            }, 30000);
+        });
+    }
+
+    private sendNotification(method: string, params?: Record<string, unknown>): void {
+        if (!this.process?.stdin) return;
+
+        const notification = {
+            jsonrpc: '2.0',
+            method,
+            params,
+        };
+        this.process.stdin.write(JSON.stringify(notification) + '\n');
+    }
+
+    async listTools(): Promise<MCPTool[]> {
+        const result = await this.sendRequest('tools/list') as { tools: MCPTool[] };
+        this.tools = result.tools || [];
+        return this.tools;
+    }
+
+    async listResources(): Promise<MCPResource[]> {
+        const result = await this.sendRequest('resources/list') as { resources: MCPResource[] };
+        this.resources = result.resources || [];
+        return this.resources;
+    }
+
+    async callTool(name: string, args: Record<string, unknown>): Promise<unknown> {
+        const result = await this.sendRequest('tools/call', {
+            name,
+            arguments: args,
+        });
+        return result;
+    }
+
+    async readResource(uri: string): Promise<{ contents: unknown[] }> {
+        const result = await this.sendRequest('resources/read', { uri });
+        return result as { contents: unknown[] };
+    }
+
+    getTools(): MCPTool[] {
+        return this.tools;
+    }
+
+    getResources(): MCPResource[] {
+        return this.resources;
+    }
+
+    getServerName(): string {
+        return this.serverName;
+    }
+
+    async disconnect(): Promise<void> {
+        if (this.reader) {
+            this.reader.close();
+        }
+        if (this.process) {
+            this.process.kill();
+            this.process = null;
+        }
+        this.pendingRequests.clear();
+    }
+}

package/src/core/mcp/index.ts

@@ -0,0 +1,2 @@
+export * from './client.js';
+export * from './manager.js';

package/src/core/mcp/manager.ts

@@ -0,0 +1,153 @@
+/**
+ * Bluehawks CLI - MCP Manager
+ * Manages MCP server connections and integrates tools
+ */
+
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import { MCPClient, type MCPServerConfig, type MCPTool } from './client.js';
+import { toolRegistry } from '../tools/index.js';
+import type { ToolDefinition } from '../api/types.js';
+
+export interface MCPConfig {
+    mcpServers?: Record<string, MCPServerConfig>;
+}
+
+export class MCPManager {
+    private clients: Map<string, MCPClient> = new Map();
+
+    constructor() {
+        // Manager initialized - config will be loaded on connectAll
+    }
+
+    /**
+     * Load MCP configuration from file
+     */
+    async loadConfig(): Promise<MCPConfig | null> {
+        const paths = [
+            path.join(process.cwd(), '.mcp.json'),
+            path.join(os.homedir(), '.bluehawks', '.mcp.json'),
+        ];
+
+        for (const configPath of paths) {
+            try {
+                const content = await fs.readFile(configPath, 'utf-8');
+                return JSON.parse(content) as MCPConfig;
+            } catch {
+                continue;
+            }
+        }
+        return null;
+    }
+
+    /**
+     * Connect to all configured MCP servers
+     */
+    async connectAll(): Promise<void> {
+        const config = await this.loadConfig();
+        if (!config?.mcpServers) {
+            return;
+        }
+
+        for (const [name, serverConfig] of Object.entries(config.mcpServers)) {
+            try {
+                await this.connect(name, serverConfig);
+            } catch (error) {
+                console.error(`Failed to connect to MCP server ${name}:`, error);
+            }
+        }
+    }
+
+    /**
+     * Connect to a specific MCP server
+     */
+    async connect(name: string, config: MCPServerConfig): Promise<MCPClient> {
+        const client = new MCPClient(name);
+        await client.connect(config);
+
+        // List and register tools
+        const tools = await client.listTools();
+        for (const tool of tools) {
+            this.registerMCPTool(name, tool);
+        }
+
+        this.clients.set(name, client);
+        return client;
+    }
+
+    /**
+     * Register an MCP tool as a Bluehawks tool
+     */
+    private registerMCPTool(serverName: string, mcpTool: MCPTool): void {
+        const toolName = `mcp_${serverName}_${mcpTool.name}`;
+
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const definition: ToolDefinition = {
+            type: 'function',
+            function: {
+                name: toolName,
+                description: `[MCP:${serverName}] ${mcpTool.description}`,
+                parameters: mcpTool.inputSchema as ToolDefinition['function']['parameters'],
+            },
+        };
+
+
+        const clients = this.clients;
+        toolRegistry.register({
+            name: toolName,
+            definition,
+            execute: async (args: Record<string, unknown>) => {
+                const client = clients.get(serverName);
+                if (!client) {
+                    return `MCP server ${serverName} not connected`;
+                }
+                try {
+                    const result = await client.callTool(mcpTool.name, args);
+                    return typeof result === 'string' ? result : JSON.stringify(result, null, 2);
+                } catch (error) {
+                    return `MCP tool error: ${error instanceof Error ? error.message : String(error)}`;
+                }
+            },
+            safeToAutoRun: false, // MCP tools require approval by default
+        });
+    }
+
+    /**
+     * Get all connected clients
+     */
+    getClients(): Map<string, MCPClient> {
+        return this.clients;
+    }
+
+    /**
+     * Get a specific client
+     */
+    getClient(name: string): MCPClient | undefined {
+        return this.clients.get(name);
+    }
+
+    /**
+     * Disconnect all MCP servers
+     */
+    async disconnectAll(): Promise<void> {
+        for (const client of this.clients.values()) {
+            await client.disconnect();
+        }
+        this.clients.clear();
+    }
+
+    /**
+     * Disconnect a specific server
+     */
+    async disconnect(name: string): Promise<void> {
+        const client = this.clients.get(name);
+        if (client) {
+            await client.disconnect();
+            this.clients.delete(name);
+        }
+    }
+}
+
+// Singleton instance
+export const mcpManager = new MCPManager();

package/src/core/plugins/index.ts

@@ -0,0 +1,2 @@
+export * from './types.js';
+export * from './loader.js';