@mcpilotx/intentorch 0.5.0

package/dist/core/retry-manager.d.ts

@@ -0,0 +1,41 @@
+export interface RetryOptions {
+    maxRetries?: number;
+    initialDelay?: number;
+    maxDelay?: number;
+    backoffFactor?: number;
+    jitter?: boolean;
+    retryableErrors?: string[];
+    nonRetryableErrors?: string[];
+}
+export interface RetryResult<T> {
+    success: boolean;
+    result?: T;
+    error?: Error;
+    attempts: number;
+    totalTime: number;
+}
+export declare class RetryManager {
+    static executeWithRetry<T>(operation: () => Promise<T>, options?: RetryOptions): Promise<RetryResult<T>>;
+    private static calculateDelay;
+    private static isRetryableError;
+    private static isNonRetryableError;
+    private static isNetworkError;
+    private static isTimeoutError;
+    private static isConfigurationError;
+    private static isAuthenticationError;
+    private static delay;
+    static executeBatchWithRetry<T>(operations: Array<() => Promise<T>>, options?: RetryOptions): Promise<Array<RetryResult<T>>>;
+    static createCircuitBreaker(options?: {
+        failureThreshold?: number;
+        resetTimeout?: number;
+        halfOpenMaxAttempts?: number;
+    }): <T>(operation: () => Promise<T>, retryOptions?: RetryOptions) => Promise<RetryResult<T>>;
+    static getStats(): {
+        totalOperations: number;
+        successfulOperations: number;
+        failedOperations: number;
+        averageRetries: number;
+        averageTime: number;
+    };
+}
+//# sourceMappingURL=retry-manager.d.ts.map

package/dist/core/retry-manager.js

