@amrhas82/agentic-kit 1.2.0 → 1.2.1

package/tests/installer/installation-engine.test.js

@@ -1,1540 +0,0 @@
-/**
- * Tests for InstallationEngine with variant support
- *
- * Tests variant-based installation, selective file copying, and manifest generation
- */
-
-const assert = require('assert');
-const fs = require('fs');
-const path = require('path');
-const InstallationEngine = require('../../installer/installation-engine.js');
-const PackageManager = require('../../installer/package-manager.js');
-const PathManager = require('../../installer/path-manager.js');
-
-// ANSI color codes for test output
-const colors = {
-  reset: '\x1b[0m',
-  bright: '\x1b[1m',
-  green: '\x1b[32m',
-  red: '\x1b[31m',
-  yellow: '\x1b[33m',
-  blue: '\x1b[34m',
-  cyan: '\x1b[36m'
-};
-
-// 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) {
-      console.log(`  ${colors.red}${error.stack.split('\n').slice(1, 3).join('\n')}${colors.reset}`);
-    }
-  }
-}
-
-/**
- * Test helper - create temporary test directory
- */
-async function createTempDir(name) {
-  const tmpDir = path.join(__dirname, '..', 'tmp', `test-${name}-${Date.now()}`);
-  await fs.promises.mkdir(tmpDir, { recursive: true });
-  return tmpDir;
-}
-
-/**
- * Test helper - cleanup temporary directory
- */
-async function cleanupTempDir(dir) {
-  try {
-    if (fs.existsSync(dir)) {
-      await fs.promises.rm(dir, { recursive: true, force: true });
-    }
-  } catch (error) {
-    console.warn(`Warning: Could not clean up ${dir}: ${error.message}`);
-  }
-}
-
-/**
- * Test helper - create mock package structure for testing
- */
-async function createMockPackage(packageDir, toolId) {
-  // Create package directories
-  await fs.promises.mkdir(path.join(packageDir, toolId, 'agents'), { recursive: true });
-  await fs.promises.mkdir(path.join(packageDir, toolId, 'skills', 'pdf'), { recursive: true });
-  await fs.promises.mkdir(path.join(packageDir, toolId, 'skills', 'docx'), { recursive: true });
-  await fs.promises.mkdir(path.join(packageDir, toolId, 'resources'), { recursive: true });
-  await fs.promises.mkdir(path.join(packageDir, toolId, 'hooks'), { recursive: true });
-
-  // Create mock agents (3 for Lite, 13 total)
-  const agents = ['master', 'orchestrator', 'scrum-master', 'developer', 'tester',
-                  'designer', 'analyst', 'reviewer', 'documenter', 'planner',
-                  'executor', 'monitor', 'reporter'];
-
-  for (const agent of agents) {
-    await fs.promises.writeFile(
-      path.join(packageDir, toolId, 'agents', `${agent}.md`),
-      `# ${agent} Agent\n\nMock agent content for testing.`
-    );
-  }
-
-  // Create mock skills (2 for testing - pdf and docx for Standard)
-  await fs.promises.writeFile(
-    path.join(packageDir, toolId, 'skills', 'pdf', 'pdf.md'),
-    '# PDF Skill\n\nMock PDF skill content.'
-  );
-  await fs.promises.writeFile(
-    path.join(packageDir, toolId, 'skills', 'docx', 'docx.md'),
-    '# DOCX Skill\n\nMock DOCX skill content.'
-  );
-
-  // Create mock resources
-  await fs.promises.writeFile(
-    path.join(packageDir, toolId, 'resources', 'workflows.yaml'),
-    'workflows:\n  - test: true'
-  );
-
-  // Create mock hooks
-  await fs.promises.writeFile(
-    path.join(packageDir, toolId, 'hooks', 'session-start.js'),
-    '// Mock session start hook'
-  );
-
-  // Create variants.json
-  const variants = {
-    lite: {
-      name: 'Lite',
-      description: 'Minimal installation',
-      useCase: 'Testing lite variant',
-      targetUsers: 'Test users',
-      agents: ['master', 'orchestrator', 'scrum-master'],
-      skills: [],
-      resources: ['workflows.yaml'],
-      hooks: ['session-start.js']
-    },
-    standard: {
-      name: 'Standard',
-      description: 'Standard installation',
-      useCase: 'Testing standard variant',
-      targetUsers: 'Test users',
-      agents: '*',
-      skills: ['pdf', 'docx'],
-      resources: ['workflows.yaml'],
-      hooks: ['session-start.js']
-    },
-    pro: {
-      name: 'Pro',
-      description: 'Full installation',
-      useCase: 'Testing pro variant',
-      targetUsers: 'Test users',
-      agents: '*',
-      skills: '*',
-      resources: '*',
-      hooks: '*'
-    }
-  };
-
-  await fs.promises.writeFile(
-    path.join(packageDir, toolId, 'variants.json'),
-    JSON.stringify(variants, null, 2)
-  );
-}
-
-/**
- * Test helper - count files recursively
- */
-async function countFilesRecursive(dir) {
-  let count = 0;
-
-  async function traverse(currentDir) {
-    const items = await fs.promises.readdir(currentDir);
-
-    for (const item of items) {
-      const itemPath = path.join(currentDir, item);
-      const stat = await fs.promises.stat(itemPath);
-
-      if (stat.isDirectory()) {
-        await traverse(itemPath);
-      } else {
-        count++;
-      }
-    }
-  }
-
-  if (fs.existsSync(dir)) {
-    await traverse(dir);
-  }
-
-  return count;
-}
-
-// Main test suite
-async function runTests() {
-  console.log(`\n${colors.bright}${colors.cyan}Installation Engine Tests (Variant Support)${colors.reset}\n`);
-
-  let tempDir = null;
-  let targetDir = null;
-
-  try {
-    // Create temporary directories for testing
-    tempDir = await createTempDir('installation-engine');
-    const mockPackagesDir = path.join(tempDir, 'packages');
-
-    // Create mock package structure
-    await createMockPackage(mockPackagesDir, 'testool');
-
-    // Create mock tools directory for manifest templates
-    const toolsDir = path.join(tempDir, 'tools', 'testool');
-    await fs.promises.mkdir(toolsDir, { recursive: true });
-    const manifestTemplate = {
-      tool: 'testool',
-      name: 'Test Tool',
-      description: 'Tool for testing',
-      optimization: 'test-optimization'
-    };
-    await fs.promises.writeFile(
-      path.join(toolsDir, 'manifest-template.json'),
-      JSON.stringify(manifestTemplate, null, 2)
-    );
-
-    // Initialize managers with mock directories
-    const packageManager = new PackageManager();
-    packageManager.packagesDir = mockPackagesDir;
-
-    const pathManager = new PathManager();
-    const installationEngine = new InstallationEngine(pathManager, packageManager);
-
-    // Override getManifestTemplate to use our test template
-    packageManager.getManifestTemplate = (toolId) => manifestTemplate;
-
-    console.log(`${colors.blue}Testing InstallationEngine.installPackage() with variant parameter${colors.reset}\n`);
-
-    // Test 1: Install Lite variant
-    await test('installPackage() accepts variant parameter (lite)', async () => {
-      targetDir = path.join(tempDir, 'install-lite');
-      await installationEngine.installPackage('testool', 'lite', targetDir);
-      assert.ok(fs.existsSync(targetDir), 'Target directory should exist');
-    });
-
-    // Test 2: Verify Lite variant files
-    await test('Lite variant installs only selected files (3 agents, 0 skills)', async () => {
-      const agentsDir = path.join(targetDir, 'agents');
-      const skillsDir = path.join(targetDir, 'skills');
-      const resourcesDir = path.join(targetDir, 'resources');
-      const hooksDir = path.join(targetDir, 'hooks');
-
-      // Count agents
-      const agents = fs.existsSync(agentsDir) ? await fs.promises.readdir(agentsDir) : [];
-      assert.strictEqual(agents.length, 3, 'Should have exactly 3 agents');
-      assert.ok(agents.includes('master.md'), 'Should include master agent');
-      assert.ok(agents.includes('orchestrator.md'), 'Should include orchestrator agent');
-      assert.ok(agents.includes('scrum-master.md'), 'Should include scrum-master agent');
-
-      // Skills should be empty (lite has no skills)
-      const skills = fs.existsSync(skillsDir) ? await fs.promises.readdir(skillsDir) : [];
-      assert.strictEqual(skills.length, 0, 'Should have 0 skills');
-
-      // Resources should exist
-      const resources = fs.existsSync(resourcesDir) ? await fs.promises.readdir(resourcesDir) : [];
-      assert.strictEqual(resources.length, 1, 'Should have 1 resource');
-
-      // Hooks should exist
-      const hooks = fs.existsSync(hooksDir) ? await fs.promises.readdir(hooksDir) : [];
-      assert.strictEqual(hooks.length, 1, 'Should have 1 hook');
-    });
-
-    // Test 3: Verify Lite manifest
-    await test('Lite variant manifest contains correct component counts', async () => {
-      const manifestPath = path.join(targetDir, 'manifest.json');
-      assert.ok(fs.existsSync(manifestPath), 'Manifest should exist');
-
-      const manifest = JSON.parse(await fs.promises.readFile(manifestPath, 'utf8'));
-      assert.strictEqual(manifest.variant, 'lite', 'Manifest should specify lite variant');
-      assert.strictEqual(manifest.components.agents, 3, 'Manifest should show 3 agents');
-      assert.strictEqual(manifest.components.skills, 0, 'Manifest should show 0 skills');
-    });
-
-    // Test 4: Install Standard variant
-    await test('installPackage() installs Standard variant (all agents, 2 skills)', async () => {
-      targetDir = path.join(tempDir, 'install-standard');
-      await installationEngine.installPackage('testool', 'standard', targetDir);
-
-      const agentsDir = path.join(targetDir, 'agents');
-      const skillsDir = path.join(targetDir, 'skills');
-
-      const agents = fs.existsSync(agentsDir) ? await fs.promises.readdir(agentsDir) : [];
-      assert.strictEqual(agents.length, 13, 'Should have all 13 agents');
-
-      const skills = fs.existsSync(skillsDir) ? await fs.promises.readdir(skillsDir) : [];
-      assert.strictEqual(skills.length, 2, 'Should have 2 skills');
-      assert.ok(skills.includes('pdf'), 'Should include pdf skill');
-      assert.ok(skills.includes('docx'), 'Should include docx skill');
-    });
-
-    // Test 5: Verify Standard manifest
-    await test('Standard variant manifest contains correct component counts', async () => {
-      const manifestPath = path.join(targetDir, 'manifest.json');
-      const manifest = JSON.parse(await fs.promises.readFile(manifestPath, 'utf8'));
-
-      assert.strictEqual(manifest.variant, 'standard', 'Manifest should specify standard variant');
-      assert.strictEqual(manifest.components.agents, 13, 'Manifest should show 13 agents');
-      assert.strictEqual(manifest.components.skills, 2, 'Manifest should show 2 skills');
-    });
-
-    // Test 6: Install Pro variant
-    await test('installPackage() installs Pro variant (all content)', async () => {
-      targetDir = path.join(tempDir, 'install-pro');
-      await installationEngine.installPackage('testool', 'pro', targetDir);
-
-      const agentsDir = path.join(targetDir, 'agents');
-      const skillsDir = path.join(targetDir, 'skills');
-
-      const agents = fs.existsSync(agentsDir) ? await fs.promises.readdir(agentsDir) : [];
-      assert.strictEqual(agents.length, 13, 'Should have all 13 agents');
-
-      const skills = fs.existsSync(skillsDir) ? await fs.promises.readdir(skillsDir) : [];
-      assert.strictEqual(skills.length, 2, 'Should have all 2 skills');
-    });
-
-    // Test 7: Verify Pro manifest
-    await test('Pro variant manifest contains correct component counts', async () => {
-      const manifestPath = path.join(targetDir, 'manifest.json');
-      const manifest = JSON.parse(await fs.promises.readFile(manifestPath, 'utf8'));
-
-      assert.strictEqual(manifest.variant, 'pro', 'Manifest should specify pro variant');
-      assert.strictEqual(manifest.components.agents, 13, 'Manifest should show 13 agents');
-      assert.strictEqual(manifest.components.skills, 2, 'Manifest should show 2 skills');
-    });
-
-    // Test 8: Verify skill directories are copied completely
-    await test('Skill directories are copied with all nested files', async () => {
-      targetDir = path.join(tempDir, 'install-skills-test');
-      await installationEngine.installPackage('testool', 'standard', targetDir);
-
-      const pdfSkillPath = path.join(targetDir, 'skills', 'pdf', 'pdf.md');
-      const docxSkillPath = path.join(targetDir, 'skills', 'docx', 'docx.md');
-
-      assert.ok(fs.existsSync(pdfSkillPath), 'PDF skill should include pdf.md');
-      assert.ok(fs.existsSync(docxSkillPath), 'DOCX skill should include docx.md');
-    });
-
-    // Test 9: Verify installation uses PackageManager methods
-    await test('installPackage() uses PackageManager.validatePackage()', async () => {
-      // This test verifies that invalid packages are rejected
-      targetDir = path.join(tempDir, 'install-invalid');
-      let errorThrown = false;
-
-      try {
-        await installationEngine.installPackage('nonexistent', 'lite', targetDir);
-      } catch (error) {
-        errorThrown = true;
-        assert.ok(error.message.includes('Package directory not found') ||
-                  error.message.includes('not found'),
-                  'Should throw error for invalid package');
-      }
-
-      assert.ok(errorThrown, 'Should throw error for nonexistent package');
-    });
-
-    // Test 10: Verify manifest includes variant information
-    await test('generateManifest() includes variant name and selected files', async () => {
-      targetDir = path.join(tempDir, 'install-manifest-test');
-      await installationEngine.installPackage('testool', 'lite', targetDir);
-
-      const manifestPath = path.join(targetDir, 'manifest.json');
-      const manifest = JSON.parse(await fs.promises.readFile(manifestPath, 'utf8'));
-
-      assert.ok(manifest.variant, 'Manifest should include variant');
-      assert.ok(manifest.components, 'Manifest should include components');
-      assert.ok(manifest.components.agents !== undefined, 'Manifest should include agent count');
-      assert.ok(manifest.components.skills !== undefined, 'Manifest should include skill count');
-      assert.ok(manifest.files, 'Manifest should include file information');
-      assert.ok(manifest.files.total !== undefined, 'Manifest should include total file count');
-    });
-
-    console.log(`\n${colors.blue}Testing Progress Callback System${colors.reset}\n`);
-
-    // Test 11: Progress callback is called during installation
-    await test('installPackage() calls progress callback during file copying', async () => {
-      targetDir = path.join(tempDir, 'install-progress-test');
-      const progressUpdates = [];
-
-      const progressCallback = (progress) => {
-        progressUpdates.push(progress);
-      };
-
-      await installationEngine.installPackage('testool', 'standard', targetDir, progressCallback);
-
-      assert.ok(progressUpdates.length > 0, 'Progress callback should be called at least once');
-      assert.ok(progressUpdates.length >= 15, 'Should have progress updates for 15+ files (13 agents + 2 skills)');
-    });
-
-    // Test 12: Progress callback receives correct information
-    await test('Progress callback receives currentFile, filesCompleted, totalFiles', async () => {
-      targetDir = path.join(tempDir, 'install-progress-info-test');
-      const progressUpdates = [];
-
-      const progressCallback = (progress) => {
-        progressUpdates.push(progress);
-      };
-
-      await installationEngine.installPackage('testool', 'lite', targetDir, progressCallback);
-
-      // Verify first progress update
-      const firstUpdate = progressUpdates[0];
-      assert.ok(firstUpdate.currentFile, 'Should include currentFile');
-      assert.ok(typeof firstUpdate.currentFile === 'string', 'currentFile should be a string');
-      assert.ok(typeof firstUpdate.filesCompleted === 'number', 'filesCompleted should be a number');
-      assert.ok(typeof firstUpdate.totalFiles === 'number', 'totalFiles should be a number');
-      assert.ok(firstUpdate.filesCompleted >= 0, 'filesCompleted should be non-negative');
-      assert.ok(firstUpdate.totalFiles > 0, 'totalFiles should be positive');
-    });
-
-    // Test 13: Progress callback includes percentage
-    await test('Progress callback includes percentage calculation', async () => {
-      targetDir = path.join(tempDir, 'install-progress-percentage-test');
-      const progressUpdates = [];
-
-      const progressCallback = (progress) => {
-        progressUpdates.push(progress);
-      };
-
-      await installationEngine.installPackage('testool', 'lite', targetDir, progressCallback);
-
-      for (const update of progressUpdates) {
-        assert.ok(typeof update.percentage === 'number', 'Should include percentage');
-        assert.ok(update.percentage >= 0 && update.percentage <= 100, 'Percentage should be 0-100');
-      }
-
-      // Last update should be 100%
-      const lastUpdate = progressUpdates[progressUpdates.length - 1];
-      assert.strictEqual(lastUpdate.percentage, 100, 'Final progress should be 100%');
-    });
-
-    // Test 14: Progress callback includes bytes transferred
-    await test('Progress callback includes bytesTransferred and totalBytes', async () => {
-      targetDir = path.join(tempDir, 'install-progress-bytes-test');
-      const progressUpdates = [];
-
-      const progressCallback = (progress) => {
-        progressUpdates.push(progress);
-      };
-
-      await installationEngine.installPackage('testool', 'standard', targetDir, progressCallback);
-
-      // Verify bytes information is included
-      for (const update of progressUpdates) {
-        assert.ok(typeof update.bytesTransferred === 'number', 'Should include bytesTransferred');
-        assert.ok(typeof update.totalBytes === 'number', 'Should include totalBytes');
-        assert.ok(update.bytesTransferred >= 0, 'bytesTransferred should be non-negative');
-        assert.ok(update.totalBytes > 0, 'totalBytes should be positive');
-        assert.ok(update.bytesTransferred <= update.totalBytes, 'bytesTransferred should not exceed totalBytes');
-      }
-
-      // Verify bytes increase over time
-      const firstUpdate = progressUpdates[0];
-      const lastUpdate = progressUpdates[progressUpdates.length - 1];
-      assert.ok(lastUpdate.bytesTransferred >= firstUpdate.bytesTransferred, 'Bytes should increase');
-      assert.strictEqual(lastUpdate.bytesTransferred, lastUpdate.totalBytes, 'Final bytes should equal total');
-    });
-
-    // Test 15: Progress updates are sequential
-    await test('Progress updates show sequential file completion', async () => {
-      targetDir = path.join(tempDir, 'install-progress-sequential-test');
-      const progressUpdates = [];
-
-      const progressCallback = (progress) => {
-        progressUpdates.push(progress);
-      };
-
-      await installationEngine.installPackage('testool', 'lite', targetDir, progressCallback);
-
-      // Verify filesCompleted increases sequentially
-      for (let i = 1; i < progressUpdates.length; i++) {
-        const prev = progressUpdates[i - 1].filesCompleted;
-        const curr = progressUpdates[i].filesCompleted;
-        assert.ok(curr >= prev, `filesCompleted should not decrease (${prev} -> ${curr})`);
-        assert.ok(curr - prev <= 1, `filesCompleted should increase by at most 1 (${prev} -> ${curr})`);
-      }
-
-      // Verify final count equals total
-      const lastUpdate = progressUpdates[progressUpdates.length - 1];
-      assert.strictEqual(lastUpdate.filesCompleted, lastUpdate.totalFiles,
-                        'Final filesCompleted should equal totalFiles');
-    });
-
-    // Test 16: Progress callback works with skill directories
-    await test('Progress callback correctly handles skill directories', async () => {
-      targetDir = path.join(tempDir, 'install-progress-skills-test');
-      const progressUpdates = [];
-      const skillFilesProcessed = [];
-
-      const progressCallback = (progress) => {
-        progressUpdates.push(progress);
-        if (progress.currentFile.includes('skills')) {
-          skillFilesProcessed.push(progress.currentFile);
-        }
-      };
-
-      await installationEngine.installPackage('testool', 'standard', targetDir, progressCallback);
-
-      // Verify skill files were processed
-      assert.ok(skillFilesProcessed.length > 0, 'Should process skill directory files');
-
-      // Verify skill directory paths are reported
-      const hasSkillPaths = progressUpdates.some(update =>
-        update.currentFile.includes('skills/pdf') || update.currentFile.includes('skills/docx')
-      );
-      assert.ok(hasSkillPaths, 'Should report skill directory paths');
-    });
-
-    // Test 17: Installation works without progress callback (backward compatibility)
-    await test('installPackage() works without progress callback parameter', async () => {
-      targetDir = path.join(tempDir, 'install-no-callback-test');
-
-      // Should not throw error when callback is not provided
-      await installationEngine.installPackage('testool', 'lite', targetDir);
-
-      const manifestPath = path.join(targetDir, 'manifest.json');
-      assert.ok(fs.existsSync(manifestPath), 'Installation should complete without callback');
-    });
-
-    // Test 18: Progress callback with Pro variant (many files)
-    await test('Progress callback handles Pro variant with many files', async () => {
-      targetDir = path.join(tempDir, 'install-progress-pro-test');
-      const progressUpdates = [];
-
-      const progressCallback = (progress) => {
-        progressUpdates.push(progress);
-      };
-
-      await installationEngine.installPackage('testool', 'pro', targetDir, progressCallback);
-
-      // Pro should have the most progress updates
-      assert.ok(progressUpdates.length >= 15, 'Pro variant should have 15+ progress updates');
-
-      // Verify final state
-      const lastUpdate = progressUpdates[progressUpdates.length - 1];
-      assert.strictEqual(lastUpdate.percentage, 100, 'Should reach 100%');
-      assert.strictEqual(lastUpdate.filesCompleted, lastUpdate.totalFiles, 'Should complete all files');
-    });
-
-    // ===================================
-    // Tests 19-25: Enhanced Manifest Generation
-    // ===================================
-    console.log(`\n${colors.cyan}${colors.bright}Enhanced Manifest Generation Tests${colors.reset}`);
-
-    // Test 19: Manifest includes variant metadata
-    await test('Manifest includes variant metadata (description, useCase, targetUsers)', async () => {
-      targetDir = path.join(tempDir, 'install-manifest-metadata-test');
-      await installationEngine.installPackage('testool', 'standard', targetDir);
-
-      const manifestPath = path.join(targetDir, 'manifest.json');
-      const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
-
-      assert.ok(manifest.variantInfo, 'Manifest should include variantInfo object');
-      assert.ok(typeof manifest.variantInfo.name === 'string', 'variantInfo should include name');
-      assert.ok(typeof manifest.variantInfo.description === 'string', 'variantInfo should include description');
-      assert.ok(typeof manifest.variantInfo.useCase === 'string', 'variantInfo should include useCase');
-      assert.ok(typeof manifest.variantInfo.targetUsers === 'string', 'variantInfo should include targetUsers');
-      assert.ok(manifest.variantInfo.description.length > 0, 'Description should not be empty');
-    });
-
-    // Test 20: Manifest includes list of installed agents
-    await test('Manifest includes list of installed agent files', async () => {
-      targetDir = path.join(tempDir, 'install-manifest-agents-test');
-      await installationEngine.installPackage('testool', 'lite', targetDir);
-
-      const manifestPath = path.join(targetDir, 'manifest.json');
-      const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
-
-      assert.ok(manifest.installedFiles, 'Manifest should include installedFiles object');
-      assert.ok(Array.isArray(manifest.installedFiles.agents), 'installedFiles.agents should be an array');
-      assert.strictEqual(manifest.installedFiles.agents.length, 3, 'Lite variant should list 3 agents');
-
-      // Verify agent names match the lite variant selection
-      const agentNames = manifest.installedFiles.agents;
-      assert.ok(agentNames.includes('master'), 'Should include master agent');
-      assert.ok(agentNames.includes('orchestrator'), 'Should include orchestrator agent');
-      assert.ok(agentNames.includes('scrum-master'), 'Should include scrum-master agent');
-    });
-
-    // Test 21: Manifest includes list of installed skills
-    await test('Manifest includes list of installed skill directories', async () => {
-      targetDir = path.join(tempDir, 'install-manifest-skills-test');
-      await installationEngine.installPackage('testool', 'standard', targetDir);
-
-      const manifestPath = path.join(targetDir, 'manifest.json');
-      const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
-
-      assert.ok(Array.isArray(manifest.installedFiles.skills), 'installedFiles.skills should be an array');
-      assert.ok(manifest.installedFiles.skills.length > 0, 'Standard variant should list skills');
-
-      // Verify skills are listed
-      const skillNames = manifest.installedFiles.skills;
-      assert.ok(skillNames.includes('pdf'), 'Should include pdf skill');
-      assert.ok(skillNames.includes('docx'), 'Should include docx skill');
-    });
-
-    // Test 22: Manifest includes list of installed resources and hooks
-    await test('Manifest includes lists of installed resources and hooks', async () => {
-      targetDir = path.join(tempDir, 'install-manifest-resources-hooks-test');
-      await installationEngine.installPackage('testool', 'standard', targetDir);
-
-      const manifestPath = path.join(targetDir, 'manifest.json');
-      const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
-
-      assert.ok(Array.isArray(manifest.installedFiles.resources), 'installedFiles.resources should be an array');
-      assert.ok(Array.isArray(manifest.installedFiles.hooks), 'installedFiles.hooks should be an array');
-      assert.ok(manifest.installedFiles.resources.length > 0, 'Should list resources');
-      assert.ok(manifest.installedFiles.hooks.length > 0, 'Should list hooks');
-    });
-
-    // Test 23: Manifest structure varies by variant
-    await test('Manifest reflects different content for different variants', async () => {
-      const liteDir = path.join(tempDir, 'install-manifest-lite');
-      const proDir = path.join(tempDir, 'install-manifest-pro');
-
-      await installationEngine.installPackage('testool', 'lite', liteDir);
-      await installationEngine.installPackage('testool', 'pro', proDir);
-
-      const liteManifest = JSON.parse(fs.readFileSync(path.join(liteDir, 'manifest.json'), 'utf8'));
-      const proManifest = JSON.parse(fs.readFileSync(path.join(proDir, 'manifest.json'), 'utf8'));
-
-      // Lite should have fewer files than Pro
-      assert.ok(liteManifest.installedFiles.agents.length <= proManifest.installedFiles.agents.length,
-                'Lite should have same or fewer agents than Pro');
-      assert.ok(liteManifest.installedFiles.skills.length < proManifest.installedFiles.skills.length,
-                'Lite should have fewer skills than Pro');
-
-      // Variant info should be different
-      assert.notStrictEqual(liteManifest.variantInfo.name, proManifest.variantInfo.name,
-                           'Variant names should differ');
-      assert.notStrictEqual(liteManifest.variant, proManifest.variant,
-                           'Variant field should differ');
-    });
-
-    // Test 24: Manifest file counts match installed files lists
-    await test('Manifest component counts match installedFiles array lengths', async () => {
-      targetDir = path.join(tempDir, 'install-manifest-counts-test');
-      await installationEngine.installPackage('testool', 'standard', targetDir);
-
-      const manifestPath = path.join(targetDir, 'manifest.json');
-      const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
-
-      assert.strictEqual(manifest.components.agents, manifest.installedFiles.agents.length,
-                        'Agent count should match installedFiles.agents length');
-      assert.strictEqual(manifest.components.skills, manifest.installedFiles.skills.length,
-                        'Skill count should match installedFiles.skills length');
-      assert.strictEqual(manifest.components.resources, manifest.installedFiles.resources.length,
-                        'Resource count should match installedFiles.resources length');
-      assert.strictEqual(manifest.components.hooks, manifest.installedFiles.hooks.length,
-                        'Hook count should match installedFiles.hooks length');
-    });
-
-    // Test 25: Manifest maintains backward compatibility with existing fields
-    await test('Manifest maintains all existing fields for backward compatibility', async () => {
-      targetDir = path.join(tempDir, 'install-manifest-compat-test');
-      await installationEngine.installPackage('testool', 'lite', targetDir);
-
-      const manifestPath = path.join(targetDir, 'manifest.json');
-      const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
-
-      // Check all existing fields are still present
-      assert.ok(manifest.tool, 'Should include tool field');
-      assert.ok(manifest.name, 'Should include name field');
-      assert.ok(manifest.description, 'Should include description field');
-      assert.ok(manifest.variant, 'Should include variant field');
-      assert.ok(manifest.version, 'Should include version field');
-      assert.ok(manifest.installed_at, 'Should include installed_at field');
-      assert.ok(manifest.components, 'Should include components object');
-      assert.ok(manifest.paths, 'Should include paths object');
-      assert.ok(manifest.files, 'Should include files object');
-
-      // Check new fields are added
-      assert.ok(manifest.variantInfo, 'Should include new variantInfo field');
-      assert.ok(manifest.installedFiles, 'Should include new installedFiles field');
-    });
-
-    // ===================================
-    // Tests 26-35: Enhanced Rollback Functionality
-    // ===================================
-    console.log(`\n${colors.cyan}${colors.bright}Enhanced Rollback Tests${colors.reset}`);
-
-    // Test 26: Installation tracks files for rollback
-    await test('Installation tracks installed files in session log', async () => {
-      targetDir = path.join(tempDir, 'install-rollback-tracking-test');
-      await installationEngine.installPackage('testool', 'lite', targetDir);
-
-      // Check that installation log exists and contains file-level information
-      const sessionLog = installationEngine.getSessionLog();
-      assert.ok(sessionLog, 'Session log should exist');
-      assert.ok(Array.isArray(sessionLog.installedFiles), 'Session log should have installedFiles array');
-      assert.ok(sessionLog.installedFiles.length > 0, 'Session log should track installed files');
-    });
-
-    // Test 27: Rollback removes only installed files (not entire directory)
-    await test('Rollback removes only installed files, not entire directory', async () => {
-      targetDir = path.join(tempDir, 'install-rollback-granular-test');
-
-      // Install package
-      await installationEngine.installPackage('testool', 'lite', targetDir);
-
-      // Create a user file (not part of installation)
-      const userFilePath = path.join(targetDir, 'my-custom-file.txt');
-      await fs.promises.writeFile(userFilePath, 'User-created content');
-
-      // Perform rollback
-      await installationEngine.rollbackInstallation('testool', targetDir);
-
-      // Verify user file still exists
-      assert.ok(fs.existsSync(userFilePath), 'User-created file should not be removed by rollback');
-
-      // Verify installed files are removed
-      const manifestPath = path.join(targetDir, 'manifest.json');
-      assert.ok(!fs.existsSync(manifestPath), 'Manifest should be removed by rollback');
-    });
-
-    // Test 28: Rollback cleans up empty directories
-    await test('Rollback removes empty directories after file removal', async () => {
-      targetDir = path.join(tempDir, 'install-rollback-cleanup-test');
-
-      // Install lite variant (only agents, no skills)
-      await installationEngine.installPackage('testool', 'lite', targetDir);
-
-      // Verify directories exist
-      const agentsDir = path.join(targetDir, 'agents');
-      assert.ok(fs.existsSync(agentsDir), 'Agents directory should exist after installation');
-
-      // Perform rollback
-      await installationEngine.rollbackInstallation('testool', targetDir);
-
-      // Verify empty directories are cleaned up
-      assert.ok(!fs.existsSync(agentsDir) || (await fs.promises.readdir(agentsDir)).length === 0,
-                'Empty agents directory should be removed or empty');
-    });
-
-    // Test 29: Rollback preserves user files in component directories
-    await test('Rollback preserves user files in component directories', async () => {
-      targetDir = path.join(tempDir, 'install-rollback-preserve-test');
-
-      // Install package
-      await installationEngine.installPackage('testool', 'standard', targetDir);
-
-      // Create user files in agents directory
-      const userAgentPath = path.join(targetDir, 'agents', 'my-custom-agent.md');
-      await fs.promises.writeFile(userAgentPath, '# My Custom Agent');
-
-      // Create user file in skills directory
-      const userSkillPath = path.join(targetDir, 'skills', 'custom-skill', 'skill.md');
-      await fs.promises.mkdir(path.join(targetDir, 'skills', 'custom-skill'), { recursive: true });
-      await fs.promises.writeFile(userSkillPath, '# My Custom Skill');
-
-      // Perform rollback
-      await installationEngine.rollbackInstallation('testool', targetDir);
-
-      // Verify user files are preserved
-      assert.ok(fs.existsSync(userAgentPath), 'User agent should be preserved');
-      assert.ok(fs.existsSync(userSkillPath), 'User skill should be preserved');
-
-      // Verify installed files are removed
-      const installedAgentPath = path.join(targetDir, 'agents', 'master.md');
-      assert.ok(!fs.existsSync(installedAgentPath), 'Installed agent should be removed');
-    });
-
-    // Test 30: Rollback works with different variants
-    await test('Rollback correctly handles Lite variant (3 agents, 0 skills)', async () => {
-      targetDir = path.join(tempDir, 'install-rollback-lite-test');
-
-      // Install lite variant
-      await installationEngine.installPackage('testool', 'lite', targetDir);
-
-      // Verify files exist
-      const agentCount = await countFilesRecursive(path.join(targetDir, 'agents'));
-      assert.ok(agentCount >= 3, 'Should have at least 3 agent files');
-
-      // Perform rollback
-      await installationEngine.rollbackInstallation('testool', targetDir);
-
-      // Verify all installed files are removed
-      const manifestPath = path.join(targetDir, 'manifest.json');
-      assert.ok(!fs.existsSync(manifestPath), 'Manifest should be removed');
-
-      // Verify agents are removed
-      const remainingAgents = fs.existsSync(path.join(targetDir, 'agents'))
-        ? await countFilesRecursive(path.join(targetDir, 'agents'))
-        : 0;
-      assert.strictEqual(remainingAgents, 0, 'All installed agents should be removed');
-    });
-
-    // Test 31: Rollback works with Standard variant (includes skills)
-    await test('Rollback correctly handles Standard variant (agents + skills)', async () => {
-      targetDir = path.join(tempDir, 'install-rollback-standard-test');
-
-      // Install standard variant
-      await installationEngine.installPackage('testool', 'standard', targetDir);
-
-      // Verify skills exist
-      const skillsDir = path.join(targetDir, 'skills');
-      assert.ok(fs.existsSync(skillsDir), 'Skills directory should exist');
-      const skillDirs = await fs.promises.readdir(skillsDir);
-      assert.ok(skillDirs.length > 0, 'Should have skill directories');
-
-      // Perform rollback
-      await installationEngine.rollbackInstallation('testool', targetDir);
-
-      // Verify skills are removed
-      const remainingSkills = fs.existsSync(skillsDir)
-        ? (await fs.promises.readdir(skillsDir)).length
-        : 0;
-      assert.strictEqual(remainingSkills, 0, 'All installed skills should be removed');
-    });
-
-    // Test 32: Rollback logs actions for troubleshooting
-    await test('Rollback logs all actions for troubleshooting', async () => {
-      targetDir = path.join(tempDir, 'install-rollback-logging-test');
-
-      // Install package
-      await installationEngine.installPackage('testool', 'lite', targetDir);
-
-      // Perform rollback
-      await installationEngine.rollbackInstallation('testool', targetDir);
-
-      // Check rollback log
-      const rollbackLog = installationEngine.getRollbackLog();
-      assert.ok(rollbackLog, 'Rollback log should exist');
-      assert.ok(Array.isArray(rollbackLog), 'Rollback log should be an array');
-      assert.ok(rollbackLog.length > 0, 'Rollback log should have entries');
-
-      // Verify log entries have required information
-      const lastRollback = rollbackLog[rollbackLog.length - 1];
-      assert.ok(lastRollback.tool, 'Log entry should include tool');
-      assert.ok(lastRollback.targetPath, 'Log entry should include target path');
-      assert.ok(lastRollback.filesRemoved, 'Log entry should include files removed count');
-      assert.ok(lastRollback.timestamp, 'Log entry should include timestamp');
-    });
-
-    // Test 33: Rollback on failed installation
-    await test('Rollback automatically triggered on failed installation', async () => {
-      targetDir = path.join(tempDir, 'install-rollback-failure-test');
-
-      // Try to install to a read-only or invalid path to trigger failure
-      // First, create a directory and make it unwritable
-      await fs.promises.mkdir(targetDir, { recursive: true });
-
-      // Install successfully first
-      await installationEngine.installPackage('testool', 'lite', targetDir);
-
-      // Verify installation succeeded
-      const manifestPath = path.join(targetDir, 'manifest.json');
-      assert.ok(fs.existsSync(manifestPath), 'Initial installation should succeed');
-
-      // Verify rollback can be called
-      await installationEngine.rollbackInstallation('testool', targetDir);
-
-      // Verify rollback removed files
-      assert.ok(!fs.existsSync(manifestPath), 'Rollback should remove manifest');
-    });
-
-    // Test 34: Rollback restores from backup if available
-    await test('Rollback restores from backup if available', async () => {
-      targetDir = path.join(tempDir, 'install-rollback-backup-test');
-
-      // Create an existing installation (must have manifest.json to be detected)
-      await fs.promises.mkdir(path.join(targetDir, 'agents'), { recursive: true });
-      const existingFilePath = path.join(targetDir, 'agents', 'existing-agent.md');
-      await fs.promises.writeFile(existingFilePath, '# Existing Agent');
-
-      // Create a manifest so it's recognized as existing installation
-      const existingManifest = {
-        tool: 'testool',
-        name: 'Test Tool',
-        version: '1.0.0',
-        installed_at: new Date().toISOString()
-      };
-      await fs.promises.writeFile(
-        path.join(targetDir, 'manifest.json'),
-        JSON.stringify(existingManifest, null, 2)
-      );
-
-      // Install over existing (should create backup)
-      await installationEngine.installPackage('testool', 'lite', targetDir);
-
-      // Verify backup was created
-      const backupLog = installationEngine.backupLog;
-      assert.ok(backupLog.length > 0, 'Backup should have been created');
-
-      // Get the backup path
-      const backup = backupLog[backupLog.length - 1];
-      assert.ok(fs.existsSync(backup.backup), 'Backup directory should exist');
-
-      // Perform rollback (should use session log first, not backup)
-      await installationEngine.rollbackInstallation('testool', targetDir);
-
-      // After rollback with session log, only installed files should be removed
-      // The existing file should still be there because it wasn't in session log
-      assert.ok(fs.existsSync(existingFilePath), 'Original file should be preserved (not in session log)');
-
-      // Verify new installed files are removed
-      const masterAgentPath = path.join(targetDir, 'agents', 'master.md');
-      assert.ok(!fs.existsSync(masterAgentPath), 'Installed agent should be removed');
-
-      // Verify manifest is removed
-      const manifestPath = path.join(targetDir, 'manifest.json');
-      assert.ok(!fs.existsSync(manifestPath), 'Manifest should be removed');
-    });
-
-    // Test 35: Rollback works correctly with partial installations
-    await test('Rollback handles partial installation (some files copied)', async () => {
-      targetDir = path.join(tempDir, 'install-rollback-partial-test');
-
-      // Install package normally first
-      await installationEngine.installPackage('testool', 'standard', targetDir);
-
-      // Now simulate a partial installation by manually tracking some files
-      // Then perform rollback and verify only those files are removed
-
-      // Get the session log before rollback
-      const sessionLog = installationEngine.getSessionLog();
-      const filesBeforeRollback = sessionLog ? sessionLog.installedFiles.length : 0;
-      assert.ok(filesBeforeRollback > 0, 'Should have files tracked before rollback');
-
-      // Perform rollback
-      await installationEngine.rollbackInstallation('testool', targetDir);
-
-      // Verify rollback processed files
-      const rollbackLog = installationEngine.getRollbackLog();
-      const lastRollback = rollbackLog[rollbackLog.length - 1];
-      assert.ok(lastRollback.filesRemoved >= 0, 'Should report number of files removed');
-    });
-
-    console.log(`\n${colors.cyan}${colors.bright}Verification Tests${colors.reset}`);
-
-    // Test 36: verifyInstallation returns success for valid installation
-    await test('verifyInstallation returns success for valid installation', async () => {
-      targetDir = path.join(tempDir, 'verify-valid-test');
-
-      // Install package
-      await installationEngine.installPackage('testool', 'standard', targetDir);
-
-      // Verify installation
-      const verification = await installationEngine.verifyInstallation('testool', targetDir);
-
-      assert.strictEqual(verification.valid, true, 'Verification should be valid');
-      assert.strictEqual(verification.toolId, 'testool', 'Tool ID should match');
-      assert.strictEqual(verification.targetPath, targetDir, 'Target path should match');
-      assert.ok(verification.manifest, 'Should have manifest data');
-      assert.strictEqual(verification.issues.length, 0, 'Should have no issues');
-    });
-
-    // Test 37: verifyInstallation detects missing manifest
-    await test('verifyInstallation detects missing manifest', async () => {
-      targetDir = path.join(tempDir, 'verify-no-manifest-test');
-
-      // Create directory but no installation
-      await fs.promises.mkdir(targetDir, { recursive: true });
-
-      // Verify installation
-      const verification = await installationEngine.verifyInstallation('testool', targetDir);
-
-      assert.strictEqual(verification.valid, false, 'Verification should be invalid');
-      assert.ok(verification.issues.length > 0, 'Should have issues');
-      assert.ok(
-        verification.issues.some(i => i.message.includes('Manifest')),
-        'Should report missing manifest'
-      );
-    });
-
-    // Test 38: verifyInstallation detects missing files
-    await test('verifyInstallation detects missing files', async () => {
-      targetDir = path.join(tempDir, 'verify-missing-files-test');
-
-      // Install package
-      await installationEngine.installPackage('testool', 'standard', targetDir);
-
-      // Delete one agent file
-      const agentsDir = path.join(targetDir, 'agents');
-      const agentFiles = await fs.promises.readdir(agentsDir);
-      if (agentFiles.length > 0) {
-        await fs.promises.unlink(path.join(agentsDir, agentFiles[0]));
-      }
-
-      // Verify installation
-      const verification = await installationEngine.verifyInstallation('testool', targetDir);
-
-      assert.strictEqual(verification.valid, false, 'Verification should be invalid');
-      assert.ok(verification.issues.length > 0, 'Should have issues');
-      assert.ok(
-        verification.components.agents.missing.length > 0,
-        'Should report missing agents'
-      );
-    });
-
-    // Test 39: verifyInstallation includes component counts
-    await test('verifyInstallation includes component counts', async () => {
-      targetDir = path.join(tempDir, 'verify-components-test');
-
-      // Install package
-      await installationEngine.installPackage('testool', 'standard', targetDir);
-
-      // Verify installation
-      const verification = await installationEngine.verifyInstallation('testool', targetDir);
-
-      assert.ok(verification.components, 'Should have components');
-      assert.ok(verification.components.agents, 'Should have agents component');
-      assert.ok(verification.components.skills, 'Should have skills component');
-      assert.ok(verification.components.resources, 'Should have resources component');
-      assert.ok(verification.components.hooks, 'Should have hooks component');
-
-      // Check component structure
-      assert.ok('expected' in verification.components.agents, 'Should have expected count');
-      assert.ok('found' in verification.components.agents, 'Should have found count');
-      assert.ok('missing' in verification.components.agents, 'Should have missing array');
-    });
-
-    // Test 40: verifyInstallation includes summary
-    await test('verifyInstallation includes summary', async () => {
-      targetDir = path.join(tempDir, 'verify-summary-test');
-
-      // Install package
-      await installationEngine.installPackage('testool', 'standard', targetDir);
-
-      // Verify installation
-      const verification = await installationEngine.verifyInstallation('testool', targetDir);
-
-      assert.ok(verification.summary, 'Should have summary');
-      assert.ok('totalExpected' in verification.summary, 'Should have totalExpected');
-      assert.ok('totalFound' in verification.summary, 'Should have totalFound');
-      assert.ok('totalMissing' in verification.summary, 'Should have totalMissing');
-      assert.ok('issueCount' in verification.summary, 'Should have issueCount');
-      assert.ok('warningCount' in verification.summary, 'Should have warningCount');
-    });
-
-    // Test 41: verifyInstallation includes variant and version info
-    await test('verifyInstallation includes variant and version info', async () => {
-      targetDir = path.join(tempDir, 'verify-metadata-test');
-
-      // Install package
-      await installationEngine.installPackage('testool', 'standard', targetDir);
-
-      // Verify installation
-      const verification = await installationEngine.verifyInstallation('testool', targetDir);
-
-      assert.ok(verification.variant, 'Should have variant');
-      assert.strictEqual(verification.variant, 'standard', 'Variant should match');
-      assert.ok(verification.version, 'Should have version');
-    });
-
-    // ===================================
-    // Tests 42-60: Uninstall Functionality
-    // ===================================
-    console.log(`\n${colors.cyan}${colors.bright}Uninstall Functionality Tests${colors.reset}`);
-
-    // Test 42: uninstall() detects missing manifest
-    await test('uninstall() detects missing manifest and returns error', async () => {
-      targetDir = path.join(tempDir, 'uninstall-no-manifest-test');
-      await fs.promises.mkdir(targetDir, { recursive: true });
-
-      const result = await installationEngine.uninstall('testool', targetDir);
-
-      assert.strictEqual(result.success, false, 'Uninstall should fail');
-      assert.ok(result.errors.length > 0, 'Should have errors');
-      assert.ok(result.errors[0].includes('Manifest'), 'Error should mention manifest');
-    });
-
-    // Test 43: uninstall() reads manifest and counts files
-    await test('uninstall() reads manifest and calculates file count', async () => {
-      targetDir = path.join(tempDir, 'uninstall-count-test');
-
-      // Install package
-      await installationEngine.installPackage('testool', 'lite', targetDir);
-
-      // Track confirmation info
-      let confirmInfo = null;
-      const confirmCallback = async (info) => {
-        confirmInfo = info;
-        return true; // Confirm uninstall
-      };
-
-      // Uninstall
-      const result = await installationEngine.uninstall('testool', targetDir, confirmCallback);
-
-      assert.ok(confirmInfo, 'Confirmation callback should be called');
-      assert.strictEqual(confirmInfo.toolId, 'testool', 'Should pass tool ID');
-      assert.ok(confirmInfo.fileCount > 0, 'Should calculate file count');
-      assert.strictEqual(confirmInfo.variant, 'lite', 'Should pass variant');
-    });
-
-    // Test 44: uninstall() respects user cancellation
-    await test('uninstall() cancels when user declines confirmation', async () => {
-      targetDir = path.join(tempDir, 'uninstall-cancel-test');
-
-      // Install package
-      await installationEngine.installPackage('testool', 'lite', targetDir);
-
-      // Decline confirmation
-      const confirmCallback = async (info) => {
-        return false; // Cancel uninstall
-      };
-
-      // Uninstall
-      const result = await installationEngine.uninstall('testool', targetDir, confirmCallback);
-
-      assert.strictEqual(result.success, false, 'Uninstall should not succeed');
-      assert.ok(result.warnings.some(w => w.includes('cancelled')), 'Should have cancellation warning');
-
-      // Verify files still exist
-      const manifestPath = path.join(targetDir, 'manifest.json');
-      assert.ok(fs.existsSync(manifestPath), 'Manifest should still exist');
-    });
-
-    // Test 45: uninstall() creates backup before removing files
-    await test('uninstall() creates backup before uninstalling', async () => {
-      targetDir = path.join(tempDir, 'uninstall-backup-test');
-
-      // Install package
-      await installationEngine.installPackage('testool', 'lite', targetDir);
-
-      // Auto-confirm
-      const confirmCallback = async () => true;
-
-      // Uninstall
-      const result = await installationEngine.uninstall('testool', targetDir, confirmCallback);
-
-      assert.ok(result.backupPath, 'Should create backup');
-      assert.ok(fs.existsSync(result.backupPath), 'Backup directory should exist');
-      assert.ok(result.backupPath.includes('.uninstall-backup.'), 'Backup should have correct naming');
-
-      // Verify backup contains files
-      const backupManifest = path.join(result.backupPath, 'manifest.json');
-      assert.ok(fs.existsSync(backupManifest), 'Backup should contain manifest');
-    });
-
-    // Test 46: uninstall() removes all installed files from Lite variant
-    await test('uninstall() removes all files from Lite variant installation', async () => {
-      targetDir = path.join(tempDir, 'uninstall-lite-test');
-
-      // Install package
-      await installationEngine.installPackage('testool', 'lite', targetDir);
-
-      // Verify installation exists
-      const manifestPath = path.join(targetDir, 'manifest.json');
-      assert.ok(fs.existsSync(manifestPath), 'Installation should exist');
-
-      // Auto-confirm
-      const confirmCallback = async () => true;
-
-      // Uninstall
-      const result = await installationEngine.uninstall('testool', targetDir, confirmCallback);
-
-      assert.strictEqual(result.success, true, 'Uninstall should succeed');
-      assert.ok(result.filesRemoved > 0, 'Should remove files');
-
-      // Verify manifest is removed
-      assert.ok(!fs.existsSync(manifestPath), 'Manifest should be removed');
-
-      // Verify agent files are removed
-      const masterAgent = path.join(targetDir, 'agents', 'master.md');
-      assert.ok(!fs.existsSync(masterAgent), 'Agent files should be removed');
-    });
-
-    // Test 47: uninstall() removes all files from Standard variant (including skills)
-    await test('uninstall() removes all files from Standard variant including skills', async () => {
-      targetDir = path.join(tempDir, 'uninstall-standard-test');
-
-      // Install package
-      await installationEngine.installPackage('testool', 'standard', targetDir);
-
-      // Verify skills exist
-      const pdfSkill = path.join(targetDir, 'skills', 'pdf');
-      assert.ok(fs.existsSync(pdfSkill), 'Skills should exist before uninstall');
-
-      // Auto-confirm
-      const confirmCallback = async () => true;
-
-      // Uninstall
-      const result = await installationEngine.uninstall('testool', targetDir, confirmCallback);
-
-      assert.strictEqual(result.success, true, 'Uninstall should succeed');
-
-      // Verify skills are removed
-      assert.ok(!fs.existsSync(pdfSkill), 'Skill directories should be removed');
-
-      // Verify agents are removed
-      const masterAgent = path.join(targetDir, 'agents', 'master.md');
-      assert.ok(!fs.existsSync(masterAgent), 'Agent files should be removed');
-    });
-
-    // Test 48: uninstall() preserves user-created files
-    await test('uninstall() preserves user-created files not in manifest', async () => {
-      targetDir = path.join(tempDir, 'uninstall-preserve-test');
-
-      // Install package
-      await installationEngine.installPackage('testool', 'lite', targetDir);
-
-      // Create user files
-      const userFile = path.join(targetDir, 'my-custom-file.txt');
-      await fs.promises.writeFile(userFile, 'User content');
-
-      const userAgent = path.join(targetDir, 'agents', 'my-agent.md');
-      await fs.promises.writeFile(userAgent, '# My Agent');
-
-      // Auto-confirm
-      const confirmCallback = async () => true;
-
-      // Uninstall
-      const result = await installationEngine.uninstall('testool', targetDir, confirmCallback);
-
-      assert.strictEqual(result.success, true, 'Uninstall should succeed');
-
-      // Verify user files are preserved
-      assert.ok(fs.existsSync(userFile), 'User file should be preserved');
-      assert.ok(fs.existsSync(userAgent), 'User agent should be preserved');
-
-      // Verify installed files are removed
-      const masterAgent = path.join(targetDir, 'agents', 'master.md');
-      assert.ok(!fs.existsSync(masterAgent), 'Installed agent should be removed');
-    });
-
-    // Test 49: uninstall() cleans up empty directories
-    await test('uninstall() removes empty directories after file removal', async () => {
-      targetDir = path.join(tempDir, 'uninstall-cleanup-test');
-
-      // Install lite variant (no skills)
-      await installationEngine.installPackage('testool', 'lite', targetDir);
-
-      // Auto-confirm
-      const confirmCallback = async () => true;
-
-      // Uninstall
-      const result = await installationEngine.uninstall('testool', targetDir, confirmCallback);
-
-      assert.strictEqual(result.success, true, 'Uninstall should succeed');
-      assert.ok(result.directoriesRemoved > 0, 'Should remove directories');
-
-      // Verify empty category directories are removed
-      const agentsDir = path.join(targetDir, 'agents');
-      const agentsDirExists = fs.existsSync(agentsDir);
-
-      if (agentsDirExists) {
-        // If directory exists, it should be empty
-        const items = await fs.promises.readdir(agentsDir);
-        assert.strictEqual(items.length, 0, 'Agents directory should be empty if it exists');
-      }
-    });
-
-    // Test 50: uninstall() preserves directories with user files
-    await test('uninstall() preserves directories containing user files', async () => {
-      targetDir = path.join(tempDir, 'uninstall-preserve-dir-test');
-
-      // Install package
-      await installationEngine.installPackage('testool', 'standard', targetDir);
-
-      // Create user file in agents directory
-      const userAgent = path.join(targetDir, 'agents', 'my-custom-agent.md');
-      await fs.promises.writeFile(userAgent, '# My Custom Agent');
-
-      // Auto-confirm
-      const confirmCallback = async () => true;
-
-      // Uninstall
-      const result = await installationEngine.uninstall('testool', targetDir, confirmCallback);
-
-      assert.strictEqual(result.success, true, 'Uninstall should succeed');
-
-      // Verify agents directory still exists (has user file)
-      const agentsDir = path.join(targetDir, 'agents');
-      assert.ok(fs.existsSync(agentsDir), 'Agents directory should be preserved');
-      assert.ok(fs.existsSync(userAgent), 'User agent should still exist');
-
-      // Verify installed agents are removed
-      const masterAgent = path.join(targetDir, 'agents', 'master.md');
-      assert.ok(!fs.existsSync(masterAgent), 'Installed agents should be removed');
-    });
-
-    // Test 51: uninstall() calls progress callback
-    await test('uninstall() calls progress callback during file removal', async () => {
-      targetDir = path.join(tempDir, 'uninstall-progress-test');
-
-      // Install package
-      await installationEngine.installPackage('testool', 'lite', targetDir);
-
-      const progressUpdates = [];
-      const progressCallback = (progress) => {
-        progressUpdates.push(progress);
-      };
-
-      // Auto-confirm
-      const confirmCallback = async () => true;
-
-      // Uninstall
-      const result = await installationEngine.uninstall('testool', targetDir, confirmCallback, progressCallback);
-
-      assert.strictEqual(result.success, true, 'Uninstall should succeed');
-      assert.ok(progressUpdates.length > 0, 'Progress callback should be called');
-
-      // Verify progress updates have correct structure
-      const firstUpdate = progressUpdates[0];
-      assert.ok(firstUpdate.type, 'Should have type');
-      assert.ok(firstUpdate.category, 'Should have category');
-      assert.ok(firstUpdate.name, 'Should have name');
-      assert.ok(typeof firstUpdate.filesRemoved === 'number', 'Should have filesRemoved count');
-      assert.ok(typeof firstUpdate.percentage === 'number', 'Should have percentage');
-    });
-
-    // Test 52: uninstall() progress reaches 100%
-    await test('uninstall() progress callback reaches 100% at completion', async () => {
-      targetDir = path.join(tempDir, 'uninstall-progress-100-test');
-
-      // Install package
-      await installationEngine.installPackage('testool', 'standard', targetDir);
-
-      const progressUpdates = [];
-      const progressCallback = (progress) => {
-        progressUpdates.push(progress);
-      };
-
-      // Auto-confirm
-      const confirmCallback = async () => true;
-
-      // Uninstall
-      await installationEngine.uninstall('testool', targetDir, confirmCallback, progressCallback);
-
-      // Verify last update is 100%
-      const lastUpdate = progressUpdates[progressUpdates.length - 1];
-      assert.strictEqual(lastUpdate.percentage, 100, 'Final progress should be 100%');
-    });
-
-    // Test 53: uninstall() returns detailed result summary
-    await test('uninstall() returns detailed result with counts and paths', async () => {
-      targetDir = path.join(tempDir, 'uninstall-result-test');
-
-      // Install package
-      await installationEngine.installPackage('testool', 'lite', targetDir);
-
-      // Auto-confirm
-      const confirmCallback = async () => true;
-
-      // Uninstall
-      const result = await installationEngine.uninstall('testool', targetDir, confirmCallback);
-
-      assert.ok(result, 'Should return result object');
-      assert.ok('success' in result, 'Should have success field');
-      assert.ok('toolId' in result, 'Should have toolId field');
-      assert.ok('targetPath' in result, 'Should have targetPath field');
-      assert.ok('filesRemoved' in result, 'Should have filesRemoved field');
-      assert.ok('directoriesRemoved' in result, 'Should have directoriesRemoved field');
-      assert.ok('backupPath' in result, 'Should have backupPath field');
-      assert.ok('errors' in result, 'Should have errors array');
-      assert.ok('warnings' in result, 'Should have warnings array');
-      assert.ok('timestamp' in result, 'Should have timestamp');
-
-      assert.strictEqual(result.success, true, 'Should succeed');
-      assert.strictEqual(result.toolId, 'testool', 'Should have correct tool ID');
-      assert.ok(result.filesRemoved > 0, 'Should have removed files');
-    });
-
-    // Test 54: uninstall() handles missing files gracefully
-    await test('uninstall() handles missing files with warnings', async () => {
-      targetDir = path.join(tempDir, 'uninstall-missing-test');
-
-      // Install package
-      await installationEngine.installPackage('testool', 'lite', targetDir);
-
-      // Delete one agent file manually
-      const agentPath = path.join(targetDir, 'agents', 'master.md');
-      await fs.promises.unlink(agentPath);
-
-      // Auto-confirm
-      const confirmCallback = async () => true;
-
-      // Uninstall
-      const result = await installationEngine.uninstall('testool', targetDir, confirmCallback);
-
-      assert.strictEqual(result.success, true, 'Uninstall should still succeed');
-      assert.ok(result.warnings.length > 0, 'Should have warnings for missing files');
-      assert.ok(result.warnings.some(w => w.includes('not found')), 'Should warn about missing file');
-    });
-
-    // Test 55: uninstall() works without confirmation callback
-    await test('uninstall() works without confirmation callback (skips confirmation)', async () => {
-      targetDir = path.join(tempDir, 'uninstall-no-confirm-test');
-
-      // Install package
-      await installationEngine.installPackage('testool', 'lite', targetDir);
-
-      // Uninstall without confirmation callback
-      const result = await installationEngine.uninstall('testool', targetDir);
-
-      assert.strictEqual(result.success, true, 'Uninstall should succeed');
-
-      // Verify files are removed
-      const manifestPath = path.join(targetDir, 'manifest.json');
-      assert.ok(!fs.existsSync(manifestPath), 'Manifest should be removed');
-    });
-
-    // Test 56: uninstall() works without progress callback
-    await test('uninstall() works without progress callback', async () => {
-      targetDir = path.join(tempDir, 'uninstall-no-progress-test');
-
-      // Install package
-      await installationEngine.installPackage('testool', 'lite', targetDir);
-
-      // Auto-confirm
-      const confirmCallback = async () => true;
-
-      // Uninstall without progress callback
-      const result = await installationEngine.uninstall('testool', targetDir, confirmCallback);
-
-      assert.strictEqual(result.success, true, 'Uninstall should succeed');
-    });
-
-    // Test 57: uninstall() handles Pro variant with many files
-    await test('uninstall() successfully removes Pro variant with many files', async () => {
-      targetDir = path.join(tempDir, 'uninstall-pro-test');
-
-      // Install Pro variant
-      await installationEngine.installPackage('testool', 'pro', targetDir);
-
-      // Auto-confirm
-      const confirmCallback = async () => true;
-
-      // Uninstall
-      const result = await installationEngine.uninstall('testool', targetDir, confirmCallback);
-
-      assert.strictEqual(result.success, true, 'Uninstall should succeed');
-      assert.ok(result.filesRemoved > 15, 'Pro variant should remove many files');
-
-      // Verify all components are removed
-      const manifestPath = path.join(targetDir, 'manifest.json');
-      assert.ok(!fs.existsSync(manifestPath), 'Manifest should be removed');
-    });
-
-    // Test 58: uninstall() counts files in skill directories correctly
-    await test('uninstall() correctly counts files inside skill directories', async () => {
-      targetDir = path.join(tempDir, 'uninstall-skill-count-test');
-
-      // Install Standard variant (has skills)
-      await installationEngine.installPackage('testool', 'standard', targetDir);
-
-      // Track confirmation info
-      let fileCount = 0;
-      const confirmCallback = async (info) => {
-        fileCount = info.fileCount;
-        return true;
-      };
-
-      // Uninstall
-      const result = await installationEngine.uninstall('testool', targetDir, confirmCallback);
-
-      assert.strictEqual(result.success, true, 'Uninstall should succeed');
-      assert.ok(fileCount > 0, 'Should count files');
-
-      // File count should include files inside skill directories
-      // Standard has 13 agents + files in 2 skills + resources + hooks + manifest
-      assert.ok(fileCount >= 15, 'Should count files inside skill directories');
-    });
-
-    // Test 59: uninstall() reports errors for permission issues
-    await test('uninstall() handles and reports errors during removal', async () => {
-      targetDir = path.join(tempDir, 'uninstall-error-test');
-
-      // Install package
-      await installationEngine.installPackage('testool', 'lite', targetDir);
-
-      // Make a file read-only to simulate permission error (on Unix-like systems)
-      const agentPath = path.join(targetDir, 'agents', 'master.md');
-      if (fs.existsSync(agentPath)) {
-        // This test might not work on all systems, so we'll be lenient
-        try {
-          await fs.promises.chmod(path.dirname(agentPath), 0o444); // Read-only directory
-        } catch (error) {
-          // Skip this test if we can't set permissions
-          console.log('  (Skipping permission test - not supported on this system)');
-          return;
-        }
-
-        // Auto-confirm
-        const confirmCallback = async () => true;
-
-        // Uninstall (might fail on some files)
-        const result = await installationEngine.uninstall('testool', targetDir, confirmCallback);
-
-        // Restore permissions for cleanup
-        await fs.promises.chmod(path.dirname(agentPath), 0o755);
-
-        // The result might have errors
-        // We're mainly testing that it doesn't crash
-        assert.ok(result, 'Should return a result even with errors');
-      }
-    });
-
-    // Test 60: uninstall() backup contains complete installation
-    await test('uninstall() backup contains complete copy of installation', async () => {
-      targetDir = path.join(tempDir, 'uninstall-backup-complete-test');
-
-      // Install package
-      await installationEngine.installPackage('testool', 'standard', targetDir);
-
-      // Count files before uninstall
-      const filesBefore = await countFilesRecursive(targetDir);
-
-      // Auto-confirm
-      const confirmCallback = async () => true;
-
-      // Uninstall
-      const result = await installationEngine.uninstall('testool', targetDir, confirmCallback);
-
-      assert.strictEqual(result.success, true, 'Uninstall should succeed');
-      assert.ok(result.backupPath, 'Should create backup');
-
-      // Count files in backup
-      const filesInBackup = await countFilesRecursive(result.backupPath);
-
-      assert.strictEqual(filesInBackup, filesBefore, 'Backup should contain all original files');
-
-      // Verify backup has manifest
-      const backupManifest = path.join(result.backupPath, 'manifest.json');
-      assert.ok(fs.existsSync(backupManifest), 'Backup should have manifest');
-    });
-
-  } finally {
-    // Cleanup
-    if (tempDir) {
-      await cleanupTempDir(tempDir);
-    }
-  }
-
-  // Print summary
-  console.log(`\n${colors.bright}Test Summary${colors.reset}`);
-  console.log(`Total: ${totalTests}`);
-  console.log(`${colors.green}Passed: ${passedTests}${colors.reset}`);
-  console.log(`${colors.red}Failed: ${failedTests}${colors.reset}`);
-
-  if (failedTests === 0) {
-    console.log(`\n${colors.green}${colors.bright}All tests passed!${colors.reset}\n`);
-  } else {
-    console.log(`\n${colors.red}${colors.bright}Some tests failed.${colors.reset}\n`);
-    process.exit(1);
-  }
-}
-
-// Run tests
-runTests().catch(error => {
-  console.error(`${colors.red}Fatal error running tests: ${error.message}${colors.reset}`);
-  console.error(error.stack);
-  process.exit(1);
-});