feat: add non-conventional-commit-type setting for legacy commits

Add optional `non-conventional-commit-type` configuration setting that treats
non-conventional commits as a specified commit type (e.g., 'fix', 'feat', 'chore').
This enables version bumping when merging legacy code that doesn't follow
conventional commit standards.

Fully backward compatible - feature disabled by default.

Fixes #2623.

Author: rabadin

schemas/config.json

@@ -20,6 +20,10 @@
           "description": "Feature changes only bump semver patch if version < 1.0.0",
           "type": "boolean"
         },
+        "non-conventional-commit-type": {
+          "description": "Treat non-conventional commits as if they were conventional commits with the specified type (e.g., 'fix', 'feat', 'chore'). When not set, non-conventional commits are ignored.",
+          "type": "string"
+        },
         "prerelease-type": {
           "description": "Configuration option for the prerelease versioning strategy. If prerelease strategy used and type set, will set the prerelease part of the version to the provided value in case prerelease part is not present.",
           "type": "string"

src/commit.ts

@@ -399,14 +399,17 @@ function splitMessages(message: string): string[] {
  * Given a list of raw commits, parse and expand into conventional commits.
  *
  * @param commits {Commit[]} The input commits
+ * @param logger {Logger} The logger to use for debug messages
+ * @param nonConventionalCommitType {string} If set, treat non-conventional commits as this commit type (e.g., 'fix', 'feat')
  *
  * @returns {ConventionalCommit[]} Parsed and expanded commits. There may be
  *   more commits returned as a single raw commit may contain multiple release
  *   messages.
  */
 export function parseConventionalCommits(
   commits: Commit[],
-  logger: Logger = defaultLogger
+  logger: Logger = defaultLogger,
+  nonConventionalCommitType?: string
 ): ConventionalCommit[] {
   const conventionalCommits: ConventionalCommit[] = [];
 
@@ -439,6 +442,24 @@ export function parseConventionalCommits(
           }`
         );
         logger.debug(`error message: ${_err}`);
+        // If nonConventionalCommitType is set, treat non-conventional commits as the specified type
+        if (nonConventionalCommitType) {
+          logger.debug(
+            `treating non-conventional commit as '${nonConventionalCommitType}': ${commit.sha}`
+          );
+          conventionalCommits.push({
+            sha: commit.sha,
+            message: commitMessage,
+            files: commit.files,
+            pullRequest: commit.pullRequest,
+            type: nonConventionalCommitType,
+            scope: null,
+            bareMessage: commitMessage.split('\n')[0],
+            notes: [],
+            references: [],
+            breaking: false,
+          });
+        }
       }
     }
   }

src/manifest.ts

@@ -101,6 +101,7 @@ export interface ReleaserConfig {
   bumpMinorPreMajor?: boolean;
   bumpPatchForMinorPreMajor?: boolean;
   prereleaseType?: string;
+  nonConventionalCommitType?: string;
 
   // Strategy options
   releaseAs?: string;
@@ -160,6 +161,7 @@ interface ReleaserConfigJson {
   'bump-minor-pre-major'?: boolean;
   'bump-patch-for-minor-pre-major'?: boolean;
   'prerelease-type'?: string;
+  'non-conventional-commit-type'?: string;
   'changelog-sections'?: ChangelogSection[];
   'release-as'?: string;
   'skip-github-release'?: boolean;
@@ -733,7 +735,8 @@ export class Manifest {
       this.logger.debug(`targetBranch: ${this.targetBranch}`);
       let pathCommits = parseConventionalCommits(
         commitsPerPath[path],
-        this.logger
+        this.logger,
+        config.nonConventionalCommitType
       );
       // The processCommits hook can be implemented by plugins to
       // post-process commits. This can be used to perform cleanup, e.g,, sentence
@@ -1377,6 +1380,7 @@ function extractReleaserConfig(
     bumpMinorPreMajor: config['bump-minor-pre-major'],
     bumpPatchForMinorPreMajor: config['bump-patch-for-minor-pre-major'],
     prereleaseType: config['prerelease-type'],
+    nonConventionalCommitType: config['non-conventional-commit-type'],
     versioning: config['versioning'],
     changelogSections: config['changelog-sections'],
     changelogPath: config['changelog-path'],

test/commits.ts

@@ -282,6 +282,77 @@ describe('parseConventionalCommits', () => {
   //   expect(conventionalCommits[0].type).to.equal('docs');
   //   expect(conventionalCommits[0].scope).is.null;
   // });
+
+  it('ignores non-conventional commits by default', async () => {
+    const commits = [
+      buildMockCommit('feat: some feature'),
+      buildMockCommit('this is a non-conventional commit'),
+      buildMockCommit('fix: some bugfix'),
+    ];
+    const conventionalCommits = parseConventionalCommits(commits);
+    expect(conventionalCommits).lengthOf(2);
+    expect(conventionalCommits[0].type).to.equal('feat');
+    expect(conventionalCommits[1].type).to.equal('fix');
+  });
+
+  it('treats non-conventional commits as fix when alias is "fix"', async () => {
+    const commits = [
+      buildMockCommit('feat: some feature'),
+      buildMockCommit('this is a non-conventional commit'),
+      buildMockCommit('fix: some bugfix'),
+    ];
+    const conventionalCommits = parseConventionalCommits(
+      commits,
+      undefined,
+      'fix'
+    );
+    expect(conventionalCommits).lengthOf(3);
+    expect(conventionalCommits[0].type).to.equal('feat');
+    expect(conventionalCommits[1].type).to.equal('fix');
+    expect(conventionalCommits[1].bareMessage).to.equal(
+      'this is a non-conventional commit'
+    );
+    expect(conventionalCommits[1].scope).is.null;
+    expect(conventionalCommits[1].breaking).to.be.false;
+    expect(conventionalCommits[2].type).to.equal('fix');
+  });
+
+  it('treats non-conventional commits as chore when alias is "chore"', async () => {
+    const commits = [buildMockCommit('regular commit message without type')];
+    const conventionalCommits = parseConventionalCommits(
+      commits,
+      undefined,
+      'chore'
+    );
+    expect(conventionalCommits).lengthOf(1);
+    expect(conventionalCommits[0].type).to.equal('chore');
+    expect(conventionalCommits[0].bareMessage).to.equal(
+      'regular commit message without type'
+    );
+  });
+
+  it('preserves files, empty notes and references when using non-conventional alias', async () => {
+    const commits = [
+      buildMockCommit('non-conventional commit', [
+        'path1/file1.txt',
+        'path2/file2.txt',
+      ]),
+    ];
+    const conventionalCommits = parseConventionalCommits(
+      commits,
+      undefined,
+      'fix'
+    );
+    expect(conventionalCommits).lengthOf(1);
+    expect(conventionalCommits[0].type).to.equal('fix');
+    expect(conventionalCommits[0].files).to.deep.equal([
+      'path1/file1.txt',
+      'path2/file2.txt',
+    ]);
+    expect(conventionalCommits[0].notes).to.be.empty;
+    expect(conventionalCommits[0].references).to.be.empty;
+    expect(conventionalCommits[0].breaking).to.be.false;
+  });
 });
 
 function assertHasCommit(

test/util/filter-commits.ts

@@ -89,4 +89,49 @@ describe('filterCommits', () => {
     ]);
     expect(commits.length).to.equal(1);
   });
+  it('includes non-conventional commits converted to fix type', () => {
+    const commits = filterCommits([
+      {
+        type: 'fix',
+        notes: [],
+        references: [],
+        bareMessage: 'update readme',
+        message: 'update readme',
+        scope: null,
+        breaking: false,
+        sha: 'abc123',
+      },
+    ]);
+    expect(commits.length).to.equal(1);
+  });
+  it('includes non-conventional commits converted to feat type', () => {
+    const commits = filterCommits([
+      {
+        type: 'feat',
+        notes: [],
+        references: [],
+        bareMessage: 'add new feature',
+        message: 'add new feature',
+        scope: null,
+        breaking: false,
+        sha: 'def456',
+      },
+    ]);
+    expect(commits.length).to.equal(1);
+  });
+  it('excludes non-conventional commits converted to chore type', () => {
+    const commits = filterCommits([
+      {
+        type: 'chore',
+        notes: [],
+        references: [],
+        bareMessage: 'update dependencies',
+        message: 'update dependencies',
+        scope: null,
+        breaking: false,
+        sha: 'ghi789',
+      },
+    ]);
+    expect(commits.length).to.equal(0);
+  });
 });