@flowdot.ai/daemon 1.0.0

package/dist/goals/GoalImporter.js

@@ -0,0 +1,345 @@
+import { EventEmitter } from 'events';
+import { EXPORT_FORMAT_VERSION, } from './GoalExporter.js';
+export class GoalImporter extends EventEmitter {
+    logger;
+    defaultOptions;
+    constructor(options = {}) {
+        super();
+        this.logger = options.logger ?? console;
+        this.defaultOptions = options.defaultOptions ?? {
+            mode: 'create',
+            conflictResolution: 'rename',
+            dryRun: false,
+            validateOnly: false,
+            importMilestones: true,
+            importTasks: true,
+            importMemories: true,
+            importMetaGoals: true,
+            resetStatus: false,
+        };
+    }
+    parse(data) {
+        let jsonData = data;
+        try {
+            if (/^[A-Za-z0-9+/=]+$/.test(data.trim())) {
+                jsonData = Buffer.from(data, 'base64').toString('utf-8');
+            }
+        }
+        catch {
+        }
+        return JSON.parse(jsonData);
+    }
+    async validate(data, dataWriter, options) {
+        const opts = { ...this.defaultOptions, ...options };
+        const errors = [];
+        const warnings = [];
+        const conflicts = [];
+        let pkg;
+        try {
+            pkg = typeof data === 'string' ? this.parse(data) : data;
+        }
+        catch (error) {
+            return {
+                valid: false,
+                errors: [`Invalid JSON: ${error instanceof Error ? error.message : String(error)}`],
+                warnings: [],
+                conflicts: [],
+                statistics: this.emptyValidationStatistics(),
+            };
+        }
+        if (!pkg.manifest) {
+            errors.push('Missing manifest');
+        }
+        else {
+            const [major] = pkg.manifest.version.split('.').map(Number);
+            const [currentMajor] = EXPORT_FORMAT_VERSION.split('.').map(Number);
+            if (major > currentMajor) {
+                errors.push(`Export version ${pkg.manifest.version} is newer than supported ${EXPORT_FORMAT_VERSION}`);
+            }
+            else if (major < currentMajor) {
+                warnings.push(`Export version ${pkg.manifest.version} is older, some features may not import`);
+            }
+        }
+        if (!Array.isArray(pkg.goals)) {
+            errors.push('Goals must be an array');
+        }
+        else {
+            for (const goal of pkg.goals) {
+                const goalErrors = this.validateGoal(goal);
+                errors.push(...goalErrors);
+                if (dataWriter.findGoalByTitle) {
+                    const existing = await dataWriter.findGoalByTitle(goal.title);
+                    if (existing) {
+                        conflicts.push({
+                            type: 'goal',
+                            existingHash: existing.hash,
+                            importedTitle: goal.title,
+                        });
+                    }
+                }
+            }
+        }
+        const statistics = {
+            goalsToImport: pkg.goals?.length ?? 0,
+            milestonesToImport: opts.importMilestones
+                ? pkg.goals?.reduce((sum, g) => sum + (g.milestones?.length ?? 0), 0) ?? 0
+                : 0,
+            tasksToImport: opts.importTasks
+                ? pkg.goals?.reduce((sum, g) => sum + (g.tasks?.length ?? 0), 0) ?? 0
+                : 0,
+            memoriesToImport: opts.importMemories
+                ? pkg.goals?.reduce((sum, g) => sum + (g.memories?.length ?? 0), 0) ?? 0
+                : 0,
+            metaGoalsToImport: opts.importMetaGoals
+                ? pkg.metaGoals?.length ?? 0
+                : 0,
+        };
+        const validation = {
+            valid: errors.length === 0,
+            errors,
+            warnings,
+            conflicts,
+            statistics,
+        };
+        this.emit('validation:completed', validation);
+        return validation;
+    }
+    async import(data, dataWriter, options) {
+        const opts = { ...this.defaultOptions, ...options };
+        const errors = [];
+        const warnings = [];
+        const imported = [];
+        const skipped = [];
+        const validation = await this.validate(data, dataWriter, opts);
+        if (!validation.valid) {
+            return {
+                success: false,
+                dryRun: opts.dryRun ?? false,
+                imported: [],
+                skipped: [],
+                errors: validation.errors,
+                warnings: validation.warnings,
+                statistics: this.emptyStatistics(),
+            };
+        }
+        if (opts.validateOnly) {
+            return {
+                success: true,
+                dryRun: true,
+                imported: [],
+                skipped: [],
+                errors: [],
+                warnings: validation.warnings,
+                statistics: {
+                    goalsImported: validation.statistics.goalsToImport,
+                    milestonesImported: validation.statistics.milestonesToImport,
+                    tasksImported: validation.statistics.tasksToImport,
+                    memoriesImported: validation.statistics.memoriesToImport,
+                    metaGoalsImported: validation.statistics.metaGoalsToImport,
+                },
+            };
+        }
+        const pkg = typeof data === 'string' ? this.parse(data) : data;
+        this.emit('import:started', pkg.goals.length);
+        let goalsImported = 0;
+        let milestonesImported = 0;
+        let tasksImported = 0;
+        let memoriesImported = 0;
+        let metaGoalsImported = 0;
+        for (let i = 0; i < pkg.goals.length; i++) {
+            const exportedGoal = pkg.goals[i];
+            this.emit('import:progress', i + 1, pkg.goals.length, exportedGoal.title);
+            try {
+                const conflict = validation.conflicts.find((c) => c.importedTitle === exportedGoal.title);
+                if (conflict) {
+                    this.emit('import:conflict', conflict);
+                    const resolution = opts.conflictResolution ?? 'skip';
+                    if (resolution === 'skip') {
+                        skipped.push(exportedGoal.title);
+                        continue;
+                    }
+                }
+                if (opts.dryRun) {
+                    goalsImported++;
+                    milestonesImported += exportedGoal.milestones?.length ?? 0;
+                    tasksImported += exportedGoal.tasks?.length ?? 0;
+                    memoriesImported += exportedGoal.memories?.length ?? 0;
+                    continue;
+                }
+                const mapping = await this.importGoal(exportedGoal, dataWriter, opts, conflict);
+                imported.push(mapping);
+                goalsImported++;
+                milestonesImported += mapping.milestoneMapping.size;
+                tasksImported += mapping.taskMapping.size;
+                memoriesImported += mapping.memoryMapping.size;
+            }
+            catch (error) {
+                errors.push(`Failed to import goal "${exportedGoal.title}": ${error instanceof Error ? error.message : String(error)}`);
+                this.emit('warning', errors[errors.length - 1]);
+            }
+        }
+        if (opts.importMetaGoals && pkg.metaGoals && dataWriter.createMetaGoal) {
+            for (const metaGoal of pkg.metaGoals) {
+                try {
+                    if (!opts.dryRun) {
+                        await this.importMetaGoal(metaGoal, dataWriter);
+                    }
+                    metaGoalsImported++;
+                }
+                catch (error) {
+                    warnings.push(`Failed to import meta-goal "${metaGoal.name}": ${error instanceof Error ? error.message : String(error)}`);
+                }
+            }
+        }
+        const result = {
+            success: errors.length === 0,
+            dryRun: opts.dryRun ?? false,
+            imported,
+            skipped,
+            errors,
+            warnings,
+            statistics: {
+                goalsImported,
+                milestonesImported,
+                tasksImported,
+                memoriesImported,
+                metaGoalsImported,
+            },
+        };
+        this.emit('import:completed', result);
+        return result;
+    }
+    async importTemplate(data, dataWriter, templateOptions) {
+        return this.import(data, dataWriter, {
+            mode: 'template',
+            conflictResolution: 'rename',
+            resetStatus: true,
+            prefixTitle: templateOptions?.newTitle,
+        });
+    }
+    validateGoal(goal) {
+        const errors = [];
+        if (!goal.hash) {
+            errors.push('Goal missing hash');
+        }
+        if (!goal.title) {
+            errors.push('Goal missing title');
+        }
+        if (!goal.status) {
+            errors.push('Goal missing status');
+        }
+        if (goal.milestones) {
+            for (let i = 0; i < goal.milestones.length; i++) {
+                if (!goal.milestones[i].title) {
+                    errors.push(`Milestone ${i} missing title`);
+                }
+            }
+        }
+        if (goal.tasks) {
+            for (let i = 0; i < goal.tasks.length; i++) {
+                if (!goal.tasks[i].title) {
+                    errors.push(`Task ${i} missing title`);
+                }
+                if (!goal.tasks[i].type) {
+                    errors.push(`Task ${i} missing type`);
+                }
+            }
+        }
+        return errors;
+    }
+    async importGoal(exported, dataWriter, options, conflict) {
+        let title = exported.title;
+        if (options.prefixTitle) {
+            title = options.prefixTitle;
+        }
+        else if (conflict && options.conflictResolution === 'rename') {
+            title = `${exported.title} (Imported ${new Date().toLocaleDateString()})`;
+        }
+        const goalInput = {
+            name: title,
+            description: exported.description,
+            priority: exported.priority,
+            deadline: exported.deadline,
+            approvalMode: exported.approvalMode,
+        };
+        const newGoal = await dataWriter.createGoal(goalInput);
+        const milestoneMapping = new Map();
+        const taskMapping = new Map();
+        const memoryMapping = new Map();
+        if (options.importMilestones && exported.milestones) {
+            for (const milestone of exported.milestones) {
+                const milestoneInput = {
+                    title: milestone.title,
+                    description: milestone.description,
+                    targetDate: milestone.deadline,
+                };
+                const newMilestone = await dataWriter.createMilestone(newGoal.hash, milestoneInput);
+                milestoneMapping.set(milestone.id, newMilestone.id);
+            }
+        }
+        if (options.importTasks && exported.tasks) {
+            for (const task of exported.tasks) {
+                const newMilestoneId = task.milestoneId
+                    ? milestoneMapping.get(task.milestoneId)
+                    : undefined;
+                const taskInput = {
+                    milestoneId: newMilestoneId,
+                    title: task.title,
+                    description: task.description,
+                    taskType: task.type || 'execute',
+                };
+                const newTask = await dataWriter.createTask(newGoal.hash, taskInput);
+                taskMapping.set(task.id, newTask.id);
+            }
+        }
+        if (options.importMemories && exported.memories) {
+            for (const memory of exported.memories) {
+                const memoryInput = {
+                    content: memory.content,
+                    memoryType: memory.category || 'conversation',
+                    source: memory.source || 'manual',
+                };
+                const newMemory = await dataWriter.createMemory(newGoal.hash, memoryInput);
+                memoryMapping.set(memory.id, newMemory.id);
+            }
+        }
+        return {
+            originalHash: exported.hash,
+            newHash: newGoal.hash,
+            milestoneMapping,
+            taskMapping,
+            memoryMapping,
+        };
+    }
+    async importMetaGoal(exported, dataWriter) {
+        if (!dataWriter.createMetaGoal)
+            return;
+        const input = {
+            description: exported.description || '',
+            priority: exported.priority,
+            scope: exported.scope === 'global' ? 'all' : (Array.isArray(exported.scope) ? exported.scope : 'all'),
+        };
+        await dataWriter.createMetaGoal(input);
+    }
+    emptyValidationStatistics() {
+        return {
+            goalsToImport: 0,
+            milestonesToImport: 0,
+            tasksToImport: 0,
+            memoriesToImport: 0,
+            metaGoalsToImport: 0,
+        };
+    }
+    emptyStatistics() {
+        return {
+            goalsImported: 0,
+            milestonesImported: 0,
+            tasksImported: 0,
+            memoriesImported: 0,
+            metaGoalsImported: 0,
+        };
+    }
+}
+export function createGoalImporter(options) {
+    return new GoalImporter(options);
+}

