emdash-core 0.1.33__py3-none-any.whl → 0.1.60__py3-none-any.whl

emdash_core/ingestion/repository.py

@@ -1,15 +1,9 @@
-"""Repository management - clone, fetch, and track Git repositories."""
+"""Repository management for local Git repositories."""
 
-import hashlib
-import os
-import shutil
-from datetime import datetime
 from pathlib import Path
 from typing import Optional
-from urllib.parse import urlparse
 
-import git
-from git import Repo, GitCommandError
+from git import Repo
 
 from ..core.exceptions import RepositoryError
 from ..core.models import RepositoryEntity
@@ -17,44 +11,37 @@ from ..utils.logger import log
 
 
 class RepositoryManager:
-    """Manages Git repository operations (clone, fetch, status)."""
+    """Manages local Git repository operations."""
 
-    def __init__(self, cache_dir: Optional[Path] = None):
-        """Initialize repository manager.
-
-        Args:
-            cache_dir: Directory to cache cloned repositories.
-                      Defaults to ~/.emdash/repos
-        """
-        if cache_dir is None:
-            cache_dir = Path.home() / ".emdash" / "repos"
-
-        self.cache_dir = cache_dir
-        self.cache_dir.mkdir(parents=True, exist_ok=True)
+    def __init__(self):
+        """Initialize repository manager."""
+        pass
 
     def get_or_clone(
         self,
         repo_path: str,
         skip_commit_count: bool = False
     ) -> tuple[Repo, RepositoryEntity]:
-        """Get a repository from cache or clone it.
+        """Get a local repository.
 
         Args:
-            repo_path: URL or local path to repository
-            skip_commit_count: Whether to skip counting commits
+            repo_path: Local path to repository
+            skip_commit_count: Whether to skip counting commits (unused, kept for API compatibility)
 
         Returns:
             Tuple of (git.Repo, RepositoryEntity)
 
         Raises:
-            RepositoryError: If repository cannot be accessed
+            RepositoryError: If repository cannot be accessed or path doesn't exist
         """
-        # Check if it's a local path
-        if Path(repo_path).exists():
-            return self._open_local_repo(repo_path)
+        # Only support local paths
+        if not Path(repo_path).exists():
+            raise RepositoryError(
+                f"Repository path does not exist: {repo_path}. "
+                "Remote repository URLs are not supported - please provide a local path."
+            )
 
-        # It's a URL - clone or fetch
-        return self._clone_or_fetch(repo_path, skip_commit_count)
+        return self._open_local_repo(repo_path)
 
     def _open_local_repo(self, path: str) -> tuple[Repo, RepositoryEntity]:
         """Open a local repository.
@@ -88,164 +75,6 @@ class RepositoryManager:
         except Exception as e:
             raise RepositoryError(f"Failed to open local repository {path}: {e}")
 
