pumuki-ast-hooks 5.3.1

package/scripts/hooks-system/infrastructure/ast/android/__tests__/feature-first-analyzer.spec.js

@@ -0,0 +1,80 @@
+const { analyzeFeatureFirst } = require('../feature-first-analyzer');
+
+describe('Android Feature-First Analyzer', () => {
+  let findings;
+  let pushFileFinding;
+
+  beforeEach(() => {
+    findings = [];
+    pushFileFinding = jest.fn((code, level, path, line, col, msg, arr) => {
+      arr.push({ code, level, path, line, col, msg });
+    });
+  });
+
+  describe('analyzeFeatureFirst', () => {
+    it('should be a function', () => {
+      expect(typeof analyzeFeatureFirst).toBe('function');
+    });
+
+    it('should not throw for valid input', () => {
+      expect(() => analyzeFeatureFirst('/app/test.kt', 'class Test', findings, pushFileFinding)).not.toThrow();
+    });
+  });
+
+  describe('Cross-Feature Imports', () => {
+    it('should detect cross-feature import', () => {
+      const content = 'import com.ruralgo.feature.users.domain.User\nclass OrderViewModel';
+      analyzeFeatureFirst('/app/feature/orders/OrderViewModel.kt', content, findings, pushFileFinding);
+      expect(pushFileFinding).toHaveBeenCalledWith(
+        'android.feature.cross_feature_import',
+        expect.any(String),
+        expect.any(String),
+        expect.any(Number),
+        expect.any(Number),
+        expect.any(String),
+        findings
+      );
+    });
+
+    it('should allow core module imports', () => {
+      const content = 'import com.ruralgo.core.network.ApiClient\nclass OrderRepository';
+      analyzeFeatureFirst('/app/feature/orders/OrderRepository.kt', content, findings, pushFileFinding);
+      const violations = findings.filter(f => f.code === 'android.feature.cross_feature_import');
+      expect(violations.length).toBe(0);
+    });
+
+    it('should allow same-feature imports', () => {
+      const content = 'import com.ruralgo.feature.orders.domain.Order\nclass OrderViewModel';
+      analyzeFeatureFirst('/app/feature/orders/OrderViewModel.kt', content, findings, pushFileFinding);
+      const violations = findings.filter(f => f.code === 'android.feature.cross_feature_import');
+      expect(violations.length).toBe(0);
+    });
+  });
+
+  describe('Feature Detection', () => {
+    it('should detect orders feature', () => {
+      const content = 'class OrderList';
+      analyzeFeatureFirst('/app/feature/orders/OrderList.kt', content, findings, pushFileFinding);
+      expect(true).toBe(true);
+    });
+
+    it('should detect users feature', () => {
+      const content = 'class UserProfile';
+      analyzeFeatureFirst('/app/feature/users/UserProfile.kt', content, findings, pushFileFinding);
+      expect(true).toBe(true);
+    });
+
+    it('should ignore non-feature files', () => {
+      const content = 'import com.ruralgo.feature.users.User\nclass AppModule';
+      analyzeFeatureFirst('/app/di/AppModule.kt', content, findings, pushFileFinding);
+      expect(pushFileFinding).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('exports', () => {
+    it('should export analyzeFeatureFirst', () => {
+      const mod = require('../feature-first-analyzer');
+      expect(mod.analyzeFeatureFirst).toBeDefined();
+    });
+  });
+});

package/scripts/hooks-system/infrastructure/ast/android/__tests__/native-bridge.spec.js

@@ -0,0 +1,31 @@
+const { runDetektNative } = require('../native-bridge');
+
+describe('Native Bridge', () => {
+  describe('runDetektNative', () => {
+    it('should be a function', () => {
+      expect(typeof runDetektNative).toBe('function');
+    });
+
+    it('should return a promise', () => {
+      const result = runDetektNative([]);
+      expect(result).toBeInstanceOf(Promise);
+    });
+
+    it('should not throw for empty findings array', async () => {
+      await expect(runDetektNative([])).resolves.not.toThrow();
+    });
+
+    it('should handle missing custom-rules gracefully', async () => {
+      const findings = [];
+      await runDetektNative(findings);
+      expect(true).toBe(true);
+    });
+  });
+
+  describe('exports', () => {
+    it('should export runDetektNative', () => {
+      const mod = require('../native-bridge');
+      expect(mod.runDetektNative).toBeDefined();
+    });
+  });
+});

package/scripts/hooks-system/infrastructure/ast/android/analyzers/AndroidASTIntelligentAnalyzer.js

@@ -0,0 +1,15 @@
+
+const { AndroidAnalysisOrchestrator } = require('./AndroidAnalysisOrchestrator');
+
+class AndroidASTIntelligentAnalyzer {
+    constructor(findings) {
+        this.findings = findings;
+        this.orchestrator = new AndroidAnalysisOrchestrator(findings);
+    }
+
+    analyzeFile(filePath) {
+        this.orchestrator.analyzeFile(filePath);
+    }
+}
+
+module.exports = { AndroidASTIntelligentAnalyzer };

package/scripts/hooks-system/infrastructure/ast/android/analyzers/AndroidASTParser.js

@@ -0,0 +1,157 @@
+const fs = require('fs');
+
+class AndroidASTParser {
+    constructor(filePath) {
+        this.filePath = filePath;
+        this.content = '';
+        this.lines = [];
+        this.imports = [];
+        this.classes = [];
+        this.functions = [];
+        this.annotations = [];
+    }
+
+    parse() {
+        if (!this.filePath.endsWith('.kt') && !this.filePath.endsWith('.kts')) {
+            return false;
+        }
+
+        try {
+            this.content = fs.readFileSync(this.filePath, 'utf8');
+            this.lines = this.content.split('\n');
+            this.extractImports();
+            this.classes = this.extractClasses();
+            this.functions = this.extractTopLevelFunctions();
+            this.annotations = this.extractAnnotations();
+            return true;
+        } catch (error) {
+            return false;
+        }
+    }
+
+    extractImports() {
+        this.imports = [];
+        const importRegex = /^import\s+(.+)$/gm;
+        let match;
+        while ((match = importRegex.exec(this.content)) !== null) {
+            const line = this.content.substring(0, match.index).split('\n').length;
+            this.imports.push({ name: match[1].trim(), line });
+        }
+    }
+
+    extractClasses() {
+        const classes = [];
+        const classRegex = /^(\s*)(data\s+|sealed\s+|abstract\s+|open\s+)?class\s+(\w+)(?:<[^>]+>)?\s*(?:\(([^)]*)\))?\s*(?::\s*([^{]+))?\s*\{?/gm;
+
+        let match;
+        while ((match = classRegex.exec(this.content)) !== null) {
+            const lineNum = this.content.substring(0, match.index).split('\n').length;
+            const body = this.extractBody(this.content, match.index);
+            const methods = this.extractMethods(body);
+            const properties = this.extractProperties(body);
+
+            classes.push({
+                name: match[3],
+                line: lineNum,
+                modifier: (match[2] || '').trim(),
+                constructor: match[4] || '',
+                inheritance: match[5] || '',
+                methods,
+                properties,
+                bodyLength: body.split('\n').length,
+                body,
+            });
+        }
+        return classes;
+    }
+
+    extractBody(content, startIndex) {
+        let braceCount = 0;
+        let started = false;
+        let body = '';
+
+        for (let i = startIndex; i < content.length; i++) {
+            if (content[i] === '{') { braceCount++; started = true; }
+            else if (content[i] === '}') braceCount--;
+            if (started) body += content[i];
+            if (started && braceCount === 0) break;
+        }
+        return body;
+    }
+
+    extractMethods(body) {
+        const methods = [];
+        const funcRegex = /(?:override\s+)?(?:suspend\s+)?(?:private\s+|internal\s+|protected\s+)?fun\s+(\w+)\s*(?:<[^>]+>)?\s*\(([^)]*)\)(?:\s*:\s*([^\s{=]+))?/g;
+
+        let match;
+        while ((match = funcRegex.exec(body)) !== null) {
+            const funcBody = this.extractBody(body, match.index);
+            methods.push({
+                name: match[1],
+                params: match[2],
+                returnType: match[3] || 'Unit',
+                bodyLength: funcBody.split('\n').length,
+                body: funcBody,
+                isSuspend: body.substring(Math.max(0, match.index - 20), match.index).includes('suspend'),
+            });
+        }
+        return methods;
+    }
+
+    extractProperties(body) {
+        const properties = [];
+        const propRegex = /(?:private\s+|protected\s+|internal\s+|public\s+)?(?:val|var)\s+(\w+)\s*(?::\s*([^\s=]+))?/g;
+
+        let match;
+        while ((match = propRegex.exec(body)) !== null) {
+            properties.push({ name: match[1], type: match[2] || 'inferred' });
+        }
+        return properties;
+    }
+
+    extractTopLevelFunctions() {
+        const functions = [];
+        const funcRegex = /^(?:private\s+|internal\s+)?(?:suspend\s+)?fun\s+(\w+)/gm;
+
+        let match;
+        while ((match = funcRegex.exec(this.content)) !== null) {
+            const lineNum = this.content.substring(0, match.index).split('\n').length;
+            const funcBody = this.extractBody(this.content, match.index);
+            functions.push({
+                name: match[1],
+                line: lineNum,
+                bodyLength: funcBody.split('\n').length,
+                body: funcBody,
+            });
+        }
+        return functions;
+    }
+
+    extractAnnotations() {
+        const annotations = [];
+        const annoRegex = /@(\w+)(?:\([^)]*\))?/g;
+
+        let match;
+        while ((match = annoRegex.exec(this.content)) !== null) {
+            const line = this.content.substring(0, match.index).split('\n').length;
+            annotations.push({ name: match[1], line });
+        }
+        return annotations;
+    }
+
+    findLine(text) {
+        const idx = this.content.indexOf(text);
+        if (idx === -1) return 1;
+        return this.content.substring(0, idx).split('\n').length;
+    }
+
+    calculateComplexity(body) {
+        let complexity = 1;
+        const patterns = [/\bif\s*\(/g, /\belse\s+if\s*\(/g, /\bwhen\s*\(/g, /\bfor\s*\(/g, /\bwhile\s*\(/g, /\bcatch\s*\(/g, /\?\./g, /\?:/g, /&&/g, /\|\|/g];
+        for (const p of patterns) complexity += (body.match(p) || []).length;
+        return complexity;
+    }
+}
+
+module.exports = { AndroidASTParser };
+

package/scripts/hooks-system/infrastructure/ast/android/analyzers/AndroidAnalysisOrchestrator.js

@@ -0,0 +1,164 @@
+const { AndroidASTParser } = require('./AndroidASTParser');
+const { AndroidClassAnalyzer } = require('./AndroidClassAnalyzer');
+const fs = require('fs');
+
+class AndroidAnalysisOrchestrator {
+    constructor(findings) {
+        this.findings = findings;
+        this.godClassCandidates = [];
+        this.godClassBaseline = null;
+    }
+
+    buildGodClassBaselineIfNeeded() {
+        if (this.godClassBaseline || !this.godClassCandidates || this.godClassCandidates.length < 10) return;
+
+        const quantile = (values, p) => {
+            if (!values || values.length === 0) return 0;
+            const sorted = [...values].filter((v) => Number.isFinite(v)).sort((a, b) => a - b);
+            if (sorted.length === 0) return 0;
+            const idx = Math.max(0, Math.min(sorted.length - 1, Math.ceil((p / 100) * sorted.length) - 1));
+            return sorted[idx];
+        };
+
+        const median = (values) => {
+            if (!values || values.length === 0) return 0;
+            const sorted = [...values].filter((v) => Number.isFinite(v)).sort((a, b) => a - b);
+            if (sorted.length === 0) return 0;
+            const mid = Math.floor(sorted.length / 2);
+            if (sorted.length % 2 === 0) return (sorted[mid - 1] + sorted[mid]) / 2;
+            return sorted[mid];
+        };
+
+        const mad = (values) => {
+            const med = median(values);
+            const deviations = (values || []).map((v) => Math.abs(v - med));
+            return median(deviations);
+        };
+
+        const robustZ = (x, med, madValue) => {
+            if (!Number.isFinite(x) || !Number.isFinite(med) || !Number.isFinite(madValue) || madValue === 0) return 0;
+            return 0.6745 * (x - med) / madValue;
+        };
+
+        const pOutlier = Number(process.env.AST_GODCLASS_P_OUTLIER || 90);
+        const pExtreme = Number(process.env.AST_GODCLASS_P_EXTREME || 97);
+
+        const methods = this.godClassCandidates.map(c => c.methodsCount);
+        const props = this.godClassCandidates.map(c => c.propertiesCount);
+        const bodies = this.godClassCandidates.map(c => c.bodyLength);
+        const complexities = this.godClassCandidates.map(c => c.complexity);
+
+        const med = {
+            methodsCount: median(methods),
+            propertiesCount: median(props),
+            bodyLength: median(bodies),
+            complexity: median(complexities),
+        };
+        const madValue = {
+            methodsCount: mad(methods),
+            propertiesCount: mad(props),
+            bodyLength: mad(bodies),
+            complexity: mad(complexities),
+        };
+
+        const z = {
+            methodsCount: methods.map(v => robustZ(v, med.methodsCount, madValue.methodsCount)),
+            propertiesCount: props.map(v => robustZ(v, med.propertiesCount, madValue.propertiesCount)),
+            bodyLength: bodies.map(v => robustZ(v, med.bodyLength, madValue.bodyLength)),
+            complexity: complexities.map(v => robustZ(v, med.complexity, madValue.complexity)),
+        };
+
+        this.godClassBaseline = {
+            thresholds: {
+                outlier: {
+                    methodsCountZ: quantile(z.methodsCount, pOutlier),
+                    propertiesCountZ: quantile(z.propertiesCount, pOutlier),
+                    bodyLengthZ: quantile(z.bodyLength, pOutlier),
+                    complexityZ: quantile(z.complexity, pOutlier),
+                },
+                extreme: {
+                    methodsCountZ: quantile(z.methodsCount, pExtreme),
+                    propertiesCountZ: quantile(z.propertiesCount, pExtreme),
+                    bodyLengthZ: quantile(z.bodyLength, pExtreme),
+                    complexityZ: quantile(z.complexity, pExtreme),
+                },
+            },
+            med,
+            mad: madValue,
+            robustZ,
+        };
+    }
+
+    pushFinding(ruleId, severity, line, message) {
+        this.findings.push({
+            ruleId,
+            severity: severity.toUpperCase(),
+            filePath: this.filePath,
+            line,
+            column: 1,
+            message,
+        });
+    }
+
+    findLine(text) {
+        const idx = this.content.indexOf(text);
+        if (idx === -1) return 1;
+        return this.content.substring(0, idx).split('\n').length;
+    }
+
+    analyzeFile(filePath) {
+        if (!filePath.endsWith('.kt') && !filePath.endsWith('.kts')) {
+            return;
+        }
+
+        try {
+            this.content = fs.readFileSync(filePath, 'utf8');
+            this.lines = this.content.split('\n');
+            this.filePath = filePath;
+
+            const parser = new AndroidASTParser(filePath);
+            if (!parser.parse()) {
+                return;
+            }
+
+            this.imports = parser.imports;
+            this.classes = parser.classes;
+            this.functions = parser.functions;
+            this.annotations = parser.annotations;
+
+            for (const cls of this.classes || []) {
+                if (!cls || !cls.name || /Spec$|Test$|Mock/.test(cls.name)) continue;
+                const complexity = parser.calculateComplexity(cls.body || '');
+                this.godClassCandidates.push({
+                    methodsCount: (cls.methods || []).length,
+                    propertiesCount: (cls.properties || []).length,
+                    bodyLength: cls.bodyLength || 0,
+                    complexity,
+                });
+            }
+
+            this.buildGodClassBaselineIfNeeded();
+
+            const classAnalyzer = new AndroidClassAnalyzer(parser, this.findings, this.godClassBaseline);
+            classAnalyzer.analyze();
+
+            this.analyzeCompose();
+            this.analyzeCoroutines();
+            this.analyzeFlow();
+            this.analyzeHilt();
+            this.analyzeRoom();
+            this.analyzeSecurity();
+            this.analyzeCleanArchitecture();
+            this.analyzeAntiPatterns();
+            this.analyzeNullSafety();
+            this.analyzeImportsRules();
+            this.analyzeAdditionalRules();
+        } catch (error) {
+            if (process.env.DEBUG) {
+                console.debug(`[AndroidAnalysisOrchestrator] Error analyzing ${filePath}: ${error.message}`);
+            }
+        }
+    }
+}
+
+module.exports = { AndroidAnalysisOrchestrator };