@flowdot.ai/daemon 1.0.0

package/dist/goals/ReviewScheduler.js

@@ -0,0 +1,360 @@
+import { EventEmitter } from 'events';
+const DEFAULT_CHECK_INTERVAL = 60 * 60 * 1000;
+const DEFAULT_STALLED_THRESHOLD = 7;
+const DEFAULT_DEADLINE_WARNING = 3;
+const DEFAULT_SNOOZE_HOURS = 24;
+export class ReviewScheduler extends EventEmitter {
+    logger;
+    checkInterval;
+    stalledThresholdDays;
+    deadlineWarningDays;
+    enableAutoTriggers;
+    schedules = new Map();
+    reviews = new Map();
+    lastActivityDates = new Map();
+    checkTimer = null;
+    reviewCounter = 0;
+    constructor(options = {}) {
+        super();
+        this.logger = options.logger ?? console;
+        this.checkInterval = options.checkInterval ?? DEFAULT_CHECK_INTERVAL;
+        this.stalledThresholdDays =
+            options.stalledThresholdDays ?? DEFAULT_STALLED_THRESHOLD;
+        this.deadlineWarningDays =
+            options.deadlineWarningDays ?? DEFAULT_DEADLINE_WARNING;
+        this.enableAutoTriggers = options.enableAutoTriggers ?? true;
+    }
+    start() {
+        if (this.checkTimer)
+            return;
+        this.logger.info('REVIEW_SCHEDULER', 'Starting review scheduler');
+        this.checkTimer = setInterval(() => {
+            this.checkDueReviews();
+        }, this.checkInterval);
+        this.checkDueReviews();
+    }
+    stop() {
+        if (this.checkTimer) {
+            clearInterval(this.checkTimer);
+            this.checkTimer = null;
+            this.logger.info('REVIEW_SCHEDULER', 'Stopped review scheduler');
+        }
+    }
+    setSchedule(config) {
+        this.schedules.set(config.goalHash, config);
+        if (config.enabled) {
+            const nextReview = this.calculateNextReviewDate(config);
+            this.scheduleReview(config.goalHash, 'progress', nextReview, config.frequency);
+        }
+        this.logger.info('REVIEW_SCHEDULER', `Set ${config.frequency} review schedule for goal ${config.goalHash}`);
+    }
+    removeSchedule(goalHash) {
+        this.schedules.delete(goalHash);
+        for (const [id, review] of this.reviews) {
+            if (review.goalHash === goalHash && !review.completedAt) {
+                this.reviews.delete(id);
+            }
+        }
+        this.logger.info('REVIEW_SCHEDULER', `Removed schedule for goal ${goalHash}`);
+    }
+    scheduleReview(goalHash, type, scheduledFor, frequency = 'custom', metadata) {
+        const review = {
+            id: `review_${++this.reviewCounter}_${Date.now()}`,
+            goalHash,
+            type,
+            scheduledFor,
+            frequency,
+            title: this.getReviewTitle(type, frequency),
+            description: this.getReviewDescription(type),
+            priority: this.getReviewPriority(type),
+            metadata,
+            createdAt: new Date(),
+        };
+        this.reviews.set(review.id, review);
+        this.emit('review:created', review);
+        this.logger.debug('REVIEW_SCHEDULER', `Scheduled ${type} review for ${goalHash} on ${scheduledFor.toISOString()}`);
+        return review;
+    }
+    completeReview(reviewId, result) {
+        const review = this.reviews.get(reviewId);
+        if (!review) {
+            this.logger.warn('REVIEW_SCHEDULER', `Review not found: ${reviewId}`);
+            return;
+        }
+        const completed = {
+            ...review,
+            completedAt: new Date(),
+        };
+        this.reviews.set(reviewId, completed);
+        this.emit('review:completed', completed, result);
+        if (review.frequency !== 'custom' && review.frequency !== 'milestone') {
+            const config = this.schedules.get(review.goalHash);
+            if (config?.enabled) {
+                const nextDate = this.calculateNextReviewDate(config);
+                this.scheduleReview(review.goalHash, review.type, nextDate, review.frequency);
+            }
+        }
+    }
+    snoozeReview(reviewId, hours = DEFAULT_SNOOZE_HOURS) {
+        const review = this.reviews.get(reviewId);
+        if (!review) {
+            this.logger.warn('REVIEW_SCHEDULER', `Review not found: ${reviewId}`);
+            return;
+        }
+        const snoozedUntil = new Date();
+        snoozedUntil.setHours(snoozedUntil.getHours() + hours);
+        const snoozed = {
+            ...review,
+            snoozedUntil,
+        };
+        this.reviews.set(reviewId, snoozed);
+        this.emit('review:snoozed', snoozed, snoozedUntil);
+        this.logger.info('REVIEW_SCHEDULER', `Snoozed review ${reviewId} until ${snoozedUntil.toISOString()}`);
+    }
+    getPendingReviews(goalHash) {
+        const pending = [];
+        const now = new Date();
+        for (const review of this.reviews.values()) {
+            if (review.completedAt)
+                continue;
+            if (goalHash && review.goalHash !== goalHash)
+                continue;
+            if (review.snoozedUntil && review.snoozedUntil > now)
+                continue;
+            pending.push(review);
+        }
+        return pending.sort((a, b) => a.scheduledFor.getTime() - b.scheduledFor.getTime());
+    }
+    getDueReviews() {
+        const now = new Date();
+        return this.getPendingReviews().filter((r) => r.scheduledFor <= now);
+    }
+    getUpcomingReviews(withinHours = 24) {
+        const now = new Date();
+        const cutoff = new Date();
+        cutoff.setHours(cutoff.getHours() + withinHours);
+        return this.getPendingReviews().filter((r) => r.scheduledFor > now && r.scheduledFor <= cutoff);
+    }
+    recordActivity(goalHash) {
+        this.lastActivityDates.set(goalHash, new Date());
+    }
+    checkStalledGoals(goals) {
+        const stalled = [];
+        const now = new Date();
+        const thresholdMs = this.stalledThresholdDays * 24 * 60 * 60 * 1000;
+        for (const goal of goals) {
+            if (goal.status !== 'active')
+                continue;
+            const lastActivity = this.lastActivityDates.get(goal.hash);
+            if (!lastActivity) {
+                const createdAt = new Date(goal.createdAt);
+                if (now.getTime() - createdAt.getTime() > thresholdMs) {
+                    stalled.push(goal.hash);
+                    const days = Math.floor((now.getTime() - createdAt.getTime()) / (24 * 60 * 60 * 1000));
+                    this.emit('goal:stalled', goal.hash, days);
+                }
+            }
+            else if (now.getTime() - lastActivity.getTime() > thresholdMs) {
+                stalled.push(goal.hash);
+                const days = Math.floor((now.getTime() - lastActivity.getTime()) / (24 * 60 * 60 * 1000));
+                this.emit('goal:stalled', goal.hash, days);
+            }
+        }
+        return stalled;
+    }
+    checkApproachingDeadlines(goals) {
+        const approaching = [];
+        const now = new Date();
+        const warningMs = this.deadlineWarningDays * 24 * 60 * 60 * 1000;
+        for (const goal of goals) {
+            if (!goal.deadline)
+                continue;
+            if (goal.status === 'completed' || goal.status === 'abandoned')
+                continue;
+            const deadline = new Date(goal.deadline);
+            const remaining = deadline.getTime() - now.getTime();
+            if (remaining > 0 && remaining <= warningMs) {
+                approaching.push(goal.hash);
+                const daysRemaining = Math.ceil(remaining / (24 * 60 * 60 * 1000));
+                this.emit('deadline:approaching', goal.hash, daysRemaining);
+                const existingReview = this.findReview(goal.hash, 'deadline');
+                if (!existingReview) {
+                    this.scheduleReview(goal.hash, 'deadline', new Date(), 'custom', { daysRemaining });
+                }
+            }
+        }
+        return approaching;
+    }
+    triggerMilestoneReview(goalHash, milestoneTitle) {
+        return this.scheduleReview(goalHash, 'milestone', new Date(), 'milestone', { milestoneTitle });
+    }
+    triggerCompletionReview(goalHash) {
+        return this.scheduleReview(goalHash, 'completion', new Date(), 'custom');
+    }
+    getStatistics() {
+        let completed = 0;
+        let pending = 0;
+        let overdue = 0;
+        let snoozed = 0;
+        const now = new Date();
+        for (const review of this.reviews.values()) {
+            if (review.completedAt) {
+                completed++;
+            }
+            else if (review.snoozedUntil && review.snoozedUntil > now) {
+                snoozed++;
+            }
+            else if (review.scheduledFor <= now) {
+                overdue++;
+            }
+            else {
+                pending++;
+            }
+        }
+        return {
+            totalScheduled: this.reviews.size,
+            completed,
+            pending,
+            overdue,
+            snoozed,
+        };
+    }
+    clearGoalData(goalHash) {
+        this.schedules.delete(goalHash);
+        this.lastActivityDates.delete(goalHash);
+        for (const [id, review] of this.reviews) {
+            if (review.goalHash === goalHash) {
+                this.reviews.delete(id);
+            }
+        }
+    }
+    checkDueReviews() {
+        const now = new Date();
+        const dueReviews = this.getDueReviews();
+        for (const review of dueReviews) {
+            this.emit('review:due', review);
+        }
+        const upcoming = this.getUpcomingReviews(1);
+        for (const review of upcoming) {
+            const daysUntil = (review.scheduledFor.getTime() - now.getTime()) / (24 * 60 * 60 * 1000);
+            this.emit('review:upcoming', review, daysUntil);
+        }
+    }
+    calculateNextReviewDate(config) {
+        const now = new Date();
+        const next = new Date();
+        let hours = 9;
+        let minutes = 0;
+        if (config.preferredTime) {
+            const [h, m] = config.preferredTime.split(':').map(Number);
+            hours = h;
+            minutes = m;
+        }
+        switch (config.frequency) {
+            case 'daily':
+                next.setDate(next.getDate() + 1);
+                break;
+            case 'weekly':
+                next.setDate(next.getDate() + 7);
+                if (config.preferredDay !== undefined) {
+                    const currentDay = next.getDay();
+                    const targetDay = config.preferredDay;
+                    const daysToAdd = (targetDay - currentDay + 7) % 7;
+                    next.setDate(next.getDate() + daysToAdd);
+                }
+                break;
+            case 'biweekly':
+                next.setDate(next.getDate() + 14);
+                break;
+            case 'monthly':
+                next.setMonth(next.getMonth() + 1);
+                if (config.preferredDay !== undefined) {
+                    next.setDate(Math.min(config.preferredDay, this.getDaysInMonth(next)));
+                }
+                break;
+            case 'custom':
+                if (config.customIntervalDays) {
+                    next.setDate(next.getDate() + config.customIntervalDays);
+                }
+                else {
+                    next.setDate(next.getDate() + 7);
+                }
+                break;
+            case 'milestone':
+                return now;
+        }
+        next.setHours(hours, minutes, 0, 0);
+        return next;
+    }
+    getDaysInMonth(date) {
+        return new Date(date.getFullYear(), date.getMonth() + 1, 0).getDate();
+    }
+    findReview(goalHash, type) {
+        for (const review of this.reviews.values()) {
+            if (review.goalHash === goalHash &&
+                review.type === type &&
+                !review.completedAt) {
+                return review;
+            }
+        }
+        return undefined;
+    }
+    getReviewTitle(type, frequency) {
+        switch (type) {
+            case 'progress':
+                return `${this.capitalizeFirst(frequency)} Progress Review`;
+            case 'milestone':
+                return 'Milestone Completion Review';
+            case 'stalled':
+                return 'Stalled Goal Check-in';
+            case 'deadline':
+                return 'Deadline Approaching Review';
+            case 'weekly_summary':
+                return 'Weekly Summary';
+            case 'monthly_summary':
+                return 'Monthly Summary';
+            case 'completion':
+                return 'Goal Completion Review';
+            default:
+                return 'Goal Review';
+        }
+    }
+    getReviewDescription(type) {
+        switch (type) {
+            case 'progress':
+                return 'Review progress and adjust priorities';
+            case 'milestone':
+                return 'Celebrate milestone and plan next steps';
+            case 'stalled':
+                return 'Review blockers and decide next actions';
+            case 'deadline':
+                return 'Assess readiness for upcoming deadline';
+            case 'weekly_summary':
+                return 'Weekly progress summary and planning';
+            case 'monthly_summary':
+                return 'Monthly retrospective and goal assessment';
+            case 'completion':
+                return 'Celebrate completion and capture learnings';
+            default:
+                return 'Review goal status';
+        }
+    }
+    getReviewPriority(type) {
+        switch (type) {
+            case 'deadline':
+            case 'stalled':
+                return 'high';
+            case 'milestone':
+            case 'completion':
+                return 'medium';
+            default:
+                return 'low';
+        }
+    }
+    capitalizeFirst(str) {
+        return str.charAt(0).toUpperCase() + str.slice(1);
+    }
+}
+export function createReviewScheduler(options) {
+    return new ReviewScheduler(options);
+}

