@flowdot.ai/daemon 1.0.0

package/dist/goals/TaskExecutor.js

@@ -0,0 +1,370 @@
+import { EventEmitter } from 'node:events';
+import { GoalError } from './errors.js';
+const noopLogger = {
+    debug: () => { },
+    info: () => { },
+    warn: () => { },
+    error: () => { },
+};
+const DEFAULT_MAX_EXECUTION_TIME_MS = 5 * 60 * 1000;
+const TASK_TYPE_PERMISSIONS = {
+    research: 'web-search',
+    draft: 'file-write',
+    code: 'file-write',
+    execute: 'command-execute',
+    recipe: 'recipe-invoke',
+    loop: 'loop-create',
+    notify: 'domain-access',
+};
+const AUTO_APPROVE_CATEGORIES = new Set([
+    'file-read',
+    'web-search',
+]);
+const ALWAYS_REQUIRE_APPROVAL = new Set([
+    'command-execute',
+    'file-create',
+]);
+export class TaskExecutionError extends GoalError {
+    taskId;
+    goalHash;
+    constructor(message, taskId, goalHash, cause) {
+        super('TASK_EXECUTION_ERROR', message, cause ? { cause, taskId, goalHash } : { taskId, goalHash });
+        this.taskId = taskId;
+        this.goalHash = goalHash;
+    }
+}
+export class PermissionDeniedError extends GoalError {
+    category;
+    reason;
+    constructor(category, reason) {
+        super('PERMISSION_DENIED', `Permission denied: ${reason}`);
+        this.category = category;
+        this.reason = reason;
+    }
+}
+export class ExecutionTimeoutError extends GoalError {
+    taskId;
+    timeoutMs;
+    constructor(taskId, timeoutMs) {
+        super('TASK_EXECUTION_TIMEOUT', `Task ${taskId} execution timed out after ${timeoutMs}ms`);
+        this.taskId = taskId;
+        this.timeoutMs = timeoutMs;
+    }
+}
+export class TaskExecutor extends EventEmitter {
+    logger;
+    checkPermission;
+    requestApproval;
+    updateTaskStatus;
+    handlers;
+    maxExecutionTimeMs;
+    logExecutions;
+    executingTasks = new Map();
+    constructor(options = {}) {
+        super();
+        this.logger = options.logger ?? noopLogger;
+        this.checkPermission = options.checkPermission;
+        this.requestApproval = options.requestApproval;
+        this.updateTaskStatus = options.updateTaskStatus;
+        this.handlers = options.handlers ?? {};
+        this.maxExecutionTimeMs = options.maxExecutionTimeMs ?? DEFAULT_MAX_EXECUTION_TIME_MS;
+        this.logExecutions = options.logExecutions ?? true;
+    }
+    async execute(goal, task) {
+        const startTime = new Date();
+        const permissionCategory = this.getPermissionCategory(task.taskType);
+        const context = {
+            goal,
+            task,
+            permissionCategory,
+            approvalMode: goal.approvalMode,
+            startTime,
+        };
+        this.executingTasks.set(task.id, context);
+        this.emit('execution-started', context);
+        try {
+            await this.updateStatus(task.id, 'in_progress');
+            const permissionResult = await this.checkTaskPermission(context);
+            this.emit('permission-checked', permissionResult, context);
+            if (!permissionResult.allowed && !permissionResult.requiresApproval) {
+                return this.createResult(context, {
+                    success: false,
+                    status: 'failed',
+                    error: permissionResult.reason ?? 'Permission denied',
+                    permissionDenied: true,
+                });
+            }
+            if (permissionResult.requiresApproval) {
+                const approvalResult = await this.requestTaskApproval(context);
+                if (!approvalResult.approved) {
+                    const status = this.getStatusFromApprovalResponse(approvalResult.response);
+                    return this.createResult(context, {
+                        success: false,
+                        status,
+                        approvalSkipped: approvalResult.response !== 'deny',
+                    });
+                }
+            }
+            const result = await this.executeTask(context);
+            return this.createResult(context, result);
+        }
+        catch (error) {
+            const err = error instanceof Error ? error : new Error(String(error));
+            this.logger.error('TASK_EXECUTOR', 'Execution failed', {
+                taskId: task.id,
+                error: err.message,
+            });
+            this.emit('error', err);
+            return this.createResult(context, {
+                success: false,
+                status: 'failed',
+                error: err.message,
+            });
+        }
+        finally {
+            this.executingTasks.delete(task.id);
+        }
+    }
+    async executeSequence(goal, tasks) {
+        const results = [];
+        for (const task of tasks) {
+            const result = await this.execute(goal, task);
+            results.push(result);
+            if (!result.success && !result.approvalSkipped) {
+                this.logger.info('TASK_EXECUTOR', 'Stopping sequence due to failure', {
+                    taskId: task.id,
+                    error: result.error,
+                });
+                break;
+            }
+        }
+        return results;
+    }
+    async canExecute(goal, task) {
+        const permissionCategory = this.getPermissionCategory(task.taskType);
+        const context = {
+            goal,
+            task,
+            permissionCategory,
+            approvalMode: goal.approvalMode,
+            startTime: new Date(),
+        };
+        const result = await this.checkTaskPermission(context);
+        return {
+            canExecute: result.allowed || result.requiresApproval,
+            requiresApproval: result.requiresApproval,
+            reason: result.reason,
+        };
+    }
+    async checkTaskPermission(context) {
+        const { approvalMode, permissionCategory } = context;
+        if (this.checkPermission) {
+            return this.checkPermission(permissionCategory, context);
+        }
+        return this.defaultPermissionCheck(approvalMode, permissionCategory);
+    }
+    defaultPermissionCheck(approvalMode, category) {
+        switch (approvalMode) {
+            case 'full':
+                return {
+                    allowed: false,
+                    requiresApproval: true,
+                    approvalMode,
+                    category,
+                };
+            case 'category':
+                if (ALWAYS_REQUIRE_APPROVAL.has(category)) {
+                    return {
+                        allowed: false,
+                        requiresApproval: true,
+                        approvalMode,
+                        category,
+                    };
+                }
+                if (AUTO_APPROVE_CATEGORIES.has(category)) {
+                    return {
+                        allowed: true,
+                        requiresApproval: false,
+                        approvalMode,
+                        category,
+                    };
+                }
+                return {
+                    allowed: false,
+                    requiresApproval: true,
+                    approvalMode,
+                    category,
+                };
+            case 'trusted':
+                if (ALWAYS_REQUIRE_APPROVAL.has(category)) {
+                    return {
+                        allowed: false,
+                        requiresApproval: true,
+                        approvalMode,
+                        category,
+                    };
+                }
+                return {
+                    allowed: true,
+                    requiresApproval: false,
+                    approvalMode,
+                    category,
+                };
+            default:
+                return {
+                    allowed: false,
+                    requiresApproval: true,
+                    approvalMode,
+                    category,
+                };
+        }
+    }
+    async requestTaskApproval(context) {
+        this.emit('approval-requested', context);
+        await this.updateStatus(context.task.id, 'awaiting_approval');
+        if (!this.requestApproval) {
+            this.logger.warn('TASK_EXECUTOR', 'No approval handler configured', {
+                taskId: context.task.id,
+            });
+            return {
+                approved: false,
+                response: 'deny',
+            };
+        }
+        const result = await this.requestApproval(context);
+        this.emit('approval-received', result, context);
+        return result;
+    }
+    async executeTask(context) {
+        const { task } = context;
+        const handler = this.handlers[task.taskType];
+        if (!handler) {
+            this.logger.warn('TASK_EXECUTOR', 'No handler for task type', {
+                taskId: task.id,
+                type: task.taskType,
+            });
+            return {
+                success: false,
+                status: 'failed',
+                error: `No handler registered for task type: ${task.taskType}`,
+            };
+        }
+        const timeoutPromise = new Promise((_, reject) => {
+            setTimeout(() => {
+                reject(new ExecutionTimeoutError(task.id, this.maxExecutionTimeMs));
+            }, this.maxExecutionTimeMs);
+        });
+        try {
+            const result = await Promise.race([
+                handler(context),
+                timeoutPromise,
+            ]);
+            if (result.success) {
+                await this.updateStatus(task.id, 'completed', {
+                    data: result.data,
+                    cost: result.cost,
+                });
+                return {
+                    success: true,
+                    status: 'completed',
+                    data: result.data,
+                    cost: result.cost,
+                };
+            }
+            else {
+                await this.updateStatus(task.id, 'failed', {
+                    error: result.error,
+                });
+                return {
+                    success: false,
+                    status: 'failed',
+                    error: result.error,
+                    cost: result.cost,
+                };
+            }
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            await this.updateStatus(task.id, 'failed', { error: message });
+            throw error;
+        }
+    }
+    registerHandler(taskType, handler) {
+        this.handlers[taskType] = handler;
+        this.logger.debug('TASK_EXECUTOR', 'Handler registered', { taskType });
+    }
+    unregisterHandler(taskType) {
+        delete this.handlers[taskType];
+    }
+    hasHandler(taskType) {
+        return taskType in this.handlers;
+    }
+    getPermissionCategory(taskType) {
+        return TASK_TYPE_PERMISSIONS[taskType] ?? 'domain-access';
+    }
+    getStatusFromApprovalResponse(response) {
+        switch (response) {
+            case 'deny':
+                return 'failed';
+            case 'skip':
+                return 'skipped';
+            case 'later':
+            case 'timeout':
+                return 'pending';
+            default:
+                return 'failed';
+        }
+    }
+    async updateStatus(taskId, status, result) {
+        if (this.updateTaskStatus) {
+            await this.updateTaskStatus(taskId, status, result);
+        }
+    }
+    createResult(context, result) {
+        const executionResult = {
+            success: result.success,
+            taskId: context.task.id,
+            goalHash: context.goal.hash,
+            status: result.status,
+            data: result.data,
+            error: result.error,
+            cost: result.cost,
+            permissionDenied: result.permissionDenied,
+            approvalSkipped: result.approvalSkipped,
+            durationMs: Date.now() - context.startTime.getTime(),
+            executedAt: new Date(),
+        };
+        if (result.success) {
+            this.emit('execution-completed', executionResult);
+        }
+        else {
+            this.emit('execution-failed', executionResult);
+        }
+        if (this.logExecutions) {
+            this.logger.info('TASK_EXECUTOR', result.success ? 'Task completed' : 'Task failed', {
+                taskId: context.task.id,
+                goalHash: context.goal.hash,
+                status: result.status,
+                durationMs: executionResult.durationMs,
+            });
+        }
+        return executionResult;
+    }
+    getExecutingTasks() {
+        return Array.from(this.executingTasks.values());
+    }
+    isExecuting(taskId) {
+        return this.executingTasks.has(taskId);
+    }
+    cancelTask(taskId) {
+        const context = this.executingTasks.get(taskId);
+        if (!context) {
+            return false;
+        }
+        this.executingTasks.delete(taskId);
+        return true;
+    }
+}
+export function createTaskExecutor(options = {}) {
+    return new TaskExecutor(options);
+}

