@cpretzinger/boss-claude 1.0.0 → 1.0.2

package/lib/setup/summary.js

@@ -0,0 +1,400 @@
+/**
+ * Boss Claude Setup Summary
+ *
+ * Beautiful success summary that makes users feel accomplished after setup.
+ * Displays what was configured, next steps, and helpful commands to try.
+ */
+
+import chalk from 'chalk';
+import prompts from '../prompts.js';
+
+const {
+  success,
+  info,
+  muted,
+  blank,
+  divider,
+  keyValue,
+  theme
+} = prompts;
+
+/**
+ * Display a beautiful setup success summary
+ *
+ * @param {Object} config - Setup configuration results
+ * @param {Object} config.user - User information (name, email, username)
+ * @param {Object} config.github - GitHub setup results (enabled, repo, token)
+ * @param {Object} config.redis - Redis setup results (enabled, url, stats)
+ * @param {Object} config.postgres - PostgreSQL setup results (enabled, url, stats)
+ * @param {Object} config.env - Environment file information (path, created)
+ * @param {number} config.duration - Setup duration in milliseconds
+ */
+export function displaySetupSummary(config) {
+  blank();
+  divider();
+  blank();
+
+  // Success header with celebration
+  console.log(chalk.bold.green('  ✨ SETUP COMPLETE! ✨'));
+  blank();
+
+  const emoji = getRandomSuccessEmoji();
+  console.log(chalk.dim(`  ${emoji} Boss Claude is ready to revolutionize your workflow ${emoji}`));
+  blank();
+  divider();
+  blank();
+
+  // Configuration summary
+  console.log(chalk.bold('  📋 WHAT WAS CONFIGURED'));
+  blank();
+
+  // User info
+  if (config.user) {
+    keyValue('Your Name', config.user.name || 'Not provided');
+    if (config.user.email) {
+      keyValue('Email', config.user.email);
+    }
+    if (config.user.username) {
+      keyValue('GitHub Username', `@${config.user.username}`);
+    }
+    blank();
+  }
+
+  // GitHub integration
+  if (config.github?.enabled) {
+    keyValue('GitHub Integration', chalk.green('✓ Enabled'));
+    if (config.github.repo) {
+      keyValue('  Repository', config.github.repo);
+    }
+    keyValue('  Authentication', chalk.green('✓ Configured'));
+    blank();
+  } else {
+    keyValue('GitHub Integration', chalk.yellow('○ Skipped (manual mode)'));
+    blank();
+  }
+
+  // Redis
+  if (config.redis?.enabled) {
+    keyValue('Redis (Session Storage)', chalk.green('✓ Connected'));
+    if (config.redis.stats) {
+      keyValue('  Identity Created', chalk.green('✓ Level 1 Boss'));
+      keyValue('  Data Structures', chalk.green(`✓ ${config.redis.stats.dataStructures || 'Initialized'}`));
+    }
+    blank();
+  } else {
+    keyValue('Redis', chalk.yellow('○ Skipped (sessions not persisted)'));
+    blank();
+  }
+
+  // PostgreSQL
+  if (config.postgres?.enabled) {
+    keyValue('PostgreSQL (Analytics)', chalk.green('✓ Connected'));
+    if (config.postgres.stats) {
+      keyValue('  Schema Version', config.postgres.stats.schemaVersion || 'v1');
+      keyValue('  Tables Created', chalk.green(`✓ ${config.postgres.stats.tablesCreated || 'All ready'}`));
+    }
+    blank();
+  } else {
+    keyValue('PostgreSQL', chalk.yellow('○ Skipped (analytics disabled)'));
+    blank();
+  }
+
+  // Environment file
+  if (config.env?.created) {
+    keyValue('Environment File', chalk.green('✓ Created'));
+    keyValue('  Location', config.env.path || '~/.boss-claude/.env');
+    blank();
+  }
+
+  // Setup duration
+  if (config.duration) {
+    const seconds = (config.duration / 1000).toFixed(1);
+    keyValue('Setup Time', `${seconds}s ${getSpeedComment(seconds)}`);
+    blank();
+  }
+
+  divider();
+  blank();
+
+  // Next steps
+  console.log(chalk.bold('  🚀 NEXT STEPS'));
+  blank();
+
+  const steps = [
+    'Check your status anytime with:',
+    chalk.cyan('  $ boss-claude status'),
+    '',
+    'Start a new session:',
+    chalk.cyan('  $ boss-claude start "Working on awesome feature"'),
+    '',
+    'Save your progress:',
+    chalk.cyan('  $ boss-claude save "Completed authentication system"'),
+    '',
+    'View your achievements:',
+    chalk.cyan('  $ boss-claude achievements')
+  ];
+
+  steps.forEach(step => console.log(chalk.dim(`  ${step}`)));
+  blank();
+
+  divider();
+  blank();
+
+  // Helpful tips
+  console.log(chalk.bold('  💡 PRO TIPS'));
+  blank();
+
+  const tips = [
+    chalk.dim('• Boss Claude tracks XP, tokens, and achievements automatically'),
+    chalk.dim('• Your identity persists across ALL your repositories'),
+    chalk.dim('• Use ') + chalk.cyan('boss-claude --help') + chalk.dim(' to see all commands'),
+    chalk.dim('• Check ') + chalk.cyan('~/.boss-claude/') + chalk.dim(' for configs and logs')
+  ];
+
+  tips.forEach(tip => console.log(`  ${tip}`));
+  blank();
+
+  divider();
+  blank();
+
+  // Final motivation
+  const motivation = getRandomMotivation();
+  console.log(chalk.bold.green(`  ${motivation}`));
+  blank();
+
+  // Documentation link
+  console.log(chalk.dim('  📚 Docs: https://github.com/cpretzinger/boss-claude#readme'));
+  blank();
+  divider();
+  blank();
+}
+
+/**
+ * Display a compact summary (for quick setups)
+ *
+ * @param {Object} config - Simplified config object
+ */
+export function displayQuickSummary(config) {
+  blank();
+  success('Setup complete!');
+  blank();
+
+  if (config.redis?.enabled) {
+    info(`Redis connected: ${config.redis.url?.split('@')[1]?.split('/')[0] || 'localhost'}`);
+  }
+
+  if (config.postgres?.enabled) {
+    info(`PostgreSQL connected: ${config.postgres.url?.split('@')[1]?.split('/')[0] || 'localhost'}`);
+  }
+
+  if (config.github?.enabled) {
+    info(`GitHub repo: ${config.github.repo}`);
+  }
+
+  blank();
+  console.log(chalk.dim('  Try: ') + chalk.cyan('boss-claude status'));
+  blank();
+}
+
+/**
+ * Display a summary for partial/failed setup
+ *
+ * @param {Object} config - Config with success/failure info
+ * @param {Array<string>} errors - List of errors encountered
+ */
+export function displayPartialSummary(config, errors = []) {
+  blank();
+  divider();
+  blank();
+
+  console.log(chalk.bold.yellow('  ⚠️  SETUP PARTIALLY COMPLETE'));
+  blank();
+
+  // Show what worked
+  const successes = [];
+  if (config.redis?.enabled) successes.push('Redis');
+  if (config.postgres?.enabled) successes.push('PostgreSQL');
+  if (config.github?.enabled) successes.push('GitHub');
+
+  if (successes.length > 0) {
+    keyValue('Configured', chalk.green(successes.join(', ')));
+    blank();
+  }
+
+  // Show what failed
+  if (errors.length > 0) {
+    console.log(chalk.bold.red('  ❌ ISSUES ENCOUNTERED'));
+    blank();
+    errors.forEach(err => {
+      console.log(chalk.dim(`  • ${err}`));
+    });
+    blank();
+  }
+
+  divider();
+  blank();
+
+  console.log(chalk.dim('  You can re-run setup anytime with: ') + chalk.cyan('boss-claude setup'));
+  blank();
+}
+
+/**
+ * Display rollback summary
+ *
+ * @param {Object} rollback - Rollback information
+ */
+export function displayRollbackSummary(rollback) {
+  blank();
+  divider();
+  blank();
+
+  console.log(chalk.bold.yellow('  ↩️  SETUP ROLLED BACK'));
+  blank();
+
+  if (rollback.reason) {
+    keyValue('Reason', rollback.reason);
+    blank();
+  }
+
+  if (rollback.actionsReverted?.length > 0) {
+    console.log(chalk.dim('  Actions reverted:'));
+    rollback.actionsReverted.forEach(action => {
+      console.log(chalk.dim(`  • ${action}`));
+    });
+    blank();
+  }
+
+  divider();
+  blank();
+
+  console.log(chalk.dim('  Your system is back to its original state.'));
+  console.log(chalk.dim('  Run ') + chalk.cyan('boss-claude setup') + chalk.dim(' to try again.'));
+  blank();
+}
+
+/**
+ * Display validation results
+ *
+ * @param {Object} validation - Validation test results
+ */
+export function displayValidationSummary(validation) {
+  blank();
+  divider();
+  blank();
+
+  console.log(chalk.bold('  🔍 VALIDATION RESULTS'));
+  blank();
+
+  const tests = validation.tests || {};
+  let passed = 0;
+  let failed = 0;
+
+  Object.entries(tests).forEach(([name, result]) => {
+    if (result.success) {
+      console.log(chalk.green(`  ✓ ${name}`));
+      passed++;
+    } else {
+      console.log(chalk.red(`  ✗ ${name}`));
+      if (result.error) {
+        console.log(chalk.dim(`    ${result.error}`));
+      }
+      failed++;
+    }
+  });
+
+  blank();
+  divider();
+  blank();
+
+  if (failed === 0) {
+    success(`All ${passed} tests passed!`);
+  } else {
+    console.log(chalk.yellow(`  ${passed} passed, ${failed} failed`));
+  }
+
+  blank();
+}
+
+/**
+ * Get a random success emoji
+ * @returns {string}
+ */
+function getRandomSuccessEmoji() {
+  const emojis = ['🎉', '🎊', '🌟', '⭐', '🚀', '💪', '🔥', '✨'];
+  return emojis[Math.floor(Math.random() * emojis.length)];
+}
+
+/**
+ * Get a comment about setup speed
+ * @param {number} seconds - Duration in seconds
+ * @returns {string}
+ */
+function getSpeedComment(seconds) {
+  if (seconds < 5) return '⚡ Lightning fast!';
+  if (seconds < 15) return '🚀 Quick setup!';
+  if (seconds < 30) return '✓ Not bad!';
+  return '✓ Done!';
+}
+
+/**
+ * Get a random motivational message
+ * @returns {string}
+ */
+function getRandomMotivation() {
+  const messages = [
+    'You\'re all set! Time to build something amazing.',
+    'Configuration complete. Let\'s get to work!',
+    'Ready to level up your productivity!',
+    'Everything is configured. Go make magic happen!',
+    'Setup successful. Your AI assistant awaits!',
+    'You\'re ready to rock! Let\'s do this.',
+    'Configuration locked in. Time to shine!',
+    'All systems go! Let\'s build the future.'
+  ];
+  return messages[Math.floor(Math.random() * messages.length)];
+}
+
+/**
+ * Create a configuration summary object from setup results
+ *
+ * @param {Object} results - Raw setup results from wizard
+ * @returns {Object} Formatted config for summary
+ */
+export function createSummaryConfig(results) {
+  return {
+    user: {
+      name: results.userName || results.user?.name,
+      email: results.userEmail || results.user?.email,
+      username: results.githubUsername || results.github?.username
+    },
+    github: {
+      enabled: results.githubEnabled || results.github?.enabled || false,
+      repo: results.githubRepo || results.github?.repo,
+      token: results.githubToken ? '✓ Set' : null
+    },
+    redis: {
+      enabled: results.redisEnabled || results.redis?.enabled || false,
+      url: results.redisUrl || results.redis?.url,
+      stats: results.redisStats || results.redis?.stats
+    },
+    postgres: {
+      enabled: results.postgresEnabled || results.postgres?.enabled || false,
+      url: results.postgresUrl || results.postgres?.url,
+      stats: results.postgresStats || results.postgres?.stats
+    },
+    env: {
+      created: results.envCreated || results.env?.created || false,
+      path: results.envPath || results.env?.path
+    },
+    duration: results.duration || results.setupDuration
+  };
+}
+
+export default {
+  displaySetupSummary,
+  displayQuickSummary,
+  displayPartialSummary,
+  displayRollbackSummary,
+  displayValidationSummary,
+  createSummaryConfig
+};

