@gatebolt/cli 0.4.0 → 0.6.0

package/recipes/claude-code/README.md

@@ -1,64 +0,0 @@
-# GateBolt × Claude Code — declare → observe recipe
-
-Files you copy into the repo your agent works in so a Claude Code session runs
-the GateBolt loop on its own: the agent **declares** the files it plans to touch
-before editing, and each turn's diff is **observed** and reconciled when the turn
-ends. Drives the [`gatebolt` CLI](../../README.md) — read that for what `declare`
-and `observe` do.
-
-## What's in here
-
-| File                        | Copies to                      | Role                                                |
-| --------------------------- | ------------------------------ | --------------------------------------------------- |
-| `settings.json`             | `<repo>/.claude/settings.json` | Wires the `PreToolUse` guard + `Stop` observe hook  |
-| `hooks/gatebolt-guard.sh`   | `<repo>/.claude/hooks/`        | Strict mode: deny `Edit`/`Write` until declared     |
-| `hooks/gatebolt-observe.sh` | `<repo>/.claude/hooks/`        | `Stop`: run `gatebolt observe` when a turn ends     |
-| `hooks/pre-push`            | `<repo>/.git/hooks/pre-push`   | Backstop: refuse to push an un-observed declaration |
-
-Merge the `hooks` block if the repo already has a `.claude/settings.json`.
-
-## Setup
-
-```sh
-# 1. Copy the recipe in.
-cp hooks/gatebolt-*.sh <repo>/.claude/hooks/
-cp settings.json       <repo>/.claude/settings.json
-cp hooks/pre-push      <repo>/.git/hooks/pre-push
-chmod +x <repo>/.claude/hooks/gatebolt-*.sh <repo>/.git/hooks/pre-push
-
-# 2. Save a GateBolt profile for this repo once — paste the key when prompted.
-#    The hooks call `gatebolt` with no flags; the profile is resolved automatically.
-npx @gatebolt/cli configure --profile <repo-slug> \
-  --url https://your-gatebolt.app --repo <repo-slug>
-
-# 3. Launch Claude Code.
-export GATEBOLT_ENFORCE="strict"           # or omit for lenient
-export GATEBOLT_CLI="npx @gatebolt/cli"    # optional — omit if `gatebolt` is on PATH
-cd <repo> && claude
-```
-
-**Prereqs:** `git`, `jq`, and the [`@gatebolt/cli`](../../README.md) client
-(`npm i -g @gatebolt/cli`). `GATEBOLT_CLI` is a command _prefix_ the hooks append
-to, defaulting to `gatebolt`; set it to `npx @gatebolt/cli` if you didn't install
-globally.
-
-## The two modes (`GATEBOLT_ENFORCE`)
-
-- **`strict`** — the guard **denies** every `Edit`/`Write` until a declaration
-  exists (holds even under `--dangerously-skip-permissions`) and tells the agent
-  to run `gatebolt declare` first. That `Bash` call isn't blocked, so the agent
-  declares, then edits go through.
-- **`lenient`** (default) — no block; declaring is an instructed step (e.g. a
-  line in the repo's `CLAUDE.md`). The pre-push backstop guarantees nothing lands
-  undeclared.
-
-## Notes and limits
-
-- **One turn ≈ one change.** `Stop` fires every turn, so `observe` reconciles and
-  clears the session each turn; strict mode re-declares next turn.
-- **Rate limit.** Two API calls per change, and the default key limit is low
-  (10/day today, surfacing as `401` when hit). Use a fresh key when iterating.
-- **Backstop is v1.** Catches only an open, un-observed declaration (the
-  Esc-interrupt case), not work that was never declared — a follow-up.
-- **Watch over-broad declarations.** Declaring `src/**` to dodge the block kills
-  the drift signal, like an empty declaration. The deny asks for specific paths.

package/recipes/claude-code/hooks/gatebolt-guard.sh

@@ -1,48 +0,0 @@
-#!/usr/bin/env bash
-# GateBolt strict-mode PreToolUse guard — blocks Edit/Write until a declaration
-# exists for this change. Opt-in via GATEBOLT_ENFORCE=strict.
-set -u
-
-# Drain stdin so the hook's pipe doesn't block; we don't need the payload.
-cat >/dev/null
-
-[ "${GATEBOLT_ENFORCE:-lenient}" = "strict" ] || exit 0
-
-project_dir="${CLAUDE_PROJECT_DIR:-$PWD}"
-git_dir=$(git -C "$project_dir" rev-parse --git-dir 2>/dev/null) || exit 0
-case "$git_dir" in
-  /*) ;;
-  *) git_dir="$project_dir/$git_dir" ;;
-esac
-
-# session.json exists = already declared → allow the edit.
-[ -f "$git_dir/gatebolt/session.json" ] && exit 0
-
-cli="${GATEBOLT_CLI:-gatebolt}"
-reason="GateBolt strict mode: declare the files you plan to touch before editing.
-Run this in Bash first, listing EVERY file you plan to create or modify for this
-task — specific repo-relative paths, not broad globs like src/** :
-
-  $cli declare \\
-    --task \"<one line describing the task>\" \\
-    --vendor claude_code --name \"Claude Code\" --model <your-model-id> \\
-    --file <path> [--file <path> ...]
-
-GBOLT_KEY, GBOLT_URL and GBOLT_REPO are already set in your environment. Once it
-prints \"Declared change …\", retry the edit."
-
-# JSON deny holds even under --dangerously-skip-permissions; without jq we fall
-# back to exit-2, which re-prompts but isn't guaranteed under bypass.
-if command -v jq >/dev/null 2>&1; then
-  jq -n --arg r "$reason" '{
-    hookSpecificOutput: {
-      hookEventName: "PreToolUse",
-      permissionDecision: "deny",
-      permissionDecisionReason: $r
-    }
-  }'
-  exit 0
-fi
-
-printf '%s\n' "$reason" >&2
-exit 2

package/recipes/claude-code/hooks/gatebolt-observe.sh

@@ -1,24 +0,0 @@
-#!/usr/bin/env bash
-# GateBolt Stop hook — runs `gatebolt observe` to reconcile the diff when a turn
-# ends. Advisory; never blocks the turn.
-set -u
-
-# Drain stdin; observe reads its target from the session file.
-cat >/dev/null
-
-cd "${CLAUDE_PROJECT_DIR:-$PWD}" || exit 0
-
-git_dir=$(git rev-parse --git-dir 2>/dev/null) || exit 0
-case "$git_dir" in
-  /*) ;;
-  *) git_dir="$PWD/$git_dir" ;;
-esac
-
-# Stop fires every turn; only reconcile when a declaration is actually open.
-[ -f "$git_dir/gatebolt/session.json" ] || exit 0
-
-cli="${GATEBOLT_CLI:-gatebolt}"
-# GATEBOLT_CLI is a command prefix; word-splitting is intentional.
-# shellcheck disable=SC2086
-$cli observe 2>&1 || true
-exit 0

package/recipes/claude-code/hooks/pre-push

@@ -1,23 +0,0 @@
-#!/usr/bin/env bash
-# GateBolt pre-push backstop — refuses to push while a declaration is still open
-# but un-observed (the Esc-interrupt case Stop misses). Needs gatebolt's env
-# (GBOLT_KEY / GBOLT_URL / GATEBOLT_CLI) exported in the shell you push from.
-set -u
-
-git_dir=$(git rev-parse --git-dir 2>/dev/null) || exit 0
-case "$git_dir" in
-  /*) ;;
-  *) git_dir="$PWD/$git_dir" ;;
-esac
-
-[ -f "$git_dir/gatebolt/session.json" ] || exit 0
-
-cli="${GATEBOLT_CLI:-gatebolt}"
-echo "GateBolt: an un-observed declaration is still open; reconciling before push…" >&2
-# shellcheck disable=SC2086
-if ! $cli observe >&2; then
-  echo "GateBolt: observe failed — refusing to push unreconciled work." >&2
-  echo "Resolve the error above (or run '$cli observe' yourself), then push again." >&2
-  exit 1
-fi
-exit 0

package/recipes/claude-code/settings.json

@@ -1,25 +0,0 @@
-{
-  "hooks": {
-    "PreToolUse": [
-      {
-        "matcher": "Edit|Write",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "\"$CLAUDE_PROJECT_DIR\"/.claude/hooks/gatebolt-guard.sh"
-          }
-        ]
-      }
-    ],
-    "Stop": [
-      {
-        "hooks": [
-          {
-            "type": "command",
-            "command": "\"$CLAUDE_PROJECT_DIR\"/.claude/hooks/gatebolt-observe.sh"
-          }
-        ]
-      }
-    ]
-  }
-}