agentic-loop 1.0.0

package/ralph/verify/browser.sh

@@ -0,0 +1,324 @@
+#!/usr/bin/env bash
+# shellcheck shell=bash
+# browser.sh - Browser validation module for ralph
+
+# Browser validation for frontend stories using Playwright
+run_browser_validation() {
+  local story="$1"
+
+  # Check if browser validation is enabled in config
+  local browser_enabled
+  browser_enabled=$(get_config '.verification.browserEnabled' "true")
+  if [[ "$browser_enabled" == "false" ]]; then
+    echo "    (browser validation disabled in config, skipping)"
+    return 0
+  fi
+
+  # Get base URL from config (required for relative URLs)
+  local base_url
+  base_url=$(get_config '.testUrlBase' "")
+
+  # Check if Docker mode - Playwright needs special handling
+  local docker_enabled
+  docker_enabled=$(get_config '.docker.enabled' "false")
+  if [[ "$docker_enabled" == "true" ]]; then
+    echo "    (Docker mode: using curl check - set verification.browserEnabled=false to hide this)"
+    # In Docker, fall back to curl unless they've set up remote browser
+    local url
+    url=$(jq -r --arg id "$story" '.stories[] | select(.id==$id) | .testUrl // empty' "$RALPH_DIR/prd.json" 2>/dev/null)
+    if [[ -n "$url" ]]; then
+      # Check for unsubstituted template variables
+      if [[ "$url" =~ \{[a-zA-Z_][a-zA-Z0-9_]*\} ]]; then
+        print_warning "    testUrl has unsubstituted variable: $url"
+        return 0
+      fi
+      # Handle relative URLs
+      if [[ "$url" =~ ^/ ]]; then
+        if [[ -z "$base_url" ]]; then
+          print_error "testUrlBase not set in config.json (needed for relative URL: $url)"
+          return 1
+        fi
+        url="${base_url}${url}"
+      fi
+      return run_curl_check "$url"
+    fi
+    return 0
+  fi
+
+  local url
+  url=$(jq -r --arg id "$story" '.stories[] | select(.id==$id) | .testUrl // empty' "$RALPH_DIR/prd.json" 2>/dev/null)
+
+  if [[ -z "$url" ]]; then
+    echo "    skipped (no testUrl - infrastructure or backend story)"
+    return 0
+  fi
+
+  # Check for unsubstituted template variables like {collectionId}
+  if [[ "$url" =~ \{[a-zA-Z_][a-zA-Z0-9_]*\} ]]; then
+    print_warning "    testUrl has unsubstituted variable: $url"
+    echo "    Add concrete ID to testUrl in PRD, or set in .ralph/config.json testUrlVars"
+    echo "    skipped"
+    return 0
+  fi
+
+  # Handle relative URLs by prepending base URL from config
+  if [[ "$url" =~ ^/ ]]; then
+    if [[ -z "$base_url" ]]; then
+      print_error "testUrlBase not set in config.json (needed for relative URL: $url)"
+      return 1
+    fi
+    url="${base_url}${url}"
+  fi
+
+  if ! validate_url "$url"; then
+    print_error "Invalid URL: $url"
+    return 1
+  fi
+
+  echo "    URL: $url"
+
+  # Check if npx is available
+  if ! command -v npx &>/dev/null; then
+    print_warning "    npx not found, skipping browser validation"
+    return 0
+  fi
+
+  # Check if Playwright package is installed
+  local playwright_installed=false
+  if npm list playwright &>/dev/null || npm list -g playwright &>/dev/null; then
+    playwright_installed=true
+  fi
+
+  # Check if browser binaries are installed (look for chromium in cache)
+  # macOS uses ~/Library/Caches, Linux uses ~/.cache
+  local browser_installed=false
+  local playwright_cache=""
+  if [[ -d "$HOME/Library/Caches/ms-playwright" ]]; then
+    playwright_cache="$HOME/Library/Caches/ms-playwright"
+  elif [[ -d "$HOME/.cache/ms-playwright" ]]; then
+    playwright_cache="$HOME/.cache/ms-playwright"
+  fi
+  if [[ -n "$playwright_cache" ]] && ls "$playwright_cache"/chromium-* &>/dev/null; then
+    browser_installed=true
+  fi
+
+  # If either is missing, auto-install (Ralph runs autonomously)
+  if [[ "$playwright_installed" == "false" ]] || [[ "$browser_installed" == "false" ]]; then
+    echo ""
+    print_info "    Installing Playwright for browser verification (~150MB)..."
+    if npm install playwright &>/dev/null && npx playwright install chromium &>/dev/null; then
+      print_success "    Playwright installed!"
+    else
+      print_warning "    Installation failed, falling back to curl check"
+      return run_curl_check "$url"
+    fi
+  fi
+
+  # Get selectors to check from story (if defined)
+  local selectors
+  selectors=$(jq -r --arg id "$story" '.stories[] | select(.id==$id) | .selectors // [] | @json' "$RALPH_DIR/prd.json" 2>/dev/null)
+  if [[ "$selectors" == "null" || -z "$selectors" ]]; then
+    selectors="[]"
+  fi
+
+  # Screenshot path
+  mkdir -p "$RALPH_DIR/screenshots"
+  local screenshot_path="$RALPH_DIR/screenshots/${story}.png"
+
+  # Check mobile too?
+  local check_mobile
+  check_mobile=$(jq -r --arg id "$story" '.stories[] | select(.id==$id) | .mobile // empty' "$RALPH_DIR/prd.json" 2>/dev/null)
+
+  # Build command - use the browser-verify skill
+  local verify_script="$RALPH_LIB/browser-verify/verify.ts"
+
+  if [[ ! -f "$verify_script" ]]; then
+    print_warning "    browser-verify.ts not found, falling back to curl check"
+    return run_curl_check "$url"
+  fi
+
+  # Check for auth config (env vars take precedence over config file)
+  local auth_login=""
+  local login_url
+  local test_user
+  local test_password
+  login_url=$(get_config '.auth.loginUrl' "")
+  test_user="${RALPH_TEST_USER:-$(get_config '.auth.testUser' "")}"
+  test_password="${RALPH_TEST_PASSWORD:-$(get_config '.auth.testPassword' "")}"
+
+  if [[ -n "$login_url" && -n "$test_user" && -n "$test_password" ]]; then
+    # Build auth login JSON
+    local username_selector
+    local password_selector
+    local submit_selector
+    local success_indicator
+    username_selector=$(get_config '.auth.usernameSelector' "input[name='email'], input[name='username'], input[type='email']")
+    password_selector=$(get_config '.auth.passwordSelector' "input[name='password'], input[type='password']")
+    submit_selector=$(get_config '.auth.submitSelector' "button[type='submit'], input[type='submit']")
+    success_indicator=$(get_config '.auth.successIndicator' "")
+
+    auth_login=$(jq -n \
+      --arg loginUrl "$login_url" \
+      --arg usernameSelector "$username_selector" \
+      --arg passwordSelector "$password_selector" \
+      --arg submitSelector "$submit_selector" \
+      --arg username "$test_user" \
+      --arg password "$test_password" \
+      --arg successIndicator "$success_indicator" \
+      '{
+        loginUrl: $loginUrl,
+        usernameSelector: $usernameSelector,
+        passwordSelector: $passwordSelector,
+        submitSelector: $submitSelector,
+        username: $username,
+        password: $password,
+        successIndicator: (if $successIndicator == "" then null else $successIndicator end)
+      }')
+  fi
+
+  echo "    Running Playwright verification..."
+
+  local result
+  local exit_code=0
+
+  # Build the command with optional auth
+  local cmd_args=(
+    npx tsx "$verify_script" "$url"
+    --selectors "$selectors"
+    --screenshot "$screenshot_path"
+    --timeout "$BROWSER_PAGE_TIMEOUT_MS"
+  )
+
+  if [[ -n "$auth_login" ]]; then
+    cmd_args+=(--auth-login "$auth_login")
+  fi
+
+  # Run browser verification with wrapper timeout (in case Playwright hangs)
+  result=$(run_with_timeout "$BROWSER_TIMEOUT_SECONDS" "${cmd_args[@]}" 2>&1) || exit_code=$?
+
+  # Check for timeout
+  if [[ $exit_code -eq 124 ]]; then
+    print_error "failed (timed out after ${BROWSER_TIMEOUT_SECONDS}s)"
+    echo "    The page may be stuck loading or the dev server isn't responding."
+    echo "    Check: curl -I $url"
+    return run_curl_check "$url"
+  fi
+
+  # Check if we got any output
+  if [[ -z "$result" ]]; then
+    print_error "failed (no output from Playwright)"
+    echo "    Exit code: $exit_code"
+    echo "    This usually means Playwright crashed or isn't installed correctly."
+    echo "    Try: npm install playwright && npx playwright install chromium"
+    return run_curl_check "$url"
+  fi
+
+  # Check if result is valid JSON
+  if ! echo "$result" | jq -e . >/dev/null 2>&1; then
+    print_error "failed (invalid response)"
+    echo "    Raw output:"
+    echo "$result" | head -20 | sed 's/^/      /'
+    return run_curl_check "$url"
+  fi
+
+  # Parse result
+  local passed
+  passed=$(echo "$result" | jq -r '.pass // false' 2>/dev/null)
+
+  if [[ "$passed" == "true" ]]; then
+    local load_time
+    load_time=$(echo "$result" | jq -r '.loadTime // 0' 2>/dev/null)
+    print_success "passed (${load_time}ms)"
+
+    # Show any warnings
+    local warnings
+    warnings=$(echo "$result" | jq -r '.warnings[]?' 2>/dev/null)
+    if [[ -n "$warnings" ]]; then
+      echo "$warnings" | sed 's/^/      Warning: /'
+    fi
+
+    # Run mobile check if required
+    if [[ -n "$check_mobile" ]]; then
+      echo -n "    Mobile viewport... "
+      local mobile_result
+      mobile_result=$(run_with_timeout "$BROWSER_TIMEOUT_SECONDS" npx tsx "$verify_script" "$url" \
+        --selectors "$selectors" \
+        --screenshot "$RALPH_DIR/screenshots/${story}-mobile.png" \
+        --mobile \
+        2>&1) || true
+
+      local mobile_passed
+      mobile_passed=$(echo "$mobile_result" | jq -r '.pass // false' 2>/dev/null)
+
+      if [[ "$mobile_passed" == "true" ]]; then
+        print_success "passed"
+      else
+        print_warning "issues found"
+        echo "$mobile_result" | jq -r '.errors[]?' 2>/dev/null | head -3 | sed 's/^/      /'
+      fi
+    fi
+
+    return 0
+  else
+    print_error "failed"
+    echo ""
+
+    # Show errors
+    echo "    Errors:"
+    echo "$result" | jq -r '.errors[]?' 2>/dev/null | sed 's/^/      /'
+
+    # Show console errors if any
+    local console_errors
+    console_errors=$(echo "$result" | jq -r '.consoleErrors[]?' 2>/dev/null)
+    if [[ -n "$console_errors" ]]; then
+      echo ""
+      echo "    Console errors:"
+      echo "$console_errors" | head -5 | sed 's/^/      /'
+    fi
+
+    # Show missing elements if any
+    local missing
+    missing=$(echo "$result" | jq -r '.elementsMissing[]?' 2>/dev/null)
+    if [[ -n "$missing" ]]; then
+      echo ""
+      echo "    Missing elements:"
+      echo "$missing" | sed 's/^/      /'
+    fi
+
+    # Save for failure context
+    echo "$result" > "$RALPH_DIR/last_browser_failure.json"
+
+    return 1
+  fi
+}
+
+# Fallback curl check when Playwright isn't available
+run_curl_check() {
+  local url="$1"
+
+  local http_response
+  http_response=$(curl -s -o /dev/null -w "%{http_code}" --max-time "$CURL_TIMEOUT_SECONDS" "$url" 2>/dev/null) || http_response="000"
+
+  if [[ "$http_response" == "000" ]]; then
+    print_error "Cannot reach $url - server not responding"
+    return 1
+  elif [[ "$http_response" -ge 500 ]]; then
+    print_error "Server error $http_response at $url"
+    return 1
+  elif [[ "$http_response" -ge 400 ]]; then
+    print_warning "HTTP $http_response (may be expected for auth pages)"
+    return 0
+  fi
+
+  # Check for error messages in response
+  local page_content
+  page_content=$(curl -s --max-time "$CURL_TIMEOUT_SECONDS" "$url" 2>/dev/null)
+
+  if echo "$page_content" | grep -qi "something went wrong\|error.*occurred\|500 internal\|503 service\|oops\!" 2>/dev/null; then
+    print_error "Page contains error message"
+    return 1
+  fi
+
+  print_success "HTTP $http_response"
+  return 0
+}

