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

emdash_core/api/agent.py

@@ -38,6 +38,7 @@ def _run_sdk_agent(
     session_id: str,
     emitter,
     plan_mode: bool = False,
+    images: list = None,
 ):
     """Run the agent using Anthropic Agent SDK.
 
@@ -72,7 +73,7 @@ def _run_sdk_agent(
     # Run async agent in sync context
     async def run_async():
         response_text = ""
-        async for event in runner.run(message):
+        async for event in runner.run(message, images=images):
             if event.get("type") == "text":
                 response_text += event.get("content", "")
         return response_text
@@ -96,6 +97,7 @@ def _run_agent_sync(
     plan_mode: bool = False,
     use_sdk: bool = None,
     history: list = None,
+    use_worktree: bool = False,
 ):
     """Run the agent synchronously (in thread pool).
 
@@ -107,6 +109,7 @@ def _run_agent_sync(
 
     Args:
         history: Optional list of previous messages to pre-populate conversation
+        use_worktree: If True, creates a git worktree for isolated changes
     """
     try:
         _ensure_emdash_importable()
@@ -152,6 +155,14 @@ def _run_agent_sync(
 
         # Use SDK for Claude models if enabled
         if use_sdk and is_claude_model(model):
+            # Convert images for SDK if provided
+            sdk_images = None
+            if images:
+                import base64
+                sdk_images = [
+                    {"data": base64.b64decode(img.data), "format": img.format}
+                    for img in images
+                ]
             return _run_sdk_agent(
                 message=message,
                 model=model,
@@ -159,6 +170,7 @@ def _run_agent_sync(
                 session_id=session_id,
                 emitter=emitter,
                 plan_mode=plan_mode,
+                images=sdk_images,
             )
 
         # Standard path: use AgentRunner with OpenAI-compatible API
@@ -170,6 +182,21 @@ def _run_agent_sync(
         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 worktree for isolated changes if requested
+        worktree_info = None
+        if use_worktree and not plan_mode:
+            from ..agent.worktree import WorktreeManager
+            try:
+                worktree_manager = WorktreeManager(repo_root)
+                # Use session_id as task slug (truncated for safety)
+                task_slug = session_id[:20] if len(session_id) > 20 else session_id
+                worktree_info = worktree_manager.create_worktree(task_slug, force=True)
+                repo_root = worktree_info.path
+                log.info(f"Created worktree at {repo_root} on branch {worktree_info.branch}")
+            except Exception as e:
+                log.warning(f"Failed to create worktree: {e}. Running in main repo.")
+                worktree_info = None
+
         # 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
@@ -199,6 +226,7 @@ def _run_agent_sync(
             "message_count": 1,
             "model": model,
             "plan_mode": plan_mode,
+            "worktree_info": worktree_info,  # Will be None if not using worktree
         }
 
         # Set up autosave callback if enabled via env var
@@ -233,9 +261,13 @@ def _run_agent_sync(
         # Convert image data if provided
         agent_images = None
         if images:
+            import base64
             from ..agent.providers.base import ImageContent
             agent_images = [
-                ImageContent(data=img.data, format=img.format)
+                ImageContent(
+                    image_data=base64.b64decode(img.data),
+                    format=img.format
+                )
                 for img in images
             ]
 
@@ -265,6 +297,7 @@ async def _run_agent_async(
     model = request.model or config.default_model
     max_iterations = request.options.max_iterations
     plan_mode = request.options.mode == AgentMode.PLAN
+    use_worktree = request.options.use_worktree
 
     # Emit session start
     sse_handler.emit(EventType.SESSION_START, {
@@ -273,6 +306,7 @@ async def _run_agent_async(
         "session_id": session_id,
         "query": request.message,
         "mode": request.options.mode.value,
+        "use_worktree": use_worktree,
     })
 
     loop = asyncio.get_event_loop()
@@ -291,6 +325,7 @@ async def _run_agent_async(
             plan_mode,
             None,  # use_sdk (auto-detect)
             request.history,  # Pre-loaded conversation history
+            use_worktree,
         )
 
         # Emit session end
@@ -505,6 +540,87 @@ async def export_session(session_id: str, limit: int = 10):
     }
 
 
+@router.post("/chat/{session_id}/compact")
+async def compact_session(session_id: str):
+    """Compact the session's message history using LLM summarization.
+
+    This manually triggers the same compaction that happens automatically
+    when context reaches 80% capacity.
+
+    Returns:
+        JSON with the summary text and stats
+    """
+    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:
+        raise HTTPException(status_code=400, detail="Session has no active runner")
+
+    # Get current messages
+    messages = getattr(runner, "_messages", [])
+    if len(messages) <= 5:
+        return {
+            "compacted": False,
+            "reason": "Not enough messages to compact (need more than 5)",
+            "message_count": len(messages),
+        }
+
+    # Import compaction utilities
+    from ..agent.runner.context import compact_messages_with_llm, estimate_context_tokens
+    from ..agent.events import AgentEventEmitter
+
+    # Create a simple emitter that captures the summary
+    class SummaryCapture:
+        def __init__(self):
+            self.summary = None
+
+        def emit_thinking(self, text):
+            pass  # Ignore thinking events
+
+    emitter = SummaryCapture()
+
+    # Estimate current tokens
+    original_tokens = estimate_context_tokens(messages)
+
+    # Compact messages
+    compacted_messages = compact_messages_with_llm(
+        messages,
+        emitter,
+        target_tokens=int(original_tokens * 0.5),
+    )
+
+    # Extract the summary from the compacted messages
+    summary_text = None
+    for msg in compacted_messages:
+        if msg.get("role") == "assistant" and "[Context Summary]" in str(msg.get("content", "")):
+            content = msg.get("content", "")
+            # Extract text between [Context Summary] and [End Summary]
+            start = content.find("[Context Summary]") + len("[Context Summary]")
+            end = content.find("[End Summary]")
+            if end > start:
+                summary_text = content[start:end].strip()
+            break
+
+    # Update runner's messages
+    runner._messages = compacted_messages
+
+    # Estimate new tokens
+    new_tokens = estimate_context_tokens(compacted_messages)
+
+    return {
+        "compacted": True,
+        "summary": summary_text,
+        "original_message_count": len(messages),
+        "new_message_count": len(compacted_messages),
+        "original_tokens": original_tokens,
+        "new_tokens": new_tokens,
+        "reduction_percent": round((1 - new_tokens / original_tokens) * 100, 1) if original_tokens > 0 else 0,
+    }
+
+
 @router.get("/chat/{session_id}/plan")
 async def get_pending_plan(session_id: str):
     """Get the pending plan for a session, if any.
@@ -1011,3 +1127,182 @@ async def add_todo(session_id: str, title: str, description: str = ""):
         "task": task.to_dict(),
         "total_tasks": len(state.tasks),
     }
