pumuki-ast-hooks 5.3.1

package/scripts/hooks-system/application/use-cases/__tests__/AnalyzeStagedFilesUseCase.spec.js

@@ -0,0 +1,146 @@
+const AnalyzeStagedFilesUseCase = require('../AnalyzeStagedFilesUseCase');
+const AuditResult = require('../../../domain/entities/AuditResult');
+const Finding = require('../../../domain/entities/Finding');
+
+function makeSUT() {
+  const mockPlatformAnalyzers = {
+    backend: {
+      analyzeFiles: jest.fn().mockResolvedValue([
+        new Finding('backend.rule1', 'high', 'Backend violation', 'backend/test.ts', 10, 'backend'),
+      ]),
+    },
+    frontend: {
+      analyzeFiles: jest.fn().mockResolvedValue([
+        new Finding('frontend.rule1', 'medium', 'Frontend violation', 'frontend/test.tsx', 20, 'frontend'),
+      ]),
+    },
+  };
+
+  const mockGitOperations = {
+    getStagedFiles: jest.fn().mockResolvedValue([
+      'backend/test.ts',
+      'frontend/test.tsx',
+    ]),
+  };
+
+  const mockPlatformDetectionService = {
+    detectPlatformFromFile: jest.fn((filePath) => {
+      if (filePath.includes('backend')) return 'backend';
+      if (filePath.includes('frontend')) return 'frontend';
+      return 'unknown';
+    }),
+  };
+
+  const useCase = new AnalyzeStagedFilesUseCase(
+    mockPlatformAnalyzers,
+    mockGitOperations,
+    mockPlatformDetectionService
+  );
+
+  return { useCase, mockPlatformAnalyzers, mockGitOperations, mockPlatformDetectionService };
+}
+
+describe('AnalyzeStagedFilesUseCase', () => {
+  describe('execute', () => {
+    it('should analyze staged files grouped by platform', async () => {
+      const { useCase, mockGitOperations, mockPlatformAnalyzers } = makeSUT();
+      const result = await useCase.execute({});
+      expect(mockGitOperations.getStagedFiles).toHaveBeenCalled();
+      expect(mockPlatformAnalyzers.backend.analyzeFiles).toHaveBeenCalled();
+      expect(mockPlatformAnalyzers.frontend.analyzeFiles).toHaveBeenCalled();
+      expect(result).toBeInstanceOf(AuditResult);
+    });
+
+    it('should return empty AuditResult when no staged files', async () => {
+      const { useCase, mockGitOperations } = makeSUT();
+      mockGitOperations.getStagedFiles.mockResolvedValue([]);
+      const result = await useCase.execute({});
+      expect(result.getTotalViolations()).toBe(0);
+      expect(result).toBeInstanceOf(AuditResult);
+    });
+
+    it('should skip platforms without analyzers', async () => {
+      const { useCase, mockGitOperations, mockPlatformDetectionService } = makeSUT();
+      mockGitOperations.getStagedFiles.mockResolvedValue(['ios/test.swift']);
+      mockPlatformDetectionService.detectPlatformFromFile.mockReturnValue('ios');
+      const result = await useCase.execute({});
+      expect(result.getTotalViolations()).toBe(0);
+    });
+
+    it('should group files by platform before analysis', async () => {
+      const { useCase, mockGitOperations, mockPlatformAnalyzers } = makeSUT();
+      mockGitOperations.getStagedFiles.mockResolvedValue([
+        'backend/file1.ts',
+        'backend/file2.ts',
+        'frontend/file1.tsx',
+      ]);
+      await useCase.execute({});
+      expect(mockPlatformAnalyzers.backend.analyzeFiles).toHaveBeenCalledWith(
+        ['backend/file1.ts', 'backend/file2.ts'],
+        {}
+      );
+      expect(mockPlatformAnalyzers.frontend.analyzeFiles).toHaveBeenCalledWith(
+        ['frontend/file1.tsx'],
+        {}
+      );
+    });
+
+    it('should pass options to analyzers', async () => {
+      const { useCase, mockPlatformAnalyzers } = makeSUT();
+      const options = { strictMode: true, includeTests: false };
+      await useCase.execute(options);
+      expect(mockPlatformAnalyzers.backend.analyzeFiles).toHaveBeenCalledWith(
+        expect.any(Array),
+        options
+      );
+    });
+
+    it('should handle empty findings from analyzers', async () => {
+      const { useCase, mockPlatformAnalyzers } = makeSUT();
+      mockPlatformAnalyzers.backend.analyzeFiles.mockResolvedValue([]);
+      mockPlatformAnalyzers.frontend.analyzeFiles.mockResolvedValue([]);
+      const result = await useCase.execute({});
+      expect(result.getTotalViolations()).toBe(0);
+    });
+
+    it('should handle null findings from analyzers', async () => {
+      const { useCase, mockPlatformAnalyzers } = makeSUT();
+      mockPlatformAnalyzers.backend.analyzeFiles.mockResolvedValue(null);
+      const result = await useCase.execute({});
+      expect(result.getTotalViolations()).toBeGreaterThanOrEqual(0);
+    });
+
+    it('should propagate errors from git operations', async () => {
+      const { useCase, mockGitOperations } = makeSUT();
+      const error = new Error('Git operation failed');
+      mockGitOperations.getStagedFiles.mockRejectedValue(error);
+      await expect(useCase.execute({})).rejects.toThrow('Git operation failed');
+    });
+
+    it('should propagate errors from analyzers', async () => {
+      const { useCase, mockPlatformAnalyzers } = makeSUT();
+      const error = new Error('Analysis failed');
+      mockPlatformAnalyzers.backend.analyzeFiles.mockRejectedValue(error);
+      await expect(useCase.execute({})).rejects.toThrow('Analysis failed');
+    });
+  });
+
+  describe('groupFilesByPlatform', () => {
+    it('should group files by detected platform', () => {
+      const { useCase } = makeSUT();
+      const stagedFiles = ['backend/file1.ts', 'frontend/file1.tsx', 'backend/file2.ts'];
+      const grouped = useCase.groupFilesByPlatform(stagedFiles);
+      expect(grouped.backend).toHaveLength(2);
+      expect(grouped.frontend).toHaveLength(1);
+    });
+
+    it('should handle unknown platforms', () => {
+      const { useCase, mockPlatformDetectionService } = makeSUT();
+      mockPlatformDetectionService.detectPlatformFromFile.mockReturnValue('unknown');
+      const stagedFiles = ['unknown/file.txt'];
+      const grouped = useCase.groupFilesByPlatform(stagedFiles);
+      expect(grouped.unknown).toHaveLength(1);
+    });
+  });
+});
+

