@flowdot.ai/daemon 1.0.0

package/dist/goals/TaskGenerator.js

@@ -0,0 +1,329 @@
+import { EventEmitter } from 'node:events';
+function getPriorityWeight(priority) {
+    switch (priority) {
+        case 'high': return 10;
+        case 'medium': return 5;
+        case 'low': return 1;
+        default: return 5;
+    }
+}
+import { TASK_TYPES } from './types.js';
+import { GoalError } from './errors.js';
+const DEFAULT_MAX_TASKS = 5;
+const DEFAULT_MODEL_TIER = 'standard';
+const noopLogger = {
+    debug: () => { },
+    info: () => { },
+    warn: () => { },
+    error: () => { },
+};
+export class TaskGenerationError extends GoalError {
+    constructor(message, cause) {
+        super('TASK_GENERATION_ERROR', message, cause ? { cause } : {});
+    }
+}
+export class LLMParseError extends GoalError {
+    constructor(message, cause) {
+        super('TASK_GENERATION_ERROR', message, cause ? { cause } : {});
+    }
+}
+export class TaskGenerator extends EventEmitter {
+    llmFunction;
+    defaultModelTier;
+    defaultMaxTasks;
+    logger;
+    constructor(options) {
+        super();
+        this.llmFunction = options.llmFunction;
+        this.defaultModelTier = options.defaultModelTier ?? DEFAULT_MODEL_TIER;
+        this.defaultMaxTasks = options.defaultMaxTasks ?? DEFAULT_MAX_TASKS;
+        this.logger = options.logger ?? noopLogger;
+    }
+    async generateTasks(goal, milestones, existingTasks, options = {}) {
+        const maxTasks = options.maxTasks ?? this.defaultMaxTasks;
+        const modelTier = options.modelTier ?? this.defaultModelTier;
+        this.logger.info('TASK_GENERATOR', 'Generating tasks for goal', {
+            goalHash: goal.hash,
+            goalName: goal.name,
+            maxTasks,
+        });
+        this.emit('generationStarted', goal.hash, options);
+        try {
+            const prompt = this.buildGenerationPrompt(goal, milestones, existingTasks, options);
+            const response = await this.llmFunction(prompt, {
+                modelTier,
+                maxTokens: 4000,
+                temperature: 0.7,
+            });
+            const result = this.parseGenerationResponse(response, goal, options);
+            for (const suggestion of result.suggestions) {
+                this.emit('taskSuggested', goal.hash, suggestion);
+            }
+            this.logger.info('TASK_GENERATOR', 'Task generation completed', {
+                goalHash: goal.hash,
+                taskCount: result.suggestions.length,
+            });
+            this.emit('generationCompleted', goal.hash, result);
+            return result;
+        }
+        catch (err) {
+            const error = err instanceof Error ? err : new Error(String(err));
+            this.logger.error('TASK_GENERATOR', 'Task generation failed', {
+                goalHash: goal.hash,
+                error: error.message,
+            });
+            this.emit('generationFailed', goal.hash, error);
+            throw new TaskGenerationError(`Failed to generate tasks for goal: ${error.message}`, error);
+        }
+    }
+    async generateDailyTasks(goal, milestones, existingTasks, options = {}) {
+        const dailyContext = `
+Focus on tasks that can be completed TODAY. Consider:
+- Current progress: ${goal.progress}%
+- Priority: ${goal.priority}
+- Generate small, actionable tasks that make incremental progress
+- Avoid tasks that require extended periods of work
+- Prioritize tasks that unblock other work
+`;
+        return this.generateTasks(goal, milestones, existingTasks, {
+            ...options,
+            maxTasks: options.maxTasks ?? 3,
+            additionalContext: dailyContext + (options.additionalContext ?? ''),
+        });
+    }
+    async suggestNextTask(goal, milestones, pendingTasks, options = {}) {
+        if (pendingTasks.length > 0) {
+            const sorted = [...pendingTasks].sort((a, b) => getPriorityWeight(b.priority) - getPriorityWeight(a.priority));
+            const topTask = sorted[0];
+            return {
+                title: topTask.title,
+                description: topTask.description ?? '',
+                type: topTask.taskType,
+                priority: getPriorityWeight(topTask.priority),
+                reasoning: 'Highest priority pending task',
+                milestoneId: topTask.milestoneId ?? undefined,
+            };
+        }
+        const result = await this.generateTasks(goal, milestones, [], {
+            ...options,
+            maxTasks: 1,
+            additionalContext: 'Generate the single most impactful next task for this goal.',
+        });
+        return result.suggestions[0] ?? null;
+    }
+    suggestionToInput(suggestion, _goalHash) {
+        return {
+            taskType: suggestion.type,
+            title: suggestion.title,
+            description: suggestion.description,
+            milestoneId: suggestion.milestoneId,
+            scheduledFor: suggestion.scheduledFor,
+        };
+    }
+    buildGenerationPrompt(goal, milestones, existingTasks, options) {
+        const maxTasks = options.maxTasks ?? this.defaultMaxTasks;
+        const taskTypesStr = options.taskTypes
+            ? options.taskTypes.join(', ')
+            : TASK_TYPES.join(', ');
+        let milestoneContext = '';
+        if (milestones.length > 0) {
+            milestoneContext = '\n## Milestones\n';
+            for (const m of milestones) {
+                const status = m.completedAt ? '✓ COMPLETED' : 'PENDING';
+                milestoneContext += `- [${status}] ${m.title}`;
+                if (m.description)
+                    milestoneContext += `: ${m.description}`;
+                if (m.targetDate)
+                    milestoneContext += ` (target: ${m.targetDate})`;
+                milestoneContext += `\n  ID: ${m.id}\n`;
+            }
+        }
+        let existingTasksContext = '';
+        if (existingTasks.length > 0) {
+            existingTasksContext = '\n## Existing Tasks\n';
+            for (const t of existingTasks) {
+                existingTasksContext += `- [${t.status}] ${t.title} (${t.taskType})\n`;
+            }
+            existingTasksContext +=
+                '\nDo not duplicate existing tasks. Build on completed work.\n';
+        }
+        let metaGoalContext = '';
+        if (options.metaGoals && options.metaGoals.length > 0) {
+            metaGoalContext = '\n## Meta-Goal Constraints\n';
+            for (const mg of options.metaGoals) {
+                metaGoalContext += `- [Priority ${mg.priority}]: ${mg.description}\n`;
+            }
+        }
+        let targetMilestone = '';
+        if (options.milestoneId) {
+            const milestone = milestones.find((m) => m.id === options.milestoneId);
+            if (milestone) {
+                targetMilestone = `\n## Focus Milestone\nGenerate tasks specifically for: "${milestone.title}"\n`;
+            }
+        }
+        return `You are a task planning assistant. Generate actionable tasks for the following goal.
+
+# Goal
+Name: ${goal.name}
+Description: ${goal.description ?? 'No description provided'}
+Status: ${goal.status}
+Priority: ${goal.priority}
+Progress: ${goal.progress}%
+Target Date: ${goal.deadline ?? 'No target date'}
+${milestoneContext}${existingTasksContext}${metaGoalContext}${targetMilestone}
+${options.additionalContext ?? ''}
+
+# Instructions
+Generate up to ${maxTasks} tasks that will help achieve this goal.
+
+## Task Types Available
+${taskTypesStr}
+
+- **research**: Web search, file reading, information gathering
+- **draft**: Content creation, writing, documentation
+- **code**: Code analysis, changes, refactoring
+- **execute**: Command execution, running scripts
+- **recipe**: FlowDot recipe invocation
+- **loop**: Create recurring task
+- **notify**: Send notification
+
+## Output Format
+Respond with a JSON object containing:
+{
+  "planSummary": "Brief overview of the task plan",
+  "suggestions": [
+    {
+      "title": "Clear, actionable task title",
+      "description": "Detailed description of what to do",
+      "type": "research|draft|code|execute|recipe|loop|notify",
+      "priority": 1-10,
+      "milestoneId": number or null,
+      "reasoning": "Why this task is important",
+      "scheduledFor": "ISO date or null for ASAP",
+      "expiresAt": "ISO date or null for no expiry",
+      "estimatedCost": number or null,
+      "dependsOnTasks": ["task titles this depends on"]
+    }
+  ],
+  "warnings": ["Any concerns or notes"],
+  "estimatedEffort": "e.g., '2-3 hours' or '1 day'"
+}
+
+Generate tasks that are:
+1. Specific and actionable
+2. Appropriate for the current progress level
+3. Ordered by priority and dependency
+4. Realistic for the target date (if set)
+
+Respond ONLY with valid JSON, no markdown code blocks or other text.`;
+    }
+    parseGenerationResponse(response, goal, options) {
+        try {
+            let cleanResponse = response.trim();
+            if (cleanResponse.startsWith('```json')) {
+                cleanResponse = cleanResponse.slice(7);
+            }
+            else if (cleanResponse.startsWith('```')) {
+                cleanResponse = cleanResponse.slice(3);
+            }
+            if (cleanResponse.endsWith('```')) {
+                cleanResponse = cleanResponse.slice(0, -3);
+            }
+            cleanResponse = cleanResponse.trim();
+            const parsed = JSON.parse(cleanResponse);
+            const suggestions = [];
+            if (Array.isArray(parsed.suggestions)) {
+                for (const s of parsed.suggestions) {
+                    const suggestion = this.validateSuggestion(s);
+                    if (suggestion) {
+                        suggestions.push(suggestion);
+                    }
+                }
+            }
+            return {
+                suggestions,
+                planSummary: parsed.planSummary ?? 'Task plan generated',
+                warnings: Array.isArray(parsed.warnings) ? parsed.warnings : [],
+                estimatedEffort: parsed.estimatedEffort,
+                metadata: {
+                    generatedAt: new Date().toISOString(),
+                    modelTier: options.modelTier ?? this.defaultModelTier,
+                },
+            };
+        }
+        catch (err) {
+            this.logger.error('TASK_GENERATOR', 'Failed to parse LLM response', {
+                response: response.substring(0, 500),
+                error: err instanceof Error ? err.message : String(err),
+            });
+            throw new LLMParseError(`Failed to parse task generation response: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    validateSuggestion(raw) {
+        if (!raw || typeof raw !== 'object') {
+            return null;
+        }
+        const s = raw;
+        const title = typeof s.title === 'string' ? s.title.trim() : '';
+        const description = typeof s.description === 'string' ? s.description.trim() : '';
+        const type = this.validateTaskType(s.type);
+        if (!title || !type) {
+            this.logger.warn('TASK_GENERATOR', 'Invalid suggestion - missing fields', {
+                hasTitle: !!title,
+                hasType: !!type,
+            });
+            return null;
+        }
+        let priority = 5;
+        if (typeof s.priority === 'number') {
+            priority = Math.max(1, Math.min(10, Math.round(s.priority)));
+        }
+        return {
+            title,
+            description,
+            type,
+            priority,
+            reasoning: typeof s.reasoning === 'string' ? s.reasoning : '',
+            scheduledFor: typeof s.scheduledFor === 'string' ? s.scheduledFor : undefined,
+            expiresAt: typeof s.expiresAt === 'string' ? s.expiresAt : undefined,
+            milestoneId: typeof s.milestoneId === 'number' ? s.milestoneId : undefined,
+            estimatedCost: typeof s.estimatedCost === 'number' ? s.estimatedCost : undefined,
+            dependsOnTasks: Array.isArray(s.dependsOnTasks)
+                ? s.dependsOnTasks.filter((d) => typeof d === 'string')
+                : undefined,
+        };
+    }
+    validateTaskType(raw) {
+        if (typeof raw !== 'string') {
+            return null;
+        }
+        const normalized = raw.toLowerCase().trim();
+        if (TASK_TYPES.includes(normalized)) {
+            return normalized;
+        }
+        const mappings = {
+            search: 'research',
+            read: 'research',
+            investigate: 'research',
+            write: 'draft',
+            create: 'draft',
+            document: 'draft',
+            coding: 'code',
+            implement: 'code',
+            develop: 'code',
+            run: 'execute',
+            command: 'execute',
+            script: 'execute',
+            workflow: 'recipe',
+            automation: 'recipe',
+            recurring: 'loop',
+            schedule: 'loop',
+            alert: 'notify',
+            message: 'notify',
+        };
+        return mappings[normalized] ?? null;
+    }
+}
+export function createTaskGenerator(options) {
+    return new TaskGenerator(options);
+}

package/dist/goals/TaskQueue.d.ts

@@ -0,0 +1,84 @@
+import { EventEmitter } from 'node:events';
+import type { Task, TaskStatus, TaskType, GoalHash, Logger } from './types.js';
+import { GoalError } from './errors.js';
+export interface QueuedTask {
+    readonly task: Task;
+    readonly goalHash: GoalHash;
+    readonly queuedAt: Date;
+    readonly priorityScore: number;
+    readonly isReady: boolean;
+    readonly notReadyReason?: string;
+}
+export interface TaskQueueOptions {
+    readonly maxTasksPerDay?: number;
+    readonly quietHours?: {
+        readonly start: number;
+        readonly end: number;
+    };
+    readonly enforceQuietHours?: boolean;
+    readonly typeWeights?: Partial<Record<TaskType, number>>;
+    readonly logger?: Logger;
+}
+export interface TaskQueueStats {
+    readonly totalPending: number;
+    readonly readyCount: number;
+    readonly scheduledCount: number;
+    readonly expiredCount: number;
+    readonly executedToday: number;
+    readonly remainingQuota: number;
+    readonly inQuietHours: boolean;
+    readonly byGoal: Map<GoalHash, number>;
+    readonly byType: Map<TaskType, number>;
+}
+export interface TaskQueueEvents {
+    taskAdded: [task: Task, goalHash: GoalHash];
+    taskRemoved: [taskId: number, goalHash: GoalHash, reason: string];
+    taskExpired: [task: Task, goalHash: GoalHash];
+    queueCleared: [goalHash?: GoalHash];
+    quietHoursStarted: [];
+    quietHoursEnded: [];
+    quotaReached: [executedCount: number];
+}
+export interface TaskFilterOptions {
+    readonly goalHash?: GoalHash;
+    readonly type?: TaskType;
+    readonly status?: TaskStatus;
+    readonly readyOnly?: boolean;
+    readonly limit?: number;
+}
+export declare class TaskQueueError extends GoalError {
+    constructor(message: string, cause?: Error);
+}
+export declare class QuotaExceededError extends GoalError {
+    constructor(executed: number, max: number);
+}
+export declare class TaskQueue extends EventEmitter<TaskQueueEvents> {
+    private readonly maxTasksPerDay;
+    private readonly quietHours;
+    private readonly enforceQuietHours;
+    private readonly typeWeights;
+    private readonly logger;
+    private readonly tasks;
+    private executedToday;
+    private lastResetDate;
+    private quietHoursTimer;
+    constructor(options?: TaskQueueOptions);
+    addTask(task: Task, goalHash: GoalHash): void;
+    addTasks(tasks: Task[], goalHash: GoalHash): void;
+    removeTask(taskId: number, goalHash: GoalHash, reason?: string): boolean;
+    getNextTask(options?: TaskFilterOptions): QueuedTask | null;
+    getTasks(options?: TaskFilterOptions): QueuedTask[];
+    getReadyTasks(options?: Omit<TaskFilterOptions, 'readyOnly'>): QueuedTask[];
+    markTaskStarted(taskId: number, goalHash: GoalHash): void;
+    clearGoal(goalHash: GoalHash): number;
+    clearAll(): number;
+    getStats(): TaskQueueStats;
+    isInQuietHours(): boolean;
+    hasQuota(): boolean;
+    stop(): void;
+    private createQueuedTask;
+    private calculatePriorityScore;
+    private pruneExpiredTasks;
+    private resetDailyCounterIfNeeded;
+}
+export declare function createTaskQueue(options?: TaskQueueOptions): TaskQueue;