voicepad 0.1.1__tar.gz

voicepad-0.1.1/PKG-INFO

@@ -0,0 +1,89 @@
+Metadata-Version: 2.4
+Name: voicepad
+Version: 0.1.1
+Summary: Command-line interface for voice recording and GPU-accelerated transcription.
+Keywords: cli,voice,audio,transcription,recording,speech-to-text,whisper,command-line,gpu-acceleration
+Author: Rajesh Das
+Author-email: Rajesh Das <rajesh@hyperoot.dev>
+License-Expression: MIT
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Multimedia :: Sound/Audio :: Capture/Recording
+Classifier: Topic :: Multimedia :: Sound/Audio :: Speech
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Typing :: Typed
+Requires-Dist: voicepad-core>=0.1.0
+Requires-Dist: typer>=0.23.1
+Requires-Dist: textual>=7.5.0
+Requires-Dist: voicepad-core[gpu] ; extra == 'gpu'
+Requires-Python: >=3.13
+Project-URL: HomePage, https://hyp3r00t.github.io/voicepad/
+Project-URL: Repository, https://github.com/HYP3R00T/voicepad
+Project-URL: Issues, https://github.com/HYP3R00T/voicepad/issues
+Project-URL: Documentation, https://hyp3r00t.github.io/voicepad/
+Provides-Extra: gpu
+Description-Content-Type: text/markdown
+
+# voicepad CLI
+
+Simple command-line interface for recording audio and managing transcription configuration.
+
+## Install
+
+```bash
+pip install voicepad
+```
+
+**Requirements:** Python 3.13+
+
+## Quick Start
+
+```bash
+# List audio input devices
+voicepad config input
+
+# Start recording (press Ctrl+C to stop)
+voicepad record start
+
+# Check system capabilities
+voicepad config system
+```
+
+## Example: Record and Transcribe
+
+```bash
+# Record a meeting (will auto-transcribe)
+voicepad record start --prefix team_meeting
+
+# Output:
+# - data/recordings/team_meeting_20260218_103045.wav
+# - data/markdown/team_meeting_20260218_103045.md
+```
+
+## Documentation
+
+- [CLI Command Reference](https://voicepad.readthedocs.io/packages/voicepad/) - Full documentation
+- [voicepad-core Library](https://voicepad.readthedocs.io/packages/voicepad-core/) - Python API
+- [Main README](https://github.com/HYP3R00T/voicepad#readme) - Project overview
+
+## Configuration
+
+Edit `voicepad.yaml` to set defaults:
+
+```yaml
+recordings_path: data/recordings
+markdown_path: data/markdown
+input_device_index: null
+transcription_model: tiny
+transcription_device: auto
+transcription_compute_type: auto
+```
+
+See the [full documentation](https://voicepad.readthedocs.io/packages/voicepad/) for all configuration options.

voicepad-0.1.1/README.md

@@ -0,0 +1,56 @@
+# voicepad CLI
+
+Simple command-line interface for recording audio and managing transcription configuration.
+
+## Install
+
+```bash
+pip install voicepad
+```
+
+**Requirements:** Python 3.13+
+
+## Quick Start
+
+```bash
+# List audio input devices
+voicepad config input
+
+# Start recording (press Ctrl+C to stop)
+voicepad record start
+
+# Check system capabilities
+voicepad config system
+```
+
+## Example: Record and Transcribe
+
+```bash
+# Record a meeting (will auto-transcribe)
+voicepad record start --prefix team_meeting
+
+# Output:
+# - data/recordings/team_meeting_20260218_103045.wav
+# - data/markdown/team_meeting_20260218_103045.md
+```
+
+## Documentation
+
+- [CLI Command Reference](https://voicepad.readthedocs.io/packages/voicepad/) - Full documentation
+- [voicepad-core Library](https://voicepad.readthedocs.io/packages/voicepad-core/) - Python API
+- [Main README](https://github.com/HYP3R00T/voicepad#readme) - Project overview
+
+## Configuration
+
+Edit `voicepad.yaml` to set defaults:
+
+```yaml
+recordings_path: data/recordings
+markdown_path: data/markdown
+input_device_index: null
+transcription_model: tiny
+transcription_device: auto
+transcription_compute_type: auto
+```
+
+See the [full documentation](https://voicepad.readthedocs.io/packages/voicepad/) for all configuration options.

voicepad-0.1.1/pyproject.toml

@@ -0,0 +1,55 @@
+[project]
+name = "voicepad"
+version = "0.1.1"
+description = "Command-line interface for voice recording and GPU-accelerated transcription."
+readme = "README.md"
+authors = [{ name = "Rajesh Das", email = "rajesh@hyperoot.dev" }]
+requires-python = ">=3.13"
+license = "MIT"
+keywords = [
+  "cli",
+  "voice",
+  "audio",
+  "transcription",
+  "recording",
+  "speech-to-text",
+  "whisper",
+  "command-line",
+  "gpu-acceleration",
+]
+classifiers = [
+  "Development Status :: 3 - Alpha",
+  "Environment :: Console",
+  "Intended Audience :: Developers",
+  "Intended Audience :: End Users/Desktop",
+  "License :: OSI Approved :: MIT License",
+  "Operating System :: OS Independent",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.13",
+  "Programming Language :: Python :: 3 :: Only",
+  "Topic :: Multimedia :: Sound/Audio :: Capture/Recording",
+  "Topic :: Multimedia :: Sound/Audio :: Speech",
+  "Topic :: Scientific/Engineering :: Artificial Intelligence",
+  "Typing :: Typed",
+]
+dependencies = ["voicepad-core>=0.1.0", "typer>=0.23.1", "textual>=7.5.0"]
+
+[project.urls]
+HomePage = "https://hyp3r00t.github.io/voicepad/"
+Repository = "https://github.com/HYP3R00T/voicepad"
+Issues = "https://github.com/HYP3R00T/voicepad/issues"
+Documentation = "https://hyp3r00t.github.io/voicepad/"
+
+[project.optional-dependencies]
+gpu = [
+  # Chain to voicepad-core GPU support for NVIDIA acceleration
+  # Users can install with: pip install voicepad[gpu]
+  "voicepad-core[gpu]",
+]
+
+[project.scripts]
+voicepad = "voicepad:main"
+
+[build-system]
+requires = ["uv_build>=0.10.2,<0.11.0"]
+build-backend = "uv_build"

voicepad-0.1.1/src/voicepad/__init__.py

@@ -0,0 +1,5 @@
+"""Voicepad - Voice recording and audio processing application."""
+
+from voicepad.main import main
+
+__all__ = ["main"]

voicepad-0.1.1/src/voicepad/__main__.py

@@ -0,0 +1,6 @@
+"""Voicepad package entry point."""
+
+from voicepad.main import main
+
+if __name__ == "__main__":
+    main()

voicepad-0.1.1/src/voicepad/cli/__init__.py

@@ -0,0 +1,4 @@
+from voicepad.cli.config import config_app
+from voicepad.cli.record import record_app
+
+__all__ = ["config_app", "record_app"]

voicepad-0.1.1/src/voicepad/cli/config.py

@@ -0,0 +1,295 @@
+"""Configuration management commands."""
+
+import logging
+from dataclasses import dataclass
+from typing import TypedDict, cast
+
+import sounddevice as sd
+import typer
+from voicepad_core import get_config, get_config_with_metadata
+
+logger = logging.getLogger(__name__)
+
+config_app = typer.Typer(help="Configuration management commands")
+
+
+@dataclass(frozen=True)
+class AudioDevice:
+    index: int
+    name: str
+    channels: int
+    sample_rate: int
+
+    def __str__(self) -> str:
+        return f"[{self.index}] {self.name} ({self.channels} in, {self.sample_rate}Hz)"
+
+
+def _get_input_devices() -> list[AudioDevice]:
+    class _DeviceInfo(TypedDict, total=False):
+        name: str
+        max_input_channels: int
+        default_samplerate: float
+
+    devices: list[AudioDevice] = []
+    all_devices = cast(list[_DeviceInfo], sd.query_devices())
+
+    for idx, dev in enumerate(all_devices):
+        max_inputs = dev.get("max_input_channels") or 0
+        if max_inputs <= 0:
+            continue
+
+        name = dev.get("name", f"Device {idx}")
+        default_rate = dev.get("default_samplerate", 0.0)
+        rate = int(default_rate) if isinstance(default_rate, (int, float)) and default_rate > 0 else 44100
+        devices.append(AudioDevice(index=idx, name=name, channels=int(max_inputs), sample_rate=rate))
+
+    return devices
+
+
+@config_app.command("input")
+def list_input_devices() -> None:
+    """List available audio input devices for configuration."""
+    devices = _get_input_devices()
+    if not devices:
+        typer.secho("No audio input devices detected.", fg=typer.colors.RED, err=True)
+        raise typer.Exit(1)
+
+    config = get_config()
+    configured_index = config.input_device_index
+
+    typer.echo("Configured default input device:")
+    if configured_index is None:
+        typer.echo("  not set")
+    else:
+        try:
+            configured_device = next(dev for dev in devices if dev.index == configured_index)
+            typer.echo(f"  {configured_index}: {configured_device.name}")
+        except StopIteration:
+            typer.echo(f"  {configured_index}: not found")
+
+    typer.echo("\nAvailable audio input devices:")
+    typer.echo("-" * 60)
+    for dev in devices:
+        selected_marker = " (configured)" if dev.index == configured_index else ""
+        typer.echo(f"{dev}{selected_marker}")
+    typer.echo("-" * 60)
+
+    _show_config_hint()
+
+
+def _show_config_hint() -> None:
+    config_file = None
+    config_source = None
+
+    _config, metadata = get_config_with_metadata()
+    if metadata.per_field:
+        first_field_source = next(iter(metadata.per_field.values()))
+        config_file = first_field_source.source_path
+        config_source = first_field_source.source
+
+    if config_file and config_source != "defaults":
+        typer.echo(f"Config file: {config_file}")
+        typer.echo("Set input_device_index in that file to persist the default.")
+    else:
+        typer.echo("Config file: using defaults (no external config found)")
+        typer.echo("Set input_device_index in voicepad.yaml to persist the default.")
+
+
+@config_app.command("system")
+def system_info() -> None:
+    """Display comprehensive system information for transcription."""
+    from voicepad_core import (
+        get_cpu_info,
+        get_ram_info,
+        gpu_diagnostics,
+    )
+
+    typer.echo("System Information")
+    typer.echo("=" * 60)
+
+    # RAM info
+    ram = get_ram_info()
+    typer.echo("\nRAM:")
+    typer.echo(f"   Total: {ram.total_gb:.1f} GB")
+    typer.echo(f"   Available: {ram.available_gb:.1f} GB")
+
+    if ram.available_gb >= 8:
+        typer.secho("   [OK] Sufficient RAM for transcription", fg=typer.colors.GREEN)
+    elif ram.available_gb >= 4:
+        typer.secho("   [WARNING] Moderate RAM - use smaller models", fg=typer.colors.YELLOW)
+    else:
+        typer.secho("   [WARNING] Limited RAM - use tiny model only", fg=typer.colors.YELLOW)
+
+    # CPU info
+    cpu = get_cpu_info()
+    typer.echo("\nCPU:")
+    typer.echo(f"   Cores: {cpu.count}")
+    if cpu.model_name:
+        typer.echo(f"   Model: {cpu.model_name}")
+
+    # GPU diagnostics
+    gpu = gpu_diagnostics()
+    typer.echo("\nGPU:")
+
+    if gpu.nvidia_smi.success:
+        typer.secho("   NVIDIA Driver: [OK] Detected", fg=typer.colors.GREEN)
+    else:
+        typer.secho("   NVIDIA Driver: [NOT FOUND]", fg=typer.colors.YELLOW)
+
+    if gpu.ctranslate2_cuda.success:
+        count = gpu.ctranslate2_cuda.cuda_device_count or 0
+        typer.secho(f"   CUDA Devices: {count} device(s) available", fg=typer.colors.GREEN)
+    else:
+        typer.echo("   CUDA Devices: Not available")
+
+    if gpu.faster_whisper_gpu.success:
+        typer.secho("   faster-whisper GPU: [OK] Compatible", fg=typer.colors.GREEN)
+    else:
+        typer.echo("   faster-whisper GPU: Not compatible (CPU mode only)")
+
+    typer.echo("=" * 60)
+
+
+@config_app.command("recommend")
+def recommend_model() -> None:
+    """Get model recommendations based on system capabilities."""
+    from voicepad_core import (
+        get_available_models,
+        get_cpu_info,
+        get_model_recommendation,
+        get_ram_info,
+        gpu_diagnostics,
+    )
+    from voicepad_core.diagnostics.models import SystemInfo
+
+    # Gather system info
+    ram = get_ram_info()
+    cpu = get_cpu_info()
+    gpu = gpu_diagnostics()
+    available_models = get_available_models()
+
+    system_info = SystemInfo(ram=ram, cpu=cpu, gpu_diagnostics=gpu)
+
+    # Get recommendation
+    recommendation = get_model_recommendation(system_info, available_models)
+
+    # Display recommendation
+    typer.echo("Model Recommendation Based on System Capabilities")
+    typer.echo("=" * 60)
+    typer.echo("\nRecommended Configuration:")
+    typer.secho(f"   Model: {recommendation.recommended_model}", fg=typer.colors.GREEN, bold=True)
+    typer.secho(f"   Device: {recommendation.recommended_device}", fg=typer.colors.GREEN, bold=True)
+    typer.secho(f"   Compute Type: {recommendation.recommended_compute_type}", fg=typer.colors.GREEN, bold=True)
+
+    typer.echo("\nReason:")
+    typer.echo(f"   {recommendation.reason}")
+
+    if recommendation.alternative_models:
+        typer.echo("\nAlternative Models:")
+        for alt in recommendation.alternative_models[:5]:  # Show top 5
+            typer.echo(f"   - {alt}")
+
+    typer.echo("\nTo apply this configuration, add to voicepad.yaml:")
+    typer.echo(f"   transcription_model: {recommendation.recommended_model}")
+    typer.echo(f"   transcription_device: {recommendation.recommended_device}")
+    typer.echo(f"   transcription_compute_type: {recommendation.recommended_compute_type}")
+    typer.echo("=" * 60)
+
+
+@config_app.command("transcription")
+def transcription_config() -> None:
+    """View current transcription configuration."""
+    from voicepad_core import (
+        get_available_models,
+        get_config,
+        get_cpu_info,
+        get_model_recommendation,
+        get_ram_info,
+        gpu_diagnostics,
+    )
+    from voicepad_core.diagnostics.models import SystemInfo
+
+    config = get_config()
+
+    typer.echo("Transcription Configuration")
+    typer.echo("=" * 60)
+    typer.echo("\nCurrent Settings:")
+    typer.echo(f"   Model: {config.transcription_model}")
+    typer.echo(f"   Device: {config.transcription_device}")
+    typer.echo(f"   Compute Type: {config.transcription_compute_type}")
+
+    # Get recommendation for comparison
+    ram = get_ram_info()
+    cpu = get_cpu_info()
+    gpu = gpu_diagnostics()
+    available_models = get_available_models()
+    system_info = SystemInfo(ram=ram, cpu=cpu, gpu_diagnostics=gpu)
+    recommendation = get_model_recommendation(system_info, available_models)
+
+    typer.echo("\nRecommended Settings:")
+    if (
+        config.transcription_model == recommendation.recommended_model
+        and config.transcription_device == recommendation.recommended_device
+        and config.transcription_compute_type == recommendation.recommended_compute_type
+    ):
+        typer.secho("   [OK] Your configuration matches the recommendation!", fg=typer.colors.GREEN)
+    else:
+        typer.secho("   [INFO] Consider updating your configuration:", fg=typer.colors.YELLOW)
+        typer.echo(f"   Model: {recommendation.recommended_model}")
+        typer.echo(f"   Device: {recommendation.recommended_device}")
+        typer.echo(f"   Compute Type: {recommendation.recommended_compute_type}")
+        typer.echo(f"\n   Reason: {recommendation.reason}")
+
+    typer.echo("=" * 60)
+    _show_config_hint()
+
+
+@config_app.command("models")
+def list_models() -> None:
+    """List all available Whisper models."""
+    from voicepad_core import get_available_models
+
+    models = get_available_models()
+
+    typer.echo("Available Whisper Models")
+    typer.echo("=" * 60)
+
+    # Categorize models
+    categories = {
+        "Tiny": [],
+        "Base": [],
+        "Small": [],
+        "Medium": [],
+        "Large": [],
+        "Turbo": [],
+        "Distil": [],
+    }
+
+    for model in models:
+        model_lower = model.lower()
+        if "turbo" in model_lower:
+            categories["Turbo"].append(model)
+        elif "distil" in model_lower:
+            categories["Distil"].append(model)
+        elif "large" in model_lower:
+            categories["Large"].append(model)
+        elif "medium" in model_lower:
+            categories["Medium"].append(model)
+        elif "small" in model_lower:
+            categories["Small"].append(model)
+        elif "base" in model_lower:
+            categories["Base"].append(model)
+        elif "tiny" in model_lower:
+            categories["Tiny"].append(model)
+
+    for category, category_models in categories.items():
+        if category_models:
+            typer.echo(f"\n{category}:")
+            for model in sorted(category_models):
+                en_only = " (English-only)" if ".en" in model else ""
+                typer.echo(f"   - {model}{en_only}")
+
+    typer.echo("\n" + "=" * 60)
+    typer.echo(f"Total: {len(models)} models available")
+    typer.echo("\nTip: Use 'voicepad config recommend' to get a model recommendation")
+    typer.echo("     based on your system capabilities.")

voicepad-0.1.1/src/voicepad/cli/record.py

@@ -0,0 +1,282 @@
+"""Audio recording CLI commands for voicepad."""
+
+import logging
+import signal
+import time
+from pathlib import Path
+
+import typer
+from voicepad_core import AudioRecorder, AudioRecorderError, get_config
+
+logger = logging.getLogger(__name__)
+
+record_app = typer.Typer(help="Audio recording commands")
+
+
+def _handle_interrupt(recorder: AudioRecorder) -> Path | None:
+    """Handle keyboard interrupt during recording.
+
+    Args:
+        recorder: The AudioRecorder instance to stop.
+
+    Returns:
+        Path to saved audio file, or None if failed.
+    """
+    typer.echo("\n\n[!] Recording stopped by user")
+    try:
+        output_file = recorder.stop_recording()
+        if output_file:
+            typer.secho(f"[OK] Recording saved to: {output_file}", fg=typer.colors.GREEN)
+            return output_file
+    except AudioRecorderError as e:
+        typer.secho(f"[ERROR] Error stopping recording: {e}", fg=typer.colors.RED, err=True)
+    return None
+
+
+def _transcribe_audio_file(output_file: Path, config) -> None:
+    """Transcribe audio file and display results.
+
+    Args:
+        output_file: Path to the audio file to transcribe.
+        config: Configuration object.
+    """
+    typer.echo()
+    typer.secho("[*] Transcribing audio...", fg=typer.colors.CYAN)
+
+    try:
+        from voicepad_core import TranscriptionError, transcribe_audio
+
+        # Generate output path
+        md_path = config.markdown_path / f"{output_file.stem}.md"
+        config.markdown_path.mkdir(parents=True, exist_ok=True)
+
+        # Transcribe
+        stats = transcribe_audio(output_file, md_path, config)
+
+        # Check if GPU fallback occurred
+        fallback_info = stats.get("fallback_info", {})
+        if fallback_info.get("fallback_occurred"):
+            typer.echo()
+            typer.secho("[!] GPU requested but CUDA libraries not available", fg=typer.colors.YELLOW)
+
+            # Show what's missing
+            missing = fallback_info.get("missing_components", [])
+            if missing:
+                typer.echo(f"  Missing: {', '.join(missing)}")
+
+            typer.echo()
+            typer.echo("  For 4x faster transcription, install GPU support:")
+            typer.secho("    pip install voicepad-core[gpu]", fg=typer.colors.CYAN)
+            typer.echo()
+            typer.echo("  Using CPU for now...")
+
+        # Success message
+        typer.echo()
+        device = stats.get("device", "cpu")
+        duration = stats.get("duration", 0)
+        typer.secho(f"[OK] Transcription saved! ({duration:.1f}s using {device})", fg=typer.colors.GREEN)
+        typer.echo(f"   File: {md_path}")
+        typer.echo(f"   Language: {stats['language']} ({stats['language_probability'] * 100:.1f}%)")
+        typer.echo(f"   Words: {stats['word_count']}")
+        typer.echo(f"   Segments: {stats['segment_count']}")
+
+    except TranscriptionError as e:
+        typer.secho(f"[ERROR] Transcription failed: {e}", fg=typer.colors.RED, err=True)
+        typer.echo("   Recording was saved successfully, but transcription failed.")
+    except Exception as e:
+        logger.exception("Unexpected error during transcription")
+        typer.secho(f"[ERROR] Unexpected transcription error: {e}", fg=typer.colors.RED, err=True)
+
+
+@record_app.command("start")
+def start_recording(
+    prefix: str | None = typer.Option(
+        None,
+        "--prefix",
+        "-p",
+        help="Custom prefix for the recording filename (overrides config)",
+    ),
+    duration: float | None = typer.Option(
+        None,
+        "--duration",
+        "-d",
+        help="Duration in seconds for fixed-length recording (optional)",
+        min=0.1,
+    ),
+    transcribe: bool = typer.Option(
+        True,
+        "--transcribe/--no-transcribe",
+        help="Transcribe audio after recording (default: enabled)",
+    ),
+    vad: bool | None = typer.Option(
+        None,
+        "--vad/--no-vad",
+        help="Enable VAD-based chunking for long recordings (uses config default if not specified)",
+    ),
+    min_chunk_duration: float | None = typer.Option(
+        None,
+        "--min-chunk-duration",
+        help="Minimum chunk duration in seconds (VAD mode only, default: 60)",
+        min=10.0,
+        max=600.0,
+    ),
+    vad_threshold: float | None = typer.Option(
+        None,
+        "--vad-threshold",
+        help="VAD speech detection threshold 0.0-1.0 (VAD mode only, default: 0.5)",
+        min=0.0,
+        max=1.0,
+    ),
+) -> None:
+    """Start recording audio from the configured input device.
+
+    The recording will use the configured microphone (input_device_index) and
+    save to the configured recordings directory (recordings_path).
+
+    By default, the audio will be automatically transcribed after recording stops.
+    Use --no-transcribe to skip transcription.
+
+    Press Ctrl+C to stop recording manually, or use --duration for automatic stop.
+    """
+    output_file: Path | None = None
+
+    try:
+        # Load configuration
+        config = get_config()
+
+        # Apply CLI overrides for VAD settings
+        if vad is not None or min_chunk_duration is not None or vad_threshold is not None:
+            # Create modified config with CLI overrides
+            config_dict = config.model_dump()
+
+            if vad is not None:
+                config_dict["vad_enabled"] = vad
+            if min_chunk_duration is not None:
+                config_dict["vad_min_chunk_duration"] = min_chunk_duration
+            if vad_threshold is not None:
+                config_dict["vad_threshold"] = vad_threshold
+
+            # Reconstruct config with overrides
+            from voicepad_core.config import Config
+
+            config = Config(**config_dict)
+
+        # Display configuration info
+        typer.echo("Recording Configuration:")
+        typer.echo(f"   Input device: {config.input_device_index or 'default'}")
+        typer.echo(f"   Output directory: {config.recordings_path}")
+        typer.echo(f"   Filename prefix: {prefix or config.recording_prefix}")
+
+        if config.vad_enabled:
+            typer.echo("   VAD chunking: enabled")
+            typer.echo(f"      Min chunk duration: {config.vad_min_chunk_duration}s")
+            typer.echo(f"      VAD threshold: {config.vad_threshold}")
+            typer.echo(f"      Min silence: {config.vad_min_silence_duration_ms}ms")
+        else:
+            typer.echo("   VAD chunking: disabled")
+
+        if transcribe:
+            typer.echo(f"   Transcription: enabled (model: {config.transcription_model})")
+        else:
+            typer.echo("   Transcription: disabled")
+        typer.echo()
+
+        # Create recorder
+        recorder = AudioRecorder(config)
+
+        # Start recording
+        output_file = recorder.start_recording(prefix=prefix, duration=duration)
+
+        if duration:
+            # Fixed-duration recording
+            typer.secho(f"[REC] Recording for {duration} seconds...", fg=typer.colors.YELLOW)
+            typer.echo(f"   Output: {output_file}")
+
+            # Wait for recording to complete
+            time.sleep(duration + 0.5)  # Add small buffer for processing
+
+            typer.secho("[OK] Recording completed!", fg=typer.colors.GREEN)
+            typer.echo(f"   Saved to: {output_file}")
+
+        else:
+            # Manual stop recording
+            typer.secho("[REC] Recording in progress...", fg=typer.colors.YELLOW)
+            typer.echo(f"   Output: {output_file}")
+            typer.echo()
+            typer.echo("Press Ctrl+C to stop recording")
+
+            # Set up signal handler for graceful shutdown
+            def signal_handler(sig: int, frame) -> None:
+                nonlocal output_file
+                output_file = _handle_interrupt(recorder)
+                # Don't exit here - let the finally block handle transcription
+
+            signal.signal(signal.SIGINT, signal_handler)
+
+            # Keep the main thread alive while recording
+            try:
+                while recorder.is_recording():
+                    time.sleep(0.1)
+            except KeyboardInterrupt:
+                output_file = _handle_interrupt(recorder)
+
+    except AudioRecorderError as e:
+        typer.secho(f"[ERROR] Recording error: {e}", fg=typer.colors.RED, err=True)
+        raise typer.Exit(1) from e
+    except Exception as e:
+        logger.exception("Unexpected error during recording")
+        typer.secho(f"[ERROR] Unexpected error: {e}", fg=typer.colors.RED, err=True)
+        raise typer.Exit(1) from e
+    finally:
+        # Transcribe if enabled and we have a valid output file
+        if transcribe and output_file and output_file.exists():
+            # For VAD mode, transcription already happened in background
+            # For non-VAD mode, transcribe now
+            if config.vad_enabled:
+                # Transcription already complete in background
+                typer.echo()
+                typer.secho("✓ Transcription already complete (background processing)", fg=typer.colors.GREEN)
+                md_path = output_file.with_suffix(".md")
+                if md_path.exists():
+                    typer.echo(f"   Markdown: {md_path}")
+            else:
+                # Non-VAD mode: transcribe now
+                _transcribe_audio_file(output_file, config)
+
+
+@record_app.command("info")
+def show_info() -> None:
+    """Display current recording configuration and status."""
+    try:
+        config = get_config()
+
+        typer.echo("Current Recording Configuration")
+        typer.echo("=" * 60)
+        typer.echo(f"Input device index: {config.input_device_index or 'default (system)'}")
+        typer.echo(f"Recordings directory: {config.recordings_path}")
+        typer.echo(f"Filename prefix: {config.recording_prefix}")
+        if config.vad_enabled:
+            typer.echo("VAD chunking: enabled")
+            typer.echo(f"   Min chunk duration: {config.vad_min_chunk_duration}s")
+            typer.echo(f"   VAD threshold: {config.vad_threshold}")
+            typer.echo(f"   Min silence: {config.vad_min_silence_duration_ms}ms")
+        else:
+            typer.echo("VAD chunking: disabled")
+        typer.echo("=" * 60)
+
+        # Check if recordings directory exists
+        if config.recordings_path.exists():
+            typer.secho("[OK] Recordings directory exists", fg=typer.colors.GREEN)
+
+            # Count existing recordings
+            recordings = list(config.recordings_path.glob("*.wav"))
+            typer.echo(f"   {len(recordings)} recording(s) found")
+        else:
+            typer.secho("[WARN] Recordings directory does not exist (will be created)", fg=typer.colors.YELLOW)
+
+        typer.echo()
+        typer.echo("Tip: Use 'voicepad config input' to view and configure audio devices")
+
+    except Exception as e:
+        typer.secho(f"[ERROR] Error: {e}", fg=typer.colors.RED, err=True)
+        raise typer.Exit(1) from e

voicepad-0.1.1/src/voicepad/main.py

@@ -0,0 +1,18 @@
+import logging
+
+import typer
+
+from voicepad.cli import config_app, record_app
+
+logger = logging.getLogger(__name__)
+
+app = typer.Typer(
+    help="Voicepad - Voice recording and audio processing application",
+)
+
+app.add_typer(config_app, name="config", help="Configuration management commands")
+app.add_typer(record_app, name="record", help="Audio recording commands")
+
+
+def main() -> None:
+    app()