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

emdash_core/agent/toolkits/plan.py

@@ -5,12 +5,16 @@ The main agent (in plan mode) writes the plan to .emdash/<feature>.md.
 """
 
 from pathlib import Path
+from typing import TYPE_CHECKING, Optional
 
 from .base import BaseToolkit
 from ..tools.coding import ReadFileTool, ListFilesTool
 from ..tools.search import SemanticSearchTool, GrepTool, GlobTool
 from ...utils.logger import log
 
+if TYPE_CHECKING:
+    from ..agents import AgentMCPServerConfig
+
 
 class PlanToolkit(BaseToolkit):
     """Read-only toolkit for Plan subagent.
@@ -24,6 +28,7 @@ class PlanToolkit(BaseToolkit):
     - glob: Find files by pattern
     - grep: Search file contents
     - semantic_search: AI-powered code search
+    - MCP server tools (if configured)
     """
 
     TOOLS = [
@@ -34,6 +39,19 @@ class PlanToolkit(BaseToolkit):
         "semantic_search",
     ]
 
+    def __init__(
+        self,
+        repo_root: Path,
+        mcp_servers: Optional[list["AgentMCPServerConfig"]] = None,
+    ):
+        """Initialize the plan toolkit.
+
+        Args:
+            repo_root: Root directory of the repository
+            mcp_servers: Optional MCP server configurations for this agent
+        """
+        super().__init__(repo_root, mcp_servers=mcp_servers)
+
     def _register_tools(self) -> None:
         """Register read-only exploration tools."""
         # All read-only exploration tools

emdash_core/agent/tools/task.py

@@ -87,11 +87,15 @@ Multiple sub-agents can be launched in parallel."""
                 suggestions=["Provide a clear task description in 'prompt'"],
             )
 
-        available_types = list_agent_types()
+        available_types = list_agent_types(self.repo_root)
+        log.info(f"TaskTool: repo_root={self.repo_root}, available_types={available_types}")
         if subagent_type not in available_types:
             return ToolResult.error_result(
                 f"Unknown agent type: {subagent_type}",
-                suggestions=[f"Available types: {available_types}"],
+                suggestions=[
+                    f"Available types: {available_types}",
+                    f"Searched in: {self.repo_root / '.emdash' / 'agents'}",
+                ],
             )
 
         # Log current mode for debugging
