protoagent 0.0.5 → 0.1.0

package/dist/config/manager.js

@@ -1,117 +0,0 @@
-/**
- * Configuration manager for ProtoAgent
- */
-import fs from 'fs/promises';
-import path from 'path';
-import os from 'os';
-import { geminiProvider, openaiProvider, cerebrasProvider } from './providers.js';
-/**
- * Get the config directory path
- */
-function getConfigDir() {
-    const homeDir = os.homedir();
-    // Use XDG Base Directory specification on Unix-like systems
-    if (process.platform === 'win32') {
-        return path.join(homeDir, 'AppData', 'Local', 'protoagent');
-    }
-    else {
-        return path.join(homeDir, '.local', 'share', 'protoagent');
-    }
-}
-/**
- * Get the config file path
- */
-function getConfigPath() {
-    return path.join(getConfigDir(), 'config.json');
-}
-/**
- * Ensure config directory exists
- */
-async function ensureConfigDir() {
-    const configDir = getConfigDir();
-    try {
-        await fs.access(configDir);
-    }
-    catch {
-        await fs.mkdir(configDir, { recursive: true });
-    }
-}
-/**
- * Check if configuration exists
- */
-export async function hasConfig() {
-    try {
-        await fs.access(getConfigPath());
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-/**
- * Load user configuration
- */
-export async function loadConfig() {
-    try {
-        const configPath = getConfigPath();
-        const configData = await fs.readFile(configPath, 'utf-8');
-        return JSON.parse(configData);
-    }
-    catch (error) {
-        throw new Error(`Failed to load configuration: ${error.message}`);
-    }
-}
-/**
- * Save user configuration
- */
-export async function saveConfig(config) {
-    try {
-        await ensureConfigDir();
-        const configPath = getConfigPath();
-        await fs.writeFile(configPath, JSON.stringify(config, null, 2));
-    }
-    catch (error) {
-        throw new Error(`Failed to save configuration: ${error.message}`);
-    }
-}
-/**
- * Validate configuration
- */
-export function validateConfig(config) {
-    if (!config || typeof config !== 'object') {
-        return false;
-    }
-    const { provider, model, credentials } = config;
-    if (!model || !credentials || !(credentials.OPENAI_API_KEY || credentials.GEMINI_API_KEY || credentials.CEREBRAS_API_KEY)) {
-        return false;
-    }
-    if (provider === 'gemini') {
-        // Check if model is available for Gemini
-        if (!geminiProvider.models.includes(model)) {
-            return false;
-        }
-        // Additional model validation for Gemini can be added here
-        return true;
-    }
-    if (provider === 'openai') {
-        // Check if model is available for OpenAI
-        if (!openaiProvider.models.includes(model)) {
-            return false;
-        }
-        return true;
-    }
-    if (provider === 'cerebras') {
-        // Check if model is available for Cerebras
-        if (!cerebrasProvider.models.includes(model)) {
-            return false;
-        }
-        return true;
-    }
-    return false;
-}
-/**
- * Get configuration directory path for display
- */
-export function getConfigDirectory() {
-    return getConfigDir();
-}

package/dist/config/mcp-commands.js

@@ -1,266 +0,0 @@
-/**
- * MCP management commands for ProtoAgent CLI
- */
-import inquirer from 'inquirer';
-import { MCPManager } from './mcp-manager.js';
-const mcpManager = new MCPManager();
-/**
- * Show current MCP configuration and status
- */
-export async function showMCPStatus() {
-    try {
-        await mcpManager.loadConfig();
-        console.log('\n🔌 MCP Configuration & Status:');
-        console.log('─'.repeat(50));
-        const servers = mcpManager.listServers();
-        const connectionStatus = mcpManager.getConnectionStatus();
-        if (Object.keys(servers).length === 0) {
-            console.log('No MCP servers configured');
-            return;
-        }
-        for (const [name, config] of Object.entries(servers)) {
-            const status = connectionStatus[name];
-            const statusIcon = status === true ? '🟢' : status === false ? '🔴' : '⚪';
-            const typeLabel = config.isBuiltIn ? '(built-in)' : '(custom)';
-            console.log(`${statusIcon} ${name} ${typeLabel}`);
-            console.log(`   Description: ${config.description}`);
-            console.log(`   Command: ${config.command} ${(config.args || []).join(' ')}`);
-            console.log(`   Enabled: ${config.enabled ? 'Yes' : 'No'}`);
-            console.log('');
-        }
-        // Show available tools if connected
-        const tools = await mcpManager.getAllTools();
-        if (tools.length > 0) {
-            console.log('🛠️  Available Tools:');
-            for (const tool of tools) {
-                console.log(`   • ${tool.server}:${tool.name} - ${tool.description || 'No description'}`);
-            }
-        }
-        console.log('─'.repeat(50));
-    }
-    catch (error) {
-        console.error(`❌ Error showing MCP status: ${error.message}`);
-    }
-}
-/**
- * Connect to MCP servers
- */
-export async function connectMCPServers() {
-    try {
-        await mcpManager.loadConfig();
-        await mcpManager.connectToAllServers();
-    }
-    catch (error) {
-        console.error(`❌ Error connecting to MCP servers: ${error.message}`);
-    }
-}
-/**
- * Add a custom MCP server
- */
-export async function addCustomMCPServer() {
-    try {
-        console.log('\n🔧 Add Custom MCP Server');
-        console.log('Configure a new MCP server for ProtoAgent\n');
-        const serverConfig = await inquirer.prompt([
-            {
-                type: 'input',
-                name: 'name',
-                message: 'Server name (unique identifier):',
-                validate: (input) => {
-                    if (!input || input.trim().length === 0) {
-                        return 'Server name is required';
-                    }
-                    if (!/^[a-zA-Z0-9\-_]+$/.test(input.trim())) {
-                        return 'Server name can only contain letters, numbers, hyphens, and underscores';
-                    }
-                    return true;
-                }
-            },
-            {
-                type: 'input',
-                name: 'description',
-                message: 'Description:',
-                validate: (input) => input.trim().length > 0 ? true : 'Description is required'
-            },
-            {
-                type: 'input',
-                name: 'command',
-                message: 'Command to run the server:',
-                validate: (input) => input.trim().length > 0 ? true : 'Command is required'
-            },
-            {
-                type: 'input',
-                name: 'args',
-                message: 'Arguments (space-separated, optional):',
-                default: ''
-            },
-            {
-                type: 'confirm',
-                name: 'enabled',
-                message: 'Enable this server?',
-                default: true
-            }
-        ]);
-        const newServer = {
-            name: serverConfig.name.trim(),
-            description: serverConfig.description.trim(),
-            command: serverConfig.command.trim(),
-            args: serverConfig.args.trim() ? serverConfig.args.trim().split(' ') : [],
-            enabled: serverConfig.enabled,
-            isBuiltIn: false
-        };
-        await mcpManager.loadConfig();
-        await mcpManager.addCustomServer(newServer);
-        console.log(`\n✅ Custom MCP server '${newServer.name}' added successfully!`);
-        if (newServer.enabled) {
-            const { connectNow } = await inquirer.prompt([
-                {
-                    type: 'confirm',
-                    name: 'connectNow',
-                    message: 'Connect to this server now?',
-                    default: true
-                }
-            ]);
-            if (connectNow) {
-                const connection = await mcpManager.connectToServer(newServer.name);
-                if (connection) {
-                    console.log(`🎉 Successfully connected to ${newServer.name}!`);
-                }
-            }
-        }
-    }
-    catch (error) {
-        console.error(`❌ Error adding custom MCP server: ${error.message}`);
-    }
-}
-/**
- * Remove a custom MCP server
- */
-export async function removeCustomMCPServer() {
-    try {
-        await mcpManager.loadConfig();
-        const servers = mcpManager.listServers();
-        const customServers = Object.entries(servers).filter(([_, config]) => !config.isBuiltIn);
-        if (customServers.length === 0) {
-            console.log('📭 No custom MCP servers configured');
-            return;
-        }
-        const { serverToRemove } = await inquirer.prompt([
-            {
-                type: 'list',
-                name: 'serverToRemove',
-                message: 'Select server to remove:',
-                choices: customServers.map(([name, config]) => ({
-                    name: `${name} - ${config.description}`,
-                    value: name
-                }))
-            }
-        ]);
-        const { confirm } = await inquirer.prompt([
-            {
-                type: 'confirm',
-                name: 'confirm',
-                message: `Are you sure you want to remove '${serverToRemove}'?`,
-                default: false
-            }
-        ]);
-        if (confirm) {
-            await mcpManager.removeCustomServer(serverToRemove);
-            console.log(`✅ Custom MCP server '${serverToRemove}' removed successfully!`);
-        }
-        else {
-            console.log('Operation cancelled.');
-        }
-    }
-    catch (error) {
-        console.error(`❌ Error removing custom MCP server: ${error.message}`);
-    }
-}
-/**
- * Toggle MCP server enabled/disabled status
- */
-export async function toggleMCPServer() {
-    try {
-        await mcpManager.loadConfig();
-        const servers = mcpManager.listServers();
-        if (Object.keys(servers).length === 0) {
-            console.log('📭 No MCP servers configured');
-            return;
-        }
-        const { serverToToggle } = await inquirer.prompt([
-            {
-                type: 'list',
-                name: 'serverToToggle',
-                message: 'Select server to enable/disable:',
-                choices: Object.entries(servers).map(([name, config]) => ({
-                    name: `${name} - ${config.enabled ? '🟢 Enabled' : '🔴 Disabled'} - ${config.description}`,
-                    value: name
-                }))
-            }
-        ]);
-        const currentConfig = servers[serverToToggle];
-        const newStatus = !currentConfig.enabled;
-        // Update the configuration
-        await mcpManager.loadConfig();
-        const updatedServers = mcpManager.listServers();
-        updatedServers[serverToToggle].enabled = newStatus;
-        // Save the updated configuration
-        const updatedConfig = {
-            servers: updatedServers,
-            globalTimeout: 30000,
-            maxConcurrentConnections: 5,
-            retryAttempts: 3
-        };
-        const mcpManagerForSave = new MCPManager(updatedConfig);
-        await mcpManagerForSave.saveConfig();
-        console.log(`✅ Server '${serverToToggle}' ${newStatus ? 'enabled' : 'disabled'}`);
-    }
-    catch (error) {
-        console.error(`❌ Error toggling MCP server: ${error.message}`);
-    }
-}
-/**
- * Test connection to a specific MCP server
- */
-export async function testMCPServer() {
-    try {
-        await mcpManager.loadConfig();
-        const servers = mcpManager.listServers();
-        const enabledServers = Object.entries(servers).filter(([_, config]) => config.enabled);
-        if (enabledServers.length === 0) {
-            console.log('📭 No enabled MCP servers to test');
-            return;
-        }
-        const { serverToTest } = await inquirer.prompt([
-            {
-                type: 'list',
-                name: 'serverToTest',
-                message: 'Select server to test:',
-                choices: enabledServers.map(([name, config]) => ({
-                    name: `${name} - ${config.description}`,
-                    value: name
-                }))
-            }
-        ]);
-        console.log(`🧪 Testing connection to ${serverToTest}...`);
-        const connection = await mcpManager.connectToServer(serverToTest);
-        if (connection) {
-            console.log(`✅ Successfully connected to ${serverToTest}!`);
-            console.log(`🛠️  Available tools: ${connection.capabilities.join(', ')}`);
-            // Clean up test connection
-            await mcpManager.disconnectServer(serverToTest);
-        }
-        else {
-            console.log(`❌ Failed to connect to ${serverToTest}`);
-        }
-    }
-    catch (error) {
-        console.error(`❌ Error testing MCP server: ${error.message}`);
-    }
-}
-/**
- * Get the MCP manager instance (for use in main application)
- */
-export function getMCPManager() {
-    return mcpManager;
-}

package/dist/config/mcp-manager.js

@@ -1,240 +0,0 @@
-/**
- * MCP (Model Context Protocol) Manager
- * Handles connections to MCP servers and tool execution
- */
-import { Client } from '@modelcontextprotocol/sdk/client/index.js';
-import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
-import { DEFAULT_MCP_CONFIG } from './mcp-types.js';
-import path from 'path';
-import fs from 'fs/promises';
-import { getConfigDirectory } from './manager.js';
-export class MCPManager {
-    constructor(config) {
-        this.connections = new Map();
-        this.processes = new Map();
-        this.config = config || DEFAULT_MCP_CONFIG;
-    }
-    /**
-     * Load MCP configuration from file
-     */
-    async loadConfig() {
-        try {
-            const configPath = path.join(getConfigDirectory(), 'mcp-config.json');
-            const configData = await fs.readFile(configPath, 'utf-8');
-            this.config = { ...DEFAULT_MCP_CONFIG, ...JSON.parse(configData) };
-        }
-        catch (error) {
-            // If no config file exists, use defaults
-            console.log('📡 Using default MCP configuration');
-            this.config = DEFAULT_MCP_CONFIG;
-        }
-    }
-    /**
-     * Save MCP configuration to file
-     */
-    async saveConfig() {
-        try {
-            const configPath = path.join(getConfigDirectory(), 'mcp-config.json');
-            await fs.writeFile(configPath, JSON.stringify(this.config, null, 2));
-        }
-        catch (error) {
-            console.error('❌ Failed to save MCP configuration:', error);
-        }
-    }
-    /**
-     * Connect to a specific MCP server
-     */
-    async connectToServer(serverName) {
-        const serverConfig = this.config.servers[serverName];
-        if (!serverConfig || !serverConfig.enabled) {
-            console.log(`⚠️  Server ${serverName} is not configured or disabled`);
-            return null;
-        }
-        try {
-            console.log(`🔌 Connecting to MCP server: ${serverName}`);
-            // Create transport for stdio communication
-            const transport = new StdioClientTransport({
-                command: serverConfig.command,
-                args: serverConfig.args || [],
-                env: {
-                    ...Object.fromEntries(Object.entries(process.env).filter(([_, v]) => v !== undefined)),
-                    ...serverConfig.env
-                }
-            });
-            // Create MCP client
-            const client = new Client({
-                name: 'protoagent',
-                version: '1.0.0'
-            }, {
-                capabilities: {
-                    tools: {}
-                }
-            });
-            // Connect to the server
-            await client.connect(transport);
-            // Get server capabilities
-            const serverCapabilities = await client.listTools();
-            const capabilities = serverCapabilities.tools.map(tool => tool.name);
-            const connection = {
-                name: serverName,
-                client,
-                capabilities,
-                connected: true
-            };
-            this.connections.set(serverName, connection);
-            console.log(`✅ Connected to ${serverName} with ${capabilities.length} tools`);
-            return connection;
-        }
-        catch (error) {
-            console.error(`❌ Failed to connect to MCP server ${serverName}:`, error);
-            return null;
-        }
-    }
-    /**
-     * Connect to all enabled MCP servers
-     */
-    async connectToAllServers() {
-        console.log('🚀 Initializing MCP connections...');
-        const enabledServers = Object.keys(this.config.servers).filter(name => this.config.servers[name].enabled);
-        if (enabledServers.length === 0) {
-            console.log('ℹ️  No MCP servers enabled');
-            return;
-        }
-        const connectionPromises = enabledServers.map(serverName => this.connectToServer(serverName).catch(error => {
-            console.error(`Failed to connect to ${serverName}:`, error);
-            return null;
-        }));
-        const results = await Promise.all(connectionPromises);
-        const successfulConnections = results.filter(conn => conn !== null);
-        console.log(`📡 MCP Status: ${successfulConnections.length}/${enabledServers.length} servers connected`);
-    }
-    /**
-     * Get all available tools from connected servers
-     */
-    async getAllTools() {
-        const allTools = [];
-        for (const [serverName, connection] of this.connections) {
-            if (!connection.connected)
-                continue;
-            try {
-                const tools = await connection.client.listTools();
-                for (const tool of tools.tools) {
-                    allTools.push({
-                        server: serverName,
-                        name: tool.name,
-                        description: tool.description,
-                        schema: tool.inputSchema
-                    });
-                }
-            }
-            catch (error) {
-                console.error(`❌ Failed to get tools from ${serverName}:`, error);
-            }
-        }
-        return allTools;
-    }
-    /**
-     * Execute a tool on a specific MCP server
-     */
-    async callTool(serverName, toolName, args) {
-        const connection = this.connections.get(serverName);
-        if (!connection || !connection.connected) {
-            throw new Error(`Server ${serverName} is not connected`);
-        }
-        try {
-            console.log(`🛠️  Calling ${serverName}:${toolName}`);
-            const result = await connection.client.callTool({
-                name: toolName,
-                arguments: args
-            });
-            return result;
-        }
-        catch (error) {
-            console.error(`❌ Tool execution failed ${serverName}:${toolName}:`, error);
-            throw error;
-        }
-    }
-    /**
-     * Find which server has a specific tool
-     */
-    findToolServer(toolName) {
-        for (const [serverName, connection] of this.connections) {
-            if (connection.capabilities.includes(toolName)) {
-                return serverName;
-            }
-        }
-        return null;
-    }
-    /**
-     * Get connection status
-     */
-    getConnectionStatus() {
-        const status = {};
-        for (const [serverName, connection] of this.connections) {
-            status[serverName] = connection.connected;
-        }
-        return status;
-    }
-    /**
-     * Add a custom MCP server configuration
-     */
-    async addCustomServer(config) {
-        this.config.servers[config.name] = config;
-        await this.saveConfig();
-        console.log(`✅ Added custom MCP server: ${config.name}`);
-    }
-    /**
-     * Remove a custom MCP server
-     */
-    async removeCustomServer(serverName) {
-        const serverConfig = this.config.servers[serverName];
-        if (serverConfig?.isBuiltIn) {
-            throw new Error('Cannot remove built-in MCP servers');
-        }
-        // Disconnect if connected
-        const connection = this.connections.get(serverName);
-        if (connection) {
-            await this.disconnectServer(serverName);
-        }
-        delete this.config.servers[serverName];
-        await this.saveConfig();
-        console.log(`✅ Removed custom MCP server: ${serverName}`);
-    }
-    /**
-     * Disconnect from a specific server
-     */
-    async disconnectServer(serverName) {
-        const connection = this.connections.get(serverName);
-        if (connection) {
-            try {
-                await connection.client.close();
-                connection.connected = false;
-                this.connections.delete(serverName);
-                console.log(`🔌 Disconnected from ${serverName}`);
-            }
-            catch (error) {
-                console.error(`❌ Error disconnecting from ${serverName}:`, error);
-            }
-        }
-    }
-    /**
-     * Disconnect from all servers
-     */
-    async disconnectAll() {
-        console.log('🔌 Disconnecting from all MCP servers...');
-        const disconnectPromises = Array.from(this.connections.keys()).map(serverName => this.disconnectServer(serverName));
-        await Promise.all(disconnectPromises);
-    }
-    /**
-     * Get server configuration
-     */
-    getServerConfig(serverName) {
-        return this.config.servers[serverName] || null;
-    }
-    /**
-     * List all configured servers
-     */
-    listServers() {
-        return { ...this.config.servers };
-    }
-}

package/dist/config/mcp-types.js

@@ -1,28 +0,0 @@
-/**
- * MCP (Model Context Protocol) configuration types
- */
-// Built-in server configurations
-export const BUILTIN_MCP_SERVERS = {
-    filesystem: {
-        name: 'filesystem',
-        description: 'File system operations via MCP',
-        command: 'npx',
-        args: ['@modelcontextprotocol/server-filesystem'],
-        enabled: true,
-        isBuiltIn: true
-    },
-    'sequential-thinking': {
-        name: 'sequential-thinking',
-        description: 'Sequential thinking and reasoning tools',
-        command: 'npx',
-        args: ['@modelcontextprotocol/server-sequential-thinking'],
-        enabled: true,
-        isBuiltIn: true
-    }
-};
-export const DEFAULT_MCP_CONFIG = {
-    servers: { ...BUILTIN_MCP_SERVERS },
-    globalTimeout: 30000, // 30 seconds
-    maxConcurrentConnections: 5,
-    retryAttempts: 3
-};