lithora-cli 0.2.0__py3-none-any.whl

lithora_cli/__init__.py

@@ -0,0 +1,3 @@
+"""lithora-cli — the terminal-native, agent-grade control plane for Lithora."""
+
+__version__ = "0.2.0"

lithora_cli/commands/_common.py

@@ -0,0 +1,41 @@
+"""Shared command helpers: client access + clean SDK-error → exit-code mapping."""
+
+from __future__ import annotations
+
+from contextlib import contextmanager
+
+import typer
+
+from lithora import ApiError, AuthError, LithoraError
+from ..output import error, exit_code_for, render
+
+
+def client(ctx: typer.Context):
+    """The authenticated Lithora client built by the global callback."""
+    return ctx.obj["client"]
+
+
+def out(ctx: typer.Context) -> str:
+    return ctx.obj.get("output", "table")
+
+
+@contextmanager
+def errors():
+    """Map SDK exceptions to a friendly stderr message + the right exit code."""
+    try:
+        yield
+    except AuthError as e:
+        detail = getattr(e, "detail", None) or str(e)
+        error("{}  (run 'lithora login')".format(detail))
+        raise typer.Exit(exit_code_for(getattr(e, "status_code", 401)))
+    except ApiError as e:
+        error(str(getattr(e, "detail", None) or e))
+        raise typer.Exit(exit_code_for(getattr(e, "status_code", None)))
+    except LithoraError as e:
+        error(str(e))
+        raise typer.Exit(1)
+
+
+def show(ctx: typer.Context, data, *, columns=None, title=None) -> None:
+    """Render a payload in the invocation's output mode."""
+    render(data, out(ctx), columns=columns, title=title)

lithora_cli/commands/account.py

@@ -0,0 +1,70 @@
+"""`lithora token` (PATs) and `lithora profile` (contexts)."""
+
+from __future__ import annotations
+
+from typing import List, Optional
+
+import typer
+
+from .. import config
+from ._common import client, errors, show
+from ..output import success
+
+# ---- token group (Personal Access Tokens) ---------------------------------
+token_app = typer.Typer(no_args_is_help=True, help="Personal access tokens (scoped API keys).")
+
+
+@token_app.command("create")
+def token_create(
+    ctx: typer.Context,
+    name: str = typer.Option(..., "--name", "-n", help="Label for the token"),
+    scopes: Optional[List[str]] = typer.Option(None, "--scope", help="Repeatable, e.g. tasks:write"),
+    expires_in_days: Optional[int] = typer.Option(None, "--expires-in-days"),
+):
+    """Mint a scoped PAT (the secret is shown ONCE — store it securely)."""
+    with errors():
+        show(ctx, client(ctx).tokens.create(name, scopes=scopes or None, expires_in_days=expires_in_days))
+
+
+@token_app.command("list")
+def token_list(ctx: typer.Context):
+    """List your PATs (masked)."""
+    with errors():
+        show(ctx, client(ctx).tokens.list(),
+             columns=["token_id", "name", "scopes", "expires_at", "last_used_at"])
+
+
+@token_app.command("revoke")
+def token_revoke(ctx: typer.Context, token_id: str = typer.Argument(...)):
+    """Revoke a PAT immediately."""
+    with errors():
+        client(ctx).tokens.revoke(token_id)
+        success("Revoked {}".format(token_id))
+
+
+# ---- profile group (contexts) ---------------------------------------------
+profile_app = typer.Typer(no_args_is_help=True, help="Switch between accounts/orgs (contexts).")
+
+
+@profile_app.command("list")
+def profile_list(ctx: typer.Context):
+    """List configured profiles."""
+    cur = config.current_profile()
+    rows = [{"profile": ("* " + n) if n == cur else n, "base_url": p.get("base_url", "")}
+            for n, p in config.list_profiles().items()]
+    show(ctx, {"profiles": rows or [{"profile": "default", "base_url": config.DEFAULT_BASE_URL}]},
+         columns=["profile", "base_url"])
+
+
+@profile_app.command("use")
+def profile_use(name: str = typer.Argument(..., help="Profile name to switch to")):
+    """Set the active profile."""
+    config.use_profile(name)
+    success("Now using profile '{}'".format(name))
+
+
+@profile_app.command("show")
+def profile_show(ctx: typer.Context):
+    """Show the active profile + base URL (token not printed)."""
+    cfg = ctx.obj["config"]
+    show(ctx, {"profile": cfg.profile, "base_url": cfg.base_url, "authenticated": bool(cfg.token)})

