@savestate/cli 0.4.2 → 0.6.0

package/dist/migrate/capabilities.js

@@ -0,0 +1,80 @@
+/**
+ * Platform Capabilities
+ *
+ * Defines what each platform supports for compatibility checking.
+ */
+export const PLATFORM_CAPABILITIES = {
+    chatgpt: {
+        id: 'chatgpt',
+        name: 'ChatGPT',
+        instructionLimit: 1500,
+        hasMemory: true,
+        memoryLimit: 100,
+        hasFiles: true,
+        fileSizeLimit: 512 * 1024 * 1024, // 512MB
+        hasProjects: false,
+        hasConversations: true,
+        hasCustomBots: true,
+    },
+    claude: {
+        id: 'claude',
+        name: 'Claude',
+        instructionLimit: 8000, // System prompt can be much longer
+        hasMemory: false, // Claude uses project knowledge instead
+        hasFiles: true,
+        fileSizeLimit: 32 * 1024 * 1024, // 32MB per file
+        hasProjects: true,
+        hasConversations: true,
+        hasCustomBots: false, // Projects serve this role
+    },
+    gemini: {
+        id: 'gemini',
+        name: 'Gemini',
+        instructionLimit: 4000,
+        hasMemory: true,
+        memoryLimit: 50,
+        hasFiles: true,
+        fileSizeLimit: 20 * 1024 * 1024, // 20MB
+        hasProjects: false,
+        hasConversations: true,
+        hasCustomBots: false,
+    },
+    copilot: {
+        id: 'copilot',
+        name: 'Microsoft Copilot',
+        instructionLimit: 2000,
+        hasMemory: true,
+        hasFiles: true,
+        fileSizeLimit: 10 * 1024 * 1024, // 10MB
+        hasProjects: false,
+        hasConversations: true,
+        hasCustomBots: false,
+    },
+};
+/**
+ * Get capabilities for a platform.
+ */
+export function getPlatformCapabilities(platform) {
+    return PLATFORM_CAPABILITIES[platform];
+}
+/**
+ * Check if a migration path is supported.
+ */
+export function isMigrationSupported(source, target) {
+    // Currently supported paths
+    const supported = [
+        ['chatgpt', 'claude'],
+        ['claude', 'chatgpt'],
+    ];
+    return supported.some(([s, t]) => s === source && t === target);
+}
+/**
+ * Get all supported migration paths.
+ */
+export function getSupportedMigrations() {
+    return [
+        { source: 'chatgpt', target: 'claude' },
+        { source: 'claude', target: 'chatgpt' },
+    ];
+}
+//# sourceMappingURL=capabilities.js.map

