react-code-smell-detector 1.0.1 → 1.1.1

package/dist/analyzer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"analyzer.d.ts","sourceRoot":"","sources":["../src/analyzer.ts"],"names":[],"mappings":"AAgBA,OAAO,EACL,cAAc,EAMd,cAAc,EAIf,MAAM,kBAAkB,CAAC;AAE1B,MAAM,WAAW,eAAe;IAC9B,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IACnB,MAAM,CAAC,EAAE,OAAO,CAAC,cAAc,CAAC,CAAC;CAClC;AAED,wBAAsB,cAAc,CAAC,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,cAAc,CAAC,CA0CtF;AA2JD,OAAO,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC"}
+{"version":3,"file":"analyzer.d.ts","sourceRoot":"","sources":["../src/analyzer.ts"],"names":[],"mappings":"AAqBA,OAAO,EACL,cAAc,EAMd,cAAc,EAIf,MAAM,kBAAkB,CAAC;AAE1B,MAAM,WAAW,eAAe;IAC9B,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IACnB,MAAM,CAAC,EAAE,OAAO,CAAC,cAAc,CAAC,CAAC;CAClC;AAED,wBAAsB,cAAc,CAAC,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,cAAc,CAAC,CA0CtF;AAyLD,OAAO,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC"}

package/dist/analyzer.js

@@ -1,7 +1,7 @@
 import fg from 'fast-glob';
 import path from 'path';
 import { parseFile } from './parser/index.js';
-import { detectUseEffectOveruse, detectPropDrilling, analyzePropDrillingDepth, detectLargeComponent, detectUnmemoizedCalculations, detectMissingKeys, detectHooksRulesViolations, detectDependencyArrayIssues, detectNestedTernaries, detectDeadCode, detectMagicValues, } from './detectors/index.js';
+import { detectUseEffectOveruse, detectPropDrilling, analyzePropDrillingDepth, detectLargeComponent, detectUnmemoizedCalculations, detectMissingKeys, detectHooksRulesViolations, detectDependencyArrayIssues, detectNestedTernaries, detectDeadCode, detectMagicValues, detectNextjsIssues, detectReactNativeIssues, detectNodejsIssues, detectJavascriptIssues, detectTypescriptIssues, } from './detectors/index.js';
 import { DEFAULT_CONFIG, } from './types/index.js';
 export async function analyzeProject(options) {
     const { rootDir, include = ['**/*.tsx', '**/*.jsx'], exclude = ['**/node_modules/**', '**/dist/**', '**/build/**', '**/*.test.*', '**/*.spec.*'], config: userConfig = {}, } = options;
@@ -68,6 +68,12 @@ function analyzeFile(parseResult, filePath, 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
     smells.push(...analyzePropDrillingDepth(components, filePath, sourceCode, config));
@@ -94,6 +100,30 @@ function calculateSummary(files) {
         '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 = {
         error: 0,

package/dist/detectors/index.d.ts

@@ -8,4 +8,9 @@ export { detectDependencyArrayIssues } from './dependencyArray.js';
 export { detectNestedTernaries } from './nestedTernary.js';
 export { detectDeadCode, detectUnusedImports } from './deadCode.js';
 export { detectMagicValues } from './magicValues.js';
+export { detectNextjsIssues } from './nextjs.js';
+export { detectReactNativeIssues } from './reactNative.js';
+export { detectNodejsIssues } from './nodejs.js';
+export { detectJavascriptIssues } from './javascript.js';
+export { detectTypescriptIssues } from './typescript.js';
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/detectors/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,sBAAsB,EAAE,MAAM,gBAAgB,CAAC;AACxD,OAAO,EAAE,kBAAkB,EAAE,wBAAwB,EAAE,MAAM,mBAAmB,CAAC;AACjF,OAAO,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAC3D,OAAO,EAAE,4BAA4B,EAAE,MAAM,kBAAkB,CAAC;AAChE,OAAO,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AACpD,OAAO,EAAE,0BAA0B,EAAE,MAAM,iBAAiB,CAAC;AAC7D,OAAO,EAAE,2BAA2B,EAAE,MAAM,sBAAsB,CAAC;AACnE,OAAO,EAAE,qBAAqB,EAAE,MAAM,oBAAoB,CAAC;AAC3D,OAAO,EAAE,cAAc,EAAE,mBAAmB,EAAE,MAAM,eAAe,CAAC;AACpE,OAAO,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/detectors/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,sBAAsB,EAAE,MAAM,gBAAgB,CAAC;AACxD,OAAO,EAAE,kBAAkB,EAAE,wBAAwB,EAAE,MAAM,mBAAmB,CAAC;AACjF,OAAO,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAC3D,OAAO,EAAE,4BAA4B,EAAE,MAAM,kBAAkB,CAAC;AAChE,OAAO,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AACpD,OAAO,EAAE,0BAA0B,EAAE,MAAM,iBAAiB,CAAC;AAC7D,OAAO,EAAE,2BAA2B,EAAE,MAAM,sBAAsB,CAAC;AACnE,OAAO,EAAE,qBAAqB,EAAE,MAAM,oBAAoB,CAAC;AAC3D,OAAO,EAAE,cAAc,EAAE,mBAAmB,EAAE,MAAM,eAAe,CAAC;AACpE,OAAO,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAErD,OAAO,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AACjD,OAAO,EAAE,uBAAuB,EAAE,MAAM,kBAAkB,CAAC;AAC3D,OAAO,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AACjD,OAAO,EAAE,sBAAsB,EAAE,MAAM,iBAAiB,CAAC;AACzD,OAAO,EAAE,sBAAsB,EAAE,MAAM,iBAAiB,CAAC"}

package/dist/detectors/index.js

@@ -8,3 +8,9 @@ export { detectDependencyArrayIssues } from './dependencyArray.js';
 export { detectNestedTernaries } from './nestedTernary.js';
 export { detectDeadCode, detectUnusedImports } from './deadCode.js';
 export { detectMagicValues } from './magicValues.js';
+// Framework-specific detectors
+export { detectNextjsIssues } from './nextjs.js';
+export { detectReactNativeIssues } from './reactNative.js';
+export { detectNodejsIssues } from './nodejs.js';
+export { detectJavascriptIssues } from './javascript.js';
+export { detectTypescriptIssues } from './typescript.js';

package/dist/detectors/javascript.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"javascript.d.ts","sourceRoot":"","sources":["../../src/detectors/javascript.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,CAwJb"}

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/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"}

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"}