ghostwriter-cli 0.1.0__py3-none-any.whl

ghostwriter/config.py

@@ -0,0 +1,242 @@
+"""Configuration management.
+
+Configuration is read from two sources, in priority order:
+1. Environment variables (GHOSTWRITER_GHOST_*, GHOSTWRITER_WECHAT_*)
+2. Config file (~/.config/ghostwriter/config.json)
+
+Use `ghostwriter config set <key> <value>` to manage the config file.
+"""
+
+import json
+import os
+import sys
+import textwrap
+
+# All required config keys mapped to their env var names.
+_REQUIRED_KEYS = {
+    "ghost.api_url":      "GHOSTWRITER_GHOST_API_URL",
+    "ghost.admin_key_id": "GHOSTWRITER_GHOST_ADMIN_KEY_ID",
+    "ghost.admin_key":    "GHOSTWRITER_GHOST_ADMIN_KEY",
+    "wechat.appid":       "GHOSTWRITER_WECHAT_APPID",
+    "wechat.secret":      "GHOSTWRITER_WECHAT_SECRET",
+}
+
+# Keys that should be masked when displayed.
+_SECRET_KEYS = {
+    "ghost.admin_key_id",
+    "ghost.admin_key",
+    "wechat.appid",
+    "wechat.secret",
+}
+
+_CONFIG_DIR = os.path.expanduser("~/.config/ghostwriter")
+_CONFIG_PATH = os.path.join(_CONFIG_DIR, "config.json")
+
+
+def _nested_get(d, key_path):
+    """Get a nested dict value by dot-separated key path.
+
+    Example: _nested_get(d, "ghost.api_url") → d["ghost"]["api_url"]
+    """
+    parts = key_path.split(".")
+    for part in parts:
+        if not isinstance(d, dict) or part not in d:
+            return None
+        d = d[part]
+    return d
+
+
+def _nested_set(d, key_path, value):
+    """Set a nested dict value by dot-separated key path.
+
+    Example: _nested_set(d, "ghost.api_url", "https://...")
+    """
+    parts = key_path.split(".")
+    for part in parts[:-1]:
+        if part not in d:
+            d[part] = {}
+        d = d[part]
+    d[parts[-1]] = value
+
+
+def _load_from_env():
+    """Try to build a config dict from environment variables.
+
+    Returns a config dict if ALL required env vars are set, otherwise None.
+    """
+    config = {"ghost": {}, "wechat": {}}
+    for key_path, env_var in _REQUIRED_KEYS.items():
+        value = os.environ.get(env_var)
+        if not value:
+            return None
+        _nested_set(config, key_path, value)
+    return config
+
+
+def _load_from_file():
+    """Load config from the JSON file.
+
+    Returns the parsed dict, or None if the file doesn't exist or is invalid.
+    """
+    if not os.path.exists(_CONFIG_PATH):
+        return None
+    try:
+        with open(_CONFIG_PATH, encoding="utf-8") as f:
+            return json.load(f)
+    except (json.JSONDecodeError, OSError):
+        return None
+
+
+def _validate_config(config, source):
+    """Check that all required keys are present.
+
+    Prints a helpful error and exits if any keys are missing.
+    """
+    missing = []
+    for key_path, env_var in _REQUIRED_KEYS.items():
+        if not _nested_get(config, key_path):
+            missing.append((key_path, env_var))
+
+    if not missing:
+        return
+
+    lines = [f"[!] 配置不完整 ({source})，缺少以下字段:"]
+    for key_path, env_var in missing:
+        lines.append(f"    {key_path}  (env: {env_var})")
+    lines.append("")
+    lines.append("设置方法:")
+    lines.append("  # 环境变量（推荐用于 CI/Docker）:")
+    for _, env_var in missing:
+        lines.append(f"  export {env_var}=<value>")
+    lines.append("")
+    lines.append("  # 或使用 CLI 写入配置文件:")
+    for key_path, _ in missing:
+        lines.append(f"  ghostwriter config set {key_path} <value>")
+    lines.append("")
+    lines.append(f"  # 配置文件位置: {_CONFIG_PATH}")
+
+    print("\n".join(lines))
+    sys.exit(1)
+
+
+def load_config():
+    """Load configuration, preferring env vars over the config file.
+
+    Returns a dict with shape:
+        {"ghost": {"api_url", "admin_key_id", "admin_key"},
+         "wechat": {"appid", "secret"}}
+
+    Exits with an error message if required keys are missing.
+    """
+    config = _load_from_env()
+    if config is not None:
+        return config
+
+    config = _load_from_file()
+    if config is not None:
+        _validate_config(config, f"文件 {_CONFIG_PATH}")
+        return config
+
+    # No config source available
+    print(f"[!] 未找到配置")
+    print(f"")
+    print(f"配置文件路径: {_CONFIG_PATH}")
+    print(f"")
+    print(f"请选择一种方式配置:")
+    print(f"")
+    print(f"  方式 1 — 环境变量（适合 CI/Docker）:")
+    for _, env_var in _REQUIRED_KEYS.items():
+        print(f"    export {env_var}=<value>")
+    print(f"")
+    print(f"  方式 2 — 配置文件（适合本地使用）:")
+    msg = "  ghostwriter config set {key} <value>"
+    print(f"    {msg.format(key='ghost.api_url')}")
+    print(f"    {msg.format(key='ghost.admin_key_id')}")
+    print(f"    {msg.format(key='ghost.admin_key')}")
+    print(f"    {msg.format(key='wechat.appid')}")
+    print(f"    {msg.format(key='wechat.secret')}")
+    sys.exit(1)
+
+
+# ── CLI config management ──────────────────────────────────────
+
+def config_path():
+    """Return the path to the config file."""
+    return _CONFIG_PATH
+
+
+def show_config():
+    """Print the current effective configuration.
+
+    Secrets (admin_key, appid, secret) are masked.
+    """
+    print(f"配置文件: {_CONFIG_PATH}")
+
+    # Show env vars if they're set (primary source)
+    env_config = _load_from_env()
+    if env_config:
+        print("来源: 环境变量")
+        source = "env"
+        config = env_config
+    else:
+        config = _load_from_file()
+        if config:
+            print("来源: 配置文件")
+            source = "file"
+        else:
+            print("来源: (无)")
+            print("")
+            print("未设置任何配置。使用以下命令开始:")
+            print("  ghostwriter config set ghost.api_url <url>")
+            return
+
+    print("")
+    for key_path in _REQUIRED_KEYS:
+        value = _nested_get(config, key_path)
+        if value and key_path in _SECRET_KEYS:
+            # Mask secret values: show first 4 + last 4 chars
+            if len(value) > 8:
+                value = value[:4] + "***" + value[-4:]
+            else:
+                value = "***"
+        elif not value:
+            value = "(未设置)"
+        print(f"  {key_path} = {value}")
+
+    # Show optional authors map
+    authors = config.get("authors", {})
+    if authors:
+        print("")
+        for slug, author_id in authors.items():
+            print(f"  authors.{slug} = {author_id}")
+
+
+def set_config_value(key_path, value):
+    """Write a single key to the config file.
+
+    Creates the config directory and file if they don't exist.
+    Preserves any existing keys in the file.
+    """
+    if key_path not in _REQUIRED_KEYS and not key_path.startswith("authors."):
+        valid = "\n".join(f"  {k}" for k in _REQUIRED_KEYS)
+        valid += "\n  authors.<slug>     (可选) 作者 slug → ID 映射"
+        print(f"[!] 未知的配置键: {key_path}")
+        print(f"有效的键:\n{valid}")
+        sys.exit(1)
+
+    # Load existing or start fresh
+    config = _load_from_file()
+    if config is None:
+        config = {"ghost": {}, "wechat": {}}
+
+    _nested_set(config, key_path, value)
+
+    # Write back
+    os.makedirs(_CONFIG_DIR, exist_ok=True)
+    with open(_CONFIG_PATH, "w", encoding="utf-8") as f:
+        json.dump(config, f, indent=2, ensure_ascii=False)
+
+    display = value
+    if key_path in _SECRET_KEYS and len(value) > 8:
+        display = value[:4] + "***" + value[-4:]
+    print(f"[+] {key_path} = {display}")

