@amrhas82/agentic-kit 1.2.0 → 1.2.1

package/tests/installer/test-error-handling.js

@@ -1,387 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * Test suite for CLI error handling and rollback options
- *
- * Tests:
- * 1. Error categorization for different error types
- * 2. Fatal error handling with actionable advice
- * 3. Pre-installation checks
- * 4. Recovery options during installation
- * 5. Rollback on failure
- */
-
-const InteractiveInstaller = require('../../installer/cli');
-const assert = require('assert');
-const fs = require('fs');
-const path = require('path');
-const os = require('os');
-
-// Test counters
-let testsRun = 0;
-let testsPassed = 0;
-let testsFailed = 0;
-
-// ANSI color codes
-const colors = {
-  reset: '\x1b[0m',
-  green: '\x1b[32m',
-  red: '\x1b[31m',
-  yellow: '\x1b[33m',
-  cyan: '\x1b[36m',
-  bright: '\x1b[1m'
-};
-
-/**
- * Test helper function
- */
-function test(name, fn) {
-  testsRun++;
-  try {
-    fn();
-    testsPassed++;
-    console.log(`${colors.green}✓${colors.reset} ${name}`);
-  } catch (error) {
-    testsFailed++;
-    console.log(`${colors.red}✗${colors.reset} ${name}`);
-    console.log(`  ${colors.red}Error:${colors.reset} ${error.message}`);
-    if (error.stack) {
-      console.log(`  ${colors.red}Stack:${colors.reset} ${error.stack.split('\n')[1]?.trim()}`);
-    }
-  }
-}
-
-/**
- * Async test helper
- */
-async function testAsync(name, fn) {
-  testsRun++;
-  try {
-    await fn();
-    testsPassed++;
-    console.log(`${colors.green}✓${colors.reset} ${name}`);
-  } catch (error) {
-    testsFailed++;
-    console.log(`${colors.red}✗${colors.reset} ${name}`);
-    console.log(`  ${colors.red}Error:${colors.reset} ${error.message}`);
-    if (error.stack) {
-      console.log(`  ${colors.red}Stack:${colors.reset} ${error.stack.split('\n')[1]?.trim()}`);
-    }
-  }
-}
-
-console.log(`${colors.cyan}${colors.bright}Testing CLI Error Handling and Rollback${colors.reset}\n`);
-
-// Test 1: Error categorization - Permission errors
-test('Categorizes EACCES permission errors correctly', () => {
-  const installer = new InteractiveInstaller();
-  const error = new Error('Permission denied');
-  error.code = 'EACCES';
-
-  const result = installer.categorizeError(error);
-
-  assert.strictEqual(result.type, 'Permission Error');
-  assert(result.advice.length > 0, 'Should provide advice');
-  assert(result.advice.some(a => a.includes('sudo')), 'Should suggest using sudo');
-  assert(result.technicalDetails, 'Should include technical details');
-});
-
-// Test 2: Error categorization - Disk space errors
-test('Categorizes ENOSPC disk space errors correctly', () => {
-  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');
-  assert(result.advice.some(a => a.includes('disk space')), 'Should mention disk space');
-  assert(result.advice.some(a => a.includes('df -h')), 'Should suggest df -h command');
-});
-
-// Test 3: Error categorization - Network errors
-test('Categorizes network errors correctly', () => {
-  const installer = new InteractiveInstaller();
-  const error = new Error('Network timeout');
-  error.code = 'ETIMEDOUT';
-
-  const result = installer.categorizeError(error);
-
-  assert.strictEqual(result.type, 'Network Error');
-  assert(result.advice.some(a => a.includes('connection') || a.includes('internet')), 'Should mention connection');
-});
-
-// Test 4: Error categorization - Missing package errors
-test('Categorizes missing package/file errors correctly', () => {
-  const installer = new InteractiveInstaller();
-  const error = new Error('No such file or directory');
-  error.code = 'ENOENT';
-
-  const result = installer.categorizeError(error);
-
-  assert.strictEqual(result.type, 'Missing Package Error');
-  assert(result.advice.some(a => a.includes('npm install') || a.includes('agentic-kit')), 'Should suggest reinstalling');
-});
-
-// Test 5: Error categorization - Invalid input errors
-test('Categorizes invalid input errors correctly', () => {
-  const installer = new InteractiveInstaller();
-  const error = new Error('At least one tool must be selected');
-
-  const result = installer.categorizeError(error);
-
-  assert.strictEqual(result.type, 'Invalid Input Error');
-  assert(result.advice.length > 0, 'Should provide advice');
-});
-
-// Test 6: Error categorization - Path validation errors
-test('Categorizes path validation errors correctly', () => {
-  const installer = new InteractiveInstaller();
-  const error = new Error('Path must be absolute');
-
-  const result = installer.categorizeError(error);
-
-  assert.strictEqual(result.type, 'Path Validation Error');
-  assert(result.advice.some(a => a.includes('absolute')), 'Should mention absolute paths');
-});
-
-// Test 7: Error categorization - Installation errors
-test('Categorizes installation errors correctly', () => {
-  const installer = new InteractiveInstaller();
-  const error = new Error('Failed to install package');
-
-  const result = installer.categorizeError(error);
-
-  assert.strictEqual(result.type, 'Installation Error');
-  assert(result.advice.some(a => a.includes('disk space') || a.includes('permission')), 'Should suggest common fixes');
-});
-
-// Test 8: Error categorization - Unknown errors
-test('Categorizes unknown errors correctly', () => {
-  const installer = new InteractiveInstaller();
-  const error = new Error('Some random unexpected error');
-
-  const result = installer.categorizeError(error);
-
-  assert.strictEqual(result.type, 'Unknown Error');
-  assert(result.advice.some(a => a.includes('report') || a.includes('issue')), 'Should suggest reporting the issue');
-});
-
-// Test 9: Pre-installation checks - Valid setup
-testAsync('Pre-installation checks pass with valid setup', async () => {
-  const installer = new InteractiveInstaller();
-
-  // Set up valid selections
-  installer.selections = {
-    variant: 'lite',
-    tools: ['claude'],
-    paths: {
-      'claude': '~/.claude-test-' + Date.now()
-    }
-  };
-
-  const result = await installer.performPreInstallationChecks();
-
-  // Should succeed or have only warnings (not errors)
-  assert(result.errors.length === 0, `Should have no errors, but got: ${result.errors.join(', ')}`);
-});
-
-// Test 10: Pre-installation checks - Invalid tool
-testAsync('Pre-installation checks fail with invalid tool', async () => {
-  const installer = new InteractiveInstaller();
-
-  // Set up invalid selections
-  installer.selections = {
-    variant: 'lite',
-    tools: ['invalid-tool-12345'],
-    paths: {
-      'invalid-tool-12345': '~/.invalid-tool'
-    }
-  };
-
-  const result = await installer.performPreInstallationChecks();
-
-  // Should have errors
-  assert(result.errors.length > 0, 'Should have errors for invalid tool');
-  assert(!result.success, 'Should not succeed with invalid tool');
-});
-
-// Test 11: Pre-installation checks - Invalid path
-testAsync('Pre-installation checks detect invalid paths', async () => {
-  const installer = new InteractiveInstaller();
-
-  // Set up selections with unwritable path
-  installer.selections = {
-    variant: 'lite',
-    tools: ['claude'],
-    paths: {
-      'claude': '/root/restricted-path-' + Date.now()  // Typically not writable
-    }
-  };
-
-  const result = await installer.performPreInstallationChecks();
-
-  // Should have errors or warnings about permissions
-  const hasPermissionIssue = result.errors.some(e => e.includes('permission')) ||
-                             result.warnings.some(w => w.includes('permission'));
-
-  // On some systems root might be writable with sudo, so check for either errors or that checks ran
-  assert(result.errors.length > 0 || result.warnings.length >= 0, 'Should detect permission issues or run checks');
-});
-
-// Test 12: Pre-installation checks - Existing installation
-testAsync('Pre-installation checks warn about existing installations', async () => {
-  const installer = new InteractiveInstaller();
-  const testPath = path.join(os.tmpdir(), '.claude-test-existing-' + Date.now());
-
-  // Create existing installation with manifest
-  fs.mkdirSync(testPath, { recursive: true });
-  fs.writeFileSync(path.join(testPath, 'manifest.json'), JSON.stringify({
-    tool: 'claude',
-    variant: 'lite',
-    version: '1.0.0'
-  }));
-  fs.writeFileSync(path.join(testPath, 'test-file.txt'), 'test content');
-
-  installer.selections = {
-    variant: 'lite',
-    tools: ['claude'],
-    paths: {
-      'claude': testPath
-    }
-  };
-
-  const result = await installer.performPreInstallationChecks();
-
-  // Clean up
-  fs.unlinkSync(path.join(testPath, 'test-file.txt'));
-  fs.unlinkSync(path.join(testPath, 'manifest.json'));
-  fs.rmdirSync(testPath);
-
-  // Should warn about existing files
-  assert(result.warnings.some(w => w.includes('already exists')), 'Should warn about existing installation');
-});
-
-// Test 13: handleFatalError includes error type
-test('handleFatalError includes categorized error type', () => {
-  const installer = new InteractiveInstaller();
-
-  // Mock categorizeError to return known result
-  const originalCategorize = installer.categorizeError;
-  installer.categorizeError = (error) => ({
-    type: 'Test Error Type',
-    advice: ['Test advice 1', 'Test advice 2'],
-    technicalDetails: 'Test details'
-  });
-
-  // Create mock error
-  const error = new Error('Test error message');
-
-  // Verify categorizeError is called
-  const result = installer.categorizeError(error);
-  assert.strictEqual(result.type, 'Test Error Type');
-  assert.strictEqual(result.advice.length, 2);
-
-  // Restore original
-  installer.categorizeError = originalCategorize;
-});
-
-// Test 14: Error advice is actionable
-test('Error advice contains actionable commands', () => {
-  const installer = new InteractiveInstaller();
-  const error = new Error('Permission denied');
-  error.code = 'EACCES';
-
-  const result = installer.categorizeError(error);
-
-  // Check that advice includes specific commands or actions
-  const hasActionableAdvice = result.advice.some(advice =>
-    advice.includes('sudo') ||
-    advice.includes('ls -la') ||
-    advice.includes('chmod') ||
-    advice.toLowerCase().includes('try') ||
-    advice.toLowerCase().includes('check')
-  );
-
-  assert(hasActionableAdvice, 'Advice should contain actionable commands or steps');
-});
-
-// Test 15: Multiple error types have distinct advice
-test('Different error types provide distinct advice', () => {
-  const installer = new InteractiveInstaller();
-
-  const permissionError = new Error('Permission denied');
-  permissionError.code = 'EACCES';
-
-  const diskError = new Error('No space left');
-  diskError.code = 'ENOSPC';
-
-  const result1 = installer.categorizeError(permissionError);
-  const result2 = installer.categorizeError(diskError);
-
-  assert.notStrictEqual(result1.type, result2.type, 'Error types should be different');
-  assert.notDeepStrictEqual(result1.advice, result2.advice, 'Advice should be different');
-});
-
-// Test 16: Pre-installation checks validate Node version
-testAsync('Pre-installation checks validate Node.js version', async () => {
-  const installer = new InteractiveInstaller();
-
-  installer.selections = {
-    variant: 'lite',
-    tools: ['claude'],
-    paths: {
-      'claude': '~/.claude-test'
-    }
-  };
-
-  // Mock process.version temporarily
-  const originalVersion = process.version;
-
-  const result = await installer.performPreInstallationChecks();
-
-  // Current Node version should pass (we're running the test)
-  // This confirms the version check logic exists
-  const nodeVersion = process.version;
-  const majorVersion = parseInt(nodeVersion.slice(1).split('.')[0]);
-
-  if (majorVersion >= 14) {
-    assert(!result.errors.some(e => e.includes('Node.js version')), 'Should not error on valid Node version');
-  }
-});
-
-// Test 17: Pre-installation checks are comprehensive
-testAsync('Pre-installation checks cover all required areas', async () => {
-  const installer = new InteractiveInstaller();
-
-  installer.selections = {
-    variant: 'lite',
-    tools: ['claude'],
-    paths: {
-      'claude': '~/.claude-test'
-    }
-  };
-
-  const result = await installer.performPreInstallationChecks();
-
-  // Result should have all expected properties
-  assert(typeof result.success === 'boolean', 'Should have success flag');
-  assert(Array.isArray(result.errors), 'Should have errors array');
-  assert(Array.isArray(result.warnings), 'Should have warnings array');
-});
-
-// Print summary
-console.log(`\n${colors.cyan}${colors.bright}${'='.repeat(60)}${colors.reset}`);
-console.log(`${colors.bright}Test Summary${colors.reset}`);
-console.log(`${colors.cyan}${'='.repeat(60)}${colors.reset}`);
-console.log(`Tests run: ${testsRun}`);
-console.log(`${colors.green}Passed: ${testsPassed}${colors.reset}`);
-console.log(`${colors.red}Failed: ${testsFailed}${colors.reset}`);
-
-if (testsFailed > 0) {
-  console.log(`\n${colors.red}${colors.bright}Some tests failed${colors.reset}`);
-  process.exit(1);
-} else {
-  console.log(`\n${colors.green}${colors.bright}All tests passed!${colors.reset}`);
-  process.exit(0);
-}

