emdash-core 0.1.7__py3-none-any.whl

emdash_core/server.py

@@ -0,0 +1,153 @@
+"""FastAPI server entry point for emdash-core."""
+
+import argparse
+import os
+import signal
+import sys
+from contextlib import asynccontextmanager
+from pathlib import Path
+from typing import Optional
+
+import uvicorn
+from dotenv import load_dotenv
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+
+from .api import api_router
+from .config import get_config, set_config
+
+
+def _load_env_files(repo_root: Optional[str] = None):
+    """Load .env files from repo root and user config.
+
+    Uses override=True so .env file takes precedence over shell environment.
+    """
+    # Also try parent directories to find .env (load first, lower priority)
+    current = Path(__file__).parent
+    for _ in range(5):
+        current = current.parent
+        env_path = current / ".env"
+        if env_path.exists():
+            load_dotenv(env_path, override=True)
+            break
+
+    # Load from repo root if provided (highest priority)
+    if repo_root:
+        env_path = Path(repo_root) / ".env"
+        if env_path.exists():
+            load_dotenv(env_path, override=True)
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    """Application lifespan handler."""
+    config = get_config()
+
+    # Startup
+    print(f"EmDash Core starting on http://{config.host}:{config.port}")
+    if config.repo_root:
+        print(f"Repository root: {config.repo_root}")
+
+    # Write port file for CLI/Electron discovery
+    port_file = Path.home() / ".emdash" / "server.port"
+    port_file.parent.mkdir(parents=True, exist_ok=True)
+    port_file.write_text(str(config.port))
+
+    yield
+
+    # Shutdown
+    print("EmDash Core shutting down...")
+    if port_file.exists():
+        port_file.unlink()
+
+
+def create_app(
+    repo_root: Optional[str] = None,
+    host: str = "127.0.0.1",
+    port: int = 8765,
+) -> FastAPI:
+    """Create and configure the FastAPI application."""
+    # Load environment variables from .env files
+    _load_env_files(repo_root)
+
+    # Set configuration
+    set_config(
+        host=host,
+        port=port,
+        repo_root=repo_root,
+    )
+
+    app = FastAPI(
+        title="EmDash Core",
+        description="FastAPI server for code intelligence",
+        version="0.1.0",
+        lifespan=lifespan,
+    )
+
+    # CORS middleware for Electron app
+    app.add_middleware(
+        CORSMiddleware,
+        allow_origins=["*"],  # Allow all origins for local development
+        allow_credentials=True,
+        allow_methods=["*"],
+        allow_headers=["*"],
+    )
+
+    # Include API routes
+    app.include_router(api_router)
+
+    return app
+
+
+def main():
+    """Main entry point for the server."""
+    parser = argparse.ArgumentParser(description="EmDash Core Server")
+    parser.add_argument(
+        "--host",
+        default="127.0.0.1",
+        help="Host to bind to (default: 127.0.0.1)"
+    )
+    parser.add_argument(
+        "--port",
+        type=int,
+        default=8765,
+        help="Port to bind to (default: 8765)"
+    )
+    parser.add_argument(
+        "--repo-root",
+        help="Repository root path"
+    )
+    parser.add_argument(
+        "--reload",
+        action="store_true",
+        help="Enable auto-reload for development"
+    )
+
+    args = parser.parse_args()
+
+    # Handle graceful shutdown
+    def signal_handler(signum, frame):
+        print("\nReceived shutdown signal...")
+        sys.exit(0)
+
+    signal.signal(signal.SIGINT, signal_handler)
+    signal.signal(signal.SIGTERM, signal_handler)
+
+    # Create app
+    app = create_app(
+        repo_root=args.repo_root,
+        host=args.host,
+        port=args.port,
+    )
+
+    # Run server
+    uvicorn.run(
+        app,
+        host=args.host,
+        port=args.port,
+        reload=args.reload,
+    )
+
+
+if __name__ == "__main__":
+    main()

emdash_core/sse/__init__.py

@@ -0,0 +1,5 @@
+"""SSE streaming utilities."""
+
+from .stream import SSEHandler, create_sse_stream
+
+__all__ = ["SSEHandler", "create_sse_stream"]

emdash_core/sse/stream.py

