react-code-smell-detector 1.0.0 → 1.1.1

package/dist/detectors/javascript.js

@@ -0,0 +1,148 @@
+import * as t from '@babel/types';
+import { getCodeSnippet } from '../parser/index.js';
+import { DEFAULT_CONFIG } from '../types/index.js';
+/**
+ * Detects vanilla JavaScript code smells:
+ * - var usage (should use let/const)
+ * - Loose equality (== instead of ===)
+ * - Implicit type coercion
+ * - Global variable pollution
+ */
+export function detectJavascriptIssues(component, filePath, sourceCode, config = DEFAULT_CONFIG) {
+    if (!config.checkJavascript)
+        return [];
+    const smells = [];
+    // Detect var usage (should use let/const)
+    component.path.traverse({
+        VariableDeclaration(path) {
+            if (path.node.kind === 'var') {
+                const loc = path.node.loc;
+                smells.push({
+                    type: 'js-var-usage',
+                    severity: 'warning',
+                    message: `Using "var" instead of "let" or "const" in "${component.name}"`,
+                    file: filePath,
+                    line: loc?.start.line || 0,
+                    column: loc?.start.column || 0,
+                    suggestion: 'Use "const" for values that never change, "let" for reassignable variables',
+                    codeSnippet: getCodeSnippet(sourceCode, loc?.start.line || 0),
+                });
+            }
+        },
+    });
+    // Detect loose equality (== and != instead of === and !==)
+    component.path.traverse({
+        BinaryExpression(path) {
+            const { operator, left, right } = path.node;
+            // Skip if comparing with null/undefined (sometimes intentional)
+            const isNullCheck = (t.isNullLiteral(left) || t.isNullLiteral(right)) ||
+                (t.isIdentifier(left) && left.name === 'undefined') ||
+                (t.isIdentifier(right) && right.name === 'undefined');
+            if (operator === '==' && !isNullCheck) {
+                const loc = path.node.loc;
+                smells.push({
+                    type: 'js-loose-equality',
+                    severity: 'warning',
+                    message: `Using loose equality "==" in "${component.name}"`,
+                    file: filePath,
+                    line: loc?.start.line || 0,
+                    column: loc?.start.column || 0,
+                    suggestion: 'Use strict equality "===" to avoid type coercion bugs',
+                    codeSnippet: getCodeSnippet(sourceCode, loc?.start.line || 0),
+                });
+            }
+            if (operator === '!=' && !isNullCheck) {
+                const loc = path.node.loc;
+                smells.push({
+                    type: 'js-loose-equality',
+                    severity: 'warning',
+                    message: `Using loose inequality "!=" in "${component.name}"`,
+                    file: filePath,
+                    line: loc?.start.line || 0,
+                    column: loc?.start.column || 0,
+                    suggestion: 'Use strict inequality "!==" to avoid type coercion bugs',
+                    codeSnippet: getCodeSnippet(sourceCode, loc?.start.line || 0),
+                });
+            }
+        },
+    });
+    // Detect implicit type coercion patterns
+    component.path.traverse({
+        // +string to convert to number
+        UnaryExpression(path) {
+            if (path.node.operator === '+' && t.isIdentifier(path.node.argument)) {
+                const loc = path.node.loc;
+                smells.push({
+                    type: 'js-implicit-coercion',
+                    severity: 'info',
+                    message: `Implicit number coercion with unary + in "${component.name}"`,
+                    file: filePath,
+                    line: loc?.start.line || 0,
+                    column: loc?.start.column || 0,
+                    suggestion: 'Use explicit conversion: Number(value) or parseInt(value, 10)',
+                    codeSnippet: getCodeSnippet(sourceCode, loc?.start.line || 0),
+                });
+            }
+        },
+        // !!value for boolean coercion - detected via UnaryExpression
+        // LogicalExpression handles &&, ||, ?? - skip for !! detection
+        // String concatenation with + that mixes types
+        BinaryExpression(path) {
+            if (path.node.operator === '+') {
+                const { left, right } = path.node;
+                const leftIsString = t.isStringLiteral(left) || t.isTemplateLiteral(left);
+                const rightIsString = t.isStringLiteral(right) || t.isTemplateLiteral(right);
+                const leftIsNumber = t.isNumericLiteral(left);
+                const rightIsNumber = t.isNumericLiteral(right);
+                // Mixed string + number concatenation
+                if ((leftIsString && rightIsNumber) || (leftIsNumber && rightIsString)) {
+                    const loc = path.node.loc;
+                    smells.push({
+                        type: 'js-implicit-coercion',
+                        severity: 'info',
+                        message: `Implicit string coercion in "${component.name}"`,
+                        file: filePath,
+                        line: loc?.start.line || 0,
+                        column: loc?.start.column || 0,
+                        suggestion: 'Use template literal for clarity: `${value}` or String(value)',
+                        codeSnippet: getCodeSnippet(sourceCode, loc?.start.line || 0),
+                    });
+                }
+            }
+        },
+    });
+    // Detect potential global pollution (assignments without declaration)
+    component.path.traverse({
+        AssignmentExpression(path) {
+            const { left } = path.node;
+            if (t.isIdentifier(left)) {
+                // Check if this identifier is declared in scope
+                const binding = path.scope.getBinding(left.name);
+                if (!binding) {
+                    // Check if it's a well-known global
+                    const knownGlobals = [
+                        'window', 'document', 'console', 'localStorage', 'sessionStorage',
+                        'setTimeout', 'setInterval', 'clearTimeout', 'clearInterval',
+                        'fetch', 'XMLHttpRequest', 'WebSocket', 'module', 'exports',
+                        'require', 'process', 'global', '__dirname', '__filename',
+                        'Buffer', 'Promise', 'Map', 'Set', 'Symbol',
+                    ];
+                    if (!knownGlobals.includes(left.name)) {
+                        const loc = path.node.loc;
+                        smells.push({
+                            type: 'js-global-pollution',
+                            severity: 'error',
+                            message: `Implicit global variable "${left.name}" in "${component.name}"`,
+                            file: filePath,
+                            line: loc?.start.line || 0,
+                            column: loc?.start.column || 0,
+                            suggestion: `Declare the variable: const ${left.name} = ... or let ${left.name} = ...`,
+                            codeSnippet: getCodeSnippet(sourceCode, loc?.start.line || 0),
+                        });
+                    }
+                }
+            }
+        },
+    });
+    return smells;
+}

