git-coco 0.4.1 → 0.6.0

package/dist/index.esm.mjs

@@ -17,10 +17,12 @@ import * as path from 'path';
 import path__default from 'path';
 import { minimatch } from 'minimatch';
 import * as fs from 'fs';
+import fs__default from 'fs';
+import { confirm, editor, select, password, input } from '@inquirer/prompts';
 import * as os from 'os';
+import os__default from 'os';
 import * as ini from 'ini';
 import { simpleGit } from 'simple-git';
-import { editor, select } from '@inquirer/prompts';
 
 /**
  * Extract the path from a file path string.
@@ -583,6 +585,82 @@ function removeUndefined(obj) {
     return Object.fromEntries(Object.entries(obj).filter(([, value]) => value !== undefined));
 }
 
+/**
+ * Default Config
+ *
+ * @type {Config}
+ */
+const DEFAULT_CONFIG = {
+    model: 'openai/gpt-4',
+    verbose: false,
+    tokenLimit: 1024,
+    summarizePrompt: SUMMARIZE_PROMPT.template,
+    temperature: 0.4,
+    mode: 'stdout',
+    ignoredFiles: ['package-lock.json'],
+    ignoredExtensions: ['.map', '.lock'],
+    defaultBranch: 'main',
+};
+/**
+ * Config keys
+ *
+ * @type {string[]}
+ */
+const CONFIG_KEYS = Object.keys({
+    ...DEFAULT_CONFIG,
+    huggingFaceHubApiKey: '',
+    openAIApiKey: '',
+    prompt: '',
+});
+
+async function updateFileSection(filePath, startComment, endComment, getNewContent, confirmUpdate = true) {
+    const lines = fs__default.existsSync(filePath) ? fs__default.readFileSync(filePath, 'utf-8').split(/\r?\n/) : [];
+    const newLines = [];
+    let foundSection = false;
+    for (let i = 0; i < lines.length; i++) {
+        if (lines[i].trim() === startComment) {
+            foundSection = true;
+            if (confirmUpdate) {
+                const confirmOverwrite = await confirm({
+                    message: `A section already exists in ${filePath}, do you want to override it?`,
+                    default: false,
+                });
+                if (!confirmOverwrite) {
+                    // keep all lines until the end comment
+                    while (i < lines.length && lines[i].trim() !== endComment) {
+                        newLines.push(lines[i]);
+                        i++;
+                    }
+                    newLines.push(endComment);
+                    continue;
+                }
+            }
+            newLines.push(startComment);
+            // Insert the new content
+            const newContent = await getNewContent();
+            newLines.push(newContent);
+            // Skip the existing content of the section
+            while (i < lines.length && lines[i].trim() !== endComment) {
+                i++;
+            }
+            newLines.push(endComment);
+            continue;
+        }
+        if (!foundSection || lines[i].trim() !== endComment) {
+            newLines.push(lines[i]);
+        }
+    }
+    // If section wasn't found, append it at the end
+    if (!foundSection) {
+        newLines.push('\n' + startComment);
+        const newContent = await getNewContent();
+        newLines.push(newContent);
+        newLines.push(endComment);
+    }
+    // Write the updated contents back to the file
+    fs__default.writeFileSync(filePath, newLines.join('\n'));
+}
+
 /**
  * Load environment variables
  *
@@ -590,26 +668,65 @@ function removeUndefined(obj) {
  * @returns {Config} Updated config
  **/
 function loadEnvConfig(config) {
-    const envConfig = {
-        model: process.env.COCO_MODEL || undefined,
-        openAIApiKey: process.env.OPENAI_API_KEY || undefined,
-        huggingFaceHubApiKey: process.env.HUGGINGFACE_HUB_API_KEY || undefined,
-        tokenLimit: process.env.COCO_TOKEN_LIMIT
-            ? parseInt(process.env.COCO_TOKEN_LIMIT)
-            : undefined,
-        prompt: process.env.COCO_PROMPT,
-        mode: process.env.COCO_MODE,
-        summarizePrompt: process.env.COCO_SUMMARIZE_PROMPT,
-        ignoredFiles: process.env.COCO_IGNORED_FILES
-            ? process.env.COCO_IGNORED_FILES.split(',')
-            : undefined,
-        ignoredExtensions: process.env.COCO_IGNORED_EXTENSIONS
-            ? process.env.COCO_IGNORED_EXTENSIONS.split(',')
-            : undefined,
-    };
-    config = { ...config, ...removeUndefined(envConfig) };
-    return config;
+    const envConfig = {};
+    CONFIG_KEYS.forEach((key) => {
+        const envVarName = toEnvVarName(key);
+        const envValue = parseEnvValue(key, process.env[envVarName]);
+        if (envValue === undefined)
+            return;
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore
+        envConfig[key] = envValue;
+    });
+    return { ...config, ...removeUndefined(envConfig) };
+}
+function parseEnvValue(key, value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    else if (key === 'tokenLimit' && typeof value === 'string') {
+        return parseInt(value);
+    }
+    else if ((key === 'ignoredFiles' || key === 'ignoredExtensions') &&
+        typeof value === 'string' &&
+        value.includes(',')) {
+        return value.split(',');
+    }
+    return value;
+}
+function toEnvVarName(key) {
+    switch (key) {
+        case 'openAIApiKey':
+            return 'OPENAI_API_KEY';
+        case 'huggingFaceHubApiKey':
+            return 'HUGGINGFACE_HUB_API_KEY';
+        default:
+            return 'COCO_' + key.replace(/([A-Z])/g, '_$1').toUpperCase();
+    }
+}
+function formatEnvValue(value) {
+    if (typeof value === 'number') {
+        return `${value}`;
+    }
+    else if (Array.isArray(value)) {
+        return `${value.join(',')}`;
+    }
+    else if (typeof value === 'string') {
+        // Escape newlines and tabs in strings
+        return `${value.replace(/\n/g, '\\n').replace(/\t/g, '\\t')}`;
+    }
+    return `${value}`;
 }
