@nlabs/lex 1.47.1 → 1.47.3

package/.gitattributes

@@ -0,0 +1 @@
+/.pnp.*              binary linguist-generated

package/.storybook/main.ts

@@ -0,0 +1,86 @@
+import type { StorybookConfig } from '@storybook/react-webpack5';
+import { dirname, resolve } from 'path';
+
+const getLexNodeModulesPath = () => {
+  const lexPackageRoot = dirname(__dirname); // Go up from .storybook to lex root
+  return resolve(lexPackageRoot, 'node_modules');
+};
+
+const lexModule = (modulePath: string) => resolve(getLexNodeModulesPath(), modulePath);
+
+const config: StorybookConfig = {
+  addons: [
+    lexModule('@storybook/addon-docs'),
+    lexModule('@storybook/addon-links'),
+    lexModule('@storybook/addon-themes')
+  ],
+  framework: {
+    name: lexModule('@storybook/react-webpack5'),
+    options: {
+      builder: {
+        useSWC: true
+      }
+    }
+  },
+  stories: ['../src/**/*.mdx', '../src/**/*.stories.@(ts|tsx)'],
+  webpackFinal: async (config) => ({
+    ...config,
+    module: {
+      ...config.module,
+      rules: [
+        ...(config.module?.rules || []),
+        {
+          loader: lexModule('babel-loader/lib/index.js'),
+          options: {
+            babelrc: false,
+            plugins: [
+              ['@babel/plugin-transform-nullish-coalescing-operator'],
+              ['@babel/plugin-transform-optional-chaining']
+            ],
+            presets: [
+              '@babel/preset-typescript',
+              [
+                '@babel/preset-react',
+                {
+                  runtime: 'automatic'
+                }
+              ]
+            ]
+          },
+          test: /\.(ts|tsx)$/
+        }
+      ]
+    },
+    resolve: {
+      ...config.resolve,
+      extensions: ['.js', '.ts', '.tsx'],
+      plugins: [
+        ...(config.resolve?.plugins || [])
+      ],
+      fallback: {
+        ...config.resolve?.fallback,
+        "process": require.resolve("process/browser"),
+        "buffer": require.resolve("buffer"),
+        "util": require.resolve("util"),
+        "stream": require.resolve("stream-browserify"),
+        "crypto": require.resolve("crypto-browserify"),
+        "path": require.resolve("path-browserify"),
+        "os": require.resolve("os-browserify/browser"),
+        "vm": require.resolve("vm-browserify"),
+        "fs": false,
+        "net": false,
+        "tls": false
+      }
+    },
+    plugins: [
+      ...(config.plugins || []),
+      new (require('webpack')).ProvidePlugin({
+        process: 'process/browser',
+        Buffer: ['buffer', 'Buffer']
+      })
+    ],
+    stats: 'verbose'
+  })
+};
+
+export default config;

package/.storybook/preview.ts

@@ -0,0 +1,15 @@
+import type { Preview } from '@storybook/react';
+
+const preview: Preview = {
+  parameters: {
+    actions: { argTypesRegex: '^on[A-Z].*' },
+    controls: {
+      matchers: {
+        color: /(background|color)$/i,
+        date: /Date$/,
+      },
+    },
+  },
+};
+
+export default preview;

package/.vscode/settings.json

