erosolar-cli 1.7.195 → 1.7.196

package/dist/core/unified/errors.d.ts

@@ -0,0 +1,189 @@
+/**
+ * Unified Error Handling
+ *
+ * Structured error system with severity levels, auto-fix capabilities,
+ * and recovery strategies.
+ *
+ * Principal Investigator: Bo Shang
+ * Framework: erosolar-cli
+ */
+import type { ErrorSeverity, ErrorCategory, ErrorSuggestion, StructuredErrorData } from './types.js';
+/**
+ * Base class for all structured errors
+ */
+export declare abstract class StructuredError extends Error {
+    readonly code: string;
+    readonly severity: ErrorSeverity;
+    readonly category: ErrorCategory;
+    readonly suggestions: ErrorSuggestion[];
+    readonly recoverable: boolean;
+    readonly metadata: Record<string, unknown>;
+    readonly timestamp: number;
+    constructor(message: string, options?: {
+        code?: string;
+        severity?: ErrorSeverity;
+        category?: ErrorCategory;
+        suggestions?: ErrorSuggestion[];
+        recoverable?: boolean;
+        metadata?: Record<string, unknown>;
+    });
+    /**
+     * Infer error code from message
+     */
+    protected inferCode(message: string): string;
+    /**
+     * Infer category from message
+     */
+    protected inferCategory(message: string): ErrorCategory;
+    /**
+     * Infer if error is recoverable
+     */
+    protected inferRecoverable(): boolean;
+    /**
+     * Try to auto-fix the error
+     */
+    tryAutoFix(): Promise<{
+        fixed: boolean;
+        result?: unknown;
+        error?: string;
+    }>;
+    /**
+     * Convert to plain object
+     */
+    toJSON(): StructuredErrorData;
+    /**
+     * Format for display
+     */
+    toDisplayString(): string;
+}
+/**
+ * Error for dangerous operations that could cause harm
+ */
+export declare class DangerousOperationError extends StructuredError {
+    readonly operation: string;
+    readonly safeAlternatives: string[];
+    constructor(message: string, operation: string, safeAlternatives?: string[], metadata?: Record<string, unknown>);
+}
+/**
+ * Error for blocked operations due to policy
+ */
+export declare class BlockedOperationError extends StructuredError {
+    readonly operation: string;
+    readonly policy: string;
+    constructor(message: string, operation: string, policy: string, metadata?: Record<string, unknown>);
+}
+/**
+ * Error for validation failures
+ */
+export declare class ValidationError extends StructuredError {
+    readonly field: string;
+    readonly expectedType?: string;
+    readonly actualValue?: unknown;
+    constructor(message: string, field: string, options?: {
+        expectedType?: string;
+        actualValue?: unknown;
+        examples?: string[];
+        metadata?: Record<string, unknown>;
+    });
+}
+/**
+ * Error for resource limits
+ */
+export declare class ResourceLimitError extends StructuredError {
+    readonly resource: string;
+    readonly limit: number;
+    readonly current: number;
+    constructor(message: string, resource: string, limit: number, current: number, metadata?: Record<string, unknown>);
+}
+/**
+ * Error for context overflow
+ */
+export declare class ContextOverflowError extends StructuredError {
+    readonly maxTokens: number;
+    readonly currentTokens: number;
+    readonly truncatable: boolean;
+    constructor(message: string, maxTokens: number, currentTokens: number, truncatable?: boolean, metadata?: Record<string, unknown>);
+}
+/**
+ * Error for provider/API issues
+ */
+export declare class ProviderError extends StructuredError {
+    readonly providerId: string;
+    readonly statusCode?: number;
+    readonly retryable: boolean;
+    constructor(message: string, providerId: string, options?: {
+        statusCode?: number;
+        retryable?: boolean;
+        retryAfterMs?: number;
+        metadata?: Record<string, unknown>;
+    });
+}
+/**
+ * Error for tool execution failures
+ */
+export declare class ToolExecutionError extends StructuredError {
+    readonly toolName: string;
+    readonly phase: 'validation' | 'execution' | 'timeout';
+    constructor(message: string, toolName: string, phase: 'validation' | 'execution' | 'timeout', metadata?: Record<string, unknown>);
+}
+/**
+ * Error for network issues
+ */
+export declare class NetworkError extends StructuredError {
+    readonly url?: string;
+    readonly retryable: boolean;
+    constructor(message: string, options?: {
+        url?: string;
+        retryable?: boolean;
+        metadata?: Record<string, unknown>;
+    });
+}
+export type RecoveryStrategy = 'retry' | 'fallback' | 'skip' | 'abort' | 'prompt_user';
+export interface RecoveryAttempt {
+    strategy: RecoveryStrategy;
+    success: boolean;
+    result?: unknown;
+    error?: string;
+}
+/**
+ * Error recovery manager
+ */
+export declare class ErrorRecoveryManager {
+    private maxRetries;
+    private retryDelayMs;
+    constructor(options?: {
+        maxRetries?: number;
+        retryDelayMs?: number;
+    });
+    /**
+     * Attempt recovery for an error
+     */
+    attemptRecovery(error: StructuredError, strategies: RecoveryStrategy[], context?: {
+        retryFn?: () => Promise<unknown>;
+        fallbackFn?: () => Promise<unknown>;
+    }): Promise<RecoveryAttempt>;
+    /**
+     * Try a specific recovery strategy
+     */
+    private tryStrategy;
+    /**
+     * Retry with exponential backoff
+     */
+    private retryWithBackoff;
+}
+/**
+ * Check if an error is a structured error
+ */
+export declare function isStructuredError(error: unknown): error is StructuredError;
+/**
+ * Wrap any error as a structured error
+ */
+export declare function wrapError(error: unknown, category?: ErrorCategory): StructuredError;
+/**
+ * Create error recovery manager
+ */
+export declare function createErrorRecoveryManager(options?: {
+    maxRetries?: number;
+    retryDelayMs?: number;
+}): ErrorRecoveryManager;
+//# sourceMappingURL=errors.d.ts.map

