@wundr.io/cli 1.0.0 → 1.0.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wundr.io/cli",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "Unified CLI framework for the Wundr platform",
   "keywords": ["wundr", "cli", "commander", "interactive", "tui", "automation"],
   "homepage": "https://wundr.io",
@@ -42,9 +42,9 @@
     "@oclif/plugin-plugins": "^4.1.0",
     "@types/axios": "^0.9.36",
     "@types/open": "^6.2.1",
-    "@wundr.io/computer-setup": "workspace:*",
-    "@wundr.io/config": "workspace:*",
-    "@wundr.io/core": "workspace:*",
+    "@wundr.io/computer-setup": "^1.0.0",
+    "@wundr.io/config": "^1.0.0",
+    "@wundr.io/core": "^1.0.0",
     "axios": "^1.11.0",
     "blessed": "^0.1.81",
     "blessed-contrib": "^4.11.0",

package/src/commands/computer-setup-commands.ts

@@ -10,6 +10,8 @@ import inquirer from 'inquirer';
 import { ConfigManager } from '../utils/config-manager';
 import { PluginManager } from '../plugins/plugin-manager';
 import { logger } from '../utils/logger';
+import { BackupRollbackManager } from '../utils/backup-rollback-manager';
+import { ClaudeConfigInstaller } from '../utils/claude-config-installer';
 import { execSync } from 'child_process';
 import * as os from 'os';
 import * as fs from 'fs/promises';
