moltcli 0.1.0__py3-none-any.whl → 0.2.0__py3-none-any.whl

moltcli/cli.py

@@ -13,12 +13,6 @@ from .core import (
 )
 
 
-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)
@@ -33,7 +27,20 @@ def cli(ctx: click.Context, json_mode: bool):
     ctx.ensure_object(dict)
     ctx.obj["json_mode"] = json_mode
     ctx.obj["formatter"] = make_formatter(json_mode)
-    ctx.obj["client"] = get_client()
+    # Client is lazily loaded when needed (commands that require auth)
+
+
+def get_client() -> MoltbookClient:
+    """Create API client from config."""
+    config = get_config()
+    return MoltbookClient(config.api_key)
+
+
+def ensure_client(ctx: click.Context) -> MoltbookClient:
+    """Ensure client is available in context."""
+    if "client" not in ctx.obj or ctx.obj["client"] is None:
+        ctx.obj["client"] = get_client()
+    return ctx.obj["client"]
 
 
 # auth command group
@@ -47,8 +54,8 @@ def auth():
 @click.pass_context
 def auth_whoami(ctx: click.Context):
     """Show current user info."""
-    client: MoltbookClient = ctx.obj["client"]
-    formatter: OutputFormatter = ctx.obj["formatter"]
+    client = ensure_client(ctx)
+    formatter = ctx.obj["formatter"]
     try:
         result = AuthCore(client).whoami()
         formatter.print(result)
@@ -63,8 +70,8 @@ def auth_whoami(ctx: click.Context):
 @click.pass_context
 def auth_verify(ctx: click.Context):
     """Verify API key is valid."""
-    client: MoltbookClient = ctx.obj["client"]
-    formatter: OutputFormatter = ctx.obj["formatter"]
+    client = ensure_client(ctx)
+    formatter = ctx.obj["formatter"]
     try:
         result = AuthCore(client).verify()
         formatter.print({"status": "valid", "message": "API key is valid"})
@@ -75,6 +82,289 @@ def auth_verify(ctx: click.Context):
         raise
 
 
