Printing Press Import

#!/usr/bin/env bash
# import-backup.sh — zip an existing internal library CLI + its manuscripts
# to /tmp/printing-press/ before overwriting.
#
# Usage:
#   import-backup.sh <api-slug>
#
# Backs up:
#   ${PRINTING_PRESS_HOME:-$HOME/printing-press}/library/<api-slug>/
#   ${PRINTING_PRESS_HOME:-$HOME/printing-press}/manuscripts/<api-slug>/  (if present)
#
# Output: prints the absolute path of the resulting zip on stdout.

set -euo pipefail

[[ $# -eq 1 ]] || { echo "usage: $0 <api-slug>" >&2; exit 2; }

API_SLUG="$1"
BACKUP_DIR="/tmp/printing-press"
TS=$(date -u +%Y%m%dT%H%M%SZ)
ZIP_PATH="$BACKUP_DIR/${API_SLUG}-${TS}.zip"

PRESS_HOME="${PRINTING_PRESS_HOME:-$HOME/printing-press}"
LIBRARY_DIR="$PRESS_HOME/library/$API_SLUG"
MANUSCRIPTS_DIR="$PRESS_HOME/manuscripts/$API_SLUG"

if [[ ! -d "$LIBRARY_DIR" && ! -d "$MANUSCRIPTS_DIR" ]]; then
  echo "nothing to backup for $API_SLUG" >&2
  exit 0
fi

mkdir -p "$BACKUP_DIR"

# Stage in a temp dir so the zip preserves the relative layout users
# would need to restore by hand: library/<api>/ and manuscripts/<api>/.
STAGE=$(mktemp -d)
trap 'rm -rf "$STAGE"' EXIT

if [[ -d "$LIBRARY_DIR" ]]; then
  mkdir -p "$STAGE/library"
  cp -R "$LIBRARY_DIR" "$STAGE/library/"
fi
if [[ -d "$MANUSCRIPTS_DIR" ]]; then
  mkdir -p "$STAGE/manuscripts"
  cp -R "$MANUSCRIPTS_DIR" "$STAGE/manuscripts/"
fi

(cd "$STAGE" && zip -qr "$ZIP_PATH" .)
echo "$ZIP_PATH"

#!/usr/bin/env bash
# import-fetch.sh — fetch one CLI subtree + its .manuscripts from the
# public library into a staging dir.
#
# Usage:
#   import-fetch.sh <library-path> <staging-dir> [--clone <local-clone-path>]
#
# Where <library-path> is the `path` field from registry.json (e.g.
# `library/productivity/cal-com`). When --clone is supplied, the script
# copies from the local clone instead of hitting GitHub.
#
# Exits 0 on success; non-zero on any failure.

set -euo pipefail

usage() {
  echo "usage: $0 <library-path> <staging-dir> [--clone <path>]" >&2
  exit 2
}

[[ $# -lt 2 ]] && usage

LIB_PATH="$1"
STAGING="$2"
shift 2

CLONE_PATH=""
while [[ $# -gt 0 ]]; do
  case "$1" in
    --clone)
      CLONE_PATH="${2:-}"
      [[ -z "$CLONE_PATH" ]] && usage
      shift 2
      ;;
    *)
      usage
      ;;
  esac
done

mkdir -p "$STAGING"

if [[ -n "$CLONE_PATH" ]]; then
  SRC="$CLONE_PATH/$LIB_PATH"
  [[ -d "$SRC" ]] || { echo "source not found in clone: $SRC" >&2; exit 1; }
  cp -R "$SRC/." "$STAGING/"
  exit 0
fi

# Remote fetch: shallow clone the whole repo to a temp dir, then copy the
# subtree out. GitHub's contents API can't return whole subtrees in one
# call and rate-limits per-file fetching for large CLIs. A shallow clone
# is ~2-5 MB and one round-trip.
TMP_CLONE=$(mktemp -d)
trap 'rm -rf "$TMP_CLONE"' EXIT

git clone --depth 1 --quiet \
  https://github.com/mvanhorn/printing-press-library.git \
  "$TMP_CLONE"

SRC="$TMP_CLONE/$LIB_PATH"
[[ -d "$SRC" ]] || { echo "source not found in clone: $SRC" >&2; exit 1; }
cp -R "$SRC/." "$STAGING/"

#!/usr/bin/env bash
# import-place.sh — atomically move a staged CLI + its manuscripts into
# the internal library at ${PRINTING_PRESS_HOME:-$HOME/printing-press}/.
#
# Layout:
#   <staging>/                      (CLI files at root)
#   <staging>/.manuscripts/<run>/   (one or more run-id dirs)
#
# Lands as:
#   ${PRINTING_PRESS_HOME:-$HOME/printing-press}/library/<api-slug>/             (CLI files)
#   ${PRINTING_PRESS_HOME:-$HOME/printing-press}/manuscripts/<api-slug>/<run>/   (each run dir)
#
# Any pre-existing target dirs are removed first; back them up with
# import-backup.sh before invoking this.
#
# Usage:
#   import-place.sh <staging-dir> <api-slug>

set -euo pipefail

[[ $# -eq 2 ]] || { echo "usage: $0 <staging-dir> <api-slug>" >&2; exit 2; }

STAGING="$1"
API_SLUG="$2"

[[ -d "$STAGING" ]] || { echo "staging dir not found: $STAGING" >&2; exit 1; }

PRESS_HOME="${PRINTING_PRESS_HOME:-$HOME/printing-press}"
LIB_TARGET="$PRESS_HOME/library/$API_SLUG"
MAN_TARGET_ROOT="$PRESS_HOME/manuscripts/$API_SLUG"

# Move manuscripts out of the staging dir before placing the CLI. This
# keeps the CLI subtree clean (no .manuscripts/ inside the library dir).
MAN_STAGE="$STAGING/.manuscripts"

mkdir -p "$(dirname "$LIB_TARGET")"
rm -rf "$LIB_TARGET"

if [[ -d "$MAN_STAGE" ]]; then
  mkdir -p "$MAN_TARGET_ROOT"
  for run_dir in "$MAN_STAGE"/*/; do
    [[ -d "$run_dir" ]] || continue
    run_name=$(basename "$run_dir")
    run_target="$MAN_TARGET_ROOT/$run_name"
    rm -rf "$run_target"
    mv "$run_dir" "$run_target"
  done
  rmdir "$MAN_STAGE" 2>/dev/null || true
fi

# Now the staging dir contains only CLI files; move it into place.
mv "$STAGING" "$LIB_TARGET"

echo "placed: $LIB_TARGET"
[[ -d "$MAN_TARGET_ROOT" ]] && echo "manuscripts: $MAN_TARGET_ROOT"

#!/usr/bin/env bash
# import-rewrite.sh — reverse the publish-step module-path rewrites in a
# staged CLI directory so it matches the freshly-generated form.
#
# Mirrors internal/pipeline/modulepath.go's RewriteModulePath in reverse:
#   module github.com/mvanhorn/printing-press-library/library/<cat>/<api>
#     -> module <api>-pp-cli
#
#   github.com/mvanhorn/printing-press-library/library/<cat>/<api>/internal/
#     -> <api>-pp-cli/internal/
#
#   github.com/mvanhorn/printing-press-library/library/<cat>/<api>/cmd/
#     -> <api>-pp-cli/cmd/
#
# README links and goreleaser ldflags pointing at the public module path
# get reverted alongside imports. Other GitHub URLs in docs (e.g., links
# to the public release page itself) are left alone — re-publishing will
# overwrite them.
#
# Usage:
#   import-rewrite.sh <staging-dir> <api-slug>

set -euo pipefail

[[ $# -eq 2 ]] || { echo "usage: $0 <staging-dir> <api-slug>" >&2; exit 2; }

STAGING="$1"
API_SLUG="$2"

[[ -d "$STAGING" ]] || { echo "staging dir not found: $STAGING" >&2; exit 1; }
[[ -f "$STAGING/go.mod" ]] || { echo "go.mod not found in $STAGING" >&2; exit 1; }

# Read the current module path from go.mod to derive the public prefix.
PUBLIC_MODULE=$(awk '$1=="module"{print $2; exit}' "$STAGING/go.mod")
if [[ -z "$PUBLIC_MODULE" ]]; then
  echo "could not parse module path from $STAGING/go.mod" >&2
  exit 1
fi

LOCAL_MODULE="${API_SLUG}-pp-cli"

if [[ "$PUBLIC_MODULE" == "$LOCAL_MODULE" ]]; then
  echo "go.mod already on local module path; nothing to rewrite" >&2
  exit 0
fi

# Rewrite go.mod first (single-line replace, anchored).
perl -pi -e "s|^module \Q${PUBLIC_MODULE}\E\$|module ${LOCAL_MODULE}|" \
  "$STAGING/go.mod"

# Rewrite import-style references in source files. Limit to the
# extensions RewriteModulePath touches: .go, .yaml, .yml, .md.
find "$STAGING" \
  \( -name '*.go' -o -name '*.yaml' -o -name '*.yml' -o -name '*.md' \) \
  -type f \
  -print0 \
  | xargs -0 perl -pi \
      -e "s|\Q${PUBLIC_MODULE}\E/internal/|${LOCAL_MODULE}/internal/|g;" \
      -e "s|\Q${PUBLIC_MODULE}\E/cmd/|${LOCAL_MODULE}/cmd/|g;"