emdash-cli 0.1.30__py3-none-any.whl → 0.1.46__py3-none-any.whl

emdash_cli/commands/agent/handlers/auth.py

@@ -0,0 +1,69 @@
+"""Handler for /auth command."""
+
+from rich.console import Console
+
+console = Console()
+
+
+def handle_auth(args: str) -> None:
+    """Handle /auth command.
+
+    Args:
+        args: Command arguments
+    """
+    from emdash_core.auth.github import GitHubAuth, get_auth_status
+
+    # Parse subcommand
+    subparts = args.split(maxsplit=1) if args else []
+    subcommand = subparts[0].lower() if subparts else "status"
+
+    if subcommand == "status" or subcommand == "":
+        # Show auth status
+        status = get_auth_status()
+        console.print()
+        console.print("[bold cyan]GitHub Authentication[/bold cyan]\n")
+
+        if status["authenticated"]:
+            console.print(f"  Status: [green]Authenticated[/green]")
+            console.print(f"  Source: {status['source']}")
+            if status["username"]:
+                console.print(f"  Username: @{status['username']}")
+            if status["scopes"]:
+                console.print(f"  Scopes: {', '.join(status['scopes'])}")
+        else:
+            console.print(f"  Status: [yellow]Not authenticated[/yellow]")
+            console.print("\n[dim]Run /auth login to authenticate with GitHub[/dim]")
+
+        console.print()
+
+    elif subcommand == "login":
+        # Start GitHub OAuth device flow
+        console.print()
+        console.print("[bold cyan]GitHub Login[/bold cyan]")
+        console.print("[dim]Starting device authorization flow...[/dim]\n")
+
+        auth = GitHubAuth()
+        try:
+            config = auth.login(open_browser=True)
+            if config:
+                console.print()
+                console.print("[green]Authentication successful![/green]")
+                console.print("[dim]MCP servers can now use ${GITHUB_TOKEN}[/dim]")
+            else:
+                console.print("[red]Authentication failed or was cancelled.[/red]")
+        except Exception as e:
+            console.print(f"[red]Login failed: {e}[/red]")
+
+        console.print()
+
+    elif subcommand == "logout":
+        # Remove stored authentication
+        auth = GitHubAuth()
+        if auth.logout():
+            console.print("[green]Logged out successfully[/green]")
+        else:
+            console.print("[dim]No stored authentication to remove[/dim]")
+
+    else:
+        console.print(f"[yellow]Unknown subcommand: {subcommand}[/yellow]")
+        console.print("[dim]Usage: /auth [status|login|logout][/dim]")

emdash_cli/commands/agent/handlers/doctor.py

