pumuki-ast-hooks 5.3.1

package/scripts/hooks-system/application/services/__tests__/PlaybookRunner.spec.js

@@ -0,0 +1,143 @@
+const PlaybookRunner = require('../PlaybookRunner');
+const fs = require('fs');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+jest.mock('child_process');
+
+function makeSUT(options = {}) {
+  return new PlaybookRunner(options);
+}
+
+function createMockPlaybooksFile(content) {
+  const playbooksPath = path.join(process.cwd(), 'scripts', 'hooks-system', 'config', 'playbooks.json');
+  const dir = path.dirname(playbooksPath);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+  fs.writeFileSync(playbooksPath, JSON.stringify(content, null, 2));
+}
+
+function cleanupPlaybooksFile() {
+  const playbooksPath = path.join(process.cwd(), 'scripts', 'hooks-system', 'config', 'playbooks.json');
+  if (fs.existsSync(playbooksPath)) {
+    fs.unlinkSync(playbooksPath);
+  }
+}
+
+describe('PlaybookRunner', () => {
+  beforeEach(() => {
+    cleanupPlaybooksFile();
+    jest.clearAllMocks();
+  });
+
+  afterEach(() => {
+    cleanupPlaybooksFile();
+  });
+
+  describe('constructor', () => {
+    it('should initialize with default cwd', () => {
+      createMockPlaybooksFile({});
+      const runner = makeSUT();
+      expect(runner.cwd).toBe(process.cwd());
+    });
+
+    it('should initialize with custom cwd', () => {
+      createMockPlaybooksFile({});
+      const customCwd = '/custom/path';
+      const runner = makeSUT({ cwd: customCwd });
+      expect(runner.cwd).toBe(customCwd);
+    });
+
+    it('should load playbooks from file', () => {
+      const playbooks = {
+        test: { steps: [{ type: 'command', cmd: 'echo test' }] },
+      };
+      createMockPlaybooksFile(playbooks);
+      const runner = makeSUT();
+      expect(runner.playbooks).toEqual(playbooks);
+    });
+  });
+
+  describe('list', () => {
+    it('should return list of playbooks with ids', () => {
+      const playbooks = {
+        playbook1: { name: 'Playbook 1', steps: [] },
+        playbook2: { name: 'Playbook 2', steps: [] },
+      };
+      createMockPlaybooksFile(playbooks);
+      const runner = makeSUT();
+      const list = runner.list();
+      expect(list).toHaveLength(2);
+      expect(list[0].id).toBe('playbook1');
+      expect(list[0].name).toBe('Playbook 1');
+      expect(list[1].id).toBe('playbook2');
+      expect(list[1].name).toBe('Playbook 2');
+    });
+
+    it('should return empty array when no playbooks', () => {
+      createMockPlaybooksFile({});
+      const runner = makeSUT();
+      const list = runner.list();
+      expect(list).toEqual([]);
+    });
+  });
+
+  describe('run', () => {
+    it('should execute playbook steps', () => {
+      const playbooks = {
+        test: {
+          steps: [
+            { type: 'command', cmd: 'echo step1' },
+            { type: 'command', cmd: 'echo step2' },
+          ],
+        },
+      };
+      createMockPlaybooksFile(playbooks);
+      spawnSync.mockReturnValue({ status: 0 });
+      const runner = makeSUT();
+      runner.run('test');
+      expect(spawnSync).toHaveBeenCalledTimes(2);
+    });
+
+    it('should throw error when playbook not found', () => {
+      createMockPlaybooksFile({});
+      const runner = makeSUT();
+      expect(() => {
+        runner.run('nonexistent');
+      }).toThrow("Playbook 'nonexistent' not found");
+    });
+
+    it('should throw error when step fails', () => {
+      const playbooks = {
+        test: {
+          steps: [{ type: 'command', cmd: 'failing-command' }],
+        },
+      };
+      createMockPlaybooksFile(playbooks);
+      spawnSync.mockReturnValue({ status: 1 });
+      const runner = makeSUT();
+      expect(() => {
+        runner.run('test');
+      }).toThrow('Step failed');
+    });
+
+    it('should use custom cwd for commands', () => {
+      const customCwd = '/custom/path';
+      const playbooks = {
+        test: {
+          steps: [{ type: 'command', cmd: 'echo test' }],
+        },
+      };
+      createMockPlaybooksFile(playbooks);
+      spawnSync.mockReturnValue({ status: 0 });
+      const runner = makeSUT({ cwd: customCwd });
+      runner.run('test');
+      expect(spawnSync).toHaveBeenCalledWith(
+        expect.any(String),
+        expect.objectContaining({ cwd: customCwd })
+      );
+    });
+  });
+});
+

