emdash-core 0.1.7__py3-none-any.whl

emdash_core/auth/github.py

@@ -0,0 +1,389 @@
+"""GitHub OAuth Device Flow authentication.
+
+This module implements GitHub's device flow for CLI authentication,
+similar to how `gh auth login` works.
+
+Device Flow Steps:
+1. Request device and user codes from GitHub
+2. Display user code and open browser to github.com/login/device
+3. Poll GitHub until user completes authorization
+4. Store access token securely
+
+Reference: https://docs.github.com/en/apps/oauth-apps/building-oauth-apps/authorizing-oauth-apps#device-flow
+"""
+
+import json
+import os
+import time
+import webbrowser
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Optional
+from urllib.parse import urlencode
+from urllib.request import Request, urlopen
+from urllib.error import HTTPError, URLError
+
+from ..utils.logger import log
+
+
+# Em Dash GitHub OAuth App Client ID
+GITHUB_CLIENT_ID = "Ov23liMPlw6JMmzUainJ"
+
+# GitHub OAuth endpoints
+DEVICE_CODE_URL = "https://github.com/login/device/code"
+ACCESS_TOKEN_URL = "https://github.com/login/oauth/access_token"
+USER_API_URL = "https://api.github.com/user"
+
+# Default scopes for Rove (repo access for code search, PRs, etc.)
+DEFAULT_SCOPES = ["repo", "read:user"]
+
+
+@dataclass
+class AuthConfig:
+    """Stored authentication configuration."""
+
+    access_token: str
+    token_type: str = "bearer"
+    scope: str = ""
+    username: Optional[str] = None
+
+    def to_dict(self) -> dict:
+        return {
+            "access_token": self.access_token,
+            "token_type": self.token_type,
+            "scope": self.scope,
+            "username": self.username,
+        }
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "AuthConfig":
+        return cls(
+            access_token=data.get("access_token", ""),
+            token_type=data.get("token_type", "bearer"),
+            scope=data.get("scope", ""),
+            username=data.get("username"),
+        )
+
+
+@dataclass
+class DeviceCodeResponse:
+    """Response from device code request."""
+
+    device_code: str
+    user_code: str
+    verification_uri: str
+    expires_in: int
+    interval: int
+
+
+def get_config_dir() -> Path:
+    """Get the Rove config directory.
+
+    Returns:
+        Path to ~/.config/emdash/
+    """
+    # Follow XDG spec on Linux/Mac
+    xdg_config = os.environ.get("XDG_CONFIG_HOME")
+    if xdg_config:
+        config_dir = Path(xdg_config) / "emdash"
+    else:
+        config_dir = Path.home() / ".config" / "emdash"
+
+    config_dir.mkdir(parents=True, exist_ok=True)
+    return config_dir
+
+
+def get_auth_file() -> Path:
+    """Get path to the auth config file."""
+    return get_config_dir() / "auth.json"
+
+
+def _make_request(url: str, data: dict, headers: dict = None) -> dict:
+    """Make a POST request and return JSON response."""
+    headers = headers or {}
+    headers["Accept"] = "application/json"
+
+    encoded_data = urlencode(data).encode("utf-8")
+    request = Request(url, data=encoded_data, headers=headers, method="POST")
+
+    try:
+        with urlopen(request, timeout=30) as response:
+            return json.loads(response.read().decode("utf-8"))
+    except HTTPError as e:
+        error_body = e.read().decode("utf-8")
+        log.error(f"HTTP error {e.code}: {error_body}")
+        raise
+    except URLError as e:
+        log.error(f"URL error: {e.reason}")
+        raise
+
+
+def _get_request(url: str, token: str) -> dict:
+    """Make a GET request with auth token."""
+    headers = {
+        "Accept": "application/json",
+        "Authorization": f"Bearer {token}",
+    }
+    request = Request(url, headers=headers)
+
+    with urlopen(request, timeout=30) as response:
+        return json.loads(response.read().decode("utf-8"))
+
+
+class GitHubAuth:
+    """GitHub OAuth device flow authentication."""
+
+    def __init__(self, client_id: str = GITHUB_CLIENT_ID):
+        self.client_id = client_id
+
+    def request_device_code(self, scopes: list[str] = None) -> DeviceCodeResponse:
+        """Request a device code from GitHub.
+
+        Args:
+            scopes: OAuth scopes to request
+
+        Returns:
+            DeviceCodeResponse with codes and URIs
+        """
+        scopes = scopes or DEFAULT_SCOPES
+
+        data = {
+            "client_id": self.client_id,
+            "scope": " ".join(scopes),
+        }
+
+        response = _make_request(DEVICE_CODE_URL, data)
+
+        return DeviceCodeResponse(
+            device_code=response["device_code"],
+            user_code=response["user_code"],
+            verification_uri=response["verification_uri"],
+            expires_in=response["expires_in"],
+            interval=response["interval"],
+        )
+
+    def poll_for_token(
+        self,
+        device_code: str,
+        interval: int = 5,
+        timeout: int = 900,
+    ) -> Optional[AuthConfig]:
+        """Poll GitHub for access token after user authorizes.
+
+        Args:
+            device_code: Device code from request_device_code
+            interval: Polling interval in seconds
+            timeout: Maximum time to wait in seconds
+
+        Returns:
+            AuthConfig if successful, None if timeout/cancelled
+        """
+        data = {
+            "client_id": self.client_id,
+            "device_code": device_code,
+            "grant_type": "urn:ietf:params:oauth:grant-type:device_code",
+        }
+
+        start_time = time.time()
+
+        while time.time() - start_time < timeout:
+            try:
+                response = _make_request(ACCESS_TOKEN_URL, data)
+
+                if "access_token" in response:
+                    # Success!
+                    config = AuthConfig(
+                        access_token=response["access_token"],
+                        token_type=response.get("token_type", "bearer"),
+                        scope=response.get("scope", ""),
+                    )
+
+                    # Fetch username
+                    try:
+                        user_info = _get_request(USER_API_URL, config.access_token)
+                        config.username = user_info.get("login")
+                    except Exception as e:
+                        log.warning(f"Failed to fetch username: {e}")
+
+                    return config
+
+                error = response.get("error")
+
+                if error == "authorization_pending":
+                    # User hasn't authorized yet, keep polling
+                    time.sleep(interval)
+                    continue
+                elif error == "slow_down":
+                    # We're polling too fast
+                    interval += 5
+                    time.sleep(interval)
+                    continue
+                elif error == "expired_token":
+                    log.error("Device code expired. Please try again.")
+                    return None
+                elif error == "access_denied":
+                    log.error("Authorization was denied.")
+                    return None
+                else:
+                    log.error(f"Unexpected error: {error}")
+                    return None
+
+            except Exception as e:
+                log.error(f"Error polling for token: {e}")
+                time.sleep(interval)
+
+        log.error("Timeout waiting for authorization.")
+        return None
+
+    def login(self, scopes: list[str] = None, open_browser: bool = True) -> Optional[AuthConfig]:
+        """Perform full device flow login.
+
+        Args:
+            scopes: OAuth scopes to request
+            open_browser: Whether to open browser automatically
+
+        Returns:
+            AuthConfig if successful, None otherwise
+        """
+        # Request device code
+        device_response = self.request_device_code(scopes)
+
+        # Display instructions
+        print()
+        print(f"! First, copy your one-time code: {device_response.user_code}")
+        print(f"- Then visit: {device_response.verification_uri}")
+
+        if open_browser:
+            input("- Press Enter to open github.com in your browser...")
+            webbrowser.open(device_response.verification_uri)
+
+        print()
+        print("Waiting for authorization...")
+
+        # Poll for token
+        config = self.poll_for_token(
+            device_response.device_code,
+            interval=device_response.interval,
+        )
+
+        if config:
+            # Save to disk
+            save_auth_config(config)
+            print()
+            if config.username:
+                print(f"✓ Authentication complete. Logged in as @{config.username}")
+            else:
+                print("✓ Authentication complete.")
+
+        return config
+
+    def logout(self) -> bool:
+        """Remove stored authentication.
+
+        Returns:
+            True if logout successful
+        """
+        auth_file = get_auth_file()
+        if auth_file.exists():
+            auth_file.unlink()
+            return True
+        return False
+
+
+def save_auth_config(config: AuthConfig) -> None:
+    """Save authentication config to disk.
+
+    Args:
+        config: AuthConfig to save
+    """
+    auth_file = get_auth_file()
+
+    # Set restrictive permissions (owner read/write only)
+    with open(auth_file, "w") as f:
+        json.dump(config.to_dict(), f, indent=2)
+
+    # chmod 600
+    os.chmod(auth_file, 0o600)
+
+    log.debug(f"Saved auth config to {auth_file}")
+
+
+def load_auth_config() -> Optional[AuthConfig]:
+    """Load authentication config from disk.
+
+    Returns:
+        AuthConfig or None if not found
+    """
+    auth_file = get_auth_file()
+
+    if not auth_file.exists():
+        return None
+
+    try:
+        with open(auth_file) as f:
+            data = json.load(f)
+        return AuthConfig.from_dict(data)
+    except Exception as e:
+        log.warning(f"Failed to load auth config: {e}")
+        return None
+
+
+def get_github_token() -> Optional[str]:
+    """Get GitHub token from auth config or environment.
+
+    Priority:
+    1. Rove auth config (~/.config/emdash/auth.json)
+    2. GITHUB_TOKEN environment variable
+    3. GITHUB_PERSONAL_ACCESS_TOKEN environment variable
+
+    Returns:
+        GitHub access token or None
+    """
+    # Check Rove auth first
+    config = load_auth_config()
+    if config and config.access_token:
+        return config.access_token
+
+    # Fall back to environment variables
+    return os.environ.get("GITHUB_TOKEN") or os.environ.get("GITHUB_PERSONAL_ACCESS_TOKEN")
+
+
+def is_authenticated() -> bool:
+    """Check if user is authenticated.
+
+    Returns:
+        True if authenticated (either via Rove auth or env var)
+    """
+    return get_github_token() is not None
+
+
+def get_auth_status() -> dict:
+    """Get current authentication status.
+
+    Returns:
+        Dict with status info
+    """
+    config = load_auth_config()
+    env_token = os.environ.get("GITHUB_TOKEN") or os.environ.get("GITHUB_PERSONAL_ACCESS_TOKEN")
+
+    if config and config.access_token:
+        return {
+            "authenticated": True,
+            "source": "emdash auth",
+            "username": config.username,
+            "scopes": config.scope.split() if config.scope else [],
+        }
+    elif env_token:
+        return {
+            "authenticated": True,
+            "source": "environment variable",
+            "username": None,
+            "scopes": [],
+        }
+    else:
+        return {
+            "authenticated": False,
+            "source": None,
+            "username": None,
+            "scopes": [],
+        }

