@flowdot.ai/daemon 1.0.0

package/dist/goals/GoalScheduler.js

@@ -0,0 +1,209 @@
+import { EventEmitter } from 'node:events';
+const noopLogger = {
+    debug: () => { },
+    info: () => { },
+    warn: () => { },
+    error: () => { },
+};
+export class GoalScheduler extends EventEmitter {
+    getDueGoals;
+    markGoalStarted;
+    markGoalCompleted;
+    executeGoal;
+    pollIntervalMs;
+    maxConcurrentExecutions;
+    logger;
+    pollTimer = null;
+    isPolling = false;
+    activeExecutions = new Map();
+    started = false;
+    startedAt = null;
+    totalPollCount = 0;
+    totalExecutionCount = 0;
+    totalSuccessCount = 0;
+    totalFailureCount = 0;
+    constructor(options) {
+        super();
+        this.getDueGoals = options.getDueGoals;
+        this.markGoalStarted = options.markGoalStarted;
+        this.markGoalCompleted = options.markGoalCompleted;
+        this.executeGoal = options.executeGoal;
+        this.pollIntervalMs = options.pollIntervalMs ?? 60000;
+        this.maxConcurrentExecutions = options.maxConcurrentExecutions ?? 3;
+        this.logger = options.logger ?? noopLogger;
+    }
+    start() {
+        if (this.started) {
+            return;
+        }
+        this.started = true;
+        this.startedAt = new Date();
+        this.logger.info('GOAL_SCHEDULER', 'Starting goal scheduler', {
+            pollIntervalMs: this.pollIntervalMs,
+            maxConcurrentExecutions: this.maxConcurrentExecutions,
+        });
+        this.poll().catch((error) => {
+            this.emit('error', error, { context: 'initial-poll' });
+        });
+        this.pollTimer = setInterval(() => {
+            this.poll().catch((error) => {
+                this.emit('error', error, { context: 'scheduled-poll' });
+            });
+        }, this.pollIntervalMs);
+    }
+    stop() {
+        if (!this.started) {
+            return;
+        }
+        this.logger.info('GOAL_SCHEDULER', 'Stopping goal scheduler', {
+            activeExecutions: this.activeExecutions.size,
+        });
+        if (this.pollTimer) {
+            clearInterval(this.pollTimer);
+            this.pollTimer = null;
+        }
+        this.started = false;
+    }
+    isRunning() {
+        return this.started;
+    }
+    async poll() {
+        if (this.isPolling) {
+            return;
+        }
+        this.isPolling = true;
+        this.totalPollCount++;
+        this.emit('poll-started');
+        try {
+            if (this.activeExecutions.size >= this.maxConcurrentExecutions) {
+                this.logger.debug('GOAL_SCHEDULER', 'Max concurrent executions reached', {
+                    active: this.activeExecutions.size,
+                    max: this.maxConcurrentExecutions,
+                });
+                this.emit('poll-completed', 0);
+                return;
+            }
+            const dueGoals = await this.getDueGoals();
+            this.logger.debug('GOAL_SCHEDULER', 'Fetched due goals', {
+                count: dueGoals.length,
+            });
+            this.emit('poll-completed', dueGoals.length);
+            const availableSlots = this.maxConcurrentExecutions - this.activeExecutions.size;
+            const goalsToExecute = dueGoals.slice(0, availableSlots);
+            for (const goal of goalsToExecute) {
+                if (this.activeExecutions.has(goal.hash)) {
+                    this.logger.debug('GOAL_SCHEDULER', 'Skipping goal already running', {
+                        goalHash: goal.hash,
+                        goalName: goal.name,
+                    });
+                    this.emit('execution-skipped', goal, 'already_running');
+                    continue;
+                }
+                this.executeGoalInBackground(goal);
+            }
+        }
+        catch (error) {
+            this.logger.error('GOAL_SCHEDULER', 'Poll failed', {
+                error: error instanceof Error ? error.message : String(error),
+            });
+            this.emit('error', error, { context: 'poll' });
+        }
+        finally {
+            this.isPolling = false;
+        }
+    }
+    executeGoalInBackground(goal) {
+        const goalHash = goal.hash;
+        const state = {
+            goalHash,
+            goalId: goal.id,
+            startedAt: new Date(),
+            status: 'running',
+        };
+        this.activeExecutions.set(goalHash, state);
+        this.totalExecutionCount++;
+        this.logger.info('GOAL_SCHEDULER', 'Starting goal execution', {
+            goalHash: goal.hash,
+            goalName: goal.name,
+            executionRecipe: goal.executionRecipe,
+        });
+        this.emit('execution-started', goal);
+        setImmediate(async () => {
+            try {
+                await this.markGoalStarted(goal.id, {
+                    source: 'goal_scheduler',
+                    startedAt: state.startedAt.toISOString(),
+                });
+                const result = await this.executeGoal(goal);
+                state.status = result.success ? 'completed' : 'failed';
+                await this.markGoalCompleted(goal.id, result.success ? 'success' : 'failed', {
+                    error: result.error,
+                });
+                if (result.success) {
+                    this.totalSuccessCount++;
+                }
+                else {
+                    this.totalFailureCount++;
+                }
+                this.logger.info('GOAL_SCHEDULER', 'Goal execution completed', {
+                    goalHash: goal.hash,
+                    goalName: goal.name,
+                    success: result.success,
+                    error: result.error,
+                });
+                this.emit('execution-completed', goal, result.success, result.error);
+            }
+            catch (error) {
+                state.status = 'failed';
+                this.totalFailureCount++;
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                this.logger.error('GOAL_SCHEDULER', 'Goal execution failed', {
+                    goalHash: goal.hash,
+                    goalName: goal.name,
+                    error: errorMessage,
+                });
+                try {
+                    await this.markGoalCompleted(goal.id, 'failed', { error: errorMessage });
+                }
+                catch (reportError) {
+                    this.logger.error('GOAL_SCHEDULER', 'Failed to report execution failure', {
+                        goalHash: goal.hash,
+                        error: reportError instanceof Error ? reportError.message : String(reportError),
+                    });
+                }
+                this.emit('execution-completed', goal, false, errorMessage);
+                this.emit('error', error, {
+                    context: 'execution',
+                    goalHash: goal.hash,
+                    goalName: goal.name,
+                });
+            }
+            finally {
+                this.activeExecutions.delete(goalHash);
+            }
+        });
+    }
+    getActiveExecutions() {
+        return Array.from(this.activeExecutions.values());
+    }
+    isGoalExecuting(goalHash) {
+        return this.activeExecutions.has(goalHash);
+    }
+    getStats() {
+        return {
+            running: this.started,
+            startedAt: this.startedAt,
+            activeExecutions: this.activeExecutions.size,
+            totalPollCount: this.totalPollCount,
+            totalExecutionCount: this.totalExecutionCount,
+            totalSuccessCount: this.totalSuccessCount,
+            totalFailureCount: this.totalFailureCount,
+        };
+    }
+    async triggerPollNow() {
+        await this.poll();
+    }
+}
+export function createGoalScheduler(options) {
+    return new GoalScheduler(options);
+}

