wingman-ai 1.0.0__py3-none-any.whl

wingman/cli/commands/auth.py

@@ -0,0 +1,90 @@
+"""wingman auth - WhatsApp authentication."""
+
+import asyncio
+
+import typer
+from rich.console import Console
+from rich.panel import Panel
+
+from wingman.config.paths import WingmanPaths
+from wingman.config.settings import Settings
+
+console = Console()
+
+
+def auth() -> None:
+    """
+    Connect to WhatsApp by scanning a QR code.
+
+    Starts the WhatsApp listener in interactive mode to display
+    the QR code for authentication.
+    """
+    paths = WingmanPaths()
+
+    # Check if initialized
+    if not paths.is_initialized():
+        console.print("[red]Wingman is not set up yet.[/red]")
+        console.print("Run [bold]wingman init[/bold] first.")
+        raise typer.Exit(1)
+
+    console.print(
+        Panel.fit(
+            "[bold blue]WhatsApp Authentication[/bold blue]\n\n"
+            "A QR code will appear below.\n"
+            "Scan it with WhatsApp on your phone:\n\n"
+            "  1. Open WhatsApp\n"
+            "  2. Go to Settings > Linked Devices\n"
+            "  3. Tap 'Link a Device'\n"
+            "  4. Scan the QR code",
+            border_style="blue",
+        )
+    )
+    console.print()
+
+    # Load settings
+    settings = Settings.load(paths=paths)
+
+    # Run the auth process
+    try:
+        asyncio.run(_run_auth(settings))
+    except KeyboardInterrupt:
+        console.print()
+        console.print("[yellow]Authentication cancelled.[/yellow]")
+        raise typer.Exit(1)
+
+
+async def _run_auth(settings: Settings) -> None:
+    """Run the WhatsApp authentication process."""
+    from wingman.core.transports import WhatsAppTransport
+
+    connected = asyncio.Event()
+
+    transport = WhatsAppTransport(settings.node_dir, auth_state_dir=settings.auth_state_dir)
+
+    async def on_connected(user_id: str) -> None:
+        console.print()
+        console.print(f"[green]Connected as {user_id}[/green]")
+        console.print()
+        console.print("[bold green]Authentication successful![/bold green]")
+        console.print("You can now run [bold]wingman start[/bold] to start the bot.")
+        connected.set()
+
+    async def on_qr_code() -> None:
+        console.print("[dim]QR code displayed above - scan with WhatsApp[/dim]")
+
+    transport.set_connected_handler(on_connected)
+    transport.set_qr_code_handler(on_qr_code)
+
+    # Start transport and wait for connection
+    async def run_until_connected():
+        asyncio.create_task(transport.start())
+        try:
+            # Wait for connection or timeout
+            await asyncio.wait_for(connected.wait(), timeout=300)  # 5 minute timeout
+        except asyncio.TimeoutError:
+            console.print("[red]Authentication timed out.[/red]")
+            console.print("Please try again with [bold]wingman auth[/bold]")
+        finally:
+            await transport.stop()
+
+    await run_until_connected()

wingman/cli/commands/config.py

