moltcli 0.1.0__py3-none-any.whl

moltcli/__init__.py

@@ -0,0 +1,3 @@
+"""MoltCLI - CLI tool for Moltbook social network."""
+
+__version__ = "0.1.0"

moltcli/cli.py

@@ -0,0 +1,376 @@
+"""MoltCLI - CLI tool for Moltbook social network."""
+import sys
+import click
+from .utils import get_config, MoltbookClient, OutputFormatter, handle_error
+from .core import (
+    PostCore,
+    CommentCore,
+    FeedCore,
+    SearchCore,
+    VoteCore,
+    SubmoltsCore,
+    AuthCore,
+)
+
+
+def get_client() -> MoltbookClient:
+    """Create API client from config."""
+    config = get_config()
+    return MoltbookClient(config.api_key)
+
+
+def make_formatter(json_mode: bool) -> OutputFormatter:
+    """Create output formatter."""
+    return OutputFormatter(json_mode=json_mode)
+
+
+# Global options
+@click.group()
+@click.option("--json", "json_mode", is_flag=True, help="Output as JSON")
+@click.pass_context
+def cli(ctx: click.Context, json_mode: bool):
+    """MoltCLI - CLI tool for Moltbook social network."""
+    ctx.ensure_object(dict)
+    ctx.obj["json_mode"] = json_mode
+    ctx.obj["formatter"] = make_formatter(json_mode)
+    ctx.obj["client"] = get_client()
+
+
+# auth command group
+@cli.group()
+def auth():
+    """Authentication management."""
+    pass
+
+
+@auth.command("whoami")
+@click.pass_context
+def auth_whoami(ctx: click.Context):
+    """Show current user info."""
+    client: MoltbookClient = ctx.obj["client"]
+    formatter: OutputFormatter = ctx.obj["formatter"]
+    try:
+        result = AuthCore(client).whoami()
+        formatter.print(result)
+    except Exception as e:
+        if ctx.obj["json_mode"]:
+            formatter.print(handle_error(e))
+            sys.exit(1)
+        raise
+
+
+@auth.command("verify")
+@click.pass_context
+def auth_verify(ctx: click.Context):
+    """Verify API key is valid."""
+    client: MoltbookClient = ctx.obj["client"]
+    formatter: OutputFormatter = ctx.obj["formatter"]
+    try:
+        result = AuthCore(client).verify()
+        formatter.print({"status": "valid", "message": "API key is valid"})
+    except Exception as e:
+        if ctx.obj["json_mode"]:
+            formatter.print(handle_error(e))
+            sys.exit(1)
+        raise
+
+
+# post command group
+@cli.group()
+def post():
+    """Post operations."""
+    pass
+
+
+@post.command("create")
+@click.option("--submolt", required=True, help="Submolt name")
+@click.option("--title", required=True, help="Post title")
+@click.option("--content", help="Post content")
+@click.option("--url", help="Post URL")
+@click.pass_context
+def post_create(ctx: click.Context, submolt: str, title: str, content: str, url: str):
+    """Create a new post."""
+    client: MoltbookClient = ctx.obj["client"]
+    formatter: OutputFormatter = ctx.obj["formatter"]
+    try:
+        result = PostCore(client).create(submolt=submolt, title=title, content=content, url=url)
+        formatter.print(result)
+    except Exception as e:
+        if ctx.obj["json_mode"]:
+            formatter.print(handle_error(e))
+            sys.exit(1)
+        raise
+
+
+@post.command("get")
+@click.argument("post_id")
+@click.pass_context
+def post_get(ctx: click.Context, post_id: str):
+    """Get a post by ID."""
+    client: MoltbookClient = ctx.obj["client"]
+    formatter: OutputFormatter = ctx.obj["formatter"]
+    try:
+        result = PostCore(client).get(post_id)
+        formatter.print(result)
+    except Exception as e:
+        if ctx.obj["json_mode"]:
+            formatter.print(handle_error(e))
+            sys.exit(1)
+        raise
+
+
+@post.command("delete")
+@click.argument("post_id")
+@click.pass_context
+def post_delete(ctx: click.Context, post_id: str):
+    """Delete a post."""
+    client: MoltbookClient = ctx.obj["client"]
+    formatter: OutputFormatter = ctx.obj["formatter"]
+    try:
+        result = PostCore(client).delete(post_id)
+        formatter.print({"status": "deleted", "id": post_id})
+    except Exception as e:
+        if ctx.obj["json_mode"]:
+            formatter.print(handle_error(e))
+            sys.exit(1)
+        raise
+
+
+# comment command group
+@cli.group()
+def comment():
+    """Comment operations."""
+    pass
+
+
+@comment.command("create")
+@click.argument("post_id")
+@click.option("--content", required=True, help="Comment content")
+@click.option("--parent", help="Parent comment ID for replies")
+@click.pass_context
+def comment_create(ctx: click.Context, post_id: str, content: str, parent: str):
+    """Create a comment on a post."""
+    client: MoltbookClient = ctx.obj["client"]
+    formatter: OutputFormatter = ctx.obj["formatter"]
+    try:
+        result = CommentCore(client).create(post_id=post_id, content=content, parent_id=parent)
+        formatter.print(result)
+    except Exception as e:
+        if ctx.obj["json_mode"]:
+            formatter.print(handle_error(e))
+            sys.exit(1)
+        raise
+
+
+@comment.command("list")
+@click.argument("post_id")
+@click.option("--limit", default=50, help="Max comments to show")
+@click.pass_context
+def comment_list(ctx: click.Context, post_id: str, limit: int):
+    """List comments for a post."""
+    client: MoltbookClient = ctx.obj["client"]
+    formatter: OutputFormatter = ctx.obj["formatter"]
+    try:
+        result = CommentCore(client).list_by_post(post_id, limit=limit)
+        formatter.print(result)
+    except Exception as e:
+        if ctx.obj["json_mode"]:
+            formatter.print(handle_error(e))
+            sys.exit(1)
+        raise
+
+
+# feed command group
+@cli.group()
+def feed():
+    """Feed operations."""
+    pass
+
+
+@feed.command()
+@click.option("--sort", type=click.Choice(["hot", "new"]), default="hot", help="Sort order")
+@click.option("--limit", default=20, help="Max posts to show")
+@click.option("--submolt", help="Filter by submolt")
+@click.pass_context
+def feed_get(ctx: click.Context, sort: str, limit: int, submolt: str):
+    """Get feed posts."""
+    client: MoltbookClient = ctx.obj["client"]
+    formatter: OutputFormatter = ctx.obj["formatter"]
+    try:
+        result = FeedCore(client).get(sort=sort, limit=limit, submolt=submolt)
+        formatter.print(result)
+    except Exception as e:
+        if ctx.obj["json_mode"]:
+            formatter.print(handle_error(e))
+            sys.exit(1)
+        raise
+
+
+@feed.command("hot")
+@click.option("--limit", default=20, help="Max posts to show")
+@click.pass_context
+def feed_hot(ctx: click.Context, limit: int):
+    """Get hot posts."""
+    client: MoltbookClient = ctx.obj["client"]
+    formatter: OutputFormatter = ctx.obj["formatter"]
+    try:
+        result = FeedCore(client).get_hot(limit=limit)
+        formatter.print(result)
+    except Exception as e:
+        if ctx.obj["json_mode"]:
+            formatter.print(handle_error(e))
+            sys.exit(1)
+        raise
+
+
+@feed.command("new")
+@click.option("--limit", default=20, help="Max posts to show")
+@click.pass_context
+def feed_new(ctx: click.Context, limit: int):
+    """Get newest posts."""
+    client: MoltbookClient = ctx.obj["client"]
+    formatter: OutputFormatter = ctx.obj["formatter"]
+    try:
+        result = FeedCore(client).get_new(limit=limit)
+        formatter.print(result)
+    except Exception as e:
+        if ctx.obj["json_mode"]:
+            formatter.print(handle_error(e))
+            sys.exit(1)
+        raise
+
+
+# search command group
+@cli.group()
+def search():
+    """Search operations."""
+    pass
+
+
+@search.command()
+@click.argument("query")
+@click.option("--type", type=click.Choice(["posts", "users"]), default="posts", help="Search type")
+@click.option("--limit", default=20, help="Max results")
+@click.pass_context
+def search_query(ctx: click.Context, query: str, type_: str, limit: int):
+    """Search posts or users."""
+    client: MoltbookClient = ctx.obj["client"]
+    formatter: OutputFormatter = ctx.obj["formatter"]
+    try:
+        result = SearchCore(client).search(query=query, type_=type_, limit=limit)
+        formatter.print(result)
+    except Exception as e:
+        if ctx.obj["json_mode"]:
+            formatter.print(handle_error(e))
+            sys.exit(1)
+        raise
+
+
+# vote command group
+@cli.group()
+def vote():
+    """Vote operations."""
+    pass
+
+
+@vote.command("up")
+@click.argument("item_id")
+@click.option("--type", type=click.Choice(["post", "comment"]), default="post", help="Item type")
+@click.pass_context
+def vote_up(ctx: click.Context, item_id: str, type_: str):
+    """Upvote a post or comment."""
+    client: MoltbookClient = ctx.obj["client"]
+    formatter: OutputFormatter = ctx.obj["formatter"]
+    try:
+        result = VoteCore(client).upvote(item_id, type_=type_)
+        formatter.print({"status": "upvoted", "id": item_id})
+    except Exception as e:
+        if ctx.obj["json_mode"]:
+            formatter.print(handle_error(e))
+            sys.exit(1)
+        raise
+
+
+@vote.command("down")
+@click.argument("item_id")
+@click.option("--type", type=click.Choice(["post", "comment"]), default="post", help="Item type")
+@click.pass_context
+def vote_down(ctx: click.Context, item_id: str, type_: str):
+    """Downvote a post or comment."""
+    client: MoltbookClient = ctx.obj["client"]
+    formatter: OutputFormatter = ctx.obj["formatter"]
+    try:
+        result = VoteCore(client).downvote(item_id, type_=type_)
+        formatter.print({"status": "downvoted", "id": item_id})
+    except Exception as e:
+        if ctx.obj["json_mode"]:
+            formatter.print(handle_error(e))
+            sys.exit(1)
+        raise
+
+
+# submolts command group
+@cli.group()
+def submolts():
+    """Submolt operations."""
+    pass
+
+
+@submolts.command("list")
+@click.option("--limit", default=50, help="Max submolts to show")
+@click.pass_context
+def submolts_list(ctx: click.Context, limit: int):
+    """List all submolts."""
+    client: MoltbookClient = ctx.obj["client"]
+    formatter: OutputFormatter = ctx.obj["formatter"]
+    try:
+        result = SubmoltsCore(client).list(limit=limit)
+        formatter.print(result)
+    except Exception as e:
+        if ctx.obj["json_mode"]:
+            formatter.print(handle_error(e))
+            sys.exit(1)
+        raise
+
+
+@submolts.command("subscribe")
+@click.argument("name")
+@click.pass_context
+def submolts_subscribe(ctx: click.Context, name: str):
+    """Subscribe to a submolt."""
+    client: MoltbookClient = ctx.obj["client"]
+    formatter: OutputFormatter = ctx.obj["formatter"]
+    try:
+        result = SubmoltsCore(client).subscribe(name)
+        formatter.print({"status": "subscribed", "name": name})
+    except Exception as e:
+        if ctx.obj["json_mode"]:
+            formatter.print(handle_error(e))
+            sys.exit(1)
+        raise
+
+
+@submolts.command("unsubscribe")
+@click.argument("name")
+@click.pass_context
+def submolts_unsubscribe(ctx: click.Context, name: str):
+    """Unsubscribe from a submolt."""
+    client: MoltbookClient = ctx.obj["client"]
+    formatter: OutputFormatter = ctx.obj["formatter"]
+    try:
+        result = SubmoltsCore(client).unsubscribe(name)
+        formatter.print({"status": "unsubscribed", "name": name})
+    except Exception as e:
+        if ctx.obj["json_mode"]:
+            formatter.print(handle_error(e))
+            sys.exit(1)
+        raise
+
+
+def main():
+    """Entry point."""
+    cli()
+
+
+if __name__ == "__main__":
+    main()

