devrites 2.6.1 → 3.0.1

package/pack/.claude/skills/devrites-lib/scripts/spec-validate.sh

@@ -1,130 +0,0 @@
-#!/usr/bin/env bash
-# Spec-grammar validator — deterministic, zero-token lint of the structured
-# Requirement/Scenario acceptance grammar (rules/spec-grammar.md) in a spec.md.
-# Turns "are the behavioral requirements well-formed?" into an exit code instead
-# of prose the model walks by hand — the spec-side mirror of check-acceptance.sh
-# (which grades the SAME [ACn] ids against seal.md at the end of the lifecycle).
-#
-# Grammar checked (only when the spec opts into the structured form):
-#   ### Requirement: <name>     — must carry a SHALL/MUST statement (header or body)
-#                               — must own >=1 #### Scenario; header names unique
-#   #### Scenario: <name>       — must carry both a WHEN and a THEN line
-# A spec with ZERO `### Requirement:` headers uses the simple flat-bullet form
-# (- [ ] [AC1] ...) — valid, and this validator no-ops (exit 0). Absence is never
-# a failure, the same discipline as the principles gate. The grammar is opt-in and
-# recommended for behavioral / high-risk requirements (progressive rigor).
-#
-# Usage: spec-validate.sh <workspace-dir | spec.md path>
-# Exit:  0 valid (or no structured requirements — nothing to lint) ·
-#        1 grammar violation(s) · 2 usage · 5 missing spec.md
-#
-# [ACn] compatibility: tag each scenario's checkable line with an [ACn] id so the
-# same criterion is graded at seal by check-acceptance.sh. This validator checks
-# SHAPE, not proof; the two compose, they don't overlap.
-
-set -euo pipefail
-
-arg="${1:-}"
-if [ -z "$arg" ]; then
-  printf 'usage: spec-validate.sh <workspace-dir | spec.md path>\n' >&2
-  exit 2
-fi
-
-if [ -d "$arg" ]; then
-  spec="$arg/spec.md"
-elif [ -f "$arg" ]; then
-  spec="$arg"
-else
-  printf 'spec-validate: no such workspace or file: %s\n' "$arg" >&2
-  exit 2
-fi
-[ -f "$spec" ] || { printf 'spec-validate: no spec.md at %s\n' "$spec" >&2; exit 5; }
-
-# Parse the structured grammar in one awk pass. Emits ERROR:/WARN: finding lines
-# and a trailing "__SUMMARY__ <requirements> <scenarios>" line. BSD/GNU awk safe:
-# tolower() is POSIX; no IGNORECASE, no gensub. Keyword matches are case-sensitive
-# on purpose — the grammar mandates uppercase SHALL / MUST / WHEN / THEN.
-findings="$(awk -v FILE="$spec" '
-  function close_scenario() {
-    if (inScenario) {
-      if (!scenWhen) { print "ERROR:" FILE ": Requirement \"" curReq "\" > Scenario \"" scenName "\" (line " scenLine ") has no WHEN line"; }
-      if (!scenThen) { print "ERROR:" FILE ": Requirement \"" curReq "\" > Scenario \"" scenName "\" (line " scenLine ") has no THEN line"; }
-      inScenario = 0
-    }
-  }
-  function close_requirement() {
-    close_scenario()
-    if (curReq != "") {
-      if (!sawShall) { print "ERROR:" FILE ": Requirement \"" curReq "\" (line " reqLine ") has no SHALL/MUST statement"; }
-      if (scenInReq == 0) {
-        if (looseWhenThen) { print "ERROR:" FILE ": Requirement \"" curReq "\" (line " reqLine ") has WHEN/THEN lines but no \"#### Scenario:\" header — wrap them in a scenario"; }
-        else { print "ERROR:" FILE ": Requirement \"" curReq "\" (line " reqLine ") has no \"#### Scenario:\" block"; }
-      }
-    }
-  }
-  /^[[:space:]]*###[[:space:]]+[Rr]equirement:/ {
-    close_requirement()
-    reqCount++
-    name = $0
-    sub(/^[[:space:]]*###[[:space:]]+[Rr]equirement:[[:space:]]*/, "", name)
-    sub(/[[:space:]]+$/, "", name)
-    curReq = name; reqLine = NR
-    sawShall = ($0 ~ /(^|[^A-Za-z])(SHALL|MUST)([^A-Za-z]|$)/) ? 1 : 0
-    scenInReq = 0; looseWhenThen = 0
-    key = tolower(name)
-    if (key in seen) { print "ERROR:" FILE ": duplicate Requirement header \"" name "\" (lines " seen[key] " and " NR ") — headers must be unique"; }
-    else { seen[key] = NR }
-    next
-  }
-  /^[[:space:]]*####[[:space:]]+[Ss]cenario:/ {
-    close_scenario()
-    if (curReq == "") { print "ERROR:" FILE ": Scenario at line " NR " is not under any \"### Requirement:\""; }
-    sName = $0
-    sub(/^[[:space:]]*####[[:space:]]+[Ss]cenario:[[:space:]]*/, "", sName)
-    sub(/[[:space:]]+$/, "", sName)
-    inScenario = 1; scenCount++; scenInReq++
-    scenName = sName; scenLine = NR; scenWhen = 0; scenThen = 0
-    next
-  }
-  {
-    if (curReq != "") {
-      if ($0 ~ /(^|[^A-Za-z])(SHALL|MUST)([^A-Za-z]|$)/) { sawShall = 1 }
-      hasWhen = ($0 ~ /(^|[^A-Za-z])WHEN([^A-Za-z]|$)/)
-      hasThen = ($0 ~ /(^|[^A-Za-z])THEN([^A-Za-z]|$)/)
-      if (inScenario) {
-        if (hasWhen) { scenWhen = 1 }
-        if (hasThen) { scenThen = 1 }
-      } else if (hasWhen || hasThen) {
-        looseWhenThen = 1
-      }
-    }
-  }
-  END { close_requirement(); print "__SUMMARY__ " reqCount+0 " " scenCount+0 }
-' "$spec")"
-
-summary="$(printf '%s\n' "$findings" | grep '^__SUMMARY__' || true)"
-reqs="$(printf '%s' "$summary" | awk '{print $2+0}')"
-scens="$(printf '%s' "$summary" | awk '{print $3+0}')"
-problems="$(printf '%s\n' "$findings" | grep -E '^(ERROR|WARN):' || true)"
-errs="$(printf '%s\n' "$findings" | grep -c '^ERROR:' || true)"
-
-rel="${spec#"$PWD"/}"
-
-if [ "$reqs" -eq 0 ]; then
-  printf 'spec-validate: %s uses the simple acceptance form (no "### Requirement:" blocks) — nothing to lint\n' "$rel"
-  exit 0
-fi
-
-if [ -n "$problems" ]; then
-  printf '%s\n' "$problems" >&2
-fi
-
-if [ "$errs" -gt 0 ]; then
-  printf 'spec-validate: %s — %d requirement(s) / %d scenario(s); %d grammar error(s) (see rules/spec-grammar.md)\n' \
-    "$rel" "$reqs" "$scens" "$errs" >&2
-  exit 1
-fi
-
-printf 'spec-validate: OK — %s: %d requirement(s) / %d scenario(s) well-formed (SHALL + WHEN/THEN, unique headers)\n' \
-  "$rel" "$reqs" "$scens"
-exit 0

