@mcpilotx/intentorch 0.5.0

package/dist/ai/command.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Simplified AI Command Handler
+ * Minimal command interface for AI features
+ */
+import { SimpleAI } from './ai';
+import { SimpleAIConfigManager } from './config';
+/**
+ * Simplified AI command handler
+ */
+export declare class SimpleAICommand {
+    private ai;
+    private configManager;
+    constructor();
+    /**
+     * Load configuration from manager
+     */
+    private loadConfiguration;
+    /**
+     * Handle AI command
+     */
+    handleCommand(action?: string, ...args: string[]): Promise<void>;
+    /**
+     * Handle configure command
+     */
+    private handleConfigure;
+    /**
+     * Handle test command
+     */
+    private handleTest;
+    /**
+     * Handle ask command
+     */
+    private handleAsk;
+    /**
+     * Handle ask result
+     */
+    private handleAskResult;
+    /**
+     * Handle reset command
+     */
+    private handleReset;
+    /**
+     * Show AI status
+     */
+    private showStatus;
+    /**
+     * Show help
+     */
+    private showHelp;
+    /**
+     * Get AI instance (for integration with other modules)
+     */
+    getAIInstance(): SimpleAI;
+    /**
+     * Get config manager instance
+     */
+    getConfigManager(): SimpleAIConfigManager;
+}
+//# sourceMappingURL=command.d.ts.map

package/dist/ai/command.js

