@pipemd-core/pipemd 1.0.0

package/scripts/Node-TypeScript/architecture/arch.sh

@@ -0,0 +1,174 @@
+#!/usr/bin/env bash
+set -uo pipefail
+# Architecture map — Node/TypeScript module dependencies
+source "$(dirname "$0")/../lib/limit.sh"
+
+: "${MAX_ARCH:=100}"
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+NORMALIZE="$SCRIPT_DIR/normalize.sh"
+[ -f "$NORMALIZE" ] || NORMALIZE="$SCRIPT_DIR/../../Shared/architecture/normalize.sh"
+
+if ! command -v python3 &>/dev/null; then
+  echo "python3 is required for architecture extraction"
+  exit 0
+fi
+
+SRC_DIR=""
+for dir in src lib app; do
+  [ -d "$dir" ] && SRC_DIR="$dir" && break
+done
+[ -z "$SRC_DIR" ] && { echo "No source directory found"; exit 0; }
+
+python3 -c "
+import os, re, json, sys
+from collections import defaultdict
+
+SRC_DIR = os.environ.get('SRC_DIR', 'src')
+MAX_FILES = 300
+MAX_MODULES = 40
+
+SKIP_DIRS = {'node_modules', 'dist', '.next', 'coverage', 'build', 'out', '.pipemd', '.git', '__tests__', '__test__', '__mocks__', 'test', 'tests', 'spec', 'specs', 'scripts', 'migrations', 'seed', 'public', 'static', 'assets', 'styles', 'views', 'templates'}
+
+ENTRY_FILES = {'index', 'main', 'app', 'server', 'mod'}
+
+def should_skip_dir(d):
+    return d in SKIP_DIRS or d.startswith('.')
+
+def should_skip_file(f):
+    if f.endswith('.d.ts'):
+        return True
+    if '.test.' in f or '.spec.' in f or '.stories.' in f or '.story.' in f:
+        return True
+    return False
+
+def module_name(rel_path):
+    parts = rel_path.replace(os.sep, '/').split('/')
+    filename = os.path.splitext(parts[-1])[0] if parts else ''
+    dirpath = parts[:-1] if len(parts) > 1 else []
+
+    if len(dirpath) == 0:
+        return filename if filename in ENTRY_FILES else None
+
+    last_dir = dirpath[-1]
+
+    # If there's only one significant file in this dir-level, use the dir name
+    # If the file is an entry point (index/main), use the dir name
+    if filename in ENTRY_FILES or filename == last_dir:
+        return last_dir
+
+    # Otherwise use dir/file to preserve detail
+    return last_dir + '/' + filename
+
+def resolve_relative(import_path, file_rel, src_dir):
+    file_dir = os.path.dirname(file_rel)
+    resolved = os.path.normpath(os.path.join(file_dir, import_path))
+    resolved = resolved.replace(os.sep, '/')
+    if resolved.startswith(src_dir + '/'):
+        resolved = resolved[len(src_dir) + 1:]
+    elif resolved == src_dir:
+        return None
+    return module_name(resolved)
+
+def load_external_deps():
+    ext = set()
+    for pkgfile in ('package.json',):
+        try:
+            with open(pkgfile, 'r', errors='replace') as f:
+                pkg = json.load(f)
+            for section in ('dependencies', 'devDependencies', 'peerDependencies'):
+                ext.update(pkg.get(section, {}).keys())
+        except Exception:
+            pass
+    return ext
+
+def external_name(spec):
+    if spec.startswith('@'):
+        parts = spec.split('/')
+        if len(parts) >= 2:
+            return parts[0] + '/' + parts[1]
+        return parts[0]
+    return spec.split('/')[0]
+
+# Match: import X from 'y', import {X} from 'y', require('y'), import('y')
+import_re = re.compile(
+    r\"\"\"(?:import\s+(?:.*?)\s+from\s+['\"]([^'\"]+)['\"]|require\s*\(\s*['\"]([^'\"]+)['\"]\s*\)|import\s*\(\s*['\"]([^'\"]+)['\"]\s*\))\"\"\",
+    re.MULTILINE
+)
+
+ext_deps = load_external_deps()
+
+files = []
+for root, dirs, filenames in os.walk(SRC_DIR):
+    dirs[:] = sorted([d for d in dirs if not should_skip_dir(d)])
+    for fn in sorted(filenames):
+        if should_skip_file(fn):
+            continue
+        if fn.endswith(('.ts', '.tsx', '.js', '.jsx')):
+            files.append(os.path.join(root, fn))
+    if len(files) >= MAX_FILES:
+        files = files[:MAX_FILES]
+        break
+
+if not files:
+    sys.exit(0)
+
+# Count files per directory to decide grouping
+dir_counts = defaultdict(list)
+for fpath in files:
+    rel = os.path.relpath(fpath, SRC_DIR).replace(os.sep, '/')
+    d = os.path.dirname(rel) if '/' in rel else '.'
+    dir_counts[d].append(fpath)
+
+# Build a set of modules — prefer dir-level for dirs with 1-2 files,
+# file-level for dirs with many files or entry points
+module_set = set()
+for fpath in files:
+    rel = os.path.relpath(fpath, SRC_DIR).replace(os.sep, '/')
+    mod = module_name(rel)
+    if mod:
+        module_set.add(mod)
+
+# If too many modules, collapse file-level back to dir-level
+if len(module_set) > MAX_MODULES:
+    module_set = set()
+    for fpath in files:
+        rel = os.path.relpath(fpath, SRC_DIR).replace(os.sep, '/')
+        parts = rel.split('/')
+        if len(parts) > 1:
+            module_set.add(parts[0])
+        else:
+            module_set.add(os.path.splitext(parts[0])[0])
+
+edges = set()
+
+for fpath in files:
+    rel = os.path.relpath(fpath, SRC_DIR).replace(os.sep, '/')
+    src_mod = module_name(rel)
+    if not src_mod or src_mod not in module_set:
+        continue
+
+    try:
+        with open(fpath, 'r', errors='replace') as f:
+            content = f.read()
+    except Exception:
+        continue
+
+    for m in import_re.finditer(content):
+        spec = m.group(1) or m.group(2) or m.group(3)
+        if not spec:
+            continue
+
+        if spec.startswith('.'):
+            target = resolve_relative(spec, rel, SRC_DIR)
+            if target and target in module_set and target != src_mod:
+                edges.add((src_mod, target))
+        else:
+            pkg = external_name(spec)
+            if pkg in ext_deps or spec.startswith('@'):
+                edges.add((src_mod, 'ext:' + pkg))
+
+if edges:
+    for s, d in sorted(edges):
+        sys.stdout.write(s + '\t' + d + '\n')
+" SRC_DIR="$SRC_DIR" | MAX_ARCH="$MAX_ARCH" bash "$NORMALIZE"

