emdash-cli 0.1.35__py3-none-any.whl → 0.1.67__py3-none-any.whl

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/index.py

@@ -0,0 +1,183 @@
+"""Handler for /index command."""
+
+import os
+from pathlib import Path
+
+from rich.console import Console
+
+console = Console()
+
+
+def handle_index(args: str, client) -> None:
+    """Handle /index command.
+
+    Args:
+        args: Command arguments (status, start, hook install/uninstall)
+        client: EmdashClient instance
+    """
+    # Parse subcommand
+    subparts = args.split(maxsplit=1) if args else []
+    subcommand = subparts[0].lower() if subparts else "status"
+    subargs = subparts[1].strip() if len(subparts) > 1 else ""
+
+    repo_path = os.getcwd()
+
+    if subcommand == "status":
+        _show_status(client, repo_path)
+
+    elif subcommand == "start":
+        _start_index(client, repo_path, subargs)
+
+    elif subcommand == "hook":
+        _handle_hook(repo_path, subargs)
+
+    else:
+        console.print(f"[yellow]Unknown subcommand: {subcommand}[/yellow]")
+        console.print("[dim]Usage: /index [status|start|hook][/dim]")
+        console.print("[dim]  /index              - Show index status[/dim]")
+        console.print("[dim]  /index start        - Start incremental indexing[/dim]")
+        console.print("[dim]  /index start --full - Force full reindex[/dim]")
+        console.print("[dim]  /index hook install - Install post-commit hook[/dim]")
+        console.print("[dim]  /index hook uninstall - Remove post-commit hook[/dim]")
+
+
+def _show_status(client, repo_path: str) -> None:
+    """Show index status."""
+    try:
+        status = client.index_status(repo_path)
+
+        console.print("\n[bold cyan]Index Status[/bold cyan]\n")
+        is_indexed = status.get("is_indexed", False)
+        console.print(f"  Indexed: {'[green]Yes[/green]' if is_indexed else '[yellow]No[/yellow]'}")
+
+        if is_indexed:
+            console.print(f"  Files: {status.get('file_count', 0)}")
+            console.print(f"  Functions: {status.get('function_count', 0)}")
+            console.print(f"  Classes: {status.get('class_count', 0)}")
+            console.print(f"  Communities: {status.get('community_count', 0)}")
+
+            if status.get("last_indexed"):
+                console.print(f"  Last indexed: {status.get('last_indexed')}")
+            if status.get("last_commit"):
+                console.print(f"  Last commit: {status.get('last_commit')[:8]}")
+
+        # Check hook status
+        hooks_dir = Path(repo_path) / ".git" / "hooks"
+        hook_path = hooks_dir / "post-commit"
+        if hook_path.exists() and "emdash" in hook_path.read_text():
+            console.print(f"  Auto-index: [green]Enabled[/green] (post-commit hook)")
+        else:
+            console.print(f"  Auto-index: [dim]Disabled[/dim] (run /index hook install)")
+
+        console.print()
+
+    except Exception as e:
+        console.print(f"[red]Error getting status: {e}[/red]")
+
+
+def _start_index(client, repo_path: str, args: str) -> None:
+    """Start indexing."""
+    import json
+    from rich.progress import Progress, BarColumn, TaskProgressColumn, TextColumn
+
+    # Parse options
+    full = "--full" in args
+
+    console.print(f"\n[bold cyan]Indexing[/bold cyan] {repo_path}\n")
+
+    try:
+        with Progress(
+            TextColumn("[bold cyan]{task.description}[/bold cyan]"),
+            BarColumn(bar_width=40, complete_style="cyan", finished_style="green"),
+            TaskProgressColumn(),
+            console=console,
+            transient=True,
+        ) as progress:
+            task = progress.add_task("Starting...", total=100)
+
+            for line in client.index_start_stream(repo_path, not full):
+                line = line.strip()
+                if line.startswith("event: "):
+                    continue
+                if line.startswith("data: "):
+                    try:
+                        data = json.loads(line[6:])
+                        step = data.get("step") or data.get("message", "")
+                        percent = data.get("percent")
+
+                        if step:
+                            progress.update(task, description=step)
+                        if percent is not None:
+                            progress.update(task, completed=percent)
+                    except json.JSONDecodeError:
+                        pass
+
+            progress.update(task, completed=100, description="Complete")
+
+        console.print("[bold green]Indexing complete![/bold green]\n")
+
+    except Exception as e:
+        console.print(f"[red]Error: {e}[/red]")
+
+
+def _handle_hook(repo_path: str, args: str) -> None:
+    """Handle hook install/uninstall."""
+    action = args.lower() if args else ""
+
+    if action not in ("install", "uninstall"):
+        console.print("[yellow]Usage: /index hook [install|uninstall][/yellow]")
+        return
+
+    hooks_dir = Path(repo_path) / ".git" / "hooks"
+    hook_path = hooks_dir / "post-commit"
+
+    if not hooks_dir.exists():
+        console.print(f"[red]Error:[/red] Not a git repository: {repo_path}")
+        return
+
+    hook_content = """#!/bin/sh
+# emdash post-commit hook - auto-reindex on commit
+# Installed by: emdash index hook install
+
+# Run indexing in background to not block the commit
+emdash index start > /dev/null 2>&1 &
+"""
+
+    if action == "install":
+        if hook_path.exists():
+            existing = hook_path.read_text()
+            if "emdash" in existing:
+                console.print("[yellow]Hook already installed[/yellow]")
+                return
+            else:
+                console.print("[yellow]Appending to existing post-commit hook[/yellow]")
+                with open(hook_path, "a") as f:
+                    f.write("\n# emdash auto-index\nemdash index start > /dev/null 2>&1 &\n")
+        else:
+            hook_path.write_text(hook_content)
+
+        hook_path.chmod(0o755)
+        console.print(f"[green]Post-commit hook installed[/green]")
+        console.print("[dim]Index will update automatically after each commit[/dim]")
+
+    elif action == "uninstall":
+        if not hook_path.exists():
+            console.print("[yellow]No post-commit hook found[/yellow]")
+            return
+
+        existing = hook_path.read_text()
+        if "emdash" not in existing:
+            console.print("[yellow]No emdash hook found in post-commit[/yellow]")
+            return
+
+        if existing.strip() == hook_content.strip():
+            hook_path.unlink()
+            console.print("[green]Post-commit hook removed[/green]")
+        else:
+            lines = existing.split("\n")
+            new_lines = [
+                line for line in lines
+                if "emdash" not in line and "auto-reindex" not in line
+            ]
+            hook_path.write_text("\n".join(new_lines))
+            console.print("[green]Emdash hook lines removed from post-commit[/green]")