pumuki-ast-hooks 5.3.1

package/scripts/hooks-system/infrastructure/ast/common/__tests__/BDDTDDWorkflowRules.spec.js

@@ -0,0 +1,133 @@
+const { BDDTDDWorkflowRules } = require('../BDDTDDWorkflowRules');
+const glob = require('glob');
+const fs = require('fs');
+
+jest.mock('glob');
+jest.mock('fs');
+jest.mock('../../ast-core', () => ({
+  pushFinding: jest.fn(),
+  pushFileFinding: jest.fn()
+}));
+
+const { pushFileFinding } = require('../../ast-core');
+
+describe('BDDTDDWorkflowRules', () => {
+  let rules;
+  let findings;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    findings = [];
+    rules = new BDDTDDWorkflowRules(findings, '/project');
+  });
+
+  describe('checkBDDFeatureFiles', () => {
+    it('should flag project with many implementation files but no features', () => {
+      glob.sync.mockImplementation((pattern) => {
+        if (pattern.includes('.feature')) return [];
+        return Array(60).fill('/project/src/file.ts');
+      });
+
+      rules.checkBDDFeatureFiles();
+
+      expect(pushFileFinding).toHaveBeenCalledWith(
+        'workflow.bdd.missing_feature_files',
+        'critical',
+        expect.any(String),
+        expect.any(Number),
+        expect.any(Number),
+        expect.stringContaining('sin feature files'),
+        findings
+      );
+    });
+
+    it('should flag insufficient feature files', () => {
+      glob.sync.mockImplementation((pattern) => {
+        if (pattern.includes('.feature')) return ['/project/test.feature'];
+        return Array(30).fill('/project/src/file.ts');
+      });
+
+      fs.readFileSync.mockReturnValue('Feature: Test\nScenario: Basic\nGiven something\nWhen action\nThen result');
+
+      rules.checkBDDFeatureFiles();
+
+      expect(pushFileFinding).toHaveBeenCalledWith(
+        'workflow.bdd.insufficient_features',
+        'high',
+        expect.any(String),
+        expect.any(Number),
+        expect.any(Number),
+        expect.stringContaining('feature files'),
+        findings
+      );
+    });
+
+    it('should not flag when feature count is adequate', () => {
+      glob.sync.mockImplementation((pattern) => {
+        if (pattern.includes('.feature')) return Array(5).fill('/project/test.feature');
+        return Array(10).fill('/project/src/file.ts');
+      });
+
+      fs.readFileSync.mockReturnValue('Feature: Test\nScenario: Basic\nGiven something\nWhen action\nThen result');
+
+      rules.checkBDDFeatureFiles();
+
+      expect(pushFileFinding).not.toHaveBeenCalledWith(
+        'workflow.bdd.missing_feature_files',
+        expect.any(String),
+        expect.any(String),
+        expect.any(Number),
+        expect.any(Number),
+        expect.any(String),
+        expect.any(Array)
+      );
+    });
+  });
+
+  describe('checkTDDTestCoverage', () => {
+    it('should check test coverage ratio', () => {
+      glob.sync.mockImplementation((pattern) => {
+        if (pattern.includes('spec') || pattern.includes('test')) return ['/project/test.spec.ts'];
+        if (pattern.includes('.feature')) return [];
+        return Array(5).fill('/project/src/service.ts');
+      });
+
+      rules.checkTDDTestCoverage();
+
+      expect(glob.sync).toHaveBeenCalled();
+    });
+  });
+
+  describe('constructor', () => {
+    it('should initialize with findings array and project root', () => {
+      const testFindings = [];
+      const testRoot = '/test/project';
+
+      const instance = new BDDTDDWorkflowRules(testFindings, testRoot);
+
+      expect(instance.findings).toBe(testFindings);
+      expect(instance.projectRoot).toBe(testRoot);
+    });
+  });
+
+  describe('analyze', () => {
+    it('should call all check methods', () => {
+      glob.sync.mockReturnValue([]);
+      fs.readFileSync.mockReturnValue('');
+
+      const spy1 = jest.spyOn(rules, 'checkBDDFeatureFiles');
+      const spy2 = jest.spyOn(rules, 'checkTDDTestCoverage');
+      const spy3 = jest.spyOn(rules, 'checkImplementationAlignment');
+      const spy4 = jest.spyOn(rules, 'checkWorkflowSequence');
+      const spy5 = jest.spyOn(rules, 'checkFeatureTestImplementationTriad');
+
+      rules.analyze();
+
+      expect(spy1).toHaveBeenCalled();
+      expect(spy2).toHaveBeenCalled();
+      expect(spy3).toHaveBeenCalled();
+      expect(spy4).toHaveBeenCalled();
+      expect(spy5).toHaveBeenCalled();
+    });
+  });
+});

