diagram-to-iac 1.0.3__tar.gz → 1.0.4__tar.gz

{diagram_to_iac-1.0.3 → diagram_to_iac-1.0.4}/PKG-INFO

@@ -1,21 +1,22 @@
 Metadata-Version: 2.4
 Name: diagram-to-iac
-Version: 1.0.3
+Version: 1.0.4
 Summary: Convert architecture diagrams into IaC modules
 Author-email: vindpro <admin@vindpro.com>
 Description-Content-Type: text/markdown
-Requires-Dist: anthropic==0.54.0
+Requires-Dist: anthropic==0.55.0
 Requires-Dist: google_api_python_client==2.173.0
 Requires-Dist: langchain_anthropic==0.3.15
 Requires-Dist: langchain-core<1.0.0,>=0.3.62
 Requires-Dist: langchain_google_genai==2.1.5
-Requires-Dist: langchain_openai==0.3.24
+Requires-Dist: langchain_openai==0.3.25
 Requires-Dist: langgraph==0.4.8
-Requires-Dist: openai==1.90.0
+Requires-Dist: openai==1.91.0
 Requires-Dist: protobuf>=5.27.0
 Requires-Dist: pydantic==2.11.7
 Requires-Dist: PyYAML==6.0.2
 Requires-Dist: Requests==2.32.4
+Requires-Dist: typing_extensions==4.14.0
 Requires-Dist: GitPython<4.0,>=3.1
 
 # diagram-to-iac

{diagram_to_iac-1.0.3 → diagram_to_iac-1.0.4}/pyproject.toml

@@ -4,11 +4,11 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name        = "diagram-to-iac"
-version     = "1.0.3"
+version     = "1.0.4"
 description = "Convert architecture diagrams into IaC modules"
 readme      = "README.md"
 authors     = [{ name="vindpro", email="admin@vindpro.com" }]
-dependencies = ["anthropic==0.54.0", "google_api_python_client==2.173.0", "langchain_anthropic==0.3.15", "langchain-core>=0.3.62,<1.0.0", "langchain_google_genai==2.1.5", "langchain_openai==0.3.24", "langgraph==0.4.8", "openai==1.90.0", "protobuf>=5.27.0", "pydantic==2.11.7", "PyYAML==6.0.2", "Requests==2.32.4", "GitPython>=3.1,<4.0"]   # ← always overwritten by update_deps.py
+dependencies = ["anthropic==0.55.0", "google_api_python_client==2.173.0", "langchain_anthropic==0.3.15", "langchain-core>=0.3.62,<1.0.0", "langchain_google_genai==2.1.5", "langchain_openai==0.3.25", "langgraph==0.4.8", "openai==1.91.0", "protobuf>=5.27.0", "pydantic==2.11.7", "PyYAML==6.0.2", "Requests==2.32.4", "typing_extensions==4.14.0", "GitPython>=3.1,<4.0"]   # ← always overwritten by update_deps.py
 
 
 

diagram_to_iac-1.0.4/src/diagram_to_iac/actions/supervisor_entry.py

@@ -0,0 +1,278 @@
+"""CLI entrypoint for SupervisorAgent."""
+
+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
+
+
+def setup_logging(verbose: bool = False) -> None:
+    level = logging.DEBUG if verbose else logging.INFO
+    logging.basicConfig(
+        level=level,
+        format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+        datefmt="%Y-%m-%d %H:%M:%S",
+    )
+
+
+def create_argument_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="supervisor-agent",
+        description="SupervisorAgent CLI - R2D (Repo-to-Deployment) automation",
+    )
+    parser.add_argument("--repo-url", help="Repository URL to operate on")
+    parser.add_argument("--branch-name", help="Branch name (deprecated - supervisor skips branch creation)")
+    parser.add_argument("--thread-id", help="Optional thread id")
+    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
+
+
+def prompt_for_repo_url() -> str:
+    """Prompt the user for a repository URL."""
+    try:
+        return input("Repository URL: ").strip()
+    except (KeyboardInterrupt, EOFError):
+        print("\n⚠️  Repository URL required")
+        sys.exit(1)
+
+
+def format_output(result: object) -> str:
+    try:
+        if hasattr(result, "model_dump"):
+            return json.dumps(result.model_dump(), indent=2)
+        return json.dumps(result, indent=2, default=str)
+    except Exception as e:
+        logging.warning(f"Failed to serialize output: {e}")
+        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 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()
+    elif not repo_url:
+        parser.error("--repo-url is required when --no-interactive is used")
+
+    # Branch name is no longer used since supervisor skips branch creation
+    # All errors are handled via GitHub issues instead
+    branch_name = args.branch_name or "main"  # Placeholder for compatibility
+
+    agent = SupervisorAgent()
+
+    while True:
+        reset_log_bus()
+        result = agent.run(
+            SupervisorAgentInput(
+                repo_url=repo_url,
+                branch_name=branch_name,
+                thread_id=args.thread_id,
+                dry_run=args.dry_run,
+            )
+        )
+
+        print(format_output(result))
+
+        try:
+            generate_step_summary(get_log_path(), Path("step-summary.md"))
+        except Exception as e:  # noqa: BLE001
+            logging.warning(f"Step summary generation failed: {e}")
+
+        if result.success or args.no_interactive:
+            break
+
+        try:
+            choice = input("Retry workflow? [y/N]: ").strip().lower()
+        except (KeyboardInterrupt, EOFError):
+            choice = ""
+
+        if choice != "y":
+            break
+
+        repo_url = prompt_for_repo_url()
+        # No longer prompt for branch name since supervisor skips branch creation
+
+    return 0 if result.success else 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

{diagram_to_iac-1.0.3 → diagram_to_iac-1.0.4}/src/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 = {