package/dist/detectors/magicValues.d.ts

@@ -0,0 +1,7 @@
+import { ParsedComponent } from '../parser/index.js';
+import { CodeSmell, DetectorConfig } from '../types/index.js';
+/**
+ * Detects magic numbers and strings that should be constants
+ */
+export declare function detectMagicValues(component: ParsedComponent, filePath: string, sourceCode: string, config?: DetectorConfig): CodeSmell[];
+//# sourceMappingURL=magicValues.d.ts.map

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

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

package/dist/detectors/magicValues.js

@@ -0,0 +1,99 @@
+import * as t from '@babel/types';
+import { getCodeSnippet } from '../parser/index.js';
+import { DEFAULT_CONFIG } from '../types/index.js';
+/**
+ * Detects magic numbers and strings that should be constants
+ */
+export function detectMagicValues(component, filePath, sourceCode, config = DEFAULT_CONFIG) {
+    if (!config.checkMagicValues)
+        return [];
+    const smells = [];
+    const threshold = config.magicNumberThreshold;
+    // Track locations to avoid duplicate reports
+    const reportedLines = new Set();
+    component.path.traverse({
+        NumericLiteral(path) {
+            const value = path.node.value;
+            const loc = path.node.loc;
+            const line = loc?.start.line || 0;
+            // Skip common acceptable values
+            if (value === 0 || value === 1 || value === -1 || value === 2 || value === 100)
+                return;
+            // Skip array indices and small numbers
+            if (value < threshold && value > -threshold)
+                return;
+            // Skip if inside an object key position (e.g., style objects)
+            if (t.isObjectProperty(path.parent) && path.parent.key === path.node)
+                return;
+            // Skip if it's a port number or similar config
+            if (value === 3000 || value === 8080 || value === 80 || value === 443)
+                return;
+            // Skip if already reported this line
+            if (reportedLines.has(line))
+                return;
+            reportedLines.add(line);
+            // Check context - skip if it's in a variable declaration that names the constant
+            if (t.isVariableDeclarator(path.parent)) {
+                const varName = t.isIdentifier(path.parent.id) ? path.parent.id.name : '';
+                // If variable name is UPPER_CASE, it's already a constant
+                if (varName === varName.toUpperCase() && varName.includes('_'))
+                    return;
+            }
+            smells.push({
+                type: 'magic-value',
+                severity: 'info',
+                message: `Magic number ${value} in "${component.name}"`,
+                file: filePath,
+                line,
+                column: loc?.start.column || 0,
+                suggestion: `Extract to a named constant: const DESCRIPTIVE_NAME = ${value}`,
+                codeSnippet: getCodeSnippet(sourceCode, line),
+            });
+        },
+        StringLiteral(path) {
+            const value = path.node.value;
+            const loc = path.node.loc;
+            const line = loc?.start.line || 0;
+            // Skip short strings, empty strings, common values
+            if (value.length < 10)
+                return;
+            // Skip if it looks like a URL, path, or import
+            if (value.startsWith('http') || value.startsWith('/') || value.startsWith('.'))
+                return;
+            // Skip if it's an import source
+            if (t.isImportDeclaration(path.parent))
+                return;
+            // Skip JSX text content (usually intentional)
+            if (t.isJSXText(path.parent) || t.isJSXExpressionContainer(path.parent))
+                return;
+            // Skip object property keys
+            if (t.isObjectProperty(path.parent) && path.parent.key === path.node)
+                return;
+            // Skip if already reported this line
+            if (reportedLines.has(line))
+                return;
+            // Skip common patterns
+            if (value.includes('className') ||
+                value.includes('px') ||
+                value.includes('rem') ||
+                value.includes('%'))
+                return;
+            // Check if it looks like a user-facing message or error
+            const looksLikeMessage = /^[A-Z][a-z]+.*[.!?]?$/.test(value) || value.includes(' ');
+            if (looksLikeMessage && value.length > 30) {
+                reportedLines.add(line);
+                smells.push({
+                    type: 'magic-value',
+                    severity: 'info',
+                    message: `Hardcoded string in "${component.name}" should be in constants or i18n`,
+                    file: filePath,
+                    line,
+                    column: loc?.start.column || 0,
+                    suggestion: `Extract to a constants file or use i18n: "${value.substring(0, 30)}..."`,
+                    codeSnippet: getCodeSnippet(sourceCode, line),
+                });
+            }
+        },
+    });
+    return smells;
+}

