gitnextver 1.0.0__tar.gz

gitnextver-1.0.0/.gitignore

@@ -0,0 +1,128 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+__marimo__/
+__pycache__/
+__pypackages__/
+__version__.py
+_version.py
+.abstra/
+.cache
+.coverage
+.coverage.*
+.cursorignore
+.cursorindexingignore
+.dmypy.json
+.DS_Store
+.eggs/
+.env
+.envrc
+.hypothesis/
+.installed.cfg
+.ipynb_checkpoints
+.mypy_cache/
+.nox/
+.pdm-build/
+.pdm-python
+.pixi
+.pybuilder/
+.pypirc
+.pyre/
+.pytest_cache/
+.Python
+.pytype/
+.ropeproject
+.ruff_cache/
+.scrapy
+.spyderproject
+.spyproject
+.tox/
+.venv
+.webassets-cache
+*.cover
+*.egg
+*.egg-info/
+*.log
+*.manifest
+*.mo
+*.pot
+*.py.cover
+*.py[codz]
+*.sage.py
+*.so
+*.spec
+*$py.class
+/site
+build/
+celerybeat-schedule
+celerybeat.pid
+cover/
+coverage.xml
+cython_debug/
+db.sqlite3
+db.sqlite3-journal
+develop-eggs/
+dist/
+dmypy.json
+docs/_build/
+downloads/
+eggs/
+env.bak/
+env/
+ENV/
+htmlcov/
+instance/
+ipython_config.py
+lib/
+lib64/
+local_settings.py
+MANIFEST
+marimo/_lsp/
+marimo/_static/
+nosetests.xml
+parts/
+pip-delete-this-directory.txt
+pip-log.txt
+profile_default/
+sdist/
+share/python-wheels/
+target/
+var/
+venv.bak/
+venv/
+wheels/

gitnextver-1.0.0/.omc/project-memory.json

@@ -0,0 +1,37 @@
+{
+  "version": "1.0.0",
+  "lastScanned": 1775659826985,
+  "projectRoot": "/Users/adam/Developer/vcs3/github.twardoch/pub/gitnextver",
+  "techStack": {
+    "languages": [],
+    "frameworks": [],
+    "packageManager": null,
+    "runtime": null
+  },
+  "build": {
+    "buildCommand": null,
+    "testCommand": null,
+    "lintCommand": null,
+    "devCommand": null,
+    "scripts": {}
+  },
+  "conventions": {
+    "namingStyle": null,
+    "importStyle": null,
+    "testPattern": null,
+    "fileOrganization": null
+  },
+  "structure": {
+    "isMonorepo": false,
+    "workspaces": [],
+    "mainDirectories": [],
+    "gitBranches": {
+      "defaultBranch": "main",
+      "branchingStrategy": null
+    }
+  },
+  "customNotes": [],
+  "directoryMap": {},
+  "hotPaths": [],
+  "userDirectives": []
+}

gitnextver-1.0.0/.omc/state/subagent-tracking.json

@@ -0,0 +1,53 @@
+{
+  "agents": [
+    {
+      "agent_id": "a7dd8008147802d16",
+      "agent_type": "Explore",
+      "started_at": "2026-04-08T14:50:39.028Z",
+      "parent_mode": "none",
+      "status": "completed",
+      "completed_at": "2026-04-08T14:51:40.022Z",
+      "duration_ms": 60994
+    },
+    {
+      "agent_id": "a6fd8fecc70890750",
+      "agent_type": "oh-my-claudecode:executor",
+      "started_at": "2026-04-08T14:58:01.667Z",
+      "parent_mode": "ultrawork",
+      "status": "completed",
+      "completed_at": "2026-04-08T14:58:20.791Z",
+      "duration_ms": 19124
+    },
+    {
+      "agent_id": "a25f98b47d41e49c5",
+      "agent_type": "oh-my-claudecode:executor",
+      "started_at": "2026-04-08T14:58:11.582Z",
+      "parent_mode": "ultrawork",
+      "status": "completed",
+      "completed_at": "2026-04-08T14:59:20.059Z",
+      "duration_ms": 68477
+    },
+    {
+      "agent_id": "a6b5450488b8eae7f",
+      "agent_type": "oh-my-claudecode:executor-low",
+      "started_at": "2026-04-08T14:58:13.504Z",
+      "parent_mode": "ultrawork",
+      "status": "completed",
+      "completed_at": "2026-04-08T14:58:22.403Z",
+      "duration_ms": 8899
+    },
+    {
+      "agent_id": "aadd6b355aaf008e3",
+      "agent_type": "oh-my-claudecode:executor-low",
+      "started_at": "2026-04-08T14:59:50.697Z",
+      "parent_mode": "ultrawork",
+      "status": "completed",
+      "completed_at": "2026-04-08T14:59:57.930Z",
+      "duration_ms": 7233
+    }
+  ],
+  "total_spawned": 5,
+  "total_completed": 5,
+  "total_failed": 0,
+  "last_updated": "2026-04-08T14:59:58.034Z"
+}