lithora_cli/commands/ai.py

@@ -0,0 +1,192 @@
+"""`lithora ai` — the confirmation-gated agent, in your terminal.
+
+    lithora ai "plan the Q3 launch into tasks"     # propose → approve → apply
+    lithora ai pending                             # staged overnight-triage plans
+    lithora ai confirm <action_id> --session <sid> # approve a staged plan
+    lithora ai sessions                            # your AI sessions
+
+The agent NEVER writes without approval: chat returns a PLAN; you approve it here.
+"""
+
+from __future__ import annotations
+
+from typing import Optional
+
+import typer
+from typer.core import TyperGroup
+
+try:  # standard Typer depends on the real click…
+    import click  # type: ignore
+except ImportError:  # …typer-slim vendors it as typer._click
+    from typer import _click as click  # type: ignore
+
+from ._common import client, errors, out, show
+from ..output import error, is_tty, print_json, success, EXIT_USAGE
+
+
+class _AiGroup(TyperGroup):
+    """Route a bare prompt to ``chat`` so ``lithora ai "plan the launch"`` works.
+
+    Real subcommands (chat/pending/confirm/sessions) still resolve normally; only
+    when the first token isn't one of them do we treat the whole arg list as a
+    chat message — so the natural-language shortcut and the structured commands
+    coexist without one stealing the other.
+    """
+
+    def resolve_command(self, ctx, args):
+        try:
+            return super().resolve_command(ctx, args)
+        except click.exceptions.UsageError:
+            chat_cmd = self.get_command(ctx, "chat")
+            if chat_cmd is None:  # pragma: no cover - chat is always registered
+                raise
+            return chat_cmd.name, chat_cmd, args
+
+
+app = typer.Typer(
+    cls=_AiGroup,
+    no_args_is_help=False,
+    invoke_without_command=True,
+    # Tolerate a leading flag before the prompt (e.g. `ai --yes "do it"`); the
+    # bare prompt itself is rerouted to `chat` by _AiGroup.resolve_command.
+    context_settings={"allow_extra_args": True, "ignore_unknown_options": True},
+    help="Talk to the confirmation-gated Lithora agent.",
+)
+
+
+def _render_plan(plan: dict) -> None:
+    """Pretty-print a staged plan (summary + planned actions)."""
+    typer.secho("\nACTION PLAN  (requires confirmation)", fg=typer.colors.YELLOW, bold=True)
+    typer.echo("  Action: {}   Status: {}".format(
+        plan.get("action_id", "?"), plan.get("state", "waiting_confirmation")))
+    for i, a in enumerate((plan.get("planned_actions") or []), 1):
+        kind = a.get("type", "action")
+        if kind == "task":
+            gh = ""
+            if a.get("github_repo"):
+                gh = "  [{}{}]".format(a["github_repo"],
+                                      "#{}".format(a["github_issue_number"]) if a.get("github_issue_number") else "")
+            typer.echo("  {}. + task: {}{}".format(i, a.get("title", "?"), gh))
+            for s in (a.get("subtasks") or []):
+                typer.echo("       - subtask: {}".format(s.get("title", "?")))
+        elif kind in ("subtask", "note"):
+            typer.echo("  {}. + {}: {}".format(i, kind, a.get("title", "?")))
+        else:
+            typer.echo("  {}. {}".format(i, a.get("label") or a.get("tool") or kind))
+    typer.echo("  Summary: {}".format(plan.get("summary", "")))
+
+
+def _apply(ctx, session_id: str, action_id: str, confirmed: bool) -> None:
+    res = client(ctx).ai.confirm_agent_action(session_id, action_id, confirmed)
+    if out(ctx) == "json":
+        print_json(res)
+        return
+    if not confirmed:
+        success("Discarded — nothing was written.")
+        return
+    success(res.get("response", "Applied."))
+    for inv in (res.get("action_plan", {}) or {}).get("tool_invocations", []):
+        ok = "✓" if inv.get("success") else "✗"
+        typer.echo("  {} {}".format(ok, inv.get("function")))
+
+
+@app.callback(invoke_without_command=True)
+def ai_main(ctx: typer.Context):
+    """Send a message; if the agent proposes changes, approve them in the terminal.
+
+    `lithora ai "<prompt>"` is a shortcut for `lithora ai chat "<prompt>"` —
+    a bare prompt is routed to the chat subcommand (see _AiGroup), so flags like
+    --yes / --session work the same either way.
+    """
+    if ctx.invoked_subcommand is None:
+        typer.echo(ctx.get_help())
+        raise typer.Exit(0)
+
+
+@app.command("chat")
+def chat(
+    ctx: typer.Context,
+    prompt: str = typer.Argument(..., help="Your message to the agent"),
+    session: Optional[str] = typer.Option(None, "--session", "-s", help="Existing session id"),
+    yes: bool = typer.Option(False, "--yes", "-y", help="Auto-approve the plan (CI)"),
+):
+    """Chat with the agent (full form, with --yes / --session)."""
+    _do_chat(ctx, prompt, session=session, yes=yes)
+
+
+def _do_chat(ctx: typer.Context, prompt: str, session: Optional[str], yes: bool) -> None:
+    with errors():
+        c = client(ctx)
+        sid = session or c.ai.create_session().get("session_id")
+        resp = c.ai.chat(sid, prompt)
+
+        if out(ctx) == "json":
+            print_json(resp)
+            # In JSON mode, still honor --yes so CI can one-shot.
+            plan = resp.get("action_plan") or {}
+            if resp.get("requires_confirmation") and plan.get("action_id") and yes:
+                _apply(ctx, sid, plan["action_id"], True)
+            return
+
+        plan = resp.get("action_plan") or {}
+        if not (resp.get("requires_confirmation") and plan.get("action_id")):
+            # plain answer (no mutations proposed)
+            typer.echo(resp.get("response", ""))
+            if not session:
+                typer.secho("\n(session: {})".format(sid), dim=True)
+            return
+
+        _render_plan(plan)
+        action_id = plan["action_id"]
+
+        if yes:
+            typer.echo("\n--yes → approving.")
+            _apply(ctx, sid, action_id, True)
+            return
+        if not is_tty():
+            error("This plan requires confirmation but stdin is not a TTY. "
+                  "Re-run with --yes, or: lithora ai confirm {} --session {}".format(action_id, sid))
+            raise typer.Exit(EXIT_USAGE)
+
+        choice = typer.prompt("\nApprove? [y]es / [n]o", default="n").strip().lower()
+        _apply(ctx, sid, action_id, choice in ("y", "yes"))
+        if not session:
+            typer.secho("(session: {})".format(sid), dim=True)
+
+
+@app.command("pending")
+def pending(ctx: typer.Context):
+    """List staged-but-unapproved agent plans (e.g. overnight triage)."""
+    with errors():
+        data = client(ctx).ai.list_pending_actions()
+        if out(ctx) == "json":
+            print_json(data)
+            return
+        items = data.get("pending", []) if isinstance(data, dict) else (data or [])
+        if not items:
+            typer.echo("No staged plans awaiting approval.")
+            return
+        for p in items:
+            _render_plan(p)
+            typer.echo("  approve: lithora ai confirm {} --session {}\n".format(
+                p.get("action_id"), p.get("session_id")))
+
+
+@app.command("confirm")
+def confirm(
+    ctx: typer.Context,
+    action_id: str = typer.Argument(...),
+    session: str = typer.Option(..., "--session", "-s"),
+    reject: bool = typer.Option(False, "--reject", help="Reject instead of approve"),
+):
+    """Approve (or --reject) a staged agent plan by id."""
+    with errors():
+        _apply(ctx, session, action_id, not reject)
+
+
+@app.command("sessions")
+def sessions(ctx: typer.Context):
+    """List your AI sessions."""
+    with errors():
+        show(ctx, client(ctx).ai.list_sessions(),
+             columns=["session_id", "title", "updated_at"])

