better-reddit-cli 0.1.0__py3-none-any.whl

better_reddit_cli-0.1.0.dist-info/METADATA

@@ -0,0 +1,125 @@
+Metadata-Version: 2.4
+Name: better-reddit-cli
+Version: 0.1.0
+Summary: A command-line tool for browsing Reddit without requiring an API key
+License-File: LICENSE
+Requires-Python: >=3.14
+Requires-Dist: httpx
+Requires-Dist: pydantic
+Requires-Dist: typer
+Provides-Extra: dev
+Requires-Dist: pytest; extra == 'dev'
+Description-Content-Type: text/markdown
+
+<p align="center">
+  <picture>
+    <source media="(prefers-color-scheme: dark)" srcset="public/banner.jpg">
+    <source media="(prefers-color-scheme: light)" srcset="public/banner.jpg">
+    <img src="public/banner.jpg" alt="Reddit CLI Logo" width="100%">
+  </picture>
+</p>
+
+<h1 align="center">Reddit CLI</h1>
+
+<p align="center">
+  Browse Reddit from your terminal. No API key, no authentication, no hassle.
+</p>
+
+<p align="center">
+  <a href="https://github.com/AliiiBenn/reddit-cli">
+    <img src="https://img.shields.io/github/license/AliiiBenn/reddit-cli" alt="License">
+  </a>
+  <a href="https://github.com/AliiiBenn/reddit-cli/actions">
+    <img src="https://img.shields.io/github/actions/workflow/status/AliiiBenn/reddit-cli/test" alt="Tests">
+  </a>
+  <a href="https://www.python.org/">
+    <img src="https://img.shields.io/badge/python-3.14+-blue" alt="Python">
+  </a>
+</p>
+
+Explore subreddits, dive into discussions, and discover trending content - all from a sleek command-line interface.
+
+## Why Reddit CLI?
+
+- **Zero setup** - No API key needed, just install and go
+- **Blazing fast** - Async HTTP powered by httpx
+- **Explore deeply** - Pagination, sorting, and threaded comments
+- **Clean output** - Readable formatting right in your terminal
+
+## Features
+
+- Browse subreddits with 6 sorting modes (hot, new, top, rising, controversial, gilded)
+- View posts with full metadata
+- Threaded comment display with depth control
+- Pagination support for infinite scrolling
+- Subreddit info, rules, and moderator discovery
+- 100% type-annotated Python
+
+## Quick Start
+
+```bash
+# Install
+uv add reddit
+
+# Browse the frontpage
+reddit
+
+# Explore a subreddit
+reddit browse python --limit 10
+
+# View a post and its comments
+reddit view t3_abc123
+reddit comments t3_abc123 --depth 3
+
+# Discover subreddits
+reddit subreddits --sort subscribers
+reddit subreddit python --rules
+```
+
+## Command Overview
+
+| Command | Description |
+|---------|-------------|
+| `reddit` | Frontpage (hot posts) |
+| `reddit browse <sub>` | Browse a subreddit |
+| `reddit view <id>` | View a post |
+| `reddit comments <id>` | View post comments |
+| `reddit subreddit <name>` | Subreddit info |
+| `reddit subreddits` | List popular subreddits |
+
+## Browse Options
+
+```
+--sort hot|new|top|rising|controversial|gilded
+--limit <n>     Number of posts (max 100)
+--period day|week|month|year|all
+--after <id>    Next page
+--before <id>    Previous page
+```
+
+## Development
+
+```bash
+# Clone and install
+git clone https://github.com/AliiiBenn/reddit-cli.git
+cd reddit-cli
+uv sync
+
+# Run tests
+uv run pytest
+
+# Lint and type-check
+uv run ruff check .
+uv run mypy reddit_cli
+
+# Try it out
+uv run reddit browse python
+```
+
+## Contributing
+
+Contributions are welcome! Feel free to open issues or submit PRs.
+
+## License
+
+MIT - See [LICENSE](LICENSE) for details.

better_reddit_cli-0.1.0.dist-info/RECORD