package/scripts/hooks-system/infrastructure/ast/common/__tests__/ast-common.spec.js

@@ -0,0 +1,20 @@
+const { runCommonIntelligence } = require('../ast-common');
+
+describe('AST Common Module', () => {
+  describe('runCommonIntelligence', () => {
+    it('should be a function', () => {
+      expect(typeof runCommonIntelligence).toBe('function');
+    });
+
+    it('should be callable', () => {
+      expect(runCommonIntelligence).toBeDefined();
+    });
+  });
+
+  describe('exports', () => {
+    it('should export runCommonIntelligence', () => {
+      const mod = require('../ast-common');
+      expect(mod.runCommonIntelligence).toBeDefined();
+    });
+  });
+});

package/scripts/hooks-system/infrastructure/ast/common/__tests__/documentation-analyzer.spec.js

@@ -0,0 +1,120 @@
+const { findDuplicateContent, findBrokenLinks } = require('../documentation-analyzer');
+const fs = require('fs');
+const path = require('path');
+
+jest.mock('fs');
+
+describe('documentation-analyzer', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe('findDuplicateContent', () => {
+    it('should detect duplicate content between files', () => {
+      const files = ['/docs/file1.md', '/docs/file2.md'];
+      const commonContent = Array(15).fill('This is a common line that appears in both files').join('\n');
+
+      fs.readFileSync.mockImplementation((file) => {
+        if (file === '/docs/file1.md') return commonContent + '\nUnique line 1';
+        if (file === '/docs/file2.md') return commonContent + '\nUnique line 2';
+        return '';
+      });
+
+      const duplicates = findDuplicateContent(files);
+
+      expect(duplicates.length).toBeGreaterThan(0);
+      expect(duplicates[0].file1).toBe('/docs/file1.md');
+      expect(duplicates[0].file2).toBe('/docs/file2.md');
+    });
+
+    it('should not flag files with low similarity', () => {
+      const files = ['/docs/file1.md', '/docs/file2.md'];
+
+      fs.readFileSync.mockImplementation((file) => {
+        if (file === '/docs/file1.md') return 'Completely different content here\nLine 2\nLine 3';
+        if (file === '/docs/file2.md') return 'Nothing in common at all\nOther line\nMore content';
+        return '';
+      });
+
+      const duplicates = findDuplicateContent(files);
+
+      expect(duplicates).toHaveLength(0);
+    });
+
+    it('should handle empty files', () => {
+      const files = ['/docs/empty1.md', '/docs/empty2.md'];
+
+      fs.readFileSync.mockReturnValue('');
+
+      const duplicates = findDuplicateContent(files);
+
+      expect(duplicates).toHaveLength(0);
+    });
+  });
+
+  describe('findBrokenLinks', () => {
+    it('should detect broken relative links', () => {
+      const content = 'Check [this guide](./non-existent.md) for more info.';
+      const filePath = '/docs/readme.md';
+
+      fs.existsSync.mockReturnValue(false);
+
+      const brokenLinks = findBrokenLinks(content, filePath, '/project');
+
+      expect(brokenLinks).toHaveLength(1);
+      expect(brokenLinks[0].url).toBe('./non-existent.md');
+      expect(brokenLinks[0].type).toBe('relative');
+    });
+
+    it('should not flag valid relative links', () => {
+      const content = 'Check [this guide](./existing.md) for more info.';
+      const filePath = '/docs/readme.md';
+
+      fs.existsSync.mockReturnValue(true);
+
+      const brokenLinks = findBrokenLinks(content, filePath, '/project');
+
+      expect(brokenLinks).toHaveLength(0);
+    });
+
+    it('should skip external http links', () => {
+      const content = 'Visit [Google](https://google.com) for search.';
+      const filePath = '/docs/readme.md';
+
+      const brokenLinks = findBrokenLinks(content, filePath, '/project');
+
+      expect(brokenLinks).toHaveLength(0);
+    });
+
+    it('should skip anchor links', () => {
+      const content = 'Jump to [section](#installation) below.';
+      const filePath = '/docs/readme.md';
+
+      const brokenLinks = findBrokenLinks(content, filePath, '/project');
+
+      expect(brokenLinks).toHaveLength(0);
+    });
+
+    it('should return correct line number for broken link', () => {
+      const content = 'Line 1\nLine 2\n[broken](./missing.md)\nLine 4';
+      const filePath = '/docs/readme.md';
+
+      fs.existsSync.mockReturnValue(false);
+
+      const brokenLinks = findBrokenLinks(content, filePath, '/project');
+
+      expect(brokenLinks[0].line).toBe(3);
+    });
+
+    it('should detect multiple broken links', () => {
+      const content = '[link1](./a.md)\n[link2](./b.md)\n[link3](./c.md)';
+      const filePath = '/docs/readme.md';
+
+      fs.existsSync.mockReturnValue(false);
+
+      const brokenLinks = findBrokenLinks(content, filePath, '/project');
+
+      expect(brokenLinks).toHaveLength(3);
+    });
+  });
+});

