@flowdot.ai/daemon 1.0.0

package/dist/goals/ProgressTracker.js

@@ -0,0 +1,324 @@
+import { EventEmitter } from 'events';
+const DEFAULT_SNAPSHOT_INTERVAL = 24 * 60 * 60 * 1000;
+const DEFAULT_VELOCITY_WINDOW = 7;
+const DEFAULT_MAX_SNAPSHOTS = 30;
+export class ProgressTracker extends EventEmitter {
+    logger;
+    snapshotInterval;
+    velocityWindow;
+    maxSnapshots;
+    enableAutoSnapshots;
+    completionRecords = new Map();
+    snapshots = new Map();
+    progressCache = new Map();
+    snapshotTimer = null;
+    snapshotCounter = 0;
+    constructor(options = {}) {
+        super();
+        this.logger = options.logger ?? console;
+        this.snapshotInterval = options.snapshotInterval ?? DEFAULT_SNAPSHOT_INTERVAL;
+        this.velocityWindow = options.velocityWindow ?? DEFAULT_VELOCITY_WINDOW;
+        this.maxSnapshots = options.maxSnapshots ?? DEFAULT_MAX_SNAPSHOTS;
+        this.enableAutoSnapshots = options.enableAutoSnapshots ?? false;
+        if (this.enableAutoSnapshots) {
+            this.startAutoSnapshots();
+        }
+    }
+    calculateProgress(goal, milestones, tasks) {
+        const goalHash = goal.hash;
+        const taskStats = this.calculateTaskStats(tasks);
+        const milestoneProgress = this.calculateMilestoneProgress(milestones, tasks);
+        const overallProgress = this.calculateOverallProgress(taskStats, milestoneProgress);
+        const velocity = this.calculateVelocity(goalHash);
+        const estimatedCompletion = this.estimateCompletion(taskStats, velocity);
+        const progress = {
+            goalHash,
+            title: goal.name,
+            status: goal.status,
+            overallProgress,
+            milestoneProgress,
+            taskStats,
+            velocity,
+            estimatedCompletion,
+            lastUpdated: new Date(),
+        };
+        const previousProgress = this.progressCache.get(goalHash);
+        this.progressCache.set(goalHash, progress);
+        this.emit('progress:updated', goalHash, progress);
+        for (const mp of milestoneProgress) {
+            if (mp.progress === 100) {
+                const previousMp = previousProgress?.milestoneProgress.find((m) => m.milestoneId === mp.milestoneId);
+                if (!previousMp || previousMp.progress < 100) {
+                    this.emit('milestone:completed', goalHash, mp.milestoneId);
+                }
+            }
+        }
+        if (overallProgress === 100 && previousProgress?.overallProgress !== 100) {
+            this.emit('goal:completed', goalHash);
+        }
+        if (estimatedCompletion?.getTime() !==
+            previousProgress?.estimatedCompletion?.getTime()) {
+            this.emit('estimate:updated', goalHash, estimatedCompletion);
+        }
+        return progress;
+    }
+    recordTaskCompletion(taskId, goalHash, durationMs, wasSuccessful) {
+        const record = {
+            taskId,
+            goalHash,
+            completedAt: new Date(),
+            durationMs,
+            wasSuccessful,
+        };
+        const records = this.completionRecords.get(goalHash) ?? [];
+        records.push(record);
+        const cutoff = new Date();
+        cutoff.setDate(cutoff.getDate() - this.velocityWindow);
+        const filtered = records.filter((r) => r.completedAt >= cutoff);
+        this.completionRecords.set(goalHash, filtered);
+        const newVelocity = this.calculateVelocity(goalHash);
+        const cached = this.progressCache.get(goalHash);
+        if (cached && this.hasVelocityChanged(cached.velocity, newVelocity)) {
+            this.emit('velocity:changed', goalHash, newVelocity);
+        }
+    }
+    createSnapshot(goalHash) {
+        const progress = this.progressCache.get(goalHash);
+        if (!progress) {
+            this.logger.warn('PROGRESS_TRACKER', `No progress data for goal ${goalHash}`);
+            return null;
+        }
+        const snapshot = {
+            id: `snap_${++this.snapshotCounter}_${Date.now()}`,
+            goalHash,
+            timestamp: new Date(),
+            progress: progress.overallProgress,
+            taskStats: { ...progress.taskStats },
+            velocity: { ...progress.velocity },
+        };
+        const snapshots = this.snapshots.get(goalHash) ?? [];
+        snapshots.push(snapshot);
+        while (snapshots.length > this.maxSnapshots) {
+            snapshots.shift();
+        }
+        this.snapshots.set(goalHash, snapshots);
+        this.emit('snapshot:created', snapshot);
+        return snapshot;
+    }
+    getSnapshots(goalHash) {
+        return [...(this.snapshots.get(goalHash) ?? [])];
+    }
+    getCachedProgress(goalHash) {
+        return this.progressCache.get(goalHash);
+    }
+    getProgressSummary(goalHashes) {
+        const summary = new Map();
+        for (const hash of goalHashes) {
+            const progress = this.progressCache.get(hash);
+            if (progress) {
+                summary.set(hash, progress);
+            }
+        }
+        return summary;
+    }
+    getAggregateStats() {
+        const goals = Array.from(this.progressCache.values());
+        if (goals.length === 0) {
+            return {
+                totalGoals: 0,
+                averageProgress: 0,
+                totalTasks: 0,
+                completedTasks: 0,
+                averageVelocity: 0,
+            };
+        }
+        const totalProgress = goals.reduce((sum, g) => sum + g.overallProgress, 0);
+        const totalTasks = goals.reduce((sum, g) => sum + g.taskStats.total, 0);
+        const completedTasks = goals.reduce((sum, g) => sum + g.taskStats.completed, 0);
+        const totalVelocity = goals.reduce((sum, g) => sum + g.velocity.tasksPerDay, 0);
+        return {
+            totalGoals: goals.length,
+            averageProgress: totalProgress / goals.length,
+            totalTasks,
+            completedTasks,
+            averageVelocity: totalVelocity / goals.length,
+        };
+    }
+    calculateProgressTrend(goalHash, days = 7) {
+        const snapshots = this.snapshots.get(goalHash) ?? [];
+        const cutoff = new Date();
+        cutoff.setDate(cutoff.getDate() - days);
+        return snapshots
+            .filter((s) => s.timestamp >= cutoff)
+            .map((s) => ({
+            date: s.timestamp,
+            progress: s.progress,
+        }));
+    }
+    getCompletionRate(goalHash) {
+        const records = this.completionRecords.get(goalHash) ?? [];
+        if (records.length === 0)
+            return 0;
+        const successful = records.filter((r) => r.wasSuccessful).length;
+        return successful / records.length;
+    }
+    clearGoalData(goalHash) {
+        this.progressCache.delete(goalHash);
+        this.completionRecords.delete(goalHash);
+        this.snapshots.delete(goalHash);
+    }
+    stop() {
+        if (this.snapshotTimer) {
+            clearInterval(this.snapshotTimer);
+            this.snapshotTimer = null;
+        }
+    }
+    calculateTaskStats(tasks) {
+        const stats = {
+            total: tasks.length,
+            pending: 0,
+            inProgress: 0,
+            completed: 0,
+            failed: 0,
+            skipped: 0,
+            blocked: 0,
+            expired: 0,
+        };
+        for (const task of tasks) {
+            const status = task.status;
+            switch (status) {
+                case 'pending':
+                    stats.pending++;
+                    break;
+                case 'in_progress':
+                    stats.inProgress++;
+                    break;
+                case 'completed':
+                    stats.completed++;
+                    break;
+                case 'failed':
+                    stats.failed++;
+                    break;
+                case 'skipped':
+                    stats.skipped++;
+                    break;
+                case 'expired':
+                    stats.expired++;
+                    break;
+            }
+        }
+        return stats;
+    }
+    calculateMilestoneProgress(milestones, tasks) {
+        return milestones.map((milestone) => {
+            const milestoneTasks = tasks.filter((t) => t.milestoneId === milestone.id);
+            const total = milestoneTasks.length;
+            const completed = milestoneTasks.filter((t) => t.status === 'completed').length;
+            const pending = milestoneTasks.filter((t) => t.status === 'pending').length;
+            const failed = milestoneTasks.filter((t) => t.status === 'failed').length;
+            const progress = total > 0 ? Math.round((completed / total) * 100) : 0;
+            return {
+                milestoneId: milestone.id,
+                title: milestone.title,
+                progress,
+                tasksTotal: total,
+                tasksCompleted: completed,
+                tasksPending: pending,
+                tasksFailed: failed,
+                estimatedCompletion: null,
+            };
+        });
+    }
+    calculateOverallProgress(taskStats, milestoneProgress) {
+        if (milestoneProgress.length > 0) {
+            const totalTasks = milestoneProgress.reduce((sum, m) => sum + m.tasksTotal, 0);
+            if (totalTasks === 0)
+                return 0;
+            let weightedSum = 0;
+            for (const mp of milestoneProgress) {
+                weightedSum += mp.progress * mp.tasksTotal;
+            }
+            return Math.round(weightedSum / totalTasks);
+        }
+        if (taskStats.total === 0)
+            return 0;
+        const completable = taskStats.total - taskStats.skipped;
+        if (completable === 0)
+            return 100;
+        return Math.round((taskStats.completed / completable) * 100);
+    }
+    calculateVelocity(goalHash) {
+        const records = this.completionRecords.get(goalHash) ?? [];
+        const successfulRecords = records.filter((r) => r.wasSuccessful);
+        if (successfulRecords.length < 2) {
+            return {
+                tasksPerDay: 0,
+                averageTaskDuration: 0,
+                completionRate: records.length > 0 ? successfulRecords.length / records.length : 0,
+                recentTrend: 'stable',
+                dataPoints: successfulRecords.length,
+            };
+        }
+        const oldest = successfulRecords[0].completedAt;
+        const newest = successfulRecords[successfulRecords.length - 1].completedAt;
+        const daySpan = (newest.getTime() - oldest.getTime()) / (24 * 60 * 60 * 1000);
+        const tasksPerDay = daySpan > 0 ? successfulRecords.length / daySpan : successfulRecords.length;
+        const totalDuration = successfulRecords.reduce((sum, r) => sum + r.durationMs, 0);
+        const averageTaskDuration = totalDuration / successfulRecords.length;
+        const completionRate = successfulRecords.length / records.length;
+        const midpoint = Math.floor(successfulRecords.length / 2);
+        const recentTrend = this.determineTrend(successfulRecords, midpoint);
+        return {
+            tasksPerDay: Math.round(tasksPerDay * 100) / 100,
+            averageTaskDuration: Math.round(averageTaskDuration),
+            completionRate: Math.round(completionRate * 100) / 100,
+            recentTrend,
+            dataPoints: successfulRecords.length,
+        };
+    }
+    determineTrend(records, midpoint) {
+        if (records.length < 4)
+            return 'stable';
+        const olderHalf = records.slice(0, midpoint);
+        const newerHalf = records.slice(midpoint);
+        const oldAvgDuration = olderHalf.reduce((sum, r) => sum + r.durationMs, 0) / olderHalf.length;
+        const newAvgDuration = newerHalf.reduce((sum, r) => sum + r.durationMs, 0) / newerHalf.length;
+        const changeRatio = newAvgDuration / oldAvgDuration;
+        if (changeRatio < 0.85)
+            return 'improving';
+        if (changeRatio > 1.15)
+            return 'declining';
+        return 'stable';
+    }
+    estimateCompletion(taskStats, velocity) {
+        if (velocity.tasksPerDay <= 0)
+            return null;
+        const remaining = taskStats.pending + taskStats.inProgress + taskStats.blocked;
+        if (remaining === 0)
+            return new Date();
+        const daysRemaining = remaining / velocity.tasksPerDay;
+        const estimate = new Date();
+        estimate.setDate(estimate.getDate() + Math.ceil(daysRemaining));
+        return estimate;
+    }
+    hasVelocityChanged(old, newV) {
+        return (old.tasksPerDay !== newV.tasksPerDay ||
+            old.recentTrend !== newV.recentTrend ||
+            Math.abs(old.completionRate - newV.completionRate) > 0.05);
+    }
+    startAutoSnapshots() {
+        this.snapshotTimer = setInterval(() => {
+            for (const goalHash of this.progressCache.keys()) {
+                try {
+                    this.createSnapshot(goalHash);
+                }
+                catch (error) {
+                    this.emit('error', error instanceof Error ? error : new Error(String(error)));
+                }
+            }
+        }, this.snapshotInterval);
+    }
+}
+export function createProgressTracker(options) {
+    return new ProgressTracker(options);
+}