@@ -0,0 +1,17 @@
+reddit_cli/__init__.py,sha256=sb4RueWnGOwAsGYNj9aV1ScWbwH5bZemsYUnZRZBIzI,1349
+reddit_cli/commands/browse.py,sha256=pJOtDOj_HleOhaUc46o2RTUi1ns3ujW34Bo3d92i7t0,1734
+reddit_cli/commands/comments.py,sha256=YhaSnRLU_wAlYc5JmtiFukRBDFxS61G-NHCcnmiznJM,2892
+reddit_cli/commands/navigation.py,sha256=I9_iphn_Vbv3tv3cZDUhoiK5AX-4fWZYqKg_r9Gruo8,2649
+reddit_cli/commands/post.py,sha256=nqTz_6xt5cusblV0Jy7Zd6dQbXtyZT3Qx6mDi5QUEZs,1195
+reddit_cli/commands/subreddit.py,sha256=RCpge9fulRiUb7TurzWSYydeClb83sgP78Adwu8VA6c,2806
+reddit_cli/reddit/__init__.py,sha256=T_MXBIZN2c346BY-rEHCsmSQlorPKRcZ84jMTVKNidA,383
+reddit_cli/reddit/base.py,sha256=g7TPjcwxyQquVZ4JpaGBR1WiR9XI-8Vshgy-L1x_o0g,837
+reddit_cli/reddit/comments.py,sha256=akBLWyaZsYmeqq2JZihaY7sfhbhd750OZimpnKSBWzA,2695
+reddit_cli/reddit/models.py,sha256=s53AL5u6lmSSiFs4nh72DIJlDVZClO2y0GQmeZ4pgq4,981
+reddit_cli/reddit/posts.py,sha256=Mt73QEN-zkxfY4XKHfLoERr1ilAQQzyJoOetH9i_ZNU,2119
+reddit_cli/reddit/subreddits.py,sha256=4DoHfNG0w9VzwNUjp9iCQsPG2IpCTKZesOKSIvPl7J4,1873
+better_reddit_cli-0.1.0.dist-info/METADATA,sha256=N019Vqt6n15M8aiQUrFszkwYG4o6VN1aOPPMnwwc9iY,3177
+better_reddit_cli-0.1.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+better_reddit_cli-0.1.0.dist-info/entry_points.txt,sha256=Xx3prHxNe-6GZlmfKwnsoEil-o6jQMncVvwsjra6WmE,42
+better_reddit_cli-0.1.0.dist-info/licenses/LICENSE,sha256=zGjJxjLOT5T07cl55eVmhhm3pm38odPhe0aB9nUFaTI,1067
+better_reddit_cli-0.1.0.dist-info/RECORD,,

better_reddit_cli-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

better_reddit_cli-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+reddit = reddit_cli:app

better_reddit_cli-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Reddit CLI
+
+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.

reddit_cli/__init__.py

@@ -0,0 +1,47 @@
+import asyncio
+import typer
+
+from reddit_cli.commands.browse import browse
+from reddit_cli.commands.comments import comment, comments
+from reddit_cli.commands.navigation import best, frontpage, home
+from reddit_cli.commands.post import post, view
+from reddit_cli.commands.subreddit import subreddit, subreddits
+from reddit_cli.reddit import RedditClient, PostsClient
+
+app = typer.Typer(invoke_without_command=True)
+app.command()(browse)
+app.command()(post)
+app.command()(view)
+app.command()(comments)
+app.command()(comment)
+app.command()(subreddit)
+app.command()(subreddits)
+app.command()(frontpage)
+app.command()(home)
+app.command()(best)
+
+
+@app.callback()
+def main() -> None:
+    """Browse the frontpage by default."""
+    asyncio.run(_frontpage_default())
+
+
+async def _frontpage_default() -> None:
+    """Default: show frontpage."""
+    async with RedditClient() as client:
+        posts_client = PostsClient(client)
+        posts, after_cursor, before_cursor = await posts_client.list_posts("reddit", "hot", 25, None)
+
+        for post in posts:
+            print(f"[{post.score}] {post.title}")
+            print(f"  ID: {post.id}")
+            print(f"  r/{post.subreddit} by {post.author}")
+            print(f"  {post.num_comments} comments")
+            print()
+
+
+@app.command()
+def ping() -> str:
+    """Ping the CLI."""
+    return "pong"

reddit_cli/commands/browse.py

