Content Factory

#!/bin/bash
# Content Factory Agent - Installation Script
# Usage: bash install.sh

set -e

SKILL_DIR="$(cd "$(dirname "$0")" && pwd)"
echo "📰 Installing Content Factory Agent..."

# Create data directories
mkdir -p "$SKILL_DIR/data"/{hotpool,topics,drafts,reviewed,published,config,assets,templates}

# Install Python deps
if [ -f "$SKILL_DIR/requirements.txt" ]; then
    echo "📦 Installing Python dependencies..."
    pip3 install -r "$SKILL_DIR/requirements.txt" 2>/dev/null || \
    python3 -m pip install -r "$SKILL_DIR/requirements.txt" 2>/dev/null || \
    echo "⚠️ pip install failed, some features may not work"
fi

# Copy default config if not exists
if [ ! -f "$SKILL_DIR/data/config/sources.json" ]; then
    cp "$SKILL_DIR/scripts/aggregator/config.json" "$SKILL_DIR/data/config/sources.json" 2>/dev/null || true
fi

echo "✅ Content Factory installed at: $SKILL_DIR"
echo ""
echo "Quick start:"
echo "  1. Run: bash $SKILL_DIR/scripts/run_daily.sh"
echo "  2. Or step by step:"
echo "     python3 $SKILL_DIR/scripts/aggregator/fetch_all.py"
echo "     python3 $SKILL_DIR/scripts/topic_scorer.py"
echo "     python3 $SKILL_DIR/scripts/content_generator.py --top 3"

httpx>=0.24.0
beautifulsoup4>=4.12.0

#!/usr/bin/env python3
"""
统一信息源热点采集器
从 微博/知乎/头条/抖音/B站/GitHub/YouTube/Twitter/Reddit/LinuxDo 等平台采集热门内容
HTTP请求统一用 subprocess+curl 避免 SSL 问题
"""

import json
import re
import subprocess
import sys
import html as htmlmod
import urllib.parse
from datetime import datetime, timezone, timedelta
from pathlib import Path

SCRIPT_DIR = Path(__file__).parent
CONFIG_FILE = SCRIPT_DIR / "config.json"
# Portable: output to skill data dir
OUTPUT_DIR = Path(__file__).resolve().parent.parent.parent / "data" / "hotpool"

TZ_CST = timezone(timedelta(hours=8))
UA = "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36"


def load_config():
    with open(CONFIG_FILE, "r") as f:
        return json.load(f)


def curl_get(url, headers=None, timeout=15):
    """用 subprocess+curl 获取 URL 内容，避免 SSL 问题"""
    cmd = ["curl", "-s", "--max-time", str(timeout), "-L",
           "-H", f"User-Agent: {UA}"]
    if headers:
        for k, v in headers.items():
            cmd += ["-H", f"{k}: {v}"]
    cmd.append(url)
    r = subprocess.run(cmd, capture_output=True, text=True, timeout=timeout + 5)
    if r.returncode != 0:
        raise RuntimeError(f"curl failed ({r.returncode}): {r.stderr[:200]}")
    return r.stdout


def curl_get_json(url, headers=None, timeout=15):
    return json.loads(curl_get(url, headers, timeout))


# Legacy compat
http_get = curl_get
http_get_json = curl_get_json


# ── 60s API 通用解析 ──────────────────────────────

def _parse_60s_v2(source_name, api_path, category="热搜"):
    """通用 60s API v2 解析器 (字段: code/data, 每条: title/link/hot_value)"""
    items = []
    try:
        data = curl_get_json(f"https://60s.viki.moe/v2/{api_path}")
        if data.get("code") != 200:
            print(f"  ⚠️ {source_name} 60s API: code={data.get('code')}", file=sys.stderr)
            return items
        for entry in data.get("data", []):
            title = entry.get("title", entry.get("name", entry.get("word", "")))
            url = entry.get("link", entry.get("url", entry.get("mobileUrl", "")))
            if not title:
                continue
            item = {
                "source": source_name,
                "title": title,
                "url": url,
                "summary": entry.get("desc", entry.get("excerpt", ""))[:200] if entry.get("desc") or entry.get("excerpt") else "",
                "category": category,
                "engagement": {},
            }
            hot = entry.get("hot_value", entry.get("hotValue", entry.get("hot", 0)))
            if hot:
                item["engagement"]["hot_value"] = hot
            items.append(item)
    except Exception as e:
        print(f"  ⚠️ {source_name}: {e}", file=sys.stderr)
    return items


# ── 微博热搜 (60s API) ────────────────────────────

def fetch_weibo(config):
    """通过 60s API 获取微博热搜"""
    return _parse_60s_v2("weibo", "weibo", "微博热搜")


# ── 知乎热榜 (60s API) ────────────────────────────

def fetch_zhihu(config):
    """通过 60s API 获取知乎热榜"""
    return _parse_60s_v2("zhihu", "zhihu", "知乎热榜")


# ── 头条热榜 (60s API) ────────────────────────────

def fetch_toutiao(config):
    """通过 60s API 获取今日头条热榜"""
    return _parse_60s_v2("toutiao", "toutiao", "头条热榜")


# ── 抖音热搜 (60s API, 替代原生) ──────────────────

def fetch_douyin(config):
    """通过 60s API 获取抖音热搜"""
    return _parse_60s_v2("douyin", "douyin", "抖音热搜")


# ── Twitter/X ──────────────────────────────────────

def fetch_twitter(config):
    items = []
    accounts = config.get("accounts", [])
    for account in accounts:
        try:
            url = f"https://syndication.twitter.com/srv/timeline-profile/screen-name/{account}"
            html = curl_get(url)
            texts = re.findall(r'"text":"([^"]{20,500})"', html)
            for text in texts[:3]:
                clean = htmlmod.unescape(text).replace("\\n", " ").strip()
                if clean.startswith("RT @"):
                    continue
                items.append({
                    "source": "twitter",
                    "title": clean[:120],
                    "url": f"https://x.com/{account}",
                    "summary": clean[:300],
                    "category": "Social/Tech",
                    "engagement": {},
                    "author": account,
                })
        except Exception as e:
            print(f"  ⚠️ Twitter @{account}: {e}", file=sys.stderr)
    return items


# ── YouTube ────────────────────────────────────────

def fetch_youtube(config):
    items = []
    channels = config.get("channels", {})
    for name, channel_id in channels.items():
        try:
            url = f"https://www.youtube.com/feeds/videos.xml?channel_id={channel_id}"
            xml = curl_get(url)
            entries = re.findall(
                r"<entry>.*?<title>(.+?)</title>.*?<yt:videoId>(.+?)</yt:videoId>.*?<published>(.+?)</published>.*?</entry>",
                xml, re.DOTALL
            )
            for title, vid, published in entries[:3]:
                title = htmlmod.unescape(title)
                items.append({
                    "source": "youtube",
                    "title": title,
                    "url": f"https://www.youtube.com/watch?v={vid}",
                    "summary": f"[{name}] {title}",
                    "category": "Video/Tech",
                    "engagement": {},
                    "author": name,
                    "published": published,
                })
        except Exception as e:
            print(f"  ⚠️ YouTube {name}: {e}", file=sys.stderr)
    return items


# ── B站 ───────────────────────────────────────────

