@nlabs/lex 1.49.4 → 1.50.0

package/lib/commands/lint/lint.js

@@ -1,83 +1,100 @@
-import { execa } from "execa";
-import { existsSync, readFileSync, unlinkSync, writeFileSync } from "fs";
-import { dirname, resolve as pathResolve, extname } from "path";
-import { LexConfig } from "../../LexConfig.js";
-import { createSpinner } from "../../utils/app.js";
-import { resolveBinaryPath } from "../../utils/file.js";
-import { log } from "../../utils/log.js";
+/**
+ * Copyright (c) 2022-Present, Nitrogen Labs, Inc.
+ * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
+ */ import { execa } from 'execa';
+import { existsSync, readFileSync, unlinkSync, writeFileSync } from 'fs';
+import { dirname, resolve as pathResolve, extname } from 'path';
+import { LexConfig } from '../../LexConfig.js';
+import { createSpinner } from '../../utils/app.js';
+import { resolveBinaryPath } from '../../utils/file.js';
+import { log } from '../../utils/log.js';
 let currentFilename;
 let currentDirname;
 try {
-  currentFilename = eval('require("url").fileURLToPath(import.meta.url)');
-  currentDirname = dirname(currentFilename);
-} catch {
-  currentFilename = process.cwd();
-  currentDirname = process.cwd();
+    currentFilename = eval('require("url").fileURLToPath(import.meta.url)');
+    currentDirname = dirname(currentFilename);
+} catch  {
+    currentFilename = process.cwd();
+    currentDirname = process.cwd();
 }
-const createDefaultESLintConfig = (useTypescript, cwd) => {
-  const configPath = pathResolve(cwd, ".lex-temp-default-eslint.cjs");
-  const originalConfig = null;
-  const configContent = `// Temporary ESLint config generated by Lex
+const createDefaultESLintConfig = (useTypescript, cwd)=>{
+    // Use a temporary file path instead of creating in the project directory
+    const configPath = pathResolve(cwd, '.lex-temp-default-eslint.cjs');
+    const originalConfig = null;
+    // Create a temporary CommonJS module that requires Lex's ESLint config
+    const configContent = `// Temporary ESLint config generated by Lex
 const lexConfig = require('@nlabs/lex/eslint.config.mjs');
 
 module.exports = lexConfig;`;
-  writeFileSync(configPath, configContent, "utf8");
-  return {
-    configPath,
-    originalConfig
-  };
+    writeFileSync(configPath, configContent, 'utf8');
+    return {
+        configPath,
+        originalConfig
+    };
 };
-const detectTypeScript = (cwd) => existsSync(pathResolve(cwd, "tsconfig.json"));
-const ensureModuleType = (cwd) => {
-  const packageJsonPath = pathResolve(cwd, "package.json");
-  if (existsSync(packageJsonPath)) {
-    try {
-      const packageJsonContent = readFileSync(packageJsonPath, "utf8");
-      const packageJson = JSON.parse(packageJsonContent);
-      if (packageJson.type !== "module") {
-        log('Warning: package.json should have "type": "module" for ESM support. Please add this manually.', "warn", false);
-      }
-    } catch (_error) {
+const detectTypeScript = (cwd)=>existsSync(pathResolve(cwd, 'tsconfig.json'));
+/**
+ * Ensure package.json has type: module for ESM support
+ */ const ensureModuleType = (cwd)=>{
+    const packageJsonPath = pathResolve(cwd, 'package.json');
+    if (existsSync(packageJsonPath)) {
+        try {
+            const packageJsonContent = readFileSync(packageJsonPath, 'utf8');
+            const packageJson = JSON.parse(packageJsonContent);
+            // If type is not set to module, warn instead of auto-modifying
+            if (packageJson.type !== 'module') {
+                log('Warning: package.json should have "type": "module" for ESM support. Please add this manually.', 'warn', false);
+            }
+        } catch (_error) {
+        // Ignore errors
+        }
     }
-  }
-};
-const installDependencies = async (cwd, useTypescript, quiet) => {
-  if (useTypescript) {
-    log("Using TypeScript ESLint from Lex...", "info", quiet);
-  } else {
-    log("Using ESLint from Lex...", "info", quiet);
-  }
 };
-const runEslintWithLex = async (cwd, quiet, cliName, fix, debug, useTypescript, captureOutput) => {
-  const spinner = createSpinner(quiet);
-  try {
-    const projectConfigPath = pathResolve(cwd, "eslint.config.mjs");
-    const projectConfigPathTs = pathResolve(cwd, "eslint.config.ts");
-    const hasProjectConfig = existsSync(projectConfigPath) || existsSync(projectConfigPathTs);
-    const hasLexConfigEslint = LexConfig.config.eslint && Object.keys(LexConfig.config.eslint).length > 0;
-    const possiblePaths = [
-      pathResolve(currentDirname, "../../../../eslint.config.mjs"),
-      pathResolve(currentDirname, "../../../../eslint.config.ts"),
-      pathResolve(process.env.LEX_HOME || "/usr/local/lib/node_modules/@nlabs/lex", "eslint.config.mjs"),
-      pathResolve(process.env.LEX_HOME || "/usr/local/lib/node_modules/@nlabs/lex", "eslint.config.ts")
-    ];
-    let lexConfigPath = "";
-    for (const path of possiblePaths) {
-      if (existsSync(path)) {
-        lexConfigPath = path;
-        break;
-      }
+const installDependencies = async (cwd, useTypescript, quiet)=>{
+    if (useTypescript) {
+        log('Using TypeScript ESLint from Lex...', 'info', quiet);
+    } else {
+        log('Using ESLint from Lex...', 'info', quiet);
     }
-    let configPath = "";
-    let tempConfigPath = "";
-    if (hasProjectConfig) {
-      configPath = existsSync(projectConfigPathTs) ? projectConfigPathTs : projectConfigPath;
-      if (debug) {
-        log(`Using project ESLint config file: ${configPath}`, "info", quiet);
-      }
-    } else if (hasLexConfigEslint) {
-      tempConfigPath = pathResolve(cwd, ".lex-temp-eslint.cjs");
-      const configContent = `// Temporary ESLint config generated by Lex
+};
+const runEslintWithLex = async (cwd, quiet, cliName, fix, debug, useTypescript, captureOutput)=>{
+    const spinner = createSpinner(quiet);
+    try {
+        const projectConfigPath = pathResolve(cwd, 'eslint.config.mjs');
+        const projectConfigPathTs = pathResolve(cwd, 'eslint.config.ts');
+        const hasProjectConfig = existsSync(projectConfigPath) || existsSync(projectConfigPathTs);
+        const hasLexConfigEslint = LexConfig.config.eslint && Object.keys(LexConfig.config.eslint).length > 0;
+        const possiblePaths = [
+            pathResolve(currentDirname, '../../../../eslint.config.mjs'),
+            pathResolve(currentDirname, '../../../../eslint.config.ts'),
+            pathResolve(process.env.LEX_HOME || '/usr/local/lib/node_modules/@nlabs/lex', 'eslint.config.mjs'),
+            pathResolve(process.env.LEX_HOME || '/usr/local/lib/node_modules/@nlabs/lex', 'eslint.config.ts')
+        ];
+        let lexConfigPath = '';
+        for (const path of possiblePaths){
+            if (existsSync(path)) {
+                lexConfigPath = path;
+                break;
+            }
+        }
+        let configPath = '';
+        let tempConfigPath = '';
+        // Priority:
+        // 1. Project eslint.config files
+        // 2. ESLint config in lex.config.* file
+        // 3. Lex's default eslint.config.mjs
+        // 4. Create a temporary config file
+        if (hasProjectConfig) {
+            configPath = existsSync(projectConfigPathTs) ? projectConfigPathTs : projectConfigPath;
+            if (debug) {
+                log(`Using project ESLint config file: ${configPath}`, 'info', quiet);
+            }
+        } else if (hasLexConfigEslint) {
+            // When using lex.config.eslint, create a temporary JS config file (not JSON)
+            // to avoid ESM JSON import issues
+            tempConfigPath = pathResolve(cwd, '.lex-temp-eslint.cjs');
+            // Create a CommonJS module that extends Lex's eslint config
+            const configContent = `// Temporary ESLint config generated by Lex
 const lexConfig = require('@nlabs/lex/eslint.config.mjs');
 const userConfig = ${JSON.stringify(LexConfig.config.eslint, null, 2)};
 
@@ -85,195 +102,212 @@ const userConfig = ${JSON.stringify(LexConfig.config.eslint, null, 2)};
 module.exports = {
   ...lexConfig
 };`;
-      writeFileSync(tempConfigPath, configContent, "utf8");
-      configPath = tempConfigPath;
-      if (debug) {
-        log(`Using ESLint config from lex.config.* file via temp file: ${tempConfigPath}`, "info", quiet);
-      }
-    } else if (lexConfigPath && existsSync(lexConfigPath)) {
-      configPath = lexConfigPath;
-      if (debug) {
-        log(`Using Lex ESLint config file: ${configPath}`, "info", quiet);
-      }
-    } else {
-      tempConfigPath = pathResolve(cwd, ".lex-temp-default-eslint.cjs");
-      const configContent = `// Temporary default ESLint config generated by Lex
+            writeFileSync(tempConfigPath, configContent, 'utf8');
+            configPath = tempConfigPath;
+            if (debug) {
+                log(`Using ESLint config from lex.config.* file via temp file: ${tempConfigPath}`, 'info', quiet);
+            }
+        } else if (lexConfigPath && existsSync(lexConfigPath)) {
+            configPath = lexConfigPath;
+            if (debug) {
+                log(`Using Lex ESLint config file: ${configPath}`, 'info', quiet);
+            }
+        } else {
+            // Create a temporary default config file if no other config is found
+            tempConfigPath = pathResolve(cwd, '.lex-temp-default-eslint.cjs');
+            // Create a basic ESLint config
+            const configContent = `// Temporary default ESLint config generated by Lex
 const lexConfig = require('@nlabs/lex/eslint.config.mjs');
 
 module.exports = lexConfig;`;
-      writeFileSync(tempConfigPath, configContent, "utf8");
-      configPath = tempConfigPath;
-      if (debug) {
-        log(`Created temporary default ESLint config at: ${tempConfigPath}`, "info", quiet);
-      } else {
-        log("No ESLint configuration found. Using Lex default configuration.", "info", quiet);
-      }
-    }
-    const eslintBinary = resolveBinaryPath("eslint", "eslint");
-    if (!eslintBinary) {
-      log(`
-${cliName} Error: ESLint binary not found in Lex's node_modules`, "error", quiet);
-      log("Please reinstall Lex or check your installation.", "info", quiet);
-      return 1;
-    }
-    const baseEslintArgs = [
-      ...fix ? ["--fix"] : [],
-      ...debug ? ["--debug"] : [],
-      "--no-error-on-unmatched-pattern",
-      "--no-warn-ignored"
-    ];
-    const configArgs = configPath ? ["--config", configPath] : [];
-    const jsResult = await execa(eslintBinary, [
-      "src/**/*.{js,jsx}",
-      ...configArgs,
-      ...baseEslintArgs
-    ], {
-      cwd,
-      reject: false,
-      shell: true,
-      stdio: "pipe"
-    });
-    if (jsResult.stdout) {
-      console.log(jsResult.stdout);
-      if (captureOutput) {
-        captureOutput(jsResult.stdout);
-      }
-    }
-    if (jsResult.stderr) {
-      console.error(jsResult.stderr);
-      if (captureOutput) {
-        captureOutput(jsResult.stderr);
-      }
-    }
-    let tsResult = { exitCode: 0, stderr: "", stdout: "" };
-    if (useTypescript) {
-      tsResult = await execa(eslintBinary, [
-        "src/**/*.{ts,tsx}",
-        ...configArgs,
-        ...baseEslintArgs
-      ], {
-        cwd,
-        reject: false,
-        shell: true,
-        stdio: "pipe"
-      });
-      if (tsResult.stdout) {
-        console.log(tsResult.stdout);
-      }
-      if (tsResult.stderr) {
-        console.error(tsResult.stderr);
-      }
-    }
-    if (tempConfigPath && existsSync(tempConfigPath)) {
-      try {
-        unlinkSync(tempConfigPath);
-        if (debug) {
-          log(`Removed temporary ESLint config at ${tempConfigPath}`, "info", quiet);
+            writeFileSync(tempConfigPath, configContent, 'utf8');
+            configPath = tempConfigPath;
+            if (debug) {
+                log(`Created temporary default ESLint config at: ${tempConfigPath}`, 'info', quiet);
+            } else {
+                log('No ESLint configuration found. Using Lex default configuration.', 'info', quiet);
+            }
         }
-      } catch (error) {
-        if (debug) {
-          log(`Failed to remove temporary ESLint config: ${error.message}`, "warn", quiet);
+        const eslintBinary = resolveBinaryPath('eslint', 'eslint');
+        if (!eslintBinary) {
+            log(`\n${cliName} Error: ESLint binary not found in Lex's node_modules`, 'error', quiet);
+            log('Please reinstall Lex or check your installation.', 'info', quiet);
+            return 1;
         }
-      }
-    }
-    const eslintNotFound = jsResult.stderr?.includes("command not found") || jsResult.stderr?.includes("eslint: command not found");
-    if (eslintNotFound) {
-      spinner.fail("ESLint not found!");
-      log(`
-${cliName} Error: Lex's ESLint binary not found. Please reinstall Lex or check your installation.`, "error", quiet);
-      return 1;
-    }
-    if (jsResult.exitCode === 0 && tsResult.exitCode === 0) {
-      spinner.succeed("Linting completed!");
-      return 0;
-    }
-    const noFilesFound = (jsResult.stderr?.includes("No such file or directory") || jsResult.stdout?.includes("No such file or directory")) && (!useTypescript || tsResult.stderr?.includes("No such file or directory") || tsResult.stdout?.includes("No such file or directory"));
-    if (noFilesFound) {
-      spinner.succeed("No files found to lint");
-      return 0;
+        // Base ESLint arguments
+        const baseEslintArgs = [
+            ...fix ? [
+                '--fix'
+            ] : [],
+            ...debug ? [
+                '--debug'
+            ] : [],
+            '--no-error-on-unmatched-pattern',
+            '--no-warn-ignored'
+        ];
+        // Add config path
+        const configArgs = configPath ? [
+            '--config',
+            configPath
+        ] : [];
+        const jsResult = await execa(eslintBinary, [
+            'src/**/*.{js,jsx}',
+            ...configArgs,
+            ...baseEslintArgs
+        ], {
+            cwd,
+            reject: false,
+            shell: true,
+            stdio: 'pipe'
+        });
+        if (jsResult.stdout) {
+            // eslint-disable-next-line no-console
+            console.log(jsResult.stdout);
+            if (captureOutput) {
+                captureOutput(jsResult.stdout);
+            }
+        }
+        if (jsResult.stderr) {
+            // eslint-disable-next-line no-console
+            console.error(jsResult.stderr);
+            if (captureOutput) {
+                captureOutput(jsResult.stderr);
+            }
+        }
+        let tsResult = {
+            exitCode: 0,
+            stderr: '',
+            stdout: ''
+        };
+        if (useTypescript) {
+            tsResult = await execa(eslintBinary, [
+                'src/**/*.{ts,tsx}',
+                ...configArgs,
+                ...baseEslintArgs
+            ], {
+                cwd,
+                reject: false,
+                shell: true,
+                stdio: 'pipe'
+            });
+            if (tsResult.stdout) {
+                // eslint-disable-next-line no-console
+                console.log(tsResult.stdout);
+            }
+            if (tsResult.stderr) {
+                // eslint-disable-next-line no-console
+                console.error(tsResult.stderr);
+            }
+        }
+        // Clean up temp file if created
+        if (tempConfigPath && existsSync(tempConfigPath)) {
+            try {
+                unlinkSync(tempConfigPath);
+                if (debug) {
+                    log(`Removed temporary ESLint config at ${tempConfigPath}`, 'info', quiet);
+                }
+            } catch (error) {
+                // Ignore errors when cleaning up
+                if (debug) {
+                    log(`Failed to remove temporary ESLint config: ${error.message}`, 'warn', quiet);
+                }
+            }
+        }
+        const eslintNotFound = jsResult.stderr?.includes('command not found') || jsResult.stderr?.includes('eslint: command not found');
+        if (eslintNotFound) {
+            spinner.fail('ESLint not found!');
+            log(`\n${cliName} Error: Lex's ESLint binary not found. Please reinstall Lex or check your installation.`, 'error', quiet);
+            return 1;
+        }
+        if (jsResult.exitCode === 0 && tsResult.exitCode === 0) {
+            spinner.succeed('Linting completed!');
+            return 0;
+        }
+        const noFilesFound = (jsResult.stderr?.includes('No such file or directory') || jsResult.stdout?.includes('No such file or directory')) && (!useTypescript || tsResult.stderr?.includes('No such file or directory') || tsResult.stdout?.includes('No such file or directory'));
+        if (noFilesFound) {
+            spinner.succeed('No files found to lint');
+            return 0;
+        }
+        spinner.fail('Linting failed!');
+        log(`\n${cliName} Error: ESLint found issues in your code.`, 'error', quiet);
+        return 1;
+    } catch (error) {
+        spinner.fail('Linting failed!');
+        log(`\n${cliName} Error: ${error.message}`, 'error', quiet);
+        return 1;
     }
-    spinner.fail("Linting failed!");
-    log(`
-${cliName} Error: ESLint found issues in your code.`, "error", quiet);
-    return 1;
-  } catch (error) {
-    spinner.fail("Linting failed!");
-    log(`
-${cliName} Error: ${error.message}`, "error", quiet);
-    return 1;
-  }
 };
-const applyAIFix = async (cwd, errors, quiet) => {
-  const spinner = createSpinner(quiet);
-  spinner.start("Using AI to fix remaining lint issues...");
-  try {
-    const fileErrorMap = /* @__PURE__ */ new Map();
-    const lines = errors.split("\n");
-    let currentFile = "";
-    for (const line of lines) {
-      if (line.match(/^(\/|[A-Z]:\\).*?\.(js|jsx|ts|tsx)$/)) {
-        currentFile = line.trim();
-        if (!fileErrorMap.has(currentFile)) {
-          fileErrorMap.set(currentFile, []);
-        }
-      } else if (currentFile && line.trim() && line.match(/\s+\d+:\d+\s+(error|warning)\s+/)) {
-        const errorArray = fileErrorMap.get(currentFile);
-        if (errorArray) {
-          errorArray.push(line.trim());
-        }
-      }
-    }
-    if (fileErrorMap.size === 0) {
-      log("Using alternative error parsing strategy", "info", quiet);
-      const sections = errors.split("\n\n");
-      for (const section of sections) {
-        if (section.trim() === "") {
-          continue;
-        }
-        const lines2 = section.split("\n");
-        const filePath = lines2[0].trim();
-        if (filePath.match(/\.(js|jsx|ts|tsx)$/)) {
-          fileErrorMap.set(filePath, []);
-          for (let i = 1; i < lines2.length; i++) {
-            if (lines2[i].trim() !== "") {
-              fileErrorMap.get(filePath)?.push(lines2[i].trim());
-            }
-          }
-        }
-      }
-    }
-    if (fileErrorMap.size === 0) {
-      log("Using direct file path extraction", "info", quiet);
-      const filePathRegex = /(?:\/|[A-Z]:\\)(?:[^:\n]+\/)*[^:\n]+\.(js|jsx|ts|tsx)/g;
-      const filePaths = errors.match(filePathRegex) || [];
-      for (const filePath of filePaths) {
-        if (!fileErrorMap.has(filePath) && existsSync(filePath)) {
-          fileErrorMap.set(filePath, []);
-        }
-      }
-      const knownFiles = [
-        pathResolve(cwd, "src/create/changelog.ts"),
-        pathResolve(cwd, "src/utils/aiService.ts"),
-        pathResolve(cwd, "src/utils/app.ts"),
-        pathResolve(cwd, "src/utils/reactShim.ts"),
-        pathResolve(cwd, "src/commands/lint/autofix.js")
-      ];
-      for (const file of knownFiles) {
-        if (existsSync(file) && !fileErrorMap.has(file)) {
-          fileErrorMap.set(file, []);
-        }
-      }
-    }
-    for (const filePath of fileErrorMap.keys()) {
-      if (!existsSync(filePath)) {
-        log(`File not found: ${filePath}`, "warn", quiet);
-        continue;
-      }
-      log(`Processing file: ${filePath}`, "info", quiet);
-      const isCursorIDE = LexConfig.config.ai?.provider === "cursor" || process.env.CURSOR_IDE === "true";
-      if (isCursorIDE) {
-        try {
-          const prompt = `Fix all ESLint errors in this file. Focus on:
+const applyAIFix = async (cwd, errors, quiet)=>{
+    const spinner = createSpinner(quiet);
+    spinner.start('Using AI to fix remaining lint issues...');
+    try {
+        const fileErrorMap = new Map();
+        const lines = errors.split('\n');
+        let currentFile = '';
+        for (const line of lines){
+            if (line.match(/^(\/|[A-Z]:\\).*?\.(js|jsx|ts|tsx)$/)) {
+                currentFile = line.trim();
+                if (!fileErrorMap.has(currentFile)) {
+                    fileErrorMap.set(currentFile, []);
+                }
+            } else if (currentFile && line.trim() && line.match(/\s+\d+:\d+\s+(error|warning)\s+/)) {
+                const errorArray = fileErrorMap.get(currentFile);
+                if (errorArray) {
+                    errorArray.push(line.trim());
+                }
+            }
+        }
+        if (fileErrorMap.size === 0) {
+            log('Using alternative error parsing strategy', 'info', quiet);
+            const sections = errors.split('\n\n');
+            for (const section of sections){
+                if (section.trim() === '') {
+                    continue;
+                }
+                const lines = section.split('\n');
+                const filePath = lines[0].trim();
+                if (filePath.match(/\.(js|jsx|ts|tsx)$/)) {
+                    fileErrorMap.set(filePath, []);
+                    for(let i = 1; i < lines.length; i++){
+                        if (lines[i].trim() !== '') {
+                            fileErrorMap.get(filePath)?.push(lines[i].trim());
+                        }
+                    }
+                }
+            }
+        }
+        if (fileErrorMap.size === 0) {
+            log('Using direct file path extraction', 'info', quiet);
+            const filePathRegex = /(?:\/|[A-Z]:\\)(?:[^:\n]+\/)*[^:\n]+\.(js|jsx|ts|tsx)/g;
+            const filePaths = errors.match(filePathRegex) || [];
+            for (const filePath of filePaths){
+                if (!fileErrorMap.has(filePath) && existsSync(filePath)) {
+                    fileErrorMap.set(filePath, []);
+                }
+            }
+            const knownFiles = [
+                pathResolve(cwd, 'src/create/changelog.ts'),
+                pathResolve(cwd, 'src/utils/aiService.ts'),
+                pathResolve(cwd, 'src/utils/app.ts'),
+                pathResolve(cwd, 'src/utils/reactShim.ts'),
+                pathResolve(cwd, 'src/commands/lint/autofix.js')
+            ];
+            for (const file of knownFiles){
+                if (existsSync(file) && !fileErrorMap.has(file)) {
+                    fileErrorMap.set(file, []);
+                }
+            }
+        }
+        for (const filePath of fileErrorMap.keys()){
+            if (!existsSync(filePath)) {
+                log(`File not found: ${filePath}`, 'warn', quiet);
+                continue;
+            }
+            log(`Processing file: ${filePath}`, 'info', quiet);
+            const isCursorIDE = LexConfig.config.ai?.provider === 'cursor' || process.env.CURSOR_IDE === 'true';
+            if (isCursorIDE) {
+                try {
+                    const prompt = `Fix all ESLint errors in this file. Focus on:
 1. Fixing naming conventions
 2. Fixing sort-keys issues
 3. Replacing console.log with log utility
@@ -346,41 +380,47 @@ import {app, events, images, locations, messages, posts, tags, users, websocket}
 const config = {baseUrl: 'https://api.example.com', apiKey: 'value', timeout: 5000};
 
 Fix ONLY the specific ESLint errors. Return the properly formatted code.`;
-          try {
-            const promptFile = pathResolve(cwd, ".cursor_prompt_temp.txt");
-            writeFileSync(promptFile, prompt, "utf8");
-            await execa("cursor", ["edit", "--file", filePath, "--prompt-file", promptFile], {
-              cwd,
-              reject: false,
-              stdio: "pipe"
-            });
-            try {
-              unlinkSync(promptFile);
-            } catch (_error) {
-            }
-            log(`Applied Cursor AI fixes to ${filePath}`, "info", quiet);
-          } catch {
-            const wasModified = await applyDirectFixes(filePath, quiet);
-            if (wasModified) {
-              log(`Applied direct fixes to ${filePath}`, "info", quiet);
-            }
-          }
-        } catch (error) {
-          log(`Error using Cursor AI: ${error.message}`, "error", quiet);
-          await applyDirectFixes(filePath, quiet);
-        }
-      } else {
-        const wasModified = await applyDirectFixes(filePath, quiet);
-        if (wasModified) {
-          log(`Applied direct fixes to ${filePath}`, "info", quiet);
-        }
-        const fileErrors = fileErrorMap.get(filePath) || [];
-        if (fileErrors.length > 0) {
-          try {
-            const { callAIService } = await import("../../utils/aiService.js");
-            const fileContent = readFileSync(filePath, "utf8");
-            const prompt = `Fix the following ESLint errors in this code:
-${fileErrors.join("\n")}
+                    try {
+                        const promptFile = pathResolve(cwd, '.cursor_prompt_temp.txt');
+                        writeFileSync(promptFile, prompt, 'utf8');
+                        // Use Cursor CLI to fix the file
+                        await execa('cursor', [
+                            'edit',
+                            '--file',
+                            filePath,
+                            '--prompt-file',
+                            promptFile
+                        ], {
+                            cwd,
+                            reject: false,
+                            stdio: 'pipe'
+                        });
+                        try {
+                            unlinkSync(promptFile);
+                        } catch (_error) {}
+                        log(`Applied Cursor AI fixes to ${filePath}`, 'info', quiet);
+                    } catch  {
+                        const wasModified = await applyDirectFixes(filePath, quiet);
+                        if (wasModified) {
+                            log(`Applied direct fixes to ${filePath}`, 'info', quiet);
+                        }
+                    }
+                } catch (error) {
+                    log(`Error using Cursor AI: ${error.message}`, 'error', quiet);
+                    await applyDirectFixes(filePath, quiet);
+                }
+            } else {
+                const wasModified = await applyDirectFixes(filePath, quiet);
+                if (wasModified) {
+                    log(`Applied direct fixes to ${filePath}`, 'info', quiet);
+                }
+                const fileErrors = fileErrorMap.get(filePath) || [];
+                if (fileErrors.length > 0) {
+                    try {
+                        const { callAIService } = await import('../../utils/aiService.js');
+                        const fileContent = readFileSync(filePath, 'utf8');
+                        const prompt = `Fix the following ESLint errors in this code:
+${fileErrors.join('\n')}
 
 Here's the code:
 \`\`\`
@@ -476,448 +516,405 @@ const config = {baseUrl: 'https://api.example.com', apiKey: 'value', timeout: 50
 
 Fix ONLY the specific ESLint errors listed above. Review the entire file for compliance with all ESLint rules.
 Return only the properly formatted fixed code without any explanations.`;
-            const fixedContent = await callAIService(prompt, quiet);
-            if (fixedContent && fixedContent !== fileContent) {
-              writeFileSync(filePath, fixedContent, "utf8");
-              log(`Applied AI fixes to ${filePath}`, "info", quiet);
+                        const fixedContent = await callAIService(prompt, quiet);
+                        if (fixedContent && fixedContent !== fileContent) {
+                            writeFileSync(filePath, fixedContent, 'utf8');
+                            log(`Applied AI fixes to ${filePath}`, 'info', quiet);
+                        }
+                    } catch (error) {
+                        log(`Error applying AI fixes to ${filePath}: ${error.message}`, 'error', quiet);
+                    }
+                }
             }
-          } catch (error) {
-            log(`Error applying AI fixes to ${filePath}: ${error.message}`, "error", quiet);
-          }
         }
-      }
-    }
-    spinner.succeed("AI fixes applied successfully!");
-  } catch (error) {
-    spinner.fail("Failed to apply AI fixes");
-    log(`Error: ${error.message}`, "error", quiet);
-    if (!quiet) {
-      console.error(error);
+        spinner.succeed('AI fixes applied successfully!');
+    } catch (error) {
+        spinner.fail('Failed to apply AI fixes');
+        log(`Error: ${error.message}`, 'error', quiet);
+        if (!quiet) {
+            console.error(error);
+        }
     }
-  }
 };
