git-coco 0.2.1 → 0.3.1

package/README.md

@@ -113,7 +113,7 @@ Remember, command line flags and environment variables should be defined in `UPP
 - [x] LangChain integration 🦜
 - [ ] Additional tests! 🧪
 - [ ] Conventional commits 🔜
-- [ ] HuggingFace integration 🔜
+- [x] HuggingFace integration 🔜
 - [ ] Google Vertex AI integration (?)
 - [ ] Automatic changelog generation 🫣
 - [ ] Rebase support 🔀

package/dist/commands/commit.d.ts

@@ -0,0 +1,16 @@
+import { Argv, CommandBuilder } from 'yargs';
+import { BaseCommandOptions } from '../types';
+export interface CommitOptions extends BaseCommandOptions {
+    interactive: boolean;
+    tokenLimit: number;
+    prompt: string;
+    commit: boolean;
+    summarizePrompt: string;
+    openInEditor: boolean;
+    ignoredFiles: string[];
+    ignoredExtensions: string[];
+}
+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>;

package/dist/index.d.ts

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

package/dist/index.esm.mjs

@@ -1,26 +1,26 @@
 #!/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';
 import * as path from 'path';
 import path__default from 'path';
 import * as ini from 'ini';
-import yargs from 'yargs';
-import { hideBin } from 'yargs/helpers';
 import { PromptTemplate } from 'langchain/prompts';
 import pQueue from 'p-queue';
-import chalk from 'chalk';
-import ora from 'ora';
-import now from 'performance-now';
-import prettyMilliseconds from 'pretty-ms';
 import { Document } from 'langchain/document';
+import { HuggingFaceInference } from 'langchain/llms/hf';
 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 GPT3NodeTokenizer from 'gpt3-tokenizer';
+import ora from 'ora';
+import now from 'performance-now';
+import prettyMilliseconds from 'pretty-ms';
 import { minimatch } from 'minimatch';
-import { simpleGit } from 'simple-git';
 
 /**
  * Returns a new object with all undefined keys removed
@@ -40,7 +40,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,
@@ -71,7 +73,9 @@ function loadGitConfig(config) {
         const gitConfigParsed = ini.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,
@@ -147,72 +151,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(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
@@ -248,7 +186,7 @@ const SUMMARIZE_PROMPT = new PromptTemplate({
  * @type {Config}
  */
 const DEFAULT_CONFIG = {
-    openAIApiKey: '',
+    model: 'openai/gpt-3.5-turbo',
     verbose: false,
     tokenLimit: 1024,
     prompt: COMMIT_PROMPT.template,
@@ -258,7 +196,6 @@ const DEFAULT_CONFIG = {
     ignoredFiles: ['package-lock.json'],
     ignoredExtensions: ['.map', '.lock'],
 };
-
 /**
  * Load application config
  *
@@ -276,7 +213,7 @@ const DEFAULT_CONFIG = {
  *
  * @returns {Config} application config
  **/
-function loadConfig() {
+function loadConfig(argv = {}) {
     // Default config
     let config = DEFAULT_CONFIG;
     config = loadGitignore(config);
@@ -285,60 +222,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 };
 }
 
 /**
@@ -425,8 +309,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);
@@ -512,7 +395,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);
@@ -530,7 +413,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),
@@ -542,22 +425,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(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 HuggingFaceInference({
+                model: model,
+                apiKey: key,
+                maxConcurrency: 4,
+                ...fields,
+            });
+        case 'openai':
+        default:
+            return new 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 RecursiveCharacterTextSplitter(options);
 }
+/**
+ * Get Summarization Chain
+ * @param model
+ * @param options
+ * @returns
+ */
 function getChain(model, options = { type: 'map_reduce' }) {
     return loadSummarizationChain(model, options);
 }
@@ -571,6 +499,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';
@@ -624,8 +558,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',
@@ -646,6 +579,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;
@@ -681,11 +615,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 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();
 };
 
@@ -723,6 +723,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 = {}) {
@@ -777,62 +778,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();
-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) {
@@ -908,7 +964,7 @@ async function main(options) {
                 process.exit(0);
             }
             if (reviewAnswer === 'edit') {
-                config.openInEditor = true;
+                options.openInEditor = true;
             }
             if (reviewAnswer === 'retryFull') {
                 summary = '';
@@ -927,7 +983,7 @@ async function main(options) {
                 continue;
             }
         }
-        if (config.openInEditor) {
+        if (options.openInEditor) {
             commitMsg = await editor({
                 message: 'Edit the commit message',
                 default: commitMsg,
@@ -942,7 +998,7 @@ async function main(options) {
         }
         const MODE = (options.interactive && 'interactive') ||
             (options.commit && 'interactive') ||
-            config?.mode ||
+            options?.mode ||
             'stdout';
         // Handle resulting commit message
         switch (MODE) {
@@ -958,5 +1014,28 @@ 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;
+
+export { commit };
 //# sourceMappingURL=index.esm.mjs.map