react-code-smell-detector 1.0.0 → 1.1.1

package/dist/detectors/nodejs.js

@@ -0,0 +1,169 @@
+import * as t from '@babel/types';
+import { getCodeSnippet } from '../parser/index.js';
+import { DEFAULT_CONFIG } from '../types/index.js';
+/**
+ * Detects Node.js-specific code smells:
+ * - Callback hell (deeply nested callbacks)
+ * - Unhandled promise rejections
+ * - Synchronous I/O operations
+ * - Missing error handling
+ */
+export function detectNodejsIssues(component, filePath, sourceCode, config = DEFAULT_CONFIG, imports = []) {
+    if (!config.checkNodejs)
+        return [];
+    // Check if this looks like a Node.js file
+    const isNodeFile = imports.some(imp => imp.includes('fs') || imp.includes('path') || imp.includes('http') ||
+        imp.includes('express') || imp.includes('child_process') ||
+        imp.includes('crypto') || imp.includes('os') || imp.includes('stream')) || filePath.includes('.server.') || filePath.includes('/api/');
+    if (!isNodeFile)
+        return [];
+    const smells = [];
+    // Detect callback hell (nested callbacks > maxCallbackDepth)
+    component.path.traverse({
+        CallExpression(path) {
+            const depth = getCallbackDepth(path);
+            if (depth > config.maxCallbackDepth) {
+                const loc = path.node.loc;
+                smells.push({
+                    type: 'nodejs-callback-hell',
+                    severity: 'warning',
+                    message: `Callback hell detected (depth: ${depth}) in "${component.name}"`,
+                    file: filePath,
+                    line: loc?.start.line || 0,
+                    column: loc?.start.column || 0,
+                    suggestion: 'Refactor to async/await or use Promise.all() for parallel operations',
+                    codeSnippet: getCodeSnippet(sourceCode, loc?.start.line || 0),
+                });
+            }
+        },
+    });
+    // Detect unhandled promise rejections (Promise without .catch or try/catch)
+    component.path.traverse({
+        CallExpression(path) {
+            // Check for .then() without .catch()
+            if (t.isMemberExpression(path.node.callee) &&
+                t.isIdentifier(path.node.callee.property) &&
+                path.node.callee.property.name === 'then') {
+                // Check if followed by .catch() in chain
+                const parent = path.parent;
+                let hasCatch = false;
+                if (t.isMemberExpression(parent)) {
+                    const prop = parent.property;
+                    if (t.isIdentifier(prop) && prop.name === 'catch') {
+                        hasCatch = true;
+                    }
+                }
+                // Check if inside try block
+                let current = path;
+                while (current) {
+                    if (t.isTryStatement(current.node)) {
+                        hasCatch = true;
+                        break;
+                    }
+                    current = current.parentPath;
+                }
+                if (!hasCatch) {
+                    const loc = path.node.loc;
+                    smells.push({
+                        type: 'nodejs-unhandled-promise',
+                        severity: 'warning',
+                        message: `.then() without .catch() in "${component.name}"`,
+                        file: filePath,
+                        line: loc?.start.line || 0,
+                        column: loc?.start.column || 0,
+                        suggestion: 'Add .catch() to handle rejections, or use try/catch with async/await',
+                        codeSnippet: getCodeSnippet(sourceCode, loc?.start.line || 0),
+                    });
+                }
+            }
+        },
+    });
+    // Detect synchronous file operations
+    const syncMethods = ['readFileSync', 'writeFileSync', 'appendFileSync', 'readdirSync',
+        'statSync', 'mkdirSync', 'rmdirSync', 'unlinkSync', 'existsSync'];
+    component.path.traverse({
+        CallExpression(path) {
+            const callee = path.node.callee;
+            if (t.isMemberExpression(callee) && t.isIdentifier(callee.property)) {
+                if (syncMethods.includes(callee.property.name)) {
+                    const loc = path.node.loc;
+                    smells.push({
+                        type: 'nodejs-sync-io',
+                        severity: 'warning',
+                        message: `Synchronous file operation "${callee.property.name}" blocks event loop`,
+                        file: filePath,
+                        line: loc?.start.line || 0,
+                        column: loc?.start.column || 0,
+                        suggestion: `Use async version: ${callee.property.name.replace('Sync', '')} with await or promises`,
+                        codeSnippet: getCodeSnippet(sourceCode, loc?.start.line || 0),
+                    });
+                }
+            }
+            // Direct function call
+            if (t.isIdentifier(callee) && syncMethods.includes(callee.name)) {
+                const loc = path.node.loc;
+                smells.push({
+                    type: 'nodejs-sync-io',
+                    severity: 'warning',
+                    message: `Synchronous file operation "${callee.name}" blocks event loop`,
+                    file: filePath,
+                    line: loc?.start.line || 0,
+                    column: loc?.start.column || 0,
+                    suggestion: `Use async version: ${callee.name.replace('Sync', '')} with await or promises`,
+                    codeSnippet: getCodeSnippet(sourceCode, loc?.start.line || 0),
+                });
+            }
+        },
+    });
+    // Detect missing error handling in async functions
+    component.path.traverse({
+        AwaitExpression(path) {
+            // Check if inside try block
+            let insideTry = false;
+            let current = path;
+            while (current) {
+                if (t.isTryStatement(current.node)) {
+                    insideTry = true;
+                    break;
+                }
+                // Stop at function boundary
+                if (t.isFunction(current.node))
+                    break;
+                current = current.parentPath;
+            }
+            if (!insideTry) {
+                // Check if the parent function has error handling at call site
+                // This is a simplified check - in practice you'd want more context
+                const loc = path.node.loc;
+                smells.push({
+                    type: 'nodejs-missing-error-handling',
+                    severity: 'info',
+                    message: `await without try/catch may cause unhandled rejections`,
+                    file: filePath,
+                    line: loc?.start.line || 0,
+                    column: loc?.start.column || 0,
+                    suggestion: 'Wrap await in try/catch or handle errors at the call site',
+                    codeSnippet: getCodeSnippet(sourceCode, loc?.start.line || 0),
+                });
+            }
+        },
+    });
+    return smells;
+}
+/**
+ * Calculate the depth of nested callbacks
+ */
+function getCallbackDepth(path) {
+    let depth = 0;
+    let current = path;
+    while (current) {
+        const node = current.node;
+        // Count function expressions that are arguments to calls
+        if ((t.isFunctionExpression(node) || t.isArrowFunctionExpression(node)) &&
+            t.isCallExpression(current.parent)) {
+            depth++;
+        }
+        current = current.parentPath;
+    }
+    return depth;
+}

