Taxue Weread

#!/usr/bin/env node
const { spawn } = require('child_process');

function checkPython() {
  return new Promise((resolve, reject) => {
    const proc = spawn('python3', ['--version']);
    let output = '';
    proc.stdout.on('data', (d) => output += d);
    proc.stderr.on('data', (d) => output += d);
    proc.on('close', (code) => {
      if (code === 0) {
        console.log(`✅ ${output.trim()}`);
        resolve();
      } else {
        // 尝试 python
        const proc2 = spawn('python', ['--version']);
        let output2 = '';
        proc2.stdout.on('data', (d) => output2 += d);
        proc2.stderr.on('data', (d) => output2 += d);
        proc2.on('close', (code2) => {
          if (code2 === 0) {
            console.log(`✅ ${output2.trim()}`);
            resolve();
          } else {
            console.error('❌ Python 3 is required but not found.');
            console.error('   Install Python 3: https://www.python.org/downloads/');
            reject(new Error('Python 3 not found'));
          }
        });
      }
    });
  });
}

checkPython().catch(() => process.exit(1));

#!/usr/bin/env node
const { spawn } = require('child_process');
const path = require('path');
const fs = require('fs');

const SCRIPT_DIR = path.resolve(__dirname, '..', 'scripts');
const PYTHON_SCRIPT = path.join(SCRIPT_DIR, 'weread.py');

// 检查 Python 是否可用
function checkPython() {
  return new Promise((resolve, reject) => {
    const proc = spawn('python3', ['--version']);
    proc.on('close', (code) => {
      if (code === 0) resolve('python3');
      else {
        // 尝试 python
        const proc2 = spawn('python', ['--version']);
        proc2.on('close', (code2) => {
          if (code2 === 0) resolve('python');
          else reject(new Error('Python 3 is required. Please install Python 3.'));
        });
      }
    });
  });
}

async function main() {
  // 检查 WEREAD_API_KEY
  if (!process.env.WEREAD_API_KEY) {
    console.error('错误: WEREAD_API_KEY 未设置，请 export WEREAD_API_KEY=wrk-xxxxxxxx');
    process.exit(1);
  }

  // 检查脚本是否存在
  if (!fs.existsSync(PYTHON_SCRIPT)) {
    console.error(`错误: 找不到脚本 ${PYTHON_SCRIPT}`);
    process.exit(1);
  }

  try {
    const pythonCmd = await checkPython();

    // 传递所有参数给 Python 脚本
    const args = [PYTHON_SCRIPT, ...process.argv.slice(2)];
    const proc = spawn(pythonCmd, args, {
      stdio: 'inherit',
      env: process.env
    });

    proc.on('close', (code) => {
      process.exit(code || 0);
    });

    proc.on('error', (err) => {
      console.error('执行错误:', err.message);
      process.exit(1);
    });
  } catch (err) {
    console.error(err.message);
    process.exit(1);
  }
}

main();

{
  "name": "taxue-weread",
  "version": "1.5.0",
  "description": "微信读书官方 Skill 的 Agent 优化版——CLI + 缓存 + 合并命令 + 压缩输出",
  "bin": {
    "taxue-weread": "bin/taxue-weread.js",
    "twr": "bin/taxue-weread.js"
  },
  "files": [
    "bin",
    "scripts",
    "SKILL.md",
    "references",
    "README.md",
    "RELEASE.md"
  ],
  "scripts": {
    "postinstall": "node bin/check-python.js"
  },
  "engines": {
    "node": ">=18.0.0"
  },
  "keywords": [
    "weread",
    "wechat-read",
    "agent",
    "skill",
    "cli",
    "book",
    "reading",
    "notes",
    "highlights"
  ],
  "author": "taxueseek",
  "license": "MIT",
  "repository": {
    "type": "git",
    "url": "https://github.com/taxueseek/taxue-weread.git"
  },
  "bugs": {
    "url": "https://github.com/taxueseek/taxue-weread/issues"
  },
  "homepage": "https://github.com/taxueseek/taxue-weread#readme"
}

#!/usr/bin/env python3
"""weread.py 功能测试 — 覆盖所有子命令和工具函数。"""
import json
import os
import sys
import unittest
import io
from unittest.mock import patch, MagicMock

# Add skill dir to path
sys.path.insert(0, os.path.dirname(__file__))
import weread


class TestUtilities(unittest.TestCase):
    """测试工具函数"""

    def test_ts_to_date(self):
        self.assertEqual(weread.ts_to_date(1748563200), "2025-05-30")
        self.assertEqual(weread.ts_to_date(0), "1970-01-01")

    def test_secs_to_hms(self):
        self.assertEqual(weread.secs_to_hms(0), "0分钟")
        self.assertEqual(weread.secs_to_hms(60), "1分钟")
        self.assertEqual(weread.secs_to_hms(3661), "1小时1分钟")
        self.assertEqual(weread.secs_to_hms(7200), "2小时0分钟")
        self.assertEqual(weread.secs_to_hms(9000), "2小时30分钟")
        self.assertEqual(weread.secs_to_hms(3600), "1小时0分钟")

    def test_star_to_str(self):
        self.assertEqual(weread.star_to_str(100), "⭐⭐⭐⭐⭐")
        self.assertEqual(weread.star_to_str(80), "⭐⭐⭐⭐")
        self.assertEqual(weread.star_to_str(60), "⭐⭐⭐")
        self.assertEqual(weread.star_to_str(40), "⭐⭐")
        self.assertEqual(weread.star_to_str(20), "⭐")
        self.assertEqual(weread.star_to_str(-1), "无评分")
        self.assertEqual(weread.star_to_str(0), "无评分")

    def test_rating_to_str(self):
        """评分 0-1000 → 文字"""
        self.assertEqual(weread.rating_to_str(950), "神作 95%")
        self.assertEqual(weread.rating_to_str(856), "力荐 86%")
        self.assertEqual(weread.rating_to_str(750), "好评 75%")
        self.assertEqual(weread.rating_to_str(500), "50.0分")
        self.assertEqual(weread.rating_to_str(0), "暂无")
        self.assertEqual(weread.rating_to_str(None), "暂无")

    def test_make_deep_link(self):
        # book only
        self.assertEqual(
            weread.make_deep_link("123"),
            "weread://reading?bId=123"
        )
        # book + chapter
        self.assertEqual(
            weread.make_deep_link("123", "456"),
            "weread://reading?bId=123&chapterUid=456"
        )
        # bookmark
        self.assertEqual(
            weread.make_deep_link("123", "456", "100", "200"),
            "weread://bestbookmark?bookId=123&chapterUid=456&rangeStart=100&rangeEnd=200"
        )
        # bookmark + userVid
        self.assertEqual(
            weread.make_deep_link("123", "456", "100", "200", "vid1"),
            "weread://bestbookmark?bookId=123&chapterUid=456&rangeStart=100&rangeEnd=200&userVid=vid1"
        )

    def test_truncate(self):
        self.assertEqual(weread.truncate("short", 200), "short")
        self.assertEqual(weread.truncate("x" * 300, 200), "x" * 200 + "…")

    def test_paginate(self):
        items = list(range(25))
        # page 1, 10 per page
        result, total = weread.paginate(items, 1, 10)
        self.assertEqual(result, list(range(10)))
        self.assertEqual(total, 3)
        # page 2
        result, total = weread.paginate(items, 2, 10)
        self.assertEqual(result, list(range(10, 20)))
        self.assertEqual(total, 3)
        # page 3
        result, total = weread.paginate(items, 3, 10)
        self.assertEqual(result, list(range(20, 25)))
        self.assertEqual(total, 3)
        # empty
        result, total = weread.paginate([], 1, 10)
        self.assertEqual(result, [])
        self.assertEqual(total, 1)

    def test_paginate_mark(self):
        items = list(range(25))
        # first page
        _, total, prev, nxt = weread.paginate_mark(items, 1, 10)
        self.assertEqual(total, 3)
        self.assertFalse(prev)
        self.assertTrue(nxt)
        # middle
        _, total, prev, nxt = weread.paginate_mark(items, 2, 10)
        self.assertEqual(total, 3)
        self.assertTrue(prev)
        self.assertTrue(nxt)
        # last
        _, total, prev, nxt = weread.paginate_mark(items, 3, 10)
        self.assertEqual(total, 3)
        self.assertTrue(prev)
        self.assertFalse(nxt)
        # single page
        _, total, prev, nxt = weread.paginate_mark(list(range(5)), 1, 10)
        self.assertEqual(total, 1)
        self.assertFalse(prev)
        self.assertFalse(nxt)


