tasktree-manager 2.12.0__tar.gz → 2.12.1__tar.gz

{tasktree_manager-2.12.0 → tasktree_manager-2.12.1}/.github/workflows/release.yml

@@ -4,9 +4,16 @@
 # Handles version bumping, testing, building, PyPI publishing,
 # and GitHub release creation.
 #
+# Order matters: the version is only *computed* up front; lint and the full
+# test matrix run against the pushed commit, and only when they pass is the
+# bump committed, tagged and pushed. A red release run therefore never
+# leaves a ghost tag or a bumped pyproject on main.
+#
 # Triggers:
 #   - Push to main: semantic-release determines if a release is needed
-#   - Manual dispatch: choose release type, pre-release, and draft options
+#   - Manual dispatch: choose release type, pre-release, and draft options.
+#     Both `draft` and `pre_release` skip the PyPI upload (the pipeline can
+#     only produce final X.Y.Z versions) and only shape the GitHub release.
 
 name: Release
 
@@ -26,12 +33,12 @@ on:
           - minor
           - major
       pre_release:
-        description: "Mark as pre-release?"
+        description: "Mark the GitHub release as pre-release? (skips PyPI)"
         required: false
         default: false
         type: boolean
       draft:
-        description: "Create as draft release?"
+        description: "Create the GitHub release as a draft? (skips PyPI)"
         required: false
         default: false
         type: boolean
@@ -49,7 +56,6 @@ jobs:
         uses: actions/checkout@v4
         with:
           fetch-depth: 0
-          token: ${{ secrets.PERSONAL_ACCESS_TOKEN }}
 
       - name: Set up Python
         uses: actions/setup-python@v5
@@ -57,84 +63,79 @@ jobs:
           python-version: "3.12"
 
       - name: Install dependencies
-        run: pip install python-semantic-release build hatch-vcs
+        # Pinned: an unpinned resolver pull once produced a PSR/GitPython
+        # combination that crashed on startup
+        run: pip install "python-semantic-release==10.6.2"
 
       - name: Determine version
         id: determine_version
         env:
-          GH_TOKEN: ${{ secrets.PERSONAL_ACCESS_TOKEN }}
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         run: |
-          # Get current version from pyproject.toml
-          current_version=$(python -c "
-          import re
-          content = open('pyproject.toml').read()
-          match = re.search(r'^\s*version\s*=\s*\"([^\"]+)\"', content, re.MULTILINE)
-          print(match.group(1) if match else '0.0.0')
-          ")
+          # The latest v* tag is the source of truth for the current version
+          # (semantic-release derives the next one from it). pyproject is
+          # only reported: a stray local bump must not shift the release.
+          latest_tag=$(git describe --tags --abbrev=0 --match 'v[0-9]*' 2>/dev/null || echo "v0.0.0")
+          current_version="${latest_tag#v}"
           echo "current_version=${current_version}" >> $GITHUB_OUTPUT
-          echo "Current version: ${current_version}"
+          echo "Current version (latest tag): ${current_version}"
 
           release_type="${{ inputs.release_type || 'auto' }}"
 
           if [ "$release_type" = "auto" ]; then
-            # Use semantic-release to determine bump type from commit history.
-            # When no qualifying commits exist, `version --print` prints the
+            # Use semantic-release to determine the next version from the
+            # commit history. When no qualifying commits exist it prints the
             # CURRENT version — require an actual bump before releasing.
-            VERSION=$(semantic-release version --print 2>/dev/null || echo "")
+            # A tool crash is an error, never "no release needed".
+            if ! VERSION=$(semantic-release version --print); then
+              echo "::error::semantic-release failed to compute the next version"
+              exit 1
+            fi
             if [ -n "$VERSION" ] && [ "$VERSION" != "$current_version" ]; then
-              # Determine bump type by comparing versions
-              IFS='.' read -r cur_major cur_minor cur_patch <<< "$current_version"
-              IFS='.' read -r new_major new_minor new_patch <<< "$VERSION"
-              if [ "$new_major" -gt "$cur_major" ]; then
-                bump_type="major"
-              elif [ "$new_minor" -gt "$cur_minor" ]; then
-                bump_type="minor"
-              else
-                bump_type="patch"
-              fi
-              # Use bump_version.py to get the actual new version
-              new_version=$(python scripts/bump_version.py "$bump_type" --dry-run 2>&1 | grep "New version:" | awk '{print $3}')
+              new_version="$VERSION"
               echo "new_version=${new_version}" >> $GITHUB_OUTPUT
               echo "released=true" >> $GITHUB_OUTPUT
-              echo "bump_type=${bump_type}" >> $GITHUB_OUTPUT
-              echo "Auto-detected bump type: ${bump_type}, version: ${new_version}"
+              echo "Auto-detected next version: ${new_version}"
             else
               echo "released=false" >> $GITHUB_OUTPUT
               echo "No release needed (no qualifying commits)"
             fi
           else
-            # Manual bump using bump_version.py
-            new_version=$(python scripts/bump_version.py "$release_type" --dry-run 2>&1 | grep "New version:" | awk '{print $3}')
-            if [ -n "$new_version" ]; then
-              echo "new_version=${new_version}" >> $GITHUB_OUTPUT
-              echo "released=true" >> $GITHUB_OUTPUT
-              echo "bump_type=${release_type}" >> $GITHUB_OUTPUT
-              echo "Manual bump to: ${new_version}"
-            else
-              echo "released=false" >> $GITHUB_OUTPUT
-              echo "Failed to determine new version"
-              exit 1
-            fi
+            # Manual bump computed from the latest tag
+            IFS='.' read -r major minor patch <<< "$current_version"
+            case "$release_type" in
+              major) new_version="$((major + 1)).0.0" ;;
+              minor) new_version="${major}.$((minor + 1)).0" ;;
+              patch) new_version="${major}.${minor}.$((patch + 1))" ;;
+              *) echo "::error::unknown release type ${release_type}"; exit 1 ;;
+            esac
+            echo "new_version=${new_version}" >> $GITHUB_OUTPUT
+            echo "released=true" >> $GITHUB_OUTPUT
+            echo "Manual bump to: ${new_version}"
           fi
 
-      - name: Apply version bump
-        if: steps.determine_version.outputs.released == 'true'
-        run: |
-          bump_type="${{ steps.determine_version.outputs.bump_type }}"
-          python scripts/bump_version.py "$bump_type"
+  lint:
+    name: Lint
+    needs: prepare-release
+    if: needs.prepare-release.outputs.released == 'true'
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
 
-      - name: Commit and tag version
-        if: steps.determine_version.outputs.released == 'true'
-        run: |
-          new_version="${{ steps.determine_version.outputs.new_version }}"
-          git config --local user.email "github-actions[bot]@users.noreply.github.com"
-          git config --local user.name "github-actions[bot]"
-          git add -A
-          git diff --cached --quiet && echo "No changes to commit" || \
-            git commit -m "chore(release): ${new_version} [skip ci]"
-          git tag -fa "v${new_version}" -m "Release v${new_version}"
-          git push origin main
-          git push origin "v${new_version}" --force
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+
+      - name: Install ruff
+        run: pip install ruff
+
+      - name: Run ruff linter
+        run: ruff check tasktree_manager tests
+
+      - name: Run ruff formatter check
+        run: ruff format --check tasktree_manager tests
 
   test:
     name: Test (Python ${{ matrix.python-version }})
@@ -144,12 +145,12 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        python-version: ["3.11", "3.13"]
+        # Same matrix as ci.yml: the release gate must not be weaker than CI
+        python-version: ["3.10", "3.11", "3.12", "3.13"]
     steps:
       - name: Checkout code
         uses: actions/checkout@v4
         with:
-          ref: "v${{ needs.prepare-release.outputs.new_version }}"
           fetch-depth: 0
 
       - name: Set up Python ${{ matrix.python-version }}
@@ -170,9 +171,47 @@ jobs:
       - name: Run tests
         run: pytest tests/ -v --tb=short
 
