monoco-toolkit 0.3.11__py3-none-any.whl → 0.3.12__py3-none-any.whl

monoco/features/agent/engines.py

@@ -1,175 +1,36 @@
 """
 Agent Engine Adapters for Monoco Scheduler.
 
-This module provides a unified interface for different AI agent execution engines,
-allowing the Worker to seamlessly switch between Gemini, Claude, and future engines.
-"""
-
-from abc import ABC, abstractmethod
-from typing import List
-
-
-class EngineAdapter(ABC):
-    """
-    Abstract base class for agent engine adapters.
-
-    Each adapter is responsible for:
-    1. Constructing the correct CLI command for its engine
-    2. Handling engine-specific error scenarios
-    3. Providing metadata about the engine's capabilities
-    """
-
-    @abstractmethod
-    def build_command(self, prompt: str) -> List[str]:
-        """
-        Build the CLI command to execute the agent with the given prompt.
-
-        Args:
-            prompt: The instruction/context to send to the agent
-
-        Returns:
-            List of command arguments (e.g., ["gemini", "-y", "prompt text"])
-        """
-        pass
-
-    @property
-    @abstractmethod
-    def name(self) -> str:
-        """Return the canonical name of this engine."""
-        pass
-
-    @property
-    def supports_yolo_mode(self) -> bool:
-        """Whether this engine supports auto-approval mode."""
-        return False
-
-
-class GeminiAdapter(EngineAdapter):
-    """
-    Adapter for Google Gemini CLI.
-
-    Command format: gemini -p <prompt> -y
-    The -y flag enables "YOLO mode" (auto-approval of actions).
-    """
-
-    def build_command(self, prompt: str) -> List[str]:
-        # Based on Gemini CLI help: -p <prompt> for non-interactive
-        return ["gemini", "-p", prompt, "-y"]
-
-    @property
-    def name(self) -> str:
-        return "gemini"
-
-    @property
-    def supports_yolo_mode(self) -> bool:
-        return True
-
-
-class ClaudeAdapter(EngineAdapter):
-    """
-    Adapter for Anthropic Claude CLI.
-
-    Command format: claude -p <prompt>
-    The -p/--print flag enables non-interactive mode.
-    """
-
-    def build_command(self, prompt: str) -> List[str]:
-        # Based on Claude CLI help: -p <prompt> is NOT standard, usually -p means print/non-interactive.
-        # But for one-shot execution, we do passing prompt as argument with -p flag.
-        return ["claude", "-p", prompt]
-
-    @property
-    def name(self) -> str:
-        return "claude"
+DEPRECATED: This module has been moved to monoco.core.scheduler.
+This file is kept for backward compatibility and re-exports from the new location.
 
