code-puppy 0.0.380__py3-none-any.whl → 0.0.382__py3-none-any.whl

code_puppy/plugins/ralph/commands.py

@@ -1,208 +0,0 @@
-"""Ralph plugin slash commands - registered via custom_command callback."""
-
-from typing import Any, List, Optional, Tuple
-
-from code_puppy.messaging import emit_error, emit_info, emit_success, emit_warning
-from code_puppy.plugins.customizable_commands.register_callbacks import (
-    MarkdownCommandResult,
-)
-
-from .state_manager import get_state_manager
-
-
-def get_ralph_help() -> List[Tuple[str, str]]:
-    """Get help entries for Ralph commands.
-
-    Returns:
-        List of (command_name, description) tuples.
-    """
-    return [
-        ("ralph", "Show Ralph help and usage"),
-        ("ralph status", "Show current prd.json status"),
-        ("ralph prd", "Switch to PRD Generator agent to create a new PRD"),
-        ("ralph convert", "Switch to Ralph Converter agent to convert PRD to JSON"),
-        ("ralph start [N]", "Start the autonomous loop (optional: max N iterations)"),
-        ("ralph stop", "Stop the running Ralph loop after current iteration"),
-        ("ralph reset", "Archive current run and reset for a new PRD"),
-    ]
-
-
-def handle_ralph_command(command: str, name: str) -> Optional[Any]:
-    """Handle /ralph commands.
-
-    Args:
-        command: Full command string (e.g., "/ralph status")
-        name: Command name without slash (e.g., "ralph")
-
-    Returns:
-        - True if handled (no further action)
-        - String to process as agent input
-        - None if not a ralph command
-    """
-    if not name.startswith("ralph"):
-        return None
-
-    # Parse subcommand
-    parts = command.strip().split(maxsplit=2)
-    subcommand = parts[1] if len(parts) > 1 else "help"
-    args = parts[2] if len(parts) > 2 else ""
-
-    # Route to handler
-    handlers = {
-        "help": _handle_help,
-        "status": _handle_status,
-        "prd": _handle_prd,
-        "convert": _handle_convert,
-        "start": _handle_start,
-        "stop": _handle_stop,
-        "reset": _handle_reset,
-    }
-
-    handler = handlers.get(subcommand, _handle_help)
-    return handler(args)
-
-
-def _handle_help(args: str) -> bool:
-    """Show Ralph help."""
-    help_text = """
-🐺 **Ralph - Autonomous AI Agent Loop**
-
-Ralph runs AI coding agents repeatedly until all PRD items are complete.
-Based on Geoffrey Huntley's Ralph pattern: https://ghuntley.com/ralph/
-
-**Commands:**
-
-  `/ralph status`     - Show current prd.json status and progress
-  `/ralph prd`        - Create a new PRD (Product Requirements Document)
-  `/ralph convert`    - Convert a markdown PRD to prd.json format
-  `/ralph start [N]`  - Start the autonomous loop (max N iterations, default 10)
-  `/ralph stop`       - Stop the loop after current iteration
-  `/ralph reset`      - Archive current run and start fresh
-
-**Workflow:**
-
-  1. `/ralph prd` - Create a detailed PRD with user stories
-  2. `/ralph convert` - Convert it to prd.json format
-  3. `/ralph start` - Let Ralph autonomously implement each story
-
-**Key Files:**
-
-  - `prd.json` - User stories with completion status
-  - `progress.txt` - Learnings and patterns for future iterations
-  - `archive/` - Previous runs (auto-archived on branch change)
-"""
-    emit_info(help_text)
-    return True
-
-
-def _handle_status(args: str) -> bool:
-    """Show PRD status."""
-    manager = get_state_manager()
-
-    if not manager.prd_exists():
-        emit_warning("No prd.json found in current directory.")
-        emit_info(
-            "Use `/ralph prd` to create a PRD, then `/ralph convert` to generate prd.json"
-        )
-        return True
-
-    status = manager.get_status_summary()
-    emit_info(status)
-
-    # Also show patterns if any
-    patterns = manager.read_codebase_patterns()
-    if patterns and "<!--" not in patterns:  # Skip if just the placeholder
-        emit_info("\n**Codebase Patterns:**")
-        emit_info(patterns)
-
-    return True
-
-
-def _handle_prd(args: str) -> MarkdownCommandResult:
-    """Switch to PRD Generator agent."""
-    emit_info("🐺 Switching to Ralph PRD Generator...")
-
-    # Return a MarkdownCommandResult so it's processed as agent input
-    return MarkdownCommandResult(
-        "/agent ralph-prd-generator\nI want to create a new PRD. Please help me define the requirements."
-    )
-
-
-def _handle_convert(args: str) -> MarkdownCommandResult:
-    """Switch to Ralph Converter agent."""
-    emit_info("🐺 Switching to Ralph Converter...")
-
-    # Return a MarkdownCommandResult so it's processed as agent input
-    if args:
-        return MarkdownCommandResult(
-            f"/agent ralph-converter\nPlease convert the PRD in {args} to prd.json format."
-        )
-    else:
-        return MarkdownCommandResult(
-            "/agent ralph-converter\nPlease help me convert my PRD to prd.json format."
-        )
-
-
-def _handle_start(args: str) -> str | bool:
-    """Start the Ralph autonomous loop."""
-    manager = get_state_manager()
-
-    if not manager.prd_exists():
-        emit_error("No prd.json found!")
-        emit_info(
-            "First create a PRD with `/ralph prd` and convert it with `/ralph convert`"
-        )
-        return True
-
-    # Check if there's work to do
-    prd = manager.read_prd()
-    if prd and prd.all_complete():
-        emit_success("🎉 All stories are already complete!")
-        return True
-
-    # Parse max iterations if provided
-    max_iter = 10
-    if args:
-        try:
-            max_iter = int(args)
-        except ValueError:
-            emit_warning(f"Invalid max_iterations '{args}', using default 10")
-
-    emit_info(f"🐺 Starting Ralph with max {max_iter} iterations...")
-
-    # Return a prompt that tells the agent to run the loop
-    return f"Call the ralph_run_loop tool with max_iterations={max_iter} to start the autonomous Ralph loop. This will implement all pending stories from prd.json one by one."
-
-
-def _handle_stop(args: str) -> bool:
-    """Stop the running Ralph loop."""
-    emit_info("To stop the Ralph loop, press Ctrl+C or your configured cancel key.")
-    emit_info("The loop will halt after the current iteration completes.")
-    return True
-
-
-def _handle_reset(args: str) -> bool:
-    """Archive current run and reset."""
-    manager = get_state_manager()
-
-    if not manager.prd_exists():
-        emit_info("Nothing to reset - no prd.json found.")
-        return True
-
-    # Archive if there's content
-    progress = manager.read_progress()
-    if progress and len(progress) > 100:
-        archive_path = manager.archive_current_run()
-        if archive_path:
-            emit_success(f"📦 Archived to: {archive_path}")
-
-    # Reset
-    manager.reset_for_new_run()
-
-    # Delete prd.json
-    if manager.prd_file.exists():
-        manager.prd_file.unlink()
-        emit_info("🗑️ Removed prd.json")
-
-    emit_success("✨ Reset complete! Ready for a new PRD.")
-    return True

