react-code-smell-detector 1.1.1 → 1.3.1

package/dist/detectors/accessibility.js

@@ -0,0 +1,191 @@
+import * as t from '@babel/types';
+import { getCodeSnippet } from '../parser/index.js';
+import { DEFAULT_CONFIG } from '../types/index.js';
+/**
+ * Detects accessibility (a11y) issues:
+ * - Images without alt text
+ * - Form inputs without labels
+ * - Missing ARIA attributes on interactive elements
+ * - Click handlers without keyboard support
+ * - Improper heading hierarchy
+ */
+export function detectAccessibilityIssues(component, filePath, sourceCode, config = DEFAULT_CONFIG) {
+    if (!config.checkAccessibility)
+        return [];
+    const smells = [];
+    component.path.traverse({
+        JSXOpeningElement(path) {
+            if (!t.isJSXIdentifier(path.node.name))
+                return;
+            const elementName = path.node.name.name;
+            const attributes = path.node.attributes;
+            const loc = path.node.loc;
+            const line = loc?.start.line || 0;
+            // Helper to check if attribute exists
+            const hasAttr = (name) => {
+                return attributes.some(attr => {
+                    if (t.isJSXAttribute(attr) && t.isJSXIdentifier(attr.name)) {
+                        return attr.name.name === name;
+                    }
+                    // Handle spread attributes - assume they might contain the attribute
+                    return t.isJSXSpreadAttribute(attr);
+                });
+            };
+            // Helper to get attribute value
+            const getAttrValue = (name) => {
+                for (const attr of attributes) {
+                    if (t.isJSXAttribute(attr) && t.isJSXIdentifier(attr.name) && attr.name.name === name) {
+                        if (t.isStringLiteral(attr.value)) {
+                            return attr.value.value;
+                        }
+                    }
+                }
+                return null;
+            };
+            // Check for images without alt text
+            if (elementName === 'img') {
+                if (!hasAttr('alt')) {
+                    smells.push({
+                        type: 'a11y-missing-alt',
+                        severity: 'error',
+                        message: `<img> missing alt attribute in "${component.name}"`,
+                        file: filePath,
+                        line,
+                        column: loc?.start.column || 0,
+                        suggestion: 'Add alt="description" for content images, or alt="" for decorative images',
+                        codeSnippet: getCodeSnippet(sourceCode, line),
+                    });
+                }
+                else {
+                    const altValue = getAttrValue('alt');
+                    if (altValue !== null && altValue.toLowerCase().includes('image')) {
+                        smells.push({
+                            type: 'a11y-missing-alt',
+                            severity: 'info',
+                            message: `<img> alt text shouldn't contain "image" - it's redundant`,
+                            file: filePath,
+                            line,
+                            column: loc?.start.column || 0,
+                            suggestion: 'Describe what the image shows, not that it is an image',
+                            codeSnippet: getCodeSnippet(sourceCode, line),
+                        });
+                    }
+                }
+            }
+            // Check for form inputs without associated labels
+            if (elementName === 'input' || elementName === 'textarea' || elementName === 'select') {
+                const inputType = getAttrValue('type') || 'text';
+                // Skip hidden inputs
+                if (inputType === 'hidden')
+                    return;
+                const hasLabel = hasAttr('aria-label') ||
+                    hasAttr('aria-labelledby') ||
+                    hasAttr('id'); // Assume id might be linked to a label
+                if (!hasLabel) {
+                    smells.push({
+                        type: 'a11y-missing-label',
+                        severity: 'warning',
+                        message: `<${elementName}> without accessible label in "${component.name}"`,
+                        file: filePath,
+                        line,
+                        column: loc?.start.column || 0,
+                        suggestion: 'Add aria-label, aria-labelledby, or associate with a <label> element',
+                        codeSnippet: getCodeSnippet(sourceCode, line),
+                    });
+                }
+            }
+            // Check for interactive divs/spans without proper role and keyboard support
+            if (elementName === 'div' || elementName === 'span') {
+                const hasOnClick = hasAttr('onClick');
+                const hasRole = hasAttr('role');
+                const hasTabIndex = hasAttr('tabIndex');
+                const hasKeyboardHandler = hasAttr('onKeyDown') || hasAttr('onKeyUp') || hasAttr('onKeyPress');
+                if (hasOnClick) {
+                    if (!hasRole) {
+                        smells.push({
+                            type: 'a11y-interactive-role',
+                            severity: 'warning',
+                            message: `Clickable <${elementName}> without role attribute in "${component.name}"`,
+                            file: filePath,
+                            line,
+                            column: loc?.start.column || 0,
+                            suggestion: 'Add role="button" or use a <button> element instead',
+                            codeSnippet: getCodeSnippet(sourceCode, line),
+                        });
+                    }
+                    if (!hasTabIndex) {
+                        smells.push({
+                            type: 'a11y-interactive-role',
+                            severity: 'warning',
+                            message: `Clickable <${elementName}> not focusable in "${component.name}"`,
+                            file: filePath,
+                            line,
+                            column: loc?.start.column || 0,
+                            suggestion: 'Add tabIndex={0} to make the element focusable',
+                            codeSnippet: getCodeSnippet(sourceCode, line),
+                        });
+                    }
+                    if (!hasKeyboardHandler) {
+                        smells.push({
+                            type: 'a11y-keyboard',
+                            severity: 'info',
+                            message: `Clickable <${elementName}> without keyboard handler in "${component.name}"`,
+                            file: filePath,
+                            line,
+                            column: loc?.start.column || 0,
+                            suggestion: 'Add onKeyDown to handle Enter/Space for keyboard users',
+                            codeSnippet: getCodeSnippet(sourceCode, line),
+                        });
+                    }
+                }
+            }
+            // Check for anchor tags without href (should be buttons)
+            if (elementName === 'a') {
+                if (!hasAttr('href')) {
+                    smells.push({
+                        type: 'a11y-semantic',
+                        severity: 'warning',
+                        message: `<a> without href should be a <button> in "${component.name}"`,
+                        file: filePath,
+                        line,
+                        column: loc?.start.column || 0,
+                        suggestion: 'Use <button> for actions and <a href="..."> for navigation',
+                        codeSnippet: getCodeSnippet(sourceCode, line),
+                    });
+                }
+            }
+            // Check for proper button usage
+            if (elementName === 'button') {
+                if (!hasAttr('type')) {
+                    smells.push({
+                        type: 'a11y-semantic',
+                        severity: 'info',
+                        message: `<button> should have explicit type attribute`,
+                        file: filePath,
+                        line,
+                        column: loc?.start.column || 0,
+                        suggestion: 'Add type="button" or type="submit" to clarify button behavior',
+                        codeSnippet: getCodeSnippet(sourceCode, line),
+                    });
+                }
+            }
+            // Check for icons that might need labels
+            if (elementName === 'svg' || elementName === 'Icon' || elementName.endsWith('Icon')) {
+                const hasAriaLabel = hasAttr('aria-label') || hasAttr('aria-hidden') || hasAttr('title');
+                if (!hasAriaLabel) {
+                    smells.push({
+                        type: 'a11y-missing-label',
+                        severity: 'info',
+                        message: `Icon/SVG may need aria-label or aria-hidden in "${component.name}"`,
+                        file: filePath,
+                        line,
+                        column: loc?.start.column || 0,
+                        suggestion: 'Add aria-label for meaningful icons, or aria-hidden="true" for decorative ones',
+                        codeSnippet: getCodeSnippet(sourceCode, line),
+                    });
+                }
+            }
+        },
+    });
+    return smells;
+}

