pumuki-ast-hooks 5.3.1

package/scripts/hooks-system/infrastructure/severity/context/context-builder.js

@@ -0,0 +1,88 @@
+const { execSync } = require('child_process');
+const { CodeClassificationAnalyzer } = require('./analyzers/CodeClassificationAnalyzer');
+const { ImpactAnalyzer } = require('./analyzers/ImpactAnalyzer');
+const { SafetyAnalyzer } = require('./analyzers/SafetyAnalyzer');
+const { DataAnalyzer } = require('./analyzers/DataAnalyzer');
+
+class ContextBuilder {
+  constructor() {
+    this.codeClassifier = new CodeClassificationAnalyzer();
+    this.impactAnalyzer = new ImpactAnalyzer();
+    this.safetyAnalyzer = new SafetyAnalyzer();
+    this.dataAnalyzer = new DataAnalyzer();
+  }
+
+  /**
+   * Build comprehensive context for a violation
+   * @param {Object} violation - AST violation
+   * @returns {Object} Context object
+   */
+  build(violation) {
+    const filePath = violation.filePath || '';
+    // Bind git helper to pass to analyzers that need it
+    const gitCommitCountFn = this.getCommitCount.bind(this);
+
+    return {
+      // Code Classification
+      isMainThread: this.codeClassifier.detectMainThread(violation, filePath),
+      isProductionCode: this.codeClassifier.isProductionCode(filePath),
+      isTestCode: this.codeClassifier.isTestCode(filePath),
+      layer: this.codeClassifier.detectLayer(filePath),
+
+      // Impact & Usage
+      callFrequency: this.impactAnalyzer.estimateCallFrequency(violation, filePath, gitCommitCountFn),
+      userFacing: this.impactAnalyzer.isUserFacing(filePath),
+      criticalPath: this.impactAnalyzer.isCriticalPath(violation, filePath),
+      inHotPath: this.impactAnalyzer.isHotPath(filePath),
+
+      // Resilience & Safety
+      hasErrorBoundary: this.safetyAnalyzer.hasErrorBoundary(violation, filePath),
+      hasFallback: this.safetyAnalyzer.hasFallback(violation, filePath),
+      hasRetryLogic: this.safetyAnalyzer.hasRetryLogic(filePath),
+
+      // Dependencies & Architecture
+      dependencyCount: this.impactAnalyzer.countDependents(filePath),
+      isPublicAPI: this.codeClassifier.isPublicAPI(filePath),
+      isSharedKernel: this.codeClassifier.isSharedKernel(filePath),
+
+      // Sensitive Data
+      handlesCredentials: this.safetyAnalyzer.handlesCredentials(filePath),
+      handlesPII: this.safetyAnalyzer.handlesPII(filePath),
+      handlesPayments: this.safetyAnalyzer.handlesPayments(filePath),
+
+      // Data Characteristics
+      userGeneratedContent: this.dataAnalyzer.handlesUserContent(filePath),
+      isSharedState: this.dataAnalyzer.isSharedState(violation, filePath),
+      isMultiStepOperation: this.dataAnalyzer.isMultiStepOperation(violation),
+      valueCanBeNil: this.dataAnalyzer.canBeNil(violation),
+
+      // Logic & Complexity
+      hasBusinessLogic: this.codeClassifier.hasBusinessLogic(filePath),
+      dataSize: this.dataAnalyzer.estimateDataSize(violation),
+      listSize: this.dataAnalyzer.estimateListSize(violation),
+
+      // Metadata / Evolution
+      modificationFrequency: this.dataAnalyzer.getModificationFrequency(filePath, gitCommitCountFn),
+      lastModified: this.dataAnalyzer.getLastModified(filePath)
+    };
+  }
+
+  getCommitCount(filePath, days) {
+    try {
+      const since = new Date();
+      since.setDate(since.getDate() - days);
+      const sinceStr = since.toISOString().split('T')[0];
+
+      const result = execSync(
+        `git log --since="${sinceStr}" --oneline --follow -- "${filePath}" | wc -l`,
+        { encoding: 'utf8', cwd: process.cwd(), stdio: ['pipe', 'pipe', 'ignore'] }
+      );
+
+      return parseInt(result.trim()) || 0;
+    } catch {
+      return 0;
+    }
+  }
+}
+
+module.exports = { ContextBuilder };

package/scripts/hooks-system/infrastructure/severity/generators/RecommendationGenerator.js

