blog-cli 0.1.0__tar.gz

blog_cli-0.1.0/PKG-INFO

@@ -0,0 +1,147 @@
+Metadata-Version: 2.4
+Name: blog-cli
+Version: 0.1.0
+Summary: Agent-friendly CLI for managing a blog. Create drafts, upload media, generate time-limited preview links.
+Author: tanaka-mambinge
+License: MIT
+Project-URL: Repository, https://github.com/tanaka-mambinge/personal
+Project-URL: Issues, https://github.com/tanaka-mambinge/personal/issues
+Keywords: blog,cli,agent,markdown,writing
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Internet :: WWW/HTTP
+Requires-Python: >=3.14
+Description-Content-Type: text/markdown
+Requires-Dist: httpx>=0.28
+Requires-Dist: typer>=0.16
+Provides-Extra: dev
+Requires-Dist: asgi-lifespan>=2.1; extra == "dev"
+Requires-Dist: fastapi>=0.115; extra == "dev"
+Requires-Dist: motor>=3.7; extra == "dev"
+Requires-Dist: pytest>=8.3; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.24; extra == "dev"
+Requires-Dist: pydantic>=2.10; extra == "dev"
+Requires-Dist: pydantic-settings>=2.6; extra == "dev"
+Requires-Dist: pymongo>=4.9; extra == "dev"
+Requires-Dist: python-multipart>=0.0.20; extra == "dev"
+Requires-Dist: uvicorn>=0.49; extra == "dev"
+
+# blog-cli
+
+Agent-friendly CLI for managing a personal blog. Create drafts, upload media, generate time-limited preview links — all from the command line.
+
+Designed for use by both humans and AI agents.
+
+## Install
+
+```bash
+pipx install blog-cli
+# or
+uv tool install blog-cli
+```
+
+For development:
+
+```bash
+git clone https://github.com/tanaka-mambinge/personal
+cd personal/blog-cli
+uv sync --extra dev
+```
+
+## Configure
+
+Set these env vars (e.g. in `~/.zshrc`):
+
+```bash
+export PERSONAL_SERVER_URL="https://api.personal.localhost:1355"
+export PERSONAL_API_KEY="your-api-key"
+export PERSONAL_SITE_URL="https://personal.localhost:1355"
+```
+
+Empty `PERSONAL_API_KEY` disables auth if your server has no key configured.
+
+## Usage
+
+### Articles
+
+```bash
+# Create a draft
+blog-cli article create \
+  --title "My Post" \
+  --description "A short summary" \
+  --type blog \
+  --markdown "# My Post\n\nHello."
+
+# List published blog posts
+blog-cli article list --type blog
+
+# Show an article
+blog-cli article show my-post
+
+# Update an article
+blog-cli article update my-post --title "Better Title"
+
+# Generate a 24h preview link for a draft
+blog-cli article preview my-post
+
+# Custom TTL (1–168 hours)
+blog-cli article preview my-post --ttl-hours 4
+
+# Publish
+blog-cli article publish my-post --published-by agent
+
+# Delete (soft)
+blog-cli article delete my-post
+
+# Unarchive (restore deleted)
+blog-cli article unarchive my-post
+```
+
+All commands support `--json` for machine-readable output and `--server-url` to override the server.
+
+### Media
+
+```bash
+# Upload (name is the unique key used in markdown)
+blog-cli media upload --name hero-image ./hero.jpg
+
+# Update (replace the file, keep the name)
+blog-cli media update --name hero-image ./new-hero.jpg
+
+# Delete (soft)
+blog-cli media delete --name hero-image
+```
+
+### Markdown Image References
+
+Upload media with a name, then reference it in article markdown:
+
+```markdown
+![Hero image](hero-image)
+
+<video controls width="100%" src="ambulance-video"></video>
+```
+
+The site resolves these to full URLs automatically.
+
+## Testing
+
+```bash
+uv run pytest -v
+```
+
+Spins up a temp MongoDB + server via test fixtures. No external deps needed.
+
+## Architecture
+
+```
+CLI (httpx) → FastAPI server → Motor/GridFS → MongoDB
+```
+
+- **Public endpoints** (GET) — list and read published articles, download media
+- **Protected endpoints** (POST/PATCH/PUT/DELETE) — require `Authorization: Bearer <key>`
+
+## License
+
+MIT

