claude-pro-minmax 1.0.0

package/scripts/runtime/adapters/generic.sh

@@ -0,0 +1,78 @@
+#!/bin/bash
+# generic.sh - Generic Adapter (Makefile fallback)
+# Used when no specific runtime is detected
+set -euo pipefail
+
+PROJECT_DIR="${CLAUDE_PROJECT_DIR:-.}"
+
+adapter_info() {
+  echo '{"runtime":"generic","tool":"make","languages":["unknown"]}'
+}
+
+adapter_verify() {
+  cd "$PROJECT_DIR"
+  if [[ -f "Makefile" ]]; then
+    make check 2>/dev/null || make test 2>/dev/null || make verify 2>/dev/null || true
+  else
+    echo "⚠️ No recognized build system found."
+    echo "Supported: Gradle, Maven, npm, pnpm, yarn, Cargo, Go, Poetry, pip"
+    echo "Please specify the build commands manually."
+    return 1
+  fi
+}
+
+adapter_build() {
+  cd "$PROJECT_DIR"
+  if [[ -f "Makefile" ]]; then
+    make build 2>/dev/null || make all 2>/dev/null || make
+  else
+    echo "No Makefile found. Cannot build."
+    return 1
+  fi
+}
+
+adapter_test() {
+  cd "$PROJECT_DIR"
+  if [[ -f "Makefile" ]]; then
+    make test
+  else
+    echo "No Makefile found. Cannot run tests."
+    return 1
+  fi
+}
+
+adapter_lint() {
+  cd "$PROJECT_DIR"
+  if [[ -f "Makefile" ]]; then
+    make lint 2>/dev/null || true
+  else
+    echo "No Makefile found. Cannot lint."
+  fi
+}
+
+adapter_format() {
+  cd "$PROJECT_DIR"
+  if [[ -f "Makefile" ]]; then
+    make format 2>/dev/null || make fmt 2>/dev/null || true
+  else
+    echo "No Makefile found. Cannot format."
+  fi
+}
+
+adapter_run() {
+  cd "$PROJECT_DIR"
+  if [[ -f "Makefile" ]]; then
+    make run 2>/dev/null || make start 2>/dev/null || make serve 2>/dev/null
+  else
+    echo "No Makefile found. Cannot run."
+    return 1
+  fi
+}
+
+adapter_clean() {
+  cd "$PROJECT_DIR"
+  if [[ -f "Makefile" ]]; then
+    make clean 2>/dev/null || true
+  fi
+  echo "Generic clean completed"
+}

package/scripts/runtime/adapters/go.sh

@@ -0,0 +1,51 @@
+#!/bin/bash
+# go.sh - Go Adapter
+# Supports Go modules
+set -euo pipefail
+
+PROJECT_DIR="${CLAUDE_PROJECT_DIR:-.}"
+
+adapter_info() {
+  echo '{"runtime":"go","tool":"go","languages":["go"]}'
+}
+
+adapter_verify() {
+  cd "$PROJECT_DIR"
+  go build ./... && go test ./... && go vet ./...
+}
+
+adapter_build() {
+  cd "$PROJECT_DIR"
+  go build ./...
+}
+
+adapter_test() {
+  cd "$PROJECT_DIR"
+  go test ./...
+}
+
+adapter_lint() {
+  cd "$PROJECT_DIR"
+  # Try golangci-lint first, fallback to go vet
+  if command -v golangci-lint &>/dev/null; then
+    golangci-lint run
+  else
+    go vet ./...
+  fi
+}
+
+adapter_format() {
+  cd "$PROJECT_DIR"
+  gofmt -w .
+}
+
+adapter_run() {
+  cd "$PROJECT_DIR"
+  go run .
+}
+
+adapter_clean() {
+  cd "$PROJECT_DIR"
+  go clean
+  rm -rf bin/ 2>/dev/null || true
+}

package/scripts/runtime/adapters/jvm.sh

