react-code-smell-detector 1.4.2 → 1.5.0

package/README.md

@@ -4,7 +4,7 @@ A CLI tool that analyzes React projects and detects common code smells, providin
 
 ## Features
 
-- 🔍 **Detect Code Smells**: Identifies common React anti-patterns (51+ smell types)
+- 🔍 **Detect Code Smells**: Identifies common React anti-patterns (70+ smell types)
 - 📊 **Technical Debt Score**: Grades your codebase from A to F
 - 💡 **Refactoring Suggestions**: Actionable recommendations for each issue
 - 📝 **Multiple Output Formats**: Console (colored), JSON, Markdown, and HTML
@@ -24,6 +24,17 @@ A CLI tool that analyzes React projects and detects common code smells, providin
 - 🔗 **Dependency Graph Visualization**: Visual SVG/HTML of component and import relationships
 - 📦 **Bundle Size Impact**: Per-component bundle size estimates and optimization suggestions
 - ⚙️ **Custom Rules Engine**: Define project-specific code quality rules in configuration
+- 🔧 **Interactive Fix Mode**: Review and apply fixes one by one with diff preview
+- 💬 **GitHub PR Comments**: Auto-comment analysis results on pull requests
+- 📊 **Performance Budget**: Set thresholds and enforce limits in CI/CD
+- 📚 **Component Documentation**: Auto-generate docs from component analysis
+- ⚛️ **React 19 Server Components**: Detect Server/Client boundary issues
+- 🔮 **Context API Analysis**: Detect context overuse, missing memoization, re-render issues
+- 🛡️ **Error Boundary Detection**: Find missing ErrorBoundary and Suspense wrappers
+- 📋 **Form Validation Smells**: Detect uncontrolled inputs, missing validation
+- 🗃️ **State Management Analysis**: Redux/Zustand anti-patterns, selector issues
+- 🧪 **Testing Gap Detection**: Identify complex components likely needing tests
+- 🤖 **AI Refactoring Suggestions**: LLM-powered smart refactoring recommendations
 
 ### Detected Code Smells
 
@@ -42,7 +53,13 @@ A CLI tool that analyzes React projects and detects common code smells, providin
 | **Import Issues** | Circular dependencies, barrel file imports, excessive imports |
 | **Unused Code** | Unused exports, dead imports |
 | **Custom Rules** | User-defined code quality rules |
+| **Server Components** | React 19 client/server boundary issues, async components |
 | **Framework-Specific** | Next.js, React Native, Node.js, TypeScript issues |
+| **Context API** | Context overuse, missing memoization, large context values |
+| **Error Boundaries** | Missing ErrorBoundary, Suspense without fallback |
+| **Form Validation** | Uncontrolled forms, missing validation, controlled inputs without onChange |
+| **State Management** | Redux selector anti-patterns, derived state issues, state sync problems |
+| **Testing Gaps** | Complex untestable components, side-effect heavy code, tight coupling |
 
 ## Installation
 
@@ -132,6 +149,16 @@ Or create manually:
 | `--graph-format <format>` | Graph output format: svg, html | `html` |
 | `--bundle` | Analyze bundle size impact per component | `false` |
 | `--rules <file>` | Custom rules configuration file | - |
+| `--fix-interactive` | Interactive fix mode: review fixes one by one | `false` |
+| `--fix-preview` | Preview fixable issues without applying | `false` |
+| `--pr-comment` | Generate PR comment (for GitHub Actions) | `false` |
+| `--budget` | Check against performance budget | `false` |
+| `--budget-config <file>` | Path to budget config file | `.smellbudget.json` |
+| `--docs` | Generate component documentation | `false` |
+| `--docs-format <format>` | Documentation format: markdown, html, json | `markdown` |
+| `--ai` | Enable AI-powered refactoring suggestions | `false` |
+| `--ai-key <key>` | API key for AI provider | - |
+| `--ai-model <model>` | AI model to use (gpt-4, claude-3-sonnet, etc.) | `gpt-4` |
 
 ### Auto-Fix
 