blog_cli-0.1.0/README.md

@@ -0,0 +1,118 @@
+# blog-cli
+
+Agent-friendly CLI for managing a personal blog. Create drafts, upload media, generate time-limited preview links — all from the command line.
+
+Designed for use by both humans and AI agents.
+
+## Install
+
+```bash
+pipx install blog-cli
+# or
+uv tool install blog-cli
+```
+
+For development:
+
+```bash
+git clone https://github.com/tanaka-mambinge/personal
+cd personal/blog-cli
+uv sync --extra dev
+```
+
+## Configure
+
+Set these env vars (e.g. in `~/.zshrc`):
+
+```bash
+export PERSONAL_SERVER_URL="https://api.personal.localhost:1355"
+export PERSONAL_API_KEY="your-api-key"
+export PERSONAL_SITE_URL="https://personal.localhost:1355"
+```
+
+Empty `PERSONAL_API_KEY` disables auth if your server has no key configured.
+
+## Usage
+
+### Articles
+
+```bash
+# Create a draft
+blog-cli article create \
+  --title "My Post" \
+  --description "A short summary" \
+  --type blog \
+  --markdown "# My Post\n\nHello."
+
+# List published blog posts
+blog-cli article list --type blog
+
+# Show an article
+blog-cli article show my-post
+
+# Update an article
+blog-cli article update my-post --title "Better Title"
+
+# Generate a 24h preview link for a draft
+blog-cli article preview my-post
+
+# Custom TTL (1–168 hours)
+blog-cli article preview my-post --ttl-hours 4
+
+# Publish
+blog-cli article publish my-post --published-by agent
+
+# Delete (soft)
+blog-cli article delete my-post
+
+# Unarchive (restore deleted)
+blog-cli article unarchive my-post
+```
+
+All commands support `--json` for machine-readable output and `--server-url` to override the server.
+
+### Media
+
+```bash
+# Upload (name is the unique key used in markdown)
+blog-cli media upload --name hero-image ./hero.jpg
+
+# Update (replace the file, keep the name)
+blog-cli media update --name hero-image ./new-hero.jpg
+
+# Delete (soft)
+blog-cli media delete --name hero-image
+```
+
+### Markdown Image References
+
+Upload media with a name, then reference it in article markdown:
+
+```markdown
+![Hero image](hero-image)
+
+<video controls width="100%" src="ambulance-video"></video>
+```
+
+The site resolves these to full URLs automatically.
+
+## Testing
+
+```bash
+uv run pytest -v
+```
+
+Spins up a temp MongoDB + server via test fixtures. No external deps needed.
+
+## Architecture
+
+```
+CLI (httpx) → FastAPI server → Motor/GridFS → MongoDB
+```
+
+- **Public endpoints** (GET) — list and read published articles, download media
+- **Protected endpoints** (POST/PATCH/PUT/DELETE) — require `Authorization: Bearer <key>`
+
+## License
+
+MIT

blog_cli-0.1.0/pyproject.toml

@@ -0,0 +1,58 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "blog-cli"
+version = "0.1.0"
+description = "Agent-friendly CLI for managing a blog. Create drafts, upload media, generate time-limited preview links."
+readme = "README.md"
+requires-python = ">=3.14"
+license = {text = "MIT"}
+authors = [{name = "tanaka-mambinge"}]
+keywords = ["blog", "cli", "agent", "markdown", "writing"]
+classifiers = [
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Topic :: Internet :: WWW/HTTP",
+]
+dependencies = [
+  "httpx>=0.28",
+  "typer>=0.16",
+]
+
+[project.urls]
+Repository = "https://github.com/tanaka-mambinge/personal"
+Issues = "https://github.com/tanaka-mambinge/personal/issues"
+
+[project.scripts]
+blog-cli = "personal_cli.cli:main"
+
+[project.optional-dependencies]
+dev = [
+  "asgi-lifespan>=2.1",
+  "fastapi>=0.115",
+  "motor>=3.7",
+  "pytest>=8.3",
+  "pytest-asyncio>=0.24",
+  "pydantic>=2.10",
+  "pydantic-settings>=2.6",
+  "pymongo>=4.9",
+  "python-multipart>=0.0.20",
+  "uvicorn>=0.49",
+]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+python_files = ["test_*.py"]
+asyncio_mode = "auto"
+
+[tool.uv]
+package = true
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+
+[tool.setuptools.packages.find]
+where = ["src"]

