git-coco 0.7.5 → 0.8.0

package/dist/index.esm.mjs

@@ -15,11 +15,11 @@ import now from 'performance-now';
 import prettyMilliseconds from 'pretty-ms';
 import pQueue from 'p-queue';
 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 { Ollama } from 'langchain/llms/ollama';
+import { OpenAI } from 'langchain/llms/openai';
 import { minimatch } from 'minimatch';
 import { simpleGit } from 'simple-git';
 import { encoding_for_model } from 'tiktoken';
@@ -47,35 +47,38 @@ const SUMMARIZE_PROMPT = new PromptTemplate({
     inputVariables: inputVariables$2,
 });
 
+const DEFAULT_IGNORED_FILES = ['package-lock.json'];
+const DEFAULT_IGNORED_EXTENSIONS = ['.map', '.lock'];
 /**
  * Default Config
  *
  * @type {Config}
  */
 const DEFAULT_CONFIG = {
-    service: 'openai/gpt-4',
+    service: 'openai',
     verbose: false,
     tokenLimit: 1024,
     summarizePrompt: SUMMARIZE_PROMPT.template,
     temperature: 0.4,
     mode: 'stdout',
-    ignoredFiles: ['package-lock.json'],
-    ignoredExtensions: ['.map', '.lock'],
+    ignoredFiles: DEFAULT_IGNORED_FILES,
+    ignoredExtensions: DEFAULT_IGNORED_EXTENSIONS,
     defaultBranch: 'main',
 };
 /**
  * Create a named export of all config keys for use in other modules.
  *
- * @see Currently used in `src/lib/config/services/env.ts` to validate all env vars.
+ * @see Used in `src/lib/config/services/env.ts` to validate all env vars.
  *
  * @type {string[]}
  */
 const CONFIG_KEYS = Object.keys({
     ...DEFAULT_CONFIG,
-    huggingFaceHubApiKey: '',
-    openAIApiKey: '',
+    endpoint: '',
     prompt: '',
 });
