emdash-core 0.1.7__py3-none-any.whl

emdash_core/swarm/merge_agent.py

@@ -0,0 +1,383 @@
+"""Intelligent merge agent for combining parallel work."""
+
+import json
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Optional, TYPE_CHECKING
+
+from git import Repo
+
+from .task_definition import SwarmTask, TaskStatus
+from .worktree_manager import WorktreeManager
+from ..utils.logger import log
+
+# Optional agent providers import (for LLM-assisted merging)
+try:
+    from ..agent.providers import get_provider
+    from ..agent.providers.factory import DEFAULT_MODEL
+    _HAS_AGENT_PROVIDERS = True
+except ImportError:
+    _HAS_AGENT_PROVIDERS = False
+    DEFAULT_MODEL = "gpt-4o-mini"
+    get_provider = None  # type: ignore
+
+
+@dataclass
+class MergeResult:
+    """Result of merging a task branch."""
+    task_id: str
+    success: bool
+    merge_type: str  # fast-forward, merge, rebase, manual, skipped
+    conflicts: list[str]
+    commit_sha: Optional[str]
+    error_message: Optional[str]
+
+
+MERGE_AGENT_PROMPT = """You are an expert software engineer merging multiple feature branches.
+
+## Completed Tasks (Already Merged)
+{task_summaries}
+
+## Current Branch to Merge
+Branch: {current_branch}
+Task: {task_title}
+Files modified: {files_modified}
+
+## Merge Conflicts Detected
+{conflict_files}
+
+## Conflict Content
+{conflict_content}
+
+## Instructions
+Analyze the conflicts and provide resolution guidance. For each conflict:
+1. Understand what both sides are trying to do
+2. Determine if changes are complementary (combine) or contradictory (choose one)
+3. Provide the resolved content
+
+Output your analysis as JSON:
+```json
+{{
+  "analysis": "Brief analysis of the conflicts",
+  "resolutions": [
+    {{
+      "file": "path/to/file",
+      "strategy": "combine|keep_ours|keep_theirs",
+      "explanation": "Why this resolution",
+      "resolved_content": "The merged content (if strategy is combine)"
+    }}
+  ],
+  "commit_message": "Suggested merge commit message"
+}}
+```
+"""
+
+
+class MergeAgent:
+    """Intelligently merges completed task branches.
+
+    Uses LLM to analyze changes and resolve conflicts when needed.
+    Falls back to manual intervention for complex conflicts.
+
+    Example:
+        agent = MergeAgent(repo_root=Path("."))
+
+        # Merge all completed tasks
+        results = agent.merge_all_completed(tasks, target_branch="main")
+
+        # Or merge with AI assistance
+        results = agent.merge_with_assistance(tasks, model="gpt-4o")
+    """
+
+    def __init__(self, repo_root: Path, model: str = DEFAULT_MODEL):
+        self.repo_root = repo_root.resolve()
+        self.repo = Repo(repo_root)
+        self.model = model
+        self.worktree_manager = WorktreeManager(repo_root)
+
+    def get_branch_diff_summary(self, branch: str, base: str = "main") -> dict:
+        """Get summary of changes on a branch."""
+        try:
+            # Get list of changed files
+            diff = self.repo.git.diff(f"{base}...{branch}", name_only=True)
+            files = diff.strip().split("\n") if diff.strip() else []
+
+            # Get commit count
+            commits = self.repo.git.rev_list(f"{base}..{branch}", count=True)
+
+            # Get diff stats
+            stat = self.repo.git.diff(f"{base}...{branch}", stat=True)
+
+            return {
+                "branch": branch,
+                "files_changed": files,
+                "commit_count": int(commits) if commits else 0,
+                "stat_summary": stat[-500:] if stat else "",
+            }
+        except Exception as e:
+            log.warning(f"Failed to get diff summary for {branch}: {e}")
+            return {
+                "branch": branch,
+                "files_changed": [],
+                "commit_count": 0,
+                "stat_summary": "",
+            }
+
+    def attempt_fast_forward(self, branch: str, target: str = "main") -> MergeResult:
+        """Try fast-forward merge (cleanest option)."""
+        try:
+            # Check if FF is possible
+            merge_base = self.repo.git.merge_base(target, branch)
+            target_sha = self.repo.refs[target].commit.hexsha
+
+            if merge_base == target_sha:
+                # Fast-forward possible
+                self.repo.git.checkout(target)
+                self.repo.git.merge(branch, ff_only=True)
+
+                return MergeResult(
+                    task_id="",
+                    success=True,
+                    merge_type="fast-forward",
+                    conflicts=[],
+                    commit_sha=self.repo.head.commit.hexsha,
+                    error_message=None,
+                )
+        except Exception:
+            pass
+
+        return MergeResult(
+            task_id="",
+            success=False,
+            merge_type="none",
+            conflicts=[],
+            commit_sha=None,
+            error_message="Fast-forward not possible",
+        )
+
+    def attempt_merge(self, branch: str, target: str = "main") -> MergeResult:
+        """Try standard merge."""
+        try:
+            self.repo.git.checkout(target)
+
+            try:
+                self.repo.git.merge(branch, no_ff=True, m=f"Merge {branch}")
+
+                return MergeResult(
+                    task_id="",
+                    success=True,
+                    merge_type="merge",
+                    conflicts=[],
+                    commit_sha=self.repo.head.commit.hexsha,
+                    error_message=None,
+                )
+            except Exception as e:
+                # Check for conflicts
+                status = self.repo.git.status(porcelain=True)
+                conflicts = []
+                for line in status.split("\n"):
+                    if line.startswith("UU ") or line.startswith("AA "):
+                        conflicts.append(line[3:])
+
+                # Abort the merge
+                try:
+                    self.repo.git.merge(abort=True)
+                except Exception:
+                    pass
+
+                return MergeResult(
+                    task_id="",
+                    success=False,
+                    merge_type="conflicts",
+                    conflicts=conflicts,
+                    commit_sha=None,
+                    error_message=str(e),
+                )
+
+        except Exception as e:
+            return MergeResult(
+                task_id="",
+                success=False,
+                merge_type="error",
+                conflicts=[],
+                commit_sha=None,
+                error_message=str(e),
+            )
+
+    def get_conflict_content(self, files: list[str]) -> str:
+        """Get the content of conflicted files."""
+        content_parts = []
+        for file_path in files[:5]:  # Limit to 5 files
+            try:
+                full_path = self.repo_root / file_path
+                if full_path.exists():
+                    content = full_path.read_text()
+                    # Only include conflict markers section
+                    if "<<<<<<<" in content:
+                        content_parts.append(f"### {file_path}\n```\n{content[:3000]}\n```")
+            except Exception:
+                pass
+        return "\n\n".join(content_parts) if content_parts else "No conflict content available"
+
+    def merge_with_llm_assistance(
+        self,
+        task: SwarmTask,
+        target: str = "main",
+        other_tasks: Optional[list[SwarmTask]] = None,
+    ) -> MergeResult:
+        """Use LLM to help with merge strategy and conflict resolution."""
+        if not _HAS_AGENT_PROVIDERS or get_provider is None:
+            log.warning("Agent providers not available, falling back to standard merge")
+            return self.attempt_merge(task.branch, target)
+
+        provider = get_provider(self.model)
+
+        # First, try a normal merge to see if there are conflicts
+        self.repo.git.checkout(target)
+        try:
+            self.repo.git.merge(task.branch, no_commit=True, no_ff=True)
+            # No conflicts - commit the merge
+            self.repo.git.commit(m=f"Merge {task.branch}: {task.title}")
+            return MergeResult(
+                task_id=task.id,
+                success=True,
+                merge_type="merge",
+                conflicts=[],
+                commit_sha=self.repo.head.commit.hexsha,
+                error_message=None,
+            )
+        except Exception:
+            pass
+
+        # There are conflicts - get their details
+        status = self.repo.git.status(porcelain=True)
+        conflicts = []
+        for line in status.split("\n"):
+            if line.startswith("UU ") or line.startswith("AA "):
+                conflicts.append(line[3:])
+
+        if not conflicts:
+            # No conflicts detected, abort and return
+            try:
+                self.repo.git.merge(abort=True)
+            except Exception:
+                pass
+            return MergeResult(
+                task_id=task.id,
+                success=False,
+                merge_type="error",
+                conflicts=[],
+                commit_sha=None,
+                error_message="Merge failed without detectable conflicts",
+            )
+
+        # Get conflict content for LLM
+        conflict_content = self.get_conflict_content(conflicts)
+
+        # Build context for LLM
+        task_summaries = []
+        for t in (other_tasks or []):
+            if t.status == TaskStatus.MERGED:
+                task_summaries.append(f"- {t.title}: {t.completion_summary or 'No summary'}")
+
+        diff_info = self.get_branch_diff_summary(task.branch, target)
+
+        prompt = MERGE_AGENT_PROMPT.format(
+            task_summaries="\n".join(task_summaries) or "None yet",
+            current_branch=task.branch,
+            task_title=task.title,
+            files_modified=", ".join(diff_info["files_changed"][:20]),
+            conflict_files=", ".join(conflicts),
+            conflict_content=conflict_content,
+        )
+
+        # Get LLM recommendation
+        messages = [{"role": "user", "content": prompt}]
+        response = provider.chat(messages)
+
+        # Log the LLM's analysis
+        log.info(f"LLM merge analysis for {task.slug}: {response.content[:500] if response.content else 'No response'}")
+
+        # For now, abort and mark as needing manual intervention
+        # A more sophisticated version would parse the JSON and apply resolutions
+        try:
+            self.repo.git.merge(abort=True)
+        except Exception:
+            pass
+
+        return MergeResult(
+            task_id=task.id,
+            success=False,
+            merge_type="manual",
+            conflicts=conflicts,
+            commit_sha=None,
+            error_message=f"LLM analysis complete. Manual resolution needed. See logs for guidance.",
+        )
+
+    def merge_all_completed(
+        self,
+        tasks: list[SwarmTask],
+        target: str = "main",
+        use_llm: bool = False,
+        cleanup_worktrees: bool = True,
+    ) -> list[MergeResult]:
+        """Merge all completed tasks in order.
+
+        Args:
+            tasks: All tasks (will filter to completed ones)
+            target: Target branch to merge into
+            use_llm: Whether to use LLM for merge assistance
+            cleanup_worktrees: Whether to delete worktrees after successful merge
+
+        Returns:
+            List of merge results
+        """
+        results = []
+        completed_tasks = [t for t in tasks if t.status == TaskStatus.COMPLETED]
+
+        if not completed_tasks:
+            log.info("No completed tasks to merge")
+            return results
+
+        # Sort by completion time (merge earlier completions first)
+        completed_tasks.sort(key=lambda t: t.completed_at or "")
+
+        merged_tasks: list[SwarmTask] = []
+
+        for task in completed_tasks:
+            log.info(f"Merging task: {task.title} ({task.branch})")
+
+            # Try fast-forward first
+            result = self.attempt_fast_forward(task.branch, target)
+
+            if not result.success:
+                if use_llm:
+                    result = self.merge_with_llm_assistance(task, target, merged_tasks)
+                else:
+                    result = self.attempt_merge(task.branch, target)
+
+            result.task_id = task.id
+            results.append(result)
+
+            # Update task status
+            if result.success:
+                task.status = TaskStatus.MERGED
+                task.merge_status = "success"
+                merged_tasks.append(task)
+
+                # Clean up worktree after successful merge
+                if cleanup_worktrees and task.slug:
+                    try:
+                        self.worktree_manager.remove_worktree(task.slug)
+                        log.info(f"Cleaned up worktree for merged task: {task.slug}")
+                    except Exception as e:
+                        log.warning(f"Failed to clean up worktree {task.slug}: {e}")
+            else:
+                task.merge_status = "conflicts"
+                task.merge_conflicts = result.conflicts
+
+                # Save updated task state (only if not cleaned up)
+                if task.worktree_path:
+                    task.save(Path(task.worktree_path))
+
+        return results