package/lib/setup/test-github-setup.js

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+
+/**
+ * Test script for GitHub repository setup
+ * Usage: node lib/setup/test-github-setup.js
+ */
+
+import { setupGitHubRepoCommand } from './github-repo.js';
+
+await setupGitHubRepoCommand();

package/lib/setup/test-postgres-init.js

@@ -0,0 +1,98 @@
+#!/usr/bin/env node
+/**
+ * Test PostgreSQL Initialization
+ *
+ * Simple test script to verify init-postgres.js works correctly
+ * Tests: connection, schema creation, health checks, and stats
+ */
+
+import {
+  initializePostgres,
+  verifyPostgres,
+  getPostgresStats,
+  printInitResults
+} from './init-postgres.js';
+import chalk from 'chalk';
+
+// Get connection string from environment or use default
+const connectionString = process.env.DATABASE_URL || process.env.POSTGRES_URL;
+
+if (!connectionString) {
+  console.log(chalk.red('\n✗ Error: No PostgreSQL connection string found'));
+  console.log(chalk.dim('Set DATABASE_URL or POSTGRES_URL environment variable\n'));
+  process.exit(1);
+}
+
+async function runTests() {
+  console.log(chalk.cyan('\n🧪 Testing PostgreSQL Initialization\n'));
+  console.log(chalk.dim(`Connection: ${connectionString.replace(/:[^:@]+@/, ':****@')}\n`));
+
+  try {
+    // Test 1: Verify connection
+    console.log(chalk.cyan('1️⃣  Verifying connection...'));
+    const verification = await verifyPostgres(connectionString);
+
+    if (!verification.connected) {
+      console.log(chalk.red(`✗ Connection failed: ${verification.error}\n`));
+      process.exit(1);
+    }
+
+    console.log(chalk.green('✓ Connected successfully'));
+    console.log(chalk.dim(`   Database: ${verification.version.split(',')[0]}`));
+
+    if (verification.schemaExists) {
+      console.log(chalk.yellow('○ Schema already exists'));
+      console.log(chalk.dim(`   Tables: ${verification.tables.join(', ')}`));
+    } else {
+      console.log(chalk.dim('   Schema does not exist yet'));
+    }
+
+    // Test 2: Initialize schema
+    console.log(chalk.cyan('\n2️⃣  Initializing schema...'));
+    const results = await initializePostgres(connectionString, false);
+    printInitResults(results);
+
+    if (!results.healthCheck.passed) {
+      console.log(chalk.red('✗ Initialization failed health check\n'));
+      process.exit(1);
+    }
+
+    // Test 3: Get statistics
+    console.log(chalk.cyan('3️⃣  Retrieving statistics...'));
+    const stats = await getPostgresStats(connectionString);
+
+    console.log(chalk.dim('\nDatabase Statistics:'));
+    console.log(chalk.dim(`   Total Sessions: ${stats.totalSessions}`));
+    console.log(chalk.dim(`   Active Sessions: ${stats.activeSessions}`));
+    console.log(chalk.dim(`   Unique Users: ${stats.totalUsers}`));
+    console.log(chalk.dim(`   Total Achievements: ${stats.totalAchievements}`));
+    console.log(chalk.dim(`   Memory Snapshots: ${stats.totalSnapshots}`));
+    console.log(chalk.dim(`   Schema Size: ${stats.schemaSize}`));
+
+    if (stats.oldestSession) {
+      console.log(chalk.dim(`   First Session: ${new Date(stats.oldestSession).toLocaleDateString()}`));
+    }
+    if (stats.newestSession) {
+      console.log(chalk.dim(`   Last Session: ${new Date(stats.newestSession).toLocaleDateString()}`));
+    }
+
+    // Test 4: Verify again
+    console.log(chalk.cyan('\n4️⃣  Final verification...'));
+    const finalCheck = await verifyPostgres(connectionString);
+
+    if (finalCheck.connected && finalCheck.healthCheck.passed) {
+      console.log(chalk.green('\n✓ All tests passed! PostgreSQL is ready.\n'));
+      process.exit(0);
+    } else {
+      console.log(chalk.red('\n✗ Final verification failed\n'));
+      process.exit(1);
+    }
+
+  } catch (error) {
+    console.log(chalk.red(`\n✗ Test failed: ${error.message}`));
+    console.log(chalk.dim(error.stack));
+    process.exit(1);
+  }
+}
+
+runTests();

