mirror of
https://github.com/leonvanzyl/autocoder.git
synced 2026-01-30 06:12:06 +00:00
bf3a6b0b73
Changes: - Add per-agent log viewer with copy-to-clipboard functionality - New AgentLogEntry type for structured log entries - Logs stored per-agent in WebSocket state (up to 500 entries) - Log modal rendered via React Portal to avoid overflow issues - Click log icon on agent card to view full activity history - Fix agents getting stuck in "failed" state - Wrap client context manager in try/except (agent.py) - Remove failed agents from UI on error state (useWebSocket.ts) - Handle permanently failed features in get_all_complete() - Add friendlier agent state labels - "Hit an issue" → "Trying plan B..." - "Retrying..." → "Being persistent..." - Softer colors (yellow/orange instead of red) - Add scheduling scores for smarter feature ordering - compute_scheduling_scores() in dependency_resolver.py - Features that unblock others get higher priority - Update CLAUDE.md with parallel mode documentation Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
303 lines
11 KiB
Python
303 lines
11 KiB
Python
"""
|
|
Agent Session Logic
|
|
===================
|
|
|
|
Core agent interaction functions for running autonomous coding sessions.
|
|
"""
|
|
|
|
import asyncio
|
|
import io
|
|
import re
|
|
import sys
|
|
from datetime import datetime, timedelta
|
|
from pathlib import Path
|
|
from typing import Optional
|
|
from zoneinfo import ZoneInfo
|
|
|
|
from claude_agent_sdk import ClaudeSDKClient
|
|
|
|
# Fix Windows console encoding for Unicode characters (emoji, etc.)
|
|
# Without this, print() crashes when Claude outputs emoji like ✅
|
|
if sys.platform == "win32":
|
|
sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding="utf-8", errors="replace", line_buffering=True)
|
|
sys.stderr = io.TextIOWrapper(sys.stderr.buffer, encoding="utf-8", errors="replace", line_buffering=True)
|
|
|
|
from client import create_client
|
|
from progress import has_features, print_progress_summary, print_session_header
|
|
from prompts import (
|
|
copy_spec_to_project,
|
|
get_coding_prompt,
|
|
get_coding_prompt_yolo,
|
|
get_initializer_prompt,
|
|
get_single_feature_prompt,
|
|
)
|
|
|
|
# Configuration
|
|
AUTO_CONTINUE_DELAY_SECONDS = 3
|
|
|
|
|
|
async def run_agent_session(
|
|
client: ClaudeSDKClient,
|
|
message: str,
|
|
project_dir: Path,
|
|
) -> tuple[str, str]:
|
|
"""
|
|
Run a single agent session using Claude Agent SDK.
|
|
|
|
Args:
|
|
client: Claude SDK client
|
|
message: The prompt to send
|
|
project_dir: Project directory path
|
|
|
|
Returns:
|
|
(status, response_text) where status is:
|
|
- "continue" if agent should continue working
|
|
- "error" if an error occurred
|
|
"""
|
|
print("Sending prompt to Claude Agent SDK...\n")
|
|
|
|
try:
|
|
# Send the query
|
|
await client.query(message)
|
|
|
|
# Collect response text and show tool use
|
|
response_text = ""
|
|
async for msg in client.receive_response():
|
|
msg_type = type(msg).__name__
|
|
|
|
# Handle AssistantMessage (text and tool use)
|
|
if msg_type == "AssistantMessage" and hasattr(msg, "content"):
|
|
for block in msg.content:
|
|
block_type = type(block).__name__
|
|
|
|
if block_type == "TextBlock" and hasattr(block, "text"):
|
|
response_text += block.text
|
|
print(block.text, end="", flush=True)
|
|
elif block_type == "ToolUseBlock" and hasattr(block, "name"):
|
|
print(f"\n[Tool: {block.name}]", flush=True)
|
|
if hasattr(block, "input"):
|
|
input_str = str(block.input)
|
|
if len(input_str) > 200:
|
|
print(f" Input: {input_str[:200]}...", flush=True)
|
|
else:
|
|
print(f" Input: {input_str}", flush=True)
|
|
|
|
# Handle UserMessage (tool results)
|
|
elif msg_type == "UserMessage" and hasattr(msg, "content"):
|
|
for block in msg.content:
|
|
block_type = type(block).__name__
|
|
|
|
if block_type == "ToolResultBlock":
|
|
result_content = getattr(block, "content", "")
|
|
is_error = getattr(block, "is_error", False)
|
|
|
|
# Check if command was blocked by security hook
|
|
if "blocked" in str(result_content).lower():
|
|
print(f" [BLOCKED] {result_content}", flush=True)
|
|
elif is_error:
|
|
# Show errors (truncated)
|
|
error_str = str(result_content)[:500]
|
|
print(f" [Error] {error_str}", flush=True)
|
|
else:
|
|
# Tool succeeded - just show brief confirmation
|
|
print(" [Done]", flush=True)
|
|
|
|
print("\n" + "-" * 70 + "\n")
|
|
return "continue", response_text
|
|
|
|
except Exception as e:
|
|
print(f"Error during agent session: {e}")
|
|
return "error", str(e)
|
|
|
|
|
|
async def run_autonomous_agent(
|
|
project_dir: Path,
|
|
model: str,
|
|
max_iterations: Optional[int] = None,
|
|
yolo_mode: bool = False,
|
|
feature_id: Optional[int] = None,
|
|
) -> None:
|
|
"""
|
|
Run the autonomous agent loop.
|
|
|
|
Args:
|
|
project_dir: Directory for the project
|
|
model: Claude model to use
|
|
max_iterations: Maximum number of iterations (None for unlimited)
|
|
yolo_mode: If True, skip browser testing and use YOLO prompt
|
|
feature_id: If set, work only on this specific feature (used by parallel orchestrator)
|
|
"""
|
|
print("\n" + "=" * 70)
|
|
print(" AUTONOMOUS CODING AGENT DEMO")
|
|
print("=" * 70)
|
|
print(f"\nProject directory: {project_dir}")
|
|
print(f"Model: {model}")
|
|
if yolo_mode:
|
|
print("Mode: YOLO (testing disabled)")
|
|
else:
|
|
print("Mode: Standard (full testing)")
|
|
if feature_id:
|
|
print(f"Single-feature mode: Feature #{feature_id}")
|
|
if max_iterations:
|
|
print(f"Max iterations: {max_iterations}")
|
|
else:
|
|
print("Max iterations: Unlimited (will run until completion)")
|
|
print()
|
|
|
|
# Create project directory
|
|
project_dir.mkdir(parents=True, exist_ok=True)
|
|
|
|
# Check if this is a fresh start or continuation
|
|
# Uses has_features() which checks if the database actually has features,
|
|
# not just if the file exists (empty db should still trigger initializer)
|
|
is_first_run = not has_features(project_dir)
|
|
|
|
if is_first_run:
|
|
print("Fresh start - will use initializer agent")
|
|
print()
|
|
print("=" * 70)
|
|
print(" NOTE: First session takes 10-20+ minutes!")
|
|
print(" The agent is generating 200 detailed test cases.")
|
|
print(" This may appear to hang - it's working. Watch for [Tool: ...] output.")
|
|
print("=" * 70)
|
|
print()
|
|
# Copy the app spec into the project directory for the agent to read
|
|
copy_spec_to_project(project_dir)
|
|
else:
|
|
print("Continuing existing project")
|
|
print_progress_summary(project_dir)
|
|
|
|
# Main loop
|
|
iteration = 0
|
|
|
|
while True:
|
|
iteration += 1
|
|
|
|
# Check max iterations
|
|
if max_iterations and iteration > max_iterations:
|
|
print(f"\nReached max iterations ({max_iterations})")
|
|
print("To continue, run the script again without --max-iterations")
|
|
break
|
|
|
|
# Print session header
|
|
print_session_header(iteration, is_first_run)
|
|
|
|
# Create client (fresh context)
|
|
# In single-feature mode, pass agent_id for browser isolation
|
|
agent_id = f"feature-{feature_id}" if feature_id else None
|
|
client = create_client(project_dir, model, yolo_mode=yolo_mode, agent_id=agent_id)
|
|
|
|
# Choose prompt based on session type
|
|
# Pass project_dir to enable project-specific prompts
|
|
if is_first_run:
|
|
prompt = get_initializer_prompt(project_dir)
|
|
is_first_run = False # Only use initializer once
|
|
elif feature_id:
|
|
# Single-feature mode (used by parallel orchestrator)
|
|
prompt = get_single_feature_prompt(feature_id, project_dir, yolo_mode)
|
|
else:
|
|
# Use YOLO prompt if in YOLO mode
|
|
if yolo_mode:
|
|
prompt = get_coding_prompt_yolo(project_dir)
|
|
else:
|
|
prompt = get_coding_prompt(project_dir)
|
|
|
|
# Run session with async context manager
|
|
# Wrap in try/except to handle MCP server startup failures gracefully
|
|
try:
|
|
async with client:
|
|
status, response = await run_agent_session(client, prompt, project_dir)
|
|
except Exception as e:
|
|
print(f"Client/MCP server error: {e}")
|
|
# Don't crash - return error status so the loop can retry
|
|
status, response = "error", str(e)
|
|
|
|
# Handle status
|
|
if status == "continue":
|
|
delay_seconds = AUTO_CONTINUE_DELAY_SECONDS
|
|
target_time_str = None
|
|
|
|
if "limit reached" in response.lower():
|
|
print("Claude Agent SDK indicated limit reached.")
|
|
|
|
# Try to parse reset time from response
|
|
match = re.search(
|
|
r"(?i)\bresets(?:\s+at)?\s+(\d+)(?::(\d+))?\s*(am|pm)\s*\(([^)]+)\)",
|
|
response,
|
|
)
|
|
if match:
|
|
hour = int(match.group(1))
|
|
minute = int(match.group(2)) if match.group(2) else 0
|
|
period = match.group(3).lower()
|
|
tz_name = match.group(4).strip()
|
|
|
|
# Convert to 24-hour format
|
|
if period == "pm" and hour != 12:
|
|
hour += 12
|
|
elif period == "am" and hour == 12:
|
|
hour = 0
|
|
|
|
try:
|
|
tz = ZoneInfo(tz_name)
|
|
now = datetime.now(tz)
|
|
target = now.replace(
|
|
hour=hour, minute=minute, second=0, microsecond=0
|
|
)
|
|
|
|
# If target time has already passed today, wait until tomorrow
|
|
if target <= now:
|
|
target += timedelta(days=1)
|
|
|
|
delta = target - now
|
|
delay_seconds = min(
|
|
delta.total_seconds(), 24 * 60 * 60
|
|
) # Clamp to 24 hours max
|
|
target_time_str = target.strftime("%B %d, %Y at %I:%M %p %Z")
|
|
|
|
except Exception as e:
|
|
print(f"Error parsing reset time: {e}, using default delay")
|
|
|
|
if target_time_str:
|
|
print(
|
|
f"\nClaude Code Limit Reached. Agent will auto-continue in {delay_seconds:.0f}s ({target_time_str})...",
|
|
flush=True,
|
|
)
|
|
else:
|
|
print(
|
|
f"\nAgent will auto-continue in {delay_seconds:.0f}s...", flush=True
|
|
)
|
|
|
|
sys.stdout.flush() # this should allow the pause to be displayed before sleeping
|
|
print_progress_summary(project_dir)
|
|
await asyncio.sleep(delay_seconds)
|
|
|
|
elif status == "error":
|
|
print("\nSession encountered an error")
|
|
print("Will retry with a fresh session...")
|
|
await asyncio.sleep(AUTO_CONTINUE_DELAY_SECONDS)
|
|
|
|
# Small delay between sessions
|
|
if max_iterations is None or iteration < max_iterations:
|
|
print("\nPreparing next session...\n")
|
|
await asyncio.sleep(1)
|
|
|
|
# Final summary
|
|
print("\n" + "=" * 70)
|
|
print(" SESSION COMPLETE")
|
|
print("=" * 70)
|
|
print(f"\nProject directory: {project_dir}")
|
|
print_progress_summary(project_dir)
|
|
|
|
# Print instructions for running the generated application
|
|
print("\n" + "-" * 70)
|
|
print(" TO RUN THE GENERATED APPLICATION:")
|
|
print("-" * 70)
|
|
print(f"\n cd {project_dir.resolve()}")
|
|
print(" ./init.sh # Run the setup script")
|
|
print(" # Or manually:")
|
|
print(" npm install && npm run dev")
|
|
print("\n Then open http://localhost:3000 (or check init.sh for the URL)")
|
|
print("-" * 70)
|
|
|
|
print("\nDone!")
|