package/scripts/hooks-system/application/services/__tests__/PredictiveHookAdvisor.spec.js

@@ -0,0 +1,181 @@
+const PredictiveHookAdvisor = require('../PredictiveHookAdvisor');
+const fs = require('fs');
+const path = require('path');
+
+function makeSUT(options = {}) {
+  return new PredictiveHookAdvisor(options);
+}
+
+function createMockMetricsFile(metrics) {
+  const metricsFile = path.join(process.cwd(), '.audit_tmp', 'hook-metrics.jsonl');
+  const dir = path.dirname(metricsFile);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+  const content = metrics.map(m => JSON.stringify(m)).join('\n');
+  fs.writeFileSync(metricsFile, content);
+}
+
+function cleanupMetricsFile() {
+  const metricsFile = path.join(process.cwd(), '.audit_tmp', 'hook-metrics.jsonl');
+  if (fs.existsSync(metricsFile)) {
+    fs.unlinkSync(metricsFile);
+  }
+}
+
+describe('PredictiveHookAdvisor', () => {
+  beforeEach(() => {
+    cleanupMetricsFile();
+  });
+
+  afterEach(() => {
+    cleanupMetricsFile();
+  });
+
+  describe('constructor', () => {
+    it('should initialize with default window size', () => {
+      const advisor = makeSUT();
+      expect(advisor.windowSize).toBe(200);
+    });
+
+    it('should initialize with custom window size', () => {
+      const advisor = makeSUT({ windowSize: 100 });
+      expect(advisor.windowSize).toBe(100);
+    });
+  });
+
+  describe('loadMetrics', () => {
+    it('should return empty array when metrics file does not exist', () => {
+      const advisor = makeSUT();
+      const metrics = advisor.loadMetrics();
+      expect(metrics).toEqual([]);
+    });
+
+    it('should load metrics from file', () => {
+      const mockMetrics = [
+        { hook: 'pre-commit', status: 'success', timestamp: Date.now() },
+        { hook: 'pre-commit', status: 'failure', timestamp: Date.now() },
+      ];
+      createMockMetricsFile(mockMetrics);
+      const advisor = makeSUT();
+      const metrics = advisor.loadMetrics();
+      expect(metrics).toHaveLength(2);
+    });
+
+    it('should limit metrics to window size', () => {
+      const manyMetrics = Array.from({ length: 250 }, (_, i) => ({
+        hook: 'pre-commit',
+        status: 'success',
+        timestamp: Date.now() + i,
+      }));
+      createMockMetricsFile(manyMetrics);
+      const advisor = makeSUT({ windowSize: 200 });
+      const metrics = advisor.loadMetrics();
+      expect(metrics.length).toBeLessThanOrEqual(200);
+    });
+
+    it('should filter out invalid JSON lines', () => {
+      const metricsFile = path.join(process.cwd(), '.audit_tmp', 'hook-metrics.jsonl');
+      const dir = path.dirname(metricsFile);
+      if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+      }
+      fs.writeFileSync(metricsFile, '{"valid": true}\ninvalid json\n{"valid2": true}');
+      const advisor = makeSUT();
+      const metrics = advisor.loadMetrics();
+      expect(metrics).toHaveLength(2);
+    });
+  });
+
+  describe('getFailureProbabilities', () => {
+    it('should return empty array when no metrics', () => {
+      const advisor = makeSUT();
+      const probabilities = advisor.getFailureProbabilities();
+      expect(probabilities).toEqual([]);
+    });
+
+    it('should calculate failure probabilities per hook', () => {
+      const mockMetrics = [
+        { hook: 'pre-commit', status: 'success' },
+        { hook: 'pre-commit', status: 'success' },
+        { hook: 'pre-commit', status: 'failure' },
+        { hook: 'pre-push', status: 'success' },
+        { hook: 'pre-push', status: 'failure' },
+      ];
+      createMockMetricsFile(mockMetrics);
+      const advisor = makeSUT();
+      const probabilities = advisor.getFailureProbabilities();
+      expect(probabilities.length).toBeGreaterThan(0);
+      const preCommit = probabilities.find(p => p.hook === 'pre-commit');
+      expect(preCommit).toBeDefined();
+      expect(preCommit.total).toBe(3);
+      expect(preCommit.failures).toBe(1);
+    });
+
+    it('should sort by probability descending', () => {
+      const mockMetrics = [
+        { hook: 'hook-a', status: 'failure' },
+        { hook: 'hook-a', status: 'failure' },
+        { hook: 'hook-b', status: 'success' },
+        { hook: 'hook-b', status: 'failure' },
+      ];
+      createMockMetricsFile(mockMetrics);
+      const advisor = makeSUT();
+      const probabilities = advisor.getFailureProbabilities();
+      expect(probabilities[0].probability).toBeGreaterThanOrEqual(probabilities[1].probability);
+    });
+
+    it('should handle unknown hooks', () => {
+      const mockMetrics = [
+        { status: 'success' },
+        { hook: 'known-hook', status: 'failure' },
+      ];
+      createMockMetricsFile(mockMetrics);
+      const advisor = makeSUT();
+      const probabilities = advisor.getFailureProbabilities();
+      expect(probabilities.some(p => p.hook === 'unknown')).toBe(true);
+    });
+  });
+
+  describe('suggestPreemptiveActions', () => {
+    it('should return empty array when no high probability failures', () => {
+      const mockMetrics = [
+        { hook: 'pre-commit', status: 'success' },
+        { hook: 'pre-commit', status: 'success' },
+      ];
+      createMockMetricsFile(mockMetrics);
+      const advisor = makeSUT();
+      const suggestions = advisor.suggestPreemptiveActions(0.5);
+      expect(suggestions).toEqual([]);
+    });
+
+    it('should filter hooks above threshold', () => {
+      const mockMetrics = [
+        { hook: 'high-failure', status: 'failure' },
+        { hook: 'high-failure', status: 'failure' },
+        { hook: 'high-failure', status: 'failure' },
+        { hook: 'low-failure', status: 'success' },
+        { hook: 'low-failure', status: 'success' },
+        { hook: 'low-failure', status: 'failure' },
+      ];
+      createMockMetricsFile(mockMetrics);
+      const advisor = makeSUT();
+      const suggestions = advisor.suggestPreemptiveActions(0.5);
+      expect(suggestions.length).toBeGreaterThan(0);
+      expect(suggestions.every(s => s.probability >= 0.5)).toBe(true);
+    });
+
+    it('should use default threshold of 0.3', () => {
+      const mockMetrics = [
+        { hook: 'test-hook', status: 'failure' },
+        { hook: 'test-hook', status: 'failure' },
+        { hook: 'test-hook', status: 'success' },
+      ];
+      createMockMetricsFile(mockMetrics);
+      const advisor = makeSUT();
+      const suggestions = advisor.suggestPreemptiveActions();
+      expect(suggestions.length).toBeGreaterThanOrEqual(0);
+    });
+  });
+});
+

