git-coco 0.5.0 → 0.6.0

package/dist/commands/init/handler.d.ts

@@ -0,0 +1,3 @@
+import { CommitOptions } from './options';
+import { Argv } from 'yargs';
+export declare function handler(argv: Argv<CommitOptions>['argv']): Promise<void>;

package/dist/commands/init/index.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="yargs" />
+import { handler } from './handler';
+declare const _default: {
+    command: string;
+    desc: string;
+    builder: (yargs: import("yargs").Argv<{}>) => import("yargs").Argv<import("yargs").Omit<{}, string> & import("yargs").InferredOptionTypes<Record<string, import("yargs").Options>>>;
+    handler: typeof handler;
+    options: Record<string, import("yargs").Options>;
+};
+export default _default;

package/dist/commands/init/options.d.ts

@@ -0,0 +1,15 @@
+import { Options, Argv } from 'yargs';
+import { BaseCommandOptions } from '../types';
+export interface CommitOptions extends BaseCommandOptions {
+    prompt: string;
+    commit: boolean;
+    summarizePrompt: string;
+    openInEditor: boolean;
+    ignoredFiles: string[];
+    ignoredExtensions: string[];
+}
+/**
+ * Command line options via yargs
+ */
+export declare const options: Record<string, Options>;
+export declare const builder: (yargs: Argv) => Argv<import("yargs").Omit<{}, string> & import("yargs").InferredOptionTypes<Record<string, Options>>>;

package/dist/index.esm.mjs

@@ -17,9 +17,11 @@ 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 { editor, select } from '@inquirer/prompts';
 import { simpleGit } from 'simple-git';
 
 /**
@@ -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,27 +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,
-        defaultBranch: process.env.COCO_DEFAULT_BRANCH || 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)
@@ -640,6 +756,38 @@ function loadGitConfig(config) {
     }
     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
@@ -689,6 +837,12 @@ function loadProjectConfig(config) {
     }
     return config;
 }
+const appendToProjectConfig = (filePath, config) => {
+    fs.writeFileSync(filePath, JSON.stringify({
+        $schema: 'https://git-co.co/schema.json',
+        ...config,
+    }, null, 2));
+};
 
 /**
  * Load XDG config
@@ -706,22 +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'],
-    defaultBranch: 'main',
-};
 /**
  * Load application config
  *
@@ -841,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) {
@@ -943,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);
@@ -1033,7 +1171,7 @@ const getRepo = () => {
     return git;
 };
 
-async function handler$1(argv) {
+async function handler$2(argv) {
     const tokenizer = getTokenizer();
     const git = getRepo();
     const options = loadConfig(argv);
@@ -1095,7 +1233,7 @@ async function handler$1(argv) {
 /**
  * Command line options via yargs
  */
-const options$1 = {
+const options$2 = {
     model: { type: 'string', description: 'LLM/Model-Name' },
     openAIApiKey: {
         type: 'string',
@@ -1141,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.
@@ -1226,7 +1364,7 @@ async function getCommitLogCurrentBranch({ git, logger, comparisonBranch = 'main
     return [];
 }
 
-async function handler(argv) {
+async function handler$1(argv) {
     const options = loadConfig(argv);
     const logger = new Logger(options);
     const git = getRepo();
@@ -1297,7 +1435,7 @@ async function handler(argv) {
 /**
  * Command line options via yargs
  */
-const options = {
+const options$1 = {
     range: {
         type: 'string',
         alias: 'r',
@@ -1343,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,
@@ -1368,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