class TestCommands(unittest.TestCase):
    """测试各子命令输出 — 使用 mock API"""

    def setUp(self):
        self.mock_api = MagicMock()

    def _run_command(self, func, args_obj, mock_api=None):
        """捕获命令 stdout 输出"""
        api = mock_api or self.mock_api
        buf = io.StringIO()
        old_stdout = sys.stdout
        sys.stdout = buf
        try:
            func(api, args_obj)
        finally:
            sys.stdout = old_stdout
        return buf.getvalue()

    def test_cmd_search(self):
        """测试搜索命令输出"""
        self.mock_api.call.return_value = {
            "results": [{
                "title": "电子书",
                "scope": 10,
                "scopeCount": 2,
                "currentCount": 2,
                "books": [
                    {
                        "bookInfo": {
                            "bookId": "695233", "title": "三体", "author": "刘慈欣",
                            "category": "科幻", "newRating": 960, "newRatingCount": 50000,
                            "newRatingDetail": {"title": "神作"}, "intro": "科幻巨作",
                            "payType": 1, "price": 0, "soldout": 0,
                        },
                        "readingCount": 100000,
                    },
                    {
                        "bookInfo": {
                            "bookId": "695234", "title": "三体2", "author": "刘慈欣",
                            "category": "科幻", "newRating": 94, "newRatingCount": 40000,
                            "intro": "黑暗森林", "soldout": 0,
                        },
                        "readingCount": 80000,
                    },
                ],
            }],
        }
        args = MagicMock()
        args.keyword = "三体"
        args.scope = None
        args.count = None
        args.page = 1
        args.per_page = 10

        output = self._run_command(weread.cmd_search, args)
        self.assertIn("三体", output)
        self.assertIn("刘慈欣", output)
        self.assertIn("weread://reading?bId=695233", output)
        self.assertIn("100000人在读", output)
        self.assertIn("共 2 条结果", output)

    def test_cmd_search_no_results(self):
        """搜索无结果"""
        self.mock_api.call.return_value = {"results": []}
        args = MagicMock()
        args.keyword = "zzzxxx"
        args.scope = None
        args.count = None
        args.page = 1
        args.per_page = 10
        output = self._run_command(weread.cmd_search, args)
        self.assertIn("未找到", output)

    def test_cmd_shelf(self):
        """测试书架命令"""
        self.mock_api.call.return_value = {
            "books": [
                {"bookId": "1", "title": "书A", "author": "作者A", "secret": 0, "readUpdateTime": 1748563200, "isTop": 1, "finishReading": 0, "category": "文学"},
                {"bookId": "2", "title": "书B", "author": "作者B", "secret": 1, "readUpdateTime": 1748000000, "isTop": 0, "finishReading": 1, "category": "科幻"},
            ],
            "albums": [
                {"albumInfo": {"albumId": "a1", "name": "有声A", "authorName": "播者A", "finish": 0}, "albumInfoExtra": {"secret": 0, "lectureReadUpdateTime": 0}},
            ],
            "mp": None,
        }
        args = MagicMock()
        args.page = 1
        args.per_page = 10

        output = self._run_command(weread.cmd_shelf, args)
        self.assertIn("共 3 个条目", output)
        self.assertIn("2 本电子书", output)
        self.assertIn("1 个专辑/有声书", output)
        self.assertIn("公开 2", output)
        self.assertIn("私密 1", output)
        self.assertIn("书A", output)
        self.assertIn("书B", output)
        self.assertIn("有声A", output)
        self.assertIn("置顶", output)
        self.assertIn("2025-05-30", output)

    def test_cmd_shelf_with_mp(self):
        """测试书架含文章收藏"""
        self.mock_api.call.return_value = {
            "books": [{"bookId": "1", "title": "书A", "author": "作者A", "secret": 0, "readUpdateTime": 0, "isTop": 0, "finishReading": 0, "category": "文学"}],
            "albums": [],
            "mp": {"some": "data"},
        }
        args = MagicMock()
        args.page = 1
        args.per_page = 10
        output = self._run_command(weread.cmd_shelf, args)
        self.assertIn("共 2 个条目", output)
        self.assertIn("文章收藏", output)
        self.assertIn("私密 1", output)  # mp counts as private

    def test_cmd_book(self):
        """测试书籍详情"""
        self.mock_api.call.side_effect = [
            {  # /book/info
                "bookId": "695233", "title": "三体", "author": "刘慈欣",
                "category": "科幻", "publisher": "科幻世界",
                "newRating": 960, "newRatingCount": 50000,
                "intro": "文化大革命如火如荼进行的同时…",
                "wordCount": 200000, "isbn": "9787536692930",
                "publishTime": "2008",
            },
            {  # /book/getprogress
                "book": {
                    "progress": 45, "recordReadingTime": 7200,
                    "updateTime": 1748563200, "finishTime": None,
                },
            },
        ]
        args = MagicMock()
        args.bookId = "695233"
        args.chapters = False
        args.progress = True
        args.chapters_page = 1
        args.chapters_per_page = 20

        output = self._run_command(weread.cmd_book, args)
        self.assertIn("三体", output)
        self.assertIn("刘慈欣", output)
        self.assertIn("神作 96%", output)
        self.assertIn("20.0万字", output)
        self.assertIn("weread://reading?bId=695233", output)
        self.assertIn("进度: 45%", output)
        self.assertIn("2小时0分钟", output)

    def test_cmd_book_chapters(self):
        """测试章节目录"""
        calls = []
        from weread import SKILL_VERSION
        def side_effect(api_name, **params):
            calls.append((api_name, params))
            if api_name == "/book/info":
                return {"title": "测试书", "author": "作者", "bookId": "1"}
            elif api_name == "/book/chapterinfo":
                return {
                    "chapters": [
                        {"chapterUid": 1, "title": "第一章", "level": 1, "paid": 1, "price": 100},
                        {"chapterUid": 2, "title": "第一节", "level": 2, "paid": 0, "price": 0},
                        {"chapterUid": 3, "title": "第二章", "level": 1, "paid": 0, "price": 0},
                    ],
                }
            return {}
        self.mock_api.call.side_effect = side_effect

        args = MagicMock()
        args.bookId = "1"
        args.chapters = True
        args.progress = False
        args.chapters_page = 1
        args.chapters_per_page = 20

        output = self._run_command(weread.cmd_book, args)
        self.assertIn("第一章", output)
        self.assertIn("第一节", output)  # level 2 should be indented
        self.assertIn("第二章", output)

    def test_cmd_notes_overview(self):
        """测试笔记本概览"""
        self.mock_api.call.return_value = {
            "books": [
                {"bookId": "1", "book": {"title": "书A", "author": "作者A"},
                 "reviewCount": 10, "noteCount": 20, "bookmarkCount": 5,
                 "readingProgress": 80, "markedStatus": 0, "sort": 1000},
                {"bookId": "2", "book": {"title": "书B", "author": "作者B"},
                 "reviewCount": 5, "noteCount": 15, "bookmarkCount": 3,
                 "readingProgress": 100, "markedStatus": 1, "sort": 900},
            ],
            "hasMore": 0,
        }
        args = MagicMock()
        args.book = None
        args.bookId = None
        args.page = 1
        args.per_page = 10
        args.max_pages = 5

        output = self._run_command(weread.cmd_notes, args)
        self.assertIn("有笔记的书共 2 本", output)
        self.assertIn("书A", output)
        self.assertIn("书B", output)
        self.assertIn("笔记 35 条", output)  # 10+20+5=35
        self.assertIn("笔记 23 条", output)  # 5+15+3=23
        self.assertIn("weread.py notes --book", output)  # CLI reference

    def test_cmd_notes_single_book(self):
        """测试单本书笔记"""
        self.mock_api.call.side_effect = [
            {  # /book/bookmarklist
                "updated": [{
                    "bookmarkId": "b1", "chapterUid": 1, "markText": "给岁月以文明",
                    "createTime": 1748563200, "range": "100-110",
                }],
                "chapters": [{"chapterUid": 1, "title": "第一章"}],
            },
            {  # /review/list/mine
                "reviews": [{
                    "review": {
                        "content": "这段写得真好", "star": 100, "createTime": 1748563200,
                        "chapterName": "第一章", "chapterUid": 1, "range": "100-110",
                    },
                }],
            },
        ]
        args = MagicMock()
        args.book = "1"
        args.bookId = "1"
        args.page = 1
        args.per_page = 10

        output = self._run_command(weread.cmd_notes, args)
        self.assertIn("给岁月以文明", output)
        self.assertIn("这段写得真好", output)
        self.assertIn("weread://bestbookmark", output)

    def test_cmd_notes_empty(self):
        """测试无笔记"""
        self.mock_api.call.side_effect = [
            {"updated": [], "chapters": []},
            {"reviews": []},
        ]
        args = MagicMock()
        args.book = "1"
        args.bookId = "1"
        args.page = 1
        args.per_page = 10

        output = self._run_command(weread.cmd_notes, args)
        self.assertIn("暂无划线", output)
        self.assertIn("暂无个人想法", output)

    def test_cmd_readdata(self):
        """测试阅读统计"""
        self.mock_api.call.return_value = {
            "readDays": 15, "totalReadTime": 5400, "dayAverageReadTime": 1800,
            "compare": 0.2,
            "readStat": [
                {"stat": "读过", "counts": "5本"},
                {"stat": "读完", "counts": "2本"},
                {"stat": "笔记", "counts": "30条"},
            ],
            "readLongest": [
                {"book": {"title": "书A", "author": "作者A"}, "readTime": 3600, "tags": ["笔记最多"]},
            ],
            "preferCategory": [
                {"categoryTitle": "文学", "readingCount": 3, "readingTime": 2000},
            ],
            "preferCategoryWord": "偏好阅读文学",
            "preferTimeWord": "偏好夜间阅读",
        }
        args = MagicMock()
        args.mode = "monthly"
        args.time = 0

        output = self._run_command(weread.cmd_readdata, args)
        self.assertIn("本月", output)  # mode=monthly
        self.assertIn("阅读 15 天", output)
        self.assertIn("1小时30分钟", output)  # 5400s
        self.assertIn("↑20%", output)  # compare=0.2
        self.assertIn("读过: 5本", output)
        self.assertIn("书A", output)
        self.assertIn("文学", output)

    def test_cmd_readdata_annually(self):
        """测试年度阅读统计"""
        self.mock_api.call.return_value = {
            "readDays": 200, "totalReadTime": 360000, "dayAverageReadTime": 986,
        }
        args = MagicMock()
        args.mode = "annually"
        args.time = 0

        output = self._run_command(weread.cmd_readdata, args)
        self.assertIn("本年", output)
        self.assertIn("100小时0分钟", output)

    def test_cmd_review(self):
        """测试书籍点评"""
        self.mock_api.call.return_value = {
            "reviewsCnt": 2,
            "deepVRecommendInfo": {"title": "100 个资深会员点评", "subtitle": "其中 80 人推荐"},
            "reviews": [{
                "idx": 0,
                "review": {"review": {
                    "content": "非常好看的一本书，强烈推荐！",
                    "star": 100, "createTime": 1748563200,
                    "author": {"name": "读者A", "userVid": "v1"},
                    "isFinish": True, "chapterName": "",
                }},
            }],
        }
        args = MagicMock()
        args.bookId = "123"
        args.type = 0
        args.page = 1
        args.per_page = 10

        output = self._run_command(weread.cmd_review, args)
        self.assertIn("点评共 2 条", output)
        self.assertIn("读者A", output)
        self.assertIn("⭐⭐⭐⭐⭐", output)
        self.assertIn("非常好看", output)
        self.assertIn("100 个资深会员点评", output)

    def test_cmd_discover_recommend(self):
        """测试为你推荐"""
        self.mock_api.call.return_value = {
            "books": [
                {"bookId": "1", "title": "推荐书A", "author": "作者A",
                 "newRating": 900, "readingCount": 5000, "reason": "看过三体的人也看",
                 "intro": "一本好书"},
            ],
        }
        args = MagicMock()
        args.book = None
        args.bookId = None
        args.page = 1
        args.per_page = 10
        args.max_pages = 5

        output = self._run_command(weread.cmd_discover, args)
        self.assertIn("为你推荐", output)
        self.assertIn("推荐书A", output)
        self.assertIn("看过三体的人也看", output)
        self.assertIn("weread://reading?bId=1", output)

    def test_cmd_discover_similar(self):
        """测试相似推荐"""
        self.mock_api.call.return_value = {
            "booksimilar": {
                "books": [{
                    "book": {"bookInfo": {"bookId": "2", "title": "相似书", "author": "作者B", "newRating": 85, "readingCount": 3000}},
                }],
            },
        }
        args = MagicMock()
        args.book = "1"
        args.bookId = "1"
        args.page = 1
        args.per_page = 10

        output = self._run_command(weread.cmd_discover, args)
        self.assertIn("相似书推荐", output)
        self.assertIn("相似书", output)

    def test_cmd_discover_empty(self):
        """测试推荐为空"""
        self.mock_api.call.return_value = {"books": []}
        args = MagicMock()
        args.book = None
        args.bookId = None
        args.page = 1
        args.per_page = 10
        args.max_pages = 5
        output = self._run_command(weread.cmd_discover, args)
        self.assertIn("暂无推荐", output)

    def test_cmd_list_apis(self):
        """测试列出接口"""
        self.mock_api.call.return_value = {
            "apis": [
                {"api_name": "/shelf/sync", "description": "同步书架", "params": []},
                {"api_name": "/store/search", "description": "搜索", "params": [
                    {"name": "keyword", "type": "string", "desc": "关键词"},
                ]},
            ],
        }
        args = MagicMock()
        output = self._run_command(weread.cmd_list_apis, args)
        self.assertIn("/shelf/sync", output)
        self.assertIn("/store/search", output)

    def test_pagination_output(self):
        """测试分页输出 — 项目超过 per_page 时显示页码"""
        books = []
        for i in range(25):
            books.append({
                "bookInfo": {"bookId": str(i), "title": f"书{i}", "author": f"作者{i}",
                             "newRating": 80, "newRatingCount": i * 100,
                             "newRatingDetail": {}, "soldout": 0, "intro": ""},
                "readingCount": i * 10,
            })
        self.mock_api.call.return_value = {
            "results": [{"title": "电子书", "scope": 10, "scopeCount": 25, "currentCount": 25, "books": books}],
        }
        args = MagicMock()
        args.keyword = "test"
        args.scope = None
        args.count = None

        # page 1
        args.page = 1
        args.per_page = 10
        output = self._run_command(weread.cmd_search, args)
        self.assertIn("第 1/3 页", output)
        self.assertIn("--page 2 下一页", output)
        self.assertIn("书0", output)
        self.assertIn("书9", output)
        self.assertNotIn("书10:", output)  # not on page 1

        # page 2
        args.page = 2
        output = self._run_command(weread.cmd_search, args)
        self.assertIn("第 2/3 页", output)
        self.assertIn("书10", output)
        self.assertIn("书19", output)

        # page 3 (last page)
        args.page = 3
        output = self._run_command(weread.cmd_search, args)
        self.assertIn("第 3/3 页", output)
        self.assertNotIn("下一页", output)  # last page, no next

    def test_cli_argparse(self):
        """测试 CLI 参数解析 — 各子命令正常创建"""
        import argparse
        # We just verify all subparsers register without error
        # by importing the module's main function (not calling it)
        # Instead, test help output by running with --help
        pass  # argparse test covered by integration