emdash_core/swarm/session_manager.py

@@ -0,0 +1,274 @@
+"""Session management for automatic worktree isolation."""
+
+import atexit
+import fcntl
+import json
+import os
+import signal
+import sys
+from dataclasses import dataclass, asdict
+from datetime import datetime
+from pathlib import Path
+from typing import Optional
+from uuid import uuid4
+
+from .worktree_manager import WorktreeManager
+from ..utils.logger import log
+
+
+@dataclass
+class Session:
+    """An active emdash agent session."""
+    id: str
+    pid: int
+    worktree_path: Optional[str]  # None if using main repo
+    branch: Optional[str]
+    started_at: str
+    task_hint: str  # First task or description
+
+    def to_dict(self) -> dict:
+        return asdict(self)
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "Session":
+        return cls(**data)
+
+
+class SessionManager:
+    """Manages multiple concurrent emdash agent sessions.
+
+    When multiple `emdash agent code` instances run:
+    1. First instance uses main repo
+    2. Subsequent instances get auto-created worktrees
+    3. Sessions are tracked in .emdash-worktrees/.sessions.json
+    4. Cleanup happens on exit
+
+    Example:
+        # Terminal 1
+        $ emdash agent code "Add auth"
+        # Uses main repo
+
+        # Terminal 2 (while terminal 1 is running)
+        $ emdash agent code "Fix bug"
+        # Auto-creates worktree, prints message about isolation
+
+        # Both can work in parallel without conflicts
+    """
+
+    SESSIONS_DIR = ".emdash-worktrees"
+    SESSIONS_FILE = ".sessions.json"
+    LOCK_FILE = ".sessions.lock"
+
+    def __init__(self, repo_root: Path):
+        self.repo_root = repo_root.resolve()
+        self.sessions_dir = self.repo_root / self.SESSIONS_DIR
+        self.sessions_file = self.sessions_dir / self.SESSIONS_FILE
+        self.lock_file = self.sessions_dir / self.LOCK_FILE
+        self.worktree_manager = WorktreeManager(repo_root)
+
+        self.current_session: Optional[Session] = None
+        self._lock_fd: Optional[int] = None
+
+    def _ensure_dir(self):
+        """Ensure sessions directory exists."""
+        self.sessions_dir.mkdir(parents=True, exist_ok=True)
+
+    def _acquire_lock(self) -> bool:
+        """Acquire exclusive lock for session file operations."""
+        self._ensure_dir()
+        try:
+            self._lock_fd = os.open(str(self.lock_file), os.O_CREAT | os.O_RDWR)
+            fcntl.flock(self._lock_fd, fcntl.LOCK_EX)
+            return True
+        except Exception as e:
+            log.warning(f"Failed to acquire session lock: {e}")
+            return False
+
+    def _release_lock(self):
+        """Release the session lock."""
+        if self._lock_fd is not None:
+            try:
+                fcntl.flock(self._lock_fd, fcntl.LOCK_UN)
+                os.close(self._lock_fd)
+            except Exception:
+                pass
+            self._lock_fd = None
+
+    def _load_sessions(self) -> list[Session]:
+        """Load current sessions from file."""
+        if not self.sessions_file.exists():
+            return []
+
+        try:
+            with open(self.sessions_file) as f:
+                data = json.load(f)
+                return [Session.from_dict(s) for s in data.get("sessions", [])]
+        except Exception:
+            return []
+
+    def _save_sessions(self, sessions: list[Session]):
+        """Save sessions to file."""
+        self._ensure_dir()
+        with open(self.sessions_file, "w") as f:
+            json.dump({
+                "sessions": [s.to_dict() for s in sessions],
+                "updated_at": datetime.now().isoformat(),
+            }, f, indent=2)
+
+    def _is_process_alive(self, pid: int) -> bool:
+        """Check if a process is still running."""
+        try:
+            os.kill(pid, 0)
+            return True
+        except OSError:
+            return False
+
+    def _cleanup_dead_sessions(self, sessions: list[Session]) -> list[Session]:
+        """Remove sessions from dead processes."""
+        alive = []
+        for session in sessions:
+            if self._is_process_alive(session.pid):
+                alive.append(session)
+            else:
+                log.debug(f"Cleaning up dead session {session.id} (pid {session.pid})")
+        return alive
+
+    def _is_main_repo_occupied(self, sessions: list[Session]) -> bool:
+        """Check if any session is using the main repo."""
+        for session in sessions:
+            if session.worktree_path is None:
+                return True
+        return False
+
+    def start_session(self, task_hint: str = "", base_branch: str | None = None) -> tuple[Path, Optional[str]]:
+        """Start a new session, creating worktree if needed.
+
+        Args:
+            task_hint: Description of the task (used for worktree naming)
+            base_branch: Branch to base worktree on
+
+        Returns:
+            (working_directory, branch_name or None if main repo)
+        """
+        self._acquire_lock()
+        try:
+            sessions = self._load_sessions()
+            sessions = self._cleanup_dead_sessions(sessions)
+
+            session_id = str(uuid4())[:8]
+            pid = os.getpid()
+
+            if self._is_main_repo_occupied(sessions):
+                # Create worktree for this session
+                slug = self._make_slug(task_hint, session_id)
+                info = self.worktree_manager.create_worktree(
+                    task_name=slug,
+                    base_branch=base_branch,
+                    force=True,
+                )
+
+                self.current_session = Session(
+                    id=session_id,
+                    pid=pid,
+                    worktree_path=str(info.path),
+                    branch=info.branch,
+                    started_at=datetime.now().isoformat(),
+                    task_hint=task_hint[:100] if task_hint else "",
+                )
+
+                sessions.append(self.current_session)
+                self._save_sessions(sessions)
+
+                # Register cleanup handlers
+                self._register_cleanup()
+
+                return info.path, info.branch
+            else:
+                # Use main repo
+                self.current_session = Session(
+                    id=session_id,
+                    pid=pid,
+                    worktree_path=None,
+                    branch=None,
+                    started_at=datetime.now().isoformat(),
+                    task_hint=task_hint[:100] if task_hint else "",
+                )
+
+                sessions.append(self.current_session)
+                self._save_sessions(sessions)
+
+                # Register cleanup handlers
+                self._register_cleanup()
+
+                return self.repo_root, None
+
+        finally:
+            self._release_lock()
+
+    def _make_slug(self, task_hint: str, session_id: str) -> str:
+        """Create a slug for the worktree."""
+        import re
+        if task_hint:
+            slug = task_hint.lower().strip()
+            slug = re.sub(r"[^\w\s-]", "", slug)
+            slug = re.sub(r"[-\s]+", "-", slug)
+            slug = slug[:30]
+        else:
+            slug = f"session-{session_id}"
+        return slug
+
+    def end_session(self):
+        """End the current session."""
+        if not self.current_session:
+            return
+
+        self._acquire_lock()
+        try:
+            sessions = self._load_sessions()
+            sessions = [s for s in sessions if s.id != self.current_session.id]
+            self._save_sessions(sessions)
+
+            # Note: We don't auto-delete the worktree - user may want to merge
+            log.info(f"Session {self.current_session.id} ended")
+
+            if self.current_session.worktree_path:
+                log.info(f"Worktree preserved at: {self.current_session.worktree_path}")
+                log.info(f"Branch: {self.current_session.branch}")
+
+        finally:
+            self._release_lock()
+            self.current_session = None
+
+    def _register_cleanup(self):
+        """Register cleanup handlers for process exit."""
+        atexit.register(self.end_session)
+
+        # Handle signals
+        def signal_handler(signum, frame):
+            self.end_session()
+            sys.exit(0)
+
+        try:
+            signal.signal(signal.SIGTERM, signal_handler)
+            signal.signal(signal.SIGINT, signal_handler)
+        except Exception:
+            pass  # May fail in non-main thread
+
+    def get_active_sessions(self) -> list[Session]:
+        """Get list of currently active sessions."""
+        self._acquire_lock()
+        try:
+            sessions = self._load_sessions()
+            return self._cleanup_dead_sessions(sessions)
+        finally:
+            self._release_lock()
+
+    def is_using_worktree(self) -> bool:
+        """Check if current session is using a worktree."""
+        return self.current_session is not None and self.current_session.worktree_path is not None
+
+    def get_current_branch(self) -> Optional[str]:
+        """Get branch name if using worktree."""
+        if self.current_session:
+            return self.current_session.branch
+        return None