+const appendToEnvFile = async (filePath, config) => {
+    const startComment = '# -- Start coco config --';
+    const endComment = '# -- End coco config --';
+    const getNewContent = async () => {
+        return Object.entries(config)
+            .map(([key, value]) => `${toEnvVarName(key)}=${formatEnvValue(value)}`)
+            .join('\n');
+    };
+    await updateFileSection(filePath, startComment, endComment, getNewContent);
+};
 
 /**
  * Load git profile config (from ~/.gitconfig)
@@ -634,10 +751,43 @@ function loadGitConfig(config) {
             summarizePrompt: gitConfigParsed.coco?.summarizePrompt || config.summarizePrompt,
             ignoredFiles: gitConfigParsed.coco?.ignoredFiles || config.ignoredFiles,
             ignoredExtensions: gitConfigParsed.coco?.ignoredExtensions || config.ignoredExtensions,
+            defaultBranch: gitConfigParsed.coco?.defaultBranch || config.defaultBranch,
         };
     }
     return config;
 }
+/**
+ * Appends the provided configuration to a git config file.
+ *
+ * @param filePath - The path to the .gitconfig
+ * @param config - The configuration object to append.
+ */
+const appendToGitConfig = async (filePath, config) => {
+    if (!fs.existsSync(filePath)) {
+        throw new Error(`File ${filePath} does not exist.`);
+    }
+    const startComment = '# -- Start coco config --';
+    const endComment = '# -- End coco config --';
+    const header = '[coco]';
+    // Function to generate new content for the coco section
+    const getNewContent = async () => {
+        const contentLines = [header];
+        for (const key in config) {
+            // check if string has new lines, if so, wrap in quotes
+            if (typeof config[key] === 'string') {
+                const value = config[key];
+                if (value.includes('\n')) {
+                    contentLines.push(`\t${key} = ${JSON.stringify(value)}`);
+                    continue;
+                }
+            }
+            contentLines.push(`\t${key} = ${config[key]}`);
+        }
+        return contentLines.join('\n');
+    };
+    // Use the updateFileSection utility
+    await updateFileSection(filePath, startComment, endComment, getNewContent);
+};
 
 /**
  * Load .gitignore in project root
@@ -679,12 +829,20 @@ function loadIgnore(config) {
  * @returns {Config} Updated config
  **/
 function loadProjectConfig(config) {
+    // TODO: Add validation based of JSON schema?
+    // @see https://github.com/acornejo/jjv
     if (fs.existsSync('.coco.config.json')) {
         const projectConfig = JSON.parse(fs.readFileSync('.coco.config.json', 'utf-8'));
         config = { ...config, ...projectConfig };
     }
     return config;
 }
