worknex 4.2.1__py3-none-any.whl

worknex/__init__.py

@@ -0,0 +1,21 @@
+"""WorkNex runtime — 公众号内容管道的确定性工具层（CLI: `worknex`）。"""
+
+# 版本单一真源 = 仓库根 VERSION 文件（pyproject 经 tool.setuptools.dynamic 同源读取）；
+# 已安装的包读打包时写入的 metadata，源码运行（PYTHONPATH=src）回退读 VERSION
+def _resolve_version() -> str:
+    try:
+        from pathlib import Path
+        source_version = Path(__file__).resolve().parents[2] / "VERSION"
+        if source_version.exists():
+            return source_version.read_text().strip()
+    except Exception:
+        pass
+    try:
+        from importlib.metadata import version
+        return version("worknex")
+    except Exception:
+        pass
+    return "0.0.0+unknown"
+
+
+__version__ = _resolve_version()

worknex/__main__.py

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

worknex/cli.py

@@ -0,0 +1,86 @@
+"""`worknex` CLI 调度器 —— 把子命令分发到 commands/ 与 toolkit/ 的既有 main()。
+
+设计约束：各命令模块保持独立 argparse（历史上是独立脚本），调度器只做
+「子命令名 → 模块」映射并透传其余参数，不重复定义参数。
+"""
+
+import importlib
+import sys
+
+from . import __version__
+from .paths import home
+
+# 子命令 → (模块, 一句话说明)。模块须提供 main(argv=None) 或 main()。
+_COMMANDS = {
+    "diagnose": ("worknex.commands.diagnose", "环境 + 配置自检（降级标记 JSON）"),
+    "score": ("worknex.commands.humanness_score", "写作质量评分（11 项检测）"),
+    "content-eval": ("worknex.commands.content_eval", "汇总编辑判断与初稿修改幅度"),
+    "hotspots": ("worknex.commands.fetch_hotspots", "多平台热点抓取"),
+    "search-articles": ("worknex.commands.search_articles", "搜狗微信搜索公众号文章"),
+    "seo": ("worknex.commands.seo_keywords", "SEO 关键词分析"),
+    "stats": ("worknex.commands.fetch_stats", "微信文章数据回填 history"),
+    "learn-edits": ("worknex.commands.learn_edits", "学习人工修改（diff → lessons）"),
+    "learn-theme": ("worknex.commands.learn_theme", "从公众号文章 URL 学排版主题"),
+    "exemplar": ("worknex.commands.extract_exemplar", "范文风格库（导入 / --list）"),
+    "fetch-article": ("worknex.commands.fetch_article", "公众号文章 URL → Markdown"),
+    "llm-write": ("worknex.commands.llm_write", "混合路由写作（DeepSeek 等出稿）"),
+    "similarity": ("worknex.commands.similarity_check", "多平台版本原创度检查"),
+    "run": ("worknex.commands.run_manager", "独立文章任务：开始 / 恢复 / 完成"),
+    "sources": ("worknex.commands.source_ledger", "记录文章事实来源"),
+    "build-playbook": ("worknex.commands.build_playbook", "从历史语料生成 playbook"),
+    "image-gen": ("worknex.toolkit.image_gen", "AI 图片生成（多 provider fallback）"),
+    "validate": ("worknex.commands.validate_html", "HTML 微信兼容性校验"),
+}
+
+# toolkit/cli.py 自带子命令（preview/publish/gallery/themes/image-post/learn-theme），
+# 这些名字直接整体透传给它。
+_TOOLKIT_PASSTHROUGH = {"preview", "publish", "gallery", "themes", "image-post"}
+
+
+def _usage() -> str:
+    lines = [f"worknex {__version__} — 公众号内容管道 CLI（状态目录: {home()}）", "", "用法: worknex <命令> [参数…]", "", "命令:"]
+    for name, (_, desc) in _COMMANDS.items():
+        lines.append(f"  {name:<16}{desc}")
+    for name in sorted(_TOOLKIT_PASSTHROUGH):
+        lines.append(f"  {name:<16}排版工具链（toolkit）")
+    lines += [
+        "  home            输出状态目录路径",
+        "  migrate         迁移旧版仓库内状态到状态目录",
+        "",
+        "任意命令加 --help 看详细参数。",
+    ]
+    return "\n".join(lines)
+
+
+def main() -> None:
+    argv = sys.argv[1:]
+    if not argv or argv[0] in {"-h", "--help"}:
+        print(_usage())
+        return
+    if argv[0] in {"-V", "--version"}:
+        print(__version__)
+        return
+
+    cmd, rest = argv[0], argv[1:]
+
+    if cmd == "home":
+        print(home())
+        return
+    if cmd == "migrate":
+        from .migrate import main as migrate_main
+        migrate_main(rest)
+        return
+    if cmd in _TOOLKIT_PASSTHROUGH:
+        from .toolkit import cli as toolkit_cli
+        sys.argv = ["worknex", cmd, *rest]
+        toolkit_cli.main()
+        return
+    if cmd in _COMMANDS:
+        module_name, _ = _COMMANDS[cmd]
+        module = importlib.import_module(module_name)
+        sys.argv = [f"worknex {cmd}", *rest]
+        module.main()
+        return
+
+    print(f"未知命令: {cmd}\n\n{_usage()}", file=sys.stderr)
+    sys.exit(2)

