feat(commitlint): improve consistency handling and update prompt structure for commit message generation

Enhancements are made to the consistency handling in the commitlint integration,
including the introduction of a new structure for consistency prompts. The
getConsistencyContent function is updated to accommodate the new format,
allowing for better management of commit messages and their associated
configuration settings. Additionally, the prompts for generating commit messages
are refined to ensure clarity and adherence to the specified requirements.

Author: cometjc

src/engine/deepseek.ts

@@ -2,7 +2,7 @@ import axios from 'axios';
 import { OpenAI } from 'openai';
 import { GenerateCommitMessageErrorEnum } from '../generateCommitMessageFromGitDiff';
 import { tokenCount } from '../utils/tokenCount';
-import { OpenAiEngine, OpenAiConfig } from './openAI';
+import { OpenAiEngine, OpenAiConfig } from './openAi';
 
 export interface DeepseekConfig extends OpenAiConfig {}
 

src/modules/commitlint/config.ts

@@ -65,24 +65,26 @@ export const configureCommitlintIntegration = async (force = false) => {
   // );
 
   const engine = getEngine();
-  let consistency =
-    (await engine.generateCommitMessage(consistencyPrompts)) || '{}';
+  let consistency = (await engine.generateCommitMessage(consistencyPrompts)) || '';
 
   // Cleanup the consistency answer. Sometimes 'gpt-3.5-turbo' sends rule's back.
   prompts.forEach((prompt) => (consistency = consistency.replace(prompt, '')));
 
-  // sometimes consistency is preceded by explanatory text like "Here is your JSON:"
-  consistency = utils.getJSONBlock(consistency);
-
-  // ... remaining might be extra set of "\n"
-  consistency = utils.removeDoubleNewlines(consistency);
+  // Cleanup any potential extra text or formatting
+  consistency = consistency.trim();
 
   const commitlintLLMConfig: CommitlintLLMConfig = {
     hash,
     prompts,
     consistency: {
       [translation.localLanguage]: {
-        ...JSON.parse(consistency as string)
+        commitMessage: consistency,
+        // Store config settings that were used to generate this message
+        config: {
+          OCO_OMIT_SCOPE: config.OCO_OMIT_SCOPE,
+          OCO_DESCRIPTION: config.OCO_DESCRIPTION,
+          OCO_EMOJI: config.OCO_EMOJI
+        }
       }
     }
   };

src/modules/commitlint/prompts.ts

@@ -11,7 +11,7 @@ import {
 
 import { getConfig } from '../../commands/config';
 import { i18n, I18nLocals } from '../../i18n';
-import { IDENTITY, INIT_DIFF_PROMPT } from '../../prompts';
+import { IDENTITY, INIT_DIFF_PROMPT, getConsistencyContent } from '../../prompts';
 
 const config = getConfig();
 const translation = i18n[(config.OCO_LANGUAGE as I18nLocals) || 'en'];
@@ -57,16 +57,16 @@ const llmReadableRules: {
     `There should ${applicable} be a blank line at the beginning of the ${key}.`,
   caseRule: (key, applicable, value: string | Array<string>) =>
     `The ${key} should ${applicable} be in ${Array.isArray(value)
-      ? `one of the following case: 
+      ? `one of the following case:
   - ${value.join('\n  - ')}.`
       : `${value} case.`
     }`,
   emptyRule: (key, applicable) => `The ${key} should ${applicable} be empty.`,
   enumRule: (key, applicable, value: string | Array<string>) =>
-    `The ${key} should ${applicable} be one of the following values: 
+    `The ${key} should ${applicable} be one of the following values:
   - ${Array.isArray(value) ? value.join('\n  - ') : value}.`,
   enumTypeRule: (key, applicable, value: string | Array<string>, prompt) =>
-    `The ${key} should ${applicable} be one of the following values: 
+    `The ${key} should ${applicable} be one of the following values:
   - ${Array.isArray(value)
       ? value
         .map((v) => {
@@ -213,42 +213,55 @@ const STRUCTURE_OF_COMMIT = config.OCO_OMIT_SCOPE
 // Prompt to generate LLM-readable rules based on @commitlint rules.
 const GEN_COMMITLINT_CONSISTENCY_PROMPT = (
   prompts: string[]
-): OpenAI.Chat.Completions.ChatCompletionMessageParam[] => [
+): OpenAI.Chat.Completions.ChatCompletionMessageParam[] => {
+  // Get the default content as reference
+  const defaultContent = getConsistencyContent(translation);
+
+  // Build dynamic requirements based on config
+  const dynamicRequirements = [
+    config.OCO_OMIT_SCOPE
+      ? '- Do not include scope in the commit message'
+      : '- Include appropriate scope in the commit message',
+    config.OCO_DESCRIPTION
+      ? '- Include a description explaining the changes'
+      : '- Do not include a description',
+    config.OCO_EMOJI
+      ? '- Use appropriate emoji at the start of the message'
+      : '- Do not use emoji'
+  ].join('\n');
+
+  return [
     {
       role: 'system',
-      content: `${IDENTITY} Your mission is to create clean and comprehensive commit messages for two different changes in a single codebase and output them in the provided JSON format: one for a bug fix and another for a new feature.
+      content: `${IDENTITY} Your mission is to create a clean and comprehensive commit message that follows both the commitlint rules and maintains the style of the reference message.
 
 Here are the specific requirements and conventions that should be strictly followed:
 
 Commit Message Conventions:
 - The commit message consists of three parts: Header, Body, and Footer.
-- Header: 
+- Header:
   - Format: ${config.OCO_OMIT_SCOPE ? '`<type>: <subject>`' : '`<type>(<scope>): <subject>`'}
 - ${prompts.join('\n- ')}
 
-JSON Output Format:
-- The JSON output should contain the commit messages for a bug fix and a new feature in the following format:
-\`\`\`json
-{
-  "localLanguage": "${translation.localLanguage}",
-  "commitFix": "<Header of commit for bug fix with scope>",
-  "commitFeat": "<Header of commit for feature with scope>",
-  "commitFixOmitScope": "<Header of commit for bug fix without scope>",
-  "commitFeatOmitScope": "<Header of commit for feature without scope>",
-  "commitDescription": "<Description of commit for both the bug fix and the feature>"
-}
-\`\`\`
-- The "commitDescription" should not include the commit message’s header, only the description.
-- Description should not be more than 74 characters.
+${dynamicRequirements}
+
+Reference Message Style:
+${defaultContent}
 
-Additional Details:
-- Changing the variable 'port' to uppercase 'PORT' is considered a bug fix.
-- Allowing the server to listen on a port specified through the environment variable is considered a new feature.
+Output Format:
+- Generate a single commit message that:
+  1. Follows all commitlint rules above
+  2. Maintains the style and features of the reference message
+  3. Follows the specific requirements above
+- The message should be a complete, valid commit message that would pass commitlint validation
+- Do not include any JSON formatting or additional text
+- The message should be ready to use as a git commit message
 
 Example Git Diff is to follow:`
     },
     INIT_DIFF_PROMPT
   ];
+};
 
 /**
  * Prompt to have LLM generate a message using @commitlint rules.
@@ -283,9 +296,7 @@ ${config.OCO_OMIT_SCOPE
     }
 You will strictly follow the following conventions to generate the content of the commit message:
 - ${prompts.join('\n- ')}
-
-The conventions refers to the following structure of commit message:
-${STRUCTURE_OF_COMMIT}`
+`
 });
 
 export const commitlintPrompts = {

src/modules/commitlint/types.ts

@@ -1,6 +1,23 @@
 import { i18n } from '../../i18n';
 
-export type ConsistencyPrompt = (typeof i18n)[keyof typeof i18n];
+export type DefaultConsistencyPrompt = {
+  commitFix: string;
+  commitFeat: string;
+  commitFixOmitScope: string;
+  commitFeatOmitScope: string;
+  commitDescription: string;
+};
+
+export type CommitlintConsistencyPrompt = {
+  commitMessage: string;
+  config: {
+    OCO_OMIT_SCOPE: boolean;
+    OCO_DESCRIPTION: boolean;
+    OCO_EMOJI: boolean;
+  };
+};
+
+export type ConsistencyPrompt = DefaultConsistencyPrompt | CommitlintConsistencyPrompt;
 
 export type CommitlintLLMConfig = {
   hash: string;

src/prompts.ts

@@ -198,7 +198,20 @@ const generateCommitString = (
     : message;
 };
 
-const getConsistencyContent = (translation: ConsistencyPrompt) => {
+export const getConsistencyContent = (translation: ConsistencyPrompt) => {
+  // Check if we're using the new commitlint format
+  if ('commitMessage' in translation) {
+    const message = translation.commitMessage;
+    // Only add emoji if it was enabled when the message was generated
+    if (translation.config.OCO_EMOJI && !message.match(/^[^\s]*\s/)) {
+      const type = message.split(':')[0].toLowerCase();
+      const emoji = COMMIT_TYPES[type as keyof typeof COMMIT_TYPES] || '✨';
+      return `${emoji} ${message}`;
+    }
+    return message;
+  }
+
+  // Handle the old default format (JSON-based)
   const fixMessage = config.OCO_OMIT_SCOPE && translation.commitFixOmitScope
     ? translation.commitFixOmitScope
     : translation.commitFix;
@@ -239,7 +252,6 @@ export const getMainCommitPrompt = async (
 
       // Replace example prompt with a prompt that's generated by OpenAI for the commitlint config.
       const commitLintConfig = await utils.getCommitlintLLMConfig();
-
       return [
         commitlintPrompts.INIT_MAIN_PROMPT(
           translation.localLanguage,