git-coco 0.2.1 → 0.3.1

package/dist/index.js

@@ -1,27 +1,27 @@
 #!/usr/bin/env node
 'use strict';
 
+var yargs = require('yargs');
 var prompts$1 = require('@inquirer/prompts');
+var simpleGit = require('simple-git');
 var fs = require('fs');
 var os = require('os');
 var path = require('path');
 var ini = require('ini');
-var yargs = require('yargs');
-var helpers = require('yargs/helpers');
 var prompts = require('langchain/prompts');
 var pQueue = require('p-queue');
-var chalk = require('chalk');
-var ora = require('ora');
-var now = require('performance-now');
-var prettyMilliseconds = require('pretty-ms');
 var document = require('langchain/document');
+var hf = require('langchain/llms/hf');
 var chains = require('langchain/chains');
 var openai = require('langchain/llms/openai');
 var text_splitter = require('langchain/text_splitter');
 var diff = require('diff');
+var chalk = require('chalk');
 var GPT3NodeTokenizer = require('gpt3-tokenizer');
+var ora = require('ora');
+var now = require('performance-now');
+var prettyMilliseconds = require('pretty-ms');
 var minimatch = require('minimatch');
-var simpleGit = require('simple-git');
 
 function _interopNamespaceDefault(e) {
   var n = Object.create(null);
@@ -63,7 +63,9 @@ function removeUndefined(obj) {
  **/
 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,
@@ -94,7 +96,9 @@ function loadGitConfig(config) {
         const gitConfigParsed = ini__namespace.parse(gitConfigRaw);
         config = {
             ...config,
+            model: gitConfigParsed.coco?.model || config.model,
             openAIApiKey: gitConfigParsed.coco?.openAIApiKey || config.openAIApiKey,
+            huggingFaceHubApiKey: gitConfigParsed.coco?.huggingFaceHubApiKey || config.huggingFaceHubApiKey,
             tokenLimit: parseInt(gitConfigParsed.coco?.tokenLimit) || config.tokenLimit,
             prompt: gitConfigParsed.coco?.prompt || config.prompt,
             mode: gitConfigParsed.coco?.mode || config.mode,
@@ -170,72 +174,6 @@ function loadXDGConfig(config) {
     return config;
 }
 
-/**
- * Command line options via yargs
- */
-const options = {
-    openAIApiKey: { type: 'string', description: 'OpenAI API Key' },
-    tokenLimit: { type: 'number', description: 'Token limit' },
-    prompt: {
-        type: 'string',
-        alias: 'p',
-        description: 'Commit message prompt',
-    },
-    interactive: {
-        type: 'boolean',
-        alias: 'i',
-        description: 'Toggle interactive mode',
-    },
-    commit: {
-        type: 'boolean',
-        alias: 's',
-        description: 'Commit staged changes with generated commit message',
-        default: false,
-    },
-    openInEditor: {
-        type: 'boolean',
-        alias: 'e',
-        description: 'Open commit message in editor before proceeding',
-    },
-    verbose: {
-        type: 'boolean',
-        description: 'Enable verbose logging',
-    },
-    summarizePrompt: {
-        type: 'string',
-        description: 'Large file summary prompt',
-    },
-    ignoredFiles: {
-        type: 'array',
-        description: 'Ignored files',
-    },
-    ignoredExtensions: {
-        type: 'array',
-        description: 'Ignored extensions',
-    },
-};
-/**
- * Load command line flags via yargs
- *
- * @returns {Partial<Config>} Updated config
- */
-const loadArgv = () => {
-    return yargs(helpers.hideBin(process.argv)).options(options).parseSync();
-};
-/**
- * Load command line flags
- *
- * Note: Arugments are parsed using yargs.
- *
- * @param {Config} config
- * @returns {Config} Updated config
- **/
-function loadCmdLineFlags(config) {
-    const argv = loadArgv();
-    config = { ...config, ...argv };
-    return config;
-}
-
 const template$1 = `Write informative git commit message 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.
 - Write concisely using an informal tone
@@ -271,7 +209,7 @@ const SUMMARIZE_PROMPT = new prompts.PromptTemplate({
  * @type {Config}
  */
 const DEFAULT_CONFIG = {
-    openAIApiKey: '',
+    model: 'openai/gpt-3.5-turbo',
     verbose: false,
     tokenLimit: 1024,
     prompt: COMMIT_PROMPT.template,
@@ -281,7 +219,6 @@ const DEFAULT_CONFIG = {
     ignoredFiles: ['package-lock.json'],
     ignoredExtensions: ['.map', '.lock'],
 };
-
 /**
  * Load application config
  *
@@ -299,7 +236,7 @@ const DEFAULT_CONFIG = {
  *
  * @returns {Config} application config
  **/
-function loadConfig() {
+function loadConfig(argv = {}) {
     // Default config
     let config = DEFAULT_CONFIG;
     config = loadGitignore(config);
@@ -308,60 +245,7 @@ function loadConfig() {
     config = loadGitConfig(config);
     config = loadProjectConfig(config);
     config = loadEnvConfig(config);
-    config = loadCmdLineFlags(config);
-    return config;
-}
-const config = loadConfig();
-
-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;
-    }
+    return { ...config, ...argv };
 }
 
 /**
@@ -448,8 +332,7 @@ const defaultOutputCallback = (group) => {
     }
     return output;
 };
-async function summarizeDiffs(rootDiffNode, { tokenizer, maxTokens = 2048, textSplitter, chain, handleOutput = defaultOutputCallback, }) {
-    const logger = new Logger(config);
+async function summarizeDiffs(rootDiffNode, { tokenizer, logger, maxTokens = 2048, textSplitter, chain, handleOutput = defaultOutputCallback, }) {
     const queue = new pQueue({ concurrency: 8 });
     logger.startTimer().startSpinner(`Organizing Diffs...`, { color: 'blue' });
     const directoryDiffs = createDirectoryDiffs(rootDiffNode);
@@ -535,7 +418,7 @@ const createDiffTree = (changes) => {
 /**
  * Asynchronously collect diffs for a given node and its children.
  */
-async function collectDiffs(node, getFileDiff, tokenizer, logger = new Logger(config)) {
+async function collectDiffs(node, getFileDiff, tokenizer, logger) {
     // Collect diffs for the files of the current node
     const diffPromises = node.files.map(async (nodeFile) => {
         const diff = await getFileDiff(nodeFile);
@@ -553,7 +436,7 @@ async function collectDiffs(node, getFileDiff, tokenizer, logger = new Logger(co
         };
     });
     // Collect diffs for the children of the current node
-    const childrenPromises = Array.from(node.children.values()).map(async (child) => collectDiffs(child, getFileDiff, tokenizer));
+    const childrenPromises = Array.from(node.children.values()).map(async (child) => collectDiffs(child, getFileDiff, tokenizer, logger));
     const [diffs, children] = await Promise.all([
         Promise.all(diffPromises),
         Promise.all(childrenPromises),
@@ -565,22 +448,67 @@ async function collectDiffs(node, getFileDiff, tokenizer, logger = new Logger(co
     };
 }
 
-// TODO: Extend this to support other models! 🎉
-function getModel(fields, configuration) {
-    return new openai.OpenAI(fields, configuration);
-    // return new HuggingFaceInference({
-    //   // model: 'gpt2',
-    //   // model: 'bigcode/starcoder',
-    //   model: 'bigscience/bloom',
-    //   apiKey: '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',
-    //   maxConcurrency: 4,
-    //   cache: true,
-    //   // maxTokens: 2046,
-    // })
+/**
+ * Get LLM Model Based on Configuration
+ * @param fields
+ * @param configuration
+ * @returns LLM Model
+ */
+function getModel(name, key, fields, configuration) {
+    const [llm, model] = name.split(/\/(.*)/s);
+    if (!model) {
+        throw new Error(`Invalid model: ${name}`);
+    }
+    switch (llm) {
+        case 'huggingface':
+            return new hf.HuggingFaceInference({
+                model: model,
+                apiKey: key,
+                maxConcurrency: 4,
+                ...fields,
+            });
+        case 'openai':
+        default:
+            return new openai.OpenAI({
+                openAIApiKey: key,
+                modelName: model,
+                ...fields,
+            }, configuration);
+    }
 }
+/**
+ * Retrieve appropriate API key based on selected model
+ * @param name
+ * @param options
+ * @returns
+ */
+function getModelAPIKey(name, options) {
+    const [llm, model] = name.split(/\/(.*)/s);
+    if (!model) {
+        throw new Error(`Invalid model: ${name}`);
+    }
+    switch (llm) {
+        case 'huggingface':
+            return options.huggingFaceHubApiKey;
+        case 'openai':
+        default:
+            return options.openAIApiKey;
+    }
+}
+/**
+ * Get Recursive Character Text Splitter
+ * @param options
+ * @returns
+ */
 function getTextSplitter(options = {}) {
     return new text_splitter.RecursiveCharacterTextSplitter(options);
 }
+/**
+ * Get Summarization Chain
+ * @param model
+ * @param options
+ * @returns
+ */
 function getChain(model, options = { type: 'map_reduce' }) {
     return chains.loadSummarizationChain(model, options);
 }
@@ -594,6 +522,12 @@ function getPrompt({ template, variables, fallback }) {
         })
         : fallback);
 }
+/**
+ * Verify  template string contains all required input variables
+ * @param text template string
+ * @param inputVariables template variables
+ * @returns boolean or error message
+ */
 function validatePromptTemplate(text, inputVariables) {
     if (!text) {
         return 'Prompt template cannot be empty';
@@ -647,8 +581,7 @@ const getDiff = async (nodeFile, { git, logger, }) => {
 };
 
 const MAX_TOKENS_PER_SUMMARY = 2048;
-const fileChangeParser = async (changes, { tokenizer, git, model }) => {
-    const logger = new Logger(config);
+const fileChangeParser = async (changes, { tokenizer, git, model, logger }) => {
     const textSplitter = getTextSplitter({ chunkSize: 2000, chunkOverlap: 125, });
     const summarizationChain = getChain(model, {
         type: 'map_reduce',
@@ -669,6 +602,7 @@ const fileChangeParser = async (changes, { tokenizer, git, model }) => {
         maxTokens: MAX_TOKENS_PER_SUMMARY,
         textSplitter,
         chain: summarizationChain,
+        logger
     });
     logger.stopTimer(`\nSummary generated for ${changes.length} staged files`, { color: 'green' });
     return summary;
@@ -704,11 +638,77 @@ const getTokenizer = () => {
     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.');
+    }
     const chain = new chains.LLMChain({ llm, prompt });
-    const res = await chain.call(variables);
-    if (res.error)
-        throw new Error(res.error);
+    let res;
+    try {
+        res = await chain.call(variables);
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            throw new Error(`LLMChain call error: ${error.message}`);
+        }
+    }
+    if (!res) {
+        throw new Error('Empty response from LLMChain call');
+    }
+    if (res.error) {
+        throw new Error(`LLMChain response error: ${res.error}`);
+    }
     return res.text.trim();
 };
 
@@ -746,6 +746,7 @@ const getSummaryText = (file, change) => {
     return `${status}: ${file.path}`;
 };
 
+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 = {}) {
@@ -800,62 +801,117 @@ async function getChanges(git, options = {}) {
 
 const noResult = async ({ git, logger }) => {
     const { staged, unstaged, untracked } = await getChanges(git);
-    if (staged.length > 0) {
+    const hasStaged = staged && staged.length > 0;
+    const hasUnstaged = unstaged && unstaged.length > 0;
+    const hasUntracked = untracked && untracked.length > 0;
+    if (hasStaged) {
         logger.log(`Staged files detected, but no summary generated...`, { color: 'red' });
         logger.log(`Files are likely either:\n  • changed files are ignored\n  • file diff is too large.`, { color: 'yellow' });
     }
-    else if (unstaged && unstaged.length > 0) {
-        logger.log('No staged files detected, but unstaged files detected.', { color: 'yellow' });
-        logger.verbose(`\n Unstaged Changes: \n ${unstaged.map(({ summary }) => summary).join('\n ')}`, {
-            color: 'yellow',
-        });
-    }
-    else if (untracked && untracked.length > 0) {
-        logger.log('No staged files detected, but untracked files detected.', { color: 'yellow' });
-        logger.verbose(`\n Untracked Changes: \n ${untracked.map(({ summary }) => summary).join('\n ')}`, {
-            color: 'yellow',
-        });
+    else if (hasUnstaged || hasUntracked) {
+        logger.log('Forget something? No staged changes found... 👻', { color: 'red' });
+        if (hasUnstaged) {
+            logger.log('\nDetected unstaged changes', { color: 'yellow' });
+            logger.verbose(`\t${unstaged.map(({ summary }) => summary).join('\n\t')}`, {
+                color: 'red',
+            });
+        }
+        if (hasUntracked) {
+            logger.log('\nDetected untracked changes', { color: 'yellow' });
+            logger.verbose(`\t${untracked.map(({ summary }) => summary).join('\n\t')}`, {
+                color: 'red',
+            });
+        }
     }
     else {
-        logger.log('No repo changes detected.', { color: 'yellow' });
+        logger.log('No repo changes detected. 👀', { color: 'blue' });
     }
-    process.exit(0);
 };
 
 async function createCommit(commitMsg, git) {
     return await git.commit(commitMsg);
 }
 
-const argv = loadArgv();
+// const argv = loadArgv()
 const tokenizer = getTokenizer();
 const git = simpleGit.simpleGit();
-async function main(options) {
-    const logger = new Logger(config);
-    if (!config.openAIApiKey) {
+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({
+    const model = getModel(options.model, key, {
         temperature: 0.4,
         maxConcurrency: 10,
-        openAIApiKey: config.openAIApiKey,
     });
-    const INTERACTIVE = config?.mode === 'interactive' || options.interactive;
+    const INTERACTIVE = options?.mode === 'interactive' || options.interactive;
     const { staged: changes } = await getChanges(git);
     let summary = '';
     let commitMsg = '';
-    let promptTemplate = config?.prompt || '';
+    let promptTemplate = options?.prompt || '';
     let modifyPrompt = false;
     while (true) {
         if (changes.length !== 0 && !summary.length) {
             logger.verbose(`\nChanged Files: \n ${changes.map(({ summary }) => summary).join('\n ')}`, {
                 color: 'blue',
             });
-            summary = await fileChangeParser(changes, { tokenizer, git, model });
+            summary = await fileChangeParser(changes, { tokenizer, git, model, logger });
         }
         // Handle empty summary
         if (!summary.length) {
-            noResult({ git, logger });
+            await noResult({ git, logger });
+            process.exit(0);
         }
         // Prompt user for commit template prompt, if necessary
         if (modifyPrompt) {
@@ -931,7 +987,7 @@ async function main(options) {
                 process.exit(0);
             }
             if (reviewAnswer === 'edit') {
-                config.openInEditor = true;
+                options.openInEditor = true;
             }
             if (reviewAnswer === 'retryFull') {
                 summary = '';
@@ -950,7 +1006,7 @@ async function main(options) {
                 continue;
             }
         }
-        if (config.openInEditor) {
+        if (options.openInEditor) {
             commitMsg = await prompts$1.editor({
                 message: 'Edit the commit message',
                 default: commitMsg,
@@ -965,7 +1021,7 @@ async function main(options) {
         }
         const MODE = (options.interactive && 'interactive') ||
             (options.commit && 'interactive') ||
-            config?.mode ||
+            options?.mode ||
             'stdout';
         // Handle resulting commit message
         switch (MODE) {
@@ -981,4 +1037,27 @@ async function main(options) {
         process.exit(0);
     }
 }
-main(argv).catch(console.error);
+
+var commit = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  builder: builder,
+  command: command,
+  description: description,
+  handler: handler
+});
+
+yargs
+    .scriptName('coco')
+    .commandDir('./commands', {
+    extensions: ['ts'],
+})
+    .demandCommand()
+    .strict()
+    .option('h', { alias: 'help' })
+    .option('v', {
+    alias: 'verbose',
+    type: 'boolean',
+    description: 'Run with verbose logging',
+}).argv;
+
+exports.commit = commit;

package/dist/lib/config/{index.d.ts → loadConfig.d.ts}

@@ -1,4 +1,10 @@
 import { Config } from './types';
+/**
+ * Default Config
+ *
+ * @type {Config}
+ */
+export declare const DEFAULT_CONFIG: Config;
 /**
  * Load application config
  *
@@ -16,6 +22,4 @@ import { Config } from './types';
  *
  * @returns {Config} application config
  **/
-export declare function loadConfig(): Config;
-declare const config: Config;
-export default config;
+export declare function loadConfig(argv?: {}): Config;

package/dist/lib/config/types.d.ts

@@ -1,8 +1,22 @@
 export interface Config {
+    /**
+     * The LLM model to use for generating results.
+     *
+     * @default 'openai/gpt-3.5-turbo'
+     *
+     * @example 'openai/gpt-4'
+     * @example 'openai/gpt-3.5-turbo'
+     * @example 'huggingface/bigscience/bloom'
+     **/
+    model: string;
     /**
      * The OpenAI API key.
      */
-    openAIApiKey: string;
+    openAIApiKey?: string;
+    /**
+     * The HuggingFace Hub API key.
+     */
+    huggingFaceHubApiKey?: string;
     /**
      * The maximum number of tokens per request.
      *