@@ -0,0 +1,83 @@
+{
+  "[javascript]": {
+    "editor.defaultFormatter": "dbaeumer.vscode-eslint"
+  },
+  "[javascriptreact]": {
+    "editor.defaultFormatter": "dbaeumer.vscode-eslint"
+  },
+  "[typescript]": {
+    "editor.defaultFormatter": "vscode.typescript-language-features"
+  },
+  "[typescriptreact]": {
+    "editor.defaultFormatter": "dbaeumer.vscode-eslint"
+  },
+  "cSpell.words": [
+    "lex",
+    "nitrogenlabs",
+    "nlabs",
+    "transpiler"
+  ],
+  "css.validate": false,
+  "editor.autoClosingBrackets": "never",
+  "editor.codeActionsOnSave": {
+    "source.fixAll.eslint": "explicit",
+    "source.organizeImports": "explicit"
+  },
+  "editor.detectIndentation": false,
+  "editor.formatOnSave": true,
+  "editor.rulers": [
+    120
+  ],
+  "editor.tabCompletion": "on",
+  "editor.tabSize": 2,
+  "editor.wordWrap": "off",
+  "editor.wordWrapColumn": 120,
+  "editor.wrappingIndent": "indent",
+  "emmet.includeLanguages": {
+    "postcss": "css"
+  },
+  "emmet.syntaxProfiles": {
+    "postcss": "css"
+  },
+  "eslint.enable": true,
+  "eslint.experimental.useFlatConfig": true,
+  "eslint.format.enable": true,
+  "eslint.lintTask.enable": true,
+  "eslint.nodePath": "./node_modules",
+  "eslint.options": {
+    "overrideConfigFile": "./eslint.config.js"
+  },
+  "eslint.run": "onType",
+  "eslint.runtime": "./node_modules/eslint/bin/eslint.js",
+  "eslint.validate": [
+    "javascript",
+    "javascriptreact",
+    "typescript",
+    "typescriptreact"
+  ],
+  "eslint.workingDirectories": [
+    "."
+  ],
+  "explorer.confirmDragAndDrop": false,
+  "explorer.decorations.badges": false,
+  "files.autoSave": "onFocusChange",
+  "files.trimTrailingWhitespace": true,
+  "html.autoClosingTags": false,
+  "html.format.enable": false,
+  "html.format.extraLiners": "",
+  "html.format.indentHandlebars": true,
+  "html.format.indentInnerHtml": true,
+  "html.suggest.html5": false,
+  "javascript.format.insertSpaceAfterFunctionKeywordForAnonymousFunctions": false,
+  "javascript.format.insertSpaceAfterKeywordsInControlFlowStatements": false,
+  "javascript.format.insertSpaceAfterOpeningAndBeforeClosingNonemptyBraces": false,
+  "javascript.format.insertSpaceAfterOpeningAndBeforeClosingNonemptyBrackets": false,
+  "javascript.updateImportsOnFileMove.enabled": "never",
+  "prettier.enable": false,
+  "typescript.format.insertSpaceAfterFunctionKeywordForAnonymousFunctions": false,
+  "typescript.format.insertSpaceAfterKeywordsInControlFlowStatements": false,
+  "typescript.format.insertSpaceAfterOpeningAndBeforeClosingNonemptyBraces": false,
+  "typescript.format.insertSpaceAfterOpeningAndBeforeClosingNonemptyBrackets": false,
+  "typescript.updateImportsOnFileMove.enabled": "never",
+  "window.zoomLevel": 0
+}

package/CHANGELOG.md

@@ -0,0 +1 @@
+# Changes

package/TYPESCRIPT_CONFIGS.md

@@ -0,0 +1,103 @@
+# TypeScript Configurations in Lex
+
+Lex now uses specialized TypeScript configurations for different commands to optimize performance and functionality.
+
+## Configuration Files
+
+### 1. `tsconfig.build.json` - For Compilation and Building
+
+Used by: `lex compile`, `lex build`
+
+**Purpose:** Optimized for compilation and bundling with ESM output.
+
+**Key Features:**
+
+- ESM module format (`"module": "ESNext"`)
+- Declaration file generation (`"declaration": true`)
+- Source maps for debugging (`"inlineSourceMap": true`)
+- Strict type checking (`"strict": true`)
+- Excludes test files for faster compilation
+
+**Use Cases:**
+
+- Building production bundles
+- Generating type declarations
+- Compiling source code for distribution
+
+### 2. `tsconfig.lint.json` - For Static Analysis
+
+Used by: `lex lint`
+
+**Purpose:** Optimized for static analysis and linting.
+
+**Key Features:**
+
+- No emission (`"noEmit": true`)
+- Strict unused variable checking (`"noUnusedLocals": true`)
+- Disabled pretty printing for faster analysis
+- Excludes test files to focus on source code
+- ESLint-friendly settings
+
+**Use Cases:**
+
+- Static type checking
+- Code quality analysis
+- Linting with ESLint + TypeScript
+
+### 3. `tsconfig.test.json` - For Testing
+
+Used by: `lex test`
+
+**Purpose:** Optimized for testing environment.
+
+**Key Features:**
+
+- Includes test files (`**/*.test.*`, `**/*.spec.*`)
+- Jest types included (`"types": ["jest", "node"]`)
+- Relaxed strict mode for test flexibility (`"strict": false`)
+- Source maps for debugging tests
+- Coverage reporting support
+
+**Use Cases:**
+
+- Running unit tests
+- Integration testing
+- Test debugging and coverage
+
+## Automatic Configuration
+
+Lex automatically creates these configuration files when needed:
+
+1. **First run:** If no specialized config exists, Lex creates it from templates
+2. **Fallback:** If specialized config doesn't exist, falls back to default `tsconfig.json`
+3. **Custom configs:** You can override any config by creating your own version
+
+## Migration from Single Config
+
+If you're migrating from a single `tsconfig.json`:
+
+1. **Keep your existing config:** It will be used as a fallback
+2. **Customize specialized configs:** Modify the generated configs for your needs
+3. **Gradual adoption:** Commands will automatically use the appropriate config
+
+## Customization
+
+You can customize any of these configurations:
+
+```json
+// tsconfig.build.json - Customize for your build needs
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "outDir": "./lib",  // Custom output directory
+    "target": "ES2020"  // Custom target
+  }
+}
+```
+
+## Benefits
+
+1. **Performance:** Each config is optimized for its specific use case
+2. **Clarity:** Clear separation of concerns between compilation, linting, and testing
+3. **Flexibility:** Easy to customize each workflow independently
+4. **Compatibility:** Maintains backward compatibility with existing setups