package/scripts/hooks-system/application/use-cases/__tests__/AutoExecuteAIStartUseCase.spec.js

@@ -0,0 +1,89 @@
+const AutoExecuteAIStartUseCase = require('../AutoExecuteAIStartUseCase');
+const path = require('path');
+
+function makeSUT(customRepoRoot = null) {
+  const mockOrchestrator = {
+    execute: jest.fn(),
+  };
+  const repoRoot = customRepoRoot || '/test/repo';
+  return new AutoExecuteAIStartUseCase(mockOrchestrator, repoRoot);
+}
+
+describe('AutoExecuteAIStartUseCase', () => {
+  describe('execute', () => {
+    it('should return error when no platforms provided', async () => {
+      const useCase = makeSUT();
+      const result = await useCase.execute([], 90);
+      expect(result.success).toBe(false);
+      expect(result.action).toBe('error');
+      expect(result.message).toContain('No platforms provided');
+    });
+
+    it('should return ignored when confidence is below 70', async () => {
+      const useCase = makeSUT();
+      const result = await useCase.execute(['backend'], 65);
+      expect(result.success).toBe(true);
+      expect(result.action).toBe('ignored');
+      expect(result.confidence).toBe(65);
+      expect(result.message).toContain('Confidence too low');
+    });
+
+    it('should return ask when confidence is between 70 and 89', async () => {
+      const useCase = makeSUT();
+      const result = await useCase.execute(['backend'], 75);
+      expect(result.success).toBe(true);
+      expect(result.action).toBe('ask');
+      expect(result.confidence).toBe(75);
+      expect(result.message).toContain('Medium confidence');
+    });
+
+    it('should attempt auto-execute when confidence is 90 or higher', async () => {
+      const useCase = makeSUT();
+      const result = await useCase.execute(['backend'], 90);
+      expect(['auto-executed', 'error']).toContain(result.action);
+    });
+
+    it('should handle platform objects with platform property', async () => {
+      const useCase = makeSUT();
+      const platforms = [{ platform: 'backend' }, { platform: 'frontend' }];
+      const result = await useCase.execute(platforms, 95);
+      expect(result.platforms).toEqual(platforms);
+    });
+
+    it('should filter out invalid platform entries', async () => {
+      const useCase = makeSUT();
+      const platforms = [{ platform: 'backend' }, null, undefined, ''];
+      const result = await useCase.execute(platforms, 95);
+      expect(['auto-executed', 'error']).toContain(result.action);
+    });
+  });
+
+  describe('autoExecute', () => {
+    it('should return error when update-evidence script not found', async () => {
+      const useCase = makeSUT();
+      const platforms = ['backend', 'frontend'];
+      const result = await useCase.autoExecute(platforms, 95);
+      expect(result.success).toBe(false);
+      expect(result.message).toContain('not found');
+    });
+
+    it('should handle script execution errors gracefully', async () => {
+      const useCase = makeSUT('/nonexistent/path');
+      const platforms = ['backend'];
+      const result = await useCase.autoExecute(platforms, 95);
+      expect(result.success).toBe(false);
+      expect(result.action).toBe('error');
+    });
+
+    it('should include output field when script executes successfully', async () => {
+      const repoRoot = process.cwd();
+      const useCase = makeSUT(repoRoot);
+      const platforms = ['backend'];
+      const result = await useCase.autoExecute(platforms, 95);
+      if (result.success && result.output) {
+        expect(typeof result.output).toBe('object');
+      }
+    });
+  });
+});
+

