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

monoco/features/issue/adapter.py

@@ -1,19 +1,32 @@
 from pathlib import Path
 from typing import Dict
-from monoco.core.feature import MonocoFeature, IntegrationData
+from monoco.core.loader import FeatureModule, FeatureMetadata
+from monoco.core.feature import IntegrationData
 from monoco.features.issue import core
 
 
-class IssueFeature(MonocoFeature):
-    @property
-    def name(self) -> str:
-        return "issue"
+class IssueFeature(FeatureModule):
+    """Issue management feature module with unified lifecycle support."""
 
-    def initialize(self, root: Path, config: Dict) -> None:
+    @property
+    def metadata(self) -> FeatureMetadata:
+        return FeatureMetadata(
+            name="issue",
+            version="1.0.0",
+            description="Issue management system for Monoco",
+            dependencies=["core"],
+            priority=10,  # High priority - load early
+        )
+
+    def _on_mount(self, context: "FeatureContext") -> None:  # type: ignore
+        """Initialize issue feature with workspace context."""
+        root = context.root
+        config = context.config
         issues_path = root / config.get("paths", {}).get("issues", "Issues")
         core.init(issues_path)
 
     def integrate(self, root: Path, config: Dict) -> IntegrationData:
+        """Provide integration data for agent environment."""
         # Determine language from config, default to 'en'
         lang = config.get("i18n", {}).get("source_lang", "en")
 

monoco/features/issue/commands.py

@@ -43,6 +43,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 +121,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 +191,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 +218,7 @@ def update(
             issue_id,
             status=status,
             stage=stage,
+            solution=solution,
             title=title,
             parent=parent,
             sprint=sprint,
@@ -398,7 +429,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(
@@ -453,6 +484,32 @@ def move_close(
         force = True
 
     try:
+        # 0. 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:
+                        git.git_commit(project_root, commit_msg)
+                        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}")
+            raise typer.Exit(code=1)
+
         issue = core.update_issue(
             issues_root,
             issue_id,
@@ -464,10 +521,37 @@ def move_close(
 
         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_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:
+                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()
+
             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}")
                 raise typer.Exit(code=1)
@@ -727,6 +811,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 +821,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 +1608,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,