+
+
+# ==================== Worktree Management ====================
+
+
+@router.get("/chat/{session_id}/worktree")
+async def get_worktree_status(session_id: str):
+    """Get the worktree status for a session.
+
+    Returns information about whether the session is using a worktree,
+    the branch name, and any uncommitted changes.
+    """
+    if session_id not in _sessions:
+        raise HTTPException(status_code=404, detail="Session not found")
+
+    session = _sessions[session_id]
+    worktree_info = session.get("worktree_info")
+
+    if not worktree_info:
+        return {
+            "session_id": session_id,
+            "has_worktree": False,
+        }
+
+    # Check for uncommitted changes in the worktree
+    import subprocess
+    try:
+        result = subprocess.run(
+            ["git", "status", "--porcelain"],
+            cwd=str(worktree_info.path),
+            capture_output=True,
+            text=True,
+        )
+        has_changes = bool(result.stdout.strip())
+        changes = result.stdout.strip().split("\n") if has_changes else []
+    except Exception:
+        has_changes = False
+        changes = []
+
+    return {
+        "session_id": session_id,
+        "has_worktree": True,
+        "worktree_path": str(worktree_info.path),
+        "branch": worktree_info.branch,
+        "base_branch": worktree_info.base_branch,
+        "has_changes": has_changes,
+        "changes": changes,
+    }
+
+
+@router.post("/chat/{session_id}/worktree/apply")
+async def apply_worktree_changes(session_id: str, commit_message: str = None):
+    """Apply worktree changes to the main branch.
+
+    This merges the worktree branch into the base branch and cleans up.
+    """
+    from ..utils.logger import log
+
+    if session_id not in _sessions:
+        raise HTTPException(status_code=404, detail="Session not found")
+
+    session = _sessions[session_id]
+    worktree_info = session.get("worktree_info")
+
+    if not worktree_info:
+        raise HTTPException(status_code=400, detail="Session is not using a worktree")
+
+    import subprocess
+    from pathlib import Path
+
+    try:
+        worktree_path = worktree_info.path
+        branch = worktree_info.branch
+        base_branch = worktree_info.base_branch
+
+        # First, commit any uncommitted changes in the worktree
+        result = subprocess.run(
+            ["git", "status", "--porcelain"],
+            cwd=str(worktree_path),
+            capture_output=True,
+            text=True,
+        )
+        if result.stdout.strip():
+            # Stage all changes
+            subprocess.run(["git", "add", "-A"], cwd=str(worktree_path), check=True)
+            # Commit
+            msg = commit_message or f"Agent session {session_id[:8]} changes"
+            subprocess.run(
+                ["git", "commit", "-m", msg],
+                cwd=str(worktree_path),
+                check=True,
+            )
+            log.info(f"Committed changes in worktree: {msg}")
+
+        # Get the main repo root (parent of .emdash-worktrees)
+        from ..config import get_config
+        config = get_config()
+        main_repo = Path(config.repo_root) if config.repo_root else Path.cwd()
+
+        # Merge the worktree branch into base branch
+        subprocess.run(
+            ["git", "checkout", base_branch],
+            cwd=str(main_repo),
+            check=True,
+        )
+        subprocess.run(
+            ["git", "merge", branch, "--no-ff", "-m", f"Merge {branch}"],
+            cwd=str(main_repo),
+            check=True,
+        )
+        log.info(f"Merged {branch} into {base_branch}")
+
+        # Clean up the worktree
+        from ..agent.worktree import WorktreeManager
+        worktree_manager = WorktreeManager(main_repo)
+        worktree_manager.remove_worktree(worktree_info.task_slug)
+        log.info(f"Removed worktree {worktree_info.task_slug}")
+
+        # Clear worktree info from session
+        session["worktree_info"] = None
+
+        return {
+            "session_id": session_id,
+            "success": True,
+            "message": f"Changes from {branch} merged into {base_branch}",
+        }
+
+    except subprocess.CalledProcessError as e:
+        log.error(f"Failed to apply worktree changes: {e}")
+        raise HTTPException(
+            status_code=500,
+            detail=f"Failed to apply changes: {e.stderr if hasattr(e, 'stderr') else str(e)}"
+        )
+    except Exception as e:
+        log.error(f"Error applying worktree changes: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.delete("/chat/{session_id}/worktree")
+async def discard_worktree(session_id: str):
+    """Discard worktree changes and clean up.
+
+    This removes the worktree and branch without merging.
+    """
+    from ..utils.logger import log
+
+    if session_id not in _sessions:
+        raise HTTPException(status_code=404, detail="Session not found")
+
+    session = _sessions[session_id]
+    worktree_info = session.get("worktree_info")
+
+    if not worktree_info:
+        raise HTTPException(status_code=400, detail="Session is not using a worktree")
+
+    try:
+        from pathlib import Path
+        from ..config import get_config
+        from ..agent.worktree import WorktreeManager
+
+        config = get_config()
+        main_repo = Path(config.repo_root) if config.repo_root else Path.cwd()
+
+        worktree_manager = WorktreeManager(main_repo)
+        worktree_manager.remove_worktree(worktree_info.task_slug)
+        log.info(f"Discarded worktree {worktree_info.task_slug}")
+
+        # Clear worktree info from session
+        session["worktree_info"] = None
+
+        return {
+            "session_id": session_id,
+            "success": True,
+            "message": f"Worktree {worktree_info.task_slug} discarded",
+        }
+
+    except Exception as e:
+        log.error(f"Error discarding worktree: {e}")
+        raise HTTPException(status_code=500, detail=str(e))

emdash_core/api/research.py

@@ -43,9 +43,9 @@ def _run_research_sync(
     import sys
     from pathlib import Path
 
-    repo_root = Path(__file__).parent.parent.parent.parent.parent
-    if str(repo_root) not in sys.path:
-        sys.path.insert(0, str(repo_root))
+    from ..config import get_config
+    config = get_config()
+    repo_root = Path(config.repo_root) if config.repo_root else Path.cwd()
 
     try:
         from ..agent.research.agent import ResearchAgent

emdash_core/api/router.py

@@ -19,7 +19,6 @@ from . import (
     research,
     review,
     embed,
-    swarm,
     rules,
     context,
     feature,
@@ -67,9 +66,6 @@ api_router.include_router(review.router)
 # Embeddings
 api_router.include_router(embed.router)
 
-# Multi-agent
-api_router.include_router(swarm.router)
-
 # Configuration
 api_router.include_router(rules.router)
 api_router.include_router(context.router)

emdash_core/context/longevity.py

@@ -0,0 +1,197 @@
+"""Longevity tracking for context items.
+
+Tracks which entities appear repeatedly across reranking calls.
+Items that keep appearing are likely important and get boosted.
+
+This uses an in-memory cache that resets on process restart.
+For persistence, the cache could be stored in the graph database.
+"""
+
+import math
+import time
+from dataclasses import dataclass, field
+from typing import Optional
+
+
+@dataclass
+class LongevityRecord:
+    """Track an entity's appearance history."""
+
+    qualified_name: str
+    appearance_count: int = 0
+    first_seen: float = field(default_factory=time.time)
+    last_seen: float = field(default_factory=time.time)
+
+    def record_appearance(self) -> None:
+        """Record a new appearance of this entity."""
+        self.appearance_count += 1
+        self.last_seen = time.time()
+
+    def get_longevity_score(self, now: Optional[float] = None) -> float:
+        """Calculate longevity score based on appearance count.
+
+        Longevity = items that have appeared in context frame more than once.
+        No time-based decay - if it keeps appearing, it's important.
+
+        Score formula (log scale for diminishing returns):
+        - 1 appearance = 0.0 (first time, no longevity yet)
+        - 2 appearances = 0.37
+        - 3 appearances = 0.50
+        - 5 appearances = 0.62
+        - 10 appearances = 0.77
+        - 20 appearances = 0.90
+
+        Args:
+            now: Current timestamp (unused, kept for API compatibility)
+
+        Returns:
+            Score between 0.0 and 1.0
+        """
+        if self.appearance_count <= 1:
+            return 0.0  # First appearance = no longevity
+
+        # Log scale for diminishing returns
+        # Subtract 1 so first repeat (count=2) starts contributing
+        return min(1.0, math.log(self.appearance_count) / 3)
+
+
+class LongevityTracker:
+    """Tracks entity appearances across reranking calls."""
+
+    def __init__(self, max_entries: int = 1000):
+        """Initialize the tracker.
+
+        Args:
+            max_entries: Maximum number of entities to track (LRU eviction)
+        """
+        self._records: dict[str, LongevityRecord] = {}
+        self._max_entries = max_entries
+
+    def record_appearance(self, qualified_name: str) -> None:
+        """Record that an entity appeared in reranking.
+
+        Args:
+            qualified_name: The entity's qualified name
+        """
+        if qualified_name in self._records:
+            self._records[qualified_name].record_appearance()
+        else:
+            # Evict oldest entries if at capacity
+            if len(self._records) >= self._max_entries:
+                self._evict_oldest()
+
+            self._records[qualified_name] = LongevityRecord(
+                qualified_name=qualified_name,
+                appearance_count=1,
+            )
+
+    def record_batch(self, qualified_names: list[str]) -> None:
+        """Record appearances for multiple entities.
+
+        Args:
+            qualified_names: List of entity qualified names
+        """
+        for qname in qualified_names:
+            self.record_appearance(qname)
+
+    def get_longevity_score(self, qualified_name: str) -> float:
+        """Get the longevity score for an entity.
+
+        Args:
+            qualified_name: The entity's qualified name
+
+        Returns:
+            Score between 0.0 and 1.0 (0.0 if never seen)
+        """
+        record = self._records.get(qualified_name)
+        if record is None:
+            return 0.0
+        return record.get_longevity_score()
+
+    def get_appearance_count(self, qualified_name: str) -> int:
+        """Get how many times an entity has appeared.
+
+        Args:
+            qualified_name: The entity's qualified name
+
+        Returns:
+            Number of appearances (0 if never seen)
+        """
+        record = self._records.get(qualified_name)
+        return record.appearance_count if record else 0
+
+    def _evict_oldest(self) -> None:
+        """Evict the oldest (least recently seen) entries."""
+        if not self._records:
+            return
+
+        # Sort by last_seen and remove bottom 10%
+        sorted_records = sorted(
+            self._records.items(),
+            key=lambda x: x[1].last_seen,
+        )
+
+        evict_count = max(1, len(sorted_records) // 10)
+        for qname, _ in sorted_records[:evict_count]:
+            del self._records[qname]
+
+    def clear(self) -> None:
+        """Clear all longevity records."""
+        self._records.clear()
+
+    def get_stats(self) -> dict:
+        """Get statistics about the tracker.
+
+        Returns:
+            Dictionary with tracker statistics
+        """
+        if not self._records:
+            return {
+                "total_entities": 0,
+                "total_appearances": 0,
+                "avg_appearances": 0,
+                "max_appearances": 0,
+            }
+
+        appearances = [r.appearance_count for r in self._records.values()]
+        return {
+            "total_entities": len(self._records),
+            "total_appearances": sum(appearances),
+            "avg_appearances": sum(appearances) / len(appearances),
+            "max_appearances": max(appearances),
+        }
+
+
+# Global tracker instance (shared across reranking calls)
+_global_tracker: Optional[LongevityTracker] = None
+
+
+def get_longevity_tracker() -> LongevityTracker:
+    """Get the global longevity tracker (creates if needed)."""
+    global _global_tracker
+    if _global_tracker is None:
+        _global_tracker = LongevityTracker()
+    return _global_tracker
+
+
+def record_reranked_items(qualified_names: list[str]) -> None:
+    """Record that items appeared in a reranking result.
+
+    Call this after reranking to update longevity scores.
+
+    Args:
+        qualified_names: List of qualified names that were reranked
+    """
+    get_longevity_tracker().record_batch(qualified_names)
+
+
+def get_longevity_score(qualified_name: str) -> float:
+    """Get the longevity score for an entity.
+
+    Args:
+        qualified_name: The entity's qualified name
+
+    Returns:
+        Score between 0.0 and 1.0
+    """
+    return get_longevity_tracker().get_longevity_score(qualified_name)