def fetch_bilibili(config):
    items = []
    try:
        data = curl_get_json(
            "https://api.bilibili.com/x/web-interface/ranking/v2?rid=0&type=all",
            headers={"Referer": "https://www.bilibili.com"}
        )
        if data.get("code") == 0:
            for v in data["data"]["list"][:15]:
                items.append({
                    "source": "bilibili",
                    "title": v["title"],
                    "url": f"https://www.bilibili.com/video/{v['bvid']}",
                    "summary": v.get("desc", "")[:200],
                    "category": v.get("tname", "综合"),
                    "engagement": {
                        "views": v.get("stat", {}).get("view", 0),
                        "likes": v.get("stat", {}).get("like", 0),
                        "comments": v.get("stat", {}).get("reply", 0),
                    },
                    "author": v.get("owner", {}).get("name", ""),
                })
    except Exception as e:
        print(f"  ⚠️ Bilibili 原生API: {e}, 回退60s", file=sys.stderr)
        items.extend(_parse_60s_v2("bilibili", "bili", "B站热门"))

    try:
        data = curl_get_json(
            "https://api.bilibili.com/x/web-interface/wbi/search/square?limit=10",
            headers={"Referer": "https://www.bilibili.com"}
        )
        if data.get("code") == 0:
            trending = data.get("data", {}).get("trending", {})
            for t in trending.get("list", [])[:10]:
                items.append({
                    "source": "bilibili",
                    "title": f"[热搜] {t.get('keyword', t.get('show_name', ''))}",
                    "url": f"https://search.bilibili.com/all?keyword={urllib.parse.quote(t.get('keyword', ''))}",
                    "summary": t.get("show_name", ""),
                    "category": "热搜",
                    "engagement": {},
                })
    except Exception as e:
        print(f"  ⚠️ Bilibili 热搜: {e}", file=sys.stderr)

    return items


# ── GitHub Trending ────────────────────────────────

def fetch_github(config):
    """GitHub Trending daily（替代原来的全历史star排名）"""
    items = []
    try:
        html = curl_get("https://github.com/trending?since=daily")
        repos = re.findall(r'<h2[^>]*>\s*<a[^>]*href="/([^"]+)"[^>]*>', html)
        for repo_path in repos[:15]:
            repo_path = repo_path.strip()
            if not repo_path or repo_path.count('/') != 1:
                continue
            desc_match = re.search(
                rf'href="/{re.escape(repo_path)}".*?<p[^>]*>(.*?)</p>',
                html, re.DOTALL
            )
            desc = re.sub(r'<[^>]+>', '', desc_match.group(1)).strip()[:200] if desc_match else ""
            stars_match = re.search(
                rf'{re.escape(repo_path)}.*?(\d[\d,]*)\s*stars today', html, re.DOTALL
            )
            stars_today = int(stars_match.group(1).replace(',', '')) if stars_match else 0
            items.append({
                "source": "github",
                "title": f"{repo_path} 🔥+{stars_today}⭐/today" if stars_today else repo_path,
                "url": f"https://github.com/{repo_path}",
                "summary": desc,
                "category": "GitHub Trending",
                "engagement": {"stars_today": stars_today},
                "author": repo_path.split('/')[0],
            })
    except Exception as e:
        print(f"  ⚠️ GitHub Trending: {e}, 回退Search API", file=sys.stderr)
        lookback = config.get("lookback_days", 1)
        min_stars = config.get("min_stars", 100)
        date_str = (datetime.now(TZ_CST) - timedelta(days=lookback)).strftime("%Y-%m-%d")
        try:
            url = f"https://api.github.com/search/repositories?q=stars:>{min_stars}+pushed:>{date_str}&sort=stars&per_page=15"
            data = curl_get_json(url)
            for r in data.get("items", [])[:15]:
                items.append({
                    "source": "github", "title": f"{r['full_name']} ⭐{r['stargazers_count']}",
                    "url": r["html_url"], "summary": (r.get("description") or "")[:200],
                    "category": r.get("language", "Unknown"),
                    "engagement": {"stars": r["stargazers_count"], "forks": r.get("forks_count", 0)},
                    "author": r["owner"]["login"],
                })
        except Exception as e2:
            print(f"  ⚠️ GitHub Search: {e2}", file=sys.stderr)
    return items


# ── Reddit ─────────────────────────────────────────

def fetch_reddit(config):
    items = []
    subreddits = config.get("subreddits", ["technology"])
    for sub in subreddits:
        try:
            url = f"https://api.pullpush.io/reddit/search/submission/?subreddit={sub}&sort=score&sort_type=desc&size=5"
            data = curl_get_json(url)
            for p in data.get("data", [])[:5]:
                items.append({
                    "source": "reddit", "title": p.get("title", ""),
                    "url": f"https://reddit.com{p.get('permalink', '')}",
                    "summary": (p.get("selftext") or "")[:200],
                    "category": f"r/{sub}",
                    "engagement": {"upvotes": p.get("score", 0), "comments": p.get("num_comments", 0)},
                    "author": p.get("author", ""),
                })
        except Exception as e:
            print(f"  ⚠️ Reddit r/{sub}: {e}", file=sys.stderr)
    return items


# ── LinuxDo ────────────────────────────────────────

def fetch_linuxdo(config):
    items = []
    cookie_file = Path.home() / ".playwright-data/linuxdo/cookies.txt"
    headers = {"Accept": "application/json", "Referer": "https://linux.do/"}
    if cookie_file.exists():
        headers["Cookie"] = cookie_file.read_text().strip()
    try:
        data = curl_get_json("https://linux.do/latest.json?order=default", headers=headers)
        topics = data.get("topic_list", {}).get("topics", [])
        for t in topics[:15]:
            items.append({
                "source": "linuxdo", "title": t.get("title", ""),
                "url": f"https://linux.do/t/{t.get('slug', '')}/{t.get('id', '')}",
                "summary": "", "category": str(t.get("category_id", "")),
                "engagement": {"views": t.get("views", 0), "likes": t.get("like_count", 0), "comments": t.get("posts_count", 0)},
            })
    except Exception as e:
        print(f"  ⚠️ LinuxDo: {e}", file=sys.stderr)
    return items


# ── 小红书 ────────────────────────────────────────

def fetch_xiaohongshu(config):
    items = []
    cookie_file = Path.home() / ".playwright-data/xiaohongshu/cookies.txt"
    if not cookie_file.exists():
        print("  ⚠️ 小红书: 需要登录态 cookie", file=sys.stderr)
        return items
    headers = {"Referer": "https://www.xiaohongshu.com/", "Cookie": cookie_file.read_text().strip()}
    try:
        html = curl_get("https://www.xiaohongshu.com/explore", headers=headers)
        match = re.search(r'window\.__INITIAL_STATE__\s*=\s*({.*?})\s*</script>', html, re.DOTALL)
        if match:
            raw = match.group(1).replace("undefined", "null")
            state = json.loads(raw)
            for note in state.get("explore", {}).get("feeds", [])[:15]:
                nd = note.get("noteCard", note)
                items.append({
                    "source": "xiaohongshu", "title": nd.get("title", nd.get("displayTitle", "")),
                    "url": f"https://www.xiaohongshu.com/explore/{note.get('id', '')}",
                    "summary": nd.get("desc", "")[:200], "category": "小红书",
                    "engagement": {"likes": nd.get("interactInfo", {}).get("likedCount", 0)},
                    "author": nd.get("user", {}).get("nickname", ""),
                })
    except Exception as e:
        print(f"  ⚠️ 小红书: {e}", file=sys.stderr)
    return items


# ── 微信公众号 ────────────────────────────────────

def fetch_wechat_mp(config):
    items = []
    cookie_file = Path.home() / ".playwright-data/sogou-weixin/cookies.txt"
    headers = {"Referer": "https://weixin.sogou.com/"}
    if cookie_file.exists():
        headers["Cookie"] = cookie_file.read_text().strip()
    keywords = config.get("keywords", ["AI", "科技", "互联网"])
    for kw in keywords[:3]:
        try:
            url = f"https://weixin.sogou.com/weixin?type=2&query={urllib.parse.quote(kw)}&ie=utf8"
            html = curl_get(url, headers=headers)
            articles = re.findall(r'<a[^>]*href="([^"]*)"[^>]*target="_blank"[^>]*>(.*?)</a>', html, re.DOTALL)
            for href, title_html in articles[:5]:
                title = re.sub(r'<[^>]+>', '', title_html).strip()
                if len(title) > 5 and "sogou" not in title.lower():
                    items.append({
                        "source": "wechat_mp", "title": title,
                        "url": href if href.startswith("http") else f"https://weixin.sogou.com{href}",
                        "summary": "", "category": f"公众号/{kw}", "engagement": {},
                    })
        except Exception as e:
            print(f"  ⚠️ 微信公众号 [{kw}]: {e}", file=sys.stderr)
    return items


