bvandeusen
e0328f2b1c
CI & Build / Python lint (push) Successful in 4s
CI & Build / integration (push) Successful in 27s
CI & Build / TypeScript typecheck (push) Successful in 35s
CI & Build / Python tests (push) Successful in 47s
CI & Build / Build & push image (push) Successful in 1m2s
The milestone headline. Auto-inject fires on the operator's prompt; the moment reuse is actually lost is later, when the agent decides mid-task to write a helper. A PreToolUse hook on Write|Edit now fires there. Channel: `additionalContext` with NO permissionDecision, so the note reaches Claude beside the tool result and the write is never blocked — a recall aid must not be able to stop the operator's work. Plain stdout would have been invisible to the model, and deny/ask would have made a nudge into a gate. Two arms, different in kind: - BY PLACE — a snippet recorded at this path (or its directory) is prior art by definition, not resemblance, so it is neither scored nor thresholded. This is what #2083's reverse lookup was built to answer. - BY MEANING — semantic search restricted to snippets (new `note_type` filter on semantic_search_notes) over the code about to be written. Place ranks first; the top-k cap spans both arms. Gates carried over from milestone 93 verbatim: threshold, margin, session dedup, titles-never-bodies. Own `source='write_path'` in retrieval_logs so precision is tunable separately — the docstring records that the place arm is unlogged and hands that to #2085. Its own on/off in Settings but the SAME threshold/top-k: one "how loud may Scribe be" knob is easier to reason about than two that drift, and splitting them later is then a data-backed change rather than a guess. Details worth keeping: the hook sends a REPO-RELATIVE path because that is how locations are recorded; the git remote resolves to a project and is never used as the location `repo` filter (different namespaces, would silently match nothing); the endpoint stays a GET because a read-scoped API key cannot POST and every other hook depends on that. plugin.json 0.1.17 -> 0.1.18. Refs #2082, milestone #232.
120 lines
5.3 KiB
Bash
Executable File
120 lines
5.3 KiB
Bash
Executable File
#!/usr/bin/env bash
|
|
# Scribe plugin — PreToolUse write-path trigger (prior-art recall).
|
|
#
|
|
# Auto-inject (scribe_autoinject.sh) fires on the operator's prompt. The moment
|
|
# reuse is actually lost is later: when the AGENT decides mid-task to write a
|
|
# helper. This hook fires there — on Write/Edit — and asks the operator's Scribe
|
|
# instance what prior art is already recorded for the target file: a snippet at
|
|
# that path or in its directory, plus snippets resembling the code about to be
|
|
# written. Titles + ids only, never bodies.
|
|
#
|
|
# NEVER BLOCKS. It returns `additionalContext` with no `permissionDecision`, so
|
|
# the write proceeds untouched and Claude sees the note beside the tool result.
|
|
# Any failure — unconfigured, unreachable, malformed — exits 0 in silence. A
|
|
# recall aid must not be able to stop the operator's work.
|
|
#
|
|
# Config (same as the other hooks), exported to the hook by Claude Code:
|
|
# CLAUDE_PLUGIN_OPTION_api_endpoint base URL, no trailing slash
|
|
# CLAUDE_PLUGIN_OPTION_api_token fmcp_ API key (sensitive)
|
|
# SCRIBE_URL / SCRIBE_TOKEN override for the settings.json dogfooding path.
|
|
set -uo pipefail
|
|
|
|
command -v jq >/dev/null 2>&1 || exit 0
|
|
command -v curl >/dev/null 2>&1 || exit 0
|
|
|
|
# PreToolUse delivers { session_id, cwd, tool_name, tool_input: {...}, ... }
|
|
event=$(cat 2>/dev/null || true)
|
|
file_path=$(printf '%s' "$event" | jq -r '.tool_input.file_path // empty' 2>/dev/null) || exit 0
|
|
session_id=$(printf '%s' "$event" | jq -r '.session_id // empty' 2>/dev/null) || session_id=""
|
|
event_cwd=$(printf '%s' "$event" | jq -r '.cwd // empty' 2>/dev/null) || event_cwd=""
|
|
|
|
[ -n "$file_path" ] || exit 0
|
|
|
|
# The code about to be written. Write and Edit name this field differently, and
|
|
# the names have changed across Claude Code versions — take whichever is present
|
|
# rather than betting on one shape.
|
|
code=$(printf '%s' "$event" | jq -r '
|
|
.tool_input.content // .tool_input.file_content //
|
|
.tool_input.new_string // .tool_input.new_str // empty' 2>/dev/null) || code=""
|
|
|
|
# Skip formats that hold prose or data rather than reusable code. Purely to
|
|
# avoid a pointless round-trip — the server would return nothing for these
|
|
# anyway. Config formats are NOT skipped: a CI workflow or a compose file is
|
|
# often exactly the thing worth reusing.
|
|
case "$file_path" in
|
|
*.md|*.mdx|*.txt|*.rst|*.json|*.lock|*.log|*.csv|*.tsv|*.svg|*.png|*.jpg|*.jpeg|*.gif|*.ico|*.pdf)
|
|
exit 0 ;;
|
|
esac
|
|
|
|
url=${SCRIBE_URL:-${CLAUDE_PLUGIN_OPTION_api_endpoint:-}}
|
|
token=${SCRIBE_TOKEN:-${CLAUDE_PLUGIN_OPTION_api_token:-}}
|
|
# Guard against an unexpanded ${...} placeholder arriving as a literal.
|
|
case "$url" in *'${'*) url="" ;; esac
|
|
case "$token" in *'${'*) token="" ;; esac
|
|
# Unconfigured install → silent. Prior-art recall is pure enrichment.
|
|
[ -n "$url" ] && [ -n "$token" ] || exit 0
|
|
|
|
# Snippet locations are recorded repo-relative, so send a repo-relative path —
|
|
# an absolute one would simply match nothing.
|
|
lookup_dir=$(dirname -- "$file_path" 2>/dev/null || true)
|
|
[ -d "$lookup_dir" ] || lookup_dir=${event_cwd:-${CLAUDE_PROJECT_DIR:-$PWD}}
|
|
repo_root=$(git -C "$lookup_dir" rev-parse --show-toplevel 2>/dev/null || true)
|
|
rel_path="$file_path"
|
|
if [ -n "$repo_root" ]; then
|
|
case "$file_path" in
|
|
"$repo_root"/*) rel_path="${file_path#"$repo_root"/}" ;;
|
|
esac
|
|
fi
|
|
|
|
# Cap the code sent as the semantic query. The embedder truncates at its own
|
|
# token limit well before this, so a bigger slice buys no extra signal — and the
|
|
# payload has to stay a GET (a read-scoped API key cannot POST, and every other
|
|
# plugin hook works with a read key).
|
|
q=$(printf '%s' "$code" | cut -c1-1200)
|
|
|
|
path_enc=$(printf '%s' "$rel_path" | jq -rR '@uri' 2>/dev/null) || exit 0
|
|
code_enc=$(printf '%s' "$q" | jq -rR '@uri' 2>/dev/null) || code_enc=""
|
|
|
|
# Resolve the working repo's remote so the server can scope to the bound project.
|
|
repo=$(git -C "$lookup_dir" remote get-url origin 2>/dev/null || true)
|
|
repo_q=""
|
|
if [ -n "$repo" ]; then
|
|
enc=$(printf '%s' "$repo" | jq -rR '@uri' 2>/dev/null) || enc=""
|
|
[ -n "$enc" ] && repo_q="&repo=${enc}"
|
|
fi
|
|
|
|
# Per-session dedup, in its own file rather than sharing auto-inject's. Each
|
|
# surface shows a given snippet at most once per session, but they don't silence
|
|
# each other: a title that flew past in a prompt menu twenty turns ago is
|
|
# exactly what should reappear at the moment the duplicate is being written.
|
|
state_dir="${TMPDIR:-/tmp}/scribe-priorart"
|
|
mkdir -p "$state_dir" 2>/dev/null || true
|
|
idfile=""
|
|
exclude_q=""
|
|
if [ -n "$session_id" ]; then
|
|
safe_sid=$(printf '%s' "$session_id" | tr -c 'A-Za-z0-9._-' '_')
|
|
idfile="$state_dir/${safe_sid}.ids"
|
|
if [ -f "$idfile" ]; then
|
|
seen=$(tr '\n' ',' < "$idfile" 2>/dev/null | sed 's/,$//')
|
|
[ -n "$seen" ] && exclude_q="&exclude_ids=${seen}"
|
|
fi
|
|
fi
|
|
|
|
body=$(curl -fsS --max-time 5 \
|
|
-H "Authorization: Bearer ${token}" \
|
|
"${url%/}/api/plugin/prior-art?path=${path_enc}&code=${code_enc}${repo_q}${exclude_q}" 2>/dev/null) || exit 0
|
|
[ -n "$body" ] || exit 0
|
|
|
|
context=$(printf '%s' "$body" | jq -r '.context // empty' 2>/dev/null) || exit 0
|
|
[ -n "$context" ] || exit 0
|
|
|
|
# Remember what was surfaced so it isn't shown again this session.
|
|
if [ -n "$idfile" ]; then
|
|
printf '%s' "$body" | jq -r '.note_ids[]? // empty' 2>/dev/null >> "$idfile" || true
|
|
fi
|
|
|
|
# No permissionDecision: this is a nudge, not a gate. The write goes ahead.
|
|
jq -n --arg c "$context" \
|
|
'{hookSpecificOutput: {hookEventName: "PreToolUse", additionalContext: $c}}'
|
|
exit 0
|