feat(bump): add interactive toolchain based bump command

* filled out docs

.gitignore

···
 tmp/
 node_modules/
 **/.vitepress/cache/
+# Added by goreleaser init:
+dist/

PROJECT.md

···
 
 ```yaml
 steps:
+  - name: Compute next version
+    run: |
+      NEXT=$(storm bump --bump patch)
+      echo "::set-output name=version::$NEXT"
   - name: Generate changelog
     run: |
       go install ./cmd/storm
-      storm release --version ${{ steps.bump.outputs.version }}
+      storm release --version ${{ steps.bump.outputs.version }} --toolchain package.json
   - name: Tag and push
     run: |
       git add CHANGELOG.md

README.md

···
-# `storm`
+# storm
 
-> A Go-based changelog manager built for clarity, speed, and interaction.
+> Local-first changelog manager with TUIs for review and release.
 
-## Goals
-
-- Use Git as a data source, not a dependency.
-- Store unreleased notes locally (`.changes/*.md`) in a simple, editable format.
-- Provide a terminal UI for reviewing commits and changes interactively.
-- Generate Markdown in strict [Keep a Changelog](https://keepachangelog.com/en/1.1.0/) format.
+## Highlights
 
-### Architecture
+- **Keep a Changelog native:** unreleased notes live in `.changes/*.md` until you promote them.
+- **Toolchain aware:** `storm bump`/`storm release` can update Cargo, npm, Python, and Deno manifests.
+- **TUI friendly:** commit selectors, diff viewers, and toolchain pickers reuse the same palette and key bindings.
+- **Scriptable CLI:** every subcommand prints concise status messages suitable for CI logs.
 
-- **Git integration:** Uses `go-git` for commit history and tag resolution — no shell calls.
-- **Diffing:** Custom lightweight diff engine for readable line-by-line output.
-- **Unreleased storage:** Simple Markdown files with YAML frontmatter (no external formats).
-- **Interactive mode:** Bubble Tea model for categorizing and confirming changes.
-- **Output:** Always produces Keep a Changelog–compliant Markdown.
-
-## Core Packages
+## Install
 
 ```sh
-.
-├── cmd
-├── internal
-│   ├── gitlog       # Parse and structure commit history via `go-git`
-│   ├── diff         # Minimal line diff for display and review
-│   ├── changeset    # Manage `.changes/*.md` files
-│   ├── changelog    # Build and update `CHANGELOG.md` sections
-│   ├── ui           # Bubble Tea–based interactive interface
-│   └── style        # Centralized Lip Gloss palette and formatting
-├── PROJECT.md
-└── README.md
+go install github.com/stormlightlabs/git-storm/cmd/storm@latest
 ```
 
-## Command Model
+(Need Homebrew? Use the `storm.rb` formula template in this repo to build a tap.)
 
-### Unreleased Changes
+## Quick Start
 
 ```sh
-storm unreleased add --type added --scope cli --summary "Add changelog command"
-storm unreleased list
+storm generate --since v1.2.0 --interactive
 storm unreleased review
+storm release --bump patch --toolchain package.json --tag
 ```
 
-Adds or reviews pending `.changes/*.md` entries.
+## Documentation
 
-### Generate From Git
+- [Introduction](docs/introduction.md)
+- [Quickstart](docs/quickstart.md)
+- [Manual](docs/manual.md)
+- [Development Guide](docs/development.md)
 
-```sh
-storm generate <from> <to> [--interactive]
-```
+For a deeper dive into release automation, see `PROJECT.md`.
 
-Pulls commits between refs, categorizes them by prefix, and optionally opens an interactive review.
+## Contributing
 
-### Release
+Run the full test suite before opening a PR:
 
 ```sh
-storm release --version 1.3.0 [--tag]
+go test ./...
 ```
 
-Merges `.changes/*.md` into the changelog, writes a new section, and optionally tags the repository.
-
-## Development Guidance
-
-1. Composable
-   Each subsystem (`diff`, `gitlog`, `tui`, etc.) should work standalone and be callable from tests or other Go programs.
-2. Frontmatter
-
-    ```yaml
-    type: added
-    scope: cli
-    summary: Add changelog command
-    ```
-
-3. Consistent Palette
-
-    See package style for the color palette.
-
-4. Commands should chain naturally and script cleanly:
-
-    ```sh
-    storm unreleased list --json
-    storm generate --since v1.2.0 --interactive
-    storm release --version 1.3.0
-    ```
-
-5. Tests
-    - Research testing bubbletea programs
-    - Use golden files for diff/changelog output.
-    - Use in-memory `go-git` repos in unit tests.
-
-## Roadmap
-
-| Phase | Deliverable                                    |
-| ----- | ---------------------------------------------- |
-| 1     | Core CLI (`generate`, `unreleased`, `release`) |
-| 2     | Git integration and commit parsing             |
-| 3     | Diff engine and styling                        |
-| 4     | `.changes` storage and parsing                 |
-| 5     | Interactive TUI                                |
-| 6     | Keep a Changelog writer                        |
-| 7     | Git tagging and CI integration                 |
-
-## Notes
-
-- No external dependencies beyond `cobra`, `go-git`, `bubbletea`, `lipgloss`, and `yaml.v3`.
-- Keep the workflow simple and reproducible so changelogs can be deterministically derived from local data.
-- Make sure interactive sessions degrade gracefully in non-TTY environments.
-
-## Conventional Commits
-
-### Structure
-
-| Element                   | Format                                   | Description                              |
-| ------------------------- | ---------------------------------------- | ---------------------------------------- |
-| Header                    | `<type>(<scope>): <description>`         | The main commit message line.            |
-| Scope                     | Optional, e.g. `api`, `cli`, `deps`      | Indicates part of the codebase affected. |
-| Breaking Change Indicator | `!` after type/scope, e.g. `feat(api)!:` | Marks a breaking API change.             |
-| Body                      | (Optional) one blank line then body text | Explanation of what & why.               |
-| Footer                    | (Optional) one blank line then meta info | Issue refs, `BREAKING CHANGE: …`, etc    |
-
-### Types
-
-| Type       | Description                                                             |
-| ---------- | ----------------------------------------------------------------------- |
-| `feat`     | A new feature.                                                          |
-| `fix`      | A bug fix.                                                              |
-| `docs`     | Documentation only changes.                                             |
-| `style`    | Code style changes (formatting, whitespace) that don’t affect behavior. |
-| `refactor` | Code changes that neither fix a bug nor add a feature.                  |
-| `perf`     | Performance improvements.                                               |
-| `test`     | Adding or updating tests.                                               |
-| `build`    | Changes that affect the build system or dependencies.                   |
-| `ci`       | Changes to CI configuration and scripts.                                |
-| `chore`    | Other changes that don’t touch src/test (e.g., tooling, config).        |
-| `revert`   | Reverts a previous commit.                                              |
-
-### Examples
-
-```text
-feat(api): add pagination endpoint
-
-fix(ui): correct button alignment issue
-
-docs: update README installation instructions
-
-perf(core): optimize user query performance
-
-refactor: restructure payment module for clarity
-
-style: apply consistent formatting
-
-test(auth): add integration tests for OAuth flow
-
-build(deps): bump dependencies to latest versions
-
-ci: add GitHub Actions workflow for CI
-
-chore: update .gitignore and clean up obsolete files
-
-feat(api)!: remove support for legacy endpoints
-
-BREAKING CHANGE: API no longer accepts XML-formatted requests.
-```
-
-### Reference
-
-<https://www.conventionalcommits.org/en/v1.0.0/> "Conventional Commits"
+Issues and feature ideas are welcome—Storm is intentionally modular so new
+commands and TUIs can be added without touching the entire codebase.

cmd/bump.go

···
+package main
+
+import (
+	"fmt"
+	"path/filepath"
+
+	"github.com/spf13/cobra"
+	"github.com/stormlightlabs/git-storm/internal/changelog"
+	"github.com/stormlightlabs/git-storm/internal/style"
+	"github.com/stormlightlabs/git-storm/internal/versioning"
+)
+
+func bumpCmd() *cobra.Command {
+	var bumpKind string
+	var toolchainSelectors []string
+
+	cmd := &cobra.Command{
+		Use:   "bump",
+		Short: "Calculate the next semantic version and optionally update toolchain manifests",
+		RunE: func(cmd *cobra.Command, args []string) error {
+			kind, err := versioning.ParseBumpType(bumpKind)
+			if err != nil {
+				return err
+			}
+
+			changelogPath := filepath.Join(repoPath, output)
+			parsed, err := changelog.Parse(changelogPath)
+			if err != nil {
+				return fmt.Errorf("failed to parse changelog: %w", err)
+			}
+
+			current, _ := versioning.LatestVersion(parsed)
+			nextVersion, err := versioning.Next(current, kind)
+			if err != nil {
+				return err
+			}
+
+			style.Headlinef("Next version: %s", nextVersion)
+
+			updated, err := updateToolchainTargets(repoPath, nextVersion, toolchainSelectors)
+			if err != nil {
+				return err
+			}
+			for _, manifest := range updated {
+				style.Addedf("✓ Updated %s", manifest.RelPath)
+			}
+
+			fmt.Fprintln(cmd.OutOrStdout(), nextVersion)
+			return nil
+		},
+	}
+
+	cmd.Flags().StringVar(&bumpKind, "bump", "", "Which semver component to bump (major, minor, or patch)")
+	cmd.Flags().StringSliceVar(&toolchainSelectors, "toolchain", nil, "Toolchain manifests to update (paths, types, or 'interactive')")
+	cmd.MarkFlagRequired("bump")
+
+	return cmd
+}

cmd/bump_test.go

···
+package main
+
+import (
+	"bytes"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+const sampleChangelog = `# Changelog
+
+## [Unreleased]
+
+## [1.2.3] - 2024-01-01
+### Added
+- Initial release
+`
+
+func TestBumpCommandPrintsVersion(t *testing.T) {
+	dir := t.TempDir()
+	writeFile(t, filepath.Join(dir, "CHANGELOG.md"), sampleChangelog)
+
+	oldRepo := repoPath
+	oldOutput := output
+	repoPath = dir
+	output = "CHANGELOG.md"
+	t.Cleanup(func() {
+		repoPath = oldRepo
+		output = oldOutput
+	})
+
+	cmd := bumpCmd()
+	cmd.SetArgs([]string{"--bump", "minor"})
+	var out bytes.Buffer
+	cmd.SetOut(&out)
+	cmd.SetErr(&out)
+
+	if err := cmd.Execute(); err != nil {
+		t.Fatalf("bump command failed: %v", err)
+	}
+
+	if !strings.Contains(out.String(), "1.3.0") {
+		t.Fatalf("expected output to contain 1.3.0, got %q", out.String())
+	}
+}
+
+func TestBumpCommandUpdatesPackageJSON(t *testing.T) {
+	dir := t.TempDir()
+	writeFile(t, filepath.Join(dir, "CHANGELOG.md"), sampleChangelog)
+	writeFile(t, filepath.Join(dir, "package.json"), `{"name":"demo","version":"1.2.3"}`)
+
+	oldRepo := repoPath
+	oldOutput := output
+	repoPath = dir
+	output = "CHANGELOG.md"
+	t.Cleanup(func() {
+		repoPath = oldRepo
+		output = oldOutput
+	})
+
+	cmd := bumpCmd()
+	cmd.SetArgs([]string{"--bump", "patch", "--toolchain", "package.json"})
+	var out bytes.Buffer
+	cmd.SetOut(&out)
+	cmd.SetErr(&out)
+
+	if err := cmd.Execute(); err != nil {
+		t.Fatalf("bump command failed: %v", err)
+	}
+
+	contents, err := os.ReadFile(filepath.Join(dir, "package.json"))
+	if err != nil {
+		t.Fatalf("failed to read package.json: %v", err)
+	}
+
+	if !strings.Contains(string(contents), "1.2.4") {
+		t.Fatalf("expected package.json to contain bumped version, got %s", contents)
+	}
+}
+
+func writeFile(t *testing.T, path, contents string) {
+	if err := os.WriteFile(path, []byte(contents), 0o644); err != nil {
+		t.Fatalf("failed to write %s: %v", path, err)
+	}
+}

cmd/main.go

···
 
 	root.PersistentFlags().StringVar(&repoPath, "repo", ".", "Path to the Git repository")
 	root.PersistentFlags().StringVarP(&output, "output", "o", "CHANGELOG.md", "Output changelog file path")
-	root.AddCommand(generateCmd(), unreleasedCmd(), releaseCmd(), diffCmd(), checkCmd(), versionCmd())
+	root.AddCommand(generateCmd(), unreleasedCmd(), releaseCmd(), bumpCmd(), diffCmd(), checkCmd(), versionCmd())
 
-	if err := fang.Execute(ctx, root, fang.WithColorSchemeFunc(style.NewColorScheme)); err != nil {
+	if err := fang.Execute(ctx, root, fang.WithColorSchemeFunc(style.NewColorScheme), fang.WithoutCompletions()); err != nil {
 		log.Fatalf("Execution failed: %v", err)
 	}
 }

cmd/release.go

···
 FLAGS
 
 	--version <X.Y.Z>     Semantic version for the new release (required)
+	--bump <type>         Automatically bump the previous version (major|minor|patch)
 	--date <YYYY-MM-DD>   Release date (default: today)
 	--clear-changes       Delete .changes/*.md files after successful release
 	--dry-run             Preview changes without writing files
 	--tag                 Create an annotated Git tag with release notes
+	--toolchain <value>   Update toolchain manifests (path/type or 'interactive')
 	--repo <path>         Path to the Git repository (default: .)
 	--output <path>       Output changelog file path (default: CHANGELOG.md)
 */