package/dist/goals/ReviewScheduler.d.ts

@@ -0,0 +1,106 @@
+import { EventEmitter } from 'events';
+import type { Goal, GoalHash, GoalStatus, Logger } from './types.js';
+export type ReviewFrequency = 'daily' | 'weekly' | 'biweekly' | 'monthly' | 'milestone' | 'custom';
+export type ReviewType = 'progress' | 'milestone' | 'stalled' | 'deadline' | 'weekly_summary' | 'monthly_summary' | 'completion';
+export interface ScheduledReview {
+    readonly id: string;
+    readonly goalHash: GoalHash;
+    readonly type: ReviewType;
+    readonly scheduledFor: Date;
+    readonly frequency: ReviewFrequency;
+    readonly title: string;
+    readonly description?: string;
+    readonly priority: 'high' | 'medium' | 'low';
+    readonly metadata?: Record<string, unknown>;
+    readonly createdAt: Date;
+    readonly completedAt?: Date;
+    readonly snoozedUntil?: Date;
+}
+export interface ReviewScheduleConfig {
+    readonly goalHash: GoalHash;
+    readonly frequency: ReviewFrequency;
+    readonly customIntervalDays?: number;
+    readonly preferredTime?: string;
+    readonly preferredDay?: number;
+    readonly enabled: boolean;
+    readonly notifyVia?: ('comms' | 'cli' | 'native')[];
+}
+export interface ReviewTrigger {
+    readonly type: 'stalled' | 'deadline_approaching' | 'velocity_drop' | 'milestone_complete';
+    readonly thresholdDays?: number;
+    readonly velocityDropPercent?: number;
+}
+export interface ReviewResult {
+    readonly reviewId: string;
+    readonly action: 'completed' | 'snoozed' | 'skipped' | 'rescheduled';
+    readonly notes?: string;
+    readonly nextReviewDate?: Date;
+    readonly goalUpdates?: {
+        statusChange?: GoalStatus;
+        priorityChange?: string;
+        deadlineChange?: Date;
+    };
+}
+export interface ReviewSchedulerOptions {
+    readonly logger?: Logger;
+    readonly checkInterval?: number;
+    readonly defaultFrequency?: ReviewFrequency;
+    readonly stalledThresholdDays?: number;
+    readonly deadlineWarningDays?: number;
+    readonly enableAutoTriggers?: boolean;
+}
+export interface ReviewSchedulerEvents {
+    'review:due': [review: ScheduledReview];
+    'review:upcoming': [review: ScheduledReview, daysUntil: number];
+    'review:completed': [review: ScheduledReview, result: ReviewResult];
+    'review:snoozed': [review: ScheduledReview, until: Date];
+    'review:created': [review: ScheduledReview];
+    'goal:stalled': [goalHash: GoalHash, daysSinceActivity: number];
+    'deadline:approaching': [goalHash: GoalHash, daysRemaining: number];
+    error: [error: Error];
+}
+export declare class ReviewScheduler extends EventEmitter<ReviewSchedulerEvents> {
+    private readonly logger;
+    private readonly checkInterval;
+    private readonly stalledThresholdDays;
+    private readonly deadlineWarningDays;
+    private readonly enableAutoTriggers;
+    private readonly schedules;
+    private readonly reviews;
+    private readonly lastActivityDates;
+    private checkTimer;
+    private reviewCounter;
+    constructor(options?: ReviewSchedulerOptions);
+    start(): void;
+    stop(): void;
+    setSchedule(config: ReviewScheduleConfig): void;
+    removeSchedule(goalHash: GoalHash): void;
+    scheduleReview(goalHash: GoalHash, type: ReviewType, scheduledFor: Date, frequency?: ReviewFrequency, metadata?: Record<string, unknown>): ScheduledReview;
+    completeReview(reviewId: string, result: ReviewResult): void;
+    snoozeReview(reviewId: string, hours?: number): void;
+    getPendingReviews(goalHash?: GoalHash): ScheduledReview[];
+    getDueReviews(): ScheduledReview[];
+    getUpcomingReviews(withinHours?: number): ScheduledReview[];
+    recordActivity(goalHash: GoalHash): void;
+    checkStalledGoals(goals: Goal[]): GoalHash[];
+    checkApproachingDeadlines(goals: Goal[]): GoalHash[];
+    triggerMilestoneReview(goalHash: GoalHash, milestoneTitle: string): ScheduledReview;
+    triggerCompletionReview(goalHash: GoalHash): ScheduledReview;
+    getStatistics(): {
+        totalScheduled: number;
+        completed: number;
+        pending: number;
+        overdue: number;
+        snoozed: number;
+    };
+    clearGoalData(goalHash: GoalHash): void;
+    private checkDueReviews;
+    private calculateNextReviewDate;
+    private getDaysInMonth;
+    private findReview;
+    private getReviewTitle;
+    private getReviewDescription;
+    private getReviewPriority;
+    private capitalizeFirst;
+}
+export declare function createReviewScheduler(options?: ReviewSchedulerOptions): ReviewScheduler;