aios-core 2.1.0

package/packages/installer/tests/integration/environment-configuration.test.js

@@ -0,0 +1,328 @@
+/**
+ * Integration Tests: Environment Configuration
+ * Story 1.6: Environment Configuration
+ *
+ * Tests for configure-environment.js with file system operations
+ */
+
+const fs = require('fs-extra');
+const path = require('path');
+const os = require('os');
+const { configureEnvironment, updateGitignore } = require('../../src/config/configure-environment');
+
+/**
+ * Cleanup helper with retry logic for flaky file system operations
+ * Handles ENOTEMPTY and EBUSY errors common in CI environments
+ * @param {string} dir - Directory to remove
+ * @param {number} maxRetries - Maximum retry attempts
+ * @param {number} retryDelay - Delay between retries in ms
+ */
+async function cleanupWithRetry(dir, maxRetries = 5, retryDelay = 100) {
+  for (let attempt = 1; attempt <= maxRetries; attempt++) {
+    try {
+      if (await fs.pathExists(dir)) {
+        await fs.remove(dir);
+      }
+      return;
+    } catch (error) {
+      const isRetryable = error.code && ['ENOTEMPTY', 'EBUSY', 'EPERM', 'EACCES'].includes(error.code);
+      if (attempt === maxRetries || !isRetryable) {
+        // Last attempt failed or non-retryable error, log but don't throw
+        console.warn(`Warning: Failed to cleanup ${dir} after ${attempt} attempts:`, error.code);
+        return;
+      }
+      // Linear backoff (100ms, 200ms, 300ms...)
+      await new Promise(resolve => setTimeout(resolve, retryDelay * attempt));
+    }
+  }
+}
+
+describe('Environment Configuration Integration', () => {
+  let testDir;
+  let testId;
+
+  beforeEach(async () => {
+    // Create unique temporary test directory with random suffix to avoid collisions
+    testId = `${Date.now()}-${Math.random().toString(36).substring(2, 8)}`;
+    testDir = path.join(os.tmpdir(), `aios-env-test-${testId}`);
+    await fs.ensureDir(testDir);
+  });
+
+  afterEach(async () => {
+    // Small delay to allow file handles to close
+    await new Promise(resolve => setTimeout(resolve, 50));
+    // Cleanup test directory with retry logic
+    await cleanupWithRetry(testDir);
+  });
+
+  describe('configureEnvironment', () => {
+    it('should create .env file with skip prompts', async () => {
+      const result = await configureEnvironment({
+        targetDir: testDir,
+        skipPrompts: true,
+        projectType: 'GREENFIELD',
+        selectedIDEs: ['vscode'],
+        mcpServers: [],
+      });
+
+      expect(result.envCreated).toBe(true);
+
+      const envPath = path.join(testDir, '.env');
+      expect(await fs.pathExists(envPath)).toBe(true);
+
+      const content = await fs.readFile(envPath, 'utf8');
+      expect(content).toContain('NODE_ENV=development');
+      expect(content).toContain('AIOS_VERSION=2.1.0');
+    });
+
+    it('should create .env.example file', async () => {
+      const result = await configureEnvironment({
+        targetDir: testDir,
+        skipPrompts: true,
+      });
+
+      expect(result.envExampleCreated).toBe(true);
+
+      const envExamplePath = path.join(testDir, '.env.example');
+      expect(await fs.pathExists(envExamplePath)).toBe(true);
+
+      const content = await fs.readFile(envExamplePath, 'utf8');
+      expect(content).toContain('OPENAI_API_KEY=');
+      expect(content).not.toMatch(/sk-[a-zA-Z0-9]{20,}/);
+    });
+
+    it('should create core-config.yaml', async () => {
+      const result = await configureEnvironment({
+        targetDir: testDir,
+        skipPrompts: true,
+        projectType: 'BROWNFIELD',
+        selectedIDEs: ['vscode', 'cursor'],
+        mcpServers: [{ name: 'github' }, { name: 'exa' }],
+      });
+
+      expect(result.coreConfigCreated).toBe(true);
+
+      const configPath = path.join(testDir, '.aios-core', 'core-config.yaml');
+      expect(await fs.pathExists(configPath)).toBe(true);
+
+      const content = await fs.readFile(configPath, 'utf8');
+      expect(content).toContain('type: BROWNFIELD');
+      expect(content).toContain('- vscode');
+      expect(content).toContain('- cursor');
+      expect(content).toContain('- github');
+      expect(content).toContain('- exa');
+    });
+
+    it('should update .gitignore', async () => {
+      const result = await configureEnvironment({
+        targetDir: testDir,
+        skipPrompts: true,
+      });
+
+      expect(result.gitignoreUpdated).toBe(true);
+
+      const gitignorePath = path.join(testDir, '.gitignore');
+      expect(await fs.pathExists(gitignorePath)).toBe(true);
+
+      const content = await fs.readFile(gitignorePath, 'utf8');
+      expect(content).toContain('.env');
+    });
+
+    it('should set .env file permissions on Unix', async () => {
+      if (process.platform === 'win32') {
+        // Skip on Windows
+        return;
+      }
+
+      await configureEnvironment({
+        targetDir: testDir,
+        skipPrompts: true,
+      });
+
+      const envPath = path.join(testDir, '.env');
+      const stats = await fs.stat(envPath);
+
+      // Check permissions are 0600 (owner read/write only)
+      const mode = stats.mode & 0o777;
+      expect(mode).toBe(0o600);
+    });
+
+    it('should create backup of existing .env in non-prompt mode', async () => {
+      // Create existing .env
+      const envPath = path.join(testDir, '.env');
+      await fs.writeFile(envPath, 'EXISTING_KEY=existing_value', 'utf8');
+
+      // Run configuration (skipPrompts mode doesn't backup)
+      await configureEnvironment({
+        targetDir: testDir,
+        skipPrompts: true,
+      });
+
+      // In skipPrompts mode, no backup is created, file is overwritten
+      const content = await fs.readFile(envPath, 'utf8');
+      expect(content).not.toContain('EXISTING_KEY=existing_value');
+    });
+
+    it('should handle errors gracefully', async () => {
+      // Try to write to a read-only directory (simulate permission error)
+      const readOnlyDir = path.join(testDir, 'readonly');
+      await fs.ensureDir(readOnlyDir);
+
+      // Note: This test is platform-dependent and may not work on all systems
+      // Just verify the function handles errors
+      try {
+        await configureEnvironment({
+          targetDir: '/invalid/path/that/does/not/exist',
+          skipPrompts: true,
+        });
+        fail('Should have thrown an error');
+      } catch (error) {
+        expect(error).toBeDefined();
+      }
+    });
+  });
+
+  describe('updateGitignore', () => {
+    it('should create .gitignore if not exists', async () => {
+      await updateGitignore(testDir);
+
+      const gitignorePath = path.join(testDir, '.gitignore');
+      expect(await fs.pathExists(gitignorePath)).toBe(true);
+
+      const content = await fs.readFile(gitignorePath, 'utf8');
+      expect(content).toContain('.env');
+    });
+
+    it('should append to existing .gitignore', async () => {
+      const gitignorePath = path.join(testDir, '.gitignore');
+      await fs.writeFile(gitignorePath, 'node_modules\n*.log\n', 'utf8');
+
+      await updateGitignore(testDir);
+
+      const content = await fs.readFile(gitignorePath, 'utf8');
+      expect(content).toContain('node_modules');
+      expect(content).toContain('*.log');
+      expect(content).toContain('.env');
+    });
+
+    it('should not duplicate .env entry', async () => {
+      const gitignorePath = path.join(testDir, '.gitignore');
+      await fs.writeFile(gitignorePath, '.env\n', 'utf8');
+
+      await updateGitignore(testDir);
+
+      const content = await fs.readFile(gitignorePath, 'utf8');
+      const lines = content.split('\n').filter(line => line.trim() === '.env' || line.trim() === '/.env');
+      expect(lines.length).toBe(1);
+    });
+
+    it('should recognize existing .env entry with slash', async () => {
+      const gitignorePath = path.join(testDir, '.gitignore');
+      await fs.writeFile(gitignorePath, '/.env\n', 'utf8');
+
+      await updateGitignore(testDir);
+
+      const content = await fs.readFile(gitignorePath, 'utf8');
+      const lines = content.split('\n').filter(line => line.trim() === '.env' || line.trim() === '/.env');
+      expect(lines.length).toBe(1);
+    });
+  });
+
+  describe('Wizard Integration', () => {
+    it('should integrate with wizard state from previous stories', async () => {
+      // Simulate wizard state from Stories 1.3, 1.4, 1.5
+      const wizardState = {
+        projectType: 'GREENFIELD',
+        selectedIDEs: ['vscode', 'cursor'],
+        mcpServers: [
+          { name: 'github', id: 'github' },
+          { name: 'exa', id: 'exa' },
+        ],
+      };
+
+      const result = await configureEnvironment({
+        targetDir: testDir,
+        skipPrompts: true,
+        ...wizardState,
+      });
+
+      // Verify all files created
+      expect(result.envCreated).toBe(true);
+      expect(result.coreConfigCreated).toBe(true);
+      expect(result.gitignoreUpdated).toBe(true);
+
+      // Verify core-config includes wizard state
+      const configPath = path.join(testDir, '.aios-core', 'core-config.yaml');
+      const configContent = await fs.readFile(configPath, 'utf8');
+
+      expect(configContent).toContain('GREENFIELD');
+      expect(configContent).toContain('vscode');
+      expect(configContent).toContain('cursor');
+      expect(configContent).toContain('github');
+      expect(configContent).toContain('exa');
+    });
+  });
+
+  describe('Cross-Platform Compatibility', () => {
+    it('should handle Windows paths', async () => {
+      const result = await configureEnvironment({
+        targetDir: testDir,
+        skipPrompts: true,
+      });
+
+      expect(result.envCreated).toBe(true);
+      expect(result.coreConfigCreated).toBe(true);
+    });
+
+    it('should create valid YAML on all platforms', async () => {
+      await configureEnvironment({
+        targetDir: testDir,
+        skipPrompts: true,
+        projectType: 'GREENFIELD',
+      });
+
+      const yaml = require('js-yaml');
+      const configPath = path.join(testDir, '.aios-core', 'core-config.yaml');
+      const content = await fs.readFile(configPath, 'utf8');
+
+      // Should parse without errors
+      const parsed = yaml.load(content);
+      expect(parsed).toBeDefined();
+      expect(parsed.project.type).toBe('GREENFIELD');
+    });
+  });
+
+  describe('File Structure', () => {
+    it('should create correct directory structure', async () => {
+      await configureEnvironment({
+        targetDir: testDir,
+        skipPrompts: true,
+      });
+
+      // Check all expected files exist
+      const expectedFiles = [
+        '.env',
+        '.env.example',
+        '.gitignore',
+        '.aios-core/core-config.yaml',
+      ];
+
+      for (const file of expectedFiles) {
+        const filePath = path.join(testDir, file);
+        expect(await fs.pathExists(filePath)).toBe(true);
+      }
+    });
+
+    it('should create .aios-core directory if missing', async () => {
+      const aioscoreDir = path.join(testDir, '.aios-core');
+      expect(await fs.pathExists(aioscoreDir)).toBe(false);
+
+      await configureEnvironment({
+        targetDir: testDir,
+        skipPrompts: true,
+      });
+
+      expect(await fs.pathExists(aioscoreDir)).toBe(true);
+    });
+  });
+});

