react-code-smell-detector 1.5.0 → 1.5.1

package/README.md

@@ -81,6 +81,26 @@ npm install -D react-code-smell-detector
 react-smell /path/to/react/project
 ```
 
+### Interactive Guide
+
+Launch an interactive tutorial to learn all features:
+
+```bash
+react-smell guide
+```
+
+### Demo Project
+
+Create a demo project with examples of all detectable code smells:
+
+```bash
+react-smell demo
+# Creates ./react-smell-demo with sample components
+
+# Or specify a directory
+react-smell demo /path/to/directory
+```
+
 ### With Code Snippets
 
 ```bash

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

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

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

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

package/dist/__tests__/aiRefactoring.test.js

@@ -0,0 +1,86 @@
+import { describe, it, expect } from 'vitest';
+import { getQuickRefactoringTemplates } from '../aiRefactoring.js';
+describe('AI Refactoring', () => {
+    describe('getQuickRefactoringTemplates', () => {
+        it('should return templates for useEffect-overuse', () => {
+            const templates = getQuickRefactoringTemplates('useEffect-overuse');
+            expect(templates.length).toBeGreaterThan(0);
+            expect(templates.some(t => t.includes('effect'))).toBe(true);
+        });
+        it('should return templates for prop-drilling', () => {
+            const templates = getQuickRefactoringTemplates('prop-drilling');
+            expect(templates.length).toBeGreaterThan(0);
+            expect(templates.some(t => t.includes('Context') || t.includes('composition'))).toBe(true);
+        });
+        it('should return templates for large-component', () => {
+            const templates = getQuickRefactoringTemplates('large-component');
+            expect(templates.length).toBeGreaterThan(0);
+            expect(templates.some(t => t.includes('Extract') || t.includes('component'))).toBe(true);
+        });
+        it('should return templates for context-overuse', () => {
+            const templates = getQuickRefactoringTemplates('context-overuse');
+            expect(templates.length).toBeGreaterThan(0);
+            expect(templates.some(t => t.includes('context'))).toBe(true);
+        });
+        it('should return templates for missing-error-boundary', () => {
+            const templates = getQuickRefactoringTemplates('missing-error-boundary');
+            expect(templates.length).toBeGreaterThan(0);
+            expect(templates.some(t => t.includes('ErrorBoundary') || t.includes('Suspense'))).toBe(true);
+        });
+        it('should return templates for state-sync-anti-pattern', () => {
+            const templates = getQuickRefactoringTemplates('state-sync-anti-pattern');
+            expect(templates.length).toBeGreaterThan(0);
+            expect(templates.some(t => t.includes('Derive') || t.includes('useMemo'))).toBe(true);
+        });
+        it('should return generic template for unknown smell types', () => {
+            const templates = getQuickRefactoringTemplates('unknown-smell-type');
+            expect(templates.length).toBeGreaterThan(0);
+            expect(templates[0]).toContain('Review');
+        });
+    });
+    describe('AIRefactoringConfig', () => {
+        it('should accept valid config object', () => {
+            const config = {
+                apiKey: 'test-key',
+                model: 'gpt-4',
+                maxTokens: 1000,
+                temperature: 0.3,
+                provider: 'openai',
+            };
+            expect(config.apiKey).toBe('test-key');
+            expect(config.model).toBe('gpt-4');
+            expect(config.provider).toBe('openai');
+        });
+        it('should accept anthropic provider', () => {
+            const config = {
+                apiKey: 'test-key',
+                model: 'claude-3-sonnet',
+                provider: 'anthropic',
+            };
+            expect(config.provider).toBe('anthropic');
+        });
+    });
+    describe('AIRefactoringSuggestion type', () => {
+        it('should have expected structure', () => {
+            const suggestion = {
+                smell: {
+                    type: 'debug-statement',
+                    severity: 'warning',
+                    message: 'Test',
+                    file: '/test.tsx',
+                    line: 1,
+                    column: 0,
+                    suggestion: 'Remove it',
+                },
+                originalCode: 'console.log("test")',
+                suggestedCode: '// removed',
+                explanation: 'Debug statements should be removed',
+                confidence: 0.9,
+                estimatedEffort: 'low',
+            };
+            expect(suggestion.confidence).toBeGreaterThanOrEqual(0);
+            expect(suggestion.confidence).toBeLessThanOrEqual(1);
+            expect(['low', 'medium', 'high']).toContain(suggestion.estimatedEffort);
+        });
+    });
+});

package/dist/__tests__/analyzer-real.test.d.ts

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

package/dist/__tests__/analyzer-real.test.d.ts.map

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

