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

emdash_cli/commands/server.py

@@ -10,6 +10,9 @@ from rich.console import Console
 
 console = Console()
 
+# Per-repo servers directory
+SERVERS_DIR = Path.home() / ".emdash" / "servers"
+
 
 @click.group()
 def server():
@@ -26,23 +29,41 @@ def server_killall():
     """
     killed = 0
 
-    # Kill by PID file first
-    pid_file = Path.home() / ".emdash" / "server.pid"
-    if pid_file.exists():
+    # Kill servers by PID files in servers directory
+    if SERVERS_DIR.exists():
+        for pid_file in SERVERS_DIR.glob("*.pid"):
+            try:
+                pid = int(pid_file.read_text().strip())
+                os.kill(pid, signal.SIGTERM)
+                console.print(f"[green]Killed server process {pid}[/green]")
+                killed += 1
+            except (ValueError, ProcessLookupError, PermissionError):
+                pass
+            finally:
+                # Clean up all files for this server
+                hash_prefix = pid_file.stem
+                for ext in [".port", ".pid", ".repo"]:
+                    server_file = SERVERS_DIR / f"{hash_prefix}{ext}"
+                    if server_file.exists():
+                        server_file.unlink(missing_ok=True)
+
+    # Also check legacy location
+    legacy_pid_file = Path.home() / ".emdash" / "server.pid"
+    if legacy_pid_file.exists():
         try:
-            pid = int(pid_file.read_text().strip())
+            pid = int(legacy_pid_file.read_text().strip())
             os.kill(pid, signal.SIGTERM)
-            console.print(f"[green]Killed server process {pid}[/green]")
+            console.print(f"[green]Killed legacy server process {pid}[/green]")
             killed += 1
         except (ValueError, ProcessLookupError, PermissionError):
             pass
         finally:
-            pid_file.unlink(missing_ok=True)
+            legacy_pid_file.unlink(missing_ok=True)
 
-    # Clean up port file
-    port_file = Path.home() / ".emdash" / "server.port"
-    if port_file.exists():
-        port_file.unlink(missing_ok=True)
+    # Clean up legacy port file
+    legacy_port_file = Path.home() / ".emdash" / "server.port"
+    if legacy_port_file.exists():
+        legacy_port_file.unlink(missing_ok=True)
 
     # Kill any remaining emdash_core.server processes
     try:
@@ -77,41 +98,79 @@ def server_killall():
 
 @server.command("status")
 def server_status():
-    """Show server status.
+    """Show status of all running servers.
 
     Example:
         emdash server status
     """
-    port_file = Path.home() / ".emdash" / "server.port"
-    pid_file = Path.home() / ".emdash" / "server.pid"
+    import httpx
 
-    if not port_file.exists():
-        console.print("[yellow]No server running[/yellow]")
-        return
+    servers_found = []
 
-    try:
-        port = int(port_file.read_text().strip())
-    except (ValueError, IOError):
-        console.print("[yellow]No server running (invalid port file)[/yellow]")
-        return
+    # Check per-repo servers directory
+    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
 
-    # Check if server is responsive
-    import httpx
-    try:
-        response = httpx.get(f"http://localhost:{port}/api/health", timeout=2.0)
-        if response.status_code == 200:
-            pid = "unknown"
-            if pid_file.exists():
+                # Get repo path if available
+                repo_file = SERVERS_DIR / f"{hash_prefix}.repo"
+                repo_path = repo_file.read_text().strip() if repo_file.exists() else "unknown"
+
+                # Get PID if available
+                pid_file = SERVERS_DIR / f"{hash_prefix}.pid"
+                pid = pid_file.read_text().strip() if pid_file.exists() else "unknown"
+
+                # Check health
                 try:
-                    pid = pid_file.read_text().strip()
-                except IOError:
-                    pass
-
-            console.print(f"[bold green]Server running[/bold green]")
-            console.print(f"  Port: {port}")
-            console.print(f"  PID: {pid}")
-            console.print(f"  URL: http://localhost:{port}")
-        else:
-            console.print(f"[yellow]Server on port {port} not healthy[/yellow]")
-    except (httpx.RequestError, httpx.TimeoutException):
-        console.print(f"[yellow]Server on port {port} not responding[/yellow]")
+                    response = httpx.get(f"http://localhost:{port}/api/health", timeout=2.0)
+                    healthy = response.status_code == 200
+                except (httpx.RequestError, httpx.TimeoutException):
+                    healthy = False
+
+                servers_found.append({
+                    "port": port,
+                    "pid": pid,
+                    "repo": repo_path,
+                    "healthy": healthy,
+                })
+            except (ValueError, IOError):
+                pass
+
+    # Check legacy location
+    legacy_port_file = Path.home() / ".emdash" / "server.port"
+    if legacy_port_file.exists():
+        try:
+            port = int(legacy_port_file.read_text().strip())
+            legacy_pid_file = Path.home() / ".emdash" / "server.pid"
+            pid = legacy_pid_file.read_text().strip() if legacy_pid_file.exists() else "unknown"
+
+            try:
+                response = httpx.get(f"http://localhost:{port}/api/health", timeout=2.0)
+                healthy = response.status_code == 200
+            except (httpx.RequestError, httpx.TimeoutException):
+                healthy = False
+
+            servers_found.append({
+                "port": port,
+                "pid": pid,
+                "repo": "(legacy)",
+                "healthy": healthy,
+            })
+        except (ValueError, IOError):
+            pass
+
+    if not servers_found:
+        console.print("[yellow]No servers running[/yellow]")
+        return
+
+    console.print(f"[bold]Found {len(servers_found)} server(s):[/bold]\n")
+    for srv in servers_found:
+        status = "[green]healthy[/green]" if srv["healthy"] else "[red]unhealthy[/red]"
+        console.print(f"  {status}")
+        console.print(f"    Port: {srv['port']}")
+        console.print(f"    PID:  {srv['pid']}")
+        console.print(f"    Repo: {srv['repo']}")
+        console.print(f"    URL:  http://localhost:{srv['port']}")
+        console.print()

emdash_cli/server_manager.py

@@ -1,6 +1,7 @@
 """Server lifecycle management for emdash-core."""
 
 import atexit
+import hashlib
 import os
 import signal
 import socket
@@ -17,15 +18,15 @@ class ServerManager:
     """Manages FastAPI server lifecycle for CLI.
 
     The ServerManager handles:
+    - Per-repo server instances (each repo gets its own server)
     - Discovering running servers via port file
     - Starting new servers when needed
     - Health checking servers
     - Graceful shutdown on CLI exit
+    - Cleanup of stale servers
     """
 
-    DEFAULT_PORT = 8765
-    PORT_FILE = Path.home() / ".emdash" / "server.port"
-    PID_FILE = Path.home() / ".emdash" / "server.pid"
+    SERVERS_DIR = Path.home() / ".emdash" / "servers"
     STARTUP_TIMEOUT = 30.0  # seconds
     HEALTH_TIMEOUT = 2.0  # seconds
 
@@ -40,8 +41,35 @@ class ServerManager:
         self.port: Optional[int] = None
         self._started_by_us = False
 
+        # Create servers directory
+        self.SERVERS_DIR.mkdir(parents=True, exist_ok=True)
+
+        # Cleanup stale servers on init
+        self._cleanup_stale_servers()
+
+    @property
+    def _repo_hash(self) -> str:
+        """Get a short hash of the repo root path for unique file naming."""
+        path_str = str(self.repo_root.resolve())
+        return hashlib.sha256(path_str.encode()).hexdigest()[:12]
+
+    @property
+    def _port_file(self) -> Path:
+        """Get the port file path for this repo."""
+        return self.SERVERS_DIR / f"{self._repo_hash}.port"
+
+    @property
+    def _pid_file(self) -> Path:
+        """Get the PID file path for this repo."""
+        return self.SERVERS_DIR / f"{self._repo_hash}.pid"
+
+    @property
+    def _repo_file(self) -> Path:
+        """Get the repo path file for this repo (for debugging)."""
+        return self.SERVERS_DIR / f"{self._repo_hash}.repo"
+
     def get_server_url(self) -> str:
-        """Get URL of running server, starting one if needed.
+        """Get URL of running server for this repo, starting one if needed.
 
         Returns:
             Base URL of the running server (e.g., "http://localhost:8765")
@@ -49,17 +77,19 @@ class ServerManager:
         Raises:
             RuntimeError: If server fails to start
         """
-        # Check if server already running
-        if self.PORT_FILE.exists():
+        # Check if server already running for THIS repo
+        if self._port_file.exists():
             try:
-                port = int(self.PORT_FILE.read_text().strip())
+                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
+            # Server not healthy, clean up stale files
+            self._cleanup_files()
 
-        # Start new server
+        # Start new server for this repo
         self.port = self._find_free_port()
         self._spawn_server()
         return f"http://localhost:{self.port}"
@@ -133,6 +163,11 @@ class ServerManager:
 
         self._started_by_us = True
 
+        # Write port, PID, and repo files
+        self._port_file.write_text(str(self.port))
+        self._pid_file.write_text(str(self.process.pid))
+        self._repo_file.write_text(str(self.repo_root))
+
         # Register cleanup for normal exit
         atexit.register(self.shutdown)
 
@@ -203,14 +238,39 @@ class ServerManager:
         )
 
     def _cleanup_files(self) -> None:
-        """Clean up port and PID files."""
-        for file in [self.PORT_FILE, self.PID_FILE]:
+        """Clean up port, PID, and repo files for this repo."""
+        for file in [self._port_file, self._pid_file, self._repo_file]:
             try:
                 if file.exists():
                     file.unlink()
             except IOError:
                 pass
 
+    def _cleanup_stale_servers(self) -> None:
+        """Clean up stale server files where process no longer exists."""
+        if not self.SERVERS_DIR.exists():
+            return
+
+        for pid_file in self.SERVERS_DIR.glob("*.pid"):
+            try:
+                pid = int(pid_file.read_text().strip())
+                # Check if process exists
+                try:
+                    os.kill(pid, 0)  # Signal 0 checks if process exists
+                except OSError:
+                    # Process doesn't exist, clean up files
+                    hash_prefix = pid_file.stem
+                    for ext in [".port", ".pid", ".repo"]:
+                        stale_file = self.SERVERS_DIR / f"{hash_prefix}{ext}"
+                        if stale_file.exists():
+                            stale_file.unlink()
+            except (ValueError, IOError):
+                # Invalid PID file, remove it
+                try:
+                    pid_file.unlink()
+                except IOError:
+                    pass
+
 
 # Global singleton for CLI commands
 _server_manager: Optional[ServerManager] = None

emdash_cli/session_store.py

@@ -0,0 +1,321 @@
+"""Session persistence for CLI conversations.
+
+Manages saving and loading of conversation sessions to .emdash/sessions/.
+Each session preserves messages, mode, and other state for later restoration.
+"""
+
+import json
+import re
+from dataclasses import dataclass, asdict
+from datetime import datetime
+from pathlib import Path
+from typing import Optional
+
+
+MAX_SESSIONS = 5
+MAX_MESSAGES = 10
+SESSION_NAME_PATTERN = re.compile(r"^[a-zA-Z0-9][a-zA-Z0-9_-]{0,49}$")
+
+
+@dataclass
+class SessionMetadata:
+    """Metadata for a saved session."""
+    name: str
+    created_at: str
+    updated_at: str
+    message_count: int
+    model: Optional[str] = None
+    mode: str = "code"
+    summary: Optional[str] = None
+
+
+@dataclass
+class SessionData:
+    """Full session data including messages."""
+    name: str
+    messages: list[dict]
+    mode: str
+    model: Optional[str] = None
+    spec: Optional[str] = None
+    created_at: str = ""
+    updated_at: str = ""
+
+    def to_dict(self) -> dict:
+        return asdict(self)
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "SessionData":
+        return cls(
+            name=data.get("name", ""),
+            messages=data.get("messages", []),
+            mode=data.get("mode", "code"),
+            model=data.get("model"),
+            spec=data.get("spec"),
+            created_at=data.get("created_at", ""),
+            updated_at=data.get("updated_at", ""),
+        )
+
+
+class SessionStore:
+    """File-based session storage.
+
+    Sessions are stored in .emdash/sessions/ with:
+    - index.json: metadata for all sessions
+    - {name}.json: individual session data
+
+    Example:
+        store = SessionStore()
+        store.save_session("my-feature", messages, "code", None, "gpt-4")
+        session = store.load_session("my-feature")
+    """
+
+    def __init__(self, repo_root: Optional[Path] = None):
+        """Initialize session store.
+
+        Args:
+            repo_root: Repository root (defaults to cwd)
+        """
+        self.repo_root = repo_root or Path.cwd()
+        self.sessions_dir = self.repo_root / ".emdash" / "sessions"
+
+    def _ensure_dir(self) -> None:
+        """Ensure sessions directory exists."""
+        self.sessions_dir.mkdir(parents=True, exist_ok=True)
+
+    def _index_path(self) -> Path:
+        """Get path to index file."""
+        return self.sessions_dir / "index.json"
+
+    def _session_path(self, name: str) -> Path:
+        """Get path to session file."""
+        return self.sessions_dir / f"{name}.json"
+
+    def _load_index(self) -> dict:
+        """Load session index."""
+        index_path = self._index_path()
+        if index_path.exists():
+            try:
+                return json.loads(index_path.read_text())
+            except (json.JSONDecodeError, IOError):
+                pass
+        return {"sessions": [], "active": None}
+
+    def _save_index(self, index: dict) -> None:
+        """Save session index."""
+        self._ensure_dir()
+        self._index_path().write_text(json.dumps(index, indent=2))
+
+    def _validate_name(self, name: str) -> bool:
+        """Validate session name.
+
+        Args:
+            name: Session name to validate
+
+        Returns:
+            True if valid
+        """
+        return bool(SESSION_NAME_PATTERN.match(name))
+
+    def _generate_summary(self, messages: list[dict]) -> str:
+        """Generate a brief summary from messages.
+
+        Args:
+            messages: List of message dicts
+
+        Returns:
+            Summary string (first user message truncated)
+        """
+        for msg in messages:
+            if msg.get("role") == "user":
+                content = msg.get("content", "")
+                if isinstance(content, str) and content:
+                    return content[:100] + ("..." if len(content) > 100 else "")
+        return "No description"
+
+    def list_sessions(self) -> list[SessionMetadata]:
+        """List all saved sessions.
+
+        Returns:
+            List of session metadata, sorted by updated_at (newest first)
+        """
+        index = self._load_index()
+        sessions = []
+        for s in index.get("sessions", []):
+            sessions.append(SessionMetadata(
+                name=s.get("name", ""),
+                created_at=s.get("created_at", ""),
+                updated_at=s.get("updated_at", ""),
+                message_count=s.get("message_count", 0),
+                model=s.get("model"),
+                mode=s.get("mode", "code"),
+                summary=s.get("summary"),
+            ))
+        # Sort by updated_at descending
+        sessions.sort(key=lambda x: x.updated_at, reverse=True)
+        return sessions
+
+    def save_session(
+        self,
+        name: str,
+        messages: list[dict],
+        mode: str,
+        spec: Optional[str] = None,
+        model: Optional[str] = None,
+    ) -> tuple[bool, str]:
+        """Save a session.
+
+        Args:
+            name: Session name (alphanumeric, hyphens, underscores)
+            messages: Conversation messages
+            mode: Current mode (plan/code)
+            spec: Current spec if any
+            model: Model being used
+
+        Returns:
+            Tuple of (success, message)
+        """
+        # Validate name
+        if not self._validate_name(name):
+            return False, "Invalid session name. Use letters, numbers, hyphens, underscores (max 50 chars)"
+
+        # Load index
+        index = self._load_index()
+        sessions = index.get("sessions", [])
+
+        # Check if updating existing session
+        existing_idx = None
+        for i, s in enumerate(sessions):
+            if s.get("name") == name:
+                existing_idx = i
+                break
+
+        # Check limit for new sessions
+        if existing_idx is None and len(sessions) >= MAX_SESSIONS:
+            return False, f"Maximum {MAX_SESSIONS} sessions reached. Delete one first with /session delete <name>"
+
+        now = datetime.utcnow().isoformat() + "Z"
+
+        # Trim messages to most recent N
+        trimmed_messages = messages[-MAX_MESSAGES:] if len(messages) > MAX_MESSAGES else messages
+
+        # Create session data
+        session_data = SessionData(
+            name=name,
+            messages=trimmed_messages,
+            mode=mode,
+            model=model,
+            spec=spec,
+            created_at=sessions[existing_idx]["created_at"] if existing_idx is not None else now,
+            updated_at=now,
+        )
+
+        # Save session file
+        self._ensure_dir()
+        self._session_path(name).write_text(json.dumps(session_data.to_dict(), indent=2))
+
+        # Update index
+        metadata = {
+            "name": name,
+            "created_at": session_data.created_at,
+            "updated_at": session_data.updated_at,
+            "message_count": len(trimmed_messages),
+            "model": model,
+            "mode": mode,
+            "summary": self._generate_summary(messages),
+        }
+
+        if existing_idx is not None:
+            sessions[existing_idx] = metadata
+        else:
+            sessions.append(metadata)
+
+        index["sessions"] = sessions
+        self._save_index(index)
+
+        return True, f"Session '{name}' saved ({len(trimmed_messages)} messages)"
+
+    def load_session(self, name: str) -> Optional[SessionData]:
+        """Load a session by name.
+
+        Args:
+            name: Session name
+
+        Returns:
+            SessionData or None if not found
+        """
+        session_path = self._session_path(name)
+        if not session_path.exists():
+            return None
+
+        try:
+            data = json.loads(session_path.read_text())
+            return SessionData.from_dict(data)
+        except (json.JSONDecodeError, IOError):
+            return None
+
+    def delete_session(self, name: str) -> tuple[bool, str]:
+        """Delete a session.
+
+        Args:
+            name: Session name
+
+        Returns:
+            Tuple of (success, message)
+        """
+        index = self._load_index()
+        sessions = index.get("sessions", [])
+
+        # Find and remove from index
+        found = False
+        for i, s in enumerate(sessions):
+            if s.get("name") == name:
+                sessions.pop(i)
+                found = True
+                break
+
+        if not found:
+            return False, f"Session '{name}' not found"
+
+        # Delete session file
+        session_path = self._session_path(name)
+        if session_path.exists():
+            session_path.unlink()
+
+        # Clear active if it was this session
+        if index.get("active") == name:
+            index["active"] = None
+
+        index["sessions"] = sessions
+        self._save_index(index)
+
+        return True, f"Session '{name}' deleted"
+
+    def get_active_session(self) -> Optional[str]:
+        """Get the name of the active session.
+
+        Returns:
+            Session name or None
+        """
+        index = self._load_index()
+        return index.get("active")
+
+    def set_active_session(self, name: Optional[str]) -> None:
+        """Set the active session.
+
+        Args:
+            name: Session name or None to clear
+        """
+        index = self._load_index()
+        index["active"] = name
+        self._save_index(index)
+
+    def session_exists(self, name: str) -> bool:
+        """Check if a session exists.
+
+        Args:
+            name: Session name
+
+        Returns:
+            True if session exists
+        """
+        return self._session_path(name).exists()