@@ -0,0 +1,285 @@
+/**
+ * Simplified AI Command Handler
+ * Minimal command interface for AI features
+ */
+import chalk from 'chalk';
+import { SimpleAI, AIError } from './ai.js';
+import { SimpleAIConfigManager } from './config.js';
+/**
+ * Simplified AI command handler
+ */
+export class SimpleAICommand {
+    ai;
+    configManager;
+    constructor() {
+        this.ai = new SimpleAI();
+        this.configManager = new SimpleAIConfigManager();
+        // Load configuration
+        this.loadConfiguration();
+    }
+    /**
+     * Load configuration from manager
+     */
+    async loadConfiguration() {
+        try {
+            const config = this.configManager.getConfig();
+            if (config.provider !== 'none') {
+                await this.ai.configure(config);
+            }
+        }
+        catch (error) {
+            console.warn(`Failed to load AI configuration: ${error.message}`);
+        }
+    }
+    /**
+     * Handle AI command
+     */
+    async handleCommand(action, ...args) {
+        if (!action) {
+            // Show status when no action provided
+            await this.showStatus();
+            return;
+        }
+        switch (action.toLowerCase()) {
+            case 'configure':
+                await this.handleConfigure(args);
+                break;
+            case 'test':
+                await this.handleTest();
+                break;
+            case 'ask':
+                await this.handleAsk(args.join(' '));
+                break;
+            case 'status':
+                await this.showStatus();
+                break;
+            case 'reset':
+                await this.handleReset();
+                break;
+            case 'help':
+                this.showHelp();
+                break;
+            default:
+                console.log(chalk.red(`Unknown action: ${action}`));
+                this.showHelp();
+        }
+    }
+    /**
+     * Handle configure command
+     */
+    async handleConfigure(args) {
+        try {
+            // Parse configuration from arguments
+            const config = this.configManager.parseFromArgs(args);
+            // Update configuration
+            await this.configManager.updateConfig(config);
+            // Configure AI service
+            if (config.provider !== 'none') {
+                await this.ai.configure(config);
+                console.log(chalk.green(`✅ AI configured with provider: ${config.provider}`));
+                if (config.provider === 'ollama') {
+                    console.log(chalk.blue('💡 Make sure Ollama service is running: ollama serve'));
+                }
+            }
+            else {
+                this.ai.reset();
+                console.log(chalk.yellow('⚠️ AI configuration reset'));
+            }
+        }
+        catch (error) {
+            console.log(chalk.red(`❌ Configuration failed: ${error.message}`));
+            if (error.message.includes('OpenAI requires API key')) {
+                console.log(chalk.yellow('\n🔧 How to get OpenAI API key:'));
+                console.log('  1. Visit: https://platform.openai.com/api-keys');
+                console.log('  2. Create new API key');
+                console.log('  3. Run: mcp ai configure openai YOUR_API_KEY');
+            }
+        }
+    }
+    /**
+     * Handle test command
+     */
+    async handleTest() {
+        const status = this.ai.getStatus();
+        if (!status.configured) {
+            console.log(chalk.yellow('⚠️ AI not configured'));
+            console.log('Run: mcp ai configure openai YOUR_API_KEY');
+            console.log('Or: mcp ai configure ollama');
+            return;
+        }
+        console.log(chalk.blue('🔌 Testing AI connection...'));
+        try {
+            const result = await this.ai.testConnection();
+            if (result.success) {
+                console.log(chalk.green(`✅ ${result.message}`));
+            }
+            else {
+                console.log(chalk.red(`❌ ${result.message}`));
+                // Provide suggestions based on provider
+                const config = this.configManager.getConfig();
+                if (config.provider === 'openai') {
+                    console.log(chalk.yellow('\n🔧 OpenAI troubleshooting:'));
+                    console.log('  1. Check internet connection');
+                    console.log('  2. Verify API key is valid');
+                    console.log('  3. Check OpenAI service status: https://status.openai.com');
+                }
+                else if (config.provider === 'ollama') {
+                    console.log(chalk.yellow('\n🔧 Ollama troubleshooting:'));
+                    console.log('  1. Ensure Ollama is installed: https://ollama.com');
+                    console.log('  2. Start Ollama service: ollama serve');
+                    console.log('  3. Check if endpoint is correct: http://localhost:11434');
+                }
+            }
+        }
+        catch (error) {
+            console.log(chalk.red(`❌ Test failed: ${error.message}`));
+        }
+    }
+    /**
+     * Handle ask command
+     */
+    async handleAsk(query) {
+        if (!query) {
+            console.log(chalk.yellow('⚠️ Please provide a query'));
+            console.log('Example: mcp ai ask "list files in current directory"');
+            return;
+        }
+        console.log(chalk.blue(`🤖 Query: "${query}"`));
+        try {
+            const result = await this.ai.ask(query);
+            await this.handleAskResult(result);
+        }
+        catch (error) {
+            if (error instanceof AIError) {
+                console.log(SimpleAI.getFriendlyError(error));
+            }
+            else {
+                console.log(chalk.red(`❌ Error: ${error.message}`));
+            }
+        }
+    }
+    /**
+     * Handle ask result
+     */
+    async handleAskResult(result) {
+        switch (result.type) {
+            case 'tool_call':
+                console.log(chalk.green(`✅ Intent recognized (confidence: ${(result.confidence || 0) * 100}%)`));
+                console.log(chalk.blue(`🔧 Tool call: ${result.tool?.service}.${result.tool?.tool}`));
+                console.log(chalk.gray(`   Parameters: ${JSON.stringify(result.tool?.params)}`));
+                // In actual implementation, this would execute the tool call
+                console.log(chalk.yellow('\n💡 Note: Tool execution would happen here'));
+                console.log('   In production, this would call the actual MCP service');
+                break;
+            case 'suggestions':
+                console.log(chalk.yellow(`⚠️ ${result.message}`));
+                if (result.help) {
+                    console.log(chalk.blue(result.help));
+                }
+                if (result.suggestions && result.suggestions.length > 0) {
+                    console.log(chalk.green('\n🔧 Suggested commands:'));
+                    result.suggestions.forEach((suggestion, i) => {
+                        console.log(`  ${i + 1}. ${suggestion}`);
+                    });
+                }
+                break;
+            case 'error':
+                console.log(chalk.red(`❌ ${result.message}`));
+                break;
+        }
+    }
+    /**
+     * Handle reset command
+     */
+    async handleReset() {
+        this.configManager.resetConfig();
+        this.ai.reset();
+        console.log(chalk.green('✅ AI configuration reset to defaults'));
+    }
+    /**
+     * Show AI status
+     */
+    async showStatus() {
+        const aiStatus = this.ai.getStatus();
+        const configStatus = this.configManager.getStatus();
+        console.log(chalk.blue('🤖 AI Status:'));
+        console.log(`  Enabled: ${aiStatus.enabled ? chalk.green('Yes') : chalk.red('No')}`);
+        console.log(`  Provider: ${chalk.cyan(aiStatus.provider)}`);
+        console.log(`  Configured: ${configStatus.configured ? chalk.green('Yes') : chalk.yellow('No')}`);
+        if (configStatus.configured) {
+            const config = this.configManager.getConfig();
+            console.log(`  Config file: ${chalk.gray(configStatus.configFile)}`);
+            if (config.provider !== 'none') {
+                console.log(chalk.blue('\n🔧 Current configuration:'));
+                console.log(this.configManager.formatConfig());
+            }
+        }
+        else {
+            console.log(chalk.yellow('\n💡 AI is not configured'));
+            console.log('   To configure: mcp ai configure openai YOUR_API_KEY');
+            console.log('   Or use Ollama: mcp ai configure ollama');
+        }
+        // Show test result if configured
+        if (aiStatus.configured) {
+            console.log(chalk.blue('\n🔌 Connection test:'));
+            try {
+                const testResult = await this.ai.testConnection();
+                console.log(`  Status: ${testResult.success ? chalk.green('OK') : chalk.red('Failed')}`);
+                console.log(`  Message: ${testResult.message}`);
+            }
+            catch (error) {
+                console.log(`  Status: ${chalk.red('Error')}`);
+                console.log(`  Message: ${error.message}`);
+            }
+        }
+    }
+    /**
+     * Show help
+     */
+    showHelp() {
+        console.log(chalk.blue('🤖 AI Commands:'));
+        console.log('');
+        console.log(chalk.green('  mcp ai'));
+        console.log('    Show AI status');
+        console.log('');
+        console.log(chalk.green('  mcp ai configure <provider> [options]'));
+        console.log('    Configure AI provider');
+        console.log('    Providers: openai, ollama, none');
+        console.log('    Options:');
+        console.log('      --api-key=<key>    API key (for OpenAI)');
+        console.log('      --endpoint=<url>   Custom endpoint');
+        console.log('      --model=<name>     Model name');
+        console.log('');
+        console.log(chalk.green('  mcp ai test'));
+        console.log('    Test AI connection');
+        console.log('');
+        console.log(chalk.green('  mcp ai ask "<query>"'));
+        console.log('    Ask AI a question');
+        console.log('    Example: mcp ai ask "list files in current directory"');
+        console.log('');
+        console.log(chalk.green('  mcp ai reset'));
+        console.log('    Reset AI configuration to defaults');
+        console.log('');
+        console.log(chalk.green('  mcp ai help'));
+        console.log('    Show this help message');
+        console.log('');
+        console.log(chalk.yellow('💡 Examples:'));
+        console.log('  Configure OpenAI: mcp ai configure openai sk-xxx');
+        console.log('  Configure Ollama: mcp ai configure ollama');
+        console.log('  Ask question:    mcp ai ask "start http service"');
+        console.log('  Test connection: mcp ai test');
+    }
+    /**
+     * Get AI instance (for integration with other modules)
+     */
+    getAIInstance() {
+        return this.ai;
+    }
+    /**
+     * Get config manager instance
+     */
+    getConfigManager() {
+        return this.configManager;
+    }
+}
+//# sourceMappingURL=command.js.map

