sinapse-ai 1.8.0 → 1.9.1

package/packages/installer/src/__tests__/performance-benchmark.js

@@ -1,383 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * SINAPSE Installer Performance Benchmark
- * Story INS-2: Installer Performance Optimization
- *
- * Measures baseline performance metrics for the installer to track optimization progress.
- *
- * Usage:
- *   node performance-benchmark.js [--output <file>] [--runs <n>]
- *
- * Output:
- *   JSON report with phase timings and statistics
- */
-
-const fs = require('fs');
-const fse = require('fs-extra');
-const path = require('path');
-const crypto = require('crypto');
-const { performance } = require('perf_hooks');
-
-// Configuration
-const CONFIG = {
-  runs: 3, // Number of runs for averaging
-  outputFile: null, // Output file path (null = stdout)
-  testProjectSize: 1000, // Number of files for test project
-  verbose: false,
-};
-
-// Parse CLI arguments
-process.argv.slice(2).forEach((arg, i, arr) => {
-  if (arg === '--output' && arr[i + 1]) CONFIG.outputFile = arr[i + 1];
-  if (arg === '--runs' && arr[i + 1]) CONFIG.runs = parseInt(arr[i + 1], 10);
-  if (arg === '--verbose' || arg === '-v') CONFIG.verbose = true;
-  if (arg === '--help' || arg === '-h') {
-    console.log(`
-SINAPSE Installer Performance Benchmark
-
-Usage: node performance-benchmark.js [options]
-
-Options:
-  --output <file>   Save JSON report to file (default: stdout)
-  --runs <n>        Number of benchmark runs (default: 3)
-  --verbose, -v     Show detailed progress
-  --help, -h        Show this help
-
-Example:
-  node performance-benchmark.js --output baseline.json --runs 5
-`);
-    process.exit(0);
-  }
-});
-
-// Benchmark results structure
-const results = {
-  timestamp: new Date().toISOString(),
-  system: {
-    platform: process.platform,
-    arch: process.arch,
-    nodeVersion: process.version,
-    cpus: require('os').cpus().length,
-    totalMemory: Math.round(require('os').totalmem() / 1024 / 1024) + ' MB',
-  },
-  config: { ...CONFIG },
-  phases: {},
-  summary: {},
-};
-
-/**
- * Timer utility for measuring phase durations
- */
-class Timer {
-  constructor(name) {
-    this.name = name;
-    this.start = null;
-    this.end = null;
-    this.runs = [];
-  }
-
-  begin() {
-    this.start = performance.now();
-  }
-
-  stop() {
-    this.end = performance.now();
-    const duration = this.end - this.start;
-    this.runs.push(duration);
-    return duration;
-  }
-
-  getStats() {
-    if (this.runs.length === 0) return null;
-    const sorted = [...this.runs].sort((a, b) => a - b);
-    return {
-      min: Math.round(sorted[0]),
-      max: Math.round(sorted[sorted.length - 1]),
-      avg: Math.round(this.runs.reduce((a, b) => a + b, 0) / this.runs.length),
-      median: Math.round(sorted[Math.floor(sorted.length / 2)]),
-      runs: this.runs.map((r) => Math.round(r)),
-      unit: 'ms',
-    };
-  }
-}
-
-// Phase timers
-const timers = {
-  directoryRead: new Timer('Directory Read (readdirSync)'),
-  directoryReadWithTypes: new Timer('Directory Read (withFileTypes)'),
-  statLoop: new Timer('Stat Loop (statSync per file)'),
-  realpathSingle: new Timer('Realpath (single call)'),
-  realpathDouble: new Timer('Realpath (double call - current)'),
-  hashSequential: new Timer('Hash Files (sequential)'),
-  hashParallelBatch: new Timer('Hash Files (parallel batch)'),
-  fileCopySequential: new Timer('File Copy (sequential)'),
-  fileCopyParallel: new Timer('File Copy (parallel)'),
-  totalInstallSimulation: new Timer('Total Install Simulation'),
-};
-
-/**
- * Log if verbose mode is enabled
- */
-function log(msg) {
-  if (CONFIG.verbose) console.log(`[benchmark] ${msg}`);
-}
-
-/**
- * Get the .sinapse-ai directory for benchmarking
- */
-function getSinapseCoreDir() {
-  const projectRoot = path.resolve(__dirname, '../../../../');
-  return path.join(projectRoot, '.sinapse-ai');
-}
-
-/**
- * Benchmark: Directory read comparison
- */
-async function benchmarkDirectoryRead(dir) {
-  const files = fs.readdirSync(dir);
-
-  // Method 1: readdirSync + statSync for each
-  timers.statLoop.begin();
-  for (const file of files) {
-    const fullPath = path.join(dir, file);
-    fs.statSync(fullPath).isDirectory();
-  }
-  timers.statLoop.stop();
-
-  // Method 2: readdirSync with withFileTypes
-  timers.directoryReadWithTypes.begin();
-  const entries = fs.readdirSync(dir, { withFileTypes: true });
-  for (const entry of entries) {
-    entry.isDirectory();
-  }
-  timers.directoryReadWithTypes.stop();
-
-  return files.length;
-}
-
-/**
- * Benchmark: Realpath comparison
- */
-async function benchmarkRealpath(files) {
-  const sampleFiles = files.slice(0, 100); // Sample 100 files
-
-  // Method 1: Single realpath call
-  timers.realpathSingle.begin();
-  for (const file of sampleFiles) {
-    fs.realpathSync(file);
-  }
-  timers.realpathSingle.stop();
-
-  // Method 2: Double realpath call (current behavior)
-  timers.realpathDouble.begin();
-  for (const file of sampleFiles) {
-    fs.realpathSync(file);
-    fs.realpathSync(path.dirname(file)); // Simulates the duplicate call
-  }
-  timers.realpathDouble.stop();
-}
-
-/**
- * Benchmark: File hashing comparison
- */
-async function benchmarkHashing(files) {
-  const sampleFiles = files.slice(0, 200); // Sample 200 files for hashing
-
-  // Method 1: Sequential hashing
-  timers.hashSequential.begin();
-  for (const file of sampleFiles) {
-    try {
-      const content = fs.readFileSync(file);
-      crypto.createHash('sha256').update(content).digest('hex');
-    } catch {
-      // Skip files that can't be read
-    }
-  }
-  timers.hashSequential.stop();
-
-  // Method 2: Parallel batch hashing
-  timers.hashParallelBatch.begin();
-  const batchSize = 50;
-  for (let i = 0; i < sampleFiles.length; i += batchSize) {
-    const batch = sampleFiles.slice(i, i + batchSize);
-    await Promise.all(
-      batch.map(async (file) => {
-        try {
-          const content = await fse.readFile(file);
-          crypto.createHash('sha256').update(content).digest('hex');
-        } catch {
-          // Skip files that can't be read
-        }
-      }),
-    );
-  }
-  timers.hashParallelBatch.stop();
-}
-
-/**
- * Collect all files recursively
- */
-function collectFiles(dir, maxFiles = 1000) {
-  const files = [];
-
-  function walk(currentDir) {
-    if (files.length >= maxFiles) return;
-
-    try {
-      const entries = fs.readdirSync(currentDir, { withFileTypes: true });
-      for (const entry of entries) {
-        if (files.length >= maxFiles) break;
-
-        const fullPath = path.join(currentDir, entry.name);
-        if (entry.isDirectory()) {
-          walk(fullPath);
-        } else if (entry.isFile()) {
-          files.push(fullPath);
-        }
-      }
-    } catch {
-      // Skip directories we can't read
-    }
-  }
-
-  walk(dir);
-  return files;
-}
-
-/**
- * Run all benchmarks
- */
-async function runBenchmarks() {
-  const sinapseCoreDir = getSinapseCoreDir();
-
-  if (!fs.existsSync(sinapseCoreDir)) {
-    console.error(`Error: .sinapse-ai directory not found at ${sinapseCoreDir}`);
-    process.exit(1);
-  }
-
-  log(`Starting benchmark with ${CONFIG.runs} runs`);
-  log(`Using .sinapse-ai at: ${sinapseCoreDir}`);
-
-  // Collect files for benchmarking
-  log('Collecting files...');
-  const allFiles = collectFiles(sinapseCoreDir, CONFIG.testProjectSize);
-  log(`Collected ${allFiles.length} files`);
-
-  results.fileCount = allFiles.length;
-
-  // Run benchmarks multiple times
-  for (let run = 1; run <= CONFIG.runs; run++) {
-    log(`\n--- Run ${run}/${CONFIG.runs} ---`);
-
-    // Directory read benchmarks
-    const agentsDir = path.join(sinapseCoreDir, 'development', 'agents');
-    if (fs.existsSync(agentsDir)) {
-      log('Benchmarking directory read...');
-      await benchmarkDirectoryRead(agentsDir);
-    }
-
-    // Realpath benchmarks
-    log('Benchmarking realpath...');
-    await benchmarkRealpath(allFiles);
-
-    // Hashing benchmarks
-    log('Benchmarking file hashing...');
-    await benchmarkHashing(allFiles);
-
-    // Total simulation
-    log('Running total install simulation...');
-    timers.totalInstallSimulation.begin();
-
-    // Simulate full install: read dirs + hash files
-    const devDir = path.join(sinapseCoreDir, 'development');
-    if (fs.existsSync(devDir)) {
-      const subdirs = fs.readdirSync(devDir, { withFileTypes: true });
-      for (const subdir of subdirs) {
-        if (subdir.isDirectory()) {
-          const fullSubdir = path.join(devDir, subdir.name);
-          fs.readdirSync(fullSubdir);
-        }
-      }
-    }
-
-    // Simulate sequential file processing
-    for (const file of allFiles.slice(0, 500)) {
-      try {
-        fs.statSync(file);
-        fs.readFileSync(file);
-      } catch {
-        // Skip
-      }
-    }
-
-    timers.totalInstallSimulation.stop();
-  }
-
-  // Compile results
-  log('\nCompiling results...');
-
-  for (const [name, timer] of Object.entries(timers)) {
-    const stats = timer.getStats();
-    if (stats) {
-      results.phases[name] = {
-        description: timer.name,
-        ...stats,
-      };
-    }
-  }
-
-  // Calculate summary
-  const hashSeq = results.phases.hashSequential?.avg || 0;
-  const hashPar = results.phases.hashParallelBatch?.avg || 0;
-  const realpathSingle = results.phases.realpathSingle?.avg || 0;
-  const realpathDouble = results.phases.realpathDouble?.avg || 0;
-  const statLoop = results.phases.statLoop?.avg || 0;
-  const withTypes = results.phases.directoryReadWithTypes?.avg || 0;
-
-  results.summary = {
-    totalFiles: results.fileCount,
-    hashingSpeedup: hashSeq > 0 ? `${(hashSeq / hashPar).toFixed(2)}x` : 'N/A',
-    realpathSavings: realpathDouble > 0 ? `${Math.round(((realpathDouble - realpathSingle) / realpathDouble) * 100)}%` : 'N/A',
-    statLoopSavings: statLoop > 0 ? `${Math.round(((statLoop - withTypes) / statLoop) * 100)}%` : 'N/A',
-    estimatedTotalTime: results.phases.totalInstallSimulation?.avg || 0,
-    target: '<30000ms for 1000 files',
-    baseline: `${results.phases.totalInstallSimulation?.avg || 'TBD'}ms`,
-  };
-
-  // Output results
-  const output = JSON.stringify(results, null, 2);
-
-  if (CONFIG.outputFile) {
-    fs.writeFileSync(CONFIG.outputFile, output);
-    console.log(`Benchmark results saved to: ${CONFIG.outputFile}`);
-  } else {
-    console.log(output);
-  }
-
-  // Print summary to stderr for visibility
-  console.error('\n' + '='.repeat(60));
-  console.error('SINAPSE Installer Performance Baseline');
-  console.error('='.repeat(60));
-  console.error(`Files analyzed: ${results.fileCount}`);
-  console.error(`Runs: ${CONFIG.runs}`);
-  console.error('');
-  console.error('Phase Results (avg ms):');
-  console.error(`  Directory stat loop:     ${statLoop}ms`);
-  console.error(`  Directory withFileTypes: ${withTypes}ms (${results.summary.statLoopSavings} faster)`);
-  console.error(`  Realpath single:         ${realpathSingle}ms`);
-  console.error(`  Realpath double:         ${realpathDouble}ms (${results.summary.realpathSavings} overhead)`);
-  console.error(`  Hash sequential:         ${hashSeq}ms`);
-  console.error(`  Hash parallel:           ${hashPar}ms (${results.summary.hashingSpeedup} faster)`);
-  console.error('');
-  console.error(`Total Install Simulation:  ${results.summary.baseline}`);
-  console.error(`Target:                    ${results.summary.target}`);
-  console.error('='.repeat(60));
-}
-
-// Run benchmarks
-runBenchmarks().catch((err) => {
-  console.error('Benchmark failed:', err);
-  process.exit(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);
-    });
-  });
-});
-