@@ -392,6 +419,153 @@ react-smell ./src --rules .smellrc-rules.json --format json --ci
 }
 ```
 
+### Interactive Fix Mode
+
+Review and apply fixes one by one with diff preview:
+
+```bash
+# Interactive mode - review each fix
+react-smell ./src --fix-interactive
+
+# Preview fixable issues without applying
+react-smell ./src --fix-preview
+```
+
+**Output:**
+```
+🔧 Interactive Fix Mode
+Found 5 fixable issue(s). Review each one:
+
+Commands: [y]es, [n]o, [a]ll, [q]uit
+
+────────────────────────────────────────────────────────────────
+src/utils/helper.ts:15
+  debug-statement: console.log found
+  Fix: Remove console.log/debugger statements
+
+  - console.log('debug:', value);
+  + (line removed)
+
+Apply this fix? [y/n/a/q]: y
+  ✓ Applied
+```
+
+### GitHub PR Comments
+
+Auto-comment code smell analysis on pull requests:
+
+```bash
+# Generate PR comment (outputs markdown)
+react-smell ./src --pr-comment
+
+# In GitHub Actions (auto-posts to PR)
+react-smell ./src --pr-comment --ci
+```
+
+**GitHub Actions workflow:**
+```yaml
+- name: Analyze Code
+  run: npx react-smell ./src --pr-comment --ci
+  env:
+    GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+```
+
+### Performance Budget
+
+Set thresholds for code quality and enforce in CI/CD:
+
+```bash
+# Create budget config
+react-smell init-budget
+
+# Check against budget
+react-smell ./src --budget
+
+# With custom config
+react-smell ./src --budget --budget-config my-budget.json
+```
+
+**Budget config (`.smellbudget.json`):**
+```json
+{
+  "maxErrors": 0,
+  "maxWarnings": 10,
+  "minScore": 70,
+  "minGrade": "C",
+  "maxSmellsPerFile": 5,
+  "maxByType": {
+    "useEffect-overuse": 3,
+    "prop-drilling": 5
+  }
+}
+```
+
+**Output:**
+```
+✗ Performance budget check failed
+
+Violations:
+  ✗ Errors (2) exceeds budget (0)
+  ⚠ Warnings (15) exceeds budget (10)
+
+Checks: 3 passed, 2 failed
+```
+
+### Component Documentation
+
+Auto-generate documentation from component analysis:
+
+```bash
+# Generate markdown docs
+react-smell docs ./src
+
+# Generate HTML docs
+react-smell docs ./src -f html
+
+# Output to specific directory
+react-smell docs ./src -f html -o ./docs
+```
+
+**Output (COMPONENTS.md):**
+```markdown
+# Component Documentation
+
+## Summary
+| Metric | Value |
+|--------|-------|
+| Total Components | 25 |
+| Technical Debt Grade | B |
+
+## Components
+
+#### Button
+📄 `components/Button.tsx`
+
+| Metric | Value |
+|--------|-------|
+| Lines | 45 |
+| Complexity | 🟢 Low |
+| Maintainability | 🟢 Good |
+
+**Hooks:** useState (2), useCallback (1)
+```
+
+### React 19 Server Components
+
+Detect Server/Client component boundary issues:
+
+```bash
+# Enabled by default for app/ directory components
+react-smell ./src
+```
+
+**Detected issues:**
+- `server-component-hooks`: Using useState/useEffect in Server Components
+- `server-component-events`: Using onClick/onChange in Server Components
+- `server-component-browser-api`: Using window/document in Server Components
+- `async-client-component`: Async function in 'use client' component
+- `mixed-directives`: Both 'use client' and 'use server' in same file
+
 ## Example Output
 
 ```
