diagram-to-iac 1.0.2__py3-none-any.whl → 1.0.4__py3-none-any.whl

diagram_to_iac/actions/supervisor_entry.py

@@ -4,13 +4,22 @@ import argparse
 import json
 import sys
 import logging
+import os
 from datetime import datetime
 from pathlib import Path
+from typing import Optional
 
 from diagram_to_iac.agents.supervisor_langgraph import (
     SupervisorAgent,
     SupervisorAgentInput,
 )
+from diagram_to_iac.agents.supervisor_langgraph.github_listener import (
+    GitHubListener,
+    RetryContext,
+    CommentEvent,
+    create_github_listener
+)
+from diagram_to_iac.core.registry import RunRegistry, RunStatus
 from diagram_to_iac.services import get_log_path, generate_step_summary, reset_log_bus
 
 
@@ -34,6 +43,16 @@ def create_argument_parser() -> argparse.ArgumentParser:
     parser.add_argument("--verbose", action="store_true", help="Enable verbose logging")
     parser.add_argument("--no-interactive", action="store_true", help="Skip interactive prompts")
     parser.add_argument("--dry-run", action="store_true", help="Print issue text instead of creating it")
+    
+    # Comment listener options
+    parser.add_argument("--listen-comments", action="store_true", 
+                       help="Enable GitHub comment listening for retry commands")
+    parser.add_argument("--issue-id", type=int, help="Issue ID to monitor for comments")
+    parser.add_argument("--poll-interval", type=int, default=30, 
+                       help="Comment polling interval in seconds (default: 30)")
+    parser.add_argument("--max-polls", type=int, 
+                       help="Maximum number of polls (default: infinite)")
+    
     return parser
 
 
@@ -56,13 +75,158 @@ def format_output(result: object) -> str:
         return str(result)
 
 
+def handle_resume_workflow(context: RetryContext) -> bool:
+    """
+    Handle resuming an existing workflow.
+    
+    Args:
+        context: RetryContext with resumption information
+        
+    Returns:
+        True if resumption was successful, False otherwise
+    """
+    logger = logging.getLogger("supervisor_entry")
+    
+    if not context.existing_run:
+        logger.error("No existing run to resume")
+        return False
+    
+    try:
+        logger.info(f"Resuming run {context.existing_run.run_key}")
+        
+        # Initialize registry and SupervisorAgent
+        registry = RunRegistry()
+        agent = SupervisorAgent(registry=registry)
+        
+        # Update run status to clear wait reason if PAT is now available
+        pat_available = os.getenv('TFE_TOKEN') is not None
+        if pat_available and context.existing_run.status == RunStatus.WAITING_FOR_PAT:
+            logger.info("PAT token now available, clearing wait reason")
+            registry.update(context.existing_run.run_key, {
+                'status': RunStatus.IN_PROGRESS,
+                'wait_reason': None
+            })
+        
+        # Resume the workflow from where it left off
+        reset_log_bus()
+        result = agent.resume_workflow(
+            context.existing_run.run_key,
+            context.target_sha or context.existing_run.commit_sha
+        )
+        
+        logger.info(f"Resume workflow result: {result.success}")
+        return result.success
+        
+    except Exception as e:
+        logger.error(f"Error resuming workflow: {e}")
+        return False
+
+
+def handle_new_workflow(context: RetryContext) -> bool:
+    """
+    Handle starting a new workflow for manual retry requests.
+    
+    Args:
+        context: RetryContext with new workflow information
+        
+    Returns:
+        True if new workflow was started successfully, False otherwise
+    """
+    logger = logging.getLogger("supervisor_entry")
+    
+    try:
+        logger.info(f"Starting new workflow for SHA {context.target_sha[:7] if context.target_sha else 'unknown'}")
+        
+        # Initialize SupervisorAgent
+        agent = SupervisorAgent()
+        
+        # Start new workflow
+        reset_log_bus()
+        result = agent.run(SupervisorAgentInput(
+            repo_url=context.comment_event.repo_url,
+            branch_name="main",  # Placeholder - supervisor handles this
+            thread_id=f"retry-{context.comment_event.comment_id}",
+            commit_sha=context.target_sha
+        ))
+        
+        logger.info(f"New workflow result: {result.success}")
+        return result.success
+        
+    except Exception as e:
+        logger.error(f"Error starting new workflow: {e}")
+        return False
+
+
+def start_comment_listener(repo_url: str, issue_id: int, poll_interval: int = 30, 
+                          max_polls: Optional[int] = None) -> None:
+    """
+    Start the GitHub comment listener.
+    
+    Args:
+        repo_url: Repository URL to monitor
+        issue_id: Issue ID to monitor for comments
+        poll_interval: Seconds between polls
+        max_polls: Maximum number of polls
+    """
+    logger = logging.getLogger("supervisor_entry")
+    
+    try:
+        # Create GitHub listener with callbacks
+        github_token = os.getenv('GITHUB_TOKEN')
+        registry = RunRegistry()
+        listener = create_github_listener(github_token=github_token, registry=registry)
+        
+        # Set up callbacks
+        listener.set_callbacks(
+            resume_callback=handle_resume_workflow,
+            new_run_callback=handle_new_workflow
+        )
+        
+        logger.info(f"Starting comment listener for issue #{issue_id} in {repo_url}")
+        logger.info(f"Poll interval: {poll_interval}s, Max polls: {max_polls or 'infinite'}")
+        
+        # Start polling
+        listener.poll_issue_comments(
+            issue_id=issue_id,
+            repo_url=repo_url,
+            poll_interval=poll_interval,
+            max_polls=max_polls
+        )
+        
+    except Exception as e:
+        logger.error(f"Error in comment listener: {e}")
+        raise
+
+
 def main() -> int:
     parser = create_argument_parser()
     args = parser.parse_args()
 
     setup_logging(args.verbose)
 
