git-coco 0.22.2 → 0.22.3

package/dist/index.esm.mjs

@@ -47,7 +47,7 @@ import { pathToFileURL } from 'url';
 /**
  * Current build version from package.json
  */
-const BUILD_VERSION = "0.22.2";
+const BUILD_VERSION = "0.22.3";
 
 const isInteractive = (config) => {
     return config?.mode === 'interactive' || !!config?.interactive;
@@ -6219,7 +6219,7 @@ function getLlm(provider, model, config) {
                 });
             case 'openai':
                 return new ChatOpenAI({
-                    openAIApiKey: apiKey,
+                    apiKey: apiKey,
                     model,
                     temperature: config.service.temperature || 0.2,
                 });
@@ -11476,9 +11476,34 @@ ${schema.description}
             // Load commitlint rules context if available
             const hasCommitLintConfig = await hasCommitlintConfig();
             let commitlint_rules_context = '';
+            let shouldSkipCommitlintValidation = false;
             if (USE_CONVENTIONAL_COMMITS || hasCommitLintConfig) {
-                const { getCommitlintRulesContext } = await Promise.resolve().then(function () { return commitlintValidator; });
-                commitlint_rules_context = await getCommitlintRulesContext();
+                const { getCommitlintRulesContext, checkCommitlintAvailability } = await Promise.resolve().then(function () { return commitlintValidator; });
+                // Check if commitlint packages are available
+                const availability = checkCommitlintAvailability();
+                if (!availability.available) {
+                    const { handleMissingCommitlintDeps } = await Promise.resolve().then(function () { return handleMissingCommitlintDeps$1; });
+                    const result = await handleMissingCommitlintDeps({
+                        logger,
+                        interactive: INTERACTIVE,
+                        missingPackages: availability.missingPackages,
+                    });
+                    switch (result.action) {
+                        case 'continue':
+                            shouldSkipCommitlintValidation = true;
+                            logger.log('Continuing without commitlint validation...', { color: 'yellow' });
+                            break;
+                        case 'setup':
+                            logger.log('\nPlease run `coco init` to set up commitlint, then try again.', { color: 'blue' });
+                            process.exit(0);
+                        case 'abort':
+                            logger.log('\nAborting commit operation.', { color: 'red' });
+                            process.exit(1);
+                    }
+                }
+                else {
+                    commitlint_rules_context = await getCommitlintRulesContext();
+                }
             }
             // Get variables for the prompt
             const variables = {
@@ -11525,13 +11550,33 @@ ${schema.description}
                 const ticketId = extractTicketIdFromBranchName(branchName);
                 const ticketFooter = argv.appendTicket && ticketId ? `\n\nPart of **${ticketId}**` : '';
                 const fullMessage = `${commitMsg.title}\n\n${commitMsg.body}${appendedText}${ticketFooter}`;
-                // If commitlint validation is needed, validate the message
-                if (USE_CONVENTIONAL_COMMITS || hasCommitLintConfig) {
+                // If commitlint validation is needed and not skipped, validate the message
+                if ((USE_CONVENTIONAL_COMMITS || hasCommitLintConfig) && !shouldSkipCommitlintValidation) {
                     const { validateCommitMessage, CommitlintValidationError } = await Promise.resolve().then(function () { return commitlintValidator; });
                     const validationResult = await validateCommitMessage(fullMessage);
                     logger.verbose(`Validation result: ${JSON.stringify(validationResult)}`, {
                         color: 'yellow',
                     });
+                    // Handle missing dependencies gracefully
+                    if (validationResult.missingDependencies && validationResult.missingDependencies.length > 0) {
+                        const { handleMissingCommitlintDeps } = await Promise.resolve().then(function () { return handleMissingCommitlintDeps$1; });
+                        const result = await handleMissingCommitlintDeps({
+                            logger,
+                            interactive: INTERACTIVE,
+                            missingPackages: validationResult.missingDependencies,
+                        });
+                        switch (result.action) {
+                            case 'continue':
+                                logger.log('Skipping commitlint validation...', { color: 'yellow' });
+                                return fullMessage;
+                            case 'setup':
+                                logger.log('\nPlease run `coco init` to set up commitlint, then try again.', { color: 'blue' });
+                                process.exit(0);
+                            case 'abort':
+                                logger.log('\nAborting commit due to missing dependencies.', { color: 'red' });
+                                process.exit(1);
+                        }
+                    }
                     if (!validationResult.valid) {
                         retryCount++;
                         // Format validation errors for next attempt
@@ -11969,14 +12014,21 @@ const questions = {
             },
         ],
     }),
+    setupCommitlint: async () => await confirm({
+        message: 'set up commitlint for conventional commits support?',
+        default: true,
+    }),
 };
 
 const handler$2 = async (argv, logger) => {
     const options = loadConfig(argv);
     logger.log(LOGO);
     let scope = options?.scope;
+    let shouldSetupCommitlint = false;
     if (!scope) {
         scope = await questions.whatScope();
+        // Ask about commitlint setup after scope selection
+        shouldSetupCommitlint = await questions.setupCommitlint();
         const llmProvider = await questions.selectLLMProvider();
         const llmModel = await questions.selectLLMModel(llmProvider);
         const service = getDefaultServiceConfigFromAlias(llmProvider, llmModel);
@@ -12093,6 +12145,10 @@ const handler$2 = async (argv, logger) => {
             }
             // After config is written, check for package installation
             await checkAndHandlePackageInstallation({ global: scope === 'global', logger });
+            // Install commitlint packages if user requested
+            if (shouldSetupCommitlint) {
+                await installCommitlintPackages(scope, logger);
+            }
             logger.log(`\ninit successful! 🦾🤖🎉`, { color: 'green' });
         }
         else {
@@ -12100,6 +12156,39 @@ const handler$2 = async (argv, logger) => {
         }
     }
 };