package/scripts/Node-TypeScript/frontend/angular-routes.sh

@@ -0,0 +1,15 @@
+#!/usr/bin/env bash
+set -uo pipefail
+# Angular route metadata — parses *-routing.module.ts files
+source "$(dirname "$0")/../lib/limit.sh"
+files=$(find src -name '*-routing.module.ts' -o -name '*-routing.module.js' 2>/dev/null | grep -v '/node_modules/')
+[ -z "$files" ] && echo "No Angular routing modules found" && exit 0
+
+echo "$files" | while IFS= read -r f; do
+  [ -z "$f" ] && continue
+  echo "File: $f"
+  grep -E '(path|redirectTo)\s*:\s*['\''"][^'\''"]*['\''"]' "$f" 2>/dev/null \
+    | sed -E 's/(path|redirectTo)\s*:\s*['\''"]([^'\''"]*)['\''"].*/  \1: \2/' \
+    | head -"$MAX_ANGULAR"
+  echo ""
+done | head -40

package/scripts/Node-TypeScript/frontend/nextjs-app-router.sh

@@ -0,0 +1,13 @@
+#!/usr/bin/env bash
+set -uo pipefail
+# Next.js App Router route tree — extracts routes from app/**/page.tsx
+source "$(dirname "$0")/../lib/limit.sh"
+[ ! -d "app" ] && echo "No Next.js app/ directory found" && exit 0
+
+find app -name 'page.tsx' -o -name 'page.ts' -o -name 'page.jsx' -o -name 'page.js' 2>/dev/null \
+  | sed 's|^app||;s|/page\.\(tsx\|ts\|jsx\|js\)$||;s|^$|/|' \
+  | sort \
+  | head -"$MAX_NEXTJS"
+
+layouts=$(find app -name 'layout.tsx' -o -name 'layout.ts' 2>/dev/null | wc -l)
+echo "(${layouts} layout(s), $(find app -name 'page.*' 2>/dev/null | wc -l) route(s))"

package/scripts/Node-TypeScript/frontend/react-components.sh

@@ -0,0 +1,20 @@
+#!/usr/bin/env bash
+set -uo pipefail
+# React component metadata — exported function components and Props types
+source "$(dirname "$0")/../lib/limit.sh"
+out=$(grep -rn --include='*.tsx' --include='*.jsx' \
+  -E '^export (default )?function [A-Z][A-Za-z]*|^export const [A-Z][A-Za-z]* =|^const [A-Z][A-Za-z]*: React\.FC' \
+  src/ 2>/dev/null | grep -v 'node_modules' \
+  | sed -E 's/:[0-9]+:.*export (default )?(function |const )([A-Z][A-Za-z]*).*/\3/' \
+  | sort -u \
+  | head -"$MAX_REACT")
+[ -z "$out" ] && echo "No React components found" && exit 0
+echo "$out"
+
+props=$(grep -rn --include='*.tsx' --include='*.jsx' \
+  -E '(type|interface) [A-Z][A-Za-z]*Props' \
+  src/ 2>/dev/null | grep -v 'node_modules' \
+  | sed -E 's/.*:(type|interface) ([A-Z][A-Za-z]*Props).*/\2/' \
+  | sort -u \
+  | head -10)
+[ -n "$props" ] && echo "" && echo "Props types:" && echo "$props"

package/scripts/Node-TypeScript/lib/limit.sh

@@ -0,0 +1,146 @@
+#!/usr/bin/env bash
+set -uo pipefail
+# limit.sh — Smart output limiter with compact fallbacks
+# TOKEN profile multiplier (override via PMD_TOKEN_PROFILE env var)
+PMD_TOKEN_PROFILE="${PMD_TOKEN_PROFILE:-medium}"
+case "$PMD_TOKEN_PROFILE" in
+  low)    MULT_NUM=1; MULT_DEN=2 ;;
+  medium) MULT_NUM=1; MULT_DEN=1 ;;
+  high)   MULT_NUM=3; MULT_DEN=2 ;;
+  xhigh)  MULT_NUM=2; MULT_DEN=1 ;;
+  unlimited) PMD_UNLIMITED=1 ;;
+  *)      MULT_NUM=1; MULT_DEN=1 ;;
+esac
+
+# Token budget constants (override via PMD_MAX_* env vars, scaled by profile)
+if [ "${PMD_UNLIMITED:-0}" = "1" ]; then
+  MAX_TREE=${PMD_MAX_TREE:-99999}
+  MAX_DEPS=${PMD_MAX_DEPS:-99999}
+  MAX_TODOS=${PMD_MAX_TODOS:-99999}
+  MAX_LOG=${PMD_MAX_LOG:-99999}
+  MAX_BRANCH=${PMD_MAX_BRANCH:-99999}
+  MAX_STATUS=${PMD_MAX_STATUS:-99999}
+  MAX_DIFF=${PMD_MAX_DIFF:-99999}
+  MAX_TYPECHECK=${PMD_MAX_TYPECHECK:-99999}
+  MAX_LINT=${PMD_MAX_LINT:-99999}
+  MAX_TEST=${PMD_MAX_TEST:-99999}
+  MAX_PRISMA=${PMD_MAX_PRISMA:-99999}
+  MAX_EXPRESS=${PMD_MAX_EXPRESS:-99999}
+  MAX_FASTAPI=${PMD_MAX_FASTAPI:-99999}
+  MAX_DJANGO=${PMD_MAX_DJANGO:-99999}
+  MAX_SQLALCHEMY=${PMD_MAX_SQLALCHEMY:-99999}
+  MAX_NEST=${PMD_MAX_NEST:-99999}
+  MAX_NEXTJS=${PMD_MAX_NEXTJS:-99999}
+  MAX_REACT=${PMD_MAX_REACT:-99999}
+  MAX_ANGULAR=${PMD_MAX_ANGULAR:-99999}
+  MAX_CMAKE=${PMD_MAX_CMAKE:-99999}
+  MAX_CLASS=${PMD_MAX_CLASS:-99999}
+  MAX_INTERFACE=${PMD_MAX_INTERFACE:-99999}
+  MAX_INCLUDE=${PMD_MAX_INCLUDE:-99999}
+  MAX_CARGO=${PMD_MAX_CARGO:-99999}
+  MAX_GO_PKGS=${PMD_MAX_GO_PKGS:-99999}
+  MAX_CARGO_FEATURES=${PMD_MAX_CARGO_FEATURES:-99999}
+  MAX_GO_INTERFACES=${PMD_MAX_GO_INTERFACES:-99999}
+  MAX_DOCKER=${PMD_MAX_DOCKER:-99999}
+  MAX_K8S=${PMD_MAX_K8S:-99999}
+  MAX_TF=${PMD_MAX_TF:-99999}
+  MAX_AWS=${PMD_MAX_AWS:-99999}
+  MAX_ARCH=${PMD_MAX_ARCH:-99999}
+  MAX_COMPOSE=${PMD_MAX_COMPOSE:-99999}
+  MAX_CREW=${PMD_MAX_CREW:-99999}
+else
+  MAX_TREE=$(( (${PMD_MAX_TREE:-50} * MULT_NUM) / MULT_DEN ))
+  MAX_DEPS=$(( (${PMD_MAX_DEPS:-40} * MULT_NUM) / MULT_DEN ))
+  MAX_TODOS=$(( (${PMD_MAX_TODOS:-20} * MULT_NUM) / MULT_DEN ))
+  MAX_LOG=$(( (${PMD_MAX_LOG:-20} * MULT_NUM) / MULT_DEN ))
+  MAX_BRANCH=$(( (${PMD_MAX_BRANCH:-20} * MULT_NUM) / MULT_DEN ))
+  MAX_STATUS=$(( (${PMD_MAX_STATUS:-30} * MULT_NUM) / MULT_DEN ))
+  MAX_DIFF=$(( (${PMD_MAX_DIFF:-30} * MULT_NUM) / MULT_DEN ))
+  MAX_TYPECHECK=$(( (${PMD_MAX_TYPECHECK:-30} * MULT_NUM) / MULT_DEN ))
+  MAX_LINT=$(( (${PMD_MAX_LINT:-20} * MULT_NUM) / MULT_DEN ))
+  MAX_TEST=$(( (${PMD_MAX_TEST:-10} * MULT_NUM) / MULT_DEN ))
+  MAX_PRISMA=$(( (${PMD_MAX_PRISMA:-40} * MULT_NUM) / MULT_DEN ))
+  MAX_EXPRESS=$(( (${PMD_MAX_EXPRESS:-30} * MULT_NUM) / MULT_DEN ))
+  MAX_FASTAPI=$(( (${PMD_MAX_FASTAPI:-30} * MULT_NUM) / MULT_DEN ))
+  MAX_DJANGO=$(( (${PMD_MAX_DJANGO:-40} * MULT_NUM) / MULT_DEN ))
+  MAX_SQLALCHEMY=$(( (${PMD_MAX_SQLALCHEMY:-40} * MULT_NUM) / MULT_DEN ))
+  MAX_NEST=$(( (${PMD_MAX_NEST:-30} * MULT_NUM) / MULT_DEN ))
+  MAX_NEXTJS=$(( (${PMD_MAX_NEXTJS:-30} * MULT_NUM) / MULT_DEN ))
+  MAX_REACT=$(( (${PMD_MAX_REACT:-30} * MULT_NUM) / MULT_DEN ))
+  MAX_ANGULAR=$(( (${PMD_MAX_ANGULAR:-30} * MULT_NUM) / MULT_DEN ))
+  MAX_CMAKE=$(( (${PMD_MAX_CMAKE:-40} * MULT_NUM) / MULT_DEN ))
+  MAX_CLASS=$(( (${PMD_MAX_CLASS:-40} * MULT_NUM) / MULT_DEN ))
+  MAX_INTERFACE=$(( (${PMD_MAX_INTERFACE:-30} * MULT_NUM) / MULT_DEN ))
+  MAX_INCLUDE=$(( (${PMD_MAX_INCLUDE:-40} * MULT_NUM) / MULT_DEN ))
+  MAX_CARGO=$(( (${PMD_MAX_CARGO:-40} * MULT_NUM) / MULT_DEN ))
+  MAX_GO_PKGS=$(( (${PMD_MAX_GO_PKGS:-40} * MULT_NUM) / MULT_DEN ))
+  MAX_CARGO_FEATURES=$(( (${PMD_MAX_CARGO_FEATURES:-20} * MULT_NUM) / MULT_DEN ))
+  MAX_GO_INTERFACES=$(( (${PMD_MAX_GO_INTERFACES:-30} * MULT_NUM) / MULT_DEN ))
+  MAX_DOCKER=$(( (${PMD_MAX_DOCKER:-30} * MULT_NUM) / MULT_DEN ))
+  MAX_K8S=$(( (${PMD_MAX_K8S:-20} * MULT_NUM) / MULT_DEN ))
+  MAX_TF=$(( (${PMD_MAX_TF:-40} * MULT_NUM) / MULT_DEN ))
+  MAX_AWS=$(( (${PMD_MAX_AWS:-10} * MULT_NUM) / MULT_DEN ))
+  MAX_ARCH=$(( (${PMD_MAX_ARCH:-100} * MULT_NUM) / MULT_DEN ))
+  MAX_COMPOSE=$(( (${PMD_MAX_COMPOSE:-150} * MULT_NUM) / MULT_DEN ))
+  MAX_CREW=$(( (${PMD_MAX_CREW:-40} * MULT_NUM) / MULT_DEN ))
+fi
+
+TREE_EXCLUDES="${PMD_TREE_EXCLUDES:-node_modules|.git|.pipemd|dist|coverage|.next|.turbo|build|out|__pycache__|venv|.venv|*.egg-info}"
+
+limit_output() {
+  local text="$1"
+  local max="${2:-25}"
+  local fallback="$3"
+  local lines
+  lines=$(echo "$text" | wc -l)
+  if [ "$lines" -le "$max" ]; then
+    echo "$text"
+  else
+    echo "$fallback"
+  fi
+}
+
+limit_tree() {
+  local max="${1:-$MAX_TREE}"
+  local excl="${TREE_EXCLUDES}"
+
+  if command -v tree &>/dev/null; then
+    local out3
+    out3=$(tree -L 3 -I "$excl" --dirsfirst 2>/dev/null)
+    local lines3=$(echo "$out3" | wc -l)
+
+    if [ "$lines3" -le "$max" ]; then
+      echo "$out3"
+      return
+    fi
+
+    local out2
+    out2=$(tree -L 2 -I "$excl" --dirsfirst 2>/dev/null)
+    local lines2=$(echo "$out2" | wc -l)
+
+    if [ "$lines2" -le "$max" ]; then
+      echo "$out2"
+      echo "(${lines3} lines at depth 3, showing depth 2)"
+      return
+    fi
+
+    local out1
+    out1=$(tree -L 1 -I "$excl" --dirsfirst 2>/dev/null)
+    echo "$out1"
+    echo "(${lines3} lines at depth 3, showing depth 1)"
+  else
+    echo "Project structure:"
+    find . -maxdepth 3 \
+      -not -path '*/node_modules/*' \
+      -not -path '*/.git/*' \
+      -not -path '*/.pipemd/*' \
+      -not -path '*/dist/*' \
+      -not -path '*/build/*' \
+      -not -path '*/.next/*' \
+      -not -path '*/coverage/*' \
+      -not -name 'node_modules' \
+      -not -name '.git' \
+      -not -name '.pipemd' \
+      2>/dev/null | head -"$max" | sort
+  fi
+}