package/dist/detectors/reactNative.d.ts

@@ -0,0 +1,10 @@
+import { ParsedComponent } from '../parser/index.js';
+import { CodeSmell, DetectorConfig } from '../types/index.js';
+/**
+ * Detects React Native-specific code smells:
+ * - Inline styles instead of StyleSheet
+ * - Missing accessibility props
+ * - Performance anti-patterns
+ */
+export declare function detectReactNativeIssues(component: ParsedComponent, filePath: string, sourceCode: string, config?: DetectorConfig, imports?: string[]): CodeSmell[];
+//# sourceMappingURL=reactNative.d.ts.map

package/dist/detectors/reactNative.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reactNative.d.ts","sourceRoot":"","sources":["../../src/detectors/reactNative.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,eAAe,EAAkB,MAAM,oBAAoB,CAAC;AACrE,OAAO,EAAE,SAAS,EAAE,cAAc,EAAkB,MAAM,mBAAmB,CAAC;AAE9E;;;;;GAKG;AACH,wBAAgB,uBAAuB,CACrC,SAAS,EAAE,eAAe,EAC1B,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,MAAM,EAClB,MAAM,GAAE,cAA+B,EACvC,OAAO,GAAE,MAAM,EAAO,GACrB,SAAS,EAAE,CAwIb"}

package/dist/detectors/reactNative.js

