jike-cli 0.1.0__tar.gz

jike_cli-0.1.0/LICENSE

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

jike_cli-0.1.0/PKG-INFO

@@ -0,0 +1,104 @@
+Metadata-Version: 2.4
+Name: jike-cli
+Version: 0.1.0
+Summary: A CLI tool for Jike (即刻) social network
+Project-URL: Homepage, https://github.com/case/jike-cli
+Project-URL: Repository, https://github.com/case/jike-cli
+Author: cypggsai
+License-Expression: MIT
+License-File: LICENSE
+Keywords: cli,jike,social,即刻
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Communications
+Requires-Python: >=3.10
+Requires-Dist: click>=8.0
+Requires-Dist: qrcode>=7.0
+Requires-Dist: requests>=2.28
+Requires-Dist: rich>=13.0
+Description-Content-Type: text/markdown
+
+# jike-cli
+
+A CLI tool for [Jike (即刻)](https://www.okjike.com) social network.
+
+## Install
+
+```bash
+# via uv
+uv tool install jike-cli
+
+# via pipx
+pipx install jike-cli
+
+# via pip
+pip install jike-cli
+```
+
+## Usage
+
+### Login
+
+```bash
+jike login    # Scan QR code with Jike app
+jike logout   # Clear saved tokens
+```
+
+### Browse
+
+```bash
+jike feed              # View following feed
+jike feed -n 10        # Limit to 10 posts
+jike search "AI"       # Search posts
+jike notifications     # View notifications
+```
+
+### Post
+
+```bash
+jike post "Hello from CLI!"    # Create a post
+jike delete-post POST_ID       # Delete a post
+```
+
+### Comments
+
+```bash
+jike comment POST_ID "Nice!"       # Add comment
+jike delete-comment COMMENT_ID     # Delete comment
+```
+
+### Users
+
+```bash
+jike profile USERNAME          # View profile
+jike followers USER_ID         # List followers
+jike following USER_ID         # List following
+```
+
+### JSON Output
+
+All read commands support `--json` for machine-readable output:
+
+```bash
+jike feed --json | jq '.[] | .content'
+```
+
+Non-TTY output (pipes) automatically uses JSON format.
+
+## Development
+
+```bash
+git clone https://github.com/case/jike-cli
+cd jike-cli
+pip install -e .
+```
+
+## License
+
+MIT

jike_cli-0.1.0/README.md

@@ -0,0 +1,78 @@
+# jike-cli
+
+A CLI tool for [Jike (即刻)](https://www.okjike.com) social network.
+
+## Install
+
+```bash
+# via uv
+uv tool install jike-cli
+
+# via pipx
+pipx install jike-cli
+
+# via pip
+pip install jike-cli
+```
+
+## Usage
+
+### Login
+
+```bash
+jike login    # Scan QR code with Jike app
+jike logout   # Clear saved tokens
+```
+
+### Browse
+
+```bash
+jike feed              # View following feed
+jike feed -n 10        # Limit to 10 posts
+jike search "AI"       # Search posts
+jike notifications     # View notifications
+```
+
+### Post
+
+```bash
+jike post "Hello from CLI!"    # Create a post
+jike delete-post POST_ID       # Delete a post
+```
+
+### Comments
+
+```bash
+jike comment POST_ID "Nice!"       # Add comment
+jike delete-comment COMMENT_ID     # Delete comment
+```
+
+### Users
+
+```bash
+jike profile USERNAME          # View profile
+jike followers USER_ID         # List followers
+jike following USER_ID         # List following
+```
+
+### JSON Output
+
+All read commands support `--json` for machine-readable output:
+
+```bash
+jike feed --json | jq '.[] | .content'
+```
+
+Non-TTY output (pipes) automatically uses JSON format.
+
+## Development
+
+```bash
+git clone https://github.com/case/jike-cli
+cd jike-cli
+pip install -e .
+```
+
+## License
+
+MIT

jike_cli-0.1.0/pyproject.toml

@@ -0,0 +1,37 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "jike-cli"
+version = "0.1.0"
+description = "A CLI tool for Jike (即刻) social network"
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.10"
+authors = [{ name = "cypggsai" }]
+keywords = ["jike", "即刻", "cli", "social"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Environment :: Console",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Communications",
+]
+dependencies = [
+    "click>=8.0",
+    "rich>=13.0",
+    "requests>=2.28",
+    "qrcode>=7.0",
+]
+
+[project.scripts]
+jike = "jike_cli.cli:cli"
+
+[project.urls]
+Homepage = "https://github.com/case/jike-cli"
+Repository = "https://github.com/case/jike-cli"

jike_cli-0.1.0/src/jike_cli/__init__.py

@@ -0,0 +1,3 @@
+"""jike-cli — Jike (即刻) social network CLI."""
+
+__version__ = "0.1.0"

jike_cli-0.1.0/src/jike_cli/__main__.py

@@ -0,0 +1,5 @@
+"""Allow running as `python -m jike_cli`."""
+
+from jike_cli.cli import cli
+
+cli()

jike_cli-0.1.0/src/jike_cli/_jike/__init__.py

@@ -0,0 +1,7 @@
+"""Vendored jike-skill — Jike API client (MIT license, from imHw/jike-skill)."""
+
+from .auth import authenticate, refresh_tokens
+from .client import JikeClient
+from .types import TokenPair
+
+__all__ = ["JikeClient", "TokenPair", "authenticate", "refresh_tokens"]

jike_cli-0.1.0/src/jike_cli/_jike/auth.py

@@ -0,0 +1,133 @@
+"""Jike QR Authentication — scan-to-login flow."""
+
+import json
+import sys
+import time
+import urllib.parse
+from typing import Optional
+
+import requests
+
+from .types import API_BASE, DEFAULT_HEADERS, TokenPair
+
+POLL_INTERVAL_SEC = 1
+POLL_TIMEOUT_SEC = 180
+
+
+def _post(path: str, headers: Optional[dict] = None, **kwargs) -> requests.Response:
+    merged = {**DEFAULT_HEADERS, "Content-Type": "application/json"}
+    if headers:
+        merged.update(headers)
+    return requests.post(f"{API_BASE}{path}", headers=merged, **kwargs)
+
+
+def _get(path: str) -> requests.Response:
+    return requests.get(f"{API_BASE}{path}", headers={**DEFAULT_HEADERS})
+
+
+def create_session() -> str:
+    resp = _post("/sessions.create")
+    resp.raise_for_status()
+    return resp.json()["uuid"]
+
+
+def build_qr_payload(uuid: str) -> str:
+    scan_url = f"https://www.okjike.com/account/scan?uuid={uuid}"
+    return (
+        "jike://page.jk/web?url="
+        + urllib.parse.quote(scan_url, safe="")
+        + "&displayHeader=false&displayFooter=false"
+    )
+
+
+def render_qr(data: str) -> bool:
+    try:
+        import qrcode
+
+        qr = qrcode.QRCode(border=1)
+        qr.add_data(data)
+        qr.make(fit=True)
+        qr.print_ascii(out=sys.stderr)
+        return True
+    except ImportError:
+        return False
+
+
+def _extract_tokens(resp: requests.Response) -> Optional[TokenPair]:
+    body: dict = {}
+    try:
+        body = resp.json()
+    except (ValueError, KeyError):
+        pass
+
+    access = (
+        body.get("x-jike-access-token")
+        or body.get("access_token")
+        or resp.headers.get("x-jike-access-token")
+    )
+    refresh = (
+        body.get("x-jike-refresh-token")
+        or body.get("refresh_token")
+        or resp.headers.get("x-jike-refresh-token")
+    )
+
+    if access and refresh:
+        return TokenPair(access_token=access, refresh_token=refresh)
+    return None
+
+
+def poll_confirmation(uuid: str) -> Optional[TokenPair]:
+    attempts = POLL_TIMEOUT_SEC // POLL_INTERVAL_SEC
+
+    for _ in range(attempts):
+        try:
+            resp = _get(f"/sessions.wait_for_confirmation?uuid={uuid}")
+        except requests.RequestException:
+            time.sleep(POLL_INTERVAL_SEC)
+            continue
+
+        if resp.status_code == 200:
+            return _extract_tokens(resp)
+
+        if resp.status_code == 400:
+            time.sleep(POLL_INTERVAL_SEC)
+            continue
+
+        time.sleep(POLL_INTERVAL_SEC)
+
+    return None
+
+
+def refresh_tokens(token_pair: TokenPair) -> TokenPair:
+    resp = _post(
+        "/app_auth_tokens.refresh",
+        headers={"x-jike-refresh-token": token_pair.refresh_token},
+        json={},
+    )
+    resp.raise_for_status()
+
+    return TokenPair(
+        access_token=resp.headers.get(
+            "x-jike-access-token", token_pair.access_token
+        ),
+        refresh_token=resp.headers.get(
+            "x-jike-refresh-token", token_pair.refresh_token
+        ),
+    )
+
+
+def authenticate() -> TokenPair:
+    uuid = create_session()
+
+    qr_payload = build_qr_payload(uuid)
+    if not render_qr(qr_payload):
+        print("Install 'qrcode' for terminal QR code.", file=sys.stderr)
+        print(f"Or open: {qr_payload}", file=sys.stderr)
+
+    tokens = poll_confirmation(uuid)
+    if not tokens:
+        print("Timeout — no scan detected.", file=sys.stderr)
+        sys.exit(1)
+
+    tokens = refresh_tokens(tokens)
+    return tokens

jike_cli-0.1.0/src/jike_cli/_jike/client.py

@@ -0,0 +1,139 @@
+"""Jike API Client — feed, posts, comments, search, profiles, notifications."""
+
+from typing import Optional
+
+import requests
+
+from .types import API_BASE, DEFAULT_HEADERS, TokenPair
+
+
+class JikeClient:
+    """Jike API client with automatic token refresh on 401."""
+
+    def __init__(self, tokens: TokenPair):
+        self._tokens = tokens
+
+    @property
+    def tokens(self) -> TokenPair:
+        return self._tokens
+
+    def _headers(self) -> dict:
+        return {
+            **DEFAULT_HEADERS,
+            "Content-Type": "application/json",
+            "x-jike-access-token": self._tokens.access_token,
+        }
+
+    def _request(
+        self, method: str, path: str, retry_on_401: bool = True, **kwargs
+    ) -> dict:
+        resp = requests.request(
+            method, f"{API_BASE}{path}", headers=self._headers(), **kwargs
+        )
+
+        if resp.status_code == 401 and retry_on_401:
+            self._refresh()
+            return self._request(method, path, retry_on_401=False, **kwargs)
+
+        resp.raise_for_status()
+        return resp.json() if resp.content else {}
+
+    def _refresh(self) -> None:
+        resp = requests.post(
+            f"{API_BASE}/app_auth_tokens.refresh",
+            headers={
+                **DEFAULT_HEADERS,
+                "Content-Type": "application/json",
+                "x-jike-refresh-token": self._tokens.refresh_token,
+            },
+            json={},
+        )
+        resp.raise_for_status()
+        self._tokens = TokenPair(
+            access_token=resp.headers.get(
+                "x-jike-access-token", self._tokens.access_token
+            ),
+            refresh_token=resp.headers.get(
+                "x-jike-refresh-token", self._tokens.refresh_token
+            ),
+        )
+
+    def feed(self, limit: int = 20, load_more_key: Optional[str] = None) -> dict:
+        body: dict[str, object] = {"limit": limit}
+        if load_more_key:
+            body["loadMoreKey"] = load_more_key
+        return self._request(
+            "POST", "/1.0/personalUpdate/followingUpdates", json=body
+        )
+
+    def get_post(self, post_id: str) -> dict:
+        return self._request("GET", f"/1.0/originalPosts/get?id={post_id}")
+
+    def create_post(self, content: str, picture_keys: Optional[list] = None) -> dict:
+        return self._request(
+            "POST",
+            "/1.0/originalPosts/create",
+            json={"content": content, "pictureKeys": picture_keys or []},
+        )
+
+    def delete_post(self, post_id: str) -> dict:
+        return self._request(
+            "POST", "/1.0/originalPosts/remove", json={"id": post_id}
+        )
+
+    def add_comment(self, post_id: str, content: str) -> dict:
+        return self._request(
+            "POST",
+            "/1.0/comments/add",
+            json={
+                "targetType": "ORIGINAL_POST",
+                "targetId": post_id,
+                "content": content,
+                "syncToPersonalUpdates": False,
+                "pictureKeys": [],
+                "force": False,
+            },
+        )
+
+    def delete_comment(self, comment_id: str) -> dict:
+        return self._request(
+            "POST",
+            "/1.0/comments/remove",
+            json={"id": comment_id, "targetType": "ORIGINAL_POST"},
+        )
+
+    def search(
+        self, keyword: str, limit: int = 20, load_more_key: Optional[str] = None
+    ) -> dict:
+        body: dict[str, object] = {"keyword": keyword, "limit": limit}
+        if load_more_key:
+            body["loadMoreKey"] = load_more_key
+        return self._request("POST", "/1.0/search/integrate", json=body)
+
+    def profile(self, username: str) -> dict:
+        return self._request("GET", f"/1.0/users/profile?username={username}")
+
+    def followers(self, user_id: str, load_more_key: Optional[str] = None) -> dict:
+        body: dict[str, object] = {"userId": user_id}
+        if load_more_key:
+            body["loadMoreKey"] = load_more_key
+        return self._request(
+            "POST", "/1.0/userRelation/getFollowerList", json=body
+        )
+
+    def following(self, user_id: str, load_more_key: Optional[str] = None) -> dict:
+        body: dict[str, object] = {"userId": user_id}
+        if load_more_key:
+            body["loadMoreKey"] = load_more_key
+        return self._request(
+            "POST", "/1.0/userRelation/getFollowingList", json=body
+        )
+
+    def unread_notifications(self) -> dict:
+        return self._request("GET", "/1.0/notifications/unread")
+
+    def list_notifications(self, load_more_key: Optional[str] = None) -> dict:
+        body: dict[str, object] = {}
+        if load_more_key:
+            body["loadMoreKey"] = load_more_key
+        return self._request("POST", "/1.0/notifications/list", json=body)

jike_cli-0.1.0/src/jike_cli/_jike/types.py

@@ -0,0 +1,28 @@
+"""Shared types for the Jike client."""
+
+from dataclasses import dataclass
+
+API_BASE = "https://api.ruguoapp.com"
+
+DEFAULT_HEADERS = {
+    "Origin": "https://web.okjike.com",
+    "User-Agent": (
+        "Mozilla/5.0 (iPhone; CPU iPhone OS 18_5 like Mac OS X) "
+        "AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.5 "
+        "Mobile/15E148 Safari/604.1"
+    ),
+    "Accept": "application/json, text/plain, */*",
+    "DNT": "1",
+}
+
+
+@dataclass(frozen=True)
+class TokenPair:
+    access_token: str
+    refresh_token: str
+
+    def to_dict(self) -> dict[str, str]:
+        return {
+            "access_token": self.access_token,
+            "refresh_token": self.refresh_token,
+        }

jike_cli-0.1.0/src/jike_cli/auth.py

@@ -0,0 +1,35 @@
+"""Token persistence — save/load/clear tokens to ~/.config/jike-cli/tokens.json."""
+
+import json
+import os
+from pathlib import Path
+from typing import Optional
+
+from jike_cli._jike import TokenPair
+
+CONFIG_DIR = Path(os.environ.get("JIKE_CLI_CONFIG_DIR", Path.home() / ".config" / "jike-cli"))
+TOKEN_FILE = CONFIG_DIR / "tokens.json"
+
+
+def save_tokens(tokens: TokenPair) -> None:
+    CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+    TOKEN_FILE.write_text(json.dumps(tokens.to_dict(), indent=2))
+    TOKEN_FILE.chmod(0o600)
+
+
+def load_tokens() -> Optional[TokenPair]:
+    if not TOKEN_FILE.exists():
+        return None
+    try:
+        data = json.loads(TOKEN_FILE.read_text())
+        return TokenPair(
+            access_token=data["access_token"],
+            refresh_token=data["refresh_token"],
+        )
+    except (json.JSONDecodeError, KeyError):
+        return None
+
+
+def clear_tokens() -> None:
+    if TOKEN_FILE.exists():
+        TOKEN_FILE.unlink()

jike_cli-0.1.0/src/jike_cli/cli.py

@@ -0,0 +1,265 @@
+"""Click command group — all jike CLI commands."""
+
+import sys
+
+import click
+import requests
+
+from jike_cli import __version__
+from jike_cli._jike import JikeClient, TokenPair, authenticate
+from jike_cli.auth import clear_tokens, load_tokens, save_tokens
+from jike_cli.formatter import (
+    console,
+    render_comment,
+    render_notifications,
+    render_posts,
+    render_user,
+    render_user_list,
+)
+from jike_cli.models import (
+    Comment,
+    Post,
+    User,
+    parse_feed,
+    parse_notifications,
+    parse_search,
+    parse_user_list,
+)
+from jike_cli.output import is_tty, print_json
+
+
+def _get_client() -> JikeClient:
+    tokens = load_tokens()
+    if not tokens:
+        console.print("[red]Not logged in. Run `jike login` first.[/red]", file=sys.stderr)
+        raise SystemExit(1)
+    return JikeClient(tokens)
+
+
+def _save_refreshed_tokens(client: JikeClient) -> None:
+    """Persist tokens if they were refreshed during the request."""
+    save_tokens(client.tokens)
+
+
+def _use_json(json_flag: bool) -> bool:
+    return json_flag or not is_tty()
+
+
+@click.group()
+@click.version_option(__version__, prog_name="jike")
+def cli() -> None:
+    """Jike (即刻) social network CLI."""
+
+
+@cli.command()
+def login() -> None:
+    """Login via QR code scan."""
+    console.print("[bold]Scan the QR code with Jike app...[/bold]")
+    try:
+        tokens = authenticate()
+        save_tokens(tokens)
+        console.print("[green]Login successful![/green]")
+    except requests.HTTPError as e:
+        console.print(f"[red]Login failed: {e}[/red]", file=sys.stderr)
+        raise SystemExit(1)
+
+
+@cli.command()
+def logout() -> None:
+    """Clear saved tokens."""
+    clear_tokens()
+    console.print("Logged out.")
+
+
+@cli.command()
+@click.option("-n", "--limit", default=20, help="Number of posts to fetch.")
+@click.option("--json", "json_flag", is_flag=True, help="Output as JSON.")
+def feed(limit: int, json_flag: bool) -> None:
+    """View your following feed."""
+    client = _get_client()
+    try:
+        data = client.feed(limit=limit)
+        _save_refreshed_tokens(client)
+        posts = parse_feed(data)
+        if _use_json(json_flag):
+            print_json(posts)
+        else:
+            render_posts(posts)
+    except requests.HTTPError as e:
+        console.print(f"[red]Error: {e}[/red]", file=sys.stderr)
+        raise SystemExit(1)
+
+
+@cli.command()
+@click.argument("content")
+@click.option("--json", "json_flag", is_flag=True, help="Output as JSON.")
+def post(content: str, json_flag: bool) -> None:
+    """Create a new post."""
+    client = _get_client()
+    try:
+        data = client.create_post(content)
+        _save_refreshed_tokens(client)
+        if _use_json(json_flag):
+            print_json(data)
+        else:
+            console.print("[green]Post created![/green]")
+            p = Post.from_api(data.get("data", data))
+            if p.id:
+                console.print(f"[dim]ID: {p.id}[/dim]")
+    except requests.HTTPError as e:
+        console.print(f"[red]Error: {e}[/red]", file=sys.stderr)
+        raise SystemExit(1)
+
+
+@cli.command("delete-post")
+@click.argument("post_id")
+def delete_post(post_id: str) -> None:
+    """Delete a post by ID."""
+    client = _get_client()
+    try:
+        client.delete_post(post_id)
+        _save_refreshed_tokens(client)
+        console.print("[green]Post deleted.[/green]")
+    except requests.HTTPError as e:
+        console.print(f"[red]Error: {e}[/red]", file=sys.stderr)
+        raise SystemExit(1)
+
+
+@cli.command()
+@click.argument("post_id")
+@click.argument("content")
+@click.option("--json", "json_flag", is_flag=True, help="Output as JSON.")
+def comment(post_id: str, content: str, json_flag: bool) -> None:
+    """Add a comment to a post."""
+    client = _get_client()
+    try:
+        data = client.add_comment(post_id, content)
+        _save_refreshed_tokens(client)
+        if _use_json(json_flag):
+            print_json(data)
+        else:
+            console.print("[green]Comment added![/green]")
+            c = Comment.from_api(data.get("data", data))
+            if c.id:
+                console.print(f"[dim]ID: {c.id}[/dim]")
+    except requests.HTTPError as e:
+        console.print(f"[red]Error: {e}[/red]", file=sys.stderr)
+        raise SystemExit(1)
+
+
+@cli.command("delete-comment")
+@click.argument("comment_id")
+def delete_comment(comment_id: str) -> None:
+    """Delete a comment by ID."""
+    client = _get_client()
+    try:
+        client.delete_comment(comment_id)
+        _save_refreshed_tokens(client)
+        console.print("[green]Comment deleted.[/green]")
+    except requests.HTTPError as e:
+        console.print(f"[red]Error: {e}[/red]", file=sys.stderr)
+        raise SystemExit(1)
+
+
+@cli.command()
+@click.argument("keyword")
+@click.option("-n", "--limit", default=20, help="Number of results.")
+@click.option("--json", "json_flag", is_flag=True, help="Output as JSON.")
+def search(keyword: str, limit: int, json_flag: bool) -> None:
+    """Search for posts."""
+    client = _get_client()
+    try:
+        data = client.search(keyword, limit=limit)
+        _save_refreshed_tokens(client)
+        posts = parse_search(data)
+        if _use_json(json_flag):
+            print_json(posts)
+        else:
+            render_posts(posts)
+    except requests.HTTPError as e:
+        console.print(f"[red]Error: {e}[/red]", file=sys.stderr)
+        raise SystemExit(1)
+
+
+@cli.command()
+@click.argument("username")
+@click.option("--json", "json_flag", is_flag=True, help="Output as JSON.")
+def profile(username: str, json_flag: bool) -> None:
+    """View a user's profile."""
+    client = _get_client()
+    try:
+        data = client.profile(username)
+        _save_refreshed_tokens(client)
+        user = User.from_api(data.get("user", data))
+        if _use_json(json_flag):
+            print_json(user)
+        else:
+            render_user(user)
+    except requests.HTTPError as e:
+        console.print(f"[red]Error: {e}[/red]", file=sys.stderr)
+        raise SystemExit(1)
+
+
+@cli.command()
+@click.argument("user_id")
+@click.option("--json", "json_flag", is_flag=True, help="Output as JSON.")
+def followers(user_id: str, json_flag: bool) -> None:
+    """List a user's followers."""
+    client = _get_client()
+    try:
+        data = client.followers(user_id)
+        _save_refreshed_tokens(client)
+        users = parse_user_list(data)
+        if _use_json(json_flag):
+            print_json(users)
+        else:
+            render_user_list(users, title="Followers")
+    except requests.HTTPError as e:
+        console.print(f"[red]Error: {e}[/red]", file=sys.stderr)
+        raise SystemExit(1)
+
+
+@cli.command()
+@click.argument("user_id")
+@click.option("--json", "json_flag", is_flag=True, help="Output as JSON.")
+def following(user_id: str, json_flag: bool) -> None:
+    """List users someone is following."""
+    client = _get_client()
+    try:
+        data = client.following(user_id)
+        _save_refreshed_tokens(client)
+        users = parse_user_list(data)
+        if _use_json(json_flag):
+            print_json(users)
+        else:
+            render_user_list(users, title="Following")
+    except requests.HTTPError as e:
+        console.print(f"[red]Error: {e}[/red]", file=sys.stderr)
+        raise SystemExit(1)
+
+
+@cli.command()
+@click.option("--unread-only", is_flag=True, help="Show only unread count.")
+@click.option("--json", "json_flag", is_flag=True, help="Output as JSON.")
+def notifications(unread_only: bool, json_flag: bool) -> None:
+    """View notifications."""
+    client = _get_client()
+    try:
+        if unread_only:
+            data = client.unread_notifications()
+            _save_refreshed_tokens(client)
+            if _use_json(json_flag):
+                print_json(data)
+            else:
+                console.print(f"Unread notifications: [bold]{data}[/bold]")
+        else:
+            data = client.list_notifications()
+            _save_refreshed_tokens(client)
+            notifs = parse_notifications(data)
+            if _use_json(json_flag):
+                print_json(notifs)
+            else:
+                render_notifications(notifs)
+    except requests.HTTPError as e:
+        console.print(f"[red]Error: {e}[/red]", file=sys.stderr)
+        raise SystemExit(1)

jike_cli-0.1.0/src/jike_cli/formatter.py

@@ -0,0 +1,124 @@
+"""Rich terminal rendering — tables, panels, formatted output."""
+
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+from rich.text import Text
+
+from jike_cli.models import Comment, Notification, Post, User
+
+console = Console()
+
+
+def _fmt_count(n: int) -> str:
+    if n >= 10000:
+        return f"{n / 10000:.1f}w"
+    if n >= 1000:
+        return f"{n / 1000:.1f}k"
+    return str(n)
+
+
+def _truncate(s: str, max_len: int = 80) -> str:
+    if len(s) <= max_len:
+        return s
+    return s[: max_len - 1] + "…"
+
+
+def render_post(post: Post) -> None:
+    name = post.user.screen_name if post.user else "Unknown"
+    username = f"@{post.user.username}" if post.user else ""
+
+    header = Text()
+    header.append(name, style="bold cyan")
+    header.append(f" {username}", style="dim")
+    header.append(f"  {post.created_at[:10]}", style="dim")
+
+    content = post.content or "(no content)"
+    if post.link_title:
+        content += f"\n🔗 {post.link_title}"
+
+    stats = (
+        f"❤ {_fmt_count(post.like_count)}  "
+        f"💬 {_fmt_count(post.comment_count)}  "
+        f"🔄 {_fmt_count(post.share_count)}"
+    )
+
+    panel = Panel(
+        f"{content}\n\n[dim]{stats}[/dim]",
+        title=header,
+        subtitle=f"[dim]{post.id}[/dim]",
+        border_style="blue",
+        padding=(0, 1),
+    )
+    console.print(panel)
+
+
+def render_posts(posts: list[Post]) -> None:
+    if not posts:
+        console.print("[dim]No posts found.[/dim]")
+        return
+    for post in posts:
+        render_post(post)
+
+
+def render_user(user: User) -> None:
+    table = Table(show_header=False, box=None, padding=(0, 2))
+    table.add_column(style="bold")
+    table.add_column()
+
+    table.add_row("Name", user.screen_name)
+    table.add_row("Username", f"@{user.username}")
+    table.add_row("ID", user.id)
+    if user.bio:
+        table.add_row("Bio", user.bio)
+    if user.gender:
+        table.add_row("Gender", user.gender)
+    table.add_row("Followers", _fmt_count(user.followers_count))
+    table.add_row("Following", _fmt_count(user.following_count))
+
+    panel = Panel(table, title="[bold cyan]Profile[/bold cyan]", border_style="blue")
+    console.print(panel)
+
+
+def render_user_list(users: list[User], title: str = "Users") -> None:
+    if not users:
+        console.print("[dim]No users found.[/dim]")
+        return
+
+    table = Table(title=title)
+    table.add_column("Name", style="cyan")
+    table.add_column("Username", style="dim")
+    table.add_column("Bio")
+
+    for u in users:
+        table.add_row(u.screen_name, f"@{u.username}", _truncate(u.bio, 50))
+
+    console.print(table)
+
+
+def render_notifications(notifications: list[Notification]) -> None:
+    if not notifications:
+        console.print("[dim]No notifications.[/dim]")
+        return
+
+    table = Table(title="Notifications")
+    table.add_column("Type", style="yellow")
+    table.add_column("From", style="cyan")
+    table.add_column("Content")
+    table.add_column("Time", style="dim")
+
+    for n in notifications:
+        name = n.user.screen_name if n.user else ""
+        table.add_row(n.type, name, _truncate(n.content, 60), n.created_at[:10])
+
+    console.print(table)
+
+
+def render_comment(comment: Comment) -> None:
+    name = comment.user.screen_name if comment.user else "Unknown"
+    console.print(
+        f"[bold cyan]{name}[/bold cyan] [dim]{comment.created_at[:10]}[/dim]"
+    )
+    console.print(f"  {comment.content}")
+    console.print(f"  [dim]❤ {_fmt_count(comment.like_count)}  ID: {comment.id}[/dim]")
+    console.print()

jike_cli-0.1.0/src/jike_cli/models.py

@@ -0,0 +1,191 @@
+"""Data models and API response parsers."""
+
+from dataclasses import dataclass, field
+from typing import Optional
+
+
+@dataclass
+class User:
+    id: str
+    username: str
+    screen_name: str
+    avatar_url: str = ""
+    bio: str = ""
+    gender: str = ""
+    is_following: bool = False
+    is_banned: bool = False
+    followers_count: int = 0
+    following_count: int = 0
+    highlights_count: int = 0
+
+    @classmethod
+    def from_api(cls, data: dict) -> "User":
+        return cls(
+            id=data.get("id", ""),
+            username=data.get("username", ""),
+            screen_name=data.get("screenName", ""),
+            avatar_url=data.get("avatarImage", {}).get("picUrl", "") if isinstance(data.get("avatarImage"), dict) else "",
+            bio=data.get("bio", ""),
+            gender=data.get("gender", ""),
+            is_following=data.get("following", False),
+            is_banned=data.get("isBanned", False),
+            followers_count=data.get("statsCount", {}).get("followedCount", 0) if isinstance(data.get("statsCount"), dict) else 0,
+            following_count=data.get("statsCount", {}).get("followingCount", 0) if isinstance(data.get("statsCount"), dict) else 0,
+            highlights_count=data.get("statsCount", {}).get("highlightedPersonalUpdates", 0) if isinstance(data.get("statsCount"), dict) else 0,
+        )
+
+    def to_dict(self) -> dict:
+        return {
+            "id": self.id,
+            "username": self.username,
+            "screen_name": self.screen_name,
+            "bio": self.bio,
+            "followers_count": self.followers_count,
+            "following_count": self.following_count,
+        }
+
+
+@dataclass
+class Post:
+    id: str
+    type: str
+    content: str
+    user: Optional[User] = None
+    created_at: str = ""
+    like_count: int = 0
+    comment_count: int = 0
+    share_count: int = 0
+    pictures: list[str] = field(default_factory=list)
+    link_url: str = ""
+    link_title: str = ""
+
+    @classmethod
+    def from_api(cls, data: dict) -> "Post":
+        user_data = data.get("user")
+        pictures = []
+        for pic in data.get("pictureKeys", []):
+            if isinstance(pic, str):
+                pictures.append(pic)
+        for pic in data.get("pictures", []):
+            if isinstance(pic, dict) and pic.get("picUrl"):
+                pictures.append(pic["picUrl"])
+
+        link_info = data.get("linkInfo") or {}
+
+        return cls(
+            id=data.get("id", ""),
+            type=data.get("type", "ORIGINAL_POST"),
+            content=data.get("content", ""),
+            user=User.from_api(user_data) if user_data else None,
+            created_at=data.get("createdAt", ""),
+            like_count=data.get("likeCount", 0),
+            comment_count=data.get("commentCount", 0),
+            share_count=data.get("shareCount", 0),
+            pictures=pictures,
+            link_url=link_info.get("linkUrl", ""),
+            link_title=link_info.get("title", ""),
+        )
+
+    def to_dict(self) -> dict:
+        return {
+            "id": self.id,
+            "type": self.type,
+            "content": self.content,
+            "user": self.user.to_dict() if self.user else None,
+            "created_at": self.created_at,
+            "like_count": self.like_count,
+            "comment_count": self.comment_count,
+            "share_count": self.share_count,
+            "pictures": self.pictures,
+            "link_url": self.link_url,
+            "link_title": self.link_title,
+        }
+
+
+@dataclass
+class Comment:
+    id: str
+    content: str
+    user: Optional[User] = None
+    created_at: str = ""
+    like_count: int = 0
+
+    @classmethod
+    def from_api(cls, data: dict) -> "Comment":
+        user_data = data.get("user")
+        return cls(
+            id=data.get("id", ""),
+            content=data.get("content", ""),
+            user=User.from_api(user_data) if user_data else None,
+            created_at=data.get("createdAt", ""),
+            like_count=data.get("likeCount", 0),
+        )
+
+    def to_dict(self) -> dict:
+        return {
+            "id": self.id,
+            "content": self.content,
+            "user": self.user.to_dict() if self.user else None,
+            "created_at": self.created_at,
+            "like_count": self.like_count,
+        }
+
+
+@dataclass
+class Notification:
+    id: str
+    type: str
+    content: str
+    user: Optional[User] = None
+    created_at: str = ""
+    referral_type: str = ""
+
+    @classmethod
+    def from_api(cls, data: dict) -> "Notification":
+        user_data = data.get("actionItem", {}).get("users", [None])[0] if data.get("actionItem", {}).get("users") else None
+        action = data.get("actionItem", {})
+        return cls(
+            id=data.get("id", ""),
+            type=data.get("type", ""),
+            content=action.get("content", "") or data.get("content", ""),
+            user=User.from_api(user_data) if user_data else None,
+            created_at=data.get("createdAt", ""),
+            referral_type=data.get("referralType", ""),
+        )
+
+    def to_dict(self) -> dict:
+        return {
+            "id": self.id,
+            "type": self.type,
+            "content": self.content,
+            "user": self.user.to_dict() if self.user else None,
+            "created_at": self.created_at,
+        }
+
+
+def parse_feed(data: dict) -> list[Post]:
+    posts = []
+    for item in data.get("data", []):
+        target = item
+        if item.get("type") == "REPOST" and item.get("target"):
+            target = item["target"]
+        posts.append(Post.from_api(target))
+    return posts
+
+
+def parse_search(data: dict) -> list[Post]:
+    posts = []
+    for item in data.get("data", []):
+        if item.get("type") in ("ORIGINAL_POST", "REPOST"):
+            posts.append(Post.from_api(item))
+        elif item.get("target"):
+            posts.append(Post.from_api(item["target"]))
+    return posts
+
+
+def parse_notifications(data: dict) -> list[Notification]:
+    return [Notification.from_api(n) for n in data.get("data", [])]
+
+
+def parse_user_list(data: dict) -> list[User]:
+    return [User.from_api(u) for u in data.get("data", [])]

jike_cli-0.1.0/src/jike_cli/output.py

@@ -0,0 +1,18 @@
+"""Output utilities — JSON mode, TTY detection."""
+
+import json
+import sys
+
+
+def is_tty() -> bool:
+    return sys.stdout.isatty()
+
+
+def print_json(data: object) -> None:
+    if isinstance(data, list):
+        output = [item.to_dict() if hasattr(item, "to_dict") else item for item in data]
+    elif hasattr(data, "to_dict"):
+        output = data.to_dict()
+    else:
+        output = data
+    print(json.dumps(output, ensure_ascii=False, indent=2))