lithora_cli/commands/automations.py

@@ -0,0 +1,112 @@
+"""`lithora automations` — workflows as code (trigger → condition → action) + runs."""
+
+from __future__ import annotations
+
+from typing import Optional
+
+import typer
+
+from ._common import client, errors, out, show
+
+app = typer.Typer(no_args_is_help=True, help="Manage automations and their runs.")
+
+
+@app.command("list")
+def list_automations(ctx: typer.Context):
+    """List automations."""
+    with errors():
+        show(ctx, client(ctx).automations.list(),
+             columns=["automation_id", "name", "trigger_type", "is_active"])
+
+
+@app.command("show")
+def show_automation(ctx: typer.Context, automation_id: str = typer.Argument(...)):
+    """Show one automation (trigger/condition/actions)."""
+    with errors():
+        show(ctx, client(ctx).automations.get(automation_id))
+
+
+@app.command("create")
+def create_automation(
+    ctx: typer.Context,
+    name: str = typer.Option(..., "--name", "-n"),
+    trigger: str = typer.Option(..., "--trigger", help="e.g. schedule, github.pr_merged"),
+    action: Optional[str] = typer.Option(None, "--action"),
+    condition: Optional[str] = typer.Option(None, "--condition"),
+    cron: Optional[str] = typer.Option(None, "--cron", help="schedule_cron for schedule triggers"),
+):
+    """Create an automation."""
+    with errors():
+        show(ctx, client(ctx).automations.create(
+            name, trigger, action=action, condition=condition, schedule_cron=cron))
+
+
+@app.command("toggle")
+def toggle(ctx: typer.Context, automation_id: str = typer.Argument(...)):
+    """Enable/disable an automation."""
+    with errors():
+        show(ctx, client(ctx).automations.toggle(automation_id))
+
+
+@app.command("execute")
+def execute(ctx: typer.Context, automation_id: str = typer.Argument(...)):
+    """Run an automation now (writes a real run record)."""
+    with errors():
+        show(ctx, client(ctx).automations.execute(automation_id))
+
+
+@app.command("history")
+def history(ctx: typer.Context, automation_id: str = typer.Argument(...)):
+    """List run records for an automation."""
+    with errors():
+        show(ctx, client(ctx).automations.runs(automation_id),
+             columns=["run_id", "status", "trigger_type", "started_at"])
+
+
+@app.command("run-status")
+def run_status(
+    ctx: typer.Context,
+    automation_id: str = typer.Argument(...),
+    run_id: str = typer.Argument(...),
+):
+    """Show one run's detail."""
+    with errors():
+        show(ctx, client(ctx).automations.run_status(automation_id, run_id))
+
+
+@app.command("export")
+def export(ctx: typer.Context, automation_id: str = typer.Argument(...)):
+    """Export the automation definition as YAML (workflows-as-code)."""
+    with errors():
+        data = client(ctx).automations.export(automation_id)
+        if out(ctx) == "table" and isinstance(data, dict) and data.get("yaml"):
+            typer.echo(data["yaml"])
+        else:
+            show(ctx, data)
+
+
+@app.command("versions")
+def versions(ctx: typer.Context, automation_id: str = typer.Argument(...)):
+    """List the automation's version history."""
+    with errors():
+        show(ctx, client(ctx).automations.versions(automation_id),
+             columns=["version", "note", "created_at"])
+
+
+@app.command("rollback")
+def rollback(
+    ctx: typer.Context,
+    automation_id: str = typer.Argument(...),
+    to: int = typer.Option(..., "--to", help="Version number to roll back to"),
+):
+    """Roll an automation back to a prior version."""
+    with errors():
+        show(ctx, client(ctx).automations.rollback(automation_id, to))
+
+
+@app.command("templates")
+def templates(ctx: typer.Context):
+    """List the dev automation template gallery."""
+    with errors():
+        show(ctx, client(ctx).automations.templates(),
+             columns=["template_id", "name", "trigger_type", "requires"])

