refactor(postgres-cli): decouple CLI output from core logic using OutputProvider

Refactor the `__main__.py` CLI tool to separate output presentation
from core query execution logic.

Introduces an `OutputProvider` strategy pattern (`PlainTextOutputProvider`
and `RichOutputProvider`) to encapsulate output formatting. This removes
the pervasive `if-else` checks for `rich` availability, making the code
cleaner and more maintainable.

Adds a `--plain` argument to force plain text output even when `rich`
is installed, providing explicit control over the output format.

Author: vistart

src/rhosocial/activerecord/backend/impl/postgres/__main__.py

@@ -1,28 +1,24 @@
 # src/rhosocial/activerecord/backend/impl/postgres/__main__.py
 import argparse
 import asyncio
-import datetime
-import decimal
 import logging
-import json
 import os
 import sys
 
+from .backend import PostgresBackend, AsyncPostgresBackend
+from .config import PostgresConnectionConfig
+from rhosocial.activerecord.backend.errors import ConnectionError, QueryError
+from .output import PlainTextOutputProvider
+
+# Attempt to import rich and the RichOutputProvider
 try:
     from rich.console import Console
-    from rich.table import Table
-    from rich.panel import Panel
     from rich.logging import RichHandler
-    from rich import box
+    from .output import RichOutputProvider
     RICH_AVAILABLE = True
 except ImportError:
     RICH_AVAILABLE = False
 
-from .backend import PostgresBackend, AsyncPostgresBackend
-from .config import PostgresConnectionConfig
-from rhosocial.activerecord.backend.errors import ConnectionError, QueryError
-
-
 logger = logging.getLogger(__name__)
 
 
@@ -32,205 +28,114 @@ def parse_args():
         formatter_class=argparse.RawTextHelpFormatter
     )
 
-    # Connection parameters with defaults from environment variables
-    parser.add_argument(
-        '--host',
-        default=os.getenv('POSTGRES_HOST', 'localhost'),
-        help='Database host (default: POSTGRES_HOST environment variable or localhost)'
-    )
-    parser.add_argument(
-        '--port',
-        type=int,
-        default=int(os.getenv('POSTGRES_PORT', 5432)),
-        help='Database port (default: POSTGRES_PORT environment variable or 5432)'
-    )
-    parser.add_argument(
-        '--database',
-        default=os.getenv('POSTGRES_DATABASE'),
-        help='Database name (optional, default: POSTGRES_DATABASE environment variable)'
-    )
-    parser.add_argument(
-        '--user',
-        default=os.getenv('POSTGRES_USER', 'postgres'),
-        help='Database user (default: POSTGRES_USER environment variable or postgres)'
-    )
-    parser.add_argument(
-        '--password',
-        default=os.getenv('POSTGRES_PASSWORD', ''),
-        help='Database password (default: POSTGRES_PASSWORD environment variable or empty string)'
-    )
-    # Positional argument for the SQL query
-    parser.add_argument(
-        'query', # Changed to positional argument
-        help='SQL query to execute. Must be enclosed in quotes.'
-    )
+    # Connection parameters
+    parser.add_argument('--host', default=os.getenv('POSTGRES_HOST', 'localhost'), help='Database host')
+    parser.add_argument('--port', type=int, default=int(os.getenv('POSTGRES_PORT', 5432)), help='Database port')
+    parser.add_argument('--database', default=os.getenv('POSTGRES_DATABASE'), help='Database name')
+    parser.add_argument('--user', default=os.getenv('POSTGRES_USER', 'postgres'), help='Database user')
+    parser.add_argument('--password', default=os.getenv('POSTGRES_PASSWORD', ''), help='Database password')
 
+    # Execution options
+    parser.add_argument('query', help='SQL query to execute. Must be enclosed in quotes.')
     parser.add_argument('--use-async', action='store_true', help='Use asynchronous backend')
-    parser.add_argument('--log-level', default='INFO', help='Set logging level (DEBUG, INFO, WARNING, ERROR, CRITICAL)')
+    
+    # Output and logging options
+    parser.add_argument('--log-level', default='INFO', help='Set logging level (e.g., DEBUG, INFO)')
+    parser.add_argument('--plain', action='store_true', help='Use plain text output even if rich is installed.')
     parser.add_argument('--rich-ascii', action='store_true', help='Use ASCII characters for rich table borders.')
 
     return parser.parse_args()
 