@@ -0,0 +1,109 @@
+"""wingman config - Edit configuration."""
+
+import subprocess
+
+import typer
+from rich.console import Console
+from rich.syntax import Syntax
+
+from wingman.config.paths import WingmanPaths
+
+console = Console()
+
+
+def config(
+    edit: bool = typer.Option(
+        False,
+        "--edit",
+        "-e",
+        help="Open config file in editor",
+    ),
+    show: bool = typer.Option(
+        False,
+        "--show",
+        "-s",
+        help="Show current config",
+    ),
+    path: bool = typer.Option(
+        False,
+        "--path",
+        "-p",
+        help="Show config file path",
+    ),
+) -> None:
+    """
+    View or edit Wingman configuration.
+
+    Without options, shows an overview of config options.
+    """
+    paths = WingmanPaths()
+
+    if not paths.config_exists():
+        console.print("[red]Wingman is not set up yet.[/red]")
+        console.print("Run [bold]wingman init[/bold] first.")
+        raise typer.Exit(1)
+
+    if path:
+        console.print(str(paths.config_file))
+        return
+
+    if show:
+        _show_config(paths)
+        return
+
+    if edit:
+        _edit_config(paths)
+        return
+
+    # Default: show overview
+    console.print("[bold]Wingman Configuration[/bold]")
+    console.print()
+    console.print(f"Config file: {paths.config_file}")
+    console.print()
+    console.print("Commands:")
+    console.print("  [bold]wingman config --show[/bold]   Show current config")
+    console.print("  [bold]wingman config --edit[/bold]   Open in editor")
+    console.print("  [bold]wingman config --path[/bold]   Print config path")
+    console.print()
+    console.print("Config files:")
+    console.print(f"  Main config:  {paths.config_file}")
+    console.print(f"  Contacts:     {paths.contacts_config}")
+    console.print(f"  Groups:       {paths.groups_config}")
+    console.print(f"  Policies:     {paths.policies_config}")
+
+
+def _show_config(paths: WingmanPaths) -> None:
+    """Show the current config file contents."""
+    config_file = paths.config_file
+
+    if not config_file.exists():
+        console.print("[yellow]Config file not found.[/yellow]")
+        return
+
+    with open(config_file) as f:
+        content = f.read()
+
+    syntax = Syntax(content, "yaml", theme="monokai", line_numbers=True)
+    console.print(syntax)
+
+
+def _edit_config(paths: WingmanPaths) -> None:
+    """Open config file in user's editor."""
+    import os
+
+    config_file = paths.config_file
+
+    # Get editor from environment
+    editor = os.environ.get("EDITOR", os.environ.get("VISUAL", "nano"))
+
+    console.print(f"[dim]Opening {config_file} in {editor}...[/dim]")
+
+    try:
+        subprocess.run([editor, str(config_file)], check=True)
+    except FileNotFoundError:
+        console.print(f"[red]Editor not found: {editor}[/red]")
+        console.print("Set the EDITOR environment variable to your preferred editor.")
+        raise typer.Exit(1)
+    except subprocess.CalledProcessError as e:
+        console.print(f"[red]Editor exited with error: {e}[/red]")
+        raise typer.Exit(1)

wingman/cli/commands/init.py

@@ -0,0 +1,71 @@
+"""wingman init - Interactive setup wizard."""
+
+import typer
+from rich.console import Console
+from rich.panel import Panel
+
+from wingman.cli.wizard import SetupWizard
+from wingman.config.paths import WingmanPaths
+
+console = Console()
+
+
+def init(
+    force: bool = typer.Option(
+        False,
+        "--force",
+        "-f",
+        help="Overwrite existing configuration",
+    ),
+) -> None:
+    """
+    Interactive setup wizard for Wingman.
+
+    Sets up OpenAI API key, bot personality, safety settings,
+    and installs the WhatsApp listener.
+    """
+    console.print(
+        Panel.fit(
+            "[bold blue]Welcome to Wingman![/bold blue]\n\n"
+            "This wizard will help you set up your personal AI chat agent.",
+            border_style="blue",
+        )
+    )
+    console.print()
+
+    paths = WingmanPaths()
+
+    # Check if already initialized
+    if paths.is_initialized() and not force:
+        console.print("[yellow]Wingman is already set up![/yellow]")
+        console.print(f"Config location: {paths.config_dir}")
+        console.print()
+        console.print("To reconfigure, run: [bold]wingman init --force[/bold]")
+        console.print("To connect WhatsApp, run: [bold]wingman auth[/bold]")
+        console.print("To start the bot, run: [bold]wingman start[/bold]")
+        raise typer.Exit()
+
+    # Run setup wizard
+    wizard = SetupWizard(paths, console)
+
+    try:
+        success = wizard.run()
+        if success:
+            console.print()
+            console.print(
+                Panel.fit(
+                    "[bold green]Setup complete![/bold green]\n\n"
+                    "Next steps:\n"
+                    "  1. Run [bold]wingman auth[/bold] to connect WhatsApp\n"
+                    "  2. Run [bold]wingman start[/bold] to start the bot",
+                    border_style="green",
+                )
+            )
+        else:
+            console.print()
+            console.print("[red]Setup incomplete. Please try again.[/red]")
+            raise typer.Exit(1)
+    except KeyboardInterrupt:
+        console.print()
+        console.print("[yellow]Setup cancelled.[/yellow]")
+        raise typer.Exit(1)

wingman/cli/commands/logs.py

