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

monoco/features/issue/commands.py

@@ -14,16 +14,18 @@ from . import core
 
 app = typer.Typer(help="Agent-Native Issue Management.")
 backlog_app = typer.Typer(help="Manage backlog operations.")
+lsp_app = typer.Typer(help="LSP Server commands.")
 app.add_typer(backlog_app, name="backlog")
+app.add_typer(lsp_app, name="lsp")
 console = Console()
 
 @app.command("create")
 def create(
-    type: IssueType = typer.Argument(..., help="Issue type (epic, feature, chore, fix)"),
+    type: str = typer.Argument(..., help="Issue type (epic, feature, chore, fix, etc.)"),
     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 (draft, doing, review)"),
+    stage: Optional[str] = typer.Option(None, "--stage", help="Issue stage"),
     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')"),
@@ -32,11 +34,19 @@ def create(
     root: Optional[str] = typer.Option(None, "--root", help="Override issues root directory"),
     json: AgentOutput = False,
 ):
+    """Create a new issue."""
     """Create a new issue."""
     config = get_config()
     issues_root = _resolve_issues_root(config, root)
-    status = IssueStatus.BACKLOG if is_backlog else IssueStatus.OPEN
+    status = "backlog" if is_backlog else "open"
+    
+    # Sanitize inputs (strip #)
+    if parent and parent.startswith("#"):
+        parent = parent[1:]
     
+    dependencies = [d[1:] if d.startswith("#") else d for d in dependencies]
+    related = [r[1:] if r.startswith("#") else r for r in related]
+
     if parent:
         parent_path = core.find_issue_path(issues_root, parent)
         if not parent_path:
@@ -63,11 +73,15 @@ def create(
         except ValueError:
             rel_path = path
 
-        OutputManager.print({
-            "issue": issue,
-            "path": str(rel_path),
-            "status": "created"
-        })
+        if OutputManager.is_agent_mode():
+            OutputManager.print({
+                "issue": issue,
+                "path": str(rel_path),
+                "status": "created"
+            })
+        else:
+            console.print(f"[green]✔ Created {issue.id} in status {issue.status}.[/green]")
+            console.print(f"Path: {rel_path}")
 
     except ValueError as e:
         OutputManager.error(str(e))
@@ -77,8 +91,8 @@ def create(
 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"),
+    status: Optional[str] = typer.Option(None, "--status", help="New status"),
+    stage: Optional[str] = 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)"),
@@ -125,7 +139,7 @@ def move_open(
     issues_root = _resolve_issues_root(config, root)
     try:
         # Pull operation: Force stage to TODO
-        issue = core.update_issue(issues_root, issue_id, status=IssueStatus.OPEN, stage=IssueStage.DRAFT)
+        issue = core.update_issue(issues_root, issue_id, status="open", stage="draft")
         OutputManager.print({
             "issue": issue,
             "status": "opened"
@@ -153,13 +167,13 @@ def start(
 
     try:
         # Implicitly ensure status is Open
-        issue = core.update_issue(issues_root, issue_id, status=IssueStatus.OPEN, stage=IssueStage.DOING)
+        issue = core.update_issue(issues_root, issue_id, status="open", stage="doing")
         
         isolation_info = None
 
         if branch:
             try:
-                issue = core.start_issue_isolation(issues_root, issue_id, IsolationType.BRANCH, project_root)
+                issue = core.start_issue_isolation(issues_root, issue_id, "branch", project_root)
                 isolation_info = {"type": "branch", "ref": issue.isolation.ref}
             except Exception as e:
                 OutputManager.error(f"Failed to create branch: {e}")
@@ -167,7 +181,7 @@ def start(
                 
         if worktree:
             try:
-                issue = core.start_issue_isolation(issues_root, issue_id, IsolationType.WORKTREE, project_root)
+                issue = core.start_issue_isolation(issues_root, issue_id, "worktree", project_root)
                 isolation_info = {"type": "worktree", "path": issue.isolation.path, "ref": issue.isolation.ref}
             except Exception as e:
                 OutputManager.error(f"Failed to create worktree: {e}")
@@ -196,7 +210,7 @@ def submit(
     project_root = _resolve_project_root(config)
     try:
         # Implicitly ensure status is Open
-        issue = core.update_issue(issues_root, issue_id, status=IssueStatus.OPEN, stage=IssueStage.REVIEW)
+        issue = core.update_issue(issues_root, issue_id, status="open", stage="review")
         
         # Delivery Report Generation
         report_status = "skipped"
@@ -228,7 +242,7 @@ def submit(
 @app.command("close")
 def move_close(
     issue_id: str = typer.Argument(..., help="Issue ID to close"),
-    solution: Optional[IssueSolution] = typer.Option(None, "--solution", "-s", help="Solution type"),
+    solution: Optional[str] = typer.Option(None, "--solution", "-s", help="Solution type"),
     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"),
@@ -241,12 +255,15 @@ def move_close(
     
     # Pre-flight check for interactive guidance (Requirement FEAT-0082 #6)
     if solution is None:
-        valid_solutions = [e.value for e in IssueSolution]
+        # Resolve options from engine
+        from .engine import get_engine
+        engine = get_engine(str(issues_root.parent))
+        valid_solutions = engine.issue_config.solutions or []
         OutputManager.error(f"Closing an issue requires a solution. Options: {', '.join(valid_solutions)}")
         raise typer.Exit(code=1)
 
     try:
-        issue = core.update_issue(issues_root, issue_id, status=IssueStatus.CLOSED, solution=solution)
+        issue = core.update_issue(issues_root, issue_id, status="closed", solution=solution)
         
         pruned_resources = []
         if prune:
@@ -276,7 +293,7 @@ def push(
     config = get_config()
     issues_root = _resolve_issues_root(config, root)
     try:
-        issue = core.update_issue(issues_root, issue_id, status=IssueStatus.BACKLOG)
+        issue = core.update_issue(issues_root, issue_id, status="backlog")
         OutputManager.print({
             "issue": issue,
             "status": "pushed_to_backlog"
@@ -295,7 +312,7 @@ def pull(
     config = get_config()
     issues_root = _resolve_issues_root(config, root)
     try:
-        issue = core.update_issue(issues_root, issue_id, status=IssueStatus.OPEN, stage=IssueStage.DRAFT)
+        issue = core.update_issue(issues_root, issue_id, status="open", stage="draft")
         OutputManager.print({
             "issue": issue,
             "status": "pulled_from_backlog"
@@ -314,7 +331,7 @@ def cancel(
     config = get_config()
     issues_root = _resolve_issues_root(config, root)
     try:
-        issue = core.update_issue(issues_root, issue_id, status=IssueStatus.CLOSED, solution=IssueSolution.CANCELLED)
+        issue = core.update_issue(issues_root, issue_id, status="closed", solution="cancelled")
         OutputManager.print({
             "issue": issue,
             "status": "cancelled"
@@ -427,10 +444,10 @@ def board(
         issue_list = []
         for issue in sorted(issues, key=lambda x: x.updated_at, reverse=True):
             type_color = {
-                IssueType.FEATURE: "green",
-                IssueType.CHORE: "blue",
-                IssueType.FIX: "red",
-                IssueType.EPIC: "magenta"
+                "feature": "green",
+                "chore": "blue",
+                "fix": "red",
+                "epic": "magenta"
             }.get(issue.type, "white")
             
             issue_list.append(
@@ -458,8 +475,8 @@ def board(
 @app.command("list")
 def list_cmd(
     status: Optional[str] = typer.Option(None, "--status", "-s", help="Filter by status (open, closed, backlog, all)"),
-    type: Optional[IssueType] = typer.Option(None, "--type", "-t", help="Filter by type"),
-    stage: Optional[IssueStage] = typer.Option(None, "--stage", help="Filter by stage"),
+    type: Optional[str] = typer.Option(None, "--type", "-t", help="Filter by type"),
+    stage: Optional[str] = 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,
@@ -481,7 +498,7 @@ def list_cmd(
     for i in issues:
         # Status Filter
         if target_status != "all":
-            if i.status.value != target_status:
+            if i.status != target_status:
                 continue
                 
         # Type Filter
@@ -530,13 +547,13 @@ def _render_issues_table(issues: List[IssueMetadata], title: str = "Issues"):
         t_color = type_colors.get(i.type, "white")
         s_color = status_colors.get(i.status, "white")
         
-        stage_str = i.stage.value if i.stage else "-"
+        stage_str = i.stage if i.stage else "-"
         updated_str = i.updated_at.strftime("%Y-%m-%d %H:%M")
         
         table.add_row(
             i.id,
-            f"[{t_color}]{i.type.value}[/{t_color}]",
-            f"[{s_color}]{i.status.value}[/{s_color}]",
+            f"[{t_color}]{i.type}[/{t_color}]",
+            f"[{s_color}]{i.status}[/{s_color}]",
             stage_str,
             i.title,
             updated_str
@@ -605,11 +622,11 @@ def scope(
         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]
-    tasks = [i for i in issues if i.type in [IssueType.CHORE, IssueType.FIX]]
+    epics = sorted([i for i in issues if i.type == "epic"], key=lambda x: x.id)
+    stories = [i for i in issues if i.type == "feature"]
+    tasks = [i for i in issues if i.type in ["chore", "fix"]]
 
-    status_map = {IssueStatus.OPEN: "[blue]●[/blue]", IssueStatus.CLOSED: "[green]✔[/green]", IssueStatus.BACKLOG: "[dim]💤[/dim]"}
+    status_map = {"open": "[blue]●[/blue]", "closed": "[green]✔[/green]", "backlog": "[dim]💤[/dim]"}
 
     for epic in epics:
         epic_node = tree.add(f"{status_map[epic.status]} [bold]{epic.id}[/bold]: {epic.title}")
@@ -622,6 +639,94 @@ def scope(
 
     console.print(Panel(tree, expand=False))
 
+@app.command("sync-files")
+def sync_files(
+    issue_id: Optional[str] = typer.Argument(None, help="Issue ID to sync (default: current context)"),
+    root: Optional[str] = typer.Option(None, "--root", help="Override issues root directory"),
+    json: AgentOutput = False,
+):
+    """
+    Sync issue 'files' field with git changed files.
+    """
+    config = get_config()
+    issues_root = _resolve_issues_root(config, root)
+    project_root = _resolve_project_root(config)
+    
+    if not issue_id:
+        # Infer from branch
+        from monoco.core import git
+        current = git.get_current_branch(project_root)
+        # Try to parse ID from branch "feat/issue-123-slug"
+        import re
+        match = re.search(r"(?:feat|fix|chore|epic)/([a-zA-Z]+-\d+)", current)
+        if match:
+             issue_id = match.group(1).upper()
+        else:
+             OutputManager.error("Cannot infer Issue ID from current branch. Please specify Issue ID.")
+             raise typer.Exit(code=1)
+
+    try:
+        changed = core.sync_issue_files(issues_root, issue_id, project_root)
+        OutputManager.print({
+            "id": issue_id,
+            "status": "synced",
+            "files": changed
+        })
+    except Exception as e:
+        OutputManager.error(str(e))
+        raise typer.Exit(code=1)
+
+@app.command("inspect")
+def inspect(
+    target: str = typer.Argument(..., help="Issue ID or File Path"),
+    root: Optional[str] = typer.Option(None, "--root", help="Override issues root directory"),
+    ast: bool = typer.Option(False, "--ast", help="Output JSON AST structure for debugging"),
+    json: AgentOutput = False,
+):
+    """
+    Inspect a specific issue and return its metadata (including actions).
+    """
+    config = get_config()
+    issues_root = _resolve_issues_root(config, root)
+    
+    # Try as Path
+    target_path = Path(target)
+    if target_path.exists() and target_path.is_file():
+        path = target_path
+    else:
+        # Try as ID
+        # Search path logic is needed? Or core.find_issue_path
+        path = core.find_issue_path(issues_root, target)
+        if not path:
+             OutputManager.error(f"Issue or file {target} not found.")
+             raise typer.Exit(code=1)
+    
+    # AST Debug Mode
+    if ast:
+        from .domain.parser import MarkdownParser
+        content = path.read_text()
+        try:
+            domain_issue = MarkdownParser.parse(content, path=str(path))
+            print(domain_issue.model_dump_json(indent=2))
+        except Exception as e:
+            OutputManager.error(f"Failed to parse AST: {e}")
+            raise typer.Exit(code=1)
+        return
+
+    # Normal Mode
+    meta = core.parse_issue(path)
+        
+    if not meta:
+         OutputManager.error(f"Could not parse issue {target}.")
+         raise typer.Exit(code=1)
+
+    # In JSON mode (AgentOutput), we might want to return rich data
+    if OutputManager.is_agent_mode():
+        OutputManager.print(meta)
+    else:
+        # For human, print yaml-like or table
+        console.print(meta)
+
 @app.command("lint")
 def lint(
     recursive: bool = typer.Option(False, "--recursive", "-r", help="Recursively scan subdirectories"),
@@ -662,27 +767,9 @@ def _resolve_issues_root(config, cli_root: Optional[str]) -> Path:
         return path
     
     # 2. Handle Default / Contextual Execution (No --root)
-    # We need to detect if we are in a Workspace Root with multiple projects
+    # Strict Workspace Check: If not in a project root, we rely on the config root.
+    # (The global app callback already enforces presence of .monoco for most commands)
     cwd = Path.cwd()
-    
-    # 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:
-            console.print(f"[yellow]Workspace detected with {len(subprojects)} projects:[/yellow]")
-            for p in subprojects:
-                console.print(f" - [bold]{p.name}[/bold]")
-            console.print("\n[yellow]Please specify a project using --root <PATH>.[/yellow]")
-            # We don't exit here strictly, but usually this means we can't find 'Issues' in CWD anyway
-            # so the config fallbacks below will likely fail or point to non-existent CWD/Issues.
-            # But let's fail fast to be helpful.
-            raise typer.Exit(code=1)
-        elif len(subprojects) == 1:
-            # Auto-select the only child project?
-            # It's safer to require explicit intent, but let's try to be helpful if it's obvious.
-            # However, standard behavior is usually "operate on current dir". 
-            # Let's stick to standard config resolution, but maybe warn.
-            pass
 
     # 3. Config Fallback
     config_issues_path = Path(config.paths.issues)
@@ -826,3 +913,40 @@ def commit(
     except Exception as e:
          console.print(f"[red]Git Error:[/red] {e}")
          raise typer.Exit(code=1)
+
+@lsp_app.command("definition")
+def lsp_definition(
+    file: str = typer.Option(..., "--file", "-f", help="Abs path to file"),
+    line: int = typer.Option(..., "--line", "-l", help="0-indexed line number"),
+    character: int = typer.Option(..., "--char", "-c", help="0-indexed character number"),
+):
+    """
+    Handle textDocument/definition request.
+    Output: JSON Location | null
+    """
+    import json
+    from monoco.core.lsp import Position
+    from monoco.features.issue.lsp import DefinitionProvider
+
+    config = get_config()
+    # Workspace Root resolution is key here. 
+    # If we are in a workspace, we want the workspace root, not just issue root.
+    # _resolve_project_root returns the closest project root or monoco root.
+    workspace_root = _resolve_project_root(config)
+    # Search for topmost workspace root to enable cross-project navigation
+    current_best = workspace_root
+    for parent in [workspace_root] + list(workspace_root.parents):
+        if (parent / ".monoco" / "workspace.yaml").exists() or (parent / ".monoco" / "project.yaml").exists():
+            current_best = parent
+    workspace_root = current_best
+    
+    provider = DefinitionProvider(workspace_root)
+    file_path = Path(file)
+    
+    locations = provider.provide_definition(
+        file_path, 
+        Position(line=line, character=character)
+    )
+    
+    # helper to serialize
+    print(json.dumps([l.model_dump(mode='json') for l in locations]))