Switch to tag-triggered releases (drop release-please)

release-please's cargo-workspace plugin had two compounding issues that
weren't worth fighting through:
  1. It can't resolve \`version.workspace = true\` inheritance, forcing
     us to either declare versions per crate or write fragile config.
  2. \`extra-files\` paths don't allow \`..\`, so a root-level CHANGELOG
     can't be written from a package declared at \`src-tauri/\`.

Tag-driven release is simpler, more honest, and doesn't impose
Conventional Commits as a hard rule:

  pnpm release patch        # bumps all 7 version locations + Cargo.lock
  git commit -am "chore: release v0.1.1"
  git tag v0.1.1
  git push --follow-tags

The tag push triggers .github/workflows/release.yml, which runs
tauri-action on Windows / macOS / Linux and attaches the .msi / .dmg /
.AppImage / .deb / .rpm bundles to a new GitHub Release.

scripts/bump-version.mjs centralizes the version-sync work — package.json,
src-tauri/tauri.conf.json, all five Cargo.tomls' [package].version,
plus Cargo.lock via cargo update -w.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: rmnunes

.github/workflows/release.yml

@@ -2,40 +2,15 @@ name: Release
 
 on:
   push:
-    branches: [main]
+    tags:
+      - "v*.*.*"
 
 permissions:
   contents: write
-  pull-requests: write
 
 jobs:
-  # Step 1: release-please watches main, opens a "chore(main): release X.Y.Z" PR
-  # that bumps Cargo.toml + Cargo.lock + package.json + tauri.conf.json and
-  # appends to CHANGELOG.md based on Conventional Commits since the last tag.
-  # When the PR is merged, it tags the repo and creates a GitHub Release —
-  # which is what the build job below latches onto.
-  release-please:
-    name: Release-please PR / Release
-    runs-on: ubuntu-latest
-    outputs:
-      release_created: ${{ steps.release.outputs.release_created }}
-      tag_name: ${{ steps.release.outputs.tag_name }}
-      upload_url: ${{ steps.release.outputs.upload_url }}
-    steps:
-      - uses: googleapis/release-please-action@v4
-        id: release
-        with:
-          config-file: .release-please-config.json
-          manifest-file: .release-please-manifest.json
-
-  # Step 2: when release-please publishes a release, build the Tauri bundles on
-  # each OS and upload them to that release. Users on the Releases page see
-  # the .msi/.nsis (Windows), .dmg/.app (macOS), and .deb/.AppImage (Linux)
-  # next to the auto-generated changelog.
   build:
     name: Build (${{ matrix.os }})
-    needs: release-please
-    if: needs.release-please.outputs.release_created
     strategy:
       fail-fast: false
       matrix:
@@ -74,12 +49,21 @@ jobs:
 
       - run: pnpm install --frozen-lockfile
 
-      - name: Build and upload Tauri bundles
+      # tauri-action runs `pnpm tauri build`, then either creates or updates a
+      # GitHub Release for the pushed tag and attaches the platform-native
+      # bundles (.msi/.exe on Windows, .dmg/.app.tar.gz on macOS, .deb/.rpm/
+      # .AppImage on Linux). The first job to reach this step creates the
+      # release; subsequent jobs upload to the same one (matched by tagName).
+      - name: Build and publish Tauri bundles
         uses: tauri-apps/tauri-action@v0
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         with:
-          tagName: ${{ needs.release-please.outputs.tag_name }}
-          releaseName: ${{ needs.release-please.outputs.tag_name }}
+          tagName: ${{ github.ref_name }}
+          releaseName: ${{ github.ref_name }}
+          releaseBody: |
+            See [CHANGELOG.md](https://github.com/rmnunes/pg-shell/blob/main/CHANGELOG.md) for details.
+
+            **Downloads** — pick the file for your OS below.
           releaseDraft: false
           prerelease: false

.release-please-config.json

@@ -62,37 +62,45 @@ If you're not sure which crate a change belongs in, the rule of thumb: anything
 4. Fill in the PR template — especially the "what I tested" section.
 5. CI must be green before review.
 
-## Releases & versioning
+## Releases
 
-Releases are automated via [release-please](https://github.com/googleapis/release-please) and [tauri-action](https://github.com/tauri-apps/tauri-action).
+Releases are tag-triggered. Pushing a `vX.Y.Z` tag to `main` kicks off `.github/workflows/release.yml`, which uses [tauri-action](https://github.com/tauri-apps/tauri-action) to build on Windows / macOS / Linux runners and attach the platform-native bundles to a GitHub Release:
 
-**The flow:**
+- Windows: `.msi` + `.exe` (NSIS)
+- macOS: `.dmg` + `.app.tar.gz`
+- Linux: `.deb` + `.AppImage` + `.rpm`
 
-1. Land commits on `main` using [Conventional Commits](https://www.conventionalcommits.org/):
-   - `feat: …` → minor bump (under v1.0 it's a patch, see config)
-   - `fix: …` → patch bump
-   - `feat!: …` or a `BREAKING CHANGE:` footer → major bump
-   - `chore:`, `docs:`, `refactor:`, `test:` → no version bump
-2. release-please keeps a PR titled `chore(main): release X.Y.Z` open. It bumps `Cargo.toml`, `Cargo.lock`, `package.json`, and `src-tauri/tauri.conf.json`, and updates `CHANGELOG.md`.
-3. **Merging that PR** is the act of releasing. release-please tags `vX.Y.Z` and creates a GitHub Release.
-4. The release event triggers `tauri-action` on Windows / macOS / Linux runners. It builds and uploads:
-   - Windows: `.msi` + `.exe` (NSIS)
-   - macOS: `.dmg` + `.app.tar.gz`
-   - Linux: `.deb` + `.AppImage` + `.rpm`
-5. Users download from the [Releases page](https://github.com/rmnunes/pg-shell/releases).
+Users download from the [Releases page](https://github.com/rmnunes/pg-shell/releases).
 
-**Manual release** (escape hatch — only if release-please is wedged):
+### Cutting a release
+
+Versions live in five places that have to stay in lockstep: `package.json`, `src-tauri/tauri.conf.json`, and the `[package].version` of each Cargo manifest (`src-tauri/Cargo.toml` + the four crates under `crates/`). The `pnpm release` script handles all of them plus regenerating `Cargo.lock`:
+
+```sh
+pnpm release patch       # 0.1.0 -> 0.1.1
+pnpm release minor       # 0.1.0 -> 0.2.0
+pnpm release major       # 0.1.0 -> 1.0.0
+pnpm release 1.2.3       # set explicitly
+```
+
+After the script finishes:
 
 ```sh