class TestAPIErrors(unittest.TestCase):
    """测试 API 错误处理"""

    def test_missing_key(self):
        """测试未设置 WEREAD_API_KEY"""
        old_key = os.environ.pop("WEREAD_API_KEY", None)
        try:
            with self.assertRaises(SystemExit) as cm:
                weread.WereadAPI()
            self.assertEqual(cm.exception.code, 1)
        finally:
            if old_key:
                os.environ["WEREAD_API_KEY"] = old_key


class TestVersion(unittest.TestCase):
    """测试版本号存在"""
    def test_skill_version(self):
        self.assertEqual(weread.SKILL_VERSION, "1.5.0")


def run_all_tests():
    """Run all tests and return True if all pass."""
    loader = unittest.TestLoader()
    suite = unittest.TestSuite()
    suite.addTests(loader.loadTestsFromTestCase(TestUtilities))
    suite.addTests(loader.loadTestsFromTestCase(TestCommands))
    suite.addTests(loader.loadTestsFromTestCase(TestAPIErrors))
    suite.addTests(loader.loadTestsFromTestCase(TestVersion))

    runner = unittest.TextTestRunner(verbosity=2)
    result = runner.run(suite)
    return result.wasSuccessful()


if __name__ == "__main__":
    success = run_all_tests()
    sys.exit(0 if success else 1)