+const appendToProjectConfig = (filePath, config) => {
+    fs.writeFileSync(filePath, JSON.stringify({
+        $schema: 'https://git-co.co/schema.json',
+        ...config,
+    }, null, 2));
+};
 
 /**
  * Load XDG config
@@ -702,21 +860,6 @@ function loadXDGConfig(config) {
     return config;
 }
 
-/**
- * Default Config
- *
- * @type {Config}
- */
-const DEFAULT_CONFIG = {
-    model: 'openai/gpt-4',
-    verbose: false,
-    tokenLimit: 1024,
-    summarizePrompt: SUMMARIZE_PROMPT.template,
-    temperature: 0.4,
-    mode: 'stdout',
-    ignoredFiles: ['package-lock.json'],
-    ignoredExtensions: ['.map', '.lock'],
-};
 /**
  * Load application config
  *
@@ -836,8 +979,8 @@ const isInteractive = (argv) => {
 };
 const SEPERATOR = chalk.blue('----------------');
 
-function logResult(result) {
-    console.log(`\n${chalk.bgBlue(chalk.bold('Proposed Commit:'))}\n${SEPERATOR}\n${result}\n${SEPERATOR}\n`);
+function logResult(label, result) {
+    console.log(`\n${chalk.bgBlue(chalk.bold(`Proposed ${label}:`))}\n${SEPERATOR}\n${result}\n${SEPERATOR}\n`);
 }
 
 async function editResult(result, options) {
@@ -938,7 +1081,7 @@ async function generateAndReviewLoop({ label, factory, parser, noResult, agent,
         })
             .stopTimer();
         if (options?.interactive) {
-            logResult(result);
+            logResult(label, result);
             const reviewAnswer = await getUserReviewDecision();
             if (reviewAnswer === 'cancel') {
                 process.exit(0);
@@ -1016,9 +1159,21 @@ const handleResult = async (result, { mode, git }) => {
     process.exit(0);
 };
 
-const tokenizer = getTokenizer();
-const git$1 = simpleGit();
-async function handler$1(argv) {
+const getRepo = () => {
+    let git;
+    try {
+        git = simpleGit();
+    }
+    catch (e) {
+        console.log('Error initializing git repo', e);
+        process.exit(1);
+    }
+    return git;
+};
+
+async function handler$2(argv) {
+    const tokenizer = getTokenizer();
+    const git = getRepo();
     const options = loadConfig(argv);
     const logger = new Logger(options);
     const key = getApiKeyForModel(options.model, options);
@@ -1032,14 +1187,14 @@ async function handler$1(argv) {
     });
     const INTERACTIVE = isInteractive(options);
     async function factory() {
-        const changes = await getChanges({ git: git$1 });
+        const changes = await getChanges({ git });
         return changes.staged;
     }
     async function parser(changes) {
         return await fileChangeParser({
             changes,
             commit: '--staged',
-            options: { tokenizer, git: git$1, model, logger },
+            options: { tokenizer, git, model, logger },
         });
     }
     const commitMsg = await generateAndReviewLoop({
@@ -1058,7 +1213,7 @@ async function handler$1(argv) {
             });
         },
         noResult: async () => {
-            await noResult({ git: git$1, logger });
+            await noResult({ git, logger });
             process.exit(0);
         },
         options: {
@@ -1071,14 +1226,14 @@ async function handler$1(argv) {
     const MODE = (INTERACTIVE && 'interactive') || (options.commit && 'interactive') || options?.mode || 'stdout';
     handleResult(commitMsg, {
         mode: MODE,
-        git: git$1,
+        git,
     });
 }
 
 /**
  * Command line options via yargs
  */
