sinapse-ai 9.3.0 → 9.5.0

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

@@ -148,20 +148,22 @@ describe('Environment Configuration Integration', () => {
       expect(mode).toBe(0o600);
     });
 
-    it('should create backup of existing .env in non-prompt mode', async () => {
-      // Create existing .env
+    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');
 
-      // Run configuration (skipPrompts mode doesn't backup)
+      // Story 10.38: merge-only policy — existing values are ALWAYS preserved.
       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');
+      // 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 () => {

package/packages/installer/tests/unit/detection/detect-project-type.test.js

@@ -1,6 +1,6 @@
 const fs = require('fs');
 const path = require('path');
-const { detectProjectType } = require('../../../src/detection/detect-project-type');
+const { detectProjectType, detectProjectTypeExtended } = require('../../../src/detection/detect-project-type');
 
 // Mock fs module
 jest.mock('fs');
@@ -399,4 +399,141 @@ describe('detectProjectType', () => {
   });
 });
 
+// ============================================================================
+// detectProjectTypeExtended
+// ============================================================================
+describe('detectProjectTypeExtended', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    jest.spyOn(console, 'error').mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    console.error.mockRestore();
+  });
+
+  test('returns object with type, techStack, maturityScore, recommendations', () => {
+    fs.existsSync.mockImplementation((checkPath) => {
+      if (checkPath === path.resolve('/test/ext')) return true;
+      return false;
+    });
+    fs.readdirSync.mockReturnValue([]);
+
+    const result = detectProjectTypeExtended('/test/ext');
+
+    expect(result).toHaveProperty('type', 'GREENFIELD');
+    expect(result).toHaveProperty('techStack');
+    expect(result).toHaveProperty('maturityScore', 0);
+    expect(result).toHaveProperty('recommendations');
+    expect(Array.isArray(result.recommendations)).toBe(true);
+  });
+
+  test('GREENFIELD returns empty tech stack and score 0', () => {
+    fs.existsSync.mockImplementation((checkPath) => {
+      if (checkPath === path.resolve('/test/green')) return true;
+      return false;
+    });
+    fs.readdirSync.mockReturnValue([]);
+
+    const result = detectProjectTypeExtended('/test/green');
+
+    expect(result.type).toBe('GREENFIELD');
+    expect(result.techStack.framework).toBeNull();
+    expect(result.techStack.language).toBeNull();
+    expect(result.techStack.database).toBeNull();
+    expect(result.techStack.testing).toBeNull();
+    expect(result.techStack.ci).toBeNull();
+    expect(result.maturityScore).toBe(0);
+  });
+
+  test('detects framework from package.json dependencies', () => {
+    const dir = path.resolve('/test/next-project');
+    fs.existsSync.mockImplementation((checkPath) => {
+      if (checkPath === dir) return true;
+      if (checkPath === path.join(dir, 'package.json')) return true;
+      if (checkPath === path.join(dir, 'tsconfig.json')) return true;
+      return false;
+    });
+    fs.readdirSync.mockImplementation((readDir) => {
+      if (typeof readDir === 'string' && readDir === dir) return ['package.json', 'tsconfig.json', 'src'];
+      return [];
+    });
+    fs.readFileSync.mockReturnValue(JSON.stringify({
+      dependencies: { next: '14.0.0', react: '18.0.0' },
+      devDependencies: { jest: '29.0.0' },
+    }));
+
+    const result = detectProjectTypeExtended('/test/next-project');
 
+    expect(result.type).toBe('BROWNFIELD');
+    expect(result.techStack.framework).toBe('next');
+    expect(result.techStack.language).toBe('typescript');
+    expect(result.techStack.testing).toBe('jest');
+  });
+
+  test('detects CI from .github/workflows', () => {
+    const dir = path.resolve('/test/ci-project');
+    fs.existsSync.mockImplementation((checkPath) => {
+      if (checkPath === dir) return true;
+      if (checkPath === path.join(dir, '.git')) return true;
+      if (checkPath === path.join(dir, '.github', 'workflows')) return true;
+      return false;
+    });
+    fs.readdirSync.mockImplementation((readDir) => {
+      if (typeof readDir === 'string' && readDir === dir) return ['.git', '.github'];
+      return [];
+    });
+
+    const result = detectProjectTypeExtended('/test/ci-project');
+
+    expect(result.techStack.ci).toBe('github-actions');
+  });
+
+  test('builds recommendations for missing items', () => {
+    const dir = path.resolve('/test/recs');
+    fs.existsSync.mockImplementation((checkPath) => {
+      if (checkPath === dir) return true;
+      if (checkPath === path.join(dir, 'package.json')) return true;
+      return false;
+    });
+    fs.readdirSync.mockImplementation((readDir) => {
+      if (typeof readDir === 'string' && readDir === dir) return ['package.json'];
+      return [];
+    });
+    fs.readFileSync.mockReturnValue(JSON.stringify({ dependencies: {} }));
+
+    const result = detectProjectTypeExtended('/test/recs');
+
+    expect(result.recommendations).toEqual(expect.arrayContaining([
+      expect.stringContaining('testing framework'),
+      expect.stringContaining('CI/CD'),
+      expect.stringContaining('.env.example'),
+      expect.stringContaining('README'),
+    ]));
+  });
+
+  test('backward compat: detectProjectType returns same string as extended .type', () => {
+    fs.existsSync.mockImplementation((checkPath) => {
+      if (checkPath === path.resolve('/test/compat')) return true;
+      if (checkPath.endsWith('package.json')) return true;
+      return false;
+    });
+    fs.readdirSync.mockImplementation((readDir) => {
+      if (typeof readDir === 'string') return ['package.json'];
+      return [];
+    });
+    fs.readFileSync.mockReturnValue(JSON.stringify({ dependencies: {} }));
+
+    const simple = detectProjectType('/test/compat');
+    const extended = detectProjectTypeExtended('/test/compat');
+
+    expect(simple).toBe(extended.type);
+    expect(simple).toBe('BROWNFIELD');
+  });
+
+  test('throws same errors as original for invalid input', () => {
+    expect(() => detectProjectTypeExtended(null)).toThrow('Invalid targetDir parameter');
+    expect(() => detectProjectTypeExtended('')).toThrow('Invalid targetDir parameter');
+    expect(() => detectProjectTypeExtended(123)).toThrow('Invalid targetDir parameter');
+  });
+});

package/packages/installer/tests/unit/doctor/doctor-orchestrator.test.js

@@ -14,8 +14,8 @@ const projectRoot = path.resolve(__dirname, '..', '..', '..', '..', '..');
 
 describe('Doctor Orchestrator', () => {
   describe('version', () => {
-    it('should export DOCTOR_VERSION as 2.0.0', () => {
-      expect(DOCTOR_VERSION).toBe('2.0.0');
+    it('should export DOCTOR_VERSION as semver string (Story A.3 bumped to 2.1.0)', () => {
+      expect(DOCTOR_VERSION).toBe('2.1.0');
     });
   });
 
@@ -24,7 +24,7 @@ describe('Doctor Orchestrator', () => {
       const result = await runDoctorChecks({ projectRoot });
       expect(result).toHaveProperty('formatted');
       expect(result).toHaveProperty('data');
-      expect(result.data).toHaveProperty('version', '2.0.0');
+      expect(result.data).toHaveProperty('version', '2.1.0');
       expect(result.data).toHaveProperty('summary');
       expect(result.data).toHaveProperty('checks');
     });