newo 3.3.3 → 3.4.1

package/dist/cli/commands/push.js

@@ -1,37 +1,147 @@
 /**
  * Push command handler
+ *
+ * Supports selective resource sync with --only and --exclude flags:
+ *   newo push --only projects,attributes
+ *   newo push --exclude integrations
+ *   newo push --all  (explicit all resources)
+ *
+ * Available resources: projects, attributes, integrations, akb
+ * Note: conversations is read-only and cannot be pushed
  */
 import { makeClient } from '../../api.js';
 import { pushChanged } from '../../sync.js';
 import { getValidAccessToken } from '../../auth.js';
 import { selectSingleCustomer, interactiveCustomerSelection } from '../customer-selection.js';
+import { setupCli } from '../../cli-new/bootstrap.js';
+import { PUSHABLE_RESOURCE_TYPES } from '../../cli-new/di/tokens.js';
+/**
+ * Parse resource list from comma-separated string
+ */
+function parseResourceList(input) {
+    if (!input)
+        return [];
+    return input.split(',').map(r => r.trim().toLowerCase()).filter(Boolean);
+}
+/**
+ * Validate resource types for push
+ */
+function validateResources(resources) {
+    const validTypes = new Set(PUSHABLE_RESOURCE_TYPES);
+    const valid = [];
+    const invalid = [];
+    for (const r of resources) {
+        if (r === 'conversations') {
+            invalid.push(r + ' (read-only)');
+        }
+        else if (validTypes.has(r)) {
+            valid.push(r);
+        }
+        else {
+            invalid.push(r);
+        }
+    }
+    return { valid, invalid };
+}
+/**
+ * Push using V2 SyncEngine with selective sync
+ */
+async function pushWithV2Engine(customerConfig, customer, resources, verbose) {
+    const { syncEngine, logger } = setupCli(customerConfig, verbose);
+    if (resources === 'all') {
+        const result = await syncEngine.pushAll(customer);
+        logger.info(`✅ Pushed: ${result.totalCreated} created, ${result.totalUpdated} updated, ${result.totalDeleted} deleted`);
+        if (result.errors.length > 0) {
+            logger.warn(`⚠️  ${result.errors.length} error(s) occurred`);
+            result.errors.forEach(e => logger.error(`   ${e}`));
+        }
+    }
+    else {
+        const result = await syncEngine.pushSelected(customer, resources);
+        logger.info(`✅ Pushed: ${result.totalCreated} created, ${result.totalUpdated} updated, ${result.totalDeleted} deleted`);
+        if (result.errors.length > 0) {
+            logger.warn(`⚠️  ${result.errors.length} error(s) occurred`);
+            result.errors.forEach(e => logger.error(`   ${e}`));
+        }
+    }
+}
 export async function handlePushCommand(customerConfig, args, verbose) {
     const { selectedCustomer, allCustomers, isMultiCustomer } = selectSingleCustomer(customerConfig, args.customer);
     const shouldPublish = !args['no-publish'];
+    // Check for selective sync flags
+    const onlyResources = parseResourceList(args.only);
+    const excludeResources = parseResourceList(args.exclude);
+    const pushAllResources = Boolean(args.all);
+    // Validate resource types
+    if (onlyResources.length > 0) {
+        const { invalid } = validateResources(onlyResources);
+        if (invalid.length > 0) {
+            console.error(`❌ Cannot push resource(s): ${invalid.join(', ')}`);
+            console.error(`   Available for push: ${PUSHABLE_RESOURCE_TYPES.join(', ')}`);
+            process.exit(1);
+        }
+    }
+    if (excludeResources.length > 0) {
+        const { invalid } = validateResources(excludeResources);
+        if (invalid.length > 0 && !invalid.every(r => r.includes('read-only'))) {
+            console.error(`❌ Unknown resource type(s): ${invalid.join(', ')}`);
+            console.error(`   Available: ${PUSHABLE_RESOURCE_TYPES.join(', ')}`);
+            process.exit(1);
+        }
+    }
+    // Determine which resources to push
+    let resourcesToPush = 'all';
+    if (onlyResources.length > 0) {
+        resourcesToPush = onlyResources;
+        console.log(`📦 Pushing selected resources: ${onlyResources.join(', ')}`);
+    }
+    else if (excludeResources.length > 0) {
+        resourcesToPush = PUSHABLE_RESOURCE_TYPES.filter(r => !excludeResources.includes(r));
+        console.log(`📦 Pushing resources (excluding: ${excludeResources.join(', ')})`);
+    }
+    else if (pushAllResources) {
+        resourcesToPush = 'all';
+        console.log(`📦 Pushing ALL resources`);
+    }
+    // Use V2 engine if selective sync requested, otherwise use legacy for backward compatibility
+    const useV2Engine = onlyResources.length > 0 || excludeResources.length > 0 || pushAllResources;
     if (selectedCustomer) {
-        // Single customer push
-        const accessToken = await getValidAccessToken(selectedCustomer);
-        const client = await makeClient(verbose, accessToken);
-        await pushChanged(client, selectedCustomer, verbose, shouldPublish);
+        if (useV2Engine) {
+            await pushWithV2Engine(customerConfig, selectedCustomer, resourcesToPush, verbose);
+        }
+        else {
+            // Legacy behavior
+            const accessToken = await getValidAccessToken(selectedCustomer);
+            const client = await makeClient(verbose, accessToken);
+            await pushChanged(client, selectedCustomer, verbose, shouldPublish);
+        }
     }
     else if (isMultiCustomer) {
         // Multiple customers exist with no default, ask user
         const customersToProcess = await interactiveCustomerSelection(allCustomers);
         if (customersToProcess.length === 1) {
-            // Single customer selected
             const customer = customersToProcess[0];
-            const accessToken = await getValidAccessToken(customer);
-            const client = await makeClient(verbose, accessToken);
-            await pushChanged(client, customer, verbose, shouldPublish);
+            if (useV2Engine) {
+                await pushWithV2Engine(customerConfig, customer, resourcesToPush, verbose);
+            }
+            else {
+                const accessToken = await getValidAccessToken(customer);
+                const client = await makeClient(verbose, accessToken);
+                await pushChanged(client, customer, verbose, shouldPublish);
+            }
         }
         else {
-            // Multi-customer push (user selected "All customers")
             console.log(`🔄 Pushing to ${customersToProcess.length} customers...`);
             for (const customer of customersToProcess) {
                 console.log(`\n📤 Pushing for customer: ${customer.idn}`);
-                const accessToken = await getValidAccessToken(customer);
-                const client = await makeClient(verbose, accessToken);
-                await pushChanged(client, customer, verbose, shouldPublish);
+                if (useV2Engine) {
+                    await pushWithV2Engine(customerConfig, customer, resourcesToPush, verbose);
+                }
+                else {
+                    const accessToken = await getValidAccessToken(customer);
+                    const client = await makeClient(verbose, accessToken);
+                    await pushChanged(client, customer, verbose, shouldPublish);
+                }
             }
             console.log(`\n✅ Push completed for all ${customersToProcess.length} customers`);
         }

package/dist/cli/commands/watch.d.ts

@@ -0,0 +1,6 @@
+import type { MultiCustomerConfig, CliArgs } from '../../types.js';
+/**
+ * Main watch command handler
+ */
+export declare function handleWatchCommand(customerConfig: MultiCustomerConfig, args: CliArgs, verbose: boolean): Promise<void>;
+//# sourceMappingURL=watch.d.ts.map

package/dist/cli/commands/watch.js

@@ -0,0 +1,195 @@
+/**
+ * Watch command handler
+ *
+ * Watches for file changes and automatically pushes when changes are detected.
+ * Supports selective resource watching with --only and --exclude flags.
+ *
+ * Usage:
+ *   newo watch                     # Watch and push all changes
+ *   newo watch --only projects     # Watch only project files
+ *   newo watch --debounce 2000     # Custom debounce delay (ms)
+ */
+import { selectSingleCustomer } from '../customer-selection.js';
+import { setupCli } from '../../cli-new/bootstrap.js';
+import { PUSHABLE_RESOURCE_TYPES } from '../../cli-new/di/tokens.js';
+import chokidar from 'chokidar';
+import path from 'path';
+// Default debounce delay in milliseconds
+const DEFAULT_DEBOUNCE_MS = 1000;
+/**
+ * Parse resource list from comma-separated string
+ */
+function parseResourceList(input) {
+    if (!input)
+        return [];
+    return input.split(',').map(r => r.trim().toLowerCase()).filter(Boolean);
+}
+/**
+ * Get file patterns to watch based on resource types
+ */
+function getWatchPatterns(customerDir, resources) {
+    const patterns = [];
+    for (const resource of resources) {
+        switch (resource) {
+            case 'projects':
+                // Watch .guidance and .jinja files in projects
+                patterns.push(path.join(customerDir, 'projects', '**', '*.guidance'));
+                patterns.push(path.join(customerDir, 'projects', '**', '*.jinja'));
+                patterns.push(path.join(customerDir, 'projects', '**', 'metadata.yaml'));
+                break;
+            case 'attributes':
+                // Watch attributes.yaml files
+                patterns.push(path.join(customerDir, 'attributes.yaml'));
+                patterns.push(path.join(customerDir, 'projects', '*', 'attributes.yaml'));
+                break;
+            case 'integrations':
+                // Watch integration files
+                patterns.push(path.join(customerDir, 'integrations', '**', '*.yaml'));
+                break;
+            case 'akb':
+                // Watch AKB files
+                patterns.push(path.join(customerDir, 'akb', '**', '*.yaml'));
+                break;
+        }
+    }
+    return patterns;
+}
+/**
+ * Push with V2 engine for selective resources
+ */
+async function pushWithV2Engine(customerConfig, customer, resources, verbose) {
+    const { syncEngine, logger } = setupCli(customerConfig, verbose);
+    const result = await syncEngine.pushSelected(customer, resources);
+    if (result.totalCreated > 0 || result.totalUpdated > 0 || result.totalDeleted > 0) {
+        logger.info(`✅ Pushed: ${result.totalCreated} created, ${result.totalUpdated} updated, ${result.totalDeleted} deleted`);
+    }
+    if (result.errors.length > 0) {
+        logger.warn(`⚠️  ${result.errors.length} error(s) occurred`);
+        result.errors.forEach(e => logger.error(`   ${e}`));
+    }
+}
+/**
+ * Main watch command handler
+ */
+export async function handleWatchCommand(customerConfig, args, verbose) {
+    const { selectedCustomer } = selectSingleCustomer(customerConfig, args.customer);
+    if (!selectedCustomer) {
+        console.error('❌ Please specify a customer with --customer <idn> or set a default');
+        process.exit(1);
+    }
+    // Parse options
+    const onlyResources = parseResourceList(args.only);
+    const excludeResources = parseResourceList(args.exclude);
+    const debounceMs = typeof args.debounce === 'number'
+        ? args.debounce
+        : (typeof args.debounce === 'string' ? parseInt(args.debounce, 10) : DEFAULT_DEBOUNCE_MS);
+    // Determine resources to watch
+    let resourcesToWatch;
+    if (onlyResources.length > 0) {
+        resourcesToWatch = onlyResources.filter(r => PUSHABLE_RESOURCE_TYPES.includes(r));
+    }
+    else if (excludeResources.length > 0) {
+        resourcesToWatch = PUSHABLE_RESOURCE_TYPES.filter(r => !excludeResources.includes(r));
+    }
+    else {
+        resourcesToWatch = [...PUSHABLE_RESOURCE_TYPES];
+    }
+    if (resourcesToWatch.length === 0) {
+        console.error('❌ No valid resources to watch');
+        console.error(`   Available: ${PUSHABLE_RESOURCE_TYPES.join(', ')}`);
+        process.exit(1);
+    }
+    const customerDir = path.join(process.cwd(), 'newo_customers', selectedCustomer.idn);
+    const watchPatterns = getWatchPatterns(customerDir, resourcesToWatch);
+    console.log(`👀 Watching for changes in: ${resourcesToWatch.join(', ')}`);
+    console.log(`📁 Customer: ${selectedCustomer.idn}`);
+    console.log(`⏱️  Debounce: ${debounceMs}ms`);
+    console.log('');
+    console.log('Press Ctrl+C to stop watching.');
+    console.log('');
+    // Debounce state
+    let debounceTimer = null;
+    let pendingChanges = new Set();
+    let isPushing = false;
+    // Push function with debouncing
+    const debouncedPush = () => {
+        if (debounceTimer) {
+            clearTimeout(debounceTimer);
+        }
+        debounceTimer = setTimeout(async () => {
+            if (isPushing) {
+                // If already pushing, wait and try again
+                debouncedPush();
+                return;
+            }
+            if (pendingChanges.size === 0) {
+                return;
+            }
+            const changedFiles = Array.from(pendingChanges);
+            pendingChanges.clear();
+            isPushing = true;
+            console.log(`\n🔄 Changes detected in ${changedFiles.length} file(s):`);
+            changedFiles.slice(0, 5).forEach(f => console.log(`   ${path.relative(process.cwd(), f)}`));
+            if (changedFiles.length > 5) {
+                console.log(`   ... and ${changedFiles.length - 5} more`);
+            }
+            try {
+                // Use V2 engine for selective push
+                await pushWithV2Engine(customerConfig, selectedCustomer, resourcesToWatch, verbose);
+                console.log('✅ Push completed');
+            }
+            catch (error) {
+                console.error('❌ Push failed:', error instanceof Error ? error.message : String(error));
+            }
+            finally {
+                isPushing = false;
+            }
+        }, debounceMs);
+    };
+    // Set up file watcher
+    const watcher = chokidar.watch(watchPatterns, {
+        persistent: true,
+        ignoreInitial: true,
+        awaitWriteFinish: {
+            stabilityThreshold: 300,
+            pollInterval: 100
+        }
+    });
+    watcher
+        .on('change', (filePath) => {
+        pendingChanges.add(filePath);
+        if (verbose) {
+            console.log(`📝 Changed: ${path.relative(process.cwd(), filePath)}`);
+        }
+        debouncedPush();
+    })
+        .on('add', (filePath) => {
+        pendingChanges.add(filePath);
+        if (verbose) {
+            console.log(`➕ Added: ${path.relative(process.cwd(), filePath)}`);
+        }
+        debouncedPush();
+    })
+        .on('unlink', (filePath) => {
+        pendingChanges.add(filePath);
+        if (verbose) {
+            console.log(`➖ Removed: ${path.relative(process.cwd(), filePath)}`);
+        }
+        debouncedPush();
+    })
+        .on('error', (error) => {
+        console.error('❌ Watcher error:', error);
+    });
+    // Handle graceful shutdown
+    process.on('SIGINT', () => {
+        console.log('\n\n👋 Stopping watch...');
+        watcher.close();
+        if (debounceTimer) {
+            clearTimeout(debounceTimer);
+        }
+        process.exit(0);
+    });
+    // Keep the process running
+    await new Promise(() => { }); // Never resolves - keeps process alive
+}
+//# sourceMappingURL=watch.js.map

package/dist/cli-new/bootstrap.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Bootstrap - Application Initialization and DI Setup
+ *
+ * This file wires all dependencies together and creates the service container.
+ * It's the single entry point for configuring the application.
+ */
+import { ServiceContainer } from './di/Container.js';
+import { type ILogger, type CustomerConfig, type MultiCustomerConfig } from '../domain/resources/common/types.js';
+import { SyncEngine, type SyncEngineOptions } from '../application/sync/SyncEngine.js';
+import { MigrationEngine } from '../application/migration/MigrationEngine.js';
+import type { AxiosInstance } from 'axios';
+/**
+ * API Client Factory that creates authenticated clients
+ */
+export declare function createApiClient(customer: CustomerConfig, verbose: boolean): Promise<AxiosInstance>;
+/**
+ * Bootstrap options
+ */
+export interface BootstrapOptions {
+    /**
+     * Enable verbose logging
+     */
+    verbose?: boolean;
+    /**
+     * Sync engine options
+     */
+    syncEngineOptions?: SyncEngineOptions;
+}
+/**
+ * Create and configure the service container
+ */
+export declare function createServiceContainer(customerConfig: MultiCustomerConfig, options?: BootstrapOptions): ServiceContainer;
+/**
+ * Get SyncEngine from container
+ */
+export declare function getSyncEngine(container: ServiceContainer): SyncEngine;
+/**
+ * Get MigrationEngine from container
+ */
+export declare function getMigrationEngine(container: ServiceContainer): MigrationEngine;
+/**
+ * Get Logger from container
+ */
+export declare function getLogger(container: ServiceContainer): ILogger;
+/**
+ * Quick setup for CLI commands
+ *
+ * Creates a configured container with all services ready to use.
+ */
+export declare function setupCli(customerConfig: MultiCustomerConfig, verbose?: boolean): {
+    container: ServiceContainer;
+    syncEngine: SyncEngine;
+    migrationEngine: MigrationEngine;
+    logger: ILogger;
+};
+/**
+ * Adapter function for legacy pull command
+ *
+ * This provides backward compatibility with the existing CLI.
+ */
+export declare function legacyPullAdapter(customerConfig: MultiCustomerConfig, customer: CustomerConfig, verbose: boolean, silentOverwrite: boolean): Promise<void>;
+/**
+ * Adapter function for legacy push command
+ */
+export declare function legacyPushAdapter(customerConfig: MultiCustomerConfig, customer: CustomerConfig, verbose: boolean): Promise<void>;
+/**
+ * Adapter function for legacy status command
+ */
+export declare function legacyStatusAdapter(customerConfig: MultiCustomerConfig, customer: CustomerConfig, verbose: boolean): Promise<void>;
+/**
+ * Adapter function for legacy migrate command
+ */
+export declare function legacyMigrateAdapter(customerConfig: MultiCustomerConfig, sourceCustomer: CustomerConfig, destCustomer: CustomerConfig, sourceClient: AxiosInstance, destClient: AxiosInstance, verbose: boolean): Promise<void>;
+//# sourceMappingURL=bootstrap.d.ts.map

package/dist/cli-new/bootstrap.js

@@ -0,0 +1,154 @@
+/**
+ * Bootstrap - Application Initialization and DI Setup
+ *
+ * This file wires all dependencies together and creates the service container.
+ * It's the single entry point for configuring the application.
+ */
+import { ServiceContainer } from './di/Container.js';
+import { TOKENS } from './di/tokens.js';
+import { ConsoleLogger } from '../domain/resources/common/types.js';
+import { SyncEngine } from '../application/sync/SyncEngine.js';
+import { MigrationEngine, TransformService } from '../application/migration/MigrationEngine.js';
+import { ProjectSyncStrategy, createProjectSyncStrategy } from '../domain/strategies/sync/ProjectSyncStrategy.js';
+import { AttributeSyncStrategy, createAttributeSyncStrategy } from '../domain/strategies/sync/AttributeSyncStrategy.js';
+import { IntegrationSyncStrategy, createIntegrationSyncStrategy } from '../domain/strategies/sync/IntegrationSyncStrategy.js';
+import { AkbSyncStrategy, createAkbSyncStrategy } from '../domain/strategies/sync/AkbSyncStrategy.js';
+import { ConversationSyncStrategy, createConversationSyncStrategy } from '../domain/strategies/sync/ConversationSyncStrategy.js';
+import { makeClient } from '../api.js';
+import { getValidAccessToken } from '../auth.js';
+/**
+ * API Client Factory that creates authenticated clients
+ */
+export async function createApiClient(customer, verbose) {
+    // Set environment variables for the customer
+    process.env.NEWO_API_KEY = customer.apiKey;
+    if (customer.projectId) {
+        process.env.NEWO_PROJECT_ID = customer.projectId;
+    }
+    const token = await getValidAccessToken();
+    return makeClient(verbose, token);
+}
+/**
+ * Create and configure the service container
+ */
+export function createServiceContainer(customerConfig, options = {}) {
+    const container = new ServiceContainer();
+    const verbose = options.verbose ?? false;
+    // === Infrastructure Layer ===
+    // Logger
+    const logger = new ConsoleLogger(verbose);
+    container.registerValue(TOKENS.LOGGER, logger);
+    // Customer Config
+    container.registerValue(TOKENS.CUSTOMER_CONFIG, customerConfig);
+    // API Client Factory
+    container.registerValue(TOKENS.API_CLIENT_FACTORY, createApiClient);
+    // === Domain Layer - Sync Strategies ===
+    // Project Sync Strategy
+    container.registerSingleton(TOKENS.PROJECT_SYNC_STRATEGY, () => createProjectSyncStrategy(createApiClient, container.get(TOKENS.LOGGER)));
+    // Attribute Sync Strategy
+    container.registerSingleton(TOKENS.ATTRIBUTE_SYNC_STRATEGY, () => createAttributeSyncStrategy(createApiClient, container.get(TOKENS.LOGGER)));
+    // Integration Sync Strategy
+    container.registerSingleton(TOKENS.INTEGRATION_SYNC_STRATEGY, () => createIntegrationSyncStrategy(createApiClient, container.get(TOKENS.LOGGER)));
+    // AKB Sync Strategy
+    container.registerSingleton(TOKENS.AKB_SYNC_STRATEGY, () => createAkbSyncStrategy(createApiClient, container.get(TOKENS.LOGGER)));
+    // Conversation Sync Strategy
+    container.registerSingleton(TOKENS.CONVERSATION_SYNC_STRATEGY, () => createConversationSyncStrategy(createApiClient, container.get(TOKENS.LOGGER)));
+    // === Application Layer ===
+    // Sync Engine (uses all sync strategies)
+    container.registerSingleton(TOKENS.SYNC_ENGINE, () => {
+        const strategies = [
+            container.get(TOKENS.PROJECT_SYNC_STRATEGY),
+            container.get(TOKENS.ATTRIBUTE_SYNC_STRATEGY),
+            container.get(TOKENS.INTEGRATION_SYNC_STRATEGY),
+            container.get(TOKENS.AKB_SYNC_STRATEGY),
+            container.get(TOKENS.CONVERSATION_SYNC_STRATEGY),
+        ];
+        return new SyncEngine(strategies, container.get(TOKENS.LOGGER), options.syncEngineOptions);
+    });
+    // Migration Engine (uses SyncEngine)
+    container.registerSingleton(TOKENS.MIGRATION_ENGINE, () => {
+        const syncEngine = container.get(TOKENS.SYNC_ENGINE);
+        const transformService = new TransformService(container.get(TOKENS.LOGGER));
+        return new MigrationEngine(syncEngine, transformService, container.get(TOKENS.LOGGER));
+    });
+    return container;
+}
+/**
+ * Get SyncEngine from container
+ */
+export function getSyncEngine(container) {
+    return container.get(TOKENS.SYNC_ENGINE);
+}
+/**
+ * Get MigrationEngine from container
+ */
+export function getMigrationEngine(container) {
+    return container.get(TOKENS.MIGRATION_ENGINE);
+}
+/**
+ * Get Logger from container
+ */
+export function getLogger(container) {
+    return container.get(TOKENS.LOGGER);
+}
+/**
+ * Quick setup for CLI commands
+ *
+ * Creates a configured container with all services ready to use.
+ */
+export function setupCli(customerConfig, verbose = false) {
+    const container = createServiceContainer(customerConfig, { verbose });
+    return {
+        container,
+        syncEngine: getSyncEngine(container),
+        migrationEngine: getMigrationEngine(container),
+        logger: getLogger(container)
+    };
+}
+/**
+ * Adapter function for legacy pull command
+ *
+ * This provides backward compatibility with the existing CLI.
+ */
+export async function legacyPullAdapter(customerConfig, customer, verbose, silentOverwrite) {
+    const { syncEngine } = setupCli(customerConfig, verbose);
+    await syncEngine.pullAll(customer, {
+        silentOverwrite,
+        verbose
+    });
+}
+/**
+ * Adapter function for legacy push command
+ */
+export async function legacyPushAdapter(customerConfig, customer, verbose) {
+    const { syncEngine } = setupCli(customerConfig, verbose);
+    await syncEngine.pushAll(customer);
+}
+/**
+ * Adapter function for legacy status command
+ */
+export async function legacyStatusAdapter(customerConfig, customer, verbose) {
+    const { syncEngine, logger } = setupCli(customerConfig, verbose);
+    const status = await syncEngine.getStatus(customer);
+    logger.info(`\nStatus for customer: ${status.customer}`);
+    logger.info(`Total changes: ${status.totalChanges}\n`);
+    for (const resource of status.resources) {
+        if (resource.changedCount > 0) {
+            logger.info(`${resource.displayName}: ${resource.changedCount} change(s)`);
+            for (const change of resource.changes) {
+                logger.info(`  ${change.operation.toUpperCase()[0]} ${change.path}`);
+            }
+        }
+    }
+    if (status.totalChanges === 0) {
+        logger.info('No changes to push.');
+    }
+}
+/**
+ * Adapter function for legacy migrate command
+ */
+export async function legacyMigrateAdapter(customerConfig, sourceCustomer, destCustomer, sourceClient, destClient, verbose) {
+    const { migrationEngine } = setupCli(customerConfig, verbose);
+    await migrationEngine.migrateAccount(sourceCustomer, destCustomer, sourceClient, destClient, { verbose });
+}
+//# sourceMappingURL=bootstrap.js.map

package/dist/cli-new/di/Container.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Dependency Injection Container
+ *
+ * A simple, TypeScript-native DI container that:
+ * - Supports singleton and factory registrations
+ * - Provides type-safe dependency resolution
+ * - Enables easy testing through dependency injection
+ */
+/**
+ * Factory function type for creating service instances
+ */
+type Factory<T> = (container: ServiceContainer) => T;
+/**
+ * Service Container for Dependency Injection
+ */
+export declare class ServiceContainer {
+    private registrations;
+    /**
+     * Register a factory that creates a new instance each time
+     */
+    register<T>(token: symbol, factory: Factory<T>): void;
+    /**
+     * Register a singleton - only created once
+     */
+    registerSingleton<T>(token: symbol, instanceOrFactory: T | Factory<T>): void;
+    /**
+     * Register a value directly
+     */
+    registerValue<T>(token: symbol, value: T): void;
+    /**
+     * Resolve a service by its token
+     */
+    get<T>(token: symbol): T;
+    /**
+     * Check if a token is registered
+     */
+    has(token: symbol): boolean;
+    /**
+     * Get all registered tokens
+     */
+    getTokens(): symbol[];
+    /**
+     * Clear all registrations (useful for testing)
+     */
+    clear(): void;
+    /**
+     * Create a child container that inherits parent registrations
+     */
+    createChild(): ServiceContainer;
+}
+/**
+ * Get the global container instance
+ */
+export declare function getContainer(): ServiceContainer;
+/**
+ * Set the global container instance (useful for testing)
+ */
+export declare function setContainer(container: ServiceContainer): void;
+/**
+ * Reset the global container (useful for testing)
+ */
+export declare function resetContainer(): void;
+export {};
+//# sourceMappingURL=Container.d.ts.map