sinapse-ai 1.8.0 → 1.9.1

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

@@ -1,192 +0,0 @@
-/**
- * Unit Tests: Doctor Orchestrator
- * Story INS-4.1: sinapse doctor rewrite
- *
- * Tests for options forwarding, output format, and fix/dry-run behavior.
- */
-
-const fs = require('fs');
-const os = require('os');
-const path = require('path');
-
-// Use real modules for orchestrator testing (checks will hit real filesystem)
-const { runDoctorChecks, DOCTOR_VERSION, resolveExitCode } = require('../../../../../.sinapse-ai/core/doctor');
-
-const projectRoot = path.resolve(__dirname, '..', '..', '..', '..', '..');
-
-describe('Doctor Orchestrator', () => {
-  describe('version', () => {
-    it('should export DOCTOR_VERSION as semver string (Story A.3 bumped to 2.1.0)', () => {
-      expect(DOCTOR_VERSION).toBe('2.1.0');
-    });
-  });
-
-  describe('options forwarding (AC1)', () => {
-    it('should accept and use options object', async () => {
-      const result = await runDoctorChecks({ projectRoot });
-      expect(result).toHaveProperty('formatted');
-      expect(result).toHaveProperty('data');
-      expect(result.data).toHaveProperty('version', '2.1.0');
-      expect(result.data).toHaveProperty('summary');
-      expect(result.data).toHaveProperty('checks');
-    });
-
-    it('should produce JSON when json option is true', async () => {
-      const result = await runDoctorChecks({ json: true, projectRoot });
-      expect(result.formatted).toBeTruthy();
-
-      // Should be valid JSON
-      const parsed = JSON.parse(result.formatted);
-      expect(parsed).toHaveProperty('version');
-      expect(parsed).toHaveProperty('summary');
-      expect(parsed).toHaveProperty('checks');
-    });
-
-    it('should produce text when json option is false', async () => {
-      const result = await runDoctorChecks({ json: false, projectRoot });
-      expect(result.formatted).toContain('SINAPSE Doctor');
-      expect(result.formatted).toContain('Summary:');
-    });
-  });
-
-  describe('15 checks (AC2 + INS-4.8)', () => {
-    it('should run exactly 15 checks', async () => {
-      const result = await runDoctorChecks({ projectRoot });
-      expect(result.data.checks).toHaveLength(16);
-    });
-
-    it('should return valid status for each check', async () => {
-      const result = await runDoctorChecks({ projectRoot });
-      const validStatuses = ['PASS', 'WARN', 'FAIL', 'INFO'];
-
-      for (const check of result.data.checks) {
-        expect(validStatuses).toContain(check.status);
-        expect(check).toHaveProperty('check');
-        expect(check).toHaveProperty('message');
-      }
-    });
-
-    it('should include all expected check names', async () => {
-      const result = await runDoctorChecks({ projectRoot });
-      const checkNames = result.data.checks.map((c) => c.check);
-
-      expect(checkNames).toContain('settings-json');
-      expect(checkNames).toContain('rules-files');
-      expect(checkNames).toContain('agent-memory');
-      expect(checkNames).toContain('entity-registry');
-      expect(checkNames).toContain('git-hooks');
-      expect(checkNames).toContain('core-config');
-      expect(checkNames).toContain('claude-md');
-      expect(checkNames).toContain('ide-sync');
-      expect(checkNames).toContain('graph-dashboard');
-      expect(checkNames).toContain('code-intel');
-      expect(checkNames).toContain('node-version');
-      expect(checkNames).toContain('npm-packages');
-      expect(checkNames).toContain('skills-count');
-      expect(checkNames).toContain('commands-count');
-      expect(checkNames).toContain('hooks-claude-count');
-      expect(checkNames).toContain('manifest-version-parity');
-    });
-  });
-
-  describe('summary (AC3)', () => {
-    it('should have pass/warn/fail/info counts that sum to 15', async () => {
-      const result = await runDoctorChecks({ projectRoot });
-      const { pass, warn, fail, info } = result.data.summary;
-      expect(pass + warn + fail + info).toBe(16);
-    });
-
-    it('should include Summary line in text output', async () => {
-      const result = await runDoctorChecks({ projectRoot });
-      expect(result.formatted).toMatch(/Summary: \d+ PASS \| \d+ WARN \| \d+ FAIL \| \d+ INFO/);
-    });
-  });
-
-  describe('--dry-run (AC4)', () => {
-    it('should include fixResults when dryRun is true', async () => {
-      const result = await runDoctorChecks({ dryRun: true, projectRoot });
-      expect(result.data).toHaveProperty('fixResults');
-    });
-
-    it('should not produce file changes with dryRun', async () => {
-      const result = await runDoctorChecks({ dryRun: true, projectRoot });
-      if (result.data.fixResults) {
-        for (const fr of result.data.fixResults) {
-          expect(fr.applied).toBe(false);
-        }
-      }
-    });
-  });
-
-  describe('NOT_INSTALLED short-circuit (Story 10.42)', () => {
-    let tempDir;
-    let fakeHome;
-
-    beforeEach(() => {
-      // Isolated projectRoot + fake HOME so the doctor cannot see the
-      // developer's real ~/.sinapse or ~/.claude. Passing homeDir via
-      // options is the reliable way across POSIX and Windows (os.homedir
-      // sometimes ignores env changes mid-process).
-      tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'sinapse-doctor-fresh-'));
-      fakeHome = fs.mkdtempSync(path.join(os.tmpdir(), 'sinapse-doctor-home-'));
-    });
-
-    afterEach(() => {
-      try { fs.rmSync(tempDir, { recursive: true, force: true }); } catch {}
-      try { fs.rmSync(fakeHome, { recursive: true, force: true }); } catch {}
-    });
-
-    it('should return notInstalled=true when no SINAPSE markers exist', async () => {
-      const result = await runDoctorChecks({ projectRoot: tempDir, homeDir: fakeHome });
-      expect(result.data.notInstalled).toBe(true);
-      expect(result.data.installCommand).toBe('npx sinapse-ai install');
-      expect(result.data.checks).toHaveLength(0);
-    });
-
-    it('should produce friendly NOT_INSTALLED text (no FAIL lines)', async () => {
-      const result = await runDoctorChecks({ projectRoot: tempDir, homeDir: fakeHome });
-      expect(result.formatted).toContain('SINAPSE is not installed');
-      expect(result.formatted).toContain('npx sinapse-ai install');
-      expect(result.formatted).not.toContain('[FAIL]');
-    });
-
-    it('should include notInstalled flag in JSON output', async () => {
-      const result = await runDoctorChecks({ json: true, projectRoot: tempDir, homeDir: fakeHome });
-      const parsed = JSON.parse(result.formatted);
-      expect(parsed.notInstalled).toBe(true);
-      expect(parsed.installCommand).toBe('npx sinapse-ai install');
-    });
-
-    it('should map to exit code 4', async () => {
-      const result = await runDoctorChecks({ projectRoot: tempDir, homeDir: fakeHome });
-      expect(resolveExitCode(result)).toBe(4);
-    });
-
-    it('should fall back to full check suite when a project marker exists', async () => {
-      // Drop a .sinapse-ai/ dir into the temp project. That alone should
-      // flip detection to installed=true and run the full check path.
-      fs.mkdirSync(path.join(tempDir, '.sinapse-ai'), { recursive: true });
-      const result = await runDoctorChecks({ projectRoot: tempDir, homeDir: fakeHome });
-      expect(result.data.notInstalled).toBeUndefined();
-      expect(result.data.checks.length).toBeGreaterThan(0);
-    });
-  });
-
-  describe('JSON output schema (AC3)', () => {
-    it('should match expected JSON schema', async () => {
-      const result = await runDoctorChecks({ json: true, projectRoot });
-      const parsed = JSON.parse(result.formatted);
-
-      expect(parsed).toHaveProperty('version');
-      expect(parsed).toHaveProperty('timestamp');
-      expect(parsed).toHaveProperty('summary');
-      expect(parsed.summary).toHaveProperty('pass');
-      expect(parsed.summary).toHaveProperty('warn');
-      expect(parsed.summary).toHaveProperty('fail');
-      expect(parsed.summary).toHaveProperty('info');
-      expect(parsed).toHaveProperty('checks');
-      expect(Array.isArray(parsed.checks)).toBe(true);
-    });
-  });
-});
-