-    # Handle repo url
+    # Handle comment listening mode
+    if args.listen_comments:
+        if not args.repo_url:
+            parser.error("--repo-url is required when using --listen-comments")
+        if not args.issue_id:
+            parser.error("--issue-id is required when using --listen-comments")
+        
+        try:
+            start_comment_listener(
+                repo_url=args.repo_url,
+                issue_id=args.issue_id,
+                poll_interval=args.poll_interval,
+                max_polls=args.max_polls
+            )
+            return 0
+        except KeyboardInterrupt:
+            print("\n⚠️  Comment listener stopped by user")
+            return 0
+        except Exception as e:
+            logging.error(f"Comment listener failed: {e}")
+            return 1
+
+    # Handle normal workflow mode
     repo_url = args.repo_url
     if not repo_url and not args.no_interactive:
         repo_url = prompt_for_repo_url()
@@ -75,7 +239,6 @@ def main() -> int:
 
     agent = SupervisorAgent()
 
-
     while True:
         reset_log_bus()
         result = agent.run(
@@ -85,7 +248,6 @@ def main() -> int:
                 thread_id=args.thread_id,
                 dry_run=args.dry_run,
             )
-
         )
 
         print(format_output(result))

diagram_to_iac/agents/git_langgraph/agent.py

@@ -69,17 +69,15 @@ class GitAgentInput(BaseModel):
 
 class GitAgentOutput(BaseModel):
     """Output schema for GitAgent operations."""
-    result: str = Field(..., description="The result of the DevOps operation")
-    thread_id: str = Field(..., description="Thread ID used for the conversation")
-    repo_path: Optional[str] = Field(None, description="Repository path for clone operations")
-    error_message: Optional[str] = Field(None, description="Error message if the operation failed")
-    operation_type: Optional[str] = Field(None, description="Type of operation performed (clone, issue, shell)")
-    pr_url: Optional[str] = Field(None, description="URL of the created pull request, if any.")
+    success: bool = Field(..., description="Indicates if the operation was successful")
+    created_pr_id: Optional[int] = Field(None, description="ID of the created pull request, if any")
+    pr_url: Optional[str] = Field(None, description="URL of the created pull request, if any")
+    created_issue_id: Optional[int] = Field(None, description="ID of the created issue, if any")
+    issue_url: Optional[str] = Field(None, description="URL of the created issue, if any")
+    summary: Optional[str] = Field(None, description="Summary of the operation result")
+    artifacts: Optional[Dict[str, Any]] = Field(None, description="Optional artifacts returned by the operation")
 
