@bluehawks/cli 1.0.0

package/src/core/plugins/loader.ts

@@ -0,0 +1,312 @@
+/**
+ * Bluehawks CLI - Plugin Loader
+ * Discovers and loads plugins from plugin directories
+ */
+
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import { pathToFileURL } from 'node:url';
+import type {
+    PluginManifest,
+    LoadedPlugin,
+    PluginDiscovery,
+    PluginCommandHandler,
+    PluginToolHandler,
+    PluginContext,
+} from './types.js';
+import { toolRegistry } from '../tools/index.js';
+import { hooksManager } from '../hooks/index.js';
+import type { ToolDefinition } from '../api/types.js';
+
+// Plugin directories to search
+const PLUGIN_DIRS = [
+    path.join(os.homedir(), '.bluehawks', 'plugins'),
+    path.join(process.cwd(), '.bluehawks', 'plugins'),
+];
+
+export class PluginLoader {
+    private plugins: Map<string, LoadedPlugin> = new Map();
+    private commandHandlers: Map<string, PluginCommandHandler> = new Map();
+
+    /**
+     * Discover all plugins in plugin directories
+     */
+    async discover(): Promise<PluginDiscovery[]> {
+        const discoveries: PluginDiscovery[] = [];
+
+        for (const pluginDir of PLUGIN_DIRS) {
+            try {
+                const entries = await fs.readdir(pluginDir, { withFileTypes: true });
+
+                for (const entry of entries) {
+                    if (!entry.isDirectory()) continue;
+
+                    const pluginPath = path.join(pluginDir, entry.name);
+                    const manifestPath = path.join(pluginPath, 'plugin.json');
+
+                    try {
+                        const manifestContent = await fs.readFile(manifestPath, 'utf-8');
+                        const manifest = JSON.parse(manifestContent) as PluginManifest;
+                        discoveries.push({ path: pluginPath, manifest });
+                    } catch {
+                        // No valid manifest, skip
+                    }
+                }
+            } catch {
+                // Directory doesn't exist, skip
+            }
+        }
+
+        return discoveries;
+    }
+
+    /**
+     * Load all discovered plugins
+     */
+    async loadAll(): Promise<void> {
+        const discoveries = await this.discover();
+
+        for (const discovery of discoveries) {
+            try {
+                await this.load(discovery);
+            } catch (error) {
+                console.error(`Failed to load plugin ${discovery.manifest.name}:`, error);
+            }
+        }
+    }
+
+    /**
+     * Load a single plugin
+     */
+    async load(discovery: PluginDiscovery): Promise<LoadedPlugin> {
+        const { manifest, path: pluginPath } = discovery;
+
+        const loaded: LoadedPlugin = {
+            manifest,
+            path: pluginPath,
+            commands: new Map(),
+            tools: new Map(),
+            hooks: [],
+            agents: new Map(),
+        };
+
+        // Load commands
+        if (manifest.commands) {
+            for (const cmd of manifest.commands) {
+                const handler = await this.loadCommandHandler(pluginPath, cmd.handler);
+                if (handler) {
+                    loaded.commands.set(cmd.name, handler);
+                    this.commandHandlers.set(`/${cmd.name}`, handler);
+
+                    // Register aliases
+                    if (cmd.aliases) {
+                        for (const alias of cmd.aliases) {
+                            this.commandHandlers.set(`/${alias}`, handler);
+                        }
+                    }
+                }
+            }
+        }
+
+        // Load tools
+        if (manifest.tools) {
+            for (const tool of manifest.tools) {
+                const handler = await this.loadToolHandler(pluginPath, tool.handler);
+                if (handler) {
+                    loaded.tools.set(tool.name, handler);
+                    this.registerPluginTool(tool.name, tool.description, tool.parameters, handler, tool.safeToAutoRun);
+                }
+            }
+        }
+
+        // Load hooks
+        if (manifest.hooks) {
+            for (const hook of manifest.hooks) {
+                const hookHandler = await this.createHookHandler(pluginPath, hook, manifest.name);
+                loaded.hooks.push(hookHandler);
+                hooksManager.register(hookHandler);
+            }
+        }
+
+        // Load agents
+        if (manifest.agents) {
+            for (const agent of manifest.agents) {
+                loaded.agents.set(agent.name, agent);
+            }
+        }
+
+        this.plugins.set(manifest.name, loaded);
+        return loaded;
+    }
+
+    /**
+     * Load a command handler from file
+     */
+    private async loadCommandHandler(
+        pluginPath: string,
+        handlerPath?: string
+    ): Promise<PluginCommandHandler | null> {
+        if (!handlerPath) return null;
+
+        try {
+            const fullPath = path.join(pluginPath, handlerPath);
+            const module = await import(pathToFileURL(fullPath).href);
+            return module.default || module.handler;
+        } catch {
+            return null;
+        }
+    }
+
+    /**
+     * Load a tool handler from file
+     */
+    private async loadToolHandler(
+        pluginPath: string,
+        handlerPath: string
+    ): Promise<PluginToolHandler | null> {
+        try {
+            const fullPath = path.join(pluginPath, handlerPath);
+            const module = await import(pathToFileURL(fullPath).href);
+            return module.default || module.handler;
+        } catch {
+            return null;
+        }
+    }
+
+    /**
+     * Create a hook handler from plugin config
+     */
+    private async createHookHandler(
+        pluginPath: string,
+        hook: import('./types.js').PluginHook,
+        pluginName: string
+    ) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const hookHandler: any = {
+            id: `${pluginName}-${hook.event}-${Date.now()}`,
+            name: `${pluginName}:${hook.event}`,
+            event: hook.event,
+            async: hook.async,
+            timeout: hook.timeout,
+        };
+
+        if (hook.matcher) {
+            hookHandler.matcher = new RegExp(hook.matcher);
+        }
+
+        if (hook.command) {
+            hookHandler.command = hook.command;
+        } else if (hook.handler) {
+            try {
+                const fullPath = path.join(pluginPath, hook.handler);
+                const module = await import(pathToFileURL(fullPath).href);
+                hookHandler.handler = module.default || module.handler;
+            } catch {
+                // Handler load failed
+            }
+        }
+
+        return hookHandler;
+    }
+
+    /**
+     * Register a plugin tool with the tool registry
+     */
+    private registerPluginTool(
+        name: string,
+        description: string,
+        parameters: ToolDefinition['function']['parameters'],
+        handler: PluginToolHandler,
+        safeToAutoRun = false
+    ): void {
+        const definition: ToolDefinition = {
+            type: 'function',
+            function: {
+                name: `plugin_${name}`,
+                description: `[Plugin] ${description}`,
+                parameters,
+            },
+        };
+
+        toolRegistry.register({
+            name: `plugin_${name}`,
+            definition,
+            execute: async (args: Record<string, unknown>) => {
+                const context: PluginContext = {
+                    projectPath: process.cwd(),
+                    sessionId: `session_${Date.now()}`,
+                    model: process.env.BLUEHAWKS_MODEL || 'unknown',
+                };
+                return handler(args, context);
+            },
+            safeToAutoRun,
+        });
+    }
+
+    /**
+     * Execute a plugin command
+     */
+    async executeCommand(
+        commandName: string,
+        args: string[],
+        context: PluginContext
+    ): Promise<string | null> {
+        const handler = this.commandHandlers.get(commandName);
+        if (!handler) return null;
+
+        const result = await handler(args, context);
+        return result || '';
+    }
+
+    /**
+     * Check if a command is a plugin command
+     */
+    hasCommand(commandName: string): boolean {
+        return this.commandHandlers.has(commandName);
+    }
+
+    /**
+     * Get all loaded plugins
+     */
+    getPlugins(): LoadedPlugin[] {
+        return Array.from(this.plugins.values());
+    }
+
+    /**
+     * Get a specific plugin
+     */
+    getPlugin(name: string): LoadedPlugin | undefined {
+        return this.plugins.get(name);
+    }
+
+    /**
+     * Get all plugin agents
+     */
+    getAgents(): Map<string, LoadedPlugin['agents']> {
+        const allAgents = new Map<string, LoadedPlugin['agents']>();
+        for (const [name, plugin] of this.plugins) {
+            if (plugin.agents.size > 0) {
+                allAgents.set(name, plugin.agents);
+            }
+        }
+        return allAgents;
+    }
+
+    /**
+     * Unload all plugins
+     */
+    unloadAll(): void {
+        for (const plugin of this.plugins.values()) {
+            // Remove hooks
+            for (const hook of plugin.hooks) {
+                hooksManager.unregister(hook.id);
+            }
+        }
+        this.plugins.clear();
+        this.commandHandlers.clear();
+    }
+}
+
+// Singleton instance
+export const pluginLoader = new PluginLoader();

