thrivekit 2.0.18 → 2.0.20

package/README.md

@@ -4,7 +4,7 @@
 
 A toolkit for implementing [RALPH](https://ghuntley.com/ralph/) with [Claude Code](https://docs.anthropic.com/en/docs/claude-code) that helps you go from idea to shipped code.
 
-> **Optimized for:** Python, TypeScript, React, and Docker projects. Auto-detects ports from `docker-compose.yml`, Vite, Next.js, and FastAPI.
+> **Optimized for:** Python, TypeScript, React, Go/Hugo, and Docker projects. Auto-detects ports from `docker-compose.yml`, Vite, Next.js, Hugo, FastAPI, and more.
 
 > You focus on what matters: your ideas. Brainstorm with `/idea`, then let Ralph handle the rest - coding, testing, and committing in an iterative loop until everything passes.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "thrivekit",
-  "version": "2.0.18",
+  "version": "2.0.20",
   "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,66 +186,70 @@ 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 web_port=""
 
-  # Check docker-compose.yml for frontend/web service port mappings
+  # 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
-      # Look for web/frontend service port mapping
-      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"
-      fi
     fi
   done
 
-  # Check for Vite config (uses port 5173 by default)
-  if [[ -z "$base_url" ]]; then
+  # 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
-        base_url="http://localhost:5173"
+        # 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
+
+  # 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
 
-  # Check for Next.js (uses port 3000 by default)
-  if [[ -z "$base_url" ]]; then
+  # 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
-        base_url="http://localhost:3000"
+        # 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 scripts for dev server port
-  if [[ -z "$base_url" && -f "package.json" ]]; then
-    if grep -q '"dev".*:3000' package.json 2>/dev/null; then
-      base_url="http://localhost:3000"
-    elif grep -q '"dev".*:5173' package.json 2>/dev/null; then
-      base_url="http://localhost:5173"
-    elif grep -q '"dev".*:8080' package.json 2>/dev/null; then
-      base_url="http://localhost:8080"
-    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
 
-  # Check for monorepo frontend
-  for fe_pkg in "apps/web/package.json" "apps/frontend/package.json" "frontend/package.json"; do
-    if [[ -f "$fe_pkg" && -z "$base_url" ]]; then
-      if grep -q ':3000' "$fe_pkg" 2>/dev/null; then
-        base_url="http://localhost:3000"
-      elif grep -q ':5173' "$fe_pkg" 2>/dev/null; then
-        base_url="http://localhost:5173"
-      fi
-    fi
-  done
+  if [[ -n "$web_port" ]]; then
+    base_url="http://localhost:$web_port"
+  fi
 
   if [[ -n "$base_url" ]]; then
     if jq -e '.testUrlBase' "$tmpfile" >/dev/null 2>&1 && [[ "$(jq -r '.testUrlBase' "$tmpfile")" != "" ]]; then
@@ -292,47 +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_port=""
 
-  # Check docker-compose.yml for API service port mappings (most common)
+  # 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
-      # Look for api/backend service port mapping like "8000:8000" or "3001:3000"
-      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"
-      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"
-      fi
+      api_port=$(grep -i "^EXPOSE" "$backend_dir/Dockerfile" 2>/dev/null | head -1 | grep -oE '[0-9]+' | head -1)
     fi
-    # Python backends (FastAPI/Django) typically use port 8000
-    if [[ -z "$api_url" ]] && { [[ -f "$backend_dir/pyproject.toml" ]] || [[ -f "$backend_dir/requirements.txt" ]] || [[ -f "$backend_dir/main.py" ]]; }; then
-      api_url="http://localhost:8000"
-    # Node backends - check for port in package.json or default to 3001
-    elif [[ -z "$api_url" && -f "$backend_dir/package.json" ]]; then
-      if grep -q ':3001' "$backend_dir/package.json" 2>/dev/null; then
-        api_url="http://localhost:3001"
-      elif grep -q ':4000' "$backend_dir/package.json" 2>/dev/null; then
-        api_url="http://localhost:4000"
-      else
-        api_url="http://localhost:3001"
+  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
+      # 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/setup.sh

@@ -257,6 +257,15 @@ setup_claude_md() {
   fi
   [[ -f "manage.py" ]] && framework="${framework:+$framework + }Django"
 
+  # Detect Hugo (Go static site generator)
+  for hugo_config in "hugo.toml" "hugo.yaml" "hugo.json" "config.toml"; do
+    if [[ -f "$hugo_config" ]] && [[ -d "content" || -d "layouts" || -d "themes" ]]; then
+      framework="${framework:+$framework + }Hugo"
+      [[ -z "$runtime" ]] && runtime="Go"
+      break
+    fi
+  done
+
   # Detect TypeScript
   [[ -f "tsconfig.json" || -f "${fe_dir}/tsconfig.json" ]] && language="TypeScript"