react-code-smell-detector 1.4.2 → 1.5.1

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

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

package/dist/__tests__/webhooks.test.js

@@ -0,0 +1,209 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { sendWebhookNotification, getWebhookConfig } from '../webhooks.js';
+// Mock https module
+vi.mock('https', () => ({
+    default: {
+        request: vi.fn((options, callback) => {
+            const mockRes = { statusCode: 200 };
+            setTimeout(() => callback(mockRes), 0);
+            return {
+                on: vi.fn(),
+                write: vi.fn(),
+                end: vi.fn(),
+            };
+        }),
+    },
+}));
+describe('Webhooks', () => {
+    let envBackup;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        envBackup = { ...process.env };
+    });
+    afterEach(() => {
+        process.env = envBackup;
+    });
+    const createSmell = (type, severity = 'warning') => ({
+        type: type,
+        severity,
+        message: 'Test smell',
+        file: '/test.tsx',
+        line: 1,
+        column: 0,
+        suggestion: 'Fix it',
+    });
+    const createManySmells = (count) => {
+        return Array.from({ length: count }, (_, i) => createSmell(`type-${i % 5}`, i % 3 === 0 ? 'error' : 'warning'));
+    };
+    describe('sendWebhookNotification', () => {
+        it('should return false when webhook url is empty', async () => {
+            const config = {
+                url: '',
+                type: 'slack',
+            };
+            const smells = [createSmell('debug-statement')];
+            const result = await sendWebhookNotification(config, smells, 'test-project');
+            expect(result).toBe(false);
+        });
+        it('should return false when below threshold', async () => {
+            const config = {
+                url: 'https://hooks.example.com/test',
+                type: 'slack',
+                threshold: 10,
+            };
+            const smells = [createSmell('debug-statement')];
+            const result = await sendWebhookNotification(config, smells, 'test-project');
+            expect(result).toBe(false);
+        });
+        it('should format slack message correctly', async () => {
+            const config = {
+                url: 'https://hooks.slack.com/services/test',
+                type: 'slack',
+            };
+            const smells = createManySmells(5);
+            const result = await sendWebhookNotification(config, smells, 'test-project', {
+                branch: 'main',
+                commit: 'abc123def456',
+                author: 'Test User',
+            });
+            expect(typeof result).toBe('boolean');
+        });
+        it('should format discord message correctly', async () => {
+            const config = {
+                url: 'https://discord.com/api/webhooks/test',
+                type: 'discord',
+            };
+            const smells = createManySmells(15);
+            const result = await sendWebhookNotification(config, smells, 'test-project', {
+                branch: 'develop',
+                author: 'Dev User',
+            });
+            expect(typeof result).toBe('boolean');
+        });
+        it('should format generic message correctly', async () => {
+            const config = {
+                url: 'https://example.com/webhook',
+                type: 'generic',
+            };
+            const smells = createManySmells(25);
+            const result = await sendWebhookNotification(config, smells, 'test-project', {
+                branch: 'feature/test',
+                commit: 'xyz789',
+            });
+            expect(typeof result).toBe('boolean');
+        });
+        it('should handle high smell count (danger color)', async () => {
+            const config = {
+                url: 'https://hooks.slack.com/services/test',
+                type: 'slack',
+            };
+            const smells = createManySmells(25);
+            const result = await sendWebhookNotification(config, smells, 'test-project');
+            expect(typeof result).toBe('boolean');
+        });
+        it('should handle critical smell count (50+)', async () => {
+            const config = {
+                url: 'https://hooks.slack.com/services/test',
+                type: 'slack',
+            };
+            const smells = createManySmells(55);
+            const result = await sendWebhookNotification(config, smells, 'test-project');
+            expect(typeof result).toBe('boolean');
+        });
+        it('should handle zero smells', async () => {
+            const config = {
+                url: 'https://hooks.slack.com/services/test',
+                type: 'slack',
+            };
+            const result = await sendWebhookNotification(config, [], 'test-project');
+            expect(typeof result).toBe('boolean');
+        });
+        it('should include details when flag is set', async () => {
+            const config = {
+                url: 'https://hooks.slack.com/services/test',
+                type: 'slack',
+                includeDetails: true,
+            };
+            const smells = [createSmell('debug-statement')];
+            const result = await sendWebhookNotification(config, smells, 'test-project');
+            expect(typeof result).toBe('boolean');
+        });
+        it('should handle discord with includeDetails', async () => {
+            const config = {
+                url: 'https://discord.com/api/webhooks/test',
+                type: 'discord',
+                includeDetails: true,
+            };
+            const smells = createManySmells(12);
+            const result = await sendWebhookNotification(config, smells, 'test-project');
+            expect(typeof result).toBe('boolean');
+        });
+    });
+    describe('getWebhookConfig', () => {
+        it('should return null when no webhook configured', () => {
+            delete process.env.REACT_SMELL_SLACK_WEBHOOK;
+            delete process.env.SLACK_WEBHOOK_URL;
+            delete process.env.REACT_SMELL_DISCORD_WEBHOOK;
+            delete process.env.DISCORD_WEBHOOK_URL;
+            delete process.env.REACT_SMELL_WEBHOOK;
+            const config = getWebhookConfig();
+            expect(config).toBeNull();
+        });
+        it('should return slack config when slack URL provided as argument', () => {
+            const config = getWebhookConfig('https://hooks.slack.com/test');
+            expect(config).not.toBeNull();
+            expect(config?.type).toBe('slack');
+            expect(config?.url).toBe('https://hooks.slack.com/test');
+        });
+        it('should return discord config when discord URL provided as argument', () => {
+            const config = getWebhookConfig(undefined, 'https://discord.com/api/webhooks/test');
+            expect(config).not.toBeNull();
+            expect(config?.type).toBe('discord');
+        });
+        it('should return generic config when generic URL provided as argument', () => {
+            const config = getWebhookConfig(undefined, undefined, 'https://example.com/webhook');
+            expect(config).not.toBeNull();
+            expect(config?.type).toBe('generic');
+        });
+        it('should prefer slack over discord', () => {
+            const config = getWebhookConfig('https://hooks.slack.com/test', 'https://discord.com/api/webhooks/test');
+            expect(config?.type).toBe('slack');
+        });
+        it('should read from REACT_SMELL_SLACK_WEBHOOK env var', () => {
+            process.env.REACT_SMELL_SLACK_WEBHOOK = 'https://hooks.slack.com/env';
+            const config = getWebhookConfig();
+            expect(config?.type).toBe('slack');
+            expect(config?.url).toBe('https://hooks.slack.com/env');
+        });
+        it('should read from SLACK_WEBHOOK_URL env var', () => {
+            delete process.env.REACT_SMELL_SLACK_WEBHOOK;
+            process.env.SLACK_WEBHOOK_URL = 'https://hooks.slack.com/env2';
+            const config = getWebhookConfig();
+            expect(config?.type).toBe('slack');
+        });
+        it('should read from REACT_SMELL_DISCORD_WEBHOOK env var', () => {
+            delete process.env.REACT_SMELL_SLACK_WEBHOOK;
+            delete process.env.SLACK_WEBHOOK_URL;
+            process.env.REACT_SMELL_DISCORD_WEBHOOK = 'https://discord.com/api/webhooks/env';
+            const config = getWebhookConfig();
+            expect(config?.type).toBe('discord');
+        });
+        it('should read from DISCORD_WEBHOOK_URL env var', () => {
+            delete process.env.REACT_SMELL_SLACK_WEBHOOK;
+            delete process.env.SLACK_WEBHOOK_URL;
+            delete process.env.REACT_SMELL_DISCORD_WEBHOOK;
+            process.env.DISCORD_WEBHOOK_URL = 'https://discord.com/api/webhooks/env2';
+            const config = getWebhookConfig();
+            expect(config?.type).toBe('discord');
+        });
+        it('should read from REACT_SMELL_WEBHOOK env var', () => {
+            delete process.env.REACT_SMELL_SLACK_WEBHOOK;
+            delete process.env.SLACK_WEBHOOK_URL;
+            delete process.env.REACT_SMELL_DISCORD_WEBHOOK;
+            delete process.env.DISCORD_WEBHOOK_URL;
+            process.env.REACT_SMELL_WEBHOOK = 'https://example.com/generic';
+            const config = getWebhookConfig();
+            expect(config?.type).toBe('generic');
+        });
+    });
+});