@@ -254,6 +258,9 @@ Multiple sub-agents can be launched in parallel."""
 
     def get_schema(self) -> dict:
         """Get OpenAI function schema."""
+        # Get available agent types dynamically (includes custom agents)
+        available_types = list_agent_types(self.repo_root)
+
         return self._make_schema(
             properties={
                 "description": {
@@ -266,8 +273,8 @@ Multiple sub-agents can be launched in parallel."""
                 },
                 "subagent_type": {
                     "type": "string",
-                    "enum": ["Explore", "Plan"],
-                    "description": "Type of specialized agent",
+                    "enum": available_types,
+                    "description": f"Type of specialized agent. Available: {', '.join(available_types)}",
                     "default": "Explore",
                 },
                 "model_tier": {

emdash_core/api/agent.py

@@ -95,6 +95,7 @@ def _run_agent_sync(
     images: list = None,
     plan_mode: bool = False,
     use_sdk: bool = None,
+    history: list = None,
 ):
     """Run the agent synchronously (in thread pool).
 
@@ -103,6 +104,9 @@ def _run_agent_sync(
 
     For Claude models with use_sdk=True, uses the Anthropic Agent SDK.
     For other models, uses the standard AgentRunner with OpenAI-compatible API.
+
+    Args:
+        history: Optional list of previous messages to pre-populate conversation
     """
     try:
         _ensure_emdash_importable()
@@ -140,6 +144,12 @@ def _run_agent_sync(
         emitter = AgentEventEmitter(agent_name="Emdash Code")
         emitter.add_handler(SSEBridgeHandler(sse_handler))
 
+        # Add hook handler for user-defined hooks
+        from ..agent.hooks import HookHandler, get_hook_manager
+        hook_manager = get_hook_manager()
+        hook_manager.set_session_id(session_id)
+        emitter.add_handler(HookHandler(hook_manager))
+
         # Use SDK for Claude models if enabled
         if use_sdk and is_claude_model(model):
             return _run_sdk_agent(
@@ -152,17 +162,23 @@ def _run_agent_sync(
             )
 
         # Standard path: use AgentRunner with OpenAI-compatible API
+        # Get repo_root from config (set by server on startup)
+        from pathlib import Path
+        from ..config import get_config
+        from ..utils.logger import log
+        config = get_config()
+        repo_root = Path(config.repo_root) if config.repo_root else Path.cwd()
+        log.info(f"Agent API: config.repo_root={config.repo_root}, resolved repo_root={repo_root}")
+
         # Create toolkit with plan_mode if requested
         # When in plan mode, generate a plan file path so write_to_file is available
         plan_file_path = None
         if plan_mode:
-            from pathlib import Path
-            repo_root = Path.cwd()
             plan_file_path = str(repo_root / ".emdash" / "plan.md")
             # Ensure .emdash directory exists
             (repo_root / ".emdash").mkdir(exist_ok=True)
 
-        toolkit = AgentToolkit(plan_mode=plan_mode, plan_file_path=plan_file_path)
+        toolkit = AgentToolkit(repo_root=repo_root, plan_mode=plan_mode, plan_file_path=plan_file_path)
 
         runner = AgentRunner(
             toolkit=toolkit,
@@ -172,6 +188,11 @@ def _run_agent_sync(
             emitter=emitter,
         )
 
+        # Inject pre-loaded conversation history if provided
+        if history:
+            runner._messages = list(history)
+            log.info(f"Injected {len(history)} messages from saved session")
+
         # Store session state BEFORE running (so it exists even if interrupted)
         _sessions[session_id] = {
             "runner": runner,
@@ -180,6 +201,35 @@ def _run_agent_sync(
             "plan_mode": plan_mode,
         }
 
+        # Set up autosave callback if enabled via env var
+        import os
+        import json
+        if os.environ.get("EMDASH_SESSION_AUTOSAVE", "").lower() == "true":
+            sessions_dir = repo_root / ".emdash" / "sessions"
+            sessions_dir.mkdir(parents=True, exist_ok=True)
+            autosave_path = sessions_dir / "_autosave.json"
+
+            def autosave_callback(messages):
+                """Save messages to autosave file after each iteration."""
+                try:
+                    # Limit to last 10 messages
+                    trimmed = messages[-10:] if len(messages) > 10 else messages
+                    autosave_data = {
+                        "name": "_autosave",
+                        "messages": trimmed,
+                        "model": model,
+                        "mode": "plan" if plan_mode else "code",
+                        "session_id": session_id,
+                    }
+                    with open(autosave_path, "w") as f:
+                        json.dump(autosave_data, f, indent=2, default=str)
+                    log.debug(f"Autosaved {len(trimmed)} messages to {autosave_path}")
+                except Exception as e:
+                    log.debug(f"Autosave failed: {e}")
+
+            runner._on_iteration_callback = autosave_callback
+            log.info("Session autosave enabled")
+
         # Convert image data if provided
         agent_images = None
         if images:
@@ -239,6 +289,8 @@ async def _run_agent_async(
             session_id,
             request.images,
             plan_mode,
+            None,  # use_sdk (auto-detect)
+            request.history,  # Pre-loaded conversation history
         )
 
         # Emit session end
@@ -411,6 +463,48 @@ async def delete_session(session_id: str):
     raise HTTPException(status_code=404, detail="Session not found")
 
 
+@router.get("/chat/{session_id}/export")
+async def export_session(session_id: str, limit: int = 10):
+    """Export session messages for persistence.
+
+    Args:
+        session_id: The session ID
+        limit: Maximum number of messages to return (default 10)
+
+    Returns:
+        JSON with messages array and metadata
+    """
+    if session_id not in _sessions:
+        raise HTTPException(status_code=404, detail="Session not found")
+
+    session = _sessions[session_id]
+    runner = session.get("runner")
+
+    if not runner:
+        return {
+            "session_id": session_id,
+            "messages": [],
+            "message_count": 0,
+            "model": session.get("model"),
+            "mode": "plan" if session.get("plan_mode") else "code",
+        }
+
+    # Get messages from runner
+    messages = getattr(runner, "_messages", [])
+
+    # Trim to limit (most recent)
+    if len(messages) > limit:
+        messages = messages[-limit:]
+
+    return {
+        "session_id": session_id,
+        "messages": messages,
+        "message_count": len(messages),
+        "model": session.get("model"),
+        "mode": "plan" if session.get("plan_mode") else "code",
+    }
+
+
 @router.get("/chat/{session_id}/plan")
 async def get_pending_plan(session_id: str):
     """Get the pending plan for a session, if any.
@@ -860,3 +954,60 @@ async def reject_plan_mode(session_id: str, feedback: str = ""):
             "X-Session-ID": session_id,
         },
     )
+
+
+@router.get("/chat/{session_id}/todos")
+async def get_todos(session_id: str):
+    """Get the current todo list for a session.
+
+    Returns the agent's task list including status of each item.
+    """
+    if session_id not in _sessions:
+        raise HTTPException(status_code=404, detail="Session not found")
+
+    # Get todos from TaskState singleton
+    from ..agent.tools.tasks import TaskState
+    state = TaskState.get_instance()
+
+    todos = state.get_all_tasks()
+
+    # Count by status
+    pending = sum(1 for t in todos if t["status"] == "pending")
+    in_progress = sum(1 for t in todos if t["status"] == "in_progress")
+    completed = sum(1 for t in todos if t["status"] == "completed")
+
+    return {
+        "session_id": session_id,
+        "todos": todos,
+        "summary": {
+            "total": len(todos),
+            "pending": pending,
+            "in_progress": in_progress,
+            "completed": completed,
+        },
+    }
+
+
+@router.post("/chat/{session_id}/todos")
+async def add_todo(session_id: str, title: str, description: str = ""):
+    """Add a new todo item to the agent's task list.
+
+    This allows users to inject tasks for the agent to work on.
+    """
+    if session_id not in _sessions:
+        raise HTTPException(status_code=404, detail="Session not found")
+
+    if not title or not title.strip():
+        raise HTTPException(status_code=400, detail="Title is required")
+
+    # Add todo via TaskState singleton
+    from ..agent.tools.tasks import TaskState
+    state = TaskState.get_instance()
+
+    task = state.add_task(title=title.strip(), description=description.strip())
+
+    return {
+        "session_id": session_id,
+        "task": task.to_dict(),
+        "total_tasks": len(state.tasks),
+    }

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

@@ -51,6 +51,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-0.1.33.dist-info → emdash_core-0.1.37.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: emdash-core
-Version: 0.1.33
+Version: 0.1.37
 Summary: EmDash Core - FastAPI server for code intelligence
 Author: Em Dash Team
 Requires-Python: >=3.10,<4.0
@@ -13,6 +13,7 @@ Classifier: Programming Language :: Python :: 3.14
 Requires-Dist: astroid (>=3.0.1,<4.0.0)
 Requires-Dist: beautifulsoup4 (>=4.12.0)
 Requires-Dist: claude-agent-sdk (>=0.1.19)
+Requires-Dist: cmake (>=3.25.0)
 Requires-Dist: duckduckgo-search (>=6.0.0)
 Requires-Dist: fastapi (>=0.109.0)
 Requires-Dist: gitpython (>=3.1.40,<4.0.0)
@@ -28,6 +29,7 @@ Requires-Dist: pydantic-settings (>=2.0.0,<3.0.0)
 Requires-Dist: pygithub (>=2.1.1,<3.0.0)
 Requires-Dist: python-dotenv (>=1.0.0,<2.0.0)
 Requires-Dist: python-louvain (>=0.16,<0.17)
+Requires-Dist: pyyaml (>=6.0,<7.0)
 Requires-Dist: sentence-transformers (>=2.2.0)
 Requires-Dist: sse-starlette (>=2.0.0)
 Requires-Dist: supabase (>=2.0.0)