@@ -0,0 +1,319 @@
+"""Handler for /doctor command - environment diagnostics."""
+
+import os
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+
+console = Console()
+
+# Minimum required Python version
+MIN_PYTHON_VERSION = (3, 10)
+
+# Required packages
+REQUIRED_PACKAGES = [
+    "emdash-cli",
+    "emdash-core",
+    "click",
+    "rich",
+    "httpx",
+    "prompt_toolkit",
+]
+
+# Servers directory for per-repo servers
+SERVERS_DIR = Path.home() / ".emdash" / "servers"
+
+
+def check_python_version() -> tuple[bool, str, str]:
+    """Check Python version.
+
+    Returns:
+        Tuple of (passed, current_version, message)
+    """
+    current = sys.version_info[:2]
+    version_str = f"{current[0]}.{current[1]}"
+
+    if current >= MIN_PYTHON_VERSION:
+        return True, version_str, f"Python {version_str} (>= {MIN_PYTHON_VERSION[0]}.{MIN_PYTHON_VERSION[1]} required)"
+    else:
+        return False, version_str, f"Python {version_str} is below minimum {MIN_PYTHON_VERSION[0]}.{MIN_PYTHON_VERSION[1]}"
+
+
+def check_package_installed(package: str) -> tuple[bool, str]:
+    """Check if a package is installed.
+
+    Returns:
+        Tuple of (installed, version_or_error)
+    """
+    try:
+        from importlib.metadata import version
+        ver = version(package)
+        return True, ver
+    except Exception:
+        return False, "not installed"
+
+
+def check_git() -> tuple[bool, str]:
+    """Check if git is available.
+
+    Returns:
+        Tuple of (available, version_or_error)
+    """
+    try:
+        result = subprocess.run(
+            ["git", "--version"],
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+        version = result.stdout.strip().replace("git version ", "")
+        return True, version
+    except Exception:
+        return False, "not found"
+
+
+def check_git_repo() -> tuple[bool, str]:
+    """Check if current directory is a git repo.
+
+    Returns:
+        Tuple of (is_repo, message)
+    """
+    try:
+        result = subprocess.run(
+            ["git", "rev-parse", "--show-toplevel"],
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+        repo_path = result.stdout.strip()
+        return True, repo_path
+    except Exception:
+        return False, "not a git repository"
+
+
+def check_server_status() -> tuple[bool, str, list[dict]]:
+    """Check emdash server status.
+
+    Returns:
+        Tuple of (any_running, message, server_list)
+    """
+    import httpx
+
+    servers = []
+
+    # Check per-repo servers
+    if SERVERS_DIR.exists():
+        for port_file in SERVERS_DIR.glob("*.port"):
+            try:
+                port = int(port_file.read_text().strip())
+                hash_prefix = port_file.stem
+
+                # Get repo path
+                repo_file = SERVERS_DIR / f"{hash_prefix}.repo"
+                repo_path = repo_file.read_text().strip() if repo_file.exists() else "unknown"
+
+                # Check health
+                try:
+                    response = httpx.get(f"http://localhost:{port}/api/health", timeout=2.0)
+                    healthy = response.status_code == 200
+                except Exception:
+                    healthy = False
+
+                servers.append({
+                    "port": port,
+                    "repo": repo_path,
+                    "healthy": healthy,
+                })
+            except Exception:
+                pass
+
+    if servers:
+        healthy_count = sum(1 for s in servers if s["healthy"])
+        return True, f"{healthy_count}/{len(servers)} healthy", servers
+    else:
+        return False, "no servers running", []
+
+
+def check_api_keys() -> list[tuple[str, bool, str]]:
+    """Check for common API keys.
+
+    Returns:
+        List of (key_name, is_set, hint)
+    """
+    keys = [
+        ("ANTHROPIC_API_KEY", "Required for Claude models"),
+        ("OPENAI_API_KEY", "Required for OpenAI models"),
+        ("FIREWORKS_API_KEY", "Required for Fireworks models"),
+        ("GITHUB_TOKEN", "Required for GitHub integration"),
+    ]
+
+    results = []
+    for key, hint in keys:
+        is_set = bool(os.environ.get(key))
+        results.append((key, is_set, hint))
+
+    return results
+
+
+def check_disk_space() -> tuple[bool, str]:
+    """Check available disk space.
+
+    Returns:
+        Tuple of (sufficient, message)
+    """
+    try:
+        usage = shutil.disk_usage(Path.home())
+        free_gb = usage.free / (1024 ** 3)
+        if free_gb < 1:
+            return False, f"{free_gb:.1f} GB free (low!)"
+        else:
+            return True, f"{free_gb:.1f} GB free"
+    except Exception:
+        return True, "unknown"
+
+
+def check_path_config() -> list[tuple[str, bool, str]]:
+    """Check if common bin directories are in PATH.
+
+    Returns:
+        List of (path, in_path, description)
+    """
+    path_env = os.environ.get("PATH", "")
+    paths_to_check = [
+        (Path.home() / ".local" / "bin", "pipx installs"),
+        (Path.home() / ".pyenv" / "shims", "pyenv"),
+        (Path("/opt/homebrew/bin"), "Homebrew (Apple Silicon)"),
+        (Path("/usr/local/bin"), "Homebrew (Intel) / system"),
+    ]
+
+    results = []
+    for path, desc in paths_to_check:
+        in_path = str(path) in path_env
+        results.append((str(path), in_path, desc))
+
+    return results
+
+
+def handle_doctor(args: str) -> None:
+    """Handle /doctor command - run environment diagnostics."""
+    console.print()
+    console.print("[bold cyan]Emdash Doctor[/bold cyan] - Environment Diagnostics")
+    console.print()
+
+    issues = []
+
+    # Python Version
+    console.print("[bold]Python Environment[/bold]")
+    py_ok, py_ver, py_msg = check_python_version()
+    if py_ok:
+        console.print(f"  [green]✓[/green] {py_msg}")
+    else:
+        console.print(f"  [red]✗[/red] {py_msg}")
+        issues.append(("Python version", f"Upgrade to Python {MIN_PYTHON_VERSION[0]}.{MIN_PYTHON_VERSION[1]}+"))
+
+    console.print(f"  [dim]  Executable: {sys.executable}[/dim]")
+    console.print()
+
+    # Packages
+    console.print("[bold]Required Packages[/bold]")
+    for pkg in REQUIRED_PACKAGES:
+        installed, ver = check_package_installed(pkg)
+        if installed:
+            console.print(f"  [green]✓[/green] {pkg} ({ver})")
+        else:
+            console.print(f"  [red]✗[/red] {pkg} - {ver}")
+            issues.append((f"Package {pkg}", f"pip install {pkg}"))
+    console.print()
+
+    # Git
+    console.print("[bold]Git[/bold]")
+    git_ok, git_ver = check_git()
+    if git_ok:
+        console.print(f"  [green]✓[/green] git ({git_ver})")
+    else:
+        console.print(f"  [red]✗[/red] git not found")
+        issues.append(("Git", "Install git"))
+
+    repo_ok, repo_path = check_git_repo()
+    if repo_ok:
+        console.print(f"  [green]✓[/green] In git repo: {repo_path}")
+    else:
+        console.print(f"  [yellow]![/yellow] Not in a git repository")
+    console.print()
+
+    # Server Status
+    console.print("[bold]Emdash Server[/bold]")
+    srv_ok, srv_msg, servers = check_server_status()
+    if srv_ok:
+        console.print(f"  [green]✓[/green] Servers: {srv_msg}")
+        for srv in servers:
+            status = "[green]healthy[/green]" if srv["healthy"] else "[red]unhealthy[/red]"
+            repo_short = srv["repo"].split("/")[-1] if "/" in srv["repo"] else srv["repo"]
+            console.print(f"      Port {srv['port']}: {status} ({repo_short})")
+    else:
+        console.print(f"  [dim]-[/dim] {srv_msg}")
+    console.print()
+
+    # API Keys
+    console.print("[bold]API Keys[/bold]")
+    api_keys = check_api_keys()
+    for key, is_set, hint in api_keys:
+        if is_set:
+            console.print(f"  [green]✓[/green] {key} [dim]({hint})[/dim]")
+        else:
+            console.print(f"  [dim]-[/dim] {key} not set [dim]({hint})[/dim]")
+    console.print()
+
+    # System
+    console.print("[bold]System[/bold]")
+    disk_ok, disk_msg = check_disk_space()
+    if disk_ok:
+        console.print(f"  [green]✓[/green] Disk space: {disk_msg}")
+    else:
+        console.print(f"  [yellow]![/yellow] Disk space: {disk_msg}")
+        issues.append(("Disk space", "Free up disk space"))
+
+    # PATH check
+    path_results = check_path_config()
+    local_bin = Path.home() / ".local" / "bin"
+    local_bin_in_path = str(local_bin) in os.environ.get("PATH", "")
+    if local_bin_in_path:
+        console.print(f"  [green]✓[/green] ~/.local/bin in PATH (pipx)")
+    else:
+        console.print(f"  [red]✗[/red] ~/.local/bin not in PATH")
+        issues.append(("PATH config", "Run: pipx ensurepath && source ~/.zshrc"))
+    console.print()
+
+    # Summary
+    if issues:
+        console.print("[bold red]Issues Found:[/bold red]")
+        console.print()
+        for issue, fix in issues:
+            console.print(f"  [red]•[/red] {issue}")
+            console.print(f"    [dim]Fix: {fix}[/dim]")
+        console.print()
+
+        # Python upgrade instructions if needed
+        if not py_ok:
+            console.print("[bold]To upgrade Python:[/bold]")
+            console.print("  [cyan]macOS:[/cyan]     brew install python@3.12")
+            console.print("  [cyan]Ubuntu:[/cyan]    sudo apt install python3.12")
+            console.print("  [cyan]Windows:[/cyan]   winget install Python.Python.3.12")
+            console.print("  [cyan]pyenv:[/cyan]     pyenv install 3.12 && pyenv global 3.12")
+            console.print()
+
+        # PATH fix instructions if needed
+        if not local_bin_in_path:
+            console.print("[bold]To fix PATH (for pipx/em command):[/bold]")
+            console.print("  [cyan]Option 1:[/cyan]  pipx ensurepath")
+            console.print("  [cyan]Option 2:[/cyan]  echo 'export PATH=\"$HOME/.local/bin:$PATH\"' >> ~/.zshrc")
+            console.print("  [dim]Then restart your terminal or run: source ~/.zshrc[/dim]")
+            console.print()
+    else:
+        console.print("[bold green]All checks passed![/bold green]")
+        console.print()

emdash_cli/commands/agent/handlers/hooks.py

@@ -0,0 +1,121 @@
+"""Handler for /hooks command."""
+
+import hashlib
+from pathlib import Path
+
+from rich.console import Console
+
+console = Console()
+
+
+def handle_hooks(args: str) -> None:
+    """Handle /hooks command.
+
+    Args:
+        args: Command arguments
+    """
+    from emdash_core.agent.hooks import HookManager, HookConfig, HookEventType
+
+    manager = HookManager(Path.cwd())
+
+    # Parse subcommand
+    subparts = args.split(maxsplit=1) if args else []
+    subcommand = subparts[0].lower() if subparts else "list"
+    subargs = subparts[1].strip() if len(subparts) > 1 else ""
+
+    if subcommand == "list" or subcommand == "":
+        # List all hooks
+        hooks = manager.get_hooks()
+        if hooks:
+            console.print("\n[bold cyan]Configured Hooks[/bold cyan]\n")
+            for hook in hooks:
+                status = "[green]enabled[/green]" if hook.enabled else "[dim]disabled[/dim]"
+                console.print(f"  [cyan]{hook.id}[/cyan] ({status})")
+                console.print(f"    Event: [yellow]{hook.event.value}[/yellow]")
+                console.print(f"    Command: [dim]{hook.command}[/dim]")
+            console.print()
+            console.print(f"[dim]Config file: {manager.hooks_file_path}[/dim]\n")
+        else:
+            console.print("\n[dim]No hooks configured.[/dim]")
+            console.print("[dim]Add with: /hooks add <event> <command>[/dim]")
+            console.print(f"[dim]Events: {', '.join(e.value for e in HookEventType)}[/dim]\n")
+
+    elif subcommand == "add":
+        # Add a new hook: /hooks add <event> <command>
+        if not subargs:
+            console.print("[yellow]Usage: /hooks add <event> <command>[/yellow]")
+            console.print(f"[dim]Events: {', '.join(e.value for e in HookEventType)}[/dim]")
+            console.print("[dim]Example: /hooks add session_end notify-send 'Agent done'[/dim]")
+        else:
+            # Parse event and command
+            add_parts = subargs.split(maxsplit=1)
+            if len(add_parts) < 2:
+                console.print("[yellow]Usage: /hooks add <event> <command>[/yellow]")
+            else:
+                event_str = add_parts[0].lower()
+                hook_command = add_parts[1]
+
+                # Validate event type
+                try:
+                    event_type = HookEventType(event_str)
+                except ValueError:
+                    console.print(f"[red]Invalid event: {event_str}[/red]")
+                    console.print(f"[dim]Valid events: {', '.join(e.value for e in HookEventType)}[/dim]")
+                    return
+
+                # Generate a unique ID
+                hook_id = f"hook-{hashlib.md5(f'{event_str}{hook_command}'.encode()).hexdigest()[:8]}"
+
+                try:
+                    hook = HookConfig(
+                        id=hook_id,
+                        event=event_type,
+                        command=hook_command,
+                        enabled=True,
+                    )
+                    manager.add_hook(hook)
+                    console.print(f"[green]Added hook '{hook_id}'[/green]")
+                    console.print(f"[dim]Event: {event_type.value}, Command: {hook_command}[/dim]")
+                except ValueError as e:
+                    console.print(f"[red]Error: {e}[/red]")
+
+    elif subcommand == "remove":
+        if not subargs:
+            console.print("[yellow]Usage: /hooks remove <hook-id>[/yellow]")
+        else:
+            if manager.remove_hook(subargs):
+                console.print(f"[green]Removed hook '{subargs}'[/green]")
+            else:
+                console.print(f"[yellow]Hook '{subargs}' not found[/yellow]")
+
+    elif subcommand == "toggle":
+        if not subargs:
+            console.print("[yellow]Usage: /hooks toggle <hook-id>[/yellow]")
+        else:
+            new_state = manager.toggle_hook(subargs)
+            if new_state is not None:
+                state_str = "[green]enabled[/green]" if new_state else "[dim]disabled[/dim]"
+                console.print(f"Hook '{subargs}' is now {state_str}")
+            else:
+                console.print(f"[yellow]Hook '{subargs}' not found[/yellow]")
+
+    elif subcommand == "events":
+        # List available event types
+        console.print("\n[bold cyan]Available Hook Events[/bold cyan]\n")
+        event_descriptions = {
+            HookEventType.TOOL_START: "Triggered before a tool executes",
+            HookEventType.TOOL_RESULT: "Triggered after a tool completes",
+            HookEventType.SESSION_START: "Triggered when agent session starts",
+            HookEventType.SESSION_END: "Triggered when agent session ends",
+            HookEventType.RESPONSE: "Triggered when agent produces a response",
+            HookEventType.ERROR: "Triggered when an error occurs",
+        }
+        for event_type in HookEventType:
+            desc = event_descriptions.get(event_type, "")
+            console.print(f"  [cyan]{event_type.value}[/cyan]")
+            console.print(f"    [dim]{desc}[/dim]")
+        console.print()
+
+    else:
+        console.print(f"[yellow]Unknown subcommand: {subcommand}[/yellow]")
+        console.print("[dim]Usage: /hooks [list|add|remove|toggle|events][/dim]")

emdash_cli/commands/agent/handlers/mcp.py

@@ -0,0 +1,183 @@
+"""Handler for /mcp command."""
+
+import json
+import os
+import subprocess
+from pathlib import Path
+
+from rich.console import Console
+
+console = Console()
+
+
+def handle_mcp(args: str) -> None:
+    """Handle /mcp command.
+
+    Args:
+        args: Command arguments
+    """
+    from emdash_core.agent.mcp.manager import get_mcp_manager
+    from emdash_core.agent.mcp.config import get_default_mcp_config_path
+
+    manager = get_mcp_manager(config_path=get_default_mcp_config_path(Path.cwd()))
+
+    # Parse subcommand
+    subparts = args.split(maxsplit=1) if args else []
+    subcommand = subparts[0].lower() if subparts else ""
+
+    def _show_mcp_interactive():
+        """Show interactive MCP server list with toggle."""
+        from prompt_toolkit import Application
+        from prompt_toolkit.key_binding import KeyBindings
+        from prompt_toolkit.layout import Layout, Window, FormattedTextControl
+        from prompt_toolkit.styles import Style
+
+        servers = manager.list_servers()
+        if not servers:
+            console.print("\n[dim]No global MCP servers configured.[/dim]")
+            console.print(f"[dim]Edit {manager.config_path} to add servers[/dim]\n")
+            return None
+
+        selected_index = [0]
+        server_names = [s["name"] for s in servers]
+
+        kb = KeyBindings()
+
+        @kb.add("up")
+        @kb.add("k")
+        def move_up(event):
+            selected_index[0] = (selected_index[0] - 1) % len(servers)
+
+        @kb.add("down")
+        @kb.add("j")
+        def move_down(event):
+            selected_index[0] = (selected_index[0] + 1) % len(servers)
+
+        @kb.add("enter")
+        @kb.add("space")
+        def toggle_server(event):
+            # Toggle the selected server's enabled status
+            server_name = server_names[selected_index[0]]
+            config_path = manager.config_path
+
+            # Read current config
+            if config_path.exists():
+                with open(config_path) as f:
+                    config = json.load(f)
+            else:
+                config = {"mcpServers": {}}
+
+            # Toggle enabled status
+            if server_name in config.get("mcpServers", {}):
+                current = config["mcpServers"][server_name].get("enabled", True)
+                config["mcpServers"][server_name]["enabled"] = not current
+
+                # Save config
+                with open(config_path, "w") as f:
+                    json.dump(config, f, indent=2)
+
+                # Reload manager
+                manager.reload_config()
+
+                # Update local servers list
+                servers[:] = manager.list_servers()
+
+        @kb.add("e")
+        def edit_config(event):
+            event.app.exit(result="edit")
+
+        @kb.add("q")
+        @kb.add("escape")
+        def quit_menu(event):
+            event.app.exit()
+
+        def get_formatted_content():
+            lines = []
+            lines.append(("class:title", "Global MCP Servers\n"))
+            lines.append(("class:dim", f"Config: {manager.config_path}\n\n"))
+
+            for i, server in enumerate(servers):
+                if server["enabled"]:
+                    if server["running"]:
+                        status = "running"
+                        status_style = "class:running"
+                    else:
+                        status = "enabled"
+                        status_style = "class:enabled"
+                else:
+                    status = "disabled"
+                    status_style = "class:disabled"
+
+                if i == selected_index[0]:
+                    lines.append(("class:selected", f"  > {server['name']}"))
+                else:
+                    lines.append(("class:normal", f"    {server['name']}"))
+
+                lines.append((status_style, f" ({status})\n"))
+
+            lines.append(("class:hint", "\n↑/↓ navigate • Enter toggle • e edit • q quit"))
+            return lines
+
+        style = Style.from_dict({
+            "title": "#00cc66 bold",
+            "dim": "#888888",
+            "selected": "#00cc66 bold",
+            "normal": "#cccccc",
+            "running": "#00cc66",
+            "enabled": "#cccc00",
+            "disabled": "#888888",
+            "hint": "#888888 italic",
+        })
+
+        layout = Layout(Window(FormattedTextControl(get_formatted_content)))
+        app = Application(layout=layout, key_bindings=kb, style=style, full_screen=False)
+
+        result = app.run()
+        if result == "edit":
+            return "edit"
+        return None
+
+    if subcommand == "" or subcommand == "list":
+        # Show interactive menu (default)
+        result = _show_mcp_interactive()
+        if result == "edit":
+            subcommand = "edit"
+        else:
+            # Don't continue to edit
+            subcommand = "done"
+
+    if subcommand == "edit":
+        # Open MCP config in editor
+        config_path = manager.config_path
+
+        # Create default config if it doesn't exist
+        if not config_path.exists():
+            config_path.parent.mkdir(parents=True, exist_ok=True)
+            config_path.write_text('{\n  "mcpServers": {}\n}\n')
+            console.print(f"[dim]Created {config_path}[/dim]")
+
+        editor = os.environ.get("EDITOR", "")
+        if not editor:
+            for ed in ["code", "vim", "nano", "vi"]:
+                try:
+                    subprocess.run(["which", ed], capture_output=True, check=True)
+                    editor = ed
+                    break
+                except (subprocess.CalledProcessError, FileNotFoundError):
+                    continue
+
+        if editor:
+            console.print(f"[dim]Opening {config_path} in {editor}...[/dim]")
+            try:
+                subprocess.run([editor, str(config_path)])
+                manager.reload_config()
+                console.print("[dim]Config reloaded[/dim]")
+            except Exception as e:
+                console.print(f"[red]Failed to open editor: {e}[/red]")
+        else:
+            console.print(f"[yellow]No editor found. Edit manually:[/yellow]")
+            console.print(f"  {config_path}")
+
+    elif subcommand != "done":
+        console.print(f"[yellow]Unknown subcommand: {subcommand}[/yellow]")
+        console.print("[dim]Usage: /mcp [list|edit][/dim]")