pumuki-ast-hooks 5.3.1

package/scripts/hooks-system/infrastructure/ast/backend/analyzers/BackendArchitectureDetector.js

@@ -0,0 +1,141 @@
+const fs = require('fs');
+const path = require('path');
+const glob = require('glob');
+
+const { FeatureFirstCleanDetector } = require('./detectors/FeatureFirstCleanDetector');
+const { CleanArchitectureDetector } = require('./detectors/CleanArchitectureDetector');
+const { OnionArchitectureDetector } = require('./detectors/OnionArchitectureDetector');
+const { LayeredArchitectureDetector } = require('./detectors/LayeredArchitectureDetector');
+const { CQRSDetector } = require('./detectors/CQRSDetector');
+const { MVCDetector } = require('./detectors/MVCDetector');
+
+class BackendArchitectureDetector {
+  constructor(projectRoot) {
+    this.projectRoot = projectRoot;
+    this.patterns = {
+      featureFirstClean: 0,
+      cleanArchitecture: 0,
+      onionArchitecture: 0,
+      layeredArchitecture: 0,
+      cqrs: 0,
+      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('[Backend Architecture] Manual configuration loaded from .ast-architecture.json');
+        return config.backend || null;
+      }
+    } catch (error) {
+      console.warn('[Backend Architecture] Error loading .ast-architecture.json:', error.message);
+    }
+    return null;
+  }
+
+  detect() {
+    if (this.manualConfig && this.manualConfig.architecturePattern) {
+      const manualPattern = this.manualConfig.architecturePattern;
+      console.log(`[Backend Architecture] Using manual configuration: ${manualPattern}`);
+      return manualPattern;
+    }
+
+    const tsFiles = glob.sync('**/*.ts', {
+      cwd: this.projectRoot,
+      ignore: ['**/node_modules/**', '**/dist/**', '**/build/**', '**/*.spec.ts', '**/*.test.ts']
+    });
+
+    if (tsFiles.length === 0) {
+      return 'UNKNOWN';
+    }
+
+    const featureFirstDetector = new FeatureFirstCleanDetector(this.projectRoot);
+    this.patterns.featureFirstClean = featureFirstDetector.detect(tsFiles);
+    console.log(`[Architecture Detection] Feature-First + Clean + DDD score: ${this.patterns.featureFirstClean}`);
+
+    const cleanDetector = new CleanArchitectureDetector(this.projectRoot);
+    this.patterns.cleanArchitecture = cleanDetector.detect(tsFiles);
+
+    const onionDetector = new OnionArchitectureDetector(this.projectRoot);
+    this.patterns.onionArchitecture = onionDetector.detect(tsFiles, this.patterns.cleanArchitecture);
+
+    const layeredDetector = new LayeredArchitectureDetector(this.projectRoot);
+    this.patterns.layeredArchitecture = layeredDetector.detect(tsFiles);
+
+    const cqrsDetector = new CQRSDetector(this.projectRoot);
+    this.patterns.cqrs = cqrsDetector.detect(tsFiles);
+
+    const mvcDetector = new MVCDetector(this.projectRoot);
+    this.patterns.mvc = mvcDetector.detect(tsFiles);
+
+    return this.getDominantPattern();
+  }
+
+  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',
+      cleanArchitecture: 'CLEAN_ARCHITECTURE',
+      onionArchitecture: 'ONION_ARCHITECTURE',
+      layeredArchitecture: 'LAYERED_ARCHITECTURE',
+      cqrs: 'CQRS',
+      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 Backend project.',
+        recommendation: 'Define project architecture before continuing. Recommended: Feature-First + Clean + DDD, or Clean Architecture.'
+      });
+    }
+
+    if (this.patterns.mvc > 0 && dominantPattern !== 'MVC') {
+      warnings.push({
+        severity: 'MEDIUM',
+        message: 'MVC anti-pattern detected. Consider migrating to Clean Architecture.',
+        recommendation: 'Refactor controllers to use services/use cases and separate business logic.'
+      });
+    }
+
+    if (dominantPattern === 'LAYERED_ARCHITECTURE') {
+      warnings.push({
+        severity: 'LOW',
+        message: 'Layered Architecture detected. Consider migrating to Clean Architecture for better testability and maintainability.',
+        recommendation: 'Introduce domain layer and use dependency inversion.'
+      });
+    }
+
+    return {
+      pattern: dominantPattern,
+      confidence,
+      scores: { ...this.patterns },
+      warnings
+    };
+  }
+}
+
+module.exports = { BackendArchitectureDetector };

package/scripts/hooks-system/infrastructure/ast/backend/analyzers/BackendPatternDetector.js

@@ -0,0 +1,23 @@
+const fs = require('fs');
+const path = require('path');
+
+class BackendPatternDetector {
+  constructor(projectRoot) {
+    this.projectRoot = projectRoot;
+  }
+
+  readFile(relativePath) {
+    try {
+      const fullPath = path.join(this.projectRoot, relativePath);
+      return fs.readFileSync(fullPath, 'utf-8');
+    } catch (error) {
+      if (process.env.DEBUG) {
+        console.debug(`[BackendPatternDetector] Failed to read file ${relativePath}: ${error.message}`);
+      }
+      return '';
+    }
+  }
+}
+
+module.exports = { BackendPatternDetector };
+

package/scripts/hooks-system/infrastructure/ast/backend/analyzers/__tests__/BackendArchitectureDetector.spec.js

@@ -0,0 +1,239 @@
+const fs = require('fs');
+const path = require('path');
+const glob = require('glob');
+
+jest.mock('fs');
+jest.mock('glob');
+
+jest.mock('../detectors/FeatureFirstCleanDetector', () => ({
+  FeatureFirstCleanDetector: jest.fn()
+}));
+jest.mock('../detectors/CleanArchitectureDetector', () => ({
+  CleanArchitectureDetector: jest.fn()
+}));
+jest.mock('../detectors/OnionArchitectureDetector', () => ({
+  OnionArchitectureDetector: jest.fn()
+}));
+jest.mock('../detectors/LayeredArchitectureDetector', () => ({
+  LayeredArchitectureDetector: jest.fn()
+}));
+jest.mock('../detectors/CQRSDetector', () => ({
+  CQRSDetector: jest.fn()
+}));
+jest.mock('../detectors/MVCDetector', () => ({
+  MVCDetector: jest.fn()
+}));
+
+const { FeatureFirstCleanDetector } = require('../detectors/FeatureFirstCleanDetector');
+const { CleanArchitectureDetector } = require('../detectors/CleanArchitectureDetector');
+const { OnionArchitectureDetector } = require('../detectors/OnionArchitectureDetector');
+const { LayeredArchitectureDetector } = require('../detectors/LayeredArchitectureDetector');
+const { CQRSDetector } = require('../detectors/CQRSDetector');
+const { MVCDetector } = require('../detectors/MVCDetector');
+
+const { BackendArchitectureDetector } = require('../BackendArchitectureDetector');
+
+function makeSUT(projectRoot = '/test/project') {
+  return new BackendArchitectureDetector(projectRoot);
+}
+
+describe('BackendArchitectureDetector', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    fs.existsSync.mockReturnValue(false);
+  });
+
+  describe('constructor', () => {
+    it('should initialize with project root', () => {
+      const detector = makeSUT('/test/project');
+      expect(detector.projectRoot).toBe('/test/project');
+      expect(detector.patterns).toBeDefined();
+    });
+
+    it('should initialize patterns with zero scores', () => {
+      const detector = makeSUT();
+      expect(detector.patterns.featureFirstClean).toBe(0);
+      expect(detector.patterns.cleanArchitecture).toBe(0);
+      expect(detector.patterns.onionArchitecture).toBe(0);
+      expect(detector.patterns.layeredArchitecture).toBe(0);
+      expect(detector.patterns.cqrs).toBe(0);
+      expect(detector.patterns.mvc).toBe(0);
+    });
+  });
+
+  describe('loadManualConfig', () => {
+    it('should load manual config from .ast-architecture.json', () => {
+      const configPath = path.join('/test/project', '.ast-architecture.json');
+      const config = {
+        backend: {
+          architecturePattern: 'CLEAN_ARCHITECTURE'
+        }
+      };
+      fs.existsSync.mockReturnValue(true);
+      fs.readFileSync.mockReturnValue(JSON.stringify(config));
+      const detector = makeSUT('/test/project');
+      expect(detector.manualConfig).toBeDefined();
+      expect(detector.manualConfig.architecturePattern).toBe('CLEAN_ARCHITECTURE');
+    });
+
+    it('should return null when config file does not exist', () => {
+      fs.existsSync.mockReturnValue(false);
+      const detector = makeSUT();
+      expect(detector.manualConfig).toBeNull();
+    });
+
+    it('should return null when config file is invalid JSON', () => {
+      const configPath = path.join('/test/project', '.ast-architecture.json');
+      fs.existsSync.mockReturnValue(true);
+      fs.readFileSync.mockReturnValue('invalid json');
+      const detector = makeSUT('/test/project');
+      expect(detector.manualConfig).toBeNull();
+    });
+  });
+
+  describe('detect', () => {
+    it('should return manual pattern when config exists', () => {
+      const config = {
+        backend: {
+          architecturePattern: 'FEATURE_FIRST_CLEAN_DDD'
+        }
+      };
+      fs.existsSync.mockReturnValue(true);
+      fs.readFileSync.mockReturnValue(JSON.stringify(config));
+      const detector = makeSUT('/test/project');
+      const result = detector.detect();
+      expect(result).toBe('FEATURE_FIRST_CLEAN_DDD');
+    });
+
+    it('should return UNKNOWN when no TypeScript files found', () => {
+      glob.sync.mockReturnValue([]);
+      const detector = makeSUT();
+      const result = detector.detect();
+      expect(result).toBe('UNKNOWN');
+    });
+
+    it('should detect patterns when TypeScript files exist', () => {
+      glob.sync.mockReturnValue(['src/app.ts', 'src/service.ts']);
+      const featureFirstDetector = { detect: jest.fn().mockReturnValue(10) };
+      const cleanDetector = { detect: jest.fn().mockReturnValue(5) };
+      const onionDetector = { detect: jest.fn().mockReturnValue(3) };
+      const layeredDetector = { detect: jest.fn().mockReturnValue(2) };
+      const cqrsDetector = { detect: jest.fn().mockReturnValue(1) };
+      const mvcDetector = { detect: jest.fn().mockReturnValue(0) };
+      FeatureFirstCleanDetector.mockImplementation(() => featureFirstDetector);
+      CleanArchitectureDetector.mockImplementation(() => cleanDetector);
+      OnionArchitectureDetector.mockImplementation(() => onionDetector);
+      LayeredArchitectureDetector.mockImplementation(() => layeredDetector);
+      CQRSDetector.mockImplementation(() => cqrsDetector);
+      MVCDetector.mockImplementation(() => mvcDetector);
+      const detector = makeSUT();
+      const result = detector.detect();
+      expect(result).toBe('FEATURE_FIRST_CLEAN_DDD');
+    });
+
+    it('should call all detectors with correct parameters', () => {
+      const files = ['src/app.ts', 'src/service.ts'];
+      glob.sync.mockReturnValue(files);
+      const featureFirstDetector = { detect: jest.fn().mockReturnValue(10) };
+      const cleanDetector = { detect: jest.fn().mockReturnValue(5) };
+      const onionDetector = { detect: jest.fn().mockReturnValue(3) };
+      const layeredDetector = { detect: jest.fn().mockReturnValue(2) };
+      const cqrsDetector = { detect: jest.fn().mockReturnValue(1) };
+      const mvcDetector = { detect: jest.fn().mockReturnValue(0) };
+      FeatureFirstCleanDetector.mockImplementation(() => featureFirstDetector);
+      CleanArchitectureDetector.mockImplementation(() => cleanDetector);
+      OnionArchitectureDetector.mockImplementation(() => onionDetector);
+      LayeredArchitectureDetector.mockImplementation(() => layeredDetector);
+      CQRSDetector.mockImplementation(() => cqrsDetector);
+      MVCDetector.mockImplementation(() => mvcDetector);
+      const detector = makeSUT();
+      detector.detect();
+      expect(featureFirstDetector.detect).toHaveBeenCalledWith(files);
+      expect(cleanDetector.detect).toHaveBeenCalledWith(files);
+      expect(onionDetector.detect).toHaveBeenCalledWith(files, 5);
+      expect(layeredDetector.detect).toHaveBeenCalledWith(files);
+      expect(cqrsDetector.detect).toHaveBeenCalledWith(files);
+      expect(mvcDetector.detect).toHaveBeenCalledWith(files);
+    });
+  });
+
+  describe('getDominantPattern', () => {
+    it('should return UNKNOWN when all scores are zero', () => {
+      const detector = makeSUT();
+      const result = detector.getDominantPattern();
+      expect(result).toBe('UNKNOWN');
+    });
+
+    it('should return FEATURE_FIRST_CLEAN_DDD when featureFirstClean has highest score', () => {
+      const detector = makeSUT();
+      detector.patterns.featureFirstClean = 10;
+      detector.patterns.cleanArchitecture = 5;
+      const result = detector.getDominantPattern();
+      expect(result).toBe('FEATURE_FIRST_CLEAN_DDD');
+    });
+
+    it('should return CLEAN_ARCHITECTURE when cleanArchitecture has highest score', () => {
+      const detector = makeSUT();
+      detector.patterns.cleanArchitecture = 10;
+      detector.patterns.featureFirstClean = 5;
+      const result = detector.getDominantPattern();
+      expect(result).toBe('CLEAN_ARCHITECTURE');
+    });
+
+    it('should return ONION_ARCHITECTURE when onionArchitecture has highest score', () => {
+      const detector = makeSUT();
+      detector.patterns.onionArchitecture = 10;
+      detector.patterns.cleanArchitecture = 5;
+      const result = detector.getDominantPattern();
+      expect(result).toBe('ONION_ARCHITECTURE');
+    });
+
+    it('should return LAYERED_ARCHITECTURE when layeredArchitecture has highest score', () => {
+      const detector = makeSUT();
+      detector.patterns.layeredArchitecture = 10;
+      detector.patterns.cleanArchitecture = 5;
+      const result = detector.getDominantPattern();
+      expect(result).toBe('LAYERED_ARCHITECTURE');
+    });
+
+    it('should return CQRS when cqrs has highest score', () => {
+      const detector = makeSUT();
+      detector.patterns.cqrs = 10;
+      detector.patterns.cleanArchitecture = 5;
+      const result = detector.getDominantPattern();
+      expect(result).toBe('CQRS');
+    });
+
+    it('should return MVC when mvc has highest score', () => {
+      const detector = makeSUT();
+      detector.patterns.mvc = 10;
+      detector.patterns.cleanArchitecture = 5;
+      const result = detector.getDominantPattern();
+      expect(result).toBe('MVC');
+    });
+  });
+
+  describe('getDetectionSummary', () => {
+    it('should return summary with all pattern scores', () => {
+      const detector = makeSUT();
+      detector.patterns.featureFirstClean = 10;
+      detector.patterns.cleanArchitecture = 5;
+      detector.patterns.onionArchitecture = 3;
+      const summary = detector.getDetectionSummary();
+      expect(summary).toBeDefined();
+      expect(summary.scores).toBeDefined();
+      expect(summary.scores.featureFirstClean).toBe(10);
+      expect(summary.scores.cleanArchitecture).toBe(5);
+      expect(summary.pattern).toBeDefined();
+      expect(summary.confidence).toBeDefined();
+    });
+
+    it('should include warnings when pattern is UNKNOWN', () => {
+      const detector = makeSUT();
+      const summary = detector.getDetectionSummary();
+      expect(summary.warnings).toBeDefined();
+      expect(summary.warnings.length).toBeGreaterThan(0);
+    });
+  });
+});
+