package/dist/migrate/capabilities.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"capabilities.js","sourceRoot":"","sources":["../../src/migrate/capabilities.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,MAAM,CAAC,MAAM,qBAAqB,GAA2C;IAC3E,OAAO,EAAE;QACP,EAAE,EAAE,SAAS;QACb,IAAI,EAAE,SAAS;QACf,gBAAgB,EAAE,IAAI;QACtB,SAAS,EAAE,IAAI;QACf,WAAW,EAAE,GAAG;QAChB,QAAQ,EAAE,IAAI;QACd,aAAa,EAAE,GAAG,GAAG,IAAI,GAAG,IAAI,EAAE,QAAQ;QAC1C,WAAW,EAAE,KAAK;QAClB,gBAAgB,EAAE,IAAI;QACtB,aAAa,EAAE,IAAI;KACpB;IACD,MAAM,EAAE;QACN,EAAE,EAAE,QAAQ;QACZ,IAAI,EAAE,QAAQ;QACd,gBAAgB,EAAE,IAAI,EAAE,mCAAmC;QAC3D,SAAS,EAAE,KAAK,EAAE,wCAAwC;QAC1D,QAAQ,EAAE,IAAI;QACd,aAAa,EAAE,EAAE,GAAG,IAAI,GAAG,IAAI,EAAE,gBAAgB;QACjD,WAAW,EAAE,IAAI;QACjB,gBAAgB,EAAE,IAAI;QACtB,aAAa,EAAE,KAAK,EAAE,2BAA2B;KAClD;IACD,MAAM,EAAE;QACN,EAAE,EAAE,QAAQ;QACZ,IAAI,EAAE,QAAQ;QACd,gBAAgB,EAAE,IAAI;QACtB,SAAS,EAAE,IAAI;QACf,WAAW,EAAE,EAAE;QACf,QAAQ,EAAE,IAAI;QACd,aAAa,EAAE,EAAE,GAAG,IAAI,GAAG,IAAI,EAAE,OAAO;QACxC,WAAW,EAAE,KAAK;QAClB,gBAAgB,EAAE,IAAI;QACtB,aAAa,EAAE,KAAK;KACrB;IACD,OAAO,EAAE;QACP,EAAE,EAAE,SAAS;QACb,IAAI,EAAE,mBAAmB;QACzB,gBAAgB,EAAE,IAAI;QACtB,SAAS,EAAE,IAAI;QACf,QAAQ,EAAE,IAAI;QACd,aAAa,EAAE,EAAE,GAAG,IAAI,GAAG,IAAI,EAAE,OAAO;QACxC,WAAW,EAAE,KAAK;QAClB,gBAAgB,EAAE,IAAI;QACtB,aAAa,EAAE,KAAK;KACrB;CACF,CAAC;AAEF;;GAEG;AACH,MAAM,UAAU,uBAAuB,CAAC,QAAkB;IACxD,OAAO,qBAAqB,CAAC,QAAQ,CAAC,CAAC;AACzC,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,oBAAoB,CAAC,MAAgB,EAAE,MAAgB;IACrE,4BAA4B;IAC5B,MAAM,SAAS,GAAG;QAChB,CAAC,SAAS,EAAE,QAAQ,CAAC;QACrB,CAAC,QAAQ,EAAE,SAAS,CAAC;KACtB,CAAC;IAEF,OAAO,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,KAAK,MAAM,IAAI,CAAC,KAAK,MAAM,CAAC,CAAC;AAClE,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,sBAAsB;IACpC,OAAO;QACL,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE;QACvC,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE;KACxC,CAAC;AACJ,CAAC"}

package/dist/migrate/extractors/registry.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Extractor Registry
+ *
+ * Manages available extractors for different platforms.
+ * New extractors are registered here.
+ */
+import type { Platform, Extractor } from '../types.js';
+/**
+ * Register an extractor for a platform.
+ */
+export declare function registerExtractor(platform: Platform, factory: () => Extractor): void;
+/**
+ * Get an extractor for a platform.
+ */
+export declare function getExtractor(platform: Platform): Extractor | null;
+/**
+ * List all registered extractors.
+ */
+export declare function listExtractors(): Platform[];
+/**
+ * Check if an extractor exists for a platform.
+ */
+export declare function hasExtractor(platform: Platform): boolean;
+//# sourceMappingURL=registry.d.ts.map

package/dist/migrate/extractors/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../../src/migrate/extractors/registry.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAIvD;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,SAAS,GAAG,IAAI,CAEpF;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,QAAQ,EAAE,QAAQ,GAAG,SAAS,GAAG,IAAI,CAGjE;AAED;;GAEG;AACH,wBAAgB,cAAc,IAAI,QAAQ,EAAE,CAE3C;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,QAAQ,EAAE,QAAQ,GAAG,OAAO,CAExD"}

package/dist/migrate/extractors/registry.js

@@ -0,0 +1,38 @@
+/**
+ * Extractor Registry
+ *
+ * Manages available extractors for different platforms.
+ * New extractors are registered here.
+ */
+const extractors = new Map();
+/**
+ * Register an extractor for a platform.
+ */
+export function registerExtractor(platform, factory) {
+    extractors.set(platform, factory);
+}
+/**
+ * Get an extractor for a platform.
+ */
+export function getExtractor(platform) {
+    const factory = extractors.get(platform);
+    return factory ? factory() : null;
+}
+/**
+ * List all registered extractors.
+ */
+export function listExtractors() {
+    return [...extractors.keys()];
+}
+/**
+ * Check if an extractor exists for a platform.
+ */
+export function hasExtractor(platform) {
+    return extractors.has(platform);
+}
+// ─── Register Built-in Extractors ────────────────────────────
+// ChatGPT extractor will be registered in #24
+// registerExtractor('chatgpt', () => new ChatGPTExtractor());
+// Claude extractor will be registered in #29
+// registerExtractor('claude', () => new ClaudeExtractor());
+//# sourceMappingURL=registry.js.map