package/scripts/hooks-system/infrastructure/ast/common/__tests__/images-backend-analyzer.spec.js

@@ -0,0 +1,123 @@
+const { analyzeImagesBackend } = require('../images-backend-analyzer');
+
+function createMockProject(files) {
+  return {
+    getSourceFiles: () => files.map(f => ({
+      getFilePath: () => f.path,
+      getFullText: () => f.content
+    }))
+  };
+}
+
+describe('images-backend-analyzer', () => {
+  describe('analyzeImagesBackend', () => {
+    it('should detect upload without size validation', () => {
+      const project = createMockProject([{
+        path: '/backend/controllers/upload.controller.ts',
+        content: '@Post("upload") handleUpload(@UploadedFile() file) {}'
+      }]);
+      const findings = [];
+
+      analyzeImagesBackend(project, findings);
+
+      expect(findings).toHaveLength(2);
+      expect(findings[0].ruleId).toBe('backend.images.missing_file_size_limit');
+      expect(findings[0].severity).toBe('HIGH');
+    });
+
+    it('should not flag when size validation present', () => {
+      const project = createMockProject([{
+        path: '/backend/controllers/upload.controller.ts',
+        content: '@Post("upload") multer({ limits: { fileSize: 10485760 } })'
+      }]);
+      const findings = [];
+
+      analyzeImagesBackend(project, findings);
+
+      expect(findings.filter(f => f.ruleId === 'backend.images.missing_file_size_limit')).toHaveLength(0);
+    });
+
+    it('should detect upload without compression', () => {
+      const project = createMockProject([{
+        path: '/backend/services/image.service.ts',
+        content: 'multer({ limits: { maxFileSize: 10000000 } })'
+      }]);
+      const findings = [];
+
+      analyzeImagesBackend(project, findings);
+
+      expect(findings).toHaveLength(1);
+      expect(findings[0].ruleId).toBe('backend.images.missing_server_compression');
+      expect(findings[0].severity).toBe('MEDIUM');
+    });
+
+    it('should not flag when sharp compression present', () => {
+      const project = createMockProject([{
+        path: '/backend/services/image.service.ts',
+        content: `
+          multer({ limits: { maxFileSize: 10000000 } });
+          sharp(buffer).resize(1920).jpeg({ quality: 80 });
+        `
+      }]);
+      const findings = [];
+
+      analyzeImagesBackend(project, findings);
+
+      expect(findings).toHaveLength(0);
+    });
+
+    it('should detect multipart uploads', () => {
+      const project = createMockProject([{
+        path: '/backend/routes/files.ts',
+        content: 'app.post("/files", multipart(), handler)'
+      }]);
+      const findings = [];
+
+      analyzeImagesBackend(project, findings);
+
+      expect(findings.length).toBeGreaterThan(0);
+    });
+
+    it('should accept jimp as compression library', () => {
+      const project = createMockProject([{
+        path: '/backend/services/image.service.ts',
+        content: `
+          multer({ limits: { fileSize: 5000000 } });
+          jimp.read(buffer).then(img => img.resize(800));
+        `
+      }]);
+      const findings = [];
+
+      analyzeImagesBackend(project, findings);
+
+      expect(findings).toHaveLength(0);
+    });
+
+    it('should accept imagemin as compression library', () => {
+      const project = createMockProject([{
+        path: '/backend/services/image.service.ts',
+        content: `
+          multer({ limits: { fileSize: 5000000 } });
+          imagemin([input], { destination: output });
+        `
+      }]);
+      const findings = [];
+
+      analyzeImagesBackend(project, findings);
+
+      expect(findings).toHaveLength(0);
+    });
+
+    it('should not flag non-upload files', () => {
+      const project = createMockProject([{
+        path: '/app/services/user.service.ts',
+        content: 'class UserService { getUsers() { return []; } }'
+      }]);
+      const findings = [];
+
+      analyzeImagesBackend(project, findings);
+
+      expect(findings).toHaveLength(0);
+    });
+  });
+});

package/scripts/hooks-system/infrastructure/ast/common/__tests__/monorepo-health-analyzer.spec.js

@@ -0,0 +1,118 @@
+const {
+  buildDependencyGraph,
+  detectCircularDependencies,
+  calculateBuildComplexity,
+  calculateHealthScore
+} = require('../monorepo-health-analyzer');
+const fs = require('fs');
+
+jest.mock('fs');
+jest.mock('glob');
+
+describe('monorepo-health-analyzer', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe('buildDependencyGraph', () => {
+    it('should build graph from apps with package.json', () => {
+      const apps = [
+        { name: 'frontend', path: '/apps/frontend', packageJsonPath: '/apps/frontend/package.json' },
+        { name: 'backend', path: '/apps/backend', packageJsonPath: '/apps/backend/package.json' }
+      ];
+
+      fs.existsSync.mockReturnValue(true);
+      fs.readFileSync.mockImplementation((file) => {
+        if (file.includes('frontend')) {
+          return JSON.stringify({ dependencies: { '@app/backend': '1.0.0' } });
+        }
+        return JSON.stringify({ dependencies: {} });
+      });
+
+      const graph = buildDependencyGraph(apps);
+
+      expect(graph).toHaveProperty('frontend');
+      expect(graph).toHaveProperty('backend');
+    });
+
+    it('should handle missing package.json', () => {
+      const apps = [
+        { name: 'app1', path: '/apps/app1', packageJsonPath: '/apps/app1/package.json' }
+      ];
+
+      fs.existsSync.mockReturnValue(false);
+
+      const graph = buildDependencyGraph(apps);
+
+      expect(graph.app1).toEqual([]);
+    });
+  });
+
+  describe('detectCircularDependencies', () => {
+    it('should detect circular dependency', () => {
+      const graph = {
+        a: ['b'],
+        b: ['c'],
+        c: ['a']
+      };
+
+      const cycles = detectCircularDependencies(graph);
+
+      expect(cycles.length).toBeGreaterThan(0);
+    });
+
+    it('should return empty for acyclic graph', () => {
+      const graph = {
+        a: ['b'],
+        b: ['c'],
+        c: []
+      };
+
+      const cycles = detectCircularDependencies(graph);
+
+      expect(cycles).toHaveLength(0);
+    });
+
+    it('should handle empty graph', () => {
+      const graph = {};
+
+      const cycles = detectCircularDependencies(graph);
+
+      expect(cycles).toHaveLength(0);
+    });
+  });
+
+  describe('calculateBuildComplexity', () => {
+    it('should be a function', () => {
+      expect(typeof calculateBuildComplexity).toBe('function');
+    });
+  });
+
+  describe('calculateHealthScore', () => {
+    it('should return high score for healthy monorepo', () => {
+      const score = calculateHealthScore(2, 0, 0, 50);
+
+      expect(score).toBeGreaterThanOrEqual(80);
+    });
+
+    it('should penalize excessive apps', () => {
+      const healthyScore = calculateHealthScore(3, 0, 0, 50);
+      const excessiveScore = calculateHealthScore(6, 0, 0, 50);
+
+      expect(excessiveScore).toBeLessThan(healthyScore);
+    });
+
+    it('should penalize circular dependencies', () => {
+      const noCircular = calculateHealthScore(3, 0, 0, 50);
+      const withCircular = calculateHealthScore(3, 2, 0, 50);
+
+      expect(withCircular).toBeLessThan(noCircular);
+    });
+
+    it('should never return negative score', () => {
+      const score = calculateHealthScore(10, 10, 100, 1000);
+
+      expect(score).toBeGreaterThanOrEqual(0);
+    });
+  });
+});