@@ -0,0 +1,58 @@
+import asyncio
+import typer
+
+from reddit_cli.reddit import RedditClient, PostsClient
+
+app = typer.Typer()
+
+
+async def _browse_async(
+    subreddit: str,
+    sort: str = "hot",
+    limit: int = 25,
+    period: str | None = None,
+    after: str | None = None,
+    before: str | None = None,
+) -> None:
+    """Async implementation of browse."""
+    async with RedditClient() as client:
+        posts_client = PostsClient(client)
+        posts, after_cursor, before_cursor = await posts_client.list_posts(
+            subreddit, sort, limit, period, after, before
+        )
+
+        for post in posts:
+            print(f"[{post.score}] {post.title}")
+            print(f"  ID: {post.id}")
+            print(f"  r/{post.subreddit} by {post.author}")
+            print(f"  {post.num_comments} comments")
+            print()
+
+        if after_cursor or before_cursor:
+            print("---")
+            if after_cursor:
+                print(f"After: {after_cursor}")
+            if before_cursor:
+                print(f"Before: {before_cursor}")
+
+
+@app.command()
+def browse(
+    subreddit: str,
+    sort: str = "hot",
+    limit: int = 25,
+    period: str | None = None,
+    after: str | None = None,
+    before: str | None = None,
+) -> None:
+    """Browse posts from a subreddit.
+
+    Args:
+        subreddit: Subreddit name (without r/)
+        sort: Sort type (hot, new, top, rising, controversial, gilded)
+        limit: Number of posts to return
+        period: Time period for top/controversial (day, week, month, year, all)
+        after: Pagination cursor (get posts after this ID)
+        before: Pagination cursor (get posts before this ID)
+    """
+    asyncio.run(_browse_async(subreddit, sort, limit, period, after, before))

reddit_cli/commands/comments.py

@@ -0,0 +1,101 @@
+import asyncio
+import sys
+import typer
+
+from reddit_cli.reddit import RedditClient, CommentsClient, Comment
+
+app = typer.Typer()
+
+
+async def _comments_async(
+    post_id: str,
+    sort: str = "confidence",
+    depth: int | None = None,
+) -> None:
+    """Async implementation of comments."""
+    async with RedditClient() as client:
+        comments_client = CommentsClient(client)
+        comments = await comments_client.get_comments(post_id, sort, depth)
+
+        for comment in comments:
+            _print_comment(comment)
+
+
+def _print_comment(comment: "Comment", indent: int = 0) -> None:
+    """Print a comment and its replies recursively."""
+    prefix = "  " * indent
+    body = comment.body.encode(sys.stdout.encoding, errors="replace").decode(
+        sys.stdout.encoding
+    )
+
+    print(f"{prefix}[{comment.score}] {comment.author}")
+    print(f"{prefix}{body[:200]}{'...' if len(body) > 200 else ''}")
+    print()
+
+    for reply in comment.replies:
+        _print_comment(reply, indent + 1)
+
+
+@app.command()
+def comments(
+    post_id: str,
+    sort: str = "confidence",
+    depth: int | None = None,
+) -> None:
+    """View comments for a post.
+
+    Args:
+        post_id: Post ID (with or without t3_ prefix)
+        sort: Sort type (confidence, top, new, old, controversial, qa)
+        depth: Maximum comment depth
+    """
+    asyncio.run(_comments_async(post_id, sort, depth))
+
+
+# Alias
+@app.command(name="comment")
+def comment(
+    post_id: str,
+    comment_id: str,
+    replies: bool = False,
+) -> None:
+    """View a single comment from a post.
+
+    Args:
+        post_id: Post ID (with or without t3_ prefix)
+        comment_id: Comment ID (with or without t1_ prefix)
+        replies: Include replies
+    """
+    asyncio.run(_comment_async(post_id, comment_id, replies))
+
+
+async def _comment_async(
+    post_id: str,
+    comment_id: str,
+    replies: bool = False,
+) -> None:
+    """Async implementation of single comment."""
+    async with RedditClient() as client:
+        comments_client = CommentsClient(client)
+        depth = 999 if replies else 0
+        comments = await comments_client.get_comments(post_id, depth=depth)
+
+        # Find the specific comment
+        target_id = comment_id.removeprefix("t1_")
+        for c in comments:
+            if c.id == target_id:
+                print(f"[{c.score}] {c.author}")
+                print(f"ID: {c.id}")
+                print(f"Parent: {c.parent_id}")
+                body = c.body.encode(sys.stdout.encoding, errors="replace").decode(
+                    sys.stdout.encoding
+                )
+                print(body)
+                print()
+                if replies and c.replies:
+                    print("Replies:")
+                    for reply in c.replies:
+                        _print_comment(reply, 1)
+                return
+
+        print(f"Comment {comment_id} not found in post {post_id}")

