@flowdot.ai/daemon 1.0.0

package/dist/goals/GoalCommsHandler.js

@@ -0,0 +1,378 @@
+import { EventEmitter } from 'node:events';
+import { GoalError } from './errors.js';
+const noopLogger = {
+    debug: () => { },
+    info: () => { },
+    warn: () => { },
+    error: () => { },
+};
+const DEFAULT_APPROVAL_EXPIRY_MS = 5 * 60 * 1000;
+const DEFAULT_MAX_MESSAGE_LENGTH = 2000;
+const MODIFICATION_ACTIONS = new Set([
+    'create',
+    'update',
+    'delete',
+    'pause',
+    'resume',
+    'complete',
+    'abandon',
+    'edit',
+    'modify',
+    'change',
+    'set',
+    'add',
+    'remove',
+]);
+export class GoalCommsError extends GoalError {
+    constructor(message, cause) {
+        super('COMMS_ERROR', message, cause ? { cause } : {});
+    }
+}
+export class ApprovalTimeoutError extends GoalError {
+    requestId;
+    taskId;
+    constructor(requestId, taskId) {
+        super('APPROVAL_TIMEOUT', `Approval request ${requestId} timed out`);
+        this.requestId = requestId;
+        this.taskId = taskId;
+    }
+}
+export class GoalCommsHandler extends EventEmitter {
+    logger;
+    sendFunction;
+    approvalExpiryMs;
+    includeDetails;
+    maxMessageLength;
+    pendingApprovals = new Map();
+    constructor(options = {}) {
+        super();
+        this.logger = options.logger ?? noopLogger;
+        this.sendFunction = options.sendFunction;
+        this.approvalExpiryMs = options.approvalExpiryMs ?? DEFAULT_APPROVAL_EXPIRY_MS;
+        this.includeDetails = options.includeDetails ?? true;
+        this.maxMessageLength = options.maxMessageLength ?? DEFAULT_MAX_MESSAGE_LENGTH;
+    }
+    async sendNotification(subtype, goal, message, details) {
+        const notification = {
+            type: 'goal_notification',
+            subtype,
+            goalHash: goal.hash,
+            goalName: goal.name,
+            message: this.truncate(message, this.maxMessageLength),
+            details: this.includeDetails ? details : undefined,
+            timestamp: new Date(),
+        };
+        await this.send(notification);
+        this.emit('notification-sent', notification);
+        this.logger.debug('GOAL_COMMS', 'Notification sent', {
+            subtype,
+            goalHash: goal.hash,
+        });
+    }
+    async notifyTasksGenerated(goal, taskCount) {
+        await this.sendNotification('tasks_generated', goal, `${taskCount} new task${taskCount === 1 ? '' : 's'} generated for "${goal.name}"`, { taskCount });
+    }
+    async notifyMilestoneReached(goal, milestoneTitle, completedCount, totalCount) {
+        await this.sendNotification('milestone_reached', goal, `Milestone completed: "${milestoneTitle}" (${completedCount}/${totalCount})`, { milestoneTitle, completedCount, totalCount });
+    }
+    async notifyReviewDue(goal) {
+        await this.sendNotification('review_due', goal, `Review due for goal "${goal.name}"`);
+    }
+    async notifyGoalCompleted(goal) {
+        await this.sendNotification('goal_completed', goal, `Goal completed: "${goal.name}"`);
+    }
+    async notifyTaskCompleted(goal, task) {
+        await this.sendNotification('task_completed', goal, `Task completed: "${task.title}"`, { taskId: task.id, taskType: task.taskType });
+    }
+    async notifyTaskFailed(goal, task, error) {
+        await this.sendNotification('task_failed', goal, `Task failed: "${task.title}" - ${error}`, { taskId: task.id, taskType: task.taskType, error });
+    }
+    async notifyDailySummary(goals, completedTasks, pendingTasks) {
+        if (goals.length === 0)
+            return;
+        const message = [
+            `Daily Summary:`,
+            `Active goals: ${goals.filter((g) => g.status === 'active').length}`,
+            `Tasks completed today: ${completedTasks}`,
+            `Pending tasks: ${pendingTasks}`,
+        ].join('\n');
+        const notification = {
+            type: 'goal_notification',
+            subtype: 'daily_summary',
+            goalHash: 'system',
+            goalName: 'Daily Summary',
+            message: this.truncate(message, this.maxMessageLength),
+            details: this.includeDetails
+                ? { activeGoals: goals.length, completedTasks, pendingTasks }
+                : undefined,
+            timestamp: new Date(),
+        };
+        await this.send(notification);
+        this.emit('notification-sent', notification);
+    }
+    async requestApproval(goal, task, permissionRequired) {
+        const requestId = this.generateRequestId();
+        const expiresAt = new Date(Date.now() + this.approvalExpiryMs);
+        const request = {
+            type: 'goal_task_approval',
+            requestId,
+            goalHash: goal.hash,
+            goalName: goal.name,
+            taskId: task.id,
+            taskTitle: task.title,
+            taskDescription: task.description,
+            taskType: task.taskType,
+            permissionRequired,
+            options: ['approve', 'deny', 'skip', 'later'],
+            expiresAt,
+            timestamp: new Date(),
+        };
+        await this.send(request);
+        this.emit('approval-sent', request);
+        this.logger.debug('GOAL_COMMS', 'Approval request sent', {
+            requestId,
+            taskId: task.id,
+        });
+        return new Promise((resolve) => {
+            const timeoutId = setTimeout(() => {
+                this.pendingApprovals.delete(requestId);
+                resolve('timeout');
+            }, this.approvalExpiryMs);
+            this.pendingApprovals.set(requestId, {
+                request,
+                resolver: resolve,
+                timeoutId,
+            });
+        });
+    }
+    handleApprovalResponse(requestId, response, userId) {
+        const pending = this.pendingApprovals.get(requestId);
+        if (!pending) {
+            this.logger.warn('GOAL_COMMS', 'Unknown approval request', { requestId });
+            return;
+        }
+        clearTimeout(pending.timeoutId);
+        this.pendingApprovals.delete(requestId);
+        this.emit('approval-received', { requestId, response, userId });
+        pending.resolver(response);
+        this.logger.debug('GOAL_COMMS', 'Approval response received', {
+            requestId,
+            response,
+            userId,
+        });
+    }
+    cancelApprovalRequest(requestId) {
+        const pending = this.pendingApprovals.get(requestId);
+        if (!pending) {
+            return false;
+        }
+        clearTimeout(pending.timeoutId);
+        this.pendingApprovals.delete(requestId);
+        pending.resolver('timeout');
+        return true;
+    }
+    getPendingApprovals() {
+        return Array.from(this.pendingApprovals.values()).map((p) => p.request);
+    }
+    async handleViewRequest(request, dataProvider) {
+        this.emit('view-request', request);
+        try {
+            let data = null;
+            let message = '';
+            switch (request.action) {
+                case 'list': {
+                    const goals = await dataProvider.listGoals(request.filters);
+                    data = goals;
+                    message = `Found ${goals.length} goal${goals.length === 1 ? '' : 's'}`;
+                    break;
+                }
+                case 'show': {
+                    if (!request.goalHash) {
+                        return this.createViewResponse(request, null, false, 'Goal ID required');
+                    }
+                    const goal = await dataProvider.getGoal(request.goalHash);
+                    if (!goal) {
+                        return this.createViewResponse(request, null, false, 'Goal not found');
+                    }
+                    data = goal;
+                    message = `Goal: ${goal.name}`;
+                    break;
+                }
+                case 'tasks': {
+                    if (!request.goalHash) {
+                        return this.createViewResponse(request, null, false, 'Goal ID required');
+                    }
+                    const tasks = await dataProvider.listTasks(request.goalHash, request.filters?.taskStatus ? { status: request.filters.taskStatus } : undefined);
+                    data = tasks;
+                    message = `Found ${tasks.length} task${tasks.length === 1 ? '' : 's'}`;
+                    break;
+                }
+                case 'progress':
+                case 'summary': {
+                    if (!request.goalHash) {
+                        return this.createViewResponse(request, null, false, 'Goal ID required');
+                    }
+                    const progress = await dataProvider.getProgress(request.goalHash);
+                    if (!progress) {
+                        return this.createViewResponse(request, null, false, 'Goal not found');
+                    }
+                    data = progress;
+                    message = `Progress: ${progress.progress}% (${progress.tasks.completed}/${progress.tasks.total} tasks)`;
+                    break;
+                }
+                default:
+                    return this.createViewResponse(request, null, false, `Unknown action: ${request.action}`);
+            }
+            const response = this.createViewResponse(request, data, true, message);
+            this.emit('view-response-sent', response);
+            return response;
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            this.logger.error('GOAL_COMMS', 'View request failed', { error: message });
+            return this.createViewResponse(request, null, false, message);
+        }
+    }
+    createViewResponse(request, data, success, message, error) {
+        return {
+            type: 'goal_view_response',
+            requestId: request.requestId,
+            action: request.action,
+            data,
+            message: message ?? '',
+            success,
+            error,
+            timestamp: new Date(),
+        };
+    }
+    isModificationAction(action) {
+        const normalizedAction = action.toLowerCase().trim();
+        return MODIFICATION_ACTIONS.has(normalizedAction) ||
+            Array.from(MODIFICATION_ACTIONS).some((mod) => normalizedAction.includes(mod));
+    }
+    createModificationRedirect(requestedAction, goalHash) {
+        const cliCommand = this.getCliCommand(requestedAction, goalHash);
+        const redirect = {
+            type: 'goal_modification_redirect',
+            requestedAction,
+            cliCommand,
+            message: `Goal modifications require CLI or Native app.\nRun: ${cliCommand}`,
+            timestamp: new Date(),
+        };
+        this.emit('modification-redirected', redirect);
+        return redirect;
+    }
+    getCliCommand(action, goalHash) {
+        const normalizedAction = action.toLowerCase().trim();
+        const hashArg = goalHash ? ` ${goalHash}` : '';
+        if (normalizedAction.includes('create') || normalizedAction.includes('add')) {
+            return 'flowdot goals create "description"';
+        }
+        if (normalizedAction.includes('update') || normalizedAction.includes('edit') ||
+            normalizedAction.includes('modify') || normalizedAction.includes('change')) {
+            return `flowdot goals update${hashArg} "changes"`;
+        }
+        if (normalizedAction.includes('delete') || normalizedAction.includes('remove')) {
+            return `flowdot goals delete${hashArg}`;
+        }
+        if (normalizedAction.includes('pause')) {
+            return `flowdot goals pause${hashArg}`;
+        }
+        if (normalizedAction.includes('resume')) {
+            return `flowdot goals resume${hashArg}`;
+        }
+        if (normalizedAction.includes('complete')) {
+            return `flowdot goals complete${hashArg}`;
+        }
+        return `flowdot goals --help`;
+    }
+    formatGoalSummary(goal) {
+        const parts = [
+            `Goal: ${goal.name}`,
+            `Status: ${goal.status}`,
+            `Priority: ${goal.priority}`,
+        ];
+        if (goal.progress !== undefined) {
+            parts.push(`Progress: ${goal.progress}%`);
+        }
+        if (goal.deadline) {
+            const daysUntil = Math.ceil((goal.deadline.getTime() - Date.now()) / (1000 * 60 * 60 * 24));
+            parts.push(`Deadline: ${daysUntil > 0 ? `${daysUntil} days` : 'Overdue'}`);
+        }
+        return parts.join('\n');
+    }
+    formatTaskSummary(task) {
+        return [
+            `Task: ${task.title}`,
+            `Type: ${task.taskType}`,
+            `Status: ${task.status}`,
+            task.description ? `Description: ${this.truncate(task.description, 100)}` : '',
+        ]
+            .filter(Boolean)
+            .join('\n');
+    }
+    formatProgressSummary(progress) {
+        const parts = [
+            `Goal: ${progress.goalName}`,
+            `Progress: ${progress.progress}%`,
+            `Status: ${progress.status}`,
+            `Milestones: ${progress.milestones.completed}/${progress.milestones.total}`,
+            `Tasks: ${progress.tasks.completed}/${progress.tasks.total}`,
+        ];
+        if (progress.tasks.pending > 0) {
+            parts.push(`Pending: ${progress.tasks.pending}`);
+        }
+        if (progress.tasks.failed > 0) {
+            parts.push(`Failed: ${progress.tasks.failed}`);
+        }
+        if (progress.daysUntilDeadline !== undefined) {
+            if (progress.daysUntilDeadline > 0) {
+                parts.push(`Deadline: ${progress.daysUntilDeadline} days`);
+            }
+            else if (progress.daysUntilDeadline === 0) {
+                parts.push(`Deadline: Today`);
+            }
+            else {
+                parts.push(`Deadline: Overdue by ${Math.abs(progress.daysUntilDeadline)} days`);
+            }
+        }
+        return parts.join('\n');
+    }
+    async send(payload) {
+        if (!this.sendFunction) {
+            this.logger.warn('GOAL_COMMS', 'No send function configured, message not sent');
+            return;
+        }
+        try {
+            await this.sendFunction(payload);
+        }
+        catch (error) {
+            const err = error instanceof Error ? error : new Error(String(error));
+            this.logger.error('GOAL_COMMS', 'Failed to send message', {
+                type: payload.type,
+                error: err.message,
+            });
+            this.emit('error', new GoalCommsError('Failed to send message', err));
+        }
+    }
+    generateRequestId() {
+        return `goal_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+    }
+    truncate(text, maxLength) {
+        if (text.length <= maxLength) {
+            return text;
+        }
+        return text.substring(0, maxLength - 3) + '...';
+    }
+    dispose() {
+        for (const [, pending] of this.pendingApprovals) {
+            clearTimeout(pending.timeoutId);
+            pending.resolver('timeout');
+        }
+        this.pendingApprovals.clear();
+        this.removeAllListeners();
+    }
+}
+export function createGoalCommsHandler(options = {}) {
+    return new GoalCommsHandler(options);
+}

package/dist/goals/GoalExporter.d.ts

@@ -0,0 +1,164 @@
+import { EventEmitter } from 'events';
+import type { Goal, GoalHash, Milestone, Task, GoalMemory, MetaGoal, Logger } from './types.js';
+import type { GoalProgress, ProgressSnapshot } from './ProgressTracker.js';
+import type { TaskFeedbackEntry } from './TaskFeedback.js';
+export declare const EXPORT_FORMAT_VERSION = "1.0.0";
+export type ExportType = 'full' | 'template' | 'backup' | 'archive';
+export type ExportScope = 'single' | 'multiple' | 'all';
+export interface ExportOptions {
+    readonly type?: ExportType;
+    readonly includeProgress?: boolean;
+    readonly includeSnapshots?: boolean;
+    readonly includeFeedback?: boolean;
+    readonly includeMetaGoals?: boolean;
+    readonly stripUserData?: boolean;
+    readonly compress?: boolean;
+    readonly prettyPrint?: boolean;
+}
+export interface ExportedGoal {
+    readonly hash: GoalHash;
+    readonly title: string;
+    readonly description?: string;
+    readonly status: string;
+    readonly priority: string;
+    readonly deadline?: string;
+    readonly approvalMode: string;
+    readonly parentHash?: GoalHash;
+    readonly dependencyHashes?: GoalHash[];
+    readonly tags?: string[];
+    readonly createdAt: string;
+    readonly updatedAt: string;
+    readonly milestones: ExportedMilestone[];
+    readonly tasks: ExportedTask[];
+    readonly memories: ExportedMemory[];
+    readonly progress?: GoalProgress;
+    readonly snapshots?: ProgressSnapshot[];
+    readonly feedback?: TaskFeedbackEntry[];
+}
+export interface ExportedMilestone {
+    readonly id: number;
+    readonly title: string;
+    readonly description?: string;
+    readonly status: string;
+    readonly order: number;
+    readonly deadline?: string;
+    readonly createdAt: string;
+    readonly updatedAt: string;
+}
+export interface ExportedTask {
+    readonly id: number;
+    readonly milestoneId?: number;
+    readonly title: string;
+    readonly description?: string;
+    readonly type: string;
+    readonly status: string;
+    readonly priority: number;
+    readonly params?: Record<string, unknown>;
+    readonly requiresApproval: boolean;
+    readonly deadline?: string;
+    readonly completedAt?: string;
+    readonly createdAt: string;
+    readonly updatedAt: string;
+}
+export interface ExportedMemory {
+    readonly id: number;
+    readonly category: string;
+    readonly content: string;
+    readonly source?: string;
+    readonly confidence?: number;
+    readonly expiresAt?: string;
+    readonly createdAt: string;
+}
+export interface ExportedMetaGoal {
+    readonly id: number;
+    readonly name: string;
+    readonly description?: string;
+    readonly scope: string;
+    readonly appliesTo?: string[];
+    readonly constraints: {
+        type: string;
+        value: string;
+    }[];
+    readonly priority: number;
+    readonly isActive: boolean;
+    readonly createdAt: string;
+    readonly updatedAt: string;
+}
+export interface ExportManifest {
+    readonly version: string;
+    readonly exportType: ExportType;
+    readonly exportedAt: string;
+    readonly exportedBy?: string;
+    readonly goalCount: number;
+    readonly metaGoalCount: number;
+    readonly totalMilestones: number;
+    readonly totalTasks: number;
+    readonly totalMemories: number;
+    readonly checksum?: string;
+    readonly options: ExportOptions;
+}
+export interface ExportPackage {
+    readonly manifest: ExportManifest;
+    readonly goals: ExportedGoal[];
+    readonly metaGoals?: ExportedMetaGoal[];
+}
+export interface ExportResult {
+    readonly success: boolean;
+    readonly package?: ExportPackage;
+    readonly serialized?: string;
+    readonly errors: string[];
+    readonly warnings: string[];
+    readonly statistics: {
+        goalsExported: number;
+        milestonesExported: number;
+        tasksExported: number;
+        memoriesExported: number;
+        metaGoalsExported: number;
+        exportSize: number;
+    };
+}
+export interface ExportDataProvider {
+    getGoals(hashes?: GoalHash[]): Promise<Goal[]>;
+    getMilestones(goalHash: GoalHash): Promise<Milestone[]>;
+    getTasks(goalHash: GoalHash): Promise<Task[]>;
+    getMemories(goalHash: GoalHash): Promise<GoalMemory[]>;
+    getMetaGoals?(): Promise<MetaGoal[]>;
+    getProgress?(goalHash: GoalHash): GoalProgress | undefined;
+    getSnapshots?(goalHash: GoalHash): ProgressSnapshot[];
+    getFeedback?(goalHash: GoalHash): TaskFeedbackEntry[];
+}
+export interface GoalExporterOptions {
+    readonly logger?: Logger;
+    readonly defaultOptions?: ExportOptions;
+}
+export interface GoalExporterEvents {
+    'export:started': [goalCount: number];
+    'export:progress': [current: number, total: number];
+    'export:completed': [result: ExportResult];
+    'export:error': [error: Error];
+    warning: [message: string];
+}
+export declare class GoalExporter extends EventEmitter<GoalExporterEvents> {
+    private readonly logger;
+    private readonly defaultOptions;
+    constructor(options?: GoalExporterOptions);
+    exportGoal(goalHash: GoalHash, dataProvider: ExportDataProvider, options?: ExportOptions): Promise<ExportResult>;
+    exportGoals(goalHashes: GoalHash[], dataProvider: ExportDataProvider, options?: ExportOptions): Promise<ExportResult>;
+    exportAll(dataProvider: ExportDataProvider, options?: ExportOptions): Promise<ExportResult>;
+    createTemplate(goalHash: GoalHash, dataProvider: ExportDataProvider, _templateName?: string): Promise<ExportResult>;
+    validateExport(data: string | ExportPackage): {
+        valid: boolean;
+        errors: string[];
+        warnings: string[];
+    };
+    private exportSingleGoal;
+    private exportMilestone;
+    private exportTask;
+    private exportMemory;
+    private exportMetaGoal;
+    private anonymizeHash;
+    private serialize;
+    private computeChecksum;
+    private emptyStatistics;
+}
+export declare function createGoalExporter(options?: GoalExporterOptions): GoalExporter;