@cpretzinger/boss-claude 1.0.0 → 1.0.2

package/scripts/redis-monitor.js

@@ -0,0 +1,284 @@
+#!/usr/bin/env node
+/**
+ * Redis Health Monitor for Boss Claude
+ *
+ * Monitors Redis connection health, key statistics, and memory usage.
+ * Useful for debugging session issues and tracking long-term stability.
+ */
+
+import Redis from 'ioredis';
+import chalk from 'chalk';
+import dotenv from 'dotenv';
+import { existsSync } from 'fs';
+import { join } from 'path';
+import os from 'os';
+
+// Load environment
+const envPath = join(os.homedir(), '.boss-claude', '.env');
+if (existsSync(envPath)) {
+  dotenv.config({ path: envPath });
+}
+
+if (!process.env.REDIS_URL) {
+  console.log(chalk.red('Error: REDIS_URL not found in ~/.boss-claude/.env'));
+  process.exit(1);
+}
+
+const redis = new Redis(process.env.REDIS_URL);
+
+async function getKeyStats() {
+  const stats = {
+    total: 0,
+    identity: 0,
+    sessions: 0,
+    repos: 0,
+    history: 0,
+    achievements: 0,
+    cache: 0
+  };
+
+  const allKeys = await redis.keys('boss:*');
+  stats.total = allKeys.length;
+
+  for (const key of allKeys) {
+    if (key === 'boss:identity') stats.identity++;
+    else if (key.startsWith('boss:session:')) stats.sessions++;
+    else if (key.startsWith('boss:repo:')) stats.repos++;
+    else if (key === 'boss:sessions:history') stats.history++;
+    else if (key.startsWith('boss:achievements:')) stats.achievements++;
+    else if (key.startsWith('boss:cache:')) stats.cache++;
+  }
+
+  return stats;
+}
+
+async function getIdentityInfo() {
+  const data = await redis.get('boss:identity');
+  if (!data) return null;
+
+  const identity = JSON.parse(data);
+  const xpForNext = identity.level * 100;
+  const progress = (identity.xp / xpForNext) * 100;
+
+  return {
+    ...identity,
+    xp_for_next_level: xpForNext,
+    level_progress: Math.round(progress)
+  };
+}
+
+async function getActiveSessions() {
+  const sessionKeys = await redis.keys('boss:session:*:current');
+  const sessions = [];
+
+  for (const key of sessionKeys) {
+    const data = await redis.get(key);
+    const session = JSON.parse(data);
+    const repoName = key.replace('boss:session:', '').replace(':current', '');
+
+    sessions.push({
+      repo: repoName,
+      started_at: session.started_at,
+      duration: Math.round((Date.now() - new Date(session.started_at).getTime()) / 1000 / 60),
+      tokens: session.tokens_used || 0
+    });
+  }
+
+  return sessions;
+}
+
+async function getRepoStats() {
+  const repoKeys = await redis.keys('boss:repo:*');
+  const repos = [];
+
+  for (const key of repoKeys) {
+    const data = await redis.get(key);
+    const repo = JSON.parse(data);
+    repos.push(repo);
+  }
+
+  // Sort by last_active descending
+  repos.sort((a, b) => new Date(b.last_active) - new Date(a.last_active));
+
+  return repos.slice(0, 5); // Top 5 most recent
+}
+
+async function getSessionHistory() {
+  const count = await redis.zcard('boss:sessions:history');
+  const recent = await redis.zrevrange('boss:sessions:history', 0, 4, 'WITHSCORES');
+
+  const sessions = [];
+  for (let i = 0; i < recent.length; i += 2) {
+    const issueId = recent[i];
+    const timestamp = parseInt(recent[i + 1]);
+    sessions.push({
+      issue: issueId,
+      timestamp: new Date(timestamp).toISOString(),
+      relative: getRelativeTime(timestamp)
+    });
+  }
+
+  return { total: count, recent: sessions };
+}
+
+async function getCacheStats() {
+  const cacheKeys = await redis.keys('boss:cache:*');
+  const stats = { total: cacheKeys.length, entries: [] };
+
+  for (const key of cacheKeys) {
+    const ttl = await redis.ttl(key);
+    const data = await redis.get(key);
+
+    if (data) {
+      const cached = JSON.parse(data);
+      stats.entries.push({
+        query: cached.query || 'unknown',
+        ttl: ttl,
+        cached_at: cached.cached_at
+      });
+    }
+  }
+
+  return stats;
+}
+
+async function testPerformance() {
+  const iterations = 100;
+  const testKey = 'boss:monitor:test';
+
+  // Single operation latency
+  const singleStart = Date.now();
+  await redis.set(testKey, 'test');
+  await redis.get(testKey);
+  const singleLatency = Date.now() - singleStart;
+
+  // Pipeline latency
+  const pipelineStart = Date.now();
+  const pipeline = redis.pipeline();
+  for (let i = 0; i < iterations; i++) {
+    pipeline.get(testKey);
+  }
+  await pipeline.exec();
+  const pipelineLatency = Date.now() - pipelineStart;
+
+  await redis.del(testKey);
+
+  return {
+    single_roundtrip_ms: singleLatency,
+    pipeline_100ops_ms: pipelineLatency,
+    pipeline_ops_per_sec: Math.round((iterations / pipelineLatency) * 1000)
+  };
+}
+
+function getRelativeTime(timestamp) {
+  const seconds = Math.floor((Date.now() - timestamp) / 1000);
+
+  if (seconds < 60) return `${seconds}s ago`;
+  if (seconds < 3600) return `${Math.floor(seconds / 60)}m ago`;
+  if (seconds < 86400) return `${Math.floor(seconds / 3600)}h ago`;
+  return `${Math.floor(seconds / 86400)}d ago`;
+}
+
+async function main() {
+  console.log(chalk.bold.cyan('\n╔═══════════════════════════════════════╗'));
+  console.log(chalk.bold.cyan('║   BOSS CLAUDE - REDIS MONITOR        ║'));
+  console.log(chalk.bold.cyan('╚═══════════════════════════════════════╝\n'));
+
+  try {
+    // Test connection
+    await redis.ping();
+    console.log(chalk.green('✓ Connected to Redis\n'));
+
+    // Get key statistics
+    console.log(chalk.cyan('📊 Key Statistics'));
+    const keyStats = await getKeyStats();
+    console.log(`  Total keys: ${chalk.yellow(keyStats.total)}`);
+    console.log(`  Identity: ${keyStats.identity ? chalk.green('✓') : chalk.red('✗')}`);
+    console.log(`  Active sessions: ${chalk.yellow(keyStats.sessions)}`);
+    console.log(`  Repos managed: ${chalk.yellow(keyStats.repos)}`);
+    console.log(`  Session history: ${keyStats.history ? chalk.green('✓') : chalk.red('✗')}`);
+    console.log(`  Achievements: ${chalk.yellow(keyStats.achievements)}`);
+    console.log(`  Cache entries: ${chalk.yellow(keyStats.cache)}\n`);
+
+    // Identity info
+    console.log(chalk.cyan('🤖 Boss Claude Identity'));
+    const identity = await getIdentityInfo();
+    if (identity) {
+      console.log(`  Level: ${chalk.yellow(identity.level)} (${identity.level_progress}% to next)`);
+      console.log(`  XP: ${chalk.yellow(identity.xp)}/${identity.xp_for_next_level}`);
+      console.log(`  Token Bank: ${chalk.yellow(identity.token_bank.toLocaleString())}`);
+      console.log(`  Total Sessions: ${chalk.yellow(identity.total_sessions)}`);
+      console.log(`  Repos Managed: ${chalk.yellow(identity.repos_managed)}`);
+      console.log(`  Created: ${chalk.gray(new Date(identity.created_at).toLocaleString())}\n`);
+    } else {
+      console.log(chalk.red('  Not initialized\n'));
+    }
+
+    // Active sessions
+    const activeSessions = await getActiveSessions();
+    if (activeSessions.length > 0) {
+      console.log(chalk.cyan('⚡ Active Sessions'));
+      activeSessions.forEach(session => {
+        console.log(`  ${chalk.yellow(session.repo)}`);
+        console.log(`    Duration: ${session.duration}m`);
+        console.log(`    Tokens: ${session.tokens.toLocaleString()}`);
+      });
+      console.log('');
+    }
+
+    // Recent repos
+    console.log(chalk.cyan('📁 Recent Repositories (Top 5)'));
+    const repos = await getRepoStats();
+    if (repos.length > 0) {
+      repos.forEach(repo => {
+        console.log(`  ${chalk.yellow(repo.name)} - ${repo.session_count} sessions`);
+        console.log(`    Last active: ${chalk.gray(getRelativeTime(new Date(repo.last_active).getTime()))}`);
+      });
+    } else {
+      console.log(chalk.gray('  No repos yet'));
+    }
+    console.log('');
+
+    // Session history
+    console.log(chalk.cyan('📜 Session History'));
+    const history = await getSessionHistory();
+    console.log(`  Total sessions: ${chalk.yellow(history.total)}`);
+    if (history.recent.length > 0) {
+      console.log(`  Recent sessions:`);
+      history.recent.forEach(session => {
+        console.log(`    ${chalk.gray(session.relative)} - ${session.issue}`);
+      });
+    }
+    console.log('');
+
+    // Cache stats
+    const cacheStats = await getCacheStats();
+    if (cacheStats.total > 0) {
+      console.log(chalk.cyan('💾 Cache Statistics'));
+      console.log(`  Total entries: ${chalk.yellow(cacheStats.total)}`);
+      cacheStats.entries.slice(0, 3).forEach(entry => {
+        console.log(`    ${entry.query} (TTL: ${entry.ttl}s)`);
+      });
+      console.log('');
+    }
+
+    // Performance test
+    console.log(chalk.cyan('⚡ Performance Test'));
+    const perf = await testPerformance();
+    console.log(`  Single round-trip: ${chalk.yellow(perf.single_roundtrip_ms + 'ms')}`);
+    console.log(`  Pipeline (100 ops): ${chalk.yellow(perf.pipeline_100ops_ms + 'ms')}`);
+    console.log(`  Pipeline throughput: ${chalk.yellow(perf.pipeline_ops_per_sec.toLocaleString() + ' ops/sec')}\n`);
+
+    // Health summary
+    const health = identity && history.total >= 0 ? chalk.green('HEALTHY') : chalk.yellow('NEEDS SETUP');
+    console.log(chalk.white(`Status: ${health}\n`));
+
+  } catch (error) {
+    console.log(chalk.red('Error:'), error.message);
+    process.exit(1);
+  } finally {
+    await redis.quit();
+  }
+}
+
+main();

