sinapse-ai 1.9.0 → 1.9.1

package/.sinapse-ai/workflow-intelligence/__tests__/workflow-registry.test.js

@@ -1,303 +0,0 @@
-/**
- * @fileoverview Unit tests for WorkflowRegistry
- * @story WIS-2 - Workflow Registry Enhancement
- */
-
-'use strict';
-
-const path = require('path');
-const {
-  WorkflowRegistry,
-  createWorkflowRegistry,
-  DEFAULT_CACHE_TTL,
-} = require('../registry/workflow-registry');
-
-describe('WorkflowRegistry', () => {
-  let registry;
-
-  beforeEach(() => {
-    registry = createWorkflowRegistry();
-  });
-
-  afterEach(() => {
-    registry.invalidateCache();
-  });
-
-  describe('constructor', () => {
-    it('should create registry with default options', () => {
-      expect(registry.cacheTTL).toBe(DEFAULT_CACHE_TTL);
-      expect(registry.cache).toBeNull();
-    });
-
-    it('should accept custom cache TTL', () => {
-      const customRegistry = createWorkflowRegistry({ cacheTTL: 1000 });
-      expect(customRegistry.cacheTTL).toBe(1000);
-    });
-
-    it('should accept custom patterns path', () => {
-      const customPath = '/custom/path.yaml';
-      const customRegistry = createWorkflowRegistry({ patternsPath: customPath });
-      expect(customRegistry.patternsPath).toBe(customPath);
-    });
-  });
-
-  describe('loadWorkflows()', () => {
-    it('should load workflow patterns from file', () => {
-      const workflows = registry.loadWorkflows();
-      expect(workflows).toBeDefined();
-      expect(typeof workflows).toBe('object');
-    });
-
-    it('should return 10 workflows', () => {
-      const workflows = registry.loadWorkflows();
-      const names = Object.keys(workflows);
-      expect(names.length).toBe(10);
-    });
-
-    it('should include story_development workflow', () => {
-      const workflows = registry.loadWorkflows();
-      expect(workflows.story_development).toBeDefined();
-    });
-
-    it('should include epic_creation workflow', () => {
-      const workflows = registry.loadWorkflows();
-      expect(workflows.epic_creation).toBeDefined();
-    });
-
-    it('should cache loaded workflows', () => {
-      const workflows1 = registry.loadWorkflows();
-      const workflows2 = registry.loadWorkflows();
-      expect(workflows1).toBe(workflows2);
-    });
-
-    it('should throw error for invalid file path', () => {
-      const badRegistry = createWorkflowRegistry({
-        patternsPath: '/nonexistent/path.yaml',
-      });
-      expect(() => badRegistry.loadWorkflows()).toThrow('Workflow patterns file not found');
-    });
-  });
-
-  describe('isCacheValid()', () => {
-    it('should return false when cache is null', () => {
-      expect(registry.isCacheValid()).toBe(false);
-    });
-
-    it('should return true after loading workflows', () => {
-      registry.loadWorkflows();
-      expect(registry.isCacheValid()).toBe(true);
-    });
-
-    it('should return false after invalidation', () => {
-      registry.loadWorkflows();
-      registry.invalidateCache();
-      expect(registry.isCacheValid()).toBe(false);
-    });
-  });
-
-  describe('getWorkflowNames()', () => {
-    it('should return array of workflow names', () => {
-      const names = registry.getWorkflowNames();
-      expect(Array.isArray(names)).toBe(true);
-      expect(names.length).toBe(10);
-    });
-
-    it('should include expected workflows', () => {
-      const names = registry.getWorkflowNames();
-      expect(names).toContain('story_development');
-      expect(names).toContain('epic_creation');
-      expect(names).toContain('backlog_management');
-      expect(names).toContain('architecture_review');
-      expect(names).toContain('git_workflow');
-      expect(names).toContain('database_workflow');
-      expect(names).toContain('code_quality_workflow');
-      expect(names).toContain('documentation_workflow');
-      expect(names).toContain('ux_workflow');
-      expect(names).toContain('research_workflow');
-    });
-  });
-
-  describe('getWorkflow()', () => {
-    it('should return workflow by name', () => {
-      const workflow = registry.getWorkflow('epic_creation');
-      expect(workflow).toBeDefined();
-      expect(workflow.description).toBeDefined();
-    });
-
-    it('should return null for unknown workflow', () => {
-      const workflow = registry.getWorkflow('nonexistent');
-      expect(workflow).toBeNull();
-    });
-
-    it('should include transitions in workflow', () => {
-      const workflow = registry.getWorkflow('epic_creation');
-      expect(workflow.transitions).toBeDefined();
-      expect(typeof workflow.transitions).toBe('object');
-    });
-  });
-
-  describe('matchWorkflow()', () => {
-    it('should match workflow from command history', () => {
-      const commands = ['create-epic', 'create-story'];
-      const match = registry.matchWorkflow(commands);
-
-      expect(match).not.toBeNull();
-      expect(match.name).toBe('epic_creation');
-    });
-
-    it('should return best matching workflow', () => {
-      const commands = ['validate-story-draft', 'develop', 'review-qa'];
-      const match = registry.matchWorkflow(commands);
-
-      expect(match).not.toBeNull();
-      expect(match.name).toBe('story_development');
-    });
-
-    it('should return null for empty commands', () => {
-      const match = registry.matchWorkflow([]);
-      expect(match).toBeNull();
-    });
-
-    it('should return null for unmatched commands', () => {
-      const match = registry.matchWorkflow(['random-cmd', 'another-random']);
-      expect(match).toBeNull();
-    });
-
-    it('should include score in match result', () => {
-      const match = registry.matchWorkflow(['create-epic', 'create-story']);
-      expect(match.score).toBeGreaterThanOrEqual(2);
-    });
-
-    it('should include matched commands', () => {
-      const match = registry.matchWorkflow(['create-epic', 'create-story']);
-      expect(match.matchedCommands).toBeDefined();
-      expect(Array.isArray(match.matchedCommands)).toBe(true);
-    });
-  });
-
-  describe('getTransitions()', () => {
-    it('should return transitions for valid state', () => {
-      const transition = registry.getTransitions('epic_creation', 'epic_drafted');
-
-      expect(transition).not.toBeNull();
-      expect(transition.trigger).toBeDefined();
-      expect(transition.confidence).toBeDefined();
-      expect(transition.next_steps).toBeDefined();
-    });
-
-    it('should return null for unknown state', () => {
-      const transition = registry.getTransitions('epic_creation', 'unknown_state');
-      expect(transition).toBeNull();
-    });
-
-    it('should return null for unknown workflow', () => {
-      const transition = registry.getTransitions('unknown_workflow', 'any_state');
-      expect(transition).toBeNull();
-    });
-
-    it('should return empty array for workflow without transitions', () => {
-      const result = registry.getAllTransitions('nonexistent');
-      expect(result).toEqual({});
-    });
-  });
-
-  describe('getNextSteps()', () => {
-    it('should return sorted next steps', () => {
-      const steps = registry.getNextSteps('epic_creation', 'epic_drafted');
-
-      expect(Array.isArray(steps)).toBe(true);
-      expect(steps.length).toBeGreaterThan(0);
-      expect(steps[0].priority).toBeLessThanOrEqual(steps[1]?.priority || 99);
-    });
-
-    it('should include command and description', () => {
-      const steps = registry.getNextSteps('epic_creation', 'epic_drafted');
-
-      expect(steps[0].command).toBeDefined();
-      expect(steps[0].description).toBeDefined();
-    });
-
-    it('should return empty array for unknown state', () => {
-      const steps = registry.getNextSteps('epic_creation', 'unknown_state');
-      expect(steps).toEqual([]);
-    });
-  });
-
-  describe('findCurrentState()', () => {
-    it('should find state from command', () => {
-      const state = registry.findCurrentState('epic_creation', 'create-epic completed');
-      expect(state).toBe('epic_drafted');
-    });
-
-    it('should find state without "completed" suffix', () => {
-      const state = registry.findCurrentState('epic_creation', 'create-epic');
-      expect(state).toBe('epic_drafted');
-    });
-
-    it('should return null for unknown command', () => {
-      const state = registry.findCurrentState('epic_creation', 'random-command');
-      expect(state).toBeNull();
-    });
-
-    it('should return null for unknown workflow', () => {
-      const state = registry.findCurrentState('unknown', 'create-epic');
-      expect(state).toBeNull();
-    });
-  });
-
-  describe('getWorkflowsByAgent()', () => {
-    it('should return workflows for agent', () => {
-      const workflows = registry.getWorkflowsByAgent('@po');
-
-      expect(Array.isArray(workflows)).toBe(true);
-      expect(workflows.length).toBeGreaterThan(0);
-    });
-
-    it('should handle agent without @ prefix', () => {
-      const workflows = registry.getWorkflowsByAgent('po');
-      expect(workflows.length).toBeGreaterThan(0);
-    });
-
-    it('should return empty array for unknown agent', () => {
-      const workflows = registry.getWorkflowsByAgent('@unknown');
-      expect(workflows).toEqual([]);
-    });
-  });
-
-  describe('getStats()', () => {
-    it('should return registry statistics', () => {
-      const stats = registry.getStats();
-
-      expect(stats.totalWorkflows).toBe(10);
-      expect(stats.workflowsWithTransitions).toBe(10);
-      expect(stats.totalTransitions).toBeGreaterThan(0);
-    });
-
-    it('should report cache status', () => {
-      registry.loadWorkflows();
-      const stats = registry.getStats();
-
-      expect(stats.cacheValid).toBe(true);
-      expect(stats.cacheAge).toBeGreaterThanOrEqual(0);
-    });
-  });
-
-  describe('normalizeCommand()', () => {
-    it('should normalize command strings', () => {
-      expect(registry.normalizeCommand('CREATE-EPIC')).toBe('create-epic');
-      expect(registry.normalizeCommand('*create-epic')).toBe('create-epic');
-      expect(registry.normalizeCommand('create-epic completed')).toBe('create-epic');
-    });
-
-    it('should handle null input', () => {
-      expect(registry.normalizeCommand(null)).toBe('');
-    });
-  });
-
-  describe('DEFAULT_CACHE_TTL', () => {
-    it('should be 5 minutes', () => {
-      expect(DEFAULT_CACHE_TTL).toBe(5 * 60 * 1000);
-    });
-  });
-});
-

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);
-});
-