package/dist/detectors/complexity.d.ts

@@ -0,0 +1,17 @@
+import { ParsedComponent } from '../parser/index.js';
+import { CodeSmell, DetectorConfig } from '../types/index.js';
+export interface ComplexityMetrics {
+    cyclomaticComplexity: number;
+    cognitiveComplexity: number;
+    maxNestingDepth: number;
+    linesOfCode: number;
+}
+/**
+ * Detect code complexity issues in a component
+ */
+export declare function detectComplexity(component: ParsedComponent, filePath: string, sourceCode: string, config: DetectorConfig): CodeSmell[];
+/**
+ * Calculate complexity metrics for a component
+ */
+export declare function calculateComplexityMetrics(component: ParsedComponent): ComplexityMetrics;
+//# sourceMappingURL=complexity.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"complexity.d.ts","sourceRoot":"","sources":["../../src/detectors/complexity.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AACrD,OAAO,EAAE,SAAS,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAE9D,MAAM,WAAW,iBAAiB;IAChC,oBAAoB,EAAE,MAAM,CAAC;IAC7B,mBAAmB,EAAE,MAAM,CAAC;IAC5B,eAAe,EAAE,MAAM,CAAC;IACxB,WAAW,EAAE,MAAM,CAAC;CACrB;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAC9B,SAAS,EAAE,eAAe,EAC1B,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,MAAM,EAClB,MAAM,EAAE,cAAc,GACrB,SAAS,EAAE,CAqCb;AAED;;GAEG;AACH,wBAAgB,0BAA0B,CAAC,SAAS,EAAE,eAAe,GAAG,iBAAiB,CA6BxF"}

