pmflow-cli 0.1.2__tar.gz → 0.1.4__tar.gz

{pmflow_cli-0.1.2 → pmflow_cli-0.1.4}/.gitignore

@@ -27,5 +27,8 @@ out/
 # Claude Code (installed via `pmflow skill install`)
 .claude/commands/
 
+# Agent Runner worktrees
+.pmflow-worktrees/
+
 # uv
 uv.lock

{pmflow_cli-0.1.2 → pmflow_cli-0.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pmflow-cli
-Version: 0.1.2
+Version: 0.1.4
 Summary: CLI for pmflow — project management for AI-assisted development
 Project-URL: Repository, https://github.com/zhanglaixian/pmflow
 Author-email: zhanglaixian <zhanglaixian@zhuanzhuan.com>
@@ -11,7 +11,7 @@ Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3
 Requires-Python: >=3.12
 Requires-Dist: httpx[socks]>=0.27
-Requires-Dist: pmflow-shared>=0.1.2
+Requires-Dist: pmflow-shared>=0.1.3
 Requires-Dist: rich>=13.0
 Requires-Dist: tomli-w>=1.0
 Requires-Dist: tomli>=2.0; python_version < '3.11'

{pmflow_cli-0.1.2 → pmflow_cli-0.1.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "pmflow-cli"
-version = "0.1.2"
+version = "0.1.4"
 description = "CLI for pmflow — project management for AI-assisted development"
 requires-python = ">=3.12"
 readme = "README.md"
@@ -13,7 +13,7 @@ classifiers = [
     "Environment :: Console",
 ]
 dependencies = [
-    "pmflow-shared>=0.1.2",
+    "pmflow-shared>=0.1.3",
     "typer>=0.12",
     "httpx[socks]>=0.27",
     "rich>=13.0",

pmflow_cli-0.1.4/src/pmflow_cli/commands/runner.py

@@ -0,0 +1,503 @@
+"""Agent Runner: polls server for tasks and executes them via Claude Code CLI."""
+
+import json
+import os
+import platform
+import subprocess
+import time
+from pathlib import Path
+
+import typer
+
+from pmflow_cli.client import PmflowClient
+from pmflow_cli.output import console, format_error
+from pmflow_cli.utils import get_workspace, run_async
+
+app = typer.Typer(name="runner", help="Agent Runner for automated task execution")
+
+WORKTREE_DIR = ".pmflow-worktrees"
+
+# Tools allowed during plan stage (read-only + Bash for pmflow CLI)
+PLAN_TOOLS = "Read,Glob,Grep,Bash(pmflow *),Skill"
+
+# Tools allowed during execute stage
+EXECUTE_TOOLS = "Edit,Write,Read,Glob,Grep,Bash(git *),Bash(uv run *),Bash(npm *),Bash(pmflow *),Skill"
+
+
+def _build_issue_ref(task: dict) -> str:
+    return f"{task['workspace_slug'].upper()}-{task['issue_seq_num']}"
+
+
+def _build_plan_prompt(task: dict) -> str:
+    """Let Claude Code run the plan-task skill to get full context."""
+    issue_ref = _build_issue_ref(task)
+
+    return f"""/pmflow:plan-task {issue_ref}
+
+完成方案制定后，在输出的最后，用以下格式标记方案是否需要人工确认：
+- 如果方案中有不确定的点，在输出末尾加上 [NEEDS_INPUT]
+- 如果方案完整可执行，不需要额外标记"""
+
+
+def _build_execute_prompt(task: dict) -> str:
+    """Execute the approved plan, then run prdfix to generate summary."""
+    issue_ref = _build_issue_ref(task)
+    approved_plan = task.get("approved_plan") or ""
+    extra_context = task.get("extra_context") or ""
+
+    parts = [
+        f"按照以下已批准的方案实现 {issue_ref}。",
+        "",
+        "## 批准的方案",
+        approved_plan,
+    ]
+    if extra_context:
+        parts.extend(["", "## 人工补充的上下文", extra_context])
+    parts.extend([
+        "",
+        "严格按方案执行，不要偏离。完成后提交 commit。",
+        "",
+        f"代码提交后，执行 /pmflow:prdfix {issue_ref} 生成实现总结。",
+    ])
+    return "\n".join(parts)
+
+
+
+def _get_main_branch(workdir: str) -> str:
+    """Detect the main branch name (main or master)."""
+    try:
+        result = subprocess.run(
+            ["git", "symbolic-ref", "refs/remotes/origin/HEAD"],
+            cwd=workdir, capture_output=True, text=True,
+        )
+        if result.returncode == 0:
+            # e.g. "refs/remotes/origin/main" → "main"
+            return result.stdout.strip().split("/")[-1]
+    except Exception:
+        pass
+    return "main"
+
+
+def _setup_worktree(workdir: str, issue_ref: str) -> tuple[str, str]:
+    """Create a git worktree for the task. Returns (worktree_path, branch_name).
+
+    Bases the new branch on local main, keeping Runner in sync with the
+    developer's local codebase state.
+    If the worktree/branch already exists (e.g. task was reset), reuse it.
+    """
+    branch = f"agent/{issue_ref.lower()}"
+    wt_path = str(Path(workdir) / WORKTREE_DIR / issue_ref)
+
+    main_branch = _get_main_branch(workdir)
+
+    if Path(wt_path).exists():
+        console.print(f"    [dim]Reusing existing worktree: {wt_path}[/dim]")
+        subprocess.run(
+            ["git", "merge", main_branch, "--no-edit"],
+            cwd=wt_path, capture_output=True,
+        )
+        return wt_path, branch
+
+    # Ensure parent directory exists
+    Path(wt_path).parent.mkdir(parents=True, exist_ok=True)
+
+    # Check if branch already exists
+    check = subprocess.run(
+        ["git", "rev-parse", "--verify", branch],
+        cwd=workdir, capture_output=True,
+    )
+    if check.returncode == 0:
+        proc = subprocess.run(
+            ["git", "worktree", "add", wt_path, branch],
+            cwd=workdir, capture_output=True, text=True,
+        )
+    else:
+        proc = subprocess.run(
+            ["git", "worktree", "add", "-b", branch, wt_path, main_branch],
+            cwd=workdir, capture_output=True, text=True,
+        )
+
+    if proc.returncode != 0:
+        raise RuntimeError(f"Failed to create worktree: {proc.stderr}")
+
+    console.print(f"    [dim]Worktree created: {wt_path} → {branch} (from {main_branch})[/dim]")
+    return wt_path, branch
+
+
+def _print_stream_event(event: dict) -> None:
+    """Print a concise, human-readable line for a stream-json event."""
+    etype = event.get("type")
+    if etype == "assistant":
+        content_blocks = event.get("message", {}).get("content", [])
+        for block in content_blocks:
+            btype = block.get("type")
+            if btype == "text":
+                text = block.get("text", "")
+                preview = text[:120].replace("\n", " ")
+                if len(text) > 120:
+                    preview += "…"
+                console.print(f"    [dim]💬 {preview}[/dim]")
+            elif btype == "tool_use":
+                tool = block.get("name", "?")
+                inp = block.get("input", {})
+                # Show the most useful argument as a short hint
+                hint = ""
+                if "command" in inp:
+                    hint = inp["command"][:80]
+                elif "file_path" in inp:
+                    hint = inp["file_path"]
+                elif "pattern" in inp:
+                    hint = inp["pattern"]
+                elif "skill" in inp:
+                    hint = inp["skill"]
+                if hint:
+                    console.print(f"    [cyan]🔧 {tool}[/cyan] [dim]{hint}[/dim]")
+                else:
+                    console.print(f"    [cyan]🔧 {tool}[/cyan]")
+            elif btype == "thinking":
+                console.print("    [dim]🧠 thinking…[/dim]")
+
+
+def _run_claude(
+    prompt: str, workdir: str, allowed_tools: str, timeout: int,
+    resume_session_id: str | None = None,
+) -> dict:
+    """Run claude CLI in non-interactive mode with streaming output.
+
+    Uses ``--output-format stream-json`` so we can show real-time progress
+    in the terminal. Returns dict with keys: ok, output (str), error (optional),
+    session_id (optional).
+    """
+    cmd = ["claude", "-p", prompt, "--output-format", "stream-json", "--allowedTools", allowed_tools]
+    if resume_session_id:
+        cmd.extend(["--resume", resume_session_id])
+    try:
+        proc = subprocess.Popen(
+            cmd,
+            cwd=workdir,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True,
+        )
+    except FileNotFoundError:
+        return {"ok": False, "output": "", "error": "claude CLI not found. Please install Claude Code."}
+
+    assistant_texts: list[str] = []
+    session_id: str | None = None
+    result_text: str | None = None
+    try:
+        assert proc.stdout is not None
+        for line in proc.stdout:
+            line = line.strip()
+            if not line:
+                continue
+            try:
+                event = json.loads(line)
+                _print_stream_event(event)
+                etype = event.get("type")
+                if etype == "assistant":
+                    for block in event.get("message", {}).get("content", []):
+                        if block.get("type") == "text" and block.get("text"):
+                            assistant_texts.append(block["text"])
+                elif etype == "result":
+                    if event.get("result"):
+                        result_text = event["result"]
+                    if event.get("session_id"):
+                        session_id = event["session_id"]
+            except json.JSONDecodeError:
+                pass
+        proc.wait(timeout=timeout)
+    except subprocess.TimeoutExpired:
+        proc.kill()
+        return {"ok": False, "output": "", "error": "Claude execution timed out"}
+
+    # Prefer the full conversation text; fall back to result summary
+    if assistant_texts:
+        text = "\n\n".join(assistant_texts)
+    elif result_text:
+        text = result_text
+    else:
+        stderr = proc.stderr.read() if proc.stderr else ""
+        text = stderr[:10000] if stderr else ""
+
+    return {"ok": proc.returncode == 0, "output": text, "session_id": session_id}
+
+
+@app.command("start")
+def start(
+    workspace: str | None = typer.Option(None, "--workspace", "-w"),
+    workdir: str | None = typer.Option(None, "--workdir", "-d", help="Working directory (default: cwd)"),
+    name: str | None = typer.Option(None, "--name", "-n", help="Runner name (default: hostname)"),
+    interval: int = typer.Option(10, "--interval", "-i", help="Poll interval in seconds"),
+    timeout: int = typer.Option(900, "--timeout", "-t", help="Claude execution timeout in seconds"),
+    auto_approve: bool = typer.Option(False, "--auto-approve", help="Auto-approve plans without [NEEDS_INPUT]"),
+):
+    """Start the Agent Runner daemon. Polls for tasks and executes via Claude Code."""
+    LOGO = r"""
+    ____  __  ___ ______ __
+   / __ \/  |/  // ____// /____  _      __
+  / /_/ / /|_/ // /_   / // __ \| | /| / /
+ / ____/ /  / // __/  / // /_/ /| |/ |/ /
+/_/   /_/  /_//_/    /_/ \____/ |__/|__/
+"""
+    console.print(f"[bold cyan]{LOGO}[/bold cyan]", highlight=False)
+    console.print("          [dim]Agent Runner[/dim]\n")
+
+    slug = get_workspace(workspace)
+    work_path = workdir or str(Path.cwd())
+    runner_id = _get_runner_id(name)
+
+    # Register: first heartbeat verifies server connectivity
+    console.print(f"[dim]Registering runner [bold]{runner_id}[/bold] ...[/dim]")
+    try:
+        _register_runner(slug, runner_id)
+    except Exception as e:
+        console.print(f"[red]Failed to register runner:[/red] {format_error(e)}")
+        console.print("[dim]Check server connectivity and authentication.[/dim]")
+        raise typer.Exit(1) from None
+
+    console.print("[bold green]Agent Runner started[/bold green]")
+    console.print(f"  Runner ID: [cyan]{runner_id}[/cyan]")
+    console.print(f"  Workspace: [cyan]{slug}[/cyan]")
+    console.print(f"  Workdir:   [cyan]{work_path}[/cyan]")
+    console.print(f"  Interval:  [cyan]{interval}s[/cyan]")
+    console.print(f"  Timeout:   [cyan]{timeout}s[/cyan]")
+    console.print(f"  Auto-approve: [cyan]{auto_approve}[/cyan]")
+    console.print()
+
+    try:
+        while True:
+            try:
+                _poll_once(slug, work_path, timeout, auto_approve, runner_id)
+            except KeyboardInterrupt:
+                raise
+            except Exception as e:
+                console.print(f"[red]Poll error:[/red] {format_error(e)}")
+
+            time.sleep(interval)
+    except KeyboardInterrupt:
+        console.print(f"\n[yellow]Shutting down runner {runner_id} ...[/yellow]")
+        _send_offline(slug, runner_id)
+        console.print("[yellow]Runner stopped.[/yellow]")
+        raise typer.Exit(0) from None
+
+
+@app.command("run")
+def run_once(
+    issue_ref: str = typer.Argument(help="Issue reference (e.g. WS-3)"),
+    workspace: str | None = typer.Option(None, "--workspace", "-w"),
+    workdir: str | None = typer.Option(None, "--workdir", "-d"),
+    timeout: int = typer.Option(900, "--timeout", "-t"),
+):
+    """Create and execute a single agent task (for debugging)."""
+    slug = get_workspace(workspace)
+    work_path = workdir or str(Path.cwd())
+
+    # Parse issue ref
+    parts = issue_ref.upper().split("-")
+    if len(parts) != 2 or not parts[1].isdigit():
+        console.print(f"[red]Invalid issue ref:[/red] {issue_ref}. Expected format: WS-3")
+        raise typer.Exit(1)
+    seq_num = int(parts[1])
+
+    # Create a task
+    async def _create():
+        async with PmflowClient() as client:
+            resp = await client.http.post(
+                f"/workspaces/{slug}/agent-tasks",
+                json={"issue_seq_num": seq_num},
+            )
+            resp.raise_for_status()
+            return resp.json()
+
+    task_data = run_async(_create())
+    console.print(f"[green]Task created:[/green] {task_data['id']}")
+
+    # Claim and execute plan stage
+    _poll_once(slug, work_path, timeout, auto_approve=False)
+
+
+def _get_runner_id(name: str | None = None) -> str:
+    """Return a stable runner identifier. Uses --name if provided, otherwise hostname."""
+    return name or platform.node()
+
+
+def _send_heartbeat(slug: str, runner_id: str) -> None:
+    """Send heartbeat to server."""
+    async def _hb():
+        async with PmflowClient() as client:
+            resp = await client.http.post(
+                f"/workspaces/{slug}/runners/heartbeat",
+                json={"runner_id": runner_id},
+            )
+            resp.raise_for_status()
+
+    try:
+        run_async(_hb())
+    except Exception:
+        pass  # heartbeat failure is non-fatal
+
+
+def _send_offline(slug: str, runner_id: str) -> None:
+    """Notify server this runner is going offline."""
+    async def _off():
+        async with PmflowClient() as client:
+            resp = await client.http.post(
+                f"/workspaces/{slug}/runners/offline",
+                json={"runner_id": runner_id},
+            )
+            resp.raise_for_status()
+
+    try:
+        run_async(_off())
+    except Exception:
+        pass  # best-effort
+
+
+def _register_runner(slug: str, runner_id: str) -> None:
+    """Register runner on startup. Raises on failure to verify connectivity."""
+    async def _reg():
+        async with PmflowClient() as client:
+            resp = await client.http.post(
+                f"/workspaces/{slug}/runners/heartbeat",
+                json={"runner_id": runner_id},
+            )
+            resp.raise_for_status()
+            return resp.json()
+
+    run_async(_reg())
+
+
+def _poll_once(slug: str, workdir: str, timeout: int, auto_approve: bool, runner_id: str | None = None) -> None:
+    """Poll server for one task and process it."""
+    runner_id = runner_id or _get_runner_id()
+
+    # Send heartbeat every poll cycle
+    _send_heartbeat(slug, runner_id)
+
+    async def _claim():
+        async with PmflowClient() as client:
+            resp = await client.http.post(
+                f"/workspaces/{slug}/agent-tasks/claim",
+                json={"runner_id": runner_id},
+            )
+            resp.raise_for_status()
+            return resp.json()
+
+    data = run_async(_claim())
+
+    # No task available
+    if data.get("task") is None and "id" not in data:
+        return
+
+    task = data
+    task_id = task["id"]
+    task_status = task["status"]
+    issue_ref = _build_issue_ref(task)
+
+    if task_status == "planning":
+        _handle_plan_stage(slug, task_id, issue_ref, task, workdir, timeout, auto_approve)
+    elif task_status == "executing":
+        _handle_execute_stage(slug, task_id, issue_ref, task, workdir, timeout)
+
+
+def _handle_plan_stage(
+    slug: str, task_id: str, issue_ref: str, task: dict,
+    workdir: str, timeout: int, auto_approve: bool,
+) -> None:
+    console.print(f"[bold blue]▶ Planning[/bold blue] {issue_ref}: {task['issue_title']}")
+
+    prompt = _build_plan_prompt(task)
+    result = _run_claude(prompt, workdir, PLAN_TOOLS, timeout)
+
+    output_text = result["output"]
+    needs_input = "[NEEDS_INPUT]" in output_text
+    session_id = result.get("session_id")
+
+    # Submit plan + session_id to server
+    async def _submit():
+        async with PmflowClient() as client:
+            resp = await client.http.post(
+                f"/workspaces/{slug}/agent-tasks/{task_id}/plan",
+                json={
+                    "plan": output_text[:50000],
+                    "needs_input": needs_input,
+                    "session_id": session_id,
+                },
+            )
+            resp.raise_for_status()
+            return resp.json()
+
+    run_async(_submit())
+
+    if session_id:
+        console.print(f"  [dim]Session: {session_id}[/dim]")
+
+    if needs_input:
+        console.print("  [yellow]⚠ Needs human input[/yellow] — waiting for review")
+    elif auto_approve:
+        # Auto-approve: submit approval immediately
+        async def _approve():
+            async with PmflowClient() as client:
+                resp = await client.http.post(
+                    f"/workspaces/{slug}/agent-tasks/{task_id}/approve",
+                    json={"approved_plan": output_text[:50000]},
+                )
+                resp.raise_for_status()
+
+        run_async(_approve())
+        console.print("  [green]✓ Plan auto-approved[/green]")
+    else:
+        console.print("  [cyan]📋 Plan submitted[/cyan] — waiting for human approval")
+
+
+def _handle_execute_stage(
+    slug: str, task_id: str, issue_ref: str, task: dict,
+    workdir: str, timeout: int,
+) -> None:
+    console.print(f"[bold green]▶ Executing[/bold green] {issue_ref}: {task.get('issue_title', '')}")
+
+    # Create isolated worktree for this task
+    try:
+        wt_path, branch = _setup_worktree(workdir, issue_ref)
+    except RuntimeError as e:
+        console.print(f"  [red]✗ Worktree setup failed:[/red] {e}")
+        async def _fail():
+            async with PmflowClient() as client:
+                resp = await client.http.post(
+                    f"/workspaces/{slug}/agent-tasks/{task_id}/result",
+                    json={"status": "failed", "error": str(e)},
+                )
+                resp.raise_for_status()
+        run_async(_fail())
+        return
+
+    console.print(f"  [dim]Branch: {branch}[/dim]")
+
+    prompt = _build_execute_prompt(task)
+    resume_id = task.get("session_id")
+    if resume_id:
+        console.print(f"  [dim]Resuming session: {resume_id}[/dim]")
+    result = _run_claude(prompt, wt_path, EXECUTE_TOOLS, timeout, resume_session_id=resume_id)
+
+    output_text = result["output"]
+
+    async def _submit():
+        async with PmflowClient() as client:
+            resp = await client.http.post(
+                f"/workspaces/{slug}/agent-tasks/{task_id}/result",
+                json={
+                    "status": "done" if result["ok"] else "failed",
+                    "output": output_text[:50000],
+                    "error": result.get("error"),
+                    "branch": branch,
+                },
+            )
+            resp.raise_for_status()
+
+    run_async(_submit())
+
+    if result["ok"]:
+        console.print(f"  [green]✓ Done[/green] — branch: [cyan]{branch}[/cyan]")
+    else:
+        console.print(f"  [red]✗ Failed[/red]: {result.get('error', 'unknown error')}")

{pmflow_cli-0.1.2 → pmflow_cli-0.1.4}/src/pmflow_cli/commands/skills.py

@@ -1,4 +1,4 @@
-"""Install/uninstall pmflow Claude Code skills to ~/.claude/commands/pmflow/."""
+"""Install/uninstall pmflow Claude Code skills."""
 
 import shutil
 from pathlib import Path
@@ -11,26 +11,37 @@ from pmflow_cli.output import console
 app = typer.Typer(help="Manage Claude Code skills")
 
 SKILLS_SOURCE = Path(__file__).parent.parent / "skills"
+
+# Claude Code target
 COMMANDS_TARGET = Path.home() / ".claude" / "commands" / "pmflow"
+
 SKILL_NAMES = ["plan-space", "plan-task", "prd", "prdfix", "snapshot-space"]
 
 # Legacy install path (pre-v0.2), cleaned up on install/uninstall
 _LEGACY_TARGET = Path.home() / ".claude" / "skills"
 
+# Legacy Codex install path, cleaned up on install/uninstall
+_CODEX_LEGACY_TARGET = Path.home() / ".codex" / "prompts"
+
 
 def _clean_legacy():
-    """Remove skills installed to the old ~/.claude/skills/ location."""
+    """Remove skills installed to old locations."""
     for name in SKILL_NAMES:
+        # Old ~/.claude/skills/ location
         legacy = _LEGACY_TARGET / f"pmflow-{name}"
         if legacy.exists():
             shutil.rmtree(legacy)
+        # Old ~/.codex/prompts/ location
+        codex_legacy = _CODEX_LEGACY_TARGET / f"pmflow-{name}.md"
+        if codex_legacy.exists():
+            codex_legacy.unlink()
 
 
 @app.command()
 def install(
     force: bool = typer.Option(False, "--force", "-f", help="Overwrite existing skills"),
 ):
-    """Install pmflow skills into ~/.claude/commands/pmflow/ for Claude Code."""
+    """Install pmflow skills into Claude Code."""
     if not SKILLS_SOURCE.exists():
         console.print("[red]Error:[/red] Skills source directory not found. Package may be corrupted.")
         raise typer.Exit(1)
@@ -38,19 +49,20 @@ def install(
     _clean_legacy()
     COMMANDS_TARGET.mkdir(parents=True, exist_ok=True)
 
-    installed = []
-    skipped = []
+    installed: list[str] = []
+    skipped: list[str] = []
 
     for name in SKILL_NAMES:
         src = SKILLS_SOURCE / name / "SKILL.md"
-        dst = COMMANDS_TARGET / f"{name}.md"
+        if not src.exists():
+            continue
 
+        dst = COMMANDS_TARGET / f"{name}.md"
         if dst.exists() and not force:
             skipped.append(name)
-            continue
-
-        shutil.copy2(src, dst)
-        installed.append(name)
+        else:
+            shutil.copy2(src, dst)
+            installed.append(name)
 
     if installed:
         console.print(f"[green]Installed {len(installed)} skill(s):[/green] {', '.join(installed)}")
@@ -59,22 +71,25 @@ def install(
         console.print("Use [bold]--force[/bold] to overwrite.")
 
     if installed:
-        console.print("\n[dim]Skills are now available as /pmflow:plan-space, /pmflow:plan-task, /pmflow:prd, /pmflow:prdfix, /pmflow:snapshot-space in Claude Code.[/dim]")
+        console.print(
+            "\n[dim]/pmflow:plan-space, /pmflow:plan-task, /pmflow:prd, /pmflow:prdfix, /pmflow:snapshot-space[/dim]"
+        )
 
 
 @app.command()
 def uninstall():
-    """Remove pmflow skills from ~/.claude/commands/pmflow/."""
+    """Remove pmflow skills from Claude Code."""
     _clean_legacy()
 
-    removed = []
+    removed: list[str] = []
+
     for name in SKILL_NAMES:
         dst = COMMANDS_TARGET / f"{name}.md"
         if dst.exists():
             dst.unlink()
             removed.append(name)
 
-    # Remove the pmflow directory if empty
+    # Remove empty directory
     if COMMANDS_TARGET.exists() and not any(COMMANDS_TARGET.iterdir()):
         COMMANDS_TARGET.rmdir()
 
@@ -87,7 +102,7 @@ def uninstall():
 @app.command(name="list")
 def list_skills():
     """List pmflow skills and their install status."""
-    table = Table(title="pmflow Claude Code Skills")
+    table = Table(title="pmflow Skills")
     table.add_column("Skill", style="bold")
     table.add_column("Command")
     table.add_column("Status")

{pmflow_cli-0.1.2 → pmflow_cli-0.1.4}/src/pmflow_cli/main.py

@@ -1,6 +1,6 @@
 import typer
 
-from pmflow_cli.commands import ai, auth, context, issue, skills, workspace
+from pmflow_cli.commands import ai, auth, context, issue, runner, skills, workspace
 
 app = typer.Typer(name="pmflow", help="pmflow - Project management for AI-assisted development")
 
@@ -10,6 +10,7 @@ app.add_typer(issue.app, name="issue", help="Issue management")
 app.add_typer(context.app, name="ctx", help="Context (attachments/docs) management")
 app.add_typer(ai.app, name="ai", help="AI-assisted PRD generation")
 app.add_typer(skills.app, name="skills", help="Manage Claude Code skills")
+app.add_typer(runner.app, name="runner", help="Agent Runner for automated task execution")
 
 
 @app.command()