-    @property
-    def supports_yolo_mode(self) -> bool:
-        # Claude uses -p for non-interactive mode, similar concept
-        return True
-
-
-class QwenAdapter(EngineAdapter):
-    """
-    Adapter for Qwen Code CLI.
-
-    Command format: qwen -p <prompt> -y
-    """
-
-    def build_command(self, prompt: str) -> List[str]:
-        # Assuming Qwen follows similar patterns (based on user feedback)
-        return ["qwen", "-p", prompt, "-y"]
-
-    @property
-    def name(self) -> str:
-        return "qwen"
-
-    @property
-    def supports_yolo_mode(self) -> bool:
-        return True
-
-
-class KimiAdapter(EngineAdapter):
-    """
-    Adapter for Kimi CLI (Moonshot AI).
-
-    Command format: kimi -p <prompt> --print
-    Note: --print implicitly adds --yolo.
-    """
-
-    def build_command(self, prompt: str) -> List[str]:
-        # Based on Kimi CLI help: -p, --prompt TEXT.
-        # Also using --print for non-interactive mode (which enables yolo).
-        return ["kimi", "-p", prompt, "--print"]
-
-    @property
-    def name(self) -> str:
-        return "kimi"
-
-    @property
-    def supports_yolo_mode(self) -> bool:
-        return True
-
-
-class EngineFactory:
-    """
-    Factory for creating engine adapter instances.
-
-    Usage:
-        adapter = EngineFactory.create("gemini")
-        command = adapter.build_command("Write a test")
-    """
-
-    _adapters = {
-        "gemini": GeminiAdapter,
-        "claude": ClaudeAdapter,
-        "qwen": QwenAdapter,
-        "kimi": KimiAdapter,
-    }
-
-    @classmethod
-    def create(cls, engine_name: str) -> EngineAdapter:
-        """
-        Create an adapter instance for the specified engine.
-
-        Args:
-            engine_name: Name of the engine (e.g., "gemini", "claude")
-
-        Returns:
-            An instance of the appropriate EngineAdapter
-
-        Raises:
-            ValueError: If the engine is not supported
-        """
-        adapter_class = cls._adapters.get(engine_name.lower())
-        if not adapter_class:
-            supported = ", ".join(cls._adapters.keys())
-            raise ValueError(
-                f"Unsupported engine: '{engine_name}'. "
-                f"Supported engines: {supported}"
-            )
-        return adapter_class()
+Migration:
+    Old: from monoco.features.agent.engines import EngineAdapter, EngineFactory
+    New: from monoco.core.scheduler import EngineAdapter, EngineFactory
+"""
 
-    @classmethod
-    def supported_engines(cls) -> List[str]:
-        """Return a list of all supported engine names."""
-        return list(cls._adapters.keys())
+import warnings
+from monoco.core.scheduler import (
+    EngineAdapter,
+    EngineFactory,
+    GeminiAdapter,
+    ClaudeAdapter,
+    QwenAdapter,
+    KimiAdapter,
+)
+
+warnings.warn(
+    "monoco.features.agent.engines is deprecated. "
+    "Use monoco.core.scheduler instead.",
+    DeprecationWarning,
+    stacklevel=2
+)
+
+__all__ = [
+    "EngineAdapter",
+    "EngineFactory",
+    "GeminiAdapter",
+    "ClaudeAdapter",
+    "QwenAdapter",
+    "KimiAdapter",
+]

monoco/features/agent/worker.py

@@ -1,6 +1,6 @@
 from typing import Optional
 from .models import RoleTemplate
-from .engines import EngineFactory
+from monoco.core.scheduler import EngineFactory
 
 
 class Worker:

monoco/features/issue/commands.py

@@ -2,6 +2,7 @@ import typer
 from pathlib import Path
 from typing import Optional, List
 from datetime import datetime
+import logging
 from rich.console import Console
 from rich.tree import Tree
 from rich.panel import Panel
@@ -24,6 +25,7 @@ from . import domain_commands
 
 app.add_typer(domain_commands.app, name="domain")
 console = Console()
+logger = logging.getLogger(__name__)
 
 
 @app.command("create")
@@ -391,6 +393,13 @@ def submit(
     )
 
     try:
+        # FEAT-0163: Automatically sync files before submission to ensure manifest completeness
+        try:
+             core.sync_issue_files(issues_root, issue_id, project_root)
+        except Exception as se:
+             # Just log warning, don't fail submit if sync fails (defensive)
+             logger.warning(f"Auto-sync failed during submit for {issue_id}: {se}")
+
         # Implicitly ensure status is Open
         issue = core.update_issue(
             issues_root,
@@ -445,7 +454,11 @@ def move_close(
     ),
     json: AgentOutput = False,
 ):
-    """Close issue."""
+    """Close issue with atomic transaction guarantee.
+    
+    If any step fails, all changes made during the close operation will be
+    automatically rolled back to ensure the mainline remains clean.
+    """
     config = get_config()
     issues_root = _resolve_issues_root(config, root)
     project_root = _resolve_project_root(config)
@@ -472,19 +485,57 @@ def move_close(
 
     # Handle force-prune logic
     if force_prune:
-        # Use OutputManager to check mode, as `json` arg might not be reliable with Typer Annotated
-        if not OutputManager.is_agent_mode() and not force:
+        # FEAT-0125: force-prune requires interactive confirmation to avoid accidental data loss 
+        # unless in agent mode (which is handled by typer.confirm's default)
+        if not OutputManager.is_agent_mode():
             confirm = typer.confirm(
-                "⚠️  [Bold Red]Warning:[/Bold Red] You are about to FORCE prune issue resources. Git merge checks will be bypassed.\nAre you sure you want to proceed?",
-                default=False,
+                "⚠ FORCE PRUNE will permanently delete the feature branch without checking its merge status. Continue?",
+                default=False
             )
             if not confirm:
-                raise typer.Abort()
+                console.print("[yellow]Aborted.[/yellow]")
+                raise typer.Exit(code=1)
+        
         prune = True
         force = True
 
+    # ATOMIC TRANSACTION: Capture initial state for potential rollback
+    initial_head = None
+    transaction_commits = []
+    
+    def rollback_transaction():
+        """Rollback all changes made during the transaction."""
+        if initial_head and transaction_commits:
+            try:
+                git.git_reset_hard(project_root, initial_head)
+                if not OutputManager.is_agent_mode():
+                    console.print(f"[yellow]↩ Rolled back to {initial_head[:7]}[/yellow]")
+            except Exception as rollback_error:
+                if not OutputManager.is_agent_mode():
+                    console.print(f"[red]⚠ Rollback failed: {rollback_error}[/red]")
+                    console.print(f"[red]   Manual recovery may be required. Run: git reset --hard {initial_head[:7]}[/red]")
+
     try:
-        # 0. Perform Smart Atomic Merge (FEAT-0154)
+        # Capture initial HEAD before any modifications
+        initial_head = git.get_current_head(project_root)
+        
+        # 0. Find issue across branches (FIX-0006)
+        # This will raise RuntimeError if issue found in multiple branches
+        found_path, source_branch = core.find_issue_path_across_branches(
+            issues_root, issue_id, project_root
+        )
+        if not found_path:
+            OutputManager.error(f"Issue {issue_id} not found in any branch.")
+            raise typer.Exit(code=1)
+        
+        # If issue was found in a different branch, notify user
+        if source_branch and source_branch != git.get_current_branch(project_root):
+            if not OutputManager.is_agent_mode():
+                console.print(
+                    f"[green]✔ Found {issue_id} in branch '{source_branch}', synced to working tree.[/green]"
+                )
+
+        # 1. Perform Smart Atomic Merge (FEAT-0154)
         merged_files = []
         try:
             merged_files = core.merge_issue_changes(issues_root, issue_id, project_root)
@@ -498,7 +549,8 @@ def move_close(
                 if not no_commit:
                     commit_msg = f"feat: atomic merge changes from {issue_id}"
                     try:
-                        git.git_commit(project_root, commit_msg)
+                        commit_hash = git.git_commit(project_root, commit_msg)
+                        transaction_commits.append(commit_hash)
                         if not OutputManager.is_agent_mode():
                             console.print(f"[green]✔ Committed merged changes.[/green]")
                     except Exception as e:
@@ -508,43 +560,42 @@ def move_close(
 
         except Exception as e:
             OutputManager.error(f"Merge Error: {e}")
+            rollback_transaction()
             raise typer.Exit(code=1)
 
-        issue = core.update_issue(
-            issues_root,
-            issue_id,
-            status="closed",
-            solution=solution,
-            no_commit=no_commit,
-            project_root=project_root,
-        )
+        # 2. Update issue status to closed
+        try:
+            issue = core.update_issue(
+                issues_root,
+                issue_id,
+                status="closed",
+                solution=solution,
+                no_commit=no_commit,
+                project_root=project_root,
+            )
+            # Track the auto-commit from update_issue if it occurred
+            if hasattr(issue, 'commit_result') and issue.commit_result:
+                transaction_commits.append(issue.commit_result)
+        except Exception as e:
+            OutputManager.error(f"Update Error: {e}")
+            rollback_transaction()
+            raise typer.Exit(code=1)
 
+        # 3. Prune issue resources (branch/worktree)
         pruned_resources = []
         if prune:
             # Get isolation info for confirmation prompt
             isolation_info = None
             if issue.isolation:
-                isolation_type = issue.isolation.type.value if issue.isolation.type else None
+                isolation_type = issue.isolation.type if issue.isolation.type else None
                 isolation_ref = issue.isolation.ref
                 isolation_info = (isolation_type, isolation_ref)
 
-            # Interactive confirmation before pruning (non-agent mode only)
-            if not OutputManager.is_agent_mode() and isolation_info and not force:
+            # Auto-prune without confirmation (FEAT-0082 Update)
+            if not OutputManager.is_agent_mode() and isolation_info:
                 iso_type, iso_ref = isolation_info
                 if iso_ref:
-                    console.print(f"\n[bold yellow]⚠️  Resource Cleanup Confirmation[/bold yellow]")
-                    console.print(f"Issue [cyan]{issue_id}[/cyan] will be closed with the following action:")
-                    console.print(f"  • Delete {iso_type}: [bold]{iso_ref}[/bold]")
-                    console.print(f"\n[dim]This operation will permanently remove the {iso_type}. "
-                                f"Ensure all changes have been merged to main.[/dim]")
-                    confirm = typer.confirm(
-                        f"\nProceed with closing {issue_id} and deleting {iso_type}?",
-                        default=True,
-                    )
-                    if not confirm:
-                        console.print(f"[yellow]Close operation cancelled.[/yellow]")
-                        console.print(f"[dim]Tip: Use --no-prune to close without deleting {iso_type}.[/dim]")
-                        raise typer.Abort()
+                    console.print(f"[dim]Cleaning up {iso_type}: {iso_ref}...[/dim]")
 
             try:
                 pruned_resources = core.prune_issue_resources(
@@ -554,14 +605,21 @@ def move_close(
                     console.print(f"[green]✔ Cleaned up:[/green] {', '.join(pruned_resources)}")
             except Exception as e:
                 OutputManager.error(f"Prune Error: {e}")
+                rollback_transaction()
                 raise typer.Exit(code=1)
 
+        # Success: Clear transaction state as all operations completed
         OutputManager.print(
             {"issue": issue, "status": "closed", "pruned": pruned_resources}
         )
 
+    except typer.Abort:
+        # User cancelled, rollback already handled
+        raise
     except Exception as e:
+        # Catch-all for unexpected errors
         OutputManager.error(str(e))
+        rollback_transaction()
         raise typer.Exit(code=1)