@elsikora/commitizen-plugin-commitlint-ai 1.2.0 → 2.0.0-dev.2

package/dist/cjs/domain/value-object/commit-body.value-object.js

@@ -0,0 +1,66 @@
+'use strict';
+
+/**
+ * Value object representing a commit message body
+ */
+class CommitBody {
+    BREAKING_CHANGE;
+    CONTENT;
+    constructor(content, breakingChange) {
+        this.CONTENT = content?.trim() ?? undefined;
+        this.BREAKING_CHANGE = breakingChange?.trim() ?? undefined;
+    }
+    /**
+     * Check if two bodies are equal
+     * @param {CommitBody} other - The other commit body to compare with
+     * @returns {boolean} True if the bodies are equal
+     */
+    equals(other) {
+        return this.CONTENT === other.CONTENT && this.BREAKING_CHANGE === other.BREAKING_CHANGE;
+    }
+    /**
+     * Get the breaking change description
+     * @returns {string | undefined} The breaking change description or undefined
+     */
+    getBreakingChange() {
+        return this.BREAKING_CHANGE;
+    }
+    /**
+     * Get the body content
+     * @returns {string | undefined} The body content or undefined
+     */
+    getContent() {
+        return this.CONTENT;
+    }
+    /**
+     * Check if there is a breaking change
+     * @returns {boolean} True if there is a breaking change
+     */
+    hasBreakingChange() {
+        return !!this.BREAKING_CHANGE;
+    }
+    /**
+     * Check if the body is empty
+     * @returns {boolean} True if the body is empty
+     */
+    isEmpty() {
+        return !this.CONTENT && !this.BREAKING_CHANGE;
+    }
+    /**
+     * Format the body as a string
+     * @returns {string} The formatted body text
+     */
+    toString() {
+        const parts = [];
+        if (this.BREAKING_CHANGE) {
+            parts.push(`BREAKING CHANGE: ${this.BREAKING_CHANGE}`);
+        }
+        if (this.CONTENT) {
+            parts.push(this.CONTENT);
+        }
+        return parts.join("\n\n");
+    }
+}
+
+exports.CommitBody = CommitBody;
+//# sourceMappingURL=commit-body.value-object.js.map

package/dist/cjs/domain/value-object/commit-body.value-object.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"commit-body.value-object.js","sources":["../../../../../src/domain/value-object/commit-body.value-object.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAAA;;AAEG;MACU,UAAU,CAAA;AACL,IAAA,eAAe;AAEf,IAAA,OAAO;IAExB,WAAY,CAAA,OAAgB,EAAE,cAAuB,EAAA;QACpD,IAAI,CAAC,OAAO,GAAG,OAAO,EAAE,IAAI,EAAE,IAAI,SAAS;QAC3C,IAAI,CAAC,eAAe,GAAG,cAAc,EAAE,IAAI,EAAE,IAAI,SAAS;;AAG3D;;;;AAIG;AACH,IAAA,MAAM,CAAC,KAAiB,EAAA;AACvB,QAAA,OAAO,IAAI,CAAC,OAAO,KAAK,KAAK,CAAC,OAAO,IAAI,IAAI,CAAC,eAAe,KAAK,KAAK,CAAC,eAAe;;AAGxF;;;AAGG;IACH,iBAAiB,GAAA;QAChB,OAAO,IAAI,CAAC,eAAe;;AAG5B;;;AAGG;IACH,UAAU,GAAA;QACT,OAAO,IAAI,CAAC,OAAO;;AAGpB;;;AAGG;IACH,iBAAiB,GAAA;AAChB,QAAA,OAAO,CAAC,CAAC,IAAI,CAAC,eAAe;;AAG9B;;;AAGG;IACH,OAAO,GAAA;QACN,OAAO,CAAC,IAAI,CAAC,OAAO,IAAI,CAAC,IAAI,CAAC,eAAe;;AAG9C;;;AAGG;IACH,QAAQ,GAAA;QACP,MAAM,KAAK,GAAkB,EAAE;AAE/B,QAAA,IAAI,IAAI,CAAC,eAAe,EAAE;YACzB,KAAK,CAAC,IAAI,CAAC,CAAA,iBAAA,EAAoB,IAAI,CAAC,eAAe,CAAE,CAAA,CAAC;;AAGvD,QAAA,IAAI,IAAI,CAAC,OAAO,EAAE;AACjB,YAAA,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC;;AAGzB,QAAA,OAAO,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC;;AAE1B;;;;"}