-def execute_query_sync(args, backend):
+def execute_query_sync(args, backend, provider):
     try:
         backend.connect()
-        if RICH_AVAILABLE:
-            Console().print(f"Executing synchronous query: [bold cyan]{args.query}[/bold cyan]")
-        else:
-            logger.info(f"Executing synchronous query: {args.query}")
+        provider.display_query(args.query, is_async=False)
         result = backend.execute(args.query)
-        handle_result(args, result)
+        handle_result(result, provider, use_ascii=args.rich_ascii)
     except ConnectionError as e:
-        if RICH_AVAILABLE:
-            Console().print(Panel(f"[bold]Database Connection Error[/bold]\n[red]{e}[/red]", title="[bold red]Error[/bold red]", border_style="red"))
-        else:
-            logger.error(f"Database connection error: {e}")
+        provider.display_connection_error(e)
         sys.exit(1)
     except QueryError as e:
-        if RICH_AVAILABLE:
-            Console().print(Panel(f"[bold]Database Query Error[/bold]\n[red]{e}[/red]", title="[bold red]Error[/bold red]", border_style="red"))
-        else:
-            logger.error(f"Database query error: {e}")
+        provider.display_query_error(e)
         sys.exit(1)
     except Exception as e:
-        if RICH_AVAILABLE:
-            Console().print(Panel(f"[bold]An unexpected error occurred during synchronous execution[/bold]\n[red]{e}[/red]", title="[bold red]Error[/bold red]", border_style="red"))
-        else:
-            logger.error(f"An unexpected error occurred during synchronous execution: {e}", exc_info=True)
+        provider.display_unexpected_error(e, is_async=False)
         sys.exit(1)
     finally:
         if backend._connection:
             backend.disconnect()
-            if RICH_AVAILABLE:
-                Console().print("[dim]Disconnected from database (synchronous).[/dim]")
-            else:
-                logger.info("Disconnected from database (synchronous).")
+            provider.display_disconnect(is_async=False)
 
-async def execute_query_async(args, backend):
+async def execute_query_async(args, backend, provider):
     try:
         await backend.connect()
-        if RICH_AVAILABLE:
-            Console().print(f"Executing asynchronous query: [bold cyan]{args.query}[/bold cyan]")
-        else:
-            logger.info(f"Executing asynchronous query: {args.query}")
+        provider.display_query(args.query, is_async=True)
         result = await backend.execute(args.query)
-        handle_result(args, result)
+        handle_result(result, provider, use_ascii=args.rich_ascii)
     except ConnectionError as e:
-        if RICH_AVAILABLE:
-            Console().print(Panel(f"[bold]Database Connection Error[/bold]\n[red]{e}[/red]", title="[bold red]Error[/bold red]", border_style="red"))
-        else:
-            logger.error(f"Database connection error: {e}")
+        provider.display_connection_error(e)
         sys.exit(1)
     except QueryError as e:
-        if RICH_AVAILABLE:
-            Console().print(Panel(f"[bold]Database Query Error[/bold]\n[red]{e}[/red]", title="[bold red]Error[/bold red]", border_style="red"))
-        else:
-            logger.error(f"Database query error: {e}")
+        provider.display_query_error(e)
         sys.exit(1)
     except Exception as e:
-        if RICH_AVAILABLE:
-            Console().print(Panel(f"[bold]An unexpected error occurred during asynchronous execution[/bold]\n[red]{e}[/red]", title="[bold red]Error[/bold red]", border_style="red"))
-        else:
-            logger.error(f"An unexpected error occurred during asynchronous execution: {e}", exc_info=True)
+        provider.display_unexpected_error(e, is_async=True)
         sys.exit(1)
     finally:
         if backend._connection:
             await backend.disconnect()