+const COCO_CONFIG_START_COMMENT = '# -- start coco config --';
+const COCO_CONFIG_END_COMMENT = '# -- end coco config --';
 
 async function updateFileSection({ filePath, startComment, endComment, getNewContent, confirmUpdate = true, confirmMessage = (path) => `A section already exists in ${path}, do you want to override it?`, }) {
     const lines = fs__default.existsSync(filePath) ? fs__default.readFileSync(filePath, 'utf-8').split(/\r?\n/) : [];
@@ -150,8 +153,9 @@ function loadEnvConfig(config) {
     CONFIG_KEYS.forEach((key) => {
         const envVarName = toEnvVarName(key);
         const envValue = parseEnvValue(key, process.env[envVarName]);
-        if (envValue === undefined)
+        if (envValue === undefined) {
             return;
+        }
         // eslint-disable-next-line @typescript-eslint/ban-ts-comment
         // @ts-ignore
         envConfig[key] = envValue;
@@ -159,27 +163,28 @@ function loadEnvConfig(config) {
     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(',');
+    switch (true) {
+        // Handle undefined values
+        case value === undefined:
+            return undefined;
+        // Handle comma separated strings for ignoredFiles and ignoredExtensions arrays
+        case (key === 'ignoredFiles' || key === 'ignoredExtensions') &&
+            typeof value === 'string' &&
+            value.includes(','):
+            return value.split(',');
+        // Handle boolean values
+        case typeof value === 'string' && (value === 'false' || value === 'true'):
+            return value === 'true';
+        default:
+            return value;
     }
-    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();
+            return `COCO_${key.replace(/([A-Z])/g, '_$1').toLocaleUpperCase()}`;
     }
 }
 function formatEnvValue(value) {
@@ -196,8 +201,6 @@ function formatEnvValue(value) {
     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)}`)
@@ -205,8 +208,8 @@ const appendToEnvFile = async (filePath, config) => {
     };
     await updateFileSection({
         filePath,
-        startComment,
-        endComment,
+        startComment: COCO_CONFIG_START_COMMENT,
+        endComment: COCO_CONFIG_END_COMMENT,
         getNewContent,
         confirmMessage: CONFIG_ALREADY_EXISTS,
     });
@@ -225,13 +228,19 @@ function loadGitConfig(config) {
         const gitConfigParsed = ini.parse(gitConfigRaw);
         config = {
             ...config,
-            service: gitConfigParsed.coco?.model || config.service,
-            openAIApiKey: gitConfigParsed.coco?.openAIApiKey || config.openAIApiKey,
-            huggingFaceHubApiKey: gitConfigParsed.coco?.huggingFaceHubApiKey || config.huggingFaceHubApiKey,
-            tokenLimit: parseInt(gitConfigParsed.coco?.tokenLimit) || config.tokenLimit,
+            service: gitConfigParsed.coco?.service || config.service,
+            ...(config.service === 'ollama'
+                ? {
+                    endpoint: gitConfigParsed.coco?.endpoint || config?.endpoint,
+                }
+                : {
+                    openAIApiKey: gitConfigParsed.coco?.openAIApiKey || config?.openAIApiKey,
+                }),
+            model: gitConfigParsed.coco?.model || config?.model,
+            temperature: gitConfigParsed.coco?.temperature || config?.temperature,
+            tokenLimit: gitConfigParsed.coco?.tokenLimit || config?.tokenLimit,
             prompt: gitConfigParsed.coco?.prompt || config.prompt,
             mode: gitConfigParsed.coco?.mode || config.mode,
-            temperature: gitConfigParsed.coco?.temperature || config.temperature,
             summarizePrompt: gitConfigParsed.coco?.summarizePrompt || config.summarizePrompt,
             ignoredFiles: gitConfigParsed.coco?.ignoredFiles || config.ignoredFiles,
             ignoredExtensions: gitConfigParsed.coco?.ignoredExtensions || config.ignoredExtensions,
@@ -250,10 +259,7 @@ 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) {
@@ -271,8 +277,8 @@ const appendToGitConfig = async (filePath, config) => {
     };
     await updateFileSection({
         filePath,
-        startComment,
-        endComment,
+        startComment: COCO_CONFIG_START_COMMENT,
+        endComment: COCO_CONFIG_END_COMMENT,
         getNewContent,
         confirmUpdate: true,
         confirmMessage: CONFIG_ALREADY_EXISTS,
@@ -318,7 +324,7 @@ function loadIgnore(config) {
  * @param {Config} config
  * @returns {Config} Updated config
  **/
-function loadProjectConfig(config) {
+function loadProjectJsonConfig(config) {
     // TODO: Add validation based of JSON schema?
     // @see https://github.com/acornejo/jjv
     if (fs.existsSync('.coco.config.json')) {
@@ -327,7 +333,10 @@ function loadProjectConfig(config) {
     }
     return config;
 }
-const appendToProjectConfig = (filePath, config) => {
+const appendToProjectJsonConfig = (filePath, config) => {
+    if (!fs.existsSync(filePath)) {
+        fs.writeFileSync(filePath, '{}');
+    }
     fs.writeFileSync(filePath, JSON.stringify({
         $schema: 'https://git-co.co/schema.json',
         ...config,
@@ -374,7 +383,7 @@ function loadConfig(argv = {}) {
     config = loadIgnore(config);
     config = loadXDGConfig(config);
     config = loadGitConfig(config);
-    config = loadProjectConfig(config);
+    config = loadProjectJsonConfig(config);
     config = loadEnvConfig(config);
     return { ...config, ...argv };
 }
@@ -661,61 +670,16 @@ async function collectDiffs(node, getFileDiff, tokenizer, logger) {
     };
 }
 
-function getModelAndProviderFromService(service) {
-    const [provider, model] = service.split(/\/(.*)/s);
-    if (!model || !provider) {
-        throw new Error(`Invalid service: ${service}`);
-    }
-    return { provider, model };
-}
-function getModelFromService(service) {
-    const { model } = getModelAndProviderFromService(service);
-    return model;
-}
 /**
- * Get LLM Model Based on Configuration
- * @param fields
- * @param configuration
- * @returns LLM Model
- */
-function getLlm(service, key, fields) {
-    const { provider, model } = getModelAndProviderFromService(service);
-    if (!model) {
-        throw new Error(`Invalid LLM Service: ${service}`);
-    }
-    switch (provider) {
-        case 'huggingface':
-            return new HuggingFaceInference({
-                model: model,
-                apiKey: key,
-                maxConcurrency: 4,
-                ...fields,
-            });
-        case 'openai':
-        default:
-            return new OpenAI({
-                openAIApiKey: key,
-                modelName: model,
-                ...fields,
-            });
-    }
-}
-/**
- * Retrieve appropriate API key based on selected model
- * @param service
+ * Get Summarization Chain
+ * @param model
  * @param options
  * @returns
  */
-function getApiKeyForModel(service, options) {
-    const { provider } = getModelAndProviderFromService(service);
-    switch (provider) {
-        case 'huggingface':
-            return options.huggingFaceHubApiKey;
-        case 'openai':
-        default:
-            return options.openAIApiKey;
-    }
+function getSummarizationChain(model, options = { type: 'map_reduce' }) {
+    return loadSummarizationChain(model, options);
 }
+
 /**
  * Get Recursive Character Text Splitter
  * @param options
@@ -724,41 +688,6 @@ function getApiKeyForModel(service, options) {
 function getTextSplitter(options = {}) {
     return new RecursiveCharacterTextSplitter(options);
 }
-/**
- * Get Summarization Chain
- * @param model
- * @param options
- * @returns
- */
-function getSummarizationChain(model, options = { type: 'map_reduce' }) {
-    return loadSummarizationChain(model, options);
-}
-function getPrompt({ template, variables, fallback }) {
-    if (!template && !fallback)
-        throw new Error('Must provide either a template or a fallback');
-    return (template
-        ? new PromptTemplate({
-            template,
-            inputVariables: variables,
-        })
-        : 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';
-    }
-    if (!inputVariables.some((entry) => text.includes(entry))) {
-        return ('Prompt template must include at least one of the following input variables: ' +
-            inputVariables.map((value) => `{${value}}`).join(', '));
-    }
-    return true;
-}
 
 async function parseDefaultFileDiff(nodeFile, commit = '--staged', git) {
     if (commit !== '--staged') {
@@ -846,14 +775,14 @@ async function fileChangeParser({ changes, commit, options: { tokenizer, git, ll
 }
 
 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.
+Commit Messages must have a short description that is less than 50 characters and a longer detailed summary no more than 300 characters, the shorter and more concise the better.  The detailed summary should be separated from the short description by a blank line.  Please follow the guidelines below when writing your commit message:
 
-- Typically a hyphen or asterisk is used for the bullet
 - Write concisely using an informal tone
 - 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
+- DO NOT include any diffs or file changes in the commit message
 - Wrap variable, class, function, components, and dependency names in back ticks e.g. \`variable\`
+- ONLY respond with the resulting commit message.
 
 """{summary}"""
 
@@ -864,6 +793,143 @@ const COMMIT_PROMPT = new PromptTemplate({
     inputVariables: inputVariables$1,
 });
 
+const DEFAULT_OLLAMA_LLM_SERVICE = {
+    provider: 'ollama',
+    model: 'codellama',
+    endpoint: 'http://localhost:11434',
+    maxConcurrent: 1,
+    tokenLimit: 1024,
+};
+const DEFAULT_OPENAI_LLM_SERVICE = {
+    provider: 'openai',
+    model: 'gpt-4',
+    authentication: {
+        type: 'APIKey',
+        credentials: {
+            apiKey: '',
+        },
+    },
+    tokenLimit: 1024,
+};
+
+/**
+ * Retrieves the provider and model from the given configuration object.
+ * @param config The configuration object.
+ * @returns An object containing the provider and model.
+ * @throws Error if the configuration is invalid or missing required properties.
+ */
+function getModelAndProviderFromConfig(config) {
+    if (!config.service) {
+        throw new Error('Invalid service: undefined');
+    }
+    let result;
+    switch (typeof config.service) {
+        case 'string':
+            result = getDefaultServiceConfigFromAlias(config.service, config?.model);
+            break;
+        case 'object':
+        default:
+            result = config.service;
+            break;
+    }
+    const { provider, model } = result;
+    if (!model || !provider) {
+        throw new Error(`Invalid service: ${config.service}`);
+    }
+    return { provider, model };
+}
+/**
+ * Retrieve appropriate API key based on selected model
+ * @param service
+ * @param options
+ * @returns API Key
+ */
+function getApiKeyForModel(config) {
+    const { provider } = getModelAndProviderFromConfig(config);
+    switch (provider) {
+        case 'openai':
+            return config.openAIApiKey || getDefaultServiceApiKey(config);
+        default:
+            return getDefaultServiceApiKey(config);
+    }
+}
+/**
+ * Retrieves the default service API key from the given configuration.
+ * @param config The configuration object.
+ * @returns The default service API key.
+ */
+function getDefaultServiceApiKey(config) {
+    const service = config.service;
+    if (service.authentication.type === 'APIKey') {
+        return service.authentication.credentials?.apiKey;
+    }
+    else if (service.authentication.type === 'OAuth') {
+        return service.authentication.credentials?.token;
+    }
+    return '';
+}
+/**
+ * Retrieves the default service configuration based on the provided alias and optional model.
+ * @param alias - The alias of the service.
+ * @param model - The optional model to be used.
+ * @returns The default service configuration.
+ * @throws Error if the alias is invalid or undefined.
+ */
+function getDefaultServiceConfigFromAlias(alias, model) {
+    if (!alias) {
+        throw new Error('Invalid alias: undefined');
+    }
+    switch (alias) {
+        case 'openai':
+            return {
+                ...DEFAULT_OPENAI_LLM_SERVICE,
+                model: model || DEFAULT_OPENAI_LLM_SERVICE.model,
+            };
+        case 'ollama':
+            return {
+                ...DEFAULT_OLLAMA_LLM_SERVICE,
+                model: model || DEFAULT_OLLAMA_LLM_SERVICE.model,
+            };
+    }
+}
+
+/**
+ * Get LLM Model Based on Configuration
+ *
+ * @param fields
+ * @param configuration
+ * @returns LLM Model
+ */
+function getLlm(provider, model, config) {
+    if (!model) {
+        throw new Error(`Invalid LLM Service: ${provider}/${model}`);
+    }
+    switch (provider) {
+        case 'ollama':
+            return new Ollama({
+                baseUrl: DEFAULT_OLLAMA_LLM_SERVICE.endpoint,
+                model,
+            });
+        case 'openai':
+        default:
+            return new OpenAI({
+                openAIApiKey: config.openAIApiKey,
+                modelName: model,
+            });
+    }
+}
+
+function getPrompt({ template, variables, fallback }) {
+    if (!template && !fallback)
+        throw new Error('Must provide either a template or a fallback');
+    return (template
+        ? new PromptTemplate({
+            template,
+            inputVariables: variables,
+        })
+        : fallback);
+}
+
 function getStatus(file, location = 'index') {
     if ('index' in file && 'working_dir' in file) {
         const statusCode = file[location];
@@ -918,9 +984,6 @@ function getSummaryText(file, change) {
     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 || {};
     const staged = [];
@@ -986,13 +1049,13 @@ async function noResult({ git, logger }) {
     else if (hasUnstaged || hasUntracked) {
         logger.log('Forget something? No staged changes found... 👻', { color: 'red' });
         if (hasUnstaged) {
-            logger.log('\nDetected unstaged changes', { color: 'yellow' });
+            logger.log('\nChanges not staged for commit:', { color: 'yellow' });
             logger.verbose(`\t${unstaged.map(({ summary }) => summary).join('\n\t')}`, {
                 color: 'red',
             });
         }
         if (hasUntracked) {
-            logger.log('\nDetected untracked changes', { color: 'yellow' });
+            logger.log('\nUntracked changes:', { color: 'yellow' });
             logger.verbose(`\t${untracked.map(({ summary }) => summary).join('\n\t')}`, {
                 color: 'red',
             });
@@ -1066,6 +1129,23 @@ async function getUserReviewDecision({ label, descriptions, enableRetry = true,
     }));
 }
 
+/**
+ * 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';
+    }
+    if (!inputVariables.some((entry) => text.includes(entry))) {
+        return ('Prompt template must include at least one of the following input variables: ' +
+            inputVariables.map((value) => `{${value}}`).join(', '));
+    }
+    return true;
+}
+
 async function editPrompt(options) {
     return await editor({
         message: 'Edit the prompt',
@@ -1211,12 +1291,14 @@ const getRepo = () => {
 const getTikToken = async (modelName) => {
     return await encoding_for_model(modelName);
 };
-const getTokenCounter = async (modelName) => getTikToken(modelName).then((tokenizer) => (text) => {
-    // console.log('Running GetTokenCount', { tokenizer, length: text.length })
-    const tokens = tokenizer.encode(text);
-    // console.log('Tokens', { tokenCount: tokens.length })
-    return tokens.length;
-});
+const getTokenCounter = async (modelName) => {
+    return getTikToken(modelName).then((tokenizer) => (text) => {
+        // console.log('Running GetTokenCount', { tokenizer, length: text.length })
+        const tokens = tokenizer.encode(text);
+        // console.log('Tokens', { tokenCount: tokens.length })
+        return tokens.length;
+    });
+};
 
 async function createCommit(commitMsg, git) {
     return await git.commit(commitMsg);
@@ -1225,17 +1307,14 @@ async function createCommit(commitMsg, git) {
 const handler$2 = async (argv, logger) => {
     const git = getRepo();
     const options = loadConfig(argv);
-    const { service } = options;
-    const key = getApiKeyForModel(service, options);
-    const tokenizer = await getTokenCounter(getModelFromService(service));
+    const key = getApiKeyForModel(options);
     if (!key) {
         logger.log(`No API Key found. 🗝️🚪`, { color: 'red' });
         process.exit(1);
     }
-    const llm = getLlm(service, key, {
-        temperature: 0.4,
-        maxConcurrency: 10,
-    });
+    const { provider, model } = getModelAndProviderFromConfig(options);
+    const tokenizer = await getTokenCounter(provider === 'openai' ? model : 'gpt-4');
+    const llm = getLlm(provider, model, options);
     const INTERACTIVE = isInteractive(options);
     if (INTERACTIVE) {
         logger.log(LOGO);
@@ -1301,16 +1380,10 @@ const handler$2 = async (argv, logger) => {
  * Command line options via yargs
  */
 const options$2 = {
-    model: { type: 'string', description: 'LLM/Model-Name' },
+    service: { type: 'string', description: 'LLM/Model-Name', choices: ['openai', 'ollama'] },
     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: {
@@ -1434,15 +1507,13 @@ async function getCommitLogCurrentBranch({ git, logger, comparisonBranch = 'main
 const handler$1 = async (argv, logger) => {
     const options = loadConfig(argv);
     const git = getRepo();
-    const key = getApiKeyForModel(options.service, options);
+    const key = getApiKeyForModel(options);
     if (!key) {
         logger.log(`No API Key found. 🗝️🚪`, { color: 'red' });
         process.exit(1);
     }
-    const model = getLlm(options.service, key, {
-        temperature: 0.4,
-        maxConcurrency: 10,
-    });
+    const { provider, model } = getModelAndProviderFromConfig(options);
+    const llm = getLlm(provider, model, options);
     const INTERACTIVE = isInteractive(options);
     if (INTERACTIVE) {
         logger.log(LOGO);
@@ -1474,7 +1545,7 @@ const handler$1 = async (argv, logger) => {
                 fallback: CHANGELOG_PROMPT,
             });
             return await executeChain({
-                llm: model,
+                llm,
                 prompt,
                 variables: { summary: context },
             });
@@ -1686,13 +1757,9 @@ function getPathToUsersGitConfig() {
     return path__default.join(os__default.homedir(), '.gitconfig');
 }
 
-async function createProjectFileAndReturnPath(fileName, contents) {
+async function getProjectConfigFilePath(configFileName) {
     const projectRoot = findProjectRoot(process.cwd());
-    const configFile = `${projectRoot}/${fileName}`;
-    if (!fs__default.existsSync(configFile)) {
-        fs__default.writeFileSync(configFile, contents || '');
-    }
-    return configFile;
+    return `${projectRoot}/${configFileName}`;
 }
 
 const handler = async (argv, logger) => {
@@ -1716,29 +1783,6 @@ const handler = async (argv, logger) => {
             ],
         });
     }
-    let configFilePath = '';
-    switch (level) {
-        case 'project':
-            const projectConfiguration = await select({
-                message: 'select type project level configuration:',
-                choices: [
-                    {
-                        name: '.coco.config.json',
-                        value: '.coco.config.json',
-                    },
-                    {
-                        name: '.env',
-                        value: '.env',
-                    },
-                ],
-            });
-            configFilePath = await createProjectFileAndReturnPath(projectConfiguration);
-            break;
-        case 'global':
-        default:
-            configFilePath = getPathToUsersGitConfig();
-            break;
-    }
     // interactive v.s stdout mode
     const mode = (await select({
         message: 'select mode:',
@@ -1835,15 +1879,38 @@ const handler = async (argv, logger) => {
     const isApproved = await confirm({
         message: 'looking good? (API key hidden for security)',
     });
+    let configFilePath = '';
+    switch (level) {
+        case 'project':
+            const projectConfiguration = (await select({
+                message: 'where would you like to store the project config?',
+                choices: [
+                    {
+                        name: '.coco.config.json',
+                        value: '.coco.config.json',
+                    },
+                    {
+                        name: '.env',
+                        value: '.env',
+                    },
+                ],
+            }));
+            configFilePath = await getProjectConfigFilePath(projectConfiguration);
+            break;
+        case 'global':
+        default:
+            configFilePath = getPathToUsersGitConfig();
+            break;
+    }
     if (isApproved) {
         if (configFilePath.endsWith('.gitconfig')) {
             await appendToGitConfig(configFilePath, config);
         }
-        else if (configFilePath === '.env') {
+        else if (configFilePath.endsWith('.env')) {
             await appendToEnvFile(configFilePath, config);
         }
-        else if (configFilePath === '.coco.config.json') {
-            await appendToProjectConfig(configFilePath, config);
+        else if (configFilePath.endsWith('.coco.config.json')) {
+            await appendToProjectJsonConfig(configFilePath, config);
         }
         // After config is written, check for package installation
         await checkAndHandlePackageInstallation({ global: level === 'global', logger });