@nlabs/lex 1.49.5 → 1.50.1

package/lib/commands/ai/ai.js

@@ -1,303 +1,302 @@
-import chalk from "chalk";
-import { Command } from "commander";
-import { readFileSync } from "fs";
-import { sync as globSync } from "glob";
-import { LexConfig } from "../../LexConfig.js";
-import { callAIService } from "../../utils/aiService.js";
-import { log } from "../../utils/log.js";
-if (process.env.CURSOR_EXTENSION === "true" || process.env.CURSOR_TERMINAL === "true" || process.env.CURSOR_APP === "true" || process.env.PATH?.includes("cursor") || process.env.CURSOR_SESSION_ID) {
-  process.env.CURSOR_IDE = "true";
+/**
+ * Copyright (c) 2018-Present, Nitrogen Labs, Inc.
+ * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
+ */ import chalk from 'chalk';
+import { Command } from 'commander';
+import { readFileSync } from 'fs';
+import { sync as globSync } from 'glob';
+import { LexConfig } from '../../LexConfig.js';
+import { callAIService } from '../../utils/aiService.js';
+import { log } from '../../utils/log.js';
+if (process.env.CURSOR_EXTENSION === 'true' || process.env.CURSOR_TERMINAL === 'true' || process.env.CURSOR_APP === 'true' || process.env.PATH?.includes('cursor') || process.env.CURSOR_SESSION_ID) {
+    process.env.CURSOR_IDE = 'true';
 }
-const getFileContext = (filePath) => {
-  try {
-    const content = readFileSync(filePath, "utf-8");
-    return `File: ${filePath}
-
-${content}`;
-  } catch (_error) {
-    return `Error reading file: ${filePath}`;
-  }
-};
-const getProjectContext = async (options) => {
-  const { file, task, context } = options;
-  if (context === false) {
-    return "";
-  }
-  let projectContext = "";
-  if (file) {
-    projectContext += getFileContext(file);
-  }
-  switch (task) {
-    case "generate":
-      const files = globSync("src/**/*.{ts,tsx,js,jsx}", {
-        cwd: process.cwd(),
-        ignore: ["**/node_modules/**", "**/lib/**", "**/dist/**", "**/*.test.*", "**/*.spec.*"],
-        maxDepth: 3
-      });
-      projectContext += `
-
-Project structure:
-${files.join("\n")}`;
-      break;
-    case "test":
-      if (file) {
-        const testConfig = getFileContext("jest.config.js");
-        projectContext += `
-
-Test configuration:
-${testConfig}`;
-      }
-      break;
-    case "optimize":
-      const webpackConfig = getFileContext("webpack.config.js");
-      projectContext += `
-
-Webpack configuration:
-${webpackConfig}`;
-      break;
-    default:
-      break;
-  }
-  return projectContext;
-};
-const constructPrompt = (options, projectContext) => {
-  const { task = "help", prompt = "" } = options;
-  const taskInstructions = {
-    generate: "Generate code according to the following request. Make sure it follows best practices and is well documented:",
-    explain: "Explain the following code in detail, including any patterns, potential issues, and improvement suggestions:",
-    test: "Generate comprehensive unit tests for the following code:",
-    optimize: "Analyze the following code/configuration and suggest optimization improvements:",
-    help: "Provide guidance on the following development question:",
-    ask: "Provide guidance on the following development question:",
-    analyze: "Analyze the following code:"
-  };
-  const taskInstruction = taskInstructions[task] || taskInstructions.help;
-  let fullPrompt = `${taskInstruction}
-
-${prompt}`;
-  if (projectContext) {
-    fullPrompt += `
-
-===CONTEXT===
-${projectContext}`;
-  }
-  return fullPrompt;
-};
-const displayResponse = (response, options) => {
-  const { task = "help", quiet = false } = options;
-  let content = "";
-  if (typeof response === "string") {
-    content = response;
-  } else if (response.choices?.[0]?.message?.content) {
-    content = response.choices[0].message.content;
-  } else if (response.content) {
-    content = response.content;
-  } else {
-    content = "No response received from AI model";
-  }
-  const cleanedContent = cleanResponse(content, options);
-  switch (task) {
-    case "generate":
-      log("\nGenerated Code:\n", "success", quiet);
-      log(cleanedContent, "default", quiet);
-      break;
-    case "explain":
-      log("\nCode Explanation:\n", "success", quiet);
-      log(cleanedContent, "default", quiet);
-      break;
-    case "test":
-      log("\nGenerated Tests:\n", "success", quiet);
-      log(cleanedContent, "default", quiet);
-      break;
-    case "optimize":
-      log("\nOptimization Suggestions:\n", "success", quiet);
-      log(cleanedContent, "default", quiet);
-      break;
-    default:
-      log("\nAI Response:\n", "success", quiet);
-      log(cleanedContent, "default", quiet);
-      break;
-  }
+const getFileContext = (filePath)=>{
+    try {
+        const content = readFileSync(filePath, 'utf-8');
+        return `File: ${filePath}\n\n${content}`;
+    } catch (_error) {
+        return `Error reading file: ${filePath}`;
+    }
 };
-const cleanResponse = (content, options) => {
-  const { prompt = "", task = "help" } = options;
-  if (!content) {
-    return content;
-  }
-  let cleanedContent = content;
-  const taskInstructions = {
-    generate: "Generate code according to the following request. Make sure it follows best practices and is well documented:",
-    explain: "Explain the following code in detail, including any patterns, potential issues, and improvement suggestions:",
-    test: "Generate comprehensive unit tests for the following code:",
-    optimize: "Analyze the following code/configuration and suggest optimization improvements:",
-    help: "Provide guidance on the following development question:",
-    ask: "Provide guidance on the following development question:",
-    analyze: "Analyze the following code:"
-  };
-  const instruction = taskInstructions[task] || "";
-  if (instruction && cleanedContent.includes(instruction)) {
-    cleanedContent = cleanedContent.replace(instruction, "").trim();
-  }
-  if (prompt && cleanedContent.includes(prompt)) {
-    cleanedContent = cleanedContent.replace(prompt, "").trim();
-  }
-  if (cleanedContent.includes("===CONTEXT===")) {
-    cleanedContent = cleanedContent.split("===CONTEXT===")[0].trim();
-  }
-  if (!cleanedContent) {
-    return content;
-  }
-  return cleanedContent;
+const getProjectContext = async (options)=>{
+    const { file, task, context } = options;
+    if (context === false) {
+        return '';
+    }
+    let projectContext = '';
+    if (file) {
+        projectContext += getFileContext(file);
+    }
+    switch(task){
+        case 'generate':
+            const files = globSync('src/**/*.{ts,tsx,js,jsx}', {
+                cwd: process.cwd(),
+                ignore: [
+                    '**/node_modules/**',
+                    '**/lib/**',
+                    '**/dist/**',
+                    '**/*.test.*',
+                    '**/*.spec.*'
+                ],
+                maxDepth: 3
+            });
+            projectContext += `\n\nProject structure:\n${files.join('\n')}`;
+            break;
+        case 'test':
+            if (file) {
+                const testConfig = getFileContext('jest.config.js');
+                projectContext += `\n\nTest configuration:\n${testConfig}`;
+            }
+            break;
+        case 'optimize':
+            const webpackConfig = getFileContext('webpack.config.js');
+            projectContext += `\n\nWebpack configuration:\n${webpackConfig}`;
+            break;
+        default:
+            break;
+    }
+    return projectContext;
 };
-const getProviderAuth = (provider) => {
-  if (process.cwd().includes("reaktor")) {
-    return "cursor-auth";
-  }
-  if (process.env.AI_API_KEY) {
-    return process.env.AI_API_KEY;
-  }
-  if (provider === "none" && process.env.CURSOR_IDE === "true") {
-    return "cursor-auth";
-  }
-  switch (provider) {
-    case "openai":
-      return process.env.OPENAI_API_KEY;
-    case "anthropic":
-      return process.env.ANTHROPIC_API_KEY;
-    case "cursor":
-      return "cursor-auth";
-    case "copilot":
-      return process.env.GITHUB_TOKEN;
-    case "none":
-      return void 0;
-    default:
-      return void 0;
-  }
+const constructPrompt = (options, projectContext)=>{
+    const { task = 'help', prompt = '' } = options;
+    const taskInstructions = {
+        analyze: 'Analyze the following code:',
+        ask: 'Provide guidance on the following development question:',
+        explain: 'Explain the following code in detail, including any patterns, potential issues, and improvement suggestions:',
+        generate: 'Generate code according to the following request. Make sure it follows best practices and is well documented:',
+        help: 'Provide guidance on the following development question:',
+        optimize: 'Analyze the following code/configuration and suggest optimization improvements:',
+        test: 'Generate comprehensive unit tests for the following code:'
+    };
+    const taskInstruction = taskInstructions[task] || taskInstructions.help;
+    let fullPrompt = `${taskInstruction}\n\n${prompt}`;
+    if (projectContext) {
+        fullPrompt += `\n\n===CONTEXT===\n${projectContext}`;
+    }
+    return fullPrompt;
 };
-const detectCursorIDE = () => {
-  if (process.env.CURSOR_IDE === "true") {
-    return true;
-  }
-  const possibleCursorSignals = [
-    process.env.CURSOR_EXTENSION === "true",
-    process.env.CURSOR_TERMINAL === "true",
-    process.env.CURSOR_APP === "true",
-    process.env.PATH?.includes("cursor"),
-    !!process.env.CURSOR_SESSION_ID
-  ];
-  const isCursorIDE = possibleCursorSignals.some((signal) => signal);
-  if (isCursorIDE) {
-    process.env.CURSOR_IDE = "true";
-  }
-  return isCursorIDE;
+const displayResponse = (response, options)=>{
+    const { task = 'help', quiet = false } = options;
+    let content = '';
+    if (typeof response === 'string') {
+        content = response;
+    } else if (response.choices?.[0]?.message?.content) {
+        const { content: messageContent } = response.choices[0].message;
+        content = messageContent;
+    } else if (response.content) {
+        const { content: responseContent } = response;
+        content = responseContent;
+    } else {
+        content = 'No response received from AI model';
+    }
+    const cleanedContent = cleanResponse(content, options);
+    switch(task){
+        case 'generate':
+            log('\nGenerated Code:\n', 'success', quiet);
+            log(cleanedContent, 'default', quiet);
+            break;
+        case 'explain':
+            log('\nCode Explanation:\n', 'success', quiet);
+            log(cleanedContent, 'default', quiet);
+            break;
+        case 'test':
+            log('\nGenerated Tests:\n', 'success', quiet);
+            log(cleanedContent, 'default', quiet);
+            break;
+        case 'optimize':
+            log('\nOptimization Suggestions:\n', 'success', quiet);
+            log(cleanedContent, 'default', quiet);
+            break;
+        default:
+            log('\nAI Response:\n', 'success', quiet);
+            log(cleanedContent, 'default', quiet);
+            break;
+    }
 };
-const aiFunction = async (options) => {
-  try {
-    const config = LexConfig.config || {};
-    const aiConfig = config.ai || {};
-    const provider = options.provider || aiConfig.provider || "none";
-    if (provider === "none" && !process.env.CURSOR_EXTENSION) {
-      log(`${chalk.red("Error:")} No AI provider configured.`, "error");
-      return { error: "No AI provider configured" };
+const cleanResponse = (content, options)=>{
+    const { prompt = '', task = 'help' } = options;
+    if (!content) {
+        return content;
     }
-    const task = options.task || "ask";
-    const validTasks = ["explain", "generate", "test", "analyze", "ask"];
-    if (!validTasks.includes(task)) {
-      log(`${chalk.red("Error:")} Invalid task "${task}". Valid tasks are: ${validTasks.join(", ")}`, "error");
-      return { error: `Invalid task "${task}"` };
+    let cleanedContent = content;
+    const taskInstructions = {
+        analyze: 'Analyze the following code:',
+        ask: 'Provide guidance on the following development question:',
+        explain: 'Explain the following code in detail, including any patterns, potential issues, and improvement suggestions:',
+        generate: 'Generate code according to the following request. Make sure it follows best practices and is well documented:',
+        help: 'Provide guidance on the following development question:',
+        optimize: 'Analyze the following code/configuration and suggest optimization improvements:',
+        test: 'Generate comprehensive unit tests for the following code:'
+    };
+    const instruction = taskInstructions[task] || '';
+    if (instruction && cleanedContent.includes(instruction)) {
+        cleanedContent = cleanedContent.replace(instruction, '').trim();
     }
-    const { prompt } = options;
-    if (!prompt) {
-      log(`${chalk.red("Error:")} No prompt provided. Use --prompt "Your prompt here"`, "error");
-      return { error: "No prompt provided" };
+    if (prompt && cleanedContent.includes(prompt)) {
+        cleanedContent = cleanedContent.replace(prompt, '').trim();
     }
-    let context = "";
-    if (options.file) {
-      try {
-        const fs = await import("fs/promises");
-        const glob = await import("glob");
-        const files = await glob.glob(options.file);
-        if (files.length === 0) {
-          log(`${chalk.yellow("Warning:")} No files found matching "${options.file}"`, "warning");
-        } else {
-          for (const file of files) {
-            const content = await fs.readFile(file, "utf8");
-            context += `
-===FILE: ${file}===
-${content}
-`;
-          }
-        }
-      } catch (error) {
-        log(`${chalk.yellow("Warning:")} Error reading file: ${error.message}`, "warning");
-      }
+    if (cleanedContent.includes('===CONTEXT===')) {
+        cleanedContent = cleanedContent.split('===CONTEXT===')[0].trim();
     }
-    if (options.dir) {
-      try {
-        const { execaSync } = await import("execa");
-        const result = execaSync("find", [options.dir, "-type", "f", "|", "sort"]);
-        context += `
-===Project structure:===
-${result.stdout}
-`;
-      } catch (error) {
-        log(`${chalk.yellow("Warning:")} Error reading directory: ${error.message}`, "warning");
-      }
+    if (!cleanedContent) {
+        return content;
     }
-    let formattedPrompt = "";
-    switch (task) {
-      case "explain":
-        formattedPrompt = `Explain the following code:
-${prompt}`;
-        break;
-      case "generate":
-        formattedPrompt = `Generate code according to the following request:
-${prompt}`;
-        break;
-      case "test":
-        formattedPrompt = `Generate comprehensive unit tests:
-${prompt}`;
-        break;
-      case "analyze":
-        formattedPrompt = `Analyze the following code:
-${prompt}`;
-        break;
-      case "ask":
-        formattedPrompt = `Provide guidance on the following development question:
-${prompt}`;
-        break;
+    return cleanedContent;
+};
+const getProviderAuth = (provider)=>{
+    if (process.cwd().includes('reaktor')) {
+        return 'cursor-auth';
     }
-    if (context) {
-      formattedPrompt += `
-===CONTEXT===
-${context}`;
+    if (process.env.AI_API_KEY) {
+        return process.env.AI_API_KEY;
     }
-    if ((provider === "cursor" || process.env.CURSOR_EXTENSION) && task === "generate") {
-      log("Using Cursor IDE for code generation...", "info");
-      log("Note: For full code generation capabilities, please use Cursor IDE directly with Cmd+L or Cmd+K.", "info");
-      log("The CLI integration has limited capabilities for code generation.", "warning");
-    } else if (provider === "cursor" || process.env.CURSOR_EXTENSION) {
-      log("Using Cursor IDE for AI assistance...", "info");
-      log("Note: This is a limited integration. For full AI capabilities, use Cursor IDE directly.", "info");
-    } else {
-      log(`Using ${provider} for AI assistance...`, "info");
+    if (provider === 'none' && process.env.CURSOR_IDE === 'true') {
+        return 'cursor-auth';
+    }
+    switch(provider){
+        case 'openai':
+            return process.env.OPENAI_API_KEY;
+        case 'anthropic':
+            return process.env.ANTHROPIC_API_KEY;
+        case 'cursor':
+            return 'cursor-auth';
+        case 'copilot':
+            return process.env.GITHUB_TOKEN;
+        case 'none':
+            return undefined;
+        default:
+            return undefined;
     }
-    const response = await callAIService(formattedPrompt, options.quiet || false);
-    log(`
-${response}`, "success");
-    return { response };
-  } catch (error) {
-    log(`${chalk.red("Error:")} ${error.message}`, "error");
-    return { error: error.message };
-  }
 };
-const ai = new Command("ai").description("Use AI to help with development tasks").option("--provider <provider>", "AI provider to use (openai, anthropic, cursor)").option("--task <task>", "Task to perform (explain, generate, test, analyze, ask)").option("--prompt <prompt>", "Prompt to send to AI").option("--file <file>", "File to analyze").option("--dir <dir>", "Directory to analyze").action(async (options) => {
-  await aiFunction(options);
-});
-var ai_default = ai;
-export {
-  ai,
-  aiFunction,
-  ai_default as default
+const detectCursorIDE = ()=>{
+    if (process.env.CURSOR_IDE === 'true') {
+        return true;
+    }
+    const possibleCursorSignals = [
+        process.env.CURSOR_EXTENSION === 'true',
+        process.env.CURSOR_TERMINAL === 'true',
+        process.env.CURSOR_APP === 'true',
+        process.env.PATH?.includes('cursor'),
+        !!process.env.CURSOR_SESSION_ID
+    ];
+    const isCursorIDE = possibleCursorSignals.some((signal)=>signal);
+    if (isCursorIDE) {
+        process.env.CURSOR_IDE = 'true';
+    }
+    return isCursorIDE;
 };
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/commands/ai/ai.ts"],
  "sourcesContent": ["/**\n * Copyright (c) 2018-Present, Nitrogen Labs, Inc.\n * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.\n */\nimport chalk from 'chalk';\nimport {Command} from 'commander';\nimport {readFileSync} from 'fs';\nimport {sync as globSync} from 'glob';\n\nimport {LexConfig} from '../../LexConfig.js';\nimport {callAIService} from '../../utils/aiService.js';\nimport {log} from '../../utils/log.js';\n\nif(process.env.CURSOR_EXTENSION === 'true' ||\n  process.env.CURSOR_TERMINAL === 'true' ||\n  process.env.CURSOR_APP === 'true' ||\n  process.env.PATH?.includes('cursor') ||\n  process.env.CURSOR_SESSION_ID) {\n  process.env.CURSOR_IDE = 'true';\n}\n\nexport interface AIOptions {\n  readonly cliName?: string;\n  readonly context?: boolean;\n  readonly file?: string;\n  readonly lexConfig?: string;\n  readonly model?: string;\n  readonly prompt?: string;\n  readonly quiet?: boolean;\n  readonly task?: 'generate' | 'explain' | 'test' | 'optimize' | 'help' | 'ask' | 'analyze';\n  readonly debug?: boolean;\n  readonly provider?: string;\n  readonly dir?: string;\n}\n\nconst getFileContext = (filePath: string): string => {\n  try {\n    const content = readFileSync(filePath, 'utf-8');\n    return `File: ${filePath}\\n\\n${content}`;\n  } catch (_error) {\n    return `Error reading file: ${filePath}`;\n  }\n};\n\nconst getProjectContext = async (options: AIOptions): Promise<string> => {\n  const {file, task, context} = options;\n\n  if(context === false) {\n    return '';\n  }\n\n  let projectContext = '';\n\n  if(file) {\n    projectContext += getFileContext(file);\n  }\n\n  switch(task) {\n    case 'generate':\n      const files = globSync('src/**/*.{ts,tsx,js,jsx}', {\n        cwd: process.cwd(),\n        ignore: ['**/node_modules/**', '**/lib/**', '**/dist/**', '**/*.test.*', '**/*.spec.*'],\n        maxDepth: 3\n      });\n      projectContext += `\\n\\nProject structure:\\n${files.join('\\n')}`;\n      break;\n\n    case 'test':\n      if(file) {\n        const testConfig = getFileContext('jest.config.js');\n        projectContext += `\\n\\nTest configuration:\\n${testConfig}`;\n      }\n      break;\n\n    case 'optimize':\n      const webpackConfig = getFileContext('webpack.config.js');\n      projectContext += `\\n\\nWebpack configuration:\\n${webpackConfig}`;\n      break;\n\n    default:\n      break;\n  }\n\n  return projectContext;\n};\n\nconst constructPrompt = (options: AIOptions, projectContext: string): string => {\n  const {task = 'help', prompt = ''} = options;\n\n  const taskInstructions: Record<string, string> = {\n    generate: 'Generate code according to the following request. Make sure it follows best practices and is well documented:',\n    explain: 'Explain the following code in detail, including any patterns, potential issues, and improvement suggestions:',\n    test: 'Generate comprehensive unit tests for the following code:',\n    optimize: 'Analyze the following code/configuration and suggest optimization improvements:',\n    help: 'Provide guidance on the following development question:',\n    ask: 'Provide guidance on the following development question:',\n    analyze: 'Analyze the following code:'\n  };\n\n  const taskInstruction = taskInstructions[task] || taskInstructions.help;\n\n  let fullPrompt = `${taskInstruction}\\n\\n${prompt}`;\n\n  if(projectContext) {\n    fullPrompt += `\\n\\n===CONTEXT===\\n${projectContext}`;\n  }\n\n  return fullPrompt;\n};\n\nconst displayResponse = (response: any, options: AIOptions): void => {\n  const {task = 'help', quiet = false} = options;\n\n  let content = '';\n\n  if(typeof response === 'string') {\n    content = response;\n  } else if(response.choices?.[0]?.message?.content) {\n    content = response.choices[0].message.content;\n  } else if(response.content) {\n    content = response.content;\n  } else {\n    content = 'No response received from AI model';\n  }\n\n  const cleanedContent = cleanResponse(content, options);\n\n  switch(task) {\n    case 'generate':\n      log('\\nGenerated Code:\\n', 'success', quiet);\n      log(cleanedContent, 'default', quiet);\n      break;\n\n    case 'explain':\n      log('\\nCode Explanation:\\n', 'success', quiet);\n      log(cleanedContent, 'default', quiet);\n      break;\n\n    case 'test':\n      log('\\nGenerated Tests:\\n', 'success', quiet);\n      log(cleanedContent, 'default', quiet);\n      break;\n\n    case 'optimize':\n      log('\\nOptimization Suggestions:\\n', 'success', quiet);\n      log(cleanedContent, 'default', quiet);\n      break;\n\n    default:\n      log('\\nAI Response:\\n', 'success', quiet);\n      log(cleanedContent, 'default', quiet);\n      break;\n  }\n};\n\nconst cleanResponse = (content: string, options: AIOptions): string => {\n  const {prompt = '', task = 'help'} = options;\n\n  if(!content) {\n    return content;\n  }\n\n  let cleanedContent = content;\n\n  const taskInstructions: Record<string, string> = {\n    generate: 'Generate code according to the following request. Make sure it follows best practices and is well documented:',\n    explain: 'Explain the following code in detail, including any patterns, potential issues, and improvement suggestions:',\n    test: 'Generate comprehensive unit tests for the following code:',\n    optimize: 'Analyze the following code/configuration and suggest optimization improvements:',\n    help: 'Provide guidance on the following development question:',\n    ask: 'Provide guidance on the following development question:',\n    analyze: 'Analyze the following code:'\n  };\n\n  const instruction = taskInstructions[task] || '';\n\n  if(instruction && cleanedContent.includes(instruction)) {\n    cleanedContent = cleanedContent.replace(instruction, '').trim();\n  }\n\n  if(prompt && cleanedContent.includes(prompt)) {\n    cleanedContent = cleanedContent.replace(prompt, '').trim();\n  }\n\n  if(cleanedContent.includes('===CONTEXT===')) {\n    cleanedContent = cleanedContent.split('===CONTEXT===')[0].trim();\n  }\n\n  if(!cleanedContent) {\n    return content;\n  }\n\n  return cleanedContent;\n};\n\nconst getProviderAuth = (provider: string): string | undefined => {\n  if(process.cwd().includes('reaktor')) {\n    return 'cursor-auth';\n  }\n\n  if(process.env.AI_API_KEY) {\n    return process.env.AI_API_KEY;\n  }\n\n  if(provider === 'none' && process.env.CURSOR_IDE === 'true') {\n    return 'cursor-auth';\n  }\n\n  switch(provider) {\n    case 'openai':\n      return process.env.OPENAI_API_KEY;\n    case 'anthropic':\n      return process.env.ANTHROPIC_API_KEY;\n    case 'cursor':\n      return 'cursor-auth';\n    case 'copilot':\n      return process.env.GITHUB_TOKEN;\n    case 'none':\n      return undefined;\n    default:\n      return undefined;\n  }\n};\n\nconst detectCursorIDE = (): boolean => {\n  if(process.env.CURSOR_IDE === 'true') {\n    return true;\n  }\n\n  const possibleCursorSignals = [\n    process.env.CURSOR_EXTENSION === 'true',\n    process.env.CURSOR_TERMINAL === 'true',\n    process.env.CURSOR_APP === 'true',\n    process.env.PATH?.includes('cursor'),\n    !!process.env.CURSOR_SESSION_ID\n  ];\n\n  const isCursorIDE = possibleCursorSignals.some((signal) => signal);\n\n  if(isCursorIDE) {\n    process.env.CURSOR_IDE = 'true';\n  }\n\n  return isCursorIDE;\n};\n\nexport const aiFunction = async (options: AIOptions): Promise<any> => {\n  try {\n    const config = LexConfig.config || {};\n    const aiConfig = config.ai || {};\n    const provider = options.provider || aiConfig.provider || 'none';\n\n    if(provider === 'none' && !process.env.CURSOR_EXTENSION) {\n      log(`${chalk.red('Error:')} No AI provider configured.`, 'error');\n      return {error: 'No AI provider configured'};\n    }\n\n    const task = options.task || 'ask';\n    const validTasks = ['explain', 'generate', 'test', 'analyze', 'ask'];\n\n    if(!validTasks.includes(task)) {\n      log(`${chalk.red('Error:')} Invalid task \"${task}\". Valid tasks are: ${validTasks.join(', ')}`, 'error');\n      return {error: `Invalid task \"${task}\"`};\n    }\n\n    const {prompt} = options;\n\n    if(!prompt) {\n      log(`${chalk.red('Error:')} No prompt provided. Use --prompt \"Your prompt here\"`, 'error');\n      return {error: 'No prompt provided'};\n    }\n\n    let context = '';\n\n    if(options.file) {\n      try {\n        const fs = await import('fs/promises');\n        const glob = await import('glob');\n        const files = await glob.glob(options.file);\n\n        if(files.length === 0) {\n          log(`${chalk.yellow('Warning:')} No files found matching \"${options.file}\"`, 'warning');\n        } else {\n          for(const file of files) {\n            const content = await fs.readFile(file, 'utf8');\n            context += `\\n===FILE: ${file}===\\n${content}\\n`;\n          }\n        }\n      } catch (error) {\n        log(`${chalk.yellow('Warning:')} Error reading file: ${error.message}`, 'warning');\n      }\n    }\n\n    if(options.dir) {\n      try {\n        const {execaSync} = await import('execa');\n        const result = execaSync('find', [options.dir, '-type', 'f', '|', 'sort']);\n        context += `\\n===Project structure:===\\n${result.stdout}\\n`;\n      } catch (error) {\n        log(`${chalk.yellow('Warning:')} Error reading directory: ${error.message}`, 'warning');\n      }\n    }\n\n    let formattedPrompt = '';\n\n    switch(task) {\n      case 'explain':\n        formattedPrompt = `Explain the following code:\\n${prompt}`;\n        break;\n      case 'generate':\n        formattedPrompt = `Generate code according to the following request:\\n${prompt}`;\n        break;\n      case 'test':\n        formattedPrompt = `Generate comprehensive unit tests:\\n${prompt}`;\n        break;\n      case 'analyze':\n        formattedPrompt = `Analyze the following code:\\n${prompt}`;\n        break;\n      case 'ask':\n        formattedPrompt = `Provide guidance on the following development question:\\n${prompt}`;\n        break;\n    }\n\n    if(context) {\n      formattedPrompt += `\\n===CONTEXT===\\n${context}`;\n    }\n\n    if((provider === 'cursor' || process.env.CURSOR_EXTENSION) && task === 'generate') {\n      log('Using Cursor IDE for code generation...', 'info');\n      log('Note: For full code generation capabilities, please use Cursor IDE directly with Cmd+L or Cmd+K.', 'info');\n      log('The CLI integration has limited capabilities for code generation.', 'warning');\n    } else if(provider === 'cursor' || process.env.CURSOR_EXTENSION) {\n      log('Using Cursor IDE for AI assistance...', 'info');\n      log('Note: This is a limited integration. For full AI capabilities, use Cursor IDE directly.', 'info');\n    } else {\n      log(`Using ${provider} for AI assistance...`, 'info');\n    }\n\n    const response = await callAIService(formattedPrompt, options.quiet || false);\n\n    log(`\\n${response}`, 'success');\n\n    return {response};\n  } catch (error) {\n    log(`${chalk.red('Error:')} ${error.message}`, 'error');\n    return {error: error.message};\n  }\n};\n\nexport const ai = new Command('ai')\n  .description('Use AI to help with development tasks')\n  .option('--provider <provider>', 'AI provider to use (openai, anthropic, cursor)')\n  .option('--task <task>', 'Task to perform (explain, generate, test, analyze, ask)')\n  .option('--prompt <prompt>', 'Prompt to send to AI')\n  .option('--file <file>', 'File to analyze')\n  .option('--dir <dir>', 'Directory to analyze')\n  .action(async (options: AIOptions) => {\n    await aiFunction(options);\n  });\n\nexport default ai;"],
  "mappings": "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",
  "names": []
}

+export const aiFunction = async (options)=>{
+    try {
+        const config = LexConfig.config || {};
+        const aiConfig = config.ai || {};
+        const provider = options.provider || aiConfig.provider || 'none';
+        if (provider === 'none' && !process.env.CURSOR_EXTENSION) {
+            log(`${chalk.red('Error:')} No AI provider configured.`, 'error');
+            return {
+                error: 'No AI provider configured'
+            };
+        }
+        const task = options.task || 'ask';
+        const validTasks = [
+            'explain',
+            'generate',
+            'test',
+            'analyze',
+            'ask'
+        ];
+        if (!validTasks.includes(task)) {
+            log(`${chalk.red('Error:')} Invalid task "${task}". Valid tasks are: ${validTasks.join(', ')}`, 'error');
+            return {
+                error: `Invalid task "${task}"`
+            };
+        }
+        const { prompt } = options;
+        if (!prompt) {
+            log(`${chalk.red('Error:')} No prompt provided. Use --prompt "Your prompt here"`, 'error');
+            return {
+                error: 'No prompt provided'
+            };
+        }
+        let context = '';
+        if (options.file) {
+            try {
+                const fs = await import('fs/promises');
+                const glob = await import('glob');
+                const files = await glob.glob(options.file);
+                if (files.length === 0) {
+                    log(`${chalk.yellow('Warning:')} No files found matching "${options.file}"`, 'warning');
+                } else {
+                    for (const file of files){
+                        const content = await fs.readFile(file, 'utf8');
+                        context += `\n===FILE: ${file}===\n${content}\n`;
+                    }
+                }
+            } catch (error) {
+                log(`${chalk.yellow('Warning:')} Error reading file: ${error.message}`, 'warning');
+            }
+        }
+        if (options.dir) {
+            try {
+                const { execaSync } = await import('execa');
+                const result = execaSync('find', [
+                    options.dir,
+                    '-type',
+                    'f',
+                    '|',
+                    'sort'
+                ]);
+                context += `\n===Project structure:===\n${result.stdout}\n`;
+            } catch (error) {
+                log(`${chalk.yellow('Warning:')} Error reading directory: ${error.message}`, 'warning');
+            }
+        }
+        let formattedPrompt = '';
+        switch(task){
+            case 'explain':
+                formattedPrompt = `Explain the following code:\n${prompt}`;
+                break;
+            case 'generate':
+                formattedPrompt = `Generate code according to the following request:\n${prompt}`;
+                break;
+            case 'test':
+                formattedPrompt = `Generate comprehensive unit tests:\n${prompt}`;
+                break;
+            case 'analyze':
+                formattedPrompt = `Analyze the following code:\n${prompt}`;
+                break;
+            case 'ask':
+                formattedPrompt = `Provide guidance on the following development question:\n${prompt}`;
+                break;
+        }
+        if (context) {
+            formattedPrompt += `\n===CONTEXT===\n${context}`;
+        }
+        if ((provider === 'cursor' || process.env.CURSOR_EXTENSION) && task === 'generate') {
+            log('Using Cursor IDE for code generation...', 'info');
+            log('Note: For full code generation capabilities, please use Cursor IDE directly with Cmd+L or Cmd+K.', 'info');
+            log('The CLI integration has limited capabilities for code generation.', 'warning');
+        } else if (provider === 'cursor' || process.env.CURSOR_EXTENSION) {
+            log('Using Cursor IDE for AI assistance...', 'info');
+            log('Note: This is a limited integration. For full AI capabilities, use Cursor IDE directly.', 'info');
+        } else {
+            log(`Using ${provider} for AI assistance...`, 'info');
+        }
+        const response = await callAIService(formattedPrompt, options.quiet || false);
+        log(`\n${response}`, 'success');
+        return {
+            response
+        };
+    } catch (error) {
+        log(`${chalk.red('Error:')} ${error.message}`, 'error');
+        return {
+            error: error.message
+        };
+    }
+};
+export const ai = new Command('ai').description('Use AI to help with development tasks').option('--provider <provider>', 'AI provider to use (openai, anthropic, cursor)').option('--task <task>', 'Task to perform (explain, generate, test, analyze, ask)').option('--prompt <prompt>', 'Prompt to send to AI').option('--file <file>', 'File to analyze').option('--dir <dir>', 'Directory to analyze').action(async (options)=>{
+    await aiFunction(options);
+});
+export default ai;
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/commands/ai/ai.ts"],"sourcesContent":["/**\n * Copyright (c) 2018-Present, Nitrogen Labs, Inc.\n * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.\n */\nimport chalk from 'chalk';\nimport {Command} from 'commander';\nimport {readFileSync} from 'fs';\nimport {sync as globSync} from 'glob';\n\nimport {LexConfig} from '../../LexConfig.js';\nimport {callAIService} from '../../utils/aiService.js';\nimport {log} from '../../utils/log.js';\n\nif(process.env.CURSOR_EXTENSION === 'true' ||\n  process.env.CURSOR_TERMINAL === 'true' ||\n  process.env.CURSOR_APP === 'true' ||\n  process.env.PATH?.includes('cursor') ||\n  process.env.CURSOR_SESSION_ID) {\n  process.env.CURSOR_IDE = 'true';\n}\n\nexport interface AIOptions {\n  readonly cliName?: string;\n  readonly context?: boolean;\n  readonly file?: string;\n  readonly lexConfig?: string;\n  readonly model?: string;\n  readonly prompt?: string;\n  readonly quiet?: boolean;\n  readonly task?: 'generate' | 'explain' | 'test' | 'optimize' | 'help' | 'ask' | 'analyze';\n  readonly debug?: boolean;\n  readonly provider?: string;\n  readonly dir?: string;\n}\n\nconst getFileContext = (filePath: string): string => {\n  try {\n    const content = readFileSync(filePath, 'utf-8');\n    return `File: ${filePath}\\n\\n${content}`;\n  } catch(_error) {\n    return `Error reading file: ${filePath}`;\n  }\n};\n\nconst getProjectContext = async (options: AIOptions): Promise<string> => {\n  const {file, task, context} = options;\n\n  if(context === false) {\n    return '';\n  }\n\n  let projectContext = '';\n\n  if(file) {\n    projectContext += getFileContext(file);\n  }\n\n  switch(task) {\n    case 'generate':\n      const files = globSync('src/**/*.{ts,tsx,js,jsx}', {\n        cwd: process.cwd(),\n        ignore: ['**/node_modules/**', '**/lib/**', '**/dist/**', '**/*.test.*', '**/*.spec.*'],\n        maxDepth: 3\n      });\n      projectContext += `\\n\\nProject structure:\\n${files.join('\\n')}`;\n      break;\n\n    case 'test':\n      if(file) {\n        const testConfig = getFileContext('jest.config.js');\n        projectContext += `\\n\\nTest configuration:\\n${testConfig}`;\n      }\n      break;\n\n    case 'optimize':\n      const webpackConfig = getFileContext('webpack.config.js');\n      projectContext += `\\n\\nWebpack configuration:\\n${webpackConfig}`;\n      break;\n\n    default:\n      break;\n  }\n\n  return projectContext;\n};\n\nconst constructPrompt = (options: AIOptions, projectContext: string): string => {\n  const {task = 'help', prompt = ''} = options;\n\n  const taskInstructions: Record<string, string> = {\n    analyze: 'Analyze the following code:',\n    ask: 'Provide guidance on the following development question:',\n    explain: 'Explain the following code in detail, including any patterns, potential issues, and improvement suggestions:',\n    generate: 'Generate code according to the following request. Make sure it follows best practices and is well documented:',\n    help: 'Provide guidance on the following development question:',\n    optimize: 'Analyze the following code/configuration and suggest optimization improvements:',\n    test: 'Generate comprehensive unit tests for the following code:'\n  };\n\n  const taskInstruction = taskInstructions[task] || taskInstructions.help;\n\n  let fullPrompt = `${taskInstruction}\\n\\n${prompt}`;\n\n  if(projectContext) {\n    fullPrompt += `\\n\\n===CONTEXT===\\n${projectContext}`;\n  }\n\n  return fullPrompt;\n};\n\nconst displayResponse = (response: any, options: AIOptions): void => {\n  const {task = 'help', quiet = false} = options;\n\n  let content = '';\n\n  if(typeof response === 'string') {\n    content = response;\n  } else if(response.choices?.[0]?.message?.content) {\n    const {content: messageContent} = response.choices[0].message;\n    content = messageContent;\n  } else if(response.content) {\n    const {content: responseContent} = response;\n    content = responseContent;\n  } else {\n    content = 'No response received from AI model';\n  }\n\n  const cleanedContent = cleanResponse(content, options);\n\n  switch(task) {\n    case 'generate':\n      log('\\nGenerated Code:\\n', 'success', quiet);\n      log(cleanedContent, 'default', quiet);\n      break;\n\n    case 'explain':\n      log('\\nCode Explanation:\\n', 'success', quiet);\n      log(cleanedContent, 'default', quiet);\n      break;\n\n    case 'test':\n      log('\\nGenerated Tests:\\n', 'success', quiet);\n      log(cleanedContent, 'default', quiet);\n      break;\n\n    case 'optimize':\n      log('\\nOptimization Suggestions:\\n', 'success', quiet);\n      log(cleanedContent, 'default', quiet);\n      break;\n\n    default:\n      log('\\nAI Response:\\n', 'success', quiet);\n      log(cleanedContent, 'default', quiet);\n      break;\n  }\n};\n\nconst cleanResponse = (content: string, options: AIOptions): string => {\n  const {prompt = '', task = 'help'} = options;\n\n  if(!content) {\n    return content;\n  }\n\n  let cleanedContent = content;\n\n  const taskInstructions: Record<string, string> = {\n    analyze: 'Analyze the following code:',\n    ask: 'Provide guidance on the following development question:',\n    explain: 'Explain the following code in detail, including any patterns, potential issues, and improvement suggestions:',\n    generate: 'Generate code according to the following request. Make sure it follows best practices and is well documented:',\n    help: 'Provide guidance on the following development question:',\n    optimize: 'Analyze the following code/configuration and suggest optimization improvements:',\n    test: 'Generate comprehensive unit tests for the following code:'\n  };\n\n  const instruction = taskInstructions[task] || '';\n\n  if(instruction && cleanedContent.includes(instruction)) {\n    cleanedContent = cleanedContent.replace(instruction, '').trim();\n  }\n\n  if(prompt && cleanedContent.includes(prompt)) {\n    cleanedContent = cleanedContent.replace(prompt, '').trim();\n  }\n\n  if(cleanedContent.includes('===CONTEXT===')) {\n    cleanedContent = cleanedContent.split('===CONTEXT===')[0].trim();\n  }\n\n  if(!cleanedContent) {\n    return content;\n  }\n\n  return cleanedContent;\n};\n\nconst getProviderAuth = (provider: string): string | undefined => {\n  if(process.cwd().includes('reaktor')) {\n    return 'cursor-auth';\n  }\n\n  if(process.env.AI_API_KEY) {\n    return process.env.AI_API_KEY;\n  }\n\n  if(provider === 'none' && process.env.CURSOR_IDE === 'true') {\n    return 'cursor-auth';\n  }\n\n  switch(provider) {\n    case 'openai':\n      return process.env.OPENAI_API_KEY;\n    case 'anthropic':\n      return process.env.ANTHROPIC_API_KEY;\n    case 'cursor':\n      return 'cursor-auth';\n    case 'copilot':\n      return process.env.GITHUB_TOKEN;\n    case 'none':\n      return undefined;\n    default:\n      return undefined;\n  }\n};\n\nconst detectCursorIDE = (): boolean => {\n  if(process.env.CURSOR_IDE === 'true') {\n    return true;\n  }\n\n  const possibleCursorSignals = [\n    process.env.CURSOR_EXTENSION === 'true',\n    process.env.CURSOR_TERMINAL === 'true',\n    process.env.CURSOR_APP === 'true',\n    process.env.PATH?.includes('cursor'),\n    !!process.env.CURSOR_SESSION_ID\n  ];\n\n  const isCursorIDE = possibleCursorSignals.some((signal) => signal);\n\n  if(isCursorIDE) {\n    process.env.CURSOR_IDE = 'true';\n  }\n\n  return isCursorIDE;\n};\n\nexport const aiFunction = async (options: AIOptions): Promise<any> => {\n  try {\n    const config = LexConfig.config || {};\n    const aiConfig = config.ai || {};\n    const provider = options.provider || aiConfig.provider || 'none';\n\n    if(provider === 'none' && !process.env.CURSOR_EXTENSION) {\n      log(`${chalk.red('Error:')} No AI provider configured.`, 'error');\n      return {error: 'No AI provider configured'};\n    }\n\n    const task = options.task || 'ask';\n    const validTasks = ['explain', 'generate', 'test', 'analyze', 'ask'];\n\n    if(!validTasks.includes(task)) {\n      log(`${chalk.red('Error:')} Invalid task \"${task}\". Valid tasks are: ${validTasks.join(', ')}`, 'error');\n      return {error: `Invalid task \"${task}\"`};\n    }\n\n    const {prompt} = options;\n\n    if(!prompt) {\n      log(`${chalk.red('Error:')} No prompt provided. Use --prompt \"Your prompt here\"`, 'error');\n      return {error: 'No prompt provided'};\n    }\n\n    let context = '';\n\n    if(options.file) {\n      try {\n        const fs = await import('fs/promises');\n        const glob = await import('glob');\n        const files = await glob.glob(options.file);\n\n        if(files.length === 0) {\n          log(`${chalk.yellow('Warning:')} No files found matching \"${options.file}\"`, 'warning');\n        } else {\n          for(const file of files) {\n            const content = await fs.readFile(file, 'utf8');\n            context += `\\n===FILE: ${file}===\\n${content}\\n`;\n          }\n        }\n      } catch(error) {\n        log(`${chalk.yellow('Warning:')} Error reading file: ${error.message}`, 'warning');\n      }\n    }\n\n    if(options.dir) {\n      try {\n        const {execaSync} = await import('execa');\n        const result = execaSync('find', [options.dir, '-type', 'f', '|', 'sort']);\n        context += `\\n===Project structure:===\\n${result.stdout}\\n`;\n      } catch(error) {\n        log(`${chalk.yellow('Warning:')} Error reading directory: ${error.message}`, 'warning');\n      }\n    }\n\n    let formattedPrompt = '';\n\n    switch(task) {\n      case 'explain':\n        formattedPrompt = `Explain the following code:\\n${prompt}`;\n        break;\n      case 'generate':\n        formattedPrompt = `Generate code according to the following request:\\n${prompt}`;\n        break;\n      case 'test':\n        formattedPrompt = `Generate comprehensive unit tests:\\n${prompt}`;\n        break;\n      case 'analyze':\n        formattedPrompt = `Analyze the following code:\\n${prompt}`;\n        break;\n      case 'ask':\n        formattedPrompt = `Provide guidance on the following development question:\\n${prompt}`;\n        break;\n    }\n\n    if(context) {\n      formattedPrompt += `\\n===CONTEXT===\\n${context}`;\n    }\n\n    if((provider === 'cursor' || process.env.CURSOR_EXTENSION) && task === 'generate') {\n      log('Using Cursor IDE for code generation...', 'info');\n      log('Note: For full code generation capabilities, please use Cursor IDE directly with Cmd+L or Cmd+K.', 'info');\n      log('The CLI integration has limited capabilities for code generation.', 'warning');\n    } else if(provider === 'cursor' || process.env.CURSOR_EXTENSION) {\n      log('Using Cursor IDE for AI assistance...', 'info');\n      log('Note: This is a limited integration. For full AI capabilities, use Cursor IDE directly.', 'info');\n    } else {\n      log(`Using ${provider} for AI assistance...`, 'info');\n    }\n\n    const response = await callAIService(formattedPrompt, options.quiet || false);\n\n    log(`\\n${response}`, 'success');\n\n    return {response};\n  } catch(error) {\n    log(`${chalk.red('Error:')} ${error.message}`, 'error');\n    return {error: error.message};\n  }\n};\n\nexport const ai = new Command('ai')\n  .description('Use AI to help with development tasks')\n  .option('--provider <provider>', 'AI provider to use (openai, anthropic, cursor)')\n  .option('--task <task>', 'Task to perform (explain, generate, test, analyze, ask)')\n  .option('--prompt <prompt>', 'Prompt to send to AI')\n  .option('--file <file>', 'File to analyze')\n  .option('--dir <dir>', 'Directory to analyze')\n  .action(async (options: AIOptions) => {\n    await aiFunction(options);\n  });\n\nexport default ai;"],"names":["chalk","Command","readFileSync","sync","globSync","LexConfig","callAIService","log","process","env","CURSOR_EXTENSION","CURSOR_TERMINAL","CURSOR_APP","PATH","includes","CURSOR_SESSION_ID","CURSOR_IDE","getFileContext","filePath","content","_error","getProjectContext","options","file","task","context","projectContext","files","cwd","ignore","maxDepth","join","testConfig","webpackConfig","constructPrompt","prompt","taskInstructions","analyze","ask","explain","generate","help","optimize","test","taskInstruction","fullPrompt","displayResponse","response","quiet","choices","message","messageContent","responseContent","cleanedContent","cleanResponse","instruction","replace","trim","split","getProviderAuth","provider","AI_API_KEY","OPENAI_API_KEY","ANTHROPIC_API_KEY","GITHUB_TOKEN","undefined","detectCursorIDE","possibleCursorSignals","isCursorIDE","some","signal","aiFunction","config","aiConfig","ai","red","error","validTasks","fs","glob","length","yellow","readFile","dir","execaSync","result","stdout","formattedPrompt","description","option","action"],"mappings":"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"}