forgexa-cli 1.0.2__py3-none-any.whl

forgexa_cli/__init__.py

@@ -0,0 +1,2 @@
+"""forgexa-cli — Forgexa command-line client."""
+__version__ = "1.0.2"

forgexa_cli/main.py

@@ -0,0 +1,592 @@
+"""
+Forgexa CLI — command-line client for the Forgexa platform.
+
+A lightweight, standalone CLI that communicates with the Forgexa server via REST API.
+Zero external dependencies — uses only Python stdlib.
+
+Configuration:
+    FORGEXA_SERVER_URL   Server URL (default: http://localhost:8000)
+    FORGEXA_TOKEN        Bearer token (obtain via `forgexa login`)
+
+Usage:
+    forgexa login
+    forgexa workspace list
+    forgexa project list --workspace <id>
+    forgexa requirement list --project <id>
+    forgexa daemon status
+    forgexa gates pending
+    forgexa --help
+"""
+from __future__ import annotations
+
+import argparse
+import getpass
+import json
+import os
+import signal
+import sys
+from pathlib import Path
+
+# ── HTTP helpers (stdlib only) ──
+
+
+def _api_url() -> str:
+    return os.environ.get("FORGEXA_SERVER_URL") or os.environ.get("ASF_SERVER_URL", "http://localhost:8000")
+
+
+def _token() -> str | None:
+    # 1. Environment variable (new name, fallback to legacy)
+    token = os.environ.get("FORGEXA_TOKEN") or os.environ.get("ASF_TOKEN")
+    if token:
+        return token
+    # 2. Token file (new path, fallback to legacy)
+    for config_dir in [".forgexa", ".asf"]:
+        token_file = Path.home() / config_dir / "token"
+        if token_file.exists():
+            return token_file.read_text().strip()
+    return None
+
+
+def _headers() -> dict[str, str]:
+    h: dict[str, str] = {"Content-Type": "application/json"}
+    token = _token()
+    if token:
+        h["Authorization"] = f"Bearer {token}"
+    return h
+
+
+def _get(path: str) -> dict | list:
+    import urllib.request
+    import urllib.error
+
+    url = f"{_api_url()}/api/v1{path}"
+    req = urllib.request.Request(url, headers=_headers())
+    try:
+        with urllib.request.urlopen(req, timeout=15) as resp:
+            return json.loads(resp.read())
+    except urllib.error.HTTPError as e:
+        body = e.read().decode(errors="replace")
+        print(f"Error {e.code}: {body}", file=sys.stderr)
+        sys.exit(1)
+    except urllib.error.URLError as e:
+        print(f"Connection error: {e.reason}\nServer: {_api_url()}", file=sys.stderr)
+        sys.exit(1)
+
+
+def _post(path: str, data: dict | None = None) -> dict:
+    import urllib.request
+    import urllib.error
+
+    url = f"{_api_url()}/api/v1{path}"
+    body = json.dumps(data or {}).encode()
+    req = urllib.request.Request(url, data=body, headers=_headers(), method="POST")
+    try:
+        with urllib.request.urlopen(req, timeout=30) as resp:
+            return json.loads(resp.read())
+    except urllib.error.HTTPError as e:
+        body_text = e.read().decode(errors="replace")
+        print(f"Error {e.code}: {body_text}", file=sys.stderr)
+        sys.exit(1)
+    except urllib.error.URLError as e:
+        print(f"Connection error: {e.reason}\nServer: {_api_url()}", file=sys.stderr)
+        sys.exit(1)
+
+
+def _delete(path: str) -> dict | None:
+    import urllib.request
+    import urllib.error
+
+    url = f"{_api_url()}/api/v1{path}"
+    req = urllib.request.Request(url, headers=_headers(), method="DELETE")
+    try:
+        with urllib.request.urlopen(req, timeout=15) as resp:
+            content = resp.read()
+            return json.loads(content) if content else None
+    except urllib.error.HTTPError as e:
+        body = e.read().decode(errors="replace")
+        print(f"Error {e.code}: {body}", file=sys.stderr)
+        sys.exit(1)
+    except urllib.error.URLError as e:
+        print(f"Connection error: {e.reason}\nServer: {_api_url()}", file=sys.stderr)
+        sys.exit(1)
+
+
+# ── Output helpers ──
+
+_output_format = "table"
+
+
+def _fmt() -> str:
+    return _output_format
+
+
+def _print_table(headers: list[str], rows: list[list[str]], fmt: str | None = None) -> None:
+    fmt = fmt or _fmt()
+    if fmt == "json":
+        result = [dict(zip(headers, row)) for row in rows]
+        print(json.dumps(result, indent=2, ensure_ascii=False))
+        return
+    if fmt == "quiet":
+        for row in rows:
+            print(row[0] if row else "")
+        return
+    if not rows:
+        return
+    widths = [len(h) for h in headers]
+    for row in rows:
+        for i, cell in enumerate(row):
+            if i < len(widths):
+                widths[i] = max(widths[i], len(str(cell)))
+    line_fmt = "  ".join(f"{{:<{w}}}" for w in widths)
+    print(line_fmt.format(*headers))
+    print(line_fmt.format(*("-" * w for w in widths)))
+    for row in rows:
+        print(line_fmt.format(*[str(c) for c in row]))
+
+
+# ── Commands ──
+
+
+def cmd_login(args: argparse.Namespace) -> None:
+    email = args.email or input("Email: ")
+    password = args.password or getpass.getpass("Password: ")
+    result = _post("/auth/login", {"email": email, "password": password})
+    token = result.get("access_token", "")
+    # Save token to file
+    token_dir = Path.home() / ".forgexa"
+    token_dir.mkdir(exist_ok=True)
+    (token_dir / "token").write_text(token)
+    (token_dir / "token").chmod(0o600)
+    print(f"Login successful. Token saved to ~/.forgexa/token")
+    print(f"Or set manually: export FORGEXA_TOKEN={token}")
+
+
+def cmd_logout(_args: argparse.Namespace) -> None:
+    removed = False
+    for config_dir in [".forgexa", ".asf"]:
+        token_file = Path.home() / config_dir / "token"
+        if token_file.exists():
+            token_file.unlink()
+            removed = True
+    if removed:
+        print("Logged out. Token removed.")
+    else:
+        print("No token file found.")
+
+
+def cmd_daemon_status(_args: argparse.Namespace) -> None:
+    runtimes = _get("/runtimes")
+    if not runtimes:
+        print("No daemons registered.")
+        return
+    _print_table(
+        ["ID", "Daemon", "Device", "Status", "Active", "Max", "Heartbeat"],
+        [
+            [
+                r["id"][:8],
+                r["daemon_id"],
+                r.get("device_name", ""),
+                r["status"],
+                str(r.get("active_tasks", 0)),
+                str(r.get("max_concurrent_tasks", 0)),
+                r.get("last_heartbeat_at", "")[:19] if r.get("last_heartbeat_at") else "never",
+            ]
+            for r in runtimes
+        ],
+    )
+
+
+def cmd_daemon_stop(_args: argparse.Namespace) -> None:
+    # Check new path first, fallback to legacy
+    for pid_path in [".forgexa-daemon.pid", ".asf-daemon.pid"]:
+        pid_file = Path.home() / pid_path
+        if pid_file.exists():
+            break
+    else:
+        print("No daemon PID file found. Is a daemon running?")
+        sys.exit(1)
+    pid = int(pid_file.read_text().strip())
+    try:
+        os.kill(pid, signal.SIGTERM)
+        print(f"Sent SIGTERM to daemon (PID {pid})")
+        pid_file.unlink()
+    except ProcessLookupError:
+        print(f"Daemon process {pid} not found (already stopped?)")
+        pid_file.unlink()
+    except PermissionError:
+        print(f"Permission denied to stop daemon (PID {pid})")
+        sys.exit(1)
+
+
+def cmd_runtimes_list(_args: argparse.Namespace) -> None:
+    runtimes = _get("/runtimes")
+    if not runtimes:
+        print("No runtimes registered.")
+        return
+    _print_table(
+        ["ID", "Daemon", "Status", "Agents", "Active/Max"],
+        [
+            [
+                r["id"][:8],
+                r["daemon_id"],
+                r["status"],
+                ", ".join(
+                    a["agent_id"] for a in r.get("available_agents", []) if isinstance(a, dict)
+                ),
+                f"{r.get('active_tasks', 0)}/{r.get('max_concurrent_tasks', 0)}",
+            ]
+            for r in runtimes
+        ],
+    )
+
+
+def cmd_workspace_list(_args: argparse.Namespace) -> None:
+    workspaces = _get("/workspaces")
+    if not workspaces:
+        print("No workspaces.")
+        return
+    _print_table(
+        ["ID", "Name", "Budget Used/Limit"],
+        [
+            [
+                w["id"][:8],
+                w["name"],
+                "$%.2f / $%.2f" % (float(w.get('budget_used_usd') or 0), float(w.get('budget_monthly_limit_usd') or 0)),
+            ]
+            for w in workspaces
+        ],
+    )
+
+
+def cmd_workspace_create(args: argparse.Namespace) -> None:
+    result = _post("/workspaces", {"name": args.name})
+    print(f"Created workspace: {result.get('id', '')} — {result.get('name', '')}")
+
+
+def cmd_project_list(args: argparse.Namespace) -> None:
+    projects = _get(f"/workspaces/{args.workspace}/projects")
+    if not projects:
+        print("No projects.")
+        return
+    _print_table(
+        ["ID", "Key", "Name", "Status"],
+        [[p["id"][:8], p.get("project_key", ""), p["name"], p["status"]] for p in projects],
+    )
+
+
+def cmd_project_status(args: argparse.Namespace) -> None:
+    status = _get(f"/projects/{args.project}/status")
+    print(json.dumps(status, indent=2))
+
+
+def cmd_project_create(args: argparse.Namespace) -> None:
+    data = {"name": args.name, "tech_stack": args.stack or ""}
+    result = _post(f"/workspaces/{args.workspace}/projects", data)
+    print(f"Created project: {result.get('id', '')} — {result.get('name', '')}")
+
+
+def cmd_requirement_list(args: argparse.Namespace) -> None:
+    reqs = _get(f"/projects/{args.project}/requirements")
+    if not reqs:
+        print("No requirements.")
+        return
+    _print_table(
+        ["ID", "Title", "Status", "Priority", "Version"],
+        [
+            [r["id"][:8], r["title"][:40], r["status"], r["priority"], str(r.get("version", 1))]
+            for r in reqs
+        ],
+    )
+
+
+def cmd_requirement_create(args: argparse.Namespace) -> None:
+    data = {"title": args.title, "description": args.description or ""}
+    result = _post(f"/projects/{args.project}/requirements", data)
+    print(f"Created requirement: {result.get('id', '')} — {result.get('title', '')}")
+
+
+def cmd_requirement_analyze(args: argparse.Namespace) -> None:
+    result = _post(f"/requirements/{args.id}/analyze")
+    print(f"Status: {result.get('status')}")
+    analysis = (result.get("metadata") or {}).get("analysis", {})
+    if analysis:
+        print(json.dumps(analysis, indent=2, ensure_ascii=False)[:3000])
+
+
+def cmd_board(args: argparse.Namespace) -> None:
+    board = _get(f"/projects/{args.project}/board")
+    columns = board.get("columns", {})
+    for col in ["backlog", "todo", "in_progress", "in_review", "done"]:
+        items = columns.get(col, [])
+        print(f"\n{'=' * 40}")
+        print(f"  {col.upper()} ({len(items)})")
+        print(f"{'=' * 40}")
+        for item in items:
+            print(
+                f"  [{item.get('type', '')}] {item['title'][:50]}  ({item.get('priority', '')})"
+            )
+
+
+def cmd_gates_pending(_args: argparse.Namespace) -> None:
+    gates = _get("/gates/pending")
+    if not gates:
+        print("No pending gates.")
+        return
+    _print_table(
+        ["ID", "Type", "Score", "Threshold", "Reviewer"],
+        [
+            [
+                g["id"][:8],
+                g.get("gate_type", ""),
+                f"{g.get('score', 0):.1f}",
+                f"{g.get('threshold', 0):.1f}",
+                g.get("reviewer_type", ""),
+            ]
+            for g in gates
+        ],
+    )
+
+
+def cmd_gate_approve(args: argparse.Namespace) -> None:
+    result = _post(f"/gates/{args.id}/approve", {"comment": args.comment or ""})
+    print(f"Gate {args.id[:8]}: {result.get('result')}")
+
+
+def cmd_gate_reject(args: argparse.Namespace) -> None:
+    result = _post(f"/gates/{args.id}/reject", {"comment": args.reason or "Rejected via CLI"})
+    print(f"Gate {args.id[:8]}: {result.get('result')}")
+
+
+def cmd_workflow_show(args: argparse.Namespace) -> None:
+    wf = _get(f"/projects/{args.project}/workflow")
+    if wf.get("raw_content"):
+        print(wf["raw_content"])
+    else:
+        print(json.dumps(wf, indent=2, ensure_ascii=False))
+
+
+def cmd_workflow_reload(args: argparse.Namespace) -> None:
+    result = _post(f"/projects/{args.project}/workflow/reload")
+    print(f"Workflow reloaded: status={result.get('status')}, version={result.get('version')}")
+
+
+def cmd_budget(args: argparse.Namespace) -> None:
+    if args.workspace:
+        data = _get(f"/workspaces/{args.workspace}/budget")
+    elif args.project:
+        data = _get(f"/projects/{args.project}/budget")
+    else:
+        print("Specify --workspace or --project", file=sys.stderr)
+        sys.exit(1)
+    print(json.dumps(data, indent=2))
+
+
+def cmd_execution_list(args: argparse.Namespace) -> None:
+    execs = _get(f"/projects/{args.project}/executions")
+    if not execs:
+        print("No executions.")
+        return
+    _print_table(
+        ["ID", "Status", "Started", "Finished"],
+        [
+            [
+                e["id"][:8],
+                e["status"],
+                e.get("started_at", "")[:19] if e.get("started_at") else "",
+                e.get("finished_at", "")[:19] if e.get("finished_at") else "",
+            ]
+            for e in execs
+        ],
+        fmt=getattr(args, "format", "table"),
+    )
+
+
+def cmd_execution_start(args: argparse.Namespace) -> None:
+    result = _post(f"/executions/{args.execution_id}/start")
+    print(f"Execution {args.execution_id[:8]}: status={result.get('status')}")
+
+
+def cmd_version(_args: argparse.Namespace) -> None:
+    from forgexa_cli import __version__
+
+    print(f"forgexa {__version__}")
+
+
+# ── Argument parser ──
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        prog="forgexa",
+        description="Forgexa CLI — communicates with the Forgexa server via REST API.",
+        epilog=(
+            "Configuration:\n"
+            "  FORGEXA_SERVER_URL   Server URL (default: http://localhost:8000)\n"
+            "  FORGEXA_TOKEN        Bearer token (or use `forgexa login`)\n"
+        ),
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    parser.add_argument(
+        "--server-url",
+        default=None,
+        help="Server URL (default: $FORGEXA_SERVER_URL or http://localhost:8000)",
+    )
+    parser.add_argument(
+        "--format",
+        choices=["table", "json", "quiet"],
+        default="table",
+        help="Output format",
+    )
+    sub = parser.add_subparsers(dest="command", help="Available commands")
+
+    # version
+    sub.add_parser("version", help="Show CLI version")
+
+    # auth
+    login_p = sub.add_parser("login", help="Login and save access token")
+    login_p.add_argument("--email", help="Email address")
+    login_p.add_argument("--password", help="Password")
+    sub.add_parser("logout", help="Remove saved access token")
+
+    # daemon (remote API only — use forgexa-daemon for local daemon management)
+    daemon_p = sub.add_parser("daemon", help="Daemon management (remote)")
+    daemon_sub = daemon_p.add_subparsers(dest="daemon_cmd")
+    daemon_sub.add_parser("status", help="Show all daemon statuses (from server)")
+    daemon_sub.add_parser("stop", help="Stop local daemon (sends SIGTERM)")
+
+    # runtimes
+    rt_p = sub.add_parser("runtimes", help="Runtime management")
+    rt_sub = rt_p.add_subparsers(dest="rt_cmd")
+    rt_sub.add_parser("list", help="List all runtimes")
+
+    # workspace
+    ws_p = sub.add_parser("workspace", help="Workspace management")
+    ws_sub = ws_p.add_subparsers(dest="ws_cmd")
+    ws_sub.add_parser("list", help="List workspaces")
+    wsc = ws_sub.add_parser("create", help="Create a workspace")
+    wsc.add_argument("name", help="Workspace name")
+
+    # project
+    proj_p = sub.add_parser("project", help="Project management")
+    proj_sub = proj_p.add_subparsers(dest="proj_cmd")
+    pl = proj_sub.add_parser("list", help="List projects")
+    pl.add_argument("--workspace", required=True, help="Workspace ID")
+    ps = proj_sub.add_parser("status", help="Project status")
+    ps.add_argument("--project", required=True, help="Project ID")
+    pc = proj_sub.add_parser("create", help="Create a project")
+    pc.add_argument("name", help="Project name")
+    pc.add_argument("--workspace", required=True, help="Workspace ID")
+    pc.add_argument("--stack", default=None, help="Tech stack")
+
+    # requirement
+    req_p = sub.add_parser("requirement", help="Requirement management")
+    req_sub = req_p.add_subparsers(dest="req_cmd")
+    rl = req_sub.add_parser("list", help="List requirements")
+    rl.add_argument("--project", required=True)
+    ra = req_sub.add_parser("analyze", help="Analyze a requirement")
+    ra.add_argument("--id", required=True)
+    rc = req_sub.add_parser("create", help="Create a requirement")
+    rc.add_argument("title", help="Requirement title")
+    rc.add_argument("--project", required=True, help="Project ID")
+    rc.add_argument("--description", default="", help="Requirement description")
+
+    # board
+    board_p = sub.add_parser("board", help="Show kanban board")
+    board_p.add_argument("--project", required=True)
+
+    # gates
+    gate_p = sub.add_parser("gates", help="Gate management")
+    gate_sub = gate_p.add_subparsers(dest="gate_cmd")
+    gate_sub.add_parser("pending", help="List pending gates")
+    ga = gate_sub.add_parser("approve", help="Approve a gate")
+    ga.add_argument("--gate", required=True, dest="id")
+    ga.add_argument("--comment", default="")
+    gr = gate_sub.add_parser("reject", help="Reject a gate")
+    gr.add_argument("--gate", required=True, dest="id")
+    gr.add_argument("--reason", default="Rejected via CLI")
+
+    # workflow
+    wf_p = sub.add_parser("workflow", help="Workflow policy management")
+    wf_sub = wf_p.add_subparsers(dest="wf_cmd")
+    wfs = wf_sub.add_parser("show", help="Show current workflow")
+    wfs.add_argument("--project", required=True)
+    wfr = wf_sub.add_parser("reload", help="Reload workflow from repo")
+    wfr.add_argument("--project", required=True)
+
+    # budget
+    budget_p = sub.add_parser("budget", help="Budget overview")
+    budget_p.add_argument("--workspace", default=None)
+    budget_p.add_argument("--project", default=None)
+
+    # executions
+    exec_p = sub.add_parser("run", help="Execution management")
+    exec_sub = exec_p.add_subparsers(dest="run_cmd")
+    el = exec_sub.add_parser("list", help="List executions")
+    el.add_argument("--project", required=True)
+    es = exec_sub.add_parser("start", help="Start a pending execution")
+    es.add_argument("execution_id", help="Execution graph ID")
+
+    args = parser.parse_args()
+
+    if args.server_url:
+        os.environ["FORGEXA_SERVER_URL"] = args.server_url
+
+    global _output_format
+    _output_format = args.format or "table"
+
+    cmd = args.command
+    if not cmd:
+        parser.print_help()
+        return
+
+    dispatch: dict = {
+        "version": cmd_version,
+        "login": cmd_login,
+        "logout": cmd_logout,
+        "daemon": lambda a: {
+            "status": cmd_daemon_status,
+            "stop": cmd_daemon_stop,
+        }.get(a.daemon_cmd, lambda _: daemon_p.print_help())(a),
+        "runtimes": lambda a: {
+            "list": cmd_runtimes_list,
+        }.get(a.rt_cmd, lambda _: rt_p.print_help())(a),
+        "workspace": lambda a: {
+            "list": cmd_workspace_list,
+            "create": cmd_workspace_create,
+        }.get(a.ws_cmd, lambda _: ws_p.print_help())(a),
+        "project": lambda a: {
+            "list": cmd_project_list,
+            "status": cmd_project_status,
+            "create": cmd_project_create,
+        }.get(a.proj_cmd, lambda _: proj_p.print_help())(a),
+        "requirement": lambda a: {
+            "list": cmd_requirement_list,
+            "analyze": cmd_requirement_analyze,
+            "create": cmd_requirement_create,
+        }.get(a.req_cmd, lambda _: req_p.print_help())(a),
+        "board": cmd_board,
+        "gates": lambda a: {
+            "pending": cmd_gates_pending,
+            "approve": cmd_gate_approve,
+            "reject": cmd_gate_reject,
+        }.get(a.gate_cmd, lambda _: gate_p.print_help())(a),
+        "workflow": lambda a: {
+            "show": cmd_workflow_show,
+            "reload": cmd_workflow_reload,
+        }.get(a.wf_cmd, lambda _: wf_p.print_help())(a),
+        "budget": cmd_budget,
+        "run": lambda a: {
+            "list": cmd_execution_list,
+            "start": cmd_execution_start,
+        }.get(a.run_cmd, lambda _: exec_p.print_help())(a),
+    }
+
+    handler = dispatch.get(cmd)
+    if handler:
+        handler(args)
+    else:
+        parser.print_help()
+
+
+if __name__ == "__main__":
+    main()