def fetch_wechat_video(config):
    print("  ⚠️ 微信视频号: 无公开 API", file=sys.stderr)
    return []


# ── 主流程 ─────────────────────────────────────────

FETCHERS = {
    "weibo": fetch_weibo,
    "zhihu": fetch_zhihu,
    "toutiao": fetch_toutiao,
    "douyin": fetch_douyin,
    "twitter": fetch_twitter,
    "youtube": fetch_youtube,
    "bilibili": fetch_bilibili,
    "github": fetch_github,
    "reddit": fetch_reddit,
    "linuxdo": fetch_linuxdo,
    "xiaohongshu": fetch_xiaohongshu,
    "wechat_mp": fetch_wechat_mp,
    "wechat_video": fetch_wechat_video,
}


def main():
    import argparse
    parser = argparse.ArgumentParser(description="信息源热点采集")
    parser.add_argument("--source", choices=list(FETCHERS.keys()), help="只采集指定平台")
    parser.add_argument("--dry-run", action="store_true", help="只打印不保存")
    args = parser.parse_args()

    config = load_config()
    now = datetime.now(TZ_CST)
    all_items = []

    sources = [args.source] if args.source else list(FETCHERS.keys())

    for src in sources:
        src_config = config.get(src, {})
        if not src_config.get("enabled", True):
            print(f"⏭️  {src}: disabled")
            continue
        print(f"🔍 采集 {src}...")
        try:
            items = FETCHERS[src](src_config)
            for item in items:
                item["fetched_at"] = now.isoformat()
            all_items.extend(items)
            print(f"  ✅ {len(items)} 条")
        except Exception as e:
            print(f"  ❌ {src}: {e}")

    output = {
        "date": now.strftime("%Y-%m-%d"),
        "fetched_at": now.isoformat(),
        "total": len(all_items),
        "sources": {src: len([i for i in all_items if i["source"] == src]) for src in sources},
        "items": all_items,
    }

    if args.dry_run:
        print(json.dumps(output, indent=2, ensure_ascii=False)[:3000])
        print(f"\n... 共 {len(all_items)} 条")
    else:
        OUTPUT_DIR.mkdir(parents=True, exist_ok=True)
        outfile = OUTPUT_DIR / f"{now.strftime('%Y-%m-%d')}.json"
        with open(outfile, "w", encoding="utf-8") as f:
            json.dump(output, f, indent=2, ensure_ascii=False)
        print(f"\n📁 已保存: {outfile}")
        print(f"📊 共 {len(all_items)} 条 ({', '.join(f'{k}:{v}' for k,v in output['sources'].items())})")


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""auto_publisher.py — 自动发布模块

支持平台：小红书（xiaohongshu）— MCP优先，Playwright备选
接口：publish(platform, title, content, images, tags) -> {success, url, error}

用法：
  python3 auto_publisher.py --platform xiaohongshu --date 2026-03-02 --topic-id 1
  python3 auto_publisher.py --platform xiaohongshu --title "测试" --content "内容" --dry-run