@@ -0,0 +1,97 @@
+#!/bin/bash
+# jvm.sh - JVM Adapter (Gradle/Maven)
+# Supports Java, Kotlin, Spring Boot
+set -euo pipefail
+
+PROJECT_DIR="${CLAUDE_PROJECT_DIR:-.}"
+
+_detect_tool() {
+  [[ -f "$PROJECT_DIR/gradlew" ]] && echo "gradle" && return
+  [[ -f "$PROJECT_DIR/mvnw" ]] && echo "maven" && return
+  [[ -f "$PROJECT_DIR/build.gradle.kts" ]] && echo "gradle" && return
+  [[ -f "$PROJECT_DIR/build.gradle" ]] && echo "gradle" && return
+  [[ -f "$PROJECT_DIR/pom.xml" ]] && echo "maven" && return
+  echo "gradle"  # default
+}
+
+_gradle() {
+  if [[ -f "$PROJECT_DIR/gradlew" ]]; then
+    "$PROJECT_DIR/gradlew" "$@"
+  else
+    gradle "$@"
+  fi
+}
+
+_maven() {
+  if [[ -f "$PROJECT_DIR/mvnw" ]]; then
+    "$PROJECT_DIR/mvnw" "$@"
+  else
+    mvn "$@"
+  fi
+}
+
+adapter_info() {
+  echo '{"runtime":"jvm","tools":["gradle","maven"],"languages":["java","kotlin"]}'
+}
+
+adapter_verify() {
+  case $(_detect_tool) in
+    gradle) _gradle check --no-daemon ;;
+    maven) _maven verify -q ;;
+  esac
+}
+
+adapter_build() {
+  case $(_detect_tool) in
+    gradle) _gradle build --no-daemon -x test ;;
+    maven) _maven package -q -DskipTests ;;
+  esac
+}
+
+adapter_test() {
+  case $(_detect_tool) in
+    gradle) _gradle test --no-daemon ;;
+    maven) _maven test -q ;;
+  esac
+}
+
+adapter_lint() {
+  case $(_detect_tool) in
+    gradle)
+      # Try ktlint for Kotlin, then checkstyle for Java
+      _gradle ktlintCheck --no-daemon 2>/dev/null || \
+      _gradle checkstyleMain --no-daemon 2>/dev/null || \
+      true
+      ;;
+    maven)
+      _maven checkstyle:check -q 2>/dev/null || true
+      ;;
+  esac
+}
+
+adapter_format() {
+  case $(_detect_tool) in
+    gradle)
+      _gradle ktlintFormat --no-daemon 2>/dev/null || \
+      _gradle spotlessApply --no-daemon 2>/dev/null || \
+      true
+      ;;
+    maven)
+      _maven spotless:apply -q 2>/dev/null || true
+      ;;
+  esac
+}
+
+adapter_run() {
+  case $(_detect_tool) in
+    gradle) _gradle bootRun --no-daemon 2>/dev/null || _gradle run --no-daemon ;;
+    maven) _maven spring-boot:run -q 2>/dev/null || _maven exec:java -q ;;
+  esac
+}
+
+adapter_clean() {
+  case $(_detect_tool) in
+    gradle) _gradle clean --no-daemon ;;
+    maven) _maven clean -q ;;
+  esac
+}

package/scripts/runtime/adapters/node.sh

