@vfarcic/dot-ai 0.1.0

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

@@ -0,0 +1,167 @@
+/**
+ * Comprehensive Error Handling System for DevOps AI Toolkit
+ *
+ * Provides centralized error handling, logging, and context management
+ * with support for MCP protocol, CLI operations, and core functionality.
+ */
+import { McpError } from '@modelcontextprotocol/sdk/types.js';
+/**
+ * Error categories for systematic error classification
+ */
+export declare enum ErrorCategory {
+    KUBERNETES = "kubernetes",
+    NETWORK = "network",
+    AUTHENTICATION = "authentication",
+    AUTHORIZATION = "authorization",
+    VALIDATION = "validation",
+    CONFIGURATION = "configuration",
+    OPERATION = "operation",
+    AI_SERVICE = "ai_service",
+    STORAGE = "storage",
+    MCP_PROTOCOL = "mcp_protocol",
+    CLI_INTERFACE = "cli_interface",
+    INTERNAL = "internal",
+    UNKNOWN = "unknown"
+}
+/**
+ * Error severity levels
+ */
+export declare enum ErrorSeverity {
+    LOW = "low",// Non-critical, operation can continue
+    MEDIUM = "medium",// Important but recoverable
+    HIGH = "high",// Significant impact, requires attention
+    CRITICAL = "critical"
+}
+/**
+ * Error context interface for comprehensive error tracking
+ */
+export interface ErrorContext {
+    operation: string;
+    component: string;
+    userId?: string;
+    sessionId?: string;
+    requestId?: string;
+    timestamp: Date;
+    version: string;
+    input?: any;
+    parameters?: Record<string, any>;
+    originalError?: Error;
+    stackTrace?: string;
+    suggestedActions?: string[];
+    isRetryable?: boolean;
+    retryCount?: number;
+}
+/**
+ * Structured error interface
+ */
+export interface AppError {
+    id: string;
+    code: string;
+    category: ErrorCategory;
+    severity: ErrorSeverity;
+    message: string;
+    userMessage?: string;
+    technicalDetails?: string;
+    context: ErrorContext;
+    timestamp: Date;
+    suggestedActions: string[];
+    isRetryable: boolean;
+    cause?: AppError;
+}
+/**
+ * Log levels for structured logging
+ */
+export declare enum LogLevel {
+    DEBUG = "debug",
+    INFO = "info",
+    WARN = "warn",
+    ERROR = "error",
+    FATAL = "fatal"
+}
+/**
+ * Structured log entry interface
+ */
+export interface LogEntry {
+    level: LogLevel;
+    timestamp: Date;
+    message: string;
+    component: string;
+    operation?: string;
+    requestId?: string;
+    sessionId?: string;
+    data?: any;
+    error?: AppError;
+    duration?: number;
+}
+/**
+ * Logger interface for dependency injection
+ */
+export interface Logger {
+    debug(message: string, data?: any): void;
+    info(message: string, data?: any): void;
+    warn(message: string, data?: any): void;
+    error(message: string, error?: Error | AppError, data?: any): void;
+    fatal(message: string, error?: Error | AppError, data?: any): void;
+}
+/**
+ * Default console logger implementation
+ */
+export declare class ConsoleLogger implements Logger {
+    private component;
+    private minLevel;
+    constructor(component: string, minLevel?: LogLevel);
+    private shouldLog;
+    private formatMessage;
+    debug(message: string, data?: any): void;
+    info(message: string, data?: any): void;
+    warn(message: string, data?: any): void;
+    error(message: string, error?: Error | AppError, data?: any): void;
+    fatal(message: string, error?: Error | AppError, data?: any): void;
+    private serializeError;
+}
+/**
+ * Error handler factory and utilities
+ */
+export declare class ErrorHandler {
+    private static requestIdCounter;
+    private static logger;
+    /**
+     * Set custom logger implementation
+     */
+    static setLogger(logger: Logger): void;
+    /**
+     * Generate unique request ID
+     */
+    static generateRequestId(): string;
+    /**
+     * Create comprehensive AppError from various error sources
+     */
+    static createError(category: ErrorCategory, severity: ErrorSeverity, message: string, context: Partial<ErrorContext>, originalError?: Error): AppError;
+    /**
+     * Convert AppError to McpError for MCP protocol
+     */
+    static toMcpError(appError: AppError): McpError;
+    /**
+     * Handle error with automatic logging and context enhancement
+     */
+    static handleError(error: Error | AppError, context: Partial<ErrorContext>, options?: {
+        rethrow?: boolean;
+        convertToMcp?: boolean;
+        logLevel?: LogLevel;
+    }): AppError | McpError;
+    /**
+     * Wrap operation with error handling
+     */
+    static withErrorHandling<T>(operation: () => Promise<T>, context: Partial<ErrorContext>, options?: {
+        retryCount?: number;
+        convertToMcp?: boolean;
+    }): Promise<T>;
+    private static generateErrorCode;
+    private static mapToMcpErrorCode;
+    private static categorizeError;
+    private static assessSeverity;
+    private static getUserFriendlyMessage;
+    private static getDefaultSuggestedActions;
+    private static wrapNativeError;
+}
+//# sourceMappingURL=error-handling.d.ts.map