package/scripts/hooks-system/infrastructure/ast/backend/analyzers/__tests__/BackendPatternDetector.spec.js

@@ -0,0 +1,58 @@
+const { BackendPatternDetector } = require('../BackendPatternDetector');
+const fs = require('fs');
+const path = require('path');
+
+jest.mock('fs');
+
+function makeSUT(projectRoot = '/test/project') {
+  return new BackendPatternDetector(projectRoot);
+}
+
+describe('BackendPatternDetector', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe('constructor', () => {
+    it('should initialize with project root', () => {
+      const detector = makeSUT('/test/project');
+      expect(detector.projectRoot).toBe('/test/project');
+    });
+  });
+
+  describe('readFile', () => {
+    it('should read file content successfully', () => {
+      const filePath = 'src/app.ts';
+      const content = 'export class App {}';
+      fs.readFileSync.mockReturnValue(content);
+      const detector = makeSUT();
+      const result = detector.readFile(filePath);
+      expect(result).toBe(content);
+      expect(fs.readFileSync).toHaveBeenCalledWith(
+        path.join('/test/project', filePath),
+        'utf-8'
+      );
+    });
+
+    it('should return empty string when file read fails', () => {
+      const filePath = 'src/nonexistent.ts';
+      fs.readFileSync.mockImplementation(() => {
+        throw new Error('File not found');
+      });
+      const detector = makeSUT();
+      const result = detector.readFile(filePath);
+      expect(result).toBe('');
+    });
+
+    it('should handle errors gracefully', () => {
+      const filePath = 'src/error.ts';
+      fs.readFileSync.mockImplementation(() => {
+        throw new Error('Permission denied');
+      });
+      const detector = makeSUT();
+      const result = detector.readFile(filePath);
+      expect(result).toBe('');
+    });
+  });
+});
+