package/scripts/hooks-system/application/use-cases/__tests__/BlockCommitUseCase.spec.js

@@ -0,0 +1,171 @@
+const BlockCommitUseCase = require('../BlockCommitUseCase');
+const CommitBlockingRules = require('../../../domain/rules/CommitBlockingRules');
+const AuditResult = require('../../../domain/entities/AuditResult');
+const Finding = require('../../../domain/entities/Finding');
+
+function makeSUT(customCommitBlockingRules = null) {
+  const commitBlockingRules = customCommitBlockingRules || new CommitBlockingRules();
+  return new BlockCommitUseCase(commitBlockingRules);
+}
+
+function createAuditResultWithFindings(findings) {
+  return new AuditResult(findings);
+}
+
+describe('BlockCommitUseCase', () => {
+  describe('execute', () => {
+    it('should block commit when critical violations exist', async () => {
+      const useCase = makeSUT();
+      const criticalFinding = new Finding('test.rule', 'critical', 'Critical violation', 'test.ts', 1, 'backend');
+      const auditResult = createAuditResultWithFindings([criticalFinding]);
+      const decision = await useCase.execute(auditResult, { strictMode: true });
+      expect(decision.shouldBlock).toBe(true);
+    });
+
+    it('should block commit when high violations exist in strict mode', async () => {
+      const useCase = makeSUT();
+      const highFinding = new Finding('test.rule', 'high', 'High violation', 'test.ts', 1, 'backend');
+      const auditResult = createAuditResultWithFindings([highFinding]);
+      const decision = await useCase.execute(auditResult, { strictMode: true });
+      expect(decision.shouldBlock).toBe(true);
+    });
+
+    it('should allow commit when only medium violations exist', async () => {
+      const useCase = makeSUT();
+      const mediumFinding = new Finding('test.rule', 'medium', 'Medium violation', 'test.ts', 1, 'backend');
+      const auditResult = createAuditResultWithFindings([mediumFinding]);
+      const decision = await useCase.execute(auditResult, { strictMode: false });
+      expect(decision.shouldBlock).toBe(false);
+    });
+
+    it('should use staged files only when useStagedOnly is true', async () => {
+      const mockCommitBlockingRules = {
+        shouldBlockByStagedFiles: jest.fn().mockReturnValue({ shouldBlock: false }),
+        shouldBlockCommit: jest.fn(),
+        calculateTechnicalDebtThreshold: jest.fn().mockReturnValue({ currentDebt: 0, message: '' }),
+        getMaintainabilityGate: jest.fn().mockReturnValue({ score: 100 }),
+      };
+      const useCase = makeSUT(mockCommitBlockingRules);
+      const auditResult = createAuditResultWithFindings([]);
+      await useCase.execute(auditResult, { useStagedOnly: true });
+      expect(mockCommitBlockingRules.shouldBlockByStagedFiles).toHaveBeenCalled();
+      expect(mockCommitBlockingRules.shouldBlockCommit).not.toHaveBeenCalled();
+    });
+
+    it('should use full audit result when useStagedOnly is false', async () => {
+      const mockCommitBlockingRules = {
+        shouldBlockByStagedFiles: jest.fn(),
+        shouldBlockCommit: jest.fn().mockReturnValue({ shouldBlock: false }),
+        calculateTechnicalDebtThreshold: jest.fn().mockReturnValue({ currentDebt: 0, message: '' }),
+        getMaintainabilityGate: jest.fn().mockReturnValue({ score: 100 }),
+      };
+      const useCase = makeSUT(mockCommitBlockingRules);
+      const auditResult = createAuditResultWithFindings([]);
+      await useCase.execute(auditResult, { useStagedOnly: false });
+      expect(mockCommitBlockingRules.shouldBlockCommit).toHaveBeenCalled();
+      expect(mockCommitBlockingRules.shouldBlockByStagedFiles).not.toHaveBeenCalled();
+    });
+
+    it('should include technical debt information when commit is allowed', async () => {
+      const mockCommitBlockingRules = {
+        shouldBlockCommit: jest.fn().mockReturnValue({ shouldBlock: false }),
+        calculateTechnicalDebtThreshold: jest.fn().mockReturnValue({
+          currentDebt: 10,
+          message: '10 hours of technical debt',
+        }),
+        getMaintainabilityGate: jest.fn().mockReturnValue({ score: 85 }),
+      };
+      const useCase = makeSUT(mockCommitBlockingRules);
+      const auditResult = createAuditResultWithFindings([]);
+      const decision = await useCase.execute(auditResult, {});
+      expect(decision.technicalDebt).toBe(10);
+      expect(decision.debtMessage).toBe('10 hours of technical debt');
+      expect(decision.maintainability).toBeDefined();
+    });
+
+    it('should include maintainability gate when commit is allowed', async () => {
+      const mockCommitBlockingRules = {
+        shouldBlockCommit: jest.fn().mockReturnValue({ shouldBlock: false }),
+        calculateTechnicalDebtThreshold: jest.fn().mockReturnValue({ currentDebt: 0, message: '' }),
+        getMaintainabilityGate: jest.fn().mockReturnValue({ score: 90 }),
+      };
+      const useCase = makeSUT(mockCommitBlockingRules);
+      const auditResult = createAuditResultWithFindings([]);
+      const decision = await useCase.execute(auditResult, {});
+      expect(decision.maintainability.score).toBe(90);
+    });
+
+    it('should respect blockOnlyCriticalHigh option', async () => {
+      const mockCommitBlockingRules = {
+        shouldBlockCommit: jest.fn().mockReturnValue({ shouldBlock: false }),
+        calculateTechnicalDebtThreshold: jest.fn().mockReturnValue({ currentDebt: 0, message: '' }),
+        getMaintainabilityGate: jest.fn().mockReturnValue({ score: 100 }),
+      };
+      const useCase = makeSUT(mockCommitBlockingRules);
+      const auditResult = createAuditResultWithFindings([]);
+      await useCase.execute(auditResult, { blockOnlyCriticalHigh: true });
+      expect(mockCommitBlockingRules.shouldBlockCommit).toHaveBeenCalledWith(
+        auditResult,
+        false,
+        true
+      );
+    });
+
+    it('should propagate errors from commit blocking rules', async () => {
+      const mockCommitBlockingRules = {
+        shouldBlockCommit: jest.fn().mockImplementation(() => {
+          throw new Error('Blocking rules error');
+        }),
+      };
+      const useCase = makeSUT(mockCommitBlockingRules);
+      const auditResult = createAuditResultWithFindings([]);
+      await expect(useCase.execute(auditResult, {})).rejects.toThrow('Blocking rules error');
+    });
+  });
+
+  describe('formatDecisionMessage', () => {
+    it('should format blocking decision message', () => {
+      const useCase = makeSUT();
+      const decision = {
+        shouldBlock: true,
+        reason: 'Critical violations detected',
+        violations: { critical: 2, high: 5 },
+      };
+      const message = useCase.formatDecisionMessage(decision);
+      expect(message).toContain('COMMIT BLOCKED');
+      expect(message).toContain('Critical violations detected');
+      expect(message).toContain('CRITICAL: 2');
+      expect(message).toContain('HIGH: 5');
+    });
+
+    it('should format allowed decision message', () => {
+      const useCase = makeSUT();
+      const decision = {
+        shouldBlock: false,
+        reason: 'No blocking violations',
+        technicalDebt: 5,
+        debtMessage: '5 hours of technical debt',
+        maintainability: { score: 90 },
+      };
+      const message = useCase.formatDecisionMessage(decision);
+      expect(message).toContain('COMMIT ALLOWED');
+      expect(message).toContain('No blocking violations');
+      expect(message).toContain('Technical Debt Tracking');
+    });
+
+    it('should include technical debt information when present', () => {
+      const useCase = makeSUT();
+      const decision = {
+        shouldBlock: false,
+        reason: 'Allowed',
+        technicalDebt: 10,
+        debtMessage: '10 hours',
+        maintainability: { score: 85 },
+      };
+      const message = useCase.formatDecisionMessage(decision);
+      expect(message).toContain('10 hours');
+      expect(message).toContain('85.0/100');
+    });
+  });
+});
+