@@ -0,0 +1,135 @@
+import * as t from '@babel/types';
+import { getCodeSnippet } from '../parser/index.js';
+import { DEFAULT_CONFIG } from '../types/index.js';
+/**
+ * Detects React Native-specific code smells:
+ * - Inline styles instead of StyleSheet
+ * - Missing accessibility props
+ * - Performance anti-patterns
+ */
+export function detectReactNativeIssues(component, filePath, sourceCode, config = DEFAULT_CONFIG, imports = []) {
+    if (!config.checkReactNative)
+        return [];
+    // Only run on React Native projects
+    const isRNProject = imports.some(imp => imp.includes('react-native') || imp.includes('@react-native'));
+    if (!isRNProject)
+        return [];
+    const smells = [];
+    const inlineStyleLines = new Set();
+    // Check for inline styles instead of StyleSheet
+    component.path.traverse({
+        JSXAttribute(path) {
+            if (!t.isJSXIdentifier(path.node.name))
+                return;
+            if (path.node.name.name !== 'style')
+                return;
+            const value = path.node.value;
+            if (!t.isJSXExpressionContainer(value))
+                return;
+            // Check if it's an inline object (not a StyleSheet reference)
+            if (t.isObjectExpression(value.expression)) {
+                const loc = path.node.loc;
+                const line = loc?.start.line || 0;
+                if (!inlineStyleLines.has(line)) {
+                    inlineStyleLines.add(line);
+                    smells.push({
+                        type: 'rn-inline-style',
+                        severity: 'warning',
+                        message: `Inline style object in "${component.name}" - prefer StyleSheet.create()`,
+                        file: filePath,
+                        line,
+                        column: loc?.start.column || 0,
+                        suggestion: 'Use StyleSheet.create() for better performance: const styles = StyleSheet.create({ ... })',
+                        codeSnippet: getCodeSnippet(sourceCode, line),
+                    });
+                }
+            }
+        },
+    });
+    // Check for missing accessibility props on interactive elements
+    const interactiveComponents = ['TouchableOpacity', 'TouchableHighlight', 'Pressable', 'Button', 'TouchableWithoutFeedback'];
+    component.path.traverse({
+        JSXOpeningElement(path) {
+            if (!t.isJSXIdentifier(path.node.name))
+                return;
+            const componentName = path.node.name.name;
+            if (!interactiveComponents.includes(componentName))
+                return;
+            // Check for accessibility props
+            const hasAccessibilityLabel = path.node.attributes.some(attr => {
+                if (t.isJSXAttribute(attr) && t.isJSXIdentifier(attr.name)) {
+                    return ['accessibilityLabel', 'accessible', 'accessibilityRole', 'accessibilityHint'].includes(attr.name.name);
+                }
+                return false;
+            });
+            if (!hasAccessibilityLabel) {
+                const loc = path.node.loc;
+                smells.push({
+                    type: 'rn-missing-accessibility',
+                    severity: 'info',
+                    message: `${componentName} missing accessibility props in "${component.name}"`,
+                    file: filePath,
+                    line: loc?.start.line || 0,
+                    column: loc?.start.column || 0,
+                    suggestion: 'Add accessibilityLabel and accessibilityRole for screen readers',
+                    codeSnippet: getCodeSnippet(sourceCode, loc?.start.line || 0),
+                });
+            }
+        },
+    });
+    // Check for performance anti-patterns
+    component.path.traverse({
+        // Detect creating anonymous functions in render (for onPress, etc.)
+        JSXAttribute(path) {
+            if (!t.isJSXIdentifier(path.node.name))
+                return;
+            const propName = path.node.name.name;
+            if (!['onPress', 'onPressIn', 'onPressOut', 'onLongPress'].includes(propName))
+                return;
+            const value = path.node.value;
+            if (!t.isJSXExpressionContainer(value))
+                return;
+            // Check for arrow functions or function expressions
+            if (t.isArrowFunctionExpression(value.expression) || t.isFunctionExpression(value.expression)) {
+                const loc = path.node.loc;
+                smells.push({
+                    type: 'rn-performance-issue',
+                    severity: 'info',
+                    message: `Inline function for ${propName} in "${component.name}" creates new reference each render`,
+                    file: filePath,
+                    line: loc?.start.line || 0,
+                    column: loc?.start.column || 0,
+                    suggestion: 'Extract to useCallback or class method to prevent unnecessary re-renders',
+                    codeSnippet: getCodeSnippet(sourceCode, loc?.start.line || 0),
+                });
+            }
+        },
+        // Detect array spreads in render that could be memoized
+        SpreadElement(path) {
+            const loc = path.node.loc;
+            // Only flag if inside JSX or return statement
+            let inJSX = false;
+            let current = path.parentPath;
+            while (current) {
+                if (t.isJSXElement(current.node) || t.isJSXFragment(current.node)) {
+                    inJSX = true;
+                    break;
+                }
+                current = current.parentPath;
+            }
+            if (inJSX && t.isArrayExpression(path.parent)) {
+                smells.push({
+                    type: 'rn-performance-issue',
+                    severity: 'info',
+                    message: `Array spread in render may cause performance issues in "${component.name}"`,
+                    file: filePath,
+                    line: loc?.start.line || 0,
+                    column: loc?.start.column || 0,
+                    suggestion: 'Consider memoizing with useMemo if this array is passed as a prop',
+                    codeSnippet: getCodeSnippet(sourceCode, loc?.start.line || 0),
+                });
+            }
+        },
+    });
+    return smells;
+}