package/scripts/hooks-system/infrastructure/ast/backend/analyzers/detectors/CQRSDetector.js

@@ -0,0 +1,41 @@
+const { BackendPatternDetector } = require('../BackendPatternDetector');
+
+class CQRSDetector extends BackendPatternDetector {
+  detect(files) {
+    let score = 0;
+
+    const cqrsIndicators = [
+      '/commands/',
+      '/queries/',
+      'CommandHandler',
+      'QueryHandler',
+      'ICommandHandler',
+      'IQueryHandler',
+      'Command<',
+      'Query<'
+    ];
+
+    files.forEach(file => {
+      const content = this.readFile(file);
+      const matches = cqrsIndicators.filter(indicator =>
+        file.includes(indicator) || content.includes(indicator)
+      ).length;
+
+      if (matches >= 2) {
+        score += matches * 2;
+      }
+    });
+
+    const hasCommands = files.some(f => f.includes('/commands/'));
+    const hasQueries = files.some(f => f.includes('/queries/'));
+
+    if (hasCommands && hasQueries) {
+      score += 10;
+    }
+
+    return score;
+  }
+}
+
+module.exports = { CQRSDetector };
+

package/scripts/hooks-system/infrastructure/ast/backend/analyzers/detectors/CleanArchitectureDetector.js

