@bluehawks/cli 1.0.0

package/src/config/settings.ts

@@ -0,0 +1,121 @@
+/**
+ * Bluehawks CLI - Settings Manager
+ */
+
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import { settingsSchema, defaultSettings, type Settings } from './schema.js';
+import { CONFIG_DIR_NAME, SETTINGS_FILE, ENV_FILE } from './constants.js';
+
+export class SettingsManager {
+    private globalConfigPath: string;
+    private projectConfigPath: string;
+    private settings: Settings;
+
+    constructor(projectPath: string = process.cwd()) {
+        this.globalConfigPath = path.join(os.homedir(), CONFIG_DIR_NAME);
+        this.projectConfigPath = path.join(projectPath, CONFIG_DIR_NAME);
+        this.settings = { ...defaultSettings };
+    }
+
+    async load(): Promise<Settings> {
+        // Load in order of increasing precedence
+        const globalSettings = await this.loadFromFile(
+            path.join(this.globalConfigPath, SETTINGS_FILE)
+        );
+        const projectSettings = await this.loadFromFile(
+            path.join(this.projectConfigPath, SETTINGS_FILE)
+        );
+        const envSettings = await this.loadFromEnv();
+
+        // Merge settings
+        this.settings = settingsSchema.parse({
+            ...defaultSettings,
+            ...globalSettings,
+            ...projectSettings,
+            ...envSettings,
+        });
+
+        return this.settings;
+    }
+
+    private async loadFromFile(filePath: string): Promise<Partial<Settings>> {
+        try {
+            const content = await fs.readFile(filePath, 'utf-8');
+            return JSON.parse(content);
+        } catch {
+            return {};
+        }
+    }
+
+    private async loadFromEnv(): Promise<Partial<Settings>> {
+        // Load from .env file if exists
+        const envPath = path.join(this.projectConfigPath, ENV_FILE);
+        try {
+            const content = await fs.readFile(envPath, 'utf-8');
+            const lines = content.split('\n');
+            for (const line of lines) {
+                const match = line.match(/^([^=]+)=(.*)$/);
+                if (match) {
+                    const [, key, value] = match;
+                    if (!process.env[key.trim()]) {
+                        process.env[key.trim()] = value.trim().replace(/^['"]|['"]$/g, '');
+                    }
+                }
+            }
+        } catch {
+            // No .env file
+        }
+
+        // Map environment variables to settings
+        const settings: Partial<Settings> = {};
+
+        if (process.env.BLUEHAWKS_API_URL) {
+            settings.apiUrl = process.env.BLUEHAWKS_API_URL;
+        }
+        if (process.env.BLUEHAWKS_API_KEY) {
+            settings.apiKey = process.env.BLUEHAWKS_API_KEY;
+        }
+        if (process.env.BLUEHAWKS_MODEL) {
+            settings.model = process.env.BLUEHAWKS_MODEL;
+        }
+        if (process.env.BLUEHAWKS_MAX_TOKENS) {
+            settings.maxTokens = parseInt(process.env.BLUEHAWKS_MAX_TOKENS, 10);
+        }
+        if (process.env.BLUEHAWKS_TEMPERATURE) {
+            settings.temperature = parseFloat(process.env.BLUEHAWKS_TEMPERATURE);
+        }
+
+        return settings;
+    }
+
+    async save(scope: 'global' | 'project' = 'project'): Promise<void> {
+        const configPath = scope === 'global' ? this.globalConfigPath : this.projectConfigPath;
+        const filePath = path.join(configPath, SETTINGS_FILE);
+
+        await fs.mkdir(configPath, { recursive: true });
+        await fs.writeFile(filePath, JSON.stringify(this.settings, null, 2), 'utf-8');
+    }
+
+    get<K extends keyof Settings>(key: K): Settings[K] {
+        return this.settings[key];
+    }
+
+    set<K extends keyof Settings>(key: K, value: Settings[K]): void {
+        this.settings[key] = value;
+    }
+
+    getAll(): Settings {
+        return { ...this.settings };
+    }
+
+    update(partial: Partial<Settings>): void {
+        this.settings = settingsSchema.parse({
+            ...this.settings,
+            ...partial,
+        });
+    }
+}
+
+export const settingsManager = new SettingsManager();

package/src/core/agents/agent.ts

@@ -0,0 +1,205 @@
+/**
+ * Bluehawks CLI - Base Agent
+ * Base class for all agents
+ */
+
+import { APIClient } from '../api/client.js';
+import { toolRegistry } from '../tools/registry.js';
+import { ToolExecutor } from '../tools/executor.js';
+import type { Message, ToolResult, ToolDefinition } from '../api/types.js';
+import { hooksManager } from '../hooks/index.js';
+import type { PreToolUseInput, PostToolUseInput, PostToolUseFailureInput } from '../hooks/types.js';
+
+export interface AgentOptions {
+    name: string;
+    systemPrompt: string;
+    tools?: string[];
+    maxIterations?: number;
+}
+
+export interface AgentResponse {
+    content: string;
+    toolsUsed: string[];
+    iterations: number;
+}
+
+export class Agent {
+    protected name: string;
+    protected systemPrompt: string;
+    protected tools: ToolDefinition[];
+    protected maxIterations: number;
+    protected apiClient: APIClient;
+    protected toolExecutor: ToolExecutor;
+    protected messages: Message[];
+    protected sessionId: string;
+
+    constructor(options: AgentOptions, apiClient: APIClient, toolExecutor: ToolExecutor) {
+        this.name = options.name;
+        this.systemPrompt = options.systemPrompt;
+        this.maxIterations = options.maxIterations || 10;
+        this.apiClient = apiClient;
+        this.toolExecutor = toolExecutor;
+        this.messages = [];
+        this.sessionId = `session_${Date.now()}`;
+
+        // Get tool definitions
+        if (options.tools && options.tools.length > 0) {
+            this.tools = options.tools
+                .map((name) => toolRegistry.get(name)?.definition)
+                .filter((def): def is ToolDefinition => def !== undefined);
+        } else {
+            this.tools = toolRegistry.getDefinitions();
+        }
+    }
+
+    async run(
+        userMessage: string,
+        onChunk?: (content: string) => void,
+        onToolStart?: (name: string) => void,
+        onToolEnd?: (name: string, result: string) => void
+    ): Promise<AgentResponse> {
+        // Initialize with system message
+        this.messages = [
+            { role: 'system', content: this.systemPrompt },
+            { role: 'user', content: userMessage },
+        ];
+
+        const toolsUsed: string[] = [];
+        let iterations = 0;
+        let finalContent = '';
+
+        while (iterations < this.maxIterations) {
+            iterations++;
+
+            // Use non-streaming with tools for agent loop (vLLM doesn't support streaming + tool_choice)
+            const response = await this.apiClient.createChatCompletion(
+                this.messages,
+                this.tools,
+                'auto'
+            );
+
+            const choice = response.choices[0];
+            const message = choice.message;
+
+            // Add assistant message
+            const assistantMessage: Message = {
+                role: 'assistant',
+                content: message.content || '',
+            };
+            if (message.tool_calls && message.tool_calls.length > 0) {
+                assistantMessage.tool_calls = message.tool_calls;
+            }
+            this.messages.push(assistantMessage);
+
+            // If no tool calls, we're done - output the response
+            if (!message.tool_calls || message.tool_calls.length === 0) {
+                const content = typeof message.content === 'string' ? message.content : '';
+                finalContent = content;
+                // Simulate streaming by outputting content progressively
+                if (onChunk && finalContent) {
+                    // Output in small chunks for streaming effect
+                    const words = finalContent.split(' ');
+                    for (const word of words) {
+                        onChunk(word + ' ');
+                        await new Promise(r => setTimeout(r, 20)); // Small delay for streaming effect
+                    }
+                }
+                break;
+            }
+
+            // Execute tool calls
+            const toolResults: ToolResult[] = [];
+            for (const toolCall of message.tool_calls) {
+                const toolName = toolCall.function.name;
+                const toolInput = JSON.parse(toolCall.function.arguments || '{}');
+                toolsUsed.push(toolName);
+
+                // Execute PreToolUse hooks
+                const hookContext = {
+                    sessionId: this.sessionId,
+                    projectPath: process.cwd(),
+                    model: this.apiClient.currentModel,
+                    timestamp: new Date().toISOString(),
+                };
+
+                const preHookInput: PreToolUseInput = {
+                    ...hookContext,
+                    toolName,
+                    toolInput,
+                };
+
+                const preResults = await hooksManager.execute('PreToolUse', preHookInput);
+
+                // Check if any hook blocked the tool
+                const blocked = preResults.find(r => r.block);
+                if (blocked) {
+                    toolResults.push({
+                        tool_call_id: toolCall.id,
+                        content: `Tool blocked by hook: ${blocked.blockReason || 'No reason provided'}`,
+                    });
+                    continue;
+                }
+
+                onToolStart?.(toolName);
+                const startTime = Date.now();
+
+                try {
+                    const result = await this.toolExecutor.executeToolCall(toolCall);
+                    const duration = Date.now() - startTime;
+                    toolResults.push(result);
+
+                    // Execute PostToolUse hooks
+                    const postHookInput: PostToolUseInput = {
+                        ...hookContext,
+                        toolName,
+                        toolInput,
+                        toolOutput: result.content,
+                        duration,
+                    };
+                    await hooksManager.execute('PostToolUse', postHookInput);
+
+                    onToolEnd?.(toolName, result.content);
+                } catch (error) {
+                    // Execute PostToolUseFailure hooks
+                    const failureHookInput: PostToolUseFailureInput = {
+                        ...hookContext,
+                        toolName,
+                        toolInput,
+                        error: error instanceof Error ? error.message : String(error),
+                    };
+                    await hooksManager.execute('PostToolUseFailure', failureHookInput);
+
+                    toolResults.push({
+                        tool_call_id: toolCall.id,
+                        content: `Error: ${error instanceof Error ? error.message : String(error)}`,
+                    });
+                    onToolEnd?.(toolName, 'Error');
+                }
+            }
+
+
+            // Add tool results to messages
+            for (const result of toolResults) {
+                this.messages.push({
+                    role: 'tool',
+                    tool_call_id: result.tool_call_id,
+                    content: result.content,
+                });
+            }
+        }
+
+        return {
+            content: finalContent,
+            toolsUsed,
+            iterations,
+        };
+    }
+
+    getMessages(): Message[] {
+        return [...this.messages];
+    }
+
+    getName(): string {
+        return this.name;
+    }
+}

package/src/core/agents/index.ts

@@ -0,0 +1,2 @@
+export * from './agent.js';
+export * from './orchestrator.js';

package/src/core/agents/orchestrator.ts

@@ -0,0 +1,223 @@
+/**
+ * Bluehawks CLI - Agent Orchestrator
+ * Coordinates multiple agents for complex tasks
+ */
+
+import { APIClient } from '../api/client.js';
+import { ToolExecutor } from '../tools/executor.js';
+import { Agent, type AgentResponse } from './agent.js';
+import { CONTEXT_FILE } from '../../config/constants.js';
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+
+export interface SubAgentConfig {
+    name: string;
+    description: string;
+    systemPrompt: string;
+    tools?: string[];
+}
+
+export interface OrchestratorOptions {
+    projectPath: string;
+    apiClient: APIClient;
+    toolExecutor: ToolExecutor;
+    planMode?: boolean;
+    maxTurns?: number;
+    systemPrompt?: string;
+    appendSystemPrompt?: string;
+}
+
+const DEFAULT_SYSTEM_PROMPT = `You are Bluehawks, a powerful AI coding assistant that helps developers understand and modify their codebase.
+
+You have access to various tools for:
+- Reading and writing files
+- Executing shell commands
+- Searching code with grep and finding files
+- Git operations (status, diff, commit, etc.)
+- Fetching web content
+
+Guidelines:
+1. Always read relevant files before making changes
+2. Make targeted, minimal changes
+3. Test your changes when possible
+4. Be careful with destructive operations
+5. Explain what you're doing and why
+
+When the user asks a question:
+1. First, understand what they're asking
+2. Use tools to gather necessary information
+3. Provide a clear, helpful response
+4. If making changes, explain what you changed and why`;
+
+export class Orchestrator {
+    private apiClient: APIClient;
+    private toolExecutor: ToolExecutor;
+    private projectPath: string;
+    private planMode: boolean;
+    private maxTurns: number;
+    private customSystemPrompt?: string;
+    private appendSystemPrompt?: string;
+    private contextContent: string = '';
+    private subAgents: Map<string, SubAgentConfig> = new Map();
+
+    constructor(options: OrchestratorOptions) {
+        this.apiClient = options.apiClient;
+        this.toolExecutor = options.toolExecutor;
+        this.projectPath = options.projectPath;
+        this.planMode = options.planMode || false;
+        this.maxTurns = options.maxTurns || 15;
+        this.customSystemPrompt = options.systemPrompt;
+        this.appendSystemPrompt = options.appendSystemPrompt;
+
+        // Register default sub-agents
+        this.registerDefaultSubAgents();
+    }
+
+
+    private registerDefaultSubAgents(): void {
+        this.subAgents.set('coder', {
+            name: 'coder',
+            description: 'Specialized in writing and modifying code',
+            systemPrompt: `You are a code-focused agent. Your job is to write clean, efficient code and make targeted modifications to existing code. Focus on:
+- Writing idiomatic code for the project's language
+- Following existing code conventions
+- Making minimal, focused changes
+- Adding appropriate comments when needed`,
+            tools: ['read_file', 'write_file', 'edit_file', 'grep_search', 'find_files'],
+        });
+
+        this.subAgents.set('researcher', {
+            name: 'researcher',
+            description: 'Specialized in gathering information and research',
+            systemPrompt: `You are a research agent. Your job is to gather information about the codebase and external resources. Focus on:
+- Reading and understanding code structure
+- Finding relevant files and functions
+- Fetching documentation when needed
+- Summarizing findings clearly`,
+            tools: ['read_file', 'list_directory', 'grep_search', 'find_files', 'fetch_url'],
+        });
+
+        this.subAgents.set('shell', {
+            name: 'shell',
+            description: 'Specialized in running commands and automation',
+            systemPrompt: `You are a shell execution agent. Your job is to run commands safely and interpret their output. Focus on:
+- Running build, test, and utility commands
+- Interpreting command output
+- Suggesting fixes for errors
+- Managing git operations`,
+            tools: ['run_command', 'git_status', 'git_diff', 'git_add', 'git_commit'],
+        });
+    }
+
+    async initialize(): Promise<void> {
+        // Load context file if it exists
+        await this.loadContextFile();
+    }
+
+    private async loadContextFile(): Promise<void> {
+        const contextPath = path.join(this.projectPath, CONTEXT_FILE);
+        try {
+            this.contextContent = await fs.readFile(contextPath, 'utf-8');
+        } catch {
+            this.contextContent = '';
+        }
+    }
+
+    private buildSystemPrompt(): string {
+        // Use custom system prompt if provided, otherwise default
+        let prompt = this.customSystemPrompt || DEFAULT_SYSTEM_PROMPT;
+
+        // Append additional prompt content if provided
+        if (this.appendSystemPrompt) {
+            prompt += `\n\n${this.appendSystemPrompt}`;
+        }
+
+        if (this.contextContent) {
+            prompt += `\n\n## Project Context (from ${CONTEXT_FILE})\n\n${this.contextContent}`;
+        }
+
+        if (this.planMode) {
+            prompt += `\n\n## Plan Mode Active
+Before making any changes, first:
+1. Analyze the request
+2. Create a step-by-step plan
+3. Present the plan to the user
+4. Wait for approval before proceeding
+5. Execute each step, reporting progress`;
+        }
+
+        return prompt;
+    }
+
+    async chat(
+        userMessage: string,
+        _history: Array<{ role: string; content: string }> = [],
+        callbacks?: {
+            onChunk?: (content: string) => void;
+            onToolStart?: (name: string) => void;
+            onToolEnd?: (name: string, result: string) => void;
+        }
+    ): Promise<AgentResponse> {
+        const mainAgent = new Agent(
+            {
+                name: 'main',
+                systemPrompt: this.buildSystemPrompt(),
+                maxIterations: this.maxTurns,
+            },
+            this.apiClient,
+            this.toolExecutor
+        );
+
+
+        return mainAgent.run(
+            userMessage,
+            callbacks?.onChunk,
+            callbacks?.onToolStart,
+            callbacks?.onToolEnd
+        );
+    }
+
+    async runSubAgent(
+        agentName: string,
+        task: string,
+        callbacks?: {
+            onChunk?: (content: string) => void;
+            onToolStart?: (name: string) => void;
+            onToolEnd?: (name: string, result: string) => void;
+        }
+    ): Promise<AgentResponse> {
+        const config = this.subAgents.get(agentName);
+        if (!config) {
+            throw new Error(`Unknown sub-agent: ${agentName}`);
+        }
+
+        const agent = new Agent(
+            {
+                name: config.name,
+                systemPrompt: config.systemPrompt,
+                tools: config.tools,
+                maxIterations: 10,
+            },
+            this.apiClient,
+            this.toolExecutor
+        );
+
+        return agent.run(task, callbacks?.onChunk, callbacks?.onToolStart, callbacks?.onToolEnd);
+    }
+
+    setPlanMode(enabled: boolean): void {
+        this.planMode = enabled;
+    }
+
+    isPlanMode(): boolean {
+        return this.planMode;
+    }
+
+    getSubAgents(): SubAgentConfig[] {
+        return Array.from(this.subAgents.values());
+    }
+
+    registerSubAgent(config: SubAgentConfig): void {
+        this.subAgents.set(config.name, config);
+    }
+}