@nlabs/lex 1.47.2 → 1.48.0

package/dist/dist/LexConfig.d.ts

@@ -0,0 +1,119 @@
+export class LexConfig {
+    static config: {
+        ai: {
+            provider: string;
+            model: string;
+            maxTokens: number;
+            temperature: number;
+        };
+        configFiles: any[];
+        copyFiles: any[];
+        entryHTML: string;
+        entryJs: string;
+        esbuild: {
+            minify: boolean;
+            treeShaking: boolean;
+            drop: string[];
+            pure: string[];
+            legalComments: string;
+            splitting: boolean;
+            metafile: boolean;
+            sourcemap: boolean;
+        };
+        env: any;
+        jest: {};
+        outputFullPath: string;
+        outputHash: boolean;
+        outputPath: string;
+        packageManager: string;
+        preset: string;
+        sourceFullPath: string;
+        sourcePath: string;
+        targetEnvironment: string;
+        useGraphQl: boolean;
+        useTypescript: boolean;
+        webpack: {};
+    };
+    /**
+     * Get the Lex package root directory, handling both development and installed environments
+     */
+    static getLexDir(): string;
+    static set useTypescript(value: any);
+    static updateConfig(updatedConfig: any): {
+        ai: {
+            provider: string;
+            model: string;
+            maxTokens: number;
+            temperature: number;
+        };
+        configFiles: any[];
+        copyFiles: any[];
+        entryHTML: string;
+        entryJs: string;
+        esbuild: {
+            minify: boolean;
+            treeShaking: boolean;
+            drop: string[];
+            pure: string[];
+            legalComments: string;
+            splitting: boolean;
+            metafile: boolean;
+            sourcemap: boolean;
+        };
+        env: any;
+        jest: {};
+        outputFullPath: string;
+        outputHash: boolean;
+        outputPath: string;
+        packageManager: string;
+        preset: string;
+        sourceFullPath: string;
+        sourcePath: string;
+        targetEnvironment: string;
+        useGraphQl: boolean;
+        useTypescript: boolean;
+        webpack: {};
+    };
+    static addConfigParams(cmd: any, params: any): void;
+    static parseConfig(cmd: any, isRoot?: boolean): Promise<void>;
+    static checkTypescriptConfig(): void;
+    static checkCompileTypescriptConfig(): void;
+    static checkLintTypescriptConfig(): void;
+    static checkTestTypescriptConfig(): void;
+}
+export namespace defaultConfigValues {
+    namespace ai {
+        let provider: string;
+        let model: string;
+        let maxTokens: number;
+        let temperature: number;
+    }
+    let configFiles: any[];
+    let copyFiles: any[];
+    let entryHTML: string;
+    let entryJs: string;
+    namespace esbuild {
+        let minify: boolean;
+        let treeShaking: boolean;
+        let drop: string[];
+        let pure: string[];
+        let legalComments: string;
+        let splitting: boolean;
+        let metafile: boolean;
+        let sourcemap: boolean;
+    }
+    let env: any;
+    let jest: {};
+    let outputFullPath: string;
+    let outputHash: boolean;
+    let outputPath: string;
+    let packageManager: string;
+    let preset: string;
+    let sourceFullPath: string;
+    let sourcePath: string;
+    let targetEnvironment: string;
+    let useGraphQl: boolean;
+    let useTypescript: boolean;
+    let webpack: {};
+}
+export function getTypeScriptConfigPath(configName: any): string;

package/dist/dist/utils/file.d.ts

@@ -0,0 +1,7 @@
+export function getDirName(): any;
+export function getFilePath(relativePath: any): any;
+export function getLexPackageJsonPath(): string;
+export function getNodePath(moduleName: any): any;
+export function relativeFilePath(filename: any, dirPath?: string, backUp?: number): any;
+export function relativeNodePath(filename: any, dirPath?: string, backUp?: number): any;
+export function resolveBinaryPath(binaryName: any, packageName: any): string;

package/dist/dist/utils/log.d.ts

@@ -0,0 +1 @@
+export function log(message: any, type?: string, quiet?: boolean): void;

package/dist/index.js