@@ -0,0 +1,52 @@
+const { BackendPatternDetector } = require('../BackendPatternDetector');
+
+class CleanArchitectureDetector extends BackendPatternDetector {
+  detect(files) {
+    let score = 0;
+
+    const hasDomain = files.some(f => f.includes('/domain/'));
+    const hasApplication = files.some(f => f.includes('/application/'));
+    const hasInfrastructure = files.some(f => f.includes('/infrastructure/'));
+
+    if (hasDomain && hasApplication && hasInfrastructure) {
+      score += 10;
+    }
+
+    const domainRepos = files.filter(f => {
+      if (!f.includes('/domain/') || !f.includes('Repository')) return false;
+      const content = this.readFile(f);
+      return content.includes('interface ') || content.includes('abstract class ');
+    });
+
+    const infraRepos = files.filter(f => {
+      if (!f.includes('/infrastructure/') || !f.includes('Repository')) return false;
+      const content = this.readFile(f);
+      return content.includes('class ') && content.includes('implements ');
+    });
+
+    if (domainRepos.length > 0 && infraRepos.length > 0) {
+      score += (domainRepos.length + infraRepos.length) * 2;
+    }
+
+    const useCases = files.filter(f =>
+      f.includes('/use-cases/') || f.includes('UseCase.ts') || (f.includes('/application/') && this.readFile(f).includes('UseCase'))
+    );
+
+    if (useCases.length > 0) {
+      score += useCases.length * 2;
+    }
+
+    const interfaces = files.filter(f => 
+      f.includes('/domain/') && (this.readFile(f).includes('interface ') || this.readFile(f).includes('abstract '))
+    );
+
+    if (interfaces.length > 0) {
+      score += interfaces.length;
+    }
+
+    return score;
+  }
+}
+
+module.exports = { CleanArchitectureDetector };
+

