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

emdash_core/swarm/merge_agent.py

@@ -1,383 +0,0 @@
-"""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

@@ -1,274 +0,0 @@
-"""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