package/dist/detectors/complexity.js

@@ -0,0 +1,69 @@
+/**
+ * Detect code complexity issues in a component
+ */
+export function detectComplexity(component, filePath, sourceCode, config) {
+    if (!config.checkComplexity)
+        return [];
+    const smells = [];
+    const metrics = calculateComplexityMetrics(component);
+    const thresholds = {
+        cyclomatic: config.maxCyclomaticComplexity || 10,
+        cognitive: config.maxCognitiveComplexity || 15,
+        nesting: config.maxNestingDepth || 4,
+    };
+    if (metrics.cyclomaticComplexity > thresholds.cyclomatic) {
+        smells.push({
+            type: 'high-cyclomatic-complexity',
+            severity: metrics.cyclomaticComplexity > thresholds.cyclomatic * 1.5 ? 'error' : 'warning',
+            message: `Component "${component.name}" has cyclomatic complexity of ${metrics.cyclomaticComplexity} (threshold: ${thresholds.cyclomatic})`,
+            file: filePath,
+            line: component.startLine,
+            column: 0,
+            suggestion: 'Break down complex logic into smaller functions.',
+        });
+    }
+    if (metrics.cognitiveComplexity > thresholds.cognitive) {
+        smells.push({
+            type: 'high-cognitive-complexity',
+            severity: metrics.cognitiveComplexity > thresholds.cognitive * 1.5 ? 'error' : 'warning',
+            message: `Component "${component.name}" has cognitive complexity of ${metrics.cognitiveComplexity} (threshold: ${thresholds.cognitive})`,
+            file: filePath,
+            line: component.startLine,
+            column: 0,
+            suggestion: 'Simplify nested conditions and flatten control flow.',
+        });
+    }
+    return smells;
+}
+/**
+ * Calculate complexity metrics for a component
+ */
+export function calculateComplexityMetrics(component) {
+    let cyclomaticComplexity = 1;
+    let cognitiveComplexity = 0;
+    component.path.traverse({
+        IfStatement() { cyclomaticComplexity++; cognitiveComplexity++; },
+        ConditionalExpression() { cyclomaticComplexity++; cognitiveComplexity++; },
+        LogicalExpression(path) {
+            if (path.node.operator === '&&' || path.node.operator === '||') {
+                cyclomaticComplexity++;
+            }
+        },
+        SwitchCase(path) {
+            if (path.node.test !== null)
+                cyclomaticComplexity++;
+        },
+        ForStatement() { cyclomaticComplexity++; cognitiveComplexity += 2; },
+        ForInStatement() { cyclomaticComplexity++; cognitiveComplexity += 2; },
+        ForOfStatement() { cyclomaticComplexity++; cognitiveComplexity += 2; },
+        WhileStatement() { cyclomaticComplexity++; cognitiveComplexity += 2; },
+        DoWhileStatement() { cyclomaticComplexity++; cognitiveComplexity += 2; },
+        CatchClause() { cyclomaticComplexity++; cognitiveComplexity++; },
+    });
+    return {
+        cyclomaticComplexity,
+        cognitiveComplexity,
+        maxNestingDepth: component.jsxDepth,
+        linesOfCode: component.endLine - component.startLine + 1,
+    };
+}

package/dist/detectors/debug.d.ts

@@ -0,0 +1,10 @@
+import { ParsedComponent } from '../parser/index.js';
+import { CodeSmell, DetectorConfig } from '../types/index.js';
+/**
+ * Detects debug statements that should be removed:
+ * - console.log/warn/error/debug
+ * - debugger statements
+ * - TODO/FIXME/HACK comments (detected via source code)
+ */
+export declare function detectDebugStatements(component: ParsedComponent, filePath: string, sourceCode: string, config?: DetectorConfig): CodeSmell[];
+//# sourceMappingURL=debug.d.ts.map

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

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

package/dist/detectors/debug.js

@@ -0,0 +1,87 @@
+import * as t from '@babel/types';
+import { getCodeSnippet } from '../parser/index.js';
+import { DEFAULT_CONFIG } from '../types/index.js';
+/**
+ * Detects debug statements that should be removed:
+ * - console.log/warn/error/debug
+ * - debugger statements
+ * - TODO/FIXME/HACK comments (detected via source code)
+ */
+export function detectDebugStatements(component, filePath, sourceCode, config = DEFAULT_CONFIG) {
+    if (!config.checkDebugStatements)
+        return [];
+    const smells = [];
+    const reportedLines = new Set();
+    // Detect console.* calls
+    component.path.traverse({
+        CallExpression(path) {
+            const { callee } = path.node;
+            if (t.isMemberExpression(callee) &&
+                t.isIdentifier(callee.object) &&
+                callee.object.name === 'console') {
+                const method = t.isIdentifier(callee.property) ? callee.property.name : '';
+                const debugMethods = ['log', 'warn', 'error', 'debug', 'info', 'trace', 'dir', 'table'];
+                if (debugMethods.includes(method)) {
+                    const loc = path.node.loc;
+                    const line = loc?.start.line || 0;
+                    if (!reportedLines.has(line)) {
+                        reportedLines.add(line);
+                        smells.push({
+                            type: 'debug-statement',
+                            severity: 'warning',
+                            message: `console.${method}() should be removed before production`,
+                            file: filePath,
+                            line,
+                            column: loc?.start.column || 0,
+                            suggestion: 'Remove console statement or use a logging library with environment-based filtering',
+                            codeSnippet: getCodeSnippet(sourceCode, line),
+                        });
+                    }
+                }
+            }
+        },
+        // Detect debugger statements
+        DebuggerStatement(path) {
+            const loc = path.node.loc;
+            smells.push({
+                type: 'debug-statement',
+                severity: 'error',
+                message: 'debugger statement must be removed before production',
+                file: filePath,
+                line: loc?.start.line || 0,
+                column: loc?.start.column || 0,
+                suggestion: 'Remove the debugger statement',
+                codeSnippet: getCodeSnippet(sourceCode, loc?.start.line || 0),
+            });
+        },
+    });
+    // Detect TODO/FIXME/HACK comments in source
+    const todoPatterns = [
+        { pattern: /\/\/\s*(TODO|FIXME|HACK|XXX|BUG)[:.\s]/gi, type: 'todo-comment' },
+        { pattern: /\/\*\s*(TODO|FIXME|HACK|XXX|BUG)[:.\s]/gi, type: 'todo-comment' },
+    ];
+    const lines = sourceCode.split('\n');
+    lines.forEach((line, index) => {
+        const lineNum = index + 1;
+        // Only check within component bounds
+        if (lineNum < component.startLine || lineNum > component.endLine)
+            return;
+        todoPatterns.forEach(({ pattern }) => {
+            const match = line.match(pattern);
+            if (match) {
+                const tag = match[0].replace(/[/\*\s:]/g, '').toUpperCase();
+                smells.push({
+                    type: 'todo-comment',
+                    severity: 'info',
+                    message: `${tag} comment found in "${component.name}"`,
+                    file: filePath,
+                    line: lineNum,
+                    column: 0,
+                    suggestion: `Address the ${tag} or create a ticket to track it`,
+                    codeSnippet: getCodeSnippet(sourceCode, lineNum),
+                });
+            }
+        });
+    });
+    return smells;
+}

package/dist/detectors/imports.d.ts

@@ -0,0 +1,22 @@
+import { CodeSmell, DetectorConfig } from '../types/index.js';
+export interface ImportInfo {
+    source: string;
+    specifiers: string[];
+    line: number;
+    isDefault: boolean;
+    isNamespace: boolean;
+}
+export interface ImportAnalysisResult {
+    smells: CodeSmell[];
+    importGraph: Map<string, string[]>;
+    circularDeps: string[][];
+}
+/**
+ * Analyze imports across multiple files for issues
+ */
+export declare function analyzeImports(files: string[], rootDir: string, config: DetectorConfig): Promise<ImportAnalysisResult>;
+/**
+ * Standalone detection function matching other detector signatures
+ */
+export declare function detectImportIssues(component: any, filePath: string, sourceCode: string, config: DetectorConfig): CodeSmell[];
+//# sourceMappingURL=imports.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"imports.d.ts","sourceRoot":"","sources":["../../src/detectors/imports.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,SAAS,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAK9D,MAAM,WAAW,UAAU;IACzB,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,OAAO,CAAC;IACnB,WAAW,EAAE,OAAO,CAAC;CACtB;AAED,MAAM,WAAW,oBAAoB;IACnC,MAAM,EAAE,SAAS,EAAE,CAAC;IACpB,WAAW,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;IACnC,YAAY,EAAE,MAAM,EAAE,EAAE,CAAC;CAC1B;AAED;;GAEG;AACH,wBAAsB,cAAc,CAClC,KAAK,EAAE,MAAM,EAAE,EACf,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,cAAc,GACrB,OAAO,CAAC,oBAAoB,CAAC,CAkD/B;AA8KD;;GAEG;AACH,wBAAgB,kBAAkB,CAChC,SAAS,EAAE,GAAG,EACd,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,MAAM,EAClB,MAAM,EAAE,cAAc,GACrB,SAAS,EAAE,CAGb"}

package/dist/detectors/imports.js

