@nlabs/lex
Version:
312 lines (300 loc) • 35.8 kB
JavaScript
/**
* 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:
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}`);
}
};
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}`);
}
};
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}`);
}
};
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}`);
}
};
export 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 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);
});
});
};
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';
}
};
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 (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');
}
return '';
}
};
//# 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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"}