code_puppy/plugins/ralph/loop_controller.py

@@ -1,289 +0,0 @@
-"""Ralph Loop Controller - Manages the autonomous iteration loop.
-
-This is the "outer loop" that spawns fresh agent instances per iteration,
-just like the original ralph.sh bash script does.
-"""
-
-import asyncio
-import logging
-from typing import Awaitable, Callable, Optional
-
-from code_puppy.messaging import emit_error, emit_info, emit_success, emit_warning
-
-from .state_manager import get_state_manager
-
-logger = logging.getLogger(__name__)
-
-
-class RalphLoopController:
-    """Controls the Ralph autonomous loop.
-
-    Each iteration:
-    1. Checks if there's work to do
-    2. Invokes the ralph-orchestrator agent with a FRESH session
-    3. Waits for completion
-    4. Checks if all stories are done or if we should continue
-    """
-
-    def __init__(self, max_iterations: int = 10):
-        self.max_iterations = max_iterations
-        self.current_iteration = 0
-        self.is_complete = False
-        self.is_running = False
-        self._stop_requested = False
-
-    def request_stop(self) -> None:
-        """Request the loop to stop after current iteration."""
-        self._stop_requested = True
-        emit_warning("🛑 Stop requested - will halt after current iteration")
-
-    async def run(
-        self,
-        invoke_func: Callable[[str, str, Optional[str]], Awaitable[dict]],
-    ) -> dict:
-        """Run the Ralph loop until completion or max iterations.
-
-        Args:
-            invoke_func: Async function to invoke an agent.
-                        Signature: (agent_name, prompt, session_id) -> result_dict
-                        The result_dict should have 'response' and 'error' keys.
-
-        Returns:
-            dict with 'success', 'iterations', 'message' keys
-        """
-        self.is_running = True
-        self.is_complete = False
-        self._stop_requested = False
-
-        manager = get_state_manager()
-
-        # Pre-flight checks
-        if not manager.prd_exists():
-            self.is_running = False
-            return {
-                "success": False,
-                "iterations": 0,
-                "message": "No prd.json found. Create one with /ralph prd first.",
-            }
-
-        if manager.all_stories_complete():
-            self.is_running = False
-            return {
-                "success": True,
-                "iterations": 0,
-                "message": "All stories already complete!",
-            }
-
-        prd = manager.read_prd()
-        emit_info("🐺 Starting Ralph Loop")
-        emit_info(f"📋 Project: {prd.project if prd else 'Unknown'}")
-        emit_info(f"📊 Progress: {prd.get_progress_summary() if prd else 'Unknown'}")
-        emit_info(f"🔄 Max iterations: {self.max_iterations}")
-        emit_info("─" * 50)
-
-        try:
-            for iteration in range(1, self.max_iterations + 1):
-                self.current_iteration = iteration
-
-                # Check for stop request
-                if self._stop_requested:
-                    emit_warning(f"🛑 Stopped at iteration {iteration}")
-                    break
-
-                # Check if already complete
-                if manager.all_stories_complete():
-                    self.is_complete = True
-                    emit_success("🎉 All stories complete!")
-                    break
-
-                # Get current story for logging
-                story = manager.get_next_story()
-                if story is None:
-                    self.is_complete = True
-                    emit_success("🎉 All stories complete!")
-                    break
-
-                emit_info(f"\n{'=' * 60}")
-                emit_info(f"🐺 RALPH ITERATION {iteration} of {self.max_iterations}")
-                emit_info(f"📌 Working on: [{story.id}] {story.title}")
-                emit_info(f"{'=' * 60}\n")
-
-                # Build the prompt for this iteration
-                iteration_prompt = self._build_iteration_prompt(story)
-
-                # Invoke orchestrator with FRESH session (unique per iteration)
-                session_id = f"ralph-iter-{iteration}"
-
-                try:
-                    result = await invoke_func(
-                        "ralph-orchestrator",
-                        iteration_prompt,
-                        session_id,
-                    )
-
-                    response = result.get("response", "")
-                    error = result.get("error")
-
-                    if error:
-                        emit_error(f"Iteration {iteration} error: {error}")
-                        # Continue to next iteration despite error
-                        continue
-
-                    # Check for completion signal in response
-                    if response and "<promise>COMPLETE</promise>" in response:
-                        self.is_complete = True
-                        emit_success("🎉 Ralph signaled COMPLETE - all stories done!")
-                        break
-
-                except asyncio.CancelledError:
-                    emit_warning(f"🛑 Iteration {iteration} cancelled")
-                    break
-                except Exception as e:
-                    emit_error(f"Iteration {iteration} failed: {e}")
-                    logger.exception(f"Ralph iteration {iteration} failed")
-                    # Continue to next iteration
-                    continue
-
-                # Brief pause between iterations
-                await asyncio.sleep(1)
-
-            else:
-                # Loop completed without break (max iterations reached)
-                emit_warning(f"⚠️ Reached max iterations ({self.max_iterations})")
-
-        finally:
-            self.is_running = False
-
-        # Final status
-        prd = manager.read_prd()
-        final_progress = prd.get_progress_summary() if prd else "Unknown"
-
-        return {
-            "success": self.is_complete,
-            "iterations": self.current_iteration,
-            "message": f"Completed {self.current_iteration} iterations. {final_progress}",
-            "all_complete": self.is_complete,
-        }
-
-    def _build_iteration_prompt(self, story) -> str:
-        """Build the prompt for a single iteration."""
-        # Find VERIFY criteria
-        verify_criteria = [
-            c for c in story.acceptance_criteria if c.startswith("VERIFY:")
-        ]
-        other_criteria = [
-            c for c in story.acceptance_criteria if not c.startswith("VERIFY:")
-        ]
-
-        verify_section = ""
-        if verify_criteria:
-            verify_section = f"""
-## MANDATORY VERIFICATION COMMANDS
-You MUST run these commands and they MUST succeed before marking complete:
-{chr(10).join(f"  {c}" for c in verify_criteria)}
-
-If ANY verification fails, fix the code and re-run until it passes!
-"""
-
-        return f"""Execute ONE iteration of the Ralph loop.
-
-## Current Story
-- **ID:** {story.id}
-- **Title:** {story.title}
-- **Description:** {story.description}
-
-## Acceptance Criteria (implement ALL of these):
-{chr(10).join(f"  - {c}" for c in other_criteria)}
-{verify_section}
-## Requires UI Verification: {story.has_ui_verification()}
-{"If yes, invoke qa-kitten to verify UI changes work correctly." if story.has_ui_verification() else ""}
-
-## Your Task
-
-1. Call `ralph_read_patterns()` to get context from previous iterations
-2. Implement this ONE story completely
-3. **RUN ALL VERIFY COMMANDS** - they must pass!
-4. If checks pass, commit with: `git commit -m "feat: {story.id} - {story.title}"`
-5. Call `ralph_mark_story_complete("{story.id}", "Verified: <what you tested>")`
-6. Call `ralph_log_progress(...)` with what you learned
-7. Call `ralph_check_all_complete()` to see if we're done
-
-If ALL stories are complete, output: <promise>COMPLETE</promise>
-
-⚠️ DO NOT mark complete until verification passes! Actually run the VERIFY commands!
-"""
-
-
-# Global controller instance
-_controller: Optional[RalphLoopController] = None
-
-
-def get_loop_controller(max_iterations: int = 10) -> RalphLoopController:
-    """Get or create the loop controller."""
-    global _controller
-    if _controller is None or not _controller.is_running:
-        _controller = RalphLoopController(max_iterations)
-    return _controller
-
-
-async def run_ralph_loop(
-    max_iterations: int = 10,
-    invoke_func: Optional[Callable] = None,
-) -> dict:
-    """Convenience function to run the Ralph loop.
-
-    Args:
-        max_iterations: Maximum number of iterations
-        invoke_func: Function to invoke agents. If None, uses default.
-
-    Returns:
-        Result dict from the controller
-    """
-    if invoke_func is None:
-        # Use the default agent invocation mechanism
-        invoke_func = _default_invoke_agent
-
-    controller = get_loop_controller(max_iterations)
-    return await controller.run(invoke_func)
-
-
-async def _default_invoke_agent(
-    agent_name: str,
-    prompt: str,
-    session_id: Optional[str] = None,
-) -> dict:
-    """Default agent invocation using code_puppy's agent system."""
-    try:
-        from code_puppy.agents import get_current_agent, load_agent, set_current_agent
-
-        # Save current agent to restore later
-        original_agent = get_current_agent()
-
-        try:
-            # Load the target agent
-            target_agent = load_agent(agent_name)
-            if target_agent is None:
-                return {"response": None, "error": f"Agent '{agent_name}' not found"}
-
-            # Run the agent with the prompt
-            # Note: This creates a fresh run with no message history
-            result = await target_agent.run_with_mcp(prompt)
-
-            # Extract response text
-            response_text = ""
-            if result is not None:
-                if hasattr(result, "data"):
-                    response_text = str(result.data) if result.data else ""
-                else:
-                    response_text = str(result)
-
-            return {"response": response_text, "error": None}
-
-        finally:
-            # Restore original agent
-            if original_agent:
-                set_current_agent(original_agent.name)
-
-    except Exception as e:
-        logger.exception(f"Failed to invoke agent {agent_name}")
-        return {"response": None, "error": str(e)}

