Added print state tables

Author: Peter-Sh

src/redis_release/bht/state.py

@@ -2,12 +2,15 @@
 import logging
 import uuid
 from datetime import datetime
+from importlib.metadata import packages_distributions
 from pathlib import Path
-from typing import TYPE_CHECKING, Any, Dict, Optional, Protocol, Union
+from typing import TYPE_CHECKING, Any, Dict, List, Optional, Protocol, Union
 
 from botocore.exceptions import ClientError
 from pydantic import BaseModel, Field
+from rich.console import Console
 from rich.pretty import pretty_repr
+from rich.table import Table
 
 from redis_release.models import WorkflowConclusion, WorkflowStatus
 from redis_release.state_manager import S3Backed, logger
@@ -238,6 +241,7 @@ def __exit__(self, exc_type: Any, exc_val: Any, exc_tb: Any) -> None:
             self.storage.release_lock(self.tag)
             self._lock_acquired = False
             logger.info(f"Lock released for tag: {self.tag}")
+        print_state_table(self.state)
 
     @property
     def state(self) -> ReleaseState:
@@ -508,3 +512,181 @@ def reset_model_to_defaults(target: BaseModel, default: BaseModel) -> None:
             else:
                 # Simple value, copy directly
                 setattr(target, field_name, default_value)