package/dist/migrate/extractors/registry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.js","sourceRoot":"","sources":["../../../src/migrate/extractors/registry.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,MAAM,UAAU,GAAG,IAAI,GAAG,EAA6B,CAAC;AAExD;;GAEG;AACH,MAAM,UAAU,iBAAiB,CAAC,QAAkB,EAAE,OAAwB;IAC5E,UAAU,CAAC,GAAG,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAC;AACpC,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,YAAY,CAAC,QAAkB;IAC7C,MAAM,OAAO,GAAG,UAAU,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;IACzC,OAAO,OAAO,CAAC,CAAC,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC;AACpC,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,cAAc;IAC5B,OAAO,CAAC,GAAG,UAAU,CAAC,IAAI,EAAE,CAAC,CAAC;AAChC,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,YAAY,CAAC,QAAkB;IAC7C,OAAO,UAAU,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;AAClC,CAAC;AAED,gEAAgE;AAEhE,8CAA8C;AAC9C,8DAA8D;AAE9D,6CAA6C;AAC7C,4DAA4D"}

package/dist/migrate/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Migration Wizard
+ *
+ * Platform-to-platform AI identity migration.
+ * Extract → Transform → Load
+ */
+export type { Platform, PlatformCapabilities, MigrationBundle, MigrationContents, MigrationState, MigrationPhase, MigrationOptions, MigrationCheckpoint, CompatibilityReport, CompatibilityItem, CompatibilityStatus, Extractor, ExtractOptions, Transformer, TransformOptions, Loader, LoadOptions, LoadResult, } from './types.js';
+export { MigrationOrchestrator, type MigrationEvent, type MigrationEventHandler } from './orchestrator.js';
+export { getExtractor, registerExtractor, listExtractors, hasExtractor } from './extractors/registry.js';
+export { getTransformer, registerTransformer, listTransformers, hasTransformer } from './transformers/registry.js';
+export { getLoader, registerLoader, listLoaders, hasLoader } from './loaders/registry.js';
+export { getPlatformCapabilities, PLATFORM_CAPABILITIES } from './capabilities.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/migrate/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/migrate/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,YAAY,EACV,QAAQ,EACR,oBAAoB,EACpB,eAAe,EACf,iBAAiB,EACjB,cAAc,EACd,cAAc,EACd,gBAAgB,EAChB,mBAAmB,EACnB,mBAAmB,EACnB,iBAAiB,EACjB,mBAAmB,EACnB,SAAS,EACT,cAAc,EACd,WAAW,EACX,gBAAgB,EAChB,MAAM,EACN,WAAW,EACX,UAAU,GACX,MAAM,YAAY,CAAC;AAGpB,OAAO,EAAE,qBAAqB,EAAE,KAAK,cAAc,EAAE,KAAK,qBAAqB,EAAE,MAAM,mBAAmB,CAAC;AAG3G,OAAO,EAAE,YAAY,EAAE,iBAAiB,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AACzG,OAAO,EAAE,cAAc,EAAE,mBAAmB,EAAE,gBAAgB,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAC;AACnH,OAAO,EAAE,SAAS,EAAE,cAAc,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAG1F,OAAO,EAAE,uBAAuB,EAAE,qBAAqB,EAAE,MAAM,mBAAmB,CAAC"}

package/dist/migrate/index.js

@@ -0,0 +1,15 @@
+/**
+ * Migration Wizard
+ *
+ * Platform-to-platform AI identity migration.
+ * Extract → Transform → Load
+ */
+// Orchestrator
+export { MigrationOrchestrator } from './orchestrator.js';
+// Registries
+export { getExtractor, registerExtractor, listExtractors, hasExtractor } from './extractors/registry.js';
+export { getTransformer, registerTransformer, listTransformers, hasTransformer } from './transformers/registry.js';
+export { getLoader, registerLoader, listLoaders, hasLoader } from './loaders/registry.js';
+// Platform capabilities (for compatibility checking)
+export { getPlatformCapabilities, PLATFORM_CAPABILITIES } from './capabilities.js';
+//# sourceMappingURL=index.js.map

package/dist/migrate/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/migrate/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAwBH,eAAe;AACf,OAAO,EAAE,qBAAqB,EAAmD,MAAM,mBAAmB,CAAC;AAE3G,aAAa;AACb,OAAO,EAAE,YAAY,EAAE,iBAAiB,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AACzG,OAAO,EAAE,cAAc,EAAE,mBAAmB,EAAE,gBAAgB,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAC;AACnH,OAAO,EAAE,SAAS,EAAE,cAAc,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAE1F,qDAAqD;AACrD,OAAO,EAAE,uBAAuB,EAAE,qBAAqB,EAAE,MAAM,mBAAmB,CAAC"}

package/dist/migrate/loaders/registry.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Loader Registry
+ *
+ * Manages available loaders for different platforms.
+ * New loaders are registered here.
+ */
+import type { Platform, Loader } from '../types.js';
+/**
+ * Register a loader for a platform.
+ */
+export declare function registerLoader(platform: Platform, factory: () => Loader): void;
+/**
+ * Get a loader for a platform.
+ */
+export declare function getLoader(platform: Platform): Loader | null;
+/**
+ * List all registered loaders.
+ */
+export declare function listLoaders(): Platform[];
+/**
+ * Check if a loader exists for a platform.
+ */
+export declare function hasLoader(platform: Platform): boolean;
+//# sourceMappingURL=registry.d.ts.map

package/dist/migrate/loaders/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../../src/migrate/loaders/registry.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAIpD;;GAEG;AACH,wBAAgB,cAAc,CAAC,QAAQ,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,MAAM,GAAG,IAAI,CAE9E;AAED;;GAEG;AACH,wBAAgB,SAAS,CAAC,QAAQ,EAAE,QAAQ,GAAG,MAAM,GAAG,IAAI,CAG3D;AAED;;GAEG;AACH,wBAAgB,WAAW,IAAI,QAAQ,EAAE,CAExC;AAED;;GAEG;AACH,wBAAgB,SAAS,CAAC,QAAQ,EAAE,QAAQ,GAAG,OAAO,CAErD"}

package/dist/migrate/loaders/registry.js

@@ -0,0 +1,38 @@
+/**
+ * Loader Registry
+ *
+ * Manages available loaders for different platforms.
+ * New loaders are registered here.
+ */
+const loaders = new Map();
+/**
+ * Register a loader for a platform.
+ */
+export function registerLoader(platform, factory) {
+    loaders.set(platform, factory);
+}
+/**
+ * Get a loader for a platform.
+ */
+export function getLoader(platform) {
+    const factory = loaders.get(platform);
+    return factory ? factory() : null;
+}
+/**
+ * List all registered loaders.
+ */
+export function listLoaders() {
+    return [...loaders.keys()];
+}
+/**
+ * Check if a loader exists for a platform.
+ */
+export function hasLoader(platform) {
+    return loaders.has(platform);
+}
+// ─── Register Built-in Loaders ───────────────────────────────
+// Claude loader will be registered in #25
+// registerLoader('claude', () => new ClaudeLoader());
+// ChatGPT loader will be registered in #30
+// registerLoader('chatgpt', () => new ChatGPTLoader());
+//# sourceMappingURL=registry.js.map

package/dist/migrate/loaders/registry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.js","sourceRoot":"","sources":["../../../src/migrate/loaders/registry.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,MAAM,OAAO,GAAG,IAAI,GAAG,EAA0B,CAAC;AAElD;;GAEG;AACH,MAAM,UAAU,cAAc,CAAC,QAAkB,EAAE,OAAqB;IACtE,OAAO,CAAC,GAAG,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAC;AACjC,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,SAAS,CAAC,QAAkB;IAC1C,MAAM,OAAO,GAAG,OAAO,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;IACtC,OAAO,OAAO,CAAC,CAAC,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC;AACpC,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,WAAW;IACzB,OAAO,CAAC,GAAG,OAAO,CAAC,IAAI,EAAE,CAAC,CAAC;AAC7B,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,SAAS,CAAC,QAAkB;IAC1C,OAAO,OAAO,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;AAC/B,CAAC;AAED,gEAAgE;AAEhE,0CAA0C;AAC1C,sDAAsD;AAEtD,2CAA2C;AAC3C,wDAAwD"}

