react-code-smell-detector 1.0.0 → 1.0.1

package/dist/detectors/missingKey.js

@@ -0,0 +1,93 @@
+import * as t from '@babel/types';
+import { getCodeSnippet } from '../parser/index.js';
+import { DEFAULT_CONFIG } from '../types/index.js';
+/**
+ * Detects .map() calls that render JSX without a key prop
+ */
+export function detectMissingKeys(component, filePath, sourceCode, config = DEFAULT_CONFIG) {
+    if (!config.checkMissingKeys)
+        return [];
+    const smells = [];
+    component.path.traverse({
+        CallExpression(path) {
+            // Check if it's a .map() call
+            if (!t.isMemberExpression(path.node.callee))
+                return;
+            const prop = path.node.callee.property;
+            if (!t.isIdentifier(prop) || prop.name !== 'map')
+                return;
+            // Check if the callback returns JSX
+            const callback = path.node.arguments[0];
+            if (!callback)
+                return;
+            let callbackBody = null;
+            if (t.isArrowFunctionExpression(callback)) {
+                callbackBody = callback.body;
+            }
+            else if (t.isFunctionExpression(callback)) {
+                callbackBody = callback.body;
+            }
+            if (!callbackBody)
+                return;
+            // Find JSX elements in the callback
+            let hasJSX = false;
+            let hasKey = false;
+            let jsxLine = path.node.loc?.start.line || 0;
+            const checkForKey = (node) => {
+                if (t.isJSXElement(node)) {
+                    hasJSX = true;
+                    jsxLine = node.loc?.start.line || jsxLine;
+                    // Check if the opening element has a key prop
+                    const openingElement = node.openingElement;
+                    const keyAttr = openingElement.attributes.find(attr => {
+                        if (t.isJSXAttribute(attr)) {
+                            return t.isJSXIdentifier(attr.name) && attr.name.name === 'key';
+                        }
+                        return false;
+                    });
+                    if (keyAttr) {
+                        hasKey = true;
+                    }
+                }
+                else if (t.isJSXFragment(node)) {
+                    hasJSX = true;
+                    // Fragments can't have keys directly, so check children
+                }
+            };
+            // Traverse the callback body to find JSX
+            if (t.isJSXElement(callbackBody) || t.isJSXFragment(callbackBody)) {
+                checkForKey(callbackBody);
+            }
+            else if (t.isBlockStatement(callbackBody)) {
+                path.traverse({
+                    ReturnStatement(returnPath) {
+                        if (returnPath.node.argument) {
+                            checkForKey(returnPath.node.argument);
+                        }
+                    },
+                    JSXElement(jsxPath) {
+                        // Only check top-level JSX in the map callback
+                        if (jsxPath.parent === callbackBody ||
+                            (t.isReturnStatement(jsxPath.parent) && jsxPath.parent.argument === jsxPath.node)) {
+                            checkForKey(jsxPath.node);
+                        }
+                    },
+                });
+            }
+            if (hasJSX && !hasKey) {
+                const loc = path.node.loc;
+                smells.push({
+                    type: 'missing-key',
+                    severity: 'error',
+                    message: `Missing "key" prop in .map() that renders JSX in "${component.name}"`,
+                    file: filePath,
+                    line: jsxLine || loc?.start.line || 0,
+                    column: loc?.start.column || 0,
+                    suggestion: 'Add a unique "key" prop to the root element: <Element key={item.id}>',
+                    codeSnippet: getCodeSnippet(sourceCode, loc?.start.line || 0),
+                });
+            }
+        },
+    });
+    return smells;
+}

package/dist/detectors/nestedTernary.d.ts

@@ -0,0 +1,7 @@
+import { ParsedComponent } from '../parser/index.js';
+import { CodeSmell, DetectorConfig } from '../types/index.js';
+/**
+ * Detects deeply nested ternary expressions (complex conditional rendering)
+ */
+export declare function detectNestedTernaries(component: ParsedComponent, filePath: string, sourceCode: string, config?: DetectorConfig): CodeSmell[];
+//# sourceMappingURL=nestedTernary.d.ts.map

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

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

package/dist/detectors/nestedTernary.js