worknex/commands/build_playbook.py

@@ -0,0 +1,198 @@
+#!/usr/bin/env python3
+"""
+Build a writing playbook from historical articles.
+
+Reads all .md files in corpus/, analyzes writing patterns
+in batches via LLM, and outputs a structured playbook.md.
+
+Usage:
+    worknex build-playbook
+    worknex build-playbook --batch-size 10
+
+Requires: ANTHROPIC_API_KEY or ARK API key in environment/config.
+This script outputs analysis prompts to stdout for the Agent (LLM) to process.
+The Agent reads the output and generates playbook.md.
+"""
+
+import argparse
+import json
+import sys
+from pathlib import Path
+
+from ..paths import corpus_dir as _corpus_dir
+
+
+def load_corpus() -> list[dict]:
+    """Load all markdown files from corpus directory ($WORKNEX_HOME/corpus)."""
+    corpus_dir = _corpus_dir()
+    if not corpus_dir.exists():
+        print(f"Error: corpus directory not found: {corpus_dir}", file=sys.stderr)
+        sys.exit(1)
+
+    articles = []
+    for md_file in sorted(corpus_dir.glob("*.md")):
+        text = md_file.read_text(encoding="utf-8")
+        if not text.strip():
+            continue
+
+        # Extract title (first H1)
+        title = ""
+        for line in text.split("\n"):
+            if line.strip().startswith("# ") and not line.strip().startswith("## "):
+                title = line.strip()[2:].strip()
+                break
+
+        # Basic stats
+        lines = [l for l in text.split("\n") if l.strip()]
+        paragraphs = text.split("\n\n")
+        h2_count = sum(1 for l in text.split("\n") if l.strip().startswith("## "))
+        char_count = len(text.replace("\n", "").replace(" ", ""))
+
+        articles.append({
+            "filename": md_file.name,
+            "title": title,
+            "char_count": char_count,
+            "paragraph_count": len([p for p in paragraphs if p.strip()]),
+            "h2_count": h2_count,
+            "text": text,
+        })
+
+    return articles
+
+
+def compute_corpus_stats(articles: list[dict]) -> dict:
+    """Compute aggregate statistics from the corpus."""
+    if not articles:
+        return {}
+
+    titles = [a["title"] for a in articles if a["title"]]
+    title_lengths = [len(t) for t in titles]
+    char_counts = [a["char_count"] for a in articles]
+    para_counts = [a["paragraph_count"] for a in articles]
+    h2_counts = [a["h2_count"] for a in articles]
+
+    return {
+        "total_articles": len(articles),
+        "avg_char_count": round(sum(char_counts) / len(char_counts)),
+        "avg_title_length": round(sum(title_lengths) / len(title_lengths), 1) if title_lengths else 0,
+        "title_length_range": f"{min(title_lengths)}-{max(title_lengths)}" if title_lengths else "N/A",
+        "avg_paragraphs": round(sum(para_counts) / len(para_counts), 1),
+        "avg_h2_count": round(sum(h2_counts) / len(h2_counts), 1),
+    }
+
+
+def build_analysis_batches(articles: list[dict], batch_size: int) -> list[list[dict]]:
+    """Split articles into batches for LLM analysis."""
+    batches = []
+    for i in range(0, len(articles), batch_size):
+        batch = articles[i:i + batch_size]
+        batches.append(batch)
+    return batches
+
+
+def output_analysis_prompt(articles: list[dict], stats: dict, batch_idx: int, total_batches: int):
+    """Output a structured analysis prompt for the Agent to process."""
+    print(f"\n{'='*60}")
+    print(f"BATCH {batch_idx + 1}/{total_batches} — {len(articles)} articles")
+    print(f"{'='*60}\n")
+
+    for i, article in enumerate(articles):
+        print(f"--- Article {i+1}: {article['title']} ({article['char_count']}字) ---")
+        # Truncate very long articles to first 2000 chars for analysis
+        text = article["text"]
+        if len(text) > 3000:
+            text = text[:3000] + "\n\n[...truncated...]"
+        print(text)
+        print()
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Build writing playbook from corpus")
+    parser.add_argument("--batch-size", type=int, default=10, help="Articles per batch")
+    parser.add_argument("--stats-only", action="store_true", help="Only show corpus stats")
+    args = parser.parse_args()
+
+    # Load corpus
+    articles = load_corpus()
+    if not articles:
+        print("Error: no articles found in corpus/", file=sys.stderr)
+        sys.exit(1)
+
+    # Compute stats
+    stats = compute_corpus_stats(articles)
+
+    print("=" * 60)
+    print("CORPUS ANALYSIS")
+    print("=" * 60)
+    print(json.dumps(stats, ensure_ascii=False, indent=2))
+
+    if args.stats_only:
+        return
+
+    # Build batches
+    batches = build_analysis_batches(articles, args.batch_size)
+
+    print(f"\nTotal: {stats['total_articles']} articles in {len(batches)} batch(es)")
+    print(f"Average: {stats['avg_char_count']} chars, {stats['avg_title_length']} char titles, {stats['avg_h2_count']} H2s")
+
+    # Output analysis instructions
+    print(f"""
+{'='*60}
+ANALYSIS INSTRUCTIONS FOR AGENT
+{'='*60}
+
+Read all articles below, then generate playbook.md with these sections:
+
+## 标题模式
+- 平均字数和范围
+- 常用策略分布（数字/反直觉/痛点/疑问/陈述，给百分比）
+- 标点习惯（逗号断句？问号？感叹号？）
+- 示例：列出 3 个最典型的标题
+
+## 开头模式
+- 最常用的开头方式（场景/数据/反问/新闻引述/个人经历）
+- 第一段平均长度
+- 从不出现的开头方式
+- 示例：列出 3 个典型开头的第一段
+
+## 段落节奏
+- 平均段落长度（字数）
+- 短段（<30字）占比
+- 最长段落上限
+- 长短交替规律
+
+## 用词指纹
+- 高频标志词/口头禅（出现 3 次以上的特征性表达）
+- 禁用词（从未使用的常见 AI 用语）
+- 英文/专业术语使用习惯
+- 语气词偏好
+
+## H2 命名习惯
+- 用问句？短语？数字编号？
+- 平均长度
+- 示例
+
+## 结尾模式
+- 收尾方式（个人观点/开放提问/行动建议/金句）
+- CTA 风格
+- 示例
+
+## 情绪基调
+- 理性 vs 感性的比例
+- 幽默频率
+- 批判性强度
+
+## 配图风格（如果历史文章有配图描述）
+- 色调偏好
+- 风格关键词
+
+请用量化数据（百分比、平均值、范围）支撑每个结论，不要只做定性描述。
+""")
+
+    # Output article batches
+    for i, batch in enumerate(batches):
+        output_analysis_prompt(batch, stats, i, len(batches))
+
+
+if __name__ == "__main__":
+    main()

