pumuki-ast-hooks 5.3.1

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

@@ -0,0 +1,43 @@
+const DynamicRulesLoader = require('../DynamicRulesLoader');
+
+describe('DynamicRulesLoader', () => {
+  describe('constructor', () => {
+    it('should be a class', () => {
+      expect(typeof DynamicRulesLoader).toBe('function');
+    });
+
+    it('should initialize with rules directory', () => {
+      const loader = new DynamicRulesLoader('/test/rules');
+      expect(loader.rulesDirectory).toBe('/test/rules');
+      expect(loader.rulesDirectories).toEqual(['/test/rules']);
+    });
+
+    it('should initialize with default rules directories', () => {
+      const loader = new DynamicRulesLoader();
+      expect(loader.rulesDirectory).toBeNull();
+      expect(Array.isArray(loader.rulesDirectories)).toBe(true);
+      expect(loader.rulesDirectories.length).toBeGreaterThan(0);
+    });
+
+    it('should have rules map for platforms', () => {
+      const loader = new DynamicRulesLoader();
+      expect(loader.rulesMap).toBeDefined();
+      expect(loader.rulesMap.backend).toBeDefined();
+      expect(loader.rulesMap.frontend).toBeDefined();
+      expect(loader.rulesMap.ios).toBeDefined();
+      expect(loader.rulesMap.android).toBeDefined();
+    });
+
+    it('should have cache with TTL', () => {
+      const loader = new DynamicRulesLoader();
+      expect(loader.cache).toBeDefined();
+      expect(loader.cache.ttl).toBeDefined();
+    });
+  });
+
+  describe('exports', () => {
+    it('should export DynamicRulesLoader class', () => {
+      expect(DynamicRulesLoader).toBeDefined();
+    });
+  });
+});

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

@@ -0,0 +1,163 @@
+const { getGitTreeState, isTreeBeyondLimit, summarizeTreeState } = require('../GitTreeState');
+const { execSync } = require('child_process');
+
+jest.mock('child_process');
+
+function makeMockGitStatus(stagedFiles = [], workingFiles = [], untrackedFiles = []) {
+  const lines = [];
+  stagedFiles.forEach(file => {
+    lines.push(`A  ${file}`);
+  });
+  workingFiles.forEach(file => {
+    lines.push(` M ${file}`);
+  });
+  untrackedFiles.forEach(file => {
+    lines.push(`?? ${file}`);
+  });
+  return lines.join('\n');
+}
+
+describe('GitTreeState', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe('getGitTreeState', () => {
+    it('should return state with empty arrays when git tree is clean', () => {
+      execSync.mockReturnValue('');
+      const state = getGitTreeState();
+      expect(state.stagedFiles).toEqual([]);
+      expect(state.workingFiles).toEqual([]);
+      expect(state.uniqueCount).toBe(0);
+    });
+
+    it('should detect staged files', () => {
+      const statusOutput = makeMockGitStatus(['file1.ts', 'file2.ts'], [], []);
+      execSync.mockReturnValue(statusOutput);
+      const state = getGitTreeState();
+      expect(state.stagedFiles).toHaveLength(2);
+      expect(state.stagedCount).toBe(2);
+    });
+
+    it('should detect working directory files', () => {
+      const statusOutput = makeMockGitStatus([], ['file1.ts', 'file2.ts'], []);
+      execSync.mockReturnValue(statusOutput);
+      const state = getGitTreeState();
+      expect(state.workingFiles).toHaveLength(2);
+      expect(state.workingCount).toBe(2);
+    });
+
+    it('should detect untracked files', () => {
+      const statusOutput = makeMockGitStatus([], [], ['new-file.ts']);
+      execSync.mockReturnValue(statusOutput);
+      const state = getGitTreeState();
+      expect(state.workingFiles).toContain('new-file.ts');
+    });
+
+    it('should calculate unique count correctly', () => {
+      const statusOutput = makeMockGitStatus(['file1.ts'], ['file2.ts'], ['file3.ts']);
+      execSync.mockReturnValue(statusOutput);
+      const state = getGitTreeState();
+      expect(state.uniqueCount).toBe(3);
+    });
+
+    it('should handle files in both staged and working', () => {
+      const statusOutput = 'M  file1.ts\n M file1.ts';
+      execSync.mockReturnValue(statusOutput);
+      const state = getGitTreeState();
+      expect(state.stagedFiles).toContain('file1.ts');
+      expect(state.workingFiles).toContain('file1.ts');
+      expect(state.uniqueCount).toBe(1);
+    });
+
+    it('should use custom repo root', () => {
+      execSync.mockReturnValue('');
+      const customRoot = '/custom/repo';
+      getGitTreeState({ repoRoot: customRoot });
+      expect(execSync).toHaveBeenCalledWith(
+        'git status --porcelain',
+        expect.objectContaining({ cwd: customRoot })
+      );
+    });
+
+    it('should handle git errors gracefully', () => {
+      execSync.mockImplementation(() => {
+        throw new Error('Not a git repository');
+      });
+      const state = getGitTreeState();
+      expect(state.stagedFiles).toEqual([]);
+      expect(state.workingFiles).toEqual([]);
+      expect(state.error).toBeDefined();
+    });
+  });
+
+  describe('isTreeBeyondLimit', () => {
+    it('should return false when state is null', () => {
+      expect(isTreeBeyondLimit(null, 10)).toBe(false);
+    });
+
+    it('should return false when limit is invalid', () => {
+      const state = { stagedCount: 5, workingCount: 5 };
+      expect(isTreeBeyondLimit(state, 0)).toBe(false);
+      expect(isTreeBeyondLimit(state, -1)).toBe(false);
+      expect(isTreeBeyondLimit(state, NaN)).toBe(false);
+    });
+
+    it('should return true when staged count exceeds limit', () => {
+      const state = { stagedCount: 15, workingCount: 5 };
+      expect(isTreeBeyondLimit(state, 10)).toBe(true);
+    });
+
+    it('should return true when working count exceeds limit', () => {
+      const state = { stagedCount: 5, workingCount: 15 };
+      expect(isTreeBeyondLimit(state, 10)).toBe(true);
+    });
+
+    it('should return false when counts are within limit', () => {
+      const state = { stagedCount: 5, workingCount: 5 };
+      expect(isTreeBeyondLimit(state, 10)).toBe(false);
+    });
+  });
+
+  describe('summarizeTreeState', () => {
+    it('should summarize clean tree state', () => {
+      const state = {
+        stagedFiles: [],
+        workingFiles: [],
+        stagedCount: 0,
+        workingCount: 0,
+        uniqueCount: 0,
+      };
+      const summary = summarizeTreeState(state);
+      expect(summary).toContain('staged 0');
+      expect(summary).toContain('working 0');
+      expect(summary).toContain('unique 0');
+    });
+
+    it('should summarize state with staged files', () => {
+      const state = {
+        stagedFiles: ['file1.ts', 'file2.ts'],
+        workingFiles: [],
+        stagedCount: 2,
+        workingCount: 0,
+        uniqueCount: 2,
+      };
+      const summary = summarizeTreeState(state);
+      expect(summary).toContain('staged');
+      expect(summary).toContain('2');
+    });
+
+    it('should summarize state with working files', () => {
+      const state = {
+        stagedFiles: [],
+        workingFiles: ['file1.ts'],
+        stagedCount: 0,
+        workingCount: 1,
+        uniqueCount: 1,
+      };
+      const summary = summarizeTreeState(state);
+      expect(summary).toContain('working');
+    });
+  });
+});
+

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

