@flowdot.ai/daemon 1.0.0

package/dist/goals/GoalExporter.js

@@ -0,0 +1,318 @@
+import { EventEmitter } from 'events';
+export const EXPORT_FORMAT_VERSION = '1.0.0';
+export class GoalExporter extends EventEmitter {
+    logger;
+    defaultOptions;
+    constructor(options = {}) {
+        super();
+        this.logger = options.logger ?? console;
+        this.defaultOptions = options.defaultOptions ?? {
+            type: 'full',
+            includeProgress: true,
+            includeSnapshots: false,
+            includeFeedback: false,
+            includeMetaGoals: true,
+            stripUserData: false,
+            compress: false,
+            prettyPrint: true,
+        };
+    }
+    async exportGoal(goalHash, dataProvider, options) {
+        return this.exportGoals([goalHash], dataProvider, options);
+    }
+    async exportGoals(goalHashes, dataProvider, options) {
+        const opts = { ...this.defaultOptions, ...options };
+        const errors = [];
+        const warnings = [];
+        this.emit('export:started', goalHashes.length);
+        try {
+            const goals = await dataProvider.getGoals(goalHashes);
+            if (goals.length === 0) {
+                return {
+                    success: false,
+                    errors: ['No goals found to export'],
+                    warnings: [],
+                    statistics: this.emptyStatistics(),
+                };
+            }
+            if (goals.length !== goalHashes.length) {
+                warnings.push(`Requested ${goalHashes.length} goals but found ${goals.length}`);
+                this.emit('warning', warnings[warnings.length - 1]);
+            }
+            const exportedGoals = [];
+            let totalMilestones = 0;
+            let totalTasks = 0;
+            let totalMemories = 0;
+            for (let i = 0; i < goals.length; i++) {
+                const goal = goals[i];
+                this.emit('export:progress', i + 1, goals.length);
+                try {
+                    const exported = await this.exportSingleGoal(goal, dataProvider, opts);
+                    exportedGoals.push(exported);
+                    totalMilestones += exported.milestones.length;
+                    totalTasks += exported.tasks.length;
+                    totalMemories += exported.memories.length;
+                }
+                catch (error) {
+                    errors.push(`Failed to export goal ${goal.hash}: ${error instanceof Error ? error.message : String(error)}`);
+                    this.emit('warning', errors[errors.length - 1]);
+                }
+            }
+            let exportedMetaGoals;
+            if (opts.includeMetaGoals && dataProvider.getMetaGoals) {
+                try {
+                    const metaGoals = await dataProvider.getMetaGoals();
+                    exportedMetaGoals = metaGoals.map((mg) => this.exportMetaGoal(mg, opts.stripUserData ?? false));
+                }
+                catch (error) {
+                    warnings.push(`Failed to export meta-goals: ${error instanceof Error ? error.message : String(error)}`);
+                }
+            }
+            const manifest = {
+                version: EXPORT_FORMAT_VERSION,
+                exportType: opts.type ?? 'full',
+                exportedAt: new Date().toISOString(),
+                goalCount: exportedGoals.length,
+                metaGoalCount: exportedMetaGoals?.length ?? 0,
+                totalMilestones,
+                totalTasks,
+                totalMemories,
+                options: opts,
+            };
+            const exportPackage = {
+                manifest,
+                goals: exportedGoals,
+                metaGoals: exportedMetaGoals,
+            };
+            const serialized = this.serialize(exportPackage, opts);
+            const result = {
+                success: errors.length === 0,
+                package: exportPackage,
+                serialized,
+                errors,
+                warnings,
+                statistics: {
+                    goalsExported: exportedGoals.length,
+                    milestonesExported: totalMilestones,
+                    tasksExported: totalTasks,
+                    memoriesExported: totalMemories,
+                    metaGoalsExported: exportedMetaGoals?.length ?? 0,
+                    exportSize: serialized.length,
+                },
+            };
+            this.emit('export:completed', result);
+            return result;
+        }
+        catch (error) {
+            const err = error instanceof Error ? error : new Error(String(error));
+            this.emit('export:error', err);
+            return {
+                success: false,
+                errors: [err.message],
+                warnings,
+                statistics: this.emptyStatistics(),
+            };
+        }
+    }
+    async exportAll(dataProvider, options) {
+        const goals = await dataProvider.getGoals();
+        const hashes = goals.map((g) => g.hash);
+        return this.exportGoals(hashes, dataProvider, options);
+    }
+    async createTemplate(goalHash, dataProvider, _templateName) {
+        return this.exportGoal(goalHash, dataProvider, {
+            type: 'template',
+            stripUserData: true,
+            includeProgress: false,
+            includeSnapshots: false,
+            includeFeedback: false,
+            includeMetaGoals: false,
+        });
+    }
+    validateExport(data) {
+        const errors = [];
+        const warnings = [];
+        try {
+            const pkg = typeof data === 'string'
+                ? JSON.parse(data)
+                : data;
+            if (!pkg.manifest) {
+                errors.push('Missing manifest');
+            }
+            else {
+                if (!pkg.manifest.version) {
+                    errors.push('Missing version in manifest');
+                }
+                if (!pkg.manifest.exportedAt) {
+                    errors.push('Missing exportedAt in manifest');
+                }
+                if (pkg.manifest.version !== EXPORT_FORMAT_VERSION) {
+                    warnings.push(`Version mismatch: export is ${pkg.manifest.version}, current is ${EXPORT_FORMAT_VERSION}`);
+                }
+            }
+            if (!Array.isArray(pkg.goals)) {
+                errors.push('Goals must be an array');
+            }
+            else {
+                for (let i = 0; i < pkg.goals.length; i++) {
+                    const goal = pkg.goals[i];
+                    if (!goal.hash) {
+                        errors.push(`Goal ${i} missing hash`);
+                    }
+                    if (!goal.title) {
+                        errors.push(`Goal ${i} missing title`);
+                    }
+                    if (!goal.status) {
+                        errors.push(`Goal ${i} missing status`);
+                    }
+                }
+            }
+            if (pkg.manifest?.checksum) {
+                const computed = this.computeChecksum(pkg.goals);
+                if (computed !== pkg.manifest.checksum) {
+                    errors.push('Checksum mismatch - data may be corrupted');
+                }
+            }
+        }
+        catch (error) {
+            errors.push(`Parse error: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        return {
+            valid: errors.length === 0,
+            errors,
+            warnings,
+        };
+    }
+    async exportSingleGoal(goal, dataProvider, options) {
+        const [milestones, tasks, memories] = await Promise.all([
+            dataProvider.getMilestones(goal.hash),
+            dataProvider.getTasks(goal.hash),
+            dataProvider.getMemories(goal.hash),
+        ]);
+        const progress = options.includeProgress && dataProvider.getProgress
+            ? dataProvider.getProgress(goal.hash)
+            : undefined;
+        const snapshots = options.includeSnapshots && dataProvider.getSnapshots
+            ? dataProvider.getSnapshots(goal.hash)
+            : undefined;
+        const feedback = options.includeFeedback && dataProvider.getFeedback
+            ? dataProvider.getFeedback(goal.hash)
+            : undefined;
+        const stripUserData = options.stripUserData ?? false;
+        return {
+            hash: stripUserData ? this.anonymizeHash(goal.hash) : goal.hash,
+            title: goal.name,
+            description: goal.description ?? undefined,
+            status: options.type === 'template' ? 'draft' : goal.status,
+            priority: goal.priority,
+            deadline: goal.deadline?.toISOString(),
+            approvalMode: goal.approvalMode,
+            parentHash: String(goal.parentId)
+                ? stripUserData
+                    ? this.anonymizeHash(String(goal.parentId))
+                    : String(goal.parentId)
+                : undefined,
+            dependencyHashes: goal.dependsOn?.map((h) => stripUserData ? this.anonymizeHash(h) : h),
+            tags: [],
+            createdAt: goal.createdAt.toISOString(),
+            updatedAt: goal.updatedAt.toISOString(),
+            milestones: milestones.map((m) => this.exportMilestone(m, stripUserData)),
+            tasks: tasks.map((t) => this.exportTask(t, stripUserData, options.type)),
+            memories: stripUserData
+                ? []
+                : memories.map((m) => this.exportMemory(m)),
+            progress: stripUserData ? undefined : progress,
+            snapshots: stripUserData ? undefined : snapshots,
+            feedback: stripUserData ? undefined : feedback,
+        };
+    }
+    exportMilestone(milestone, stripUserData) {
+        return {
+            id: milestone.id,
+            title: milestone.title,
+            description: milestone.description ?? undefined,
+            status: stripUserData ? 'pending' : (milestone.isComplete ? 'completed' : 'pending'),
+            order: milestone.id,
+            deadline: stripUserData ? undefined : milestone.targetDate?.toISOString(),
+            createdAt: milestone.createdAt.toISOString(),
+            updatedAt: milestone.updatedAt.toISOString(),
+        };
+    }
+    exportTask(task, stripUserData, exportType) {
+        return {
+            id: task.id,
+            milestoneId: task.milestoneId ?? undefined,
+            title: task.title,
+            description: task.description ?? undefined,
+            type: task.taskType,
+            status: exportType === 'template' || stripUserData ? 'pending' : task.status,
+            priority: task.priority ? { "high": 1, "medium": 2, "low": 3 }[task.priority] ?? 2 : 2,
+            params: stripUserData ? undefined : task.params,
+            requiresApproval: task.requiresApproval ?? false,
+            deadline: stripUserData ? undefined : task.deadline?.toISOString(),
+            completedAt: stripUserData ? undefined : task.completedAt?.toISOString(),
+            createdAt: task.createdAt.toISOString(),
+            updatedAt: task.updatedAt.toISOString(),
+        };
+    }
+    exportMemory(memory) {
+        return {
+            id: memory.id,
+            category: memory.memoryType,
+            content: memory.content,
+            source: memory.source,
+            confidence: undefined,
+            expiresAt: undefined,
+            createdAt: memory.createdAt.toISOString(),
+        };
+    }
+    exportMetaGoal(metaGoal, stripUserData) {
+        return {
+            id: metaGoal.id,
+            name: metaGoal.description,
+            description: metaGoal.description,
+            scope: metaGoal.scope === 'all' ? 'all' : 'specific',
+            appliesTo: metaGoal.scope === 'all' ? undefined : (stripUserData ? undefined : metaGoal.scope),
+            constraints: [],
+            priority: metaGoal.priority,
+            isActive: metaGoal.isActive,
+            createdAt: metaGoal.createdAt.toISOString(),
+            updatedAt: metaGoal.updatedAt.toISOString(),
+        };
+    }
+    anonymizeHash(hash) {
+        const base = hash.substring(0, 4);
+        return `anon_${base}_${Date.now().toString(36)}`;
+    }
+    serialize(pkg, options) {
+        const indent = options.prettyPrint ? 2 : undefined;
+        let serialized = JSON.stringify(pkg, null, indent);
+        if (options.compress) {
+            serialized = Buffer.from(serialized).toString('base64');
+        }
+        return serialized;
+    }
+    computeChecksum(goals) {
+        const data = JSON.stringify(goals.map((g) => g.hash).sort());
+        let hash = 0;
+        for (let i = 0; i < data.length; i++) {
+            const char = data.charCodeAt(i);
+            hash = (hash << 5) - hash + char;
+            hash = hash & hash;
+        }
+        return Math.abs(hash).toString(16);
+    }
+    emptyStatistics() {
+        return {
+            goalsExported: 0,
+            milestonesExported: 0,
+            tasksExported: 0,
+            memoriesExported: 0,
+            metaGoalsExported: 0,
+            exportSize: 0,
+        };
+    }
+}
+export function createGoalExporter(options) {
+    return new GoalExporter(options);
+}

package/dist/goals/GoalImporter.d.ts

@@ -0,0 +1,107 @@
+import { EventEmitter } from 'events';
+import type { Goal, GoalHash, CreateGoalInput, CreateMilestoneInput, CreateTaskInput, CreateMemoryInput, CreateMetaGoalInput, Logger } from './types.js';
+import { type ExportPackage } from './GoalExporter.js';
+export type ImportMode = 'create' | 'merge' | 'replace' | 'template';
+export type ConflictResolution = 'skip' | 'overwrite' | 'rename' | 'ask';
+export interface ImportOptions {
+    readonly mode?: ImportMode;
+    readonly conflictResolution?: ConflictResolution;
+    readonly dryRun?: boolean;
+    readonly validateOnly?: boolean;
+    readonly importMilestones?: boolean;
+    readonly importTasks?: boolean;
+    readonly importMemories?: boolean;
+    readonly importMetaGoals?: boolean;
+    readonly resetStatus?: boolean;
+    readonly assignToUser?: number;
+    readonly prefixTitle?: string;
+}
+export interface ImportConflict {
+    readonly type: 'goal' | 'meta_goal';
+    readonly existingHash?: GoalHash;
+    readonly importedTitle: string;
+    readonly resolution?: ConflictResolution;
+}
+export interface ImportValidation {
+    readonly valid: boolean;
+    readonly errors: string[];
+    readonly warnings: string[];
+    readonly conflicts: ImportConflict[];
+    readonly statistics: {
+        goalsToImport: number;
+        milestonesToImport: number;
+        tasksToImport: number;
+        memoriesToImport: number;
+        metaGoalsToImport: number;
+    };
+}
+export interface ImportMapping {
+    readonly originalHash: GoalHash;
+    readonly newHash: GoalHash;
+    readonly milestoneMapping: Map<number, number>;
+    readonly taskMapping: Map<number, number>;
+    readonly memoryMapping: Map<number, number>;
+}
+export interface ImportResult {
+    readonly success: boolean;
+    readonly dryRun: boolean;
+    readonly imported: ImportMapping[];
+    readonly skipped: string[];
+    readonly errors: string[];
+    readonly warnings: string[];
+    readonly statistics: {
+        goalsImported: number;
+        milestonesImported: number;
+        tasksImported: number;
+        memoriesImported: number;
+        metaGoalsImported: number;
+    };
+}
+export interface ImportDataWriter {
+    createGoal(input: CreateGoalInput): Promise<Goal>;
+    createMilestone(goalHash: GoalHash, input: CreateMilestoneInput): Promise<{
+        id: number;
+    }>;
+    createTask(goalHash: GoalHash, input: CreateTaskInput): Promise<{
+        id: number;
+    }>;
+    createMemory(goalHash: GoalHash, input: CreateMemoryInput): Promise<{
+        id: number;
+    }>;
+    createMetaGoal?(input: CreateMetaGoalInput): Promise<{
+        id: number;
+    }>;
+    goalExists?(hash: GoalHash): Promise<boolean>;
+    findGoalByTitle?(title: string): Promise<Goal | null>;
+}
+export interface GoalImporterOptions {
+    readonly logger?: Logger;
+    readonly defaultOptions?: ImportOptions;
+}
+export interface GoalImporterEvents {
+    'import:started': [goalCount: number];
+    'import:progress': [current: number, total: number, goalTitle: string];
+    'import:conflict': [conflict: ImportConflict];
+    'import:completed': [result: ImportResult];
+    'import:error': [error: Error];
+    'validation:completed': [validation: ImportValidation];
+    warning: [message: string];
+}
+export declare class GoalImporter extends EventEmitter<GoalImporterEvents> {
+    private readonly logger;
+    private readonly defaultOptions;
+    constructor(options?: GoalImporterOptions);
+    parse(data: string): ExportPackage;
+    validate(data: string | ExportPackage, dataWriter: ImportDataWriter, options?: ImportOptions): Promise<ImportValidation>;
+    import(data: string | ExportPackage, dataWriter: ImportDataWriter, options?: ImportOptions): Promise<ImportResult>;
+    importTemplate(data: string | ExportPackage, dataWriter: ImportDataWriter, templateOptions?: {
+        newTitle?: string;
+        newDeadline?: string;
+    }): Promise<ImportResult>;
+    private validateGoal;
+    private importGoal;
+    private importMetaGoal;
+    private emptyValidationStatistics;
+    private emptyStatistics;
+}
+export declare function createGoalImporter(options?: GoalImporterOptions): GoalImporter;