react-code-smell-detector 1.2.0 → 1.4.1

package/dist/watcher.js

@@ -0,0 +1,89 @@
+import chokidar from 'chokidar';
+import path from 'path';
+import chalk from 'chalk';
+import { analyzeProject } from './analyzer.js';
+import { reportResults } from './reporter.js';
+/**
+ * Start watching a project for changes and re-analyze on each change
+ */
+export function startWatch(options) {
+    const { rootDir, include = ['**/*.tsx', '**/*.jsx'], exclude = ['**/node_modules/**', '**/dist/**', '**/build/**'], config, showSnippets, onAnalysis, } = options;
+    console.log(chalk.cyan('\n👀 Watch mode started'));
+    console.log(chalk.dim(`   Watching: ${rootDir}`));
+    console.log(chalk.dim(`   Patterns: ${include.join(', ')}`));
+    console.log(chalk.dim('   Press Ctrl+C to stop\n'));
+    // Debounce timer
+    let debounceTimer = null;
+    let isAnalyzing = false;
+    const runAnalysis = async () => {
+        if (isAnalyzing)
+            return;
+        isAnalyzing = true;
+        console.log(chalk.dim('\n─────────────────────────────────────────'));
+        console.log(chalk.cyan('🔄 Re-analyzing...'));
+        try {
+            const result = await analyzeProject({
+                rootDir,
+                include,
+                exclude,
+                config,
+            });
+            // Clear console and show results
+            console.clear();
+            console.log(chalk.cyan('\n👀 Watch mode - Last update: ' + new Date().toLocaleTimeString()));
+            console.log(chalk.dim('   Press Ctrl+C to stop\n'));
+            const output = reportResults(result, {
+                format: 'console',
+                showCodeSnippets: showSnippets,
+                rootDir,
+            });
+            console.log(output);
+            if (onAnalysis) {
+                onAnalysis(result.summary.totalFiles, result.summary.totalSmells);
+            }
+        }
+        catch (error) {
+            console.error(chalk.red('Analysis error:'), error.message);
+        }
+        finally {
+            isAnalyzing = false;
+        }
+    };
+    // Debounced analysis trigger
+    const triggerAnalysis = () => {
+        if (debounceTimer) {
+            clearTimeout(debounceTimer);
+        }
+        debounceTimer = setTimeout(runAnalysis, 300);
+    };
+    // Set up file watcher
+    const watchPatterns = include.map(p => path.join(rootDir, p));
+    const watcher = chokidar.watch(watchPatterns, {
+        ignored: exclude.map(p => {
+            if (p.startsWith('**/'))
+                return p;
+            return path.join(rootDir, p);
+        }),
+        persistent: true,
+        ignoreInitial: false,
+        awaitWriteFinish: {
+            stabilityThreshold: 100,
+            pollInterval: 50,
+        },
+    });
+    watcher
+        .on('add', () => triggerAnalysis())
+        .on('change', () => triggerAnalysis())
+        .on('unlink', () => triggerAnalysis())
+        .on('error', error => console.error(chalk.red('Watcher error:'), error));
+    // Initial analysis
+    triggerAnalysis();
+    return {
+        close: () => {
+            if (debounceTimer)
+                clearTimeout(debounceTimer);
+            watcher.close();
+            console.log(chalk.yellow('\n👋 Watch mode stopped'));
+        },
+    };
+}

package/dist/webhooks.d.ts

@@ -0,0 +1,20 @@
+import { CodeSmell } from './types/index.js';
+export interface WebhookConfig {
+    url: string;
+    type: 'slack' | 'discord' | 'generic';
+    threshold?: number;
+    includeDetails?: boolean;
+}
+/**
+ * Send analysis results to chat platform via webhook
+ */
+export declare function sendWebhookNotification(whConfig: WebhookConfig, smells: CodeSmell[], projectName: string, metadata?: {
+    branch?: string;
+    commit?: string;
+    author?: string;
+}): Promise<boolean>;
+/**
+ * Parse webhook URL from environment or config
+ */
+export declare function getWebhookConfig(slackUrl?: string, discordUrl?: string, genericUrl?: string): WebhookConfig | null;
+//# sourceMappingURL=webhooks.d.ts.map