package/dist/detectors/typescript.d.ts

@@ -0,0 +1,11 @@
+import { ParsedComponent } from '../parser/index.js';
+import { CodeSmell, DetectorConfig } from '../types/index.js';
+/**
+ * Detects TypeScript-specific code smells:
+ * - Overuse of 'any' type
+ * - Missing return type on functions
+ * - Non-null assertion operator (!)
+ * - Type assertions (as) that could be avoided
+ */
+export declare function detectTypescriptIssues(component: ParsedComponent, filePath: string, sourceCode: string, config?: DetectorConfig): CodeSmell[];
+//# sourceMappingURL=typescript.d.ts.map

package/dist/detectors/typescript.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typescript.d.ts","sourceRoot":"","sources":["../../src/detectors/typescript.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,eAAe,EAAkB,MAAM,oBAAoB,CAAC;AACrE,OAAO,EAAE,SAAS,EAAE,cAAc,EAAkB,MAAM,mBAAmB,CAAC;AAE9E;;;;;;GAMG;AACH,wBAAgB,sBAAsB,CACpC,SAAS,EAAE,eAAe,EAC1B,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,MAAM,EAClB,MAAM,GAAE,cAA+B,GACtC,SAAS,EAAE,CAsIb"}

package/dist/detectors/typescript.js

@@ -0,0 +1,135 @@
+import * as t from '@babel/types';
+import { getCodeSnippet } from '../parser/index.js';
+import { DEFAULT_CONFIG } from '../types/index.js';
+/**
+ * Detects TypeScript-specific code smells:
+ * - Overuse of 'any' type
+ * - Missing return type on functions
+ * - Non-null assertion operator (!)
+ * - Type assertions (as) that could be avoided
+ */
+export function detectTypescriptIssues(component, filePath, sourceCode, config = DEFAULT_CONFIG) {
+    if (!config.checkTypescript)
+        return [];
+    // Only run on TypeScript files
+    if (!filePath.endsWith('.ts') && !filePath.endsWith('.tsx'))
+        return [];
+    const smells = [];
+    // Detect 'any' type usage
+    component.path.traverse({
+        TSAnyKeyword(path) {
+            const loc = path.node.loc;
+            smells.push({
+                type: 'ts-any-usage',
+                severity: 'warning',
+                message: `Using "any" type in "${component.name}"`,
+                file: filePath,
+                line: loc?.start.line || 0,
+                column: loc?.start.column || 0,
+                suggestion: 'Use a specific type, "unknown", or create an interface',
+                codeSnippet: getCodeSnippet(sourceCode, loc?.start.line || 0),
+            });
+        },
+    });
+    // Detect functions without return type (only in complex functions)
+    component.path.traverse({
+        FunctionDeclaration(path) {
+            // Skip if function has explicit return type
+            if (path.node.returnType)
+                return;
+            // Check if function body has return statements
+            let hasReturn = false;
+            path.traverse({
+                ReturnStatement(returnPath) {
+                    if (returnPath.node.argument) {
+                        hasReturn = true;
+                    }
+                },
+            });
+            if (hasReturn) {
+                const loc = path.node.loc;
+                smells.push({
+                    type: 'ts-missing-return-type',
+                    severity: 'info',
+                    message: `Function "${path.node.id?.name || 'anonymous'}" missing return type`,
+                    file: filePath,
+                    line: loc?.start.line || 0,
+                    column: loc?.start.column || 0,
+                    suggestion: 'Add explicit return type: function name(): ReturnType { ... }',
+                    codeSnippet: getCodeSnippet(sourceCode, loc?.start.line || 0),
+                });
+            }
+        },
+        ArrowFunctionExpression(path) {
+            // Only check arrow functions assigned to variables with 5+ lines
+            if (!path.node.returnType) {
+                const body = path.node.body;
+                // Skip simple arrow functions (single expression)
+                if (!t.isBlockStatement(body))
+                    return;
+                // Check complexity - only flag if function is substantial
+                const startLine = path.node.loc?.start.line || 0;
+                const endLine = path.node.loc?.end.line || 0;
+                if (endLine - startLine >= 5) {
+                    // Check if parent is variable declarator (assigned to variable)
+                    const parent = path.parent;
+                    if (t.isVariableDeclarator(parent) && t.isIdentifier(parent.id)) {
+                        const loc = path.node.loc;
+                        smells.push({
+                            type: 'ts-missing-return-type',
+                            severity: 'info',
+                            message: `Arrow function "${parent.id.name}" missing return type`,
+                            file: filePath,
+                            line: loc?.start.line || 0,
+                            column: loc?.start.column || 0,
+                            suggestion: 'Add return type: const name = (): ReturnType => { ... }',
+                            codeSnippet: getCodeSnippet(sourceCode, loc?.start.line || 0),
+                        });
+                    }
+                }
+            }
+        },
+    });
+    // Detect non-null assertion operator (!)
+    component.path.traverse({
+        TSNonNullExpression(path) {
+            const loc = path.node.loc;
+            smells.push({
+                type: 'ts-non-null-assertion',
+                severity: 'warning',
+                message: `Non-null assertion (!) bypasses type safety in "${component.name}"`,
+                file: filePath,
+                line: loc?.start.line || 0,
+                column: loc?.start.column || 0,
+                suggestion: 'Use optional chaining (?.) or proper null checks instead',
+                codeSnippet: getCodeSnippet(sourceCode, loc?.start.line || 0),
+            });
+        },
+    });
+    // Detect type assertions (as keyword) - these can hide type errors
+    component.path.traverse({
+        TSAsExpression(path) {
+            // Skip assertions to 'const' (used for const assertions)
+            if (t.isTSTypeReference(path.node.typeAnnotation)) {
+                const typeName = path.node.typeAnnotation.typeName;
+                if (t.isIdentifier(typeName) && typeName.name === 'const')
+                    return;
+            }
+            // Skip double assertions (as unknown as Type) - already flagged by TypeScript
+            if (t.isTSAsExpression(path.node.expression))
+                return;
+            const loc = path.node.loc;
+            smells.push({
+                type: 'ts-type-assertion',
+                severity: 'info',
+                message: `Type assertion (as) bypasses type checking in "${component.name}"`,
+                file: filePath,
+                line: loc?.start.line || 0,
+                column: loc?.start.column || 0,
+                suggestion: 'Consider using type guards or proper typing instead of assertions',
+                codeSnippet: getCodeSnippet(sourceCode, loc?.start.line || 0),
+            });
+        },
+    });
+    return smells;
+}