"""

import argparse
import json
import os
import subprocess
import sys
import time
from datetime import datetime
from pathlib import Path
from typing import Optional

from paths import DRAFTS_DIR, DATA_DIR
XHS_MCP_BIN = Path.home() / ".local/bin/xiaohongshu-mcp"
XHS_MCP_ENDPOINT = "http://localhost:18060/mcp"
XHS_COOKIES_DIR = Path.home() / ".playwright-data/xiaohongshu"
XHS_COOKIES_FALLBACK = [
    Path.home() / ".xiaohongshu/cookies.json",
    Path("/tmp/cookies.json"),
]
PUBLISH_LOG = DATA_DIR / "publish-log.json"

PLATFORMS = ["xiaohongshu"]  # Phase 1

# Clear proxy env to avoid socks:// issues with httpx
for _k in ['http_proxy', 'https_proxy', 'HTTP_PROXY', 'HTTPS_PROXY', 'all_proxy', 'ALL_PROXY']:
    os.environ.pop(_k, None)


# ---------------------------------------------------------------------------
# MCP transport
# ---------------------------------------------------------------------------

def _mcp_available() -> bool:
    """Check if xiaohongshu-mcp binary exists and service is reachable."""
    if not XHS_MCP_BIN.exists():
        return False
    try:
        import httpx
        r = httpx.get(XHS_MCP_ENDPOINT.replace("/mcp", "/health"), timeout=3)
        return r.status_code < 500
    except Exception:

        return False


def _mcp_call(method: str, params: dict) -> dict:
    """Call xiaohongshu-mcp via stdio JSON-RPC."""
    import httpx

    payload = {
        "jsonrpc": "2.0",
        "id": 1,
        "method": "tools/call",
        "params": {"name": method, "arguments": params},
    }
    try:
        r = httpx.post(XHS_MCP_ENDPOINT, json=payload, timeout=60)
        r.raise_for_status()
        data = r.json()
        if "error" in data:
            return {"success": False, "error": str(data["error"])}
        return {"success": True, "result": data.get("result")}
    except Exception as e:
        return {"success": False, "error": str(e)}


def publish_xiaohongshu_mcp(title: str, content: str,
                            images: list = None, tags: list = None) -> dict:
    """Publish via xiaohongshu-mcp (MCP JSON-RPC)."""
    # Step 1: create note
    params = {"title": title, "content": content}
    if images:
        params["images"] = images
    if tags:
        params["tags"] = tags

    result = _mcp_call("create_note", params)
    if not result.get("success"):
        return {"success": False, "url": "", "error": f"MCP create_note failed: {result.get('error')}"}

    note_data = result.get("result", {})
    url = note_data.get("url", note_data.get("note_url", ""))
    return {"success": True, "url": url, "error": ""}


# ---------------------------------------------------------------------------
# Playwright transport (fallback)
# ---------------------------------------------------------------------------

def _find_cookies_storage() -> Optional[Path]:
    """Find a valid storage state / cookies file for Playwright."""
    XHS_COOKIES_DIR.mkdir(parents=True, exist_ok=True)
    state = XHS_COOKIES_DIR / "state.json"
    if state.exists():
        return state
    for p in XHS_COOKIES_FALLBACK:
        if p.exists():
            return p
    return None


def publish_xiaohongshu_playwright(title: str, content: str,
                                   images: list = None, tags: list = None) -> dict:
    """Publish via Playwright automation on creator.xiaohongshu.com."""
    try:
        from playwright.sync_api import sync_playwright
    except ImportError:
        return {"success": False, "url": "", "error": "playwright not installed (pip install playwright)"}

    storage = _find_cookies_storage()
    if not storage:
        return {"success": False, "url": "",
                "error": "无小红书 cookies/storage state，请先登录并保存到 ~/.playwright-data/xiaohongshu/state.json"}

    result = {"success": False, "url": "", "error": ""}
    browser = None

    try:
        with sync_playwright() as p:
            browser = p.chromium.launch(headless=True)
            ctx = browser.new_context(storage_state=str(storage))
            page = ctx.new_page()

            # Navigate to creator publish page
            page.goto("https://creator.xiaohongshu.com/publish/publish", timeout=30000)
            page.wait_for_load_state("networkidle", timeout=15000)

            # Check login state
            if "login" in page.url.lower():
                result["error"] = "未登录：cookies 已过期，请重新登录"
                return result

            # --- Fill title ---
            title_sel = 'input[placeholder*="标题"], input[name="title"], #title'
            try:
                page.wait_for_selector(title_sel, timeout=5000)
                page.fill(title_sel, title)
            except Exception:
                # Some versions use contenteditable div
                page.locator('[contenteditable="true"]').first.fill(title)

            # --- Fill content ---
            # XHS editor is usually a contenteditable div or ProseMirror
            editor_sels = [
                '.ql-editor',
                '[contenteditable="true"]:not(input)',
                '.ProseMirror',
                '#content-editable',
            ]
            filled = False
            for sel in editor_sels:
                try:
                    el = page.wait_for_selector(sel, timeout=3000)
                    if el:
                        el.click()
                        page.keyboard.type(content, delay=10)
                        filled = True
                        break
                except Exception:
                    continue
            if not filled:
                result["error"] = "未找到内容编辑器选择器，需要更新 selector"
                return result

            # --- Upload images (if any) ---
            if images:
                file_input = page.locator('input[type="file"]').first
                for img_path in images:
                    if Path(img_path).exists():
                        file_input.set_input_files(img_path)
                        time.sleep(2)  # wait for upload

            # --- Add tags ---
            if tags:
                for tag in tags[:5]:  # XHS limits tags
                    tag_input = page.locator('input[placeholder*="标签"], input[placeholder*="话题"]')
                    if tag_input.count() > 0:
                        tag_input.first.fill(tag)
                        page.keyboard.press("Enter")
                        time.sleep(0.5)

            # --- Click publish ---
            pub_btn_sels = [
                'button:has-text("发布")',
                'button:has-text("Publish")',
                '.publish-btn',
                '[data-testid="publish-btn"]',
            ]
            published = False
            for sel in pub_btn_sels:
                try:
                    btn = page.locator(sel).first
                    if btn.is_visible():
                        btn.click()
                        published = True
                        break
                except Exception:
                    continue

            if not published:
                result["error"] = "未找到发布按钮"
                return result

            # Wait for redirect / success indication
            page.wait_for_timeout(3000)
            result["success"] = True
            result["url"] = page.url

            # Save updated storage state
            ctx.storage_state(path=str(storage))

            ctx.close()
            browser.close()
            browser = None

    except Exception as e:
        result["error"] = str(e)
    finally:
        # Force cleanup
        if browser:
            try:
                browser.close()
            except Exception:
                pass
        subprocess.run(["pkill", "-f", "chromium.*--headless"], capture_output=True)

    return result


# ---------------------------------------------------------------------------
# Unified publish interface
# ---------------------------------------------------------------------------

def publish(platform: str, title: str, content: str,
            images: list = None, tags: list = None,
            dry_run: bool = False) -> dict:
    """
    发布内容到指定平台。

    Returns: {"success": bool, "url": str, "error": str, "method": str}
    """
    if platform not in PLATFORMS:
        return {"success": False, "url": "", "error": f"不支持的平台: {platform}", "method": "none"}

    if dry_run:
        print(f"[DRY-RUN] 平台: {platform}")
        print(f"  标题: {title}")
        print(f"  内容: {content[:200]}...")
        print(f"  图片: {images or '无'}")
        print(f"  标签: {tags or '无'}")
        return {"success": True, "url": "dry-run://ok", "error": "", "method": "dry-run"}

    if platform == "xiaohongshu":
        # Try MCP first
        if _mcp_available():
            print("📡 使用 MCP 方式发布...")
            r = publish_xiaohongshu_mcp(title, content, images, tags)
            r["method"] = "mcp"
            if r.get("success"):
                return r
            print(f"⚠️ MCP 失败: {r.get('error')}，回退到 Playwright...")
        else:
            print("⚠️ MCP 不可用，跳过...")

        # Fallback to Playwright
        print("🎭 使用 Playwright 方式...")
        storage = _find_cookies_storage()
        if not storage:
            print("⚠️ 登录态检查: 未找到小红书 cookies")
            print("  请先运行: python3 -m playwright install chromium")
            print("  然后手动登录并保存 storage state 到:")
            print(f"    {XHS_COOKIES_DIR}/state.json")
            return {"success": False, "url": "",
                    "error": "缺少小红书登录态，请先保存 cookies (详见上方提示)",
                    "method": "playwright"}
        print(f"✅ 登录态检查: 找到 cookies → {storage}")
        r = publish_xiaohongshu_playwright(title, content, images, tags)
        r["method"] = "playwright"
        return r

    return {"success": False, "url": "", "error": "unreachable", "method": "none"}


def log_publish(date_str: str, topic_id: str, platform: str, result: dict):
    """Append publish result to log file."""
    PUBLISH_LOG.parent.mkdir(parents=True, exist_ok=True)
    entry = {
        "timestamp": datetime.now().isoformat(),
        "date": date_str,
        "topic_id": topic_id,
        "platform": platform,
        **result,
    }
    logs = []
    if PUBLISH_LOG.exists():
        try:
            logs = json.loads(PUBLISH_LOG.read_text())
        except Exception:
            pass
    logs.append(entry)
    PUBLISH_LOG.write_text(json.dumps(logs, ensure_ascii=False, indent=2))


# ---------------------------------------------------------------------------
# CLI
# ---------------------------------------------------------------------------

def parse_draft(date_str: str, topic_id: str, platform: str) -> tuple:
    """Read title + content from draft file."""
    path = DRAFTS_DIR / date_str / str(topic_id) / f"{platform}.md"
    if not path.exists():
        raise FileNotFoundError(f"草稿不存在: {path}")
    text = path.read_text()
    # Try to extract title from first line
    lines = text.strip().splitlines()
    title = ""
    content = text
    for line in lines:
        stripped = line.strip()
        if stripped.startswith("【标题】"):
            title = stripped.replace("【标题】", "").strip()
        elif stripped.startswith("[TWEET]") or stripped.startswith("# "):
            title = stripped.lstrip("#[ ").rstrip("]").strip()
            break
    if not title and lines:
        title = lines[0][:60]
    return title, content


def main():
    ap = argparse.ArgumentParser(description="自动发布模块")
    ap.add_argument("--platform", choices=PLATFORMS, default="xiaohongshu")
    ap.add_argument("--date", default=datetime.now().strftime("%Y-%m-%d"))
    ap.add_argument("--topic-id", type=int, help="从 drafts 读取")
    ap.add_argument("--title", help="直接指定标题")
    ap.add_argument("--content", help="直接指定内容")
    ap.add_argument("--images", nargs="*", help="图片路径")
    ap.add_argument("--tags", nargs="*", help="标签")
    ap.add_argument("--dry-run", action="store_true", help="仅预览不发布")
    args = ap.parse_args()

    if args.title and args.content:
        title, content = args.title, args.content
    elif args.topic_id:
        title, content = parse_draft(args.date, str(args.topic_id), args.platform)
    else:
        print("❌ 需要指定 --topic-id 或 --title + --content", file=sys.stderr)
        return 1

    print(f"{'🏃' if not args.dry_run else '📝'} 发布: {args.platform} | {title[:40]}")
    result = publish(args.platform, title, content, args.images, args.tags, dry_run=args.dry_run)

    if result["success"]:
        print(f"✅ 发布成功 [{result.get('method', '?')}] → {result.get('url', 'N/A')}")
    else:
        print(f"❌ 发布失败 [{result.get('method', '?')}]: {result.get('error', '?')}")

    if not args.dry_run:
        log_publish(args.date, str(args.topic_id or 0), args.platform, result)

    return 0 if result["success"] else 1


if __name__ == "__main__":
    raise SystemExit(main())

#!/usr/bin/env python3
"""content_generator.py — 多平台内容生成引擎

读取评分选题 + 平台模板 → 调用 LLM (glm-5) → 输出多平台草稿。

用法:
  python content_generator.py --topic-id 1 --platform xiaohongshu
  python content_generator.py --top 3 --all-platforms
  python content_generator.py --topic-id 1 --all-platforms --dry-run