@@ -0,0 +1,104 @@
+#!/bin/bash
+# node.sh - Node Adapter (npm/pnpm/yarn/bun)
+# Supports TypeScript, JavaScript, React, Next.js, Vite
+set -euo pipefail
+
+PROJECT_DIR="${CLAUDE_PROJECT_DIR:-.}"
+
+_detect_pm() {
+  [[ -f "$PROJECT_DIR/pnpm-lock.yaml" ]] && echo "pnpm" && return
+  [[ -f "$PROJECT_DIR/yarn.lock" ]] && echo "yarn" && return
+  [[ -f "$PROJECT_DIR/bun.lockb" ]] && echo "bun" && return
+  echo "npm"
+}
+
+_run() {
+  local pm=$(_detect_pm)
+  case $pm in
+    pnpm) pnpm "$@" ;;
+    yarn) yarn "$@" ;;
+    bun) bun "$@" ;;
+    *) npm "$@" ;;
+  esac
+}
+
+_has_script() {
+  local script="$1"
+  [[ -f "$PROJECT_DIR/package.json" ]] && \
+    grep -q "\"$script\":" "$PROJECT_DIR/package.json" 2>/dev/null
+}
+
+adapter_info() {
+  local pm=$(_detect_pm)
+  echo "{\"runtime\":\"node\",\"tool\":\"$pm\",\"languages\":[\"typescript\",\"javascript\"]}"
+}
+
+adapter_verify() {
+  # Type check if TypeScript
+  if [[ -f "$PROJECT_DIR/tsconfig.json" ]]; then
+    npx tsc --noEmit 2>/dev/null || true
+  fi
+  
+  # Lint
+  if _has_script "lint"; then
+    _run run lint 2>/dev/null || true
+  elif [[ -f "$PROJECT_DIR/.eslintrc.js" ]] || [[ -f "$PROJECT_DIR/.eslintrc.json" ]] || [[ -f "$PROJECT_DIR/eslint.config.js" ]] || [[ -f "$PROJECT_DIR/eslint.config.mjs" ]]; then
+    npx eslint . 2>/dev/null || true
+  fi
+  
+  # Test
+  if _has_script "test"; then
+    _run test 2>/dev/null || true
+  fi
+}
+
+adapter_build() {
+  if _has_script "build"; then
+    _run run build
+  else
+    echo "No build script found in package.json"
+  fi
+}
+
+adapter_test() {
+  if _has_script "test"; then
+    _run test
+  elif [[ -f "$PROJECT_DIR/vitest.config.ts" ]] || [[ -f "$PROJECT_DIR/vitest.config.js" ]]; then
+    npx vitest run
+  elif [[ -f "$PROJECT_DIR/jest.config.js" ]] || [[ -f "$PROJECT_DIR/jest.config.ts" ]]; then
+    npx jest
+  else
+    echo "No test runner found"
+  fi
+}
+
+adapter_lint() {
+  if _has_script "lint"; then
+    _run run lint
+  else
+    npx eslint . 2>/dev/null || true
+  fi
+}
+
+adapter_format() {
+  if _has_script "format"; then
+    _run run format
+  else
+    npx prettier --write . 2>/dev/null || true
+  fi
+}
+
+adapter_run() {
+  if _has_script "dev"; then
+    _run run dev
+  elif _has_script "start"; then
+    _run start
+  else
+    echo "No dev or start script found"
+  fi
+}
+
+adapter_clean() {
+  rm -rf node_modules dist build .next out .nuxt .output .turbo 2>/dev/null || true
+  echo "Cleaned node_modules, dist, build, .next, out"
+}

package/scripts/runtime/adapters/python.sh

@@ -0,0 +1,116 @@
+#!/bin/bash
+# python.sh - Python Adapter
+# Supports pip, poetry, uv
+set -euo pipefail
+
+PROJECT_DIR="${CLAUDE_PROJECT_DIR:-.}"
+
+_detect_tool() {
+  [[ -f "$PROJECT_DIR/poetry.lock" ]] && echo "poetry" && return
+  [[ -f "$PROJECT_DIR/uv.lock" ]] && echo "uv" && return
+  [[ -f "$PROJECT_DIR/Pipfile.lock" ]] && echo "pipenv" && return
+  echo "pip"
+}
+
+_run() {
+  local tool=$(_detect_tool)
+  case $tool in
+    poetry) poetry run "$@" ;;
+    uv) uv run "$@" ;;
+    pipenv) pipenv run "$@" ;;
+    *) python -m "$@" ;;
+  esac
+}
+
+adapter_info() {
+  local tool=$(_detect_tool)
+  echo "{\"runtime\":\"python\",\"tool\":\"$tool\",\"languages\":[\"python\"]}"
+}
+
+adapter_verify() {
+  cd "$PROJECT_DIR"
+  local tool=$(_detect_tool)
+  
+  # Type check with mypy
+  case $tool in
+    poetry) poetry run mypy . 2>/dev/null || true ;;
+    uv) uv run mypy . 2>/dev/null || true ;;
+    *) python -m mypy . 2>/dev/null || true ;;
+  esac
+  
+  # Run tests
+  case $tool in
+    poetry) poetry run pytest ;;
+    uv) uv run pytest ;;
+    *) python -m pytest ;;
+  esac
+}
+
+adapter_build() {
+  cd "$PROJECT_DIR"
+  local tool=$(_detect_tool)
+  
+  case $tool in
+    poetry) poetry build ;;
+    uv) uv build 2>/dev/null || python -m build ;;
+    *) python -m build ;;
+  esac
+}
+
+adapter_test() {
+  cd "$PROJECT_DIR"
+  local tool=$(_detect_tool)
+  
+  case $tool in
+    poetry) poetry run pytest ;;
+    uv) uv run pytest ;;
+    *) python -m pytest ;;
+  esac
+}
+
+adapter_lint() {
+  cd "$PROJECT_DIR"
+  # Try ruff first (faster), then flake8
+  if command -v ruff &>/dev/null; then
+    ruff check .
+  elif command -v flake8 &>/dev/null; then
+    flake8 .
+  else
+    _run flake8 . 2>/dev/null || true
+  fi
+}
+
+adapter_format() {
+  cd "$PROJECT_DIR"
+  # Try ruff format first, then black
+  if command -v ruff &>/dev/null; then
+    ruff format .
+  elif command -v black &>/dev/null; then
+    black .
+  else
+    _run black . 2>/dev/null || true
+  fi
+}
+
+adapter_run() {
+  cd "$PROJECT_DIR"
+  local tool=$(_detect_tool)
+  
+  if [[ -f "$PROJECT_DIR/manage.py" ]]; then
+    # Django
+    _run python manage.py runserver
+  elif [[ -f "$PROJECT_DIR/app.py" ]]; then
+    _run python app.py
+  elif [[ -f "$PROJECT_DIR/main.py" ]]; then
+    _run python main.py
+  else
+    echo "No entry point found (manage.py, app.py, main.py)"
+  fi
+}
+
+adapter_clean() {
+  cd "$PROJECT_DIR"
+  rm -rf __pycache__ .pytest_cache .mypy_cache .ruff_cache dist build *.egg-info .eggs 2>/dev/null || true
+  find . -type d -name "__pycache__" -exec rm -rf {} + 2>/dev/null || true
+  echo "Cleaned Python cache and build directories"
+}

