--- name: printing-press-amend description: > Amend a published CLI from one of two input sources: (1) dogfood mode mines the active Claude Code session transcript for friction (missing flags, hand- rolled API payloads, silent-null returns); (2) direct-input mode accepts user-supplied asks (rename a command, add commands or feeds, fix a named bug, optionally sniff the source site for new endpoints). Confirms scope with the user, plans + executes the fix autonomously, scrubs PII, and opens a PR against mvanhorn/printing-press-library. Two user-in-loop checkpoints: scope after capture, PR draft before open. Trigger phrases: "amend the CLI", "submit a patch", "fix what I just dogfooded", "open a PR for this CLI", "patch this CLI", "add features to my CLI", "rename this command", "add these feeds to ", "sniff for new APIs in ", "amend with these ideas", "use printing-press-amend", "run printing-press-amend". version: 0.2.0 min-binary-version: "4.0.0" context: fork user-invocable: true allowed-tools: - Bash - Read - Write - Edit - Glob - Grep - AskUserQuestion --- # /printing-press-amend Turn a dogfood session into a PR for a printed CLI in the public library. ```bash /printing-press-amend # auto-detect target CLI from session /printing-press-amend superhuman # explicit short name /printing-press-amend superhuman-pp-cli /printing-press-amend "$PRESS_LIBRARY/superhuman" ``` This skill lives in this repo (the machine) and acts on a printed CLI in the public library. It is sibling to `/printing-press-publish` (adds a new CLI), `/printing-press-polish` (improves a CLI pre-publish), and `/printing-press-retro` (reflects on the machine itself). None of those cover post-publish CLI amendments driven by real-session friction. The artifact this skill produces is semantically a "patch" (in the git/PR sense), tracked by the public library's `.printing-press-patches/` directory (one file per patch). Inline `// PATCH(...)` source comments are optional navigation aids when they make a customized site easier to grep. The slash-skill name is `amend` to disambiguate from the existing `cli-printing-press patch` binary subcommand (which AST-injects pre-defined features — different mechanism, different intent). ## Setup Before doing anything else: ```bash # min-binary-version: 4.0.0 # Derive scope first — needed for local build detection _scope_dir="$(git rev-parse --show-toplevel 2>/dev/null || echo "$PWD")" _scope_dir="$(cd "$_scope_dir" && pwd -P)" # Prefer local build when running from inside the printing-press repo. _press_repo=false if [ -x "$_scope_dir/cli-printing-press" ] && [ -d "$_scope_dir/cmd/cli-printing-press" ]; then _press_repo=true export PATH="$_scope_dir:$PATH" echo "Using local build: $_scope_dir/cli-printing-press" elif ! command -v cli-printing-press >/dev/null 2>&1; then if [ -x "$HOME/go/bin/cli-printing-press" ]; then echo "cli-printing-press found at ~/go/bin/cli-printing-press but not on PATH." echo "Add GOPATH/bin to your PATH: export PATH=\"\$HOME/go/bin:\$PATH\"" else echo "cli-printing-press binary not found." echo "Install with: go install github.com/mvanhorn/cli-printing-press/v4/cmd/cli-printing-press@latest" fi return 1 2>/dev/null || exit 1 fi # Resolve and emit the absolute path the agent must use for every later # `cli-printing-press` invocation. `export PATH` above only affects this one # Bash tool call; subsequent calls open a fresh shell and resolve bare # `cli-printing-press` against the user's default PATH, where a stale global # can silently shadow the local build. The agent captures this marker and # substitutes the absolute path into every later invocation. if [ "$_press_repo" = "true" ]; then PRINTING_PRESS_BIN="$_scope_dir/cli-printing-press" else PRINTING_PRESS_BIN="$(command -v cli-printing-press 2>/dev/null || true)" fi if ! command -v go >/dev/null 2>&1; then echo "" echo "[setup-error] Go toolchain not found." echo "" echo "This Printing Press flow runs Go-based build or validation commands." echo "Install Go 1.26.6 or newer from https://go.dev/dl/, then verify with:" echo " go version" echo "Then re-run this skill." echo "" return 1 2>/dev/null || exit 1 fi echo "PRINTING_PRESS_BIN=$PRINTING_PRESS_BIN" _pp_semver_lt() { if [ -z "${PP_SEMVER_A:-}" ] || [ -z "${PP_SEMVER_B:-}" ]; then echo "[setup-error] semver comparison inputs are missing." >&2 return 2 fi awk -v a="${PP_SEMVER_A:-}" -v b="${PP_SEMVER_B:-}" 'BEGIN { split(a, x, "."); split(b, y, ".") for (i = 1; i <= 3; i++) { if ((x[i] + 0) < (y[i] + 0)) exit 0 if ((x[i] + 0) > (y[i] + 0)) exit 1 } exit 1 }' } _pp_go_version_norm() { printf '%s\n' "${PP_GO_VERSION_INPUT:-}" | sed -nE 's/.*go([0-9]+)\.([0-9]+)(\.([0-9]+))?.*/\1.\2.\4/p' | sed -E 's/\.$/.0/' } _pp_check_go_currency() { _pp_go_installed="$(PP_GO_VERSION_INPUT="$(go env GOVERSION 2>/dev/null)" _pp_go_version_norm)" _pp_go_required="$(PP_GO_VERSION_INPUT="$(go version "$PRINTING_PRESS_BIN" 2>/dev/null)" _pp_go_version_norm)" PP_SEMVER_A="$_pp_go_installed" PP_SEMVER_B="$_pp_go_required" if [ -z "$_pp_go_installed" ] || [ -z "$_pp_go_required" ] || ! _pp_semver_lt; then return 0 fi echo "" if [ "${GOTOOLCHAIN:-auto}" = "local" ]; then echo "[setup-error] Go $_pp_go_required or newer is required by this cli-printing-press binary (installed: $_pp_go_installed)." echo "GOTOOLCHAIN=local disables automatic toolchain downloads, so later Go quality gates would fail." echo "Install Go $_pp_go_required or newer from https://go.dev/dl/, or unset GOTOOLCHAIN." echo "" return 1 fi echo "[go-toolchain-old] Go $_pp_go_required or newer is required by this cli-printing-press binary (installed: $_pp_go_installed)." echo "PRESS_GO_INSTALLED=$_pp_go_installed" echo "PRESS_GO_REQUIRED=$_pp_go_required" echo "Default GOTOOLCHAIN behavior may download the required toolchain during Go commands." echo "" return 0 } _pp_check_go_currency || { return 1 2>/dev/null || exit 1; } PRESS_BASE="$(basename "$_scope_dir" | tr '[:upper:]' '[:lower:]' | sed -E 's/[^a-z0-9_-]/-/g; s/^-+//; s/-+$//')" if [ -z "$PRESS_BASE" ]; then PRESS_BASE="workspace" fi PRESS_SCOPE="$PRESS_BASE-$(printf '%s' "$_scope_dir" | shasum -a 256 | cut -c1-8)" PRESS_HOME="${PRINTING_PRESS_HOME:-$HOME/printing-press}" PRESS_RUNSTATE="$PRESS_HOME/.runstate/$PRESS_SCOPE" PRESS_LIBRARY="$PRESS_HOME/library" PRESS_MANUSCRIPTS="$PRESS_HOME/manuscripts" PRESS_CURRENT="$PRESS_RUNSTATE/current" _pp_check_disk_space() { _pp_disk_warn_kb="${PRINTING_PRESS_DISK_WARN_KB:-3145728}" _pp_disk_fail_kb="${PRINTING_PRESS_DISK_FAIL_KB:-524288}" case "$_pp_disk_warn_kb$_pp_disk_fail_kb" in ""|*[!0-9]*) return 0 ;; esac _pp_disk_path="$PRESS_HOME" while [ ! -e "$_pp_disk_path" ] && [ "$_pp_disk_path" != "/" ]; do _pp_disk_path="$(dirname "$_pp_disk_path")" done _pp_disk_avail_kb="$(df -Pk "$_pp_disk_path" 2>/dev/null | awk 'BEGIN { if ((getline header) <= 0 || (getline record) <= 0) exit field_count = split(record, fields) if (field_count >= 4) print fields[4] }')" case "$_pp_disk_avail_kb" in ""|*[!0-9]*) return 0 ;; esac if [ "$_pp_disk_avail_kb" -lt "$_pp_disk_fail_kb" ]; then echo "" echo "[setup-error] Critically low disk space on the Printing Press workspace volume." echo "PRESS_DISK_PATH=$_pp_disk_path" echo "PRESS_DISK_AVAIL_KB=$_pp_disk_avail_kb" echo "PRESS_DISK_FAIL_KB=$_pp_disk_fail_kb" echo "Free disk space or set PRINTING_PRESS_HOME to a volume with more room, then re-run this skill." echo "" return 1 fi if [ "$_pp_disk_avail_kb" -lt "$_pp_disk_warn_kb" ]; then echo "" echo "[low-disk] Printing Press workspace volume is low on free space." echo "PRESS_DISK_PATH=$_pp_disk_path" echo "PRESS_DISK_AVAIL_KB=$_pp_disk_avail_kb" echo "PRESS_DISK_WARN_KB=$_pp_disk_warn_kb" echo "This flow may need several GiB for generated files, Go build cache, module downloads, or repository clones." echo "" fi } _pp_check_disk_space || { return 1 2>/dev/null || exit 1; } mkdir -p "$PRESS_RUNSTATE" "$PRESS_LIBRARY" "$PRESS_MANUSCRIPTS" "$PRESS_CURRENT" # --- Currency-floor check (standalone, fail-open) --- # Hard-stop on binaries below the published supported floor so amend does not # regenerate CLIs with since-fixed bugs. Repo checkouts build from source and # are exempt. The floor is clamped to <= latest so a bad value cannot brick # every install. Fetched fresh each run rather than reusing the printing-press # preflight's TTL cache: amend is low-frequency, so the bounded curl + go-list # cost is not worth its own cache here. if [ "$_press_repo" != "true" ] && command -v curl >/dev/null 2>&1; then _semver_lt() { if [ -z "${PP_SEMVER_A:-}" ] || [ -z "${PP_SEMVER_B:-}" ]; then echo "[setup-error] semver comparison inputs are missing." >&2 return 2 fi awk -v a="${PP_SEMVER_A:-}" -v b="${PP_SEMVER_B:-}" 'BEGIN { split(a, x, "."); split(b, y, ".") for (i = 1; i <= 3; i++) { if ((x[i] + 0) < (y[i] + 0)) exit 0 if ((x[i] + 0) > (y[i] + 0)) exit 1 } exit 1 }' } _floor_installed=$("$PRINTING_PRESS_BIN" version --json 2>/dev/null | sed -nE 's/.*"version"[[:space:]]*:[[:space:]]*"([^"]+)".*/\1/p') _floor_doc=$(curl -fsSL --max-time 5 \ https://raw.githubusercontent.com/mvanhorn/cli-printing-press/main/supported-versions.txt 2>/dev/null || true) _floor_min=$(printf '%s\n' "$_floor_doc" | sed -nE 's/^min_supported=//p' | head -n 1) _floor_reason=$(printf '%s\n' "$_floor_doc" | sed -nE 's/^reason=//p' | head -n 1) _floor_latest="" if command -v go >/dev/null 2>&1; then _floor_latest=$(go list -m -json github.com/mvanhorn/cli-printing-press/v4@latest 2>/dev/null | sed -nE 's/^[[:space:]]*"Version":[[:space:]]*"v?([^"]+)".*/\1/p' | head -n 1) fi if [ -n "$_floor_min" ] && [ -n "$_floor_installed" ] && [ -n "$_floor_latest" ] && PP_SEMVER_A="$_floor_installed" PP_SEMVER_B="$_floor_min" _semver_lt && ! PP_SEMVER_A="$_floor_latest" PP_SEMVER_B="$_floor_min" _semver_lt; then echo "" echo "[upgrade-required] printing-press v$_floor_min is the minimum supported version (you have v$_floor_installed)" echo "PRESS_REQUIRED_MIN=$_floor_min" echo "PRESS_REQUIRED_INSTALLED=$_floor_installed" echo "PRESS_REQUIRED_REASON=$_floor_reason" echo "" fi fi ``` After running the setup contract, capture the `PRINTING_PRESS_BIN=` line from stdout. **Every subsequent `cli-printing-press ...` invocation in this skill must use that absolute path** (substitute the value, not the literal `$PRINTING_PRESS_BIN` token) — `export PATH` above only affects the single Bash tool call it runs in, so later calls open a fresh shell where bare `cli-printing-press` resolves against the user's default `PATH` and a stale global can shadow the local build. If setup emitted `[go-toolchain-old]` or `[low-disk]`, surface the advisory to the user and continue unless setup also emitted `[setup-error]`. `[go-toolchain-old]` means later Go commands may download the required toolchain or fail when downloads are blocked; `[low-disk]` means this run may need several GiB for generated files, Go build cache, module downloads, or repository clones. After capturing the binary path, check binary version compatibility. Read the `min-binary-version` field from this skill's YAML frontmatter. Run ` version --json` and parse the version from the output. Compare it to `min-binary-version` using semver rules. If the installed binary is older than the minimum, stop immediately and tell the user: "cli-printing-press binary vX.Y.Z is older than the minimum required vA.B.C. Run `go install github.com/mvanhorn/cli-printing-press/v4/cmd/cli-printing-press@latest` to update." If the setup contract emitted an `[upgrade-required]` block, the installed binary is below the published **currency floor** (`PRESS_REQUIRED_MIN`) — older releases regenerate CLIs with since-fixed bugs (`PRESS_REQUIRED_REASON`). This is a hard gate distinct from `min-binary-version`: do not amend or regenerate on that binary. Offer a one-click upgrade via `AskUserQuestion` — **Yes — upgrade now** (run `go install github.com/mvanhorn/cli-printing-press/v4/cmd/cli-printing-press@latest`, re-capture `PRINTING_PRESS_BIN`, then continue) or **Cancel** (stop the run). There is no skip-and-continue; below the floor the only paths are upgrade or abort. If the upgrade command fails, surface it and stop. ## Phase 0 — Input Mode Detection This skill accepts two input sources for the finding list it later patches: a Claude Code session transcript (dogfood mode, current behavior) and user-supplied asks in the slash-command prompt (direct-input mode, added in v0.2). The two modes diverge only in Phase 1; Phase 2 onward is mode-agnostic and consumes a typed finding list with identical shape regardless of source. Decide the mode before Phase 1 runs. ### Detection rubric Read the slash-command prompt body and the immediate invocation turn from the conversation context. Classify into one of four branches: - **`MODE=direct`** — the prompt contains a concrete CLI name AND at least one direct-input signal: - Action verbs targeting the CLI: `rename`, `add`, `remove`, `fix`, `sniff`, `discover` - Explicit URLs the user wants added (e.g., `https://example.com/feed/x`) - An enumerated list of feeds, commands, endpoints, or features - Phrasing like "these ideas", "these features", "with the following" - **`MODE=dogfood`** — the prompt is empty, OR names a CLI without any asks ("amend the superhuman CLI"), OR explicitly references the session ("what I just dogfooded", "this session's friction", "from my session today") - **`MODE=both`** — the prompt clearly references both: a session AND specific asks ("I dogfooded this session and also want to add feature X", "in addition to the friction I hit, please add command Y") - **Ambiguous** — only one signal is present (CLI named with no verbs, or verbs with no target CLI, or asks worded so they could be friction reports OR new asks). Ask the user via `AskUserQuestion`: > "Two ways to source findings for this amend. Which fits? > 1. Mine the current session transcript (dogfood mode) > 2. Use the asks I just typed (direct-input mode) > 3. Both — combine transcript friction with my asks" Default when no slash-command prompt is present at all: `MODE=dogfood`. This preserves the canonical UX — `/printing-press-amend` with nothing after still works exactly as it did in v0.1. ### Persist the mode Write the resolved mode to `$PRESS_RUNSTATE/current/mode.txt` so later phases (and a resumed run) can read it: ```bash echo "$MODE" > "$PRESS_RUNSTATE/current/mode.txt" ``` ### Output Phase 0 emits one line to Phase 1: ```yaml mode: ``` Phase 1 branches on this value — dogfood findings flow through `### 1a`, direct-input findings flow through `### 1b`, and combined runs execute both sub-sections in sequence. Phase 2 onward ignores the mode entirely — the finding list is the contract. ## Phase 1 — Capture This phase produces a typed finding list. The list shape is identical across modes: each finding carries `id`, `kind`, `category`, `classification` (bug or feature), `evidence`, `target_cli`, `rationale`, and `provenance` (`transcript` for dogfood, `user-ask` for direct, `sniff` for sniff-derived). Phase 2 consumes the list verbatim. When `MODE=dogfood`, run only `### 1a`. When `MODE=direct`, run only `### 1b`. When `MODE=both`, run `### 1a` first, then `### 1b`, and merge the two finding lists with non-colliding IDs (1b continues numbering where 1a left off). ### 1a. Dogfood mode (MODE=dogfood) Read `references/transcript-parsing.md` for the full procedure. Summary of what this sub-section does: 1. **Resolve the active session transcript file** — derive `` from the current working directory, list `~/.claude/projects//*.jsonl` by mtime, pick the most-recently-modified. ALWAYS confirm the resolved path with the user via `AskUserQuestion` before reading — wrong-file selection ingests friction from the wrong session. 2. **Walk the transcript and extract friction signals** — non-zero exit codes, error messages, hand-rolled API payloads (e.g. direct `curl` POSTs that should be a CLI command), retry-after-failure patterns, agent commentary like "X doesn't exist" / "X returns 400", missing-flag references, silent-null returns, auth confusion. Each signal carries timestamp + category + verbatim evidence + the `-pp-cli` it references. 3. **Classify each signal as bug or feature** with a one-line rationale. Bug = CLI behavior is wrong; feature = CLI behavior is missing. The classification is the agent's best read; the user confirms or overrides at the U4 scope checkpoint. 4. **Auto-detect target CLI** — count occurrences of each `-pp-cli` in the signals, propose the most-touched CLI as the default. Confirm with `AskUserQuestion` (single CLI: simple yes/no; multiple close: pick from list). When the user passed an explicit `` argument, skip auto-detect. 5. **Resolve target paths and publish status** — accept short name, full name, or absolute path (per R4). Normalize the input to the bare CLI slug, then resolve publish status by looking up that slug in the public library (`~/printing-press-library/library/*/` when a local clone exists, otherwise the same path via `gh api`). Do not infer publish status from the local working copy's git remotes, and do not treat a missing `$PRESS_LIBRARY/` working copy as unpublished. If the slug is found in the public library, record `target_category`, `published_status: published`, and route the run through the managed-clone upstream PR path. Only use `published_status: local-only` when the slug is absent from the public library. The category is needed by U7's PR open phase and is captured here so it doesn't have to be re-derived. Each finding emitted by 1a carries `provenance: transcript`. Output flows into Phase 2 as the structured finding list documented in `references/transcript-parsing.md`. ### 1b. Direct-input mode (MODE=direct) Read `references/direct-input-parsing.md` for the full procedure (introduced in v0.2). Summary of what this sub-section does: 1. **Read the slash-command prompt body** plus the immediate agent-message turn that fired the skill — these carry the user's verbatim asks (e.g., "rename Digg 1000 to Digg, add these four feeds: ..., sniff for new endpoints"). There is no transcript to confirm; skip the U1 transcript-path modal that 1a runs. 2. **Resolve the target CLI** — same name-resolution rules as 1a step 4-5 (per R4), but the CLI is normally already named in the prompt itself. Extract via regex (`-pp-cli` or "the CLI"); if absent, ask the user. 3. **Parse the asks into structured findings** using the rubric in `references/direct-input-parsing.md`. Each ask maps to one finding with a typed `kind` field: - `rename` — "rename X to Y" / "call it X instead of Y" → `classification: feature` - `add-command` — "add command X" / "add subcommand X" → `classification: feature` - `add-feed` — "add feed " / enumerated URLs the user wants added (one finding per URL) → `classification: feature` - `add-endpoint` — "add endpoint " / explicit API path → `classification: feature` - `fix-bug` — "fix X" / "X is broken" / "X returns null" → `classification: bug` - `sniff` — "sniff for new APIs" / "find new endpoints" / "discover more" → routes to the sniff subroutine in `### 1b.i` 4. **Each finding records the user's verbatim phrasing** in `evidence` so the U4 scope confir