package/dist/cjs/domain/value-object/commit-header.value-object.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Value object representing a commit message header
+ */
+export declare class CommitHeader {
+    private readonly SCOPE;
+    private readonly SUBJECT;
+    private readonly TYPE;
+    constructor(type: string, subject: string, scope?: string);
+    /**
+     * Check if two headers are equal
+     * @param {CommitHeader} other - The other commit header to compare with
+     * @returns {boolean} True if the headers are equal
+     */
+    equals(other: CommitHeader): boolean;
+    /**
+     * Get the commit scope
+     * @returns {string | undefined} The commit scope or undefined
+     */
+    getScope(): string | undefined;
+    /**
+     * Get the commit subject
+     * @returns {string} The commit subject
+     */
+    getSubject(): string;
+    /**
+     * Get the commit type
+     * @returns {string} The commit type
+     */
+    getType(): string;
+    /**
+     * Format the header as a string
+     * @returns {string} The formatted header
+     */
+    toString(): string;
+}

package/dist/cjs/domain/value-object/commit-header.value-object.js

@@ -0,0 +1,63 @@
+'use strict';
+
+/**
+ * Value object representing a commit message header
+ */
+class CommitHeader {
+    SCOPE;
+    SUBJECT;
+    TYPE;
+    constructor(type, subject, scope) {
+        if (!type || type.trim().length === 0) {
+            throw new Error("Commit type cannot be empty");
+        }
+        if (!subject || subject.trim().length === 0) {
+            throw new Error("Commit subject cannot be empty");
+        }
+        this.TYPE = type.trim();
+        this.SUBJECT = subject.trim();
+        this.SCOPE = scope?.trim();
+    }
+    /**
+     * Check if two headers are equal
+     * @param {CommitHeader} other - The other commit header to compare with
+     * @returns {boolean} True if the headers are equal
+     */
+    equals(other) {
+        return this.TYPE === other.getType() && this.SCOPE === other.getScope() && this.SUBJECT === other.getSubject();
+    }
+    /**
+     * Get the commit scope
+     * @returns {string | undefined} The commit scope or undefined
+     */
+    getScope() {
+        return this.SCOPE;
+    }
+    /**
+     * Get the commit subject
+     * @returns {string} The commit subject
+     */
+    getSubject() {
+        return this.SUBJECT;
+    }
+    /**
+     * Get the commit type
+     * @returns {string} The commit type
+     */
+    getType() {
+        return this.TYPE;
+    }
+    /**
+     * Format the header as a string
+     * @returns {string} The formatted header
+     */
+    toString() {
+        if (this.SCOPE) {
+            return `${this.TYPE}(${this.SCOPE}): ${this.SUBJECT}`;
+        }
+        return `${this.TYPE}: ${this.SUBJECT}`;
+    }
+}
+
+exports.CommitHeader = CommitHeader;
+//# sourceMappingURL=commit-header.value-object.js.map

package/dist/cjs/domain/value-object/commit-header.value-object.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"commit-header.value-object.js","sources":["../../../../../src/domain/value-object/commit-header.value-object.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAAA;;AAEG;MACU,YAAY,CAAA;AACP,IAAA,KAAK;AAEL,IAAA,OAAO;AAEP,IAAA,IAAI;AAErB,IAAA,WAAA,CAAY,IAAY,EAAE,OAAe,EAAE,KAAc,EAAA;AACxD,QAAA,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC,IAAI,EAAE,CAAC,MAAM,KAAK,CAAC,EAAE;AACtC,YAAA,MAAM,IAAI,KAAK,CAAC,6BAA6B,CAAC;;AAG/C,QAAA,IAAI,CAAC,OAAO,IAAI,OAAO,CAAC,IAAI,EAAE,CAAC,MAAM,KAAK,CAAC,EAAE;AAC5C,YAAA,MAAM,IAAI,KAAK,CAAC,gCAAgC,CAAC;;AAGlD,QAAA,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,IAAI,EAAE;AACvB,QAAA,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC,IAAI,EAAE;AAC7B,QAAA,IAAI,CAAC,KAAK,GAAG,KAAK,EAAE,IAAI,EAAE;;AAG3B;;;;AAIG;AACH,IAAA,MAAM,CAAC,KAAmB,EAAA;QACzB,OAAO,IAAI,CAAC,IAAI,KAAK,KAAK,CAAC,OAAO,EAAE,IAAI,IAAI,CAAC,KAAK,KAAK,KAAK,CAAC,QAAQ,EAAE,IAAI,IAAI,CAAC,OAAO,KAAK,KAAK,CAAC,UAAU,EAAE;;AAG/G;;;AAGG;IACH,QAAQ,GAAA;QACP,OAAO,IAAI,CAAC,KAAK;;AAGlB;;;AAGG;IACH,UAAU,GAAA;QACT,OAAO,IAAI,CAAC,OAAO;;AAGpB;;;AAGG;IACH,OAAO,GAAA;QACN,OAAO,IAAI,CAAC,IAAI;;AAGjB;;;AAGG;IACH,QAAQ,GAAA;AACP,QAAA,IAAI,IAAI,CAAC,KAAK,EAAE;AACf,YAAA,OAAO,CAAG,EAAA,IAAI,CAAC,IAAI,CAAI,CAAA,EAAA,IAAI,CAAC,KAAK,CAAM,GAAA,EAAA,IAAI,CAAC,OAAO,EAAE;;QAGtD,OAAO,CAAA,EAAG,IAAI,CAAC,IAAI,KAAK,IAAI,CAAC,OAAO,CAAA,CAAE;;AAEvC;;;;"}