-const options$1 = {
+const options$2 = {
     model: { type: 'string', description: 'LLM/Model-Name' },
     openAIApiKey: {
         type: 'string',
@@ -1124,16 +1279,16 @@ const options$1 = {
         description: 'Ignored extensions',
     },
 };
-const builder$1 = (yargs) => {
-    return yargs.options(options$1);
+const builder$2 = (yargs) => {
+    return yargs.options(options$2);
 };
 
 var commit = {
     command: 'commit',
     desc: 'Generate commit message',
-    builder: builder$1,
-    handler: handler$1,
-    options: options$1,
+    builder: builder$2,
+    handler: handler$2,
+    options: options$2,
 };
 
 const template = `Write informative git changelog, in the imperative, based on a series of individual messages.
@@ -1152,15 +1307,9 @@ const CHANGELOG_PROMPT = new PromptTemplate({
 
 async function getCommitLogRange(from, to, { noMerges, git }) {
     try {
-        const output = await git.raw([
-            'log',
-            `${from}..${to}`,
-            '--pretty=format:%s',
-            // Include '--no-merges' here if you want to exclude merge commits.
-            noMerges ? '--no-merges' : null,
-        ].filter(Boolean)); // filter(Boolean) removes any null values from the array
-        const messages = output.split('\n').filter(Boolean);
-        return messages;
+        const logOptions = { from: `${from}^1`, to, '--no-merges': noMerges };
+        const commitLog = await git.log(logOptions);
+        return commitLog.all.map(({ message, date, body, author_name }) => `[${date}] ${message}\n${body}\n - ${author_name}`);
     }
     catch (error) {
         // If there's an error, handle it appropriately
@@ -1169,10 +1318,56 @@ async function getCommitLogRange(from, to, { noMerges, git }) {
     }
 }
 
-const git = simpleGit();
-async function handler(argv) {
+async function getCurrentBranchName({ git }) {
+    return await git.revparse(['--abbrev-ref', 'HEAD']);
+}
+
+async function getCommitLogCurrentBranch({ git, logger, comparisonBranch = 'main', comparisonRemote = 'origin', }) {
+    try {
+        // Get the current branch name
+        const branch = await getCurrentBranchName({ git });
+        // Check if the current branch has any commits
+        const hasCommits = (await git.raw(['rev-list', '--count', branch])) !== '0';
+        if (!hasCommits) {
+            logger?.log('No commits on the current branch.');
+            return [];
+        }
+        // Get the list of commits that are unique to the current branch
+        let uniqueCommits;
+        if (comparisonBranch === branch) {
+            // If the comparison branch is the same as the current branch, we compare against the remote.
+            uniqueCommits = (await git.raw(['rev-list', `${comparisonRemote}/${comparisonBranch}..${branch}`]))
+                .split('\n')
+                .filter(Boolean)
+                .reverse();
+        }
+        else {
+            // Your existing code for different branches
+            uniqueCommits = (await git.raw(['rev-list', `${comparisonBranch}..${branch}`]))
+                .split('\n')
+                .filter(Boolean)
+                .reverse();
+        }
+        logger?.verbose(`Found ${uniqueCommits.length} unique commits on "${branch}"`, { color: 'blue' });
+        const firstCommit = uniqueCommits[0];
+        const lastCommit = uniqueCommits[uniqueCommits.length - 1];
+        if (!firstCommit || !lastCommit) {
+            logger?.log('Unable to determine first and last commit on the current branch', { color: 'yellow' });
+            return [];
+        }
+        // Retrieve commit log with messages
+        return await getCommitLogRange(firstCommit, lastCommit, { git, noMerges: true });
+    }
+    catch (error) {
+        logger?.log('Encountered an error getting commit log from current branch', { color: 'red' });
+    }
+    return [];
+}
+
+async function handler$1(argv) {
     const options = loadConfig(argv);
     const logger = new Logger(options);
+    const git = getRepo();
     const key = getApiKeyForModel(options.model, options);
     if (!key) {
         logger.log(`No API Key found. 🗝️🚪`, { color: 'red' });
@@ -1183,14 +1378,17 @@ async function handler(argv) {
         maxConcurrency: 10,
     });
     const INTERACTIVE = isInteractive(options);
-    const [from, to] = options.range?.split(':');
-    if (!from || !to) {
-        logger.log(`Invalid range provided. Expected format is <from>:<to>`, { color: 'red' });
-        process.exit(1);
-    }
     async function factory() {
-        const messages = await getCommitLogRange(from, to, { git, noMerges: true });
-        return messages;
+        if (options.range) {
+            const [from, to] = options.range?.split(':');
+            if (!from || !to) {
+                logger.log(`Invalid range provided. Expected format is <from>:<to>`, { color: 'red' });
+                process.exit(1);
+            }
+            return await getCommitLogRange(from, to, { git, noMerges: true });
+        }
+        logger.verbose(`No range provided. Defaulting to current branch`, { color: 'yellow' });
+        return await getCommitLogCurrentBranch({ git, logger });
     }
     async function parser(messages) {
         const result = messages.join('\n');
@@ -1213,7 +1411,11 @@ async function handler(argv) {
             });
         },
         noResult: async () => {
-            await noResult({ git, logger });
+            if (options.range) {
+                logger.log(`No commits found in the provided range.`, { color: 'red' });
+                process.exit(0);
+            }
+            logger.log(`No commits found in the current branch.`, { color: 'red' });
             process.exit(0);
         },
         options: {
@@ -1233,12 +1435,11 @@ async function handler(argv) {
 /**
  * Command line options via yargs
  */
-const options = {
+const options$1 = {
     range: {
         type: 'string',
         alias: 'r',
         description: 'Commit range e.g `HEAD~2:HEAD`',
-        demandOption: true,
     },
     model: { type: 'string', description: 'LLM/Model-Name' },
     openAIApiKey: {
@@ -1280,13 +1481,240 @@ const options = {
         description: 'Ignored extensions',
     },
 };
-const builder = (yargs) => {
-    return yargs.options(options);
+const builder$1 = (yargs) => {
+    return yargs.options(options$1);
 };
 
 var changelog = {
     command: 'changelog',
     desc: 'Generate a changelog from a commit range',
+    builder: builder$1,
+    handler: handler$1,
+    options: options$1,
+};
+
+const handleProjectLevelConfig = async () => {
+    const projectConfiguration = await select({
+        message: 'select type project level configuration:',
+        choices: [
+            {
+                name: '.coco.config.json',
+                value: '.coco.config.json',
+            },
+            {
+                name: '.env',
+                value: '.env',
+            },
+        ],
+    });
+    let configFile = '.coco.config.json';
+    if (projectConfiguration === '.env') {
+        configFile = '.env';
+        if (!fs__default.existsSync('.env')) {
+            fs__default.writeFileSync('.env', '');
+        }
+    }
+    return configFile;
+};
+const handleSystemLevelConfig = () => {
+    return path__default.join(os__default.homedir(), '.gitconfig');
+};
+async function handler(argv) {
+    const options = loadConfig(argv);
+    const logger = new Logger(options);
+    const level = await select({
+        message: 'configure coco at the system or project level:',
+        choices: [
+            {
+                name: 'system',
+                value: 'system',
+                description: 'add coco config to your global git config',
+            },
+            {
+                name: 'project',
+                value: 'project',
+                description: 'add coco config to existing git project',
+            },
+        ],
+    });
+    let configFilePath = '';
+    switch (level) {
+        case 'system':
+            configFilePath = await handleSystemLevelConfig();
+            break;
+        case 'project':
+            configFilePath = await handleProjectLevelConfig();
+            break;
+    }
+    // interactive v.s stdout mode
+    const mode = (await select({
+        message: 'select mode:',
+        choices: [
+            {
+                name: 'interactive',
+                value: 'interactive',
+                description: 'interactive prompt for creating, reviewing, and committing',
+            },
+            {
+                name: 'stdout',
+                value: 'stdout',
+                description: 'print results to stdout',
+            },
+        ],
+    }));
+    const apiKey = await password({
+        message: `enter your OpenAI API key:`,
+        validate(input) {
+            return input.length > 0 ? true : 'API key cannot be empty';
+        },
+    });
+    const tokenLimit = await input({
+        message: 'maximum number of tokens for the commit message:',
+        default: '500',
+    });
+    const defaultBranch = await input({
+        message: 'default branch for the repository:',
+        default: 'main',
+    });
+    const advOptions = await confirm({
+        message: 'would you like to configure advanced options?',
+        default: false,
+    });
+    const config = {
+        openAIApiKey: '•••••••••••••••',
+        tokenLimit: parseInt(tokenLimit),
+        defaultBranch,
+        mode,
+    };
+    /**
+     * Prompt for advanced options
+     *
+     * e.g.
+     * - temperature
+     * - verbose logging
+     * - ignored files
+     * - ignored extensions
+     * - commit message prompt
+     */
+    if (advOptions) {
+        const temperature = await input({
+            message: 'temperature for the model:',
+            default: '0.4',
+        });
+        config.temperature = parseFloat(temperature);
+        config.verbose = await confirm({
+            message: 'enable verbose logging:',
+            default: false,
+        });
+        const promptForIgnores = await confirm({
+            message: 'would you like to configure ignored files and extensions?',
+            default: false,
+        });
+        if (promptForIgnores) {
+            const ignoredFiles = await input({
+                message: 'paths of files to be excluded when generating commit messages (comma-separated):',
+                default: 'package-lock.json',
+            });
+            const ignoredExtensions = await input({
+                message: 'file extensions to be excluded when generating commit messages (comma-separated):',
+                default: '.map, .lock',
+            });
+            config.ignoredFiles =
+                (ignoredFiles && ignoredFiles.split(',').map((file) => file.trim())) || [];
+            config.ignoredExtensions =
+                (ignoredExtensions && ignoredExtensions.split(',').map((ext) => ext.trim())) || [];
+        }
+        const promptForCommitPrompt = await confirm({
+            message: 'would you like to configure the commit message prompt?',
+            default: false,
+        });
+        if (promptForCommitPrompt) {
+            const commitPrompt = await editor({
+                message: 'modify default commit message prompt:',
+                default: COMMIT_PROMPT.template,
+            });
+            config.prompt = commitPrompt;
+        }
+    }
+    logResult('Config', JSON.stringify(config, null, 2));
+    // add to config after logging, so that the API key is not logged
+    config.openAIApiKey = apiKey;
+    const isApproved = await confirm({
+        message: 'look good? (hiding API key for security)',
+    });
+    if (isApproved) {
+        if (configFilePath.endsWith('.gitconfig')) {
+            await appendToGitConfig(configFilePath, config);
+        }
+        else if (configFilePath === '.env') {
+            await appendToEnvFile(configFilePath, config);
+        }
+        else if (configFilePath === '.coco.config.json') {
+            await appendToProjectConfig(configFilePath, config);
+        }
+        logger.log(`init successful! 🦾🤖🎉`, { color: 'green' });
+    }
+    else {
+        logger.log('init cancelled.', { color: 'yellow' });
+    }
+}
+
+/**
+ * Command line options via yargs
+ */
+const options = {
+    model: { type: 'string', description: 'LLM/Model-Name' },
+    openAIApiKey: {
+        type: 'string',
+        description: 'OpenAI API Key',
+        conflicts: 'huggingFaceHubApiKey',
+    },
+    huggingFaceHubApiKey: {
+        type: 'string',
+        description: 'HuggingFace Hub API Key',
+        conflicts: 'openAIApiKey',
+    },
+    tokenLimit: { type: 'number', description: 'Token limit' },
+    prompt: {
+        type: 'string',
+        alias: 'p',
+        description: 'Commit message prompt',
+    },
+    i: {
+        type: 'boolean',
+        alias: 'interactive',
+        description: 'Toggle interactive mode',
+    },
+    s: {
+        type: 'boolean',
+        description: 'Automatically commit staged changes with generated commit message',
+        default: false,
+    },
+    e: {
+        type: 'boolean',
+        alias: 'edit',
+        description: 'Open commit message in editor before proceeding',
+    },
+    summarizePrompt: {
+        type: 'string',
+        description: 'Large file summary prompt',
+    },
+    ignoredFiles: {
+        type: 'array',
+        description: 'Ignored files',
+    },
+    ignoredExtensions: {
+        type: 'array',
+        description: 'Ignored extensions',
+    },
+};
+const builder = (yargs) => {
+    return yargs.options(options);
+};
+
+var init = {
+    command: 'init',
+    desc: 'Setup coco for a new project or system',
     builder,
     handler,
     options,
@@ -1305,6 +1733,11 @@ commit.builder, commit.handler)
 // eslint-disable-next-line @typescript-eslint/ban-ts-comment
 // @ts-ignore
 changelog.builder, changelog.handler)
+    .command(init.command, init.desc, 
+// TODO: fix type on builder
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore
+init.builder, init.handler)
     .demandCommand()
     .help().argv;
 //# sourceMappingURL=index.esm.mjs.map