monoco-toolkit 0.1.1__py3-none-any.whl → 0.2.5__py3-none-any.whl

monoco/features/issue/commands.py

@@ -8,7 +8,7 @@ from rich.table import Table
 import typer
 
 from monoco.core.config import get_config
-from monoco.core.output import print_output
+from monoco.core.output import print_output, OutputManager, AgentOutput
 from .models import IssueType, IssueStatus, IssueSolution, IssueStage, IsolationType, IssueMetadata
 from . import core
 
@@ -23,13 +23,14 @@ def create(
     title: str = typer.Option(..., "--title", "-t", help="Issue title"),
     parent: Optional[str] = typer.Option(None, "--parent", "-p", help="Parent Issue ID"),
     is_backlog: bool = typer.Option(False, "--backlog", help="Create as backlog item"),
-    stage: Optional[IssueStage] = typer.Option(None, "--stage", help="Issue stage (todo, doing, review)"),
+    stage: Optional[IssueStage] = typer.Option(None, "--stage", help="Issue stage (draft, doing, review)"),
     dependencies: List[str] = typer.Option([], "--dependency", "-d", help="Issue dependency ID(s)"),
     related: List[str] = typer.Option([], "--related", "-r", help="Related Issue ID(s)"),
     subdir: Optional[str] = typer.Option(None, "--subdir", "-s", help="Subdirectory for organization (e.g. 'Backend/Auth')"),
     sprint: Optional[str] = typer.Option(None, "--sprint", help="Sprint ID"),
     tags: List[str] = typer.Option([], "--tag", help="Tags"),
     root: Optional[str] = typer.Option(None, "--root", help="Override issues root directory"),
+    json: AgentOutput = False,
 ):
     """Create a new issue."""
     config = get_config()
