@waymakeros/cli 2.0.0

package/dist/cli/cli.js

@@ -0,0 +1,703 @@
+#!/usr/bin/env node
+/**
+ * Waymaker Sync CLI
+ * Command-line interface for Waymaker Sync engine
+ */
+import { SyncDaemon } from './daemon.js';
+import { ConfigManager } from '../sync/config-manager.js';
+import { SyncEngine } from '../sync/sync-engine.js';
+const COMMANDS = {
+    START: 'start',
+    STOP: 'stop',
+    STATUS: 'status',
+    INIT: 'init',
+    LAYER: 'layer',
+    KANBAN: 'kanban',
+    SYNC_ALL: 'sync-all',
+};
+async function main() {
+    const args = process.argv.slice(2);
+    // Default to current directory
+    const projectPath = process.cwd();
+    if (args.length === 0) {
+        printHelp();
+        process.exit(0);
+    }
+    const command = args[0];
+    try {
+        switch (command) {
+            case COMMANDS.START:
+                await startCommand(projectPath);
+                break;
+            case COMMANDS.STOP:
+                await stopCommand(projectPath);
+                break;
+            case COMMANDS.STATUS:
+                await statusCommand(projectPath);
+                break;
+            case COMMANDS.INIT:
+                await initCommand(projectPath, args.slice(1));
+                break;
+            case COMMANDS.LAYER:
+                await layerCommand(projectPath, args.slice(1));
+                break;
+            case COMMANDS.KANBAN:
+                await kanbanCommand(projectPath, args.slice(1));
+                break;
+            case COMMANDS.SYNC_ALL:
+                await syncAllCommand(projectPath, args.slice(1));
+                break;
+            default:
+                console.error(`Unknown command: ${command}`);
+                printHelp();
+                process.exit(1);
+        }
+    }
+    catch (error) {
+        console.error('Error:', error instanceof Error ? error.message : String(error));
+        process.exit(1);
+    }
+}
+/**
+ * Start sync daemon
+ */
+async function startCommand(projectPath) {
+    console.log('Starting Waymaker Sync daemon...');
+    const daemon = new SyncDaemon(projectPath);
+    if (daemon.isRunning()) {
+        console.log('❌ Sync daemon is already running');
+        console.log(`PID: ${daemon.getPid()}`);
+        process.exit(1);
+    }
+    await daemon.start();
+}
+/**
+ * Stop sync daemon
+ */
+async function stopCommand(projectPath) {
+    console.log('Stopping Waymaker Sync daemon...');
+    const daemon = new SyncDaemon(projectPath);
+    if (!daemon.isRunning()) {
+        console.log('Sync daemon is not running');
+        process.exit(0);
+    }
+    const pid = daemon.getPid();
+    if (pid) {
+        // Send SIGTERM to graceful shutdown
+        process.kill(pid, 'SIGTERM');
+        console.log(`✅ Sent stop signal to daemon (PID: ${pid})`);
+    }
+}
+/**
+ * Show sync daemon status
+ */
+async function statusCommand(projectPath) {
+    const daemon = new SyncDaemon(projectPath);
+    const status = daemon.getStatus();
+    console.log('\n📊 Waymaker Sync Status\n');
+    console.log(`Running: ${status.running ? '✅ Yes' : '❌ No'}`);
+    if (status.running && status.pid) {
+        console.log(`PID: ${status.pid}`);
+    }
+    if (status.status) {
+        const s = status.status;
+        console.log(`\nSync Statistics:`);
+        console.log(`  Started: ${s.startedAt?.toLocaleString() || 'N/A'}`);
+        console.log(`  Files Watched: ${s.filesWatched}`);
+        console.log(`  Last Sync: ${s.lastSyncAt?.toLocaleString() || 'Never'}`);
+        console.log(`  Total Syncs: ${s.syncCount}`);
+        console.log(`  Errors: ${s.errorCount}`);
+        if (s.recentErrors.length > 0) {
+            console.log(`\nRecent Errors:`);
+            s.recentErrors.forEach((err, i) => {
+                console.log(`  ${i + 1}. [${err.timestamp.toLocaleTimeString()}] ${err.filePath}`);
+                console.log(`     ${err.error}`);
+            });
+        }
+    }
+    console.log();
+}
+/**
+ * Initialize Waymaker Sync configuration
+ */
+async function initCommand(projectPath, args) {
+    console.log('Initializing Waymaker Sync configuration...\n');
+    const configManager = new ConfigManager(projectPath);
+    // Check if config already exists
+    if (configManager.exists()) {
+        console.log('❌ Configuration already exists at:');
+        console.log(`   ${configManager.getConfigPath()}`);
+        console.log('\nUse --force to overwrite existing configuration');
+        process.exit(1);
+    }
+    // Parse command line arguments
+    const options = parseInitOptions(args);
+    if (!options.workspace_id || !options.project_id || !options.organization_id) {
+        console.error('Missing required options. Usage:');
+        console.error('  waymaker sync init \\');
+        console.error('    --workspace-id <uuid> \\');
+        console.error('    --project-id <uuid> \\');
+        console.error('    --organization-id <clerk-org-id> \\');
+        console.error('    [--taskboard-id <uuid>]');
+        process.exit(1);
+    }
+    // Create configuration
+    const config = await configManager.createInitialConfig({
+        workspace_id: options.workspace_id,
+        project_id: options.project_id,
+        organization_id: options.organization_id,
+        taskboard_id: options.taskboard_id,
+    });
+    console.log('✅ Configuration created successfully!\n');
+    console.log(`Config file: ${configManager.getConfigPath()}\n`);
+    console.log('Configuration:');
+    console.log(`  Workspace ID: ${config.workspace_id}`);
+    console.log(`  Project ID: ${config.project_id}`);
+    console.log(`  Organization ID: ${config.organization_id}`);
+    console.log(`  Taskboard ID: ${config.sync.taskboard_id || '(not set)'}`);
+    console.log(`  Sync Mode: ${config.sync.mode}`);
+    console.log(`  Watch Patterns: ${config.sync.watch_patterns.length}`);
+    console.log('\nNext steps:');
+    console.log('  1. Set WAYMAKER_API_KEY environment variable');
+    console.log('  2. Run: waymaker sync start');
+}
+/**
+ * Parse init command options
+ */
+function parseInitOptions(args) {
+    const options = {};
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        const value = args[i + 1];
+        switch (arg) {
+            case '--workspace-id':
+                options.workspace_id = value;
+                i++;
+                break;
+            case '--project-id':
+                options.project_id = value;
+                i++;
+                break;
+            case '--organization-id':
+                options.organization_id = value;
+                i++;
+                break;
+            case '--taskboard-id':
+                options.taskboard_id = value;
+                i++;
+                break;
+        }
+    }
+    return options;
+}
+/**
+ * Layer management commands
+ */
+async function layerCommand(projectPath, args) {
+    if (args.length === 0) {
+        printLayerHelp();
+        process.exit(0);
+    }
+    const subCommand = args[0];
+    const subArgs = args.slice(1);
+    // Get config for taskboard ID
+    const configManager = new ConfigManager(projectPath);
+    if (!configManager.exists()) {
+        console.error('❌ No Waymaker Sync configuration found.');
+        console.error('Run `waymaker sync init` first to configure sync.');
+        process.exit(1);
+    }
+    const config = configManager.getConfig();
+    const taskboardId = parseOption(subArgs, '--taskboard') || config.sync.taskboard_id;
+    if (!taskboardId) {
+        console.error('❌ No taskboard ID specified.');
+        console.error('Either set taskboard_id in .commander/config.json or use --taskboard <id>');
+        process.exit(1);
+    }
+    const apiKey = process.env.WAYMAKER_API_KEY;
+    if (!apiKey) {
+        console.error('❌ WAYMAKER_API_KEY environment variable not set.');
+        process.exit(1);
+    }
+    const appsUrl = process.env.WAYMAKER_APPS_URL || 'https://apps.waymakerone.com';
+    switch (subCommand) {
+        case 'list':
+            await layerListCommand(appsUrl, apiKey, taskboardId);
+            break;
+        case 'create':
+            await layerCreateCommand(appsUrl, apiKey, taskboardId, subArgs);
+            break;
+        case 'delete':
+            await layerDeleteCommand(appsUrl, apiKey, taskboardId, subArgs);
+            break;
+        default:
+            console.error(`Unknown layer command: ${subCommand}`);
+            printLayerHelp();
+            process.exit(1);
+    }
+}
+/**
+ * List layers on a taskboard
+ */
+async function layerListCommand(appsUrl, apiKey, taskboardId) {
+    console.log('\n📊 Layers on taskboard\n');
+    const response = await fetch(`${appsUrl}/functions/v1/commander-layer-operations`, {
+        method: 'POST',
+        headers: {
+            'Authorization': `Bearer ${apiKey}`,
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({
+            action: 'list-layers',
+            taskboardId,
+        }),
+    });
+    if (!response.ok) {
+        console.error('❌ Failed to list layers:', response.status, await response.text());
+        process.exit(1);
+    }
+    const result = await response.json();
+    if (!result.success) {
+        console.error('❌ Error:', result.error);
+        process.exit(1);
+    }
+    const layers = result.data?.layers || [];
+    if (layers.length === 0) {
+        console.log('No layers found on this taskboard.\n');
+        console.log('Create one with: waymaker sync layer create "My Layer"');
+        return;
+    }
+    // Print hierarchy
+    const printLayer = (layer, indent = 0) => {
+        const prefix = '  '.repeat(indent) + (indent > 0 ? '└── ' : '');
+        console.log(`${prefix}${layer.name}`);
+        console.log(`${' '.repeat(indent * 2 + (indent > 0 ? 4 : 0))}ID: ${layer.id}`);
+        if (layer.path && layer.path !== layer.name) {
+            console.log(`${' '.repeat(indent * 2 + (indent > 0 ? 4 : 0))}Path: ${layer.path}`);
+        }
+        console.log();
+    };
+    // Build hierarchy and print
+    const hierarchy = result.data?.hierarchy || [];
+    const printHierarchy = (nodes, indent = 0) => {
+        for (const node of nodes) {
+            printLayer(node, indent);
+            if (node.children?.length > 0) {
+                printHierarchy(node.children, indent + 1);
+            }
+        }
+    };
+    printHierarchy(hierarchy);
+    console.log(`Total: ${layers.length} layer(s)\n`);
+}
+/**
+ * Create a new layer
+ */
+async function layerCreateCommand(appsUrl, apiKey, taskboardId, args) {
+    // First positional arg is the layer name
+    const name = args.find(a => !a.startsWith('--'));
+    const parentLayer = parseOption(args, '--parent');
+    if (!name) {
+        console.error('❌ Layer name required.');
+        console.error('Usage: waymaker sync layer create "Sprint 1" --parent "Taskboards"');
+        process.exit(1);
+    }
+    console.log(`\n📦 Creating layer: ${name}`);
+    if (parentLayer) {
+        console.log(`   Parent: ${parentLayer}`);
+    }
+    // If parent specified, resolve it first
+    let parentLayerId = null;
+    if (parentLayer) {
+        const findResponse = await fetch(`${appsUrl}/functions/v1/commander-layer-operations`, {
+            method: 'POST',
+            headers: {
+                'Authorization': `Bearer ${apiKey}`,
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({
+                action: 'find-layer-by-path',
+                taskboardId,
+                layerPath: parentLayer,
+            }),
+        });
+        if (!findResponse.ok) {
+            console.error('❌ Failed to find parent layer:', await findResponse.text());
+            process.exit(1);
+        }
+        const findResult = await findResponse.json();
+        if (!findResult.success || !findResult.data?.layer) {
+            console.error(`❌ Parent layer not found: ${parentLayer}`);
+            process.exit(1);
+        }
+        parentLayerId = findResult.data.layer.id;
+    }
+    // Create the layer
+    const response = await fetch(`${appsUrl}/functions/v1/commander-layer-operations`, {
+        method: 'POST',
+        headers: {
+            'Authorization': `Bearer ${apiKey}`,
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({
+            action: 'create-layer',
+            taskboardId,
+            name,
+            parentLayerId,
+            description: parseOption(args, '--description'),
+            startDate: parseOption(args, '--start-date'),
+            endDate: parseOption(args, '--end-date'),
+        }),
+    });
+    if (!response.ok) {
+        console.error('❌ Failed to create layer:', response.status, await response.text());
+        process.exit(1);
+    }
+    const result = await response.json();
+    if (!result.success) {
+        console.error('❌ Error:', result.error);
+        process.exit(1);
+    }
+    const layer = result.data?.layer;
+    const layerPath = parentLayer ? `${parentLayer}/${name}` : name;
+    console.log(`\n✅ Layer created successfully!`);
+    console.log(`   Name: ${layer.name}`);
+    console.log(`   ID: ${layer.id}`);
+    console.log(`   Path: ${layerPath}`);
+    console.log();
+}
+/**
+ * Delete a layer
+ */
+async function layerDeleteCommand(appsUrl, apiKey, taskboardId, args) {
+    // First positional arg is the layer path
+    const layerPath = args.find(a => !a.startsWith('--'));
+    if (!layerPath) {
+        console.error('❌ Layer path required.');
+        console.error('Usage: waymaker sync layer delete "Taskboards/Sprint 1"');
+        process.exit(1);
+    }
+    console.log(`\n🗑️  Deleting layer: ${layerPath}`);
+    // Find the layer first
+    const findResponse = await fetch(`${appsUrl}/functions/v1/commander-layer-operations`, {
+        method: 'POST',
+        headers: {
+            'Authorization': `Bearer ${apiKey}`,
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({
+            action: 'find-layer-by-path',
+            taskboardId,
+            layerPath,
+        }),
+    });
+    if (!findResponse.ok) {
+        console.error('❌ Failed to find layer:', await findResponse.text());
+        process.exit(1);
+    }
+    const findResult = await findResponse.json();
+    if (!findResult.success || !findResult.data?.layer) {
+        console.error(`❌ Layer not found: ${layerPath}`);
+        process.exit(1);
+    }
+    const layerId = findResult.data.layer.id;
+    // Delete the layer
+    const response = await fetch(`${appsUrl}/functions/v1/commander-layer-operations`, {
+        method: 'POST',
+        headers: {
+            'Authorization': `Bearer ${apiKey}`,
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({
+            action: 'delete-layer',
+            layerId,
+        }),
+    });
+    if (!response.ok) {
+        console.error('❌ Failed to delete layer:', response.status, await response.text());
+        process.exit(1);
+    }
+    const result = await response.json();
+    if (!result.success) {
+        console.error('❌ Error:', result.error);
+        process.exit(1);
+    }
+    console.log(`✅ Layer deleted: ${layerPath}\n`);
+}
+/**
+ * Parse a command line option value
+ */
+function parseOption(args, optionName) {
+    const index = args.indexOf(optionName);
+    if (index >= 0 && index < args.length - 1) {
+        return args[index + 1];
+    }
+    return undefined;
+}
+/**
+ * Display kanban board in terminal
+ */
+async function kanbanCommand(projectPath, args) {
+    // Get config for taskboard ID
+    const configManager = new ConfigManager(projectPath);
+    if (!configManager.exists()) {
+        console.error('❌ No Waymaker Sync configuration found.');
+        console.error('Run `waymaker sync init` first to configure sync.');
+        process.exit(1);
+    }
+    const config = configManager.getConfig();
+    const taskboardId = parseOption(args, '--taskboard') || config.sync.taskboard_id;
+    if (!taskboardId) {
+        console.error('❌ No taskboard ID specified.');
+        console.error('Either set taskboard_id in .commander/config.json or use --taskboard <id>');
+        process.exit(1);
+    }
+    const apiKey = process.env.WAYMAKER_API_KEY;
+    if (!apiKey) {
+        console.error('❌ WAYMAKER_API_KEY environment variable not set.');
+        process.exit(1);
+    }
+    const appsUrl = process.env.WAYMAKER_APPS_URL || 'https://apps.waymakerone.com';
+    const layerFilter = parseOption(args, '--layer');
+    const maxTasks = parseInt(parseOption(args, '--max') || '10', 10);
+    // const compact = args.includes('--compact'); // Reserved for future use
+    console.log('\n📋 Fetching Kanban board...\n');
+    // Fetch tasks from taskboard
+    const response = await fetch(`${appsUrl}/functions/v1/commander-taskboard-tasks`, {
+        method: 'POST',
+        headers: {
+            'Authorization': `Bearer ${apiKey}`,
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({
+            taskboard_id: taskboardId,
+        }),
+    });
+    if (!response.ok) {
+        console.error('❌ Failed to fetch taskboard:', response.status, await response.text());
+        process.exit(1);
+    }
+    const result = await response.json();
+    if (!result.success) {
+        console.error('❌ Error:', result.error);
+        process.exit(1);
+    }
+    const { board, status_sections, tasks, layers } = result.data;
+    // Filter tasks by layer if specified
+    let filteredTasks = tasks;
+    let layerName = null;
+    if (layerFilter) {
+        const layer = layers.find((l) => l.id === layerFilter || l.name.toLowerCase() === layerFilter.toLowerCase());
+        if (layer) {
+            filteredTasks = filteredTasks.filter((t) => t.layer_id === layer.id);
+            layerName = layer.name;
+        }
+    }
+    // Group tasks by status section
+    const tasksBySection = new Map();
+    for (const section of status_sections) {
+        tasksBySection.set(section.id, []);
+    }
+    for (const task of filteredTasks) {
+        const sectionTasks = tasksBySection.get(task.status_section_id);
+        if (sectionTasks) {
+            sectionTasks.push(task);
+        }
+    }
+    // Sort sections by position
+    const sortedSections = [...status_sections].sort((a, b) => a.position - b.position);
+    // Print board
+    console.log(`📋 ${board.name}${layerName ? ` (${layerName})` : ''}`);
+    console.log('─'.repeat(60));
+    for (const section of sortedSections) {
+        const sectionTasks = tasksBySection.get(section.id) || [];
+        const icon = section.is_completed ? '✅' : '📌';
+        console.log(`\n${icon} ${section.name} (${sectionTasks.length})`);
+        const displayTasks = sectionTasks.slice(0, maxTasks);
+        for (const task of displayTasks) {
+            const priority = getPriorityIcon(task.priority);
+            const checkbox = task.is_completed ? '☑' : '☐';
+            console.log(`   ${checkbox} ${priority} ${task.name}`);
+        }
+        if (sectionTasks.length > maxTasks) {
+            console.log(`   ... +${sectionTasks.length - maxTasks} more`);
+        }
+    }
+    // Summary
+    const totalTasks = filteredTasks.length;
+    const completedTasks = sortedSections
+        .filter((s) => s.is_completed)
+        .reduce((sum, s) => sum + (tasksBySection.get(s.id)?.length || 0), 0);
+    console.log('\n─'.repeat(60));
+    console.log(`Total: ${totalTasks} tasks | Completed: ${completedTasks} | Open: ${totalTasks - completedTasks}`);
+    console.log();
+}
+/**
+ * Get priority icon for CLI display
+ */
+function getPriorityIcon(priority) {
+    switch (priority) {
+        case 1: return '🔴';
+        case 2: return '🟠';
+        case 3: return '🟡';
+        case 4: return '🟢';
+        default: return '⚪';
+    }
+}
+/**
+ * Sync all existing files command
+ */
+async function syncAllCommand(projectPath, args) {
+    console.log('\n🔄 Waymaker Sync - Initial File Scan\n');
+    // Check for config
+    const configManager = new ConfigManager(projectPath);
+    if (!configManager.exists()) {
+        console.error('❌ No Waymaker Sync configuration found.');
+        console.error('Run `waymaker sync init` first to configure sync.');
+        process.exit(1);
+    }
+    const apiKey = process.env.WAYMAKER_API_KEY;
+    if (!apiKey) {
+        console.error('❌ WAYMAKER_API_KEY environment variable not set.');
+        process.exit(1);
+    }
+    const dryRun = args.includes('--dry-run');
+    const force = args.includes('--force');
+    const batchSize = parseInt(parseOption(args, '--batch-size') || '50', 10);
+    const concurrency = parseInt(parseOption(args, '--concurrency') || '5', 10);
+    console.log('Options:');
+    console.log(`  Batch Size: ${batchSize}`);
+    console.log(`  Concurrency: ${concurrency}`);
+    console.log(`  Dry Run: ${dryRun ? 'Yes' : 'No'}`);
+    console.log(`  Force: ${force ? 'Yes' : 'No'}`);
+    console.log();
+    // Create and initialize sync engine
+    const engine = new SyncEngine(projectPath);
+    await engine.initialize();
+    // Set up progress listener
+    engine.on('sync-progress', (progress) => {
+        const percent = Math.round((progress.processed / progress.total) * 100);
+        process.stdout.write(`\r  Progress: ${progress.processed}/${progress.total} (${percent}%) - Synced: ${progress.synced}, Skipped: ${progress.skipped}, Failed: ${progress.failed}`);
+    });
+    console.log('Starting scan...\n');
+    const result = await engine.syncAll({
+        batchSize,
+        concurrency,
+        dryRun,
+        force,
+    });
+    console.log('\n\n✅ Initial scan complete!\n');
+    console.log('Results:');
+    console.log(`  Total Files: ${result.totalFiles}`);
+    console.log(`  Synced: ${result.synced}`);
+    console.log(`  Skipped: ${result.skipped}`);
+    console.log(`  Failed: ${result.failed}`);
+    console.log(`  Duration: ${(result.duration / 1000).toFixed(2)}s`);
+    if (result.errors.length > 0) {
+        console.log('\nErrors:');
+        for (const error of result.errors.slice(0, 10)) {
+            console.log(`  ❌ ${error.filePath}`);
+            console.log(`     ${error.error}`);
+        }
+        if (result.errors.length > 10) {
+            console.log(`  ... and ${result.errors.length - 10} more errors`);
+        }
+    }
+    console.log();
+}
+/**
+ * Print layer command help
+ */
+function printLayerHelp() {
+    console.log(`
+Waymaker Sync - Layer Management
+
+Usage:
+  waymaker sync layer <command> [options]
+
+Commands:
+  list      List all layers on the taskboard
+  create    Create a new layer
+  delete    Delete a layer
+
+Examples:
+  # List all layers
+  waymaker sync layer list
+
+  # Create a top-level layer
+  waymaker sync layer create "Taskboards"
+
+  # Create a child layer (sprint under product)
+  waymaker sync layer create "Sprint 1" --parent "Taskboards"
+
+  # Create with dates
+  waymaker sync layer create "Sprint 2" --parent "Taskboards" \\
+    --start-date 2026-02-01 --end-date 2026-02-14
+
+  # Delete a layer by path
+  waymaker sync layer delete "Taskboards/Sprint 1"
+
+Options:
+  --taskboard <id>      Taskboard ID (uses config if not specified)
+  --parent <path>       Parent layer path for hierarchical layers
+  --description <text>  Layer description
+  --start-date <date>   Start date (YYYY-MM-DD)
+  --end-date <date>     End date (YYYY-MM-DD)
+  `);
+}
+/**
+ * Print help message
+ */
+function printHelp() {
+    console.log(`
+Waymaker Sync - IDE ↔ Commander Bridge
+
+Usage:
+  waymaker sync <command> [options]
+
+Commands:
+  start     Start sync daemon
+  stop      Stop sync daemon
+  status    Show sync daemon status
+  init      Initialize configuration
+  layer     Manage taskboard layers (list, create, delete)
+  kanban    Display Kanban board in terminal
+  sync-all  Sync all existing files (initial scan)
+
+Examples:
+  # Initialize configuration
+  waymaker sync init \\
+    --workspace-id <uuid> \\
+    --project-id <uuid> \\
+    --organization-id <org-id> \\
+    --taskboard-id <uuid>
+
+  # Start sync daemon
+  waymaker sync start
+
+  # Check status
+  waymaker sync status
+
+  # Stop daemon
+  waymaker sync stop
+
+  # Display Kanban board
+  waymaker sync kanban
+  waymaker sync kanban --layer "Sprint 1"
+
+  # Initial sync of all files
+  waymaker sync sync-all
+  waymaker sync sync-all --dry-run
+  waymaker sync sync-all --force --batch-size 100
+
+Environment Variables:
+  WAYMAKER_API_KEY       API key for Commander access
+  WAYMAKER_APPS_URL      Supabase apps URL (optional)
+
+For more information, visit:
+  https://docs.waymakerone.com/waymaker-sync
+  `);
+}
+// Run CLI
+main();
+//# sourceMappingURL=cli.js.map