package/dist/ai/config.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Simplified AI Configuration Manager
+ * Minimal configuration system for AI features
+ */
+import { SimpleAIConfig } from './ai';
+/**
+ * Simplified AI configuration manager
+ */
+export declare class SimpleAIConfigManager {
+    private config;
+    constructor();
+    /**
+     * Load configuration from file
+     */
+    private loadConfig;
+    /**
+     * Save configuration to file
+     */
+    private saveConfig;
+    /**
+     * Get current configuration
+     */
+    getConfig(): SimpleAIConfig;
+    /**
+     * Update configuration
+     */
+    updateConfig(config: SimpleAIConfig): Promise<void>;
+    /**
+     * Validate configuration
+     */
+    private validateConfig;
+    /**
+     * Check if string is a valid URL
+     */
+    private isValidUrl;
+    /**
+     * Parse configuration from command line arguments
+     */
+    parseFromArgs(args: string[]): SimpleAIConfig;
+    /**
+     * Get configuration file path
+     */
+    getConfigFilePath(): string;
+    /**
+     * Check if configuration file exists
+     */
+    configFileExists(): boolean;
+    /**
+     * Reset configuration to defaults
+     */
+    resetConfig(): void;
+    /**
+     * Get configuration status
+     */
+    getStatus(): {
+        configured: boolean;
+        provider: string;
+        hasApiKey: boolean;
+        configFile: string;
+    };
+    /**
+     * Format configuration for display
+     */
+    formatConfig(): string;
+}
+//# sourceMappingURL=config.d.ts.map

package/dist/ai/config.js

