@nlabs/lex 1.46.2 → 1.47.1

package/dist/commands/ai/ai.js

@@ -0,0 +1,303 @@
+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/**", "**/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 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 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 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 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 += `
+===FILE: ${file}===
+${content}
+`;
+          }
+        }
+      } 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 += `
+===Project structure:===
+${result.stdout}
+`;
+      } catch (error) {
+        log(`${chalk.yellow("Warning:")} Error reading directory: ${error.message}`, "warning");
+      }
+    }
+    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;
+    }
+    if (context) {
+      formattedPrompt += `
+===CONTEXT===
+${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(`
+${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
+};
+//# 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/**', '**/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": []
}


package/dist/commands/ai/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Copyright (c) 2018-Present, Nitrogen Labs, Inc.
+ * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
+ */
+import ai, { type AIOptions } from './ai.js';
+export { ai };
+export type { AIOptions };
+export default ai;

package/dist/commands/ai/index.js

@@ -0,0 +1,7 @@
+import ai from "./ai.js";
+var ai_default = ai;
+export {
+  ai,
+  ai_default as default
+};
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vc3JjL2NvbW1hbmRzL2FpL2luZGV4LnRzIl0sCiAgInNvdXJjZXNDb250ZW50IjogWyIvKipcbiAqIENvcHlyaWdodCAoYykgMjAxOC1QcmVzZW50LCBOaXRyb2dlbiBMYWJzLCBJbmMuXG4gKiBDb3B5cmlnaHRzIGxpY2Vuc2VkIHVuZGVyIHRoZSBNSVQgTGljZW5zZS4gU2VlIHRoZSBhY2NvbXBhbnlpbmcgTElDRU5TRSBmaWxlIGZvciB0ZXJtcy5cbiAqL1xuaW1wb3J0IGFpLCB7dHlwZSBBSU9wdGlvbnN9IGZyb20gJy4vYWkuanMnO1xuXG5leHBvcnQge2FpfTtcbmV4cG9ydCB0eXBlIHtBSU9wdGlvbnN9O1xuZXhwb3J0IGRlZmF1bHQgYWk7Il0sCiAgIm1hcHBpbmdzIjogIkFBSUEsT0FBTyxRQUEwQjtBQUlqQyxJQUFPLGFBQVE7IiwKICAibmFtZXMiOiBbXQp9Cg==

package/dist/commands/build/build.cli.test.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Test file for build CLI argument generation
+ * This test focuses on CLI argument logic without importing problematic modules
+ */
+export {};

package/dist/commands/build/build.d.ts

@@ -0,0 +1,18 @@
+export interface BuildOptions {
+    readonly assist?: boolean;
+    readonly analyze?: boolean;
+    readonly bundler?: 'webpack' | 'esbuild';
+    readonly cliName?: string;
+    readonly format?: string;
+    readonly outputPath?: string;
+    readonly quiet?: boolean;
+    readonly remove?: boolean;
+    readonly sourcePath?: string;
+    readonly variables?: string;
+    readonly watch?: boolean;
+}
+export type BuildCallback = (status: number) => void;
+export declare const buildWithEsBuild: (spinner: any, commandOptions: BuildOptions, callback: BuildCallback) => Promise<0 | 1>;
+export declare const buildWithWebpack: (spinner: any, cmd: any, callback: any) => Promise<0 | 1>;
+export declare const build: (cmd: BuildOptions, callback?: BuildCallback) => Promise<number>;
+export default build;

package/dist/commands/build/build.integration.test.d.ts

@@ -0,0 +1 @@
+export {};