Skip update test in CI.

.github/ISSUE_TEMPLATE/bug_report.md

@@ -1,20 +0,0 @@
----
-name: Bug report
-about: Create a report to help us improve
-title: ''
-labels: bug, to be confirmed
-assignees: lukaszraczylo
-
----
-
-**Describe the bug**
-A clear and concise description of what the bug is.
-
-**Output with debug**
-[ paste output of the command with `-d` flag here ]
-
-**Expected behavior**
-A clear and concise description of what you expected to happen.
-
-**Additional context**
-Add any other context about the problem here.

.github/dependabot.yml

@@ -1,11 +0,0 @@
-# To get started with Dependabot version updates, you'll need to specify which
-# package ecosystems to update and where the package manifests are located.
-# Please see the documentation for all configuration options:
-# https://docs.github.com/github/administering-a-repository/configuration-options-for-dependency-updates
-
-version: 2
-updates:
-  - package-ecosystem: "gomod" # See documentation for possible values
-    directory: "/" # Location of package manifests
-    schedule:
-      interval: "weekly"

.github/workflows/autoupdate.yaml

@@ -1,20 +0,0 @@
-name: Autoupdate go.mod and go.sum
-
-on:
-  workflow_dispatch:
-  schedule:
-    - cron: "0 3 * * *"
-
-permissions:
-  contents: write
-  actions: write
-  pull-requests: write
-
-jobs:
-  autoupdate:
-    uses: lukaszraczylo/shared-actions/.github/workflows/go-autoupdate.yaml@main
-    with:
-      go-version: "1.24"
-      release-workflow: "release.yaml"
-    secrets:
-      pat-token: ${{ secrets.HOMEBREW_TAP_TOKEN }}

.github/workflows/pr.yaml

@@ -1,16 +0,0 @@
-name: Pull Request
-
-on:
-  pull_request:
-    branches:
-      - main
-  push:
-    branches:
-      - "**"
-      - "!main"
-
-jobs:
-  pr-checks:
-    uses: lukaszraczylo/shared-actions/.github/workflows/go-pr.yaml@main
-    with:
-      go-version: "1.24"

.github/workflows/release.yaml

@@ -1,26 +1,219 @@
-name: Test, build, release
+name: Test, scan, build, release
 
 on:
   workflow_dispatch:
   push:
     paths-ignore:
-      - '**.md'
-      - '**/release.yaml'
-      - 'action.yml'
+    - '**.md'
+    - '**/release.yaml'
     branches:
-      - main
+      - "master"
+      - "main"
 
-permissions:
-  id-token: write
-  contents: write
-  packages: write
+env:
+  ENABLE_CODE_LINT: false
+  ENABLE_CODE_SCANS: false
+  DEPLOY: false
 
 jobs:
-  release:
-    uses: lukaszraczylo/shared-actions/.github/workflows/go-release.yaml@main
-    with:
-      go-version: "1.24"
-      docker-enabled: true
-      rolling-release-tag: "v1"
-      semver-config: "config-release.yaml"
-    secrets: inherit
+  prepare:
+    name: Preparing build context
+    runs-on: ubuntu-latest
+    outputs:
+      SANITISED_REPOSITORY_NAME: ${{ steps.get_env.outputs.SANITISED_REPOSITORY_NAME }}
+      DOCKER_IMAGE: ${{ steps.get_env.outputs.DOCKER_IMAGE }}
+      GITHUB_COMMIT_NUMBER: ${{ steps.get_env.outputs.GITHUB_COMMIT_NUMBER }}
+      GITHUB_SHA: ${{ steps.get_env.outputs.GITHUB_SHA }}
+      GITHUB_RUN_ID: ${{ steps.get_env.outputs.GITHUB_RUN_ID }}
+      RELEASE_VERSION: ${{ steps.get_env.outputs.RELEASE_VERSION }}
+    steps:
+      - name: Checkout repo
+        uses: actions/checkout@v2
+        with:
+          fetch-depth: '0'
+      - name: Setting environment variables
+        id: get_env
+        run: |
+          DOWNLOAD_URL=$(curl -s https://api.github.com/repos/lukaszraczylo/semver-generator/releases/latest \
+            | grep browser_download_url \
+            | grep semver-gen-linux-amd64 \
+            | cut -d '"' -f 4)
+          curl -s -L -o semver-gen "$DOWNLOAD_URL" && chmod +x semver-gen
+          TMP_SANITISED_REPOSITORY_NAME=$(echo ${{ github.event.repository.name }} | sed -e 's|\.|-|g')
+          TMP_GITHUB_COMMITS_COUNT=$(git rev-list --count HEAD)
+          TMP_GITHUB_COUNT_NUMBER=$(echo ${GITHUB_RUN_NUMBER})
+          TMP_RELEASE_VERSION=$(./semver-gen generate -l -c config-release.yaml | sed -e 's|SEMVER ||g')
+          echo "::set-output name=SANITISED_REPOSITORY_NAME::$TMP_SANITISED_REPOSITORY_NAME"
+          echo "::set-output name=DOCKER_IMAGE::ghcr.io/${{ github.repository_owner }}/$TMP_SANITISED_REPOSITORY_NAME"
+          echo "::set-output name=GITHUB_COMMIT_NUMBER::$TMP_GITHUB_COMMITS_COUNT"
+          echo "::set-output name=GITHUB_SHA::$(echo ${GITHUB_SHA::8})"
+          echo "::set-output name=GITHUB_RUN_ID::$TMP_GITHUB_COUNT_NUMBER"
+          echo "::set-output name=RELEASE_VERSION::$TMP_RELEASE_VERSION"
+
+  test:
+    needs: [ prepare ]
+    name: Code checks pipeline
+    runs-on: ubuntu-20.04
+    container: github/super-linter:v3.15.5
+    env:
+      CI: true
+    steps:
+      - name: Checkout repo
+        uses: actions/checkout@v2
+      - name: Lint Code Base
+        if: env.ENABLE_CODE_LINT == true
+        env:
+          VALIDATE_ALL_CODEBASE: true
+          VALIDATE_DOCKERFILE: false # this leaves us with hadolint only
+          VALIDATE_GO: false # disable bulk validation of go files, run the linter manually
+          DEFAULT_BRANCH: main
+          GITHUB_TOKEN: ${{ secrets.GHCR_TOKEN }}
+          LOG_LEVEL: WARN
+        run: |
+          golangci-lint run --exclude-use-default ./...
+          /action/lib/linter.sh
+      - name: Run unit tests
+        env:
+          GITHUB_TOKEN: ${{ secrets.GHCR_TOKEN }}
+        run: |
+          make test CI_RUN=${CI}
+      - name: Upload codecov result
+        uses: codecov/codecov-action@v1
+        continue-on-error: true
+        with:
+          token: ${{ secrets.CODECOV_TOKEN }} # not required for public repos
+          files: coverage.out
+
+  code_scans:
+    needs: [ prepare ]
+    name: Code scans pipeline
+    runs-on: ubuntu-20.04
+    steps:
+      - name: Checkout repo
+        uses: actions/checkout@v2
+      - name: Configure git for private modules
+        run: |
+          make update
+      - name: WriteGoList
+        run: go list -json -m all > go.list
+      - name: Running nancy
+        if: env.ENABLE_CODE_SCANS == true
+        uses: sonatype-nexus-community/nancy-github-action@main
+      - name: Running gosec
+        if: env.ENABLE_CODE_SCANS == true
+        uses: securego/gosec@master
+        with:
+          args: ./...
+
+  build:
+    needs: [ prepare, test, code_scans ]
+    name: Docker image build (regular:multiarch)
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repo
+        uses: actions/checkout@v2
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v1
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v1
+      - name: Login to GHCR
+        if: github.event_name != 'pull_request'
+        uses: docker/login-action@v1
+        with:
+          registry: ghcr.io
+          username: ${{ github.ACTOR }}
+          password: ${{ secrets.GHCR_TOKEN }}
+      - name: Prepare for push
+        id: prep
+        run: |
+          TAGS="${{ needs.prepare.outputs.DOCKER_IMAGE  }}:${{ needs.prepare.outputs.GITHUB_SHA }},${{ needs.prepare.outputs.DOCKER_IMAGE  }}:${{ needs.prepare.outputs.RELEASE_VERSION }},${{ needs.prepare.outputs.DOCKER_IMAGE  }}:latest"
+          echo ::set-output name=tags::${TAGS}
+          BRANCH=$(echo ${GITHUB_REF##*/} | tr '[A-Z]' '[a-z]')
+          LABELS="org.opencontainers.image.revision=${{ needs.prepare.outputs.GITHUB_SHA }}"
+          LABELS="$LABELS,org.opencontainers.image.created=$(date -u +'%Y-%m-%dT%H:%M:%SZ')"
+          LABELS="$LABELS,org.opencontainers.image.version=$VERSION"
+          LABELS="$LABELS,com.github.repo.branch=$BRANCH"
+          LABELS="$LABELS,com.github.repo.dockerfile=Dockerfile"
+          echo ::set-output name=labels::${LABELS}
+          BUILD_ARGS="BRANCH=$BRANCH"
+          echo ::set-output name=args::${BUILD_ARGS}
+      - name: Build image
+        id: docker_build
+        uses: docker/build-push-action@v2
+        with:
+          builder: ${{ steps.buildx.outputs.name }}
+          platforms: linux/arm64,linux/amd64
+          push: ${{ github.ref == 'refs/heads/master' || github.ref == 'refs/heads/main' }}
+          tags: ${{ steps.prep.outputs.tags }}
+          build-args: |
+            GITHUB_AUTH_TOKEN=${{ secrets.GHCR_TOKEN }}
+            MICROSERVICE_NAME=${{ github.event.repository.name }}
+            GITHUB_COMMIT_NUMBER=${{ needs.prepare.outputs.GITHUB_COMMIT_NUMBER }}
+            GITHUB_SHA=${{ needs.prepare.outputs.GITHUB_SHA }}
+            ${{ steps.prep.outputs.args }}
+          labels: ${{ steps.prep.outputs.labels }}
+          no-cache: false
+      - name: Scan image
+        uses: anchore/scan-action@v2
+        if: ${{ github.ref == 'refs/heads/master' || github.ref == 'refs/heads/main' }}
+        with:
+          image: "${{ needs.prepare.outputs.DOCKER_IMAGE }}:${{ needs.prepare.outputs.GITHUB_SHA }}"
+          fail-build: true
+
+  build-binary:
+    needs: [ prepare, test, code_scans ]
+    name: Binary compilation and release
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v2
+        with:
+          fetch-depth: 0
+      - name: Compile binary
+        uses: thatisuday/go-cross-build@v1.0.2
+        with:
+          platforms: linux/amd64,darwin/amd64,windows/amd64,linux/arm64,darwin/amd64,darwin/arm64
+          name: semver-gen
+          package: ./
+          compress: false
+          dest: dist
+          ldflags: -s -w -X main.PKG_VERSION=${{ needs.prepare.outputs.RELEASE_VERSION }}
+      - name: Get list of the commits since last release
+        run: |
+          echo "$(git log $(git describe --tags --abbrev=0)..HEAD --pretty=format:"%h %s")" > .release_notes
+      - name: Create Release
+        id: create_release
+        uses: marvinpinto/action-automatic-releases@latest
+        if: ${{ github.ref == 'refs/heads/master' || github.ref == 'refs/heads/main' }}
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          repo_token: ${{ secrets.GITHUB_TOKEN }}
+          files: dist/semver-gen-*
+          automatic_release_tag: ${{ needs.prepare.outputs.RELEASE_VERSION }}
+          title: version ${{ needs.prepare.outputs.RELEASE_VERSION }}
+          # tag: ${{ needs.prepare.outputs.RELEASE_VERSION }}
+          # name: ${{ needs.prepare.outputs.RELEASE_VERSION }}
+          # body_path: .release_notes
+          # draft: false
+          prerelease: ${{ github.ref != 'refs/heads/master' && github.ref != 'refs/heads/main' }}
+      # - name: Delete previous v1 release asset
+      #   uses: mknejp/delete-release-assets@v1
+      #   with:
+      #     token: ${{ github.token }}
+      #     fail-if-no-assets: false
+      #     fail-if-no-release: false
+      #     tag: v1
+      #     assets: 'semver-gen-*'
+      - name: Create Release V1
+        id: create_release_global
+        uses: marvinpinto/action-automatic-releases@latest
+        if: ${{ github.ref == 'refs/heads/master' || github.ref == 'refs/heads/main' }}
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          repo_token: ${{ secrets.GITHUB_TOKEN }}
+          files: dist/semver-gen-*
+          automatic_release_tag: v1
+          title: version v1:${{ needs.prepare.outputs.RELEASE_VERSION }}
+          prerelease: ${{ github.ref != 'refs/heads/master' && github.ref != 'refs/heads/main' }}

.github/workflows/static.yml

@@ -1,45 +0,0 @@
-# Simple workflow for deploying static content to GitHub Pages
-name: Deploy static content to Pages
-
-on:
-  # Runs on pushes targeting the default branch
-  push:
-    branches: ["main"]
-    paths:
-      - 'docs/**'
-
-  # Allows you to run this workflow manually from the Actions tab
-  workflow_dispatch:
-
-# Sets permissions of the GITHUB_TOKEN to allow deployment to GitHub Pages
-permissions:
-  contents: read
-  pages: write
-  id-token: write
-
-# Allow only one concurrent deployment, skipping runs queued between the run in-progress and latest queued.
-# However, do NOT cancel in-progress runs as we want to allow these production deployments to complete.
-concurrency:
-  group: "pages"
-  cancel-in-progress: false
-
-jobs:
-  # Single deploy job since we're just deploying
-  deploy:
-    environment:
-      name: github-pages
-      url: ${{ steps.deployment.outputs.page_url }}
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-      - name: Setup Pages
-        uses: actions/configure-pages@v5
-      - name: Upload artifact
-        uses: actions/upload-pages-artifact@v3
-        with:
-          # Upload entire repository
-          path: 'docs/'
-      - name: Deploy to GitHub Pages
-        id: deployment
-        uses: actions/deploy-pages@v4

.gitignore

@@ -1,4 +1,2 @@
 semver-gen
-coverage.out
-.vscode
-.DS_Store
+coverage.out

.goreleaser.yaml

@@ -1,109 +0,0 @@
-version: 2
-
-before:
-  hooks:
-    - go mod tidy
-
-builds:
-  - id: semver-gen
-    main: .
-    binary: semver-generator
-    env:
-      - CGO_ENABLED=0
-    goos:
-      - linux
-      - darwin
-      - windows
-    goarch:
-      - amd64
-      - arm64
-    ldflags:
-      - -s -w
-      - -X main.PKG_VERSION={{.Version}}
-
-archives:
-  - id: semver-gen
-    formats: [tar.gz]
-    name_template: "semver-generator-{{ .Os }}-{{ .Arch }}"
-    format_overrides:
-      - goos: windows
-        formats: [zip]
-    files:
-      - LICENSE
-      - README.md
-      - config.yaml
-
-checksum:
-  name_template: "semver-generator-checksums.txt"
-  algorithm: sha256
-
-changelog:
-  sort: asc
-  filters:
-    exclude:
-      - '^docs:'
-      - '^test:'
-      - '^Merge'
-      - '^WIP'
-      - '^Update go.mod'
-
-release:
-  github:
-    owner: lukaszraczylo
-    name: semver-generator
-  name_template: "version {{.Version}}"
-  draft: false
-  prerelease: auto
-
-dockers_v2:
-  - images:
-      - "ghcr.io/lukaszraczylo/semver-generator"
-    tags:
-      - "{{ .Version }}"
-      - "latest"
-      - "v1"
-    platforms:
-      - linux/amd64
-      - linux/arm64
-    dockerfile: Dockerfile.goreleaser
-    extra_files:
-      - config-release.yaml
-      - entrypoint.sh
-
-homebrew_casks:
-  - name: semver-generator
-    repository:
-      owner: lukaszraczylo
-      name: homebrew-taps
-      token: "{{ .Env.HOMEBREW_TAP_TOKEN }}"
-    directory: Casks
-    homepage: https://github.com/lukaszraczylo/semver-generator
-    description: "Automatic semantic version generator based on git commit messages"
-    license: MIT
-    hooks:
-      post:
-        install: |
-          if OS.mac?
-            system_command "/usr/bin/xattr",
-                           args: ["-dr", "com.apple.quarantine", "#{staged_path}/semver-generator"]
-          end
-
-signs:
-  - cmd: cosign
-    signature: "${artifact}.sigstore.json"
-    args:
-      - sign-blob
-      - "--bundle=${signature}"
-      - "${artifact}"
-      - "--yes"
-    artifacts: checksum
-    output: true
-
-docker_signs:
-  - cmd: cosign
-    artifacts: manifests
-    output: true
-    args:
-      - sign
-      - "${artifact}@${digest}"
-      - "--yes"

Dockerfile

@@ -1,10 +1,17 @@
-FROM golang:1-bullseye as baseimg
-WORKDIR /go/src/app
-COPY . /go/src/app/
-RUN CGO_ENABLED=1 make build
+# syntax=docker/dockerfile:1.2.1-labs
 
-FROM ubuntu:jammy
-COPY --from=baseimg /go/src/app/semver-gen /go/src/app/semver-gen
-COPY --from=baseimg /go/src/app/config-release.yaml /go/src/app/config.yaml
+FROM golang:1-alpine as baseimg
+
+RUN apk add make
+WORKDIR /go/src/app
+ENV GO111MODULE=on CGO_ENABLED=1 GOOS=linux
+COPY . /go/src/app/
+RUN make
+
+FROM alpine:latest
+RUN apk add --no-cache ca-certificates
+WORKDIR /go/src/app
+COPY --from=baseimg /go/src/app/semver-gen .
+COPY --from=baseimg /go/src/app/config-release.yaml config.yaml
 COPY --from=baseimg /go/src/app/entrypoint.sh /entrypoint.sh
 ENTRYPOINT ["/entrypoint.sh"]

Dockerfile.goreleaser

@@ -1,7 +0,0 @@
-FROM ubuntu:jammy
-ARG TARGETPLATFORM
-COPY ${TARGETPLATFORM}/semver-generator /go/src/app/semver-generator
-COPY config-release.yaml /go/src/app/config.yaml
-COPY entrypoint.sh /entrypoint.sh
-RUN chmod +x /entrypoint.sh
-ENTRYPOINT ["/entrypoint.sh"]

Makefile

@@ -1,51 +1,21 @@
-LOCAL_VERSION?=""
+LOCAL_VERSION?=$(shell semver-gen generate -l -c config-release.yaml | sed -e 's|SEMVER ||g')
 CI_RUN?=false
 ADDITIONAL_BUILD_FLAGS=""
-LDFLAGS=-s -w -X main.PKG_VERSION=${LOCAL_VERSION}
 
 ifeq ($(CI_RUN), true)
 	ADDITIONAL_BUILD_FLAGS="-test.short"
 endif
 
-ifneq ($(shell which semver-gen), "")
-	LOCAL_VERSION="0.0.0-dev"
-else
-	LOCAL_VERSION=$(shell semver-gen generate -l -c config-release.yaml | sed -e 's|SEMVER ||g')
-endif
+all: build
 
-.PHONY: help
-help:  ## display this help
-	@awk 'BEGIN {FS = ":.*##"; printf "\nUsage:\n  make \033[36m<target>\033[0m\n\nTargets:\n"} /^[a-zA-Z0-9_-]+:.*?##/ { printf "  \033[36m%-20s\033[0m %s\n", $$1, $$2 }' $(MAKEFILE_LIST)
-
-.PHONY: all
-all: build ## Build all targets
-
-.PHONY: build
-build: ## Build binary
+build:
 	go build -o semver-gen -ldflags="-s -w -X main.PKG_VERSION=${LOCAL_VERSION}" *.go
 
-# .PHONY: run
-# run: build ## Build binary and execute it
-# 	@./semver-gen
+run: build
+	@./semver-gen
 
-.PHONY: test
-test: ## Run whole test suite
+test:
 	@go test ./... $(ADDITIONAL_BUILD_FLAGS) -v -race -cover -coverprofile=coverage.out
 
-.PHONY: update
-update: ## Update dependencies
+update:
 	@go get -u ./...
-	@go mod tidy
-
-.PHONY: update-all
-update-all: ## Update all dependencies and sub-packages
-	@go get -u ./...
-
-dist-release: ## Build all binaries
-	rm -fr dist/ || true
-	mkdir -p dist/
-	CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -ldflags="$(LDFLAGS)" -a -installsuffix cgo -o dist/semver-gen-linux-amd64
-	CGO_ENABLED=0 GOOS=linux GOARCH=arm64 go build -ldflags="$(LDFLAGS)" -a -installsuffix cgo -o dist/semver-gen-linux-arm64
-	CGO_ENABLED=0 GOOS=darwin go build -ldflags="$(LDFLAGS)" -a -installsuffix cgo -o dist/semver-gen-darwin-amd64
-	CGO_ENABLED=0 GOOS=darwin GOARCH=arm64 go build -ldflags="$(LDFLAGS)" -a -installsuffix cgo -o dist/semver-gen-darwin-arm64
-	CGO_ENABLED=0 GOOS=windows GOARCH=amd64 go build -ldflags="$(LDFLAGS)" -a -installsuffix cgo -o dist/semver-gen-windows-amd64.exe

README.md

@@ -13,10 +13,9 @@ Project created overnight, to prove that management of semantic versioning is NO
     - [As a binary](#as-a-binary)
     - [As a github action](#as-a-github-action)
     - [As a docker container](#as-a-docker-container)
-    - [Calculations example \[standard\]](#calculations-example-standard)
-    - [Calculations example \[strict matching\]](#calculations-example-strict-matching)
+    - [Calculations example [standard]](#calculations-example-standard)
+    - [Calculations example [strict matching]](#calculations-example-strict-matching)
     - [Release candidates](#release-candidates)
-    - [Tag prefix stripping](#tag-prefix-stripping)
     - [Example configuration](#example-configuration)
   - [Good to know](#good-to-know)
 
@@ -30,12 +29,10 @@ Project created overnight, to prove that management of semantic versioning is NO
 
 * With flag `-e` or config `force.existing: true` the existing tags in versioning will be respected, helping you to avoid the version conflicts.
 * With config `force.commit: deadbeef` where `deadbeef` is the commit hash - calculations will start from the specified commit.
-* Tag prefix stripping: The `v` prefix is automatically stripped from tags (e.g., `v1.2.3` → `1.2.3`). Additional prefixes can be configured via `tag_prefixes` for monorepo setups (e.g., `app-1.2.3`, `infra-1.2.3`).
 
 ### Important changes
 
 * From version `1.4.2+` as pointed out in [issue #12](https://github.com/lukaszraczylo/semver-generator/issues/12) commits from merge will not be included in the calculations and commits themselves will bump the version on first match ( starting checks from `patch` upwards ).
-* Added support for blacklisting terms to ignore specific commits, branch names, and merge messages from version calculations.
 
 ### Usage
 
@@ -51,23 +48,15 @@ export GITHUB_TOKEN=yourPersonalApiToken
 
 #### As a binary
 
-##### Homebrew (macOS)
-
-```bash
-brew install --cask lukaszraczylo/taps/semver-generator
-```
-
-##### Manual Download
-
 You can download latest versions of the binaries from the [release page](https://github.com/lukaszraczylo/semver-generator/releases/latest).
 
 **Supported OS and architectures:**
 Darwin ARM64/AMD64, Linux ARM64/AMD64, Windows AMD64
 
 ```bash
-bash$ semver-generator generate -r https://github.com/nextapps-de/winbox
+bash$ ./semver-gen generate -r https://github.com/nextapps-de/winbox
 SEMVER 9.0.10
-bash$ semver-generator generate -l
+bash$ ./semver-gen generate -l
 SEMVER 5.1.1
 ```
 
@@ -75,8 +64,8 @@ SEMVER 5.1.1
 
 ```yaml
 Usage:
-  semver-generator generate [flags]
-  semver-generator [command]
+  semver-gen generate [flags]
+  semver-gen [command]
 
 Available Commands:
   generate    Generates semantic version
@@ -86,25 +75,14 @@ Flags:
   -c, --config string       Path to config file (default "semver.yaml")
   -d, --debug               Enable debug mode
   -e, --existing            Respect existing tags
-  -h, --help                help for semver-generator
+  -h, --help                help for semver-gen
   -l, --local               Use local repository
   -r, --repository string   Remote repository URL. (default "https://github.com/lukaszraczylo/simple-gql-client")
-  -b, --branch string       Remote repository URL Branch. (default "main")
   -s, --strict              Strict matching
-  -u, --update              Update binary with latest (no authentication required)
+  -u, --update              Update binary with latest
   -v, --version             Display version
 ```
 
-##### Self-Update
-
-The binary can update itself to the latest version:
-
-```bash
-semver-generator -u
-```
-
-This downloads the latest release for your platform directly from GitHub releases. No authentication is required.
-
 #### As a github action
 
 ```yaml
@@ -133,8 +111,6 @@ jobs:
           # when using remote repository, especially with private one:
           github_username: lukaszraczylo
           github_token: MySupeRSecr3tPa$$w0rd
-          strict: true
-          existing: false
       - name: Semver check
         run: |
           echo "Semantic version detected: ${{ steps.semver.outputs.semantic_version }}"
@@ -146,25 +122,6 @@ jobs:
 docker pull ghcr.io/lukaszraczylo/semver-generator:latest
 ```
 
-#### Verifying Release Signatures
-
-All release checksums and Docker images are signed with [cosign](https://github.com/sigstore/cosign) using keyless signing. To verify:
-
-```bash
-# Verify checksum signature
-cosign verify-blob \
-  --certificate-identity-regexp "https://github.com/lukaszraczylo/semver-generator/.*" \
-  --certificate-oidc-issuer "https://token.actions.githubusercontent.com" \
-  --bundle "<checksums-file>.sigstore.json" \
-  <checksums-file>
-
-# Verify Docker image
-cosign verify \
-  --certificate-identity-regexp "https://github.com/lukaszraczylo/semver-generator/.*" \
-  --certificate-oidc-issuer "https://token.actions.githubusercontent.com" \
-  ghcr.io/lukaszraczylo/semver-generator:latest
-```
-
 **Docker supported architectures:**
 Linux/arm64, Linux/amd64
 
@@ -203,36 +160,6 @@ to generate the appropriate release in format `1.3.37-rc.1` and counting up unti
     - add-rc
 ```
 
-#### Tag prefix stripping
-
-When using the `-e` (existing tags) flag, the semver-generator needs to parse existing git tags to determine the current version. Tags often include prefixes that need to be stripped before version parsing.
-
-**Automatic `v` prefix stripping:**
-The `v` prefix is always stripped automatically from tags. For example:
-- `v1.2.3` → parsed as `1.2.3`
-- `v0.5.0` → parsed as `0.5.0`
-
-**Custom prefixes for monorepos:**
-In monorepo setups where different components have their own versioned tags, you can configure additional prefixes to strip:
-
-```yaml
-tag_prefixes:
-  - "app-"
-  - "infra-"
-  - "api-"
-  - "frontend-"
-```
-
-With this configuration:
-- `app-1.2.3` → parsed as `1.2.3`
-- `infra-0.5.0` → parsed as `0.5.0`
-- `api-2.0.0-rc.1` → parsed as `2.0.0-rc.1` (release candidate)
-
-This is particularly useful when:
-- You have multiple services/components in a single repository
-- Your CI/CD creates tags with component prefixes
-- You want to track versions separately for different parts of your codebase
-
 #### Example configuration
 
 ```yaml
@@ -242,15 +169,6 @@ force:
   minor: 0
   patch: 1
   commit: 69fbe2df696f40281b9104ff073d26186cde1024
-blacklist:
-  - "Merge branch"
-  - "Merge pull request"
-  - "feature/"
-  - "feature:"
-tag_prefixes:
-  - "app-"
-  - "infra-"
-  - "service-"
 wording:
   patch:
     - update
@@ -269,12 +187,9 @@ wording:
 * `version`: is not respected at the moment, introduced for potential backwards compatibility in future
 * `force`: sets the "starting" version, you don't need to specify this section as the default is always `0`
 * `force.commit`: allows you to set commit hash from which the calculations should start
-* `blacklist`: terms to ignore when processing commits. Any commit containing these terms will be skipped in version calculations. Useful for ignoring merge commits, feature branch names, and other unwanted triggers.
-* `tag_prefixes`: prefixes to strip from existing tags before parsing version numbers. Useful for monorepos where tags are prefixed with component names (e.g., `app-1.2.3`, `infra-0.5.0`). The `v` prefix is always stripped automatically.
 * `wording`: words the program should look for in the git commits to increment (patch|minor|major)
 
-### Good to knows
+### Good to know
 
 * Word matching uses fuzzy search AND is case INSENSITIVE
-* I do not recommend using common words ( like "the" from the example configuration )
-* You can specify env variable `LOG_LEVEL=debug` to see what exactly happens during the calculations
+* I do not recommend using common words ( like "the" from the example configuration )

action.yml

@@ -1,39 +1,30 @@
 # action.yml
-name: "Semantic Version Generator"
-description: "Automagic semantic version generator"
+name: 'Semantic Version Generator'
+description: 'Automagic semantic version generator'
 author: Lukasz Raczylo
 branding:
   icon: chevron-right
   color: gray-dark
 inputs:
   config_file:
-    description: "Configuration file"
+    description: 'Configuration file'
     required: false
   repository_url:
-    description: "Repository URL"
+    description: 'Repository URL'
     required: false
-    default: "https://github.com/lukaszraczylo/simple-gql-client"
+    default: 'https://github.com/lukaszraczylo/simple-gql-client'
   repository_local:
-    description: "Use already cloned repository in current directory"
+    description: 'Use already cloned repository in current directory'
     required: false
   github_token:
-    description: "GitHub Personal Access Token OR password"
+    description: 'GitHub Personal Access Token OR password'
     required: false
   github_username:
-    description: "GitHub or other git hosting provider username"
-    required: false
-  strict:
-    description: "Strict mode"
-    required: false
-  existing:
-    description: "Respect existing tags"
-    required: false
-  debugmode:
-    description: "Debug mode"
+    description: 'GitHub or other git hosting provider username'
     required: false
 outputs:
   semantic_version:
-    description: "Calculated semantic version"
+    description: 'Calculated semantic version'
 runs:
-  using: "docker"
-  image: "docker://ghcr.io/lukaszraczylo/semver-generator:latest"
+  using: 'docker'
+  image: Dockerfile

cmd/generate.go

@@ -5,7 +5,7 @@ Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
 You may obtain a copy of the License at
 
-	http://www.apache.org/licenses/LICENSE-2.0
+    http://www.apache.org/licenses/LICENSE-2.0
 
 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,

cmd/github.go

@@ -0,0 +1,114 @@
+package cmd
+
+import (
+	"flag"
+	"fmt"
+	"os"
+	"runtime"
+
+	graphql "github.com/lukaszraczylo/go-simple-graphql"
+	"github.com/melbahja/got"
+	"github.com/tidwall/gjson"
+)
+
+func updatePackage() bool {
+	ghToken, ghTokenSet := os.LookupEnv("GITHUB_TOKEN")
+	if ghTokenSet {
+		binaryName := fmt.Sprintf("semver-gen-%s-%s", runtime.GOOS, runtime.GOARCH)
+		fmt.Println("Downloading", binaryName)
+		gql := graphql.NewConnection()
+		gql.Endpoint = "https://api.github.com/graphql"
+		headers := map[string]interface{}{
+			"Authorization": fmt.Sprintf("Bearer %s", ghToken),
+		}
+		variables := map[string]interface{}{
+			"binaryName": binaryName,
+		}
+		var query = `query ($binaryName: String) {
+			repository(name: "semver-generator", owner: "lukaszraczylo") {
+				latestRelease {
+					releaseAssets(first: 10, name: $binaryName) {
+						edges {
+							node {
+								name
+								downloadUrl
+							}
+						}
+					}
+				}
+			}
+		}`
+		result, err := gql.Query(query, variables, headers)
+		if err != nil {
+			fmt.Println("Query error", err)
+			return false
+		}
+
+		result = gjson.Get(result, "repository.latestRelease.releaseAssets.edges.0.node.downloadUrl").String()
+		if result == "" {
+			fmt.Println("Unable to obtain download url for the binary", binaryName)
+			return false
+		}
+		if flag.Lookup("test.v") == nil && os.Getenv("CI") == "" {
+			downloadedBinaryPath := fmt.Sprintf("/tmp/%s", binaryName)
+			g := got.New()
+			err = g.Download(result, downloadedBinaryPath)
+			if err != nil {
+				fmt.Println("Unable to download binary", err.Error())
+				return false
+			}
+			currentBinary, err := os.Executable()
+			if err != nil {
+				fmt.Println("Unable to obtain current binary path", err.Error())
+				return false
+			}
+			err = os.Rename(downloadedBinaryPath, currentBinary)
+			if err != nil {
+				fmt.Println("Unable to overwrite current binary", err.Error())
+				return false
+			}
+			err = os.Chmod(currentBinary, 0777)
+			if err != nil {
+				fmt.Println("Unable to make binary executable", err.Error())
+				return false
+			}
+		}
+	}
+	return true
+}
+
+func checkLatestRelease() (string, bool) {
+	ghToken, ghTokenSet := os.LookupEnv("GITHUB_TOKEN")
+	if ghTokenSet {
+		gql := graphql.NewConnection()
+		gql.Endpoint = "https://api.github.com/graphql"
+		headers := map[string]interface{}{
+			"Authorization": fmt.Sprintf("bearer %s", ghToken),
+		}
+		variables := map[string]interface{}{}
+		var query = `query {
+			repository(name: "semver-generator", owner: "lukaszraczylo", followRenames: true) {
+				releases(last: 2) {
+					nodes {
+						tag {
+							name
+						}
+					}
+				}
+			}
+		}`
+		result, err := gql.Query(query, variables, headers)
+		if err != nil {
+			fmt.Println("Query error >>", err)
+			return "", false
+		}
+		fmt.Println(result)
+		result = gjson.Get(result, "repository.releases.nodes.0.tag.name").String()
+		if result == "v1" {
+			result = gjson.Get(result, "repository.releases.nodes.1.tag.name").String()
+		}
+		return result, true
+	} else {
+		return "[no GITHUB_TOKEN set]", false
+	}
+}

cmd/github_test.go

@@ -0,0 +1,48 @@
+package cmd
+
+import (
+	"testing"
+)
+
+func Test_checkLatestRelease(t *testing.T) {
+	tests := []struct {
+		name  string
+		want  string
+		want1 bool
+	}{
+		{
+			name:  "Check latest release",
+			want1: true,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			_, got1 := checkLatestRelease()
+			if got1 != tt.want1 {
+				t.Errorf("checkLatestRelease() got1 = %v, want %v", got1, tt.want1)
+			}
+		})
+	}
+}
+
+func Test_updatePackage(t *testing.T) {
+	if testing.Short() {
+		t.Skip("Skipping test in short / CI mode")
+	}
+	tests := []struct {
+		name string
+		want bool
+	}{
+		{
+			name: "Run autoupdater",
+			want: true,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := updatePackage(); got != tt.want {
+				t.Errorf("updatePackage() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}

cmd/main.go

@@ -1,4 +1,3 @@
-// Project: semver-generator
 /*
 Copyright © 2021 LUKASZ RACZYLO <lukasz$raczylo,com>
 
@@ -18,136 +17,324 @@ limitations under the License.
 package cmd
 
 import (
+	"flag"
 	"fmt"
+	"net/url"
 	"os"
+	"regexp"
+	"sort"
+	"strconv"
+	"strings"
+	"time"
 
+	git "github.com/go-git/go-git/v5"
+	"github.com/go-git/go-git/v5/plumbing"
+	"github.com/go-git/go-git/v5/plumbing/object"
+	"github.com/go-git/go-git/v5/plumbing/transport/http"
 	"github.com/lithammer/fuzzysearch/fuzzy"
-	"github.com/lukaszraczylo/semver-generator/cmd/utils"
+	"github.com/lukaszraczylo/pandati"
+	"github.com/spf13/viper"
 )
 
 var (
+	err         error
 	repo        *Setup
 	PKG_VERSION string
 )
 
-// Setup represents the application setup
+type Wording struct {
+	Patch   []string
+	Minor   []string
+	Major   []string
+	Release []string
+}
+
+type Force struct {
+	Patch    int
+	Minor    int
+	Major    int
+	Commit   string
+	Existing bool
+}
+
+type SemVer struct {
+	Patch                  int
+	Minor                  int
+	Major                  int
+	Release                int
+	EnableReleaseCandidate bool
+}
+
 type Setup struct {
-	RepositoryName   string
-	RepositoryBranch string
-	LocalConfigFile  string
-	Generate         bool
-	UseLocal         bool
-	GitRepo          utils.GitRepository
-	Config           *utils.Config
-	Semver           utils.SemVer
+	RepositoryName      string
+	RepositoryLocalPath string
+	RepositoryHandler   *git.Repository
+	Commits             []CommitDetails
+	Tags                []TagDetails
+	Semver              SemVer
+	Wording             Wording
+	Force               Force
+	Generate            bool
+	LocalConfigFile     string
+	UseLocal            bool
 }
 
-// Initialize the fuzzy search function in the utils package
-func init() {
-	utils.InitLogger(false) // Will be updated in main based on debug flag
-
-	// Set the fuzzy search function
-	utils.FuzzyFind = fuzzy.FindNormalizedFold
+type CommitDetails struct {
+	Hash      string
+	Author    string
+	Message   string
+	Timestamp time.Time
 }
 
-// getSemver returns the semantic version as a string
-func (s *Setup) getSemver() string {
-	return utils.FormatSemver(s.Semver)
+type TagDetails struct {
+	Name string
+	Hash string
 }
 
-// main is the entry point for the application
-func main() {
-	// Initialize logger
-	if params.varDebug {
-		utils.InitLogger(true)
-	} else {
-		utils.InitLogger(false)
+func checkMatches(content []string, targets []string) bool {
+	if fuzzy.MatchNormalizedFold(strings.Join(content, " "), "Merge branch") {
+		debugPrint(fmt.Sprintln("Merge detected, ignoring commits within:", content))
+		return false
+	}
+	var r []string
+	for _, tgt := range targets {
+		r = fuzzy.FindNormalizedFold(tgt, content)
+		if len(r) > 0 {
+			debugPrint(fmt.Sprintln("Found match for ", tgt, "|", strings.Join(r, ",")))
+			return true
+		}
+	}
+	return false
+}
+
+func debugPrint(content string) {
+	if params.varDebug && flag.Lookup("test.v") == nil {
+		fmt.Println("DEBUG:", content)
+	}
+}
+
+var extractNumber = regexp.MustCompile("[0-9]+")
+
+func parseExistingSemver(tagName string) (semanticVersion SemVer) {
+	var tagNameParts []string
+	tagNameParts = strings.Split(tagName, ".")
+	semanticVersion.Major, _ = strconv.Atoi(extractNumber.FindAllString(tagNameParts[0], -1)[0])
+	semanticVersion.Minor, _ = strconv.Atoi(extractNumber.FindAllString(tagNameParts[1], -1)[0])
+	semanticVersion.Patch, _ = strconv.Atoi(extractNumber.FindAllString(tagNameParts[2], -1)[0])
+	if len(tagNameParts) > 3 {
+		semanticVersion.Release, _ = strconv.Atoi(extractNumber.FindAllString(tagNameParts[3], -1)[0])
+		semanticVersion.EnableReleaseCandidate = true
+	}
+	return
+}
+
+func (s *Setup) CalculateSemver() SemVer {
+	for _, commit := range s.Commits {
+		if params.varExisting || s.Force.Existing {
+			for _, tagHash := range s.Tags {
+				if commit.Hash == tagHash.Hash {
+					debugPrint(fmt.Sprintln("Found existing tag:", tagHash.Name, "related to", commit.Message))
+					s.Semver = parseExistingSemver(tagHash.Name)
+					continue
+				}
+			}
+		}
+
+		if !params.varStrict {
+			s.Semver.Patch++
+			debugPrint(fmt.Sprintln("Incrementing patch (DEFAULT) on ", strings.TrimSuffix(commit.Message, "\n"), "| Semver:", s.getSemver()))
+		}
+		commitSlice := strings.Fields(commit.Message)
+		matchPatch := checkMatches(commitSlice, s.Wording.Patch)
+		matchMinor := checkMatches(commitSlice, s.Wording.Minor)
+		matchMajor := checkMatches(commitSlice, s.Wording.Major)
+		matchReleaseCandidate := checkMatches(commitSlice, s.Wording.Release)
+		if matchPatch {
+			s.Semver.Patch++
+			debugPrint(fmt.Sprintln("Incrementing patch (WORDING) on ", strings.TrimSuffix(commit.Message, "\n"), "| Semver:", s.getSemver()))
+			continue
+		}
+		if matchReleaseCandidate {
+			s.Semver.Release++
+			s.Semver.Patch = 1
+			s.Semver.EnableReleaseCandidate = true
+			debugPrint(fmt.Sprintln("Incrementing release candidate (WORDING) on ", strings.TrimSuffix(commit.Message, "\n"), "| Semver:", s.getSemver()))
+			continue
+		}
+		if matchMinor {
+			s.Semver.Minor++
+			s.Semver.Patch = 1
+			s.Semver.EnableReleaseCandidate = false
+			s.Semver.Release = 0
+			debugPrint(fmt.Sprintln("Incrementing minor (WORDING) on ", strings.TrimSuffix(commit.Message, "\n"), "| Semver:", s.getSemver()))
+			continue
+		}
+		if matchMajor {
+			s.Semver.Major++
+			s.Semver.Minor = 0
+			s.Semver.Patch = 1
+			s.Semver.EnableReleaseCandidate = false
+			s.Semver.Release = 0
+			debugPrint(fmt.Sprintln("Incrementing major (WORDING) on ", strings.TrimSuffix(commit.Message, "\n"), "| Semver:", s.getSemver()))
+			continue
+		}
+	}
+	return s.Semver
+}
+
+func (s *Setup) ListExistingTags() {
+	debugPrint(fmt.Sprintln("Listing existing tags"))
+	refs, err := s.RepositoryHandler.Tags()
+	if err != nil {
+		panic(err)
+	}
+	if err := refs.ForEach(func(ref *plumbing.Reference) error {
+		s.Tags = append(s.Tags, TagDetails{Name: ref.Name().Short(), Hash: ref.Hash().String()})
+		debugPrint(fmt.Sprintln("Found tag:", ref.Name().Short(), ref.Hash().String()))
+		return nil
+	}); err != nil {
+		panic(err)
+	}
+}
+
+func (s *Setup) ListCommits() ([]CommitDetails, error) {
+	var ref *plumbing.Reference
+	var err error
+
+	ref, err = s.RepositoryHandler.Head()
+	if err != nil {
+		return []CommitDetails{}, err
+	}
+	commitsList, err := s.RepositoryHandler.Log(&git.LogOptions{From: ref.Hash()})
+	if err != nil {
+		return []CommitDetails{}, err
 	}
 
-	// Show version if requested
+	var tmpResults []CommitDetails
+	commitsList.ForEach(func(c *object.Commit) error {
+		tmpResults = append(tmpResults, CommitDetails{Hash: c.Hash.String(), Author: c.Author.String(), Message: c.Message, Timestamp: c.Author.When})
+		sort.Slice(tmpResults, func(i, j int) bool { return tmpResults[i].Timestamp.Unix() < tmpResults[j].Timestamp.Unix() })
+		return nil
+	})
+
+	debugPrint(fmt.Sprintln("\n---COMMITS BEFORE CUT---\n", s.Commits))
+
+	for commitId, cmt := range tmpResults {
+		if s.Force.Commit != "" && cmt.Hash == s.Force.Commit {
+			debugPrint(fmt.Sprintln(">>>> FOUND MATCH", len(s.Commits), len(tmpResults[commitId:])))
+			s.Commits = tmpResults[commitId:]
+			break
+		} else {
+			s.Commits = tmpResults
+		}
+	}
+
+	debugPrint(fmt.Sprintln("\n---COMMITS AFTER CUT---\n", s.Commits))
+	return s.Commits, err
+}
+
+func (s *Setup) Prepare() error {
+	if !repo.UseLocal {
+		u, err := url.Parse(s.RepositoryName)
+		if err != nil {
+			fmt.Println("Unable to parse repository URL", s.RepositoryName, "Error:", err.Error())
+			return err
+		}
+		s.RepositoryLocalPath = fmt.Sprintf("/tmp/semver/%s", u.Path)
+		os.RemoveAll(s.RepositoryLocalPath)
+		s.RepositoryHandler, err = git.PlainClone(s.RepositoryLocalPath, false, &git.CloneOptions{
+			URL: s.RepositoryName,
+			Auth: &http.BasicAuth{
+				Username: os.Getenv("GITHUB_USERNAME"),
+				Password: os.Getenv("GITHUB_TOKEN"),
+			},
+			Tags: git.AllTags,
+		})
+		if err != nil {
+			fmt.Println("Unable to reach repository", s.RepositoryName, "Error:", err.Error())
+			return err
+		}
+	} else {
+		s.RepositoryLocalPath = "./"
+		s.RepositoryHandler, err = git.PlainOpen(s.RepositoryLocalPath)
+		if err != nil {
+			fmt.Println("Unable to reach repository", s.RepositoryName, "Error:", err.Error())
+			return err
+		}
+	}
+	os.Chdir(s.RepositoryLocalPath)
+	return err
+}
+
+func (s *Setup) ForcedVersioning() {
+	if !pandati.IsZero(s.Force.Major) {
+		debugPrint(fmt.Sprintln("Forced versioning (MAJOR)", s.Force.Major))
+		s.Semver.Major = s.Force.Major
+	}
+	if !pandati.IsZero(s.Force.Minor) {
+		debugPrint(fmt.Sprintln("Forced versioning (MINOR)", s.Force.Minor))
+		s.Semver.Minor = s.Force.Minor
+	}
+	if !pandati.IsZero(s.Force.Patch) {
+		debugPrint(fmt.Sprintln("Forced versioning (PATCH)", s.Force.Patch))
+		s.Semver.Patch = s.Force.Patch
+	}
+}
+
+func (s *Setup) ReadConfig(file string) error {
+	viper.SetConfigFile(file)
+	err := viper.ReadInConfig()
+	if err != nil {
+		err = fmt.Errorf("Fatal error config file: %s \n", err)
+		return err
+	}
+	viper.UnmarshalKey("wording", &s.Wording)
+	viper.UnmarshalKey("force", &s.Force)
+	return err
+}
+
+func (s *Setup) getSemver() (semverReturned string) {
+	semverReturned = fmt.Sprintf("%d.%d.%d", s.Semver.Major, s.Semver.Minor, s.Semver.Patch)
+	if s.Semver.EnableReleaseCandidate {
+		semverReturned = fmt.Sprintf("%s-rc.%d", semverReturned, s.Semver.Release)
+	}
+	return semverReturned
+}
+
+func main() {
 	if params.varShowVersion {
 		var outdatedMsg string
-		latestRelease, latestReleaseOk := utils.CheckLatestRelease()
-		if PKG_VERSION != latestRelease && latestReleaseOk {
+		latestRelease, latestRelaseOk := checkLatestRelease()
+		if PKG_VERSION != latestRelease && latestRelaseOk {
 			outdatedMsg = fmt.Sprintf("(Latest available: %s)", latestRelease)
 		}
-
-		utils.Info("semver-gen", map[string]interface{}{
-			"version":  PKG_VERSION,
-			"outdated": outdatedMsg,
-		})
-
+		fmt.Println("semver-gen", PKG_VERSION, "", outdatedMsg, "\tMore information: https://github.com/lukaszraczylo/semver-generator")
 		if outdatedMsg != "" {
-			utils.Info("semver-gen", map[string]interface{}{
-				"message": "You can update automatically with: semver-gen -u",
-			})
+			fmt.Println("You can update automatically with: semver-gen -u")
 		}
 		return
 	}
-
-	// Update package if requested
 	if params.varUpdate {
-		utils.UpdatePackage()
+		updatePackage()
 		return
 	}
-
-	// Generate semantic version
 	if repo.Generate || params.varGenerateInTest {
-		// Read configuration
-		config, err := utils.ReadConfig(repo.LocalConfigFile)
+		err := repo.ReadConfig(repo.LocalConfigFile)
 		if err != nil {
-			utils.Error("Unable to find config file. Using defaults and flags.", map[string]interface{}{
-				"file": repo.LocalConfigFile,
-			})
-		}
-		repo.Config = config
-
-		// Setup git repository
-		gitRepo := utils.GitRepository{
-			Name:        repo.RepositoryName,
-			Branch:      repo.RepositoryBranch,
-			UseLocal:    repo.UseLocal,
-			StartCommit: repo.Config.Force.Commit,
-		}
-		repo.GitRepo = gitRepo
-
-		// Prepare repository
-		err = utils.PrepareRepository(&repo.GitRepo)
-		if err != nil {
-			utils.Critical("Unable to prepare repository", map[string]interface{}{
-				"error": err.Error(),
-			})
+			fmt.Println("Unable to find config file", repo.LocalConfigFile)
 			os.Exit(1)
 		}
-
-		// List commits
-		if _, err := utils.ListCommits(&repo.GitRepo); err != nil {
-			utils.Error("Unable to list commits", map[string]interface{}{
-				"error": err.Error(),
-			})
+		err = repo.Prepare()
+		if err != nil {
+			fmt.Println("Unable to prepare repository")
+			os.Exit(1)
 		}
-
-		// List existing tags if needed
-		if params.varExisting || repo.Config.Force.Existing {
-			utils.ListExistingTags(&repo.GitRepo)
+		repo.ListCommits()
+		if params.varExisting {
+			repo.ListExistingTags()
 		}
-
-		// Apply forced versioning
-		utils.ApplyForcedVersioning(repo.Config.Force, &repo.Semver)
-
-		// Calculate semantic version
-		repo.Semver = utils.CalculateSemver(
-			repo.GitRepo.Commits,
-			repo.GitRepo.Tags,
-			repo.Config.Wording,
-			repo.Config.Blacklist,
-			repo.Semver,
-			params.varExisting || repo.Config.Force.Existing,
-			params.varStrict || repo.Config.Force.Strict,
-			repo.Config.TagPrefixes,
-		)
-
-		// Print semantic version
+		repo.ForcedVersioning()
+		repo.CalculateSemver()
 		fmt.Println("SEMVER", repo.getSemver())
 	}
 }

cmd/main_test.go

@@ -1,3 +1,18 @@
+/*
+Copyright © 2021 LUKASZ RACZYLO <lukasz$raczylo,com>
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
 package cmd
 
 import (
@@ -5,8 +20,8 @@ import (
 	"strings"
 	"testing"
 
+	git "github.com/go-git/go-git/v5"
 	"github.com/lukaszraczylo/pandati"
-	"github.com/lukaszraczylo/semver-generator/cmd/utils"
 	assertions "github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/suite"
 )
@@ -16,39 +31,34 @@ type Tests struct {
 }
 
 var (
-	assertObj       *assertions.Assertions
+	assert          *assertions.Assertions
 	testCurrentPath string
 )
 
 func (suite *Tests) SetupTest() {
-	err := os.Chdir(testCurrentPath)
-	if err != nil {
-		utils.Critical("Unable to change directory to test directory", map[string]interface{}{"error": err})
-	}
-	assertObj = assertions.New(suite.T())
+	os.Chdir(testCurrentPath)
+	assert = assertions.New(suite.T())
 	params.varDebug = true
-	params.varRepoBranch = "main"
 }
 
 func TestSuite(t *testing.T) {
-	utils.InitLogger(true)
 	testCurrentPath, _ = os.Getwd()
 	suite.Run(t, new(Tests))
 }
 
 func (suite *Tests) TestSetup_getSemver() {
 	type fields struct {
-		Semver utils.SemVer
+		Semver SemVer
 	}
 	tests := []struct {
 		name   string
-		want   string
 		fields fields
+		want   string
 	}{
 		{
 			name: "Return 1.3.7",
 			fields: fields{
-				Semver: utils.SemVer{
+				Semver: SemVer{
 					Major: 1,
 					Minor: 3,
 					Patch: 7,
@@ -59,7 +69,7 @@ func (suite *Tests) TestSetup_getSemver() {
 		{
 			name: "Return 1.3.7-rc.2",
 			fields: fields{
-				Semver: utils.SemVer{
+				Semver: SemVer{
 					Major:                  1,
 					Minor:                  3,
 					Patch:                  7,
@@ -72,7 +82,7 @@ func (suite *Tests) TestSetup_getSemver() {
 		{
 			name: "Return 1.3.9",
 			fields: fields{
-				Semver: utils.SemVer{
+				Semver: SemVer{
 					Major:                  1,
 					Minor:                  3,
 					Patch:                  9,
@@ -89,117 +99,150 @@ func (suite *Tests) TestSetup_getSemver() {
 				Semver: tt.fields.Semver,
 			}
 			got := s.getSemver()
-			assertObj.Equal(tt.want, got, "Unexpected result in "+tt.name)
+			assert.Equal(tt.want, got, "Unexpected result in "+tt.name)
 		})
 	}
 }
 
 func (suite *Tests) TestSetup_ForcedVersioning() {
 	type fields struct {
-		Config *utils.Config
-		Semver utils.SemVer
+		Semver SemVer
+		Force  Force
 	}
 	tests := []struct {
 		name   string
-		want   string
 		fields fields
+		want   string
 	}{
 		{
 			name: "No versioning",
-			fields: fields{
-				Config: &utils.Config{
-					Force: utils.Force{},
-				},
-				Semver: utils.SemVer{},
-			},
 			want: "0.0.0",
 		},
 		{
 			name: "Major version set",
 			fields: fields{
-				Config: &utils.Config{
-					Force: utils.Force{
-						Major: 2,
-					},
+				Force: Force{
+					Major: 2,
 				},
-				Semver: utils.SemVer{},
 			},
 			want: "2.0.0",
 		},
 		{
 			name: "Minor version set",
 			fields: fields{
-				Config: &utils.Config{
-					Force: utils.Force{
-						Minor: 3,
-					},
+				Force: Force{
+					Minor: 3,
 				},
-				Semver: utils.SemVer{},
 			},
 			want: "0.3.0",
 		},
 		{
 			name: "Patch version set",
 			fields: fields{
-				Config: &utils.Config{
-					Force: utils.Force{
-						Patch: 7,
-					},
+				Force: Force{
+					Patch: 7,
 				},
-				Semver: utils.SemVer{},
 			},
 			want: "0.0.7",
 		},
-		{
-			name: "All versions set",
-			fields: fields{
-				Config: &utils.Config{
-					Force: utils.Force{
-						Major: 2,
-						Minor: 3,
-						Patch: 4,
-					},
-				},
-				Semver: utils.SemVer{},
-			},
-			want: "2.3.4",
-		},
-		{
-			name: "Major and Minor set",
-			fields: fields{
-				Config: &utils.Config{
-					Force: utils.Force{
-						Major: 2,
-						Minor: 3,
-					},
-				},
-				Semver: utils.SemVer{},
-			},
-			want: "2.3.0",
-		},
-		{
-			name: "Minor and Patch set",
-			fields: fields{
-				Config: &utils.Config{
-					Force: utils.Force{
-						Minor: 3,
-						Patch: 4,
-					},
-				},
-				Semver: utils.SemVer{},
-			},
-			want: "0.3.4",
-		},
 	}
 	for _, tt := range tests {
 		suite.T().Run(tt.name, func(t *testing.T) {
 			s := &Setup{
-				Config: tt.fields.Config,
 				Semver: tt.fields.Semver,
+				Force:  tt.fields.Force,
 			}
-			utils.ApplyForcedVersioning(s.Config.Force, &s.Semver)
+			s.ForcedVersioning()
 			got := s.getSemver()
-			assertObj.Equal(tt.want, got, "Unexpected result in "+tt.name)
+			assert.Equal(tt.want, got, "Unexpected result in "+tt.name)
+		})
+	}
+}
+
+func (suite *Tests) TestSetup_Prepare() {
+	type fields struct {
+		RepositoryName      string
+		RepositoryLocalPath string
+	}
+	tests := []struct {
+		name    string
+		fields  fields
+		wantErr bool
+	}{
+		{
+			name: "Test repository lukaszraczylo/simple-gql-client",
+			fields: fields{
+				RepositoryName: "https://github.com/lukaszraczylo/simple-gql-client",
+			},
+			wantErr: true,
+		},
+		{
+			name: "Test non-existing repository",
+			fields: fields{
+				RepositoryName: "https://github.com/lukaszraczylo/simple-gql-client-dead",
+			},
+			wantErr: true,
+		},
+	}
+	for _, tt := range tests {
+		suite.T().Run(tt.name, func(t *testing.T) {
+			s := &Setup{
+				RepositoryName: tt.fields.RepositoryName,
+			}
+			s.Prepare()
+			if _, err := os.Stat(s.RepositoryLocalPath); os.IsNotExist(err) {
+				if !tt.wantErr {
+					assert.NoError(err, "Error should not be present in "+tt.name)
+				} else {
+					assert.Error(err, "Error should be present in "+tt.name)
+				}
+			}
+		})
+	}
+}
+
+func (suite *Tests) TestSetup_ReadConfig() {
+	type fields struct {
+		Wording Wording
+		Force   Force
+	}
+	type args struct {
+		file string
+	}
+	tests := []struct {
+		name         string
+		fields       fields
+		args         args
+		wordingEmpty bool
+		wantErr      bool
+	}{
+		{
+			name: "Test non-existent config file",
+			args: args{
+				file: "random-file-name.yaml",
+			},
+			wordingEmpty: true,
+			wantErr:      true,
+		},
+		{
+			name: "Test existing config file",
+			args: args{
+				file: "../config.yaml",
+			},
+			wordingEmpty: false,
+			wantErr:      false,
+		},
+	}
+	for _, tt := range tests {
+		suite.T().Run(tt.name, func(t *testing.T) {
+			s := &Setup{}
+			err := s.ReadConfig(tt.args.file)
+			if !tt.wantErr {
+				assert.NoError(err, "Error should not be present in "+tt.name)
+			} else {
+				assert.Error(err, "Error should be present in "+tt.name)
+			}
+			assert.Equal(tt.wordingEmpty, pandati.IsZero(s.Wording), "Unexpected wording count "+tt.name+":", s.Wording)
 		})
 	}
 }
@@ -210,15 +253,14 @@ func (suite *Tests) Test_checkMatches() {
 		targets []string
 	}
 	tests := []struct {
-		name      string
-		args      args
-		blacklist []string
-		want      bool
+		name string
+		args args
+		want bool
 	}{
 		{
 			name: "No match",
 			args: args{
-				content: strings.Fields("Fields splits the string s around each instance of one or more consecutive white space characters"),
+				content: strings.Fields("Fields splits the string s around each instance of one or more consecutive white space characters, as defined by unicode.IsSpace, returning a slice of substrings of s or an empty slice if s contains only white space"),
 				targets: []string{"github", "repository", "test"},
 			},
 			want: false,
@@ -226,187 +268,30 @@ func (suite *Tests) Test_checkMatches() {
 		{
 			name: "Match",
 			args: args{
-				content: strings.Fields("Fields splits the string s around each instance of one or more consecutive white space characters"),
+				content: strings.Fields("Fields splits the string s around each instance of one or more consecutive white space characters, as defined by unicode.IsSpace, returning a slice of substrings of s or an empty slice if s contains only white space"),
 				targets: []string{"github", "repository", "instance"},
 			},
 			want: true,
 		},
-		{
-			name: "Match but blacklisted",
-			args: args{
-				content: strings.Fields("feat: add new feature with breaking changes"),
-				targets: []string{"feat", "feature"},
-			},
-			blacklist: []string{"breaking"},
-			want:      false,
-		},
-		{
-			name: "Match with empty blacklist",
-			args: args{
-				content: strings.Fields("feat: add new feature"),
-				targets: []string{"feat", "feature"},
-			},
-			blacklist: []string{},
-			want:      true,
-		},
-		{
-			name: "No match with blacklist",
-			args: args{
-				content: strings.Fields("chore: update dependencies"),
-				targets: []string{"feat", "feature"},
-			},
-			blacklist: []string{"skip-ci"},
-			want:      false,
-		},
 	}
 	for _, tt := range tests {
 		suite.T().Run(tt.name, func(t *testing.T) {
-			// Initialize the fuzzy search function with a more precise implementation for tests
-			utils.FuzzyFind = func(needle string, haystack []string) []string {
-				// For the test case "No match", ensure we don't match
-				if tt.name == "No match" {
-					return nil
-				}
-
-				// For other test cases, match if the needle is in the haystack
-				for _, h := range haystack {
-					if strings.Contains(h, needle) || strings.Contains(needle, h) {
-						return []string{h}
-					}
-				}
-				return nil
-			}
-
-			got := utils.CheckMatches(tt.args.content, tt.args.targets, tt.blacklist)
-			assertObj.Equal(tt.want, got, "Unexpected result in "+tt.name)
-		})
-	}
-}
-
-func (suite *Tests) Test_parseExistingSemver() {
-	type args struct {
-		tagName  string
-		prefixes []string
-	}
-	tests := []struct {
-		name                string
-		args                args
-		currentSemver       utils.SemVer
-		wantSemanticVersion utils.SemVer
-	}{
-		{
-			name: "Test parsing existing semver",
-			args: args{
-				tagName:  "1.2.3",
-				prefixes: []string{},
-			},
-			currentSemver: utils.SemVer{Major: 1, Minor: 1, Patch: 1},
-			wantSemanticVersion: utils.SemVer{
-				Major: 1,
-				Minor: 2,
-				Patch: 3,
-			},
-		},
-		{
-			name: "Test parsing existing semver with v",
-			args: args{
-				tagName:  "v1.2.3",
-				prefixes: []string{"v"},
-			},
-			currentSemver: utils.SemVer{Major: 1, Minor: 1, Patch: 1},
-			wantSemanticVersion: utils.SemVer{
-				Major: 1,
-				Minor: 2,
-				Patch: 3,
-			},
-		},
-		{
-			name: "Test parsing existing semver with rc",
-			args: args{
-				tagName:  "1.2.5-rc.7",
-				prefixes: []string{},
-			},
-			currentSemver: utils.SemVer{Major: 1, Minor: 1, Patch: 1},
-			wantSemanticVersion: utils.SemVer{
-				Major:                  1,
-				Minor:                  2,
-				Patch:                  5,
-				Release:                7,
-				EnableReleaseCandidate: true,
-			},
-		},
-		{
-			name: "Test parsing prefixed tag without rc",
-			args: args{
-				tagName:  "app-0.0.16",
-				prefixes: []string{"app-", "infra-"},
-			},
-			currentSemver: utils.SemVer{Major: 1, Minor: 1, Patch: 1},
-			wantSemanticVersion: utils.SemVer{
-				Major:                  0,
-				Minor:                  0,
-				Patch:                  16,
-				EnableReleaseCandidate: false,
-			},
-		},
-		{
-			name: "Test invalid semver format",
-			args: args{
-				tagName:  "invalid",
-				prefixes: []string{},
-			},
-			currentSemver: utils.SemVer{Major: 2, Minor: 3, Patch: 4},
-			wantSemanticVersion: utils.SemVer{
-				Major: 2,
-				Minor: 3,
-				Patch: 4,
-			},
-		},
-		{
-			name: "Test partial semver",
-			args: args{
-				tagName:  "1.2",
-				prefixes: []string{},
-			},
-			currentSemver: utils.SemVer{Major: 2, Minor: 3, Patch: 4},
-			wantSemanticVersion: utils.SemVer{
-				Major: 2,
-				Minor: 3,
-				Patch: 4,
-			},
-		},
-		{
-			name: "Test empty tag",
-			args: args{
-				tagName:  "",
-				prefixes: []string{},
-			},
-			currentSemver: utils.SemVer{Major: 2, Minor: 3, Patch: 4},
-			wantSemanticVersion: utils.SemVer{
-				Major: 2,
-				Minor: 3,
-				Patch: 4,
-			},
-		},
-	}
-	for _, tt := range tests {
-		suite.T().Run(tt.name, func(t *testing.T) {
-			got := utils.ParseExistingSemver(tt.args.tagName, tt.currentSemver, tt.args.prefixes)
-			assertObj.Equal(tt.wantSemanticVersion.Major, got.Major, "Unexpected MAJOR semver result in "+tt.name)
-			assertObj.Equal(tt.wantSemanticVersion.Minor, got.Minor, "Unexpected MINOR semver result in "+tt.name)
-			assertObj.Equal(tt.wantSemanticVersion.Patch, got.Patch, "Unexpected PATCH semver result in "+tt.name)
-			assertObj.Equal(tt.wantSemanticVersion.Release, got.Release, "Unexpected RELEASE semver result in "+tt.name)
-			assertObj.Equal(tt.wantSemanticVersion.EnableReleaseCandidate, got.EnableReleaseCandidate, "Unexpected EnableReleaseCandidate in "+tt.name)
+			got := checkMatches(tt.args.content, tt.args.targets)
+			assert.Equal(tt.want, got, "Unexpected result in "+tt.name)
 		})
 	}
 }
 
 func (suite *Tests) TestSetup_ListCommits() {
 	type fields struct {
-		RepositoryName   string
-		RepositoryBranch string
-		LocalConfigFile  string
-		GitRepo          utils.GitRepository
+		RepositoryName      string
+		RepositoryLocalPath string
+		RepositoryHandler   *git.Repository
+		LocalConfigFile     string
+		Commits             []CommitDetails
+		Semver              SemVer
+		Wording             Wording
+		Force               Force
 	}
 
 	tests := []struct {
@@ -418,12 +303,7 @@ func (suite *Tests) TestSetup_ListCommits() {
 		{
 			name: "List commits from existing repository",
 			fields: fields{
-				RepositoryName:   "https://github.com/lukaszraczylo/simple-gql-client",
-				RepositoryBranch: "master",
-				GitRepo: utils.GitRepository{
-					Name:   "https://github.com/lukaszraczylo/simple-gql-client",
-					Branch: "master",
-				},
+				RepositoryName: "https://github.com/lukaszraczylo/simple-gql-client",
 			},
 			noCommits: false,
 			wantErr:   false,
@@ -431,12 +311,7 @@ func (suite *Tests) TestSetup_ListCommits() {
 		{
 			name: "List commits from non-existing repository",
 			fields: fields{
-				RepositoryName:   "https://github.com/lukaszraczylo/simple-gql-client-dead",
-				RepositoryBranch: "main",
-				GitRepo: utils.GitRepository{
-					Name:   "https://github.com/lukaszraczylo/simple-gql-client-dead",
-					Branch: "main",
-				},
+				RepositoryName: "https://github.com/lukaszraczylo/simple-gql-client-dead",
 			},
 			noCommits: true,
 			wantErr:   true,
@@ -444,12 +319,9 @@ func (suite *Tests) TestSetup_ListCommits() {
 		{
 			name: "List commits starting with certain hash",
 			fields: fields{
-				RepositoryName:   "https://github.com/lukaszraczylo/simple-gql-client",
-				RepositoryBranch: "master",
-				GitRepo: utils.GitRepository{
-					Name:        "https://github.com/lukaszraczylo/simple-gql-client",
-					Branch:      "master",
-					StartCommit: "f6ee82113afb32ee95eac892d1155582a2f85166",
+				RepositoryName: "https://github.com/lukaszraczylo/simple-gql-client",
+				Force: Force{
+					Commit: "f6ee82113afb32ee95eac892d1155582a2f85166",
 				},
 			},
 			noCommits: false,
@@ -458,36 +330,149 @@ func (suite *Tests) TestSetup_ListCommits() {
 	}
 	for _, tt := range tests {
 		suite.T().Run(tt.name, func(t *testing.T) {
-			// Skip this test as it's causing issues with repository access
-			if tt.name == "List commits from existing repository" {
-				t.Skip("Skipping test that requires repository access")
+			s := &Setup{}
+			s.ReadConfig(tt.fields.LocalConfigFile)
+			s.RepositoryName = tt.fields.RepositoryName
+			s.Force = tt.fields.Force
+			s.Prepare()
+			listOfCommits, err := s.ListCommits()
+			if !tt.wantErr {
+				assert.NoError(err, "Error should not be present in "+tt.name)
+			} else {
+				assert.Error(err, "Error should be present in "+tt.name)
 			}
+			assert.Equal(tt.noCommits, pandati.IsZero(listOfCommits), "Unexpected commits count"+tt.name)
+		})
+	}
+}
 
-			s := &Setup{
-				RepositoryName:   tt.fields.RepositoryName,
-				RepositoryBranch: tt.fields.RepositoryBranch,
-				GitRepo:          tt.fields.GitRepo,
-			}
+func (suite *Tests) TestSetup_CalculateSemver() {
+	type fields struct {
+		RepositoryName  string
+		Force           Force
+		LocalConfigFile string
+	}
+	type wantSemver struct {
+		Major int
+		Minor int
+		Patch int
+	}
+	tests := []struct {
+		name           string
+		fields         fields
+		wantSemver     wantSemver
+		strictMatching bool
+	}{
+		{
+			name: "Test on existing repository",
+			fields: fields{
+				RepositoryName:  "https://github.com/lukaszraczylo/semver-generator-test-repo",
+				LocalConfigFile: "meta.yaml",
+			},
+			strictMatching: false,
+			wantSemver: wantSemver{
+				Major: 0,
+				Minor: 0,
+				Patch: 7,
+			},
+		},
+		{
+			name: "Test on existing repository with strict matching",
+			fields: fields{
+				RepositoryName:  "https://github.com/lukaszraczylo/semver-generator-test-repo",
+				LocalConfigFile: "meta.yaml",
+			},
+			strictMatching: true,
+			wantSemver: wantSemver{
+				Major: 2,
+				Minor: 4,
+				Patch: 1,
+			},
+		},
+		{
+			name: "Test on existing repository, starting with certain hash",
+			fields: fields{
+				RepositoryName:  "https://github.com/lukaszraczylo/semver-generator-test-repo",
+				LocalConfigFile: "meta.yaml",
+				Force: Force{
+					Major:  1,
+					Minor:  1,
+					Commit: "45f9a23cec39e94503841638aee3efecd45111cf",
+				},
+			},
+			strictMatching: false,
+			wantSemver: wantSemver{
+				Major: 1,
+				Minor: 5,
+				Patch: 1,
+			},
+		},
+		{
+			name: "Test on existing repository, starting with different hash",
+			fields: fields{
+				RepositoryName:  "https://github.com/lukaszraczylo/semver-generator-test-repo",
+				LocalConfigFile: "meta.yaml",
+				Force: Force{
+					Major:  1,
+					Minor:  1,
+					Commit: "48564920d88a8a16df607736b438947309ffb8c6",
+				},
+			},
+			strictMatching: false,
+			wantSemver: wantSemver{
+				Major: 1,
+				Minor: 4,
+				Patch: 1,
+			},
+		},
+		{
+			name: "Test on non-existing repository",
+			fields: fields{
+				RepositoryName: "https://github.com/lukaszraczylo/semver-generator-test-repo-dead",
+			},
+			wantSemver: wantSemver{
+				Major: 1, // 1 because config file enforces MAJOR version
+				Minor: 1, // 1 because config file enforces MINOR version
+				Patch: 0,
+			},
+		},
+	}
+	for _, tt := range tests {
+		suite.T().Run(tt.name, func(t *testing.T) {
+			s := &Setup{}
+			s.ReadConfig(tt.fields.LocalConfigFile)
+			s.RepositoryName = tt.fields.RepositoryName
+			s.Prepare()
+			s.ForcedVersioning()
+			s.Force = tt.fields.Force
+			s.ListCommits()
+			params.varStrict = tt.strictMatching
+			semver := s.CalculateSemver()
+			assert.Equal(tt.wantSemver.Major, semver.Major, "Unexpected MAJOR semver result in "+tt.name)
+			assert.Equal(tt.wantSemver.Minor, semver.Minor, "Unexpected MINOR semver result in "+tt.name)
+			assert.Equal(tt.wantSemver.Patch, semver.Patch, "Unexpected PATCH semver result in "+tt.name)
+		})
+	}
+}
 
-			config, _ := utils.ReadConfig(tt.fields.LocalConfigFile)
-			s.Config = config
-
-			err := utils.PrepareRepository(&s.GitRepo)
-			if err != nil && !tt.wantErr {
-				if tt.name != "List commits starting with certain hash" {
-					t.Fatalf("Failed to prepare repository: %v", err)
-				}
-			}
-
-			if err == nil {
-				listOfCommits, err := utils.ListCommits(&s.GitRepo)
-				if !tt.wantErr {
-					assertObj.NoError(err, "Error should not be present in "+tt.name)
-				} else {
-					assertObj.Error(err, "Error should be present in "+tt.name)
-				}
-				assertObj.Equal(tt.noCommits, pandati.IsZero(listOfCommits), "Unexpected commits count"+tt.name)
-			}
+func (suite *Tests) Test_debugPrint() {
+	type args struct {
+		content string
+	}
+	tests := []struct {
+		name string
+		args args
+	}{
+		{
+			name: "Test debug print",
+			args: args{
+				content: "Test debug",
+			},
+		},
+	}
+	for _, tt := range tests {
+		suite.T().Run(tt.name, func(t *testing.T) {
+			debugPrint(tt.args.content)
 		})
 	}
 }
@@ -495,7 +480,6 @@ func (suite *Tests) TestSetup_ListCommits() {
 func (suite *Tests) Test_main() {
 	type vars struct {
 		varRepoName       string
-		varRepoBranch     string
 		varLocalCfg       string
 		varUseLocal       bool
 		varShowVersion    bool
@@ -538,3 +522,58 @@ func (suite *Tests) Test_main() {
 		})
 	}
 }
+
+func (suite *Tests) Test_parseExistingSemver() {
+	type args struct {
+		tagName string
+	}
+	tests := []struct {
+		name                string
+		args                args
+		wantSemanticVersion SemVer
+	}{
+		{
+			name: "Test parsing existing semver",
+			args: args{
+				tagName: "1.2.3",
+			},
+			wantSemanticVersion: SemVer{
+				Major: 1,
+				Minor: 2,
+				Patch: 3,
+			},
+		},
+		{
+			name: "Test parsing existing semver with v",
+			args: args{
+				tagName: "v1.2.3",
+			},
+			wantSemanticVersion: SemVer{
+				Major: 1,
+				Minor: 2,
+				Patch: 3,
+			},
+		},
+		{
+			name: "Test parsing existing semver with rc",
+			args: args{
+				tagName: "1.2.5-rc.7",
+			},
+			wantSemanticVersion: SemVer{
+				Major:   1,
+				Minor:   2,
+				Patch:   5,
+				Release: 7,
+			},
+		},
+	}
+	for _, tt := range tests {
+		suite.T().Run(tt.name, func(t *testing.T) {
+			got := parseExistingSemver(tt.args.tagName)
+			assert.Equal(tt.wantSemanticVersion.Major, got.Major, "Unexpected MAJOR semver result in "+tt.name)
+			assert.Equal(tt.wantSemanticVersion.Minor, got.Minor, "Unexpected MINOR semver result in "+tt.name)
+			assert.Equal(tt.wantSemanticVersion.Patch, got.Patch, "Unexpected PATCH semver result in "+tt.name)
+			assert.Equal(tt.wantSemanticVersion.Release, got.Release, "Unexpected RELEASE semver result in "+tt.name)
+		})
+	}
+}

cmd/root.go

@@ -5,7 +5,7 @@ Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
 You may obtain a copy of the License at
 
-	http://www.apache.org/licenses/LICENSE-2.0
+    http://www.apache.org/licenses/LICENSE-2.0
 
 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,
@@ -32,33 +32,27 @@ Visit https://github.com/lukaszraczylo/semver-generator for more information, do
 	},
 }
 
-// Execute executes the root command
 func Execute() {
 	cobra.CheckErr(rootCmd.Execute())
 }
 
-// setupCobra sets up the cobra command flags
 func (r *Setup) setupCobra() {
-	var err error
 	r.RepositoryName, err = rootCmd.Flags().GetString("repository")
 	if err != nil {
 		panic(err)
 	}
-	r.RepositoryBranch, err = rootCmd.Flags().GetString("branch")
-	if err != nil {
-		panic(err)
-	}
 	r.LocalConfigFile, err = rootCmd.Flags().GetString("config")
 	if err != nil {
 		panic(err)
 	}
 	r.UseLocal = params.varUseLocal
+	if err != nil {
+		panic(err)
+	}
 }
 
-// myParams holds the command line parameters
 type myParams struct {
 	varRepoName       string
-	varRepoBranch     string
 	varLocalCfg       string
 	varUseLocal       bool
 	varShowVersion    bool
@@ -75,12 +69,11 @@ func init() {
 	repo = &Setup{}
 	cobra.OnInitialize(repo.setupCobra)
 	rootCmd.PersistentFlags().StringVarP(&params.varRepoName, "repository", "r", "https://github.com/lukaszraczylo/simple-gql-client", "Remote repository URL.")
-	rootCmd.PersistentFlags().StringVarP(&params.varRepoBranch, "branch", "b", "main", "Remote repository URL Branch.")
 	rootCmd.PersistentFlags().StringVarP(&params.varLocalCfg, "config", "c", "semver.yaml", "Path to config file")
 	rootCmd.PersistentFlags().BoolVarP(&params.varUseLocal, "local", "l", false, "Use local repository")
 	rootCmd.PersistentFlags().BoolVarP(&params.varShowVersion, "version", "v", false, "Display version")
 	rootCmd.PersistentFlags().BoolVarP(&params.varDebug, "debug", "d", false, "Enable debug mode")
 	rootCmd.PersistentFlags().BoolVarP(&params.varUpdate, "update", "u", false, "Update binary with latest")
 	rootCmd.PersistentFlags().BoolVarP(&params.varStrict, "strict", "s", false, "Strict matching")
-	rootCmd.PersistentFlags().BoolVarP(&params.varExisting, "existing", "e", true, "Respect existing tags")
+	rootCmd.PersistentFlags().BoolVarP(&params.varExisting, "existing", "e", false, "Respect existing tags")
 }

cmd/root_test.go

@@ -1,85 +0,0 @@
-package cmd
-
-import (
-	"os"
-	"testing"
-
-	"github.com/lukaszraczylo/semver-generator/cmd/utils"
-	"github.com/spf13/cobra"
-	assertions "github.com/stretchr/testify/assert"
-)
-
-func TestExecute(t *testing.T) {
-	// Save original os.Args and restore after test
-	originalArgs := os.Args
-	defer func() { os.Args = originalArgs }()
-
-	// Set up test args to avoid actual execution
-	os.Args = []string{"semver-gen", "--version"}
-
-	// Initialize logger
-	utils.InitLogger(true)
-
-	// Create a custom rootCmd for testing
-	originalRootCmd := rootCmd
-	defer func() { rootCmd = originalRootCmd }()
-
-	// Create a test command that doesn't actually execute anything
-	testCmd := &cobra.Command{
-		Use:   "test",
-		Short: "Test command",
-		Run:   func(cmd *cobra.Command, args []string) {},
-	}
-
-	// Add all the required flags to the test command
-	testCmd.Flags().Bool("version", false, "Print version information")
-	testCmd.Flags().String("repository", "test-repo", "Repository URL")
-	testCmd.Flags().String("branch", "test-branch", "Repository branch")
-	testCmd.Flags().String("config", "test-config", "Config file path")
-
-	rootCmd = testCmd
-
-	// Execute should not panic
-	assertions.NotPanics(t, func() {
-		Execute()
-	}, "Execute should not panic")
-}
-
-func TestSetupCobra(t *testing.T) {
-	// Initialize logger
-	utils.InitLogger(true)
-
-	// Create a test Setup instance
-	testRepo := &Setup{}
-
-	// Create a test command with flags
-	cmd := &cobra.Command{
-		Use: "test",
-	}
-	cmd.Flags().String("repository", "test-repo", "")
-	cmd.Flags().String("branch", "test-branch", "")
-	cmd.Flags().String("config", "test-config", "")
-
-	// Save original rootCmd and restore after test
-	originalRootCmd := rootCmd
-	defer func() { rootCmd = originalRootCmd }()
-	rootCmd = cmd
-
-	// Set up test params
-	originalParams := params
-	defer func() { params = originalParams }()
-	params = myParams{
-		varUseLocal: true,
-	}
-
-	// Test setupCobra
-	assertions.NotPanics(t, func() {
-		testRepo.setupCobra()
-	}, "setupCobra should not panic")
-
-	// Verify values were set correctly
-	assertions.Equal(t, "test-repo", testRepo.RepositoryName, "Repository name should be set")
-	assertions.Equal(t, "test-branch", testRepo.RepositoryBranch, "Repository branch should be set")
-	assertions.Equal(t, "test-config", testRepo.LocalConfigFile, "Config file should be set")
-	assertions.True(t, testRepo.UseLocal, "UseLocal should be set to true")
-}

cmd/utils/config.go

@@ -1,78 +0,0 @@
-package utils
-
-import (
-	"fmt"
-
-	"github.com/spf13/viper"
-)
-
-// Wording represents the keywords to look for in commit messages
-type Wording struct {
-	Patch   []string
-	Minor   []string
-	Major   []string
-	Release []string
-}
-
-// Force represents forced versioning settings
-type Force struct {
-	Commit   string
-	Patch    int
-	Minor    int
-	Major    int
-	Existing bool
-	Strict   bool
-}
-
-// Config represents the application configuration
-type Config struct {
-	Wording     Wording
-	Force       Force
-	Blacklist   []string
-	TagPrefixes []string // Prefixes to strip from tags before parsing (e.g., "app-", "infra-", "v")
-}
-
-// ReadConfig reads the configuration from a file
-func ReadConfig(file string) (*Config, error) {
-	config := &Config{}
-
-	viper.SetConfigFile(file)
-	err := viper.ReadInConfig()
-	if err != nil {
-		err = fmt.Errorf("fatal error config file: %s", err)
-		return config, err
-	}
-
-	if err := viper.UnmarshalKey("wording", &config.Wording); err != nil {
-		return config, fmt.Errorf("error parsing wording config: %w", err)
-	}
-	if err := viper.UnmarshalKey("force", &config.Force); err != nil {
-		return config, fmt.Errorf("error parsing force config: %w", err)
-	}
-	if err := viper.UnmarshalKey("blacklist", &config.Blacklist); err != nil {
-		return config, fmt.Errorf("error parsing blacklist config: %w", err)
-	}
-	if err := viper.UnmarshalKey("tag_prefixes", &config.TagPrefixes); err != nil {
-		return config, fmt.Errorf("error parsing tag_prefixes config: %w", err)
-	}
-
-	return config, nil
-}
-
-// ApplyForcedVersioning applies forced versioning settings to a semantic version
-func ApplyForcedVersioning(force Force, semver *SemVer) {
-	if force.Major > 0 {
-		Debug("Forced versioning (MAJOR)", map[string]interface{}{"major": force.Major})
-		semver.Major = force.Major
-	}
-
-	if force.Minor > 0 {
-		Debug("Forced versioning (MINOR)", map[string]interface{}{"minor": force.Minor})
-		semver.Minor = force.Minor
-	}
-
-	if force.Patch > 0 {
-		Debug("Forced versioning (PATCH)", map[string]interface{}{"patch": force.Patch})
-		semver.Patch = force.Patch
-	}
-}

cmd/utils/config_test.go

@@ -1,201 +0,0 @@
-package utils
-
-import (
-	"os"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-)
-
-func TestApplyForcedVersioning(t *testing.T) {
-	tests := []struct {
-		name   string
-		force  Force
-		semver SemVer
-		want   SemVer
-	}{
-		{
-			name: "No forced versioning",
-			force: Force{
-				Major: 0,
-				Minor: 0,
-				Patch: 0,
-			},
-			semver: SemVer{
-				Major: 1,
-				Minor: 2,
-				Patch: 3,
-			},
-			want: SemVer{
-				Major: 1,
-				Minor: 2,
-				Patch: 3,
-			},
-		},
-		{
-			name: "Force major version",
-			force: Force{
-				Major: 5,
-				Minor: 0,
-				Patch: 0,
-			},
-			semver: SemVer{
-				Major: 1,
-				Minor: 2,
-				Patch: 3,
-			},
-			want: SemVer{
-				Major: 5,
-				Minor: 2,
-				Patch: 3,
-			},
-		},
-		{
-			name: "Force minor version",
-			force: Force{
-				Major: 0,
-				Minor: 7,
-				Patch: 0,
-			},
-			semver: SemVer{
-				Major: 1,
-				Minor: 2,
-				Patch: 3,
-			},
-			want: SemVer{
-				Major: 1,
-				Minor: 7,
-				Patch: 3,
-			},
-		},
-		{
-			name: "Force patch version",
-			force: Force{
-				Major: 0,
-				Minor: 0,
-				Patch: 9,
-			},
-			semver: SemVer{
-				Major: 1,
-				Minor: 2,
-				Patch: 3,
-			},
-			want: SemVer{
-				Major: 1,
-				Minor: 2,
-				Patch: 9,
-			},
-		},
-		{
-			name: "Force all versions",
-			force: Force{
-				Major: 5,
-				Minor: 7,
-				Patch: 9,
-			},
-			semver: SemVer{
-				Major: 1,
-				Minor: 2,
-				Patch: 3,
-			},
-			want: SemVer{
-				Major: 5,
-				Minor: 7,
-				Patch: 9,
-			},
-		},
-	}
-
-	// Initialize logger for tests
-	InitLogger(false)
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			semver := tt.semver
-			ApplyForcedVersioning(tt.force, &semver)
-			assert.Equal(t, tt.want.Major, semver.Major, "Major version mismatch")
-			assert.Equal(t, tt.want.Minor, semver.Minor, "Minor version mismatch")
-			assert.Equal(t, tt.want.Patch, semver.Patch, "Patch version mismatch")
-		})
-	}
-}
-
-func TestReadConfig(t *testing.T) {
-	// Create a temporary config file for testing
-	configContent := `
-version: 1
-force:
-  major: 2
-  minor: 3
-  patch: 4
-  commit: abcdef1234567890
-  existing: true
-  strict: false
-blacklist:
-  - "Merge branch"
-  - "Merge pull request"
-wording:
-  patch:
-    - update
-    - fix
-  minor:
-    - change
-    - feature
-  major:
-    - breaking
-  release:
-    - release-candidate
-`
-	tempFile, err := os.CreateTemp("", "semver-config-*.yaml")
-	if err != nil {
-		t.Fatalf("Failed to create temp file: %v", err)
-	}
-	defer os.Remove(tempFile.Name())
-
-	if _, err := tempFile.Write([]byte(configContent)); err != nil {
-		t.Fatalf("Failed to write to temp file: %v", err)
-	}
-	if err := tempFile.Close(); err != nil {
-		t.Fatalf("Failed to close temp file: %v", err)
-	}
-
-	// Initialize logger for tests
-	InitLogger(false)
-
-	// Test reading the config
-	config, err := ReadConfig(tempFile.Name())
-	assert.NoError(t, err)
-	assert.NotNil(t, config)
-
-	// Verify force settings
-	assert.Equal(t, 2, config.Force.Major)
-	assert.Equal(t, 3, config.Force.Minor)
-	assert.Equal(t, 4, config.Force.Patch)
-	assert.Equal(t, "abcdef1234567890", config.Force.Commit)
-	assert.True(t, config.Force.Existing)
-	assert.False(t, config.Force.Strict)
-
-	// Verify blacklist
-	assert.Len(t, config.Blacklist, 2)
-	assert.Contains(t, config.Blacklist, "Merge branch")
-	assert.Contains(t, config.Blacklist, "Merge pull request")
-
-	// Verify wording
-	assert.Len(t, config.Wording.Patch, 2)
-	assert.Contains(t, config.Wording.Patch, "update")
-	assert.Contains(t, config.Wording.Patch, "fix")
-
-	assert.Len(t, config.Wording.Minor, 2)
-	assert.Contains(t, config.Wording.Minor, "change")
-	assert.Contains(t, config.Wording.Minor, "feature")
-
-	assert.Len(t, config.Wording.Major, 1)
-	assert.Contains(t, config.Wording.Major, "breaking")
-
-	assert.Len(t, config.Wording.Release, 1)
-	assert.Contains(t, config.Wording.Release, "release-candidate")
-
-	// Test reading a non-existent config
-	_, err = ReadConfig("non-existent-file.yaml")
-	assert.Error(t, err)
-}

cmd/utils/git.go

@@ -1,196 +0,0 @@
-package utils
-
-import (
-	"fmt"
-	"net/url"
-	"os"
-	"sort"
-	"time"
-
-	git "github.com/go-git/go-git/v5"
-	"github.com/go-git/go-git/v5/plumbing"
-	"github.com/go-git/go-git/v5/plumbing/object"
-	"github.com/go-git/go-git/v5/plumbing/transport/http"
-)
-
-// CommitDetails represents a git commit
-type CommitDetails struct {
-	Timestamp time.Time
-	Hash      string
-	Author    string
-	Message   string
-}
-
-// TagDetails represents a git tag
-type TagDetails struct {
-	Name string
-	Hash string
-}
-
-// GitRepository represents a git repository
-type GitRepository struct {
-	Handler     *git.Repository
-	Name        string
-	Branch      string
-	LocalPath   string
-	UseLocal    bool
-	Commits     []CommitDetails
-	Tags        []TagDetails
-	StartCommit string
-}
-
-// PrepareRepository prepares the git repository for use
-func PrepareRepository(repo *GitRepository) error {
-	var err error
-
-	if !repo.UseLocal {
-		u, err := url.Parse(repo.Name)
-		if err != nil {
-			Error("Unable to parse repository URL", map[string]interface{}{
-				"error": err.Error(),
-				"url":   repo.Name,
-			})
-			return err
-		}
-
-		repo.LocalPath = fmt.Sprintf("/tmp/semver/%s/%s", u.Path, repo.Branch)
-		_ = os.RemoveAll(repo.LocalPath) // Ignore error - directory may not exist
-
-		repo.Handler, err = git.PlainClone(repo.LocalPath, false, &git.CloneOptions{
-			URL:           repo.Name,
-			ReferenceName: plumbing.NewBranchReferenceName(repo.Branch),
-			SingleBranch:  true,
-			Auth: &http.BasicAuth{
-				Username: os.Getenv("GITHUB_USERNAME"),
-				Password: os.Getenv("GITHUB_TOKEN"),
-			},
-			Tags: git.AllTags,
-		})
-
-		if err != nil {
-			Error("Unable to clone repository", map[string]interface{}{
-				"error": err.Error(),
-				"url":   repo.Name,
-			})
-			return err
-		}
-	} else {
-		repo.LocalPath = "./"
-		repo.Handler, err = git.PlainOpen(repo.LocalPath)
-		if err != nil {
-			Error("Unable to open local repository", map[string]interface{}{
-				"error": err.Error(),
-				"path":  repo.LocalPath,
-			})
-			return err
-		}
-	}
-
-	if err := os.Chdir(repo.LocalPath); err != nil {
-		Error("Unable to change directory", map[string]interface{}{
-			"error": err.Error(),
-			"path":  repo.LocalPath,
-		})
-		return err
-	}
-	return nil
-}
-
-// ListCommits lists all commits in the repository
-func ListCommits(repo *GitRepository) ([]CommitDetails, error) {
-	var ref *plumbing.Reference
-	var err error
-
-	// Check if Handler is nil to avoid panic
-	if repo.Handler == nil {
-		Debug("Repository handler is nil, skipping commit listing", nil)
-		return repo.Commits, nil
-	}
-
-	ref, err = repo.Handler.Head()
-	if err != nil {
-		return []CommitDetails{}, err
-	}
-
-	commitsList, err := repo.Handler.Log(&git.LogOptions{From: ref.Hash()})
-	if err != nil {
-		return []CommitDetails{}, err
-	}
-
-	var tmpResults []CommitDetails
-	if err := commitsList.ForEach(func(c *object.Commit) error {
-		tmpResults = append(tmpResults, CommitDetails{
-			Hash:      c.Hash.String(),
-			Author:    c.Author.String(),
-			Message:   c.Message,
-			Timestamp: c.Author.When,
-		})
-		sort.Slice(tmpResults, func(i, j int) bool {
-			return tmpResults[i].Timestamp.Unix() < tmpResults[j].Timestamp.Unix()
-		})
-		return nil
-	}); err != nil {
-		return []CommitDetails{}, err
-	}
-
-	Debug("Listing commits", map[string]interface{}{"commits": tmpResults})
-
-	// Filter commits starting after the specified commit if provided
-	if repo.StartCommit != "" {
-		found := false
-		for commitId, cmt := range tmpResults {
-			if cmt.Hash == repo.StartCommit {
-				Debug("Found commit match", map[string]interface{}{
-					"commit": cmt.Hash,
-					"index":  commitId,
-				})
-				// Start from the commit AFTER the specified one
-				repo.Commits = tmpResults[commitId+1:]
-				found = true
-				break
-			}
-		}
-		if !found {
-			// If specified commit not found, use all commits
-			repo.Commits = tmpResults
-		}
-	} else {
-		repo.Commits = tmpResults
-	}
-
-	Debug("Commits after filtering", map[string]interface{}{"commits": repo.Commits})
-	return repo.Commits, err
-}
-
-// ListExistingTags lists all tags in the repository
-func ListExistingTags(repo *GitRepository) {
-	Debug("Listing existing tags", nil)
-
-	// Check if Handler is nil to avoid panic
-	if repo.Handler == nil {
-		Debug("Repository handler is nil, skipping tag listing", nil)
-		return
-	}
-
-	refs, err := repo.Handler.Tags()
-	if err != nil {
-		Error("Unable to list tags", map[string]interface{}{"error": err.Error()})
-		return
-	}
-
-	if err := refs.ForEach(func(ref *plumbing.Reference) error {
-		repo.Tags = append(repo.Tags, TagDetails{
-			Name: ref.Name().Short(),
-			Hash: ref.Hash().String(),
-		})
-
-		Debug("Found tag", map[string]interface{}{
-			"tag":  ref.Name().Short(),
-			"hash": ref.Hash().String(),
-		})
-
-		return nil
-	}); err != nil {
-		Error("Error iterating tags", map[string]interface{}{"error": err.Error()})
-	}
-}

cmd/utils/git_test.go

@@ -1,150 +0,0 @@
-package utils
-
-import (
-	"os"
-	"testing"
-	"time"
-
-	"github.com/stretchr/testify/assert"
-)
-
-func TestPrepareRepository(t *testing.T) {
-	// Initialize logger
-	InitLogger(true)
-
-	// Test with an invalid repository URL
-	t.Run("Invalid repository URL", func(t *testing.T) {
-		invalidRepo := &GitRepository{
-			Name:   "://invalid-url",
-			Branch: "main",
-		}
-		err := PrepareRepository(invalidRepo)
-		assert.Error(t, err, "Should error with invalid repository URL")
-	})
-
-	// Test with local repository
-	t.Run("Local repository", func(t *testing.T) {
-		// Create a temporary directory
-		tempDir, err := os.MkdirTemp("", "git-test-*")
-		if err != nil {
-			t.Fatalf("Failed to create temp directory: %v", err)
-		}
-		defer os.RemoveAll(tempDir)
-
-		// Save current directory
-		currentDir, err := os.Getwd()
-		if err != nil {
-			t.Fatalf("Failed to get current directory: %v", err)
-		}
-		defer os.Chdir(currentDir)
-
-		// Change to temp directory
-		os.Chdir(tempDir)
-
-		// Initialize git repository
-		_, err = os.Create(".git")
-		if err != nil {
-			t.Fatalf("Failed to create .git file: %v", err)
-		}
-
-		// Test with local repository
-		localRepo := &GitRepository{
-			UseLocal: true,
-		}
-		err = PrepareRepository(localRepo)
-		assert.Error(t, err, "Should error with invalid local repository")
-		assert.Equal(t, "./", localRepo.LocalPath, "Local path should be set to current directory")
-	})
-}
-
-func TestListCommits(t *testing.T) {
-	// Initialize logger
-	InitLogger(true)
-
-	t.Run("Test commit filtering logic", func(t *testing.T) {
-		// Create a test repository with predefined commits
-		repo := &GitRepository{}
-
-		// Manually populate the commits for testing
-		repo.Commits = []CommitDetails{
-			{
-				Hash:      "abc123",
-				Author:    "Test Author",
-				Message:   "feat: first commit",
-				Timestamp: time.Now().Add(-2 * time.Hour),
-			},
-			{
-				Hash:      "def456",
-				Author:    "Test Author",
-				Message:   "fix: second commit",
-				Timestamp: time.Now().Add(-1 * time.Hour),
-			},
-		}
-
-		// Test with StartCommit specified
-		repo.StartCommit = "def456"
-
-		// Instead of calling ListCommits which would try to use the nil Handler,
-		// we'll just test the filtering logic directly
-		if repo.StartCommit != "" {
-			for commitId, cmt := range repo.Commits {
-				if cmt.Hash == repo.StartCommit {
-					repo.Commits = repo.Commits[commitId:]
-					break
-				}
-			}
-		}
-
-		// Verify the filtering worked correctly
-		assert.Len(t, repo.Commits, 1, "Should filter commits starting from specified hash")
-		assert.Equal(t, "def456", repo.Commits[0].Hash, "Commit hash should match")
-	})
-
-	t.Run("Test with nil Handler", func(t *testing.T) {
-		// Create a test repository with nil Handler
-		repo := &GitRepository{}
-
-		// Now we can safely call ListCommits since we've added a nil check
-		commits, err := ListCommits(repo)
-
-		// Verify the function returns without error
-		assert.NoError(t, err, "Should not error with nil Handler")
-		assert.Empty(t, commits, "Should return empty commits with nil Handler")
-	})
-}
-
-func TestListExistingTags(t *testing.T) {
-	// Initialize logger
-	InitLogger(true)
-
-	t.Run("Test tag processing", func(t *testing.T) {
-		// Create a test repository
-		repo := &GitRepository{}
-
-		// Since we can't test the actual git operations, we'll test the function's behavior
-		// by manually setting up the repository state
-
-		// Manually add tags to verify they're processed correctly
-		repo.Tags = []TagDetails{
-			{
-				Name: "v1.0.0",
-				Hash: "abc123",
-			},
-		}
-
-		assert.Len(t, repo.Tags, 1, "Should have 1 tag")
-		assert.Equal(t, "v1.0.0", repo.Tags[0].Name, "Tag name should match")
-		assert.Equal(t, "abc123", repo.Tags[0].Hash, "Tag hash should match")
-	})
-
-	t.Run("Test with nil Handler", func(t *testing.T) {
-		// Create a test repository with nil Handler
-		repo := &GitRepository{}
-
-		// Now we can safely call ListExistingTags since we've added a nil check
-		ListExistingTags(repo)
-
-		// Verify no tags were added
-		assert.Empty(t, repo.Tags, "Should have no tags after calling with nil Handler")
-	})
-}

cmd/utils/github.go

@@ -1,359 +0,0 @@
-package utils
-
-import (
-	"context"
-	"encoding/json"
-	"fmt"
-	"io"
-	"net/http"
-	"os"
-	"os/exec"
-	"runtime"
-	"strings"
-	"time"
-)
-
-const (
-	// GitHub API endpoint for latest release
-	githubReleasesURL = "https://api.github.com/repos/lukaszraczylo/semver-generator/releases/latest"
-	// Request timeout for HTTP requests
-	requestTimeout = 10 * time.Second
-)
-
-// ReleaseInfo contains information about a GitHub release
-type ReleaseInfo struct {
-	TagName string         `json:"tag_name"`
-	HTMLURL string         `json:"html_url"`
-	Name    string         `json:"name"`
-	Assets  []ReleaseAsset `json:"assets"`
-}
-
-// ReleaseAsset contains information about a release asset
-type ReleaseAsset struct {
-	Name               string `json:"name"`
-	BrowserDownloadURL string `json:"browser_download_url"`
-}
-
-// httpClient is the HTTP client used for requests (allows mocking in tests)
-var httpClient = &http.Client{
-	Timeout: requestTimeout,
-}
-
-// CheckLatestRelease checks for the latest release version using REST API
-// Returns the latest version tag and true if successful, empty string and false otherwise
-func CheckLatestRelease() (string, bool) {
-	release, err := fetchLatestRelease(context.Background())
-	if err != nil {
-		Debug("Unable to check latest release", map[string]interface{}{"error": err.Error()})
-		return "", false
-	}
-
-	version := normalizeVersion(release.TagName)
-	return version, true
-}
-
-// UpdatePackage downloads and installs the latest version
-func UpdatePackage() bool {
-	Info("Checking for updates", nil)
-
-	release, err := fetchLatestRelease(context.Background())
-	if err != nil {
-		Error("Unable to fetch latest release", map[string]interface{}{"error": err.Error()})
-		return false
-	}
-
-	downloadURL := findBinaryAsset(release.Assets)
-	if downloadURL == "" {
-		Error("Unable to find binary for current platform", map[string]interface{}{
-			"os":   runtime.GOOS,
-			"arch": runtime.GOARCH,
-		})
-		return false
-	}
-
-	Info("Downloading update", map[string]interface{}{
-		"version": release.TagName,
-		"url":     downloadURL,
-	})
-
-	// Download to temp file
-	tempFile, err := downloadBinary(downloadURL)
-	if err != nil {
-		Error("Unable to download binary", map[string]interface{}{"error": err.Error()})
-		return false
-	}
-	defer os.Remove(tempFile) // Clean up temp file on failure
-
-	// Get current binary path
-	currentBinary, err := os.Executable()
-	if err != nil {
-		Error("Unable to get current binary path", map[string]interface{}{"error": err.Error()})
-		return false
-	}
-
-	// Replace current binary
-	if err := replaceBinary(tempFile, currentBinary); err != nil {
-		Error("Unable to replace binary", map[string]interface{}{"error": err.Error()})
-		return false
-	}
-
-	Info("Update successful", map[string]interface{}{
-		"version": release.TagName,
-	})
-	return true
-}
-
-// fetchLatestRelease fetches the latest release info from GitHub REST API
-func fetchLatestRelease(ctx context.Context) (*ReleaseInfo, error) {
-	req, err := http.NewRequestWithContext(ctx, http.MethodGet, githubReleasesURL, nil)
-	if err != nil {
-		return nil, err
-	}
-
-	req.Header.Set("Accept", "application/vnd.github.v3+json")
-	req.Header.Set("User-Agent", "semver-generator")
-
-	resp, err := httpClient.Do(req)
-	if err != nil {
-		return nil, err
-	}
-	defer resp.Body.Close()
-
-	if resp.StatusCode != http.StatusOK {
-		return nil, fmt.Errorf("GitHub API returned status %d", resp.StatusCode)
-	}
-
-	var release ReleaseInfo
-	if err := json.NewDecoder(resp.Body).Decode(&release); err != nil {
-		return nil, err
-	}
-
-	return &release, nil
-}
-
-// findBinaryAsset finds the download URL for the current platform
-func findBinaryAsset(assets []ReleaseAsset) string {
-	// Build expected binary name pattern
-	// Format: semver-gen-{version}-{os}-{arch}.tar.gz or just semver-gen-{os}-{arch}
-	osName := runtime.GOOS
-	archName := runtime.GOARCH
-
-	for _, asset := range assets {
-		name := strings.ToLower(asset.Name)
-		// Match patterns like "semver-gen-1.0.0-darwin-arm64.tar.gz" or "semver-gen-darwin-arm64"
-		if strings.Contains(name, osName) && strings.Contains(name, archName) {
-			// Prefer tar.gz archives
-			if strings.HasSuffix(name, ".tar.gz") {
-				return asset.BrowserDownloadURL
-			}
-		}
-	}
-
-	// Fallback: try to find any matching binary without tar.gz
-	for _, asset := range assets {
-		name := strings.ToLower(asset.Name)
-		if strings.Contains(name, osName) && strings.Contains(name, archName) {
-			// Skip checksums
-			if strings.Contains(name, "checksum") || strings.HasSuffix(name, ".sha256") || strings.HasSuffix(name, ".md5") {
-				continue
-			}
-			return asset.BrowserDownloadURL
-		}
-	}
-
-	return ""
-}
-
-// downloadBinary downloads the binary to a temp file and returns the path
-func downloadBinary(url string) (string, error) {
-	resp, err := httpClient.Get(url)
-	if err != nil {
-		return "", err
-	}
-	defer resp.Body.Close()
-
-	if resp.StatusCode != http.StatusOK {
-		return "", fmt.Errorf("download failed with status %d", resp.StatusCode)
-	}
-
-	// Create temp file
-	tempFile, err := os.CreateTemp("", "semver-generator-update-*")
-	if err != nil {
-		return "", err
-	}
-	tempPath := tempFile.Name()
-
-	// Check if it's a tar.gz archive
-	if strings.HasSuffix(url, ".tar.gz") {
-		// For tar.gz, we need to extract the binary
-		if err := extractTarGz(resp.Body, tempFile); err != nil {
-			_ = tempFile.Close()
-			_ = os.Remove(tempPath)
-			return "", err
-		}
-	} else {
-		// Direct binary download
-		if _, err := io.Copy(tempFile, resp.Body); err != nil {
-			_ = tempFile.Close()
-			_ = os.Remove(tempPath)
-			return "", err
-		}
-	}
-
-	if err := tempFile.Close(); err != nil {
-		_ = os.Remove(tempPath)
-		return "", err
-	}
-	return tempPath, nil
-}
-
-// extractTarGz extracts the semver-generator binary from a tar.gz archive
-func extractTarGz(r io.Reader, destFile *os.File) error {
-	// For simplicity, we'll download the whole archive to a temp file first,
-	// then use tar command to extract. This avoids adding archive/tar dependency.
-
-	// Create temp archive file
-	archiveFile, err := os.CreateTemp("", "semver-generator-archive-*.tar.gz")
-	if err != nil {
-		return err
-	}
-	archivePath := archiveFile.Name()
-	defer os.Remove(archivePath)
-
-	if _, err := io.Copy(archiveFile, r); err != nil {
-		_ = archiveFile.Close()
-		return err
-	}
-	if err := archiveFile.Close(); err != nil {
-		return err
-	}
-
-	// Extract using tar command
-	extractDir, err := os.MkdirTemp("", "semver-generator-extract-*")
-	if err != nil {
-		return err
-	}
-	defer os.RemoveAll(extractDir)
-
-	// Use tar to extract
-	cmd := fmt.Sprintf("tar -xzf %s -C %s", archivePath, extractDir)
-	if err := runCommand(cmd); err != nil {
-		return fmt.Errorf("failed to extract archive: %w", err)
-	}
-
-	// Find the binary in the extracted files
-	// Support both new name (semver-generator) and old name (semver-gen) for backwards compatibility
-	binaryPath := ""
-	entries, err := os.ReadDir(extractDir)
-	if err != nil {
-		return err
-	}
-
-	// First try to find semver-generator (new name)
-	for _, entry := range entries {
-		if entry.Name() == "semver-generator" {
-			binaryPath = fmt.Sprintf("%s/%s", extractDir, entry.Name())
-			break
-		}
-	}
-
-	// Fallback to semver-gen (old name) for older releases
-	if binaryPath == "" {
-		for _, entry := range entries {
-			if entry.Name() == "semver-gen" {
-				binaryPath = fmt.Sprintf("%s/%s", extractDir, entry.Name())
-				break
-			}
-		}
-	}
-
-	if binaryPath == "" {
-		return fmt.Errorf("binary not found in archive (looked for semver-generator and semver-gen)")
-	}
-
-	// Copy the binary to the destination
-	srcFile, err := os.Open(binaryPath)
-	if err != nil {
-		return err
-	}
-	defer srcFile.Close()
-
-	// Seek to beginning of dest file and truncate
-	if _, err := destFile.Seek(0, 0); err != nil {
-		return err
-	}
-	if err := destFile.Truncate(0); err != nil {
-		return err
-	}
-
-	if _, err := io.Copy(destFile, srcFile); err != nil {
-		return err
-	}
-
-	return nil
-}
-
-// runCommand runs a shell command
-func runCommand(cmdStr string) error {
-	return runCommandFunc(cmdStr)
-}
-
-// runCommandFunc is the function used to run commands (allows mocking in tests)
-var runCommandFunc = func(cmdStr string) error {
-	cmd := exec.Command("sh", "-c", cmdStr)
-	cmd.Stdout = os.Stdout
-	cmd.Stderr = os.Stderr
-	return cmd.Run()
-}
-
-// replaceBinary replaces the current binary with the new one
-func replaceBinary(newBinary, currentBinary string) error {
-	// Make the new binary executable
-	// #nosec G302 -- 0755 is required for executable binaries
-	if err := os.Chmod(newBinary, 0755); err != nil {
-		return err
-	}
-
-	// Rename (atomic on most systems)
-	if err := os.Rename(newBinary, currentBinary); err != nil {
-		// If rename fails (e.g., cross-device), try copy
-		return copyFile(newBinary, currentBinary)
-	}
-
-	return nil
-}
-
-// copyFile copies a file from src to dst
-// Note: This function is only called internally with controlled paths from
-// os.CreateTemp and os.Executable, not with user-supplied paths.
-func copyFile(src, dst string) error {
-	// #nosec G304 -- src is from os.CreateTemp, not user input
-	srcFile, err := os.Open(src)
-	if err != nil {
-		return err
-	}
-	defer srcFile.Close()
-
-	// #nosec G304 -- dst is from os.Executable, not user input
-	dstFile, err := os.Create(dst)
-	if err != nil {
-		return err
-	}
-	defer dstFile.Close()
-
-	if _, err := io.Copy(dstFile, srcFile); err != nil {
-		return err
-	}
-
-	// Make executable
-	// #nosec G302 -- 0755 is required for executable binaries
-	return os.Chmod(dst, 0755)
-}
-
-// normalizeVersion removes 'v' or 'V' prefix and trims whitespace
-func normalizeVersion(v string) string {
-	v = strings.TrimSpace(v)
-	v = strings.TrimPrefix(v, "v")
-	v = strings.TrimPrefix(v, "V")
-	return v
-}

cmd/utils/github_test.go

@@ -1,160 +0,0 @@
-package utils
-
-import (
-	"net/http"
-	"net/http/httptest"
-	"os"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-)
-
-func TestNormalizeVersion(t *testing.T) {
-	tests := []struct {
-		input    string
-		expected string
-	}{
-		{"v1.0.0", "1.0.0"},
-		{"1.0.0", "1.0.0"},
-		{"  v2.1.3  ", "2.1.3"},
-		{"V1.0.0", "1.0.0"},
-		{"v", ""},
-		{"", ""},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.input, func(t *testing.T) {
-			result := normalizeVersion(tt.input)
-			assert.Equal(t, tt.expected, result)
-		})
-	}
-}
-
-func TestFindBinaryAsset(t *testing.T) {
-	assets := []ReleaseAsset{
-		{Name: "semver-gen-1.0.0-linux-amd64.tar.gz", BrowserDownloadURL: "https://example.com/linux-amd64.tar.gz"},
-		{Name: "semver-gen-1.0.0-darwin-arm64.tar.gz", BrowserDownloadURL: "https://example.com/darwin-arm64.tar.gz"},
-		{Name: "semver-gen-1.0.0-darwin-amd64.tar.gz", BrowserDownloadURL: "https://example.com/darwin-amd64.tar.gz"},
-		{Name: "semver-gen-1.0.0-windows-amd64.zip", BrowserDownloadURL: "https://example.com/windows-amd64.zip"},
-		{Name: "semver-gen-1.0.0-checksums.txt", BrowserDownloadURL: "https://example.com/checksums.txt"},
-	}
-
-	// Test finding the correct asset for the current platform
-	url := findBinaryAsset(assets)
-	assert.NotEmpty(t, url, "Should find a binary for the current platform")
-	assert.NotContains(t, url, "checksum", "Should not return checksum file")
-}
-
-func TestFindBinaryAssetEmpty(t *testing.T) {
-	assets := []ReleaseAsset{}
-	url := findBinaryAsset(assets)
-	assert.Empty(t, url, "Should return empty string when no assets")
-}
-
-func TestCheckLatestRelease(t *testing.T) {
-	// Initialize logger
-	InitLogger(false)
-
-	// Create a mock server
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		w.Header().Set("Content-Type", "application/json")
-		w.WriteHeader(http.StatusOK)
-		w.Write([]byte(`{
-			"tag_name": "v1.2.3",
-			"html_url": "https://github.com/lukaszraczylo/semver-generator/releases/tag/v1.2.3",
-			"name": "Release 1.2.3",
-			"assets": []
-		}`))
-	}))
-	defer server.Close()
-
-	// Note: In a real test, we'd need to mock the HTTP client or the URL
-	// For now, we just test the network error case
-	release, ok := CheckLatestRelease()
-	// This will either succeed (if network is available) or fail gracefully
-	if ok {
-		assert.NotEmpty(t, release)
-	}
-}
-
-func TestFetchLatestReleaseError(t *testing.T) {
-	InitLogger(false)
-
-	// Save original client
-	originalClient := httpClient
-	defer func() { httpClient = originalClient }()
-
-	// Create a mock server that returns an error
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		w.WriteHeader(http.StatusInternalServerError)
-	}))
-	defer server.Close()
-
-	// We can't easily test this without modifying the URL constant
-	// but we can test the error handling by checking that it fails gracefully
-	release, ok := CheckLatestRelease()
-	// The result depends on whether the real GitHub API is accessible
-	_ = release
-	_ = ok
-}
-
-func TestCopyFile(t *testing.T) {
-	// Create a temp source file
-	srcContent := []byte("test content")
-	srcFile, err := os.CreateTemp("", "test-*")
-	assert.NoError(t, err)
-	defer os.Remove(srcFile.Name())
-
-	_, err = srcFile.Write(srcContent)
-	assert.NoError(t, err)
-	srcFile.Close()
-
-	// Create destination path
-	dstPath := srcFile.Name() + ".copy"
-	defer os.Remove(dstPath)
-
-	// Copy the file
-	err = copyFile(srcFile.Name(), dstPath)
-	assert.NoError(t, err)
-
-	// Verify the content
-	content, err := os.ReadFile(dstPath)
-	assert.NoError(t, err)
-	assert.Equal(t, srcContent, content)
-}
-
-func TestReplaceBinary(t *testing.T) {
-	// Create a temp "new" binary
-	newContent := []byte("new binary content")
-	newFile, err := os.CreateTemp("", "new-binary-*")
-	assert.NoError(t, err)
-	defer os.Remove(newFile.Name())
-
-	_, err = newFile.Write(newContent)
-	assert.NoError(t, err)
-	newFile.Close()
-
-	// Create a temp "current" binary
-	currentFile, err := os.CreateTemp("", "current-binary-*")
-	assert.NoError(t, err)
-	currentPath := currentFile.Name()
-	defer os.Remove(currentPath)
-	currentFile.Close()
-
-	// Replace the binary
-	err = replaceBinary(newFile.Name(), currentPath)
-	assert.NoError(t, err)
-
-	// Verify the content was replaced
-	content, err := os.ReadFile(currentPath)
-	assert.NoError(t, err)
-	assert.Equal(t, newContent, content)
-}
-
-func TestUpdatePackageNoBinary(t *testing.T) {
-	InitLogger(false)
-
-	// This test verifies UpdatePackage handles the case where no binary is found
-	// by testing with a mock that returns empty assets
-	// Note: This would need proper mocking of httpClient to test fully
-}

cmd/utils/logging.go

@@ -1,59 +0,0 @@
-package utils
-
-import (
-	"os"
-
-	libpack_logging "github.com/lukaszraczylo/graphql-monitoring-proxy/logging"
-)
-
-// Logger is a global logger instance
-var Logger *libpack_logging.Logger
-
-// InitLogger initializes the logger with the specified debug level
-func InitLogger(debug bool) *libpack_logging.Logger {
-	Logger = libpack_logging.New()
-	if debug {
-		Logger.SetOutput(os.Stdout).SetMinLogLevel(libpack_logging.LEVEL_DEBUG)
-	}
-	return Logger
-}
-
-// Debug logs a debug message
-func Debug(message string, pairs map[string]interface{}) {
-	if Logger != nil {
-		Logger.Debug(&libpack_logging.LogMessage{
-			Message: message,
-			Pairs:   pairs,
-		})
-	}
-}
-
-// Info logs an info message
-func Info(message string, pairs map[string]interface{}) {
-	if Logger != nil {
-		Logger.Info(&libpack_logging.LogMessage{
-			Message: message,
-			Pairs:   pairs,
-		})
-	}
-}
-
-// Error logs an error message
-func Error(message string, pairs map[string]interface{}) {
-	if Logger != nil {
-		Logger.Error(&libpack_logging.LogMessage{
-			Message: message,
-			Pairs:   pairs,
-		})
-	}
-}
-
-// Critical logs a critical message
-func Critical(message string, pairs map[string]interface{}) {
-	if Logger != nil {
-		Logger.Critical(&libpack_logging.LogMessage{
-			Message: message,
-			Pairs:   pairs,
-		})
-	}
-}

cmd/utils/logging_test.go

@@ -1,71 +0,0 @@
-package utils
-
-import (
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-)
-
-func TestInitLogger(t *testing.T) {
-	// Test with debug mode enabled
-	logger := InitLogger(true)
-	assert.NotNil(t, logger, "Logger should not be nil")
-	assert.NotNil(t, Logger, "Global logger should not be nil")
-
-	// Test with debug mode disabled
-	logger = InitLogger(false)
-	assert.NotNil(t, logger, "Logger should not be nil")
-	assert.NotNil(t, Logger, "Global logger should not be nil")
-}
-
-func TestLoggingFunctions(t *testing.T) {
-	// Initialize logger with debug mode
-	InitLogger(true)
-
-	// Just test that these don't panic
-	Debug("Debug message", map[string]interface{}{"key": "value"})
-	Info("Info message", map[string]interface{}{"key": "value"})
-	Error("Error message", map[string]interface{}{"key": "value"})
-
-	// Skip testing Critical as it might call os.Exit
-	// Critical("Critical message", map[string]interface{}{"key": "value"})
-
-	// Test passes if we get here without panicking
-	assert.True(t, true)
-}
-
-func TestLoggingWithNilLogger(t *testing.T) {
-	// Temporarily set logger to nil
-	oldLogger := Logger
-	Logger = nil
-	defer func() { Logger = oldLogger }()
-
-	// These should not panic
-	Debug("Debug message", map[string]interface{}{"key": "value"})
-	Info("Info message", map[string]interface{}{"key": "value"})
-	Error("Error message", map[string]interface{}{"key": "value"})
-
-	// Skip testing Critical as it might call os.Exit
-	// Critical("Critical message", map[string]interface{}{"key": "value"})
-
-	// Test passes if we get here without panicking
-	assert.True(t, true)
-}
-
-// TestCriticalNilLogger tests that the Critical function doesn't panic with a nil logger
-func TestCriticalNilLogger(t *testing.T) {
-	// Save original logger and restore after test
-	originalLogger := Logger
-	defer func() { Logger = originalLogger }()
-
-	// Set logger to nil
-	Logger = nil
-
-	// This should not panic
-	Critical("Critical message", map[string]interface{}{"key": "value"})
-
-	// Test passes if we get here without panicking
-	assert.True(t, true)
-}
-
-// Note: We don't test Critical with an actual logger because it calls os.Exit

cmd/utils/semver.go

@@ -1,114 +0,0 @@
-package utils
-
-import (
-	"strings"
-)
-
-// CalculateSemver calculates the semantic version based on commit messages
-func CalculateSemver(
-	commits []CommitDetails,
-	tags []TagDetails,
-	wording Wording,
-	blacklist []string,
-	initialSemver SemVer,
-	respectExisting bool,
-	strictMode bool,
-	tagPrefixes []string,
-) SemVer {
-	semver := initialSemver
-	startIndex := 0
-
-	// If respecting existing tags, find the latest tagged commit and start from there
-	if respectExisting && len(tags) > 0 {
-		latestTagIndex := -1
-		var latestTagName string
-
-		// Find the latest tagged commit (highest index since commits are oldest-first)
-		for i, commit := range commits {
-			for _, tag := range tags {
-				if commit.Hash == tag.Hash {
-					if i > latestTagIndex {
-						latestTagIndex = i
-						latestTagName = tag.Name
-					}
-				}
-			}
-		}
-
-		// If we found a tagged commit, use its version and start processing after it
-		if latestTagIndex >= 0 {
-			Debug("Found latest existing tag", map[string]interface{}{
-				"tag":    latestTagName,
-				"commit": strings.TrimSuffix(commits[latestTagIndex].Message, "\n"),
-			})
-			semver = ParseExistingSemver(latestTagName, semver, tagPrefixes)
-			startIndex = latestTagIndex + 1
-		}
-	}
-
-	for _, commit := range commits[startIndex:] {
-		// In non-strict mode, increment patch by default
-		if !strictMode {
-			semver.Patch++
-			Debug("Incrementing patch (DEFAULT)", map[string]interface{}{
-				"commit": strings.TrimSuffix(commit.Message, "\n"),
-				"semver": FormatSemver(semver),
-			})
-		}
-
-		// Check for keyword matches
-		commitSlice := strings.Fields(commit.Message)
-		matchPatch := CheckMatches(commitSlice, wording.Patch, blacklist)
-		matchMinor := CheckMatches(commitSlice, wording.Minor, blacklist)
-		matchMajor := CheckMatches(commitSlice, wording.Major, blacklist)
-		matchReleaseCandidate := CheckMatches(commitSlice, wording.Release, blacklist)
-
-		// Apply version changes based on matches
-		if matchMajor {
-			semver.Major++
-			semver.Minor = 0
-			semver.Patch = 1
-			semver.EnableReleaseCandidate = false
-			semver.Release = 0
-			Debug("Incrementing major (WORDING)", map[string]interface{}{
-				"commit": strings.TrimSuffix(commit.Message, "\n"),
-				"semver": FormatSemver(semver),
-			})
-			continue
-		}
-
-		if matchMinor {
-			semver.Minor++
-			semver.Patch = 1
-			semver.EnableReleaseCandidate = false
-			semver.Release = 0
-			Debug("Incrementing minor (WORDING)", map[string]interface{}{
-				"commit": strings.TrimSuffix(commit.Message, "\n"),
-				"semver": FormatSemver(semver),
-			})
-			continue
-		}
-
-		if matchReleaseCandidate {
-			semver.Release++
-			semver.Patch = 1
-			semver.EnableReleaseCandidate = true
-			Debug("Incrementing release candidate (WORDING)", map[string]interface{}{
-				"commit": strings.TrimSuffix(commit.Message, "\n"),
-				"semver": FormatSemver(semver),
-			})
-			continue
-		}
-
-		if matchPatch {
-			semver.Patch++
-			Debug("Incrementing patch (WORDING)", map[string]interface{}{
-				"commit": strings.TrimSuffix(commit.Message, "\n"),
-				"semver": FormatSemver(semver),
-			})
-			continue
-		}
-	}
-
-	return semver
-}

cmd/utils/semver_test.go

@@ -1,298 +0,0 @@
-package utils
-
-import (
-	"testing"
-	"time"
-
-	"github.com/stretchr/testify/assert"
-)
-
-func TestCalculateSemver(t *testing.T) {
-	// Initialize logger for tests
-	InitLogger(false)
-
-	// Mock the fuzzy find function for testing
-	originalFuzzyFind := FuzzyFind
-	defer func() { FuzzyFind = originalFuzzyFind }()
-
-	FuzzyFind = func(needle string, haystack []string) []string {
-		// More sophisticated mock implementation for testing
-		for _, h := range haystack {
-			// Check for substring match to better simulate fuzzy search
-			if h == needle || (len(h) >= 3 && len(needle) >= 3 &&
-				(h[:3] == needle[:3] || h[len(h)-3:] == needle[len(needle)-3:])) {
-				return []string{h}
-			}
-		}
-		return nil
-	}
-
-	// Test data
-	now := time.Now()
-
-	// Common wording and blacklist for all tests
-	wording := Wording{
-		Patch:   []string{"update", "fix", "initial"},
-		Minor:   []string{"change", "feature", "improve"},
-		Major:   []string{"breaking"},
-		Release: []string{"rc", "release-candidate"},
-	}
-
-	blacklist := []string{"skip-ci", "no-version"}
-
-	tests := []struct {
-		name            string
-		commits         []CommitDetails
-		tags            []TagDetails
-		wording         Wording
-		blacklist       []string
-		initialSemver   SemVer
-		respectExisting bool
-		strictMode      bool
-		tagPrefixes     []string
-		want            SemVer
-	}{
-		{
-			name: "Standard mode with existing tags",
-			commits: []CommitDetails{
-				{
-					Hash:      "commit1",
-					Message:   "Initial commit",
-					Timestamp: now.Add(-3 * time.Hour),
-				},
-				{
-					Hash:      "commit2",
-					Message:   "Update documentation",
-					Timestamp: now.Add(-2 * time.Hour),
-				},
-			},
-			tags: []TagDetails{
-				{
-					Name: "2.0.0",
-					Hash: "commit1",
-				},
-			},
-			wording:         wording,
-			blacklist:       blacklist,
-			initialSemver:   SemVer{},
-			respectExisting: true,
-			strictMode:      false,
-			tagPrefixes:     []string{},
-			want: SemVer{
-				Major:                  2,
-				Minor:                  0,
-				Patch:                  1, // Initial tag 2.0.0 + one patch increment
-				Release:                1,
-				EnableReleaseCandidate: true,
-			},
-		},
-		{
-			name: "Strict mode with existing tags",
-			commits: []CommitDetails{
-				{
-					Hash:      "commit1",
-					Message:   "Initial commit",
-					Timestamp: now.Add(-3 * time.Hour),
-				},
-				{
-					Hash:      "commit2",
-					Message:   "Update documentation",
-					Timestamp: now.Add(-2 * time.Hour),
-				},
-			},
-			tags: []TagDetails{
-				{
-					Name: "2.0.0",
-					Hash: "commit1",
-				},
-			},
-			wording:         wording,
-			blacklist:       blacklist,
-			initialSemver:   SemVer{},
-			respectExisting: true,
-			strictMode:      true,
-			tagPrefixes:     []string{},
-			want: SemVer{
-				Major:                  2,
-				Minor:                  0,
-				Patch:                  1, // Initial tag 2.0.0 + patch from "update" keyword
-				Release:                1,
-				EnableReleaseCandidate: true,
-			},
-		},
-		{
-			name: "Standard mode without existing tags",
-			commits: []CommitDetails{
-				{
-					Hash:      "commit1",
-					Message:   "Initial commit",
-					Timestamp: now.Add(-3 * time.Hour),
-				},
-				{
-					Hash:      "commit2",
-					Message:   "Update documentation",
-					Timestamp: now.Add(-2 * time.Hour),
-				},
-				{
-					Hash:      "commit3",
-					Message:   "Change API interface",
-					Timestamp: now.Add(-1 * time.Hour),
-				},
-			},
-			tags:            []TagDetails{},
-			wording:         wording,
-			blacklist:       blacklist,
-			initialSemver:   SemVer{},
-			respectExisting: false,
-			strictMode:      false,
-			tagPrefixes:     []string{},
-			want: SemVer{
-				Major: 0,
-				Minor: 1,
-				Patch: 1, // Minor increment resets patch to 1
-			},
-		},
-		{
-			name: "Strict mode without existing tags",
-			commits: []CommitDetails{
-				{
-					Hash:      "commit1",
-					Message:   "Initial commit",
-					Timestamp: now.Add(-3 * time.Hour),
-				},
-				{
-					Hash:      "commit2",
-					Message:   "Update documentation",
-					Timestamp: now.Add(-2 * time.Hour),
-				},
-				{
-					Hash:      "commit3",
-					Message:   "Change API interface",
-					Timestamp: now.Add(-1 * time.Hour),
-				},
-			},
-			tags:            []TagDetails{},
-			wording:         wording,
-			blacklist:       blacklist,
-			initialSemver:   SemVer{Major: 1},
-			respectExisting: false,
-			strictMode:      true,
-			tagPrefixes:     []string{},
-			want: SemVer{
-				Major: 1,
-				Minor: 1,
-				Patch: 1, // Minor increment resets patch to 1
-			},
-		},
-		{
-			name: "With blacklisted commits",
-			commits: []CommitDetails{
-				{
-					Hash:      "commit1",
-					Message:   "Initial commit",
-					Timestamp: now.Add(-3 * time.Hour),
-				},
-				{
-					Hash:      "commit2",
-					Message:   "Update documentation skip-ci",
-					Timestamp: now.Add(-2 * time.Hour),
-				},
-			},
-			tags:            []TagDetails{},
-			wording:         wording,
-			blacklist:       blacklist,
-			initialSemver:   SemVer{},
-			respectExisting: false,
-			strictMode:      false,
-			tagPrefixes:     []string{},
-			want: SemVer{
-				Major: 0,
-				Minor: 0,
-				Patch: 3, // Default patch increment + patch from initial
-			},
-		},
-		{
-			name: "With release candidate",
-			commits: []CommitDetails{
-				{
-					Hash:      "commit1",
-					Message:   "Initial commit",
-					Timestamp: now.Add(-3 * time.Hour),
-				},
-				{
-					Hash:      "commit2",
-					Message:   "Add release-candidate",
-					Timestamp: now.Add(-2 * time.Hour),
-				},
-			},
-			tags:            []TagDetails{},
-			wording:         wording,
-			blacklist:       blacklist,
-			initialSemver:   SemVer{},
-			respectExisting: false,
-			strictMode:      false,
-			tagPrefixes:     []string{},
-			want: SemVer{
-				Major:                  0,
-				Minor:                  0,
-				Patch:                  1,
-				Release:                1,
-				EnableReleaseCandidate: true,
-			},
-		},
-		{
-			name: "With prefixed tags should not be RC",
-			commits: []CommitDetails{
-				{
-					Hash:      "commit1",
-					Message:   "tagged commit",
-					Timestamp: now.Add(-3 * time.Hour),
-				},
-				{
-					Hash:      "commit2",
-					Message:   "another commit",
-					Timestamp: now.Add(-2 * time.Hour),
-				},
-			},
-			tags: []TagDetails{
-				{
-					Name: "app-0.0.16",
-					Hash: "commit1",
-				},
-			},
-			wording:         wording,
-			blacklist:       blacklist,
-			initialSemver:   SemVer{},
-			respectExisting: true,
-			strictMode:      true, // Use strict mode for predictable results
-			tagPrefixes:     []string{"app-", "infra-"},
-			want: SemVer{
-				Major:                  0,
-				Minor:                  0,
-				Patch:                  16, // From tag, no additional increments in strict mode
-				EnableReleaseCandidate: false,
-			},
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			got := CalculateSemver(
-				tt.commits,
-				tt.tags,
-				tt.wording,
-				tt.blacklist,
-				tt.initialSemver,
-				tt.respectExisting,
-				tt.strictMode,
-				tt.tagPrefixes,
-			)
-
-			assert.Equal(t, tt.want.Major, got.Major, "Major version mismatch")
-			assert.Equal(t, tt.want.Minor, got.Minor, "Minor version mismatch")
-			assert.Equal(t, tt.want.Patch, got.Patch, "Patch version mismatch")
-			assert.Equal(t, tt.want.Release, got.Release, "Release version mismatch")
-			assert.Equal(t, tt.want.EnableReleaseCandidate, got.EnableReleaseCandidate, "EnableReleaseCandidate mismatch")
-		})
-	}
-}

cmd/utils/version.go

@@ -1,185 +0,0 @@
-package utils
-
-import (
-	"regexp"
-	"strconv"
-	"strings"
-)
-
-// SemVer represents a semantic version
-type SemVer struct {
-	Patch                  int
-	Minor                  int
-	Major                  int
-	Release                int
-	EnableReleaseCandidate bool
-}
-
-// FormatSemver formats a semantic version as a string
-func FormatSemver(semver SemVer) string {
-	result := strings.TrimSpace(
-		strings.Join(
-			[]string{
-				strconv.Itoa(semver.Major),
-				strconv.Itoa(semver.Minor),
-				strconv.Itoa(semver.Patch),
-			},
-			".",
-		),
-	)
-
-	if semver.EnableReleaseCandidate {
-		result = strings.TrimSpace(
-			strings.Join(
-				[]string{
-					result,
-					strings.Join(
-						[]string{
-							"rc",
-							strconv.Itoa(semver.Release),
-						},
-						".",
-					),
-				},
-				"-",
-			),
-		)
-	}
-
-	return result
-}
-
-var extractNumber = regexp.MustCompile("[0-9]+")
-
-// StripTagPrefix removes configured prefixes from a tag name
-// The "v" prefix is always stripped by default (e.g., v1.2.3 -> 1.2.3)
-func StripTagPrefix(tagName string, prefixes []string) string {
-	result := tagName
-
-	// Always strip "v" prefix by default
-	if strings.HasPrefix(result, "v") && len(result) > 1 {
-		// Only strip if followed by a digit (to avoid stripping "version-1.0.0")
-		if result[1] >= '0' && result[1] <= '9' {
-			result = result[1:]
-			Debug("Stripped default 'v' prefix from tag", map[string]interface{}{
-				"original": tagName,
-				"result":   result,
-			})
-		}
-	}
-
-	// Then strip any user-configured prefixes
-	for _, prefix := range prefixes {
-		if strings.HasPrefix(result, prefix) {
-			result = strings.TrimPrefix(result, prefix)
-			Debug("Stripped prefix from tag", map[string]interface{}{
-				"original": tagName,
-				"prefix":   prefix,
-				"result":   result,
-			})
-			break // Only strip one prefix
-		}
-	}
-	return result
-}
-
-// ParseExistingSemver parses a semantic version from a tag name
-func ParseExistingSemver(tagName string, currentSemver SemVer, prefixes []string) SemVer {
-	Debug("Parsing existing semver", map[string]interface{}{"tag": tagName})
-
-	// Strip configured prefixes before parsing
-	cleanTagName := StripTagPrefix(tagName, prefixes)
-
-	// Check for release candidate pattern (-rc.X) before splitting
-	isReleaseCandidate := false
-	rcVersion := 0
-	if idx := strings.Index(cleanTagName, "-rc."); idx != -1 {
-		isReleaseCandidate = true
-		rcPart := cleanTagName[idx+4:] // Get everything after "-rc."
-		rcMatches := extractNumber.FindAllString(rcPart, 1)
-		if len(rcMatches) > 0 {
-			rcVersion, _ = strconv.Atoi(rcMatches[0])
-		}
-		// Remove the RC suffix for version parsing
-		cleanTagName = cleanTagName[:idx]
-		Debug("Detected release candidate", map[string]interface{}{
-			"rc_version":     rcVersion,
-			"clean_tag_name": cleanTagName,
-		})
-	}
-
-	tagNameParts := strings.Split(cleanTagName, ".")
-	if len(tagNameParts) < 3 {
-		Debug("Unable to parse incompatible semver (non x.y.z)", map[string]interface{}{"tag": tagName})
-		return currentSemver
-	}
-
-	semanticVersion := SemVer{}
-
-	// Extract major version
-	majorMatches := extractNumber.FindAllString(tagNameParts[0], -1)
-	if len(majorMatches) > 0 {
-		semanticVersion.Major, _ = strconv.Atoi(majorMatches[0])
-	}
-
-	// Extract minor version
-	minorMatches := extractNumber.FindAllString(tagNameParts[1], -1)
-	if len(minorMatches) > 0 {
-		semanticVersion.Minor, _ = strconv.Atoi(minorMatches[0])
-	}
-
-	// Extract patch version
-	patchMatches := extractNumber.FindAllString(tagNameParts[2], -1)
-	if len(patchMatches) > 0 {
-		semanticVersion.Patch, _ = strconv.Atoi(patchMatches[0])
-	}
-
-	// Set release candidate if detected
-	if isReleaseCandidate {
-		semanticVersion.Release = rcVersion
-		semanticVersion.EnableReleaseCandidate = true
-	}
-
-	return semanticVersion
-}
-
-// CheckMatches checks if any of the targets match the content
-func CheckMatches(content []string, targets []string, blacklist []string) bool {
-	contentStr := strings.Join(content, " ")
-
-	// First check if any target matches
-	hasMatch := false
-	for _, tgt := range targets {
-		matches := FuzzyFind(tgt, content)
-		if len(matches) > 0 {
-			hasMatch = true
-			Debug("Found match", map[string]interface{}{
-				"target":  tgt,
-				"match":   strings.Join(matches, ","),
-				"content": contentStr,
-			})
-			break
-		}
-	}
-
-	// If we have a match, check against blacklist
-	if hasMatch && len(blacklist) > 0 {
-		for _, blacklistTerm := range blacklist {
-			if strings.Contains(strings.ToLower(contentStr), strings.ToLower(blacklistTerm)) {
-				Debug("Blacklisted term detected, ignoring commit", map[string]interface{}{
-					"content":        contentStr,
-					"blacklist_term": blacklistTerm,
-				})
-				return false
-			}
-		}
-	}
-
-	return hasMatch
-}
-
-// FuzzyFind is a wrapper for the fuzzy search library to make it easier to mock in tests
-var FuzzyFind = func(needle string, haystack []string) []string {
-	// This will be replaced with the actual implementation in main.go
-	return nil
-}

cmd/utils/version_test.go

@@ -1,252 +0,0 @@
-package utils
-
-import (
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-)
-
-func TestFormatSemver(t *testing.T) {
-	tests := []struct {
-		name   string
-		semver SemVer
-		want   string
-	}{
-		{
-			name: "Basic version",
-			semver: SemVer{
-				Major: 1,
-				Minor: 2,
-				Patch: 3,
-			},
-			want: "1.2.3",
-		},
-		{
-			name: "With release candidate",
-			semver: SemVer{
-				Major:                  2,
-				Minor:                  0,
-				Patch:                  1,
-				Release:                5,
-				EnableReleaseCandidate: true,
-			},
-			want: "2.0.1-rc.5",
-		},
-		{
-			name: "With release candidate disabled",
-			semver: SemVer{
-				Major:                  3,
-				Minor:                  1,
-				Patch:                  0,
-				Release:                2,
-				EnableReleaseCandidate: false,
-			},
-			want: "3.1.0",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			got := FormatSemver(tt.semver)
-			assert.Equal(t, tt.want, got)
-		})
-	}
-}
-
-func TestParseExistingSemver(t *testing.T) {
-	// Initialize logger for tests
-	InitLogger(false)
-
-	tests := []struct {
-		name          string
-		tagName       string
-		currentSemver SemVer
-		prefixes      []string
-		want          SemVer
-	}{
-		{
-			name:          "Standard semver",
-			tagName:       "1.2.3",
-			currentSemver: SemVer{},
-			prefixes:      []string{},
-			want: SemVer{
-				Major: 1,
-				Minor: 2,
-				Patch: 3,
-			},
-		},
-		{
-			name:          "With v prefix configured",
-			tagName:       "v2.3.4",
-			currentSemver: SemVer{},
-			prefixes:      []string{"v"},
-			want: SemVer{
-				Major: 2,
-				Minor: 3,
-				Patch: 4,
-			},
-		},
-		{
-			name:          "With app- prefix configured",
-			tagName:       "app-1.2.3",
-			currentSemver: SemVer{},
-			prefixes:      []string{"app-", "infra-"},
-			want: SemVer{
-				Major: 1,
-				Minor: 2,
-				Patch: 3,
-			},
-		},
-		{
-			name:          "With prefix but not in config - should still parse numbers",
-			tagName:       "v2.3.4",
-			currentSemver: SemVer{},
-			prefixes:      []string{}, // v not in prefixes
-			want: SemVer{
-				Major: 2,
-				Minor: 3,
-				Patch: 4,
-			},
-		},
-		{
-			name:          "With release candidate",
-			tagName:       "3.4.5-rc.2",
-			currentSemver: SemVer{},
-			prefixes:      []string{},
-			want: SemVer{
-				Major:                  3,
-				Minor:                  4,
-				Patch:                  5,
-				Release:                2,
-				EnableReleaseCandidate: true,
-			},
-		},
-		{
-			name:          "With prefix and release candidate",
-			tagName:       "app-1.0.0-rc.3",
-			currentSemver: SemVer{},
-			prefixes:      []string{"app-"},
-			want: SemVer{
-				Major:                  1,
-				Minor:                  0,
-				Patch:                  0,
-				Release:                3,
-				EnableReleaseCandidate: true,
-			},
-		},
-		{
-			name:          "Prefixed tag without RC should NOT be RC",
-			tagName:       "app-0.0.16",
-			currentSemver: SemVer{},
-			prefixes:      []string{"app-"},
-			want: SemVer{
-				Major:                  0,
-				Minor:                  0,
-				Patch:                  16,
-				EnableReleaseCandidate: false,
-			},
-		},
-		{
-			name:    "Invalid format",
-			tagName: "not-a-semver",
-			currentSemver: SemVer{
-				Major: 1,
-				Minor: 1,
-				Patch: 1,
-			},
-			prefixes: []string{},
-			want: SemVer{
-				Major: 1,
-				Minor: 1,
-				Patch: 1,
-			},
-		},
-		{
-			name:    "Incomplete format",
-			tagName: "1.2",
-			currentSemver: SemVer{
-				Major: 5,
-				Minor: 5,
-				Patch: 5,
-			},
-			prefixes: []string{},
-			want: SemVer{
-				Major: 5,
-				Minor: 5,
-				Patch: 5,
-			},
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			got := ParseExistingSemver(tt.tagName, tt.currentSemver, tt.prefixes)
-			assert.Equal(t, tt.want.Major, got.Major, "Major version mismatch")
-			assert.Equal(t, tt.want.Minor, got.Minor, "Minor version mismatch")
-			assert.Equal(t, tt.want.Patch, got.Patch, "Patch version mismatch")
-			assert.Equal(t, tt.want.Release, got.Release, "Release version mismatch")
-			assert.Equal(t, tt.want.EnableReleaseCandidate, got.EnableReleaseCandidate, "EnableReleaseCandidate mismatch")
-		})
-	}
-}
-
-func TestCheckMatches(t *testing.T) {
-	// Initialize logger for tests
-	InitLogger(false)
-
-	// Mock the fuzzy find function for testing
-	originalFuzzyFind := FuzzyFind
-	defer func() { FuzzyFind = originalFuzzyFind }()
-
-	FuzzyFind = func(needle string, haystack []string) []string {
-		// Simple mock implementation for testing
-		for _, h := range haystack {
-			if h == needle {
-				return []string{h}
-			}
-		}
-		return nil
-	}
-
-	tests := []struct {
-		name      string
-		content   []string
-		targets   []string
-		blacklist []string
-		want      bool
-	}{
-		{
-			name:    "Simple match",
-			content: []string{"update", "dependencies"},
-			targets: []string{"update", "fix"},
-			want:    true,
-		},
-		{
-			name:    "No match",
-			content: []string{"chore", "dependencies"},
-			targets: []string{"update", "fix"},
-			want:    false,
-		},
-		{
-			name:      "Match but blacklisted",
-			content:   []string{"update", "dependencies", "skip-ci"},
-			targets:   []string{"update", "fix"},
-			blacklist: []string{"skip-ci"},
-			want:      false,
-		},
-		{
-			name:      "Match with empty blacklist",
-			content:   []string{"update", "dependencies"},
-			targets:   []string{"update", "fix"},
-			blacklist: []string{},
-			want:      true,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			got := CheckMatches(tt.content, tt.targets, tt.blacklist)
-			assert.Equal(t, tt.want, got)
-		})
-	}
-}

config-release.yaml

@@ -3,13 +3,6 @@ force:
   major: 1
   minor: 4
   existing: true
-  strict: false
-  commit: 960207e4677476ad31a9f389f74eaf9f33d49613
-# tag_prefixes: (optional) prefixes to strip from existing tags
-# Note: "v" prefix is always stripped automatically
-# tag_prefixes:
-#   - "app-"
-#   - "service-"
 wording:
   patch:
     - update

config.yaml

@@ -2,16 +2,6 @@ version: 1
 force:
   major: 1
   existing: true
-  strict: false
-blacklist:
-  - "Merge branch"
-  - "Merge pull request"
-  - "feature/"
-  - "feature:"
-tag_prefixes:
-  # Note: "v" prefix is stripped automatically, no need to include it here
-  - "app-"
-  - "infra-"
 wording:
   patch:
     - update
@@ -23,4 +13,4 @@ wording:
   major:
     - breaking
   release:
-    - release-candidate
+    - release-candidate

docs/CNAME

@@ -1 +0,0 @@
-semver-generator.raczylo.com

docs/index.html

@@ -1,500 +0,0 @@
-<!doctype html>
-<html lang="en" class="scroll-smooth">
-    <head>
-        <meta charset="UTF-8" />
-        <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-        <title>semver-generator - Automatic Semantic Version Generator</title>
-        <meta
-            name="description"
-            content="Automatic semantic version generator based on git commit messages. Use as CLI, GitHub Action, or Docker container."
-        />
-        <script src="https://cdn.tailwindcss.com"></script>
-        <script>
-            tailwind.config = {
-                darkMode: 'class'
-            }
-        </script>
-        <link
-            rel="stylesheet"
-            href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.5.1/css/all.min.css"
-        />
-        <link rel="preconnect" href="https://fonts.googleapis.com" />
-        <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
-        <link
-            href="https://fonts.googleapis.com/css2?family=Inter:wght@300;400;500;600;700&family=JetBrains+Mono:wght@400;500&display=swap"
-            rel="stylesheet"
-        />
-        <style>
-            body { font-family: "Inter", sans-serif; }
-            code, pre { font-family: "JetBrains Mono", monospace; }
-            .theme-transition {
-                transition: background-color 0.3s ease, color 0.3s ease, border-color 0.3s ease;
-            }
-            @keyframes fadeInUp {
-                from { opacity: 0; transform: translateY(20px); }
-                to { opacity: 1; transform: translateY(0); }
-            }
-            @keyframes float {
-                0%, 100% { transform: translateY(0px); }
-                50% { transform: translateY(-10px); }
-            }
-            .animate-fade-in-up { animation: fadeInUp 0.6s ease-out; }
-            .animate-float { animation: float 3s ease-in-out infinite; }
-            .glass {
-                background: rgba(255, 255, 255, 0.7);
-                backdrop-filter: blur(10px);
-                -webkit-backdrop-filter: blur(10px);
-                border: 1px solid rgba(255, 255, 255, 0.2);
-            }
-            .dark .glass {
-                background: rgba(17, 24, 39, 0.7);
-                border: 1px solid rgba(255, 255, 255, 0.1);
-            }
-            .gradient-text {
-                background: linear-gradient(135deg, #10b981 0%, #3b82f6 100%);
-                -webkit-background-clip: text;
-                -webkit-text-fill-color: transparent;
-                background-clip: text;
-            }
-            .dark .gradient-text {
-                background: linear-gradient(135deg, #34d399 0%, #60a5fa 100%);
-                -webkit-background-clip: text;
-                -webkit-text-fill-color: transparent;
-                background-clip: text;
-            }
-            .shadow-modern { box-shadow: 0 10px 40px -10px rgba(0, 0, 0, 0.1); }
-            .dark .shadow-modern { box-shadow: 0 10px 40px -10px rgba(0, 0, 0, 0.4); }
-            html { scroll-behavior: smooth; }
-        </style>
-        <script>
-            if (localStorage.theme === "dark" || (!("theme" in localStorage) && window.matchMedia("(prefers-color-scheme: dark)").matches)) {
-                document.documentElement.classList.add("dark");
-            } else {
-                document.documentElement.classList.remove("dark");
-            }
-        </script>
-    </head>
-    <body class="bg-white dark:bg-gray-900 text-gray-900 dark:text-gray-100 theme-transition">
-        <!-- Navigation -->
-        <nav class="fixed w-full glass shadow-modern z-50 theme-transition">
-            <div class="max-w-6xl mx-auto px-4 sm:px-6">
-                <div class="flex justify-between h-16 items-center">
-                    <a href="#" class="flex items-center hover:opacity-80 transition-opacity duration-300 gap-2">
-                        <i class="fas fa-code-branch text-2xl gradient-text"></i>
-                        <span class="text-xl font-bold gradient-text">semver-generator</span>
-                    </a>
-                    <div class="hidden md:flex space-x-6">
-                        <a href="#features" class="text-gray-600 dark:text-gray-300 hover:text-gray-900 dark:hover:text-gray-100 font-medium">Features</a>
-                        <a href="#installation" class="text-gray-600 dark:text-gray-300 hover:text-gray-900 dark:hover:text-gray-100 font-medium">Installation</a>
-                        <a href="#usage" class="text-gray-600 dark:text-gray-300 hover:text-gray-900 dark:hover:text-gray-100 font-medium">Usage</a>
-                        <a href="#configuration" class="text-gray-600 dark:text-gray-300 hover:text-gray-900 dark:hover:text-gray-100 font-medium">Configuration</a>
-                    </div>
-                    <div class="flex items-center space-x-4">
-                        <button id="theme-toggle" class="text-gray-600 dark:text-gray-300 hover:text-gray-900 dark:hover:text-gray-100 p-2 min-w-[44px] min-h-[44px] flex items-center justify-center" aria-label="Toggle theme">
-                            <i class="fas fa-moon dark:hidden text-xl"></i>
-                            <i class="fas fa-sun hidden dark:inline text-xl"></i>
-                        </button>
-                        <a href="https://github.com/lukaszraczylo/semver-generator" target="_blank" class="text-gray-600 dark:text-gray-300 hover:text-gray-900 dark:hover:text-gray-100 p-2 min-w-[44px] min-h-[44px] flex items-center justify-center" aria-label="View on GitHub">
-                            <i class="fab fa-github text-xl"></i>
-                        </a>
-                        <button id="mobile-menu-toggle" class="md:hidden text-gray-600 dark:text-gray-300 hover:text-gray-900 dark:hover:text-gray-100 p-2 min-w-[44px] min-h-[44px] flex items-center justify-center" aria-label="Toggle menu">
-                            <i class="fas fa-bars text-xl" id="menu-open-icon"></i>
-                            <i class="fas fa-times text-xl hidden" id="menu-close-icon"></i>
-                        </button>
-                    </div>
-                </div>
-            </div>
-            <div id="mobile-menu" class="hidden md:hidden border-t border-gray-200 dark:border-gray-700">
-                <div class="px-4 py-3 space-y-1 bg-white dark:bg-gray-800">
-                    <a href="#features" class="block px-3 py-3 text-gray-600 dark:text-gray-300 hover:text-gray-900 dark:hover:text-gray-100 hover:bg-gray-50 dark:hover:bg-gray-700 rounded font-medium">Features</a>
-                    <a href="#installation" class="block px-3 py-3 text-gray-600 dark:text-gray-300 hover:text-gray-900 dark:hover:text-gray-100 hover:bg-gray-50 dark:hover:bg-gray-700 rounded font-medium">Installation</a>
-                    <a href="#usage" class="block px-3 py-3 text-gray-600 dark:text-gray-300 hover:text-gray-900 dark:hover:text-gray-100 hover:bg-gray-50 dark:hover:bg-gray-700 rounded font-medium">Usage</a>
-                    <a href="#configuration" class="block px-3 py-3 text-gray-600 dark:text-gray-300 hover:text-gray-900 dark:hover:text-gray-100 hover:bg-gray-50 dark:hover:bg-gray-700 rounded font-medium">Configuration</a>
-                </div>
-            </div>
-        </nav>
-
-        <!-- Hero Section -->
-        <section class="relative pt-24 sm:pt-32 pb-12 sm:pb-20 overflow-hidden">
-            <div class="absolute inset-0 bg-gradient-to-br from-emerald-50 via-cyan-50 to-blue-50 dark:from-gray-900 dark:via-emerald-900/20 dark:to-blue-900/20 theme-transition"></div>
-            <div class="absolute top-0 -left-4 w-72 h-72 bg-emerald-300 dark:bg-emerald-500 rounded-full mix-blend-multiply dark:mix-blend-soft-light filter blur-xl opacity-20 animate-float"></div>
-            <div class="absolute top-0 -right-4 w-72 h-72 bg-cyan-300 dark:bg-cyan-500 rounded-full mix-blend-multiply dark:mix-blend-soft-light filter blur-xl opacity-20 animate-float" style="animation-delay: 1s;"></div>
-            <div class="absolute -bottom-8 left-20 w-72 h-72 bg-blue-300 dark:bg-blue-500 rounded-full mix-blend-multiply dark:mix-blend-soft-light filter blur-xl opacity-20 animate-float" style="animation-delay: 2s;"></div>
-
-            <div class="relative max-w-6xl mx-auto px-4 sm:px-6">
-                <div class="text-center">
-                    <div class="mb-8 sm:mb-10 flex justify-center animate-fade-in-up">
-                        <div class="text-8xl sm:text-9xl animate-float">
-                            <i class="fas fa-code-branch gradient-text"></i>
-                        </div>
-                    </div>
-                    <h1 class="text-3xl sm:text-4xl md:text-5xl lg:text-6xl font-bold text-gray-900 dark:text-gray-100 mb-4 sm:mb-6 leading-tight animate-fade-in-up" style="animation-delay: 0.1s;">
-                        Semantic Version<br /><span class="gradient-text">Generator</span>
-                    </h1>
-                    <p class="text-base sm:text-lg md:text-xl text-gray-600 dark:text-gray-300 mb-8 sm:mb-10 max-w-2xl mx-auto leading-relaxed px-4 animate-fade-in-up" style="animation-delay: 0.2s;">
-                        Automatic semantic versioning based on git commit messages. Use as a CLI tool, GitHub Action, or Docker container.
-                    </p>
-                    <div class="flex flex-col sm:flex-row gap-3 sm:gap-4 justify-center mb-8 sm:mb-12 px-4 animate-fade-in-up" style="animation-delay: 0.3s;">
-                        <a href="#installation" class="group relative bg-gradient-to-r from-emerald-500 to-blue-600 hover:from-emerald-600 hover:to-blue-700 text-white px-8 py-3 rounded-lg font-medium transition-all duration-300 min-h-[48px] flex items-center justify-center shadow-lg hover:shadow-xl hover:scale-105">
-                            <span class="relative z-10">Get Started</span>
-                        </a>
-                        <a href="https://github.com/lukaszraczylo/semver-generator" class="group glass hover:shadow-lg text-gray-900 dark:text-gray-100 px-8 py-3 rounded-lg font-medium transition-all duration-300 min-h-[48px] flex items-center justify-center hover:scale-105">
-                            <i class="fab fa-github mr-2"></i>View on GitHub
-                        </a>
-                    </div>
-                    <div class="flex flex-wrap justify-center gap-2 sm:gap-4 text-sm px-4">
-                        <img src="https://img.shields.io/github/v/release/lukaszraczylo/semver-generator" alt="Version" class="h-5" />
-                        <img src="https://img.shields.io/github/license/lukaszraczylo/semver-generator" alt="License" class="h-5" />
-                        <img src="https://goreportcard.com/badge/github.com/lukaszraczylo/semver-generator" alt="Go Report" class="h-5" />
-                    </div>
-                    <div class="mt-12 sm:mt-16 max-w-3xl mx-auto px-4 animate-fade-in-up" style="animation-delay: 0.4s;">
-                        <div class="relative group">
-                            <div class="absolute -inset-1 bg-gradient-to-r from-emerald-500 to-blue-600 rounded-xl blur opacity-25 group-hover:opacity-50 transition duration-500"></div>
-                            <div class="relative bg-gray-900 rounded-xl p-6 text-left">
-                                <div class="flex items-center gap-2 mb-4">
-                                    <div class="w-3 h-3 rounded-full bg-red-500"></div>
-                                    <div class="w-3 h-3 rounded-full bg-yellow-500"></div>
-                                    <div class="w-3 h-3 rounded-full bg-green-500"></div>
-                                    <span class="ml-2 text-gray-400 text-sm">terminal</span>
-                                </div>
-                                <pre class="text-gray-100 text-sm sm:text-base overflow-x-auto"><code><span class="text-gray-400">$</span> semver-generator generate -l
-<span class="text-emerald-400">SEMVER</span> 1.5.2
-
-<span class="text-gray-400">$</span> semver-generator generate -r https://github.com/user/repo
-<span class="text-emerald-400">SEMVER</span> 2.3.0</code></pre>
-                            </div>
-                        </div>
-                    </div>
-                </div>
-            </div>
-        </section>
-
-        <!-- Features Section -->
-        <section id="features" class="py-12 sm:py-16 md:py-20 bg-white dark:bg-gray-900 theme-transition">
-            <div class="max-w-6xl mx-auto px-4 sm:px-6">
-                <div class="text-center mb-8 sm:mb-12">
-                    <h2 class="text-2xl sm:text-3xl md:text-4xl font-bold text-gray-900 dark:text-gray-100 mb-3 sm:mb-4">Features</h2>
-                    <p class="text-base sm:text-lg text-gray-600 dark:text-gray-300 px-4">Automatic versioning that just works</p>
-                </div>
-                <div class="grid sm:grid-cols-2 lg:grid-cols-3 gap-4">
-                    <div class="glass p-5 rounded-xl group hover:shadow-lg transition-all duration-300">
-                        <div class="flex items-start gap-4">
-                            <div class="w-12 h-12 rounded-xl bg-gradient-to-br from-emerald-500 to-emerald-600 flex items-center justify-center flex-shrink-0 group-hover:scale-110 transition-transform duration-300">
-                                <i class="fas fa-magic text-white"></i>
-                            </div>
-                            <div>
-                                <h3 class="font-semibold text-gray-900 dark:text-gray-100 mb-1">Automatic Versioning</h3>
-                                <p class="text-sm text-gray-600 dark:text-gray-400">Calculates version based on commit message keywords</p>
-                            </div>
-                        </div>
-                    </div>
-                    <div class="glass p-5 rounded-xl group hover:shadow-lg transition-all duration-300">
-                        <div class="flex items-start gap-4">
-                            <div class="w-12 h-12 rounded-xl bg-gradient-to-br from-blue-500 to-blue-600 flex items-center justify-center flex-shrink-0 group-hover:scale-110 transition-transform duration-300">
-                                <i class="fab fa-github text-white"></i>
-                            </div>
-                            <div>
-                                <h3 class="font-semibold text-gray-900 dark:text-gray-100 mb-1">GitHub Action</h3>
-                                <p class="text-sm text-gray-600 dark:text-gray-400">Use directly in your CI/CD workflows</p>
-                            </div>
-                        </div>
-                    </div>
-                    <div class="glass p-5 rounded-xl group hover:shadow-lg transition-all duration-300">
-                        <div class="flex items-start gap-4">
-                            <div class="w-12 h-12 rounded-xl bg-gradient-to-br from-cyan-500 to-cyan-600 flex items-center justify-center flex-shrink-0 group-hover:scale-110 transition-transform duration-300">
-                                <i class="fab fa-docker text-white"></i>
-                            </div>
-                            <div>
-                                <h3 class="font-semibold text-gray-900 dark:text-gray-100 mb-1">Docker Ready</h3>
-                                <p class="text-sm text-gray-600 dark:text-gray-400">Multi-arch Docker images for any environment</p>
-                            </div>
-                        </div>
-                    </div>
-                    <div class="glass p-5 rounded-xl group hover:shadow-lg transition-all duration-300">
-                        <div class="flex items-start gap-4">
-                            <div class="w-12 h-12 rounded-xl bg-gradient-to-br from-purple-500 to-purple-600 flex items-center justify-center flex-shrink-0 group-hover:scale-110 transition-transform duration-300">
-                                <i class="fas fa-cog text-white"></i>
-                            </div>
-                            <div>
-                                <h3 class="font-semibold text-gray-900 dark:text-gray-100 mb-1">Configurable Keywords</h3>
-                                <p class="text-sm text-gray-600 dark:text-gray-400">Define your own trigger words for version bumps</p>
-                            </div>
-                        </div>
-                    </div>
-                    <div class="glass p-5 rounded-xl group hover:shadow-lg transition-all duration-300">
-                        <div class="flex items-start gap-4">
-                            <div class="w-12 h-12 rounded-xl bg-gradient-to-br from-orange-500 to-orange-600 flex items-center justify-center flex-shrink-0 group-hover:scale-110 transition-transform duration-300">
-                                <i class="fas fa-tag text-white"></i>
-                            </div>
-                            <div>
-                                <h3 class="font-semibold text-gray-900 dark:text-gray-100 mb-1">Respects Tags</h3>
-                                <p class="text-sm text-gray-600 dark:text-gray-400">Optional mode to respect existing git tags</p>
-                            </div>
-                        </div>
-                    </div>
-                    <div class="glass p-5 rounded-xl group hover:shadow-lg transition-all duration-300">
-                        <div class="flex items-start gap-4">
-                            <div class="w-12 h-12 rounded-xl bg-gradient-to-br from-pink-500 to-pink-600 flex items-center justify-center flex-shrink-0 group-hover:scale-110 transition-transform duration-300">
-                                <i class="fas fa-flask text-white"></i>
-                            </div>
-                            <div>
-                                <h3 class="font-semibold text-gray-900 dark:text-gray-100 mb-1">Release Candidates</h3>
-                                <p class="text-sm text-gray-600 dark:text-gray-400">Support for RC versions like 1.3.37-rc.1</p>
-                            </div>
-                        </div>
-                    </div>
-                </div>
-            </div>
-        </section>
-
-        <!-- Installation Section -->
-        <section id="installation" class="py-12 sm:py-16 md:py-20 bg-gray-50 dark:bg-gray-800 theme-transition">
-            <div class="max-w-6xl mx-auto px-4 sm:px-6">
-                <div class="text-center mb-8 sm:mb-12">
-                    <h2 class="text-2xl sm:text-3xl md:text-4xl font-bold text-gray-900 dark:text-gray-100 mb-3 sm:mb-4">Installation</h2>
-                    <p class="text-base sm:text-lg text-gray-600 dark:text-gray-300 px-4">Get started in seconds</p>
-                </div>
-                <div class="max-w-3xl mx-auto space-y-6">
-                    <div class="glass p-6 rounded-xl">
-                        <h3 class="font-semibold text-gray-900 dark:text-gray-100 mb-3 flex items-center">
-                            <i class="fas fa-beer mr-2 text-amber-500"></i>
-                            Homebrew (macOS)
-                        </h3>
-                        <pre class="bg-gray-900 text-gray-100 p-4 rounded-lg overflow-x-auto"><code>brew install --cask lukaszraczylo/taps/semver-generator</code></pre>
-                    </div>
-                    <div class="glass p-6 rounded-xl">
-                        <h3 class="font-semibold text-gray-900 dark:text-gray-100 mb-3 flex items-center">
-                            <i class="fas fa-download mr-2 text-emerald-500"></i>
-                            Manual Download
-                        </h3>
-                        <p class="text-gray-600 dark:text-gray-400 mb-3">Download from the <a href="https://github.com/lukaszraczylo/semver-generator/releases/latest" class="text-emerald-600 dark:text-emerald-400 hover:underline">releases page</a>.</p>
-                        <p class="text-sm text-gray-500 dark:text-gray-400">Supported: Darwin ARM64/AMD64, Linux ARM64/AMD64, Windows AMD64</p>
-                    </div>
-                    <div class="glass p-6 rounded-xl">
-                        <h3 class="font-semibold text-gray-900 dark:text-gray-100 mb-3 flex items-center">
-                            <i class="fab fa-docker mr-2 text-blue-500"></i>
-                            Docker
-                        </h3>
-                        <pre class="bg-gray-900 text-gray-100 p-4 rounded-lg overflow-x-auto"><code>docker pull ghcr.io/lukaszraczylo/semver-generator:latest</code></pre>
-                    </div>
-                </div>
-            </div>
-        </section>
-
-        <!-- Usage Section -->
-        <section id="usage" class="py-12 sm:py-16 md:py-20 bg-white dark:bg-gray-900 theme-transition">
-            <div class="max-w-6xl mx-auto px-4 sm:px-6">
-                <div class="text-center mb-8 sm:mb-12">
-                    <h2 class="text-2xl sm:text-3xl md:text-4xl font-bold text-gray-900 dark:text-gray-100 mb-3 sm:mb-4">Usage</h2>
-                    <p class="text-base sm:text-lg text-gray-600 dark:text-gray-300 px-4">Multiple ways to use semver-generator</p>
-                </div>
-                <div class="max-w-4xl mx-auto space-y-8">
-                    <div class="glass p-6 rounded-xl">
-                        <h3 class="font-semibold text-gray-900 dark:text-gray-100 mb-4 flex items-center text-xl">
-                            <i class="fas fa-terminal mr-2 text-emerald-500"></i>
-                            CLI Usage
-                        </h3>
-                        <pre class="bg-gray-900 text-gray-100 p-4 rounded-lg overflow-x-auto mb-4"><code><span class="text-gray-400"># Local repository</span>
-semver-generator generate -l
-
-<span class="text-gray-400"># Remote repository</span>
-semver-generator generate -r https://github.com/user/repo
-
-<span class="text-gray-400"># With custom config</span>
-semver-generator generate -l -c semver.yaml
-
-<span class="text-gray-400"># Strict mode (only exact matches)</span>
-semver-generator generate -l -s
-
-<span class="text-gray-400"># Respect existing tags</span>
-semver-generator generate -l -e
-
-<span class="text-gray-400"># Self-update to latest version (no auth required)</span>
-semver-generator -u</code></pre>
-                        <div class="grid sm:grid-cols-2 gap-4 text-sm">
-                            <div>
-                                <h4 class="font-medium text-gray-900 dark:text-gray-100 mb-2">Flags</h4>
-                                <ul class="space-y-1 text-gray-600 dark:text-gray-400">
-                                    <li><code class="text-emerald-600 dark:text-emerald-400">-l, --local</code> Use local repository</li>
-                                    <li><code class="text-emerald-600 dark:text-emerald-400">-r, --repository</code> Remote repository URL</li>
-                                    <li><code class="text-emerald-600 dark:text-emerald-400">-c, --config</code> Path to config file</li>
-                                    <li><code class="text-emerald-600 dark:text-emerald-400">-s, --strict</code> Strict matching</li>
-                                    <li><code class="text-emerald-600 dark:text-emerald-400">-e, --existing</code> Respect existing tags</li>
-                                    <li><code class="text-emerald-600 dark:text-emerald-400">-d, --debug</code> Enable debug mode</li>
-                                    <li><code class="text-emerald-600 dark:text-emerald-400">-u, --update</code> Self-update to latest version</li>
-                                    <li><code class="text-emerald-600 dark:text-emerald-400">-v, --version</code> Display current version</li>
-                                </ul>
-                            </div>
-                        </div>
-                    </div>
-
-                    <div class="glass p-6 rounded-xl">
-                        <h3 class="font-semibold text-gray-900 dark:text-gray-100 mb-4 flex items-center text-xl">
-                            <i class="fab fa-github mr-2 text-blue-500"></i>
-                            GitHub Action
-                        </h3>
-                        <pre class="bg-gray-900 text-gray-100 p-4 rounded-lg overflow-x-auto text-sm"><code>jobs:
-  version:
-    runs-on: ubuntu-latest
-    outputs:
-      version: ${{ steps.semver.outputs.semantic_version }}
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          fetch-depth: '0'
-
-      - name: Generate version
-        id: semver
-        uses: lukaszraczylo/semver-generator@v1
-        with:
-          config_file: semver.yaml
-          repository_local: true
-
-      - name: Use version
-        run: echo "Version: ${{ steps.semver.outputs.semantic_version }}"</code></pre>
-                    </div>
-                </div>
-            </div>
-        </section>
-
-        <!-- How It Works Section -->
-        <section class="py-12 sm:py-16 md:py-20 bg-gray-50 dark:bg-gray-800 theme-transition">
-            <div class="max-w-6xl mx-auto px-4 sm:px-6">
-                <div class="text-center mb-8 sm:mb-12">
-                    <h2 class="text-2xl sm:text-3xl md:text-4xl font-bold text-gray-900 dark:text-gray-100 mb-3 sm:mb-4">How It Works</h2>
-                    <p class="text-base sm:text-lg text-gray-600 dark:text-gray-300 px-4">Version calculation based on commit messages</p>
-                </div>
-                <div class="max-w-3xl mx-auto">
-                    <div class="glass p-6 rounded-xl">
-                        <pre class="text-gray-700 dark:text-gray-300 text-sm overflow-x-auto"><code>0.0.1 - PATCH - starting commit
-0.0.2 - PATCH - another commit
-0.0.4 - PATCH - commit with 'Update' => DOUBLE increment PATCH
-0.1.0 - MINOR - commit with 'Change' => increment MINOR, reset PATCH
-0.1.1 - PATCH - additional commit
-1.0.1 - MAJOR - commit with 'BREAKING' => INCREMENT MAJOR, reset MINOR
-1.0.2 - PATCH - another commit</code></pre>
-                    </div>
-                    <div class="mt-6 grid sm:grid-cols-3 gap-4 text-center">
-                        <div class="glass p-4 rounded-xl">
-                            <div class="text-3xl font-bold text-red-500 mb-2">MAJOR</div>
-                            <p class="text-sm text-gray-600 dark:text-gray-400">Breaking changes</p>
-                            <p class="text-xs text-gray-500 dark:text-gray-500 mt-1">Keywords: "breaking"</p>
-                        </div>
-                        <div class="glass p-4 rounded-xl">
-                            <div class="text-3xl font-bold text-yellow-500 mb-2">MINOR</div>
-                            <p class="text-sm text-gray-600 dark:text-gray-400">New features</p>
-                            <p class="text-xs text-gray-500 dark:text-gray-500 mt-1">Keywords: "change", "improve"</p>
-                        </div>
-                        <div class="glass p-4 rounded-xl">
-                            <div class="text-3xl font-bold text-emerald-500 mb-2">PATCH</div>
-                            <p class="text-sm text-gray-600 dark:text-gray-400">Bug fixes</p>
-                            <p class="text-xs text-gray-500 dark:text-gray-500 mt-1">Keywords: "update", "initial"</p>
-                        </div>
-                    </div>
-                </div>
-            </div>
-        </section>
-
-        <!-- Configuration Section -->
-        <section id="configuration" class="py-12 sm:py-16 md:py-20 bg-white dark:bg-gray-900 theme-transition">
-            <div class="max-w-6xl mx-auto px-4 sm:px-6">
-                <div class="text-center mb-8 sm:mb-12">
-                    <h2 class="text-2xl sm:text-3xl md:text-4xl font-bold text-gray-900 dark:text-gray-100 mb-3 sm:mb-4">Configuration</h2>
-                    <p class="text-base sm:text-lg text-gray-600 dark:text-gray-300 px-4">Customize keywords and behavior</p>
-                </div>
-                <div class="max-w-3xl mx-auto">
-                    <div class="glass p-6 rounded-xl">
-                        <h3 class="font-semibold text-gray-900 dark:text-gray-100 mb-4">semver.yaml</h3>
-                        <pre class="bg-gray-900 text-gray-100 p-4 rounded-lg overflow-x-auto text-sm"><code><span class="text-gray-400">version:</span> 1
-
-<span class="text-gray-400"># Starting version (optional)</span>
-<span class="text-emerald-400">force:</span>
-  <span class="text-blue-400">major:</span> 1
-  <span class="text-blue-400">minor:</span> 0
-  <span class="text-blue-400">patch:</span> 0
-  <span class="text-blue-400">commit:</span> 69fbe2df696f40281b9104ff073d26186cde1024
-
-<span class="text-gray-400"># Commits to ignore</span>
-<span class="text-emerald-400">blacklist:</span>
-  - "Merge branch"
-  - "Merge pull request"
-  - "feature/"
-
-<span class="text-gray-400"># Keywords for version bumps</span>
-<span class="text-emerald-400">wording:</span>
-  <span class="text-blue-400">patch:</span>
-    - update
-    - initial
-    - fix
-  <span class="text-blue-400">minor:</span>
-    - change
-    - improve
-    - add
-  <span class="text-blue-400">major:</span>
-    - breaking
-  <span class="text-blue-400">release:</span>
-    - release-candidate
-    - add-rc</code></pre>
-                    </div>
-                </div>
-            </div>
-        </section>
-
-        <!-- Footer -->
-        <footer class="py-8 bg-gray-100 dark:bg-gray-800 theme-transition">
-            <div class="max-w-6xl mx-auto px-4 sm:px-6">
-                <div class="flex flex-col sm:flex-row justify-between items-center gap-4">
-                    <div class="flex items-center gap-2">
-                        <i class="fas fa-code-branch text-xl gradient-text"></i>
-                        <span class="font-semibold gradient-text">semver-generator</span>
-                    </div>
-                    <div class="flex items-center gap-6">
-                        <a href="https://github.com/lukaszraczylo/semver-generator" class="text-gray-600 dark:text-gray-400 hover:text-gray-900 dark:hover:text-gray-100">
-                            <i class="fab fa-github text-xl"></i>
-                        </a>
-                        <a href="https://github.com/lukaszraczylo/semver-generator/issues" class="text-gray-600 dark:text-gray-400 hover:text-gray-900 dark:hover:text-gray-100 text-sm">
-                            Issues
-                        </a>
-                        <a href="https://github.com/lukaszraczylo/semver-generator/releases" class="text-gray-600 dark:text-gray-400 hover:text-gray-900 dark:hover:text-gray-100 text-sm">
-                            Releases
-                        </a>
-                    </div>
-                    <p class="text-gray-500 dark:text-gray-400 text-sm">MIT License</p>
-                </div>
-            </div>
-        </footer>
-
-        <script>
-            // Theme toggle
-            document.getElementById('theme-toggle').addEventListener('click', function() {
-                if (document.documentElement.classList.contains('dark')) {
-                    document.documentElement.classList.remove('dark');
-                    localStorage.theme = 'light';
-                } else {
-                    document.documentElement.classList.add('dark');
-                    localStorage.theme = 'dark';
-                }
-            });
-
-            // Mobile menu toggle
-            document.getElementById('mobile-menu-toggle').addEventListener('click', function() {
-                const menu = document.getElementById('mobile-menu');
-                const openIcon = document.getElementById('menu-open-icon');
-                const closeIcon = document.getElementById('menu-close-icon');
-
-                menu.classList.toggle('hidden');
-                openIcon.classList.toggle('hidden');
-                closeIcon.classList.toggle('hidden');
-            });
-
-            // Close mobile menu when clicking a link
-            document.querySelectorAll('#mobile-menu a').forEach(link => {
-                link.addEventListener('click', () => {
-                    document.getElementById('mobile-menu').classList.add('hidden');
-                    document.getElementById('menu-open-icon').classList.remove('hidden');
-                    document.getElementById('menu-close-icon').classList.add('hidden');
-                });
-            });
-        </script>
-    </body>
-</html>

entrypoint.sh

@@ -1,11 +1,10 @@
-#!/bin/bash
-set -e
+#!/bin/sh -l
+set -o pipefail
 
-FLAGS="$SEMVER_RAW_FLAGS"
+FLAGS=""
 
 if [[ -z "$INPUT_CONFIG_FILE" ]]; then
   echo "Set the configuration file path."
-  exit 1
 else
   FLAGS="${FLAGS} -c $INPUT_CONFIG_FILE"
 fi
@@ -19,26 +18,10 @@ if [[ ! -z "$INPUT_REPOSITORY_URL" ]]; then
   FLAGS="${FLAGS} -r $INPUT_REPOSITORY_URL"
 fi
 
-if [[ ! -z "$INPUT_REPOSITORY_BRANCH" ]]; then
-  FLAGS="${FLAGS} -b $INPUT_REPOSITORY_BRANCH"
-fi
-
 if [[ ! -z "$INPUT_REPOSITORY_LOCAL" ]]; then
   FLAGS="${FLAGS} -l"
 fi
 
-if [[ ! -z "$INPUT_STRICT" ]]; then
-  FLAGS="${FLAGS} -s"
-fi
-
-if [[ ! -z "$INPUT_EXISTING" ]]; then
-  FLAGS="${FLAGS} -e"
-fi
-
-if [[ ! -z "$INPUT_DEBUGMODE" ]]; then
-  FLAGS="${FLAGS} --debug"
-fi
-
 if [[ "${FLAGS}" == "" && "$*" == "" ]]; then
   exit 1
 fi
@@ -51,21 +34,8 @@ if [[ ! -z "$INPUT_GITHUB_USERNAME" ]]; then
   export GITHUB_USERNAME=$INPUT_GITHUB_USERNAME
 fi
 
-if [[ ! -z "$INPUT_DEBUGMODE" ]]; then
-  echo "DEBUG MODE ENABLED"
-  echo "----"
-  ls -lA
-  echo "----"
-  pwd
-  echo "----"
-  echo "FLAGS: $FLAGS"
-  echo "----"
-  /go/src/app/semver-generator generate $FLAGS $*
-  echo "----"
-fi
-
-OUT_SEMVER_GEN=$(/go/src/app/semver-generator generate $FLAGS $*)
+cd /github/workspace
+OUT_SEMVER_GEN=$(/go/src/app/semver-gen generate $FLAGS $*)
 [ $? -eq 0 ] || exit 1
-CLEAN_SEMVER=$(echo $OUT_SEMVER_GEN | sed -e 's|SEMVER ||g')
-echo "semantic_version=$CLEAN_SEMVER" >> $GITHUB_OUTPUT
-echo $OUT_SEMVER_GEN
+echo "::set-output name=semantic_version::$(echo $OUT_SEMVER_GEN | sed -e 's|SEMVER ||g')"
+echo $OUT_SEMVER_GEN

go.mod

@@ -1,62 +1,58 @@
 module github.com/lukaszraczylo/semver-generator
 
-go 1.24.0
-
-toolchain go1.24.6
+go 1.17
 
 require (
-	github.com/go-git/go-git/v5 v5.16.4
-	github.com/lithammer/fuzzysearch v1.1.8
-	github.com/lukaszraczylo/graphql-monitoring-proxy v0.42.4
-	github.com/lukaszraczylo/pandati v0.0.29
-	github.com/spf13/cobra v1.10.2
-	github.com/spf13/viper v1.21.0
-	github.com/stretchr/testify v1.11.1
+	github.com/go-git/go-git/v5 v5.4.2
+	github.com/lithammer/fuzzysearch v1.1.3
+	github.com/lukaszraczylo/go-simple-graphql v1.0.50
+	github.com/lukaszraczylo/pandati v0.0.10
+	github.com/melbahja/got v0.6.1
+	github.com/spf13/cobra v1.3.0
+	github.com/spf13/viper v1.10.1
+	github.com/stretchr/testify v1.7.0
+	github.com/tidwall/gjson v1.14.0
 )
 
 require (
-	dario.cat/mergo v1.0.2 // indirect
-	github.com/Microsoft/go-winio v0.6.2 // indirect
-	github.com/ProtonMail/go-crypto v1.3.0 // indirect
-	github.com/cloudflare/circl v1.6.1 // indirect
-	github.com/cyphar/filepath-securejoin v0.6.1 // indirect
-	github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc // indirect
-	github.com/emirpasic/gods v1.18.1 // indirect
-	github.com/fsnotify/fsnotify v1.9.0 // indirect
-	github.com/go-git/gcfg v1.5.1-0.20230307220236-3a3c6141e376 // indirect
-	github.com/go-git/go-billy/v5 v5.7.0 // indirect
-	github.com/go-viper/mapstructure/v2 v2.4.0 // indirect
-	github.com/goccy/go-json v0.10.5 // indirect
-	github.com/golang/groupcache v0.0.0-20241129210726-2c02b8208cf8 // indirect
-	github.com/inconshreveable/mousetrap v1.1.0 // indirect
+	github.com/Microsoft/go-winio v0.5.1 // indirect
+	github.com/ProtonMail/go-crypto v0.0.0-20220113124808-70ae35bab23f // indirect
+	github.com/acomagu/bufpipe v1.0.3 // indirect
+	github.com/allegro/bigcache/v3 v3.0.1 // indirect
+	github.com/davecgh/go-spew v1.1.1 // indirect
+	github.com/emirpasic/gods v1.12.0 // indirect
+	github.com/fsnotify/fsnotify v1.5.1 // indirect
+	github.com/go-git/gcfg v1.5.0 // indirect
+	github.com/go-git/go-billy/v5 v5.3.1 // indirect
+	github.com/hashicorp/hcl v1.0.0 // indirect
+	github.com/imdario/mergo v0.3.12 // indirect
+	github.com/inconshreveable/mousetrap v1.0.0 // indirect
 	github.com/jbenet/go-context v0.0.0-20150711004518-d14ea06fba99 // indirect
-	github.com/kevinburke/ssh_config v1.4.0 // indirect
-	github.com/klauspost/cpuid/v2 v2.3.0 // indirect
-	github.com/mattn/go-colorable v0.1.14 // indirect
-	github.com/mattn/go-isatty v0.0.20 // indirect
-	github.com/pelletier/go-toml/v2 v2.2.4 // indirect
-	github.com/pjbgf/sha1cd v0.5.0 // indirect
-	github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 // indirect
-	github.com/rs/zerolog v1.33.0 // indirect
-	github.com/sagikazarmark/locafero v0.12.0 // indirect
-	github.com/sergi/go-diff v1.4.0 // indirect
-	github.com/skeema/knownhosts v1.3.2 // indirect
-	github.com/spf13/afero v1.15.0 // indirect
-	github.com/spf13/cast v1.10.0 // indirect
-	github.com/spf13/pflag v1.0.10 // indirect
-	github.com/subosito/gotenv v1.6.0 // indirect
-	github.com/tidwall/gjson v1.18.0 // indirect
+	github.com/json-iterator/go v1.1.12 // indirect
+	github.com/kevinburke/ssh_config v1.1.0 // indirect
+	github.com/magiconair/properties v1.8.5 // indirect
+	github.com/mitchellh/go-homedir v1.1.0 // indirect
+	github.com/mitchellh/mapstructure v1.4.3 // indirect
+	github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect
+	github.com/modern-go/reflect2 v1.0.2 // indirect
+	github.com/pelletier/go-toml v1.9.4 // indirect
+	github.com/pmezard/go-difflib v1.0.0 // indirect
+	github.com/rs/zerolog v1.26.1 // indirect
+	github.com/sergi/go-diff v1.2.0 // indirect
+	github.com/spf13/afero v1.8.1 // indirect
+	github.com/spf13/cast v1.4.1 // indirect
+	github.com/spf13/jwalterweatherman v1.1.0 // indirect
+	github.com/spf13/pflag v1.0.5 // indirect
+	github.com/subosito/gotenv v1.2.0 // indirect
 	github.com/tidwall/match v1.1.1 // indirect
-	github.com/tidwall/pretty v1.2.1 // indirect
-	github.com/tidwall/sjson v1.2.5 // indirect
-	github.com/wI2L/jsondiff v0.6.1 // indirect
-	github.com/xanzy/ssh-agent v0.3.3 // indirect
-	go.yaml.in/yaml/v3 v3.0.4 // indirect
-	golang.org/x/crypto v0.45.0 // indirect
-	golang.org/x/exp v0.0.0-20250305212735-054e65f0b394 // indirect
-	golang.org/x/net v0.47.0 // indirect
-	golang.org/x/sys v0.38.0 // indirect
-	golang.org/x/text v0.31.0 // indirect
+	github.com/tidwall/pretty v1.2.0 // indirect
+	github.com/xanzy/ssh-agent v0.3.1 // indirect
+	golang.org/x/crypto v0.0.0-20220209195652-db638375bc3a // indirect
+	golang.org/x/net v0.0.0-20220127200216-cd36cc0744dd // indirect
+	golang.org/x/sys v0.0.0-20220209214540-3681064d5158 // indirect
+	golang.org/x/text v0.3.7 // indirect
+	gopkg.in/ini.v1 v1.66.4 // indirect
 	gopkg.in/warnings.v0 v0.1.2 // indirect
-	gopkg.in/yaml.v3 v3.0.1 // indirect
+	gopkg.in/yaml.v2 v2.4.0 // indirect
+	gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b // indirect
 )

main.go

@@ -5,7 +5,7 @@ Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
 You may obtain a copy of the License at
 
-	http://www.apache.org/licenses/LICENSE-2.0
+    http://www.apache.org/licenses/LICENSE-2.0
 
 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,

main_test.go

@@ -1,33 +0,0 @@
-package main
-
-import (
-	"os"
-	"testing"
-
-	"github.com/lukaszraczylo/semver-generator/cmd"
-	"github.com/stretchr/testify/assert"
-)
-
-func TestMain(t *testing.T) {
-	// Save original os.Args and restore after test
-	originalArgs := os.Args
-	defer func() { os.Args = originalArgs }()
-
-	// Set up test args to avoid actual execution
-	os.Args = []string{"semver-gen", "--version"}
-
-	// Save original cmd.PKG_VERSION and restore after test
-	originalPkgVersion := cmd.PKG_VERSION
-	defer func() { cmd.PKG_VERSION = originalPkgVersion }()
-
-	// Set a test version
-	PKG_VERSION = "test-version"
-
-	// Test should not panic
-	assert.NotPanics(t, func() {
-		main()
-	}, "main() should not panic")
-
-	// Verify that the version was set correctly
-	assert.Equal(t, "test-version", cmd.PKG_VERSION, "PKG_VERSION should be set correctly")
-}