@@ -0,0 +1,211 @@
+/**
+ * Simplified AI Configuration Manager
+ * Minimal configuration system for AI features
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { logger } from '../core/logger.js';
+// Configuration file path
+const CONFIG_DIR = process.env.MCPILOT_CONFIG_DIR ||
+    path.join(process.env.HOME || process.env.USERPROFILE || '.', '.mcpilot');
+const CONFIG_FILE = path.join(CONFIG_DIR, 'ai-config.json');
+/**
+ * Simplified AI configuration manager
+ */
+export class SimpleAIConfigManager {
+    config = null;
+    constructor() {
+        this.loadConfig();
+    }
+    /**
+     * Load configuration from file
+     */
+    loadConfig() {
+        try {
+            if (fs.existsSync(CONFIG_FILE)) {
+                const content = fs.readFileSync(CONFIG_FILE, 'utf-8');
+                this.config = JSON.parse(content);
+                logger.info('[AI] Configuration loaded from file');
+            }
+            else {
+                logger.info('[AI] No configuration file found, using defaults');
+                this.config = { provider: 'none' };
+            }
+        }
+        catch (error) {
+            logger.warn(`[AI] Failed to load configuration: ${error.message}`);
+            this.config = { provider: 'none' };
+        }
+    }
+    /**
+     * Save configuration to file
+     */
+    saveConfig() {
+        try {
+            // Ensure config directory exists
+            if (!fs.existsSync(CONFIG_DIR)) {
+                fs.mkdirSync(CONFIG_DIR, { recursive: true });
+            }
+            // Save configuration
+            fs.writeFileSync(CONFIG_FILE, JSON.stringify(this.config, null, 2));
+            logger.info('[AI] Configuration saved to file');
+        }
+        catch (error) {
+            logger.error(`[AI] Failed to save configuration: ${error.message}`);
+            throw new Error(`Failed to save configuration: ${error.message}`, { cause: error });
+        }
+    }
+    /**
+     * Get current configuration
+     */
+    getConfig() {
+        return this.config || { provider: 'none' };
+    }
+    /**
+     * Update configuration
+     */
+    async updateConfig(config) {
+        // Validate configuration
+        this.validateConfig(config);
+        // Update configuration
+        this.config = config;
+        // Save to file
+        this.saveConfig();
+        logger.info(`[AI] Configuration updated for provider: ${config.provider}`);
+    }
+    /**
+     * Validate configuration
+     */
+    validateConfig(config) {
+        // Basic validation
+        if (!config.provider) {
+            throw new Error('Provider is required');
+        }
+        const validProviders = ['openai', 'ollama', 'none'];
+        if (!validProviders.includes(config.provider)) {
+            throw new Error(`Invalid provider: ${config.provider}. Valid providers: ${validProviders.join(', ')}`);
+        }
+        // Provider-specific validation
+        if (config.provider === 'openai' && !config.apiKey) {
+            throw new Error('OpenAI requires API key');
+        }
+        // Validate endpoint format if provided
+        if (config.endpoint && !this.isValidUrl(config.endpoint)) {
+            throw new Error(`Invalid endpoint URL: ${config.endpoint}`);
+        }
+    }
+    /**
+     * Check if string is a valid URL
+     */
+    isValidUrl(url) {
+        try {
+            new URL(url);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Parse configuration from command line arguments
+     */
+    parseFromArgs(args) {
+        if (args.length === 0) {
+            throw new Error('No arguments provided');
+        }
+        const provider = args[0].toLowerCase();
+        const config = { provider: 'none' };
+        // Parse provider
+        if (provider === 'openai' || provider === 'ollama') {
+            config.provider = provider;
+        }
+        else if (provider === 'none' || provider === 'reset') {
+            config.provider = 'none';
+            return config;
+        }
+        else {
+            throw new Error(`Unknown provider: ${provider}. Use: openai, ollama, or none`);
+        }
+        // Parse additional arguments
+        for (let i = 1; i < args.length; i++) {
+            const arg = args[i];
+            if (arg.startsWith('--')) {
+                const [key, value] = arg.slice(2).split('=');
+                switch (key) {
+                    case 'api-key':
+                    case 'apikey':
+                        config.apiKey = value;
+                        break;
+                    case 'endpoint':
+                        config.endpoint = value;
+                        break;
+                    case 'model':
+                        config.model = value;
+                        break;
+                    default:
+                        logger.warn(`[AI] Unknown option: --${key}`);
+                }
+            }
+            else if (i === 1 && !arg.startsWith('--')) {
+                // First non-option argument after provider is treated as API key
+                config.apiKey = arg;
+            }
+        }
+        return config;
+    }
+    /**
+     * Get configuration file path
+     */
+    getConfigFilePath() {
+        return CONFIG_FILE;
+    }
+    /**
+     * Check if configuration file exists
+     */
+    configFileExists() {
+        return fs.existsSync(CONFIG_FILE);
+    }
+    /**
+     * Reset configuration to defaults
+     */
+    resetConfig() {
+        this.config = { provider: 'none' };
+        this.saveConfig();
+        logger.info('[AI] Configuration reset to defaults');
+    }
+    /**
+     * Get configuration status
+     */
+    getStatus() {
+        return {
+            configured: this.config?.provider !== 'none',
+            provider: this.config?.provider || 'none',
+            hasApiKey: !!this.config?.apiKey,
+            configFile: CONFIG_FILE,
+        };
+    }
+    /**
+     * Format configuration for display
+     */
+    formatConfig() {
+        const config = this.getConfig();
+        const lines = [
+            'AI Configuration:',
+            `  Provider: ${config.provider}`,
+        ];
+        if (config.provider !== 'none') {
+            if (config.model) {
+                lines.push(`  Model: ${config.model}`);
+            }
+            if (config.endpoint) {
+                lines.push(`  Endpoint: ${config.endpoint}`);
+            }
+            if (config.apiKey) {
+                lines.push(`  API Key: ${config.apiKey ? '********' + config.apiKey.slice(-4) : 'Not set'}`);
+            }
+        }
+        lines.push(`  Config file: ${CONFIG_FILE}`);
+        return lines.join('\n');
+    }
+}
+//# sourceMappingURL=config.js.map

package/dist/ai/enhanced-intent.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Enhanced Intent Engine
+ * Advanced AI-powered intent parsing with context awareness
+ */
+export interface IntentResult {
+    service: string;
+    method: string;
+    parameters: Record<string, any>;
+    confidence: number;
+}
+export declare class EnhancedIntentEngine {
+    private config;
+    constructor(config: any);
+    parse(query: string, availableTools: string[]): Promise<IntentResult | null>;
+    updateConfig(config: any): void;
+}
+//# sourceMappingURL=enhanced-intent.d.ts.map

package/dist/ai/enhanced-intent.js

@@ -0,0 +1,32 @@
+/**
+ * Enhanced Intent Engine
+ * Advanced AI-powered intent parsing with context awareness
+ */
+export class EnhancedIntentEngine {
+    config;
+    constructor(config) {
+        this.config = config;
+        // Initialize with configuration
+    }
+    async parse(query, availableTools) {
+        // Simple implementation for now
+        // In a real implementation, this would use AI to parse the query
+        // Find the first tool that matches the query
+        for (const tool of availableTools) {
+            if (tool.toLowerCase().includes(query.toLowerCase())) {
+                const [service, method] = tool.split(':');
+                return {
+                    service,
+                    method,
+                    parameters: {},
+                    confidence: 0.7,
+                };
+            }
+        }
+        return null;
+    }
+    updateConfig(config) {
+        this.config = config;
+    }
+}
+//# sourceMappingURL=enhanced-intent.js.map

package/dist/ai/index.d.ts

@@ -0,0 +1,29 @@
+/**
+ * AI Module Exports
+ * Provides unified interface for AI functionality
+ */
+export { SimpleAI, AIError, type SimpleAIConfig, type AskResult, type ToolCall } from './ai';
+export { SimpleAIConfigManager } from './config';
+export { SimpleAICommand } from './command';
+export { CloudIntentEngine, type CloudIntentEngineConfig, type AtomicIntent, type DependencyEdge, type IntentParseResult, type ToolSelectionResult, type ExecutionContext, type ExecutionResult, type EnhancedExecutionStep, type WorkflowPlan, type EnhancedExecutionResult, } from './cloud-intent-engine';
+export { EnhancedIntentEngine } from './enhanced-intent';
+export { IntentEngine } from './intent';
+/**
+ * Check AI capabilities
+ * Simplified version without vector database
+ */
+export declare function checkAICapabilities(config?: any): Promise<{
+    aiAvailable: boolean;
+    mode: 'api' | 'none';
+}>;
+/**
+ * Get AI system status
+ */
+export declare function getAIStatus(config?: any): Promise<{
+    timestamp: string;
+    version: string;
+    note: string;
+    aiAvailable: boolean;
+    mode: "api" | "none";
+}>;
+//# sourceMappingURL=index.d.ts.map