package/scripts/hooks-system/infrastructure/ast/backend/analyzers/detectors/FeatureFirstCleanDetector.js

@@ -0,0 +1,74 @@
+const { BackendPatternDetector } = require('../BackendPatternDetector');
+
+class FeatureFirstCleanDetector extends BackendPatternDetector {
+  detect(files) {
+    let score = 0;
+
+    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') ||
+      f.includes('ValueObject.ts')
+    );
+
+    if (hasFeaturesFolders) {
+      score += 10;
+    }
+
+    if (foundCleanFolders.length >= 3) {
+      score += foundCleanFolders.length * 3;
+    }
+
+    if (dddConcepts.length > 0) {
+      score += 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) {
+      score += featureNames.size * 4;
+    }
+
+    files.forEach(file => {
+      const content = this.readFile(file);
+
+      if (file.includes('/domain/') && content.includes('interface ') && content.includes('Repository')) {
+        score += 3;
+      }
+
+      if (file.includes('/application/') || file.includes('/use-cases/')) {
+        if (content.includes('UseCase') || content.includes('execute(')) {
+          score += 2;
+        }
+      }
+
+      if (content.includes('Event') && (file.includes('/domain/') || file.includes('/application/'))) {
+        score += 2;
+      }
+    });
+
+    return score;
+  }
+}
+
+module.exports = { FeatureFirstCleanDetector };
+

package/scripts/hooks-system/infrastructure/ast/backend/analyzers/detectors/LayeredArchitectureDetector.js

@@ -0,0 +1,25 @@
+const { BackendPatternDetector } = require('../BackendPatternDetector');
+
+class LayeredArchitectureDetector extends BackendPatternDetector {
+  detect(files) {
+    let score = 0;
+
+    const hasControllers = files.some(f => f.includes('/controllers/') || f.includes('.controller.ts'));
+    const hasServices = files.some(f => f.includes('/services/') || f.includes('.service.ts'));
+    const hasRepositories = files.some(f => f.includes('/repositories/') || f.includes('.repository.ts'));
+    const hasDomain = files.some(f => f.includes('/domain/'));
+
+    if (hasControllers && hasServices && hasRepositories) {
+      if (!hasDomain) {
+        score += 10;
+      } else {
+        score -= 5;
+      }
+    }
+
+    return score;
+  }
+}
+
+module.exports = { LayeredArchitectureDetector };
+

package/scripts/hooks-system/infrastructure/ast/backend/analyzers/detectors/MVCDetector.js

@@ -0,0 +1,32 @@
+const { BackendPatternDetector } = require('../BackendPatternDetector');
+
+class MVCDetector extends BackendPatternDetector {
+  detect(files) {
+    let score = 0;
+
+    files.forEach(file => {
+      if (!file.includes('controller') && !file.includes('Controller')) return;
+      
+      const content = this.readFile(file);
+      
+      if (content.includes('@InjectRepository') || content.includes('TypeORM') || content.includes('Prisma')) {
+        const hasService = files.some(f => 
+          f.includes('.service.ts') && !f.includes('controller')
+        );
+        
+        if (!hasService) {
+          score += 3;
+        }
+      }
+
+      if (content.match(/async\s+\w+\(.*\)\s*{[\s\S]{0,500}if\s*\(.*\)\s*{[\s\S]{0,500}if\s*\(.*\)\s*{/)) {
+        score += 2;
+      }
+    });
+
+    return score;
+  }
+}
+
+module.exports = { MVCDetector };
+