gitnextver-1.0.0/CLAUDE.md

@@ -0,0 +1,70 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Project Overview
+
+**gitnextver** is a Git versioning automation CLI tool published to PyPI. It automatically bumps semantic version tags (`vX.Y.Z`) in Git repositories, commits all changes with the version as the commit message, creates the tag, and pushes to the remote.
+
+### Workflow
+
+1. Validate git repo
+2. Ensure GitPython index compatibility (downgrade v3→v2 if needed)
+3. Stash uncommitted changes (including untracked)
+4. Pull from remote with conflict detection
+5. Re-apply stash
+6. Find latest `vX.Y.Z` tag, increment patch → next version
+7. Stage all, commit, tag, push
+
+## Tech Stack
+
+- **Language:** Python 3.10+
+- **Build system:** hatchling + hatch-vcs (git-tag-based semver)
+- **Package manager:** uv
+- **Dependencies:** GitPython, fire (CLI), rich (terminal UI), loguru (logging)
+
+## Package Layout
+
+```
+src/gitnextver/
+├── __init__.py       # version import with fallback chain
+├── __main__.py       # `python -m gitnextver` entry point
+├── __version__.py    # generated by hatch-vcs (in .gitignore)
+└── cli.py            # all CLI logic, app() is the console_scripts entry point
+```
+
+- `pyproject.toml` — `[project.scripts] gitnextver = "gitnextver.cli:app"`
+- `gitnextver-old.md` — previous single-file implementation (reference only)
+
+## Build & Run Commands
+
+```bash
+# Run directly via uvx (PyPI)
+uvx gitnextver [--directory PATH] [--verbose]
+
+# Development
+uv sync                              # install deps + editable
+uvx hatch build                      # build sdist + wheel
+uvx hatch test                       # run tests
+uvx ruff check --fix .               # lint
+uvx ruff format .                    # format
+```
+
+## Versioning
+
+Versions are derived from git tags via hatch-vcs. `__version__.py` is auto-generated at build time and must not be committed (it's in `.gitignore`). To release a new version, create a git tag like `v1.2.3` and build.
+
+## Architecture Notes
+
+- CLI via `fire.Fire(main)` — the `app()` function in `cli.py` is the entry point
+- Version tags parsed with regex `^v(\d+)\.(\d+)\.(\d+)$`, only patch is auto-incremented
+- Remote selection: prefers `origin`, falls back to any available remote, skips gracefully if none
+- GitPython compatibility: handles index version mismatch (v3→v2 downgrade) and index.lock cleanup
+- Stash/restore pattern wraps pull to avoid losing local work on conflict
+
+## Key Design Decisions
+
+- Defaults to `v1.0.0` when no version tags exist
+- Commits use the version string as the entire commit message (e.g., `v1.0.1`)
+- All files are staged (`git add -A`) — intentional for the "snapshot and tag" workflow
+- Conflicts abort with user-friendly Rich panels rather than attempting auto-resolution

gitnextver-1.0.0/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   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.

gitnextver-1.0.0/PKG-INFO

@@ -0,0 +1,72 @@
+Metadata-Version: 2.4
+Name: gitnextver
+Version: 1.0.0
+Summary: Automatically bump semantic version tags in Git repositories
+Project-URL: Homepage, https://github.com/twardoch/gitnextver
+Project-URL: Repository, https://github.com/twardoch/gitnextver
+Project-URL: Issues, https://github.com/twardoch/gitnextver/issues
+Author-email: Adam Twardoch <adam+github@twardoch.com>
+License-Expression: Apache-2.0
+License-File: LICENSE
+Keywords: bump,git,semver,tag,version
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Version Control :: Git
+Requires-Python: >=3.10
+Requires-Dist: fire
+Requires-Dist: gitpython
+Requires-Dist: loguru
+Requires-Dist: rich
+Description-Content-Type: text/markdown
+
+# gitnextver
+
+Automatically bump semantic version tags in Git repositories.
+
+## Installation
+
+```
+pip install gitnextver
+```
+
+Or run directly:
+
+```
+uvx gitnextver
+```
+
+## Usage
+
+```bash
+# Bump patch version in current directory
+gitnextver
+
+# Specify directory
+gitnextver --directory /path/to/repo
+
+# Verbose output
+gitnextver --verbose
+```
+
+## What it does
+
+1. Validates you're in a git repository
+2. Stashes uncommitted changes
+3. Pulls from remote with conflict detection
+4. Re-applies stashed changes
+5. Finds the latest `vX.Y.Z` tag and increments the patch version
+6. Commits all changes, creates the tag, and pushes
+
+Defaults to `v1.0.0` if no version tags exist.
+
+## License
+
+Apache-2.0

gitnextver-1.0.0/README.md

@@ -0,0 +1,43 @@
+# gitnextver
+
+Automatically bump semantic version tags in Git repositories.
+
+## Installation
+
+```
+pip install gitnextver
+```
+
+Or run directly:
+
+```
+uvx gitnextver
+```
+
+## Usage
+
+```bash
+# Bump patch version in current directory
+gitnextver
+
+# Specify directory
+gitnextver --directory /path/to/repo
+
+# Verbose output
+gitnextver --verbose
+```
+
+## What it does
+
+1. Validates you're in a git repository
+2. Stashes uncommitted changes
+3. Pulls from remote with conflict detection
+4. Re-applies stashed changes
+5. Finds the latest `vX.Y.Z` tag and increments the patch version
+6. Commits all changes, creates the tag, and pushes
+
+Defaults to `v1.0.0` if no version tags exist.
+
+## License
+
+Apache-2.0

gitnextver-1.0.0/pyproject.toml

@@ -0,0 +1,66 @@
+[build-system]
+requires = ["hatchling", "hatch-vcs"]
+build-backend = "hatchling.build"
+
+[project]
+name = "gitnextver"
+dynamic = ["version"]
+description = "Automatically bump semantic version tags in Git repositories"
+readme = "README.md"
+license = "Apache-2.0"
+requires-python = ">=3.10"
+authors = [
+    { name = "Adam Twardoch", email = "adam+github@twardoch.com" },
+]
+keywords = ["git", "version", "semver", "tag", "bump"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Environment :: Console",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: Apache Software License",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Software Development :: Version Control :: Git",
+]
+dependencies = [
+    "fire",
+    "GitPython",
+    "loguru",
+    "rich",
+]
+
+[project.scripts]
+gitnextver = "gitnextver.cli:app"
+
+[project.urls]
+Homepage = "https://github.com/twardoch/gitnextver"
+Repository = "https://github.com/twardoch/gitnextver"
+Issues = "https://github.com/twardoch/gitnextver/issues"
+
+[tool.hatch.version]
+source = "vcs"
+
+[tool.hatch.build.hooks.vcs]
+version-file = "src/gitnextver/__version__.py"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/gitnextver"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+
+[tool.ruff]
+target-version = "py310"
+src = ["src"]
+
+[tool.ruff.lint]
+select = ["E", "F", "W", "I"]
+
+[tool.mypy]
+python_version = "3.10"
+warn_return_any = true
+warn_unused_configs = true

gitnextver-1.0.0/src/gitnextver/__init__.py

@@ -0,0 +1,12 @@
+# this_file: src/gitnextver/__init__.py
+"""gitnextver - Automatically bump semantic version tags in Git repositories."""
+
+try:
+    from gitnextver.__version__ import __version__
+except ImportError:
+    from importlib.metadata import version, PackageNotFoundError
+
+    try:
+        __version__ = version("gitnextver")
+    except PackageNotFoundError:
+        __version__ = "0.0.0"

gitnextver-1.0.0/src/gitnextver/__main__.py

@@ -0,0 +1,7 @@
+# this_file: src/gitnextver/__main__.py
+"""Entry point for `python -m gitnextver`."""
+
+from gitnextver.cli import app
+
+if __name__ == "__main__":
+    app()

gitnextver-1.0.0/src/gitnextver/__version__.py

@@ -0,0 +1,24 @@
+# file generated by vcs-versioning
+# don't change, don't track in version control
+from __future__ import annotations
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+version: str
+__version__: str
+__version_tuple__: tuple[int | str, ...]
+version_tuple: tuple[int | str, ...]
+commit_id: str | None
+__commit_id__: str | None
+
+__version__ = version = '1.0.0'
+__version_tuple__ = version_tuple = (1, 0, 0)
+
+__commit_id__ = commit_id = None

gitnextver-1.0.0/src/gitnextver/cli.py

@@ -0,0 +1,448 @@
+# this_file: src/gitnextver/cli.py
+
+"""
+Git Next Version Tool - Automatically bump version tags and commit changes.
+
+This tool:
+1. Checks if we're in a git repo
+2. Pulls from remote repo
+3. Handles conflicts gracefully
+4. Determines next version tag based on existing tags
+5. Commits all changes with version tag
+6. Creates and pushes the new tag
+"""
+
+import re
+import sys
+from pathlib import Path
+from typing import Optional
+
+import fire  # type: ignore
+import git
+from git.exc import GitCommandError, InvalidGitRepositoryError
+from loguru import logger
+from rich.console import Console
+from rich.panel import Panel
+from rich.text import Text
+
+console = Console()
+
+# Pre-compiled regex to match semantic version tags like v1.2.3
+VERSION_PATTERN = re.compile(r"^v(\d+)\.(\d+)\.(\d+)$")
+
+# Friendly default remote name
+DEFAULT_REMOTE_NAME = "origin"
+
+
+def setup_logging(verbose: bool = False) -> None:
+    """Setup logging configuration."""
+    logger.remove()
+    level = "DEBUG" if verbose else "INFO"
+    logger.add(
+        sys.stderr,
+        format=(
+            "<green>{time:YYYY-MM-DD HH:mm:ss}</green> | "
+            "<level>{level: <8}</level> | <level>{message}</level>"
+        ),
+        level=level,
+    )
+
+
+def is_git_repo(path: Path) -> bool:
+    """Check if the given path is a git repository."""
+    try:
+        git.Repo(path)
+        return True
+    except InvalidGitRepositoryError:
+        return False
+
+
+def get_last_version_tag(repo: git.Repo) -> Optional[str]:
+    """Get the last version tag in vA.B.C format."""
+    tags = repo.tags
+    version_tags = []
+
+    for tag in tags:
+        match = VERSION_PATTERN.match(tag.name)
+        if match:
+            major, minor, patch = map(int, match.groups())
+            version_tags.append((major, minor, patch, tag.name))
+
+    if not version_tags:
+        return None
+
+    # Pick the tag with the highest numerical value
+    latest = max(version_tags, key=lambda x: (x[0], x[1], x[2]))
+    return latest[3]
+
+
+def calculate_next_version(last_tag: Optional[str]) -> str:
+    """Calculate the next version tag."""
+    if not last_tag:
+        return "v1.0.0"
+
+    match = VERSION_PATTERN.match(last_tag)
+
+    if not match:
+        return "v1.0.0"
+
+    major, minor, patch = map(int, match.groups())
+    return f"v{major}.{minor}.{patch + 1}"
+
+
+def _select_remote(repo: git.Repo):
+    """Return a remote to interact with, or *None* if no remotes exist."""
+    remotes = {r.name: r for r in repo.remotes}
+    if DEFAULT_REMOTE_NAME in remotes:
+        return remotes[DEFAULT_REMOTE_NAME]
+    # Fallback to any remote if 'origin' is missing
+    return next(iter(remotes.values())) if remotes else None
+
+
+def stash_uncommitted_changes(repo: git.Repo) -> bool:
+    """Stash any uncommitted (including untracked) changes before a pull.
+
+    Returns True if a stash was created, False otherwise.
+    """
+    if repo.is_dirty(untracked_files=True) or repo.untracked_files:
+        logger.info("Stashing uncommitted changes before pull …")
+        try:
+            # Include untracked files to ensure a clean working tree
+            repo.git.stash(
+                "push",
+                "--include-untracked",
+                "-m",
+                "gitnextver-auto-stash",
+            )
+            return True
+        except GitCommandError as e:
+            if "could not write index" in str(e):
+                # Try to fix index corruption
+                logger.warning("Git index appears corrupted, attempting to fix...")
+                try:
+                    # Remove index lock if it exists
+                    index_lock = Path(repo.git_dir) / "index.lock"
+                    if index_lock.exists():
+                        index_lock.unlink()
+                        logger.info("Removed stale index.lock file")
+
+                    # Reset the index
+                    repo.git.reset("--mixed")
+                    logger.info("Reset git index")
+
+                    # Try stash again
+                    repo.git.stash(
+                        "push",
+                        "--include-untracked",
+                        "-m",
+                        "gitnextver-auto-stash",
+                    )
+                    return True
+                except Exception as fix_error:
+                    logger.error(f"Failed to fix git index: {fix_error}")
+                    console.print(
+                        Panel(
+                            Text(
+                                "Git index is corrupted. Try running:\n"
+                                "rm -f .git/index.lock\n"
+                                "git reset --mixed",
+                                style="bold red",
+                            ),
+                            title="❌ Git Index Error",
+                            border_style="red",
+                        )
+                    )
+                    raise
+            else:
+                raise
+    return False
+
+
+def apply_latest_stash(repo: git.Repo) -> bool:
+    """Apply (pop) the most recent stash if one exists.
+
+    Returns True when the stash is successfully applied (or none existed).
+    Returns False when applying the stash leads to merge conflicts or other
+    errors that require manual user intervention.
+    """
+    stash_list = repo.git.stash("list").strip()
+    if not stash_list:
+        # Nothing to apply
+        return True
+
+    try:
+        logger.info("Re-applying stashed changes …")
+        repo.git.stash("pop")
+        logger.info("Successfully re-applied stashed changes")
+        return True
+    except GitCommandError as exc:
+        message = str(exc)
+        if "CONFLICT" in message.upper():
+            logger.error("Applying stash resulted in conflicts")
+            console.print(
+                Panel(
+                    Text(
+                        "Applying stashed changes resulted in "
+                        "merge conflicts!\n\n"
+                        "Please resolve conflicts manually and run the "
+                        "command again.",
+                        style="bold red",
+                    ),
+                    title="❌ Merge Conflict",
+                    border_style="red",
+                )
+            )
+            return False
+
+        logger.error(f"Failed to apply stash: {exc}")
+        console.print(
+            Panel(
+                Text(f"Failed to apply stash: {exc}", style="bold red"),
+                title="❌ Stash Error",
+                border_style="red",
+            )
+        )
+        return False
+
+
+def pull_with_conflict_check(repo: git.Repo) -> bool:
+    """Pull from the selected remote and check for merge conflicts.
+
+    Returns True on success, False if a conflict or pull failure occurred.
+    If no remote is configured, the function logs a warning and returns
+    True (nothing to pull).
+    """
+    remote = _select_remote(repo)
+
+    if remote is None:
+        logger.warning("No git remotes configured – skipping pull step.")
+        return True
+
+    try:
+        logger.info(f"Pulling from remote '{remote.name}' …")
+        remote.pull()
+        logger.info("Successfully pulled from remote")
+        return True
+    except GitCommandError as exc:
+        if "CONFLICT" in str(exc).upper():
+            logger.error("Git pull resulted in conflicts")
+            console.print(
+                Panel(
+                    Text(
+                        "Git pull resulted in merge conflicts!\n\n"
+                        "Please resolve conflicts manually and run the "
+                        "command again.",
+                        style="bold red",
+                    ),
+                    title="❌ Merge Conflict",
+                    border_style="red",
+                )
+            )
+            return False
+
+        logger.error(f"Git pull failed: {exc}")
+        console.print(
+            Panel(
+                Text(f"Git pull failed: {exc}", style="bold red"),
+                title="❌ Pull Error",
+                border_style="red",
+            )
+        )
+        return False
+
+
+def ensure_gitpython_compatibility(repo: git.Repo) -> None:
+    """Ensure git index is compatible with GitPython by downgrading if needed."""
+    try:
+        # Test if GitPython can read the index
+        _ = repo.index.entries
+    except AssertionError as e:
+        # The AssertionError from GitPython index version incompatibility
+        logger.warning(f"Git index version incompatible with GitPython: {e}")
+        logger.warning("Attempting to downgrade git index to version 2...")
+        try:
+            # Downgrade index to version 2 (compatible with GitPython)
+            repo.git.update_index("--index-version", "2")
+            logger.info("Successfully downgraded git index to version 2")
+
+            # Verify the fix worked by testing index access again
+            _ = repo.index.entries
+            logger.info("GitPython can now access the git index")
+        except GitCommandError as downgrade_error:
+            logger.error(f"Failed to downgrade git index: {downgrade_error}")
+            raise
+        except Exception as verify_error:
+            logger.error(f"Git index still incompatible after downgrade: {verify_error}")
+            raise
+
+
+def commit_and_tag(
+    repo: git.Repo,
+    version: str,
+    verbose: bool = False,
+) -> None:
+    """Add all files, commit, create tag, and push."""
+    try:
+        # Add all untracked and modified files
+        logger.info("Adding all untracked and modified files...")
+        repo.git.add(A=True)
+
+        # Check if there are any changes to commit
+        if not repo.is_dirty() and not repo.untracked_files:
+            logger.warning("No changes to commit")
+            console.print(
+                Panel(
+                    Text("No changes found to commit", style="yellow"),
+                    title="⚠️  Warning",
+                    border_style="yellow",
+                )
+            )
+            return
+
+        # Ensure GitPython compatibility before committing
+        ensure_gitpython_compatibility(repo)
+
+        # Commit with version as message
+        logger.info(f"Committing changes with message: {version}")
+        repo.index.commit(version)
+
+        # Create tag
+        logger.info(f"Creating tag: {version}")
+        repo.create_tag(version)
+
+        # Push commits and tags
+        logger.info("Pushing commits and tags to remote...")
+        remote = _select_remote(repo)
+        if remote is None:
+            logger.warning("No remotes configured – skipping push step.")
+        else:
+            remote.push()
+            remote.push(tags=True)
+
+        console.print(
+            Panel(
+                Text(
+                    f"✅ Successfully created and pushed version {version}",
+                    style="bold green",
+                ),
+                title="🎉 Success",
+                border_style="green",
+            )
+        )
+
+    except GitCommandError as e:
+        logger.error(f"Git operation failed: {e}")
+        console.print(
+            Panel(
+                Text(f"Git operation failed: {str(e)}", style="bold red"),
+                title="❌ Git Error",
+                border_style="red",
+            )
+        )
+        sys.exit(1)
+
+
+def main(directory: Optional[str] = None, verbose: bool = False) -> None:
+    """
+    Main function to handle git version tagging.
+
+    Args:
+        directory: Directory to work in (defaults to current directory)
+        verbose: Enable verbose logging
+    """
+    setup_logging(verbose)
+
+    # Determine working directory
+    work_dir = Path(directory) if directory else Path.cwd()
+    work_dir = work_dir.resolve()
+
+    logger.info(f"Working in directory: {work_dir}")
+
+    # Check if it's a git repository
+    if not is_git_repo(work_dir):
+        console.print(
+            Panel(
+                Text(
+                    f"Directory {work_dir} is not a git repository!",
+                    style="bold red",
+                ),
+                title="❌ Not a Git Repository",
+                border_style="red",
+            )
+        )
+        sys.exit(1)
+
+    # Initialize git repo object
+    repo = git.Repo(work_dir)
+
+    # Ensure git index is compatible with GitPython early on
+    try:
+        ensure_gitpython_compatibility(repo)
+    except Exception as e:
+        logger.error(f"Failed to ensure GitPython compatibility: {e}")
+        console.print(
+            Panel(
+                Text(
+                    f"Git index compatibility issue: {e}\n\n"
+                    "This may be due to a newer git index version. "
+                    "Try running: git update-index --index-version=2",
+                    style="bold red",
+                ),
+                title="❌ Git Index Error",
+                border_style="red",
+            )
+        )
+        sys.exit(1)
+
+    # If there are local changes, stash them so that pull can proceed safely
+    had_stash = stash_uncommitted_changes(repo)
+
+    # Pull from remote
+    if not pull_with_conflict_check(repo):
+        # If pull failed and we created a stash, attempt to restore it so the
+        # user does not lose their work (even though they may need to resolve
+        # issues manually afterwards).
+        if had_stash:
+            try:
+                repo.git.stash("pop")
+            except GitCommandError:
+                # If even restoring fails we still proceed to exit – the user
+                # has to handle the situation manually.
+                pass
+        sys.exit(1)
+
+    # Re-apply stashed changes (if any)
+    if had_stash and not apply_latest_stash(repo):
+        sys.exit(1)
+
+    # Get last version tag
+    last_tag = get_last_version_tag(repo)
+    logger.info(f"Last version tag: {last_tag if last_tag else 'None found'}")
+
+    # Calculate next version
+    next_version = calculate_next_version(last_tag)
+    logger.info(f"Next version will be: {next_version}")
+
+    console.print(
+        Panel(
+            Text(
+                f"Current version: {last_tag if last_tag else 'None'}\n"
+                f"Next version: {next_version}",
+                style="bold blue",
+            ),
+            title="📋 Version Info",
+            border_style="blue",
+        )
+    )
+
+    # Commit and tag
+    commit_and_tag(repo, next_version, verbose)
+
+
+def app() -> None:
+    """CLI entry point for gitnextver."""
+    fire.Fire(main)
+
+
+if __name__ == "__main__":
+    app()