#!/usr/bin/env python3
"""
微信读书批量查询 — 一次进程调用，避免多次启动开销

用法:
  python3 weread_batch.py info <bookId1> <bookId2> ...
  python3 weread_batch.py search "关键词1" "关键词2" ...
  python3 weread_batch.py notes <bookId>
  python3 weread_batch.py chapters <bookId>
  python3 weread_batch.py bookmarks <bookId> [--count 20]

输出: JSON
"""
import sys, json, subprocess, os
from concurrent.futures import ThreadPoolExecutor, as_completed

WR = os.path.join(os.path.dirname(__file__), "weread.py")


def cmd(*args):
    """执行命令，返回 stdout"""
    r = subprocess.run([WR] + list(args), capture_output=True, text=True, timeout=15)
    return r.stdout.strip()


def parse_json(stdout):
    """
    解析 weread.py 的 JSON 输出。
    weread.py 的 mirror 等命令会输出进度信息（如 [1/2] 并发获取...），
    需要跳过这些非 JSON 行，找到第一个 { 开始的 JSON 对象。
    """
    if not stdout:
        return None
    json_start = stdout.find('{')
    if json_start == -1:
        return None
    return json.loads(stdout[json_start:])


def info_batch(book_ids):
    """批量获取书籍详情"""
    results = []
    with ThreadPoolExecutor(max_workers=5) as ex:
        futs = {ex.submit(cmd, "book", str(bid)): bid for bid in book_ids}
        for f in as_completed(futs):
            stdout = f.result()
            if stdout:
                info = {"book_id": str(futs[f])}
                for line in stdout.split("\n"):
                    line = line.strip()
                    if line.startswith("《") and line.endswith("》"):
                        info["title"] = line.strip("《》")
                    elif line.startswith("作者:"):
                        info["author"] = line.split(":", 1)[1].strip()
                    elif line.startswith("评分:"):
                        info["rating"] = line.split(":", 1)[1].strip()
                    elif line.startswith("分类:"):
                        info["category"] = line.split(":", 1)[1].strip()
                    elif line.startswith("出版社:"):
                        info["publisher"] = line.split(":", 1)[1].strip()
                    elif line.startswith("简介:"):
                        info["intro"] = line.split(":", 1)[1].strip()[:200]
                results.append(info)
    return results