reddit_cli/commands/navigation.py

@@ -0,0 +1,93 @@
+import asyncio
+import typer
+
+from reddit_cli.reddit import RedditClient, PostsClient
+
+app = typer.Typer()
+
+
+async def _browse_frontpage_async(
+    sort: str = "hot",
+    limit: int = 25,
+    period: str | None = None,
+    after: str | None = None,
+    before: str | None = None,
+) -> None:
+    """Async implementation of frontpage browsing."""
+    async with RedditClient() as client:
+        posts_client = PostsClient(client)
+        posts, after_cursor, before_cursor = await posts_client.list_posts(
+            "reddit", sort, limit, period, after, before
+        )
+
+        for post in posts:
+            print(f"[{post.score}] {post.title}")
+            print(f"  ID: {post.id}")
+            print(f"  r/{post.subreddit} by {post.author}")
+            print(f"  {post.num_comments} comments")
+            print()
+
+        if after_cursor or before_cursor:
+            print("---")
+            if after_cursor:
+                print(f"After: {after_cursor}")
+            if before_cursor:
+                print(f"Before: {before_cursor}")
+
+
+@app.command(name="frontpage")
+def frontpage(
+    sort: str = "hot",
+    limit: int = 25,
+    period: str | None = None,
+    after: str | None = None,
+    before: str | None = None,
+) -> None:
+    """Browse the frontpage.
+
+    Args:
+        sort: Sort type (hot, new, top, rising, controversial, gilded)
+        limit: Number of posts to return
+        period: Time period for top/controversial (day, week, month, year, all)
+        after: Pagination cursor
+        before: Pagination cursor
+    """
+    asyncio.run(_browse_frontpage_async(sort, limit, period, after, before))
+
+
+@app.command(name="home")
+def home(
+    sort: str = "hot",
+    limit: int = 25,
+    period: str | None = None,
+    after: str | None = None,
+    before: str | None = None,
+) -> None:
+    """Alias for frontpage.
+
+    Args:
+        sort: Sort type (hot, new, top, rising, controversial, gilded)
+        limit: Number of posts to return
+        period: Time period for top/controversial (day, week, month, year, all)
+        after: Pagination cursor
+        before: Pagination cursor
+    """
+    asyncio.run(_browse_frontpage_async(sort, limit, period, after, before))
+
+
+@app.command(name="best")
+def best(
+    limit: int = 25,
+    period: str = "all",
+    after: str | None = None,
+    before: str | None = None,
+) -> None:
+    """Browse the best posts overall.
+
+    Args:
+        limit: Number of posts to return
+        period: Time period (day, week, month, year, all)
+        after: Pagination cursor
+        before: Pagination cursor
+    """
+    asyncio.run(_browse_frontpage_async("top", limit, period, after, before))

reddit_cli/commands/post.py

@@ -0,0 +1,45 @@
+import asyncio
+import sys
+import typer
+
+from reddit_cli.reddit import RedditClient, PostsClient
+
+app = typer.Typer()
+
+
+async def _post_async(post_id: str) -> None:
+    """Async implementation of post."""
+    async with RedditClient() as client:
+        posts_client = PostsClient(client)
+        post = await posts_client.get_post(post_id)
+
+        print(f"Title: {post.title}")
+        print(f"Score: {post.score}")
+        print(f"Comments: {post.num_comments}")
+        print(f"Author: {post.author}")
+        print(f"Subreddit: r/{post.subreddit}")
+        print(f"URL: {post.url}")
+        print(f"Permalink: https://reddit.com{post.permalink}")
+        print()
+        if post.selftext:
+            print(post.selftext.encode(sys.stdout.encoding, errors="replace").decode(sys.stdout.encoding))
+
+
+@app.command()
+def post(post_id: str) -> None:
+    """View a single post by ID.
+
+    Args:
+        post_id: Post ID (with or without t3_ prefix)
+    """
+    asyncio.run(_post_async(post_id))
+
+
+@app.command(name="view")
+def view(post_id: str) -> None:
+    """Alias for post command.
+
+    Args:
+        post_id: Post ID (with or without t3_ prefix)
+    """
+    asyncio.run(_post_async(post_id))