@@ -0,0 +1,58 @@
+import * as t from '@babel/types';
+import { getCodeSnippet } from '../parser/index.js';
+import { DEFAULT_CONFIG } from '../types/index.js';
+/**
+ * Detects deeply nested ternary expressions (complex conditional rendering)
+ */
+export function detectNestedTernaries(component, filePath, sourceCode, config = DEFAULT_CONFIG) {
+    const smells = [];
+    const maxDepth = config.maxTernaryDepth;
+    component.path.traverse({
+        ConditionalExpression(path) {
+            // Only check the outermost ternary
+            if (isNestedInTernary(path))
+                return;
+            const depth = getTernaryDepth(path.node);
+            if (depth > maxDepth) {
+                const loc = path.node.loc;
+                smells.push({
+                    type: 'nested-ternary',
+                    severity: depth > maxDepth + 1 ? 'warning' : 'info',
+                    message: `Nested ternary expression (depth: ${depth}) in "${component.name}"`,
+                    file: filePath,
+                    line: loc?.start.line || 0,
+                    column: loc?.start.column || 0,
+                    suggestion: `Refactor to use if/else, switch, or extract into separate components. Max recommended depth: ${maxDepth}`,
+                    codeSnippet: getCodeSnippet(sourceCode, loc?.start.line || 0),
+                });
+            }
+        },
+    });
+    return smells;
+}
+/**
+ * Check if a ternary is nested inside another ternary
+ */
+function isNestedInTernary(path) {
+    let current = path.parentPath;
+    while (current) {
+        if (t.isConditionalExpression(current.node)) {
+            return true;
+        }
+        current = current.parentPath;
+    }
+    return false;
+}
+/**
+ * Calculate the depth of nested ternary expressions
+ */
+function getTernaryDepth(node) {
+    let maxChildDepth = 0;
+    if (t.isConditionalExpression(node.consequent)) {
+        maxChildDepth = Math.max(maxChildDepth, getTernaryDepth(node.consequent));
+    }
+    if (t.isConditionalExpression(node.alternate)) {
+        maxChildDepth = Math.max(maxChildDepth, getTernaryDepth(node.alternate));
+    }
+    return 1 + maxChildDepth;
+}

package/dist/reporter.js

@@ -212,6 +212,12 @@ 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',
     };
     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';
 export interface CodeSmell {
     type: SmellType;
     severity: SmellSeverity;
@@ -59,6 +59,13 @@ export interface DetectorConfig {
     maxComponentLines: number;
     maxPropsCount: number;
     checkMemoization: boolean;
+    checkMissingKeys: boolean;
+    checkHooksRules: boolean;
+    checkDependencyArrays: boolean;
+    maxTernaryDepth: number;
+    checkDeadCode: boolean;
+    checkMagicValues: boolean;
+    magicNumberThreshold: 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,CAAC;AAElB,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;CAC9B;AAED,eAAO,MAAM,cAAc,EAAE,cAa5B,CAAC"}

package/dist/types/index.js

@@ -4,4 +4,11 @@ export const DEFAULT_CONFIG = {
     maxComponentLines: 300,
     maxPropsCount: 7,
     checkMemoization: true,
+    checkMissingKeys: true,
+    checkHooksRules: true,
+    checkDependencyArrays: true,
+    maxTernaryDepth: 2,
+    checkDeadCode: true,
+    checkMagicValues: true,
+    magicNumberThreshold: 10,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-code-smell-detector",
-  "version": "1.0.0",
+  "version": "1.0.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,12 @@ import {
   analyzePropDrillingDepth,
   detectLargeComponent,
   detectUnmemoizedCalculations,
+  detectMissingKeys,
+  detectHooksRulesViolations,
+  detectDependencyArrayIssues,
+  detectNestedTernaries,
+  detectDeadCode,
+  detectMagicValues,
 } from './detectors/index.js';
 import {
   AnalysisResult,
@@ -100,6 +106,12 @@ 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));
   });
 
   // Run cross-component analysis