package/dist/migrate/orchestrator.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Migration Orchestrator
+ *
+ * Coordinates the three-phase migration process:
+ * Extract → Transform → Load
+ *
+ * Features:
+ * - Phase checkpoint/resume capability
+ * - Progress tracking
+ * - Error recovery
+ * - Rollback support
+ */
+import type { Platform, MigrationBundle, MigrationState, MigrationPhase, MigrationOptions, CompatibilityReport, LoadResult } from './types.js';
+export type MigrationEventType = 'phase:start' | 'phase:complete' | 'phase:error' | 'progress' | 'checkpoint' | 'complete' | 'error';
+export interface MigrationEvent {
+    type: MigrationEventType;
+    phase?: MigrationPhase;
+    progress?: number;
+    message?: string;
+    error?: Error;
+    data?: unknown;
+}
+export type MigrationEventHandler = (event: MigrationEvent) => void;
+export declare class MigrationOrchestrator {
+    private state;
+    private bundle;
+    private eventHandlers;
+    private workDir;
+    constructor(source: Platform, target: Platform, options?: MigrationOptions);
+    /**
+     * Run the full migration pipeline.
+     */
+    run(): Promise<LoadResult>;
+    /**
+     * Run only the extract phase (useful for debugging/inspection).
+     */
+    extract(): Promise<MigrationBundle>;
+    /**
+     * Generate compatibility report without running full migration.
+     */
+    analyze(): Promise<CompatibilityReport>;
+    /**
+     * Resume a failed or interrupted migration.
+     */
+    static resume(migrationId: string, workDir?: string): Promise<MigrationOrchestrator>;
+    /**
+     * Resume and continue the migration from where it left off.
+     */
+    continue(): Promise<LoadResult>;
+    /**
+     * Clean up migration artifacts.
+     */
+    cleanup(): Promise<void>;
+    /**
+     * Subscribe to migration events.
+     */
+    on(handler: MigrationEventHandler): () => void;
+    /**
+     * Get current migration state.
+     */
+    getState(): MigrationState;
+    /**
+     * Get the migration bundle (if extracted).
+     */
+    getBundle(): MigrationBundle | null;
+    private runExtractPhase;
+    private runTransformPhase;
+    private runLoadPhase;
+    private generateId;
+    private ensureWorkDir;
+    private setPhase;
+    private saveState;
+    private saveCheckpoint;
+    private loadCheckpoint;
+    private emit;
+}
+//# sourceMappingURL=orchestrator.d.ts.map

package/dist/migrate/orchestrator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"orchestrator.d.ts","sourceRoot":"","sources":["../../src/migrate/orchestrator.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAQH,OAAO,KAAK,EACV,QAAQ,EACR,eAAe,EACf,cAAc,EACd,cAAc,EAEd,gBAAgB,EAChB,mBAAmB,EAInB,UAAU,EACX,MAAM,YAAY,CAAC;AAQpB,MAAM,MAAM,kBAAkB,GAC1B,aAAa,GACb,gBAAgB,GAChB,aAAa,GACb,UAAU,GACV,YAAY,GACZ,UAAU,GACV,OAAO,CAAC;AAEZ,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,kBAAkB,CAAC;IACzB,KAAK,CAAC,EAAE,cAAc,CAAC;IACvB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,KAAK,CAAC;IACd,IAAI,CAAC,EAAE,OAAO,CAAC;CAChB;AAED,MAAM,MAAM,qBAAqB,GAAG,CAAC,KAAK,EAAE,cAAc,KAAK,IAAI,CAAC;AAIpE,qBAAa,qBAAqB;IAChC,OAAO,CAAC,KAAK,CAAiB;IAC9B,OAAO,CAAC,MAAM,CAAgC;IAC9C,OAAO,CAAC,aAAa,CAA+B;IACpD,OAAO,CAAC,OAAO,CAAS;gBAGtB,MAAM,EAAE,QAAQ,EAChB,MAAM,EAAE,QAAQ,EAChB,OAAO,GAAE,gBAAqB;IAoBhC;;OAEG;IACG,GAAG,IAAI,OAAO,CAAC,UAAU,CAAC;IA+BhC;;OAEG;IACG,OAAO,IAAI,OAAO,CAAC,eAAe,CAAC;IAMzC;;OAEG;IACG,OAAO,IAAI,OAAO,CAAC,mBAAmB,CAAC;IAkB7C;;OAEG;WACU,MAAM,CAAC,WAAW,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,qBAAqB,CAAC;IAwB1F;;OAEG;IACG,QAAQ,IAAI,OAAO,CAAC,UAAU,CAAC;IA+BrC;;OAEG;IACG,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAM9B;;OAEG;IACH,EAAE,CAAC,OAAO,EAAE,qBAAqB,GAAG,MAAM,IAAI;IAQ9C;;OAEG;IACH,QAAQ,IAAI,cAAc;IAI1B;;OAEG;IACH,SAAS,IAAI,eAAe,GAAG,IAAI;YAMrB,eAAe;YAgCf,iBAAiB;YA+BjB,YAAY;IAqD1B,OAAO,CAAC,UAAU;YAIJ,aAAa;IAI3B,OAAO,CAAC,QAAQ;YAKF,SAAS;YAKT,cAAc;YA4Bd,cAAc;IAc5B,OAAO,CAAC,IAAI;CASb"}