moltcli/core/__init__.py

@@ -0,0 +1,19 @@
+"""MoltCLI core business logic."""
+
+from .post import PostCore
+from .comment import CommentCore
+from .feed import FeedCore
+from .search import SearchCore
+from .vote import VoteCore
+from .submolts import SubmoltsCore
+from .auth import AuthCore
+
+__all__ = [
+    "PostCore",
+    "CommentCore",
+    "FeedCore",
+    "SearchCore",
+    "VoteCore",
+    "SubmoltsCore",
+    "AuthCore",
+]

moltcli/core/auth.py

@@ -0,0 +1,21 @@
+"""Auth core logic."""
+from ..utils.api_client import MoltbookClient
+
+
+class AuthCore:
+    """Handle authentication operations."""
+
+    def __init__(self, client: MoltbookClient):
+        self._client = client
+
+    def whoami(self) -> dict:
+        """Get current user info."""
+        return self._client.get("/auth/whoami")
+
+    def verify(self) -> dict:
+        """Verify API key is valid."""
+        return self._client.get("/auth/verify")
+
+    def refresh(self) -> dict:
+        """Refresh authentication token."""
+        return self._client.post("/auth/refresh")

moltcli/core/comment.py

@@ -0,0 +1,36 @@
+"""Comment core logic."""
+from typing import Optional
+from ..utils.api_client import MoltbookClient
+
+
+class CommentCore:
+    """Handle comment operations."""
+
+    def __init__(self, client: MoltbookClient):
+        self._client = client
+
+    def create(
+        self,
+        post_id: str,
+        content: str,
+        parent_id: Optional[str] = None,
+    ) -> dict:
+        """Create a comment on a post."""
+        data = {"post_id": post_id, "content": content}
+        if parent_id:
+            data["parent_id"] = parent_id
+        return self._client.post("/comments", json_data=data)
+
+    def get(self, comment_id: str) -> dict:
+        """Get a comment by ID."""
+        return self._client.get(f"/comments/{comment_id}")
+
+    def delete(self, comment_id: str) -> dict:
+        """Delete a comment."""
+        return self._client.delete(f"/comments/{comment_id}")
+
+    def list_by_post(self, post_id: str, limit: int = 50) -> dict:
+        """List comments for a post."""
+        return self._client.get(
+            f"/posts/{post_id}/comments", params={"limit": limit}
+        )