@@ -0,0 +1,210 @@
+import * as t from '@babel/types';
+import _traverse from '@babel/traverse';
+import { parse } from '@babel/parser';
+import fs from 'fs/promises';
+import path from 'path';
+// Handle ESM/CJS interop
+const traverse = typeof _traverse === 'function' ? _traverse : _traverse.default;
+/**
+ * Analyze imports across multiple files for issues
+ */
+export async function analyzeImports(files, rootDir, config) {
+    const smells = [];
+    const importGraph = new Map();
+    // Build import graph
+    for (const file of files) {
+        try {
+            const content = await fs.readFile(file, 'utf-8');
+            const imports = extractImports(content, file);
+            const resolvedImports = [];
+            for (const imp of imports) {
+                // Skip external packages
+                if (!imp.source.startsWith('.') && !imp.source.startsWith('/')) {
+                    continue;
+                }
+                const resolvedPath = resolveImportPath(file, imp.source, rootDir);
+                if (resolvedPath) {
+                    resolvedImports.push(resolvedPath);
+                }
+            }
+            importGraph.set(file, resolvedImports);
+            // Detect import-related smells in this file
+            smells.push(...detectImportSmells(imports, file, content, config));
+        }
+        catch {
+            // Skip files that can't be parsed
+        }
+    }
+    // Detect circular dependencies
+    const circularDeps = detectCircularDependencies(importGraph);
+    // Add circular dependency smells
+    for (const cycle of circularDeps) {
+        const cycleStr = cycle.map(f => path.basename(f)).join(' → ');
+        smells.push({
+            type: 'circular-dependency',
+            severity: 'warning',
+            message: `Circular dependency detected: ${cycleStr}`,
+            file: cycle[0],
+            line: 1,
+            column: 0,
+            suggestion: 'Refactor to break the cycle. Consider extracting shared logic to a separate module.',
+        });
+    }
+    return { smells, importGraph, circularDeps };
+}
+/**
+ * Extract all imports from a file
+ */
+function extractImports(sourceCode, filePath) {
+    const imports = [];
+    try {
+        const ast = parse(sourceCode, {
+            sourceType: 'module',
+            plugins: ['jsx', 'typescript'],
+        });
+        traverse(ast, {
+            ImportDeclaration(nodePath) {
+                const node = nodePath.node;
+                const specifiers = node.specifiers.map(spec => {
+                    if (t.isImportDefaultSpecifier(spec))
+                        return 'default';
+                    if (t.isImportNamespaceSpecifier(spec))
+                        return '*';
+                    return spec.local.name;
+                });
+                imports.push({
+                    source: node.source.value,
+                    specifiers,
+                    line: node.loc?.start.line || 0,
+                    isDefault: node.specifiers.some(t.isImportDefaultSpecifier),
+                    isNamespace: node.specifiers.some(t.isImportNamespaceSpecifier),
+                });
+            },
+        });
+    }
+    catch {
+        // Parse error, skip
+    }
+    return imports;
+}
+/**
+ * Resolve an import path relative to the importing file
+ */
+function resolveImportPath(fromFile, importSource, rootDir) {
+    if (!importSource.startsWith('.')) {
+        return null; // External package
+    }
+    const dir = path.dirname(fromFile);
+    let resolved = path.resolve(dir, importSource);
+    // Try common extensions
+    const extensions = ['.tsx', '.ts', '.jsx', '.js', '/index.tsx', '/index.ts', '/index.jsx', '/index.js'];
+    for (const ext of extensions) {
+        const tryPath = resolved + ext;
+        // We don't check existence here - just build the graph
+        if (!ext.includes('/')) {
+            return tryPath;
+        }
+    }
+    return resolved;
+}
+/**
+ * Detect circular dependencies in import graph using DFS
+ */
+function detectCircularDependencies(graph) {
+    const cycles = [];
+    const visited = new Set();
+    const recursionStack = new Set();
+    const path = [];
+    function dfs(node) {
+        visited.add(node);
+        recursionStack.add(node);
+        path.push(node);
+        const neighbors = graph.get(node) || [];
+        for (const neighbor of neighbors) {
+            if (!visited.has(neighbor)) {
+                dfs(neighbor);
+            }
+            else if (recursionStack.has(neighbor)) {
+                // Found a cycle
+                const cycleStart = path.indexOf(neighbor);
+                if (cycleStart !== -1) {
+                    const cycle = path.slice(cycleStart).concat(neighbor);
+                    // Avoid duplicate cycles
+                    const cycleKey = [...cycle].sort().join('|');
+                    if (!cycles.some(c => [...c].sort().join('|') === cycleKey)) {
+                        cycles.push(cycle);
+                    }
+                }
+            }
+        }
+        path.pop();
+        recursionStack.delete(node);
+    }
+    for (const node of graph.keys()) {
+        if (!visited.has(node)) {
+            dfs(node);
+        }
+    }
+    return cycles;
+}
+/**
+ * Detect import-related code smells in a single file
+ */
+function detectImportSmells(imports, filePath, sourceCode, config) {
+    const smells = [];
+    // Check for barrel file imports (importing from index files)
+    for (const imp of imports) {
+        if (imp.source.endsWith('/index') || imp.source === '.') {
+            smells.push({
+                type: 'barrel-file-import',
+                severity: 'info',
+                message: `Barrel file import from "${imp.source}" may impact tree-shaking`,
+                file: filePath,
+                line: imp.line,
+                column: 0,
+                suggestion: 'Import directly from the source file instead of barrel/index files for better build optimization.',
+            });
+        }
+    }
+    // Check for namespace imports (import * as)
+    for (const imp of imports) {
+        if (imp.isNamespace && !imp.source.startsWith('.')) {
+            smells.push({
+                type: 'namespace-import',
+                severity: 'info',
+                message: `Namespace import "* as" from "${imp.source}" may prevent tree-shaking`,
+                file: filePath,
+                line: imp.line,
+                column: 0,
+                suggestion: 'Import only the specific exports you need for better bundle size.',
+            });
+        }
+    }
+    // Check for too many imports from same source
+    const importCounts = new Map();
+    for (const imp of imports) {
+        const count = (importCounts.get(imp.source) || 0) + imp.specifiers.length;
+        importCounts.set(imp.source, count);
+    }
+    for (const [source, count] of importCounts) {
+        if (count > 10 && source.startsWith('.')) {
+            smells.push({
+                type: 'excessive-imports',
+                severity: 'warning',
+                message: `${count} imports from "${source}" suggests tight coupling`,
+                file: filePath,
+                line: imports.find(i => i.source === source)?.line || 1,
+                column: 0,
+                suggestion: 'Consider if this file has too many responsibilities or if modules should be reorganized.',
+            });
+        }
+    }
+    return smells;
+}
+/**
+ * Standalone detection function matching other detector signatures
+ */
+export function detectImportIssues(component, filePath, sourceCode, config) {
+    const imports = extractImports(sourceCode, filePath);
+    return detectImportSmells(imports, filePath, sourceCode, config);
+}