blog_cli-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

blog_cli-0.1.0/src/blog_cli.egg-info/PKG-INFO

@@ -0,0 +1,147 @@
+Metadata-Version: 2.4
+Name: blog-cli
+Version: 0.1.0
+Summary: Agent-friendly CLI for managing a blog. Create drafts, upload media, generate time-limited preview links.
+Author: tanaka-mambinge
+License: MIT
+Project-URL: Repository, https://github.com/tanaka-mambinge/personal
+Project-URL: Issues, https://github.com/tanaka-mambinge/personal/issues
+Keywords: blog,cli,agent,markdown,writing
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Internet :: WWW/HTTP
+Requires-Python: >=3.14
+Description-Content-Type: text/markdown
+Requires-Dist: httpx>=0.28
+Requires-Dist: typer>=0.16
+Provides-Extra: dev
+Requires-Dist: asgi-lifespan>=2.1; extra == "dev"
+Requires-Dist: fastapi>=0.115; extra == "dev"
+Requires-Dist: motor>=3.7; extra == "dev"
+Requires-Dist: pytest>=8.3; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.24; extra == "dev"
+Requires-Dist: pydantic>=2.10; extra == "dev"
+Requires-Dist: pydantic-settings>=2.6; extra == "dev"
+Requires-Dist: pymongo>=4.9; extra == "dev"
+Requires-Dist: python-multipart>=0.0.20; extra == "dev"
+Requires-Dist: uvicorn>=0.49; extra == "dev"
+
+# blog-cli
+
+Agent-friendly CLI for managing a personal blog. Create drafts, upload media, generate time-limited preview links — all from the command line.
+
+Designed for use by both humans and AI agents.
+
+## Install
+
+```bash
+pipx install blog-cli
+# or
+uv tool install blog-cli
+```
+
+For development:
+
+```bash
+git clone https://github.com/tanaka-mambinge/personal
+cd personal/blog-cli
+uv sync --extra dev
+```
+
+## Configure
+
+Set these env vars (e.g. in `~/.zshrc`):
+
+```bash
+export PERSONAL_SERVER_URL="https://api.personal.localhost:1355"
+export PERSONAL_API_KEY="your-api-key"
+export PERSONAL_SITE_URL="https://personal.localhost:1355"
+```
+
+Empty `PERSONAL_API_KEY` disables auth if your server has no key configured.
+
+## Usage
+
+### Articles
+
+```bash
+# Create a draft
+blog-cli article create \
+  --title "My Post" \
+  --description "A short summary" \
+  --type blog \
+  --markdown "# My Post\n\nHello."
+
+# List published blog posts
+blog-cli article list --type blog
+
+# Show an article
+blog-cli article show my-post
+
+# Update an article
+blog-cli article update my-post --title "Better Title"
+
+# Generate a 24h preview link for a draft
+blog-cli article preview my-post
+
+# Custom TTL (1–168 hours)
+blog-cli article preview my-post --ttl-hours 4
+
+# Publish
+blog-cli article publish my-post --published-by agent
+
+# Delete (soft)
+blog-cli article delete my-post
+
+# Unarchive (restore deleted)
+blog-cli article unarchive my-post
+```
+
+All commands support `--json` for machine-readable output and `--server-url` to override the server.
+
+### Media
+
+```bash
+# Upload (name is the unique key used in markdown)
+blog-cli media upload --name hero-image ./hero.jpg
+
+# Update (replace the file, keep the name)
+blog-cli media update --name hero-image ./new-hero.jpg
+
+# Delete (soft)
+blog-cli media delete --name hero-image
+```
+
+### Markdown Image References
+
+Upload media with a name, then reference it in article markdown:
+
+```markdown
+![Hero image](hero-image)
+
+<video controls width="100%" src="ambulance-video"></video>
+```
+
+The site resolves these to full URLs automatically.
+
+## Testing
+
+```bash
+uv run pytest -v
+```
+
+Spins up a temp MongoDB + server via test fixtures. No external deps needed.
+
+## Architecture
+
+```
+CLI (httpx) → FastAPI server → Motor/GridFS → MongoDB
+```
+
+- **Public endpoints** (GET) — list and read published articles, download media
+- **Protected endpoints** (POST/PATCH/PUT/DELETE) — require `Authorization: Bearer <key>`
+
+## License
+
+MIT

