cafe-engine 0.1.2__tar.gz → 0.1.4__tar.gz

{cafe_engine-0.1.2 → cafe_engine-0.1.4}/CHANGELOG.md

@@ -2,6 +2,17 @@
 
 All notable changes to this project will be documented in this file.
 
+## [0.1.3]
+
+### Added
+- Added `--post-todo-list` option to `cafe pr` command to post PR comment todo list as GitHub PR comment
+- Added `--post-pr-todo-list` option to `cafe prepare` command to set post-PR-todo-list mode for prepare phase
+- Added token usage summary display after PR comment organization completes
+
+### Fixed
+- Fixed copilot session_id detection to recognize both file-based (.jsonl) and directory-based session formats
+- Fixed `_print_token_usage_summary` to gracefully handle mocked agent_manager in tests
+
 ## [0.1.2]
 
 ### Fixed

{cafe_engine-0.1.2 → cafe_engine-0.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cafe-engine
-Version: 0.1.2
+Version: 0.1.4
 Summary: CLI Agent Flow Engine - Automated development workflow with AI agents
 License-File: LICENSE
 Requires-Python: >=3.10
@@ -82,9 +82,35 @@ CAFE supports `git worktree`, enabling parallel development across multiple issu
 
 ### Flexible Integration with CLI Agent Tools
 
-CAFE integrates with multiple CLI-based AI agents (e.g., Claude Code, Cursor CLI).  
+CAFE integrates with multiple CLI-based AI agents (e.g., Claude Code, Cursor CLI).
 Different agents and models can be assigned per role, allowing you to balance cost, performance, and reasoning depth.
 
+### Automatic Backup Agent Switching on Rate Limits
+
+When a primary agent hits an API rate limit, CAFE automatically switches to backup agents in configured order—without stopping the workflow. If the backup agent also hits a rate limit, CAFE continues to the next backup until one succeeds or all are exhausted.
+
+You can configure backup agents and their per-phase models in `.cafe/config.yaml`:
+
+```yaml
+agents:
+  developer:
+    name: David
+    cli: claude                    # Primary CLI agent
+    backup:                        # Backup agents (tried in order on rate limit)
+      - gemini
+      - copilot
+    models:                        # Per-CLI, per-phase model configuration
+      claude:
+        plan: opus
+        develop: sonnet
+      gemini:
+        plan: gemini-2.5-pro-preview
+        develop: gemini-2-flash-preview
+      copilot: {}                  # Use CLI default model
+```
+
+If all agents (primary + backups) are exhausted, the workflow stops with a clear error message listing which agents were tried. You can add more backup agents with `cafe config edit`.
+
 ---
 
 ### GitHub-Native Workflow

{cafe_engine-0.1.2 → cafe_engine-0.1.4}/README.md

@@ -58,9 +58,35 @@ CAFE supports `git worktree`, enabling parallel development across multiple issu
 
 ### Flexible Integration with CLI Agent Tools
 
-CAFE integrates with multiple CLI-based AI agents (e.g., Claude Code, Cursor CLI).  
+CAFE integrates with multiple CLI-based AI agents (e.g., Claude Code, Cursor CLI).
 Different agents and models can be assigned per role, allowing you to balance cost, performance, and reasoning depth.
 
+### Automatic Backup Agent Switching on Rate Limits
+
+When a primary agent hits an API rate limit, CAFE automatically switches to backup agents in configured order—without stopping the workflow. If the backup agent also hits a rate limit, CAFE continues to the next backup until one succeeds or all are exhausted.
+
+You can configure backup agents and their per-phase models in `.cafe/config.yaml`:
+
+```yaml
+agents:
+  developer:
+    name: David
+    cli: claude                    # Primary CLI agent
+    backup:                        # Backup agents (tried in order on rate limit)
+      - gemini
+      - copilot
+    models:                        # Per-CLI, per-phase model configuration
+      claude:
+        plan: opus
+        develop: sonnet
+      gemini:
+        plan: gemini-2.5-pro-preview
+        develop: gemini-2-flash-preview
+      copilot: {}                  # Use CLI default model
+```
+
+If all agents (primary + backups) are exhausted, the workflow stops with a clear error message listing which agents were tried. You can add more backup agents with `cafe config edit`.
+
 ---
 
 ### GitHub-Native Workflow

{cafe_engine-0.1.2 → cafe_engine-0.1.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "cafe-engine"
-version = "0.1.2"
+version = "0.1.4"
 description = "CLI Agent Flow Engine - Automated development workflow with AI agents"
 readme = "README.md"
 requires-python = ">=3.10"

{cafe_engine-0.1.2 → cafe_engine-0.1.4}/src/cafe/agents/cli/copilot.py

@@ -97,13 +97,15 @@ class CopilotCLI(AbstractCLI):
         #          claude-sonnet-4.5    14.3k input, 39 output, 10.2k cache read (Est. 1 Premium request)
         # New: Breakdown by AI model:
         #       claude-sonnet-4.5       16.0k in, 74 out, 0 cached (Est. 1 Premium request)
+        #       claude-sonnet-4.5       1.2m in, 4.6k out, 1.1m cached (Est. 1 Premium request)
+        # Token counts can have k (thousands) or m (millions) suffix
 
         # Try new format first
-        usage_match = re.search(r'Breakdown by AI model:\s*\n\s+([\w.-]+)\s+([\d.]+k?)\s+in,\s+([\d.]+k?)\s+out(?:,\s+([\d.]+k?)\s+cached)?', full_output)
+        usage_match = re.search(r'Breakdown by AI model:\s*\n\s+([\w.-]+)\s+([\d.]+[km]?)\s+in,\s+([\d.]+[km]?)\s+out(?:,\s+([\d.]+[km]?)\s+cached)?', full_output)
 
         # Fall back to old format if new format not found
         if not usage_match:
-            usage_match = re.search(r'Usage by model:\s*\n\s+([\w.-]+)\s+([\d.]+k?)\s+input,\s+([\d.]+k?)\s+output(?:,\s+([\d.]+k?)\s+cache read)?', full_output)
+            usage_match = re.search(r'Usage by model:\s*\n\s+([\w.-]+)\s+([\d.]+[km]?)\s+input,\s+([\d.]+[km]?)\s+output(?:,\s+([\d.]+[km]?)\s+cache read)?', full_output)
         
         if usage_match:
             # Extract model name
@@ -147,17 +149,19 @@ class CopilotCLI(AbstractCLI):
         return response, token_usage, permission_denials, model
 
     def _parse_token_count(self, token_str: str) -> int:
-        """Parse token count string (e.g., '14.3k' or '39') to integer.
-        
+        """Parse token count string (e.g., '14.3k', '1.2m', or '39') to integer.
+
         Args:
-            token_str: Token count string
-            
+            token_str: Token count string with optional k (thousands) or m (millions) suffix
+
         Returns:
             Token count as integer
         """
         token_str = token_str.strip()
-        if token_str.endswith('k'):
-            # Convert 'k' notation to thousands
+        if token_str.endswith('m'):
+            number = float(token_str[:-1])
+            return int(number * 1_000_000)
+        elif token_str.endswith('k'):
             number = float(token_str[:-1])
             return int(number * 1000)
         else:
@@ -221,7 +225,7 @@ class CopilotCLI(AbstractCLI):
 
         if copilot_session_dir.exists():
             self._existing_sessions = {
-                f.name for f in copilot_session_dir.iterdir() if f.is_file()
+                f.name for f in copilot_session_dir.iterdir() if f.is_file() or f.is_dir()
             }
         else:
             self._existing_sessions = set()
@@ -229,7 +233,7 @@ class CopilotCLI(AbstractCLI):
     def extract_session_id(self, output_lines: List[str]) -> Optional[str]:
         """Extract newly created session ID from file system.
 
-        Copilot automatically creates session files, need to detect from file system.
+        Copilot automatically creates session directories, need to detect from file system.
 
         Args:
             output_lines: List of lines from CLI output (not used here)
@@ -245,9 +249,9 @@ class CopilotCLI(AbstractCLI):
         # Wait for file system to update
         time.sleep(0.1)
 
-        # Get current session files
+        # Get current session files and directories
         current_sessions = {
-            f.name for f in copilot_session_dir.iterdir() if f.is_file()
+            f.name for f in copilot_session_dir.iterdir() if f.is_file() or f.is_dir()
         }
 
         # Find newly created sessions
@@ -256,7 +260,7 @@ class CopilotCLI(AbstractCLI):
         if new_sessions:
             # Get newest session (sorted by name)
             newest_session = sorted(new_sessions)[-1]
-            # Remove .jsonl extension
+            # Remove .jsonl extension if present (for file-based sessions)
             session_id = newest_session.replace(".jsonl", "")
             return session_id
 

{cafe_engine-0.1.2 → cafe_engine-0.1.4}/src/cafe/agents/executor.py

@@ -820,6 +820,21 @@ class AgentExecutor:
                 err.cli_command_args = cmd[1:]
                 raise err
 
+        # Append stderr to streaming output file (for debugging token usage parsing)
+        if streaming_file_handle and stderr_output:
+            try:
+                from datetime import datetime
+                stderr_obj = {
+                    "index": streaming_line_index,
+                    "timestamp": datetime.now().astimezone().isoformat(),
+                    "type": "stderr",
+                    "content": stderr_output.rstrip('\n'),
+                }
+                streaming_file_handle.write(json.dumps(stderr_obj, ensure_ascii=False) + "\n")
+                streaming_file_handle.flush()
+            except Exception as e:
+                print(f"⚠️  Failed to write stderr to streaming output file: {e}")
+
         # Close streaming output file
         if streaming_file_handle:
             try:
@@ -886,5 +901,5 @@ class AgentExecutor:
             token_usage=token_usage,
             permission_denials=permission_denials,
             streaming_log=final_streaming_log,
-            model=model
+            model=model,
         )

{cafe_engine-0.1.2 → cafe_engine-0.1.4}/src/cafe/agents/manager.py

@@ -7,7 +7,7 @@ from typing import Any, Dict, List, Optional, Tuple
 
 from cafe.agents.executor import AgentExecutor, AgentExecutionError
 from cafe.core.session import SessionManager
-from cafe.core.types import AgentConfig, PermissionDenial, TokenUsage
+from cafe.core.types import AgentConfig, AgentResponse, PermissionDenial, TokenUsage
 
 
 class AgentNotFoundError(Exception):
@@ -63,12 +63,14 @@ class AgentManager:
         session_id = session_data.session_id if session_data else None
         # Note: Don't create session here - let executor handle it on first use
 
-        # Update config with session ID (may be None)
+        # Update config with session ID (may be None), preserve backup and models config
         config_with_session = AgentConfig(
             name=config.name,
             cli=config.cli,
             session_id=session_id,
             model=config.model,
+            backup_clis=config.backup_clis,
+            models_config=config.models_config,
         )
 
         # Create executor
@@ -120,7 +122,8 @@ class AgentManager:
         prompt: str,
         allowed_tools: Optional[List[str]] = None,
         allowed_directories: Optional[List[str]] = None,
-        streaming_output_file: Optional[str] = None
+        streaming_output_file: Optional[str] = None,
+        phase_name: Optional[str] = None,
     ) -> Tuple[str, TokenUsage, List, Optional[List[str]], List[str], Optional[str]]:
         """Execute prompt with specified agent.
 
@@ -130,12 +133,14 @@ class AgentManager:
             allowed_tools: List of allowed tools (using Claude naming convention)
             allowed_directories: List of allowed directories
             streaming_output_file: Optional file path to write streaming output line-by-line
+            phase_name: Current phase name for phase-specific model lookup in backup agents
 
         Returns:
             Tuple of (agent's response, token usage, permission denials, cli_command_args, streaming_log, model)
 
         Raises:
             AgentNotFoundError: If agent not found
+            AgentExecutionError: If all agents (primary + backups) fail
         """
         executor = self.get_agent(agent_name)
 
