pumuki-ast-hooks 5.3.1

package/scripts/hooks-system/infrastructure/ast/common/rules/WorkflowRules.js

@@ -0,0 +1,137 @@
+const fs = require('fs');
+const glob = require('glob');
+const { pushFileFinding } = require('../../ast-core');
+
+class WorkflowRules {
+    constructor(projectRoot) {
+        this.projectRoot = projectRoot;
+    }
+
+    analyze(findings) {
+        this.checkWorkflowSequence(findings);
+        this.checkFeatureTestImplementationTriad(findings);
+    }
+
+    checkWorkflowSequence(findings) {
+        const features = glob.sync('**/*.feature', { cwd: this.projectRoot, absolute: true });
+        const tests = glob.sync('**/*.{test,spec}.{ts,tsx,swift,kt}', { cwd: this.projectRoot, absolute: true });
+        const impl = glob.sync('**/src/**/*.{ts,tsx,swift,kt}', {
+            cwd: this.projectRoot,
+            ignore: ['**/*test*', '**/*spec*'],
+            absolute: true
+        });
+
+        const isLibrarySelfAudit = process.env.AUDIT_LIBRARY_SELF === 'true' ||
+            this.projectRoot.includes('ast-intelligence-hooks');
+        if (isLibrarySelfAudit) {
+            return;
+        }
+
+        const ratio = {
+            features: features.length,
+            tests: tests.length,
+            implementation: impl.length
+        };
+
+        if (ratio.implementation > ratio.tests * 2 && ratio.implementation > 20) {
+            pushFileFinding(
+                'workflow.sequence.tests_lagging',
+                'critical',
+                'PROJECT_ROOT',
+                1,
+                1,
+                `🚨 CRITICAL: Ratio Implementation:Tests desequilibrado (${ratio.implementation} implementaciones : ${ratio.tests} tests).\n\nWORKFLOW BDD→TDD→IMPLEMENTATION VIOLADO:\n- BDD: ${ratio.features} features\n- TDD: ${ratio.tests} tests (INSUFICIENTES)\n- Implementation: ${ratio.implementation} archivos (DEMASIADOS sin tests)\n\nTDD requiere: Tests primero, luego implementación. Ratio ideal: Tests >= Implementation.\n\nACCIÓN REQUERIDA:\n- Escribir tests para cada implementación\n- No crear nueva implementación sin tests correspondientes\n- Seguir flujo: Feature → Tests → Implementation`,
+                findings
+            );
+        } else if (ratio.implementation > ratio.tests * 2) {
+            pushFileFinding(
+                'workflow.sequence.tests_lagging',
+                'high',
+                'PROJECT_ROOT',
+                1,
+                1,
+                `⚠️ HIGH: Ratio Implementation:Tests desequilibrado (${ratio.implementation}:${ratio.tests}). TDD requiere tests primero.`,
+                findings
+            );
+        }
+
+        if (ratio.tests > 0 && ratio.features === 0) {
+            pushFileFinding(
+                'workflow.sequence.missing_bdd_specs',
+                'medium',
+                'PROJECT_ROOT',
+                1,
+                1,
+                'Tests sin feature files BDD. Workflow debe empezar con especificaciones de comportamiento.',
+                findings
+            );
+        }
+    }
+
+    checkFeatureTestImplementationTriad(findings) {
+        const featureFiles = glob.sync('**/*.feature', { cwd: this.projectRoot, absolute: true });
+
+        featureFiles.forEach(featureFile => {
+            const content = fs.readFileSync(featureFile, 'utf-8');
+            const featureName = this.extractFeatureName(content);
+
+            if (featureName) {
+                const testFiles = glob.sync(`**/*${featureName}*.{test,spec}.{ts,tsx,swift,kt}`, {
+                    cwd: this.projectRoot,
+                    absolute: true,
+                    nocase: true
+                });
+
+                const implFiles = glob.sync(`**/*${featureName}*.{ts,tsx,swift,kt}`, {
+                    cwd: this.projectRoot,
+                    ignore: ['**/*test*', '**/*spec*', '**/*.feature'],
+                    absolute: true,
+                    nocase: true
+                });
+
+                if (testFiles.length === 0) {
+                    pushFileFinding(
+                        'workflow.triad.feature_without_tests',
+                        'high',
+                        featureFile,
+                        1,
+                        1,
+                        `Feature '${featureName}' sin tests correspondientes. BDD → TDD workflow roto.`,
+                        findings
+                    );
+                }
+
+                if (implFiles.length === 0 && testFiles.length > 0) {
+                    pushFileFinding(
+                        'workflow.triad.tests_without_implementation',
+                        'low',
+                        featureFile,
+                        1,
+                        1,
+                        `Feature '${featureName}' con tests pero sin implementación (OK si está en desarrollo).`,
+                        findings
+                    );
+                }
+
+                if (implFiles.length > 0 && testFiles.length === 0) {
+                    pushFileFinding(
+                        'workflow.triad.implementation_without_tests',
+                        'critical',
+                        featureFile,
+                        1,
+                        1,
+                        `Feature '${featureName}' con implementación pero SIN tests. Violación grave de TDD.`,
+                        findings
+                    );
+                }
+            }
+        });
+    }
+
+    extractFeatureName(content) {
+        const match = content.match(/Feature:\s*(.+)/);
+        return match ? match[1].trim().replace(/\s+/g, '') : null;
+    }
+}
+
+module.exports = WorkflowRules;

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

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

