50f6ef7a96
Fixes three security issues identified in Phase 1.1 code review:
1. JSON injection in parse_json_response() (response_analyzer.sh:113-132)
- Replace heredoc with jq construction using --arg for strings
- Use --argjson for numeric/boolean fields
- Ensures proper escaping of quotes, newlines, backslashes
2. Input validation for --allowed-tools flag (ralph_loop.sh:903-905)
- Add VALID_TOOL_PATTERNS whitelist
- Add validate_allowed_tools() function
- Validate against whitelist in argument parsing
- Allow Bash(...) patterns with any content
3. Shell injection in build_claude_command() (ralph_loop.sh:439-444)
- Convert from string concatenation to command array
- Use global CLAUDE_CMD_ARGS array
- Execute with "${CLAUDE_CMD_ARGS[@]}" instead of bash -c
- No manual escaping needed - array handles metacharacters
All 98 tests passing.
Closes #48, #50
1002 lines
35 KiB
Bash
Executable file
1002 lines
35 KiB
Bash
Executable file
#!/bin/bash
|
|
|
|
# Claude Code Ralph Loop with Rate Limiting and Documentation
|
|
# Adaptation of the Ralph technique for Claude Code with usage management
|
|
|
|
set -e # Exit on any error
|
|
|
|
# Source library components
|
|
SCRIPT_DIR="$(dirname "${BASH_SOURCE[0]}")"
|
|
source "$SCRIPT_DIR/lib/date_utils.sh"
|
|
source "$SCRIPT_DIR/lib/response_analyzer.sh"
|
|
source "$SCRIPT_DIR/lib/circuit_breaker.sh"
|
|
|
|
# Configuration
|
|
PROMPT_FILE="PROMPT.md"
|
|
LOG_DIR="logs"
|
|
DOCS_DIR="docs/generated"
|
|
STATUS_FILE="status.json"
|
|
PROGRESS_FILE="progress.json"
|
|
CLAUDE_CODE_CMD="claude"
|
|
MAX_CALLS_PER_HOUR=100 # Adjust based on your plan
|
|
VERBOSE_PROGRESS=false # Default: no verbose progress updates
|
|
CLAUDE_TIMEOUT_MINUTES=15 # Default: 15 minutes timeout for Claude Code execution
|
|
SLEEP_DURATION=3600 # 1 hour in seconds
|
|
CALL_COUNT_FILE=".call_count"
|
|
TIMESTAMP_FILE=".last_reset"
|
|
USE_TMUX=false
|
|
|
|
# Modern Claude CLI configuration (Phase 1.1)
|
|
CLAUDE_OUTPUT_FORMAT="json" # Options: json, text
|
|
CLAUDE_ALLOWED_TOOLS="Write,Bash(git *),Read" # Comma-separated list of allowed tools
|
|
CLAUDE_USE_CONTINUE=true # Enable session continuity
|
|
CLAUDE_SESSION_FILE=".claude_session_id" # Session ID persistence file
|
|
CLAUDE_MIN_VERSION="2.0.76" # Minimum required Claude CLI version
|
|
|
|
# Valid tool patterns for --allowed-tools validation
|
|
# Tools can be exact matches or pattern matches with wildcards in parentheses
|
|
VALID_TOOL_PATTERNS=(
|
|
"Write"
|
|
"Read"
|
|
"Edit"
|
|
"MultiEdit"
|
|
"Glob"
|
|
"Grep"
|
|
"Task"
|
|
"TodoWrite"
|
|
"WebFetch"
|
|
"WebSearch"
|
|
"Bash"
|
|
"Bash(git *)"
|
|
"Bash(npm *)"
|
|
"Bash(bats *)"
|
|
"Bash(python *)"
|
|
"Bash(node *)"
|
|
"NotebookEdit"
|
|
)
|
|
|
|
# Exit detection configuration
|
|
EXIT_SIGNALS_FILE=".exit_signals"
|
|
MAX_CONSECUTIVE_TEST_LOOPS=3
|
|
MAX_CONSECUTIVE_DONE_SIGNALS=2
|
|
TEST_PERCENTAGE_THRESHOLD=30 # If more than 30% of recent loops are test-only, flag it
|
|
|
|
# Colors for terminal output
|
|
RED='\033[0;31m'
|
|
GREEN='\033[0;32m'
|
|
YELLOW='\033[1;33m'
|
|
BLUE='\033[0;34m'
|
|
PURPLE='\033[0;35m'
|
|
NC='\033[0m' # No Color
|
|
|
|
# Initialize directories
|
|
mkdir -p "$LOG_DIR" "$DOCS_DIR"
|
|
|
|
# Check if tmux is available
|
|
check_tmux_available() {
|
|
if ! command -v tmux &> /dev/null; then
|
|
log_status "ERROR" "tmux is not installed. Please install tmux or run without --monitor flag."
|
|
echo "Install tmux:"
|
|
echo " Ubuntu/Debian: sudo apt-get install tmux"
|
|
echo " macOS: brew install tmux"
|
|
echo " CentOS/RHEL: sudo yum install tmux"
|
|
exit 1
|
|
fi
|
|
}
|
|
|
|
# Setup tmux session with monitor
|
|
setup_tmux_session() {
|
|
local session_name="ralph-$(date +%s)"
|
|
local ralph_home="${RALPH_HOME:-$HOME/.ralph}"
|
|
|
|
log_status "INFO" "Setting up tmux session: $session_name"
|
|
|
|
# Create new tmux session detached
|
|
tmux new-session -d -s "$session_name" -c "$(pwd)"
|
|
|
|
# Split window vertically to create monitor pane on the right
|
|
tmux split-window -h -t "$session_name" -c "$(pwd)"
|
|
|
|
# Start monitor in the right pane
|
|
if command -v ralph-monitor &> /dev/null; then
|
|
tmux send-keys -t "$session_name:0.1" "ralph-monitor" Enter
|
|
else
|
|
tmux send-keys -t "$session_name:0.1" "'$ralph_home/ralph_monitor.sh'" Enter
|
|
fi
|
|
|
|
# Start ralph loop in the left pane (exclude tmux flag to avoid recursion)
|
|
local ralph_cmd
|
|
if command -v ralph &> /dev/null; then
|
|
ralph_cmd="ralph"
|
|
else
|
|
ralph_cmd="'$ralph_home/ralph_loop.sh'"
|
|
fi
|
|
|
|
if [[ "$MAX_CALLS_PER_HOUR" != "100" ]]; then
|
|
ralph_cmd="$ralph_cmd --calls $MAX_CALLS_PER_HOUR"
|
|
fi
|
|
if [[ "$PROMPT_FILE" != "PROMPT.md" ]]; then
|
|
ralph_cmd="$ralph_cmd --prompt '$PROMPT_FILE'"
|
|
fi
|
|
|
|
tmux send-keys -t "$session_name:0.0" "$ralph_cmd" Enter
|
|
|
|
# Focus on left pane (main ralph loop)
|
|
tmux select-pane -t "$session_name:0.0"
|
|
|
|
# Set window title
|
|
tmux rename-window -t "$session_name:0" "Ralph: Loop | Monitor"
|
|
|
|
log_status "SUCCESS" "Tmux session created. Attaching to session..."
|
|
log_status "INFO" "Use Ctrl+B then D to detach from session"
|
|
log_status "INFO" "Use 'tmux attach -t $session_name' to reattach"
|
|
|
|
# Attach to session (this will block until session ends)
|
|
tmux attach-session -t "$session_name"
|
|
|
|
exit 0
|
|
}
|
|
|
|
# Initialize call tracking
|
|
init_call_tracking() {
|
|
log_status "INFO" "DEBUG: Entered init_call_tracking..."
|
|
local current_hour=$(date +%Y%m%d%H)
|
|
local last_reset_hour=""
|
|
|
|
if [[ -f "$TIMESTAMP_FILE" ]]; then
|
|
last_reset_hour=$(cat "$TIMESTAMP_FILE")
|
|
fi
|
|
|
|
# Reset counter if it's a new hour
|
|
if [[ "$current_hour" != "$last_reset_hour" ]]; then
|
|
echo "0" > "$CALL_COUNT_FILE"
|
|
echo "$current_hour" > "$TIMESTAMP_FILE"
|
|
log_status "INFO" "Call counter reset for new hour: $current_hour"
|
|
fi
|
|
|
|
# Initialize exit signals tracking if it doesn't exist
|
|
if [[ ! -f "$EXIT_SIGNALS_FILE" ]]; then
|
|
echo '{"test_only_loops": [], "done_signals": [], "completion_indicators": []}' > "$EXIT_SIGNALS_FILE"
|
|
fi
|
|
|
|
# Initialize circuit breaker
|
|
init_circuit_breaker
|
|
|
|
log_status "INFO" "DEBUG: Completed init_call_tracking successfully"
|
|
}
|
|
|
|
# Log function with timestamps and colors
|
|
log_status() {
|
|
local level=$1
|
|
local message=$2
|
|
local timestamp=$(date '+%Y-%m-%d %H:%M:%S')
|
|
local color=""
|
|
|
|
case $level in
|
|
"INFO") color=$BLUE ;;
|
|
"WARN") color=$YELLOW ;;
|
|
"ERROR") color=$RED ;;
|
|
"SUCCESS") color=$GREEN ;;
|
|
"LOOP") color=$PURPLE ;;
|
|
esac
|
|
|
|
echo -e "${color}[$timestamp] [$level] $message${NC}"
|
|
echo "[$timestamp] [$level] $message" >> "$LOG_DIR/ralph.log"
|
|
}
|
|
|
|
# Update status JSON for external monitoring
|
|
update_status() {
|
|
local loop_count=$1
|
|
local calls_made=$2
|
|
local last_action=$3
|
|
local status=$4
|
|
local exit_reason=${5:-""}
|
|
|
|
cat > "$STATUS_FILE" << STATUSEOF
|
|
{
|
|
"timestamp": "$(get_iso_timestamp)",
|
|
"loop_count": $loop_count,
|
|
"calls_made_this_hour": $calls_made,
|
|
"max_calls_per_hour": $MAX_CALLS_PER_HOUR,
|
|
"last_action": "$last_action",
|
|
"status": "$status",
|
|
"exit_reason": "$exit_reason",
|
|
"next_reset": "$(get_next_hour_time)"
|
|
}
|
|
STATUSEOF
|
|
}
|
|
|
|
# Check if we can make another call
|
|
can_make_call() {
|
|
local calls_made=0
|
|
if [[ -f "$CALL_COUNT_FILE" ]]; then
|
|
calls_made=$(cat "$CALL_COUNT_FILE")
|
|
fi
|
|
|
|
if [[ $calls_made -ge $MAX_CALLS_PER_HOUR ]]; then
|
|
return 1 # Cannot make call
|
|
else
|
|
return 0 # Can make call
|
|
fi
|
|
}
|
|
|
|
# Increment call counter
|
|
increment_call_counter() {
|
|
local calls_made=0
|
|
if [[ -f "$CALL_COUNT_FILE" ]]; then
|
|
calls_made=$(cat "$CALL_COUNT_FILE")
|
|
fi
|
|
|
|
((calls_made++))
|
|
echo "$calls_made" > "$CALL_COUNT_FILE"
|
|
echo "$calls_made"
|
|
}
|
|
|
|
# Wait for rate limit reset with countdown
|
|
wait_for_reset() {
|
|
local calls_made=$(cat "$CALL_COUNT_FILE" 2>/dev/null || echo "0")
|
|
log_status "WARN" "Rate limit reached ($calls_made/$MAX_CALLS_PER_HOUR). Waiting for reset..."
|
|
|
|
# Calculate time until next hour
|
|
local current_minute=$(date +%M)
|
|
local current_second=$(date +%S)
|
|
local wait_time=$(((60 - current_minute - 1) * 60 + (60 - current_second)))
|
|
|
|
log_status "INFO" "Sleeping for $wait_time seconds until next hour..."
|
|
|
|
# Countdown display
|
|
while [[ $wait_time -gt 0 ]]; do
|
|
local hours=$((wait_time / 3600))
|
|
local minutes=$(((wait_time % 3600) / 60))
|
|
local seconds=$((wait_time % 60))
|
|
|
|
printf "\r${YELLOW}Time until reset: %02d:%02d:%02d${NC}" $hours $minutes $seconds
|
|
sleep 1
|
|
((wait_time--))
|
|
done
|
|
printf "\n"
|
|
|
|
# Reset counter
|
|
echo "0" > "$CALL_COUNT_FILE"
|
|
echo "$(date +%Y%m%d%H)" > "$TIMESTAMP_FILE"
|
|
log_status "SUCCESS" "Rate limit reset! Ready for new calls."
|
|
}
|
|
|
|
# Check if we should gracefully exit
|
|
should_exit_gracefully() {
|
|
log_status "INFO" "DEBUG: Checking exit conditions..." >&2
|
|
|
|
if [[ ! -f "$EXIT_SIGNALS_FILE" ]]; then
|
|
log_status "INFO" "DEBUG: No exit signals file found, continuing..." >&2
|
|
return 1 # Don't exit, file doesn't exist
|
|
fi
|
|
|
|
local signals=$(cat "$EXIT_SIGNALS_FILE")
|
|
log_status "INFO" "DEBUG: Exit signals content: $signals" >&2
|
|
|
|
# Count recent signals (last 5 loops) - with error handling
|
|
local recent_test_loops
|
|
local recent_done_signals
|
|
local recent_completion_indicators
|
|
|
|
recent_test_loops=$(echo "$signals" | jq '.test_only_loops | length' 2>/dev/null || echo "0")
|
|
recent_done_signals=$(echo "$signals" | jq '.done_signals | length' 2>/dev/null || echo "0")
|
|
recent_completion_indicators=$(echo "$signals" | jq '.completion_indicators | length' 2>/dev/null || echo "0")
|
|
|
|
log_status "INFO" "DEBUG: Exit counts - test_loops:$recent_test_loops, done_signals:$recent_done_signals, completion:$recent_completion_indicators" >&2
|
|
|
|
# Check for exit conditions
|
|
|
|
# 1. Too many consecutive test-only loops
|
|
if [[ $recent_test_loops -ge $MAX_CONSECUTIVE_TEST_LOOPS ]]; then
|
|
log_status "WARN" "Exit condition: Too many test-focused loops ($recent_test_loops >= $MAX_CONSECUTIVE_TEST_LOOPS)"
|
|
echo "test_saturation"
|
|
return 0
|
|
fi
|
|
|
|
# 2. Multiple "done" signals
|
|
if [[ $recent_done_signals -ge $MAX_CONSECUTIVE_DONE_SIGNALS ]]; then
|
|
log_status "WARN" "Exit condition: Multiple completion signals ($recent_done_signals >= $MAX_CONSECUTIVE_DONE_SIGNALS)"
|
|
echo "completion_signals"
|
|
return 0
|
|
fi
|
|
|
|
# 3. Strong completion indicators
|
|
if [[ $recent_completion_indicators -ge 2 ]]; then
|
|
log_status "WARN" "Exit condition: Strong completion indicators ($recent_completion_indicators)"
|
|
echo "project_complete"
|
|
return 0
|
|
fi
|
|
|
|
# 4. Check fix_plan.md for completion
|
|
if [[ -f "@fix_plan.md" ]]; then
|
|
local total_items=$(grep -c "^- \[" "@fix_plan.md" 2>/dev/null)
|
|
local completed_items=$(grep -c "^- \[x\]" "@fix_plan.md" 2>/dev/null)
|
|
|
|
# Handle case where grep returns no matches (exit code 1)
|
|
[[ -z "$total_items" ]] && total_items=0
|
|
[[ -z "$completed_items" ]] && completed_items=0
|
|
|
|
log_status "INFO" "DEBUG: @fix_plan.md check - total_items:$total_items, completed_items:$completed_items" >&2
|
|
|
|
if [[ $total_items -gt 0 ]] && [[ $completed_items -eq $total_items ]]; then
|
|
log_status "WARN" "Exit condition: All fix_plan.md items completed ($completed_items/$total_items)" >&2
|
|
echo "plan_complete"
|
|
return 0
|
|
fi
|
|
else
|
|
log_status "INFO" "DEBUG: @fix_plan.md file not found" >&2
|
|
fi
|
|
|
|
log_status "INFO" "DEBUG: No exit conditions met, continuing loop" >&2
|
|
echo "" # Return empty string instead of using return code
|
|
}
|
|
|
|
# =============================================================================
|
|
# MODERN CLI HELPER FUNCTIONS (Phase 1.1)
|
|
# =============================================================================
|
|
|
|
# Check Claude CLI version for compatibility with modern flags
|
|
check_claude_version() {
|
|
local version=$($CLAUDE_CODE_CMD --version 2>/dev/null | grep -oE '[0-9]+\.[0-9]+\.[0-9]+' | head -1)
|
|
|
|
if [[ -z "$version" ]]; then
|
|
log_status "WARN" "Cannot detect Claude CLI version, assuming compatible"
|
|
return 0
|
|
fi
|
|
|
|
# Compare versions (simplified semver comparison)
|
|
local required="$CLAUDE_MIN_VERSION"
|
|
|
|
# Convert to comparable integers (major * 10000 + minor * 100 + patch)
|
|
local ver_parts=(${version//./ })
|
|
local req_parts=(${required//./ })
|
|
|
|
local ver_num=$((${ver_parts[0]:-0} * 10000 + ${ver_parts[1]:-0} * 100 + ${ver_parts[2]:-0}))
|
|
local req_num=$((${req_parts[0]:-0} * 10000 + ${req_parts[1]:-0} * 100 + ${req_parts[2]:-0}))
|
|
|
|
if [[ $ver_num -lt $req_num ]]; then
|
|
log_status "WARN" "Claude CLI version $version < $required. Some modern features may not work."
|
|
log_status "WARN" "Consider upgrading: npm update -g @anthropic-ai/claude-code"
|
|
return 1
|
|
fi
|
|
|
|
log_status "INFO" "Claude CLI version $version (>= $required) - modern features enabled"
|
|
return 0
|
|
}
|
|
|
|
# Validate allowed tools against whitelist
|
|
# Returns 0 if valid, 1 if invalid with error message
|
|
validate_allowed_tools() {
|
|
local tools_input=$1
|
|
|
|
if [[ -z "$tools_input" ]]; then
|
|
return 0 # Empty is valid (uses defaults)
|
|
fi
|
|
|
|
# Split by comma
|
|
local IFS=','
|
|
read -ra tools <<< "$tools_input"
|
|
|
|
for tool in "${tools[@]}"; do
|
|
# Trim whitespace
|
|
tool=$(echo "$tool" | sed 's/^[[:space:]]*//;s/[[:space:]]*$//')
|
|
|
|
if [[ -z "$tool" ]]; then
|
|
continue
|
|
fi
|
|
|
|
local valid=false
|
|
|
|
# Check against valid patterns
|
|
for pattern in "${VALID_TOOL_PATTERNS[@]}"; do
|
|
if [[ "$tool" == "$pattern" ]]; then
|
|
valid=true
|
|
break
|
|
fi
|
|
|
|
# Check for Bash(*) pattern - any Bash with parentheses is allowed
|
|
if [[ "$tool" =~ ^Bash\(.+\)$ ]]; then
|
|
valid=true
|
|
break
|
|
fi
|
|
done
|
|
|
|
if [[ "$valid" == "false" ]]; then
|
|
echo "Error: Invalid tool in --allowed-tools: '$tool'"
|
|
echo "Valid tools: ${VALID_TOOL_PATTERNS[*]}"
|
|
echo "Note: Bash(...) patterns with any content are allowed (e.g., 'Bash(git *)')"
|
|
return 1
|
|
fi
|
|
done
|
|
|
|
return 0
|
|
}
|
|
|
|
# Build loop context for Claude Code session
|
|
# Provides loop-specific context via --append-system-prompt
|
|
build_loop_context() {
|
|
local loop_count=$1
|
|
local context=""
|
|
|
|
# Add loop number
|
|
context="Loop #${loop_count}. "
|
|
|
|
# Extract incomplete tasks from @fix_plan.md
|
|
if [[ -f "@fix_plan.md" ]]; then
|
|
local incomplete_tasks=$(grep -c "^- \[ \]" "@fix_plan.md" 2>/dev/null || echo "0")
|
|
context+="Remaining tasks: ${incomplete_tasks}. "
|
|
fi
|
|
|
|
# Add circuit breaker state
|
|
if [[ -f ".circuit_breaker_state" ]]; then
|
|
local cb_state=$(jq -r '.state // "UNKNOWN"' .circuit_breaker_state 2>/dev/null)
|
|
if [[ "$cb_state" != "CLOSED" && "$cb_state" != "null" && -n "$cb_state" ]]; then
|
|
context+="Circuit breaker: ${cb_state}. "
|
|
fi
|
|
fi
|
|
|
|
# Add previous loop summary (truncated)
|
|
if [[ -f ".response_analysis" ]]; then
|
|
local prev_summary=$(jq -r '.analysis.work_summary // ""' .response_analysis 2>/dev/null | head -c 200)
|
|
if [[ -n "$prev_summary" && "$prev_summary" != "null" ]]; then
|
|
context+="Previous: ${prev_summary}"
|
|
fi
|
|
fi
|
|
|
|
# Limit total length to ~500 chars
|
|
echo "${context:0:500}"
|
|
}
|
|
|
|
# Initialize or resume Claude session
|
|
init_claude_session() {
|
|
if [[ -f "$CLAUDE_SESSION_FILE" ]]; then
|
|
local session_id=$(cat "$CLAUDE_SESSION_FILE" 2>/dev/null)
|
|
if [[ -n "$session_id" ]]; then
|
|
log_status "INFO" "Resuming Claude session: ${session_id:0:20}..."
|
|
echo "$session_id"
|
|
return 0
|
|
fi
|
|
fi
|
|
|
|
log_status "INFO" "Starting new Claude session"
|
|
echo ""
|
|
}
|
|
|
|
# Save session ID after successful execution
|
|
save_claude_session() {
|
|
local output_file=$1
|
|
|
|
# Try to extract session ID from JSON output
|
|
if [[ -f "$output_file" ]]; then
|
|
local session_id=$(jq -r '.metadata.session_id // .session_id // empty' "$output_file" 2>/dev/null)
|
|
if [[ -n "$session_id" && "$session_id" != "null" ]]; then
|
|
echo "$session_id" > "$CLAUDE_SESSION_FILE"
|
|
log_status "INFO" "Saved Claude session: ${session_id:0:20}..."
|
|
fi
|
|
fi
|
|
}
|
|
|
|
# Global array for Claude command arguments (avoids shell injection)
|
|
declare -a CLAUDE_CMD_ARGS=()
|
|
|
|
# Build Claude CLI command with modern flags using array (shell-injection safe)
|
|
# Populates global CLAUDE_CMD_ARGS array for direct execution
|
|
build_claude_command() {
|
|
local prompt_file=$1
|
|
local loop_context=$2
|
|
local session_id=$3
|
|
|
|
# Reset global array
|
|
CLAUDE_CMD_ARGS=("$CLAUDE_CODE_CMD")
|
|
|
|
# Add output format flag
|
|
if [[ "$CLAUDE_OUTPUT_FORMAT" == "json" ]]; then
|
|
CLAUDE_CMD_ARGS+=("--output-format" "json")
|
|
fi
|
|
|
|
# Add allowed tools (each tool as separate array element)
|
|
if [[ -n "$CLAUDE_ALLOWED_TOOLS" ]]; then
|
|
CLAUDE_CMD_ARGS+=("--allowedTools")
|
|
# Split by comma and add each tool
|
|
local IFS=','
|
|
read -ra tools_array <<< "$CLAUDE_ALLOWED_TOOLS"
|
|
for tool in "${tools_array[@]}"; do
|
|
# Trim whitespace
|
|
tool=$(echo "$tool" | sed 's/^[[:space:]]*//;s/[[:space:]]*$//')
|
|
if [[ -n "$tool" ]]; then
|
|
CLAUDE_CMD_ARGS+=("$tool")
|
|
fi
|
|
done
|
|
fi
|
|
|
|
# Add session continuity flag
|
|
if [[ "$CLAUDE_USE_CONTINUE" == "true" ]]; then
|
|
CLAUDE_CMD_ARGS+=("--continue")
|
|
fi
|
|
|
|
# Add loop context as system prompt (no escaping needed - array handles it)
|
|
if [[ -n "$loop_context" ]]; then
|
|
CLAUDE_CMD_ARGS+=("--append-system-prompt" "$loop_context")
|
|
fi
|
|
|
|
# Add prompt file
|
|
CLAUDE_CMD_ARGS+=("--prompt-file" "$prompt_file")
|
|
}
|
|
|
|
# Main execution function
|
|
execute_claude_code() {
|
|
local timestamp=$(date '+%Y-%m-%d_%H-%M-%S')
|
|
local output_file="$LOG_DIR/claude_output_${timestamp}.log"
|
|
local loop_count=$1
|
|
local calls_made=$(cat "$CALL_COUNT_FILE" 2>/dev/null || echo "0")
|
|
calls_made=$((calls_made + 1))
|
|
|
|
log_status "LOOP" "Executing Claude Code (Call $calls_made/$MAX_CALLS_PER_HOUR)"
|
|
local timeout_seconds=$((CLAUDE_TIMEOUT_MINUTES * 60))
|
|
log_status "INFO" "⏳ Starting Claude Code execution... (timeout: ${CLAUDE_TIMEOUT_MINUTES}m)"
|
|
|
|
# Build loop context for session continuity
|
|
local loop_context=""
|
|
if [[ "$CLAUDE_USE_CONTINUE" == "true" ]]; then
|
|
loop_context=$(build_loop_context "$loop_count")
|
|
if [[ -n "$loop_context" && "$VERBOSE_PROGRESS" == "true" ]]; then
|
|
log_status "INFO" "Loop context: $loop_context"
|
|
fi
|
|
fi
|
|
|
|
# Initialize or resume session
|
|
local session_id=""
|
|
if [[ "$CLAUDE_USE_CONTINUE" == "true" ]]; then
|
|
session_id=$(init_claude_session)
|
|
fi
|
|
|
|
# Build the Claude CLI command with modern flags
|
|
# Note: We use the modern --prompt-file approach when CLAUDE_OUTPUT_FORMAT is "json"
|
|
# For backward compatibility, fall back to stdin piping for text mode
|
|
local use_modern_cli=false
|
|
|
|
if [[ "$CLAUDE_OUTPUT_FORMAT" == "json" ]]; then
|
|
# Modern approach: use CLI flags (builds CLAUDE_CMD_ARGS array)
|
|
build_claude_command "$PROMPT_FILE" "$loop_context" "$session_id"
|
|
use_modern_cli=true
|
|
log_status "INFO" "Using modern CLI mode (JSON output)"
|
|
else
|
|
log_status "INFO" "Using legacy CLI mode (text output)"
|
|
fi
|
|
|
|
# Execute Claude Code
|
|
if [[ "$use_modern_cli" == "true" ]]; then
|
|
# Modern execution with command array (shell-injection safe)
|
|
# Execute array directly without bash -c to prevent shell metacharacter interpretation
|
|
if timeout ${timeout_seconds}s "${CLAUDE_CMD_ARGS[@]}" > "$output_file" 2>&1 &
|
|
then
|
|
: # Continue to wait loop
|
|
else
|
|
log_status "ERROR" "❌ Failed to start Claude Code process (modern mode)"
|
|
# Fall back to legacy mode
|
|
log_status "INFO" "Falling back to legacy mode..."
|
|
use_modern_cli=false
|
|
fi
|
|
fi
|
|
|
|
# Fall back to legacy stdin piping if modern mode failed or not enabled
|
|
if [[ "$use_modern_cli" == "false" ]]; then
|
|
if timeout ${timeout_seconds}s $CLAUDE_CODE_CMD < "$PROMPT_FILE" > "$output_file" 2>&1 &
|
|
then
|
|
: # Continue to wait loop
|
|
else
|
|
log_status "ERROR" "❌ Failed to start Claude Code process"
|
|
return 1
|
|
fi
|
|
fi
|
|
|
|
# Get PID and monitor progress
|
|
local claude_pid=$!
|
|
local progress_counter=0
|
|
|
|
# Show progress while Claude Code is running
|
|
while kill -0 $claude_pid 2>/dev/null; do
|
|
progress_counter=$((progress_counter + 1))
|
|
case $((progress_counter % 4)) in
|
|
1) progress_indicator="⠋" ;;
|
|
2) progress_indicator="⠙" ;;
|
|
3) progress_indicator="⠹" ;;
|
|
0) progress_indicator="⠸" ;;
|
|
esac
|
|
|
|
# Get last line from output if available
|
|
local last_line=""
|
|
if [[ -f "$output_file" && -s "$output_file" ]]; then
|
|
last_line=$(tail -1 "$output_file" 2>/dev/null | head -c 80)
|
|
fi
|
|
|
|
# Update progress file for monitor
|
|
cat > "$PROGRESS_FILE" << EOF
|
|
{
|
|
"status": "executing",
|
|
"indicator": "$progress_indicator",
|
|
"elapsed_seconds": $((progress_counter * 10)),
|
|
"last_output": "$last_line",
|
|
"timestamp": "$(date '+%Y-%m-%d %H:%M:%S')"
|
|
}
|
|
EOF
|
|
|
|
# Only log if verbose mode is enabled
|
|
if [[ "$VERBOSE_PROGRESS" == "true" ]]; then
|
|
if [[ -n "$last_line" ]]; then
|
|
log_status "INFO" "$progress_indicator Claude Code: $last_line... (${progress_counter}0s)"
|
|
else
|
|
log_status "INFO" "$progress_indicator Claude Code working... (${progress_counter}0s elapsed)"
|
|
fi
|
|
fi
|
|
|
|
sleep 10
|
|
done
|
|
|
|
# Wait for the process to finish and get exit code
|
|
wait $claude_pid
|
|
local exit_code=$?
|
|
|
|
if [ $exit_code -eq 0 ]; then
|
|
# Only increment counter on successful execution
|
|
echo "$calls_made" > "$CALL_COUNT_FILE"
|
|
|
|
# Clear progress file
|
|
echo '{"status": "completed", "timestamp": "'$(date '+%Y-%m-%d %H:%M:%S')'"}' > "$PROGRESS_FILE"
|
|
|
|
log_status "SUCCESS" "✅ Claude Code execution completed successfully"
|
|
|
|
# Save session ID from JSON output (Phase 1.1)
|
|
if [[ "$CLAUDE_USE_CONTINUE" == "true" ]]; then
|
|
save_claude_session "$output_file"
|
|
fi
|
|
|
|
# Analyze the response
|
|
log_status "INFO" "🔍 Analyzing Claude Code response..."
|
|
analyze_response "$output_file" "$loop_count"
|
|
local analysis_exit_code=$?
|
|
|
|
# Update exit signals based on analysis
|
|
update_exit_signals
|
|
|
|
# Log analysis summary
|
|
log_analysis_summary
|
|
|
|
# Get file change count for circuit breaker
|
|
local files_changed=$(git diff --name-only 2>/dev/null | wc -l || echo 0)
|
|
local has_errors="false"
|
|
|
|
# Two-stage error detection to avoid JSON field false positives
|
|
# Stage 1: Filter out JSON field patterns like "is_error": false
|
|
# Stage 2: Look for actual error messages in specific contexts
|
|
# Avoid type annotations like "error: Error" by requiring lowercase after ": error"
|
|
if grep -v '"[^"]*error[^"]*":' "$output_file" 2>/dev/null | \
|
|
grep -qE '(^Error:|^ERROR:|^error:|\]: error|Link: error|Error occurred|failed with error|[Ee]xception|Fatal|FATAL)'; then
|
|
has_errors="true"
|
|
|
|
# Debug logging: show what triggered error detection
|
|
if [[ "$VERBOSE_PROGRESS" == "true" ]]; then
|
|
log_status "DEBUG" "Error patterns found:"
|
|
grep -v '"[^"]*error[^"]*":' "$output_file" 2>/dev/null | \
|
|
grep -nE '(^Error:|^ERROR:|^error:|\]: error|Link: error|Error occurred|failed with error|[Ee]xception|Fatal|FATAL)' | \
|
|
head -3 | while IFS= read -r line; do
|
|
log_status "DEBUG" " $line"
|
|
done
|
|
fi
|
|
|
|
log_status "WARN" "Errors detected in output, check: $output_file"
|
|
fi
|
|
local output_length=$(wc -c < "$output_file" 2>/dev/null || echo 0)
|
|
|
|
# Record result in circuit breaker
|
|
record_loop_result "$loop_count" "$files_changed" "$has_errors" "$output_length"
|
|
local circuit_result=$?
|
|
|
|
if [[ $circuit_result -ne 0 ]]; then
|
|
log_status "WARN" "Circuit breaker opened - halting execution"
|
|
return 3 # Special code for circuit breaker trip
|
|
fi
|
|
|
|
return 0
|
|
else
|
|
# Clear progress file on failure
|
|
echo '{"status": "failed", "timestamp": "'$(date '+%Y-%m-%d %H:%M:%S')'"}' > "$PROGRESS_FILE"
|
|
|
|
# Check if the failure is due to API 5-hour limit
|
|
if grep -qi "5.*hour.*limit\|limit.*reached.*try.*back\|usage.*limit.*reached" "$output_file"; then
|
|
log_status "ERROR" "🚫 Claude API 5-hour usage limit reached"
|
|
return 2 # Special return code for API limit
|
|
else
|
|
log_status "ERROR" "❌ Claude Code execution failed, check: $output_file"
|
|
return 1
|
|
fi
|
|
fi
|
|
}
|
|
|
|
# Cleanup function
|
|
cleanup() {
|
|
log_status "INFO" "Ralph loop interrupted. Cleaning up..."
|
|
update_status "$loop_count" "$(cat "$CALL_COUNT_FILE" 2>/dev/null || echo "0")" "interrupted" "stopped"
|
|
exit 0
|
|
}
|
|
|
|
# Set up signal handlers
|
|
trap cleanup SIGINT SIGTERM
|
|
|
|
# Global variable for loop count (needed by cleanup function)
|
|
loop_count=0
|
|
|
|
# Main loop
|
|
main() {
|
|
|
|
log_status "SUCCESS" "🚀 Ralph loop starting with Claude Code"
|
|
log_status "INFO" "Max calls per hour: $MAX_CALLS_PER_HOUR"
|
|
log_status "INFO" "Logs: $LOG_DIR/ | Docs: $DOCS_DIR/ | Status: $STATUS_FILE"
|
|
|
|
# Check if this is a Ralph project directory
|
|
if [[ ! -f "$PROMPT_FILE" ]]; then
|
|
log_status "ERROR" "Prompt file '$PROMPT_FILE' not found!"
|
|
echo ""
|
|
|
|
# Check if this looks like a partial Ralph project
|
|
if [[ -f "@fix_plan.md" ]] || [[ -d "specs" ]] || [[ -f "@AGENT.md" ]]; then
|
|
echo "This appears to be a Ralph project but is missing PROMPT.md."
|
|
echo "You may need to create or restore the PROMPT.md file."
|
|
else
|
|
echo "This directory is not a Ralph project."
|
|
fi
|
|
|
|
echo ""
|
|
echo "To fix this:"
|
|
echo " 1. Create a new project: ralph-setup my-project"
|
|
echo " 2. Import existing requirements: ralph-import requirements.md"
|
|
echo " 3. Navigate to an existing Ralph project directory"
|
|
echo " 4. Or create PROMPT.md manually in this directory"
|
|
echo ""
|
|
echo "Ralph projects should contain: PROMPT.md, @fix_plan.md, specs/, src/, etc."
|
|
exit 1
|
|
fi
|
|
|
|
log_status "INFO" "Starting main loop..."
|
|
log_status "INFO" "DEBUG: About to enter while loop, loop_count=$loop_count"
|
|
|
|
while true; do
|
|
loop_count=$((loop_count + 1))
|
|
log_status "INFO" "DEBUG: Successfully incremented loop_count to $loop_count"
|
|
log_status "INFO" "Loop #$loop_count - calling init_call_tracking..."
|
|
init_call_tracking
|
|
|
|
log_status "LOOP" "=== Starting Loop #$loop_count ==="
|
|
|
|
# Check circuit breaker before attempting execution
|
|
if should_halt_execution; then
|
|
update_status "$loop_count" "$(cat "$CALL_COUNT_FILE")" "circuit_breaker_open" "halted" "stagnation_detected"
|
|
log_status "ERROR" "🛑 Circuit breaker has opened - execution halted"
|
|
break
|
|
fi
|
|
|
|
# Check rate limits
|
|
if ! can_make_call; then
|
|
wait_for_reset
|
|
continue
|
|
fi
|
|
|
|
# Check for graceful exit conditions
|
|
local exit_reason=$(should_exit_gracefully)
|
|
if [[ "$exit_reason" != "" ]]; then
|
|
log_status "SUCCESS" "🏁 Graceful exit triggered: $exit_reason"
|
|
update_status "$loop_count" "$(cat "$CALL_COUNT_FILE")" "graceful_exit" "completed" "$exit_reason"
|
|
|
|
log_status "SUCCESS" "🎉 Ralph has completed the project! Final stats:"
|
|
log_status "INFO" " - Total loops: $loop_count"
|
|
log_status "INFO" " - API calls used: $(cat "$CALL_COUNT_FILE")"
|
|
log_status "INFO" " - Exit reason: $exit_reason"
|
|
|
|
break
|
|
fi
|
|
|
|
# Update status
|
|
local calls_made=$(cat "$CALL_COUNT_FILE" 2>/dev/null || echo "0")
|
|
update_status "$loop_count" "$calls_made" "executing" "running"
|
|
|
|
# Execute Claude Code
|
|
execute_claude_code "$loop_count"
|
|
local exec_result=$?
|
|
|
|
if [ $exec_result -eq 0 ]; then
|
|
update_status "$loop_count" "$(cat "$CALL_COUNT_FILE")" "completed" "success"
|
|
|
|
# Brief pause between successful executions
|
|
sleep 5
|
|
elif [ $exec_result -eq 3 ]; then
|
|
# Circuit breaker opened
|
|
update_status "$loop_count" "$(cat "$CALL_COUNT_FILE")" "circuit_breaker_open" "halted" "stagnation_detected"
|
|
log_status "ERROR" "🛑 Circuit breaker has opened - halting loop"
|
|
log_status "INFO" "Run 'ralph --reset-circuit' to reset the circuit breaker after addressing issues"
|
|
break
|
|
elif [ $exec_result -eq 2 ]; then
|
|
# API 5-hour limit reached - handle specially
|
|
update_status "$loop_count" "$(cat "$CALL_COUNT_FILE")" "api_limit" "paused"
|
|
log_status "WARN" "🛑 Claude API 5-hour limit reached!"
|
|
|
|
# Ask user whether to wait or exit
|
|
echo -e "\n${YELLOW}The Claude API 5-hour usage limit has been reached.${NC}"
|
|
echo -e "${YELLOW}You can either:${NC}"
|
|
echo -e " ${GREEN}1)${NC} Wait for the limit to reset (usually within an hour)"
|
|
echo -e " ${GREEN}2)${NC} Exit the loop and try again later"
|
|
echo -e "\n${BLUE}Choose an option (1 or 2):${NC} "
|
|
|
|
# Read user input with timeout
|
|
read -t 30 -n 1 user_choice
|
|
echo # New line after input
|
|
|
|
if [[ "$user_choice" == "2" ]] || [[ -z "$user_choice" ]]; then
|
|
log_status "INFO" "User chose to exit (or timed out). Exiting loop..."
|
|
update_status "$loop_count" "$(cat "$CALL_COUNT_FILE")" "api_limit_exit" "stopped" "api_5hour_limit"
|
|
break
|
|
else
|
|
log_status "INFO" "User chose to wait. Waiting for API limit reset..."
|
|
# Wait for longer period when API limit is hit
|
|
local wait_minutes=60
|
|
log_status "INFO" "Waiting $wait_minutes minutes before retrying..."
|
|
|
|
# Countdown display
|
|
local wait_seconds=$((wait_minutes * 60))
|
|
while [[ $wait_seconds -gt 0 ]]; do
|
|
local minutes=$((wait_seconds / 60))
|
|
local seconds=$((wait_seconds % 60))
|
|
printf "\r${YELLOW}Time until retry: %02d:%02d${NC}" $minutes $seconds
|
|
sleep 1
|
|
((wait_seconds--))
|
|
done
|
|
printf "\n"
|
|
fi
|
|
else
|
|
update_status "$loop_count" "$(cat "$CALL_COUNT_FILE")" "failed" "error"
|
|
log_status "WARN" "Execution failed, waiting 30 seconds before retry..."
|
|
sleep 30
|
|
fi
|
|
|
|
log_status "LOOP" "=== Completed Loop #$loop_count ==="
|
|
done
|
|
}
|
|
|
|
# Help function
|
|
show_help() {
|
|
cat << HELPEOF
|
|
Ralph Loop for Claude Code
|
|
|
|
Usage: $0 [OPTIONS]
|
|
|
|
IMPORTANT: This command must be run from a Ralph project directory.
|
|
Use 'ralph-setup project-name' to create a new project first.
|
|
|
|
Options:
|
|
-h, --help Show this help message
|
|
-c, --calls NUM Set max calls per hour (default: $MAX_CALLS_PER_HOUR)
|
|
-p, --prompt FILE Set prompt file (default: $PROMPT_FILE)
|
|
-s, --status Show current status and exit
|
|
-m, --monitor Start with tmux session and live monitor (requires tmux)
|
|
-v, --verbose Show detailed progress updates during execution
|
|
-t, --timeout MIN Set Claude Code execution timeout in minutes (default: $CLAUDE_TIMEOUT_MINUTES)
|
|
--reset-circuit Reset circuit breaker to CLOSED state
|
|
--circuit-status Show circuit breaker status and exit
|
|
|
|
Modern CLI Options (Phase 1.1):
|
|
--output-format FORMAT Set Claude output format: json or text (default: $CLAUDE_OUTPUT_FORMAT)
|
|
--allowed-tools TOOLS Comma-separated list of allowed tools (default: $CLAUDE_ALLOWED_TOOLS)
|
|
--no-continue Disable session continuity across loops
|
|
|
|
Files created:
|
|
- $LOG_DIR/: All execution logs
|
|
- $DOCS_DIR/: Generated documentation
|
|
- $STATUS_FILE: Current status (JSON)
|
|
|
|
Example workflow:
|
|
ralph-setup my-project # Create project
|
|
cd my-project # Enter project directory
|
|
$0 --monitor # Start Ralph with monitoring
|
|
|
|
Examples:
|
|
$0 --calls 50 --prompt my_prompt.md
|
|
$0 --monitor # Start with integrated tmux monitoring
|
|
$0 --monitor --timeout 30 # 30-minute timeout for complex tasks
|
|
$0 --verbose --timeout 5 # 5-minute timeout with detailed progress
|
|
$0 --output-format text # Use legacy text output format
|
|
$0 --no-continue # Disable session continuity
|
|
|
|
HELPEOF
|
|
}
|
|
|
|
# Parse command line arguments
|
|
while [[ $# -gt 0 ]]; do
|
|
case $1 in
|
|
-h|--help)
|
|
show_help
|
|
exit 0
|
|
;;
|
|
-c|--calls)
|
|
MAX_CALLS_PER_HOUR="$2"
|
|
shift 2
|
|
;;
|
|
-p|--prompt)
|
|
PROMPT_FILE="$2"
|
|
shift 2
|
|
;;
|
|
-s|--status)
|
|
if [[ -f "$STATUS_FILE" ]]; then
|
|
echo "Current Status:"
|
|
cat "$STATUS_FILE" | jq . 2>/dev/null || cat "$STATUS_FILE"
|
|
else
|
|
echo "No status file found. Ralph may not be running."
|
|
fi
|
|
exit 0
|
|
;;
|
|
-m|--monitor)
|
|
USE_TMUX=true
|
|
shift
|
|
;;
|
|
-v|--verbose)
|
|
VERBOSE_PROGRESS=true
|
|
shift
|
|
;;
|
|
-t|--timeout)
|
|
if [[ "$2" =~ ^[1-9][0-9]*$ ]] && [[ "$2" -le 120 ]]; then
|
|
CLAUDE_TIMEOUT_MINUTES="$2"
|
|
else
|
|
echo "Error: Timeout must be a positive integer between 1 and 120 minutes"
|
|
exit 1
|
|
fi
|
|
shift 2
|
|
;;
|
|
--reset-circuit)
|
|
# Source the circuit breaker library
|
|
SCRIPT_DIR="$(dirname "${BASH_SOURCE[0]}")"
|
|
source "$SCRIPT_DIR/lib/circuit_breaker.sh"
|
|
reset_circuit_breaker "Manual reset via command line"
|
|
exit 0
|
|
;;
|
|
--circuit-status)
|
|
# Source the circuit breaker library
|
|
SCRIPT_DIR="$(dirname "${BASH_SOURCE[0]}")"
|
|
source "$SCRIPT_DIR/lib/circuit_breaker.sh"
|
|
show_circuit_status
|
|
exit 0
|
|
;;
|
|
--output-format)
|
|
if [[ "$2" == "json" || "$2" == "text" ]]; then
|
|
CLAUDE_OUTPUT_FORMAT="$2"
|
|
else
|
|
echo "Error: --output-format must be 'json' or 'text'"
|
|
exit 1
|
|
fi
|
|
shift 2
|
|
;;
|
|
--allowed-tools)
|
|
if ! validate_allowed_tools "$2"; then
|
|
exit 1
|
|
fi
|
|
CLAUDE_ALLOWED_TOOLS="$2"
|
|
shift 2
|
|
;;
|
|
--no-continue)
|
|
CLAUDE_USE_CONTINUE=false
|
|
shift
|
|
;;
|
|
*)
|
|
echo "Unknown option: $1"
|
|
show_help
|
|
exit 1
|
|
;;
|
|
esac
|
|
done
|
|
|
|
# If tmux mode requested, set it up
|
|
if [[ "$USE_TMUX" == "true" ]]; then
|
|
check_tmux_available
|
|
setup_tmux_session
|
|
fi
|
|
|
|
# Start the main loop
|
|
main
|