+/**
+ * Install commitlint packages based on scope (global or project)
+ */
+async function installCommitlintPackages(scope, logger) {
+    const packages = ['@commitlint/config-conventional', '@commitlint/cli'];
+    try {
+        if (scope === 'global') {
+            logger.startSpinner('Installing commitlint packages globally...', { color: 'blue' });
+            for (const pkg of packages) {
+                await installNpmPackage({ name: pkg, flags: ['-g'] });
+            }
+            logger.stopSpinner('Installed commitlint packages globally');
+        }
+        else {
+            logger.startSpinner('Installing commitlint packages in project...', { color: 'blue' });
+            for (const pkg of packages) {
+                await installNpmPackage({ name: pkg, flags: ['--save-dev'] });
+            }
+            logger.stopSpinner('Installed commitlint packages in project');
+        }
+    }
+    catch (error) {
+        logger.stopSpinner('Failed to install commitlint packages');
+        logger.log(`Error installing commitlint packages: ${error.message}`, { color: 'red' });
+        logger.log('You can install them manually later:', { color: 'yellow' });
+        if (scope === 'global') {
+            logger.log('npm install -g @commitlint/config-conventional @commitlint/cli', { color: 'gray' });
+        }
+        else {
+            logger.log('npm install --save-dev @commitlint/config-conventional @commitlint/cli', { color: 'gray' });
+        }
+    }
+}
 
 var init = {
     command: command$2,
@@ -12786,6 +12875,31 @@ class CommitlintValidationError extends Error {
         this.commitMessage = commitMessage;
     }
 }
+/**
+ * Check if commitlint config packages are available
+ * We only check for config-conventional since @commitlint/core is bundled with git-coco
+ */
+function checkCommitlintAvailability() {
+    const requiredPackages = ['@commitlint/config-conventional'];
+    const missingPackages = [];
+    for (const pkg of requiredPackages) {
+        try {
+            // Try to resolve the package from the current working directory
+            require.resolve(pkg, { paths: [process.cwd(), ...module.paths] });
+        }
+        catch (error) {
+            missingPackages.push(pkg);
+        }
+    }
+    // If config-conventional is missing, also suggest installing CLI
+    if (missingPackages.length > 0) {
+        missingPackages.push('@commitlint/cli');
+    }
+    return {
+        available: missingPackages.length === 0,
+        missingPackages,
+    };
+}
 /**
  * Load commitlint configuration
  */
