hoja-cli 0.21.4__py3-none-any.whl

hoja/commands/auth_cmd.py

@@ -0,0 +1,271 @@
+"""`hoja me` and `hoja auth ...` commands."""
+
+from __future__ import annotations
+
+import asyncio
+import json as _json
+from typing import Any, Optional
+
+import typer
+
+from hoja.auth import get_viewer
+from hoja.cli_state import build_client, get_state
+from hoja.client import LinearClient
+from hoja.config import (
+    AccountConfig,
+    load_config,
+    resolve_workspace,
+    save_config,
+)
+from hoja.errors import AuthError, UsageError
+from hoja.models.enums import OutputFormat
+from hoja.output import render
+
+me_app = typer.Typer(help="Show the currently-authenticated Linear user")
+auth_app = typer.Typer(help="Authentication operations")
+
+
+@me_app.callback(invoke_without_command=True)
+def me(ctx: typer.Context) -> None:
+    """Show the currently-authenticated user (alias for `auth status`)."""
+    if ctx.invoked_subcommand is not None:
+        return
+    asyncio.run(_run_me())
+
+
+@auth_app.command("status")
+def status() -> None:
+    """Show the currently-authenticated user and token source."""
+    asyncio.run(_run_me())
+
+
+@auth_app.command("whoami")
+def whoami() -> None:
+    """Alias of `auth status`."""
+    asyncio.run(_run_me())
+
+
+async def _run_me() -> None:
+    state = get_state()
+    async with build_client(state) as client:
+        viewer = await get_viewer(client)
+        render(viewer, fmt=state.output, title="Viewer")
+
+
+@auth_app.command("accounts")
+def accounts_list() -> None:
+    """List all configured accounts with default/workspace/current markers."""
+    state = get_state()
+    config = state.config
+    workspace = resolve_workspace()
+    workspace_account = (
+        config.workspaces.get(str(workspace)) if workspace else None
+    )
+
+    account_rows: list[dict[str, Any]] = []
+    for name, acc in config.accounts.items():
+        markers: list[str] = []
+        if name == config.defaults.default_account:
+            markers.append("default")
+        if name == workspace_account:
+            markers.append("workspace")
+        if name == state.account_name:
+            markers.append("current")
+        account_rows.append(
+            {
+                "name": name,
+                "org_name": acc.org_name or "(unknown)",
+                "token_source": "config" if acc.token else f"${acc.token_env}",
+                "teams": acc.teams,
+                "markers": markers,
+            }
+        )
+
+    if state.output == OutputFormat.JSON:
+        print(_json.dumps(account_rows, indent=2))
+        return
+
+    # Human output
+    if not account_rows:
+        typer.echo("No accounts configured.")
+        typer.echo("Run: hoja auth add <name> --token <token>")
+        return
+
+    typer.echo("Configured accounts:")
+    for row in account_rows:
+        marker_str = ""
+        if row["markers"]:
+            marker_str = " [" + ", ".join(row["markers"]) + "]"
+        typer.echo(f"  • {row['name']}{marker_str}")
+        if row["org_name"] != "(unknown)":
+            typer.echo(f"    org: {row['org_name']}")
+        typer.echo(f"    token: {row['token_source']}")
+        if row["teams"]:
+            typer.echo(f"    teams: {', '.join(row['teams'])}")
+    if workspace:
+        typer.echo(f"\nWorkspace: {workspace}")
+    else:
+        typer.echo("\nWorkspace: (none — not in a git repo)")
+
+
+@auth_app.command("add")
+def account_add(
+    name: str = typer.Argument(..., help="Account name"),
+    token: str = typer.Option(..., "--token", help="Hoja API token"),
+    token_env: str = typer.Option(
+        "HOJA_TOKEN", "--token-env", help="Environment variable name"
+    ),
+    verify: bool = typer.Option(
+        True, "--verify/--no-verify", help="Verify token by calling the API"
+    ),
+    default: bool = typer.Option(
+        False, "--default", help="Set as global default account"
+    ),
+    teams: Optional[str] = typer.Option(
+        None,
+        "--teams",
+        help="Comma-separated team keys this account owns (e.g. 'SWA,ENG'). "
+        "Enables automatic account selection when a command targets one of "
+        "these teams.",
+    ),
+) -> None:
+    """Add a new named account."""
+    config = load_config()
+    if name in config.accounts:
+        raise UsageError(
+            f"Account '{name}' already exists",
+            hint="Use 'hoja auth remove {name}' first, or pick a different name.",
+        )
+
+    org_name: str | None = None
+    if verify:
+        try:
+            org_name = asyncio.run(_fetch_org_name(token))
+        except Exception as e:
+            typer.echo(f"Warning: could not verify token ({e})", err=True)
+
+    team_keys = (
+        [t.strip().upper() for t in teams.split(",") if t.strip()] if teams else []
+    )
+    was_empty = len(config.accounts) == 0
+    config.accounts[name] = AccountConfig(
+        # The shared default env vars are never persisted; only a distinct
+        # per-account variable stores the token inline.
+        token=token if token_env in ("HOJA_TOKEN", "LINEAR_TOKEN") else None,
+        token_env=token_env,
+        org_name=org_name,
+        teams=team_keys,
+    )
+    if default or was_empty:
+        config.defaults.default_account = name
+    save_config(config)
+    typer.echo(f"Added account '{name}'" + (f" ({org_name})" if org_name else ""))
+
+
+async def _fetch_org_name(token: str) -> str | None:
+    """Make a quick API call to get the organization name."""
+    from hoja.graphql import queries
+    from hoja.models.user import User
+
+    client = LinearClient(token=token, timeout=10.0)
+    async with client:
+        viewer = await client.execute_as(User, queries.VIEWER, path=["viewer"], operation="Viewer")
+        # viewer.organization may not exist on the User model; handle gracefully
+        return getattr(viewer, "organization_name", None) or getattr(
+            viewer, "organization", None
+        )
+
+
+@auth_app.command("switch")
+def account_switch(
+    name: str = typer.Argument(..., help="Account name to set as default"),
+) -> None:
+    """Set the global default account."""
+    config = load_config()
+    if name not in config.accounts:
+        raise AuthError(
+            f"Account '{name}' not found",
+            hint="Run 'hoja auth accounts' to see available accounts.",
+        )
+    config.defaults.default_account = name
+    save_config(config)
+    typer.echo(f"Default account set to '{name}'")
+
+
+@auth_app.command("teams")
+def account_teams(
+    name: str = typer.Argument(..., help="Account name to edit"),
+    teams: str = typer.Argument(
+        ...,
+        help="Comma-separated team keys this account owns (e.g. 'SWA,ENG'). "
+        "Pass an empty string to clear.",
+    ),
+) -> None:
+    """Set the team keys an account owns (for automatic account selection)."""
+    config = load_config()
+    if name not in config.accounts:
+        raise AuthError(
+            f"Account '{name}' not found",
+            hint="Run 'hoja auth accounts' to see available accounts.",
+        )
+    team_keys = [t.strip().upper() for t in teams.split(",") if t.strip()]
+    config.accounts[name].teams = team_keys
+    save_config(config)
+    if team_keys:
+        typer.echo(f"Account '{name}' now owns teams: {', '.join(team_keys)}")
+    else:
+        typer.echo(f"Cleared team ownership for account '{name}'")
+
+
+@auth_app.command("remove")
+def account_remove(
+    name: str = typer.Argument(..., help="Account name to remove"),
+) -> None:
+    """Remove a named account."""
+    config = load_config()
+    if name not in config.accounts:
+        raise AuthError(
+            f"Account '{name}' not found",
+            hint="Run 'hoja auth accounts' to see available accounts.",
+        )
+    del config.accounts[name]
+    # Clean up workspace mappings pointing to this account
+    config.workspaces = {
+        k: v for k, v in config.workspaces.items() if v != name
+    }
+    if config.defaults.default_account == name:
+        config.defaults.default_account = next(iter(config.accounts), None)
+    save_config(config)
+    typer.echo(f"Removed account '{name}'")
+
+
+@auth_app.command("workspace")
+def auth_workspace() -> None:
+    """Show current workspace detection and mapped account."""
+    state = get_state()
+    config = state.config
+    workspace = resolve_workspace()
+
+    result: dict[str, Any] = {
+        "workspace": str(workspace) if workspace else None,
+        "mapped_account": None,
+        "default_account": config.defaults.default_account,
+    }
+    if workspace:
+        mapped = config.workspaces.get(str(workspace))
+        result["mapped_account"] = mapped
+
+    if state.output == OutputFormat.JSON:
+        print(_json.dumps(result, indent=2))
+        return
+
+    if workspace:
+        typer.echo(f"Workspace: {workspace}")
+        if mapped := result["mapped_account"]:
+            typer.echo(f"Mapped account: {mapped}")
+        else:
+            typer.echo("No workspace mapping configured.")
+            typer.echo(f"Default account: {config.defaults.default_account or '(none)'}")
+    else:
+        typer.echo("Not inside a git repository.")
+        typer.echo(f"Default account: {config.defaults.default_account or '(none)'}")

hoja/commands/comment.py

@@ -0,0 +1,149 @@
+"""`hoja comment ...` commands."""
+
+from __future__ import annotations
+
+import asyncio
+import sys
+from typing import Optional
+
+import typer
+
+from hoja.cli_state import build_client, get_state
+from hoja.errors import UsageError
+from hoja.graphql import mutations, queries
+from hoja.models.issue import Comment, Issue
+from hoja.output import render
+
+comment_app = typer.Typer(help="Comments")
+
+
+@comment_app.command("list")
+def list_comments(
+    issue_id: str = typer.Argument(..., help="Issue identifier (ENG-34) or UUID"),
+    limit: int = typer.Option(50, "--limit", "-n"),
+) -> None:
+    """List comments on an issue."""
+    asyncio.run(_run_list(issue_id, limit))
+
+
+@comment_app.command("add")
+def add_comment(
+    issue_id: str = typer.Argument(..., help="Issue identifier or UUID"),
+    body: Optional[str] = typer.Argument(None, help="Comment body. If omitted, reads stdin."),
+) -> None:
+    """Add a comment to an issue. Reads stdin if body argument is omitted."""
+    text = body if body is not None else sys.stdin.read()
+    if not text.strip():
+        raise UsageError("Empty comment body — provide an argument or pipe content")
+    asyncio.run(_run_add(issue_id, text))
+
+
+@comment_app.command("edit")
+def edit_comment(
+    comment_id: str = typer.Argument(..., help="Comment UUID"),
+    body: Optional[str] = typer.Argument(None, help="New body. If omitted, reads stdin."),
+) -> None:
+    """Edit an existing comment."""
+    text = body if body is not None else sys.stdin.read()
+    if not text.strip():
+        raise UsageError("Empty body")
+    asyncio.run(_run_edit(comment_id, text))
+
+
+@comment_app.command("delete")
+def delete_comment(
+    comment_id: str = typer.Argument(..., help="Comment UUID"),
+) -> None:
+    """Delete a comment."""
+    asyncio.run(_run_delete(comment_id))
+
+
+# ---------- runners ----------
+
+async def _resolve_issue_uuid(client, ref: str) -> str:
+    """Resolve identifier like ENG-34 to a UUID; pass through if already UUID."""
+    if len(ref) == 36 and ref.count("-") == 4:
+        return ref
+    issue = await client.execute_as(
+        Issue, queries.ISSUE_BY_IDENTIFIER, {"id": ref},
+        path=["issue"], operation="IssueByIdentifier",
+    )
+    return issue.id
+
+
+async def _run_list(issue_ref: str, limit: int) -> None:
+    state = get_state()
+    async with build_client(state) as client:
+        data = await client.execute(
+            queries.ISSUE_COMMENTS,
+            {"issueId": issue_ref, "first": limit},
+            operation="IssueComments",
+        )
+        issue_data = data.get("issue") or {}
+        nodes = (issue_data.get("comments") or {}).get("nodes") or []
+        comments = [Comment.model_validate(n) for n in nodes]
+        render(
+            comments,
+            fmt=state.output,
+            title=f"Comments on {issue_data.get('identifier', issue_ref)}",
+        )
+
+
+async def _run_add(issue_ref: str, body: str) -> None:
+    state = get_state()
+    async with build_client(state) as client:
+        issue_uuid = await _resolve_issue_uuid(client, issue_ref)
+        input_ = {"issueId": issue_uuid, "body": body.strip()}
+        if state.dry_run:
+            from hoja.output import emit_error
+            emit_error("dry-run: not executing", hint=str({"input": input_}))
+            return
+        data = await client.execute(
+            mutations.COMMENT_CREATE, {"input": input_}, operation="CommentCreate"
+        )
+        payload = data.get("commentCreate", {})
+        if not payload.get("success"):
+            raise UsageError("commentCreate returned success=false")
+        c = Comment.model_validate(payload["comment"])
+        render(c, fmt=state.output, title="Comment added")
+
+
+async def _run_edit(comment_id: str, body: str) -> None:
+    state = get_state()
+    async with build_client(state) as client:
+        input_ = {"body": body.strip()}
+        if state.dry_run:
+            from hoja.output import emit_error
+            emit_error("dry-run: not executing", hint=str({"id": comment_id, "input": input_}))
+            return
+        data = await client.execute(
+            mutations.COMMENT_UPDATE,
+            {"id": comment_id, "input": input_},
+            operation="CommentUpdate",
+        )
+        payload = data.get("commentUpdate", {})
+        if not payload.get("success"):
+            raise UsageError("commentUpdate returned success=false")
+        c = Comment.model_validate(payload["comment"])
+        render(c, fmt=state.output, title="Comment updated")
+
+
+async def _run_delete(comment_id: str) -> None:
+    state = get_state()
+    async with build_client(state) as client:
+        if state.dry_run:
+            from hoja.output import emit_error
+            emit_error("dry-run: not executing", hint=f"delete comment {comment_id}")
+            return
+        data = await client.execute(
+            mutations.COMMENT_DELETE, {"id": comment_id}, operation="CommentDelete"
+        )
+        ok = data.get("commentDelete", {}).get("success")
+        if not ok:
+            raise UsageError("commentDelete returned success=false")
+        from hoja.models.enums import OutputFormat
+        if state.output == OutputFormat.JSON:
+            import json as _json
+            print(_json.dumps({"deleted": comment_id, "success": True}))
+        else:
+            print(f"Deleted comment {comment_id}")