reddit_cli/commands/subreddit.py

@@ -0,0 +1,88 @@
+import asyncio
+import sys
+import typer
+
+from reddit_cli.reddit import RedditClient, SubredditsClient
+
+app = typer.Typer()
+
+
+async def _subreddit_async(
+    name: str,
+    rules: bool = False,
+    moderators: bool = False,
+) -> None:
+    """Async implementation of subreddit."""
+    async with RedditClient() as client:
+        subreddits_client = SubredditsClient(client)
+
+        if rules:
+            rules_data = await subreddits_client.get_rules(name)
+            print(f"Rules for r/{name}:")
+            for i, rule in enumerate(rules_data.get("rules", []), 1):
+                print(f"  {i}. {rule.get('short_name', 'N/A')}")
+                print(f"     {rule.get('description', 'N/A')[:100]}...")
+        elif moderators:
+            try:
+                mods_data = await subreddits_client.get_moderators(name)
+                print(f"Moderators of r/{name}:")
+                for mod in mods_data:
+                    print(f"  - {mod.get('name', 'N/A')}")
+            except Exception:
+                print("Moderators list is not publicly available (requires authentication)")
+        else:
+            subreddit = await subreddits_client.get_subreddit(name)
+            print(f"Subreddit: r/{subreddit.display_name}")
+            print(f"Title: {subreddit.title}")
+            print(f"Subscribers: {subreddit.subscribers:,}")
+            print(f"Active users: {subreddit.active_users:,}")
+            desc = subreddit.description.encode(
+                sys.stdout.encoding, errors="replace"
+            ).decode(sys.stdout.encoding)
+            print(f"Description: {desc[:300]}{'...' if len(desc) > 300 else ''}")
+
+
+@app.command()
+def subreddit(
+    name: str,
+    rules: bool = False,
+    moderators: bool = False,
+) -> None:
+    """Get subreddit info.
+
+    Args:
+        name: Subreddit name (with or without r/ prefix)
+        rules: Show subreddit rules
+        moderators: Show subreddit moderators
+    """
+    asyncio.run(_subreddit_async(name, rules, moderators))
+
+
+@app.command(name="subreddits")
+def subreddits(
+    sort: str = "subscribers",
+    limit: int = 25,
+) -> None:
+    """List popular subreddits.
+
+    Args:
+        sort: Sort type (subscribers, active)
+        limit: Number of subreddits to return
+    """
+    asyncio.run(_list_subreddits_async(sort, limit))
+
+
+async def _list_subreddits_async(
+    sort: str = "subscribers",
+    limit: int = 25,
+) -> None:
+    """Async implementation of subreddits listing."""
+    async with RedditClient() as client:
+        subreddits_client = SubredditsClient(client)
+        subreddits = await subreddits_client.list_subreddits(sort, limit)
+
+        for sub in subreddits:
+            print(f"r/{sub.display_name}")
+            print(f"  {sub.title}")
+            print(f"  Subscribers: {sub.subscribers:,}")
+            print()

reddit_cli/reddit/__init__.py

@@ -0,0 +1,7 @@
+from reddit_cli.reddit.base import RedditClient
+from reddit_cli.reddit.comments import CommentsClient
+from reddit_cli.reddit.models import Comment, Post, Subreddit
+from reddit_cli.reddit.posts import PostsClient
+from reddit_cli.reddit.subreddits import SubredditsClient
+
+__all__ = ["RedditClient", "PostsClient", "CommentsClient", "SubredditsClient", "Post", "Subreddit", "Comment"]

reddit_cli/reddit/base.py