package/dist/goals/GoalManager.d.ts

@@ -0,0 +1,110 @@
+import { EventEmitter } from 'node:events';
+import type { Goal, GoalHash, Milestone, Task, GoalMemory, MetaGoal, GoalActionLog, GoalProgress, CreateGoalInput, UpdateGoalInput, CreateMilestoneInput, UpdateMilestoneInput, CreateTaskInput, UpdateTaskInput, CreateMemoryInput, UpdateMemoryInput, CreateMetaGoalInput, UpdateMetaGoalInput, TaskFeedbackInput, TaskFailInput, Logger } from './types.js';
+import { type GoalApiClientOptions, type TokenProvider, type ApiListOptions } from './GoalApiClient.js';
+import { type GoalValidationConstraints } from './GoalValidator.js';
+import { type GoalCacheOptions, type CacheStats } from './GoalCache.js';
+export interface GoalManagerEvents {
+    goalCreated: [goal: Goal];
+    goalUpdated: [goal: Goal];
+    goalPaused: [goal: Goal];
+    goalResumed: [goal: Goal];
+    goalCompleted: [goal: Goal];
+    goalAbandoned: [goal: Goal];
+    goalDeleted: [hash: GoalHash];
+    milestoneCreated: [goalHash: GoalHash, milestone: Milestone];
+    milestoneUpdated: [goalHash: GoalHash, milestone: Milestone];
+    milestoneCompleted: [goalHash: GoalHash, milestone: Milestone];
+    milestoneDeleted: [goalHash: GoalHash, milestoneId: number];
+    taskCreated: [goalHash: GoalHash, task: Task];
+    taskUpdated: [goalHash: GoalHash, task: Task];
+    taskStatusChanged: [goalHash: GoalHash, task: Task, previousStatus: string];
+    taskDeleted: [goalHash: GoalHash, taskId: number];
+    memoryCreated: [goalHash: GoalHash, memory: GoalMemory];
+    memoryUpdated: [goalHash: GoalHash, memory: GoalMemory];
+    memoryDeleted: [goalHash: GoalHash, memoryId: number];
+    metaGoalCreated: [metaGoal: MetaGoal];
+    metaGoalUpdated: [metaGoal: MetaGoal];
+    metaGoalToggled: [metaGoal: MetaGoal];
+    metaGoalDeleted: [id: number];
+    cacheInvalidated: [type: string];
+    error: [error: Error];
+}
+export interface GoalManagerOptions {
+    readonly baseUrl: string;
+    readonly tokenProvider: TokenProvider;
+    readonly apiOptions?: Partial<Omit<GoalApiClientOptions, 'baseUrl' | 'tokenProvider'>>;
+    readonly validationConstraints?: Partial<GoalValidationConstraints>;
+    readonly cacheOptions?: GoalCacheOptions;
+    readonly logger?: Logger;
+}
+export interface GoalManagerStats {
+    readonly cache: CacheStats;
+    readonly apiCalls: number;
+    readonly goalsLoaded: number;
+}
+export declare class GoalManager extends EventEmitter<GoalManagerEvents> {
+    private readonly apiClient;
+    private readonly validator;
+    private readonly cache;
+    private readonly logger;
+    private apiCallCount;
+    private loadedGoals;
+    constructor(options: GoalManagerOptions);
+    initialize(): Promise<void>;
+    listGoals(options?: ApiListOptions & {
+        forceRefresh?: boolean;
+    }): Promise<Goal[]>;
+    getGoal(hash: GoalHash, forceRefresh?: boolean): Promise<Goal>;
+    createGoal(input: CreateGoalInput): Promise<Goal>;
+    updateGoal(hash: GoalHash, input: UpdateGoalInput): Promise<Goal>;
+    deleteGoal(hash: GoalHash): Promise<void>;
+    pauseGoal(hash: GoalHash): Promise<Goal>;
+    resumeGoal(hash: GoalHash): Promise<Goal>;
+    completeGoal(hash: GoalHash): Promise<Goal>;
+    abandonGoal(hash: GoalHash): Promise<Goal>;
+    getGoalProgress(hash: GoalHash): Promise<GoalProgress>;
+    listMilestones(goalHash: GoalHash, forceRefresh?: boolean): Promise<Milestone[]>;
+    createMilestone(goalHash: GoalHash, input: CreateMilestoneInput): Promise<Milestone>;
+    getMilestone(goalHash: GoalHash, milestoneId: number): Promise<Milestone>;
+    updateMilestone(goalHash: GoalHash, milestoneId: number, input: UpdateMilestoneInput): Promise<Milestone>;
+    deleteMilestone(goalHash: GoalHash, milestoneId: number): Promise<void>;
+    completeMilestone(goalHash: GoalHash, milestoneId: number): Promise<Milestone>;
+    listTasks(goalHash: GoalHash, options?: ApiListOptions & {
+        forceRefresh?: boolean;
+    }): Promise<Task[]>;
+    getPendingTasks(): Promise<Task[]>;
+    getTasksAwaitingApproval(): Promise<Task[]>;
+    createTask(goalHash: GoalHash, input: CreateTaskInput): Promise<Task>;
+    getTask(goalHash: GoalHash, taskId: number): Promise<Task>;
+    updateTask(goalHash: GoalHash, taskId: number, input: UpdateTaskInput): Promise<Task>;
+    deleteTask(goalHash: GoalHash, taskId: number): Promise<void>;
+    approveTask(goalHash: GoalHash, taskId: number): Promise<Task>;
+    denyTask(goalHash: GoalHash, taskId: number): Promise<Task>;
+    startTask(goalHash: GoalHash, taskId: number): Promise<Task>;
+    completeTask(goalHash: GoalHash, taskId: number, result?: Record<string, unknown>): Promise<Task>;
+    failTask(goalHash: GoalHash, taskId: number, input: TaskFailInput): Promise<Task>;
+    skipTask(goalHash: GoalHash, taskId: number): Promise<Task>;
+    addTaskFeedback(goalHash: GoalHash, taskId: number, input: TaskFeedbackInput): Promise<Task>;
+    listMemories(goalHash: GoalHash, forceRefresh?: boolean): Promise<GoalMemory[]>;
+    getEnabledMemories(goalHash: GoalHash): Promise<GoalMemory[]>;
+    createMemory(goalHash: GoalHash, input: CreateMemoryInput): Promise<GoalMemory>;
+    updateMemory(goalHash: GoalHash, memoryId: number, input: UpdateMemoryInput): Promise<GoalMemory>;
+    toggleMemory(goalHash: GoalHash, memoryId: number): Promise<GoalMemory>;
+    deleteMemory(goalHash: GoalHash, memoryId: number): Promise<void>;
+    listMetaGoals(active?: boolean, forceRefresh?: boolean): Promise<MetaGoal[]>;
+    getMetaGoalsForGoal(goalHash: GoalHash): Promise<MetaGoal[]>;
+    createMetaGoal(input: CreateMetaGoalInput): Promise<MetaGoal>;
+    getMetaGoal(id: number): Promise<MetaGoal>;
+    updateMetaGoal(id: number, input: UpdateMetaGoalInput): Promise<MetaGoal>;
+    toggleMetaGoal(id: number): Promise<MetaGoal>;
+    deleteMetaGoal(id: number): Promise<void>;
+    getActionLogs(goalHash: GoalHash, limit?: number): Promise<GoalActionLog[]>;
+    clearCache(): void;
+    pruneCache(): number;
+    getCacheStats(): CacheStats;
+    getStats(): GoalManagerStats;
+    resetStats(): void;
+    private validateNoDependencyCycle;
+    private hasCycleDFS;
+}
+export declare function createGoalManager(options: GoalManagerOptions): GoalManager;