package/dist/webhooks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"webhooks.d.ts","sourceRoot":"","sources":["../src/webhooks.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAE7C,MAAM,WAAW,aAAa;IAC5B,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,OAAO,GAAG,SAAS,GAAG,SAAS,CAAC;IACtC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,cAAc,CAAC,EAAE,OAAO,CAAC;CAC1B;AAED;;GAEG;AACH,wBAAsB,uBAAuB,CAC3C,QAAQ,EAAE,aAAa,EACvB,MAAM,EAAE,SAAS,EAAE,EACnB,WAAW,EAAE,MAAM,EACnB,QAAQ,CAAC,EAAE;IACT,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB,GACA,OAAO,CAAC,OAAO,CAAC,CAqBlB;AAmLD;;GAEG;AACH,wBAAgB,gBAAgB,CAC9B,QAAQ,CAAC,EAAE,MAAM,EACjB,UAAU,CAAC,EAAE,MAAM,EACnB,UAAU,CAAC,EAAE,MAAM,GAClB,aAAa,GAAG,IAAI,CAoBtB"}

package/dist/webhooks.js

@@ -0,0 +1,199 @@
+import https from 'https';
+/**
+ * Send analysis results to chat platform via webhook
+ */
+export async function sendWebhookNotification(whConfig, smells, projectName, metadata) {
+    if (!whConfig.url)
+        return false;
+    // Check threshold
+    if (whConfig.threshold && smells.length < whConfig.threshold) {
+        return false;
+    }
+    try {
+        const payload = whConfig.type === 'slack'
+            ? formatSlackMessage(smells, projectName, metadata, whConfig.includeDetails)
+            : whConfig.type === 'discord'
+                ? formatDiscordMessage(smells, projectName, metadata, whConfig.includeDetails)
+                : formatGenericMessage(smells, projectName, metadata);
+        return await postToWebhook(whConfig.url, payload);
+    }
+    catch (error) {
+        console.error('Webhook notification failed:', error);
+        return false;
+    }
+}
+/**
+ * Post JSON to a webhook URL
+ */
+function postToWebhook(url, payload) {
+    return new Promise((resolve) => {
+        try {
+            const data = JSON.stringify(payload);
+            const urlObj = new URL(url);
+            const options = {
+                hostname: urlObj.hostname,
+                path: urlObj.pathname + urlObj.search,
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Content-Length': Buffer.byteLength(data),
+                },
+            };
+            const req = https.request(options, (res) => {
+                resolve(res.statusCode ? res.statusCode >= 200 && res.statusCode < 300 : false);
+            });
+            req.on('error', () => resolve(false));
+            req.write(data);
+            req.end();
+        }
+        catch (error) {
+            resolve(false);
+        }
+    });
+}
+function formatSlackMessage(smells, projectName, metadata, includeDetails = false) {
+    const smellSummary = summarizeSmells(smells);
+    const color = smells.length > 20 ? 'danger' : smells.length > 10 ? 'warning' : 'good';
+    const fields = [
+        {
+            title: 'Total Smells',
+            value: smells.length.toString(),
+            short: true,
+        },
+        {
+            title: 'Severity',
+            value: getSeverityEmoji(smells.length),
+            short: true,
+        },
+    ];
+    if (metadata?.branch) {
+        fields.push({
+            title: 'Branch',
+            value: metadata.branch,
+            short: true,
+        });
+    }
+    if (metadata?.commit) {
+        fields.push({
+            title: 'Commit',
+            value: metadata.commit.slice(0, 7),
+            short: true,
+        });
+    }
+    // Add top issues
+    const topTypes = Object.entries(smellSummary)
+        .sort(([, a], [, b]) => b - a)
+        .slice(0, 5);
+    if (topTypes.length > 0) {
+        fields.push({
+            title: 'Top Issues',
+            value: topTypes.map(([type, count]) => `• ${type}: ${count}`).join('\n'),
+            short: false,
+        });
+    }
+    return {
+        text: `Code Smell Analysis: ${projectName}`,
+        attachments: [
+            {
+                fallback: `${smells.length} code smells detected`,
+                color,
+                title: `${smells.length} Code Smells Detected`,
+                fields,
+                footer: 'React Code Smell Detector',
+                ts: Math.floor(Date.now() / 1000),
+            },
+        ],
+    };
+}
+function formatDiscordMessage(smells, projectName, metadata, includeDetails = false) {
+    const smellSummary = summarizeSmells(smells);
+    const color = smells.length > 20 ? 15671935 : smells.length > 10 ? 16776960 : 65280; // Red, Yellow, Green
+    const topTypes = Object.entries(smellSummary)
+        .sort(([, a], [, b]) => b - a)
+        .slice(0, 5);
+    let description = `**Total Smells:** ${smells.length}\n`;
+    if (metadata?.branch) {
+        description += `**Branch:** ${metadata.branch}\n`;
+    }
+    if (metadata?.author) {
+        description += `**Author:** ${metadata.author}\n`;
+    }
+    if (topTypes.length > 0) {
+        description += '\n**Top Issues:**\n';
+        description += topTypes.map(([type, count]) => `• ${type}: ${count}`).join('\n');
+    }
+    return {
+        content: `Code Smell Analysis for ${projectName}`,
+        embeds: [
+            {
+                title: `${smells.length} Code Smells Detected`,
+                description,
+                color,
+                footer: {
+                    text: 'React Code Smell Detector',
+                },
+                timestamp: new Date().toISOString(),
+            },
+        ],
+    };
+}
+function formatGenericMessage(smells, projectName, metadata) {
+    const smellSummary = summarizeSmells(smells);
+    return {
+        project: projectName,
+        totalSmells: smells.length,
+        timestamp: new Date().toISOString(),
+        metadata,
+        summary: smellSummary,
+        severity: getSeverityLevel(smells.length),
+    };
+}
+function summarizeSmells(smells) {
+    const summary = {};
+    for (const smell of smells) {
+        summary[smell.type] = (summary[smell.type] || 0) + 1;
+    }
+    return summary;
+}
+function getSeverityEmoji(count) {
+    if (count > 50)
+        return '🔴 Critical';
+    if (count > 20)
+        return '🟠 High';
+    if (count > 10)
+        return '🟡 Medium';
+    if (count > 0)
+        return '🟢 Low';
+    return '✅ Excellent';
+}
+function getSeverityLevel(count) {
+    if (count > 50)
+        return 'critical';
+    if (count > 20)
+        return 'high';
+    if (count > 10)
+        return 'medium';
+    if (count > 0)
+        return 'low';
+    return 'excellent';
+}
+/**
+ * Parse webhook URL from environment or config
+ */
+export function getWebhookConfig(slackUrl, discordUrl, genericUrl) {
+    const slack = slackUrl || process.env.REACT_SMELL_SLACK_WEBHOOK || process.env.SLACK_WEBHOOK_URL;
+    const discord = discordUrl ||
+        process.env.REACT_SMELL_DISCORD_WEBHOOK ||
+        process.env.DISCORD_WEBHOOK_URL;
+    const generic = genericUrl || process.env.REACT_SMELL_WEBHOOK;
+    if (slack) {
+        return { url: slack, type: 'slack' };
+    }
+    if (discord) {
+        return { url: discord, type: 'discord' };
+    }
+    if (generic) {
+        return { url: generic, type: 'generic' };
+    }
+    return null;
+}

