@defai.digital/automatosx 8.0.19 → 8.0.21

package/dist/scripts/src/agents/AgentRegistry.js

@@ -1,246 +0,0 @@
-/**
- * AgentRegistry.ts
- *
- * Central registry for all AI agents
- * Phase 7: Agent System Implementation - Day 1
- */
-/**
- * AgentRegistry - Central registry for all agents
- *
- * Provides:
- * - Agent registration and discovery
- * - Agent selection by capability
- * - Agent metadata lookup
- * - List available agents
- */
-export class AgentRegistry {
-    agents = new Map();
-    initialized = false;
-    /**
-     * Register an agent
-     */
-    register(agent) {
-        const metadata = agent.getMetadata();
-        if (this.agents.has(metadata.type)) {
-            throw new Error(`Agent already registered: ${metadata.type}`);
-        }
-        this.agents.set(metadata.type, agent);
-    }
-    /**
-     * Get agent by type
-     */
-    get(type) {
-        return this.agents.get(type);
-    }
-    /**
-     * Get all registered agents
-     */
-    getAll() {
-        return Array.from(this.agents.values());
-    }
-    /**
-     * Get all agent types
-     */
-    getTypes() {
-        return Array.from(this.agents.keys());
-    }
-    /**
-     * Get agent metadata by type
-     */
-    getMetadata(type) {
-        const agent = this.agents.get(type);
-        return agent?.getMetadata();
-    }
-    /**
-     * Get all agent metadata
-     */
-    getAllMetadata() {
-        return this.getAll().map((agent) => agent.getMetadata());
-    }
-    /**
-     * Find best agent for a task based on capability matching
-     */
-    findBestAgent(task) {
-        if (task.assignedAgent) {
-            // Task already assigned to specific agent
-            const agent = this.agents.get(task.assignedAgent);
-            return agent || null;
-        }
-        let bestAgent = null;
-        let bestScore = 0;
-        for (const agent of this.agents.values()) {
-            const score = agent.canHandle(task);
-            if (score > bestScore) {
-                bestScore = score;
-                bestAgent = agent;
-            }
-        }
-        // Require minimum score of 0.3 to consider agent capable
-        return bestScore >= 0.3 ? bestAgent : null;
-    }
-    /**
-     * Find multiple agents by capability (for collaboration)
-     */
-    findAgentsByCapability(capability) {
-        const capabilityLower = capability.toLowerCase();
-        const matches = [];
-        for (const agent of this.agents.values()) {
-            const metadata = agent.getMetadata();
-            // Check capabilities
-            for (const cap of metadata.capabilities) {
-                if (cap.name.toLowerCase().includes(capabilityLower) ||
-                    cap.keywords.some((k) => k.toLowerCase().includes(capabilityLower))) {
-                    matches.push(agent);
-                    break;
-                }
-            }
-            // Check specializations
-            for (const spec of metadata.specializations) {
-                if (spec.toLowerCase().includes(capabilityLower)) {
-                    matches.push(agent);
-                    break;
-                }
-            }
-        }
-        return matches;
-    }
-    /**
-     * Search agents by keywords
-     */
-    searchAgents(keywords) {
-        const matches = new Map();
-        for (const agent of this.agents.values()) {
-            let score = 0;
-            const metadata = agent.getMetadata();
-            for (const keyword of keywords) {
-                const keywordLower = keyword.toLowerCase();
-                // Check name
-                if (metadata.name.toLowerCase().includes(keywordLower)) {
-                    score += 3;
-                }
-                // Check description
-                if (metadata.description.toLowerCase().includes(keywordLower)) {
-                    score += 2;
-                }
-                // Check capabilities
-                for (const cap of metadata.capabilities) {
-                    if (cap.name.toLowerCase().includes(keywordLower)) {
-                        score += 2;
-                    }
-                    if (cap.keywords.some((k) => k.toLowerCase().includes(keywordLower))) {
-                        score += 1;
-                    }
-                }
-                // Check specializations
-                for (const spec of metadata.specializations) {
-                    if (spec.toLowerCase().includes(keywordLower)) {
-                        score += 2;
-                    }
-                }
-            }
-            if (score > 0) {
-                matches.set(agent, score);
-            }
-        }
-        // Sort by score
-        return Array.from(matches.entries())
-            .sort(([, scoreA], [, scoreB]) => scoreB - scoreA)
-            .map(([agent]) => agent);
-    }
-    /**
-     * Get agents by specialization
-     */
-    getAgentsBySpecialization(specialization) {
-        const specializationLower = specialization.toLowerCase();
-        const matches = [];
-        for (const agent of this.agents.values()) {
-            const metadata = agent.getMetadata();
-            if (metadata.specializations.some((s) => s.toLowerCase().includes(specializationLower))) {
-                matches.push(agent);
-            }
-        }
-        return matches;
-    }
-    /**
-     * Check if agent is registered
-     */
-    has(type) {
-        return this.agents.has(type);
-    }
-    /**
-     * Unregister an agent
-     */
-    unregister(type) {
-        return this.agents.delete(type);
-    }
-    /**
-     * Clear all agents
-     */
-    clear() {
-        this.agents.clear();
-        this.initialized = false;
-    }
-    /**
-     * Get registry size
-     */
-    size() {
-        return this.agents.size;
-    }
-    /**
-     * Mark registry as initialized
-     */
-    markInitialized() {
-        this.initialized = true;
-    }
-    /**
-     * Check if registry is initialized
-     */
-    isInitialized() {
-        return this.initialized;
-    }
-    /**
-     * Get registry statistics
-     */
-    getStats() {
-        const metadata = this.getAllMetadata();
-        return {
-            totalAgents: this.size(),
-            agentTypes: this.getTypes(),
-            totalCapabilities: metadata.reduce((sum, m) => sum + m.capabilities.length, 0),
-            totalSpecializations: metadata.reduce((sum, m) => sum + m.specializations.length, 0),
-            initialized: this.initialized,
-        };
-    }
-    /**
-     * Validate registry (ensure all required agents are registered)
-     */
-    validate() {
-        const requiredAgents = [
-            'backend',
-            'frontend',
-            'security',
-            'quality',
-            'devops',
-            'architecture',
-            'data',
-            'product',
-        ];
-        const missingAgents = requiredAgents.filter((type) => !this.has(type));
-        return {
-            valid: missingAgents.length === 0,
-            missingAgents,
-        };
-    }
-    /**
-     * Export registry as JSON
-     */
-    toJSON() {
-        return {
-            agents: Array.from(this.agents.entries()).map(([type, agent]) => ({
-                type,
-                metadata: agent.getMetadata(),
-            })),
-            stats: this.getStats(),
-        };
-    }
-}