package/scripts/hooks-system/infrastructure/ast/frontend/analyzers/FrontendArchitectureDetector.js

@@ -0,0 +1,289 @@
+const fs = require('fs');
+const path = require('path');
+const glob = require('glob');
+
+class FrontendArchitectureDetector {
+  constructor(projectRoot) {
+    this.projectRoot = projectRoot;
+    this.patterns = {
+      featureFirstClean: 0,  // Feature-First + DDD + Clean Architecture
+      componentBased: 0,     // Component-Based Architecture
+      atomicDesign: 0,       // Atomic Design Pattern
+      stateManagement: 0,    // State Management pattern
+      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('[Frontend Architecture] Manual configuration loaded from .ast-architecture.json');
+        return config.frontend || null;
+      }
+    } catch (error) {
+      console.warn('[Frontend Architecture] Error loading .ast-architecture.json:', error.message);
+    }
+    return null;
+  }
+
+  detect() {
+    if (this.manualConfig && this.manualConfig.architecturePattern) {
+      const manualPattern = this.manualConfig.architecturePattern;
+      console.log(`[Frontend Architecture] Using manual configuration: ${manualPattern}`);
+      return manualPattern;
+    }
+
+    const tsxFiles = glob.sync('**/*.{tsx,jsx}', {
+      cwd: this.projectRoot,
+      ignore: ['**/node_modules/**', '**/.next/**', '**/dist/**', '**/build/**', '**/*.test.{tsx,jsx}', '**/*.spec.{tsx,jsx}']
+    });
+
+    const tsFiles = glob.sync('**/*.ts', {
+      cwd: this.projectRoot,
+      ignore: ['**/node_modules/**', '**/.next/**', '**/dist/**', '**/build/**', '**/*.test.ts', '**/*.spec.ts']
+    });
+
+    const allFiles = [...tsxFiles, ...tsFiles];
+
+    if (allFiles.length === 0) {
+      return 'UNKNOWN';
+    }
+
+    this.detectFeatureFirstClean(allFiles);
+    this.detectComponentBased(allFiles);
+    this.detectAtomicDesign(allFiles);
+    this.detectStateManagement(allFiles);
+    this.detectMVC(allFiles);
+
+    return this.getDominantPattern();
+  }
+
+  detectFeatureFirstClean(files) {
+    const hasFeaturesFolders = files.some(f =>
+      /\/features?\/\w+\/(domain|application|infrastructure|presentation)\//.test(f)
+    );
+
+    const cleanArchFolders = ['domain', 'application', 'infrastructure', 'presentation'];
+    const foundCleanFolders = cleanArchFolders.filter(folder => {
+      return files.some(f => f.includes(`/${folder}/`));
+    });
+
+    const dddConcepts = files.filter(f =>
+      f.includes('/entities/') ||
+      f.includes('/value-objects/') ||
+      f.includes('/use-cases/') ||
+      f.includes('/repositories/') ||
+      f.includes('Entity.ts') ||
+      f.includes('UseCase.ts') ||
+      f.includes('Repository.ts')
+    );
+
+    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 (file.includes('/domain/') && content.includes('interface ') && content.includes('Repository')) {
+        this.patterns.featureFirstClean += 3;
+      }
+
+      if (file.includes('/application/') || file.includes('/use-cases/')) {
+        if (content.includes('UseCase') || content.includes('useCase')) {
+          this.patterns.featureFirstClean += 2;
+        }
+      }
+
+      if (file.includes('/hooks/') && file.includes('use') && file.endsWith('.ts')) {
+        this.patterns.featureFirstClean += 1;
+      }
+    });
+
+    console.log(`[Architecture Detection] Feature-First + Clean + DDD score: ${this.patterns.featureFirstClean}`);
+  }
+
+  detectComponentBased(files) {
+    const hasComponentsFolder = files.some(f => f.includes('/components/'));
+    
+    if (hasComponentsFolder) {
+      this.patterns.componentBased += 10;
+    }
+
+    const componentFiles = files.filter(f =>
+      f.includes('/components/') && (f.endsWith('.tsx') || f.endsWith('.jsx'))
+    );
+
+    if (componentFiles.length > 0) {
+      this.patterns.componentBased += componentFiles.length;
+    }
+
+    files.forEach(file => {
+      if (!file.includes('/components/')) return;
+      
+      const content = this.readFile(file);
+      const componentImports = content.match(/from\s+['"]\.\.\/components\//g) || [];
+      
+      if (componentImports.length > 0) {
+        this.patterns.componentBased += componentImports.length;
+      }
+    });
+  }
+
+  detectAtomicDesign(files) {
+    const atomicFolders = ['atoms', 'molecules', 'organisms', 'templates', 'pages'];
+    
+    const foundFolders = atomicFolders.filter(folder => {
+      return files.some(f => f.includes(`/${folder}/`));
+    });
+
+    if (foundFolders.length >= 3) {
+      this.patterns.atomicDesign += foundFolders.length * 5;
+    }
+
+    if (files.some(f => f.includes('/atoms/')) && 
+        files.some(f => f.includes('/molecules/')) && 
+        files.some(f => f.includes('/organisms/'))) {
+      this.patterns.atomicDesign += 10;
+    }
+  }
+
+  detectStateManagement(files) {
+    files.forEach(file => {
+      const content = this.readFile(file);
+
+      if (content.includes('zustand') || content.includes('create(') && file.includes('store')) {
+        this.patterns.stateManagement += 5;
+      }
+
+      if (content.includes('redux') || content.includes('@reduxjs/toolkit') || 
+          file.includes('slice') || file.includes('reducer')) {
+        this.patterns.stateManagement += 5;
+      }
+
+      if (content.includes('createContext') || content.includes('Context.Provider')) {
+        this.patterns.stateManagement += 2;
+      }
+
+      if (file.includes('/stores/') || file.includes('/state/')) {
+        this.patterns.stateManagement += 3;
+      }
+    });
+  }
+
+  detectMVC(files) {
+    files.forEach(file => {
+      if (!file.includes('component') && !file.endsWith('.tsx') && !file.endsWith('.jsx')) return;
+      
+      const content = this.readFile(file);
+      
+      if (content.includes('fetch(') || content.includes('axios.') || content.includes('.get(')) {
+        const hasHook = files.some(f => 
+          f.includes('use') && f.endsWith('.ts') && !f.includes('component')
+        );
+        const hasService = files.some(f => 
+          f.includes('service') || f.includes('api')
+        );
+        
+        if (!hasHook && !hasService) {
+          this.patterns.mvc += 3;
+        }
+      }
+
+      if (content.match(/const\s+\w+\s*=\s*\(.*\)\s*=>\s*{[\s\S]{0,500}if\s*\(.*\)\s*{[\s\S]{0,500}if\s*\(.*\)\s*{[\s\S]{0,500}if\s*\(.*\)\s*{/)) {
+        this.patterns.mvc += 2;
+      }
+    });
+  }
+
+  readFile(relativePath) {
+    try {
+      const fullPath = path.join(this.projectRoot, relativePath);
+      return fs.readFileSync(fullPath, 'utf-8');
+    } catch (error) {
+      if (process.env.DEBUG) {
+        console.debug(`[FrontendArchitectureDetector] Failed to read file ${relativePath}: ${error.message}`);
+      }
+      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',
+      componentBased: 'COMPONENT_BASED',
+      atomicDesign: 'ATOMIC_DESIGN',
+      stateManagement: 'STATE_MANAGEMENT',
+      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 Frontend project.',
+        recommendation: 'Define project architecture before continuing. Recommended: Feature-First + Clean + DDD, or Component-Based Architecture.'
+      });
+    }
+
+    if (this.patterns.mvc > 0 && dominantPattern !== 'MVC') {
+      warnings.push({
+        severity: 'MEDIUM',
+        message: 'MVC anti-pattern detected. Consider migrating to Feature-First or Component-Based Architecture.',
+        recommendation: 'Refactor components to use hooks/services for business logic and API calls.'
+      });
+    }
+
+    return {
+      pattern: dominantPattern,
+      confidence,
+      scores: { ...this.patterns },
+      warnings
+    };
+  }
+}
+
+module.exports = { FrontendArchitectureDetector };
+