package/package.json

@@ -1,12 +1,17 @@
 {
   "name": "react-code-smell-detector",
-  "version": "1.2.0",
-  "description": "Detect code smells in React projects - useEffect overuse, prop drilling, large components, security issues, accessibility, and more",
+  "version": "1.4.1",
+  "description": "Detect code smells in React projects - useEffect overuse, prop drilling, large components, security issues, accessibility, memory leaks, and more",
   "main": "dist/index.js",
   "bin": {
     "react-smell": "dist/cli.js"
   },
   "type": "module",
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
   "scripts": {
     "build": "tsc",
     "dev": "tsc --watch",
@@ -29,8 +34,11 @@
     "@babel/traverse": "^7.23.0",
     "@babel/types": "^7.23.0",
     "chalk": "^5.3.0",
+    "chokidar": "^5.0.0",
     "commander": "^11.1.0",
     "fast-glob": "^3.3.2",
+    "fs-extra": "^11.3.3",
+    "node-fetch": "^3.3.2",
     "ora": "^8.0.1"
   },
   "devDependencies": {

package/src/analyzer.ts

@@ -1,324 +0,0 @@
-import fg from 'fast-glob';
-import path from 'path';
-import { parseFile, ParseResult } from './parser/index.js';
-import {
-  detectUseEffectOveruse,
-  detectPropDrilling,
-  analyzePropDrillingDepth,
-  detectLargeComponent,
-  detectUnmemoizedCalculations,
-  detectMissingKeys,
-  detectHooksRulesViolations,
-  detectDependencyArrayIssues,
-  detectNestedTernaries,
-  detectDeadCode,
-  detectMagicValues,
-  detectNextjsIssues,
-  detectReactNativeIssues,
-  detectNodejsIssues,
-  detectJavascriptIssues,
-  detectTypescriptIssues,
-  detectDebugStatements,
-  detectSecurityIssues,
-  detectAccessibilityIssues,
-} from './detectors/index.js';
-import {
-  AnalysisResult,
-  FileAnalysis,
-  ComponentInfo,
-  CodeSmell,
-  AnalysisSummary,
-  TechnicalDebtScore,
-  DetectorConfig,
-  DEFAULT_CONFIG,
-  SmellType,
-  SmellSeverity,
-} from './types/index.js';
-
-export interface AnalyzerOptions {
-  rootDir: string;
-  include?: string[];
-  exclude?: string[];
-  config?: Partial<DetectorConfig>;
-}
-
-export async function analyzeProject(options: AnalyzerOptions): Promise<AnalysisResult> {
-  const {
-    rootDir,
-    include = ['**/*.tsx', '**/*.jsx'],
-    exclude = ['**/node_modules/**', '**/dist/**', '**/build/**', '**/*.test.*', '**/*.spec.*'],
-    config: userConfig = {},
-  } = options;
-
-  const config: DetectorConfig = { ...DEFAULT_CONFIG, ...userConfig };
-
-  // Find all React files
-  const patterns = include.map(p => path.join(rootDir, p));
-  const files = await fg(patterns, {
-    ignore: exclude,
-    absolute: true,
-  });
-
-  const fileAnalyses: FileAnalysis[] = [];
-
-  // Analyze each file
-  for (const file of files) {
-    try {
-      const parseResult = await parseFile(file);
-      const analysis = analyzeFile(parseResult, file, config);
-      if (analysis.components.length > 0 || analysis.smells.length > 0) {
-        fileAnalyses.push(analysis);
-      }
-    } catch (error) {
-      // Skip files that can't be parsed
-      console.warn(`Warning: Could not parse ${file}: ${(error as Error).message}`);
-    }
-  }
-
-  // Calculate summary and score
-  const summary = calculateSummary(fileAnalyses);
-  const debtScore = calculateTechnicalDebtScore(fileAnalyses, summary);
-
-  return {
-    files: fileAnalyses,
-    summary,
-    debtScore,
-  };
-}
-
-function analyzeFile(parseResult: ParseResult, filePath: string, config: DetectorConfig): FileAnalysis {
-  const { components, imports, sourceCode } = parseResult;
-  const smells: CodeSmell[] = [];
-  const componentInfos: ComponentInfo[] = [];
-
-  // Run all detectors on each component
-  components.forEach(component => {
-    // Collect component info
-    componentInfos.push({
-      name: component.name,
-      file: filePath,
-      startLine: component.startLine,
-      endLine: component.endLine,
-      lineCount: component.endLine - component.startLine + 1,
-      useEffectCount: component.hooks.useEffect.length,
-      useStateCount: component.hooks.useState.length,
-      useMemoCount: component.hooks.useMemo.length,
-      useCallbackCount: component.hooks.useCallback.length,
-      propsCount: component.props.length,
-      propsDrillingDepth: 0, // Calculated separately
-      hasExpensiveCalculation: false, // Will be set by memoization detector
-    });
-
-    // Run detectors
-    smells.push(...detectUseEffectOveruse(component, filePath, sourceCode, config));
-    smells.push(...detectPropDrilling(component, filePath, sourceCode, config));
-    smells.push(...detectLargeComponent(component, filePath, sourceCode, config));
-    smells.push(...detectUnmemoizedCalculations(component, filePath, sourceCode, config));
-    smells.push(...detectMissingKeys(component, filePath, sourceCode, config));
-    smells.push(...detectHooksRulesViolations(component, filePath, sourceCode, config));
-    smells.push(...detectDependencyArrayIssues(component, filePath, sourceCode, config));
-    smells.push(...detectNestedTernaries(component, filePath, sourceCode, config));
-    smells.push(...detectDeadCode(component, filePath, sourceCode, config));
-    smells.push(...detectMagicValues(component, filePath, sourceCode, config));
-    // Framework-specific detectors
-    smells.push(...detectNextjsIssues(component, filePath, sourceCode, config, imports));
-    smells.push(...detectReactNativeIssues(component, filePath, sourceCode, config, imports));
-    smells.push(...detectNodejsIssues(component, filePath, sourceCode, config, imports));
-    smells.push(...detectJavascriptIssues(component, filePath, sourceCode, config));
-    smells.push(...detectTypescriptIssues(component, filePath, sourceCode, config));
-    // Debug, Security, Accessibility
-    smells.push(...detectDebugStatements(component, filePath, sourceCode, config));
-    smells.push(...detectSecurityIssues(component, filePath, sourceCode, config));
-    smells.push(...detectAccessibilityIssues(component, filePath, sourceCode, config));
-  });
-
-  // Run cross-component analysis
-  smells.push(...analyzePropDrillingDepth(components, filePath, sourceCode, config));
-
-  // Filter out smells with @smell-ignore comments
-  const filteredSmells = filterIgnoredSmells(smells, sourceCode);
-
-  return {
-    file: filePath,
-    components: componentInfos,
-    smells: filteredSmells,
-    imports,
-  };
-}
-
-/**
- * Filter out smells that have @smell-ignore comment on the preceding line
- * Supports: // @smell-ignore, block comments with @smell-ignore, @smell-ignore [type]
- */
-function filterIgnoredSmells(smells: CodeSmell[], sourceCode: string): CodeSmell[] {
-  const lines = sourceCode.split('\n');
-  
-  return smells.filter(smell => {
-    if (smell.line <= 1) return true;
-    
-    // Check the line before and the same line for ignore comments
-    const lineIndex = smell.line - 1; // Convert to 0-indexed
-    const prevLine = lines[lineIndex - 1]?.trim() || '';
-    const currentLine = lines[lineIndex]?.trim() || '';
-    
-    // Check for @smell-ignore patterns
-    const ignorePatterns = [
-      /@smell-ignore\s*$/,                           // @smell-ignore (ignore all)
-      /@smell-ignore\s+\*/,                          // @smell-ignore * (ignore all)
-      new RegExp(`@smell-ignore\\s+${smell.type}`),  // @smell-ignore [specific-type]
-    ];
-    
-    for (const pattern of ignorePatterns) {
-      if (pattern.test(prevLine) || pattern.test(currentLine)) {
-        return false; // Filter out this smell
-      }
-    }
-    
-    return true; // Keep this smell
-  });
-}
-
-function calculateSummary(files: FileAnalysis[]): AnalysisSummary {
-  const smellsByType: Record<SmellType, number> = {
-    'useEffect-overuse': 0,
-    'prop-drilling': 0,
-    'large-component': 0,
-    'unmemoized-calculation': 0,
-    'missing-dependency': 0,
-    'state-in-loop': 0,
-    'inline-function-prop': 0,
-    'deep-nesting': 0,
-    'missing-key': 0,
-    'hooks-rules-violation': 0,
-    'dependency-array-issue': 0,
-    'nested-ternary': 0,
-    'dead-code': 0,
-    'magic-value': 0,
-    // Next.js
-    'nextjs-client-server-boundary': 0,
-    'nextjs-missing-metadata': 0,
-    'nextjs-image-unoptimized': 0,
-    'nextjs-router-misuse': 0,
-    // React Native
-    'rn-inline-style': 0,
-    'rn-missing-accessibility': 0,
-    'rn-performance-issue': 0,
-    // Node.js
-    'nodejs-callback-hell': 0,
-    'nodejs-unhandled-promise': 0,
-    'nodejs-sync-io': 0,
-    'nodejs-missing-error-handling': 0,
-    // JavaScript
-    'js-var-usage': 0,
-    'js-loose-equality': 0,
-    'js-implicit-coercion': 0,
-    'js-global-pollution': 0,
-    // TypeScript
-    'ts-any-usage': 0,
-    'ts-missing-return-type': 0,
-    'ts-non-null-assertion': 0,
-    'ts-type-assertion': 0,
-    // Debug statements
-    'debug-statement': 0,
-    'todo-comment': 0,
-    // Security
-    'security-xss': 0,
-    'security-eval': 0,
-    'security-secrets': 0,
-    // Accessibility
-    'a11y-missing-alt': 0,
-    'a11y-missing-label': 0,
-    'a11y-interactive-role': 0,
-    'a11y-keyboard': 0,
-    'a11y-semantic': 0,
-  };
-
-  const smellsBySeverity: Record<SmellSeverity, number> = {
-    error: 0,
-    warning: 0,
-    info: 0,
-  };
-
-  let totalSmells = 0;
-  let totalComponents = 0;
-
-  files.forEach(file => {
-    totalComponents += file.components.length;
-    file.smells.forEach(smell => {
-      totalSmells++;
-      smellsByType[smell.type]++;
-      smellsBySeverity[smell.severity]++;
-    });
-  });
-
-  return {
-    totalFiles: files.length,
-    totalComponents,
-    totalSmells,
-    smellsByType,
-    smellsBySeverity,
-  };
-}
-
-function calculateTechnicalDebtScore(files: FileAnalysis[], summary: AnalysisSummary): TechnicalDebtScore {
-  // Calculate individual scores (0-100, higher is better)
-  
-  // useEffect score: penalize based on useEffect-related issues
-  const useEffectIssues = summary.smellsByType['useEffect-overuse'];
-  const useEffectScore = Math.max(0, 100 - useEffectIssues * 15);
-
-  // Prop drilling score
-  const propDrillingIssues = summary.smellsByType['prop-drilling'];
-  const propDrillingScore = Math.max(0, 100 - propDrillingIssues * 12);
-
-  // Component size score
-  const sizeIssues = summary.smellsByType['large-component'] + summary.smellsByType['deep-nesting'];
-  const componentSizeScore = Math.max(0, 100 - sizeIssues * 10);
-
-  // Memoization score
-  const memoIssues = summary.smellsByType['unmemoized-calculation'] + summary.smellsByType['inline-function-prop'];
-  const memoizationScore = Math.max(0, 100 - memoIssues * 8);
-
-  // Overall score (weighted average)
-  const score = Math.round(
-    useEffectScore * 0.3 +
-    propDrillingScore * 0.25 +
-    componentSizeScore * 0.25 +
-    memoizationScore * 0.2
-  );
-
-  // Determine grade
-  let grade: 'A' | 'B' | 'C' | 'D' | 'F';
-  if (score >= 90) grade = 'A';
-  else if (score >= 80) grade = 'B';
-  else if (score >= 70) grade = 'C';
-  else if (score >= 60) grade = 'D';
-  else grade = 'F';
-
-  // Estimate refactor time
-  const errorCount = summary.smellsBySeverity.error;
-  const warningCount = summary.smellsBySeverity.warning;
-  const totalIssues = errorCount * 30 + warningCount * 15; // minutes
-  
-  let estimatedRefactorTime: string;
-  if (totalIssues < 30) estimatedRefactorTime = '< 30 minutes';
-  else if (totalIssues < 60) estimatedRefactorTime = '30 min - 1 hour';
-  else if (totalIssues < 120) estimatedRefactorTime = '1-2 hours';
-  else if (totalIssues < 240) estimatedRefactorTime = '2-4 hours';
-  else if (totalIssues < 480) estimatedRefactorTime = '4-8 hours';
-  else estimatedRefactorTime = '> 1 day';
-
-  return {
-    score,
-    grade,
-    breakdown: {
-      useEffectScore,
-      propDrillingScore,
-      componentSizeScore,
-      memoizationScore,
-    },
-    estimatedRefactorTime,
-  };
-}
-
-export { DEFAULT_CONFIG, DetectorConfig } from './types/index.js';