@bluehawks/cli 1.0.0

package/src/cli/app.tsx

@@ -0,0 +1,319 @@
+/**
+ * Bluehawks CLI - Main Application Component
+ */
+
+import React, { useState, useCallback, useEffect } from 'react';
+import { Text, Box, useInput, useApp } from 'ink';
+import Spinner from 'ink-spinner';
+import TextInput from 'ink-text-input';
+import { APIClient } from '../core/api/client.js';
+import { Orchestrator } from '../core/agents/orchestrator.js';
+import { ToolExecutor, toolRegistry, registerAllTools } from '../core/tools/index.js';
+import { SessionManager } from '../core/session/manager.js';
+import { commandRegistry, type CommandContext } from './commands/index.js';
+import { CLI_NAME, CLI_VERSION, COLORS } from '../config/constants.js';
+import { hooksManager } from '../core/hooks/index.js';
+import type { SessionStartInput, StopInput } from '../core/hooks/types.js';
+
+
+interface AppProps {
+    initialPrompt?: string;
+    apiKey?: string;
+    yoloMode?: boolean;
+}
+
+interface MessageDisplay {
+    role: 'user' | 'assistant' | 'tool' | 'system' | 'error';
+    content: string;
+}
+
+export const App: React.FC<AppProps> = ({ initialPrompt, apiKey, yoloMode = false }) => {
+    const { exit } = useApp();
+    const [input, setInput] = useState('');
+    const [messages, setMessages] = useState<MessageDisplay[]>([]);
+    const [isProcessing, setIsProcessing] = useState(false);
+    const [currentTool, setCurrentTool] = useState<string | null>(null);
+    const [streamingContent, setStreamingContent] = useState('');
+    const [pendingApproval, setPendingApproval] = useState<{
+        toolName: string;
+        args: Record<string, unknown>;
+        resolve: (approved: boolean) => void;
+    } | null>(null);
+    const [isYoloMode, setIsYoloMode] = useState(yoloMode);
+
+    // Initialize components
+    const [apiClient] = useState(() => new APIClient({ apiKey }));
+    const [toolExecutor] = useState(() => {
+        const executor = new ToolExecutor({
+            approvalMode: yoloMode ? 'never' : 'unsafe-only',
+        });
+        return executor;
+    });
+    const [orchestrator] = useState(() => {
+        registerAllTools();
+        return new Orchestrator({
+            projectPath: process.cwd(),
+            apiClient,
+            toolExecutor,
+        });
+    });
+    const [sessionManager] = useState(
+        () => new SessionManager(process.cwd(), apiClient.currentModel)
+    );
+
+    // Set up approval handler and lifecycle hooks
+    useEffect(() => {
+        toolExecutor.setApprovalHandler(async (toolName, args) => {
+            if (isYoloMode) return true;
+
+            return new Promise<boolean>((resolve) => {
+                setPendingApproval({ toolName, args, resolve });
+            });
+        });
+
+        // Initialize orchestrator and trigger SessionStart hook
+        orchestrator.initialize().then(async () => {
+            const hookContext: SessionStartInput = {
+                sessionId: sessionManager.getSessionId(),
+                projectPath: process.cwd(),
+                model: apiClient.currentModel,
+                timestamp: new Date().toISOString(),
+                cwd: process.cwd(),
+            };
+            await hooksManager.execute('SessionStart', hookContext);
+        }).catch((err) => {
+            setMessages((prev) => [...prev, { role: 'error', content: `Init error: ${err}` }]);
+        });
+
+        // Cleanup: trigger Stop hook and auto-save session on exit
+        return () => {
+            const cleanup = async () => {
+                const stopContext: StopInput = {
+                    sessionId: sessionManager.getSessionId(),
+                    projectPath: process.cwd(),
+                    model: apiClient.currentModel,
+                    timestamp: new Date().toISOString(),
+                    reason: 'completed',
+                    messageCount: sessionManager.getStats().messageCount,
+                };
+                await hooksManager.execute('Stop', stopContext);
+                await sessionManager.save();
+            };
+            cleanup().catch(console.error);
+        };
+    }, [toolExecutor, isYoloMode, orchestrator, sessionManager, apiClient]);
+
+
+    // Handle initial prompt
+    useEffect(() => {
+        if (initialPrompt) {
+            handleSubmit(initialPrompt);
+        }
+    }, []);
+
+    const handleSubmit = useCallback(
+        async (value: string) => {
+            const trimmed = value.trim();
+            if (!trimmed || isProcessing) return;
+
+            // Check for slash commands
+            if (commandRegistry.isCommand(trimmed)) {
+                const context: CommandContext = {
+                    sessionManager,
+                    orchestrator,
+                    toolRegistry,
+                    onExit: () => exit(),
+                };
+
+                const result = await commandRegistry.execute(trimmed, context);
+                if (result) {
+                    setMessages((prev) => [...prev, { role: 'system', content: result }]);
+                }
+                setInput('');
+                return;
+            }
+
+            // Check for YOLO toggle
+            if (trimmed.toLowerCase() === '/yolo') {
+                setIsYoloMode((prev) => {
+                    const newValue = !prev;
+                    toolExecutor.setApprovalMode(newValue ? 'never' : 'unsafe-only');
+                    setMessages((prev) => [
+                        ...prev,
+                        {
+                            role: 'system',
+                            content: newValue
+                                ? '⚡ YOLO mode enabled! All tools will auto-execute.'
+                                : '🛡️ YOLO mode disabled. Dangerous tools will require approval.',
+                        },
+                    ]);
+                    return newValue;
+                });
+                setInput('');
+                return;
+            }
+
+            // Add user message
+            setMessages((prev) => [...prev, { role: 'user', content: trimmed }]);
+            setInput('');
+            setIsProcessing(true);
+            setStreamingContent('');
+
+            try {
+                const response = await orchestrator.chat(trimmed, [], {
+                    onChunk: (chunk) => {
+                        setStreamingContent((prev) => prev + chunk);
+                    },
+                    onToolStart: (name) => {
+                        setCurrentTool(name);
+                        setMessages((prev) => [
+                            ...prev,
+                            { role: 'tool', content: `🔧 Running: ${name}...` },
+                        ]);
+                    },
+                    onToolEnd: (name, result) => {
+                        setCurrentTool(null);
+                        const truncated =
+                            result.length > 500 ? result.substring(0, 500) + '...' : result;
+                        setMessages((prev) => [
+                            ...prev,
+                            { role: 'tool', content: `✓ ${name}:\n${truncated}` },
+                        ]);
+                    },
+                });
+
+                // Add final response
+                if (response.content) {
+                    setMessages((prev) => [...prev, { role: 'assistant', content: response.content }]);
+                }
+
+                // Update session
+                sessionManager.addMessage({ role: 'user', content: trimmed });
+                sessionManager.addMessage({ role: 'assistant', content: response.content });
+                response.toolsUsed.forEach((tool) => sessionManager.addToolUsed(tool));
+            } catch (error) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                setMessages((prev) => [...prev, { role: 'error', content: `Error: ${errorMessage}` }]);
+            } finally {
+                setIsProcessing(false);
+                setStreamingContent('');
+                setCurrentTool(null);
+            }
+        },
+        [isProcessing, orchestrator, sessionManager, exit, toolExecutor, isYoloMode]
+    );
+
+    // Handle approval input
+    useInput(
+        (input, key) => {
+            if (pendingApproval) {
+                if (input.toLowerCase() === 'y' || key.return) {
+                    pendingApproval.resolve(true);
+                    setPendingApproval(null);
+                } else if (input.toLowerCase() === 'n' || key.escape) {
+                    pendingApproval.resolve(false);
+                    setPendingApproval(null);
+                }
+            }
+        },
+        { isActive: pendingApproval !== null }
+    );
+
+    const getRoleColor = (role: MessageDisplay['role']): string => {
+        switch (role) {
+            case 'user':
+                return COLORS.primary;
+            case 'assistant':
+                return COLORS.success;
+            case 'tool':
+                return COLORS.info;
+            case 'system':
+                return COLORS.warning;
+            case 'error':
+                return COLORS.error;
+            default:
+                return COLORS.muted;
+        }
+    };
+
+    return (
+        <Box flexDirection="column" padding={1}>
+            {/* Header */}
+            <Box marginBottom={1}>
+                <Text bold color={COLORS.primary}>
+                    🦅 {CLI_NAME} v{CLI_VERSION}
+                </Text>
+                <Text color={COLORS.muted}> | </Text>
+                <Text color={COLORS.muted}>Type /help for commands</Text>
+                {isYoloMode && (
+                    <>
+                        <Text color={COLORS.muted}> | </Text>
+                        <Text color={COLORS.warning}>⚡ YOLO</Text>
+                    </>
+                )}
+            </Box>
+
+            {/* Messages */}
+            <Box flexDirection="column" marginBottom={1}>
+                {messages.slice(-20).map((msg, i) => (
+                    <Box key={i} marginBottom={1}>
+                        <Text color={getRoleColor(msg.role)}>
+                            {msg.role === 'user' ? '› ' : msg.role === 'assistant' ? '🦅 ' : ''}
+                            {msg.content}
+                        </Text>
+                    </Box>
+                ))}
+
+                {/* Streaming content */}
+                {streamingContent && (
+                    <Box marginBottom={1}>
+                        <Text color={COLORS.success}>🦅 {streamingContent}</Text>
+                    </Box>
+                )}
+
+                {/* Current tool */}
+                {currentTool && (
+                    <Box>
+                        <Spinner type="dots" />
+                        <Text color={COLORS.info}> Running {currentTool}...</Text>
+                    </Box>
+                )}
+
+                {/* Approval prompt */}
+                {pendingApproval && (
+                    <Box flexDirection="column" borderStyle="round" borderColor="yellow" padding={1}>
+                        <Text color={COLORS.warning}>
+                            ⚠️ Tool requires approval: {pendingApproval.toolName}
+                        </Text>
+                        <Text color={COLORS.muted}>
+                            Args: {JSON.stringify(pendingApproval.args, null, 2).substring(0, 200)}
+                        </Text>
+                        <Text>
+                            Press <Text color="green">Y</Text> to approve, <Text color="red">N</Text> to deny
+                        </Text>
+                    </Box>
+                )}
+            </Box>
+
+            {/* Input */}
+            {!pendingApproval && (
+                <Box>
+                    <Text color={COLORS.primary}>› </Text>
+                    {isProcessing ? (
+                        <Box>
+                            <Spinner type="dots" />
+                            <Text color={COLORS.muted}> Thinking...</Text>
+                        </Box>
+                    ) : (
+                        <TextInput
+                            value={input}
+                            onChange={setInput}
+                            onSubmit={handleSubmit}
+                            placeholder="Ask me anything..."
+                        />
+                    )}
+                </Box>
+            )}
+        </Box>
+    );
+};

