@defai.digital/ax-cli 2.7.0 → 3.0.0

package/dist/agent/subagent-types.js

@@ -0,0 +1,152 @@
+/**
+ * Subagent System Types
+ *
+ * Type definitions for the autonomous subagent system that enables
+ * parallel task execution and specialized agent capabilities.
+ */
+/**
+ * Types of specialized agents available
+ */
+export var SubagentRole;
+(function (SubagentRole) {
+    /** General-purpose agent for any task */
+    SubagentRole["GENERAL"] = "general";
+    /** Specialized in writing and running tests */
+    SubagentRole["TESTING"] = "testing";
+    /** Specialized in generating documentation */
+    SubagentRole["DOCUMENTATION"] = "documentation";
+    /** Specialized in code refactoring */
+    SubagentRole["REFACTORING"] = "refactoring";
+    /** Specialized in code analysis and bug detection */
+    SubagentRole["ANALYSIS"] = "analysis";
+    /** Specialized in debugging and error resolution */
+    SubagentRole["DEBUG"] = "debug";
+    /** Specialized in performance optimization */
+    SubagentRole["PERFORMANCE"] = "performance";
+})(SubagentRole || (SubagentRole = {}));
+/**
+ * Execution state of a subagent
+ */
+export var SubagentState;
+(function (SubagentState) {
+    /** Waiting to be started */
+    SubagentState["PENDING"] = "pending";
+    /** Currently executing */
+    SubagentState["RUNNING"] = "running";
+    /** Successfully completed */
+    SubagentState["COMPLETED"] = "completed";
+    /** Failed with error */
+    SubagentState["FAILED"] = "failed";
+    /** Cancelled by user or system */
+    SubagentState["CANCELLED"] = "cancelled";
+})(SubagentState || (SubagentState = {}));
+/**
+ * Default subagent configuration by role
+ */
+export const DEFAULT_SUBAGENT_CONFIG = {
+    [SubagentRole.GENERAL]: {
+        allowedTools: ['bash', 'text_editor', 'search', 'todo'],
+        maxToolRounds: 30,
+        contextDepth: 20,
+        priority: 1,
+    },
+    [SubagentRole.TESTING]: {
+        allowedTools: ['bash', 'text_editor', 'search'],
+        maxToolRounds: 20,
+        contextDepth: 15,
+        priority: 2,
+    },
+    [SubagentRole.DOCUMENTATION]: {
+        allowedTools: ['text_editor', 'search'],
+        maxToolRounds: 15,
+        contextDepth: 10,
+        priority: 2,
+    },
+    [SubagentRole.REFACTORING]: {
+        allowedTools: ['text_editor', 'search', 'bash'],
+        maxToolRounds: 25,
+        contextDepth: 20,
+        priority: 2,
+    },
+    [SubagentRole.ANALYSIS]: {
+        allowedTools: ['search', 'bash'],
+        maxToolRounds: 15,
+        contextDepth: 15,
+        priority: 3,
+    },
+    [SubagentRole.DEBUG]: {
+        allowedTools: ['bash', 'text_editor', 'search'],
+        maxToolRounds: 25,
+        contextDepth: 20,
+        priority: 3,
+    },
+    [SubagentRole.PERFORMANCE]: {
+        allowedTools: ['bash', 'search', 'text_editor'],
+        maxToolRounds: 20,
+        contextDepth: 15,
+        priority: 2,
+    },
+};
+/**
+ * System prompts for each subagent role
+ */
+export const SUBAGENT_SYSTEM_PROMPTS = {
+    [SubagentRole.GENERAL]: `You are a general-purpose AI coding assistant.
+You can handle any coding task assigned to you.
+Be thorough, clear, and follow best practices.`,
+    [SubagentRole.TESTING]: `You are a specialized testing agent.
+Your role is to:
+- Write comprehensive unit tests
+- Write integration tests
+- Ensure high test coverage
+- Follow testing best practices for the project's framework
+- Write clear, maintainable test code
+- Include edge cases and error scenarios
+Focus ONLY on testing tasks.`,
+    [SubagentRole.DOCUMENTATION]: `You are a specialized documentation agent.
+Your role is to:
+- Generate clear, comprehensive documentation
+- Follow documentation standards (JSDoc, Markdown, etc.)
+- Include usage examples
+- Document edge cases and limitations
+- Write in clear, concise language
+- Structure documentation logically
+Focus ONLY on documentation tasks.`,
+    [SubagentRole.REFACTORING]: `You are a specialized refactoring agent.
+Your role is to:
+- Improve code structure and readability
+- Apply SOLID principles
+- Reduce code duplication
+- Optimize performance where applicable
+- Maintain backward compatibility
+- Preserve existing functionality
+Focus ONLY on refactoring tasks.`,
+    [SubagentRole.ANALYSIS]: `You are a specialized code analysis agent.
+Your role is to:
+- Analyze code for potential bugs
+- Identify security vulnerabilities
+- Detect code smells and anti-patterns
+- Suggest improvements
+- Check for best practice violations
+- Provide detailed analysis reports
+Focus ONLY on analysis tasks.`,
+    [SubagentRole.DEBUG]: `You are a specialized debugging agent.
+Your role is to:
+- Identify and fix bugs
+- Add proper error handling
+- Improve error messages
+- Add logging where helpful
+- Test fixes thoroughly
+- Explain the root cause of issues
+Focus ONLY on debugging tasks.`,
+    [SubagentRole.PERFORMANCE]: `You are a specialized performance optimization agent.
+Your role is to:
+- Identify performance bottlenecks
+- Optimize algorithms and data structures
+- Reduce memory usage
+- Improve execution speed
+- Add performance monitoring
+- Benchmark optimizations
+Focus ONLY on performance tasks.`,
+};
+//# sourceMappingURL=subagent-types.js.map