package/scripts/runtime/adapters/rust.sh

@@ -0,0 +1,49 @@
+#!/bin/bash
+# rust.sh - Rust Adapter
+# Supports Cargo
+set -euo pipefail
+
+PROJECT_DIR="${CLAUDE_PROJECT_DIR:-.}"
+
+adapter_info() {
+  echo '{"runtime":"rust","tool":"cargo","languages":["rust"]}'
+}
+
+adapter_verify() {
+  cd "$PROJECT_DIR"
+  cargo check && cargo test && (cargo clippy 2>/dev/null || true)
+}
+
+adapter_build() {
+  cd "$PROJECT_DIR"
+  cargo build
+}
+
+adapter_test() {
+  cd "$PROJECT_DIR"
+  cargo test
+}
+
+adapter_lint() {
+  cd "$PROJECT_DIR"
+  if command -v cargo-clippy &>/dev/null || cargo clippy --version &>/dev/null; then
+    cargo clippy
+  else
+    echo "clippy not installed, skipping lint"
+  fi
+}
+
+adapter_format() {
+  cd "$PROJECT_DIR"
+  cargo fmt
+}
+
+adapter_run() {
+  cd "$PROJECT_DIR"
+  cargo run
+}
+
+adapter_clean() {
+  cd "$PROJECT_DIR"
+  cargo clean
+}

package/scripts/runtime/detect.sh