def search_batch(keywords):
    """批量搜索"""
    results = {}
    with ThreadPoolExecutor(max_workers=5) as ex:
        futs = {ex.submit(cmd, "search", kw, "--json"): kw for kw in keywords}
        for f in as_completed(futs):
            stdout = f.result()
            if stdout:
                items = json.loads(stdout).get("items", [])
                for item in items[:5]:
                    bid = item["bookId"]
                    if bid not in results:
                        results[bid] = {
                            "title": item["title"],
                            "author": item.get("author", ""),
                            "rating": round(item.get("newRating", 0) / 10, 1),
                            "rating_count": item.get("newRatingCount", 0),
                            "category": item.get("category", ""),
                            "book_id": bid
                        }
    return list(results.values())


def main():
    if len(sys.argv) < 3:
        print(__doc__)
        sys.exit(1)

    action = sys.argv[1]

    if action == "info":
        results = info_batch(sys.argv[2:])
        print(json.dumps(results, ensure_ascii=False, indent=2))

    elif action == "search":
        results = search_batch(sys.argv[2:])
        print(json.dumps(results, ensure_ascii=False, indent=2))

    elif action == "notes":
        stdout = cmd("notes", "--book", sys.argv[2], "--json")
        print(stdout if stdout else "[]")

    elif action == "chapters":
        stdout = cmd("book", sys.argv[2], "--chapters")
        if stdout:
            chapters = []
            in_toc = False
            for line in stdout.split("\n"):
                if "章节目录" in line:
                    in_toc = True
                    continue
                if in_toc:
                    line = line.strip()
                    if line and not line.startswith("──"):
                        chapters.append(line)
            print(json.dumps(chapters, ensure_ascii=False, indent=2))

    elif action == "bookmarks":
        book_id = sys.argv[2]
        count = 20
        if "--count" in sys.argv:
            idx = sys.argv.index("--count")
            if idx + 1 < len(sys.argv):
                count = int(sys.argv[idx + 1])
        stdout = cmd("bestbookmarks", book_id, "--json")
        if stdout:
            d = json.loads(stdout)
            items = d.get("items", [])[:count]
            print(json.dumps(items, ensure_ascii=False, indent=2))

    else:
        print(f"未知操作: {action}")
        sys.exit(1)


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""
微信读书章节推荐 — 数据拉取 + 模型语义匹配

用法:
  python3 weread_chapters.py <bookId> "用户查询"

输出 JSON，包含：
- chapters: 章节目录（含层级）
- bookmarks_by_chapter: 按章节聚合的热门划线
- prompt: 直接喂给模型做语义匹配的提示词

模型拿到这个数据后，根据用户查询返回最相关的章节。

示例:
  python3 weread_chapters.py 44026191 "关于财富积累的章节"
"""
import sys, json, subprocess, os
from collections import defaultdict

WR = os.path.join(os.path.dirname(__file__), "weread.py")


def get_chapters(book_id):
    """获取章节目录"""
    r = subprocess.run([WR, "book", str(book_id), "--chapters"],
                      capture_output=True, text=True, timeout=15)
    chapters = []
    in_toc = False
    for line in r.stdout.split("\n"):
        if "章节目录" in line:
            in_toc = True
            continue
        if not in_toc:
            continue
        line = line.strip()
        if not line or line.startswith("──"):
            continue
        # 判断层级：3个空格=二级章节
        if line.startswith("   "):
            level = 2
            title = line.strip()
        else:
            level = 1
            title = line.strip()
        if title:
            chapters.append({"idx": len(chapters), "title": title, "level": level})
    return chapters


def get_bookmarks(book_id, count=50):
    """获取热门划线，按 chapterUid 聚合"""
    r = subprocess.run([WR, "bestbookmarks", str(book_id), "--json"],
                      capture_output=True, text=True, timeout=15)
    if not r.stdout.strip():
        return {}
    d = json.loads(r.stdout)
    items = d.get("items", []) or d.get("bookmarks", [])[:count]

    by_chapter = defaultdict(list)
    for bm in items:
        uid = bm.get("chapterUid", 0)
        text = bm.get("markText", "")
        if uid and text:
            by_chapter[uid].append(text)
    return dict(by_chapter)


def get_book_meta(book_id):
    """获取书名和简介"""
    r = subprocess.run([WR, "book", str(book_id)],
                      capture_output=True, text=True, timeout=15)
    meta = {"book_id": str(book_id)}
    for line in r.stdout.split("\n"):
        line = line.strip()
        if line.startswith("《") and line.endswith("》"):
            meta["title"] = line.strip("《》")
        elif line.startswith("作者:"):
            meta["author"] = line.split(":", 1)[1].strip()
        elif line.startswith("评分:"):
            meta["rating"] = line.split(":", 1)[1].strip()
        elif line.startswith("分类:"):
            meta["category"] = line.split(":", 1)[1].strip()
        elif line.startswith("简介:"):
            meta["intro"] = line.split(":", 1)[1].strip()[:300]
    return meta


def build_prompt(meta, chapters, bookmarks_by_chapter, query):
    """构建给模型的提示词"""
    # 构建目录文本
    toc_lines = []
    for ch in chapters:
        indent = "  " if ch["level"] == 2 else ""
        # 找到该章节的划线数
        uid = ch["idx"] + 1  # chapterUid 通常从 1 开始
        bm_count = len(bookmarks_by_chapter.get(uid, []))
        bm_hint = f" [{bm_count}条划线]" if bm_count > 0 else ""
        toc_lines.append(f"{indent}{ch['title']}{bm_hint}")
    toc_text = "\n".join(toc_lines)

    # 构建划线摘要（每个章节最多3条）
    bm_lines = []
    for ch in chapters:
        uid = ch["idx"] + 1
        texts = bookmarks_by_chapter.get(uid, [])
        if texts:
            bm_lines.append(f"\n【{ch['title']}】")
            for t in texts[:3]:
                bm_lines.append(f"  · {t[:100]}")
    bm_text = "\n".join(bm_lines) if bm_lines else "（暂无热门划线）"

    return f"""你是一个阅读助手。用户正在阅读一本书，需要你推荐最相关的章节。