package/dist/core/unified/errors.d.ts.map

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

package/dist/core/unified/errors.js

@@ -0,0 +1,497 @@
+/**
+ * Unified Error Handling
+ *
+ * Structured error system with severity levels, auto-fix capabilities,
+ * and recovery strategies.
+ *
+ * Principal Investigator: Bo Shang
+ * Framework: erosolar-cli
+ */
+// ============================================================================
+// Base Structured Error
+// ============================================================================
+/**
+ * Base class for all structured errors
+ */
+export class StructuredError extends Error {
+    code;
+    severity;
+    category;
+    suggestions;
+    recoverable;
+    metadata;
+    timestamp;
+    constructor(message, options = {}) {
+        super(message);
+        this.name = this.constructor.name;
+        this.code = options.code || this.inferCode(message);
+        this.severity = options.severity || 'error';
+        this.category = options.category || this.inferCategory(message);
+        this.suggestions = options.suggestions || [];
+        this.recoverable = options.recoverable ?? this.inferRecoverable();
+        this.metadata = options.metadata || {};
+        this.timestamp = Date.now();
+        // Maintain proper stack trace
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, this.constructor);
+        }
+    }
+    /**
+     * Infer error code from message
+     */
+    inferCode(message) {
+        const msgLower = message.toLowerCase();
+        if (msgLower.includes('permission') || msgLower.includes('denied'))
+            return 'PERMISSION_DENIED';
+        if (msgLower.includes('not found') || msgLower.includes('missing'))
+            return 'NOT_FOUND';
+        if (msgLower.includes('timeout'))
+            return 'TIMEOUT';
+        if (msgLower.includes('validation') || msgLower.includes('invalid'))
+            return 'VALIDATION_ERROR';
+        if (msgLower.includes('network') || msgLower.includes('connection'))
+            return 'NETWORK_ERROR';
+        return 'UNKNOWN_ERROR';
+    }
+    /**
+     * Infer category from message
+     */
+    inferCategory(message) {
+        const msgLower = message.toLowerCase();
+        if (msgLower.includes('dangerous') || msgLower.includes('unsafe'))
+            return 'dangerous';
+        if (msgLower.includes('blocked') || msgLower.includes('not allowed'))
+            return 'blocked';
+        if (msgLower.includes('validation') || msgLower.includes('invalid'))
+            return 'validation';
+        if (msgLower.includes('resource') || msgLower.includes('limit'))
+            return 'resource';
+        if (msgLower.includes('context') || msgLower.includes('token'))
+            return 'context';
+        if (msgLower.includes('provider') || msgLower.includes('api'))
+            return 'provider';
+        if (msgLower.includes('tool'))
+            return 'tool';
+        if (msgLower.includes('permission'))
+            return 'permission';
+        if (msgLower.includes('network'))
+            return 'network';
+        return 'unknown';
+    }
+    /**
+     * Infer if error is recoverable
+     */
+    inferRecoverable() {
+        // Most errors are recoverable except critical ones
+        return this.severity !== 'critical';
+    }
+    /**
+     * Try to auto-fix the error
+     */
+    async tryAutoFix() {
+        for (const suggestion of this.suggestions) {
+            if (suggestion.autoFixable && suggestion.fixFn) {
+                try {
+                    const result = await suggestion.fixFn();
+                    if (result) {
+                        return { fixed: true, result };
+                    }
+                }
+                catch (error) {
+                    return { fixed: false, error: String(error) };
+                }
+            }
+        }
+        return { fixed: false };
+    }
+    /**
+     * Convert to plain object
+     */
+    toJSON() {
+        return {
+            code: this.code,
+            message: this.message,
+            severity: this.severity,
+            category: this.category,
+            suggestions: this.suggestions.map((s) => ({
+                action: s.action,
+                description: s.description,
+                autoFixable: s.autoFixable,
+            })),
+            recoverable: this.recoverable,
+            metadata: this.metadata,
+        };
+    }
+    /**
+     * Format for display
+     */
+    toDisplayString() {
+        let str = `[${this.severity.toUpperCase()}] ${this.message}`;
+        if (this.suggestions.length > 0) {
+            str += '\n\nSuggestions:';
+            for (const suggestion of this.suggestions) {
+                str += `\n  - ${suggestion.action}: ${suggestion.description}`;
+            }
+        }
+        return str;
+    }
+}
+// ============================================================================
+// Specific Error Types
+// ============================================================================
+/**
+ * Error for dangerous operations that could cause harm
+ */
+export class DangerousOperationError extends StructuredError {
+    operation;
+    safeAlternatives;
+    constructor(message, operation, safeAlternatives = [], metadata) {
+        super(message, {
+            code: 'DANGEROUS_OPERATION',
+            severity: 'critical',
+            category: 'dangerous',
+            recoverable: false,
+            metadata: { ...metadata, operation, safeAlternatives },
+            suggestions: safeAlternatives.map((alt) => ({
+                action: 'Use safe alternative',
+                description: alt,
+                autoFixable: false,
+            })),
+        });
+        this.operation = operation;
+        this.safeAlternatives = safeAlternatives;
+    }
+}
+/**
+ * Error for blocked operations due to policy
+ */
+export class BlockedOperationError extends StructuredError {
+    operation;
+    policy;
+    constructor(message, operation, policy, metadata) {
+        super(message, {
+            code: 'BLOCKED_OPERATION',
+            severity: 'error',
+            category: 'blocked',
+            recoverable: false,
+            metadata: { ...metadata, operation, policy },
+            suggestions: [
+                {
+                    action: 'Review policy',
+                    description: `This operation is blocked by policy: ${policy}`,
+                    autoFixable: false,
+                },
+            ],
+        });
+        this.operation = operation;
+        this.policy = policy;
+    }
+}
+/**
+ * Error for validation failures
+ */
+export class ValidationError extends StructuredError {
+    field;
+    expectedType;
+    actualValue;
+    constructor(message, field, options) {
+        const suggestions = [];
+        if (options?.expectedType) {
+            suggestions.push({
+                action: 'Fix type',
+                description: `Expected type: ${options.expectedType}`,
+                autoFixable: false,
+            });
+        }
+        if (options?.examples) {
+            suggestions.push({
+                action: 'See examples',
+                description: options.examples.join(', '),
+                autoFixable: false,
+            });
+        }
+        super(message, {
+            code: 'VALIDATION_ERROR',
+            severity: 'error',
+            category: 'validation',
+            recoverable: true,
+            metadata: { ...options?.metadata, field, expectedType: options?.expectedType },
+            suggestions,
+        });
+        this.field = field;
+        this.expectedType = options?.expectedType;
+        this.actualValue = options?.actualValue;
+    }
+}
+/**
+ * Error for resource limits
+ */
+export class ResourceLimitError extends StructuredError {
+    resource;
+    limit;
+    current;
+    constructor(message, resource, limit, current, metadata) {
+        super(message, {
+            code: 'RESOURCE_LIMIT',
+            severity: 'error',
+            category: 'resource',
+            recoverable: true,
+            metadata: { ...metadata, resource, limit, current },
+            suggestions: [
+                {
+                    action: 'Reduce usage',
+                    description: `Current: ${current}, Limit: ${limit}`,
+                    autoFixable: false,
+                },
+            ],
+        });
+        this.resource = resource;
+        this.limit = limit;
+        this.current = current;
+    }
+}
+/**
+ * Error for context overflow
+ */
+export class ContextOverflowError extends StructuredError {
+    maxTokens;
+    currentTokens;
+    truncatable;
+    constructor(message, maxTokens, currentTokens, truncatable = true, metadata) {
+        const suggestions = [];
+        if (truncatable) {
+            suggestions.push({
+                action: 'Truncate context',
+                description: 'Older messages can be removed to free up space',
+                autoFixable: true,
+            });
+        }
+        suggestions.push({
+            action: 'Reduce input',
+            description: `Reduce input size by ${currentTokens - maxTokens} tokens`,
+            autoFixable: false,
+        });
+        super(message, {
+            code: 'CONTEXT_OVERFLOW',
+            severity: 'warning',
+            category: 'context',
+            recoverable: truncatable,
+            metadata: { ...metadata, maxTokens, currentTokens },
+            suggestions,
+        });
+        this.maxTokens = maxTokens;
+        this.currentTokens = currentTokens;
+        this.truncatable = truncatable;
+    }
+}
+/**
+ * Error for provider/API issues
+ */
+export class ProviderError extends StructuredError {
+    providerId;
+    statusCode;
+    retryable;
+    constructor(message, providerId, options) {
+        const retryable = options?.retryable ?? (options?.statusCode ? options.statusCode >= 500 : false);
+        const suggestions = [];
+        if (retryable) {
+            suggestions.push({
+                action: 'Retry',
+                description: options?.retryAfterMs
+                    ? `Retry after ${options.retryAfterMs}ms`
+                    : 'Retry the request',
+                autoFixable: true,
+            });
+        }
+        super(message, {
+            code: 'PROVIDER_ERROR',
+            severity: options?.statusCode === 500 ? 'error' : 'warning',
+            category: 'provider',
+            recoverable: retryable,
+            metadata: { ...options?.metadata, providerId, statusCode: options?.statusCode },
+            suggestions,
+        });
+        this.providerId = providerId;
+        this.statusCode = options?.statusCode;
+        this.retryable = retryable;
+    }
+}
+/**
+ * Error for tool execution failures
+ */
+export class ToolExecutionError extends StructuredError {
+    toolName;
+    phase;
+    constructor(message, toolName, phase, metadata) {
+        const suggestions = [];
+        if (phase === 'validation') {
+            suggestions.push({
+                action: 'Fix arguments',
+                description: 'Check the tool arguments match the expected schema',
+                autoFixable: false,
+            });
+        }
+        else if (phase === 'timeout') {
+            suggestions.push({
+                action: 'Increase timeout',
+                description: 'The operation took too long - try increasing the timeout',
+                autoFixable: false,
+            });
+        }
+        super(message, {
+            code: 'TOOL_EXECUTION_ERROR',
+            severity: phase === 'timeout' ? 'warning' : 'error',
+            category: 'tool',
+            recoverable: phase !== 'validation',
+            metadata: { ...metadata, toolName, phase },
+            suggestions,
+        });
+        this.toolName = toolName;
+        this.phase = phase;
+    }
+}
+/**
+ * Error for network issues
+ */
+export class NetworkError extends StructuredError {
+    url;
+    retryable;
+    constructor(message, options) {
+        super(message, {
+            code: 'NETWORK_ERROR',
+            severity: 'error',
+            category: 'network',
+            recoverable: options?.retryable ?? true,
+            metadata: { ...options?.metadata, url: options?.url },
+            suggestions: [
+                {
+                    action: 'Check connection',
+                    description: 'Verify network connectivity',
+                    autoFixable: false,
+                },
+                {
+                    action: 'Retry',
+                    description: 'The request can be retried',
+                    autoFixable: true,
+                },
+            ],
+        });
+        this.url = options?.url;
+        this.retryable = options?.retryable ?? true;
+    }
+}
+/**
+ * Error recovery manager
+ */
+export class ErrorRecoveryManager {
+    maxRetries;
+    retryDelayMs;
+    constructor(options) {
+        this.maxRetries = options?.maxRetries ?? 3;
+        this.retryDelayMs = options?.retryDelayMs ?? 1000;
+    }
+    /**
+     * Attempt recovery for an error
+     */
+    async attemptRecovery(error, strategies, context) {
+        for (const strategy of strategies) {
+            const result = await this.tryStrategy(error, strategy, context);
+            if (result.success) {
+                return result;
+            }
+        }
+        return { strategy: 'abort', success: false, error: 'All recovery strategies failed' };
+    }
+    /**
+     * Try a specific recovery strategy
+     */
+    async tryStrategy(error, strategy, context) {
+        switch (strategy) {
+            case 'retry':
+                if (!context?.retryFn) {
+                    return { strategy, success: false, error: 'No retry function provided' };
+                }
+                return this.retryWithBackoff(context.retryFn);
+            case 'fallback':
+                if (!context?.fallbackFn) {
+                    return { strategy, success: false, error: 'No fallback function provided' };
+                }
+                try {
+                    const result = await context.fallbackFn();
+                    return { strategy, success: true, result };
+                }
+                catch (e) {
+                    return { strategy, success: false, error: String(e) };
+                }
+            case 'skip':
+                return { strategy, success: true };
+            case 'abort':
+                return { strategy, success: false, error: error.message };
+            case 'prompt_user':
+                return { strategy, success: false, error: 'User intervention required' };
+            default:
+                return { strategy, success: false, error: 'Unknown strategy' };
+        }
+    }
+    /**
+     * Retry with exponential backoff
+     */
+    async retryWithBackoff(fn) {
+        let lastError;
+        for (let attempt = 0; attempt < this.maxRetries; attempt++) {
+            try {
+                const result = await fn();
+                return { strategy: 'retry', success: true, result };
+            }
+            catch (e) {
+                lastError = e;
+                const delay = this.retryDelayMs * Math.pow(2, attempt);
+                await new Promise((resolve) => setTimeout(resolve, delay));
+            }
+        }
+        return {
+            strategy: 'retry',
+            success: false,
+            error: lastError?.message || 'Max retries exceeded',
+        };
+    }
+}
+// ============================================================================
+// Utility Functions
+// ============================================================================
+/**
+ * Check if an error is a structured error
+ */
+export function isStructuredError(error) {
+    return error instanceof StructuredError;
+}
+/**
+ * Wrap any error as a structured error
+ */
+export function wrapError(error, category) {
+    if (isStructuredError(error)) {
+        return error;
+    }
+    if (error instanceof Error) {
+        const errMessage = error.message;
+        const errStack = error.stack;
+        return new (class extends StructuredError {
+            constructor() {
+                super(errMessage, { category });
+                this.stack = errStack;
+            }
+        })();
+    }
+    return new (class extends StructuredError {
+        constructor() {
+            super(String(error), { category });
+        }
+    })();
+}
+/**
+ * Create error recovery manager
+ */
+export function createErrorRecoveryManager(options) {
+    return new ErrorRecoveryManager(options);
+}
+//# sourceMappingURL=errors.js.map