-    def _clone_or_fetch(
-        self,
-        url: str,
-        skip_commit_count: bool
-    ) -> tuple[Repo, RepositoryEntity]:
-        """Clone a repository or fetch updates if already cloned.
-
-        Args:
-            url: Repository URL
-            skip_commit_count: Whether to skip counting commits
-
-        Returns:
-            Tuple of (git.Repo, RepositoryEntity)
-        """
-        # Generate cache path from URL
-        cache_path = self._get_cache_path(url)
-
-        if cache_path.exists():
-            log.info(f"Repository already cached at {cache_path}")
-            return self._fetch_updates(cache_path, url, skip_commit_count)
-        else:
-            log.info(f"Cloning repository: {url}")
-            return self._clone_repo(url, cache_path, skip_commit_count)
-
-    def _clone_repo(
-        self,
-        url: str,
-        cache_path: Path,
-        skip_commit_count: bool
-    ) -> tuple[Repo, RepositoryEntity]:
-        """Clone a repository.
-
-        Args:
-            url: Repository URL
-            cache_path: Path to clone into
-            skip_commit_count: Whether to skip counting commits
-
-        Returns:
-            Tuple of (git.Repo, RepositoryEntity)
-        """
-        try:
-            repo = Repo.clone_from(url, cache_path, depth=None)
-            log.info(f"Successfully cloned {url}")
-
-            entity = self._create_repository_entity(
-                repo,
-                url,
-                skip_commit_count=skip_commit_count
-            )
-            return repo, entity
-
-        except GitCommandError as e:
-            raise RepositoryError(f"Failed to clone repository {url}: {e}")
-        except Exception as e:
-            raise RepositoryError(f"Unexpected error cloning {url}: {e}")
-
-    def _fetch_updates(
-        self,
-        cache_path: Path,
-        url: str,
-        skip_commit_count: bool
-    ) -> tuple[Repo, RepositoryEntity]:
-        """Fetch updates for an existing repository.
-
-        Args:
-            cache_path: Path to cached repository
-            url: Repository URL
-            skip_commit_count: Whether to skip counting commits
-
-        Returns:
-            Tuple of (git.Repo, RepositoryEntity)
-        """
-        try:
-            repo = Repo(cache_path)
-
-            log.info("Fetching updates from remote...")
-            repo.remotes.origin.fetch()
-
-            # Pull latest changes
-            repo.remotes.origin.pull()
-
-            log.info("Repository updated successfully")
-
-            entity = self._create_repository_entity(
-                repo,
-                url,
-                skip_commit_count=skip_commit_count
-            )
-            return repo, entity
-
-        except GitCommandError as e:
-            raise RepositoryError(f"Failed to fetch updates for {url}: {e}")
-        except Exception as e:
-            raise RepositoryError(f"Unexpected error fetching updates: {e}")
-
-    def _create_repository_entity(
-        self,
-        repo: Repo,
-        url: str,
-        skip_commit_count: bool = False
-    ) -> RepositoryEntity:
-        """Create a RepositoryEntity from a git.Repo.
-
-        Args:
-            repo: Git repository
-            url: Repository URL
-            skip_commit_count: Whether to skip counting commits
-
-        Returns:
-            RepositoryEntity
-        """
-        # Parse URL to extract owner and name
-        parsed = urlparse(url)
-        path_parts = parsed.path.strip("/").split("/")
-
-        if len(path_parts) >= 2:
-            owner = path_parts[-2]
-            repo_name = path_parts[-1].replace(".git", "")
-        else:
-            owner = None
-            repo_name = path_parts[-1].replace(".git", "") if path_parts else "unknown"
-
-        commit_count = 0
-        if not skip_commit_count:
-            try:
-                commit_count = sum(1 for _ in repo.iter_commits())
-            except Exception:
-                commit_count = 0
-
-        return RepositoryEntity(
-            url=url,
-            name=repo_name,
-            owner=owner,
-            default_branch=repo.active_branch.name if repo.active_branch else "main",
-            last_ingested=None,
-            ingestion_status="pending",
-            commit_count=commit_count,
-        )
-
-    def _get_cache_path(self, url: str) -> Path:
-        """Get the cache path for a repository URL.
-
-        Args:
-            url: Repository URL
-
-        Returns:
-            Path to cache directory
-        """
-        # Create a unique directory name from URL
-        url_hash = hashlib.md5(url.encode()).hexdigest()[:12]
-
-        # Extract repo name from URL
-        parsed = urlparse(url)
-        path_parts = parsed.path.strip("/").split("/")
-        repo_name = path_parts[-1].replace(".git", "")
-
-        return self.cache_dir / f"{repo_name}_{url_hash}"
-
     def _get_origin_url(self, repo: Repo) -> Optional[str]:
         """Get the origin URL of a repository.
 
@@ -334,13 +163,3 @@ class RepositoryManager:
             This is a convenience wrapper around get_source_files() for backward compatibility.
         """
         return self.get_source_files(repo, ['.py'], ignore_patterns)
-
-    def clear_cache(self):
-        """Clear all cached repositories."""
-        log.warning("Clearing repository cache...")
-
-        if self.cache_dir.exists():
-            shutil.rmtree(self.cache_dir)
-            self.cache_dir.mkdir(parents=True, exist_ok=True)
-
-        log.info("Cache cleared successfully")

emdash_core/models/agent.py

@@ -1,11 +1,17 @@
 """Pydantic models for agent API."""
 
+import os
 from enum import Enum
 from typing import Optional
 
 from pydantic import BaseModel, Field
 
 
+def _default_use_worktree() -> bool:
+    """Get default worktree setting from environment."""
+    return os.environ.get("EMDASH_USE_WORKTREE", "false").lower() in ("true", "1", "yes")
+
+
 class AgentMode(str, Enum):
     """Agent operation modes."""
 
@@ -33,6 +39,10 @@ class AgentChatOptions(BaseModel):
         default=0.6,
         description="Context window threshold for summarization (0-1)"
     )
+    use_worktree: bool = Field(
+        default_factory=_default_use_worktree,
+        description="Use git worktree for isolated changes (EMDASH_USE_WORKTREE env)"
+    )
 
 
 class AgentChatRequest(BaseModel):
@@ -51,6 +61,10 @@ class AgentChatRequest(BaseModel):
         default_factory=list,
         description="Images for vision-capable models"
     )
+    history: list[dict] = Field(
+        default_factory=list,
+        description="Pre-loaded conversation history from saved session"
+    )
     options: AgentChatOptions = Field(
         default_factory=AgentChatOptions,
         description="Agent options"

emdash_core/server.py

@@ -89,18 +89,13 @@ async def lifespan(app: FastAPI):
     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))
+    # Note: Port file management is handled by ServerManager (per-repo files)
 
     yield
 
     # Shutdown
     print("EmDash Core shutting down...")
     _shutdown_executors()
