git-coco 0.3.1 → 0.3.3

package/dist/commands/commit.d.ts

@@ -13,4 +13,4 @@ export interface CommitOptions extends BaseCommandOptions {
 export declare const command: string[];
 export declare const description = "Generate a commit message based on the diff summary";
 export declare const builder: CommandBuilder<CommitOptions>;
-export declare function handler(argv: Argv<CommitOptions>["argv"]): Promise<void>;
+export declare function handler(argv: Argv<CommitOptions>['argv']): Promise<void>;

package/dist/index.d.ts

@@ -1,3 +1,4 @@
 #!/usr/bin/env node
 import * as commit from './commands/commit';
-export { commit };
+import { loadConfig } from './lib/config/loadConfig';
+export { commit, loadConfig };

package/dist/index.esm.mjs

@@ -1,6 +1,5 @@
 #!/usr/bin/env node
 import yargs from 'yargs';
-import { select, editor } from '@inquirer/prompts';
 import { simpleGit } from 'simple-git';
 import * as fs from 'fs';
 import * as os from 'os';
@@ -8,6 +7,8 @@ import * as path from 'path';
 import path__default from 'path';
 import * as ini from 'ini';
 import { PromptTemplate } from 'langchain/prompts';
+import chalk from 'chalk';
+import { select, editor } from '@inquirer/prompts';
 import pQueue from 'p-queue';
 import { Document } from 'langchain/document';
 import { HuggingFaceInference } from 'langchain/llms/hf';
@@ -15,12 +16,11 @@ import { loadSummarizationChain, LLMChain } from 'langchain/chains';
 import { OpenAI } from 'langchain/llms/openai';
 import { RecursiveCharacterTextSplitter } from 'langchain/text_splitter';
 import { createTwoFilesPatch } from 'diff';
-import chalk from 'chalk';
+import { minimatch } from 'minimatch';
 import GPT3NodeTokenizer from 'gpt3-tokenizer';
 import ora from 'ora';
 import now from 'performance-now';
 import prettyMilliseconds from 'pretty-ms';
-import { minimatch } from 'minimatch';
 
 /**
  * Returns a new object with all undefined keys removed
@@ -151,11 +151,13 @@ function loadXDGConfig(config) {
     return config;
 }
 
-const template$1 = `Write informative git commit message based on the diffs & file changes provided in the "Diff Summary" section.  
+const template$1 = `Write informative git commit message, in the imperative, based on the diffs & file changes provided in the "Diff Summary" section.  
 Commit Messages must have a short description that is less than 50 characters followed by a newline character and then a more verbose detailed description.
+
+- Typically a hyphen or asterisk is used for the bullet
 - Write concisely using an informal tone
-- List significant changes
-- DO NOT use phrases like "this commit", "this change", etc.
+- DO NOT use phrases like "this commit", "this change", "this function", etc. Instead refer to the function, variable, or class by name
+- DO NOT use phrases like "this commit", "this change", "this function", etc. Instead refer to the function, variable, or class by name
 - DO NOT use specific names or files from the code
 - Wrap variable, class, function, components, and dependency names in back ticks e.g. \`variable\`
 
@@ -186,7 +188,7 @@ const SUMMARIZE_PROMPT = new PromptTemplate({
  * @type {Config}
  */
 const DEFAULT_CONFIG = {
-    model: 'openai/gpt-3.5-turbo',
+    model: 'openai/gpt-4',
     verbose: false,
     tokenLimit: 1024,
     prompt: COMMIT_PROMPT.template,
@@ -371,7 +373,7 @@ const createDiffTree = (changes) => {
     const root = new DiffTreeNode();
     for (const change of changes) {
         let currentParent = root;
-        const parts = change.filepath.split('/');
+        const parts = change.filePath.split('/');
         parts.pop();
         for (const part of parts) {
             let childNode = currentParent.getChild(part);
@@ -383,8 +385,8 @@ const createDiffTree = (changes) => {
         }
         // Create a NodeFile object and add it to the parent
         currentParent.addFile({
-            filepath: change.filepath,
-            oldFilepath: change.oldFilepath,
+            filePath: change.filePath,
+            oldFilePath: change.oldFilePath,
             summary: change.summary,
             status: change.status,
         });
@@ -402,11 +404,11 @@ async function collectDiffs(node, getFileDiff, tokenizer, logger) {
         // TODO: Swap out the GPT3Tokenizer for LangChain tokenizer
         const tokenizedDiff = tokenizer.encode(diff).text;
         const tokenCount = tokenizedDiff.length;
-        logger.verbose(`Collected diff for ${nodeFile.filepath} (${tokenCount} tokens)`, {
+        logger.verbose(`Collected diff for ${nodeFile.filePath} (${tokenCount} tokens)`, {
             color: 'magenta',
         });
         return {
-            file: nodeFile.filepath,
+            file: nodeFile.filePath,
             summary: nodeFile.summary,
             diff,
             tokenCount,
@@ -431,7 +433,7 @@ async function collectDiffs(node, getFileDiff, tokenizer, logger) {
  * @param configuration
  * @returns LLM Model
  */
-function getModel(name, key, fields, configuration) {
+function getModel(name, key, fields) {
     const [llm, model] = name.split(/\/(.*)/s);
     if (!model) {
         throw new Error(`Invalid model: ${name}`);
@@ -450,7 +452,7 @@ function getModel(name, key, fields, configuration) {
                 openAIApiKey: key,
                 modelName: model,
                 ...fields,
-            }, configuration);
+            });
     }
 }
 /**
@@ -517,18 +519,18 @@ function validatePromptTemplate(text, inputVariables) {
 }
 
 const parseDefaultFileDiff = async (nodeFile, git) => {
-    return await git.diff(['--staged', nodeFile.filepath]);
+    return await git.diff(['--staged', nodeFile.filePath]);
 };
 const parseRenamedFileDiff = async (nodeFile, git, logger) => {
     let result = '';
-    const oldFilepath = nodeFile?.oldFilepath || nodeFile.filepath;
+    const oldFilePath = nodeFile?.oldFilePath || nodeFile.filePath;
     try {
         const [headContent, indexContent] = await Promise.all([
-            git.show([`HEAD:${oldFilepath}`]),
-            git.show([`:${nodeFile.filepath}`]),
+            git.show([`HEAD:${oldFilePath}`]),
+            git.show([`:${nodeFile.filePath}`]),
         ]);
         if (headContent !== indexContent) {
-            result = createTwoFilesPatch(oldFilepath, nodeFile.filepath, headContent, indexContent, '', '', {
+            result = createTwoFilesPatch(oldFilePath, nodeFile.filePath, headContent, indexContent, '', '', {
                 context: 3,
             });
             // remove the first 4 lines of the patch (they contain the old and new file names)
@@ -539,7 +541,7 @@ const parseRenamedFileDiff = async (nodeFile, git, logger) => {
         }
     }
     catch (err) {
-        logger.verbose(`Error comparing file contents for ${nodeFile.filepath}`, { color: 'red' });
+        logger.verbose(`Error comparing file contents for ${nodeFile.filePath}`, { color: 'red' });
         result = 'Error comparing file contents.';
     }
     return result;
@@ -548,7 +550,7 @@ const getDiff = async (nodeFile, { git, logger, }) => {
     if (nodeFile.status === 'deleted') {
         return 'This file has been deleted.';
     }
-    if (nodeFile.status === 'renamed' && nodeFile.oldFilepath) {
+    if (nodeFile.status === 'renamed' && nodeFile.oldFilePath) {
         const renamedDiff = await parseRenamedFileDiff(nodeFile, git, logger);
         return renamedDiff;
     }
@@ -585,87 +587,6 @@ const fileChangeParser = async (changes, { tokenizer, git, model, logger }) => {
     return summary;
 };
 
-const SEPERATOR = chalk.blue('----------------');
-const logCommit = (commit) => {
-    console.log(`\n${chalk.bgBlue(chalk.bold('Proposed Commit:'))}\n${SEPERATOR}\n${commit}\n${SEPERATOR}\n`);
-};
-const logSuccess = () => {
-    console.log(chalk.green(chalk.bold('\nAll set! 🦾🤖')));
-};
-
-/**
- * Wrapper around GPT3NodeTokenizer to handle default export.
- *
- * @see https://github.com/botisan-ai/gpt3-tokenizer/issues/18
- *
- * @returns {GPT3NodeTokenizer} The GPT3NodeTokenizer instance.
- */
-const getTokenizer = () => {
-    let tokenizer;
-    // eslint-disable-next-line
-    // @ts-ignore
-    if (GPT3NodeTokenizer.default) {
-        // eslint-disable-next-line
-        // @ts-ignore
-        tokenizer = new GPT3NodeTokenizer.default({ type: 'gpt3' });
-    }
-    else {
-        tokenizer = new GPT3NodeTokenizer({ type: 'gpt3' });
-    }
-    return tokenizer;
-};
-
-class Logger {
-    constructor(config) {
-        this.config = config;
-        this.spinner = null;
-    }
-    log(message, options = { color: 'blue' }) {
-        let outputMessage = message;
-        if (options.color) {
-            outputMessage = chalk[options.color](outputMessage);
-        }
-        console.log(outputMessage);
-        return this;
-    }
-    verbose(message, options = {}) {
-        if (!this.config?.verbose) {
-            return this;
-        }
-        this.log(message, options);
-        return this;
-    }
-    startTimer() {
-        this.timerStart = now();
-        return this;
-    }
-    stopTimer(message, options = { color: 'yellow' }) {
-        if (!this.config?.verbose || !this.timerStart) {
-            return this;
-        }
-        const elapsedTime = prettyMilliseconds(now() - this.timerStart);
-        let outputMessage = message
-            ? `${message} (⏲ ${elapsedTime})`
-            : `⏲ ${elapsedTime}`;
-        if (options.color) {
-            outputMessage = chalk[options.color](outputMessage);
-        }
-        console.log(outputMessage);
-        return this;
-    }
-    startSpinner(message, options = { color: 'green' }) {
-        const spinnerMessage = options.color ? chalk[options.color](message) : message;
-        this.spinner = ora(spinnerMessage).start();
-        return this;
-    }
-    stopSpinner(message = '', options = { mode: 'succeed', color: 'green' }) {
-        const spinnerMessage = options?.color ? chalk[options.color](message) : message;
-        this.spinner?.[options.mode || 'succeed'](spinnerMessage);
-        this.spinner = null;
-        return this;
-    }
-}
-
 const llm = async ({ llm, prompt, variables }) => {
     if (!llm || !prompt || !variables) {
         throw new Error('The input parameters "llm", "prompt", and "variables" are all required.');
@@ -690,52 +611,72 @@ const llm = async ({ llm, prompt, variables }) => {
 };
 
 const getStatus = (file, location = 'index') => {
-    const statusCode = file[location] ? file[location] : file.index;
-    let status;
-    switch (statusCode) {
-        case 'A':
-            status = 'added';
-            break;
-        case 'D':
-            status = 'deleted';
-            break;
-        case 'M':
-            status = 'modified';
-            break;
-        case 'R':
-            status = 'renamed';
-            break;
-        case '?':
-            status = 'untracked';
-            break;
-        default:
-            status = 'unknown';
-            break;
+    if ('index' in file && 'working_dir' in file) {
+        const statusCode = file[location];
+        switch (statusCode) {
+            case 'A':
+                return 'added';
+            case 'D':
+                return 'deleted';
+            case 'M':
+                return 'modified';
+            case 'R':
+                return 'renamed';
+            case '?':
+                return 'untracked';
+            default:
+                return 'unknown';
+        }
+    }
+    else if ('changes' in file && 'binary' in file) {
+        if (file.changes === 0)
+            return 'untracked';
+        if (file.file.includes('=>'))
+            return 'renamed';
+        if (file.deletions === 0 && file.insertions > 0)
+            return 'added';
+        if (file.insertions === 0 && file.deletions > 0)
+            return 'deleted';
+        if ((file.insertions > 0 && file.deletions > 0) || file.changes > 0)
+            return 'modified';
+        return 'unknown';
+    }
+    else {
+        throw new Error("Invalid file type");
     }
-    return status;
 };
 
 const getSummaryText = (file, change) => {
     const status = change.status || getStatus(file);
-    if (change.oldFilepath) {
-        return `${status}: ${change.oldFilepath} -> ${file.path}`;
+    let filePath;
+    if ('path' in file) {
+        filePath = file.path;
+    }
+    else if ('file' in file) {
+        filePath = change?.filePath || file.file;
+    }
+    else {
+        throw new Error("Invalid file type");
+    }
+    if (change.oldFilePath) {
+        return `${status}: ${change.oldFilePath} -> ${filePath}`;
     }
-    return `${status}: ${file.path}`;
+    return `${status}: ${filePath}`;
 };
 
 const config = loadConfig();
 const DEFAULT_IGNORED_FILES = config?.ignoredFiles?.length ? config.ignoredFiles : [];
 const DEFAULT_IGNORED_EXTENSIONS = config?.ignoredExtensions?.length ? config.ignoredExtensions : [];
-async function getChanges(git, options = {}) {
-    const { ignoredFiles = DEFAULT_IGNORED_FILES, ignoredExtensions = DEFAULT_IGNORED_EXTENSIONS } = options;
+async function getChanges({ git, options }) {
+    const { ignoredFiles = DEFAULT_IGNORED_FILES, ignoredExtensions = DEFAULT_IGNORED_EXTENSIONS } = options || {};
     const staged = [];
     const unstaged = [];
     const untracked = [];
     const status = await git.status();
     status.files.forEach((file) => {
         const fileChange = {
-            filepath: file.path,
-            oldFilepath: status.renamed.filter((renamed) => renamed.to === file.path)[0]?.from,
+            filePath: file.path,
+            oldFilePath: status.renamed.filter((renamed) => renamed.to === file.path)[0]?.from,
         };
         // Unstaged files
         if (file.working_dir !== '?' && file.working_dir !== ' ') {
@@ -758,16 +699,19 @@ async function getChanges(git, options = {}) {
     });
     const ignoredExtensionsSet = new Set(ignoredExtensions.map((extension) => extension.toLowerCase()));
     const filteredStaged = staged.filter((file) => {
-        const extension = path__default.extname(file.filepath).toLowerCase();
-        return !ignoredExtensionsSet.has(extension) && !ignoredFiles.some(ignoredPattern => minimatch(file.filepath, ignoredPattern));
+        const extension = path__default.extname(file.filePath).toLowerCase();
+        return (!ignoredExtensionsSet.has(extension) &&
+            !ignoredFiles.some((ignoredPattern) => minimatch(file.filePath, ignoredPattern)));
     });
     const filteredUnstaged = unstaged.filter((file) => {
-        const extension = path__default.extname(file.filepath).toLowerCase();
-        return !ignoredExtensionsSet.has(extension) && !ignoredFiles.some(ignoredPattern => minimatch(file.filepath, ignoredPattern));
+        const extension = path__default.extname(file.filePath).toLowerCase();
+        return (!ignoredExtensionsSet.has(extension) &&
+            !ignoredFiles.some((ignoredPattern) => minimatch(file.filePath, ignoredPattern)));
     });
     const filteredUntracked = untracked.filter((file) => {
-        const extension = path__default.extname(file.filepath).toLowerCase();
-        return !ignoredExtensionsSet.has(extension) && !ignoredFiles.some(ignoredPattern => minimatch(file.filepath, ignoredPattern));
+        const extension = path__default.extname(file.filePath).toLowerCase();
+        return (!ignoredExtensionsSet.has(extension) &&
+            !ignoredFiles.some((ignoredPattern) => minimatch(file.filePath, ignoredPattern)));
     });
     return {
         staged: filteredStaged,
@@ -777,7 +721,7 @@ async function getChanges(git, options = {}) {
 }
 
 const noResult = async ({ git, logger }) => {
-    const { staged, unstaged, untracked } = await getChanges(git);
+    const { staged, unstaged, untracked } = await getChanges({ git });
     const hasStaged = staged && staged.length > 0;
     const hasUnstaged = unstaged && unstaged.length > 0;
     const hasUntracked = untracked && untracked.length > 0;
@@ -809,76 +753,25 @@ async function createCommit(commitMsg, git) {
     return await git.commit(commitMsg);
 }
 
-// const argv = loadArgv()
-const tokenizer = getTokenizer();
-const git = simpleGit();
-const command = ['commit', '$0'];
-const description = 'Generate a commit message based on the diff summary';
-const builder = {
-    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 SEPERATOR = chalk.blue('----------------');
+const isInteractive = (argv) => {
+    return argv?.mode === 'interactive' || argv.interactive;
 };
-async function handler(argv) {
-    const options = loadConfig(argv);
-    const logger = new Logger(options);
-    const key = getModelAPIKey(options.model, options);
-    if (!key) {
-        logger.log(`No API Key found. 🗝️🚪`, { color: 'red' });
-        process.exit(1);
-    }
-    const model = getModel(options.model, key, {
-        temperature: 0.4,
-        maxConcurrency: 10,
-    });
-    const INTERACTIVE = options?.mode === 'interactive' || options.interactive;
-    const { staged: changes } = await getChanges(git);
+const logCommit = (commit) => {
+    console.log(`\n${chalk.bgBlue(chalk.bold('Proposed Commit:'))}\n${SEPERATOR}\n${commit}\n${SEPERATOR}\n`);
+};
+const logSuccess = () => {
+    console.log(chalk.green(chalk.bold('\nAll set! 🦾🤖')));
+};
+const generateCommitMessageAndReviewLoop = async (changes, options) => {
+    const { logger, model, git, tokenizer } = options;
     let summary = '';
     let commitMsg = '';
     let promptTemplate = options?.prompt || '';
     let modifyPrompt = false;
-    while (true) {
+    // determine if we continue generating commit messages
+    let continueLoop = true;
+    while (continueLoop) {
         if (changes.length !== 0 && !summary.length) {
             logger.verbose(`\nChanged Files: \n ${changes.map(({ summary }) => summary).join('\n ')}`, {
                 color: 'blue',
@@ -924,7 +817,7 @@ async function handler(argv) {
             mode: 'succeed',
         })
             .stopTimer();
-        if (INTERACTIVE) {
+        if (options?.interactive) {
             logCommit(commitMsg);
             const reviewAnswer = await select({
                 message: 'Would you like to make any changes to the commit message?',
@@ -996,23 +889,180 @@ async function handler(argv) {
                 },
             });
         }
-        const MODE = (options.interactive && 'interactive') ||
-            (options.commit && 'interactive') ||
-            options?.mode ||
-            'stdout';
-        // Handle resulting commit message
-        switch (MODE) {
-            case 'interactive':
-                await createCommit(commitMsg, git);
-                logSuccess();
-                break;
-            case 'stdout':
-            default:
-                process.stdout.write(commitMsg, 'utf8');
-                break;
+        continueLoop = false;
+    }
+    return commitMsg;
+};
+const handleResult = async (commit, { mode, git }) => {
+    // Handle resulting commit message
+    switch (mode) {
+        case 'interactive':
+            await createCommit(commit, git);
+            logSuccess();
+            break;
+        case 'stdout':
+        default:
+            process.stdout.write(commit, 'utf8');
+            break;
+    }
+    process.exit(0);
+};
+
+/**
+ * Wrapper around GPT3NodeTokenizer to handle default export.
+ *
+ * @see https://github.com/botisan-ai/gpt3-tokenizer/issues/18
+ *
+ * @returns {GPT3NodeTokenizer} The GPT3NodeTokenizer instance.
+ */
+const getTokenizer = () => {
+    let tokenizer;
+    // eslint-disable-next-line
+    // @ts-ignore
+    if (GPT3NodeTokenizer.default) {
+        // eslint-disable-next-line
+        // @ts-ignore
+        tokenizer = new GPT3NodeTokenizer.default({ type: 'gpt3' });
+    }
+    else {
+        tokenizer = new GPT3NodeTokenizer({ type: 'gpt3' });
+    }
+    return tokenizer;
+};
+
+class Logger {
+    constructor(config) {
+        this.config = config;
+        this.spinner = null;
+    }
+    log(message, options = { color: 'blue' }) {
+        let outputMessage = message;
+        if (options.color) {
+            outputMessage = chalk[options.color](outputMessage);
+        }
+        console.log(outputMessage);
+        return this;
+    }
+    verbose(message, options = {}) {
+        if (!this.config?.verbose) {
+            return this;
+        }
+        this.log(message, options);
+        return this;
+    }
+    startTimer() {
+        this.timerStart = now();
+        return this;
+    }
+    stopTimer(message, options = { color: 'yellow' }) {
+        if (!this.config?.verbose || !this.timerStart) {
+            return this;
+        }
+        const elapsedTime = prettyMilliseconds(now() - this.timerStart);
+        let outputMessage = message
+            ? `${message} (⏲ ${elapsedTime})`
+            : `⏲ ${elapsedTime}`;
+        if (options.color) {
+            outputMessage = chalk[options.color](outputMessage);
         }
-        process.exit(0);
+        console.log(outputMessage);
+        return this;
+    }
+    startSpinner(message, options = { color: 'green' }) {
+        const spinnerMessage = options.color ? chalk[options.color](message) : message;
+        this.spinner = ora(spinnerMessage).start();
+        return this;
+    }
+    stopSpinner(message = '', options = { mode: 'succeed', color: 'green' }) {
+        const spinnerMessage = options?.color ? chalk[options.color](message) : message;
+        this.spinner?.[options.mode || 'succeed'](spinnerMessage);
+        this.spinner = null;
+        return this;
+    }
+}
+
+// const argv = loadArgv()
+const tokenizer = getTokenizer();
+const git = simpleGit();
+const command = ['commit', '$0'];
+const description = 'Generate a commit message based on the diff summary';
+const builder = {
+    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',
+    },
+};
+async function handler(argv) {
+    const options = loadConfig(argv);
+    const logger = new Logger(options);
+    const key = getModelAPIKey(options.model, options);
+    if (!key) {
+        logger.log(`No API Key found. 🗝️🚪`, { color: 'red' });
+        process.exit(1);
     }
+    const model = getModel(options.model, key, {
+        temperature: 0.4,
+        maxConcurrency: 10,
+    });
+    const INTERACTIVE = isInteractive(options);
+    const { staged: changes } = await getChanges({ git });
+    const commitMsg = await generateCommitMessageAndReviewLoop(changes, {
+        logger,
+        model,
+        git,
+        tokenizer,
+        prompt: options.prompt,
+        interactive: INTERACTIVE,
+        openInEditor: options.openInEditor,
+    });
+    const MODE = (options.interactive && 'interactive') ||
+        (options.commit && 'interactive') ||
+        options?.mode ||
+        'stdout';
+    handleResult(commitMsg, {
+        mode: MODE,
+        git,
+    });
 }
 
 var commit = /*#__PURE__*/Object.freeze({
@@ -1037,5 +1087,5 @@ yargs
     description: 'Run with verbose logging',
 }).argv;
 
-export { commit };
+export { commit, loadConfig };
 //# sourceMappingURL=index.esm.mjs.map