blog_cli-0.1.0/src/blog_cli.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+README.md
+pyproject.toml
+src/blog_cli.egg-info/PKG-INFO
+src/blog_cli.egg-info/SOURCES.txt
+src/blog_cli.egg-info/dependency_links.txt
+src/blog_cli.egg-info/entry_points.txt
+src/blog_cli.egg-info/requires.txt
+src/blog_cli.egg-info/top_level.txt
+src/personal_cli/__init__.py
+src/personal_cli/__main__.py
+src/personal_cli/cli.py
+src/personal_cli/client.py
+src/personal_cli/formatting.py
+tests/test_cli.py
+tests/test_client.py

blog_cli-0.1.0/src/blog_cli.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

blog_cli-0.1.0/src/blog_cli.egg-info/entry_points.txt

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

blog_cli-0.1.0/src/blog_cli.egg-info/requires.txt

@@ -0,0 +1,14 @@
+httpx>=0.28
+typer>=0.16
+
+[dev]
+asgi-lifespan>=2.1
+fastapi>=0.115
+motor>=3.7
+pytest>=8.3
+pytest-asyncio>=0.24
+pydantic>=2.10
+pydantic-settings>=2.6
+pymongo>=4.9
+python-multipart>=0.0.20
+uvicorn>=0.49

blog_cli-0.1.0/src/blog_cli.egg-info/top_level.txt

@@ -0,0 +1 @@
+personal_cli

blog_cli-0.1.0/src/personal_cli/__init__.py

@@ -0,0 +1,2 @@
+"""Personal article CLI."""
+

blog_cli-0.1.0/src/personal_cli/__main__.py

@@ -0,0 +1,6 @@
+from personal_cli.cli import main
+
+
+if __name__ == "__main__":
+    main()
+

blog_cli-0.1.0/src/personal_cli/cli.py