"""

import argparse
import json
import os
import sys
import httpx
from datetime import datetime
from pathlib import Path

# 清除代理，避免 httpx 不支持 socks 协议报错
for _k in ("http_proxy", "https_proxy", "HTTP_PROXY", "HTTPS_PROXY", "all_proxy", "ALL_PROXY"):
    os.environ.pop(_k, None)

from paths import TOPICS_DIR, DRAFTS_DIR, TEMPLATES_DIR

PLATFORMS = ["xiaohongshu", "twitter", "wechat"]

LLM_BASE = os.environ.get("LLM_BASE_URL", "https://open.bigmodel.cn/api/paas/v4")
LLM_MODEL = os.environ.get("LLM_MODEL", "glm-5")
LLM_TIMEOUT = int(os.environ.get("LLM_TIMEOUT", "120"))


def get_api_key() -> str:
    key = os.environ.get("LLM_API_KEY") or os.environ.get("ZAI_API_KEY")
    if key:
        return key
    import subprocess
    r = subprocess.run(["pass", "show", "api/zai-glm5-new"], capture_output=True, text=True, timeout=10)
    if r.returncode == 0 and r.stdout.strip():
        return r.stdout.strip()
    raise RuntimeError("无法获取 API Key，请设置 LLM_API_KEY 或配置 pass")


def load_topics(date_str: str) -> dict:
    path = TOPICS_DIR / f"{date_str}.json"
    if not path.exists():
        files = sorted(TOPICS_DIR.glob("*.json"), reverse=True)
        if not files:
            raise FileNotFoundError(f"topics 目录为空: {TOPICS_DIR}")
        path = files[0]
        print(f"⚠️  回退到: {path.name}", file=sys.stderr)
    return json.loads(path.read_text())


def load_system_prompts() -> dict:
    path = TEMPLATES_DIR / "system_prompts.json"
    return json.loads(path.read_text())


def load_template(platform: str) -> str:
    path = TEMPLATES_DIR / f"{platform}.md"
    if not path.exists():
        return ""
    return path.read_text()


def fill_template(template: str, topic: dict) -> str:
    title = topic.get("title", "")
    summary = topic.get("summary", "")
    if not isinstance(summary, str):
        summary = str(summary)
    source = f"{topic.get('source', '')}/{topic.get('category', '')}"
    angle = topic.get("angle", "")
    return (template
            .replace("{title}", title)
            .replace("{summary}", summary)
            .replace("{source}", source)
            .replace("{angles}", angle)
            .replace("{angle}", angle))


def call_llm(system_prompt: str, user_prompt: str, dry_run: bool = False) -> str:
    if dry_run:
        return f"[DRY-RUN] 不调用LLM\n\n=== SYSTEM ===\n{system_prompt[:200]}...\n\n=== USER ===\n{user_prompt[:500]}..."

    api_key = get_api_key()
    url = f"{LLM_BASE}/chat/completions"
    headers = {"Authorization": f"Bearer {api_key}", "Content-Type": "application/json"}
    body = {
        "model": LLM_MODEL,
        "messages": [
            {"role": "system", "content": system_prompt},
            {"role": "user", "content": user_prompt},
        ],
        "temperature": 0.8,
        "max_tokens": 4096,
    }

    with httpx.Client(timeout=LLM_TIMEOUT) as client:
        resp = client.post(url, headers=headers, json=body)
        resp.raise_for_status()
        data = resp.json()
        return data["choices"][0]["message"]["content"]


def generate_one(topic, topic_idx, platform, date_str, sys_prompts, dry_run):
    sp_entry = sys_prompts.get(platform, {})
    system_prompt = sp_entry.get("system_prompt", f"你是{platform}内容创作者。")
    output_format = sp_entry.get("output_format", "")

    template = load_template(platform)
    user_prompt = fill_template(template, topic)
    if output_format:
        user_prompt += f"\n\n请严格按照以下格式输出:\n{output_format}"

    content = call_llm(system_prompt, user_prompt, dry_run=dry_run)

    out_dir = DRAFTS_DIR / date_str / str(topic_idx)
    out_dir.mkdir(parents=True, exist_ok=True)
    out_file = out_dir / f"{platform}.md"
    out_file.write_text(content)
    return out_file


def main():
    p = argparse.ArgumentParser(description="多平台内容生成引擎")
    p.add_argument("--date", default=datetime.now().strftime("%Y-%m-%d"))
    p.add_argument("--topic-id", type=int, help="指定选题编号 (1-based)")
    p.add_argument("--top", type=int, default=3, help="批量生成 Top N")
    p.add_argument("--platform", choices=PLATFORMS, help="指定单一平台")
    p.add_argument("--all-platforms", action="store_true", help="生成所有平台版本")
    p.add_argument("--dry-run", action="store_true", help="只打印 prompt 不调用 LLM")
    args = p.parse_args()

    if not args.platform and not args.all_platforms:
        args.all_platforms = True

    platforms = PLATFORMS if args.all_platforms else [args.platform]
    data = load_topics(args.date)
    sys_prompts = load_system_prompts()
    top_items = data.get("top", [])

    if args.topic_id:
        idx = args.topic_id - 1
        if idx < 0 or idx >= len(top_items):
            print(f"❌ topic-id {args.topic_id} 超出范围 (1-{len(top_items)})", file=sys.stderr)
            return 1
        targets = [(args.topic_id, top_items[idx])]
    else:
        targets = [(i + 1, t) for i, t in enumerate(top_items[:args.top])]

    date_str = data.get("date", args.date)
    total = len(targets) * len(platforms)
    done = 0

    for tid, topic in targets:
        title = (topic.get("title") or "")[:40]
        for plat in platforms:
            done += 1
            tag = "🏃" if not args.dry_run else "📝"
            print(f"{tag} [{done}/{total}] #{tid} {title} → {plat}")
            try:
                out = generate_one(topic, tid, plat, date_str, sys_prompts, args.dry_run)
                print(f"   ✅ {out}")
            except Exception as e:
                print(f"   ❌ {e}", file=sys.stderr)

    print(f"\n{'📝 DRY-RUN' if args.dry_run else '✅'} 完成: {done} 篇内容 → {DRAFTS_DIR / date_str}/")
    return 0


if __name__ == "__main__":
    raise SystemExit(main())

#!/usr/bin/env python3
"""draft_reviewer.py — 草稿预览推送脚本

功能：
- 读取 drafts/{date}/{topic_id}/{platform}.md
- 支持指定 date/topic/platform；支持 --all 推送当天所有草稿
- 推送到 Daniel (chat_id: 8518085684)
- --dry-run 仅打印