package/ralph/verify/lint.sh

@@ -0,0 +1,363 @@
+#!/usr/bin/env bash
+# shellcheck shell=bash
+# lint.sh - Lint and auto-fix verification module for ralph
+
+# Auto-fix lint issues before running checks
+run_auto_fix() {
+  echo "    Auto-fixing lint issues..."
+
+  # Python: ruff fix (auto-fix what we can)
+  if command -v ruff &>/dev/null; then
+    ruff check --fix . 2>/dev/null || true
+  fi
+
+  # JavaScript/TypeScript: eslint fix (root)
+  if [[ -f "package.json" ]] && command -v npx &>/dev/null; then
+    if grep -q '"eslint"' package.json 2>/dev/null || [[ -f ".eslintrc.js" ]] || [[ -f "eslint.config.js" ]]; then
+      npx eslint --fix . 2>/dev/null || true
+    fi
+  fi
+
+  # Check frontend directories (monorepo support)
+  local fe_dirs
+  fe_dirs=$(get_frontend_dirs)
+
+  while IFS= read -r fe_dir; do
+    [[ -z "$fe_dir" ]] && continue
+    [[ ! -f "$fe_dir/package.json" ]] && continue
+    # ESLint fix
+    if grep -q '"eslint"' "$fe_dir/package.json" 2>/dev/null; then
+      (cd "$fe_dir" && npx eslint --fix . 2>/dev/null) || true
+    fi
+
+    # Next.js lint fix
+    if grep -q '"next"' "$fe_dir/package.json" 2>/dev/null; then
+      (cd "$fe_dir" && npx next lint --fix 2>/dev/null) || true
+    fi
+
+    # Prettier fix (common in frontend)
+    if grep -q '"prettier"' "$fe_dir/package.json" 2>/dev/null; then
+      (cd "$fe_dir" && npx prettier --write . 2>/dev/null) || true
+    fi
+  done <<< "$fe_dirs"
+
+  # Prettier fix (root - for non-monorepo)
+  if [[ -f "package.json" ]] && grep -q '"prettier"' package.json 2>/dev/null; then
+    npx prettier --write . 2>/dev/null || true
+  fi
+}
+
+# Verify lint passes after auto-fix (catch unfixable errors)
+verify_lint() {
+  local failed=0
+
+  # Python: ruff lint check
+  if command -v ruff &>/dev/null && [[ -f "pyproject.toml" || -f "ruff.toml" ]]; then
+    echo -n "    Ruff lint check... "
+    if ruff check . --quiet 2>/dev/null; then
+      print_success "passed"
+    else
+      print_error "failed"
+      echo ""
+      echo "    Unfixable lint errors:"
+      ruff check . 2>/dev/null | head -"$MAX_LINT_ERROR_LINES" | sed 's/^/      /'
+      failed=1
+    fi
+  fi
+
+  # Check for monorepo backend directories
+  local api_dirs
+  api_dirs=$(get_backend_dirs)
+
+  while IFS= read -r api_dir; do
+    [[ -z "$api_dir" ]] && continue
+    if [[ -f "$api_dir/pyproject.toml" || -f "$api_dir/ruff.toml" ]]; then
+      echo -n "    Ruff lint check ($api_dir)... "
+      if (cd "$api_dir" && ruff check . --quiet 2>/dev/null); then
+        print_success "passed"
+      else
+        print_error "failed"
+        echo ""
+        echo "    Unfixable lint errors in $api_dir:"
+        (cd "$api_dir" && ruff check . 2>/dev/null) | head -"$MAX_LINT_ERROR_LINES" | sed 's/^/      /'
+        failed=1
+      fi
+    fi
+  done <<< "$api_dirs"
+
+  return $failed
+}
+
+# Check FastAPI endpoints have Pydantic response models (for Swagger docs)
+run_fastapi_response_check() {
+  # Use RALPH_LIB which points to the ralph/ directory
+  local check_script="${RALPH_LIB:-$(dirname "${BASH_SOURCE[0]}")/..}/checks/check-fastapi-responses.py"
+
+  # Skip if check script doesn't exist
+  [[ ! -f "$check_script" ]] && return 0
+
+  # Find FastAPI directories (check root + backend dirs)
+  local fastapi_dirs=()
+  local all_dirs=(".")
+  while IFS= read -r dir; do
+    [[ -n "$dir" ]] && all_dirs+=("$dir")
+  done < <(get_backend_dirs)
+
+  for dir in "${all_dirs[@]}"; do
+    [[ ! -d "$dir" ]] && continue
+    # Check for FastAPI imports
+    if grep -rq "from fastapi" "$dir"/*.py 2>/dev/null || \
+       grep -rq "from fastapi" "$dir"/**/*.py 2>/dev/null; then
+      fastapi_dirs+=("$dir")
+    fi
+  done
+
+  [[ ${#fastapi_dirs[@]} -eq 0 ]] && return 0
+
+  local failed=0
+  for dir in "${fastapi_dirs[@]}"; do
+    echo -n "    FastAPI response models ($dir)... "
+
+    local output
+    local log_file="$RALPH_DIR/last_fastapi_response_check.log"
+
+    if output=$(python3 "$check_script" "$dir" 2>&1); then
+      print_success "passed"
+      rm -f "$log_file"
+    else
+      print_error "failed"
+      echo ""
+      echo "$output" | head -"$MAX_ERROR_PREVIEW_LINES" | sed 's/^/      /'
+      # Save for failure context so Claude can fix
+      echo "$output" > "$log_file"
+      failed=1
+    fi
+  done
+
+  return $failed
+}
+
+# Run all checks defined in config.json
+run_configured_checks() {
+  local config="$RALPH_DIR/config.json"
+
+  # ALWAYS run auto-fix and lint verification, even without config.json
+  run_auto_fix
+
+  # Verify lint passes after auto-fix (catch unfixable errors)
+  if ! verify_lint; then
+    return 1
+  fi
+
+  # Auto-detect and run FastAPI response model check
+  run_fastapi_response_check
+
+  # Run pre-commit hooks if available (catches errors before commit attempt)
+  if command -v pre-commit &>/dev/null && [[ -f ".pre-commit-config.yaml" ]]; then
+    echo -n "    pre-commit hooks... "
+    local precommit_log="$RALPH_DIR/last_precommit_failure.log"
+
+    # Helper function: check if pre-commit output has REAL errors (not just file modifications or warnings)
+    has_real_errors() {
+      local log_file="$1"
+
+      # If all "Failed" hooks only have "files were modified" - not real errors
+      # Real errors have patterns like: "error:", "Error:", numbered errors "✖ N problems (N errors"
+      # But ESLint "0 errors, N warnings" is NOT a real error
+
+      # Check for actual error indicators (not warnings-only)
+      if grep -qE "^error:|: error:|Error:|SyntaxError|TypeError|NameError" "$log_file" 2>/dev/null; then
+        return 0  # Has real errors
+      fi
+
+      # Check ESLint output - fail only if errors > 0
+      if grep -qE "✖ [0-9]+ problems? \([1-9][0-9]* errors?" "$log_file" 2>/dev/null; then
+        return 0  # Has real ESLint errors
+      fi
+
+      # Check ruff output - actual errors have file:line:col: error pattern
+      if grep -qE "^[^:]+:[0-9]+:[0-9]+: [EF][0-9]+" "$log_file" 2>/dev/null; then
+        return 0  # Has real ruff errors
+      fi
+
+      # Check for hooks that failed for reasons OTHER than file modification
+      # Get all "Failed" hooks and check if any DON'T have "files were modified"
+      local failed_hooks
+      failed_hooks=$(grep -B 5 "^- hook id:" "$log_file" | grep -B 1 "Failed" | grep "hook id:" | sed 's/.*hook id: //' 2>/dev/null)
+
+      while IFS= read -r hook_id; do
+        [[ -z "$hook_id" ]] && continue
+        # Check if this hook's failure section contains "files were modified"
+        if ! grep -A 3 "hook id: $hook_id" "$log_file" | grep -q "files were modified"; then
+          # This hook failed for a real reason
+          return 0
+        fi
+      done <<< "$failed_hooks"
+
+      return 1  # No real errors found
+    }
+
+    # Run pre-commit up to 3 times to handle auto-fix chains
+    local max_attempts=3
+    local attempt=1
+    local passed=false
+
+    while [[ $attempt -le $max_attempts ]]; do
+      if pre-commit run --all-files > "$precommit_log" 2>&1; then
+        passed=true
+        break
+      fi
+
+      # Check if failure is due to file modifications (auto-fix)
+      if grep -q "files were modified by this hook" "$precommit_log"; then
+        # Check if there are also REAL errors (not just file mods)
+        if has_real_errors "$precommit_log"; then
+          # Real errors exist - fail
+          break
+        fi
+
+        # Only file modifications - stage and retry
+        if [[ $attempt -lt $max_attempts ]]; then
+          echo -n "auto-fixing (attempt $attempt)... "
+          git add -A 2>/dev/null || true
+          ((attempt++))
+          continue
+        else
+          # Max attempts reached, but only file mods - consider it passed
+          # Some hooks (like backup-database) always modify files
+          echo -n "auto-fix complete... "
+          git add -A 2>/dev/null || true
+          passed=true
+          break
+        fi
+      else
+        # Failed without "files were modified" - check for real errors
+        if has_real_errors "$precommit_log"; then
+          break  # Real errors
+        else
+          # No real errors detected (warnings only, etc.)
+          passed=true
+          break
+        fi
+      fi
+
+      ((attempt++))
+    done
+
+    if [[ "$passed" == "true" ]]; then
+      if [[ $attempt -gt 1 ]]; then
+        print_success "passed (after auto-fix)"
+      else
+        print_success "passed"
+      fi
+      rm -f "$precommit_log"
+    else
+      print_error "failed"
+      echo ""
+      echo "    Pre-commit hook errors:"
+      # Show actual errors, not just "Failed" status lines
+      grep -E "^error:|: error:|Error:|SyntaxError|✖ [0-9]+ problems|^[^:]+:[0-9]+:[0-9]+:" "$precommit_log" | head -"$MAX_ERROR_PREVIEW_LINES" | sed 's/^/      /'
+      # If no errors shown, show more context
+      if ! grep -qE "^error:|: error:|Error:|SyntaxError|✖ [0-9]+ problems" "$precommit_log"; then
+        echo "    Full output:"
+        tail -30 "$precommit_log" | sed 's/^/      /'
+      fi
+      return 1
+    fi
+  fi
+
+  # Config-based checks are optional
+  if [[ ! -f "$config" ]]; then
+    echo "    (no config.json for additional checks)"
+    return 0
+  fi
+
+  # Get list of check names (excluding 'test' which we run separately)
+  local check_names
+  check_names=$(jq -r '.checks | keys[] | select(. != "test")' "$config" 2>/dev/null)
+
+  if [[ -z "$check_names" ]]; then
+    echo "    (no additional checks configured)"
+    return 0
+  fi
+
+  local all_passed=0
+
+  while IFS= read -r check_name; do
+    [[ -z "$check_name" ]] && continue
+
+    local cmd
+    cmd=$(jq -r ".checks[\"$check_name\"] // empty" "$config")
+
+    if [[ -z "$cmd" || "$cmd" == "null" ]]; then
+      continue
+    fi
+
+    # Check if command exists
+    local first_word
+    first_word=$(echo "$cmd" | awk '{print $1}')
+
+    if [[ "$first_word" == "cd" ]]; then
+      local actual_cmd
+      actual_cmd=$(echo "$cmd" | sed 's/.*&& *//' | awk '{print $1}')
+      if [[ -n "$actual_cmd" ]] && ! command -v "$actual_cmd" &>/dev/null; then
+        echo "    Skipping $check_name ($actual_cmd not found)"
+        continue
+      fi
+    elif ! command -v "$first_word" &>/dev/null; then
+      echo "    Skipping $check_name ($first_word not found)"
+      continue
+    fi
+
+    if ! run_check "$check_name" "$cmd"; then
+      all_passed=1
+    fi
+  done <<< "$check_names"
+
+  return $all_passed
+}
+
+# Run a single check
+run_check() {
+  local name="$1"
+  local cmd="$2"
+  local log_file
+  log_file=$(create_temp_file ".log") || return 1
+
+  echo -n "    $name... "
+
+  if safe_exec "$cmd" "$log_file"; then
+    print_success "passed"
+    rm -f "$log_file"
+    return 0
+  else
+    print_error "failed"
+    echo ""
+    echo "    Output (last $MAX_LOG_LINES lines):"
+    tail -"$MAX_LOG_LINES" "$log_file" | sed 's/^/      /'
+    rm -f "$log_file"
+    return 1
+  fi
+}
+
+# Quick check command (subset of verification)
+ralph_check() {
+  if [[ ! -f "$RALPH_DIR/config.json" ]]; then
+    print_error "Ralph not initialized. Run 'ralph init' first."
+    exit 1
+  fi
+
+  echo ""
+  print_info "=== Running Checks ==="
+  echo ""
+
+  if run_configured_checks; then
+    echo ""
+    print_success "All checks passed!"
+    return 0
+  else
+    echo ""
+    print_error "Some checks failed"
+    return 1
+  fi
+}