emdash-cli 0.1.4__py3-none-any.whl

emdash_cli/main.py

@@ -0,0 +1,104 @@
+"""Main CLI entry point for emdash-cli."""
+
+import click
+
+from .commands import (
+    agent,
+    db,
+    auth,
+    analyze,
+    embed,
+    index,
+    plan,
+    rules,
+    search,
+    server,
+    team,
+    swarm,
+    projectmd,
+    research,
+    spec,
+    tasks,
+)
+
+
+@click.group()
+@click.version_option()
+def cli():
+    """EmDash - The 'Senior Engineer' Context Engine.
+
+    A graph-based coding intelligence system powered by AI.
+    """
+    pass
+
+
+# Register command groups
+cli.add_command(agent)
+cli.add_command(db)
+cli.add_command(auth)
+cli.add_command(analyze)
+cli.add_command(embed)
+cli.add_command(index)
+cli.add_command(plan)
+cli.add_command(rules)
+cli.add_command(server)
+cli.add_command(team)
+cli.add_command(swarm)
+
+# Register standalone commands
+cli.add_command(search)
+cli.add_command(projectmd)
+cli.add_command(research)
+cli.add_command(spec)
+cli.add_command(tasks)
+
+# Add killall as top-level alias for server killall
+from .commands.server import server_killall
+cli.add_command(server_killall, name="killall")
+
+
+# Direct entry point for `em` command - wraps agent_code with click
+@click.command()
+@click.argument("task", required=False)
+@click.option("--model", "-m", default=None, help="Model to use")
+@click.option("--mode", type=click.Choice(["plan", "tasks", "code"]), default="code",
+              help="Starting mode")
+@click.option("--quiet", "-q", is_flag=True, help="Less verbose output")
+@click.option("--max-iterations", default=20, help="Max agent iterations")
+@click.option("--no-graph-tools", is_flag=True, help="Skip graph exploration tools")
+@click.option("--save", is_flag=True, help="Save specs to specs/<feature>/")
+def start_coding_agent(
+    task: str | None,
+    model: str | None,
+    mode: str,
+    quiet: bool,
+    max_iterations: int,
+    no_graph_tools: bool,
+    save: bool,
+):
+    """EmDash Coding Agent - AI-powered code assistant.
+
+    Start interactive mode or run a single task.
+
+    Examples:
+        em                        # Interactive mode
+        em "Fix the login bug"    # Single task
+        em --mode plan            # Start in plan mode
+    """
+    # Import and call agent_code directly
+    from .commands.agent import agent_code as _agent_code
+    ctx = click.Context(_agent_code)
+    ctx.invoke(
+        _agent_code,
+        task=task,
+        model=model,
+        mode=mode,
+        quiet=quiet,
+        max_iterations=max_iterations,
+        no_graph_tools=no_graph_tools,
+        save=save,
+    )
+
+
+if __name__ == "__main__":
+    cli()

emdash_cli/server_manager.py