@@ -12825,10 +12939,35 @@ async function loadCommitlintConfig() {
     catch (error) {
         // Could be an error parsing, or just not found. Fall through to default.
     }
-    // If nothing worked, fallback to conventional config
-    return load({
-        extends: ['@commitlint/config-conventional'],
-    });
+    // Try to fallback to conventional config, but handle missing dependencies gracefully
+    try {
+        return await load({
+            extends: ['@commitlint/config-conventional'],
+        });
+    }
+    catch (error) {
+        // If @commitlint/config-conventional is not available, return a basic conventional config
+        if (error instanceof Error && error.message.includes('Cannot find module "@commitlint/config-conventional"')) {
+            return await load({
+                rules: {
+                    'header-max-length': [2, 'always', 72],
+                    'header-min-length': [2, 'always', 8],
+                    'subject-empty': [2, 'never'],
+                    'subject-full-stop': [2, 'never', '.'],
+                    'subject-case': [2, 'always', ['sentence-case', 'start-case', 'pascal-case', 'upper-case', 'lower-case']],
+                    'type-empty': [2, 'never'],
+                    'type-case': [2, 'always', 'lower-case'],
+                    'type-enum': [2, 'always', [
+                            'build', 'chore', 'ci', 'docs', 'feat', 'fix',
+                            'perf', 'refactor', 'revert', 'style', 'test'
+                        ]],
+                    'body-max-line-length': [2, 'always', 100],
+                    'scope-case': [2, 'always', 'lower-case'],
+                },
+            });
+        }
+        throw error;
+    }
 }
 /**
  * Format commitlint rules into a human-readable string for AI prompts
@@ -12937,9 +13076,19 @@ async function validateCommitMessage(message, options = {}) {
         };
     }
     catch (error) {
+        const errorMessage = error.message;
+        // Check if this is a missing dependency error
+        if (errorMessage.includes('Cannot find module "@commitlint/config-conventional"')) {
+            return {
+                valid: false,
+                errors: ['Commitlint configuration requires @commitlint/config-conventional to be installed'],
+                warnings: [],
+                missingDependencies: ['@commitlint/config-conventional', '@commitlint/cli'],
+            };
+        }
         return {
             valid: false,
-            errors: [error.message],
+            errors: [errorMessage],
             warnings: [],
         };
     }
@@ -12948,12 +13097,61 @@ async function validateCommitMessage(message, options = {}) {
 var commitlintValidator = /*#__PURE__*/Object.freeze({
   __proto__: null,
   CommitlintValidationError: CommitlintValidationError,
+  checkCommitlintAvailability: checkCommitlintAvailability,
   formatCommitlintRulesForPrompt: formatCommitlintRulesForPrompt,
   getCommitlintRulesContext: getCommitlintRulesContext,
   loadCommitlintConfig: loadCommitlintConfig,
   validateCommitMessage: validateCommitMessage
 });
 
+/**
+ * Handle missing commitlint dependencies with user-friendly options
+ */
+async function handleMissingCommitlintDeps(options) {
+    const { logger, interactive, missingPackages } = options;
+    if (!interactive) {
+        logger.log('\nCommitlint packages not found. Skipping commit message validation.', {
+            color: 'yellow',
+        });
+        logger.log('Run `coco init` to set up commitlint for conventional commits.', {
+            color: 'gray',
+        });
+        return { action: 'continue' };
+    }
+    logger.log('\nCommitlint configuration requires additional packages:', { color: 'yellow' });
+    missingPackages.forEach((pkg) => {
+        logger.log(`  • ${pkg}`, { color: 'gray' });
+    });
+    logger.log('');
+    const choice = await select({
+        message: 'How would you like to proceed?',
+        choices: [
+            {
+                name: 'Continue without commitlint validation',
+                value: 'continue',
+                description: 'Generate commit message without validation rules',
+            },
+            {
+                name: 'Set up commitlint (run coco init)',
+                value: 'setup',
+                description: 'Exit and run the init command to install required packages',
+            },
+            {
+                name: 'Abort',
+                value: 'abort',
+                description: 'Cancel the commit operation',
+            },
+        ],
+        default: 'continue',
+    });
+    return { action: choice };
+}
+
+var handleMissingCommitlintDeps$1 = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  handleMissingCommitlintDeps: handleMissingCommitlintDeps
+});
+
 /**
  * Handle commit message validation results with user interaction
  */

package/dist/index.js

@@ -69,7 +69,7 @@ var readline__namespace = /*#__PURE__*/_interopNamespaceDefault(readline);
 /**
  * Current build version from package.json
  */
-const BUILD_VERSION = "0.22.2";
+const BUILD_VERSION = "0.22.3";
 
 const isInteractive = (config) => {
     return config?.mode === 'interactive' || !!config?.interactive;
@@ -6241,7 +6241,7 @@ function getLlm(provider, model, config) {
                 });
             case 'openai':
                 return new openai.ChatOpenAI({
-                    openAIApiKey: apiKey,
+                    apiKey: apiKey,
                     model,
                     temperature: config.service.temperature || 0.2,
                 });