+  tag-release:
+    name: Commit and Tag
+    needs: [prepare-release, lint, test]
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+        with:
+          # The exact commit that was tested. Pushing HEAD:main below fails
+          # (non-fast-forward) if main moved in the meantime, instead of
+          # tagging code the gate never saw.
+          ref: ${{ github.sha }}
+          fetch-depth: 0
+          token: ${{ secrets.PERSONAL_ACCESS_TOKEN }}
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+
+      - name: Apply version bump
+        # Write the exact version semantic-release computed; deriving it
+        # again from pyproject would drift whenever pyproject and the tag
+        # disagree (phantom or skipped releases)
+        run: python scripts/bump_version.py --set "${{ needs.prepare-release.outputs.new_version }}"
+
+      - name: Commit and tag version
+        run: |
+          new_version="${{ needs.prepare-release.outputs.new_version }}"
+          git config --local user.email "github-actions[bot]@users.noreply.github.com"
+          git config --local user.name "github-actions[bot]"
+          git add -A
+          git diff --cached --quiet && echo "No changes to commit" || \
+            git commit -m "chore(release): ${new_version} [skip ci]"
+          git tag -a "v${new_version}" -m "Release v${new_version}"
+          git push origin HEAD:main
+          git push origin "v${new_version}"
+
   build:
     name: Build Package
-    needs: [prepare-release, test]
+    needs: [prepare-release, tag-release]
     runs-on: ubuntu-latest
     steps:
       - name: Checkout code
@@ -210,6 +249,9 @@ jobs:
   publish-pypi:
     name: Publish to PyPI
     needs: [prepare-release, build]
+    # Drafts and pre-releases never reach PyPI: bump_version.py only emits
+    # final X.Y.Z versions, so uploading would publish a real release
+    if: ${{ !inputs.draft && !inputs.pre_release }}
     runs-on: ubuntu-latest
     environment: pypi
     permissions:
@@ -231,7 +273,13 @@ jobs:
 
   github-release:
     name: Create GitHub Release
-    needs: [prepare-release, publish-pypi]
+    needs: [prepare-release, build, publish-pypi]
+    # Run after a successful build whether PyPI publishing ran or was
+    # skipped (draft / pre-release), but never after a failed upload
+    if: >-
+      always() &&
+      needs.build.result == 'success' &&
+      (needs.publish-pypi.result == 'success' || needs.publish-pypi.result == 'skipped')
     runs-on: ubuntu-latest
     permissions:
       contents: write

{tasktree_manager-2.12.0 → tasktree_manager-2.12.1}/CHANGELOG.md

@@ -15,6 +15,18 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Git hooks support
 - Custom task metadata
 
+## [2.12.1] - 2026-09-03
+
+### Changed
+- Align guides with deletion, config and platform behaviour
+- **release**: Gate tag on lint and tests, derive version from tags
+
+### Fixed
+- **tui**: Install configured keybindings, safe worktree delete, markup-safe rows
+- **config**: Keep env overrides out of config.toml and fail on bad TOML
+- **services**: Harden task deletion, creation and archive safety
+
+
 ## [2.12.0] - 2026-07-31
 
 ### Added

{tasktree_manager-2.12.0 → tasktree_manager-2.12.1}/PKG-INFO

@@ -1,10 +1,11 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: tasktree-manager
-Version: 2.12.0
+Version: 2.12.1
 Summary: TUI application for managing worktree-based tasks
 License-File: LICENSE
 Requires-Python: >=3.10
 Requires-Dist: textual>=7.0.0
+Requires-Dist: tomli>=2.0.1; python_version < '3.11'
 Provides-Extra: dev
 Requires-Dist: build>=1.0.0; extra == 'dev'
 Requires-Dist: pytest-asyncio>=0.23.0; extra == 'dev'

{tasktree_manager-2.12.0 → tasktree_manager-2.12.1}/README.md

@@ -82,7 +82,7 @@ tasktree-manager repos           # available repos in REPOS_DIR
 tasktree-manager add-repo DIC-1901-argocd-tls infra
 tasktree-manager status                       # current task inferred from $PWD; also --json / --oneline / --forge
 tasktree-manager finish DIC-1901-argocd-tls   # safety sweep -> archive diff -> delete; --push / --no-archive / --force
