jiva-core 0.1.0

package/src/interfaces/cli/setup-wizard.ts

@@ -0,0 +1,355 @@
+/**
+ * Setup Wizard for first-time configuration
+ */
+
+import inquirer from 'inquirer';
+import { configManager } from '../../core/config.js';
+import { logger } from '../../utils/logger.js';
+import chalk from 'chalk';
+
+export async function runSetupWizard(): Promise<void> {
+  console.log(chalk.bold.cyan('\n🤖 Welcome to Jiva Setup Wizard\n'));
+  console.log('This wizard will help you configure Jiva for the first time.\n');
+
+  // Reasoning Model Configuration
+  console.log(chalk.bold('Reasoning Model Configuration (gpt-oss-120b)'));
+  console.log(chalk.gray('This model will be used for reasoning and tool calling.\n'));
+
+  const reasoningAnswers = await inquirer.prompt([
+    {
+      type: 'input',
+      name: 'endpoint',
+      message: 'API Endpoint URL:',
+      default: 'https://cloud.olakrutrim.com/v1/chat/completions',
+      validate: (input: string) => {
+        try {
+          new URL(input);
+          return true;
+        } catch {
+          return 'Please enter a valid URL';
+        }
+      },
+    },
+    {
+      type: 'password',
+      name: 'apiKey',
+      message: 'API Key:',
+      validate: (input: string) => input.length > 0 || 'API key is required',
+    },
+    {
+      type: 'input',
+      name: 'model',
+      message: 'Model name:',
+      default: 'gpt-oss-120b',
+    },
+  ]);
+
+  configManager.setReasoningModel({
+    name: 'reasoning',
+    endpoint: reasoningAnswers.endpoint,
+    apiKey: reasoningAnswers.apiKey,
+    type: 'reasoning',
+    defaultModel: reasoningAnswers.model,
+  });
+
+  logger.success('Reasoning model configured');
+
+  // Multimodal Model Configuration (Optional)
+  console.log(chalk.bold('\nMultimodal Model Configuration (Optional)'));
+  console.log(chalk.gray('This model will be used for understanding images.\n'));
+
+  const { configureMultimodal } = await inquirer.prompt([
+    {
+      type: 'confirm',
+      name: 'configureMultimodal',
+      message: 'Would you like to configure a multimodal model?',
+      default: true,
+    },
+  ]);
+
+  if (configureMultimodal) {
+    const multimodalAnswers = await inquirer.prompt([
+      {
+        type: 'input',
+        name: 'endpoint',
+        message: 'Multimodal API Endpoint URL:',
+        default: 'https://cloud.olakrutrim.com/v1/chat/completions',
+        validate: (input: string) => {
+          try {
+            new URL(input);
+            return true;
+          } catch {
+            return 'Please enter a valid URL';
+          }
+        },
+      },
+      {
+        type: 'password',
+        name: 'apiKey',
+        message: 'Multimodal API Key:',
+        default: reasoningAnswers.apiKey,
+        validate: (input: string) => input.length > 0 || 'API key is required',
+      },
+      {
+        type: 'input',
+        name: 'model',
+        message: 'Multimodal model name:',
+        default: 'Llama-4-Maverick-17B-128E-Instruct',
+      },
+    ]);
+
+    configManager.setMultimodalModel({
+      name: 'multimodal',
+      endpoint: multimodalAnswers.endpoint,
+      apiKey: multimodalAnswers.apiKey,
+      type: 'multimodal',
+      defaultModel: multimodalAnswers.model,
+    });
+
+    logger.success('Multimodal model configured');
+  }
+
+  // MCP Servers Configuration
+  console.log(chalk.bold('\nMCP Servers Configuration'));
+  console.log(chalk.gray('Setting up default MCP servers (filesystem, commands)...\n'));
+
+  configManager.initializeDefaultServers();
+  logger.success('Default MCP servers configured');
+
+  // Debug Mode
+  const { enableDebug } = await inquirer.prompt([
+    {
+      type: 'confirm',
+      name: 'enableDebug',
+      message: 'Enable debug mode?',
+      default: false,
+    },
+  ]);
+
+  configManager.setDebug(enableDebug);
+
+  console.log(chalk.bold.green('\n✓ Setup complete!\n'));
+  console.log(`Configuration saved to: ${chalk.cyan(configManager.getConfigPath())}`);
+  console.log('\nYou can now run:', chalk.cyan('jiva'));
+  console.log('');
+}
+
+/**
+ * Update existing configuration interactively
+ */
+export async function updateConfiguration(): Promise<void> {
+  console.log(chalk.bold.cyan('\n🔧 Update Jiva Configuration\n'));
+
+  const { choice } = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'choice',
+      message: 'What would you like to update?',
+      choices: [
+        { name: 'Reasoning Model', value: 'reasoning' },
+        { name: 'Multimodal Model', value: 'multimodal' },
+        { name: 'MCP Servers', value: 'mcp' },
+        { name: 'Debug Mode', value: 'debug' },
+        { name: 'View Configuration', value: 'view' },
+        { name: 'Reset All', value: 'reset' },
+        { name: 'Cancel', value: 'cancel' },
+      ],
+    },
+  ]);
+
+  switch (choice) {
+    case 'reasoning':
+      await updateReasoningModel();
+      break;
+    case 'multimodal':
+      await updateMultimodalModel();
+      break;
+    case 'mcp':
+      await manageMCPServers();
+      break;
+    case 'debug':
+      await toggleDebugMode();
+      break;
+    case 'view':
+      viewConfiguration();
+      break;
+    case 'reset':
+      await resetConfiguration();
+      break;
+    case 'cancel':
+      console.log('Cancelled');
+      break;
+  }
+}
+
+async function updateReasoningModel() {
+  const current = configManager.getReasoningModel();
+
+  const answers = await inquirer.prompt([
+    {
+      type: 'input',
+      name: 'endpoint',
+      message: 'API Endpoint URL:',
+      default: current?.endpoint,
+    },
+    {
+      type: 'password',
+      name: 'apiKey',
+      message: 'API Key:',
+      default: current?.apiKey,
+    },
+    {
+      type: 'input',
+      name: 'model',
+      message: 'Model name:',
+      default: current?.defaultModel,
+    },
+  ]);
+
+  configManager.setReasoningModel({
+    name: 'reasoning',
+    endpoint: answers.endpoint,
+    apiKey: answers.apiKey,
+    type: 'reasoning',
+    defaultModel: answers.model,
+  });
+
+  logger.success('Reasoning model updated');
+}
+
+async function updateMultimodalModel() {
+  const current = configManager.getMultimodalModel();
+
+  const answers = await inquirer.prompt([
+    {
+      type: 'input',
+      name: 'endpoint',
+      message: 'Multimodal API Endpoint URL:',
+      default: current?.endpoint || 'https://cloud.olakrutrim.com/v1/chat/completions',
+    },
+    {
+      type: 'password',
+      name: 'apiKey',
+      message: 'Multimodal API Key:',
+      default: current?.apiKey,
+    },
+    {
+      type: 'input',
+      name: 'model',
+      message: 'Multimodal model name:',
+      default: current?.defaultModel || 'Llama-4-Maverick-17B-128E-Instruct',
+    },
+  ]);
+
+  configManager.setMultimodalModel({
+    name: 'multimodal',
+    endpoint: answers.endpoint,
+    apiKey: answers.apiKey,
+    type: 'multimodal',
+    defaultModel: answers.model,
+  });
+
+  logger.success('Multimodal model updated');
+}
+
+async function manageMCPServers() {
+  const servers = configManager.getMCPServers();
+  const serverNames = Object.keys(servers);
+
+  const { action } = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'action',
+      message: 'MCP Server Action:',
+      choices: [
+        { name: 'List Servers', value: 'list' },
+        { name: 'Add Server', value: 'add' },
+        { name: 'Remove Server', value: 'remove' },
+        { name: 'Back', value: 'back' },
+      ],
+    },
+  ]);
+
+  if (action === 'list') {
+    console.log('\nConfigured MCP Servers:');
+    Object.entries(servers).forEach(([name, config]) => {
+      console.log(`  ${config.enabled ? '✓' : '✗'} ${name}: ${config.command} ${config.args?.join(' ') || ''}`);
+    });
+  } else if (action === 'add') {
+    const answers = await inquirer.prompt([
+      {
+        type: 'input',
+        name: 'name',
+        message: 'Server name:',
+      },
+      {
+        type: 'input',
+        name: 'command',
+        message: 'Command:',
+      },
+      {
+        type: 'input',
+        name: 'args',
+        message: 'Arguments (space-separated):',
+      },
+    ]);
+
+    configManager.addMCPServer(answers.name, {
+      command: answers.command,
+      args: answers.args ? answers.args.split(' ') : [],
+      enabled: true,
+    });
+
+    logger.success(`MCP server '${answers.name}' added`);
+  } else if (action === 'remove' && serverNames.length > 0) {
+    const { serverName } = await inquirer.prompt([
+      {
+        type: 'list',
+        name: 'serverName',
+        message: 'Select server to remove:',
+        choices: serverNames,
+      },
+    ]);
+
+    configManager.removeMCPServer(serverName);
+    logger.success(`MCP server '${serverName}' removed`);
+  }
+}
+
+async function toggleDebugMode() {
+  const current = configManager.isDebug();
+
+  const { enabled } = await inquirer.prompt([
+    {
+      type: 'confirm',
+      name: 'enabled',
+      message: 'Enable debug mode?',
+      default: current,
+    },
+  ]);
+
+  configManager.setDebug(enabled);
+  logger.success(`Debug mode ${enabled ? 'enabled' : 'disabled'}`);
+}
+
+function viewConfiguration() {
+  const config = configManager.getConfig();
+  console.log('\nCurrent Configuration:');
+  console.log(JSON.stringify(config, null, 2));
+}
+
+async function resetConfiguration() {
+  const { confirm } = await inquirer.prompt([
+    {
+      type: 'confirm',
+      name: 'confirm',
+      message: chalk.red('Are you sure you want to reset all configuration?'),
+      default: false,
+    },
+  ]);
+
+  if (confirm) {
+    configManager.reset();
+    logger.success('Configuration reset');
+  }
+}