package/dist/agent/subagent-types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"subagent-types.js","sourceRoot":"","sources":["../../src/agent/subagent-types.ts"],"names":[],"mappings":"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"}

package/dist/agent/subagent.d.ts

@@ -0,0 +1,88 @@
+/**
+ * Subagent Base Class
+ *
+ * Base class for all specialized subagents. Subagents are lightweight AI agents
+ * that focus on specific tasks (testing, documentation, refactoring, etc.) with
+ * limited tool access and shallow conversation history.
+ */
+import { EventEmitter } from 'events';
+import { LLMClient } from '../llm/client.js';
+import type { LLMMessage } from '../llm/client.js';
+import type { ChatEntry } from './llm-agent.js';
+import type { SubagentConfig, SubagentTask, SubagentResult, SubagentStatus } from './subagent-types.js';
+import { SubagentRole } from './subagent-types.js';
+/**
+ * Base Subagent class
+ */
+export declare class Subagent extends EventEmitter {
+    readonly id: string;
+    readonly role: SubagentRole;
+    readonly config: SubagentConfig;
+    protected llmClient: LLMClient;
+    protected chatHistory: ChatEntry[];
+    protected messages: LLMMessage[];
+    protected tools: Map<string, any>;
+    protected isActive: boolean;
+    protected currentTaskId: string | null;
+    protected status: SubagentStatus;
+    constructor(role: SubagentRole, configOverrides?: Partial<SubagentConfig>);
+    /**
+     * Get default configuration for a role
+     */
+    private getDefaultConfig;
+    /**
+     * Initialize tools based on allowed tools in config
+     */
+    private initializeTools;
+    /**
+     * Build system prompt for this subagent role
+     * Override in specialized subagent classes
+     */
+    protected buildSystemPrompt(): string;
+    /**
+     * Execute a task
+     */
+    executeTask(task: SubagentTask): Promise<SubagentResult>;
+    /**
+     * Build context prompt from task
+     */
+    private buildContextPrompt;
+    /**
+     * Execute a tool call
+     */
+    private executeToolCall;
+    /**
+     * Get tool definitions for LLM
+     */
+    private getToolDefinitions;
+    /**
+     * Get current status
+     */
+    getStatus(): SubagentStatus;
+    /**
+     * Abort execution
+     */
+    abort(): void;
+    /**
+     * Terminate subagent
+     */
+    terminate(): Promise<void>;
+    /**
+     * Get chat history (for debugging/monitoring)
+     */
+    getChatHistory(): ChatEntry[];
+    /**
+     * Get logs (alias for getChatHistory for test compatibility)
+     */
+    getLogs(): ChatEntry[];
+    /**
+     * Receive a message from parent/orchestrator
+     */
+    receiveMessage(message: {
+        from: 'parent' | 'orchestrator';
+        to: 'subagent';
+        type: 'instruction' | 'cancellation' | 'query';
+        content: string;
+        timestamp: Date;
+    }): Promise<void>;
+}

