@nlabs/lex 1.46.2 → 1.47.1

package/__mocks__/LexConfig.js

@@ -0,0 +1,20 @@
+// Mock implementation of LexConfig
+const defaultConfigValues = {
+  bundler: 'webpack',
+  useTypescript: false,
+  useGraphQl: false,
+  targetEnvironment: 'web',
+  sourcePath: './src',
+  outputPath: './dist'
+};
+
+const LexConfig = {
+  config: defaultConfigValues,
+  parseConfig: jest.fn(),
+  checkTypescriptConfig: jest.fn()
+};
+
+module.exports = {
+  LexConfig,
+  defaultConfigValues
+};

package/__mocks__/boxen.js

@@ -0,0 +1,7 @@
+// Mock implementation of boxen
+const mockBoxen = jest.fn().mockImplementation((text, options) => {
+  return `[BOXED] ${text}`;
+});
+
+module.exports = mockBoxen;
+module.exports.default = mockBoxen;

package/__mocks__/build.js

@@ -0,0 +1,16 @@
+// Mock implementation of build module
+const mockSpinner = {
+  start: jest.fn(),
+  succeed: jest.fn(),
+  fail: jest.fn()
+};
+
+const build = jest.fn().mockResolvedValue(0);
+const buildWithEsBuild = jest.fn().mockResolvedValue(0);
+const buildWithWebpack = jest.fn().mockResolvedValue(0);
+
+module.exports = {
+  build,
+  buildWithEsBuild,
+  buildWithWebpack
+};

package/__mocks__/chalk.js

@@ -0,0 +1,23 @@
+// Mock implementation of chalk
+const createChalkMock = (text) => text;
+
+const chalkMock = {
+  red: createChalkMock,
+  green: createChalkMock,
+  blue: createChalkMock,
+  yellow: createChalkMock,
+  cyan: createChalkMock,
+  magenta: createChalkMock,
+  white: createChalkMock,
+  gray: createChalkMock,
+  grey: createChalkMock,
+  black: createChalkMock,
+  bold: createChalkMock,
+  dim: createChalkMock,
+  italic: createChalkMock,
+  underline: createChalkMock,
+  strikethrough: createChalkMock
+};
+
+module.exports = chalkMock;
+module.exports.default = chalkMock;

package/__mocks__/compile.js

@@ -0,0 +1,8 @@
+// Mock implementation of compile module
+const compile = jest.fn().mockResolvedValue(0);
+const hasFileType = jest.fn().mockReturnValue(false);
+
+module.exports = {
+  compile,
+  hasFileType
+};

package/__mocks__/execa.js

@@ -0,0 +1,21 @@
+// Mock implementation of execa
+const mockExeca = jest.fn().mockImplementation(() => ({
+  stdout: '',
+  stderr: '',
+  exitCode: 0,
+  command: 'mocked-command',
+  pid: 123
+}));
+
+mockExeca.sync = jest.fn().mockImplementation(() => ({
+  stdout: '',
+  stderr: '',
+  exitCode: 0,
+  command: 'mocked-command',
+  pid: 123
+}));
+
+module.exports = {
+  execa: mockExeca,
+  default: mockExeca
+};

package/__mocks__/ora.js

@@ -0,0 +1,17 @@
+// Mock implementation of ora
+const mockSpinner = {
+  start: jest.fn().mockReturnThis(),
+  stop: jest.fn().mockReturnThis(),
+  succeed: jest.fn().mockReturnThis(),
+  fail: jest.fn().mockReturnThis(),
+  warn: jest.fn().mockReturnThis(),
+  info: jest.fn().mockReturnThis(),
+  text: '',
+  color: 'cyan',
+  isSpinning: false
+};
+
+const mockOra = jest.fn().mockImplementation(() => mockSpinner);
+
+module.exports = mockOra;
+module.exports.default = mockOra;

package/__mocks__/versions.js

