trelloctl 0.1.0__py3-none-any.whl

trelloctl/__init__.py

@@ -0,0 +1,5 @@
+"""trelloctl - A command-line interface for Trello."""
+
+from importlib.metadata import version
+
+__version__ = version("trelloctl")

trelloctl/cli.py

@@ -0,0 +1,91 @@
+"""Main CLI entry point."""
+
+from __future__ import annotations
+
+import os
+import sys
+
+import click
+
+from trelloctl import __version__
+from trelloctl.client import TrelloClient
+from trelloctl.config import Config
+from trelloctl.output import OutputFormat, print_error
+from trelloctl.resolver import Resolver
+
+
+class Context:
+    """CLI context object holding shared state."""
+
+    def __init__(self) -> None:
+        self.profile = os.environ.get("TRELLOCTL_PROFILE", "default")
+        self.config = Config(self.profile)
+        self.client: TrelloClient | None = None
+        self._resolver: Resolver | None = None
+        self.format = OutputFormat.TABLE
+
+    def ensure_client(self) -> TrelloClient:
+        """Ensure we have an authenticated client."""
+        if self.client is None:
+            api_key = self.config.get_api_key()
+            token = self.config.get_token()
+
+            if not api_key or not token:
+                print_error("Not authenticated. Run 'trelloctl auth login' first.")
+                sys.exit(1)
+
+            self.client = TrelloClient(api_key, token)
+
+        return self.client
+
+    @property
+    def resolver(self) -> Resolver:
+        """Get the name resolver."""
+        if self._resolver is None:
+            self._resolver = Resolver(self.ensure_client())
+        return self._resolver
+
+
+pass_context = click.make_pass_decorator(Context, ensure=True)
+
+
+@click.group()
+@click.version_option(version=__version__, prog_name="trelloctl")
+@click.option(
+    "--format",
+    "-f",
+    type=click.Choice(["table", "json", "csv", "plain"]),
+    default="table",
+    help="Output format",
+)
+@click.option(
+    "--profile",
+    "-p",
+    envvar="TRELLOCTL_PROFILE",
+    default="default",
+    help="Configuration profile to use",
+)
+@pass_context
+def main(ctx: Context, format: str, profile: str) -> None:
+    """trelloctl - Manage your Trello boards from the command line."""
+    ctx.format = OutputFormat(format)
+    ctx.profile = profile
+    ctx.config = Config(profile)
+
+
+def _register_commands() -> None:
+    """Register command groups with the main CLI."""
+    from trelloctl.commands import auth, board, card
+    from trelloctl.commands import list as list_cmd
+
+    main.add_command(auth.auth)
+    main.add_command(board.board)
+    main.add_command(card.card)
+    main.add_command(list_cmd.list_)
+
+
+_register_commands()
+
+
+if __name__ == "__main__":
+    main()

trelloctl/client.py