@@ -0,0 +1,153 @@
+class RecommendationGenerator {
+    generate(violation, severity, context) {
+        const impact = this.explainImpact(violation, context);
+        const fix = this.suggestFix(violation, context);
+
+        const icons = {
+            CRITICAL: '🚨',
+            HIGH: '⚠️',
+            MEDIUM: '⚡',
+            LOW: 'ℹ️'
+        };
+
+        const actions = {
+            CRITICAL: 'Fix IMMEDIATELY (blocks commit)',
+            HIGH: 'Fix in this PR (blocks merge to main)',
+            MEDIUM: 'Create tech debt issue for next sprint',
+            LOW: 'Consider fixing when touching this code'
+        };
+
+        return `${icons[severity]} ${severity}: ${violation.message}
+
+Impact: ${impact}
+Action Required: ${actions[severity]}
+
+Suggested Fix:
+${fix}`;
+    }
+
+    explainImpact(violation, context) {
+        const impacts = [];
+
+        if (context.criticalPath) {
+            impacts.push('Affects critical user flow (checkout, payment, signup)');
+        }
+
+        if (context.dependencyCount > 10) {
+            impacts.push(`${context.dependencyCount} modules depend on this (ripple effect)`);
+        }
+
+        if (context.callFrequency > 1000) {
+            impacts.push(`Executed ${context.callFrequency} times/day (high frequency)`);
+        }
+
+        if (context.isMainThread) {
+            impacts.push('Runs on UI thread (can freeze app)');
+        }
+
+        if (context.handlesPayments) {
+            impacts.push('🔴 PAYMENT PROCESSING - highest priority');
+        }
+
+        if (context.handlesPII) {
+            impacts.push('Handles personal data (GDPR compliance)');
+        }
+
+        return impacts.length > 0 ? impacts.join('\n- ') : 'Standard code quality issue';
+    }
+
+    suggestFix(violation, context) {
+        const fixes = {
+            'solid.srp': this.generateSRPFix(violation, context),
+            'solid.ocp': this.generateOCPFix(violation, context),
+            'solid.lsp': this.generateLSPFix(violation, context),
+            'solid.isp': this.generateISPFix(violation, context),
+            'solid.dip': this.generateDIPFix(violation, context),
+            'clean_arch': this.generateCleanArchFix(violation, context),
+            'cqrs': this.generateCQRSFix(violation, context)
+        };
+
+        for (const [prefix, generator] of Object.entries(fixes)) {
+            if (violation.ruleId.includes(prefix)) {
+                return generator;
+            }
+        }
+
+        return violation.message;
+    }
+
+    generateSRPFix(violation, context) {
+        if (violation.metrics && violation.metrics.responsibilities) {
+            const responsibilities = violation.metrics.responsibilities;
+            return `Split into ${responsibilities.length} classes:
+${responsibilities.map((r, i) => `${i + 1}. ${r}Class - handles ${r.toLowerCase()} only`).join('\n')}
+
+Example:
+❌ class ${violation.className} {
+}
+
+✅ Split into separate classes`;
+        }
+        return 'Extract responsibilities into separate classes (SRP)';
+    }
+
+    generateOCPFix(violation, context) {
+        return 'Use polymorphism or strategy pattern instead of modification';
+    }
+
+    generateLSPFix(violation, context) {
+        return 'Ensure subclass can be substituted for base class';
+    }
+
+    generateISPFix(violation, context) {
+        return 'Split large interface into smaller specific ones';
+    }
+
+    generateDIPFix(violation, context) {
+        if (violation.concreteDependency) {
+            const concrete = violation.concreteDependency;
+            const protocol = concrete.replace(/(Service|Repository|Client|Manager)$/, '$1Protocol');
+
+            return `Create protocol abstraction:
+
+1. Define protocol:
+   protocol ${protocol} {
+   }
+
+2. Make concrete conform:
+   class ${concrete}: ${protocol} {
+   }
+
+3. Inject protocol:
+   init(repository: ${protocol}) {
+       self.repository = repository
+   }`;
+        }
+        return 'Inject protocol abstraction instead of concrete type (DIP)';
+    }
+
+    generateCleanArchFix(violation, context) {
+        return 'Ensure dependencies point inwards (Domain <- Application <- Infrastructure)';
+    }
+
+    generateCQRSFix(violation, context) {
+        return `Split into Command + Query:
+
+❌ Current:
+func updateAndReturn(_ item: Item) -> Item {
+    self.items.append(item)
+    return item
+}
+
+✅ Refactor:
+func updateItem(_ item: Item) {
+    self.items.append(item)
+}
+
+func getItem(id: UUID) -> Item? {
+    return items.first { $0.id == id }
+}`;
+    }
+}
+
+module.exports = RecommendationGenerator;