package/dist/reporter.js

@@ -212,6 +212,36 @@ function formatSmellType(type) {
         'state-in-loop': '🔄 State in Loop',
         'inline-function-prop': '📎 Inline Function Prop',
         'deep-nesting': '📊 Deep Nesting',
+        'missing-key': '🔑 Missing Key',
+        'hooks-rules-violation': '⚠️ Hooks Rules Violation',
+        'dependency-array-issue': '📋 Dependency Array Issue',
+        'nested-ternary': '❓ Nested Ternary',
+        'dead-code': '💀 Dead Code',
+        'magic-value': '🔢 Magic Value',
+        // Next.js
+        'nextjs-client-server-boundary': '▲ Next.js Client/Server Boundary',
+        'nextjs-missing-metadata': '▲ Next.js Missing Metadata',
+        'nextjs-image-unoptimized': '▲ Next.js Unoptimized Image',
+        'nextjs-router-misuse': '▲ Next.js Router Misuse',
+        // React Native
+        'rn-inline-style': '📱 RN Inline Style',
+        'rn-missing-accessibility': '📱 RN Missing Accessibility',
+        'rn-performance-issue': '📱 RN Performance Issue',
+        // Node.js
+        'nodejs-callback-hell': '🟢 Node.js Callback Hell',
+        'nodejs-unhandled-promise': '🟢 Node.js Unhandled Promise',
+        'nodejs-sync-io': '🟢 Node.js Sync I/O',
+        'nodejs-missing-error-handling': '🟢 Node.js Missing Error Handling',
+        // JavaScript
+        'js-var-usage': '📜 JS var Usage',
+        'js-loose-equality': '📜 JS Loose Equality',
+        'js-implicit-coercion': '📜 JS Implicit Coercion',
+        'js-global-pollution': '📜 JS Global Pollution',
+        // TypeScript
+        'ts-any-usage': '🔷 TS any Usage',
+        'ts-missing-return-type': '🔷 TS Missing Return Type',
+        'ts-non-null-assertion': '🔷 TS Non-null Assertion',
+        'ts-type-assertion': '🔷 TS Type Assertion',
     };
     return labels[type] || type;
 }