## 书籍信息
- 书名：{meta.get('title', '未知')}
- 作者：{meta.get('author', '未知')}
- 评分：{meta.get('rating', '未知')}
- 简介：{meta.get('intro', '无')[:200]}

## 章节目录（[数字] = 该章节的热门划线数）
{toc_text}

## 各章节热门划线摘要
{bm_text}

## 用户查询
"{query}"

## 你的任务
根据用户查询，从目录中选出最相关的章节（最多5个）。

判断依据：
1. 章节标题与查询的语义匹配度
2. 该章节的热门划线内容是否涉及查询主题
3. 对于投资/理财类书，"财富""收入""投资""复利"等是强信号
4. 对于人生/哲学类书，"幸福""心态""选择""价值观"是强信号

请用 JSON 输出：
{{
  "query": "用户查询",
  "recommendations": [
    {{
      "chapter": "章节名",
      "level": 1或2,
      "reason": "为什么推荐这章（结合划线内容说明）",
      "key_highlights": ["划线摘要1", "划线摘要2"],
      "relevance": "high|medium|low"
    }}
  ],
  "summary": "一句话总结推荐逻辑"
}}

只输出 JSON，不要其他内容。"""


def main():
    if len(sys.argv) < 3:
        print("用法: weread_chapters.py <bookId> \"用户查询\"")
        print("输出 JSON，包含目录、划线和给模型的 prompt")
        sys.exit(1)

    book_id = sys.argv[1]
    query = " ".join(sys.argv[2:])

    # 拉取数据
    meta = get_book_meta(book_id)
    chapters = get_chapters(book_id)
    bookmarks = get_bookmarks(book_id)

    # 构建 prompt
    prompt = build_prompt(meta, chapters, bookmarks, query)

    # 输出
    output = {
        "book": meta,
        "chapters": chapters,
        "bookmarks_by_chapter": {str(k): v for k, v in bookmarks.items()},
        "query": query,
        "prompt": prompt,
        "stats": {
            "total_chapters": len(chapters),
            "chapters_with_highlights": len(bookmarks),
            "total_highlights": sum(len(v) for v in bookmarks.values())
        }
    }

    print(json.dumps(output, ensure_ascii=False, indent=2))


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""
微信读书精细化推荐引擎 v3

用法:
  python3 weread_recommend.py books "投资 心理学" [--limit 10]
  python3 weread_recommend.py authors "投资 思维" [--limit 5]
  python3 weread_recommend.py chapters <book-id> "财富 幸福" [--limit 5]
  python3 weread_recommend.py versions "思考快与慢"
  python3 weread_recommend.py similar <book-id> [--limit 5]
  python3 weread_recommend.py profile --data /tmp/user_data.json
"""
import sys, json, subprocess, os, re
from concurrent.futures import ThreadPoolExecutor, as_completed

WR = os.path.join(os.path.dirname(__file__), "weread.py")


# ─── 底层搜索 ────────────────────────────────────────────────────────

def _search_single(keyword, count=10):
    """搜索单个关键词，返回原始 items"""
    r = subprocess.run([WR, "search", keyword, "--json"],
                      capture_output=True, text=True, timeout=15)
    if not r.stdout.strip():
        return []
    return json.loads(r.stdout).get("items", [])[:count]


def search(keyword, count=10):
    """
    搜索书籍，支持多关键词。
    - 单关键词：直接搜
    - 多关键词：并行搜 N 个，合并去重，按评分×评价人数排序
    """
    keywords = keyword.strip().split()
    if not keywords:
        return []

    all_raw = []
    seen = set()

    if len(keywords) == 1:
        raw_list = [_search_single(keywords[0], count * 2)]
    else:
        raw_list = []
        with ThreadPoolExecutor(max_workers=5) as ex:
            futs = {ex.submit(_search_single, kw, count * 2): kw for kw in keywords}
            for f in as_completed(futs):
                try:
                    raw_list.append(f.result())
                except:
                    pass

    for raw in raw_list:
        for b in raw:
            bid = b["bookId"]
            if bid not in seen:
                seen.add(bid)
                rating = b.get("newRating", 0)
                rc = b.get("newRatingCount", 0)
                all_raw.append({
                    "title": b["title"],
                    "author": b.get("author", ""),
                    "rating": round(rating / 10, 1),
                    "rating_count": rc,
                    "reading_count": b.get("readingCount", 0),
                    "category": b.get("category", ""),
                    "book_id": bid,
                    "_score": (rating / 10) * (1 + min(rc, 10000) / 1000)
                })

    all_raw.sort(key=lambda x: x["_score"], reverse=True)
    for b in all_raw:
        del b["_score"]
    return all_raw[:count]


def get_book_info(book_id):
    """获取书籍详情（文本解析）"""
    r = subprocess.run([WR, "book", str(book_id)],
                      capture_output=True, text=True, timeout=15)
    text = r.stdout
    info = {"book_id": str(book_id)}
    for line in text.split("\n"):
        line = line.strip()
        if line.startswith("《") and line.endswith("》"):
            info["title"] = line.strip("《》")
        elif line.startswith("作者:"):
            info["author"] = line.split(":", 1)[1].strip()
        elif line.startswith("评分:"):
            info["rating_str"] = line.split(":", 1)[1].strip()
        elif line.startswith("分类:"):
            info["category"] = line.split(":", 1)[1].strip()
        elif line.startswith("出版社:"):
            info["publisher"] = line.split(":", 1)[1].strip()
        elif line.startswith("简介:"):
            info["intro"] = line.split(":", 1)[1].strip()
    return info


# ─── 批量查询（一次进程调用）────────────────────────────────────────

def batch_query(book_ids):
    """
    批量查询多本书的信息，一次进程调用。
    避免多次启动 Python 进程的开销（每次 ~85ms）。
    """
    results = []
    with ThreadPoolExecutor(max_workers=5) as ex:
        futs = {ex.submit(get_book_info, bid): bid for bid in book_ids}
        for f in as_completed(futs):
            try:
                results.append(f.result())
            except:
                pass
    return results


