@flowdot.ai/daemon 1.0.0

package/dist/goals/GoalReporter.js

@@ -0,0 +1,534 @@
+import { EventEmitter } from 'events';
+const DEFAULT_PERIOD_DAYS = 7;
+const DEFAULT_SECTIONS = [
+    'overview',
+    'milestones',
+    'tasks',
+    'velocity',
+    'actions',
+];
+export class GoalReporter extends EventEmitter {
+    logger;
+    defaultFormat;
+    defaultDetailLevel;
+    defaultPeriodDays;
+    reportCounter = 0;
+    constructor(options = {}) {
+        super();
+        this.logger = options.logger ?? console;
+        this.defaultFormat = options.defaultFormat ?? 'markdown';
+        this.defaultDetailLevel = options.defaultDetailLevel ?? 'standard';
+        this.defaultPeriodDays = options.defaultPeriodDays ?? DEFAULT_PERIOD_DAYS;
+    }
+    generateReport(goal, progress, milestones, tasks, snapshots = [], options = {}) {
+        const format = options.format ?? this.defaultFormat;
+        const detailLevel = options.detailLevel ?? this.defaultDetailLevel;
+        const periodDays = options.periodDays ?? this.defaultPeriodDays;
+        const sections = options.sections ?? DEFAULT_SECTIONS;
+        const period = this.calculatePeriod(periodDays);
+        const metadata = this.buildMetadata(progress, options.compareWithSnapshot);
+        const sectionContents = [];
+        for (const section of sections) {
+            const content = this.generateSection(section, goal, progress, milestones, tasks, snapshots, detailLevel, format);
+            if (content) {
+                sectionContents.push(content);
+            }
+        }
+        const fullContent = this.combineContent(sectionContents, format, goal, period);
+        const report = {
+            id: `report_${++this.reportCounter}_${Date.now()}`,
+            goalHash: goal.hash,
+            title: `Progress Report: ${goal.name}`,
+            generatedAt: new Date(),
+            period,
+            format,
+            detailLevel,
+            content: fullContent,
+            sections: sectionContents,
+            metadata,
+        };
+        this.emit('report:generated', report);
+        const actions = this.identifyActionItems(goal, progress, milestones, tasks);
+        if (actions.length > 0) {
+            this.emit('actions:identified', goal.hash, actions);
+        }
+        if (options.includeRisks) {
+            const risks = this.assessRisks(goal, progress, milestones, tasks);
+            if (risks.length > 0) {
+                this.emit('risks:identified', goal.hash, risks);
+            }
+        }
+        return report;
+    }
+    generateSummary(goal, progress) {
+        const lines = [];
+        lines.push(`📊 **${goal.name}**`);
+        lines.push(`Progress: ${progress.overallProgress}%`);
+        lines.push(`Tasks: ${progress.taskStats.completed}/${progress.taskStats.total} completed`);
+        if (progress.velocity.tasksPerDay > 0) {
+            lines.push(`Velocity: ${progress.velocity.tasksPerDay} tasks/day`);
+        }
+        if (progress.estimatedCompletion) {
+            lines.push(`Est. Completion: ${this.formatDate(progress.estimatedCompletion)}`);
+        }
+        return lines.join('\n');
+    }
+    generateComparisonReport(goal, current, previous, format = 'markdown') {
+        const progressDelta = current.overallProgress - previous.progress;
+        const tasksCompleted = current.taskStats.completed - previous.taskStats.completed;
+        if (format === 'json') {
+            return JSON.stringify({
+                goalHash: goal.hash,
+                title: goal.name,
+                current: {
+                    progress: current.overallProgress,
+                    tasks: current.taskStats,
+                },
+                previous: {
+                    progress: previous.progress,
+                    tasks: previous.taskStats,
+                    timestamp: previous.timestamp,
+                },
+                delta: {
+                    progress: progressDelta,
+                    tasksCompleted,
+                },
+            }, null, 2);
+        }
+        const lines = [];
+        lines.push(`## Progress Comparison: ${goal.name}\n`);
+        lines.push(`**Period**: ${this.formatDate(previous.timestamp)} → Now\n`);
+        lines.push(`### Changes`);
+        lines.push(`- Progress: ${previous.progress}% → ${current.overallProgress}% (${progressDelta >= 0 ? '+' : ''}${progressDelta}%)`);
+        lines.push(`- Tasks Completed: +${tasksCompleted}`);
+        lines.push(`- Current Velocity: ${current.velocity.tasksPerDay} tasks/day`);
+        lines.push(`- Trend: ${this.formatTrend(current.velocity.recentTrend)}`);
+        return lines.join('\n');
+    }
+    identifyActionItems(goal, progress, milestones, tasks) {
+        const actions = [];
+        let actionCounter = 0;
+        const failedTasks = tasks.filter((t) => t.status === 'failed');
+        for (const task of failedTasks) {
+            actions.push({
+                id: `action_${++actionCounter}`,
+                type: 'blocked_task',
+                priority: 'high',
+                description: `Task "${task.title}" has failed`,
+                relatedTaskId: task.id,
+                suggestedAction: 'Review error and retry or skip task',
+            });
+        }
+        const now = new Date();
+        const overdueTasks = tasks.filter((t) => t.status === 'pending' &&
+            t.deadline &&
+            new Date(t.deadline) < now);
+        for (const task of overdueTasks) {
+            actions.push({
+                id: `action_${++actionCounter}`,
+                type: 'overdue',
+                priority: 'high',
+                description: `Task "${task.title}" is overdue`,
+                relatedTaskId: task.id,
+                suggestedAction: 'Reschedule or prioritize immediately',
+            });
+        }
+        const tomorrow = new Date();
+        tomorrow.setDate(tomorrow.getDate() + 1);
+        const atRiskTasks = tasks.filter((t) => t.status === 'pending' &&
+            t.deadline &&
+            new Date(t.deadline) <= tomorrow &&
+            new Date(t.deadline) >= now);
+        for (const task of atRiskTasks) {
+            actions.push({
+                id: `action_${++actionCounter}`,
+                type: 'at_risk',
+                priority: 'medium',
+                description: `Task "${task.title}" deadline approaching`,
+                relatedTaskId: task.id,
+                suggestedAction: 'Prioritize to complete before deadline',
+            });
+        }
+        const pendingApproval = tasks.filter((t) => t.status === 'pending' && t.requiresApproval);
+        for (const task of pendingApproval) {
+            actions.push({
+                id: `action_${++actionCounter}`,
+                type: 'approval_pending',
+                priority: 'medium',
+                description: `Task "${task.title}" requires approval`,
+                relatedTaskId: task.id,
+                suggestedAction: 'Review and approve/deny task',
+            });
+        }
+        for (const mp of progress.milestoneProgress) {
+            if (mp.progress > 0 && mp.progress < 100 && mp.tasksPending === 0 && mp.tasksFailed > 0) {
+                const milestone = milestones.find((m) => m.id === mp.milestoneId);
+                actions.push({
+                    id: `action_${++actionCounter}`,
+                    type: 'review_needed',
+                    priority: 'high',
+                    description: `Milestone "${milestone?.title ?? mp.milestoneId}" has failed tasks`,
+                    relatedMilestoneId: mp.milestoneId,
+                    suggestedAction: 'Review failed tasks and create recovery plan',
+                });
+            }
+        }
+        return actions;
+    }
+    assessRisks(goal, progress, _milestones, _tasks) {
+        const risks = [];
+        let riskCounter = 0;
+        if (goal.deadline && progress.estimatedCompletion) {
+            const deadline = new Date(goal.deadline);
+            if (progress.estimatedCompletion > deadline) {
+                const daysOver = Math.ceil((progress.estimatedCompletion.getTime() - deadline.getTime()) /
+                    (24 * 60 * 60 * 1000));
+                risks.push({
+                    id: `risk_${++riskCounter}`,
+                    severity: daysOver > 7 ? 'high' : daysOver > 3 ? 'medium' : 'low',
+                    category: 'deadline',
+                    description: `Goal may miss deadline by ~${daysOver} days`,
+                    mitigation: 'Increase velocity or reduce scope',
+                    likelihood: Math.min(0.9, 0.5 + daysOver * 0.05),
+                });
+            }
+        }
+        if (progress.velocity.recentTrend === 'declining') {
+            risks.push({
+                id: `risk_${++riskCounter}`,
+                severity: 'medium',
+                category: 'resources',
+                description: 'Task completion velocity is declining',
+                mitigation: 'Review blockers and resource allocation',
+                likelihood: 0.7,
+            });
+        }
+        const failureRate = progress.taskStats.total > 0
+            ? progress.taskStats.failed / progress.taskStats.total
+            : 0;
+        if (failureRate > 0.2) {
+            risks.push({
+                id: `risk_${++riskCounter}`,
+                severity: failureRate > 0.4 ? 'high' : 'medium',
+                category: 'technical',
+                description: `High task failure rate (${Math.round(failureRate * 100)}%)`,
+                mitigation: 'Analyze failure patterns and address root causes',
+                likelihood: 0.8,
+            });
+        }
+        const blockedCount = progress.taskStats.blocked;
+        if (blockedCount > 0) {
+            risks.push({
+                id: `risk_${++riskCounter}`,
+                severity: blockedCount > 3 ? 'high' : 'medium',
+                category: 'dependencies',
+                description: `${blockedCount} tasks are blocked`,
+                mitigation: 'Resolve blocking dependencies',
+                likelihood: 0.9,
+            });
+        }
+        return risks;
+    }
+    calculatePeriod(days) {
+        const end = new Date();
+        const start = new Date();
+        start.setDate(start.getDate() - days);
+        return {
+            start,
+            end,
+            label: `Last ${days} days`,
+        };
+    }
+    buildMetadata(progress, compareSnapshot) {
+        return {
+            progress: progress.overallProgress,
+            taskStats: progress.taskStats,
+            velocity: progress.velocity,
+            estimatedCompletion: progress.estimatedCompletion,
+            previousProgress: compareSnapshot?.progress,
+            progressDelta: compareSnapshot
+                ? progress.overallProgress - compareSnapshot.progress
+                : undefined,
+        };
+    }
+    generateSection(section, goal, progress, milestones, tasks, snapshots, detailLevel, format) {
+        switch (section) {
+            case 'overview':
+                return this.generateOverviewSection(goal, progress, format);
+            case 'milestones':
+                return this.generateMilestonesSection(progress, milestones, detailLevel, format);
+            case 'tasks':
+                return this.generateTasksSection(progress, tasks, detailLevel, format);
+            case 'velocity':
+                return this.generateVelocitySection(progress, format);
+            case 'history':
+                return this.generateHistorySection(snapshots, format);
+            case 'actions':
+                return this.generateActionsSection(this.identifyActionItems(goal, progress, milestones, tasks), format);
+            case 'risks':
+                return this.generateRisksSection(this.assessRisks(goal, progress, milestones, tasks), format);
+            default:
+                return null;
+        }
+    }
+    generateOverviewSection(goal, progress, format) {
+        let content;
+        if (format === 'json') {
+            content = JSON.stringify({
+                status: goal.status,
+                progress: progress.overallProgress,
+                estimatedCompletion: progress.estimatedCompletion,
+                lastUpdated: progress.lastUpdated,
+            });
+        }
+        else {
+            const lines = [];
+            lines.push(`**Status**: ${goal.status}`);
+            lines.push(`**Progress**: ${progress.overallProgress}%`);
+            lines.push(this.renderProgressBar(progress.overallProgress));
+            if (progress.estimatedCompletion) {
+                lines.push(`**Est. Completion**: ${this.formatDate(progress.estimatedCompletion)}`);
+            }
+            if (goal.deadline) {
+                lines.push(`**Deadline**: ${this.formatDate(new Date(goal.deadline))}`);
+            }
+            content = lines.join('\n');
+        }
+        return {
+            section: 'overview',
+            title: 'Overview',
+            content,
+            data: {
+                status: goal.status,
+                progress: progress.overallProgress,
+            },
+        };
+    }
+    generateMilestonesSection(progress, milestones, detailLevel, format) {
+        let content;
+        if (format === 'json') {
+            content = JSON.stringify(progress.milestoneProgress);
+        }
+        else {
+            const lines = [];
+            for (const mp of progress.milestoneProgress) {
+                const milestone = milestones.find((m) => m.id === mp.milestoneId);
+                const statusIcon = mp.progress === 100 ? '✅' : mp.progress > 0 ? '🔄' : '⏳';
+                lines.push(`${statusIcon} **${milestone?.title ?? `Milestone ${mp.milestoneId}`}**`);
+                lines.push(`   ${this.renderProgressBar(mp.progress)} ${mp.progress}%`);
+                if (detailLevel !== 'summary') {
+                    lines.push(`   Tasks: ${mp.tasksCompleted}/${mp.tasksTotal} completed`);
+                }
+                lines.push('');
+            }
+            content = lines.join('\n');
+        }
+        return {
+            section: 'milestones',
+            title: 'Milestones',
+            content,
+            data: { milestones: progress.milestoneProgress },
+        };
+    }
+    generateTasksSection(progress, tasks, detailLevel, format) {
+        const stats = progress.taskStats;
+        let content;
+        if (format === 'json') {
+            content = JSON.stringify(stats);
+        }
+        else {
+            const lines = [];
+            lines.push(`**Total**: ${stats.total}`);
+            lines.push(`**Completed**: ${stats.completed} ✅`);
+            lines.push(`**In Progress**: ${stats.inProgress} 🔄`);
+            lines.push(`**Pending**: ${stats.pending} ⏳`);
+            if (stats.blocked > 0)
+                lines.push(`**Blocked**: ${stats.blocked} 🚫`);
+            if (stats.failed > 0)
+                lines.push(`**Failed**: ${stats.failed} ❌`);
+            if (stats.skipped > 0)
+                lines.push(`**Skipped**: ${stats.skipped} ⏭️`);
+            if (detailLevel === 'detailed' || detailLevel === 'full') {
+                lines.push('\n**Recent Tasks**:');
+                const recentTasks = tasks
+                    .filter((t) => t.status === 'completed')
+                    .slice(-5);
+                for (const task of recentTasks) {
+                    lines.push(`- ✅ ${task.title}`);
+                }
+            }
+            content = lines.join('\n');
+        }
+        return {
+            section: 'tasks',
+            title: 'Tasks',
+            content,
+            data: { ...stats },
+        };
+    }
+    generateVelocitySection(progress, format) {
+        const velocity = progress.velocity;
+        let content;
+        if (format === 'json') {
+            content = JSON.stringify(velocity);
+        }
+        else {
+            const lines = [];
+            lines.push(`**Tasks/Day**: ${velocity.tasksPerDay}`);
+            lines.push(`**Avg Duration**: ${this.formatDuration(velocity.averageTaskDuration)}`);
+            lines.push(`**Success Rate**: ${Math.round(velocity.completionRate * 100)}%`);
+            lines.push(`**Trend**: ${this.formatTrend(velocity.recentTrend)}`);
+            lines.push(`*Based on ${velocity.dataPoints} data points*`);
+            content = lines.join('\n');
+        }
+        return {
+            section: 'velocity',
+            title: 'Velocity',
+            content,
+            data: { ...velocity },
+        };
+    }
+    generateHistorySection(snapshots, format) {
+        let content;
+        if (format === 'json') {
+            content = JSON.stringify(snapshots.slice(-10));
+        }
+        else {
+            if (snapshots.length === 0) {
+                content = '*No historical data available*';
+            }
+            else {
+                const lines = [];
+                const recent = snapshots.slice(-7);
+                for (const snap of recent) {
+                    lines.push(`- ${this.formatDate(snap.timestamp)}: ${snap.progress}%`);
+                }
+                content = lines.join('\n');
+            }
+        }
+        return {
+            section: 'history',
+            title: 'History',
+            content,
+            data: { snapshots: snapshots.slice(-10) },
+        };
+    }
+    generateActionsSection(actions, format) {
+        let content;
+        if (format === 'json') {
+            content = JSON.stringify(actions);
+        }
+        else {
+            if (actions.length === 0) {
+                content = '✅ No action items';
+            }
+            else {
+                const lines = [];
+                const priorityOrder = { high: 0, medium: 1, low: 2 };
+                const sorted = [...actions].sort((a, b) => priorityOrder[a.priority] - priorityOrder[b.priority]);
+                for (const action of sorted) {
+                    const icon = action.priority === 'high'
+                        ? '🔴'
+                        : action.priority === 'medium'
+                            ? '🟡'
+                            : '🟢';
+                    lines.push(`${icon} **${action.type}**: ${action.description}`);
+                    if (action.suggestedAction) {
+                        lines.push(`   → ${action.suggestedAction}`);
+                    }
+                }
+                content = lines.join('\n');
+            }
+        }
+        return {
+            section: 'actions',
+            title: 'Action Items',
+            content,
+            data: { actions },
+        };
+    }
+    generateRisksSection(risks, format) {
+        let content;
+        if (format === 'json') {
+            content = JSON.stringify(risks);
+        }
+        else {
+            if (risks.length === 0) {
+                content = '✅ No significant risks identified';
+            }
+            else {
+                const lines = [];
+                for (const risk of risks) {
+                    const icon = risk.severity === 'high'
+                        ? '🔴'
+                        : risk.severity === 'medium'
+                            ? '🟡'
+                            : '🟢';
+                    lines.push(`${icon} **${risk.category}**: ${risk.description}`);
+                    if (risk.mitigation) {
+                        lines.push(`   Mitigation: ${risk.mitigation}`);
+                    }
+                }
+                content = lines.join('\n');
+            }
+        }
+        return {
+            section: 'risks',
+            title: 'Risks',
+            content,
+            data: { risks },
+        };
+    }
+    combineContent(sections, format, goal, period) {
+        if (format === 'json') {
+            return JSON.stringify({
+                goal: { hash: goal.hash, title: goal.name },
+                period,
+                sections: sections.map((s) => ({ section: s.section, data: s.data })),
+            }, null, 2);
+        }
+        const lines = [];
+        lines.push(`# Progress Report: ${goal.name}`);
+        lines.push(`*Generated: ${this.formatDate(new Date())}*`);
+        lines.push(`*Period: ${period.label}*\n`);
+        for (const section of sections) {
+            lines.push(`## ${section.title}\n`);
+            lines.push(section.content);
+            lines.push('');
+        }
+        return lines.join('\n');
+    }
+    renderProgressBar(percent) {
+        const filled = Math.round(percent / 10);
+        const empty = 10 - filled;
+        return `[${'█'.repeat(filled)}${'░'.repeat(empty)}]`;
+    }
+    formatDate(date) {
+        return date.toLocaleDateString('en-US', {
+            year: 'numeric',
+            month: 'short',
+            day: 'numeric',
+        });
+    }
+    formatDuration(ms) {
+        if (ms < 60000)
+            return `${Math.round(ms / 1000)}s`;
+        if (ms < 3600000)
+            return `${Math.round(ms / 60000)}m`;
+        return `${Math.round(ms / 3600000)}h`;
+    }
+    formatTrend(trend) {
+        switch (trend) {
+            case 'improving':
+                return '📈 Improving';
+            case 'declining':
+                return '📉 Declining';
+            case 'stable':
+            default:
+                return '➡️ Stable';
+        }
+    }
+}
+export function createGoalReporter(options) {
+    return new GoalReporter(options);
+}