package/scripts/Node-TypeScript/project/deps.sh

@@ -0,0 +1,15 @@
+#!/usr/bin/env bash
+set -uo pipefail
+# Direct dependencies (production + dev + peer) — summarize if too many
+source "$(dirname "$0")/../lib/limit.sh"
+if [ ! -f package.json ]; then
+  echo "No package.json found"
+  exit 0
+fi
+out=$(node -e "const p=require('./package.json');const d={...p.dependencies,...p.devDependencies,...p.peerDependencies};if(!Object.keys(d).length){console.log('No dependencies');process.exit()};Object.entries(d).forEach(([k,v])=>console.log(k+' '+v))" 2>/dev/null)
+if [ -z "$out" ]; then
+  echo "No dependencies found in package.json"
+  exit 0
+fi
+total=$(echo "$out" | wc -l | tr -d '[:space:]')
+limit_output "$out" "$MAX_DEPS" "$(echo "$out" | head -5 && echo "... and $total total dependencies")"

package/scripts/Node-TypeScript/project/find-todos.sh

@@ -0,0 +1,6 @@
+#!/usr/bin/env bash
+set -uo pipefail
+# Find TODO, FIXME, HACK — TypeScript/JavaScript files
+source "$(dirname "$0")/../lib/limit.sh"
+out=$(grep -rn 'TODO\|FIXME\|HACK' --include="*.ts" --include="*.js" --include="*.tsx" --include="*.jsx" . 2>/dev/null | grep -v '/node_modules/' | grep -v '/.git/' | grep -v '/.pipemd/' | grep -v '/dist/')
+limit_output "$out" "$MAX_TODOS" "$(echo "$out" | head -3 && echo "... and $(($(echo "$out" | wc -l) - 3)) more items")"