package/dist/scripts/src/cli/interactive/ConversationContext.js

@@ -1,318 +0,0 @@
-/**
- * AutomatosX v8.0.0 - Conversation Context Manager
- *
- * Manages conversation state, messages, and context variables
- * Day 3: In-memory implementation
- * Day 4: Will add SQLite persistence
- */
-import { randomUUID } from 'crypto';
-/**
- * Conversation Context Manager
- *
- * Handles:
- * - Message history (in-memory for Day 3)
- * - Active agent tracking
- * - Active workflow tracking
- * - Context variables
- * - Snapshots for save/load
- */
-export class ConversationContext {
-    db;
-    conversationId;
-    userId;
-    messages = [];
-    activeAgent;
-    activeWorkflow;
-    variables = {};
-    createdAt;
-    updatedAt;
-    constructor(db, userId, conversationId) {
-        this.db = db;
-        this.userId = userId;
-        this.conversationId = conversationId || randomUUID();
-        this.createdAt = new Date();
-        this.updatedAt = new Date();
-    }
-    /**
-     * Get conversation ID
-     */
-    getConversationId() {
-        return this.conversationId;
-    }
-    /**
-     * Get user ID
-     */
-    getUserId() {
-        return this.userId;
-    }
-    /**
-     * Add message to conversation
-     */
-    addMessage(role, content, metadata) {
-        const message = {
-            id: randomUUID(),
-            conversationId: this.conversationId,
-            role,
-            content,
-            timestamp: new Date(),
-            metadata: metadata || {}
-        };
-        this.messages.push(message);
-        this.updatedAt = new Date();
-        return message;
-    }
-    /**
-     * Get all messages in conversation
-     */
-    getMessages() {
-        return [...this.messages];
-    }
-    /**
-     * Get recent messages (last N)
-     */
-    getRecentMessages(limit = 10) {
-        return this.messages.slice(-limit);
-    }
-    /**
-     * Get message count
-     */
-    getMessageCount() {
-        return this.messages.length;
-    }
-    /**
-     * Set active agent
-     */
-    setActiveAgent(agentName) {
-        this.activeAgent = agentName;
-        this.updatedAt = new Date();
-    }
-    /**
-     * Get active agent
-     */
-    getActiveAgent() {
-        return this.activeAgent;
-    }
-    /**
-     * Set active workflow
-     */
-    setActiveWorkflow(workflowPath) {
-        this.activeWorkflow = workflowPath;
-        this.updatedAt = new Date();
-    }
-    /**
-     * Get active workflow
-     */
-    getActiveWorkflow() {
-        return this.activeWorkflow;
-    }
-    /**
-     * Set context variable
-     */
-    setVariable(key, value) {
-        this.variables[key] = value;
-        this.updatedAt = new Date();
-    }
-    /**
-     * Get context variable
-     */
-    getVariable(key) {
-        return this.variables[key];
-    }
-    /**
-     * Get all variables
-     */
-    getVariables() {
-        return { ...this.variables };
-    }
-    /**
-     * Delete context variable
-     */
-    deleteVariable(key) {
-        if (key in this.variables) {
-            delete this.variables[key];
-            this.updatedAt = new Date();
-            return true;
-        }
-        return false;
-    }
-    /**
-     * Clear all variables
-     */
-    clearVariables() {
-        this.variables = {};
-        this.updatedAt = new Date();
-    }
-    /**
-     * Get context snapshot for save/load
-     */
-    getSnapshot() {
-        return {
-            conversationId: this.conversationId,
-            userId: this.userId,
-            messages: this.getMessages(),
-            activeAgent: this.activeAgent,
-            activeWorkflow: this.activeWorkflow,
-            variables: this.getVariables(),
-            createdAt: this.createdAt,
-            updatedAt: this.updatedAt
-        };
-    }
-    /**
-     * Restore from snapshot
-     */
-    restoreFromSnapshot(snapshot) {
-        this.conversationId = snapshot.conversationId;
-        this.userId = snapshot.userId;
-        this.messages = [...snapshot.messages];
-        this.activeAgent = snapshot.activeAgent;
-        this.activeWorkflow = snapshot.activeWorkflow;
-        this.variables = { ...snapshot.variables };
-        this.createdAt = new Date(snapshot.createdAt);
-        this.updatedAt = new Date(snapshot.updatedAt);
-    }
-    /**
-     * Clear conversation (reset to initial state)
-     */
-    clear() {
-        this.messages = [];
-        this.activeAgent = undefined;
-        this.activeWorkflow = undefined;
-        this.variables = {};
-        this.conversationId = randomUUID();
-        this.createdAt = new Date();
-        this.updatedAt = new Date();
-    }
-    /**
-     * Get conversation summary
-     */
-    getSummary() {
-        return {
-            conversationId: this.conversationId,
-            messageCount: this.messages.length,
-            activeAgent: this.activeAgent,
-            activeWorkflow: this.activeWorkflow,
-            variableCount: Object.keys(this.variables).length,
-            createdAt: this.createdAt,
-            updatedAt: this.updatedAt
-        };
-    }
-    // ============================================
-    // SQLite Persistence (Day 4 Implementation)
-    // ============================================
-    /**
-     * Save context to SQLite
-     * Persists conversation metadata and all messages to database
-     */
-    async saveToDB() {
-        try {
-            const { ConversationDAO } = await import('../../database/dao/ConversationDAO.js');
-            const { MessageDAO } = await import('../../database/dao/MessageDAO.js');
-            const conversationDAO = new ConversationDAO(this.db);
-            const messageDAO = new MessageDAO(this.db);
-            // Check if conversation exists
-            const existing = conversationDAO.getById(this.conversationId);
-            if (existing) {
-                // Update existing conversation
-                conversationDAO.update({
-                    id: this.conversationId,
-                    metadata: {
-                        activeAgent: this.activeAgent,
-                        activeWorkflow: this.activeWorkflow,
-                        variables: this.variables
-                    }
-                });
-            }
-            else {
-                // Create new conversation
-                conversationDAO.create({
-                    agentId: this.activeAgent || 'system', // Required field, use system if no active agent
-                    userId: this.userId,
-                    title: `Conversation ${this.conversationId.slice(0, 8)}`,
-                    metadata: {
-                        activeAgent: this.activeAgent,
-                        activeWorkflow: this.activeWorkflow,
-                        variables: this.variables
-                    }
-                });
-            }
-            // Save all messages
-            for (const message of this.messages) {
-                // Check if message exists
-                const existingMessage = messageDAO.getById(message.id);
-                if (!existingMessage) {
-                    // Create new message
-                    messageDAO.create({
-                        conversationId: this.conversationId,
-                        role: message.role,
-                        content: message.content,
-                        tokens: message.tokensUsed,
-                        metadata: message.metadata
-                    });
-                }
-                // Note: We don't update existing messages as they are immutable
-            }
-        }
-        catch (error) {
-            console.error('[ConversationContext] Failed to save to DB:', error.message);
-            // Don't throw - allow REPL to continue even if save fails
-        }
-    }
-    /**
-     * Load context from SQLite
-     * Reconstructs ConversationContext from database records
-     */
-    static async loadFromDB(db, conversationId) {
-        try {
-            const { ConversationDAO } = await import('../../database/dao/ConversationDAO.js');
-            const { MessageDAO } = await import('../../database/dao/MessageDAO.js');
-            const conversationDAO = new ConversationDAO(db);
-            const messageDAO = new MessageDAO(db);
-            // Load conversation record
-            const conversation = conversationDAO.getById(conversationId);
-            if (!conversation) {
-                return null;
-            }
-            // Load all messages for this conversation
-            const dbMessages = messageDAO.getByConversation(conversationId);
-            // Create new ConversationContext
-            const context = new ConversationContext(db, conversation.userId || 'unknown', conversationId);
-            // Restore state from snapshot
-            const messages = dbMessages.map((m) => ({
-                id: m.id,
-                conversationId: m.conversationId,
-                role: m.role,
-                content: m.content,
-                timestamp: new Date(m.createdAt * 1000), // Convert UNIX seconds to Date
-                tokensUsed: m.tokens,
-                metadata: m.metadata || {}
-            }));
-            const snapshot = {
-                conversationId: conversation.id,
-                userId: conversation.userId || 'unknown',
-                messages,
-                activeAgent: conversation.metadata?.activeAgent,
-                activeWorkflow: conversation.metadata?.activeWorkflow,
-                variables: conversation.metadata?.variables || {},
-                createdAt: new Date(conversation.createdAt * 1000), // Convert UNIX seconds to Date
-                updatedAt: new Date(conversation.updatedAt * 1000)
-            };
-            context.restoreFromSnapshot(snapshot);
-            return context;
-        }
-        catch (error) {
-            console.error('[ConversationContext] Failed to load from DB:', error.message);
-            return null;
-        }
-    }
-    /**
-     * Get conversation metadata
-     */
-    getMetadata() {
-        return {
-            conversationId: this.conversationId,
-            userId: this.userId,
-            createdAt: this.createdAt,
-            updatedAt: this.updatedAt
-        };
-    }
-}