package/dist/cjs/domain/value-object/index.d.ts

@@ -0,0 +1,3 @@
+export * from './api-key.value-object';
+export * from './commit-body.value-object';
+export * from './commit-header.value-object';

package/dist/cjs/index.d.ts

@@ -1,14 +1,16 @@
-import type { Answers, DistinctQuestion } from "inquirer";
-export { getLLMConfig, setLLMConfig } from "./services/llm/index.js";
-export type { CommitMode, LLMConfig, LLMConfigStorage, LLMModel, LLMProvider } from "./services/llm/types.js";
-type Commit = (message: string) => void;
+import "dotenv/config";
 /**
- * Entry point for commitizen
- * @param  inquirerIns instance passed by commitizen, unused
- * @param commit callback to execute with complete commit message
- * @return {void}
+ * Commitizen adapter entry point
+ * This function is called by Commitizen when running `git cz`
+ * It delegates to the CommitizenAdapter to handle the interactive commit process
+ * @param {unknown} inquirerInstance - The inquirer instance provided by Commitizen
+ * @param {(message: string) => void} commit - Callback function to execute the commit with the generated message
+ * @returns {Promise<void>} Promise that resolves when the commit process is complete
  */
-export declare function prompter(inquirerIns: {
-    prompt(questions: Array<DistinctQuestion>): Promise<Answers>;
-}, commit: Commit): Promise<void>;
-//# sourceMappingURL=index.d.ts.map
+export declare function prompter(inquirerInstance: unknown, commit: (message: string) => void): Promise<void>;
+declare const _default: {
+    prompter: typeof prompter;
+};
+export default _default;
+export * from './application/index';
+export * from './domain/index';

package/dist/cjs/index.js

@@ -1,92 +1,94 @@
 'use strict';
 
-var node_fs = require('node:fs');
-var node_path = require('node:path');
-var load = require('@commitlint/load');
-var chalk = require('chalk');
-var dotenv = require('dotenv');
-var inquirer = require('inquirer');
-var Process = require('./Process.js');
-require('./services/llm/index.js');
-var config = require('./services/llm/config.js');
+Object.defineProperty(exports, '__esModule', { value: true });
 