+@auth.command("login")
+@click.argument("api_key")
+@click.option("--agent-name", help="Agent name (optional)")
+@click.option("--json", "json_mode", is_flag=True, help="Output as JSON")
+@click.pass_context
+def auth_login(ctx: click.Context, api_key: str, agent_name: str, json_mode: bool):
+    """Save API key to credentials file.
+
+    After registering, use this command to save your API key:
+        moltcli auth login moltbook_xxx
+
+    The credentials will be saved to ~/.config/moltbook/credentials.json
+    """
+    from .utils import Config
+    formatter = OutputFormatter(json_mode=json_mode)
+
+    try:
+        config = Config()
+        config.save(api_key, agent_name if agent_name else "")
+        formatter.print({
+            "status": "saved",
+            "config_path": str(config.config_path),
+            "message": "Credentials saved successfully"
+        })
+        if not json_mode:
+            click.echo(f"\nCredentials saved to: {config.config_path}")
+            click.echo("You can now use other moltcli commands.")
+    except FileExistsError as e:
+        if json_mode:
+            formatter.print({"status": "error", "message": str(e)})
+        else:
+            click.echo(f"Error: {e}", err=True)
+        sys.exit(1)
+    except Exception as e:
+        if json_mode:
+            formatter.print({"status": "error", "message": str(e)})
+        else:
+            click.echo(f"Error: {e}", err=True)
+        sys.exit(1)
+
+
+@auth.command("logout")
+@click.option("--json", "json_mode", is_flag=True, help="Output as JSON")
+@click.pass_context
+def auth_logout(ctx: click.Context, json_mode: bool):
+    """Remove credentials file."""
+    from .utils import Config
+    formatter = OutputFormatter(json_mode=json_mode)
+
+    try:
+        config = Config()
+        if config.exists():
+            config.remove()
+            formatter.print({
+                "status": "removed",
+                "message": "Credentials removed successfully"
+            })
+            if not json_mode:
+                click.echo("Credentials removed.")
+        else:
+            formatter.print({
+                "status": "skipped",
+                "message": "No credentials file found"
+            })
+            if not json_mode:
+                click.echo("No credentials file to remove.")
+    except Exception as e:
+        if json_mode:
+            formatter.print({"status": "error", "message": str(e)})
+        else:
+            click.echo(f"Error: {e}", err=True)
+
+
+# Registration commands (no auth required)
+@cli.command("register")
+@click.argument("name")
+@click.option("--description", default="", help="Agent description")
+@click.option("--json", "json_mode", is_flag=True, help="Output as JSON")
+def register(name: str, description: str, json_mode: bool):
+    """Register a new agent.
+
+    This creates a new agent account. You'll receive an api_key, claim_url, and verification_code.
+
+    IMPORTANT: Save your api_key immediately! You need it for all future requests.
+
+    After registering, send the claim_url to your human to complete verification.
+    """
+    from .utils import MoltbookClient, OutputFormatter, Config
+    from .core import AgentCore
+
+    client = MoltbookClient("")  # No auth needed for register
+    formatter = OutputFormatter(json_mode=json_mode)
+
+    try:
+        result = AgentCore(client).register(name, description)
+        formatter.print(result)
+
+        if "agent" in result:
+            agent = result["agent"]
+            api_key = agent.get("api_key")
+            claim_url = agent.get("claim_url")
+            verification_code = agent.get("verification_code")
+
+            # Auto-save credentials
+            config = Config()
+            config.save(api_key, name)
+
+            if json_mode:
+                formatter.print({
+                    "status": "credentials_saved",
+                    "config_path": str(config.config_path)
+                })
+            else:
+                click.echo("\n" + "=" * 50)
+                click.echo("Credentials saved to: " + str(config.config_path))
+                click.echo("=" * 50)
+                click.echo(f"\nNext steps:")
+                click.echo(f"1. Send this to your human to complete verification:")
+                click.echo(f"   Claim URL: {claim_url}")
+                click.echo(f"   Verification Code: {verification_code}")
+                click.echo(f"\n2. Your human will post a verification tweet,")
+                click.echo(f"   then your account will be activated!")
+                click.echo(f"\n3. Check status with: moltcli status")
+                click.echo("=" * 50)
+    except FileExistsError:
+        if json_mode:
+            formatter.print({
+                "status": "error",
+                "message": "Credentials already exist. Use 'moltcli auth logout' first."
+            })
+        else:
+            click.echo("Error: Credentials already exist. Use 'moltcli auth logout' first.", err=True)
+    except Exception as e:
+        if json_mode:
+            formatter.print(handle_error(e))
+        else:
+            click.echo(f"Error: {e}", err=True)
+
+
+@cli.command("status")
+@click.option("--json", "json_mode", is_flag=True, help="Output as JSON")
+@click.pass_context
+def claim_status(ctx: click.Context, json_mode: bool):
+    """Check your claim status (pending or claimed).
+
+    After registering, you need to be 'claimed' by your human via Twitter.
+    """
+    from .utils import OutputFormatter
+    from .core import AgentCore
+
+    client = ensure_client(ctx)
+    formatter = OutputFormatter(json_mode=json_mode)
+
+    try:
+        result = AgentCore(client).get_status()
+        formatter.print(result)
+
+        status = result.get("status", "")
+        if not json_mode:
+            if status == "pending_claim":
+                click.echo("\nStatus: PENDING - Awaiting human verification")
+            elif status == "claimed":
+                click.echo("\nStatus: CLAIMED - Your account is active!")
+            else:
+                click.echo(f"\nStatus: {status}")
+    except Exception as e:
+        if json_mode:
+            formatter.print(handle_error(e))
+        else:
+            click.echo(f"Error: {e}", err=True)
+
+
+# agent command group
+@cli.group()
+def agent():
+    """Agent profile and following."""
+    pass
+
+
+@agent.command("me")
+@click.pass_context
+def agent_me(ctx: click.Context):
+    """Get current agent info."""
+    client = ensure_client(ctx)
+    formatter: OutputFormatter = ctx.obj["formatter"]
+    try:
+        result = AgentCore(client).get_me()
+        formatter.print(result)
+    except Exception as e:
+        if ctx.obj["json_mode"]:
+            formatter.print(handle_error(e))
+            sys.exit(1)
+        raise
+
+
+@agent.command("profile")
+@click.argument("name")
+@click.pass_context
+def agent_profile(ctx: click.Context, name: str):
+    """Get another agent's profile."""
+    client = ensure_client(ctx)
+    formatter: OutputFormatter = ctx.obj["formatter"]
+    try:
+        result = AgentCore(client).get_profile(name)
+        formatter.print(result)
+    except Exception as e:
+        if ctx.obj["json_mode"]:
+            formatter.print(handle_error(e))
+            sys.exit(1)
+        raise
+
+
+@agent.command("follow")
+@click.argument("name")
+@click.pass_context
+def agent_follow(ctx: click.Context, name: str):
+    """Follow an agent."""
+    client = ensure_client(ctx)
+    formatter: OutputFormatter = ctx.obj["formatter"]
+    try:
+        result = AgentCore(client).follow(name)
+        formatter.print({"status": "following", "agent": name})
+    except Exception as e:
+        if ctx.obj["json_mode"]:
+            formatter.print(handle_error(e))
+            sys.exit(1)
+        raise
+
+
+@agent.command("unfollow")
+@click.argument("name")
+@click.pass_context
+def agent_unfollow(ctx: click.Context, name: str):
+    """Unfollow an agent."""
+    client = ensure_client(ctx)
+    formatter: OutputFormatter = ctx.obj["formatter"]
+    try:
+        result = AgentCore(client).unfollow(name)
+        formatter.print({"status": "unfollowed", "agent": name})
+    except Exception as e:
+        if ctx.obj["json_mode"]:
+            formatter.print(handle_error(e))
+            sys.exit(1)
+        raise
+
+
+@agent.command("update")
+@click.option("--description", help="Update your description")
+@click.option("--metadata", help="Update metadata as JSON string")
+@click.pass_context
+def agent_update(ctx: click.Context, description: str, metadata: str):
+    """Update your agent profile.
+
+    Note: You can only update one of description or metadata at a time.
+    """
+    import json
+    client = ensure_client(ctx)
+    formatter: OutputFormatter = ctx.obj["formatter"]
+
+    meta_dict = None
+    if metadata:
+        try:
+            meta_dict = json.loads(metadata)
+        except json.JSONDecodeError:
+            if ctx.obj["json_mode"]:
+                formatter.print({"error": "Invalid JSON for --metadata"})
+            else:
+                click.echo("Error: Invalid JSON for --metadata", err=True)
+            return
+
+    try:
+        result = AgentCore(client).update_profile(
+            description=description if description else None,
+            metadata=meta_dict
+        )
+        formatter.print({"status": "updated"})
+    except Exception as e:
+        if ctx.obj["json_mode"]:
+            formatter.print(handle_error(e))
+        else:
+            click.echo(f"Error: {e}", err=True)
+
+
 # post command group
 @cli.group()
 def post():
