pumuki-ast-hooks 5.3.1

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

@@ -0,0 +1,142 @@
+const { SyntaxKind } = require('ts-morph');
+
+function analyzeCleanArchitecture(sf, findings, pushFinding) {
+  if (!sf || typeof sf.getFilePath !== 'function') return;
+  const filePath = sf.getFilePath();
+
+  const layer = detectLayer(filePath);
+  if (!layer) return;
+
+  const imports = sf.getImportDeclarations();
+
+  imports.forEach(imp => {
+    const importPath = imp.getModuleSpecifierValue();
+    const targetLayer = detectLayer(importPath);
+
+    if (layer === 'domain') {
+      const forbiddenImports = [
+        '@nestjs',
+        'typeorm',
+        'mongoose',
+        '@prisma',
+        'express',
+        'fastify',
+        '../infrastructure',
+        '../presentation',
+        '../application'
+      ];
+
+      const violation = forbiddenImports.find(forbidden =>
+        importPath.includes(forbidden)
+      );
+
+      if (violation) {
+        pushFinding('backend.clean.domain_dependency_violation', 'critical', sf, imp,
+          `Domain layer importing ${violation} - Domain must be framework-agnostic and independent. Move to Infrastructure layer.`,
+          findings);
+      }
+    }
+
+    if (layer === 'application' && targetLayer === 'presentation') {
+      pushFinding('backend.clean.application_presentation_violation', 'critical', sf, imp,
+        `Application layer importing from Presentation - violates dependency direction. Invert dependency.`,
+        findings);
+    }
+
+    if (layer === 'infrastructure' && targetLayer === 'presentation') {
+      pushFinding('backend.clean.infrastructure_presentation_violation', 'high', sf, imp,
+        `Infrastructure importing from Presentation - should use dependency inversion.`,
+        findings);
+    }
+
+    if (targetLayer && targetLayer === layer && importPath.includes('../')) {
+      const importing = filePath.split('/').slice(-2).join('/');
+      const imported = importPath.split('/').slice(-2).join('/');
+
+      if (importing !== imported) {
+        pushFinding('backend.clean.circular_dependency', 'high', sf, imp,
+          `Potential circular dependency within ${layer} layer - review module boundaries.`,
+          findings);
+      }
+    }
+  });
+
+  if (layer === 'domain') {
+    const hasCorrectStructure =
+      filePath.includes('/entities/') ||
+      filePath.includes('/repositories/') ||
+      filePath.includes('/value-objects/') ||
+      filePath.includes('/interfaces/');
+
+    if (!hasCorrectStructure) {
+      pushFinding('backend.clean.domain_structure', 'medium', sf, sf,
+        `File in domain/ without correct structure. Use: entities/, repositories/, value-objects/, interfaces/`,
+        findings);
+    }
+  }
+
+  if (layer === 'application') {
+    const hasCorrectStructure =
+      filePath.includes('/use-cases/') ||
+      filePath.includes('/dtos/') ||
+      filePath.includes('/events/');
+
+    if (!hasCorrectStructure) {
+      pushFinding('backend.clean.application_structure', 'medium', sf, sf,
+        `File in application/ without correct structure. Use: use-cases/, dtos/, events/`,
+        findings);
+    }
+  }
+
+  if (layer === 'infrastructure') {
+    const hasCorrectStructure =
+      filePath.includes('/database/') ||
+      filePath.includes('/repositories/') ||
+      filePath.includes('/external-services/') ||
+      filePath.includes('/config/');
+
+    if (!hasCorrectStructure) {
+      pushFinding('backend.clean.infrastructure_structure', 'medium', sf, sf,
+        `File in infrastructure/ without correct structure. Use: database/, repositories/, external-services/, config/`,
+        findings);
+    }
+  }
+
+  if (layer === 'presentation') {
+    const hasCorrectStructure =
+      filePath.includes('/controllers/') ||
+      filePath.includes('/middleware/') ||
+      filePath.includes('/guards/') ||
+      filePath.includes('/interceptors/');
+
+    if (!hasCorrectStructure) {
+      pushFinding('backend.clean.presentation_structure', 'medium', sf, sf,
+        `File in presentation/ without correct structure. Use: controllers/, middleware/, guards/, interceptors/`,
+        findings);
+    }
+  }
+}
+
+function detectLayer(path) {
+  const normalized = path.toLowerCase().replace(/\\/g, '/');
+
+  if (normalized.includes('/domain/')) return 'domain';
+  if (normalized.includes('/application/')) return 'application';
+  if (normalized.includes('/infrastructure/')) return 'infrastructure';
+  if (normalized.includes('/presentation/')) return 'presentation';
+
+  if (normalized.includes('/controllers/')) return 'presentation';
+  if (normalized.includes('/middleware/')) return 'presentation';
+  if (normalized.includes('/guards/')) return 'presentation';
+  if (normalized.includes('/interceptors/')) return 'presentation';
+
+  if (normalized.match(/\/(entities|repositories|value-objects)\//)) return 'domain';
+  if (normalized.match(/\/(use-cases|dtos|events)\//)) return 'application';
+  if (normalized.match(/\/(database|config|external-services)\//)) return 'infrastructure';
+
+  return null;
+}
+
+module.exports = {
+  analyzeCleanArchitecture
+};

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

@@ -0,0 +1,256 @@
+const { SyntaxKind } = require('ts-morph');
+
+function analyzeDDD(sf, findings, pushFinding, project) {
+  if (!sf || typeof sf.getFilePath !== 'function') return;
+  const filePath = sf.getFilePath();
+
+  analyzeRepositoryPattern(sf, filePath, findings, pushFinding, project);
+
+  analyzeUseCasesPattern(sf, filePath, findings, pushFinding);
+
+  analyzeDTOsPattern(sf, filePath, findings, pushFinding);
+
+  analyzeAnemicDomain(sf, filePath, findings, pushFinding);
+
+  analyzeValueObjects(sf, filePath, findings, pushFinding);
+
+  analyzeDomainEvents(sf, filePath, findings, pushFinding);
+}
+
+function analyzeRepositoryPattern(sf, filePath, findings, pushFinding, project) {
+  const classes = sf.getClasses();
+  const interfaces = sf.getInterfaces();
+
+  classes.forEach(cls => {
+    const className = cls.getName() || '';
+
+    if (/Repository$/i.test(className) && !className.startsWith('I')) {
+      if (!filePath.includes('/infrastructure/')) {
+        pushFinding('backend.ddd.repository_wrong_layer', 'critical', sf, cls,
+          `Repository implementation ${className} must be in infrastructure/ layer, not domain/.`,
+          findings);
+      }
+
+      const implementsClause = cls.getImplements();
+      const hasInterface = implementsClause.length > 0;
+
+      if (!hasInterface) {
+        pushFinding('backend.ddd.repository_missing_interface', 'high', sf, cls,
+          `Repository ${className} should implement an interface (I${className}) from domain/.`,
+          findings);
+      }
+
+      const methods = cls.getMethods();
+      const hasComplexLogic = methods.some(method => {
+        const body = method.getBody();
+        if (!body) return false;
+
+        const bodyText = body.getText();
+        const hasBusinessLogic =
+          (bodyText.match(/if\s*\(/g) || []).length > 2 ||
+          bodyText.includes('switch') ||
+          bodyText.includes('for (') && !bodyText.includes('forEach');
+
+        return hasBusinessLogic;
+      });
+
+      if (hasComplexLogic) {
+        pushFinding('backend.ddd.repository_business_logic', 'high', sf, cls,
+          `Repository ${className} contains business logic - move to Use Case. Repositories should only handle CRUD.`,
+          findings);
+      }
+    }
+  });
+
+  interfaces.forEach(iface => {
+    const interfaceName = iface.getName() || '';
+
+    if (/Repository$/i.test(interfaceName)) {
+      if (!filePath.includes('/domain/')) {
+        pushFinding('backend.ddd.repository_interface_wrong_layer', 'critical', sf, iface,
+          `Repository interface ${interfaceName} must be in domain/repositories/, not infrastructure/.`,
+          findings);
+      }
+    }
+  });
+}
+
+function analyzeUseCasesPattern(sf, filePath, findings, pushFinding) {
+  if (/UseCase\.ts$/i.test(filePath)) {
+    const classes = sf.getClasses();
+
+    if (classes.length === 0) {
+      pushFinding('backend.ddd.usecase_missing_class', 'high', sf, sf,
+        `UseCase file without class - create class matching filename.`,
+        findings);
+      return;
+    }
+
+    if (classes.length > 1) {
+      pushFinding('backend.ddd.usecase_multiple_classes', 'medium', sf, sf,
+        `UseCase file with multiple classes - one use case per file for clarity.`,
+        findings);
+    }
+
+    const useCaseClass = classes[0];
+    const className = useCaseClass.getName() || '';
+
+    if (!/UseCase$/i.test(className)) {
+      pushFinding('backend.ddd.usecase_naming', 'medium', sf, useCaseClass,
+        `Use Case class should end with 'UseCase': ${className}UseCase`,
+        findings);
+    }
+
+    const methods = useCaseClass.getMethods();
+    const hasExecuteMethod = methods.some(m =>
+      /^(execute|handle|run)$/i.test(m.getName())
+    );
+
+    if (!hasExecuteMethod) {
+      pushFinding('backend.ddd.usecase_missing_execute', 'medium', sf, useCaseClass,
+        `Use Case should have execute(), handle() or run() method as entry point.`,
+        findings);
+    }
+
+    const constructor = useCaseClass.getConstructors()[0];
+    if (constructor) {
+      const params = constructor.getParameters();
+      const hasRepositories = params.some(p => {
+        const typeName = p.getType().getText();
+        return /Repository/i.test(typeName);
+      });
+
+      if (!hasRepositories && methods.length > 0) {
+        pushFinding('backend.ddd.usecase_no_repository', 'low', sf, constructor,
+          `Use Case without repository injection - consider if it needs data access.`,
+          findings);
+      }
+    }
+  }
+}
+
+function analyzeDTOsPattern(sf, filePath, findings, pushFinding) {
+  if (/\.dto\.ts$/i.test(filePath) || filePath.includes('/dtos/')) {
+    const classes = sf.getClasses();
+
+    classes.forEach(cls => {
+      const className = cls.getName() || '';
+
+      if (!/Dto$/i.test(className)) {
+        pushFinding('backend.ddd.dto_naming', 'medium', sf, cls,
+          `DTO class should end with 'Dto': ${className}Dto`,
+          findings);
+      }
+
+      const properties = cls.getProperties();
+      const hasValidationDecorators = properties.some(prop => {
+        const decorators = prop.getDecorators();
+        return decorators.some(d => {
+          const decoratorName = d.getName();
+          return /^(IsString|IsNumber|IsEmail|IsBoolean|IsArray|IsOptional|IsNotEmpty|Min|Max|Length|Matches|ValidateNested)$/i.test(decoratorName);
+        });
+      });
+
+      if (properties.length > 0 && !hasValidationDecorators) {
+        pushFinding('backend.ddd.dto_missing_validation', 'high', sf, cls,
+          `DTO ${className} without class-validator decorators - add @IsString(), @IsEmail(), etc. for validation.`,
+          findings);
+      }
+    });
+  }
+}
+
+function analyzeAnemicDomain(sf, filePath, findings, pushFinding) {
+  if (!filePath.includes('/domain/') && !filePath.includes('/entities/')) return;
+
+  const classes = sf.getClasses();
+
+  classes.forEach(cls => {
+    const className = cls.getName() || '';
+
+    if (!/Entity$/i.test(className) && !filePath.includes('/entities/')) return;
+
+    const methods = cls.getMethods();
+    const properties = cls.getProperties();
+
+    const businessMethods = methods.filter(m => {
+      const name = m.getName();
+      return !/^(get|set|constructor)/.test(name) &&
+             name !== 'toString' &&
+             name !== 'toJSON';
+    });
+
+    if (properties.length > 3 && businessMethods.length === 0) {
+      pushFinding('backend.ddd.anemic_entity', 'high', sf, cls,
+        `Anemic entity ${className} (${properties.length} properties, 0 business methods) - add domain logic.`,
+        findings);
+    }
+  });
+}
+
+function analyzeValueObjects(sf, filePath, findings, pushFinding) {
+  if (!/VO\.ts$|ValueObject\.ts$/i.test(filePath) && !filePath.includes('/value-objects/')) return;
+
+  const classes = sf.getClasses();
+
+  classes.forEach(cls => {
+    const properties = cls.getProperties();
+
+    properties.forEach(prop => {
+      const hasReadonly = prop.hasModifier(SyntaxKind.ReadonlyKeyword);
+
+      if (!hasReadonly) {
+        pushFinding('backend.ddd.value_object_mutable', 'high', sf, prop,
+          `Value Object property ${prop.getName()} should be readonly - Value Objects must be immutable.`,
+          findings);
+      }
+    });
+  });
+}
+
+function analyzeDomainEvents(sf, filePath, findings, pushFinding) {
+  const classes = sf.getClasses();
+
+  classes.forEach(cls => {
+    const className = cls.getName() || '';
+
+    if (/Event$/i.test(className)) {
+      if (!filePath.includes('/events/')) {
+        pushFinding('backend.ddd.event_wrong_location', 'medium', sf, cls,
+          `Domain Event ${className} should be in application/events/ directory.`,
+          findings);
+      }
+
+      const properties = cls.getProperties();
+      const mutableProps = properties.filter(p =>
+        !p.hasModifier(SyntaxKind.ReadonlyKeyword)
+      );
+
+      if (mutableProps.length > 0) {
+        pushFinding('backend.ddd.event_mutable', 'medium', sf, cls,
+          `Domain Event ${className} has mutable properties - events should be immutable.`,
+          findings);
+      }
+    }
+  });
+}
+
+function detectLayer(path) {
+  const normalized = path.toLowerCase().replace(/\\/g, '/');
+
+  if (normalized.includes('/domain/')) return 'domain';
+  if (normalized.includes('/application/')) return 'application';
+  if (normalized.includes('/infrastructure/')) return 'infrastructure';
+  if (normalized.includes('/presentation/')) return 'presentation';
+
+  if (normalized.match(/\/(controllers|middleware|guards|interceptors)\//)) return 'presentation';
+  if (normalized.match(/\/(entities|repositories|value-objects)\//)) return 'domain';
+  if (normalized.match(/\/(use-cases|dtos|events)\//)) return 'application';
+  if (normalized.match(/\/(database|config|external-services)\//)) return 'infrastructure';
+
+  return null;
+}
+
+module.exports = {
+  analyzeDDD
+};

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

@@ -0,0 +1,70 @@
+const path = require('path');
+
+function analyzeFeatureFirst(sf, findings, pushFinding) {
+  if (!sf || typeof sf.getFilePath !== 'function') return;
+  const filePath = sf.getFilePath();
+
+  const feature = detectFeature(filePath);
+  if (!feature) return;
+
+  const imports = sf.getImportDeclarations();
+
+  imports.forEach(imp => {
+    const importPath = imp.getModuleSpecifierValue();
+    const targetFeature = detectFeature(importPath);
+
+    if (targetFeature && targetFeature !== feature) {
+      const isSharedModule = /\/(core|common|shared)\//.test(importPath);
+
+      if (!isSharedModule) {
+        pushFinding('backend.feature.cross_feature_import', 'high', sf, imp,
+          `Feature '${feature}' importing from feature '${targetFeature}' - features should be independent. Move shared code to core/.`,
+          findings);
+      }
+    }
+  });
+
+  checkFeatureStructure(filePath, feature, findings, pushFinding);
+}
+
+function detectFeature(filePath) {
+  const normalized = filePath.toLowerCase().replace(/\\/g, '/');
+
+  
+  
+  
+  
+
+  const match = normalized.match(/\/(?:src|modules|features?)\/([^\/]+)\//);
+  if (!match) return null;
+
+  const featureName = match[1];
+
+  const nonFeatures = [
+    'common', 'core', 'shared', 'utils', 'helpers',
+    'domain', 'application', 'infrastructure', 'presentation',
+    'config', 'database', 'migrations', 'seeders'
+  ];
+
+  if (nonFeatures.includes(featureName)) return null;
+
+  return featureName;
+}
+
+function checkFeatureStructure(filePath, feature, findings, pushFinding) {
+
+  const fileName = path.basename(filePath);
+
+  const expectedPrefix = feature.toLowerCase();
+  const actualPrefix = fileName.split('.')[0].toLowerCase();
+
+  const isInSubdir = filePath.includes(`/${feature}/`) &&
+                     filePath.split(`/${feature}/`)[1].includes('/');
+
+  if (!isInSubdir && !actualPrefix.startsWith(expectedPrefix)) {
+  }
+}
+
+module.exports = {
+  analyzeFeatureFirst
+};