pumuki-ast-hooks 5.3.1

package/scripts/hooks-system/domain/entities/__tests__/Finding.spec.js

@@ -0,0 +1,335 @@
+const Finding = require('../Finding');
+
+describe('Finding', () => {
+  describe('constructor', () => {
+    it('should create Finding with required fields', () => {
+      const finding = new Finding(
+        'test.rule',
+        'high',
+        'Test violation message',
+        'test.ts',
+        10,
+        'backend'
+      );
+      expect(finding.ruleId).toBe('test.rule');
+      expect(finding.severity).toBe('high');
+      expect(finding.message).toBe('Test violation message');
+      expect(finding.filePath).toBe('test.ts');
+      expect(finding.line).toBe(10);
+      expect(finding.platform).toBe('backend');
+      expect(finding.timestamp).toBeInstanceOf(Date);
+      expect(finding.id).toBeDefined();
+    });
+
+    it('should default line to 1 when not provided', () => {
+      const finding = new Finding('test.rule', 'high', 'Message', 'test.ts', null, 'backend');
+      expect(finding.line).toBe(1);
+    });
+
+    it('should normalize platform to lowercase', () => {
+      const finding = new Finding('test.rule', 'high', 'Message', 'test.ts', 1, 'BACKEND');
+      expect(finding.platform).toBe('backend');
+    });
+
+    it('should default platform to unknown when not provided', () => {
+      const finding = new Finding('test.rule', 'high', 'Message', 'test.ts', 1, null);
+      expect(finding.platform).toBe('unknown');
+    });
+
+    it('should throw error when ruleId is missing', () => {
+      expect(() => {
+        new Finding(null, 'high', 'Message', 'test.ts', 1, 'backend');
+      }).toThrow('Finding requires valid ruleId (string)');
+    });
+
+    it('should throw error when ruleId is not a string', () => {
+      expect(() => {
+        new Finding(123, 'high', 'Message', 'test.ts', 1, 'backend');
+      }).toThrow('Finding requires valid ruleId (string)');
+    });
+
+    it('should throw error when severity is invalid', () => {
+      expect(() => {
+        new Finding('test.rule', 'invalid', 'Message', 'test.ts', 1, 'backend');
+      }).toThrow('Invalid severity');
+    });
+
+    it('should throw error when message is missing', () => {
+      expect(() => {
+        new Finding('test.rule', 'high', null, 'test.ts', 1, 'backend');
+      }).toThrow('Finding requires valid message (string)');
+    });
+
+    it('should throw error when filePath is missing', () => {
+      expect(() => {
+        new Finding('test.rule', 'high', 'Message', null, 1, 'backend');
+      }).toThrow('Finding requires valid filePath (string)');
+    });
+  });
+
+  describe('normalizeSeverity', () => {
+    it('should normalize error to high', () => {
+      const finding = new Finding('test.rule', 'error', 'Message', 'test.ts', 1, 'backend');
+      expect(finding.severity).toBe('high');
+    });
+
+    it('should normalize warning to medium', () => {
+      const finding = new Finding('test.rule', 'warning', 'Message', 'test.ts', 1, 'backend');
+      expect(finding.severity).toBe('medium');
+    });
+
+    it('should keep critical as critical', () => {
+      const finding = new Finding('test.rule', 'critical', 'Message', 'test.ts', 1, 'backend');
+      expect(finding.severity).toBe('critical');
+    });
+
+    it('should keep high as high', () => {
+      const finding = new Finding('test.rule', 'high', 'Message', 'test.ts', 1, 'backend');
+      expect(finding.severity).toBe('high');
+    });
+
+    it('should be case insensitive', () => {
+      const finding = new Finding('test.rule', 'CRITICAL', 'Message', 'test.ts', 1, 'backend');
+      expect(finding.severity).toBe('critical');
+    });
+  });
+
+  describe('generateId', () => {
+    it('should generate unique ID', () => {
+      const finding1 = new Finding('test.rule', 'high', 'Message', 'test.ts', 1, 'backend');
+      const finding2 = new Finding('test.rule', 'high', 'Message', 'test.ts', 1, 'backend');
+      expect(finding1.id).toBeDefined();
+      expect(finding2.id).toBeDefined();
+    });
+
+    it('should generate different IDs for different findings', () => {
+      const finding1 = new Finding('test.rule', 'high', 'Message', 'test.ts', 1, 'backend');
+      const finding2 = new Finding('test.rule', 'high', 'Message', 'test.ts', 1, 'backend');
+      expect(finding1.id).toBeDefined();
+      expect(finding2.id).toBeDefined();
+      expect(typeof finding1.id).toBe('string');
+      expect(typeof finding2.id).toBe('string');
+    });
+  });
+
+  describe('severity checks', () => {
+    it('should correctly identify critical severity', () => {
+      const finding = new Finding('test.rule', 'critical', 'Message', 'test.ts', 1, 'backend');
+      expect(finding.isCritical()).toBe(true);
+      expect(finding.isHigh()).toBe(false);
+      expect(finding.isMedium()).toBe(false);
+      expect(finding.isLow()).toBe(false);
+      expect(finding.isInfo()).toBe(false);
+    });
+
+    it('should correctly identify high severity', () => {
+      const finding = new Finding('test.rule', 'high', 'Message', 'test.ts', 1, 'backend');
+      expect(finding.isCritical()).toBe(false);
+      expect(finding.isHigh()).toBe(true);
+      expect(finding.isMedium()).toBe(false);
+      expect(finding.isLow()).toBe(false);
+      expect(finding.isInfo()).toBe(false);
+    });
+
+    it('should correctly identify medium severity', () => {
+      const finding = new Finding('test.rule', 'medium', 'Message', 'test.ts', 1, 'backend');
+      expect(finding.isCritical()).toBe(false);
+      expect(finding.isHigh()).toBe(false);
+      expect(finding.isMedium()).toBe(true);
+      expect(finding.isLow()).toBe(false);
+      expect(finding.isInfo()).toBe(false);
+    });
+
+    it('should correctly identify low severity', () => {
+      const finding = new Finding('test.rule', 'low', 'Message', 'test.ts', 1, 'backend');
+      expect(finding.isCritical()).toBe(false);
+      expect(finding.isHigh()).toBe(false);
+      expect(finding.isMedium()).toBe(false);
+      expect(finding.isLow()).toBe(true);
+      expect(finding.isInfo()).toBe(false);
+    });
+
+    it('should correctly identify info severity', () => {
+      const finding = new Finding('test.rule', 'info', 'Message', 'test.ts', 1, 'backend');
+      expect(finding.isCritical()).toBe(false);
+      expect(finding.isHigh()).toBe(false);
+      expect(finding.isMedium()).toBe(false);
+      expect(finding.isLow()).toBe(false);
+      expect(finding.isInfo()).toBe(true);
+    });
+  });
+
+  describe('isBlockingLevel', () => {
+    it('should return true for critical severity', () => {
+      const finding = new Finding('test.rule', 'critical', 'Message', 'test.ts', 1, 'backend');
+      expect(finding.isBlockingLevel()).toBe(true);
+    });
+
+    it('should return true for high severity', () => {
+      const finding = new Finding('test.rule', 'high', 'Message', 'test.ts', 1, 'backend');
+      expect(finding.isBlockingLevel()).toBe(true);
+    });
+
+    it('should return false for medium severity', () => {
+      const finding = new Finding('test.rule', 'medium', 'Message', 'test.ts', 1, 'backend');
+      expect(finding.isBlockingLevel()).toBe(false);
+    });
+
+    it('should return false for low severity', () => {
+      const finding = new Finding('test.rule', 'low', 'Message', 'test.ts', 1, 'backend');
+      expect(finding.isBlockingLevel()).toBe(false);
+    });
+
+    it('should return false for info severity', () => {
+      const finding = new Finding('test.rule', 'info', 'Message', 'test.ts', 1, 'backend');
+      expect(finding.isBlockingLevel()).toBe(false);
+    });
+  });
+
+  describe('belongsToPlatform', () => {
+    it('should return true for matching platform', () => {
+      const finding = new Finding('test.rule', 'high', 'Message', 'test.ts', 1, 'backend');
+      expect(finding.belongsToPlatform('backend')).toBe(true);
+    });
+
+    it('should return false for non-matching platform', () => {
+      const finding = new Finding('test.rule', 'high', 'Message', 'test.ts', 1, 'backend');
+      expect(finding.belongsToPlatform('frontend')).toBe(false);
+    });
+
+    it('should be case insensitive', () => {
+      const finding = new Finding('test.rule', 'high', 'Message', 'test.ts', 1, 'backend');
+      expect(finding.belongsToPlatform('BACKEND')).toBe(true);
+    });
+  });
+
+  describe('getSeverityWeight', () => {
+    it('should return correct weight for critical', () => {
+      const finding = new Finding('test.rule', 'critical', 'Message', 'test.ts', 1, 'backend');
+      expect(finding.getSeverityWeight()).toBe(4);
+    });
+
+    it('should return correct weight for high', () => {
+      const finding = new Finding('test.rule', 'high', 'Message', 'test.ts', 1, 'backend');
+      expect(finding.getSeverityWeight()).toBe(3);
+    });
+
+    it('should return correct weight for medium', () => {
+      const finding = new Finding('test.rule', 'medium', 'Message', 'test.ts', 1, 'backend');
+      expect(finding.getSeverityWeight()).toBe(2);
+    });
+
+    it('should return correct weight for low', () => {
+      const finding = new Finding('test.rule', 'low', 'Message', 'test.ts', 1, 'backend');
+      expect(finding.getSeverityWeight()).toBe(1);
+    });
+
+    it('should return correct weight for info', () => {
+      const finding = new Finding('test.rule', 'info', 'Message', 'test.ts', 1, 'backend');
+      expect(finding.getSeverityWeight()).toBe(0);
+    });
+  });
+
+  describe('getTechnicalDebtHours', () => {
+    it('should return correct hours for critical', () => {
+      const finding = new Finding('test.rule', 'critical', 'Message', 'test.ts', 1, 'backend');
+      expect(finding.getTechnicalDebtHours()).toBe(4);
+    });
+
+    it('should return correct hours for high', () => {
+      const finding = new Finding('test.rule', 'high', 'Message', 'test.ts', 1, 'backend');
+      expect(finding.getTechnicalDebtHours()).toBe(2);
+    });
+
+    it('should return correct hours for medium', () => {
+      const finding = new Finding('test.rule', 'medium', 'Message', 'test.ts', 1, 'backend');
+      expect(finding.getTechnicalDebtHours()).toBe(1);
+    });
+
+    it('should return correct hours for low', () => {
+      const finding = new Finding('test.rule', 'low', 'Message', 'test.ts', 1, 'backend');
+      expect(finding.getTechnicalDebtHours()).toBe(0.5);
+    });
+
+    it('should return correct hours for info', () => {
+      const finding = new Finding('test.rule', 'info', 'Message', 'test.ts', 1, 'backend');
+      expect(finding.getTechnicalDebtHours()).toBe(0);
+    });
+  });
+
+  describe('toJSON', () => {
+    it('should serialize to JSON correctly', () => {
+      const finding = new Finding('test.rule', 'high', 'Test message', 'test.ts', 10, 'backend');
+      const json = finding.toJSON();
+      expect(json.id).toBe(finding.id);
+      expect(json.ruleId).toBe('test.rule');
+      expect(json.severity).toBe('high');
+      expect(json.message).toBe('Test message');
+      expect(json.filePath).toBe('test.ts');
+      expect(json.line).toBe(10);
+      expect(json.platform).toBe('backend');
+      expect(json.timestamp).toBeDefined();
+      expect(json.technicalDebtHours).toBe(2);
+    });
+
+    it('should include ISO timestamp', () => {
+      const finding = new Finding('test.rule', 'high', 'Message', 'test.ts', 1, 'backend');
+      const json = finding.toJSON();
+      expect(json.timestamp).toMatch(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/);
+    });
+  });
+
+  describe('fromJSON', () => {
+    it('should deserialize from JSON correctly', () => {
+      const original = new Finding('test.rule', 'high', 'Test message', 'test.ts', 10, 'backend');
+      const json = original.toJSON();
+      const deserialized = Finding.fromJSON(json);
+      expect(deserialized.ruleId).toBe('test.rule');
+      expect(deserialized.severity).toBe('high');
+      expect(deserialized.message).toBe('Test message');
+      expect(deserialized.filePath).toBe('test.ts');
+      expect(deserialized.line).toBe(10);
+      expect(deserialized.platform).toBe('backend');
+      expect(deserialized.id).toBe(original.id);
+      expect(deserialized.timestamp).toBeInstanceOf(Date);
+    });
+
+    it('should handle missing timestamp gracefully', () => {
+      const json = {
+        ruleId: 'test.rule',
+        severity: 'high',
+        message: 'Message',
+        filePath: 'test.ts',
+        line: 1,
+        platform: 'backend',
+      };
+      const deserialized = Finding.fromJSON(json);
+      expect(deserialized.timestamp).toBeInstanceOf(Date);
+    });
+
+    it('should handle missing id gracefully', () => {
+      const json = {
+        ruleId: 'test.rule',
+        severity: 'high',
+        message: 'Message',
+        filePath: 'test.ts',
+        line: 1,
+        platform: 'backend',
+      };
+      const deserialized = Finding.fromJSON(json);
+      expect(deserialized.id).toBeDefined();
+    });
+  });
+
+  describe('toString', () => {
+    it('should format finding as string correctly', () => {
+      const finding = new Finding('test.rule', 'high', 'Test message', 'test.ts', 10, 'backend');
+      const str = finding.toString();
+      expect(str).toContain('[HIGH]');
+      expect(str).toContain('test.rule');
+      expect(str).toContain('test.ts:10');
+      expect(str).toContain('Test message');
+    });
+  });
+});
+