@@ -123,6 +135,12 @@ 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,
   };
 
   const smellsBySeverity: Record<SmellSeverity, number> = {

package/src/detectors/deadCode.ts

@@ -0,0 +1,163 @@
+import * as t from '@babel/types';
+import { ParsedComponent, getCodeSnippet } from '../parser/index.js';
+import { CodeSmell, DetectorConfig, DEFAULT_CONFIG } from '../types/index.js';
+
+/**
+ * Detects potentially dead code: unused variables, imports, and functions
+ */
+export function detectDeadCode(
+  component: ParsedComponent,
+  filePath: string,
+  sourceCode: string,
+  config: DetectorConfig = DEFAULT_CONFIG
+): CodeSmell[] {
+  if (!config.checkDeadCode) return [];
+
+  const smells: CodeSmell[] = [];
+  
+  // Track declared and used identifiers within the component
+  const declared = new Map<string, { line: number; column: number; type: string }>();
+  const used = new Set<string>();
+
+  // Collect all declared variables in the component
+  component.path.traverse({
+    VariableDeclarator(path) {
+      if (t.isIdentifier(path.node.id)) {
+        const loc = path.node.loc;
+        declared.set(path.node.id.name, {
+          line: loc?.start.line || 0,
+          column: loc?.start.column || 0,
+          type: 'variable',
+        });
+      } else if (t.isObjectPattern(path.node.id)) {
+        // Destructured variables
+        path.node.id.properties.forEach(prop => {
+          if (t.isObjectProperty(prop) && t.isIdentifier(prop.value)) {
+            const loc = prop.loc;
+            declared.set(prop.value.name, {
+              line: loc?.start.line || 0,
+              column: loc?.start.column || 0,
+              type: 'variable',
+            });
+          } else if (t.isRestElement(prop) && t.isIdentifier(prop.argument)) {
+            const loc = prop.loc;
+            declared.set(prop.argument.name, {
+              line: loc?.start.line || 0,
+              column: loc?.start.column || 0,
+              type: 'variable',
+            });
+          }
+        });
+      } else if (t.isArrayPattern(path.node.id)) {
+        // Array destructured variables
+        path.node.id.elements.forEach(elem => {
+          if (t.isIdentifier(elem)) {
+            const loc = elem.loc;
+            declared.set(elem.name, {
+              line: loc?.start.line || 0,
+              column: loc?.start.column || 0,
+              type: 'variable',
+            });
+          }
+        });
+      }
+    },
+
+    FunctionDeclaration(path) {
+      if (path.node.id) {
+        const loc = path.node.loc;
+        declared.set(path.node.id.name, {
+          line: loc?.start.line || 0,
+          column: loc?.start.column || 0,
+          type: 'function',
+        });
+      }
+    },
+  });
+
+  // Collect all used identifiers
+  component.path.traverse({
+    Identifier(path) {
+      // Skip if it's a declaration
+      if (
+        t.isVariableDeclarator(path.parent) && path.parent.id === path.node ||
+        t.isFunctionDeclaration(path.parent) && path.parent.id === path.node ||
+        t.isObjectProperty(path.parent) && path.parent.key === path.node ||
+        t.isImportSpecifier(path.parent) ||
+        t.isImportDefaultSpecifier(path.parent)
+      ) {
+        return;
+      }
+
+      // Skip property access (x.y - y is not a reference)
+      if (t.isMemberExpression(path.parent) && path.parent.property === path.node && !path.parent.computed) {
+        return;
+      }
+
+      used.add(path.node.name);
+    },
+
+    JSXIdentifier(path) {
+      // Components used in JSX
+      if (t.isJSXOpeningElement(path.parent) || t.isJSXClosingElement(path.parent)) {
+        used.add(path.node.name);
+      }
+    },
+  });
+
+  // Find unused declarations
+  declared.forEach((info, name) => {
+    // Skip hooks and common patterns
+    if (name.startsWith('_') || name.startsWith('set')) return;
+    
+    // Skip if it's the component name itself
+    if (name === component.name) return;
+
+    if (!used.has(name)) {
+      smells.push({
+        type: 'dead-code',
+        severity: 'info',
+        message: `Unused ${info.type} "${name}" in "${component.name}"`,
+        file: filePath,
+        line: info.line,
+        column: info.column,
+        suggestion: `Remove the unused ${info.type} or use it in the component.`,
+        codeSnippet: getCodeSnippet(sourceCode, info.line),
+      });
+    }
+  });
+
+  return smells;
+}
+
+/**
+ * Detects unused imports at the file level
+ */
+export function detectUnusedImports(
+  imports: Map<string, { source: string; line: number }>,
+  usedInFile: Set<string>,
+  filePath: string,
+  sourceCode: string
+): CodeSmell[] {
+  const smells: CodeSmell[] = [];
+
+  imports.forEach((info, name) => {
+    // Skip React imports as they might be used implicitly
+    if (name === 'React' || info.source === 'react') return;
+
+    if (!usedInFile.has(name)) {
+      smells.push({
+        type: 'dead-code',
+        severity: 'info',
+        message: `Unused import "${name}" from "${info.source}"`,
+        file: filePath,
+        line: info.line,
+        column: 0,
+        suggestion: `Remove the unused import: import { ${name} } from '${info.source}'`,
+        codeSnippet: getCodeSnippet(sourceCode, info.line),
+      });
+    }
+  });
+
+  return smells;
+}

package/src/detectors/dependencyArray.ts

@@ -0,0 +1,176 @@
+import * as t from '@babel/types';
+import { ParsedComponent, getCodeSnippet } from '../parser/index.js';
+import { CodeSmell, DetectorConfig, DEFAULT_CONFIG } from '../types/index.js';
+
+/**
+ * Detects potential issues with useEffect dependency arrays
+ */
+export function detectDependencyArrayIssues(
+  component: ParsedComponent,
+  filePath: string,
+  sourceCode: string,
+  config: DetectorConfig = DEFAULT_CONFIG
+): CodeSmell[] {
+  if (!config.checkDependencyArrays) return [];
+
+  const smells: CodeSmell[] = [];
+
+  // Analyze each useEffect
+  component.hooks.useEffect.forEach(effectCall => {
+    const args = effectCall.arguments;
+    const callback = args[0];
+    const depsArray = args[1];
+
+    const loc = effectCall.loc;
+    const line = loc?.start.line || 0;
+
+    // Check 1: Missing dependency array entirely
+    if (!depsArray) {
+      smells.push({
+        type: 'dependency-array-issue',
+        severity: 'warning',
+        message: `useEffect without dependency array in "${component.name}" runs on every render`,
+        file: filePath,
+        line,
+        column: loc?.start.column || 0,
+        suggestion: 'Add a dependency array. Use [] for mount-only effect, or [dep1, dep2] for reactive dependencies.',
+        codeSnippet: getCodeSnippet(sourceCode, line),
+      });
+      return;
+    }
+
+    // Check 2: Empty dependency array with variables used inside
+    if (t.isArrayExpression(depsArray) && depsArray.elements.length === 0) {
+      // Collect variables used in the effect callback
+      const usedVariables = new Set<string>();
+      
+      if (t.isArrowFunctionExpression(callback) || t.isFunctionExpression(callback)) {
+        collectVariablesUsed(callback.body, usedVariables);
+        
+        // Filter out common globals and React hooks
+        const globals = new Set(['console', 'window', 'document', 'setTimeout', 'setInterval', 
+          'clearTimeout', 'clearInterval', 'fetch', 'Promise', 'JSON', 'Math', 'Date', 'Array', 
+          'Object', 'String', 'Number', 'Boolean', 'Error', 'undefined', 'null', 'true', 'false']);
+        
+        // Check if there are local variables that might need to be dependencies
+        const potentialMissing = [...usedVariables].filter(v => 
+          !globals.has(v) && 
+          !v.startsWith('set') && // Setters from useState are stable
+          v !== 'props' &&
+          v !== 'children'
+        );
+
+        // Only warn if there appear to be external variables used
+        if (potentialMissing.length > 3) {
+          smells.push({
+            type: 'dependency-array-issue',
+            severity: 'info',
+            message: `useEffect in "${component.name}" has empty deps array but uses external variables`,
+            file: filePath,
+            line,
+            column: loc?.start.column || 0,
+            suggestion: `Consider adding dependencies: [${potentialMissing.slice(0, 3).join(', ')}...]`,
+            codeSnippet: getCodeSnippet(sourceCode, line),
+          });
+        }
+      }
+    }
+
+    // Check 3: Dependency array with object/array literals
+    if (t.isArrayExpression(depsArray)) {
+      depsArray.elements.forEach((elem, index) => {
+        if (t.isObjectExpression(elem) || t.isArrayExpression(elem)) {
+          smells.push({
+            type: 'dependency-array-issue',
+            severity: 'warning',
+            message: `Object/array literal in useEffect dependency array in "${component.name}" causes infinite re-renders`,
+            file: filePath,
+            line,
+            column: loc?.start.column || 0,
+            suggestion: 'Move the object/array to a useMemo or extract to a constant outside the component.',
+            codeSnippet: getCodeSnippet(sourceCode, line),
+          });
+        }
+
+        // Check for inline functions
+        if (t.isArrowFunctionExpression(elem) || t.isFunctionExpression(elem)) {
+          smells.push({
+            type: 'dependency-array-issue',
+            severity: 'warning',
+            message: `Inline function in useEffect dependency array in "${component.name}" causes infinite re-renders`,
+            file: filePath,
+            line,
+            column: loc?.start.column || 0,
+            suggestion: 'Wrap the function in useCallback before using as a dependency.',
+            codeSnippet: getCodeSnippet(sourceCode, line),
+          });
+        }
+      });
+    }
+  });
+
+  // Also check useMemo and useCallback
+  [...component.hooks.useMemo, ...component.hooks.useCallback].forEach(hookCall => {
+    const depsArray = hookCall.arguments[1];
+    const loc = hookCall.loc;
+    const line = loc?.start.line || 0;
+
+    if (!depsArray) {
+      const hookName = t.isIdentifier((hookCall.callee as t.Identifier)) 
+        ? ((hookCall.callee as t.Identifier).name)
+        : 'useMemo/useCallback';
+      
+      smells.push({
+        type: 'dependency-array-issue',
+        severity: 'warning',
+        message: `${hookName} without dependency array in "${component.name}"`,
+        file: filePath,
+        line,
+        column: loc?.start.column || 0,
+        suggestion: 'Add a dependency array to specify when the value should be recalculated.',
+        codeSnippet: getCodeSnippet(sourceCode, line),
+      });
+    }
+  });
+
+  return smells;
+}
+
+/**
+ * Helper to collect variable names used in a code block
+ */
+function collectVariablesUsed(node: t.Node, variables: Set<string>): void {
+  if (t.isIdentifier(node)) {
+    variables.add(node.name);
+  } else if (t.isMemberExpression(node)) {
+    if (t.isIdentifier(node.object)) {
+      variables.add(node.object.name);
+    } else {
+      collectVariablesUsed(node.object, variables);
+    }
+  } else if (t.isBlockStatement(node)) {
+    node.body.forEach(stmt => collectVariablesUsed(stmt, variables));
+  } else if (t.isExpressionStatement(node)) {
+    collectVariablesUsed(node.expression, variables);
+  } else if (t.isCallExpression(node)) {
+    if (t.isIdentifier(node.callee)) {
+      variables.add(node.callee.name);
+    }
+    node.arguments.forEach(arg => {
+      if (t.isNode(arg)) collectVariablesUsed(arg, variables);
+    });
+  } else if (t.isConditionalExpression(node)) {
+    collectVariablesUsed(node.test, variables);
+    collectVariablesUsed(node.consequent, variables);
+    collectVariablesUsed(node.alternate, variables);
+  } else if (t.isBinaryExpression(node) || t.isLogicalExpression(node)) {
+    collectVariablesUsed(node.left, variables);
+    collectVariablesUsed(node.right, variables);
+  } else if (t.isReturnStatement(node) && node.argument) {
+    collectVariablesUsed(node.argument, variables);
+  } else if (t.isIfStatement(node)) {
+    collectVariablesUsed(node.test, variables);
+    collectVariablesUsed(node.consequent, variables);
+    if (node.alternate) collectVariablesUsed(node.alternate, variables);
+  }
+}