package/dist/goals/GoalValidator.d.ts

@@ -0,0 +1,72 @@
+import type { CreateGoalInput, UpdateGoalInput, CreateMilestoneInput, UpdateMilestoneInput, CreateTaskInput, UpdateTaskInput, CreateMemoryInput, UpdateMemoryInput, CreateMetaGoalInput, UpdateMetaGoalInput, TaskFeedbackInput } from './types.js';
+export interface GoalValidationConstraints {
+    readonly maxNameLength: number;
+    readonly minNameLength: number;
+    readonly maxDescriptionLength: number;
+    readonly maxTitleLength: number;
+    readonly minTitleLength: number;
+    readonly maxMemoryContentLength: number;
+    readonly minMemoryContentLength: number;
+    readonly maxMetaGoalDescriptionLength: number;
+    readonly minMetaGoalDescriptionLength: number;
+    readonly maxMetaGoalPriority: number;
+    readonly minMetaGoalPriority: number;
+    readonly maxFeedbackCommentLength: number;
+    readonly maxDependencies: number;
+    readonly namePattern: RegExp;
+}
+export declare const DEFAULT_GOAL_VALIDATION_CONSTRAINTS: GoalValidationConstraints;
+export interface ValidationResult {
+    readonly valid: boolean;
+    readonly errors: ValidationIssue[];
+}
+export interface ValidationIssue {
+    readonly field: string;
+    readonly message: string;
+    readonly value?: unknown;
+}
+export declare class GoalValidator {
+    private readonly constraints;
+    constructor(constraints?: Partial<GoalValidationConstraints>);
+    validateCreateGoalInput(input: CreateGoalInput): void;
+    validateCreateGoalInputSafe(input: CreateGoalInput): ValidationResult;
+    validateUpdateGoalInput(input: UpdateGoalInput): void;
+    validateUpdateGoalInputSafe(input: UpdateGoalInput): ValidationResult;
+    validateCreateMilestoneInput(input: CreateMilestoneInput): void;
+    validateCreateMilestoneInputSafe(input: CreateMilestoneInput): ValidationResult;
+    validateUpdateMilestoneInput(input: UpdateMilestoneInput): void;
+    validateUpdateMilestoneInputSafe(input: UpdateMilestoneInput): ValidationResult;
+    validateCreateTaskInput(input: CreateTaskInput): void;
+    validateCreateTaskInputSafe(input: CreateTaskInput): ValidationResult;
+    validateUpdateTaskInput(input: UpdateTaskInput): void;
+    validateUpdateTaskInputSafe(input: UpdateTaskInput): ValidationResult;
+    validateTaskFeedbackInput(input: TaskFeedbackInput): void;
+    validateTaskFeedbackInputSafe(input: TaskFeedbackInput): ValidationResult;
+    validateCreateMemoryInput(input: CreateMemoryInput): void;
+    validateCreateMemoryInputSafe(input: CreateMemoryInput): ValidationResult;
+    validateUpdateMemoryInput(input: UpdateMemoryInput): void;
+    validateUpdateMemoryInputSafe(input: UpdateMemoryInput): ValidationResult;
+    validateCreateMetaGoalInput(input: CreateMetaGoalInput): void;
+    validateCreateMetaGoalInputSafe(input: CreateMetaGoalInput): ValidationResult;
+    validateUpdateMetaGoalInput(input: UpdateMetaGoalInput): void;
+    validateUpdateMetaGoalInputSafe(input: UpdateMetaGoalInput): ValidationResult;
+    validateGoalHash(hash: string): void;
+    private validateName;
+    private validateTitle;
+    private validateDescription;
+    private validateMemoryContent;
+    private validateMetaGoalDescription;
+    private validateMetaGoalPriority;
+    private validateMetaGoalScope;
+    private validateDateString;
+    private validateDependencies;
+    private issuesToRecord;
+}
+export declare function createGoalValidator(constraints?: Partial<GoalValidationConstraints>): GoalValidator;
+export declare function validateCreateGoalInput(input: CreateGoalInput): void;
+export declare function validateUpdateGoalInput(input: UpdateGoalInput): void;
+export declare function validateCreateTaskInput(input: CreateTaskInput): void;
+export declare function validateCreateMilestoneInput(input: CreateMilestoneInput): void;
+export declare function validateCreateMemoryInput(input: CreateMemoryInput): void;
+export declare function validateCreateMetaGoalInput(input: CreateMetaGoalInput): void;
+export declare function validateGoalHash(hash: string): void;