ghostwriter/ghost.py

@@ -0,0 +1,126 @@
+"""Ghost Admin API client.
+
+Handles JWT authentication, CRUD operations, image upload, and author
+lookup via the Ghost Admin and Content APIs.
+"""
+
+import json
+import time
+
+import jwt
+import requests
+
+
+def get_ghost_token(key_id, key_secret):
+    """Create a short-lived JWT for the Ghost Admin API.
+
+    The secret must be the raw hex string from Ghost's integration page.
+    It is decoded from hex to bytes before signing.
+    """
+    secret_bytes = bytes.fromhex(key_secret)
+    now = int(time.time())
+    payload = {
+        "aud": "/admin/",
+        "iat": now,
+        "exp": now + 300,
+        "type": "admin",
+    }
+    header = {"alg": "HS256", "typ": "JWT", "kid": key_id}
+    return jwt.encode(payload, secret_bytes, algorithm="HS256", headers=header)
+
+
+def _api_request(method, path, config, data=None):
+    """Low-level Ghost Admin API request."""
+    key_id = config["ghost"]["admin_key_id"]
+    key_secret = config["ghost"]["admin_key"]
+    api_url = config["ghost"]["api_url"]
+    token = get_ghost_token(key_id, key_secret)
+
+    headers = {"Authorization": f"Ghost {token}"}
+    kwargs = {"headers": headers, "timeout": 30}
+
+    if data is not None:
+        kwargs["headers"]["Content-Type"] = "application/json"
+        kwargs["data"] = json.dumps(data, ensure_ascii=False).encode("utf-8")
+
+    url = f"{api_url.rstrip('/')}/{path.lstrip('/')}"
+    r = requests.request(method, url, **kwargs)
+    r.raise_for_status()
+    return r.json() if r.text else {}
+
+
+def ghost_api_get(path, config):
+    """GET from Ghost Admin API."""
+    return _api_request("GET", path, config)
+
+
+def ghost_api_post(path, data, config):
+    """POST to Ghost Admin API."""
+    return _api_request("POST", path, config, data=data)
+
+
+def ghost_api_put(path, data, config):
+    """PUT to Ghost Admin API."""
+    return _api_request("PUT", path, config, data=data)
+
+
+def ghost_api_delete(path, config):
+    """DELETE from Ghost Admin API."""
+    return _api_request("DELETE", path, config)
+
+
+def upload_image_to_ghost(config, image_path):
+    """Upload an image file to Ghost, returning the public URL."""
+    import os
+
+    if not os.path.isfile(image_path):
+        raise FileNotFoundError(f"封面图片不存在: {image_path}")
+
+    key_id = config["ghost"]["admin_key_id"]
+    key_secret = config["ghost"]["admin_key"]
+    api_url = config["ghost"]["api_url"]
+    token = get_ghost_token(key_id, key_secret)
+
+    with open(image_path, "rb") as f:
+        # Detect MIME type from file extension
+        ext = os.path.splitext(image_path)[1].lower()
+        mime_map = {
+            ".jpg": "image/jpeg", ".jpeg": "image/jpeg",
+            ".png": "image/png", ".gif": "image/gif",
+            ".webp": "image/webp",
+        }
+        content_type = mime_map.get(ext, "image/png")
+        r = requests.post(
+            f"{api_url}/ghost/api/admin/images/upload/",
+            files={"file": (os.path.basename(image_path), f, content_type)},
+            headers={"Authorization": f"Ghost {token}"},
+            timeout=60,
+        )
+    r.raise_for_status()
+    result = r.json()
+    return result["images"][0]["url"]
+
+
+def get_ghost_posts(config, limit=20, status="all"):
+    """List Ghost posts via Admin API."""
+    return ghost_api_get(f"/ghost/api/admin/posts/?limit={limit}&status={status}", config)
+
+
+def get_ghost_article(article_id, config):
+    """Fetch a single Ghost article with HTML rendering."""
+    return ghost_api_get(f"/ghost/api/admin/posts/{article_id}/?formats=html", config)
+
+
+def get_ghost_authors(config):
+    """Fetch authors via Ghost Content API (no auth needed)."""
+    try:
+        api_url = config["ghost"]["api_url"]
+        r = requests.get(
+            f"{api_url}/ghost/api/content/authors/?limit=50",
+            timeout=10,
+        )
+        if r.ok:
+            return r.json()
+    except Exception:
+        pass
+    return {"authors": []}