package/dist/__tests__/analyzer-real.test.js

@@ -0,0 +1,149 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { analyzeProject } from '../analyzer.js';
+import * as fg from 'fast-glob';
+import * as fs from 'fs/promises';
+// Mock fast-glob
+vi.mock('fast-glob', () => ({
+    default: vi.fn(),
+}));
+// Mock fs/promises for parseFile
+vi.mock('fs/promises', async (importOriginal) => {
+    const actual = await importOriginal();
+    return {
+        ...actual,
+        default: actual,
+        readFile: vi.fn(),
+    };
+});
+describe('Analyzer - Real Tests', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    describe('analyzeProject', () => {
+        it('should return empty results when no files found', async () => {
+            fg.default.mockResolvedValue([]);
+            const result = await analyzeProject({
+                rootDir: '/fake/path',
+            });
+            expect(result.files).toEqual([]);
+            expect(result.summary.totalFiles).toBe(0);
+            expect(result.summary.totalComponents).toBe(0);
+            expect(result.summary.totalSmells).toBe(0);
+        });
+        it('should call fast-glob with correct patterns', async () => {
+            fg.default.mockResolvedValue([]);
+            await analyzeProject({
+                rootDir: '/fake/path',
+                include: ['**/*.tsx'],
+            });
+            expect(fg.default).toHaveBeenCalled();
+        });
+        it('should handle parse errors gracefully', async () => {
+            fg.default.mockResolvedValue(['/fake/path/broken.tsx']);
+            const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => { });
+            const result = await analyzeProject({
+                rootDir: '/fake/path',
+            });
+            // Should return empty since file doesn't exist
+            expect(result.files.length).toBe(0);
+            warnSpy.mockRestore();
+        });
+        it('should use custom include patterns', async () => {
+            fg.default.mockResolvedValue([]);
+            await analyzeProject({
+                rootDir: '/fake/path',
+                include: ['**/*.ts'],
+                exclude: ['**/node_modules/**'],
+            });
+            expect(fg.default).toHaveBeenCalledWith(expect.arrayContaining([expect.stringContaining('.ts')]), expect.objectContaining({ ignore: ['**/node_modules/**'] }));
+        });
+        it('should merge user config with defaults', async () => {
+            fg.default.mockResolvedValue([]);
+            const result = await analyzeProject({
+                rootDir: '/fake/path',
+                config: { maxUseEffectsPerComponent: 5 },
+            });
+            expect(result.summary).toBeDefined();
+        });
+    });
+    describe('Technical Debt Score Calculation', () => {
+        it('should calculate grade A for clean projects', async () => {
+            const cleanCode = `
+        function CleanComponent() {
+          return <div>Clean</div>;
+        }
+      `;
+            fg.default.mockResolvedValue(['/fake/path/Clean.tsx']);
+            fs.readFile.mockResolvedValue(cleanCode);
+            const result = await analyzeProject({
+                rootDir: '/fake/path',
+                config: { checkDebugStatements: false },
+            });
+            expect(result.debtScore.grade).toBe('A');
+            expect(result.debtScore.score).toBeGreaterThanOrEqual(90);
+        });
+        it('should estimate refactor time based on issues', async () => {
+            fg.default.mockResolvedValue([]);
+            const result = await analyzeProject({
+                rootDir: '/fake/path',
+            });
+            expect(result.debtScore.estimatedRefactorTime).toBeDefined();
+        });
+        it('should include breakdown scores', async () => {
+            fg.default.mockResolvedValue([]);
+            const result = await analyzeProject({
+                rootDir: '/fake/path',
+            });
+            expect(result.debtScore.breakdown).toBeDefined();
+            expect(result.debtScore.breakdown.useEffectScore).toBeDefined();
+            expect(result.debtScore.breakdown.propDrillingScore).toBeDefined();
+            expect(result.debtScore.breakdown.componentSizeScore).toBeDefined();
+            expect(result.debtScore.breakdown.memoizationScore).toBeDefined();
+        });
+    });
+    describe('Smell Ignore Comments', () => {
+        it('should filter smells with @smell-ignore comment', async () => {
+            // Test behavior: when no files match, result should be empty
+            fg.default.mockResolvedValue([]);
+            const result = await analyzeProject({
+                rootDir: '/fake/path',
+                config: { checkDebugStatements: true },
+            });
+            // Empty result with no smells
+            expect(result.files.length).toBe(0);
+            expect(result.summary.totalSmells).toBe(0);
+        });
+    });
+    describe('Summary Calculation', () => {
+        it('should have smells by type structure', async () => {
+            fg.default.mockResolvedValue([]);
+            const result = await analyzeProject({
+                rootDir: '/fake/path',
+                config: { checkDebugStatements: true },
+            });
+            // Should have smellsByType object even if empty
+            expect(result.summary.smellsByType).toBeDefined();
+        });
+        it('should aggregate smells by severity', async () => {
+            fg.default.mockResolvedValue([]);
+            const result = await analyzeProject({
+                rootDir: '/fake/path',
+            });
+            expect(result.summary.smellsBySeverity).toBeDefined();
+            expect(result.summary.smellsBySeverity.error).toBeDefined();
+            expect(result.summary.smellsBySeverity.warning).toBeDefined();
+            expect(result.summary.smellsBySeverity.info).toBeDefined();
+        });
+    });
+    describe('Component Info Collection', () => {
+        it('should return components array in file results', async () => {
+            // Test that result structure includes components array
+            fg.default.mockResolvedValue([]);
+            const result = await analyzeProject({
+                rootDir: '/fake/path',
+            });
+            // For non-existent files, we get empty results
+            expect(Array.isArray(result.files)).toBe(true);
+        });
+    });
+});

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

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

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

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