@@ -38,6 +40,8 @@ interface LocalSetupOptions {
 export class ComputerSetupCommands {
   private orchestrator: RealSetupOrchestrator;
   private platform: SetupPlatform;
+  private backupManager: BackupRollbackManager;
+  private claudeInstaller: ClaudeConfigInstaller;
 
   constructor(
     private program: Command,
@@ -46,6 +50,8 @@ export class ComputerSetupCommands {
   ) {
     this.platform = this.detectPlatform();
     this.orchestrator = new RealSetupOrchestrator(this.platform);
+    this.backupManager = new BackupRollbackManager();
+    this.claudeInstaller = new ClaudeConfigInstaller();
     this.registerCommands();
   }
 
@@ -165,6 +171,41 @@ Examples:
       .action(async (tool, options) => {
         await this.installTool(tool, options);
       });
+
+    // Claude Code configuration commands
+    computerSetup
+      .command('claude-config')
+      .description('Install Claude Code configuration')
+      .option('--dry-run', 'Show what would be installed')
+      .option('--skip-backup', 'Skip backup creation')
+      .option('--overwrite', 'Overwrite existing configurations')
+      .option('--verbose', 'Show detailed output')
+      .action(async options => {
+        await this.installClaudeConfig(options);
+      });
+
+    // Backup management commands
+    computerSetup
+      .command('backup')
+      .description('Manage configuration backups')
+      .option('-l, --list', 'List all backups')
+      .option('-c, --create', 'Create new backup')
+      .option('-v, --verify <id>', 'Verify backup integrity')
+      .option('--cleanup', 'Clean up old backups')
+      .action(async options => {
+        await this.manageBackups(options);
+      });
+
+    // Rollback command
+    computerSetup
+      .command('rollback')
+      .description('Restore from backup')
+      .option('--backup <id>', 'Specific backup to restore')
+      .option('--dry-run', 'Show what would be restored')
+      .option('--verbose', 'Show detailed output')
+      .action(async options => {
+        await this.rollbackConfiguration(options);
+      });
   }
 
   private async runSetup(options: any): Promise<void> {
@@ -706,4 +747,123 @@ Examples:
       console.log(chalk.gray(`  Fixing ${failure.name}...`));
     }
   }
+
+  /**
+   * Install Claude Code configuration
+   */
+  private async installClaudeConfig(options: any): Promise<void> {
+    console.log(chalk.cyan('\n🔧 Claude Code Configuration Installer\n'));
+
+    try {
+      // Initialize managers
+      await this.backupManager.initialize();
+      await this.claudeInstaller.initialize();
+
+      // Install configurations
+      const result = await this.claudeInstaller.install({
+        dryRun: options.dryRun,
+        skipBackup: options.skipBackup,
+        overwrite: options.overwrite,
+        verbose: options.verbose,
+      });
+
+      if (!result.success) {
+        process.exit(1);
+      }
+    } catch (error) {
+      console.error(chalk.red('❌ Installation failed:'), error);
+      logger.error('Claude config installation failed', error);
+      process.exit(1);
+    }
+  }
+
+  /**
+   * Manage backups
+   */
+  private async manageBackups(options: any): Promise<void> {
+    await this.backupManager.initialize();
+
+    if (options.list) {
+      const backups = await this.backupManager.listBackups();
+
+      if (backups.length === 0) {
+        console.log(chalk.yellow('No backups found'));
+        return;
+      }
+
+      console.log(chalk.cyan('\n📦 Available Backups\n'));
+      backups.forEach(backup => {
+        const date = new Date(backup.timestamp).toLocaleString();
+        const status = backup.success
+          ? chalk.green('✅ Success')
+          : chalk.red('❌ Failed');
+
+        console.log(chalk.white(`ID: ${backup.backupId}`));
+        console.log(chalk.gray(`  Date: ${date}`));
+        console.log(chalk.gray(`  Reason: ${backup.reason}`));
+        console.log(chalk.gray(`  Status: ${status}`));
+        console.log(chalk.gray(`  Files: ${backup.files.length}`));
+        console.log();
+      });
+    } else if (options.create) {
+      const { files } = await inquirer.prompt([
+        {
+          type: 'input',
+          name: 'files',
+          message: 'Enter file paths (comma-separated):',
+          validate: input => input.length > 0,
+        },
+      ]);
+
+      const fileList = files.split(',').map((f: string) => f.trim());
+      const backup = await this.backupManager.createBackup(
+        fileList,
+        'Manual backup'
+      );
+
+      this.backupManager.displayBackupInfo(backup);
+    } else if (options.verify) {
+      const isValid = await this.backupManager.verifyBackup(options.verify);
+
+      if (isValid) {
+        console.log(chalk.green(`✅ Backup ${options.verify} is valid`));
+      } else {
+        console.log(chalk.red(`❌ Backup ${options.verify} is invalid`));
+        process.exit(1);
+      }
+    } else if (options.cleanup) {
+      await this.backupManager.cleanupOldBackups();
+      console.log(chalk.green('✅ Old backups cleaned up'));
+    } else {
+      console.log(chalk.yellow('Please specify an option. Use --help for details.'));
+    }
+  }
+
+  /**
+   * Rollback configuration
+   */
+  private async rollbackConfiguration(options: any): Promise<void> {
+    console.log(chalk.cyan('\n🔄 Configuration Rollback\n'));
+
+    await this.backupManager.initialize();
+
+    const success = await this.backupManager.rollback({
+      backupId: options.backup,
+      dryRun: options.dryRun,
+      verbose: options.verbose,
+    });
+
+    if (!success) {
+      console.log(chalk.red('\n❌ Rollback failed'));
+      process.exit(1);
+    }
+
+    if (!options.dryRun) {
+      console.log(chalk.green('\n✅ Rollback completed successfully'));
+      console.log(chalk.cyan('\nNext steps:'));
+      console.log(chalk.white('  1. Verify restored configurations'));
+      console.log(chalk.white('  2. Restart terminal if needed'));
+      console.log(chalk.white('  3. Run validation script'));
+    }
+  }
 }

package/src/tests/computer-setup-integration.test.ts