@@ -0,0 +1,12 @@
+// Mock implementation of versions module
+const jsonVersions = jest.fn().mockResolvedValue({});
+const packages = jest.fn().mockResolvedValue([]);
+const parseVersion = jest.fn().mockReturnValue('1.0.0');
+const versions = jest.fn().mockResolvedValue(undefined);
+
+module.exports = {
+  jsonVersions,
+  packages,
+  parseVersion,
+  versions
+};

package/dist/LexConfig.d.ts

@@ -0,0 +1,79 @@
+export interface EsbuildConfig {
+    entryPoints?: string[];
+    outdir?: string;
+    platform?: 'node' | 'browser';
+    target?: string;
+    format?: 'cjs' | 'esm';
+    minify?: boolean;
+    treeShaking?: boolean;
+    drop?: string[];
+    pure?: string[];
+    external?: string[];
+    splitting?: boolean;
+    metafile?: boolean;
+    sourcemap?: boolean | 'inline' | 'external';
+    legalComments?: 'none' | 'inline' | 'eof' | 'linked' | 'separate';
+    banner?: Record<string, string>;
+    footer?: Record<string, string>;
+    define?: Record<string, string>;
+    [key: string]: unknown;
+}
+export interface JestConfig {
+    roots?: string[];
+    testEnvironment?: string;
+    transform?: Record<string, [string, Record<string, unknown>]>;
+    transformIgnorePatterns?: string[];
+    moduleNameMapper?: Record<string, string>;
+    extensionsToTreatAsEsm?: string[];
+    preset?: string;
+    [key: string]: unknown;
+}
+export interface WebpackConfig {
+    entry?: string | string[];
+    output?: Record<string, unknown>;
+    module?: Record<string, unknown>;
+    plugins?: unknown[];
+    [key: string]: unknown;
+}
+export interface AIConfig {
+    provider?: 'cursor' | 'copilot' | 'openai' | 'anthropic' | 'none';
+    apiKey?: string;
+    model?: string;
+    maxTokens?: number;
+    temperature?: number;
+}
+export interface LexConfigType {
+    ai?: AIConfig;
+    configFiles?: string[];
+    copyFiles?: string[];
+    entryHTML?: string;
+    entryJs?: string;
+    esbuild?: EsbuildConfig;
+    env?: object;
+    gitUrl?: string;
+    jest?: JestConfig;
+    libraryName?: string;
+    libraryTarget?: string;
+    outputFile?: string;
+    outputFullPath?: string;
+    outputHash?: boolean;
+    outputPath?: string;
+    packageManager?: 'npm' | 'yarn';
+    preset?: 'web' | 'node' | 'lambda' | 'mobile';
+    sourceFullPath?: string;
+    sourcePath?: string;
+    targetEnvironment?: 'node' | 'web';
+    useGraphQl?: boolean;
+    useTypescript?: boolean;
+    webpack?: WebpackConfig;
+}
+export type Config = LexConfigType;
+export declare const defaultConfigValues: LexConfigType;
+export declare class LexConfig {
+    static config: LexConfigType;
+    static set useTypescript(value: boolean);
+    static updateConfig(updatedConfig: LexConfigType): LexConfigType;
+    static addConfigParams(cmd: any, params: LexConfigType): void;
+    static parseConfig(cmd: any, isRoot?: boolean): Promise<void>;
+    static checkTypescriptConfig(): void;
+}

package/dist/LexConfig.js

@@ -5,10 +5,26 @@ import { relativeFilePath } from "./utils/file.js";
 import { log } from "./utils/log.js";
 const cwd = process.cwd();
 const defaultConfigValues = {
+  ai: {
+    provider: "none",
+    model: "gpt-4o",
+    maxTokens: 4e3,
+    temperature: 0.1
+  },
   configFiles: [],
+  copyFiles: [],
   entryHTML: "index.html",
   entryJs: "index.js",
-  esbuild: {},
+  esbuild: {
+    minify: true,
+    treeShaking: true,
+    drop: ["console", "debugger"],
+    pure: ["console.log", "console.warn", "console.error"],
+    legalComments: "none",
+    splitting: true,
+    metafile: false,
+    sourcemap: false
+  },
   env: null,
   jest: {},
   outputFullPath: pathResolve(cwd, "./dist"),
@@ -41,9 +57,8 @@ class LexConfig {
       }
     }
   }
