sinapse-ai 1.9.0 → 1.9.1

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

@@ -1,332 +0,0 @@
-/**
- * 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(), `sinapse-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');
-      // Version-agnostic: check SINAPSE_VERSION exists with valid semver format
-      expect(content).toMatch(/SINAPSE_VERSION=\d+\.\d+\.\d+/);
-    });
-
-    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, '.sinapse-ai', '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 preserve existing .env values via merge (Story 10.38)', async () => {
-      // Create existing .env with a user-defined value
-      const envPath = path.join(testDir, '.env');
-      await fs.writeFile(envPath, 'EXISTING_KEY=existing_value', 'utf8');
-
-      // Story 10.38: merge-only policy — existing values are ALWAYS preserved.
-      await configureEnvironment({
-        targetDir: testDir,
-        skipPrompts: true,
-      });
-
-      const content = await fs.readFile(envPath, 'utf8');
-      // User value is preserved
-      expect(content).toContain('EXISTING_KEY=existing_value');
-      // SINAPSE variables are added
-      expect(content).toMatch(/OPENROUTER_API_KEY|ANTHROPIC_API_KEY|OPENAI_API_KEY/);
-    });
-
-    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, '.sinapse-ai', '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, '.sinapse-ai', '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',
-        '.sinapse-ai/core-config.yaml',
-      ];
-
-      for (const file of expectedFiles) {
-        const filePath = path.join(testDir, file);
-        expect(await fs.pathExists(filePath)).toBe(true);
-      }
-    });
-
-    it('should create .sinapse-ai directory if missing', async () => {
-      const sinapsecoreDir = path.join(testDir, '.sinapse-ai');
-      expect(await fs.pathExists(sinapsecoreDir)).toBe(false);
-
-      await configureEnvironment({
-        targetDir: testDir,
-        skipPrompts: true,
-      });
-
-      expect(await fs.pathExists(sinapsecoreDir)).toBe(true);
-    });
-  });
-});
-

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

@@ -1,352 +0,0 @@
-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('.sinapse-ai')) 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');
-      // Output uses lowercase format for display
-      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('.sinapse-ai')) 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('.sinapse-ai')) return false; // No SINAPSE
-        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('.sinapse-ai')) return false; // No SINAPSE
-        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('.sinapse-ai')) 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_SINAPSE detection
-  // ============================================================================
-  describe('EXISTING_SINAPSE Detection Flow', () => {
-    test('wizard correctly detects and processes EXISTING_SINAPSE installation', async () => {
-      // Setup: Directory with .sinapse-ai
-      fs.existsSync.mockImplementation((checkPath) => {
-        if (checkPath.includes('test-existing')) return true;
-        if (checkPath.endsWith('.sinapse-ai')) return true;
-        return true; // Other files exist
-      });
-      fs.readdirSync.mockReturnValue(['.sinapse-ai', 'package.json', '.git']);
-
-      const result = await runWizard({ targetDir: '/test-existing' });
-
-      expect(result.projectType).toBe('EXISTING_SINAPSE');
-      expect(result.targetDir).toBe('/test-existing');
-      // Output shows "brownfield" since EXISTING_SINAPSE is treated as brownfield update
-      expect(console.log).toHaveBeenCalledWith(expect.stringContaining('brownfield'));
-    });
-
-    test('confirmProjectType shows update/reinstall message for EXISTING_SINAPSE', async () => {
-      const confirmed = await confirmProjectType('EXISTING_SINAPSE');
-
-      expect(confirmed).toBe('EXISTING_SINAPSE');
-      expect(console.log).toHaveBeenCalledWith(
-        expect.stringContaining('update or reinstall'),
-      );
-    });
-
-    test('getProjectType helper returns EXISTING_SINAPSE when .sinapse-ai exists', () => {
-      fs.existsSync.mockImplementation((checkPath) => {
-        if (checkPath.includes('existing')) return true;
-        if (checkPath.endsWith('.sinapse-ai')) return true;
-        return false;
-      });
-      fs.readdirSync.mockReturnValue(['.sinapse-ai']);
-
-      const type = getProjectType('/test/existing');
-
-      expect(type).toBe('EXISTING_SINAPSE');
-    });
-  });
-
-  // ============================================================================
-  // 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_SINAPSE', '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(
-        'Directory does not exist',
-      );
-    });
-
-    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('.sinapse-ai')) 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('.sinapse-ai')) 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('.sinapse-ai')) 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 SINAPSE 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('Analyzing project directory'),
-      );
-    });
-  });
-});
-
-