package/dist/__tests__/analyzer.test.js

@@ -0,0 +1,173 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+// Mock dependencies for analyzer
+vi.mock('fast-glob', () => ({
+    default: vi.fn().mockResolvedValue([]),
+}));
+vi.mock('ora', () => ({
+    default: () => ({
+        start: vi.fn().mockReturnThis(),
+        succeed: vi.fn().mockReturnThis(),
+        fail: vi.fn().mockReturnThis(),
+        stop: vi.fn().mockReturnThis(),
+        text: '',
+    }),
+}));
+describe('Analyzer', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    describe('analyzeProject', () => {
+        it('should accept project path', () => {
+            const projectPath = '/path/to/project';
+            expect(typeof projectPath).toBe('string');
+        });
+        it('should accept options object', () => {
+            const options = {
+                verbose: true,
+                fix: false,
+                format: 'json',
+            };
+            expect(options.verbose).toBe(true);
+            expect(options.fix).toBe(false);
+            expect(options.format).toBe('json');
+        });
+        it('should handle default options', () => {
+            const defaultOptions = {
+                verbose: false,
+                fix: false,
+                format: 'console',
+                include: ['**/*.tsx', '**/*.jsx', '**/*.ts', '**/*.js'],
+                exclude: ['node_modules/**', 'dist/**', 'build/**'],
+            };
+            expect(defaultOptions.include).toContain('**/*.tsx');
+            expect(defaultOptions.exclude).toContain('node_modules/**');
+        });
+        it('should support various output formats', () => {
+            const formats = ['json', 'console', 'markdown', 'html', 'sarif'];
+            formats.forEach(format => {
+                expect(['json', 'console', 'markdown', 'html', 'sarif']).toContain(format);
+            });
+        });
+    });
+    describe('File pattern matching', () => {
+        it('should match React file extensions', () => {
+            const patterns = ['**/*.tsx', '**/*.jsx', '**/*.ts', '**/*.js'];
+            const testFiles = [
+                'src/App.tsx',
+                'src/utils/helper.ts',
+                'components/Button.jsx',
+                'lib/index.js',
+            ];
+            testFiles.forEach(file => {
+                const matches = patterns.some(pattern => {
+                    const ext = pattern.replace('**/*', '');
+                    return file.endsWith(ext);
+                });
+                expect(matches).toBe(true);
+            });
+        });
+        it('should exclude node_modules and build dirs', () => {
+            const excludePatterns = ['node_modules/**', 'dist/**', 'build/**'];
+            const shouldExclude = (file) => {
+                return excludePatterns.some(pattern => {
+                    const dir = pattern.replace('/**', '');
+                    return file.startsWith(dir + '/') || file.startsWith(dir);
+                });
+            };
+            expect(shouldExclude('node_modules/react/index.js')).toBe(true);
+            expect(shouldExclude('dist/bundle.js')).toBe(true);
+            expect(shouldExclude('build/output.js')).toBe(true);
+            expect(shouldExclude('src/App.tsx')).toBe(false);
+        });
+    });
+    describe('Options validation', () => {
+        it('should validate format option', () => {
+            const validFormats = ['json', 'console', 'markdown', 'html', 'sarif'];
+            const isValidFormat = (format) => validFormats.includes(format);
+            expect(isValidFormat('json')).toBe(true);
+            expect(isValidFormat('invalid')).toBe(false);
+        });
+        it('should validate threshold is positive number', () => {
+            const isValidThreshold = (threshold) => {
+                return typeof threshold === 'number' && threshold >= 0;
+            };
+            expect(isValidThreshold(10)).toBe(true);
+            expect(isValidThreshold(0)).toBe(true);
+            expect(isValidThreshold(-1)).toBe(false);
+            expect(isValidThreshold('10')).toBe(false);
+        });
+        it('should validate custom rules path', () => {
+            const isValidPath = (path) => {
+                return typeof path === 'string' && path.length > 0;
+            };
+            expect(isValidPath('./rules.json')).toBe(true);
+            expect(isValidPath('')).toBe(false);
+            expect(isValidPath(null)).toBe(false);
+        });
+    });
+    describe('Analysis results structure', () => {
+        it('should have correct result shape', () => {
+            const mockResult = {
+                smells: [],
+                filesAnalyzed: 10,
+                totalSmells: 0,
+                byType: {},
+                bySeverity: { error: 0, warning: 0, info: 0 },
+            };
+            expect(mockResult).toHaveProperty('smells');
+            expect(mockResult).toHaveProperty('filesAnalyzed');
+            expect(mockResult).toHaveProperty('totalSmells');
+            expect(mockResult).toHaveProperty('byType');
+            expect(mockResult).toHaveProperty('bySeverity');
+        });
+        it('should aggregate smells by type', () => {
+            const smells = [
+                { type: 'debug-statement' },
+                { type: 'debug-statement' },
+                { type: 'js-var-usage' },
+            ];
+            const byType = smells.reduce((acc, s) => {
+                acc[s.type] = (acc[s.type] || 0) + 1;
+                return acc;
+            }, {});
+            expect(byType['debug-statement']).toBe(2);
+            expect(byType['js-var-usage']).toBe(1);
+        });
+        it('should aggregate smells by severity', () => {
+            const smells = [
+                { severity: 'error' },
+                { severity: 'warning' },
+                { severity: 'warning' },
+                { severity: 'info' },
+            ];
+            const bySeverity = smells.reduce((acc, s) => {
+                acc[s.severity] = (acc[s.severity] || 0) + 1;
+                return acc;
+            }, { error: 0, warning: 0, info: 0 });
+            expect(bySeverity.error).toBe(1);
+            expect(bySeverity.warning).toBe(2);
+            expect(bySeverity.info).toBe(1);
+        });
+    });
+    describe('Performance', () => {
+        it('should batch file processing efficiently', () => {
+            const files = Array(100).fill(null).map((_, i) => `file${i}.tsx`);
+            const batchSize = 10;
+            const batches = [];
+            for (let i = 0; i < files.length; i += batchSize) {
+                batches.push(files.slice(i, i + batchSize));
+            }
+            expect(batches).toHaveLength(10);
+            expect(batches[0]).toHaveLength(10);
+        });
+        it('should handle concurrent file analysis', async () => {
+            const analyzeFile = async (file) => {
+                return { file, smells: [] };
+            };
+            const files = ['a.tsx', 'b.tsx', 'c.tsx'];
+            const results = await Promise.all(files.map(analyzeFile));
+            expect(results).toHaveLength(3);
+            expect(results[0].file).toBe('a.tsx');
+        });
+    });
+});

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

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

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

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