worknex/commands/content_eval.py

@@ -0,0 +1,104 @@
+"""Create a deterministic editorial report from an editor assessment."""
+
+from __future__ import annotations
+
+import argparse
+import difflib
+import json
+import re
+import sys
+from pathlib import Path
+
+import yaml
+
+
+DIMENSIONS = ("accuracy", "viewpoint", "usefulness", "voice", "readability")
+DECISIONS = {"pass", "revise", "needs_input"}
+
+
+def _load_mapping(path: str) -> dict:
+    data = yaml.safe_load(Path(path).read_text(encoding="utf-8"))
+    if not isinstance(data, dict):
+        raise ValueError("assessment must be a YAML or JSON object")
+    return data
+
+
+def _headings(text: str) -> list[str]:
+    return re.findall(r"^##\s+(.+)$", text, re.MULTILINE)
+
+
+def build_report(draft: str, final: str, assessment: dict) -> dict:
+    if not draft.strip() or not final.strip():
+        raise ValueError("draft and final must both be non-empty")
+    decision = assessment.get("decision")
+    if decision not in DECISIONS:
+        raise ValueError("decision must be pass, revise, or needs_input")
+
+    dimensions = assessment.get("dimensions")
+    if not isinstance(dimensions, dict):
+        raise ValueError("assessment.dimensions must contain five scores")
+    normalized = {}
+    for name in DIMENSIONS:
+        score = dimensions.get(name)
+        if not isinstance(score, (int, float)) or isinstance(score, bool) or not 1 <= score <= 5:
+            raise ValueError(f"dimension {name} must be between 1 and 5")
+        normalized[name] = float(score)
+
+    blockers = assessment.get("blockers", [])
+    major_issues = assessment.get("major_issues", [])
+    if not isinstance(blockers, list) or not isinstance(major_issues, list):
+        raise ValueError("blockers and major_issues must be lists")
+
+    pass_number = assessment.get("pass_number", 1)
+    if not isinstance(pass_number, int) or isinstance(pass_number, bool) or pass_number not in {1, 2}:
+        raise ValueError("pass_number must be 1 or 2")
+
+    ratio = difflib.SequenceMatcher(None, draft, final, autojunk=False).ratio()
+    average = round(sum(normalized.values()) / len(normalized), 2)
+    minimum = min(normalized.values())
+    publishable = decision == "pass" and not blockers and minimum >= 3 and average >= 4
+
+    return {
+        "version": 1,
+        "decision": decision,
+        "pass_number": pass_number,
+        "publishable": publishable,
+        "dimensions": normalized,
+        "dimension_average": average,
+        "blockers": blockers,
+        "major_issues": major_issues,
+        "notes": assessment.get("notes", ""),
+        "draft_chars": len(draft),
+        "final_chars": len(final),
+        "edit_ratio": round(1 - ratio, 4),
+        "structure_changed": _headings(draft) != _headings(final),
+    }
+
+
+def main(argv=None):
+    parser = argparse.ArgumentParser(description="汇总文章编辑判断与修改幅度")
+    parser.add_argument("--draft", required=True, help="初稿 Markdown")
+    parser.add_argument("--final", required=True, help="终稿 Markdown")
+    parser.add_argument("--assessment", required=True, help="编辑判断 YAML/JSON")
+    parser.add_argument("--output", help="报告 JSON 输出路径")
+    parser.add_argument("--json", action="store_true", help="在标准输出打印 JSON")
+    args = parser.parse_args(argv)
+
+    try:
+        draft = Path(args.draft).read_text(encoding="utf-8")
+        final = Path(args.final).read_text(encoding="utf-8")
+        report = build_report(draft, final, _load_mapping(args.assessment))
+        rendered = json.dumps(report, ensure_ascii=False, indent=2)
+        if args.output:
+            output = Path(args.output)
+            output.parent.mkdir(parents=True, exist_ok=True)
+            output.write_text(rendered + "\n", encoding="utf-8")
+        if args.json or not args.output:
+            print(rendered)
+    except (OSError, ValueError, yaml.YAMLError) as exc:
+        print(f"Error: {exc}", file=sys.stderr)
+        raise SystemExit(2)
+
+
+if __name__ == "__main__":
+    main()