@@ -0,0 +1,204 @@
+import { logger } from './logger.js';
+export class RetryManager {
+    static async executeWithRetry(operation, options = {}) {
+        const { maxRetries = 3, initialDelay = 1000, maxDelay = 30000, backoffFactor = 2, jitter = true, retryableErrors = [], nonRetryableErrors = [], } = options;
+        let lastError;
+        const startTime = Date.now();
+        for (let attempt = 0; attempt <= maxRetries; attempt++) {
+            try {
+                if (attempt > 0) {
+                    const delay = this.calculateDelay(attempt, initialDelay, maxDelay, backoffFactor, jitter);
+                    logger.info(`Retry attempt ${attempt}/${maxRetries} after ${delay}ms delay`);
+                    await this.delay(delay);
+                }
+                const result = await operation();
+                if (attempt > 0) {
+                    logger.info(`Success on retry attempt ${attempt}`);
+                }
+                return {
+                    success: true,
+                    result,
+                    attempts: attempt + 1,
+                    totalTime: Date.now() - startTime,
+                };
+            }
+            catch (error) {
+                lastError = error;
+                // Check if it's a non-retryable error
+                if (this.isNonRetryableError(error, nonRetryableErrors)) {
+                    logger.warn(`Non-retryable error encountered: ${error.message}`);
+                    break;
+                }
+                // Check if it's a retryable error
+                const shouldRetry = attempt < maxRetries &&
+                    (retryableErrors.length === 0 || this.isRetryableError(error, retryableErrors));
+                logger.warn(`Attempt ${attempt + 1} failed: ${error.message}`);
+                if (shouldRetry) {
+                    const nextDelay = this.calculateDelay(attempt + 1, initialDelay, maxDelay, backoffFactor, jitter);
+                    logger.info(`Will retry in ${nextDelay}ms`);
+                }
+                else {
+                    break;
+                }
+            }
+        }
+        return {
+            success: false,
+            error: lastError || new Error('Operation failed'),
+            attempts: maxRetries + 1,
+            totalTime: Date.now() - startTime,
+        };
+    }
+    static calculateDelay(attempt, initialDelay, maxDelay, backoffFactor, jitter) {
+        // Exponential backoff
+        let delay = initialDelay * Math.pow(backoffFactor, attempt - 1);
+        // Add jitter (randomness)
+        if (jitter) {
+            const jitterAmount = delay * 0.1; // 10% jitter
+            delay += Math.random() * jitterAmount * 2 - jitterAmount;
+        }
+        // Limit maximum delay
+        return Math.min(delay, maxDelay);
+    }
+    static isRetryableError(error, retryableErrors) {
+        if (retryableErrors.length === 0) {
+            // Default retry network errors and timeout errors
+            return this.isNetworkError(error) || this.isTimeoutError(error);
+        }
+        const errorMessage = error.message.toLowerCase();
+        return retryableErrors.some(pattern => errorMessage.includes(pattern.toLowerCase()));
+    }
+    static isNonRetryableError(error, nonRetryableErrors) {
+        if (nonRetryableErrors.length === 0) {
+            // Default don't retry configuration errors and authentication errors
+            return this.isConfigurationError(error) || this.isAuthenticationError(error);
+        }
+        const errorMessage = error.message.toLowerCase();
+        return nonRetryableErrors.some(pattern => errorMessage.includes(pattern.toLowerCase()));
+    }
+    static isNetworkError(error) {
+        const networkKeywords = [
+            'network', 'connection', 'socket', 'timeout', 'econnrefused',
+            'econnreset', 'eaddrinuse', 'eaddrinfo', 'enetunreach',
+            'fetch failed', 'request failed', 'aborted',
+        ];
+        const errorMessage = error.message.toLowerCase();
+        return networkKeywords.some(keyword => errorMessage.includes(keyword));
+    }
+    static isTimeoutError(error) {
+        const timeoutKeywords = ['timeout', 'timed out', 'aborted'];
+        const errorMessage = error.message.toLowerCase();
+        return timeoutKeywords.some(keyword => errorMessage.includes(keyword));
+    }
+    static isConfigurationError(error) {
+        const configKeywords = [
+            'configuration', 'config', 'invalid', 'missing', 'required',
+            'not found', 'undefined', 'null', 'api key', 'endpoint',
+        ];
+        const errorMessage = error.message.toLowerCase();
+        return configKeywords.some(keyword => errorMessage.includes(keyword));
+    }
+    static isAuthenticationError(error) {
+        const authKeywords = [
+            'authentication', 'authorization', 'unauthorized', 'forbidden',
+            'invalid token', 'api key', 'credentials', '401', '403',
+        ];
+        const errorMessage = error.message.toLowerCase();
+        return authKeywords.some(keyword => errorMessage.includes(keyword));
+    }
+    static delay(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+    // Batch operation retry
+    static async executeBatchWithRetry(operations, options = {}) {
+        const results = [];
+        for (let i = 0; i < operations.length; i++) {
+            logger.debug(`Executing batch operation ${i + 1}/${operations.length}`);
+            const result = await this.executeWithRetry(operations[i], options);
+            results.push(result);
+            // If operation fails, can choose to continue or stop
+            if (!result.success && options.nonRetryableErrors?.some(pattern => result.error?.message.toLowerCase().includes(pattern.toLowerCase()))) {
+                logger.warn(`Stopping batch execution due to non-retryable error in operation ${i + 1}`);
+                break;
+            }
+        }
+        return results;
+    }
+    // Retry with circuit breaker
+    static createCircuitBreaker(options = {}) {
+        const { failureThreshold = 5, resetTimeout = 60000, // 60seconds
+        halfOpenMaxAttempts = 3, } = options;
+        let state = 'closed';
+        let failureCount = 0;
+        let lastFailureTime = 0;
+        let halfOpenAttempts = 0;
+        return async function withCircuitBreaker(operation, retryOptions) {
+            const now = Date.now();
+            // Check circuit breaker state
+            if (state === 'open') {
+                if (now - lastFailureTime > resetTimeout) {
+                    // Enter half-open state
+                    state = 'half-open';
+                    halfOpenAttempts = 0;
+                    logger.info('Circuit breaker transitioning to half-open state');
+                }
+                else {
+                    throw new Error('Circuit breaker is open - service unavailable');
+                }
+            }
+            if (state === 'half-open') {
+                if (halfOpenAttempts >= halfOpenMaxAttempts) {
+                    // Too many attempts in half-open state, reopen
+                    state = 'open';
+                    lastFailureTime = now;
+                    throw new Error('Circuit breaker re-opened - service still unavailable');
+                }
+                halfOpenAttempts++;
+            }
+            try {
+                const result = await RetryManager.executeWithRetry(operation, retryOptions);
+                if (result.success) {
+                    // Operation successful, reset circuit breaker
+                    if (state === 'half-open') {
+                        logger.info('Circuit breaker transitioning to closed state');
+                    }
+                    state = 'closed';
+                    failureCount = 0;
+                    halfOpenAttempts = 0;
+                }
+                else {
+                    // Operation failed, update failure count
+                    failureCount++;
+                    lastFailureTime = now;
+                    if (failureCount >= failureThreshold) {
+                        state = 'open';
+                        logger.error(`Circuit breaker opened after ${failureCount} failures`);
+                    }
+                }
+                return result;
+            }
+            catch (error) {
+                // Update failure count
+                failureCount++;
+                lastFailureTime = now;
+                if (failureCount >= failureThreshold) {
+                    state = 'open';
+                    logger.error(`Circuit breaker opened after ${failureCount} failures`);
+                }
+                throw error;
+            }
+        };
+    }
+    // Monitoring and reporting
+    static getStats() {
+        // Here you can add actual statistical tracking
+        return {
+            totalOperations: 0,
+            successfulOperations: 0,
+            failedOperations: 0,
+            averageRetries: 0,
+            averageTime: 0,
+        };
+    }
+}
+//# sourceMappingURL=retry-manager.js.map

package/dist/core/types.d.ts

@@ -0,0 +1,155 @@
+export type RuntimeType = 'node' | 'python' | 'docker' | 'java' | 'go' | 'rust' | 'binary';
+export interface DockerConnectionConfig {
+    type: 'local' | 'remote' | 'socket';
+    host?: string;
+    port?: number;
+    socketPath?: string;
+    useTLS?: boolean;
+    certs?: {
+        ca?: string;
+        cert?: string;
+        key?: string;
+    };
+    registryAuth?: {
+        username: string;
+        password: string;
+        serveraddress: string;
+    };
+}
+export interface RuntimeSpecificConfig {
+    node?: {
+        npmRegistry?: string;
+        bun?: boolean;
+        nodeVersion?: string;
+    };
+    python?: {
+        venv?: boolean;
+        mirror?: string;
+        pythonVersion?: string;
+        dependencies?: string[];
+    };
+    go?: {
+        module?: string;
+        build?: boolean;
+        goVersion?: string;
+    };
+    rust?: {
+        release?: boolean;
+        rustVersion?: string;
+        test?: boolean;
+        binary?: string;
+        debug?: boolean;
+        output?: string;
+    };
+    docker?: DockerConnectionConfig & {
+        image?: string;
+        dockerfile?: string;
+        buildContext?: string;
+        ports?: number[];
+        volumes?: string[];
+        workdir?: string;
+    };
+    java?: {
+        maven?: boolean;
+        gradle?: boolean;
+        javaVersion?: string;
+    };
+}
+export interface DetectionEvidence {
+    executableAnalysis?: {
+        type: string;
+        confidence: number;
+        details: any;
+    };
+    projectFiles?: {
+        files: string[];
+        confidence: number;
+    };
+    fileStatistics?: {
+        extensions: Record<string, number>;
+        confidence: number;
+    };
+    fileExtensions?: {
+        extensions: string[];
+        confidence: number;
+    };
+}
+export interface DetectionResult {
+    runtime: RuntimeType;
+    confidence: number;
+    evidence: DetectionEvidence;
+    source: 'legacy' | 'enhanced' | 'explicit';
+    suggestions?: string[];
+    warning?: string;
+}
+export type AIProvider = 'openai' | 'anthropic' | 'google' | 'azure' | 'deepseek' | 'cohere' | 'ollama' | 'local' | 'custom' | 'none';
+export interface AIConfig {
+    provider: AIProvider;
+    model: string;
+    apiKey?: string;
+    apiEndpoint?: string;
+    timeout?: number;
+    maxTokens?: number;
+    temperature?: number;
+    apiVersion?: string;
+    region?: string;
+    embeddingProvider?: string;
+    embeddingApiKey?: string;
+    embeddingModel?: string;
+    embeddingEndpoint?: string;
+    localModelPath?: string;
+    ollamaHost?: string;
+    customConfig?: Record<string, any>;
+}
+export interface RegistryConfig {
+    preferred: string;
+    customRegistries?: Record<string, string>;
+}
+export interface ServicesConfig {
+    autoStart: string[];
+    defaultTimeout?: number;
+}
+export interface Config {
+    ai: AIConfig;
+    registry: RegistryConfig;
+    services: ServicesConfig;
+    detectionThreshold?: number;
+    defaultDockerHost?: string;
+    requireExplicitRuntime?: boolean;
+    autoSaveDetection?: boolean;
+    interactiveMode?: boolean;
+    logLevel?: string;
+}
+export interface ServiceConfig {
+    name: string;
+    path: string;
+    runtime?: RuntimeType;
+    detectedRuntime?: RuntimeType;
+    detectionConfidence?: number;
+    detectionSource?: 'legacy' | 'enhanced' | 'explicit';
+    detectionEvidence?: DetectionEvidence;
+    runtimeConfig?: RuntimeSpecificConfig;
+    dockerHost?: string;
+    entry?: string;
+    args?: string[];
+    env?: Record<string, string>;
+    image?: string;
+    ports?: number[];
+    volumes?: string[];
+    workdir?: string;
+    dockerfile?: string;
+    buildContext?: string;
+    build?: boolean;
+    output?: string;
+    binary?: string;
+    trim?: boolean;
+    installedAt?: string;
+    lastDetectedAt?: string;
+    detectionWarning?: string;
+}
+export interface DaemonResponse {
+    success: boolean;
+    message?: string;
+    data?: any;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/core/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/daemon/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Daemon Module Exports
+ * Provides unified interface for daemon functionality
+ */
+export { Orchestrator } from './orchestrator';
+export { IntentEngine } from './intent-engine';
+export { ProcessManager } from './pm';
+export { DaemonServer } from './server';
+export { ServiceManager } from './service';
+//# sourceMappingURL=index.d.ts.map

package/dist/daemon/index.js

@@ -0,0 +1,15 @@
+/**
+ * Daemon Module Exports
+ * Provides unified interface for daemon functionality
+ */
+// Export orchestrator
+export { Orchestrator } from './orchestrator.js';
+// Export intent engine
+export { IntentEngine } from './intent-engine.js';
+// Export process management
+export { ProcessManager } from './pm.js';
+// Export server
+export { DaemonServer } from './server.js';
+// Export service management
+export { ServiceManager } from './service.js';
+//# sourceMappingURL=index.js.map

package/dist/daemon/intent-engine.d.ts

@@ -0,0 +1,22 @@
+export declare class IntentEngine {
+    private availableTools;
+    constructor();
+    parse(query: string): Promise<{
+        tool: string;
+        action: string;
+        params: {
+            path: string;
+            expression?: undefined;
+        };
+    } | {
+        tool: string;
+        action: string;
+        params: {
+            expression: string;
+            path?: undefined;
+        };
+    }>;
+    addTool(tool: any): void;
+    getTools(): any[];
+}
+//# sourceMappingURL=intent-engine.d.ts.map

package/dist/daemon/intent-engine.js

@@ -0,0 +1,50 @@
+export class IntentEngine {
+    availableTools = [];
+    constructor() {
+        // For now, we'll have a simple hardcoded list of tools
+        this.availableTools = [
+            {
+                name: 'filesystem',
+                description: 'Read and list files in a directory',
+                capabilities: ['list_directory', 'read_file'],
+            },
+            {
+                name: 'calculator',
+                description: 'Perform mathematical calculations',
+                capabilities: ['add', 'subtract', 'multiply', 'divide'],
+            },
+        ];
+    }
+    async parse(query) {
+        // Simple keyword matching for now
+        // In a real implementation, this would use vector search and LLM
+        const queryLower = query.toLowerCase();
+        if (queryLower.includes('file') || queryLower.includes('directory') || queryLower.includes('list')) {
+            return {
+                tool: 'filesystem',
+                action: 'list_directory',
+                params: { path: '.' },
+            };
+        }
+        if (queryLower.includes('calculate') || queryLower.includes('math') || queryLower.includes('add') || queryLower.includes('subtract')) {
+            return {
+                tool: 'calculator',
+                action: 'calculate',
+                params: { expression: query },
+            };
+        }
+        // Default fallback
+        return {
+            tool: 'filesystem',
+            action: 'list_directory',
+            params: { path: '.' },
+        };
+    }
+    addTool(tool) {
+        this.availableTools.push(tool);
+    }
+    getTools() {
+        return this.availableTools;
+    }
+}
+//# sourceMappingURL=intent-engine.js.map

package/dist/daemon/orchestrator.d.ts

@@ -0,0 +1,24 @@
+import { ProcessManager } from './pm';
+export declare class Orchestrator {
+    private pm;
+    private intentEngine;
+    private config;
+    constructor(pm: ProcessManager);
+    executeQuery(query: string): Promise<{
+        success: boolean;
+        service: string;
+        method: string;
+        result: any;
+    }>;
+    getConfig(): any;
+    updateAIConfig(newAIConfig: any): {
+        success: boolean;
+        config: import("..").AIConfig;
+        error?: undefined;
+    } | {
+        success: boolean;
+        error: any;
+        config?: undefined;
+    };
+}
+//# sourceMappingURL=orchestrator.d.ts.map

package/dist/daemon/orchestrator.js

@@ -0,0 +1,100 @@
+import { EnhancedIntentEngine } from '../ai/enhanced-intent.js';
+import * as fs from 'fs';
+import { CONFIG_PATH } from '../core/constants.js';
+import { ConfigValidator } from '../core/config-validator.js';
+import { logger } from '../core/logger.js';
+export class Orchestrator {
+    pm;
+    intentEngine;
+    config;
+    constructor(pm) {
+        this.pm = pm;
+        // Load and validate configuration
+        if (fs.existsSync(CONFIG_PATH)) {
+            const rawConfig = JSON.parse(fs.readFileSync(CONFIG_PATH, 'utf-8'));
+            this.config = ConfigValidator.mergeWithDefaults(rawConfig);
+            logger.info('Configuration loaded and validated');
+        }
+        else {
+            this.config = ConfigValidator.getDefaultConfig();
+            logger.warn('Config file not found, using default configuration');
+        }
+        // Check if AI is enabled
+        if (this.config.ai?.enabled !== false) {
+            // Use enhanced AI intent engine
+            this.intentEngine = new EnhancedIntentEngine(this.config.ai);
+            logger.info('AI features enabled (vector database functionality removed)');
+        }
+        else {
+            // AI disabled
+            this.intentEngine = null;
+            logger.info('AI features disabled');
+        }
+    }
+    async executeQuery(query) {
+        logger.info(`Processing query: "${query}"`);
+        // Check if AI is enabled
+        if (!this.intentEngine) {
+            throw new Error('AI features are disabled. Enable AI in configuration to use natural language queries.');
+        }
+        try {
+            // 1. Get all available tools
+            const availableServices = this.pm.getRunningServices();
+            const availableTools = [];
+            for (const service of availableServices) {
+                const tools = this.pm.getServiceTools(service);
+                if (tools) {
+                    availableTools.push(...tools.map((tool) => `${service}:${tool.name}`));
+                }
+            }
+            logger.debug(`Available tools: ${availableTools.join(', ')}`);
+            // 2. Use AI intent engine to parse user intent
+            const toolCall = await this.intentEngine.parse(query, availableTools);
+            if (!toolCall) {
+                throw new Error('Unable to determine which service to use for your request.');
+            }
+            logger.info(`AI selected service: ${toolCall.service}.${toolCall.method}`);
+            // 3. Call the selected service
+            const result = await this.pm.callService(toolCall.service, toolCall.method, toolCall.parameters);
+            return {
+                success: true,
+                service: toolCall.service,
+                method: toolCall.method,
+                result: result,
+            };
+        }
+        catch (error) {
+            logger.error(`Query execution failed: ${error.message}`);
+            // No vector database fallback available
+            throw new Error(`Query failed: ${error.message}. Vector database functionality has been removed.`);
+        }
+    }
+    getConfig() {
+        return this.config;
+    }
+    // Update AI configuration
+    updateAIConfig(newAIConfig) {
+        try {
+            // Validate new AI configuration
+            const validatedConfig = ConfigValidator.validate({ ai: newAIConfig });
+            this.config.ai = validatedConfig.ai;
+            // Update intent engine configuration if it exists
+            if (this.intentEngine) {
+                this.intentEngine.updateConfig(validatedConfig.ai);
+            }
+            // Save to configuration file
+            if (fs.existsSync(CONFIG_PATH)) {
+                const currentConfig = JSON.parse(fs.readFileSync(CONFIG_PATH, 'utf-8'));
+                currentConfig.ai = validatedConfig.ai;
+                fs.writeFileSync(CONFIG_PATH, JSON.stringify(currentConfig, null, 2));
+            }
+            logger.info(`AI configuration updated to provider: ${validatedConfig.ai.provider}`);
+            return { success: true, config: validatedConfig.ai };
+        }
+        catch (error) {
+            logger.error(`Failed to update AI config: ${error.message}`);
+            return { success: false, error: error.message };
+        }
+    }
+}
+//# sourceMappingURL=orchestrator.js.map

package/dist/daemon/pm.d.ts

@@ -0,0 +1,33 @@
+import { EventEmitter } from 'events';
+import { NodeAdapter } from '../runtime/node';
+import { PythonAdapter } from '../runtime/python';
+import { DockerAdapter } from '../runtime/docker';
+export interface ServiceInstance {
+    name: string;
+    runtime: string;
+    path: string;
+    image?: string;
+    adapter: NodeAdapter | PythonAdapter | DockerAdapter | null;
+    status: 'stopped' | 'running' | 'error';
+    error?: string;
+    tools?: any[];
+}
+export declare class ProcessManager extends EventEmitter {
+    private instances;
+    constructor();
+    loadFromConfig(): void;
+    startService(name: string): Promise<void>;
+    discoverTools(name: string): Promise<void>;
+    callService(name: string, method: string, params?: any): Promise<any>;
+    getStatuses(): {
+        name: string;
+        runtime: string;
+        status: "running" | "stopped" | "error";
+        error: string;
+        toolsCount: number;
+    }[];
+    getRunningServices(): string[];
+    getServiceTools(serviceName: string): any[];
+    stopService(name: string): void;
+}
+//# sourceMappingURL=pm.d.ts.map