Merge pull request #1 from mariuspruvot/reorganize-cli

Reorganize cli

Author: mariuspruvot

README.md

@@ -66,8 +66,9 @@ uv pip install -e ".[dev]"
 # Quick record - press Enter to stop
 shh
 
-# Record for specific duration
-shh --duration 60
+# Minimal output (just result + "Done")
+shh --quiet
+shh -q
 ```
 
 ### Formatting Styles
@@ -99,6 +100,25 @@ shh config set default_translation_language English
 shh
 ```
 
+### Output Modes
+
+```bash
+# Rich UI (default) - colors, panels, live progress
+shh
+
+# Quiet mode - minimal output for scripting
+shh --quiet
+
+# Set quiet mode as default
+shh config set quiet_mode true
+
+# Override quiet mode with verbose flag
+shh --verbose
+
+# Combine with other options
+shh --quiet --style casual --translate English
+```
+
 ### Configuration
 
 ```bash

shh/cli/app.py

@@ -46,14 +46,30 @@ def default_command(
             help="Translate to language (e.g., English, French)",
         ),
     ] = None,
+    quiet: Annotated[
+        bool,
+        typer.Option(
+            "--quiet",
+            "-q",
+            help="Minimal output (overrides config default)",
+        ),
+    ] = False,
+    verbose: Annotated[
+        bool,
+        typer.Option(
+            "--verbose",
+            "-v",
+            help="Rich UI output (overrides config default)",
+        ),
+    ] = False,
 ) -> None:
     """Record audio and transcribe. Press Enter to stop."""
     # If a subcommand was invoked, don't run the default
     if ctx.invoked_subcommand is not None:
         return
 
     # Run the async record command
-    asyncio.run(record_command(style=style, translate=translate))
+    asyncio.run(record_command(style=style, translate=translate, quiet=quiet, verbose=verbose))
 
 
 def main() -> None:

shh/cli/commands/config.py

@@ -13,16 +13,15 @@
 console = Console()
 
 # Create a sub-app for config commands
-config_app = typer.Typer(
-    help="Manage configuration (wizard, show, get, set, edit, reset)"
-)
+config_app = typer.Typer(help="Manage configuration (wizard, show, get, set, edit, reset)")
 
 
 # Valid settings keys for validation
 VALID_KEYS = {
     "default_style": list(TranscriptionStyle),
     "default_translation_language": None,  # Freeform text, no validation
     "show_progress": [True, False],
+    "quiet_mode": [True, False],
     "whisper_model": list(WhisperModel),
 }
 
@@ -55,6 +54,7 @@ def config_show() -> None:
         settings.default_translation_language or "[dim]None[/dim]",
     )
     table.add_row("show_progress", str(settings.show_progress))
+    table.add_row("quiet_mode", str(settings.quiet_mode))
     table.add_row("whisper_model", str(settings.whisper_model))
     table.add_row("default_output", ", ".join(settings.default_output))
 
@@ -131,6 +131,11 @@ def config_set(key: str, value: str) -> None:
             console.print("[red]Error: show_progress must be 'true' or 'false'[/red]")
             raise typer.Exit(code=1)
         typed_value = value.lower() == "true"
+    elif key == "quiet_mode":
+        if value.lower() not in ("true", "false"):
+            console.print("[red]Error: quiet_mode must be 'true' or 'false'[/red]")
+            raise typer.Exit(code=1)
+        typed_value = value.lower() == "true"
     elif key == "whisper_model":
         try:
             typed_value = WhisperModel(value)

shh/cli/commands/record.py

@@ -1,154 +1,125 @@
 """Recording command for the shh CLI."""
 
-import asyncio
-import contextlib
 import logging
 import sys
 
-import pyperclip  # type: ignore[import-untyped]
-from rich.console import Console
-from rich.live import Live
-from rich.panel import Panel
-from rich.text import Text
-
-from shh.adapters.audio.processor import save_audio_to_wav
-from shh.adapters.audio.recorder import AudioRecorder
-from shh.adapters.llm.formatter import format_transcription
-from shh.adapters.whisper.client import transcribe_audio
+from shh.cli.ui import QuietUI, RichUI, UIOutput
+from shh.cli.ui.base import RecordingProgress, TranscriptionResult
 from shh.config.settings import Settings
+from shh.core.models import RecordingOptions
 from shh.core.styles import TranscriptionStyle
+from shh.services.recording import RecordingService
 
 # Suppress HTTP request logs
 logging.getLogger("httpx").setLevel(logging.WARNING)
 logging.getLogger("openai").setLevel(logging.WARNING)
 
-console = Console()
-
 
-async def wait_for_enter() -> None:
-    """Wait for user to press Enter (runs in thread pool)."""
-    loop = asyncio.get_running_loop()
-    await loop.run_in_executor(None, sys.stdin.readline)
+def _get_ui(quiet: bool, verbose: bool, settings: Settings) -> UIOutput:
+    """
+    Determine which UI to use based on flags and config.
+    
+    Priority: verbose flag > quiet flag > config setting
+    
+    Args:
+        quiet: Force quiet mode
+        verbose: Force verbose mode
+        settings: User settings
+        
+    Returns:
+        UIOutput instance (RichUI or QuietUI)
+    """
+    if verbose:
+        return RichUI()
+    if quiet:
+        return QuietUI()
+    return QuietUI() if settings.quiet_mode else RichUI()
 
 
 async def record_command(
     style: TranscriptionStyle | None = None,
     translate: str | None = None,
+    quiet: bool = False,
+    verbose: bool = False,
 ) -> None:
     """
     Record audio, transcribe, and optionally format/translate.
 
     Args:
         style: Formatting style to apply (overrides config default)
         translate: Target language for translation
+        quiet: Force minimal output (overrides config)
+        verbose: Force rich UI (overrides config)
     """
     # Load settings
     settings = Settings.load_from_file()
     if not settings or not settings.openai_api_key:
-        console.print("[red]Error: No API key found.[/red]")
-        console.print("[dim]Run 'shh setup' to configure your OpenAI API key.[/dim]")
+        # For error message, default to Rich UI unless quiet explicitly set
+        ui: UIOutput = QuietUI() if quiet else RichUI()
+        ui.show_error(
+            "No API key found.",
+            "Run 'shh setup' to configure your OpenAI API key.",
+        )
         sys.exit(1)
 
     # Use provided options or fall back to config defaults
     formatting_style = style if style is not None else settings.default_style
     target_language = translate if translate is not None else settings.default_translation_language
+    ui = _get_ui(quiet, verbose, settings)
 
-    # Step 1: Recording
-    console.print()
+    # Create service
+    service = RecordingService(settings)
+    options = RecordingOptions(
+        style=formatting_style,
+        translate=target_language,
+        show_progress=settings.show_progress,
+    )
 
     try:
-        async with AudioRecorder() as recorder:
-            # Start waiting for Enter in background
-            enter_task = asyncio.create_task(wait_for_enter())
-
-            # Show live progress
-            with Live(auto_refresh=False, console=console) as live:
-                while not enter_task.done() and not recorder.is_max_duration_reached():
-                    elapsed = recorder.elapsed_time()
-                    max_duration = recorder._max_duration
-
-                    # Create progress text
-                    progress = Text()
-                    progress.append("Recording... ", style="bold green")
-                    progress.append(f"{elapsed:.1f}s ", style="cyan")
-                    progress.append(f"/ {max_duration:.0f}s ", style="dim")
-                    progress.append("[Press Enter to stop]", style="dim")
-
-                    live.update(progress)
-                    live.refresh()
-                    await asyncio.sleep(0.1)
-
-                # Check if max duration reached
-                if recorder.is_max_duration_reached():
-                    console.print(
-                        "\n[yellow]Maximum recording duration reached (5 minutes)[/yellow]"
-                    )
-
-            # Cancel Enter task if we hit max duration
-            if not enter_task.done():
-                enter_task.cancel()
-                with contextlib.suppress(asyncio.CancelledError):
-                    await enter_task
-
-            # Get recorded audio
-            audio_data = recorder.get_audio()
+        # Recording phase
+        ui.show_recording_start()
 
-    except KeyboardInterrupt:
-        console.print("\n[yellow]Recording cancelled.[/yellow]")
-        sys.exit(130)  # Standard exit code for Ctrl+C
+        def progress_callback(elapsed: float, max_duration: float) -> None:
+            ui.show_recording_progress(RecordingProgress(elapsed, max_duration))
 
-    # Check if we got any audio
-    if len(audio_data) == 0:
-        console.print("[yellow]No audio recorded.[/yellow]")
-        sys.exit(1)
+        # Always pass progress callback - UI decides how to display it
+        audio_data = await service.record_audio(on_progress=progress_callback)
 
-    # Step 2: Save to WAV
-    console.print("\n[cyan]Saving audio...[/cyan]")
-    audio_file_path = save_audio_to_wav(audio_data)
+        ui.show_recording_stopped()
 
-    try:
-        # Step 3: Transcribe
-        console.print("[cyan]Transcribing with Whisper...[/cyan]")
-        transcription = await transcribe_audio(
-            audio_file_path=audio_file_path,
-            api_key=settings.openai_api_key,
-        )
+        # Check if we got any audio
+        if len(audio_data) == 0:
+            ui.show_warning("No audio recorded.")
+            sys.exit(1)
+
+        # Processing phases
+        ui.show_processing_step("Saving audio...")
+        ui.show_processing_step("Transcribing with Whisper...")
 
-        # Step 4: Format/Translate (if requested)
         if formatting_style != TranscriptionStyle.NEUTRAL or target_language:
             if target_language:
-                console.print(f"[cyan]Formatting and translating to {target_language}...[/cyan]")
+                ui.show_processing_step(f"Formatting and translating to {target_language}...")
             else:
-                console.print(f"[cyan]Formatting ({formatting_style})...[/cyan]")
-
-            formatted = await format_transcription(
-                transcription,
-                style=formatting_style,
-                api_key=settings.openai_api_key,
-                target_language=target_language,
+                ui.show_processing_step(f"Formatting ({formatting_style})...")
+
+        # Transcribe and format
+        result = await service.transcribe_and_format(audio_data, options)
+
+        # Display result
+        ui.show_result(
+            TranscriptionResult(
+                text=result.text,
+                copied_to_clipboard=result.copied_to_clipboard,
+                style=result.style.value,
+                translated_to=result.translated_to,
             )
-            final_text = formatted.text
-        else:
-            final_text = transcription
-
-        # Step 5: Copy to clipboard
-        clipboard_success = True
-        try:
-            pyperclip.copy(final_text)
-        except Exception as e:
-            clipboard_success = False
-            console.print(f"[yellow]Warning: Could not copy to clipboard: {e}[/yellow]")
-
-        # Step 6: Display result
-        console.print()
-        result_panel = Panel(
-            final_text,
-            title="Transcription" + (" (copied to clipboard)" if clipboard_success else ""),
-            border_style="green" if clipboard_success else "yellow",
         )
-        console.print(result_panel)
-        console.print()
 
+    except KeyboardInterrupt:
+        ui.show_warning("Recording cancelled.")
+        sys.exit(130)  # Standard exit code for Ctrl+C
+    except ValueError as e:
+        ui.show_error(str(e))
+        sys.exit(1)
     finally:
-        # Cleanup temp file
-        audio_file_path.unlink(missing_ok=True)
+        ui.cleanup()

shh/cli/ui/__init__.py

@@ -0,0 +1,7 @@
+"""UI layer for CLI output formatting."""
+
+from shh.cli.ui.base import UIOutput
+from shh.cli.ui.quiet_ui import QuietUI
+from shh.cli.ui.rich_ui import RichUI
+
+__all__ = ["UIOutput", "RichUI", "QuietUI"]