pumuki-ast-hooks 5.3.1

package/scripts/hooks-system/infrastructure/ast/backend/forbidden-literals-analyzer.js

@@ -0,0 +1,236 @@
+const { SyntaxKind } = require('../ast-core');
+
+const FORBIDDEN_STRING_LITERALS = [
+    'unknown',
+    'null',
+    'undefined',
+    'any',
+    'void',
+    'never',
+];
+
+const FORBIDDEN_STATUS_LITERALS = [
+    'active',
+    'inactive',
+    'pending',
+    'completed',
+    'failed',
+    'success',
+    'error',
+];
+
+const MAGIC_NUMBERS = [0, 1];
+
+function analyzeForbiddenLiterals(sf, findings, pushFinding) {
+    const stringLiterals = sf.getDescendantsOfKind(SyntaxKind.StringLiteral);
+    const numericLiterals = sf.getDescendantsOfKind(SyntaxKind.NumericLiteral);
+    const asExpressions = sf.getDescendantsOfKind(SyntaxKind.AsExpression);
+    const nullishCoalescing = sf.getDescendantsOfKind(SyntaxKind.NullishCoalescingExpression);
+    const conditionalExpressions = sf.getDescendantsOfKind(SyntaxKind.ConditionalExpression);
+
+    stringLiterals.forEach((literal) => {
+        const value = literal.getLiteralValue();
+        const parent = literal.getParent();
+
+        if (!parent) return;
+
+        const isInTypeDefinition = parent.getKind && (
+            parent.getKind() === SyntaxKind.UnionType ||
+            parent.getKind() === SyntaxKind.TypeLiteral ||
+            parent.getKind() === SyntaxKind.PropertySignature
+        );
+
+        if (isInTypeDefinition) return;
+
+        const isInImport = parent.getKind && (
+            parent.getKind() === SyntaxKind.ImportDeclaration ||
+            parent.getKind() === SyntaxKind.ImportSpecifier
+        );
+
+        if (isInImport) return;
+
+        const isInComment = parent.getKind && parent.getKind() === SyntaxKind.JSDocComment;
+        if (isInComment) return;
+
+        const fullText = sf.getFullText();
+        const literalText = literal.getText();
+        const literalIndex = literal.getStart();
+        const lineStart = fullText.lastIndexOf('\n', literalIndex) + 1;
+        const lineEnd = fullText.indexOf('\n', literalIndex);
+        const fullLine = fullText.substring(lineStart, lineEnd === -1 ? undefined : lineEnd);
+
+        const isInStringTemplate = /`[^`]*${literalText}[^`]*`/.test(fullLine);
+        const isInConsoleLog = /console\.(log|error|warn|info)/i.test(fullLine);
+        const isInTestFile = /\.(spec|test)\.(ts|js)$/i.test(sf.getFilePath());
+
+        if (isInStringTemplate || isInConsoleLog || isInTestFile) return;
+
+        if (FORBIDDEN_STRING_LITERALS.includes(value)) {
+            pushFinding(
+                'backend.types.forbidden_literal',
+                'critical',
+                literal,
+                sf,
+                `Forbidden string literal '${value}' detected. Use enums, constants, or type-safe alternatives instead of magic strings.`,
+                findings
+            );
+        }
+
+        const isStatusContext = /status|state|role|type|kind|category/i.test(fullLine) &&
+            !/enum|const|type|interface|Record<.*Status/i.test(fullLine);
+
+        if (isStatusContext && FORBIDDEN_STATUS_LITERALS.includes(value)) {
+            pushFinding(
+                'backend.types.forbidden_status_literal',
+                'high',
+                literal,
+                sf,
+                `Forbidden status literal '${value}' detected. Use enums or constants instead of string literals for status/state values.`,
+                findings
+            );
+        }
+    });
+
+    numericLiterals.forEach((literal) => {
+        const value = parseFloat(literal.getText());
+        const parent = literal.getParent();
+
+        if (!parent) return;
+
+        const isInTypeDefinition = parent.getKind && (
+            parent.getKind() === SyntaxKind.UnionType ||
+            parent.getKind() === SyntaxKind.TypeLiteral ||
+            parent.getKind() === SyntaxKind.PropertySignature
+        );
+
+        if (isInTypeDefinition) return;
+
+        const fullText = sf.getFullText();
+        const literalIndex = literal.getStart();
+        const lineStart = fullText.lastIndexOf('\n', literalIndex) + 1;
+        const lineEnd = fullText.indexOf('\n', literalIndex);
+        const fullLine = fullText.substring(lineStart, lineEnd === -1 ? undefined : lineEnd);
+
+        const isInArrayIndex = /\[\s*\d+\s*\]/.test(fullLine);
+        const isInTestFile = /\.(spec|test)\.(ts|js)$/i.test(sf.getFilePath());
+        const isInEnumValue = /=\s*\d+/.test(fullLine) && /enum/.test(fullText.substring(0, literalIndex));
+
+        if (isInArrayIndex || isInTestFile || isInEnumValue) return;
+
+        if (MAGIC_NUMBERS.includes(value) && !isInEnumValue) {
+            const context = fullLine.trim();
+            const isIncrement = /\+\+\s*$|=\s*\w+\s*\+\s*1|=\s*\w+\s*\+\s*\d+\s*\+/.test(context);
+            const isInitialization = /=\s*0\s*[,;]/.test(context);
+
+            if (isIncrement || isInitialization) {
+                pushFinding(
+                    'backend.types.magic_number',
+                    'high',
+                    literal,
+                    sf,
+                    `Magic number ${value} detected. Use named constants (e.g., INITIAL_COUNT, INCREMENT_VALUE) instead of magic numbers.`,
+                    findings
+                );
+            }
+        }
+    });
+
+    asExpressions.forEach((expr) => {
+        const fullText = sf.getFullText();
+        const exprIndex = expr.getStart();
+        const lineStart = fullText.lastIndexOf('\n', exprIndex) + 1;
+        const lineEnd = fullText.indexOf('\n', exprIndex);
+        const fullLine = fullText.substring(lineStart, lineEnd === -1 ? undefined : lineEnd);
+
+        const isInTestFile = /\.(spec|test)\.(ts|js)$/i.test(sf.getFilePath());
+        const isTypeAssertion = /as\s+(UserRole|OrderStatus|UserStatus|AlertStatus)/i.test(fullLine);
+
+        if (isInTestFile || isTypeAssertion) return;
+
+        pushFinding(
+            'backend.types.forbidden_type_cast',
+            'high',
+            expr,
+            sf,
+            `Type casting with 'as' detected. Use type guards, mappers, or proper type narrowing instead of type assertions.`,
+            findings
+        );
+    });
+
+    nullishCoalescing.forEach((expr) => {
+        const fullText = sf.getFullText();
+        const exprIndex = expr.getStart();
+        const lineStart = fullText.lastIndexOf('\n', exprIndex) + 1;
+        const lineEnd = fullText.indexOf('\n', exprIndex);
+        const fullLine = fullText.substring(lineStart, lineEnd === -1 ? undefined : lineEnd);
+
+        const isInTestFile = /\.(spec|test)\.(ts|js)$/i.test(sf.getFilePath());
+        const hasNull = /null/.test(fullLine);
+        const hasUndefined = /undefined/.test(fullLine);
+
+        if (isInTestFile) return;
+
+        if (hasNull || hasUndefined) {
+            pushFinding(
+                'backend.types.forbidden_nullish_coalescing',
+                'critical',
+                expr,
+                sf,
+                `Nullish coalescing with null/undefined detected. Use optional properties (name?: string) instead of nullable types (name: string | null). Eliminate null/undefined from codebase.`,
+                findings
+            );
+        }
+    });
+
+    conditionalExpressions.forEach((expr) => {
+        const fullText = sf.getFullText();
+        const exprIndex = expr.getStart();
+        const lineStart = fullText.lastIndexOf('\n', exprIndex) + 1;
+        const lineEnd = fullText.indexOf('\n', exprIndex);
+        const fullLine = fullText.substring(lineStart, lineEnd === -1 ? undefined : lineEnd);
+
+        const isInTestFile = /\.(spec|test)\.(ts|js)$/i.test(sf.getFilePath());
+        const hasNull = /\?\s*null\s*:/.test(fullLine);
+        const hasUndefined = /\?\s*undefined\s*:/.test(fullLine);
+
+        if (isInTestFile) return;
+
+        if (hasNull || hasUndefined) {
+            pushFinding(
+                'backend.types.forbidden_ternary_null_undefined',
+                'critical',
+                expr,
+                sf,
+                `Ternary operator with null/undefined detected. Use optional properties (prop?: Type) and spread conditional pattern instead of ternary with null/undefined. Build objects with only defined properties.`,
+                findings
+            );
+        }
+    });
+
+    const objectLiteralExpressions = sf.getDescendantsOfKind(SyntaxKind.ObjectLiteralExpression);
+    objectLiteralExpressions.forEach((obj) => {
+        const fullText = sf.getFullText();
+        const objIndex = obj.getStart();
+        const lineStart = fullText.lastIndexOf('\n', objIndex) + 1;
+        const lineEnd = fullText.indexOf('\n', objIndex);
+        const fullLine = fullText.substring(lineStart, lineEnd === -1 ? undefined : lineEnd);
+
+        const isInTestFile = /\.(spec|test)\.(ts|js)$/i.test(sf.getFilePath());
+        const hasUndefinedAssignment = /:\s*undefined/.test(fullLine);
+
+        if (isInTestFile) return;
+
+        if (hasUndefinedAssignment) {
+            pushFinding(
+                'backend.types.forbidden_undefined_assignment',
+                'critical',
+                obj,
+                sf,
+                `Direct undefined assignment in object detected. Use optional properties and conditional spread pattern. Only include properties when they have values. Example: { ...base, ...(value && { prop: value }) }`,
+                findings
+            );
+        }
+    });
+}
+
+module.exports = { analyzeForbiddenLiterals };