package/scripts/redis-setup.js

@@ -0,0 +1,412 @@
+#!/usr/bin/env node
+/**
+ * Redis Setup and Verification Script for Boss Claude
+ *
+ * This script:
+ * 1. Tests connection to the Redis instance (from REDIS_URL env var)
+ * 2. Verifies read/write operations
+ * 3. Documents the complete key schema
+ * 4. Initializes necessary data structures
+ * 5. Provides performance benchmarks
+ */
+
+import Redis from 'ioredis';
+import chalk from 'chalk';
+
+const REDIS_URL = process.env.REDIS_URL;
+if (!REDIS_URL) {
+  console.error('❌ REDIS_URL environment variable is required');
+  console.error('Set it with: export REDIS_URL=redis://...');
+  process.exit(1);
+}
+
+// Boss Claude Redis Schema
+const SCHEMA = {
+  identity: {
+    key: 'boss:identity',
+    type: 'string (JSON)',
+    ttl: 'none',
+    description: 'Global Boss Claude identity (level, XP, token bank, total sessions)',
+    example: {
+      level: 1,
+      xp: 0,
+      token_bank: 0,
+      total_sessions: 0,
+      repos_managed: 0,
+      created_at: '2025-01-30T18:00:00.000Z',
+      updated_at: '2025-01-30T18:00:00.000Z'
+    }
+  },
+  session_current: {
+    key: 'boss:session:{repo_name}:current',
+    type: 'string (JSON)',
+    ttl: 'none (deleted on save)',
+    description: 'Active session data for a specific repo',
+    example: {
+      started_at: '2025-01-30T18:00:00.000Z',
+      messages: [],
+      tokens_used: 0,
+      tasks_completed: 0,
+      files_modified: []
+    }
+  },
+  repo_stats: {
+    key: 'boss:repo:{repo_name}',
+    type: 'string (JSON)',
+    ttl: 'none',
+    description: 'Per-repo statistics and metadata',
+    example: {
+      name: 'BOSS-claude',
+      path: '/Users/craigpretzinger/projects/BOSS-claude',
+      session_count: 0,
+      first_seen: '2025-01-30T18:00:00.000Z',
+      last_active: '2025-01-30T18:00:00.000Z',
+      total_tokens: 0,
+      total_xp_earned: 0
+    }
+  },
+  session_history: {
+    key: 'boss:sessions:history',
+    type: 'sorted set',
+    ttl: 'none',
+    description: 'Historical sessions sorted by timestamp',
+    score: 'unix timestamp',
+    value: 'session_id (links to GitHub issue)'
+  },
+  achievement: {
+    key: 'boss:achievements:{username}',
+    type: 'set',
+    ttl: 'none',
+    description: 'Unlocked achievements',
+    example: ['first_session', 'level_5', 'token_saver', 'perfect_execution']
+  },
+  leaderboard: {
+    key: 'boss:leaderboard:xp',
+    type: 'sorted set',
+    ttl: 'none',
+    description: 'Global XP leaderboard',
+    score: 'total XP',
+    value: 'username'
+  },
+  cache_memory: {
+    key: 'boss:cache:memory:{query_hash}',
+    type: 'string (JSON)',
+    ttl: '3600 (1 hour)',
+    description: 'Cached memory search results',
+    example: {
+      query: 'redis setup',
+      results: [],
+      cached_at: '2025-01-30T18:00:00.000Z'
+    }
+  }
+};
+
+async function testConnection() {
+  console.log(chalk.cyan('\n🔌 Testing Redis Connection...\n'));
+
+  const redis = new Redis(REDIS_URL, {
+    connectTimeout: 10000,
+    maxRetriesPerRequest: 3,
+    retryStrategy(times) {
+      const delay = Math.min(times * 50, 2000);
+      return delay;
+    }
+  });
+
+  return new Promise((resolve, reject) => {
+    redis.on('connect', () => {
+      console.log(chalk.green(`✓ Connected to Redis (${new URL(REDIS_URL).host})`));
+      resolve(redis);
+    });
+
+    redis.on('error', (err) => {
+      console.log(chalk.red('✗ Connection failed:'), err.message);
+      reject(err);
+    });
+
+    redis.on('ready', () => {
+      console.log(chalk.green('✓ Redis client ready'));
+    });
+  });
+}
+
+async function verifyReadWrite(redis) {
+  console.log(chalk.cyan('\n📝 Testing Read/Write Operations...\n'));
+
+  const testKey = 'boss:test:connection';
+  const testValue = JSON.stringify({
+    timestamp: new Date().toISOString(),
+    test: 'Boss Claude Redis Setup'
+  });
+
+  try {
+    // Write test
+    await redis.set(testKey, testValue);
+    console.log(chalk.green('✓ Write operation successful'));
+
+    // Read test
+    const retrieved = await redis.get(testKey);
+    if (retrieved === testValue) {
+      console.log(chalk.green('✓ Read operation successful'));
+    } else {
+      throw new Error('Data mismatch');
+    }
+
+    // TTL test
+    await redis.setex('boss:test:ttl', 60, 'expires in 60s');
+    const ttl = await redis.ttl('boss:test:ttl');
+    console.log(chalk.green(`✓ TTL operation successful (${ttl}s remaining)`));
+
+    // Cleanup
+    await redis.del(testKey, 'boss:test:ttl');
+    console.log(chalk.green('✓ Delete operation successful'));
+
+    return true;
+  } catch (error) {
+    console.log(chalk.red('✗ Read/Write test failed:'), error.message);
+    return false;
+  }
+}
+
+async function checkExistingData(redis) {
+  console.log(chalk.cyan('\n🔍 Checking Existing Data...\n'));
+
+  // Check for existing identity
+  const identity = await redis.get('boss:identity');
+  if (identity) {
+    console.log(chalk.yellow('⚠ Existing identity found:'));
+    console.log(JSON.stringify(JSON.parse(identity), null, 2));
+  } else {
+    console.log(chalk.gray('ℹ No existing identity (will be created on first use)'));
+  }
+
+  // Check for repo data
+  const repoKeys = await redis.keys('boss:repo:*');
+  if (repoKeys.length > 0) {
+    console.log(chalk.yellow(`⚠ Found ${repoKeys.length} existing repo(s):`));
+    for (const key of repoKeys) {
+      const data = await redis.get(key);
+      const repo = JSON.parse(data);
+      console.log(`  - ${repo.name} (${repo.session_count} sessions)`);
+    }
+  } else {
+    console.log(chalk.gray('ℹ No existing repos'));
+  }
+
+  // Check for active sessions
+  const sessionKeys = await redis.keys('boss:session:*:current');
+  if (sessionKeys.length > 0) {
+    console.log(chalk.yellow(`⚠ Found ${sessionKeys.length} active session(s):`));
+    sessionKeys.forEach(key => {
+      const repoName = key.replace('boss:session:', '').replace(':current', '');
+      console.log(`  - ${repoName}`);
+    });
+  } else {
+    console.log(chalk.gray('ℹ No active sessions'));
+  }
+}
+
+async function benchmarkOperations(redis) {
+  console.log(chalk.cyan('\n⚡ Running Performance Benchmarks...\n'));
+
+  const iterations = 1000;
+  const testData = JSON.stringify({ test: 'data', timestamp: Date.now() });
+
+  // SET benchmark
+  const setStart = Date.now();
+  for (let i = 0; i < iterations; i++) {
+    await redis.set(`boss:bench:${i}`, testData);
+  }
+  const setDuration = Date.now() - setStart;
+  const setOpsPerSec = Math.round((iterations / setDuration) * 1000);
+
+  console.log(chalk.green(`✓ SET: ${iterations} ops in ${setDuration}ms (${setOpsPerSec} ops/sec)`));
+
+  // GET benchmark
+  const getStart = Date.now();
+  for (let i = 0; i < iterations; i++) {
+    await redis.get(`boss:bench:${i}`);
+  }
+  const getDuration = Date.now() - getStart;
+  const getOpsPerSec = Math.round((iterations / getDuration) * 1000);
+
+  console.log(chalk.green(`✓ GET: ${iterations} ops in ${getDuration}ms (${getOpsPerSec} ops/sec)`));
+
+  // Pipeline benchmark
+  const pipelineStart = Date.now();
+  const pipeline = redis.pipeline();
+  for (let i = 0; i < iterations; i++) {
+    pipeline.get(`boss:bench:${i}`);
+  }
+  await pipeline.exec();
+  const pipelineDuration = Date.now() - pipelineStart;
+  const pipelineOpsPerSec = Math.round((iterations / pipelineDuration) * 1000);
+
+  console.log(chalk.green(`✓ PIPELINE: ${iterations} ops in ${pipelineDuration}ms (${pipelineOpsPerSec} ops/sec)`));
+
+  // Cleanup
+  const keys = await redis.keys('boss:bench:*');
+  if (keys.length > 0) {
+    await redis.del(...keys);
+  }
+
+  console.log(chalk.gray(`\nℹ Cleaned up ${iterations} test keys`));
+
+  return {
+    set: { duration: setDuration, opsPerSec: setOpsPerSec },
+    get: { duration: getDuration, opsPerSec: getOpsPerSec },
+    pipeline: { duration: pipelineDuration, opsPerSec: pipelineOpsPerSec }
+  };
+}
+
+async function displayServerInfo(redis) {
+  console.log(chalk.cyan('\n🖥️  Redis Server Information...\n'));
+
+  const info = await redis.info();
+  const lines = info.split('\r\n');
+
+  const extractValue = (key) => {
+    const line = lines.find(l => l.startsWith(key));
+    return line ? line.split(':')[1] : 'N/A';
+  };
+
+  console.log(chalk.white('Server:'));
+  console.log(`  Redis Version: ${extractValue('redis_version')}`);
+  console.log(`  OS: ${extractValue('os')}`);
+  console.log(`  Uptime: ${Math.round(extractValue('uptime_in_seconds') / 86400)} days`);
+
+  console.log(chalk.white('\nMemory:'));
+  const usedMemory = extractValue('used_memory_human');
+  const maxMemory = extractValue('maxmemory_human');
+  console.log(`  Used: ${usedMemory}`);
+  console.log(`  Max: ${maxMemory || 'unlimited'}`);
+
+  console.log(chalk.white('\nStats:'));
+  console.log(`  Total Connections: ${extractValue('total_connections_received')}`);
+  console.log(`  Total Commands: ${extractValue('total_commands_processed')}`);
+  console.log(`  Connected Clients: ${extractValue('connected_clients')}`);
+
+  const dbInfo = lines.find(l => l.startsWith('db0'));
+  if (dbInfo) {
+    const keys = dbInfo.match(/keys=(\d+)/)[1];
+    console.log(`  Keys in DB: ${keys}`);
+  } else {
+    console.log(`  Keys in DB: 0`);
+  }
+}
+
+function printSchema() {
+  console.log(chalk.cyan('\n📋 Boss Claude Redis Schema\n'));
+
+  Object.entries(SCHEMA).forEach(([name, spec]) => {
+    console.log(chalk.white.bold(`${name.toUpperCase()}`));
+    console.log(`  Key: ${chalk.yellow(spec.key)}`);
+    console.log(`  Type: ${spec.type}`);
+    console.log(`  TTL: ${spec.ttl}`);
+    console.log(`  Description: ${spec.description}`);
+    if (spec.example) {
+      console.log(`  Example: ${chalk.gray(JSON.stringify(spec.example, null, 2).split('\n').join('\n           '))}`);
+    }
+    console.log('');
+  });
+}
+
+async function initializeStructures(redis) {
+  console.log(chalk.cyan('\n🚀 Initializing Data Structures...\n'));
+
+  // Check if identity exists
+  const existingIdentity = await redis.get('boss:identity');
+
+  if (!existingIdentity) {
+    const identity = {
+      level: 1,
+      xp: 0,
+      token_bank: 0,
+      total_sessions: 0,
+      repos_managed: 0,
+      created_at: new Date().toISOString()
+    };
+
+    await redis.set('boss:identity', JSON.stringify(identity));
+    console.log(chalk.green('✓ Created default Boss Claude identity (Level 1)'));
+  } else {
+    console.log(chalk.yellow('⚠ Identity already exists (skipping)'));
+  }
+
+  // Initialize session history sorted set (if not exists)
+  const historyExists = await redis.exists('boss:sessions:history');
+  if (!historyExists) {
+    // Create empty sorted set
+    await redis.zadd('boss:sessions:history', 0, 'placeholder');
+    await redis.zrem('boss:sessions:history', 'placeholder');
+    console.log(chalk.green('✓ Initialized session history sorted set'));
+  } else {
+    const count = await redis.zcard('boss:sessions:history');
+    console.log(chalk.yellow(`⚠ Session history already exists (${count} entries)`));
+  }
+
+  console.log(chalk.green('\n✓ Initialization complete!'));
+}
+
+async function main() {
+  console.log(chalk.bold.cyan('╔═══════════════════════════════════════════╗'));
+  console.log(chalk.bold.cyan('║   BOSS CLAUDE - REDIS SETUP & VERIFY     ║'));
+  console.log(chalk.bold.cyan('╚═══════════════════════════════════════════╝'));
+
+  let redis;
+
+  try {
+    // Test connection
+    redis = await testConnection();
+
+    // Display server info
+    await displayServerInfo(redis);
+
+    // Verify read/write
+    const rwSuccess = await verifyReadWrite(redis);
+    if (!rwSuccess) {
+      throw new Error('Read/Write verification failed');
+    }
+
+    // Check existing data
+    await checkExistingData(redis);
+
+    // Run benchmarks
+    const benchmarks = await benchmarkOperations(redis);
+
+    // Initialize structures
+    await initializeStructures(redis);
+
+    // Print schema documentation
+    printSchema();
+
+    console.log(chalk.bold.green('\n✅ ALL TESTS PASSED!\n'));
+    console.log(chalk.white('Connection Details:'));
+    console.log(`  Host: ${chalk.yellow(new URL(REDIS_URL).host)}`);
+    console.log(`  Database: ${chalk.yellow('0 (default)')}`);
+    console.log(`  Status: ${chalk.green('Connected')}`);
+
+    console.log(chalk.white('\nPerformance:'));
+    console.log(`  SET ops/sec: ${chalk.yellow(benchmarks.set.opsPerSec.toLocaleString())}`);
+    console.log(`  GET ops/sec: ${chalk.yellow(benchmarks.get.opsPerSec.toLocaleString())}`);
+    console.log(`  PIPELINE ops/sec: ${chalk.yellow(benchmarks.pipeline.opsPerSec.toLocaleString())}`);
+
+    console.log(chalk.white('\nNext Steps:'));
+    console.log(`  1. Update ${chalk.yellow('~/.boss-claude/.env')} with new REDIS_URL`);
+    console.log(`  2. Run ${chalk.yellow('npm install -g .')} to install boss-claude globally`);
+    console.log(`  3. Run ${chalk.yellow('boss-claude status')} to verify installation`);
+
+  } catch (error) {
+    console.log(chalk.bold.red('\n❌ SETUP FAILED!\n'));
+    console.log(chalk.red('Error:'), error.message);
+    console.log(chalk.red('Stack:'), error.stack);
+    process.exit(1);
+  } finally {
+    if (redis) {
+      await redis.quit();
+      console.log(chalk.gray('\n[Connection closed]'));
+    }
+  }
+}
+
+main();