@erclx/canon 5.13.0 → 5.14.0

package/scripts/core/check-plugin-boundary.sh

@@ -1,45 +0,0 @@
-#!/usr/bin/env bash
-set -e
-set -o pipefail
-
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-PROJECT_ROOT="${PROJECT_ROOT:-$(cd "$SCRIPT_DIR/../.." && pwd)}"
-
-INTERNAL_ROOT="$PROJECT_ROOT/internal"
-PLUGIN_ROOT="$PROJECT_ROOT/claude"
-
-# `find` writes to stderr and returns non-zero for a missing root, inside a
-# process substitution whose status nothing reads. Without this the walk covers
-# nothing and the check reports the boundary clean having never measured it.
-if [ ! -d "$PLUGIN_ROOT" ]; then
-  echo "No plugin root at ${PLUGIN_ROOT#"$PROJECT_ROOT/"}, boundary unverifiable." >&2
-  exit 1
-fi
-
-# `realpath` resolves each walked path below. Absent, `set -e` aborts on the
-# substitution and the stage reports a leak for a tool that is not installed,
-# which is the same unmeasured-tree-with-a-verdict shape the guard above closes.
-if ! command -v realpath >/dev/null 2>&1; then
-  echo "realpath is not installed, boundary unverifiable." >&2
-  exit 1
-fi
-
-# The plugin reaches `standards/` through a symlink, which an
-# installer dereferences with no code in the path to filter. Walking the plugin
-# tree with symlinks followed is what an install actually copies, so resolving
-# each file and rejecting anything under `internal/` asserts the boundary at the
-# only place it can be measured.
-leaked=""
-while IFS= read -r file; do
-  resolved=$(realpath "$file")
-  case "$resolved" in
-  "$INTERNAL_ROOT"/*) leaked="$leaked  ${file#"$PROJECT_ROOT/"} -> ${resolved#"$PROJECT_ROOT/"}"$'\n' ;;
-  esac
-done < <(find -L "$PLUGIN_ROOT" -type f)
-
-if [ -n "$leaked" ]; then
-  echo "Plugin ships toolkit-internal content:" >&2
-  printf '%s' "$leaked" >&2
-  echo "Author internal content under internal/, which nothing under claude/ reaches." >&2
-  exit 1
-fi

package/scripts/core/check-seed-independence.sh

@@ -1,62 +0,0 @@
-#!/usr/bin/env bash
-set -e
-set -o pipefail
-
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-PROJECT_ROOT="${PROJECT_ROOT:-$(cd "$SCRIPT_DIR/../.." && pwd)}"
-
-source "$PROJECT_ROOT/scripts/lib/tooling.sh"
-
-TOOLKIT_TOKEN="canon"
-TOOLING_ROOT="$PROJECT_ROOT/tooling"
-
-# `find` writes to stderr and returns non-zero for a missing root, inside a
-# process substitution whose status nothing reads. Without this the walk covers
-# nothing and the check reports the seeds independent having never read one.
-if [ ! -d "$TOOLING_ROOT" ]; then
-  echo "No tooling root at ${TOOLING_ROOT#"$PROJECT_ROOT/"}, seed independence unverifiable." >&2
-  exit 1
-fi
-
-# An empty discovery is a real state rather than a broken walk, and the Seed
-# standards stage already reports it as a skip. Failing here would have the two
-# stages disagree about what the same condition means.
-seed_roots=$(collect_seed_roots)
-if [ -z "$seed_roots" ]; then
-  echo "No seed root carries .claude/ or canon/, nothing to check." >&2
-  exit 0
-fi
-
-# Markdown alone. The seed tree also ships hooks that call the toolkit CLI on
-# purpose, each reporting a named stale-index warning when the binary is absent,
-# and scoping by extension leaves them outside this walk without an exemption
-# list that would have to be maintained against them.
-cited=""
-measured=0
-while IFS= read -r seed_root; do
-  while IFS= read -r file; do
-    measured=$((measured + 1))
-    # A token followed by `/` is the tracked surface root, a folder the seed
-    # itself installs, rather than the binary. Every other spelling still
-    # reports, which keeps a verb, a plugin skill prefix, and a bare mention in.
-    while IFS= read -r hit; do
-      cited="$cited  ${file#"$PROJECT_ROOT/"}:$hit"$'\n'
-    done < <(grep -nE "${TOOLKIT_TOKEN}([^/]|$)" "$file" || true)
-  done < <(find "$PROJECT_ROOT/$seed_root" -type f -name '*.md')
-done <<<"$seed_roots"
-
-# Roots resolved and no markdown under any of them is a walk that covered
-# nothing, which is the verdict-without-a-measurement the guards above refuse for
-# a missing tree. Reporting a pass here would say the seeds cite no CLI on the
-# strength of having read no prose.
-if [ "$measured" -eq 0 ]; then
-  echo "Seed roots resolved but carry no markdown, seed independence unverifiable." >&2
-  exit 1
-fi
-
-if [ -n "$cited" ]; then
-  echo "Seed prose cites the toolkit CLI:" >&2
-  printf '%s' "$cited" >&2
-  echo "A scaffolded project may not have $TOOLKIT_TOKEN installed. State the capability the line needs rather than the binary that supplies it." >&2
-  exit 1
-fi

package/scripts/core/check-skill-paths.sh

@@ -1,24 +0,0 @@
-#!/usr/bin/env bash
-set -e
-set -o pipefail
-
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-PROJECT_ROOT="${PROJECT_ROOT:-$(cd "$SCRIPT_DIR/../.." && pwd)}"
-
-SKILLS_DIR="$PROJECT_ROOT/claude/skills"
-
-# A shipped skill runs from a target project, where the toolkit's own wiki/ does
-# not exist. Anchoring on a non-path character keeps a target's .claude/wiki/ legal.
-BANNED_PATH_PATTERN='(^|[^[:alnum:]._/-])wiki/'
-
-[ -d "$SKILLS_DIR" ] || exit 0
-
-matches=$(grep -rnE "$BANNED_PATH_PATTERN" "$SKILLS_DIR" || true)
-
-[ -z "$matches" ] && exit 0
-
-echo "Shipped skills reference a repo-local path that does not exist in a target project:"
-echo "$matches" | sed "s|^$PROJECT_ROOT/||"
-echo
-echo "Reach supporting prose through a canon docs command, a standard cited at the flat root, or inlined text."
-exit 1

package/scripts/core/list-seed-roots.sh

@@ -1,18 +0,0 @@
-#!/usr/bin/env bash
-# Prints every seed root carrying a `.claude/` or a `canon/`, one per line and
-# relative to the project root.
-#
-# The discovery rule has one definition, `collect_seed_roots` in
-# `scripts/lib/tooling.sh`, which `check-seed-independence.sh` already reads.
-# This file is the route a caller outside bash takes to that same answer, so a
-# stack seeding either root later reaches both readers and the two stages
-# measuring seed content cannot disagree about which roots exist.
-set -e
-set -o pipefail
-
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-PROJECT_ROOT="${PROJECT_ROOT:-$(cd "$SCRIPT_DIR/../.." && pwd)}"
-
-source "$PROJECT_ROOT/scripts/lib/tooling.sh"
-
-collect_seed_roots

package/scripts/lib/tooling.sh

@@ -1,37 +0,0 @@
-#!/usr/bin/env bash
-
-TOOLING_STACK_EXCLUDE=("claude")
-
-is_tooling_stack_excluded() {
-  local name="$1"
-  local excluded
-  for excluded in "${TOOLING_STACK_EXCLUDE[@]}"; do
-    if [ "$name" = "$excluded" ]; then
-      return 0
-    fi
-  done
-  return 1
-}
-
-list_tooling_stacks() {
-  local tooling_dir="${1:-$PROJECT_ROOT/tooling}"
-  local name
-  while IFS= read -r entry; do
-    name=$(basename "$entry")
-    is_tooling_stack_excluded "$name" && continue
-    echo "$name"
-  done < <(find "$tooling_dir" -mindepth 1 -maxdepth 1 -type d | sort)
-}
-
-# Seed roots that carry a `.claude/` or a `canon/`, emitted relative to
-# `PROJECT_ROOT`. Every stage measuring seed content discovers through this
-# rather than naming a stack, so a stack seeding either root later arrives
-# covered with no edit to any caller. A stack seeding only tracked surfaces
-# carries `canon/` alone, which a `.claude/` test would drop from both stages.
-collect_seed_roots() {
-  local dir
-  for dir in "$PROJECT_ROOT"/tooling/*/seeds; do
-    [ -d "$dir/.claude" ] || [ -d "$dir/canon" ] || continue
-    printf '%s\n' "${dir#"$PROJECT_ROOT"/}"
-  done
-}