package/src/cli/commands/index.ts

@@ -0,0 +1,261 @@
+/**
+ * Bluehawks CLI - Slash Commands
+ */
+
+export interface Command {
+    name: string;
+    aliases?: string[];
+    description: string;
+    execute: (args: string[], context: CommandContext) => Promise<string> | string;
+}
+
+export interface CommandContext {
+    sessionManager: {
+        getStats: () => {
+            messageCount: number;
+            userMessages: number;
+            assistantMessages: number;
+            toolMessages: number;
+            tokensUsed: number;
+            toolsUsed: string[];
+            duration: number;
+        };
+        clear: () => void;
+        compressHistory: () => void;
+        save: () => Promise<string>;
+    };
+    orchestrator: {
+        setPlanMode: (enabled: boolean) => void;
+        isPlanMode: () => boolean;
+        getSubAgents: () => Array<{ name: string; description: string }>;
+    };
+    toolRegistry: {
+        getAll: () => Array<{ name: string; definition: { function: { description: string } } }>;
+    };
+    onExit: () => void;
+}
+
+// Help command
+const helpCommand: Command = {
+    name: 'help',
+    aliases: ['h', '?'],
+    description: 'Show available commands',
+    execute: (_args, _context) => {
+        const lines: string[] = [
+            '📘 Available Commands:',
+            '',
+            '  /help, /h, /?         Show this help message',
+            '  /clear, /c            Clear conversation history',
+            '  /stats, /s            Show session statistics',
+            '  /tools                List available tools',
+            '  /agents               List available sub-agents',
+            '  /plan                 Toggle plan mode (think before acting)',
+            '  /compress             Compress conversation history',
+            '  /save                 Save current session',
+            '  /yolo                 Toggle YOLO mode (auto-approve all tools)',
+            '  /exit, /quit, /q      Exit Bluehawks',
+            '',
+            '💡 Tips:',
+            '  - Use @ to reference files: @src/index.ts',
+            '  - Use Ctrl+C to cancel current operation',
+            '  - Use Up/Down arrows for command history',
+        ];
+
+        return lines.join('\n');
+    },
+};
+
+// Clear command
+const clearCommand: Command = {
+    name: 'clear',
+    aliases: ['c'],
+    description: 'Clear conversation history',
+    execute: (_args, context) => {
+        context.sessionManager.clear();
+        return '🗑️  Conversation history cleared.';
+    },
+};
+
+// Stats command
+const statsCommand: Command = {
+    name: 'stats',
+    aliases: ['s'],
+    description: 'Show session statistics',
+    execute: (_args, context) => {
+        const stats = context.sessionManager.getStats();
+        const duration = Math.floor(stats.duration / 1000);
+        const minutes = Math.floor(duration / 60);
+        const seconds = duration % 60;
+
+        const lines: string[] = [
+            '📊 Session Statistics:',
+            '',
+            `  Messages:      ${stats.messageCount}`,
+            `  User:          ${stats.userMessages}`,
+            `  Assistant:     ${stats.assistantMessages}`,
+            `  Tool calls:    ${stats.toolMessages}`,
+            `  Tokens used:   ${stats.tokensUsed}`,
+            `  Duration:      ${minutes}m ${seconds}s`,
+            '',
+        ];
+
+        if (stats.toolsUsed.length > 0) {
+            lines.push(`  Tools used:    ${stats.toolsUsed.join(', ')}`);
+        }
+
+        return lines.join('\n');
+    },
+};
+
+// Tools command
+const toolsCommand: Command = {
+    name: 'tools',
+    description: 'List available tools',
+    execute: (_args, context) => {
+        const tools = context.toolRegistry.getAll();
+        const lines: string[] = ['🔧 Available Tools:', ''];
+
+        for (const tool of tools) {
+            const desc = tool.definition.function.description.substring(0, 60);
+            lines.push(`  ${tool.name.padEnd(20)} ${desc}...`);
+        }
+
+        return lines.join('\n');
+    },
+};
+
+// Agents command
+const agentsCommand: Command = {
+    name: 'agents',
+    description: 'List available sub-agents',
+    execute: (_args, context) => {
+        const agents = context.orchestrator.getSubAgents();
+        const lines: string[] = ['🤖 Available Sub-Agents:', ''];
+
+        for (const agent of agents) {
+            lines.push(`  ${agent.name.padEnd(15)} ${agent.description}`);
+        }
+
+        return lines.join('\n');
+    },
+};
+
+// Plan command
+const planCommand: Command = {
+    name: 'plan',
+    description: 'Toggle plan mode',
+    execute: (_args, context) => {
+        const current = context.orchestrator.isPlanMode();
+        context.orchestrator.setPlanMode(!current);
+
+        if (!current) {
+            return '📋 Plan mode enabled. I will create a plan before making changes.';
+        } else {
+            return '⚡ Plan mode disabled. I will execute tasks directly.';
+        }
+    },
+};
+
+// Compress command
+const compressCommand: Command = {
+    name: 'compress',
+    description: 'Compress conversation history',
+    execute: (_args, context) => {
+        context.sessionManager.compressHistory();
+        return '📦 Conversation history compressed to save tokens.';
+    },
+};
+
+// Save command
+const saveCommand: Command = {
+    name: 'save',
+    description: 'Save current session',
+    execute: async (_args, context) => {
+        const path = await context.sessionManager.save();
+        return `💾 Session saved to: ${path}`;
+    },
+};
+
+// Exit command
+const exitCommand: Command = {
+    name: 'exit',
+    aliases: ['quit', 'q'],
+    description: 'Exit Bluehawks',
+    execute: (_args, context) => {
+        context.onExit();
+        return '👋 Goodbye!';
+    },
+};
+
+// Bug command
+const bugCommand: Command = {
+    name: 'bug',
+    description: 'Report a bug',
+    execute: () => {
+        return `🐛 To report a bug:
+1. Go to: https://github.com/bluehawks/cli/issues
+2. Click "New Issue"
+3. Describe the bug with steps to reproduce
+
+Thank you for helping improve Bluehawks!`;
+    },
+};
+
+// All commands
+export const commands: Command[] = [
+    helpCommand,
+    clearCommand,
+    statsCommand,
+    toolsCommand,
+    agentsCommand,
+    planCommand,
+    compressCommand,
+    saveCommand,
+    exitCommand,
+    bugCommand,
+];
+
+// Command registry
+class CommandRegistry {
+    private commands: Map<string, Command> = new Map();
+
+    constructor() {
+        for (const cmd of commands) {
+            this.register(cmd);
+        }
+    }
+
+    register(command: Command): void {
+        this.commands.set(command.name, command);
+        if (command.aliases) {
+            for (const alias of command.aliases) {
+                this.commands.set(alias, command);
+            }
+        }
+    }
+
+    get(name: string): Command | undefined {
+        return this.commands.get(name);
+    }
+
+    async execute(input: string, context: CommandContext): Promise<string | null> {
+        if (!input.startsWith('/')) return null;
+
+        const parts = input.slice(1).split(/\s+/);
+        const commandName = parts[0].toLowerCase();
+        const args = parts.slice(1);
+
+        const command = this.get(commandName);
+        if (!command) {
+            return `Unknown command: /${commandName}. Type /help for available commands.`;
+        }
+
+        return command.execute(args, context);
+    }
+
+    isCommand(input: string): boolean {
+        return input.startsWith('/');
+    }
+}
+
+export const commandRegistry = new CommandRegistry();