package/packages/installer/tests/unit/entity-registry-bootstrap.test.js

@@ -1,186 +0,0 @@
-'use strict';
-
-/**
- * Entity Registry Bootstrap Tests (Story INS-4.6)
- *
- * Validates that the installer calls populate-entity-registry.js during install,
- * handles failures gracefully, and that sinapse doctor can verify the registry.
- */
-
-const fs = require('fs');
-const path = require('path');
-
-const WIZARD_PATH = path.join(__dirname, '..', '..', 'src', 'wizard', 'index.js');
-const POPULATE_SCRIPT = path.join(
-  __dirname, '..', '..', '..', '..', '.sinapse-ai', 'development', 'scripts', 'populate-entity-registry.js'
-);
-const DOCTOR_CHECK = path.join(
-  __dirname, '..', '..', '..', '..', '.sinapse-ai', 'core', 'doctor', 'checks', 'entity-registry.js'
-);
-const REGISTRY_PATH = path.join(
-  __dirname, '..', '..', '..', '..', '.sinapse-ai', 'data', 'entity-registry.yaml'
-);
-const PRE_PUSH_HOOK = path.join(__dirname, '..', '..', '..', '..', '.husky', 'pre-push');
-const IDS_PRE_PUSH = path.join(
-  __dirname, '..', '..', '..', '..', '.sinapse-ai', 'hooks', 'ids-pre-push.js'
-);
-
-describe('Entity Registry Bootstrap (Story INS-4.6)', () => {
-  let wizardSource;
-
-  beforeAll(() => {
-    wizardSource = fs.readFileSync(WIZARD_PATH, 'utf8');
-  });
-
-  describe('AC1: Bootstrap called during install', () => {
-    test('wizard calls populate-entity-registry.js', () => {
-      expect(wizardSource).toContain('populate-entity-registry.js');
-      expect(wizardSource).toContain('Bootstrapping entity registry');
-    });
-
-    test('bootstrap runs after .sinapse-ai/ copy (injection order)', () => {
-      const sinapseCoreIdx = wizardSource.indexOf('SINAPSE core installed');
-      const bootstrapIdx = wizardSource.indexOf('Bootstrapping entity registry');
-      const envConfigIdx = wizardSource.indexOf('Configuring environment');
-
-      // Bootstrap must come after sinapse-ai install
-      expect(bootstrapIdx).toBeGreaterThan(sinapseCoreIdx);
-      // Bootstrap must come before environment configuration
-      expect(bootstrapIdx).toBeLessThan(envConfigIdx);
-    });
-
-    test('bootstrap has try/catch — failure does not abort install', () => {
-      // Verify the bootstrap block is wrapped in try/catch
-      expect(wizardSource).toContain("answers.entityRegistryStatus = 'failed'");
-      expect(wizardSource).toContain('Entity registry bootstrap failed');
-      // Should warn, not throw
-      expect(wizardSource).toContain("run 'sinapse doctor' post-install");
-    });
-
-    test('bootstrap uses 30s timeout guard', () => {
-      expect(wizardSource).toContain('timeout: 30000');
-    });
-
-    test('bootstrap reports entity count on success', () => {
-      expect(wizardSource).toContain("answers.entityRegistryStatus = 'populated'");
-      expect(wizardSource).toContain('answers.entityRegistryCount');
-      expect(wizardSource).toContain('answers.entityRegistryMs');
-    });
-
-    test('bootstrap handles missing script gracefully', () => {
-      expect(wizardSource).toContain("answers.entityRegistryStatus = 'skipped'");
-      expect(wizardSource).toContain('Entity registry script not found');
-    });
-  });
-
-  describe('AC2: Sanity check (relative threshold)', () => {
-    test('sinapse doctor entity-registry check exists', () => {
-      expect(fs.existsSync(DOCTOR_CHECK)).toBe(true);
-    });
-
-    test('doctor check uses relative validation (file exists + non-empty), not fixed threshold', () => {
-      const checkSource = fs.readFileSync(DOCTOR_CHECK, 'utf8');
-
-      // Should check file existence
-      expect(checkSource).toContain('existsSync');
-      // Should NOT have hardcoded threshold like >= 500
-      expect(checkSource).not.toMatch(/>= ?\d{3}/);
-      // Should report line count (relative measure)
-      expect(checkSource).toContain('lineCount');
-    });
-
-    test('doctor check validates recency (mtime)', () => {
-      const checkSource = fs.readFileSync(DOCTOR_CHECK, 'utf8');
-      expect(checkSource).toContain('mtimeMs');
-      expect(checkSource).toContain('MAX_AGE_MS');
-    });
-  });
-
-  describe('AC3: No duplication with pre-push hook', () => {
-    test('pre-push hook calls pre-push-safety.js, not populate script', () => {
-      const hookContent = fs.readFileSync(PRE_PUSH_HOOK, 'utf8');
-      expect(hookContent).toContain('pre-push-safety.js');
-      expect(hookContent).not.toContain('populate-entity-registry.js');
-    });
-
-    test('ids-pre-push.js uses RegistryUpdater.processChanges (incremental)', () => {
-      const idsSource = fs.readFileSync(IDS_PRE_PUSH, 'utf8');
-      expect(idsSource).toContain('RegistryUpdater');
-      expect(idsSource).toContain('processChanges');
-    });
-
-    test('bootstrap uses populate-entity-registry.js (full scan), distinct from incremental', () => {
-      // Wizard calls populate-entity-registry.js
-      expect(wizardSource).toContain('populate-entity-registry.js');
-      // Wizard does NOT call ids-pre-push.js
-      expect(wizardSource).not.toContain('ids-pre-push.js');
-    });
-  });
-
-  describe('AC4: Performance guard', () => {
-    test('populate-entity-registry.js exists and is executable', () => {
-      expect(fs.existsSync(POPULATE_SCRIPT)).toBe(true);
-    });
-
-    test('populate script has programmatic API (module.exports)', () => {
-      const scriptSource = fs.readFileSync(POPULATE_SCRIPT, 'utf8');
-      expect(scriptSource).toContain('module.exports');
-      expect(scriptSource).toContain('populate');
-    });
-
-    test('measured runtime is well under 15s threshold', () => {
-      // Run the actual script and measure time
-      const { execSync } = require('child_process');
-      const projectRoot = path.join(__dirname, '..', '..', '..', '..');
-      const start = Date.now();
-
-      try {
-        execSync(`node "${POPULATE_SCRIPT}"`, {
-          cwd: projectRoot,
-          encoding: 'utf8',
-          timeout: 30000,
-          stdio: 'pipe',
-        });
-      } catch {
-        // Script may fail in some environments — that's ok for timing test
-        console.log('SKIP: populate script execution failed — timing not measured');
-        return;
-      }
-
-      const elapsed = Date.now() - start;
-      // Must be under 15s (AC4 threshold)
-      expect(elapsed).toBeLessThan(15000);
-      console.log(`Measured runtime: ${(elapsed / 1000).toFixed(2)}s`);
-    });
-  });
-
-  describe('AC5: Post-bootstrap verification', () => {
-    test('entity-registry.yaml exists after bootstrap', () => {
-      expect(fs.existsSync(REGISTRY_PATH)).toBe(true);
-    });
-
-    test('entity-registry.yaml has at least 1 entity (non-empty)', () => {
-      const content = fs.readFileSync(REGISTRY_PATH, 'utf8');
-      const match = content.match(/entityCount:\s*(\d+)/);
-      expect(match).not.toBeNull();
-      const count = parseInt(match[1], 10);
-      expect(count).toBeGreaterThan(0);
-    });
-
-    // NOTE: This test depends on AC4 "measured runtime" test running first,
-    // which executes populate-entity-registry.js and refreshes the file mtime.
-    test('entity-registry.yaml updatedAt is recent (within 5 minutes)', () => {
-      const stat = fs.statSync(REGISTRY_PATH);
-      const ageMs = Date.now() - stat.mtimeMs;
-      const FIVE_MINUTES = 5 * 60 * 1000;
-      expect(ageMs).toBeLessThan(FIVE_MINUTES);
-    });
-
-    test('sinapse doctor entity-registry check passes on current registry', async () => {
-      const { run } = require(DOCTOR_CHECK);
-      const projectRoot = path.join(__dirname, '..', '..', '..', '..');
-      const result = await run({ projectRoot });
-      expect(result.status).toBe('PASS');
-    });
-  });
-});