package/lib/setup/verify-setup.js

@@ -0,0 +1,102 @@
+#!/usr/bin/env node
+
+/**
+ * Verification script for GitHub repository setup
+ * Tests all major functionality without creating a repository
+ */
+
+import chalk from 'chalk';
+import { getGitHubToken } from './github-repo.js';
+import { Octokit } from '@octokit/rest';
+
+console.log(chalk.bold('\n🔍 Boss Claude GitHub Setup Verification\n'));
+
+// Step 1: Check for token
+console.log(chalk.blue('1. Checking for GitHub token...'));
+const token = getGitHubToken();
+
+if (token) {
+  console.log(chalk.green('   ✓ Token found'));
+  console.log(chalk.gray(`   → Source: ${process.env.GITHUB_TOKEN ? 'GITHUB_TOKEN env var' : 'git config'}`));
+  console.log(chalk.gray(`   → Length: ${token.length} characters`));
+  console.log(chalk.gray(`   → Prefix: ${token.substring(0, 7)}...`));
+} else {
+  console.log(chalk.red('   ✗ No token found'));
+  console.log(chalk.yellow('\n   To fix, run one of these:'));
+  console.log(chalk.gray('   export GITHUB_TOKEN=ghp_your_token'));
+  console.log(chalk.gray('   git config --global github.token ghp_your_token'));
+  process.exit(1);
+}
+
+// Step 2: Test authentication
+console.log(chalk.blue('\n2. Testing GitHub authentication...'));
+const octokit = new Octokit({ auth: token });
+
+try {
+  const { data: user } = await octokit.users.getAuthenticated();
+  console.log(chalk.green('   ✓ Authentication successful'));
+  console.log(chalk.gray(`   → Username: ${user.login}`));
+  console.log(chalk.gray(`   → Name: ${user.name || 'Not set'}`));
+  console.log(chalk.gray(`   → Account type: ${user.type}`));
+  console.log(chalk.gray(`   → Public repos: ${user.public_repos}`));
+  console.log(chalk.gray(`   → Private repos: ${user.total_private_repos || 'Unknown'}`));
+} catch (error) {
+  console.log(chalk.red('   ✗ Authentication failed'));
+  console.log(chalk.red(`   → Error: ${error.message}`));
+  console.log(chalk.yellow('\n   Your token may be invalid or expired.'));
+  console.log(chalk.gray('   Create a new token at: https://github.com/settings/tokens'));
+  process.exit(1);
+}
+
+// Step 3: Check token scopes
+console.log(chalk.blue('\n3. Checking token permissions...'));
+try {
+  const { headers } = await octokit.request('HEAD /user');
+  const scopes = headers['x-oauth-scopes']?.split(', ') || [];
+
+  if (scopes.length === 0) {
+    console.log(chalk.yellow('   ⚠ Warning: Could not determine token scopes'));
+  } else {
+    console.log(chalk.green('   ✓ Token scopes found'));
+    scopes.forEach(scope => {
+      const hasRepo = scope === 'repo' || scope.startsWith('repo:');
+      const icon = hasRepo ? chalk.green('✓') : chalk.gray('•');
+      console.log(chalk.gray(`   ${icon} ${scope}`));
+    });
+
+    const hasRepoScope = scopes.some(s => s === 'repo' || s.startsWith('repo:'));
+    if (hasRepoScope) {
+      console.log(chalk.green('\n   ✓ Token has required repo permissions'));
+    } else {
+      console.log(chalk.yellow('\n   ⚠ Warning: Token may not have repo creation permissions'));
+      console.log(chalk.gray('   → Required scope: repo'));
+    }
+  }
+} catch (error) {
+  console.log(chalk.yellow('   ⚠ Could not check token permissions'));
+  console.log(chalk.gray(`   → ${error.message}`));
+}
+
+// Step 4: Check rate limits
+console.log(chalk.blue('\n4. Checking API rate limits...'));
+try {
+  const { data: rateLimit } = await octokit.rateLimit.get();
+  const { core } = rateLimit.resources;
+
+  console.log(chalk.green('   ✓ Rate limit status'));
+  console.log(chalk.gray(`   → Remaining: ${core.remaining}/${core.limit}`));
+  console.log(chalk.gray(`   → Resets at: ${new Date(core.reset * 1000).toLocaleTimeString()}`));
+
+  if (core.remaining < 10) {
+    console.log(chalk.yellow('\n   ⚠ Warning: Low rate limit remaining'));
+  }
+} catch (error) {
+  console.log(chalk.yellow('   ⚠ Could not check rate limits'));
+  console.log(chalk.gray(`   → ${error.message}`));
+}
+
+// Step 5: Summary
+console.log(chalk.bold.green('\n✓ Verification Complete\n'));
+console.log(chalk.gray('Your GitHub setup is ready for Boss Claude repository creation.'));
+console.log(chalk.gray('\nTo create the repository, run:'));
+console.log(chalk.cyan('  node lib/setup/test-github-setup.js\n'));