@@ -90,7 +380,7 @@ def post():
 @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"]
+    client = ensure_client(ctx)
     formatter: OutputFormatter = ctx.obj["formatter"]
     try:
         result = PostCore(client).create(submolt=submolt, title=title, content=content, url=url)
@@ -107,7 +397,7 @@ def post_create(ctx: click.Context, submolt: str, title: str, content: str, url:
 @click.pass_context
 def post_get(ctx: click.Context, post_id: str):
     """Get a post by ID."""
-    client: MoltbookClient = ctx.obj["client"]
+    client = ensure_client(ctx)
     formatter: OutputFormatter = ctx.obj["formatter"]
     try:
         result = PostCore(client).get(post_id)
@@ -124,7 +414,7 @@ def post_get(ctx: click.Context, post_id: str):
 @click.pass_context
 def post_delete(ctx: click.Context, post_id: str):
     """Delete a post."""
-    client: MoltbookClient = ctx.obj["client"]
+    client = ensure_client(ctx)
     formatter: OutputFormatter = ctx.obj["formatter"]
     try:
         result = PostCore(client).delete(post_id)
@@ -149,8 +439,11 @@ def comment():
 @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"]
+    """Create a comment on a post.
+
+    Use --parent to reply to a specific comment.
+    """
+    client = ensure_client(ctx)
     formatter: OutputFormatter = ctx.obj["formatter"]
     try:
         result = CommentCore(client).create(post_id=post_id, content=content, parent_id=parent)
@@ -162,13 +455,32 @@ def comment_create(ctx: click.Context, post_id: str, content: str, parent: str):
         raise
 
 
+@comment.command("reply")
+@click.argument("post_id")
+@click.argument("parent_id")
+@click.option("--content", required=True, help="Reply content")
+@click.pass_context
+def comment_reply(ctx: click.Context, post_id: str, parent_id: str, content: str):
+    """Reply to a comment."""
+    client = ensure_client(ctx)
+    formatter: OutputFormatter = ctx.obj["formatter"]
+    try:
+        result = CommentCore(client).create(post_id=post_id, content=content, parent_id=parent_id)
+        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"]
+    client = ensure_client(ctx)
     formatter: OutputFormatter = ctx.obj["formatter"]
     try:
         result = CommentCore(client).list_by_post(post_id, limit=limit)
@@ -187,14 +499,14 @@ def feed():
     pass
 
 
-@feed.command()
+@feed.command("get")
 @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"]
+    client = ensure_client(ctx)
     formatter: OutputFormatter = ctx.obj["formatter"]
     try:
         result = FeedCore(client).get(sort=sort, limit=limit, submolt=submolt)
@@ -211,7 +523,7 @@ def feed_get(ctx: click.Context, sort: str, limit: int, submolt: str):
 @click.pass_context
 def feed_hot(ctx: click.Context, limit: int):
     """Get hot posts."""
-    client: MoltbookClient = ctx.obj["client"]
+    client = ensure_client(ctx)
     formatter: OutputFormatter = ctx.obj["formatter"]
     try:
         result = FeedCore(client).get_hot(limit=limit)
@@ -228,7 +540,7 @@ def feed_hot(ctx: click.Context, limit: int):
 @click.pass_context
 def feed_new(ctx: click.Context, limit: int):
     """Get newest posts."""
-    client: MoltbookClient = ctx.obj["client"]
+    client = ensure_client(ctx)
     formatter: OutputFormatter = ctx.obj["formatter"]
     try:
         result = FeedCore(client).get_new(limit=limit)
@@ -247,17 +559,17 @@ def search():
     pass
 
 
-@search.command()
+@search.command("query")
 @click.argument("query")
-@click.option("--type", type=click.Choice(["posts", "users"]), default="posts", help="Search type")
+@click.option("--type", "search_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):
+def search_query(ctx: click.Context, query: str, search_type: str, limit: int):
     """Search posts or users."""
-    client: MoltbookClient = ctx.obj["client"]
+    client = ensure_client(ctx)
     formatter: OutputFormatter = ctx.obj["formatter"]
     try:
-        result = SearchCore(client).search(query=query, type_=type_, limit=limit)
+        result = SearchCore(client).search(query=query, type_=search_type, limit=limit)
         formatter.print(result)
     except Exception as e:
         if ctx.obj["json_mode"]:
@@ -275,15 +587,15 @@ def vote():
 
 @vote.command("up")
 @click.argument("item_id")
-@click.option("--type", type=click.Choice(["post", "comment"]), default="post", help="Item type")
+@click.option("--type", "item_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):
+def vote_up(ctx: click.Context, item_id: str, item_type: str):
     """Upvote a post or comment."""
-    client: MoltbookClient = ctx.obj["client"]
+    client = ensure_client(ctx)
     formatter: OutputFormatter = ctx.obj["formatter"]
     try:
-        result = VoteCore(client).upvote(item_id, type_=type_)
-        formatter.print({"status": "upvoted", "id": item_id})
+        result = VoteCore(client).upvote(item_id, type_=item_type)
+        formatter.print({"status": "upvoted", "id": item_id, "type": item_type})
     except Exception as e:
         if ctx.obj["json_mode"]:
             formatter.print(handle_error(e))
@@ -293,15 +605,49 @@ def vote_up(ctx: click.Context, item_id: str, type_: str):
 
 @vote.command("down")
 @click.argument("item_id")
-@click.option("--type", type=click.Choice(["post", "comment"]), default="post", help="Item type")
+@click.option("--type", "item_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):
+def vote_down(ctx: click.Context, item_id: str, item_type: str):
     """Downvote a post or comment."""
-    client: MoltbookClient = ctx.obj["client"]
+    client = ensure_client(ctx)
+    formatter: OutputFormatter = ctx.obj["formatter"]
+    try:
+        result = VoteCore(client).downvote(item_id, type_=item_type)
+        formatter.print({"status": "downvoted", "id": item_id, "type": item_type})
+    except Exception as e:
+        if ctx.obj["json_mode"]:
+            formatter.print(handle_error(e))
+            sys.exit(1)
+        raise
+
+
+@vote.command("up-comment")
+@click.argument("comment_id")
+@click.pass_context
+def vote_up_comment(ctx: click.Context, comment_id: str):
+    """Upvote a comment."""
+    client = ensure_client(ctx)
+    formatter: OutputFormatter = ctx.obj["formatter"]
+    try:
+        result = VoteCore(client).upvote_comment(comment_id)
+        formatter.print({"status": "upvoted", "id": comment_id, "type": "comment"})
+    except Exception as e:
+        if ctx.obj["json_mode"]:
+            formatter.print(handle_error(e))
+            sys.exit(1)
+        raise
+
+
+@vote.command("down-comment")
+@click.argument("comment_id")
+@click.pass_context
+def vote_down_comment(ctx: click.Context, comment_id: str):
+    """Downvote a comment."""
+    client = ensure_client(ctx)
     formatter: OutputFormatter = ctx.obj["formatter"]
     try:
-        result = VoteCore(client).downvote(item_id, type_=type_)
-        formatter.print({"status": "downvoted", "id": item_id})
+        result = VoteCore(client).downvote_comment(comment_id)
+        formatter.print({"status": "downvoted", "id": comment_id, "type": "comment"})
     except Exception as e:
         if ctx.obj["json_mode"]:
             formatter.print(handle_error(e))
@@ -321,7 +667,7 @@ def submolts():
 @click.pass_context
 def submolts_list(ctx: click.Context, limit: int):
     """List all submolts."""
-    client: MoltbookClient = ctx.obj["client"]
+    client = ensure_client(ctx)
     formatter: OutputFormatter = ctx.obj["formatter"]
     try:
         result = SubmoltsCore(client).list(limit=limit)
@@ -333,12 +679,67 @@ def submolts_list(ctx: click.Context, limit: int):
         raise
 
 
+@submolts.command("get")
+@click.argument("name")
+@click.pass_context
+def submolts_get(ctx: click.Context, name: str):
+    """Get submolt info."""
+    client = ensure_client(ctx)
+    formatter: OutputFormatter = ctx.obj["formatter"]
+    try:
+        result = SubmoltsCore(client).get(name)
+        formatter.print(result)
+    except Exception as e:
+        if ctx.obj["json_mode"]:
+            formatter.print(handle_error(e))
+            sys.exit(1)
+        raise
+
+
+@submolts.command("create")
+@click.argument("name")
+@click.argument("display_name")
+@click.option("--description", default="", help="Submolt description")
+@click.pass_context
+def submolts_create(ctx: click.Context, name: str, display_name: str, description: str):
+    """Create a new submolt."""
+    client = ensure_client(ctx)
+    formatter: OutputFormatter = ctx.obj["formatter"]
+    try:
+        result = SubmoltsCore(client).create(name, display_name, description)
+        formatter.print({"status": "created", "name": name, "display_name": display_name})
+    except Exception as e:
+        if ctx.obj["json_mode"]:
+            formatter.print(handle_error(e))
+            sys.exit(1)
+        raise
+
+
+@submolts.command("feed")
+@click.argument("name")
+@click.option("--sort", type=click.Choice(["hot", "new", "top", "rising"]), default="hot", help="Sort order")
+@click.option("--limit", default=20, help="Max posts")
+@click.pass_context
+def submolts_feed(ctx: click.Context, name: str, sort: str, limit: int):
+    """Get posts from a submolt."""
+    client = ensure_client(ctx)
+    formatter: OutputFormatter = ctx.obj["formatter"]
+    try:
+        result = SubmoltsCore(client).feed(name, sort=sort, 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"]
+    client = ensure_client(ctx)
     formatter: OutputFormatter = ctx.obj["formatter"]
     try:
         result = SubmoltsCore(client).subscribe(name)
@@ -355,7 +756,7 @@ def submolts_subscribe(ctx: click.Context, name: str):
 @click.pass_context
 def submolts_unsubscribe(ctx: click.Context, name: str):
     """Unsubscribe from a submolt."""
-    client: MoltbookClient = ctx.obj["client"]
+    client = ensure_client(ctx)
     formatter: OutputFormatter = ctx.obj["formatter"]
     try:
         result = SubmoltsCore(client).unsubscribe(name)
@@ -367,6 +768,23 @@ def submolts_unsubscribe(ctx: click.Context, name: str):
         raise
 
 
+@submolts.command("trending")
+@click.option("--limit", default=10, help="Max submolts to show")
+@click.pass_context
+def submolts_trending(ctx: click.Context, limit: int):
+    """Get trending submolts."""
+    client = ensure_client(ctx)
+    formatter: OutputFormatter = ctx.obj["formatter"]
+    try:
+        result = SubmoltsCore(client).trending(limit=limit)
+        formatter.print(result)
+    except Exception as e:
+        if ctx.obj["json_mode"]:
+            formatter.print(handle_error(e))
+            sys.exit(1)
+        raise
+
+
 def main():
     """Entry point."""
     cli()

moltcli/core/__init__.py

@@ -7,6 +7,7 @@ from .search import SearchCore
 from .vote import VoteCore
 from .submolts import SubmoltsCore
 from .auth import AuthCore
+from .agent import AgentCore
 
 __all__ = [
     "PostCore",
@@ -16,4 +17,5 @@ __all__ = [
     "VoteCore",
     "SubmoltsCore",
     "AuthCore",
+    "AgentCore",
 ]

moltcli/core/agent.py

@@ -0,0 +1,60 @@
+"""Agent core logic."""
+from typing import Optional
+from ..utils.api_client import MoltbookClient
+
+
+class AgentCore:
+    """Handle agent operations."""
+
+    def __init__(self, client: MoltbookClient):
+        self._client = client
+
+    def register(self, name: str, description: str = "") -> dict:
+        """Register a new agent.
+
+        This does NOT require authentication - it's how new agents sign up.
+
+        Args:
+            name: Unique agent name
+            description: Agent description
+
+        Returns:
+            Contains api_key, claim_url, and verification_code.
+            IMPORTANT: Save the api_key immediately!
+        """
+        return self._client.post("/agents/register", json_data={
+            "name": name,
+            "description": description,
+        })
+
+    def get_status(self) -> dict:
+        """Check claim status (pending or claimed)."""
+        return self._client.get("/agents/status")
+
+    def get_me(self) -> dict:
+        """Get current agent info."""
+        return self._client.get("/agents/me")
+
+    def get_profile(self, name: str) -> dict:
+        """Get another agent's profile."""
+        return self._client.get(f"/agents/profile?name={name}")
+
+    def follow(self, name: str) -> dict:
+        """Follow an agent."""
+        return self._client.post(f"/agents/{name}/follow")
+
+    def unfollow(self, name: str) -> dict:
+        """Unfollow an agent."""
+        return self._client.delete(f"/agents/{name}/follow")
+
+    def update_profile(self, description: str = None, metadata: dict = None) -> dict:
+        """Update current agent profile.
+
+        Note: API only allows one of description or metadata at a time.
+        """
+        data = {}
+        if description is not None:
+            data["description"] = description
+        if metadata is not None:
+            data["metadata"] = metadata
+        return self._client.patch("/agents/me", json_data=data)

moltcli/core/auth.py

@@ -9,12 +9,12 @@ class AuthCore:
         self._client = client
 
     def whoami(self) -> dict:
-        """Get current user info."""
-        return self._client.get("/auth/whoami")
+        """Get current user info. Uses /agents/me endpoint."""
+        return self._client.get("/agents/me")
 
     def verify(self) -> dict:
-        """Verify API key is valid."""
-        return self._client.get("/auth/verify")
+        """Verify API key is valid. Uses /agents/me endpoint."""
+        return self._client.get("/agents/me")
 
     def refresh(self) -> dict:
         """Refresh authentication token."""

moltcli/core/submolts.py

@@ -17,13 +17,40 @@ class SubmoltsCore:
         """Get a submolt by name."""
         return self._client.get(f"/submolts/{name}")
 
+    def create(self, name: str, display_name: str, description: str = "") -> dict:
+        """Create a new submolt.
+
+        Args:
+            name: Unique name (e.g., "aithoughts")
+            display_name: Display name (e.g., "AI Thoughts")
+            description: Submolt description
+        """
+        return self._client.post("/submolts", json_data={
+            "name": name,
+            "display_name": display_name,
+            "description": description,
+        })
+
+    def feed(self, name: str, sort: str = "hot", limit: int = 20) -> dict:
+        """Get feed from a specific submolt.
+
+        Args:
+            name: Submolt name
+            sort: Sort order (hot, new, top, rising)
+            limit: Max posts to return
+        """
+        return self._client.get(
+            f"/submolts/{name}/feed",
+            params={"sort": sort, "limit": limit}
+        )
+
     def subscribe(self, name: str) -> dict:
         """Subscribe to a submolt."""
-        return self._client.post("/submolts/subscribe", json_data={"name": name})
+        return self._client.post(f"/submolts/{name}/subscribe")
 
     def unsubscribe(self, name: str) -> dict:
         """Unsubscribe from a submolt."""
-        return self._client.post("/submolts/unsubscribe", json_data={"name": name})
+        return self._client.delete(f"/submolts/{name}/subscribe")
 
     def get_subscribed(self) -> dict:
         """Get user's subscribed submolts."""

moltcli/core/vote.py

@@ -20,11 +20,25 @@ class VoteCore:
         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_}")
+        """Internal vote method.
+
+        Endpoints from skill.md:
+        - POST /posts/{id}/upvote
+        - POST /posts/{id}/downvote
+        - POST /comments/{id}/upvote
+        - POST /comments/{id}/downvote
+        """
+        direction_full = "upvote" if direction == "up" else "downvote"
+        if type_ == "post":
+            endpoint = f"/posts/{item_id}/{direction_full}"
+        else:
+            endpoint = f"/comments/{item_id}/{direction_full}"
+        return self._client.post(endpoint)
+
+    def upvote_comment(self, comment_id: str) -> dict:
+        """Upvote a comment. Shortcut for: upvote(comment_id, type='comment')"""
+        return self._vote(comment_id, self.UP, "comment")
+
+    def downvote_comment(self, comment_id: str) -> dict:
+        """Downvote a comment. Shortcut for: downvote(comment_id, type='comment')"""
+        return self._vote(comment_id, self.DOWN, "comment")

moltcli/utils/api_client.py

@@ -37,13 +37,21 @@ class MoltbookClient:
         )
 
         if not response.ok:
-            self._handle_error_response(response)
+            self._handle_error_response(response, endpoint)
 
         return response.json()
 
-    def _handle_error_response(self, response):
+    def _handle_error_response(self, response, endpoint: str = ""):
         """Handle API error response with specific error types."""
         status = response.status_code
+        response_text = response.text.strip()
+
+        # Determine endpoint type for rate limit
+        endpoint_type = "general"
+        if "/posts" in endpoint or "/post" in endpoint:
+            endpoint_type = "post"
+        elif "/vote" in endpoint or "/upvote" in endpoint or "/downvote" in endpoint:
+            endpoint_type = "vote"
 
         # Rate limit (429)
         if status == 429:
@@ -52,11 +60,12 @@ class MoltbookClient:
                 retry_after=retry_after,
                 limit=limit,
                 remaining=remaining,
+                endpoint_type=endpoint_type,
             )
 
         # Authentication errors (401, 403)
         if status in (401, 403):
-            raise AuthError(f"Authentication failed: {response.text}")
+            raise AuthError(f"Authentication failed: {response_text or 'No response body'}")
 
         # Not found (404)
         if status == 404:
@@ -69,8 +78,18 @@ class MoltbookClient:
             else:
                 raise NotFoundError("resource")
 
+        # Method not allowed (405)
+        if status == 405:
+            # Try to get error message from response body
+            try:
+                error_body = response.json()
+                error_msg = error_body.get("error", error_body.get("message", response_text))
+            except Exception:
+                error_msg = response_text or f"Method not allowed for {endpoint}"
+            raise Exception(f"API error {status}: {error_msg}")
+
         # Other errors
-        raise Exception(f"API error: {status} {response.text}")
+        raise Exception(f"API error {status}: {response_text or 'No response body'}")
 
     def get(self, endpoint: str, params: Optional[dict] = None) -> dict:
         """GET request."""
@@ -85,3 +104,7 @@ class MoltbookClient:
     def delete(self, endpoint: str) -> dict:
         """DELETE request."""
         return self._request("DELETE", endpoint)
+
+    def patch(self, endpoint: str, json_data: Optional[dict] = None) -> dict:
+        """PATCH request."""
+        return self._request("PATCH", endpoint, json_data=json_data)

moltcli/utils/config.py

@@ -8,11 +8,14 @@ from typing import Optional
 class Config:
     """Config loader for credentials and settings."""
 
+    DEFAULT_CONFIG_DIR = Path.home() / ".config" / "moltbook"
+    DEFAULT_CONFIG_FILE = DEFAULT_CONFIG_DIR / "credentials.json"
+
     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")
+                str(self.DEFAULT_CONFIG_FILE)
             )
         self.config_path = Path(config_path)
         self._config: Optional[dict] = None
@@ -44,6 +47,53 @@ class Config:
         """Get config value by key."""
         return self.config.get(key, default)
 
+    def save(self, api_key: str, agent_name: str = "") -> None:
+        """Save credentials to config file.
+
+        Does NOT overwrite existing files.
+
+        Args:
+            api_key: Moltbook API key
+            agent_name: Agent name (optional)
+
+        Raises:
+            FileExistsError: If config file already exists
+        """
+        # Ensure config directory exists
+        self.config_path.parent.mkdir(parents=True, exist_ok=True)
+
+        if self.config_path.exists():
+            raise FileExistsError(
+                f"Credentials file already exists: {self.config_path}\n"
+                f"Use 'moltcli auth logout' first to remove existing credentials."
+            )
+
+        config = {"api_key": api_key}
+        if agent_name:
+            config["agent_name"] = agent_name
+
+        with open(self.config_path, "x") as f:
+            json.dump(config, f, indent=2)
+
+        # Clear cached config
+        self._config = None
+
+    def remove(self) -> bool:
+        """Remove config file.
+
+        Returns:
+            True if file was removed, False if it didn't exist.
+        """
+        if self.config_path.exists():
+            self.config_path.unlink()
+            self._config = None
+            return True
+        return False
+
+    def exists(self) -> bool:
+        """Check if config file exists."""
+        return self.config_path.exists()
+
 
 # Global config instance
 _config: Optional[Config] = None

moltcli/utils/errors.py

@@ -51,11 +51,17 @@ class NotFoundError(MoltCLIError):
 class RateLimitError(MoltCLIError):
     """Rate limit exceeded."""
 
+    # Default wait times for common scenarios
+    DEFAULT_WAIT_POST = 1800  # 30 minutes for posting
+    DEFAULT_WAIT_VOTE = 10    # 10 seconds for voting
+    DEFAULT_WAIT_GENERAL = 60  # 60 seconds for general requests
+
     def __init__(
         self,
         retry_after: Optional[int] = None,
         limit: Optional[int] = None,
         remaining: Optional[int] = None,
+        endpoint_type: str = "general",
     ):
         """Initialize rate limit error.
 
@@ -63,22 +69,29 @@ class RateLimitError(MoltCLIError):
             retry_after: Seconds until retry is allowed
             limit: Rate limit maximum requests
             remaining: Remaining requests in window
+            endpoint_type: Type of endpoint (post, vote, general)
         """
         self.retry_after = retry_after
         self.limit = limit
         self.remaining = remaining
 
+        # Get default wait time based on endpoint type
+        default_wait = getattr(self, f"DEFAULT_WAIT_{endpoint_type.upper()}", self.DEFAULT_WAIT_GENERAL)
+        wait_time = retry_after or default_wait
+
         # Build message
         if retry_after:
             message = f"Rate limit exceeded. Retry after {retry_after} seconds."
         else:
-            message = "Rate limit exceeded. Please slow down."
+            message = f"Rate limit exceeded. Please wait about {wait_time} seconds."
 
         # Build suggestion
-        if retry_after:
+        if remaining is not None and remaining == 0:
+            suggestion = f"Rate limit reached (0/{limit} remaining). Wait {wait_time} seconds."
+        elif retry_after:
             suggestion = f"Wait {retry_after} seconds before retrying."
         else:
-            suggestion = "Wait a moment before retrying. Use --delay to space requests."
+            suggestion = f"Wait ~{wait_time} seconds before retrying. Consider adding --wait flag for auto-delay."
 
         super().__init__(message, RATE_LIMIT, suggestion)
 

{moltcli-0.1.0.dist-info → moltcli-0.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: moltcli
-Version: 0.1.0
+Version: 0.2.0
 Summary: CLI tool for Moltbook social network, AI Agent friendly
 Author: MoltCLI Team
 License: MIT

moltcli-0.2.0.dist-info/RECORD

@@ -0,0 +1,22 @@
+moltcli/__init__.py,sha256=e7p2Cat3JV5cvVi0A3XGjA8fhwg9p00mWktYc-RJcsM,77
+moltcli/cli.py,sha256=UX5YqEpaSi0f3oMsYJy4wmmFr99dJlA3NYDV5OSovrg,24718
+moltcli/core/__init__.py,sha256=JnkWgO3F3dYBKLOkwg1N7P2RDB31iR4g35gCtFkRMYA,425
+moltcli/core/agent.py,sha256=bZ73jZxZhoNDXLOVwqthrXUiLgCD1u-1WNRemj3gsPA,1920
+moltcli/core/auth.py,sha256=HmZH2KClOqTIhp93iL-fplbuECzQzILI8L2H4w16FSA,618
+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=NVm_3Ld8MgP0XkiPqIqEJuzb88SiWr0jdlw8lVvWIYo,2005
+moltcli/core/vote.py,sha256=Lle39DHCOqS7Paf6x3BRhfAxiGpwtkGRRZOKNvdbccs,1527
+moltcli/utils/__init__.py,sha256=-bfVKSN8rxaSrTkb3oYG6wmD_GYoR7xn-IMo6v2WxeA,526
+moltcli/utils/api_client.py,sha256=omNVpE-XlpjzBTQ5GU72B3gIUtlsPeesgxwttnn9vuM,3707
+moltcli/utils/config.py,sha256=lDshmadh2j4jQdqR-GWJXH2-vypjd4vWnOoV32nxnYg,3078
+moltcli/utils/errors.py,sha256=UmUEpeFpps2OSprtF83Qe49oQbVD8P0Exubmh4aIVBA,4835
+moltcli/utils/formatter.py,sha256=kLYCPJw1IsanGYKXA8XGEm8mDAnC_AlIYQwN5bFypCc,1313
+moltcli-0.2.0.dist-info/licenses/LICENSE,sha256=EOduU9kNb_dRzzPmt7gJsVSxqTCYJeYl5C2POxT0rj8,1069
+moltcli-0.2.0.dist-info/METADATA,sha256=Zvruf9eFcX5AdPKyE9hGN4cpki_MSijQnf_-Lh2sljg,2585
+moltcli-0.2.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+moltcli-0.2.0.dist-info/entry_points.txt,sha256=Cn6XRCOpVqQHJYqbjOCJ9LfePx6VYR_Gdn6MsoMtLq4,45
+moltcli-0.2.0.dist-info/top_level.txt,sha256=3BuZXxTPE63yrySE7ET5eCy32LneFysqMiG-pfEQifw,8
+moltcli-0.2.0.dist-info/RECORD,,

moltcli-0.1.0.dist-info/RECORD

@@ -1,21 +0,0 @@
-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,,