-  // Set options from a custom configuration file
   static updateConfig(updatedConfig) {
-    const { outputFullPath, outputPath, sourcePath, sourceFullPath, useTypescript } = updatedConfig;
+    const { outputFullPath, outputPath, sourcePath, sourceFullPath, useTypescript, ai } = updatedConfig;
     const cwd2 = process.cwd();
     if (useTypescript !== void 0) {
       LexConfig.useTypescript = useTypescript;
@@ -54,10 +69,15 @@ class LexConfig {
     if (sourcePath !== void 0 && sourceFullPath === void 0) {
       updatedConfig.sourceFullPath = pathResolve(cwd2, sourcePath);
     }
+    if (ai) {
+      LexConfig.config.ai = { ...LexConfig.config.ai, ...ai };
+      if (process.env.CURSOR_IDE === "true" && LexConfig.config.ai.provider === "none") {
+        LexConfig.config.ai.provider = "cursor";
+      }
+    }
     LexConfig.config = { ...LexConfig.config, ...updatedConfig };
     return LexConfig.config;
   }
-  // Set option updates from the command line
   static addConfigParams(cmd, params) {
     const nameProperty = "_name";
     const { environment, outputPath, sourcePath, typescript } = cmd;
@@ -85,13 +105,28 @@ class LexConfig {
       0
     );
   }
-  // Get configuration
   static async parseConfig(cmd, isRoot = true) {
-    const { cliName = "Lex", lexConfig, lexConfigName, quiet, typescript } = cmd;
-    const configName = lexConfigName || "lex.config.js";
-    const defaultConfigPath = isRoot ? pathResolve(cwd, `./${configName}`) : relativeFilePath(configName, cwd);
-    const configPath = lexConfig || defaultConfigPath;
-    const configExists = existsSync(configPath);
+    const { cliName = "Lex", lexConfig, lexConfigName, quiet, typescript, debug = false } = cmd;
+    const configFormats = ["js", "mjs", "cjs", "ts", "json"];
+    const configBaseName = lexConfigName || "lex.config";
+    let configPath = lexConfig || "";
+    let configExists = lexConfig ? existsSync(configPath) : false;
+    if (!configPath || !configExists) {
+      if (debug) {
+        log(`Searching for config files with base name: ${configBaseName}`, "info", quiet);
+      }
+      for (const format of configFormats) {
+        const potentialPath = isRoot ? pathResolve(cwd, `./${configBaseName}.${format}`) : relativeFilePath(`${configBaseName}.${format}`, cwd);
+        if (debug) {
+          log(`Checking for config file: ${potentialPath}`, "info", quiet);
+        }
+        if (existsSync(potentialPath)) {
+          configPath = potentialPath;
+          configExists = true;
+          break;
+        }
+      }
+    }
     if (configExists) {
       log(`Using ${cliName} configuration file: ${configPath}`, "note", quiet);
       const ext = pathExtname(configPath);
@@ -102,6 +137,8 @@ class LexConfig {
           try {
             configJson = JSON.parse(configContent)?.default || {};
           } catch (error) {
+            log(`
+${cliName} Error: Failed to parse JSON config: ${error.message}`, "error", quiet);
             configJson = {};
           }
           LexConfig.addConfigParams(cmd, configJson);
@@ -109,14 +146,45 @@ class LexConfig {
           log(`
 ${cliName} Error: Config file malformed, ${configPath}`, "error", quiet);
         }
-      } else if (ext === ".js") {
-        const lexCustomConfig = await import(configPath);
-        LexConfig.addConfigParams(cmd, lexCustomConfig.default || {});
+      } else if ([".js", ".mjs", ".cjs", ".ts"].includes(ext)) {
+        try {
+          let lexCustomConfig;
+          if (ext === ".cjs") {
+            const fileUrl = new URL(`file:///${pathResolve(configPath)}`).href;
+            if (debug) {
+              log(`Loading CommonJS config from: ${fileUrl}`, "info", quiet);
+            }
+            lexCustomConfig = await import(fileUrl);
+          } else {
+            if (debug) {
+              log(`Loading ESM/TS config from: ${configPath}`, "info", quiet);
+            }
+            lexCustomConfig = await import(configPath);
+          }
+          const config = lexCustomConfig.default || lexCustomConfig;
+          if (debug) {
+            log(`Loaded config: ${JSON.stringify(config, null, 2)}`, "info", quiet);
+          }
+          if (!config) {
+            log(`
+${cliName} Warning: Config file loaded but no configuration found`, "warn", quiet);
+          }
+          LexConfig.addConfigParams(cmd, config || {});
+        } catch (error) {
+          log(`
+${cliName} Error: Failed to load config file: ${error.message}`, "error", quiet);
+          if (debug) {
+            console.error(error);
+          }
+        }
       } else {
         log(`
-${cliName} Error: Config file must be a JS or JSON file.`, "error", quiet);
+${cliName} Error: Config file must be a JS, CJS, MJS, TS, or JSON file.`, "error", quiet);
       }
     } else {
+      if (debug) {
+        log("No config file found. Using default configuration.", "info", quiet);
+      }
       LexConfig.useTypescript = !!typescript;
       LexConfig.addConfigParams(cmd, LexConfig.config);
     }
@@ -133,4 +201,4 @@ export {
   LexConfig,
   defaultConfigValues
 };
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../src/LexConfig.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 {existsSync, readFileSync, writeFileSync} from 'fs';\nimport {extname as pathExtname, resolve as pathResolve} from 'path';\nimport {URL} from 'url';\n\nimport {relativeFilePath} from './utils/file.js';\nimport {log} from './utils/log.js';\n\nconst cwd: string = process.cwd();\n\nexport interface EsbuildConfig {\n  entryPoints?: string[];\n  outdir?: string;\n  platform?: 'node' | 'browser';\n  target?: string;\n  format?: 'cjs' | 'esm';\n  [key: string]: unknown;\n}\n\nexport interface JestConfig {\n  roots?: string[];\n  testEnvironment?: string;\n  transform?: Record<string, [string, Record<string, unknown>]>;\n  [key: string]: unknown;\n}\n\nexport interface WebpackConfig {\n  entry?: string | string[];\n  output?: Record<string, unknown>;\n  module?: Record<string, unknown>;\n  plugins?: unknown[];\n  [key: string]: unknown;\n}\n\nexport interface LexConfigType {\n  configFiles?: string[];\n  entryHTML?: string;\n  entryJs?: string;\n  esbuild?: EsbuildConfig;\n  env?: object;\n  gitUrl?: string;\n  jest?: JestConfig;\n  libraryName?: string;\n  libraryTarget?: string;\n  outputFile?: string;\n  outputFullPath?: string;\n  outputHash?: boolean;\n  outputPath?: string;\n  packageManager?: 'npm' | 'yarn';\n  preset?: 'web' | 'node' | 'lambda' | 'mobile';\n  sourceFullPath?: string;\n  sourcePath?: string;\n  targetEnvironment?: 'node' | 'web';\n  useGraphQl?: boolean;\n  useTypescript?: boolean;\n  webpack?: WebpackConfig;\n}\n\nexport const defaultConfigValues: LexConfigType = {\n  configFiles: [],\n  entryHTML: 'index.html',\n  entryJs: 'index.js',\n  esbuild: {},\n  env: null,\n  jest: {},\n  outputFullPath: pathResolve(cwd, './dist'),\n  outputHash: false,\n  outputPath: './dist',\n  packageManager: 'npm',\n  preset: 'web',\n  sourceFullPath: pathResolve(cwd, './src'),\n  sourcePath: './src',\n  targetEnvironment: 'web',\n  useGraphQl: false,\n  useTypescript: false,\n  webpack: {}\n};\n\nexport class LexConfig {\n  static config: LexConfigType = {\n    ...defaultConfigValues\n  };\n\n  static set useTypescript(value: boolean) {\n    LexConfig.config.useTypescript = value;\n    const {sourceFullPath} = LexConfig.config;\n\n    // Make sure we change the default entry file if Typescript is being used.\n    const {entryJs} = LexConfig.config;\n\n    if(entryJs === 'index.js' && value) {\n      const indexPath: string = pathResolve(cwd, sourceFullPath, 'index.tsx');\n      const hasIndexTsx: boolean = existsSync(indexPath);\n\n      if(hasIndexTsx) {\n        LexConfig.config.entryJs = 'index.tsx';\n      } else {\n        LexConfig.config.entryJs = 'index.ts';\n      }\n    }\n  }\n\n  // Set options from a custom configuration file\n  static updateConfig(updatedConfig: LexConfigType): LexConfigType {\n    const {outputFullPath, outputPath, sourcePath, sourceFullPath, useTypescript} = updatedConfig;\n    const cwd: string = process.cwd();\n\n    // Use Typescript\n    if(useTypescript !== undefined) {\n      LexConfig.useTypescript = useTypescript;\n    }\n\n    // Destination Path\n    if(outputPath !== undefined && outputFullPath === undefined) {\n      updatedConfig.outputFullPath = pathResolve(cwd, outputPath);\n    }\n\n    // Source code path\n    if(sourcePath !== undefined && sourceFullPath === undefined) {\n      updatedConfig.sourceFullPath = pathResolve(cwd, sourcePath);\n    }\n\n    LexConfig.config = {...LexConfig.config, ...updatedConfig};\n    return LexConfig.config;\n  }\n\n  // Set option updates from the command line\n  static addConfigParams(cmd, params: LexConfigType) {\n    const nameProperty: string = '_name';\n    const {environment, outputPath, sourcePath, typescript} = cmd;\n\n    // Custom output dir\n    if(outputPath !== undefined) {\n      params.outputPath = outputPath;\n      params.outputFullPath = pathResolve(cwd, outputPath);\n    }\n\n    // Custom source dir\n    if(sourcePath !== undefined) {\n      params.sourcePath = sourcePath;\n      params.sourceFullPath = pathResolve(cwd, sourcePath);\n    }\n\n    // Determine if we're using Typescript or Flow\n    if(typescript !== undefined) {\n      params.useTypescript = true;\n    }\n\n    // Set the target environment\n    if(environment !== undefined) {\n      params.targetEnvironment = environment === 'web' ? 'web' : 'node';\n    }\n\n    process.env.LEX_CONFIG = JSON.stringify(\n      {\n        ...LexConfig.updateConfig(params),\n        commandName: cmd[nameProperty],\n        isStatic: cmd.static\n      }, null, 0\n    );\n  }\n\n  // Get configuration\n  static async parseConfig(cmd, isRoot: boolean = true): Promise<void> {\n    const {cliName = 'Lex', lexConfig, lexConfigName, quiet, typescript} = cmd;\n    const configName: string = lexConfigName || 'lex.config.js';\n    const defaultConfigPath: string = isRoot\n      ? pathResolve(cwd, `./${configName}`)\n      : relativeFilePath(configName, cwd);\n    const configPath: string = lexConfig || defaultConfigPath;\n    const configExists: boolean = existsSync(configPath);\n\n    // If user has a Lex config file, lets use it.\n    if(configExists) {\n      log(`Using ${cliName} configuration file: ${configPath}`, 'note', quiet);\n      const ext: string = pathExtname(configPath);\n\n      if(ext === '.json') {\n        const configContent: string = readFileSync(configPath, 'utf8');\n\n        if(configContent) {\n          let configJson: LexConfigType;\n\n          try {\n            configJson = JSON.parse(configContent)?.default || {};\n          } catch(error) {\n            configJson = {};\n          }\n\n          LexConfig.addConfigParams(cmd, configJson);\n        } else {\n          log(`\\n${cliName} Error: Config file malformed, ${configPath}`, 'error', quiet);\n        }\n      } else if(ext === '.js') {\n        const lexCustomConfig = await import(configPath);\n        LexConfig.addConfigParams(cmd, lexCustomConfig.default || {});\n      } else {\n        log(`\\n${cliName} Error: Config file must be a JS or JSON file.`, 'error', quiet);\n      }\n    } else {\n      // Determine if we're using Typescript or Flow\n      LexConfig.useTypescript = !!typescript;\n\n      // Save config as environment variable for other commands to include\n      LexConfig.addConfigParams(cmd, LexConfig.config);\n    }\n  }\n\n  static checkTypescriptConfig() {\n    const tsconfigPath: string = pathResolve(cwd, './tsconfig.json');\n\n    if(!existsSync(tsconfigPath)) {\n      const dirName = new URL('.', import.meta.url).pathname;\n      writeFileSync(tsconfigPath, readFileSync(pathResolve(dirName, '../../../tsconfig.base.json')));\n    }\n  }\n}\n"],
  "mappings": "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",
  "names": ["cwd"]
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../src/LexConfig.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 {existsSync, readFileSync, writeFileSync} from 'fs';\nimport {extname as pathExtname, resolve as pathResolve} from 'path';\nimport {URL} from 'url';\n\nimport {relativeFilePath} from './utils/file.js';\nimport {log} from './utils/log.js';\n\nconst cwd: string = process.cwd();\n\nexport interface EsbuildConfig {\n  entryPoints?: string[];\n  outdir?: string;\n  platform?: 'node' | 'browser';\n  target?: string;\n  format?: 'cjs' | 'esm';\n  minify?: boolean;\n  treeShaking?: boolean;\n  drop?: string[];\n  pure?: string[];\n  external?: string[];\n  splitting?: boolean;\n  metafile?: boolean;\n  sourcemap?: boolean | 'inline' | 'external';\n  legalComments?: 'none' | 'inline' | 'eof' | 'linked' | 'separate';\n  banner?: Record<string, string>;\n  footer?: Record<string, string>;\n  define?: Record<string, string>;\n  [key: string]: unknown;\n}\n\nexport interface JestConfig {\n  roots?: string[];\n  testEnvironment?: string;\n  transform?: Record<string, [string, Record<string, unknown>]>;\n  transformIgnorePatterns?: string[];\n  moduleNameMapper?: Record<string, string>;\n  extensionsToTreatAsEsm?: string[];\n  preset?: string;\n  [key: string]: unknown;\n}\n\nexport interface WebpackConfig {\n  entry?: string | string[];\n  output?: Record<string, unknown>;\n  module?: Record<string, unknown>;\n  plugins?: unknown[];\n  [key: string]: unknown;\n}\n\nexport interface AIConfig {\n  provider?: 'cursor' | 'copilot' | 'openai' | 'anthropic' | 'none';\n  apiKey?: string;\n  model?: string;\n  maxTokens?: number;\n  temperature?: number;\n}\nexport interface LexConfigType {\n  ai?: AIConfig;\n  configFiles?: string[];\n  copyFiles?: string[];\n  entryHTML?: string;\n  entryJs?: string;\n  esbuild?: EsbuildConfig;\n  env?: object;\n  gitUrl?: string;\n  jest?: JestConfig;\n  libraryName?: string;\n  libraryTarget?: string;\n  outputFile?: string;\n  outputFullPath?: string;\n  outputHash?: boolean;\n  outputPath?: string;\n  packageManager?: 'npm' | 'yarn';\n  preset?: 'web' | 'node' | 'lambda' | 'mobile';\n  sourceFullPath?: string;\n  sourcePath?: string;\n  targetEnvironment?: 'node' | 'web';\n  useGraphQl?: boolean;\n  useTypescript?: boolean;\n  webpack?: WebpackConfig;\n}\n\nexport type Config = LexConfigType;\n\nexport const defaultConfigValues: LexConfigType = {\n  ai: {\n    provider: 'none',\n    model: 'gpt-4o',\n    maxTokens: 4000,\n    temperature: 0.1\n  },\n  configFiles: [],\n  copyFiles: [],\n  entryHTML: 'index.html',\n  entryJs: 'index.js',\n  esbuild: {\n    minify: true,\n    treeShaking: true,\n    drop: ['console', 'debugger'],\n    pure: ['console.log', 'console.warn', 'console.error'],\n    legalComments: 'none',\n    splitting: true,\n    metafile: false,\n    sourcemap: false\n  },\n  env: null,\n  jest: {},\n  outputFullPath: pathResolve(cwd, './dist'),\n  outputHash: false,\n  outputPath: './dist',\n  packageManager: 'npm',\n  preset: 'web',\n  sourceFullPath: pathResolve(cwd, './src'),\n  sourcePath: './src',\n  targetEnvironment: 'web',\n  useGraphQl: false,\n  useTypescript: false,\n  webpack: {}\n};\n\nexport class LexConfig {\n  static config: LexConfigType = {\n    ...defaultConfigValues\n  };\n\n  static set useTypescript(value: boolean) {\n    LexConfig.config.useTypescript = value;\n    const {sourceFullPath} = LexConfig.config;\n\n    const {entryJs} = LexConfig.config;\n\n    if(entryJs === 'index.js' && value) {\n      const indexPath: string = pathResolve(cwd, sourceFullPath, 'index.tsx');\n      const hasIndexTsx: boolean = existsSync(indexPath);\n\n      if(hasIndexTsx) {\n        LexConfig.config.entryJs = 'index.tsx';\n      } else {\n        LexConfig.config.entryJs = 'index.ts';\n      }\n    }\n  }\n\n  static updateConfig(updatedConfig: LexConfigType): LexConfigType {\n    const {outputFullPath, outputPath, sourcePath, sourceFullPath, useTypescript, ai} = updatedConfig;\n    const cwd: string = process.cwd();\n\n    if(useTypescript !== undefined) {\n      LexConfig.useTypescript = useTypescript;\n    }\n\n    if(outputPath !== undefined && outputFullPath === undefined) {\n      updatedConfig.outputFullPath = pathResolve(cwd, outputPath);\n    }\n\n    if(sourcePath !== undefined && sourceFullPath === undefined) {\n      updatedConfig.sourceFullPath = pathResolve(cwd, sourcePath);\n    }\n\n    if(ai) {\n      LexConfig.config.ai = {...LexConfig.config.ai, ...ai};\n\n      if(process.env.CURSOR_IDE === 'true' && LexConfig.config.ai.provider === 'none') {\n        LexConfig.config.ai.provider = 'cursor';\n      }\n    }\n\n    LexConfig.config = {...LexConfig.config, ...updatedConfig};\n\n    return LexConfig.config;\n  }\n\n  static addConfigParams(cmd, params: LexConfigType) {\n    const nameProperty: string = '_name';\n    const {environment, outputPath, sourcePath, typescript} = cmd;\n\n    if(outputPath !== undefined) {\n      params.outputPath = outputPath;\n      params.outputFullPath = pathResolve(cwd, outputPath);\n    }\n\n    if(sourcePath !== undefined) {\n      params.sourcePath = sourcePath;\n      params.sourceFullPath = pathResolve(cwd, sourcePath);\n    }\n\n    if(typescript !== undefined) {\n      params.useTypescript = true;\n    }\n\n    if(environment !== undefined) {\n      params.targetEnvironment = environment === 'web' ? 'web' : 'node';\n    }\n\n    process.env.LEX_CONFIG = JSON.stringify(\n      {\n        ...LexConfig.updateConfig(params),\n        commandName: cmd[nameProperty],\n        isStatic: cmd.static\n      }, null, 0\n    );\n  }\n\n  static async parseConfig(cmd, isRoot: boolean = true): Promise<void> {\n    const {cliName = 'Lex', lexConfig, lexConfigName, quiet, typescript, debug = false} = cmd;\n    const configFormats = ['js', 'mjs', 'cjs', 'ts', 'json'];\n    const configBaseName: string = lexConfigName || 'lex.config';\n    let configPath: string = lexConfig || '';\n    let configExists: boolean = lexConfig ? existsSync(configPath) : false;\n\n    if(!configPath || !configExists) {\n      if(debug) {\n        log(`Searching for config files with base name: ${configBaseName}`, 'info', quiet);\n      }\n\n      for(const format of configFormats) {\n        const potentialPath = isRoot\n          ? pathResolve(cwd, `./${configBaseName}.${format}`)\n          : relativeFilePath(`${configBaseName}.${format}`, cwd);\n\n        if(debug) {\n          log(`Checking for config file: ${potentialPath}`, 'info', quiet);\n        }\n\n        if(existsSync(potentialPath)) {\n          configPath = potentialPath;\n          configExists = true;\n          break;\n        }\n      }\n    }\n\n    if(configExists) {\n      log(`Using ${cliName} configuration file: ${configPath}`, 'note', quiet);\n      const ext: string = pathExtname(configPath);\n\n      if(ext === '.json') {\n        const configContent: string = readFileSync(configPath, 'utf8');\n\n        if(configContent) {\n          let configJson: LexConfigType;\n\n          try {\n            configJson = JSON.parse(configContent)?.default || {};\n          } catch(error) {\n            log(`\\n${cliName} Error: Failed to parse JSON config: ${error.message}`, 'error', quiet);\n            configJson = {};\n          }\n\n          LexConfig.addConfigParams(cmd, configJson);\n        } else {\n          log(`\\n${cliName} Error: Config file malformed, ${configPath}`, 'error', quiet);\n        }\n      } else if(['.js', '.mjs', '.cjs', '.ts'].includes(ext)) {\n        try {\n          let lexCustomConfig;\n\n          if(ext === '.cjs') {\n            const fileUrl = new URL(`file:///${pathResolve(configPath)}`).href;\n\n            if(debug) {\n              log(`Loading CommonJS config from: ${fileUrl}`, 'info', quiet);\n            }\n            lexCustomConfig = await import(fileUrl);\n          } else {\n            if(debug) {\n              log(`Loading ESM/TS config from: ${configPath}`, 'info', quiet);\n            }\n\n            lexCustomConfig = await import(configPath);\n          }\n\n          const config = lexCustomConfig.default || lexCustomConfig;\n\n          if(debug) {\n            log(`Loaded config: ${JSON.stringify(config, null, 2)}`, 'info', quiet);\n          }\n\n          if(!config) {\n            log(`\\n${cliName} Warning: Config file loaded but no configuration found`, 'warn', quiet);\n          }\n\n          LexConfig.addConfigParams(cmd, config || {});\n        } catch(error) {\n          log(`\\n${cliName} Error: Failed to load config file: ${error.message}`, 'error', quiet);\n          if(debug) {\n            console.error(error);\n          }\n        }\n      } else {\n        log(`\\n${cliName} Error: Config file must be a JS, CJS, MJS, TS, or JSON file.`, 'error', quiet);\n      }\n    } else {\n      if(debug) {\n        log('No config file found. Using default configuration.', 'info', quiet);\n      }\n\n      LexConfig.useTypescript = !!typescript;\n      LexConfig.addConfigParams(cmd, LexConfig.config);\n    }\n  }\n\n  static checkTypescriptConfig() {\n    const tsconfigPath: string = pathResolve(cwd, './tsconfig.json');\n\n    if(!existsSync(tsconfigPath)) {\n      const dirName = new URL('.', import.meta.url).pathname;\n      writeFileSync(tsconfigPath, readFileSync(pathResolve(dirName, '../../../tsconfig.base.json')));\n    }\n  }\n}"],
  "mappings": "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",
  "names": ["cwd"]
}


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

@@ -0,0 +1,17 @@
+import { Command } from 'commander';
+export interface AIOptions {
+    readonly cliName?: string;
+    readonly context?: boolean;
+    readonly file?: string;
+    readonly lexConfig?: string;
+    readonly model?: string;
+    readonly prompt?: string;
+    readonly quiet?: boolean;
+    readonly task?: 'generate' | 'explain' | 'test' | 'optimize' | 'help' | 'ask' | 'analyze';
+    readonly debug?: boolean;
+    readonly provider?: string;
+    readonly dir?: string;
+}
+export declare const aiFunction: (options: AIOptions) => Promise<any>;
+export declare const ai: Command;
+export default ai;