@delorenj/pjangler 1.1.4 → 1.2.1

package/.mise/scripts/link-agentfiles.sh

@@ -0,0 +1,9 @@
+#!/bin/bash
+
+if [ -f AGENTS.md ]; then
+  ln -sf AGENTS.md CLAUDE.md
+  ln -sf AGENTS.md GEMINI.md
+  echo "✅ AI agent symlinks verified"
+else
+  echo "No AGENTS.md file found. Can't symlink."
+fi

package/.mise/scripts/versioning.sh

@@ -0,0 +1,236 @@
+#!/usr/bin/env bash
+# versioning.sh — single source of all repo versioning logic.
+#
+# Installed by the `mise-versioning` skill. All version read/write/bump logic
+# lives here; mise tasks are thin wrappers that call into it.
+#
+# Canonical version = the HIGHEST semver across every file in the manifest.
+# All manifest files are kept in parity on every write (bump / set / sync).
+#
+# Usage:
+#   versioning.sh current              Print canonical version as vX.Y.Z
+#   versioning.sh bump <patch|minor|major>
+#   versioning.sh set <X.Y.Z|vX.Y.Z>   Force all files to an explicit version
+#   versioning.sh check                Exit 0 if all files in parity, else list drift
+#   versioning.sh sync                 Force every file up to the canonical (highest) version
+#   versioning.sh files                List the manifest
+#
+# Manifest: .mise/version-files.conf  — lines of "<type> <path>" (see file-types).
+#   types: json toml cargo csproj gradle plain gittag
+#
+# Storage format per type:
+#   json/toml/cargo/csproj/gradle/plain -> bare  "X.Y.Z"
+#   gittag                              -> tag   "vX.Y.Z"
+# `current` always prints with the leading "v".
+
+set -euo pipefail
+
+REPO_ROOT="$(git rev-parse --show-toplevel 2>/dev/null || pwd)"
+MANIFEST="${VERSION_FILES_CONF:-$REPO_ROOT/.mise/version-files.conf}"
+
+die() { printf 'versioning: %s\n' "$1" >&2; exit 1; }
+
+# Friendly display path for a manifest entry.
+rel() {  # $1=type $2=abspath
+  [[ "$1" == gittag ]] && { printf '(git tags)'; return; }
+  local p="${2#"$REPO_ROOT"/}"; printf '%s' "${p:-$2}"
+}
+
+# ---- semver helpers ---------------------------------------------------------
+
+# Strip a leading v/V and surrounding whitespace; validate X.Y.Z.
+normalize() {
+  local v="${1#[vV]}"
+  v="$(printf '%s' "$v" | tr -d '[:space:]')"
+  [[ "$v" =~ ^[0-9]+\.[0-9]+\.[0-9]+$ ]] || return 1
+  printf '%s' "$v"
+}
+
+# Return 0 if $1 > $2 (strict), comparing X.Y.Z numerically.
+semver_gt() {
+  local a b
+  IFS=. read -r a1 a2 a3 <<<"$1"
+  IFS=. read -r b1 b2 b3 <<<"$2"
+  ((a1 != b1)) && { ((a1 > b1)); return; }
+  ((a2 != b2)) && { ((a2 > b2)); return; }
+  ((a3 > b3))
+}
+
+bump_semver() {
+  local ver="$1" part="$2" x y z
+  IFS=. read -r x y z <<<"$ver"
+  case "$part" in
+    major) x=$((x + 1)); y=0; z=0 ;;
+    minor) y=$((y + 1)); z=0 ;;
+    patch) z=$((z + 1)) ;;
+    *) die "unknown bump part: $part (expected patch|minor|major)" ;;
+  esac
+  printf '%s.%s.%s' "$x" "$y" "$z"
+}
+
+# ---- manifest ---------------------------------------------------------------
+
+[[ -f "$MANIFEST" ]] || die "manifest not found: $MANIFEST (run the mise-versioning init)"
+
+# Emits "type<TAB>abspath" per manifest line, skipping blanks/comments.
+manifest_entries() {
+  while read -r type path _rest; do
+    [[ -z "${type:-}" || "$type" == \#* ]] && continue
+    case "$path" in
+      /*) : ;;
+      .|"") path="$REPO_ROOT" ;;
+      *) path="$REPO_ROOT/$path" ;;
+    esac
+    printf '%s\t%s\n' "$type" "$path"
+  done <"$MANIFEST"
+}
+
+# ---- per-type read -----------------------------------------------------------
+
+read_version() {  # $1=type $2=path -> bare X.Y.Z on stdout, or nothing
+  local type="$1" path="$2" raw=""
+  case "$type" in
+    json)
+      [[ -f "$path" ]] || return 0
+      raw="$(jq -r '.version // empty' "$path" 2>/dev/null || true)" ;;
+    toml|cargo)
+      [[ -f "$path" ]] || return 0
+      raw="$(grep -m1 -E '^version[[:space:]]*=' "$path" 2>/dev/null \
+             | sed -E 's/^version[[:space:]]*=[[:space:]]*["'\'']?([^"'\'' ]+).*/\1/' || true)" ;;
+    csproj)
+      [[ -f "$path" ]] || return 0
+      raw="$(grep -m1 -oE '<Version>[^<]+</Version>' "$path" 2>/dev/null \
+             | sed -E 's#</?Version>##g' || true)" ;;
+    gradle)
+      [[ -f "$path" ]] || return 0
+      raw="$(grep -m1 -E '^[[:space:]]*version[[:space:]]*[=]?[[:space:]]*["'\'']' "$path" 2>/dev/null \
+             | sed -E 's/.*["'\'']([0-9]+\.[0-9]+\.[0-9]+)["'\''].*/\1/' || true)" ;;
+    plain)
+      [[ -f "$path" ]] || return 0
+      raw="$(head -n1 "$path" 2>/dev/null || true)" ;;
+    gittag)
+      raw="$(git -C "$REPO_ROOT" tag --list 'v[0-9]*' --sort=-v:refname 2>/dev/null | head -n1 || true)" ;;
+    *) die "unknown manifest type: $type" ;;
+  esac
+  [[ -z "$raw" ]] && return 0
+  normalize "$raw" 2>/dev/null || return 0
+}
+
+# ---- per-type write ----------------------------------------------------------
+
+write_version() {  # $1=type $2=path $3=bare-new-version
+  local type="$1" path="$2" new="$3" tmp
+  case "$type" in
+    json)
+      [[ -f "$path" ]] || return 0
+      tmp="$(mktemp)"
+      jq --indent 2 --arg v "$new" '.version = $v' "$path" >"$tmp" && mv "$tmp" "$path" ;;
+    toml|cargo)
+      [[ -f "$path" ]] || return 0
+      # Replace only the first top-level `version = "..."` line.
+      sed -i -E "0,/^version[[:space:]]*=/{s/^(version[[:space:]]*=[[:space:]]*[\"']?)[^\"' ]+([\"']?)/\1$new\2/}" "$path" ;;
+    csproj)
+      [[ -f "$path" ]] || return 0
+      sed -i -E "0,/<Version>[^<]+<\/Version>/{s#<Version>[^<]+</Version>#<Version>$new</Version>#}" "$path" ;;
+    gradle)
+      [[ -f "$path" ]] || return 0
+      sed -i -E "0,/^[[:space:]]*version[[:space:]]*[=]?[[:space:]]*[\"']/{s/([\"'])[0-9]+\.[0-9]+\.[0-9]+([\"'])/\1$new\2/}" "$path" ;;
+    plain)
+      printf '%s\n' "$new" >"$path" ;;
+    gittag)
+      if git -C "$REPO_ROOT" rev-parse "v$new" >/dev/null 2>&1; then
+        printf 'versioning: git tag v%s already exists, skipping\n' "$new" >&2
+      else
+        git -C "$REPO_ROOT" tag -a "v$new" -m "v$new"
+        printf 'versioning: created git tag v%s\n' "$new" >&2
+      fi ;;
+    *) die "unknown manifest type: $type" ;;
+  esac
+}
+
+# ---- canonical resolution ----------------------------------------------------
+
+canonical() {  # highest version across the manifest -> bare X.Y.Z (empty if none)
+  local best="" v
+  while IFS=$'\t' read -r type path; do
+    v="$(read_version "$type" "$path")" || true
+    [[ -z "$v" ]] && continue
+    if [[ -z "$best" ]] || semver_gt "$v" "$best"; then best="$v"; fi
+  done < <(manifest_entries)
+  printf '%s' "$best"
+}
+
+write_all() {  # $1=bare-new-version : write to every manifest file
+  local new="$1" type path
+  while IFS=$'\t' read -r type path; do
+    write_version "$type" "$path" "$new"
+    printf '  %-7s %s -> %s\n' "$type" "$(rel "$type" "$path")" "$new" >&2
+  done < <(manifest_entries)
+}
+
+# ---- commands ----------------------------------------------------------------
+
+cmd_current() {
+  local v; v="$(canonical)"
+  printf 'v%s\n' "${v:-0.0.0}"
+}
+
+cmd_bump() {
+  local part="${1:-patch}" cur new
+  cur="$(canonical)"; [[ -z "$cur" ]] && cur="0.0.0"
+  new="$(bump_semver "$cur" "$part")"
+  printf 'versioning: %s bump v%s -> v%s\n' "$part" "$cur" "$new" >&2
+  write_all "$new"
+  printf 'v%s\n' "$new"
+}
+
+cmd_set() {
+  local new; new="$(normalize "${1:?usage: set <X.Y.Z>}")" || die "invalid version: $1"
+  printf 'versioning: set -> v%s\n' "$new" >&2
+  write_all "$new"
+  printf 'v%s\n' "$new"
+}
+
+cmd_check() {
+  local canon drift=0 v type path; canon="$(canonical)"
+  [[ -z "$canon" ]] && { echo "versioning: no version found in any manifest file" >&2; return 0; }
+  while IFS=$'\t' read -r type path; do
+    v="$(read_version "$type" "$path")" || true
+    [[ -z "$v" ]] && continue
+    if [[ "$v" != "$canon" ]]; then
+      printf 'DRIFT  %-7s %s = v%s (canonical v%s)\n' "$type" "$(rel "$type" "$path")" "$v" "$canon" >&2
+      drift=1
+    fi
+  done < <(manifest_entries)
+  if ((drift)); then echo "versioning: files out of parity; run 'versioning.sh sync'" >&2; return 1; fi
+  printf 'versioning: all files in parity at v%s\n' "$canon"
+}
+
+cmd_sync() {
+  local canon; canon="$(canonical)"
+  [[ -z "$canon" ]] && die "no version found in any manifest file"
+  printf 'versioning: syncing all files to v%s\n' "$canon" >&2
+  write_all "$canon"
+  printf 'v%s\n' "$canon"
+}
+
+cmd_files() {
+  while IFS=$'\t' read -r type path; do
+    printf '%s\t%s\n' "$type" "$(rel "$type" "$path")"
+  done < <(manifest_entries)
+}
+
+main() {
+  local cmd="${1:-current}"; shift || true
+  case "$cmd" in
+    current|cur) cmd_current ;;
+    bump)        cmd_bump "$@" ;;
+    set)         cmd_set "$@" ;;
+    check)       cmd_check ;;
+    sync)        cmd_sync ;;
+    files)       cmd_files ;;
+    *) die "unknown command: $cmd (current|bump|set|check|sync|files)" ;;
+  esac
+}
+
+main "$@"