sinapse-ai 1.9.0 → 1.9.1

package/.sinapse-ai/core/memory/__tests__/active-modules.verify.js

@@ -1,265 +0,0 @@
-/**
- * Verification Tests for Active SINAPSE Memory Modules
- *
- * Tests active memory modules:
- * 1. Feedback Loop (gotchas-memory.js)
- * 2. Custom Rules per Project (semantic-merge-engine.js)
- *
- * @created 2026-01-29
- * @updated 2026-02-09 - Removed orphan modules tests (Story MIS-2)
- * @updated 2026-06-15 - Status note added (see below)
- *
- * STATUS — IMPORTANT (do not mistake this for a passing CI gate):
- * This is a `.verify.js` standalone script (run manually via `node`), NOT a
- * Jest spec — jest.config.js only matches `*.test.js`/`*.spec.js`, so it never
- * runs in CI. The "Feedback Loop" section below asserts the Story 9.4 surface
- * (FeedbackType enum + trackUserFeedback / getAccuracyMetrics / getSuggestedRules)
- * which is NOT yet implemented in gotchas-memory.js — those assertions are a
- * forward spec for pending work, not a regression check. The Custom Rules
- * section reflects shipped behavior. Do not "fix" this by inventing the feedback
- * feature without its story (Constitution Art. IV — No Invention).
- */
-
-const path = require('path');
-const fs = require('fs');
-
-// Test helpers
-const testResults = {
-  passed: 0,
-  failed: 0,
-  errors: [],
-};
-
-function test(name, fn) {
-  try {
-    fn();
-    console.log(`  ✅ ${name}`);
-    testResults.passed++;
-  } catch (error) {
-    console.log(`  ❌ ${name}`);
-    console.log(`     Error: ${error.message}`);
-    testResults.failed++;
-    testResults.errors.push({ name, error: error.message });
-  }
-}
-
-function assertEqual(actual, expected, message) {
-  if (actual !== expected) {
-    throw new Error(`${message}: expected ${expected}, got ${actual}`);
-  }
-}
-
-function assertTrue(condition, message) {
-  if (!condition) {
-    throw new Error(message || 'Assertion failed');
-  }
-}
-
-function assertDefined(value, message) {
-  if (value === undefined || value === null) {
-    throw new Error(message || 'Value is undefined or null');
-  }
-}
-
-// ============================================================================
-// TEST SUITE 1: FEEDBACK LOOP
-// ============================================================================
-
-console.log('\n🔄 Testing Feedback Loop...\n');
-
-test('GotchasMemory module loads with FeedbackType', () => {
-  const { GotchasMemory, FeedbackType } = require('../gotchas-memory');
-
-  assertDefined(GotchasMemory, 'GotchasMemory should be defined');
-  assertDefined(FeedbackType, 'FeedbackType should be defined');
-});
-
-test('FeedbackType has required types', () => {
-  const { FeedbackType } = require('../gotchas-memory');
-
-  assertEqual(FeedbackType.HELPFUL, 'helpful', 'HELPFUL type');
-  assertEqual(FeedbackType.NOT_HELPFUL, 'not_helpful', 'NOT_HELPFUL type');
-  assertEqual(FeedbackType.FALSE_POSITIVE, 'false_positive', 'FALSE_POSITIVE type');
-  assertEqual(FeedbackType.MISSED, 'missed', 'MISSED type');
-  assertEqual(FeedbackType.IMPROVED, 'improved', 'IMPROVED type');
-});
-
-test('GotchasMemory has trackUserFeedback method', () => {
-  const { GotchasMemory } = require('../gotchas-memory');
-
-  // GotchasMemory constructor takes rootPath as first arg (string)
-  const memory = new GotchasMemory(process.cwd());
-  assertDefined(memory.trackUserFeedback, 'trackUserFeedback method should exist');
-});
-
-test('GotchasMemory has getAccuracyMetrics method', () => {
-  const { GotchasMemory } = require('../gotchas-memory');
-
-  const memory = new GotchasMemory(process.cwd());
-  assertDefined(memory.getAccuracyMetrics, 'getAccuracyMetrics method should exist');
-});
-
-test('GotchasMemory has getSuggestedRules method', () => {
-  const { GotchasMemory } = require('../gotchas-memory');
-
-  const memory = new GotchasMemory(process.cwd());
-  assertDefined(memory.getSuggestedRules, 'getSuggestedRules method should exist');
-});
-
-test('GotchasMemory can track feedback', () => {
-  const { GotchasMemory, FeedbackType } = require('../gotchas-memory');
-
-  const memory = new GotchasMemory(process.cwd());
-  const result = memory.trackUserFeedback({
-    gotchaId: 'test-gotcha-1',
-    feedbackType: FeedbackType.HELPFUL,
-    comment: 'Test feedback',
-  });
-
-  assertDefined(result, 'Result should be defined');
-  // Result structure may vary
-  assertTrue(typeof result === 'object', 'Result should be an object');
-});
-
-test('GotchasMemory can get accuracy metrics', () => {
-  const { GotchasMemory } = require('../gotchas-memory');
-
-  const memory = new GotchasMemory(process.cwd());
-  const metrics = memory.getAccuracyMetrics();
-
-  assertDefined(metrics, 'Metrics should be defined');
-  assertTrue(typeof metrics === 'object', 'Metrics should be an object');
-});
-
-// ============================================================================
-// TEST SUITE 2: CUSTOM RULES PER PROJECT
-// ============================================================================
-
-console.log('\n⚙️  Testing Custom Rules per Project...\n');
-
-test('SemanticMergeEngine loads CustomRulesLoader', () => {
-  const {
-    SemanticMergeEngine,
-    CustomRulesLoader,
-  } = require('../../execution/semantic-merge-engine');
-
-  assertDefined(SemanticMergeEngine, 'SemanticMergeEngine should be defined');
-  assertDefined(CustomRulesLoader, 'CustomRulesLoader should be defined');
-});
-
-test('CustomRulesLoader instantiates correctly', () => {
-  const { CustomRulesLoader } = require('../../execution/semantic-merge-engine');
-
-  const loader = new CustomRulesLoader(process.cwd());
-  assertDefined(loader, 'Loader should instantiate');
-  assertDefined(loader.loadCustomRules, 'loadCustomRules method should exist');
-  assertDefined(loader.getMergedRules, 'getMergedRules method should exist');
-});
-
-test('CustomRulesLoader has getDefaultRules method', () => {
-  const { CustomRulesLoader } = require('../../execution/semantic-merge-engine');
-
-  const loader = new CustomRulesLoader(process.cwd());
-  const defaults = loader.getDefaultRules();
-
-  assertDefined(defaults, 'Defaults should be defined');
-  assertDefined(defaults.compatibility, 'Defaults should have compatibility');
-  assertDefined(defaults.file_patterns, 'Defaults should have file_patterns');
-  assertDefined(defaults.languages, 'Defaults should have languages');
-  assertDefined(defaults.ai, 'Defaults should have ai config');
-});
-
-test('CustomRulesLoader can get merged rules', () => {
-  const { CustomRulesLoader } = require('../../execution/semantic-merge-engine');
-
-  const loader = new CustomRulesLoader(process.cwd());
-  const rules = loader.getMergedRules();
-
-  assertDefined(rules, 'Rules should be defined');
-  assertDefined(rules.file_patterns, 'Rules should have file_patterns');
-});
-
-test('CustomRulesLoader can categorize files', () => {
-  const { CustomRulesLoader } = require('../../execution/semantic-merge-engine');
-
-  const loader = new CustomRulesLoader(process.cwd());
-
-  // Test matchesPattern directly
-  const skipPatterns = ['node_modules/**', '.git/**', '*.log'];
-  const matchesNodeModules = loader.matchesPattern('node_modules/package/index.js', skipPatterns);
-  assertTrue(matchesNodeModules, 'node_modules/package/index.js should match node_modules/**');
-
-  // Test default category
-  const defaultCategory = loader.getFileCategory('src/utils/helper.js');
-  // This depends on rules, but should be defined
-  assertDefined(defaultCategory, 'Category should be defined');
-});
-
-test('CustomRulesLoader has cache functionality', () => {
-  const { CustomRulesLoader } = require('../../execution/semantic-merge-engine');
-
-  const loader = new CustomRulesLoader(process.cwd());
-
-  // First call loads
-  loader.getMergedRules();
-
-  // Check cache is valid
-  const isValid = loader.isCacheValid();
-  assertTrue(isValid, 'Cache should be valid after loading');
-
-  // Clear cache
-  loader.clearCache();
-  const isInvalid = !loader.isCacheValid();
-  assertTrue(isInvalid, 'Cache should be invalid after clearing');
-});
-
-test('SemanticMergeEngine integrates with CustomRulesLoader', () => {
-  const { SemanticMergeEngine } = require('../../execution/semantic-merge-engine');
-
-  const engine = new SemanticMergeEngine({ rootPath: process.cwd() });
-
-  assertDefined(engine.rulesLoader, 'Engine should have rulesLoader');
-  assertDefined(engine.getRules, 'Engine should have getRules method');
-  assertDefined(engine.reloadRules, 'Engine should have reloadRules method');
-  assertDefined(engine.getFileCategory, 'Engine should have getFileCategory method');
-});
-
-test('SemanticMergeEngine can get rules', () => {
-  const { SemanticMergeEngine } = require('../../execution/semantic-merge-engine');
-
-  const engine = new SemanticMergeEngine({ rootPath: process.cwd() });
-  const rules = engine.getRules();
-
-  assertDefined(rules, 'Rules should be defined');
-});
-
-test('merge-rules.yaml exists in .sinapse', () => {
-  const rulesPath = path.join(process.cwd(), '.sinapse', 'merge-rules.yaml');
-  const exists = fs.existsSync(rulesPath);
-
-  assertTrue(exists, 'merge-rules.yaml should exist in .sinapse');
-});
-
-// ============================================================================
-// TEST SUMMARY
-// ============================================================================
-
-console.log('\n' + '='.repeat(60));
-console.log('TEST SUMMARY');
-console.log('='.repeat(60));
-console.log(`\n  ✅ Passed: ${testResults.passed}`);
-console.log(`  ❌ Failed: ${testResults.failed}`);
-console.log(`  📊 Total:  ${testResults.passed + testResults.failed}`);
-
-if (testResults.errors.length > 0) {
-  console.log('\n  Errors:');
-  testResults.errors.forEach((e) => {
-    console.log(`    - ${e.name}: ${e.error}`);
-  });
-}
-
-console.log('\n' + '='.repeat(60));
-
-// Exit with error code if tests failed
-process.exit(testResults.failed > 0 ? 1 : 0);
-

