pumuki-ast-hooks 5.3.1

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

@@ -0,0 +1,334 @@
+const fs = require('fs');
+const path = require('path');
+const glob = require('glob');
+
+class AndroidArchitectureDetector {
+  constructor(projectRoot) {
+    this.projectRoot = projectRoot;
+    this.patterns = {
+      featureFirstClean: 0,  // Feature-First + DDD + Clean Architecture
+      mvvm: 0,
+      mvi: 0,
+      mvp: 0,
+      cleanArchitecture: 0,
+      mvc: 0
+    };
+    this.manualConfig = this.loadManualConfig();
+  }
+
+  loadManualConfig() {
+    try {
+      const configPath = path.join(this.projectRoot, '.ast-architecture.json');
+      if (fs.existsSync(configPath)) {
+        const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+        console.log('[Android Architecture] Manual configuration loaded from .ast-architecture.json');
+        return config.android || null;
+      }
+    } catch (error) {
+      console.warn('[Android Architecture] Error loading .ast-architecture.json:', error.message);
+    }
+    return null;
+  }
+
+  detect() {
+    if (this.manualConfig && this.manualConfig.architecturePattern) {
+      const manualPattern = this.manualConfig.architecturePattern;
+      console.log(`[Android Architecture] Using manual configuration: ${manualPattern}`);
+      return manualPattern;
+    }
+
+    const kotlinFiles = glob.sync('**/*.kt', {
+      cwd: this.projectRoot,
+      ignore: ['**/build/**', '**/.gradle/**', '**/node_modules/**']
+    });
+
+    if (kotlinFiles.length === 0) {
+      return 'UNKNOWN';
+    }
+
+    this.detectFeatureFirstClean(kotlinFiles);
+
+    this.detectMVVM(kotlinFiles);
+    this.detectMVI(kotlinFiles);
+    this.detectMVP(kotlinFiles);
+    this.detectCleanArchitecture(kotlinFiles);
+    this.detectMVC(kotlinFiles);
+
+    return this.getDominantPattern();
+  }
+
+  detectFeatureFirstClean(files) {
+    const hasFeaturesFolders = files.some(f =>
+      /\/features?\/\w+\/(domain|data|presentation)\//.test(f)
+    );
+
+    const cleanArchFolders = ['domain', 'data', 'presentation'];
+    const foundCleanFolders = cleanArchFolders.filter(folder => {
+      return files.some(f => f.includes(`/${folder}/`));
+    });
+
+    const dddConcepts = files.filter(f =>
+      f.includes('/entities/') ||
+      f.includes('/usecases/') ||
+      f.includes('/repositories/') ||
+      f.includes('Entity.kt') ||
+      f.includes('UseCase.kt') ||
+      f.includes('Repository.kt')
+    );
+
+    if (hasFeaturesFolders) {
+      this.patterns.featureFirstClean += 10;
+    }
+
+    if (foundCleanFolders.length >= 3) {
+      this.patterns.featureFirstClean += foundCleanFolders.length * 3;
+    }
+
+    if (dddConcepts.length > 0) {
+      this.patterns.featureFirstClean += dddConcepts.length * 2;
+    }
+
+    const featureNames = new Set();
+    files.forEach(f => {
+      const match = f.match(/\/features?\/(\w+)\//);
+      if (match) {
+        featureNames.add(match[1]);
+      }
+    });
+
+    if (featureNames.size >= 2) {
+      this.patterns.featureFirstClean += featureNames.size * 4;
+    }
+
+    files.forEach(file => {
+      const content = this.readFile(file);
+
+      if (content.includes('data class ') && (content.includes('VO') || content.includes('ValueObject'))) {
+        this.patterns.featureFirstClean += 2;
+      }
+
+      if (file.includes('Entity.kt') && content.includes('fun ')) {
+        this.patterns.featureFirstClean += 2;
+      }
+
+      if (file.includes('/domain/') && content.includes('interface ') && content.includes('Repository')) {
+        this.patterns.featureFirstClean += 3;
+      }
+
+      if (file.includes('/usecases/') || (file.includes('/domain/') && content.includes('UseCase'))) {
+        this.patterns.featureFirstClean += 2;
+      }
+    });
+
+    console.log(`[Architecture Detection] Feature-First + Clean + DDD score: ${this.patterns.featureFirstClean}`);
+  }
+
+  detectMVVM(files) {
+    const mvvmIndicators = [
+      'class.*ViewModel',
+      'androidx.lifecycle.ViewModel',
+      'LiveData',
+      'StateFlow',
+      'SharedFlow',
+      'MutableLiveData',
+      'MutableStateFlow'
+    ];
+
+    files.forEach(file => {
+      const content = this.readFile(file);
+      const matches = mvvmIndicators.filter(indicator =>
+        new RegExp(indicator).test(content)
+      ).length;
+
+      if (matches >= 2) {
+        this.patterns.mvvm += matches;
+      }
+    });
+
+    const viewModelFiles = files.filter(f =>
+      /ViewModel\.kt$/i.test(f)
+    );
+
+    if (viewModelFiles.length > 0) {
+      this.patterns.mvvm += viewModelFiles.length * 3;
+    }
+  }
+
+  detectMVI(files) {
+    const mviIndicators = [
+      'sealed class.*State',
+      'sealed class.*Intent',
+      'sealed class.*Effect',
+      'sealed interface.*State',
+      'sealed interface.*Intent',
+      'fun handleIntent',
+      'fun processIntent'
+    ];
+
+    files.forEach(file => {
+      const content = this.readFile(file);
+      const matches = mviIndicators.filter(indicator =>
+        new RegExp(indicator).test(content)
+      ).length;
+
+      if (matches >= 3) {
+        this.patterns.mvi += matches * 2;
+      }
+    });
+
+    const mviFiles = files.filter(f =>
+      /(State|Intent|Effect)\.kt$/i.test(f) && f.includes('/ui/')
+    );
+
+    if (mviFiles.length >= 2) {
+      this.patterns.mvi += mviFiles.length * 3;
+    }
+  }
+
+  detectMVP(files) {
+    const mvpIndicators = [
+      'class.*Presenter',
+      'interface.*View',
+      'interface.*Contract',
+      'class.*Contract'
+    ];
+
+    files.forEach(file => {
+      const content = this.readFile(file);
+      const matches = mvpIndicators.filter(indicator =>
+        new RegExp(indicator).test(content)
+      ).length;
+
+      if (matches >= 2) {
+        this.patterns.mvp += matches;
+      }
+    });
+
+    const presenterFiles = files.filter(f =>
+      /Presenter\.kt$/i.test(f)
+    );
+
+    if (presenterFiles.length > 0) {
+      this.patterns.mvp += presenterFiles.length * 3;
+    }
+
+    const contractFiles = files.filter(f =>
+      /Contract\.kt$/i.test(f)
+    );
+
+    if (contractFiles.length > 0) {
+      this.patterns.mvp += contractFiles.length * 2;
+    }
+  }
+
+  detectCleanArchitecture(files) {
+    const hasDomain = files.some(f => f.includes('/domain/'));
+    const hasData = files.some(f => f.includes('/data/'));
+    const hasPresentation = files.some(f => f.includes('/presentation/') || f.includes('/ui/'));
+
+    if (hasDomain && hasData && hasPresentation) {
+      this.patterns.cleanArchitecture += 10;
+    }
+
+    const domainRepos = files.filter(f => 
+      f.includes('/domain/') && f.includes('Repository') && fs.readFileSync(path.join(this.projectRoot, f), 'utf-8').includes('interface ')
+    );
+    const dataRepos = files.filter(f => 
+      f.includes('/data/') && f.includes('Repository') && fs.readFileSync(path.join(this.projectRoot, f), 'utf-8').includes('class ')
+    );
+
+    if (domainRepos.length > 0 && dataRepos.length > 0) {
+      this.patterns.cleanArchitecture += (domainRepos.length + dataRepos.length) * 2;
+    }
+
+    const useCases = files.filter(f =>
+      f.includes('/usecases/') || f.includes('UseCase.kt')
+    );
+
+    if (useCases.length > 0) {
+      this.patterns.cleanArchitecture += useCases.length * 2;
+    }
+  }
+
+  detectMVC(files) {
+    files.forEach(file => {
+      const content = this.readFile(file);
+      
+      if ((file.includes('Activity.kt') || file.includes('Fragment.kt')) &&
+          (content.includes('RoomDatabase') || content.includes('SQLiteDatabase'))) {
+        this.patterns.mvc += 3;
+      }
+
+      if ((file.includes('Activity.kt') || file.includes('Fragment.kt')) &&
+          content.match(/fun\s+(calculate|process|validate|transform)/)) {
+        this.patterns.mvc += 2;
+      }
+    });
+  }
+
+  readFile(relativePath) {
+    try {
+      const fullPath = path.join(this.projectRoot, relativePath);
+      return fs.readFileSync(fullPath, 'utf-8');
+    } catch (err) {
+      return '';
+    }
+  }
+
+  getDominantPattern() {
+    const scores = Object.entries(this.patterns);
+    scores.sort((a, b) => b[1] - a[1]);
+
+    const [dominantName, dominantScore] = scores[0];
+
+    if (dominantScore === 0) {
+      return 'UNKNOWN';
+    }
+
+    const patternMap = {
+      featureFirstClean: 'FEATURE_FIRST_CLEAN_DDD',
+      mvvm: 'MVVM',
+      mvi: 'MVI',
+      mvp: 'MVP',
+      cleanArchitecture: 'CLEAN_ARCHITECTURE',
+      mvc: 'MVC'
+    };
+
+    return patternMap[dominantName] || 'UNKNOWN';
+  }
+
+  getDetectionSummary() {
+    const totalScore = Object.values(this.patterns).reduce((a, b) => a + b, 0);
+    const dominantPattern = this.getDominantPattern();
+    const dominantScore = Math.max(...Object.values(this.patterns));
+
+    const confidence = totalScore > 0 ? Math.round((dominantScore / totalScore) * 100) : 0;
+    const warnings = [];
+
+    if (dominantPattern === 'UNKNOWN') {
+      warnings.push({
+        severity: 'HIGH',
+        message: 'Could not detect a clear architectural pattern in the Android project.',
+        recommendation: 'Define project architecture before continuing. Options: MVVM, MVI, MVP, Clean Architecture, or Feature-First + Clean + DDD.'
+      });
+    }
+
+    if (this.patterns.mvc > 0 && dominantPattern !== 'MVC') {
+      warnings.push({
+        severity: 'MEDIUM',
+        message: 'MVC anti-pattern detected. Consider migrating to MVVM, MVI, or MVP.',
+        recommendation: 'Refactor Activities/Fragments to use ViewModels and separate business logic.'
+      });
+    }
+
+    return {
+      pattern: dominantPattern,
+      confidence,
+      scores: { ...this.patterns },
+      warnings
+    };
+  }
+}
+
+module.exports = { AndroidArchitectureDetector };
+

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

@@ -0,0 +1,162 @@
+class AndroidClassAnalyzer {
+    constructor(parser, findings, godClassBaseline = null) {
+        this.parser = parser;
+        this.findings = findings;
+        this.godClassBaseline = godClassBaseline;
+    }
+
+    analyze() {
+        const filePath = this.parser.filePath;
+        if (/infrastructure\/ast\/|analyzers\/|detectors\//.test(filePath)) {
+            return;
+        }
+
+        for (const cls of this.parser.classes) {
+            this.checkGodClass(cls);
+            this.checkMassiveViewModel(cls);
+            this.checkGodNaming(cls);
+            this.checkUnusedProperties(cls);
+            this.checkConcreteDependencies(cls);
+            this.checkFatInterface(cls);
+            this.checkLongFunctions(cls);
+            this.checkRepositoryPattern(cls);
+            this.checkUseCasePattern(cls);
+        }
+    }
+
+    checkGodClass(cls) {
+        if (!this.godClassBaseline) {
+            if (cls.methods.length > 15 || cls.properties.length > 10 || cls.bodyLength > 300) {
+                this.pushFinding('android.solid.srp.god_class', 'critical', cls.line,
+                    `God class '${cls.name}': ${cls.methods.length} methods, ${cls.properties.length} props - VIOLATES SRP`);
+            }
+            return;
+        }
+
+        const methodsCount = cls.methods.length;
+        const propertiesCount = cls.properties.length;
+        const bodyLength = cls.bodyLength;
+        const complexity = this.parser.calculateComplexity(cls.body);
+
+        const methodsZ = this.godClassBaseline.robustZ(methodsCount, this.godClassBaseline.med.methodsCount, this.godClassBaseline.mad.methodsCount);
+        const propsZ = this.godClassBaseline.robustZ(propertiesCount, this.godClassBaseline.med.propertiesCount, this.godClassBaseline.mad.propertiesCount);
+        const bodyZ = this.godClassBaseline.robustZ(bodyLength, this.godClassBaseline.med.bodyLength, this.godClassBaseline.mad.bodyLength);
+        const complexityZ = this.godClassBaseline.robustZ(complexity, this.godClassBaseline.med.complexity, this.godClassBaseline.mad.complexity);
+
+        const sizeOutlier =
+            (methodsZ > 0 && methodsZ >= this.godClassBaseline.thresholds.outlier.methodsCountZ) ||
+            (propsZ > 0 && propsZ >= this.godClassBaseline.thresholds.outlier.propertiesCountZ) ||
+            (bodyZ > 0 && bodyZ >= this.godClassBaseline.thresholds.outlier.bodyLengthZ);
+        const complexityOutlier = complexityZ > 0 && complexityZ >= this.godClassBaseline.thresholds.outlier.complexityZ;
+
+        const extremeOutlier =
+            (methodsZ > 0 && methodsZ >= this.godClassBaseline.thresholds.extreme.methodsCountZ) ||
+            (propsZ > 0 && propsZ >= this.godClassBaseline.thresholds.extreme.propertiesCountZ) ||
+            (bodyZ > 0 && bodyZ >= this.godClassBaseline.thresholds.extreme.bodyLengthZ) ||
+            (complexityZ > 0 && complexityZ >= this.godClassBaseline.thresholds.extreme.complexityZ);
+
+        const signalCount = [sizeOutlier, complexityOutlier].filter(Boolean).length;
+
+        if (extremeOutlier || signalCount >= 2) {
+            this.pushFinding('android.solid.srp.god_class', 'critical', cls.line,
+                `God class '${cls.name}': ${methodsCount} methods (z=${methodsZ.toFixed(2)}), ${propertiesCount} props (z=${propsZ.toFixed(2)}), ${bodyLength} lines (z=${bodyZ.toFixed(2)}), complexity ${complexity} (z=${complexityZ.toFixed(2)}) - VIOLATES SRP`);
+        }
+    }
+
+    checkMassiveViewModel(cls) {
+        if (cls.name.includes('ViewModel') && cls.bodyLength > 200) {
+            this.pushFinding('android.architecture.massive_viewmodel', 'high', cls.line,
+                `Massive ViewModel '${cls.name}': ${cls.bodyLength} lines - extract to UseCases`);
+        }
+    }
+
+    checkGodNaming(cls) {
+        if (/Manager$|Helper$|Utils$|Handler$/.test(cls.name)) {
+            this.pushFinding('android.naming.god_naming', 'medium', cls.line,
+                `Suspicious name '${cls.name}' - often indicates SRP violation`);
+        }
+    }
+
+    checkUnusedProperties(cls) {
+        for (const prop of cls.properties) {
+            let used = false;
+            for (const m of cls.methods) {
+                if (new RegExp(`\\b${prop.name}\\b`).test(m.body)) { used = true; break; }
+            }
+            if (!used) {
+                this.pushFinding('android.solid.isp.unused_property', 'high', cls.line,
+                    `Unused property '${prop.name}' in '${cls.name}' - ISP violation`);
+            }
+        }
+    }
+
+    checkConcreteDependencies(cls) {
+        if (cls.name.includes('ViewModel') || cls.name.includes('UseCase')) {
+            const params = cls.constructor.split(',').filter(p => p.trim());
+            for (const p of params) {
+                const type = p.split(':')[1]?.trim();
+                if (type && /Impl$|Repository(?!Interface)|Service(?!Interface)/.test(type) && !type.includes('Interface')) {
+                    this.pushFinding('android.solid.dip.concrete_dependency', 'high', cls.line,
+                        `'${cls.name}' depends on concrete '${type}' - use interface`);
+                }
+            }
+        }
+    }
+
+    checkFatInterface(cls) {
+        if (cls.modifier === 'abstract' || this.parser.content.includes(`interface ${cls.name}`)) {
+            if (cls.methods.length > 5) {
+                this.pushFinding('android.solid.isp.fat_interface', 'medium', cls.line,
+                    `Interface '${cls.name}' has ${cls.methods.length} methods - consider splitting`);
+            }
+        }
+    }
+
+    checkLongFunctions(cls) {
+        for (const m of cls.methods) {
+            if (m.bodyLength > 50) {
+                this.pushFinding('android.quality.long_function', 'high', cls.line,
+                    `Function '${cls.name}.${m.name}' is ${m.bodyLength} lines - extract smaller functions`);
+            }
+
+            const complexity = this.parser.calculateComplexity(m.body);
+            if (complexity > 10) {
+                this.pushFinding('android.quality.high_complexity', 'high', cls.line,
+                    `Function '${m.name}' has complexity ${complexity} - simplify`);
+            }
+        }
+    }
+
+    checkRepositoryPattern(cls) {
+        if (cls.name.includes('Repository') && !cls.name.includes('Impl')) {
+            if (!cls.inheritance.includes('Repository')) {
+                this.pushFinding('android.architecture.repository_no_interface', 'high', cls.line,
+                    `Repository '${cls.name}' should implement an interface`);
+            }
+        }
+    }
+
+    checkUseCasePattern(cls) {
+        if (cls.name.includes('UseCase')) {
+            const hasExecute = cls.methods.some(m => /^(execute|invoke|run)$/.test(m.name));
+            if (!hasExecute) {
+                this.pushFinding('android.architecture.usecase_no_execute', 'medium', cls.line,
+                    `UseCase '${cls.name}' missing execute/invoke method`);
+            }
+        }
+    }
+
+    pushFinding(ruleId, severity, line, message) {
+        this.findings.push({
+            ruleId,
+            severity: severity.toUpperCase(),
+            filePath: this.parser.filePath,
+            line,
+            column: 1,
+            message,
+        });
+    }
+}
+
+module.exports = { AndroidClassAnalyzer };
+