# ─── 推荐书 ──────────────────────────────────────────────────────────

def recommend_books(query, limit=10, prefer_categories=None, exclude_ids=None):
    """
    推荐书。
    - query: 空格分隔的关键词
    - prefer_categories: 优先分类
    - exclude_ids: 排除的 bookId 集合（用户已读过的）
    """
    books = search(query, limit * 3)
    exclude_ids = exclude_ids or set()

    # 过滤已读
    books = [b for b in books if b["book_id"] not in exclude_ids]

    if prefer_categories:
        preferred = [b for b in books if any(cat in b.get("category", "") for cat in prefer_categories)]
        others = [b for b in books if b not in preferred]
        books = preferred + others

    return books[:limit]


# ─── 推荐作者 ────────────────────────────────────────────────────────

def _get_author_books(author_name):
    """获取作者的所有书"""
    r = subprocess.run([WR, "author", author_name, "--json"],
                      capture_output=True, text=True, timeout=15)
    if not r.stdout.strip():
        return None
    d = json.loads(r.stdout)
    books = d.get("books", [])
    if not books:
        return None
    ratings = [b.get("rating", 0) for b in books if b.get("rating", 0) > 0]
    return {
        "author": author_name,
        "total_books": len(books),
        "top_books": [b["title"] for b in sorted(books, key=lambda x: x.get("rating", 0), reverse=True)[:3]],
        "avg_rating": round(sum(ratings) / len(ratings) / 10, 1) if ratings else 0,
        "best_book_id": books[0]["bookId"] if books else None
    }


def recommend_authors(query, limit=5, exclude=None):
    """推荐作者：搜索相关书 → 提取作者 → 获取作者作品 → 排序"""
    books = search(query, 30)
    exclude = exclude or set()
    authors = {}

    for b in books:
        author = b.get("author", "")
        if not author or author in exclude:
            continue
        # 去掉国籍标记、译者等
        author = re.sub(r'\[.*?\]', '', author).strip()
        author = re.sub(r'著|编|译$', '', author).strip()
        if not author or len(author) > 15:
            continue
        if author not in authors:
            authors[author] = b.get("rating", 0)

    sorted_authors = sorted(authors.keys(), key=lambda a: authors[a], reverse=True)

    results = []
    with ThreadPoolExecutor(max_workers=5) as ex:
        futs = {ex.submit(_get_author_books, a): a for a in sorted_authors[:limit * 2]}
        for f in as_completed(futs):
            try:
                info = f.result()
                if info and info["total_books"] > 0:
                    results.append(info)
            except:
                pass

    results.sort(key=lambda x: x["avg_rating"] * min(x["total_books"], 5), reverse=True)
    return results[:limit]


# ─── 推荐章节 ────────────────────────────────────────────────────────

def _parse_chapters(book_id):
    """解析章节目录"""
    r = subprocess.run([WR, "book", str(book_id), "--chapters"],
                      capture_output=True, text=True, timeout=15)
    chapters = []
    in_toc = False
    for line in r.stdout.split("\n"):
        if "章节目录" in line:
            in_toc = True
            continue
        if not in_toc:
            continue
        line = line.strip()
        if not line or line.startswith("──"):
            continue
        # 判断层级
        if line.startswith("   ") or line.startswith("\t"):
            level = 2
        else:
            level = 1
        title = line.strip()
        if title:
            chapters.append({"idx": len(chapters), "title": title, "level": level})
    return chapters


def _get_bestbookmarks(book_id, count=50):
    """获取热门划线"""
    r = subprocess.run([WR, "bestbookmarks", str(book_id), "--json"],
                      capture_output=True, text=True, timeout=15)
    if not r.stdout.strip():
        return []
    d = json.loads(r.stdout)
    return d.get("items", []) or d.get("bookmarks", [])[:count]


def recommend_chapters(book_id, query, limit=5):
    """
    推荐章节。
    策略：
    1. 获取章节目录 + 热门划线
    2. 划线有 chapterUid，通过 bestbookmarks 返回的 chapterUid 映射到章节
    3. 按查询关键词匹配划线内容 → 找到相关章节
    4. 如果没匹配到，返回前 N 个一级章节
    """
    chapters = _parse_chapters(book_id)
    bookmarks = _get_bestbookmarks(book_id, 50)
    keywords = query.strip().split()

    if not chapters:
        return []

    # 建立 chapterUid → 章节索引 映射
    # chapterUid 是递增的，按顺序对应章节
    uid_map = {}
    for bm in bookmarks:
        uid = bm.get("chapterUid", 0)
        if uid and uid not in uid_map:
            # 找到最近的章节
            idx = min(uid - 1, len(chapters) - 1) if uid <= len(chapters) else min(uid % len(chapters), len(chapters) - 1)
            uid_map[uid] = idx

    # 按关键词匹配划线
    chapter_scores = {}
    for bm in bookmarks:
        text = bm.get("markText", "") or bm.get("mark", "")
        matched_kws = [kw for kw in keywords if kw in text]
        if matched_kws:
            uid = bm.get("chapterUid", 0)
            idx = uid_map.get(uid, 0)
            if idx not in chapter_scores:
                chapter_scores[idx] = {"score": 0, "highlights": [], "matched_keywords": set()}
            chapter_scores[idx]["score"] += len(matched_kws)
            chapter_scores[idx]["highlights"].append(text[:120])
            chapter_scores[idx]["matched_keywords"].update(matched_kws)

    if chapter_scores:
        sorted_chapters = sorted(chapter_scores.items(), key=lambda x: x[1]["score"], reverse=True)
        return [{
            "chapter": chapters[idx]["title"],
            "level": chapters[idx]["level"],
            "relevance_score": data["score"],
            "matched_keywords": list(data["matched_keywords"]),
            "sample_highlights": data["highlights"][:3]
        } for idx, data in sorted_chapters[:limit]]
    else:
        # 没有匹配到，返回前 N 个一级章节
        top_chapters = [ch for ch in chapters if ch["level"] == 1][:limit]
        return [{
            "chapter": ch["title"],
            "level": ch["level"],
            "relevance_score": 0,
            "matched_keywords": [],
            "sample_highlights": [],
            "note": "未匹配到相关关键词，返回目录前几章"
        } for ch in top_chapters]


# ─── 版本对比 ────────────────────────────────────────────────────────