package/dist/__tests__/baseline.test.js

@@ -0,0 +1,136 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { initializeBaseline, recordBaseline, getTrendAnalysis } from '../baseline.js';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+describe('Baseline', () => {
+    let tempDir;
+    beforeEach(() => {
+        // Create a temporary directory for tests
+        tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'baseline-test-'));
+    });
+    afterEach(() => {
+        // Clean up temporary directory
+        try {
+            fs.rmSync(tempDir, { recursive: true });
+        }
+        catch {
+            // Ignore cleanup errors
+        }
+    });
+    const createSmell = (type) => ({
+        type: type,
+        severity: 'warning',
+        message: 'Test smell',
+        file: '/test.tsx',
+        line: 1,
+        column: 0,
+        suggestion: 'Fix it',
+    });
+    describe('initializeBaseline', () => {
+        it('should create baseline file if it does not exist', () => {
+            initializeBaseline(tempDir);
+            const baselinePath = path.join(tempDir, '.smellrc-baseline.json');
+            expect(fs.existsSync(baselinePath)).toBe(true);
+        });
+        it('should not overwrite existing baseline file', () => {
+            const baselinePath = path.join(tempDir, '.smellrc-baseline.json');
+            // Create initial baseline
+            initializeBaseline(tempDir);
+            // Add a record
+            recordBaseline(tempDir, [createSmell('debug-statement')]);
+            // Reinitialize
+            initializeBaseline(tempDir);
+            // Check that record still exists
+            const data = JSON.parse(fs.readFileSync(baselinePath, 'utf-8'));
+            expect(data.records.length).toBeGreaterThan(0);
+        });
+        it('should create valid JSON structure', () => {
+            initializeBaseline(tempDir);
+            const baselinePath = path.join(tempDir, '.smellrc-baseline.json');
+            const data = JSON.parse(fs.readFileSync(baselinePath, 'utf-8'));
+            expect(data.version).toBe('1.0');
+            expect(Array.isArray(data.records)).toBe(true);
+        });
+    });
+    describe('recordBaseline', () => {
+        it('should add a record to baseline', () => {
+            initializeBaseline(tempDir);
+            const smells = [createSmell('debug-statement'), createSmell('js-var-usage')];
+            const record = recordBaseline(tempDir, smells);
+            expect(record.totalSmells).toBe(2);
+            expect(record.byType['debug-statement']).toBe(1);
+            expect(record.byType['js-var-usage']).toBe(1);
+        });
+        it('should include timestamp', () => {
+            initializeBaseline(tempDir);
+            const record = recordBaseline(tempDir, [createSmell('debug-statement')]);
+            expect(record.timestamp).toBeDefined();
+            expect(new Date(record.timestamp).getTime()).toBeLessThanOrEqual(Date.now());
+        });
+        it('should include commit hash when provided', () => {
+            initializeBaseline(tempDir);
+            const record = recordBaseline(tempDir, [createSmell('debug-statement')], 'abc123');
+            expect(record.commit).toBe('abc123');
+        });
+        it('should keep only last 50 records', () => {
+            initializeBaseline(tempDir);
+            // Add 55 records
+            for (let i = 0; i < 55; i++) {
+                recordBaseline(tempDir, [createSmell('debug-statement')]);
+            }
+            const baselinePath = path.join(tempDir, '.smellrc-baseline.json');
+            const data = JSON.parse(fs.readFileSync(baselinePath, 'utf-8'));
+            expect(data.records.length).toBe(50);
+        });
+        it('should limit stored smells to 100', () => {
+            initializeBaseline(tempDir);
+            // Create 150 smells
+            const manySmells = Array(150).fill(null).map(() => createSmell('debug-statement'));
+            const record = recordBaseline(tempDir, manySmells);
+            expect(record.totalSmells).toBe(150);
+            expect(record.smells.length).toBe(100);
+        });
+    });
+    describe('getTrendAnalysis', () => {
+        it('should return stable when no baseline exists', () => {
+            const trend = getTrendAnalysis(tempDir);
+            expect(trend.trend).toBe('stable');
+            expect(trend.improved).toBe(0);
+            expect(trend.worsened).toBe(0);
+        });
+        it('should return stable with only one record', () => {
+            initializeBaseline(tempDir);
+            recordBaseline(tempDir, [createSmell('debug-statement')]);
+            const trend = getTrendAnalysis(tempDir);
+            expect(trend.trend).toBe('stable');
+        });
+        it('should detect improving trend', () => {
+            initializeBaseline(tempDir);
+            // First record: 5 smells
+            recordBaseline(tempDir, Array(5).fill(null).map(() => createSmell('debug-statement')));
+            // Second record: 3 smells (improved)
+            recordBaseline(tempDir, Array(3).fill(null).map(() => createSmell('debug-statement')));
+            const trend = getTrendAnalysis(tempDir);
+            expect(trend.trend).toBe('improving');
+            expect(trend.improved).toBe(2);
+        });
+        it('should detect worsening trend', () => {
+            initializeBaseline(tempDir);
+            // First record: 3 smells
+            recordBaseline(tempDir, Array(3).fill(null).map(() => createSmell('debug-statement')));
+            // Second record: 5 smells (worsened)
+            recordBaseline(tempDir, Array(5).fill(null).map(() => createSmell('debug-statement')));
+            const trend = getTrendAnalysis(tempDir);
+            expect(trend.trend).toBe('worsening');
+            expect(trend.worsened).toBe(2);
+        });
+        it('should return stable when same count', () => {
+            initializeBaseline(tempDir);
+            recordBaseline(tempDir, Array(3).fill(null).map(() => createSmell('debug-statement')));
+            recordBaseline(tempDir, Array(3).fill(null).map(() => createSmell('js-var-usage')));
+            const trend = getTrendAnalysis(tempDir);
+            expect(trend.trend).toBe('stable');
+        });
+    });
+});

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

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

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

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