emdash_core/config.py

@@ -0,0 +1,74 @@
+"""Server configuration."""
+
+import os
+from pathlib import Path
+from typing import Optional
+
+from pydantic import Field
+from pydantic_settings import BaseSettings
+
+
+def _get_default_model() -> str:
+    """Get the default model from emdash_core or fallback."""
+    try:
+        from .agent.providers.factory import DEFAULT_MODEL
+        return DEFAULT_MODEL
+    except ImportError:
+        # Fallback if not available
+        return os.getenv("EMDASH_DEFAULT_MODEL", "fireworks:accounts/fireworks/models/minimax-m2p1")
+
+
+class ServerConfig(BaseSettings):
+    """Configuration for the emdash-core server."""
+
+    # Server settings
+    host: str = Field(default="127.0.0.1", description="Host to bind to")
+    port: int = Field(default=8765, description="Port to bind to")
+
+    # Repository settings
+    repo_root: Optional[str] = Field(default=None, description="Repository root path")
+
+    # Database settings
+    database_path: str = Field(
+        default=".emdash/index/kuzu_db",
+        description="Path to Kuzu database relative to repo root"
+    )
+
+    # Agent settings
+    default_model: str = Field(default_factory=_get_default_model, description="Default LLM model")
+    max_iterations: int = Field(default=50, description="Max agent iterations")
+    context_threshold: float = Field(default=0.6, description="Context window threshold for summarization")
+
+    # SSE settings
+    sse_ping_interval: int = Field(default=15, description="SSE ping interval in seconds")
+
+    class Config:
+        env_prefix = "EMDASH_"
+        env_file = ".env"
+        extra = "ignore"
+
+    @property
+    def database_full_path(self) -> Path:
+        """Get full path to database."""
+        if self.repo_root:
+            return Path(self.repo_root) / self.database_path
+        return Path(self.database_path)
+
+
+# Global config instance
+_config: Optional[ServerConfig] = None
+
+
+def get_config() -> ServerConfig:
+    """Get or create server configuration."""
+    global _config
+    if _config is None:
+        _config = ServerConfig()
+    return _config
+
+
+def set_config(**kwargs) -> ServerConfig:
+    """Set server configuration with overrides."""
+    global _config
+    _config = ServerConfig(**kwargs)
+    return _config