@@ -0,0 +1,84 @@
+"""wingman logs - View bot logs."""
+
+import subprocess
+
+import typer
+from rich.console import Console
+
+from wingman.config.paths import WingmanPaths
+
+console = Console()
+
+
+def logs(
+    follow: bool = typer.Option(
+        True,
+        "--follow/--no-follow",
+        "-f/-F",
+        help="Follow log output (stream new lines)",
+    ),
+    lines: int = typer.Option(
+        50,
+        "--lines",
+        "-n",
+        help="Number of lines to show",
+    ),
+    error: bool = typer.Option(
+        False,
+        "--error",
+        "-e",
+        help="Show error log instead of main log",
+    ),
+) -> None:
+    """
+    View Wingman activity logs.
+
+    Streams the log file in real-time by default.
+    Use --no-follow to just show recent lines.
+    """
+    paths = WingmanPaths()
+
+    # Determine log file
+    log_file = paths.log_dir / ("agent.log" if not error else "error.log")
+
+    if not log_file.exists():
+        console.print(f"[yellow]Log file not found: {log_file}[/yellow]")
+        console.print("Wingman may not have run yet.")
+        raise typer.Exit(1)
+
+    console.print(f"[dim]Log file: {log_file}[/dim]")
+    console.print()
+
+    # Use tail to show/follow logs
+    try:
+        cmd = ["tail"]
+        if follow:
+            cmd.append("-f")
+        cmd.extend(["-n", str(lines), str(log_file)])
+
+        # Run tail and stream output
+        process = subprocess.Popen(
+            cmd,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True,
+        )
+
+        try:
+            for line in process.stdout:
+                # Color-code log levels
+                if "ERROR" in line:
+                    console.print(f"[red]{line.rstrip()}[/red]")
+                elif "WARNING" in line:
+                    console.print(f"[yellow]{line.rstrip()}[/yellow]")
+                elif "INFO" in line:
+                    console.print(line.rstrip())
+                else:
+                    console.print(f"[dim]{line.rstrip()}[/dim]")
+        except KeyboardInterrupt:
+            process.terminate()
+            console.print()
+
+    except FileNotFoundError:
+        console.print("[red]tail command not found[/red]")
+        raise typer.Exit(1)

wingman/cli/commands/start.py

@@ -0,0 +1,111 @@
+"""wingman start - Start the bot."""
+
+import asyncio
+
+import typer
+from rich.console import Console
+from rich.panel import Panel
+
+from wingman.config.paths import WingmanPaths
+from wingman.config.settings import Settings
+
+console = Console()
+
+
+def start(
+    foreground: bool = typer.Option(
+        False,
+        "--foreground",
+        "-f",
+        help="Run in foreground instead of as daemon",
+    ),
+) -> None:
+    """
+    Start the Wingman bot.
+
+    By default, starts as a background daemon (macOS launchd).
+    Use --foreground to run in the current terminal.
+    """
+    paths = WingmanPaths()
+
+    # Check if initialized
+    if not paths.is_initialized():
+        console.print("[red]Wingman is not set up yet.[/red]")
+        console.print("Run [bold]wingman init[/bold] first.")
+        raise typer.Exit(1)
+
+    # Check if auth state exists
+    if not paths.auth_state_dir.exists() or not any(paths.auth_state_dir.iterdir()):
+        console.print("[red]WhatsApp is not connected.[/red]")
+        console.print("Run [bold]wingman auth[/bold] first.")
+        raise typer.Exit(1)
+
+    # Load settings
+    settings = Settings.load(paths=paths)
+
+    # Validate settings
+    errors = settings.validate()
+    if errors:
+        console.print("[red]Configuration errors:[/red]")
+        for error in errors:
+            console.print(f"  - {error}")
+        raise typer.Exit(1)
+
+    if foreground:
+        # Run in foreground
+        console.print(
+            Panel.fit(
+                "[bold blue]Starting Wingman[/bold blue]\n\n"
+                f"Bot name: {settings.bot_name}\n"
+                f"Model: {settings.openai_model}\n\n"
+                "Press Ctrl+C to stop.",
+                border_style="blue",
+            )
+        )
+        console.print()
+
+        try:
+            asyncio.run(_run_foreground(settings))
+        except KeyboardInterrupt:
+            console.print()
+            console.print("[yellow]Wingman stopped.[/yellow]")
+    else:
+        # Start as daemon
+        _start_daemon(paths, settings)
+
+
+async def _run_foreground(settings: Settings) -> None:
+    """Run the bot in foreground mode."""
+    from wingman.core.agent import run_agent
+
+    await run_agent(settings)
+
+
+def _start_daemon(paths: WingmanPaths, settings: Settings) -> None:
+    """Start the bot as a background daemon."""
+    from wingman.daemon import DaemonManager
+
+    daemon = DaemonManager(paths)
+
+    # Check if already running
+    if daemon.is_running():
+        pid = daemon.get_pid()
+        console.print(f"[yellow]Wingman is already running (PID: {pid})[/yellow]")
+        console.print("Run [bold]wingman stop[/bold] to stop it first.")
+        raise typer.Exit(1)
+
+    # Start daemon
+    console.print("[blue]Starting Wingman as background service...[/blue]")
+
+    try:
+        daemon.start()
+        console.print()
+        console.print("[green]Wingman started as background service.[/green]")
+        console.print()
+        console.print("Commands:")
+        console.print("  [bold]wingman status[/bold]  - Check if running")
+        console.print("  [bold]wingman logs[/bold]    - View activity logs")
+        console.print("  [bold]wingman stop[/bold]    - Stop the bot")
+    except Exception as e:
+        console.print(f"[red]Failed to start daemon: {e}[/red]")
+        raise typer.Exit(1)