-// Load environment variables from .env file
-try {
-    dotenv.config();
-}
-catch {
-    // Silently continue if .env file is not found or cannot be loaded
-}
-// Check what commit mode to use based on config, environment variable, and fallback file
-const getCommitMode = () => {
-    try {
-        // First check environment variable (highest priority)
-        // Next check for manual flag file
-        if (node_fs.existsSync(node_path.join("./.elsikora", "manual"))) {
-            return "manual";
-        }
-        // Finally check config file
-        const config$1 = config.getLLMConfig();
-        if (config$1?.mode && // Validation is now done in config.ts to avoid duplicate messages
-            (config$1.mode === "auto" || config$1.mode === "manual")) {
-            return config$1.mode;
-        }
-        // Default to auto if not specified
-        return "auto";
-    }
-    catch {
-        // In case of any errors, default to auto
-        return "auto";
-    }
-};
+var container = require('./infrastructure/di/container.js');
+var commitizen_adapter = require('./presentation/commitizen.adapter.js');
+require('dotenv/config');
+var configureLlm_useCase = require('./application/use-case/configure-llm.use-case.js');
+var generateCommitMessage_useCase = require('./application/use-case/generate-commit-message.use-case.js');
+var manualCommit_useCase = require('./application/use-case/manual-commit.use-case.js');
+var validateCommitMessage_useCase = require('./application/use-case/validate-commit-message.use-case.js');
+var commitMessage_entity = require('./domain/entity/commit-message.entity.js');
+var llmConfiguration_entity = require('./domain/entity/llm-configuration.entity.js');
+var anthropicModel_enum = require('./domain/enum/anthropic-model.enum.js');
+var awsBedrockModel_enum = require('./domain/enum/aws-bedrock-model.enum.js');
+var azureOpenaiModel_enum = require('./domain/enum/azure-openai-model.enum.js');
+var commitMode_enum = require('./domain/enum/commit-mode.enum.js');
+var googleModel_enum = require('./domain/enum/google-model.enum.js');
+var llmProvider_enum = require('./domain/enum/llm-provider.enum.js');
+var logLevel_enum = require('./domain/enum/log-level.enum.js');
+var ollamaModel_enum = require('./domain/enum/ollama-model.enum.js');
+var openaiModel_enum = require('./domain/enum/openai-model.enum.js');
+var apiKey_valueObject = require('./domain/value-object/api-key.value-object.js');
+var commitBody_valueObject = require('./domain/value-object/commit-body.value-object.js');
+var commitHeader_valueObject = require('./domain/value-object/commit-header.value-object.js');
+
+// Initialize the DI container
+container.createAppContainer();
+// Create adapter instance
+const adapter = new commitizen_adapter.CommitizenAdapter();
 /**
- * Entry point for commitizen
- * @param  inquirerIns instance passed by commitizen, unused
- * @param commit callback to execute with complete commit message
- * @return {void}
+ * Commitizen adapter entry point
+ * This function is called by Commitizen when running `git cz`
+ * It delegates to the CommitizenAdapter to handle the interactive commit process
+ * @param {unknown} inquirerInstance - The inquirer instance provided by Commitizen
+ * @param {(message: string) => void} commit - Callback function to execute the commit with the generated message
+ * @returns {Promise<void>} Promise that resolves when the commit process is complete
  */