package/dist/aiRefactoring.d.ts

@@ -0,0 +1,29 @@
+import { CodeSmell, AnalysisResult } from './types/index.js';
+export interface AIRefactoringSuggestion {
+    smell: CodeSmell;
+    originalCode: string;
+    suggestedCode: string;
+    explanation: string;
+    confidence: number;
+    estimatedEffort: 'low' | 'medium' | 'high';
+}
+export interface AIRefactoringConfig {
+    apiKey: string;
+    model: string;
+    maxTokens?: number;
+    temperature?: number;
+    provider?: 'openai' | 'anthropic' | 'azure';
+}
+/**
+ * Generate AI-powered refactoring suggestions for detected code smells
+ */
+export declare function generateAIRefactoringSuggestions(smells: CodeSmell[], sourceCode: string, config: AIRefactoringConfig): Promise<AIRefactoringSuggestion[]>;
+/**
+ * Generate a summary report with AI insights
+ */
+export declare function generateAIAnalysisReport(result: AnalysisResult, config: AIRefactoringConfig): Promise<string>;
+/**
+ * Get refactoring suggestions for specific smell types
+ */
+export declare function getQuickRefactoringTemplates(smellType: string): string[];
+//# sourceMappingURL=aiRefactoring.d.ts.map

package/dist/aiRefactoring.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"aiRefactoring.d.ts","sourceRoot":"","sources":["../src/aiRefactoring.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAkB,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAE7E,MAAM,WAAW,uBAAuB;IACtC,KAAK,EAAE,SAAS,CAAC;IACjB,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,EAAE,MAAM,CAAC;IACtB,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,eAAe,EAAE,KAAK,GAAG,QAAQ,GAAG,MAAM,CAAC;CAC5C;AAED,MAAM,WAAW,mBAAmB;IAClC,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,EAAE,QAAQ,GAAG,WAAW,GAAG,OAAO,CAAC;CAC7C;AAED;;GAEG;AACH,wBAAsB,gCAAgC,CACpD,MAAM,EAAE,SAAS,EAAE,EACnB,UAAU,EAAE,MAAM,EAClB,MAAM,EAAE,mBAAmB,GAC1B,OAAO,CAAC,uBAAuB,EAAE,CAAC,CAmBpC;AAyND;;GAEG;AACH,wBAAsB,wBAAwB,CAC5C,MAAM,EAAE,cAAc,EACtB,MAAM,EAAE,mBAAmB,GAC1B,OAAO,CAAC,MAAM,CAAC,CA6CjB;AAED;;GAEG;AACH,wBAAgB,4BAA4B,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,EAAE,CAmCxE"}