package/dist/core/error-handling.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"error-handling.d.ts","sourceRoot":"","sources":["../../src/core/error-handling.ts"],"names":[],"mappings":"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"}

package/dist/core/error-handling.js

@@ -0,0 +1,399 @@
+"use strict";
+/**
+ * Comprehensive Error Handling System for DevOps AI Toolkit
+ *
+ * Provides centralized error handling, logging, and context management
+ * with support for MCP protocol, CLI operations, and core functionality.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ErrorHandler = exports.ConsoleLogger = exports.LogLevel = exports.ErrorSeverity = exports.ErrorCategory = void 0;
+const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
+/**
+ * Error categories for systematic error classification
+ */
+var ErrorCategory;
+(function (ErrorCategory) {
+    // Infrastructure errors
+    ErrorCategory["KUBERNETES"] = "kubernetes";
+    ErrorCategory["NETWORK"] = "network";
+    ErrorCategory["AUTHENTICATION"] = "authentication";
+    ErrorCategory["AUTHORIZATION"] = "authorization";
+    // Application errors
+    ErrorCategory["VALIDATION"] = "validation";
+    ErrorCategory["CONFIGURATION"] = "configuration";
+    ErrorCategory["OPERATION"] = "operation";
+    // External service errors
+    ErrorCategory["AI_SERVICE"] = "ai_service";
+    ErrorCategory["STORAGE"] = "storage";
+    // Protocol errors
+    ErrorCategory["MCP_PROTOCOL"] = "mcp_protocol";
+    ErrorCategory["CLI_INTERFACE"] = "cli_interface";
+    // System errors
+    ErrorCategory["INTERNAL"] = "internal";
+    ErrorCategory["UNKNOWN"] = "unknown";
+})(ErrorCategory || (exports.ErrorCategory = ErrorCategory = {}));
+/**
+ * Error severity levels
+ */
+var ErrorSeverity;
+(function (ErrorSeverity) {
+    ErrorSeverity["LOW"] = "low";
+    ErrorSeverity["MEDIUM"] = "medium";
+    ErrorSeverity["HIGH"] = "high";
+    ErrorSeverity["CRITICAL"] = "critical"; // System-threatening, immediate action required
+})(ErrorSeverity || (exports.ErrorSeverity = ErrorSeverity = {}));
+/**
+ * Log levels for structured logging
+ */
+var LogLevel;
+(function (LogLevel) {
+    LogLevel["DEBUG"] = "debug";
+    LogLevel["INFO"] = "info";
+    LogLevel["WARN"] = "warn";
+    LogLevel["ERROR"] = "error";
+    LogLevel["FATAL"] = "fatal";
+})(LogLevel || (exports.LogLevel = LogLevel = {}));
+/**
+ * Default console logger implementation
+ */
+class ConsoleLogger {
+    component;
+    minLevel;
+    constructor(component, minLevel = LogLevel.INFO) {
+        this.component = component;
+        this.minLevel = minLevel;
+    }
+    shouldLog(level) {
+        const levels = [LogLevel.DEBUG, LogLevel.INFO, LogLevel.WARN, LogLevel.ERROR, LogLevel.FATAL];
+        return levels.indexOf(level) >= levels.indexOf(this.minLevel);
+    }
+    formatMessage(level, message, data) {
+        const timestamp = new Date().toISOString();
+        const baseMessage = `[${timestamp}] ${level.toUpperCase()} [${this.component}] ${message}`;
+        if (data) {
+            return `${baseMessage} ${JSON.stringify(data, null, 2)}`;
+        }
+        return baseMessage;
+    }
+    debug(message, data) {
+        if (this.shouldLog(LogLevel.DEBUG)) {
+            console.debug(this.formatMessage(LogLevel.DEBUG, message, data));
+        }
+    }
+    info(message, data) {
+        if (this.shouldLog(LogLevel.INFO)) {
+            console.info(this.formatMessage(LogLevel.INFO, message, data));
+        }
+    }
+    warn(message, data) {
+        if (this.shouldLog(LogLevel.WARN)) {
+            console.warn(this.formatMessage(LogLevel.WARN, message, data));
+        }
+    }
+    error(message, error, data) {
+        if (this.shouldLog(LogLevel.ERROR)) {
+            const errorData = error ? { error: this.serializeError(error), ...data } : data;
+            console.error(this.formatMessage(LogLevel.ERROR, message, errorData));
+        }
+    }
+    fatal(message, error, data) {
+        if (this.shouldLog(LogLevel.FATAL)) {
+            const errorData = error ? { error: this.serializeError(error), ...data } : data;
+            console.error(this.formatMessage(LogLevel.FATAL, message, errorData));
+        }
+    }
+    serializeError(error) {
+        if ('category' in error) {
+            // AppError
+            return {
+                id: error.id,
+                code: error.code,
+                category: error.category,
+                severity: error.severity,
+                message: error.message,
+                context: error.context
+            };
+        }
+        else {
+            // Native Error
+            return {
+                name: error.name,
+                message: error.message,
+                stack: error.stack
+            };
+        }
+    }
+}
+exports.ConsoleLogger = ConsoleLogger;
+/**
+ * Error handler factory and utilities
+ */
+class ErrorHandler {
+    static requestIdCounter = 0;
+    static logger = new ConsoleLogger('ErrorHandler');
+    /**
+     * Set custom logger implementation
+     */
+    static setLogger(logger) {
+        this.logger = logger;
+    }
+    /**
+     * Generate unique request ID
+     */
+    static generateRequestId() {
+        return `req_${Date.now()}_${++this.requestIdCounter}`;
+    }
+    /**
+     * Create comprehensive AppError from various error sources
+     */
+    static createError(category, severity, message, context, originalError) {
+        const errorId = `err_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+        const timestamp = new Date();
+        const fullContext = {
+            operation: context.operation || 'unknown',
+            component: context.component || 'unknown',
+            timestamp,
+            version: process.env.npm_package_version || '0.1.0',
+            originalError,
+            stackTrace: originalError?.stack || new Error().stack,
+            isRetryable: context.isRetryable || false,
+            retryCount: context.retryCount || 0,
+            ...context
+        };
+        const suggestedActions = context.suggestedActions || this.getDefaultSuggestedActions(category);
+        const appError = {
+            id: errorId,
+            code: this.generateErrorCode(category, severity),
+            category,
+            severity,
+            message,
+            userMessage: this.getUserFriendlyMessage(category),
+            technicalDetails: originalError?.message,
+            context: fullContext,
+            timestamp,
+            suggestedActions,
+            isRetryable: fullContext.isRetryable || false,
+            // Don't wrap the original error to prevent circular references
+            cause: undefined
+        };
+        // Log the error
+        this.logger.error(`Error created: ${message}`, appError, {
+            category,
+            severity,
+            operation: fullContext.operation,
+            component: fullContext.component
+        });
+        return appError;
+    }
+    /**
+     * Convert AppError to McpError for MCP protocol
+     */
+    static toMcpError(appError) {
+        const errorCode = this.mapToMcpErrorCode(appError.category);
+        const message = `${appError.message}${appError.technicalDetails ? ` - ${appError.technicalDetails}` : ''}`;
+        return new types_js_1.McpError(errorCode, message);
+    }
+    /**
+     * Handle error with automatic logging and context enhancement
+     */
+    static handleError(error, context, options = {}) {
+        let appError;
+        if ('category' in error) {
+            // Already an AppError
+            appError = error;
+        }
+        else {
+            // Convert native Error to AppError
+            appError = this.createError(this.categorizeError(error), this.assessSeverity(error), error.message, context, error);
+        }
+        // Log the handled error
+        const logLevel = options.logLevel || LogLevel.ERROR;
+        this.logger[logLevel](`Error handled in ${context.component || 'unknown'}`, appError);
+        if (options.convertToMcp) {
+            const mcpError = this.toMcpError(appError);
+            if (options.rethrow) {
+                throw mcpError;
+            }
+            return mcpError;
+        }
+        if (options.rethrow) {
+            throw appError;
+        }
+        return appError;
+    }
+    /**
+     * Wrap operation with error handling
+     */
+    static async withErrorHandling(operation, context, options = {}) {
+        const maxRetries = options.retryCount || 0;
+        let lastError;
+        for (let attempt = 0; attempt <= maxRetries; attempt++) {
+            try {
+                this.logger.debug(`Executing operation: ${context.operation}`, {
+                    attempt: attempt + 1,
+                    maxRetries: maxRetries + 1
+                });
+                return await operation();
+            }
+            catch (error) {
+                lastError = error;
+                const enhancedContext = {
+                    ...context,
+                    retryCount: attempt,
+                    isRetryable: attempt < maxRetries
+                };
+                const appError = this.handleError(lastError, enhancedContext, {
+                    logLevel: attempt < maxRetries ? LogLevel.WARN : LogLevel.ERROR
+                });
+                // Retry if we haven't exceeded max retries and the error is retryable
+                // For retry logic, we consider errors retryable by default unless explicitly marked as not retryable
+                const shouldRetry = attempt < maxRetries && (appError.isRetryable || enhancedContext.isRetryable);
+                if (shouldRetry) {
+                    this.logger.info(`Retrying operation: ${context.operation}`, {
+                        attempt: attempt + 1,
+                        maxRetries: maxRetries + 1,
+                        reason: appError.message
+                    });
+                    continue;
+                }
+                // Final attempt failed or not retryable
+                if (options.convertToMcp) {
+                    throw this.toMcpError(appError);
+                }
+                throw appError;
+            }
+        }
+        // This should never be reached, but TypeScript requires it
+        throw lastError;
+    }
+    static generateErrorCode(category, severity) {
+        const categoryCode = category.toUpperCase().replace('_', '');
+        const severityCode = severity.charAt(0).toUpperCase();
+        const timestamp = Date.now().toString().slice(-6);
+        const random = Math.random().toString(36).substring(2, 5);
+        return `${categoryCode}_${severityCode}_${timestamp}_${random}`;
+    }
+    static mapToMcpErrorCode(category) {
+        switch (category) {
+            case ErrorCategory.VALIDATION:
+                return types_js_1.ErrorCode.InvalidParams;
+            case ErrorCategory.AUTHENTICATION:
+            case ErrorCategory.AUTHORIZATION:
+                return types_js_1.ErrorCode.InvalidParams;
+            case ErrorCategory.MCP_PROTOCOL:
+                return types_js_1.ErrorCode.MethodNotFound;
+            case ErrorCategory.OPERATION:
+            case ErrorCategory.CLI_INTERFACE:
+                return types_js_1.ErrorCode.InvalidRequest;
+            default:
+                return types_js_1.ErrorCode.InternalError;
+        }
+    }
+    static categorizeError(error) {
+        const message = error.message.toLowerCase();
+        if (message.includes('kubeconfig') || message.includes('kubernetes')) {
+            return ErrorCategory.KUBERNETES;
+        }
+        if (message.includes('network') || message.includes('connection')) {
+            return ErrorCategory.NETWORK;
+        }
+        if (message.includes('authentication') || message.includes('unauthorized')) {
+            return ErrorCategory.AUTHENTICATION;
+        }
+        if (message.includes('anthropic') || message.includes('ai') || message.includes('claude') || message.includes('api key invalid')) {
+            return ErrorCategory.AI_SERVICE;
+        }
+        if (message.includes('validation') || message.includes('invalid')) {
+            return ErrorCategory.VALIDATION;
+        }
+        return ErrorCategory.UNKNOWN;
+    }
+    static assessSeverity(error) {
+        const message = error.message.toLowerCase();
+        if (message.includes('critical') || message.includes('fatal')) {
+            return ErrorSeverity.CRITICAL;
+        }
+        if (message.includes('authentication') || message.includes('authorization')) {
+            return ErrorSeverity.HIGH;
+        }
+        if (message.includes('validation') || message.includes('invalid')) {
+            return ErrorSeverity.MEDIUM;
+        }
+        return ErrorSeverity.LOW;
+    }
+    static getUserFriendlyMessage(category) {
+        switch (category) {
+            case ErrorCategory.KUBERNETES:
+                return 'Unable to connect to Kubernetes cluster. Please check your kubeconfig and cluster connectivity.';
+            case ErrorCategory.AUTHENTICATION:
+                return 'Authentication failed. Please verify your credentials.';
+            case ErrorCategory.VALIDATION:
+                return 'Input validation failed. Please check your parameters and try again.';
+            case ErrorCategory.AI_SERVICE:
+                return 'AI service is temporarily unavailable. Please try again later.';
+            default:
+                return 'An unexpected error occurred. Please try again or contact support.';
+        }
+    }
+    static getDefaultSuggestedActions(category) {
+        switch (category) {
+            case ErrorCategory.KUBERNETES:
+                return [
+                    'Verify kubeconfig file exists and is valid',
+                    'Check cluster connectivity with kubectl cluster-info',
+                    'Ensure proper authentication credentials'
+                ];
+            case ErrorCategory.VALIDATION:
+                return [
+                    'Review input parameters for correct format',
+                    'Check required fields are provided',
+                    'Verify data types match expected schema'
+                ];
+            case ErrorCategory.AI_SERVICE:
+                return [
+                    'Check ANTHROPIC_API_KEY environment variable',
+                    'Verify API key is valid and has sufficient credits',
+                    'Try again after a short delay'
+                ];
+            default:
+                return [
+                    'Try the operation again',
+                    'Check system logs for more details',
+                    'Contact support if problem persists'
+                ];
+        }
+    }
+    static wrapNativeError(error) {
+        const errorId = `err_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+        const timestamp = new Date();
+        const category = this.categorizeError(error);
+        const severity = this.assessSeverity(error);
+        const context = {
+            operation: 'error_wrapping',
+            component: 'ErrorHandler',
+            timestamp,
+            version: process.env.npm_package_version || '0.1.0',
+            originalError: error,
+            stackTrace: error.stack,
+            isRetryable: false,
+            retryCount: 0
+        };
+        const appError = {
+            id: errorId,
+            code: this.generateErrorCode(category, severity),
+            category,
+            severity,
+            message: error.message,
+            userMessage: this.getUserFriendlyMessage(category),
+            technicalDetails: error.message,
+            context,
+            timestamp,
+            suggestedActions: this.getDefaultSuggestedActions(category),
+            isRetryable: false,
+            // No cause to prevent circular reference
+            cause: undefined
+        };
+        return appError;
+    }
+}
+exports.ErrorHandler = ErrorHandler;