lithora_cli/commands/github.py

@@ -0,0 +1,33 @@
+"""`lithora github` — GitHub integration status / repos / connect."""
+
+from __future__ import annotations
+
+from typing import Optional
+
+import typer
+
+from ._common import client, errors, show
+
+app = typer.Typer(no_args_is_help=True, help="GitHub integration.")
+
+
+@app.command("status")
+def status(ctx: typer.Context):
+    """Show GitHub connection status."""
+    with errors():
+        show(ctx, client(ctx).github.status())
+
+
+@app.command("repos")
+def repos(ctx: typer.Context, org: Optional[str] = typer.Option(None, "--org", "-o")):
+    """List accessible repositories."""
+    with errors():
+        show(ctx, client(ctx).github.repos(org=org),
+             columns=["full_name", "private", "default_branch"])
+
+
+@app.command("connect")
+def connect(ctx: typer.Context):
+    """Print the URL to connect GitHub in your browser (OAuth)."""
+    url = client(ctx).github.connect_url()
+    typer.echo("Open this URL to connect GitHub:\n  {}".format(url))

lithora_cli/commands/projects.py

@@ -0,0 +1,68 @@
+"""`lithora projects` — manage projects (repositories)."""
+
+from __future__ import annotations
+
+from typing import Optional
+
+import typer
+
+from ._common import client, errors, show
+
+app = typer.Typer(no_args_is_help=True, help="Manage projects.")
+
+
+@app.command("list")
+def list_projects(ctx: typer.Context):
+    """List projects you can access."""
+    with errors():
+        show(ctx, client(ctx).projects.list(),
+             columns=["project_id", "name", "status", "team_id"])
+
+
+@app.command("show")
+def show_project(ctx: typer.Context, project_id: str = typer.Argument(...)):
+    """Show one project (with task stats)."""
+    with errors():
+        show(ctx, client(ctx).projects.get(project_id))
+
+
+@app.command("create")
+def create_project(
+    ctx: typer.Context,
+    name: str = typer.Option(..., "--name", "-n"),
+    team: str = typer.Option(..., "--team", "-t", help="Owning team id"),
+    description: Optional[str] = typer.Option(None, "--description"),
+    status: Optional[str] = typer.Option(None, "--status", help="active|archived|completed"),
+):
+    """Create a project."""
+    with errors():
+        show(ctx, client(ctx).projects.create(name, team, description=description, status=status))
+
+
+@app.command("update")
+def update_project(
+    ctx: typer.Context,
+    project_id: str = typer.Argument(...),
+    name: Optional[str] = typer.Option(None, "--name"),
+    status: Optional[str] = typer.Option(None, "--status"),
+    description: Optional[str] = typer.Option(None, "--description"),
+):
+    """Update a project's metadata."""
+    updates = {k: v for k, v in {"name": name, "status": status, "description": description}.items() if v is not None}
+    if not updates:
+        raise typer.BadParameter("Pass at least one of --name/--status/--description")
+    with errors():
+        show(ctx, client(ctx).projects.patch(project_id, **updates))
+
+
+@app.command("delete")
+def delete_project(
+    ctx: typer.Context,
+    project_id: str = typer.Argument(...),
+    yes: bool = typer.Option(False, "--yes", "-y", help="Skip confirmation"),
+):
+    """Delete a project."""
+    if not yes and not typer.confirm("Delete project {}?".format(project_id)):
+        raise typer.Exit(0)
+    with errors():
+        show(ctx, client(ctx).projects.delete(project_id))