-            if RICH_AVAILABLE:
-                Console().print("[dim]Disconnected from database (asynchronous).[/dim]")
-            else:
-                logger.info("Disconnected from database (asynchronous).")
-
-def json_serializer(obj):
-    """Handles serialization of types not supported by default JSON encoder."""
-    if isinstance(obj, (datetime.datetime, datetime.date)):
-        return obj.isoformat()
-    if isinstance(obj, datetime.timedelta):
-        return str(obj)
-    if isinstance(obj, decimal.Decimal):
-        return str(obj)
-    raise TypeError(f"Object of type {obj.__class__.__name__} is not JSON serializable")
-
-
-def handle_result(args, result):
+            provider.display_disconnect(is_async=True)
+
+
+def handle_result(result, provider, **kwargs):
     if not result:
-        if RICH_AVAILABLE:
-            Console().print("[yellow]Query executed, but no result object returned.[/yellow]")
-        else:
-            logger.info("Query executed, but no result object returned.")
+        provider.display_no_result_object()
         return
 
-    if RICH_AVAILABLE:
-        console = Console()
-        console.print(f"[bold green]Query executed successfully.[/bold green] "
-                      f"Affected rows: [bold cyan]{result.affected_rows}[/bold cyan], "
-                      f"Duration: [bold cyan]{result.duration:.4f}s[/bold cyan]")
-        if result.data:
-            # Ensure data is a list of dicts
-            if not isinstance(result.data, list) or not result.data or not all(isinstance(i, dict) for i in result.data):
-                console.print(result.data)
-                return
-
-            box_style = box.ASCII if args.rich_ascii else box.SQUARE
-            table = Table(show_header=True, header_style="bold magenta", box=box_style)
-            headers = result.data[0].keys()
-            for header in headers:
-                table.add_column(header, style="dim", overflow="fold")
-            
-            for row in result.data:
-                table.add_row(*(str(v) for v in row.values()))
-            
-            console.print(table)
-        else:
-            console.print("[yellow]No data returned.[/yellow]")
+    provider.display_success(result.affected_rows, result.duration)
+    if result.data:
+        provider.display_results(result.data, **kwargs)
     else:
-        logger.info(f"Query executed successfully. Affected rows: {result.affected_rows}, Duration: {result.duration:.4f}s")
-        if result.data:
-            logger.info("Results:")
-            for row in result.data:
-                if isinstance(row, (dict, list)):
-                    print(json.dumps(row, indent=2, ensure_ascii=False, default=json_serializer))
-                else:
-                    print(row)
-        else:
-            logger.info("No data returned.")
+        provider.display_no_data()
 
 def main():
     args = parse_args()
 
-    # Set logging level
+    # Setup logging
     numeric_level = getattr(logging, args.log_level.upper(), None)
     if not isinstance(numeric_level, int):
         raise ValueError(f'Invalid log level: {args.log_level}')
 
-    if RICH_AVAILABLE:
+    # Choose output provider
+    if RICH_AVAILABLE and not args.plain:
+        provider = RichOutputProvider(console=Console(), ascii_borders=args.rich_ascii)
         logging.basicConfig(
             level=numeric_level,
             format="%(message)s",
             datefmt="[%X]",
             handlers=[RichHandler(rich_tracebacks=True, show_path=False)]
         )
-        Console().print("[bold green]Rich library detected. Logging and output are beautified.[/bold green]")
     else:
+        provider = PlainTextOutputProvider()
         logging.basicConfig(level=numeric_level, format='%(asctime)s - %(levelname)s - %(message)s')
-        print("Rich library not found. We recommend installing rich for a more user-friendly output.")
+    
+    provider.display_greeting()
 
+    # Setup backend
     config = PostgresConnectionConfig(
         host=args.host,
         port=args.port,
         database=args.database,
         username=args.user,
         password=args.password,
-
-
     )
 
     if args.use_async:
         backend = AsyncPostgresBackend(connection_config=config)
-        asyncio.run(execute_query_async(args, backend))
+        asyncio.run(execute_query_async(args, backend, provider))
     else:
         backend = PostgresBackend(connection_config=config)
-        execute_query_sync(args, backend)
+        execute_query_sync(args, backend, provider)
 
 if __name__ == "__main__":
     main()