package/src/core/plugins/types.ts

@@ -0,0 +1,111 @@
+/**
+ * Bluehawks CLI - Plugin Types
+ * Type definitions for the plugin system
+ */
+
+import type { ToolDefinition } from '../api/types.js';
+import type { HookHandler } from '../hooks/types.js';
+
+/**
+ * Plugin manifest (plugin.json)
+ */
+export interface PluginManifest {
+    name: string;
+    version: string;
+    description?: string;
+    author?: string;
+    main?: string;  // Entry point for JS plugins
+    commands?: PluginCommand[];
+    tools?: PluginTool[];
+    hooks?: PluginHook[];
+    agents?: PluginAgent[];
+}
+
+/**
+ * Custom slash command definition
+ */
+export interface PluginCommand {
+    name: string;
+    description: string;
+    aliases?: string[];
+    handler?: string;  // Path to handler file
+}
+
+/**
+ * Custom tool definition
+ */
+export interface PluginTool {
+    name: string;
+    description: string;
+    parameters: ToolDefinition['function']['parameters'];
+    handler: string;  // Path to handler file
+    safeToAutoRun?: boolean;
+}
+
+/**
+ * Hook configuration
+ */
+export interface PluginHook {
+    event: string;
+    command?: string;
+    handler?: string;  // Path to handler file
+    matcher?: string;
+    async?: boolean;
+    timeout?: number;
+}
+
+/**
+ * Custom agent definition
+ */
+export interface PluginAgent {
+    name: string;
+    description: string;
+    systemPrompt: string;
+    tools?: string[];
+    maxIterations?: number;
+}
+
+/**
+ * Loaded plugin instance
+ */
+export interface LoadedPlugin {
+    manifest: PluginManifest;
+    path: string;
+    commands: Map<string, PluginCommandHandler>;
+    tools: Map<string, PluginToolHandler>;
+    hooks: HookHandler[];
+    agents: Map<string, PluginAgent>;
+}
+
+/**
+ * Command handler function
+ */
+export type PluginCommandHandler = (
+    args: string[],
+    context: PluginContext
+) => Promise<string | void>;
+
+/**
+ * Tool handler function
+ */
+export type PluginToolHandler = (
+    args: Record<string, unknown>,
+    context: PluginContext
+) => Promise<string>;
+
+/**
+ * Context passed to plugin handlers
+ */
+export interface PluginContext {
+    projectPath: string;
+    sessionId: string;
+    model: string;
+}
+
+/**
+ * Plugin discovery result
+ */
+export interface PluginDiscovery {
+    path: string;
+    manifest: PluginManifest;
+}

