kingdom-cli 0.3.2__tar.gz → 0.5.0__tar.gz

{kingdom_cli-0.3.2 → kingdom_cli-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kingdom-cli
-Version: 0.3.2
+Version: 0.5.0
 Summary: A markdown file-based CLI for software development with multi-agent council design, markdown tickets, and background worker loops.
 Author: James Robinson-Bohnslav
 License-Expression: Apache-2.0

{kingdom_cli-0.3.2 → kingdom_cli-0.5.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "kingdom-cli"
-version = "0.3.2"
+version = "0.5.0"
 description = "A markdown file-based CLI for software development with multi-agent council design, markdown tickets, and background worker loops."
 readme = "README.md"
 requires-python = ">=3.10"

{kingdom_cli-0.3.2 → kingdom_cli-0.5.0}/src/kingdom/agent.py

@@ -62,6 +62,7 @@ class AgentConfig:
     install_hint: str = ""
     model: str = ""
     extra_flags: list[str] = field(default_factory=list)
+    reasoning_effort: str = ""
 
 
 def resolve_agent(name: str, agent_def: AgentDef) -> AgentConfig:
@@ -85,6 +86,7 @@ def resolve_agent(name: str, agent_def: AgentDef) -> AgentConfig:
         install_hint=defaults["install_hint"],
         model=agent_def.model,
         extra_flags=list(agent_def.extra_flags),
+        reasoning_effort=agent_def.reasoning_effort,
     )
 
 
@@ -310,6 +312,63 @@ RESPONSE_PARSERS: dict[str, ResponseParser] = {
 }
 
 
+def extract_codex_error(stdout: str, stderr: str, code: int) -> str | None:
+    """Extract a human-meaningful error from Codex JSONL output.
+
+    Prefers terminal failure events over transient reconnect notices so callers
+    can surface the actual cause instead of a generic exit code.
+    """
+    del code  # Error extraction only depends on emitted output.
+
+    turn_failed: list[str] = []
+    item_errors: list[str] = []
+    event_errors: list[str] = []
+
+    for line in stdout.strip().split("\n"):
+        if not line:
+            continue
+        try:
+            event = json.loads(line)
+        except json.JSONDecodeError:
+            continue
+        if not isinstance(event, dict):
+            continue
+
+        event_type = event.get("type")
+        if event_type == "turn.failed":
+            error = event.get("error", {})
+            if isinstance(error, dict):
+                message = error.get("message")
+                if isinstance(message, str) and message:
+                    turn_failed.append(message)
+        elif event_type == "item.completed":
+            item = event.get("item", {})
+            if isinstance(item, dict) and item.get("type") == "error":
+                message = item.get("message") or item.get("text")
+                if isinstance(message, str) and message:
+                    item_errors.append(message)
+        elif event_type == "error":
+            message = event.get("message")
+            if isinstance(message, str) and message:
+                event_errors.append(message)
+
+    for candidates in (turn_failed, item_errors, event_errors):
+        if candidates:
+            return candidates[-1]
+
+    stripped = stderr.strip()
+    if stripped:
+        return stripped
+    return None
+
+
+ErrorExtractor = Callable[[str, str, int], str | None]
+
+ERROR_EXTRACTORS: dict[str, ErrorExtractor] = {
+    "codex": extract_codex_error,
+}
+
+
 # ---------------------------------------------------------------------------
 # Backend-specific command builders
 # ---------------------------------------------------------------------------
@@ -373,6 +432,8 @@ def build_codex_command(
         parts.extend(["-c", 'sandbox_permissions=["disk-full-read-access"]'])
     if config.model:
         parts.extend(["--model", config.model])
+    if config.reasoning_effort:
+        parts.extend(["-c", f"model_reasoning_effort={config.reasoning_effort}"])
     if config.extra_flags:
         parts.extend(config.extra_flags)
     if session_id:
@@ -493,6 +554,20 @@ def parse_response(config: AgentConfig, stdout: str, stderr: str, code: int) ->
     return parser(stdout, stderr, code)
 
 
+def extract_error(config: AgentConfig, stdout: str, stderr: str, code: int) -> str | None:
+    """Extract a backend-aware error message from CLI output."""
+    extractor = ERROR_EXTRACTORS.get(config.backend)
+    if extractor is not None:
+        error = extractor(stdout, stderr, code)
+        if error:
+            return error
+
+    stripped = stderr.strip()
+    if stripped:
+        return stripped
+    return None
+
+
 # ---------------------------------------------------------------------------
 # Stream text extractors — extract text from individual NDJSON lines
 # ---------------------------------------------------------------------------

{kingdom_cli-0.3.2 → kingdom_cli-0.5.0}/src/kingdom/cli/__init__.py

@@ -9,6 +9,7 @@ from __future__ import annotations
 import json
 import os
 import subprocess
+import sys
 from pathlib import Path
 from typing import Annotated
 
@@ -40,6 +41,8 @@ from .council import council_app
 from .design import design_app, get_branch_paths, get_doc_status  # noqa: F401 (re-export)
 from .display import error_console, print_error, styled_echo
 from .helpers import install_skill, is_git_repo, require_project_root, verbose_echo  # noqa: F401
+from .hook import hook_app
+from .lord import lord_app
 from .peasant import (  # noqa: F401
     PeasantContext,
     launch_work_background,
@@ -47,6 +50,7 @@ from .peasant import (  # noqa: F401
     peasant_app,
     resolve_peasant_context,
 )
+from .plugin import plugin_app
 from .ticket import format_ticket_line, format_ticket_summary, get_tickets_dir, ticket_app  # noqa: F401
 
 NO_COLOR = "NO_COLOR" in os.environ or os.environ.get("TERM") == "dumb"
@@ -78,6 +82,9 @@ app.add_typer(council_app, name="council")
 app.add_typer(design_app, name="design")
 app.add_typer(peasant_app, name="peasant")
 app.add_typer(config_app, name="config")
+app.add_typer(hook_app, name="hook")
+app.add_typer(lord_app, name="lord")
+app.add_typer(plugin_app, name="plugin")
 app.add_typer(ticket_app, name="ticket")
 app.add_typer(ticket_app, name="tk", hidden=True)  # Alias for muscle memory
 
@@ -133,7 +140,10 @@ def start(
     if current_path.exists() and not force:
         existing = current_path.read_text(encoding="utf-8").strip()
         print_error(f"A session is already active: {existing}")
-        error_console.print("  Use --force to override, or run `kd done` first.")
+        error_console.print(
+            "  If that branch is finished, run `kd done` to clean it up before starting a new session.\n"
+            "  If you need to switch mid-work, use `kd start --force` to override."
+        )
         raise typer.Exit(code=1)
 
     # Determine branch name
@@ -168,6 +178,109 @@ def start(
     typer.echo(f"  Design: {design_path}")
 
 
+@app.command(help="Switch the active kd session to another branch.")
+def switch(
+    branch: Annotated[str | None, typer.Argument(help="Branch name to switch to.")] = None,
+) -> None:
+    """Switch the active kd session without changing git branch.
+
+    With an argument: validate the branch exists in .kd/branches/ and update .kd/current.
+    Without arguments: list all tracked branches, marking the current session and git branch.
+    """
+    base = require_project_root()
+    console = Console()
+
+    if branch is None:
+        # List mode: show all tracked branches
+        branches_dir = base / ".kd" / "branches"
+        if not branches_dir.exists() or not any(branches_dir.iterdir()):
+            typer.echo("No tracked branches. Use `kd start <branch>` to create one.")
+            return
+
+        # Determine current kd session
+        current_session: str | None = None
+        current_path = base / ".kd" / "current"
+        if current_path.exists():
+            current_session = current_path.read_text(encoding="utf-8").strip() or None
+
+        # Determine current git branch
+        git_branch = get_current_git_branch()
+        git_normalized = normalize_branch_name(git_branch) if git_branch else None
+
+        for branch_dir in sorted(branches_dir.iterdir()):
+            if not branch_dir.is_dir():
+                continue
+            name = branch_dir.name
+
+            # Read original branch name from state.json
+            state_path = branch_dir / "state.json"
+            original = name
+            branch_status = ""
+            if state_path.exists():
+                try:
+                    state = read_json(state_path)
+                    original = state.get("branch", name)
+                    if state.get("status") == "done":
+                        branch_status = " [dim](done)[/dim]"
+                except (FileNotFoundError, KeyError):
+                    pass
+
+            # Count open tickets
+            tickets_dir = branch_dir / "tickets"
+            ticket_count = 0
+            if tickets_dir.exists():
+                ticket_count = sum(1 for f in tickets_dir.glob("*.md"))
+
+            # Build markers
+            markers = []
+            if name == current_session:
+                markers.append("[bold cyan]* session[/bold cyan]")
+            if name == git_normalized:
+                markers.append("[green]* git[/green]")
+            marker_str = f"  ({', '.join(markers)})" if markers else ""
+
+            console.print(f"  {original}{branch_status}  [{ticket_count} tickets]{marker_str}")
+        return
+
+    # Switch mode: validate and update
+    normalized = normalize_branch_name(branch)
+    branch_dir = base / ".kd" / "branches" / normalized
+    if not branch_dir.exists():
+        print_error(f"Branch '{branch}' not found in .kd/branches/.")
+        error_console.print("Available branches:")
+        branches_dir = base / ".kd" / "branches"
+        if branches_dir.exists():
+            for d in sorted(branches_dir.iterdir()):
+                if d.is_dir():
+                    error_console.print(f"  {d.name}")
+        raise typer.Exit(code=1)
+
+    set_current_run(base, normalized)
+
+    # Print summary
+    state_path = branch_dir / "state.json"
+    original = branch
+    if state_path.exists():
+        try:
+            state = read_json(state_path)
+            original = state.get("branch", branch)
+        except (FileNotFoundError, KeyError):
+            pass
+
+    tickets_dir = branch_dir / "tickets"
+    tickets = list_tickets(tickets_dir) if tickets_dir.exists() else []
+    open_count = sum(1 for t in tickets if t.status != "closed")
+    closed_count = sum(1 for t in tickets if t.status == "closed")
+
+    git_branch = get_current_git_branch()
+    git_info = f"  git: {git_branch}" if git_branch else ""
+    if git_branch and normalize_branch_name(git_branch) != normalized:
+        git_info += " [yellow](mismatch)[/yellow]"
+
+    console.print(f"Switched to [bold]{original}[/bold]")
+    console.print(f"  {open_count} open, {closed_count} closed tickets{git_info}")
+
+
 @app.command(help="Mark the current session as done.")
 def done(
     feature: Annotated[str | None, typer.Argument(help="Branch name (defaults to current session).")] = None,
@@ -219,7 +332,7 @@ def done(
     # Clean up associated worktrees (read from state.json worktrees map)
     worktrees = state.get("worktrees", {})
     if worktrees:
-        if not force:
+        if not force and sys.stdin.isatty():
             names = ", ".join(worktrees.keys())
             typer.confirm(f"Remove {len(worktrees)} worktree(s) ({names})?", abort=True)
         for ticket_id, wt_path in worktrees.items():
@@ -324,11 +437,11 @@ def status(
         if ticket.status in status_counts:
             status_counts[ticket.status] += 1
 
-    # Count ready tickets (open/in_progress with all deps closed — excludes in_review)
+    # Count ready tickets (open with all deps closed — startable, not already started)
     status_by_id = {t.id: t.status for t in tickets}
     ready_count = 0
     for ticket in tickets:
-        if ticket.status not in ("open", "in_progress"):
+        if ticket.status != "open":
             continue
         all_deps_closed = all(status_by_id.get(dep, "unknown") == "closed" for dep in ticket.deps)
         if all_deps_closed: