@mcpilotx/intentorch 0.5.0

package/dist/core/error-ai.js

@@ -0,0 +1,217 @@
+import chalk from 'chalk';
+import { PROVIDER_DB, getProviderDisplayName } from './providers.js';
+export class AIErrorHandler {
+    static handleError(error) {
+        console.log(chalk.red(`❌ ${error.message}`));
+        // Provide different repair suggestions based on error type
+        const suggestions = this.getSuggestions(error);
+        if (suggestions.length > 0) {
+            console.log(chalk.yellow('\n🔧 Repair suggestions:'));
+            suggestions.forEach((suggestion, index) => {
+                console.log(`  ${index + 1}. ${suggestion}`);
+            });
+        }
+        // Provide next steps
+        console.log(chalk.blue('\n📝 Next steps:'));
+        this.printNextSteps(error);
+    }
+    static getSuggestions(error) {
+        const suggestions = [];
+        switch (error.type) {
+            case 'config':
+                suggestions.push('Check configuration file format is correct');
+                suggestions.push('Ensure all required fields are filled');
+                if (error.provider) {
+                    const providerInfo = PROVIDER_DB[error.provider];
+                    if (providerInfo?.configHint) {
+                        suggestions.push(providerInfo.configHint);
+                    }
+                }
+                break;
+            case 'connection':
+                suggestions.push('Check network connection is normal');
+                suggestions.push('Confirm API endpoint is accessible');
+                if (error.provider === 'ollama') {
+                    suggestions.push('Ensure Ollama service is running: ollama serve');
+                    suggestions.push('Check Ollama host address: http://localhost:11434');
+                }
+                break;
+            case 'authentication':
+                suggestions.push('Check API key is correct');
+                suggestions.push('Confirm API key has sufficient permissions');
+                suggestions.push('Try generating a new API key');
+                if (error.provider) {
+                    suggestions.push(`Visit ${this.getProviderWebsite(error.provider)} to manage API keys`);
+                }
+                break;
+            case 'validation':
+                suggestions.push('Check input parameters meet requirements');
+                suggestions.push('Confirm model name is correct');
+                suggestions.push('View provider documentation to understand parameter limits');
+                break;
+            case 'unknown':
+                suggestions.push('View detailed error logs: mcp logs');
+                suggestions.push('Try restarting MCPilot services');
+                suggestions.push('Check system resources are sufficient');
+                break;
+        }
+        // Add general suggestions
+        if (error.provider) {
+            suggestions.push(`View ${getProviderDisplayName(error.provider)} configuration help: mcp ai help ${error.provider}`);
+        }
+        return suggestions;
+    }
+    static printNextSteps(error) {
+        console.log(`  • Reconfigure: ${chalk.cyan('mcp ai use <provider>')}`);
+        if (error.provider) {
+            console.log(`  • Test connection: ${chalk.cyan('mcp ai test')}`);
+            console.log(`  • View configuration: ${chalk.cyan('mcp ai config')}`);
+        }
+        console.log(`  • View help: ${chalk.cyan('mcp ai --help')}`);
+        if (error.type === 'config' || error.type === 'validation') {
+            console.log(`  • View providers: ${chalk.cyan('mcp ai providers')}`);
+        }
+        if (error.details) {
+            console.log(chalk.gray(`\n💡 Detailed error information: ${JSON.stringify(error.details, null, 2)}`));
+        }
+    }
+    static getProviderWebsite(provider) {
+        const websites = {
+            openai: 'https://platform.openai.com/api-keys',
+            anthropic: 'https://console.anthropic.com/keys',
+            google: 'https://makersuite.google.com/app/apikey',
+            azure: 'https://portal.azure.com/#create/Microsoft.CognitiveServicesOpenAI',
+            deepseek: 'https://platform.deepseek.com/api-keys',
+            cohere: 'https://dashboard.cohere.com/api-keys',
+            ollama: 'https://ollama.com',
+            local: '',
+            custom: '',
+            none: '',
+        };
+        return websites[provider] || '';
+    }
+    // Handle provider name errors
+    static handleProviderError(input, similarProviders) {
+        console.log(chalk.red(`❌ Unknown AI provider: '${input}'`));
+        if (similarProviders && similarProviders.length > 0) {
+            console.log(chalk.yellow('\n🔍 Similar providers:'));
+            similarProviders.forEach((similar, index) => {
+                const providerInfo = PROVIDER_DB[similar.provider];
+                const displayName = providerInfo?.name || similar.provider;
+                console.log(`  • ${chalk.cyan(displayName)} (similarity ${similar.similarity}%)`);
+            });
+        }
+        console.log(chalk.blue('\n📋 Supported providers:'));
+        const providerList = Object.entries(PROVIDER_DB)
+            .map(([id, info]) => `${chalk.cyan(id)} - ${info.description}`)
+            .join('\n  ');
+        console.log(`  ${providerList}`);
+        console.log(chalk.green('\n💡 Use the following commands:'));
+        console.log(`  • View all providers: ${chalk.cyan('mcp ai providers')}`);
+        console.log(`  • Configure provider: ${chalk.cyan('mcp ai use <provider>')}`);
+    }
+    // Handle model name errors
+    static handleModelError(provider, model, availableModels) {
+        const providerInfo = PROVIDER_DB[provider];
+        const displayName = providerInfo?.name || provider;
+        console.log(chalk.red(`❌ ${displayName} does not support model: '${model}'`));
+        if (availableModels && availableModels.length > 0) {
+            console.log(chalk.yellow('\n📋 Available models:'));
+            availableModels.forEach(availableModel => {
+                const description = providerInfo?.modelDescriptions?.[availableModel] || '';
+                console.log(`  • ${chalk.cyan(availableModel)} ${description ? `- ${description}` : ''}`);
+            });
+        }
+        else if (providerInfo?.modelDescriptions) {
+            console.log(chalk.yellow('\n📋 Common models:'));
+            Object.entries(providerInfo.modelDescriptions).forEach(([modelName, description]) => {
+                console.log(`  • ${chalk.cyan(modelName)} - ${description}`);
+            });
+        }
+        console.log(chalk.green('\n💡 Use the following commands:'));
+        console.log(`  • View all models: ${chalk.cyan(`mcp ai models ${provider}`)}`);
+        console.log(`  • Use default model: ${chalk.cyan(`mcp ai use ${provider}`)}`);
+    }
+    // Handle API key errors
+    static handleApiKeyError(provider) {
+        const providerInfo = PROVIDER_DB[provider];
+        const displayName = providerInfo?.name || provider;
+        console.log(chalk.red(`❌ ${displayName} requires API key`));
+        console.log(chalk.yellow('\n🔑 How to get API key:'));
+        switch (provider) {
+            case 'openai':
+                console.log('  1. Visit https://platform.openai.com/api-keys');
+                console.log('  2. Login or register OpenAI account');
+                console.log('  3. Create new API key');
+                console.log('  4. Key format: sk-xxx...');
+                break;
+            case 'deepseek':
+                console.log('  1. Visit https://platform.deepseek.com/api-keys');
+                console.log('  2. Login or register DeepSeek account');
+                console.log('  3. Create new API key');
+                console.log('  4. Key format: sk-xxx or obtain from platform');
+                break;
+            case 'anthropic':
+                console.log('  1. Visit https://console.anthropic.com/keys');
+                console.log('  2. Login or register Anthropic account');
+                console.log('  3. Create new API key');
+                console.log('  4. Key format: sk-ant-xxx...');
+                break;
+            case 'cohere':
+                console.log('  1. Visit https://dashboard.cohere.com/api-keys');
+                console.log('  2. Login or register Cohere account');
+                console.log('  3. Create new API key');
+                break;
+            default:
+                console.log(`  Please visit ${displayName} official website to get API key`);
+        }
+        console.log(chalk.green('\n💡 Configuration method:'));
+        console.log(`  • Direct configuration: ${chalk.cyan(`mcp ai use ${provider} <your-api-key>`)}`);
+        console.log(`  • Environment variable: ${chalk.cyan(`export ${this.getEnvVarName(provider)}=<your-api-key>`)}`);
+    }
+    static getEnvVarName(provider) {
+        const envVars = {
+            openai: 'OPENAI_API_KEY',
+            anthropic: 'ANTHROPIC_API_KEY',
+            google: 'GOOGLE_API_KEY',
+            azure: 'AZURE_OPENAI_API_KEY',
+            deepseek: 'DEEPSEEK_API_KEY',
+            cohere: 'COHERE_API_KEY',
+            ollama: '',
+            local: '',
+            custom: '',
+            none: '',
+        };
+        return envVars[provider] || `${provider.toUpperCase()}_API_KEY`;
+    }
+    // Handle connection test results
+    static handleTestResult(success, provider, details) {
+        if (success) {
+            if (provider) {
+                const providerInfo = PROVIDER_DB[provider];
+                const displayName = providerInfo?.name || provider;
+                console.log(chalk.green(`✅ ${displayName} connection test successful!`));
+            }
+            else {
+                console.log(chalk.green('✅ AI connection test successful!'));
+            }
+            if (details) {
+                console.log(chalk.gray('\n📊 Test details:'));
+                console.log(JSON.stringify(details, null, 2));
+            }
+        }
+        else {
+            console.log(chalk.red('❌ AI connection test failed'));
+            if (details?.error) {
+                const error = {
+                    type: 'connection',
+                    message: details.error.message || 'Connection failed',
+                    provider,
+                    details: details.error,
+                };
+                this.handleError(error);
+            }
+        }
+    }
+}
+//# sourceMappingURL=error-ai.js.map

package/dist/core/error-handler.d.ts

@@ -0,0 +1,197 @@
+/**
+ * IntentOrch SDK Unified Error Handling System
+ * Balances minimalist style with functional robustness
+ * Formerly known as MCPilot SDK
+ */
+/**
+ * Error Code Enumeration
+ * Clear categorization for easy identification and handling
+ */
+export declare enum ErrorCode {
+    CONFIG_INVALID = "CONFIG_001",
+    CONFIG_MISSING = "CONFIG_002",
+    CONFIG_VALIDATION_FAILED = "CONFIG_003",
+    CONFIG_MIGRATION_FAILED = "CONFIG_004",
+    SERVICE_NOT_FOUND = "SERVICE_001",
+    SERVICE_ALREADY_EXISTS = "SERVICE_002",
+    SERVICE_START_FAILED = "SERVICE_003",
+    SERVICE_STOP_FAILED = "SERVICE_004",
+    SERVICE_HEALTH_CHECK_FAILED = "SERVICE_005",
+    RUNTIME_DETECTION_FAILED = "RUNTIME_001",
+    RUNTIME_NOT_SUPPORTED = "RUNTIME_002",
+    RUNTIME_NOT_INSTALLED = "RUNTIME_003",
+    RUNTIME_ADAPTER_ERROR = "RUNTIME_004",
+    PROCESS_NOT_FOUND = "PROCESS_001",
+    PROCESS_START_FAILED = "PROCESS_002",
+    PROCESS_STOP_FAILED = "PROCESS_003",
+    PROCESS_TIMEOUT = "PROCESS_004",
+    RESOURCE_LIMIT_EXCEEDED = "RESOURCE_001",
+    MEMORY_LIMIT_EXCEEDED = "RESOURCE_002",
+    CPU_LIMIT_EXCEEDED = "RESOURCE_003",
+    DISK_SPACE_INSUFFICIENT = "RESOURCE_004",
+    PERMISSION_DENIED = "PERMISSION_001",
+    FILE_PERMISSION_ERROR = "PERMISSION_002",
+    NETWORK_PERMISSION_ERROR = "PERMISSION_003",
+    NETWORK_ERROR = "NETWORK_001",
+    CONNECTION_REFUSED = "NETWORK_002",
+    CONNECTION_TIMEOUT = "NETWORK_003",
+    DNS_RESOLUTION_FAILED = "NETWORK_004",
+    AI_CONFIG_INVALID = "AI_001",
+    AI_PROVIDER_NOT_AVAILABLE = "AI_002",
+    AI_QUERY_FAILED = "AI_003",
+    AI_MODEL_NOT_FOUND = "AI_004",
+    SYSTEM_ERROR = "SYSTEM_001",
+    UNEXPECTED_ERROR = "SYSTEM_002",
+    NOT_IMPLEMENTED = "SYSTEM_003",
+    VALIDATION_FAILED = "VALIDATION_001",
+    REQUIRED_FIELD_MISSING = "VALIDATION_002",
+    INVALID_FORMAT = "VALIDATION_003",
+    OUT_OF_RANGE = "VALIDATION_004"
+}
+/**
+ * Error Severity Levels
+ */
+export declare enum ErrorSeverity {
+    LOW = "low",// Ignorable errors, don't affect core functionality
+    MEDIUM = "medium",// Errors that need attention, may affect some functionality
+    HIGH = "high",// Serious errors, affect core functionality
+    CRITICAL = "critical"
+}
+/**
+ * Error Context Information
+ */
+export interface ErrorContext {
+    [key: string]: any;
+    timestamp?: Date;
+    userId?: string;
+    requestId?: string;
+    serviceName?: string;
+    runtimeType?: string;
+    configPath?: string;
+    environment?: string;
+}
+/**
+ * Error Fix Suggestions
+ */
+export interface ErrorSuggestion {
+    title: string;
+    description: string;
+    steps: string[];
+    codeExample?: string;
+    documentationUrl?: string;
+}
+/**
+ * IntentOrch Unified Error Class
+ */
+export declare class IntentOrchError extends Error {
+    code: ErrorCode;
+    message: string;
+    severity: ErrorSeverity;
+    context: ErrorContext;
+    suggestions: ErrorSuggestion[];
+    cause?: Error;
+    constructor(code: ErrorCode, message: string, severity?: ErrorSeverity, context?: ErrorContext, suggestions?: ErrorSuggestion[], cause?: Error);
+    /**
+     * Convert to JSON format for easy logging and transmission
+     */
+    toJSON(): object;
+    /**
+     * Get error summary for display
+     */
+    getSummary(): string;
+    /**
+     * Get detailed error information
+     */
+    getDetails(): string;
+}
+/**
+ * MCPilot Unified Error Class (for backward compatibility)
+ * @deprecated Use IntentOrchError instead
+ */
+export declare class MCPilotError extends IntentOrchError {
+    constructor(code: ErrorCode, message: string, severity?: ErrorSeverity, context?: ErrorContext, suggestions?: ErrorSuggestion[], cause?: Error);
+}
+/**
+ * Error Factory - Create standardized error instances
+ */
+export declare class ErrorFactory {
+    /**
+     * Configuration error
+     */
+    static configInvalid(message: string, context?: ErrorContext, cause?: Error): MCPilotError;
+    /**
+     * Service not found error
+     */
+    static serviceNotFound(serviceName: string, context?: ErrorContext): MCPilotError;
+    /**
+     * Runtime detection failed error
+     */
+    static runtimeDetectionFailed(path: string, context?: ErrorContext, cause?: Error): MCPilotError;
+    /**
+     * Process start failed error
+     */
+    static processStartFailed(serviceName: string, context?: ErrorContext, cause?: Error): MCPilotError;
+    /**
+     * Permission denied error
+     */
+    static permissionDenied(operation: string, resource: string, context?: ErrorContext): MCPilotError;
+    /**
+     * Network error
+     */
+    static networkError(operation: string, url: string, context?: ErrorContext, cause?: Error): MCPilotError;
+    /**
+     * Not implemented error
+     */
+    static notImplemented(feature: string, context?: ErrorContext): MCPilotError;
+    /**
+     * Validation error
+     */
+    static validationFailed(field: string, reason: string, context?: ErrorContext): MCPilotError;
+}
+/**
+ * Error Handler - Handle, log and recover from errors
+ */
+export declare class ErrorHandler {
+    private static instance;
+    private handlers;
+    private constructor();
+    static getInstance(): ErrorHandler;
+    /**
+     * Register error handler
+     */
+    registerHandler(handler: (error: MCPilotError) => Promise<void>): void;
+    /**
+     * Handle error
+     */
+    handle(error: Error | MCPilotError): Promise<void>;
+    /**
+     * Safely execute function, automatically handle errors
+     */
+    execute<T>(operation: string, fn: () => Promise<T>, context?: ErrorContext): Promise<T>;
+}
+/**
+ * Default Error Handler - Console Output
+ */
+export declare class ConsoleErrorHandler {
+    static handle(error: MCPilotError): Promise<void>;
+}
+/**
+ * Error Recovery Strategy
+ */
+export interface RetryStrategy {
+    maxAttempts: number;
+    backoff: 'linear' | 'exponential' | 'fixed';
+    baseDelay: number;
+    maxDelay?: number;
+}
+/**
+ * Error Handler with Retry
+ */
+export declare class RetryErrorHandler {
+    static withRetry<T>(operation: string, fn: () => Promise<T>, strategy?: RetryStrategy, context?: ErrorContext): Promise<T>;
+}
+export declare function createError(code: ErrorCode, message: string, severity?: ErrorSeverity, context?: ErrorContext): MCPilotError;
+export declare function wrapError(error: Error, code?: ErrorCode, context?: ErrorContext): MCPilotError;
+export declare function isMCPilotError(error: any): error is MCPilotError;
+export declare function shouldRetry(error: Error): boolean;
+//# sourceMappingURL=error-handler.d.ts.map