@@ -11498,9 +11498,34 @@ ${schema.description}
             // Load commitlint rules context if available
             const hasCommitLintConfig = await hasCommitlintConfig();
             let commitlint_rules_context = '';
+            let shouldSkipCommitlintValidation = false;
             if (USE_CONVENTIONAL_COMMITS || hasCommitLintConfig) {
-                const { getCommitlintRulesContext } = await Promise.resolve().then(function () { return commitlintValidator; });
-                commitlint_rules_context = await getCommitlintRulesContext();
+                const { getCommitlintRulesContext, checkCommitlintAvailability } = await Promise.resolve().then(function () { return commitlintValidator; });
+                // Check if commitlint packages are available
+                const availability = checkCommitlintAvailability();
+                if (!availability.available) {
+                    const { handleMissingCommitlintDeps } = await Promise.resolve().then(function () { return handleMissingCommitlintDeps$1; });
+                    const result = await handleMissingCommitlintDeps({
+                        logger,
+                        interactive: INTERACTIVE,
+                        missingPackages: availability.missingPackages,
+                    });
+                    switch (result.action) {
+                        case 'continue':
+                            shouldSkipCommitlintValidation = true;
+                            logger.log('Continuing without commitlint validation...', { color: 'yellow' });
+                            break;
+                        case 'setup':
+                            logger.log('\nPlease run `coco init` to set up commitlint, then try again.', { color: 'blue' });
+                            process.exit(0);
+                        case 'abort':
+                            logger.log('\nAborting commit operation.', { color: 'red' });
+                            process.exit(1);
+                    }
+                }
+                else {
+                    commitlint_rules_context = await getCommitlintRulesContext();
+                }
             }
             // Get variables for the prompt
             const variables = {
@@ -11547,13 +11572,33 @@ ${schema.description}
                 const ticketId = extractTicketIdFromBranchName(branchName);
                 const ticketFooter = argv.appendTicket && ticketId ? `\n\nPart of **${ticketId}**` : '';
                 const fullMessage = `${commitMsg.title}\n\n${commitMsg.body}${appendedText}${ticketFooter}`;
-                // If commitlint validation is needed, validate the message
-                if (USE_CONVENTIONAL_COMMITS || hasCommitLintConfig) {
+                // If commitlint validation is needed and not skipped, validate the message
+                if ((USE_CONVENTIONAL_COMMITS || hasCommitLintConfig) && !shouldSkipCommitlintValidation) {
                     const { validateCommitMessage, CommitlintValidationError } = await Promise.resolve().then(function () { return commitlintValidator; });
                     const validationResult = await validateCommitMessage(fullMessage);
                     logger.verbose(`Validation result: ${JSON.stringify(validationResult)}`, {
                         color: 'yellow',
                     });
+                    // Handle missing dependencies gracefully
+                    if (validationResult.missingDependencies && validationResult.missingDependencies.length > 0) {
+                        const { handleMissingCommitlintDeps } = await Promise.resolve().then(function () { return handleMissingCommitlintDeps$1; });
+                        const result = await handleMissingCommitlintDeps({
+                            logger,
+                            interactive: INTERACTIVE,
+                            missingPackages: validationResult.missingDependencies,
+                        });
+                        switch (result.action) {
+                            case 'continue':
+                                logger.log('Skipping commitlint validation...', { color: 'yellow' });
+                                return fullMessage;
+                            case 'setup':
+                                logger.log('\nPlease run `coco init` to set up commitlint, then try again.', { color: 'blue' });
+                                process.exit(0);
+                            case 'abort':
+                                logger.log('\nAborting commit due to missing dependencies.', { color: 'red' });
+                                process.exit(1);
+                        }
+                    }
                     if (!validationResult.valid) {
                         retryCount++;
                         // Format validation errors for next attempt
@@ -11991,14 +12036,21 @@ const questions = {
             },
         ],
     }),
+    setupCommitlint: async () => await prompts.confirm({
+        message: 'set up commitlint for conventional commits support?',
+        default: true,
+    }),
 };
 
 const handler$2 = async (argv, logger) => {
     const options = loadConfig(argv);
     logger.log(LOGO);
     let scope = options?.scope;
+    let shouldSetupCommitlint = false;
     if (!scope) {
         scope = await questions.whatScope();
+        // Ask about commitlint setup after scope selection
+        shouldSetupCommitlint = await questions.setupCommitlint();
         const llmProvider = await questions.selectLLMProvider();
         const llmModel = await questions.selectLLMModel(llmProvider);
         const service = getDefaultServiceConfigFromAlias(llmProvider, llmModel);
@@ -12115,6 +12167,10 @@ const handler$2 = async (argv, logger) => {
             }
             // After config is written, check for package installation
             await checkAndHandlePackageInstallation({ global: scope === 'global', logger });
+            // Install commitlint packages if user requested
+            if (shouldSetupCommitlint) {
+                await installCommitlintPackages(scope, logger);
+            }
             logger.log(`\ninit successful! 🦾🤖🎉`, { color: 'green' });
         }
         else {
@@ -12122,6 +12178,39 @@ const handler$2 = async (argv, logger) => {
         }
     }
 };