package/dist/goals/TaskFeedback.d.ts

@@ -0,0 +1,126 @@
+import { EventEmitter } from 'events';
+import type { GoalHash, TaskId, TaskType, Logger } from './types.js';
+export type FeedbackRating = 1 | 2 | 3 | 4 | 5;
+export type FeedbackCategory = 'quality' | 'accuracy' | 'completeness' | 'relevance' | 'safety' | 'performance' | 'other';
+export type FeedbackSentiment = 'positive' | 'neutral' | 'negative';
+export interface TaskFeedbackEntry {
+    readonly id: string;
+    readonly taskId: TaskId;
+    readonly goalHash: GoalHash;
+    readonly taskType: TaskType;
+    readonly rating: FeedbackRating;
+    readonly category: FeedbackCategory;
+    readonly sentiment: FeedbackSentiment;
+    readonly comment?: string;
+    readonly tags?: string[];
+    readonly wasTaskModified: boolean;
+    readonly wasTaskRetried: boolean;
+    readonly createdAt: Date;
+    readonly metadata?: Record<string, unknown>;
+}
+export interface FeedbackStatistics {
+    readonly totalFeedback: number;
+    readonly averageRating: number;
+    readonly ratingDistribution: Record<FeedbackRating, number>;
+    readonly categoryBreakdown: Record<FeedbackCategory, number>;
+    readonly sentimentBreakdown: Record<FeedbackSentiment, number>;
+    readonly taskTypeBreakdown: Record<string, {
+        count: number;
+        avgRating: number;
+    }>;
+    readonly commonIssues: IssuePattern[];
+    readonly trends: FeedbackTrend[];
+}
+export interface IssuePattern {
+    readonly id: string;
+    readonly description: string;
+    readonly frequency: number;
+    readonly affectedTaskTypes: TaskType[];
+    readonly averageRating: number;
+    readonly exampleFeedbackIds: string[];
+    readonly suggestedFix?: string;
+}
+export interface FeedbackTrend {
+    readonly period: string;
+    readonly averageRating: number;
+    readonly feedbackCount: number;
+    readonly change: 'improving' | 'stable' | 'declining';
+}
+export interface FeedbackQueryOptions {
+    readonly goalHash?: GoalHash;
+    readonly taskType?: TaskType;
+    readonly category?: FeedbackCategory;
+    readonly minRating?: FeedbackRating;
+    readonly maxRating?: FeedbackRating;
+    readonly sentiment?: FeedbackSentiment;
+    readonly startDate?: Date;
+    readonly endDate?: Date;
+    readonly limit?: number;
+    readonly offset?: number;
+}
+export interface FeedbackInput {
+    readonly taskId: TaskId;
+    readonly goalHash: GoalHash;
+    readonly taskType: TaskType;
+    readonly rating: FeedbackRating;
+    readonly category?: FeedbackCategory;
+    readonly comment?: string;
+    readonly tags?: string[];
+    readonly wasTaskModified?: boolean;
+    readonly wasTaskRetried?: boolean;
+    readonly metadata?: Record<string, unknown>;
+}
+export interface ImprovementSuggestion {
+    readonly id: string;
+    readonly priority: 'high' | 'medium' | 'low';
+    readonly area: string;
+    readonly description: string;
+    readonly basedOnFeedbackCount: number;
+    readonly potentialImpact: number;
+    readonly actionItems: string[];
+}
+export interface TaskFeedbackOptions {
+    readonly logger?: Logger;
+    readonly maxFeedbackEntries?: number;
+    readonly patternDetectionThreshold?: number;
+    readonly trendWindowDays?: number;
+}
+export interface TaskFeedbackEvents {
+    'feedback:submitted': [feedback: TaskFeedbackEntry];
+    'pattern:detected': [pattern: IssuePattern];
+    'quality:declining': [stats: FeedbackStatistics];
+    'quality:improving': [stats: FeedbackStatistics];
+    'suggestion:generated': [suggestion: ImprovementSuggestion];
+    error: [error: Error];
+}
+export declare class TaskFeedback extends EventEmitter<TaskFeedbackEvents> {
+    private readonly logger;
+    private readonly maxEntries;
+    private readonly patternThreshold;
+    private readonly trendWindowDays;
+    private readonly feedback;
+    private readonly patterns;
+    private feedbackCounter;
+    private patternCounter;
+    constructor(options?: TaskFeedbackOptions);
+    submitFeedback(input: FeedbackInput): TaskFeedbackEntry;
+    getFeedback(feedbackId: string): TaskFeedbackEntry | undefined;
+    queryFeedback(options?: FeedbackQueryOptions): TaskFeedbackEntry[];
+    getTaskFeedback(taskId: TaskId): TaskFeedbackEntry[];
+    getGoalFeedback(goalHash: GoalHash): TaskFeedbackEntry[];
+    calculateStatistics(options?: FeedbackQueryOptions): FeedbackStatistics;
+    getPatterns(): IssuePattern[];
+    generateSuggestions(): ImprovementSuggestion[];
+    getGoalAverageRating(goalHash: GoalHash): number | null;
+    clearGoalFeedback(goalHash: GoalHash): number;
+    exportFeedback(options?: FeedbackQueryOptions): string;
+    private deriveSentiment;
+    private enforceMaxEntries;
+    private detectPatterns;
+    private suggestFix;
+    private calculateTrends;
+    private checkQualityTrends;
+    private capitalizeFirst;
+    private emptyStatistics;
+}
+export declare function createTaskFeedback(options?: TaskFeedbackOptions): TaskFeedback;