@@ -0,0 +1,52 @@
+#!/bin/bash
+# detect.sh - Runtime Detection with Monorepo Support
+# OCP Runtime-Adaptive Architecture
+set -euo pipefail
+
+PROJECT_DIR="${CLAUDE_PROJECT_DIR:-.}"
+TARGET_DIR="$PROJECT_DIR"
+
+# Parse --path argument for Monorepo support
+while [[ $# -gt 0 ]]; do
+  case $1 in
+    --path) TARGET_DIR="$PROJECT_DIR/$2"; shift 2 ;;
+    *) shift ;;
+  esac
+done
+
+# Detection priority order
+detect_runtime() {
+  local dir="$1"
+  
+  # JVM (Gradle > Maven)
+  [[ -f "$dir/build.gradle.kts" ]] && echo '{"runtime":"jvm","tool":"gradle-kts","adapter":"jvm.sh"}' && return
+  [[ -f "$dir/build.gradle" ]] && echo '{"runtime":"jvm","tool":"gradle","adapter":"jvm.sh"}' && return
+  [[ -f "$dir/pom.xml" ]] && echo '{"runtime":"jvm","tool":"maven","adapter":"jvm.sh"}' && return
+  
+  # Node (detect package manager)
+  if [[ -f "$dir/package.json" ]]; then
+    [[ -f "$dir/pnpm-lock.yaml" ]] && echo '{"runtime":"node","tool":"pnpm","adapter":"node.sh"}' && return
+    [[ -f "$dir/yarn.lock" ]] && echo '{"runtime":"node","tool":"yarn","adapter":"node.sh"}' && return
+    [[ -f "$dir/bun.lockb" ]] && echo '{"runtime":"node","tool":"bun","adapter":"node.sh"}' && return
+    echo '{"runtime":"node","tool":"npm","adapter":"node.sh"}' && return
+  fi
+  
+  # Rust
+  [[ -f "$dir/Cargo.toml" ]] && echo '{"runtime":"rust","tool":"cargo","adapter":"rust.sh"}' && return
+  
+  # Go
+  [[ -f "$dir/go.mod" ]] && echo '{"runtime":"go","tool":"go","adapter":"go.sh"}' && return
+  
+  # Python (check lock files first for accurate tool detection)
+  if [[ -f "$dir/pyproject.toml" ]] || [[ -f "$dir/setup.py" ]] || [[ -f "$dir/requirements.txt" ]]; then
+    [[ -f "$dir/poetry.lock" ]] && echo '{"runtime":"python","tool":"poetry","adapter":"python.sh"}' && return
+    [[ -f "$dir/uv.lock" ]] && echo '{"runtime":"python","tool":"uv","adapter":"python.sh"}' && return
+    [[ -f "$dir/Pipfile.lock" ]] && echo '{"runtime":"python","tool":"pipenv","adapter":"python.sh"}' && return
+    echo '{"runtime":"python","tool":"pip","adapter":"python.sh"}' && return
+  fi
+  
+  # Generic fallback
+  echo '{"runtime":"generic","tool":"make","adapter":"generic.sh"}'
+}
+
+detect_runtime "$TARGET_DIR"

package/scripts/scrub-secrets.js