@@ -421,9 +595,23 @@ react-smell ./src --rules .smellrc-rules.json --format json --ci
 ## Programmatic API
 
 ```typescript
-import { analyzeProject, reportResults } from 'react-code-smell-detector';
-import { initializeBaseline, recordBaseline, getTrendAnalysis, formatTrendReport } from 'react-code-smell-detector';
-import { sendWebhookNotification, getWebhookConfig } from 'react-code-smell-detector';
+import { 
+  analyzeProject, 
+  reportResults,
+  // Interactive fixing
+  runInteractiveFix,
+  previewFixes,
+  // PR Comments
+  generatePRComment,
+  postPRComment,
+  // Performance Budget
+  loadBudget,
+  checkBudget,
+  formatBudgetReport,
+  // Documentation
+  generateComponentDocs,
+  writeComponentDocs,
+} from 'react-code-smell-detector';
 
 const result = await analyzeProject({
   rootDir: './src',
@@ -431,32 +619,29 @@ const result = await analyzeProject({
     maxUseEffectsPerComponent: 3,
     maxComponentLines: 300,
     checkUnusedCode: true,
-    baselineEnabled: true,
+    checkServerComponents: true, // React 19
   },
 });
 
 console.log(`Grade: ${result.debtScore.grade}`);
 console.log(`Total issues: ${result.summary.totalSmells}`);
 
-// Track baseline
-initializeBaseline('./src');
-recordBaseline('./src', result.files.flatMap(f => f.smells));
-const trend = getTrendAnalysis('./src');
-console.log(formatTrendReport('./src'));
-
-// Send notification
-const webhookConfig = getWebhookConfig(
-  process.env.REACT_SMELL_SLACK_WEBHOOK,
-  process.env.REACT_SMELL_DISCORD_WEBHOOK
-);
-if (webhookConfig) {
-  await sendWebhookNotification(
-    webhookConfig,
-    result.files.flatMap(f => f.smells),
-    'my-project'
-  );
+// Check against performance budget
+const budget = await loadBudget();
+const budgetResult = checkBudget(result, budget);
+if (!budgetResult.passed) {
+  console.log(formatBudgetReport(budgetResult));
 }
 
+// Generate documentation
+const docsPath = await writeComponentDocs(result, './src', {
+  format: 'markdown',
+  includeSmells: true,
+});
+
+// Generate PR comment
+const prComment = generatePRComment(result, './src');
+
 // Or use the reporter
 const report = reportResults(result, {
   format: 'markdown',

package/dist/__tests__/parser.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=parser.test.d.ts.map

package/dist/__tests__/parser.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parser.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/parser.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/parser.test.js

@@ -0,0 +1,56 @@
+import { describe, it, expect } from 'vitest';
+import { parseCode } from '../parser/index.js';
+describe('Parser', () => {
+    it('should parse a simple React component', () => {
+        const code = `
+      function Hello({ name }) {
+        return <div>Hello {name}</div>;
+      }
+    `;
+        const result = parseCode(code);
+        expect(result.components).toHaveLength(1);
+        expect(result.components[0].name).toBe('Hello');
+    });
+    it('should detect useState hook', () => {
+        const code = `
+      function Counter() {
+        const [count, setCount] = useState(0);
+        return <button onClick={() => setCount(count + 1)}>{count}</button>;
+      }
+    `;
+        const result = parseCode(code);
+        expect(result.components).toHaveLength(1);
+        expect(result.components[0].hooks.useState).toHaveLength(1);
+    });
+    it('should detect useEffect hook', () => {
+        const code = `
+      function Timer() {
+        const [time, setTime] = useState(0);
+        useEffect(() => {
+          const id = setInterval(() => setTime(t => t + 1), 1000);
+          return () => clearInterval(id);
+        }, []);
+        return <span>{time}</span>;
+      }
+    `;
+        const result = parseCode(code);
+        expect(result.components).toHaveLength(1);
+        expect(result.components[0].hooks.useEffect).toHaveLength(1);
+    });
+    it('should extract component props', () => {
+        const code = `
+      function Card({ title, description, onClick }) {
+        return (
+          <div onClick={onClick}>
+            <h1>{title}</h1>
+            <p>{description}</p>
+          </div>
+        );
+      }
+    `;
+        const result = parseCode(code);
+        expect(result.components[0].props).toContain('title');
+        expect(result.components[0].props).toContain('description');
+        expect(result.components[0].props).toContain('onClick');
+    });
+});

package/dist/__tests__/performanceBudget.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=performanceBudget.test.d.ts.map

package/dist/__tests__/performanceBudget.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"performanceBudget.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/performanceBudget.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/performanceBudget.test.js

@@ -0,0 +1,91 @@
+import { describe, it, expect } from 'vitest';
+import { checkBudget } from '../performanceBudget.js';
+describe('Performance Budget', () => {
+    const createMockResult = (overrides = {}) => ({
+        files: [],
+        summary: {
+            totalFiles: 5,
+            totalComponents: 10,
+            totalSmells: 3,
+            smellsByType: Object.fromEntries([
+                'useEffect-overuse', 'prop-drilling', 'large-component', 'unmemoized-calculation',
+                'missing-dependency', 'state-in-loop', 'inline-function-prop', 'deep-nesting',
+                'missing-key', 'hooks-rules-violation', 'dependency-array-issue', 'nested-ternary',
+                'dead-code', 'magic-value', 'debug-statement', 'todo-comment', 'security-xss',
+                'security-eval', 'security-secrets', 'a11y-missing-alt', 'a11y-missing-label',
+                'a11y-interactive-role', 'a11y-keyboard', 'a11y-semantic',
+                'nextjs-client-server-boundary', 'nextjs-missing-metadata', 'nextjs-image-unoptimized',
+                'nextjs-router-misuse', 'rn-inline-style', 'rn-missing-accessibility', 'rn-performance-issue',
+                'nodejs-callback-hell', 'nodejs-unhandled-promise', 'nodejs-sync-io', 'nodejs-missing-error-handling',
+                'js-var-usage', 'js-loose-equality', 'js-implicit-coercion', 'js-global-pollution',
+                'ts-any-usage', 'ts-missing-return-type', 'ts-non-null-assertion', 'ts-type-assertion',
+                'high-cyclomatic-complexity', 'high-cognitive-complexity',
+                'memory-leak-event-listener', 'memory-leak-subscription', 'memory-leak-timer', 'memory-leak-async',
+                'circular-dependency', 'barrel-file-import', 'namespace-import', 'excessive-imports',
+                'unused-export', 'dead-import',
+                'server-component-hooks', 'server-component-events', 'server-component-browser-api',
+                'async-client-component', 'mixed-directives', 'custom-rule'
+            ].map(key => [key, 0])),
+            smellsBySeverity: { error: 0, warning: 2, info: 1 },
+        },
+        debtScore: {
+            score: 85,
+            grade: 'B',
+            breakdown: {
+                useEffectScore: 90,
+                propDrillingScore: 80,
+                componentSizeScore: 85,
+                memoizationScore: 85,
+            },
+            estimatedRefactorTime: '< 30 minutes',
+        },
+        ...overrides,
+    });
+    it('should pass when all budgets are met', () => {
+        const budget = {
+            maxTotalSmells: 10,
+            maxErrors: 5,
+            minGrade: 'C',
+        };
+        const result = checkBudget(createMockResult(), budget);
+        expect(result.passed).toBe(true);
+        expect(result.violations).toHaveLength(0);
+    });
+    it('should fail when total smells exceed budget', () => {
+        const budget = {
+            maxTotalSmells: 2,
+        };
+        const result = checkBudget(createMockResult(), budget);
+        expect(result.passed).toBe(false);
+        expect(result.violations).toHaveLength(1);
+        expect(result.violations[0].rule).toBe('maxTotalSmells');
+    });
+    it('should fail when errors exceed budget', () => {
+        const budget = {
+            maxErrors: 0,
+        };
+        const mockResult = createMockResult();
+        mockResult.summary.smellsBySeverity.error = 2;
+        const result = checkBudget(mockResult, budget);
+        expect(result.passed).toBe(false);
+        expect(result.violations[0].rule).toBe('maxErrors');
+    });
+    it('should fail when grade is below minimum', () => {
+        const budget = {
+            minGrade: 'A',
+        };
+        const result = checkBudget(createMockResult(), budget);
+        expect(result.passed).toBe(false);
+        expect(result.violations[0].rule).toBe('minGrade');
+    });
+    it('should allow warnings as non-blocking violations', () => {
+        const budget = {
+            maxWarnings: 1,
+        };
+        const result = checkBudget(createMockResult(), budget);
+        // Should have violation but still pass (warnings are non-blocking)
+        expect(result.violations).toHaveLength(1);
+        expect(result.violations[0].severity).toBe('warning');
+        expect(result.passed).toBe(true);
+    });
+});

package/dist/__tests__/prComments.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=prComments.test.d.ts.map

package/dist/__tests__/prComments.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prComments.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/prComments.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/prComments.test.js

@@ -0,0 +1,118 @@
+import { describe, it, expect } from 'vitest';
+import { generatePRComment, generateInlineComments } from '../prComments.js';
+describe('PR Comments', () => {
+    const createMockResult = () => ({
+        files: [
+            {
+                file: '/src/components/Button.tsx',
+                components: [
+                    {
+                        name: 'Button',
+                        file: '/src/components/Button.tsx',
+                        startLine: 1,
+                        endLine: 50,
+                        lineCount: 50,
+                        useEffectCount: 1,
+                        useStateCount: 2,
+                        useMemoCount: 0,
+                        useCallbackCount: 0,
+                        propsCount: 3,
+                        propsDrillingDepth: 0,
+                        hasExpensiveCalculation: false,
+                    },
+                ],
+                smells: [
+                    {
+                        type: 'useEffect-overuse',
+                        severity: 'warning',
+                        message: 'Component has multiple useEffect hooks',
+                        file: '/src/components/Button.tsx',
+                        line: 10,
+                        column: 0,
+                        suggestion: 'Consider consolidating effects',
+                    },
+                ],
+                imports: [],
+            },
+        ],
+        summary: {
+            totalFiles: 1,
+            totalComponents: 1,
+            totalSmells: 1,
+            smellsByType: {
+                'useEffect-overuse': 1,
+            },
+            smellsBySeverity: { error: 0, warning: 1, info: 0 },
+        },
+        debtScore: {
+            score: 85,
+            grade: 'B',
+            breakdown: {
+                useEffectScore: 85,
+                propDrillingScore: 100,
+                componentSizeScore: 100,
+                memoizationScore: 100,
+            },
+            estimatedRefactorTime: '< 30 minutes',
+        },
+    });
+    it('should generate a markdown PR comment', () => {
+        const result = createMockResult();
+        const comment = generatePRComment(result, '/');
+        expect(comment).toContain('## 🔍 Code Smell Analysis Report');
+        expect(comment).toContain('Grade: **B**');
+        expect(comment).toContain('Total Issues | 1');
+        expect(comment).toContain('useEffect-overuse');
+    });
+    it('should include score breakdown', () => {
+        const result = createMockResult();
+        const comment = generatePRComment(result, '/');
+        expect(comment).toContain('Score Breakdown');
+        expect(comment).toContain('useEffect Usage');
+        expect(comment).toContain('85/100');
+    });
+    it('should generate inline comments for smells', () => {
+        const smells = [
+            {
+                type: 'debug-statement',
+                severity: 'warning',
+                message: 'console.log found',
+                file: '/src/utils/helper.ts',
+                line: 15,
+                column: 0,
+                suggestion: 'Remove debug statements',
+            },
+        ];
+        const comments = generateInlineComments(smells, '/');
+        expect(comments).toHaveLength(1);
+        expect(comments[0].path).toBe('src/utils/helper.ts');
+        expect(comments[0].line).toBe(15);
+        expect(comments[0].body).toContain('debug-statement');
+    });
+    it('should group multiple smells on same line', () => {
+        const smells = [
+            {
+                type: 'debug-statement',
+                severity: 'warning',
+                message: 'console.log found',
+                file: '/src/utils/helper.ts',
+                line: 15,
+                column: 0,
+                suggestion: 'Remove debug statements',
+            },
+            {
+                type: 'js-var-usage',
+                severity: 'warning',
+                message: 'var usage detected',
+                file: '/src/utils/helper.ts',
+                line: 15,
+                column: 0,
+                suggestion: 'Use let or const',
+            },
+        ];
+        const comments = generateInlineComments(smells, '/');
+        expect(comments).toHaveLength(1);
+        expect(comments[0].body).toContain('debug-statement');
+        expect(comments[0].body).toContain('js-var-usage');
+    });
+});

package/dist/analyzer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"analyzer.d.ts","sourceRoot":"","sources":["../src/analyzer.ts"],"names":[],"mappings":"AA+BA,OAAO,EACL,cAAc,EAMd,cAAc,EAIf,MAAM,kBAAkB,CAAC;AAE1B,MAAM,WAAW,eAAe;IAC9B,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IACnB,MAAM,CAAC,EAAE,OAAO,CAAC,cAAc,CAAC,CAAC;CAClC;AAED,wBAAsB,cAAc,CAAC,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,cAAc,CAAC,CA8DtF;AA0QD,OAAO,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC"}
+{"version":3,"file":"analyzer.d.ts","sourceRoot":"","sources":["../src/analyzer.ts"],"names":[],"mappings":"AAiCA,OAAO,EACL,cAAc,EAMd,cAAc,EAIf,MAAM,kBAAkB,CAAC;AAE1B,MAAM,WAAW,eAAe;IAC9B,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IACnB,MAAM,CAAC,EAAE,OAAO,CAAC,cAAc,CAAC,CAAC;CAClC;AAED,wBAAsB,cAAc,CAAC,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,cAAc,CAAC,CA8DtF;AAmRD,OAAO,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC"}

package/dist/analyzer.js

@@ -1,7 +1,7 @@
 import fg from 'fast-glob';
 import path from 'path';
 import { parseFile } from './parser/index.js';
-import { detectUseEffectOveruse, detectPropDrilling, analyzePropDrillingDepth, detectLargeComponent, detectUnmemoizedCalculations, detectMissingKeys, detectHooksRulesViolations, detectDependencyArrayIssues, detectNestedTernaries, detectDeadCode, detectMagicValues, detectNextjsIssues, detectReactNativeIssues, detectNodejsIssues, detectJavascriptIssues, detectTypescriptIssues, detectDebugStatements, detectSecurityIssues, detectAccessibilityIssues, detectComplexity, detectMemoryLeaks, detectImportIssues, detectUnusedCode, } from './detectors/index.js';
+import { detectUseEffectOveruse, detectPropDrilling, analyzePropDrillingDepth, detectLargeComponent, detectUnmemoizedCalculations, detectMissingKeys, detectHooksRulesViolations, detectDependencyArrayIssues, detectNestedTernaries, detectDeadCode, detectMagicValues, detectNextjsIssues, detectReactNativeIssues, detectNodejsIssues, detectJavascriptIssues, detectTypescriptIssues, detectDebugStatements, detectSecurityIssues, detectAccessibilityIssues, detectComplexity, detectMemoryLeaks, detectImportIssues, detectUnusedCode, detectServerComponentIssues, detectAsyncComponentIssues, } from './detectors/index.js';
 import { parseCustomRules, detectCustomRuleViolations } from './customRules.js';
 import { buildDependencyGraph } from './graphGenerator.js';
 import { analyzeBundleImpact } from './bundleAnalyzer.js';
@@ -100,6 +100,9 @@ function analyzeFile(parseResult, filePath, config) {
         smells.push(...detectMemoryLeaks(component, filePath, sourceCode, config));
         smells.push(...detectImportIssues(component, filePath, sourceCode, config));
         smells.push(...detectUnusedCode(component, filePath, sourceCode, config));
+        // Server Components (React 19)
+        smells.push(...detectServerComponentIssues(component, filePath, sourceCode, config, imports));
+        smells.push(...detectAsyncComponentIssues(component, filePath, sourceCode, config));
         // Custom rules
         const customRules = parseCustomRules(config);
         if (customRules.length > 0) {
@@ -213,6 +216,12 @@ function calculateSummary(files) {
         // Unused code
         'unused-export': 0,
         'dead-import': 0,
+        // Server Components (React 19)
+        'server-component-hooks': 0,
+        'server-component-events': 0,
+        'server-component-browser-api': 0,
+        'async-client-component': 0,
+        'mixed-directives': 0,
         // Custom rules
         'custom-rule': 0,
     };