@flowdot.ai/daemon 1.0.0

package/dist/goals/TaskFeedback.js

@@ -0,0 +1,402 @@
+import { EventEmitter } from 'events';
+const DEFAULT_MAX_ENTRIES = 10000;
+const DEFAULT_PATTERN_THRESHOLD = 5;
+const DEFAULT_TREND_WINDOW_DAYS = 7;
+export class TaskFeedback extends EventEmitter {
+    logger;
+    maxEntries;
+    patternThreshold;
+    trendWindowDays;
+    feedback = new Map();
+    patterns = new Map();
+    feedbackCounter = 0;
+    patternCounter = 0;
+    constructor(options = {}) {
+        super();
+        this.logger = options.logger ?? console;
+        this.maxEntries = options.maxFeedbackEntries ?? DEFAULT_MAX_ENTRIES;
+        this.patternThreshold =
+            options.patternDetectionThreshold ?? DEFAULT_PATTERN_THRESHOLD;
+        this.trendWindowDays = options.trendWindowDays ?? DEFAULT_TREND_WINDOW_DAYS;
+    }
+    submitFeedback(input) {
+        const sentiment = this.deriveSentiment(input.rating);
+        const entry = {
+            id: `feedback_${++this.feedbackCounter}_${Date.now()}`,
+            taskId: input.taskId,
+            goalHash: input.goalHash,
+            taskType: input.taskType,
+            rating: input.rating,
+            category: input.category ?? 'quality',
+            sentiment,
+            comment: input.comment,
+            tags: input.tags,
+            wasTaskModified: input.wasTaskModified ?? false,
+            wasTaskRetried: input.wasTaskRetried ?? false,
+            createdAt: new Date(),
+            metadata: input.metadata,
+        };
+        this.feedback.set(entry.id, entry);
+        this.enforceMaxEntries();
+        this.emit('feedback:submitted', entry);
+        this.logger.debug('TASK_FEEDBACK', `Feedback submitted for task ${input.taskId}: ${input.rating}/5`);
+        this.detectPatterns();
+        this.checkQualityTrends();
+        return entry;
+    }
+    getFeedback(feedbackId) {
+        return this.feedback.get(feedbackId);
+    }
+    queryFeedback(options = {}) {
+        let results = Array.from(this.feedback.values());
+        if (options.goalHash) {
+            results = results.filter((f) => f.goalHash === options.goalHash);
+        }
+        if (options.taskType) {
+            results = results.filter((f) => f.taskType === options.taskType);
+        }
+        if (options.category) {
+            results = results.filter((f) => f.category === options.category);
+        }
+        if (options.sentiment) {
+            results = results.filter((f) => f.sentiment === options.sentiment);
+        }
+        if (options.minRating) {
+            results = results.filter((f) => f.rating >= options.minRating);
+        }
+        if (options.maxRating) {
+            results = results.filter((f) => f.rating <= options.maxRating);
+        }
+        if (options.startDate) {
+            results = results.filter((f) => f.createdAt >= options.startDate);
+        }
+        if (options.endDate) {
+            results = results.filter((f) => f.createdAt <= options.endDate);
+        }
+        results.sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime());
+        if (options.offset) {
+            results = results.slice(options.offset);
+        }
+        if (options.limit) {
+            results = results.slice(0, options.limit);
+        }
+        return results;
+    }
+    getTaskFeedback(taskId) {
+        return Array.from(this.feedback.values()).filter((f) => f.taskId === taskId);
+    }
+    getGoalFeedback(goalHash) {
+        return this.queryFeedback({ goalHash });
+    }
+    calculateStatistics(options = {}) {
+        const entries = this.queryFeedback(options);
+        if (entries.length === 0) {
+            return this.emptyStatistics();
+        }
+        const ratingDistribution = {
+            1: 0,
+            2: 0,
+            3: 0,
+            4: 0,
+            5: 0,
+        };
+        const categoryBreakdown = {
+            quality: 0,
+            accuracy: 0,
+            completeness: 0,
+            relevance: 0,
+            safety: 0,
+            performance: 0,
+            other: 0,
+        };
+        const sentimentBreakdown = {
+            positive: 0,
+            neutral: 0,
+            negative: 0,
+        };
+        const taskTypeData = new Map();
+        let totalRating = 0;
+        for (const entry of entries) {
+            totalRating += entry.rating;
+            ratingDistribution[entry.rating]++;
+            categoryBreakdown[entry.category]++;
+            sentimentBreakdown[entry.sentiment]++;
+            const taskType = entry.taskType;
+            const existing = taskTypeData.get(taskType) ?? { sum: 0, count: 0 };
+            taskTypeData.set(taskType, {
+                sum: existing.sum + entry.rating,
+                count: existing.count + 1,
+            });
+        }
+        const taskTypeBreakdown = {};
+        for (const [type, data] of taskTypeData) {
+            taskTypeBreakdown[type] = {
+                count: data.count,
+                avgRating: Math.round((data.sum / data.count) * 100) / 100,
+            };
+        }
+        return {
+            totalFeedback: entries.length,
+            averageRating: Math.round((totalRating / entries.length) * 100) / 100,
+            ratingDistribution,
+            categoryBreakdown,
+            sentimentBreakdown,
+            taskTypeBreakdown,
+            commonIssues: Array.from(this.patterns.values()),
+            trends: this.calculateTrends(entries),
+        };
+    }
+    getPatterns() {
+        return Array.from(this.patterns.values());
+    }
+    generateSuggestions() {
+        const stats = this.calculateStatistics();
+        const suggestions = [];
+        let suggestionCounter = 0;
+        if (stats.averageRating < 3 && stats.totalFeedback >= 5) {
+            suggestions.push({
+                id: `suggestion_${++suggestionCounter}`,
+                priority: 'high',
+                area: 'Overall Quality',
+                description: `Average rating is ${stats.averageRating}/5, below target threshold`,
+                basedOnFeedbackCount: stats.totalFeedback,
+                potentialImpact: 80,
+                actionItems: [
+                    'Review recent negative feedback',
+                    'Identify common failure patterns',
+                    'Adjust task generation prompts',
+                ],
+            });
+        }
+        for (const [category, count] of Object.entries(stats.categoryBreakdown)) {
+            if (count >= this.patternThreshold) {
+                const categoryFeedback = this.queryFeedback({
+                    category: category,
+                });
+                const avgRating = categoryFeedback.reduce((sum, f) => sum + f.rating, 0) /
+                    categoryFeedback.length;
+                if (avgRating < 3) {
+                    suggestions.push({
+                        id: `suggestion_${++suggestionCounter}`,
+                        priority: avgRating < 2 ? 'high' : 'medium',
+                        area: `${this.capitalizeFirst(category)} Issues`,
+                        description: `${category} feedback has low average rating (${avgRating.toFixed(1)}/5)`,
+                        basedOnFeedbackCount: count,
+                        potentialImpact: 60,
+                        actionItems: [
+                            `Review ${category} feedback comments`,
+                            `Identify specific ${category} issues`,
+                            `Implement targeted improvements`,
+                        ],
+                    });
+                }
+            }
+        }
+        for (const pattern of this.patterns.values()) {
+            if (pattern.averageRating < 3) {
+                suggestions.push({
+                    id: `suggestion_${++suggestionCounter}`,
+                    priority: 'medium',
+                    area: 'Recurring Pattern',
+                    description: pattern.description,
+                    basedOnFeedbackCount: pattern.frequency,
+                    potentialImpact: 50,
+                    actionItems: pattern.suggestedFix
+                        ? [pattern.suggestedFix]
+                        : ['Analyze pattern and develop fix'],
+                });
+            }
+        }
+        for (const [taskType, data] of Object.entries(stats.taskTypeBreakdown)) {
+            if (data.count >= 3 && data.avgRating < 3) {
+                suggestions.push({
+                    id: `suggestion_${++suggestionCounter}`,
+                    priority: data.avgRating < 2 ? 'high' : 'medium',
+                    area: `Task Type: ${taskType}`,
+                    description: `${taskType} tasks have low satisfaction (${data.avgRating}/5)`,
+                    basedOnFeedbackCount: data.count,
+                    potentialImpact: 40,
+                    actionItems: [
+                        `Review ${taskType} task generation`,
+                        'Analyze failure modes',
+                        'Improve task handling logic',
+                    ],
+                });
+            }
+        }
+        for (const suggestion of suggestions) {
+            this.emit('suggestion:generated', suggestion);
+        }
+        return suggestions.sort((a, b) => b.potentialImpact - a.potentialImpact);
+    }
+    getGoalAverageRating(goalHash) {
+        const feedback = this.getGoalFeedback(goalHash);
+        if (feedback.length === 0)
+            return null;
+        const sum = feedback.reduce((acc, f) => acc + f.rating, 0);
+        return Math.round((sum / feedback.length) * 100) / 100;
+    }
+    clearGoalFeedback(goalHash) {
+        let deleted = 0;
+        for (const [id, entry] of this.feedback) {
+            if (entry.goalHash === goalHash) {
+                this.feedback.delete(id);
+                deleted++;
+            }
+        }
+        return deleted;
+    }
+    exportFeedback(options = {}) {
+        const entries = this.queryFeedback(options);
+        return JSON.stringify({
+            exportedAt: new Date().toISOString(),
+            count: entries.length,
+            statistics: this.calculateStatistics(options),
+            entries,
+        }, null, 2);
+    }
+    deriveSentiment(rating) {
+        if (rating >= 4)
+            return 'positive';
+        if (rating <= 2)
+            return 'negative';
+        return 'neutral';
+    }
+    enforceMaxEntries() {
+        if (this.feedback.size <= this.maxEntries)
+            return;
+        const entries = Array.from(this.feedback.entries()).sort(([, a], [, b]) => a.createdAt.getTime() - b.createdAt.getTime());
+        const toRemove = entries.slice(0, entries.length - this.maxEntries);
+        for (const [id] of toRemove) {
+            this.feedback.delete(id);
+        }
+    }
+    detectPatterns() {
+        const negativeFeedback = Array.from(this.feedback.values()).filter((f) => f.rating <= 2);
+        const groups = new Map();
+        for (const entry of negativeFeedback) {
+            const key = `${entry.category}:${entry.taskType}`;
+            const existing = groups.get(key) ?? {
+                entries: [],
+                taskTypes: new Set(),
+            };
+            existing.entries.push(entry);
+            existing.taskTypes.add(entry.taskType);
+            groups.set(key, existing);
+        }
+        for (const [key, group] of groups) {
+            if (group.entries.length >= this.patternThreshold) {
+                const [category, taskType] = key.split(':');
+                const patternId = `pattern_${++this.patternCounter}`;
+                const avgRating = group.entries.reduce((sum, e) => sum + e.rating, 0) /
+                    group.entries.length;
+                const pattern = {
+                    id: patternId,
+                    description: `Low ratings for ${category} in ${taskType} tasks`,
+                    frequency: group.entries.length,
+                    affectedTaskTypes: Array.from(group.taskTypes),
+                    averageRating: Math.round(avgRating * 100) / 100,
+                    exampleFeedbackIds: group.entries.slice(0, 3).map((e) => e.id),
+                    suggestedFix: this.suggestFix(category, taskType),
+                };
+                const existingPattern = Array.from(this.patterns.values()).find((p) => p.description === pattern.description ||
+                    (p.affectedTaskTypes.includes(taskType) &&
+                        p.description.includes(category)));
+                if (!existingPattern) {
+                    this.patterns.set(patternId, pattern);
+                    this.emit('pattern:detected', pattern);
+                }
+            }
+        }
+    }
+    suggestFix(category, taskType) {
+        const fixes = {
+            quality: `Review ${taskType} task generation prompts and improve output quality`,
+            accuracy: `Verify ${taskType} task outputs and add validation`,
+            completeness: `Ensure ${taskType} tasks include all required elements`,
+            relevance: `Review context gathering for ${taskType} tasks`,
+            safety: `Add safety checks for ${taskType} task execution`,
+            performance: `Optimize ${taskType} task execution speed`,
+            other: `Analyze ${taskType} task feedback for improvement areas`,
+        };
+        return fixes[category];
+    }
+    calculateTrends(entries) {
+        if (entries.length < 2)
+            return [];
+        const trends = [];
+        const now = new Date();
+        for (let i = 0; i < 4; i++) {
+            const weekEnd = new Date(now);
+            weekEnd.setDate(weekEnd.getDate() - i * 7);
+            const weekStart = new Date(weekEnd);
+            weekStart.setDate(weekStart.getDate() - 7);
+            const weekEntries = entries.filter((e) => e.createdAt >= weekStart && e.createdAt < weekEnd);
+            if (weekEntries.length > 0) {
+                const avgRating = weekEntries.reduce((sum, e) => sum + e.rating, 0) / weekEntries.length;
+                trends.push({
+                    period: `Week ${i + 1}`,
+                    averageRating: Math.round(avgRating * 100) / 100,
+                    feedbackCount: weekEntries.length,
+                    change: 'stable',
+                });
+            }
+        }
+        for (let i = 0; i < trends.length - 1; i++) {
+            const current = trends[i].averageRating;
+            const previous = trends[i + 1].averageRating;
+            const diff = current - previous;
+            const trendWithChange = {
+                ...trends[i],
+                change: diff > 0.2 ? 'improving' : diff < -0.2 ? 'declining' : 'stable',
+            };
+            trends[i] = trendWithChange;
+        }
+        return trends;
+    }
+    checkQualityTrends() {
+        const recentStats = this.calculateStatistics({
+            startDate: new Date(Date.now() - this.trendWindowDays * 24 * 60 * 60 * 1000),
+        });
+        if (recentStats.totalFeedback < 5)
+            return;
+        const olderStats = this.calculateStatistics({
+            endDate: new Date(Date.now() - this.trendWindowDays * 24 * 60 * 60 * 1000),
+        });
+        if (olderStats.totalFeedback < 5)
+            return;
+        const diff = recentStats.averageRating - olderStats.averageRating;
+        if (diff < -0.5) {
+            this.emit('quality:declining', recentStats);
+        }
+        else if (diff > 0.5) {
+            this.emit('quality:improving', recentStats);
+        }
+    }
+    capitalizeFirst(str) {
+        return str.charAt(0).toUpperCase() + str.slice(1);
+    }
+    emptyStatistics() {
+        return {
+            totalFeedback: 0,
+            averageRating: 0,
+            ratingDistribution: { 1: 0, 2: 0, 3: 0, 4: 0, 5: 0 },
+            categoryBreakdown: {
+                quality: 0,
+                accuracy: 0,
+                completeness: 0,
+                relevance: 0,
+                safety: 0,
+                performance: 0,
+                other: 0,
+            },
+            sentimentBreakdown: { positive: 0, neutral: 0, negative: 0 },
+            taskTypeBreakdown: {},
+            commonIssues: [],
+            trends: [],
+        };
+    }
+}
+export function createTaskFeedback(options) {
+    return new TaskFeedback(options);
+}