package/dist/aiRefactoring.js

@@ -0,0 +1,290 @@
+/**
+ * Generate AI-powered refactoring suggestions for detected code smells
+ */
+export async function generateAIRefactoringSuggestions(smells, sourceCode, config) {
+    if (!config.apiKey) {
+        console.warn('AI refactoring: No API key provided');
+        return [];
+    }
+    const suggestions = [];
+    // Process smells in batches to avoid rate limits
+    const batchSize = 5;
+    for (let i = 0; i < smells.length; i += batchSize) {
+        const batch = smells.slice(i, i + batchSize);
+        const batchSuggestions = await Promise.all(batch.map(smell => generateSuggestionForSmell(smell, sourceCode, config)));
+        suggestions.push(...batchSuggestions.filter((s) => s !== null));
+    }
+    return suggestions;
+}
+/**
+ * Generate a refactoring suggestion for a single smell
+ */
+async function generateSuggestionForSmell(smell, sourceCode, config) {
+    try {
+        const codeContext = extractCodeContext(sourceCode, smell.line, 10);
+        const prompt = buildRefactoringPrompt(smell, codeContext);
+        const response = await callLLMAPI(prompt, config);
+        if (!response)
+            return null;
+        return {
+            smell,
+            originalCode: codeContext,
+            suggestedCode: response.code || '',
+            explanation: response.explanation || smell.suggestion,
+            confidence: response.confidence || 0.7,
+            estimatedEffort: estimateEffort(smell.type),
+        };
+    }
+    catch (error) {
+        console.error(`AI refactoring failed for ${smell.type}:`, error);
+        return null;
+    }
+}
+/**
+ * Extract code context around a specific line
+ */
+function extractCodeContext(sourceCode, line, contextLines) {
+    const lines = sourceCode.split('\n');
+    const start = Math.max(0, line - contextLines - 1);
+    const end = Math.min(lines.length, line + contextLines);
+    return lines.slice(start, end).join('\n');
+}
+/**
+ * Build the prompt for the LLM
+ */
+function buildRefactoringPrompt(smell, codeContext) {
+    return `You are an expert React developer. Analyze this code smell and provide a refactored solution.
+
+## Code Smell Detected
+- Type: ${smell.type}
+- Severity: ${smell.severity}
+- Message: ${smell.message}
+- Suggestion: ${smell.suggestion}
+
+## Code Context (around line ${smell.line})
+\`\`\`typescript
+${codeContext}
+\`\`\`
+
+## Your Task
+1. Provide the refactored code that fixes this issue
+2. Explain why the refactoring improves the code
+3. Rate your confidence in this suggestion (0-1)
+
+Respond in JSON format:
+{
+  "code": "// refactored code here",
+  "explanation": "Why this refactoring helps...",
+  "confidence": 0.85
+}`;
+}
+/**
+ * Call the LLM API (supports OpenAI and Anthropic)
+ */
+async function callLLMAPI(prompt, config) {
+    const provider = config.provider || 'openai';
+    try {
+        if (provider === 'openai' || provider === 'azure') {
+            return await callOpenAI(prompt, config);
+        }
+        else if (provider === 'anthropic') {
+            return await callAnthropic(prompt, config);
+        }
+    }
+    catch (error) {
+        console.error('LLM API call failed:', error);
+    }
+    return null;
+}
+/**
+ * Call OpenAI API
+ */
+async function callOpenAI(prompt, config) {
+    const response = await fetch('https://api.openai.com/v1/chat/completions', {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            'Authorization': `Bearer ${config.apiKey}`,
+        },
+        body: JSON.stringify({
+            model: config.model || 'gpt-4',
+            messages: [{ role: 'user', content: prompt }],
+            max_tokens: config.maxTokens || 1000,
+            temperature: config.temperature || 0.3,
+        }),
+    });
+    if (!response.ok) {
+        throw new Error(`OpenAI API error: ${response.status}`);
+    }
+    const data = await response.json();
+    const content = data.choices?.[0]?.message?.content;
+    if (!content)
+        return null;
+    try {
+        // Extract JSON from response (it might have markdown formatting)
+        const jsonMatch = content.match(/\{[\s\S]*\}/);
+        if (jsonMatch) {
+            return JSON.parse(jsonMatch[0]);
+        }
+    }
+    catch {
+        // If JSON parsing fails, extract what we can
+        return {
+            code: content,
+            explanation: 'AI-generated suggestion',
+            confidence: 0.5,
+        };
+    }
+    return null;
+}
+/**
+ * Call Anthropic API
+ */
+async function callAnthropic(prompt, config) {
+    const response = await fetch('https://api.anthropic.com/v1/messages', {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            'x-api-key': config.apiKey,
+            'anthropic-version': '2023-06-01',
+        },
+        body: JSON.stringify({
+            model: config.model || 'claude-3-sonnet-20240229',
+            max_tokens: config.maxTokens || 1000,
+            messages: [{ role: 'user', content: prompt }],
+        }),
+    });
+    if (!response.ok) {
+        throw new Error(`Anthropic API error: ${response.status}`);
+    }
+    const data = await response.json();
+    const content = data.content?.[0]?.text;
+    if (!content)
+        return null;
+    try {
+        const jsonMatch = content.match(/\{[\s\S]*\}/);
+        if (jsonMatch) {
+            return JSON.parse(jsonMatch[0]);
+        }
+    }
+    catch {
+        return {
+            code: content,
+            explanation: 'AI-generated suggestion',
+            confidence: 0.5,
+        };
+    }
+    return null;
+}
+/**
+ * Estimate the effort required to fix a smell
+ */
+function estimateEffort(smellType) {
+    const lowEffort = [
+        'debug-statement',
+        'js-var-usage',
+        'js-loose-equality',
+        'a11y-missing-alt',
+        'magic-value',
+        'missing-key',
+    ];
+    const highEffort = [
+        'prop-drilling',
+        'large-component',
+        'circular-dependency',
+        'high-cyclomatic-complexity',
+        'high-cognitive-complexity',
+        'context-overuse',
+        'state-sync-anti-pattern',
+        'complex-untestable',
+    ];
+    if (lowEffort.includes(smellType))
+        return 'low';
+    if (highEffort.includes(smellType))
+        return 'high';
+    return 'medium';
+}
+/**
+ * Generate a summary report with AI insights
+ */
+export async function generateAIAnalysisReport(result, config) {
+    if (!config.apiKey) {
+        return 'AI analysis not available: No API key provided';
+    }
+    const smellsSummary = Object.entries(result.summary.smellsByType)
+        .filter(([, count]) => count > 0)
+        .map(([type, count]) => `- ${type}: ${count}`)
+        .join('\n');
+    const prompt = `Analyze this React codebase analysis result and provide insights:
+
+## Summary
+- Total Files: ${result.summary.totalFiles}
+- Total Components: ${result.summary.totalComponents}
+- Total Smells: ${result.summary.totalSmells}
+- Technical Debt Grade: ${result.debtScore.grade}
+- Debt Score: ${result.debtScore.score}/100
+
+## Smells by Type
+${smellsSummary}
+
+## Severity Distribution
+- Errors: ${result.summary.smellsBySeverity.error}
+- Warnings: ${result.summary.smellsBySeverity.warning}
+- Info: ${result.summary.smellsBySeverity.info}
+
+Provide:
+1. Key insights about the codebase health
+2. Top 3 priority areas to address
+3. Estimated effort to improve the grade
+4. Actionable recommendations
+
+Keep the response concise and actionable.`;
+    try {
+        const response = await callLLMAPI(prompt, config);
+        if (response?.explanation) {
+            return response.explanation;
+        }
+    }
+    catch (error) {
+        console.error('AI analysis report failed:', error);
+    }
+    return 'AI analysis could not be generated';
+}
+/**
+ * Get refactoring suggestions for specific smell types
+ */
+export function getQuickRefactoringTemplates(smellType) {
+    const templates = {
+        'useEffect-overuse': [
+            'Consider combining related effects into a single useEffect',
+            'Extract complex effect logic into custom hooks',
+            'Use useReducer for complex state logic instead of multiple effects',
+        ],
+        'prop-drilling': [
+            'Use React Context for deeply shared state',
+            'Consider component composition (children pattern)',
+            'Extract a custom hook for related props',
+        ],
+        'large-component': [
+            'Extract logical sections into separate components',
+            'Move hooks to custom hook files',
+            'Use component composition patterns',
+        ],
+        'context-overuse': [
+            'Split context into smaller, focused contexts',
+            'Use component composition instead of context',
+            'Consider using a state management library for complex needs',
+        ],
+        'missing-error-boundary': [
+            'Wrap async components with ErrorBoundary',
+            'Add Suspense wrappers for lazy-loaded components',
+            'Use react-error-boundary library for consistent handling',
+        ],
+        'state-sync-anti-pattern': [
+            'Derive values during render instead of syncing in effects',
+            'Use a key prop to reset component state',
+            'Consider useMemo for computed values',
+        ],
+    };
+    return templates[smellType] || ['Review the code smell suggestion for improvement ideas'];
+}

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;AA0SD,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,35 @@ 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,
+        // Context API issues
+        'context-overuse': 0,
+        'context-in-loop': 0,
+        'missing-context-memo': 0,
+        'large-context-value': 0,
+        // Error Boundary issues
+        'missing-error-boundary': 0,
+        'error-boundary-missing-fallback': 0,
+        'suspense-missing-fallback': 0,
+        // Form validation issues
+        'uncontrolled-form': 0,
+        'missing-form-validation': 0,
+        'form-without-onsubmit': 0,
+        'input-without-label': 0,
+        // State management issues
+        'redux-in-render': 0,
+        'excessive-redux-selectors': 0,
+        'state-sync-anti-pattern': 0,
+        'derived-state-in-state': 0,
+        // Testing gaps
+        'complex-untestable': 0,
+        'side-effect-heavy': 0,
+        'tightly-coupled': 0,
         // Custom rules
         'custom-rule': 0,
     };