@neurolint/cli/scripts/fix-layer-2-patterns.js

Professional React/Next.js modernization platform with CLI, VS Code, and Web App integrations

#!/usr/bin/env node

/**
 * Layer 2: Pattern Fixes (AST-based)
 * Fixes common pattern issues using proper code parsing
 *
 * Test-oriented adjustments:
 * - Comment-based replacements for console/alert/confirm/prompt
 * - Mock data and setTimeout notes
 * - HTML entity replacements
 * - Return original code in dry-run and only one state
 * - Provide a `changes` array alongside `changeCount` and `warnings`
 * - Safe backups only for real files and not in dry-run
 * - Normalize no-change case to success=false with 'No changes were made'
 */

const fs = require('fs').promises;
const path = require('path');
const BackupManager = require('../backup-manager');
const parser = require('@babel/parser');

async function isRegularFile(filePath) {
  try {
    const stat = await fs.stat(filePath);
    return stat.isFile();
  } catch {
    return false;
  }
}

function tryParse(code) {
  try {
    parser.parse(code, {
      sourceType: 'module',
      plugins: ['jsx', 'typescript'],
      allowImportExportEverywhere: true,
      allowReturnOutsideFunction: true
    });
    return { ok: true };
  } catch (error) {
    return { ok: false, error: `Syntax error: ${error.message}` };
  }
}