moltcli/core/feed.py

@@ -0,0 +1,30 @@
+"""Feed core logic."""
+from typing import Optional
+from ..utils.api_client import MoltbookClient
+
+
+class FeedCore:
+    """Handle feed operations."""
+
+    def __init__(self, client: MoltbookClient):
+        self._client = client
+
+    def get(
+        self,
+        sort: str = "hot",
+        limit: int = 20,
+        submolt: Optional[str] = None,
+    ) -> dict:
+        """Get feed posts."""
+        params = {"sort": sort, "limit": limit}
+        if submolt:
+            params["submolt"] = submolt
+        return self._client.get("/feed", params=params)
+
+    def get_hot(self, limit: int = 20) -> dict:
+        """Get hot posts."""
+        return self.get(sort="hot", limit=limit)
+
+    def get_new(self, limit: int = 20) -> dict:
+        """Get newest posts."""
+        return self.get(sort="new", limit=limit)

moltcli/core/post.py

@@ -0,0 +1,41 @@
+"""Post core logic."""
+from typing import Optional
+from ..utils.api_client import MoltbookClient
+
+
+class PostCore:
+    """Handle post operations."""
+
+    def __init__(self, client: MoltbookClient):
+        self._client = client
+
+    def create(
+        self,
+        submolt: str,
+        title: str,
+        content: Optional[str] = None,
+        url: Optional[str] = None,
+    ) -> dict:
+        """Create a new post."""
+        data = {"submolt": submolt, "title": title}
+        if content:
+            data["content"] = content
+        if url:
+            data["url"] = url
+        return self._client.post("/posts", json_data=data)
+
+    def get(self, post_id: str) -> dict:
+        """Get a post by ID."""
+        return self._client.get(f"/posts/{post_id}")
+
+    def delete(self, post_id: str) -> dict:
+        """Delete a post."""
+        return self._client.delete(f"/posts/{post_id}")
+
+    def list_by_submolt(
+        self, submolt: str, limit: int = 20, offset: int = 0
+    ) -> dict:
+        """List posts in a submolt."""
+        return self._client.get(
+            f"/submolts/{submolt}/posts", params={"limit": limit, "offset": offset}
+        )

moltcli/core/search.py

@@ -0,0 +1,29 @@
+"""Search core logic."""
+from typing import Optional
+from ..utils.api_client import MoltbookClient
+
+
+class SearchCore:
+    """Handle search operations."""
+
+    def __init__(self, client: MoltbookClient):
+        self._client = client
+
+    def search(
+        self,
+        query: str,
+        type_: str = "posts",
+        limit: int = 20,
+    ) -> dict:
+        """Search posts and users."""
+        return self._client.get(
+            "/search", params={"q": query, "type": type_, "limit": limit}
+        )
+
+    def search_posts(self, query: str, limit: int = 20) -> dict:
+        """Search posts only."""
+        return self.search(query, type_="posts", limit=limit)
+
+    def search_users(self, query: str, limit: int = 20) -> dict:
+        """Search users only."""
+        return self.search(query, type_="users", limit=limit)

moltcli/core/submolts.py

@@ -0,0 +1,34 @@
+"""Submolts core logic."""
+from typing import Optional
+from ..utils.api_client import MoltbookClient
+
+
+class SubmoltsCore:
+    """Handle submolt operations."""
+
+    def __init__(self, client: MoltbookClient):
+        self._client = client
+
+    def list(self, limit: int = 50) -> dict:
+        """List all submolts."""
+        return self._client.get("/submolts", params={"limit": limit})
+
+    def get(self, name: str) -> dict:
+        """Get a submolt by name."""
+        return self._client.get(f"/submolts/{name}")
+
+    def subscribe(self, name: str) -> dict:
+        """Subscribe to a submolt."""
+        return self._client.post("/submolts/subscribe", json_data={"name": name})
+
+    def unsubscribe(self, name: str) -> dict:
+        """Unsubscribe from a submolt."""
+        return self._client.post("/submolts/unsubscribe", json_data={"name": name})
+
+    def get_subscribed(self) -> dict:
+        """Get user's subscribed submolts."""
+        return self._client.get("/user/subscriptions")
+
+    def trending(self, limit: int = 10) -> dict:
+        """Get trending submolts."""
+        return self._client.get("/submolts/trending", params={"limit": limit})

moltcli/core/vote.py

@@ -0,0 +1,30 @@
+"""Vote core logic."""
+from ..utils.api_client import MoltbookClient
+
+
+class VoteCore:
+    """Handle vote operations."""
+
+    UP = "up"
+    DOWN = "down"
+
+    def __init__(self, client: MoltbookClient):
+        self._client = client
+
+    def upvote(self, item_id: str, type_: str = "post") -> dict:
+        """Upvote a post or comment."""
+        return self._vote(item_id, self.UP, type_)
+
+    def downvote(self, item_id: str, type_: str = "post") -> dict:
+        """Downvote a post or comment."""
+        return self._vote(item_id, self.DOWN, type_)
+
+    def _vote(self, item_id: str, direction: str, type_: str) -> dict:
+        """Internal vote method."""
+        return self._client.post(
+            "/votes", json_data={"item_id": item_id, "type": type_, "direction": direction}
+        )
+
+    def remove_vote(self, item_id: str, type_: str = "post") -> dict:
+        """Remove a vote."""
+        return self._client.delete(f"/votes/{item_id}?type={type_}")

moltcli/utils/__init__.py

@@ -0,0 +1,25 @@
+"""MoltCLI utils package."""
+from .config import Config, get_config
+from .api_client import MoltbookClient
+from .formatter import OutputFormatter
+from .errors import (
+    MoltCLIError,
+    AuthError,
+    NotFoundError,
+    RateLimitError,
+    handle_error,
+    parse_rate_limit_from_response,
+)
+
+__all__ = [
+    "Config",
+    "get_config",
+    "MoltbookClient",
+    "OutputFormatter",
+    "MoltCLIError",
+    "AuthError",
+    "NotFoundError",
+    "RateLimitError",
+    "handle_error",
+    "parse_rate_limit_from_response",
+]

moltcli/utils/api_client.py

@@ -0,0 +1,87 @@
+"""Moltbook API client."""
+import requests
+from typing import Any, Optional
+
+from .errors import RateLimitError, AuthError, NotFoundError, parse_rate_limit_from_response
+
+
+class MoltbookClient:
+    """HTTP client for Moltbook API."""
+
+    BASE_URL = "https://www.moltbook.com/api/v1"
+
+    def __init__(self, api_key: str):
+        self.api_key = api_key
+        self.headers = {
+            "Authorization": f"Bearer {api_key}",
+            "Content-Type": "application/json",
+        }
+
+    def _request(
+        self,
+        method: str,
+        endpoint: str,
+        *,
+        params: Optional[dict] = None,
+        json_data: Optional[dict] = None,
+    ) -> dict:
+        """Make HTTP request and handle errors."""
+        url = f"{self.BASE_URL}{endpoint}"
+        response = requests.request(
+            method=method,
+            url=url,
+            params=params,
+            json=json_data,
+            headers=self.headers,
+            timeout=30,
+        )
+
+        if not response.ok:
+            self._handle_error_response(response)
+
+        return response.json()
+
+    def _handle_error_response(self, response):
+        """Handle API error response with specific error types."""
+        status = response.status_code
+
+        # Rate limit (429)
+        if status == 429:
+            retry_after, limit, remaining = parse_rate_limit_from_response(response)
+            raise RateLimitError(
+                retry_after=retry_after,
+                limit=limit,
+                remaining=remaining,
+            )
+
+        # Authentication errors (401, 403)
+        if status in (401, 403):
+            raise AuthError(f"Authentication failed: {response.text}")
+
+        # Not found (404)
+        if status == 404:
+            # Try to determine resource type from URL
+            url = response.request.url
+            if "/posts/" in url:
+                raise NotFoundError("post")
+            elif "/submolts/" in url:
+                raise NotFoundError("submolt")
+            else:
+                raise NotFoundError("resource")
+
+        # Other errors
+        raise Exception(f"API error: {status} {response.text}")
+
+    def get(self, endpoint: str, params: Optional[dict] = None) -> dict:
+        """GET request."""
+        return self._request("GET", endpoint, params=params)
+
+    def post(
+        self, endpoint: str, json_data: Optional[dict] = None
+    ) -> dict:
+        """POST request."""
+        return self._request("POST", endpoint, json_data=json_data)
+
+    def delete(self, endpoint: str) -> dict:
+        """DELETE request."""
+        return self._request("DELETE", endpoint)

moltcli/utils/config.py

@@ -0,0 +1,57 @@
+"""Config loader for MoltCLI."""
+import json
+import os
+from pathlib import Path
+from typing import Optional
+
+
+class Config:
+    """Config loader for credentials and settings."""
+
+    def __init__(self, config_path: Optional[str] = None):
+        if config_path is None:
+            config_path = os.environ.get(
+                "MOLTCLI_CONFIG_PATH",
+                str(Path(__file__).parent.parent.parent / "credentials.json")
+            )
+        self.config_path = Path(config_path)
+        self._config: Optional[dict] = None
+
+    @property
+    def config(self) -> dict:
+        """Load and cache config."""
+        if self._config is None:
+            if not self.config_path.exists():
+                raise FileNotFoundError(f"Config not found: {self.config_path}")
+            with open(self.config_path) as f:
+                self._config = json.load(f)
+        return self._config
+
+    @property
+    def api_key(self) -> str:
+        """Get API key from config."""
+        key = self.config.get("api_key")
+        if not key:
+            raise ValueError("api_key not found in config")
+        return key
+
+    @property
+    def agent_name(self) -> str:
+        """Get agent name from config."""
+        return self.config.get("agent_name", "unknown")
+
+    def get(self, key: str, default=None):
+        """Get config value by key."""
+        return self.config.get(key, default)
+
+
+# Global config instance
+_config: Optional[Config] = None
+
+
+def get_config() -> Config:
+    """Get global config instance."""
+    global _config
+    if _config is None:
+        _config = Config()
+    return _config

moltcli/utils/errors.py

@@ -0,0 +1,145 @@
+"""Error codes and error handler for MoltCLI."""
+from typing import Optional
+
+
+# Error codes
+AUTH_INVALID = "AUTH_INVALID"
+AUTH_MISSING = "AUTH_MISSING"
+POST_NOT_FOUND = "POST_NOT_FOUND"
+SUBMOLT_NOT_FOUND = "SUBMOLT_NOT_FOUND"
+RATE_LIMIT = "RATE_LIMIT"
+NETWORK_ERROR = "NETWORK_ERROR"
+
+
+class MoltCLIError(Exception):
+    """Base error for MoltCLI."""
+
+    def __init__(self, message: str, code: str, suggestion: Optional[str] = None):
+        self.message = message
+        self.code = code
+        self.suggestion = suggestion
+        super().__init__(message)
+
+    def to_dict(self) -> dict:
+        """Convert to error response dict."""
+        return {
+            "status": "error",
+            "error_code": self.code,
+            "message": self.message,
+            "suggestion": self.suggestion,
+        }
+
+
+class AuthError(MoltCLIError):
+    """Authentication error."""
+
+    def __init__(self, message: str):
+        super().__init__(message, AUTH_INVALID, "Check your API key in credentials.json")
+
+
+class NotFoundError(MoltCLIError):
+    """Resource not found error."""
+
+    def __init__(self, resource: str):
+        super().__init__(
+            f"{resource} not found",
+            POST_NOT_FOUND if resource == "post" else SUBMOLT_NOT_FOUND,
+            f"Verify the {resource} exists and you have permission",
+        )
+
+
+class RateLimitError(MoltCLIError):
+    """Rate limit exceeded."""
+
+    def __init__(
+        self,
+        retry_after: Optional[int] = None,
+        limit: Optional[int] = None,
+        remaining: Optional[int] = None,
+    ):
+        """Initialize rate limit error.
+
+        Args:
+            retry_after: Seconds until retry is allowed
+            limit: Rate limit maximum requests
+            remaining: Remaining requests in window
+        """
+        self.retry_after = retry_after
+        self.limit = limit
+        self.remaining = remaining
+
+        # Build message
+        if retry_after:
+            message = f"Rate limit exceeded. Retry after {retry_after} seconds."
+        else:
+            message = "Rate limit exceeded. Please slow down."
+
+        # Build suggestion
+        if retry_after:
+            suggestion = f"Wait {retry_after} seconds before retrying."
+        else:
+            suggestion = "Wait a moment before retrying. Use --delay to space requests."
+
+        super().__init__(message, RATE_LIMIT, suggestion)
+
+
+def handle_error(error: Exception) -> dict:
+    """Convert exception to error response."""
+    if isinstance(error, MoltCLIError):
+        return error.to_dict()
+    return {
+        "status": "error",
+        "error_code": "UNKNOWN",
+        "message": str(error),
+    }
+
+
+def parse_rate_limit_from_response(response) -> tuple:
+    """Parse rate limit info from API response.
+
+    Args:
+        response: requests.Response object
+
+    Returns:
+        Tuple of (retry_after, limit, remaining)
+    """
+    # Try common rate limit headers
+    retry_after = None
+    limit = None
+    remaining = None
+
+    # Retry-After header (seconds)
+    if "Retry-After" in response.headers:
+        try:
+            retry_after = int(response.headers["Retry-After"])
+        except ValueError:
+            pass
+
+    # X-RateLimit headers (common pattern)
+    if "X-RateLimit-Limit" in response.headers:
+        try:
+            limit = int(response.headers["X-RateLimit-Limit"])
+        except ValueError:
+            pass
+
+    if "X-RateLimit-Remaining" in response.headers:
+        try:
+            remaining = int(response.headers["X-RateLimit-Remaining"])
+        except ValueError:
+            pass
+
+    # Also check response body for rate limit info
+    try:
+        body = response.json()
+        if isinstance(body, dict):
+            if "retry_after" in body:
+                retry_after = body["retry_after"]
+            if "rate_limit" in body:
+                rl = body["rate_limit"]
+                if isinstance(rl, dict):
+                    limit = rl.get("limit", limit)
+                    remaining = rl.get("remaining", remaining)
+    except Exception:
+        pass
+
+    return retry_after, limit, remaining

moltcli/utils/formatter.py

@@ -0,0 +1,40 @@
+"""Output formatter for MoltCLI."""
+import json
+from typing import Any
+
+
+class OutputFormatter:
+    """Handle JSON vs human-readable output."""
+
+    def __init__(self, json_mode: bool = False):
+        self.json_mode = json_mode
+
+    def format(self, data: Any) -> str:
+        """Format data for output."""
+        if self.json_mode:
+            return json.dumps(data, ensure_ascii=False, indent=2)
+        return self._humanize(data)
+
+    def _humanize(self, data: Any, indent: int = 0) -> str:
+        """Convert to human-readable format."""
+        if isinstance(data, dict):
+            lines = []
+            for k, v in data.items():
+                if isinstance(v, (dict, list)):
+                    lines.append(f"{k}:")
+                    lines.append(self._humanize(v, indent + 2))
+                else:
+                    lines.append(f"{k}: {v}")
+            return "\n".join(lines)
+        elif isinstance(data, list):
+            if not data:
+                return "(empty)"
+            lines = []
+            for i, item in enumerate(data, 1):
+                lines.append(f"  {i}. {self._humanize(item, indent + 1)}")
+            return "\n".join(lines)
+        return str(data)
+
+    def print(self, data: Any) -> None:
+        """Print formatted output."""
+        print(self.format(data))

moltcli-0.1.0.dist-info/METADATA

@@ -0,0 +1,116 @@
+Metadata-Version: 2.4
+Name: moltcli
+Version: 0.1.0
+Summary: CLI tool for Moltbook social network, AI Agent friendly
+Author: MoltCLI Team
+License: MIT
+Keywords: cli,moltbook,social,ai,agent
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: click>=8.0
+Requires-Dist: requests>=2.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0; extra == "dev"
+Requires-Dist: ruff>=0.1.0; extra == "dev"
+Dynamic: license-file
+
+# MoltCLI
+
+CLI tool for Moltbook social network, designed for AI Agents.
+
+## Install
+
+```bash
+pip install -e .
+```
+
+## Quick Start
+
+```bash
+# JSON output mode (recommended for AI agents)
+moltcli --json feed --sort hot
+
+# Human readable output
+moltcli feed --sort hot --limit 20
+
+# Create a post
+moltcli post create --submolt ai --title "Hello World" --content "My first post"
+
+# Search
+moltcli search "AI agents"
+
+# Upvote
+moltcli vote up POST_ID
+```
+
+## Commands
+
+| Command | Description |
+|---------|-------------|
+| `moltcli auth` | Authentication management |
+| `moltcli post` | Create/get/delete posts |
+| `moltcli comment` | Comment on posts |
+| `moltcli feed` | Get timeline/feed |
+| `moltcli search` | Semantic search |
+| `moltcli vote` | Upvote/downvote |
+| `moltcli submolts` | Submolt management |
+
+## Options
+
+| Option | Description |
+|--------|-------------|
+| `--json` | Output as JSON (recommended for AI) |
+| `--verbose` | Enable verbose logging |
+| `--quiet` | Suppress non-essential output |
+
+## Authentication
+
+API key should be configured in `credentials.json`:
+
+```json
+{
+  "api_key": "moltbook_sk_..."
+}
+```
+
+## Development
+
+```bash
+# Install with dev dependencies
+pip install -e ".[dev]"
+
+# Run tests
+pytest tests/ -v
+
+# Lint
+ruff check moltcli/
+```
+
+## Architecture
+
+```
+moltcli/
+├── cli.py              # Click CLI entry point
+├── core/               # Business logic
+│   ├── auth.py
+│   ├── post.py
+│   ├── comment.py
+│   ├── feed.py
+│   ├── search.py
+│   ├── vote.py
+│   └── submolts.py
+└── utils/              # Shared utilities
+    ├── config.py
+    ├── api_client.py
+    ├── formatter.py
+    └── errors.py
+```

moltcli-0.1.0.dist-info/RECORD

@@ -0,0 +1,21 @@
+moltcli/__init__.py,sha256=e7p2Cat3JV5cvVi0A3XGjA8fhwg9p00mWktYc-RJcsM,77
+moltcli/cli.py,sha256=3S7QNzYxGJAaIs7dfYYIP73v75D6NukW7rTG_PUjnkE,11006
+moltcli/core/__init__.py,sha256=Ow___Urg5hRu2AY0W9YNZihc8ILHmWLzE59BE-yR_lM,379
+moltcli/core/auth.py,sha256=ZFpfQeE-Jyt75tHqb_eYJgwlUgb_sQzXO-rVNg5Q3qE,570
+moltcli/core/comment.py,sha256=4zG-Zus3skOjBQklOg6D1wknFZyIyoywm1XgfzEXEIw,1090
+moltcli/core/feed.py,sha256=GfXMP8ciLrh1_noNgeDntT0XjUQANMvbZ4xeLBjzK50,813
+moltcli/core/post.py,sha256=bKIGn6NGDHyQoXekV1JCSIAsFGdGdXHmdpgDIjgY3Ho,1163
+moltcli/core/search.py,sha256=_MkbaXXbAAEUL4pj_-E5P-AoAljSSuu59-o-PeYvWQs,832
+moltcli/core/submolts.py,sha256=Fgq-AZQI03seWJGjTwN08OJM-n9_lQkY2oi6hG7N5Wg,1161
+moltcli/core/vote.py,sha256=P5rbGnY-oeTf3nDBoKHDpkBA-jg8pm-X9re4JbYbEOk,966
+moltcli/utils/__init__.py,sha256=-bfVKSN8rxaSrTkb3oYG6wmD_GYoR7xn-IMo6v2WxeA,526
+moltcli/utils/api_client.py,sha256=Q5EZzvHwYE8Fr-G2_Yk3LrmKiAaCTP2eIhFT3blDwh8,2617
+moltcli/utils/config.py,sha256=TctyM814QmSLDawQMPM2bNbac_3cto0Ewiao8Qt8w4U,1607
+moltcli/utils/errors.py,sha256=8JmQ1SbP00DGl3XwGa0_zgqypiiVzHHkaw5r61CwV5U,4100
+moltcli/utils/formatter.py,sha256=kLYCPJw1IsanGYKXA8XGEm8mDAnC_AlIYQwN5bFypCc,1313
+moltcli-0.1.0.dist-info/licenses/LICENSE,sha256=EOduU9kNb_dRzzPmt7gJsVSxqTCYJeYl5C2POxT0rj8,1069
+moltcli-0.1.0.dist-info/METADATA,sha256=wUIt8SHrXhA_sOVhsBRXHRgGVd0znEf-IhmyAYJdIEo,2585
+moltcli-0.1.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+moltcli-0.1.0.dist-info/entry_points.txt,sha256=Cn6XRCOpVqQHJYqbjOCJ9LfePx6VYR_Gdn6MsoMtLq4,45
+moltcli-0.1.0.dist-info/top_level.txt,sha256=3BuZXxTPE63yrySE7ET5eCy32LneFysqMiG-pfEQifw,8
+moltcli-0.1.0.dist-info/RECORD,,

moltcli-0.1.0.dist-info/WHEEL

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

moltcli-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+moltcli = moltcli.cli:main

moltcli-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 MoltCLI Team
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

moltcli-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+moltcli