package/__mocks__/LexConfig.js

@@ -11,10 +11,25 @@ const defaultConfigValues = {
 const LexConfig = {
   config: defaultConfigValues,
   parseConfig: jest.fn(),
-  checkTypescriptConfig: jest.fn()
+  checkTypescriptConfig: jest.fn(),
+  checkCompileTypescriptConfig: jest.fn(),
+  checkLintTypescriptConfig: jest.fn(),
+  checkTestTypescriptConfig: jest.fn(),
+  getLexDir: jest.fn(() => '/mock/lex/dir'),
+  updateConfig: jest.fn((config) => ({ ...defaultConfigValues, ...config })),
+  addConfigParams: jest.fn(),
+  get useTypescript() {
+    return this.config.useTypescript;
+  },
+  set useTypescript(value) {
+    this.config.useTypescript = value;
+  }
 };
 
+const getTypeScriptConfigPath = jest.fn((configName) => `/mock/lex/dir/${configName}`);
+
 module.exports = {
   LexConfig,
-  defaultConfigValues
+  defaultConfigValues,
+  getTypeScriptConfigPath
 };

package/__mocks__/execa.js

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

package/__mocks__/file.js

@@ -0,0 +1,50 @@
+const path = require('path');
+const fs = require('fs');
+
+// Mock implementations that don't use import.meta.url
+function getDirName() {
+  return process.cwd();
+}
+
+function getFilePath(relativePath) {
+  // For testing, resolve relative to process.cwd()
+  return path.resolve(process.cwd(), relativePath);
+}
+
+function getLexPackageJsonPath() {
+  // For testing, return a mock path
+  return path.resolve(process.cwd(), 'package.json');
+}
+
+function relativeFilePath(filename, dirPath = './', backUp = 0) {
+  // Mock implementation
+  return path.resolve(process.cwd(), filename);
+}
+
+function relativeNodePath(filename, dirPath = './', backUp = 0) {
+  // Mock implementation
+  return path.resolve(process.cwd(), `node_modules/${filename}`);
+}
+
+function getNodePath(moduleName) {
+  // Mock implementation
+  return path.resolve(process.cwd(), `node_modules/${moduleName}`);
+}
+
+function resolveBinaryPath(binaryName, packageName) {
+  // Mock implementation
+  if (packageName) {
+    return path.resolve(process.cwd(), `node_modules/${packageName}/bin/${binaryName}`);
+  }
+  return path.resolve(process.cwd(), `node_modules/.bin/${binaryName}`);
+}
+
+module.exports = {
+  getDirName,
+  getFilePath,
+  getLexPackageJsonPath,
+  relativeFilePath,
+  relativeNodePath,
+  getNodePath,
+  resolveBinaryPath
+};

package/__mocks__/ora.js

@@ -13,5 +13,14 @@ const mockSpinner = {
 
 const mockOra = jest.fn().mockImplementation(() => mockSpinner);
 
-module.exports = mockOra;
+module.exports = () => ({
+  start: jest.fn().mockReturnThis(),
+  succeed: jest.fn().mockReturnThis(),
+  fail: jest.fn().mockReturnThis(),
+  stop: jest.fn().mockReturnThis(),
+  info: jest.fn().mockReturnThis(),
+  warn: jest.fn().mockReturnThis(),
+  text: ''
+});
+
 module.exports.default = mockOra;

package/config.json

@@ -0,0 +1,33 @@
+{
+  "useTypescript": true,
+  "sourcePath": "./src",
+  "outputPath": "./dist",
+  "targetEnvironment": "web",
+  "preset": "web",
+  "packageManager": "npm",
+  "ai": {
+    "provider": "none",
+    "model": "gpt-4o",
+    "maxTokens": 4000,
+    "temperature": 0.1
+  },
+  "esbuild": {
+    "minify": true,
+    "treeShaking": true,
+    "drop": [],
+    "pure": [],
+    "legalComments": "none",
+    "splitting": true,
+    "metafile": false,
+    "sourcemap": false
+  },
+  "webpack": {},
+  "jest": {},
+  "outputHash": false,
+  "useGraphQl": false,
+  "configFiles": [],
+  "copyFiles": [],
+  "entryHTML": "index.html",
+  "entryJs": "index.js",
+  "env": null
+}

package/dist/LexConfig.js

@@ -1,7 +1,7 @@
 import { existsSync, readFileSync, writeFileSync } from "fs";
-import { extname as pathExtname, resolve as pathResolve } from "path";
+import { dirname, extname as pathExtname, resolve as pathResolve } from "path";
 import { URL } from "url";
-import { relativeFilePath } from "./utils/file.js";
+import { getDirName, getLexPackageJsonPath, relativeFilePath } from "./utils/file.js";
 import { log } from "./utils/log.js";
 const cwd = process.cwd();
 const defaultConfigValues = {
@@ -39,10 +39,67 @@ const defaultConfigValues = {
   useTypescript: false,
   webpack: {}
 };
+function findLexRoot(startDir) {
+  let dir = startDir;
+  console.log("DEBUG: findLexRoot starting with dir:", dir);
+  while (dir !== "/" && dir !== ".") {
+    const pkgPath = pathResolve(dir, "package.json");
+    console.log("DEBUG: findLexRoot checking", pkgPath);
+    if (existsSync(pkgPath)) {
+      try {
+        const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
+        if (pkg.name === "@nlabs/lex") {
+          return dir;
+        }
+      } catch {
+      }
+    }
+    const parent = dirname(dir);
+    console.log("DEBUG: findLexRoot parent of", dir, "is", parent);
+    if (parent === dir) {
+      break;
+    }
+    dir = parent;
+  }
+  throw new Error("Could not find @nlabs/lex root");
+}
+function getTypeScriptConfigPath(configName) {
+  const cwd2 = process.cwd();
+  if (configName === "tsconfig.build.json") {
+    const projectBuildConfig = pathResolve(cwd2, "tsconfig.build.json");
+    if (existsSync(projectBuildConfig)) {
+      return projectBuildConfig;
+    }
+  }
+  if (configName === "tsconfig.lint.json") {
+    const projectLintConfig = pathResolve(cwd2, "tsconfig.eslint.json");
+    if (existsSync(projectLintConfig)) {
+      return projectLintConfig;
+    }
+  }
+  if (configName === "tsconfig.test.json") {
+    const projectTestConfig = pathResolve(cwd2, "tsconfig.test.json");
+    if (existsSync(projectTestConfig)) {
+      return projectTestConfig;
+    }
+  }
+  const projectConfigPath = pathResolve(cwd2, configName);
+  if (existsSync(projectConfigPath)) {
+    return projectConfigPath;
+  }
+  const lexDir = LexConfig.getLexDir();
+  return pathResolve(lexDir, configName);
+}
 class LexConfig {
   static config = {
     ...defaultConfigValues
   };
+  /**
+   * Get the Lex package root directory, handling both development and installed environments
+   */
+  static getLexDir() {
+    return dirname(getLexPackageJsonPath());
+  }
   static set useTypescript(value) {
     LexConfig.config.useTypescript = value;
     const { sourceFullPath } = LexConfig.config;
@@ -192,13 +249,44 @@ ${cliName} Error: Config file must be a JS, CJS, MJS, TS, or JSON file.`, "error
   static checkTypescriptConfig() {
     const tsconfigPath = pathResolve(cwd, "./tsconfig.json");
     if (!existsSync(tsconfigPath)) {
-      const dirName = new URL(".", import.meta.url).pathname;
+      const dirName = getDirName();
       writeFileSync(tsconfigPath, readFileSync(pathResolve(dirName, "../../../tsconfig.base.json")));
     }
   }
+  static checkCompileTypescriptConfig() {
+    const lexDir = LexConfig.getLexDir();
+    const tsconfigCompilePath = pathResolve(lexDir, "./tsconfig.build.json");
+    if (!existsSync(tsconfigCompilePath)) {
+      const templatePath = pathResolve(lexDir, "tsconfig.build.json");
+      if (existsSync(templatePath)) {
+        writeFileSync(tsconfigCompilePath, readFileSync(templatePath));
+      }
+    }
+  }
+  static checkLintTypescriptConfig() {
+    const lexDir = LexConfig.getLexDir();
+    const tsconfigLintPath = pathResolve(lexDir, "./tsconfig.lint.json");
+    if (!existsSync(tsconfigLintPath)) {
+      const templatePath = pathResolve(lexDir, "tsconfig.lint.json");
+      if (existsSync(templatePath)) {
+        writeFileSync(tsconfigLintPath, readFileSync(templatePath));
+      }
+    }
+  }
+  static checkTestTypescriptConfig() {
+    const lexDir = LexConfig.getLexDir();
+    const tsconfigTestPath = pathResolve(lexDir, "./tsconfig.test.json");
+    if (!existsSync(tsconfigTestPath)) {
+      const templatePath = pathResolve(lexDir, "tsconfig.test.json");
+      if (existsSync(templatePath)) {
+        writeFileSync(tsconfigTestPath, readFileSync(templatePath));
+      }
+    }
+  }
 }
 export {
   LexConfig,
-  defaultConfigValues
+  defaultConfigValues,
+  getTypeScriptConfigPath
 };
-//# 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": "AAIA,SAAQ,YAAY,cAAc,qBAAoB;AACtD,SAAQ,WAAW,aAAa,WAAW,mBAAkB;AAC7D,SAAQ,WAAU;AAElB,SAAQ,wBAAuB;AAC/B,SAAQ,WAAU;AAElB,MAAM,MAAc,QAAQ,IAAI;AA6EzB,MAAM,sBAAqC;AAAA,EAChD,IAAI;AAAA,IACF,UAAU;AAAA,IACV,OAAO;AAAA,IACP,WAAW;AAAA,IACX,aAAa;AAAA,EACf;AAAA,EACA,aAAa,CAAC;AAAA,EACd,WAAW,CAAC;AAAA,EACZ,WAAW;AAAA,EACX,SAAS;AAAA,EACT,SAAS;AAAA,IACP,QAAQ;AAAA,IACR,aAAa;AAAA,IACb,MAAM,CAAC,WAAW,UAAU;AAAA,IAC5B,MAAM,CAAC,eAAe,gBAAgB,eAAe;AAAA,IACrD,eAAe;AAAA,IACf,WAAW;AAAA,IACX,UAAU;AAAA,IACV,WAAW;AAAA,EACb;AAAA,EACA,KAAK;AAAA,EACL,MAAM,CAAC;AAAA,EACP,gBAAgB,YAAY,KAAK,QAAQ;AAAA,EACzC,YAAY;AAAA,EACZ,YAAY;AAAA,EACZ,gBAAgB;AAAA,EAChB,QAAQ;AAAA,EACR,gBAAgB,YAAY,KAAK,OAAO;AAAA,EACxC,YAAY;AAAA,EACZ,mBAAmB;AAAA,EACnB,YAAY;AAAA,EACZ,eAAe;AAAA,EACf,SAAS,CAAC;AACZ;AAEO,MAAM,UAAU;AAAA,EACrB,OAAO,SAAwB;AAAA,IAC7B,GAAG;AAAA,EACL;AAAA,EAEA,WAAW,cAAc,OAAgB;AACvC,cAAU,OAAO,gBAAgB;AACjC,UAAM,EAAC,eAAc,IAAI,UAAU;AAEnC,UAAM,EAAC,QAAO,IAAI,UAAU;AAE5B,QAAG,YAAY,cAAc,OAAO;AAClC,YAAM,YAAoB,YAAY,KAAK,gBAAgB,WAAW;AACtE,YAAM,cAAuB,WAAW,SAAS;AAEjD,UAAG,aAAa;AACd,kBAAU,OAAO,UAAU;AAAA,MAC7B,OAAO;AACL,kBAAU,OAAO,UAAU;AAAA,MAC7B;AAAA,IACF;AAAA,EACF;AAAA,EAEA,OAAO,aAAa,eAA6C;AAC/D,UAAM,EAAC,gBAAgB,YAAY,YAAY,gBAAgB,eAAe,GAAE,IAAI;AACpF,UAAMA,OAAc,QAAQ,IAAI;AAEhC,QAAG,kBAAkB,QAAW;AAC9B,gBAAU,gBAAgB;AAAA,IAC5B;AAEA,QAAG,eAAe,UAAa,mBAAmB,QAAW;AAC3D,oBAAc,iBAAiB,YAAYA,MAAK,UAAU;AAAA,IAC5D;AAEA,QAAG,eAAe,UAAa,mBAAmB,QAAW;AAC3D,oBAAc,iBAAiB,YAAYA,MAAK,UAAU;AAAA,IAC5D;AAEA,QAAG,IAAI;AACL,gBAAU,OAAO,KAAK,EAAC,GAAG,UAAU,OAAO,IAAI,GAAG,GAAE;AAEpD,UAAG,QAAQ,IAAI,eAAe,UAAU,UAAU,OAAO,GAAG,aAAa,QAAQ;AAC/E,kBAAU,OAAO,GAAG,WAAW;AAAA,MACjC;AAAA,IACF;AAEA,cAAU,SAAS,EAAC,GAAG,UAAU,QAAQ,GAAG,cAAa;AAEzD,WAAO,UAAU;AAAA,EACnB;AAAA,EAEA,OAAO,gBAAgB,KAAK,QAAuB;AACjD,UAAM,eAAuB;AAC7B,UAAM,EAAC,aAAa,YAAY,YAAY,WAAU,IAAI;AAE1D,QAAG,eAAe,QAAW;AAC3B,aAAO,aAAa;AACpB,aAAO,iBAAiB,YAAY,KAAK,UAAU;AAAA,IACrD;AAEA,QAAG,eAAe,QAAW;AAC3B,aAAO,aAAa;AACpB,aAAO,iBAAiB,YAAY,KAAK,UAAU;AAAA,IACrD;AAEA,QAAG,eAAe,QAAW;AAC3B,aAAO,gBAAgB;AAAA,IACzB;AAEA,QAAG,gBAAgB,QAAW;AAC5B,aAAO,oBAAoB,gBAAgB,QAAQ,QAAQ;AAAA,IAC7D;AAEA,YAAQ,IAAI,aAAa,KAAK;AAAA,MAC5B;AAAA,QACE,GAAG,UAAU,aAAa,MAAM;AAAA,QAChC,aAAa,IAAI,YAAY;AAAA,QAC7B,UAAU,IAAI;AAAA,MAChB;AAAA,MAAG;AAAA,MAAM;AAAA,IACX;AAAA,EACF;AAAA,EAEA,aAAa,YAAY,KAAK,SAAkB,MAAqB;AACnE,UAAM,EAAC,UAAU,OAAO,WAAW,eAAe,OAAO,YAAY,QAAQ,MAAK,IAAI;AACtF,UAAM,gBAAgB,CAAC,MAAM,OAAO,OAAO,MAAM,MAAM;AACvD,UAAM,iBAAyB,iBAAiB;AAChD,QAAI,aAAqB,aAAa;AACtC,QAAI,eAAwB,YAAY,WAAW,UAAU,IAAI;AAEjE,QAAG,CAAC,cAAc,CAAC,cAAc;AAC/B,UAAG,OAAO;AACR,YAAI,8CAA8C,cAAc,IAAI,QAAQ,KAAK;AAAA,MACnF;AAEA,iBAAU,UAAU,eAAe;AACjC,cAAM,gBAAgB,SAClB,YAAY,KAAK,KAAK,cAAc,IAAI,MAAM,EAAE,IAChD,iBAAiB,GAAG,cAAc,IAAI,MAAM,IAAI,GAAG;AAEvD,YAAG,OAAO;AACR,cAAI,6BAA6B,aAAa,IAAI,QAAQ,KAAK;AAAA,QACjE;AAEA,YAAG,WAAW,aAAa,GAAG;AAC5B,uBAAa;AACb,yBAAe;AACf;AAAA,QACF;AAAA,MACF;AAAA,IACF;AAEA,QAAG,cAAc;AACf,UAAI,SAAS,OAAO,wBAAwB,UAAU,IAAI,QAAQ,KAAK;AACvE,YAAM,MAAc,YAAY,UAAU;AAE1C,UAAG,QAAQ,SAAS;AAClB,cAAM,gBAAwB,aAAa,YAAY,MAAM;AAE7D,YAAG,eAAe;AAChB,cAAI;AAEJ,cAAI;AACF,yBAAa,KAAK,MAAM,aAAa,GAAG,WAAW,CAAC;AAAA,UACtD,SAAQ,OAAO;AACb,gBAAI;AAAA,EAAK,OAAO,wCAAwC,MAAM,OAAO,IAAI,SAAS,KAAK;AACvF,yBAAa,CAAC;AAAA,UAChB;AAEA,oBAAU,gBAAgB,KAAK,UAAU;AAAA,QAC3C,OAAO;AACL,cAAI;AAAA,EAAK,OAAO,kCAAkC,UAAU,IAAI,SAAS,KAAK;AAAA,QAChF;AAAA,MACF,WAAU,CAAC,OAAO,QAAQ,QAAQ,KAAK,EAAE,SAAS,GAAG,GAAG;AACtD,YAAI;AACF,cAAI;AAEJ,cAAG,QAAQ,QAAQ;AACjB,kBAAM,UAAU,IAAI,IAAI,WAAW,YAAY,UAAU,CAAC,EAAE,EAAE;AAE9D,gBAAG,OAAO;AACR,kBAAI,iCAAiC,OAAO,IAAI,QAAQ,KAAK;AAAA,YAC/D;AACA,8BAAkB,MAAM,OAAO;AAAA,UACjC,OAAO;AACL,gBAAG,OAAO;AACR,kBAAI,+BAA+B,UAAU,IAAI,QAAQ,KAAK;AAAA,YAChE;AAEA,8BAAkB,MAAM,OAAO;AAAA,UACjC;AAEA,gBAAM,SAAS,gBAAgB,WAAW;AAE1C,cAAG,OAAO;AACR,gBAAI,kBAAkB,KAAK,UAAU,QAAQ,MAAM,CAAC,CAAC,IAAI,QAAQ,KAAK;AAAA,UACxE;AAEA,cAAG,CAAC,QAAQ;AACV,gBAAI;AAAA,EAAK,OAAO,2DAA2D,QAAQ,KAAK;AAAA,UAC1F;AAEA,oBAAU,gBAAgB,KAAK,UAAU,CAAC,CAAC;AAAA,QAC7C,SAAQ,OAAO;AACb,cAAI;AAAA,EAAK,OAAO,uCAAuC,MAAM,OAAO,IAAI,SAAS,KAAK;AACtF,cAAG,OAAO;AACR,oBAAQ,MAAM,KAAK;AAAA,UACrB;AAAA,QACF;AAAA,MACF,OAAO;AACL,YAAI;AAAA,EAAK,OAAO,iEAAiE,SAAS,KAAK;AAAA,MACjG;AAAA,IACF,OAAO;AACL,UAAG,OAAO;AACR,YAAI,sDAAsD,QAAQ,KAAK;AAAA,MACzE;AAEA,gBAAU,gBAAgB,CAAC,CAAC;AAC5B,gBAAU,gBAAgB,KAAK,UAAU,MAAM;AAAA,IACjD;AAAA,EACF;AAAA,EAEA,OAAO,wBAAwB;AAC7B,UAAM,eAAuB,YAAY,KAAK,iBAAiB;AAE/D,QAAG,CAAC,WAAW,YAAY,GAAG;AAC5B,YAAM,UAAU,IAAI,IAAI,KAAK,YAAY,GAAG,EAAE;AAC9C,oBAAc,cAAc,aAAa,YAAY,SAAS,6BAA6B,CAAC,CAAC;AAAA,IAC/F;AAAA,EACF;AACF;",
  "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 {dirname, extname as pathExtname, resolve as pathResolve} from 'path';\nimport {URL} from 'url';\n\nimport {getDirName, getLexPackageJsonPath, 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\nfunction findLexRoot(startDir: string): string {\n  let dir = startDir;\n  console.log('DEBUG: findLexRoot starting with dir:', dir); // TEMP DEBUG\n  while(dir !== '/' && dir !== '.') {\n    const pkgPath = pathResolve(dir, 'package.json');\n    console.log('DEBUG: findLexRoot checking', pkgPath); // TEMP DEBUG\n    if(existsSync(pkgPath)) {\n      try {\n        const pkg = JSON.parse(readFileSync(pkgPath, 'utf8'));\n        if(pkg.name === '@nlabs/lex') {\n          return dir;\n        }\n      } catch{}\n    }\n    const parent = dirname(dir);\n    console.log('DEBUG: findLexRoot parent of', dir, 'is', parent); // TEMP DEBUG\n    if(parent === dir) {\n      break;\n    }\n    dir = parent;\n  }\n  throw new Error('Could not find @nlabs/lex root');\n}\n\n/**\n * Get the appropriate TypeScript config path, prioritizing project configs over Lex configs\n */\nexport function getTypeScriptConfigPath(configName: string): string {\n  const cwd = process.cwd();\n\n  // For compile command, check for project's build config first\n  if(configName === 'tsconfig.build.json') {\n    const projectBuildConfig = pathResolve(cwd, 'tsconfig.build.json');\n    if(existsSync(projectBuildConfig)) {\n      return projectBuildConfig;\n    }\n  }\n\n  // For lint command, check for project's lint config first\n  if(configName === 'tsconfig.lint.json') {\n    const projectLintConfig = pathResolve(cwd, 'tsconfig.eslint.json');\n    if(existsSync(projectLintConfig)) {\n      return projectLintConfig;\n    }\n  }\n\n  // For test command, check for project's test config first\n  if(configName === 'tsconfig.test.json') {\n    const projectTestConfig = pathResolve(cwd, 'tsconfig.test.json');\n    if(existsSync(projectTestConfig)) {\n      return projectTestConfig;\n    }\n  }\n\n  // Check for the exact config name in the project\n  const projectConfigPath = pathResolve(cwd, configName);\n  if(existsSync(projectConfigPath)) {\n    return projectConfigPath;\n  }\n\n  // Otherwise, use Lex's config\n  const lexDir = LexConfig.getLexDir();\n  return pathResolve(lexDir, configName);\n}\n\nexport class LexConfig {\n  static config: LexConfigType = {\n    ...defaultConfigValues\n  };\n\n  /**\n   * Get the Lex package root directory, handling both development and installed environments\n   */\n  static getLexDir(): string {\n    // Always use the directory of Lex's own package.json\n    return dirname(getLexPackageJsonPath());\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 = getDirName();\n      writeFileSync(tsconfigPath, readFileSync(pathResolve(dirName, '../../../tsconfig.base.json')));\n    }\n  }\n\n  static checkCompileTypescriptConfig() {\n    const lexDir = LexConfig.getLexDir();\n    const tsconfigCompilePath: string = pathResolve(lexDir, './tsconfig.build.json');\n\n    if(!existsSync(tsconfigCompilePath)) {\n      // Try to copy from the template location\n      const templatePath = pathResolve(lexDir, 'tsconfig.build.json');\n      if(existsSync(templatePath)) {\n        writeFileSync(tsconfigCompilePath, readFileSync(templatePath));\n      }\n    }\n  }\n\n  static checkLintTypescriptConfig() {\n    const lexDir = LexConfig.getLexDir();\n    const tsconfigLintPath: string = pathResolve(lexDir, './tsconfig.lint.json');\n\n    if(!existsSync(tsconfigLintPath)) {\n      // Try to copy from the template location\n      const templatePath = pathResolve(lexDir, 'tsconfig.lint.json');\n      if(existsSync(templatePath)) {\n        writeFileSync(tsconfigLintPath, readFileSync(templatePath));\n      }\n    }\n  }\n\n  static checkTestTypescriptConfig() {\n    const lexDir = LexConfig.getLexDir();\n    const tsconfigTestPath: string = pathResolve(lexDir, './tsconfig.test.json');\n\n    if(!existsSync(tsconfigTestPath)) {\n      // Try to copy from the template location\n      const templatePath = pathResolve(lexDir, 'tsconfig.test.json');\n      if(existsSync(templatePath)) {\n        writeFileSync(tsconfigTestPath, readFileSync(templatePath));\n      }\n    }\n  }\n}"],
  "mappings": "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",
  "names": ["cwd"]
}