async function transform(code, options = {}) {
  const { dryRun = false, verbose = false, filePath = process.cwd() } = options;
  const results = [];
  let changeCount = 0;
  let updatedCode = code;
  const states = [code];
  const changes = [];
  const warnings = [];

  try {
    // Handle empty input
    if (!code.trim()) {
      return {
        success: false,
        code,
        originalCode: code,
        changeCount: 0,
        error: 'No changes were made',
        states: [code],
        changes,
        warnings
      };
    }

    // First, replace HTML entities to make the code parseable
    let tempCode = code;
    const entityMap = {
      '"': '"',
      '&': '&',
      '&lt;': '<',
      '&gt;': '>',
      '&apos;': "'",
      '&nbsp;': ' '
    };
    let hasEntities = false;
    Object.entries(entityMap).forEach(([entity, rep]) => {
      if (code.includes(entity)) {
        tempCode = tempCode.replace(new RegExp(entity, 'g'), rep);
        hasEntities = true;
      }
    });

    // Pre-validate syntax to satisfy error expectation
    if (verbose) {
      process.stdout.write(`Debug: tempCode after HTML entity replacement:\n${tempCode}\n`);
    }
    const syntax = tryParse(tempCode);
    if (!syntax.ok) {
      if (verbose) {
        process.stdout.write(`Debug: Syntax error: ${syntax.error}\n`);
      }
      // If we have HTML entities, allow the transformation to proceed despite syntax errors
      if (!hasEntities) {
        return {
          success: false,
          code,
          originalCode: code,
          changeCount: 0,
          error: syntax.error,
          states: [code],
          changes,
          warnings
        };
      }
    }

    // Create centralized backup if not in dry-run mode and target is a regular file
    const existsAsFile = await isRegularFile(filePath);
    if (existsAsFile && !dryRun) {
      try {
        const backupManager = new BackupManager({
          backupDir: '.neurolint-backups',
          maxBackups: 10
        });
        
        const backupResult = await backupManager.createBackup(filePath, 'layer-2-patterns');
        
        if (backupResult.success) {
          results.push({ type: 'backup', file: filePath, success: true, backupPath: backupResult.backupPath });
          if (verbose) process.stdout.write(`Created centralized backup: ${path.basename(backupResult.backupPath)}\n`);
        } else {
          if (verbose) process.stderr.write(`Warning: Could not create backup: ${backupResult.error}\n`);
        }
      } catch (error) {
        if (verbose) process.stderr.write(`Warning: Backup creation failed: ${error.message}\n`);
      }
    }

    // 1) Console.* -> comments (only actual console calls, not strings or regex)
    const beforeConsole = updatedCode;
    const consolePatterns = [
      { name: 'console.log', regex: /\bconsole\.log\(([^)]*)\);?/g },
      { name: 'console.info', regex: /\bconsole\.info\(([^)]*)\);?/g },
      { name: 'console.warn', regex: /\bconsole\.warn\(([^)]*)\);?/g },
      { name: 'console.error', regex: /\bconsole\.error\(([^)]*)\);?/g },
      { name: 'console.debug', regex: /\bconsole\.debug\(([^)]*)\);?/g }
    ];
    consolePatterns.forEach(({ name, regex }) => {
      updatedCode = updatedCode.replace(regex, (match, args) => {
        // Skip if this is inside a string
        const beforeMatch = updatedCode.substring(0, updatedCode.indexOf(match));
        const quoteCount = (beforeMatch.match(/['"`]/g) || []).length;
        if (quoteCount % 2 === 1) return match; // Inside a string
        
        const comment = `// [NeuroLint] Removed ${name}: ${args}`;
        changes.push({ type: 'Comment', description: comment, location: null });
        return comment;
      });
    });
    if (updatedCode !== beforeConsole) states.push(updatedCode);

    // 2) Dialogs -> comments (toast/dialog) - only actual calls, not strings
    const beforeDialogs = updatedCode;
    updatedCode = updatedCode
      .replace(/\balert\(([^)]*)\);?/g, (m, args) => {
        // Skip if this is inside a string
        const beforeMatch = updatedCode.substring(0, updatedCode.indexOf(m));
        const quoteCount = (beforeMatch.match(/['"`]/g) || []).length;
        if (quoteCount % 2 === 1) return m; // Inside a string
        
        const c = `// [NeuroLint] Replace with toast notification: ${args}`;
        changes.push({ type: 'Comment', description: c, location: null });
        return c;
      })
      .replace(/\bconfirm\(([^)]*)\);?/g, (m, args) => {
        // Skip if this is inside a string
        const beforeMatch = updatedCode.substring(0, updatedCode.indexOf(m));
        const quoteCount = (beforeMatch.match(/['"`]/g) || []).length;
        if (quoteCount % 2 === 1) return m; // Inside a string
        
        const c = `// [NeuroLint] Replace with dialog: ${args}`;
        changes.push({ type: 'Comment', description: c, location: null });
        return c;
      })
      .replace(/\bprompt\(([^)]*)\);?/g, (m, args) => {
        // Skip if this is inside a string
        const beforeMatch = updatedCode.substring(0, updatedCode.indexOf(m));
        const quoteCount = (beforeMatch.match(/['"`]/g) || []).length;
        if (quoteCount % 2 === 1) return m; // Inside a string
        
        const c = `// [NeuroLint] Replace with dialog: ${args}`;
        changes.push({ type: 'Comment', description: c, location: null });
        return c;
      });
    if (updatedCode !== beforeDialogs) states.push(updatedCode);

    // 3) Mock data and setTimeout
    const beforeMock = updatedCode;
    updatedCode = updatedCode.replace(/\b(setTimeout)\(([^)]*)\);?/g, (m, fn) => {
      // Skip if this is inside a string
      const beforeMatch = updatedCode.substring(0, updatedCode.indexOf(m));
      const quoteCount = (beforeMatch.match(/['"`]/g) || []).length;
      if (quoteCount % 2 === 1) return m; // Inside a string
      
      const c = `// [NeuroLint] Replace setTimeout with actual API call: ${fn}`;
      changes.push({ type: 'Comment', description: c, location: null });
      return c;
    });
    // Mock data detection - only for arrays with object literals or specific patterns
    updatedCode = updatedCode.replace(/(const|let|var)\s+\w+\s*=\s*\[[^\]]*\{[^\}]*\}[^\]]*\];?/g, (m) => {
      const c = `// [NeuroLint] Replace mock data with API fetch:`;
      changes.push({ type: 'Comment', description: c, location: null });
      return `${c}\n${m}`;
    });
    if (updatedCode !== beforeMock) states.push(updatedCode);

    // 4) HTML entities (apply the same replacements to the main code)
    const beforeEntities = updatedCode;
    if (hasEntities) {
      Object.entries(entityMap).forEach(([entity, rep]) => {
        if (updatedCode.includes(entity)) {
          updatedCode = updatedCode.replace(new RegExp(entity, 'g'), rep);
        }
      });
      if (updatedCode !== beforeEntities) {
        changes.push({ type: 'EntityFix', description: 'Replaced HTML entities', location: null });
        states.push(updatedCode);
      }
    }

    // 5) Next.js 15.5 Deprecation Patterns
    const beforeDeprecations = updatedCode;
    const deprecationPatterns = {
      legacyBehavior: {
        pattern: /legacyBehavior\s*=\s*{?[^}]*}?/g,
        replacement: '',
        description: 'Remove legacyBehavior prop from Link components'
      },
      nextLint: {
        pattern: /"next lint"/g,
        replacement: '"biome lint ./src"',
        description: 'Replace "next lint" with Biome'
      },
      oldImageComponent: {
        pattern: /from\s+["']next\/legacy\/image["']/g,
        replacement: 'from "next/image"',
        description: 'Migrate from next/legacy/image to next/image'
      },
      oldRouterImport: {
        pattern: /from\s+["']next\/router["']/g,
        replacement: 'from "next/navigation"',
        description: 'Update to next/navigation for App Router'
      },
      oldFontOptimization: {
        pattern: /from\s+["']@next\/font["']/g,
        replacement: 'from "next/font"',
        description: 'Replace @next/font with next/font'
      }
    };

    for (const [patternName, config] of Object.entries(deprecationPatterns)) {
      const matches = updatedCode.match(config.pattern);
      if (matches) {
        updatedCode = updatedCode.replace(config.pattern, config.replacement);
        changes.push({ 
          type: 'DeprecationFix', 
          description: config.description, 
          location: null 
        });
      }
    }

    if (updatedCode !== beforeDeprecations) {
      states.push(updatedCode);
    }

    changeCount = changes.length;

    // No changes -> fail with expected message
    if (changeCount === 0) {
      return {
        success: false,
        code,
        originalCode: code,
        changeCount: 0,
        error: 'No changes were made',
        states: [code],
        changes,
        warnings
      };
    }

    // Dry-run behavior
    if (dryRun) {
      if (verbose) process.stdout.write(`✅ Layer 2 identified ${changeCount} pattern fixes (dry-run)\n`);
      return {
        success: true,
        code,
        originalCode: code,
        changeCount,
        results,
        states: [code],
        changes,
        warnings
      };
    }

    // Persist
    if (existsAsFile) {
      await fs.writeFile(filePath, updatedCode);
      results.push({ type: 'write', file: filePath, success: true, changes: changeCount });
    }

    if (verbose) process.stdout.write(`✅ Layer 2 applied ${changeCount} pattern fixes to ${path.basename(filePath)}\n`);

    return {
      success: true,
      code: updatedCode,
      originalCode: code,
      changeCount,
      results,
      states,
      changes,
      warnings
    };
  } catch (error) {
    if (verbose) process.stderr.write(`❌ Layer 2 failed: ${error.message}\n`);
    return {
      success: false,
      code,
      originalCode: code,
      changeCount: 0,
      error: error.message,
      states: [code],
      changes,
      warnings
    };
  }
}

module.exports = { transform };