@@ -0,0 +1,26 @@
+import httpx
+
+
+class RedditClient:
+    """Async HTTP client for Reddit JSON API."""
+
+    BASE_URL = "https://www.reddit.com"
+
+    def __init__(self) -> None:
+        self._client: httpx.AsyncClient | None = None
+
+    async def __aenter__(self) -> "RedditClient":
+        self._client = httpx.AsyncClient(base_url=self.BASE_URL)
+        return self
+
+    async def __aexit__(self, *args: object) -> None:
+        if self._client:
+            await self._client.aclose()
+
+    async def get(self, path: str, params: dict | None = None) -> dict:
+        """Make a GET request to the Reddit API."""
+        if not self._client:
+            raise RuntimeError("Client not initialized. Use async context manager.")
+        response = await self._client.get(path, params=params)
+        response.raise_for_status()
+        return response.json()

reddit_cli/reddit/comments.py

@@ -0,0 +1,81 @@
+from reddit_cli.reddit.base import RedditClient
+from reddit_cli.reddit.models import Comment
+
+
+class CommentsClient:
+    """Client for Reddit comment endpoints."""
+
+    def __init__(self, client: RedditClient) -> None:
+        self._client = client
+
+    async def get_comments(
+        self,
+        post_id: str,
+        sort: str = "confidence",
+        depth: int | None = None,
+    ) -> list[Comment]:
+        """Get comments for a post.
+
+        Args:
+            post_id: Post ID (with or without t3_ prefix)
+            sort: Sort type (confidence, top, new, old, controversial, qa)
+            depth: Maximum comment depth (None for unlimited)
+        """
+        if post_id.startswith("t3_"):
+            post_id = post_id[3:]
+
+        path = f"/comments/{post_id}.json"
+        params = f"?sort={sort}"
+
+        data = await self._client.get(path + params)
+        comments_data = data[1]["data"]["children"]
+
+        comments = []
+        for item in comments_data:
+            if item["kind"] == "t1":  # Comment
+                comment = self._parse_comment(item["data"], depth or 999, 0)
+                comments.append(comment)
+
+        return comments
+
+    def _parse_comment(
+        self, data: dict, max_depth: int, current_depth: int
+    ) -> Comment:
+        """Parse a comment and its replies recursively."""
+        replies: list[Comment] = []
+
+        if data.get("replies") and isinstance(data["replies"], dict):
+            for reply in data["replies"]["data"]["children"]:
+                if reply["kind"] == "t1" and current_depth < max_depth:
+                    replies.append(
+                        self._parse_comment(
+                            reply["data"], max_depth, current_depth + 1
+                        )
+                    )
+
+        return Comment(
+            id=data["id"],
+            author=data["author"],
+            body=data["body"],
+            score=data["score"],
+            created_utc=data["created_utc"],
+            parent_id=data["parent_id"],
+            link_id=data["link_id"],
+            depth=current_depth,
+            replies=replies,
+        )
+
+    async def get_comment(self, comment_id: str) -> Comment:
+        """Get a single comment by ID.
+
+        Args:
+            comment_id: Comment ID (with or without t1_ prefix)
+        """
+        if comment_id.startswith("t1_"):
+            comment_id = comment_id[3:]
+
+        data = await self._client.get(f"/by_id/t1_{comment_id}.json")
+        # Response is a list with [0] = post, [1] = comments
+        # The comment itself is nested in the listing
+        comment_data = data[1]["data"]["children"][0]["data"]
+        return self._parse_comment(comment_data, 0, 0)

reddit_cli/reddit/models.py

@@ -0,0 +1,51 @@
+from pydantic import BaseModel, Field
+
+
+class Post(BaseModel):
+    """Reddit post model."""
+
+    id: str
+    title: str
+    author: str
+    subreddit: str
+    score: int
+    num_comments: int
+    permalink: str
+    url: str
+    created_utc: float
+    selftext: str = ""
+
+    @property
+    def short_id(self) -> str:
+        """Return the post short ID (without prefix)."""
+        return self.id
+
+
+class Subreddit(BaseModel):
+    """Subreddit model."""
+
+    id: str
+    display_name: str
+    title: str
+    description: str
+    subscribers: int
+    active_users: int = Field(default=0, validation_alias="accounts_active")
+
+
+class Comment(BaseModel):
+    """Reddit comment model."""
+
+    id: str
+    author: str
+    body: str
+    score: int
+    created_utc: float
+    parent_id: str
+    link_id: str
+    depth: int = 0
+    replies: list["Comment"] = []
+
+    @property
+    def short_id(self) -> str:
+        """Return the comment short ID (without prefix)."""
+        return self.id