package/pack/.claude/skills/devrites-lib/scripts/stuck.sh

@@ -1,67 +0,0 @@
-#!/usr/bin/env bash
-# stuck.sh — loop detector for the unattended build. The slice-wright or orchestrator
-# appends one record per tool action; `check` flags the semantic-repeat patterns that
-# mean the agent is stuck burning tokens (the #1 silent AFK failure mode): the same
-# action repeating, an action<->error ping-pong, or one action dominating the window.
-# A detected loop pauses the build even under AFK (rules/afk-hitl.md). Deterministic;
-# matching is by (tool,target) hash, timestamps ignored.
-#
-#   stuck.sh log   <slug> <tool> [target]   # append one action record (caller)
-#   stuck.sh check <slug> [window]          # non-zero if the recent window looks stuck
-#
-# The log lives at .devrites/work/<slug>/action.log as "<epoch> <tool> <sha1>" lines.
-#
-# Exit codes:
-#   0  ok — not stuck (or logging, or no workspace: never fail the caller on log)
-#   2  bad args
-#   3  STUCK — the recent window is a loop: stop and escalate to a blocking question
-set -u
-
-cmd="${1:-}"; slug="${2:-}"
-[ -n "$cmd" ] && [ -n "$slug" ] || { echo "usage: stuck.sh log|check <slug> [...]" >&2; exit 2; }
-
-dir=".devrites/work/$slug"
-log="$dir/action.log"
-
-hash_of() {
-  if command -v sha1sum >/dev/null 2>&1; then
-    printf '%s' "$1" | sha1sum | awk '{print $1}'
-  else
-    printf '%s' "$1" | shasum | awk '{print $1}'
-  fi
-}
-
-case "$cmd" in
-  log)
-    tool="${3:-}"; target="${4:-}"
-    [ -n "$tool" ] || { echo "usage: stuck.sh log <slug> <tool> [target]" >&2; exit 2; }
-    [ -d "$dir" ] || exit 0
-    printf '%s %s %s\n' "$(date +%s)" "$tool" "$(hash_of "$tool|$target")" >> "$log"
-    ;;
-  check)
-    win="${3:-4}"
-    [ -f "$log" ] || { echo "stuck: no actions logged — not stuck."; exit 0; }
-    awk -v win="$win" '
-      { h[NR]=$3 }
-      END {
-        if (NR < win) { print "stuck: only " NR " action(s) — not stuck."; exit 0 }
-        same=1
-        for (i=NR-win+1; i<=NR; i++) if (h[i]!=h[NR]) { same=0; break }
-        if (same) { print "stuck: last " win " actions identical — STUCK."; exit 3 }
-        if (NR>=6) {
-          pp=1
-          for (i=NR-5; i<=NR; i++) { e=(((NR-i)%2)==0)?h[NR]:h[NR-1]; if (h[i]!=e) { pp=0; break } }
-          if (pp && h[NR]!=h[NR-1]) { print "stuck: A<->B ping-pong over last 6 — STUCK."; exit 3 }
-        }
-        if (NR>=8) {
-          for (i=NR-7;i<=NR;i++) c[h[i]]++
-          top=0; for (k in c) if (c[k]>top) top=c[k]
-          if (top>=6) { print "stuck: one action " top "/8 of recent window — STUCK."; exit 3 }
-        }
-        print "stuck: recent window varied — not stuck."
-      }
-    ' "$log"
-    ;;
-  *)
-    echo "usage: stuck.sh log|check <slug> [...]" >&2; exit 2 ;;
-esac