package/dist/scripts/src/cli/interactive/SlashCommandRegistry.js

@@ -1,110 +0,0 @@
-/**
- * AutomatosX v8.0.0 - Slash Command Registry
- *
- * Registry for managing and executing slash commands in Interactive CLI
- */
-/**
- * Slash Command Registry
- *
- * Manages registration and execution of slash commands
- */
-export class SlashCommandRegistry {
-    commands = new Map();
-    aliases = new Map();
-    /**
-     * Register a slash command
-     *
-     * @throws Error if command name or alias conflicts with existing command
-     */
-    register(command) {
-        // Check for name conflict
-        if (this.commands.has(command.name)) {
-            throw new Error(`Command '${command.name}' is already registered`);
-        }
-        // Check for alias conflicts
-        if (command.aliases) {
-            for (const alias of command.aliases) {
-                if (this.aliases.has(alias)) {
-                    throw new Error(`Alias '${alias}' is already registered`);
-                }
-            }
-        }
-        // Register command
-        this.commands.set(command.name, command);
-        // Register aliases
-        if (command.aliases) {
-            for (const alias of command.aliases) {
-                this.aliases.set(alias, command.name);
-            }
-        }
-    }
-    /**
-     * Get a command by name or alias
-     */
-    get(nameOrAlias) {
-        // Try direct name lookup
-        let command = this.commands.get(nameOrAlias);
-        // Try alias lookup
-        if (!command) {
-            const commandName = this.aliases.get(nameOrAlias);
-            if (commandName) {
-                command = this.commands.get(commandName);
-            }
-        }
-        return command;
-    }
-    /**
-     * List all registered commands
-     */
-    list() {
-        return Array.from(this.commands.values());
-    }
-    /**
-     * Execute a slash command
-     *
-     * @param input - Raw input string (e.g., "/help" or "/agent security")
-     * @param context - Command execution context
-     */
-    async execute(input, context) {
-        // Parse command and arguments
-        const { commandName, args } = this.parseInput(input);
-        // Get command
-        const command = this.get(commandName);
-        if (!command) {
-            throw new Error(`Unknown command: /${commandName}`);
-        }
-        // Execute command
-        await command.execute(args, context);
-    }
-    /**
-     * Parse slash command input
-     */
-    parseInput(input) {
-        // Remove leading slash
-        const trimmed = input.startsWith('/') ? input.slice(1) : input;
-        // Split by whitespace
-        const parts = trimmed.split(/\s+/).filter(p => p.length > 0);
-        const commandName = parts[0] || '';
-        const args = parts.slice(1);
-        return { commandName, args };
-    }
-    /**
-     * Check if a command exists
-     */
-    has(nameOrAlias) {
-        return this.get(nameOrAlias) !== undefined;
-    }
-    /**
-     * Get command count
-     */
-    count() {
-        return this.commands.size;
-    }
-    /**
-     * Clear all commands (useful for testing)
-     */
-    clear() {
-        this.commands.clear();
-        this.aliases.clear();
-    }
-}

package/dist/scripts/src/cli/interactive/types.js

@@ -1,6 +0,0 @@
-/**
- * AutomatosX v8.0.0 - Interactive CLI Types
- *
- * Shared type definitions for Interactive CLI Mode
- */
-export {};