+/**
+ * Install commitlint packages based on scope (global or project)
+ */
+async function installCommitlintPackages(scope, logger) {
+    const packages = ['@commitlint/config-conventional', '@commitlint/cli'];
+    try {
+        if (scope === 'global') {
+            logger.startSpinner('Installing commitlint packages globally...', { color: 'blue' });
+            for (const pkg of packages) {
+                await installNpmPackage({ name: pkg, flags: ['-g'] });
+            }
+            logger.stopSpinner('Installed commitlint packages globally');
+        }
+        else {
+            logger.startSpinner('Installing commitlint packages in project...', { color: 'blue' });
+            for (const pkg of packages) {
+                await installNpmPackage({ name: pkg, flags: ['--save-dev'] });
+            }
+            logger.stopSpinner('Installed commitlint packages in project');
+        }
+    }
+    catch (error) {
+        logger.stopSpinner('Failed to install commitlint packages');
+        logger.log(`Error installing commitlint packages: ${error.message}`, { color: 'red' });
+        logger.log('You can install them manually later:', { color: 'yellow' });
+        if (scope === 'global') {
+            logger.log('npm install -g @commitlint/config-conventional @commitlint/cli', { color: 'gray' });
+        }
+        else {
+            logger.log('npm install --save-dev @commitlint/config-conventional @commitlint/cli', { color: 'gray' });
+        }
+    }
+}
 
 var init = {
     command: command$2,
@@ -12808,6 +12897,31 @@ class CommitlintValidationError extends Error {
         this.commitMessage = commitMessage;
     }
 }
+/**
+ * Check if commitlint config packages are available
+ * We only check for config-conventional since @commitlint/core is bundled with git-coco
+ */
+function checkCommitlintAvailability() {
+    const requiredPackages = ['@commitlint/config-conventional'];
+    const missingPackages = [];
+    for (const pkg of requiredPackages) {
+        try {
+            // Try to resolve the package from the current working directory
+            require.resolve(pkg, { paths: [process.cwd(), ...module.paths] });
+        }
+        catch (error) {
+            missingPackages.push(pkg);
+        }
+    }
+    // If config-conventional is missing, also suggest installing CLI
+    if (missingPackages.length > 0) {
+        missingPackages.push('@commitlint/cli');
+    }
+    return {
+        available: missingPackages.length === 0,
+        missingPackages,
+    };
+}
 /**
  * Load commitlint configuration
  */