forgexa_cli-1.0.2.dist-info/METADATA

@@ -0,0 +1,183 @@
+Metadata-Version: 2.4
+Name: forgexa-cli
+Version: 1.0.2
+Summary: Forgexa CLI — command-line client for managing workspaces, projects, requirements, and agent runtimes
+Author-email: Shinetech <dev@shinetechsoftware.com>
+License: MIT
+Project-URL: Homepage, https://forgexa.net
+Project-URL: Documentation, https://docs.forgexa.net
+Project-URL: Repository, https://github.com/anthropics/ai-software-factory
+Project-URL: Issues, https://github.com/anthropics/ai-software-factory/issues
+Keywords: forgexa,ai,software-factory,cli,devops,agent
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Build Tools
+Classifier: Topic :: Software Development :: Quality Assurance
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+
+# Forgexa CLI
+
+Command-line client for the [[Forgexa](https://forgexa.net) platform.
+
+Lightweight, zero-dependency — communicates with the Forgexa server via REST API using only Python stdlib.
+
+## Installation
+
+```bash
+# From PyPI (recommended)
+pip install forgexa-cli
+
+# Or with pipx (isolated environment)
+pipx install forgexa-cli
+
+# Verify installation
+forgexa version
+```
+
+### Development Installation
+
+```bash
+# Install from source (editable mode)
+git clone https://github.com/anthropics/ai-software-factory.git
+cd ai-software-factory/cli
+pip install -e .
+```
+
+## Quick Start
+
+```bash
+# Configure server (default: http://localhost:8000)
+export FORGEXA_SERVER_URL=https://your-server.example.com
+
+# Login (saves token to ~/.forgexa/token)
+asf login
+
+# List workspaces
+asf workspace list
+
+# List projects
+asf project list --workspace <workspace-id>
+
+# Show kanban board
+asf board --project <project-id>
+```
+
+## Commands
+
+| Command | Description |
+|---------|-------------|
+| `forgexa login` | Login and save access token |
+| `forgexa logout` | Remove saved token |
+| `forgexa workspace list` | List workspaces |
+| `forgexa workspace create <name>` | Create a workspace |
+| `forgexa project list --workspace <id>` | List projects |
+| `forgexa project create <name> --workspace <id>` | Create a project |
+| `forgexa requirement list --project <id>` | List requirements |
+| `forgexa requirement create <title> --project <id>` | Create a requirement |
+| `forgexa requirement analyze --id <id>` | Analyze a requirement |
+| `forgexa board --project <id>` | Show kanban board |
+| `forgexa run list --project <id>` | List executions |
+| `forgexa run start <execution-id>` | Start an execution |
+| `forgexa gates pending` | List pending gates |
+| `forgexa gates approve --gate <id>` | Approve a gate |
+| `forgexa gates reject --gate <id>` | Reject a gate |
+| `forgexa workflow show --project <id>` | Show workflow policy |
+| `forgexa workflow reload --project <id>` | Reload workflow |
+| `forgexa budget --workspace <id>` | Budget overview |
+| `forgexa daemon status` | Show daemon statuses |
+| `forgexa daemon stop` | Stop local daemon |
+| `forgexa runtimes list` | List runtimes |
+| `forgexa version` | Show CLI version |
+
+## Configuration
+
+| Variable | Default | Description |
+|----------|---------|-------------|
+| `FORGEXA_SERVER_URL` | `http://localhost:8000` | `Server base URL |
+| `FORGEXA_TOKEN` | — | Bearer token (overrides `~/.forgexa/token`) |
+
+## Output Format
+
+```bash
+asf workspace list                  # Table (default)
+asf workspace list --format json    # JSON
+asf workspace list --format quiet   # IDs only
+```
+
+## Daemon Management
+
+The `forgexa` CLI handles remote daemon queries. To **start** a daemon locally,
+use the `forgexa-daemon` command from the backend package:
+
+```bash
+pip install ./backend
+forgexa-daemon  # starts the runtime daemon
+```
+
+## Publishing to PyPI
+
+### Prerequisites
+
+```bash
+pip install build twine
+```
+
+### Build & Publish
+
+```bash
+cd cli/
+
+# Build only (creates dist/)
+./scripts/publish.sh build
+
+# Publish to TestPyPI (for testing)
+./scripts/publish.sh test
+
+# Publish to PyPI (production)
+./scripts/publish.sh
+```
+
+### Version Bumping
+
+```bash
+# Bump version (updates pyproject.toml + __init__.py)
+./scripts/bump-version.sh 0.3.0
+
+# Then commit, tag, and publish
+git add -A && git commit -m "release(cli): v0.3.0"
+git tag cli-v0.3.0
+./scripts/publish.sh
+```
+
+### PyPI Authentication
+
+Configure via environment variables or `~/.pypirc`:
+
+```bash
+# Using API token (recommended)
+export TWINE_USERNAME=__token__
+export TWINE_PASSWORD=pypi-AgEIcH...
+
+# Or create ~/.pypirc
+cat > ~/.pypirc << 'EOF'
+[pypi]
+username = __token__
+password = pypi-AgEIcH...
+
+[testpypi]
+repository = https://test.pypi.org/legacy/
+username = __token__
+password = pypi-AgEIcH...
+EOF
+chmod 600 ~/.pypirc
+```

forgexa_cli-1.0.2.dist-info/RECORD

@@ -0,0 +1,8 @@
+forgexa_cli/__init__.py,sha256=haJPS5qIm70bNh8_Q0up6H_-dxj12agqS3Y7MPZOal8,73
+forgexa_cli/main.py,sha256=crKUI1a-kcm2aaDverjvFdVjy8Z-cDBA5CKZJ46eWjQ,20237
+forgexa_cli/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+forgexa_cli-1.0.2.dist-info/METADATA,sha256=J2nwPvyVfAECfCqm0-fCSr04wgcXt8llA_zCPV5M-UI,5072
+forgexa_cli-1.0.2.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+forgexa_cli-1.0.2.dist-info/entry_points.txt,sha256=xsyhMUyXX5cIytreQJf_TvOjxNrXKxnpto7ERL0oUy8,50
+forgexa_cli-1.0.2.dist-info/top_level.txt,sha256=fmUzrXOBX6YCXHLqfvVl1xAwdBIx25hx2XCpeo0N6DU,12
+forgexa_cli-1.0.2.dist-info/RECORD,,

forgexa_cli-1.0.2.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

forgexa_cli-1.0.2.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+forgexa = forgexa_cli.main:main

forgexa_cli-1.0.2.dist-info/top_level.txt

@@ -0,0 +1 @@
+forgexa_cli