@@ -0,0 +1,207 @@
+const HookSystemScheduler = require('../HookSystemScheduler');
+const HookSystemStateMachine = require('../../state/HookSystemStateMachine');
+const { recordMetric } = require('../../../infrastructure/telemetry/metrics-logger');
+
+jest.mock('../../state/HookSystemStateMachine');
+jest.mock('../../../infrastructure/telemetry/metrics-logger');
+
+function makeSUT(options = {}) {
+  const mockOrchestrator = {
+    shouldReanalyze: jest.fn().mockReturnValue(true),
+    analyzeContext: jest.fn().mockResolvedValue({ action: 'ignored' }),
+  };
+  const mockContextEngine = {
+    detectContext: jest.fn(),
+  };
+  const defaultOptions = {
+    orchestrator: mockOrchestrator,
+    contextEngine: mockContextEngine,
+    intervalMs: 1000,
+    ...options,
+  };
+  return new HookSystemScheduler(defaultOptions);
+}
+
+describe('HookSystemScheduler', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    jest.useFakeTimers();
+    HookSystemStateMachine.mockImplementation(() => ({
+      getState: jest.fn().mockReturnValue('idle'),
+      transition: jest.fn(),
+    }));
+  });
+
+  afterEach(() => {
+    jest.useRealTimers();
+  });
+
+  describe('constructor', () => {
+    it('should initialize with provided options', () => {
+      const mockOrchestrator = { shouldReanalyze: jest.fn() };
+      const mockContextEngine = { detectContext: jest.fn() };
+      const scheduler = makeSUT({
+        orchestrator: mockOrchestrator,
+        contextEngine: mockContextEngine,
+        intervalMs: 5000,
+      });
+      expect(scheduler.orchestrator).toBe(mockOrchestrator);
+      expect(scheduler.contextEngine).toBe(mockContextEngine);
+      expect(scheduler.intervalMs).toBe(5000);
+    });
+
+    it('should use default interval when not provided', () => {
+      const scheduler = makeSUT();
+      expect(scheduler.intervalMs).toBe(1000);
+    });
+
+    it('should create state machine instance', () => {
+      makeSUT();
+      expect(HookSystemStateMachine).toHaveBeenCalled();
+    });
+  });
+
+  describe('start', () => {
+    it('should start timer when not already running', () => {
+      const scheduler = makeSUT();
+      scheduler.start();
+      expect(scheduler.timer).toBeDefined();
+    });
+
+    it('should not start multiple timers', () => {
+      const scheduler = makeSUT();
+      scheduler.start();
+      const firstTimer = scheduler.timer;
+      scheduler.start();
+      expect(scheduler.timer).toBe(firstTimer);
+    });
+
+    it('should call tick at interval', () => {
+      const scheduler = makeSUT();
+      const tickSpy = jest.spyOn(scheduler, 'tick').mockResolvedValue();
+      scheduler.start();
+      jest.advanceTimersByTime(1000);
+      expect(tickSpy).toHaveBeenCalled();
+    });
+  });
+
+  describe('stop', () => {
+    it('should stop timer when running', () => {
+      const scheduler = makeSUT();
+      scheduler.start();
+      scheduler.stop();
+      expect(scheduler.timer).toBeNull();
+    });
+
+    it('should handle stop when not running', () => {
+      const scheduler = makeSUT();
+      expect(() => scheduler.stop()).not.toThrow();
+    });
+  });
+
+  describe('tick', () => {
+    it('should skip when state is not idle', async () => {
+      const mockStateMachine = {
+        getState: jest.fn().mockReturnValue('analyzing'),
+        transition: jest.fn(),
+      };
+      HookSystemStateMachine.mockImplementation(() => mockStateMachine);
+      const scheduler = makeSUT();
+      await scheduler.tick();
+      expect(scheduler.orchestrator.shouldReanalyze).not.toHaveBeenCalled();
+    });
+
+    it('should skip when orchestrator should not reanalyze', async () => {
+      const mockStateMachine = {
+        getState: jest.fn().mockReturnValue('idle'),
+        transition: jest.fn(),
+      };
+      HookSystemStateMachine.mockImplementation(() => mockStateMachine);
+      const mockOrchestrator = {
+        shouldReanalyze: jest.fn().mockReturnValue(false),
+        analyzeContext: jest.fn(),
+      };
+      const scheduler = makeSUT({ orchestrator: mockOrchestrator });
+      await scheduler.tick();
+      expect(mockOrchestrator.analyzeContext).not.toHaveBeenCalled();
+    });
+
+    it('should execute analysis when conditions are met', async () => {
+      const mockStateMachine = {
+        getState: jest.fn().mockReturnValue('idle'),
+        transition: jest.fn(),
+      };
+      HookSystemStateMachine.mockImplementation(() => mockStateMachine);
+      const mockOrchestrator = {
+        shouldReanalyze: jest.fn().mockReturnValue(true),
+        analyzeContext: jest.fn().mockResolvedValue({ action: 'ignored' }),
+      };
+      const scheduler = makeSUT({ orchestrator: mockOrchestrator });
+      await scheduler.tick();
+      expect(mockOrchestrator.analyzeContext).toHaveBeenCalled();
+      expect(mockStateMachine.transition).toHaveBeenCalledWith('analyze');
+    });
+
+    it('should record success metric on completion', async () => {
+      const mockStateMachine = {
+        getState: jest.fn().mockReturnValue('idle'),
+        transition: jest.fn(),
+      };
+      HookSystemStateMachine.mockImplementation(() => mockStateMachine);
+      const scheduler = makeSUT();
+      await scheduler.tick();
+      expect(recordMetric).toHaveBeenCalledWith(
+        expect.objectContaining({
+          hook: 'autonomous-orchestrator',
+          status: 'success',
+        })
+      );
+    });
+
+    it('should handle errors and transition to error state', async () => {
+      const mockStateMachine = {
+        getState: jest.fn().mockReturnValue('idle'),
+        transition: jest.fn(),
+      };
+      HookSystemStateMachine.mockImplementation(() => mockStateMachine);
+      const mockOrchestrator = {
+        shouldReanalyze: jest.fn().mockReturnValue(true),
+        analyzeContext: jest.fn().mockRejectedValue(new Error('Analysis failed')),
+      };
+      const scheduler = makeSUT({ orchestrator: mockOrchestrator });
+      await expect(scheduler.tick()).rejects.toThrow('Analysis failed');
+      expect(mockStateMachine.transition).toHaveBeenCalledWith('error');
+      expect(mockStateMachine.transition).toHaveBeenCalledWith('reset');
+      expect(recordMetric).toHaveBeenCalledWith(
+        expect.objectContaining({
+          status: 'failure',
+        })
+      );
+    });
+  });
+
+  describe('executeAction', () => {
+    it('should handle auto-execute action', async () => {
+      const scheduler = makeSUT();
+      const action = { action: 'auto-execute' };
+      await expect(scheduler.executeAction(action)).resolves.not.toThrow();
+    });
+
+    it('should handle ask action', async () => {
+      const scheduler = makeSUT();
+      const action = { action: 'ask' };
+      await expect(scheduler.executeAction(action)).resolves.not.toThrow();
+    });
+
+    it('should handle null action', async () => {
+      const scheduler = makeSUT();
+      await expect(scheduler.executeAction(null)).resolves.not.toThrow();
+    });
+
+    it('should handle action without action property', async () => {
+      const scheduler = makeSUT();
+      const action = { type: 'unknown' };
+      await expect(scheduler.executeAction(action)).resolves.not.toThrow();
+    });
+  });
+});