package/dist/core/index.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Core Intelligence Module
+ *
+ * Shared intelligence for both CLI and MCP interfaces
+ */
+import { KubernetesDiscovery } from './discovery';
+import { MemorySystem } from './memory';
+import { WorkflowEngine } from './workflow';
+import { ClaudeIntegration } from './claude';
+import { SchemaParser, ManifestValidator, ResourceRecommender } from './schema';
+export interface CoreConfig {
+    kubernetesConfig?: string;
+    anthropicApiKey?: string;
+}
+export declare class DotAI {
+    private config;
+    private initialized;
+    readonly discovery: KubernetesDiscovery;
+    readonly memory: MemorySystem;
+    readonly workflow: WorkflowEngine;
+    readonly claude: ClaudeIntegration;
+    readonly schema: {
+        parser: SchemaParser;
+        validator: ManifestValidator;
+        ranker: ResourceRecommender | null;
+        parseResource: (resourceName: string) => Promise<any>;
+        rankResources: (intent: string) => Promise<any>;
+    };
+    constructor(config?: CoreConfig);
+    private validateConfig;
+    initialize(): Promise<void>;
+    isInitialized(): boolean;
+    getVersion(): string;
+    getAnthropicApiKey(): string | undefined;
+}
+export { KubernetesDiscovery } from './discovery';
+export { MemorySystem } from './memory';
+export { WorkflowEngine } from './workflow';
+export { ClaudeIntegration } from './claude';
+export { SchemaParser, ManifestValidator, ResourceRecommender } from './schema';
+export default DotAI;
+//# sourceMappingURL=index.d.ts.map

