thrivekit 2.0.19 → 2.0.21

package/.claude/commands/idea.md

@@ -163,7 +163,35 @@ Break the idea into small, executable PRDs following the JSON structure below.
 
 **STOP and wait for user response. Do not proceed until they approve.**
 
-### Step 7: Final Instructions
+### Step 7: Final Review
+
+Before finishing, do a quick sanity check on the PRD:
+
+1. **Read the PRD back:**
+   ```bash
+   cat .ralph/prd.json | jq '.'
+   ```
+
+2. **Review for common issues:**
+   - Are story IDs sequential and unique?
+   - Does each story have testable acceptance criteria?
+   - Are file paths specific (not vague like "src/")?
+   - Are dependencies correctly ordered?
+   - Are testSteps actually executable shell commands?
+   - Is any story too large (>4 acceptance criteria)?
+
+3. **If issues found**, say:
+   "I found some issues with the PRD:
+   - [issue 1]
+   - [issue 2]
+
+   Fixing now..."
+
+   Then fix the issues and rewrite the PRD.
+
+4. **If no issues**, proceed to final instructions.
+
+### Step 8: Final Instructions
 
 Once the user approves the PRD, say:
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "thrivekit",
-  "version": "2.0.19",
+  "version": "2.0.21",
   "description": "Tools to thrive with agentic coding - RALPH autonomous loop, Claude Code hooks, PRD-driven development",
   "author": "Allie Jones <allie@allthrive.ai>",
   "license": "MIT",

package/ralph/init.sh