说明：
- 发送动作使用 OpenClaw message tool 更合适；脚本内默认走 newsbot_send.py 作为降级。
- 当前实现：优先调用 newsbot_send.py（如果其支持 --target/--chat-id），否则 dry-run。
"""

import argparse
import os
from pathlib import Path
from datetime import datetime
import textwrap
import subprocess
import sys

# 清除代理
for _k in ("http_proxy", "https_proxy", "HTTP_PROXY", "HTTPS_PROXY", "all_proxy", "ALL_PROXY"):
    os.environ.pop(_k, None)

from paths import DRAFTS_DIR, NEWSBOT_SEND
DANIEL_CHAT_ID = "8518085684"

PLATFORMS = ["xiaohongshu", "twitter", "wechat"]


def read_text(path: Path) -> str:
    return path.read_text(encoding="utf-8", errors="ignore")


def preview(text: str, n: int = 300) -> str:
    t = " ".join(text.split())
    return t[:n] + ("..." if len(t) > n else "")


def iter_drafts(date_str: str, topic_id: str | None, platform: str | None):
    base = DRAFTS_DIR / date_str
    if not base.exists():
        return []

    items = []
    topic_dirs = [base / str(topic_id)] if topic_id else sorted([p for p in base.iterdir() if p.is_dir()], key=lambda p: int(p.name) if p.name.isdigit() else p.name)
    for td in topic_dirs:
        if not td.exists() or not td.is_dir():
            continue
        plats = [platform] if platform else PLATFORMS
        for plat in plats:
            f = td / f"{plat}.md"
            if f.exists():
                items.append((td.name, plat, f))
    return items


def format_message(date_str: str, topic_id: str, platform: str, content: str) -> str:
    head = f"📝 Draft Review\n\nDate: {date_str}\nTopic: #{topic_id}\nPlatform: {platform}\n"
    body = preview(content, 300)
    tail = "\n\n回复：✅ 通过 / ❌ 退回（可附原因）"
    return head + "\n" + body + tail


def send_via_newsbotsend(message: str, dry_run: bool):
    sender = NEWSBOT_SEND
    if dry_run:
        print("--- DRY RUN SEND ---")
        print(message)
        return True
    if not sender.exists():
        raise FileNotFoundError(f"newsbot_send.py 不存在：{NEWSBOT_SEND} (set NEWSBOT_SEND env var)")

    # 尝试把 Daniel chat_id 作为 target 参数传入（兼容不同实现）。
    candidates = [
        [sys.executable, str(sender), "--target", DANIEL_CHAT_ID, "--message", message],
        [sys.executable, str(sender), "--chat-id", DANIEL_CHAT_ID, "--message", message],
        [sys.executable, str(sender), "--to", DANIEL_CHAT_ID, "--message", message],
    ]
    last_err = None
    for cmd in candidates:
        p = subprocess.run(cmd, capture_output=True, text=True, timeout=30)
        if p.returncode == 0:
            return True
        last_err = (p.stderr or p.stdout).strip()

    raise RuntimeError(f"newsbot_send.py 发送失败（可能不支持指定 chat_id 参数）。最后错误: {last_err}")


def main():
    ap = argparse.ArgumentParser(description="推送草稿预览到 Daniel")
    ap.add_argument("--date", default=datetime.now().strftime("%Y-%m-%d"))
    ap.add_argument("--topic-id", type=int, help="topic id (1-based)")
    ap.add_argument("--platform", choices=PLATFORMS)
    ap.add_argument("--all", action="store_true", help="推送当天所有草稿")
    ap.add_argument("--dry-run", action="store_true")
    args = ap.parse_args()

    if args.all:
        topic_id = None
    else:
        topic_id = str(args.topic_id) if args.topic_id else None

    drafts = iter_drafts(args.date, topic_id, args.platform)
    if not drafts:
        print("⚠️ 未找到任何草稿", file=sys.stderr)
        return 1

    for tid, plat, path in drafts:
        content = read_text(path)
        msg = format_message(args.date, tid, plat, content)
        send_via_newsbotsend(msg, args.dry_run)
        print(f"✅ queued: {args.date}/{tid}/{plat}")

    return 0


if __name__ == "__main__":
    raise SystemExit(main())

"""
Shared path configuration for Content Factory.
All data paths are relative to SKILL_DIR, making the skill portable.
"""
from pathlib import Path

# SKILL_DIR = parent of scripts/
SKILL_DIR = Path(__file__).resolve().parent.parent
DATA_DIR = SKILL_DIR / "data"

HOTPOOL_DIR = DATA_DIR / "hotpool"
TOPICS_DIR = DATA_DIR / "topics"
DRAFTS_DIR = DATA_DIR / "drafts"
REVIEWED_DIR = DATA_DIR / "reviewed"
PUBLISHED_DIR = DATA_DIR / "published"
TEMPLATES_DIR = DATA_DIR / "templates"
CONFIG_DIR = DATA_DIR / "config"
ASSETS_DIR = DATA_DIR / "assets"

LOG_FILE = DATA_DIR / "daily.log"

# Local aggregator
FETCH_ALL = SKILL_DIR / "scripts" / "aggregator" / "fetch_all.py"

# Newsbot: prefer environment variable, then local scripts
import os
_newsbot_env = os.environ.get("NEWSBOT_SEND")
NEWSBOT_SEND = Path(_newsbot_env) if _newsbot_env else (
    Path.home() / "clawd/scripts/newsbot_send.py"
)

# Ensure data dirs exist on import
for d in [HOTPOOL_DIR, TOPICS_DIR, DRAFTS_DIR, REVIEWED_DIR, PUBLISHED_DIR,
          TEMPLATES_DIR, CONFIG_DIR, ASSETS_DIR]:
    d.mkdir(parents=True, exist_ok=True)

#!/bin/bash
# Content Factory — Daily Pipeline (portable)
# Uses paths relative to skill directory

SKILL_DIR="$(cd "$(dirname "$0")/.." && pwd)"
SCRIPTS="$SKILL_DIR/scripts"
DATA="$SKILL_DIR/data"
LOG="$DATA/daily.log"

# Create data dirs
mkdir -p "$DATA"/{hotpool,topics,drafts,reviewed,published}

# Clear proxy to avoid SSL issues
unset http_proxy https_proxy HTTP_PROXY HTTPS_PROXY all_proxy ALL_PROXY

log() { echo "[$(date '+%Y-%m-%d %H:%M:%S')] $1" >> "$LOG"; }
log "=== 内容工厂每日流程开始 ==="

# Step 1: 热点采集
log "Step 1: 热点采集..."
cd "$SCRIPTS/aggregator"
timeout 120 python3 fetch_all.py >> "$LOG" 2>&1 || log "⚠️ 热点采集超时或部分失败"
log "热点采集完成"

# Step 2: 选题评分
log "Step 2: 选题评分..."
sleep 5
cd "$SCRIPTS"
python3 topic_scorer.py >> "$LOG" 2>&1 || log "⚠️ 选题评分失败"
log "选题评分完成"

# Step 3: 推送选题给用户
log "Step 3: 推送选题..."
sleep 5
python3 topic_presenter.py >> "$LOG" 2>&1 || log "⚠️ 推送失败"
log "选题推送完成"

# Step 4: 内容生成 (Top 3)
log "Step 4: 内容生成 (Top 3)..."
sleep 5
python3 content_generator.py --top 3 >> "$LOG" 2>&1 || log "⚠️ 内容生成失败"
log "草稿生成完成"

# Step 5: 草稿审核
log "Step 5: 草稿审核..."
sleep 5
python3 draft_reviewer.py --all >> "$LOG" 2>&1 || log "⚠️ 草稿审核失败"
log "草稿审核推送完成"

log "=== 内容工厂每日流程结束 ==="

#!/bin/bash
# Content Factory - Portable daily pipeline
SKILL_DIR="$(cd "$(dirname "$0")/.." && pwd)"
SCRIPTS="$SKILL_DIR/scripts"
DATA="$SKILL_DIR/data"
LOG="$DATA/daily.log"

unset http_proxy https_proxy HTTP_PROXY HTTPS_PROXY all_proxy ALL_PROXY

log() { echo "[$(date '+%Y-%m-%d %H:%M:%S')] $1" >> "$LOG"; }
log "=== Content Factory Daily Pipeline ==="

log "Step 1: Fetching hot topics..."
cd "$SCRIPTS/aggregator" && timeout 120 python3 fetch_all.py >> "$LOG" 2>&1 || log "⚠️ Fetch error"

log "Step 2: Scoring topics..."
cd "$SCRIPTS" && python3 topic_scorer.py >> "$LOG" 2>&1 || log "⚠️ Scorer error"

log "Step 3: Presenting topics..."
python3 topic_presenter.py >> "$LOG" 2>&1 || log "⚠️ Presenter error"

log "Step 4: Generating content (Top 3)..."
python3 content_generator.py --top 3 >> "$LOG" 2>&1 || log "⚠️ Generator error"

log "Step 5: Reviewing drafts..."
python3 draft_reviewer.py --all >> "$LOG" 2>&1 || log "⚠️ Reviewer error"

log "=== Pipeline Complete ==="

#!/usr/bin/env python3
"""topic_presenter.py

将评分后的选题（topics/YYYY-MM-DD.json）格式化为 Telegram 卡片消息并推送。

需求：
1) 读取 ~/clawd/workspace/content-pipeline/topics/YYYY-MM-DD.json
2) 格式化消息（编号、标题、分数、来源、角度）
3) 调用 ~/clawd/scripts/newsbot_send.py 推送
4) --dry-run 只打印不发送
5) --top N 推送 Top N

用法：
  python topic_presenter.py
  python topic_presenter.py --date 2026-03-02 --top 5 --dry-run