-    if port_file.exists():
-        port_file.unlink()
 
 
 def create_app(

emdash_core/sse/stream.py

@@ -8,6 +8,8 @@ from typing import Any, AsyncIterator
 
 from pydantic import BaseModel
 
+from ..utils.logger import log
+
 
 class EventType(str, Enum):
     """Types of events emitted by agents (matches emdash.agent.events.EventType)."""
@@ -27,10 +29,12 @@ class EventType(str, Enum):
     # Output
     RESPONSE = "response"
     PARTIAL_RESPONSE = "partial_response"
+    ASSISTANT_TEXT = "assistant_text"
 
     # Interaction
     CLARIFICATION = "clarification"
     CLARIFICATION_RESPONSE = "clarification_response"
+    PLAN_MODE_REQUESTED = "plan_mode_requested"
     PLAN_SUBMITTED = "plan_submitted"
 
     # Errors
@@ -100,9 +104,20 @@ class SSEHandler:
         if self._closed:
             return
 
+        # Convert event type, with error handling for unknown types
+        try:
+            event_type = EventType(event.type.value)
+        except ValueError:
+            log.warning(
+                f"Unknown SSE event type: {event.type.value} - event dropped. "
+                "This may indicate EventType enum in sse/stream.py is out of sync "
+                "with agent/events.py"
+            )
+            return
+
         # Convert to SSEEvent
         sse_event = SSEEvent(
-            type=EventType(event.type.value),
+            type=event_type,
             data=event.data,
             timestamp=event.timestamp,
             agent_name=event.agent_name or self._agent_name,

emdash_core/utils/__init__.py

@@ -7,7 +7,6 @@ from .image import (
     read_clipboard_image,
     encode_image_to_base64,
     encode_image_for_llm,
-    resize_image_if_needed,
     get_image_info,
     estimate_image_tokens,
     read_and_prepare_image,
@@ -31,7 +30,6 @@ __all__ = [
     "read_clipboard_image",
     "encode_image_to_base64",
     "encode_image_for_llm",
-    "resize_image_if_needed",
     "get_image_info",
     "estimate_image_tokens",
     "read_and_prepare_image",

emdash_core/utils/git.py

@@ -82,3 +82,106 @@ def get_normalized_remote_url(repo_root: Path) -> Optional[str]:
     if remote_url:
         return normalize_repo_url(remote_url)
     return None
+
+
+def get_current_branch(repo_root: Path) -> Optional[str]:
+    """Get the current git branch name.
+
+    Args:
+        repo_root: Path to the git repository root
+
+    Returns:
+        The current branch name or None if not found/not in a git repo
+    """
+    try:
+        result = subprocess.run(
+            ["git", "rev-parse", "--abbrev-ref", "HEAD"],
+            cwd=repo_root,
+            capture_output=True,
+            text=True,
+            timeout=5,
+        )
+        if result.returncode == 0:
+            return result.stdout.strip()
+    except (subprocess.TimeoutExpired, FileNotFoundError, OSError):
+        pass
+    return None
+
+
+def get_git_status_summary(repo_root: Path) -> Optional[str]:
+    """Get a brief summary of git status.
+
+    Args:
+        repo_root: Path to the git repository root
+
+    Returns:
+        Brief status summary (e.g., "3 modified, 2 untracked") or None
+    """
+    try:
+        result = subprocess.run(
+            ["git", "status", "--porcelain"],
+            cwd=repo_root,
+            capture_output=True,
+            text=True,
+            timeout=5,
+        )
+        if result.returncode != 0:
+            return None
+
+        lines = result.stdout.strip().split("\n") if result.stdout.strip() else []
+        if not lines:
+            return "clean"
+
+        # Count by status type
+        modified = 0
+        untracked = 0
+        staged = 0
+        deleted = 0
+
+        for line in lines:
+            if not line:
+                continue
+            status = line[:2]
+            if status == "??":
+                untracked += 1
+            elif status[0] in ("M", "A", "D", "R", "C"):
+                staged += 1
+            elif status[1] == "M":
+                modified += 1
+            elif status[1] == "D":
+                deleted += 1
+
+        parts = []
+        if staged:
+            parts.append(f"{staged} staged")
+        if modified:
+            parts.append(f"{modified} modified")
+        if deleted:
+            parts.append(f"{deleted} deleted")
+        if untracked:
+            parts.append(f"{untracked} untracked")
+
+        return ", ".join(parts) if parts else "clean"
+
+    except (subprocess.TimeoutExpired, FileNotFoundError, OSError):
+        pass
+    return None
+
+
+def get_repo_name(repo_root: Path) -> Optional[str]:
+    """Get the repository name from the remote URL or directory name.
+
+    Args:
+        repo_root: Path to the git repository root
+
+    Returns:
+        Repository name (e.g., "user/repo") or None
+    """
+    remote_url = get_normalized_remote_url(repo_root)
+    if remote_url:
+        # Extract user/repo from https://github.com/user/repo
+        parts = remote_url.rstrip("/").split("/")
+        if len(parts) >= 2:
+            return f"{parts[-2]}/{parts[-1]}"
+    # Fallback to directory name
+    return repo_root.name