package/scripts/hooks-system/domain/entities/__tests__/SeverityConfig.spec.js

@@ -0,0 +1,240 @@
+const { SeverityConfig, SEVERITY_LEVELS, SEVERITY_MAP, SEVERITY_ICONS, SEVERITY_LABELS } = require('../SeverityConfig');
+
+describe('SeverityConfig', () => {
+  describe('getSeverityValue', () => {
+    it('should return CRITICAL for critical severity', () => {
+      expect(SeverityConfig.getSeverityValue('critical')).toBe('CRITICAL');
+      expect(SeverityConfig.getSeverityValue('CRITICAL')).toBe('CRITICAL');
+    });
+
+    it('should return HIGH for high severity', () => {
+      expect(SeverityConfig.getSeverityValue('high')).toBe('HIGH');
+      expect(SeverityConfig.getSeverityValue('HIGH')).toBe('HIGH');
+    });
+
+    it('should return MEDIUM for medium severity', () => {
+      expect(SeverityConfig.getSeverityValue('medium')).toBe('MEDIUM');
+      expect(SeverityConfig.getSeverityValue('MEDIUM')).toBe('MEDIUM');
+    });
+
+    it('should return LOW for low severity', () => {
+      expect(SeverityConfig.getSeverityValue('low')).toBe('LOW');
+      expect(SeverityConfig.getSeverityValue('LOW')).toBe('LOW');
+    });
+
+    it('should map error to HIGH', () => {
+      expect(SeverityConfig.getSeverityValue('error')).toBe('HIGH');
+    });
+
+    it('should map warning to MEDIUM', () => {
+      expect(SeverityConfig.getSeverityValue('warning')).toBe('MEDIUM');
+    });
+
+    it('should map info to LOW', () => {
+      expect(SeverityConfig.getSeverityValue('info')).toBe('LOW');
+    });
+
+    it('should return MEDIUM as default for unknown severity', () => {
+      expect(SeverityConfig.getSeverityValue('unknown')).toBe('MEDIUM');
+      expect(SeverityConfig.getSeverityValue(null)).toBe('MEDIUM');
+      expect(SeverityConfig.getSeverityValue(undefined)).toBe('MEDIUM');
+    });
+  });
+
+  describe('getSeverityIcon', () => {
+    it('should return correct icon for CRITICAL', () => {
+      expect(SeverityConfig.getSeverityIcon('critical')).toBe('🔴');
+      expect(SeverityConfig.getSeverityIcon('CRITICAL')).toBe('🔴');
+    });
+
+    it('should return correct icon for HIGH', () => {
+      expect(SeverityConfig.getSeverityIcon('high')).toBe('🟠');
+      expect(SeverityConfig.getSeverityIcon('HIGH')).toBe('🟠');
+    });
+
+    it('should return correct icon for MEDIUM', () => {
+      expect(SeverityConfig.getSeverityIcon('medium')).toBe('🟡');
+      expect(SeverityConfig.getSeverityIcon('MEDIUM')).toBe('🟡');
+    });
+
+    it('should return correct icon for LOW', () => {
+      expect(SeverityConfig.getSeverityIcon('low')).toBe('🟢');
+      expect(SeverityConfig.getSeverityIcon('LOW')).toBe('🟢');
+    });
+
+    it('should return MEDIUM icon as default for unknown severity', () => {
+      expect(SeverityConfig.getSeverityIcon('unknown')).toBe('🟡');
+    });
+  });
+
+  describe('getSeverityLabel', () => {
+    it('should return correct label for CRITICAL', () => {
+      expect(SeverityConfig.getSeverityLabel('critical')).toBe('Critical');
+      expect(SeverityConfig.getSeverityLabel('CRITICAL')).toBe('Critical');
+    });
+
+    it('should return correct label for HIGH', () => {
+      expect(SeverityConfig.getSeverityLabel('high')).toBe('High');
+      expect(SeverityConfig.getSeverityLabel('HIGH')).toBe('High');
+    });
+
+    it('should return correct label for MEDIUM', () => {
+      expect(SeverityConfig.getSeverityLabel('medium')).toBe('Medium');
+      expect(SeverityConfig.getSeverityLabel('MEDIUM')).toBe('Medium');
+    });
+
+    it('should return correct label for LOW', () => {
+      expect(SeverityConfig.getSeverityLabel('low')).toBe('Low');
+      expect(SeverityConfig.getSeverityLabel('LOW')).toBe('Low');
+    });
+
+    it('should return MEDIUM label as default for unknown severity', () => {
+      expect(SeverityConfig.getSeverityLabel('unknown')).toBe('Medium');
+    });
+  });
+
+  describe('isBlocking', () => {
+    it('should return true for CRITICAL severity', () => {
+      expect(SeverityConfig.isBlocking('critical')).toBe(true);
+      expect(SeverityConfig.isBlocking('CRITICAL')).toBe(true);
+    });
+
+    it('should return true for HIGH severity', () => {
+      expect(SeverityConfig.isBlocking('high')).toBe(true);
+      expect(SeverityConfig.isBlocking('HIGH')).toBe(true);
+    });
+
+    it('should return false for MEDIUM severity', () => {
+      expect(SeverityConfig.isBlocking('medium')).toBe(false);
+      expect(SeverityConfig.isBlocking('MEDIUM')).toBe(false);
+    });
+
+    it('should return false for LOW severity', () => {
+      expect(SeverityConfig.isBlocking('low')).toBe(false);
+      expect(SeverityConfig.isBlocking('LOW')).toBe(false);
+    });
+
+    it('should return true for error (mapped to HIGH)', () => {
+      expect(SeverityConfig.isBlocking('error')).toBe(true);
+    });
+
+    it('should return false for warning (mapped to MEDIUM)', () => {
+      expect(SeverityConfig.isBlocking('warning')).toBe(false);
+    });
+  });
+
+  describe('filterBySeverity', () => {
+    it('should filter violations by exact severity match', () => {
+      const violations = [
+        { severity: 'CRITICAL', ruleId: 'rule1' },
+        { severity: 'HIGH', ruleId: 'rule2' },
+        { severity: 'CRITICAL', ruleId: 'rule3' },
+        { severity: 'MEDIUM', ruleId: 'rule4' },
+      ];
+      const filtered = SeverityConfig.filterBySeverity(violations, 'CRITICAL');
+      expect(filtered).toHaveLength(2);
+      expect(filtered.every(v => v.severity === 'CRITICAL' || v.severity === 'critical')).toBe(true);
+    });
+
+    it('should handle case-insensitive severity values', () => {
+      const violations = [
+        { severity: 'critical', ruleId: 'rule1' },
+        { severity: 'CRITICAL', ruleId: 'rule2' },
+        { severity: 'high', ruleId: 'rule3' },
+      ];
+      const filtered = SeverityConfig.filterBySeverity(violations, 'CRITICAL');
+      expect(filtered.length).toBeGreaterThanOrEqual(1);
+    });
+
+    it('should return empty array when no matches', () => {
+      const violations = [
+        { severity: 'HIGH', ruleId: 'rule1' },
+        { severity: 'MEDIUM', ruleId: 'rule2' },
+      ];
+      const filtered = SeverityConfig.filterBySeverity(violations, 'CRITICAL');
+      expect(filtered).toHaveLength(0);
+    });
+
+    it('should return empty array for empty violations array', () => {
+      const filtered = SeverityConfig.filterBySeverity([], 'CRITICAL');
+      expect(filtered).toHaveLength(0);
+    });
+  });
+
+  describe('sortBySeverity', () => {
+    it('should sort violations by severity descending', () => {
+      const violations = [
+        { severity: 'LOW', ruleId: 'rule1' },
+        { severity: 'CRITICAL', ruleId: 'rule2' },
+        { severity: 'MEDIUM', ruleId: 'rule3' },
+        { severity: 'HIGH', ruleId: 'rule4' },
+      ];
+      const sorted = SeverityConfig.sortBySeverity(violations);
+      expect(sorted[0].severity).toBe('CRITICAL');
+      expect(sorted[1].severity).toBe('HIGH');
+      expect(sorted[2].severity).toBe('MEDIUM');
+      expect(sorted[3].severity).toBe('LOW');
+    });
+
+    it('should handle case-insensitive severity values', () => {
+      const violations = [
+        { severity: 'low', ruleId: 'rule1' },
+        { severity: 'critical', ruleId: 'rule2' },
+        { severity: 'high', ruleId: 'rule3' },
+      ];
+      const sorted = SeverityConfig.sortBySeverity(violations);
+      expect(sorted[0].severity).toBe('critical');
+      expect(sorted[1].severity).toBe('high');
+      expect(sorted[2].severity).toBe('low');
+    });
+
+    it('should handle unknown severities (place at end)', () => {
+      const violations = [
+        { severity: 'unknown', ruleId: 'rule1' },
+        { severity: 'CRITICAL', ruleId: 'rule2' },
+        { severity: 'invalid', ruleId: 'rule3' },
+      ];
+      const sorted = SeverityConfig.sortBySeverity(violations);
+      expect(sorted[0].severity).toBe('CRITICAL');
+    });
+
+    it('should return empty array for empty violations', () => {
+      const sorted = SeverityConfig.sortBySeverity([]);
+      expect(sorted).toHaveLength(0);
+    });
+  });
+
+  describe('Constants', () => {
+    it('should export SEVERITY_LEVELS', () => {
+      expect(SEVERITY_LEVELS).toBeDefined();
+      expect(SEVERITY_LEVELS.CRITICAL).toBe(4);
+      expect(SEVERITY_LEVELS.HIGH).toBe(3);
+      expect(SEVERITY_LEVELS.MEDIUM).toBe(2);
+      expect(SEVERITY_LEVELS.LOW).toBe(1);
+    });
+
+    it('should export SEVERITY_MAP', () => {
+      expect(SEVERITY_MAP).toBeDefined();
+      expect(SEVERITY_MAP['critical']).toBe('CRITICAL');
+      expect(SEVERITY_MAP['error']).toBe('HIGH');
+      expect(SEVERITY_MAP['warning']).toBe('MEDIUM');
+    });
+
+    it('should export SEVERITY_ICONS', () => {
+      expect(SEVERITY_ICONS).toBeDefined();
+      expect(SEVERITY_ICONS.CRITICAL).toBe('🔴');
+      expect(SEVERITY_ICONS.HIGH).toBe('🟠');
+      expect(SEVERITY_ICONS.MEDIUM).toBe('🟡');
+      expect(SEVERITY_ICONS.LOW).toBe('🟢');
+    });
+
+    it('should export SEVERITY_LABELS', () => {
+      expect(SEVERITY_LABELS).toBeDefined();
+      expect(SEVERITY_LABELS.CRITICAL).toBe('Critical');
+      expect(SEVERITY_LABELS.HIGH).toBe('High');
+      expect(SEVERITY_LABELS.MEDIUM).toBe('Medium');
+      expect(SEVERITY_LABELS.LOW).toBe('Low');
+    });
+  });
+});
+