package/scripts/Node-TypeScript/quality/lint.sh

@@ -0,0 +1,10 @@
+#!/usr/bin/env bash
+set -uo pipefail
+# Lint errors — compact format
+source "$(dirname "$0")/../lib/limit.sh"
+if compgen -G ".eslintrc.*" &>/dev/null || compgen -G "eslint.config.*" &>/dev/null || npx eslint --version &>/dev/null; then
+  out=$(npx eslint . --format=compact 2>&1 | grep -E "^[^W]")
+  limit_output "$out" "$MAX_LINT" "$(echo "$out" | head -3 && echo "... and $(echo "$out" | wc -l) more lint issues")"
+else
+  echo "No linter configured"
+fi

package/scripts/Node-TypeScript/quality/test-summary.sh

@@ -0,0 +1,39 @@
+#!/usr/bin/env bash
+set -uo pipefail
+# Test summary — pass/fail counts only
+source "$(dirname "$0")/../lib/limit.sh"
+
+if compgen -G "jest.config.*" &>/dev/null || [ -f jest.config.js ] || [ -f jest.config.ts ]; then
+  out=$(npx jest --no-coverage --silent 2>&1 | tail -5)
+  if [ -z "$out" ]; then
+    echo "jest ran but produced no output"
+  else
+    echo "$out"
+  fi
+  exit 0
+elif compgen -G "vitest.config.*" &>/dev/null || [ -f vitest.config.ts ] || [ -f vitest.config.js ]; then
+  out=$(npx vitest run --reporter=verbose 2>&1 | tail -5)
+  if [ -z "$out" ]; then
+    echo "vitest ran but produced no output"
+  else
+    echo "$out"
+  fi
+  exit 0
+fi
+
+# Fallback: detect test script in package.json
+if [ -f package.json ]; then
+  test_cmd=$(node -e "const p=require('./package.json');console.log(p.scripts&&p.scripts['test:unit']?'test:unit':p.scripts&&p.scripts['test']?'test':'')" 2>/dev/null)
+  if [ -n "$test_cmd" ]; then
+    pkg_mgr="npm"
+    [ -f pnpm-lock.yaml ] && pkg_mgr="pnpm"
+    [ -f yarn.lock ] && pkg_mgr="yarn"
+    out=$($pkg_mgr run $test_cmd 2>&1 | tail -"$MAX_TEST")
+    if [ -n "$out" ]; then
+      echo "$out"
+      exit 0
+    fi
+  fi
+fi
+
+echo "No test runner configured for this ecosystem"