···
 	"github.com/stormlightlabs/git-storm/internal/changeset"
 	"github.com/stormlightlabs/git-storm/internal/shared"
 	"github.com/stormlightlabs/git-storm/internal/style"
+	"github.com/stormlightlabs/git-storm/internal/versioning"
 )
 
 func releaseCmd() *cobra.Command {
 	var (
 		version      string
+		bumpKind     string
 		date         string
 		clearChanges bool
 		dryRun       bool
 		tag          bool
+		toolchains   []string
 	)
 
 	c := &cobra.Command{
···
 		Long: `Merges all .changes entries into CHANGELOG.md under a new version header.
 Optionally creates a Git tag and clears the .changes directory.`,
 		RunE: func(cmd *cobra.Command, args []string) error {
-			if err := changelog.ValidateVersion(version); err != nil {
+			changelogPath := filepath.Join(repoPath, output)
+			existingChangelog, err := changelog.Parse(changelogPath)
+			if err != nil {
+				return fmt.Errorf("failed to parse changelog: %w", err)
+			}
+
+			resolvedVersion, err := resolveReleaseVersion(version, bumpKind, existingChangelog)
+			if err != nil {
 				return err
 			}
+			version = resolvedVersion
 
 			releaseDate := date
 			if releaseDate == "" {
···
 				return fmt.Errorf("failed to build version: %w", err)
 			}
 
-			changelogPath := filepath.Join(repoPath, output)
-			existingChangelog, err := changelog.Parse(changelogPath)
-			if err != nil {
-				return fmt.Errorf("failed to parse existing changelog: %w", err)
-			}
-
 			changelog.Merge(existingChangelog, newVersion)
 
 			if dryRun {
···
 				displayVersionPreview(newVersion)
 				style.Newline()
 				style.Println("No files were modified (--dry-run)")
+				if len(toolchains) > 0 {
+					style.Warningf("Skipping toolchain updates (--dry-run)")
+				}
 				return nil
 			}
 
···
 				style.Println("✓ Deleted %d entry files from %s", deletedCount, changesDir)
 			}
 
+			if len(toolchains) > 0 {
+				updated, err := updateToolchainTargets(repoPath, version, toolchains)
+				if err != nil {
+					return err
+				}
+				for _, manifest := range updated {
+					style.Addedf("✓ Updated %s", manifest.RelPath)
+				}
+			}
+
 			style.Newline()
 			style.Headlinef("Release %s completed successfully", version)
 
···
 	}
 
 	c.Flags().StringVar(&version, "version", "", "Semantic version for the new release (e.g., 1.3.0)")
+	c.Flags().StringVar(&bumpKind, "bump", "", "Automatically bump the previous version (major, minor, or patch)")
 	c.Flags().StringVar(&date, "date", "", "Release date in YYYY-MM-DD format (default: today)")
 	c.Flags().BoolVar(&clearChanges, "clear-changes", false, "Delete .changes/*.md files after successful release")
 	c.Flags().BoolVar(&dryRun, "dry-run", false, "Preview changes without writing files")
 	c.Flags().BoolVar(&tag, "tag", false, "Create an annotated Git tag with release notes")
-	c.MarkFlagRequired("version")
+	c.Flags().StringSliceVar(&toolchains, "toolchain", nil, "Toolchain manifests to update (paths, types, or 'interactive')")
 
 	return c
+}
+
+func resolveReleaseVersion(versionFlag, bumpFlag string, existing *changelog.Changelog) (string, error) {
+	if bumpFlag == "" {
+		if versionFlag == "" {
+			return "", fmt.Errorf("either --version or --bump must be provided")
+		}
+		if err := changelog.ValidateVersion(versionFlag); err != nil {
+			return "", err
+		}
+		return versionFlag, nil
+	}
+
+	if versionFlag != "" {
+		return "", fmt.Errorf("--version and --bump cannot be used together")
+	}
+
+	kind, err := versioning.ParseBumpType(bumpFlag)
+	if err != nil {
+		return "", err
+	}
+
+	var current string
+	if v, ok := versioning.LatestVersion(existing); ok {
+		current = v
+	}
+
+	return versioning.Next(current, kind)
 }
 
 // createReleaseTag creates an annotated Git tag for the release with changelog entries as the message.

cmd/release_test.go

···
 
 	testutils.Expect.True(t, strings.HasPrefix(message, "Release 1.0.0\n\n"), "Should still have release header even with no sections")
 }