@@ -0,0 +1,243 @@
+from __future__ import annotations
+
+import asyncio
+from pathlib import Path
+
+import typer
+
+from personal_cli.client import ArticleApiClient, CLIError, get_default_config
+from personal_cli.formatting import emit_result, read_markdown_from_source
+
+app = typer.Typer(help="Agent-facing article CLI.")
+article_app = typer.Typer(help="Manage articles.")
+media_app = typer.Typer(help="Manage media uploads.")
+
+app.add_typer(article_app, name="article")
+app.add_typer(media_app, name="media")
+
+
+def build_client(server_url: str | None = None) -> ArticleApiClient:
+    url, api_key = get_default_config()
+    return ArticleApiClient(server_url or url, api_key=api_key)
+
+
+def run(coro):
+    return asyncio.run(coro)
+
+
+@article_app.command("list")
+def article_list(
+    type_filter: str = typer.Option("all", "--type", help="all, blog, or project."),
+    status: str | None = typer.Option(None, "--status", help="Filter by article status."),
+    json_output: bool = typer.Option(False, "--json", help="Emit JSON output."),
+    server_url: str | None = typer.Option(None, "--server-url", help="FastAPI base URL."),
+) -> None:
+    try:
+        client = build_client(server_url)
+        articles = run(client.list_articles(status=status, type_filter=type_filter))
+        emit_result(articles, json_output=json_output)
+    except CLIError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(code=1) from exc
+
+
+@article_app.command("show")
+def article_show(
+    slug: str,
+    json_output: bool = typer.Option(False, "--json", help="Emit JSON output."),
+    server_url: str | None = typer.Option(None, "--server-url", help="FastAPI base URL."),
+) -> None:
+    try:
+        client = build_client(server_url)
+        article = run(client.get_article(slug))
+        emit_result(article, json_output=json_output)
+    except CLIError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(code=1) from exc
+
+
+@article_app.command("create")
+def article_create(
+    title: str = typer.Option(..., "--title", help="Article title."),
+    description: str = typer.Option(..., "--description", help="Short summary."),
+    slug: str | None = typer.Option(None, "--slug", help="Optional slug override."),
+    tag: list[str] = typer.Option([], "--tag", help="Repeat for each tag."),
+    article_type: str = typer.Option(..., "--type", help="blog or project."),
+    status: str = typer.Option("draft", "--status", help="draft or published."),
+    markdown: str | None = typer.Option(None, "--markdown", help="Inline markdown body."),
+    markdown_file: Path | None = typer.Option(None, "--markdown-file", exists=True, readable=True, dir_okay=False),
+    json_output: bool = typer.Option(False, "--json", help="Emit JSON output."),
+    server_url: str | None = typer.Option(None, "--server-url", help="FastAPI base URL."),
+) -> None:
+    try:
+        body = read_markdown_from_source(markdown=markdown, markdown_file=markdown_file)
+        client = build_client(server_url)
+        payload = {
+            "title": title,
+            "description": description,
+            "slug": slug,
+            "tags": tag,
+            "type": article_type,
+            "status": status,
+            "markdown": body,
+        }
+        article = run(client.create_article(payload))
+        emit_result(article, json_output=json_output)
+    except CLIError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(code=1) from exc
+
+
+@article_app.command("update")
+def article_update(
+    slug: str,
+    title: str | None = typer.Option(None, "--title", help="New title."),
+    description: str | None = typer.Option(None, "--description", help="New summary."),
+    tag: list[str] | None = typer.Option(None, "--tag", help="Repeat for each tag."),
+    article_type: str | None = typer.Option(None, "--type", help="blog or project."),
+    status: str | None = typer.Option(None, "--status", help="draft or published."),
+    markdown: str | None = typer.Option(None, "--markdown", help="Inline markdown body."),
+    markdown_file: Path | None = typer.Option(None, "--markdown-file", exists=True, readable=True, dir_okay=False),
+    json_output: bool = typer.Option(False, "--json", help="Emit JSON output."),
+    server_url: str | None = typer.Option(None, "--server-url", help="FastAPI base URL."),
+) -> None:
+    try:
+        client = build_client(server_url)
+        payload: dict[str, object] = {}
+        if title is not None:
+            payload["title"] = title
+        if description is not None:
+            payload["description"] = description
+        if tag is not None:
+            payload["tags"] = tag
+        if article_type is not None:
+            payload["type"] = article_type
+        if status is not None:
+            payload["status"] = status
+        if markdown is not None or markdown_file is not None:
+            payload["markdown"] = read_markdown_from_source(markdown=markdown, markdown_file=markdown_file)
+        article = run(client.update_article(slug, payload))
+        emit_result(article, json_output=json_output)
+    except CLIError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(code=1) from exc
+
+
+@article_app.command("publish")
+def article_publish(
+    slug: str,
+    published_by: str | None = typer.Option(None, "--published-by", help="Who published the article."),
+    json_output: bool = typer.Option(False, "--json", help="Emit JSON output."),
+    server_url: str | None = typer.Option(None, "--server-url", help="FastAPI base URL."),
+) -> None:
+    try:
+        client = build_client(server_url)
+        article = run(client.publish_article(slug, {"published_by": published_by} if published_by else None))
+        emit_result(article, json_output=json_output)
+    except CLIError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(code=1) from exc
+
+
+@article_app.command("delete")
+def article_delete(
+    slug: str,
+    json_output: bool = typer.Option(False, "--json", help="Emit JSON output."),
+    server_url: str | None = typer.Option(None, "--server-url", help="FastAPI base URL."),
+) -> None:
+    try:
+        client = build_client(server_url)
+        result = run(client.delete_article(slug))
+        emit_result(result, json_output=json_output)
+    except CLIError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(code=1) from exc
+
+
+@article_app.command("unarchive")
+def article_unarchive(
+    slug: str,
+    json_output: bool = typer.Option(False, "--json", help="Emit JSON output."),
+    server_url: str | None = typer.Option(None, "--server-url", help="FastAPI base URL."),
+) -> None:
+    try:
+        client = build_client(server_url)
+        article = run(client.unarchive_article(slug))
+        emit_result(article, json_output=json_output)
+    except CLIError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(code=1) from exc
+
+
+@article_app.command("preview")
+def article_preview(
+    slug: str,
+    ttl_hours: int = typer.Option(24, "--ttl-hours", help="Hours until the preview link expires."),
+    site_url: str | None = typer.Option(None, "--site-url", help="Base URL of the personal site."),
+    json_output: bool = typer.Option(False, "--json", help="Emit JSON output."),
+    server_url: str | None = typer.Option(None, "--server-url", help="FastAPI base URL."),
+) -> None:
+    try:
+        import os
+        resolved_site_url = site_url or os.environ.get("PERSONAL_SITE_URL", "http://localhost:3000")
+        client = build_client(server_url)
+        result = run(client.generate_preview(slug, ttl_hours=ttl_hours, base_url=resolved_site_url))
+        emit_result(result, json_output=json_output)
+    except CLIError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(code=1) from exc
+
+
+@media_app.command("upload")
+def media_upload(
+    name: str = typer.Option(..., "--name", help="Unique name for the media (e.g. hero-image)."),
+    path: Path = typer.Argument(..., exists=True, file_okay=True, dir_okay=False, readable=True),
+    json_output: bool = typer.Option(False, "--json", help="Emit JSON output."),
+    server_url: str | None = typer.Option(None, "--server-url", help="FastAPI base URL."),
+) -> None:
+    try:
+        client = build_client(server_url)
+        result = run(client.upload_media(name, path))
+        emit_result(result, json_output=json_output)
+    except CLIError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(code=1) from exc
+
+
+@media_app.command("update")
+def media_update(
+    name: str = typer.Option(..., "--name", help="Name of the media to replace."),
+    path: Path = typer.Argument(..., exists=True, file_okay=True, dir_okay=False, readable=True),
+    json_output: bool = typer.Option(False, "--json", help="Emit JSON output."),
+    server_url: str | None = typer.Option(None, "--server-url", help="FastAPI base URL."),
+) -> None:
+    try:
+        client = build_client(server_url)
+        result = run(client.update_media(name, path))
+        emit_result(result, json_output=json_output)
+    except CLIError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(code=1) from exc
+
+
+@media_app.command("delete")
+def media_delete(
+    name: str = typer.Option(..., "--name", help="Name of the media to delete."),
+    json_output: bool = typer.Option(False, "--json", help="Emit JSON output."),
+    server_url: str | None = typer.Option(None, "--server-url", help="FastAPI base URL."),
+) -> None:
+    try:
+        client = build_client(server_url)
+        result = run(client.delete_media(name))
+        emit_result(result, json_output=json_output)
+    except CLIError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(code=1) from exc
+
+
+def main() -> None:
+    app()
+
+
+if __name__ == "__main__":
+    main()