注意：脚本不依赖 topic_scorer.py，可独立运行。
"""

import argparse
import json
import sys
import subprocess
from datetime import datetime
from pathlib import Path

from paths import TOPICS_DIR, NEWSBOT_SEND


def load_topics(date_str: str) -> dict:
    path = TOPICS_DIR / f"{date_str}.json"
    if not path.exists():
        # 回退到最新
        files = sorted(TOPICS_DIR.glob("*.json"), reverse=True)
        if not files:
            raise FileNotFoundError(f"topics 目录为空: {TOPICS_DIR}")
        path = files[0]
        print(f"⚠️ 未找到 {date_str}.json，回退到最新: {path.name}")

    data = json.loads(path.read_text())
    if "top" not in data:
        raise ValueError(f"topics 文件缺少 top 字段: {path}")
    return data


def normalize_source(item: dict) -> str:
    source = item.get("source", "?")
    category = item.get("category", "")
    if category:
        return f"{source}/{category}"
    return str(source)


def format_message(top_items: list, date_str: str, title_prefix: str = "📰 今日选题") -> str:
    nums = ["1️⃣", "2️⃣", "3️⃣", "4️⃣", "5️⃣", "6️⃣", "7️⃣", "8️⃣", "9️⃣", "🔟"]

    lines = [
        f"{title_prefix} Top {len(top_items)} ({date_str})",
        "",
    ]

    for i, item in enumerate(top_items):
        num = nums[i] if i < 10 else f"[{i+1}]"
        score = item.get("total_score", item.get("score", "?"))
        title = (item.get("title") or "").strip()
        if len(title) > 80:
            title = title[:77] + "..."

        src = normalize_source(item)
        angle = (item.get("angle") or "").strip()
        if not angle:
            angle = "(未提供)"

        lines.append(f"{num} [{score}分] {title} - {src}")
        lines.append(f"   💡 角度：{angle}")
        lines.append("")

    lines.append("回复编号（如 \"1 3 7\"）选择要创作的主题")
    return "\n".join(lines).rstrip() + "\n"


def send(message: str) -> None:
    sender = NEWSBOT_SEND
    if not sender.exists():
        raise FileNotFoundError(f"newsbot_send.py 不存在：{NEWSBOT_SEND} (set NEWSBOT_SEND env var)")

    proc = subprocess.run(
        [sys.executable, str(sender), "--message", message],
        capture_output=True,
        text=True,
        timeout=30,
    )
    if proc.returncode != 0:
        raise RuntimeError(proc.stderr.strip() or proc.stdout.strip() or "newsbot_send failed")


def main():
    parser = argparse.ArgumentParser(description="推送今日选题到 Telegram")
    parser.add_argument("--date", default=datetime.now().strftime("%Y-%m-%d"), help="topics 日期")
    parser.add_argument("--top", type=int, default=10, help="推送 Top N")
    parser.add_argument("--dry-run", action="store_true", help="只打印不发送")
    args = parser.parse_args()

    data = load_topics(args.date)
    top_items = data.get("top", [])[: max(args.top, 0)]

    if not top_items:
        print("⚠️ topics.top 为空，退出")
        return 1

    date_str = data.get("date", args.date)
    msg = format_message(top_items, date_str)

    if args.dry_run:
        print(msg)
        return 0

    send(msg)
    print("✅ 已推送")
    return 0


if __name__ == "__main__":
    raise SystemExit(main())

#!/usr/bin/env python3
"""
选题评分脚本 — 从热点池筛选 Top 10 推荐选题

读取 hotpool/YYYY-MM-DD.json → LLM评分 → 排序 → 生成选题卡片 → 保存+推送

用法:
    python topic_scorer.py                    # 评分今天的热点池
    python topic_scorer.py --date 2026-02-19  # 指定日期
    python topic_scorer.py --top 5            # 只取 Top 5
    python topic_scorer.py --no-send          # 不推送，只输出
    python topic_scorer.py --dry-run          # 不调LLM，用随机分
"""

import json
import os
import sys
import subprocess
import argparse
import time
from datetime import datetime
from pathlib import Path

# 清除代理，避免 SSL EOF 错误
for k in ['http_proxy', 'https_proxy', 'HTTP_PROXY', 'HTTPS_PROXY', 'all_proxy', 'ALL_PROXY']:
    os.environ.pop(k, None)

# === 路径配置 ===
from paths import HOTPOOL_DIR, TOPICS_DIR, FETCH_ALL, NEWSBOT_SEND

# === LLM 配置（多后端，按优先级） ===
API_BACKENDS = [
    {
        "name": "DeepSeek",
        "endpoint": "https://api.deepseek.com/chat/completions",
        "model": "deepseek-chat",
        "key_cmd": ["pass", "show", "api/deepseek"],
    },
    {
        "name": "ZAI (Zeabur)",
        "endpoint": "https://open.zeabur.com/v1/chat/completions",
        "model": "glm-5",
        "key_cmd": ["pass", "show", "api/zai"],
    },
]

# === 评分权重 ===
WEIGHTS = {"heat": 0.35, "timeliness": 0.25, "creativity": 0.40}

# === 批量评分 prompt ===
SCORING_PROMPT = """你是一个内容选题专家。请对以下热点逐条评分（0-100），并推荐创作角度。

评分维度：
- heat（热度）：当前关注度和讨论量，越火越高
- timeliness（时效性）：话题新鲜度，过时的打低分
- creativity（创作空间）：能否写出有价值、有深度的内容，纯新闻搬运打低分

对每条热点输出 JSON（严格格式，不要多余文字）：
```json
[
  {
    "index": 0,
    "heat": 85,
    "timeliness": 90,
    "creativity": 75,
    "angle": "推荐的创作角度（一句话）"
  },
  ...
]
```