+
+func TestResolveReleaseVersion(t *testing.T) {
+	existing := &changelog.Changelog{Versions: []changelog.Version{{Number: "Unreleased"}, {Number: "1.2.3"}}}
+
+	version, err := resolveReleaseVersion("", "minor", existing)
+	if err != nil {
+		t.Fatalf("resolveReleaseVersion returned error: %v", err)
+	}
+	if version != "1.3.0" {
+		t.Fatalf("expected 1.3.0, got %s", version)
+	}
+
+	version, err = resolveReleaseVersion("2.0.0", "", existing)
+	if err != nil {
+		t.Fatalf("resolveReleaseVersion returned error: %v", err)
+	}
+	if version != "2.0.0" {
+		t.Fatalf("expected 2.0.0, got %s", version)
+	}
+
+	if _, err := resolveReleaseVersion("2.0.0", "patch", existing); err == nil {
+		t.Fatal("expected error when both --version and --bump are set")
+	}
+
+	blankChangelog := &changelog.Changelog{}
+	version, err = resolveReleaseVersion("", "patch", blankChangelog)
+	if err != nil {
+		t.Fatalf("resolveReleaseVersion returned error: %v", err)
+	}
+	if version != "0.0.1" {
+		t.Fatalf("expected 0.0.1 for empty changelog, got %s", version)
+	}
+}

cmd/toolchain_helpers.go

···
+package main
+
+import (
+	"fmt"
+
+	"github.com/stormlightlabs/git-storm/internal/toolchain"
+)
+
+func updateToolchainTargets(repoPath, newVersion string, selectors []string) ([]toolchain.Manifest, error) {
+	if len(selectors) == 0 {
+		return nil, nil
+	}
+
+	selected, interactive, available, err := toolchain.ResolveTargets(repoPath, selectors)
+	if err != nil {
+		return nil, err
+	}
+
+	if interactive {
+		if len(available) == 0 {
+			return nil, fmt.Errorf("no toolchain manifests detected for interactive selection")
+		}
+		chosen, err := toolchain.SelectManifests(available)
+		if err != nil {
+			return nil, err
+		}
+		selected = append(selected, chosen...)
+	}
+
+	selected = dedupeManifests(selected)
+	if len(selected) == 0 {
+		return nil, nil
+	}
+
+	for _, manifest := range selected {
+		if err := toolchain.UpdateManifest(manifest, newVersion); err != nil {
+			return nil, err
+		}
+	}
+
+	return selected, nil
+}
+
+func dedupeManifests(manifests []toolchain.Manifest) []toolchain.Manifest {
+	if len(manifests) == 0 {
+		return nil
+	}
+
+	seen := make(map[string]struct{})
+	var result []toolchain.Manifest
+	for _, manifest := range manifests {
+		key := manifest.Path
+		if _, ok := seen[key]; ok {
+			continue
+		}
+		seen[key] = struct{}{}
+		result = append(result, manifest)
+	}
+	return result
+}

docs/.vitepress/config.mts