blog_cli-0.1.0/src/personal_cli/client.py

@@ -0,0 +1,151 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+import httpx
+
+
+class CLIError(RuntimeError):
+    def __init__(self, message: str, *, status_code: int | None = None) -> None:
+        super().__init__(message)
+        self.status_code = status_code
+
+
+class ArticleApiClient:
+    def __init__(
+        self,
+        base_url: str,
+        *,
+        api_key: str | None = None,
+        transport: httpx.AsyncBaseTransport | None = None,
+        timeout: float = 30.0,
+    ) -> None:
+        self.base_url = base_url.rstrip("/")
+        self.api_key = api_key
+        self.transport = transport
+        self.timeout = timeout
+
+    def _headers(self) -> dict[str, str]:
+        if not self.api_key:
+            return {}
+        return {"Authorization": f"Bearer {self.api_key}"}
+
+    async def _request_json(
+        self,
+        method: str,
+        path: str,
+        *,
+        json: dict[str, Any] | list[Any] | None = None,
+        params: dict[str, Any] | None = None,
+        files: Any = None,
+    ) -> Any:
+        async with httpx.AsyncClient(
+            base_url=self.base_url,
+            transport=self.transport,
+            timeout=self.timeout,
+            headers=self._headers(),
+        ) as client:
+            response = await client.request(method, path, json=json, params=params, files=files)
+            if response.status_code >= 400:
+                message = response.text.strip() or response.reason_phrase
+                raise CLIError(f"{method} {path} failed: {response.status_code} {message}", status_code=response.status_code)
+            if response.content:
+                return response.json()
+            return None
+
+    async def list_articles(self, *, status: str | None = None, type_filter: str = "all") -> list[dict[str, Any]]:
+        params: dict[str, Any] = {"type": type_filter}
+        if status is not None:
+            params["status_filter"] = status
+        result = await self._request_json("GET", "/api/v1/articles", params=params)
+        return list(result or [])
+
+    async def get_article(self, slug: str) -> dict[str, Any]:
+        result = await self._request_json("GET", f"/api/v1/articles/{slug}")
+        return dict(result)
+
+    async def create_article(self, payload: dict[str, Any]) -> dict[str, Any]:
+        result = await self._request_json("POST", "/api/v1/articles", json=payload)
+        return dict(result)
+
+    async def update_article(self, slug: str, payload: dict[str, Any]) -> dict[str, Any]:
+        result = await self._request_json("PATCH", f"/api/v1/articles/{slug}", json=payload)
+        return dict(result)
+
+    async def publish_article(self, slug: str, payload: dict[str, Any] | None = None) -> dict[str, Any]:
+        result = await self._request_json("POST", f"/api/v1/articles/{slug}/publish", json=payload)
+        return dict(result)
+
+    async def unarchive_article(self, slug: str) -> dict[str, Any]:
+        result = await self._request_json("POST", f"/api/v1/articles/{slug}/unarchive")
+        return dict(result)
+
+    async def delete_article(self, slug: str) -> dict[str, Any]:
+        result = await self._request_json("DELETE", f"/api/v1/articles/{slug}")
+        return dict(result or {})
+
+    async def upload_media(self, name: str, path: Path) -> dict[str, Any]:
+        with path.open("rb") as handle:
+            result = await self._request_json(
+                "POST",
+                "/api/v1/media",
+                params={"name": name},
+                files={"file": (path.name, handle, "application/octet-stream")},
+            )
+        return dict(result)
+
+    async def update_media(self, name: str, path: Path) -> dict[str, Any]:
+        with path.open("rb") as handle:
+            result = await self._request_json(
+                "PUT",
+                f"/api/v1/media/{name}",
+                files={"file": (path.name, handle, "application/octet-stream")},
+            )
+        return dict(result)
+
+    async def delete_media(self, name: str) -> dict[str, Any]:
+        result = await self._request_json("DELETE", f"/api/v1/media/{name}")
+        return dict(result or {})
+
+    async def generate_preview(self, slug: str, *, ttl_hours: int = 24, base_url: str = "http://localhost:3000") -> dict[str, Any]:
+        result = await self._request_json(
+            "POST",
+            f"/api/v1/articles/{slug}/preview",
+            params={"ttl_hours": ttl_hours, "base_url": base_url},
+        )
+        return dict(result)
+
+
+def get_default_config() -> tuple[str, str | None]:
+    import os
+    _load_dotenv()
+    return (
+        os.environ.get("PERSONAL_SERVER_URL", "http://127.0.0.1:8000"),
+        os.environ.get("PERSONAL_API_KEY"),
+    )
+
+
+def _load_dotenv() -> None:
+    import os
+    from pathlib import Path
+
+    candidates = [
+        Path.cwd() / ".env",
+        Path(__file__).resolve().parents[3] / ".env",
+    ]
+    for env_path in candidates:
+        if not env_path.exists():
+            continue
+        with env_path.open() as f:
+            for line in f:
+                line = line.strip()
+                if not line or line.startswith("#"):
+                    continue
+                if "=" not in line:
+                    continue
+                key, _, value = line.partition("=")
+                key = key.strip()
+                value = value.strip().strip("'\"")
+                os.environ[key] = value
+        break