package/dist/detectors/missingKey.d.ts

@@ -0,0 +1,7 @@
+import { ParsedComponent } from '../parser/index.js';
+import { CodeSmell, DetectorConfig } from '../types/index.js';
+/**
+ * Detects .map() calls that render JSX without a key prop
+ */
+export declare function detectMissingKeys(component: ParsedComponent, filePath: string, sourceCode: string, config?: DetectorConfig): CodeSmell[];
+//# sourceMappingURL=missingKey.d.ts.map

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

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

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/detectors/nextjs.d.ts

@@ -0,0 +1,11 @@
+import { ParsedComponent } from '../parser/index.js';
+import { CodeSmell, DetectorConfig } from '../types/index.js';
+/**
+ * Detects Next.js-specific code smells:
+ * - Missing 'use client' / 'use server' directives
+ * - Unoptimized images (using <img> instead of next/image)
+ * - Router misuse patterns
+ * - Missing metadata exports
+ */
+export declare function detectNextjsIssues(component: ParsedComponent, filePath: string, sourceCode: string, config?: DetectorConfig, imports?: string[]): CodeSmell[];
+//# sourceMappingURL=nextjs.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"nextjs.d.ts","sourceRoot":"","sources":["../../src/detectors/nextjs.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,kBAAkB,CAChC,SAAS,EAAE,eAAe,EAC1B,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,MAAM,EAClB,MAAM,GAAE,cAA+B,EACvC,OAAO,GAAE,MAAM,EAAO,GACrB,SAAS,EAAE,CA0Gb"}

package/dist/detectors/nextjs.js

