bvandeusenandClaude Opus 5.5
556872c039
CI & Build / Python lint (push) Successful in 3s
CI & Build / Plugin hooks (push) Successful in 12s
CI & Build / TypeScript typecheck (push) Successful in 54s
CI & Build / integration (push) Successful in 1m6s
CI & Build / Python tests (push) Failing after 1m22s
CI & Build / Build & push image (push) Skipped
A System's rulings (the Rulings section of its description) now reach the work by path, not by similarity. Both PreToolUse arms resolve the files a command or edit names to the Systems whose path_patterns cover them, and the first touch in a session shows each area's rulings in one line; a repeat is a one-line reference. A lookup, so no floor, no budget, no retrieval_logs row. - services/system_rulings: parse_rulings, command_paths (reads and writes, relative to the repo root from any cwd; flags, URLs, globs skipped), rulings_for_paths - /tool-rules takes root, cwd and seen_ruling_systems; /prior-art takes seen_ruling_systems; both return ruling_system_ids - hooks share <sid>.rulings.ids (cleared on compaction by the ledger naming convention); the Bash hook sends the repo root and cwd - system_usage_events (migration 0114): surfacings by source, pulls from get_system; carried by backup (v20) through the system map - writing-records: rulings also arrive when the area's files are touched Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
166 lines
8.1 KiB
Bash
166 lines
8.1 KiB
Bash
#!/usr/bin/env bash
|
|
# Scribe — PreToolUse rule arm for ACTIONS (#3476).
|
|
#
|
|
# The sibling of scribe_prior_art.sh. That hook is registered on Write|Edit and
|
|
# asks "what is recorded about the file being written". This one asks "does a
|
|
# standing rule speak to the command about to be run" — the question nothing
|
|
# could ask before, and the reason every rule about which tool to reach for had
|
|
# to live in the preload instead, back when there was one.
|
|
#
|
|
# WHY A HOOK AND NOT AN INSTRUCTION. A reflex generates no query (note #3089):
|
|
# you reach for `curl` confidently, with no moment of doubt, so a surface that
|
|
# waits to be asked never fires. Here nothing is asked — the tool call IS the
|
|
# query, and the reflex has to become a tool call before it can do anything.
|
|
#
|
|
# SILENT ON OUTAGE, deliberately, unlike the prior-art hook. A write is
|
|
# occasional; a Bash call is not, and an "instance did not answer" line before
|
|
# every command is the noise that gets a channel muted. scribe_prior_art.sh
|
|
# still speaks for both when the instance is down.
|
|
#
|
|
# Env:
|
|
# SCRIBE_URL / SCRIBE_TOKEN override for the settings.json dogfooding path.
|
|
|
|
command -v curl >/dev/null 2>&1 || exit 0
|
|
|
|
# Sourced FIRST, because the JSON reader below lives there (#4107). It defines
|
|
# functions and clears `url`/`token`; nothing here runs before it is needed.
|
|
# shellcheck source=plugin/hooks/scribe_defs.sh
|
|
. "$(dirname "${BASH_SOURCE[0]}")/scribe_defs.sh"
|
|
|
|
# PreToolUse delivers { session_id, cwd, tool_name, tool_input: {...}, ... }
|
|
event=$(cat 2>/dev/null || true)
|
|
event_flat=$(printf '%s' "$event" | scribe_json_flat)
|
|
tool_name=$(scribe_json_pick "$event_flat" '.tool_name')
|
|
session_id=$(scribe_json_pick "$event_flat" '.session_id')
|
|
event_cwd=$(scribe_json_pick "$event_flat" '.cwd')
|
|
|
|
[ -n "$tool_name" ] || exit 0
|
|
|
|
# The action, as text. `.command` is Bash's field; the fallbacks let the matcher
|
|
# in hooks.json widen to other tools without this script changing — which is the
|
|
# whole reason the server side takes a name and a string rather than a schema.
|
|
command_text=$(scribe_json_pick "$event_flat" '.tool_input.command')
|
|
[ -n "$command_text" ] || command_text=$(scribe_json_pick "$event_flat" '.tool_input.url')
|
|
[ -n "$command_text" ] || command_text=$(scribe_json_pick "$event_flat" '.tool_input.prompt')
|
|
|
|
[ -n "$command_text" ] || exit 0
|
|
|
|
# scribe_config, not a hand-rolled pair of parameter expansions: it also treats
|
|
# an UNEXPANDED `${...}` placeholder as unset, which would otherwise be sent as
|
|
# a garbage Bearer token and 401 on every call (#2198's class).
|
|
scribe_config || exit 0
|
|
|
|
# Bounded before encoding: a heredoc or a pasted script can be enormous, and
|
|
# the verb and its target — the part a rule is about — sit at the front. The
|
|
# server bounds it again; this keeps a huge payload off the wire in the first
|
|
# place. `head -c`, never `cut -c`: cut truncates each LINE and caps nothing.
|
|
command_text=$(printf '%s' "$command_text" | head -c 2000)
|
|
|
|
# Whole, never line by line: the predecessor (`jq -rR`) encoded a multi-line
|
|
# command one line at a time and joined them with raw newlines — an invalid URL.
|
|
# scribe_urlenc reads bytes and has no notion of a line.
|
|
cmd_enc=$(printf '%s' "$command_text" | scribe_urlenc)
|
|
tool_enc=$(printf '%s' "$tool_name" | scribe_urlenc)
|
|
[ -n "$cmd_enc" ] && [ -n "$tool_enc" ] || exit 0
|
|
|
|
repo_q=""
|
|
lookup_dir=${event_cwd:-${CLAUDE_PROJECT_DIR:-$PWD}}
|
|
scope=$(scribe_scope_query "$lookup_dir")
|
|
[ -n "$scope" ] && repo_q="&${scope}"
|
|
|
|
# Where the command runs, against the repo's root (milestone 444): the paths a
|
|
# command names are relative to its cwd or absolute, and a System's patterns
|
|
# are relative to the root. The server does the arithmetic; this sends both.
|
|
where_q=""
|
|
repo_root=$(git -C "$lookup_dir" rev-parse --show-toplevel 2>/dev/null || true)
|
|
if [ -n "$repo_root" ]; then
|
|
where_q="&root=$(printf '%s' "$repo_root" | scribe_urlenc)&cwd=$(printf '%s' "$lookup_dir" | scribe_urlenc)"
|
|
fi
|
|
|
|
# THE SHARED SESSION LEDGER, and the thing most worth getting right here.
|
|
#
|
|
# scribe_prior_art.sh keeps the rules it has already named in
|
|
# <state>/<sid>.rules.ids and passes them as exclude_rule_ids. This hook reads
|
|
# and appends to that SAME file rather than keeping its own: two ledgers would
|
|
# mean a rule named by one arm gets re-offered by the other, and the hint that
|
|
# fires most often is exactly the one that must not repeat itself.
|
|
#
|
|
# The directory keeps the prior-art name on purpose — renaming it would orphan
|
|
# every live session's state for a cosmetic gain.
|
|
state_dir="${TMPDIR:-/tmp}/scribe-priorart"
|
|
mkdir -p "$state_dir" 2>/dev/null || true
|
|
rulefile=""
|
|
rule_exclude_q=""
|
|
rulingsfile=""
|
|
rulings_q=""
|
|
if [ -n "$session_id" ]; then
|
|
safe_sid=$(printf '%s' "$session_id" | tr -c 'A-Za-z0-9._-' '_')
|
|
rulefile="$state_dir/${safe_sid}.rules.ids"
|
|
# Ageing, not a flat read (#3751): an id named two hours ago is not one the
|
|
# session is still holding. scribe_rules_live carries the reasoning.
|
|
rule_seen=$(scribe_rules_live "$rulefile")
|
|
[ -n "$rule_seen" ] && rule_exclude_q="&exclude_rule_ids=${rule_seen}"
|
|
# What the session actually OPENED, as against what it was shown (#4100).
|
|
rule_exclude_q="${rule_exclude_q}$(scribe_held_query "$state_dir/${safe_sid}.opened.ids")"
|
|
# The Systems whose rulings were shown in full — shared with the write-path
|
|
# hook, for the reason the rule file is.
|
|
rulingsfile="$state_dir/${safe_sid}.rulings.ids"
|
|
rulings_q=$(scribe_rulings_query "$rulingsfile")
|
|
fi
|
|
|
|
# `|| exit 0` here, unlike the prior-art hook: there is no local arm whose
|
|
# finding would be discarded, and an outage line before every command is worse
|
|
# than silence. See the header.
|
|
body=$(curl -fsS --max-time 5 \
|
|
-H "Authorization: Bearer ${token}" \
|
|
"${url%/}/api/plugin/tool-rules?tool=${tool_enc}&command=${cmd_enc}${repo_q}${where_q}${rule_exclude_q}${rulings_q}" 2>/dev/null) || exit 0
|
|
|
|
body_flat=$(printf '%s' "$body" | scribe_json_flat)
|
|
context=$(scribe_json_pick "$body_flat" '.context')
|
|
|
|
# Remember what was named so it is not repeated this session. BEFORE the
|
|
# checkpoint branch and before the empty-context exit: the ledger records what
|
|
# the server chose to surface, which happened whichever way this hook then
|
|
# renders it. Doing it inside one branch is how the two arms' ledgers came to
|
|
# disagree once already.
|
|
if [ -n "$rulefile" ]; then
|
|
scribe_json_list "$body_flat" '.rule_ids' | scribe_rules_append "$rulefile"
|
|
fi
|
|
if [ -n "$rulingsfile" ]; then
|
|
scribe_json_list "$body_flat" '.ruling_system_ids' >> "$rulingsfile" || true
|
|
fi
|
|
|
|
# ── The pre-act checkpoint (#4214, milestone 419) ────────────────────────
|
|
#
|
|
# WHY THIS ARM AND NOT THE WRITE PATH. scribe_prior_art.sh carries an explicit,
|
|
# tested property that it never returns a permissionDecision — a recall aid may
|
|
# not stand in the way of a write, which is the operator's decision and is
|
|
# guarded by test_hook_never_returns_a_permission_decision. No equivalent
|
|
# decision covers this arm, and the misses that motivated the milestone on the
|
|
# command side are the ones a stop actually reaches: a commit message asserting
|
|
# what CI said, a verification script that checks nothing.
|
|
#
|
|
# WHAT THE STOP IS FOR. Everything else this plugin emits is additionalContext,
|
|
# which Claude Code delivers alongside the tool RESULT — so the rule is read
|
|
# after the call is written and reads as commentary on a decision already made.
|
|
# That is milestone 419's central finding. A deny returns the reason to the
|
|
# model with the call unrun, so the rule's own text can be read before the act
|
|
# exists. It costs the operator nothing: no prompt reaches them, and the model
|
|
# clears it by reading one record and re-submitting.
|
|
#
|
|
# It cannot recur. `scribe_checkpoint_allowed` holds at most one act per rule
|
|
# and at most five per session, so the worst case of a mis-set floor is a noisy
|
|
# session rather than one that cannot move.
|
|
cp_rule=$(scribe_json_pick "$body_flat" '.checkpoint.rule_id')
|
|
cp_reason=$(scribe_json_pick "$body_flat" '.checkpoint.reason')
|
|
if [ -n "$cp_rule" ] && [ -n "$cp_reason" ] && [ -n "$session_id" ]; then
|
|
if scribe_checkpoint_allowed "$state_dir/${safe_sid}.checkpoint.ids" "$cp_rule"; then
|
|
scribe_json_deny PreToolUse "$cp_reason"
|
|
exit 0
|
|
fi
|
|
fi
|
|
|
|
[ -n "$context" ] || exit 0
|
|
scribe_json_out PreToolUse "$context"
|
|
exit 0
|