@@ -163,6 +168,18 @@ class AgentManager:
                     executor.config.session_id = None
 
                     # Loop will retry (with no session ID, a new one will be created)
+                elif hasattr(e, 'error_type') and e.error_type in ("rate_limit", "cli_not_found"):
+                    # Try backup agents
+                    agent_response = self._try_backup_agents(
+                        primary_error=e,
+                        primary_executor=executor,
+                        prompt=prompt,
+                        allowed_tools=allowed_tools,
+                        allowed_directories=allowed_directories,
+                        streaming_output_file=streaming_output_file,
+                        phase_name=phase_name,
+                    )
+                    break  # Backup succeeded, exit loop
                 else:
                     # Not a session conflict, or already retried - re-raise
                     raise
@@ -206,6 +223,109 @@ class AgentManager:
 
         return response, token_usage, permission_denials, cli_command_args, streaming_log, model
 
+    def _try_backup_agents(
+        self,
+        primary_error: "AgentExecutionError",
+        primary_executor: AgentExecutor,
+        prompt: str,
+        allowed_tools: Optional[List[str]] = None,
+        allowed_directories: Optional[List[str]] = None,
+        streaming_output_file: Optional[str] = None,
+        phase_name: Optional[str] = None,
+    ) -> "AgentResponse":
+        """Try backup agents in order until one succeeds or all fail.
+
+        Backup retry flow:
+        1. If no backup CLIs are configured, re-raise the original error immediately
+        2. Try each backup CLI in backup_clis in order
+        3. If a backup CLI also hits rate_limit or cli_not_found, continue to the next
+        4. If a backup CLI raises any other error, re-raise it immediately (do not continue)
+        5. If all backups fail, raise an error listing all attempted CLIs
+
+        phase_name is used to look up the model for the backup CLI from models_config,
+        e.g. during the "develop" phase with gemini backup: models_config["gemini"]["develop"].
+
+        Args:
+            primary_error: Error raised by the primary agent
+            primary_executor: Primary agent executor
+            prompt: Prompt to execute
+            allowed_tools: List of allowed tools
+            allowed_directories: List of allowed directories
+            streaming_output_file: File path for streaming output
+            phase_name: Current phase name, used to look up model configuration
+
+        Returns:
+            AgentResponse: Response from the first successful backup agent
+
+        Raises:
+            AgentExecutionError: Raised when all agents (primary + backups) fail
+        """
+        config = primary_executor.config
+        backup_clis = config.backup_clis
+        models_config = config.models_config
+
+        if not backup_clis:
+            # No backup agents configured, re-raise the original error
+            raise primary_error
+
+        primary_cli_name = config.cli.value
+        print(f"❌ {primary_cli_name} API rate limit reached, trying backup agent...")
+
+        # Track tried CLIs to avoid duplicates (primary CLI is included from the start)
+        tried_clis = {config.cli}
+        failed_agents: List[str] = [f"{primary_cli_name} ({primary_error})"]
+
+        for backup_cli in backup_clis:
+            # Skip CLIs already tried (e.g. backup_clis contains the same CLI as primary)
+            if backup_cli in tried_clis:
+                continue
+            tried_clis.add(backup_cli)
+
+            # Look up the model for this backup CLI in the current phase
+            # e.g. models_config = {"gemini": {"develop": "gemini-2-flash-preview"}}
+            # If not configured or empty string, use None (CLI default model)
+            backup_model: Optional[str] = None
+            if phase_name and models_config:
+                backup_model = models_config.get(backup_cli.value, {}).get(phase_name) or None
+
+            # Treat empty string as None
+            if backup_model == "":
+                backup_model = None
+
+            print(f"Trying {backup_cli.value}...")
+
+            # Create a new executor for the backup CLI (fresh session to avoid session contamination)
+            backup_config = AgentConfig(
+                name=config.name,
+                cli=backup_cli,
+                model=backup_model,
+            )
+            backup_executor = AgentExecutor(backup_config)
+
+            try:
+                agent_response = backup_executor.execute(
+                    prompt, allowed_tools, allowed_directories, streaming_output_file
+                )
+                print(f"✅ Successfully completed with {backup_cli.value}")
+                return agent_response
+            except AgentExecutionError as backup_error:
+                if hasattr(backup_error, 'error_type') and backup_error.error_type in ("rate_limit", "cli_not_found"):
+                    # rate_limit or cli_not_found: record and continue to next backup
+                    failed_agents.append(f"{backup_cli.value} ({backup_error})")
+                    print(f"❌ {backup_cli.value} also hit rate limit, trying next agent...")
+                    continue
+                else:
+                    # Other errors (e.g. invalid prompt format): re-raise immediately
+                    raise
+
+        # All agents (primary + all backups) failed, compose error message
+        tried_list = ", ".join(failed_agents)
+        raise AgentExecutionError(
+            f"All agents failed. Tried: {tried_list}. "
+            f"Please wait for rate limits to reset or add more backup agents.",
+            error_type="rate_limit",
+        )
+
     def execute_current(self, prompt: str) -> str:
         """Execute prompt with current agent.
 

{cafe_engine-0.1.2 → cafe_engine-0.1.4}/src/cafe/core/phase.py

@@ -848,6 +848,72 @@ class Phase(ABC):
 
         return prompt_multiline("Please answer the question")
 
+    def _validate_and_retry_questions_xml(
+        self,
+        xml_path: Path,
+        agent_name: str,
+        allowed_tools: List[str],
+        max_retries: int = 3,
+    ) -> bool:
+        """Validate questions.xml and retry with agent if invalid.
+
+        Args:
+            xml_path: Path to questions.xml file
+            agent_name: Agent name for retry execution
+            allowed_tools: Tools allowed for agent
+            max_retries: Maximum number of retry attempts (default: 3)
+
+        Returns:
+            True if XML is valid (or was fixed), False otherwise
+        """
+        from cafe.core.questions_schema import validate_questions_xml
+
+        # Require agent_manager attribute
+        if not hasattr(self, 'agent_manager'):
+            raise AttributeError("Phase must have 'agent_manager' attribute to validate questions XML")
+
+        # Check if file exists
+        if not xml_path.exists():
+            return False
+
+        # First validation attempt
+        if validate_questions_xml(xml_path):
+            return True
+
+        # Retry loop: ask agent to fix invalid XML
+        for retry in range(max_retries):
+            print(f"\n⚠️  questions.xml format is invalid, asking agent to fix... (attempt {retry + 1}/{max_retries})")
+
+            retry_prompt = (
+                f"The questions XML file at {xml_path} has invalid format. "
+                f"Please fix it so that:\n"
+                f"- Root element is <questions>\n"
+                f"- Each <question> has a unique id attribute, a <title>, and <options> with at least one <option>\n"
+                f"- The file is well-formed XML\n\n"
+                f"Read the file, fix the issues, and write the corrected XML back to {xml_path}."
+            )
+
+            try:
+                self.agent_manager.execute(
+                    agent_name,
+                    retry_prompt,
+                    allowed_tools=allowed_tools,
+                )
+            except Exception as e:
+                print(f"⚠️  Error during XML fix retry: {e}")
+                continue
+
+            # Check if fixed
+            if xml_path.exists() and validate_questions_xml(xml_path):
+                print(f"✓ Agent successfully fixed questions.xml")
+                return True
+
+        # All retries failed - delete invalid file and fallback
+        print(f"\n❌ questions.xml still invalid after {max_retries} attempts, falling back to original Q&A")
+        if xml_path.exists():
+            xml_path.unlink()
+        return False
+
     def _process_review_decision(
         self,
         choice: str,
@@ -1136,8 +1202,15 @@ class Phase(ABC):
         if not hasattr(self, "agent_manager"):
             return
 
-        token_usage = self.agent_manager.get_total_token_usage()
-        model = self.agent_manager.get_last_model()
+        try:
+            token_usage = self.agent_manager.get_total_token_usage()
+            model = self.agent_manager.get_last_model()
+
+            # Verify we have real token usage data (not mocks)
+            if not isinstance(token_usage.input_tokens, int):
+                return
+        except (AttributeError, TypeError):
+            return
 
         print()
         print("=" * 60)

{cafe_engine-0.1.2 → cafe_engine-0.1.4}/src/cafe/core/status_codes.py

@@ -28,7 +28,7 @@ class PhaseStatusCode(str, Enum):
 
     # ========== Develop Phase ==========
     NO_CHANGES_NEEDED = "CAFE_NO_CHANGES_NEEDED"  # Developer believes no changes needed (dispute reviewer)
-    SKIP_REVIEW = "CAFE_SKIP_REVIEW"              # User agreed with developer, skip review phase
+    CONFIRMED_SKIP_REVIEW = "CAFE_CONFIRMED_SKIP_REVIEW"  # User confirmed to skip review phase (development completed)
 
     # ========== Authorization ==========
     NEED_PERMISSION = "CAFE_NEED_PERMISSION"       # Need user permission
@@ -130,9 +130,22 @@ class StatusCodeParser:
         response_upper = response.upper()
 
         # Search for all status codes in the response
-        codes_to_check = valid_codes if valid_codes else list(PhaseStatusCode)
+        # Sort by length descending so longer (more specific) codes are checked first
+        codes_to_check = sorted(
+            valid_codes if valid_codes else list(PhaseStatusCode),
+            key=lambda x: len(x.value),
+            reverse=True,
+        )
         for code in codes_to_check:
             if code.value in response_upper:
+                # Skip if this code is a prefix of an already-found longer code
+                if any(found.value.startswith(code.value) for found in found_codes):
+                    continue
+                # Remove any already-found codes that are prefixes of this code
+                found_codes = {
+                    found for found in found_codes
+                    if not code.value.startswith(found.value)
+                }
                 found_codes.add(code)
 
         return found_codes

{cafe_engine-0.1.2 → cafe_engine-0.1.4}/src/cafe/core/types.py

@@ -56,12 +56,36 @@ class PermissionAction(str, Enum):
 
 
 class AgentConfig(BaseModel):
-    """Configuration for an AI agent."""
+    """Configuration for an AI agent.
+
+    backup_clis and models_config support automatic backup agent switching.
+    When the primary CLI hits a rate limit, AgentManager tries each backup CLI in order.
+
+    Example config.yaml::
+
+        agents:
+          developer:
+            name: David
+            cli: claude                    # Primary CLI
+            backup:                        # Backup CLIs (tried in order)
+              - gemini
+              - copilot
+            models:                        # Per-CLI per-phase model configuration
+              claude:
+                plan: opus
+                develop: sonnet
+              gemini:
+                plan: gemini-2.5-pro-preview
+                develop: gemini-2-flash-preview
+              copilot: {}                  # Use CLI default model
+    """
 
     name: str
     cli: AgentCLI
     session_id: Optional[str] = None
     model: Optional[str] = None  # Optional model name for CLI (e.g., "sonnet", "opus")
+    backup_clis: List["AgentCLI"] = Field(default_factory=list)  # Ordered list of backup CLIs
+    models_config: Dict[str, Dict[str, str]] = Field(default_factory=dict)  # Per-CLI per-phase model configuration
 
 
 class TokenUsage(BaseModel):