@flowdot.ai/daemon 1.0.0

package/dist/goals/ErrorRecovery.js

@@ -0,0 +1,489 @@
+import { EventEmitter } from 'node:events';
+import { GoalError } from './errors.js';
+const noopLogger = {
+    debug: () => { },
+    info: () => { },
+    warn: () => { },
+    error: () => { },
+};
+const DEFAULT_RETRY_CONFIG = {
+    maxAttempts: 3,
+    baseDelayMs: 1000,
+    multiplier: 2,
+    maxDelayMs: 30000,
+    jitter: 0.1,
+};
+const DEFAULT_MAX_CHECKPOINTS = 10;
+const DEFAULT_ESCALATE_THRESHOLD = 3;
+const TRANSIENT_ERROR_PATTERNS = [
+    /timeout/i,
+    /connection refused/i,
+    /network/i,
+    /temporary/i,
+    /retry/i,
+    /rate limit/i,
+    /429/,
+    /503/,
+    /ETIMEDOUT/,
+    /ECONNRESET/,
+    /ECONNREFUSED/,
+];
+const PERMISSION_ERROR_PATTERNS = [
+    /permission denied/i,
+    /access denied/i,
+    /unauthorized/i,
+    /forbidden/i,
+    /401/,
+    /403/,
+];
+const RESOURCE_ERROR_PATTERNS = [
+    /not found/i,
+    /does not exist/i,
+    /no such file/i,
+    /404/,
+    /ENOENT/,
+];
+export class ErrorRecoveryError extends GoalError {
+    constructor(message, cause) {
+        super('RECOVERY_ERROR', message, cause ? { cause } : {});
+    }
+}
+export class CheckpointNotFoundError extends GoalError {
+    checkpointId;
+    constructor(checkpointId) {
+        super('CHECKPOINT_NOT_FOUND', `Checkpoint not found: ${checkpointId}`);
+        this.checkpointId = checkpointId;
+    }
+}
+export class ErrorRecovery extends EventEmitter {
+    logger;
+    retryConfig;
+    maxCheckpointsPerGoal;
+    autoRetryTransient;
+    escalateThreshold;
+    checkpoints = new Map();
+    failureCounts = new Map();
+    retryState = new Map();
+    constructor(options = {}) {
+        super();
+        this.logger = options.logger ?? noopLogger;
+        this.retryConfig = { ...DEFAULT_RETRY_CONFIG, ...options.retryConfig };
+        this.maxCheckpointsPerGoal = options.maxCheckpointsPerGoal ?? DEFAULT_MAX_CHECKPOINTS;
+        this.autoRetryTransient = options.autoRetryTransient ?? true;
+        this.escalateThreshold = options.escalateThreshold ?? DEFAULT_ESCALATE_THRESHOLD;
+    }
+    createCheckpoint(goal, task, state, description) {
+        const checkpoint = {
+            id: this.generateCheckpointId(),
+            goalHash: goal.hash,
+            taskId: task.id,
+            taskStatus: task.status,
+            timestamp: new Date(),
+            stateData: state,
+            description,
+        };
+        let goalCheckpoints = this.checkpoints.get(goal.hash);
+        if (!goalCheckpoints) {
+            goalCheckpoints = [];
+            this.checkpoints.set(goal.hash, goalCheckpoints);
+        }
+        goalCheckpoints.push(checkpoint);
+        while (goalCheckpoints.length > this.maxCheckpointsPerGoal) {
+            goalCheckpoints.shift();
+        }
+        this.emit('checkpoint-created', checkpoint);
+        this.logger.debug('ERROR_RECOVERY', 'Checkpoint created', {
+            checkpointId: checkpoint.id,
+            goalHash: goal.hash,
+            taskId: task.id,
+        });
+        return checkpoint;
+    }
+    getCheckpoints(goalHash) {
+        return this.checkpoints.get(goalHash) ?? [];
+    }
+    getCheckpoint(checkpointId) {
+        for (const checkpoints of this.checkpoints.values()) {
+            const found = checkpoints.find((c) => c.id === checkpointId);
+            if (found)
+                return found;
+        }
+        return null;
+    }
+    async restoreCheckpoint(checkpointId, restoreFunction) {
+        const checkpoint = this.getCheckpoint(checkpointId);
+        if (!checkpoint) {
+            throw new CheckpointNotFoundError(checkpointId);
+        }
+        try {
+            await restoreFunction(checkpoint.stateData);
+            this.emit('checkpoint-restored', checkpoint);
+            this.logger.info('ERROR_RECOVERY', 'Checkpoint restored', {
+                checkpointId,
+                goalHash: checkpoint.goalHash,
+            });
+        }
+        catch (error) {
+            const err = error instanceof Error ? error : new Error(String(error));
+            this.logger.error('ERROR_RECOVERY', 'Failed to restore checkpoint', {
+                checkpointId,
+                error: err.message,
+            });
+            throw new ErrorRecoveryError(`Failed to restore checkpoint: ${err.message}`, err);
+        }
+    }
+    clearCheckpoints(goalHash) {
+        this.checkpoints.delete(goalHash);
+        this.logger.debug('ERROR_RECOVERY', 'Checkpoints cleared', { goalHash });
+    }
+    analyzeError(result) {
+        const error = result.error ?? 'Unknown error';
+        const category = this.categorizeError(error);
+        const isRecoverable = this.isRecoverable(category, result);
+        const recommendedStrategy = this.recommendStrategy(category, result);
+        const suggestions = this.generateSuggestions(category, error, result);
+        const confidence = this.calculateConfidence(category, error);
+        const analysis = {
+            category,
+            rootCause: this.extractRootCause(error),
+            isRecoverable,
+            recommendedStrategy,
+            confidence,
+            suggestions,
+        };
+        this.emit('error-analyzed', analysis, result);
+        this.logger.debug('ERROR_RECOVERY', 'Error analyzed', {
+            taskId: result.taskId,
+            category,
+            recommendedStrategy,
+        });
+        return analysis;
+    }
+    categorizeError(error) {
+        if (PERMISSION_ERROR_PATTERNS.some((p) => p.test(error))) {
+            return 'permission';
+        }
+        if (TRANSIENT_ERROR_PATTERNS.some((p) => p.test(error))) {
+            return 'transient';
+        }
+        if (RESOURCE_ERROR_PATTERNS.some((p) => p.test(error))) {
+            return 'resource';
+        }
+        if (/timeout/i.test(error)) {
+            return 'timeout';
+        }
+        if (/network|connection|socket/i.test(error)) {
+            return 'network';
+        }
+        if (/valid|invalid|format|parse/i.test(error)) {
+            return 'validation';
+        }
+        if (/system|internal|fatal/i.test(error)) {
+            return 'system';
+        }
+        return 'unknown';
+    }
+    isRecoverable(category, result) {
+        switch (category) {
+            case 'transient':
+            case 'timeout':
+            case 'network':
+                return true;
+            case 'validation':
+                return false;
+            case 'permission':
+                return false;
+            case 'resource':
+                return false;
+            case 'system':
+                return false;
+            case 'unknown': {
+                const retryState = this.retryState.get(result.taskId);
+                return !retryState || retryState.attempts < this.retryConfig.maxAttempts;
+            }
+        }
+    }
+    recommendStrategy(category, result) {
+        const failureCount = this.failureCounts.get(result.taskId) ?? 0;
+        if (failureCount >= this.escalateThreshold) {
+            return 'escalate';
+        }
+        switch (category) {
+            case 'transient':
+            case 'timeout':
+            case 'network':
+                return 'retry';
+            case 'permission':
+                return 'escalate';
+            case 'validation':
+                return 'skip';
+            case 'resource':
+                return 'escalate';
+            case 'system':
+                return 'abort';
+            case 'unknown':
+                return 'retry';
+        }
+    }
+    generateSuggestions(category, error, _result) {
+        const suggestions = [];
+        switch (category) {
+            case 'transient':
+                suggestions.push('Wait a moment and retry the operation');
+                suggestions.push('Check if external services are available');
+                break;
+            case 'timeout':
+                suggestions.push('Increase timeout settings');
+                suggestions.push('Check network connectivity');
+                suggestions.push('Break the task into smaller operations');
+                break;
+            case 'network':
+                suggestions.push('Check network connectivity');
+                suggestions.push('Verify firewall settings');
+                suggestions.push('Check if remote service is available');
+                break;
+            case 'permission':
+                suggestions.push('Review and approve the required permission');
+                suggestions.push('Check goal restrictions configuration');
+                suggestions.push('Verify file/directory permissions');
+                break;
+            case 'validation':
+                suggestions.push('Review task parameters');
+                suggestions.push('Check input data format');
+                suggestions.push('Update task configuration');
+                break;
+            case 'resource':
+                suggestions.push('Verify the resource exists');
+                suggestions.push('Check file paths and URLs');
+                suggestions.push('Create missing resources if needed');
+                break;
+            case 'system':
+                suggestions.push('Check system logs for details');
+                suggestions.push('Restart the daemon if needed');
+                suggestions.push('Contact support if issue persists');
+                break;
+            default:
+                suggestions.push('Review the error details');
+                suggestions.push('Try the operation again');
+        }
+        if (/rate limit/i.test(error)) {
+            suggestions.push('Wait before retrying (rate limited)');
+        }
+        if (/memory/i.test(error)) {
+            suggestions.push('Free up system memory');
+        }
+        if (/disk/i.test(error)) {
+            suggestions.push('Check disk space availability');
+        }
+        return suggestions;
+    }
+    extractRootCause(error) {
+        const colonIndex = error.indexOf(':');
+        if (colonIndex > 0 && colonIndex < 50) {
+            return error.substring(0, colonIndex).trim();
+        }
+        if (error.length > 100) {
+            return error.substring(0, 100) + '...';
+        }
+        return error;
+    }
+    calculateConfidence(category, error) {
+        let confidence = 0.5;
+        const specificPatterns = [
+            PERMISSION_ERROR_PATTERNS,
+            TRANSIENT_ERROR_PATTERNS,
+            RESOURCE_ERROR_PATTERNS,
+        ];
+        for (const patterns of specificPatterns) {
+            if (patterns.some((p) => p.test(error))) {
+                confidence += 0.2;
+                break;
+            }
+        }
+        if (category === 'unknown') {
+            confidence -= 0.2;
+        }
+        if (/\b(400|401|403|404|429|500|502|503)\b/.test(error)) {
+            confidence += 0.1;
+        }
+        return Math.min(1, Math.max(0, confidence));
+    }
+    async executeRecovery(action, handlers) {
+        this.emit('recovery-started', action);
+        try {
+            if (action.delayMs > 0) {
+                await this.delay(action.delayMs);
+            }
+            let result;
+            switch (action.type) {
+                case 'retry': {
+                    this.updateRetryState(action.taskId, action.attempt);
+                    const execResult = await handlers.retry(action.taskId);
+                    result = {
+                        success: execResult.success,
+                        strategy: 'retry',
+                        details: execResult.success
+                            ? 'Retry succeeded'
+                            : `Retry failed: ${execResult.error}`,
+                        newStatus: execResult.status,
+                        shouldContinue: execResult.success,
+                    };
+                    break;
+                }
+                case 'skip': {
+                    await handlers.skip(action.taskId);
+                    result = {
+                        success: true,
+                        strategy: 'skip',
+                        details: 'Task skipped',
+                        newStatus: 'skipped',
+                        shouldContinue: true,
+                    };
+                    break;
+                }
+                case 'rollback': {
+                    if (!action.checkpointId) {
+                        throw new ErrorRecoveryError('Checkpoint ID required for rollback');
+                    }
+                    await handlers.rollback(action.checkpointId);
+                    result = {
+                        success: true,
+                        strategy: 'rollback',
+                        details: `Rolled back to checkpoint ${action.checkpointId}`,
+                        shouldContinue: true,
+                    };
+                    break;
+                }
+                case 'escalate': {
+                    await handlers.escalate(action.taskId, action.goalHash);
+                    this.emit('escalation-triggered', {
+                        goalHash: action.goalHash,
+                        taskId: action.taskId,
+                        reason: 'Recovery escalation',
+                    });
+                    result = {
+                        success: true,
+                        strategy: 'escalate',
+                        details: 'Escalated to user',
+                        shouldContinue: false,
+                    };
+                    break;
+                }
+                case 'abort': {
+                    await handlers.abort(action.goalHash);
+                    result = {
+                        success: true,
+                        strategy: 'abort',
+                        details: 'Goal execution aborted',
+                        shouldContinue: false,
+                    };
+                    break;
+                }
+                default:
+                    throw new ErrorRecoveryError(`Unknown recovery strategy: ${action.type}`);
+            }
+            this.emit('recovery-completed', result, action);
+            return result;
+        }
+        catch (error) {
+            const err = error instanceof Error ? error : new Error(String(error));
+            const result = {
+                success: false,
+                strategy: action.type,
+                details: `Recovery failed: ${err.message}`,
+                shouldContinue: false,
+            };
+            this.emit('recovery-failed', result, action);
+            this.emit('error', err);
+            return result;
+        }
+    }
+    createRecoveryAction(strategy, taskId, goalHash, options) {
+        const retryState = this.retryState.get(taskId);
+        const attempt = (retryState?.attempts ?? 0) + 1;
+        let delayMs = 0;
+        if (strategy === 'retry' && attempt > 1) {
+            delayMs = this.calculateRetryDelay(attempt);
+        }
+        return {
+            type: strategy,
+            taskId,
+            goalHash,
+            attempt,
+            maxAttempts: this.retryConfig.maxAttempts,
+            delayMs: options?.customDelay ?? delayMs,
+            checkpointId: options?.checkpointId,
+            timestamp: new Date(),
+        };
+    }
+    calculateRetryDelay(attempt) {
+        const { baseDelayMs, multiplier, maxDelayMs, jitter } = this.retryConfig;
+        let delay = baseDelayMs * Math.pow(multiplier, attempt - 1);
+        delay = Math.min(delay, maxDelayMs);
+        const jitterAmount = delay * jitter * (Math.random() * 2 - 1);
+        delay = delay + jitterAmount;
+        return Math.round(Math.max(0, delay));
+    }
+    updateRetryState(taskId, attempt) {
+        this.retryState.set(taskId, {
+            attempts: attempt,
+            lastAttempt: new Date(),
+        });
+    }
+    canRetry(taskId) {
+        const state = this.retryState.get(taskId);
+        if (!state)
+            return true;
+        return state.attempts < this.retryConfig.maxAttempts;
+    }
+    getRemainingRetries(taskId) {
+        const state = this.retryState.get(taskId);
+        if (!state)
+            return this.retryConfig.maxAttempts;
+        return Math.max(0, this.retryConfig.maxAttempts - state.attempts);
+    }
+    resetRetryState(taskId) {
+        this.retryState.delete(taskId);
+        this.failureCounts.delete(taskId);
+    }
+    recordFailure(taskId) {
+        const count = (this.failureCounts.get(taskId) ?? 0) + 1;
+        this.failureCounts.set(taskId, count);
+        return count;
+    }
+    getFailureCount(taskId) {
+        return this.failureCounts.get(taskId) ?? 0;
+    }
+    shouldEscalate(taskId) {
+        return this.getFailureCount(taskId) >= this.escalateThreshold;
+    }
+    generateCheckpointId() {
+        return `cp_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+    }
+    delay(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+    clearAll() {
+        this.checkpoints.clear();
+        this.failureCounts.clear();
+        this.retryState.clear();
+        this.logger.debug('ERROR_RECOVERY', 'All state cleared');
+    }
+    getStats() {
+        const goalCheckpoints = new Map();
+        let totalCheckpoints = 0;
+        for (const [goalHash, checkpoints] of this.checkpoints) {
+            goalCheckpoints.set(goalHash, checkpoints.length);
+            totalCheckpoints += checkpoints.length;
+        }
+        return {
+            totalCheckpoints,
+            goalCheckpoints,
+            failedTasks: this.failureCounts.size,
+            pendingRetries: this.retryState.size,
+        };
+    }
+}
+export function createErrorRecovery(options = {}) {
+    return new ErrorRecovery(options);
+}

package/dist/goals/GoalApiClient.d.ts

@@ -0,0 +1,81 @@
+import type { Goal, GoalHash, Milestone, Task, GoalMemory, MetaGoal, GoalActionLog, GoalProgress, CreateGoalInput, UpdateGoalInput, CreateMilestoneInput, UpdateMilestoneInput, CreateTaskInput, UpdateTaskInput, CreateMemoryInput, UpdateMemoryInput, CreateMetaGoalInput, UpdateMetaGoalInput, TaskFeedbackInput, TaskFailInput, Logger } from './types.js';
+export type TokenProvider = () => Promise<string | null>;
+export interface GoalApiClientOptions {
+    readonly baseUrl: string;
+    readonly tokenProvider: TokenProvider;
+    readonly timeout?: number;
+    readonly retries?: number;
+    readonly logger?: Logger;
+}
+export interface PaginatedResponse<T> {
+    readonly data: T[];
+    readonly meta?: {
+        readonly currentPage: number;
+        readonly lastPage: number;
+        readonly perPage: number;
+        readonly total: number;
+    };
+}
+export interface ApiListOptions {
+    readonly status?: string;
+    readonly page?: number;
+    readonly perPage?: number;
+}
+export declare class GoalApiClient {
+    private readonly baseUrl;
+    private readonly tokenProvider;
+    private readonly timeout;
+    private readonly retries;
+    private readonly logger;
+    constructor(options: GoalApiClientOptions);
+    listGoals(options?: ApiListOptions): Promise<Goal[]>;
+    getGoal(hash: GoalHash): Promise<Goal>;
+    createGoal(input: CreateGoalInput): Promise<Goal>;
+    updateGoal(hash: GoalHash, input: UpdateGoalInput): Promise<Goal>;
+    deleteGoal(hash: GoalHash): Promise<void>;
+    pauseGoal(hash: GoalHash): Promise<Goal>;
+    resumeGoal(hash: GoalHash): Promise<Goal>;
+    completeGoal(hash: GoalHash): Promise<Goal>;
+    abandonGoal(hash: GoalHash): Promise<Goal>;
+    getGoalProgress(hash: GoalHash): Promise<GoalProgress>;
+    listMilestones(goalHash: GoalHash): Promise<Milestone[]>;
+    createMilestone(goalHash: GoalHash, input: CreateMilestoneInput): Promise<Milestone>;
+    getMilestone(goalHash: GoalHash, milestoneId: number): Promise<Milestone>;
+    updateMilestone(goalHash: GoalHash, milestoneId: number, input: UpdateMilestoneInput): Promise<Milestone>;
+    deleteMilestone(goalHash: GoalHash, milestoneId: number): Promise<void>;
+    completeMilestone(goalHash: GoalHash, milestoneId: number): Promise<Milestone>;
+    listTasks(goalHash: GoalHash, options?: ApiListOptions): Promise<Task[]>;
+    getPendingTasks(): Promise<Task[]>;
+    getTasksAwaitingApproval(): Promise<Task[]>;
+    createTask(goalHash: GoalHash, input: CreateTaskInput): Promise<Task>;
+    getTask(goalHash: GoalHash, taskId: number): Promise<Task>;
+    updateTask(goalHash: GoalHash, taskId: number, input: UpdateTaskInput): Promise<Task>;
+    deleteTask(goalHash: GoalHash, taskId: number): Promise<void>;
+    approveTask(goalHash: GoalHash, taskId: number): Promise<Task>;
+    denyTask(goalHash: GoalHash, taskId: number): Promise<Task>;
+    startTask(goalHash: GoalHash, taskId: number): Promise<Task>;
+    completeTask(goalHash: GoalHash, taskId: number, result?: Record<string, unknown>): Promise<Task>;
+    failTask(goalHash: GoalHash, taskId: number, input: TaskFailInput): Promise<Task>;
+    skipTask(goalHash: GoalHash, taskId: number): Promise<Task>;
+    addTaskFeedback(goalHash: GoalHash, taskId: number, input: TaskFeedbackInput): Promise<Task>;
+    listMemories(goalHash: GoalHash): Promise<GoalMemory[]>;
+    getEnabledMemories(goalHash: GoalHash): Promise<GoalMemory[]>;
+    createMemory(goalHash: GoalHash, input: CreateMemoryInput): Promise<GoalMemory>;
+    updateMemory(goalHash: GoalHash, memoryId: number, input: UpdateMemoryInput): Promise<GoalMemory>;
+    toggleMemory(goalHash: GoalHash, memoryId: number): Promise<GoalMemory>;
+    deleteMemory(goalHash: GoalHash, memoryId: number): Promise<void>;
+    listMetaGoals(active?: boolean): Promise<MetaGoal[]>;
+    getMetaGoalsForGoal(goalHash: GoalHash): Promise<MetaGoal[]>;
+    createMetaGoal(input: CreateMetaGoalInput): Promise<MetaGoal>;
+    getMetaGoal(id: number): Promise<MetaGoal>;
+    updateMetaGoal(id: number, input: UpdateMetaGoalInput): Promise<MetaGoal>;
+    toggleMetaGoal(id: number): Promise<MetaGoal>;
+    deleteMetaGoal(id: number): Promise<void>;
+    getActionLogs(goalHash: GoalHash, limit?: number): Promise<GoalActionLog[]>;
+    private transformGoalInput;
+    private request;
+    private executeRequest;
+    private handleHttpError;
+    private delay;
+}
+export declare function createGoalApiClient(options: GoalApiClientOptions): GoalApiClient;