ghostwriter/lexical.py

@@ -0,0 +1,252 @@
+"""Markdown to Ghost Lexical JSON converter.
+
+Converts Markdown text to Ghost's Lexical editor format (JSON). The output
+can be posted directly to the Ghost Admin API and is editable in Ghost's
+editor afterward.
+
+Supported Markdown:
+  - Headings (h1-h6)
+  - Paragraphs, bold (**), italic (*), inline code (`)
+  - Links [text](url)
+  - Fenced code blocks with language tags
+  - Tables (converted to html-card nodes)
+  - Ordered and unordered lists
+  - Horizontal rules (---, ***, ___)
+"""
+
+import json
+import re
+
+# Lexical format constants
+_LEXICAL_FORMATS = {1: "bold", 2: "italic", 8: "code"}
+
+
+def _lex_text(text, fmt=0):
+    return {
+        "type": "extended-text", "text": text, "format": fmt,
+        "version": 1, "detail": 0, "style": "", "mode": "normal",
+    }
+
+
+def _lex_link(text, url):
+    return {
+        "type": "link", "url": url,
+        "children": [_lex_text(text)],
+        "format": 0, "version": 1, "detail": 0, "style": "",
+        "mode": "normal", "rel": None, "target": None, "title": None,
+    }
+
+
+def _lex_para(children):
+    return {
+        "type": "paragraph", "children": children,
+        "format": "", "indent": 0, "version": 1, "direction": "ltr",
+    }
+
+
+def _lex_heading(tag, children):
+    return {
+        "type": "extended-heading", "tag": tag, "children": children,
+        "format": "", "indent": 0, "version": 1, "direction": "ltr",
+    }
+
+
+def _lex_codeblock(code, lang=""):
+    return {
+        "type": "codeblock", "code": code, "language": lang,
+        "caption": "", "version": 1,
+    }
+
+
+def _lex_hr():
+    return {"type": "horizontalrule", "version": 1}
+
+
+def _lex_listitem(children):
+    return {
+        "type": "listitem", "children": children,
+        "format": "", "indent": 0, "value": 1, "version": 1,
+        "direction": "ltr",
+    }
+
+
+def _lex_list(items, ordered=False):
+    return {
+        "type": "list",
+        "listType": "number" if ordered else "bullet",
+        "start": 1, "children": items,
+        "format": "", "indent": 0, "version": 1, "direction": "ltr",
+    }
+
+
+def _lex_html_card(html):
+    return {"type": "html", "html": html, "version": 1}
+
+
+def _extract_fenced_codes(md_text):
+    """Extract fenced code blocks to placeholders.
+
+    Returns (processed_text, code_map) where code_map maps placeholder
+    keys to {"lang": ..., "code": ...} dicts.
+    """
+    code_map = {}
+    idx = 0
+
+    def _save(m):
+        nonlocal idx
+        lang = m.group(1) or ""
+        code = m.group(2).rstrip("\n")
+        code_map[f"__CB_{idx}__"] = {"lang": lang, "code": code}
+        r = f"\n__CB_{idx}__\n"
+        idx += 1
+        return r
+
+    text = re.sub(
+        r'```(\w*)\n(.*?)```', _save, md_text,
+        flags=re.DOTALL,
+    )
+    return text, code_map
+
+
+def _parse_inline(text):
+    """Parse inline formatting: **bold**, `code`, *italic*, [links](url)."""
+    children = []
+    last = 0
+    pattern = (
+        r'\*\*(.+?)\*\*|'
+        r'(`[^`]+`)|'
+        r'(\*(.+?)\*)|'
+        r'(\[([^\]]+)\]\(([^)]+)\))'
+    )
+    for m in re.finditer(pattern, text):
+        s, e = m.start(), m.end()
+        if s > last:
+            children.append(_lex_text(text[last:s]))
+        if m.group(1):       # **bold**
+            children.append(_lex_text(m.group(1), 1))
+        elif m.group(2):     # `code`
+            children.append(_lex_text(m.group(2).strip('`'), 8))
+        elif m.group(3):     # *italic*
+            children.append(_lex_text(m.group(4), 2))
+        elif m.group(5):     # [text](url)
+            children.append(_lex_link(m.group(6), m.group(7)))
+        last = e
+    if last < len(text):
+        children.append(_lex_text(text[last:]))
+    return children if children else [_lex_text("")]
+
+
+def _table_to_html(raw):
+    """Convert a Markdown table to an HTML <table> string."""
+    rows = [
+        r for r in raw.split('\n')
+        if r.strip() and not re.match(r'^\|[\s:-]+\|', r)
+    ]
+    parts = ['<table>']
+    for i, row in enumerate(rows):
+        tag = 'th' if i == 0 else 'td'
+        cells = [c.strip() for c in row.split('|')[1:-1]]
+        parts.append('<tr>')
+        for cell in cells:
+            ch = re.sub(r'\*\*(.+?)\*\*', r'<strong>\1</strong>', cell)
+            ch = re.sub(r'`([^`]+)`', r'<code>\1</code>', ch)
+            parts.append(f'<{tag}>{ch}</{tag}>')
+        parts.append('</tr>')
+    parts.append('</table>')
+    return '\n'.join(parts)
+
+
+def md_to_ghost_lexical(md_text):
+    """Convert Markdown text to Ghost Lexical JSON.
+
+    Supported Markdown elements:
+      - Headings (h1-h6 via # prefix)
+      - Paragraphs
+      - Fenced code blocks (```lang ... ```)
+      - Tables (pipe syntax)
+      - Ordered and unordered lists
+      - Horizontal rules (---, ***, ___)
+      - Inline: bold, italic, code, links
+
+    Returns:
+        (title: str, lexical_json: str) — title extracted from the first
+        h1 heading (or empty), and a JSON string of the Lexical document.
+    """
+    lines = md_text.split('\n')
+    title = ""
+    if lines and lines[0].startswith('# '):
+        title = lines[0][2:].strip()
+        lines = lines[1:]
+    content = '\n'.join(lines)
+
+    content, code_map = _extract_fenced_codes(content)
+    raw_blocks = re.split(r'\n{2,}', content)
+
+    children = []
+    for raw in raw_blocks:
+        raw = raw.strip()
+        if not raw:
+            continue
+
+        cm = re.match(r'^__CB_(\d+)__$', raw)
+        if cm:
+            cb = code_map.get(raw)
+            if cb:
+                children.append(_lex_codeblock(cb["code"], cb["lang"]))
+            continue
+
+        if re.match(r'^[-*_]{3,}\s*$', raw):
+            children.append(_lex_hr())
+            continue
+
+        hm = re.match(r'^(#{1,6})\s+(.+)$', raw)
+        if hm:
+            children.append(
+                _lex_heading(f"h{len(hm.group(1))}",
+                             _parse_inline(hm.group(2)))
+            )
+            continue
+
+        if '|' in raw and raw.count('|') >= 4:
+            children.append(_lex_html_card(_table_to_html(raw)))
+            continue
+
+        lines_list = raw.split('\n')
+        if all(
+            re.match(r'^(\s*[-*+]\s+|\s*\d+[.)]\s+)', l)
+            for l in lines_list if l.strip()
+        ):
+            items, ordered = [], None
+            for line in lines_list:
+                m = re.match(r'^\s*([-*+]|\d+[.)])\s+(.*)$', line)
+                if not m:
+                    continue
+                marker, content_i = m.group(1), m.group(2)
+                is_ordered = (
+                    marker.endswith(')') or marker.endswith('.')
+                    or marker.isdigit()
+                )
+                if ordered is None:
+                    ordered = bool(
+                        is_ordered and marker not in ['-', '*', '+']
+                    )
+                items.append(
+                    _lex_listitem(_parse_inline(content_i.strip()))
+                )
+            if items:
+                children.append(_lex_list(items, ordered or False))
+            continue
+
+        children.append(_lex_para(_parse_inline(raw)))
+
+    lexical_tree = {
+        "root": {
+            "children": children,
+            "direction": None,
+            "format": "",
+            "indent": 0,
+            "type": "root",
+            "version": 1,
+        }
+    }
+    return title, json.dumps(lexical_tree, ensure_ascii=False)

ghostwriter/normalize.py

@@ -0,0 +1,23 @@
+"""Unicode title normalization for WeChat compatibility.
+
+WeChat's draft API (error 45003) rejects titles containing certain
+Unicode characters. This module maps them to safe ASCII equivalents.
+"""
+
+
+def normalize_title(title):
+    """Replace Unicode special characters with ASCII equivalents.
+
+    Mappings:
+        “ ”  (curly double quotes)  → "
+        ‘ ’  (curly single quotes)  → '
+        — –  (em/en dash)            → -
+        　         (fullwidth space)       → " "
+    """
+    return (
+        title
+        .replace('“', '"').replace('”', '"')
+        .replace('‘', "'").replace('’', "'")
+        .replace('—', '-').replace('–', '-')
+        .replace('　', ' ')
+    )