hoja/commands/cycle.py

@@ -0,0 +1,75 @@
+"""`hoja cycle ...` commands."""
+
+from __future__ import annotations
+
+import asyncio
+
+import typer
+
+from hoja.cli_state import build_client, get_state
+from hoja.errors import NotFoundError
+from hoja.graphql import queries
+from hoja.models.cycle import Cycle
+from hoja.models.team import Team
+from hoja.output import render
+
+cycle_app = typer.Typer(help="Cycles (sprints)")
+
+
+@cycle_app.command("current")
+def current_cycle(team: str = typer.Argument(..., help="Team key (e.g. ENG)")) -> None:
+    """Show the currently-active cycle for a team."""
+    asyncio.run(_run_current(team))
+
+
+@cycle_app.command("list")
+def list_cycles(team: str = typer.Argument(..., help="Team key (e.g. ENG)")) -> None:
+    """List cycles for a team."""
+    asyncio.run(_run_list(team))
+
+
+async def _resolve_team_id(client, key: str) -> str:
+    if len(key) == 36 and key.count("-") == 4:
+        return key
+    teams = await client.execute_list(
+        Team, queries.TEAM_BY_KEY, {"key": key.upper()},
+        path=["teams"], operation="TeamByKey",
+    )
+    if not teams:
+        raise NotFoundError(f"No team with key {key!r}")
+    return teams[0].id
+
+
+async def _run_current(team: str) -> None:
+    state = get_state()
+    async with build_client(state) as client:
+        team_id = await _resolve_team_id(client, team)
+        data = await client.execute(
+            queries.TEAM_CYCLES, {"teamId": team_id}, operation="TeamCycles"
+        )
+        active = data.get("team", {}).get("activeCycle")
+        if not active:
+            # Graceful empty result — exit 0, but signal absence cleanly
+            from hoja.models.enums import OutputFormat
+            from hoja.output import emit_error
+            if state.output == OutputFormat.JSON:
+                import json as _json
+                print(_json.dumps({"active_cycle": None, "team": team}, indent=2))
+            elif state.output == OutputFormat.IDS:
+                pass  # empty stdout — no IDs to print
+            else:
+                emit_error(f"No active cycle on team {team!r}",
+                           hint="Run `hoja cycle list <team>` to see all cycles")
+            return
+        render(Cycle.model_validate(active), fmt=state.output, title="Active Cycle")
+
+
+async def _run_list(team: str) -> None:
+    state = get_state()
+    async with build_client(state) as client:
+        team_id = await _resolve_team_id(client, team)
+        cycles = await client.execute_list(
+            Cycle, queries.TEAM_CYCLES, {"teamId": team_id},
+            path=["team", "cycles"], operation="TeamCycles",
+        )
+        render(cycles, fmt=state.output, title=f"Cycles ({team})")

