chore(release): v1.0.3

.gitignore

@@ -1,2 +1,4 @@
 .pre-commit-config.yaml
 .direnv
+result
+template/flake.lock

README.md

@@ -0,0 +1,72 @@
+# repo-lib
+
+Simple Nix flake library for:
+
+- a shared development shell (`mkDevShell`)
+- an optional release command (`mkRelease`)
+- a starter template (`template/`)
+
+## Prerequisites
+
+- [Nix](https://nixos.org/download/) with flakes enabled
+- [`direnv`](https://direnv.net/) (recommended)
+
+## Use the template (new repo)
+
+From your new project folder:
+
+```bash
+nix flake new myapp -t 'git+https://git.dgren.dev/eric/nix-flake-lib?ref=v1.0.3#default' --refresh
+```
+
+## Use the library (existing repo)
+
+Add this flake input:
+
+```nix
+inputs.devshell-lib.url = "git+https://git.dgren.dev/eric/nix-flake-lib?ref=v1.0.3";
+inputs.devshell-lib.inputs.nixpkgs.follows = "nixpkgs";
+```
+
+Create your shell from `mkDevShell`:
+
+```nix
+env = devshell-lib.lib.mkDevShell {
+  inherit system;
+  extraPackages = [ ];
+  tools = [ ];
+  additionalHooks = { };
+};
+```
+
+Expose it in `devShells` as `default` and run:
+
+```bash
+nix develop
+```
+
+## Common commands
+
+```bash
+nix fmt           # format files
+```
+
+## Optional: release command
+
+If your flake defines:
+
+```nix
+packages.${system}.release = devshell-lib.lib.mkRelease { inherit system; };
+```
+
+Run releases with:
+
+```bash
+release
+release patch
+release minor beta
+release stable
+release set 1.2.3
+```
+
+The release script uses `./VERSION` as the source of truth and creates tags like `v1.2.3`.

VERSION

@@ -0,0 +1,3 @@
+1.0.3
+stable
+0

flake.nix

@@ -95,6 +95,11 @@
               // additionalHooks;
             };
 
+            toolNameWidth = builtins.foldl' (
+              maxWidth: t: pkgs.lib.max maxWidth (builtins.stringLength t.name)
+            ) 0 tools;
+            toolLabelWidth = toolNameWidth + 1;
+
             toolBannerScript = pkgs.lib.concatMapStrings (
               t:
               let
@@ -102,7 +107,8 @@
               in
               ''
                 if command -v ${t.bin} >/dev/null 2>&1; then
-                  printf "  $CYAN ${t.name}:$RESET\t${colorVar}%s$RESET\n" "$(${t.bin} ${t.versionCmd})"
+                  version="$(${t.bin} ${t.versionCmd} 2>/dev/null | head -n 1 | sed -E 's/^[[:space:]]+//; s/[[:space:]]+$//')"
+                  printf "  $CYAN %-${toString toolLabelWidth}s$RESET ${colorVar}%s$RESET\n" "${t.name}:" "$version"
                 fi
               ''
             ) tools;
@@ -122,13 +128,19 @@
                 ${pre-commit-check.shellHook}
 
                 if [ -t 1 ]; then
-                  # command -v tput >/dev/null 2>&1 && tput clear || printf '\033c'
+                  command -v tput >/dev/null 2>&1 && tput clear || printf '\033c'
                 fi
 
                 GREEN='\033[1;32m'
                 CYAN='\033[1;36m'
                 YELLOW='\033[1;33m'
                 BLUE='\033[1;34m'
+                RED='\033[1;31m'
+                MAGENTA='\033[1;35m'
+                WHITE='\033[1;37m'
+                GRAY='\033[0;90m'
+                BOLD='\033[1m'
+                UNDERLINE='\033[4m'
                 RESET='\033[0m'
 
                 printf "\n$GREEN 🚀 Dev shell ready$RESET\n\n"