@@ -0,0 +1,179 @@
+"""Trello API client."""
+
+from typing import Any
+
+import httpx
+
+BASE_URL = "https://api.trello.com/1"
+
+
+class TrelloClient:
+    """HTTP client for Trello API."""
+
+    def __init__(self, api_key: str, token: str) -> None:
+        self.api_key = api_key
+        self.token = token
+        self._client = httpx.Client(timeout=30.0)
+
+    def _auth_params(self) -> dict[str, str]:
+        """Return authentication parameters."""
+        return {"key": self.api_key, "token": self.token}
+
+    def _request(
+        self,
+        method: str,
+        path: str,
+        params: dict | None = None,
+        json: dict | None = None,
+    ) -> Any:
+        """Make an authenticated request to Trello API."""
+        url = f"{BASE_URL}{path}"
+        all_params = self._auth_params()
+        if params:
+            all_params.update(params)
+
+        response = self._client.request(method, url, params=all_params, json=json)
+        response.raise_for_status()
+
+        if response.status_code == 204:
+            return None
+        return response.json()
+
+    def get(self, path: str, params: dict | None = None) -> Any:
+        """Make a GET request."""
+        return self._request("GET", path, params=params)
+
+    def post(
+        self, path: str, params: dict | None = None, json: dict | None = None
+    ) -> Any:
+        """Make a POST request."""
+        return self._request("POST", path, params=params, json=json)
+
+    def put(
+        self, path: str, params: dict | None = None, json: dict | None = None
+    ) -> Any:
+        """Make a PUT request."""
+        return self._request("PUT", path, params=params, json=json)
+
+    def delete(self, path: str, params: dict | None = None) -> Any:
+        """Make a DELETE request."""
+        return self._request("DELETE", path, params=params)
+
+    # Board methods
+    def get_boards(self, filter: str = "open") -> list[dict]:
+        """Get all boards for the authenticated user."""
+        return self.get("/members/me/boards", params={"filter": filter})
+
+    def get_board(self, board_id: str) -> dict:
+        """Get a board by ID."""
+        return self.get(f"/boards/{board_id}")
+
+    def create_board(self, name: str, desc: str = "") -> dict:
+        """Create a new board."""
+        return self.post("/boards", params={"name": name, "desc": desc})
+
+    def close_board(self, board_id: str, closed: bool = True) -> dict:
+        """Close or reopen a board."""
+        return self.put(f"/boards/{board_id}", params={"closed": str(closed).lower()})
+
+    def delete_board(self, board_id: str) -> None:
+        """Delete a board."""
+        self.delete(f"/boards/{board_id}")
+
+    def get_board_lists(self, board_id: str, filter: str = "open") -> list[dict]:
+        """Get all lists on a board."""
+        return self.get(f"/boards/{board_id}/lists", params={"filter": filter})
+
+    def get_board_labels(self, board_id: str) -> list[dict]:
+        """Get all labels on a board."""
+        return self.get(f"/boards/{board_id}/labels")
+
+    def get_board_members(self, board_id: str) -> list[dict]:
+        """Get all members of a board."""
+        return self.get(f"/boards/{board_id}/members")
+
+    # List methods
+    def get_list(self, list_id: str) -> dict:
+        """Get a list by ID."""
+        return self.get(f"/lists/{list_id}")
+
+    def create_list(self, board_id: str, name: str, pos: str = "bottom") -> dict:
+        """Create a new list on a board."""
+        return self.post(
+            "/lists", params={"idBoard": board_id, "name": name, "pos": pos}
+        )
+
+    def archive_list(self, list_id: str, closed: bool = True) -> dict:
+        """Archive or unarchive a list."""
+        return self.put(f"/lists/{list_id}", params={"closed": str(closed).lower()})
+
+    def get_list_cards(self, list_id: str) -> list[dict]:
+        """Get all cards in a list."""
+        return self.get(f"/lists/{list_id}/cards")
+
+    # Card methods
+    def get_card(self, card_id: str) -> dict:
+        """Get a card by ID."""
+        return self.get(f"/cards/{card_id}")
+
+    def create_card(
+        self,
+        list_id: str,
+        name: str,
+        desc: str = "",
+        pos: str = "bottom",
+        due: str | None = None,
+        labels: list[str] | None = None,
+        members: list[str] | None = None,
+    ) -> dict:
+        """Create a new card."""
+        params: dict[str, Any] = {
+            "idList": list_id,
+            "name": name,
+            "desc": desc,
+            "pos": pos,
+        }
+        if due:
+            params["due"] = due
+        if labels:
+            params["idLabels"] = ",".join(labels)
+        if members:
+            params["idMembers"] = ",".join(members)
+        return self.post("/cards", params=params)
+
+    def update_card(self, card_id: str, **kwargs: Any) -> dict:
+        """Update a card."""
+        return self.put(f"/cards/{card_id}", params=kwargs)
+
+    def move_card(self, card_id: str, list_id: str, pos: str = "bottom") -> dict:
+        """Move a card to a different list."""
+        return self.put(f"/cards/{card_id}", params={"idList": list_id, "pos": pos})
+
+    def archive_card(self, card_id: str, closed: bool = True) -> dict:
+        """Archive or unarchive a card."""
+        return self.put(f"/cards/{card_id}", params={"closed": str(closed).lower()})
+
+    def delete_card(self, card_id: str) -> None:
+        """Delete a card."""
+        self.delete(f"/cards/{card_id}")
+
+    def add_card_member(self, card_id: str, member_id: str) -> list[dict]:
+        """Add a member to a card."""
+        return self.post(f"/cards/{card_id}/idMembers", params={"value": member_id})
+
+    def remove_card_member(self, card_id: str, member_id: str) -> list[dict]:
+        """Remove a member from a card."""
+        return self.delete(f"/cards/{card_id}/idMembers/{member_id}")
+
+    def add_card_comment(self, card_id: str, text: str) -> dict:
+        """Add a comment to a card."""
+        return self.post(f"/cards/{card_id}/actions/comments", params={"text": text})
+
+    def get_card_comments(self, card_id: str) -> list[dict]:
+        """Get comments on a card."""
+        return self.get(f"/cards/{card_id}/actions", params={"filter": "commentCard"})
+
+    # Member methods
+    def get_me(self) -> dict:
+        """Get the authenticated user."""
+        return self.get("/members/me")

