@drunkcoding/agents-and-skills 0.0.25 → 0.0.27

package/plugins/team-superpower/scripts/detect-stack.sh

@@ -1,473 +0,0 @@
-#!/usr/bin/env bash
-# detect-stack.sh — best-effort filesystem detection for the team-superpower
-# stack block. Emits a YAML block (the same shape that lives inside the
-# ```team-superpower``` fence in CLAUDE.md) to stdout, plus exit codes:
-#
-#   0  confident detection (single BE candidate and/or single FE candidate)
-#   1  no stack signals found (BE absent AND FE absent) — lead should escalate
-#   2  ambiguous (multiple plausible BE languages, or BE/FE conflict that the
-#      owner must resolve) — lead writes stack.detected.md with both options
-#
-# Usage:
-#   bash detect-stack.sh [<repo-root>]
-#
-# Dependencies: bash, find, grep, sed. jq is preferred but not required (we
-# parse package.json with grep fallbacks when jq is missing).
-#
-# What this script does NOT do:
-#   - Write to CLAUDE.md. The spec forbids it. Output goes to stdout; the lead
-#     decides whether to write it to docs/superpowers/stack.detected.md.
-#   - Guess test commands when there is no signal — fields left blank with a
-#     `# CONFIRM:` comment for the owner to fill in.
-
-set -euo pipefail
-
-# ---- subcommand: detect-side ---------------------------------------------
-# Usage:
-#   bash detect-stack.sh detect-side "<launch message>"
-# Outputs one of: be-only | fe-only | mixed | none
-# Used by scripts/assess-complexity.sh for the rung-2 single-side signal.
-if [ "${1:-}" = "detect-side" ]; then
-  shift
-  text="${1:-}"
-  # Normalize to lowercase for case-insensitive matching.
-  lc="$(printf '%s' "$text" | tr '[:upper:]' '[:lower:]')"
-
-  be_keywords=(
-    "endpoint" "api" "/api" "/auth" "/health" "route" "controller" "service"
-    "repository" "schema" "migration" "database" "column" "table"
-    "queue" "worker" "cron" "webhook" "grpc" "rpc"
-  )
-  fe_keywords=(
-    "component" "page" "form" "button" "modal" "input" "field"
-    "ui" "layout" "css" "tailwind" "tsx" "jsx" "react" "vue"
-    "svelte" "stylesheet" "wireframe" "design system" "screen"
-  )
-
-  has_be=0
-  has_fe=0
-  for kw in "${be_keywords[@]}"; do
-    case "$lc" in *"$kw"*) has_be=1; break ;; esac
-  done
-  for kw in "${fe_keywords[@]}"; do
-    case "$lc" in *"$kw"*) has_fe=1; break ;; esac
-  done
-
-  if [ "$has_be" -eq 1 ] && [ "$has_fe" -eq 1 ]; then echo "mixed"
-  elif [ "$has_be" -eq 1 ]; then echo "be-only"
-  elif [ "$has_fe" -eq 1 ]; then echo "fe-only"
-  else echo "none"
-  fi
-  exit 0
-fi
-
-ROOT="${1:-$PWD}"
-cd "$ROOT"
-
-# ---- helpers --------------------------------------------------------------
-
-has_file_glob() {
-  # has_file_glob <maxdepth> <name>
-  find . -maxdepth "$1" -type f -name "$2" 2>/dev/null | head -n1 | grep -q .
-}
-
-has_file_deep() {
-  # has_file_deep <name>
-  find . -type f -name "$1" -not -path './node_modules/*' -not -path './.git/*' -not -path './dist/*' -not -path './build/*' 2>/dev/null | head -n1 | grep -q .
-}
-
-read_pkg_field() {
-  # read_pkg_field <jq-expr> [default]
-  local expr="$1" default="${2:-}"
-  [ -f package.json ] || { printf '%s' "$default"; return; }
-  if command -v jq >/dev/null 2>&1; then
-    local v
-    v="$(jq -r "$expr // empty" package.json 2>/dev/null || true)"
-    printf '%s' "${v:-$default}"
-  else
-    printf '%s' "$default"
-  fi
-}
-
-pkg_has_dep() {
-  # pkg_has_dep <name>
-  [ -f package.json ] || return 1
-  if command -v jq >/dev/null 2>&1; then
-    jq -e --arg n "$1" '((.dependencies // {}) + (.devDependencies // {}) + (.peerDependencies // {})) | has($n)' package.json >/dev/null 2>&1
-  else
-    grep -qE "\"$1\"[[:space:]]*:" package.json
-  fi
-}
-
-pkg_script() {
-  # pkg_script <script-name> -> command string (empty if missing)
-  [ -f package.json ] || return 0
-  if command -v jq >/dev/null 2>&1; then
-    jq -r --arg n "$1" '.scripts[$n] // empty' package.json 2>/dev/null || true
-  fi
-}
-
-# ---- backend detection ----------------------------------------------------
-
-backend_language=""
-backend_framework=""
-backend_test_framework=""
-backend_build_command=""
-backend_test_command=""
-backend_format_command=""
-backend_migration_tool=""
-backend_package_manager=""
-backend_candidates=()
-
-if has_file_glob 3 '*.csproj' || has_file_glob 2 '*.sln' || [ -f Directory.Build.props ]; then
-  backend_candidates+=("csharp")
-fi
-if [ -f pyproject.toml ] || [ -f setup.py ] || [ -f requirements.txt ] || [ -f Pipfile ]; then
-  backend_candidates+=("python")
-fi
-if [ -f go.mod ]; then
-  backend_candidates+=("go")
-fi
-if [ -f Cargo.toml ]; then
-  backend_candidates+=("rust")
-fi
-if [ -f pom.xml ] || [ -f build.gradle ] || [ -f build.gradle.kts ]; then
-  backend_candidates+=("java")
-fi
-# Node-ts as backend only when package.json exists, "type": "module", and no
-# frontend signal in deps. We resolve this after FE detection.
-
-if [ ${#backend_candidates[@]} -eq 1 ]; then
-  backend_language="${backend_candidates[0]}"
-fi
-
-# Per-language fillers
-case "$backend_language" in
-  csharp)
-    backend_framework="aspnetcore"
-    backend_build_command="dotnet build"
-    backend_test_command="dotnet test"
-    backend_format_command="dotnet format --verify-no-changes"
-    backend_package_manager="nuget"
-    # Test framework: scan csproj for hints
-    if find . -maxdepth 4 -type f -name '*.csproj' -exec grep -l -iE 'xunit' {} \; 2>/dev/null | head -n1 | grep -q .; then
-      backend_test_framework="xunit"
-    elif find . -maxdepth 4 -type f -name '*.csproj' -exec grep -l -iE 'nunit' {} \; 2>/dev/null | head -n1 | grep -q .; then
-      backend_test_framework="nunit"
-    elif find . -maxdepth 4 -type f -name '*.csproj' -exec grep -l -iE 'mstest' {} \; 2>/dev/null | head -n1 | grep -q .; then
-      backend_test_framework="mstest"
-    elif find . -maxdepth 4 -type f -name '*.csproj' -exec grep -l -iE 'reqnroll|specflow' {} \; 2>/dev/null | head -n1 | grep -q .; then
-      backend_test_framework="reqnroll"
-    else
-      backend_test_framework="# CONFIRM: xunit | nunit | mstest | reqnroll"
-    fi
-    # Migration tool: EF Core hint
-    if find . -maxdepth 4 -type f -name '*.csproj' -exec grep -l -iE 'Microsoft\.EntityFrameworkCore' {} \; 2>/dev/null | head -n1 | grep -q .; then
-      backend_migration_tool="ef-core"
-    else
-      backend_migration_tool="none"
-    fi
-    ;;
-  python)
-    backend_framework="# CONFIRM: fastapi | django | flask | starlette | none"
-    if [ -f pyproject.toml ] && grep -qE '\[tool\.poetry\]' pyproject.toml; then
-      backend_package_manager="poetry"
-      backend_build_command="poetry build"
-      backend_test_command="poetry run pytest"
-    elif [ -f Pipfile ]; then
-      backend_package_manager="pipenv"
-      backend_build_command="# CONFIRM: build command"
-      backend_test_command="pipenv run pytest"
-    else
-      backend_package_manager="pip"
-      backend_build_command="# CONFIRM: build command (often none for python apps)"
-      backend_test_command="pytest"
-    fi
-    backend_test_framework="pytest"
-    backend_format_command="# CONFIRM: ruff format --check . | black --check . | none"
-    if grep -qiE 'alembic' pyproject.toml requirements.txt Pipfile 2>/dev/null; then
-      backend_migration_tool="alembic"
-    elif grep -qiE 'django' pyproject.toml requirements.txt Pipfile 2>/dev/null; then
-      backend_migration_tool="django-migrations"
-    else
-      backend_migration_tool="none"
-    fi
-    ;;
-  go)
-    backend_framework="# CONFIRM: stdlib | gin | echo | chi | fiber"
-    backend_build_command="go build ./..."
-    backend_test_command="go test ./..."
-    backend_format_command="gofmt -l ."
-    backend_test_framework="go-testing"
-    backend_package_manager="go-modules"
-    backend_migration_tool="# CONFIRM: golang-migrate | goose | none"
-    ;;
-  rust)
-    backend_framework="# CONFIRM: axum | actix | rocket | warp"
-    backend_build_command="cargo build"
-    backend_test_command="cargo test"
-    backend_format_command="cargo fmt -- --check"
-    backend_test_framework="cargo-test"
-    backend_package_manager="cargo"
-    backend_migration_tool="# CONFIRM: sqlx-migrate | refinery | none"
-    ;;
-  java)
-    backend_framework="# CONFIRM: spring-boot | quarkus | micronaut | none"
-    if [ -f pom.xml ]; then
-      backend_build_command="mvn -B compile"
-      backend_test_command="mvn -B test"
-      backend_format_command="# CONFIRM: mvn spotless:check | none"
-      backend_package_manager="maven"
-    else
-      backend_build_command="./gradlew build"
-      backend_test_command="./gradlew test"
-      backend_format_command="# CONFIRM: ./gradlew spotlessCheck | none"
-      backend_package_manager="gradle"
-    fi
-    backend_test_framework="junit"
-    backend_migration_tool="# CONFIRM: flyway | liquibase | none"
-    ;;
-esac
-
-# ---- frontend detection ---------------------------------------------------
-
-frontend_language=""
-frontend_framework=""
-frontend_bundler=""
-frontend_test_framework=""
-frontend_e2e_framework=""
-frontend_ui_library=""
-frontend_package_manager=""
-frontend_build_command=""
-frontend_test_command=""
-have_pkg=0
-[ -f package.json ] && have_pkg=1
-
-if [ "$have_pkg" -eq 1 ]; then
-  # Detect framework
-  if pkg_has_dep next; then frontend_framework="next"; frontend_bundler="next";
-  elif pkg_has_dep nuxt; then frontend_framework="nuxt"; frontend_bundler="nuxt";
-  elif pkg_has_dep react || pkg_has_dep react-dom; then frontend_framework="react";
-  elif pkg_has_dep vue; then frontend_framework="vue";
-  elif pkg_has_dep svelte; then frontend_framework="svelte";
-  elif pkg_has_dep solid-js; then frontend_framework="solid";
-  elif pkg_has_dep '@angular/core'; then frontend_framework="angular";
-  fi
-
-  if [ -z "$frontend_bundler" ]; then
-    if has_file_glob 2 'vite.config.*'; then frontend_bundler="vite";
-    elif has_file_glob 2 'webpack.config.*'; then frontend_bundler="webpack";
-    elif has_file_glob 2 'rspack.config.*'; then frontend_bundler="rspack";
-    elif has_file_glob 2 'rollup.config.*'; then frontend_bundler="rollup";
-    elif has_file_glob 2 'next.config.*'; then frontend_bundler="next";
-    elif has_file_glob 2 'nuxt.config.*'; then frontend_bundler="nuxt";
-    fi
-  fi
-
-  if [ -n "$frontend_framework" ] || [ -n "$frontend_bundler" ]; then
-    # Confirmed FE shape
-    frontend_language="typescript"
-    [ -f tsconfig.json ] || frontend_language="javascript"
-
-    if pkg_has_dep vitest; then frontend_test_framework="vitest";
-    elif pkg_has_dep jest; then frontend_test_framework="jest";
-    elif pkg_has_dep '@playwright/test'; then frontend_test_framework="none";
-    else frontend_test_framework="# CONFIRM: vitest | jest | none";
-    fi
-
-    if pkg_has_dep '@playwright/test'; then frontend_e2e_framework="playwright";
-    elif pkg_has_dep cypress; then frontend_e2e_framework="cypress";
-    else frontend_e2e_framework="none";
-    fi
-
-    if pkg_has_dep '@shadcn/ui' || [ -d components/ui ] && grep -RIl 'shadcn' components/ui 2>/dev/null | head -n1 | grep -q . ; then
-      frontend_ui_library="shadcn"
-    elif pkg_has_dep '@mui/material'; then frontend_ui_library="mui";
-    elif pkg_has_dep antd; then frontend_ui_library="antd";
-    elif pkg_has_dep tailwindcss; then frontend_ui_library="tailwind-only";
-    else frontend_ui_library="# CONFIRM: shadcn | mui | antd | tailwind-only | none";
-    fi
-
-    # Package manager: lockfile is the source of truth
-    if [ -f pnpm-lock.yaml ]; then frontend_package_manager="pnpm";
-    elif [ -f yarn.lock ]; then frontend_package_manager="yarn";
-    elif [ -f bun.lockb ] || [ -f bun.lock ]; then frontend_package_manager="bun";
-    else frontend_package_manager="npm";
-    fi
-
-    # Scripts → commands
-    local_build="$(pkg_script build)"
-    local_test="$(pkg_script test)"
-    if [ -n "$local_build" ]; then
-      frontend_build_command="$frontend_package_manager build"
-    fi
-    if [ -n "$local_test" ]; then
-      frontend_test_command="$frontend_package_manager test"
-    fi
-  fi
-fi
-
-# Resolve node-ts-as-backend: package.json without any FE framework and with a
-# server framework dep counts as a BE candidate.
-if [ "$have_pkg" -eq 1 ] && [ -z "$frontend_framework" ] && [ -z "$frontend_bundler" ]; then
-  if pkg_has_dep express || pkg_has_dep fastify || pkg_has_dep koa || pkg_has_dep '@nestjs/core' || pkg_has_dep hono; then
-    backend_candidates+=("node-ts")
-    # If this was our only BE candidate, set it
-    if [ -z "$backend_language" ] && [ ${#backend_candidates[@]} -eq 1 ]; then
-      backend_language="node-ts"
-    fi
-  fi
-fi
-
-# Fill node-ts BE
-if [ "$backend_language" = "node-ts" ]; then
-  if pkg_has_dep '@nestjs/core'; then backend_framework="nestjs";
-  elif pkg_has_dep fastify; then backend_framework="fastify";
-  elif pkg_has_dep express; then backend_framework="express";
-  elif pkg_has_dep koa; then backend_framework="koa";
-  elif pkg_has_dep hono; then backend_framework="hono";
-  fi
-  if pkg_has_dep vitest; then backend_test_framework="vitest";
-  elif pkg_has_dep jest; then backend_test_framework="jest";
-  else backend_test_framework="# CONFIRM: vitest | jest | mocha";
-  fi
-  if [ -f pnpm-lock.yaml ]; then backend_package_manager="pnpm";
-  elif [ -f yarn.lock ]; then backend_package_manager="yarn";
-  elif [ -f bun.lockb ] || [ -f bun.lock ]; then backend_package_manager="bun";
-  else backend_package_manager="npm";
-  fi
-  backend_build_command="$backend_package_manager build"
-  backend_test_command="$backend_package_manager test"
-  backend_format_command="# CONFIRM: prettier --check . | eslint . | none"
-  backend_migration_tool="# CONFIRM: prisma | typeorm | knex | none"
-fi
-
-# ---- contracts ------------------------------------------------------------
-
-contracts_sot=""
-contracts_openapi_path=""
-contracts_ts_gen_command=""
-
-if find . -maxdepth 5 -type f \( -name 'openapi.yaml' -o -name 'openapi.json' -o -name 'swagger.yaml' -o -name 'swagger.json' \) -not -path './node_modules/*' -not -path './.git/*' 2>/dev/null | head -n1 | grep -q .; then
-  contracts_sot="openapi"
-  contracts_openapi_path="$(find . -maxdepth 5 -type f \( -name 'openapi.yaml' -o -name 'openapi.json' -o -name 'swagger.yaml' \) -not -path './node_modules/*' -not -path './.git/*' 2>/dev/null | head -n1 | sed 's|^\./||')"
-  contracts_ts_gen_command="# CONFIRM: command that regenerates TS types from $contracts_openapi_path"
-elif find . -maxdepth 5 -type f -name '*.proto' -not -path './node_modules/*' -not -path './.git/*' 2>/dev/null | head -n1 | grep -q .; then
-  contracts_sot="grpc"
-elif find . -maxdepth 5 -type f -name 'schema.graphql' -not -path './node_modules/*' -not -path './.git/*' 2>/dev/null | head -n1 | grep -q .; then
-  contracts_sot="graphql"
-elif [ -n "$backend_language" ] && [ -n "$frontend_framework" ]; then
-  contracts_sot="# CONFIRM: openapi | grpc | graphql | typescript | none"
-else
-  contracts_sot="none"
-fi
-
-# ---- CI -------------------------------------------------------------------
-
-ci_provider=""
-ci_workflow_path=""
-
-if find .github/workflows -maxdepth 1 -type f \( -name '*.yml' -o -name '*.yaml' \) 2>/dev/null | head -n1 | grep -q .; then
-  ci_provider="github-actions"
-  ci_workflow_path="$(find .github/workflows -maxdepth 1 -type f \( -name '*.yml' -o -name '*.yaml' \) 2>/dev/null | head -n1)"
-elif [ -f azure-pipelines.yml ] || [ -f .azure/pipelines.yml ]; then
-  ci_provider="azure-pipelines"
-  [ -f azure-pipelines.yml ] && ci_workflow_path="azure-pipelines.yml" || ci_workflow_path=".azure/pipelines.yml"
-elif [ -f .gitlab-ci.yml ]; then
-  ci_provider="gitlab-ci"
-  ci_workflow_path=".gitlab-ci.yml"
-elif [ -f .circleci/config.yml ]; then
-  ci_provider="circleci"
-  ci_workflow_path=".circleci/config.yml"
-else
-  ci_provider="none"
-fi
-
-# ---- emit -----------------------------------------------------------------
-
-if [ -z "$backend_language" ] && [ -z "$frontend_framework" ] && [ -z "$frontend_bundler" ]; then
-  echo "# detect-stack: no BE or FE signal found in $ROOT" >&2
-  exit 1
-fi
-
-emit_backend=0
-emit_frontend=0
-[ -n "$backend_language" ] && emit_backend=1
-{ [ -n "$frontend_framework" ] || [ -n "$frontend_bundler" ]; } && emit_frontend=1
-
-cat <<EOF
-# Auto-generated by team-superpower detect-stack.sh on $(date -u +%Y-%m-%dT%H:%M:%SZ).
-# Review every \`# CONFIRM:\` line, then paste into your CLAUDE.md inside a
-# \`\`\`team-superpower fenced block. The plugin will NOT overwrite your CLAUDE.md.
-EOF
-
-if [ "$emit_backend" -eq 1 ]; then
-  cat <<EOF
-backend:
-  language: ${backend_language}
-  framework: ${backend_framework:-# CONFIRM: framework}
-  test_framework: ${backend_test_framework:-# CONFIRM: test framework}
-  build_command: ${backend_build_command:-# CONFIRM: build command}
-  test_command: ${backend_test_command:-# CONFIRM: test command}
-  format_command: ${backend_format_command:-# CONFIRM: format check command (or 'none')}
-  migration_tool: ${backend_migration_tool:-none}
-  package_manager: ${backend_package_manager:-# CONFIRM: package manager}
-EOF
-else
-  echo "backend: none"
-fi
-
-if [ "$emit_frontend" -eq 1 ]; then
-  cat <<EOF
-frontend:
-  language: ${frontend_language:-typescript}
-  framework: ${frontend_framework:-# CONFIRM: framework}
-  bundler: ${frontend_bundler:-# CONFIRM: bundler}
-  test_framework: ${frontend_test_framework:-none}
-  e2e_framework: ${frontend_e2e_framework:-none}
-  ui_library: ${frontend_ui_library:-none}
-  package_manager: ${frontend_package_manager:-npm}
-  build_command: ${frontend_build_command:-# CONFIRM: build command}
-  test_command: ${frontend_test_command:-# CONFIRM: test command}
-EOF
-else
-  echo "frontend: none"
-fi
-
-cat <<EOF
-contracts:
-  source_of_truth: ${contracts_sot}
-EOF
-if [ -n "$contracts_openapi_path" ]; then
-  echo "  openapi_path: $contracts_openapi_path"
-fi
-if [ -n "$contracts_ts_gen_command" ]; then
-  echo "  ts_gen_command: \"$contracts_ts_gen_command\""
-fi
-
-cat <<EOF
-ci:
-  provider: ${ci_provider}
-EOF
-if [ -n "$ci_workflow_path" ]; then
-  echo "  workflow_path: $ci_workflow_path"
-fi
-cat <<EOF
-  required_checks: []     # CONFIRM: e.g. ["build", "test", "lint"]
-  poll_timeout_minutes: 20
-security:
-  domain: # CONFIRM: payments | healthcare | generic | internal-only
-  pii: # CONFIRM: yes | no
-  public_endpoints: # CONFIRM: yes | no
-  data_at_rest: # CONFIRM: sql | nosql | none
-EOF
-
-# Exit with ambiguity warning when there are >1 BE candidates the script could
-# not narrow down.
-if [ ${#backend_candidates[@]} -gt 1 ]; then
-  uniq_list="$(printf '%s\n' "${backend_candidates[@]}" | sort -u | tr '\n' ',' | sed 's/,$//')"
-  echo "# AMBIGUOUS_BACKEND: multiple BE candidates found: $uniq_list — owner must confirm" >&2
-  exit 2
-fi
-
-exit 0

package/plugins/team-superpower/scripts/parse-claudemd.sh

@@ -1,194 +0,0 @@
-#!/usr/bin/env bash
-# parse-claudemd.sh — extract the team-superpower YAML block from CLAUDE.md.
-#
-# Usage:
-#   parse-claudemd.sh extract [<path-to-CLAUDE.md>]   prints the YAML block to stdout
-#   parse-claudemd.sh shape   [<path-to-CLAUDE.md>]   prints "full-stack" | "be-only" | "fe-only" | "none"
-#   parse-claudemd.sh get <dotted.key> [<path>]       prints a single scalar value
-#                                                      (limited: top-level group + leaf, e.g. backend.test_command)
-#
-# Exit codes:
-#   0  success
-#   1  CLAUDE.md missing or contains no `team-superpower` fenced block
-#   2  bad arguments
-#   3  key not found (only for `get`)
-#
-# Notes:
-#   - The fenced block is recognised by the literal opener "```team-superpower"
-#     (with no language indent) and the matching "```" closer.
-#   - Comments starting with `#` (after optional whitespace) are stripped before
-#     value extraction. Inline `# comment` tails are also stripped.
-#   - This is a deliberately tiny parser. It does NOT validate the schema.
-#     Schema validation is the lead's job (it halts on bad values per the spec).
-
-set -euo pipefail
-
-usage() {
-  sed -n '2,30p' "$0" | sed 's/^# \{0,1\}//'
-}
-
-CLAUDE_FILE_DEFAULT="${CLAUDE_PROJECT_DIR:-$PWD}/CLAUDE.md"
-
-extract_block() {
-  local file="$1"
-  [ -f "$file" ] || return 1
-  # awk: print lines strictly between the opener and closer fences.
-  awk '
-    /^```team-superpower[[:space:]]*$/ { in_block = 1; next }
-    in_block && /^```[[:space:]]*$/    { in_block = 0; exit }
-    in_block                            { print }
-  ' "$file"
-}
-
-block_has_content() {
-  # Returns 0 if the YAML block extracted to stdin has at least one non-comment,
-  # non-blank line; 1 otherwise.
-  local payload
-  payload="$(cat || true)"
-  printf '%s' "$payload" | grep -vE '^[[:space:]]*(#|$)' | head -n1 | grep -q .
-}
-
-# Strip an inline `# comment` tail (but not `#` inside a quoted string — we
-# tolerate the simple case here, the spec doesn't ship complex YAML values).
-strip_comment() {
-  sed -E 's/[[:space:]]+#[^"\x27]*$//' | sed -E 's/^[[:space:]]*#.*$//'
-}
-
-cmd_extract() {
-  local file="${1:-$CLAUDE_FILE_DEFAULT}"
-  if [ ! -f "$file" ]; then
-    echo "parse-claudemd: $file does not exist" >&2
-    return 1
-  fi
-  local block
-  block="$(extract_block "$file")"
-  if [ -z "$block" ] || ! printf '%s' "$block" | block_has_content; then
-    echo "parse-claudemd: no \`team-superpower\` block found in $file" >&2
-    return 1
-  fi
-  printf '%s\n' "$block"
-}
-
-# Read a top-level scalar like `backend: none` or detect whether a group is
-# explicitly "none".
-group_is_none() {
-  # group_is_none <yaml-block-on-stdin> <group-name>
-  local group="$2"
-  awk -v g="$group" '
-    BEGIN { found = 0 }
-    {
-      sub(/[[:space:]]+#[^"\x27]*$/, "")
-      sub(/^[[:space:]]*#.*$/, "")
-    }
-    $0 ~ "^"g":[[:space:]]+none[[:space:]]*$" { found = 1; exit }
-    END { exit found ? 0 : 1 }
-  ' <<<"$1"
-}
-
-# A group is "present" if there is `group:` followed (on subsequent indented
-# lines) by at least one non-comment, non-blank key/value pair.
-group_is_present() {
-  # group_is_present <yaml-block> <group-name>
-  local group="$2"
-  awk -v g="$group" '
-    BEGIN { state = 0; has_keys = 0 }
-    {
-      line = $0
-      # strip comments
-      sub(/[[:space:]]+#[^"\x27]*$/, "", line)
-      sub(/^[[:space:]]*#.*$/, "", line)
-    }
-    line ~ "^"g":[[:space:]]*$"          { state = 1; next }
-    line ~ "^"g":[[:space:]]+none"       { state = 0; exit }
-    state == 1 && line ~ /^[^[:space:]]/ { state = 0 }
-    state == 1 && line ~ /^[[:space:]]+[A-Za-z_][A-Za-z0-9_]*:/ { has_keys = 1 }
-    END { exit has_keys ? 0 : 1 }
-  ' <<<"$1"
-}
-
-cmd_shape() {
-  local file="${1:-$CLAUDE_FILE_DEFAULT}"
-  local block
-  block="$(cmd_extract "$file")" || return 1
-
-  local be_present=1 fe_present=1
-  group_is_present "$block" backend  || be_present=0
-  group_is_present "$block" frontend || fe_present=0
-
-  if   [ "$be_present" -eq 1 ] && [ "$fe_present" -eq 1 ]; then echo "full-stack"
-  elif [ "$be_present" -eq 1 ];                              then echo "be-only"
-  elif [ "$fe_present" -eq 1 ];                              then echo "fe-only"
-  else                                                            echo "none"
-  fi
-}
-
-cmd_get() {
-  local key="${1:-}"
-  local file="${2:-$CLAUDE_FILE_DEFAULT}"
-  if [ -z "$key" ]; then usage >&2; return 2; fi
-  local block
-  block="$(cmd_extract "$file")" || return 1
-
-  case "$key" in
-    *.*)
-      local group leaf
-      group="${key%%.*}"
-      leaf="${key#*.}"
-      local value
-      value="$(awk -v g="$group" -v k="$leaf" '
-        BEGIN { in_group = 0; pat = "^[[:space:]]+" k "[[:space:]]*:[[:space:]]*" }
-        {
-          line = $0
-          sub(/[[:space:]]+#[^"\x27]*$/, "", line)
-          sub(/^[[:space:]]*#.*$/, "", line)
-        }
-        line ~ "^"g":[[:space:]]*$"           { in_group = 1; next }
-        in_group && line ~ /^[^[:space:]]/    { in_group = 0 }
-        in_group && line ~ pat {
-          v = line
-          sub(pat, "", v)
-          sub(/[[:space:]]+$/, "", v)
-          gsub(/^"|"$/, "", v)
-          gsub(/^\x27|\x27$/, "", v)
-          print v
-          exit
-        }
-      ' <<<"$block")"
-      if [ -z "$value" ]; then return 3; fi
-      printf '%s\n' "$value"
-      ;;
-    *)
-      # Top-level scalar (e.g. "backend" for `backend: none`)
-      local value
-      value="$(awk -v k="$key" '
-        BEGIN { pat = "^" k ":[[:space:]]+" }
-        {
-          line = $0
-          sub(/[[:space:]]+#[^"\x27]*$/, "", line)
-          sub(/^[[:space:]]*#.*$/, "", line)
-        }
-        line ~ pat {
-          v = line; sub(pat, "", v); sub(/[[:space:]]+$/, "", v)
-          print v
-          exit
-        }
-      ' <<<"$block")"
-      if [ -z "$value" ]; then return 3; fi
-      printf '%s\n' "$value"
-      ;;
-  esac
-}
-
-main() {
-  local sub="${1:-}"
-  shift || true
-  case "$sub" in
-    extract) cmd_extract "$@" ;;
-    shape)   cmd_shape   "$@" ;;
-    get)     cmd_get     "$@" ;;
-    -h|--help|"") usage; [ -z "$sub" ] && return 2 || return 0 ;;
-    *) echo "unknown subcommand: $sub" >&2; usage >&2; return 2 ;;
-  esac
-}
-
-main "$@"