@@ -0,0 +1,231 @@
+"""Server lifecycle management for emdash-core."""
+
+import atexit
+import os
+import signal
+import socket
+import subprocess
+import sys
+import time
+from pathlib import Path
+from typing import Optional
+
+import httpx
+
+
+class ServerManager:
+    """Manages FastAPI server lifecycle for CLI.
+
+    The ServerManager handles:
+    - Discovering running servers via port file
+    - Starting new servers when needed
+    - Health checking servers
+    - Graceful shutdown on CLI exit
+    """
+
+    DEFAULT_PORT = 8765
+    PORT_FILE = Path.home() / ".emdash" / "server.port"
+    PID_FILE = Path.home() / ".emdash" / "server.pid"
+    STARTUP_TIMEOUT = 30.0  # seconds
+    HEALTH_TIMEOUT = 2.0  # seconds
+
+    def __init__(self, repo_root: Optional[Path] = None):
+        """Initialize the server manager.
+
+        Args:
+            repo_root: Repository root path (for server to use)
+        """
+        self.repo_root = repo_root or self._detect_repo_root()
+        self.process: Optional[subprocess.Popen] = None
+        self.port: Optional[int] = None
+        self._started_by_us = False
+
+    def get_server_url(self) -> str:
+        """Get URL of running server, starting one if needed.
+
+        Returns:
+            Base URL of the running server (e.g., "http://localhost:8765")
+
+        Raises:
+            RuntimeError: If server fails to start
+        """
+        # Check if server already running
+        if self.PORT_FILE.exists():
+            try:
+                port = int(self.PORT_FILE.read_text().strip())
+                if self._check_health(port):
+                    self.port = port
+                    return f"http://localhost:{port}"
+            except (ValueError, IOError):
+                pass
+
+        # Start new server
+        self.port = self._find_free_port()
+        self._spawn_server()
+        return f"http://localhost:{self.port}"
+
+    def ensure_server(self) -> str:
+        """Ensure server is running and return URL.
+
+        Alias for get_server_url() for clearer intent.
+        """
+        return self.get_server_url()
+
+    def shutdown(self) -> None:
+        """Shutdown the server if we started it."""
+        if self._started_by_us and self.process:
+            try:
+                self.process.terminate()
+                self.process.wait(timeout=5)
+            except subprocess.TimeoutExpired:
+                self.process.kill()
+            finally:
+                self._cleanup_files()
+                self.process = None
+
+    def _detect_repo_root(self) -> Path:
+        """Detect repository root from current directory."""
+        try:
+            result = subprocess.run(
+                ["git", "rev-parse", "--show-toplevel"],
+                capture_output=True,
+                text=True,
+                check=True,
+            )
+            return Path(result.stdout.strip())
+        except subprocess.CalledProcessError:
+            return Path.cwd()
+
+    def _find_free_port(self) -> int:
+        """Find an available port."""
+        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+            s.bind(("", 0))
+            s.listen(1)
+            return s.getsockname()[1]
+
+    def _spawn_server(self) -> None:
+        """Spawn FastAPI server as subprocess."""
+        # Find emdash-core module
+        core_module = self._find_core_module()
+
+        cmd = [
+            sys.executable,
+            "-m", "emdash_core.server",
+            "--port", str(self.port),
+            "--host", "127.0.0.1",
+        ]
+
+        if self.repo_root:
+            cmd.extend(["--repo-root", str(self.repo_root)])
+
+        # Set environment to include core package
+        env = os.environ.copy()
+        if core_module:
+            python_path = env.get("PYTHONPATH", "")
+            env["PYTHONPATH"] = f"{core_module}:{python_path}" if python_path else str(core_module)
+
+        self.process = subprocess.Popen(
+            cmd,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            env=env,
+        )
+
+        self._started_by_us = True
+
+        # Register cleanup for normal exit
+        atexit.register(self.shutdown)
+
+        # Register signal handlers for Ctrl+C and termination
+        self._register_signal_handlers()
+
+        # Wait for server ready
+        self._wait_for_ready()
+
+    def _register_signal_handlers(self) -> None:
+        """Register signal handlers for graceful shutdown."""
+        def signal_handler(_signum, _frame):
+            self.shutdown()
+            sys.exit(0)
+
+        # Handle SIGINT (Ctrl+C) and SIGTERM
+        signal.signal(signal.SIGINT, signal_handler)
+        signal.signal(signal.SIGTERM, signal_handler)
+
+    def _find_core_module(self) -> Optional[Path]:
+        """Find the emdash-core package directory."""
+        # Check relative to this file (for development)
+        cli_dir = Path(__file__).parent.parent
+        core_dir = cli_dir.parent / "core"
+        if (core_dir / "emdash_core").exists():
+            return core_dir
+        return None
+
+    def _check_health(self, port: int) -> bool:
+        """Check if server is healthy.
+
+        Args:
+            port: Port to check
+
+        Returns:
+            True if server responds to health check
+        """
+        try:
+            response = httpx.get(
+                f"http://localhost:{port}/api/health",
+                timeout=self.HEALTH_TIMEOUT,
+            )
+            return response.status_code == 200
+        except (httpx.RequestError, httpx.TimeoutException):
+            return False
+
+    def _wait_for_ready(self) -> None:
+        """Wait for server to become ready.
+
+        Raises:
+            RuntimeError: If server fails to start within timeout
+        """
+        assert self.port is not None, "Port must be set before waiting for ready"
+        start = time.time()
+        while time.time() - start < self.STARTUP_TIMEOUT:
+            if self._check_health(self.port):
+                return
+
+            # Check if process died
+            if self.process and self.process.poll() is not None:
+                stderr = self.process.stderr.read().decode() if self.process.stderr else ""
+                raise RuntimeError(f"Server process died: {stderr}")
+
+            time.sleep(0.1)
+
+        raise RuntimeError(
+            f"Server failed to start within {self.STARTUP_TIMEOUT}s"
+        )
+
+    def _cleanup_files(self) -> None:
+        """Clean up port and PID files."""
+        for file in [self.PORT_FILE, self.PID_FILE]:
+            try:
+                if file.exists():
+                    file.unlink()
+            except IOError:
+                pass
+
+
+# Global singleton for CLI commands
+_server_manager: Optional[ServerManager] = None
+
+
+def get_server_manager(repo_root: Optional[Path] = None) -> ServerManager:
+    """Get or create the global server manager.
+
+    Args:
+        repo_root: Repository root (only used on first call)
+
+    Returns:
+        The server manager instance
+    """
+    global _server_manager
+    if _server_manager is None:
+        _server_manager = ServerManager(repo_root)
+    return _server_manager