package/scripts/hooks-system/infrastructure/severity/mappers/SeverityMapper.js

@@ -0,0 +1,10 @@
+class SeverityMapper {
+    static mapToSeverity(score) {
+        if (score >= 85) return 'CRITICAL';
+        if (score >= 65) return 'HIGH';
+        if (score >= 40) return 'MEDIUM';
+        return 'LOW';
+    }
+}
+
+module.exports = SeverityMapper;

package/scripts/hooks-system/infrastructure/severity/policies/gate-policies.js

@@ -0,0 +1,136 @@
+
+const fs = require('fs');
+const path = require('path');
+
+class GatePolicies {
+  constructor() {
+    const policiesPath = path.join(__dirname, 'severity-policies.json');
+    this.policies = JSON.parse(fs.readFileSync(policiesPath, 'utf8'));
+  }
+
+  /**
+   * Apply quality gate to violations
+   * @param {Array} violations - Enhanced violations with computed severity
+   * @returns {Object} Gate result
+   */
+  apply(violations) {
+    const grouped = this.groupBySeverity(violations);
+
+    const override = this.detectContextOverride(violations);
+    const effectivePolicies = override ? this.policies.context_overrides[override].policies : this.policies.quality_gate;
+
+    const results = {
+      CRITICAL: this.checkLevel('CRITICAL', grouped.CRITICAL || [], effectivePolicies.CRITICAL || effectivePolicies['CRITICAL']),
+      HIGH: this.checkLevel('HIGH', grouped.HIGH || [], effectivePolicies.HIGH || effectivePolicies['HIGH']),
+      MEDIUM: this.checkLevel('MEDIUM', grouped.MEDIUM || [], effectivePolicies.MEDIUM || effectivePolicies['MEDIUM']),
+      LOW: this.checkLevel('LOW', grouped.LOW || [], effectivePolicies.LOW || effectivePolicies['LOW'])
+    };
+
+    const passed = !results.CRITICAL.failed && !results.HIGH.failed;
+    const blockedBy = results.CRITICAL.failed ? 'CRITICAL' : (results.HIGH.failed ? 'HIGH' : null);
+
+    return {
+      passed,
+      blockedBy,
+      contextOverride: override,
+      levelResults: results,
+      summary: this.generateSummary(grouped, results),
+      action: blockedBy ? effectivePolicies[blockedBy].action : 'ALLOW',
+      exitCode: passed ? 0 : 1,
+      violations: grouped
+    };
+  }
+
+  groupBySeverity(violations) {
+    return violations.reduce((acc, v) => {
+      const severity = v.severity || 'MEDIUM';
+      if (!acc[severity]) acc[severity] = [];
+      acc[severity].push(v);
+      return acc;
+    }, {});
+  }
+
+  detectContextOverride(violations) {
+    const allPaths = violations.map(v => v.filePath || '');
+
+    for (const [contextName, config] of Object.entries(this.policies.context_overrides)) {
+      const patterns = config.patterns || [];
+      const matchCount = allPaths.filter(p =>
+        patterns.some(pattern => p.includes(pattern))
+      ).length;
+
+      if (matchCount > allPaths.length * 0.8) {
+        return contextName;
+      }
+    }
+
+    return null;
+  }
+
+  checkLevel(severity, violations, policy) {
+    const count = violations.length;
+    const threshold = policy?.threshold ?? 0;
+    const failed = count > threshold;
+
+    return {
+      severity,
+      count,
+      threshold,
+      failed,
+      action: policy?.action || 'WARN',
+      message: policy?.message || `${count} ${severity} violations`,
+      violations: failed ? violations.map(v => ({
+        ruleId: v.ruleId,
+        filePath: v.filePath,
+        line: v.line,
+        message: v.message,
+        score: v.severityScore
+      })) : []
+    };
+  }
+
+  generateSummary(grouped, results) {
+    const total = Object.values(grouped).flat().length;
+
+    return {
+      total,
+      bySeverity: {
+        CRITICAL: grouped.CRITICAL?.length || 0,
+        HIGH: grouped.HIGH?.length || 0,
+        MEDIUM: grouped.MEDIUM?.length || 0,
+        LOW: grouped.LOW?.length || 0
+      },
+      failed: {
+        CRITICAL: results.CRITICAL.failed,
+        HIGH: results.HIGH.failed,
+        MEDIUM: results.MEDIUM.failed,
+        LOW: results.LOW.failed
+      },
+      message: this.buildSummaryMessage(results)
+    };
+  }
+
+  buildSummaryMessage(results) {
+    const parts = [];
+
+    if (results.CRITICAL.failed) {
+      parts.push(`🚨 ${results.CRITICAL.count} CRITICAL (threshold: ${results.CRITICAL.threshold})`);
+    }
+
+    if (results.HIGH.failed) {
+      parts.push(`⚠️  ${results.HIGH.count} HIGH (threshold: ${results.HIGH.threshold})`);
+    }
+
+    if (results.MEDIUM.count > 0) {
+      parts.push(`⚡ ${results.MEDIUM.count} MEDIUM (threshold: ${results.MEDIUM.threshold})`);
+    }
+
+    if (results.LOW.count > 0) {
+      parts.push(`ℹ️  ${results.LOW.count} LOW (threshold: ${results.LOW.threshold})`);
+    }
+
+    return parts.join('\n');
+  }
+}
+
+module.exports = { GatePolicies };

