@delorenj/pjangler 1.1.4 → 1.1.5

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 "$@"

package/dist/index.js

@@ -1447,7 +1447,8 @@ function systemctlUser(args) {
   };
 }
 function templateVersioningScript(ctx) {
-  return readText(join6(ctx.pjanglerRoot, ".mise", "scripts", "versioning.sh"));
+  const source = join6(ctx.pjanglerRoot, ".mise", "scripts", "versioning.sh");
+  return existsSync5(source) ? readText(source) : void 0;
 }
 function templateVersionFilesConf(ctx, repoRoot) {
   const packageJson = join6(repoRoot, "package.json");
@@ -1834,6 +1835,9 @@ var RULES = [
       }
       const versioningPath = join6(ctx.repoRoot, ".mise", "scripts", "versioning.sh");
       const expectedScript = templateVersioningScript(ctx);
+      if (expectedScript === void 0) {
+        return { id: finding.id, title: finding.title, status: "blocked", summary: "pjangler install is missing .mise/scripts/versioning.sh \u2014 update @delorenj/pjangler (broken package)", changedFiles, details: [] };
+      }
       if (safeReadText(versioningPath) !== expectedScript) {
         changedFiles.push(versioningPath);
         if (!ctx.dryRun) {
@@ -2328,7 +2332,20 @@ function runMigration(selector, repoArg, dryRun, all) {
   if (!selected.length) {
     throw new Error(`Unknown parity rule: ${selector}`);
   }
-  const results = selected.map((rule) => rule.migrate(ctx, rule.audit(ctx)));
+  const results = selected.map((rule) => {
+    try {
+      return rule.migrate(ctx, rule.audit(ctx));
+    } catch (err) {
+      return {
+        id: rule.id,
+        title: rule.title,
+        status: "blocked",
+        summary: `migrate threw: ${err instanceof Error ? err.message : String(err)}`,
+        changedFiles: [],
+        details: []
+      };
+    }
+  });
   const changedFiles = Array.from(new Set(results.flatMap((result) => result.changedFiles))).sort();
   return {
     repo: ctx.repoRoot,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@delorenj/pjangler",
-  "version": "1.1.4",
+  "version": "1.1.5",
   "description": "Project subsystem bootstrapper CLI",
   "type": "module",
   "main": "dist/index.js",
@@ -11,7 +11,8 @@
   },
   "files": [
     "dist",
-    "templates"
+    "templates",
+    ".mise/scripts/versioning.sh"
   ],
   "engines": {
     "node": ">=20"