hoja/commands/init.py

@@ -0,0 +1,108 @@
+"""`hoja init` — scaffold the config file at the standard location."""
+
+from __future__ import annotations
+
+import os
+
+import typer
+
+from hoja.config import config_path
+
+init_app = typer.Typer(help="Initialize hoja configuration")
+
+
+CONFIG_TEMPLATE = """\
+# hoja configuration file
+# Location: __CONFIG_PATH__
+#
+# Token resolution order (per account):
+#   1. --token CLI flag
+#   2. $<ACCOUNT_TOKEN_ENV> environment variable (default: HOJA_TOKEN;
+#      the deprecated LINEAR_TOKEN is read as a fallback)
+#   3. [accounts.<name>].token below (discouraged: plaintext in dotfiles)
+#
+# Account resolution order:
+#   1. --account CLI flag
+#   2. Workspace-mapped account (git repo → account)
+#   3. Global default account
+
+[accounts.default]
+# Environment variable to read the token from. Default: HOJA_TOKEN
+# (LINEAR_TOKEN is still honoured as a deprecated fallback).
+token_env = "HOJA_TOKEN"
+# Uncomment to store the token here directly (not recommended):
+# token = "lin_api_..."
+# Team keys this account owns — enables automatic account selection when a
+# command targets one of these teams (e.g. `hoja issue get SWA-20`).
+# teams = ["SWA", "ENG"]
+
+[defaults]
+# Default team key — used when commands accept --team but you omit it.
+# team = "ENG"
+output = "human"
+# editor = "$EDITOR"
+# Global default account when not in a mapped workspace
+default_account = "default"
+
+[display]
+color = true
+table_max_width = 120
+truncate_descriptions = 80
+
+# Per-workspace account mappings (absolute repo path → account name).
+# Detected automatically when you run `hoja auth workspace`.
+# [workspaces]
+# "/home/user/work/acme" = "work"
+# "/home/user/oss/project" = "personal"
+
+# Named filter aliases. Use with: hoja issue list --view <name>
+# (Not yet wired up in v0.2 — reserved.)
+[views]
+# my-open-bugs = { assignee = "me", label = "Bug", "state.type" = "!completed" }
+# team-blockers = { team = "ENG", priority = 1, "state.type" = "started" }
+"""
+
+
+@init_app.callback(invoke_without_command=True)
+def init(
+    ctx: typer.Context,
+    force: bool = typer.Option(False, "--force", "-f", help="Overwrite existing config"),
+    path: str | None = typer.Option(
+        None, "--path", help="Write to this path instead of the default"
+    ),
+) -> None:
+    """Create a starter config file at the standard location."""
+    if ctx.invoked_subcommand is not None:
+        return
+    target = config_path() if path is None else _to_path(path)
+    target.parent.mkdir(parents=True, exist_ok=True)
+    if target.exists() and not force:
+        typer.echo(
+            f"Config already exists at {target}. Use --force to overwrite.",
+            err=True,
+        )
+        raise typer.Exit(2)
+    target.write_text(
+        CONFIG_TEMPLATE.replace("__CONFIG_PATH__", str(target)),
+        encoding="utf-8",
+    )
+    try:
+        os.chmod(target, 0o600)
+    except OSError:
+        pass
+    typer.echo(f"Created {target}")
+    typer.echo("")
+    typer.echo("Next steps:")
+    typer.echo(f"  1. export HOJA_TOKEN=\"lin_api_...\"  # or edit {target}")
+    typer.echo("  2. hoja me  # verify it works")
+    typer.echo("")
+    typer.echo("Multi-account setup:")
+    typer.echo("  hoja auth add work --token $HOJA_WORK_TOKEN")
+    typer.echo("  hoja auth add personal --token $HOJA_PERSONAL_TOKEN")
+    typer.echo("  hoja auth switch work")
+
+
+def _to_path(p: str):
+    from pathlib import Path
+
+    return Path(p).expanduser().resolve()