package/src/config/constants.ts

@@ -0,0 +1,45 @@
+/**
+ * Bluehawks CLI - Core Constants
+ */
+
+// API Configuration
+export const API_BASE_URL = 'https://api.bluehawks.ai/v1';
+export const DEFAULT_MODEL = 'Qwen/Qwen3-0.6B';
+
+// CLI Metadata
+export const CLI_NAME = 'bluehawks';
+export const CLI_VERSION = '1.0.0';
+export const CLI_DESCRIPTION = 'A production-ready multi-agent AI CLI assistant';
+
+// Configuration Paths
+export const CONFIG_DIR_NAME = '.bluehawks';
+export const SETTINGS_FILE = 'settings.json';
+export const CONTEXT_FILE = 'BLUEHAWKS.md';
+export const HISTORY_FILE = 'history.json';
+export const ENV_FILE = '.env';
+
+// API Defaults
+export const DEFAULT_MAX_TOKENS = 4096;
+export const DEFAULT_TEMPERATURE = 0.7;
+export const DEFAULT_TIMEOUT_MS = 120000;
+export const MAX_RETRIES = 3;
+export const RETRY_DELAY_MS = 1000;
+
+// Tool Execution
+export const COMMAND_TIMEOUT_MS = 60000;
+export const MAX_OUTPUT_LENGTH = 50000;
+export const MAX_FILE_SIZE_BYTES = 10 * 1024 * 1024; // 10MB
+
+// Session
+export const MAX_HISTORY_MESSAGES = 100;
+export const COMPRESS_THRESHOLD = 50;
+
+// Colors (for terminal output)
+export const COLORS = {
+    primary: '#3B82F6',
+    success: '#10B981',
+    warning: '#F59E0B',
+    error: '#EF4444',
+    info: '#6366F1',
+    muted: '#6B7280',
+} as const;

