@mcpilotx/intentorch 0.5.0

package/dist/runtime/adapter-advanced.d.ts

@@ -0,0 +1,184 @@
+/**
+ * Enhanced Runtime Adapter Interface
+ * Balances minimalist style with functional robustness
+ */
+import { ServiceConfig } from '../core/types';
+/**
+ * Process Information
+ */
+export interface ProcessInfo {
+    id: string;
+    pid?: number;
+    status: 'starting' | 'running' | 'stopping' | 'stopped' | 'error';
+    startedAt?: Date;
+    config: ServiceConfig;
+}
+/**
+ * Process Status
+ */
+export interface ProcessStatus {
+    running: boolean;
+    pid?: number;
+    uptime?: number;
+    memory?: number;
+    cpu?: number;
+    exitCode?: number;
+    error?: string;
+}
+/**
+ * Health Status
+ */
+export interface HealthStatus {
+    healthy: boolean;
+    checks: Array<{
+        name: string;
+        status: 'pass' | 'fail' | 'warn';
+        message?: string;
+        duration?: number;
+    }>;
+    score: number;
+}
+/**
+ * Log Options
+ */
+export interface LogOptions {
+    follow?: boolean;
+    tail?: number;
+    since?: Date;
+    until?: Date;
+    filter?: (line: string) => boolean;
+}
+/**
+ * Enhanced Runtime Adapter Interface
+ * Core functionality remains simple, optional features provided through extended interface
+ */
+export interface EnhancedRuntimeAdapter {
+    /**
+     * Start service
+     */
+    start(config: ServiceConfig): Promise<ProcessInfo>;
+    /**
+     * Stop service
+     */
+    stop(processId: string): Promise<void>;
+    /**
+     * Get service status
+     */
+    status(processId: string): Promise<ProcessStatus>;
+    /**
+     * Health check (optional)
+     */
+    healthCheck?(config: ServiceConfig): Promise<HealthStatus>;
+    /**
+     * Get logs (optional)
+     */
+    logs?(processId: string, options?: LogOptions): AsyncIterable<string>;
+    /**
+     * Restart service (optional)
+     */
+    restart?(processId: string): Promise<ProcessInfo>;
+    /**
+     * Pre-start hook
+     */
+    onStart?(config: ServiceConfig): Promise<void>;
+    /**
+     * Post-start hook
+     */
+    onStarted?(processInfo: ProcessInfo): Promise<void>;
+    /**
+     * Pre-stop hook
+     */
+    onStop?(processId: string): Promise<void>;
+    /**
+     * Post-stop hook
+     */
+    onStopped?(processId: string): Promise<void>;
+    /**
+     * Error handling hook
+     */
+    onError?(error: Error, context: any): Promise<void>;
+}
+/**
+ * Adapter Factory Interface
+ */
+export interface RuntimeAdapterFactory {
+    /**
+     * Create adapter instance
+     */
+    create(config: ServiceConfig): EnhancedRuntimeAdapter;
+    /**
+     * Check if runtime type is supported
+     */
+    supports(runtimeType: string): boolean;
+}
+/**
+ * Unified Error Type
+ */
+export declare class RuntimeAdapterError extends Error {
+    code: string;
+    message: string;
+    context?: Record<string, any>;
+    cause?: Error;
+    constructor(code: string, message: string, context?: Record<string, any>, cause?: Error);
+}
+/**
+ * Error Code Enumeration
+ */
+export declare enum RuntimeErrorCode {
+    CONFIG_INVALID = "CONFIG_INVALID",
+    CONFIG_MISSING = "CONFIG_MISSING",
+    PROCESS_START_FAILED = "PROCESS_START_FAILED",
+    PROCESS_STOP_FAILED = "PROCESS_STOP_FAILED",
+    PROCESS_NOT_FOUND = "PROCESS_NOT_FOUND",
+    RUNTIME_NOT_SUPPORTED = "RUNTIME_NOT_SUPPORTED",
+    RUNTIME_NOT_INSTALLED = "RUNTIME_NOT_INSTALLED",
+    RESOURCE_LIMIT_EXCEEDED = "RESOURCE_LIMIT_EXCEEDED",
+    PERMISSION_DENIED = "PERMISSION_DENIED",
+    NETWORK_ERROR = "NETWORK_ERROR",
+    CONNECTION_REFUSED = "CONNECTION_REFUSED",
+    TIMEOUT = "TIMEOUT",
+    UNKNOWN = "UNKNOWN"
+}
+/**
+ * Adapter Registry
+ */
+export declare class RuntimeAdapterRegistry {
+    private static factories;
+    /**
+     * Register adapter factory
+     */
+    static register(runtimeType: string, factory: RuntimeAdapterFactory): void;
+    /**
+     * Get adapter factory
+     */
+    static getFactory(runtimeType: string): RuntimeAdapterFactory | undefined;
+    /**
+     * Create adapter instance
+     */
+    static createAdapter(runtimeType: string, config: ServiceConfig): EnhancedRuntimeAdapter;
+    /**
+     * Get all supported runtime types
+     */
+    static getSupportedRuntimes(): string[];
+}
+/**
+ * Base Adapter Abstract Class
+ * Provides default implementations and utility methods
+ */
+export declare abstract class BaseRuntimeAdapter implements EnhancedRuntimeAdapter {
+    protected processMap: Map<string, ProcessInfo>;
+    abstract start(config: ServiceConfig): Promise<ProcessInfo>;
+    abstract stop(processId: string): Promise<void>;
+    abstract status(processId: string): Promise<ProcessStatus>;
+    healthCheck(config: ServiceConfig): Promise<HealthStatus>;
+    logs(processId: string, options?: LogOptions): AsyncIterable<string>;
+    restart(processId: string): Promise<ProcessInfo>;
+    protected generateProcessId(config: ServiceConfig): string;
+    protected validateConfig(config: ServiceConfig): void;
+    onStart(config: ServiceConfig): Promise<void>;
+    onStarted(processInfo: ProcessInfo): Promise<void>;
+    onStop(processId: string): Promise<void>;
+    onStopped(processId: string): Promise<void>;
+    onError(error: Error, context: any): Promise<void>;
+}
+//# sourceMappingURL=adapter-advanced.d.ts.map