def recommend_versions(query):
    """
    版本对比：搜索同一本书的所有版本，推荐最优版本。
    修复：正则 split 改为更稳健的分组策略。
    """
    results = _search_single(query, 20)
    if not results:
        return []

    # 按基础书名分组：取前2-4个字作为分组 key
    groups = {}
    for b in results:
        title = b["title"]
        # 取前 min(4, len(title)//2) 个字符作为分组 key
        key_len = max(2, min(4, len(title) // 2))
        base = title[:key_len]
        if base not in groups:
            groups[base] = []
        groups[base].append(b)

    output = []
    for base_key, versions in groups.items():
        if len(versions) < 2:
            continue

        # 找到最完整的书名（包含版本信息）
        base_name = max(versions, key=lambda b: len(b["title"]))["title"].split("（")[0].split("(")[0].strip()

        versions.sort(key=lambda b: (
            b.get("newRating", 0),
            b.get("newRatingCount", 0),
            -len(b["title"])
        ), reverse=True)

        best = versions[0]
        output.append({
            "base_title": base_name or base_key,
            "versions": [{
                "title": b["title"],
                "author": b.get("author", ""),
                "rating": round(b.get("newRating", 0) / 10, 1),
                "rating_count": b.get("newRatingCount", 0),
                "book_id": b["bookId"],
                "is_recommended": b == best
            } for b in versions],
            "recommended": {
                "title": best["title"],
                "author": best.get("author", ""),
                "rating": round(best.get("newRating", 0) / 10, 1),
                "book_id": best["bookId"],
                "reason": f"评分最高（{round(best.get('newRating',0)/10,1)}%），评价人数{best.get('newRatingCount',0)}人"
            },
            "version_count": len(versions)
        })

    return output


# ─── 相似书 ──────────────────────────────────────────────────────────

def recommend_similar(book_id, limit=5):
    """
    相似书推荐。
    策略：discover → 二次搜索验证评分 → 过滤低质量
    """
    r = subprocess.run([WR, "discover", "--book", str(book_id), "--json"],
                      capture_output=True, text=True, timeout=15)
    if not r.stdout.strip():
        return []
    d = json.loads(r.stdout)
    raw = d.get("books", []) or d.get("items", []) or []

    results = []
    seen_ids = set()

    for b in raw:
        title = b.get("title", "")
        author = b.get("author", "")
        bid = str(b.get("bookId", ""))
        if not title or bid in seen_ids:
            continue
        seen_ids.add(bid)

        # 二次搜索获取准确评分
        verified = _search_single(title, 3)
        if verified:
            v = verified[0]
            results.append({
                "title": v["title"],
                "author": v.get("author", author),
                "rating": round(v.get("newRating", 0) / 10, 1),
                "rating_count": v.get("newRatingCount", 0),
                "category": v.get("category", ""),
                "book_id": v["bookId"]
            })
        else:
            results.append({
                "title": title,
                "author": author,
                "rating": round(b.get("newRating", 0) / 10, 1),
                "rating_count": b.get("newRatingCount", 0),
                "category": b.get("category", ""),
                "book_id": bid
            })

    # 过滤低质量
    results = [r for r in results if (r["rating"] or 0) > 70 and (r["rating_count"] or 0) > 10]
    return results[:limit]


# ─── 综合画像推荐 ────────────────────────────────────────────────────

def recommend_profile(user_data, limit_per_category=5):
    """基于用户画像综合推荐"""
    results = {}
    exclude_ids = set(user_data.get("read_book_ids", []))

    if user_data.get("top_categories"):
        cat_query = " ".join([c.split("-")[-1] for c in user_data["top_categories"]])
        results["based_on_interest"] = recommend_books(cat_query, limit_per_category, exclude_ids=exclude_ids)

    if user_data.get("preferred_authors"):
        author_query = " ".join(user_data["preferred_authors"][:3])
        results["similar_authors"] = recommend_authors(author_query, 3, exclude=set(user_data["preferred_authors"]))

    if user_data.get("blind_spots"):
        blind_query = " ".join(user_data["blind_spots"])
        results["blind_spot_fill"] = recommend_books(blind_query, limit_per_category, exclude_ids=exclude_ids)

    return results


# ─── CLI ──────────────────────────────────────────────────────────────

USAGE = """\
微信读书精细化推荐引擎 v3

用法:
  python3 weread_recommend.py books "投资 心理学" [--limit 10]
  python3 weread_recommend.py authors "投资 思维" [--limit 5]
  python3 weread_recommend.py chapters <book-id> "财富 幸福" [--limit 5]
  python3 weread_recommend.py versions "思考快与慢"
  python3 weread_recommend.py similar <book-id> [--limit 5]
  python3 weread_recommend.py batch <bookId1> <bookId2> ...
  python3 weread_recommend.py profile --data /tmp/user_data.json
"""


def main():
    if len(sys.argv) < 2:
        print(USAGE)
        sys.exit(1)

    cmd = sys.argv[1]

    if cmd == "books":
        query = " ".join(sys.argv[2:]) if len(sys.argv) > 2 else "投资 理财"
        results = recommend_books(query, 10)
        print(json.dumps(results, ensure_ascii=False, indent=2))

    elif cmd == "authors":
        query = " ".join(sys.argv[2:]) if len(sys.argv) > 2 else "投资"
        results = recommend_authors(query, 5)
        print(json.dumps(results, ensure_ascii=False, indent=2))

    elif cmd == "chapters":
        if len(sys.argv) < 4:
            print("用法: chapters <book-id> <query>")
            sys.exit(1)
        book_id = sys.argv[2]
        query = " ".join(sys.argv[3:])
        results = recommend_chapters(book_id, query, 5)
        print(json.dumps(results, ensure_ascii=False, indent=2))

    elif cmd == "versions":
        query = " ".join(sys.argv[2:]) if len(sys.argv) > 2 else ""
        if not query:
            print("用法: versions <书名>")
            sys.exit(1)
        results = recommend_versions(query)
        print(json.dumps(results, ensure_ascii=False, indent=2))

    elif cmd == "similar":
        if len(sys.argv) < 3:
            print("用法: similar <book-id>")
            sys.exit(1)
        book_id = sys.argv[2]
        results = recommend_similar(book_id, 5)
        print(json.dumps(results, ensure_ascii=False, indent=2))

    elif cmd == "batch":
        if len(sys.argv) < 3:
            print("用法: batch <bookId1> <bookId2> ...")
            sys.exit(1)
        book_ids = sys.argv[2:]
        results = batch_query(book_ids)
        print(json.dumps(results, ensure_ascii=False, indent=2))

    elif cmd == "profile":
        user_data = {}
        if len(sys.argv) > 2 and os.path.exists(sys.argv[2]):
            with open(sys.argv[2]) as f:
                user_data = json.load(f)
        results = recommend_profile(user_data)
        print(json.dumps(results, ensure_ascii=False, indent=2))

    else:
        print(f"未知命令: {cmd}")
        print(USAGE)
        sys.exit(1)


if __name__ == "__main__":
    main()