package/dist/goals/TaskGenerator.d.ts

@@ -0,0 +1,75 @@
+import { EventEmitter } from 'node:events';
+import type { Goal, Milestone, Task, TaskType, MetaGoal, CreateTaskInput, Logger } from './types.js';
+import { GoalError } from './errors.js';
+export type TaskGeneratorLLMFunction = (prompt: string, options?: {
+    modelTier?: string;
+    maxTokens?: number;
+    temperature?: number;
+}) => Promise<string>;
+export interface TaskSuggestion {
+    readonly title: string;
+    readonly description: string;
+    readonly type: TaskType;
+    readonly priority: number;
+    readonly scheduledFor?: string;
+    readonly expiresAt?: string;
+    readonly milestoneId?: number;
+    readonly reasoning: string;
+    readonly estimatedCost?: number;
+    readonly dependsOnTasks?: string[];
+}
+export interface TaskGenerationResult {
+    readonly suggestions: TaskSuggestion[];
+    readonly planSummary: string;
+    readonly warnings: string[];
+    readonly estimatedEffort?: string;
+    readonly metadata: {
+        readonly generatedAt: string;
+        readonly modelTier: string;
+        readonly promptTokens?: number;
+        readonly responseTokens?: number;
+    };
+}
+export interface TaskGenerationOptions {
+    readonly maxTasks?: number;
+    readonly milestoneId?: number;
+    readonly taskTypes?: TaskType[];
+    readonly additionalContext?: string;
+    readonly metaGoals?: MetaGoal[];
+    readonly modelTier?: string;
+    readonly includeReasoning?: boolean;
+}
+export interface TaskGeneratorOptions {
+    readonly llmFunction: TaskGeneratorLLMFunction;
+    readonly defaultModelTier?: string;
+    readonly defaultMaxTasks?: number;
+    readonly logger?: Logger;
+}
+export interface TaskGeneratorEvents {
+    generationStarted: [goalHash: string, options: TaskGenerationOptions];
+    generationCompleted: [goalHash: string, result: TaskGenerationResult];
+    generationFailed: [goalHash: string, error: Error];
+    taskSuggested: [goalHash: string, suggestion: TaskSuggestion];
+}
+export declare class TaskGenerationError extends GoalError {
+    constructor(message: string, cause?: Error);
+}
+export declare class LLMParseError extends GoalError {
+    constructor(message: string, cause?: Error);
+}
+export declare class TaskGenerator extends EventEmitter<TaskGeneratorEvents> {
+    private readonly llmFunction;
+    private readonly defaultModelTier;
+    private readonly defaultMaxTasks;
+    private readonly logger;
+    constructor(options: TaskGeneratorOptions);
+    generateTasks(goal: Goal, milestones: Milestone[], existingTasks: Task[], options?: TaskGenerationOptions): Promise<TaskGenerationResult>;
+    generateDailyTasks(goal: Goal, milestones: Milestone[], existingTasks: Task[], options?: TaskGenerationOptions): Promise<TaskGenerationResult>;
+    suggestNextTask(goal: Goal, milestones: Milestone[], pendingTasks: Task[], options?: TaskGenerationOptions): Promise<TaskSuggestion | null>;
+    suggestionToInput(suggestion: TaskSuggestion, _goalHash: string): CreateTaskInput;
+    private buildGenerationPrompt;
+    private parseGenerationResponse;
+    private validateSuggestion;
+    private validateTaskType;
+}
+export declare function createTaskGenerator(options: TaskGeneratorOptions): TaskGenerator;