package/scripts/hooks-system/domain/entities/__tests__/entities.spec.js

@@ -0,0 +1,29 @@
+describe('domain/entities', () => {
+  describe('AuditResult', () => {
+    it('should export class', () => {
+      const AuditResult = require('../AuditResult');
+      expect(AuditResult).toBeDefined();
+    });
+
+    it('should be instantiable with empty array', () => {
+      const AuditResult = require('../AuditResult');
+      const instance = new AuditResult([]);
+      expect(instance).toBeDefined();
+      expect(instance.findings).toEqual([]);
+    });
+  });
+
+  describe('Finding', () => {
+    it('should export class', () => {
+      const Finding = require('../Finding');
+      expect(Finding).toBeDefined();
+    });
+
+    it('should be instantiable with valid params', () => {
+      const Finding = require('../Finding');
+      const instance = new Finding('rule-id', 'high', 'message', 'file.js', 1, 'backend');
+      expect(instance).toBeDefined();
+      expect(instance.ruleId).toBe('rule-id');
+    });
+  });
+});

package/scripts/hooks-system/domain/errors/__tests__/DomainErrors.spec.js

@@ -0,0 +1,59 @@
+const { DomainError, GuardError, EvidenceError } = require('../index');
+
+describe('Domain Errors', () => {
+    describe('DomainError', () => {
+        it('should correctly identify fatal errors', () => {
+            const fatalError = new DomainError('Fatal', 'CRITICAL_ERROR');
+            const nonFatalError = new DomainError('Warn', 'VALIDATION_ERROR');
+
+            expect(fatalError.isFatal()).toBe(true);
+            expect(nonFatalError.isFatal()).toBe(false);
+        });
+
+        it('should provide correct logging levels', () => {
+            const fatalError = new DomainError('Fatal', 'CRITICAL_ERROR');
+            const nonFatalError = new DomainError('Warn', 'VALIDATION_ERROR');
+
+            expect(fatalError.getLoggingLevel()).toBe('error');
+            expect(nonFatalError.getLoggingLevel()).toBe('warn');
+        });
+
+        it('should serialize correctly to JSON including isFatal flag', () => {
+            const error = new DomainError('Test', 'TEST_CODE');
+            const json = error.toJSON();
+
+            expect(json).toMatchObject({
+                name: 'DomainError',
+                message: 'Test',
+                code: 'TEST_CODE',
+                isFatal: false
+            });
+            expect(json.timestamp).toBeDefined();
+            expect(json.stack).toBeDefined();
+        });
+    });
+
+    describe('GuardError', () => {
+        it('should create from violation using factory method', () => {
+            const error = GuardError.fromViolation('Forbidden file', 'CommitGate');
+            expect(error.message).toContain('Forbidden file');
+            expect(error.details.gate).toBe('CommitGate');
+            expect(error.code).toBe('GUARD_ERROR');
+        });
+    });
+
+    describe('EvidenceError', () => {
+        it('should create stale error via factory', () => {
+            const error = EvidenceError.stale('/path/to/evidence', 300);
+            expect(error.message).toContain('stale');
+            expect(error.message).toContain('300s');
+            expect(error.details.evidencePath).toBe('/path/to/evidence');
+        });
+
+        it('should create missing error via factory', () => {
+            const error = EvidenceError.missing('/path/to/evidence');
+            expect(error.message).toContain('not found');
+            expect(error.details.evidencePath).toBe('/path/to/evidence');
+        });
+    });
+});