package/packages/installer/tests/integration/wizard-detection.test.js

@@ -0,0 +1,349 @@
+const fs = require('fs');
+const path = require('path');
+const { runWizard, getProjectType, confirmProjectType } = require('../../src/wizard/wizard');
+const { detectProjectType } = require('../../src/detection/detect-project-type');
+
+// Mock fs module
+jest.mock('fs');
+
+// Mock console methods to avoid test output pollution
+global.console = {
+  ...console,
+  log: jest.fn(),
+  error: jest.fn(),
+};
+
+describe('Wizard Integration with Project Type Detection', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  // ============================================================================
+  // Task 1.3.5.2: Test full wizard flow with GREENFIELD detection
+  // ============================================================================
+  describe('GREENFIELD Detection Flow', () => {
+    test('wizard correctly detects and processes GREENFIELD project', async () => {
+      // Setup: Empty directory (directory exists but no markers)
+      const targetPath = path.resolve('/test-greenfield');
+      fs.existsSync.mockImplementation((checkPath) => {
+        if (checkPath === targetPath) return true; // Directory exists
+        // No markers exist
+        if (checkPath.includes('.aios-core')) return false;
+        if (checkPath.includes('package.json')) return false;
+        if (checkPath.includes('.git')) return false;
+        return false;
+      });
+      fs.readdirSync.mockReturnValue([]);
+
+      const result = await runWizard({ targetDir: '/test-greenfield' });
+
+      expect(result.projectType).toBe('GREENFIELD');
+      expect(result.targetDir).toBe('/test-greenfield');
+      expect(console.log).toHaveBeenCalledWith(expect.stringContaining('GREENFIELD'));
+    });
+
+    test('getProjectType helper returns GREENFIELD for empty directory', () => {
+      const targetPath = path.resolve('/test/empty');
+      fs.existsSync.mockImplementation((checkPath) => {
+        if (checkPath === targetPath) return true;
+        if (checkPath.includes('.aios-core')) return false;
+        if (checkPath.includes('package.json')) return false;
+        if (checkPath.includes('.git')) return false;
+        return false;
+      });
+      fs.readdirSync.mockReturnValue([]);
+
+      const type = getProjectType('/test/empty');
+
+      expect(type).toBe('GREENFIELD');
+    });
+  });
+
+  // ============================================================================
+  // Task 1.3.5.3: Test full wizard flow with BROWNFIELD detection
+  // ============================================================================
+  describe('BROWNFIELD Detection Flow', () => {
+    test('wizard correctly detects and processes BROWNFIELD project with package.json', async () => {
+      // Setup: Directory with package.json
+      const targetPath = path.resolve('/test-brownfield');
+      fs.existsSync.mockImplementation((checkPath) => {
+        if (checkPath === targetPath) return true;
+        if (checkPath.includes('.aios-core')) return false; // No AIOS
+        if (checkPath.includes('package.json')) return true; // Has package.json
+        if (checkPath.includes('.git')) return false;
+        return false;
+      });
+      fs.readdirSync.mockReturnValue(['package.json', 'src', 'README.md']);
+
+      const result = await runWizard({ targetDir: '/test-brownfield' });
+
+      expect(result.projectType).toBe('BROWNFIELD');
+      expect(result.targetDir).toBe('/test-brownfield');
+      expect(console.log).toHaveBeenCalledWith(expect.stringContaining('BROWNFIELD'));
+    });
+
+    test('wizard correctly detects and processes BROWNFIELD project with .git', async () => {
+      // Setup: Directory with .git
+      const targetPath = path.resolve('/test-git');
+      fs.existsSync.mockImplementation((checkPath) => {
+        if (checkPath === targetPath) return true;
+        if (checkPath.includes('.aios-core')) return false; // No AIOS
+        if (checkPath.includes('package.json')) return false;
+        if (checkPath.includes('.git')) return true; // Has .git
+        return false;
+      });
+      fs.readdirSync.mockReturnValue(['.git', 'README.md']);
+
+      const result = await runWizard({ targetDir: '/test-git' });
+
+      expect(result.projectType).toBe('BROWNFIELD');
+      expect(console.log).toHaveBeenCalledWith(expect.stringContaining('BROWNFIELD'));
+    });
+
+    test('getProjectType helper returns BROWNFIELD for existing project', () => {
+      const targetPath = path.resolve('/test/brownfield');
+      fs.existsSync.mockImplementation((checkPath) => {
+        if (checkPath === targetPath) return true;
+        if (checkPath.includes('.aios-core')) return false;
+        if (checkPath.includes('package.json')) return true;
+        if (checkPath.includes('.git')) return false;
+        return false;
+      });
+      fs.readdirSync.mockReturnValue(['package.json', 'src']);
+
+      const type = getProjectType('/test/brownfield');
+
+      expect(type).toBe('BROWNFIELD');
+    });
+  });
+
+  // ============================================================================
+  // Task 1.3.5.4: Test full wizard flow with EXISTING_AIOS detection
+  // ============================================================================
+  describe('EXISTING_AIOS Detection Flow', () => {
+    test('wizard correctly detects and processes EXISTING_AIOS installation', async () => {
+      // Setup: Directory with .aios-core
+      fs.existsSync.mockImplementation((checkPath) => {
+        if (checkPath.includes('test-existing')) return true;
+        if (checkPath.endsWith('.aios-core')) return true;
+        return true; // Other files exist
+      });
+      fs.readdirSync.mockReturnValue(['.aios-core', 'package.json', '.git']);
+
+      const result = await runWizard({ targetDir: '/test-existing' });
+
+      expect(result.projectType).toBe('EXISTING_AIOS');
+      expect(result.targetDir).toBe('/test-existing');
+      expect(console.log).toHaveBeenCalledWith(expect.stringContaining('EXISTING_AIOS'));
+    });
+
+    test('confirmProjectType shows update/reinstall message for EXISTING_AIOS', async () => {
+      const confirmed = await confirmProjectType('EXISTING_AIOS');
+
+      expect(confirmed).toBe('EXISTING_AIOS');
+      expect(console.log).toHaveBeenCalledWith(
+        expect.stringContaining('update or reinstall'),
+      );
+    });
+
+    test('getProjectType helper returns EXISTING_AIOS when .aios-core exists', () => {
+      fs.existsSync.mockImplementation((checkPath) => {
+        if (checkPath.includes('existing')) return true;
+        if (checkPath.endsWith('.aios-core')) return true;
+        return false;
+      });
+      fs.readdirSync.mockReturnValue(['.aios-core']);
+
+      const type = getProjectType('/test/existing');
+
+      expect(type).toBe('EXISTING_AIOS');
+    });
+  });
+
+  // ============================================================================
+  // Task 1.3.5.5: Test user override of detection result
+  // ============================================================================
+  describe('User Override Functionality', () => {
+    test('confirmProjectType accepts detected type', async () => {
+      const confirmed = await confirmProjectType('GREENFIELD');
+
+      expect(confirmed).toBe('GREENFIELD');
+      expect(console.log).toHaveBeenCalledWith(expect.stringContaining('GREENFIELD'));
+    });
+
+    test('confirmProjectType shows appropriate message for each type', async () => {
+      const types = ['GREENFIELD', 'BROWNFIELD', 'EXISTING_AIOS', 'UNKNOWN'];
+
+      for (const type of types) {
+        jest.clearAllMocks();
+        const confirmed = await confirmProjectType(type);
+
+        expect(confirmed).toBe(type);
+        expect(console.log).toHaveBeenCalledWith(expect.stringContaining(type));
+      }
+    });
+
+    test('confirmProjectType provides description for GREENFIELD', async () => {
+      await confirmProjectType('GREENFIELD');
+
+      expect(console.log).toHaveBeenCalledWith(
+        expect.stringContaining('New project'),
+      );
+    });
+
+    test('confirmProjectType provides description for BROWNFIELD', async () => {
+      await confirmProjectType('BROWNFIELD');
+
+      expect(console.log).toHaveBeenCalledWith(
+        expect.stringContaining('Existing project'),
+      );
+    });
+  });
+
+  // ============================================================================
+  // Task 1.3.5.6: Test error handling and fallback to manual selection
+  // ============================================================================
+  describe('Error Handling in Wizard Flow', () => {
+    test('wizard propagates detection errors correctly', async () => {
+      // Setup: Invalid directory
+      fs.existsSync.mockImplementation((checkPath) => {
+        if (checkPath.includes('invalid')) return false;
+        return false;
+      });
+
+      await expect(runWizard({ targetDir: '/invalid' })).rejects.toThrow(
+        'Failed to detect project type',
+      );
+    });
+
+    test('wizard logs error message on detection failure', async () => {
+      // Setup: Permission error
+      fs.existsSync.mockImplementation(() => {
+        throw new Error('EACCES: permission denied');
+      });
+
+      await expect(runWizard({ targetDir: '/denied' })).rejects.toThrow();
+      // Check that console.error was called with the error message
+      const errorCalls = console.error.mock.calls;
+      const hasInstallationFailed = errorCalls.some(call => 
+        call.some(arg => String(arg).includes('Installation failed')),
+      );
+      expect(hasInstallationFailed).toBe(true);
+    });
+
+    test('confirmProjectType handles UNKNOWN type gracefully', async () => {
+      const confirmed = await confirmProjectType('UNKNOWN');
+
+      expect(confirmed).toBe('UNKNOWN');
+      expect(console.log).toHaveBeenCalledWith(
+        expect.stringContaining('Manual selection required'),
+      );
+    });
+  });
+
+  // ============================================================================
+  // Task 1.3.5.7: Verify detection result flows correctly to Story 1.4
+  // ============================================================================
+  describe('Integration with Downstream Stories', () => {
+    test('wizard returns configuration object with projectType for downstream use', async () => {
+      const targetPath = path.resolve('/test/downstream');
+      fs.existsSync.mockImplementation((checkPath) => {
+        if (checkPath === targetPath) return true;
+        if (checkPath.includes('.aios-core')) return false;
+        if (checkPath.includes('package.json')) return false;
+        if (checkPath.includes('.git')) return false;
+        return false;
+      });
+      fs.readdirSync.mockReturnValue([]);
+
+      const config = await runWizard({ targetDir: '/test/downstream' });
+
+      // Verify config has required fields for downstream stories
+      expect(config).toHaveProperty('projectType');
+      expect(config).toHaveProperty('targetDir');
+      expect(config.projectType).toBe('GREENFIELD');
+      expect(config.targetDir).toBe('/test/downstream');
+    });
+
+    test('getProjectType can be called independently by downstream stories', () => {
+      const targetPath = path.resolve('/test/standalone');
+      fs.existsSync.mockImplementation((checkPath) => {
+        if (checkPath === targetPath) return true;
+        if (checkPath.includes('.aios-core')) return false;
+        if (checkPath.includes('package.json')) return false;
+        if (checkPath.includes('.git')) return false;
+        return false;
+      });
+      fs.readdirSync.mockReturnValue([]);
+
+      // Story 1.4 (IDE Selection) can call this directly
+      const type = getProjectType('/test/standalone');
+
+      expect(type).toBe('GREENFIELD');
+      expect(typeof type).toBe('string');
+    });
+
+    test('detection result remains consistent across multiple calls', () => {
+      const targetPath = path.resolve('/test/consistent');
+      fs.existsSync.mockImplementation((checkPath) => {
+        if (checkPath === targetPath) return true;
+        if (checkPath.includes('.aios-core')) return false;
+        if (checkPath.includes('package.json')) return true;
+        if (checkPath.includes('.git')) return false;
+        return false;
+      });
+      fs.readdirSync.mockReturnValue(['package.json']);
+
+      const type1 = getProjectType('/test/consistent');
+      const type2 = getProjectType('/test/consistent');
+      const type3 = detectProjectType('/test/consistent');
+
+      expect(type1).toBe(type2);
+      expect(type2).toBe(type3);
+      expect(type1).toBe('BROWNFIELD');
+    });
+  });
+
+  // ============================================================================
+  // Default Behavior Tests
+  // ============================================================================
+  describe('Default Wizard Behavior', () => {
+    test('wizard uses process.cwd() when no targetDir provided', async () => {
+      const mockCwd = process.cwd();
+      
+      fs.existsSync.mockImplementation((checkPath) => {
+        if (checkPath === path.resolve(mockCwd)) return true;
+        return false;
+      });
+      fs.readdirSync.mockReturnValue([]);
+
+      const result = await runWizard();
+
+      expect(result.targetDir).toBe(mockCwd);
+      expect(result.projectType).toBe('GREENFIELD');
+    });
+
+    test('wizard displays welcome message', async () => {
+      fs.existsSync.mockImplementation(() => true);
+      fs.readdirSync.mockReturnValue([]);
+
+      await runWizard({ targetDir: '/test' });
+
+      expect(console.log).toHaveBeenCalledWith(
+        expect.stringContaining('Welcome to AIOS Installer'),
+      );
+    });
+
+    test('wizard displays detection step message', async () => {
+      fs.existsSync.mockImplementation(() => true);
+      fs.readdirSync.mockReturnValue([]);
+
+      await runWizard({ targetDir: '/test' });
+
+      expect(console.log).toHaveBeenCalledWith(
+        expect.stringContaining('Detecting project type'),
+      );
+    });
+  });
+});
+