以下是待评分的热点列表：
{items_text}
"""

BATCH_SIZE = 15


def init_backend():
    """初始化可用的 API 后端，清除代理干扰"""
    # 环境里可能存在 socks 代理(不被 httpx 支持方案)，这里优先禁用 SOCKS，仅保留 HTTP 代理
    for var in ["ALL_PROXY", "all_proxy"]:
        os.environ.pop(var, None)

    import httpx
    # 诊断：显示代理环境（仅供调试，不打印 key）
    # print('HTTP_PROXY=', os.environ.get('HTTP_PROXY'), 'HTTPS_PROXY=', os.environ.get('HTTPS_PROXY'))
    for backend in API_BACKENDS:
        try:
            result = subprocess.run(backend["key_cmd"], capture_output=True, text=True, timeout=10)
            key = result.stdout.strip()
            if not key:
                continue
            r = httpx.post(
                backend["endpoint"],
                json={"model": backend["model"], "messages": [{"role": "user", "content": "say ok"}], "max_tokens": 5},
                headers={"Authorization": f"Bearer {key}", "Content-Type": "application/json"},
                timeout=30,
            )
            if r.status_code == 200:
                print(f"✅ 使用 API: {backend['name']} ({backend['model']})")
                return {"endpoint": backend["endpoint"], "model": backend["model"], "key": key}
            else:
                print(f"  ⚠️ {backend['name']}: HTTP {r.status_code} {r.text[:100]}")
        except Exception as e:
            print(f"  ⚠️ {backend['name']}: {e}")
    print("❌ 无可用 API 后端", file=sys.stderr)
    sys.exit(1)


def load_hotpool(date_str: str) -> list:
    """加载热点池"""
    path = HOTPOOL_DIR / f"{date_str}.json"
    if not path.exists():
        print(f"⚠️ {path} 不存在，尝试调用 fetch_all.py 采集...")
        if FETCH_ALL.exists():
            subprocess.run([sys.executable, str(FETCH_ALL)], timeout=120)
        if not path.exists():
            files = sorted(HOTPOOL_DIR.glob("*.json"), reverse=True)
            if files:
                path = files[0]
                print(f"📂 使用最新热点池: {path.name}")
            else:
                print("❌ 无可用热点池", file=sys.stderr)
                sys.exit(1)

    data = json.loads(path.read_text())
    items = data.get("items", data if isinstance(data, list) else [])
    valid = [it for it in items if len(it.get("title", "")) > 10]
    print(f"📥 加载 {len(valid)} 条有效热点 (共 {len(items)} 条)")
    return valid


def call_llm(prompt: str, backend: dict, retries: int = 2) -> str:
    """调用 LLM API"""
    import httpx
    for attempt in range(retries + 1):
        try:
            r = httpx.post(
                backend["endpoint"],
                json={"model": backend["model"], "messages": [{"role": "user", "content": prompt}],
                      "temperature": 0.3, "max_tokens": 4096},
                headers={"Authorization": f"Bearer {backend['key']}", "Content-Type": "application/json"},
                timeout=90,
            )
            r.raise_for_status()
            return r.json()["choices"][0]["message"]["content"]
        except Exception as e:
            if attempt < retries:
                wait = 2 ** (attempt + 1)
                print(f"  ⏳ LLM 请求失败 ({e}), {wait}s 后重试...")
                time.sleep(wait)
            else:
                raise


def parse_scores(llm_output: str) -> list:
    """从 LLM 输出中解析评分 JSON"""
    text = llm_output
    if "```json" in text:
        text = text.split("```json")[1].split("```")[0]
    elif "```" in text:
        text = text.split("```")[1].split("```")[0]
    start = text.find("[")
    end = text.rfind("]")
    if start >= 0 and end > start:
        text = text[start:end + 1]
    try:
        return json.loads(text)
    except json.JSONDecodeError:
        print(f"  ⚠️ JSON 解析失败，跳过此批", file=sys.stderr)
        return []


def score_items(items: list, backend: dict) -> list:
    """批量评分所有热点"""
    scored = []
    total_batches = (len(items) + BATCH_SIZE - 1) // BATCH_SIZE

    for batch_idx in range(total_batches):
        start = batch_idx * BATCH_SIZE
        end = min(start + BATCH_SIZE, len(items))
        batch = items[start:end]

        print(f"🔄 评分第 {batch_idx + 1}/{total_batches} 批 ({len(batch)} 条)...")

        items_text = ""
        for i, item in enumerate(batch):
            source = item.get("source", "unknown")
            title = str(item.get("title", "")).strip()
            summary = str(item.get("summary", "")).strip()[:200]
            author = str(item.get("author", ""))
            items_text += f"\n[{i}] 来源:{source} | 作者:{author}\n标题: {title}\n摘要: {summary}\n"

        prompt = SCORING_PROMPT.replace("{items_text}", items_text)

        try:
            output = call_llm(prompt, backend)
            scores = parse_scores(output)
            for score in scores:
                idx = score.get("index", -1)
                if 0 <= idx < len(batch):
                    item = batch[idx].copy()
                    item["scores"] = {
                        "heat": score.get("heat", 50),
                        "timeliness": score.get("timeliness", 50),
                        "creativity": score.get("creativity", 50),
                    }
                    item["angle"] = score.get("angle", "")
                    item["total_score"] = round(
                        item["scores"]["heat"] * WEIGHTS["heat"]
                        + item["scores"]["timeliness"] * WEIGHTS["timeliness"]
                        + item["scores"]["creativity"] * WEIGHTS["creativity"]
                    )
                    # 兼容 downstream: 每个 item 必须有 score 字段
                    item["score"] = item["total_score"]
                    scored.append(item)
        except Exception as e:
            print(f"  ❌ 第 {batch_idx + 1} 批评分失败: {e}", file=sys.stderr)
            for item in batch:
                c = item.copy()
                c["scores"] = {"heat": 50, "timeliness": 50, "creativity": 50}
                c["angle"] = "需人工评估"
                c["total_score"] = 50
                c["score"] = 50
                scored.append(c)

        if batch_idx < total_batches - 1:
            time.sleep(1)

    return scored


def format_telegram_message(top_items: list, date_str: str) -> str:
    """生成 Telegram 选题卡片消息"""
    nums = ["1️⃣", "2️⃣", "3️⃣", "4️⃣", "5️⃣", "6️⃣", "7️⃣", "8️⃣", "9️⃣", "🔟"]
    lines = [f"🔥 今日热点选题 Top {len(top_items)} ({date_str})", "━━━━━━━━━━━━━━", ""]

    for i, item in enumerate(top_items):
        num = nums[i] if i < 10 else f"[{i+1}]"
        title = item.get("title", "").strip()
        if len(title) > 60:
            title = title[:57] + "..."
        total = item.get("total_score", 0)
        s = item.get("scores", {})
        source = item.get("source", "?")
        category = item.get("category", "")
        angle = item.get("angle", "")
        source_tag = f"{source}/{category}" if category else source

        lines.append(f"{num} {title} ⭐{total}")
        lines.append(f"📊 热度:{s.get('heat',0)} 时效:{s.get('timeliness',0)} 创作:{s.get('creativity',0)}")
        lines.append(f"📌 来源: {source_tag} | 💡 角度: {angle}")
        lines.append("")

    lines.extend(["━━━━━━━━━━━━━━", "📝 回复编号选择主题（如 \"1 3 7\"）", "💡 也可自定义主题"])
    return "\n".join(lines)


def save_topics(scored_items: list, top_items: list, date_str: str):
    """保存评分结果"""
    TOPICS_DIR.mkdir(parents=True, exist_ok=True)
    output = {
        "date": date_str,
        "scored_at": datetime.now().isoformat(),
        "total_scored": len(scored_items),
        "top_count": len(top_items),
        "weights": WEIGHTS,
        "top": top_items,
        "all_scored": scored_items,
    }
    path = TOPICS_DIR / f"{date_str}.json"
    path.write_text(json.dumps(output, indent=2, ensure_ascii=False))
    print(f"💾 保存到 {path}")


def send_via_newsbot(message: str):
    """通过 newsbot_send.py 推送"""
    if not NEWSBOT_SEND.exists():
        print(f"⚠️ {NEWSBOT_SEND} 不存在，跳过推送")
        return False
    try:
        proc = subprocess.run(
            [sys.executable, str(NEWSBOT_SEND), "--message", message],
            capture_output=True, text=True, timeout=30,
        )
        if proc.returncode == 0:
            print("📤 推送成功")
            return True
        print(f"⚠️ 推送失败: {proc.stderr}", file=sys.stderr)
        return False
    except Exception as e:
        print(f"⚠️ 推送异常: {e}", file=sys.stderr)
        return False


def main():
    parser = argparse.ArgumentParser(description="热点选题评分")
    parser.add_argument("--date", default=datetime.now().strftime("%Y-%m-%d"), help="热点池日期")
    parser.add_argument("--top", type=int, default=10, help="Top N")
    parser.add_argument("--limit", type=int, default=0, help="只评分前N条热点(0表示全部)")
    parser.add_argument("--no-send", action="store_true", help="不推送")
    parser.add_argument("--dry-run", action="store_true", help="不调LLM，用随机分")
    args = parser.parse_args()

    print(f"📅 选题评分: {args.date}")
    items = load_hotpool(args.date)
    if args.limit and args.limit > 0:
        items = items[:args.limit]
        print(f"✂️ 只评分前 {len(items)} 条热点 (--limit)")
    if not items:
        print("❌ 热点池为空")
        sys.exit(1)

    if args.dry_run:
        import random
        print("🧪 Dry run 模式")
        scored = []
        for item in items:
            c = item.copy()
            h, t, cr = random.randint(40, 100), random.randint(40, 100), random.randint(40, 100)
            c["scores"] = {"heat": h, "timeliness": t, "creativity": cr}
            c["total_score"] = round(h * WEIGHTS["heat"] + t * WEIGHTS["timeliness"] + cr * WEIGHTS["creativity"])
            c["score"] = c["total_score"]
            c["angle"] = "dry-run"
            scored.append(c)
    else:
        backend = init_backend()
        scored = score_items(items, backend)

    scored.sort(key=lambda x: x.get("total_score", 0), reverse=True)
    top = scored[:args.top]

    print(f"\n🏆 Top {len(top)} 选题:")
    for i, item in enumerate(top):
        print(f"  {i+1}. [{item.get('total_score',0)}分] {item.get('title','')[:50]}")

    save_topics(scored, top, args.date)
    message = format_telegram_message(top, args.date)
    print(f"\n{message}")

    if not args.no_send:
        send_via_newsbot(message)

    return message


if __name__ == "__main__":
    main()