package/dist/goals/TaskExecutor.d.ts

@@ -0,0 +1,116 @@
+import { EventEmitter } from 'node:events';
+import type { Goal, GoalHash, Task, TaskStatus, TaskType, ApprovalMode, Logger } from './types.js';
+import { GoalError } from './errors.js';
+export type PermissionCategory = 'file-read' | 'file-write' | 'file-create' | 'command-execute' | 'web-search' | 'recipe-invoke' | 'domain-access' | 'loop-create';
+export interface PermissionCheckResult {
+    readonly allowed: boolean;
+    readonly requiresApproval: boolean;
+    readonly reason?: string;
+    readonly approvalMode: ApprovalMode;
+    readonly category: PermissionCategory;
+}
+export interface ApprovalResult {
+    readonly approved: boolean;
+    readonly response: 'approve' | 'deny' | 'skip' | 'later' | 'timeout';
+    readonly userId?: number;
+    readonly respondedAt?: Date;
+}
+export interface ExecutionResult {
+    readonly success: boolean;
+    readonly taskId: number;
+    readonly goalHash: GoalHash;
+    readonly status: TaskStatus;
+    readonly data?: unknown;
+    readonly error?: string;
+    readonly durationMs: number;
+    readonly cost?: number;
+    readonly permissionDenied?: boolean;
+    readonly approvalSkipped?: boolean;
+    readonly executedAt: Date;
+}
+export interface ExecutionContext {
+    readonly goal: Goal;
+    readonly task: Task;
+    readonly permissionCategory: PermissionCategory;
+    readonly approvalMode: ApprovalMode;
+    readonly startTime: Date;
+}
+export type TaskExecutionHandler = (context: ExecutionContext) => Promise<{
+    success: boolean;
+    data?: unknown;
+    error?: string;
+    cost?: number;
+}>;
+export type PermissionCheckFunction = (category: PermissionCategory, context: ExecutionContext) => Promise<PermissionCheckResult>;
+export type ApprovalRequestFunction = (context: ExecutionContext) => Promise<ApprovalResult>;
+export type TaskStatusUpdateFunction = (taskId: number, status: TaskStatus, result?: {
+    data?: unknown;
+    error?: string;
+    cost?: number;
+}) => Promise<void>;
+export interface TaskExecutorOptions {
+    readonly logger?: Logger;
+    readonly checkPermission?: PermissionCheckFunction;
+    readonly requestApproval?: ApprovalRequestFunction;
+    readonly updateTaskStatus?: TaskStatusUpdateFunction;
+    readonly handlers?: Partial<Record<TaskType, TaskExecutionHandler>>;
+    readonly maxExecutionTimeMs?: number;
+    readonly logExecutions?: boolean;
+}
+export interface TaskExecutorEvents {
+    'execution-started': [ExecutionContext];
+    'permission-checked': [PermissionCheckResult, ExecutionContext];
+    'approval-requested': [ExecutionContext];
+    'approval-received': [ApprovalResult, ExecutionContext];
+    'execution-completed': [ExecutionResult];
+    'execution-failed': [ExecutionResult];
+    'error': [Error];
+}
+export declare class TaskExecutionError extends GoalError {
+    readonly taskId: number;
+    readonly goalHash: GoalHash;
+    constructor(message: string, taskId: number, goalHash: GoalHash, cause?: Error);
+}
+export declare class PermissionDeniedError extends GoalError {
+    readonly category: PermissionCategory;
+    readonly reason: string;
+    constructor(category: PermissionCategory, reason: string);
+}
+export declare class ExecutionTimeoutError extends GoalError {
+    readonly taskId: number;
+    readonly timeoutMs: number;
+    constructor(taskId: number, timeoutMs: number);
+}
+export declare class TaskExecutor extends EventEmitter<TaskExecutorEvents> {
+    private readonly logger;
+    private readonly checkPermission?;
+    private readonly requestApproval?;
+    private readonly updateTaskStatus?;
+    private readonly handlers;
+    private readonly maxExecutionTimeMs;
+    private readonly logExecutions;
+    private readonly executingTasks;
+    constructor(options?: TaskExecutorOptions);
+    execute(goal: Goal, task: Task): Promise<ExecutionResult>;
+    executeSequence(goal: Goal, tasks: Task[]): Promise<ExecutionResult[]>;
+    canExecute(goal: Goal, task: Task): Promise<{
+        canExecute: boolean;
+        requiresApproval: boolean;
+        reason?: string;
+    }>;
+    private checkTaskPermission;
+    private defaultPermissionCheck;
+    private requestTaskApproval;
+    private executeTask;
+    registerHandler(taskType: TaskType, handler: TaskExecutionHandler): void;
+    unregisterHandler(taskType: TaskType): void;
+    hasHandler(taskType: TaskType): boolean;
+    getPermissionCategory(taskType: TaskType): PermissionCategory;
+    private getStatusFromApprovalResponse;
+    private updateStatus;
+    private createResult;
+    getExecutingTasks(): ExecutionContext[];
+    isExecuting(taskId: number): boolean;
+    cancelTask(taskId: number): boolean;
+}
+export declare function createTaskExecutor(options?: TaskExecutorOptions): TaskExecutor;