···
 
 // https://vitepress.dev/reference/site-config
 export default defineConfig({
-    title: "Git Storm",
-    description: "A changelog manager",
+    title: "Storm",
+    description: "Local-first changelog manager for git repositories",
     markdown: {
         theme: {
             light: "catppuccin-latte",
···
     themeConfig: {
         // https://vitepress.dev/reference/default-theme-config
         nav: [
-            { text: "Home", link: "/" },
-            { text: "Examples", link: "/markdown-examples" },
+            { text: "Introduction", link: "/introduction" },
+            { text: "Quickstart", link: "/quickstart" },
+            { text: "Manual", link: "/manual" },
+            { text: "Development", link: "/development" },
         ],
-
         sidebar: [
             {
-                text: "Examples",
+                text: "Getting Started",
                 items: [
-                    { text: "Markdown Examples", link: "/markdown-examples" },
-                    { text: "Runtime API Examples", link: "/api-examples" },
+                    { text: "Introduction", link: "/introduction" },
+                    { text: "Quickstart", link: "/quickstart" },
+                ],
+            },
+            {
+                text: "Reference",
+                items: [
+                    { text: "Manual", link: "/manual" },
+                    { text: "Development", link: "/development" },
                 ],
             },
         ],
-
         socialLinks: [
-            { icon: "github", link: "https://github.com/vuejs/vitepress" },
+            {
+                icon: "github",
+                link: "https://github.com/stormlightlabs/git-storm",
+            },
+            {
+                icon: "bluesky",
+                link: "http://bsky.app/profile/desertthunder.dev/",
+            },
         ],
     },
 });

docs/api-examples.md

···
----
-outline: deep
----
-
-# Runtime API Examples
-
-This page demonstrates usage of some of the runtime APIs provided by VitePress.
-
-The main `useData()` API can be used to access site, theme, and page data for the current page. It works in both `.md` and `.vue` files:
-
-```md
-<script setup>
-import { useData } from 'vitepress'
-
-const { theme, page, frontmatter } = useData()
-</script>
-
-## Results
-
-### Theme Data
-<pre>{{ theme }}</pre>
-
-### Page Data
-<pre>{{ page }}</pre>
-
-### Page Frontmatter
-<pre>{{ frontmatter }}</pre>
-```
-
-<script setup>
-import { useData } from 'vitepress'
-
-const { site, theme, page, frontmatter } = useData()
-</script>
-
-## Results
-
-### Theme Data
-<pre>{{ theme }}</pre>
-
-### Page Data
-<pre>{{ page }}</pre>
-
-### Page Frontmatter
-<pre>{{ frontmatter }}</pre>
-
-## More
-
-Check out the documentation for the [full list of runtime APIs](https://vitepress.dev/reference/runtime-api#usedata).

docs/development.md

···
+---
+title: Development
+outline: deep
+---
+
+# Development
+
+Storm is designed to be hackable: each package works on its own and can be
+composed in tests or other Go programs. This document contains the guidance that
+previously lived in the repository README.
+
+## Guidance
+
+1. **Composable:** packages such as `diff`, `gitlog`, and `tui` should expose
+   standalone entry points that can be imported elsewhere.
+2. **Frontmatter:** `.changes/*.md` entries follow this schema:
+
+   ```yaml
+   type: added
+   scope: cli
+   summary: Add changelog command
+   ```
+
+3. **Palette:** all TUIs must use the colors defined in `internal/style`.
+4. **Command chaining:** every command should behave well in pipelines, e.g.
+
+   ```sh
+   storm unreleased list --json
+   storm generate --since v1.2.0 --interactive
+   storm release --bump patch --toolchain package.json
+   ```
+
+5. **Tests:**
+   - Prefer teatest for Bubble Tea programs.
+   - Use golden files for diff/changelog output when useful.
+   - Spin up in-memory `go-git` repositories in unit tests.
+
+## Notes
+
+- Keep the workflow deterministic so releases can be derived from local files
+  alone.
+- TUIs should degrade gracefully when `stdin`/`stdout` are not TTYs.
+- The binary should not depend on external services beyond git data already in
+  the repo.
+
+## Roadmap
+
+| Phase | Deliverable                                    |
+| ----- | ---------------------------------------------- |
+| 1     | Core CLI (`generate`, `unreleased`, `release`) |
+| 2     | Git integration and commit parsing             |
+| 3     | Diff engine and styling                        |
+| 4     | `.changes` storage and parsing                 |
+| 5     | Interactive TUI                                |
+| 6     | Keep a Changelog writer                        |
+| 7     | Git tagging and CI integration                 |
+
+## Conventional Commits
+
+Storm follows the [Conventional Commits](https://www.conventionalcommits.org)
+spec. Use the format `type(scope): summary` with optional body and footers.
+
+### Structure
+
+| Element | Format | Description |
+| ------- | ------ | ----------- |
+| Header | `<type>(<scope>): <description>` | Main commit line. |
+| Scope | Optional, e.g. `api`, `cli`, `deps`. | Part of the codebase affected. |
+| Breaking indicator | `!` after type/scope, e.g. `feat(api)!:` | Marks breaking change. |
+| Body | Blank line then body text. | Explains what and why. |
+| Footer | Blank line then metadata. | Issue references, `BREAKING CHANGE`, etc. |
+
+### Types
+
+| Type | Description |
+| ---- | ----------- |
+| `feat` | New feature. |
+| `fix` | Bug fix. |
+| `docs` | Documentation change. |
+| `style` | Formatting-only change. |
+| `refactor` | Structural change without new features or fixes. |
+| `perf` | Performance improvement. |
+| `test` | Adds or updates tests. |
+| `build` | Build system or dependency change. |
+| `ci` | CI config change. |
+| `chore` | Tooling or config change outside src/test. |
+| `revert` | Reverts a previous commit. |
+
+### Examples
+
+```text
+feat(api): add pagination endpoint
+fix(ui): correct button alignment issue
+docs: update README installation instructions
+perf(core): optimize user query performance
+refactor: restructure payment module for clarity
+style: apply consistent formatting
+test(auth): add integration tests for OAuth flow
+build(deps): bump dependencies to latest versions
+ci: add GitHub Actions workflow for CI
+chore: update .gitignore and clean up obsolete files
+feat(api)!: remove support for legacy endpoints
+
+BREAKING CHANGE: API no longer accepts XML-formatted requests.
+```

docs/index.md

···
 ---
-# https://vitepress.dev/reference/default-theme-home-page
 layout: home
-
 hero:
-  name: "Git Storm"
-  text: "A changelog manager"
-  tagline: My great project tagline
+  name: "Storm"
+  text: "Local-first changelog manager"
+  tagline: "Collect unreleased notes, review them in TUIs, and publish semantic releases without leaving git"
   actions:
     - theme: brand
-      text: Markdown Examples
-      link: /markdown-examples
-    - theme: alt
-      text: API Examples
-      link: /api-examples
-
+      text: Quickstart
+      link: /quickstart
 features:
-  - title: Feature A
-    details: Lorem ipsum dolor sit amet, consectetur adipiscing elit
-  - title: Feature B
-    details: Lorem ipsum dolor sit amet, consectetur adipiscing elit
-  - title: Feature C
-    details: Lorem ipsum dolor sit amet, consectetur adipiscing elit
+  - title: Keep a Changelog native
+    details: Entries stay in `.changes/*.md` until you promote them, keeping releases reproducible and reviewable.
+  - title: Toolchain aware
+    details: The bump and release commands can update Cargo, npm, Python, and Deno manifests in lockstep.
+  - title: Built for TUIs
+    details: Commit selectors, unreleased reviews, and diff viewers are powered by Bubble Tea and share the same palette.
 ---
-

docs/introduction.md

···
+---
+title: Introduction
+outline: deep
+---
+
+# Introduction
+
+Storm is a CLI that keeps changelog entries close to your code. It grew from a
+few principles:
+
+1. **Plain text first.** Every unreleased change is a Markdown file that lives
+   in your repo, making reviews and rebases simple.
+2. **Deterministic releases.** Given the same `.changes` directory, Storm will
+   always write the same `CHANGELOG.md` section.
+3. **Interactive when helpful, scriptable everywhere.** TUIs exist for reviews
+   and diffs, but every action prints machine-readable summaries for CI.
+
+## Why Storm?
+
+Storm sits between `git log` and `CHANGELOG.md`. It understands conventional
+commits, keeps notes in version control, and prefers deterministic text files
+over generated blobs. The CLI is written in Go, so it ships as a single binary
+that runs anywhere your repository does.
+
+- **Local-first workflow:** no external services or databases.
+- **Deterministic releases:** `storm release` is idempotent and can run in CI.
+- **Composable commands:** each subcommand prints useful summaries for scripts.
+
+## Quick Preview
+
+```sh
+# Extract commits into .changes entries
+storm generate --since v1.2.0 --interactive
+
+# Review pending notes
+storm unreleased review
+
+# Cut a new release and update package.json
+storm release --bump minor --toolchain package.json --tag
+```
+
+Need the details? Head to the [Quickstart](/quickstart) for a guided flow or
+read the [manual](/manual) for every flag and exit code.
+
+## Architecture Overview
+
+```sh
+.git/
+.changes/
+CHANGELOG.md
+```
+
+- `storm generate` and `storm unreleased add` populate `.changes/`.
+- `storm check` and your CI ensure nothing merges without an entry.
+- `storm release` merges the queue into `CHANGELOG.md`, optionally creates a
+tag, and can update external manifests.
+
+## Toolchain-aware versioning
+
+The bump and release commands understand common ecosystem manifests:
+
+| Manifest | Alias | Notes |
+| -------- | ----- | ----- |
+| `Cargo.toml` | `cargo`, `rust` | Updates `[package]` version. |
+| `pyproject.toml` | `pyproject`, `python`, `poetry` | Supports `[project]` and `[tool.poetry]`. |
+| `package.json` | `npm`, `node`, `package` | Edits the top-level `version` field. |
+| `deno.json` | `deno` | Updates the root `version`. |
+
+Pass specific paths or the literal `interactive` to launch the toolchain picker
+TUI.
+
+## TUIs everywhere
+
+Storm shares a consistent palette (`internal/style`) across Bubble Tea
+experiences:
+
+- **Commit selector** for `storm generate --interactive`.
+- **Unreleased review** for curating `.changes` entries.
+- **Diff viewer** for `storm diff` with split/unified modes.
+- **Toolchain picker** accessible via `--toolchain interactive`.
+
+Each interface supports familiar Vim-style navigation (↑/↓, g/G, space to
+select, `q` to quit) and degrades gracefully when no TTY is available.
+
+## Suggested Workflow
+
+1. Developers add `.changes` entries alongside feature branches.
+2. Pull requests run `storm check --since <last-release>`.
+3. Release engineers run `storm generate` (if needed) then `storm release`.
+4. CI tags the release and publishes artifacts.
+
+Need concrete steps? See the [Quickstart](/quickstart) or jump to the
+[manual](/manual).

docs/manual.md

···
+---
+title: Storm CLI Manual
+---
+
+# NAME
+
+**storm** is a git powered aware changelog manager for Go projects.
+
+## SYNOPSIS
+
+```text
+storm [--repo <path>] [--output <file>] <command> [flags]
+```
+
+## DESCRIPTION
+
+Storm keeps unreleased notes in `.changes/*.md`, promotes them into
+`CHANGELOG.md`, and offers TUIs for reviewing diffs and entries. The binary
+is composed of self-contained subcommands that chain well inside scripts
+or CI jobs.
+
+### GLOBAL FLAGS
+
+| Flag                    | Description                                              |
+| ----------------------- | -------------------------------------------------------- |
+| `--repo <path>`         | Working tree to operate on (default: current directory). |
+| `-o`, `--output <file>` | Target changelog (default: `CHANGELOG.md`).              |
+
+### COMMANDS
+
+#### `storm bump`
+
+Calculate the next semantic version by inspecting `CHANGELOG.md`.
+
+```text
+storm bump --bump <major|minor|patch> [--toolchain value...]
+```
+
+##### Flags
+
+| Flag                         | Description                                                                                                                                                                                            |
+| ---------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| `--bump <type>` _(required)_ | Which semver component to increment.                                                                                                                                                                   |
+| `--toolchain <value>`        | Update language manifests (`Cargo.toml`, `pyproject.toml`, `package.json`, `deno.json`). Accepts explicit paths, type aliases like `cargo`/`npm`, or the literal `interactive` to launch a picker TUI. |
+
+#### `storm release`
+
+Promote `.changes/*.md` into the changelog and optionally tag the repo.
+
+```text
+storm release (--version X.Y.Z | --bump <type>) [flags]
+```
+
+##### Flags
+
+| Flag                  | Description                                                                         |
+| --------------------- | ----------------------------------------------------------------------------------- |
+| `--version <X.Y.Z>`   | Explicit version for the new changelog entry.                                       |
+| `--bump <type>`       | Derive the version from the previous release (mutually exclusive with `--version`). |
+| `--date <YYYY-MM-DD>` | Override the release date (default: today).                                         |
+| `--clear-changes`     | Remove `.changes/*.md` files after a successful release.                            |
+| `--dry-run`           | Render a preview without touching any files.                                        |
+| `--tag`               | Create an annotated git tag containing the release notes.                           |
+| `--toolchain <value>` | Update manifest files just like in `storm bump`.                                    |
+
+#### `storm generate`
+
+Create `.changes/*.md` files from commit history, with optional TUI review.
+
+```text
+storm generate <from> <to>
+storm generate --since <tag> [to]
+```
+
+##### Flags
+
+| Flag                  | Description                                       |
+| --------------------- | ------------------------------------------------- |
+| `-i`, `--interactive` | Open a commit selector TUI for choosing entries.  |
+| `--since <tag>`       | Shortcut for `<from>`; defaults `<to>` to `HEAD`. |
+
+#### `storm diff`
+
+Side-by-side or unified diff with TUI navigation.
+
+```text
+storm diff <from>..<to> [flags]
+storm diff <from> <to> [flags]
+```
+
+| Flag                            | Description                                           |
+| ------------------------------- | ----------------------------------------------------- |
+| `-f`, `--file <path>`           | Restrict the diff to a single file.                   |
+| `-e`, `--expanded`              | Show all unchanged lines instead of compressed hunks. |
+| `-v`, `--view <split\|unified>` | Rendering style (default: split).                     |
+
+#### `storm check`
+
+Verify every commit in a range has a corresponding unreleased entry.
+
+```text
+storm check <from> <to>
+storm check --since <tag> [to]
+```
+
+| Flag            | Description                                                |
+| --------------- | ---------------------------------------------------------- |
+| `--since <tag>` | Start range at the provided tag and default end to `HEAD`. |
+
+Non-zero exit status indicates missing entries. Messages containing
+`[nochanges]` or `[skip changelog]` are ignored.
+
+#### `storm unreleased`
+
+Manage `.changes` entries directly.
+
+##### `add`
+
+```text
+storm unreleased add --type <kind> --summary <text> [--scope value]
+```
+
+| Flag                                                | Description                                 |
+| --------------------------------------------------- | ------------------------------------------- |
+| `--type <added\|changed\|fixed\|removed\|security>` | Entry category.                             |
+| `--summary <text>`                                  | Short human readable note.                  |
+| `--scope <value>`                                   | Optional component indicator (e.g., `cli`). |
+
+##### `list`
+
+```text
+storm unreleased list [--json]
+```
+
+| Flag     | Description                                        |
+| -------- | -------------------------------------------------- |
+| `--json` | Emit machine-readable JSON instead of styled text. |
+
+##### `partial`
+
+```text
+storm unreleased partial <commit-ref> [flags]
+```
+
+| Flag               | Description                                         |
+| ------------------ | --------------------------------------------------- |
+| `--type <value>`   | Override the inferred type from the commit message. |
+| `--summary <text>` | Override the inferred summary.                      |
+| `--scope <value>`  | Optional component indicator.                       |
+
+##### `review`
+
+```text
+storm unreleased review
+```
+
+Launch a Bubble Tea TUI for editing and deleting entries before release.
+Requires a TTY; fall back to `storm unreleased list` otherwise.
+
+#### `storm version`
+
+Print the current build’s version string.
+
+## FILES
+
+- `.changes/` — queue of unreleased entries created by `storm generate` or `storm unreleased add`.
+- `CHANGELOG.md` — Keep a Changelog-compatible file updated by `storm release`.
+
+## SEE ALSO
+
+`CHANGELOG.md`, [Keep a Changelog](https://keepachangelog.com), semantic versioning at [semver.org](https://semver.org).

docs/markdown-examples.md

···
-# Markdown Extension Examples
-
-This page demonstrates some of the built-in markdown extensions provided by VitePress.
-
-## Syntax Highlighting
-
-VitePress provides Syntax Highlighting powered by [Shiki](https://github.com/shikijs/shiki), with additional features like line-highlighting:
-
-**Input**
-
-````md
-```js{4}
-export default {
-  data () {
-    return {
-      msg: 'Highlighted!'
-    }
-  }
-}
-```
-````
-
-**Output**
-
-```js{4}
-export default {
-  data () {
-    return {
-      msg: 'Highlighted!'
-    }
-  }
-}
-```
-
-## Custom Containers
-
-**Input**
-
-```md
-::: info
-This is an info box.
-:::
-
-::: tip
-This is a tip.
-:::
-
-::: warning
-This is a warning.
-:::
-
-::: danger
-This is a dangerous warning.
-:::
-
-::: details
-This is a details block.
-:::
-```
-
-**Output**
-
-::: info
-This is an info box.
-:::
-
-::: tip
-This is a tip.
-:::
-
-::: warning
-This is a warning.
-:::
-
-::: danger
-This is a dangerous warning.
-:::
-
-::: details
-This is a details block.
-:::
-
-## More
-
-Check out the documentation for the [full list of markdown extensions](https://vitepress.dev/guide/markdown).

docs/quickstart.md

···
+---
+title: Quickstart
+outline: deep
+---
+
+# Quickstart
+
+This walkthrough gets you from zero to a published changelog entry in a few
+minutes. It mirrors the default workflow baked into the CLI.
+
+## 1. Install the CLI
+
+```sh
+go install github.com/stormlightlabs/git-storm/cmd/storm@latest
+```
+
+Verify the binary is available:
+
+```sh
+storm version
+```
+
+## 2. Capture unreleased changes
+
+Create a `.changes` entry manually or generate them from commits.
+
+### Option A — Manual entry
+
+```sh
+storm unreleased add \
+  --type added \
+  --scope cli \
+  --summary "Add bump command"
+```
+
+### Option B — From git history
+
+```sh
+storm generate --since v1.2.0 --interactive
+```
+
+Use the commit selector TUI to pick which commits become entries. Storm writes
+Markdown files such as `.changes/2025-03-01-add-bump-command.md`.
+
+## 3. Review pending entries
+
+```sh
+storm unreleased review
+```
+
+The Bubble Tea UI lets you edit summaries, delete noise, or mark entries as
+ready. In non-interactive environments, fall back to
+`storm unreleased list --json`.
+
+## 4. Dry-run a release
+
+```sh
+storm release --bump patch --dry-run
+```
+
+This prints the new `CHANGELOG` section without modifying files. When the
+output looks right, re-run without `--dry-run`.
+
+## 5. Publish and tag
+
+```sh
+storm release --bump patch --toolchain package.json --tag
+```
+
+- `--bump patch` derives the next version from the previous release.
+- `--toolchain package.json` keeps your npm manifest in sync.
+- `--tag` creates an annotated git tag containing the release notes.
+
+Follow up with standard git commands:
+
+```sh
+git add CHANGELOG.md package.json .changes
+git commit -m "Release v$(storm bump --bump patch)"
+git push origin main --tags
+```
+
+## 6. Enforce entries in CI (optional)
+
+```sh
+storm check --since v1.2.0
+```
+
+The command exits non-zero when commits are missing `.changes` files, making it
+ideal for pre-merge checks.
+
+## Next steps
+
+- Skim the [Introduction](/introduction) to understand the design.
+- Explore every flag in the [manual](/manual).

internal/toolchain/manifest.go

···
+package toolchain
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io/fs"
+	"os"
+	"path/filepath"
+	"regexp"
+	"sort"
+	"strings"
+)
+
+// ManifestType enumerates supported ecosystem manifests whose versions we can bump.
+type ManifestType string
+
+const (
+	ManifestCargo  ManifestType = "cargo"
+	ManifestPython ManifestType = "python"
+	ManifestNode   ManifestType = "node"
+	ManifestDeno   ManifestType = "deno"
+)
+
+var manifestFilenames = map[string]ManifestType{
+	"cargo.toml":     ManifestCargo,
+	"pyproject.toml": ManifestPython,
+	"package.json":   ManifestNode,
+	"deno.json":      ManifestDeno,
+}
+
+var toolchainAliases = map[string]ManifestType{
+	"cargo":          ManifestCargo,
+	"rust":           ManifestCargo,
+	"cargo.toml":     ManifestCargo,
+	"pyproject":      ManifestPython,
+	"pyproject.toml": ManifestPython,
+	"python":         ManifestPython,
+	"package":        ManifestNode,
+	"package.json":   ManifestNode,
+	"npm":            ManifestNode,
+	"node":           ManifestNode,
+	"deno":           ManifestDeno,
+	"deno.json":      ManifestDeno,
+}
+
+var skipWalkDirs = map[string]struct{}{
+	".git":         {},
+	"node_modules": {},
+	"vendor":       {},
+	"dist":         {},
+	"target":       {},
+	"tmp":          {},
+}
+
+// Manifest describes a discovered manifest file with its current version.
+type Manifest struct {
+	Type    ManifestType
+	Path    string
+	RelPath string
+	Version string
+	Name    string
+}
+
+// DisplayLabel returns a concise label for TUI listings.
+func (m Manifest) DisplayLabel() string {
+	label := m.RelPath
+	if m.Name != "" {
+		label = fmt.Sprintf("%s · %s", label, m.Name)
+	}
+	if m.Version != "" {
+		label = fmt.Sprintf("%s @ %s", label, m.Version)
+	}
+	return label
+}
+
+// Discover scans the repository tree for supported manifest files.
+func Discover(root string) ([]Manifest, error) {
+	absRoot, err := filepath.Abs(root)
+	if err != nil {
+		return nil, err
+	}
+
+	var manifests []Manifest
+	err = filepath.WalkDir(absRoot, func(path string, d fs.DirEntry, walkErr error) error {
+		if walkErr != nil {
+			return walkErr
+		}
+		if d.IsDir() {
+			if path != absRoot {
+				if _, skip := skipWalkDirs[strings.ToLower(d.Name())]; skip {
+					return filepath.SkipDir
+				}
+			}
+			return nil
+		}
+
+		kind, ok := manifestFilenames[strings.ToLower(d.Name())]
+		if !ok {
+			return nil
+		}
+
+		manifest, err := buildManifest(absRoot, path, kind)
+		if err != nil {
+			return err
+		}
+		manifests = append(manifests, manifest)
+		return nil
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	sort.Slice(manifests, func(i, j int) bool {
+		return manifests[i].RelPath < manifests[j].RelPath
+	})
+	return manifests, nil
+}
+
+// ResolveTargets resolves CLI selectors into manifest targets, optionally requesting a TUI selection.
+func ResolveTargets(root string, selectors []string) ([]Manifest, bool, []Manifest, error) {
+	if len(selectors) == 0 {
+		return nil, false, nil, nil
+	}
+
+	absRoot, err := filepath.Abs(root)
+	if err != nil {
+		return nil, false, nil, err
+	}
+
+	available, err := Discover(absRoot)
+	if err != nil {
+		return nil, false, nil, err
+	}
+
+	manifestByPath := make(map[string]Manifest)
+	for _, manifest := range available {
+		manifestByPath[filepath.Clean(manifest.Path)] = manifest
+	}
+
+	var selected []Manifest
+	seen := make(map[string]struct{})
+	interactive := false
+
+	for _, raw := range selectors {
+		value := strings.TrimSpace(raw)
+		if value == "" {
+			continue
+		}
+
+		lower := strings.ToLower(value)
+		switch lower {
+		case "interactive", "tui", "select":
+			interactive = true
+			continue
+		}
+
+		if kind, ok := toolchainAliases[lower]; ok {
+			matched := false
+			for _, manifest := range available {
+				if manifest.Type == kind {
+					key := filepath.Clean(manifest.Path)
+					if _, exists := seen[key]; !exists {
+						selected = append(selected, manifest)
+						seen[key] = struct{}{}
+					}
+					matched = true
+				}
+			}
+			if !matched {
+				return nil, false, nil, fmt.Errorf("no %s manifest found", value)
+			}
+			continue
+		}
+
+		target := value
+		if !filepath.IsAbs(value) {
+			target = filepath.Join(absRoot, value)
+		}
+		target = filepath.Clean(target)
+
+		manifest, err := loadManifest(absRoot, target)
+		if err != nil {
+			return nil, false, nil, err
+		}
+
+		if _, exists := seen[target]; !exists {
+			selected = append(selected, manifest)
+			seen[target] = struct{}{}
+		}
+	}
+
+	return selected, interactive, available, nil
+}
+
+// UpdateManifest rewrites the manifest on disk with the provided version.
+func UpdateManifest(manifest Manifest, newVersion string) error {
+	switch manifest.Type {
+	case ManifestCargo:
+		return updateTomlVersion(manifest.Path, []string{"package"}, newVersion)
+	case ManifestPython:
+		return updateTomlVersion(manifest.Path, []string{"project", "tool.poetry"}, newVersion)
+	case ManifestNode:
+		return updateJSONVersion(manifest.Path, newVersion)
+	case ManifestDeno:
+		return updateJSONVersion(manifest.Path, newVersion)
+	default:
+		return fmt.Errorf("unsupported manifest type: %s", manifest.Type)
+	}
+}
+
+func buildManifest(root, path string, kind ManifestType) (Manifest, error) {
+	version, name, err := extractMetadata(path, kind)
+	if err != nil {
+		return Manifest{}, err
+	}
+
+	rel, err := filepath.Rel(root, path)
+	if err != nil {
+		rel = path
+	}
+
+	return Manifest{
+		Type:    kind,
+		Path:    filepath.Clean(path),
+		RelPath: filepath.Clean(rel),
+		Version: version,
+		Name:    name,
+	}, nil
+}
+
+func loadManifest(root, path string) (Manifest, error) {
+	info, err := os.Stat(path)
+	if err != nil {
+		return Manifest{}, fmt.Errorf("unable to read %s: %w", path, err)
+	}
+	if info.IsDir() {
+		return Manifest{}, fmt.Errorf("%s is a directory", path)
+	}
+
+	kind, ok := manifestFilenames[strings.ToLower(filepath.Base(path))]
+	if !ok {
+		return Manifest{}, fmt.Errorf("unsupported toolchain file: %s", filepath.Base(path))
+	}
+
+	return buildManifest(root, path, kind)
+}
+
+func extractMetadata(path string, kind ManifestType) (string, string, error) {
+	switch kind {
+	case ManifestCargo:
+		return parseTomlManifest(path, []string{"package"})
+	case ManifestPython:
+		return parseTomlManifest(path, []string{"project", "tool.poetry"})
+	case ManifestNode:
+		return parseJSONManifest(path)
+	case ManifestDeno:
+		return parseJSONManifest(path)
+	default:
+		return "", "", fmt.Errorf("unsupported manifest type: %s", kind)
+	}
+}
+
+func parseJSONManifest(path string) (string, string, error) {
+	data, err := os.ReadFile(path)
+	if err != nil {
+		return "", "", err
+	}
+
+	var payload map[string]any
+	if err := json.Unmarshal(data, &payload); err != nil {
+		return "", "", fmt.Errorf("failed to parse %s: %w", filepath.Base(path), err)
+	}
+
+	version, _ := payload["version"].(string)
+	if version == "" {
+		return "", "", fmt.Errorf("version not found in %s", filepath.Base(path))
+	}
+
+	name, _ := payload["name"].(string)
+	return version, name, nil
+}
+
+func parseTomlManifest(path string, sections []string) (string, string, error) {
+	data, err := os.ReadFile(path)
+	if err != nil {
+		return "", "", err
+	}
+
+	sectionSet := make(map[string]struct{})
+	for _, section := range sections {
+		sectionSet[section] = struct{}{}
+	}
+
+	var current string
+	var version string
+	var name string
+	lines := strings.Split(string(data), "\n")
+
+	for _, line := range lines {
+		trimmed := strings.TrimSpace(line)
+		if trimmed == "" || strings.HasPrefix(trimmed, "#") {
+			continue
+		}
+		if strings.HasPrefix(trimmed, "[") && strings.HasSuffix(trimmed, "]") {
+			current = strings.TrimSpace(strings.Trim(trimmed, "[]"))
+			continue
+		}
+		if _, ok := sectionSet[current]; !ok {
+			continue
+		}
+
+		if value, ok := parseTomlAssignment(line, "version"); ok && version == "" {
+			version = value
+			continue
+		}
+		if value, ok := parseTomlAssignment(line, "name"); ok && name == "" {
+			name = value
+		}
+	}
+
+	if version == "" {
+		return "", "", fmt.Errorf("version not found in %s", filepath.Base(path))
+	}
+
+	return version, name, nil
+}
+
+func parseTomlAssignment(line, key string) (string, bool) {
+	withoutComment := strings.Split(line, "#")[0]
+	parts := strings.SplitN(withoutComment, "=", 2)
+	if len(parts) != 2 {
+		return "", false
+	}
+	if strings.TrimSpace(parts[0]) != key {
+		return "", false
+	}
+
+	value := strings.TrimSpace(parts[1])
+	if len(value) >= 2 {
+		if (value[0] == '"' && value[len(value)-1] == '"') || (value[0] == '\'' && value[len(value)-1] == '\'') {
+			value = value[1 : len(value)-1]
+		}
+	}
+	return value, true
+}
+
+var tomlVersionPattern = regexp.MustCompile(`^(\s*version\s*=\s*)(['"])([^'"]*)(['"])(.*)$`)
+
+func updateTomlVersion(path string, sections []string, newVersion string) error {
+	data, err := os.ReadFile(path)
+	if err != nil {
+		return err
+	}
+
+	sectionSet := make(map[string]struct{})
+	for _, section := range sections {
+		sectionSet[section] = struct{}{}
+	}
+
+	lines := strings.Split(string(data), "\n")
+	current := ""
+	replaced := false
+
+	for idx, line := range lines {
+		trimmed := strings.TrimSpace(line)
+		if strings.HasPrefix(trimmed, "[") && strings.HasSuffix(trimmed, "]") {
+			current = strings.TrimSpace(strings.Trim(trimmed, "[]"))
+			continue
+		}
+		if replaced {
+			continue
+		}
+		if _, ok := sectionSet[current]; !ok {
+			continue
+		}
+		if matches := tomlVersionPattern.FindStringSubmatch(line); matches != nil {
+			lines[idx] = fmt.Sprintf("%s%s%s%s%s", matches[1], matches[2], newVersion, matches[4], matches[5])
+			replaced = true
+		}
+	}
+
+	if !replaced {
+		return fmt.Errorf("version not found in %s", filepath.Base(path))
+	}
+
+	return os.WriteFile(path, []byte(strings.Join(lines, "\n")), 0644)
+}
+
+func updateJSONVersion(path string, newVersion string) error {
+	data, err := os.ReadFile(path)
+	if err != nil {
+		return err
+	}
+
+	start, end, err := findRootJSONVersion(data)
+	if err != nil {
+		return fmt.Errorf("version not found in %s", filepath.Base(path))
+	}
+
+	var buf bytes.Buffer
+	buf.Grow(len(data) - (end - start) + len(newVersion))
+	buf.Write(data[:start])
+	buf.WriteString(newVersion)
+	buf.Write(data[end:])
+
+	return os.WriteFile(path, buf.Bytes(), 0644)
+}
+
+func findRootJSONVersion(data []byte) (int, int, error) {
+	depth := 0
+	inString := false
+	escape := false
+	keyStart := -1
+
+	for i := 0; i < len(data); i++ {
+		b := data[i]
+		if inString {
+			if escape {
+				escape = false
+				continue
+			}
+			if b == '\\' {
+				escape = true
+				continue
+			}
+			if b == '"' {
+				inString = false
+				keyEnd := i
+				if keyStart >= 0 {
+					j := i + 1
+					for j < len(data) && (data[j] == ' ' || data[j] == '\t' || data[j] == '\n' || data[j] == '\r') {
+						j++
+					}
+					if j < len(data) && data[j] == ':' {
+						key := string(data[keyStart:keyEnd])
+						if key == "version" && depth == 1 {
+							valueStart, valueEnd, err := locateJSONString(data, j+1)
+							if err != nil {
+								return -1, -1, err
+							}
+							return valueStart, valueEnd, nil
+						}
+					}
+				}
+				keyStart = -1
+			}
+			continue
+		}
+
+		switch b {
+		case '"':
+			inString = true
+			keyStart = i + 1
+		case '{', '[':
+			depth++
+		case '}', ']':
+			if depth > 0 {
+				depth--
+			}
+		}
+	}
+
+	return -1, -1, fmt.Errorf("version key not found")
+}
+
+func locateJSONString(data []byte, start int) (int, int, error) {
+	i := start
+	for i < len(data) && (data[i] == ' ' || data[i] == '\t' || data[i] == '\n' || data[i] == '\r') {
+		i++
+	}
+	if i >= len(data) || data[i] != '"' {
+		return -1, -1, fmt.Errorf("version value must be a string")
+	}
+	valueStart := i + 1
+	for j := valueStart; j < len(data); j++ {
+		if data[j] == '\\' {
+			j++
+			continue
+		}
+		if data[j] == '"' {
+			return valueStart, j, nil
+		}
+	}
+	return -1, -1, fmt.Errorf("unterminated version string")
+}

internal/toolchain/manifest_test.go

···
+package toolchain
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func TestDiscover(t *testing.T) {
+	dir := t.TempDir()
+
+	writeFile(t, dir, "Cargo.toml", `[package]
+name = "demo"
+version = "0.1.0"
+
+[dependencies]
+serde = "1"
+`)
+
+	subDir := filepath.Join(dir, "app")
+	if err := os.MkdirAll(subDir, 0o755); err != nil {
+		t.Fatalf("failed to create subdir: %v", err)
+	}
+	writeFile(t, subDir, "pyproject.toml", `[project]
+name = "demo-app"
+version = "0.2.0"
+`)
+
+	writeFile(t, dir, "package.json", `{
+  "name": "demo-web",
+  "version": "1.5.0"
+}`)
+
+	writeFile(t, dir, "deno.json", `{
+  "version": "3.1.4"
+}`)
+
+	manifests, err := Discover(dir)
+	if err != nil {
+		t.Fatalf("Discover returned error: %v", err)
+	}
+	if len(manifests) != 4 {
+		t.Fatalf("expected 4 manifests, got %d", len(manifests))
+	}
+
+	manifestByType := make(map[ManifestType]Manifest)
+	for _, manifest := range manifests {
+		manifestByType[manifest.Type] = manifest
+	}
+
+	if manifestByType[ManifestCargo].Version != "0.1.0" {
+		t.Fatalf("cargo version mismatch: %#v", manifestByType[ManifestCargo])
+	}
+	if manifestByType[ManifestPython].Version != "0.2.0" {
+		t.Fatalf("python version mismatch: %#v", manifestByType[ManifestPython])
+	}
+	if manifestByType[ManifestNode].Version != "1.5.0" {
+		t.Fatalf("npm version mismatch: %#v", manifestByType[ManifestNode])
+	}
+	if manifestByType[ManifestDeno].Version != "3.1.4" {
+		t.Fatalf("deno version mismatch: %#v", manifestByType[ManifestDeno])
+	}
+}
+
+func TestResolveTargets(t *testing.T) {
+	dir := t.TempDir()
+	writeFile(t, dir, "Cargo.toml", `[package]
+name = "demo"
+version = "0.1.0"
+`)
+	writeFile(t, dir, "package.json", `{"name":"demo","version":"1.0.0"}`)
+
+	selected, interactive, available, err := ResolveTargets(dir, []string{"cargo"})
+	if err != nil {
+		t.Fatalf("ResolveTargets returned error: %v", err)
+	}
+	if interactive {
+		t.Fatal("expected interactive to be false")
+	}
+	if len(selected) != 1 || selected[0].Type != ManifestCargo {
+		t.Fatalf("expected cargo manifest to be selected, got %#v", selected)
+	}
+	if len(available) != 2 {
+		t.Fatalf("expected 2 discovered manifests, got %d", len(available))
+	}
+
+	selected, interactive, _, err = ResolveTargets(dir, []string{"interactive"})
+	if err != nil {
+		t.Fatalf("ResolveTargets interactive: %v", err)
+	}
+	if !interactive {
+		t.Fatal("expected interactive mode to be true")
+	}
+	if len(selected) != 0 {
+		t.Fatalf("interactive request should not preselect manifests: got %d", len(selected))
+	}
+
+	selected, _, _, err = ResolveTargets(dir, []string{"package.json"})
+	if err != nil {
+		t.Fatalf("ResolveTargets path selection: %v", err)
+	}
+	if len(selected) != 1 || selected[0].Type != ManifestNode {
+		t.Fatalf("expected package.json selection, got %#v", selected)
+	}
+}
+
+func TestUpdateManifest(t *testing.T) {
+	dir := t.TempDir()
+	writeFile(t, dir, "Cargo.toml", `[package]
+name = "demo"
+version = "0.1.0"
+`)
+	writeFile(t, dir, "pyproject.toml", `[project]
+name = "demo"
+version = "0.2.0"
+`)
+	writeFile(t, dir, "package.json", `{"name":"demo","version":"1.0.0"}`)
+	writeFile(t, dir, "deno.json", `{"version":"1.1.0"}`)
+
+	files := []string{"Cargo.toml", "pyproject.toml", "package.json", "deno.json"}
+	for _, name := range files {
+		manifest, err := loadManifest(dir, filepath.Join(dir, name))
+		if err != nil {
+			t.Fatalf("loadManifest(%s) error: %v", name, err)
+		}
+		if err := UpdateManifest(manifest, "9.9.9"); err != nil {
+			t.Fatalf("UpdateManifest(%s) error: %v", name, err)
+		}
+		data, err := os.ReadFile(filepath.Join(dir, name))
+		if err != nil {
+			t.Fatalf("read updated %s: %v", name, err)
+		}
+		if !strings.Contains(string(data), "9.9.9") {
+			t.Fatalf("%s was not updated: %s", name, string(data))
+		}
+	}
+}
+
+func writeFile(t *testing.T, dir, name, content string) {
+	t.Helper()
+	if err := os.WriteFile(filepath.Join(dir, name), []byte(content), 0o644); err != nil {
+		t.Fatalf("failed to write %s: %v", name, err)
+	}
+}

internal/toolchain/selector.go

···
+package toolchain
+
+import (
+	"fmt"
+	"os"
+	"strings"
+
+	tea "github.com/charmbracelet/bubbletea"
+	"github.com/charmbracelet/lipgloss"
+	"github.com/stormlightlabs/git-storm/internal/style"
+	"golang.org/x/term"
+)
+
+var (
+	cursorStyle   = lipgloss.NewStyle().Foreground(style.AccentBlue).Bold(true)
+	selectedStyle = lipgloss.NewStyle().Foreground(style.AddedColor)
+	mutedStyle    = lipgloss.NewStyle().Foreground(style.AccentSteel)
+)
+
+// SelectManifests launches an interactive selector so users can pick which manifests to update.
+func SelectManifests(manifests []Manifest) ([]Manifest, error) {
+	if len(manifests) == 0 {
+		return nil, fmt.Errorf("no toolchain manifests detected")
+	}
+	if !isTTY() {
+		return nil, fmt.Errorf("interactive selection requires a TTY; pass specific --toolchain paths instead")
+	}
+
+	program := tea.NewProgram(newSelectorModel(manifests))
+	finalModel, err := program.Run()
+	if err != nil {
+		return nil, err
+	}
+
+	model, ok := finalModel.(selectorModel)
+	if !ok {
+		return nil, fmt.Errorf("unexpected selector model type %T", finalModel)
+	}
+	if model.cancelled {
+		return nil, fmt.Errorf("selection cancelled")
+	}
+	return model.selectedManifests(), nil
+}
+
+func isTTY() bool {
+	return term.IsTerminal(int(os.Stdout.Fd())) && term.IsTerminal(int(os.Stdin.Fd()))
+}
+
+type selectorModel struct {
+	manifests []Manifest
+	cursor    int
+	selected  map[int]struct{}
+	done      bool
+	cancelled bool
+}
+
+func newSelectorModel(manifests []Manifest) selectorModel {
+	return selectorModel{
+		manifests: manifests,
+		selected:  make(map[int]struct{}),
+	}
+}
+
+func (m selectorModel) Init() tea.Cmd { return nil }
+
+func (m selectorModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
+	switch msg := msg.(type) {
+	case tea.KeyMsg:
+		switch msg.String() {
+		case "q", "esc", "ctrl+c":
+			m.cancelled = true
+			return m, tea.Quit
+		case "enter":
+			if len(m.selected) == 0 && len(m.manifests) > 0 {
+				m.selected[m.cursor] = struct{}{}
+			}
+			m.done = true
+			return m, tea.Quit
+		case " ":
+			if _, ok := m.selected[m.cursor]; ok {
+				delete(m.selected, m.cursor)
+			} else {
+				m.selected[m.cursor] = struct{}{}
+			}
+		case "j", "down":
+			if m.cursor < len(m.manifests)-1 {
+				m.cursor++
+			}
+		case "k", "up":
+			if m.cursor > 0 {
+				m.cursor--
+			}
+		case "home", "g":
+			m.cursor = 0
+		case "end", "G":
+			if len(m.manifests) > 0 {
+				m.cursor = len(m.manifests) - 1
+			}
+		}
+	}
+
+	return m, nil
+}
+
+func (m selectorModel) View() string {
+	if len(m.manifests) == 0 {
+		return "No manifests available"
+	}
+
+	var view strings.Builder
+	view.WriteString(style.StyleHeadline.Render("Select toolchain manifests to bump"))
+	view.WriteString("\n\n")
+
+	for i, manifest := range m.manifests {
+		cursor := " "
+		if i == m.cursor {
+			cursor = cursorStyle.Render("›")
+		}
+		checkbox := "[ ]"
+		if _, ok := m.selected[i]; ok {
+			checkbox = selectedStyle.Render("[x]")
+		}
+		line := fmt.Sprintf("%s %s %s", cursor, checkbox, manifest.DisplayLabel())
+		view.WriteString(line)
+		view.WriteString("\n")
+	}
+
+	view.WriteString("\n")
+	view.WriteString(mutedStyle.Render("space: toggle • enter: confirm • q: cancel"))
+	return view.String()
+}
+
+func (m selectorModel) selectedManifests() []Manifest {
+	if len(m.manifests) == 0 {
+		return nil
+	}
+	var chosen []Manifest
+	for idx, manifest := range m.manifests {
+		if _, ok := m.selected[idx]; ok {
+			chosen = append(chosen, manifest)
+		}
+	}
+	if len(chosen) == 0 && !m.cancelled && len(m.manifests) > 0 {
+		return []Manifest{m.manifests[m.cursor]}
+	}
+	return chosen
+}

internal/toolchain/selector_test.go

···
+package toolchain
+
+import (
+	"testing"
+
+	tea "github.com/charmbracelet/bubbletea"
+	"github.com/stormlightlabs/git-storm/internal/testutils"
+)
+
+func TestSelectorModel_DefaultSelection(t *testing.T) {
+	manifests := []Manifest{{RelPath: "Cargo.toml"}, {RelPath: "package.json"}}
+	model := newSelectorModel(manifests)
+	final := testutils.RunModelWithInteraction(t, model, []tea.Msg{tea.KeyMsg{Type: tea.KeyEnter}})
+	selector := final.(selectorModel)
+	selected := selector.selectedManifests()
+	if len(selected) != 1 || selected[0].RelPath != "Cargo.toml" {
+		t.Fatalf("expected first manifest to be selected, got %#v", selected)
+	}
+}
+
+func TestSelectorModel_ToggleSelection(t *testing.T) {
+	manifests := []Manifest{{RelPath: "Cargo.toml"}, {RelPath: "package.json"}}
+	model := newSelectorModel(manifests)
+	msgs := []tea.Msg{
+		tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune{'j'}},
+		tea.KeyMsg{Type: tea.KeySpace},
+		tea.KeyMsg{Type: tea.KeyEnter},
+	}
+	final := testutils.RunModelWithInteraction(t, model, msgs)
+	selector := final.(selectorModel)
+	selected := selector.selectedManifests()
+	if len(selected) != 1 || selected[0].RelPath != "package.json" {
+		t.Fatalf("expected second manifest to be selected, got %#v", selected)
+	}
+}

internal/ui/ui.go

···
 
 // renderHeader creates the header bar showing file paths.
 func (m DiffModel) renderHeader() string {
-	headerStyle := lipgloss.NewStyle().
-		Foreground(style.AccentBlue).
-		Bold(true).
-		Padding(0, 1)
+	headerStyle := lipgloss.NewStyle().Foreground(style.AccentBlue).Bold(true).Padding(0, 1)
 
 	oldLabel := lipgloss.NewStyle().Foreground(style.RemovedColor).Render("−")
 	newLabel := lipgloss.NewStyle().Foreground(style.AddedColor).Render("+")
···
 	totalWidth := m.viewport.Width
 	helpWidth := lipgloss.Width(helpText)
 	scrollWidth := lipgloss.Width(scrollInfo)
-	padding := totalWidth - helpWidth - scrollWidth - 2
-
-	if padding < 0 {
-		padding = 0
-	}
+	padding := max(totalWidth-helpWidth-scrollWidth-2, 0)
 
 	return footerStyle.Render(
 		helpText + strings.Repeat(" ", padding) + scrollInfo,
···
 	totalWidth := m.width
 	helpWidth := lipgloss.Width(helpText)
 	scrollWidth := lipgloss.Width(scrollInfo)
-	padding := totalWidth - helpWidth - scrollWidth - 2
-
-	if padding < 0 {
-		padding = 0
-	}
+	padding := max(totalWidth-helpWidth-scrollWidth-2, 0)
 
 	return footerStyle.Render(
 		helpText + strings.Repeat(" ", padding) + scrollInfo,

internal/versioning/versioning.go

···
+package versioning
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+
+	"github.com/stormlightlabs/git-storm/internal/changelog"
+)
+
+// BumpType represents the semantic version component to increment.
+type BumpType string
+
+const (
+	BumpMajor BumpType = "major"
+	BumpMinor BumpType = "minor"
+	BumpPatch BumpType = "patch"
+)
+
+// Version represents a semantic version split into numeric components.
+type Version struct {
+	Major int
+	Minor int
+	Patch int
+}
+
+// Parse converts a semantic version string (X.Y.Z) into a Version structure.
+// An empty string returns 0.0.0 to simplify bump workflows.
+func Parse(version string) (Version, error) {
+	if version == "" {
+		return Version{}, nil
+	}
+
+	parts := strings.Split(version, ".")
+	if len(parts) != 3 {
+		return Version{}, fmt.Errorf("invalid semantic version: %s", version)
+	}
+
+	vals := make([]int, 3)
+	for i, part := range parts {
+		value, err := strconv.Atoi(part)
+		if err != nil || value < 0 {
+			return Version{}, fmt.Errorf("invalid semantic version: %s", version)
+		}
+		vals[i] = value
+	}
+
+	return Version{Major: vals[0], Minor: vals[1], Patch: vals[2]}, nil
+}
+
+// String formats the Version back into X.Y.Z form.
+func (v Version) String() string {
+	return fmt.Sprintf("%d.%d.%d", v.Major, v.Minor, v.Patch)
+}
+
+// Bump increments the requested component following semver rules.
+func (v Version) Bump(kind BumpType) Version {
+	switch kind {
+	case BumpMajor:
+		return Version{Major: v.Major + 1, Minor: 0, Patch: 0}
+	case BumpMinor:
+		return Version{Major: v.Major, Minor: v.Minor + 1, Patch: 0}
+	case BumpPatch:
+		return Version{Major: v.Major, Minor: v.Minor, Patch: v.Patch + 1}
+	default:
+		return v
+	}
+}
+
+// Next returns the bumped version string for the provided semantic version.
+func Next(current string, kind BumpType) (string, error) {
+	parsed, err := Parse(current)
+	if err != nil {
+		return "", err
+	}
+	return parsed.Bump(kind).String(), nil
+}
+
+// ParseBumpType validates user input into a BumpType.
+func ParseBumpType(value string) (BumpType, error) {
+	switch strings.ToLower(value) {
+	case string(BumpMajor):
+		return BumpMajor, nil
+	case string(BumpMinor):
+		return BumpMinor, nil
+	case string(BumpPatch):
+		return BumpPatch, nil
+	default:
+		return "", fmt.Errorf("invalid bump type %q (expected major, minor, or patch)", value)
+	}
+}
+
+// LatestVersion scans a parsed changelog for the most recent released version.
+// It skips the "Unreleased" section if present and validates with Keep a Changelog semantics.
+func LatestVersion(ch *changelog.Changelog) (string, bool) {
+	if ch == nil {
+		return "", false
+	}
+
+	for _, v := range ch.Versions {
+		if strings.EqualFold(v.Number, "unreleased") {
+			continue
+		}
+		if err := changelog.ValidateVersion(v.Number); err == nil {
+			return v.Number, true
+		}
+	}
+
+	return "", false
+}

internal/versioning/versioning_test.go

···
+package versioning
+
+import (
+	"testing"
+
+	"github.com/stormlightlabs/git-storm/internal/changelog"
+)
+
+func TestParseAndBump(t *testing.T) {
+	version, err := Parse("1.2.3")
+	if err != nil {
+		t.Fatalf("Parse returned error: %v", err)
+	}
+
+	if version.Major != 1 || version.Minor != 2 || version.Patch != 3 {
+		t.Fatalf("unexpected parse result: %#v", version)
+	}
+
+	major := version.Bump(BumpMajor)
+	if got := major.String(); got != "2.0.0" {
+		t.Fatalf("major bump = %s, want 2.0.0", got)
+	}
+
+	minor := version.Bump(BumpMinor)
+	if got := minor.String(); got != "1.3.0" {
+		t.Fatalf("minor bump = %s, want 1.3.0", got)
+	}
+
+	patch := version.Bump(BumpPatch)
+	if got := patch.String(); got != "1.2.4" {
+		t.Fatalf("patch bump = %s, want 1.2.4", got)
+	}
+}
+
+func TestParseBumpType(t *testing.T) {
+	cases := map[string]BumpType{
+		"MAJOR": BumpMajor,
+		"minor": BumpMinor,
+		"Patch": BumpPatch,
+	}
+
+	for input, expected := range cases {
+		kind, err := ParseBumpType(input)
+		if err != nil {
+			t.Fatalf("ParseBumpType(%s) returned error: %v", input, err)
+		}
+		if kind != expected {
+			t.Fatalf("ParseBumpType(%s) = %s, want %s", input, kind, expected)
+		}
+	}
+
+	if _, err := ParseBumpType("invalid"); err == nil {
+		t.Fatal("expected error for invalid bump type")
+	}
+}
+
+func TestNextHandlesEmptyVersion(t *testing.T) {
+	got, err := Next("", BumpMinor)
+	if err != nil {
+		t.Fatalf("Next returned error: %v", err)
+	}
+	if got != "0.1.0" {
+		t.Fatalf("Next = %s, want 0.1.0", got)
+	}
+}
+
+func TestLatestVersion(t *testing.T) {
+	ch := &changelog.Changelog{
+		Versions: []changelog.Version{
+			{Number: "Unreleased"},
+			{Number: "1.5.0"},
+			{Number: "0.9.1"},
+		},
+	}
+
+	version, ok := LatestVersion(ch)
+	if !ok {
+		t.Fatal("LatestVersion returned false")
+	}
+	if version != "1.5.0" {
+		t.Fatalf("LatestVersion = %s, want 1.5.0", version)
+	}
+
+	if _, ok := LatestVersion(&changelog.Changelog{}); ok {
+		t.Fatal("expected LatestVersion to return false when no releases exist")
+	}
+}