@@ -0,0 +1,439 @@
+/**
+ * Integration tests for computer-setup with Claude Code configuration
+ */
+
+import { describe, it, expect, beforeEach, afterEach, jest } from '@jest/globals';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { existsSync } from 'fs';
+import { BackupRollbackManager } from '../utils/backup-rollback-manager';
+import { ClaudeConfigInstaller } from '../utils/claude-config-installer';
+
+describe('Computer Setup Integration Tests', () => {
+  const testDir = path.join(__dirname, '.test-temp');
+  const backupDir = path.join(testDir, 'backups');
+  const claudeDir = path.join(testDir, '.claude');
+
+  beforeEach(async () => {
+    // Create test directories
+    await fs.mkdir(testDir, { recursive: true });
+    await fs.mkdir(backupDir, { recursive: true });
+    await fs.mkdir(claudeDir, { recursive: true });
+  });
+
+  afterEach(async () => {
+    // Clean up test directories
+    await fs.rm(testDir, { recursive: true, force: true });
+  });
+
+  describe('BackupRollbackManager', () => {
+    let backupManager: BackupRollbackManager;
+
+    beforeEach(async () => {
+      backupManager = new BackupRollbackManager(backupDir);
+      await backupManager.initialize();
+    });
+
+    it('should initialize backup directory', async () => {
+      expect(existsSync(backupDir)).toBe(true);
+    });
+
+    it('should create backup of files', async () => {
+      // Create test files
+      const testFile1 = path.join(testDir, 'test1.txt');
+      const testFile2 = path.join(testDir, 'test2.txt');
+      await fs.writeFile(testFile1, 'content1');
+      await fs.writeFile(testFile2, 'content2');
+
+      // Create backup
+      const metadata = await backupManager.createBackup(
+        [testFile1, testFile2],
+        'Test backup'
+      );
+
+      expect(metadata.success).toBe(true);
+      expect(metadata.files).toHaveLength(2);
+      expect(metadata.backupId).toBeTruthy();
+
+      // Verify backup files exist
+      for (const file of metadata.files) {
+        expect(existsSync(file.backupPath)).toBe(true);
+      }
+    });
+
+    it('should list backups', async () => {
+      // Create test file and backup
+      const testFile = path.join(testDir, 'test.txt');
+      await fs.writeFile(testFile, 'content');
+
+      await backupManager.createBackup([testFile], 'Backup 1');
+      await backupManager.createBackup([testFile], 'Backup 2');
+
+      const backups = await backupManager.listBackups();
+      expect(backups.length).toBeGreaterThanOrEqual(2);
+    });
+
+    it('should restore files from backup', async () => {
+      // Create original file
+      const testFile = path.join(testDir, 'test.txt');
+      await fs.writeFile(testFile, 'original content');
+
+      // Create backup
+      const metadata = await backupManager.createBackup([testFile], 'Test backup');
+
+      // Modify file
+      await fs.writeFile(testFile, 'modified content');
+
+      // Restore from backup
+      const success = await backupManager.rollback({
+        backupId: metadata.backupId,
+        dryRun: false,
+      });
+
+      expect(success).toBe(true);
+
+      // Verify content restored
+      const content = await fs.readFile(testFile, 'utf-8');
+      expect(content).toBe('original content');
+    });
+
+    it('should verify backup integrity', async () => {
+      // Create test file and backup
+      const testFile = path.join(testDir, 'test.txt');
+      await fs.writeFile(testFile, 'content');
+
+      const metadata = await backupManager.createBackup([testFile], 'Test backup');
+
+      const isValid = await backupManager.verifyBackup(metadata.backupId);
+      expect(isValid).toBe(true);
+    });
+
+    it('should clean up old backups', async () => {
+      // Create multiple backups
+      const testFile = path.join(testDir, 'test.txt');
+      await fs.writeFile(testFile, 'content');
+
+      for (let i = 0; i < 10; i++) {
+        await backupManager.createBackup([testFile], `Backup ${i}`);
+      }
+
+      // Clean up, keeping only 5
+      await backupManager.cleanupOldBackups(5);
+
+      const backups = await backupManager.listBackups();
+      expect(backups.length).toBeLessThanOrEqual(5);
+    });
+
+    it('should handle dry-run rollback', async () => {
+      const testFile = path.join(testDir, 'test.txt');
+      await fs.writeFile(testFile, 'original');
+
+      const metadata = await backupManager.createBackup([testFile], 'Test');
+
+      await fs.writeFile(testFile, 'modified');
+
+      const success = await backupManager.rollback({
+        backupId: metadata.backupId,
+        dryRun: true,
+      });
+
+      expect(success).toBe(true);
+
+      // File should not be restored in dry-run
+      const content = await fs.readFile(testFile, 'utf-8');
+      expect(content).toBe('modified');
+    });
+  });
+
+  describe('ClaudeConfigInstaller', () => {
+    let installer: ClaudeConfigInstaller;
+
+    beforeEach(async () => {
+      installer = new ClaudeConfigInstaller({
+        claudeDir,
+        sourceDir: testDir,
+      });
+      await installer.initialize();
+
+      // Create mock CLAUDE.md
+      await fs.writeFile(
+        path.join(testDir, 'CLAUDE.md'),
+        '# Claude Configuration\nTest content'
+      );
+    });
+
+    it('should initialize directory structure', async () => {
+      expect(existsSync(claudeDir)).toBe(true);
+      expect(existsSync(path.join(claudeDir, 'hooks'))).toBe(true);
+      expect(existsSync(path.join(claudeDir, 'agents'))).toBe(true);
+      expect(existsSync(path.join(claudeDir, 'workflows'))).toBe(true);
+      expect(existsSync(path.join(claudeDir, 'scripts'))).toBe(true);
+    });
+
+    it('should install CLAUDE.md', async () => {
+      const result = await installer.install({
+        dryRun: false,
+        skipBackup: true,
+      });
+
+      expect(result.success).toBe(true);
+      expect(result.installed).toContain('CLAUDE.md');
+      expect(existsSync(path.join(claudeDir, 'CLAUDE.md'))).toBe(true);
+    });
+
+    it('should install hooks', async () => {
+      const result = await installer.install({
+        dryRun: false,
+        skipBackup: true,
+      });
+
+      expect(result.success).toBe(true);
+
+      const hooksDir = path.join(claudeDir, 'hooks');
+      expect(existsSync(path.join(hooksDir, 'pre-commit'))).toBe(true);
+      expect(existsSync(path.join(hooksDir, 'post-checkout'))).toBe(true);
+    });
+
+    it('should install conventions', async () => {
+      const result = await installer.install({
+        dryRun: false,
+        skipBackup: true,
+      });
+
+      expect(result.success).toBe(true);
+      expect(result.installed).toContain('conventions.json');
+
+      const conventionsPath = path.join(claudeDir, 'conventions.json');
+      expect(existsSync(conventionsPath)).toBe(true);
+
+      const conventions = JSON.parse(await fs.readFile(conventionsPath, 'utf-8'));
+      expect(conventions).toHaveProperty('fileNaming');
+      expect(conventions).toHaveProperty('codeStyle');
+    });
+
+    it('should install agent templates', async () => {
+      const result = await installer.install({
+        dryRun: false,
+        skipBackup: true,
+      });
+
+      expect(result.success).toBe(true);
+
+      const agentsDir = path.join(claudeDir, 'agents');
+      expect(existsSync(path.join(agentsDir, 'backend-developer.json'))).toBe(true);
+      expect(existsSync(path.join(agentsDir, 'frontend-developer.json'))).toBe(true);
+      expect(existsSync(path.join(agentsDir, 'fullstack-developer.json'))).toBe(true);
+    });
+
+    it('should install git-worktree workflows', async () => {
+      const result = await installer.install({
+        dryRun: false,
+        skipBackup: true,
+      });
+
+      expect(result.success).toBe(true);
+
+      const workflowsDir = path.join(claudeDir, 'workflows');
+      expect(
+        existsSync(path.join(workflowsDir, 'feature-development.json'))
+      ).toBe(true);
+      expect(existsSync(path.join(workflowsDir, 'bug-fix.json'))).toBe(true);
+    });
+
+    it('should install validation scripts', async () => {
+      const result = await installer.install({
+        dryRun: false,
+        skipBackup: true,
+      });
+
+      expect(result.success).toBe(true);
+
+      const scriptsDir = path.join(claudeDir, 'scripts');
+      expect(existsSync(path.join(scriptsDir, 'validate-setup.sh'))).toBe(true);
+      expect(existsSync(path.join(scriptsDir, 'check-config.sh'))).toBe(true);
+    });
+
+    it('should handle dry-run installation', async () => {
+      const result = await installer.install({
+        dryRun: true,
+        skipBackup: true,
+      });
+
+      expect(result.success).toBe(true);
+      expect(result.installed.every(f => f.includes('dry-run'))).toBe(true);
+
+      // Files should not exist in dry-run
+      expect(existsSync(path.join(claudeDir, 'CLAUDE.md'))).toBe(false);
+    });
+
+    it('should skip existing files without overwrite', async () => {
+      // Create existing file
+      await fs.writeFile(path.join(claudeDir, 'CLAUDE.md'), 'existing content');
+
+      const result = await installer.install({
+        dryRun: false,
+        skipBackup: true,
+        overwrite: false,
+      });
+
+      expect(result.skipped).toContain('CLAUDE.md');
+
+      // Content should remain unchanged
+      const content = await fs.readFile(path.join(claudeDir, 'CLAUDE.md'), 'utf-8');
+      expect(content).toBe('existing content');
+    });
+
+    it('should overwrite existing files with overwrite flag', async () => {
+      // Create existing file
+      await fs.writeFile(path.join(claudeDir, 'CLAUDE.md'), 'existing content');
+
+      const result = await installer.install({
+        dryRun: false,
+        skipBackup: true,
+        overwrite: true,
+      });
+
+      expect(result.installed).toContain('CLAUDE.md');
+
+      // Content should be updated
+      const content = await fs.readFile(path.join(claudeDir, 'CLAUDE.md'), 'utf-8');
+      expect(content).toContain('Test content');
+    });
+
+    it('should create backup before installation', async () => {
+      // Create existing configurations
+      await fs.writeFile(path.join(claudeDir, 'CLAUDE.md'), 'existing');
+      await fs.writeFile(
+        path.join(claudeDir, 'conventions.json'),
+        JSON.stringify({ test: true })
+      );
+
+      const result = await installer.install({
+        dryRun: false,
+        skipBackup: false,
+        overwrite: true,
+      });
+
+      expect(result.backupId).toBeTruthy();
+    });
+  });
+
+  describe('End-to-End Integration', () => {
+    it('should complete full installation workflow', async () => {
+      const backupManager = new BackupRollbackManager(backupDir);
+      const installer = new ClaudeConfigInstaller({
+        claudeDir,
+        sourceDir: testDir,
+      });
+
+      await backupManager.initialize();
+      await installer.initialize();
+
+      // Create mock source file
+      await fs.writeFile(
+        path.join(testDir, 'CLAUDE.md'),
+        '# Enhanced Claude Configuration'
+      );
+
+      // Install configurations
+      const installResult = await installer.install({
+        dryRun: false,
+        skipBackup: false,
+      });
+
+      expect(installResult.success).toBe(true);
+      expect(installResult.installed.length).toBeGreaterThan(0);
+
+      // Verify all components installed
+      expect(existsSync(path.join(claudeDir, 'CLAUDE.md'))).toBe(true);
+      expect(existsSync(path.join(claudeDir, 'conventions.json'))).toBe(true);
+      expect(existsSync(path.join(claudeDir, 'hooks', 'pre-commit'))).toBe(true);
+      expect(existsSync(path.join(claudeDir, 'agents', 'backend-developer.json'))).toBe(
+        true
+      );
+      expect(
+        existsSync(path.join(claudeDir, 'workflows', 'feature-development.json'))
+      ).toBe(true);
+      expect(existsSync(path.join(claudeDir, 'scripts', 'validate-setup.sh'))).toBe(
+        true
+      );
+    });
+
+    it('should support complete backup and rollback cycle', async () => {
+      const backupManager = new BackupRollbackManager(backupDir);
+      const installer = new ClaudeConfigInstaller({
+        claudeDir,
+        sourceDir: testDir,
+      });
+
+      await backupManager.initialize();
+      await installer.initialize();
+
+      // Create initial config
+      const initialConfig = path.join(claudeDir, 'CLAUDE.md');
+      await fs.writeFile(initialConfig, 'Initial configuration');
+
+      // Create backup
+      const backup = await backupManager.createBackup(
+        [initialConfig],
+        'Pre-update backup'
+      );
+
+      // Update configuration
+      await fs.writeFile(initialConfig, 'Updated configuration');
+
+      // Rollback to original
+      const success = await backupManager.rollback({
+        backupId: backup.backupId,
+        dryRun: false,
+      });
+
+      expect(success).toBe(true);
+
+      // Verify rollback
+      const content = await fs.readFile(initialConfig, 'utf-8');
+      expect(content).toBe('Initial configuration');
+    });
+  });
+
+  describe('Error Handling', () => {
+    it('should handle missing source files gracefully', async () => {
+      const installer = new ClaudeConfigInstaller({
+        claudeDir,
+        sourceDir: testDir,
+      });
+
+      await installer.initialize();
+
+      // Don't create CLAUDE.md source
+      const result = await installer.install({
+        dryRun: false,
+        skipBackup: true,
+      });
+
+      // Should skip missing files
+      expect(result.skipped).toContain('CLAUDE.md');
+    });
+
+    it('should handle permission errors', async () => {
+      const installer = new ClaudeConfigInstaller({
+        claudeDir: '/root/unauthorized', // Likely no permission
+        sourceDir: testDir,
+      });
+
+      await expect(installer.initialize()).rejects.toThrow();
+    });
+
+    it('should handle corrupted backup metadata', async () => {
+      const backupManager = new BackupRollbackManager(backupDir);
+      await backupManager.initialize();
+
+      // Corrupt metadata file
+      const metadataPath = path.join(backupDir, 'metadata.json');
+      await fs.writeFile(metadataPath, 'invalid json {');
+
+      const backups = await backupManager.listBackups();
+      expect(backups).toEqual([]);
+    });
+  });
+});