@amrhas82/agentic-kit 1.2.0 → 1.2.1

package/tests/installer/cli.test.js

@@ -1,751 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * Comprehensive CLI Test Suite
- *
- * Tests the complete InteractiveInstaller CLI with:
- * - End-to-end installation flows
- * - User input validation
- * - Edge cases and boundary conditions
- * - Multi-tool installations
- * - Path customization scenarios
- * - Progress tracking accuracy
- * - Verification and reporting
- * - Error handling and recovery
- *
- * Coverage includes all CLI methods and workflows
- */
-
-const assert = require('assert');
-const fs = require('fs');
-const path = require('path');
-const os = require('os');
-const InteractiveInstaller = require('../../installer/cli.js');
-const PackageManager = require('../../installer/package-manager.js');
-const InstallationEngine = require('../../installer/installation-engine.js');
-
-// ANSI color codes
-const colors = {
-  reset: '\x1b[0m',
-  bright: '\x1b[1m',
-  green: '\x1b[32m',
-  red: '\x1b[31m',
-  yellow: '\x1b[33m',
-  cyan: '\x1b[36m',
-  blue: '\x1b[34m',
-  magenta: '\x1b[35m'
-};
-
-// Test results tracking
-let totalTests = 0;
-let passedTests = 0;
-let failedTests = 0;
-
-/**
- * Test helper - runs a test and tracks results
- */
-async function test(name, fn) {
-  totalTests++;
-  try {
-    await fn();
-    passedTests++;
-    console.log(`${colors.green}✓${colors.reset} ${name}`);
-  } catch (error) {
-    failedTests++;
-    console.log(`${colors.red}✗${colors.reset} ${name}`);
-    console.log(`  ${colors.red}Error: ${error.message}${colors.reset}`);
-    if (error.stack) {
-      const stack = error.stack.split('\n').slice(1, 3).join('\n');
-      console.log(`  ${colors.red}${stack}${colors.reset}`);
-    }
-  }
-}
-
-/**
- * Create temporary test directory
- */
-function createTempDir(prefix) {
-  const tempDir = path.join(
-    os.tmpdir(),
-    `${prefix}-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`
-  );
-  fs.mkdirSync(tempDir, { recursive: true });
-  return tempDir;
-}
-
-/**
- * Clean up temporary directory
- */
-function cleanupTempDir(dir) {
-  if (fs.existsSync(dir)) {
-    fs.rmSync(dir, { recursive: true, force: true });
-  }
-}
-
-// =============================================================================
-// Test Suite
-// =============================================================================
-
-async function runTests() {
-  console.log(`\n${colors.bright}${colors.cyan}Comprehensive CLI Test Suite${colors.reset}`);
-  console.log(`${colors.cyan}Testing: InteractiveInstaller${colors.reset}\n`);
-
-  // ===== Group 1: Constructor and Initialization =====
-  console.log(`${colors.blue}${colors.bright}Group 1: Constructor and Initialization${colors.reset}\n`);
-
-  await test('Constructor initializes with correct default state', async () => {
-    const installer = new InteractiveInstaller();
-
-    assert.ok(installer.selections, 'Should have selections object');
-    assert.strictEqual(installer.selections.variant, null, 'Variant should be null initially');
-    assert.ok(Array.isArray(installer.selections.tools), 'Tools should be an array');
-    assert.strictEqual(installer.selections.tools.length, 0, 'Tools should be empty initially');
-    assert.ok(installer.selections.paths, 'Paths should be initialized');
-    assert.strictEqual(Object.keys(installer.selections.paths).length, 0, 'Paths should be empty initially');
-  });
-
-  await test('Constructor initializes 4 tools with complete metadata', async () => {
-    const installer = new InteractiveInstaller();
-
-    assert.strictEqual(installer.tools.length, 4, 'Should have 4 tools');
-
-    const requiredFields = ['id', 'name', 'path', 'description', 'useCase', 'targetUsers'];
-    installer.tools.forEach(tool => {
-      requiredFields.forEach(field => {
-        assert.ok(tool[field], `Tool ${tool.id} should have ${field}`);
-        assert.ok(typeof tool[field] === 'string', `${field} should be a string`);
-        assert.ok(tool[field].length > 0, `${field} should not be empty`);
-      });
-    });
-  });
-
-  await test('Constructor initializes 3 variants with correct structure', async () => {
-    const installer = new InteractiveInstaller();
-
-    assert.strictEqual(installer.variants.length, 3, 'Should have 3 variants');
-
-    const expectedVariants = ['lite', 'standard', 'pro'];
-    installer.variants.forEach((variant, index) => {
-      assert.ok(variant.id, 'Variant should have id');
-      assert.ok(variant.name, 'Variant should have name');
-      assert.ok(typeof variant.agents === 'number', 'Variant should have agent count');
-      assert.ok(typeof variant.skills === 'number', 'Variant should have skill count');
-      assert.ok(variant.description, 'Variant should have description');
-      assert.strictEqual(variant.id, expectedVariants[index], `Variant ${index} should be ${expectedVariants[index]}`);
-    });
-  });
-
-  await test('Constructor initializes PackageManager', async () => {
-    const installer = new InteractiveInstaller();
-
-    assert.ok(installer.packageManager, 'Should have PackageManager instance');
-    assert.ok(installer.packageManager instanceof PackageManager, 'Should be instance of PackageManager');
-    assert.ok(installer.getPackageManager(), 'getPackageManager() should return instance');
-  });
-
-  // ===== Group 2: Error Categorization and Handling =====
-  console.log(`\n${colors.blue}${colors.bright}Group 2: Error Categorization and Handling${colors.reset}\n`);
-
-  await test('categorizeError identifies permission errors', async () => {
-    const installer = new InteractiveInstaller();
-
-    const error1 = new Error('Permission denied');
-    error1.code = 'EACCES';
-    const result1 = installer.categorizeError(error1);
-
-    assert.strictEqual(result1.type, 'Permission Error', 'Should identify EACCES as permission error');
-    assert.ok(result1.advice.length > 0, 'Should provide advice');
-    assert.ok(result1.advice.some(a => a.includes('sudo') || a.includes('permission')), 'Should mention permissions');
-  });
-
-  await test('categorizeError identifies disk space errors', async () => {
-    const installer = new InteractiveInstaller();
-
-    const error = new Error('No space left on device');
-    error.code = 'ENOSPC';
-    const result = installer.categorizeError(error);
-
-    assert.strictEqual(result.type, 'Disk Space Error', 'Should identify ENOSPC as disk space error');
-    assert.ok(result.advice.length > 0, 'Should provide advice');
-    assert.ok(result.advice.some(a => a.includes('space') || a.includes('disk')), 'Should mention disk space');
-  });
-
-  await test('categorizeError identifies network errors', async () => {
-    const installer = new InteractiveInstaller();
-
-    const error = new Error('Network connection failed');
-    error.code = 'ETIMEDOUT';
-    const result = installer.categorizeError(error);
-
-    assert.strictEqual(result.type, 'Network Error', 'Should identify ETIMEDOUT as network error');
-    assert.ok(result.advice.length > 0, 'Should provide advice');
-  });
-
-  await test('categorizeError identifies missing package errors', async () => {
-    const installer = new InteractiveInstaller();
-
-    const error = new Error('Package not found');
-    error.code = 'ENOENT';
-    const result = installer.categorizeError(error);
-
-    assert.strictEqual(result.type, 'Missing Package Error', 'Should identify ENOENT as missing package error');
-    assert.ok(result.advice.length > 0, 'Should provide advice');
-  });
-
-  await test('categorizeError identifies path validation errors', async () => {
-    const installer = new InteractiveInstaller();
-
-    const error = new Error('Path must be absolute');
-    const result = installer.categorizeError(error);
-
-    assert.strictEqual(result.type, 'Path Validation Error', 'Should identify path validation error');
-    assert.ok(result.advice.length > 0, 'Should provide advice');
-  });
-
-  await test('categorizeError identifies invalid input errors', async () => {
-    const installer = new InteractiveInstaller();
-
-    const error = new Error('Invalid tool selection');
-    const result = installer.categorizeError(error);
-
-    assert.strictEqual(result.type, 'Invalid Input Error', 'Should identify invalid input error');
-    assert.ok(result.advice.length > 0, 'Should provide advice');
-  });
-
-  await test('categorizeError identifies installation errors', async () => {
-    const installer = new InteractiveInstaller();
-
-    const error = new Error('Installation failed');
-    const result = installer.categorizeError(error);
-
-    assert.strictEqual(result.type, 'Installation Error', 'Should identify installation error');
-    assert.ok(result.advice.length > 0, 'Should provide advice');
-  });
-
-  await test('categorizeError handles unknown errors', async () => {
-    const installer = new InteractiveInstaller();
-
-    const error = new Error('Something completely unexpected');
-    const result = installer.categorizeError(error);
-
-    assert.strictEqual(result.type, 'Unknown Error', 'Should identify as unknown error');
-    assert.ok(result.advice.length > 0, 'Should provide advice');
-  });
-
-  await test('categorizeError provides distinct advice for different error types', async () => {
-    const installer = new InteractiveInstaller();
-
-    const permError = new Error('Permission denied');
-    permError.code = 'EACCES';
-    const diskError = new Error('No space left');
-    diskError.code = 'ENOSPC';
-
-    const perm = installer.categorizeError(permError);
-    const disk = installer.categorizeError(diskError);
-
-    assert.notStrictEqual(perm.advice[0], disk.advice[0], 'Different errors should have different advice');
-  });
-
-  // ===== Group 3: Path Validation =====
-  console.log(`\n${colors.blue}${colors.bright}Group 3: Path Validation${colors.reset}\n`);
-
-  await test('validatePath accepts absolute paths', async () => {
-    const installer = new InteractiveInstaller();
-    const tempDir = createTempDir('cli-test-validate-abs');
-
-    try {
-      const result = installer.validatePath(tempDir);
-
-      assert.ok(result.valid, 'Absolute path should be valid');
-      assert.ok(result.parentExists, 'Should recognize parent exists');
-      assert.strictEqual(result.issues.filter(i => i.severity === 'error').length, 0, 'Should have no error issues');
-    } finally {
-      cleanupTempDir(tempDir);
-    }
-  });
-
-  await test('validatePath rejects relative paths', async () => {
-    const installer = new InteractiveInstaller();
-
-    const result = installer.validatePath('./relative/path');
-
-    // Note: path.resolve() converts relative to absolute, but we can test with a clearly non-absolute path
-    // However, since the implementation uses path.resolve(), relative paths get converted
-    // Let's test that the validation still works correctly
-    assert.ok(result, 'Should return a result');
-    assert.ok(typeof result.valid === 'boolean', 'Should have valid flag');
-  });
-
-  await test('validatePath expands tilde paths', async () => {
-    const installer = new InteractiveInstaller();
-
-    const result = installer.validatePath('~/.test-path');
-
-    // The validation logic doesn't return expandedPath explicitly, but it processes it internally
-    assert.ok(result, 'Should return result');
-    assert.ok(typeof result.valid === 'boolean', 'Should have valid flag');
-    assert.ok(result.issues !== undefined, 'Should have issues array');
-  });
-
-  await test('validatePath checks parent directory existence', async () => {
-    const installer = new InteractiveInstaller();
-    const tempDir = createTempDir('cli-test-validate-parent');
-
-    try {
-      const validPath = path.join(tempDir, 'new-dir');
-      const invalidPath = path.join('/nonexistent-parent-dir-12345', 'new-dir');
-
-      const validResult = installer.validatePath(validPath);
-      const invalidResult = installer.validatePath(invalidPath);
-
-      assert.ok(validResult.parentExists, 'Should find existing parent');
-      assert.ok(!invalidResult.parentExists, 'Should detect non-existent parent');
-      // The implementation adds a warning about parent directory, not necessarily including the word "parent"
-      assert.ok(invalidResult.issues.some(i => i.message && (i.message.includes('parent') || i.message.includes('does not exist'))), 'Should report parent issue');
-    } finally {
-      cleanupTempDir(tempDir);
-    }
-  });
-
-  await test('validatePath checks write permissions', async () => {
-    const installer = new InteractiveInstaller();
-    const tempDir = createTempDir('cli-test-validate-perm');
-
-    try {
-      const result = installer.validatePath(path.join(tempDir, 'test-write'));
-
-      assert.ok(result.hasPermission, 'Should have permission in writable temp dir');
-    } finally {
-      cleanupTempDir(tempDir);
-    }
-  });
-
-  await test('validatePath checks disk space availability', async () => {
-    const installer = new InteractiveInstaller();
-    const tempDir = createTempDir('cli-test-validate-space');
-
-    try {
-      const result = installer.validatePath(tempDir);
-
-      assert.ok(typeof result.hasDiskSpace === 'boolean', 'Should check disk space');
-      // Note: The implementation doesn't return availableSpace/requiredSpace in the result object
-      // It only checks and sets hasDiskSpace flag
-    } finally {
-      cleanupTempDir(tempDir);
-    }
-  });
-
-  await test('validatePath detects existing installations', async () => {
-    const installer = new InteractiveInstaller();
-    const tempDir = createTempDir('cli-test-validate-exists');
-
-    try {
-      // Create a manifest to simulate existing installation
-      const manifestPath = path.join(tempDir, 'manifest.json');
-      fs.writeFileSync(manifestPath, JSON.stringify({ tool: 'claude', variant: 'standard' }));
-
-      const result = installer.validatePath(tempDir);
-
-      // The implementation checks if path exists and adds a warning
-      assert.ok(result.issues.some(i => i.message && i.message.includes('exist')), 'Should warn about existing path');
-    } finally {
-      cleanupTempDir(tempDir);
-    }
-  });
-
-  // ===== Group 4: Utility Methods =====
-  console.log(`\n${colors.blue}${colors.bright}Group 4: Utility Methods${colors.reset}\n`);
-
-  await test('formatBytes formats 0 bytes correctly', async () => {
-    const installer = new InteractiveInstaller();
-
-    const result = installer.formatBytes(0);
-
-    assert.strictEqual(result, '0 Bytes', 'Should format 0 as "0 Bytes"');
-  });
-
-  await test('formatBytes formats bytes correctly', async () => {
-    const installer = new InteractiveInstaller();
-
-    const result = installer.formatBytes(500);
-
-    assert.ok(result.includes('500'), 'Should include byte count');
-    assert.ok(result.includes('Bytes'), 'Should include "Bytes" unit');
-  });
-
-  await test('formatBytes formats kilobytes correctly', async () => {
-    const installer = new InteractiveInstaller();
-
-    const result = installer.formatBytes(1024 * 5.5);
-
-    assert.ok(result.includes('5.5'), 'Should include KB value');
-    assert.ok(result.includes('KB'), 'Should include "KB" unit');
-  });
-
-  await test('formatBytes formats megabytes correctly', async () => {
-    const installer = new InteractiveInstaller();
-
-    const result = installer.formatBytes(1024 * 1024 * 10);
-
-    assert.ok(result.includes('10'), 'Should include MB value');
-    assert.ok(result.includes('MB'), 'Should include "MB" unit');
-  });
-
-  await test('formatBytes formats gigabytes correctly', async () => {
-    const installer = new InteractiveInstaller();
-
-    const result = installer.formatBytes(1024 * 1024 * 1024 * 2);
-
-    assert.ok(result.includes('2'), 'Should include GB value');
-    assert.ok(result.includes('GB'), 'Should include "GB" unit');
-  });
-
-  // ===== Group 5: Progress Bar Rendering =====
-  console.log(`\n${colors.blue}${colors.bright}Group 5: Progress Bar Rendering${colors.reset}\n`);
-
-  await test('drawProgressBar writes to stdout (0% progress)', async () => {
-    const installer = new InteractiveInstaller();
-
-    // drawProgressBar writes to stdout and doesn't return a value
-    // We just test that it doesn't throw an error
-    assert.doesNotThrow(() => {
-      installer.drawProgressBar(0, 100, 0, 'test.js', 0, 1024, 0, 0, 0);
-    }, 'Should write progress bar without error');
-  });
-
-  await test('drawProgressBar writes to stdout (50% progress)', async () => {
-    const installer = new InteractiveInstaller();
-
-    assert.doesNotThrow(() => {
-      installer.drawProgressBar(50, 100, 50, 'test.js', 512, 1024, 100, 5, 5);
-    }, 'Should write progress bar without error');
-  });
-
-  await test('drawProgressBar writes to stdout (100% progress)', async () => {
-    const installer = new InteractiveInstaller();
-
-    assert.doesNotThrow(() => {
-      installer.drawProgressBar(100, 100, 100, 'final.js', 1024, 1024, 100, 10, 0);
-    }, 'Should write progress bar without error');
-  });
-
-  await test('drawProgressBar handles long filenames', async () => {
-    const installer = new InteractiveInstaller();
-
-    const longFilename = 'very-long-filename-that-should-be-truncated-because-it-is-too-long.js';
-
-    assert.doesNotThrow(() => {
-      installer.drawProgressBar(1, 10, 10, longFilename, 100, 1000, 50, 1, 9);
-    }, 'Should handle long filenames without error');
-  });
-
-  await test('drawOverallProgress writes to stdout', async () => {
-    const installer = new InteractiveInstaller();
-
-    assert.doesNotThrow(() => {
-      installer.drawOverallProgress(150, 300, 50, 2, 3);
-    }, 'Should write overall progress without error');
-  });
-
-  // ===== Group 6: Verification Report Display =====
-  console.log(`\n${colors.blue}${colors.bright}Group 6: Verification Report Display${colors.reset}\n`);
-
-  await test('displayVerificationReport shows valid installation', async () => {
-    const installer = new InteractiveInstaller();
-
-    const verification = {
-      valid: true,
-      targetPath: '/test/path',
-      variant: 'standard',
-      version: '1.0.0',
-      toolId: 'claude',
-      components: {
-        agents: { expected: 13, found: 13, missing: [] },
-        skills: { expected: 8, found: 8, missing: [] },
-        resources: { expected: 1, found: 1, missing: [] },
-        hooks: { expected: 2, found: 2, missing: [] }
-      },
-      issues: [],
-      warnings: []
-    };
-
-    // Capture output
-    let output = '';
-    const originalLog = console.log;
-    console.log = (...args) => { output += args.join(' ') + '\n'; };
-
-    try {
-      installer.displayVerificationReport(verification, 'claude');
-
-      assert.ok(output.includes('✓'), 'Should show success indicator');
-      assert.ok(output.includes('verified') || output.includes('passed'), 'Should mention success');
-      assert.ok(output.includes('13 agent'), 'Should show agent count');
-      assert.ok(output.includes('8 skill'), 'Should show skill count');
-    } finally {
-      console.log = originalLog;
-    }
-  });
-
-  await test('displayVerificationReport shows failed installation', async () => {
-    const installer = new InteractiveInstaller();
-
-    const verification = {
-      valid: false,
-      targetPath: '/test/path',
-      variant: 'standard',
-      version: '1.0.0',
-      toolId: 'claude',
-      components: {
-        agents: { expected: 13, found: 11, missing: ['agent1.md', 'agent2.md'] },
-        skills: { expected: 8, found: 8, missing: [] },
-        resources: { expected: 1, found: 1, missing: [] },
-        hooks: { expected: 2, found: 2, missing: [] }
-      },
-      issues: [
-        { message: 'Missing file: agent1.md' },
-        { message: 'Missing file: agent2.md' }
-      ],
-      warnings: []
-    };
-
-    let output = '';
-    const originalLog = console.log;
-    console.log = (...args) => { output += args.join(' ') + '\n'; };
-
-    try {
-      installer.displayVerificationReport(verification, 'claude');
-
-      assert.ok(output.includes('✗') || output.includes('failed'), 'Should show failure indicator');
-      assert.ok(output.includes('agent1.md'), 'Should list missing file');
-      assert.ok(output.includes('agent2.md'), 'Should list missing file');
-    } finally {
-      console.log = originalLog;
-    }
-  });
-
-  await test('displayVerificationReport shows warnings', async () => {
-    const installer = new InteractiveInstaller();
-
-    const verification = {
-      valid: true,
-      targetPath: '/test/path',
-      variant: 'standard',
-      version: '1.0.0',
-      toolId: 'claude',
-      components: {
-        agents: { expected: 13, found: 13, missing: [] },
-        skills: { expected: 8, found: 8, missing: [] },
-        resources: { expected: 1, found: 1, missing: [] },
-        hooks: { expected: 2, found: 2, missing: [] }
-      },
-      issues: [],
-      warnings: [
-        { message: 'Permission warning' },
-        { message: 'Path warning' }
-      ]
-    };
-
-    let output = '';
-    const originalLog = console.log;
-    console.log = (...args) => { output += args.join(' ') + '\n'; };
-
-    try {
-      installer.displayVerificationReport(verification, 'claude');
-
-      assert.ok(output.includes('Permission warning'), 'Should show warning');
-      assert.ok(output.includes('Path warning'), 'Should show warning');
-    } finally {
-      console.log = originalLog;
-    }
-  });
-
-  // ===== Group 7: Installation Report Generation =====
-  console.log(`\n${colors.blue}${colors.bright}Group 7: Installation Report Generation${colors.reset}\n`);
-
-  await test('generateInstallationReport creates report file', async () => {
-    const installer = new InteractiveInstaller();
-    const tempDir = createTempDir('cli-test-report');
-
-    // Set up installer selections to match what generateInstallationReport expects
-    installer.selections.variant = 'standard';
-    installer.selections.tools = ['claude'];
-
-    try {
-      const successfulInstalls = [
-        {
-          name: 'Claude Code',
-          toolId: 'claude',
-          path: tempDir,
-          fileCount: 24,
-          elapsedMs: 1500
-        }
-      ];
-
-      const verificationResults = [
-        {
-          valid: true,
-          components: {
-            agents: { expected: 13, found: 13, missing: [] },
-            skills: { expected: 8, found: 8, missing: [] },
-            resources: { expected: 1, found: 1, missing: [] },
-            hooks: { expected: 2, found: 2, missing: [] }
-          },
-          issues: [],
-          warnings: []
-        }
-      ];
-
-      await installer.generateInstallationReport(successfulInstalls, [], verificationResults, 2000);
-
-      const reportPath = path.join(os.homedir(), '.agentic-kit-install.log');
-      assert.ok(fs.existsSync(reportPath), 'Should create report file');
-
-      const content = fs.readFileSync(reportPath, 'utf8');
-      assert.ok(content.includes('claude'), 'Should include tool id');
-      assert.ok(content.includes('standard'), 'Should include variant');
-      assert.ok(content.includes('24'), 'Should include file count');
-    } finally {
-      cleanupTempDir(tempDir);
-      const reportPath = path.join(os.homedir(), '.agentic-kit-install.log');
-      if (fs.existsSync(reportPath)) {
-        fs.unlinkSync(reportPath);
-      }
-    }
-  });
-
-  await test('generateInstallationReport includes failed installations', async () => {
-    const installer = new InteractiveInstaller();
-
-    // Set up installer selections
-    installer.selections.variant = 'standard';
-    installer.selections.tools = ['opencode'];
-
-    try {
-      const failedInstalls = [
-        {
-          name: 'Opencode',
-          toolId: 'opencode',
-          path: '/tmp/test',
-          error: 'Installation failed',
-          errorType: 'Installation Error'
-        }
-      ];
-
-      await installer.generateInstallationReport([], failedInstalls, [], 1000);
-
-      const reportPath = path.join(os.homedir(), '.agentic-kit-install.log');
-      assert.ok(fs.existsSync(reportPath), 'Should create report file');
-
-      const content = fs.readFileSync(reportPath, 'utf8');
-      assert.ok(content.includes('opencode'), 'Should include failed tool');
-      assert.ok(content.includes('failed') || content.includes('Failed'), 'Should mention failure');
-    } finally {
-      const reportPath = path.join(os.homedir(), '.agentic-kit-install.log');
-      if (fs.existsSync(reportPath)) {
-        fs.unlinkSync(reportPath);
-      }
-    }
-  });
-
-  // ===== Group 8: Integration Tests =====
-  console.log(`\n${colors.blue}${colors.bright}Group 8: Integration Tests${colors.reset}\n`);
-
-  await test('CLI integrates with PackageManager correctly', async () => {
-    const installer = new InteractiveInstaller();
-
-    const packageManager = installer.getPackageManager();
-
-    assert.ok(packageManager, 'Should have PackageManager');
-    assert.ok(typeof packageManager.getPackageContents === 'function', 'Should have getPackageContents method');
-    assert.ok(typeof packageManager.getPackageSize === 'function', 'Should have getPackageSize method');
-    assert.ok(typeof packageManager.validatePackage === 'function', 'Should have validatePackage method');
-  });
-
-  await test('CLI can retrieve package information', async () => {
-    const installer = new InteractiveInstaller();
-    const packageManager = installer.getPackageManager();
-
-    try {
-      const contents = packageManager.getPackageContents('claude', 'standard');
-
-      assert.ok(contents, 'Should get package contents');
-      assert.ok(typeof contents.totalFiles === 'number', 'Should have totalFiles count');
-    } catch (error) {
-      // Package might not exist in test environment, that's okay
-      // Just verify we get an error object
-      assert.ok(error, 'Should get error for missing package');
-      assert.ok(error.message, 'Error should have message');
-    }
-  });
-
-  await test('Pre-installation checks validate Node.js version', async () => {
-    const installer = new InteractiveInstaller();
-
-    // Set up minimal selections
-    installer.selections.variant = 'standard';
-    installer.selections.tools = ['claude'];
-    installer.selections.paths = { claude: createTempDir('cli-test-node-check') };
-
-    try {
-      const result = await installer.performPreInstallationChecks();
-
-      assert.ok(result, 'Should return check result');
-      assert.ok(typeof result.success === 'boolean', 'Should have success flag');
-      assert.ok(Array.isArray(result.warnings), 'Should have warnings array');
-      assert.ok(Array.isArray(result.errors), 'Should have errors array');
-    } finally {
-      cleanupTempDir(installer.selections.paths.claude);
-    }
-  });
-
-  await test('Pre-installation checks validate paths', async () => {
-    const installer = new InteractiveInstaller();
-    const tempDir = createTempDir('cli-test-path-check');
-
-    installer.selections.variant = 'standard';
-    installer.selections.tools = ['claude'];
-    installer.selections.paths = { claude: tempDir };
-
-    try {
-      const result = await installer.performPreInstallationChecks();
-
-      // Should validate the path exists and is writable
-      if (result.success) {
-        assert.ok(true, 'Path validation passed');
-      } else {
-        // Might fail if package doesn't exist, but should still validate path
-        assert.ok(result.errors.some(e => e.includes('package')) ||
-                 result.errors.some(e => e.includes('path')),
-          'Errors should be related to package or path');
-      }
-    } finally {
-      cleanupTempDir(tempDir);
-    }
-  });
-
-  // ===== Test Summary =====
-  console.log(`\n${colors.bright}${colors.cyan}═══════════════════════════════════════════════════════${colors.reset}`);
-  console.log(`${colors.bright}Test Summary${colors.reset}`);
-  console.log(`${colors.cyan}═══════════════════════════════════════════════════════${colors.reset}`);
-  console.log(`Total:  ${totalTests}`);
-  console.log(`${colors.green}Passed: ${passedTests}${colors.reset}`);
-  console.log(`${colors.red}Failed: ${failedTests}${colors.reset}`);
-  console.log(`${colors.cyan}═══════════════════════════════════════════════════════${colors.reset}\n`);
-
-  if (failedTests === 0) {
-    console.log(`${colors.green}${colors.bright}✓ All CLI tests passed!${colors.reset}\n`);
-  } else {
-    console.log(`${colors.red}${colors.bright}✗ Some tests failed${colors.reset}\n`);
-    process.exit(1);
-  }
-}
-
-// Run tests
-if (require.main === module) {
-  runTests().catch(error => {
-    console.error(`${colors.red}Fatal error running tests:${colors.reset}`, error);
-    process.exit(1);
-  });
-}
-
-module.exports = { runTests };