trelloctl/commands/__init__.py

@@ -0,0 +1 @@
+"""Command modules for Trello CLI."""

trelloctl/commands/auth/__init__.py

@@ -0,0 +1,91 @@
+"""Authentication commands."""
+
+import webbrowser
+
+import click
+
+from trelloctl.cli import Context, pass_context
+from trelloctl.output import print_error, print_info, print_success
+
+
+@click.group()
+def auth() -> None:
+    """Authentication commands."""
+    pass
+
+
+@auth.command("login")
+@click.option("--api-key", prompt=False, help="Trello API key")
+@click.option("--token", prompt=False, help="Trello token")
+@pass_context
+def login(ctx: Context, api_key: str | None, token: str | None) -> None:
+    """Set up authentication with Trello.
+
+    You can get your API key at: https://trello.com/app-key
+    """
+    if not api_key:
+        print_info("Get your API key at: https://trello.com/app-key")
+        if click.confirm("Open browser to get API key?", default=True):
+            webbrowser.open("https://trello.com/app-key")
+        api_key = click.prompt("Enter your API key")
+
+    ctx.config.set_api_key(api_key)
+    print_success("API key saved")
+
+    if not token:
+        token_url = (
+            f"https://trello.com/1/authorize?"
+            f"expiration=never&scope=read,write,account&"
+            f"response_type=token&name=trelloctl&key={api_key}"
+        )
+        print_info(f"Generate a token at: {token_url}")
+        if click.confirm("Open browser to generate token?", default=True):
+            webbrowser.open(token_url)
+        token = click.prompt("Enter your token")
+
+    ctx.config.set_token(token)
+    print_success("Token saved")
+
+    # Verify credentials
+    try:
+        client = ctx.ensure_client()
+        me = client.get_me()
+        print_success(f"Authenticated as: {me['fullName']} (@{me['username']})")
+    except Exception as e:
+        print_error(f"Authentication failed: {e}")
+
+
+@auth.command("status")
+@pass_context
+def status(ctx: Context) -> None:
+    """Check authentication status."""
+    if not ctx.config.is_configured():
+        print_error("Not authenticated. Run 'trelloctl auth login' first.")
+        return
+
+    try:
+        client = ctx.ensure_client()
+        me = client.get_me()
+        print_success(f"Authenticated as: {me['fullName']} (@{me['username']})")
+    except Exception as e:
+        print_error(f"Authentication error: {e}")
+
+
+@auth.command("logout")
+@pass_context
+def logout(ctx: Context) -> None:
+    """Remove stored credentials."""
+    import keyring
+    from trelloctl.config import SERVICE_NAME
+
+    try:
+        keyring.delete_password(SERVICE_NAME, f"{ctx.profile}:api_key")
+    except keyring.errors.PasswordDeleteError:
+        pass
+
+    try:
+        keyring.delete_password(SERVICE_NAME, f"{ctx.profile}:token")
+    except keyring.errors.PasswordDeleteError:
+        pass
+
+    print_success("Credentials removed")

trelloctl/commands/board/__init__.py

@@ -0,0 +1,209 @@
+"""Board commands."""
+
+import click
+
+from trelloctl.cli import Context, pass_context
+from trelloctl.output import format_output, print_error, print_success
+
+
+@click.group()
+def board() -> None:
+    """Board management commands."""
+    pass
+
+
+@board.command("list")
+@click.option(
+    "--filter",
+    "-f",
+    type=click.Choice(
+        ["all", "closed", "members", "open", "organization", "public", "starred"]
+    ),
+    default="open",
+    help="Filter boards",
+)
+@pass_context
+def list_boards(ctx: Context, filter: str) -> None:
+    """List all accessible boards."""
+    client = ctx.ensure_client()
+    boards = client.get_boards(filter=filter)
+
+    data = [
+        {
+            "id": b["id"],
+            "name": b["name"],
+            "url": b["url"],
+            "closed": "Yes" if b.get("closed") else "No",
+        }
+        for b in boards
+    ]
+
+    format_output(
+        data,
+        ctx.format,
+        columns=[("name", "Name"), ("id", "ID"), ("closed", "Closed")],
+        title="Boards",
+        template="{name} ({id})",
+    )
+
+
+@board.command("show")
+@click.argument("board")
+@pass_context
+def show_board(ctx: Context, board: str) -> None:
+    """Show details of a board.
+
+    BOARD can be an ID or name (partial match supported).
+    """
+    client = ctx.ensure_client()
+
+    try:
+        board_id = ctx.resolver.resolve_board(board)
+        board_data = client.get_board(board_id)
+    except Exception as e:
+        print_error(str(e))
+        return
+
+    data = {
+        "id": board_data["id"],
+        "name": board_data["name"],
+        "description": board_data.get("desc", ""),
+        "url": board_data["url"],
+        "closed": "Yes" if board_data.get("closed") else "No",
+    }
+
+    format_output(
+        data,
+        ctx.format,
+        columns=[
+            ("name", "Name"),
+            ("id", "ID"),
+            ("description", "Description"),
+            ("url", "URL"),
+            ("closed", "Closed"),
+        ],
+    )
+
+
+@board.command("create")
+@click.option("--name", "-n", required=True, help="Board name")
+@click.option("--description", "-d", default="", help="Board description")
+@pass_context
+def create_board(ctx: Context, name: str, description: str) -> None:
+    """Create a new board."""
+    client = ctx.ensure_client()
+
+    try:
+        board_data = client.create_board(name, description)
+        print_success(f"Created board: {board_data['name']} ({board_data['id']})")
+    except Exception as e:
+        print_error(f"Failed to create board: {e}")
+
+
+@board.command("close")
+@click.argument("board")
+@click.option("--reopen", is_flag=True, help="Reopen instead of close")
+@pass_context
+def close_board(ctx: Context, board: str, reopen: bool) -> None:
+    """Close (archive) a board.
+
+    BOARD can be an ID or name (partial match supported).
+    """
+    client = ctx.ensure_client()
+
+    try:
+        board_id = ctx.resolver.resolve_board(board)
+        client.close_board(board_id, closed=not reopen)
+        action = "Reopened" if reopen else "Closed"
+        print_success(f"{action} board: {board}")
+    except Exception as e:
+        print_error(str(e))
+
+
+@board.command("delete")
+@click.argument("board")
+@click.confirmation_option(prompt="Are you sure you want to delete this board?")
+@pass_context
+def delete_board(ctx: Context, board: str) -> None:
+    """Delete a board (permanently).
+
+    BOARD can be an ID or name (partial match supported).
+    """
+    client = ctx.ensure_client()
+
+    try:
+        board_id = ctx.resolver.resolve_board(board)
+        client.delete_board(board_id)
+        print_success(f"Deleted board: {board}")
+    except Exception as e:
+        print_error(str(e))
+
+
+@board.command("labels")
+@click.argument("board")
+@pass_context
+def board_labels(ctx: Context, board: str) -> None:
+    """List labels on a board.
+
+    BOARD can be an ID or name (partial match supported).
+    """
+    client = ctx.ensure_client()
+
+    try:
+        board_id = ctx.resolver.resolve_board(board)
+        labels = client.get_board_labels(board_id)
+    except Exception as e:
+        print_error(str(e))
+        return
+
+    data = [
+        {
+            "id": label["id"],
+            "name": label.get("name", ""),
+            "color": label.get("color", ""),
+        }
+        for label in labels
+    ]
+
+    format_output(
+        data,
+        ctx.format,
+        columns=[("name", "Name"), ("color", "Color"), ("id", "ID")],
+        title="Labels",
+        template="{name} ({color})",
+    )
+
+
+@board.command("members")
+@click.argument("board")
+@pass_context
+def board_members(ctx: Context, board: str) -> None:
+    """List members of a board.
+
+    BOARD can be an ID or name (partial match supported).
+    """
+    client = ctx.ensure_client()
+
+    try:
+        board_id = ctx.resolver.resolve_board(board)
+        members = client.get_board_members(board_id)
+    except Exception as e:
+        print_error(str(e))
+        return
+
+    data = [
+        {
+            "id": m["id"],
+            "username": m.get("username", ""),
+            "fullName": m.get("fullName", ""),
+        }
+        for m in members
+    ]
+
+    format_output(
+        data,
+        ctx.format,
+        columns=[("fullName", "Name"), ("username", "Username"), ("id", "ID")],
+        title="Members",
+        template="{fullName} (@{username})",
+    )