@@ -144,36 +156,39 @@
         mkRelease =
           {
             system,
-            readVersion,
+            # Source of truth is always $ROOT_DIR/VERSION.
-            # Shell string — must print current version to stdout: "x.y.z" or "x.y.z-channel.N"
+            # Format:
-            # Example:
+            #   line 1: X.Y.Z
-            #   readVersion = ''cat "$ROOT_DIR/VERSION"'';
+            #   line 2: CHANNEL (stable|alpha|beta|rc|internal|...)
-            writeVersion,
+            #   line 3: N (prerelease number, 0 for stable)
-            # Shell string — env vars available: BASE_VERSION, CHANNEL, PRERELEASE_NUM, FULL_VERSION
-            # Example:
-            #   writeVersion = ''echo "$FULL_VERSION" > "$ROOT_DIR/VERSION"'';
             postVersion ? "",
-            # Shell string — runs after writeVersion and versionFiles, before git add.
+            # Shell string — runs after VERSION + release steps are written/run, before git add.
             # Same env vars available.
-            versionFiles ? [ ],
+            release ? [ ],
-            # List of { path, template } attrsets.
+            # Unified list processed in declaration order:
-            # template is a Nix function: version -> string
+            #   { file = "path/to/file"; content = ''...$FULL_VERSION...''; }  # write file
-            # The content is fully rendered by Nix at eval time — no shell interpolation needed.
+            #   { run = ''...shell snippet...''; }                               # run script
             # Example:
-            #   versionFiles = [
+            #   release = [
             #     {
-            #       path = "src/version.ts";
+            #       file = "src/version.ts";
-            #       template = version: ''export const APP_VERSION = "${version}" as const;'';
+            #       content = ''export const APP_VERSION = "$FULL_VERSION" as const;'';
             #     }
             #     {
-            #       path = "internal/version/version.go";
+            #       file = "internal/version/version.go";
-            #       template = version: ''
+            #       content = ''
             #         package version
             #
-            #         const Version = "${version}"
+            #         const Version = "$FULL_VERSION"
+            #       '';
+            #     }
+            #     {
+            #       run = ''
+            #         sed -E -i "s#^([[:space:]]*my-lib\\.url = \")github:org/my-lib[^"]*(\";)#\\1github:org/my-lib?ref=$FULL_TAG\\2#" "$ROOT_DIR/flake.nix"
             #       '';
             #     }
             #   ];
+            # Runtime env includes: BASE_VERSION, CHANNEL, PRERELEASE_NUM, FULL_VERSION, FULL_TAG.
             channels ? [
               "alpha"
               "beta"
@@ -188,39 +203,34 @@
             pkgs = import nixpkgs { inherit system; };
             channelList = pkgs.lib.concatStringsSep " " channels;
 
-            # Version files are fully rendered by Nix at eval time.
+            releaseStepsScript = pkgs.lib.concatMapStrings (
-            # The shell only writes the pre-computed strings — no shell interpolation in templates.
+              entry:
-            versionFilesScript = pkgs.lib.concatMapStrings (
+              if entry ? file then
-              f:
-              let
-                # We can't call f.template here since FULL_VERSION is a runtime value.
-                # Instead we pass the path and use a shell heredoc with the template
-                # rendered at runtime via the VERSION env vars.
-                renderedContent = f.template "$FULL_VERSION";
-              in
                 ''
-                mkdir -p "$(dirname "${f.path}")"
+                  mkdir -p "$(dirname "${entry.file}")"
-                cat > "${f.path}" << 'NIXEOF'
+                  cat > "${entry.file}" << NIXEOF
-                ${renderedContent}
+                  ${entry.content}
                   NIXEOF
-                log "Generated version file: ${f.path}"
+                  log "Generated version file: ${entry.file}"
                 ''
-            ) versionFiles;
+              else if entry ? run then
+                ''
+                  ${entry.run}
+                ''
+              else
+                builtins.throw "release entry must have either 'file' or 'run'"
+            ) release;
 
             script =
               builtins.replaceStrings
                 [
                   "__CHANNEL_LIST__"
-                  "__VERSION_FILES__"
+                  "__RELEASE_STEPS__"
-                  "__READ_VERSION__"
-                  "__WRITE_VERSION__"
                   "__POST_VERSION__"
                 ]
                 [
                   channelList
-                  versionFilesScript
+                  releaseStepsScript
-                  readVersion
-                  writeVersion
                   postVersion
                 ]
                 (builtins.readFile ./packages/release/release.sh);
@@ -243,20 +253,24 @@
       };
 
       # ── packages ────────────────────────────────────────────────────────────
-      packages = forAllSystems (
+      packages = forAllSystems (system: {
-        system:
-        let
-          pkgs = import nixpkgs { inherit system; };
-        in
-        {
         # Expose a no-op release package for the lib repo itself (dogfood)
         release = self.lib.mkRelease {
           inherit system;
-            readVersion = ''cat "$ROOT_DIR/VERSION"'';
+          release = [
-            writeVersion = ''echo "$FULL_VERSION" > "$ROOT_DIR/VERSION"'';
+            {
-          };
+              run = ''
+                sed -E -i "s#^([[:space:]]*devshell-lib\\.url = \")git\\+https://git\\.dgren\\.dev/eric/nix-flake-lib[^\"]*(\";)#\\1git+https://git.dgren.dev/eric/nix-flake-lib?ref=$FULL_TAG\\2#" "$ROOT_DIR/template/flake.nix"
+                log "Updated template/flake.nix devshell-lib ref to $FULL_TAG"
+
+                sed -E -i "s|(nix flake new myapp -t ')git\\+https://git\\.dgren\\.dev/eric/nix-flake-lib[^']*(#default' --refresh)|\\1git+https://git.dgren.dev/eric/nix-flake-lib?ref=$FULL_TAG\\2|" "$ROOT_DIR/README.md"
+                sed -E -i "s#^([[:space:]]*inputs\\.devshell-lib\\.url = \")git\\+https://git\\.dgren\\.dev/eric/nix-flake-lib[^\"]*(\";)#\\1git+https://git.dgren.dev/eric/nix-flake-lib?ref=$FULL_TAG\\2#" "$ROOT_DIR/README.md"
+                log "Updated README.md devshell-lib refs to $FULL_TAG"
+              '';
             }
-      );
+          ];
+        };
+      });
 
       # ── devShells ───────────────────────────────────────────────────────────
       devShells = forAllSystems (

packages/release/release.nix

@@ -1,10 +1,11 @@
 # release.nix
 {
   pkgs,
-  readVersion,
-  writeVersion,
   postVersion ? "",
-  versionFiles ? [ ],
+  release ? [ ],
+  # Unified list, processed in declaration order:
+  #   { file = "path/to/file"; content = "..."; }   — write file
+  #   { run = "shell snippet..."; }                  — run script
   channels ? [
     "alpha"
     "beta"
@@ -16,28 +17,28 @@
 let
   channelList = pkgs.lib.concatStringsSep " " channels;
 
-  versionFilesScript = pkgs.lib.concatMapStrings (f: ''
+  releaseScript = pkgs.lib.concatMapStrings (
-    mkdir -p "$(dirname "${f.path}")"
+    entry:
-    ${f.content} > "${f.path}"
+    if entry ? file then
-    log "Generated version file: ${f.path}"
+      ''
-  '') versionFiles;
+        mkdir -p "$(dirname "${entry.file}")"
+        cat > "${entry.file}" << NIXEOF
+        ${entry.content}
+        NIXEOF
+        log "Generated version file: ${entry.file}"
+      ''
+    else if entry ? run then
+      ''
+        ${entry.run}
+      ''
+    else
+      builtins.throw "release entry must have either 'file' or 'run'"
+  ) release;
 
   script =
     builtins.replaceStrings
-      [
+      [ "__CHANNEL_LIST__" "__RELEASE_STEPS__" "__POST_VERSION__" ]
-        "__CHANNEL_LIST__"
+      [ channelList releaseScript postVersion ]
-        "__VERSION_FILES__"
-        "__READ_VERSION__"
-        "__WRITE_VERSION__"
-        "__POST_VERSION__"
-      ]
-      [
-        channelList
-        versionFilesScript
-        readVersion
-        writeVersion
-        postVersion
-      ]
       (builtins.readFile ./release.sh);
 in
 pkgs.writeShellApplication {

packages/release/release.sh

@@ -9,7 +9,7 @@ CREATED_TAG=""
 
 # ── logging ────────────────────────────────────────────────────────────────
 
-log() { echo "[release] $*"; }
+log() { echo "[release] $*" >&2; }
 
 usage() {
 	local cmd
@@ -159,7 +159,8 @@ compute_full_version() {
 	else
 		FULL_VERSION="${BASE_VERSION}-${CHANNEL}.${PRERELEASE_NUM:-1}"
 	fi
-  export BASE_VERSION CHANNEL PRERELEASE_NUM FULL_VERSION
+	FULL_TAG="v$FULL_VERSION"
+	export BASE_VERSION CHANNEL PRERELEASE_NUM FULL_VERSION FULL_TAG
 }
 
 # ── gitlint ────────────────────────────────────────────────────────────────
@@ -187,23 +188,75 @@ validate_commit_message() {
 
 # ── version file generation ────────────────────────────────────────────────
 
-generate_version_files() {
+run_release_steps() {
 	:
-  __VERSION_FILES__
+	__RELEASE_STEPS__
 }
 
-# ── user-provided hooks ────────────────────────────────────────────────────
+# ── version source (built-in) ──────────────────────────────────────────────
+
+# Initializes $ROOT_DIR/VERSION from git tags if it doesn't exist.
+# Must be called outside of any subshell so log output stays on stderr
+# and never contaminates the stdout of do_read_version.
+init_version_file() {
+	if [[ -f "$ROOT_DIR/VERSION" ]]; then
+		return 0
+	fi
+
+	local highest_tag=""
+	while IFS= read -r raw_tag; do
+		local tag="${raw_tag#v}"
+		[[ $tag =~ ^[0-9]+\.[0-9]+\.[0-9]+(-[a-zA-Z]+\.[0-9]+)?$ ]] || continue
+
+		if [[ -z $highest_tag ]]; then
+			highest_tag="$tag"
+			continue
+		fi
+
+		local cmp_status=0
+		version_cmp "$tag" "$highest_tag" || cmp_status=$?
+		[[ $cmp_status -eq 1 ]] && highest_tag="$tag"
+	done < <(git tag --list)
+
+	[[ -z $highest_tag ]] && highest_tag="0.0.1"
+
+	parse_full_version "$highest_tag"
+	local channel_to_write="$CHANNEL"
+	local n_to_write="${PRERELEASE_NUM:-1}"
+	if [[ $channel_to_write == "stable" || -z $channel_to_write ]]; then
+		channel_to_write="stable"
+		n_to_write="0"
+	fi
+
+	printf '%s\n%s\n%s\n' "$BASE_VERSION" "$channel_to_write" "$n_to_write" >"$ROOT_DIR/VERSION"
+	log "Initialized $ROOT_DIR/VERSION from highest tag: v$highest_tag"
+}
 
 do_read_version() {
-  :
+	local base_line channel_line n_line
-  __READ_VERSION__
+	base_line="$(sed -n '1p' "$ROOT_DIR/VERSION" | tr -d '\r')"
+	channel_line="$(sed -n '2p' "$ROOT_DIR/VERSION" | tr -d '\r')"
+	n_line="$(sed -n '3p' "$ROOT_DIR/VERSION" | tr -d '\r')"
+
+	if [[ -z $channel_line || $channel_line == "stable" ]]; then
+		printf '%s\n' "$base_line"
+	else
+		printf '%s-%s.%s\n' "$base_line" "$channel_line" "$n_line"
+	fi
 }
 
 do_write_version() {
-  :
+	local channel_to_write="$CHANNEL"
-  __WRITE_VERSION__
+	local n_to_write="${PRERELEASE_NUM:-1}"
+	if [[ $channel_to_write == "stable" || -z $channel_to_write ]]; then
+		channel_to_write="stable"
+		n_to_write="0"
+	fi
+	printf '%s\n%s\n%s\n' "$BASE_VERSION" "$channel_to_write" "$n_to_write" >"$ROOT_DIR/VERSION"
 }
 
+# ── user-provided hook ─────────────────────────────────────────────────────
+
 do_post_version() {
 	:
 	__POST_VERSION__
@@ -218,8 +271,16 @@ main() {
 	START_HEAD="$(git rev-parse HEAD)"
 	trap revert_on_failure ERR
 
+	# Initialize VERSION file outside any subshell so log lines never
+	# bleed into the stdout capture below.
+	init_version_file
+
 	local raw_version
-  raw_version="$(do_read_version)"
+	raw_version="$(do_read_version | grep -E '^[0-9]+\.[0-9]+\.[0-9]+(-[a-zA-Z]+\.[0-9]+)?$' | tail -n1)"
+	if [[ -z $raw_version ]]; then
+		echo "Error: could not determine current version from VERSION source" >&2
+		exit 1
+	fi
 	parse_full_version "$raw_version"
 
 	log "Current: base=$BASE_VERSION channel=$CHANNEL pre=${PRERELEASE_NUM:-}"
@@ -304,7 +365,8 @@ main() {
 	do_write_version
 	log "Updated version source"
 
-  generate_version_files
+	run_release_steps
+	log "Release steps done"
 
 	do_post_version
 	log "Post-version hook done"
@@ -318,13 +380,13 @@ main() {
 	git commit -m "$commit_msg"
 	log "Created commit"
 
-  git tag "v$FULL_VERSION"
+	git tag "$FULL_TAG"
-  CREATED_TAG="v$FULL_VERSION"
+	CREATED_TAG="$FULL_TAG"
-  log "Tagged v$FULL_VERSION"
+	log "Tagged $FULL_TAG"
 
 	git push
 	git push --tags
-  log "Done — released v$FULL_VERSION"
+	log "Done — released $FULL_TAG"
 
 	trap - ERR
 }

result

@@ -1 +0,0 @@
-/nix/store/acl2f263ncy3zfy38cipk2idmqnnvp9x-release

template/.vscode/settings.json

@@ -0,0 +1,10 @@
+{
+  "files.exclude": {
+    "**/.git": true,
+    "**/.svn": true,
+    "**/.hg": true,
+    "**/.DS_Store": true,
+    "**/Thumbs.db": true,
+    "VERSION": true
+  }
+}

template/flake.lock

@@ -0,0 +1,159 @@
+{
+  "nodes": {
+    "devshell-lib": {
+      "inputs": {
+        "git-hooks": "git-hooks",
+        "nixpkgs": [
+          "nixpkgs"
+        ],
+        "treefmt-nix": "treefmt-nix"
+      },
+      "locked": {
+        "lastModified": 1772603902,
+        "narHash": "sha256-GN5EC9m0flWDuc6qaB6QoIBD73yFnhl2PBIYXzSTGeQ=",
+        "ref": "v0.0.2",
+        "rev": "db4ed150e01e2f9245e668077245447d0089163f",
+        "revCount": 15,
+        "type": "git",
+        "url": "https://git.dgren.dev/eric/nix-flake-lib"
+      },
+      "original": {
+        "ref": "v0.0.2",
+        "type": "git",
+        "url": "https://git.dgren.dev/eric/nix-flake-lib"
+      }
+    },
+    "flake-compat": {
+      "flake": false,
+      "locked": {
+        "lastModified": 1767039857,
+        "narHash": "sha256-vNpUSpF5Nuw8xvDLj2KCwwksIbjua2LZCqhV1LNRDns=",
+        "owner": "NixOS",
+        "repo": "flake-compat",
+        "rev": "5edf11c44bc78a0d334f6334cdaf7d60d732daab",
+        "type": "github"
+      },
+      "original": {
+        "owner": "NixOS",
+        "repo": "flake-compat",
+        "type": "github"
+      }
+    },
+    "git-hooks": {
+      "inputs": {
+        "flake-compat": "flake-compat",
+        "gitignore": "gitignore",
+        "nixpkgs": "nixpkgs"
+      },
+      "locked": {
+        "lastModified": 1772024342,
+        "narHash": "sha256-+eXlIc4/7dE6EcPs9a2DaSY3fTA9AE526hGqkNID3Wg=",
+        "owner": "cachix",
+        "repo": "git-hooks.nix",
+        "rev": "6e34e97ed9788b17796ee43ccdbaf871a5c2b476",
+        "type": "github"
+      },
+      "original": {
+        "owner": "cachix",
+        "repo": "git-hooks.nix",
+        "type": "github"
+      }
+    },
+    "gitignore": {
+      "inputs": {
+        "nixpkgs": [
+          "devshell-lib",
+          "git-hooks",
+          "nixpkgs"
+        ]
+      },
+      "locked": {
+        "lastModified": 1709087332,
+        "narHash": "sha256-HG2cCnktfHsKV0s4XW83gU3F57gaTljL9KNSuG6bnQs=",
+        "owner": "hercules-ci",
+        "repo": "gitignore.nix",
+        "rev": "637db329424fd7e46cf4185293b9cc8c88c95394",
+        "type": "github"
+      },
+      "original": {
+        "owner": "hercules-ci",
+        "repo": "gitignore.nix",
+        "type": "github"
+      }
+    },
+    "nixpkgs": {
+      "locked": {
+        "lastModified": 1770073757,
+        "narHash": "sha256-Vy+G+F+3E/Tl+GMNgiHl9Pah2DgShmIUBJXmbiQPHbI=",
+        "owner": "NixOS",
+        "repo": "nixpkgs",
+        "rev": "47472570b1e607482890801aeaf29bfb749884f6",
+        "type": "github"
+      },
+      "original": {
+        "owner": "NixOS",
+        "ref": "nixpkgs-unstable",
+        "repo": "nixpkgs",
+        "type": "github"
+      }
+    },
+    "nixpkgs_2": {
+      "locked": {
+        "lastModified": 1770107345,
+        "narHash": "sha256-tbS0Ebx2PiA1FRW8mt8oejR0qMXmziJmPaU1d4kYY9g=",
+        "owner": "nixos",
+        "repo": "nixpkgs",
+        "rev": "4533d9293756b63904b7238acb84ac8fe4c8c2c4",
+        "type": "github"
+      },
+      "original": {
+        "owner": "nixos",
+        "ref": "nixpkgs-unstable",
+        "repo": "nixpkgs",
+        "type": "github"
+      }
+    },
+    "nixpkgs_3": {
+      "locked": {
+        "lastModified": 1772542754,
+        "narHash": "sha256-WGV2hy+VIeQsYXpsLjdr4GvHv5eECMISX1zKLTedhdg=",
+        "owner": "nixos",
+        "repo": "nixpkgs",
+        "rev": "8c809a146a140c5c8806f13399592dbcb1bb5dc4",
+        "type": "github"
+      },
+      "original": {
+        "owner": "nixos",
+        "ref": "nixos-unstable",
+        "repo": "nixpkgs",
+        "type": "github"
+      }
+    },
+    "root": {
+      "inputs": {
+        "devshell-lib": "devshell-lib",
+        "nixpkgs": "nixpkgs_3"
+      }
+    },
+    "treefmt-nix": {
+      "inputs": {
+        "nixpkgs": "nixpkgs_2"
+      },
+      "locked": {
+        "lastModified": 1770228511,
+        "narHash": "sha256-wQ6NJSuFqAEmIg2VMnLdCnUc0b7vslUohqqGGD+Fyxk=",
+        "owner": "numtide",
+        "repo": "treefmt-nix",
+        "rev": "337a4fe074be1042a35086f15481d763b8ddc0e7",
+        "type": "github"
+      },
+      "original": {
+        "owner": "numtide",
+        "repo": "treefmt-nix",
+        "type": "github"
+      }
+    }
+  },
+  "root": "root",
+  "version": 7
+}

template/flake.nix

@@ -4,7 +4,7 @@
 
   inputs = {
     nixpkgs.url = "github:nixos/nixpkgs?ref=nixos-unstable";
-    devshell-lib.url = "github:yourorg/devshell-lib";
+    devshell-lib.url = "git+https://git.dgren.dev/eric/nix-flake-lib?ref=v1.0.3";
     devshell-lib.inputs.nixpkgs.follows = "nixpkgs";
   };
 
@@ -96,5 +96,50 @@
       );
 
       formatter = forAllSystems (system: (devshell-lib.lib.mkDevShell { inherit system; }).formatter);
+
+      # Optional: release command (`release`)
+      #
+      # The release script always updates VERSION first, then:
+      #   1) runs release steps in order (file writes and scripts)
+      #   2) runs postVersion hook
+      #   3) formats, stages, commits, tags, and pushes
+      #
+      # Runtime env vars available in release.run/postVersion:
+      #   BASE_VERSION, CHANNEL, PRERELEASE_NUM, FULL_VERSION, FULL_TAG
+      #
+      # packages = forAllSystems (
+      #   system:
+      #   {
+      #     release = devshell-lib.lib.mkRelease {
+      #       inherit system;
+      #
+      #       release = [
+      #         {
+      #           file = "src/version.ts";
+      #           content = ''
+      #             export const APP_VERSION = "$FULL_VERSION" as const;
+      #           '';
+      #         }
+      #         {
+      #           file = "internal/version/version.go";
+      #           content = ''
+      #             package version
+      #
+      #             const Version = "$FULL_VERSION"
+      #           '';
+      #         }
+      #         {
+      #           run = ''
+      #             sed -E -i "s#^([[:space:]]*my-lib\\.url = \")github:org/my-lib[^"]*(\";)#\\1github:org/my-lib?ref=$FULL_TAG\\2#" "$ROOT_DIR/flake.nix"
+      #           '';
+      #         }
+      #       ];
+      #
+      #       postVersion = ''
+      #         echo "Released $FULL_TAG"
+      #       '';
+      #     };
+      #   }
+      # );
     };
 }