package/scripts/hooks-system/infrastructure/severity/policies/severity-policies.json

@@ -0,0 +1,206 @@
+{
+  "version": "2.0.0",
+  "description": "Severity-based quality gate policies with intelligent evaluation",
+
+  "quality_gate": {
+    "CRITICAL": {
+      "threshold": 0,
+      "action": "BLOCK_COMMIT",
+      "message": "🚨 CRITICAL violations detected - commit BLOCKED",
+      "autoFix": false,
+      "requiresApproval": false,
+      "exitCode": 1
+    },
+    "HIGH": {
+      "threshold": 0,
+      "action": "BLOCK_MERGE",
+      "message": "⚠️  HIGH violations detected - fix before merging to main/develop",
+      "allowInFeatureBranch": true,
+      "requiresApproval": true,
+      "createIssue": true,
+      "exitCode": 1
+    },
+    "MEDIUM": {
+      "threshold": 10,
+      "action": "WARN_AND_ALLOW",
+      "message": "⚡ MEDIUM violations detected - create tech debt issues",
+      "autoCreateIssues": true,
+      "requiresComment": true,
+      "showInReport": true,
+      "exitCode": 0
+    },
+    "LOW": {
+      "threshold": 50,
+      "action": "TRACK_ONLY",
+      "message": "ℹ️  LOW violations detected - tracked in metrics",
+      "showInReport": true,
+      "trackInMetrics": true,
+      "exitCode": 0
+    }
+  },
+
+  "context_overrides": {
+    "payment_flow": {
+      "description": "Stricter rules for payment/checkout code",
+      "patterns": [
+        "/payment/",
+        "/checkout/",
+        "/billing/",
+        "/stripe/",
+        "/transaction/"
+      ],
+      "policies": {
+        "CRITICAL": { "threshold": 0 },
+        "HIGH": { "threshold": 0 },
+        "MEDIUM": { "threshold": 0 },
+        "LOW": { "threshold": 5 }
+      }
+    },
+
+    "authentication_flow": {
+      "description": "Stricter rules for auth code",
+      "patterns": [
+        "/auth/",
+        "/login/",
+        "/signup/",
+        "/session/"
+      ],
+      "policies": {
+        "CRITICAL": { "threshold": 0 },
+        "HIGH": { "threshold": 0 },
+        "MEDIUM": { "threshold": 2 },
+        "LOW": { "threshold": 10 }
+      }
+    },
+
+    "domain_layer": {
+      "description": "Stricter SOLID rules for domain layer",
+      "patterns": [
+        "/domain/",
+        "/Domain/",
+        "/entities/",
+        "/value-objects/"
+      ],
+      "policies": {
+        "CRITICAL": { "threshold": 0 },
+        "HIGH": { "threshold": 0 },
+        "MEDIUM": { "threshold": 3 },
+        "LOW": { "threshold": 15 }
+      }
+    },
+
+    "test_code": {
+      "description": "More lenient for test code",
+      "patterns": [
+        "/test/",
+        "/__tests__/",
+        ".test.",
+        ".spec.",
+        "/Tests/",
+        "/androidTest/"
+      ],
+      "policies": {
+        "CRITICAL": { "threshold": 2 },
+        "HIGH": { "threshold": 5 },
+        "MEDIUM": { "threshold": 20 },
+        "LOW": { "threshold": 100 }
+      }
+    },
+
+    "generated_code": {
+      "description": "Very lenient for generated code",
+      "patterns": [
+        "/generated/",
+        "/Generated/",
+        ".generated.",
+        "// Generated by"
+      ],
+      "policies": {
+        "CRITICAL": { "threshold": 5 },
+        "HIGH": { "threshold": 10 },
+        "MEDIUM": { "threshold": 50 },
+        "LOW": { "threshold": 200 }
+      }
+    }
+  },
+
+  "severity_thresholds": {
+    "score_ranges": {
+      "CRITICAL": { "min": 85, "max": 100 },
+      "HIGH": { "min": 65, "max": 84 },
+      "MEDIUM": { "min": 40, "max": 64 },
+      "LOW": { "min": 0, "max": 39 }
+    },
+
+    "description": "Score ranges for severity mapping (computed from impact analysis)"
+  },
+
+  "impact_weights": {
+    "security": 0.40,
+    "stability": 0.30,
+    "performance": 0.20,
+    "maintainability": 0.10
+  },
+
+  "context_multipliers": {
+    "critical_path": 1.5,
+    "handles_payments": 2.0,
+    "handles_pii": 1.4,
+    "user_facing_no_error_boundary": 1.3,
+    "public_api": 1.2,
+    "main_thread": 2.0,
+    "high_dependency_count": "1 + (count / 20)",
+    "high_call_frequency": 1.2,
+    "solid_in_domain": 1.4,
+    "clean_arch_domain_violation": 1.6,
+
+    "reductions": {
+      "test_code": 0.3,
+      "has_error_boundary_and_fallback": 0.7,
+      "has_retry_logic": 0.9,
+      "generated_code": 0.2
+    }
+  },
+
+  "rule_specific_base_scores": {
+    "SOLID": {
+      "srp_god_class": 70,
+      "ocp_switch": 50,
+      "lsp_contract": 75,
+      "isp_fat_protocol": 45,
+      "dip_concrete": 65
+    },
+
+    "Clean_Architecture": {
+      "domain_imports_framework": 95,
+      "application_depends_infrastructure": 70,
+      "presentation_business_logic": 65,
+      "wrong_directory": 45,
+      "repository_no_abstraction": 75
+    },
+
+    "Security": {
+      "hardcoded_secret": 90,
+      "userdefaults_sensitive": 85,
+      "sql_injection": 95,
+      "xss": 80,
+      "http_url": 60,
+      "missing_ssl_pinning": 55
+    },
+
+    "Stability": {
+      "force_unwrap": 70,
+      "empty_catch": 60,
+      "untyped_catch": 50,
+      "retain_cycle": 55,
+      "context_leak": 60
+    },
+
+    "Testing": {
+      "mock_in_production": 95,
+      "missing_tests_critical": 60,
+      "missing_tests": 25,
+      "test_naming": 15
+    }
+  }
+}

