@stackmemoryai/stackmemory 0.3.1 → 0.3.3

package/dist/src/cli/index.js

@@ -1,995 +0,0 @@
-#!/usr/bin/env node
-/**
- * StackMemory CLI
- * Command-line interface for StackMemory operations
- */
-import { program } from 'commander';
-import { logger } from '../core/monitoring/logger.js';
-import { FrameManager } from '../core/context/frame-manager.js';
-import { sessionManager, FrameQueryMode } from '../core/session/index.js';
-import { PebblesTaskStore } from '../features/tasks/pebbles-task-store.js';
-import { LinearAuthManager, LinearOAuthSetup, } from '../integrations/linear/auth.js';
-import { LinearSyncEngine, DEFAULT_SYNC_CONFIG, } from '../integrations/linear/sync.js';
-import { initializeAutoSync, getAutoSyncService, stopAutoSync, } from '../integrations/linear/auto-sync.js';
-import { LinearConfigManager } from '../integrations/linear/config.js';
-import { UpdateChecker } from '../core/utils/update-checker.js';
-import { ProgressTracker } from '../core/monitoring/progress-tracker.js';
-import { registerProjectCommands } from './commands/projects.js';
-import { registerLinearCommands } from './commands/linear.js';
-import { registerLinearTestCommand } from './commands/linear-test.js';
-import { createSessionCommands } from './commands/session.js';
-import { registerWorktreeCommands } from './commands/worktree.js';
-import { registerOnboardingCommand } from './commands/onboard.js';
-import { webhookCommand } from './commands/webhook.js';
-import { createTaskCommands } from './commands/tasks.js';
-import { createSearchCommand } from './commands/search.js';
-import { createLogCommand } from './commands/log.js';
-import { createContextCommands } from './commands/context.js';
-import { createConfigCommand } from './commands/config.js';
-import { createAgentCommand } from './commands/agent.js';
-import { createHandoffCommand } from './commands/handoff.js';
-import { ProjectManager } from '../core/projects/project-manager.js';
-import Database from 'better-sqlite3';
-import { join } from 'path';
-import { existsSync, mkdirSync } from 'fs';
-const VERSION = '0.2.7';
-// Check for updates on CLI startup
-UpdateChecker.checkForUpdates(VERSION, true).catch(() => {
-    // Silently ignore errors
-});
-program
-    .name('stackmemory')
-    .description('Lossless memory runtime for AI coding tools')
-    .version(VERSION);
-program
-    .command('init')
-    .description('Initialize StackMemory in current project')
-    .action(async () => {
-    try {
-        const projectRoot = process.cwd();
-        const dbDir = join(projectRoot, '.stackmemory');
-        if (!existsSync(dbDir)) {
-            mkdirSync(dbDir, { recursive: true });
-        }
-        const dbPath = join(dbDir, 'context.db');
-        const db = new Database(dbPath);
-        new FrameManager(db, 'cli-project');
-        logger.info('StackMemory initialized successfully', { projectRoot });
-        console.log('✅ StackMemory initialized in', projectRoot);
-        db.close();
-    }
-    catch (error) {
-        logger.error('Failed to initialize StackMemory', error);
-        console.error('❌ Initialization failed:', error.message);
-        process.exit(1);
-    }
-});
-program
-    .command('status')
-    .description('Show current StackMemory status')
-    .option('--all', 'Show all active frames across sessions')
-    .option('--project', 'Show all active frames in current project')
-    .option('--session <id>', 'Show frames for specific session')
-    .action(async (options) => {
-    try {
-        const projectRoot = process.cwd();
-        const dbPath = join(projectRoot, '.stackmemory', 'context.db');
-        if (!existsSync(dbPath)) {
-            console.log('❌ StackMemory not initialized. Run "stackmemory init" first.');
-            return;
-        }
-        // Check for updates and display if available
-        await UpdateChecker.checkForUpdates(VERSION);
-        // Initialize session manager
-        await sessionManager.initialize();
-        const session = await sessionManager.getOrCreateSession({
-            projectPath: projectRoot,
-            sessionId: options.session,
-        });
-        const db = new Database(dbPath);
-        const frameManager = new FrameManager(db, session.projectId);
-        // Set query mode based on options
-        if (options.all) {
-            frameManager.setQueryMode(FrameQueryMode.ALL_ACTIVE);
-        }
-        else if (options.project) {
-            frameManager.setQueryMode(FrameQueryMode.PROJECT_ACTIVE);
-        }
-        const activeFrames = frameManager.getActiveFramePath();
-        const stackDepth = frameManager.getStackDepth();
-        // Always get total counts across all sessions
-        const totalStats = db
-            .prepare(`
-        SELECT 
-          COUNT(*) as total_frames,
-          SUM(CASE WHEN state = 'active' THEN 1 ELSE 0 END) as active_frames,
-          SUM(CASE WHEN state = 'closed' THEN 1 ELSE 0 END) as closed_frames,
-          COUNT(DISTINCT run_id) as total_sessions
-        FROM frames
-        WHERE project_id = ?
-      `)
-            .get(session.projectId);
-        const contextCount = db
-            .prepare(`
-        SELECT COUNT(*) as count FROM contexts
-      `)
-            .get();
-        const eventCount = db
-            .prepare(`
-        SELECT COUNT(*) as count FROM events
-      `)
-            .get();
-        console.log('📊 StackMemory Status:');
-        console.log(`   Session: ${session.sessionId.slice(0, 8)} (${session.state}, ${Math.round((Date.now() - session.startedAt) / 1000 / 60)}min old)`);
-        console.log(`   Project: ${session.projectId}`);
-        if (session.branch) {
-            console.log(`   Branch: ${session.branch}`);
-        }
-        // Show total database statistics
-        console.log(`\n   Database Statistics:`);
-        console.log(`     Total contexts: ${contextCount.count}`);
-        console.log(`     Total frames: ${totalStats.total_frames} (${totalStats.active_frames} active, ${totalStats.closed_frames} closed)`);
-        console.log(`     Total events: ${eventCount.count}`);
-        console.log(`     Total sessions: ${totalStats.total_sessions}`);
-        // Show recent activity
-        const recentFrames = db
-            .prepare(`
-        SELECT name, type, state, datetime(created_at, 'unixepoch') as created
-        FROM frames
-        WHERE project_id = ?
-        ORDER BY created_at DESC
-        LIMIT 3
-      `)
-            .all(session.projectId);
-        if (recentFrames.length > 0) {
-            console.log(`\n   Recent Activity:`);
-            recentFrames.forEach((f) => {
-                const stateIcon = f.state === 'active' ? '🟢' : '⚫';
-                console.log(`     ${stateIcon} ${f.name} [${f.type}] - ${f.created}`);
-            });
-        }
-        console.log(`\n   Current Session:`);
-        console.log(`     Stack depth: ${stackDepth}`);
-        console.log(`     Active frames: ${activeFrames.length}`);
-        if (activeFrames.length > 0) {
-            activeFrames.forEach((frame, i) => {
-                const indent = '     ' + '  '.repeat(frame.depth || i);
-                const prefix = i === 0 ? '└─' : '  └─';
-                console.log(`${indent}${prefix} ${frame.name} [${frame.type}]`);
-            });
-        }
-        // Show other sessions if in default mode
-        if (!options.all && !options.project) {
-            const otherSessions = await sessionManager.listSessions({
-                projectId: session.projectId,
-                state: 'active',
-            });
-            const otherActive = otherSessions.filter((s) => s.sessionId !== session.sessionId);
-            if (otherActive.length > 0) {
-                console.log(`\n   Other Active Sessions (same project):`);
-                otherActive.forEach((s) => {
-                    const age = Math.round((Date.now() - s.lastActiveAt) / 1000 / 60 / 60);
-                    console.log(`     - ${s.sessionId.slice(0, 8)}: ${s.branch || 'main'}, ${age}h old`);
-                });
-                console.log(`\n   Tip: Use --all to see frames across sessions`);
-            }
-        }
-        db.close();
-    }
-    catch (error) {
-        logger.error('Failed to get status', error);
-        console.error('❌ Status check failed:', error.message);
-        process.exit(1);
-    }
-});
-// Linear Integration Commands
-const linearCommand = program
-    .command('linear')
-    .description('Linear API integration commands');
-linearCommand
-    .command('setup')
-    .description('Setup Linear OAuth integration')
-    .action(async () => {
-    try {
-        const projectRoot = process.cwd();
-        const linearSetup = new LinearOAuthSetup(projectRoot);
-        const { authUrl, instructions } = await linearSetup.setupInteractive();
-        console.log('🔗 Linear OAuth Setup\n');
-        instructions.forEach((instruction) => {
-            console.log(instruction);
-        });
-        if (authUrl) {
-            console.log('\n📋 Next step: Complete authorization and run:');
-            console.log('stackmemory linear authorize <auth-code>');
-        }
-    }
-    catch (error) {
-        logger.error('Linear setup failed', error);
-        console.error('❌ Setup failed:', error.message);
-        process.exit(1);
-    }
-});
-linearCommand
-    .command('authorize')
-    .description('Complete Linear OAuth authorization')
-    .argument('<code>', 'Authorization code from Linear')
-    .action(async (authCode) => {
-    try {
-        const projectRoot = process.cwd();
-        const linearSetup = new LinearOAuthSetup(projectRoot);
-        const success = await linearSetup.completeAuth(authCode);
-        if (success) {
-            console.log('✅ Linear integration authorized successfully!');
-            console.log('🧪 Testing connection...');
-            const connectionOk = await linearSetup.testConnection();
-            if (connectionOk) {
-                console.log('✅ Linear connection test passed!');
-                console.log('\n🚀 You can now use:');
-                console.log('- stackmemory linear sync');
-                console.log('- stackmemory linear status');
-            }
-            else {
-                console.log('⚠️ Linear connection test failed. Check your configuration.');
-            }
-        }
-        else {
-            console.error('❌ Authorization failed. Please try again.');
-            process.exit(1);
-        }
-    }
-    catch (error) {
-        logger.error('Linear authorization failed', error);
-        console.error('❌ Authorization failed:', error.message);
-        process.exit(1);
-    }
-});
-linearCommand
-    .command('status')
-    .description('Show Linear integration status')
-    .action(async () => {
-    try {
-        const projectRoot = process.cwd();
-        const authManager = new LinearAuthManager(projectRoot);
-        const isConfigured = authManager.isConfigured();
-        console.log('📊 Linear Integration Status:');
-        console.log(`   Configured: ${isConfigured ? '✅' : '❌'}`);
-        if (isConfigured) {
-            const config = authManager.loadConfig();
-            const tokens = authManager.loadTokens();
-            console.log(`   Client ID: ${config?.clientId ? config.clientId.substring(0, 8) + '...' : 'Not set'}`);
-            console.log(`   Tokens: ${tokens ? '✅ Valid' : '❌ Missing'}`);
-            if (tokens) {
-                const expiresIn = Math.floor((tokens.expiresAt - Date.now()) / 1000 / 60);
-                console.log(`   Token expires: ${expiresIn > 0 ? `${expiresIn} minutes` : 'Expired'}`);
-            }
-            // Test connection
-            console.log('\n🧪 Testing connection...');
-            const linearSetup = new LinearOAuthSetup(projectRoot);
-            const connectionOk = await linearSetup.testConnection();
-            console.log(`   Connection: ${connectionOk ? '✅ OK' : '❌ Failed'}`);
-        }
-        else {
-            console.log('\n💡 Run "stackmemory linear setup" to get started');
-        }
-    }
-    catch (error) {
-        logger.error('Linear status check failed', error);
-        console.error('❌ Status check failed:', error.message);
-        process.exit(1);
-    }
-});
-linearCommand
-    .command('sync')
-    .description('Sync tasks with Linear')
-    .option('-d, --direction <direction>', 'Sync direction: bidirectional, to_linear, from_linear', 'bidirectional')
-    .action(async (options) => {
-    try {
-        const projectRoot = process.cwd();
-        const dbPath = join(projectRoot, '.stackmemory', 'context.db');
-        if (!existsSync(dbPath)) {
-            console.log('❌ StackMemory not initialized. Run "stackmemory init" first.');
-            return;
-        }
-        const authManager = new LinearAuthManager(projectRoot);
-        // Check for API key from environment first
-        if (!process.env.LINEAR_API_KEY && !authManager.isConfigured()) {
-            console.log('❌ Linear not configured. Set LINEAR_API_KEY environment variable or run "stackmemory linear setup" first.');
-            return;
-        }
-        const db = new Database(dbPath);
-        const taskStore = new PebblesTaskStore(projectRoot, db);
-        const syncConfig = {
-            ...DEFAULT_SYNC_CONFIG,
-            enabled: true,
-            direction: options.direction,
-        };
-        const linearSync = new LinearSyncEngine(taskStore, authManager, syncConfig);
-        console.log(`🔄 Starting ${options.direction} sync with Linear...`);
-        const result = await linearSync.sync();
-        // Track progress
-        const progress = new ProgressTracker(projectRoot);
-        if (result.success) {
-            console.log('✅ Sync completed successfully!');
-            console.log(`   To Linear: ${result.synced.toLinear} created`);
-            console.log(`   From Linear: ${result.synced.fromLinear} created`);
-            console.log(`   Updated: ${result.synced.updated}`);
-            // Update progress tracker
-            progress.updateLinearStatus({
-                lastSync: new Date().toISOString(),
-                tasksSynced: result.synced.toLinear +
-                    result.synced.fromLinear +
-                    result.synced.updated,
-            });
-            if (result.conflicts.length > 0) {
-                console.log(`\n⚠️ Conflicts detected: ${result.conflicts.length}`);
-                result.conflicts.forEach((conflict) => {
-                    console.log(`   - ${conflict.taskId}: ${conflict.reason}`);
-                });
-            }
-        }
-        else {
-            console.log('❌ Sync failed');
-            if (result.errors.length > 0) {
-                result.errors.forEach((error) => {
-                    console.log(`   Error: ${error}`);
-                });
-            }
-        }
-        db.close();
-    }
-    catch (error) {
-        logger.error('Linear sync failed', error);
-        console.error('❌ Sync failed:', error.message);
-        process.exit(1);
-    }
-});
-// Auto-sync commands
-linearCommand
-    .command('auto-sync')
-    .description('Manage automatic synchronization')
-    .option('--start', 'Start auto-sync service')
-    .option('--stop', 'Stop auto-sync service')
-    .option('--status', 'Show auto-sync status')
-    .option('--interval <minutes>', 'Set sync interval in minutes', '5')
-    .option('--direction <direction>', 'Set sync direction: bidirectional, to_linear, from_linear', 'bidirectional')
-    .option('--quiet-start <hour>', 'Start of quiet hours (0-23)', '22')
-    .option('--quiet-end <hour>', 'End of quiet hours (0-23)', '7')
-    .action(async (options) => {
-    try {
-        const projectRoot = process.cwd();
-        if (options.status) {
-            const service = getAutoSyncService();
-            if (service) {
-                const status = service.getStatus();
-                console.log('📊 Linear Auto-Sync Status:');
-                console.log(`   Running: ${status.running ? '✅' : '❌'}`);
-                console.log(`   Direction: ${status.config.direction}`);
-                console.log(`   Interval: ${status.config.interval} minutes`);
-                console.log(`   Conflict Resolution: ${status.config.conflictResolution}`);
-                if (status.lastSyncTime > 0) {
-                    const lastSync = new Date(status.lastSyncTime);
-                    console.log(`   Last Sync: ${lastSync.toLocaleString()}`);
-                }
-                if (status.nextSyncTime) {
-                    const nextSync = new Date(status.nextSyncTime);
-                    console.log(`   Next Sync: ${nextSync.toLocaleString()}`);
-                }
-                if (status.config.quietHours) {
-                    console.log(`   Quiet Hours: ${status.config.quietHours.start}:00 - ${status.config.quietHours.end}:00`);
-                }
-                if (status.retryCount > 0) {
-                    console.log(`   ⚠️  Retry Count: ${status.retryCount}`);
-                }
-            }
-            else {
-                console.log('📊 Linear Auto-Sync Status: ❌ Not running');
-            }
-            return;
-        }
-        if (options.start) {
-            const authManager = new LinearAuthManager(projectRoot);
-            if (!authManager.isConfigured()) {
-                console.log('❌ Linear not configured. Run "stackmemory linear setup" first.');
-                return;
-            }
-            const config = {
-                interval: parseInt(options.interval),
-                direction: options.direction,
-                quietHours: {
-                    start: parseInt(options.quietStart),
-                    end: parseInt(options.quietEnd),
-                },
-            };
-            const service = initializeAutoSync(projectRoot, config);
-            await service.start();
-            console.log('✅ Linear auto-sync started');
-            console.log(`   Interval: ${config.interval} minutes`);
-            console.log(`   Direction: ${config.direction}`);
-            console.log(`   Quiet Hours: ${config.quietHours.start}:00 - ${config.quietHours.end}:00`);
-            console.log('\n💡 Use "stackmemory linear auto-sync --status" to check status');
-            // Keep process alive for auto-sync
-            process.on('SIGINT', () => {
-                console.log('\n🛑 Stopping auto-sync service...');
-                service.stop();
-                process.exit(0);
-            });
-            console.log('🔄 Auto-sync running... Press Ctrl+C to stop');
-            // Keep the process running
-            await new Promise(() => { }); // Intentionally never resolves
-        }
-        if (options.stop) {
-            stopAutoSync();
-            console.log('🛑 Linear auto-sync stopped');
-        }
-        if (!options.start && !options.stop && !options.status) {
-            console.log('💡 Usage:');
-            console.log('  --start     Start auto-sync service');
-            console.log('  --stop      Stop auto-sync service');
-            console.log('  --status    Show current status');
-            console.log('\nExample: stackmemory linear auto-sync --start --interval 10');
-        }
-    }
-    catch (error) {
-        logger.error('Linear auto-sync command failed', error);
-        console.error('❌ Auto-sync failed:', error.message);
-        process.exit(1);
-    }
-});
-linearCommand
-    .command('force-sync')
-    .description('Force immediate synchronization')
-    .action(async () => {
-    try {
-        const service = getAutoSyncService();
-        if (service) {
-            console.log('🔄 Forcing immediate sync...');
-            await service.forceSync();
-            console.log('✅ Sync completed');
-        }
-        else {
-            console.log('❌ Auto-sync service not running. Use manual sync instead:');
-            console.log('   stackmemory linear sync');
-        }
-    }
-    catch (error) {
-        logger.error('Force sync failed', error);
-        console.error('❌ Force sync failed:', error.message);
-        process.exit(1);
-    }
-});
-linearCommand
-    .command('update <issueId>')
-    .description('Update Linear task status')
-    .option('-s, --status <status>', 'New status (todo, in-progress, done, canceled)')
-    .option('-t, --title <title>', 'Update task title')
-    .option('-d, --description <desc>', 'Update task description')
-    .option('-p, --priority <priority>', 'Set priority (1=urgent, 2=high, 3=medium, 4=low)')
-    .action(async (issueId, options) => {
-    try {
-        const projectRoot = process.cwd();
-        const authManager = new LinearAuthManager(projectRoot);
-        const tokens = authManager.loadTokens();
-        if (!tokens) {
-            console.error('❌ Not authenticated. Run: stackmemory linear setup');
-            process.exit(1);
-        }
-        const { LinearClient } = await import('../integrations/linear/client.js');
-        const client = new LinearClient({
-            apiKey: tokens.accessToken,
-        });
-        // Find the issue first
-        let issue = await client.getIssue(issueId);
-        if (!issue) {
-            // Try finding by identifier
-            issue = await client.findIssueByIdentifier(issueId);
-        }
-        if (!issue) {
-            console.error(`❌ Issue ${issueId} not found`);
-            process.exit(1);
-        }
-        const updates = {};
-        // Handle status update
-        if (options.status) {
-            const team = await client.getTeam();
-            const states = await client.getWorkflowStates(team.id);
-            const statusMap = {
-                todo: 'unstarted',
-                'in-progress': 'started',
-                done: 'completed',
-                canceled: 'cancelled',
-            };
-            const targetType = statusMap[options.status.toLowerCase()] || options.status;
-            const targetState = states.find((s) => s.type === targetType);
-            if (!targetState) {
-                console.error(`❌ Invalid status: ${options.status}`);
-                console.log('Available states:');
-                states.forEach((s) => console.log(`  - ${s.name} (${s.type})`));
-                process.exit(1);
-            }
-            updates.stateId = targetState.id;
-        }
-        if (options.title)
-            updates.title = options.title;
-        if (options.description)
-            updates.description = options.description;
-        if (options.priority)
-            updates.priority = parseInt(options.priority);
-        // Perform update
-        const updatedIssue = await client.updateIssue(issue.id, updates);
-        console.log(`✅ Updated ${updatedIssue.identifier}: ${updatedIssue.title}`);
-        if (options.status) {
-            console.log(`   Status: ${updatedIssue.state.name}`);
-        }
-        console.log(`   ${updatedIssue.url}`);
-        // Auto-sync to local tasks after update
-        console.log('\n🔄 Syncing to local tasks...');
-        const dbPath = join(projectRoot, '.stackmemory', 'context.db');
-        if (existsSync(dbPath)) {
-            const db = new Database(dbPath);
-            const taskStore = new PebblesTaskStore(projectRoot, db);
-            const { LinearSyncEngine, DEFAULT_SYNC_CONFIG } = await import('../integrations/linear/sync.js');
-            const syncEngine = new LinearSyncEngine(taskStore, authManager, { ...DEFAULT_SYNC_CONFIG, enabled: true, direction: 'from_linear' }, projectRoot);
-            const syncResult = await syncEngine.sync();
-            if (syncResult.success) {
-                console.log(`   ✅ Local tasks synced (${syncResult.synced.fromLinear} new, ${syncResult.synced.updated} updated)`);
-            }
-            db.close();
-        }
-    }
-    catch (error) {
-        logger.error('Failed to update Linear task', error);
-        console.error('❌ Failed to update task:', error.message);
-        process.exit(1);
-    }
-});
-linearCommand
-    .command('config')
-    .description('Configure auto-sync settings')
-    .option('--show', 'Show current configuration')
-    .option('--set-interval <minutes>', 'Set sync interval in minutes')
-    .option('--set-direction <direction>', 'Set sync direction: bidirectional, to_linear, from_linear')
-    .option('--set-conflict-resolution <strategy>', 'Set conflict resolution: newest_wins, linear_wins, stackmemory_wins, manual')
-    .option('--set-quiet-start <hour>', 'Set start of quiet hours (0-23)')
-    .option('--set-quiet-end <hour>', 'Set end of quiet hours (0-23)')
-    .option('--enable', 'Enable auto-sync')
-    .option('--disable', 'Disable auto-sync')
-    .option('--reset', 'Reset to default configuration')
-    .action(async (options) => {
-    try {
-        const projectRoot = process.cwd();
-        const configManager = new LinearConfigManager(projectRoot);
-        if (options.reset) {
-            configManager.resetConfig();
-            console.log('✅ Configuration reset to defaults');
-            return;
-        }
-        if (options.show) {
-            const config = configManager.loadConfig();
-            if (config) {
-                console.log('📊 Linear Auto-Sync Configuration:');
-                console.log(`   Enabled: ${config.enabled ? '✅' : '❌'}`);
-                console.log(`   Interval: ${config.interval} minutes`);
-                console.log(`   Direction: ${config.direction}`);
-                console.log(`   Conflict Resolution: ${config.conflictResolution}`);
-                console.log(`   Retry Attempts: ${config.retryAttempts}`);
-                console.log(`   Retry Delay: ${config.retryDelay / 1000}s`);
-                if (config.quietHours) {
-                    console.log(`   Quiet Hours: ${config.quietHours.start}:00 - ${config.quietHours.end}:00`);
-                }
-                const lastUpdated = new Date(config.lastUpdated);
-                console.log(`   Last Updated: ${lastUpdated.toLocaleString()}`);
-            }
-            else {
-                console.log('📊 No configuration found. Using defaults.');
-                const defaultConfig = configManager.getDefaultConfig();
-                console.log(`   Default interval: ${defaultConfig.interval} minutes`);
-                console.log(`   Default direction: ${defaultConfig.direction}`);
-            }
-            return;
-        }
-        // Update configuration
-        const updates = {};
-        if (options.setInterval) {
-            const interval = parseInt(options.setInterval);
-            if (isNaN(interval) || interval < 1) {
-                console.error('❌ Interval must be a positive number');
-                process.exit(1);
-            }
-            updates.interval = interval;
-            console.log(`✅ Set interval to ${interval} minutes`);
-        }
-        if (options.setDirection) {
-            const validDirections = ['bidirectional', 'to_linear', 'from_linear'];
-            if (!validDirections.includes(options.setDirection)) {
-                console.error(`❌ Invalid direction. Must be one of: ${validDirections.join(', ')}`);
-                process.exit(1);
-            }
-            updates.direction = options.setDirection;
-            console.log(`✅ Set direction to ${options.setDirection}`);
-        }
-        if (options.setConflictResolution) {
-            const validStrategies = [
-                'newest_wins',
-                'linear_wins',
-                'stackmemory_wins',
-                'manual',
-            ];
-            if (!validStrategies.includes(options.setConflictResolution)) {
-                console.error(`❌ Invalid strategy. Must be one of: ${validStrategies.join(', ')}`);
-                process.exit(1);
-            }
-            updates.conflictResolution = options.setConflictResolution;
-            console.log(`✅ Set conflict resolution to ${options.setConflictResolution}`);
-        }
-        if (options.setQuietStart) {
-            const hour = parseInt(options.setQuietStart);
-            if (isNaN(hour) || hour < 0 || hour > 23) {
-                console.error('❌ Quiet start hour must be between 0 and 23');
-                process.exit(1);
-            }
-            const currentConfig = configManager.loadConfig() || configManager.getDefaultConfig();
-            updates.quietHours = {
-                start: hour,
-                end: currentConfig.quietHours?.end || 7,
-            };
-            console.log(`✅ Set quiet hours start to ${hour}:00`);
-        }
-        if (options.setQuietEnd) {
-            const hour = parseInt(options.setQuietEnd);
-            if (isNaN(hour) || hour < 0 || hour > 23) {
-                console.error('❌ Quiet end hour must be between 0 and 23');
-                process.exit(1);
-            }
-            const currentConfig = configManager.loadConfig() || configManager.getDefaultConfig();
-            updates.quietHours = {
-                start: currentConfig.quietHours?.start || 22,
-                end: hour,
-            };
-            console.log(`✅ Set quiet hours end to ${hour}:00`);
-        }
-        if (options.enable) {
-            updates.enabled = true;
-            console.log('✅ Auto-sync enabled');
-        }
-        if (options.disable) {
-            updates.enabled = false;
-            console.log('❌ Auto-sync disabled');
-        }
-        if (Object.keys(updates).length > 0) {
-            configManager.saveConfig(updates);
-            console.log('\n💡 Configuration updated. Restart auto-sync service to apply changes.');
-        }
-        else if (!options.show) {
-            console.log('💡 Use --show to view current configuration');
-            console.log('💡 Use --help to see all configuration options');
-        }
-    }
-    catch (error) {
-        logger.error('Linear config command failed', error);
-        console.error('❌ Config failed:', error.message);
-        process.exit(1);
-    }
-});
-program
-    .command('update-check')
-    .description('Check for StackMemory updates')
-    .action(async () => {
-    try {
-        console.log('🔍 Checking for updates...');
-        await UpdateChecker.forceCheck(VERSION);
-    }
-    catch (error) {
-        logger.error('Update check failed', error);
-        console.error('❌ Update check failed:', error.message);
-        process.exit(1);
-    }
-});
-program
-    .command('analytics')
-    .description('Launch task analytics dashboard')
-    .option('-p, --port <port>', 'Port for dashboard server', '3000')
-    .option('-o, --open', 'Open dashboard in browser')
-    .option('--export <format>', 'Export metrics (json|csv)')
-    .option('--sync', 'Sync with Linear before launching')
-    .option('--view', 'Show analytics in terminal')
-    .action(async (options) => {
-    try {
-        const projectRoot = process.cwd();
-        const dbPath = join(projectRoot, '.stackmemory', 'context.db');
-        if (!existsSync(dbPath)) {
-            console.log('❌ StackMemory not initialized. Run "stackmemory init" first.');
-            return;
-        }
-        if (options.view) {
-            const { displayAnalyticsDashboard } = await import('./utils/viewer.js');
-            await displayAnalyticsDashboard(projectRoot);
-            return;
-        }
-        if (options.export) {
-            const { AnalyticsService } = await import('../features/analytics/index.js');
-            const service = new AnalyticsService(projectRoot);
-            if (options.sync) {
-                console.log('🔄 Syncing with Linear...');
-                await service.syncLinearTasks();
-            }
-            const state = await service.getDashboardState();
-            if (options.export === 'csv') {
-                console.log('📊 Exporting metrics as CSV...');
-                // Convert to CSV format
-                const tasks = state.recentTasks;
-                const headers = [
-                    'ID',
-                    'Title',
-                    'State',
-                    'Priority',
-                    'Created',
-                    'Completed',
-                ];
-                const rows = tasks.map((t) => [
-                    t.id,
-                    t.title,
-                    t.state,
-                    t.priority,
-                    t.createdAt.toISOString(),
-                    t.completedAt?.toISOString() || '',
-                ]);
-                console.log(headers.join(','));
-                rows.forEach((r) => console.log(r.join(',')));
-            }
-            else {
-                console.log(JSON.stringify(state, null, 2));
-            }
-            service.close();
-            return;
-        }
-        // Launch dashboard server
-        console.log(`🚀 Launching analytics dashboard on port ${options.port}...`);
-        const express = (await import('express')).default;
-        const { AnalyticsAPI } = await import('../features/analytics/index.js');
-        const { createServer } = await import('http');
-        const app = express();
-        // Add error handling middleware
-        app.use((err, _req, res, _next) => {
-            console.error('Express error:', err);
-            res.status(500).json({ error: err.message });
-        });
-        const analyticsAPI = new AnalyticsAPI(projectRoot);
-        if (options.sync) {
-            console.log('🔄 Syncing with Linear...');
-            const service = new (await import('../features/analytics/index.js')).AnalyticsService(projectRoot);
-            await service.syncLinearTasks();
-            service.close();
-        }
-        app.use('/api/analytics', analyticsAPI.getRouter());
-        // Serve the HTML dashboard
-        app.get('/', async (req, res) => {
-            // Try multiple paths for the dashboard HTML
-            const possiblePaths = [
-                join(projectRoot, 'src/features/analytics/dashboard.html'),
-                join(projectRoot, 'dist/features/analytics/dashboard.html'),
-            ];
-            for (const dashboardPath of possiblePaths) {
-                if (existsSync(dashboardPath)) {
-                    res.sendFile(dashboardPath);
-                    return;
-                }
-            }
-            // Inline fallback dashboard
-            res.send(`<!DOCTYPE html>
-<html lang="en">
-<head>
-  <meta charset="UTF-8">
-  <meta name="viewport" content="width=device-width, initial-scale=1.0">
-  <title>StackMemory Analytics</title>
-  <script src="https://cdn.jsdelivr.net/npm/chart.js"></script>
-  <style>
-    * { margin: 0; padding: 0; box-sizing: border-box; }
-    body { font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif; background: #1a1a2e; color: #eee; padding: 20px; }
-    .container { max-width: 1200px; margin: 0 auto; }
-    h1 { color: #667eea; margin-bottom: 20px; }
-    .grid { display: grid; grid-template-columns: repeat(auto-fit, minmax(200px, 1fr)); gap: 20px; margin-bottom: 30px; }
-    .card { background: #16213e; border-radius: 12px; padding: 20px; }
-    .metric-value { font-size: 2.5em; font-weight: bold; color: #667eea; }
-    .metric-label { color: #888; text-transform: uppercase; font-size: 0.8em; }
-    .task-list { max-height: 400px; overflow-y: auto; }
-    .task-item { padding: 10px; border-left: 3px solid #667eea; margin-bottom: 8px; background: #1a1a2e; }
-    .task-item.completed { border-color: #22c55e; }
-    .task-item.in_progress { border-color: #f59e0b; }
-    .status { display: inline-block; padding: 2px 8px; border-radius: 4px; font-size: 0.8em; margin-right: 8px; }
-    .status.completed { background: #22c55e30; color: #22c55e; }
-    .status.in_progress { background: #f59e0b30; color: #f59e0b; }
-    .status.todo { background: #667eea30; color: #667eea; }
-  </style>
-</head>
-<body>
-  <div class="container">
-    <h1>📊 StackMemory Analytics</h1>
-    <div class="grid" id="metrics"></div>
-    <div class="card"><h3>Recent Tasks</h3><div class="task-list" id="tasks">Loading...</div></div>
-  </div>
-  <script>
-    async function load() {
-      const metrics = await fetch('/api/analytics/metrics').then(r => r.json());
-      const tasks = await fetch('/api/analytics/tasks').then(r => r.json());
-      
-      document.getElementById('metrics').innerHTML = \`
-        <div class="card"><div class="metric-label">Total</div><div class="metric-value">\${metrics.data.metrics.totalTasks}</div></div>
-        <div class="card"><div class="metric-label">Completed</div><div class="metric-value">\${metrics.data.metrics.completedTasks}</div></div>
-        <div class="card"><div class="metric-label">In Progress</div><div class="metric-value">\${metrics.data.metrics.inProgressTasks}</div></div>
-        <div class="card"><div class="metric-label">Completion</div><div class="metric-value">\${metrics.data.metrics.completionRate.toFixed(0)}%</div></div>
-      \`;
-      
-      document.getElementById('tasks').innerHTML = tasks.data.tasks.slice(0, 10).map(t => \`
-        <div class="task-item \${t.state}">
-          <span class="status \${t.state}">\${t.state}</span>
-          <strong>\${t.title}</strong>
-        </div>
-      \`).join('');
-    }
-    load();
-    setInterval(load, 30000);
-  </script>
-</body>
-</html>`);
-        });
-        const server = createServer(app);
-        analyticsAPI.setupWebSocket(server);
-        server.listen(options.port, async () => {
-            console.log(`✅ Analytics dashboard running at http://localhost:${options.port}`);
-            if (options.open) {
-                const { exec } = await import('child_process');
-                const url = `http://localhost:${options.port}`;
-                const command = process.platform === 'darwin'
-                    ? `open ${url}`
-                    : process.platform === 'win32'
-                        ? `start ${url}`
-                        : `xdg-open ${url}`;
-                exec(command);
-            }
-        });
-        process.on('SIGINT', () => {
-            console.log('\n👋 Shutting down analytics dashboard...');
-            analyticsAPI.close();
-            server.close();
-            process.exit(0);
-        });
-        // Keep the process alive
-        await new Promise(() => { });
-    }
-    catch (error) {
-        logger.error('Analytics command failed', error);
-        console.error('❌ Analytics failed:', error.message);
-        process.exit(1);
-    }
-});
-program
-    .command('progress')
-    .description('Show current progress and recent changes')
-    .action(async () => {
-    try {
-        const projectRoot = process.cwd();
-        const dbPath = join(projectRoot, '.stackmemory', 'context.db');
-        if (!existsSync(dbPath)) {
-            console.log('❌ StackMemory not initialized. Run "stackmemory init" first.');
-            return;
-        }
-        const progress = new ProgressTracker(projectRoot);
-        console.log(progress.getSummary());
-    }
-    catch (error) {
-        logger.error('Failed to show progress', error);
-        console.error('❌ Failed to show progress:', error.message);
-        process.exit(1);
-    }
-});
-program
-    .command('mcp-server')
-    .description('Start StackMemory MCP server for Claude Desktop')
-    .option('-p, --project <path>', 'Project root directory', process.cwd())
-    .action(async (options) => {
-    try {
-        const { runMCPServer } = await import('../integrations/mcp/server.js');
-        // Set project root
-        process.env.PROJECT_ROOT = options.project;
-        console.log('🚀 Starting StackMemory MCP Server...');
-        console.log(`   Project: ${options.project}`);
-        console.log(`   Version: ${VERSION}`);
-        // Check for updates silently
-        UpdateChecker.checkForUpdates(VERSION, true).catch(() => { });
-        // Start the MCP server
-        await runMCPServer();
-    }
-    catch (error) {
-        logger.error('Failed to start MCP server', error);
-        console.error('❌ MCP server failed:', error.message);
-        process.exit(1);
-    }
-});
-// Add test context command
-program
-    .command('context:test')
-    .description('Test context persistence by creating sample frames')
-    .action(async () => {
-    try {
-        const projectRoot = process.cwd();
-        const dbPath = join(projectRoot, '.stackmemory', 'context.db');
-        if (!existsSync(dbPath)) {
-            console.log('❌ StackMemory not initialized. Run "stackmemory init" first.');
-            return;
-        }
-        const db = new Database(dbPath);
-        const frameManager = new FrameManager(db, 'cli-project');
-        // Create test frames
-        console.log('📝 Creating test context frames...');
-        const rootFrame = frameManager.createFrame({
-            type: 'task',
-            name: 'Test Session',
-            inputs: { test: true, timestamp: new Date().toISOString() },
-        });
-        const taskFrame = frameManager.createFrame({
-            type: 'subtask',
-            name: 'Sample Task',
-            inputs: { description: 'Testing context persistence' },
-            parentFrameId: rootFrame,
-        });
-        const commandFrame = frameManager.createFrame({
-            type: 'tool_scope',
-            name: 'test-command',
-            inputs: { args: ['--test'] },
-            parentFrameId: taskFrame,
-        });
-        // Add some events
-        frameManager.addEvent('observation', {
-            message: 'Test event recorded',
-        }, commandFrame);
-        console.log('✅ Test frames created!');
-        console.log(`📊 Stack depth: ${frameManager.getStackDepth()}`);
-        console.log(`🔄 Active frames: ${frameManager.getActiveFramePath().length}`);
-        // Close one frame to test state changes
-        frameManager.closeFrame(commandFrame);
-        console.log(`📊 After closing command frame: depth = ${frameManager.getStackDepth()}`);
-        db.close();
-    }
-    catch (error) {
-        logger.error('Test context failed', error);
-        console.error('❌ Test failed:', error.message);
-        process.exit(1);
-    }
-});
-// Register project management commands
-// Register command modules
-registerOnboardingCommand(program);
-registerProjectCommands(program);
-registerWorktreeCommands(program);
-// Register Linear integration commands
-registerLinearCommands(program);
-registerLinearTestCommand(program);
-// Register session management commands
-program.addCommand(createSessionCommands());
-// Register webhook command
-program.addCommand(webhookCommand());
-// Register enhanced CLI commands
-program.addCommand(createTaskCommands());
-program.addCommand(createSearchCommand());
-program.addCommand(createLogCommand());
-program.addCommand(createContextCommands());
-program.addCommand(createConfigCommand());
-program.addCommand(createAgentCommand());
-program.addCommand(createHandoffCommand());
-// Auto-detect current project on startup
-if (process.argv.length > 2) {
-    const manager = ProjectManager.getInstance();
-    manager.detectProject().catch(() => {
-        // Silently fail if not in a project directory
-    });
-}
-// Only parse when running as main module (not when imported for testing)
-const isMainModule = import.meta.url === `file://${process.argv[1]}` ||
-    process.argv[1]?.endsWith('/stackmemory') ||
-    process.argv[1]?.endsWith('index.ts') ||
-    process.argv[1]?.includes('tsx');
-if (isMainModule) {
-    program.parse();
-}
-export { program };
-//# sourceMappingURL=index.js.map