package/dist/goals/GoalScheduler.d.ts

@@ -0,0 +1,102 @@
+import { EventEmitter } from 'node:events';
+import type { GoalHash, Logger } from './types.js';
+export interface ScheduledGoal {
+    id: number;
+    hash: GoalHash;
+    userId: number;
+    name: string;
+    description: string | null;
+    approvalMode: 'full' | 'category' | 'trusted';
+    scheduleType: 'cron' | 'interval';
+    cronExpression: string | null;
+    intervalMinutes: number | null;
+    scheduleTimezone: string;
+    executionRecipe: string | null;
+    maxIterations: number;
+    maxRuntimeMinutes: number;
+    llmTier: 'simple' | 'capable' | 'complex';
+    allowedActions: string[] | null;
+    blockedActions: string[] | null;
+    nextRunAt: string;
+    consecutiveFailures: number;
+    user: {
+        id: number;
+        name: string;
+        email: string;
+    };
+}
+export type GetDueGoalsFunction = () => Promise<ScheduledGoal[]>;
+export type MarkGoalStartedFunction = (goalId: number, metadata?: Record<string, unknown>) => Promise<void>;
+export type MarkGoalCompletedFunction = (goalId: number, status: 'success' | 'failed', options?: {
+    error?: string;
+    progress?: number;
+}) => Promise<{
+    nextRunAt: string | null;
+    scheduleActive: boolean;
+}>;
+export type ExecuteGoalFunction = (goal: ScheduledGoal) => Promise<{
+    success: boolean;
+    data?: unknown;
+    error?: string;
+}>;
+export interface GoalSchedulerOptions {
+    getDueGoals: GetDueGoalsFunction;
+    markGoalStarted: MarkGoalStartedFunction;
+    markGoalCompleted: MarkGoalCompletedFunction;
+    executeGoal: ExecuteGoalFunction;
+    pollIntervalMs?: number;
+    maxConcurrentExecutions?: number;
+    logger?: Logger;
+}
+export interface GoalSchedulerEvents {
+    'poll-started': [];
+    'poll-completed': [dueGoalsCount: number];
+    'execution-started': [goal: ScheduledGoal];
+    'execution-completed': [goal: ScheduledGoal, success: boolean, error?: string];
+    'execution-skipped': [goal: ScheduledGoal, reason: string];
+    error: [error: Error, context?: Record<string, unknown>];
+}
+interface ExecutionState {
+    goalHash: GoalHash;
+    goalId: number;
+    startedAt: Date;
+    status: 'running' | 'completed' | 'failed';
+}
+export declare class GoalScheduler extends EventEmitter {
+    private readonly getDueGoals;
+    private readonly markGoalStarted;
+    private readonly markGoalCompleted;
+    private readonly executeGoal;
+    private readonly pollIntervalMs;
+    private readonly maxConcurrentExecutions;
+    private readonly logger;
+    private pollTimer;
+    private isPolling;
+    private readonly activeExecutions;
+    private started;
+    private startedAt;
+    private totalPollCount;
+    private totalExecutionCount;
+    private totalSuccessCount;
+    private totalFailureCount;
+    constructor(options: GoalSchedulerOptions);
+    start(): void;
+    stop(): void;
+    isRunning(): boolean;
+    poll(): Promise<void>;
+    private executeGoalInBackground;
+    getActiveExecutions(): ExecutionState[];
+    isGoalExecuting(goalHash: GoalHash): boolean;
+    getStats(): {
+        running: boolean;
+        startedAt: Date | null;
+        activeExecutions: number;
+        totalPollCount: number;
+        totalExecutionCount: number;
+        totalSuccessCount: number;
+        totalFailureCount: number;
+    };
+    triggerPollNow(): Promise<void>;
+}
+export declare function createGoalScheduler(options: GoalSchedulerOptions): GoalScheduler;
+export {};