@wundr.io/cli 1.0.0 → 1.0.2-dev.20260530174250.ef0ec927

package/src/nlp/command-mapper.ts

@@ -1,7 +1,10 @@
+import { spawn } from 'child_process';
 import { EventEmitter } from 'events';
-import { spawn, ChildProcess } from 'child_process';
+
 import { logger } from '../utils/logger';
-import { IntentResult } from './intent-parser';
+
+import type { IntentResult } from './intent-parser';
+import type { ChildProcess } from 'child_process';
 
 /**
  * Command execution result
@@ -807,7 +810,9 @@ export class CommandMapper extends EventEmitter {
       case 'directory_exists':
         const fsDir = await import('fs-extra');
         const dirPath = parameters[rule.rule as string];
-        if (!dirPath) return false;
+        if (!dirPath) {
+          return false;
+        }
         const stats = await fsDir.stat(dirPath).catch(() => null);
         return stats ? stats.isDirectory() : false;
 

package/src/nlp/command-parser.ts

@@ -1,5 +1,6 @@
 import { logger } from '../utils/logger';
-import { AIService, ConversationContext } from '../ai/ai-service';
+
+import type { AIService, ConversationContext } from '../ai/ai-service';
 
 /**
  * Natural language command parsing result
@@ -141,7 +142,9 @@ export class CommandParser {
 
       for (let i = 0; i < steps.length; i++) {
         const step = steps[i];
-        if (!step) continue;
+        if (!step) {
+          continue;
+        }
 
         const stepResult = await this.parseCommand(step, context);
 

package/src/nlp/intent-parser.ts

@@ -1,7 +1,9 @@
 import { EventEmitter } from 'events';
-import { ClaudeClient, ClaudeMessage } from '../ai/claude-client';
+
 import { logger } from '../utils/logger';
 
+import type { ClaudeClient, ClaudeMessage } from '../ai/claude-client';
+
 /**
  * Intent classification result
  */
@@ -559,7 +561,9 @@ Extract parameters from the user input and respond with JSON only:
     };
 
     for (const [intent, pattern] of this.commandPatterns) {
-      if (!availableCommands.includes(intent)) continue;
+      if (!availableCommands.includes(intent)) {
+        continue;
+      }
 
       const confidence = this.calculatePatternScore(input, pattern);
 
@@ -592,7 +596,9 @@ Extract parameters from the user input and respond with JSON only:
 
       let matchCount = 0;
       for (const word of patternWords) {
-        if (word.startsWith('{') && word.endsWith('}')) continue; // Skip parameters
+        if (word.startsWith('{') && word.endsWith('}')) {
+          continue;
+        } // Skip parameters
         if (inputWords.includes(word)) {
           matchCount++;
         }
@@ -752,12 +758,13 @@ Analyze and respond with JSON only:
 
     if (patternResult.intent === aiResult.intent) {
       finalResult.confidence = Math.min(0.98, aiResult.confidence + 0.1);
-      finalResult.reasoning += ` (confirmed by pattern matching)`;
+      finalResult.reasoning += ' (confirmed by pattern matching)';
     } else if (patternResult.confidence > 0.8) {
       // High-confidence pattern match might override AI
       if (patternResult.confidence > aiResult.confidence) {
         finalResult = patternResult;
-        finalResult.reasoning += ` (overridden by high-confidence pattern match)`;
+        finalResult.reasoning +=
+          ' (overridden by high-confidence pattern match)';
       }
     }
 
@@ -784,7 +791,8 @@ Analyze and respond with JSON only:
     // Add safety warnings for destructive commands
     const commandPattern = this.commandPatterns.get(result.intent);
     if (commandPattern?.destructive) {
-      result.clarification = `This is a destructive operation. Are you sure you want to proceed?`;
+      result.clarification =
+        'This is a destructive operation. Are you sure you want to proceed?';
     }
 
     // Enrich with context-aware suggestions
@@ -922,7 +930,9 @@ Analyze and respond with JSON only:
 
     for (const command of availableCommands) {
       const pattern = this.commandPatterns.get(command);
-      if (!pattern) continue;
+      if (!pattern) {
+        continue;
+      }
 
       // Check if partial input matches command or examples
       const confidence = Math.max(
@@ -1063,8 +1073,12 @@ Provide ${limit} suggestions in JSON format:
       negativeWords.includes(word)
     ).length;
 
-    if (positiveCount > negativeCount) return 'positive';
-    if (negativeCount > positiveCount) return 'negative';
+    if (positiveCount > negativeCount) {
+      return 'positive';
+    }
+    if (negativeCount > positiveCount) {
+      return 'negative';
+    }
     return 'neutral';
   }
 

package/src/plugins/plugin-manager.ts

@@ -1,11 +1,19 @@
-import fs from 'fs-extra';
-import path from 'path';
 import { spawn, type ChildProcess } from 'child_process';
+import path from 'path';
+
 import chalk from 'chalk';
-import { ConfigManager } from '../utils/config-manager';
-import { logger } from '../utils/logger';
+import fs from 'fs-extra';
+
 import { errorHandler } from '../utils/error-handler';
-import { Plugin, PluginContext, PluginCommand, PluginHook } from '../types';
+import { logger } from '../utils/logger';
+
+import type {
+  Plugin,
+  PluginContext,
+  PluginCommand,
+  PluginHook,
+} from '../types';
+import type { ConfigManager } from '../utils/config-manager';
 
 /**
  * Plugin management system for CLI extensibility
@@ -306,28 +314,46 @@ export class PluginManager {
   }
 
   /**
-   * Get available plugins from registry
+   * Get available plugins by scanning the plugins directory on the filesystem.
+   * Returns an empty array if the directory does not exist or contains no valid plugins.
    */
   async getAvailablePlugins(): Promise<any[]> {
     try {
-      // This would query a plugin registry
-      // For now, return mock data
-      return [
-        {
-          name: '@wundr/plugin-git',
-          version: '1.0.0',
-          description: 'Git integration plugin',
-          downloads: 1000,
-          updated: new Date().toISOString(),
-        },
-        {
-          name: '@wundr/plugin-docker',
-          version: '1.2.0',
-          description: 'Docker integration plugin',
-          downloads: 800,
-          updated: new Date().toISOString(),
-        },
-      ];
+      if (!(await fs.pathExists(this.pluginsDir))) {
+        logger.debug(`Plugin directory not found: ${this.pluginsDir}`);
+        return [];
+      }
+
+      const entries = await fs.readdir(this.pluginsDir);
+      const plugins: any[] = [];
+
+      for (const entry of entries) {
+        const entryPath = path.join(this.pluginsDir, entry);
+        const packageJsonPath = path.join(entryPath, 'package.json');
+
+        if (!(await fs.pathExists(packageJsonPath))) {
+          continue;
+        }
+
+        try {
+          const packageJson = await fs.readJson(packageJsonPath);
+          const stat = await fs.stat(entryPath);
+          plugins.push({
+            name: packageJson.name || entry,
+            version: packageJson.version || 'unknown',
+            description: packageJson.description || '',
+            author: packageJson.author || '',
+            updated: stat.mtime.toISOString(),
+          });
+        } catch (parseError) {
+          logger.debug(
+            `Failed to read package.json for plugin ${entry}:`,
+            parseError
+          );
+        }
+      }
+
+      return plugins;
     } catch (error) {
       logger.debug('Failed to get available plugins:', error);
       return [];

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

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

package/src/types/index.ts

@@ -1,4 +1,4 @@
-import { Command } from 'commander';
+import type { Command } from 'commander';
 
 /**
  * Core types for the Wundr CLI