package/src/mcp/client.ts

@@ -0,0 +1,231 @@
+/**
+ * MCP Client Implementation
+ *
+ * Manages connections to MCP servers and provides tool discovery/execution.
+ */
+
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
+import {
+  CallToolResultSchema,
+  ListToolsResultSchema,
+} from '@modelcontextprotocol/sdk/types.js';
+import { MCPError } from '../utils/errors.js';
+import { logger } from '../utils/logger.js';
+import { Tool } from '../models/base.js';
+
+export interface MCPServerConnection {
+  name: string;
+  client: Client;
+  transport: StdioClientTransport;
+  tools: Tool[];
+}
+
+export class MCPClient {
+  private connections: Map<string, MCPServerConnection> = new Map();
+
+  /**
+   * Connect to an MCP server
+   */
+  async connect(
+    name: string,
+    command: string,
+    args: string[] = [],
+    env?: Record<string, string>
+  ): Promise<void> {
+    try {
+      logger.info(`Connecting to MCP server: ${name}`);
+      logger.debug(`Command: ${command}`);
+      logger.debug(`Args: ${JSON.stringify(args)}`);
+      logger.debug(`Args length: ${args.length}, values: ${args.map((a, i) => `[${i}]="${a}"`).join(', ')}`);
+
+      const transport = new StdioClientTransport({
+        command,
+        args,
+        env: env || {},
+      });
+
+      const client = new Client(
+        {
+          name: 'jiva-agent',
+          version: '0.1.0',
+        },
+        {
+          capabilities: {},
+        }
+      );
+
+      await client.connect(transport);
+
+      // List available tools
+      const toolsResult = await client.listTools();
+      const tools = this.convertMCPTools(toolsResult.tools || []);
+
+      this.connections.set(name, {
+        name,
+        client,
+        transport,
+        tools,
+      });
+
+      logger.success(`Connected to MCP server: ${name} (${tools.length} tools available)`);
+    } catch (error) {
+      throw new MCPError(
+        `Failed to connect to MCP server '${name}': ${error instanceof Error ? error.message : String(error)}`,
+        name
+      );
+    }
+  }
+
+  /**
+   * Disconnect from an MCP server
+   */
+  async disconnect(name: string): Promise<void> {
+    const connection = this.connections.get(name);
+    if (!connection) {
+      logger.warn(`MCP server '${name}' not connected`);
+      return;
+    }
+
+    try {
+      await connection.client.close();
+      this.connections.delete(name);
+      logger.info(`Disconnected from MCP server: ${name}`);
+    } catch (error) {
+      logger.error(`Error disconnecting from MCP server '${name}'`, error);
+    }
+  }
+
+  /**
+   * Disconnect from all MCP servers
+   */
+  async disconnectAll(): Promise<void> {
+    const names = Array.from(this.connections.keys());
+    await Promise.all(names.map(name => this.disconnect(name)));
+  }
+
+  /**
+   * Get all available tools from all connected servers
+   */
+  getAllTools(): Tool[] {
+    const allTools: Tool[] = [];
+
+    for (const connection of this.connections.values()) {
+      // Prefix tool names with server name to avoid conflicts
+      const prefixedTools = connection.tools.map(tool => ({
+        ...tool,
+        name: `${connection.name}__${tool.name}`,
+        description: `[${connection.name}] ${tool.description}`,
+      }));
+      allTools.push(...prefixedTools);
+    }
+
+    return allTools;
+  }
+
+  /**
+   * Get tools from a specific server
+   */
+  getServerTools(serverName: string): Tool[] {
+    const connection = this.connections.get(serverName);
+    if (!connection) {
+      return [];
+    }
+
+    return connection.tools.map(tool => ({
+      ...tool,
+      name: `${serverName}__${tool.name}`,
+      description: `[${serverName}] ${tool.description}`,
+    }));
+  }
+
+  /**
+   * Execute a tool call
+   */
+  async executeTool(toolName: string, args: Record<string, any>): Promise<any> {
+    // Parse server name and actual tool name
+    const [serverName, ...toolParts] = toolName.split('__');
+    const actualToolName = toolParts.join('__');
+
+    const connection = this.connections.get(serverName);
+    if (!connection) {
+      throw new MCPError(`MCP server '${serverName}' not connected`, serverName);
+    }
+
+    try {
+      logger.debug(`Executing tool: ${toolName}`, args);
+
+      const result = await connection.client.callTool({
+        name: actualToolName,
+        arguments: args,
+      });
+
+      logger.debug(`Tool result from ${toolName}:`, result);
+
+      // Extract content from MCP response
+      if (result.content && Array.isArray(result.content)) {
+        const textContent = result.content
+          .filter((c: any) => c.type === 'text')
+          .map((c: any) => c.text)
+          .join('\n');
+        return textContent || result;
+      }
+
+      return result;
+    } catch (error) {
+      throw new MCPError(
+        `Failed to execute tool '${toolName}': ${error instanceof Error ? error.message : String(error)}`,
+        serverName
+      );
+    }
+  }
+
+  /**
+   * Convert MCP tool definitions to our internal Tool format
+   */
+  private convertMCPTools(mcpTools: any[]): Tool[] {
+    return mcpTools.map(tool => ({
+      name: tool.name,
+      description: tool.description || tool.name,
+      parameters: tool.inputSchema || {
+        type: 'object',
+        properties: {},
+      },
+    }));
+  }
+
+  /**
+   * Check if a server is connected
+   */
+  isConnected(serverName: string): boolean {
+    return this.connections.has(serverName);
+  }
+
+  /**
+   * Get list of connected server names
+   */
+  getConnectedServers(): string[] {
+    return Array.from(this.connections.keys());
+  }
+
+  /**
+   * Refresh tools from a specific server
+   */
+  async refreshTools(serverName: string): Promise<void> {
+    const connection = this.connections.get(serverName);
+    if (!connection) {
+      throw new MCPError(`MCP server '${serverName}' not connected`, serverName);
+    }
+
+    try {
+      const toolsResult = await connection.client.listTools();
+      connection.tools = this.convertMCPTools(toolsResult.tools || []);
+      logger.info(`Refreshed tools for MCP server: ${serverName} (${connection.tools.length} tools)`);
+    } catch (error) {
+      throw new MCPError(
+        `Failed to refresh tools for '${serverName}': ${error instanceof Error ? error.message : String(error)}`,
+        serverName
+      );
+    }
+  }
+}