package/dist/detectors/index.d.ts

@@ -13,4 +13,10 @@ export { detectReactNativeIssues } from './reactNative.js';
 export { detectNodejsIssues } from './nodejs.js';
 export { detectJavascriptIssues } from './javascript.js';
 export { detectTypescriptIssues } from './typescript.js';
+export { detectDebugStatements } from './debug.js';
+export { detectSecurityIssues } from './security.js';
+export { detectAccessibilityIssues } from './accessibility.js';
+export { detectComplexity, calculateComplexityMetrics } from './complexity.js';
+export { detectMemoryLeaks } from './memoryLeak.js';
+export { detectImportIssues, analyzeImports } from './imports.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;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"}
+{"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;AAEzD,OAAO,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AACnD,OAAO,EAAE,oBAAoB,EAAE,MAAM,eAAe,CAAC;AACrD,OAAO,EAAE,yBAAyB,EAAE,MAAM,oBAAoB,CAAC;AAE/D,OAAO,EAAE,gBAAgB,EAAE,0BAA0B,EAAE,MAAM,iBAAiB,CAAC;AAC/E,OAAO,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AACpD,OAAO,EAAE,kBAAkB,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC"}

package/dist/detectors/index.js

@@ -14,3 +14,11 @@ export { detectReactNativeIssues } from './reactNative.js';
 export { detectNodejsIssues } from './nodejs.js';
 export { detectJavascriptIssues } from './javascript.js';
 export { detectTypescriptIssues } from './typescript.js';
+// Debug, Security, Accessibility
+export { detectDebugStatements } from './debug.js';
+export { detectSecurityIssues } from './security.js';
+export { detectAccessibilityIssues } from './accessibility.js';
+// Complexity, Memory Leaks, Imports
+export { detectComplexity, calculateComplexityMetrics } from './complexity.js';
+export { detectMemoryLeaks } from './memoryLeak.js';
+export { detectImportIssues, analyzeImports } from './imports.js';

package/dist/detectors/memoryLeak.d.ts

@@ -0,0 +1,7 @@
+import { ParsedComponent } from '../parser/index.js';
+import { CodeSmell, DetectorConfig } from '../types/index.js';
+/**
+ * Detect potential memory leaks in React components
+ */
+export declare function detectMemoryLeaks(component: ParsedComponent, filePath: string, sourceCode: string, config: DetectorConfig): CodeSmell[];
+//# sourceMappingURL=memoryLeak.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"memoryLeak.d.ts","sourceRoot":"","sources":["../../src/detectors/memoryLeak.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AACrD,OAAO,EAAE,SAAS,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAE9D;;GAEG;AACH,wBAAgB,iBAAiB,CAC/B,SAAS,EAAE,eAAe,EAC1B,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,MAAM,EAClB,MAAM,EAAE,cAAc,GACrB,SAAS,EAAE,CAgEb"}