@@ -12847,10 +12961,35 @@ async function loadCommitlintConfig() {
     catch (error) {
         // Could be an error parsing, or just not found. Fall through to default.
     }
-    // If nothing worked, fallback to conventional config
-    return load({
-        extends: ['@commitlint/config-conventional'],
-    });
+    // Try to fallback to conventional config, but handle missing dependencies gracefully
+    try {
+        return await load({
+            extends: ['@commitlint/config-conventional'],
+        });
+    }
+    catch (error) {
+        // If @commitlint/config-conventional is not available, return a basic conventional config
+        if (error instanceof Error && error.message.includes('Cannot find module "@commitlint/config-conventional"')) {
+            return await load({
+                rules: {
+                    'header-max-length': [2, 'always', 72],
+                    'header-min-length': [2, 'always', 8],
+                    'subject-empty': [2, 'never'],
+                    'subject-full-stop': [2, 'never', '.'],
+                    'subject-case': [2, 'always', ['sentence-case', 'start-case', 'pascal-case', 'upper-case', 'lower-case']],
+                    'type-empty': [2, 'never'],
+                    'type-case': [2, 'always', 'lower-case'],
+                    'type-enum': [2, 'always', [
+                            'build', 'chore', 'ci', 'docs', 'feat', 'fix',
+                            'perf', 'refactor', 'revert', 'style', 'test'
+                        ]],
+                    'body-max-line-length': [2, 'always', 100],
+                    'scope-case': [2, 'always', 'lower-case'],
+                },
+            });
+        }
+        throw error;
+    }
 }
 /**
  * Format commitlint rules into a human-readable string for AI prompts
@@ -12959,9 +13098,19 @@ async function validateCommitMessage(message, options = {}) {
         };
     }
     catch (error) {
+        const errorMessage = error.message;
+        // Check if this is a missing dependency error
+        if (errorMessage.includes('Cannot find module "@commitlint/config-conventional"')) {
+            return {
+                valid: false,
+                errors: ['Commitlint configuration requires @commitlint/config-conventional to be installed'],
+                warnings: [],
+                missingDependencies: ['@commitlint/config-conventional', '@commitlint/cli'],
+            };
+        }
         return {
             valid: false,
-            errors: [error.message],
+            errors: [errorMessage],
             warnings: [],
         };
     }
@@ -12970,12 +13119,61 @@ async function validateCommitMessage(message, options = {}) {
 var commitlintValidator = /*#__PURE__*/Object.freeze({
   __proto__: null,
   CommitlintValidationError: CommitlintValidationError,
+  checkCommitlintAvailability: checkCommitlintAvailability,
   formatCommitlintRulesForPrompt: formatCommitlintRulesForPrompt,
   getCommitlintRulesContext: getCommitlintRulesContext,
   loadCommitlintConfig: loadCommitlintConfig,
   validateCommitMessage: validateCommitMessage
 });
 
+/**
+ * Handle missing commitlint dependencies with user-friendly options
+ */
+async function handleMissingCommitlintDeps(options) {
+    const { logger, interactive, missingPackages } = options;
+    if (!interactive) {
+        logger.log('\nCommitlint packages not found. Skipping commit message validation.', {
+            color: 'yellow',
+        });
+        logger.log('Run `coco init` to set up commitlint for conventional commits.', {
+            color: 'gray',
+        });
+        return { action: 'continue' };
+    }
+    logger.log('\nCommitlint configuration requires additional packages:', { color: 'yellow' });
+    missingPackages.forEach((pkg) => {
+        logger.log(`  • ${pkg}`, { color: 'gray' });
+    });
+    logger.log('');
+    const choice = await prompts.select({
+        message: 'How would you like to proceed?',
+        choices: [
+            {
+                name: 'Continue without commitlint validation',
+                value: 'continue',
+                description: 'Generate commit message without validation rules',
+            },
+            {
+                name: 'Set up commitlint (run coco init)',
+                value: 'setup',
+                description: 'Exit and run the init command to install required packages',
+            },
+            {
+                name: 'Abort',
+                value: 'abort',
+                description: 'Cancel the commit operation',
+            },
+        ],
+        default: 'continue',
+    });
+    return { action: choice };
+}
+
+var handleMissingCommitlintDeps$1 = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  handleMissingCommitlintDeps: handleMissingCommitlintDeps
+});
+
 /**
  * Handle commit message validation results with user interaction
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "git-coco",
-  "version": "0.22.2",
+  "version": "0.22.3",
   "description": "zero-effort git commits with coco.",
   "author": "gfargo <ghfargo@gmail.com>",
   "license": "MIT",
@@ -45,6 +45,7 @@
     "coco:esm": "node dist/index.esm.mjs"
   },
   "devDependencies": {
+    "@commitlint/types": "^19.8.0",
     "@rollup/plugin-commonjs": "^28.0.0",
     "@rollup/plugin-eslint": "^9.0.5",
     "@rollup/plugin-json": "^6.0.0",
@@ -73,9 +74,7 @@
     "typescript": "^5.4.5"
   },
   "dependencies": {
-    "@commitlint/config-conventional": "^19.8.0",
     "@commitlint/core": "^19.8.0",
-    "@commitlint/types": "^19.8.0",
     "@inquirer/prompts": "3.3.0",
     "@langchain/anthropic": "^0.3.14",
     "@langchain/community": "^0.3.32",