@nlabs/lex 1.49.5 → 1.50.1

package/lib/utils/aiService.js

@@ -1,25 +1,33 @@
-import { existsSync, readFileSync, writeFileSync } from "fs";
-import { resolve as pathResolve } from "path";
-import readline from "readline";
-import { LexConfig } from "../LexConfig.js";
-import { createSpinner } from "./app.js";
-import { log } from "./log.js";
-const callCursorAI = async (prompt, _options) => {
-  try {
-    log("Using Cursor IDE for AI fixes...", "info");
-    log("AI fix requested via Cursor IDE", "info");
-    const taskMatch = prompt.match(/^(Generate code according to the following request|Explain the following code|Generate comprehensive unit tests|Analyze the following code|Provide guidance on the following development question):/);
-    const task = taskMatch ? taskMatch[1] : "";
-    const isGenerateTask = task.startsWith("Generate code");
-    const questionMatch = prompt.match(/(?:Generate code according to the following request|Explain the following code|Generate comprehensive unit tests|Analyze the following code|Provide guidance on the following development question):\s*([\s\S]+?)(?:===CONTEXT===|$)/);
-    const question = questionMatch ? questionMatch[1].trim() : prompt;
-    if (question.toLowerCase().includes("how many files") && prompt.includes("Project structure:")) {
-      const projectStructure = prompt.split("Project structure:")[1] || "";
-      const files = projectStructure.trim().split("\n");
-      return `Based on the project structure provided, there are ${files.length} files in the project.`;
-    }
-    if (isGenerateTask) {
-      return `
+/**
+ * Copyright (c) 2022-Present, Nitrogen Labs, Inc.
+ * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
+ */ import { existsSync, readFileSync, writeFileSync } from 'fs';
+import { resolve as pathResolve } from 'path';
+import readline from 'readline';
+import { LexConfig } from '../LexConfig.js';
+import { createSpinner } from './app.js';
+import { log } from './log.js';
+// Cursor IDE integration
+export const callCursorAI = async (prompt, _options)=>{
+    try {
+        // When running within Cursor IDE, we can write the prompt to a temporary file
+        // that Cursor can use to provide AI assistance
+        log('Using Cursor IDE for AI fixes...', 'info');
+        // For now, just log the prompt and return a placeholder
+        // In a real implementation, Cursor would handle this automatically
+        log('AI fix requested via Cursor IDE', 'info');
+        const taskMatch = prompt.match(/^(Generate code according to the following request|Explain the following code|Generate comprehensive unit tests|Analyze the following code|Provide guidance on the following development question):/);
+        const task = taskMatch ? taskMatch[1] : '';
+        const isGenerateTask = task.startsWith('Generate code');
+        const questionMatch = prompt.match(/(?:Generate code according to the following request|Explain the following code|Generate comprehensive unit tests|Analyze the following code|Provide guidance on the following development question):\s*([\s\S]+?)(?:===CONTEXT===|$)/);
+        const question = questionMatch ? questionMatch[1].trim() : prompt;
+        if (question.toLowerCase().includes('how many files') && prompt.includes('Project structure:')) {
+            const projectStructure = prompt.split('Project structure:')[1] || '';
+            const files = projectStructure.trim().split('\n');
+            return `Based on the project structure provided, there are ${files.length} files in the project.`;
+        }
+        if (isGenerateTask) {
+            return `
 # Code Generation Request: "${question}"
 
 To generate code using Cursor's AI capabilities:
@@ -49,8 +57,8 @@ The current CLI integration doesn't have direct access to Cursor's code generati
    Install: \`npm install -g @cursor/cli\`
    Run: \`cursor ai "${question}"\`
 `;
-    }
-    return `
+        }
+        return `
 To use Cursor's AI capabilities for "${question}", you need to:
 
 1. Open your project in Cursor IDE (https://cursor.sh)
@@ -79,221 +87,226 @@ Then set your API key as an environment variable:
 export OPENAI_API_KEY=your_key_here
 \`\`\`
 `;
-  } catch (error) {
-    throw new Error(`Cursor AI error: ${error.message}`);
-  }
-};
-const callOpenAIAI = async (prompt, options) => {
-  try {
-    const apiKey = options.apiKey || process.env.OPENAI_API_KEY;
-    if (!apiKey) {
-      throw new Error("OpenAI API key is required. Set it in your lex.config file or as OPENAI_API_KEY environment variable.");
-    }
-    const response = await fetch("https://api.openai.com/v1/chat/completions", {
-      body: JSON.stringify({
-        max_tokens: options.maxTokens || 4e3,
-        messages: [
-          { content: "You are a helpful assistant that fixes ESLint errors in code.", role: "system" },
-          { content: prompt, role: "user" }
-        ],
-        model: options.model || "gpt-4o",
-        temperature: options.temperature || 0.1
-      }),
-      headers: {
-        Authorization: `Bearer ${apiKey}`,
-        "Content-Type": "application/json"
-      },
-      method: "POST"
-    });
-    if (!response.ok) {
-      const error = await response.json();
-      throw new Error(`OpenAI API error: ${error.error?.message || response.statusText}`);
+    } catch (error) {
+        throw new Error(`Cursor AI error: ${error.message}`);
     }
-    const data = await response.json();
-    return data.choices[0].message.content;
-  } catch (error) {
-    throw new Error(`OpenAI AI error: ${error.message}`);
-  }
 };
-const callAnthropicAI = async (prompt, options) => {
-  try {
-    const apiKey = options.apiKey || process.env.ANTHROPIC_API_KEY;
-    if (!apiKey) {
-      throw new Error("Anthropic API key is required. Set it in your lex.config file or as ANTHROPIC_API_KEY environment variable.");
+export const callOpenAIAI = async (prompt, options)=>{
+    try {
+        const apiKey = options.apiKey || process.env.OPENAI_API_KEY;
+        if (!apiKey) {
+            throw new Error('OpenAI API key is required. Set it in your lex.config file or as OPENAI_API_KEY environment variable.');
+        }
+        const response = await fetch('https://api.openai.com/v1/chat/completions', {
+            body: JSON.stringify({
+                max_tokens: options.maxTokens || 4000,
+                messages: [
+                    {
+                        content: 'You are a helpful assistant that fixes ESLint errors in code.',
+                        role: 'system'
+                    },
+                    {
+                        content: prompt,
+                        role: 'user'
+                    }
+                ],
+                model: options.model || 'gpt-4o',
+                temperature: options.temperature || 0.1
+            }),
+            headers: {
+                Authorization: `Bearer ${apiKey}`,
+                'Content-Type': 'application/json'
+            },
+            method: 'POST'
+        });
+        if (!response.ok) {
+            const error = await response.json();
+            throw new Error(`OpenAI API error: ${error.error?.message || response.statusText}`);
+        }
+        const data = await response.json();
+        return data.choices[0].message.content;
+    } catch (error) {
+        throw new Error(`OpenAI AI error: ${error.message}`);
     }
-    const response = await fetch("https://api.anthropic.com/v1/messages", {
-      body: JSON.stringify({
-        max_tokens: options.maxTokens || 4e3,
-        messages: [
-          { content: prompt, role: "user" }
-        ],
-        model: options.model || "claude-3-sonnet-20240229",
-        temperature: options.temperature || 0.1
-      }),
-      headers: {
-        "Content-Type": "application/json",
-        "anthropic-version": "2023-06-01",
-        "x-api-key": apiKey
-      },
-      method: "POST"
-    });
-    if (!response.ok) {
-      const error = await response.json();
-      throw new Error(`Anthropic API error: ${error.error?.message || response.statusText}`);
+};
+export const callAnthropicAI = async (prompt, options)=>{
+    try {
+        const apiKey = options.apiKey || process.env.ANTHROPIC_API_KEY;
+        if (!apiKey) {
+            throw new Error('Anthropic API key is required. Set it in your lex.config file or as ANTHROPIC_API_KEY environment variable.');
+        }
+        const response = await fetch('https://api.anthropic.com/v1/messages', {
+            body: JSON.stringify({
+                max_tokens: options.maxTokens || 4000,
+                messages: [
+                    {
+                        content: prompt,
+                        role: 'user'
+                    }
+                ],
+                model: options.model || 'claude-3-sonnet-20240229',
+                temperature: options.temperature || 0.1
+            }),
+            headers: {
+                'Content-Type': 'application/json',
+                'anthropic-version': '2023-06-01',
+                'x-api-key': apiKey
+            },
+            method: 'POST'
+        });
+        if (!response.ok) {
+            const error = await response.json();
+            throw new Error(`Anthropic API error: ${error.error?.message || response.statusText}`);
+        }
+        const data = await response.json();
+        return data.content[0].text;
+    } catch (error) {
+        throw new Error(`Anthropic AI error: ${error.message}`);
     }
-    const data = await response.json();
-    return data.content[0].text;
-  } catch (error) {
-    throw new Error(`Anthropic AI error: ${error.message}`);
-  }
 };
-const callCopilotAI = async (prompt, _options) => {
-  try {
-    log("GitHub Copilot AI fixes not directly supported. Using manual fix mode.", "info");
-    return prompt;
-  } catch (error) {
-    throw new Error(`GitHub Copilot AI error: ${error.message}`);
-  }
+export const callCopilotAI = async (prompt, _options)=>{
+    try {
+        log('GitHub Copilot AI fixes not directly supported. Using manual fix mode.', 'info');
+        return prompt;
+    } catch (error) {
+        throw new Error(`GitHub Copilot AI error: ${error.message}`);
+    }
 };
-const promptForAIProvider = async (_quiet = false) => {
-  const rl = readline.createInterface({
-    input: process.stdin,
-    output: process.stdout
-  });
-  return new Promise((resolve) => {
-    log("\nNo AI provider configured. Please choose an AI provider:", "info");
-    log("1. Cursor IDE", "info");
-    log("2. OpenAI", "info");
-    log("3. Anthropic", "info");
-    log("4. GitHub Copilot", "info");
-    log("5. None (Skip AI features)", "info");
-    rl.question("Enter your choice (1-5): ", (answer) => {
-      rl.close();
-      switch (answer) {
-        case "1":
-          resolve("cursor");
-          break;
-        case "2":
-          resolve("openai");
-          break;
-        case "3":
-          resolve("anthropic");
-          break;
-        case "4":
-          resolve("copilot");
-          break;
-        default:
-          resolve("none");
-      }
+export const promptForAIProvider = async (_quiet = false)=>{
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout
     });
-  });
-};
-const promptForAPIKey = async (provider, _quiet = false) => {
-  const rl = readline.createInterface({
-    input: process.stdin,
-    output: process.stdout
-  });
-  return new Promise((resolve) => {
-    rl.question(`Please enter your ${provider} API key: `, (answer) => {
-      rl.close();
-      resolve(answer);
+    return new Promise((resolve)=>{
+        log('\nNo AI provider configured. Please choose an AI provider:', 'info');
+        log('1. Cursor IDE', 'info');
+        log('2. OpenAI', 'info');
+        log('3. Anthropic', 'info');
+        log('4. GitHub Copilot', 'info');
+        log('5. None (Skip AI features)', 'info');
+        rl.question('Enter your choice (1-5): ', (answer)=>{
+            rl.close();
+            switch(answer){
+                case '1':
+                    resolve('cursor');
+                    break;
+                case '2':
+                    resolve('openai');
+                    break;
+                case '3':
+                    resolve('anthropic');
+                    break;
+                case '4':
+                    resolve('copilot');
+                    break;
+                default:
+                    resolve('none');
+            }
+        });
     });
-  });
 };
-const getAIService = (provider, _options) => {
-  switch (provider) {
-    case "cursor":
-      return callCursorAI;
-    case "openai":
-      return callOpenAIAI;
-    case "anthropic":
-      return callAnthropicAI;
-    case "copilot":
-      return callCopilotAI;
-    default:
-      return async () => "No AI provider configured";
-  }
+export const promptForAPIKey = async (provider, _quiet = false)=>{
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout
+    });
+    return new Promise((resolve)=>{
+        rl.question(`Please enter your ${provider} API key: `, (answer)=>{
+            rl.close();
+            resolve(answer);
+        });
+    });
 };
-const callAIService = async (prompt, quiet = false) => {
-  const spinner = createSpinner(quiet);
-  spinner.start("Calling AI service to fix code issues...");
-  try {
-    const aiConfig = LexConfig.config.ai || { provider: "none" };
-    const isInCursorIDE = process.env.CURSOR_IDE === "true";
-    if (isInCursorIDE && (aiConfig.provider === "none" || !aiConfig.provider)) {
-      log("Detected Cursor IDE environment, using Cursor as AI provider", "info", quiet);
-      aiConfig.provider = "cursor";
+export const getAIService = (provider, _options)=>{
+    switch(provider){
+        case 'cursor':
+            return callCursorAI;
+        case 'openai':
+            return callOpenAIAI;
+        case 'anthropic':
+            return callAnthropicAI;
+        case 'copilot':
+            return callCopilotAI;
+        default:
+            return async ()=>'No AI provider configured';
     }
-    if (aiConfig.provider === "none") {
-      const provider = await promptForAIProvider(quiet);
-      if (provider === "none") {
-        spinner.fail("AI features skipped");
-        return "";
-      }
-      aiConfig.provider = provider;
-      if (provider !== "cursor" && provider !== "copilot" && !process.env[`${provider.toUpperCase()}_API_KEY`]) {
-        aiConfig.apiKey = await promptForAPIKey(provider, quiet);
-      }
-      LexConfig.config.ai = aiConfig;
-      const configFormats = ["js", "mjs", "cjs", "ts", "json"];
-      const configBaseName = "lex.config";
-      let configPath = "";
-      for (const format of configFormats) {
-        const potentialPath = pathResolve(process.cwd(), `./${configBaseName}.${format}`);
-        if (existsSync(potentialPath)) {
-          configPath = potentialPath;
-          break;
+};
+export const callAIService = async (prompt, quiet = false)=>{
+    const spinner = createSpinner(quiet);
+    spinner.start('Calling AI service to fix code issues...');
+    try {
+        const aiConfig = LexConfig.config.ai || {
+            provider: 'none'
+        };
+        const isInCursorIDE = process.env.CURSOR_IDE === 'true';
+        if (isInCursorIDE && (aiConfig.provider === 'none' || !aiConfig.provider)) {
+            log('Detected Cursor IDE environment, using Cursor as AI provider', 'info', quiet);
+            aiConfig.provider = 'cursor';
         }
-      }
-      if (configPath) {
-        try {
-          const configContent = readFileSync(configPath, "utf8");
-          const updatedConfig = configContent.replace(
-            /ai:.*?[,}]/s,
-            `ai: { provider: '${aiConfig.provider}' },`
-          );
-          writeFileSync(configPath, updatedConfig);
-        } catch (_error) {
+        if (aiConfig.provider === 'none') {
+            const provider = await promptForAIProvider(quiet);
+            if (provider === 'none') {
+                spinner.fail('AI features skipped');
+                return '';
+            }
+            aiConfig.provider = provider;
+            if (provider !== 'cursor' && provider !== 'copilot' && !process.env[`${provider.toUpperCase()}_API_KEY`]) {
+                aiConfig.apiKey = await promptForAPIKey(provider, quiet);
+            }
+            LexConfig.config.ai = aiConfig;
+            // Search for config files in multiple formats like LexConfig.parseConfig does
+            const configFormats = [
+                'js',
+                'mjs',
+                'cjs',
+                'ts',
+                'json'
+            ];
+            const configBaseName = 'lex.config';
+            let configPath = '';
+            for (const format of configFormats){
+                const potentialPath = pathResolve(process.cwd(), `./${configBaseName}.${format}`);
+                if (existsSync(potentialPath)) {
+                    configPath = potentialPath;
+                    break;
+                }
+            }
+            if (configPath) {
+                try {
+                    const configContent = readFileSync(configPath, 'utf8');
+                    const updatedConfig = configContent.replace(/ai:.*?[,}]/s, `ai: { provider: '${aiConfig.provider}' },`);
+                    writeFileSync(configPath, updatedConfig);
+                } catch (_error) {}
+            }
         }
-      }
-    }
-    let result = "";
-    switch (aiConfig.provider) {
-      case "cursor":
-        result = await callCursorAI(prompt, aiConfig);
-        log("Cursor IDE AI integration active", "info", quiet);
-        break;
-      case "openai":
-        result = await callOpenAIAI(prompt, aiConfig);
-        break;
-      case "anthropic":
-        result = await callAnthropicAI(prompt, aiConfig);
-        break;
-      case "copilot":
-        result = await callCopilotAI(prompt, aiConfig);
-        break;
-      default:
-        spinner.fail("No AI provider configured");
-        return "";
-    }
-    spinner.succeed("AI code fixes generated successfully");
-    return result;
-  } catch (error) {
-    spinner.fail(`AI service error: ${error.message}`);
-    if (!quiet) {
-      log(error, "error");
+        let result = '';
+        switch(aiConfig.provider){
+            case 'cursor':
+                result = await callCursorAI(prompt, aiConfig);
+                log('Cursor IDE AI integration active', 'info', quiet);
+                break;
+            case 'openai':
+                result = await callOpenAIAI(prompt, aiConfig);
+                break;
+            case 'anthropic':
+                result = await callAnthropicAI(prompt, aiConfig);
+                break;
+            case 'copilot':
+                result = await callCopilotAI(prompt, aiConfig);
+                break;
+            default:
+                spinner.fail('No AI provider configured');
+                return '';
+        }
+        spinner.succeed('AI code fixes generated successfully');
+        return result;
+    } catch (error) {
+        spinner.fail(`AI service error: ${error.message}`);
+        if (!quiet) {
+            log(error, 'error');
+        }
+        return '';
     }
-    return "";
-  }
 };
-export {
-  callAIService,
-  callAnthropicAI,
-  callCopilotAI,
-  callCursorAI,
-  callOpenAIAI,
-  getAIService,
-  promptForAIProvider,
-  promptForAPIKey
-};
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../src/utils/aiService.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 {existsSync, readFileSync, writeFileSync} from 'fs';\nimport {resolve as pathResolve} from 'path';\nimport readline from 'readline';\n\nimport {AIConfig, LexConfig} from '../LexConfig.js';\nimport {createSpinner} from './app.js';\nimport {log} from './log.js';\n\n// Cursor IDE integration\nexport const callCursorAI = async (prompt: string, _options: AIConfig): Promise<string> => {\n  try {\n    // When running within Cursor IDE, we can write the prompt to a temporary file\n    // that Cursor can use to provide AI assistance\n    log('Using Cursor IDE for AI fixes...', 'info');\n\n    // For now, just log the prompt and return a placeholder\n    // In a real implementation, Cursor would handle this automatically\n    log('AI fix requested via Cursor IDE', 'info');\n\n    const taskMatch = prompt.match(/^(Generate code according to the following request|Explain the following code|Generate comprehensive unit tests|Analyze the following code|Provide guidance on the following development question):/);\n    const task = taskMatch ? taskMatch[1] : '';\n    const isGenerateTask = task.startsWith('Generate code');\n\n    const questionMatch = prompt.match(/(?:Generate code according to the following request|Explain the following code|Generate comprehensive unit tests|Analyze the following code|Provide guidance on the following development question):\\s*([\\s\\S]+?)(?:===CONTEXT===|$)/);\n    const question = questionMatch ? questionMatch[1].trim() : prompt;\n\n    if(question.toLowerCase().includes('how many files') && prompt.includes('Project structure:')) {\n      const projectStructure = prompt.split('Project structure:')[1] || '';\n      const files = projectStructure.trim().split('\\n');\n      return `Based on the project structure provided, there are ${files.length} files in the project.`;\n    }\n\n    if(isGenerateTask) {\n      return `\n# Code Generation Request: \"${question}\"\n\nTo generate code using Cursor's AI capabilities:\n\n1. **Open your project in Cursor IDE** (https://cursor.sh)\n2. Press **Cmd+L** (or Ctrl+L on Windows/Linux) to open the AI chat\n3. Type your request: \"${question}\"\n4. Cursor will generate the code directly in your editor\n\nThe current CLI integration doesn't have direct access to Cursor's code generation capabilities.\n\n**Alternative options:**\n\n1. **Use OpenAI or Anthropic directly:**\n   Configure in your lex.config file:\n   \\`\\`\\`js\n   export default {\n     ai: {\n       provider: 'openai',\n       apiKey: process.env.OPENAI_API_KEY,\n       model: 'gpt-4o'\n     }\n   }\n   \\`\\`\\`\n\n2. **Use Cursor's command line tool:**\n   Install: \\`npm install -g @cursor/cli\\`\n   Run: \\`cursor ai \"${question}\"\\`\n`;\n    }\n\n    return `\nTo use Cursor's AI capabilities for \"${question}\", you need to:\n\n1. Open your project in Cursor IDE (https://cursor.sh)\n2. Use Cursor's built-in AI features by pressing Cmd+K or Cmd+L\n3. Or run the 'cursor' command directly from your terminal\n\nThe current integration is limited and doesn't directly access Cursor's AI capabilities.\n\nFor the best experience with AI code generation:\n- Use Cursor IDE directly\n- Or configure OpenAI or Anthropic as your provider in your lex.config file:\n\n\\`\\`\\`js\n// lex.config.js (or lex.config.mjs, lex.config.cjs, etc.)\nexport default {\n  ai: {\n    provider: 'openai', // or 'anthropic'\n    apiKey: process.env.OPENAI_API_KEY, // or ANTHROPIC_API_KEY\n    model: 'gpt-4o' // or 'claude-3-opus'\n  }\n}\n\\`\\`\\`\n\nThen set your API key as an environment variable:\n\\`\\`\\`\nexport OPENAI_API_KEY=your_key_here\n\\`\\`\\`\n`;\n  } catch (error) {\n    throw new Error(`Cursor AI error: ${error.message}`);\n  }\n};\n\nexport const callOpenAIAI = async (prompt: string, options: AIConfig): Promise<string> => {\n  try {\n    const apiKey = options.apiKey || process.env.OPENAI_API_KEY;\n    if(!apiKey) {\n      throw new Error('OpenAI API key is required. Set it in your lex.config file or as OPENAI_API_KEY environment variable.');\n    }\n\n    const response = await fetch('https://api.openai.com/v1/chat/completions', {\n      body: JSON.stringify({\n        max_tokens: options.maxTokens || 4000,\n        messages: [\n          {content: 'You are a helpful assistant that fixes ESLint errors in code.', role: 'system'},\n          {content: prompt, role: 'user'}\n        ],\n        model: options.model || 'gpt-4o',\n        temperature: options.temperature || 0.1\n      }),\n      headers: {\n        Authorization: `Bearer ${apiKey}`,\n        'Content-Type': 'application/json'\n      },\n      method: 'POST'\n    });\n\n    if(!response.ok) {\n      const error = await response.json();\n      throw new Error(`OpenAI API error: ${error.error?.message || response.statusText}`);\n    }\n\n    const data = await response.json();\n    return data.choices[0].message.content;\n  } catch (error) {\n    throw new Error(`OpenAI AI error: ${error.message}`);\n  }\n};\n\nexport const callAnthropicAI = async (prompt: string, options: AIConfig): Promise<string> => {\n  try {\n    const apiKey = options.apiKey || process.env.ANTHROPIC_API_KEY;\n    if(!apiKey) {\n      throw new Error('Anthropic API key is required. Set it in your lex.config file or as ANTHROPIC_API_KEY environment variable.');\n    }\n\n    const response = await fetch('https://api.anthropic.com/v1/messages', {\n      body: JSON.stringify({\n        max_tokens: options.maxTokens || 4000,\n        messages: [\n          {content: prompt, role: 'user'}\n        ],\n        model: options.model || 'claude-3-sonnet-20240229',\n        temperature: options.temperature || 0.1\n      }),\n      headers: {\n        'Content-Type': 'application/json',\n        'anthropic-version': '2023-06-01',\n        'x-api-key': apiKey\n      },\n      method: 'POST'\n    });\n\n    if(!response.ok) {\n      const error = await response.json();\n      throw new Error(`Anthropic API error: ${error.error?.message || response.statusText}`);\n    }\n\n    const data = await response.json();\n    return data.content[0].text;\n  } catch (error) {\n    throw new Error(`Anthropic AI error: ${error.message}`);\n  }\n};\n\nexport const callCopilotAI = async (prompt: string, _options: AIConfig): Promise<string> => {\n  try {\n    log('GitHub Copilot AI fixes not directly supported. Using manual fix mode.', 'info');\n    return prompt;\n  } catch (error) {\n    throw new Error(`GitHub Copilot AI error: ${error.message}`);\n  }\n};\n\nexport const promptForAIProvider = async (_quiet = false): Promise<'cursor' | 'copilot' | 'openai' | 'anthropic' | 'none'> => {\n  const rl = readline.createInterface({\n    input: process.stdin,\n    output: process.stdout\n  });\n\n  return new Promise((resolve) => {\n    log('\\nNo AI provider configured. Please choose an AI provider:', 'info');\n    log('1. Cursor IDE', 'info');\n    log('2. OpenAI', 'info');\n    log('3. Anthropic', 'info');\n    log('4. GitHub Copilot', 'info');\n    log('5. None (Skip AI features)', 'info');\n\n    rl.question('Enter your choice (1-5): ', (answer) => {\n      rl.close();\n\n      switch(answer) {\n        case '1':\n          resolve('cursor');\n          break;\n        case '2':\n          resolve('openai');\n          break;\n        case '3':\n          resolve('anthropic');\n          break;\n        case '4':\n          resolve('copilot');\n          break;\n        default:\n          resolve('none');\n      }\n    });\n  });\n};\n\nexport const promptForAPIKey = async (provider: string, _quiet = false): Promise<string> => {\n  const rl = readline.createInterface({\n    input: process.stdin,\n    output: process.stdout\n  });\n\n  return new Promise((resolve) => {\n    rl.question(`Please enter your ${provider} API key: `, (answer) => {\n      rl.close();\n      resolve(answer);\n    });\n  });\n};\n\nexport const getAIService = (\n  provider: string,\n  _options: AIConfig\n): (prompt: string, options: AIConfig) => Promise<string> => {\n  switch(provider) {\n    case 'cursor':\n      return callCursorAI;\n    case 'openai':\n      return callOpenAIAI;\n    case 'anthropic':\n      return callAnthropicAI;\n    case 'copilot':\n      return callCopilotAI;\n    default:\n      return async () => 'No AI provider configured';\n  }\n};\n\nexport const callAIService = async (prompt: string, quiet = false): Promise<string> => {\n  const spinner = createSpinner(quiet);\n  spinner.start('Calling AI service to fix code issues...');\n\n  try {\n    const aiConfig = LexConfig.config.ai || {provider: 'none'};\n\n    const isInCursorIDE = process.env.CURSOR_IDE === 'true';\n    if(isInCursorIDE && (aiConfig.provider === 'none' || !aiConfig.provider)) {\n      log('Detected Cursor IDE environment, using Cursor as AI provider', 'info', quiet);\n      aiConfig.provider = 'cursor';\n    }\n\n    if(aiConfig.provider === 'none') {\n      const provider = await promptForAIProvider(quiet);\n\n      if(provider === 'none') {\n        spinner.fail('AI features skipped');\n        return '';\n      }\n\n      aiConfig.provider = provider;\n\n      if(provider !== 'cursor' && provider !== 'copilot' &&\n        !process.env[`${provider.toUpperCase()}_API_KEY`]) {\n        aiConfig.apiKey = await promptForAPIKey(provider, quiet);\n      }\n\n      LexConfig.config.ai = aiConfig;\n\n      // Search for config files in multiple formats like LexConfig.parseConfig does\n      const configFormats = ['js', 'mjs', 'cjs', 'ts', 'json'];\n      const configBaseName = 'lex.config';\n      let configPath = '';\n\n      for(const format of configFormats) {\n        const potentialPath = pathResolve(process.cwd(), `./${configBaseName}.${format}`);\n        if(existsSync(potentialPath)) {\n          configPath = potentialPath;\n          break;\n        }\n      }\n\n      if(configPath) {\n        try {\n          const configContent = readFileSync(configPath, 'utf8');\n          const updatedConfig = configContent.replace(\n            /ai:.*?[,}]/s,\n            `ai: { provider: '${aiConfig.provider}' },`\n          );\n          writeFileSync(configPath, updatedConfig);\n        } catch (_error) {\n        }\n      }\n    }\n\n    let result = '';\n\n    switch(aiConfig.provider) {\n      case 'cursor':\n        result = await callCursorAI(prompt, aiConfig);\n        log('Cursor IDE AI integration active', 'info', quiet);\n        break;\n      case 'openai':\n        result = await callOpenAIAI(prompt, aiConfig);\n        break;\n      case 'anthropic':\n        result = await callAnthropicAI(prompt, aiConfig);\n        break;\n      case 'copilot':\n        result = await callCopilotAI(prompt, aiConfig);\n        break;\n      default:\n        spinner.fail('No AI provider configured');\n        return '';\n    }\n\n    spinner.succeed('AI code fixes generated successfully');\n    return result;\n  } catch (error) {\n    spinner.fail(`AI service error: ${error.message}`);\n    if(!quiet) {\n      log(error, 'error');\n    }\n    return '';\n  }\n};"],
  "mappings": "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",
  "names": []
}

+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/utils/aiService.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 {existsSync, readFileSync, writeFileSync} from 'fs';\nimport {resolve as pathResolve} from 'path';\nimport readline from 'readline';\n\nimport {AIConfig, LexConfig} from '../LexConfig.js';\nimport {createSpinner} from './app.js';\nimport {log} from './log.js';\n\n// Cursor IDE integration\nexport const callCursorAI = async (prompt: string, _options: AIConfig): Promise<string> => {\n  try {\n    // When running within Cursor IDE, we can write the prompt to a temporary file\n    // that Cursor can use to provide AI assistance\n    log('Using Cursor IDE for AI fixes...', 'info');\n\n    // For now, just log the prompt and return a placeholder\n    // In a real implementation, Cursor would handle this automatically\n    log('AI fix requested via Cursor IDE', 'info');\n\n    const taskMatch = prompt.match(/^(Generate code according to the following request|Explain the following code|Generate comprehensive unit tests|Analyze the following code|Provide guidance on the following development question):/);\n    const task = taskMatch ? taskMatch[1] : '';\n    const isGenerateTask = task.startsWith('Generate code');\n\n    const questionMatch = prompt.match(/(?:Generate code according to the following request|Explain the following code|Generate comprehensive unit tests|Analyze the following code|Provide guidance on the following development question):\\s*([\\s\\S]+?)(?:===CONTEXT===|$)/);\n    const question = questionMatch ? questionMatch[1].trim() : prompt;\n\n    if(question.toLowerCase().includes('how many files') && prompt.includes('Project structure:')) {\n      const projectStructure = prompt.split('Project structure:')[1] || '';\n      const files = projectStructure.trim().split('\\n');\n      return `Based on the project structure provided, there are ${files.length} files in the project.`;\n    }\n\n    if(isGenerateTask) {\n      return `\n# Code Generation Request: \"${question}\"\n\nTo generate code using Cursor's AI capabilities:\n\n1. **Open your project in Cursor IDE** (https://cursor.sh)\n2. Press **Cmd+L** (or Ctrl+L on Windows/Linux) to open the AI chat\n3. Type your request: \"${question}\"\n4. Cursor will generate the code directly in your editor\n\nThe current CLI integration doesn't have direct access to Cursor's code generation capabilities.\n\n**Alternative options:**\n\n1. **Use OpenAI or Anthropic directly:**\n   Configure in your lex.config file:\n   \\`\\`\\`js\n   export default {\n     ai: {\n       provider: 'openai',\n       apiKey: process.env.OPENAI_API_KEY,\n       model: 'gpt-4o'\n     }\n   }\n   \\`\\`\\`\n\n2. **Use Cursor's command line tool:**\n   Install: \\`npm install -g @cursor/cli\\`\n   Run: \\`cursor ai \"${question}\"\\`\n`;\n    }\n\n    return `\nTo use Cursor's AI capabilities for \"${question}\", you need to:\n\n1. Open your project in Cursor IDE (https://cursor.sh)\n2. Use Cursor's built-in AI features by pressing Cmd+K or Cmd+L\n3. Or run the 'cursor' command directly from your terminal\n\nThe current integration is limited and doesn't directly access Cursor's AI capabilities.\n\nFor the best experience with AI code generation:\n- Use Cursor IDE directly\n- Or configure OpenAI or Anthropic as your provider in your lex.config file:\n\n\\`\\`\\`js\n// lex.config.js (or lex.config.mjs, lex.config.cjs, etc.)\nexport default {\n  ai: {\n    provider: 'openai', // or 'anthropic'\n    apiKey: process.env.OPENAI_API_KEY, // or ANTHROPIC_API_KEY\n    model: 'gpt-4o' // or 'claude-3-opus'\n  }\n}\n\\`\\`\\`\n\nThen set your API key as an environment variable:\n\\`\\`\\`\nexport OPENAI_API_KEY=your_key_here\n\\`\\`\\`\n`;\n  } catch(error) {\n    throw new Error(`Cursor AI error: ${error.message}`);\n  }\n};\n\nexport const callOpenAIAI = async (prompt: string, options: AIConfig): Promise<string> => {\n  try {\n    const apiKey = options.apiKey || process.env.OPENAI_API_KEY;\n    if(!apiKey) {\n      throw new Error('OpenAI API key is required. Set it in your lex.config file or as OPENAI_API_KEY environment variable.');\n    }\n\n    const response = await fetch('https://api.openai.com/v1/chat/completions', {\n      body: JSON.stringify({\n        max_tokens: options.maxTokens || 4000,\n        messages: [\n          {content: 'You are a helpful assistant that fixes ESLint errors in code.', role: 'system'},\n          {content: prompt, role: 'user'}\n        ],\n        model: options.model || 'gpt-4o',\n        temperature: options.temperature || 0.1\n      }),\n      headers: {\n        Authorization: `Bearer ${apiKey}`,\n        'Content-Type': 'application/json'\n      },\n      method: 'POST'\n    });\n\n    if(!response.ok) {\n      const error = await response.json();\n      throw new Error(`OpenAI API error: ${error.error?.message || response.statusText}`);\n    }\n\n    const data = await response.json();\n    return data.choices[0].message.content;\n  } catch(error) {\n    throw new Error(`OpenAI AI error: ${error.message}`);\n  }\n};\n\nexport const callAnthropicAI = async (prompt: string, options: AIConfig): Promise<string> => {\n  try {\n    const apiKey = options.apiKey || process.env.ANTHROPIC_API_KEY;\n    if(!apiKey) {\n      throw new Error('Anthropic API key is required. Set it in your lex.config file or as ANTHROPIC_API_KEY environment variable.');\n    }\n\n    const response = await fetch('https://api.anthropic.com/v1/messages', {\n      body: JSON.stringify({\n        max_tokens: options.maxTokens || 4000,\n        messages: [\n          {content: prompt, role: 'user'}\n        ],\n        model: options.model || 'claude-3-sonnet-20240229',\n        temperature: options.temperature || 0.1\n      }),\n      headers: {\n        'Content-Type': 'application/json',\n        'anthropic-version': '2023-06-01',\n        'x-api-key': apiKey\n      },\n      method: 'POST'\n    });\n\n    if(!response.ok) {\n      const error = await response.json();\n      throw new Error(`Anthropic API error: ${error.error?.message || response.statusText}`);\n    }\n\n    const data = await response.json();\n    return data.content[0].text;\n  } catch(error) {\n    throw new Error(`Anthropic AI error: ${error.message}`);\n  }\n};\n\nexport const callCopilotAI = async (prompt: string, _options: AIConfig): Promise<string> => {\n  try {\n    log('GitHub Copilot AI fixes not directly supported. Using manual fix mode.', 'info');\n    return prompt;\n  } catch(error) {\n    throw new Error(`GitHub Copilot AI error: ${error.message}`);\n  }\n};\n\nexport const promptForAIProvider = async (_quiet = false): Promise<'cursor' | 'copilot' | 'openai' | 'anthropic' | 'none'> => {\n  const rl = readline.createInterface({\n    input: process.stdin,\n    output: process.stdout\n  });\n\n  return new Promise((resolve) => {\n    log('\\nNo AI provider configured. Please choose an AI provider:', 'info');\n    log('1. Cursor IDE', 'info');\n    log('2. OpenAI', 'info');\n    log('3. Anthropic', 'info');\n    log('4. GitHub Copilot', 'info');\n    log('5. None (Skip AI features)', 'info');\n\n    rl.question('Enter your choice (1-5): ', (answer) => {\n      rl.close();\n\n      switch(answer) {\n        case '1':\n          resolve('cursor');\n          break;\n        case '2':\n          resolve('openai');\n          break;\n        case '3':\n          resolve('anthropic');\n          break;\n        case '4':\n          resolve('copilot');\n          break;\n        default:\n          resolve('none');\n      }\n    });\n  });\n};\n\nexport const promptForAPIKey = async (provider: string, _quiet = false): Promise<string> => {\n  const rl = readline.createInterface({\n    input: process.stdin,\n    output: process.stdout\n  });\n\n  return new Promise((resolve) => {\n    rl.question(`Please enter your ${provider} API key: `, (answer) => {\n      rl.close();\n      resolve(answer);\n    });\n  });\n};\n\nexport const getAIService = (\n  provider: string,\n  _options: AIConfig\n): (prompt: string, options: AIConfig) => Promise<string> => {\n  switch(provider) {\n    case 'cursor':\n      return callCursorAI;\n    case 'openai':\n      return callOpenAIAI;\n    case 'anthropic':\n      return callAnthropicAI;\n    case 'copilot':\n      return callCopilotAI;\n    default:\n      return async () => 'No AI provider configured';\n  }\n};\n\nexport const callAIService = async (prompt: string, quiet = false): Promise<string> => {\n  const spinner = createSpinner(quiet);\n  spinner.start('Calling AI service to fix code issues...');\n\n  try {\n    const aiConfig = LexConfig.config.ai || {provider: 'none'};\n\n    const isInCursorIDE = process.env.CURSOR_IDE === 'true';\n    if(isInCursorIDE && (aiConfig.provider === 'none' || !aiConfig.provider)) {\n      log('Detected Cursor IDE environment, using Cursor as AI provider', 'info', quiet);\n      aiConfig.provider = 'cursor';\n    }\n\n    if(aiConfig.provider === 'none') {\n      const provider = await promptForAIProvider(quiet);\n\n      if(provider === 'none') {\n        spinner.fail('AI features skipped');\n        return '';\n      }\n\n      aiConfig.provider = provider;\n\n      if(provider !== 'cursor' && provider !== 'copilot' &&\n        !process.env[`${provider.toUpperCase()}_API_KEY`]) {\n        aiConfig.apiKey = await promptForAPIKey(provider, quiet);\n      }\n\n      LexConfig.config.ai = aiConfig;\n\n      // Search for config files in multiple formats like LexConfig.parseConfig does\n      const configFormats = ['js', 'mjs', 'cjs', 'ts', 'json'];\n      const configBaseName = 'lex.config';\n      let configPath = '';\n\n      for(const format of configFormats) {\n        const potentialPath = pathResolve(process.cwd(), `./${configBaseName}.${format}`);\n        if(existsSync(potentialPath)) {\n          configPath = potentialPath;\n          break;\n        }\n      }\n\n      if(configPath) {\n        try {\n          const configContent = readFileSync(configPath, 'utf8');\n          const updatedConfig = configContent.replace(\n            /ai:.*?[,}]/s,\n            `ai: { provider: '${aiConfig.provider}' },`\n          );\n          writeFileSync(configPath, updatedConfig);\n        } catch(_error) {\n        }\n      }\n    }\n\n    let result = '';\n\n    switch(aiConfig.provider) {\n      case 'cursor':\n        result = await callCursorAI(prompt, aiConfig);\n        log('Cursor IDE AI integration active', 'info', quiet);\n        break;\n      case 'openai':\n        result = await callOpenAIAI(prompt, aiConfig);\n        break;\n      case 'anthropic':\n        result = await callAnthropicAI(prompt, aiConfig);\n        break;\n      case 'copilot':\n        result = await callCopilotAI(prompt, aiConfig);\n        break;\n      default:\n        spinner.fail('No AI provider configured');\n        return '';\n    }\n\n    spinner.succeed('AI code fixes generated successfully');\n    return result;\n  } catch(error) {\n    spinner.fail(`AI service error: ${error.message}`);\n    if(!quiet) {\n      log(error, 'error');\n    }\n    return '';\n  }\n};"],"names":["existsSync","readFileSync","writeFileSync","resolve","pathResolve","readline","LexConfig","createSpinner","log","callCursorAI","prompt","_options","taskMatch","match","task","isGenerateTask","startsWith","questionMatch","question","trim","toLowerCase","includes","projectStructure","split","files","length","error","Error","message","callOpenAIAI","options","apiKey","process","env","OPENAI_API_KEY","response","fetch","body","JSON","stringify","max_tokens","maxTokens","messages","content","role","model","temperature","headers","Authorization","method","ok","json","statusText","data","choices","callAnthropicAI","ANTHROPIC_API_KEY","text","callCopilotAI","promptForAIProvider","_quiet","rl","createInterface","input","stdin","output","stdout","Promise","answer","close","promptForAPIKey","provider","getAIService","callAIService","quiet","spinner","start","aiConfig","config","ai","isInCursorIDE","CURSOR_IDE","fail","toUpperCase","configFormats","configBaseName","configPath","format","potentialPath","cwd","configContent","updatedConfig","replace","_error","result","succeed"],"mappings":"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"}