package/pack/.claude/skills/devrites-lib/scripts/test-integrity.sh

@@ -1,87 +0,0 @@
-#!/usr/bin/env bash
-# test-integrity.sh — anti-reward-hacking gate for /rite-build, /rite-prove, /rite-seal.
-# Proves the slice did not reach green by WEAKENING its tests. Diffs the test files
-# against the slice base (the reconcile.sh snapshot tree if present, else HEAD) and
-# flags any test file that was deleted, had a skip/focus marker added, or lost
-# assertions. Turns "never weaken a failing test" (rules/testing.md) into an exit code
-# instead of a prose promise the model can rationalize past — same doctrine as
-# reconcile.sh / readiness.sh. Read-only.
-#
-# Usage:
-#   test-integrity.sh [slug]            (alias: test-integrity.sh check [slug])
-#     slug — optional; defaults to .devrites/ACTIVE
-#
-# Exit codes:
-#   0  clean — no test file deleted, skipped, or de-asserted since the base
-#   2  no active workspace / bad args
-#   3  WEAKENED — a test was deleted, skip/.only-marked, or lost assertions: Critical.
-#      Revert the weakening; fix the code (or route the change as a blocking question).
-set -u
-
-a1="${1:-}"
-case "$a1" in
-  check) slug="${2:-}" ;;
-  ""|-*) slug="" ;;
-  *) slug="$a1" ;;
-esac
-[ -n "$slug" ] || slug="$(cat .devrites/ACTIVE 2>/dev/null || true)"
-[ -n "$slug" ] || { echo "test-integrity: no active workspace (pass a slug or set .devrites/ACTIVE)." >&2; exit 2; }
-
-d=".devrites/work/$slug"
-[ -d "$d" ] || { echo "test-integrity: no workspace at $d." >&2; exit 2; }
-
-root="$(git rev-parse --show-toplevel 2>/dev/null || true)"
-if [ -z "$root" ]; then
-  echo "test-integrity: not a git repo — gate skipped, eyeball the test diff by hand." >&2
-  exit 0
-fi
-
-base_tree="$(cat "$d/.reconcile-base" 2>/dev/null || true)"
-ref="${base_tree:-HEAD}"
-
-is_test_file() {
-  case "$1" in
-    *_test.*|*.test.*|*.spec.*|*_spec.*|*Test.*|*Tests.*|*Spec.*) return 0 ;;
-    */__tests__/*|*/tests/*|*/test/*|*/spec/*|test_*) return 0 ;;
-    *test*|*spec*) return 0 ;;
-  esac
-  return 1
-}
-
-SKIP_RE='(\bit|\bdescribe|\btest|\bcontext)\.skip|\bxit\b|\bxdescribe\b|\.only\b|@pytest\.mark\.skip|@unittest\.skip|\bpytest\.skip\b|t\.Skip\(|#\[ignore\]|@Ignore\b|@Disabled\b|\bfdescribe\b|\bfit\('
-ASSERT_RE='assert|expect\(|\.should\b|\brequire\.|EXPECT_|ASSERT_|XCTAssert|t\.Error|t\.Fatal'
-
-count() { printf '%s' "${1:-}" | grep -oE "$2" 2>/dev/null | wc -l | tr -d ' '; }
-
-weak=0
-report=""
-
-while IFS= read -r f; do
-  [ -z "$f" ] && continue
-  is_test_file "$f" || continue
-  old="$(git -C "$root" show "$ref:$f" 2>/dev/null || true)"
-  [ -n "$old" ] || continue           # new test file — adding tests is never a weakening
-  if [ ! -f "$root/$f" ]; then
-    weak=$((weak+1)); report="${report}  - ${f}: test file DELETED
-"; continue
-  fi
-  new="$(cat "$root/$f")"
-  os="$(count "$old" "$SKIP_RE")"; ns="$(count "$new" "$SKIP_RE")"
-  oa="$(count "$old" "$ASSERT_RE")"; na="$(count "$new" "$ASSERT_RE")"
-  if [ "${ns:-0}" -gt "${os:-0}" ]; then
-    weak=$((weak+1)); report="${report}  - ${f}: skip/focus markers added (${os}→${ns})
-"
-  elif [ "${na:-0}" -lt "${oa:-0}" ]; then
-    weak=$((weak+1)); report="${report}  - ${f}: assertions dropped (${oa}→${na})
-"
-  fi
-done < <(git -C "$root" diff --name-only "$ref" 2>/dev/null)
-
-if [ "$weak" -gt 0 ]; then
-  echo "test-integrity: WEAKENED — $weak test file(s) lost coverage since the slice base:" >&2
-  printf '%s' "$report" >&2
-  echo "A test weakened to pass a gate is a Critical finding. Revert it; fix the code or raise a blocking question." >&2
-  exit 3
-fi
-echo "test-integrity: OK — no test deleted, skipped, or de-asserted since the base."
-exit 0

package/pack/.claude/skills/devrites-lib/scripts/tick-afk.sh

@@ -1,52 +0,0 @@
-#!/usr/bin/env bash
-# Decrement the AFK slice budget in state.md — called by /rite-build's record
-# step (workflow step 6) after a slice is built under AFK. The mutable remaining count lives in
-# state.md (`AFK slices remaining: <n>`); `.devrites/AFK`'s `max_slices` is the
-# read-only initial budget and is never rewritten in place.
-#
-# Usage: tick-afk.sh <state.md path>
-#
-# Reads "AFK slices remaining: <n>", decrements it, writes it back in place,
-# and prints the new value.
-#
-# Exit codes:
-#   0  decremented, budget remains (new value > 0); or no AFK budget set (no-op)
-#   3  budget exhausted (new value reached 0) — caller must force a HITL stop
-
-set -euo pipefail
-
-sfile="${1:-}"
-if [ -z "$sfile" ] || [ ! -f "$sfile" ]; then
-  printf 'tick-afk: state.md not found at %s\n' "${sfile:-<unset>}" >&2
-  exit 5
-fi
-
-# Defensive: a state.md without the field means no AFK budget is in effect.
-# Don't invent one; let the build proceed (HITL or unbudgeted AFK).
-# state.md renders fields as markdown bullets ("- AFK slices remaining: <n>").
-# Tolerate an optional leading "- " and a trailing " | none" / comment.
-cur="$(awk 'match($0, /^[[:space:]]*-?[[:space:]]*AFK slices remaining:[[:space:]]*/) {
-              rest = substr($0, RLENGTH + 1); sub(/[[:space:]].*$/, "", rest); print rest; exit }' "$sfile")"
-if [ -z "$cur" ] || [ "$cur" = "none" ]; then
-  printf 'tick-afk: no "AFK slices remaining" budget set in %s — no-op\n' "$sfile"
-  exit 0
-fi
-if ! printf '%s' "$cur" | grep -qE '^[0-9]+$'; then
-  printf 'tick-afk: "AFK slices remaining" is not a number (%s) in %s\n' "$cur" "$sfile" >&2
-  exit 5
-fi
-
-new=$(( cur - 1 ))
-[ "$new" -lt 0 ] && new=0
-
-# Rewrite the field in place. Awk rewrites the file atomically via a temp file.
-awk -v n="$new" '
-  /^[[:space:]]*-?[[:space:]]*AFK slices remaining:/ { print "- AFK slices remaining: " n; next }
-  { print }
-' "$sfile" > "$sfile.tmp" && mv "$sfile.tmp" "$sfile"
-
-printf '%s\n' "$new"
-
-# Budget exhausted — force the caller to stop and revert to HITL.
-[ "$new" -le 0 ] && exit 3
-exit 0

