pumuki-ast-hooks 5.3.1

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

@@ -0,0 +1,178 @@
+const path = require('path');
+
+function analyzeNetworkResilience(project, findings) {
+  const sourceFiles = project.getSourceFiles();
+
+  sourceFiles.forEach(sf => {
+    const filePath = sf.getFilePath();
+    const content = sf.getFullText();
+
+    checkRetryPolicy(sf, content, findings);
+    checkTimeoutConfiguration(sf, content, findings);
+    checkCircuitBreaker(sf, content, findings);
+    checkRequestQueue(sf, content, findings);
+    checkNetworkErrorHandling(sf, content, findings);
+    checkConnectionPooling(sf, content, findings);
+  });
+}
+
+function checkRetryPolicy(sf, content, findings) {
+  const hasRetry = /retry|retryWhen|retryPolicy/i.test(content);
+  const hasNetworkCall = /fetch\(|axios\.|http\.get|http\.post/i.test(content);
+
+  if (hasNetworkCall && !hasRetry && !content.includes('test') && !content.includes('mock')) {
+    findings.push({
+      filePath: sf.getFilePath(),
+      line: 1,
+      column: 0,
+      severity: 'CRITICAL',
+      ruleId: 'common.network.missing_retry_policy',
+      message: 'Network calls without retry policy - implement exponential backoff for rural connectivity resilience',
+      category: 'Network',
+      suggestion: 'Add retry with exponential backoff: retry({ maxAttempts: 3, backoff: exponential })',
+      context: {
+        impact: 'CRITICAL for RuralGO - rural areas have intermittent connectivity',
+        recommendation: 'axios-retry or custom retry wrapper'
+      }
+    });
+  }
+}
+
+function checkTimeoutConfiguration(sf, content, findings) {
+  const isServer = /http\.createServer|http\.createClient|\.listen\(|express\(|app\.listen/i.test(content);
+  if (isServer) {
+    return;
+  }
+
+  const hasNetworkCall = /fetch\(|axios\.|http\.(get|post|request|put|patch|delete)/i.test(content);
+  const hasTimeout = /timeout:|signal:|AbortController/i.test(content);
+
+  if (hasNetworkCall && !hasTimeout && !content.includes('test')) {
+    findings.push({
+      filePath: sf.getFilePath(),
+      line: 1,
+      column: 0,
+      severity: 'HIGH',
+      ruleId: 'common.network.missing_timeout',
+      message: 'Network calls without timeout - rural connections can hang indefinitely',
+      category: 'Network',
+      suggestion: 'Add timeout: { timeout: 30000 } or AbortController with 30s timeout',
+      context: {
+        impact: 'HIGH - hanging requests degrade UX',
+        recommendation: '30s timeout for API calls, 60s for uploads'
+      }
+    });
+  }
+}
+
+function checkCircuitBreaker(sf, content, findings) {
+  const filePath = sf.getFilePath();
+  const isAnalyzer = /infrastructure\/ast\/|analyzers\/|detectors\/|scanner|analyzer|detector/i.test(filePath);
+  if (isAnalyzer) {
+    return;
+  }
+
+  const hasMultipleRetries = content.match(/retry/gi)?.length > 2;
+  const hasCircuitBreaker = /circuitBreaker|circuit-breaker|circuit\s+breaker|opossum/i.test(content);
+  const hasActualNetworkCall = /fetch\(|axios\.|http\.(get|post|request)/i.test(content);
+
+  if (hasMultipleRetries && !hasCircuitBreaker && hasActualNetworkCall) {
+    findings.push({
+      filePath: sf.getFilePath(),
+      line: 1,
+      column: 0,
+      severity: 'HIGH',
+      ruleId: 'common.network.missing_circuit_breaker',
+      message: 'Multiple retry logic without circuit breaker - prevents cascading failures',
+      category: 'Network',
+      suggestion: 'Implement circuit breaker pattern: opossum library or custom implementation',
+      context: {
+        impact: 'HIGH - prevents system overload when backend down'
+      }
+    });
+  }
+}
+
+function checkRequestQueue(sf, content, findings) {
+  const hasNetworkCall = /fetch\(|axios\./i.test(content);
+  const isOfflineContext = /offline|queue|pending/i.test(content);
+
+  if (hasNetworkCall && isOfflineContext) {
+    const hasQueue = /Queue|PendingRequests|OfflineQueue/i.test(content);
+
+    if (!hasQueue) {
+      findings.push({
+        filePath: sf.getFilePath(),
+        line: 1,
+        column: 0,
+        severity: 'CRITICAL',
+        ruleId: 'common.network.missing_request_queue',
+        message: 'Offline context without request queue - failed requests will be lost',
+        category: 'Network',
+        suggestion: 'Implement offline request queue with persistence (IndexedDB/AsyncStorage)',
+        context: {
+          impact: 'CRITICAL for RuralGO - data loss in rural areas without queue'
+        }
+      });
+    }
+  }
+}
+
+function checkNetworkErrorHandling(sf, content, findings) {
+  const filePath = sf.getFilePath();
+  const isAnalyzer = /infrastructure\/ast\/|analyzers\/|detectors\/|scanner|analyzer|detector/i.test(filePath);
+  if (isAnalyzer) {
+    return;
+  }
+
+  const hasTryCatch = /try\s*{[\s\S]*?catch/i.test(content);
+  const hasNetworkCall = /fetch\(|axios\./i.test(content);
+
+  if (hasNetworkCall && !hasTryCatch && !content.includes('.catch(')) {
+    findings.push({
+      filePath: sf.getFilePath(),
+      line: 1,
+      column: 0,
+      severity: 'HIGH',
+      ruleId: 'common.network.missing_error_handling',
+      message: 'Network calls without error handling - unhandled rejections crash app',
+      category: 'Network',
+      suggestion: 'Wrap in try-catch or add .catch() with specific error types (NetworkError, TimeoutError)',
+      context: {
+        impact: 'HIGH - unhandled network errors cause crashes'
+      }
+    });
+  }
+}
+
+function checkConnectionPooling(sf, content, findings) {
+  const filePath = sf.getFilePath();
+  const isAnalyzer = /infrastructure\/ast\/|analyzers\/|detectors\/|scanner|analyzer|detector/i.test(filePath);
+  const isTestFile = /\.(spec|test)\.(js|ts)$/i.test(filePath);
+  if (isAnalyzer || isTestFile) {
+    return;
+  }
+
+  const hasHttpAgent = /HttpAgent|keepAlive|maxSockets/i.test(content);
+  const isHttpClient = /class.*Client|createClient|httpClient/i.test(content);
+
+  if (isHttpClient && !hasHttpAgent) {
+    findings.push({
+      filePath: sf.getFilePath(),
+      line: 1,
+      column: 0,
+      severity: 'MEDIUM',
+      ruleId: 'common.network.missing_connection_pooling',
+      message: 'HTTP client without connection pooling - reuse connections for performance',
+      category: 'Network',
+      suggestion: 'Configure HTTP agent with keepAlive: true, maxSockets: 50',
+      context: {
+        impact: 'MEDIUM - connection reuse improves performance'
+      }
+    });
+  }
+}
+
+module.exports = {
+  analyzeNetworkResilience
+};

package/scripts/hooks-system/infrastructure/ast/common/offline-backend-analyzer.js

@@ -0,0 +1,53 @@
+function analyzeOfflineBackend(project, findings) {
+  project.getSourceFiles().forEach(sf => {
+    const content = sf.getFullText();
+    const filePath = sf.getFilePath();
+
+    if (!filePath.includes('backend') && !filePath.includes('api')) return;
+
+    const isDomainEntity = /\/domain\/|\/entities\/|ValueObject|\.dto\.ts$|\.entity\.ts$/i.test(filePath);
+    if (isDomainEntity) return;
+
+    const isAnalyzer = /analyzer\.js$|analyzer\.ts$|detector\.js$|detector\.ts$/i.test(filePath);
+    const isTestFile = /\.(spec|test)\.(js|ts)$/i.test(filePath);
+    if (isAnalyzer || isTestFile) return;
+
+    if (content.match(/@Post|@Put|@Patch/gi)) {
+      const hasVersioning = /version|etag|lastModified|timestamp/i.test(content);
+      if (!hasVersioning) {
+        findings.push({
+          filePath, line: 1, column: 0, severity: 'HIGH',
+          ruleId: 'backend.offline.missing_optimistic_locking',
+          message: 'Mutation endpoint without versioning - implement optimistic locking (version/etag) for conflict resolution',
+          category: 'Offline', suggestion: 'Add version field to DTOs, check on update, return 409 Conflict if mismatch'
+        });
+      }
+    }
+
+    if (content.match(/async\s+\w+\([^)]*\).*{[\s\S]*?insert|update|delete/i)) {
+      const hasIdempotency = /idempotencyKey|requestId|deduplication/i.test(content);
+      if (!hasIdempotency) {
+        findings.push({
+          filePath, line: 1, column: 0, severity: 'CRITICAL',
+          ruleId: 'backend.offline.missing_idempotency_key',
+          message: 'Mutation without idempotency key - retried requests will duplicate data',
+          category: 'Offline', suggestion: 'Add idempotencyKey to request headers, check before processing'
+        });
+      }
+    }
+
+    if (content.includes('/sync') || content.includes('SyncController')) {
+      const hasOptimization = /lastSyncedAt|delta|incremental/i.test(content);
+      if (!hasOptimization) {
+        findings.push({
+          filePath, line: 1, column: 0, severity: 'HIGH',
+          ruleId: 'backend.offline.sync_endpoint_optimization',
+          message: 'Sync endpoint without delta sync - full sync wastes bandwidth in rural areas',
+          category: 'Offline', suggestion: 'Implement delta sync: return only changes since lastSyncedAt timestamp'
+        });
+      }
+    }
+  });
+}
+
+module.exports = { analyzeOfflineBackend };

package/scripts/hooks-system/infrastructure/ast/common/push-backend-analyzer.js

@@ -0,0 +1,42 @@
+function analyzePushBackend(project, findings) {
+  project.getSourceFiles().forEach(sf => {
+    const content = sf.getFullText();
+    const filePath = sf.getFilePath();
+
+    if (filePath.includes('hooks-system/') || filePath.includes('scripts/')) {
+      return;
+    }
+
+    const isAnalyzer = /infrastructure\/ast\/|analyzers\/|detectors\/|scanner|analyzer|detector/i.test(filePath);
+    const isTestFile = /\.(spec|test)\.(js|ts)$/i.test(filePath);
+    if (isAnalyzer || isTestFile) {
+      return;
+    }
+
+    const isSystemNotification = /sendNotification.*title|osascript|terminal-notifier/i.test(content);
+    if (content.match(/sendNotification|pushNotification|fcm\.send|apns\.send/i) && !isSystemNotification) {
+      const hasQueue = /Queue|Bull|BullMQ|queueAdd/i.test(content);
+      if (!hasQueue) {
+        findings.push({
+          filePath, line: 1, column: 0, severity: 'HIGH',
+          ruleId: 'backend.push.missing_notification_queue',
+          message: 'Push notification without queue - direct sends fail silently, use queue (Bull/BullMQ) for retry',
+          category: 'Push', suggestion: 'Implement notification queue with retry policy'
+        });
+      }
+
+      const hasBatching = /batch|chunk|bulkSend/i.test(content);
+      const hasLoop = /for\s*\(|forEach|map\(/i.test(content);
+      if (hasLoop && !hasBatching) {
+        findings.push({
+          filePath, line: 1, column: 0, severity: 'MEDIUM',
+          ruleId: 'backend.push.missing_notification_batching',
+          message: 'Notifications sent in loop - batch multiple sends (500 tokens/batch) for FCM efficiency',
+          category: 'Push', suggestion: 'Use FCM multicast or batch send API'
+        });
+      }
+    }
+  });
+}
+
+module.exports = { analyzePushBackend };

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

@@ -0,0 +1,87 @@
+const fs = require('fs');
+const glob = require('glob');
+const { pushFileFinding } = require('../../ast-core');
+
+class BDDRules {
+    constructor(projectRoot) {
+        this.projectRoot = projectRoot;
+    }
+
+    analyze(findings) {
+        this.checkBDDFeatureFiles(findings);
+    }
+
+    checkBDDFeatureFiles(findings) {
+        const featureFiles = glob.sync('**/*.feature', {
+            cwd: this.projectRoot,
+            ignore: ['**/node_modules/**', '**/build/**', '**/dist/**'],
+            absolute: true
+        });
+
+        const implementationFiles = glob.sync('**/*.{swift,kt,ts,tsx}', {
+            cwd: this.projectRoot,
+            ignore: ['**/node_modules/**', '**/build/**', '**/dist/**', '**/*test*', '**/*spec*'],
+            absolute: true
+        });
+
+        if (implementationFiles.length > 50 && featureFiles.length === 0) {
+            pushFileFinding(
+                'workflow.bdd.missing_feature_files',
+                'critical',
+                'PROJECT_ROOT',
+                1,
+                1,
+                `🚨 CRITICAL: Proyecto con ${implementationFiles.length} archivos de implementación sin feature files (.feature).\n\nWORKFLOW BDD→TDD→IMPLEMENTATION VIOLADO:\n1. BDD (OBLIGATORIO): Crear feature files (.feature) con especificaciones Gherkin ANTES de cualquier código\n2. TDD: Escribir tests basados en las features\n3. Implementation: Implementar código que pase los tests\n\nACCIÓN REQUERIDA:\n- Crear feature files en features/ o specs/ con estructura:\n  Feature: Nombre de la funcionalidad\n    Scenario: Descripción del escenario\n      Given condición inicial\n      When acción\n      Then resultado esperado\n\nSin feature files, el proyecto NO sigue el workflow estándar BDD→TDD.`,
+                findings
+            );
+        }
+
+        if (implementationFiles.length > 20 && featureFiles.length < 3) {
+            pushFileFinding(
+                'workflow.bdd.insufficient_features',
+                'high',
+                'PROJECT_ROOT',
+                1,
+                1,
+                `⚠️ HIGH: Solo ${featureFiles.length} feature files para ${implementationFiles.length} archivos de implementación.\n\nBDD requiere feature files para cada funcionalidad. Aumentar cobertura BDD antes de continuar.`,
+                findings
+            );
+        }
+
+        featureFiles.forEach(featureFile => {
+            const content = fs.readFileSync(featureFile, 'utf-8');
+
+            const hasFeature = content.includes('Feature:');
+            const hasScenario = content.includes('Scenario:');
+            const hasGiven = content.includes('Given ');
+            const hasWhen = content.includes('When ');
+            const hasThen = content.includes('Then ');
+
+            if (!hasFeature || !hasScenario) {
+                pushFileFinding(
+                    'workflow.bdd.invalid_feature_structure',
+                    'high',
+                    featureFile,
+                    1,
+                    1,
+                    'Feature file sin estructura Gherkin correcta (Feature, Scenario, Given/When/Then)',
+                    findings
+                );
+            }
+
+            if (hasScenario && (!hasGiven || !hasWhen || !hasThen)) {
+                pushFileFinding(
+                    'workflow.bdd.incomplete_gherkin',
+                    'medium',
+                    featureFile,
+                    1,
+                    1,
+                    'Scenario sin estructura completa Given/When/Then',
+                    findings
+                );
+            }
+        });
+    }
+}
+
+module.exports = BDDRules;

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

@@ -0,0 +1,83 @@
+const fs = require('fs');
+const glob = require('glob');
+const { pushFileFinding } = require('../../ast-core');
+
+class ImplementationRules {
+    constructor(projectRoot) {
+        this.projectRoot = projectRoot;
+    }
+
+    analyze(findings) {
+        this.checkImplementationAlignment(findings);
+    }
+
+    checkImplementationAlignment(findings) {
+        const srcFiles = glob.sync('**/src/**/*.{ts,tsx,swift,kt}', {
+            cwd: this.projectRoot,
+            ignore: ['**/node_modules/**', '**/*test*'],
+            absolute: true
+        });
+
+        srcFiles.forEach(file => {
+            const content = fs.readFileSync(file, 'utf-8');
+
+            if (file.includes('/presentation/') || file.includes('/controllers/')) {
+                const hasComplexLogic =
+                    (content.match(/func\s+\w+[\s\S]{200,}?}/g) || []).length > 0 ||
+                    content.includes('for ') || content.includes('while ') ||
+                    (content.match(/if\s*\(/g) || []).length > 5;
+
+                if (hasComplexLogic) {
+                    pushFileFinding(
+                        'workflow.implementation.presentation_business_logic',
+                        'high',
+                        file,
+                        1,
+                        1,
+                        'Presentation/Controllers con lógica de negocio compleja. Extraer a Use Cases (application layer).',
+                        findings
+                    );
+                }
+            }
+
+            if (file.includes('/domain/')) {
+                const frameworkImports = [
+                    'UIKit', 'SwiftUI', 'Alamofire', 'CoreData',
+                    '@nestjs', 'express', 'axios', 'react', 'next'
+                ];
+
+                frameworkImports.forEach(framework => {
+                    if (content.includes(framework)) {
+                        pushFileFinding(
+                            'workflow.implementation.domain_framework_dependency',
+                            'critical',
+                            file,
+                            1,
+                            1,
+                            `Domain layer depende de '${framework}'. Domain debe ser framework-agnostic (lógica pura).`,
+                            findings
+                        );
+                    }
+                });
+            }
+
+            if (file.includes('Repository') && content.includes('class ') && !file.includes('/domain/')) {
+                const hasInterface = content.includes('protocol ') || content.includes('interface ');
+
+                if (!hasInterface) {
+                    pushFileFinding(
+                        'workflow.implementation.repository_without_interface',
+                        'high',
+                        file,
+                        1,
+                        1,
+                        'Repository implementation sin interface/protocol en domain. DDD requiere abstracción.',
+                        findings
+                    );
+                }
+            }
+        });
+    }
+}
+
+module.exports = ImplementationRules;

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

@@ -0,0 +1,109 @@
+const path = require('path');
+const glob = require('glob');
+const { pushFileFinding } = require('../../ast-core');
+
+class TDDRules {
+    constructor(projectRoot) {
+        this.projectRoot = projectRoot;
+    }
+
+    analyze(findings) {
+        this.checkTDDTestCoverage(findings);
+    }
+
+    checkTDDTestCoverage(findings) {
+        const features = this.findFeatures();
+
+        features.forEach(feature => {
+            const hasTests = this.hasTestsForFeature(feature);
+            const hasImplementation = this.hasImplementationForFeature(feature);
+
+            if (hasImplementation && !hasTests) {
+                pushFileFinding(
+                    'workflow.tdd.implementation_before_tests',
+                    'critical',
+                    feature.path,
+                    1,
+                    1,
+                    `🚨 CRITICAL: Feature '${feature.name}' tiene implementación sin tests.\n\nWORKFLOW BDD→TDD→IMPLEMENTATION VIOLADO:\n- BDD: ✅ Feature file existe\n- TDD: ❌ Tests NO existen (REQUERIDO antes de implementación)\n- Implementation: ✅ Existe (pero NO debería existir sin tests)\n\nACCIÓN REQUERIDA:\n1. Crear tests (.spec.ts, .test.ts, .spec.swift, etc.) basados en la feature\n2. Los tests deben fallar inicialmente (red phase)\n3. Luego implementar código para que pasen (green phase)\n4. Refactorizar si es necesario\n\nTDD requiere: Tests ANTES de implementación. Sin tests, no hay TDD.`,
+                    findings
+                );
+            }
+        });
+
+        const srcFiles = glob.sync('**/src/**/*.{ts,tsx,swift,kt}', {
+            cwd: this.projectRoot,
+            ignore: ['**/*test*', '**/*spec*', '**/node_modules/**'],
+            absolute: false
+        });
+
+        const testFiles = glob.sync('**/*.{test,spec}.{ts,tsx,swift,kt}', {
+            cwd: this.projectRoot,
+            ignore: ['**/node_modules/**'],
+            absolute: false
+        });
+
+        const srcWithoutTests = srcFiles.filter(srcFile => {
+            const baseName = path.basename(srcFile, path.extname(srcFile));
+            return !testFiles.some(testFile => testFile.includes(baseName));
+        });
+
+        if (srcWithoutTests.length > 10) {
+            pushFileFinding(
+                'workflow.tdd.low_test_coverage',
+                'critical',
+                'PROJECT_ROOT',
+                1,
+                1,
+                `🚨 CRITICAL: ${srcWithoutTests.length} archivos de implementación sin tests.\n\nTDD VIOLADO: TDD requiere tests para cada implementación.\n\nWORKFLOW CORRECTO:\n1. BDD: Feature file (.feature) ✅\n2. TDD: Tests escritos ANTES de implementación ❌ (FALTAN)\n3. Implementation: Código que pasa los tests ✅\n\nACCIÓN REQUERIDA:\n- Crear tests para cada archivo de implementación\n- Tests deben existir ANTES o al mismo tiempo que la implementación\n- Sin tests, no hay TDD`,
+                findings
+            );
+        } else if (srcWithoutTests.length > 0) {
+            pushFileFinding(
+                'workflow.tdd.low_test_coverage',
+                'high',
+                'PROJECT_ROOT',
+                1,
+                1,
+                `⚠️ HIGH: ${srcWithoutTests.length} archivos de implementación sin tests. TDD requiere tests para cada implementación.`,
+                findings
+            );
+        }
+    }
+
+    findFeatures() {
+        const features = [];
+        const featureFolders = glob.sync('**/Features/*/', {
+            cwd: this.projectRoot,
+            absolute: true
+        });
+
+        featureFolders.forEach(folder => {
+            const name = path.basename(folder);
+            features.push({
+                name,
+                path: folder
+            });
+        });
+
+        return features;
+    }
+
+    hasTestsForFeature(feature) {
+        const testFiles = glob.sync(`**/*${feature.name}*.{test,spec}.{ts,tsx,swift,kt}`, {
+            cwd: this.projectRoot,
+            nocase: true
+        });
+        return testFiles.length > 0;
+    }
+
+    hasImplementationForFeature(feature) {
+        const implFiles = glob.sync(`**/Features/${feature.name}/**/*.{ts,tsx,swift,kt}`, {
+            cwd: this.projectRoot,
+            ignore: ['**/*test*', '**/*spec*']
+        });
+        return implFiles.length > 0;
+    }
+}
+
+module.exports = TDDRules;