package/dist/core/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/core/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAClD,OAAO,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AACxC,OAAO,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAC5C,OAAO,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAC7C,OAAO,EAAE,YAAY,EAAE,iBAAiB,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAC;AAEhF,MAAM,WAAW,UAAU;IACzB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED,qBAAa,KAAK;IAChB,OAAO,CAAC,MAAM,CAAa;IAC3B,OAAO,CAAC,WAAW,CAAkB;IAErC,SAAgB,SAAS,EAAE,mBAAmB,CAAC;IAC/C,SAAgB,MAAM,EAAE,YAAY,CAAC;IACrC,SAAgB,QAAQ,EAAE,cAAc,CAAC;IACzC,SAAgB,MAAM,EAAE,iBAAiB,CAAC;IAC1C,SAAgB,MAAM,EAAE;QACtB,MAAM,EAAE,YAAY,CAAC;QACrB,SAAS,EAAE,iBAAiB,CAAC;QAC7B,MAAM,EAAE,mBAAmB,GAAG,IAAI,CAAC;QACnC,aAAa,EAAE,CAAC,YAAY,EAAE,MAAM,KAAK,OAAO,CAAC,GAAG,CAAC,CAAC;QACtD,aAAa,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,OAAO,CAAC,GAAG,CAAC,CAAC;KACjD,CAAC;gBAEU,MAAM,GAAE,UAAe;IAoEnC,OAAO,CAAC,cAAc;IAMhB,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAcjC,aAAa,IAAI,OAAO;IAIxB,UAAU,IAAI,MAAM;IAIpB,kBAAkB,IAAI,MAAM,GAAG,SAAS;CAGzC;AAGD,OAAO,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAClD,OAAO,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AACxC,OAAO,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAC5C,OAAO,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAC7C,OAAO,EAAE,YAAY,EAAE,iBAAiB,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAC;AAGhF,eAAe,KAAK,CAAC"}