package/scripts/merge-codex-hooks.mjs

@@ -1,78 +0,0 @@
-#!/usr/bin/env node
-import fs from 'node:fs';
-
-const [, , mode, ...args] = process.argv;
-let existingPath;
-let devritesPath;
-let outPath;
-
-if (mode === 'merge') {
-  [existingPath, devritesPath, outPath] = args;
-} else if (mode === 'strip') {
-  [existingPath, outPath] = args;
-}
-
-if (!['merge', 'strip'].includes(mode) || !existingPath || !outPath || (mode === 'merge' && !devritesPath)) {
-  console.error('usage: merge-codex-hooks.mjs merge EXISTING DEVRITES OUT');
-  console.error('   or: merge-codex-hooks.mjs strip EXISTING OUT');
-  process.exit(2);
-}
-
-function readJson(path) {
-  return JSON.parse(fs.readFileSync(path, 'utf8'));
-}
-
-function isDevRitesHook(value) {
-  const s = JSON.stringify(value);
-  return s.includes('.codex/hooks/devrites-') || s.includes('DevRites:') || s.includes('DEVRITES_');
-}
-
-function stripDevRitesHooks(config) {
-  if (!config || typeof config !== 'object' || Array.isArray(config)) return {};
-  const next = { ...config };
-  if (typeof next.$comment === 'string' && next.$comment.includes('DevRites hooks for Codex')) {
-    delete next.$comment;
-  }
-  const hooks = next.hooks && typeof next.hooks === 'object' && !Array.isArray(next.hooks)
-    ? { ...next.hooks }
-    : {};
-
-  for (const [event, entries] of Object.entries(hooks)) {
-    const kept = Array.isArray(entries) ? entries.filter((entry) => !isDevRitesHook(entry)) : entries;
-    if (Array.isArray(kept) && kept.length === 0) {
-      delete hooks[event];
-    } else {
-      hooks[event] = kept;
-    }
-  }
-
-  if (Object.keys(hooks).length) {
-    next.hooks = hooks;
-  } else {
-    delete next.hooks;
-  }
-  return next;
-}
-
-const existing = stripDevRitesHooks(readJson(existingPath));
-
-if (mode === 'merge') {
-  const devrites = readJson(devritesPath);
-  const hooks = existing.hooks && typeof existing.hooks === 'object' && !Array.isArray(existing.hooks)
-    ? existing.hooks
-    : {};
-  const devritesHooks = devrites.hooks && typeof devrites.hooks === 'object' && !Array.isArray(devrites.hooks)
-    ? devrites.hooks
-    : {};
-
-  for (const [event, entries] of Object.entries(devritesHooks)) {
-    hooks[event] = [
-      ...(Array.isArray(hooks[event]) ? hooks[event] : []),
-      ...(Array.isArray(entries) ? entries : []),
-    ];
-  }
-
-  existing.hooks = hooks;
-}
-
-fs.writeFileSync(outPath, `${JSON.stringify(existing, null, 2)}\n`);