blog_cli-0.1.0/src/personal_cli/formatting.py

@@ -0,0 +1,38 @@
+from __future__ import annotations
+
+import json
+import sys
+from pathlib import Path
+from typing import Any
+
+from personal_cli.client import CLIError
+
+
+def read_markdown_from_source(
+    *,
+    markdown: str | None,
+    markdown_file: Path | None,
+) -> str:
+    if markdown is not None and markdown_file is not None:
+        raise CLIError("Use either --markdown or --markdown-file, not both.")
+    if markdown is not None:
+        return markdown
+    if markdown_file is not None:
+        return markdown_file.read_text(encoding="utf-8")
+    if sys.stdin.isatty():
+        raise CLIError("Provide markdown via --markdown, --markdown-file, or stdin.")
+    return sys.stdin.read()
+
+
+def emit_result(data: Any, *, json_output: bool = False) -> None:
+    if json_output:
+        print(json.dumps(data, indent=2, ensure_ascii=False, default=str))
+        return
+
+    if isinstance(data, list):
+        for item in data:
+            print(item)
+        return
+
+    print(data)
+

blog_cli-0.1.0/tests/test_cli.py

@@ -0,0 +1,130 @@
+from __future__ import annotations
+
+import json
+
+import pytest
+from typer.testing import CliRunner
+
+from personal_cli.client import ArticleApiClient
+from personal_cli.cli import app
+
+
+@pytest.fixture()
+def runner() -> CliRunner:
+    return CliRunner()
+
+
+def _build_client_mock(live_server: str):
+    return lambda server_url=None: ArticleApiClient(live_server)
+
+
+def test_article_cli_smoke(monkeypatch, runner: CliRunner, live_server: str) -> None:
+    monkeypatch.setattr("personal_cli.cli.build_client", _build_client_mock(live_server))
+
+    create_result = runner.invoke(
+        app,
+        [
+            "article",
+            "create",
+            "--title",
+            "CLI Article",
+            "--description",
+            "Created from the CLI",
+            "--type",
+            "blog",
+            "--markdown",
+            "# CLI Article\n\nBody.",
+            "--tag",
+            "build",
+            "--tag",
+            "indie",
+            "--json",
+        ],
+    )
+    assert create_result.exit_code == 0
+    created = json.loads(create_result.stdout)
+    assert created["slug"] == "cli-article"
+    assert created["type"] == "blog"
+
+    list_result = runner.invoke(app, ["article", "list", "--type", "blog", "--json"])
+    assert list_result.exit_code == 0
+    listed = json.loads(list_result.stdout)
+    assert listed[0]["slug"] == "cli-article"
+
+    publish_result = runner.invoke(app, ["article", "publish", "cli-article", "--published-by", "agent", "--json"])
+    assert publish_result.exit_code == 0
+    published = json.loads(publish_result.stdout)
+    assert published["status"] == "published"
+
+    delete_result = runner.invoke(app, ["article", "delete", "cli-article", "--json"])
+    assert delete_result.exit_code == 0
+    deleted = json.loads(delete_result.stdout)
+    assert deleted["deleted"] is True
+    assert deleted["slug"] == "cli-article"
+    assert deleted["deleted_at"]
+
+    unarchive_result = runner.invoke(app, ["article", "unarchive", "cli-article", "--json"])
+    assert unarchive_result.exit_code == 0
+    unarchived = json.loads(unarchive_result.stdout)
+    assert unarchived["slug"] == "cli-article"
+    assert unarchived["status"] == "published"
+
+    empty_list = runner.invoke(app, ["article", "list", "--json"])
+    assert empty_list.exit_code == 0
+    assert json.loads(empty_list.stdout)[0]["slug"] == "cli-article"
+
+
+def test_media_cli_smoke(monkeypatch, runner: CliRunner, live_server: str, tmp_path) -> None:
+    monkeypatch.setattr("personal_cli.cli.build_client", _build_client_mock(live_server))
+
+    media_file = tmp_path / "test-image.png"
+    media_file.write_bytes(b"fake-image-data")
+
+    upload_result = runner.invoke(
+        app,
+        [
+            "media",
+            "upload",
+            "--name",
+            "hero-image",
+            str(media_file),
+            "--json",
+        ],
+    )
+    assert upload_result.exit_code == 0
+    uploaded = json.loads(upload_result.stdout)
+    assert uploaded["name"] == "hero-image"
+    assert uploaded["url"] == "/api/v1/media/hero-image"
+
+    updated_file = tmp_path / "test-image-v2.png"
+    updated_file.write_bytes(b"fake-image-data-v2")
+
+    update_result = runner.invoke(
+        app,
+        [
+            "media",
+            "update",
+            "--name",
+            "hero-image",
+            str(updated_file),
+            "--json",
+        ],
+    )
+    assert update_result.exit_code == 0
+    updated = json.loads(update_result.stdout)
+    assert updated["name"] == "hero-image"
+
+    delete_result = runner.invoke(
+        app,
+        [
+            "media",
+            "delete",
+            "--name",
+            "hero-image",
+            "--json",
+        ],
+    )
+    assert delete_result.exit_code == 0
+    deleted = json.loads(delete_result.stdout)
+    assert deleted["deleted"] is True
+    assert deleted["name"] == "hero-image"

blog_cli-0.1.0/tests/test_client.py

@@ -0,0 +1,8 @@
+from __future__ import annotations
+
+from personal_cli.formatting import read_markdown_from_source
+
+
+def test_read_markdown_from_source_prefers_inline_text() -> None:
+    assert read_markdown_from_source(markdown="hello", markdown_file=None) == "hello"
+