package/tests/installer/test-install-method.js

@@ -1,305 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * Manual test for CLI install() method with real-time progress bars
- *
- * Tests the enhanced install() method with:
- * - Real InstallationEngine integration
- * - Real-time progress bar display
- * - Multi-tool installation
- * - Success/failure handling
- * - Overall progress tracking
- */
-
-const fs = require('fs');
-const path = require('path');
-const InteractiveInstaller = require('../../installer/cli');
-
-// ANSI colors for test output
-const colors = {
-  reset: '\x1b[0m',
-  bright: '\x1b[1m',
-  green: '\x1b[32m',
-  blue: '\x1b[34m',
-  yellow: '\x1b[33m',
-  cyan: '\x1b[36m',
-  red: '\x1b[31m'
-};
-
-// Test utilities
-const tests = [];
-const results = { passed: 0, failed: 0 };
-
-function test(name, fn) {
-  tests.push({ name, fn });
-}
-
-async function runTests() {
-  console.log(`${colors.bright}${colors.cyan}Testing CLI install() Method with Progress Bars${colors.reset}\n`);
-
-  for (const t of tests) {
-    try {
-      await t.fn();
-      results.passed++;
-      console.log(`${colors.green}✓${colors.reset} ${t.name}`);
-    } catch (error) {
-      results.failed++;
-      console.log(`${colors.red}✗${colors.reset} ${t.name}`);
-      console.log(`  ${colors.red}Error: ${error.message}${colors.reset}`);
-    }
-  }
-
-  console.log(`\n${colors.bright}Test Summary${colors.reset}`);
-  console.log(`Total: ${tests.length}`);
-  console.log(`${colors.green}Passed: ${results.passed}${colors.reset}`);
-  if (results.failed > 0) {
-    console.log(`${colors.red}Failed: ${results.failed}${colors.reset}`);
-  }
-
-  if (results.failed === 0) {
-    console.log(`\n${colors.green}${colors.bright}All tests passed!${colors.reset}`);
-  } else {
-    process.exit(1);
-  }
-}
-
-// Create temporary test directory
-const tmpDir = path.join(__dirname, '../tmp', `test-cli-install-${Date.now()}`);
-fs.mkdirSync(tmpDir, { recursive: true });
-
-// Test 1: Install single tool with progress tracking
-test('Install single tool (Claude Lite) with progress tracking', async () => {
-  const installer = new InteractiveInstaller();
-
-  // Mock readline close
-  installer.rl.close = () => {};
-
-  // Set up selections
-  installer.selections = {
-    variant: 'lite',
-    tools: ['claude'],
-    paths: {
-      claude: path.join(tmpDir, 'claude-lite-test')
-    }
-  };
-
-  // Track progress callbacks
-  let progressCallbacks = 0;
-
-  // Spy on drawProgressBar
-  const originalDrawProgressBar = installer.drawProgressBar.bind(installer);
-  installer.drawProgressBar = (...args) => {
-    progressCallbacks++;
-    // Don't actually draw during test (avoid console spam)
-    // originalDrawProgressBar(...args);
-  };
-
-  // Run installation
-  await installer.install();
-
-  // Verify installation
-  const manifestPath = path.join(tmpDir, 'claude-lite-test', 'manifest.json');
-  if (!fs.existsSync(manifestPath)) {
-    throw new Error('Manifest not created');
-  }
-
-  const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
-  if (manifest.variant !== 'lite') {
-    throw new Error(`Expected variant 'lite', got '${manifest.variant}'`);
-  }
-
-  if (manifest.components.agents !== 3) {
-    throw new Error(`Expected 3 agents, got ${manifest.components.agents}`);
-  }
-
-  if (progressCallbacks === 0) {
-    throw new Error('Progress callbacks were not called');
-  }
-
-  console.log(`  ${colors.cyan}Progress callbacks: ${progressCallbacks}${colors.reset}`);
-});
-
-// Test 2: Install multiple tools with progress tracking
-test('Install multiple tools (Claude + Opencode) with progress tracking', async () => {
-  const installer = new InteractiveInstaller();
-
-  // Mock readline close
-  installer.rl.close = () => {};
-
-  // Set up selections
-  installer.selections = {
-    variant: 'lite',
-    tools: ['claude', 'opencode'],
-    paths: {
-      claude: path.join(tmpDir, 'multi-claude'),
-      opencode: path.join(tmpDir, 'multi-opencode')
-    }
-  };
-
-  // Track progress callbacks per tool
-  let totalProgressCallbacks = 0;
-
-  // Spy on drawProgressBar
-  installer.drawProgressBar = (...args) => {
-    totalProgressCallbacks++;
-  };
-
-  // Run installation
-  await installer.install();
-
-  // Verify both installations
-  const claudeManifestPath = path.join(tmpDir, 'multi-claude', 'manifest.json');
-  const opencodeManifestPath = path.join(tmpDir, 'multi-opencode', 'manifest.json');
-
-  if (!fs.existsSync(claudeManifestPath)) {
-    throw new Error('Claude manifest not created');
-  }
-
-  if (!fs.existsSync(opencodeManifestPath)) {
-    throw new Error('Opencode manifest not created');
-  }
-
-  if (totalProgressCallbacks === 0) {
-    throw new Error('Progress callbacks were not called');
-  }
-
-  console.log(`  ${colors.cyan}Total progress callbacks: ${totalProgressCallbacks}${colors.reset}`);
-});
-
-// Test 3: Test installation failure and rollback
-test('Installation failure triggers rollback with proper error handling', async () => {
-  const installer = new InteractiveInstaller();
-
-  // Mock readline close
-  installer.rl.close = () => {};
-
-  // Set up selections with invalid tool
-  installer.selections = {
-    variant: 'lite',
-    tools: ['claude', 'invalid-tool'],
-    paths: {
-      claude: path.join(tmpDir, 'rollback-test-claude'),
-      'invalid-tool': path.join(tmpDir, 'rollback-test-invalid')
-    }
-  };
-
-  // Track progress callbacks
-  let progressCallbacks = 0;
-  installer.drawProgressBar = (...args) => {
-    progressCallbacks++;
-  };
-
-  // Run installation (should partially succeed, partially fail)
-  await installer.install();
-
-  // Verify Claude was installed successfully
-  const claudeManifestPath = path.join(tmpDir, 'rollback-test-claude', 'manifest.json');
-  if (!fs.existsSync(claudeManifestPath)) {
-    throw new Error('Claude should have been installed successfully');
-  }
-
-  // Verify invalid tool was not installed (rollback should have cleaned up)
-  const invalidToolPath = path.join(tmpDir, 'rollback-test-invalid');
-  const invalidManifestPath = path.join(invalidToolPath, 'manifest.json');
-  if (fs.existsSync(invalidManifestPath)) {
-    throw new Error('Invalid tool should not have manifest after rollback');
-  }
-
-  console.log(`  ${colors.cyan}Successfully handled partial failure with rollback${colors.reset}`);
-});
-
-// Test 4: Test progress bar helper methods
-test('Progress bar helper methods work correctly', async () => {
-  const installer = new InteractiveInstaller();
-
-  // Test drawProgressBar doesn't throw errors
-  installer.drawProgressBar(50, 100, 50, 'test/file.txt', '1.5 MB', '3 MB', '500 KB', '0:30', '0:30');
-
-  // Clear the progress bar output
-  process.stdout.write('\x1b[2K\r');
-  process.stdout.write('\x1b[1A\x1b[2K\r');
-
-  // Test drawOverallProgress doesn't throw errors
-  installer.drawOverallProgress(150, 300, 50, 2, 3);
-
-  // Clear the overall progress output
-  process.stdout.write('\x1b[2K\r');
-
-  console.log(`  ${colors.cyan}Progress bar rendering methods work correctly${colors.reset}`);
-});
-
-// Test 5: Test formatBytes helper
-test('formatBytes helper formats sizes correctly', async () => {
-  const installer = new InteractiveInstaller();
-
-  const tests = [
-    { bytes: 0, expected: '0 Bytes' },
-    { bytes: 1024, expected: '1 KB' },
-    { bytes: 1024 * 1024, expected: '1 MB' },
-    { bytes: 1536 * 1024, expected: '1.5 MB' },
-    { bytes: 8.39 * 1024 * 1024, expected: '8.39 MB' }
-  ];
-
-  for (const t of tests) {
-    const result = installer.formatBytes(t.bytes);
-    if (result !== t.expected) {
-      throw new Error(`formatBytes(${t.bytes}) expected '${t.expected}', got '${result}'`);
-    }
-  }
-
-  console.log(`  ${colors.cyan}All byte format conversions correct${colors.reset}`);
-});
-
-// Test 6: Test Standard variant installation
-test('Install Standard variant with progress tracking', async () => {
-  const installer = new InteractiveInstaller();
-
-  // Mock readline close
-  installer.rl.close = () => {};
-
-  // Set up selections
-  installer.selections = {
-    variant: 'standard',
-    tools: ['claude'],
-    paths: {
-      claude: path.join(tmpDir, 'claude-standard-test')
-    }
-  };
-
-  // Track progress
-  let progressCallbacks = 0;
-  installer.drawProgressBar = (...args) => {
-    progressCallbacks++;
-  };
-
-  // Run installation
-  await installer.install();
-
-  // Verify installation
-  const manifestPath = path.join(tmpDir, 'claude-standard-test', 'manifest.json');
-  if (!fs.existsSync(manifestPath)) {
-    throw new Error('Manifest not created');
-  }
-
-  const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
-  if (manifest.variant !== 'standard') {
-    throw new Error(`Expected variant 'standard', got '${manifest.variant}'`);
-  }
-
-  if (manifest.components.agents !== 13) {
-    throw new Error(`Expected 13 agents, got ${manifest.components.agents}`);
-  }
-
-  if (manifest.components.skills !== 8) {
-    throw new Error(`Expected 8 skills, got ${manifest.components.skills}`);
-  }
-
-  if (progressCallbacks === 0) {
-    throw new Error('Progress callbacks were not called');
-  }
-
-  console.log(`  ${colors.cyan}Standard variant: 13 agents, 8 skills, ${progressCallbacks} progress updates${colors.reset}`);
-});
-
-// Run all tests
-runTests().catch(console.error);