-    @property
-    def answer(self) -> str:
-        """Alias for result to match learning guide tests."""
-        return self.result
+    model_config = {"extra": "ignore"}
 
 
 # --- Agent State Definition ---
@@ -848,7 +846,7 @@ Important: Only use routing tokens if the input contains actionable DevOps reque
             return "open_issue"
         elif final_result in ["route_to_shell", "ROUTE_TO_SHELL"]:
             return "shell_exec"
-        elif final_result == self.config['routing_keys']['create_pr']:
+        elif final_result in ["route_to_create_pr", "ROUTE_TO_CREATE_PR"]:
             return "create_pr_node"
         elif final_result in ["route_to_end", "ROUTE_TO_END"]:
             return END
@@ -959,13 +957,37 @@ Important: Only use routing tokens if the input contains actionable DevOps reque
                 result=final_result,
             )
             
+            # Determine success based on whether there was an error
+            success = error_message is None or error_message == ""
+            
+            # Extract PR/Issue IDs from URLs if available
+            created_pr_id = None
+            created_issue_id = None
+            if pr_url:
+                # Extract PR ID from GitHub URL pattern
+                import re
+                pr_match = re.search(r'/pull/(\d+)', pr_url)
+                if pr_match:
+                    created_pr_id = int(pr_match.group(1))
+                else:
+                    # Check if it's an issue URL
+                    issue_match = re.search(r'/issues/(\d+)', pr_url)
+                    if issue_match:
+                        created_issue_id = int(issue_match.group(1))
+            
             output = GitAgentOutput(
-                result=final_result,
-                thread_id=current_thread_id,
-                repo_path=repo_path,
-                error_message=error_message,
-                operation_type=operation_type,
-                pr_url=pr_url
+                success=success,
+                created_pr_id=created_pr_id,
+                pr_url=pr_url if created_pr_id else None,
+                created_issue_id=created_issue_id,
+                issue_url=pr_url if created_issue_id else None,
+                summary=final_result,
+                artifacts={
+                    "thread_id": current_thread_id,
+                    "repo_path": repo_path,
+                    "operation_type": operation_type,
+                    "error_message": error_message
+                }
             )
             return output
             
@@ -977,12 +999,18 @@ Important: Only use routing tokens if the input contains actionable DevOps reque
                 error=str(e),
             )
             return GitAgentOutput(
-                result="An unexpected error occurred during execution.",
-                thread_id=current_thread_id,
-                repo_path=None, # Or more specifically result_state.get("repo_path") if available
-                error_message=str(e),
-                operation_type="error",
-                pr_url=None
+                success=False,
+                created_pr_id=None,
+                pr_url=None,
+                created_issue_id=None,
+                issue_url=None,
+                summary="An unexpected error occurred during execution.",
+                artifacts={
+                    "thread_id": current_thread_id,
+                    "repo_path": None,  # Or more specifically result_state.get("repo_path") if available
+                    "operation_type": "error",
+                    "error_message": str(e)
+                }
             )
     
     def get_conversation_history(self) -> List[Dict[str, Any]]:
@@ -1042,11 +1070,15 @@ Important: Only use routing tokens if the input contains actionable DevOps reque
         if isinstance(result, GitAgentOutput):
             report = {
                 "status": "completed",
-                "result": result.result,
-                "thread_id": result.thread_id,
-                "error": result.error_message,
-                "operation_type": result.operation_type,
-                "success": result.error_message is None
+                "result": result.summary,
+                "thread_id": result.artifacts.get("thread_id") if result.artifacts else None,
+                "error": result.artifacts.get("error_message") if result.artifacts else None,
+                "operation_type": result.artifacts.get("operation_type") if result.artifacts else None,
+                "success": result.success,
+                "pr_url": result.pr_url,
+                "issue_url": result.issue_url,
+                "created_pr_id": result.created_pr_id,
+                "created_issue_id": result.created_issue_id
             }
         elif isinstance(result, str):
             report = {