@nlabs/lex 1.48.7 → 1.49.0

package/lib/commands/lint/lint.js

@@ -0,0 +1,993 @@
+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();
+}
+const createDefaultESLintConfig = (useTypescript, cwd) => {
+  const configPath = pathResolve(cwd, ".lex-temp-default-eslint.cjs");
+  const originalConfig = null;
+  const possiblePaths = [
+    pathResolve(currentDirname, "eslint.config.ts"),
+    pathResolve(currentDirname, "eslint.config.js"),
+    pathResolve(process.env.LEX_HOME || "./node_modules/@nlabs/lex", "eslint.config.ts"),
+    pathResolve(process.env.LEX_HOME || "./node_modules/@nlabs/lex", "eslint.config.js")
+  ];
+  let foundConfig = "";
+  for (const path of possiblePaths) {
+    if (existsSync(path)) {
+      foundConfig = path;
+      break;
+    }
+  }
+  const configContent = `// Temporary ESLint config generated by Lex
+const lexConfig = require('@nlabs/lex/eslint.config.js');
+
+module.exports = lexConfig;`;
+  writeFileSync(configPath, configContent, "utf8");
+  return {
+    configPath,
+    originalConfig
+  };
+};
+const createBasicESLintConfig = (useTypescript) => {
+  const config = `// ESLint configuration
+import lexConfig from '@nlabs/lex/eslint.config.js';
+
+return lexConfig;`;
+  return config;
+};
+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 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.js");
+    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.js"),
+      pathResolve(currentDirname, "../../../../eslint.config.ts"),
+      pathResolve(process.env.LEX_HOME || "/usr/local/lib/node_modules/@nlabs/lex", "eslint.config.js"),
+      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 = "";
+    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 lexConfig = require('@nlabs/lex/eslint.config.js');
+const userConfig = ${JSON.stringify(LexConfig.config.eslint, null, 2)};
+
+// Merge Lex's config with user config
+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
+const lexConfig = require('@nlabs/lex/eslint.config.js');
+
+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
+    ], {
+      reject: false,
+      stdio: "pipe",
+      cwd,
+      shell: true
+    });
+    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, stdout: "", stderr: "" };
+    if (useTypescript) {
+      tsResult = await execa(eslintBinary, [
+        "src/**/*.{ts,tsx}",
+        ...configArgs,
+        ...baseEslintArgs
+      ], {
+        reject: false,
+        stdio: "pipe",
+        cwd,
+        shell: true
+      });
+      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);
+        }
+      } catch (error) {
+        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(`
+${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(`
+${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:
+1. Fixing naming conventions
+2. Fixing sort-keys issues
+3. Replacing console.log with log utility
+4. Fixing no-plusplus issues
+5. Fixing unnecessary escape characters
+6. Fixing other ESLint errors
+
+CRITICAL REQUIREMENTS:
+- ONLY fix the specific lines with ESLint errors
+- DO NOT modify any other lines of code
+- DO NOT remove line breaks unless they are specifically causing ESLint errors
+- DO NOT condense multi-line structures to single lines
+- PRESERVE all existing line breaks and formatting that is not causing errors
+
+SPECIFIC FORMATTING RULES:
+- Maintain proper indentation (2 spaces)
+- Keep line breaks between class/interface declaration and their members
+- Keep line breaks between methods
+- Ensure there is a line break after opening braces for classes, interfaces, and methods
+- DO NOT place class/interface properties or methods on the same line as the opening brace
+- Preserve empty lines between logical code blocks
+- PRESERVE multi-line imports - do not condense them to single lines
+- PRESERVE multi-line object/array declarations - do not condense them to single lines
+
+SORT-KEYS RULE (HIGHEST PRIORITY):
+- All object literal keys MUST be sorted alphabetically in ascending order
+- This applies to ALL objects in the file, not just those with explicit sort-keys errors
+- Example: {b: 2, a: 1, c: 3} should become {a: 1, b: 2, c: 3}
+- Preserve the original formatting and line breaks when sorting
+
+Example of CORRECT formatting (DO NOT CHANGE):
+export class UserConstants {
+  static readonly ADD_ITEM_ERROR: string = 'USER_ADD_ITEM_ERROR';
+  static readonly OTHER_CONSTANT: string = 'OTHER_CONSTANT';
+}
+
+constructor(flux: FluxFramework, CustomAdapter: typeof Event = Event) {
+  this.CustomAdapter = CustomAdapter;
+  this.flux = flux;
+}
+
+import {
+  app,
+  events,
+  images,
+  locations,
+  messages,
+  posts,
+  tags,
+  users,
+  websocket
+} from './stores';
+
+const config = {
+  apiKey: 'value',
+  baseUrl: 'https://api.example.com',
+  timeout: 5000
+};
+
+Example of INCORRECT formatting (FIX THIS):
+export class UserConstants {static readonly ADD_ITEM_ERROR: string = 'USER_ADD_ITEM_ERROR';
+  static readonly OTHER_CONSTANT: string = 'OTHER_CONSTANT';
+}
+
+constructor(flux: FluxFramework, CustomAdapter: typeof Event = Event) {this.CustomAdapter = CustomAdapter;
+  this.flux = flux;}
+
+import {app, events, images, locations, messages, posts, tags, users, websocket} from './stores';
+
+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], {
+              reject: false,
+              stdio: "pipe",
+              cwd
+            });
+            try {
+              unlinkSync(promptFile);
+            } catch (_error) {
+            }
+            log(`Applied Cursor AI fixes to ${filePath}`, "info", quiet);
+          } catch (error) {
+            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:
+\`\`\`
+${fileContent}
+\`\`\`
+
+CRITICAL REQUIREMENTS:
+- ONLY fix the specific lines with ESLint errors
+- DO NOT modify any other lines of code
+- DO NOT remove line breaks unless they are specifically causing ESLint errors
+- DO NOT condense multi-line structures to single lines
+- PRESERVE all existing line breaks and formatting that is not causing errors
+
+SPECIFIC FORMATTING RULES:
+- Maintain proper indentation (2 spaces)
+- Keep line breaks between class/interface declaration and their members
+- Keep line breaks between methods
+- Ensure there is a line break after opening braces for classes, interfaces, and methods
+- DO NOT place class/interface properties or methods on the same line as the opening brace
+- Preserve empty lines between logical code blocks
+- PRESERVE multi-line imports - do not condense them to single lines
+- PRESERVE multi-line object/array declarations - do not condense them to single lines
+
+SORT-KEYS RULE (HIGHEST PRIORITY):
+- All object literal keys MUST be sorted alphabetically in ascending order
+- This applies to ALL objects in the file, not just those with explicit sort-keys errors
+- Example: {b: 2, a: 1, c: 3} should become {a: 1, b: 2, c: 3}
+- Preserve the original formatting and line breaks when sorting
+
+WHAT TO FIX:
+1. Sorting all object keys alphabetically (sort-keys rule) - ALL objects must have sorted keys
+2. Fixing naming conventions - ONLY for variables/functions with naming errors
+3. Replacing console.log with log utility - ONLY for console.log statements
+4. Fixing no-plusplus issues - ONLY for ++/-- operators
+5. Fixing unnecessary escape characters - ONLY for escaped characters that don't need escaping
+6. Proper indentation and spacing - ONLY where specifically required by errors
+7. String quotes consistency (use single quotes) - ONLY for string literals with quote errors
+8. Import order and spacing - ONLY for imports with order/spacing errors
+9. Function parameter formatting - ONLY for functions with parameter errors
+10. Variable naming conventions - ONLY for variables with naming errors
+11. No unused variables or imports - ONLY for unused variables/imports
+12. Avoiding nested ternaries - ONLY for nested ternary expressions
+13. Any other ESLint errors - ONLY for the specific errors listed above
+
+WHAT NOT TO FIX:
+- Do not change properly formatted multi-line structures
+- Do not remove line breaks that are not causing errors
+- Do not change indentation that is already correct
+- Do not modify spacing that is already correct
+- Do not condense readable multi-line code to single lines
+- Do not modify code that is not mentioned in the ESLint errors
+
+Example of CORRECT formatting (DO NOT CHANGE):
+export class UserConstants {
+  static readonly ADD_ITEM_ERROR: string = 'USER_ADD_ITEM_ERROR';
+  static readonly OTHER_CONSTANT: string = 'OTHER_CONSTANT';
+}
+
+constructor(flux: FluxFramework, CustomAdapter: typeof Event = Event) {
+  this.CustomAdapter = CustomAdapter;
+  this.flux = flux;
+}
+
+import {
+  app,
+  events,
+  images,
+  locations,
+  messages,
+  posts,
+  tags,
+  users,
+  websocket
+} from './stores';
+
+const config = {
+  apiKey: 'value',
+  baseUrl: 'https://api.example.com',
+  timeout: 5000
+};
+
+Example of INCORRECT formatting (FIX THIS):
+export class UserConstants {static readonly ADD_ITEM_ERROR: string = 'USER_ADD_ITEM_ERROR';
+  static readonly OTHER_CONSTANT: string = 'OTHER_CONSTANT';
+}
+
+constructor(flux: FluxFramework, CustomAdapter: typeof Event = Event) {this.CustomAdapter = CustomAdapter;
+  this.flux = flux;}
+
+import {app, events, images, locations, messages, posts, tags, users, websocket} from './stores';
+
+const config = {baseUrl: 'https://api.example.com', apiKey: 'value', timeout: 5000};
+
+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);
+            }
+          } 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);
+    }
+  }
+};
+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 = '\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 (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;
+  }
+};
+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) {
+    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 };
+      }
+    } catch (error) {
+      log(`Error loading AI configuration from ${lexConfigPath}: ${error.message}`, "warn", quiet);
+      if (debug) {
+        console.error(error);
+      }
+    }
+  }
+};
+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;
+            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;
+        }
+        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;
+    }
+    const ext = extname(filePath);
+    let isTypeScript = false;
+    let isJavaScript = false;
+    if ([".ts", ".tsx"].includes(ext)) {
+      isTypeScript = true;
+    } else if ([".js", ".jsx"].includes(ext)) {
+      isJavaScript = true;
+    } else {
+      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,
+    // Handle kebab-case CLI flag conversion
+    "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.js");
+    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.js"),
+        pathResolve(process.env.LEX_HOME || "./node_modules/@nlabs/lex", "eslint.config.ts"),
+        pathResolve(process.env.LEX_HOME || "./node_modules/@nlabs/lex", "eslint.config.js")
+      ];
+      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/**", "**/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
+  ai: {
+    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 (_error) {
+        }
+      }
+    }
+  }
+};
+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  // Try to locate Lex's ESLint config\n  const possiblePaths = [\n    pathResolve(currentDirname, 'eslint.config.ts'),\n    pathResolve(currentDirname, 'eslint.config.js'),\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.js')\n  ];\n\n  let foundConfig = '';\n\n  for(const path of possiblePaths) {\n    if(existsSync(path)) {\n      foundConfig = path;\n      break;\n    }\n  }\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.js');\n\nmodule.exports = lexConfig;`;\n\n  writeFileSync(configPath, configContent, 'utf8');\n\n  return {\n    configPath,\n    originalConfig\n  };\n};\n\nconst createBasicESLintConfig = (useTypescript: boolean): string => {\n  // Create a simplified config that extends Lex's ESLint config\n  const config = `// ESLint configuration\nimport lexConfig from '@nlabs/lex/eslint.config.js';\n\nreturn lexConfig;`;\n  return config;\n};\n\n/**\n * Check if TypeScript is being used by looking for tsconfig.json\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.js');\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.js'),\n      pathResolve(currentDirname, '../../../../eslint.config.ts'),\n      pathResolve(process.env.LEX_HOME || '/usr/local/lib/node_modules/@nlabs/lex', 'eslint.config.js'),\n      pathResolve(process.env.LEX_HOME || '/usr/local/lib/node_modules/@nlabs/lex', 'eslint.config.ts')\n    ];\n\n    let lexConfigPath = '';\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.js\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.js');\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.js');\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      reject: false,\n      stdio: 'pipe',\n      cwd,\n      shell: true\n    });\n\n    if(jsResult.stdout) {\n      console.log(jsResult.stdout);\n      if(captureOutput) {\n        captureOutput(jsResult.stdout);\n      }\n    }\n\n    if(jsResult.stderr) {\n      console.error(jsResult.stderr);\n      if(captureOutput) {\n        captureOutput(jsResult.stderr);\n      }\n    }\n\n    let tsResult: any = {exitCode: 0, stdout: '', stderr: ''};\n    if(useTypescript) {\n      tsResult = await execa(eslintBinary, [\n        'src/**/*.{ts,tsx}',\n        ...configArgs,\n        ...baseEslintArgs\n      ], {\n        reject: false,\n        stdio: 'pipe',\n        cwd,\n        shell: true\n      });\n\n      if(tsResult.stdout) {\n        console.log(tsResult.stdout);\n      }\n\n      if(tsResult.stderr) {\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              reject: false,\n              stdio: 'pipe',\n              cwd\n            });\n\n            try {\n              unlinkSync(promptFile);\n            } catch (_error) {\n            }\n\n            log(`Applied Cursor AI fixes to ${filePath}`, 'info', quiet);\n          } catch (error) {\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\n/**\n * Removes comments from a file except for TODOs and copyright notices\n */\nconst removeFileComments = (filePath: string, quiet: boolean): boolean => {\n  try {\n    const fileContent = readFileSync(filePath, 'utf8');\n\n    // Skip files that are too large to avoid performance issues\n    if(fileContent.length > 1000000) { // 1MB limit\n      log(`Skipping comment removal for large file: ${filePath}`, 'info', quiet);\n      return false;\n    }\n\n    // Determine file type from extension\n    const ext = extname(filePath);\n    let isTypeScript = false;\n    let isJavaScript = false;\n\n    if(['.ts', '.tsx'].includes(ext)) {\n      isTypeScript = true;\n    } else if(['.js', '.jsx'].includes(ext)) {\n      isJavaScript = true;\n    } else {\n      // Skip unsupported file types\n      return false;\n    }\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    // Handle kebab-case CLI flag conversion\n    'remove-comments': removeCommentsFlag = false\n  } = cmd;\n\n  // Use either the camelCase or kebab-case version of the flag\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.js');\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    // Check for ESLint config in lex.config.*\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.js'),\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.js')\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    // Remove comments if enabled\n    if(shouldRemoveComments) {\n      spinner.start('Removing comments from files...');\n\n      // Get all .js, .jsx, .ts, .tsx files in the project\n      const glob = await import('glob');\n      const files = glob.sync('{src,lib}/**/*.{js,jsx,ts,tsx}', {\n        cwd,\n        ignore: ['**/node_modules/**', '**/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    // Clean up temporary config files\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 (_error) {\n          // Ignore errors\n        }\n      }\n    }\n  }\n};"],
  "mappings": "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",
  "names": ["lines"]
}
