@erclx/canon 5.12.0 → 5.14.0

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
-}

package/scripts/tooling/verify.sh

@@ -1,184 +0,0 @@
-#!/usr/bin/env bash
-set -e
-set -o pipefail
-
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-PROJECT_ROOT="${PROJECT_ROOT:-$(dirname "$(dirname "$SCRIPT_DIR")")}"
-
-source "$PROJECT_ROOT/scripts/lib/ui.sh"
-source "$PROJECT_ROOT/scripts/lib/tooling.sh"
-
-show_help() {
-  echo -e "${GREY}┌${NC}"
-  echo -e "${GREY}├${NC} ${WHITE}Usage:${NC} canon tooling verify <stack> [options]"
-  echo -e "${GREY}│${NC}"
-  echo -e "${GREY}│${NC}  ${WHITE}Options:${NC}"
-  echo -e "${GREY}│${NC}    --keep       ${GREY}# Keep tmp dir after run for inspection${NC}"
-  echo -e "${GREY}│${NC}    -h, --help   ${GREY}# Show this help message${NC}"
-  echo -e "${GREY}│${NC}"
-  echo -e "${GREY}│${NC}  Scaffolds <stack> into .canon/tmp/runs/verify-<stack>/, syncs the full"
-  echo -e "${GREY}│${NC}  layer chain, and runs check + test:e2e + screenshot."
-  echo -e "${GREY}└${NC}"
-  exit 0
-}
-
-read_manifest_field() {
-  local toml="$1"
-  local section="$2"
-  local field="$3"
-  awk -v s="$section" -v f="$field" '
-    $0 == "[" s "]" { in_section = 1; next }
-    in_section && /^\[/ { exit }
-    in_section && match($0, "^" f "[[:space:]]*=") {
-      val = substr($0, RLENGTH + 1)
-      sub(/^[[:space:]]+/, "", val)
-      sub(/^"/, "", val)
-      sub(/"$/, "", val)
-      print val
-      exit
-    }
-  ' "$toml"
-}
-
-run_phase() {
-  local name="$1"
-  shift
-  log_step "$name"
-  if "$@" >/tmp/verify-phase.log 2>&1; then
-    log_info "$name passed"
-    RESULTS+=("$name:pass")
-    return 0
-  fi
-  log_warn "$name failed"
-  tail -20 /tmp/verify-phase.log >&2
-  RESULTS+=("$name:fail")
-  FAILED=1
-  return 1
-}
-
-main() {
-  local stack=""
-  local keep=0
-
-  while [[ $# -gt 0 ]]; do
-    case "$1" in
-    -h | --help) show_help ;;
-    --keep)
-      keep=1
-      shift
-      ;;
-    -*)
-      log_error "Unknown option: $1"
-      ;;
-    *)
-      if [ -z "$stack" ]; then
-        stack="$1"
-        shift
-      else
-        log_error "Unexpected argument: $1"
-      fi
-      ;;
-    esac
-  done
-
-  [ -z "$stack" ] && log_error "Stack required. See --help."
-
-  export CI=1
-
-  if is_tooling_stack_excluded "$stack"; then
-    log_error "Stack '$stack' is excluded from tooling."
-  fi
-
-  local manifest="$PROJECT_ROOT/tooling/$stack/manifest.toml"
-  [ ! -f "$manifest" ] && log_error "No manifest at $manifest"
-
-  local scaffold
-  scaffold=$(read_manifest_field "$manifest" "stack" "scaffold")
-  [ -z "$scaffold" ] && log_error "Stack '$stack' has no scaffold command in manifest."
-
-  local prepare
-  prepare=$(read_manifest_field "$manifest" "verify" "prepare")
-
-  open_timeline "canon tooling verify $stack"
-  trap close_timeline EXIT
-
-  local tmp_root="$PROJECT_ROOT/.canon/tmp/runs"
-  local tmp_dir="$tmp_root/verify-$stack"
-
-  mkdir -p "$tmp_root"
-  rm -rf "$tmp_dir"
-
-  local project_name="verify-$stack"
-  local scaffold_cmd="${scaffold//\{\{name\}\}/$project_name}"
-
-  RESULTS=()
-  FAILED=0
-
-  log_step "Scaffolding $stack"
-  (cd "$tmp_root" && eval "$scaffold_cmd") >/tmp/verify-scaffold.log 2>&1 || {
-    log_warn "Scaffold failed"
-    tail -20 /tmp/verify-scaffold.log >&2
-    FAILED=1
-  }
-
-  if [ ! -d "$tmp_dir" ]; then
-    log_error "Scaffold did not produce $tmp_dir"
-  fi
-
-  (cd "$tmp_dir" && git init -q && git add . && git commit -m "chore: verify scaffold" -q --no-verify)
-
-  if [ -n "$prepare" ]; then
-    run_phase "Prepare" bash -c "cd '$tmp_dir' && $prepare"
-  fi
-
-  log_info "Sync resolves via bun $PROJECT_ROOT/src/cli.ts, not PATH canon"
-  run_phase "Sync" bash -c "cd '$tmp_dir' && CANON_NON_INTERACTIVE=1 bun '$PROJECT_ROOT/src/cli.ts' tooling sync $stack . --write"
-
-  if [ -f "$tmp_dir/package.json" ]; then
-    run_phase "lint:fix" bash -c "cd '$tmp_dir' && bun run lint:fix"
-    run_phase "check" bash -c "cd '$tmp_dir' && bun run check"
-
-    if grep -q '"test:e2e"' "$tmp_dir/package.json"; then
-      run_phase "test:e2e" bash -c "cd '$tmp_dir' && bun run test:e2e"
-    fi
-
-    if grep -q '"screenshot"' "$tmp_dir/package.json"; then
-      if run_phase "screenshot" bash -c "cd '$tmp_dir' && timeout 60 bun run screenshot"; then
-        local shots
-        shots=$(find "$tmp_dir/screenshots" -type f -name '*.png' 2>/dev/null | wc -l)
-        if [ "$shots" -eq 0 ]; then
-          log_warn "screenshot produced no png files"
-          RESULTS+=("screenshot-artifacts:fail")
-          FAILED=1
-        else
-          RESULTS+=("screenshot-artifacts:pass")
-        fi
-      fi
-    fi
-  fi
-
-  log_step "Results"
-  for r in "${RESULTS[@]}"; do
-    local name="${r%:*}"
-    local status="${r##*:}"
-    if [ "$status" = "pass" ]; then
-      log_info "$name"
-    else
-      log_warn "$name"
-    fi
-  done
-
-  if [ "$keep" -eq 0 ] && [ "$FAILED" -eq 0 ]; then
-    rm -rf "$tmp_dir"
-  else
-    log_info "Kept $tmp_dir"
-  fi
-
-  if [ "$FAILED" -ne 0 ]; then
-    exit 1
-  fi
-}
-
-if [[ "${BASH_SOURCE[0]}" == "${0}" ]]; then
-  main "$@"
-fi