-tasktree-manager delete DIC-1901-argocd-tls   # low-level delete; refuses on unfinished work; --force overrides
+tasktree-manager delete DIC-1901-argocd-tls   # archive diff -> delete; refuses on unfinished work; --force overrides
 ```
 
 Exit code is 0 on success, 1 on failure with the reason on stderr. `delete` and `finish` run
@@ -173,7 +173,9 @@ Contributions welcome! See [CONTRIBUTING.md](CONTRIBUTING.md) for guidelines.
 - Python 3.10+ (3.13+ recommended)
 - Git 2.0+
 - 256-color terminal
-- Unix-like OS (macOS, Linux, WSL2)
+- Unix-like OS (macOS, Linux, WSL2). Opening a folder, editor or Claude session in a
+  new terminal tab (`o`, `e`, `c`) drives Ghostty via AppleScript and is macOS-only;
+  elsewhere those keys show a notice
 
 See [Installation Guide](docs/installation.md) for detailed requirements and setup.
 

{tasktree_manager-2.12.0 → tasktree_manager-2.12.1}/docs/configuration.md

@@ -165,6 +165,9 @@ claude_path = "claude"
 # task's .claude/settings.local.json so every task session reads and writes one
 # shared memory pool that persists across tasks.
 # Set to "" to disable (each task keeps its own throwaway memory).
+# If you relocated Claude Code's config home with $CLAUDE_CONFIG_DIR, point
+# this under that directory too (the per-repo worktree memory below and
+# session resume already honour the variable).
 # Default: "~/.claude/tasktree-memory"
 claude_memory_dir = "~/.claude/tasktree-memory"
 
@@ -547,7 +550,10 @@ blocklist = [
 > **Upgrading note:** if your existing `config.toml` already contains a
 > `blocklist`, it keeps overriding the defaults — the key-material patterns
 > added in newer versions do NOT apply until you add them (or delete the
-> `blocklist` line to inherit the defaults).
+> `blocklist` line to inherit the defaults). Saving the config from the app
+> (for example on a theme switch) no longer writes the default list: the key
+> is only written when you customised it, so the built-in defaults keep
+> applying as they evolve.
 
 ### Common Use Cases
 
@@ -687,10 +693,14 @@ Override configuration for a single session using environment variables:
 | `TASKS_DIR`               | `tasks_dir`            | `export TASKS_DIR=~/worktrees`   |
 | `TASKTREE_THEME`          | `ui.theme`             | `export TASKTREE_THEME=nord`     |
 | `TASKTREE_DEFAULT_BRANCH` | `git.default_base_branch` | `export TASKTREE_DEFAULT_BRANCH=develop` |
-| `EDITOR`                  | `tools.editor`         | `export EDITOR=nvim`             |
-| `SHELL`                   | `tools.shell`          | `export SHELL=/bin/zsh`          |
+| `EDITOR`                  | `tools.editor` (fallback: used only when `tools.editor` is empty) | `export EDITOR=nvim` |
 | `XDG_CONFIG_HOME`         | (config location)      | `export XDG_CONFIG_HOME=~/.cfg`  |
 
+Environment overrides apply to the running session only: saving the config (for
+example by switching themes with `t`) writes the config-file values back, never the
+overridden ones. Empty values (`TASKS_DIR=`) are ignored. A config file that fails to
+parse is an error at startup, not an empty config.
+
 ### Usage Examples
 
 **Temporary different repos directory:**

{tasktree_manager-2.12.0 → tasktree_manager-2.12.1}/docs/installation.md

@@ -256,7 +256,10 @@ Launch tasktree-manager:
 tasktree-manager
 ```
 
-On first run, you'll see a configuration wizard:
+On first run, you'll see a configuration wizard (it appears when the repositories
+directory, `~/repos` by default, does not exist yet; with `~/repos` already present
+the defaults apply and no `config.toml` is written until you change a setting, such
+as the theme):
 
 #### Configuration Wizard
 

{tasktree_manager-2.12.0 → tasktree_manager-2.12.1}/docs/troubleshooting.md