-# Bump versions in Cargo.toml workspace.package, package.json, src-tauri/tauri.conf.json,
-# update CHANGELOG.md, then:
+git diff                                  # sanity check
+git commit -am "chore: release v0.1.1"
 git tag v0.1.1
-git push --tags
-# Then create the GitHub Release manually; tauri-action will not fire on bare tag pushes
-# in the current setup — only on releases created by release-please.
+git push --follow-tags
 ```
 
-If you want manual tag-triggered builds, switch the `release.yml` `build` job's trigger to `on: push: tags: ['v*']` and remove the `needs: release-please` gate.
+The release workflow takes ~10–15 minutes per OS.
+
+### Versioning rules of thumb
+
+We're pre-1.0, so:
+
+- **Breaking change** (IPC contract, profile JSON shape, persistence format): minor bump.
+- **New feature, bug fix, performance improvement**: patch bump.
+- Once we hit 1.0, switch to standard SemVer.
 
 ## Reporting bugs
 

.release-please-manifest.json

@@ -7,7 +7,8 @@
     "dev": "vite",
     "build": "tsc -b && vite build",
     "preview": "vite preview",
-    "tauri": "tauri"
+    "tauri": "tauri",
+    "release": "node scripts/bump-version.mjs"
   },
   "dependencies": {
     "@monaco-editor/react": "^4.7.0",

CONTRIBUTING.md

@@ -0,0 +1,84 @@
+#!/usr/bin/env node
+// Bump version across every file that needs to stay in lockstep:
+//   - package.json
+//   - src-tauri/tauri.conf.json
+//   - src-tauri/Cargo.toml + crates/*/Cargo.toml ([package].version)
+//   - Cargo.lock (regenerated via `cargo update -w`)
+//
+// Usage: node scripts/bump-version.mjs <patch|minor|major|x.y.z>
+//
+// After this script, review the diff, commit with `chore: release vX.Y.Z`,
+// then `git tag vX.Y.Z && git push --follow-tags` to kick off the release
+// workflow.
+
+import { readFileSync, writeFileSync } from "node:fs";
+import { execSync } from "node:child_process";
+import { resolve, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const repoRoot = resolve(__dirname, "..");
+
+const arg = process.argv[2];
+if (!arg) {
+  console.error("usage: bump-version.mjs <patch|minor|major|x.y.z>");
+  process.exit(1);
+}
+
+const pkg = JSON.parse(readFileSync(resolve(repoRoot, "package.json"), "utf8"));
+const current = pkg.version;
+const next = computeNext(current, arg);
+
+console.log(`${current} -> ${next}`);
+
+const cargoTomls = [
+  "src-tauri/Cargo.toml",
+  "crates/pg-core/Cargo.toml",
+  "crates/pg-intellisense/Cargo.toml",
+  "crates/pg-schema-cache/Cargo.toml",
+  "crates/pg-profiles/Cargo.toml",
+];
+
+for (const path of cargoTomls) {
+  const full = resolve(repoRoot, path);
+  const content = readFileSync(full, "utf8");
+  const updated = content.replace(
+    /^version\s*=\s*"[^"]+"/m,
+    `version = "${next}"`,
+  );
+  if (updated === content) {
+    console.error(`[!] no [package].version line found in ${path}`);
+    process.exit(1);
+  }
+  writeFileSync(full, updated);
+}
+
+pkg.version = next;
+writeFileSync(
+  resolve(repoRoot, "package.json"),
+  JSON.stringify(pkg, null, 2) + "\n",
+);
+
+const tauriConfPath = resolve(repoRoot, "src-tauri/tauri.conf.json");
+const tauriConf = JSON.parse(readFileSync(tauriConfPath, "utf8"));
+tauriConf.version = next;
+writeFileSync(tauriConfPath, JSON.stringify(tauriConf, null, 2) + "\n");
+
+console.log("regenerating Cargo.lock...");
+execSync("cargo update -w", { cwd: repoRoot, stdio: "inherit" });
+
+console.log("");
+console.log(`done. Review the diff, then:`);
+console.log(`  git commit -am "chore: release v${next}"`);
+console.log(`  git tag v${next}`);
+console.log(`  git push --follow-tags`);
+
+function computeNext(curr, bump) {
+  if (/^\d+\.\d+\.\d+/.test(bump)) return bump;
+  const [maj, min, pat] = curr.split(".").map(Number);
+  if (bump === "patch") return `${maj}.${min}.${pat + 1}`;
+  if (bump === "minor") return `${maj}.${min + 1}.0`;
+  if (bump === "major") return `${maj + 1}.0.0`;
+  console.error(`unknown bump: ${bump}`);
+  process.exit(1);
+}