feat: Add customizable commit prefixes for version bumping (#159)

* Initial plan

* Implement core custom prefix functionality for CLI and conventionalcommits package

Co-authored-by: goloroden <906327+goloroden@users.noreply.github.com>

* Complete implementation with precedence handling, comprehensive tests, and documentation

Co-authored-by: goloroden <906327+goloroden@users.noreply.github.com>

* Refactor to instance-based TypeClassifier, eliminating global state

Co-authored-by: goloroden <906327+goloroden@users.noreply.github.com>

* Remove unnecessary comments that explain 'what' instead of 'why'

Co-authored-by: goloroden <906327+goloroden@users.noreply.github.com>

* Address PR review feedback: remove global state, fix documentation, clean up code

Co-authored-by: goloroden <906327+goloroden@users.noreply.github.com>

* Remove empty init.go file and fix double newline in type.go

Co-authored-by: goloroden <906327+goloroden@users.noreply.github.com>

* Remove accidentally committed binary file

Co-authored-by: goloroden <906327+goloroden@users.noreply.github.com>

---------

Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com>
Co-authored-by: goloroden <906327+goloroden@users.noreply.github.com>

Author: Copilot

README.md

@@ -76,6 +76,10 @@ jobs:
       uses: thenativeweb/get-next-version@main
       with:
         prefix: 'v' # optional, defaults to ''
+        # Optional: customize commit prefixes
+        # fix_prefixes: 'fix,deps,perf'
+        # feature_prefixes: 'feat,enhance'  
+        # chore_prefixes: 'chore,docs,style'
     - name: Show the next version
       run: |
         echo ${{ steps.get_next_version.outputs.version }}
@@ -98,4 +102,48 @@ Some examples for commit messages are shown below:
 - `feat: Add support for Node.js 18`
 - `feat!: Change API from v1 to v2`
 
-Please note that `!` indicates breaking changes, and will always result in a new major version, independent of the type of change.
+## Customizing commit prefixes
+
+By default, `get-next-version` uses the following commit prefixes:
+
+- Feature prefixes (minor version bump): `feat`
+- Fix prefixes (patch version bump): `fix`
+- Chore prefixes (no version bump): `build`, `chore`, `ci`, `docs`, `style`, `refactor`, `perf`, `test`
+
+You can customize these prefixes to match your project's conventions using CLI flags or GitHub Action inputs.
+
+### Using CLI
+
+Use comma-separated values for custom prefixes:
+
+```sh
+# Add 'deps' and 'perf' as fix prefixes (patch version bump)
+get-next-version --fix-prefixes "fix,deps,perf"
+
+# Add 'enhance' as a feature prefix (minor version bump)  
+get-next-version --feature-prefixes "feat,enhance"
+
+# Customize chore prefixes (no version bump)
+get-next-version --chore-prefixes "chore,docs,style"
+
+# Combine multiple custom prefixes
+get-next-version --fix-prefixes "fix,deps" --feature-prefixes "feat,enhance"
+```
+
+### Using GitHub Action
+
+When using the GitHub Action, specify custom prefixes as inputs:
+
+```yaml
+- name: Get next version
+  id: get_next_version
+  uses: thenativeweb/get-next-version@main
+  with:
+    fix_prefixes: 'fix,deps,perf'
+    feature_prefixes: 'feat,enhance'
+    chore_prefixes: 'chore,docs,style'
+```
+
+When you specify custom prefixes, they completely replace the defaults for that category. If you want to keep the defaults and add new ones, include them explicitly in your custom list.
+
+Note that `!` indicates breaking changes, and will always result in a new major version, independent of the type of change.

action.yml.tpl

@@ -7,6 +7,18 @@ inputs:
     description: 'Sets the version prefix'
     required: false
     default: ''
+  feature_prefixes:
+    description: 'Sets custom feature prefixes (comma-separated)'
+    required: false
+    default: ''
+  fix_prefixes:
+    description: 'Sets custom fix prefixes (comma-separated)'
+    required: false
+    default: ''
+  chore_prefixes:
+    description: 'Sets custom chore prefixes (comma-separated)'
+    required: false
+    default: ''
 outputs:
   version:
     description: 'Next version'

action/entrypoint.sh

@@ -5,4 +5,7 @@ set -e
 /action/get-next-version \
   --repository /github/workspace \
   --target github-action \
-  --prefix "$INPUT_PREFIX"
+  --prefix "$INPUT_PREFIX" \
+  --feature-prefixes "$INPUT_FEATURE_PREFIXES" \
+  --fix-prefixes "$INPUT_FIX_PREFIXES" \
+  --chore-prefixes "$INPUT_CHORE_PREFIXES"

cli/root.go

@@ -1,10 +1,13 @@
 package cli
 
 import (
+	"strings"
+	
 	"github.com/Masterminds/semver"
 	gogit "github.com/go-git/go-git/v5"
 	"github.com/rs/zerolog/log"
 	"github.com/spf13/cobra"
+	"github.com/thenativeweb/get-next-version/conventionalcommits"
 	"github.com/thenativeweb/get-next-version/git"
 	"github.com/thenativeweb/get-next-version/target"
 	"github.com/thenativeweb/get-next-version/util"
@@ -13,15 +16,21 @@ import (
 )
 
 var (
-	rootRepositoryFlag string
-	rootTargetFlag     string
-	rootPrefixFlag     string
+	rootRepositoryFlag      string
+	rootTargetFlag          string
+	rootPrefixFlag          string
+	rootFeaturePrefixesFlag string
+	rootFixPrefixesFlag     string
+	rootChorePrefixesFlag   string
 )
 
 func init() {
 	RootCommand.Flags().StringVarP(&rootRepositoryFlag, "repository", "r", ".", "sets the path to the repository")
 	RootCommand.Flags().StringVarP(&rootTargetFlag, "target", "t", "version", "sets the output target")
 	RootCommand.Flags().StringVarP(&rootPrefixFlag, "prefix", "p", "", "sets the version prefix")
+	RootCommand.Flags().StringVar(&rootFeaturePrefixesFlag, "feature-prefixes", "", "sets custom feature prefixes (comma-separated)")
+	RootCommand.Flags().StringVar(&rootFixPrefixesFlag, "fix-prefixes", "", "sets custom fix prefixes (comma-separated)")
+	RootCommand.Flags().StringVar(&rootChorePrefixesFlag, "chore-prefixes", "", "sets custom chore prefixes (comma-separated)")
 }
 
 var RootCommand = &cobra.Command{
@@ -43,14 +52,16 @@ var RootCommand = &cobra.Command{
 			log.Fatal().Msg("invalid target")
 		}
 
+		classifier := createTypeClassifier()
+
 		repository, err := gogit.PlainOpen(rootRepositoryFlag)
 		if err != nil {
 			log.Fatal().Msg(err.Error())
 		}
 
 		var nextVersion semver.Version
 		var hasNextVersion bool
-		result, err := git.GetConventionalCommitTypesSinceLastRelease(repository)
+		result, err := git.GetConventionalCommitTypesSinceLastRelease(repository, classifier)
 		if err != nil {
 			log.Fatal().Msg(err.Error())
 		} else {
@@ -63,3 +74,36 @@ var RootCommand = &cobra.Command{
 		}
 	},
 }
+
+func createTypeClassifier() *conventionalcommits.TypeClassifier {
+	var choreTypes, fixTypes, featureTypes []string
+	
+	if rootChorePrefixesFlag != "" {
+		choreTypes = parseCommaSeparatedPrefixes(rootChorePrefixesFlag)
+	}
+	
+	if rootFixPrefixesFlag != "" {
+		fixTypes = parseCommaSeparatedPrefixes(rootFixPrefixesFlag)
+	}
+	
+	if rootFeaturePrefixesFlag != "" {
+		featureTypes = parseCommaSeparatedPrefixes(rootFeaturePrefixesFlag)
+	}
+	
+	return conventionalcommits.NewTypeClassifierWithCustomPrefixes(choreTypes, fixTypes, featureTypes)
+}
+
+func parseCommaSeparatedPrefixes(input string) []string {
+	if input == "" {
+		return nil
+	}
+	
+	var result []string
+	for _, prefix := range strings.Split(input, ",") {
+		trimmed := strings.TrimSpace(prefix)
+		if trimmed != "" {
+			result = append(result, trimmed)
+		}
+	}
+	return result
+}

conventionalcommits/commit_message.go

@@ -10,14 +10,13 @@ import (
 )
 
 var (
-	bodyRegex             *regexp.Regexp
 	breakingFooterTokens  = []string{"BREAKING CHANGE", "BREAKING-CHANGE"}
 	footerTokenSeparators = []string{": ", " #"}
 )
 
-func initCommitMessage() {
+func createBodyRegex(classifier *TypeClassifier) *regexp.Regexp {
 	typesRegexString := ""
-	for _, prefix := range allTypes {
+	for _, prefix := range classifier.GetAllTypes() {
 		typesRegexString += prefix + "|"
 	}
 	typesRegexString = strings.TrimSuffix(typesRegexString, "|")
@@ -26,7 +25,7 @@ func initCommitMessage() {
 		typesRegexString,
 	)
 
-	bodyRegex = regexp.MustCompile(conventionalCommitBodyRegexString)
+	return regexp.MustCompile(conventionalCommitBodyRegexString)
 }
 
 func splitCommitMessage(message string) (body string, footers []string) {
@@ -57,7 +56,7 @@ func splitCommitMessage(message string) (body string, footers []string) {
 	return body, footers
 }
 
-func CommitMessageToType(message string) (Type, error) {
+func CommitMessageToTypeWithClassifier(message string, classifier *TypeClassifier) (Type, error) {
 	body, footers := splitCommitMessage(message)
 
 	var breakingFooterPrefixes []string
@@ -72,6 +71,7 @@ func CommitMessageToType(message string) (Type, error) {
 		}
 	}
 
+	bodyRegex := createBodyRegex(classifier)
 	parsedMessageBody := bodyRegex.FindStringSubmatch(body)
 	if parsedMessageBody == nil {
 		return Chore, errors.New("invalid message body for conventional commit message")
@@ -85,5 +85,5 @@ func CommitMessageToType(message string) (Type, error) {
 
 	typeIndex := util.MustFind(bodyRegex.SubexpNames(), "type")
 
-	return StringToType(parsedMessageBody[typeIndex])
+	return classifier.StringToType(parsedMessageBody[typeIndex])
 }

conventionalcommits/commit_message_test.go

@@ -8,6 +8,8 @@ import (
 )
 
 func TestCommitMessageToType(t *testing.T) {
+	classifier := conventionalcommits.NewTypeClassifier()
+	
 	tests := []struct {
 		message            string
 		doExpectError      bool
@@ -32,7 +34,7 @@ func TestCommitMessageToType(t *testing.T) {
 	}
 
 	for _, test := range tests {
-		commitType, err := conventionalcommits.CommitMessageToType(test.message)
+		commitType, err := conventionalcommits.CommitMessageToTypeWithClassifier(test.message, classifier)
 
 		if test.doExpectError {
 			assert.Error(t, err)

conventionalcommits/init.go

@@ -16,29 +16,70 @@ const (
 )
 
 var (
-	choreTypes   = []string{"build", "chore", "ci", "docs", "style", "refactor", "perf", "test"}
-	fixTypes     = []string{"fix"}
-	featureTypes = []string{"feat"}
-	allTypes     []string
+	defaultChoreTypes   = []string{"build", "chore", "ci", "docs", "style", "refactor", "perf", "test"}
+	defaultFixTypes     = []string{"fix"}
+	defaultFeatureTypes = []string{"feat"}
 )
 
-func initType() {
-	for _, types := range [][]string{choreTypes, fixTypes, featureTypes} {
+type TypeClassifier struct {
+	choreTypes   []string
+	fixTypes     []string
+	featureTypes []string
+}
+
+func NewTypeClassifier() *TypeClassifier {
+	return &TypeClassifier{
+		choreTypes:   append([]string{}, defaultChoreTypes...),
+		fixTypes:     append([]string{}, defaultFixTypes...),
+		featureTypes: append([]string{}, defaultFeatureTypes...),
+	}
+}
+
+func NewTypeClassifierWithCustomPrefixes(customChoreTypes, customFixTypes, customFeatureTypes []string) *TypeClassifier {
+	tc := &TypeClassifier{}
+	
+	if len(customChoreTypes) > 0 {
+		tc.choreTypes = customChoreTypes
+	} else {
+		tc.choreTypes = append([]string{}, defaultChoreTypes...)
+	}
+	
+	if len(customFixTypes) > 0 {
+		tc.fixTypes = customFixTypes
+	} else {
+		tc.fixTypes = append([]string{}, defaultFixTypes...)
+	}
+	
+	if len(customFeatureTypes) > 0 {
+		tc.featureTypes = customFeatureTypes
+	} else {
+		tc.featureTypes = append([]string{}, defaultFeatureTypes...)
+	}
+	
+	return tc
+}
+
+func (tc *TypeClassifier) GetAllTypes() []string {
+	var allTypes []string
+	for _, types := range [][]string{tc.choreTypes, tc.fixTypes, tc.featureTypes} {
 		allTypes = append(allTypes, types...)
 	}
+	return allTypes
 }
 
-func StringToType(s string) (Type, error) {
-	if slices.Contains(choreTypes, strings.ToLower(s)) {
-		return Chore, nil
+func (tc *TypeClassifier) StringToType(s string) (Type, error) {
+	lowerS := strings.ToLower(s)
+	
+	if slices.Contains(tc.featureTypes, lowerS) {
+		return Feature, nil
 	}
 
-	if slices.Contains(fixTypes, strings.ToLower(s)) {
+	if slices.Contains(tc.fixTypes, lowerS) {
 		return Fix, nil
 	}
 
-	if slices.Contains(featureTypes, strings.ToLower(s)) {
-		return Feature, nil
+	if slices.Contains(tc.choreTypes, lowerS) {
+		return Chore, nil
 	}
 
 	return Chore, errors.New("invalid string for conventional commit type")