package/dist/runtime/adapter-advanced.js

@@ -0,0 +1,160 @@
+/**
+ * Enhanced Runtime Adapter Interface
+ * Balances minimalist style with functional robustness
+ */
+/**
+ * Unified Error Type
+ */
+export class RuntimeAdapterError extends Error {
+    code;
+    message;
+    context;
+    cause;
+    constructor(code, message, context, cause) {
+        super(message);
+        this.code = code;
+        this.message = message;
+        this.context = context;
+        this.cause = cause;
+        this.name = 'RuntimeAdapterError';
+    }
+}
+/**
+ * Error Code Enumeration
+ */
+export var RuntimeErrorCode;
+(function (RuntimeErrorCode) {
+    // Configuration errors
+    RuntimeErrorCode["CONFIG_INVALID"] = "CONFIG_INVALID";
+    RuntimeErrorCode["CONFIG_MISSING"] = "CONFIG_MISSING";
+    // Process errors
+    RuntimeErrorCode["PROCESS_START_FAILED"] = "PROCESS_START_FAILED";
+    RuntimeErrorCode["PROCESS_STOP_FAILED"] = "PROCESS_STOP_FAILED";
+    RuntimeErrorCode["PROCESS_NOT_FOUND"] = "PROCESS_NOT_FOUND";
+    // Runtime errors
+    RuntimeErrorCode["RUNTIME_NOT_SUPPORTED"] = "RUNTIME_NOT_SUPPORTED";
+    RuntimeErrorCode["RUNTIME_NOT_INSTALLED"] = "RUNTIME_NOT_INSTALLED";
+    // Resource errors
+    RuntimeErrorCode["RESOURCE_LIMIT_EXCEEDED"] = "RESOURCE_LIMIT_EXCEEDED";
+    RuntimeErrorCode["PERMISSION_DENIED"] = "PERMISSION_DENIED";
+    // Network errors
+    RuntimeErrorCode["NETWORK_ERROR"] = "NETWORK_ERROR";
+    RuntimeErrorCode["CONNECTION_REFUSED"] = "CONNECTION_REFUSED";
+    // Timeout errors
+    RuntimeErrorCode["TIMEOUT"] = "TIMEOUT";
+    // Unknown errors
+    RuntimeErrorCode["UNKNOWN"] = "UNKNOWN";
+})(RuntimeErrorCode || (RuntimeErrorCode = {}));
+/**
+ * Adapter Registry
+ */
+export class RuntimeAdapterRegistry {
+    static factories = new Map();
+    /**
+     * Register adapter factory
+     */
+    static register(runtimeType, factory) {
+        this.factories.set(runtimeType, factory);
+    }
+    /**
+     * Get adapter factory
+     */
+    static getFactory(runtimeType) {
+        return this.factories.get(runtimeType);
+    }
+    /**
+     * Create adapter instance
+     */
+    static createAdapter(runtimeType, config) {
+        const factory = this.getFactory(runtimeType);
+        if (!factory) {
+            throw new RuntimeAdapterError(RuntimeErrorCode.RUNTIME_NOT_SUPPORTED, `Runtime type '${runtimeType}' is not supported`, { runtimeType, supportedRuntimes: Array.from(this.factories.keys()) });
+        }
+        return factory.create(config);
+    }
+    /**
+     * Get all supported runtime types
+     */
+    static getSupportedRuntimes() {
+        return Array.from(this.factories.keys());
+    }
+}
+/**
+ * Base Adapter Abstract Class
+ * Provides default implementations and utility methods
+ */
+export class BaseRuntimeAdapter {
+    processMap = new Map();
+    // Default implementations for optional methods
+    async healthCheck(config) {
+        // Default health check: Check if process is running
+        const processes = Array.from(this.processMap.values())
+            .filter(p => p.config.name === config.name);
+        if (processes.length === 0) {
+            return {
+                healthy: false,
+                checks: [{
+                        name: 'process-exists',
+                        status: 'fail',
+                        message: 'No running process found',
+                    }],
+                score: 0,
+            };
+        }
+        const runningProcesses = processes.filter(p => p.status === 'running');
+        return {
+            healthy: runningProcesses.length > 0,
+            checks: [{
+                    name: 'process-running',
+                    status: runningProcesses.length > 0 ? 'pass' : 'fail',
+                    message: runningProcesses.length > 0
+                        ? `${runningProcesses.length} process(es) running`
+                        : 'No running processes',
+                }],
+            score: runningProcesses.length > 0 ? 100 : 0,
+        };
+    }
+    async *logs(processId, options) {
+        // Default implementation: Return empty log stream
+        // Specific adapters should override this method
+        yield `Logs not available for process ${processId}`;
+    }
+    async restart(processId) {
+        // Default implementation: Stop then start
+        const processInfo = this.processMap.get(processId);
+        if (!processInfo) {
+            throw new RuntimeAdapterError(RuntimeErrorCode.PROCESS_NOT_FOUND, `Process ${processId} not found`);
+        }
+        await this.stop(processId);
+        return this.start(processInfo.config);
+    }
+    // Utility methods
+    generateProcessId(config) {
+        return `${config.name}-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+    }
+    validateConfig(config) {
+        if (!config.name || !config.name.trim()) {
+            throw new RuntimeAdapterError(RuntimeErrorCode.CONFIG_INVALID, 'Service name is required', { config });
+        }
+        if (!config.path || !config.path.trim()) {
+            throw new RuntimeAdapterError(RuntimeErrorCode.CONFIG_INVALID, 'Service path is required', { config });
+        }
+    }
+    // Default implementations for lifecycle hooks
+    async onStart(config) {
+        // Default no-op
+    }
+    async onStarted(processInfo) {
+        // Default no-op
+    }
+    async onStop(processId) {
+        // Default no-op
+    }
+    async onStopped(processId) {
+        // Default no-op
+    }
+    async onError(error, context) {
+        console.error('Runtime adapter error:', error, context);
+    }
+}
+//# sourceMappingURL=adapter-advanced.js.map

package/dist/runtime/adapter.d.ts

@@ -0,0 +1,9 @@
+import { ServiceConfig } from '../core/types';
+export interface RuntimeAdapter {
+    getSpawnArgs(config: ServiceConfig): {
+        command: string;
+        args: string[];
+    };
+    setup(config: ServiceConfig): Promise<void>;
+}
+//# sourceMappingURL=adapter.d.ts.map

package/dist/runtime/adapter.js

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

package/dist/runtime/detector-advanced.d.ts

@@ -0,0 +1,59 @@
+import { RuntimeType, DetectionResult } from '../core/types';
+export declare class EnhancedRuntimeDetector {
+    /**
+     * Run both old and new detectors in parallel, select the best result
+     */
+    static detect(servicePath: string): Promise<DetectionResult>;
+    /**
+     * Run traditional detector
+     */
+    private static runLegacyDetector;
+    /**
+     * Run enhanced detection
+     */
+    private static runEnhancedDetection;
+    /**
+     * Analyze executable files
+     */
+    private static analyzeExecutables;
+    /**
+     * Analyze project configuration files
+     */
+    private static analyzeProjectFiles;
+    /**
+     * Analyze file statistics
+     */
+    private static analyzeFileStatistics;
+    /**
+     * Analyze file extensions
+     */
+    private static analyzeFileExtensions;
+    /**
+     * Determine runtime type from evidence
+     */
+    private static determineRuntimeFromEvidence;
+    /**
+     * Generate low confidence warning
+     */
+    private static generateLowConfidenceWarning;
+    /**
+     * Generate runtime suggestions
+     */
+    private static generateRuntimeSuggestions;
+    /**
+     * Find Python configuration files
+     */
+    private static findPythonConfigFiles;
+    /**
+     * Find Java configuration files
+     */
+    private static findJavaConfigFiles;
+    /**
+     * Quick detection (for CLI interaction)
+     */
+    static quickDetect(servicePath: string): {
+        runtime: RuntimeType;
+        confidence: number;
+    };
+}
+//# sourceMappingURL=detector-advanced.d.ts.map