@@ -692,34 +692,33 @@ wsl --shutdown
 
 ## Git-Specific Issues
 
-### "Branch already exists"
+### Task branch already exists
 
-**Error:**
+Creating a task whose branch already exists in a repo (left behind by an earlier
+task, or created by hand) is not an error: the worktree is created **on the existing
+branch as-is**, keeping every commit on it. The base branch you enter is ignored for
+that repo.
+
+**Error you can still hit:**
 ```
-fatal: A branch named 'FEAT-123' already exists
+fatal: 'FEAT-123' is already checked out at '/Users/you/repos/repo-name'
 ```
 
-**Cause:** Branch exists in repository from previous task.
+**Cause:** the branch is checked out in the main repository (or another worktree);
+git allows a branch in only one worktree at a time.
 
-**Solutions:**
-
-1. **Use different task name:**
-   ```bash
-   # Instead of FEAT-123, use FEAT-123-v2
-   ```
-
-2. **Delete old branch:**
-   ```bash
-   cd ~/repos/repo-name
-   git branch -d FEAT-123  # If merged
-   git branch -D FEAT-123  # Force delete
-   ```
+**Solution:**
+```bash
+cd ~/repos/repo-name
+git switch main            # move the main checkout off the task branch
+# then retry the task creation / add-repo
+```
 
-3. **Use existing branch:**
-   ```bash
-   # When creating task, use existing branch as base
-   Base branch: FEAT-123
-   ```
+To start the task fresh from the base branch instead, delete the old branch first:
+```bash
+git branch -d FEAT-123  # If merged
+git branch -D FEAT-123  # Force delete (loses its unmerged commits)
+```
 
 ### "Detached HEAD state"
 
@@ -921,10 +920,11 @@ Yes! Each task creates its own worktree and branch:
 ### What happens to branches when I delete a task?
 
 - Worktrees are removed from `TASKS_DIR`
-- Local branches remain in main repository
+- The local task branch is deleted from the main repository (`git branch -D`);
+  the remaining diff is archived under `archive_dir` first
 - Remote branches remain on GitHub/GitLab (if pushed)
 
-**Manual cleanup:**
+**Manual cleanup (only for branches created outside tasktree):**
 ```bash
 cd ~/repos/repo-name
 git branch -d FEAT-123  # Delete local branch

{tasktree_manager-2.12.0 → tasktree_manager-2.12.1}/docs/user-guide.md

@@ -310,10 +310,10 @@ what is displayed. Press `?` for the full reference at any time.
 5. Select repos with `Space` (can select multiple)
 6. Tab to "Create" button, press `Enter`
 
-Task names may contain letters, numbers, `.`, `_`, `/` and `-`. Because the
-name becomes a directory under your tasks dir (and a git branch), names with
-`.`/`..` path segments, empty segments, or a leading `-` are rejected; base
-branch names must not start with `-` either.
+Task names may contain letters, numbers, `.`, `_` and `-`. The name becomes a
+single directory under your tasks dir (and a git branch), so `/`, `.`, `..` and a
+leading `-` are rejected; base branch names must be plain branch names too (no
+leading `-`/`+`, no `:` refspecs, none of the characters git forbids in refs).
 
 **Clone task workflow:**
 Useful when you're spinning up several similar tasks that share the same set of repos.
@@ -648,6 +648,14 @@ d (delete task)
    - **Uncommitted changes**: Commit or stash first
    - **Unpushed commits**: Push or force delete
    - **Unmerged branches**: Merge PR or force delete
+   - **Wrong branch checked out**: a worktree that is detached or on another branch
+     is reported as an error — switch back to the task branch (the check and the
+     archive follow the task branch, because that is what deletion removes)
+
+**Delete a single worktree:**
+1. Highlight the worktree in the right panel
+2. Press `D` — the same safety check, dialog (Push / Open Lazygit / Force Delete)
+   and diff archive apply, scoped to that one repo
 
 **Safety features:**
 - tasktree-manager checks for uncommitted changes
@@ -664,7 +672,9 @@ d (delete task)
 - ✅ Worktrees removed from `TASKS_DIR`
 - ✅ Branches remain on remote (if pushed)
 - ✅ Original repos in `REPOS_DIR` untouched
-- ❌ Local branches remain in original repos (cleanup manually if needed)
+- ❌ The local task branch is deleted from each repo (`git branch -D`) — unpushed
+  commits survive only in the archive patch, which is why the safety check blocks
+  unpushed work and why a worktree must be on its task branch to count as safe
 
 **From scripts:** `tasktree-manager finish <task>` runs the same guided flow headlessly
 (safety sweep → optional `--push` → archive → delete), and `tasktree-manager status