@@ -39,7 +40,7 @@ def create(
     if parent:
         parent_path = core.find_issue_path(issues_root, parent)
         if not parent_path:
-            console.print(f"[red]✘ Error:[/red] Parent issue {parent} not found.")
+            OutputManager.error(f"Parent issue {parent} not found.")
             raise typer.Exit(code=1)
 
     try:
@@ -62,26 +63,75 @@ def create(
         except ValueError:
             rel_path = path
 
-        console.print(f"[green]✔[/green] Created [bold]{issue.id}[/bold] in status [cyan]{issue.status.value}[/cyan].")
-        console.print(f"[dim]Path: {rel_path}[/dim]")
+        OutputManager.print({
+            "issue": issue,
+            "path": str(rel_path),
+            "status": "created"
+        })
+
     except ValueError as e:
-        console.print(f"[red]✘ Error:[/red] {str(e)}")
+        OutputManager.error(str(e))
         raise typer.Exit(code=1)
 
+@app.command("update")
+def update(
+    issue_id: str = typer.Argument(..., help="Issue ID to update"),
+    title: Optional[str] = typer.Option(None, "--title", "-t", help="New title"),
+    status: Optional[IssueStatus] = typer.Option(None, "--status", help="New status"),
+    stage: Optional[IssueStage] = typer.Option(None, "--stage", help="New stage"),
+    parent: Optional[str] = typer.Option(None, "--parent", "-p", help="Parent Issue ID"),
+    sprint: Optional[str] = typer.Option(None, "--sprint", help="Sprint ID"),
+    dependencies: Optional[List[str]] = typer.Option(None, "--dependency", "-d", help="Issue dependency ID(s)"),
+    related: Optional[List[str]] = typer.Option(None, "--related", "-r", help="Related Issue ID(s)"),
+    tags: Optional[List[str]] = typer.Option(None, "--tag", help="Tags"),
+    root: Optional[str] = typer.Option(None, "--root", help="Override issues root directory"),
+    json: AgentOutput = False,
+):
+    """Update an existing issue."""
+    config = get_config()
+    issues_root = _resolve_issues_root(config, root)
+    
+    try:
+        issue = core.update_issue(
+            issues_root, 
+            issue_id, 
+            status=status, 
+            stage=stage,
+            title=title,
+            parent=parent,
+            sprint=sprint,
+            dependencies=dependencies, 
+            related=related, 
+            tags=tags
+        )
+        
+        OutputManager.print({
+            "issue": issue,
+            "status": "updated"
+        })
+    except Exception as e:
+        OutputManager.error(str(e))
+        raise typer.Exit(code=1)
+
+
 @app.command("open")
 def move_open(
     issue_id: str = typer.Argument(..., help="Issue ID to open"),
     root: Optional[str] = typer.Option(None, "--root", help="Override issues root directory"),
+    json: AgentOutput = False,
 ):
-    """Move issue to open status and set stage to Todo."""
+    """Move issue to open status and set stage to Draft."""
     config = get_config()
     issues_root = _resolve_issues_root(config, root)
     try:
         # Pull operation: Force stage to TODO
-        core.update_issue(issues_root, issue_id, status=IssueStatus.OPEN, stage=IssueStage.TODO)
-        console.print(f"[green]▶[/green] Issue [bold]{issue_id}[/bold] moved to open/todo.")
+        issue = core.update_issue(issues_root, issue_id, status=IssueStatus.OPEN, stage=IssueStage.DRAFT)
+        OutputManager.print({
+            "issue": issue,
+            "status": "opened"
+        })
     except Exception as e:
-        console.print(f"[red]✘ Error:[/red] {str(e)}")
+        OutputManager.error(str(e))
         raise typer.Exit(code=1)
 
 @app.command("start")
@@ -90,6 +140,7 @@ def start(
     branch: bool = typer.Option(False, "--branch", "-b", help="Start in a new git branch"),
     worktree: bool = typer.Option(False, "--worktree", "-w", help="Start in a new git worktree"),
     root: Optional[str] = typer.Option(None, "--root", help="Override issues root directory"),
+    json: AgentOutput = False,
 ):
     """Start working on an issue (Stage -> Doing)."""
     config = get_config()
@@ -97,32 +148,38 @@ def start(
     project_root = _resolve_project_root(config)
 
     if branch and worktree:
-         console.print("[red]Error:[/red] Cannot specify both --branch and --worktree.")
+         OutputManager.error("Cannot specify both --branch and --worktree.")
          raise typer.Exit(code=1)
 
     try:
         # Implicitly ensure status is Open
-        core.update_issue(issues_root, issue_id, status=IssueStatus.OPEN, stage=IssueStage.DOING)
+        issue = core.update_issue(issues_root, issue_id, status=IssueStatus.OPEN, stage=IssueStage.DOING)
         
+        isolation_info = None
+
         if branch:
             try:
-                meta = core.start_issue_isolation(issues_root, issue_id, IsolationType.BRANCH, project_root)
-                console.print(f"[green]✔[/green] Switched to branch [bold]{meta.isolation.ref}[/bold]")
+                issue = core.start_issue_isolation(issues_root, issue_id, IsolationType.BRANCH, project_root)
+                isolation_info = {"type": "branch", "ref": issue.isolation.ref}
             except Exception as e:
-                console.print(f"[red]Error:[/red] Failed to create branch: {e}")
+                OutputManager.error(f"Failed to create branch: {e}")
                 raise typer.Exit(code=1)
                 
         if worktree:
             try:
-                meta = core.start_issue_isolation(issues_root, issue_id, IsolationType.WORKTREE, project_root)
-                console.print(f"[green]✔[/green] Created worktree at [bold]{meta.isolation.path}[/bold]")
+                issue = core.start_issue_isolation(issues_root, issue_id, IsolationType.WORKTREE, project_root)
+                isolation_info = {"type": "worktree", "path": issue.isolation.path, "ref": issue.isolation.ref}
             except Exception as e:
-                console.print(f"[red]Error:[/red] Failed to create worktree: {e}")
+                OutputManager.error(f"Failed to create worktree: {e}")
                 raise typer.Exit(code=1)
 
-        console.print(f"[green]🚀[/green] Issue [bold]{issue_id}[/bold] started.")
+        OutputManager.print({
+            "issue": issue,
+            "status": "started",
+            "isolation": isolation_info
+        })
     except Exception as e:
-        console.print(f"[red]✘ Error:[/red] {str(e)}")
+        OutputManager.error(str(e))
         raise typer.Exit(code=1)
 
 @app.command("submit")
@@ -131,6 +188,7 @@ def submit(
     prune: bool = typer.Option(False, "--prune", help="Delete branch/worktree after submit"),
     force: bool = typer.Option(False, "--force", help="Force delete branch/worktree"),
     root: Optional[str] = typer.Option(None, "--root", help="Override issues root directory"),
+    json: AgentOutput = False,
 ):
     """Submit issue for review (Stage -> Review) and generate delivery report."""
     config = get_config()
@@ -138,27 +196,33 @@ def submit(
     project_root = _resolve_project_root(config)
     try:
         # Implicitly ensure status is Open
-        core.update_issue(issues_root, issue_id, status=IssueStatus.OPEN, stage=IssueStage.REVIEW)
-        console.print(f"[green]🚀[/green] Issue [bold]{issue_id}[/bold] submitted for review.")
+        issue = core.update_issue(issues_root, issue_id, status=IssueStatus.OPEN, stage=IssueStage.REVIEW)
         
         # Delivery Report Generation
+        report_status = "skipped"
         try:
              core.generate_delivery_report(issues_root, issue_id, project_root)
-             console.print(f"[dim]✔ Delivery report appended to issue file.[/dim]")
+             report_status = "generated"
         except Exception as e:
-             console.print(f"[yellow]⚠ Failed to generate delivery report: {e}[/yellow]")
+             report_status = f"failed: {e}"
         
+        pruned_resources = []
         if prune:
             try:
-                deleted = core.prune_issue_resources(issues_root, issue_id, force, project_root)
-                if deleted:
-                    console.print(f"[dim]✔ Pruned resources: {', '.join(deleted)}[/dim]")
+                pruned_resources = core.prune_issue_resources(issues_root, issue_id, force, project_root)
             except Exception as e:
-                console.print(f"[red]Prune Error:[/red] {e}")
+                OutputManager.error(f"Prune Error: {e}")
                 raise typer.Exit(code=1)
              
+        OutputManager.print({
+            "issue": issue,
+            "status": "submitted",
+            "report": report_status,
+            "pruned": pruned_resources
+        })
+             
     except Exception as e:
-        console.print(f"[red]✘ Error:[/red] {str(e)}")
+        OutputManager.error(str(e))
         raise typer.Exit(code=1)
 
 @app.command("close")
@@ -168,86 +232,114 @@ def move_close(
     prune: bool = typer.Option(False, "--prune", help="Delete branch/worktree after close"),
     force: bool = typer.Option(False, "--force", help="Force delete branch/worktree"),
     root: Optional[str] = typer.Option(None, "--root", help="Override issues root directory"),
+    json: AgentOutput = False,
 ):
     """Close issue."""
     config = get_config()
     issues_root = _resolve_issues_root(config, root)
     project_root = _resolve_project_root(config)
+    
+    # Pre-flight check for interactive guidance (Requirement FEAT-0082 #6)
+    if solution is None:
+        valid_solutions = [e.value for e in IssueSolution]
+        OutputManager.error(f"Closing an issue requires a solution. Options: {', '.join(valid_solutions)}")
+        raise typer.Exit(code=1)
+
     try:
-        core.update_issue(issues_root, issue_id, status=IssueStatus.CLOSED, solution=solution)
-        console.print(f"[dim]✔[/dim] Issue [bold]{issue_id}[/bold] closed.")
+        issue = core.update_issue(issues_root, issue_id, status=IssueStatus.CLOSED, solution=solution)
         
+        pruned_resources = []
         if prune:
             try:
-                deleted = core.prune_issue_resources(issues_root, issue_id, force, project_root)
-                if deleted:
-                    console.print(f"[dim]✔ Pruned resources: {', '.join(deleted)}[/dim]")
+                pruned_resources = core.prune_issue_resources(issues_root, issue_id, force, project_root)
             except Exception as e:
-                console.print(f"[red]Prune Error:[/red] {e}")
+                OutputManager.error(f"Prune Error: {e}")
                 raise typer.Exit(code=1)
 
+        OutputManager.print({
+            "issue": issue,
+            "status": "closed",
+            "pruned": pruned_resources
+        })
+
     except Exception as e:
-        console.print(f"[red]✘ Error:[/red] {str(e)}")
+        OutputManager.error(str(e))
         raise typer.Exit(code=1)
 
 @backlog_app.command("push")
 def push(
     issue_id: str = typer.Argument(..., help="Issue ID to push to backlog"),
     root: Optional[str] = typer.Option(None, "--root", help="Override issues root directory"),
+    json: AgentOutput = False,
 ):
     """Push issue to backlog."""
     config = get_config()
     issues_root = _resolve_issues_root(config, root)
     try:
-        core.update_issue(issues_root, issue_id, status=IssueStatus.BACKLOG)
-        console.print(f"[blue]💤[/blue] Issue [bold]{issue_id}[/bold] pushed to backlog.")
+        issue = core.update_issue(issues_root, issue_id, status=IssueStatus.BACKLOG)
+        OutputManager.print({
+            "issue": issue,
+            "status": "pushed_to_backlog"
+        })
     except Exception as e:
-        console.print(f"[red]✘ Error:[/red] {str(e)}")
+        OutputManager.error(str(e))
         raise typer.Exit(code=1)
 
 @backlog_app.command("pull")
 def pull(
     issue_id: str = typer.Argument(..., help="Issue ID to pull from backlog"),
     root: Optional[str] = typer.Option(None, "--root", help="Override issues root directory"),
+    json: AgentOutput = False,
 ):
-    """Pull issue from backlog (Open & Todo)."""
+    """Pull issue from backlog (Open & Draft)."""
     config = get_config()
     issues_root = _resolve_issues_root(config, root)
     try:
-        core.update_issue(issues_root, issue_id, status=IssueStatus.OPEN, stage=IssueStage.TODO)
-        console.print(f"[green]🔥[/green] Issue [bold]{issue_id}[/bold] pulled from backlog.")
+        issue = core.update_issue(issues_root, issue_id, status=IssueStatus.OPEN, stage=IssueStage.DRAFT)
+        OutputManager.print({
+            "issue": issue,
+            "status": "pulled_from_backlog"
+        })
     except Exception as e:
-        console.print(f"[red]✘ Error:[/red] {str(e)}")
+        OutputManager.error(str(e))
         raise typer.Exit(code=1)
 
 @app.command("cancel")
 def cancel(
     issue_id: str = typer.Argument(..., help="Issue ID to cancel"),
     root: Optional[str] = typer.Option(None, "--root", help="Override issues root directory"),
+    json: AgentOutput = False,
 ):
     """Cancel issue."""
     config = get_config()
     issues_root = _resolve_issues_root(config, root)
     try:
-        core.update_issue(issues_root, issue_id, status=IssueStatus.CLOSED, solution=IssueSolution.CANCELLED)
-        console.print(f"[red]✘[/red] Issue [bold]{issue_id}[/bold] cancelled.")
+        issue = core.update_issue(issues_root, issue_id, status=IssueStatus.CLOSED, solution=IssueSolution.CANCELLED)
+        OutputManager.print({
+            "issue": issue,
+            "status": "cancelled"
+        })
     except Exception as e:
-        console.print(f"[red]✘ Error:[/red] {str(e)}")
+        OutputManager.error(str(e))
         raise typer.Exit(code=1)
 
 @app.command("delete")
 def delete(
     issue_id: str = typer.Argument(..., help="Issue ID to delete"),
     root: Optional[str] = typer.Option(None, "--root", help="Override issues root directory"),
+    json: AgentOutput = False,
 ):
     """Physically remove an issue file."""
     config = get_config()
     issues_root = _resolve_issues_root(config, root)
     try:
         core.delete_issue_file(issues_root, issue_id)
-        console.print(f"[red]✔[/red] Issue [bold]{issue_id}[/bold] physically deleted.")
+        OutputManager.print({
+            "id": issue_id,
+            "status": "deleted"
+        })
     except Exception as e:
-        console.print(f"[red]✘ Error:[/red] {str(e)}")
+        OutputManager.error(str(e))
         raise typer.Exit(code=1)
 
 @app.command("move")
@@ -256,6 +348,7 @@ def move(
     target: str = typer.Option(..., "--to", help="Target project directory (e.g., ../OtherProject)"),
     renumber: bool = typer.Option(False, "--renumber", help="Automatically renumber on ID conflict"),
     root: Optional[str] = typer.Option(None, "--root", help="Override source issues root directory"),
+    json: AgentOutput = False,
 ):
     """Move an issue to another project."""
     config = get_config()
@@ -270,7 +363,7 @@ def move(
     elif target_path.name == "Issues" and target_path.exists():
         target_issues_root = target_path
     else:
-        console.print(f"[red]✘ Error:[/red] Target path must be a project root with 'Issues' directory or an 'Issues' directory itself.")
+        OutputManager.error("Target path must be a project root with 'Issues' directory or an 'Issues' directory itself.")
         raise typer.Exit(code=1)
     
     try:
@@ -286,32 +379,37 @@ def move(
         except ValueError:
             rel_path = new_path
         
-        if updated_meta.id != issue_id:
-            console.print(f"[green]✔[/green] Moved and renumbered: [bold]{issue_id}[/bold] → [bold]{updated_meta.id}[/bold]")
-        else:
-            console.print(f"[green]✔[/green] Moved [bold]{issue_id}[/bold] to target project.")
-        
-        console.print(f"[dim]New path: {rel_path}[/dim]")
+        OutputManager.print({
+            "issue": updated_meta,
+            "new_path": str(rel_path),
+            "status": "moved",
+            "renumbered": updated_meta.id != issue_id
+        })
         
     except FileNotFoundError as e:
-        console.print(f"[red]✘ Error:[/red] {str(e)}")
+        OutputManager.error(str(e))
         raise typer.Exit(code=1)
     except ValueError as e:
-        console.print(f"[red]✘ Conflict:[/red] {str(e)}")
+        OutputManager.error(str(e))
         raise typer.Exit(code=1)
     except Exception as e:
-        console.print(f"[red]✘ Error:[/red] {str(e)}")
+        OutputManager.error(str(e))
         raise typer.Exit(code=1)
 
 @app.command("board")
 def board(
     root: Optional[str] = typer.Option(None, "--root", help="Override issues root directory"),
+    json: AgentOutput = False,
 ):
     """Visualize issues in a Kanban board."""
     config = get_config()
     issues_root = _resolve_issues_root(config, root)
     
     board_data = core.get_board_data(issues_root)
+
+    if OutputManager.is_agent_mode():
+        OutputManager.print(board_data)
+        return
     
     from rich.columns import Columns
     from rich.console import RenderableType
@@ -319,7 +417,7 @@ def board(
     columns: List[RenderableType] = []
     
     stage_titles = {
-        "todo": "[bold white]TODO[/bold white]",
+        "draft": "[bold white]DRAFT[/bold white]",
         "doing": "[bold yellow]DOING[/bold yellow]",
         "review": "[bold cyan]REVIEW[/bold cyan]",
         "done": "[bold green]DONE[/bold green]"
@@ -364,6 +462,7 @@ def list_cmd(
     stage: Optional[IssueStage] = typer.Option(None, "--stage", help="Filter by stage"),
     root: Optional[str] = typer.Option(None, "--root", help="Override issues root directory"),
     workspace: bool = typer.Option(False, "--workspace", "-w", help="Include issues from workspace members"),
+    json: AgentOutput = False,
 ):
     """List issues in a table format with filtering."""
     config = get_config()
@@ -371,7 +470,7 @@ def list_cmd(
     
     # Validation
     if status and status.lower() not in ["open", "closed", "backlog", "all"]:
-         console.print(f"[red]Invalid status:[/red] {status}. Use open, closed, backlog or all.")
+         OutputManager.error(f"Invalid status: {status}. Use open, closed, backlog or all.")
          raise typer.Exit(code=1)
          
     target_status = status.lower() if status else "open"
@@ -395,12 +494,13 @@ def list_cmd(
             
         filtered.append(i)
         
-    # Sort: Updated Descending
-        filtered.append(i)
-        
     # Sort: Updated Descending
     filtered.sort(key=lambda x: x.updated_at, reverse=True)
     
+    if OutputManager.is_agent_mode():
+        OutputManager.print(filtered)
+        return
+
     # Render
     _render_issues_table(filtered, title=f"Issues ({len(filtered)})")
 
@@ -448,6 +548,7 @@ def _render_issues_table(issues: List[IssueMetadata], title: str = "Issues"):
 def query_cmd(
     query: str = typer.Argument(..., help="Search query (e.g. '+bug -ui' or 'login')"),
     root: Optional[str] = typer.Option(None, "--root", help="Override issues root directory"),
+    json: AgentOutput = False,
 ):
     """
     Search issues using advanced syntax.
@@ -468,6 +569,10 @@ def query_cmd(
     # For now, updated at descending is useful.
     results.sort(key=lambda x: x.updated_at, reverse=True)
     
+    if OutputManager.is_agent_mode():
+        OutputManager.print(results)
+        return
+
     _render_issues_table(results, title=f"Search Results for '{query}' ({len(results)})")
 
 @app.command("scope")
@@ -477,6 +582,7 @@ def scope(
     recursive: bool = typer.Option(False, "--recursive", "-r", help="Recursively scan subdirectories"),
     root: Optional[str] = typer.Option(None, "--root", help="Override issues root directory"),
     workspace: bool = typer.Option(False, "--workspace", "-w", help="Include issues from workspace members"),
+    json: AgentOutput = False,
 ):
     """Show progress tree."""
     config = get_config()
@@ -494,6 +600,10 @@ def scope(
             
     issues = filtered_issues
 
+    if OutputManager.is_agent_mode():
+        OutputManager.print(issues)
+        return
+
     tree = Tree(f"[bold blue]Monoco Issue Scope[/bold blue]")
     epics = sorted([i for i in issues if i.type == IssueType.EPIC], key=lambda x: x.id)
     stories = [i for i in issues if i.type == IssueType.FEATURE]
@@ -515,13 +625,21 @@ def scope(
 @app.command("lint")
 def lint(
     recursive: bool = typer.Option(False, "--recursive", "-r", help="Recursively scan subdirectories"),
+    fix: bool = typer.Option(False, "--fix", help="Attempt to automatically fix issues (e.g. missing headings)"),
+    format: str = typer.Option("table", "--format", "-f", help="Output format (table, json)"),
+    file: Optional[str] = typer.Option(None, "--file", help="Validate a single file instead of scanning the entire workspace"),
     root: Optional[str] = typer.Option(None, "--root", help="Override issues root directory"),
+    json: AgentOutput = False,
 ):
     """Verify the integrity of the Issues directory (declarative check)."""
     from . import linter
     config = get_config()
     issues_root = _resolve_issues_root(config, root)
-    linter.run_lint(issues_root, recursive=recursive)
+    
+    if OutputManager.is_agent_mode():
+        format = "json"
+
+    linter.run_lint(issues_root, recursive=recursive, fix=fix, format=format, file_path=file)
 
 def _resolve_issues_root(config, cli_root: Optional[str]) -> Path:
     """
@@ -547,7 +665,7 @@ def _resolve_issues_root(config, cli_root: Optional[str]) -> Path:
     # We need to detect if we are in a Workspace Root with multiple projects
     cwd = Path.cwd()
     
-    # If CWD is NOT a project root (no monoco.yaml/Issues), scan for subprojects
+    # If CWD is NOT a project root (no .monoco/), scan for subprojects
     if not is_project_root(cwd):
         subprojects = find_projects(cwd)
         if len(subprojects) > 1: