- [] [build for both mjs and cjs](https://snyk.io/blog/best-practices-create-modern-npm-package/)

- [] make bundle smaller by properly configuring esbuild

- [] do // TODOs in the code

- [] batch small files in one request

- [] add tests

- [] make hook work

import { intro, outro } from '@clack/prompts';

import {

ChatCompletionRequestMessage,

ChatCompletionResponseMessage,

Configuration as OpenAiApiConfiguration,

OpenAIApi

} from 'openai';

import { getConfig } from './commands/config';

const config = getConfig();

let apiKey = config?.OPENAI_API_KEY;

if (!apiKey) {

intro('opencommit');

outro(

'OPENAI_API_KEY is not set, please run `oc config set OPENAI_API_KEY=<your token>`'

);

outro(

'For help Look into README https://github.com/di-sukharev/opencommit#setup'

);

class OpenAi {

private openAiApiConfiguration = new OpenAiApiConfiguration({

apiKey: apiKey

});

private openAI = new OpenAIApi(this.openAiApiConfiguration);

public generateCommitMessage = async (

messages: Array<ChatCompletionRequestMessage>

): Promise<ChatCompletionResponseMessage | undefined> => {

try {

const { data } = await this.openAI.createChatCompletion({

model: 'gpt-3.5-turbo',

messages,

temperature: 0,

top_p: 0.1,

max_tokens: 196

});

const message = data.choices[0].message;

return message;

} catch (error) {

console.error('openAI api error', { error });

throw error;

}

};

export const api = new OpenAi();

import { execa } from 'execa';

import {

GenerateCommitMessageErrorEnum,

generateCommitMessageWithChatCompletion

} from '../generateCommitMessageFromGitDiff';

import { assertGitRepo, getStagedGitDiff } from '../utils/git';

import { spinner, confirm, outro, isCancel, intro } from '@clack/prompts';

import chalk from 'chalk';

const generateCommitMessageFromGitDiff = async (

diff: string

): Promise<void> => {

await assertGitRepo();

const commitSpinner = spinner();

commitSpinner.start('Generating the commit message');

const commitMessage = await generateCommitMessageWithChatCompletion(diff);

if (typeof commitMessage !== 'string') {

const errorMessages = {

[GenerateCommitMessageErrorEnum.emptyMessage]:

'empty openAI response, weird, try again',

[GenerateCommitMessageErrorEnum.internalError]:

'internal error, try again',

[GenerateCommitMessageErrorEnum.tooMuchTokens]:

'too much tokens in git diff, stage and commit files in parts'

};

outro(`${chalk.red('✖')} ${errorMessages[commitMessage.error]}`);

process.exit(1);

}

commitSpinner.stop('📝 Commit message generated');

outro(

`Commit message:

);

const isCommitConfirmedByUser = await confirm({

message: 'Confirm the commit message'

});

if (isCommitConfirmedByUser && !isCancel(isCommitConfirmedByUser)) {

await execa('git', ['commit', '-m', commitMessage]);

outro(`${chalk.green('✔')} successfully committed`);

} else outro(`${chalk.gray('✖')} process cancelled`);

export async function commit(isStageAllFlag = false) {

intro('open-commit');

const stagedFilesSpinner = spinner();

stagedFilesSpinner.start('Counting staged files');

const staged = await getStagedGitDiff(isStageAllFlag);

if (!staged && isStageAllFlag) {

outro(

`${chalk.red(

);

process.exit(1);

}

if (!staged) {

outro(

`${chalk.red('Nothing to commit')} — stage the files ${chalk

);

stagedFilesSpinner.stop('Counting staged files');

const isStageAllAndCommitConfirmedByUser = await confirm({

message: 'Do you want to stage all files and generate commit message?'

});

if (

isStageAllAndCommitConfirmedByUser &&

!isCancel(isStageAllAndCommitConfirmedByUser)

) {

await commit(true);

}

process.exit(1);

}

stagedFilesSpinner.stop(

`${staged.files.length} staged files:\n${staged.files

);

await generateCommitMessageFromGitDiff(staged.diff);

import { command } from 'cleye';

import { join as pathJoin } from 'path';

import { parse as iniParse, stringify as iniStringify } from 'ini';

import { existsSync, writeFileSync, readFileSync } from 'fs';

import { homedir } from 'os';

import { intro, outro } from '@clack/prompts';

import chalk from 'chalk';

export enum CONFIG_KEYS {

OPENAI_API_KEY = 'OPENAI_API_KEY',

description = 'description',

emoji = 'emoji'

const validateConfig = (

key: string,

condition: any,

validationMessage: string

) => {

if (!condition) {

throw new Error(`Unsupported config key ${key}: ${validationMessage}`);

}

export const configValidators = {

[CONFIG_KEYS.OPENAI_API_KEY](value: any) {

validateConfig(CONFIG_KEYS.OPENAI_API_KEY, value, 'Cannot be empty');

validateConfig(

CONFIG_KEYS.OPENAI_API_KEY,

value.startsWith('sk-'),

'Must start with "sk-"'

);

validateConfig(

CONFIG_KEYS.OPENAI_API_KEY,

value.length === 51,

'Must be 51 characters long'

);

return value;

},

[CONFIG_KEYS.description](value: any) {

validateConfig(

CONFIG_KEYS.description,

typeof value === 'boolean',

'Must be true or false'

);

return value;

},

[CONFIG_KEYS.emoji](value: any) {

validateConfig(

CONFIG_KEYS.emoji,

typeof value === 'boolean',

'Must be true or false'

);

return value;

}

export type ConfigType = {

[key in CONFIG_KEYS]?: any;

const configPath = pathJoin(homedir(), '.opencommit');

export const getConfig = (): ConfigType | null => {

const configExists = existsSync(configPath);

if (!configExists) return null;

const configFile = readFileSync(configPath, 'utf8');

const config = iniParse(configFile);

for (const configKey of Object.keys(config)) {

const validValue = configValidators[configKey as CONFIG_KEYS](

config[configKey]

);

config[configKey] = validValue;

}

return config;

export const setConfig = (keyValues: [key: string, value: string][]) => {

const config = getConfig() || {};

for (const [configKey, configValue] of keyValues) {

if (!configValidators.hasOwnProperty(configKey)) {

throw new Error(`Unsupported config key: ${configKey}`);

}

let parsedConfigValue;

try {

parsedConfigValue = JSON.parse(configValue);

} catch (error) {

parsedConfigValue = configValue;

}

const validValue =

configValidators[configKey as CONFIG_KEYS](parsedConfigValue);

config[configKey as CONFIG_KEYS] = validValue;

}

writeFileSync(configPath, iniStringify(config), 'utf8');

outro(`${chalk.green('✔')} config successfully set`);

export const configCommand = command(

{

name: 'config',

parameters: ['<mode>', '<key=values...>']

},

async (argv) => {

intro('opencommit — config');

try {

const { mode, keyValues } = argv._;

if (mode === 'get') {

const config = getConfig() || {};

for (const key of keyValues) {

outro(`${key}=${config[key as keyof typeof config]}`);

}

} else if (mode === 'set') {

await setConfig(

keyValues.map((keyValue) => keyValue.split('=') as [string, string])

);

} else {

throw new Error(

`Unsupported mode: ${mode}. Valid modes are: "set" and "get"`

);

}

} catch (error) {

outro(`${chalk.red('✖')} ${error}`);

process.exit(1);

}

}