package/src/config/index.ts

@@ -0,0 +1,3 @@
+export * from './constants.js';
+export * from './schema.js';
+export * from './settings.js';

package/src/config/schema.ts

@@ -0,0 +1,36 @@
+/**
+ * Bluehawks CLI - Settings Schema
+ */
+
+import { z } from 'zod';
+
+export const settingsSchema = z.object({
+    // API Settings
+    apiUrl: z.string().url().optional(),
+    apiKey: z.string().optional(),
+    model: z.string().optional(),
+
+    // Execution Settings
+    approvalMode: z.enum(['always', 'never', 'unsafe-only']).default('unsafe-only'),
+    maxTokens: z.number().min(1).max(32768).default(4096),
+    temperature: z.number().min(0).max(2).default(0.7),
+    timeout: z.number().min(1000).max(600000).default(120000),
+
+    // UI Settings
+    theme: z.enum(['dark', 'light', 'auto']).default('dark'),
+    showTimestamps: z.boolean().default(false),
+    compactMode: z.boolean().default(false),
+
+    // Feature Flags
+    planMode: z.boolean().default(false),
+    mcpEnabled: z.boolean().default(false),
+
+    // Tool Settings
+    commandTimeout: z.number().min(1000).max(300000).default(60000),
+    maxOutputLength: z.number().min(1000).max(100000).default(50000),
+    excludePatterns: z.array(z.string()).default(['node_modules', '.git', 'dist', 'build']),
+});
+
+export type Settings = z.infer<typeof settingsSchema>;
+
+export const defaultSettings: Settings = settingsSchema.parse({});