agentic-loop 3.1.5 → 3.2.0

package/ralph/api.sh

@@ -1,216 +0,0 @@
-#!/usr/bin/env bash
-# shellcheck shell=bash
-# api.sh - API validation for backend stories
-
-# Parse an endpoint string into method and path
-# Usage: parse_endpoint "POST /api/users" "http://localhost:3000"
-# Sets: ENDPOINT_METHOD, ENDPOINT_PATH, ENDPOINT_URL
-parse_endpoint() {
-  local endpoint="$1"
-  local base_url="${2:-}"
-
-  # Defaults
-  ENDPOINT_METHOD="GET"
-  ENDPOINT_PATH="$endpoint"
-  ENDPOINT_URL=""
-
-  # Parse method if present (e.g., "POST /api/contact")
-  if [[ "$endpoint" =~ ^(GET|POST|PUT|PATCH|DELETE)[[:space:]]+(.*) ]]; then
-    ENDPOINT_METHOD="${BASH_REMATCH[1]}"
-    ENDPOINT_PATH="${BASH_REMATCH[2]}"
-  fi
-
-  # Build full URL
-  if [[ "$ENDPOINT_PATH" =~ ^https?:// ]]; then
-    ENDPOINT_URL="$ENDPOINT_PATH"
-  elif [[ -n "$base_url" ]]; then
-    ENDPOINT_URL="${base_url}${ENDPOINT_PATH}"
-  fi
-}
-
-# Check if endpoint is a WebSocket (can't be tested with HTTP)
-is_websocket_endpoint() {
-  local endpoint="$1"
-  [[ "$endpoint" =~ ^wss?:// ]] || [[ "$endpoint" =~ ^(GET|POST|PUT|PATCH|DELETE)[[:space:]]+wss?:// ]]
-}
-
-# Validate API endpoints for a backend story
-run_api_validation() {
-  local story="$1"
-
-  # Get API endpoints from story
-  local endpoints
-  endpoints=$(jq -r --arg id "$story" '.stories[] | select(.id==$id) | .apiEndpoints[]?' "$RALPH_DIR/prd.json" 2>/dev/null)
-
-  if [[ -z "$endpoints" ]]; then
-    echo "  (no apiEndpoints defined, skipping API validation)"
-    return 0
-  fi
-
-  # Get base URL from config or use default
-  local base_url
-  base_url=$(get_config '.api.baseUrl' "http://localhost:3000")
-
-  local failed=0
-
-  echo "  Validating API endpoints..."
-
-  while IFS= read -r endpoint; do
-    [[ -z "$endpoint" ]] && continue
-
-    # Skip WebSocket endpoints - they can't be tested with HTTP curl
-    if is_websocket_endpoint "$endpoint"; then
-      echo "    Skipping WebSocket endpoint: $endpoint (use integration tests)"
-      continue
-    fi
-
-    # Parse endpoint into method, path, and full URL
-    parse_endpoint "$endpoint" "$base_url"
-
-    echo -n "    $ENDPOINT_METHOD $ENDPOINT_PATH... "
-
-    # Make the request
-    local response_code
-    response_code=$(curl -sf -m "$CURL_TIMEOUT_SECONDS" -o /dev/null -w "%{http_code}" -X "$ENDPOINT_METHOD" "$ENDPOINT_URL" 2>/dev/null)
-
-    if [[ "$response_code" =~ ^2[0-9][0-9]$ ]]; then
-      print_success "$response_code"
-    elif [[ "$response_code" == "000" ]]; then
-      print_error "connection failed"
-      failed=1
-    elif [[ "$response_code" == "422" || "$response_code" == "400" ]]; then
-      # 422/400 = endpoint exists but needs params - don't fail verification
-      print_warning "$response_code (needs params)"
-    elif [[ "$response_code" == "401" || "$response_code" == "403" ]]; then
-      # Auth required - endpoint exists
-      print_warning "$response_code (auth required)"
-    else
-      print_error "$response_code"
-      failed=1
-    fi
-  done <<< "$endpoints"
-
-  return $failed
-}
-
-# Run comprehensive API tests for a story
-run_api_tests() {
-  local story="$1"
-
-  # Get test steps that look like API calls
-  local test_steps
-  test_steps=$(jq -r --arg id "$story" '.stories[] | select(.id==$id) | .testSteps[]?' "$RALPH_DIR/prd.json" 2>/dev/null)
-
-  if [[ -z "$test_steps" ]]; then
-    return 0
-  fi
-
-  local failed=0
-  local log_file
-  log_file=$(create_temp_file ".log") || return 1
-
-  echo "  Running API test steps..."
-
-  while IFS= read -r step; do
-    [[ -z "$step" ]] && continue
-
-    # Check if this looks like a curl command or API test
-    if [[ "$step" =~ ^curl ]]; then
-      echo -n "    $step... "
-
-      if safe_exec "$step" "$log_file"; then
-        print_success "passed"
-      else
-        print_error "failed"
-        echo ""
-        echo "    Response:"
-        tail -"$MAX_OUTPUT_PREVIEW_LINES" "$log_file" | sed 's/^/      /'
-        failed=1
-      fi
-    fi
-  done <<< "$test_steps"
-
-  rm -f "$log_file"
-  return $failed
-}
-
-# Validate error handling for API
-run_api_error_tests() {
-  local story="$1"
-
-  # Get error handling requirements
-  local error_handling
-  error_handling=$(jq -r --arg id "$story" '.stories[] | select(.id==$id) | .errorHandling[]?' "$RALPH_DIR/prd.json" 2>/dev/null)
-
-  if [[ -z "$error_handling" ]]; then
-    return 0
-  fi
-
-  # Get base URL and endpoints
-  local base_url
-  base_url=$(get_config '.api.baseUrl' "http://localhost:3000")
-
-  local endpoints
-  endpoints=$(jq -r --arg id "$story" '.stories[] | select(.id==$id) | .apiEndpoints[0]?' "$RALPH_DIR/prd.json" 2>/dev/null)
-
-  if [[ -z "$endpoints" ]]; then
-    return 0
-  fi
-
-  # Skip WebSocket endpoints
-  if is_websocket_endpoint "$endpoints"; then
-    echo "  Skipping error tests for WebSocket endpoint"
-    return 0
-  fi
-
-  # Parse endpoint (default to POST for error tests)
-  parse_endpoint "$endpoints" "$base_url"
-  [[ "$ENDPOINT_METHOD" == "GET" ]] && ENDPOINT_METHOD="POST"
-
-  local failed=0
-
-  echo "  Testing API error handling..."
-
-  # Test common error cases
-  while IFS= read -r error_case; do
-    [[ -z "$error_case" ]] && continue
-
-    # Check for 400 tests (bad input)
-    if [[ "$error_case" =~ 400 ]]; then
-      echo -n "    Testing 400 (bad request)... "
-
-      local response_code
-      response_code=$(curl -sf -m "$CURL_TIMEOUT_SECONDS" -o /dev/null -w "%{http_code}" \
-        -X "$ENDPOINT_METHOD" \
-        -H "Content-Type: application/json" \
-        -d '{}' \
-        "$ENDPOINT_URL" 2>/dev/null)
-
-      if [[ "$response_code" == "400" ]]; then
-        print_success "correctly returns 400"
-      else
-        print_warning "got $response_code (expected 400)"
-        failed=1
-      fi
-    fi
-
-    # Check for 401 tests (unauthorized)
-    if [[ "$error_case" =~ 401 ]]; then
-      echo -n "    Testing 401 (unauthorized)... "
-
-      local response_code
-      response_code=$(curl -sf -m "$CURL_TIMEOUT_SECONDS" -o /dev/null -w "%{http_code}" \
-        -X "$ENDPOINT_METHOD" \
-        "$ENDPOINT_URL" 2>/dev/null)
-
-      if [[ "$response_code" == "401" ]]; then
-        print_success "correctly returns 401"
-      else
-        print_warning "got $response_code (expected 401)"
-        failed=1
-      fi
-    fi
-  done <<< "$error_handling"
-
-  return $failed
-}

package/ralph/browser-verify/README.md

@@ -1,135 +0,0 @@
-# Browser Verify Skill
-
-Verify that a web page loads correctly using real browser automation (Playwright).
-
-## Purpose
-
-This skill launches a real Chromium browser to verify pages work correctly. Unlike asking Claude to "imagine" what a page looks like, this actually:
-
-- Loads the page in a real browser
-- Detects JavaScript console errors
-- Detects failed network requests
-- Checks for error messages on the page ("Oops!", "Something went wrong")
-- Verifies required elements exist
-- Takes screenshots for evidence
-- Tests mobile viewport
-
-## When to Use
-
-Use this skill for **frontend story verification**:
-- After implementing a UI feature
-- To verify a page loads without errors
-- To check that required elements render
-- To test mobile responsiveness
-
-## Usage
-
-```bash
-npx tsx ralph/browser-verify/verify.ts <url> [options]
-```
-
-### Options
-
-| Option | Description | Default |
-|--------|-------------|---------|
-| `--selectors '["#app", ".btn"]'` | Required elements (JSON array) | `[]` |
-| `--screenshot <path>` | Save screenshot to path | none |
-| `--timeout <ms>` | Page load timeout | 30000 |
-| `--headless` | Run without visible browser | true |
-| `--no-headless` | Show browser window | false |
-| `--check-console` | Fail on console errors | true |
-| `--no-check-console` | Ignore console errors | false |
-| `--mobile` | Use mobile viewport (375x667) | false |
-| `--viewport <W>x<H>` | Custom viewport size | 1280x720 |
-
-### Examples
-
-**Basic page check:**
-```bash
-npx tsx ralph/browser-verify/verify.ts http://localhost:3000/dashboard
-```
-
-**Check specific elements exist:**
-```bash
-npx tsx ralph/browser-verify/verify.ts http://localhost:3000/login \
-  --selectors '["#email", "#password", "button[type=submit]"]'
-```
-
-**Take screenshot and check mobile:**
-```bash
-npx tsx ralph/browser-verify/verify.ts http://localhost:3000/dashboard \
-  --screenshot .ralph/screenshots/dashboard.png \
-  --mobile
-```
-
-**Debug mode (visible browser):**
-```bash
-npx tsx ralph/browser-verify/verify.ts http://localhost:3000/dashboard \
-  --no-headless
-```
-
-## Output
-
-Returns JSON to stdout:
-
-```json
-{
-  "pass": true,
-  "errors": [],
-  "warnings": ["Page loaded slowly (3500ms)"],
-  "screenshot": ".ralph/screenshots/dashboard.png",
-  "title": "Dashboard - MyApp",
-  "elementsFound": ["#app", ".header", ".sidebar"],
-  "elementsMissing": [],
-  "consoleErrors": [],
-  "networkErrors": [],
-  "loadTime": 1234
-}
-```
-
-### Exit Codes
-
-- `0` - Verification passed
-- `1` - Verification failed (check `errors` array)
-
-## What It Catches
-
-| Issue | How It's Detected |
-|-------|-------------------|
-| Page won't load | Connection refused, timeout |
-| JavaScript errors | Console error messages |
-| Failed API calls | Network request failures, 4xx/5xx responses |
-| Error pages | Text matching "Oops!", "Something went wrong", etc. |
-| Missing elements | Selector not found in DOM |
-| Slow pages | Load time > 5 seconds (warning) |
-
-## Integration with Ralph
-
-Ralph automatically uses this skill for frontend story verification:
-
-1. Story has `testUrl` defined
-2. Ralph calls `verify.ts` with the URL
-3. Optionally checks `selectors` from story config
-4. Takes screenshot for evidence
-5. Fails verification if errors detected
-
-## Requirements
-
-- Node.js 18+
-- Playwright (`npx playwright install chromium`)
-
-## Troubleshooting
-
-**"Cannot find module 'playwright'"**
-```bash
-npm install playwright
-npx playwright install chromium
-```
-
-**"Browser closed unexpectedly"**
-- Try with `--no-headless` to see what's happening
-- Check if the URL is accessible
-
-**"Timeout waiting for page"**
-- Increase timeout: `--timeout 60000`
-- Check if dev server is running