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

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")
@@ -43,6 +45,9 @@ def create(
     related: List[str] = typer.Option(
         [], "--related", "-r", help="Related Issue ID(s)"
     ),
+    from_memo: List[str] = typer.Option(
+        [], "--from-memo", "-m", help="Memo ID(s) to link to this issue"
+    ),
     force: bool = typer.Option(False, "--force", help="Bypass branch context checks"),
     subdir: Optional[str] = typer.Option(
         None,
@@ -118,20 +123,46 @@ def create(
             criticality=criticality_level,
         )
 
+        # Link memos to the newly created issue
+        linked_memos = []
+        missing_memos = []
+        if from_memo:
+            from monoco.features.memo.core import load_memos, update_memo
+            
+            existing_memos = {m.uid: m for m in load_memos(issues_root)}
+            
+            for memo_id in from_memo:
+                if memo_id in existing_memos:
+                    # Only update if not already linked to this issue (idempotency)
+                    memo = existing_memos[memo_id]
+                    if memo.ref != issue.id:
+                        update_memo(issues_root, memo_id, {"status": "tracked", "ref": issue.id})
+                        linked_memos.append(memo_id)
+                else:
+                    missing_memos.append(memo_id)
+
         try:
             rel_path = path.relative_to(Path.cwd())
         except ValueError:
             rel_path = path
 
         if OutputManager.is_agent_mode():
-            OutputManager.print(
-                {"issue": issue, "path": str(rel_path), "status": "created"}
-            )
+            result = {"issue": issue, "path": str(rel_path), "status": "created"}
+            if linked_memos:
+                result["linked_memos"] = linked_memos
+            if missing_memos:
+                result["missing_memos"] = missing_memos
+            OutputManager.print(result)
         else:
             console.print(
                 f"[green]✔ Created {issue.id} in status {issue.status}.[/green]"
             )
             console.print(f"Path: {rel_path}")
+            
+            if linked_memos:
+                console.print(f"[green]✔ Linked {len(linked_memos)} memo(s): {', '.join(linked_memos)}[/green]")
+            if missing_memos:
+                console.print(f"[yellow]⚠ Memo(s) not found: {', '.join(missing_memos)}[/yellow]")
 
             # Prompt for Language
             source_lang = config.i18n.source_lang or "en"
@@ -162,6 +193,7 @@ def update(
     title: Optional[str] = typer.Option(None, "--title", "-t", help="New title"),
     status: Optional[str] = typer.Option(None, "--status", help="New status"),
     stage: Optional[str] = typer.Option(None, "--stage", help="New stage"),
+    solution: Optional[str] = typer.Option(None, "--solution", "-s", help="Solution type (implemented, cancelled, wontfix, duplicate)"),
     parent: Optional[str] = typer.Option(
         None, "--parent", "-p", help="Parent Issue ID"
     ),
@@ -188,6 +220,7 @@ def update(
             issue_id,
             status=status,
             stage=stage,
+            solution=solution,
             title=title,
             parent=parent,
             sprint=sprint,
@@ -360,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,
@@ -398,7 +438,7 @@ def move_close(
         None, "--solution", "-s", help="Solution type"
     ),
     prune: bool = typer.Option(
-        False, "--prune", help="Delete branch/worktree after close"
+        True, "--prune/--no-prune", help="Delete branch/worktree after close (default: True)"
     ),
     force: bool = typer.Option(False, "--force", help="Force delete branch/worktree"),
     force_prune: bool = typer.Option(
@@ -414,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)
@@ -441,43 +485,141 @@ 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:
-        issue = core.update_issue(
-            issues_root,
-            issue_id,
-            status="closed",
-            solution=solution,
-            no_commit=no_commit,
-            project_root=project_root,
+        # 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)
+            if merged_files:
+                if not OutputManager.is_agent_mode():
+                    console.print(
+                        f"[green]✔ Smart Merge:[/green] Synced {len(merged_files)} files from feature branch."
+                    )
+
+                # Auto-commit merged files if not no_commit
+                if not no_commit:
+                    commit_msg = f"feat: atomic merge changes from {issue_id}"
+                    try:
+                        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:
+                        # If commit fails (e.g. nothing to commit?), just warn
+                        if not OutputManager.is_agent_mode():
+                            console.print(f"[yellow]⚠ Commit skipped: {e}[/yellow]")
+
+        except Exception as e:
+            OutputManager.error(f"Merge Error: {e}")
+            rollback_transaction()
+            raise typer.Exit(code=1)
 
+        # 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 if issue.isolation.type else None
+                isolation_ref = issue.isolation.ref
+                isolation_info = (isolation_type, isolation_ref)
+
+            # 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"[dim]Cleaning up {iso_type}: {iso_ref}...[/dim]")
+
             try:
                 pruned_resources = core.prune_issue_resources(
                     issues_root, issue_id, force, project_root
                 )
+                if pruned_resources and not OutputManager.is_agent_mode():
+                    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)
 
 
@@ -727,6 +869,9 @@ def list_cmd(
     workspace: bool = typer.Option(
         False, "--workspace", "-w", help="Include issues from workspace members"
     ),
+    all: bool = typer.Option(
+        False, "--all", "-a", help="Include archived issues in the list"
+    ),
     json: AgentOutput = False,
 ):
     """List issues in a table format with filtering."""
@@ -734,15 +879,15 @@ def list_cmd(
     issues_root = _resolve_issues_root(config, root)
 
     # Validation
-    if status and status.lower() not in ["open", "closed", "backlog", "all"]:
+    if status and status.lower() not in ["open", "closed", "backlog", "archived", "all"]:
         OutputManager.error(
-            f"Invalid status: {status}. Use open, closed, backlog or all."
+            f"Invalid status: {status}. Use open, closed, backlog, archived or all."
         )
         raise typer.Exit(code=1)
 
     target_status = status.lower() if status else "open"
 
-    issues = core.list_issues(issues_root, recursive_workspace=workspace)
+    issues = core.list_issues(issues_root, recursive_workspace=workspace, include_archived=all)
     filtered = []
 
     for i in issues:
@@ -1521,6 +1666,193 @@ def show(
     OutputManager.print(result)
 
 
+@app.command("check-critical")
+def check_critical(
+    fail_on_warning: bool = typer.Option(
+        False,
+        "--fail-on-warning",
+        help="Exit with error code if high priority issues are found",
+    ),
+    root: Optional[str] = typer.Option(
+        None, "--root", help="Override issues root directory"
+    ),
+    json: AgentOutput = False,
+):
+    """
+    Check for incomplete critical/high priority issues.
+
+    Returns:
+        0: No critical/high issues found
+        1: High priority issues found (warning)
+        2: Critical issues found (blocking)
+    """
+    from .criticality import CriticalityLevel
+
+    config = get_config()
+    issues_root = _resolve_issues_root(config, root)
+
+    issues = core.list_issues(issues_root)
+
+    critical_issues = []
+    high_issues = []
+
+    for issue in issues:
+        if issue.status == "closed":
+            continue
+
+        criticality = issue.criticality
+        if not criticality:
+            continue
+
+        if criticality == CriticalityLevel.CRITICAL:
+            critical_issues.append(issue)
+        elif criticality == CriticalityLevel.HIGH:
+            high_issues.append(issue)
+
+    result = {
+        "critical_count": len(critical_issues),
+        "high_count": len(high_issues),
+        "critical_issues": [
+            {"id": i.id, "title": i.title, "stage": i.stage}
+            for i in critical_issues
+        ],
+        "high_issues": [
+            {"id": i.id, "title": i.title, "stage": i.stage}
+            for i in high_issues
+        ],
+    }
+
+    if OutputManager.is_agent_mode() or json:
+        OutputManager.print(result)
+    else:
+        if critical_issues:
+            console.print("[red]❌ Critical issues (blocking):[/red]")
+            for issue in critical_issues:
+                console.print(f"  [red]• {issue.id}:[/red] {issue.title} ({issue.stage})")
+
+        if high_issues:
+            console.print("[yellow]⚠️  High priority issues (warning):[/yellow]")
+            for issue in high_issues:
+                console.print(f"  [yellow]• {issue.id}:[/yellow] {issue.title} ({issue.stage})")
+
+        if not critical_issues and not high_issues:
+            console.print("[green]✓ No incomplete critical or high priority issues.[/green]")
+
+    # Determine exit code
+    if critical_issues:
+        raise typer.Exit(code=2)
+    elif high_issues and fail_on_warning:
+        raise typer.Exit(code=1)
+    elif high_issues:
+        # Warning only, don't fail
+        pass
+
+    raise typer.Exit(code=0)
+
+
+@app.command("sync-isolation")
+def sync_isolation(
+    issue_id: str = typer.Argument(..., help="Issue ID to sync isolation for"),
+    branch: Optional[str] = typer.Option(
+        None, "--branch", help="Current branch name (auto-detected if not provided)"
+    ),
+    root: Optional[str] = typer.Option(
+        None, "--root", help="Override issues root directory"
+    ),
+    json: AgentOutput = False,
+):
+    """
+    Sync issue isolation configuration with current branch.
+
+    Updates the isolation.ref field to match the current branch context.
+    This is typically called by the post-checkout hook.
+    """
+    import subprocess
+    from .core import update_issue_field
+
+    config = get_config()
+    issues_root = _resolve_issues_root(config, root)
+    project_root = Path(config.paths.root).resolve()
+
+    # Auto-detect branch if not provided
+    if not branch:
+        try:
+            result = subprocess.run(
+                ["git", "rev-parse", "--abbrev-ref", "HEAD"],
+                cwd=project_root,
+                capture_output=True,
+                text=True,
+                check=True,
+            )
+            branch = result.stdout.strip()
+        except Exception:
+            OutputManager.error("Could not detect current branch. Use --branch.")
+            raise typer.Exit(code=1)
+
+    # Find the issue
+    issue_path = core.find_issue_path(issues_root, issue_id)
+    if not issue_path:
+        OutputManager.error(f"Issue {issue_id} not found.")
+        raise typer.Exit(code=1)
+
+    # Parse current issue
+    issue = core.parse_issue(issue_path)
+    if not issue:
+        OutputManager.error(f"Could not parse issue {issue_id}.")
+        raise typer.Exit(code=1)
+
+    # Check if isolation needs updating
+    current_isolation = issue.isolation
+    if current_isolation:
+        current_ref = current_isolation.ref or ""
+        current_isolation_dict = {
+            "type": current_isolation.type,
+            "ref": current_isolation.ref,
+        }
+        if current_isolation.path:
+            current_isolation_dict["path"] = current_isolation.path
+        if current_isolation.created_at:
+            current_isolation_dict["created_at"] = current_isolation.created_at.isoformat()
+    else:
+        current_ref = ""
+        current_isolation_dict = {}
+
+    # Expected ref format: branch:branch-name
+    expected_ref = f"branch:{branch}"
+
+    if current_ref == expected_ref:
+        if OutputManager.is_agent_mode() or json:
+            OutputManager.print({"updated": False, "message": "Isolation already up to date"})
+        else:
+            console.print(f"[dim]Isolation already up to date for {issue_id}[/dim]")
+        raise typer.Exit(code=0)
+
+    # Update the isolation field
+    new_isolation = {**current_isolation_dict, "ref": expected_ref, "type": "branch"}
+
+    try:
+        update_issue_field(
+            issue_path,
+            "isolation",
+            new_isolation,
+        )
+
+        result = {
+            "updated": True,
+            "issue_id": issue_id,
+            "isolation": new_isolation,
+        }
+
+        if OutputManager.is_agent_mode() or json:
+            OutputManager.print(result)
+        else:
+            console.print(f"[green]✓ Updated isolation for {issue_id}:[/green] {expected_ref}")
+
+    except Exception as e:
+        OutputManager.error(f"Failed to update isolation: {e}")
+        raise typer.Exit(code=1)
+
+
 def _validate_branch_context(
     project_root: Path,
     allowed: Optional[List[str]] = None,