@@ -1,7 +1,7 @@
 export * from "./types.js";
 import {
-  LexConfig,
-  defaultConfigValues
+  defaultConfigValues,
+  LexConfig
 } from "./LexConfig.js";
 const Config = {
   create: (config) => config
@@ -23,6 +23,7 @@ export * from "./commands/link/link.js";
 export * from "./commands/lint/lint.js";
 export * from "./commands/migrate/migrate.js";
 export * from "./commands/publish/publish.js";
+export * from "./commands/storybook/storybook.js";
 export * from "./commands/test/test.js";
 export * from "./commands/update/update.js";
 export * from "./commands/upgrade/upgrade.js";
@@ -32,4 +33,4 @@ export {
   LexConfig,
   defaultConfigValues
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lex.js

@@ -1,6 +1,8 @@
 #!/usr/bin/env node
 import { Option, program } from "commander";
 import { readFileSync } from "fs";
+import { createRequire } from "module";
+import { dirname, resolve } from "path";
 import { fileURLToPath } from "url";
 import { aiFunction } from "./commands/ai/ai.js";
 import { build } from "./commands/build/build.js";
@@ -14,10 +16,19 @@ import { linked } from "./commands/link/link.js";
 import { lint } from "./commands/lint/lint.js";
 import { migrate } from "./commands/migrate/migrate.js";
 import { publish } from "./commands/publish/publish.js";
+import { storybook } from "./commands/storybook/storybook.js";
 import { test } from "./commands/test/test.js";
 import { update } from "./commands/update/update.js";
 import { upgrade } from "./commands/upgrade/upgrade.js";
 import { versions } from "./commands/versions/versions.js";
+const lexNodeModules = resolve(dirname(fileURLToPath(import.meta.url)), "../node_modules");
+if (!process.env.NODE_PATH) {
+  process.env.NODE_PATH = lexNodeModules;
+} else if (!process.env.NODE_PATH.split(":").includes(lexNodeModules)) {
+  process.env.NODE_PATH += `:${lexNodeModules}`;
+}
+const require2 = createRequire(import.meta.url);
+require2("module").Module._initPaths();
 const packagePath = fileURLToPath(new URL("../package.json", import.meta.url));
 const packageJson = JSON.parse(readFileSync(packagePath, "utf8"));
 program.command("build").option("--assist", "Enable AI assistance for fixing build errors.", false).option("--analyze", "Enable AI analysis for build optimization suggestions or invoke webpack-bundle-analyzer plugin.", false).addOption(new Option("--bundler <n>", 'Bundler to use ("webpack" or "esbuild"). Default: "webpack".').choices(["webpack", "esbuild"]).default("webpack")).option("--config <path>", "Custom Webpack configuration file path (ie. webpack.config.js).").option("--configName <value...>", "Name of the configuration to use.").option("--defineProcessEnvNodeEnv <value>", "Sets process.env.NODE_ENV to the specified value. (Currently an alias for `--node-env`)").option("--devtool <value>", "A developer tool to enhance debugging (false | eval | [inline-|hidden-|eval-][nosources-][cheap-[module-]]source-map).").option("--disableInterpret", "Disable interpret for loading the config file.", false).option("--entry <value...>", "A module that is loaded upon startup. Only the last one is exported.").option("--env <value>", "Environment passed to the configuration when it is a function.").option("--failOnWarnings", "Stop webpack-cli process with non-zero exit code on warnings from webpack", false).addOption(new Option("--format <value>", 'This sets the output format for the generated JavaScript files. Default: "cjs".').choices(["cjs", "esm"]).default("cjs")).option("--json <value>", "Prints result as JSON or store it in a file.").option("--lexConfig <path>", "Lex configuration file path (lex.config.js).").option("--merge", 'Merge two or more configurations using "webpack-merge".', false).addOption(new Option("--mode <type>", 'Webpack mode ("production" or "development"). Default: "development".').choices(["development", "production"]).default("development")).option("--name <value>", "Name of the configuration. Used when loading multiple configurations.").option("--noDevtool", 'Negative "devtool" option.', false).option("--noStats", 'Negative "stats" option.', false).option("--noTarget", 'Negative "target" option.', false).option("--noWatch", 'Negative "watch" option.', false).option("--noWatchOptionsStdin", 'Negative "watch-options-stdin" option.', false).option("--nodeEnv <value>", "Sets process.env.NODE_ENV to the specified value.").option("--outputPath <value>", "The output directory as **absolute path** (required).").option("--quiet", "No Lex notifications printed in the console.", false).option("--remove", "Removes all files from the output directory before compiling.", false).option("--sourcePath <path>", "Source path").option("--stats <value>", "Stats options object or preset name.").option("--static", "Creates static HTML files when building app.", false).option("--target <value>", "Environment to build for. Environment to build for. An array of environments to build for all of them when possible.").option("--typescript", "Transpile as Typescript.", false).option("--variables <n>", `Environment variables to set in "process.env". (ie. "{NODE_ENV: 'production'}").`).option("--watch", "Watch for changes.", false).option("--watchOptionsStdin", "Stop watching when stdin stream has ended.", false).action((cmd) => build(cmd, process.exit).then(() => {
@@ -42,6 +53,8 @@ program.command("migrate").option("-q, --quiet", "No Lex notifications printed i
 }));
 program.command("publish").addOption(new Option("--bump <type>", 'Increments the version. Types include: major, minor, patch, beta, alpha, rc. Default: "patch".').choices(["major", "minor", "patch", "beta", "alpha", "rc"]).default("patch")).option("--newVersion <versionNumber>", "Publish as a specific version.").option("--otp <code>", "Provide a two-factor code.").addOption(new Option("--package-manager <manager>", "Which package manager to use. Default: npm").choices(["npm", "yarn"]).default("npm")).option("--private", "Publishes the module as restricted.").option("--quiet", "No Lex notifications printed in the console.").option("--tag <tag>", "Registers the published package with the given tag.").action((cmd) => publish(cmd, process.exit).then(() => {
 }));
+program.command("storybook").option("--config <path>", "Custom Storybook configuration directory path (ie. .storybook).").option("--lexConfig <path>", "Custom Lex configuration file path (ie. lex.config.js).").option("--open", "Automatically open Storybook in a new browser window.").option("--port <number>", "Port number for the Storybook server.").option("--quiet", "No Lex notifications printed in the console.").option("--static", "Build a static Storybook site instead of starting dev server.").option("--variables <n>", `Environment variables to set in "process.env". (ie. "{STORYBOOK_THEME: 'dark'}").`).action((cmd) => storybook(cmd, process.exit).then(() => {
+}));
 program.command("test").option("--analyze", "Use AI to analyze test coverage and suggest improvements.", false).option("--debugTests", "Use AI to debug test failures and suggest fixes.", false).option("--generate", "Use AI to generate test cases for untested code.", false).option("--bail", "Exit the test suite immediately upon the first failing test suite.").option("--changedFilesWithAncestor", "Runs tests related to the current changes and the changes made in the last commit.").option("--changedSince", "Runs tests related the changes since the provided branch.").option("--ci", "When this option is provided, Jest will assume it is running in a CI environment.").option("--clearCache", "Clear Jest cache.").option("--collectCoverageFrom <glob>", "A glob pattern relative to matching the files that coverage info needs to be collected from.").option("--colors", "Forces test results output highlighting even if stdout is not a TTY.").option("--config <path>", "Custom Jest configuration file path (ie. jest.config.js).").option("--debug", "Print debugging info about your Jest config.").option("--detectOpenHandles", "Attempt to collect and print open handles preventing Jest from exiting cleanly").option("--environment <n>", 'Target environment. "node" or "web". Default: "node".').option("--env", "The test environment used for all tests. This can point to any file or node module. Examples: jsdom, node or path/to/my-environment.js.").option("--errorOnDeprecated", "Make calling deprecated APIs throw helpful error messages.").option("--expand", "Use this flag to show full diffs and errors instead of a patch.").option("--forceExit", "Force Jest to exit after all tests have completed running.").option("--json", "Prints the test results in JSON.").option("--lastCommit", "Run all tests affected by file changes in the last commit made.").option("--lexConfig <path>", "Custom Lex configuration file path (ie. lex.config.js).").option("--listTests", "Lists all tests as JSON that Jest will run given the arguments, and exits.").option("--logHeapUsage", "Logs the heap usage after every test.").option("--maxWorkers <num>", "Specifies the maximum number of workers the worker-pool will spawn for running tests. ").option("--noStackTrace", "Disables stack trace in test results output.").option("--notify", "Activates notifications for test results.").option("--onlyChanged", "un based on which files have changed in the current repository. ").option("--outputFile <filename>", "Write test results to a file when the --json option is also specified.").option("--passWithNoTests", "Allows the test suite to pass when no files are found.").option("--quiet", "No Lex notifications printed in the console.").option("--runInBand", "Run all tests serially in the current process, rather than creating a worker pool of child processes that run tests.").option("--setup <path>", "Jest setup file path.").option("--showConfig", "Print your Jest config and then exits.").option("--silent", "Prevent tests from printing messages through the console.").option("--testLocationInResults", "Adds a location field to test results.").option("--testNamePattern <regex>", "Run only tests with a name that matches the regex. ").option("--testPathPattern <regex>", "A regexp pattern string that is matched against all tests paths before executing the test.").option("--typescript", "Transpile as Typescript.").option("--update", 'Update snapshots. Runs "jest --updateSnapshots"').option("--useStderr", "Divert all output to stderr.").option("--verbose", "Display individual test results with the test suite hierarchy.").option("--watch <path>", "Watch files for changes and rerun tests related to changed files.").option("--watchAll", "Watch files for changes and rerun all tests when something changes.").action((options, cmd) => test(options, cmd.args, process.exit).then(() => {
 }));
 program.command("update").option("--interactive", "Choose which packages to update.").addOption(new Option("--package-manager <manager>", "Which package manager to use. Default: npm").choices(["npm", "yarn"]).default("npm")).option("--quiet", "No Lex notifications printed in the console.").option("--registry", "Add a custom registry url.").action((cmd) => update(cmd, process.exit).then(() => {
@@ -53,4 +66,4 @@ program.command("ai").option("--context", "Include project context in the AI pro
 program.command("versions").option("--json", "Print the version as a JSON object.").action((cmd) => versions(cmd, process.exit).then(() => {
 }));
 program.version(packageJson.version).parse(process.argv);
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../src/lex.ts"],
  "sourcesContent": ["#!/usr/bin/env node\n/**\n * Copyright (c) 2018-Present, Nitrogen Labs, Inc.\n * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.\n */\nimport {Option, program} from 'commander';\nimport {readFileSync} from 'fs';\nimport {fileURLToPath} from 'url';\n\nimport {aiFunction} from './commands/ai/ai.js';\nimport {build} from './commands/build/build.js';\nimport {clean} from './commands/clean/clean.js';\nimport {compile} from './commands/compile/compile.js';\nimport {config} from './commands/config/config.js';\nimport {create} from './commands/create/create.js';\nimport {dev} from './commands/dev/dev.js';\nimport {init} from './commands/init/init.js';\nimport {linked} from './commands/link/link.js';\nimport {lint} from './commands/lint/lint.js';\nimport {migrate} from './commands/migrate/migrate.js';\nimport {publish} from './commands/publish/publish.js';\nimport {test} from './commands/test/test.js';\nimport {update} from './commands/update/update.js';\nimport {upgrade} from './commands/upgrade/upgrade.js';\nimport {versions} from './commands/versions/versions.js';\n\nconst packagePath = fileURLToPath(new URL('../package.json', import.meta.url));\nconst packageJson = JSON.parse(readFileSync(packagePath, 'utf8'));\n\nprogram.command('build')\n  .option('--assist', 'Enable AI assistance for fixing build errors.', false)\n  .option('--analyze', 'Enable AI analysis for build optimization suggestions or invoke webpack-bundle-analyzer plugin.', false)\n  .addOption(new Option('--bundler <n>', 'Bundler to use (\"webpack\" or \"esbuild\"). Default: \"webpack\".').choices(['webpack', 'esbuild']).default('webpack'))\n  .option('--config <path>', 'Custom Webpack configuration file path (ie. webpack.config.js).')\n  .option('--configName <value...>', 'Name of the configuration to use.')\n  .option('--defineProcessEnvNodeEnv <value>', 'Sets process.env.NODE_ENV to the specified value. (Currently an alias for `--node-env`)')\n  .option('--devtool <value>', 'A developer tool to enhance debugging (false | eval | [inline-|hidden-|eval-][nosources-][cheap-[module-]]source-map).')\n  .option('--disableInterpret', 'Disable interpret for loading the config file.', false)\n  .option('--entry <value...>', 'A module that is loaded upon startup. Only the last one is exported.')\n  .option('--env <value>', 'Environment passed to the configuration when it is a function.')\n  .option('--failOnWarnings', 'Stop webpack-cli process with non-zero exit code on warnings from webpack', false)\n  .addOption(new Option('--format <value>', 'This sets the output format for the generated JavaScript files. Default: \"cjs\".').choices(['cjs', 'esm']).default('cjs'))\n  .option('--json <value>', 'Prints result as JSON or store it in a file.')\n  .option('--lexConfig <path>', 'Lex configuration file path (lex.config.js).')\n  .option('--merge', 'Merge two or more configurations using \"webpack-merge\".', false)\n  .addOption(new Option('--mode <type>', 'Webpack mode (\"production\" or \"development\"). Default: \"development\".').choices(['development', 'production']).default('development'))\n  .option('--name <value>', 'Name of the configuration. Used when loading multiple configurations.')\n  .option('--noDevtool', 'Negative \"devtool\" option.', false)\n  .option('--noStats', 'Negative \"stats\" option.', false)\n  .option('--noTarget', 'Negative \"target\" option.', false)\n  .option('--noWatch', 'Negative \"watch\" option.', false)\n  .option('--noWatchOptionsStdin', 'Negative \"watch-options-stdin\" option.', false)\n  .option('--nodeEnv <value>', 'Sets process.env.NODE_ENV to the specified value.')\n  .option('--outputPath <value>', 'The output directory as **absolute path** (required).')\n  .option('--quiet', 'No Lex notifications printed in the console.', false)\n  .option('--remove', 'Removes all files from the output directory before compiling.', false)\n  .option('--sourcePath <path>', 'Source path')\n  .option('--stats <value>', 'Stats options object or preset name.')\n  .option('--static', 'Creates static HTML files when building app.', false)\n  .option('--target <value>', 'Environment to build for. Environment to build for. An array of environments to build for all of them when possible.')\n  .option('--typescript', 'Transpile as Typescript.', false)\n  .option('--variables <n>', 'Environment variables to set in \"process.env\". (ie. \"{NODE_ENV: \\'production\\'}\").')\n  .option('--watch', 'Watch for changes.', false)\n  .option('--watchOptionsStdin', 'Stop watching when stdin stream has ended.', false)\n  .action((cmd) => build(cmd, process.exit).then(() => {}));\n\nprogram.command('clean')\n  .option('--quiet', 'No Lex notifications printed in the console.')\n  .option('--snapshots', 'Remove all \"__snapshots__\" directories.')\n  .action((cmd) => clean(cmd, process.exit).then(() => {}));\n\nprogram.command('config <type>')\n  .option('--quiet', 'No Lex notifications printed in the console.')\n  .option('--json <path>', 'Save output to json file.')\n  .action((type, cmd) => config(type, cmd, process.exit).then(() => {}));\n\nprogram.command('compile')\n  .option('--config <path>', 'Transpiler configuration file path (ie. tsconfig.json).')\n  .option('--environment <n>', 'Target environment. \"node\" or \"web\". Default: \"node\".')\n  .option('--lexConfig <path>', 'Custom Lex configuration file path (ie. lex.config.js).')\n  .option('--outputPath <path>', 'Output path')\n  .option('--remove', 'Removes all files from the output directory before compiling.')\n  .option('--sourcePath <path>', 'Source path')\n  .option('--typescript', 'Transpile as Typescript.')\n  .option('--quiet', 'No Lex notifications printed in the console.')\n  .option('--watch', 'Watches for changes and compiles.')\n  .action((cmd) => compile(cmd, process.exit).then(() => {}));\n\nprogram.command('create <type>')\n  .option('--outputFile <path>', 'Output filename.')\n  .option('--outputName <n>', 'Output name.')\n  .option('--quiet', 'No Lex notifications printed in the console.')\n  .option('--typescript', 'Create Typescript version.')\n  .action((type, cmd) => create(type, cmd, process.exit).then(() => {}));\n\nprogram.command('dev')\n  .option('--bundleAnalyzer', 'Run bundle analyzer.')\n  .option('--config <path>', 'Custom Webpack configuration file path (ie. webpack.config.js).')\n  .option('--lexConfig <path>', 'Custom Lex configuration file path (ie. lex.config.js).')\n  .option('--open', 'Automatically open dev server in a new browser window.')\n  .option('--outputPath <path>', 'Output path')\n  .option('--quiet', 'No Lex notifications printed in the console.')\n  .option('--remove', 'Removes all files from the output directory before compiling.')\n  .option('--sourcePath <path>', 'Source path')\n  .option('--typescript', 'Transpile as Typescript.')\n  .option('--variables <n>', 'Environment variables to set in \"process.env\". (ie. \"{NODE_ENV: \\'development\\'}\").')\n  .option('--watch', 'Watch for changes.')\n  .action((cmd) => dev(cmd, process.exit).then(() => {}));\n\nprogram.command('init <appName> [packageName]')\n  .option('--install', 'Install dependencies.')\n  .addOption(new Option('--package-manager <manager>', 'Which package manager to use. Default: npm').choices(['npm', 'yarn']).default('npm'))\n  .option('--quiet', 'No Lex notifications printed in the console.')\n  .option('--typescript', 'Use a Typescript based app.')\n  .action((appName, packageName, cmd) => init(appName, packageName, cmd, process.exit).then(() => {}));\n\nprogram.command('linked')\n  .option('--quiet', 'No Lex notifications printed in the console.')\n  .action((cmd) => linked(cmd, process.exit).then(() => {}));\n\nprogram.command('lint')\n  .option('--cache', 'Only check changed files. Default: false.', false)\n  .option('--cacheLocation <path>', 'Path to the cache file or directory.')\n  .option('--color', 'Force enabling of color.', false)\n  .option('--config <path>', 'Use this configuration, overriding .eslintrc.* config options if present. If not specified and no local config exists, Lex will use its default config.')\n  .option('--debug', 'Output debugging information.', false)\n  .option('--envInfo', 'Output execution environment information. Default: false.', false)\n  .option('--env <n>', 'Specify environments.')\n  .option('--fix', 'Apply AI fixes after built-in ESLint fixes (same as --fix).', false)\n  .option('--fixDryRun', 'Automatically fix problems without saving the changes to the file system.', false)\n  .option('--fixType <type>', 'Specify the types of fixes to apply (problem, suggestion, layout).')\n  .option('--format <n>', 'Use a specific output format. Default: stylish.')\n  .option('--global <variables>', 'Define global variables.')\n  .option('--ignorePath <path>', 'Specify path of ignore file.')\n  .option('--ignorePattern <pattern>', 'Pattern of files to ignore (in addition to those in .eslintignore).')\n  .option('--init', 'Run config initialization wizard. Default: false.', false)\n  .option('--maxWarnings <num>', 'Number of warnings to trigger nonzero exit code. Default: -1.')\n  .option('--noColor', 'Force disabling of color.', false)\n  .option('--noEslintrc', 'Disable use of configuration from .eslintrc.*.', false)\n  .option('--noIgnore', 'Disable use of ignore files and patterns.', false)\n  .option('--noInlineConfig', 'Prevent comments from changing config or rules.', false)\n  .option('--outputFile <path>', 'Specify file to write report to.')\n  .option('--parser <n>', 'Specify the parser to be used.')\n  .option('--parserOptions <options>', 'Specify parser options.')\n  .option('--plugin <plugins>', 'Specify plugins.')\n  .option('--printConfig <path>', 'Print the configuration for the given file.')\n  .option('--quiet', 'No Lex notifications printed in the console.', false)\n  .option('--reportUnusedDisableDirectives', 'Adds reported errors for unused eslint-disable directives.', false)\n  .option('--resolvePluginsRelativeTo <path>', 'A folder where plugins should be resolved from.')\n  .option('--rule <path>', 'Specify rules.')\n  .option('--rulesdir <path>', 'Use additional rules from this directory.')\n  .option('--stdin', 'Lint code provided on <STDIN> - Default: false.', false)\n  .option('--stdinFilename <n>', 'Specify filename to process STDIN as.')\n  .action((cmd) => lint(cmd, process.exit).then(() => {}));\n\nprogram.command('migrate')\n  .option('-q, --quiet', 'No Lex notifications printed in the console.')\n  .action((cmd) => migrate(cmd, process.exit).then(() => {}));\n\nprogram.command('publish')\n  .addOption(new Option('--bump <type>', 'Increments the version. Types include: major, minor, patch, beta, alpha, rc. Default: \"patch\".').choices(['major', 'minor', 'patch', 'beta', 'alpha', 'rc']).default('patch'))\n  .option('--newVersion <versionNumber>', 'Publish as a specific version.')\n  .option('--otp <code>', 'Provide a two-factor code.')\n  .addOption(new Option('--package-manager <manager>', 'Which package manager to use. Default: npm').choices(['npm', 'yarn']).default('npm'))\n  .option('--private', 'Publishes the module as restricted.')\n  .option('--quiet', 'No Lex notifications printed in the console.')\n  .option('--tag <tag>', 'Registers the published package with the given tag.')\n  .action((cmd) => publish(cmd, process.exit).then(() => {}));\n\nprogram.command('test')\n  .option('--analyze', 'Use AI to analyze test coverage and suggest improvements.', false)\n  .option('--debugTests', 'Use AI to debug test failures and suggest fixes.', false)\n  .option('--generate', 'Use AI to generate test cases for untested code.', false)\n  .option('--bail', 'Exit the test suite immediately upon the first failing test suite.')\n  .option('--changedFilesWithAncestor', 'Runs tests related to the current changes and the changes made in the last commit.')\n  .option('--changedSince', 'Runs tests related the changes since the provided branch.')\n  .option('--ci', 'When this option is provided, Jest will assume it is running in a CI environment.')\n  .option('--clearCache', 'Clear Jest cache.')\n  .option('--collectCoverageFrom <glob>', 'A glob pattern relative to matching the files that coverage info needs to be collected from.')\n  .option('--colors', 'Forces test results output highlighting even if stdout is not a TTY.')\n  .option('--config <path>', 'Custom Jest configuration file path (ie. jest.config.js).')\n  .option('--debug', 'Print debugging info about your Jest config.')\n  .option('--detectOpenHandles', 'Attempt to collect and print open handles preventing Jest from exiting cleanly')\n  .option('--environment <n>', 'Target environment. \"node\" or \"web\". Default: \"node\".')\n  .option('--env', 'The test environment used for all tests. This can point to any file or node module. Examples: jsdom, node or path/to/my-environment.js.')\n  .option('--errorOnDeprecated', 'Make calling deprecated APIs throw helpful error messages.')\n  .option('--expand', 'Use this flag to show full diffs and errors instead of a patch.')\n  .option('--forceExit', 'Force Jest to exit after all tests have completed running.')\n  .option('--json', 'Prints the test results in JSON.')\n  .option('--lastCommit', 'Run all tests affected by file changes in the last commit made.')\n  .option('--lexConfig <path>', 'Custom Lex configuration file path (ie. lex.config.js).')\n  .option('--listTests', 'Lists all tests as JSON that Jest will run given the arguments, and exits.')\n  .option('--logHeapUsage', 'Logs the heap usage after every test.')\n  .option('--maxWorkers <num>', 'Specifies the maximum number of workers the worker-pool will spawn for running tests. ')\n  .option('--noStackTrace', 'Disables stack trace in test results output.')\n  .option('--notify', 'Activates notifications for test results.')\n  .option('--onlyChanged', 'un based on which files have changed in the current repository. ')\n  .option('--outputFile <filename>', 'Write test results to a file when the --json option is also specified.')\n  .option('--passWithNoTests', 'Allows the test suite to pass when no files are found.')\n  .option('--quiet', 'No Lex notifications printed in the console.')\n  .option('--runInBand', 'Run all tests serially in the current process, rather than creating a worker pool of child processes that run tests.')\n  .option('--setup <path>', 'Jest setup file path.')\n  .option('--showConfig', 'Print your Jest config and then exits.')\n  .option('--silent', 'Prevent tests from printing messages through the console.')\n  .option('--testLocationInResults', 'Adds a location field to test results.')\n  .option('--testNamePattern <regex>', 'Run only tests with a name that matches the regex. ')\n  .option('--testPathPattern <regex>', 'A regexp pattern string that is matched against all tests paths before executing the test.')\n  .option('--typescript', 'Transpile as Typescript.')\n  .option('--update', 'Update snapshots. Runs \"jest --updateSnapshots\"')\n  .option('--useStderr', 'Divert all output to stderr.')\n  .option('--verbose', 'Display individual test results with the test suite hierarchy.')\n  .option('--watch <path>', 'Watch files for changes and rerun tests related to changed files.')\n  .option('--watchAll', 'Watch files for changes and rerun all tests when something changes.')\n  .action((options, cmd) => test(options, cmd.args, process.exit).then(() => {}));\n\nprogram.command('update')\n  .option('--interactive', 'Choose which packages to update.')\n  .addOption(new Option('--package-manager <manager>', 'Which package manager to use. Default: npm').choices(['npm', 'yarn']).default('npm'))\n  .option('--quiet', 'No Lex notifications printed in the console.')\n  .option('--registry', 'Add a custom registry url.')\n  .action((cmd) => update(cmd, process.exit).then(() => {}));\n\nprogram.command('upgrade')\n  .addOption(new Option('--package-manager <manager>', 'Which package manager to use. Default: npm').choices(['npm', 'yarn']).default('npm'))\n  .option('--quiet', 'No Lex notifications printed in the console.')\n  .action((cmd) => upgrade(cmd, process.exit).then(() => {}));\n\nprogram.command('ai')\n  .option('--context', 'Include project context in the AI prompt.', true)\n  .option('--file <path>', 'Specific file to operate on.')\n  .option('--lexConfig <path>', 'Custom Lex configuration file path (ie. lex.config.js).')\n  .option('--model <model>', 'AI model to use. Default: gpt-4o.')\n  .option('--prompt <text>', 'The prompt to send to the AI.')\n  .option('--quiet', 'No Lex notifications printed in the console.')\n  .addOption(new Option('--task <task>', 'Type of AI task to perform.').choices(['generate', 'explain', 'test', 'optimize', 'help']).default('help'))\n  .action((cmd) => aiFunction(cmd).then(() => {}));\n\nprogram.command('versions')\n  .option('--json', 'Print the version as a JSON object.')\n  .action((cmd) => versions(cmd, process.exit).then(() => {}));\n\nprogram\n  .version(packageJson.version)\n  .parse(process.argv);"],
  "mappings": "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",
  "names": []
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../src/lex.ts"],
  "sourcesContent": ["#!/usr/bin/env node\n/**\n * Copyright (c) 2018-Present, Nitrogen Labs, Inc.\n * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.\n */\nimport {Option, program} from 'commander';\nimport {readFileSync} from 'fs';\nimport {createRequire} from 'module';\nimport {dirname, resolve} from 'path';\nimport {fileURLToPath} from 'url';\n\nimport {aiFunction} from './commands/ai/ai.js';\nimport {build} from './commands/build/build.js';\nimport {clean} from './commands/clean/clean.js';\nimport {compile} from './commands/compile/compile.js';\nimport {config} from './commands/config/config.js';\nimport {create} from './commands/create/create.js';\nimport {dev} from './commands/dev/dev.js';\nimport {init} from './commands/init/init.js';\nimport {linked} from './commands/link/link.js';\nimport {lint} from './commands/lint/lint.js';\nimport {migrate} from './commands/migrate/migrate.js';\nimport {publish} from './commands/publish/publish.js';\nimport {storybook} from './commands/storybook/storybook.js';\nimport {test} from './commands/test/test.js';\nimport {update} from './commands/update/update.js';\nimport {upgrade} from './commands/upgrade/upgrade.js';\nimport {versions} from './commands/versions/versions.js';\n\n// Inject Lex's own node_modules into NODE_PATH for module resolution\nconst lexNodeModules = resolve(dirname(fileURLToPath(import.meta.url)), '../node_modules');\nif(!process.env.NODE_PATH) {\n  process.env.NODE_PATH = lexNodeModules;\n} else if(!process.env.NODE_PATH.split(':').includes(lexNodeModules)) {\n  process.env.NODE_PATH += `:${lexNodeModules}`;\n}\n// Re-initialize Node's module search paths\nconst require = createRequire(import.meta.url);\nrequire('module').Module._initPaths();\n\nconst packagePath = fileURLToPath(new URL('../package.json', import.meta.url));\nconst packageJson = JSON.parse(readFileSync(packagePath, 'utf8'));\n\nprogram.command('build')\n  .option('--assist', 'Enable AI assistance for fixing build errors.', false)\n  .option('--analyze', 'Enable AI analysis for build optimization suggestions or invoke webpack-bundle-analyzer plugin.', false)\n  .addOption(new Option('--bundler <n>', 'Bundler to use (\"webpack\" or \"esbuild\"). Default: \"webpack\".').choices(['webpack', 'esbuild']).default('webpack'))\n  .option('--config <path>', 'Custom Webpack configuration file path (ie. webpack.config.js).')\n  .option('--configName <value...>', 'Name of the configuration to use.')\n  .option('--defineProcessEnvNodeEnv <value>', 'Sets process.env.NODE_ENV to the specified value. (Currently an alias for `--node-env`)')\n  .option('--devtool <value>', 'A developer tool to enhance debugging (false | eval | [inline-|hidden-|eval-][nosources-][cheap-[module-]]source-map).')\n  .option('--disableInterpret', 'Disable interpret for loading the config file.', false)\n  .option('--entry <value...>', 'A module that is loaded upon startup. Only the last one is exported.')\n  .option('--env <value>', 'Environment passed to the configuration when it is a function.')\n  .option('--failOnWarnings', 'Stop webpack-cli process with non-zero exit code on warnings from webpack', false)\n  .addOption(new Option('--format <value>', 'This sets the output format for the generated JavaScript files. Default: \"cjs\".').choices(['cjs', 'esm']).default('cjs'))\n  .option('--json <value>', 'Prints result as JSON or store it in a file.')\n  .option('--lexConfig <path>', 'Lex configuration file path (lex.config.js).')\n  .option('--merge', 'Merge two or more configurations using \"webpack-merge\".', false)\n  .addOption(new Option('--mode <type>', 'Webpack mode (\"production\" or \"development\"). Default: \"development\".').choices(['development', 'production']).default('development'))\n  .option('--name <value>', 'Name of the configuration. Used when loading multiple configurations.')\n  .option('--noDevtool', 'Negative \"devtool\" option.', false)\n  .option('--noStats', 'Negative \"stats\" option.', false)\n  .option('--noTarget', 'Negative \"target\" option.', false)\n  .option('--noWatch', 'Negative \"watch\" option.', false)\n  .option('--noWatchOptionsStdin', 'Negative \"watch-options-stdin\" option.', false)\n  .option('--nodeEnv <value>', 'Sets process.env.NODE_ENV to the specified value.')\n  .option('--outputPath <value>', 'The output directory as **absolute path** (required).')\n  .option('--quiet', 'No Lex notifications printed in the console.', false)\n  .option('--remove', 'Removes all files from the output directory before compiling.', false)\n  .option('--sourcePath <path>', 'Source path')\n  .option('--stats <value>', 'Stats options object or preset name.')\n  .option('--static', 'Creates static HTML files when building app.', false)\n  .option('--target <value>', 'Environment to build for. Environment to build for. An array of environments to build for all of them when possible.')\n  .option('--typescript', 'Transpile as Typescript.', false)\n  .option('--variables <n>', 'Environment variables to set in \"process.env\". (ie. \"{NODE_ENV: \\'production\\'}\").')\n  .option('--watch', 'Watch for changes.', false)\n  .option('--watchOptionsStdin', 'Stop watching when stdin stream has ended.', false)\n  .action((cmd) => build(cmd, process.exit).then(() => {}));\n\nprogram.command('clean')\n  .option('--quiet', 'No Lex notifications printed in the console.')\n  .option('--snapshots', 'Remove all \"__snapshots__\" directories.')\n  .action((cmd) => clean(cmd, process.exit).then(() => {}));\n\nprogram.command('config <type>')\n  .option('--quiet', 'No Lex notifications printed in the console.')\n  .option('--json <path>', 'Save output to json file.')\n  .action((type, cmd) => config(type, cmd, process.exit).then(() => {}));\n\nprogram.command('compile')\n  .option('--config <path>', 'Transpiler configuration file path (ie. tsconfig.json).')\n  .option('--environment <n>', 'Target environment. \"node\" or \"web\". Default: \"node\".')\n  .option('--lexConfig <path>', 'Custom Lex configuration file path (ie. lex.config.js).')\n  .option('--outputPath <path>', 'Output path')\n  .option('--remove', 'Removes all files from the output directory before compiling.')\n  .option('--sourcePath <path>', 'Source path')\n  .option('--typescript', 'Transpile as Typescript.')\n  .option('--quiet', 'No Lex notifications printed in the console.')\n  .option('--watch', 'Watches for changes and compiles.')\n  .action((cmd) => compile(cmd, process.exit).then(() => {}));\n\nprogram.command('create <type>')\n  .option('--outputFile <path>', 'Output filename.')\n  .option('--outputName <n>', 'Output name.')\n  .option('--quiet', 'No Lex notifications printed in the console.')\n  .option('--typescript', 'Create Typescript version.')\n  .action((type, cmd) => create(type, cmd, process.exit).then(() => {}));\n\nprogram.command('dev')\n  .option('--bundleAnalyzer', 'Run bundle analyzer.')\n  .option('--config <path>', 'Custom Webpack configuration file path (ie. webpack.config.js).')\n  .option('--lexConfig <path>', 'Custom Lex configuration file path (ie. lex.config.js).')\n  .option('--open', 'Automatically open dev server in a new browser window.')\n  .option('--outputPath <path>', 'Output path')\n  .option('--quiet', 'No Lex notifications printed in the console.')\n  .option('--remove', 'Removes all files from the output directory before compiling.')\n  .option('--sourcePath <path>', 'Source path')\n  .option('--typescript', 'Transpile as Typescript.')\n  .option('--variables <n>', 'Environment variables to set in \"process.env\". (ie. \"{NODE_ENV: \\'development\\'}\").')\n  .option('--watch', 'Watch for changes.')\n  .action((cmd) => dev(cmd, process.exit).then(() => {}));\n\nprogram.command('init <appName> [packageName]')\n  .option('--install', 'Install dependencies.')\n  .addOption(new Option('--package-manager <manager>', 'Which package manager to use. Default: npm').choices(['npm', 'yarn']).default('npm'))\n  .option('--quiet', 'No Lex notifications printed in the console.')\n  .option('--typescript', 'Use a Typescript based app.')\n  .action((appName, packageName, cmd) => init(appName, packageName, cmd, process.exit).then(() => {}));\n\nprogram.command('linked')\n  .option('--quiet', 'No Lex notifications printed in the console.')\n  .action((cmd) => linked(cmd, process.exit).then(() => {}));\n\nprogram.command('lint')\n  .option('--cache', 'Only check changed files. Default: false.', false)\n  .option('--cacheLocation <path>', 'Path to the cache file or directory.')\n  .option('--color', 'Force enabling of color.', false)\n  .option('--config <path>', 'Use this configuration, overriding .eslintrc.* config options if present. If not specified and no local config exists, Lex will use its default config.')\n  .option('--debug', 'Output debugging information.', false)\n  .option('--envInfo', 'Output execution environment information. Default: false.', false)\n  .option('--env <n>', 'Specify environments.')\n  .option('--fix', 'Apply AI fixes after built-in ESLint fixes (same as --fix).', false)\n  .option('--fixDryRun', 'Automatically fix problems without saving the changes to the file system.', false)\n  .option('--fixType <type>', 'Specify the types of fixes to apply (problem, suggestion, layout).')\n  .option('--format <n>', 'Use a specific output format. Default: stylish.')\n  .option('--global <variables>', 'Define global variables.')\n  .option('--ignorePath <path>', 'Specify path of ignore file.')\n  .option('--ignorePattern <pattern>', 'Pattern of files to ignore (in addition to those in .eslintignore).')\n  .option('--init', 'Run config initialization wizard. Default: false.', false)\n  .option('--maxWarnings <num>', 'Number of warnings to trigger nonzero exit code. Default: -1.')\n  .option('--noColor', 'Force disabling of color.', false)\n  .option('--noEslintrc', 'Disable use of configuration from .eslintrc.*.', false)\n  .option('--noIgnore', 'Disable use of ignore files and patterns.', false)\n  .option('--noInlineConfig', 'Prevent comments from changing config or rules.', false)\n  .option('--outputFile <path>', 'Specify file to write report to.')\n  .option('--parser <n>', 'Specify the parser to be used.')\n  .option('--parserOptions <options>', 'Specify parser options.')\n  .option('--plugin <plugins>', 'Specify plugins.')\n  .option('--printConfig <path>', 'Print the configuration for the given file.')\n  .option('--quiet', 'No Lex notifications printed in the console.', false)\n  .option('--reportUnusedDisableDirectives', 'Adds reported errors for unused eslint-disable directives.', false)\n  .option('--resolvePluginsRelativeTo <path>', 'A folder where plugins should be resolved from.')\n  .option('--rule <path>', 'Specify rules.')\n  .option('--rulesdir <path>', 'Use additional rules from this directory.')\n  .option('--stdin', 'Lint code provided on <STDIN> - Default: false.', false)\n  .option('--stdinFilename <n>', 'Specify filename to process STDIN as.')\n  .action((cmd) => lint(cmd, process.exit).then(() => {}));\n\nprogram.command('migrate')\n  .option('-q, --quiet', 'No Lex notifications printed in the console.')\n  .action((cmd) => migrate(cmd, process.exit).then(() => {}));\n\nprogram.command('publish')\n  .addOption(new Option('--bump <type>', 'Increments the version. Types include: major, minor, patch, beta, alpha, rc. Default: \"patch\".').choices(['major', 'minor', 'patch', 'beta', 'alpha', 'rc']).default('patch'))\n  .option('--newVersion <versionNumber>', 'Publish as a specific version.')\n  .option('--otp <code>', 'Provide a two-factor code.')\n  .addOption(new Option('--package-manager <manager>', 'Which package manager to use. Default: npm').choices(['npm', 'yarn']).default('npm'))\n  .option('--private', 'Publishes the module as restricted.')\n  .option('--quiet', 'No Lex notifications printed in the console.')\n  .option('--tag <tag>', 'Registers the published package with the given tag.')\n  .action((cmd) => publish(cmd, process.exit).then(() => {}));\n\nprogram.command('storybook')\n  .option('--config <path>', 'Custom Storybook configuration directory path (ie. .storybook).')\n  .option('--lexConfig <path>', 'Custom Lex configuration file path (ie. lex.config.js).')\n  .option('--open', 'Automatically open Storybook in a new browser window.')\n  .option('--port <number>', 'Port number for the Storybook server.')\n  .option('--quiet', 'No Lex notifications printed in the console.')\n  .option('--static', 'Build a static Storybook site instead of starting dev server.')\n  .option('--variables <n>', 'Environment variables to set in \"process.env\". (ie. \"{STORYBOOK_THEME: \\'dark\\'}\").')\n  .action((cmd) => storybook(cmd, process.exit).then(() => {}));\n\nprogram.command('test')\n  .option('--analyze', 'Use AI to analyze test coverage and suggest improvements.', false)\n  .option('--debugTests', 'Use AI to debug test failures and suggest fixes.', false)\n  .option('--generate', 'Use AI to generate test cases for untested code.', false)\n  .option('--bail', 'Exit the test suite immediately upon the first failing test suite.')\n  .option('--changedFilesWithAncestor', 'Runs tests related to the current changes and the changes made in the last commit.')\n  .option('--changedSince', 'Runs tests related the changes since the provided branch.')\n  .option('--ci', 'When this option is provided, Jest will assume it is running in a CI environment.')\n  .option('--clearCache', 'Clear Jest cache.')\n  .option('--collectCoverageFrom <glob>', 'A glob pattern relative to matching the files that coverage info needs to be collected from.')\n  .option('--colors', 'Forces test results output highlighting even if stdout is not a TTY.')\n  .option('--config <path>', 'Custom Jest configuration file path (ie. jest.config.js).')\n  .option('--debug', 'Print debugging info about your Jest config.')\n  .option('--detectOpenHandles', 'Attempt to collect and print open handles preventing Jest from exiting cleanly')\n  .option('--environment <n>', 'Target environment. \"node\" or \"web\". Default: \"node\".')\n  .option('--env', 'The test environment used for all tests. This can point to any file or node module. Examples: jsdom, node or path/to/my-environment.js.')\n  .option('--errorOnDeprecated', 'Make calling deprecated APIs throw helpful error messages.')\n  .option('--expand', 'Use this flag to show full diffs and errors instead of a patch.')\n  .option('--forceExit', 'Force Jest to exit after all tests have completed running.')\n  .option('--json', 'Prints the test results in JSON.')\n  .option('--lastCommit', 'Run all tests affected by file changes in the last commit made.')\n  .option('--lexConfig <path>', 'Custom Lex configuration file path (ie. lex.config.js).')\n  .option('--listTests', 'Lists all tests as JSON that Jest will run given the arguments, and exits.')\n  .option('--logHeapUsage', 'Logs the heap usage after every test.')\n  .option('--maxWorkers <num>', 'Specifies the maximum number of workers the worker-pool will spawn for running tests. ')\n  .option('--noStackTrace', 'Disables stack trace in test results output.')\n  .option('--notify', 'Activates notifications for test results.')\n  .option('--onlyChanged', 'un based on which files have changed in the current repository. ')\n  .option('--outputFile <filename>', 'Write test results to a file when the --json option is also specified.')\n  .option('--passWithNoTests', 'Allows the test suite to pass when no files are found.')\n  .option('--quiet', 'No Lex notifications printed in the console.')\n  .option('--runInBand', 'Run all tests serially in the current process, rather than creating a worker pool of child processes that run tests.')\n  .option('--setup <path>', 'Jest setup file path.')\n  .option('--showConfig', 'Print your Jest config and then exits.')\n  .option('--silent', 'Prevent tests from printing messages through the console.')\n  .option('--testLocationInResults', 'Adds a location field to test results.')\n  .option('--testNamePattern <regex>', 'Run only tests with a name that matches the regex. ')\n  .option('--testPathPattern <regex>', 'A regexp pattern string that is matched against all tests paths before executing the test.')\n  .option('--typescript', 'Transpile as Typescript.')\n  .option('--update', 'Update snapshots. Runs \"jest --updateSnapshots\"')\n  .option('--useStderr', 'Divert all output to stderr.')\n  .option('--verbose', 'Display individual test results with the test suite hierarchy.')\n  .option('--watch <path>', 'Watch files for changes and rerun tests related to changed files.')\n  .option('--watchAll', 'Watch files for changes and rerun all tests when something changes.')\n  .action((options, cmd) => test(options, cmd.args, process.exit).then(() => {}));\n\nprogram.command('update')\n  .option('--interactive', 'Choose which packages to update.')\n  .addOption(new Option('--package-manager <manager>', 'Which package manager to use. Default: npm').choices(['npm', 'yarn']).default('npm'))\n  .option('--quiet', 'No Lex notifications printed in the console.')\n  .option('--registry', 'Add a custom registry url.')\n  .action((cmd) => update(cmd, process.exit).then(() => {}));\n\nprogram.command('upgrade')\n  .addOption(new Option('--package-manager <manager>', 'Which package manager to use. Default: npm').choices(['npm', 'yarn']).default('npm'))\n  .option('--quiet', 'No Lex notifications printed in the console.')\n  .action((cmd) => upgrade(cmd, process.exit).then(() => {}));\n\nprogram.command('ai')\n  .option('--context', 'Include project context in the AI prompt.', true)\n  .option('--file <path>', 'Specific file to operate on.')\n  .option('--lexConfig <path>', 'Custom Lex configuration file path (ie. lex.config.js).')\n  .option('--model <model>', 'AI model to use. Default: gpt-4o.')\n  .option('--prompt <text>', 'The prompt to send to the AI.')\n  .option('--quiet', 'No Lex notifications printed in the console.')\n  .addOption(new Option('--task <task>', 'Type of AI task to perform.').choices(['generate', 'explain', 'test', 'optimize', 'help']).default('help'))\n  .action((cmd) => aiFunction(cmd).then(() => {}));\n\nprogram.command('versions')\n  .option('--json', 'Print the version as a JSON object.')\n  .action((cmd) => versions(cmd, process.exit).then(() => {}));\n\nprogram\n  .version(packageJson.version)\n  .parse(process.argv);"],
  "mappings": "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",
  "names": ["require"]
}


package/dist/utils/aiService.js

@@ -1,9 +1,9 @@
 import { existsSync, readFileSync, writeFileSync } from "fs";
 import { resolve as pathResolve } from "path";
 import readline from "readline";
+import { LexConfig } from "../LexConfig.js";
 import { createSpinner } from "./app.js";
 import { log } from "./log.js";
-import { LexConfig } from "../LexConfig.js";
 const callCursorAI = async (prompt, options) => {
   try {
     log("Using Cursor IDE for AI fixes...", "info");
@@ -296,4 +296,4 @@ export {
   promptForAIProvider,
   promptForAPIKey
 };
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../src/utils/aiService.ts"],
  "sourcesContent": ["/**\n * Copyright (c) 2022-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 {resolve as pathResolve} from 'path';\nimport readline from 'readline';\n\nimport {createSpinner} from './app.js';\nimport {log} from './log.js';\nimport {LexConfig, AIConfig} from '../LexConfig.js';\n\n// Cursor IDE integration\nexport const callCursorAI = async (prompt: string, options: AIConfig): Promise<string> => {\n  try {\n    // When running within Cursor IDE, we can write the prompt to a temporary file\n    // that Cursor can use to provide AI assistance\n    log('Using Cursor IDE for AI fixes...', 'info');\n\n    // For now, just log the prompt and return a placeholder\n    // In a real implementation, Cursor would handle this automatically\n    log('AI fix requested via Cursor IDE', 'info');\n\n    const taskMatch = prompt.match(/^(Generate code according to the following request|Explain the following code|Generate comprehensive unit tests|Analyze the following code|Provide guidance on the following development question):/);\n    const task = taskMatch ? taskMatch[1] : '';\n    const isGenerateTask = task.startsWith('Generate code');\n\n    const questionMatch = prompt.match(/(?:Generate code according to the following request|Explain the following code|Generate comprehensive unit tests|Analyze the following code|Provide guidance on the following development question):\\s*([\\s\\S]+?)(?:===CONTEXT===|$)/);\n    const question = questionMatch ? questionMatch[1].trim() : prompt;\n\n    if(question.toLowerCase().includes('how many files') && prompt.includes('Project structure:')) {\n      const projectStructure = prompt.split('Project structure:')[1] || '';\n      const files = projectStructure.trim().split('\\n');\n      return `Based on the project structure provided, there are ${files.length} files in the project.`;\n    }\n\n    if(isGenerateTask) {\n      return `\n# Code Generation Request: \"${question}\"\n\nTo generate code using Cursor's AI capabilities:\n\n1. **Open your project in Cursor IDE** (https://cursor.sh)\n2. Press **Cmd+L** (or Ctrl+L on Windows/Linux) to open the AI chat\n3. Type your request: \"${question}\"\n4. Cursor will generate the code directly in your editor\n\nThe current CLI integration doesn't have direct access to Cursor's code generation capabilities.\n\n**Alternative options:**\n\n1. **Use OpenAI or Anthropic directly:**\n   Configure in your lex.config file:\n   \\`\\`\\`js\n   export default {\n     ai: {\n       provider: 'openai',\n       apiKey: process.env.OPENAI_API_KEY,\n       model: 'gpt-4o'\n     }\n   }\n   \\`\\`\\`\n\n2. **Use Cursor's command line tool:**\n   Install: \\`npm install -g @cursor/cli\\`\n   Run: \\`cursor ai \"${question}\"\\`\n`;\n    }\n\n    return `\nTo use Cursor's AI capabilities for \"${question}\", you need to:\n\n1. Open your project in Cursor IDE (https://cursor.sh)\n2. Use Cursor's built-in AI features by pressing Cmd+K or Cmd+L\n3. Or run the 'cursor' command directly from your terminal\n\nThe current integration is limited and doesn't directly access Cursor's AI capabilities.\n\nFor the best experience with AI code generation:\n- Use Cursor IDE directly\n- Or configure OpenAI or Anthropic as your provider in your lex.config file:\n\n\\`\\`\\`js\n// lex.config.js (or lex.config.mjs, lex.config.cjs, etc.)\nexport default {\n  ai: {\n    provider: 'openai', // or 'anthropic'\n    apiKey: process.env.OPENAI_API_KEY, // or ANTHROPIC_API_KEY\n    model: 'gpt-4o' // or 'claude-3-opus'\n  }\n}\n\\`\\`\\`\n\nThen set your API key as an environment variable:\n\\`\\`\\`\nexport OPENAI_API_KEY=your_key_here\n\\`\\`\\`\n`;\n  } catch(error) {\n    throw new Error(`Cursor AI error: ${error.message}`);\n  }\n};\n\nexport const callOpenAIAI = async (prompt: string, options: AIConfig): Promise<string> => {\n  try {\n    const apiKey = options.apiKey || process.env.OPENAI_API_KEY;\n    if(!apiKey) {\n      throw new Error('OpenAI API key is required. Set it in your lex.config file or as OPENAI_API_KEY environment variable.');\n    }\n\n    const response = await fetch('https://api.openai.com/v1/chat/completions', {\n      body: JSON.stringify({\n        max_tokens: options.maxTokens || 4000,\n        messages: [\n          {content: 'You are a helpful assistant that fixes ESLint errors in code.', role: 'system'},\n          {content: prompt, role: 'user'}\n        ],\n        model: options.model || 'gpt-4o',\n        temperature: options.temperature || 0.1\n      }),\n      headers: {\n        Authorization: `Bearer ${apiKey}`,\n        'Content-Type': 'application/json'\n      },\n      method: 'POST'\n    });\n\n    if(!response.ok) {\n      const error = await response.json();\n      throw new Error(`OpenAI API error: ${error.error?.message || response.statusText}`);\n    }\n\n    const data = await response.json();\n    return data.choices[0].message.content;\n  } catch(error) {\n    throw new Error(`OpenAI AI error: ${error.message}`);\n  }\n};\n\nexport const callAnthropicAI = async (prompt: string, options: AIConfig): Promise<string> => {\n  try {\n    const apiKey = options.apiKey || process.env.ANTHROPIC_API_KEY;\n    if(!apiKey) {\n      throw new Error('Anthropic API key is required. Set it in your lex.config file or as ANTHROPIC_API_KEY environment variable.');\n    }\n\n    const response = await fetch('https://api.anthropic.com/v1/messages', {\n      body: JSON.stringify({\n        max_tokens: options.maxTokens || 4000,\n        messages: [\n          {content: prompt, role: 'user'}\n        ],\n        model: options.model || 'claude-3-sonnet-20240229',\n        temperature: options.temperature || 0.1\n      }),\n      headers: {\n        'Content-Type': 'application/json',\n        'anthropic-version': '2023-06-01',\n        'x-api-key': apiKey\n      },\n      method: 'POST'\n    });\n\n    if(!response.ok) {\n      const error = await response.json();\n      throw new Error(`Anthropic API error: ${error.error?.message || response.statusText}`);\n    }\n\n    const data = await response.json();\n    return data.content[0].text;\n  } catch(error) {\n    throw new Error(`Anthropic AI error: ${error.message}`);\n  }\n};\n\nexport const callCopilotAI = async (prompt: string, options: AIConfig): Promise<string> => {\n  try {\n    log('GitHub Copilot AI fixes not directly supported. Using manual fix mode.', 'info');\n    return prompt;\n  } catch(error) {\n    throw new Error(`GitHub Copilot AI error: ${error.message}`);\n  }\n};\n\nexport const promptForAIProvider = async (quiet = false): Promise<'cursor' | 'copilot' | 'openai' | 'anthropic' | 'none'> => {\n  const rl = readline.createInterface({\n    input: process.stdin,\n    output: process.stdout\n  });\n\n  return new Promise((resolve) => {\n    log('\\nNo AI provider configured. Please choose an AI provider:', 'info');\n    log('1. Cursor IDE', 'info');\n    log('2. OpenAI', 'info');\n    log('3. Anthropic', 'info');\n    log('4. GitHub Copilot', 'info');\n    log('5. None (Skip AI features)', 'info');\n\n    rl.question('Enter your choice (1-5): ', (answer) => {\n      rl.close();\n\n      switch(answer) {\n        case '1':\n          resolve('cursor');\n          break;\n        case '2':\n          resolve('openai');\n          break;\n        case '3':\n          resolve('anthropic');\n          break;\n        case '4':\n          resolve('copilot');\n          break;\n        default:\n          resolve('none');\n      }\n    });\n  });\n};\n\nexport const promptForAPIKey = async (provider: string, quiet = false): Promise<string> => {\n  const rl = readline.createInterface({\n    input: process.stdin,\n    output: process.stdout\n  });\n\n  return new Promise((resolve) => {\n    rl.question(`Please enter your ${provider} API key: `, (answer) => {\n      rl.close();\n      resolve(answer);\n    });\n  });\n};\n\nexport const getAIService = (provider: string, options: AIConfig): (prompt: string, options: AIConfig) => Promise<string> => {\n  switch(provider) {\n    case 'cursor':\n      return callCursorAI;\n    case 'openai':\n      return callOpenAIAI;\n    case 'anthropic':\n      return callAnthropicAI;\n    case 'copilot':\n      return callCopilotAI;\n    default:\n      return async () => 'No AI provider configured';\n  }\n};\n\nexport const callAIService = async (prompt: string, quiet = false): Promise<string> => {\n  const spinner = createSpinner(quiet);\n  spinner.start('Calling AI service to fix code issues...');\n\n  try {\n    const aiConfig = LexConfig.config.ai || {provider: 'none'};\n\n    const isInCursorIDE = process.env.CURSOR_IDE === 'true';\n    if(isInCursorIDE && (aiConfig.provider === 'none' || !aiConfig.provider)) {\n      log('Detected Cursor IDE environment, using Cursor as AI provider', 'info', quiet);\n      aiConfig.provider = 'cursor';\n    }\n\n    if(aiConfig.provider === 'none') {\n      const provider = await promptForAIProvider(quiet);\n\n      if(provider === 'none') {\n        spinner.fail('AI features skipped');\n        return '';\n      }\n\n      aiConfig.provider = provider;\n\n      if(provider !== 'cursor' && provider !== 'copilot' &&\n         !process.env[`${provider.toUpperCase()}_API_KEY`]) {\n        aiConfig.apiKey = await promptForAPIKey(provider, quiet);\n      }\n\n      LexConfig.config.ai = aiConfig;\n\n      // Search for config files in multiple formats like LexConfig.parseConfig does\n      const configFormats = ['js', 'mjs', 'cjs', 'ts', 'json'];\n      const configBaseName = 'lex.config';\n      let configPath = '';\n\n      for(const format of configFormats) {\n        const potentialPath = pathResolve(process.cwd(), `./${configBaseName}.${format}`);\n        if(existsSync(potentialPath)) {\n          configPath = potentialPath;\n          break;\n        }\n      }\n\n      if(configPath) {\n        try {\n          const configContent = readFileSync(configPath, 'utf8');\n          const updatedConfig = configContent.replace(\n            /ai:.*?[,}]/s,\n            `ai: { provider: '${aiConfig.provider}' },`\n          );\n          writeFileSync(configPath, updatedConfig);\n        } catch(_error) {\n        }\n      }\n    }\n\n    let result = '';\n\n    switch(aiConfig.provider) {\n      case 'cursor':\n        result = await callCursorAI(prompt, aiConfig);\n        log('Cursor IDE AI integration active', 'info', quiet);\n        break;\n      case 'openai':\n        result = await callOpenAIAI(prompt, aiConfig);\n        break;\n      case 'anthropic':\n        result = await callAnthropicAI(prompt, aiConfig);\n        break;\n      case 'copilot':\n        result = await callCopilotAI(prompt, aiConfig);\n        break;\n      default:\n        spinner.fail('No AI provider configured');\n        return '';\n    }\n\n    spinner.succeed('AI code fixes generated successfully');\n    return result;\n  } catch(error) {\n    spinner.fail(`AI service error: ${error.message}`);\n    if(!quiet) {\n      log(error, 'error');\n    }\n    return '';\n  }\n};"],
  "mappings": "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",
  "names": []
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../src/utils/aiService.ts"],
  "sourcesContent": ["/**\n * Copyright (c) 2022-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 {resolve as pathResolve} from 'path';\nimport readline from 'readline';\n\nimport {AIConfig, LexConfig} from '../LexConfig.js';\nimport {createSpinner} from './app.js';\nimport {log} from './log.js';\n\n// Cursor IDE integration\nexport const callCursorAI = async (prompt: string, options: AIConfig): Promise<string> => {\n  try {\n    // When running within Cursor IDE, we can write the prompt to a temporary file\n    // that Cursor can use to provide AI assistance\n    log('Using Cursor IDE for AI fixes...', 'info');\n\n    // For now, just log the prompt and return a placeholder\n    // In a real implementation, Cursor would handle this automatically\n    log('AI fix requested via Cursor IDE', 'info');\n\n    const taskMatch = prompt.match(/^(Generate code according to the following request|Explain the following code|Generate comprehensive unit tests|Analyze the following code|Provide guidance on the following development question):/);\n    const task = taskMatch ? taskMatch[1] : '';\n    const isGenerateTask = task.startsWith('Generate code');\n\n    const questionMatch = prompt.match(/(?:Generate code according to the following request|Explain the following code|Generate comprehensive unit tests|Analyze the following code|Provide guidance on the following development question):\\s*([\\s\\S]+?)(?:===CONTEXT===|$)/);\n    const question = questionMatch ? questionMatch[1].trim() : prompt;\n\n    if(question.toLowerCase().includes('how many files') && prompt.includes('Project structure:')) {\n      const projectStructure = prompt.split('Project structure:')[1] || '';\n      const files = projectStructure.trim().split('\\n');\n      return `Based on the project structure provided, there are ${files.length} files in the project.`;\n    }\n\n    if(isGenerateTask) {\n      return `\n# Code Generation Request: \"${question}\"\n\nTo generate code using Cursor's AI capabilities:\n\n1. **Open your project in Cursor IDE** (https://cursor.sh)\n2. Press **Cmd+L** (or Ctrl+L on Windows/Linux) to open the AI chat\n3. Type your request: \"${question}\"\n4. Cursor will generate the code directly in your editor\n\nThe current CLI integration doesn't have direct access to Cursor's code generation capabilities.\n\n**Alternative options:**\n\n1. **Use OpenAI or Anthropic directly:**\n   Configure in your lex.config file:\n   \\`\\`\\`js\n   export default {\n     ai: {\n       provider: 'openai',\n       apiKey: process.env.OPENAI_API_KEY,\n       model: 'gpt-4o'\n     }\n   }\n   \\`\\`\\`\n\n2. **Use Cursor's command line tool:**\n   Install: \\`npm install -g @cursor/cli\\`\n   Run: \\`cursor ai \"${question}\"\\`\n`;\n    }\n\n    return `\nTo use Cursor's AI capabilities for \"${question}\", you need to:\n\n1. Open your project in Cursor IDE (https://cursor.sh)\n2. Use Cursor's built-in AI features by pressing Cmd+K or Cmd+L\n3. Or run the 'cursor' command directly from your terminal\n\nThe current integration is limited and doesn't directly access Cursor's AI capabilities.\n\nFor the best experience with AI code generation:\n- Use Cursor IDE directly\n- Or configure OpenAI or Anthropic as your provider in your lex.config file:\n\n\\`\\`\\`js\n// lex.config.js (or lex.config.mjs, lex.config.cjs, etc.)\nexport default {\n  ai: {\n    provider: 'openai', // or 'anthropic'\n    apiKey: process.env.OPENAI_API_KEY, // or ANTHROPIC_API_KEY\n    model: 'gpt-4o' // or 'claude-3-opus'\n  }\n}\n\\`\\`\\`\n\nThen set your API key as an environment variable:\n\\`\\`\\`\nexport OPENAI_API_KEY=your_key_here\n\\`\\`\\`\n`;\n  } catch(error) {\n    throw new Error(`Cursor AI error: ${error.message}`);\n  }\n};\n\nexport const callOpenAIAI = async (prompt: string, options: AIConfig): Promise<string> => {\n  try {\n    const apiKey = options.apiKey || process.env.OPENAI_API_KEY;\n    if(!apiKey) {\n      throw new Error('OpenAI API key is required. Set it in your lex.config file or as OPENAI_API_KEY environment variable.');\n    }\n\n    const response = await fetch('https://api.openai.com/v1/chat/completions', {\n      body: JSON.stringify({\n        max_tokens: options.maxTokens || 4000,\n        messages: [\n          {content: 'You are a helpful assistant that fixes ESLint errors in code.', role: 'system'},\n          {content: prompt, role: 'user'}\n        ],\n        model: options.model || 'gpt-4o',\n        temperature: options.temperature || 0.1\n      }),\n      headers: {\n        Authorization: `Bearer ${apiKey}`,\n        'Content-Type': 'application/json'\n      },\n      method: 'POST'\n    });\n\n    if(!response.ok) {\n      const error = await response.json();\n      throw new Error(`OpenAI API error: ${error.error?.message || response.statusText}`);\n    }\n\n    const data = await response.json();\n    return data.choices[0].message.content;\n  } catch(error) {\n    throw new Error(`OpenAI AI error: ${error.message}`);\n  }\n};\n\nexport const callAnthropicAI = async (prompt: string, options: AIConfig): Promise<string> => {\n  try {\n    const apiKey = options.apiKey || process.env.ANTHROPIC_API_KEY;\n    if(!apiKey) {\n      throw new Error('Anthropic API key is required. Set it in your lex.config file or as ANTHROPIC_API_KEY environment variable.');\n    }\n\n    const response = await fetch('https://api.anthropic.com/v1/messages', {\n      body: JSON.stringify({\n        max_tokens: options.maxTokens || 4000,\n        messages: [\n          {content: prompt, role: 'user'}\n        ],\n        model: options.model || 'claude-3-sonnet-20240229',\n        temperature: options.temperature || 0.1\n      }),\n      headers: {\n        'Content-Type': 'application/json',\n        'anthropic-version': '2023-06-01',\n        'x-api-key': apiKey\n      },\n      method: 'POST'\n    });\n\n    if(!response.ok) {\n      const error = await response.json();\n      throw new Error(`Anthropic API error: ${error.error?.message || response.statusText}`);\n    }\n\n    const data = await response.json();\n    return data.content[0].text;\n  } catch(error) {\n    throw new Error(`Anthropic AI error: ${error.message}`);\n  }\n};\n\nexport const callCopilotAI = async (prompt: string, options: AIConfig): Promise<string> => {\n  try {\n    log('GitHub Copilot AI fixes not directly supported. Using manual fix mode.', 'info');\n    return prompt;\n  } catch(error) {\n    throw new Error(`GitHub Copilot AI error: ${error.message}`);\n  }\n};\n\nexport const promptForAIProvider = async (quiet = false): Promise<'cursor' | 'copilot' | 'openai' | 'anthropic' | 'none'> => {\n  const rl = readline.createInterface({\n    input: process.stdin,\n    output: process.stdout\n  });\n\n  return new Promise((resolve) => {\n    log('\\nNo AI provider configured. Please choose an AI provider:', 'info');\n    log('1. Cursor IDE', 'info');\n    log('2. OpenAI', 'info');\n    log('3. Anthropic', 'info');\n    log('4. GitHub Copilot', 'info');\n    log('5. None (Skip AI features)', 'info');\n\n    rl.question('Enter your choice (1-5): ', (answer) => {\n      rl.close();\n\n      switch(answer) {\n        case '1':\n          resolve('cursor');\n          break;\n        case '2':\n          resolve('openai');\n          break;\n        case '3':\n          resolve('anthropic');\n          break;\n        case '4':\n          resolve('copilot');\n          break;\n        default:\n          resolve('none');\n      }\n    });\n  });\n};\n\nexport const promptForAPIKey = async (provider: string, quiet = false): Promise<string> => {\n  const rl = readline.createInterface({\n    input: process.stdin,\n    output: process.stdout\n  });\n\n  return new Promise((resolve) => {\n    rl.question(`Please enter your ${provider} API key: `, (answer) => {\n      rl.close();\n      resolve(answer);\n    });\n  });\n};\n\nexport const getAIService = (provider: string, options: AIConfig): (prompt: string, options: AIConfig) => Promise<string> => {\n  switch(provider) {\n    case 'cursor':\n      return callCursorAI;\n    case 'openai':\n      return callOpenAIAI;\n    case 'anthropic':\n      return callAnthropicAI;\n    case 'copilot':\n      return callCopilotAI;\n    default:\n      return async () => 'No AI provider configured';\n  }\n};\n\nexport const callAIService = async (prompt: string, quiet = false): Promise<string> => {\n  const spinner = createSpinner(quiet);\n  spinner.start('Calling AI service to fix code issues...');\n\n  try {\n    const aiConfig = LexConfig.config.ai || {provider: 'none'};\n\n    const isInCursorIDE = process.env.CURSOR_IDE === 'true';\n    if(isInCursorIDE && (aiConfig.provider === 'none' || !aiConfig.provider)) {\n      log('Detected Cursor IDE environment, using Cursor as AI provider', 'info', quiet);\n      aiConfig.provider = 'cursor';\n    }\n\n    if(aiConfig.provider === 'none') {\n      const provider = await promptForAIProvider(quiet);\n\n      if(provider === 'none') {\n        spinner.fail('AI features skipped');\n        return '';\n      }\n\n      aiConfig.provider = provider;\n\n      if(provider !== 'cursor' && provider !== 'copilot' &&\n        !process.env[`${provider.toUpperCase()}_API_KEY`]) {\n        aiConfig.apiKey = await promptForAPIKey(provider, quiet);\n      }\n\n      LexConfig.config.ai = aiConfig;\n\n      // Search for config files in multiple formats like LexConfig.parseConfig does\n      const configFormats = ['js', 'mjs', 'cjs', 'ts', 'json'];\n      const configBaseName = 'lex.config';\n      let configPath = '';\n\n      for(const format of configFormats) {\n        const potentialPath = pathResolve(process.cwd(), `./${configBaseName}.${format}`);\n        if(existsSync(potentialPath)) {\n          configPath = potentialPath;\n          break;\n        }\n      }\n\n      if(configPath) {\n        try {\n          const configContent = readFileSync(configPath, 'utf8');\n          const updatedConfig = configContent.replace(\n            /ai:.*?[,}]/s,\n            `ai: { provider: '${aiConfig.provider}' },`\n          );\n          writeFileSync(configPath, updatedConfig);\n        } catch(_error) {\n        }\n      }\n    }\n\n    let result = '';\n\n    switch(aiConfig.provider) {\n      case 'cursor':\n        result = await callCursorAI(prompt, aiConfig);\n        log('Cursor IDE AI integration active', 'info', quiet);\n        break;\n      case 'openai':\n        result = await callOpenAIAI(prompt, aiConfig);\n        break;\n      case 'anthropic':\n        result = await callAnthropicAI(prompt, aiConfig);\n        break;\n      case 'copilot':\n        result = await callCopilotAI(prompt, aiConfig);\n        break;\n      default:\n        spinner.fail('No AI provider configured');\n        return '';\n    }\n\n    spinner.succeed('AI code fixes generated successfully');\n    return result;\n  } catch(error) {\n    spinner.fail(`AI service error: ${error.message}`);\n    if(!quiet) {\n      log(error, 'error');\n    }\n    return '';\n  }\n};"],
  "mappings": "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",
  "names": []
}


package/dist/utils/app.js

@@ -1,6 +1,6 @@
 import boxen from "boxen";
 import { copyFile, existsSync, lstatSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from "fs";
-import { globSync } from "glob";
+import { sync as globSync } from "glob";
 import isEmpty from "lodash/isEmpty.js";
 import ora from "ora";
 import { basename as pathBasename, join as pathJoin, relative as pathRelative, resolve as pathResolve } from "path";
@@ -224,7 +224,7 @@ const linkedModules = (startPath) => {
       }
       return list;
     } catch (fsError) {
-      throw fsError;
+      return list;
     }
   }, []);
 };
@@ -264,4 +264,4 @@ export {
   setPackageJson,
   updateTemplateName
 };
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../src/utils/app.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 boxen from 'boxen';\nimport {copyFile, existsSync, lstatSync, mkdirSync, readdirSync, readFileSync, writeFileSync} from 'fs';\nimport {globSync} from 'glob';\nimport isEmpty from 'lodash/isEmpty.js';\nimport ora from 'ora';\nimport {basename as pathBasename, join as pathJoin, relative as pathRelative, resolve as pathResolve} from 'path';\nimport {rimrafSync} from 'rimraf';\n\nimport {log} from './log.js';\n\nimport type {LexConfigType} from '../LexConfig.js';\n\nexport const cwd: string = process.cwd();\n\nexport interface GetFilenamesProps {\n  readonly callback?: (status: number) => void;\n  readonly cliName?: string;\n  readonly name?: string;\n  readonly quiet?: boolean;\n  readonly type?: string;\n  readonly useTypescript?: boolean;\n}\n\ninterface FilenamesResult {\n  nameCaps: string;\n  templateExt: string;\n  templatePath: string;\n  templateReact: string;\n}\n\nexport const getFilenames = (props: GetFilenamesProps): FilenamesResult | void => {\n  const {callback, cliName, name, quiet, type, useTypescript} = props;\n\n  let nameCaps: string;\n  const itemTypes: string[] = ['stores', 'views'];\n\n  if(!name) {\n    if(itemTypes.includes(type)) {\n      log(`\\n${cliName} Error: ${type} name is required. Please use 'lex -h' for options.`, 'error', quiet);\n      return callback?.(1);\n    }\n  } else {\n    nameCaps = `${name.charAt(0).toUpperCase()}${name.substr(1)}`;\n  }\n\n  log(`${cliName} adding ${name} ${type}...`, 'info', quiet);\n\n  let templatePath: string;\n  let templateExt: string;\n  let templateReact: string;\n\n  if(useTypescript) {\n    templatePath = '../../templates/typescript';\n    templateExt = '.ts';\n    templateReact = '.tsx';\n  } else {\n    templatePath = '../../templates/flow';\n    templateExt = '.js';\n    templateReact = '.js';\n  }\n\n  return {\n    nameCaps,\n    templateExt,\n    templatePath,\n    templateReact\n  };\n};\n\nexport interface Spinner {\n  fail: (text?: string) => void;\n  start: (text?: string) => void;\n  succeed: (text?: string) => void;\n}\n\nexport const createSpinner = (quiet = false): Spinner => {\n  if(quiet) {\n    return {\n      fail: () => {},\n      start: () => {},\n      succeed: () => {}\n    };\n  }\n\n  return ora({color: 'yellow'});\n};\n\nexport const copyFiles = async (files: string[], typeName: string, spinner, config: LexConfigType) => {\n  const {outputFullPath, sourceFullPath} = config;\n  const items = files.map((fileName: string) => ({\n    from: fileName,\n    to: pathResolve(outputFullPath, pathRelative(sourceFullPath, fileName))\n  }));\n\n  try {\n    spinner.start(`Copying ${typeName} files...`);\n    await Promise.all(items.map(({from, to}) => new Promise(\n      (resolve, reject) => {\n        mkdirSync(pathResolve(to, '..'), {recursive: true});\n        return copyFile(from, to, (copyError) => {\n          if(copyError) {\n            reject();\n          } else {\n            resolve(true);\n          }\n        });\n      }\n    )));\n    spinner.succeed(`Successfully copied ${files.length} ${typeName} files!`);\n  } catch(error) {\n    spinner.fail(`Copying of ${typeName} files failed.`);\n    log(`Error: ${error.message}`, 'error');\n    log(error, 'error');\n  }\n};\n\nexport const copyConfiguredFiles = async (spinner, config: LexConfigType, quiet: boolean) => {\n  const {copyFiles: copyFilesConfig, outputFullPath, sourceFullPath, sourcePath} = config;\n  if (!copyFilesConfig || copyFilesConfig.length === 0) {\n    return;\n  }\n\n  try {\n    spinner.start('Copying configured files...');\n    let totalCopied = 0;\n\n    const baseDir = sourceFullPath || (sourcePath ? pathResolve(cwd, sourcePath) : cwd);\n\n    for (const pattern of copyFilesConfig) {\n      const resolvedPattern = pathResolve(baseDir, pattern);\n      const matchingFiles = globSync(resolvedPattern, {\n        nodir: true,\n        absolute: true\n      });\n      if (matchingFiles.length === 0) {\n        if (!quiet) {\n          log(`Warning: No files found matching pattern: ${pattern}`, 'warn', quiet);\n        }\n        continue;\n      }\n\n      for (const sourceFile of matchingFiles) {\n        // Calculate relative path from source directory\n        const relativePath = pathRelative(baseDir, sourceFile);\n        // Determine destination path in output directory\n        const destPath = pathResolve(outputFullPath, relativePath);\n        // Create destination directory if it doesn't exist\n        const destDir = pathResolve(destPath, '..');\n        mkdirSync(destDir, {recursive: true});\n\n        await new Promise((resolve, reject) => {\n          copyFile(sourceFile, destPath, (copyError) => {\n            if (copyError) {\n              reject(copyError);\n            } else {\n              resolve(true);\n            }\n          });\n        });\n        totalCopied++;\n      }\n    }\n    if (totalCopied > 0) {\n      spinner.succeed(`Successfully copied ${totalCopied} configured files!`);\n    } else {\n      spinner.succeed('No configured files to copy');\n    }\n  } catch (error) {\n    spinner.fail('Failed to copy configured files');\n    log(`Error copying configured files: ${error.message}`, 'error', quiet);\n    throw error;\n  }\n};\n\nexport const copyFileSync = (source: string, target: string) => {\n  let targetFile: string = target;\n\n  if(existsSync(target)) {\n    if(lstatSync(target).isDirectory()) {\n      targetFile = pathJoin(target, pathBasename(source));\n    }\n  }\n\n  writeFileSync(targetFile, readFileSync(source));\n};\n\nexport const copyFolderRecursiveSync = (source: string, target: string): void => {\n  let files: string[] = [];\n\n  const targetFolder: string = pathJoin(target, pathBasename(source));\n\n  if(!existsSync(targetFolder)) {\n    mkdirSync(targetFolder);\n  }\n\n  if(lstatSync(source).isDirectory()) {\n    files = readdirSync(source);\n    files.forEach((file: string) => {\n      const curSource: string = pathJoin(source, file);\n\n      if(lstatSync(curSource).isDirectory()) {\n        copyFolderRecursiveSync(curSource, targetFolder);\n      } else {\n        copyFileSync(curSource, targetFolder);\n      }\n    });\n  }\n};\n\nexport const getPackageJson = (packagePath?: string) => {\n  const formatPath: string = packagePath || `${process.cwd()}/package.json`;\n\n  const packageData: string = readFileSync(formatPath).toString();\n  return JSON.parse(packageData);\n};\n\nexport const getFilesByExt = (ext: string, config: LexConfigType): string[] => {\n  const {sourceFullPath} = config;\n  return globSync(`${sourceFullPath}/**/**${ext}`);\n};\n\nexport const removeConflictModules = (moduleList: object) => {\n  const updatedList: object = {...moduleList};\n\n  Object.keys(updatedList).forEach((moduleName: string) => {\n    const regex: RegExp = new RegExp('^(?!@types/).*?(jest|webpack).*$', 'gi');\n    if(regex.test(moduleName)) {\n      delete updatedList[moduleName];\n    }\n  });\n\n  return updatedList;\n};\n\nexport const removeFiles = (fileName: string, isRelative: boolean = false) => new Promise((resolve, reject) => {\n  const filePath: string = isRelative ? pathResolve(cwd, fileName) : fileName;\n  try {\n    rimrafSync(filePath);\n    return resolve(null);\n  } catch(error) {\n    return reject(error);\n  }\n});\n\nexport const removeModules = () => new Promise(async (resolve, reject) => {\n  try {\n    // Remove node_modules\n    await removeFiles('./node_modules', true);\n\n    // Remove yarn lock\n    await removeFiles('./yarn.lock', true);\n\n    // Remove npm lock\n    await removeFiles('./package-lock.json', true);\n\n    resolve(null);\n  } catch(error) {\n    reject(error);\n  }\n});\n\nexport const setPackageJson = (json, packagePath?: string) => {\n  if(!json) {\n    return;\n  }\n\n  const formatPath: string = packagePath || `${process.cwd()}/package.json`;\n\n  writeFileSync(formatPath, JSON.stringify(json, null, 2));\n};\n\nexport interface LinkedModuleType {\n  readonly name: string;\n  readonly path: string;\n}\n\nexport const linkedModules = (startPath?: string): LinkedModuleType[] => {\n  const workingPath: string = startPath || process.cwd();\n  let modulePath: string;\n  let prefix: string;\n\n  if(workingPath.includes('@')) {\n    prefix = `@${workingPath.split('@').pop()}`;\n    modulePath = workingPath;\n  } else {\n    modulePath = pathJoin(workingPath, 'node_modules');\n  }\n\n  const foundPaths: string[] = globSync(`${modulePath}/*`);\n  return foundPaths.reduce((list: LinkedModuleType[], foundPath: string) => {\n    try {\n      const stats = lstatSync(foundPath);\n\n      if(stats.isDirectory()) {\n        const deepList: LinkedModuleType[] = linkedModules(foundPath);\n        list.push(...deepList);\n      } else if(stats.isSymbolicLink()) {\n        const moduleNames: string[] = ([prefix, pathBasename(foundPath)]).filter((item: string) => !isEmpty(item));\n        list.push({name: `${moduleNames.join('/')}`, path: foundPath});\n      }\n\n      return list;\n    } catch(fsError) {\n      throw fsError;\n    }\n  }, []);\n};\n\nexport const checkLinkedModules = () => {\n  const linked = linkedModules();\n\n  if(linked.length) {\n    const msgModule: string = linked.length > 1 ? 'Modules' : 'Module';\n    const linkedMsg: string = linked.reduce(\n      (msg: string, linkedModule: LinkedModuleType) =>\n        `${msg}\\n * ${linkedModule.name}`,\n      `Linked ${msgModule}:`\n    );\n    log(boxen(linkedMsg, {dimBorder: true, padding: 1}), 'warn');\n  }\n};\n\nexport const updateTemplateName = (filePath: string, replace: string, replaceCaps: string) => {\n  let data: string = readFileSync(filePath, 'utf8');\n  data = data.replace(/sample/g, replace);\n  data = data.replace(/Sample/g, replaceCaps);\n  writeFileSync(filePath, data, 'utf8');\n};"],
  "mappings": "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",
  "names": []
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../src/utils/app.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 */\n\nimport boxen from 'boxen';\nimport {copyFile, existsSync, lstatSync, mkdirSync, readdirSync, readFileSync, writeFileSync} from 'fs';\nimport {sync as globSync} from 'glob';\nimport isEmpty from 'lodash/isEmpty.js';\nimport ora from 'ora';\nimport {basename as pathBasename, join as pathJoin, relative as pathRelative, resolve as pathResolve} from 'path';\nimport {rimrafSync} from 'rimraf';\n\n\nimport {log} from './log.js';\n\nimport type {LexConfigType} from '../LexConfig.js';\n\n\nexport const cwd: string = process.cwd();\n\nexport interface GetFilenamesProps {\n  readonly callback?: (status: number) => void;\n  readonly cliName?: string;\n  readonly name?: string;\n  readonly quiet?: boolean;\n  readonly type?: string;\n  readonly useTypescript?: boolean;\n}\n\ninterface FilenamesResult {\n  nameCaps: string;\n  templateExt: string;\n  templatePath: string;\n  templateReact: string;\n}\n\nexport const getFilenames = (props: GetFilenamesProps): FilenamesResult | void => {\n  const {callback, cliName, name, quiet, type, useTypescript} = props;\n\n  let nameCaps: string;\n  const itemTypes: string[] = ['stores', 'views'];\n\n  if(!name) {\n    if(itemTypes.includes(type)) {\n      log(`\\n${cliName} Error: ${type} name is required. Please use 'lex -h' for options.`, 'error', quiet);\n      return callback?.(1);\n    }\n  } else {\n    nameCaps = `${name.charAt(0).toUpperCase()}${name.substr(1)}`;\n  }\n\n  log(`${cliName} adding ${name} ${type}...`, 'info', quiet);\n\n  let templatePath: string;\n  let templateExt: string;\n  let templateReact: string;\n\n  if(useTypescript) {\n    templatePath = '../../templates/typescript';\n    templateExt = '.ts';\n    templateReact = '.tsx';\n  } else {\n    templatePath = '../../templates/flow';\n    templateExt = '.js';\n    templateReact = '.js';\n  }\n\n  return {\n    nameCaps,\n    templateExt,\n    templatePath,\n    templateReact\n  };\n};\n\nexport interface Spinner {\n  fail: (text?: string) => void;\n  start: (text?: string) => void;\n  succeed: (text?: string) => void;\n}\n\nexport const createSpinner = (quiet = false): Spinner => {\n  if(quiet) {\n    return {\n      fail: () => {},\n      start: () => {},\n      succeed: () => {}\n    };\n  }\n\n  return ora({color: 'yellow'});\n};\n\nexport const copyFiles = async (files: string[], typeName: string, spinner, config: LexConfigType) => {\n  const {outputFullPath, sourceFullPath} = config;\n  const items = files.map((fileName: string) => ({\n    from: fileName,\n    to: pathResolve(outputFullPath, pathRelative(sourceFullPath, fileName))\n  }));\n\n  try {\n    spinner.start(`Copying ${typeName} files...`);\n    await Promise.all(items.map(({from, to}) => new Promise(\n      (resolve, reject) => {\n        mkdirSync(pathResolve(to, '..'), {recursive: true});\n        return copyFile(from, to, (copyError) => {\n          if(copyError) {\n            reject();\n          } else {\n            resolve(true);\n          }\n        });\n      }\n    )));\n    spinner.succeed(`Successfully copied ${files.length} ${typeName} files!`);\n  } catch(error) {\n    spinner.fail(`Copying of ${typeName} files failed.`);\n    log(`Error: ${error.message}`, 'error');\n    log(error, 'error');\n  }\n};\n\nexport const copyConfiguredFiles = async (spinner, config: LexConfigType, quiet: boolean) => {\n  const {copyFiles: copyFilesConfig, outputFullPath, sourceFullPath, sourcePath} = config;\n  if(!copyFilesConfig || copyFilesConfig.length === 0) {\n    return;\n  }\n\n  try {\n    spinner.start('Copying configured files...');\n    let totalCopied = 0;\n\n    const baseDir = sourceFullPath || (sourcePath ? pathResolve(cwd, sourcePath) : cwd);\n\n    for(const pattern of copyFilesConfig) {\n      const resolvedPattern = pathResolve(baseDir, pattern);\n      const matchingFiles = globSync(resolvedPattern, {\n        nodir: true,\n        absolute: true\n      });\n      if(matchingFiles.length === 0) {\n        if(!quiet) {\n          log(`Warning: No files found matching pattern: ${pattern}`, 'warn', quiet);\n        }\n        continue;\n      }\n\n      for(const sourceFile of matchingFiles) {\n        // Calculate relative path from source directory\n        const relativePath = pathRelative(baseDir, sourceFile);\n        // Determine destination path in output directory\n        const destPath = pathResolve(outputFullPath, relativePath);\n        // Create destination directory if it doesn't exist\n        const destDir = pathResolve(destPath, '..');\n        mkdirSync(destDir, {recursive: true});\n\n        await new Promise((resolve, reject) => {\n          copyFile(sourceFile, destPath, (copyError) => {\n            if(copyError) {\n              reject(copyError);\n            } else {\n              resolve(true);\n            }\n          });\n        });\n        totalCopied++;\n      }\n    }\n    if(totalCopied > 0) {\n      spinner.succeed(`Successfully copied ${totalCopied} configured files!`);\n    } else {\n      spinner.succeed('No configured files to copy');\n    }\n  } catch(error) {\n    spinner.fail('Failed to copy configured files');\n    log(`Error copying configured files: ${error.message}`, 'error', quiet);\n    throw error;\n  }\n};\n\nexport const copyFileSync = (source: string, target: string) => {\n  let targetFile: string = target;\n\n  if(existsSync(target)) {\n    if(lstatSync(target).isDirectory()) {\n      targetFile = pathJoin(target, pathBasename(source));\n    }\n  }\n\n  writeFileSync(targetFile, readFileSync(source));\n};\n\nexport const copyFolderRecursiveSync = (source: string, target: string): void => {\n  let files: string[] = [];\n\n  const targetFolder: string = pathJoin(target, pathBasename(source));\n\n  if(!existsSync(targetFolder)) {\n    mkdirSync(targetFolder);\n  }\n\n  if(lstatSync(source).isDirectory()) {\n    files = readdirSync(source);\n    files.forEach((file: string) => {\n      const curSource: string = pathJoin(source, file);\n\n      if(lstatSync(curSource).isDirectory()) {\n        copyFolderRecursiveSync(curSource, targetFolder);\n      } else {\n        copyFileSync(curSource, targetFolder);\n      }\n    });\n  }\n};\n\nexport const getPackageJson = (packagePath?: string) => {\n  const formatPath: string = packagePath || `${process.cwd()}/package.json`;\n\n  const packageData: string = readFileSync(formatPath).toString();\n  return JSON.parse(packageData);\n};\n\nexport const getFilesByExt = (ext: string, config: LexConfigType): string[] => {\n  const {sourceFullPath} = config;\n  return globSync(`${sourceFullPath}/**/**${ext}`);\n};\n\nexport const removeConflictModules = (moduleList: object) => {\n  const updatedList: object = {...moduleList};\n\n  Object.keys(updatedList).forEach((moduleName: string) => {\n    const regex: RegExp = new RegExp('^(?!@types/).*?(jest|webpack).*$', 'gi');\n    if(regex.test(moduleName)) {\n      delete updatedList[moduleName];\n    }\n  });\n\n  return updatedList;\n};\n\nexport const removeFiles = (fileName: string, isRelative: boolean = false) => new Promise((resolve, reject) => {\n  const filePath: string = isRelative ? pathResolve(cwd, fileName) : fileName;\n  try {\n    rimrafSync(filePath);\n    return resolve(null);\n  } catch(error) {\n    return reject(error);\n  }\n});\n\nexport const removeModules = () => new Promise(async (resolve, reject) => {\n  try {\n    // Remove node_modules\n    await removeFiles('./node_modules', true);\n\n    // Remove yarn lock\n    await removeFiles('./yarn.lock', true);\n\n    // Remove npm lock\n    await removeFiles('./package-lock.json', true);\n\n    resolve(null);\n  } catch(error) {\n    reject(error);\n  }\n});\n\nexport const setPackageJson = (json, packagePath?: string) => {\n  if(!json) {\n    return;\n  }\n\n  const formatPath: string = packagePath || `${process.cwd()}/package.json`;\n\n  writeFileSync(formatPath, JSON.stringify(json, null, 2));\n};\n\nexport interface LinkedModuleType {\n  readonly name: string;\n  readonly path: string;\n}\n\nexport const linkedModules = (startPath?: string): LinkedModuleType[] => {\n  const workingPath: string = startPath || process.cwd();\n  let modulePath: string;\n  let prefix: string;\n\n  if(workingPath.includes('@')) {\n    prefix = `@${workingPath.split('@').pop()}`;\n    modulePath = workingPath;\n  } else {\n    modulePath = pathJoin(workingPath, 'node_modules');\n  }\n\n  const foundPaths: string[] = globSync(`${modulePath}/*`);\n  return foundPaths.reduce((list: LinkedModuleType[], foundPath: string) => {\n    try {\n      const stats = lstatSync(foundPath);\n\n      if(stats.isDirectory()) {\n        const deepList: LinkedModuleType[] = linkedModules(foundPath);\n        list.push(...deepList);\n      } else if(stats.isSymbolicLink()) {\n        const moduleNames: string[] = ([prefix, pathBasename(foundPath)]).filter((item: string) => !isEmpty(item));\n        list.push({name: `${moduleNames.join('/')}`, path: foundPath});\n      }\n\n      return list;\n    } catch(fsError) {\n      // Skip files that don't exist or can't be accessed\n      return list;\n    }\n  }, []);\n};\n\nexport const checkLinkedModules = () => {\n  const linked = linkedModules();\n\n  if(linked.length) {\n    const msgModule: string = linked.length > 1 ? 'Modules' : 'Module';\n    const linkedMsg: string = linked.reduce(\n      (msg: string, linkedModule: LinkedModuleType) =>\n        `${msg}\\n * ${linkedModule.name}`,\n      `Linked ${msgModule}:`\n    );\n    log(boxen(linkedMsg, {dimBorder: true, padding: 1}), 'warn');\n  }\n};\n\nexport const updateTemplateName = (filePath: string, replace: string, replaceCaps: string) => {\n  let data: string = readFileSync(filePath, 'utf8');\n  data = data.replace(/sample/g, replace);\n  data = data.replace(/Sample/g, replaceCaps);\n  writeFileSync(filePath, data, 'utf8');\n};"],
  "mappings": "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",
  "names": []
}