package/scripts/hooks-system/infrastructure/ast/backend/nestjs-patterns-analyzer.js

@@ -0,0 +1,11 @@
+function analyzeNestJSPatterns(sf, findings, pushFinding) {
+  const filePath = sf.getFilePath();
+  const content = sf.getFullText();
+
+  if (!filePath.endsWith('.ts')) return;
+  if (!filePath.includes('.controller.')) return;
+  if (!content.includes('@Controller')) return;
+
+}
+
+module.exports = { analyzeNestJSPatterns };

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

@@ -0,0 +1,392 @@
+const { SyntaxKind } = require('ts-morph');
+
+function analyzeSRP(cls, sf, findings, pushFinding) {
+  const className = cls.getName() || 'AnonymousClass';
+  const methods = cls.getMethods();
+  const properties = cls.getProperties();
+
+  if (methods.length === 0) return;
+
+  const lcom = calculateLCOM(methods, properties);
+
+  const clusters = clusterMethodsBySemanticDomain(methods);
+
+  const constructor = cls.getConstructors()[0];
+  const injectedDependencies = constructor?.getParameters() || [];
+  const dependencyConcerns = analyzeDependencyConcerns(injectedDependencies);
+
+  const imports = sf.getImportDeclarations();
+  const importConcerns = analyzeImportConcerns(imports);
+
+  const violations = [];
+
+  if (lcom > 0.8 && clusters.length >= 3) {
+    violations.push(`Low cohesion (LCOM=${lcom.toFixed(2)}) with ${clusters.length} semantic domains: ${clusters.join(', ')}`);
+  }
+
+  if (dependencyConcerns.length >= 3) {
+    violations.push(`Constructor injects ${dependencyConcerns.length} unrelated concerns: ${dependencyConcerns.join(', ')}`);
+  }
+
+  if (importConcerns.length >= 3) {
+    violations.push(`Imports from ${importConcerns.length} different contexts: ${importConcerns.join(', ')}`);
+  }
+
+  if (violations.length >= 2) {
+    const message = `SRP VIOLATION in ${className}:\n${violations.map(v => '  - ' + v).join('\n')}\n→ Split into multiple classes with single responsibility`;
+    pushFinding('solid.srp.violation', 'critical', sf, cls, message, findings);
+  } else if (violations.length === 1) {
+    const message = `Potential SRP issue in ${className}: ${violations[0]}`;
+    pushFinding('solid.srp.warning', 'high', sf, cls, message, findings);
+  }
+}
+
+function calculateLCOM(methods, properties) {
+  if (methods.length === 0 || properties.length === 0) return 0;
+
+  const methodPropertyUsage = [];
+
+  methods.forEach(method => {
+    const usedProps = new Set();
+    const methodBody = method.getBody();
+    if (!methodBody) return;
+
+    properties.forEach(prop => {
+      const propName = prop.getName();
+      const bodyText = methodBody.getText();
+
+      if (bodyText.includes(`this.${propName}`) || bodyText.includes(`.${propName}`)) {
+        usedProps.add(propName);
+      }
+    });
+
+    methodPropertyUsage.push(usedProps);
+  });
+
+  let P = 0, Q = 0;
+
+  for (let i = 0; i < methodPropertyUsage.length; i++) {
+    for (let j = i + 1; j < methodPropertyUsage.length; j++) {
+      const shared = [...methodPropertyUsage[i]].filter(p => methodPropertyUsage[j].has(p));
+
+      if (shared.length === 0) {
+        P++;
+      } else {
+        Q++;
+      }
+    }
+  }
+
+  const total = P + Q;
+  return total > 0 ? P / total : 0;
+}
+
+function clusterMethodsBySemanticDomain(methods) {
+  const domains = {
+    user: ['user', 'customer', 'account', 'profile'],
+    auth: ['auth', 'login', 'token', 'session', 'password', 'jwt'],
+    payment: ['payment', 'pay', 'charge', 'refund', 'invoice', 'billing'],
+    order: ['order', 'cart', 'checkout', 'purchase'],
+    email: ['email', 'mail', 'send', 'smtp'],
+    notification: ['notification', 'notify', 'alert', 'push'],
+    analytics: ['metric', 'analytic', 'track', 'log', 'event'],
+    storage: ['save', 'load', 'read', 'write', 'persist', 'fetch'],
+    cache: ['cache', 'redis', 'memcache'],
+    validation: ['validate', 'check', 'verify', 'sanitize']
+  };
+
+  const foundDomains = new Set();
+
+  methods.forEach(method => {
+    const methodName = method.getName().toLowerCase();
+
+    for (const [domain, keywords] of Object.entries(domains)) {
+      if (keywords.some(kw => methodName.includes(kw))) {
+        foundDomains.add(domain);
+      }
+    }
+  });
+
+  return Array.from(foundDomains);
+}
+
+function analyzeDependencyConcerns(parameters) {
+  const concerns = new Set();
+
+  parameters.forEach(param => {
+    const typeName = param.getType().getText().toLowerCase();
+
+    if (/user|customer|account/i.test(typeName)) concerns.add('user');
+    if (/auth|jwt|token/i.test(typeName)) concerns.add('auth');
+    if (/payment|billing/i.test(typeName)) concerns.add('payment');
+    if (/order|cart/i.test(typeName)) concerns.add('order');
+    if (/email|mail|notification/i.test(typeName)) concerns.add('notification');
+    if (/repository|database|orm/i.test(typeName)) concerns.add('storage');
+    if (/cache|redis/i.test(typeName)) concerns.add('cache');
+    if (/logger|logging/i.test(typeName)) concerns.add('logging');
+    if (/event|emitter|publisher/i.test(typeName)) concerns.add('events');
+  });
+
+  return Array.from(concerns);
+}
+
+function analyzeImportConcerns(imports) {
+  const concerns = new Set();
+
+  imports.forEach(imp => {
+    const path = imp.getModuleSpecifierValue();
+
+    if (/\/users\/|\/user\//i.test(path)) concerns.add('users-context');
+    if (/\/auth\/|\/authentication\//i.test(path)) concerns.add('auth-context');
+    if (/\/payment\/|\/billing\//i.test(path)) concerns.add('payment-context');
+    if (/\/order\/|\/orders\//i.test(path)) concerns.add('order-context');
+    if (/\/notification\/|\/email\//i.test(path)) concerns.add('notification-context');
+    if (/\/admin\//i.test(path)) concerns.add('admin-context');
+    if (/\/analytics\//i.test(path)) concerns.add('analytics-context');
+  });
+
+  return Array.from(concerns);
+}
+
+function analyzeOCP(cls, sf, findings, pushFinding) {
+  const className = cls.getName() || 'AnonymousClass';
+  const methods = cls.getMethods();
+
+  methods.forEach(method => {
+    const methodName = method.getName();
+    const body = method.getBody();
+    if (!body) return;
+
+    const switches = body.getDescendantsOfKind(SyntaxKind.SwitchStatement);
+    const typeSwitch = switches.filter(sw => {
+      const expr = sw.getExpression().getText();
+      return /type|kind|status|role|category/i.test(expr);
+    });
+
+    if (typeSwitch.length > 0) {
+      const expr = typeSwitch[0].getExpression().getText();
+      pushFinding('solid.ocp.type_switching', 'critical', sf, typeSwitch[0],
+        `OCP violation in ${className}.${methodName}: switch on '${expr}' - use Strategy/Factory pattern instead`, findings);
+    }
+
+    const ifStatements = body.getDescendantsOfKind(SyntaxKind.IfStatement);
+    const typeIfChains = detectTypeIfChains(ifStatements);
+
+    if (typeIfChains.length >= 3) {
+      pushFinding('solid.ocp.if_type_chain', 'critical', sf, method,
+        `OCP violation in ${className}.${methodName}: ${typeIfChains.length} if-else checking types - use polymorphism`, findings);
+    }
+  });
+}
+
+function detectTypeIfChains(ifStatements) {
+  return ifStatements.filter(ifStmt => {
+    const condition = ifStmt.getExpression().getText();
+    return /===\s*['"]|instanceof\s+\w+|typeof\s+.*===/.test(condition);
+  });
+}
+
+function analyzeLSP(cls, sf, findings, pushFinding) {
+  const className = cls.getName() || 'AnonymousClass';
+  const baseClass = cls.getBaseClass();
+
+  if (!baseClass) return;
+
+  const methods = cls.getMethods();
+
+  methods.forEach(method => {
+    const methodName = method.getName();
+    const baseMethod = baseClass.getMethod(methodName);
+
+    if (!baseMethod) return;
+
+    const methodBody = method.getBody();
+    const baseBody = baseMethod.getBody();
+
+    if (!methodBody || !baseBody) return;
+
+    const childThrows = methodBody.getDescendantsOfKind(SyntaxKind.ThrowStatement);
+    const baseThrows = baseBody.getDescendantsOfKind(SyntaxKind.ThrowStatement);
+
+    if (childThrows.length > baseThrows.length) {
+      pushFinding('solid.lsp.additional_exceptions', 'critical', sf, method,
+        `LSP violation in ${className}.${methodName}: throws exceptions not thrown by base class`, findings);
+    }
+
+    const childReturnsNull = methodBody.getText().includes('return null');
+    const baseReturnsNull = baseBody.getText().includes('return null');
+
+    if (childReturnsNull && !baseReturnsNull) {
+      pushFinding('solid.lsp.null_return', 'critical', sf, method,
+        `LSP violation in ${className}.${methodName}: returns null but base doesn't - breaks contract`, findings);
+    }
+
+    const childValidations = countValidations(methodBody);
+    const baseValidations = countValidations(baseBody);
+
+    if (childValidations > baseValidations + 2) {
+      pushFinding('solid.lsp.stricter_preconditions', 'critical', sf, method,
+        `Potential LSP issue in ${className}.${methodName}: stricter preconditions than base (${childValidations} vs ${baseValidations} validations)`, findings);
+    }
+  });
+}
+
+function countValidations(methodBody) {
+  const validationPatterns = [
+    SyntaxKind.IfStatement,
+    SyntaxKind.ThrowStatement
+  ];
+
+  let count = 0;
+  validationPatterns.forEach(kind => {
+    count += methodBody.getDescendantsOfKind(kind).length;
+  });
+
+  return count;
+}
+
+function analyzeISP(sf, findings, pushFinding, project) {
+  const interfaces = sf.getInterfaces();
+
+  interfaces.forEach(iface => {
+    const interfaceName = iface.getName();
+    const interfaceMethods = iface.getMethods();
+
+    if (interfaceMethods.length < 5) return;
+
+    const implementations = findImplementations(iface, project);
+
+    if (implementations.length === 0) return;
+
+    let emptyMethodCount = 0;
+    let totalImplementationMethods = 0;
+
+    implementations.forEach(impl => {
+      interfaceMethods.forEach(ifaceMethod => {
+        const ifaceMethodName = ifaceMethod.getName();
+        const implMethod = impl.getMethod(ifaceMethodName);
+
+        if (!implMethod) return;
+
+        totalImplementationMethods++;
+
+        const body = implMethod.getBody();
+        if (!body) return;
+
+        const bodyText = body.getText().trim();
+
+        if (bodyText === '{}' ||
+            bodyText.includes('throw new NotImplementedError') ||
+            bodyText.includes('throw new Error')) {
+          emptyMethodCount++;
+        }
+
+        if (/^{\s*return\s+(null|undefined);\s*}$/.test(bodyText)) {
+          emptyMethodCount++;
+        }
+      });
+    });
+
+    const emptyPercentage = totalImplementationMethods > 0 ?
+      emptyMethodCount / totalImplementationMethods : 0;
+
+    if (emptyPercentage > 0.3) {
+      pushFinding('solid.isp.fat_interface', 'critical', sf, iface,
+        `ISP violation: ${interfaceName} has ${interfaceMethods.length} methods, ${Math.round(emptyPercentage * 100)}% are unimplemented/empty - split into smaller interfaces`, findings);
+    }
+
+    const methodClusters = clusterMethodsBySemanticDomain(interfaceMethods);
+
+    if (methodClusters.length >= 3) {
+      pushFinding('solid.isp.multiple_concerns', 'critical', sf, iface,
+        `ISP violation: ${interfaceName} mixes ${methodClusters.length} concerns (${methodClusters.join(', ')}) - segregate into focused interfaces`, findings);
+    }
+  });
+}
+
+function findImplementations(iface, project) {
+  const implementations = [];
+  const interfaceName = iface.getName();
+
+  project.getSourceFiles().forEach(sf => {
+    sf.getClasses().forEach(cls => {
+      const implementsClause = cls.getImplements();
+      implementsClause.forEach(impl => {
+        if (impl.getText().includes(interfaceName)) {
+          implementations.push(cls);
+        }
+      });
+    });
+  });
+
+  return implementations;
+}
+
+function analyzeDIP(cls, sf, findings, pushFinding) {
+  if (!sf || typeof sf.getFilePath !== 'function') return;
+  const className = cls.getName() || 'AnonymousClass';
+  const filePath = sf.getFilePath();
+
+  const isDomain = /\/domain\//i.test(filePath);
+
+  if (isDomain) {
+    const imports = sf.getImportDeclarations();
+
+    imports.forEach(imp => {
+      const importPath = imp.getModuleSpecifierValue();
+
+      if (/\/infrastructure\//i.test(importPath) ||
+          /@nestjs|typeorm|mongoose|prisma|express/i.test(importPath)) {
+        pushFinding('solid.dip.domain_depends_infrastructure', 'critical', sf, imp,
+          `DIP VIOLATION: Domain layer importing from Infrastructure/Framework: ${importPath} - Domain should depend only on abstractions`, findings);
+      }
+    });
+  }
+
+  const constructor = cls.getConstructors()[0];
+  if (!constructor) return;
+
+  const parameters = constructor.getParameters();
+
+  parameters.forEach(param => {
+    const paramType = param.getType();
+    const paramTypeName = paramType.getText();
+
+    if (/string|number|boolean|Date|Array|Promise/i.test(paramTypeName)) return;
+
+    const typeSymbol = paramType.getSymbol();
+    if (!typeSymbol) return;
+
+    const declarations = typeSymbol.getDeclarations();
+    if (!declarations || declarations.length === 0) return;
+
+    const isInterface = declarations.some(d => d.getKind() === SyntaxKind.InterfaceDeclaration);
+    const isAbstract = declarations.some(d => {
+      try {
+        if (d.getKind() === SyntaxKind.ClassDeclaration) {
+          return d.isAbstract && d.isAbstract();
+        }
+      } catch (_error) {
+        return false;
+      }
+      return false;
+    });
+
+    if (!isInterface && !isAbstract) {
+      const isFrameworkService = /@Injectable\(\)/.test(declarations[0]?.getText() || '');
+
+      if (!isFrameworkService) {
+        pushFinding('solid.dip.concrete_dependency', 'critical', sf, param,
+          `DIP violation in ${className}: depends on concrete class ${paramTypeName} - inject interface/abstraction instead`, findings);
+      }
+    }
+  });
+}
+
+module.exports = {
+  analyzeSRP,
+  analyzeOCP,
+  analyzeLSP,
+  analyzeISP,
+  analyzeDIP
+};

package/scripts/hooks-system/infrastructure/ast/common/BDDTDDWorkflowRules.js

@@ -0,0 +1,52 @@
+const BDDRules = require('./rules/BDDRules');
+const TDDRules = require('./rules/TDDRules');
+const ImplementationRules = require('./rules/ImplementationRules');
+const WorkflowRules = require('./rules/WorkflowRules');
+
+/**
+ * BDDTDDWorkflowRules
+ *
+ * Fachada/Orquestador que delega la validación de reglas BDD/TDD
+ * a clases especializadas para cumplir con SRP.
+ */
+class BDDTDDWorkflowRules {
+    constructor(findings, projectRoot) {
+        this.findings = findings;
+        this.projectRoot = projectRoot;
+
+        this.bddRules = new BDDRules(projectRoot);
+        this.tddRules = new TDDRules(projectRoot);
+        this.implementationRules = new ImplementationRules(projectRoot);
+        this.workflowRules = new WorkflowRules(projectRoot);
+    }
+
+    analyze() {
+        this.checkBDDFeatureFiles();
+        this.checkTDDTestCoverage();
+        this.checkImplementationAlignment();
+        this.checkWorkflowSequence();
+        this.checkFeatureTestImplementationTriad();
+    }
+
+    checkBDDFeatureFiles() {
+        return this.bddRules.checkBDDFeatureFiles(this.findings);
+    }
+
+    checkTDDTestCoverage() {
+        return this.tddRules.checkTDDTestCoverage(this.findings);
+    }
+
+    checkImplementationAlignment() {
+        return this.implementationRules.checkImplementationAlignment(this.findings);
+    }
+
+    checkWorkflowSequence() {
+        return this.workflowRules.checkWorkflowSequence(this.findings);
+    }
+
+    checkFeatureTestImplementationTriad() {
+        return this.workflowRules.checkFeatureTestImplementationTriad(this.findings);
+    }
+}
+
+module.exports = { BDDTDDWorkflowRules };