package/scripts/hooks-system/infrastructure/ast/common/__tests__/network-resilience-analyzer.spec.js

@@ -0,0 +1,180 @@
+const { analyzeNetworkResilience } = require('../network-resilience-analyzer');
+
+function createMockProject(files) {
+  return {
+    getSourceFiles: () => files.map(f => ({
+      getFilePath: () => f.path,
+      getFullText: () => f.content
+    }))
+  };
+}
+
+describe('network-resilience-analyzer', () => {
+  describe('retry policy', () => {
+    it('should detect network call without retry', () => {
+      const project = createMockProject([{
+        path: '/app/services/api.service.ts',
+        content: 'async getData() { return fetch("/api/data"); }'
+      }]);
+      const findings = [];
+
+      analyzeNetworkResilience(project, findings);
+
+      expect(findings.some(f => f.ruleId === 'common.network.missing_retry_policy')).toBe(true);
+    });
+
+    it('should not flag when retry present', () => {
+      const project = createMockProject([{
+        path: '/app/services/api.service.ts',
+        content: 'async getData() { return fetchWithRetry("/api/data", { retry: 3 }); }'
+      }]);
+      const findings = [];
+
+      analyzeNetworkResilience(project, findings);
+
+      expect(findings.filter(f => f.ruleId === 'common.network.missing_retry_policy')).toHaveLength(0);
+    });
+
+    it('should skip test files', () => {
+      const project = createMockProject([{
+        path: '/app/services/api.service.ts',
+        content: 'test("should work", () => { fetch("/api/data"); })'
+      }]);
+      const findings = [];
+
+      analyzeNetworkResilience(project, findings);
+
+      expect(findings.filter(f => f.ruleId === 'common.network.missing_retry_policy')).toHaveLength(0);
+    });
+  });
+
+  describe('timeout configuration', () => {
+    it('should detect network call without timeout', () => {
+      const project = createMockProject([{
+        path: '/app/services/api.service.ts',
+        content: 'axios.get("/api/data")'
+      }]);
+      const findings = [];
+
+      analyzeNetworkResilience(project, findings);
+
+      expect(findings.some(f => f.ruleId === 'common.network.missing_timeout')).toBe(true);
+    });
+
+    it('should not flag when timeout present', () => {
+      const project = createMockProject([{
+        path: '/app/services/api.service.ts',
+        content: 'axios.get("/api/data", { timeout: 30000 })'
+      }]);
+      const findings = [];
+
+      analyzeNetworkResilience(project, findings);
+
+      expect(findings.filter(f => f.ruleId === 'common.network.missing_timeout')).toHaveLength(0);
+    });
+  });
+
+  describe('circuit breaker', () => {
+    it('should detect multiple retries without circuit breaker', () => {
+      const project = createMockProject([{
+        path: '/app/services/api.service.ts',
+        content: 'retry retry retry retry fetch("/api")'
+      }]);
+      const findings = [];
+
+      analyzeNetworkResilience(project, findings);
+
+      expect(findings.some(f => f.ruleId === 'common.network.missing_circuit_breaker')).toBe(true);
+    });
+
+    it('should not flag when circuit breaker present', () => {
+      const project = createMockProject([{
+        path: '/app/services/api.service.ts',
+        content: 'retry retry retry retry circuitBreaker()'
+      }]);
+      const findings = [];
+
+      analyzeNetworkResilience(project, findings);
+
+      expect(findings.filter(f => f.ruleId === 'common.network.missing_circuit_breaker')).toHaveLength(0);
+    });
+  });
+
+  describe('request queue', () => {
+    it('should detect offline context without queue', () => {
+      const project = createMockProject([{
+        path: '/app/services/offline.service.ts',
+        content: 'if (offline) { fetch("/api/data"); }'
+      }]);
+      const findings = [];
+
+      analyzeNetworkResilience(project, findings);
+
+      expect(findings.some(f => f.ruleId === 'common.network.missing_request_queue')).toBe(true);
+    });
+
+    it('should not flag when queue present', () => {
+      const project = createMockProject([{
+        path: '/app/services/offline.service.ts',
+        content: 'if (offline) { OfflineQueue.add(fetch("/api")); }'
+      }]);
+      const findings = [];
+
+      analyzeNetworkResilience(project, findings);
+
+      expect(findings.filter(f => f.ruleId === 'common.network.missing_request_queue')).toHaveLength(0);
+    });
+  });
+
+  describe('error handling', () => {
+    it('should detect network call without error handling', () => {
+      const project = createMockProject([{
+        path: '/app/services/api.service.ts',
+        content: 'function get() { axios.get("/api"); }'
+      }]);
+      const findings = [];
+
+      analyzeNetworkResilience(project, findings);
+
+      expect(findings.some(f => f.ruleId === 'common.network.missing_error_handling')).toBe(true);
+    });
+
+    it('should not flag when try-catch present', () => {
+      const project = createMockProject([{
+        path: '/app/services/api.service.ts',
+        content: 'try { axios.get("/api"); } catch(e) { handle(e); }'
+      }]);
+      const findings = [];
+
+      analyzeNetworkResilience(project, findings);
+
+      expect(findings.filter(f => f.ruleId === 'common.network.missing_error_handling')).toHaveLength(0);
+    });
+  });
+
+  describe('connection pooling', () => {
+    it('should detect HTTP client without pooling', () => {
+      const project = createMockProject([{
+        path: '/app/services/http.client.ts',
+        content: 'class ApiClient { }'
+      }]);
+      const findings = [];
+
+      analyzeNetworkResilience(project, findings);
+
+      expect(findings.some(f => f.ruleId === 'common.network.missing_connection_pooling')).toBe(true);
+    });
+
+    it('should not flag when HttpAgent configured', () => {
+      const project = createMockProject([{
+        path: '/app/services/http.client.ts',
+        content: 'class ApiClient { agent = new HttpAgent({ keepAlive: true }); }'
+      }]);
+      const findings = [];
+
+      analyzeNetworkResilience(project, findings);
+
+      expect(findings.filter(f => f.ruleId === 'common.network.missing_connection_pooling')).toHaveLength(0);
+    });
+  });
+});