@@ -0,0 +1,48 @@
+#!/usr/bin/env node
+/**
+ * Secret Scrubber
+ * Removes 15+ secret patterns from text
+ * Usage: cat file | node scrub-secrets.js > clean-file
+ */
+
+const readline = require('readline');
+
+const PATTERNS = [
+  { p: /sk-[a-zA-Z0-9\-]{20,}/g, r: '[REDACTED:OPENAI_KEY]' },
+  { p: /sk-ant-[a-zA-Z0-9\-]{20,}/g, r: '[REDACTED:ANTHROPIC_KEY]' },
+  { p: /pplx-[a-zA-Z0-9\-]{20,}/g, r: '[REDACTED:PERPLEXITY_KEY]' },
+  { p: /sk_live_[a-zA-Z0-9]{20,}/g, r: '[REDACTED:STRIPE_LIVE]' },
+  { p: /sk_test_[a-zA-Z0-9]{20,}/g, r: '[REDACTED:STRIPE_TEST]' },
+  { p: /ghp_[a-zA-Z0-9]{36}/g, r: '[REDACTED:GITHUB_PAT]' },
+  { p: /gho_[a-zA-Z0-9]{36}/g, r: '[REDACTED:GITHUB_OAUTH]' },
+  { p: /AKIA[A-Z0-9]{16}/g, r: '[REDACTED:AWS_KEY]' },
+  { p: /postgres(ql)?:\/\/[^:]+:[^@]+@[^\s]+/g, r: '[REDACTED:POSTGRES_URL]' },
+  { p: /mysql:\/\/[^:]+:[^@]+@[^\s]+/g, r: '[REDACTED:MYSQL_URL]' },
+  { p: /mongodb(\+srv)?:\/\/[^:]+:[^@]+@[^\s]+/g, r: '[REDACTED:MONGODB_URL]' },
+  { p: /Bearer\s+[a-zA-Z0-9\-_.]{20,}/g, r: 'Bearer [REDACTED:TOKEN]' },
+  { p: /eyJ[a-zA-Z0-9\-_]+\.eyJ[a-zA-Z0-9\-_]+\.[a-zA-Z0-9\-_]+/g, r: '[REDACTED:JWT]' },
+  { p: /password["'\s:=]+["'][^"']{4,}["']/gi, r: 'password: "[REDACTED]"' },
+  { p: /secret["'\s:=]+["'][^"']{8,}["']/gi, r: 'secret: "[REDACTED]"' },
+  { p: /-----BEGIN[A-Z\s]+PRIVATE KEY-----[\s\S]*?-----END[A-Z\s]+PRIVATE KEY-----/g, r: '[REDACTED:PRIVATE_KEY]' },
+];
+
+let count = 0;
+
+function scrub(line) {
+  let result = line;
+  for (const { p, r } of PATTERNS) {
+    const m = result.match(p);
+    if (m) { count += m.length; result = result.replace(p, r); }
+  }
+  return result;
+}
+
+async function main() {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout, terminal: false });
+  const lines = [];
+  for await (const line of rl) lines.push(scrub(line));
+  console.log(lines.join('\n'));
+  console.error(`\n--- Scrubbed: ${count} secrets ---`);
+}
+
+main().catch(console.error);

package/scripts/snapshot.sh

@@ -0,0 +1,45 @@
+#!/bin/bash
+# snapshot.sh - Atomic rollback helper for /do commands
+# Deterministic git stash with label-based safety guard
+# Usage: scripts/snapshot.sh push|pop|drop [label]
+set -euo pipefail
+
+ACTION="${1:-}"
+LABEL="${2:-cpmm-do}"
+STASH_ID="${LABEL}-$(date +%s)"
+
+case "$ACTION" in
+  push)
+    BEFORE=$(git stash list 2>/dev/null | wc -l | tr -d ' ')
+    git stash push -m "$STASH_ID" 2>/dev/null || true
+    AFTER=$(git stash list 2>/dev/null | wc -l | tr -d ' ')
+    if [ "$AFTER" -gt "$BEFORE" ]; then
+      echo "SNAPSHOT=true"
+    else
+      echo "SNAPSHOT=false"
+    fi
+    ;;
+  pop)
+    # Check if top stash is ours (cpmm-labeled) before popping
+    TOP=$(git stash list -1 2>/dev/null || echo "")
+    if echo "$TOP" | grep -q "cpmm-"; then
+      git stash pop 2>/dev/null && echo "RESTORED" || echo "RESTORE_FAILED"
+    else
+      # No cpmm snapshot — discard tracked changes only
+      git checkout . 2>/dev/null && echo "CHECKOUT_CLEAN" || echo "CLEAN_FAILED"
+    fi
+    ;;
+  drop)
+    # Check if top stash is ours (cpmm-labeled) before dropping
+    TOP=$(git stash list -1 2>/dev/null || echo "")
+    if echo "$TOP" | grep -q "cpmm-"; then
+      git stash drop 2>/dev/null && echo "DROPPED" || echo "DROP_FAILED"
+    else
+      echo "NO_SNAPSHOT"
+    fi
+    ;;
+  *)
+    echo "Usage: scripts/snapshot.sh push|pop|drop [label]" >&2
+    exit 1
+    ;;
+esac

package/scripts/test.sh

@@ -0,0 +1,34 @@
+#!/bin/bash
+# test.sh - Universal Test
+# Delegates to runtime-specific adapter
+set -euo pipefail
+
+PROJECT_DIR="${CLAUDE_PROJECT_DIR:-.}"
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+RUNTIME_DIR="$SCRIPT_DIR/runtime"
+
+# Detect runtime
+RUNTIME=$("$RUNTIME_DIR/detect.sh" "$@")
+
+# Parse JSON - prefer jq, fallback to bash
+parse_json() {
+  local key="$1"
+  if command -v jq &>/dev/null; then
+    echo "$RUNTIME" | jq -r ".$key"
+  else
+    echo "$RUNTIME" | sed 's/.*"'"$key"'":"\([^"]*\)".*/\1/'
+  fi
+}
+
+ADAPTER=$(parse_json adapter)
+RUNTIME_NAME=$(parse_json runtime)
+TOOL_NAME=$(parse_json tool)
+
+echo "🔍 Detected: $RUNTIME_NAME ($TOOL_NAME)"
+
+# Source adapter
+source "$RUNTIME_DIR/adapters/$ADAPTER"
+
+# Execute
+echo "🧪 Running tests..."
+adapter_test