@nlabs/lex 1.48.6 → 1.49.0

package/lib/utils/aiService.js

@@ -0,0 +1,299 @@
+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 `
+# Code Generation Request: "${question}"
+
+To generate code using Cursor's AI capabilities:
+
+1. **Open your project in Cursor IDE** (https://cursor.sh)
+2. Press **Cmd+L** (or Ctrl+L on Windows/Linux) to open the AI chat
+3. Type your request: "${question}"
+4. Cursor will generate the code directly in your editor
+
+The current CLI integration doesn't have direct access to Cursor's code generation capabilities.
+
+**Alternative options:**
+
+1. **Use OpenAI or Anthropic directly:**
+   Configure in your lex.config file:
+   \`\`\`js
+   export default {
+     ai: {
+       provider: 'openai',
+       apiKey: process.env.OPENAI_API_KEY,
+       model: 'gpt-4o'
+     }
+   }
+   \`\`\`
+
+2. **Use Cursor's command line tool:**
+   Install: \`npm install -g @cursor/cli\`
+   Run: \`cursor ai "${question}"\`
+`;
+    }
+    return `
+To use Cursor's AI capabilities for "${question}", you need to:
+
+1. Open your project in Cursor IDE (https://cursor.sh)
+2. Use Cursor's built-in AI features by pressing Cmd+K or Cmd+L
+3. Or run the 'cursor' command directly from your terminal
+
+The current integration is limited and doesn't directly access Cursor's AI capabilities.
+
+For the best experience with AI code generation:
+- Use Cursor IDE directly
+- Or configure OpenAI or Anthropic as your provider in your lex.config file:
+
+\`\`\`js
+// lex.config.js (or lex.config.mjs, lex.config.cjs, etc.)
+export default {
+  ai: {
+    provider: 'openai', // or 'anthropic'
+    apiKey: process.env.OPENAI_API_KEY, // or ANTHROPIC_API_KEY
+    model: 'gpt-4o' // or 'claude-3-opus'
+  }
+}
+\`\`\`
+
+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}`);
+    }
+    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.");
+    }
+    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}`);
+    }
+    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}`);
+  }
+};
+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");
+      }
+    });
+  });
+};
+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 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";
+  }
+};
+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 (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;
+        }
+      }
+      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");
+    }
+    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": []
}


package/{dist → lib}/utils/app.d.ts

@@ -23,8 +23,11 @@ export interface Spinner {
     fail: (text?: string) => void;
     start: (text?: string) => void;
     succeed: (text?: string) => void;
+    text?: string;
 }
 export declare const createSpinner: (quiet?: boolean) => Spinner;
+export declare const createProgressBar: (percentage: number) => string;
+export declare const handleWebpackProgress: (output: string, spinner: Spinner, quiet: boolean, emoji: string, action: string) => void;
 export declare const copyFiles: (files: string[], typeName: string, spinner: any, config: LexConfigType) => Promise<void>;
 export declare const copyConfiguredFiles: (spinner: any, config: LexConfigType, quiet: boolean) => Promise<void>;
 export declare const copyFileSync: (source: string, target: string) => void;