lithora_cli/commands/search.py

@@ -0,0 +1,30 @@
+"""`lithora search` — permission-scoped global search."""
+
+from __future__ import annotations
+
+from typing import Optional
+
+import typer
+
+from ._common import client, errors, show
+
+app = typer.Typer(no_args_is_help=True, help="Search across your workspace.")
+
+
+@app.command("query")
+def query(
+    ctx: typer.Context,
+    q: str = typer.Argument(..., help="Search query"),
+    limit: Optional[int] = typer.Option(None, "--limit", "-l"),
+):
+    """Search tasks, projects, docs and more."""
+    with errors():
+        show(ctx, client(ctx).search.query(q, limit=limit),
+             columns=["type", "title", "id"])
+
+
+@app.command("recent")
+def recent(ctx: typer.Context):
+    """Your recent searches."""
+    with errors():
+        show(ctx, client(ctx).search.recent())

lithora_cli/commands/tasks.py

@@ -0,0 +1,120 @@
+"""`lithora tasks` — manage issues/tasks."""
+
+from __future__ import annotations
+
+from typing import List, Optional
+
+import typer
+
+from ._common import client, errors, show
+
+app = typer.Typer(no_args_is_help=True, help="Manage issues / tasks.")
+
+_TASK_COLS = ["task_id", "title", "status", "priority", "assigned_to"]
+
+
+@app.command("list")
+def list_tasks(
+    ctx: typer.Context,
+    project: str = typer.Option(..., "--project", "-p", help="Project id"),
+    status: Optional[str] = typer.Option(None, "--status", "-s"),
+):
+    """List tasks in a project (optionally filtered by status)."""
+    with errors():
+        data = client(ctx).tasks.list(project)
+        if status:
+            rows = data.get("tasks", data) if isinstance(data, dict) else data
+            rows = [t for t in (rows or []) if t.get("status") == status]
+            data = {"tasks": rows}
+        show(ctx, data, columns=_TASK_COLS)
+
+
+@app.command("my")
+def my_tasks(ctx: typer.Context, status: Optional[str] = typer.Option(None, "--status", "-s")):
+    """List tasks assigned to you."""
+    with errors():
+        data = client(ctx).tasks.my()
+        if status:
+            rows = data.get("tasks", data) if isinstance(data, dict) else data
+            data = {"tasks": [t for t in (rows or []) if t.get("status") == status]}
+        show(ctx, data, columns=_TASK_COLS + ["project_id"])
+
+
+@app.command("show")
+def show_task(ctx: typer.Context, task_id: str = typer.Argument(...)):
+    """Show one task."""
+    with errors():
+        show(ctx, client(ctx).tasks.get(task_id))
+
+
+@app.command("create")
+def create_task(
+    ctx: typer.Context,
+    title: str = typer.Option(..., "--title", "-t"),
+    project: str = typer.Option(..., "--project", "-p"),
+    description: Optional[str] = typer.Option(None, "--description", "-d"),
+    priority: Optional[str] = typer.Option(None, "--priority", help="low|medium|high|urgent"),
+    assignee: Optional[str] = typer.Option(None, "--assignee", "-a", help="User id"),
+    due: Optional[str] = typer.Option(None, "--due", help="ISO date"),
+    tags: Optional[List[str]] = typer.Option(None, "--tag", help="Repeatable"),
+):
+    """Create a task."""
+    with errors():
+        show(ctx, client(ctx).tasks.create(
+            title, project, description=description, priority=priority,
+            assigned_to=assignee, due_date=due, tags=tags or None,
+        ))
+
+
+@app.command("status")
+def set_status(
+    ctx: typer.Context,
+    task_id: str = typer.Argument(...),
+    status: str = typer.Argument(..., help="todo|in_progress|in_review|done|blocked"),
+):
+    """Change a task's status."""
+    with errors():
+        show(ctx, client(ctx).tasks.set_status(task_id, status))
+
+
+@app.command("update")
+def update_task(
+    ctx: typer.Context,
+    task_id: str = typer.Argument(...),
+    title: Optional[str] = typer.Option(None, "--title"),
+    priority: Optional[str] = typer.Option(None, "--priority"),
+    description: Optional[str] = typer.Option(None, "--description"),
+    due: Optional[str] = typer.Option(None, "--due"),
+):
+    """Update task metadata."""
+    updates = {k: v for k, v in {
+        "title": title, "priority": priority, "description": description, "due_date": due,
+    }.items() if v is not None}
+    if not updates:
+        raise typer.BadParameter("Pass at least one field to update")
+    with errors():
+        show(ctx, client(ctx).tasks.update(task_id, **updates))
+
+
+@app.command("assign")
+def assign_task(
+    ctx: typer.Context,
+    task_id: str = typer.Argument(...),
+    user: str = typer.Option(..., "--user", "-u", help="Assignee user id"),
+):
+    """Assign a task (via task update)."""
+    with errors():
+        show(ctx, client(ctx).tasks.update(task_id, assigned_to=user))
+
+
+@app.command("delete")
+def delete_task(
+    ctx: typer.Context,
+    task_id: str = typer.Argument(...),
+    yes: bool = typer.Option(False, "--yes", "-y"),
+):
+    """Delete a task."""
+    if not yes and not typer.confirm("Delete task {}?".format(task_id)):
+        raise typer.Exit(0)
+    with errors():
+        show(ctx, client(ctx).tasks.delete(task_id))