reddit_cli/reddit/posts.py

@@ -0,0 +1,61 @@
+from reddit_cli.reddit.base import RedditClient
+from reddit_cli.reddit.models import Post
+
+
+class PostsClient:
+    """Client for Reddit post endpoints."""
+
+    def __init__(self, client: RedditClient) -> None:
+        self._client = client
+
+    async def list_posts(
+        self,
+        subreddit: str,
+        sort: str = "hot",
+        limit: int = 25,
+        period: str | None = None,
+        after: str | None = None,
+        before: str | None = None,
+    ) -> tuple[list[Post], str | None, str | None]:
+        """List posts from a subreddit.
+
+        Args:
+            subreddit: Subreddit name (without r/)
+            sort: Sort type (hot, new, top, rising, controversial, gilded)
+            limit: Number of posts to return (max 100)
+            period: Time period for top/controversial (day, week, month, year, all)
+            after: Pagination cursor (get posts after this ID)
+            before: Pagination cursor (get posts before this ID)
+
+        Returns:
+            Tuple of (posts, after_cursor, before_cursor)
+        """
+        path = f"/r/{subreddit}/{sort}.json"
+
+        params: dict[str, int | str] = {"limit": limit}
+        if period and sort in ("top", "controversial"):
+            params["t"] = period
+        if after:
+            params["after"] = after
+        if before:
+            params["before"] = before
+
+        data = await self._client.get(path, params=params)
+        posts = data.get("data", {}).get("children", [])
+        after_cursor = data.get("data", {}).get("after")
+        before_cursor = data.get("data", {}).get("before")
+
+        return [Post(**post["data"]) for post in posts], after_cursor, before_cursor
+
+    async def get_post(self, post_id: str) -> Post:
+        """Get a single post by ID.
+
+        Args:
+            post_id: Post ID (with or without t3_ prefix)
+        """
+        if post_id.startswith("t3_"):
+            post_id = post_id[3:]
+
+        # We need the subreddit to fetch the post, so we search by id first
+        data = await self._client.get(f"/by_id/t3_{post_id}.json")
+        return Post(**data["data"]["children"][0]["data"])

reddit_cli/reddit/subreddits.py

@@ -0,0 +1,63 @@
+from reddit_cli.reddit.base import RedditClient
+from reddit_cli.reddit.models import Subreddit
+
+
+class SubredditsClient:
+    """Client for Reddit subreddit endpoints."""
+
+    def __init__(self, client: RedditClient) -> None:
+        self._client = client
+
+    async def get_subreddit(self, name: str) -> Subreddit:
+        """Get subreddit info.
+
+        Args:
+            name: Subreddit name (with or without r/ prefix)
+        """
+        if name.startswith("r/"):
+            name = name[2:]
+
+        data = await self._client.get(f"/r/{name}/about.json")
+        return Subreddit(**data["data"])
+
+    async def get_rules(self, name: str) -> dict:
+        """Get subreddit rules.
+
+        Args:
+            name: Subreddit name (with or without r/ prefix)
+        """
+        if name.startswith("r/"):
+            name = name[2:]
+
+        data = await self._client.get(f"/r/{name}/about/rules.json")
+        return data
+
+    async def get_moderators(self, name: str) -> list[dict]:
+        """Get subreddit moderators.
+
+        Args:
+            name: Subreddit name (with or without r/ prefix)
+        """
+        if name.startswith("r/"):
+            name = name[2:]
+
+        data = await self._client.get(f"/r/{name}/about/moderators.json")
+        return data["data"]["children"]
+
+    async def list_subreddits(
+        self,
+        sort: str = "subscribers",
+        limit: int = 25,
+    ) -> list[Subreddit]:
+        """List popular subreddits.
+
+        Args:
+            sort: Sort type (subscribers, active)
+            limit: Number of subreddits to return
+        """
+        path = "/subreddits.json"
+        params: dict[str, int | str] = {"limit": limit, "sort": sort}
+
+        data = await self._client.get(path, params=params)
+        subreddits = data.get("data", {}).get("children", [])
+        return [Subreddit(**sub["data"]) for sub in subreddits]