@@ -0,0 +1,103 @@
+import * as t from '@babel/types';
+import { getCodeSnippet } from '../parser/index.js';
+import { DEFAULT_CONFIG } from '../types/index.js';
+/**
+ * Detects Next.js-specific code smells:
+ * - Missing 'use client' / 'use server' directives
+ * - Unoptimized images (using <img> instead of next/image)
+ * - Router misuse patterns
+ * - Missing metadata exports
+ */
+export function detectNextjsIssues(component, filePath, sourceCode, config = DEFAULT_CONFIG, imports = []) {
+    if (!config.checkNextjs)
+        return [];
+    // Only run on Next.js projects (check for next imports)
+    const isNextProject = imports.some(imp => imp.includes('next/') || imp.includes('next'));
+    // Also check file path patterns
+    const isAppRouter = filePath.includes('/app/') &&
+        (filePath.endsWith('page.tsx') || filePath.endsWith('page.jsx') ||
+            filePath.endsWith('layout.tsx') || filePath.endsWith('layout.jsx'));
+    const smells = [];
+    // Check for unoptimized images (using <img> instead of next/image)
+    component.path.traverse({
+        JSXOpeningElement(path) {
+            if (t.isJSXIdentifier(path.node.name) && path.node.name.name === 'img') {
+                const loc = path.node.loc;
+                smells.push({
+                    type: 'nextjs-image-unoptimized',
+                    severity: 'warning',
+                    message: `Using native <img> instead of next/image in "${component.name}"`,
+                    file: filePath,
+                    line: loc?.start.line || 0,
+                    column: loc?.start.column || 0,
+                    suggestion: 'Use next/image for automatic image optimization: import Image from "next/image"',
+                    codeSnippet: getCodeSnippet(sourceCode, loc?.start.line || 0),
+                });
+            }
+        },
+    });
+    // Check for client-side hooks in server components (App Router)
+    if (isAppRouter && !sourceCode.includes("'use client'") && !sourceCode.includes('"use client"')) {
+        const clientHooks = ['useState', 'useEffect', 'useContext', 'useReducer', 'useRef'];
+        const usedClientHooks = [];
+        component.path.traverse({
+            CallExpression(path) {
+                if (t.isIdentifier(path.node.callee) && clientHooks.includes(path.node.callee.name)) {
+                    usedClientHooks.push(path.node.callee.name);
+                }
+            },
+        });
+        if (usedClientHooks.length > 0) {
+            const loc = component.node.loc;
+            smells.push({
+                type: 'nextjs-client-server-boundary',
+                severity: 'error',
+                message: `Client hooks (${usedClientHooks.join(', ')}) used without 'use client' directive in "${component.name}"`,
+                file: filePath,
+                line: loc?.start.line || 1,
+                column: 0,
+                suggestion: "Add 'use client' at the top of the file, or move client logic to a separate component",
+                codeSnippet: getCodeSnippet(sourceCode, 1),
+            });
+        }
+    }
+    // Check for missing metadata in page/layout files
+    if (isAppRouter && filePath.includes('page.')) {
+        // This would require checking exports, which needs file-level analysis
+        const hasMetadata = sourceCode.includes('export const metadata') ||
+            sourceCode.includes('export function generateMetadata');
+        if (!hasMetadata && component.name === 'default') {
+            smells.push({
+                type: 'nextjs-missing-metadata',
+                severity: 'info',
+                message: 'Page component missing metadata export',
+                file: filePath,
+                line: 1,
+                column: 0,
+                suggestion: 'Add metadata for SEO: export const metadata = { title: "...", description: "..." }',
+            });
+        }
+    }
+    // Check for router misuse (using window.location instead of next/router)
+    component.path.traverse({
+        MemberExpression(path) {
+            if (t.isIdentifier(path.node.object) &&
+                path.node.object.name === 'window' &&
+                t.isIdentifier(path.node.property) &&
+                path.node.property.name === 'location') {
+                const loc = path.node.loc;
+                smells.push({
+                    type: 'nextjs-router-misuse',
+                    severity: 'warning',
+                    message: `Using window.location instead of Next.js router in "${component.name}"`,
+                    file: filePath,
+                    line: loc?.start.line || 0,
+                    column: loc?.start.column || 0,
+                    suggestion: 'Use next/navigation: import { useRouter } from "next/navigation"',
+                    codeSnippet: getCodeSnippet(sourceCode, loc?.start.line || 0),
+                });
+            }
+        },
+    });
+    return smells;
+}

package/dist/detectors/nodejs.d.ts

@@ -0,0 +1,11 @@
+import { ParsedComponent } from '../parser/index.js';
+import { CodeSmell, DetectorConfig } 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 declare function detectNodejsIssues(component: ParsedComponent, filePath: string, sourceCode: string, config?: DetectorConfig, imports?: string[]): CodeSmell[];
+//# sourceMappingURL=nodejs.d.ts.map

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

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