emdash_core/context/__init__.py

@@ -0,0 +1,52 @@
+"""Session-based context provider system.
+
+This module provides an extensible system for extracting and managing
+contextual information during agent sessions.
+
+Example usage:
+    from emdash_core.context import ContextService
+
+    # Create service
+    service = ContextService()
+
+    # Get terminal ID (creates one if not exists)
+    terminal_id = ContextService.get_terminal_id()
+
+    # Update context after changes
+    service.update_context(terminal_id)
+
+    # Get formatted context for LLM
+    context_prompt = service.get_context_prompt(terminal_id)
+
+Adding new providers:
+    1. Create a new provider class inheriting from ContextProvider
+    2. Implement extract_context() method
+    3. Register with ContextProviderRegistry.register("name", MyProvider)
+    4. Add to CONTEXT_PROVIDERS env var
+"""
+
+from .models import ContextItem, ContextProviderSpec, SessionContext
+from .reranker import get_rerank_scores, rerank_context_items
+from .registry import ContextProviderRegistry, get_provider
+from .service import ContextService
+from .session import SessionContextManager
+
+# Import providers to trigger registration
+from .providers import explored_areas, touched_areas  # noqa: F401
+
+__all__ = [
+    # Models
+    "ContextItem",
+    "ContextProviderSpec",
+    "SessionContext",
+    # Registry
+    "ContextProviderRegistry",
+    "get_provider",
+    # Reranker
+    "rerank_context_items",
+    "get_rerank_scores",
+    # Service
+    "ContextService",
+    # Session
+    "SessionContextManager",
+]