package/scripts/hooks-system/application/use-cases/__tests__/GenerateAuditReportUseCase.spec.js

@@ -0,0 +1,207 @@
+const GenerateAuditReportUseCase = require('../GenerateAuditReportUseCase');
+const AuditResult = require('../../../domain/entities/AuditResult');
+const Finding = require('../../../domain/entities/Finding');
+
+function makeSUT(customOutputFormatter = null) {
+  const outputFormatter = customOutputFormatter || null;
+  return new GenerateAuditReportUseCase(outputFormatter);
+}
+
+function createAuditResultWithFindings(findings) {
+  const result = new AuditResult(findings);
+  result.setMetadata(10, 1000, ['backend', 'frontend']);
+  return result;
+}
+
+describe('GenerateAuditReportUseCase', () => {
+  describe('execute', () => {
+    it('should generate console report by default', async () => {
+      const useCase = makeSUT();
+      const findings = [
+        new Finding('test.rule1', 'high', 'Violation 1', 'test1.ts', 1, 'backend'),
+        new Finding('test.rule2', 'medium', 'Violation 2', 'test2.ts', 2, 'frontend'),
+      ];
+      const auditResult = createAuditResultWithFindings(findings);
+      const report = await useCase.execute(auditResult, {});
+      expect(report).toContain('AUDIT SUMMARY');
+      expect(report).toContain('Total Violations: 2');
+    });
+
+    it('should generate JSON report when reportType is json', async () => {
+      const useCase = makeSUT();
+      const findings = [new Finding('test.rule', 'high', 'Violation', 'test.ts', 1, 'backend')];
+      const auditResult = createAuditResultWithFindings(findings);
+      const report = await useCase.execute(auditResult, { reportType: 'json' });
+      const parsed = JSON.parse(report);
+      expect(parsed.summary).toBeDefined();
+      expect(parsed.findings).toBeDefined();
+    });
+
+    it('should generate HTML report when reportType is html', async () => {
+      const useCase = makeSUT();
+      const findings = [new Finding('test.rule', 'high', 'Violation', 'test.ts', 1, 'backend')];
+      const auditResult = createAuditResultWithFindings(findings);
+      const report = await useCase.execute(auditResult, { reportType: 'html' });
+      expect(report).toContain('<!DOCTYPE html>');
+      expect(report).toContain('Audit Report');
+    });
+
+    it('should include signature by default', async () => {
+      const useCase = makeSUT();
+      const auditResult = createAuditResultWithFindings([]);
+      const report = await useCase.execute(auditResult, {});
+      expect(report).toContain('PUMUKI TEAM');
+    });
+
+    it('should exclude signature when includeSignature is false', async () => {
+      const useCase = makeSUT();
+      const auditResult = createAuditResultWithFindings([]);
+      const report = await useCase.execute(auditResult, { includeSignature: false });
+      expect(report).not.toContain('PUMUKI TEAM');
+    });
+
+    it('should propagate errors during report generation', async () => {
+      const useCase = makeSUT();
+      const invalidAuditResult = null;
+      await expect(useCase.execute(invalidAuditResult, {})).rejects.toThrow();
+    });
+  });
+
+  describe('generateJSONReport', () => {
+    it('should serialize audit result to JSON', () => {
+      const useCase = makeSUT();
+      const findings = [new Finding('test.rule', 'high', 'Violation', 'test.ts', 1, 'backend')];
+      const auditResult = createAuditResultWithFindings(findings);
+      const json = useCase.generateJSONReport(auditResult);
+      const parsed = JSON.parse(json);
+      expect(parsed.summary.totalViolations).toBe(1);
+      expect(parsed.findings).toHaveLength(1);
+    });
+
+    it('should include all audit result data in JSON', () => {
+      const useCase = makeSUT();
+      const auditResult = createAuditResultWithFindings([]);
+      const json = useCase.generateJSONReport(auditResult);
+      const parsed = JSON.parse(json);
+      expect(parsed.timestamp).toBeDefined();
+      expect(parsed.summary).toBeDefined();
+      expect(parsed.metadata).toBeDefined();
+      expect(parsed.findings).toBeDefined();
+    });
+  });
+
+  describe('generateHTMLReport', () => {
+    it('should generate HTML with summary information', () => {
+      const useCase = makeSUT();
+      const findings = [
+        new Finding('test.rule1', 'critical', 'Critical', 'test1.ts', 1, 'backend'),
+        new Finding('test.rule2', 'high', 'High', 'test2.ts', 2, 'frontend'),
+      ];
+      const auditResult = createAuditResultWithFindings(findings);
+      const html = useCase.generateHTMLReport(auditResult);
+      expect(html).toContain('Total Violations:');
+      expect(html).toMatch(/Total Violations:.*2/);
+      expect(html).toContain('Critical:');
+      expect(html).toContain('<span class="critical">1</span>');
+      expect(html).toContain('High:');
+      expect(html).toContain('<span class="high">1</span>');
+    });
+
+    it('should include technical debt hours in HTML', () => {
+      const useCase = makeSUT();
+      const findings = [new Finding('test.rule', 'high', 'Violation', 'test.ts', 1, 'backend')];
+      const auditResult = createAuditResultWithFindings(findings);
+      const html = useCase.generateHTMLReport(auditResult);
+      expect(html).toContain('Technical Debt:');
+    });
+
+    it('should include maintainability index in HTML', () => {
+      const useCase = makeSUT();
+      const auditResult = createAuditResultWithFindings([]);
+      const html = useCase.generateHTMLReport(auditResult);
+      expect(html).toContain('Maintainability Index:');
+    });
+  });
+
+  describe('generateConsoleReport', () => {
+    it('should include total violations count', () => {
+      const useCase = makeSUT();
+      const findings = [
+        new Finding('test.rule1', 'critical', 'Critical', 'test1.ts', 1, 'backend'),
+        new Finding('test.rule2', 'high', 'High', 'test2.ts', 2, 'frontend'),
+      ];
+      const auditResult = createAuditResultWithFindings(findings);
+      const report = useCase.generateConsoleReport(auditResult, false);
+      expect(report).toContain('Total Violations: 2');
+    });
+
+    it('should include severity breakdown', () => {
+      const useCase = makeSUT();
+      const findings = [
+        new Finding('test.rule1', 'critical', 'Critical', 'test1.ts', 1, 'backend'),
+        new Finding('test.rule2', 'high', 'High', 'test2.ts', 2, 'frontend'),
+        new Finding('test.rule3', 'medium', 'Medium', 'test3.ts', 3, 'ios'),
+        new Finding('test.rule4', 'low', 'Low', 'test4.ts', 4, 'android'),
+      ];
+      const auditResult = createAuditResultWithFindings(findings);
+      const report = useCase.generateConsoleReport(auditResult, false);
+      expect(report).toContain('CRITICAL: 1');
+      expect(report).toMatch(/HIGH:\s+1/);
+      expect(report).toMatch(/MEDIUM:\s+1/);
+      expect(report).toMatch(/LOW:\s+1/);
+    });
+
+    it('should include platform breakdown when violations exist', () => {
+      const useCase = makeSUT();
+      const findings = [
+        new Finding('test.rule1', 'high', 'Violation', 'backend/test.ts', 1, 'backend'),
+        new Finding('test.rule2', 'medium', 'Violation', 'frontend/test.tsx', 2, 'frontend'),
+      ];
+      const auditResult = createAuditResultWithFindings(findings);
+      const report = useCase.generateConsoleReport(auditResult, false);
+      expect(report).toContain('BY PLATFORM');
+    });
+
+    it('should include top violated rules', () => {
+      const useCase = makeSUT();
+      const findings = [
+        new Finding('rule.a', 'high', 'Violation', 'test1.ts', 1, 'backend'),
+        new Finding('rule.a', 'high', 'Violation', 'test2.ts', 2, 'backend'),
+        new Finding('rule.b', 'medium', 'Violation', 'test3.ts', 3, 'frontend'),
+      ];
+      const auditResult = createAuditResultWithFindings(findings);
+      const report = useCase.generateConsoleReport(auditResult, false);
+      expect(report).toContain('TOP VIOLATED RULES');
+    });
+
+    it('should include top violated files', () => {
+      const useCase = makeSUT();
+      const findings = [
+        new Finding('rule.a', 'high', 'Violation', 'test.ts', 1, 'backend'),
+        new Finding('rule.b', 'medium', 'Violation', 'test.ts', 2, 'backend'),
+      ];
+      const auditResult = createAuditResultWithFindings(findings);
+      const report = useCase.generateConsoleReport(auditResult, false);
+      expect(report).toContain('TOP VIOLATED FILES');
+    });
+
+    it('should use outputFormatter signature when available', () => {
+      const mockOutputFormatter = {
+        generateSignature: jest.fn().mockReturnValue('Custom Signature'),
+      };
+      const useCase = makeSUT(mockOutputFormatter);
+      const auditResult = createAuditResultWithFindings([]);
+      const report = useCase.generateConsoleReport(auditResult, true);
+      expect(mockOutputFormatter.generateSignature).toHaveBeenCalled();
+      expect(report).toContain('Custom Signature');
+    });
+
+    it('should use default signature when outputFormatter not available', () => {
+      const useCase = makeSUT();
+      const auditResult = createAuditResultWithFindings([]);
+      const report = useCase.generateConsoleReport(auditResult, true);
+      expect(report).toContain('PUMUKI TEAM');
+    });
+  });
+});
+