wingman/cli/commands/status.py

@@ -0,0 +1,84 @@
+"""wingman status - Check bot status."""
+
+from rich.console import Console
+from rich.table import Table
+
+from wingman.config.paths import WingmanPaths
+from wingman.config.settings import Settings
+
+console = Console()
+
+
+def status() -> None:
+    """
+    Check the status of the Wingman bot.
+    """
+    paths = WingmanPaths()
+
+    # Check initialization status
+    is_initialized = paths.is_initialized()
+    config_exists = paths.config_exists()
+
+    # Create status table
+    table = Table(title="Wingman Status", show_header=False, box=None)
+    table.add_column("Item", style="bold")
+    table.add_column("Status")
+
+    # Setup status
+    if is_initialized:
+        table.add_row("Setup", "[green]Complete[/green]")
+    elif config_exists:
+        table.add_row("Setup", "[yellow]Partial (run wingman init)[/yellow]")
+    else:
+        table.add_row("Setup", "[red]Not initialized (run wingman init)[/red]")
+
+    # Config location
+    table.add_row("Config", str(paths.config_dir))
+
+    # WhatsApp auth status
+    has_auth = paths.auth_state_dir.exists() and any(paths.auth_state_dir.iterdir())
+    if has_auth:
+        table.add_row("WhatsApp", "[green]Connected[/green]")
+    else:
+        table.add_row("WhatsApp", "[yellow]Not connected (run wingman auth)[/yellow]")
+
+    # Running status
+    from wingman.daemon import DaemonManager
+
+    daemon = DaemonManager(paths)
+
+    if daemon.is_running():
+        pid = daemon.get_pid()
+        uptime = daemon.get_uptime()
+        uptime_str = _format_uptime(uptime) if uptime else "unknown"
+        table.add_row("Status", f"[green]Running[/green] (PID: {pid})")
+        table.add_row("Uptime", uptime_str)
+    else:
+        table.add_row("Status", "[dim]Not running[/dim]")
+
+    # Load settings for additional info
+    if config_exists:
+        try:
+            settings = Settings.load(paths=paths)
+            table.add_row("Bot Name", settings.bot_name)
+            table.add_row("Model", settings.openai_model)
+        except Exception:
+            pass
+
+    console.print()
+    console.print(table)
+    console.print()
+
+
+def _format_uptime(seconds: float) -> str:
+    """Format uptime in human-readable format."""
+    if seconds < 60:
+        return f"{int(seconds)}s"
+    elif seconds < 3600:
+        mins = int(seconds / 60)
+        secs = int(seconds % 60)
+        return f"{mins}m {secs}s"
+    else:
+        hours = int(seconds / 3600)
+        mins = int((seconds % 3600) / 60)
+        return f"{hours}h {mins}m"

wingman/cli/commands/stop.py