package/scripts/Node-TypeScript/quality/type-check.sh

@@ -0,0 +1,10 @@
+#!/usr/bin/env bash
+set -uo pipefail
+# TypeScript type check — errors only
+source "$(dirname "$0")/../lib/limit.sh"
+out=$(npx tsc --noEmit 2>&1)
+if [ -z "$out" ]; then
+  echo "No type errors"
+  exit 0
+fi
+limit_output "$out" "$MAX_TYPECHECK" "$(echo "$out" | head -5 && echo "... and $(echo "$out" | grep -c 'error TS') total errors")"

package/scripts/Python/api/fastapi-routes.sh

@@ -0,0 +1,12 @@
+#!/usr/bin/env bash
+set -uo pipefail
+# FastAPI route metadata — endpoint signatures
+source "$(dirname "$0")/../lib/limit.sh"
+out=$(grep -rn --include='*.py' \
+  -E '@(app|router|APIRouter)\.(get|post|put|delete|patch)\(' \
+  . 2>/dev/null \
+  | grep -v 'venv' | grep -v '.venv' | grep -v '__pycache__' \
+  | sed -E 's/.*@(app|router|APIRouter)\.(get|post|put|delete|patch)\(\s*['\''"](\/[^'\''"]*)['\''"].*/\U\2 \3/' \
+  | head -"$MAX_FASTAPI")
+[ -z "$out" ] && echo "No FastAPI routes found" && exit 0
+echo "$out"