package/dist/migrate/orchestrator.js

@@ -0,0 +1,322 @@
+/**
+ * Migration Orchestrator
+ *
+ * Coordinates the three-phase migration process:
+ * Extract → Transform → Load
+ *
+ * Features:
+ * - Phase checkpoint/resume capability
+ * - Progress tracking
+ * - Error recovery
+ * - Rollback support
+ */
+import { randomBytes } from 'node:crypto';
+import { mkdir, writeFile, readFile, rm } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { createHash } from 'node:crypto';
+import { getExtractor } from './extractors/registry.js';
+import { getTransformer } from './transformers/registry.js';
+import { getLoader } from './loaders/registry.js';
+// ─── Orchestrator ────────────────────────────────────────────
+export class MigrationOrchestrator {
+    state;
+    bundle = null;
+    eventHandlers = [];
+    workDir;
+    constructor(source, target, options = {}) {
+        const id = this.generateId();
+        this.workDir = options.workDir ?? join(process.cwd(), '.savestate', 'migrations', id);
+        this.state = {
+            id,
+            phase: 'pending',
+            source,
+            target,
+            startedAt: new Date().toISOString(),
+            phaseStartedAt: new Date().toISOString(),
+            checkpoints: [],
+            progress: 0,
+            options,
+        };
+    }
+    // ─── Public API ────────────────────────────────────────────
+    /**
+     * Run the full migration pipeline.
+     */
+    async run() {
+        await this.ensureWorkDir();
+        try {
+            // Phase 1: Extract
+            await this.runExtractPhase();
+            // Phase 2: Transform
+            await this.runTransformPhase();
+            // Phase 3: Load
+            const result = await this.runLoadPhase();
+            this.state.phase = 'complete';
+            this.state.completedAt = new Date().toISOString();
+            await this.saveState();
+            this.emit({ type: 'complete', data: result });
+            return result;
+        }
+        catch (error) {
+            this.state.phase = 'failed';
+            this.state.error = error instanceof Error ? error.message : String(error);
+            await this.saveState();
+            this.emit({ type: 'error', error: error instanceof Error ? error : new Error(String(error)) });
+            throw error;
+        }
+    }
+    /**
+     * Run only the extract phase (useful for debugging/inspection).
+     */
+    async extract() {
+        await this.ensureWorkDir();
+        await this.runExtractPhase();
+        return this.bundle;
+    }
+    /**
+     * Generate compatibility report without running full migration.
+     */
+    async analyze() {
+        await this.ensureWorkDir();
+        // Extract first if we don't have a bundle
+        if (!this.bundle) {
+            await this.runExtractPhase();
+        }
+        const transformer = getTransformer(this.state.source, this.state.target);
+        if (!transformer) {
+            throw new Error(`No transformer available for ${this.state.source} → ${this.state.target}`);
+        }
+        return transformer.analyze(this.bundle);
+    }
+    /**
+     * Resume a failed or interrupted migration.
+     */
+    static async resume(migrationId, workDir) {
+        const baseDir = workDir ?? join(process.cwd(), '.savestate', 'migrations', migrationId);
+        const statePath = join(baseDir, 'state.json');
+        if (!existsSync(statePath)) {
+            throw new Error(`Migration ${migrationId} not found at ${baseDir}`);
+        }
+        const stateJson = await readFile(statePath, 'utf-8');
+        const state = JSON.parse(stateJson);
+        const orchestrator = new MigrationOrchestrator(state.source, state.target, state.options);
+        orchestrator.state = state;
+        orchestrator.workDir = baseDir;
+        // Load bundle if we have one
+        if (state.bundlePath && existsSync(state.bundlePath)) {
+            const bundleJson = await readFile(state.bundlePath, 'utf-8');
+            orchestrator.bundle = JSON.parse(bundleJson);
+        }
+        return orchestrator;
+    }
+    /**
+     * Resume and continue the migration from where it left off.
+     */
+    async continue() {
+        const lastCheckpoint = this.state.checkpoints[this.state.checkpoints.length - 1];
+        if (!lastCheckpoint) {
+            // No checkpoint, start from beginning
+            return this.run();
+        }
+        // Resume from the phase after the last checkpoint
+        switch (lastCheckpoint.phase) {
+            case 'extracting':
+                // Extract completed, continue with transform
+                await this.loadCheckpoint(lastCheckpoint);
+                await this.runTransformPhase();
+                return this.runLoadPhase();
+            case 'transforming':
+                // Transform completed, continue with load
+                await this.loadCheckpoint(lastCheckpoint);
+                return this.runLoadPhase();
+            case 'loading':
+                // Load was in progress, need to restart it
+                await this.loadCheckpoint(lastCheckpoint);
+                return this.runLoadPhase();
+            default:
+                return this.run();
+        }
+    }
+    /**
+     * Clean up migration artifacts.
+     */
+    async cleanup() {
+        if (existsSync(this.workDir)) {
+            await rm(this.workDir, { recursive: true, force: true });
+        }
+    }
+    /**
+     * Subscribe to migration events.
+     */
+    on(handler) {
+        this.eventHandlers.push(handler);
+        return () => {
+            const index = this.eventHandlers.indexOf(handler);
+            if (index >= 0)
+                this.eventHandlers.splice(index, 1);
+        };
+    }
+    /**
+     * Get current migration state.
+     */
+    getState() {
+        return { ...this.state };
+    }
+    /**
+     * Get the migration bundle (if extracted).
+     */
+    getBundle() {
+        return this.bundle;
+    }
+    // ─── Phase Runners ─────────────────────────────────────────
+    async runExtractPhase() {
+        this.setPhase('extracting');
+        this.emit({ type: 'phase:start', phase: 'extracting', message: 'Starting extraction...' });
+        const extractor = getExtractor(this.state.source);
+        if (!extractor) {
+            throw new Error(`No extractor available for ${this.state.source}`);
+        }
+        const canExtract = await extractor.canExtract();
+        if (!canExtract) {
+            throw new Error(`Cannot extract from ${this.state.source} - check authentication`);
+        }
+        this.bundle = await extractor.extract({
+            include: this.state.options.include,
+            workDir: this.workDir,
+            onProgress: (progress, message) => {
+                this.state.progress = progress * 0.33; // Extract is 0-33%
+                this.emit({ type: 'progress', progress: this.state.progress, message });
+            },
+        });
+        // Save bundle to disk
+        const bundlePath = join(this.workDir, 'bundle.json');
+        await writeFile(bundlePath, JSON.stringify(this.bundle, null, 2));
+        this.state.bundlePath = bundlePath;
+        await this.saveCheckpoint('extracting');
+        this.emit({ type: 'phase:complete', phase: 'extracting', message: 'Extraction complete' });
+    }
+    async runTransformPhase() {
+        if (!this.bundle) {
+            throw new Error('No bundle to transform - run extract phase first');
+        }
+        this.setPhase('transforming');
+        this.emit({ type: 'phase:start', phase: 'transforming', message: 'Starting transformation...' });
+        const transformer = getTransformer(this.state.source, this.state.target);
+        if (!transformer) {
+            throw new Error(`No transformer available for ${this.state.source} → ${this.state.target}`);
+        }
+        this.bundle = await transformer.transform(this.bundle, {
+            overflowStrategy: 'summarize',
+            onProgress: (progress, message) => {
+                this.state.progress = 33 + progress * 0.34; // Transform is 33-67%
+                this.emit({ type: 'progress', progress: this.state.progress, message });
+            },
+        });
+        // Update bundle on disk
+        const bundlePath = join(this.workDir, 'bundle.json');
+        await writeFile(bundlePath, JSON.stringify(this.bundle, null, 2));
+        await this.saveCheckpoint('transforming');
+        this.emit({ type: 'phase:complete', phase: 'transforming', message: 'Transformation complete' });
+    }
+    async runLoadPhase() {
+        if (!this.bundle) {
+            throw new Error('No bundle to load - run extract and transform phases first');
+        }
+        this.setPhase('loading');
+        this.emit({ type: 'phase:start', phase: 'loading', message: 'Starting load...' });
+        // Handle dry run
+        if (this.state.options.dryRun) {
+            const dryRunResult = {
+                success: true,
+                loaded: {
+                    instructions: !!this.bundle.contents.instructions,
+                    memories: this.bundle.contents.memories?.count ?? 0,
+                    files: this.bundle.contents.files?.count ?? 0,
+                    customBots: this.bundle.contents.customBots?.count ?? 0,
+                },
+                warnings: ['Dry run - no changes made'],
+                errors: [],
+            };
+            this.emit({ type: 'phase:complete', phase: 'loading', message: 'Dry run complete' });
+            return dryRunResult;
+        }
+        const loader = getLoader(this.state.target);
+        if (!loader) {
+            throw new Error(`No loader available for ${this.state.target}`);
+        }
+        const canLoad = await loader.canLoad();
+        if (!canLoad) {
+            throw new Error(`Cannot load to ${this.state.target} - check authentication`);
+        }
+        const result = await loader.load(this.bundle, {
+            dryRun: false,
+            projectName: `Migrated from ${this.state.source} (${new Date().toISOString().split('T')[0]})`,
+            onProgress: (progress, message) => {
+                this.state.progress = 67 + progress * 0.33; // Load is 67-100%
+                this.emit({ type: 'progress', progress: this.state.progress, message });
+            },
+        });
+        await this.saveCheckpoint('loading');
+        this.emit({ type: 'phase:complete', phase: 'loading', message: 'Load complete', data: result });
+        return result;
+    }
+    // ─── Helpers ───────────────────────────────────────────────
+    generateId() {
+        return `mig_${randomBytes(8).toString('hex')}`;
+    }
+    async ensureWorkDir() {
+        await mkdir(this.workDir, { recursive: true });
+    }
+    setPhase(phase) {
+        this.state.phase = phase;
+        this.state.phaseStartedAt = new Date().toISOString();
+    }
+    async saveState() {
+        const statePath = join(this.workDir, 'state.json');
+        await writeFile(statePath, JSON.stringify(this.state, null, 2));
+    }
+    async saveCheckpoint(phase) {
+        const checkpointId = `checkpoint_${phase}_${Date.now()}`;
+        const checkpointPath = join(this.workDir, `${checkpointId}.json`);
+        const checkpointData = {
+            phase,
+            bundle: this.bundle,
+            state: this.state,
+        };
+        const dataStr = JSON.stringify(checkpointData);
+        await writeFile(checkpointPath, dataStr);
+        const checksum = createHash('sha256').update(dataStr).digest('hex');
+        const checkpoint = {
+            phase,
+            timestamp: new Date().toISOString(),
+            dataPath: checkpointPath,
+            checksum,
+        };
+        this.state.checkpoints.push(checkpoint);
+        await this.saveState();
+        this.emit({ type: 'checkpoint', phase, message: `Checkpoint saved: ${checkpointId}` });
+    }
+    async loadCheckpoint(checkpoint) {
+        const dataStr = await readFile(checkpoint.dataPath, 'utf-8');
+        // Verify checksum
+        const actualChecksum = createHash('sha256').update(dataStr).digest('hex');
+        if (actualChecksum !== checkpoint.checksum) {
+            throw new Error(`Checkpoint corrupted: ${checkpoint.dataPath}`);
+        }
+        const data = JSON.parse(dataStr);
+        this.bundle = data.bundle;
+        // Don't overwrite current state - we want to keep progress info
+    }
+    emit(event) {
+        for (const handler of this.eventHandlers) {
+            try {
+                handler(event);
+            }
+            catch {
+                // Don't let handler errors break the migration
+            }
+        }
+    }
+}
+//# sourceMappingURL=orchestrator.js.map