package/packages/installer/tests/unit/env-template.test.js

@@ -1,187 +0,0 @@
-/**
- * Unit Tests: .env Template Generator
- * Story 1.6: Environment Configuration
- *
- * Tests for env-template.js
- */
-
-const { generateEnvContent, generateEnvExample } = require('../../src/config/templates/env-template');
-
-describe('.env Template Generator', () => {
-  describe('generateEnvContent', () => {
-    it('should generate .env with empty API keys when none provided', () => {
-      const content = generateEnvContent();
-
-      expect(content).toContain('NODE_ENV=development');
-      // Version-agnostic: check SINAPSE_VERSION exists with valid semver format
-      expect(content).toMatch(/SINAPSE_VERSION=\d+\.\d+\.\d+/);
-      expect(content).toContain('OPENAI_API_KEY=');
-      expect(content).toContain('ANTHROPIC_API_KEY=');
-      expect(content).toContain('# SINAPSE Environment Configuration');
-    });
-
-    it('should generate .env with provided API keys', () => {
-      const apiKeys = {
-        openai: 'sk-test-openai-key',
-        anthropic: 'sk-ant-test-anthropic-key',
-      };
-
-      const content = generateEnvContent(apiKeys);
-
-      expect(content).toContain('OPENAI_API_KEY=sk-test-openai-key');
-      expect(content).toContain('ANTHROPIC_API_KEY=sk-ant-test-anthropic-key');
-    });
-
-    it('should generate .env with optional service API keys', () => {
-      const apiKeys = {
-        clickup: 'clickup-test-key',
-        github: 'ghp-test-token',
-        exa: 'exa-test-key',
-      };
-
-      const content = generateEnvContent(apiKeys);
-
-      expect(content).toContain('CLICKUP_API_KEY=clickup-test-key');
-      expect(content).toContain('GITHUB_TOKEN=ghp-test-token');
-      expect(content).toContain('EXA_API_KEY=exa-test-key');
-    });
-
-    it('should include helpful comments', () => {
-      const content = generateEnvContent();
-
-      expect(content).toContain('# LLM Providers');
-      expect(content).toContain('# Search & Research Tools');
-      expect(content).toContain('Get your key at:');
-    });
-
-    it('should not contain sensitive data in comments', () => {
-      const content = generateEnvContent();
-
-      // Should not have example API keys or credentials in comments
-      expect(content).not.toMatch(/sk-[a-zA-Z0-9]{20,}/);
-      expect(content).not.toMatch(/example.*key.*[a-zA-Z0-9]{20,}/i);
-    });
-
-    it('should use KEY=value format without spaces', () => {
-      const apiKeys = { openai: 'test-key' };
-      const content = generateEnvContent(apiKeys);
-
-      // Check no spaces around =
-      const lines = content.split('\n').filter(line => !line.startsWith('#') && line.trim());
-      lines.forEach(line => {
-        if (line.includes('=')) {
-          expect(line).toMatch(/^[A-Z0-9_]+=.*/);
-          // Check there are NO spaces before or after the = sign
-          expect(line).not.toMatch(/\s=/); // No space before =
-          expect(line).not.toMatch(/=\s[^=]*$/); // No space after = (except in comments)
-        }
-      });
-    });
-  });
-
-  describe('generateEnvExample', () => {
-    it('should generate .env.example with empty values', () => {
-      const content = generateEnvExample();
-
-      expect(content).toContain('NODE_ENV=development');
-      // Version-agnostic: check SINAPSE_VERSION exists with valid semver format
-      expect(content).toMatch(/SINAPSE_VERSION=\d+\.\d+\.\d+/);
-      expect(content).toContain('OPENAI_API_KEY=');
-      expect(content).toContain('ANTHROPIC_API_KEY=');
-      expect(content).toContain('CLICKUP_API_KEY=');
-    });
-
-    it('should not contain any actual API keys', () => {
-      const content = generateEnvExample();
-
-      // All API key fields should be empty
-      const apiKeyLines = content.split('\n').filter(line =>
-        line.includes('_API_KEY=') || line.includes('_TOKEN='),
-      );
-
-      apiKeyLines.forEach(line => {
-        const [, value] = line.split('=');
-        expect(value.trim()).toBe('');
-      });
-    });
-
-    it('should include helpful comments with links', () => {
-      const content = generateEnvExample();
-
-      expect(content).toContain('https://platform.openai.com');
-      expect(content).toContain('https://console.anthropic.com');
-      expect(content).toContain('ClickUp Settings');
-      expect(content).toContain('https://github.com/settings/tokens');
-    });
-
-    it('should be safe to commit', () => {
-      const content = generateEnvExample();
-
-      // Should not contain any of these sensitive patterns
-      const sensitivePatterns = [
-        /sk-[a-zA-Z0-9]{20,}/, // OpenAI keys
-        /sk-ant-[a-zA-Z0-9]{30,}/, // Anthropic keys
-        /ghp_[a-zA-Z0-9]+/, // GitHub tokens
-      ];
-
-      sensitivePatterns.forEach(pattern => {
-        expect(content).not.toMatch(pattern);
-      });
-
-      // Check that no API key fields have actual values (only empty or commented)
-      const lines = content.split('\n').filter(line => !line.trim().startsWith('#'));
-      lines.forEach(line => {
-        if (line.includes('PASSWORD') || line.includes('SECRET') || line.includes('KEY') || line.includes('TOKEN')) {
-          const [key, value] = line.split('=');
-          if (value !== undefined) {
-            expect(value.trim()).toBe('');
-          }
-        }
-      });
-    });
-
-    it('should match .env structure but with empty values', () => {
-      const envContent = generateEnvContent({ openai: 'test', anthropic: 'test' });
-      const exampleContent = generateEnvExample();
-
-      // Extract non-comment, non-empty lines
-      const envKeys = envContent.split('\n')
-        .filter(line => line.trim() && !line.startsWith('#'))
-        .map(line => line.split('=')[0]);
-
-      const exampleKeys = exampleContent.split('\n')
-        .filter(line => line.trim() && !line.startsWith('#'))
-        .map(line => line.split('=')[0]);
-
-      // Both should have the same keys
-      expect(exampleKeys.sort()).toEqual(envKeys.sort());
-    });
-  });
-
-  describe('Content Quality', () => {
-    it('should have proper line endings', () => {
-      const content = generateEnvContent();
-
-      // Should use \n for line endings
-      expect(content).not.toContain('\r\n');
-      expect(content.split('\n').length).toBeGreaterThan(10);
-    });
-
-    it('should organize content in sections', () => {
-      const content = generateEnvContent();
-
-      // Should have clear section headers
-      expect(content).toContain('# SINAPSE Core Configuration');
-      expect(content).toContain('# LLM Providers');
-      expect(content).toContain('# Search & Research Tools');
-    });
-
-    it('should include usage instructions', () => {
-      const content = generateEnvContent();
-
-      // Should help users understand what to do
-      expect(content).toContain('DO NOT commit');
-      expect(content).toContain('Get yours at:');
-    });
-  });
-});