pumuki-ast-hooks 5.3.1

package/scripts/hooks-system/infrastructure/ast/frontend/analyzers/FrontendForbiddenLiteralsAnalyzer.js

@@ -0,0 +1,257 @@
+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];
+
+class FrontendForbiddenLiteralsAnalyzer {
+    analyze(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);
+        const objectLiteralExpressions = sf.getDescendantsOfKind(SyntaxKind.ObjectLiteralExpression);
+
+        this.analyzeStringLiterals(stringLiterals, sf, findings, pushFinding);
+        this.analyzeNumericLiterals(numericLiterals, sf, findings, pushFinding);
+        this.analyzeTypeCasts(asExpressions, sf, findings, pushFinding);
+        this.analyzeNullishCoalescing(nullishCoalescing, sf, findings, pushFinding);
+        this.analyzeConditionalExpressions(conditionalExpressions, sf, findings, pushFinding);
+        this.analyzeObjectLiterals(objectLiteralExpressions, sf, findings, pushFinding);
+    }
+
+    analyzeStringLiterals(stringLiterals, sf, findings, pushFinding) {
+        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|tsx|js|jsx)$/i.test(sf.getFilePath());
+
+            if (isInStringTemplate || isInConsoleLog || isInTestFile) return;
+
+            if (FORBIDDEN_STRING_LITERALS.includes(value)) {
+                pushFinding(
+                    'frontend.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(
+                    'frontend.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
+                );
+            }
+        });
+    }
+
+    analyzeNumericLiterals(numericLiterals, sf, findings, pushFinding) {
+        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|tsx|js|jsx)$/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(
+                        'frontend.types.magic_number',
+                        'high',
+                        literal,
+                        sf,
+                        `Magic number ${value} detected. Use named constants (e.g., INITIAL_COUNT, INCREMENT_VALUE) instead of magic numbers.`,
+                        findings
+                    );
+                }
+            }
+        });
+    }
+
+    analyzeTypeCasts(asExpressions, sf, findings, pushFinding) {
+        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|tsx|js|jsx)$/i.test(sf.getFilePath());
+            const isTypeAssertion = /as\s+(UserRole|OrderStatus|UserStatus|AlertStatus)/i.test(fullLine);
+
+            if (isInTestFile || isTypeAssertion) return;
+
+            pushFinding(
+                'frontend.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
+            );
+        });
+    }
+
+    analyzeNullishCoalescing(nullishCoalescing, sf, findings, pushFinding) {
+        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|tsx|js|jsx)$/i.test(sf.getFilePath());
+            const hasNull = /null/.test(fullLine);
+            const hasUndefined = /undefined/.test(fullLine);
+
+            if (isInTestFile) return;
+
+            if (hasNull || hasUndefined) {
+                pushFinding(
+                    'frontend.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
+                );
+            }
+        });
+    }
+
+    analyzeConditionalExpressions(conditionalExpressions, sf, findings, pushFinding) {
+        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|tsx|js|jsx)$/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(
+                    'frontend.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
+                );
+            }
+        });
+    }
+
+    analyzeObjectLiterals(objectLiteralExpressions, sf, findings, pushFinding) {
+        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|tsx|js|jsx)$/i.test(sf.getFilePath());
+            const hasUndefinedAssignment = /:\s*undefined/.test(fullLine);
+
+            if (isInTestFile) return;
+
+            if (hasUndefinedAssignment) {
+                pushFinding(
+                    'frontend.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 = { FrontendForbiddenLiteralsAnalyzer };

package/scripts/hooks-system/infrastructure/ast/frontend/analyzers/FrontendSOLIDAnalyzer.js

@@ -0,0 +1,274 @@
+
+const path = require('path');
+const { pushFinding, SyntaxKind } = require(path.join(__dirname, '../../ast-core'));
+
+/**
+ * FrontendSOLIDAnalyzer
+ * Enterprise-grade SOLID principles analyzer for Frontend/React
+ * Uses TypeScript AST (ts-morph) for dynamic node-based analysis
+ *
+ * @class FrontendSOLIDAnalyzer
+ */
+class FrontendSOLIDAnalyzer {
+  constructor() {
+    this.findings = [];
+  }
+
+  /**
+   * Analyze source file for SOLID violations
+   * @param {SourceFile} sf - TypeScript morph source file
+   * @param {Array} findings - Global findings array
+   * @param {Function} pushFinding - Push finding function
+   */
+  analyze(sf, findings, pushFinding) {
+    this.findings = findings;
+    this.pushFinding = pushFinding;
+
+    this.analyzeOCP(sf);
+    this.analyzeDIP(sf);
+    this.analyzeSRP(sf);
+    this.analyzeISP(sf);
+  }
+
+
+  analyzeOCP(sf) {
+    const filePath = sf.getFilePath();
+    const fileName = filePath.split('/').pop() || 'unknown';
+
+    const functions = sf.getFunctions();
+    const arrowFunctions = sf.getVariableDeclarations().filter(vd => {
+      const init = vd.getInitializer();
+      return init && init.getKind() === SyntaxKind.ArrowFunction;
+    });
+
+    const components = sf.getExportedDeclarations();
+
+    const allNodes = [
+      ...functions.map(f => ({ type: 'function', node: f, name: f.getName() || 'anonymous' })),
+      ...arrowFunctions.map(af => ({ type: 'arrow', node: af, name: af.getName() || 'anonymous' })),
+    ];
+
+    components.forEach((declarations, exportName) => {
+      declarations.forEach(decl => {
+        if (decl.getKind() === SyntaxKind.FunctionDeclaration ||
+          decl.getKind() === SyntaxKind.VariableDeclaration) {
+          allNodes.push({ type: 'component', node: decl, name: exportName });
+        }
+      });
+    });
+
+    allNodes.forEach(({ type, node, name }) => {
+      this.analyzeNodeForOCP(node, name, fileName, sf);
+    });
+  }
+
+  analyzeNodeForOCP(node, nodeName, fileName, sf) {
+    let body;
+
+    if (node.getKind() === SyntaxKind.FunctionDeclaration ||
+      node.getKind() === SyntaxKind.FunctionExpression) {
+      body = node.getBody();
+    } else if (node.getKind() === SyntaxKind.VariableDeclaration) {
+      const init = node.getInitializer();
+      if (init && init.getKind() === SyntaxKind.ArrowFunction) {
+        body = init.getBody();
+      }
+    } else {
+      return;
+    }
+
+    if (!body) return;
+
+    const switches = body.getDescendantsOfKind(SyntaxKind.SwitchStatement);
+
+    switches.forEach(switchStmt => {
+      const switchExpr = switchStmt.getExpression();
+      const exprText = switchExpr.getText();
+      const cases = switchStmt.getCaseClauses();
+
+      if (cases.length >= 3) {
+        const isDomainValue = /status|type|priority|role|kind|category|state|mode/i.test(exprText);
+
+        if (isDomainValue) {
+          const message = `OCP VIOLATION in ${fileName}::${nodeName}: switch on '${exprText}' with ${cases.length} cases - use Strategy/Map pattern with centralized constants`;
+          this.pushFinding('solid.ocp.switch_statement', 'critical', sf, switchStmt, message, this.findings);
+        } else if (cases.length >= 5) {
+          const message = `OCP VIOLATION in ${fileName}::${nodeName}: large switch (${cases.length} cases) on '${exprText}' - consider Strategy/Factory pattern`;
+          this.pushFinding('solid.ocp.switch_statement', 'high', sf, switchStmt, message, this.findings);
+        }
+      }
+    });
+
+    const ifStatements = body.getDescendantsOfKind(SyntaxKind.IfStatement);
+    const typeIfChains = this.detectTypeIfChains(ifStatements);
+
+    if (typeIfChains.length >= 3) {
+      const chainVars = new Set(typeIfChains.map(chain => chain.variable));
+      if (chainVars.size === 1) {
+        const varName = Array.from(chainVars)[0];
+        const message = `OCP VIOLATION in ${fileName}::${nodeName}: ${typeIfChains.length} if-else checking '${varName}' - use Strategy pattern or polymorphism`;
+        this.pushFinding('solid.ocp.if_type_chain', 'critical', sf, typeIfChains[0].node, message, this.findings);
+      }
+    }
+
+    switches.forEach(switchStmt => {
+      const nestedSwitches = switchStmt.getDescendantsOfKind(SyntaxKind.SwitchStatement);
+      if (nestedSwitches.length > 0) {
+        const message = `OCP VIOLATION in ${fileName}::${nodeName}: nested switch statements - use Strategy/Map pattern with composition`;
+        this.pushFinding('solid.ocp.nested_switch', 'critical', sf, switchStmt, message, this.findings);
+      }
+    });
+  }
+
+  detectTypeIfChains(ifStatements) {
+    const chains = [];
+
+    ifStatements.forEach(ifStmt => {
+      const condition = ifStmt.getExpression();
+      const conditionText = condition.getText();
+
+      const typeCheckPattern = /(\w+)\s*(===|==|!==|!=)\s*['"]([\w\s]+)['"]|typeof\s+(\w+)|(\w+)\s+instanceof/i;
+      const match = conditionText.match(typeCheckPattern);
+
+      if (match) {
+        const variable = match[1] || match[4] || match[5];
+        chains.push({ variable, node: ifStmt });
+      }
+    });
+
+    return chains;
+  }
+
+
+  analyzeDIP(sf) {
+    const filePath = sf.getFilePath();
+    const fileName = filePath.split('/').pop() || 'unknown';
+
+    const isPresentation = /\/presentation\//i.test(filePath);
+
+    if (isPresentation) {
+      const imports = sf.getImportDeclarations();
+
+      imports.forEach(imp => {
+        const importPath = imp.getModuleSpecifierValue();
+
+        if (/\/infrastructure\//i.test(importPath) &&
+          !/\/infrastructure\/repositories\/|\/infrastructure\/config\//i.test(importPath)) {
+          const message = `DIP VIOLATION in ${fileName}: Presentation layer importing from Infrastructure: ${importPath} - use repository interfaces or abstractions`;
+          this.pushFinding('solid.dip.presentation_infrastructure', 'critical', sf, imp, message, this.findings);
+        }
+      });
+    }
+
+    const classes = sf.getClasses();
+    classes.forEach(cls => {
+      const className = cls.getName() || 'AnonymousClass';
+
+      if (/ViewModel|UseCase|Store/i.test(className)) {
+        const imports = sf.getImportDeclarations();
+
+        imports.forEach(imp => {
+          const importPath = imp.getModuleSpecifierValue();
+
+          if (/Repository|Service|Client/i.test(importPath) &&
+            !/interface|protocol|Repository.*Protocol/i.test(importPath)) {
+            const message = `DIP VIOLATION in ${fileName}::${className}: depends on concrete implementation '${importPath}' - inject interface/abstraction`;
+            this.pushFinding('solid.dip.concrete_dependency', 'critical', sf, imp, message, this.findings);
+          }
+        });
+      }
+    });
+  }
+
+
+  analyzeSRP(sf) {
+    const filePath = sf.getFilePath();
+    const fileName = filePath.split('/').pop() || 'unknown';
+
+    const functions = sf.getFunctions();
+    const arrowFunctions = sf.getVariableDeclarations().filter(vd => {
+      const init = vd.getInitializer();
+      return init && init.getKind() === SyntaxKind.ArrowFunction;
+    });
+
+    [...functions, ...arrowFunctions].forEach(func => {
+      const funcName = func.getName?.() || 'anonymous';
+      const body = func.getBody?.() || func.getInitializer()?.getBody();
+
+      if (!body) return;
+
+      const statements = body.getStatements();
+      const ifStatements = body.getDescendantsOfKind(SyntaxKind.IfStatement);
+      const switchStatements = body.getDescendantsOfKind(SyntaxKind.SwitchStatement);
+      const loops = body.getDescendantsOfKind(SyntaxKind.ForStatement)
+        .concat(body.getDescendantsOfKind(SyntaxKind.ForInStatement))
+        .concat(body.getDescendantsOfKind(SyntaxKind.WhileStatement));
+
+      if (statements.length > 30 || ifStatements.length > 10 || switchStatements.length > 2 || loops.length > 5) {
+        const message = `SRP VIOLATION in ${fileName}::${funcName}: high complexity (${statements.length} statements, ${ifStatements.length} ifs, ${switchStatements.length} switches) - extract responsibilities`;
+        this.pushFinding('solid.srp.high_complexity', 'critical', sf, func, message, this.findings);
+      }
+    });
+
+    const classes = sf.getClasses();
+    classes.forEach(cls => {
+      const className = cls.getName() || 'AnonymousClass';
+      const methods = cls.getMethods();
+
+      if (methods.length > 20) {
+        const message = `SRP VIOLATION in ${fileName}::${className}: God class with ${methods.length} methods - split into focused classes`;
+        this.pushFinding('solid.srp.god_class', 'critical', sf, cls, message, this.findings);
+      }
+
+      if (methods.length > 0) {
+        const methodConcerns = methods.map(m => this.detectMethodConcern(m.getName()));
+        const uniqueConcerns = new Set(methodConcerns.filter(c => c !== 'unknown'));
+
+        if (uniqueConcerns.size >= 3) {
+          const message = `SRP VIOLATION in ${fileName}::${className}: mixes ${uniqueConcerns.size} concerns (${Array.from(uniqueConcerns).join(', ')}) - split responsibilities`;
+          this.pushFinding('solid.srp.multiple_concerns', 'high', sf, cls, message, this.findings);
+        }
+      }
+    });
+  }
+
+
+  analyzeISP(sf) {
+    const interfaces = sf.getInterfaces();
+
+    interfaces.forEach(iface => {
+      const interfaceName = iface.getName();
+      const properties = iface.getProperties();
+      const methods = iface.getMethods();
+
+      if (properties.length > 10) {
+        const message = `ISP VIOLATION: ${interfaceName} has ${properties.length} properties - split into focused interfaces`;
+        this.pushFinding('solid.isp.fat_interface', 'critical', sf, iface, message, this.findings);
+      }
+
+      if (methods.length > 0) {
+        const methodConcerns = methods.map(m => this.detectMethodConcern(m.getName()));
+        const uniqueConcerns = new Set(methodConcerns.filter(c => c !== 'unknown'));
+
+        if (uniqueConcerns.size >= 3) {
+          const message = `ISP VIOLATION: ${interfaceName} mixes ${uniqueConcerns.size} concerns (${Array.from(uniqueConcerns).join(', ')}) - segregate into focused interfaces`;
+          this.pushFinding('solid.isp.multiple_concerns', 'critical', sf, iface, message, this.findings);
+        }
+      }
+    });
+  }
+
+  detectMethodConcern(methodName) {
+    const name = methodName.toLowerCase();
+
+    if (/get|fetch|load|read|find|query/i.test(name)) return 'data-access';
+    if (/set|save|create|update|delete|remove/i.test(name)) return 'data-mutation';
+    if (/validate|check|verify/i.test(name)) return 'validation';
+    if (/format|parse|transform/i.test(name)) return 'transformation';
+    if (/render|display|show/i.test(name)) return 'rendering';
+
+    return 'unknown';
+  }
+}
+
+module.exports = { FrontendSOLIDAnalyzer };

package/scripts/hooks-system/infrastructure/ast/frontend/analyzers/__tests__/FrontendArchitectureDetector.spec.js

@@ -0,0 +1,151 @@
+const { FrontendArchitectureDetector } = require('../FrontendArchitectureDetector');
+const fs = require('fs');
+const path = require('path');
+const glob = require('glob');
+
+function makeSUT(projectRoot = '/test/project') {
+  return new FrontendArchitectureDetector(projectRoot);
+}
+
+describe('FrontendArchitectureDetector', () => {
+  beforeEach(() => {
+    jest.restoreAllMocks();
+    jest.spyOn(fs, 'existsSync').mockReturnValue(false);
+    jest.spyOn(fs, 'readFileSync').mockReturnValue('');
+    jest.spyOn(glob, 'sync').mockReturnValue([]);
+  });
+
+  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.componentBased).toBe(0);
+      expect(detector.patterns.atomicDesign).toBe(0);
+      expect(detector.patterns.stateManagement).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 = {
+        frontend: {
+          architecturePattern: 'FEATURE_FIRST_CLEAN'
+        }
+      };
+      fs.existsSync.mockReturnValue(true);
+      fs.readFileSync.mockReturnValue(JSON.stringify(config));
+      const detector = makeSUT('/test/project');
+      expect(detector.manualConfig).toBeDefined();
+      expect(detector.manualConfig.architecturePattern).toBe('FEATURE_FIRST_CLEAN');
+    });
+
+    it('should return null when config file does not exist', () => {
+      fs.existsSync.mockReturnValue(false);
+      const detector = makeSUT();
+      expect(detector.manualConfig).toBeNull();
+    });
+  });
+
+  describe('detect', () => {
+    it('should return manual pattern when config exists', () => {
+      const config = {
+        frontend: {
+          architecturePattern: 'FEATURE_FIRST_CLEAN'
+        }
+      };
+      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');
+    });
+
+    it('should return UNKNOWN when no files found', () => {
+      glob.sync.mockReturnValue([]);
+      const detector = makeSUT();
+      const result = detector.detect();
+      expect(result).toBe('UNKNOWN');
+    });
+
+    it('should detect feature first clean pattern', () => {
+      const files = [
+        'src/features/orders/domain/Order.ts',
+        'src/features/orders/application/CreateOrderUseCase.ts',
+        'src/features/orders/infrastructure/OrderRepository.ts',
+        'src/features/orders/presentation/OrderScreen.tsx'
+      ];
+      glob.sync.mockReturnValueOnce(files).mockReturnValueOnce([]);
+      fs.readFileSync.mockReturnValue('export interface OrderRepository {}');
+      const detector = makeSUT();
+      const result = detector.detect();
+      expect(result).toBe('FEATURE_FIRST_CLEAN_DDD');
+    });
+
+    it('should detect component based pattern', () => {
+      const files = [
+        'src/components/Button.tsx',
+        'src/components/Card.tsx',
+        'src/components/Modal.tsx',
+        'src/pages/Home.tsx'
+      ];
+      glob.sync.mockReturnValueOnce(files).mockReturnValueOnce([]);
+      const detector = makeSUT();
+      const result = detector.detect();
+      expect(result).toBe('COMPONENT_BASED');
+    });
+
+    it('should detect atomic design pattern', () => {
+      const files = [
+        'src/components/atoms/Button.tsx',
+        'src/components/molecules/FormField.tsx',
+        'src/components/organisms/Header.tsx',
+        'src/components/templates/PageLayout.tsx'
+      ];
+      glob.sync.mockReturnValueOnce(files).mockReturnValueOnce([]);
+      const detector = makeSUT();
+      const result = detector.detect();
+      expect(result).toBe('ATOMIC_DESIGN');
+    });
+  });
+
+  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.componentBased = 5;
+      const result = detector.getDominantPattern();
+      expect(result).toBe('FEATURE_FIRST_CLEAN_DDD');
+    });
+
+    it('should return COMPONENT_BASED when componentBased has highest score', () => {
+      const detector = makeSUT();
+      detector.patterns.componentBased = 10;
+      detector.patterns.featureFirstClean = 5;
+      const result = detector.getDominantPattern();
+      expect(result).toBe('COMPONENT_BASED');
+    });
+
+    it('should return ATOMIC_DESIGN when atomicDesign has highest score', () => {
+      const detector = makeSUT();
+      detector.patterns.atomicDesign = 10;
+      detector.patterns.componentBased = 5;
+      const result = detector.getDominantPattern();
+      expect(result).toBe('ATOMIC_DESIGN');
+    });
+  });
+});
+