+
+
+def print_state_table(state: ReleaseState, console: Optional[Console] = None) -> None:
+    """Print table showing the release state.
+
+    Args:
+        state: The ReleaseState to display
+        console: Optional Rich Console instance (creates new one if not provided)
+    """
+    if console is None:
+        console = Console()
+
+    # Create table with title
+    table = Table(
+        title=f"[bold cyan]Release State: {state.meta.tag or 'N/A'}[/bold cyan]",
+        show_header=True,
+        header_style="bold magenta",
+        border_style="bright_blue",
+        title_style="bold cyan",
+    )
+
+    # Add columns
+    table.add_column("Package", style="cyan", no_wrap=True, width=20)
+    table.add_column("Build", justify="center", width=15)
+    table.add_column("Publish", justify="center", width=15)
+    table.add_column("Details", style="yellow", width=40)
+
+    # Process each package
+    for package_name, package in sorted(state.packages.items()):
+        # Determine build status
+        build_status = _get_workflow_status_display(package.build)
+
+        # Determine publish status
+        publish_status = _get_workflow_status_display(package.publish)
+
+        # Collect details from workflows
+        details = _collect_details(package)
+
+        # Add row to table
+        table.add_row(
+            package_name,
+            build_status,
+            publish_status,
+            details,
+        )
+
+    # Print the table
+    console.print()
+    console.print(table)
+    console.print()
+
+
+def _get_workflow_status_display(workflow: Workflow) -> str:
+    """Get a rich-formatted status display for a workflow.
+
+    Args:
+        workflow: The workflow to check
+
+    Returns:
+        Rich-formatted status string
+    """
+    # Check result field - if we have result, we succeeded
+    if workflow.result is not None:
+        return "[bold green]✓ Success[/bold green]"
+
+    # Check if workflow was triggered
+    if workflow.triggered_at is None:
+        return "[dim]− Not Started[/dim]"
+
+    # Workflow was triggered but no result - it failed
+    return "[bold red]✗ Failed[/bold red]"
+
+
+def _collect_workflow_details(workflow: Workflow, prefix: str) -> List[str]:
+    """Collect details from a workflow using bottom-up approach.
+
+    Shows successes until the first failure, then stops.
+    Bottom-up means: trigger → identify → timeout → conclusion → artifacts → result
+
+    Args:
+        workflow: The workflow to check
+        prefix: Prefix for detail messages (e.g., "Build" or "Publish")
+
+    Returns:
+        List of detail strings
+    """
+    details: List[str] = []
+
+    # Stage 1: Trigger (earliest/bottom)
+    if workflow.ephemeral.trigger_failed or workflow.triggered_at is None:
+        details.append(f"[red]✗ Trigger {prefix} workflow failed[/red]")
+        return details
+    else:
+        details.append(f"[green]✓ {prefix} workflow triggered[/green]")
+
+    # Stage 2: Identify
+    if workflow.ephemeral.identify_failed or workflow.run_id is None:
+        details.append(f"[red]✗ {prefix} workflow not found[/red]")
+        return details
+    else:
+        details.append(f"[green]✓ {prefix} workflow found[/green]")
+
+    # Stage 3: Timeout (only ephemeral)
+    if workflow.ephemeral.timed_out:
+        details.append(f"[yellow]⏱ {prefix} timed out[/yellow]")
+        return details
+
+    # Stage 4: Workflow conclusion
+    if workflow.conclusion == WorkflowConclusion.FAILURE:
+        details.append(f"[red]✗ {prefix} workflow failed[/red]")
+        return details
+
+    # Stage 5: Artifacts download
+    if workflow.ephemeral.artifacts_download_failed or workflow.artifacts is None:
+        details.append(f"[red]✗ {prefix} artifacts download failed[/red]")
+        return details
+    else:
+        details.append(f"[green]✓ {prefix} artifacts downloaded[/green]")
+
+    # Stage 6: Result extraction (latest/top)
+    if workflow.result is None or workflow.ephemeral.extract_result_failed:
+        details.append(f"[red]✗ {prefix} failed to extract result[/red]")
+        return details
+    else:
+        details.append(f"[green]✓ {prefix} result extracted[/green]")
+
+    # Check for other workflow states
+    if workflow.status == WorkflowStatus.IN_PROGRESS:
+        details.append(f"[blue]⟳ {prefix} in progress[/blue]")
+    elif workflow.status == WorkflowStatus.QUEUED:
+        details.append(f"[cyan]⋯ {prefix} queued[/cyan]")
+    elif workflow.status == WorkflowStatus.PENDING:
+        details.append(f"[dim]○ {prefix} pending[/dim]")
+
+    return details
+
+
+def _collect_package_details(package: Package) -> List[str]:
+    """Collect details from package metadata.
+
+    Args:
+        package: The package to check
+
+    Returns:
+        List of detail strings (may be empty)
+    """
+    details: List[str] = []
+
+    if package.meta.ephemeral.identify_ref_failed:
+        details.append("[red]✗ Identify target ref to run workflow failed[/red]")
+    elif package.meta.ref is not None:
+        details.append(f"[green]✓ Target Ref identified: {package.meta.ref}[/green]")
+
+    return details
+
+
+def _collect_details(package: Package) -> str:
+    """Collect and format all details from package and workflows.
+
+    Args:
+        package: The package to check
+
+    Returns:
+        Formatted string of details
+    """
+    details: List[str] = []
+
+    # Collect package-level details
+    details.extend(_collect_package_details(package))
+
+    # Collect build workflow details
+    details.extend(_collect_workflow_details(package.build, "Build"))
+
+    # Only collect publish details if build succeeded (has result)
+    if package.build.result is not None:
+        details.extend(_collect_workflow_details(package.publish, "Publish"))
+
+    return "\n".join(details)

src/redis_release/cli.py

@@ -17,6 +17,8 @@
     PackageMeta,
     ReleaseMeta,
     ReleaseState,
+    S3StateStorage,
+    StateSyncer,
     Workflow,
 )
 
@@ -345,5 +347,31 @@ def release_bht(
         asyncio.run(async_tick_tock(tree))
 
 
+@app.command()
+def release_state(
+    release_tag: str = typer.Argument(..., help="Release tag (e.g., 8.4-m01-int1)"),
+    config_file: Optional[str] = typer.Option(
+        None, "--config", "-c", help="Path to config file (default: config.yaml)"
+    ),
+) -> None:
+    """Run release using behaviour tree implementation."""
+    setup_logging(logging.INFO)
+    config_path = config_file or "config.yaml"
+    config = load_config(config_path)
+
+    # Create release args
+    args = ReleaseArgs(
+        release_tag=release_tag,
+        force_rebuild=[],
+    )
+
+    with StateSyncer(
+        storage=S3StateStorage(),
+        config=config,
+        args=args,
+    ):
+        pass
+
+
 if __name__ == "__main__":
     app()