code_puppy/plugins/ralph/models.py

@@ -1,125 +0,0 @@
-"""Data models for the Ralph plugin."""
-
-import json
-from dataclasses import dataclass, field
-from datetime import datetime
-from typing import List, Optional
-
-
-@dataclass
-class UserStory:
-    """A single user story in the PRD."""
-
-    id: str
-    title: str
-    description: str
-    acceptance_criteria: List[str]
-    priority: int
-    passes: bool = False
-    notes: str = ""
-
-    def to_dict(self) -> dict:
-        return {
-            "id": self.id,
-            "title": self.title,
-            "description": self.description,
-            "acceptanceCriteria": self.acceptance_criteria,
-            "priority": self.priority,
-            "passes": self.passes,
-            "notes": self.notes,
-        }
-
-    @classmethod
-    def from_dict(cls, data: dict) -> "UserStory":
-        return cls(
-            id=data.get("id", ""),
-            title=data.get("title", ""),
-            description=data.get("description", ""),
-            acceptance_criteria=data.get("acceptanceCriteria", []),
-            priority=data.get("priority", 0),
-            passes=data.get("passes", False),
-            notes=data.get("notes", ""),
-        )
-
-    def has_ui_verification(self) -> bool:
-        """Check if this story requires browser/UI verification."""
-        ui_keywords = ["browser", "ui", "verify in browser", "qa-kitten", "visual"]
-        criteria_text = " ".join(self.acceptance_criteria).lower()
-        return any(kw in criteria_text for kw in ui_keywords)
-
-
-@dataclass
-class PRDConfig:
-    """Configuration for a PRD project."""
-
-    project: str
-    branch_name: str
-    description: str
-    user_stories: List[UserStory] = field(default_factory=list)
-
-    def to_dict(self) -> dict:
-        return {
-            "project": self.project,
-            "branchName": self.branch_name,
-            "description": self.description,
-            "userStories": [s.to_dict() for s in self.user_stories],
-        }
-
-    @classmethod
-    def from_dict(cls, data: dict) -> "PRDConfig":
-        return cls(
-            project=data.get("project", ""),
-            branch_name=data.get("branchName", ""),
-            description=data.get("description", ""),
-            user_stories=[UserStory.from_dict(s) for s in data.get("userStories", [])],
-        )
-
-    def to_json(self, indent: int = 2) -> str:
-        return json.dumps(self.to_dict(), indent=indent)
-
-    @classmethod
-    def from_json(cls, json_str: str) -> "PRDConfig":
-        return cls.from_dict(json.loads(json_str))
-
-    def get_next_story(self) -> Optional[UserStory]:
-        """Get the highest priority story that hasn't passed yet."""
-        pending = [s for s in self.user_stories if not s.passes]
-        if not pending:
-            return None
-        return min(pending, key=lambda s: s.priority)
-
-    def all_complete(self) -> bool:
-        """Check if all stories have passed."""
-        return all(s.passes for s in self.user_stories)
-
-    def get_progress_summary(self) -> str:
-        """Get a summary of progress."""
-        total = len(self.user_stories)
-        done = sum(1 for s in self.user_stories if s.passes)
-        return f"{done}/{total} stories complete"
-
-
-@dataclass
-class ProgressEntry:
-    """An entry in the progress log."""
-
-    timestamp: datetime
-    story_id: str
-    summary: str
-    files_changed: List[str] = field(default_factory=list)
-    learnings: List[str] = field(default_factory=list)
-
-    def to_markdown(self) -> str:
-        """Convert to markdown format for progress.txt."""
-        lines = [
-            f"## {self.timestamp.strftime('%Y-%m-%d %H:%M')} - {self.story_id}",
-            f"- {self.summary}",
-        ]
-        if self.files_changed:
-            lines.append(f"- Files changed: {', '.join(self.files_changed)}")
-        if self.learnings:
-            lines.append("- **Learnings for future iterations:**")
-            for learning in self.learnings:
-                lines.append(f"  - {learning}")
-        lines.append("---")
-        return "\n".join(lines)