package/dist/agent/subagent.js

@@ -0,0 +1,426 @@
+/**
+ * Subagent Base Class
+ *
+ * Base class for all specialized subagents. Subagents are lightweight AI agents
+ * that focus on specific tasks (testing, documentation, refactoring, etc.) with
+ * limited tool access and shallow conversation history.
+ */
+import { EventEmitter } from 'events';
+import { LLMClient } from '../llm/client.js';
+import { SubagentRole, SubagentState } from './subagent-types.js';
+// Import tools
+import { BashTool } from '../tools/bash.js';
+import { TextEditorTool } from '../tools/text-editor.js';
+import { SearchTool } from '../tools/search.js';
+/**
+ * Base Subagent class
+ */
+export class Subagent extends EventEmitter {
+    id;
+    role;
+    config;
+    llmClient;
+    chatHistory;
+    messages;
+    tools;
+    isActive;
+    currentTaskId;
+    status;
+    constructor(role, configOverrides) {
+        super();
+        this.id = `${role}-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+        this.role = role;
+        // Merge with default config for this role
+        const defaultConfig = this.getDefaultConfig(role);
+        this.config = { ...defaultConfig, ...configOverrides, role };
+        this.chatHistory = [];
+        this.messages = [];
+        this.tools = new Map();
+        this.isActive = false;
+        this.currentTaskId = null;
+        // Initialize status
+        this.status = {
+            id: this.id,
+            taskId: '',
+            role: this.role,
+            state: SubagentState.PENDING,
+            progress: 0,
+            startTime: new Date(),
+        };
+        // Initialize LLM client with same settings as main agent
+        this.llmClient = new LLMClient(process.env.YOUR_API_KEY || '', process.env.GROK_MODEL || 'glm-4.6', process.env.GROK_BASE_URL);
+        // Initialize allowed tools
+        this.initializeTools();
+        // Set system prompt
+        this.messages.push({
+            role: 'system',
+            content: this.buildSystemPrompt(),
+        });
+    }
+    /**
+     * Get default configuration for a role
+     */
+    getDefaultConfig(role) {
+        // Default tools and settings based on role
+        const roleDefaults = {
+            [SubagentRole.GENERAL]: {
+                allowedTools: ['bash', 'text_editor', 'search'],
+                maxToolRounds: 30,
+                contextDepth: 20,
+                priority: 1,
+            },
+            [SubagentRole.TESTING]: {
+                allowedTools: ['bash', 'text_editor', 'search'],
+                maxToolRounds: 20,
+                contextDepth: 10,
+                priority: 2,
+            },
+            [SubagentRole.DOCUMENTATION]: {
+                allowedTools: ['text_editor', 'search'],
+                maxToolRounds: 15,
+                contextDepth: 20,
+                priority: 1,
+            },
+            [SubagentRole.REFACTORING]: {
+                allowedTools: ['bash', 'text_editor', 'search'],
+                maxToolRounds: 25,
+                contextDepth: 20,
+                priority: 2,
+            },
+            [SubagentRole.ANALYSIS]: {
+                allowedTools: ['bash', 'text_editor', 'search'],
+                maxToolRounds: 15,
+                contextDepth: 15,
+                priority: 3,
+            },
+            [SubagentRole.DEBUG]: {
+                allowedTools: ['bash', 'text_editor', 'search'],
+                maxToolRounds: 30,
+                contextDepth: 15,
+                priority: 3,
+            },
+            [SubagentRole.PERFORMANCE]: {
+                allowedTools: ['bash', 'search'],
+                maxToolRounds: 25,
+                contextDepth: 10,
+                priority: 2,
+            },
+        };
+        return {
+            role,
+            allowedTools: [],
+            maxToolRounds: 20,
+            contextDepth: 10,
+            priority: 1,
+            ...roleDefaults[role],
+        };
+    }
+    /**
+     * Initialize tools based on allowed tools in config
+     */
+    initializeTools() {
+        const allowedTools = this.config.allowedTools;
+        if (allowedTools.includes('bash')) {
+            this.tools.set('bash', new BashTool());
+        }
+        if (allowedTools.includes('text_editor')) {
+            // TextEditorTool doesn't need parameters
+            this.tools.set('text_editor', new TextEditorTool());
+        }
+        if (allowedTools.includes('search')) {
+            this.tools.set('search', new SearchTool());
+        }
+    }
+    /**
+     * Build system prompt for this subagent role
+     * Override in specialized subagent classes
+     */
+    buildSystemPrompt() {
+        return this.config.customSystemPrompt || `You are a specialized ${this.role} agent.`;
+    }
+    /**
+     * Execute a task
+     */
+    async executeTask(task) {
+        this.isActive = true;
+        this.currentTaskId = task.id;
+        const startTime = Date.now();
+        // Update status
+        this.status = {
+            id: this.id,
+            taskId: task.id,
+            role: this.role,
+            state: SubagentState.RUNNING,
+            progress: 0,
+            startTime: new Date(),
+            toolsUsed: [],
+            toolRoundsUsed: 0,
+        };
+        const result = {
+            id: this.id,
+            taskId: task.id,
+            role: this.role,
+            success: false,
+            output: '',
+            executionTime: 0,
+            status: this.status,
+            filesModified: [],
+            filesCreated: [],
+            toolCalls: [],
+        };
+        try {
+            // Emit both 'start' and 'task-started' for compatibility
+            this.emit('start', { taskId: task.id, role: this.role });
+            this.emit('task-started', { taskId: task.id, role: this.role });
+            // Add task context to messages
+            const contextPrompt = this.buildContextPrompt(task);
+            this.messages.push({
+                role: 'user',
+                content: contextPrompt,
+            });
+            // Add to chat history
+            this.chatHistory.push({
+                type: 'user',
+                content: contextPrompt,
+                timestamp: new Date(),
+            });
+            // Execute with tool rounds limit
+            let toolRounds = 0;
+            let isComplete = false;
+            while (toolRounds < this.config.maxToolRounds && !isComplete) {
+                const response = await this.llmClient.chat(this.messages, this.getToolDefinitions(), { stream: false });
+                if (!response.choices || response.choices.length === 0) {
+                    throw new Error('No response from LLM');
+                }
+                const choice = response.choices[0];
+                const message = choice.message;
+                // Handle content
+                if (message.content) {
+                    this.chatHistory.push({
+                        type: 'assistant',
+                        content: message.content,
+                        timestamp: new Date(),
+                    });
+                    result.output = message.content;
+                    this.emit('progress', {
+                        taskId: task.id,
+                        content: message.content,
+                    });
+                }
+                // Handle tool calls
+                if (message.tool_calls && message.tool_calls.length > 0) {
+                    this.messages.push({
+                        role: 'assistant',
+                        content: message.content || '',
+                        tool_calls: message.tool_calls,
+                    });
+                    for (const toolCall of message.tool_calls) {
+                        const toolResult = await this.executeToolCall(toolCall);
+                        // Track tool usage in status
+                        if (!this.status.toolsUsed) {
+                            this.status.toolsUsed = [];
+                        }
+                        if (!this.status.toolsUsed.includes(toolCall.function.name)) {
+                            this.status.toolsUsed.push(toolCall.function.name);
+                        }
+                        // Track tool calls
+                        if (!result.toolCalls) {
+                            result.toolCalls = [];
+                        }
+                        result.toolCalls.push(toolCall);
+                        // Track files created/modified
+                        if (toolCall.function.name === 'text_editor' && toolResult.success) {
+                            try {
+                                const args = JSON.parse(toolCall.function.arguments);
+                                if (args.path) {
+                                    if (args.command === 'create') {
+                                        if (!result.filesCreated.includes(args.path)) {
+                                            result.filesCreated.push(args.path);
+                                        }
+                                    }
+                                    else {
+                                        if (!result.filesModified.includes(args.path)) {
+                                            result.filesModified.push(args.path);
+                                        }
+                                    }
+                                }
+                            }
+                            catch {
+                                // Ignore JSON parse errors for file tracking - non-critical
+                            }
+                        }
+                        // Add tool result to messages
+                        this.messages.push({
+                            role: 'tool',
+                            tool_call_id: toolCall.id,
+                            content: toolResult.output || toolResult.error || '',
+                        });
+                        this.chatHistory.push({
+                            type: 'tool_result',
+                            content: toolResult.output || toolResult.error || '',
+                            timestamp: new Date(),
+                            toolCall: toolCall,
+                            toolResult: toolResult,
+                        });
+                        this.emit('tool-executed', {
+                            taskId: task.id,
+                            toolName: toolCall.function.name,
+                            result: toolResult,
+                        });
+                    }
+                    toolRounds++;
+                    this.status.toolRoundsUsed = toolRounds;
+                }
+                else {
+                    // No more tool calls, task complete
+                    isComplete = true;
+                }
+                // Check timeout
+                const elapsed = Date.now() - startTime;
+                if (this.config.timeout && elapsed > this.config.timeout) {
+                    throw new Error(`Task timeout after ${elapsed}ms`);
+                }
+            }
+            result.success = true;
+            result.executionTime = Date.now() - startTime;
+            this.status.state = SubagentState.COMPLETED;
+            this.status.endTime = new Date();
+            this.status.progress = 100;
+            result.status = { ...this.status };
+            this.emit('task-completed', { taskId: task.id, result });
+        }
+        catch (error) {
+            result.success = false;
+            result.error = error.message;
+            result.executionTime = Date.now() - startTime;
+            this.status.state = SubagentState.FAILED;
+            this.status.endTime = new Date();
+            this.status.error = error.message;
+            result.status = { ...this.status };
+            this.emit('task-failed', { taskId: task.id, error: error.message });
+        }
+        finally {
+            this.isActive = false;
+            this.currentTaskId = null;
+        }
+        return result;
+    }
+    /**
+     * Build context prompt from task
+     */
+    buildContextPrompt(task) {
+        let prompt = `Task: ${task.description}\n\n`;
+        if (task.context) {
+            prompt += `Context:\n`;
+            if (task.context.metadata?.workingDirectory) {
+                prompt += `- Working Directory: ${task.context.metadata.workingDirectory}\n`;
+            }
+            if (task.context.conversationHistory && task.context.conversationHistory.length > 0) {
+                prompt += `\nRecent conversation:\n`;
+                task.context.conversationHistory.slice(-5).forEach((entry) => {
+                    prompt += `${entry.type}: ${entry.content.substring(0, 200)}\n`;
+                });
+            }
+        }
+        return prompt;
+    }
+    /**
+     * Execute a tool call
+     */
+    async executeToolCall(toolCall) {
+        const toolName = toolCall.function.name;
+        const tool = this.tools.get(toolName);
+        if (!tool) {
+            return {
+                success: false,
+                error: `Tool '${toolName}' not available for ${this.role} agent`,
+            };
+        }
+        // Validate arguments exist before parsing
+        if (!toolCall.function.arguments || toolCall.function.arguments.trim() === '') {
+            return {
+                success: false,
+                error: `Tool '${toolName}' called with empty arguments`,
+            };
+        }
+        let args;
+        try {
+            args = JSON.parse(toolCall.function.arguments);
+        }
+        catch (parseError) {
+            return {
+                success: false,
+                error: `Failed to parse ${toolName} arguments: ${parseError.message}`,
+            };
+        }
+        try {
+            const result = await tool.execute(args);
+            return result;
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: `Tool execution error in ${toolName}: ${error.message}`,
+            };
+        }
+    }
+    /**
+     * Get tool definitions for LLM
+     */
+    getToolDefinitions() {
+        const definitions = [];
+        for (const [, tool] of this.tools) {
+            if (typeof tool.getToolDefinition === 'function') {
+                definitions.push(tool.getToolDefinition());
+            }
+        }
+        return definitions;
+    }
+    /**
+     * Get current status
+     */
+    getStatus() {
+        return { ...this.status };
+    }
+    /**
+     * Abort execution
+     */
+    abort() {
+        this.isActive = false;
+        this.status.state = SubagentState.CANCELLED;
+        this.status.endTime = new Date();
+        this.emit('cancel', { role: this.role });
+    }
+    /**
+     * Terminate subagent
+     */
+    async terminate() {
+        this.isActive = false;
+        this.currentTaskId = null;
+        this.removeAllListeners();
+        this.emit('terminated', { role: this.role });
+    }
+    /**
+     * Get chat history (for debugging/monitoring)
+     */
+    getChatHistory() {
+        return [...this.chatHistory];
+    }
+    /**
+     * Get logs (alias for getChatHistory for test compatibility)
+     */
+    getLogs() {
+        return [...this.chatHistory];
+    }
+    /**
+     * Receive a message from parent/orchestrator
+     */
+    async receiveMessage(message) {
+        this.emit('message', message);
+        // Handle cancellation messages
+        if (message.type === 'cancellation') {
+            this.abort();
+        }
+    }
+}
+//# sourceMappingURL=subagent.js.map