package/scripts/hooks-system/application/services/__tests__/RealtimeGuardPlugin.spec.js

@@ -0,0 +1,45 @@
+const { EvidenceRealtimeGuardPlugin } = require('../RealtimeGuardPlugin');
+
+describe('EvidenceRealtimeGuardPlugin', () => {
+    it('enqueues notifications through NotificationCenter when available', () => {
+        const enqueue = jest.fn();
+        const start = jest.fn();
+        const stop = jest.fn();
+
+        const plugin = new EvidenceRealtimeGuardPlugin({
+            notificationCenter: { enqueue },
+            evidenceMonitor: { start, stop }
+        });
+
+        plugin.start();
+        plugin.forwardNotification({ message: 'Stale evidence', level: 'warn', type: 'evidence_stale' });
+        plugin.stop();
+
+        expect(start).toHaveBeenCalled();
+        expect(stop).toHaveBeenCalled();
+        expect(enqueue).toHaveBeenCalledWith({
+            message: 'Stale evidence',
+            level: 'warn',
+            type: 'evidence_stale',
+            metadata: {}
+        });
+    });
+
+    it('falls back to logger when NotificationCenter is not provided', () => {
+        const info = jest.fn();
+        const warn = jest.fn();
+        const error = jest.fn();
+        const plugin = new EvidenceRealtimeGuardPlugin({
+            logger: { info, warn, error },
+            evidenceMonitor: { start: jest.fn(), stop: jest.fn() }
+        });
+
+        plugin.forwardNotification({ message: 'All good', level: 'info' });
+        plugin.forwardNotification({ message: 'Heads up', level: 'warn' });
+        plugin.forwardNotification({ message: 'Broken', level: 'error' });
+
+        expect(info).toHaveBeenCalledWith('EvidenceMonitor: All good', {});
+        expect(warn).toHaveBeenCalledWith('EvidenceMonitor: Heads up', {});
+        expect(error).toHaveBeenCalledWith('EvidenceMonitor: Broken', {});
+    });
+});