@@ -0,0 +1,33 @@
+"""wingman stop - Stop the bot."""
+
+import typer
+from rich.console import Console
+
+from wingman.config.paths import WingmanPaths
+
+console = Console()
+
+
+def stop() -> None:
+    """
+    Stop the running Wingman bot.
+    """
+    paths = WingmanPaths()
+
+    from wingman.daemon import DaemonManager
+
+    daemon = DaemonManager(paths)
+
+    if not daemon.is_running():
+        console.print("[yellow]Wingman is not running.[/yellow]")
+        raise typer.Exit()
+
+    pid = daemon.get_pid()
+    console.print(f"[blue]Stopping Wingman (PID: {pid})...[/blue]")
+
+    try:
+        daemon.stop()
+        console.print("[green]Wingman stopped.[/green]")
+    except Exception as e:
+        console.print(f"[red]Failed to stop daemon: {e}[/red]")
+        raise typer.Exit(1)

wingman/cli/commands/uninstall.py

@@ -0,0 +1,113 @@
+"""wingman uninstall - Remove Wingman completely."""
+
+import shutil
+
+import typer
+from rich.console import Console
+
+from wingman.config.paths import WingmanPaths
+
+console = Console()
+
+
+def uninstall(
+    keep_config: bool = typer.Option(
+        False,
+        "--keep-config",
+        "-k",
+        help="Keep configuration files (only remove data and stop daemon)",
+    ),
+    force: bool = typer.Option(
+        False,
+        "--force",
+        "-f",
+        help="Don't ask for confirmation",
+    ),
+) -> None:
+    """
+    Uninstall Wingman and remove all data.
+
+    This will:
+    - Stop the running daemon
+    - Remove the launchd service (macOS)
+    - Remove config files (unless --keep-config)
+    - Remove data files (database, auth state)
+    - Remove log files
+
+    After running this, you can run `pip uninstall wingman-ai` to
+    remove the package itself.
+    """
+    paths = WingmanPaths()
+
+    # Show what will be removed
+    console.print("[bold]This will remove:[/bold]")
+    console.print()
+
+    if not keep_config:
+        console.print(f"  Config:  {paths.config_dir}")
+    console.print(f"  Data:    {paths.data_dir}")
+    console.print(f"  Logs:    {paths.cache_dir}")
+
+    if paths.launchd_plist.exists():
+        console.print(f"  Service: {paths.launchd_plist}")
+
+    console.print()
+
+    # Confirm
+    if not force:
+        confirm = typer.confirm("Are you sure you want to uninstall Wingman?")
+        if not confirm:
+            console.print("[yellow]Uninstall cancelled.[/yellow]")
+            raise typer.Exit()
+
+    # Stop daemon first
+    from wingman.daemon import DaemonManager
+
+    daemon = DaemonManager(paths)
+
+    if daemon.is_running():
+        console.print("[blue]Stopping daemon...[/blue]")
+        try:
+            daemon.stop()
+        except Exception as e:
+            console.print(f"[yellow]Warning: Could not stop daemon: {e}[/yellow]")
+
+    # Remove launchd service
+    daemon.uninstall()
+
+    # Remove directories
+    removed = []
+
+    if not keep_config and paths.config_dir.exists():
+        try:
+            shutil.rmtree(paths.config_dir)
+            removed.append("config")
+        except Exception as e:
+            console.print(f"[yellow]Warning: Could not remove config: {e}[/yellow]")
+
+    if paths.data_dir.exists():
+        try:
+            shutil.rmtree(paths.data_dir)
+            removed.append("data")
+        except Exception as e:
+            console.print(f"[yellow]Warning: Could not remove data: {e}[/yellow]")
+
+    if paths.cache_dir.exists():
+        try:
+            shutil.rmtree(paths.cache_dir)
+            removed.append("logs")
+        except Exception as e:
+            console.print(f"[yellow]Warning: Could not remove logs: {e}[/yellow]")
+
+    console.print()
+    console.print("[green]Wingman uninstalled successfully.[/green]")
+
+    if removed:
+        console.print(f"Removed: {', '.join(removed)}")
+
+    if keep_config:
+        console.print(f"[dim]Config preserved at: {paths.config_dir}[/dim]")
+
+    console.print()
+    console.print("To remove the package, run:")
+    console.print("  [bold]pip uninstall wingman-ai[/bold]")