package/src/core/session/index.ts

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

package/src/core/session/manager.ts

@@ -0,0 +1,246 @@
+/**
+ * Bluehawks CLI - Session Manager
+ * Manages conversation history and session state
+ */
+
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import type { Message } from '../api/types.js';
+import { CONFIG_DIR_NAME, HISTORY_FILE, MAX_HISTORY_MESSAGES } from '../../config/constants.js';
+
+export interface Session {
+    id: string;
+    startTime: Date;
+    messages: Message[];
+    metadata: {
+        projectPath: string;
+        model: string;
+        tokensUsed: number;
+        toolsUsed: string[];
+    };
+}
+
+export interface SessionStats {
+    messageCount: number;
+    userMessages: number;
+    assistantMessages: number;
+    toolMessages: number;
+    tokensUsed: number;
+    toolsUsed: string[];
+    duration: number;
+}
+
+export class SessionManager {
+    private session: Session;
+    private configDir: string;
+
+    constructor(projectPath: string, model: string) {
+        this.configDir = path.join(projectPath, CONFIG_DIR_NAME);
+        this.session = {
+            id: this.generateSessionId(),
+            startTime: new Date(),
+            messages: [],
+            metadata: {
+                projectPath,
+                model,
+                tokensUsed: 0,
+                toolsUsed: [],
+            },
+        };
+    }
+
+    private generateSessionId(): string {
+        return `session_${Date.now()}_${Math.random().toString(36).substring(2, 8)}`;
+    }
+
+    addMessage(message: Message): void {
+        this.session.messages.push(message);
+
+        // Limit history size
+        if (this.session.messages.length > MAX_HISTORY_MESSAGES) {
+            this.compressHistory();
+        }
+    }
+
+    addMessages(messages: Message[]): void {
+        for (const message of messages) {
+            this.addMessage(message);
+        }
+    }
+
+    addToolUsed(toolName: string): void {
+        if (!this.session.metadata.toolsUsed.includes(toolName)) {
+            this.session.metadata.toolsUsed.push(toolName);
+        }
+    }
+
+    addTokensUsed(tokens: number): void {
+        this.session.metadata.tokensUsed += tokens;
+    }
+
+    getMessages(): Message[] {
+        return [...this.session.messages];
+    }
+
+    getStats(): SessionStats {
+        const messages = this.session.messages;
+        const duration = Date.now() - this.session.startTime.getTime();
+
+        return {
+            messageCount: messages.length,
+            userMessages: messages.filter((m) => m.role === 'user').length,
+            assistantMessages: messages.filter((m) => m.role === 'assistant').length,
+            toolMessages: messages.filter((m) => m.role === 'tool').length,
+            tokensUsed: this.session.metadata.tokensUsed,
+            toolsUsed: [...this.session.metadata.toolsUsed],
+            duration,
+        };
+    }
+
+    clear(): void {
+        this.session.messages = [];
+        this.session.metadata.tokensUsed = 0;
+        this.session.metadata.toolsUsed = [];
+    }
+
+    compressHistory(): void {
+        // Keep system message and recent messages
+        const systemMessage = this.session.messages.find((m) => m.role === 'system');
+        const recentMessages = this.session.messages.slice(-20);
+
+        // Create a summary of older messages
+        const olderMessages = this.session.messages.slice(
+            systemMessage ? 1 : 0,
+            -20
+        );
+
+        if (olderMessages.length > 0) {
+            const summaryContent = `[Previous conversation compressed: ${olderMessages.length} messages removed to save context. Key topics discussed included: ${this.extractTopics(olderMessages)}]`;
+
+            const newMessages: Message[] = [];
+            if (systemMessage) {
+                newMessages.push(systemMessage);
+            }
+            newMessages.push({
+                role: 'assistant',
+                content: summaryContent,
+            });
+            newMessages.push(...recentMessages);
+
+            this.session.messages = newMessages;
+        }
+    }
+
+    private extractTopics(messages: Message[]): string {
+        // Simple topic extraction - just get first few words from user messages
+        const userMessages = messages
+            .filter((m) => m.role === 'user')
+            .map((m) => {
+                const content = typeof m.content === 'string' ? m.content : '';
+                return content.substring(0, 50).replace(/\n/g, ' ');
+            })
+            .slice(0, 5);
+
+        return userMessages.join(', ') || 'general coding assistance';
+    }
+
+    async save(name?: string): Promise<string> {
+        await fs.mkdir(this.configDir, { recursive: true });
+
+        // Save to local project config
+        const historyPath = path.join(this.configDir, HISTORY_FILE);
+        const data = JSON.stringify(this.session, null, 2);
+        await fs.writeFile(historyPath, data, 'utf-8');
+
+        // Also save to global session storage for --continue/--resume
+        const { sessionStorage } = await import('./storage.js');
+        const preview = this.getPreview();
+        await sessionStorage.saveSession(
+            this.session.id,
+            name || null,
+            this.session,
+            {
+                projectPath: this.session.metadata.projectPath,
+                model: this.session.metadata.model,
+                messageCount: this.session.messages.length,
+                preview,
+            }
+        );
+
+        return historyPath;
+    }
+
+    /**
+     * Get a preview of the session (first user message)
+     */
+    private getPreview(): string {
+        const userMessage = this.session.messages.find(m => m.role === 'user');
+        if (userMessage && typeof userMessage.content === 'string') {
+            return userMessage.content.substring(0, 100).replace(/\n/g, ' ');
+        }
+        return '';
+    }
+
+    /**
+     * Load from global session storage (for --continue/--resume)
+     */
+    async loadFromGlobalStorage(sessionIdOrName?: string): Promise<boolean> {
+        const { sessionStorage } = await import('./storage.js');
+
+        let sessionData: unknown;
+        if (sessionIdOrName) {
+            sessionData = await sessionStorage.loadSession(sessionIdOrName);
+        } else {
+            const last = await sessionStorage.loadLastSession();
+            sessionData = last?.data;
+        }
+
+        if (sessionData && typeof sessionData === 'object' && sessionData !== null) {
+            const loaded = sessionData as Session;
+            this.session = {
+                ...loaded,
+                startTime: new Date(loaded.startTime),
+            };
+            return true;
+        }
+        return false;
+    }
+
+    /**
+     * Set a name for the current session
+     */
+    setSessionName(name: string): void {
+        // Store the name - will be used when saving
+        (this.session as Session & { name?: string }).name = name;
+    }
+
+
+    async load(sessionId?: string): Promise<boolean> {
+        const historyPath = path.join(this.configDir, HISTORY_FILE);
+
+        try {
+            const data = await fs.readFile(historyPath, 'utf-8');
+            const loaded = JSON.parse(data) as Session;
+
+            if (!sessionId || loaded.id === sessionId) {
+                this.session = {
+                    ...loaded,
+                    startTime: new Date(loaded.startTime),
+                };
+                return true;
+            }
+        } catch {
+            // No history file or invalid format
+        }
+
+        return false;
+    }
+
+    getSessionId(): string {
+        return this.session.id;
+    }
+
+    getStartTime(): Date {
+        return this.session.startTime;
+    }
+}