package/scripts/hooks-system/infrastructure/severity/scorers/ContextMultiplier.js

@@ -0,0 +1,49 @@
+class ContextMultiplier {
+    calculate(baseScore, context, violation) {
+        let multiplier = 1.0;
+
+        if (context.isProductionCode) {
+            if (context.criticalPath) multiplier *= 1.5;
+            if (context.handlesPayments) multiplier *= 2.0;
+            if (context.handlesPII) multiplier *= 1.4;
+            if (context.userFacing && !context.hasErrorBoundary) multiplier *= 1.3;
+            if (context.isPublicAPI) multiplier *= 1.2;
+        }
+
+        if (context.isMainThread && baseScore > 30) {
+            multiplier *= 2.0;
+        }
+
+        if (context.dependencyCount > 10) {
+            multiplier *= (1 + context.dependencyCount / 50);
+        }
+
+        if (context.callFrequency > 1000) {
+            multiplier *= 1.2;
+        }
+
+        if (violation.ruleId.includes('solid.') && context.layer === 'DOMAIN') {
+            multiplier *= 1.4;
+        }
+
+        if (violation.ruleId.includes('clean_arch.') && violation.ruleId.includes('domain')) {
+            multiplier *= 1.6;
+        }
+
+        if (context.isTestCode) {
+            multiplier *= 0.3;
+        }
+
+        if (context.hasErrorBoundary && context.hasFallback) {
+            multiplier *= 0.7;
+        }
+
+        if (context.hasRetryLogic) {
+            multiplier *= 0.9;
+        }
+
+        return Math.min(100, baseScore * multiplier);
+    }
+}
+
+module.exports = ContextMultiplier;