-async function prompter(inquirerIns, commit) {
-    // eslint-disable-next-line @elsikora-typescript/typedef
-    await load().then(async ({ prompt = {}, rules }) => {
-        // Use process (AI mode) unless manual mode is enabled
-        const commitMode = getCommitMode();
-        if (commitMode === "manual") {
-            const { useExisting } = await inquirer.prompt([
-                {
-                    // eslint-disable-next-line @elsikora-typescript/naming-convention
-                    default: true,
-                    message: `Use manual configuration?`,
-                    name: "useExisting",
-                    type: "confirm",
-                },
-            ]);
-            if (useExisting) {
-                console.log(chalk.blue("Using manual commit mode..."));
-                // Import manualProcess dynamically to avoid loading AI deps when not needed
-                // eslint-disable-next-line @elsikora-typescript/typedef
-                await Promise.resolve().then(function () { return require('./ManualProcess.js'); }).then(async ({ default: manualProcess }) => {
-                    await manualProcess(rules, prompt, inquirerIns).then(commit);
-                });
-            }
-            else {
-                console.log(chalk.blue("Using AI-powered commit mode..."));
-                // eslint-disable-next-line @elsikora/typescript/no-non-null-assertion
-                const oldConfig = config.getLLMConfig();
-                config.setLLMConfig({
-                    ...oldConfig,
-                    mode: "auto",
-                });
-                await Process.default(rules, prompt, inquirerIns).then(commit);
-            }
-        }
-        else {
-            console.log(chalk.blue("Using AI-powered commit mode..."));
-            await Process.default(rules, prompt, inquirerIns).then(commit);
-        }
-    });
+async function prompter(inquirerInstance, commit) {
+    return adapter.prompter(inquirerInstance, commit);
 }
+// Export the prompter function for Commitizen
+var index = {
+    prompter,
+};
 
-exports.getLLMConfig = config.getLLMConfig;
-exports.setLLMConfig = config.setLLMConfig;
+exports.ConfigureLLMUseCase = configureLlm_useCase.ConfigureLLMUseCase;
+exports.GenerateCommitMessageUseCase = generateCommitMessage_useCase.GenerateCommitMessageUseCase;
+exports.ManualCommitUseCase = manualCommit_useCase.ManualCommitUseCase;
+exports.ValidateCommitMessageUseCase = validateCommitMessage_useCase.ValidateCommitMessageUseCase;
+exports.CommitMessage = commitMessage_entity.CommitMessage;
+exports.LLMConfiguration = llmConfiguration_entity.LLMConfiguration;
+Object.defineProperty(exports, "EAnthropicModel", {
+    enumerable: true,
+    get: function () { return anthropicModel_enum.EAnthropicModel; }
+});
+Object.defineProperty(exports, "EAWSBedrockModel", {
+    enumerable: true,
+    get: function () { return awsBedrockModel_enum.EAWSBedrockModel; }
+});
+Object.defineProperty(exports, "EAzureOpenAIModel", {
+    enumerable: true,
+    get: function () { return azureOpenaiModel_enum.EAzureOpenAIModel; }
+});
+Object.defineProperty(exports, "ECommitMode", {
+    enumerable: true,
+    get: function () { return commitMode_enum.ECommitMode; }
+});
+Object.defineProperty(exports, "EGoogleModel", {
+    enumerable: true,
+    get: function () { return googleModel_enum.EGoogleModel; }
+});
+Object.defineProperty(exports, "ELLMProvider", {
+    enumerable: true,
+    get: function () { return llmProvider_enum.ELLMProvider; }
+});
+Object.defineProperty(exports, "ELogLevel", {
+    enumerable: true,
+    get: function () { return logLevel_enum.ELogLevel; }
+});
+Object.defineProperty(exports, "EOllamaModel", {
+    enumerable: true,
+    get: function () { return ollamaModel_enum.EOllamaModel; }
+});
+Object.defineProperty(exports, "EOpenAIModel", {
+    enumerable: true,
+    get: function () { return openaiModel_enum.EOpenAIModel; }
+});
+exports.ApiKey = apiKey_valueObject.ApiKey;
+exports.CommitBody = commitBody_valueObject.CommitBody;
+exports.CommitHeader = commitHeader_valueObject.CommitHeader;
+exports.default = index;
 exports.prompter = prompter;
 //# sourceMappingURL=index.js.map

package/dist/cjs/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":["../../../src/index.ts"],"sourcesContent":[null],"names":["loadDotEnvironment","existsSync","join","config","getLLMConfig","setLLMConfig","process"],"mappings":";;;;;;;;;;;;AAeA;AACA,IAAI;AACH,IAAAA,aAAkB,EAAE;AACrB;AAAE,MAAM;;AAER;AASA;AACA,MAAM,aAAa,GAAG,MAAiB;AACtC,IAAA,IAAI;;;QAIH,IAAIC,kBAAU,CAACC,cAAI,CAAC,aAAa,EAAE,QAAQ,CAAC,CAAC,EAAE;AAC9C,YAAA,OAAO,QAAQ;;;AAIhB,QAAA,MAAMC,QAAM,GAAmDC,mBAAY,EAAE;AAE7E,QAAA,IACCD,QAAM,EAAE,IAAI;AACZ,aAACA,QAAM,CAAC,IAAI,KAAK,MAAM,IAAIA,QAAM,CAAC,IAAI,KAAK,QAAQ,CAAC,EACnD;YACD,OAAOA,QAAM,CAAC,IAAI;;;AAInB,QAAA,OAAO,MAAM;;AACZ,IAAA,MAAM;;AAEP,QAAA,OAAO,MAAM;;AAEf,CAAC;AAED;;;;;AAKG;AACI,eAAe,QAAQ,CAC7B,WAEC,EACD,MAAc,EAAA;;AAGd,IAAA,MAAM,IAAI,EAAE,CAAC,IAAI,CAAC,OAAO,EAAE,MAAM,GAAG,EAAE,EAAE,KAAK,EAAE,KAAI;;AAElD,QAAA,MAAM,UAAU,GAAsB,aAAa,EAAE;AAErD,QAAA,IAAI,UAAU,KAAK,QAAQ,EAAE;YAC5B,MAAM,EAAE,WAAW,EAAE,GAAQ,MAAM,QAAQ,CAAC,MAAM,CAAC;AAClD,gBAAA;;AAEC,oBAAA,OAAO,EAAE,IAAI;AACb,oBAAA,OAAO,EAAE,CAA2B,yBAAA,CAAA;AACpC,oBAAA,IAAI,EAAE,aAAa;AACnB,oBAAA,IAAI,EAAE,SAAS;AACf,iBAAA;AACD,aAAA,CAAC;YAEF,IAAI,WAAW,EAAE;gBAChB,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC,6BAA6B,CAAC,CAAC;;;AAGtD,gBAAA,MAAM,oDAAO,oBAAoB,KAAC,CAAC,IAAI,CAAC,OAAO,EAAE,OAAO,EAAE,aAAa,EAAE,KAAI;AAC5E,oBAAA,MAAM,aAAa,CAAC,KAAK,EAAE,MAAM,EAAE,WAAW,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC;AAC7D,iBAAC,CAAC;;iBACI;gBACN,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC,iCAAiC,CAAC,CAAC;;AAE1D,gBAAA,MAAM,SAAS,GAAcC,mBAAY,EAAG;AAC5C,gBAAAC,mBAAY,CAAC;AACZ,oBAAA,GAAG,SAAS;AACZ,oBAAA,IAAI,EAAE,MAAM;AACZ,iBAAA,CAAC;AACF,gBAAA,MAAMC,eAAO,CAAC,KAAK,EAAE,MAAM,EAAE,WAAW,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC;;;aAEjD;YACN,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC,iCAAiC,CAAC,CAAC;AAC1D,YAAA,MAAMA,eAAO,CAAC,KAAK,EAAE,MAAM,EAAE,WAAW,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC;;AAExD,KAAC,CAAC;AACH;;;;;;"}
+{"version":3,"file":"index.js","sources":["../../../src/index.ts"],"sourcesContent":[null],"names":["createAppContainer","CommitizenAdapter"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAKA;AACAA,4BAAkB,EAAE;AAEpB;AACA,MAAM,OAAO,GAAsB,IAAIC,oCAAiB,EAAE;AAE1D;;;;;;;AAOG;AACI,eAAe,QAAQ,CAAC,gBAAyB,EAAE,MAAiC,EAAA;IAC1F,OAAO,OAAO,CAAC,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAC;AAClD;AAEA;AACA,YAAe;IACd,QAAQ;CACR;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/cjs/infrastructure/commit-validator/commitlint-validator.service.d.ts

@@ -0,0 +1,38 @@
+import type { ICommitValidationResult, ICommitValidator } from '../../application/interface/commit-validator.interface';
+import type { ILlmPromptContext, ILlmService } from '../../application/interface/llm-service.interface';
+import type { CommitMessage } from '../../domain/entity/commit-message.entity';
+import type { LLMConfiguration } from '../../domain/entity/llm-configuration.entity';
+/**
+ * Commitlint implementation of the commit validator
+ */
+export declare class CommitlintValidatorService implements ICommitValidator {
+    private readonly LLM_SERVICES?;
+    private llmConfiguration?;
+    constructor(llmServices?: Array<ILlmService>);
+    /**
+     * Attempt to fix a commit message based on validation errors
+     * @param {CommitMessage} message - The commit message to fix
+     * @param {ICommitValidationResult} validationResult - The validation result containing errors
+     * @param {ILlmPromptContext} context - Optional original context for LLM-based fixing
+     * @returns {Promise<CommitMessage | null>} Promise resolving to the fixed commit message or null if unfixable
+     */
+    fix(message: CommitMessage, validationResult: ICommitValidationResult, context?: ILlmPromptContext): Promise<CommitMessage | null>;
+    /**
+     * Set the LLM configuration for this validator
+     * @param {LLMConfiguration} configuration - The LLM configuration to set
+     */
+    setLLMConfiguration(configuration: LLMConfiguration): void;
+    /**
+     * Validate a commit message using commitlint
+     * @param {CommitMessage} message - The commit message to validate
+     * @returns {Promise<ICommitValidationResult>} Promise resolving to the validation result
+     */
+    validate(message: CommitMessage): Promise<ICommitValidationResult>;
+    /**
+     * Wrap text to ensure no line exceeds the specified length
+     * @param {string | undefined} text - The text to wrap
+     * @param {number} maxLength - Maximum line length
+     * @returns {string | undefined} The wrapped text
+     */
+    private wrapText;
+}

package/dist/cjs/infrastructure/commit-validator/commitlint-validator.service.js

@@ -0,0 +1,207 @@
+'use strict';
+
+var lint = require('@commitlint/lint');
+var load = require('@commitlint/load');
+var numeric_constant = require('../../domain/constant/numeric.constant.js');
+var commitBody_valueObject = require('../../domain/value-object/commit-body.value-object.js');
+var commitHeader_valueObject = require('../../domain/value-object/commit-header.value-object.js');
+
+/**
+ * Commitlint implementation of the commit validator
+ */
+class CommitlintValidatorService {
+    LLM_SERVICES;
+    llmConfiguration;
+    constructor(llmServices) {
+        this.LLM_SERVICES = llmServices;
+    }
+    /**
+     * Attempt to fix a commit message based on validation errors
+     * @param {CommitMessage} message - The commit message to fix
+     * @param {ICommitValidationResult} validationResult - The validation result containing errors
+     * @param {ILlmPromptContext} context - Optional original context for LLM-based fixing
+     * @returns {Promise<CommitMessage | null>} Promise resolving to the fixed commit message or null if unfixable
+     */
+    async fix(message, validationResult, context) {
+        if (!validationResult.errors || validationResult.errors.length === 0) {
+            return message;
+        }
+        // If we have context and LLM services, use LLM to regenerate
+        if (context && this.LLM_SERVICES && this.llmConfiguration) {
+            const service = this.LLM_SERVICES.find((s) => {
+                const config = this.llmConfiguration;
+                return config ? s.supports(config) : false;
+            });
+            if (service) {
+                process.stdout.write("Using LLM to intelligently fix validation errors...\n");
+                try {
+                    // Create a minimal context for fixing - no need to send diff again
+                    const fixContext = {
+                        body: context.body,
+                        // Explicitly exclude diff and files
+                        diff: undefined,
+                        files: undefined,
+                        rules: {
+                            ...(typeof context.rules === "object" && !Array.isArray(context.rules) ? context.rules : {}),
+                            instructions: "Fix the commit message to comply with the validation rules. Do not change the meaning or content, only fix the format to pass validation.",
+                            previousAttempt: message.toString(),
+                            validationErrors: validationResult.errors,
+                        },
+                        scopeDescription: context.scopeDescription,
+                        subject: context.subject,
+                        typeDescription: context.typeDescription,
+                        typeDescriptions: context.typeDescriptions,
+                        typeEnum: context.typeEnum,
+                    };
+                    // Generate a new commit message with the minimal context
+                    const fixedMessage = await service.generateCommitMessage(fixContext, this.llmConfiguration);
+                    // Validate the new message
+                    const fixedValidation = await this.validate(fixedMessage);
+                    if (fixedValidation.isValid) {
+                        process.stdout.write("LLM fix successful!\n");
+                        return fixedMessage;
+                    }
+                    else {
+                        process.stdout.write("LLM fix still has validation errors, falling back to simple fixes\n");
+                    }
+                }
+                catch (error) {
+                    process.stderr.write(`Failed to fix commit message with LLM: ${error instanceof Error ? error.message : String(error)}\n`);
+                    // Fall through to simple fixes
+                }
+            }
+        }
+        process.stdout.write("Attempting simple rule-based fixes...\n");
+        // Fallback to simple fixes
+        let fixedMessage = message;
+        // Try to fix common errors
+        for (const error of validationResult.errors) {
+            if (error.includes("subject may not be empty")) {
+                // Can't fix empty subject
+                return null;
+            }
+            if (error.includes("type may not be empty")) {
+                // Can't fix empty type
+                return null;
+            }
+            // Fix subject case issues
+            if (error.includes("subject must not be sentence-case")) {
+                const header = fixedMessage.getHeader();
+                const subject = header.getSubject();
+                const fixedSubject = subject.charAt(0).toLowerCase() + subject.slice(1);
+                const newHeader = new commitHeader_valueObject.CommitHeader(header.getType(), fixedSubject, header.getScope());
+                fixedMessage = fixedMessage.withHeader(newHeader);
+            }
+            // Fix subject trailing period
+            if (error.includes("subject may not end with period")) {
+                const header = fixedMessage.getHeader();
+                const subject = header.getSubject();
+                const fixedSubject = subject.replace(/\.$/, "");
+                const newHeader = new commitHeader_valueObject.CommitHeader(header.getType(), fixedSubject, header.getScope());
+                fixedMessage = fixedMessage.withHeader(newHeader);
+            }
+            // Fix header max length
+            if (error.includes("header must not be longer than")) {
+                const maxLengthNumbers = error.match(/\d+/g) ?? [];
+                if (maxLengthNumbers.length > 0 && maxLengthNumbers[0]) {
+                    const maxLength = Number.parseInt(maxLengthNumbers[0], 10);
+                    const header = fixedMessage.getHeader();
+                    const currentLength = header.toString().length;
+                    if (currentLength > maxLength) {
+                        // Try to shorten the subject
+                        const overhead = currentLength - maxLength;
+                        const subject = header.getSubject();
+                        const shortenedSubject = subject.slice(0, Math.max(0, subject.length - overhead - numeric_constant.ELLIPSIS_LENGTH)) + "...";
+                        const newHeader = new commitHeader_valueObject.CommitHeader(header.getType(), shortenedSubject, header.getScope());
+                        fixedMessage = fixedMessage.withHeader(newHeader);
+                    }
+                }
+            }
+            // Fix body/footer line length
+            if (error.includes("footer's lines must not be longer than") || error.includes("body's lines must not be longer than")) {
+                const maxLengthNumbers = error.match(/\d+/g) ?? [];
+                if (maxLengthNumbers.length > 0 && maxLengthNumbers[0]) {
+                    const maxLength = Number.parseInt(maxLengthNumbers[0], 10);
+                    const body = fixedMessage.getBody();
+                    // Wrap body lines
+                    const wrappedBody = this.wrapText(body.getContent(), maxLength);
+                    const wrappedBreaking = this.wrapText(body.getBreakingChange(), maxLength);
+                    const newBody = new commitBody_valueObject.CommitBody(wrappedBody, wrappedBreaking);
+                    fixedMessage = fixedMessage.withBody(newBody);
+                }
+            }
+        }
+        // Validate the fixed message
+        const fixedValidation = await this.validate(fixedMessage);
+        if (fixedValidation.isValid) {
+            process.stdout.write("Simple fixes successful!\n");
+            return fixedMessage;
+        }
+        // If still invalid, return null
+        process.stdout.write("Simple fixes failed to resolve all validation errors\n");
+        return null;
+    }
+    /**
+     * Set the LLM configuration for this validator
+     * @param {LLMConfiguration} configuration - The LLM configuration to set
+     */
+    setLLMConfiguration(configuration) {
+        this.llmConfiguration = configuration;
+    }
+    /**
+     * Validate a commit message using commitlint
+     * @param {CommitMessage} message - The commit message to validate
+     * @returns {Promise<ICommitValidationResult>} Promise resolving to the validation result
+     */
+    async validate(message) {
+        const loadResult = await load();
+        const { rules = {} } = loadResult;
+        const result = await lint(message.toString(), rules);
+        return {
+            errors: result.errors.map((error) => error.message),
+            isValid: result.valid,
+            warnings: result.warnings.map((warning) => warning.message),
+        };
+    }
+    /**
+     * Wrap text to ensure no line exceeds the specified length
+     * @param {string | undefined} text - The text to wrap
+     * @param {number} maxLength - Maximum line length
+     * @returns {string | undefined} The wrapped text
+     */
+    wrapText(text, maxLength) {
+        if (!text) {
+            return text;
+        }
+        const lines = text.split("\n");
+        const wrappedLines = [];
+        for (const line of lines) {
+            if (line.length <= maxLength) {
+                wrappedLines.push(line);
+            }
+            else {
+                // Simple word wrap
+                const words = line.split(" ");
+                let currentLine = "";
+                for (const word of words) {
+                    if (currentLine.length + word.length + 1 <= maxLength) {
+                        currentLine += (currentLine ? " " : "") + word;
+                    }
+                    else {
+                        if (currentLine) {
+                            wrappedLines.push(currentLine);
+                        }
+                        currentLine = word;
+                    }
+                }
+                if (currentLine) {
+                    wrappedLines.push(currentLine);
+                }
+            }
+        }
+        return wrappedLines.join("\n");
+    }
+}
+
+exports.CommitlintValidatorService = CommitlintValidatorService;
+//# sourceMappingURL=commitlint-validator.service.js.map