@@ -0,0 +1,196 @@
+"""SSE streaming infrastructure for agent events."""
+
+import asyncio
+import json
+from datetime import datetime
+from enum import Enum
+from typing import Any, AsyncIterator
+
+from pydantic import BaseModel
+
+
+class EventType(str, Enum):
+    """Types of events emitted by agents (matches emdash.agent.events.EventType)."""
+
+    # Tool lifecycle
+    TOOL_START = "tool_start"
+    TOOL_RESULT = "tool_result"
+
+    # Agent thinking/progress
+    THINKING = "thinking"
+    PROGRESS = "progress"
+
+    # Output
+    RESPONSE = "response"
+    PARTIAL_RESPONSE = "partial_response"
+
+    # Interaction
+    CLARIFICATION = "clarification"
+    CLARIFICATION_RESPONSE = "clarification_response"
+
+    # Errors
+    ERROR = "error"
+    WARNING = "warning"
+
+    # Session
+    SESSION_START = "session_start"
+    SESSION_END = "session_end"
+
+    # Context
+    CONTEXT_FRAME = "context_frame"
+
+
+class SSEEvent(BaseModel):
+    """An SSE event for streaming to clients."""
+
+    type: EventType
+    data: dict[str, Any]
+    timestamp: datetime
+    agent_name: str | None = None
+
+    def to_sse(self) -> str:
+        """Format as SSE wire protocol.
+
+        Returns:
+            SSE formatted string: "event: {type}\ndata: {json}\n\n"
+        """
+        payload = {
+            **self.data,
+            "timestamp": self.timestamp.isoformat(),
+        }
+        if self.agent_name:
+            payload["agent_name"] = self.agent_name
+
+        data_json = json.dumps(payload, default=str)
+        return f"event: {self.type.value}\ndata: {data_json}\n\n"
+
+
+class SSEHandler:
+    """Event handler that queues events for SSE streaming.
+
+    This handler implements the EventHandler protocol and collects
+    events into an async queue for streaming to HTTP clients.
+
+    Thread-safe: can be used from both async context and thread pools.
+    """
+
+    def __init__(self, agent_name: str | None = None):
+        """Initialize the handler.
+
+        Args:
+            agent_name: Optional name to tag events
+        """
+        # Use thread-safe queue for cross-thread communication
+        import queue
+        self._queue: queue.Queue[SSEEvent | None] = queue.Queue()
+        self._agent_name = agent_name
+        self._closed = False
+
+    def handle(self, event: Any) -> None:
+        """Handle an event from the agent.
+
+        Args:
+            event: AgentEvent from the agent system
+        """
+        if self._closed:
+            return
+
+        # Convert to SSEEvent
+        sse_event = SSEEvent(
+            type=EventType(event.type.value),
+            data=event.data,
+            timestamp=event.timestamp,
+            agent_name=event.agent_name or self._agent_name,
+        )
+
+        # Put in queue (thread-safe)
+        self._queue.put(sse_event)
+
+    def emit(self, event_type: EventType, data: dict[str, Any]) -> None:
+        """Emit an event directly (thread-safe).
+
+        Args:
+            event_type: Type of event
+            data: Event data
+        """
+        if self._closed:
+            return
+
+        sse_event = SSEEvent(
+            type=event_type,
+            data=data,
+            timestamp=datetime.now(),
+            agent_name=self._agent_name,
+        )
+
+        self._queue.put(sse_event)
+
+    async def emit_async(self, event_type: EventType, data: dict[str, Any]) -> None:
+        """Emit an event asynchronously.
+
+        Args:
+            event_type: Type of event
+            data: Event data
+        """
+        if self._closed:
+            return
+
+        sse_event = SSEEvent(
+            type=event_type,
+            data=data,
+            timestamp=datetime.now(),
+            agent_name=self._agent_name,
+        )
+
+        self._queue.put(sse_event)
+
+    def close(self) -> None:
+        """Close the handler and signal end of stream."""
+        self._closed = True
+        self._queue.put(None)  # Sentinel to end iteration
+
+    async def __aiter__(self) -> AsyncIterator[str]:
+        """Iterate over SSE-formatted events.
+
+        Yields:
+            SSE formatted strings ready for HTTP streaming
+        """
+        import queue
+
+        loop = asyncio.get_event_loop()
+        ping_counter = 0
+
+        while True:
+            try:
+                # Run blocking queue.get in executor to not block event loop
+                try:
+                    event = await loop.run_in_executor(
+                        None,  # Default executor
+                        lambda: self._queue.get(timeout=1.0)
+                    )
+                    if event is None:
+                        break
+                    yield event.to_sse()
+                    ping_counter = 0
+                except queue.Empty:
+                    ping_counter += 1
+                    # Send keep-alive ping every 30 seconds
+                    if ping_counter >= 30:
+                        yield ": ping\n\n"
+                        ping_counter = 0
+                    continue
+            except Exception:
+                break
+
+
+async def create_sse_stream(handler: SSEHandler) -> AsyncIterator[str]:
+    """Create an SSE stream from a handler.
+
+    Args:
+        handler: SSE handler to stream from
+
+    Yields:
+        SSE formatted event strings
+    """
+    async for event in handler:
+        yield event

emdash_core/swarm/__init__.py

@@ -0,0 +1,17 @@
+"""Multi-agent swarm execution with git worktrees."""
+
+from .task_definition import SwarmTask, SwarmState, TaskStatus
+from .worktree_manager import WorktreeManager, WorktreeInfo, WorktreeError
+from .swarm_runner import SwarmRunner
+from .session_manager import SessionManager
+
+__all__ = [
+    "SwarmTask",
+    "SwarmState",
+    "TaskStatus",
+    "WorktreeManager",
+    "WorktreeInfo",
+    "WorktreeError",
+    "SwarmRunner",
+    "SessionManager",
+]