package/.sinapse-ai/core/permissions/__tests__/permission-mode.test.js

@@ -1,293 +0,0 @@
-/**
- * Permission Mode Tests
- *
- * Tests for the permission mode system (Epic 6)
- */
-
-const { PermissionMode } = require('../permission-mode');
-const { OperationGuard } = require('../operation-guard');
-const path = require('path');
-const fs = require('fs').promises;
-const os = require('os');
-
-describe('PermissionMode', () => {
-  let tempDir;
-  let mode;
-
-  beforeEach(async () => {
-    // Create temp directory for tests
-    tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'sinapse-test-'));
-    await fs.mkdir(path.join(tempDir, '.sinapse'), { recursive: true });
-    mode = new PermissionMode(tempDir);
-  });
-
-  afterEach(async () => {
-    // Cleanup temp directory
-    try {
-      await fs.rm(tempDir, { recursive: true });
-    } catch {
-      // Ignore cleanup errors
-    }
-  });
-
-  describe('load()', () => {
-    it('should default to "ask" mode when no config exists', async () => {
-      const result = await mode.load();
-      expect(result).toBe('ask');
-      expect(mode.currentMode).toBe('ask');
-    });
-
-    it('should load mode from config file', async () => {
-      await fs.writeFile(
-        path.join(tempDir, '.sinapse', 'config.yaml'),
-        'permissions:\n  mode: auto\n',
-      );
-
-      const result = await mode.load();
-      expect(result).toBe('auto');
-    });
-
-    it('should fallback to "ask" for invalid mode in config', async () => {
-      await fs.writeFile(
-        path.join(tempDir, '.sinapse', 'config.yaml'),
-        'permissions:\n  mode: invalid_mode\n',
-      );
-
-      const result = await mode.load();
-      expect(result).toBe('ask');
-    });
-  });
-
-  describe('setMode()', () => {
-    it('should set mode and persist to config', async () => {
-      const result = await mode.setMode('auto');
-
-      expect(result.mode).toBe('auto');
-      expect(mode.currentMode).toBe('auto');
-
-      // Verify persisted
-      const configContent = await fs.readFile(path.join(tempDir, '.sinapse', 'config.yaml'), 'utf-8');
-      expect(configContent).toContain('mode: auto');
-    });
-
-    it('should handle alias "yolo" for "auto"', async () => {
-      const result = await mode.setMode('yolo');
-      expect(result.mode).toBe('auto');
-    });
-
-    it('should handle alias "safe" for "explore"', async () => {
-      const result = await mode.setMode('safe');
-      expect(result.mode).toBe('explore');
-    });
-
-    it('should throw error for invalid mode', async () => {
-      await expect(mode.setMode('invalid')).rejects.toThrow('Invalid mode');
-    });
-  });
-
-  describe('getBadge()', () => {
-    it('should return correct badge for each mode', async () => {
-      mode.currentMode = 'explore';
-      expect(mode.getBadge()).toBe('[🔍 Explore]');
-
-      mode.currentMode = 'ask';
-      expect(mode.getBadge()).toBe('[⚠️ Ask]');
-
-      mode.currentMode = 'auto';
-      expect(mode.getBadge()).toBe('[⚡ Auto]');
-    });
-  });
-
-  describe('canPerform()', () => {
-    it('should allow all reads in all modes', () => {
-      for (const modeName of ['explore', 'ask', 'auto']) {
-        mode.currentMode = modeName;
-        const result = mode.canPerform('read');
-        expect(result.allowed).toBe(true);
-      }
-    });
-
-    it('should block writes in explore mode', () => {
-      mode.currentMode = 'explore';
-      const result = mode.canPerform('write');
-      expect(result.allowed).toBe(false);
-    });
-
-    it('should require confirmation for writes in ask mode', () => {
-      mode.currentMode = 'ask';
-      const result = mode.canPerform('write');
-      expect(result.allowed).toBe('confirm');
-    });
-
-    it('should allow writes in auto mode', () => {
-      mode.currentMode = 'auto';
-      const result = mode.canPerform('write');
-      expect(result.allowed).toBe(true);
-    });
-  });
-
-  describe('cycleMode()', () => {
-    it('should cycle through modes correctly', async () => {
-      mode.currentMode = 'explore';
-      mode._loaded = true;
-
-      let result = await mode.cycleMode();
-      expect(result.mode).toBe('ask');
-
-      result = await mode.cycleMode();
-      expect(result.mode).toBe('auto');
-
-      result = await mode.cycleMode();
-      expect(result.mode).toBe('explore');
-    });
-  });
-
-  describe('isAutonomous()', () => {
-    it('should return true only for auto mode', () => {
-      mode.currentMode = 'auto';
-      expect(mode.isAutonomous()).toBe(true);
-
-      mode.currentMode = 'ask';
-      expect(mode.isAutonomous()).toBe(false);
-
-      mode.currentMode = 'explore';
-      expect(mode.isAutonomous()).toBe(false);
-    });
-  });
-
-  describe('isReadOnly()', () => {
-    it('should return true only for explore mode', () => {
-      mode.currentMode = 'explore';
-      expect(mode.isReadOnly()).toBe(true);
-
-      mode.currentMode = 'ask';
-      expect(mode.isReadOnly()).toBe(false);
-
-      mode.currentMode = 'auto';
-      expect(mode.isReadOnly()).toBe(false);
-    });
-  });
-});
-
-describe('OperationGuard', () => {
-  let mode;
-  let guard;
-
-  beforeEach(() => {
-    mode = new PermissionMode();
-    mode._loaded = true;
-    guard = new OperationGuard(mode);
-  });
-
-  describe('classifyOperation()', () => {
-    it('should classify Read tool as read', () => {
-      expect(guard.classifyOperation('Read', {})).toBe('read');
-    });
-
-    it('should classify Write tool as write', () => {
-      expect(guard.classifyOperation('Write', {})).toBe('write');
-    });
-
-    it('should classify Edit tool as write', () => {
-      expect(guard.classifyOperation('Edit', {})).toBe('write');
-    });
-
-    it('should classify Glob tool as read', () => {
-      expect(guard.classifyOperation('Glob', {})).toBe('read');
-    });
-
-    it('should classify Grep tool as read', () => {
-      expect(guard.classifyOperation('Grep', {})).toBe('read');
-    });
-  });
-
-  describe('classifyBashCommand()', () => {
-    it('should classify git status as read', () => {
-      expect(guard.classifyBashCommand('git status')).toBe('read');
-    });
-
-    it('should classify ls as read', () => {
-      expect(guard.classifyBashCommand('ls -la')).toBe('read');
-    });
-
-    it('should classify git push as write', () => {
-      expect(guard.classifyBashCommand('git push origin main')).toBe('write');
-    });
-
-    it('should classify rm -rf as delete', () => {
-      expect(guard.classifyBashCommand('rm -rf node_modules')).toBe('delete');
-    });
-
-    it('should classify git reset --hard as delete', () => {
-      expect(guard.classifyBashCommand('git reset --hard HEAD')).toBe('delete');
-    });
-
-    it('should classify npm install as write', () => {
-      expect(guard.classifyBashCommand('npm install lodash')).toBe('write');
-    });
-
-    it('should classify mkdir as write', () => {
-      expect(guard.classifyBashCommand('mkdir new_dir')).toBe('write');
-    });
-  });
-
-  describe('guard()', () => {
-    it('should allow read operations in all modes', async () => {
-      for (const modeName of ['explore', 'ask', 'auto']) {
-        mode.currentMode = modeName;
-        const result = await guard.guard('Read', { file_path: 'test.js' });
-        expect(result.proceed).toBe(true);
-      }
-    });
-
-    it('should block write in explore mode', async () => {
-      mode.currentMode = 'explore';
-      const result = await guard.guard('Write', { file_path: 'test.js' });
-      expect(result.proceed).toBe(false);
-      expect(result.blocked).toBe(true);
-    });
-
-    it('should request confirmation for write in ask mode', async () => {
-      mode.currentMode = 'ask';
-      const result = await guard.guard('Write', { file_path: 'test.js' });
-      expect(result.proceed).toBe(false);
-      expect(result.needsConfirmation).toBe(true);
-    });
-
-    it('should allow write in auto mode', async () => {
-      mode.currentMode = 'auto';
-      const result = await guard.guard('Write', { file_path: 'test.js' });
-      expect(result.proceed).toBe(true);
-    });
-
-    it('should block destructive bash commands in explore mode', async () => {
-      mode.currentMode = 'explore';
-      const result = await guard.guard('Bash', { command: 'rm -rf temp' });
-      expect(result.proceed).toBe(false);
-      expect(result.blocked).toBe(true);
-    });
-
-    it('should allow safe bash commands in explore mode', async () => {
-      mode.currentMode = 'explore';
-      const result = await guard.guard('Bash', { command: 'git status' });
-      expect(result.proceed).toBe(true);
-    });
-  });
-
-  describe('getStats()', () => {
-    it('should track operation statistics', async () => {
-      mode.currentMode = 'auto';
-
-      await guard.guard('Read', {});
-      await guard.guard('Write', {});
-      await guard.guard('Bash', { command: 'rm -rf x' });
-
-      const stats = guard.getStats();
-      expect(stats.total).toBe(3);
-      expect(stats.byOperation.read).toBe(1);
-      expect(stats.byOperation.write).toBe(1);
-      expect(stats.byOperation.delete).toBe(1);
-    });
-  });
-});
-