@nlabs/lex 1.48.4 → 1.48.5

package/.vscode/settings.json

@@ -21,7 +21,7 @@
   "editor.autoClosingBrackets": "never",
   "editor.codeActionsOnSave": {
     "source.fixAll.eslint": "explicit",
-    "source.organizeImports": false
+    "source.organizeImports": "never"
   },
   "editor.detectIndentation": false,
   "editor.formatOnSave": true,

package/README.md

@@ -1,37 +1,308 @@
-# @nlabs/lex
+# 🚀 Lex - The Ultimate React Development CLI
 
-Lex is a console line execution module. Works out of the box for any React project, taking care of all your development needs. No need to install unit testing, transpilers, compilers, or even development servers. Install Lex globally and let go of all the grunt work, allowing you focus on coding your app.
+> **Zero Configuration. Maximum Productivity.**
 
-Lex eliminates this hassle. With the most common enterprise configurations used, developers can simply run and go. Lex uses the following libraries to assist in development.
+Lex is the all-in-one development CLI that eliminates the complexity of modern React development. No more juggling webpack configs, testing setups, or build tools. Just install Lex globally and focus on what matters most - building amazing applications.
 
-- [ESBuild](https://esbuild.github.io/)
-- [Jest](https://facebook.github.io/jest/)
-- [Typescript](http://www.typescriptlang.org/)
-- [Webpack](https://webpack.js.org/)
+[![npm version](https://badge.fury.io/js/%40nlabs%2Flex.svg)](https://badge.fury.io/js/%40nlabs%2Flex)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg)](http://makeapullrequest.com)
 
+## ✨ Why Lex?
 
-## Documentation
+### 🎯 **Zero Configuration**
 
-See Lex [documentation site](http://lex.nitrogenlabs.com) for full details.
+- Works out of the box with any React project
+- No webpack configs to write
+- No testing setup to configure
+- No build tools to manage
 
-## Installation
+### ⚡ **Lightning Fast**
 
-Lex is installed globally using npm.
+- ESBuild-powered compilation
+- Hot reloading development server
+- Optimized production builds
+- Parallel test execution
 
-```shell
-$ npm install -g @nlabs/lex
+### 🧠 **AI-Powered Development**
+
+- AI-assisted error fixing
+- Intelligent test generation
+- Code optimization suggestions
+- Smart linting with auto-fix
+
+### 🛠️ **Enterprise Ready**
+
+- TypeScript support out of the box
+- Jest testing framework included
+- Storybook integration
+- Production-optimized builds
+
+## 🚀 Quick Start
+
+```bash
+# Install Lex globally
+npm install -g @nlabs/lex
+
+# Create a new React app
+lex init my-awesome-app --typescript --install
+
+# Navigate to your app
+cd my-awesome-app
+
+# Start development server
+lex dev --open
+
+# Run tests
+lex test
+
+# Build for production
+lex build --mode production
 ```
 
-lex compile -c ./webpack.config.js
+## 📦 What's Included
+
+Lex comes with everything you need for modern React development:
+
+| Tool | Purpose | Version |
+|------|---------|---------|
+| **ESBuild** | Lightning-fast bundler | Latest |
+| **Jest** | Testing framework | Latest |
+| **TypeScript** | Type safety | Latest |
+| **Webpack** | Advanced bundling | Latest |
+| **Storybook** | Component development | Latest |
+| **PostCSS** | CSS processing | Latest |
+| **ESLint** | Code linting | Latest |
+
+## 🎮 Commands Overview
+
+### 🏗️ **Project Setup**
+
+| Command | Description | Quick Example |
+|---------|-------------|---------------|
+| [`lex init`](#init) | Create new React applications | `lex init my-app --typescript` |
+| [`lex create`](#create) | Generate project assets | `lex create view Dashboard` |
+| [`lex migrate`](#migrate) | Migrate existing projects | `lex migrate` |
+
+### 🛠️ **Development**
+
+| Command | Description | Quick Example |
+|---------|-------------|---------------|
+| [`lex dev`](#dev) | Start development server | `lex dev --open` |
+| [`lex compile`](#compile) | Compile TypeScript/JavaScript | `lex compile --watch` |
+| [`lex build`](#build) | Build for production | `lex build --mode production` |
+
+### 🧪 **Testing & Quality**
+
+| Command | Description | Quick Example |
+|---------|-------------|---------------|
+| [`lex test`](#test) | Run Jest tests | `lex test --watch` |
+| [`lex lint`](#lint) | Lint code with ESLint | `lex lint --fix` |
+| [`lex storybook`](#storybook) | Start Storybook | `lex storybook --open` |
+
+### 🤖 **AI-Powered Features**
+
+| Command | Description | Quick Example |
+|---------|-------------|---------------|
+| [`lex ai`](#ai) | AI code assistance | `lex ai --task generate --prompt "Create a button component"` |
+| [`lex ai`](#ai) | AI test generation | `lex test --generate` |
+| [`lex ai`](#ai) | AI error fixing | `lex build --assist` |
 
-## Quick Start
+### 📦 **Package Management**
 
-```shell
-// Install a skeleton app with the ArkhamJS framework
-$ npm install -g @nlabs/lex
-$ lex init myApp -i
-$ cd myApp
+| Command | Description | Quick Example |
+|---------|-------------|---------------|
+| [`lex update`](#update) | Update dependencies | `lex update --interactive` |
+| [`lex upgrade`](#upgrade) | Upgrade Lex itself | `lex upgrade` |
+| [`lex publish`](#publish) | Publish to npm | `lex publish --bump minor` |
 
-// Run the dev server
-$ lex dev -o
+### 🔧 **Utilities**
+
+| Command | Description | Quick Example |
+|---------|-------------|---------------|
+| [`lex clean`](#clean) | Clean project files | `lex clean` |
+| [`lex copy`](#copy) | Copy files/directories | `lex copy src dist` |
+| [`lex config`](#config) | Show configurations | `lex config webpack` |
+| [`lex versions`](#versions) | Show tool versions | `lex versions` |
+| [`lex link`](#link) | Check linked modules | `lex link` |
+
+## 🎯 Core Features
+
+### 🚀 **Development Server**
+
+```bash
+# Start with hot reloading
+lex dev --open
+
+# With bundle analyzer
+lex dev --bundleAnalyzer
+
+# Custom webpack config
+lex dev --config ./custom.webpack.js
+```
+
+### 🏗️ **Production Builds**
+
+```bash
+# Standard production build
+lex build --mode production
+
+# With ESBuild (faster)
+lex build --bundler esbuild
+
+# With AI optimization analysis
+lex build --analyze
+```
+
+### 🧪 **Testing Suite**
+
+```bash
+# Run all tests
+lex test
+
+# Watch mode
+lex test --watch
+
+# Generate tests with AI
+lex test --generate
+
+# Debug failing tests
+lex test --debugTests
 ```
+
+### 🎨 **Storybook Integration**
+
+```bash
+# Start Storybook
+lex storybook --open
+
+# With Tailwind CSS support
+lex storybook --useLexConfig
+
+# Build static site
+lex storybook --static
+```
+
+### 🤖 **AI-Powered Development**
+
+```bash
+# Generate code
+lex ai --task generate --prompt "Create a user profile component"
+
+# Explain code
+lex ai --task explain --file src/components/Button.tsx
+
+# Fix errors
+lex ai --task help --prompt "Fix this TypeScript error"
+```
+
+## 🎨 Framework Support
+
+Lex works seamlessly with popular React frameworks and libraries:
+
+- ✅ **Create React App** - Migrate existing CRA projects
+- ✅ **Next.js** - Use Lex for testing and building
+- ✅ **Gatsby** - Integrate Lex workflows
+- ✅ **Vite** - Alternative to Vite for complex projects
+- ✅ **TypeScript** - Full TypeScript support out of the box
+- ✅ **Tailwind CSS** - Automatic Tailwind integration
+- ✅ **Storybook** - Built-in Storybook support
+
+## 🚀 Performance
+
+Lex is designed for speed and efficiency:
+
+- **⚡ ESBuild Integration** - 10-100x faster than traditional bundlers
+- **🧠 Smart Caching** - Intelligent caching for faster rebuilds
+- **🔄 Hot Reloading** - Instant feedback during development
+- **📦 Tree Shaking** - Automatic dead code elimination
+- **🎯 Code Splitting** - Automatic code splitting for optimal loading
+
+## 🛠️ Configuration
+
+Lex works out of the box, but you can customize it with a `lex.config.js` file:
+
+```javascript
+export default {
+  // Project settings
+  useTypescript: true,
+  sourcePath: './src',
+  outputPath: './dist',
+
+  // Package manager
+  packageManager: 'npm',
+
+  // AI configuration
+  ai: {
+    provider: 'openai',
+    model: 'gpt-4'
+  },
+
+  // ESBuild configuration
+  esbuild: {
+    minify: true,
+    sourcemap: true,
+    target: 'es2020'
+  }
+};
+```
+
+## 📚 Documentation
+
+- 📖 **[Full Documentation](http://lex.nitrogenlabs.com)** - Complete API reference
+- 🎯 **[Getting Started Guide](http://lex.nitrogenlabs.com/getting-started)** - Step-by-step tutorial
+- 🛠️ **[Configuration Guide](http://lex.nitrogenlabs.com/configuration)** - Customization options
+- 🤖 **[AI Features Guide](http://lex.nitrogenlabs.com/ai-features)** - AI-powered development
+- 🧪 **[Testing Guide](http://lex.nitrogenlabs.com/testing)** - Testing best practices
+
+## 🤝 Contributing
+
+We love contributions! Here's how you can help:
+
+1. **Fork** the repository
+2. **Create** a feature branch (`git checkout -b feature/amazing-feature`)
+3. **Commit** your changes (`git commit -m 'Add amazing feature'`)
+4. **Push** to the branch (`git push origin feature/amazing-feature`)
+5. **Open** a Pull Request
+
+### Development Setup
+
+```bash
+# Clone the repository
+git clone https://github.com/nitrogenlabs/lex.git
+
+# Install dependencies
+npm install
+
+# Run tests
+npm test
+
+# Build the project
+npm run build
+```
+
+## 📄 License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+
+## 🙏 Acknowledgments
+
+- **ESBuild** - For lightning-fast bundling
+- **Jest** - For comprehensive testing
+- **TypeScript** - For type safety
+- **Webpack** - For advanced bundling features
+- **Storybook** - For component development
+- **OpenAI/Anthropic** - For AI-powered features
+
+## 📞 Support
+
+- 🐛 **Issues** - [GitHub Issues](https://github.com/nitrogenlabs/lex/issues)
+- 💬 **Discussions** - [GitHub Discussions](https://github.com/nitrogenlabs/lex/discussions)
+- 📧 **Email** - <support@nitrogenlabs.com>
+- 🐦 **Twitter** - [@NitrogenLabs](https://twitter.com/NitrogenLabs)
+
+---
+
+**Made with ❤️ by [Nitrogen Labs](https://nitrogenlabs.com)**
+
+*Lex - Because development should be effortless.*

package/__mocks__/compare-versions.js

@@ -0,0 +1,3 @@
+module.exports = {
+  compareVersions: jest.fn().mockReturnValue(1)
+};

package/__mocks__/fileMock.js

@@ -0,0 +1 @@
+module.exports = 'test-file-stub';

package/__mocks__/latest-version.js

@@ -0,0 +1 @@
+module.exports = jest.fn().mockResolvedValue('1.0.0');

package/__mocks__/react-markdown.js

@@ -0,0 +1,12 @@
+const React = require('react');
+
+// Mock implementation of react-markdown
+const ReactMarkdown = ({children}) => {
+  return React.createElement('div', {
+    'data-testid': 'react-markdown',
+    dangerouslySetInnerHTML: {__html: children}
+  });
+};
+
+module.exports = ReactMarkdown;
+module.exports.default = ReactMarkdown;

package/babel.config.json

@@ -8,6 +8,7 @@
         }
       }
     ],
-    "@babel/preset-typescript"
+    "@babel/preset-typescript",
+    "@babel/preset-react"
   ]
 }

package/dist/Button.stories.d.ts

@@ -0,0 +1,19 @@
+import React from 'react';
+import type { Meta, StoryObj } from '@storybook/react';
+interface ButtonProps {
+    children: React.ReactNode;
+    disabled?: boolean;
+    onClick?: () => void;
+    size?: 'lg' | 'md' | 'sm';
+    variant?: 'outline' | 'primary' | 'secondary';
+}
+declare const Button: React.FC<ButtonProps>;
+declare const meta: Meta<typeof Button>;
+export default meta;
+type Story = StoryObj<typeof meta>;
+export declare const Primary: Story;
+export declare const Secondary: Story;
+export declare const Outline: Story;
+export declare const Small: Story;
+export declare const Large: Story;
+export declare const Disabled: Story;

package/dist/LexConfig.d.ts

@@ -0,0 +1,84 @@
+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 function getTypeScriptConfigPath(configName: string): string;
+export declare class LexConfig {
+    static config: LexConfigType;
+    static getLexDir(): string;
+    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;
+    static checkCompileTypescriptConfig(): void;
+    static checkLintTypescriptConfig(): void;
+    static checkTestTypescriptConfig(): void;
+}

package/dist/LexConfig.js

@@ -91,9 +91,6 @@ class LexConfig {
   static config = {
     ...defaultConfigValues
   };
-  /**
-   * Get the Lex package root directory, handling both development and installed environments
-   */
   static getLexDir() {
     return dirname(getLexPackageJsonPath());
   }
@@ -286,4 +283,4 @@ export {
   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 {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  while(dir !== '/' && dir !== '.') {\n    const pkgPath = pathResolve(dir, 'package.json');\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    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"]
}

+//# 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  while(dir !== '/' && dir !== '.') {\n    const pkgPath = pathResolve(dir, 'package.json');\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    if(parent === dir) {\n      break;\n    }\n    dir = parent;\n  }\n  throw new Error('Could not find @nlabs/lex root');\n}\n\nexport function getTypeScriptConfigPath(configName: string): string {\n  const cwd = process.cwd();\n\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  if(configName === 'tsconfig.lint.json') {\n    const projectLintConfig = pathResolve(cwd, 'tsconfig.eslint.json');\n    if(existsSync(projectLintConfig)) {\n      return projectLintConfig;\n    }\n  }\n\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  const projectConfigPath = pathResolve(cwd, configName);\n  if(existsSync(projectConfigPath)) {\n    return projectConfigPath;\n  }\n\n  const lexDir = LexConfig.getLexDir();\n  return pathResolve(lexDir, configName);\n}\n\nexport class LexConfig {\n  static config: LexConfigType = {\n    ...defaultConfigValues\n  };\n\n  static getLexDir(): string {\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      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      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      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"]
}


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;

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/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<1 | 0>;
+export declare const buildWithWebpack: (spinner: any, cmd: any, callback: any) => Promise<1 | 0>;
+export declare const build: (cmd: BuildOptions, callback?: BuildCallback) => Promise<number>;
+export default build;

package/dist/commands/clean/clean.d.ts

@@ -0,0 +1,7 @@
+export interface CleanOptions {
+    readonly cliName?: string;
+    readonly quiet?: boolean;
+    readonly snapshots?: boolean;
+}
+export type CleanCallback = (status: number) => void;
+export declare const clean: (cmd: CleanOptions, callback?: CleanCallback) => Promise<number>;