emdash_core/context/models.py

@@ -0,0 +1,50 @@
+"""Data models for the context provider system."""
+
+from dataclasses import dataclass, field
+from datetime import datetime
+from typing import Optional
+
+
+@dataclass(frozen=True)
+class ContextProviderSpec:
+    """Specification for a context provider."""
+
+    name: str
+    description: str
+    requires_graph: bool = True
+
+
+@dataclass
+class ContextItem:
+    """A single context item extracted from code."""
+
+    qualified_name: str
+    entity_type: str  # 'Function', 'Class', 'File'
+    description: Optional[str] = None
+    file_path: Optional[str] = None
+    score: float = 1.0
+    touch_count: int = 1
+    last_touched: Optional[datetime] = None
+    neighbors: list[str] = field(default_factory=list)
+
+    def __post_init__(self):
+        if self.last_touched is None:
+            object.__setattr__(self, "last_touched", datetime.now())
+
+
+@dataclass
+class SessionContext:
+    """Context for a terminal session."""
+
+    session_id: str
+    terminal_id: str
+    items: list[ContextItem] = field(default_factory=list)
+    created_at: Optional[datetime] = None
+    last_active: Optional[datetime] = None
+
+    def __post_init__(self):
+        now = datetime.now()
+        if self.created_at is None:
+            self.created_at = now
+        if self.last_active is None:
+            self.last_active = now

emdash_core/context/providers/__init__.py

@@ -0,0 +1,11 @@
+"""Context providers package."""
+
+from .base import ContextProvider
+from .explored_areas import ExploredAreasProvider
+from .touched_areas import TouchedAreasProvider
+
+__all__ = [
+    "ContextProvider",
+    "ExploredAreasProvider",
+    "TouchedAreasProvider",
+]

emdash_core/context/providers/base.py

@@ -0,0 +1,74 @@
+"""Abstract base class for context providers."""
+
+from abc import ABC, abstractmethod
+from typing import Optional
+
+from ..models import ContextItem, ContextProviderSpec
+from ...graph.connection import KuzuConnection
+
+
+class ContextProvider(ABC):
+    """Base class for context providers.
+
+    Context providers extract relevant context from various sources
+    (AST, git history, semantic search, etc.) to help the LLM
+    understand the codebase during a session.
+    """
+
+    def __init__(self, connection: KuzuConnection, config: Optional[dict] = None):
+        """Initialize context provider.
+
+        Args:
+            connection: Kuzu database connection
+            config: Optional provider-specific configuration
+        """
+        self.connection = connection
+        self.config = config or {}
+
+    @property
+    @abstractmethod
+    def spec(self) -> ContextProviderSpec:
+        """Get provider specification."""
+        pass
+
+    @property
+    def name(self) -> str:
+        """Get provider name."""
+        return self.spec.name
+
+    @abstractmethod
+    def extract_context(self, modified_files: list[str]) -> list[ContextItem]:
+        """Extract context items from modified files.
+
+        Args:
+            modified_files: List of file paths that were modified
+
+        Returns:
+            List of context items extracted from those files
+        """
+        pass
+
+    def format_for_prompt(self, items: list[ContextItem]) -> str:
+        """Format context items for LLM system prompt.
+
+        Args:
+            items: Context items to format
+
+        Returns:
+            Formatted string for inclusion in system prompt
+        """
+        if not items:
+            return ""
+
+        lines = [f"## Context from {self.name}\n"]
+        for item in sorted(items, key=lambda x: -x.score):
+            lines.append(f"### {item.entity_type}: {item.qualified_name}")
+            if item.file_path:
+                lines.append(f"File: {item.file_path}")
+            if item.description:
+                lines.append(f"Description: {item.description}")
+            if item.neighbors:
+                lines.append(f"Related: {', '.join(item.neighbors[:5])}")
+            lines.append("")
+
+        return "\n".join(lines)