@@ -186,67 +186,69 @@ auto_configure_project() {
     fi
   fi
 
-  # 2. Detect testUrlBase from common patterns
+  # 2. Detect testUrlBase by parsing actual config files for port values
   local base_url=""
-  local detected_framework=""
+  local web_port=""
 
-  # Check docker-compose.yml for frontend/web service port mappings (highest priority)
+  # Priority 1: docker-compose.yml - parse actual port mappings
   for compose_file in "docker-compose.yml" "docker-compose.yaml" "compose.yml" "compose.yaml"; do
-    if [[ -f "$compose_file" && -z "$base_url" ]]; then
-      local web_port
+    if [[ -f "$compose_file" && -z "$web_port" ]]; then
+      # Extract port from web/frontend service: "5173:5173" -> 5173
       web_port=$(grep -A 20 -E '^\s*(web|frontend|client|ui):' "$compose_file" 2>/dev/null | \
                  grep -E '^\s*-\s*"?[0-9]+:[0-9]+"?' | head -1 | \
                  grep -oE '[0-9]+:' | head -1 | tr -d ':')
-      if [[ -n "$web_port" ]]; then
-        base_url="http://localhost:$web_port"
-        detected_framework="docker"
-      fi
     fi
   done
 
-  # Detect framework and use default port from constants
-  if [[ -z "$base_url" ]]; then
-    # Vite
+  # Priority 2: Vite config - parse server.port
+  if [[ -z "$web_port" ]]; then
     for vite_config in "vite.config.ts" "vite.config.js" "apps/web/vite.config.ts" "apps/web/vite.config.js" \
                        "apps/frontend/vite.config.ts" "frontend/vite.config.ts"; do
       if [[ -f "$vite_config" ]]; then
-        detected_framework="vite"
-        base_url="http://localhost:${DEFAULT_PORTS[vite]}"
+        # Look for port: 3000 or port: '3000'
+        web_port=$(grep -E 'port\s*[=:]\s*[0-9]+' "$vite_config" 2>/dev/null | grep -oE '[0-9]{4}' | head -1)
+        [[ -z "$web_port" ]] && web_port="5173"  # Vite's documented default
         break
       fi
     done
   fi
 
-  if [[ -z "$base_url" ]]; then
-    # Next.js
-    for next_config in "next.config.js" "next.config.ts" "next.config.mjs" \
-                       "apps/web/next.config.js" "apps/web/next.config.mjs"; do
-      if [[ -f "$next_config" ]]; then
-        detected_framework="nextjs"
-        base_url="http://localhost:${DEFAULT_PORTS[nextjs]}"
+  # Priority 3: Hugo config - parse server.port or use documented default
+  if [[ -z "$web_port" ]]; then
+    for hugo_config in "hugo.toml" "hugo.yaml" "hugo.json" "config.toml"; do
+      if [[ -f "$hugo_config" ]] && [[ -d "content" || -d "layouts" || -d "themes" ]]; then
+        web_port=$(grep -E 'port\s*=' "$hugo_config" 2>/dev/null | grep -oE '[0-9]+' | head -1)
+        [[ -z "$web_port" ]] && web_port="1313"  # Hugo's documented default
         break
       fi
     done
   fi
 
-  if [[ -z "$base_url" ]]; then
-    # Hugo
-    for hugo_config in "hugo.toml" "hugo.yaml" "hugo.json" "config.toml"; do
-      if [[ -f "$hugo_config" ]] && [[ -d "content" || -d "layouts" || -d "themes" ]]; then
-        detected_framework="hugo"
-        base_url="http://localhost:${DEFAULT_PORTS[hugo]}"
+  # Priority 4: Next.js - check package.json dev script for -p flag
+  if [[ -z "$web_port" ]]; then
+    for next_config in "next.config.js" "next.config.ts" "next.config.mjs" \
+                       "apps/web/next.config.js" "apps/web/next.config.mjs"; do
+      if [[ -f "$next_config" ]]; then
+        # Check if package.json has custom port: "dev": "next dev -p 4000"
+        local pkg_dir
+        pkg_dir=$(dirname "$next_config")
+        if [[ -f "$pkg_dir/package.json" ]]; then
+          web_port=$(grep -E '"dev".*-p\s*[0-9]+' "$pkg_dir/package.json" 2>/dev/null | grep -oE '\-p\s*[0-9]+' | grep -oE '[0-9]+')
+        fi
+        [[ -z "$web_port" ]] && web_port="3000"  # Next.js documented default
         break
       fi
     done
   fi
 
-  # Fallback: Check package.json for port hints
-  if [[ -z "$base_url" && -f "package.json" ]]; then
-    local pkg_port
-    pkg_port=$(grep -oE ':[0-9]{4}' package.json 2>/dev/null | head -1 | tr -d ':')
-    if [[ -n "$pkg_port" ]]; then
-      base_url="http://localhost:$pkg_port"
-    fi
+  # Priority 5: Generic package.json port detection
+  if [[ -z "$web_port" && -f "package.json" ]]; then
+    # Look for explicit port in scripts: --port 3000, -p 3000, :3000
+    web_port=$(grep -E '"(dev|start|serve)"' package.json 2>/dev/null | grep -oE '(--port|-p|:)[[:space:]]*[0-9]{4}' | grep -oE '[0-9]{4}' | head -1)
+  fi
+
+  if [[ -n "$web_port" ]]; then
+    base_url="http://localhost:$web_port"
   fi
 
   if [[ -n "$base_url" ]]; then
@@ -294,55 +296,52 @@ auto_configure_project() {
     fi
   fi
 
-  # 4. Detect API baseUrl based on backend type
+  # 4. Detect API baseUrl by parsing actual config files for port values
   local api_url=""
-  local api_framework=""
+  local api_port=""
 
-  # Check docker-compose.yml for API service port mappings (highest priority)
+  # Priority 1: docker-compose.yml - parse actual port mappings
   for compose_file in "docker-compose.yml" "docker-compose.yaml" "compose.yml" "compose.yaml"; do
-    if [[ -f "$compose_file" && -z "$api_url" ]]; then
-      local api_port
+    if [[ -f "$compose_file" && -z "$api_port" ]]; then
+      # Extract port from api/backend service: "8000:8000" -> 8000
       api_port=$(grep -A 20 -E '^\s*(api|backend|server|app):' "$compose_file" 2>/dev/null | \
                  grep -E '^\s*-\s*"?[0-9]+:[0-9]+"?' | head -1 | \
                  grep -oE '[0-9]+:' | head -1 | tr -d ':')
-      if [[ -n "$api_port" ]]; then
-        api_url="http://localhost:$api_port"
-        api_framework="docker"
-      fi
     fi
   done
 
-  if [[ -n "$backend_dir" && -z "$api_url" ]]; then
-    # Check Dockerfile for EXPOSE directive
+  # Priority 2: Dockerfile EXPOSE directive
+  if [[ -n "$backend_dir" && -z "$api_port" ]]; then
     if [[ -f "$backend_dir/Dockerfile" ]]; then
-      local docker_port
-      docker_port=$(grep -i "^EXPOSE" "$backend_dir/Dockerfile" 2>/dev/null | head -1 | grep -oE '[0-9]+' | head -1)
-      if [[ -n "$docker_port" ]]; then
-        api_url="http://localhost:$docker_port"
-        api_framework="docker"
-      fi
+      api_port=$(grep -i "^EXPOSE" "$backend_dir/Dockerfile" 2>/dev/null | head -1 | grep -oE '[0-9]+' | head -1)
     fi
-    # Python backends - detect framework and use default port
-    if [[ -z "$api_url" ]] && { [[ -f "$backend_dir/pyproject.toml" ]] || [[ -f "$backend_dir/requirements.txt" ]] || [[ -f "$backend_dir/main.py" ]]; }; then
-      if grep -q "fastapi\|FastAPI" "$backend_dir"/*.py "$backend_dir/pyproject.toml" 2>/dev/null; then
-        api_framework="fastapi"
-      elif grep -q "django\|Django" "$backend_dir"/*.py "$backend_dir/pyproject.toml" 2>/dev/null; then
-        api_framework="django"
-      elif grep -q "flask\|Flask" "$backend_dir"/*.py "$backend_dir/pyproject.toml" 2>/dev/null; then
-        api_framework="flask"
-      else
-        api_framework="fastapi"  # Default for Python
+  fi
+
+  # Priority 3: Python - check for uvicorn/gunicorn port in scripts or pyproject.toml
+  if [[ -n "$backend_dir" && -z "$api_port" ]]; then
+    if [[ -f "$backend_dir/pyproject.toml" ]] || [[ -f "$backend_dir/requirements.txt" ]]; then
+      # Check pyproject.toml for port config
+      if [[ -f "$backend_dir/pyproject.toml" ]]; then
+        api_port=$(grep -E 'port\s*=' "$backend_dir/pyproject.toml" 2>/dev/null | grep -oE '[0-9]+' | head -1)
       fi
-      api_url="http://localhost:${DEFAULT_PORTS[$api_framework]}"
-    # Node backends - check for port in package.json
-    elif [[ -z "$api_url" && -f "$backend_dir/package.json" ]]; then
-      local node_port
-      node_port=$(grep -oE ':[0-9]{4}' "$backend_dir/package.json" 2>/dev/null | head -1 | tr -d ':')
-      api_url="http://localhost:${node_port:-${DEFAULT_PORTS[express]}}"
-      api_framework="express"
+      # Check for uvicorn command with --port
+      if [[ -z "$api_port" && -f "$backend_dir/Makefile" ]]; then
+        api_port=$(grep -E 'uvicorn.*--port' "$backend_dir/Makefile" 2>/dev/null | grep -oE '\-\-port[[:space:]]*[0-9]+' | grep -oE '[0-9]+' | head -1)
+      fi
+      # Uvicorn/FastAPI default
+      [[ -z "$api_port" ]] && api_port="8000"
     fi
   fi
 
+  # Priority 4: Node backend - check package.json for port
+  if [[ -n "$backend_dir" && -z "$api_port" && -f "$backend_dir/package.json" ]]; then
+    api_port=$(grep -E '"(dev|start|serve)"' "$backend_dir/package.json" 2>/dev/null | grep -oE '(--port|-p|:)[[:space:]]*[0-9]{4}' | grep -oE '[0-9]{4}' | head -1)
+  fi
+
+  if [[ -n "$api_port" ]]; then
+    api_url="http://localhost:$api_port"
+  fi
+
   if [[ -n "$api_url" ]]; then
     if jq -e '.api.baseUrl' "$tmpfile" >/dev/null 2>&1 && [[ "$(jq -r '.api.baseUrl' "$tmpfile")" != "" ]]; then
       : # Already set

package/ralph/utils.sh

@@ -24,20 +24,6 @@ readonly CURL_TIMEOUT_SECONDS=10
 readonly FRONTEND_DIRS=("apps/web" "frontend" "client" "web")
 readonly BACKEND_DIRS=("apps/api" "api" "backend" "server")
 
-# Default ports by framework (used only during detection, then stored in config)
-declare -A DEFAULT_PORTS=(
-  ["vite"]=5173
-  ["nextjs"]=3000
-  ["hugo"]=1313
-  ["react"]=3000
-  ["vue"]=5173
-  ["express"]=3001
-  ["fastapi"]=8000
-  ["django"]=8000
-  ["flask"]=5000
-  ["rails"]=3000
-)
-
 # Track temp files for safe cleanup
 RALPH_TEMP_FILES=()