@@ -752,9 +762,9 @@ npm i -g hunkdiff
 
 **Direct editor integration:**
 1. Highlight task or worktree
-2. Press `e` to open your configured editor
-3. tasktree-manager suspends while editor runs
-4. Selection is preserved when you return
+2. Press `e` to open your configured editor in a new Ghostty tab (`$EDITOR .`)
+3. tasktree-manager keeps running alongside the editor (macOS + Ghostty only, see
+   Limitations)
 
 **Configure your editor** in `~/.config/tasktree-manager/config.toml`:
 ```toml

{tasktree_manager-2.12.0 → tasktree_manager-2.12.1}/mise.toml

@@ -69,17 +69,20 @@ description = "Run tasktree-manager in dev mode with textual console"
 run = "textual run --dev tasktree_manager.app:TaskTreeApp"
 
 [tasks."release:check"]
-description = "Dry-run to preview what a release would do"
+description = "Dry-run to preview what a patch release would do"
 run = "python scripts/bump_version.py patch --dry-run"
 
+# Releases are cut by the Release workflow (tests gate the tag). Bumping
+# pyproject locally desyncs it from the latest tag and makes the workflow
+# skip or double-bump, so these tasks dispatch the workflow instead.
 [tasks."release:patch"]
-description = "Bump patch version locally"
-run = "python scripts/bump_version.py patch"
+description = "Trigger a patch release via GitHub Actions"
+run = "gh workflow run release.yml -f release_type=patch"
 
 [tasks."release:minor"]
-description = "Bump minor version locally"
-run = "python scripts/bump_version.py minor"
+description = "Trigger a minor release via GitHub Actions"
+run = "gh workflow run release.yml -f release_type=minor"
 
 [tasks."release:major"]
-description = "Bump major version locally"
-run = "python scripts/bump_version.py major"
+description = "Trigger a major release via GitHub Actions"
+run = "gh workflow run release.yml -f release_type=major"

{tasktree_manager-2.12.0 → tasktree_manager-2.12.1}/pyproject.toml

@@ -9,6 +9,7 @@ description = "TUI application for managing worktree-based tasks"
 requires-python = ">=3.10"
 dependencies = [
     "textual>=7.0.0",
+    "tomli>=2.0.1; python_version < '3.11'",
 ]
 
 [project.optional-dependencies]
@@ -70,7 +71,7 @@ version-file = "tasktree_manager/_version.py"
 # Semantic Release Configuration
 [tool.semantic_release]
 version_toml = ["pyproject.toml:tool.semantic_release.version"]
-version = "2.12.0"
+version = "2.12.1"
 tag_format = "v{version}"
 branch = "main"
 commit_message = "chore(release): {version} [skip ci]"

{tasktree_manager-2.12.0 → tasktree_manager-2.12.1}/scripts/bump_version.py

@@ -22,8 +22,16 @@ def parse_args():
     parser = argparse.ArgumentParser(description="Bump version for tasktree-manager")
     parser.add_argument(
         "bump_type",
+        nargs="?",
         choices=["patch", "minor", "major"],
-        help="The type of version bump to perform",
+        help="The type of version bump to perform (omit when using --set)",
+    )
+    parser.add_argument(
+        "--set",
+        dest="set_version",
+        metavar="X.Y.Z",
+        help="Write this exact version instead of bumping (used by the release "
+        "workflow, which takes the version from semantic-release)",
     )
     parser.add_argument(
         "--dry-run",
@@ -106,7 +114,9 @@ def update_pyproject_version(current_version: str, new_version: str, dry_run: bo
         elif stripped.startswith("[") and in_section:
             in_section = False
 
-        if in_section and re.match(r'^version\s*=\s*"' + re.escape(current_version) + '"', stripped):
+        if in_section and re.match(
+            r'^version\s*=\s*"' + re.escape(current_version) + '"', stripped
+        ):
             line = line.replace(f'"{current_version}"', f'"{new_version}"')
             changed = True
 
@@ -135,7 +145,9 @@ def get_changelog_from_commits() -> str:
     try:
         result = subprocess.run(
             ["git", "describe", "--tags", "--abbrev=0"],
-            capture_output=True, text=True, cwd=PROJECT_ROOT,
+            capture_output=True,
+            text=True,
+            cwd=PROJECT_ROOT,
         )
         last_tag = result.stdout.strip() if result.returncode == 0 else ""
     except Exception:
@@ -148,7 +160,10 @@ def get_changelog_from_commits() -> str:
 
     try:
         result = subprocess.run(
-            git_log_cmd, capture_output=True, text=True, cwd=PROJECT_ROOT,
+            git_log_cmd,
+            capture_output=True,
+            text=True,
+            cwd=PROJECT_ROOT,
         )
         commits = result.stdout.strip().splitlines() if result.returncode == 0 else []
     except Exception:
@@ -262,7 +277,11 @@ def update_changelog(new_version: str, message: str = "", dry_run: bool = False)
                 while insert_idx < len(lines) and lines[insert_idx].strip() == "":
                     insert_idx += 1
                 # Skip description lines
-                while insert_idx < len(lines) and lines[insert_idx].strip() and not lines[insert_idx].startswith("##"):
+                while (
+                    insert_idx < len(lines)
+                    and lines[insert_idx].strip()
+                    and not lines[insert_idx].startswith("##")
+                ):
                     insert_idx += 1
                 while insert_idx < len(lines) and lines[insert_idx].strip() == "":
                     insert_idx += 1
@@ -288,7 +307,9 @@ def commit_changes(new_version: str, push: bool = False, create_tag: bool = Fals
             cwd=PROJECT_ROOT,
         )
 
-        subprocess.run(["git", "add", "pyproject.toml", "CHANGELOG.md"], check=True, cwd=PROJECT_ROOT)
+        subprocess.run(
+            ["git", "add", "pyproject.toml", "CHANGELOG.md"], check=True, cwd=PROJECT_ROOT
+        )
 
         commit_message = f"chore(release): bump version to {new_version}"
         subprocess.run(["git", "commit", "-m", commit_message], check=True, cwd=PROJECT_ROOT)
@@ -330,7 +351,14 @@ def main():
 
     try:
         current_version = get_current_version()
-        new_version = calculate_new_version(current_version, args.bump_type)
+        if args.set_version:
+            if not re.fullmatch(r"\d+\.\d+\.\d+", args.set_version):
+                raise ValueError(f"--set expects X.Y.Z, got {args.set_version!r}")
+            new_version = args.set_version
+        elif args.bump_type:
+            new_version = calculate_new_version(current_version, args.bump_type)
+        else:
+            raise ValueError("either a bump type (patch/minor/major) or --set X.Y.Z is required")
 
         print(f"Current version: {current_version}")
         print(f"New version: {new_version}")
@@ -357,7 +385,9 @@ def main():
         else:
             print("\nNext steps:")
             print(f"1. Edit CHANGELOG.md to document changes in version {new_version}")
-            print(f"2. Commit changes: git commit -am 'chore(release): bump version to {new_version}'")
+            print(
+                f"2. Commit changes: git commit -am 'chore(release): bump version to {new_version}'"
+            )
             print(f"3. Create tag: git tag -a v{new_version} -m 'Release v{new_version}'")
             print("4. Push changes: git push origin HEAD && git push origin --tags")
 

{tasktree_manager-2.12.0 → tasktree_manager-2.12.1}/tasktree_manager/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '2.12.0'
-__version_tuple__ = version_tuple = (2, 12, 0)
+__version__ = version = '2.12.1'
+__version_tuple__ = version_tuple = (2, 12, 1)
 
 __commit_id__ = commit_id = None