package/dist/types/index.d.ts

@@ -1,5 +1,5 @@
 export type SmellSeverity = 'error' | 'warning' | 'info';
-export type SmellType = 'useEffect-overuse' | 'prop-drilling' | 'large-component' | 'unmemoized-calculation' | 'missing-dependency' | 'state-in-loop' | 'inline-function-prop' | 'deep-nesting';
+export type SmellType = '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' | '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';
 export interface CodeSmell {
     type: SmellType;
     severity: SmellSeverity;
@@ -59,6 +59,19 @@ export interface DetectorConfig {
     maxComponentLines: number;
     maxPropsCount: number;
     checkMemoization: boolean;
+    checkMissingKeys: boolean;
+    checkHooksRules: boolean;
+    checkDependencyArrays: boolean;
+    maxTernaryDepth: number;
+    checkDeadCode: boolean;
+    checkMagicValues: boolean;
+    magicNumberThreshold: number;
+    checkNextjs: boolean;
+    checkReactNative: boolean;
+    checkNodejs: boolean;
+    checkJavascript: boolean;
+    checkTypescript: boolean;
+    maxCallbackDepth: number;
 }
 export declare const DEFAULT_CONFIG: DetectorConfig;
 //# sourceMappingURL=index.d.ts.map

package/dist/types/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/types/index.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,aAAa,GAAG,OAAO,GAAG,SAAS,GAAG,MAAM,CAAC;AAEzD,MAAM,MAAM,SAAS,GACjB,mBAAmB,GACnB,eAAe,GACf,iBAAiB,GACjB,wBAAwB,GACxB,oBAAoB,GACpB,eAAe,GACf,sBAAsB,GACtB,cAAc,CAAC;AAEnB,MAAM,WAAW,SAAS;IACxB,IAAI,EAAE,SAAS,CAAC;IAChB,QAAQ,EAAE,aAAa,CAAC;IACxB,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,cAAc,EAAE,MAAM,CAAC;IACvB,aAAa,EAAE,MAAM,CAAC;IACtB,YAAY,EAAE,MAAM,CAAC;IACrB,gBAAgB,EAAE,MAAM,CAAC;IACzB,UAAU,EAAE,MAAM,CAAC;IACnB,kBAAkB,EAAE,MAAM,CAAC;IAC3B,uBAAuB,EAAE,OAAO,CAAC;CAClC;AAED,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,aAAa,EAAE,CAAC;IAC5B,MAAM,EAAE,SAAS,EAAE,CAAC;IACpB,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB;AAED,MAAM,WAAW,cAAc;IAC7B,KAAK,EAAE,YAAY,EAAE,CAAC;IACtB,OAAO,EAAE,eAAe,CAAC;IACzB,SAAS,EAAE,kBAAkB,CAAC;CAC/B;AAED,MAAM,WAAW,eAAe;IAC9B,UAAU,EAAE,MAAM,CAAC;IACnB,eAAe,EAAE,MAAM,CAAC;IACxB,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,MAAM,CAAC,SAAS,EAAE,MAAM,CAAC,CAAC;IACxC,gBAAgB,EAAE,MAAM,CAAC,aAAa,EAAE,MAAM,CAAC,CAAC;CACjD;AAED,MAAM,WAAW,kBAAkB;IACjC,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,CAAC;IACnC,SAAS,EAAE;QACT,cAAc,EAAE,MAAM,CAAC;QACvB,iBAAiB,EAAE,MAAM,CAAC;QAC1B,kBAAkB,EAAE,MAAM,CAAC;QAC3B,gBAAgB,EAAE,MAAM,CAAC;KAC1B,CAAC;IACF,qBAAqB,EAAE,MAAM,CAAC;CAC/B;AAED,MAAM,WAAW,cAAc;IAC7B,yBAAyB,EAAE,MAAM,CAAC;IAClC,oBAAoB,EAAE,MAAM,CAAC;IAC7B,iBAAiB,EAAE,MAAM,CAAC;IAC1B,aAAa,EAAE,MAAM,CAAC;IACtB,gBAAgB,EAAE,OAAO,CAAC;CAC3B;AAED,eAAO,MAAM,cAAc,EAAE,cAM5B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/types/index.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,aAAa,GAAG,OAAO,GAAG,SAAS,GAAG,MAAM,CAAC;AAEzD,MAAM,MAAM,SAAS,GACjB,mBAAmB,GACnB,eAAe,GACf,iBAAiB,GACjB,wBAAwB,GACxB,oBAAoB,GACpB,eAAe,GACf,sBAAsB,GACtB,cAAc,GACd,aAAa,GACb,uBAAuB,GACvB,wBAAwB,GACxB,gBAAgB,GAChB,WAAW,GACX,aAAa,GAEb,+BAA+B,GAC/B,yBAAyB,GACzB,0BAA0B,GAC1B,sBAAsB,GAEtB,iBAAiB,GACjB,0BAA0B,GAC1B,sBAAsB,GAEtB,sBAAsB,GACtB,0BAA0B,GAC1B,gBAAgB,GAChB,+BAA+B,GAE/B,cAAc,GACd,mBAAmB,GACnB,sBAAsB,GACtB,qBAAqB,GAErB,cAAc,GACd,wBAAwB,GACxB,uBAAuB,GACvB,mBAAmB,CAAC;AAExB,MAAM,WAAW,SAAS;IACxB,IAAI,EAAE,SAAS,CAAC;IAChB,QAAQ,EAAE,aAAa,CAAC;IACxB,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,cAAc,EAAE,MAAM,CAAC;IACvB,aAAa,EAAE,MAAM,CAAC;IACtB,YAAY,EAAE,MAAM,CAAC;IACrB,gBAAgB,EAAE,MAAM,CAAC;IACzB,UAAU,EAAE,MAAM,CAAC;IACnB,kBAAkB,EAAE,MAAM,CAAC;IAC3B,uBAAuB,EAAE,OAAO,CAAC;CAClC;AAED,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,aAAa,EAAE,CAAC;IAC5B,MAAM,EAAE,SAAS,EAAE,CAAC;IACpB,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB;AAED,MAAM,WAAW,cAAc;IAC7B,KAAK,EAAE,YAAY,EAAE,CAAC;IACtB,OAAO,EAAE,eAAe,CAAC;IACzB,SAAS,EAAE,kBAAkB,CAAC;CAC/B;AAED,MAAM,WAAW,eAAe;IAC9B,UAAU,EAAE,MAAM,CAAC;IACnB,eAAe,EAAE,MAAM,CAAC;IACxB,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,MAAM,CAAC,SAAS,EAAE,MAAM,CAAC,CAAC;IACxC,gBAAgB,EAAE,MAAM,CAAC,aAAa,EAAE,MAAM,CAAC,CAAC;CACjD;AAED,MAAM,WAAW,kBAAkB;IACjC,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,CAAC;IACnC,SAAS,EAAE;QACT,cAAc,EAAE,MAAM,CAAC;QACvB,iBAAiB,EAAE,MAAM,CAAC;QAC1B,kBAAkB,EAAE,MAAM,CAAC;QAC3B,gBAAgB,EAAE,MAAM,CAAC;KAC1B,CAAC;IACF,qBAAqB,EAAE,MAAM,CAAC;CAC/B;AAED,MAAM,WAAW,cAAc;IAC7B,yBAAyB,EAAE,MAAM,CAAC;IAClC,oBAAoB,EAAE,MAAM,CAAC;IAC7B,iBAAiB,EAAE,MAAM,CAAC;IAC1B,aAAa,EAAE,MAAM,CAAC;IACtB,gBAAgB,EAAE,OAAO,CAAC;IAC1B,gBAAgB,EAAE,OAAO,CAAC;IAC1B,eAAe,EAAE,OAAO,CAAC;IACzB,qBAAqB,EAAE,OAAO,CAAC;IAC/B,eAAe,EAAE,MAAM,CAAC;IACxB,aAAa,EAAE,OAAO,CAAC;IACvB,gBAAgB,EAAE,OAAO,CAAC;IAC1B,oBAAoB,EAAE,MAAM,CAAC;IAE7B,WAAW,EAAE,OAAO,CAAC;IACrB,gBAAgB,EAAE,OAAO,CAAC;IAC1B,WAAW,EAAE,OAAO,CAAC;IACrB,eAAe,EAAE,OAAO,CAAC;IACzB,eAAe,EAAE,OAAO,CAAC;IACzB,gBAAgB,EAAE,MAAM,CAAC;CAC1B;AAED,eAAO,MAAM,cAAc,EAAE,cAoB5B,CAAC"}

package/dist/types/index.js

@@ -4,4 +4,18 @@ export const DEFAULT_CONFIG = {
     maxComponentLines: 300,
     maxPropsCount: 7,
     checkMemoization: true,
+    checkMissingKeys: true,
+    checkHooksRules: true,
+    checkDependencyArrays: true,
+    maxTernaryDepth: 2,
+    checkDeadCode: true,
+    checkMagicValues: true,
+    magicNumberThreshold: 10,
+    // Framework detection - auto-enabled based on project
+    checkNextjs: true,
+    checkReactNative: true,
+    checkNodejs: true,
+    checkJavascript: true,
+    checkTypescript: true,
+    maxCallbackDepth: 3,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-code-smell-detector",
-  "version": "1.0.0",
+  "version": "1.1.1",
   "description": "Detect code smells in React projects - useEffect overuse, prop drilling, large components, and more",
   "main": "dist/index.js",
   "bin": {

package/src/analyzer.ts

@@ -7,6 +7,17 @@ import {
   analyzePropDrillingDepth,
   detectLargeComponent,
   detectUnmemoizedCalculations,
+  detectMissingKeys,
+  detectHooksRulesViolations,
+  detectDependencyArrayIssues,
+  detectNestedTernaries,
+  detectDeadCode,
+  detectMagicValues,
+  detectNextjsIssues,
+  detectReactNativeIssues,
+  detectNodejsIssues,
+  detectJavascriptIssues,
+  detectTypescriptIssues,
 } from './detectors/index.js';
 import {
   AnalysisResult,
@@ -100,6 +111,18 @@ function analyzeFile(parseResult: ParseResult, filePath: string, config: Detecto
     smells.push(...detectPropDrilling(component, filePath, sourceCode, config));
     smells.push(...detectLargeComponent(component, filePath, sourceCode, config));
     smells.push(...detectUnmemoizedCalculations(component, filePath, sourceCode, config));
+    smells.push(...detectMissingKeys(component, filePath, sourceCode, config));
+    smells.push(...detectHooksRulesViolations(component, filePath, sourceCode, config));
+    smells.push(...detectDependencyArrayIssues(component, filePath, sourceCode, config));
+    smells.push(...detectNestedTernaries(component, filePath, sourceCode, config));
+    smells.push(...detectDeadCode(component, filePath, sourceCode, config));
+    smells.push(...detectMagicValues(component, filePath, sourceCode, config));
+    // Framework-specific detectors
+    smells.push(...detectNextjsIssues(component, filePath, sourceCode, config, imports));
+    smells.push(...detectReactNativeIssues(component, filePath, sourceCode, config, imports));
+    smells.push(...detectNodejsIssues(component, filePath, sourceCode, config, imports));
+    smells.push(...detectJavascriptIssues(component, filePath, sourceCode, config));
+    smells.push(...detectTypescriptIssues(component, filePath, sourceCode, config));
   });
 
   // Run cross-component analysis
@@ -123,6 +146,36 @@ function calculateSummary(files: FileAnalysis[]): AnalysisSummary {
     'state-in-loop': 0,
     'inline-function-prop': 0,
     'deep-nesting': 0,
+    'missing-key': 0,
+    'hooks-rules-violation': 0,
+    'dependency-array-issue': 0,
+    'nested-ternary': 0,
+    'dead-code': 0,
+    'magic-value': 0,
+    // Next.js
+    'nextjs-client-server-boundary': 0,
+    'nextjs-missing-metadata': 0,
+    'nextjs-image-unoptimized': 0,
+    'nextjs-router-misuse': 0,
+    // React Native
+    'rn-inline-style': 0,
+    'rn-missing-accessibility': 0,
+    'rn-performance-issue': 0,
+    // Node.js
+    'nodejs-callback-hell': 0,
+    'nodejs-unhandled-promise': 0,
+    'nodejs-sync-io': 0,
+    'nodejs-missing-error-handling': 0,
+    // JavaScript
+    'js-var-usage': 0,
+    'js-loose-equality': 0,
+    'js-implicit-coercion': 0,
+    'js-global-pollution': 0,
+    // TypeScript
+    'ts-any-usage': 0,
+    'ts-missing-return-type': 0,
+    'ts-non-null-assertion': 0,
+    'ts-type-assertion': 0,
   };
 
   const smellsBySeverity: Record<SmellSeverity, number> = {