@thebassclef/lite 1.0.3 → 1.1.0

package/dist/lite/scripts/generate-lite-manifest.sh

@@ -0,0 +1,505 @@
+#!/usr/bin/env bash
+# tier: lite
+# Generate lite-manifest.json at repo root.
+#
+# Reads tier: lite frontmatter across the 7 substrate surfaces and emits
+# the manifest per standards/lite-manifest.schema.json v1.0.0.
+#
+# Per bassclef-upstream#1020 (partner packaging manifest) + #1030 (root
+# location + generator). Session 2026-08-01d option b — standalone
+# generator; release-script integration deferred per bet doc Out of scope.
+#
+# Cures per pre-mortem risk ledger docs/risk-ledgers/2026-08-01c-lite-manifest.md:
+#   F-b.H1 — resolves repo root via git rev-parse; writes to ${ROOT}/lite-manifest.json
+#   F1.1   — real substrate paths (not synthetic); tests iterate all project surfaces
+#   F1.3   — iterates ALL 7 surfaces (skills + rules + hooks + luminaries + agents + standards + ADRs)
+#   F2.1/2/6/7 — schema validates output at CI drift-check (Step 5)
+#
+# Usage:
+#   scripts/generate-lite-manifest.sh                    # writes lite-manifest.json at repo root
+#   scripts/generate-lite-manifest.sh --dry-run          # prints JSON to stdout; no file write
+#   scripts/generate-lite-manifest.sh --output PATH      # writes to specified path (test harness)
+#   scripts/generate-lite-manifest.sh --root PATH        # override repo root (test harness)
+#
+# Exit codes:
+#   0 — manifest written or dry-run printed
+#   1 — invalid arg or missing dependency (jq, git, shasum/sha256sum)
+#   2 — no lite entries found (schema requires minItems: 1)
+
+set -euo pipefail
+
+MANIFEST_VERSION="1.6.1"
+
+# --- arg parse ---
+DRY_RUN=0
+OUTPUT_PATH=""
+REPO_ROOT_OVERRIDE=""
+TARGET_TIER="lite"  # per #1295 — script now tier-parameterizable; default preserves prior API
+
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --dry-run) DRY_RUN=1; shift ;;
+    --output) OUTPUT_PATH="${2:-}"; shift 2 ;;
+    --root) REPO_ROOT_OVERRIDE="${2:-}"; shift 2 ;;
+    --tier) TARGET_TIER="${2:-}"; shift 2 ;;
+    -h|--help)
+      grep -E '^# ' "$0" | sed 's/^# \?//'
+      exit 0
+      ;;
+    *) echo "Unknown arg: $1 (use --help)" >&2; exit 1 ;;
+  esac
+done
+
+# --- validate tier arg per ADR-043 D1 ---
+case "$TARGET_TIER" in
+  lite|standard|ultra|standard-pro) ;;
+  *) echo "generate-tier-manifest: invalid --tier '$TARGET_TIER' (allowed: lite, standard, ultra, standard-pro)" >&2; exit 1 ;;
+esac
+
+# --- resolve repo root ---
+if [[ -n "$REPO_ROOT_OVERRIDE" ]]; then
+  REPO_ROOT="$REPO_ROOT_OVERRIDE"
+else
+  REPO_ROOT="$(git rev-parse --show-toplevel 2>/dev/null || true)"
+fi
+
+if [[ -z "$REPO_ROOT" || ! -d "$REPO_ROOT" ]]; then
+  echo "generate-lite-manifest: cannot resolve repo root (not in a git tree; use --root)" >&2
+  exit 1
+fi
+
+# --- dependency check ---
+for cmd in jq git; do
+  if ! command -v "$cmd" >/dev/null 2>&1; then
+    echo "generate-lite-manifest: missing dependency: $cmd" >&2
+    exit 1
+  fi
+done
+
+if command -v shasum >/dev/null 2>&1; then
+  SHA_CMD="shasum -a 256"
+elif command -v sha256sum >/dev/null 2>&1; then
+  SHA_CMD="sha256sum"
+else
+  echo "generate-lite-manifest: missing dependency: shasum or sha256sum" >&2
+  exit 1
+fi
+
+# --- default output path (root of the resolved repo; per-tier filename) ---
+if [[ -z "$OUTPUT_PATH" ]]; then
+  OUTPUT_PATH="${REPO_ROOT}/${TARGET_TIER}-manifest.json"
+fi
+
+# --- generation metadata ---
+GENERATED_AT="$(date -u +'%Y-%m-%dT%H:%M:%SZ')"
+UPSTREAM_COMMIT="$(cd "$REPO_ROOT" && git rev-parse HEAD 2>/dev/null || echo '0000000000000000000000000000000000000000')"
+
+# --- extractors ---
+
+# Extract tier from markdown YAML frontmatter (skills, rules, luminaries, agents, standards, ADRs).
+extract_yaml_tier() {
+  awk '
+    /^---$/ { c++; if (c == 2) exit; next }
+    c == 1 && /^tier:[[:space:]]/ {
+      sub(/^tier:[[:space:]]*/, "")
+      gsub(/[[:space:]]/, "")
+      print
+      exit
+    }
+  ' "$1"
+}
+
+# Extract tier from bash hook file # tier: header.
+extract_hook_tier() {
+  grep -m1 -E '^#[[:space:]]*tier:[[:space:]]' "$1" 2>/dev/null \
+    | sed -E 's/^#[[:space:]]*tier:[[:space:]]*//' \
+    | sed -E 's/[[:space:]]*$//' \
+    || true
+}
+
+# Normalize `—` YAML escape to literal em-dash character. Closes
+# bassclef-upstream#1548 — YAML frontmatter with double-quoted strings can
+# carry `—` as a 6-char literal; jq preserves it as `\\u2014` in JSON
+# output, which downstream renderers write verbatim into MDX. Adopters see
+# raw `—` on the live site. Normalizing at extraction time lets jq
+# emit the standard `—` JSON escape sequence, which parses cleanly to
+# em-dash at every consumer.
+normalize_em_dash() {
+  local val="$1"
+  echo "${val//\\u2014/—}"
+}
+
+# Extract description from markdown YAML frontmatter (first line of description: field).
+extract_yaml_description() {
+  local val
+  val=$(awk '
+    /^---$/ { c++; if (c == 2) exit; next }
+    c == 1 && /^description:[[:space:]]/ {
+      sub(/^description:[[:space:]]*/, "")
+      sub(/^"/, "")
+      sub(/"$/, "")
+      sub(/^\047/, "")
+      sub(/\047$/, "")
+      print
+      exit
+    }
+  ' "$1")
+  normalize_em_dash "$val"
+}
+
+# Extract a `<field>:` inline YAML list from the frontmatter as a JSON array string.
+# Handles shape `<field>: [foo, bar]` — bassclef's convention. Returns `[]` when absent or malformed.
+_extract_yaml_inline_list() {
+  local file="$1" field="$2" raw
+  raw=$(awk -v f="$field" '
+    /^---$/ { c++; if (c == 2) exit; next }
+    c == 1 && $0 ~ ("^" f ":[[:space:]]*\\[") {
+      sub("^" f ":[[:space:]]*", "")
+      print
+      exit
+    }
+  ' "$file" 2>/dev/null)
+  if [[ -z "$raw" ]]; then
+    echo "[]"
+    return
+  fi
+  # Strip enclosing brackets, split on comma, trim, quote each, join. Always output valid JSON.
+  echo "$raw" | jq -Rc '
+    ltrimstr("[") | rtrimstr("]")
+    | split(",")
+    | map(sub("^\\s+"; "") | sub("\\s+$"; ""))
+    | map(select(length > 0))
+  ' 2>/dev/null || echo "[]"
+}
+
+extract_yaml_composes_with() {
+  _extract_yaml_inline_list "$1" "composes_with"
+}
+
+extract_yaml_depends_on() {
+  _extract_yaml_inline_list "$1" "depends_on"
+}
+
+# Per bassclef-web#268 — inputs + outputs read as inline YAML lists from
+# frontmatter. Stage 1 = frontmatter-declared (deterministic). Stage 2 =
+# body-section extraction (deferred per L169 awk-portability note).
+extract_yaml_inputs() {
+  _extract_yaml_inline_list "$1" "inputs"
+}
+
+extract_yaml_outputs() {
+  _extract_yaml_inline_list "$1" "outputs"
+}
+
+# Extract a `<field>:` YAML string value from the frontmatter. Handles inline
+# form `<field>: some text`. Multi-line block scalars (`|` / `>`) are not
+# supported today — Feathers F3 single-line contract per goal 2026-09-07c.
+# Returns empty string when the field is absent, quoting normalized like
+# extract_yaml_description does.
+_extract_yaml_string_field() {
+  local val
+  val=$(awk -v f="$2" '
+    /^---$/ { c++; if (c == 2) exit; next }
+    c == 1 && $0 ~ ("^" f ":[[:space:]]") {
+      sub("^" f ":[[:space:]]*", "")
+      sub(/^"/, "")
+      sub(/"$/, "")
+      sub(/^\047/, "")
+      sub(/\047$/, "")
+      print
+      exit
+    }
+  ' "$1")
+  normalize_em_dash "$val"
+}
+
+# Extract `problem:` frontmatter field per bassclef-web#268 + web#265 Stage 1
+# (frontmatter-first path per Peirce disposition c on bassclef-upstream#1533).
+# Skill-surface-only per Hoare H5 pre-mortem. Empty when absent — jq guard
+# drops the key.
+extract_yaml_problem() {
+  _extract_yaml_string_field "$1" "problem"
+}
+
+# Extract `value:` frontmatter field per bassclef-web#268 + web#265 Stage 1.
+# Skill-surface-only per Hoare H5 pre-mortem. Empty when absent.
+extract_yaml_value() {
+  _extract_yaml_string_field "$1" "value"
+}
+
+# Body-anchor extraction for problem + value deferred per bassclef-web#265
+# Stage 2 note. Stage 1 awk section extraction proved non-deterministic
+# across BSD (macOS) and GNU (Linux) awk implementations. Schema fields
+# remain defined for Stage 2 hand-authored `data/skill-pitches.json`
+# overrides. Frontmatter path above ships today (goal 2026-09-07c Step 3).
+# See PR discussion on bassclef-upstream#1480.
+
+# Extract description from bash hook file — first non-shebang, non-tier, non-metadata comment.
+extract_hook_description() {
+  grep -E '^#' "$1" 2>/dev/null \
+    | grep -vE '^#!' \
+    | grep -vE '^#[[:space:]]*(tier|install-class|matcher|event|luminary|@)' \
+    | grep -vE '^#[[:space:]]*$' \
+    | head -1 \
+    | sed -E 's/^#[[:space:]]*//' \
+    | sed -E 's/[[:space:]]*$//' \
+    || true
+}
+
+sha256_file() {
+  $SHA_CMD "$1" | awk '{print "sha256:"$1}'
+}
+
+# --- emit entries for a single surface ---
+# Args:
+#   $1 = surface type ("skill", "rule", etc.)
+#   $2 = tier extractor function name
+#   $3 = description extractor function name
+#   $4 = slug source ("dirname" | "basename" | "adr")
+#   $5+ = file paths (already expanded)
+emit_entries() {
+  local surface_type="$1"; shift
+  local tier_fn="$1"; shift
+  local desc_fn="$1"; shift
+  local slug_from="$1"; shift
+
+  local f slug tier path hash desc
+  # Per #1295 — for standard/ultra manifests, ships derives as SUPERSET of
+  # lite. So standard includes {lite, standard}; ultra includes {lite, standard, ultra}.
+  # Adopters at a given tier see everything their tier plus lower tiers ship.
+  local include_lite=0 include_standard=0 include_ultra=0
+  case "$TARGET_TIER" in
+    lite) include_lite=1 ;;
+    standard) include_lite=1; include_standard=1 ;;
+    standard-pro) include_lite=1; include_standard=1 ;;
+    ultra) include_lite=1; include_standard=1; include_ultra=1 ;;
+  esac
+  for f in "$@"; do
+    [[ -f "$f" ]] || continue
+    # Skip TEMPLATE + Index files — scaffolding not real substrate;
+    # they carry uppercase slugs that violate schema pattern.
+    case "$(basename "$f")" in
+      TEMPLATE.md|ADR-Index.md) continue ;;
+    esac
+    tier=$("$tier_fn" "$f" || true)
+    case "$tier" in
+      lite) [[ "$include_lite" == "1" ]] || continue ;;
+      standard) [[ "$include_standard" == "1" ]] || continue ;;
+      standard-pro) [[ "$include_standard" == "1" ]] || continue ;;
+      ultra) [[ "$include_ultra" == "1" ]] || continue ;;
+      *) continue ;;
+    esac
+
+    case "$slug_from" in
+      dirname)
+        slug=$(basename "$(dirname "$f")")
+        ;;
+      adr)
+        slug=$(basename "$f" .md | sed -E 's/^ADR-//')
+        ;;
+      *)
+        slug=$(basename "$f")
+        slug="${slug%.md}"
+        slug="${slug%.sh}"
+        slug="${slug%.json}"     # #1295 embedding entries
+        # Lowercase + normalize (schema pattern: ^[a-z0-9][a-z0-9-]*[a-z0-9]$)
+        slug=$(echo "$slug" | tr '[:upper:]' '[:lower:]' | sed -E 's/^ADR-//i' | sed -E 's/[^a-z0-9-]/-/g' | sed -E 's/^-+//;s/-+$//;s/-+/-/g')
+        ;;
+    esac
+
+    path="${f#$REPO_ROOT/}"
+    hash=$(sha256_file "$f")
+    desc=$("$desc_fn" "$f" || true)
+
+    # Extract additive graph fields per bassclef-web#104 partial.
+    # composes_with + depends_on read from YAML frontmatter via jq (deterministic).
+    # Every markdown surface with frontmatter carries these.
+    local composes_with_json="[]"
+    local depends_on_json="[]"
+    case "$surface_type" in
+      skill|rule|luminary|agent|standard|adr|template|root-doc)
+        composes_with_json=$(extract_yaml_composes_with "$f" 2>/dev/null || echo "[]")
+        depends_on_json=$(extract_yaml_depends_on "$f" 2>/dev/null || echo "[]")
+        ;;
+    esac
+
+    # inputs + outputs + problem + value are skill-surface-only per Hoare H5
+    # pre-mortem (docs/risk-ledgers/2026-09-07c-lite-manifest-schema-extractor-
+    # backfill-ledger.md). Other surfaces (rules, luminaries, etc) do not
+    # semantically carry "what to feed" / "what comes back" — they are steering,
+    # not tool-like. Per goal 2026-09-07c Step 3.
+    local inputs_json="[]"
+    local outputs_json="[]"
+    local problem=""
+    local value=""
+    if [ "$surface_type" = "skill" ]; then
+      inputs_json=$(extract_yaml_inputs "$f" 2>/dev/null || echo "[]")
+      outputs_json=$(extract_yaml_outputs "$f" 2>/dev/null || echo "[]")
+      problem=$(extract_yaml_problem "$f" 2>/dev/null || true)
+      value=$(extract_yaml_value "$f" 2>/dev/null || true)
+    fi
+
+    jq -c -n \
+      --arg slug "$slug" \
+      --arg type "$surface_type" \
+      --arg path "$path" \
+      --arg tier "$tier" \
+      --arg hash "$hash" \
+      --arg desc "${desc:-}" \
+      --arg problem "${problem:-}" \
+      --arg value "${value:-}" \
+      --argjson composes_with "${composes_with_json:-[]}" \
+      --argjson depends_on "${depends_on_json:-[]}" \
+      --argjson inputs "${inputs_json:-[]}" \
+      --argjson outputs "${outputs_json:-[]}" \
+      '{slug:$slug, type:$type, path:$path, tier:$tier, content_hash:$hash}
+        + (if $desc == "" then {} else {description:$desc} end)
+        + (if ($composes_with | length) == 0 then {} else {composes_with:$composes_with} end)
+        + (if ($depends_on | length) == 0 then {} else {depends_on:$depends_on} end)
+        + (if ($inputs | length) == 0 then {} else {inputs:$inputs} end)
+        + (if ($outputs | length) == 0 then {} else {outputs:$outputs} end)
+        + (if $problem == "" then {} else {problem:$problem} end)
+        + (if $value == "" then {} else {value:$value} end)'
+  done
+}
+
+# --- collect entries from 13 surfaces per #1392 Shape 3 (goal 2026-08-27a) ---
+# Original 8 (7 doc + 1 embedding per #1295 Step 5) plus 5 new install surfaces:
+#   lib (lib/*.sh) + script (scripts/*.sh) + presence-template (presence/install/*)
+#   + template (templates/*.md) + root-doc (root-level *.md)
+# The extension makes the manifest the definitive install list for bassclef-cli.
+# Note: `readarray` is bash 4.0+; macOS ships bash 3.2. Use while-read loop.
+STANDARDS_FILES=()
+while IFS= read -r f; do
+  STANDARDS_FILES+=("$f")
+done < <(find "$REPO_ROOT/standards" -type f -name '*.md' | sort)
+
+# Embedding files (JSON) — per #1295 Step 5; ultra tier ships Voyage vectors
+EMBEDDING_FILES=()
+while IFS= read -r f; do
+  EMBEDDING_FILES+=("$f")
+done < <(find "$REPO_ROOT/.claude/embeddings" -type f -name '*.json' 2>/dev/null | sort)
+
+# Lib files (bash) — per #1392 Shape 3; adopter runtime needs lib/state.sh + lib/hook-inject.sh etc
+LIB_FILES=()
+while IFS= read -r f; do
+  LIB_FILES+=("$f")
+done < <(find "$REPO_ROOT/lib" -maxdepth 1 -type f -name '*.sh' 2>/dev/null | sort)
+
+# Script files (bash) — per #1392 Shape 3; adopter runtime needs scripts/bassclef-*.sh helpers
+SCRIPT_FILES=()
+while IFS= read -r f; do
+  SCRIPT_FILES+=("$f")
+done < <(find "$REPO_ROOT/scripts" -maxdepth 1 -type f -name '*.sh' 2>/dev/null | sort)
+
+# Presence templates (bash + md) — per #1392 Shape 3; adopter install dispatches through these
+PRESENCE_TEMPLATE_SH_FILES=()
+while IFS= read -r f; do
+  PRESENCE_TEMPLATE_SH_FILES+=("$f")
+done < <(find "$REPO_ROOT/presence/install" -maxdepth 1 -type f -name '*.sh' 2>/dev/null | sort)
+
+PRESENCE_TEMPLATE_MD_FILES=()
+while IFS= read -r f; do
+  PRESENCE_TEMPLATE_MD_FILES+=("$f")
+done < <(find "$REPO_ROOT/presence/install" -maxdepth 1 -type f -name '*.md' 2>/dev/null | sort)
+
+# Templates (md) — per #1392 Shape 3; chronicle-template + iteration-goal etc adopters copy
+TEMPLATE_FILES=()
+while IFS= read -r f; do
+  TEMPLATE_FILES+=("$f")
+done < <(find "$REPO_ROOT/templates" -maxdepth 1 -type f -name '*.md' 2>/dev/null | sort)
+
+# Root docs (md) — per #1392 Shape 3; README + CLAUDE + AGENTS adopters read on install
+ROOT_DOC_FILES=()
+while IFS= read -r f; do
+  ROOT_DOC_FILES+=("$f")
+done < <(find "$REPO_ROOT" -maxdepth 1 -type f -name '*.md' 2>/dev/null | sort)
+
+# Extract tier from JSON root-key `"tier"` or `"_tier"` — per #1295
+extract_json_tier() {
+  head -5 "$1" 2>/dev/null | awk '
+    /"tier"[[:space:]]*:[[:space:]]*"/ {
+      match($0, /"tier"[[:space:]]*:[[:space:]]*"[^"]+"/)
+      v=substr($0, RSTART, RLENGTH)
+      sub(/^"tier"[[:space:]]*:[[:space:]]*"/,"",v); sub(/"$/,"",v)
+      print v; exit
+    }
+    /"_tier"[[:space:]]*:[[:space:]]*"/ {
+      match($0, /"_tier"[[:space:]]*:[[:space:]]*"[^"]+"/)
+      v=substr($0, RSTART, RLENGTH)
+      sub(/^"_tier"[[:space:]]*:[[:space:]]*"/,"",v); sub(/"$/,"",v)
+      print v; exit
+    }'
+}
+
+# Embeddings have no description field; return empty
+extract_json_description() {
+  echo ""
+}
+
+ENTRIES_JSON=$(
+  {
+    emit_entries "skill"     extract_yaml_tier extract_yaml_description dirname  "$REPO_ROOT/.claude/skills/"*/SKILL.md
+    emit_entries "rule"      extract_yaml_tier extract_yaml_description basename "$REPO_ROOT/.claude/rules/"*.md
+    emit_entries "hook"      extract_hook_tier extract_hook_description basename "$REPO_ROOT/.claude/hooks/"*.sh
+    emit_entries "luminary"  extract_yaml_tier extract_yaml_description basename "$REPO_ROOT/.claude/luminaries/"*.md
+    emit_entries "agent"     extract_yaml_tier extract_yaml_description basename "$REPO_ROOT/.claude/agents/"*.md
+    emit_entries "standard"  extract_yaml_tier extract_yaml_description basename "${STANDARDS_FILES[@]}"
+    emit_entries "adr"       extract_yaml_tier extract_yaml_description adr      "$REPO_ROOT/architecture/decisions/"ADR-*.md
+    if [[ ${#EMBEDDING_FILES[@]} -gt 0 ]]; then
+      emit_entries "embedding" extract_json_tier extract_json_description basename "${EMBEDDING_FILES[@]}"
+    fi
+    # Per #1392 Shape 3 — 5 new install surfaces for bassclef-cli
+    if [[ ${#LIB_FILES[@]} -gt 0 ]]; then
+      emit_entries "lib"     extract_hook_tier extract_hook_description basename "${LIB_FILES[@]}"
+    fi
+    if [[ ${#SCRIPT_FILES[@]} -gt 0 ]]; then
+      emit_entries "script"  extract_hook_tier extract_hook_description basename "${SCRIPT_FILES[@]}"
+    fi
+    if [[ ${#PRESENCE_TEMPLATE_SH_FILES[@]} -gt 0 ]]; then
+      emit_entries "presence-template" extract_hook_tier extract_hook_description basename "${PRESENCE_TEMPLATE_SH_FILES[@]}"
+    fi
+    if [[ ${#PRESENCE_TEMPLATE_MD_FILES[@]} -gt 0 ]]; then
+      emit_entries "presence-template" extract_yaml_tier extract_yaml_description basename "${PRESENCE_TEMPLATE_MD_FILES[@]}"
+    fi
+    if [[ ${#TEMPLATE_FILES[@]} -gt 0 ]]; then
+      emit_entries "template" extract_yaml_tier extract_yaml_description basename "${TEMPLATE_FILES[@]}"
+    fi
+    if [[ ${#ROOT_DOC_FILES[@]} -gt 0 ]]; then
+      emit_entries "root-doc" extract_yaml_tier extract_yaml_description basename "${ROOT_DOC_FILES[@]}"
+    fi
+  } | jq -s 'sort_by(.type, .slug)'
+)
+
+ENTRY_COUNT=$(echo "$ENTRIES_JSON" | jq 'length')
+
+if [[ "$ENTRY_COUNT" -lt 1 ]]; then
+  echo "generate-tier-manifest: no entries found for tier '$TARGET_TIER' (schema requires minItems: 1)" >&2
+  exit 2
+fi
+
+# --- assemble manifest ---
+# Includes tier root-key per #1295 — the manifest itself carries its own tier tag
+# so tier-tag-required-at-write.sh recognizes it. Per Saltzer-Schroeder complete
+# mediation — no derived artifact escapes the tier system.
+MANIFEST_JSON=$(jq -n \
+  --arg tier "$TARGET_TIER" \
+  --arg mv "$MANIFEST_VERSION" \
+  --arg ga "$GENERATED_AT" \
+  --argjson entries "$ENTRIES_JSON" \
+  '{tier:$tier, manifest_version:$mv, generated_at:$ga, entries:$entries}')
+
+# Per bassclef-upstream#1508 Cure a: upstream_commit dropped from manifest
+# content. Every rebase over a merged sibling PR guaranteed a conflict
+# because the hash changes per parent. Traceability now comes from git
+# log on the manifest file itself. `generated_at` still causes minor
+# timestamp conflicts but is human-scannable; drop deferred if the class
+# still recurs.
+
+# --- emit ---
+if [[ "$DRY_RUN" == "1" ]]; then
+  echo "$MANIFEST_JSON"
+else
+  echo "$MANIFEST_JSON" > "$OUTPUT_PATH"
+  echo "Wrote $OUTPUT_PATH ($ENTRY_COUNT entries; commit ${UPSTREAM_COMMIT:0:7})" >&2
+fi

package/dist/lite/scripts/generate-tier-manifest.sh

@@ -0,0 +1,28 @@
+#!/usr/bin/env bash
+# tier: lite
+# generate-tier-manifest.sh — thin wrapper over generate-lite-manifest.sh
+# for the tier-agnostic API per bassclef-upstream#1295.
+#
+# generate-lite-manifest.sh keeps its historical name for backward compat.
+# This wrapper exposes the new API: `generate-tier-manifest.sh <tier>`.
+#
+# Usage:
+#   bash scripts/generate-tier-manifest.sh lite       # writes lite-manifest.json
+#   bash scripts/generate-tier-manifest.sh standard   # writes standard-manifest.json (superset of lite)
+#   bash scripts/generate-tier-manifest.sh ultra      # writes ultra-manifest.json (superset of lite + standard)
+#   bash scripts/generate-tier-manifest.sh <tier> --dry-run
+#
+# Per #1295 body L23 — standard + ultra manifests derived as supersets of lite.
+
+set -euo pipefail
+
+if [ $# -lt 1 ]; then
+  echo "usage: $0 <tier> [--dry-run] [--output PATH] [--root PATH]" >&2
+  echo "  tier: lite | standard | ultra | standard-pro" >&2
+  exit 1
+fi
+
+TIER="$1"; shift
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+exec bash "${SCRIPT_DIR}/generate-lite-manifest.sh" --tier "$TIER" "$@"