-const applyDirectFixes = async (filePath, quiet) => {
-  let wasModified = false;
-  try {
-    const fileContent = readFileSync(filePath, "utf8");
-    let newContent = fileContent;
-    if (filePath.includes("aiService.ts")) {
-      log("Fixing issues in aiService.ts", "info", quiet);
-      newContent = newContent.replace(
-        /'Content-Type': 'application\/json',\s*'Authorization': `Bearer/g,
-        "'Authorization': `Bearer', 'Content-Type': 'application/json'"
-      );
-      newContent = newContent.replace(
-        /headers: {([^}]*)},\s*method: 'POST'/g,
-        "method: 'POST',\n      headers: {$1}"
-      );
-      newContent = newContent.replace(
-        /{role: 'system', content:/g,
-        "{content:, role: 'system',"
-      );
-      newContent = newContent.replace(
-        /{role: 'user', content:/g,
-        "{content:, role: 'user',"
-      );
-      newContent = newContent.replace(
-        /\(([^)]*?)_([a-zA-Z0-9]+)(\s*:[^)]*)\)/g,
-        "($1$2$3)"
-      );
-      newContent = newContent.replace(/console\.log\(/g, "log(");
-      if (!newContent.includes("import {log}") && newContent.includes("log(")) {
-        newContent = newContent.replace(
-          /import {([^}]*)} from '(.*)';/,
-          "import {$1} from '$2';\nimport {log} from './log.js';"
-        );
-      }
-    }
-    if (filePath.includes("reactShim.ts")) {
-      log("Fixing naming-convention issues in reactShim.ts", "info", quiet);
-      newContent = newContent.replace(
-        "import * as React from",
-        "import * as react from"
-      );
-      newContent = newContent.replace(/React\./g, "react.");
-    }
-    if (filePath.includes("changelog.ts")) {
-      log("Fixing issues in changelog.ts", "info", quiet);
-      newContent = newContent.replace(/(\w+)\+\+/g, "$1 += 1");
-      newContent = newContent.replace(/\\\$/g, "$");
-      newContent = newContent.replace(/\\\./g, ".");
-      newContent = newContent.replace(/\\\*/g, "*");
-      newContent = newContent.replace(/\\:/g, ":");
+const applyDirectFixes = async (filePath, quiet)=>{
+    let wasModified = false;
+    try {
+        const fileContent = readFileSync(filePath, 'utf8');
+        let newContent = fileContent;
+        if (filePath.includes('aiService.ts')) {
+            log('Fixing issues in aiService.ts', 'info', quiet);
+            newContent = newContent.replace(/'Content-Type': 'application\/json',\s*'Authorization': `Bearer/g, '\'Authorization\': `Bearer\', \'Content-Type\': \'application/json\'');
+            newContent = newContent.replace(/headers: {([^}]*)},\s*method: 'POST'/g, 'method: \'POST\',\n      headers: {$1}');
+            newContent = newContent.replace(/{role: 'system', content:/g, '{content:, role: \'system\',');
+            newContent = newContent.replace(/{role: 'user', content:/g, '{content:, role: \'user\',');
+            newContent = newContent.replace(/\(([^)]*?)_([a-zA-Z0-9]+)(\s*:[^)]*)\)/g, '($1$2$3)');
+            newContent = newContent.replace(/console\.log\(/g, 'log(');
+            if (!newContent.includes('import {log}') && newContent.includes('log(')) {
+                newContent = newContent.replace(/import {([^}]*)} from '(.*)';/, 'import {$1} from \'$2\';\nimport {log} from \'./log.js\';');
+            }
+        }
+        if (filePath.includes('reactShim.ts')) {
+            log('Fixing naming-convention issues in reactShim.ts', 'info', quiet);
+            newContent = newContent.replace('import * as React from', 'import * as react from');
+            newContent = newContent.replace(/React\./g, 'react.');
+        }
+        if (filePath.includes('changelog.ts')) {
+            log('Fixing issues in changelog.ts', 'info', quiet);
+            newContent = newContent.replace(/(\w+)\+\+/g, '$1 += 1');
+            newContent = newContent.replace(/\\\$/g, '$');
+            newContent = newContent.replace(/\\\./g, '.');
+            newContent = newContent.replace(/\\\*/g, '*');
+            newContent = newContent.replace(/\\:/g, ':');
+        }
+        if (filePath.includes('app.ts')) {
+            log('Fixing issues in app.ts', 'info', quiet);
+            newContent = newContent.replace(/console\.log\(/g, 'log(');
+            if (!newContent.includes('import {log}') && newContent.includes('log(')) {
+                newContent = newContent.replace(/import boxen from 'boxen';/, 'import boxen from \'boxen\';\nimport {log} from \'./log.js\';');
+            }
+            newContent = newContent.replace(/\\\//g, '/');
+        }
+        if (filePath.includes('autofix.js')) {
+            log('Fixing issues in autofix.js', 'info', quiet);
+            newContent = newContent.replace(/import {([^}]*)} from 'path';[\s\n]*import {([^}]*)} from 'path';/, 'import {$1, $2} from \'path\';');
+            newContent = newContent.replace(/__filename/g, 'currentFilename');
+            newContent = newContent.replace(/__dirname/g, 'currentDirname');
+            newContent = newContent.replace(/const prefix = type === 'error' \? '❌ ' : type === 'success' \? '✅ ' : 'ℹ️ ';/, 'let prefix = \'ℹ️ \';\nif(type === \'error\') {\n  prefix = \'❌ \';\n} else if(type === \'success\') {\n  prefix = \'✅ \';\n}');
+            newContent = newContent.replace(/async function runEslintFix\(\)/g, 'const runEslintFix = async ()');
+            newContent = newContent.replace(/async function getFilesWithErrors\(\)/g, 'const getFilesWithErrors = async ()');
+            newContent = newContent.replace(/async function isCursorAvailable\(\)/g, 'const isCursorAvailable = async ()');
+            newContent = newContent.replace(/async function fixFileWithCursorAI\(filePath\)/g, 'const fixFileWithCursorAI = async (filePath)');
+            newContent = newContent.replace(/async function main\(\)/g, 'const main = async ()');
+            newContent = newContent.replace(/import {existsSync, readFileSync, writeFileSync}/g, 'import {writeFileSync}');
+            newContent = newContent.replace(/console\.log\(`\${prefix} \${message}`\);/g, 'process.stdout.write(`${prefix} ${message}\\n`);');
+            newContent = newContent.replace(/} catch\(error\) {[\s\n]*\/\/ Ignore cleanup errors/g, '} catch(_) {\n      // Ignore cleanup errors');
+            newContent = newContent.replace(/} catch\(error\) {[\s\n]*log\(/g, '} catch(err) {\n    log(');
+            newContent = newContent.replace(/} catch\(error\) {[\s\n]*return false;/g, '} catch(_) {\n    return false;');
+            newContent = newContent.replace(/for\(const filePath of filesWithErrors\) {[\s\n]*const success = await fixFileWithCursorAI\(filePath\);/g, 'const fixResults = await Promise.all(filesWithErrors.map(filePath => fixFileWithCursorAI(filePath)));\nfor(const success of fixResults) {');
+            newContent = newContent.replace(/fixedCount\+\+;/g, 'fixedCount += 1;');
+        }
+        if (newContent !== fileContent) {
+            writeFileSync(filePath, newContent, 'utf8');
+            log(`Fixed issues in ${filePath}`, 'info', quiet);
+            wasModified = true;
+        }
+        return wasModified;
+    } catch (error) {
+        log(`Error applying direct fixes to ${filePath}: ${error.message}`, 'error', quiet);
+        return false;
     }
-    if (filePath.includes("app.ts")) {
-      log("Fixing issues in app.ts", "info", quiet);
-      newContent = newContent.replace(/console\.log\(/g, "log(");
-      if (!newContent.includes("import {log}") && newContent.includes("log(")) {
-        newContent = newContent.replace(
-          /import boxen from 'boxen';/,
-          "import boxen from 'boxen';\nimport {log} from './log.js';"
-        );
-      }
-      newContent = newContent.replace(/\\\//g, "/");
+};
+const loadAIConfig = async (cwd, quiet, debug = false)=>{
+    const configFormats = [
+        'js',
+        'mjs',
+        'cjs',
+        'ts',
+        'json'
+    ];
+    const configBaseName = 'lex.config';
+    let lexConfigPath = '';
+    for (const format of configFormats){
+        const potentialPath = pathResolve(cwd, `./${configBaseName}.${format}`);
+        if (existsSync(potentialPath)) {
+            lexConfigPath = potentialPath;
+            break;
+        }
     }
-    if (filePath.includes("autofix.js")) {
-      log("Fixing issues in autofix.js", "info", quiet);
-      newContent = newContent.replace(
-        /import {([^}]*)} from 'path';[\s\n]*import {([^}]*)} from 'path';/,
-        "import {$1, $2} from 'path';"
-      );
-      newContent = newContent.replace(
-        /__filename/g,
-        "currentFilename"
-      );
-      newContent = newContent.replace(
-        /__dirname/g,
-        "currentDirname"
-      );
-      newContent = newContent.replace(
-        /const prefix = type === 'error' \? '❌ ' : type === 'success' \? '✅ ' : 'ℹ️ ';/,
-        "let prefix = '\u2139\uFE0F ';\nif(type === 'error') {\n  prefix = '\u274C ';\n} else if(type === 'success') {\n  prefix = '\u2705 ';\n}"
-      );
-      newContent = newContent.replace(
-        /async function runEslintFix\(\)/g,
-        "const runEslintFix = async ()"
-      );
-      newContent = newContent.replace(
-        /async function getFilesWithErrors\(\)/g,
-        "const getFilesWithErrors = async ()"
-      );
-      newContent = newContent.replace(
-        /async function isCursorAvailable\(\)/g,
-        "const isCursorAvailable = async ()"
-      );
-      newContent = newContent.replace(
-        /async function fixFileWithCursorAI\(filePath\)/g,
-        "const fixFileWithCursorAI = async (filePath)"
-      );
-      newContent = newContent.replace(
-        /async function main\(\)/g,
-        "const main = async ()"
-      );
-      newContent = newContent.replace(
-        /import {existsSync, readFileSync, writeFileSync}/g,
-        "import {writeFileSync}"
-      );
-      newContent = newContent.replace(
-        /console\.log\(`\${prefix} \${message}`\);/g,
-        "process.stdout.write(`${prefix} ${message}\\n`);"
-      );
-      newContent = newContent.replace(
-        /} catch\(error\) {[\s\n]*\/\/ Ignore cleanup errors/g,
-        "} catch(_) {\n      // Ignore cleanup errors"
-      );
-      newContent = newContent.replace(
-        /} catch\(error\) {[\s\n]*log\(/g,
-        "} catch(err) {\n    log("
-      );
-      newContent = newContent.replace(
-        /} catch\(error\) {[\s\n]*return false;/g,
-        "} catch(_) {\n    return false;"
-      );
-      newContent = newContent.replace(
-        /for\(const filePath of filesWithErrors\) {[\s\n]*const success = await fixFileWithCursorAI\(filePath\);/g,
-        "const fixResults = await Promise.all(filesWithErrors.map(filePath => fixFileWithCursorAI(filePath)));\nfor(const success of fixResults) {"
-      );
-      newContent = newContent.replace(
-        /fixedCount\+\+;/g,
-        "fixedCount += 1;"
-      );
+    if (lexConfigPath) {
+        try {
+            // For MJS files, we need to use dynamic import with URL for compatibility
+            const format = extname(lexConfigPath).slice(1);
+            let importPath = lexConfigPath;
+            // Use URL protocol for ESM imports
+            if (format === 'mjs') {
+                try {
+                    const url = new URL(`file://${lexConfigPath}`);
+                    importPath = url.href;
+                    if (debug) {
+                        log(`Using URL format for MJS import: ${importPath}`, 'info', quiet);
+                    }
+                } catch (urlError) {
+                    log(`Error creating URL for MJS import: ${urlError.message}`, 'warn', debug || !quiet);
+                    importPath = `file://${lexConfigPath}`;
+                }
+            }
+            if (debug) {
+                log(`Trying to import config from ${importPath} (format: ${format})`, 'info', quiet);
+            }
+            let lexConfig;
+            try {
+                lexConfig = await import(importPath);
+            } catch (importError) {
+                if (importError.message.includes('not defined in ES module scope')) {
+                    log(`ES Module syntax error in ${lexConfigPath}. Make sure you're using 'export' instead of 'module.exports'.`, 'error', quiet);
+                    if (debug) {
+                        console.error(importError);
+                    }
+                    return;
+                }
+                throw importError;
+            }
+            // Handle both ESM (default export) and CommonJS (module.exports)
+            let configData = null;
+            if (lexConfig.default) {
+                configData = lexConfig.default;
+                if (debug) {
+                    log(`Found default export in ${lexConfigPath}`, 'info', quiet);
+                }
+            } else {
+                // For CommonJS or other module systems
+                configData = lexConfig;
+                if (debug) {
+                    log(`Using direct export in ${lexConfigPath}`, 'info', quiet);
+                }
+            }
+            if (configData && configData.ai) {
+                log(`Found AI configuration in ${pathResolve(cwd, lexConfigPath)}, applying settings...`, 'info', quiet);
+                LexConfig.config.ai = {
+                    ...LexConfig.config.ai,
+                    ...configData.ai
+                };
+            }
+        } catch (error) {
+            log(`Error loading AI configuration from ${lexConfigPath}: ${error.message}`, 'warn', quiet);
+            if (debug) {
+                console.error(error);
+            }
+        }
     }
-    if (newContent !== fileContent) {
-      writeFileSync(filePath, newContent, "utf8");
-      log(`Fixed issues in ${filePath}`, "info", quiet);
-      wasModified = true;
+};
+/**
+ * Load ESLint configuration from lex.config.* files
+ */ const loadESLintConfig = async (cwd, quiet, debug)=>{
+    // Check if LexConfig already has ESLint configuration loaded
+    if (LexConfig.config.eslint && Object.keys(LexConfig.config.eslint).length > 0) {
+        log('Found ESLint configuration in lex.config.* file', 'info', debug || !quiet);
+        return true;
+    }
+    // Try to load from lex.config.* files if not already loaded
+    const configFormats = [
+        'js',
+        'mjs',
+        'cjs',
+        'ts',
+        'json'
+    ];
+    const configBaseName = 'lex.config';
+    for (const format of configFormats){
+        const potentialPath = pathResolve(cwd, `./${configBaseName}.${format}`);
+        if (existsSync(potentialPath)) {
+            try {
+                // For MJS files, we need to use dynamic import with URL for compatibility
+                const fileFormat = extname(potentialPath).slice(1);
+                let importPath = potentialPath;
+                // Use URL protocol for ESM imports
+                if (fileFormat === 'mjs') {
+                    try {
+                        const url = new URL(`file://${potentialPath}`);
+                        importPath = url.href;
+                        if (debug) {
+                            log(`Using URL format for MJS import: ${importPath}`, 'info', quiet);
+                        }
+                    } catch (urlError) {
+                        log(`Error creating URL for MJS import: ${urlError.message}`, 'warn', debug || !quiet);
+                        importPath = `file://${potentialPath}`;
+                    }
+                }
+                if (debug) {
+                    log(`Trying to import config from ${importPath} (format: ${fileFormat})`, 'info', quiet);
+                }
+                let lexConfig;
+                try {
+                    lexConfig = await import(importPath);
+                } catch (importError) {
+                    if (importError.message.includes('not defined in ES module scope')) {
+                        log(`ES Module syntax error in ${potentialPath}. Make sure you're using 'export' instead of 'module.exports'.`, 'error', quiet);
+                        if (debug) {
+                            console.error(importError);
+                        }
+                        continue;
+                    }
+                    throw importError;
+                }
+                // Handle both ESM (default export) and CommonJS (module.exports)
+                let configData = null;
+                if (lexConfig.default) {
+                    configData = lexConfig.default;
+                    if (debug) {
+                        log(`Found default export in ${potentialPath}`, 'info', quiet);
+                    }
+                } else {
+                    // For CommonJS or other module systems
+                    configData = lexConfig;
+                    if (debug) {
+                        log(`Using direct export in ${potentialPath}`, 'info', quiet);
+                    }
+                }
+                if (configData && configData.eslint && Object.keys(configData.eslint).length > 0) {
+                    log(`Found ESLint configuration in ${pathResolve(cwd, potentialPath)}, applying settings...`, 'info', debug || !quiet);
+                    LexConfig.config.eslint = {
+                        ...LexConfig.config.eslint,
+                        ...configData.eslint
+                    };
+                    return true;
+                }
+            } catch (error) {
+                log(`Error loading ESLint configuration from ${potentialPath}: ${error.message}`, 'warn', quiet);
+                if (debug) {
+                    console.error(error);
+                }
+            }
+        }
     }
-    return wasModified;
-  } catch (error) {
-    log(`Error applying direct fixes to ${filePath}: ${error.message}`, "error", quiet);
     return false;
-  }
 };
-const loadAIConfig = async (cwd, quiet, debug = false) => {
-  const configFormats = ["js", "mjs", "cjs", "ts", "json"];
-  const configBaseName = "lex.config";
-  let lexConfigPath = "";
-  for (const format of configFormats) {
-    const potentialPath = pathResolve(cwd, `./${configBaseName}.${format}`);
-    if (existsSync(potentialPath)) {
-      lexConfigPath = potentialPath;
-      break;
-    }
-  }
-  if (lexConfigPath) {
+const removeFileComments = (filePath, quiet)=>{
     try {
-      const format = extname(lexConfigPath).slice(1);
-      let importPath = lexConfigPath;
-      if (format === "mjs") {
-        try {
-          const url = new URL(`file://${lexConfigPath}`);
-          importPath = url.href;
-          if (debug) {
-            log(`Using URL format for MJS import: ${importPath}`, "info", quiet);
-          }
-        } catch (urlError) {
-          log(`Error creating URL for MJS import: ${urlError.message}`, "warn", debug || !quiet);
-          importPath = `file://${lexConfigPath}`;
-        }
-      }
-      if (debug) {
-        log(`Trying to import config from ${importPath} (format: ${format})`, "info", quiet);
-      }
-      let lexConfig;
-      try {
-        lexConfig = await import(importPath);
-      } catch (importError) {
-        if (importError.message.includes("not defined in ES module scope")) {
-          log(`ES Module syntax error in ${lexConfigPath}. Make sure you're using 'export' instead of 'module.exports'.`, "error", quiet);
-          if (debug) {
-            console.error(importError);
-          }
-          return;
-        }
-        throw importError;
-      }
-      let configData = null;
-      if (lexConfig.default) {
-        configData = lexConfig.default;
-        if (debug) {
-          log(`Found default export in ${lexConfigPath}`, "info", quiet);
-        }
-      } else {
-        configData = lexConfig;
-        if (debug) {
-          log(`Using direct export in ${lexConfigPath}`, "info", quiet);
-        }
-      }
-      if (configData && configData.ai) {
-        log(`Found AI configuration in ${pathResolve(cwd, lexConfigPath)}, applying settings...`, "info", quiet);
-        LexConfig.config.ai = { ...LexConfig.config.ai, ...configData.ai };
-      }
+        const fileContent = readFileSync(filePath, 'utf8');
+        if (fileContent.length > 1000000) {
+            log(`Skipping comment removal for large file: ${filePath}`, 'info', quiet);
+            return false;
+        }
+        // Use regex to match different types of comments
+        // Preserves:
+        // 1. Copyright notices (/* Copyright ... */)
+        // 2. TODO comments (// TODO: ...)
+        // 3. License headers (/* ... License ... */)
+        // Handle multi-line comments first - preserve copyright/license notices
+        let newContent = fileContent.replace(/\/\*[\s\S]*?\*\//g, (match)=>{
+            if (match.includes('Copyright') || match.includes('LICENSE') || match.includes('License') || match.includes('license')) {
+                return match;
+            }
+            return '';
+        });
+        // Handle single-line comments - preserve TODOs
+        newContent = newContent.replace(/\/\/.*$/gm, (match)=>{
+            if (match.includes('TODO') || match.includes('FIXME')) {
+                return match;
+            }
+            return '';
+        });
+        // Clean up any multiple blank lines created by comment removal
+        newContent = newContent.replace(/\n\s*\n\s*\n/g, '\n\n');
+        // If the file was modified, save it
+        if (newContent !== fileContent) {
+            writeFileSync(filePath, newContent, 'utf8');
+            log(`Removed comments from ${filePath}`, 'info', quiet);
+            return true;
+        }
+        return false;
     } catch (error) {
-      log(`Error loading AI configuration from ${lexConfigPath}: ${error.message}`, "warn", quiet);
-      if (debug) {
-        console.error(error);
-      }
+        log(`Error removing comments from ${filePath}: ${error.message}`, 'error', quiet);
+        return false;
     }
-  }
 };
-const loadESLintConfig = async (cwd, quiet, debug) => {
-  if (LexConfig.config.eslint && Object.keys(LexConfig.config.eslint).length > 0) {
-    log("Found ESLint configuration in lex.config.* file", "info", debug || !quiet);
-    return true;
-  }
-  const configFormats = ["js", "mjs", "cjs", "ts", "json"];
-  const configBaseName = "lex.config";
-  for (const format of configFormats) {
-    const potentialPath = pathResolve(cwd, `./${configBaseName}.${format}`);
-    if (existsSync(potentialPath)) {
-      try {
-        const fileFormat = extname(potentialPath).slice(1);
-        let importPath = potentialPath;
-        if (fileFormat === "mjs") {
-          try {
-            const url = new URL(`file://${potentialPath}`);
-            importPath = url.href;
+export const lint = async (cmd, callback = process.exit)=>{
+    const { cliName = 'Lex', fix = false, debug = false, quiet = false, config = null, removeComments = false, 'remove-comments': removeCommentsFlag = false } = cmd;
+    const shouldRemoveComments = removeComments || removeCommentsFlag;
+    log(`${cliName} linting...`, 'info', quiet);
+    const cwd = process.cwd();
+    const spinner = createSpinner(quiet);
+    await loadAIConfig(cwd, quiet, debug);
+    let tempConfigPath = null;
+    try {
+        const useTypescript = detectTypeScript(cwd);
+        log(`TypeScript ${useTypescript ? 'detected' : 'not detected'} from tsconfig.json`, 'info', quiet);
+        if (useTypescript) {
+            LexConfig.checkLintTypescriptConfig();
+        }
+        ensureModuleType(cwd);
+        await installDependencies(cwd, useTypescript, quiet);
+        const projectConfigPath = pathResolve(cwd, 'eslint.config.mjs');
+        const projectConfigPathTs = pathResolve(cwd, 'eslint.config.ts');
+        const hasEslintConfig = existsSync(projectConfigPath) || existsSync(projectConfigPathTs) || existsSync(pathResolve(cwd, '.eslintrc.js')) || existsSync(pathResolve(cwd, '.eslintrc.json')) || existsSync(pathResolve(cwd, '.eslintrc.yml')) || existsSync(pathResolve(cwd, '.eslintrc.yaml')) || existsSync(pathResolve(cwd, '.eslintrc'));
+        const hasLexEslintConfig = await loadESLintConfig(cwd, quiet, debug);
+        if (hasLexEslintConfig) {
+            log('Using ESLint configuration from lex.config.* file', 'info', quiet);
+        }
+        if (existsSync(pathResolve(cwd, '.eslintrc.json'))) {
+            unlinkSync(pathResolve(cwd, '.eslintrc.json'));
+        }
+        let lexConfigPath = '';
+        let shouldCreateTempConfig = false;
+        if (!hasEslintConfig && !hasLexEslintConfig) {
+            const possiblePaths = [
+                pathResolve(currentDirname, '../../../../eslint.config.ts'),
+                pathResolve(currentDirname, '../../../../eslint.config.jms'),
+                pathResolve(process.env.LEX_HOME || './node_modules/@nlabs/lex', 'eslint.config.ts'),
+                pathResolve(process.env.LEX_HOME || './node_modules/@nlabs/lex', 'eslint.config.mjs')
+            ];
+            for (const path of possiblePaths){
+                if (existsSync(path)) {
+                    lexConfigPath = path;
+                    break;
+                }
+            }
             if (debug) {
-              log(`Using URL format for MJS import: ${importPath}`, "info", quiet);
+                log(`Current directory: ${currentDirname}`, 'info', quiet);
+                log(`Project config path: ${projectConfigPath}`, 'info', quiet);
+                log(`Project config exists: ${hasEslintConfig}`, 'info', quiet);
+                log(`Found Lex config: ${lexConfigPath}`, 'info', quiet);
+                log(`Lex config exists: ${!!lexConfigPath && existsSync(lexConfigPath)}`, 'info', quiet);
+            }
+            if (lexConfigPath && existsSync(lexConfigPath)) {
+                log('No ESLint configuration found in project. Using Lex\'s default configuration.', 'info', quiet);
+            } else {
+                shouldCreateTempConfig = true;
             }
-          } catch (urlError) {
-            log(`Error creating URL for MJS import: ${urlError.message}`, "warn", debug || !quiet);
-            importPath = `file://${potentialPath}`;
-          }
         }
-        if (debug) {
-          log(`Trying to import config from ${importPath} (format: ${fileFormat})`, "info", quiet);
+        if (config) {
+            const userConfigPath = pathResolve(cwd, config);
+            if (existsSync(userConfigPath)) {
+                log(`Using specified ESLint configuration: ${config}`, 'info', quiet);
+                shouldCreateTempConfig = false;
+            } else {
+                log(`Specified ESLint configuration not found: ${config}. Using Lex's default configuration.`, 'warn', quiet);
+            }
         }
-        let lexConfig;
-        try {
-          lexConfig = await import(importPath);
-        } catch (importError) {
-          if (importError.message.includes("not defined in ES module scope")) {
-            log(`ES Module syntax error in ${potentialPath}. Make sure you're using 'export' instead of 'module.exports'.`, "error", quiet);
-            if (debug) {
-              console.error(importError);
-            }
-            continue;
-          }
-          throw importError;
-        }
-        let configData = null;
-        if (lexConfig.default) {
-          configData = lexConfig.default;
-          if (debug) {
-            log(`Found default export in ${potentialPath}`, "info", quiet);
-          }
-        } else {
-          configData = lexConfig;
-          if (debug) {
-            log(`Using direct export in ${potentialPath}`, "info", quiet);
-          }
-        }
-        if (configData && configData.eslint && Object.keys(configData.eslint).length > 0) {
-          log(`Found ESLint configuration in ${pathResolve(cwd, potentialPath)}, applying settings...`, "info", debug || !quiet);
-          LexConfig.config.eslint = { ...LexConfig.config.eslint, ...configData.eslint };
-          return true;
-        }
-      } catch (error) {
-        log(`Error loading ESLint configuration from ${potentialPath}: ${error.message}`, "warn", quiet);
-        if (debug) {
-          console.error(error);
-        }
-      }
-    }
-  }
-  return false;
-};
-const removeFileComments = (filePath, quiet) => {
-  try {
-    const fileContent = readFileSync(filePath, "utf8");
-    if (fileContent.length > 1e6) {
-      log(`Skipping comment removal for large file: ${filePath}`, "info", quiet);
-      return false;
-    }
-    let newContent = fileContent.replace(
-      /\/\*[\s\S]*?\*\//g,
-      (match) => {
-        if (match.includes("Copyright") || match.includes("LICENSE") || match.includes("License") || match.includes("license")) {
-          return match;
-        }
-        return "";
-      }
-    );
-    newContent = newContent.replace(
-      /\/\/.*$/gm,
-      (match) => {
-        if (match.includes("TODO") || match.includes("FIXME")) {
-          return match;
-        }
-        return "";
-      }
-    );
-    newContent = newContent.replace(/\n\s*\n\s*\n/g, "\n\n");
-    if (newContent !== fileContent) {
-      writeFileSync(filePath, newContent, "utf8");
-      log(`Removed comments from ${filePath}`, "info", quiet);
-      return true;
-    }
-    return false;
-  } catch (error) {
-    log(`Error removing comments from ${filePath}: ${error.message}`, "error", quiet);
-    return false;
-  }
-};
-const lint = async (cmd, callback = process.exit) => {
-  const {
-    cliName = "Lex",
-    fix = false,
-    debug = false,
-    quiet = false,
-    config = null,
-    removeComments = false,
-    "remove-comments": removeCommentsFlag = false
-  } = cmd;
-  const shouldRemoveComments = removeComments || removeCommentsFlag;
-  log(`${cliName} linting...`, "info", quiet);
-  const cwd = process.cwd();
-  const spinner = createSpinner(quiet);
-  await loadAIConfig(cwd, quiet, debug);
-  let tempConfigPath = null;
-  try {
-    const useTypescript = detectTypeScript(cwd);
-    log(`TypeScript ${useTypescript ? "detected" : "not detected"} from tsconfig.json`, "info", quiet);
-    if (useTypescript) {
-      LexConfig.checkLintTypescriptConfig();
-    }
-    ensureModuleType(cwd);
-    await installDependencies(cwd, useTypescript, quiet);
-    const projectConfigPath = pathResolve(cwd, "eslint.config.mjs");
-    const projectConfigPathTs = pathResolve(cwd, "eslint.config.ts");
-    const hasEslintConfig = existsSync(projectConfigPath) || existsSync(projectConfigPathTs) || existsSync(pathResolve(cwd, ".eslintrc.js")) || existsSync(pathResolve(cwd, ".eslintrc.json")) || existsSync(pathResolve(cwd, ".eslintrc.yml")) || existsSync(pathResolve(cwd, ".eslintrc.yaml")) || existsSync(pathResolve(cwd, ".eslintrc"));
-    const hasLexEslintConfig = await loadESLintConfig(cwd, quiet, debug);
-    if (hasLexEslintConfig) {
-      log("Using ESLint configuration from lex.config.* file", "info", quiet);
-    }
-    if (existsSync(pathResolve(cwd, ".eslintrc.json"))) {
-      unlinkSync(pathResolve(cwd, ".eslintrc.json"));
-    }
-    let lexConfigPath = "";
-    let shouldCreateTempConfig = false;
-    if (!hasEslintConfig && !hasLexEslintConfig) {
-      const possiblePaths = [
-        pathResolve(currentDirname, "../../../../eslint.config.ts"),
-        pathResolve(currentDirname, "../../../../eslint.config.jms"),
-        pathResolve(process.env.LEX_HOME || "./node_modules/@nlabs/lex", "eslint.config.ts"),
-        pathResolve(process.env.LEX_HOME || "./node_modules/@nlabs/lex", "eslint.config.mjs")
-      ];
-      for (const path of possiblePaths) {
-        if (existsSync(path)) {
-          lexConfigPath = path;
-          break;
-        }
-      }
-      if (debug) {
-        log(`Current directory: ${currentDirname}`, "info", quiet);
-        log(`Project config path: ${projectConfigPath}`, "info", quiet);
-        log(`Project config exists: ${hasEslintConfig}`, "info", quiet);
-        log(`Found Lex config: ${lexConfigPath}`, "info", quiet);
-        log(`Lex config exists: ${!!lexConfigPath && existsSync(lexConfigPath)}`, "info", quiet);
-      }
-      if (lexConfigPath && existsSync(lexConfigPath)) {
-        log("No ESLint configuration found in project. Using Lex's default configuration.", "info", quiet);
-      } else {
-        shouldCreateTempConfig = true;
-      }
-    }
-    if (config) {
-      const userConfigPath = pathResolve(cwd, config);
-      if (existsSync(userConfigPath)) {
-        log(`Using specified ESLint configuration: ${config}`, "info", quiet);
-        shouldCreateTempConfig = false;
-      } else {
-        log(`Specified ESLint configuration not found: ${config}. Using Lex's default configuration.`, "warn", quiet);
-      }
-    }
-    if (shouldCreateTempConfig) {
-      log("No ESLint configuration found. Creating a temporary configuration...", "info", quiet);
-      const configResult = createDefaultESLintConfig(useTypescript, cwd);
-      tempConfigPath = configResult.configPath;
-    }
-    let eslintOutput = "";
-    const captureOutput = (output) => {
-      eslintOutput += `${output}
-`;
-    };
-    const result = await runEslintWithLex(cwd, quiet, cliName, true, debug, useTypescript, captureOutput);
-    if (shouldRemoveComments) {
-      spinner.start("Removing comments from files...");
-      const glob = await import("glob");
-      const files = glob.sync("{src,lib}/**/*.{js,jsx,ts,tsx}", {
-        cwd,
-        ignore: ["**/node_modules/**", "**/lib/**", "**/dist/**", "**/build/**"]
-      });
-      let processedCount = 0;
-      for (const file of files) {
-        const filePath = pathResolve(cwd, file);
-        if (removeFileComments(filePath, quiet)) {
-          processedCount++;
-        }
-      }
-      spinner.succeed(`Removed comments from ${processedCount} files`);
-    }
-    if (result !== 0 && fix) {
-      const aiConfigured = LexConfig.config.ai?.provider && LexConfig.config.ai.provider !== "none";
-      if (aiConfigured) {
-        log("Applying AI fixes to remaining issues...", "info", quiet);
-        await applyAIFix(cwd, eslintOutput, quiet);
-        const afterFixResult = await runEslintWithLex(cwd, quiet, cliName, false, debug, useTypescript);
-        callback(afterFixResult);
-        return afterFixResult;
-      }
-      log("ESLint could not fix all issues automatically.", "warn", quiet);
-      log("To enable AI-powered fixes, add AI configuration to your lex.config file:", "info", quiet);
-      log(`
+        if (shouldCreateTempConfig) {
+            log('No ESLint configuration found. Creating a temporary configuration...', 'info', quiet);
+            const configResult = createDefaultESLintConfig(useTypescript, cwd);
+            tempConfigPath = configResult.configPath;
+        }
+        let eslintOutput = '';
+        const captureOutput = (output)=>{
+            eslintOutput += `${output}\n`;
+        };
+        const result = await runEslintWithLex(cwd, quiet, cliName, true, debug, useTypescript, captureOutput);
+        if (shouldRemoveComments) {
+            spinner.start('Removing comments from files...');
+            const glob = await import('glob');
+            const files = glob.sync('{src,lib}/**/*.{js,jsx,ts,tsx}', {
+                cwd,
+                ignore: [
+                    '**/node_modules/**',
+                    '**/lib/**',
+                    '**/dist/**',
+                    '**/build/**'
+                ]
+            });
+            let processedCount = 0;
+            for (const file of files){
+                const filePath = pathResolve(cwd, file);
+                if (removeFileComments(filePath, quiet)) {
+                    processedCount++;
+                }
+            }
+            spinner.succeed(`Removed comments from ${processedCount} files`);
+        }
+        if (result !== 0 && fix) {
+            const aiConfigured = LexConfig.config.ai?.provider && LexConfig.config.ai.provider !== 'none';
+            if (aiConfigured) {
+                log('Applying AI fixes to remaining issues...', 'info', quiet);
+                await applyAIFix(cwd, eslintOutput, quiet);
+                const afterFixResult = await runEslintWithLex(cwd, quiet, cliName, false, debug, useTypescript);
+                callback(afterFixResult);
+                return afterFixResult;
+            }
+            log('ESLint could not fix all issues automatically.', 'warn', quiet);
+            log('To enable AI-powered fixes, add AI configuration to your lex.config file:', 'info', quiet);
+            log(`
 // In lex.config.js (or lex.config.mjs, lex.config.cjs, etc.)
 export default {
   // Your existing config
@@ -925,38 +922,34 @@ export default {
     provider: 'cursor' // or 'openai', 'anthropic', etc.
     // Additional provider-specific settings
   }
-};`, "info", quiet);
-    }
-    callback(result);
-    return result;
-  } catch (error) {
-    log(`
-${cliName} Error: ${error.message}`, "error", quiet);
-    if (spinner) {
-      spinner.fail("Linting failed!");
-    }
-    callback(1);
-    return 1;
-  } finally {
-    const tempFilePaths = [
-      tempConfigPath,
-      pathResolve(cwd, ".lex-temp-eslint.cjs"),
-      pathResolve(cwd, ".lex-temp-default-eslint.cjs")
-    ];
-    for (const filePath of tempFilePaths) {
-      if (filePath && existsSync(filePath)) {
-        try {
-          unlinkSync(filePath);
-          if (debug) {
-            log(`Cleaned up temporary ESLint config at ${filePath}`, "info", quiet);
-          }
-        } catch {
+};`, 'info', quiet);
+        }
+        callback(result);
+        return result;
+    } catch (error) {
+        log(`\n${cliName} Error: ${error.message}`, 'error', quiet);
+        if (spinner) {
+            spinner.fail('Linting failed!');
+        }
+        callback(1);
+        return 1;
+    } finally{
+        const tempFilePaths = [
+            tempConfigPath,
+            pathResolve(cwd, '.lex-temp-eslint.cjs'),
+            pathResolve(cwd, '.lex-temp-default-eslint.cjs')
+        ];
+        for (const filePath of tempFilePaths){
+            if (filePath && existsSync(filePath)) {
+                try {
+                    unlinkSync(filePath);
+                    if (debug) {
+                        log(`Cleaned up temporary ESLint config at ${filePath}`, 'info', quiet);
+                    }
+                } catch  {}
+            }
         }
-      }
     }
-  }
 };
-export {
-  lint
-};
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/commands/lint/lint.ts"],
  "sourcesContent": ["/**\n * Copyright (c) 2022-Present, Nitrogen Labs, Inc.\n * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.\n */\nimport {execa} from 'execa';\nimport {existsSync, readFileSync, unlinkSync, writeFileSync} from 'fs';\nimport {dirname, resolve as pathResolve, extname} from 'path';\n\nimport {LexConfig} from '../../LexConfig.js';\nimport {createSpinner} from '../../utils/app.js';\nimport {resolveBinaryPath} from '../../utils/file.js';\nimport {log} from '../../utils/log.js';\n\nlet currentFilename: string;\nlet currentDirname: string;\n\ntry {\n  currentFilename = eval('require(\"url\").fileURLToPath(import.meta.url)');\n  currentDirname = dirname(currentFilename);\n} catch {\n  currentFilename = process.cwd();\n  currentDirname = process.cwd();\n}\n\nexport interface LintOptions {\n  readonly cache?: boolean;\n  readonly cacheFile?: string;\n  readonly cacheLocation?: string;\n  readonly cliName?: string;\n  readonly color?: boolean;\n  readonly config?: string;\n  readonly debug?: boolean;\n  readonly env?: string;\n  readonly envInfo?: boolean;\n  readonly ext?: string;\n  readonly fix?: boolean;\n  readonly fixDryRun?: boolean;\n  readonly fixType?: string;\n  readonly format?: string;\n  readonly global?: string;\n  readonly ignorePath?: string;\n  readonly ignorePattern?: string;\n  readonly init?: boolean;\n  readonly maxWarnings?: string;\n  readonly noColor?: boolean;\n  readonly noEslintrc?: boolean;\n  readonly noIgnore?: boolean;\n  readonly noInlineConfig?: boolean;\n  readonly outputFile?: string;\n  readonly parser?: string;\n  readonly parserOptions?: string;\n  readonly plugin?: string;\n  readonly printConfig?: string;\n  readonly quiet?: boolean;\n  readonly removeComments?: boolean;\n  readonly reportUnusedDisableDirectives?: boolean;\n  readonly resolvePluginsRelativeTo?: string;\n  readonly rule?: string;\n  readonly rulesdir?: string;\n  readonly stdin?: boolean;\n  readonly stdinFilename?: string;\n}\n\nexport type LintCallback = typeof process.exit;\n\ninterface ConfigResult {\n  configPath: string;\n  originalConfig: string | null;\n}\n\nconst createDefaultESLintConfig = (useTypescript: boolean, cwd: string): ConfigResult => {\n  // Use a temporary file path instead of creating in the project directory\n  const configPath = pathResolve(cwd, '.lex-temp-default-eslint.cjs');\n  const originalConfig = null;\n\n  // Create a temporary CommonJS module that requires Lex's ESLint config\n  const configContent = `// Temporary ESLint config generated by Lex\nconst lexConfig = require('@nlabs/lex/eslint.config.mjs');\n\nmodule.exports = lexConfig;`;\n\n  writeFileSync(configPath, configContent, 'utf8');\n\n  return {\n    configPath,\n    originalConfig\n  };\n};\n\nconst detectTypeScript = (cwd: string): boolean => existsSync(pathResolve(cwd, 'tsconfig.json'));\n\n/**\n * Ensure package.json has type: module for ESM support\n */\nconst ensureModuleType = (cwd: string): void => {\n  const packageJsonPath = pathResolve(cwd, 'package.json');\n\n  if(existsSync(packageJsonPath)) {\n    try {\n      const packageJsonContent = readFileSync(packageJsonPath, 'utf8');\n      const packageJson = JSON.parse(packageJsonContent);\n\n      // If type is not set to module, warn instead of auto-modifying\n      if(packageJson.type !== 'module') {\n        log('Warning: package.json should have \"type\": \"module\" for ESM support. Please add this manually.', 'warn', false);\n      }\n    } catch (_error) {\n      // Ignore errors\n    }\n  }\n};\n\nconst installDependencies = async (cwd: string, useTypescript: boolean, quiet: boolean): Promise<void> => {\n  if(useTypescript) {\n    log('Using TypeScript ESLint from Lex...', 'info', quiet);\n  } else {\n    log('Using ESLint from Lex...', 'info', quiet);\n  }\n};\n\nconst runEslintWithLex = async (\n  cwd: string,\n  quiet: boolean,\n  cliName: string,\n  fix: boolean,\n  debug: boolean,\n  useTypescript: boolean,\n  captureOutput?: (output: string) => void\n): Promise<number> => {\n  const spinner = createSpinner(quiet);\n\n  try {\n    const projectConfigPath = pathResolve(cwd, 'eslint.config.mjs');\n    const projectConfigPathTs = pathResolve(cwd, 'eslint.config.ts');\n    const hasProjectConfig = existsSync(projectConfigPath) || existsSync(projectConfigPathTs);\n    const hasLexConfigEslint = LexConfig.config.eslint && Object.keys(LexConfig.config.eslint).length > 0;\n\n    const possiblePaths = [\n      pathResolve(currentDirname, '../../../../eslint.config.mjs'),\n      pathResolve(currentDirname, '../../../../eslint.config.ts'),\n      pathResolve(process.env.LEX_HOME || '/usr/local/lib/node_modules/@nlabs/lex', 'eslint.config.mjs'),\n      pathResolve(process.env.LEX_HOME || '/usr/local/lib/node_modules/@nlabs/lex', 'eslint.config.ts')\n    ];\n\n    let lexConfigPath = '';\n\n    for(const path of possiblePaths) {\n      if(existsSync(path)) {\n        lexConfigPath = path;\n        break;\n      }\n    }\n\n    let configPath = '';\n    let tempConfigPath = '';\n\n    // Priority:\n    // 1. Project eslint.config files\n    // 2. ESLint config in lex.config.* file\n    // 3. Lex's default eslint.config.mjs\n    // 4. Create a temporary config file\n    if(hasProjectConfig) {\n      configPath = existsSync(projectConfigPathTs) ? projectConfigPathTs : projectConfigPath;\n      if(debug) {\n        log(`Using project ESLint config file: ${configPath}`, 'info', quiet);\n      }\n    } else if(hasLexConfigEslint) {\n      // When using lex.config.eslint, create a temporary JS config file (not JSON)\n      // to avoid ESM JSON import issues\n      tempConfigPath = pathResolve(cwd, '.lex-temp-eslint.cjs');\n\n      // Create a CommonJS module that extends Lex's eslint config\n      const configContent = `// Temporary ESLint config generated by Lex\nconst lexConfig = require('@nlabs/lex/eslint.config.mjs');\nconst userConfig = ${JSON.stringify(LexConfig.config.eslint, null, 2)};\n\n// Merge Lex's config with user config\nmodule.exports = {\n  ...lexConfig\n};`;\n\n      writeFileSync(tempConfigPath, configContent, 'utf8');\n      configPath = tempConfigPath;\n\n      if(debug) {\n        log(`Using ESLint config from lex.config.* file via temp file: ${tempConfigPath}`, 'info', quiet);\n      }\n    } else if(lexConfigPath && existsSync(lexConfigPath)) {\n      configPath = lexConfigPath;\n      if(debug) {\n        log(`Using Lex ESLint config file: ${configPath}`, 'info', quiet);\n      }\n    } else {\n      // Create a temporary default config file if no other config is found\n      tempConfigPath = pathResolve(cwd, '.lex-temp-default-eslint.cjs');\n\n      // Create a basic ESLint config\n      const configContent = `// Temporary default ESLint config generated by Lex\nconst lexConfig = require('@nlabs/lex/eslint.config.mjs');\n\nmodule.exports = lexConfig;`;\n\n      writeFileSync(tempConfigPath, configContent, 'utf8');\n      configPath = tempConfigPath;\n\n      if(debug) {\n        log(`Created temporary default ESLint config at: ${tempConfigPath}`, 'info', quiet);\n      } else {\n        log('No ESLint configuration found. Using Lex default configuration.', 'info', quiet);\n      }\n    }\n\n    const eslintBinary = resolveBinaryPath('eslint', 'eslint');\n\n    if(!eslintBinary) {\n      log(`\\n${cliName} Error: ESLint binary not found in Lex's node_modules`, 'error', quiet);\n      log('Please reinstall Lex or check your installation.', 'info', quiet);\n      return 1;\n    }\n\n    // Base ESLint arguments\n    const baseEslintArgs = [\n      ...(fix ? ['--fix'] : []),\n      ...(debug ? ['--debug'] : []),\n      '--no-error-on-unmatched-pattern',\n      '--no-warn-ignored'\n    ];\n\n    // Add config path\n    const configArgs = configPath ? ['--config', configPath] : [];\n\n    const jsResult = await execa(eslintBinary, [\n      'src/**/*.{js,jsx}',\n      ...configArgs,\n      ...baseEslintArgs\n    ], {\n      cwd,\n      reject: false,\n      shell: true,\n      stdio: 'pipe'\n    });\n\n    if(jsResult.stdout) {\n      // eslint-disable-next-line no-console\n      console.log(jsResult.stdout);\n      if(captureOutput) {\n        captureOutput(jsResult.stdout);\n      }\n    }\n\n    if(jsResult.stderr) {\n      // eslint-disable-next-line no-console\n      console.error(jsResult.stderr);\n      if(captureOutput) {\n        captureOutput(jsResult.stderr);\n      }\n    }\n\n    let tsResult: any = {exitCode: 0, stderr: '', stdout: ''};\n    if(useTypescript) {\n      tsResult = await execa(eslintBinary, [\n        'src/**/*.{ts,tsx}',\n        ...configArgs,\n        ...baseEslintArgs\n      ], {\n        cwd,\n        reject: false,\n        shell: true,\n        stdio: 'pipe'\n      });\n\n      if(tsResult.stdout) {\n        // eslint-disable-next-line no-console\n        console.log(tsResult.stdout);\n      }\n\n      if(tsResult.stderr) {\n        // eslint-disable-next-line no-console\n        console.error(tsResult.stderr);\n      }\n    }\n\n    // Clean up temp file if created\n    if(tempConfigPath && existsSync(tempConfigPath)) {\n      try {\n        unlinkSync(tempConfigPath);\n        if(debug) {\n          log(`Removed temporary ESLint config at ${tempConfigPath}`, 'info', quiet);\n        }\n      } catch (error) {\n        // Ignore errors when cleaning up\n        if(debug) {\n          log(`Failed to remove temporary ESLint config: ${error.message}`, 'warn', quiet);\n        }\n      }\n    }\n\n    const eslintNotFound = jsResult.stderr?.includes('command not found') || jsResult.stderr?.includes('eslint: command not found');\n    if(eslintNotFound) {\n      spinner.fail('ESLint not found!');\n      log(`\\n${cliName} Error: Lex's ESLint binary not found. Please reinstall Lex or check your installation.`, 'error', quiet);\n      return 1;\n    }\n\n    if(jsResult.exitCode === 0 && tsResult.exitCode === 0) {\n      spinner.succeed('Linting completed!');\n      return 0;\n    }\n\n    const noFilesFound =\n      (jsResult.stderr?.includes('No such file or directory') || jsResult.stdout?.includes('No such file or directory')) &&\n      (!useTypescript || tsResult.stderr?.includes('No such file or directory') || tsResult.stdout?.includes('No such file or directory'));\n\n    if(noFilesFound) {\n      spinner.succeed('No files found to lint');\n      return 0;\n    }\n    spinner.fail('Linting failed!');\n    log(`\\n${cliName} Error: ESLint found issues in your code.`, 'error', quiet);\n    return 1;\n  } catch (error) {\n    spinner.fail('Linting failed!');\n    log(`\\n${cliName} Error: ${error.message}`, 'error', quiet);\n    return 1;\n  }\n};\n\nconst applyAIFix = async (\n  cwd: string,\n  errors: string,\n  quiet: boolean\n): Promise<void> => {\n  const spinner = createSpinner(quiet);\n  spinner.start('Using AI to fix remaining lint issues...');\n\n  try {\n    const fileErrorMap = new Map<string, string[]>();\n    const lines = errors.split('\\n');\n    let currentFile = '';\n\n    for(const line of lines) {\n      if(line.match(/^(\\/|[A-Z]:\\\\).*?\\.(js|jsx|ts|tsx)$/)) {\n        currentFile = line.trim();\n        if(!fileErrorMap.has(currentFile)) {\n          fileErrorMap.set(currentFile, []);\n        }\n      } else if(currentFile && line.trim() && line.match(/\\s+\\d+:\\d+\\s+(error|warning)\\s+/)) {\n        const errorArray = fileErrorMap.get(currentFile);\n        if(errorArray) {\n          errorArray.push(line.trim());\n        }\n      }\n    }\n\n    if(fileErrorMap.size === 0) {\n      log('Using alternative error parsing strategy', 'info', quiet);\n\n      const sections = errors.split('\\n\\n');\n\n      for(const section of sections) {\n        if(section.trim() === '') {\n          continue;\n        }\n\n        const lines = section.split('\\n');\n        const filePath = lines[0].trim();\n\n        if(filePath.match(/\\.(js|jsx|ts|tsx)$/)) {\n          fileErrorMap.set(filePath, []);\n\n          for(let i = 1; i < lines.length; i++) {\n            if(lines[i].trim() !== '') {\n              fileErrorMap.get(filePath)?.push(lines[i].trim());\n            }\n          }\n        }\n      }\n    }\n\n    if(fileErrorMap.size === 0) {\n      log('Using direct file path extraction', 'info', quiet);\n\n      const filePathRegex = /(?:\\/|[A-Z]:\\\\)(?:[^:\\n]+\\/)*[^:\\n]+\\.(js|jsx|ts|tsx)/g;\n      const filePaths = errors.match(filePathRegex) || [];\n\n      for(const filePath of filePaths) {\n        if(!fileErrorMap.has(filePath) && existsSync(filePath)) {\n          fileErrorMap.set(filePath, []);\n        }\n      }\n\n      const knownFiles = [\n        pathResolve(cwd, 'src/create/changelog.ts'),\n        pathResolve(cwd, 'src/utils/aiService.ts'),\n        pathResolve(cwd, 'src/utils/app.ts'),\n        pathResolve(cwd, 'src/utils/reactShim.ts'),\n        pathResolve(cwd, 'src/commands/lint/autofix.js')\n      ];\n\n      for(const file of knownFiles) {\n        if(existsSync(file) && !fileErrorMap.has(file)) {\n          fileErrorMap.set(file, []);\n        }\n      }\n    }\n\n    for(const filePath of fileErrorMap.keys()) {\n      if(!existsSync(filePath)) {\n        log(`File not found: ${filePath}`, 'warn', quiet);\n        continue;\n      }\n\n      log(`Processing file: ${filePath}`, 'info', quiet);\n\n      const isCursorIDE = LexConfig.config.ai?.provider === 'cursor' || process.env.CURSOR_IDE === 'true';\n\n      if(isCursorIDE) {\n        try {\n          const prompt = `Fix all ESLint errors in this file. Focus on:\n1. Fixing naming conventions\n2. Fixing sort-keys issues\n3. Replacing console.log with log utility\n4. Fixing no-plusplus issues\n5. Fixing unnecessary escape characters\n6. Fixing other ESLint errors\n\nCRITICAL REQUIREMENTS:\n- ONLY fix the specific lines with ESLint errors\n- DO NOT modify any other lines of code\n- DO NOT remove line breaks unless they are specifically causing ESLint errors\n- DO NOT condense multi-line structures to single lines\n- PRESERVE all existing line breaks and formatting that is not causing errors\n\nSPECIFIC FORMATTING RULES:\n- Maintain proper indentation (2 spaces)\n- Keep line breaks between class/interface declaration and their members\n- Keep line breaks between methods\n- Ensure there is a line break after opening braces for classes, interfaces, and methods\n- DO NOT place class/interface properties or methods on the same line as the opening brace\n- Preserve empty lines between logical code blocks\n- PRESERVE multi-line imports - do not condense them to single lines\n- PRESERVE multi-line object/array declarations - do not condense them to single lines\n\nSORT-KEYS RULE (HIGHEST PRIORITY):\n- All object literal keys MUST be sorted alphabetically in ascending order\n- This applies to ALL objects in the file, not just those with explicit sort-keys errors\n- Example: {b: 2, a: 1, c: 3} should become {a: 1, b: 2, c: 3}\n- Preserve the original formatting and line breaks when sorting\n\nExample of CORRECT formatting (DO NOT CHANGE):\nexport class UserConstants {\n  static readonly ADD_ITEM_ERROR: string = 'USER_ADD_ITEM_ERROR';\n  static readonly OTHER_CONSTANT: string = 'OTHER_CONSTANT';\n}\n\nconstructor(flux: FluxFramework, CustomAdapter: typeof Event = Event) {\n  this.CustomAdapter = CustomAdapter;\n  this.flux = flux;\n}\n\nimport {\n  app,\n  events,\n  images,\n  locations,\n  messages,\n  posts,\n  tags,\n  users,\n  websocket\n} from './stores';\n\nconst config = {\n  apiKey: 'value',\n  baseUrl: 'https://api.example.com',\n  timeout: 5000\n};\n\nExample of INCORRECT formatting (FIX THIS):\nexport class UserConstants {static readonly ADD_ITEM_ERROR: string = 'USER_ADD_ITEM_ERROR';\n  static readonly OTHER_CONSTANT: string = 'OTHER_CONSTANT';\n}\n\nconstructor(flux: FluxFramework, CustomAdapter: typeof Event = Event) {this.CustomAdapter = CustomAdapter;\n  this.flux = flux;}\n\nimport {app, events, images, locations, messages, posts, tags, users, websocket} from './stores';\n\nconst config = {baseUrl: 'https://api.example.com', apiKey: 'value', timeout: 5000};\n\nFix ONLY the specific ESLint errors. Return the properly formatted code.`;\n\n          try {\n            const promptFile = pathResolve(cwd, '.cursor_prompt_temp.txt');\n            writeFileSync(promptFile, prompt, 'utf8');\n\n            // Use Cursor CLI to fix the file\n            await execa('cursor', ['edit', '--file', filePath, '--prompt-file', promptFile], {\n              cwd,\n              reject: false,\n              stdio: 'pipe'\n            });\n\n            try {\n              unlinkSync(promptFile);\n            } catch (_error) {\n            }\n\n            log(`Applied Cursor AI fixes to ${filePath}`, 'info', quiet);\n          } catch {\n            const wasModified = await applyDirectFixes(filePath, quiet);\n            if(wasModified) {\n              log(`Applied direct fixes to ${filePath}`, 'info', quiet);\n            }\n          }\n        } catch (error) {\n          log(`Error using Cursor AI: ${error.message}`, 'error', quiet);\n          await applyDirectFixes(filePath, quiet);\n        }\n      } else {\n        const wasModified = await applyDirectFixes(filePath, quiet);\n        if(wasModified) {\n          log(`Applied direct fixes to ${filePath}`, 'info', quiet);\n        }\n\n        const fileErrors = fileErrorMap.get(filePath) || [];\n        if(fileErrors.length > 0) {\n          try {\n            const {callAIService} = await import('../../utils/aiService.js');\n\n            const fileContent = readFileSync(filePath, 'utf8');\n\n            const prompt = `Fix the following ESLint errors in this code:\n${fileErrors.join('\\n')}\n\nHere's the code:\n\\`\\`\\`\n${fileContent}\n\\`\\`\\`\n\nCRITICAL REQUIREMENTS:\n- ONLY fix the specific lines with ESLint errors\n- DO NOT modify any other lines of code\n- DO NOT remove line breaks unless they are specifically causing ESLint errors\n- DO NOT condense multi-line structures to single lines\n- PRESERVE all existing line breaks and formatting that is not causing errors\n\nSPECIFIC FORMATTING RULES:\n- Maintain proper indentation (2 spaces)\n- Keep line breaks between class/interface declaration and their members\n- Keep line breaks between methods\n- Ensure there is a line break after opening braces for classes, interfaces, and methods\n- DO NOT place class/interface properties or methods on the same line as the opening brace\n- Preserve empty lines between logical code blocks\n- PRESERVE multi-line imports - do not condense them to single lines\n- PRESERVE multi-line object/array declarations - do not condense them to single lines\n\nSORT-KEYS RULE (HIGHEST PRIORITY):\n- All object literal keys MUST be sorted alphabetically in ascending order\n- This applies to ALL objects in the file, not just those with explicit sort-keys errors\n- Example: {b: 2, a: 1, c: 3} should become {a: 1, b: 2, c: 3}\n- Preserve the original formatting and line breaks when sorting\n\nWHAT TO FIX:\n1. Sorting all object keys alphabetically (sort-keys rule) - ALL objects must have sorted keys\n2. Fixing naming conventions - ONLY for variables/functions with naming errors\n3. Replacing console.log with log utility - ONLY for console.log statements\n4. Fixing no-plusplus issues - ONLY for ++/-- operators\n5. Fixing unnecessary escape characters - ONLY for escaped characters that don't need escaping\n6. Proper indentation and spacing - ONLY where specifically required by errors\n7. String quotes consistency (use single quotes) - ONLY for string literals with quote errors\n8. Import order and spacing - ONLY for imports with order/spacing errors\n9. Function parameter formatting - ONLY for functions with parameter errors\n10. Variable naming conventions - ONLY for variables with naming errors\n11. No unused variables or imports - ONLY for unused variables/imports\n12. Avoiding nested ternaries - ONLY for nested ternary expressions\n13. Any other ESLint errors - ONLY for the specific errors listed above\n\nWHAT NOT TO FIX:\n- Do not change properly formatted multi-line structures\n- Do not remove line breaks that are not causing errors\n- Do not change indentation that is already correct\n- Do not modify spacing that is already correct\n- Do not condense readable multi-line code to single lines\n- Do not modify code that is not mentioned in the ESLint errors\n\nExample of CORRECT formatting (DO NOT CHANGE):\nexport class UserConstants {\n  static readonly ADD_ITEM_ERROR: string = 'USER_ADD_ITEM_ERROR';\n  static readonly OTHER_CONSTANT: string = 'OTHER_CONSTANT';\n}\n\nconstructor(flux: FluxFramework, CustomAdapter: typeof Event = Event) {\n  this.CustomAdapter = CustomAdapter;\n  this.flux = flux;\n}\n\nimport {\n  app,\n  events,\n  images,\n  locations,\n  messages,\n  posts,\n  tags,\n  users,\n  websocket\n} from './stores';\n\nconst config = {\n  apiKey: 'value',\n  baseUrl: 'https://api.example.com',\n  timeout: 5000\n};\n\nExample of INCORRECT formatting (FIX THIS):\nexport class UserConstants {static readonly ADD_ITEM_ERROR: string = 'USER_ADD_ITEM_ERROR';\n  static readonly OTHER_CONSTANT: string = 'OTHER_CONSTANT';\n}\n\nconstructor(flux: FluxFramework, CustomAdapter: typeof Event = Event) {this.CustomAdapter = CustomAdapter;\n  this.flux = flux;}\n\nimport {app, events, images, locations, messages, posts, tags, users, websocket} from './stores';\n\nconst config = {baseUrl: 'https://api.example.com', apiKey: 'value', timeout: 5000};\n\nFix ONLY the specific ESLint errors listed above. Review the entire file for compliance with all ESLint rules.\nReturn only the properly formatted fixed code without any explanations.`;\n\n            const fixedContent = await callAIService(prompt, quiet);\n\n            if(fixedContent && fixedContent !== fileContent) {\n              writeFileSync(filePath, fixedContent, 'utf8');\n              log(`Applied AI fixes to ${filePath}`, 'info', quiet);\n            }\n          } catch (error) {\n            log(`Error applying AI fixes to ${filePath}: ${error.message}`, 'error', quiet);\n          }\n        }\n      }\n    }\n\n    spinner.succeed('AI fixes applied successfully!');\n  } catch (error) {\n    spinner.fail('Failed to apply AI fixes');\n    log(`Error: ${error.message}`, 'error', quiet);\n    if(!quiet) {\n      console.error(error);\n    }\n  }\n};\n\nconst applyDirectFixes = async (filePath: string, quiet: boolean): Promise<boolean> => {\n  let wasModified = false;\n\n  try {\n    const fileContent = readFileSync(filePath, 'utf8');\n    let newContent = fileContent;\n\n    if(filePath.includes('aiService.ts')) {\n      log('Fixing issues in aiService.ts', 'info', quiet);\n\n      newContent = newContent.replace(\n        /'Content-Type': 'application\\/json',\\s*'Authorization': `Bearer/g,\n        '\\'Authorization\\': `Bearer\\', \\'Content-Type\\': \\'application/json\\''\n      );\n\n      newContent = newContent.replace(\n        /headers: {([^}]*)},\\s*method: 'POST'/g,\n        'method: \\'POST\\',\\n      headers: {$1}'\n      );\n\n      newContent = newContent.replace(\n        /{role: 'system', content:/g,\n        '{content:, role: \\'system\\','\n      );\n      newContent = newContent.replace(\n        /{role: 'user', content:/g,\n        '{content:, role: \\'user\\','\n      );\n\n      newContent = newContent.replace(\n        /\\(([^)]*?)_([a-zA-Z0-9]+)(\\s*:[^)]*)\\)/g,\n        '($1$2$3)'\n      );\n\n      newContent = newContent.replace(/console\\.log\\(/g, 'log(');\n\n      if(!newContent.includes('import {log}') && newContent.includes('log(')) {\n        newContent = newContent.replace(\n          /import {([^}]*)} from '(.*)';/,\n          'import {$1} from \\'$2\\';\\nimport {log} from \\'./log.js\\';'\n        );\n      }\n    }\n\n    if(filePath.includes('reactShim.ts')) {\n      log('Fixing naming-convention issues in reactShim.ts', 'info', quiet);\n\n      newContent = newContent.replace(\n        'import * as React from',\n        'import * as react from'\n      );\n\n      newContent = newContent.replace(/React\\./g, 'react.');\n    }\n\n    if(filePath.includes('changelog.ts')) {\n      log('Fixing issues in changelog.ts', 'info', quiet);\n\n      newContent = newContent.replace(/(\\w+)\\+\\+/g, '$1 += 1');\n\n      newContent = newContent.replace(/\\\\\\$/g, '$');\n      newContent = newContent.replace(/\\\\\\./g, '.');\n      newContent = newContent.replace(/\\\\\\*/g, '*');\n      newContent = newContent.replace(/\\\\:/g, ':');\n    }\n\n    if(filePath.includes('app.ts')) {\n      log('Fixing issues in app.ts', 'info', quiet);\n\n      newContent = newContent.replace(/console\\.log\\(/g, 'log(');\n\n      if(!newContent.includes('import {log}') && newContent.includes('log(')) {\n        newContent = newContent.replace(\n          /import boxen from 'boxen';/,\n          'import boxen from \\'boxen\\';\\nimport {log} from \\'./log.js\\';'\n        );\n      }\n\n      newContent = newContent.replace(/\\\\\\//g, '/');\n    }\n\n    if(filePath.includes('autofix.js')) {\n      log('Fixing issues in autofix.js', 'info', quiet);\n\n      newContent = newContent.replace(\n        /import {([^}]*)} from 'path';[\\s\\n]*import {([^}]*)} from 'path';/,\n        'import {$1, $2} from \\'path\\';'\n      );\n\n      newContent = newContent.replace(\n        /__filename/g,\n        'currentFilename'\n      );\n      newContent = newContent.replace(\n        /__dirname/g,\n        'currentDirname'\n      );\n\n      newContent = newContent.replace(\n        /const prefix = type === 'error' \\? '\u274C ' : type === 'success' \\? '\u2705 ' : '\u2139\uFE0F ';/,\n        'let prefix = \\'\u2139\uFE0F \\';\\nif(type === \\'error\\') {\\n  prefix = \\'\u274C \\';\\n} else if(type === \\'success\\') {\\n  prefix = \\'\u2705 \\';\\n}'\n      );\n\n      newContent = newContent.replace(\n        /async function runEslintFix\\(\\)/g,\n        'const runEslintFix = async ()'\n      );\n      newContent = newContent.replace(\n        /async function getFilesWithErrors\\(\\)/g,\n        'const getFilesWithErrors = async ()'\n      );\n      newContent = newContent.replace(\n        /async function isCursorAvailable\\(\\)/g,\n        'const isCursorAvailable = async ()'\n      );\n      newContent = newContent.replace(\n        /async function fixFileWithCursorAI\\(filePath\\)/g,\n        'const fixFileWithCursorAI = async (filePath)'\n      );\n      newContent = newContent.replace(\n        /async function main\\(\\)/g,\n        'const main = async ()'\n      );\n\n      newContent = newContent.replace(\n        /import {existsSync, readFileSync, writeFileSync}/g,\n        'import {writeFileSync}'\n      );\n\n      newContent = newContent.replace(\n        /console\\.log\\(`\\${prefix} \\${message}`\\);/g,\n        'process.stdout.write(`${prefix} ${message}\\\\n`);'\n      );\n\n      newContent = newContent.replace(\n        /} catch\\(error\\) {[\\s\\n]*\\/\\/ Ignore cleanup errors/g,\n        '} catch(_) {\\n      // Ignore cleanup errors'\n      );\n      newContent = newContent.replace(\n        /} catch\\(error\\) {[\\s\\n]*log\\(/g,\n        '} catch(err) {\\n    log('\n      );\n      newContent = newContent.replace(\n        /} catch\\(error\\) {[\\s\\n]*return false;/g,\n        '} catch(_) {\\n    return false;'\n      );\n\n      newContent = newContent.replace(\n        /for\\(const filePath of filesWithErrors\\) {[\\s\\n]*const success = await fixFileWithCursorAI\\(filePath\\);/g,\n        'const fixResults = await Promise.all(filesWithErrors.map(filePath => fixFileWithCursorAI(filePath)));\\nfor(const success of fixResults) {'\n      );\n\n      newContent = newContent.replace(\n        /fixedCount\\+\\+;/g,\n        'fixedCount += 1;'\n      );\n    }\n\n    if(newContent !== fileContent) {\n      writeFileSync(filePath, newContent, 'utf8');\n      log(`Fixed issues in ${filePath}`, 'info', quiet);\n      wasModified = true;\n    }\n\n    return wasModified;\n  } catch (error) {\n    log(`Error applying direct fixes to ${filePath}: ${error.message}`, 'error', quiet);\n    return false;\n  }\n};\n\nconst loadAIConfig = async (cwd: string, quiet: boolean, debug: boolean = false): Promise<void> => {\n  const configFormats = ['js', 'mjs', 'cjs', 'ts', 'json'];\n  const configBaseName = 'lex.config';\n  let lexConfigPath = '';\n\n  for(const format of configFormats) {\n    const potentialPath = pathResolve(cwd, `./${configBaseName}.${format}`);\n    if(existsSync(potentialPath)) {\n      lexConfigPath = potentialPath;\n      break;\n    }\n  }\n\n  if(lexConfigPath) {\n    try {\n      // For MJS files, we need to use dynamic import with URL for compatibility\n      const format = extname(lexConfigPath).slice(1);\n      let importPath = lexConfigPath;\n\n      // Use URL protocol for ESM imports\n      if(format === 'mjs') {\n        try {\n          const url = new URL(`file://${lexConfigPath}`);\n          importPath = url.href;\n          if(debug) {\n            log(`Using URL format for MJS import: ${importPath}`, 'info', quiet);\n          }\n        } catch (urlError) {\n          log(`Error creating URL for MJS import: ${urlError.message}`, 'warn', debug || !quiet);\n          importPath = `file://${lexConfigPath}`;\n        }\n      }\n\n      if(debug) {\n        log(`Trying to import config from ${importPath} (format: ${format})`, 'info', quiet);\n      }\n\n      let lexConfig;\n      try {\n        lexConfig = await import(importPath);\n      } catch (importError) {\n        if(importError.message.includes('not defined in ES module scope')) {\n          log(`ES Module syntax error in ${lexConfigPath}. Make sure you're using 'export' instead of 'module.exports'.`, 'error', quiet);\n          if(debug) {\n            console.error(importError);\n          }\n          return;\n        }\n        throw importError;\n      }\n\n      // Handle both ESM (default export) and CommonJS (module.exports)\n      let configData = null;\n      if(lexConfig.default) {\n        configData = lexConfig.default;\n        if(debug) {\n          log(`Found default export in ${lexConfigPath}`, 'info', quiet);\n        }\n      } else {\n        // For CommonJS or other module systems\n        configData = lexConfig;\n        if(debug) {\n          log(`Using direct export in ${lexConfigPath}`, 'info', quiet);\n        }\n      }\n\n      if(configData && configData.ai) {\n        log(`Found AI configuration in ${pathResolve(cwd, lexConfigPath)}, applying settings...`, 'info', quiet);\n        LexConfig.config.ai = {...LexConfig.config.ai, ...configData.ai};\n      }\n    } catch (error) {\n      log(`Error loading AI configuration from ${lexConfigPath}: ${error.message}`, 'warn', quiet);\n      if(debug) {\n        console.error(error);\n      }\n    }\n  }\n};\n\n/**\n * Load ESLint configuration from lex.config.* files\n */\nconst loadESLintConfig = async (cwd: string, quiet: boolean, debug: boolean): Promise<boolean> => {\n  // Check if LexConfig already has ESLint configuration loaded\n  if(LexConfig.config.eslint && Object.keys(LexConfig.config.eslint).length > 0) {\n    log('Found ESLint configuration in lex.config.* file', 'info', debug || !quiet);\n    return true;\n  }\n\n  // Try to load from lex.config.* files if not already loaded\n  const configFormats = ['js', 'mjs', 'cjs', 'ts', 'json'];\n  const configBaseName = 'lex.config';\n\n  for(const format of configFormats) {\n    const potentialPath = pathResolve(cwd, `./${configBaseName}.${format}`);\n    if(existsSync(potentialPath)) {\n      try {\n        // For MJS files, we need to use dynamic import with URL for compatibility\n        const fileFormat = extname(potentialPath).slice(1);\n        let importPath = potentialPath;\n\n        // Use URL protocol for ESM imports\n        if(fileFormat === 'mjs') {\n          try {\n            const url = new URL(`file://${potentialPath}`);\n            importPath = url.href;\n            if(debug) {\n              log(`Using URL format for MJS import: ${importPath}`, 'info', quiet);\n            }\n          } catch (urlError) {\n            log(`Error creating URL for MJS import: ${urlError.message}`, 'warn', debug || !quiet);\n            importPath = `file://${potentialPath}`;\n          }\n        }\n\n        if(debug) {\n          log(`Trying to import config from ${importPath} (format: ${fileFormat})`, 'info', quiet);\n        }\n\n        let lexConfig;\n        try {\n          lexConfig = await import(importPath);\n        } catch (importError) {\n          if(importError.message.includes('not defined in ES module scope')) {\n            log(`ES Module syntax error in ${potentialPath}. Make sure you're using 'export' instead of 'module.exports'.`, 'error', quiet);\n            if(debug) {\n              console.error(importError);\n            }\n            continue;\n          }\n          throw importError;\n        }\n\n        // Handle both ESM (default export) and CommonJS (module.exports)\n        let configData = null;\n        if(lexConfig.default) {\n          configData = lexConfig.default;\n          if(debug) {\n            log(`Found default export in ${potentialPath}`, 'info', quiet);\n          }\n        } else {\n          // For CommonJS or other module systems\n          configData = lexConfig;\n          if(debug) {\n            log(`Using direct export in ${potentialPath}`, 'info', quiet);\n          }\n        }\n\n        if(configData && configData.eslint && Object.keys(configData.eslint).length > 0) {\n          log(`Found ESLint configuration in ${pathResolve(cwd, potentialPath)}, applying settings...`, 'info', debug || !quiet);\n          LexConfig.config.eslint = {...LexConfig.config.eslint, ...configData.eslint};\n          return true;\n        }\n      } catch (error) {\n        log(`Error loading ESLint configuration from ${potentialPath}: ${error.message}`, 'warn', quiet);\n        if(debug) {\n          console.error(error);\n        }\n      }\n    }\n  }\n\n  return false;\n};\n\nconst removeFileComments = (filePath: string, quiet: boolean): boolean => {\n  try {\n    const fileContent = readFileSync(filePath, 'utf8');\n\n    if(fileContent.length > 1000000) { // 1MB limit\n      log(`Skipping comment removal for large file: ${filePath}`, 'info', quiet);\n      return false;\n    }\n    // Use regex to match different types of comments\n    // Preserves:\n    // 1. Copyright notices (/* Copyright ... */)\n    // 2. TODO comments (// TODO: ...)\n    // 3. License headers (/* ... License ... */)\n\n    // Handle multi-line comments first - preserve copyright/license notices\n    let newContent = fileContent.replace(\n      /\\/\\*[\\s\\S]*?\\*\\//g,\n      (match) => {\n        if(match.includes('Copyright') ||\n          match.includes('LICENSE') ||\n          match.includes('License') ||\n          match.includes('license')) {\n          return match;\n        }\n        return '';\n      }\n    );\n\n    // Handle single-line comments - preserve TODOs\n    newContent = newContent.replace(\n      /\\/\\/.*$/gm,\n      (match) => {\n        if(match.includes('TODO') || match.includes('FIXME')) {\n          return match;\n        }\n        return '';\n      }\n    );\n\n    // Clean up any multiple blank lines created by comment removal\n    newContent = newContent.replace(/\\n\\s*\\n\\s*\\n/g, '\\n\\n');\n\n    // If the file was modified, save it\n    if(newContent !== fileContent) {\n      writeFileSync(filePath, newContent, 'utf8');\n      log(`Removed comments from ${filePath}`, 'info', quiet);\n      return true;\n    }\n\n    return false;\n  } catch (error) {\n    log(`Error removing comments from ${filePath}: ${error.message}`, 'error', quiet);\n    return false;\n  }\n};\n\nexport const lint = async (cmd: LintOptions & {'remove-comments'?: boolean}, callback: LintCallback = process.exit): Promise<number> => {\n  const {\n    cliName = 'Lex',\n    fix = false,\n    debug = false,\n    quiet = false,\n    config = null,\n    removeComments = false,\n    'remove-comments': removeCommentsFlag = false\n  } = cmd;\n\n  const shouldRemoveComments = removeComments || removeCommentsFlag;\n\n  log(`${cliName} linting...`, 'info', quiet);\n\n  const cwd = process.cwd();\n  const spinner = createSpinner(quiet);\n\n  await loadAIConfig(cwd, quiet, debug);\n\n  let tempConfigPath: string | null = null;\n\n  try {\n    const useTypescript = detectTypeScript(cwd);\n    log(`TypeScript ${useTypescript ? 'detected' : 'not detected'} from tsconfig.json`, 'info', quiet);\n\n    if(useTypescript) {\n      LexConfig.checkLintTypescriptConfig();\n    }\n\n    ensureModuleType(cwd);\n\n    await installDependencies(cwd, useTypescript, quiet);\n\n    const projectConfigPath = pathResolve(cwd, 'eslint.config.mjs');\n    const projectConfigPathTs = pathResolve(cwd, 'eslint.config.ts');\n    const hasEslintConfig = existsSync(projectConfigPath) ||\n      existsSync(projectConfigPathTs) ||\n      existsSync(pathResolve(cwd, '.eslintrc.js')) ||\n      existsSync(pathResolve(cwd, '.eslintrc.json')) ||\n      existsSync(pathResolve(cwd, '.eslintrc.yml')) ||\n      existsSync(pathResolve(cwd, '.eslintrc.yaml')) ||\n      existsSync(pathResolve(cwd, '.eslintrc'));\n\n    const hasLexEslintConfig = await loadESLintConfig(cwd, quiet, debug);\n\n    if(hasLexEslintConfig) {\n      log('Using ESLint configuration from lex.config.* file', 'info', quiet);\n    }\n\n    if(existsSync(pathResolve(cwd, '.eslintrc.json'))) {\n      unlinkSync(pathResolve(cwd, '.eslintrc.json'));\n    }\n\n    let lexConfigPath = '';\n    let shouldCreateTempConfig = false;\n\n    if(!hasEslintConfig && !hasLexEslintConfig) {\n      const possiblePaths = [\n        pathResolve(currentDirname, '../../../../eslint.config.ts'),\n        pathResolve(currentDirname, '../../../../eslint.config.jms'),\n        pathResolve(process.env.LEX_HOME || './node_modules/@nlabs/lex', 'eslint.config.ts'),\n        pathResolve(process.env.LEX_HOME || './node_modules/@nlabs/lex', 'eslint.config.mjs')\n      ];\n\n      for(const path of possiblePaths) {\n        if(existsSync(path)) {\n          lexConfigPath = path;\n          break;\n        }\n      }\n\n      if(debug) {\n        log(`Current directory: ${currentDirname}`, 'info', quiet);\n        log(`Project config path: ${projectConfigPath}`, 'info', quiet);\n        log(`Project config exists: ${hasEslintConfig}`, 'info', quiet);\n        log(`Found Lex config: ${lexConfigPath}`, 'info', quiet);\n        log(`Lex config exists: ${!!lexConfigPath && existsSync(lexConfigPath)}`, 'info', quiet);\n      }\n\n      if(lexConfigPath && existsSync(lexConfigPath)) {\n        log('No ESLint configuration found in project. Using Lex\\'s default configuration.', 'info', quiet);\n      } else {\n        shouldCreateTempConfig = true;\n      }\n    }\n\n    if(config) {\n      const userConfigPath = pathResolve(cwd, config);\n      if(existsSync(userConfigPath)) {\n        log(`Using specified ESLint configuration: ${config}`, 'info', quiet);\n        shouldCreateTempConfig = false;\n      } else {\n        log(`Specified ESLint configuration not found: ${config}. Using Lex's default configuration.`, 'warn', quiet);\n      }\n    }\n\n    if(shouldCreateTempConfig) {\n      log('No ESLint configuration found. Creating a temporary configuration...', 'info', quiet);\n      const configResult = createDefaultESLintConfig(useTypescript, cwd);\n      tempConfigPath = configResult.configPath;\n    }\n\n    let eslintOutput = '';\n    const captureOutput = (output: string) => {\n      eslintOutput += `${output}\\n`;\n    };\n\n    const result = await runEslintWithLex(cwd, quiet, cliName, true, debug, useTypescript, captureOutput);\n\n    if(shouldRemoveComments) {\n      spinner.start('Removing comments from files...');\n\n      const glob = await import('glob');\n      const files = glob.sync('{src,lib}/**/*.{js,jsx,ts,tsx}', {\n        cwd,\n        ignore: ['**/node_modules/**', '**/lib/**', '**/dist/**', '**/build/**']\n      });\n\n      let processedCount = 0;\n      for(const file of files) {\n        const filePath = pathResolve(cwd, file);\n        if(removeFileComments(filePath, quiet)) {\n          processedCount++;\n        }\n      }\n\n      spinner.succeed(`Removed comments from ${processedCount} files`);\n    }\n\n    if(result !== 0 && fix) {\n      const aiConfigured = LexConfig.config.ai?.provider && LexConfig.config.ai.provider !== 'none';\n\n      if(aiConfigured) {\n        log('Applying AI fixes to remaining issues...', 'info', quiet);\n        await applyAIFix(cwd, eslintOutput, quiet);\n\n        const afterFixResult = await runEslintWithLex(cwd, quiet, cliName, false, debug, useTypescript);\n\n        callback(afterFixResult);\n        return afterFixResult;\n      }\n      log('ESLint could not fix all issues automatically.', 'warn', quiet);\n      log('To enable AI-powered fixes, add AI configuration to your lex.config file:', 'info', quiet);\n      log(`\n// In lex.config.js (or lex.config.mjs, lex.config.cjs, etc.)\nexport default {\n  // Your existing config\n  ai: {\n    provider: 'cursor' // or 'openai', 'anthropic', etc.\n    // Additional provider-specific settings\n  }\n};`, 'info', quiet);\n    }\n\n    callback(result);\n    return result;\n  } catch (error) {\n    log(`\\n${cliName} Error: ${error.message}`, 'error', quiet);\n    if(spinner) {\n      spinner.fail('Linting failed!');\n    }\n    callback(1);\n    return 1;\n  } finally {\n    const tempFilePaths = [\n      tempConfigPath,\n      pathResolve(cwd, '.lex-temp-eslint.cjs'),\n      pathResolve(cwd, '.lex-temp-default-eslint.cjs')\n    ];\n\n    for(const filePath of tempFilePaths) {\n      if(filePath && existsSync(filePath)) {\n        try {\n          unlinkSync(filePath);\n          if(debug) {\n            log(`Cleaned up temporary ESLint config at ${filePath}`, 'info', quiet);\n          }\n        } catch {\n        }\n      }\n    }\n  }\n};"],
  "mappings": "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",
  "names": ["lines"]
}

+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/commands/lint/lint.ts"],"sourcesContent":["/**\n * Copyright (c) 2022-Present, Nitrogen Labs, Inc.\n * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.\n */\nimport {execa} from 'execa';\nimport {existsSync, readFileSync, unlinkSync, writeFileSync} from 'fs';\nimport {dirname, resolve as pathResolve, extname} from 'path';\n\nimport {LexConfig} from '../../LexConfig.js';\nimport {createSpinner} from '../../utils/app.js';\nimport {resolveBinaryPath} from '../../utils/file.js';\nimport {log} from '../../utils/log.js';\n\nlet currentFilename: string;\nlet currentDirname: string;\n\ntry {\n  currentFilename = eval('require(\"url\").fileURLToPath(import.meta.url)');\n  currentDirname = dirname(currentFilename);\n} catch{\n  currentFilename = process.cwd();\n  currentDirname = process.cwd();\n}\n\nexport interface LintOptions {\n  readonly cache?: boolean;\n  readonly cacheFile?: string;\n  readonly cacheLocation?: string;\n  readonly cliName?: string;\n  readonly color?: boolean;\n  readonly config?: string;\n  readonly debug?: boolean;\n  readonly env?: string;\n  readonly envInfo?: boolean;\n  readonly ext?: string;\n  readonly fix?: boolean;\n  readonly fixDryRun?: boolean;\n  readonly fixType?: string;\n  readonly format?: string;\n  readonly global?: string;\n  readonly ignorePath?: string;\n  readonly ignorePattern?: string;\n  readonly init?: boolean;\n  readonly maxWarnings?: string;\n  readonly noColor?: boolean;\n  readonly noEslintrc?: boolean;\n  readonly noIgnore?: boolean;\n  readonly noInlineConfig?: boolean;\n  readonly outputFile?: string;\n  readonly parser?: string;\n  readonly parserOptions?: string;\n  readonly plugin?: string;\n  readonly printConfig?: string;\n  readonly quiet?: boolean;\n  readonly removeComments?: boolean;\n  readonly reportUnusedDisableDirectives?: boolean;\n  readonly resolvePluginsRelativeTo?: string;\n  readonly rule?: string;\n  readonly rulesdir?: string;\n  readonly stdin?: boolean;\n  readonly stdinFilename?: string;\n}\n\nexport type LintCallback = typeof process.exit;\n\ninterface ConfigResult {\n  configPath: string;\n  originalConfig: string | null;\n}\n\nconst createDefaultESLintConfig = (useTypescript: boolean, cwd: string): ConfigResult => {\n  // Use a temporary file path instead of creating in the project directory\n  const configPath = pathResolve(cwd, '.lex-temp-default-eslint.cjs');\n  const originalConfig = null;\n\n  // Create a temporary CommonJS module that requires Lex's ESLint config\n  const configContent = `// Temporary ESLint config generated by Lex\nconst lexConfig = require('@nlabs/lex/eslint.config.mjs');\n\nmodule.exports = lexConfig;`;\n\n  writeFileSync(configPath, configContent, 'utf8');\n\n  return {\n    configPath,\n    originalConfig\n  };\n};\n\nconst detectTypeScript = (cwd: string): boolean => existsSync(pathResolve(cwd, 'tsconfig.json'));\n\n/**\n * Ensure package.json has type: module for ESM support\n */\nconst ensureModuleType = (cwd: string): void => {\n  const packageJsonPath = pathResolve(cwd, 'package.json');\n\n  if(existsSync(packageJsonPath)) {\n    try {\n      const packageJsonContent = readFileSync(packageJsonPath, 'utf8');\n      const packageJson = JSON.parse(packageJsonContent);\n\n      // If type is not set to module, warn instead of auto-modifying\n      if(packageJson.type !== 'module') {\n        log('Warning: package.json should have \"type\": \"module\" for ESM support. Please add this manually.', 'warn', false);\n      }\n    } catch(_error) {\n      // Ignore errors\n    }\n  }\n};\n\nconst installDependencies = async (cwd: string, useTypescript: boolean, quiet: boolean): Promise<void> => {\n  if(useTypescript) {\n    log('Using TypeScript ESLint from Lex...', 'info', quiet);\n  } else {\n    log('Using ESLint from Lex...', 'info', quiet);\n  }\n};\n\nconst runEslintWithLex = async (\n  cwd: string,\n  quiet: boolean,\n  cliName: string,\n  fix: boolean,\n  debug: boolean,\n  useTypescript: boolean,\n  captureOutput?: (output: string) => void\n): Promise<number> => {\n  const spinner = createSpinner(quiet);\n\n  try {\n    const projectConfigPath = pathResolve(cwd, 'eslint.config.mjs');\n    const projectConfigPathTs = pathResolve(cwd, 'eslint.config.ts');\n    const hasProjectConfig = existsSync(projectConfigPath) || existsSync(projectConfigPathTs);\n    const hasLexConfigEslint = LexConfig.config.eslint && Object.keys(LexConfig.config.eslint).length > 0;\n\n    const possiblePaths = [\n      pathResolve(currentDirname, '../../../../eslint.config.mjs'),\n      pathResolve(currentDirname, '../../../../eslint.config.ts'),\n      pathResolve(process.env.LEX_HOME || '/usr/local/lib/node_modules/@nlabs/lex', 'eslint.config.mjs'),\n      pathResolve(process.env.LEX_HOME || '/usr/local/lib/node_modules/@nlabs/lex', 'eslint.config.ts')\n    ];\n\n    let lexConfigPath = '';\n\n    for(const path of possiblePaths) {\n      if(existsSync(path)) {\n        lexConfigPath = path;\n        break;\n      }\n    }\n\n    let configPath = '';\n    let tempConfigPath = '';\n\n    // Priority:\n    // 1. Project eslint.config files\n    // 2. ESLint config in lex.config.* file\n    // 3. Lex's default eslint.config.mjs\n    // 4. Create a temporary config file\n    if(hasProjectConfig) {\n      configPath = existsSync(projectConfigPathTs) ? projectConfigPathTs : projectConfigPath;\n      if(debug) {\n        log(`Using project ESLint config file: ${configPath}`, 'info', quiet);\n      }\n    } else if(hasLexConfigEslint) {\n      // When using lex.config.eslint, create a temporary JS config file (not JSON)\n      // to avoid ESM JSON import issues\n      tempConfigPath = pathResolve(cwd, '.lex-temp-eslint.cjs');\n\n      // Create a CommonJS module that extends Lex's eslint config\n      const configContent = `// Temporary ESLint config generated by Lex\nconst lexConfig = require('@nlabs/lex/eslint.config.mjs');\nconst userConfig = ${JSON.stringify(LexConfig.config.eslint, null, 2)};\n\n// Merge Lex's config with user config\nmodule.exports = {\n  ...lexConfig\n};`;\n\n      writeFileSync(tempConfigPath, configContent, 'utf8');\n      configPath = tempConfigPath;\n\n      if(debug) {\n        log(`Using ESLint config from lex.config.* file via temp file: ${tempConfigPath}`, 'info', quiet);\n      }\n    } else if(lexConfigPath && existsSync(lexConfigPath)) {\n      configPath = lexConfigPath;\n      if(debug) {\n        log(`Using Lex ESLint config file: ${configPath}`, 'info', quiet);\n      }\n    } else {\n      // Create a temporary default config file if no other config is found\n      tempConfigPath = pathResolve(cwd, '.lex-temp-default-eslint.cjs');\n\n      // Create a basic ESLint config\n      const configContent = `// Temporary default ESLint config generated by Lex\nconst lexConfig = require('@nlabs/lex/eslint.config.mjs');\n\nmodule.exports = lexConfig;`;\n\n      writeFileSync(tempConfigPath, configContent, 'utf8');\n      configPath = tempConfigPath;\n\n      if(debug) {\n        log(`Created temporary default ESLint config at: ${tempConfigPath}`, 'info', quiet);\n      } else {\n        log('No ESLint configuration found. Using Lex default configuration.', 'info', quiet);\n      }\n    }\n\n    const eslintBinary = resolveBinaryPath('eslint', 'eslint');\n\n    if(!eslintBinary) {\n      log(`\\n${cliName} Error: ESLint binary not found in Lex's node_modules`, 'error', quiet);\n      log('Please reinstall Lex or check your installation.', 'info', quiet);\n      return 1;\n    }\n\n    // Base ESLint arguments\n    const baseEslintArgs = [\n      ...(fix ? ['--fix'] : []),\n      ...(debug ? ['--debug'] : []),\n      '--no-error-on-unmatched-pattern',\n      '--no-warn-ignored'\n    ];\n\n    // Add config path\n    const configArgs = configPath ? ['--config', configPath] : [];\n\n    const jsResult = await execa(eslintBinary, [\n      'src/**/*.{js,jsx}',\n      ...configArgs,\n      ...baseEslintArgs\n    ], {\n      cwd,\n      reject: false,\n      shell: true,\n      stdio: 'pipe'\n    });\n\n    if(jsResult.stdout) {\n      // eslint-disable-next-line no-console\n      console.log(jsResult.stdout);\n      if(captureOutput) {\n        captureOutput(jsResult.stdout);\n      }\n    }\n\n    if(jsResult.stderr) {\n      // eslint-disable-next-line no-console\n      console.error(jsResult.stderr);\n      if(captureOutput) {\n        captureOutput(jsResult.stderr);\n      }\n    }\n\n    let tsResult: any = {exitCode: 0, stderr: '', stdout: ''};\n    if(useTypescript) {\n      tsResult = await execa(eslintBinary, [\n        'src/**/*.{ts,tsx}',\n        ...configArgs,\n        ...baseEslintArgs\n      ], {\n        cwd,\n        reject: false,\n        shell: true,\n        stdio: 'pipe'\n      });\n\n      if(tsResult.stdout) {\n        // eslint-disable-next-line no-console\n        console.log(tsResult.stdout);\n      }\n\n      if(tsResult.stderr) {\n        // eslint-disable-next-line no-console\n        console.error(tsResult.stderr);\n      }\n    }\n\n    // Clean up temp file if created\n    if(tempConfigPath && existsSync(tempConfigPath)) {\n      try {\n        unlinkSync(tempConfigPath);\n        if(debug) {\n          log(`Removed temporary ESLint config at ${tempConfigPath}`, 'info', quiet);\n        }\n      } catch(error) {\n        // Ignore errors when cleaning up\n        if(debug) {\n          log(`Failed to remove temporary ESLint config: ${error.message}`, 'warn', quiet);\n        }\n      }\n    }\n\n    const eslintNotFound = jsResult.stderr?.includes('command not found') || jsResult.stderr?.includes('eslint: command not found');\n    if(eslintNotFound) {\n      spinner.fail('ESLint not found!');\n      log(`\\n${cliName} Error: Lex's ESLint binary not found. Please reinstall Lex or check your installation.`, 'error', quiet);\n      return 1;\n    }\n\n    if(jsResult.exitCode === 0 && tsResult.exitCode === 0) {\n      spinner.succeed('Linting completed!');\n      return 0;\n    }\n\n    const noFilesFound =\n      (jsResult.stderr?.includes('No such file or directory') || jsResult.stdout?.includes('No such file or directory')) &&\n      (!useTypescript || tsResult.stderr?.includes('No such file or directory') || tsResult.stdout?.includes('No such file or directory'));\n\n    if(noFilesFound) {\n      spinner.succeed('No files found to lint');\n      return 0;\n    }\n    spinner.fail('Linting failed!');\n    log(`\\n${cliName} Error: ESLint found issues in your code.`, 'error', quiet);\n    return 1;\n  } catch(error) {\n    spinner.fail('Linting failed!');\n    log(`\\n${cliName} Error: ${error.message}`, 'error', quiet);\n    return 1;\n  }\n};\n\nconst applyAIFix = async (\n  cwd: string,\n  errors: string,\n  quiet: boolean\n): Promise<void> => {\n  const spinner = createSpinner(quiet);\n  spinner.start('Using AI to fix remaining lint issues...');\n\n  try {\n    const fileErrorMap = new Map<string, string[]>();\n    const lines = errors.split('\\n');\n    let currentFile = '';\n\n    for(const line of lines) {\n      if(line.match(/^(\\/|[A-Z]:\\\\).*?\\.(js|jsx|ts|tsx)$/)) {\n        currentFile = line.trim();\n        if(!fileErrorMap.has(currentFile)) {\n          fileErrorMap.set(currentFile, []);\n        }\n      } else if(currentFile && line.trim() && line.match(/\\s+\\d+:\\d+\\s+(error|warning)\\s+/)) {\n        const errorArray = fileErrorMap.get(currentFile);\n        if(errorArray) {\n          errorArray.push(line.trim());\n        }\n      }\n    }\n\n    if(fileErrorMap.size === 0) {\n      log('Using alternative error parsing strategy', 'info', quiet);\n\n      const sections = errors.split('\\n\\n');\n\n      for(const section of sections) {\n        if(section.trim() === '') {\n          continue;\n        }\n\n        const lines = section.split('\\n');\n        const filePath = lines[0].trim();\n\n        if(filePath.match(/\\.(js|jsx|ts|tsx)$/)) {\n          fileErrorMap.set(filePath, []);\n\n          for(let i = 1; i < lines.length; i++) {\n            if(lines[i].trim() !== '') {\n              fileErrorMap.get(filePath)?.push(lines[i].trim());\n            }\n          }\n        }\n      }\n    }\n\n    if(fileErrorMap.size === 0) {\n      log('Using direct file path extraction', 'info', quiet);\n\n      const filePathRegex = /(?:\\/|[A-Z]:\\\\)(?:[^:\\n]+\\/)*[^:\\n]+\\.(js|jsx|ts|tsx)/g;\n      const filePaths = errors.match(filePathRegex) || [];\n\n      for(const filePath of filePaths) {\n        if(!fileErrorMap.has(filePath) && existsSync(filePath)) {\n          fileErrorMap.set(filePath, []);\n        }\n      }\n\n      const knownFiles = [\n        pathResolve(cwd, 'src/create/changelog.ts'),\n        pathResolve(cwd, 'src/utils/aiService.ts'),\n        pathResolve(cwd, 'src/utils/app.ts'),\n        pathResolve(cwd, 'src/utils/reactShim.ts'),\n        pathResolve(cwd, 'src/commands/lint/autofix.js')\n      ];\n\n      for(const file of knownFiles) {\n        if(existsSync(file) && !fileErrorMap.has(file)) {\n          fileErrorMap.set(file, []);\n        }\n      }\n    }\n\n    for(const filePath of fileErrorMap.keys()) {\n      if(!existsSync(filePath)) {\n        log(`File not found: ${filePath}`, 'warn', quiet);\n        continue;\n      }\n\n      log(`Processing file: ${filePath}`, 'info', quiet);\n\n      const isCursorIDE = LexConfig.config.ai?.provider === 'cursor' || process.env.CURSOR_IDE === 'true';\n\n      if(isCursorIDE) {\n        try {\n          const prompt = `Fix all ESLint errors in this file. Focus on:\n1. Fixing naming conventions\n2. Fixing sort-keys issues\n3. Replacing console.log with log utility\n4. Fixing no-plusplus issues\n5. Fixing unnecessary escape characters\n6. Fixing other ESLint errors\n\nCRITICAL REQUIREMENTS:\n- ONLY fix the specific lines with ESLint errors\n- DO NOT modify any other lines of code\n- DO NOT remove line breaks unless they are specifically causing ESLint errors\n- DO NOT condense multi-line structures to single lines\n- PRESERVE all existing line breaks and formatting that is not causing errors\n\nSPECIFIC FORMATTING RULES:\n- Maintain proper indentation (2 spaces)\n- Keep line breaks between class/interface declaration and their members\n- Keep line breaks between methods\n- Ensure there is a line break after opening braces for classes, interfaces, and methods\n- DO NOT place class/interface properties or methods on the same line as the opening brace\n- Preserve empty lines between logical code blocks\n- PRESERVE multi-line imports - do not condense them to single lines\n- PRESERVE multi-line object/array declarations - do not condense them to single lines\n\nSORT-KEYS RULE (HIGHEST PRIORITY):\n- All object literal keys MUST be sorted alphabetically in ascending order\n- This applies to ALL objects in the file, not just those with explicit sort-keys errors\n- Example: {b: 2, a: 1, c: 3} should become {a: 1, b: 2, c: 3}\n- Preserve the original formatting and line breaks when sorting\n\nExample of CORRECT formatting (DO NOT CHANGE):\nexport class UserConstants {\n  static readonly ADD_ITEM_ERROR: string = 'USER_ADD_ITEM_ERROR';\n  static readonly OTHER_CONSTANT: string = 'OTHER_CONSTANT';\n}\n\nconstructor(flux: FluxFramework, CustomAdapter: typeof Event = Event) {\n  this.CustomAdapter = CustomAdapter;\n  this.flux = flux;\n}\n\nimport {\n  app,\n  events,\n  images,\n  locations,\n  messages,\n  posts,\n  tags,\n  users,\n  websocket\n} from './stores';\n\nconst config = {\n  apiKey: 'value',\n  baseUrl: 'https://api.example.com',\n  timeout: 5000\n};\n\nExample of INCORRECT formatting (FIX THIS):\nexport class UserConstants {static readonly ADD_ITEM_ERROR: string = 'USER_ADD_ITEM_ERROR';\n  static readonly OTHER_CONSTANT: string = 'OTHER_CONSTANT';\n}\n\nconstructor(flux: FluxFramework, CustomAdapter: typeof Event = Event) {this.CustomAdapter = CustomAdapter;\n  this.flux = flux;}\n\nimport {app, events, images, locations, messages, posts, tags, users, websocket} from './stores';\n\nconst config = {baseUrl: 'https://api.example.com', apiKey: 'value', timeout: 5000};\n\nFix ONLY the specific ESLint errors. Return the properly formatted code.`;\n\n          try {\n            const promptFile = pathResolve(cwd, '.cursor_prompt_temp.txt');\n            writeFileSync(promptFile, prompt, 'utf8');\n\n            // Use Cursor CLI to fix the file\n            await execa('cursor', ['edit', '--file', filePath, '--prompt-file', promptFile], {\n              cwd,\n              reject: false,\n              stdio: 'pipe'\n            });\n\n            try {\n              unlinkSync(promptFile);\n            } catch(_error) {\n            }\n\n            log(`Applied Cursor AI fixes to ${filePath}`, 'info', quiet);\n          } catch{\n            const wasModified = await applyDirectFixes(filePath, quiet);\n            if(wasModified) {\n              log(`Applied direct fixes to ${filePath}`, 'info', quiet);\n            }\n          }\n        } catch(error) {\n          log(`Error using Cursor AI: ${error.message}`, 'error', quiet);\n          await applyDirectFixes(filePath, quiet);\n        }\n      } else {\n        const wasModified = await applyDirectFixes(filePath, quiet);\n        if(wasModified) {\n          log(`Applied direct fixes to ${filePath}`, 'info', quiet);\n        }\n\n        const fileErrors = fileErrorMap.get(filePath) || [];\n        if(fileErrors.length > 0) {\n          try {\n            const {callAIService} = await import('../../utils/aiService.js');\n\n            const fileContent = readFileSync(filePath, 'utf8');\n\n            const prompt = `Fix the following ESLint errors in this code:\n${fileErrors.join('\\n')}\n\nHere's the code:\n\\`\\`\\`\n${fileContent}\n\\`\\`\\`\n\nCRITICAL REQUIREMENTS:\n- ONLY fix the specific lines with ESLint errors\n- DO NOT modify any other lines of code\n- DO NOT remove line breaks unless they are specifically causing ESLint errors\n- DO NOT condense multi-line structures to single lines\n- PRESERVE all existing line breaks and formatting that is not causing errors\n\nSPECIFIC FORMATTING RULES:\n- Maintain proper indentation (2 spaces)\n- Keep line breaks between class/interface declaration and their members\n- Keep line breaks between methods\n- Ensure there is a line break after opening braces for classes, interfaces, and methods\n- DO NOT place class/interface properties or methods on the same line as the opening brace\n- Preserve empty lines between logical code blocks\n- PRESERVE multi-line imports - do not condense them to single lines\n- PRESERVE multi-line object/array declarations - do not condense them to single lines\n\nSORT-KEYS RULE (HIGHEST PRIORITY):\n- All object literal keys MUST be sorted alphabetically in ascending order\n- This applies to ALL objects in the file, not just those with explicit sort-keys errors\n- Example: {b: 2, a: 1, c: 3} should become {a: 1, b: 2, c: 3}\n- Preserve the original formatting and line breaks when sorting\n\nWHAT TO FIX:\n1. Sorting all object keys alphabetically (sort-keys rule) - ALL objects must have sorted keys\n2. Fixing naming conventions - ONLY for variables/functions with naming errors\n3. Replacing console.log with log utility - ONLY for console.log statements\n4. Fixing no-plusplus issues - ONLY for ++/-- operators\n5. Fixing unnecessary escape characters - ONLY for escaped characters that don't need escaping\n6. Proper indentation and spacing - ONLY where specifically required by errors\n7. String quotes consistency (use single quotes) - ONLY for string literals with quote errors\n8. Import order and spacing - ONLY for imports with order/spacing errors\n9. Function parameter formatting - ONLY for functions with parameter errors\n10. Variable naming conventions - ONLY for variables with naming errors\n11. No unused variables or imports - ONLY for unused variables/imports\n12. Avoiding nested ternaries - ONLY for nested ternary expressions\n13. Any other ESLint errors - ONLY for the specific errors listed above\n\nWHAT NOT TO FIX:\n- Do not change properly formatted multi-line structures\n- Do not remove line breaks that are not causing errors\n- Do not change indentation that is already correct\n- Do not modify spacing that is already correct\n- Do not condense readable multi-line code to single lines\n- Do not modify code that is not mentioned in the ESLint errors\n\nExample of CORRECT formatting (DO NOT CHANGE):\nexport class UserConstants {\n  static readonly ADD_ITEM_ERROR: string = 'USER_ADD_ITEM_ERROR';\n  static readonly OTHER_CONSTANT: string = 'OTHER_CONSTANT';\n}\n\nconstructor(flux: FluxFramework, CustomAdapter: typeof Event = Event) {\n  this.CustomAdapter = CustomAdapter;\n  this.flux = flux;\n}\n\nimport {\n  app,\n  events,\n  images,\n  locations,\n  messages,\n  posts,\n  tags,\n  users,\n  websocket\n} from './stores';\n\nconst config = {\n  apiKey: 'value',\n  baseUrl: 'https://api.example.com',\n  timeout: 5000\n};\n\nExample of INCORRECT formatting (FIX THIS):\nexport class UserConstants {static readonly ADD_ITEM_ERROR: string = 'USER_ADD_ITEM_ERROR';\n  static readonly OTHER_CONSTANT: string = 'OTHER_CONSTANT';\n}\n\nconstructor(flux: FluxFramework, CustomAdapter: typeof Event = Event) {this.CustomAdapter = CustomAdapter;\n  this.flux = flux;}\n\nimport {app, events, images, locations, messages, posts, tags, users, websocket} from './stores';\n\nconst config = {baseUrl: 'https://api.example.com', apiKey: 'value', timeout: 5000};\n\nFix ONLY the specific ESLint errors listed above. Review the entire file for compliance with all ESLint rules.\nReturn only the properly formatted fixed code without any explanations.`;\n\n            const fixedContent = await callAIService(prompt, quiet);\n\n            if(fixedContent && fixedContent !== fileContent) {\n              writeFileSync(filePath, fixedContent, 'utf8');\n              log(`Applied AI fixes to ${filePath}`, 'info', quiet);\n            }\n          } catch(error) {\n            log(`Error applying AI fixes to ${filePath}: ${error.message}`, 'error', quiet);\n          }\n        }\n      }\n    }\n\n    spinner.succeed('AI fixes applied successfully!');\n  } catch(error) {\n    spinner.fail('Failed to apply AI fixes');\n    log(`Error: ${error.message}`, 'error', quiet);\n    if(!quiet) {\n      console.error(error);\n    }\n  }\n};\n\nconst applyDirectFixes = async (filePath: string, quiet: boolean): Promise<boolean> => {\n  let wasModified = false;\n\n  try {\n    const fileContent = readFileSync(filePath, 'utf8');\n    let newContent = fileContent;\n\n    if(filePath.includes('aiService.ts')) {\n      log('Fixing issues in aiService.ts', 'info', quiet);\n\n      newContent = newContent.replace(\n        /'Content-Type': 'application\\/json',\\s*'Authorization': `Bearer/g,\n        '\\'Authorization\\': `Bearer\\', \\'Content-Type\\': \\'application/json\\''\n      );\n\n      newContent = newContent.replace(\n        /headers: {([^}]*)},\\s*method: 'POST'/g,\n        'method: \\'POST\\',\\n      headers: {$1}'\n      );\n\n      newContent = newContent.replace(\n        /{role: 'system', content:/g,\n        '{content:, role: \\'system\\','\n      );\n      newContent = newContent.replace(\n        /{role: 'user', content:/g,\n        '{content:, role: \\'user\\','\n      );\n\n      newContent = newContent.replace(\n        /\\(([^)]*?)_([a-zA-Z0-9]+)(\\s*:[^)]*)\\)/g,\n        '($1$2$3)'\n      );\n\n      newContent = newContent.replace(/console\\.log\\(/g, 'log(');\n\n      if(!newContent.includes('import {log}') && newContent.includes('log(')) {\n        newContent = newContent.replace(\n          /import {([^}]*)} from '(.*)';/,\n          'import {$1} from \\'$2\\';\\nimport {log} from \\'./log.js\\';'\n        );\n      }\n    }\n\n    if(filePath.includes('reactShim.ts')) {\n      log('Fixing naming-convention issues in reactShim.ts', 'info', quiet);\n\n      newContent = newContent.replace(\n        'import * as React from',\n        'import * as react from'\n      );\n\n      newContent = newContent.replace(/React\\./g, 'react.');\n    }\n\n    if(filePath.includes('changelog.ts')) {\n      log('Fixing issues in changelog.ts', 'info', quiet);\n\n      newContent = newContent.replace(/(\\w+)\\+\\+/g, '$1 += 1');\n\n      newContent = newContent.replace(/\\\\\\$/g, '$');\n      newContent = newContent.replace(/\\\\\\./g, '.');\n      newContent = newContent.replace(/\\\\\\*/g, '*');\n      newContent = newContent.replace(/\\\\:/g, ':');\n    }\n\n    if(filePath.includes('app.ts')) {\n      log('Fixing issues in app.ts', 'info', quiet);\n\n      newContent = newContent.replace(/console\\.log\\(/g, 'log(');\n\n      if(!newContent.includes('import {log}') && newContent.includes('log(')) {\n        newContent = newContent.replace(\n          /import boxen from 'boxen';/,\n          'import boxen from \\'boxen\\';\\nimport {log} from \\'./log.js\\';'\n        );\n      }\n\n      newContent = newContent.replace(/\\\\\\//g, '/');\n    }\n\n    if(filePath.includes('autofix.js')) {\n      log('Fixing issues in autofix.js', 'info', quiet);\n\n      newContent = newContent.replace(\n        /import {([^}]*)} from 'path';[\\s\\n]*import {([^}]*)} from 'path';/,\n        'import {$1, $2} from \\'path\\';'\n      );\n\n      newContent = newContent.replace(\n        /__filename/g,\n        'currentFilename'\n      );\n      newContent = newContent.replace(\n        /__dirname/g,\n        'currentDirname'\n      );\n\n      newContent = newContent.replace(\n        /const prefix = type === 'error' \\? '❌ ' : type === 'success' \\? '✅ ' : 'ℹ️ ';/,\n        'let prefix = \\'ℹ️ \\';\\nif(type === \\'error\\') {\\n  prefix = \\'❌ \\';\\n} else if(type === \\'success\\') {\\n  prefix = \\'✅ \\';\\n}'\n      );\n\n      newContent = newContent.replace(\n        /async function runEslintFix\\(\\)/g,\n        'const runEslintFix = async ()'\n      );\n      newContent = newContent.replace(\n        /async function getFilesWithErrors\\(\\)/g,\n        'const getFilesWithErrors = async ()'\n      );\n      newContent = newContent.replace(\n        /async function isCursorAvailable\\(\\)/g,\n        'const isCursorAvailable = async ()'\n      );\n      newContent = newContent.replace(\n        /async function fixFileWithCursorAI\\(filePath\\)/g,\n        'const fixFileWithCursorAI = async (filePath)'\n      );\n      newContent = newContent.replace(\n        /async function main\\(\\)/g,\n        'const main = async ()'\n      );\n\n      newContent = newContent.replace(\n        /import {existsSync, readFileSync, writeFileSync}/g,\n        'import {writeFileSync}'\n      );\n\n      newContent = newContent.replace(\n        /console\\.log\\(`\\${prefix} \\${message}`\\);/g,\n        'process.stdout.write(`${prefix} ${message}\\\\n`);'\n      );\n\n      newContent = newContent.replace(\n        /} catch\\(error\\) {[\\s\\n]*\\/\\/ Ignore cleanup errors/g,\n        '} catch(_) {\\n      // Ignore cleanup errors'\n      );\n      newContent = newContent.replace(\n        /} catch\\(error\\) {[\\s\\n]*log\\(/g,\n        '} catch(err) {\\n    log('\n      );\n      newContent = newContent.replace(\n        /} catch\\(error\\) {[\\s\\n]*return false;/g,\n        '} catch(_) {\\n    return false;'\n      );\n\n      newContent = newContent.replace(\n        /for\\(const filePath of filesWithErrors\\) {[\\s\\n]*const success = await fixFileWithCursorAI\\(filePath\\);/g,\n        'const fixResults = await Promise.all(filesWithErrors.map(filePath => fixFileWithCursorAI(filePath)));\\nfor(const success of fixResults) {'\n      );\n\n      newContent = newContent.replace(\n        /fixedCount\\+\\+;/g,\n        'fixedCount += 1;'\n      );\n    }\n\n    if(newContent !== fileContent) {\n      writeFileSync(filePath, newContent, 'utf8');\n      log(`Fixed issues in ${filePath}`, 'info', quiet);\n      wasModified = true;\n    }\n\n    return wasModified;\n  } catch(error) {\n    log(`Error applying direct fixes to ${filePath}: ${error.message}`, 'error', quiet);\n    return false;\n  }\n};\n\nconst loadAIConfig = async (cwd: string, quiet: boolean, debug: boolean = false): Promise<void> => {\n  const configFormats = ['js', 'mjs', 'cjs', 'ts', 'json'];\n  const configBaseName = 'lex.config';\n  let lexConfigPath = '';\n\n  for(const format of configFormats) {\n    const potentialPath = pathResolve(cwd, `./${configBaseName}.${format}`);\n    if(existsSync(potentialPath)) {\n      lexConfigPath = potentialPath;\n      break;\n    }\n  }\n\n  if(lexConfigPath) {\n    try {\n      // For MJS files, we need to use dynamic import with URL for compatibility\n      const format = extname(lexConfigPath).slice(1);\n      let importPath = lexConfigPath;\n\n      // Use URL protocol for ESM imports\n      if(format === 'mjs') {\n        try {\n          const url = new URL(`file://${lexConfigPath}`);\n          importPath = url.href;\n          if(debug) {\n            log(`Using URL format for MJS import: ${importPath}`, 'info', quiet);\n          }\n        } catch(urlError) {\n          log(`Error creating URL for MJS import: ${urlError.message}`, 'warn', debug || !quiet);\n          importPath = `file://${lexConfigPath}`;\n        }\n      }\n\n      if(debug) {\n        log(`Trying to import config from ${importPath} (format: ${format})`, 'info', quiet);\n      }\n\n      let lexConfig;\n      try {\n        lexConfig = await import(importPath);\n      } catch(importError) {\n        if(importError.message.includes('not defined in ES module scope')) {\n          log(`ES Module syntax error in ${lexConfigPath}. Make sure you're using 'export' instead of 'module.exports'.`, 'error', quiet);\n          if(debug) {\n            console.error(importError);\n          }\n          return;\n        }\n        throw importError;\n      }\n\n      // Handle both ESM (default export) and CommonJS (module.exports)\n      let configData = null;\n      if(lexConfig.default) {\n        configData = lexConfig.default;\n        if(debug) {\n          log(`Found default export in ${lexConfigPath}`, 'info', quiet);\n        }\n      } else {\n        // For CommonJS or other module systems\n        configData = lexConfig;\n        if(debug) {\n          log(`Using direct export in ${lexConfigPath}`, 'info', quiet);\n        }\n      }\n\n      if(configData && configData.ai) {\n        log(`Found AI configuration in ${pathResolve(cwd, lexConfigPath)}, applying settings...`, 'info', quiet);\n        LexConfig.config.ai = {...LexConfig.config.ai, ...configData.ai};\n      }\n    } catch(error) {\n      log(`Error loading AI configuration from ${lexConfigPath}: ${error.message}`, 'warn', quiet);\n      if(debug) {\n        console.error(error);\n      }\n    }\n  }\n};\n\n/**\n * Load ESLint configuration from lex.config.* files\n */\nconst loadESLintConfig = async (cwd: string, quiet: boolean, debug: boolean): Promise<boolean> => {\n  // Check if LexConfig already has ESLint configuration loaded\n  if(LexConfig.config.eslint && Object.keys(LexConfig.config.eslint).length > 0) {\n    log('Found ESLint configuration in lex.config.* file', 'info', debug || !quiet);\n    return true;\n  }\n\n  // Try to load from lex.config.* files if not already loaded\n  const configFormats = ['js', 'mjs', 'cjs', 'ts', 'json'];\n  const configBaseName = 'lex.config';\n\n  for(const format of configFormats) {\n    const potentialPath = pathResolve(cwd, `./${configBaseName}.${format}`);\n    if(existsSync(potentialPath)) {\n      try {\n        // For MJS files, we need to use dynamic import with URL for compatibility\n        const fileFormat = extname(potentialPath).slice(1);\n        let importPath = potentialPath;\n\n        // Use URL protocol for ESM imports\n        if(fileFormat === 'mjs') {\n          try {\n            const url = new URL(`file://${potentialPath}`);\n            importPath = url.href;\n            if(debug) {\n              log(`Using URL format for MJS import: ${importPath}`, 'info', quiet);\n            }\n          } catch(urlError) {\n            log(`Error creating URL for MJS import: ${urlError.message}`, 'warn', debug || !quiet);\n            importPath = `file://${potentialPath}`;\n          }\n        }\n\n        if(debug) {\n          log(`Trying to import config from ${importPath} (format: ${fileFormat})`, 'info', quiet);\n        }\n\n        let lexConfig;\n        try {\n          lexConfig = await import(importPath);\n        } catch(importError) {\n          if(importError.message.includes('not defined in ES module scope')) {\n            log(`ES Module syntax error in ${potentialPath}. Make sure you're using 'export' instead of 'module.exports'.`, 'error', quiet);\n            if(debug) {\n              console.error(importError);\n            }\n            continue;\n          }\n          throw importError;\n        }\n\n        // Handle both ESM (default export) and CommonJS (module.exports)\n        let configData = null;\n        if(lexConfig.default) {\n          configData = lexConfig.default;\n          if(debug) {\n            log(`Found default export in ${potentialPath}`, 'info', quiet);\n          }\n        } else {\n          // For CommonJS or other module systems\n          configData = lexConfig;\n          if(debug) {\n            log(`Using direct export in ${potentialPath}`, 'info', quiet);\n          }\n        }\n\n        if(configData && configData.eslint && Object.keys(configData.eslint).length > 0) {\n          log(`Found ESLint configuration in ${pathResolve(cwd, potentialPath)}, applying settings...`, 'info', debug || !quiet);\n          LexConfig.config.eslint = {...LexConfig.config.eslint, ...configData.eslint};\n          return true;\n        }\n      } catch(error) {\n        log(`Error loading ESLint configuration from ${potentialPath}: ${error.message}`, 'warn', quiet);\n        if(debug) {\n          console.error(error);\n        }\n      }\n    }\n  }\n\n  return false;\n};\n\nconst removeFileComments = (filePath: string, quiet: boolean): boolean => {\n  try {\n    const fileContent = readFileSync(filePath, 'utf8');\n\n    if(fileContent.length > 1000000) { // 1MB limit\n      log(`Skipping comment removal for large file: ${filePath}`, 'info', quiet);\n      return false;\n    }\n    // Use regex to match different types of comments\n    // Preserves:\n    // 1. Copyright notices (/* Copyright ... */)\n    // 2. TODO comments (// TODO: ...)\n    // 3. License headers (/* ... License ... */)\n\n    // Handle multi-line comments first - preserve copyright/license notices\n    let newContent = fileContent.replace(\n      /\\/\\*[\\s\\S]*?\\*\\//g,\n      (match) => {\n        if(match.includes('Copyright') ||\n          match.includes('LICENSE') ||\n          match.includes('License') ||\n          match.includes('license')) {\n          return match;\n        }\n        return '';\n      }\n    );\n\n    // Handle single-line comments - preserve TODOs\n    newContent = newContent.replace(\n      /\\/\\/.*$/gm,\n      (match) => {\n        if(match.includes('TODO') || match.includes('FIXME')) {\n          return match;\n        }\n        return '';\n      }\n    );\n\n    // Clean up any multiple blank lines created by comment removal\n    newContent = newContent.replace(/\\n\\s*\\n\\s*\\n/g, '\\n\\n');\n\n    // If the file was modified, save it\n    if(newContent !== fileContent) {\n      writeFileSync(filePath, newContent, 'utf8');\n      log(`Removed comments from ${filePath}`, 'info', quiet);\n      return true;\n    }\n\n    return false;\n  } catch(error) {\n    log(`Error removing comments from ${filePath}: ${error.message}`, 'error', quiet);\n    return false;\n  }\n};\n\nexport const lint = async (cmd: LintOptions & {'remove-comments'?: boolean}, callback: LintCallback = process.exit): Promise<number> => {\n  const {\n    cliName = 'Lex',\n    fix = false,\n    debug = false,\n    quiet = false,\n    config = null,\n    removeComments = false,\n    'remove-comments': removeCommentsFlag = false\n  } = cmd;\n\n  const shouldRemoveComments = removeComments || removeCommentsFlag;\n\n  log(`${cliName} linting...`, 'info', quiet);\n\n  const cwd = process.cwd();\n  const spinner = createSpinner(quiet);\n\n  await loadAIConfig(cwd, quiet, debug);\n\n  let tempConfigPath: string | null = null;\n\n  try {\n    const useTypescript = detectTypeScript(cwd);\n    log(`TypeScript ${useTypescript ? 'detected' : 'not detected'} from tsconfig.json`, 'info', quiet);\n\n    if(useTypescript) {\n      LexConfig.checkLintTypescriptConfig();\n    }\n\n    ensureModuleType(cwd);\n\n    await installDependencies(cwd, useTypescript, quiet);\n\n    const projectConfigPath = pathResolve(cwd, 'eslint.config.mjs');\n    const projectConfigPathTs = pathResolve(cwd, 'eslint.config.ts');\n    const hasEslintConfig = existsSync(projectConfigPath) ||\n      existsSync(projectConfigPathTs) ||\n      existsSync(pathResolve(cwd, '.eslintrc.js')) ||\n      existsSync(pathResolve(cwd, '.eslintrc.json')) ||\n      existsSync(pathResolve(cwd, '.eslintrc.yml')) ||\n      existsSync(pathResolve(cwd, '.eslintrc.yaml')) ||\n      existsSync(pathResolve(cwd, '.eslintrc'));\n\n    const hasLexEslintConfig = await loadESLintConfig(cwd, quiet, debug);\n\n    if(hasLexEslintConfig) {\n      log('Using ESLint configuration from lex.config.* file', 'info', quiet);\n    }\n\n    if(existsSync(pathResolve(cwd, '.eslintrc.json'))) {\n      unlinkSync(pathResolve(cwd, '.eslintrc.json'));\n    }\n\n    let lexConfigPath = '';\n    let shouldCreateTempConfig = false;\n\n    if(!hasEslintConfig && !hasLexEslintConfig) {\n      const possiblePaths = [\n        pathResolve(currentDirname, '../../../../eslint.config.ts'),\n        pathResolve(currentDirname, '../../../../eslint.config.jms'),\n        pathResolve(process.env.LEX_HOME || './node_modules/@nlabs/lex', 'eslint.config.ts'),\n        pathResolve(process.env.LEX_HOME || './node_modules/@nlabs/lex', 'eslint.config.mjs')\n      ];\n\n      for(const path of possiblePaths) {\n        if(existsSync(path)) {\n          lexConfigPath = path;\n          break;\n        }\n      }\n\n      if(debug) {\n        log(`Current directory: ${currentDirname}`, 'info', quiet);\n        log(`Project config path: ${projectConfigPath}`, 'info', quiet);\n        log(`Project config exists: ${hasEslintConfig}`, 'info', quiet);\n        log(`Found Lex config: ${lexConfigPath}`, 'info', quiet);\n        log(`Lex config exists: ${!!lexConfigPath && existsSync(lexConfigPath)}`, 'info', quiet);\n      }\n\n      if(lexConfigPath && existsSync(lexConfigPath)) {\n        log('No ESLint configuration found in project. Using Lex\\'s default configuration.', 'info', quiet);\n      } else {\n        shouldCreateTempConfig = true;\n      }\n    }\n\n    if(config) {\n      const userConfigPath = pathResolve(cwd, config);\n      if(existsSync(userConfigPath)) {\n        log(`Using specified ESLint configuration: ${config}`, 'info', quiet);\n        shouldCreateTempConfig = false;\n      } else {\n        log(`Specified ESLint configuration not found: ${config}. Using Lex's default configuration.`, 'warn', quiet);\n      }\n    }\n\n    if(shouldCreateTempConfig) {\n      log('No ESLint configuration found. Creating a temporary configuration...', 'info', quiet);\n      const configResult = createDefaultESLintConfig(useTypescript, cwd);\n      tempConfigPath = configResult.configPath;\n    }\n\n    let eslintOutput = '';\n    const captureOutput = (output: string) => {\n      eslintOutput += `${output}\\n`;\n    };\n\n    const result = await runEslintWithLex(cwd, quiet, cliName, true, debug, useTypescript, captureOutput);\n\n    if(shouldRemoveComments) {\n      spinner.start('Removing comments from files...');\n\n      const glob = await import('glob');\n      const files = glob.sync('{src,lib}/**/*.{js,jsx,ts,tsx}', {\n        cwd,\n        ignore: ['**/node_modules/**', '**/lib/**', '**/dist/**', '**/build/**']\n      });\n\n      let processedCount = 0;\n      for(const file of files) {\n        const filePath = pathResolve(cwd, file);\n        if(removeFileComments(filePath, quiet)) {\n          processedCount++;\n        }\n      }\n\n      spinner.succeed(`Removed comments from ${processedCount} files`);\n    }\n\n    if(result !== 0 && fix) {\n      const aiConfigured = LexConfig.config.ai?.provider && LexConfig.config.ai.provider !== 'none';\n\n      if(aiConfigured) {\n        log('Applying AI fixes to remaining issues...', 'info', quiet);\n        await applyAIFix(cwd, eslintOutput, quiet);\n\n        const afterFixResult = await runEslintWithLex(cwd, quiet, cliName, false, debug, useTypescript);\n\n        callback(afterFixResult);\n        return afterFixResult;\n      }\n      log('ESLint could not fix all issues automatically.', 'warn', quiet);\n      log('To enable AI-powered fixes, add AI configuration to your lex.config file:', 'info', quiet);\n      log(`\n// In lex.config.js (or lex.config.mjs, lex.config.cjs, etc.)\nexport default {\n  // Your existing config\n  ai: {\n    provider: 'cursor' // or 'openai', 'anthropic', etc.\n    // Additional provider-specific settings\n  }\n};`, 'info', quiet);\n    }\n\n    callback(result);\n    return result;\n  } catch(error) {\n    log(`\\n${cliName} Error: ${error.message}`, 'error', quiet);\n    if(spinner) {\n      spinner.fail('Linting failed!');\n    }\n    callback(1);\n    return 1;\n  } finally {\n    const tempFilePaths = [\n      tempConfigPath,\n      pathResolve(cwd, '.lex-temp-eslint.cjs'),\n      pathResolve(cwd, '.lex-temp-default-eslint.cjs')\n    ];\n\n    for(const filePath of tempFilePaths) {\n      if(filePath && existsSync(filePath)) {\n        try {\n          unlinkSync(filePath);\n          if(debug) {\n            log(`Cleaned up temporary ESLint config at ${filePath}`, 'info', quiet);\n          }\n        } catch{\n        }\n      }\n    }\n  }\n};"],"names":["execa","existsSync","readFileSync","unlinkSync","writeFileSync","dirname","resolve","pathResolve","extname","LexConfig","createSpinner","resolveBinaryPath","log","currentFilename","currentDirname","eval","process","cwd","createDefaultESLintConfig","useTypescript","configPath","originalConfig","configContent","detectTypeScript","ensureModuleType","packageJsonPath","packageJsonContent","packageJson","JSON","parse","type","_error","installDependencies","quiet","runEslintWithLex","cliName","fix","debug","captureOutput","spinner","projectConfigPath","projectConfigPathTs","hasProjectConfig","hasLexConfigEslint","config","eslint","Object","keys","length","possiblePaths","env","LEX_HOME","lexConfigPath","path","tempConfigPath","stringify","eslintBinary","baseEslintArgs","configArgs","jsResult","reject","shell","stdio","stdout","console","stderr","error","tsResult","exitCode","message","eslintNotFound","includes","fail","succeed","noFilesFound","applyAIFix","errors","start","fileErrorMap","Map","lines","split","currentFile","line","match","trim","has","set","errorArray","get","push","size","sections","section","filePath","i","filePathRegex","filePaths","knownFiles","file","isCursorIDE","ai","provider","CURSOR_IDE","prompt","promptFile","wasModified","applyDirectFixes","fileErrors","callAIService","fileContent","join","fixedContent","newContent","replace","loadAIConfig","configFormats","configBaseName","format","potentialPath","slice","importPath","url","URL","href","urlError","lexConfig","importError","configData","default","loadESLintConfig","fileFormat","removeFileComments","lint","cmd","callback","exit","removeComments","removeCommentsFlag","shouldRemoveComments","checkLintTypescriptConfig","hasEslintConfig","hasLexEslintConfig","shouldCreateTempConfig","userConfigPath","configResult","eslintOutput","output","result","glob","files","sync","ignore","processedCount","aiConfigured","afterFixResult","tempFilePaths"],"mappings":"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"}