codebee 0.1.47 → 0.1.49

package/CHANGELOG.md

@@ -6,6 +6,18 @@ README 元数据带回，供老版本在「发现新版本」时展示新版更
 
 ## 未发布
 
+## v0.1.49（2026-09-22）
+
+### 🛠 问题修复
+
+- 修复设置 →「钩子」卡片样式坍缩：下拉框漏写闭合标签导致命令框与操作行被吞进内部，整卡挤成一行。
+
+## v0.1.48（2026-09-22）
+
+### ✨ 新功能
+
+- 新增「钩子」：在任务生命周期的关键点挂你自己的本机脚本——任务开始（输出注入任务上下文）、消息送达（输出注入提示词头）、运行结束（回写知识库等副作用）。命令从标准输入收 JSON，输出 `{"inject": "文本"}` 即注入；失败/超时静默跳过，绝不挡主流程。设置 →「钩子」里管理，支持逐条开关、超时与一键测试。
+
 ## v0.1.47（2026-09-22）
 
 ### ✨ 新功能

package/app/core/aiflavor.py

@@ -8,6 +8,8 @@
 """
 from __future__ import annotations
 
+import re
+
 # 译制腔/套话词表（按误导性排序，持续运维）
 AI_PHRASES = (
     "空气仿佛凝固", "眸中闪过一丝", "嘴角勾起一抹", "心中一动",
@@ -81,8 +83,73 @@ def narrative_analyze(text):
     return {"cats": cats, "per_kilo": per_kilo, "alert": alert, "ending_hits": ending_hits}
 
 
-def report_line(text):
-    """生成注入评审提示词的报告行（措辞层 + 叙事架构层）；全部无命中返回空串。"""
+# ---------- 节奏/钩子密度（借鉴 web-novel-pacing-analyzer：连载作品的章级
+# 节奏审计——读者留存看「每章有没有钩子、段落有没有淤积、是不是通篇独白」，
+# 这些是能确定性统计的客观量。与套话检测同路：只给评审官一条参考线，
+# 不直接扣分——短段落多的快节奏文也可能开篇没有冲突词。）
+NARRATIVE_FLOWS = ("novel", "serial_novel", "video_script")
+
+# 冲突/悬念信号词表：开篇用来看「抓不抓人」，章末用来看「留不留钩子」
+HOOK_WORDS = (
+    "突然", "忽然", "竟然", "没想到", "万万没想到", "难道", "究竟", "为什么",
+    "是谁", "怎么回事", "就在这时", "就在此时", "然而", "可是", "却见", "却听",
+    "不对劲", "不对！", "脸色一变", "猛地", "陡然", "下一秒", "醒来", "睁开眼",
+    "电话响", "门被推开", "传来", "砸", "吼", "喊",
+)
+DIALOG_RE = re.compile(r"[「『“\"]")
+OPENING_SCAN_CHARS = 300        # 开篇抓力只看前 300 字（黄金三章 / 短视频黄金 3 秒）
+PACING_TAIL_CHARS = 200         # 章末钩子只看最后 200 字
+PARA_LONG_CHARS = 400           # 单段超过此字数算「信息淤积」
+PARA_AVG_ALERT = 300            # 段均长告警线
+DIALOG_ALERT_RATIO = 0.12       # 含对话段占比低于此值算「通篇叙述独白」
+PACING_MIN_CHARS = 400          # 太短（摘要/片段）不做节奏统计，避免噪声
+
+
+def _paras(text):
+    """切段：空行或单换行都算分隔；丢掉标题行（# 开头）与空白。"""
+    out = []
+    for p in re.split(r"\n\s*\n|\n", text or ""):
+        p = p.strip()
+        if p and not p.startswith("#"):
+            out.append(p)
+    return out
+
+
+def pacing_analyze(text):
+    """统计叙事节奏客观量。返回 {ok, paras, avg_len, longest, dialog_ratio,
+    open_hits, tail_hits, alerts, alert}；文本过短时 ok=False。"""
+    text = text or ""
+    paras = _paras(text)
+    if len(text) < PACING_MIN_CHARS or not paras:
+        return {"ok": False}
+    lens = [len(p) for p in paras]
+    avg = round(sum(lens) * 1.0 / len(lens), 1)
+    longest = max(lens)
+    dialog = sum(1 for p in paras if DIALOG_RE.search(p))
+    ratio = round(dialog * 1.0 / len(paras), 3)
+    opening, tail = text[:OPENING_SCAN_CHARS], text[-PACING_TAIL_CHARS:]
+    open_hits = sum(1 for w in HOOK_WORDS if w in opening)
+    tail_hits = sum(1 for w in HOOK_WORDS if w in tail)
+    alerts = []
+    if avg >= PARA_AVG_ALERT:
+        alerts.append("段落偏长（均 %.0f 字），阅读有淤积感" % avg)
+    if longest >= PARA_LONG_CHARS:
+        alerts.append("存在超长段（最长 %d 字）" % longest)
+    if ratio < DIALOG_ALERT_RATIO:
+        alerts.append("对话段占比偏低（%.0f%%），易成通篇独白" % (ratio * 100))
+    if not tail_hits:
+        alerts.append("章末 200 字无悬念信号，缺钩子")
+    if not open_hits:
+        alerts.append("开篇 300 字无冲突信号，开头偏平")
+    return {"ok": True, "paras": len(paras), "avg_len": avg, "longest": longest,
+            "dialog_ratio": ratio, "open_hits": open_hits, "tail_hits": tail_hits,
+            "alerts": alerts, "alert": bool(alerts)}
+
+
+def report_line(text, kind=None):
+    """生成注入评审提示词的报告行（措辞层 + 叙事架构层 + 节奏层）；
+    全部无命中返回空串。kind 为流程类型：只有叙事类流程才下发节奏检测
+    （邮件/汇报/翻译等非叙事文体统计段落节奏没有意义）。"""
     lines = []
     r = analyze(text)
     if r["hits"]:
@@ -102,4 +169,15 @@ def report_line(text):
                      "请评审情节结构：主题是否被叙述者直接说破、情绪是否只有身体描写、"
                      "结尾是否靠主角想通收束。")
         lines.append(line)
+    if kind in NARRATIVE_FLOWS:
+        pr = pacing_analyze(text)
+        if pr["ok"]:
+            line = ("- [节奏检测] 确定性统计：%d 段（均 %.0f 字 / 最长 %d 字），"
+                    "含对话段 %.0f%%，开篇 300 字冲突信号 %d 处，章末 200 字悬念信号 %d 处。"
+                    % (pr["paras"], pr["avg_len"], pr["longest"],
+                       pr["dialog_ratio"] * 100, pr["open_hits"], pr["tail_hits"]))
+            if pr["alert"]:
+                line += ("提示：%s。连载留存取决于每章的钩子与段落节奏，"
+                         "请评审官结合剧情判断是否真问题。" % "、".join(pr["alerts"]))
+            lines.append(line)
     return "\n".join(lines)

package/app/core/automation.py

@@ -10,8 +10,13 @@ store.create_run → jobs.enqueue）拉起一次真实运行，不自己造运
 任务模型：
   {id, name, prompt, workdir, kind: daily|interval|weekly|once, time: "HH:MM",
    interval_hours, weekday(0-6 周一=0), run_at(once 用, ISO), flow(编排流程 id),
+   mode(编排模式), thinking(思考程度), direct_provider_id/direct_model(仅 direct 流程),
    enabled, created_at, last_run, next_run, run_count, last_status}
 
+运行偏好（mode/thinking/对话模型）与新建任务 Composer 的三颗胶囊同一套取值，
+到点拉起时原样透传给 store.create_task——定时任务不是另一条执行链，用户在这里
+选的编排强度与模型偏好必须与手动建任务完全等价。
+
 重启语义：错过的 once 不补跑（启动恢复时直接停用）；daily/weekly/interval
 重算 next_run 到下一个未来时刻即可，不追赶停机期间错过的周期。
 
@@ -48,17 +53,24 @@ KINDS = ("daily", "interval", "weekly", "once")
 INTERVAL_MIN, INTERVAL_MAX = 1, 720   # interval_hours 合法区间（小时）
 DEFAULT_FLOW = "doc"  # 未指定编排流程时的兜底：review 引擎产出文档，适配巡检/整理类提示词
 
+# 运行偏好取值（必须与 store.create_task 的口径一致，否则到点拉起时被静默改档）
+MODES = ("auto", "fast", "expert", "manual")
+THINKINGS = ("auto", "low", "standard", "high")
+
 _TIME_RE = re.compile(r"\s*(\d{1,2}):(\d{1,2})\s*")
 
 # 字段缺省（加载历史文件/脏数据时兜底；enabled 兜底为 False，绝不意外触发）
 _DEFAULTS = {"id": "", "name": "", "prompt": "", "workdir": "", "kind": "", "time": "",
              "interval_hours": 0, "weekday": -1, "run_at": "", "flow": "",
+             "mode": "auto", "thinking": "standard",
+             "direct_provider_id": "", "direct_model": "",
              "enabled": False, "created_at": "", "last_run": "", "next_run": "",
              "run_count": 0, "last_status": ""}
 
 # 允许通过 update() 修改的字段（id/created_at/run_count 等运行痕迹不可改）
 _UPDATABLE = ("name", "prompt", "workdir", "kind", "time", "interval_hours",
-              "weekday", "run_at", "flow", "enabled")
+              "weekday", "run_at", "flow", "mode", "thinking",
+              "direct_provider_id", "direct_model", "enabled")
 
 
 # ---------------------------------------------------------------- 时间工具
@@ -206,6 +218,37 @@ def _apply_schedule(t, check_flow=True):
         t["flow"] = DEFAULT_FLOW
 
 
+def _flow_engine(flow_id):
+    """流程引擎名（查不到返回空串）。"""
+    from . import flows as flows_mod
+    f = flows_mod.get_flow(str(flow_id or "").strip())
+    return (f or {}).get("engine") or ""
+
+
+def _apply_run_prefs(t):
+    """校验并归一运行偏好（编排模式/思考程度/对话模型），就地改写 t。必须在
+    _apply_schedule 之后调用——只有那里才把 flow 归一成最终值。
+
+    mode/thinking 非法值一律收敛到默认（auto/standard），不抛异常：这两个是
+    「偏好」不是「配置」，脏值不该把保存卡死。对话模型只在流程引擎为 direct
+    时有意义：非 direct 流程一律清空，避免换流程后残留的模型绑定在下一次
+    触发时静默生效（用户看不到却在生效的配置，比没有更糟）。direct 流程下
+    「有模型没厂商」则明确报错——猜一个厂商等于把模型请求打到别家。
+    """
+    mode = str(t.get("mode") or "").strip().lower()
+    t["mode"] = mode if mode in MODES else "auto"
+    thinking = str(t.get("thinking") or "").strip().lower()
+    t["thinking"] = thinking if thinking in THINKINGS else "standard"
+    pid = str(t.get("direct_provider_id") or "").strip()[:80]
+    model = str(t.get("direct_model") or "").strip()[:160]
+    if _flow_engine(t.get("flow")) != "direct":
+        t["direct_provider_id"], t["direct_model"] = "", ""
+        return
+    if model and not pid:
+        raise ValueError("指定对话模型时必须同时选择厂商")
+    t["direct_provider_id"], t["direct_model"] = pid, model
+
+
 # ---------------------------------------------------------------- 持久化
 
 def _list_locked():
@@ -298,7 +341,15 @@ def _launch_run(t):
                "title": ("%s %s" % (t.get("name") or "定时任务",
                                     time.strftime("%m-%d %H:%M"))).strip()[:40],
                "goal": t.get("prompt") or "",
-               "workdir": (t.get("workdir") or "").strip()}
+               "workdir": (t.get("workdir") or "").strip(),
+               # 运行偏好与 Composer 同一套字段：create_task 里已支持，透传即可
+               "mode": t.get("mode") or "auto",
+               "thinking": t.get("thinking") or "standard"}
+    # direct 流程才有对话模型；非 direct 流程这两个键连传都不传（避免碰 store
+    # 里「有模型没厂商就报错」的校验，也避免给别的引擎塞无意义字段）
+    if t.get("direct_provider_id"):
+        payload["direct_provider_id"] = t["direct_provider_id"]
+        payload["direct_model"] = t.get("direct_model") or ""
     task = None
     run = None
     try:
@@ -470,6 +521,7 @@ def create(payload):
     t["kind"] = payload.get("kind") or "daily"
     _validate_core(t)
     _apply_schedule(t)
+    _apply_run_prefs(t)     # 依赖 _apply_schedule 归一后的 flow 判引擎
     t["next_run"] = compute_next_run(t)
     with _LOCK:
         _TASKS[t["id"]] = t
@@ -492,6 +544,7 @@ def update(tid, patch):
                 merged[k] = patch[k]
         _validate_core(merged, check_workdir=("workdir" in patch))
         _apply_schedule(merged, check_flow=("flow" in patch))
+        _apply_run_prefs(merged)   # 改了 flow 就重判：非 direct 流程清掉残留模型
         merged["next_run"] = compute_next_run(merged)
         _TASKS[tid] = merged
         _save_locked()

package/app/core/flows.py

@@ -13,7 +13,7 @@ import json
 import re
 import threading
 
-from . import paths
+from . import paths, volumes
 
 _LOCK = threading.RLock()
 _FILE = paths.DATA_DIR / "flows.json"
@@ -149,10 +149,19 @@ def _norm_serial(serial):
     if not isinstance(serial, dict) or not serial.get("chapters"):
         return None
     try:
-        return {"chapters": max(2, min(20, int(serial["chapters"]))),
-                "words_per_chapter": max(500, min(8000, int(serial.get("words_per_chapter") or 2500)))}
+        out = {"chapters": max(2, min(20, int(serial["chapters"]))),
+               "words_per_chapter": max(500, min(8000, int(serial.get("words_per_chapter") or 2500)))}
     except Exception:
         return None
+    # 分卷（可选）：显式卷表优先，其次每卷章数。流程模板里可以预置，
+    # 任务级 payload 仍可覆盖/关闭（0 = 不分卷）。
+    spec = volumes.norm_spec(serial.get("volumes"))
+    if spec:
+        out["volumes"] = spec
+    per = volumes.norm_per(serial.get("volume_chapters"))
+    if per:
+        out["volume_chapters"] = per
+    return out
 
 
 def _norm_rubric(rubric):

package/app/core/hooks.py

@@ -0,0 +1,156 @@
+# -*- coding: utf-8 -*-
+"""任务生命周期钩子（借鉴 ZCode hooks，收窄为三个事件——2026-09-22 用户立项）：
+
+- task_start     任务开跑前（编排/直连都触发）：stdout 可注入文本，追加进任务上下文
+- message_submit 用户消息送达前：stdout 可注入文本，随消息进提示词头
+- run_end        每轮运行结束：纯副作用型（回写知识库等），输出被忽略
+
+协议：钩子命令从 stdin 收 JSON（事件+上下文）；stdout 若为 {"inject": "..."}
+取该字段为注入文本，否则把非空 stdout 整体当注入文本。
+失败/超时一律静默跳过（外部脚本不稳绝不拖死编排主流程）。
+
+命令执行：shlex 分词（保 Windows 反斜杠）后走参数列表，不经 shell——
+不支持管道/重定向等 shell 语法，需要时写 .py/.bat 包装脚本。
+配置：DATA_DIR/hooks.json，纯本机设置。"""
+from __future__ import annotations
+
+import json
+import logging
+import shlex
+import subprocess
+
+from . import paths
+
+log = logging.getLogger(__name__)
+
+EVENTS = ("task_start", "message_submit", "run_end")
+_DEFAULT_TIMEOUT = 10
+_FILE = None          # 测试重绑（同 modelhub._FILE 惯例）
+
+_CREATE_NO_WINDOW = 0x08000000 if hasattr(subprocess, "CREATE_NO_WINDOW") else 0
+
+
+def _path():
+    return _FILE or (paths.DATA_DIR / "hooks.json")
+
+
+def _default_list():
+    return []
+
+
+def load_list():
+    """读钩子配置列表；损坏/缺省回落空表。"""
+    try:
+        data = json.loads(_path().read_text(encoding="utf-8"))
+        return data if isinstance(data, list) else _default_list()
+    except Exception:
+        return _default_list()
+
+
+def save_list(items):
+    """整表保存（UI 全量提交）。字段归一 + 事件白名单。"""
+    if not isinstance(items, list):
+        raise ValueError("hooks 必须是数组")
+    out = []
+    for i, h in enumerate(items):
+        if not isinstance(h, dict):
+            continue
+        name = str(h.get("name") or "").strip()[:60]
+        event = str(h.get("event") or "").strip()
+        cmd = str(h.get("cmd") or "").strip()
+        if not cmd:
+            continue
+        if event not in EVENTS:
+            raise ValueError("第 %d 条钩子 event 非法（%s）" % (i + 1, event))
+        try:
+            timeout = max(1, min(120, int(h.get("timeout_s") or _DEFAULT_TIMEOUT)))
+        except (TypeError, ValueError):
+            timeout = _DEFAULT_TIMEOUT
+        out.append({"id": str(h.get("id") or ("hk-%d" % (i + 1)))[:40],
+                    "name": name or ("钩子 %d" % (i + 1)),
+                    "event": event, "cmd": cmd,
+                    "enabled": bool(h.get("enabled", True)),
+                    "timeout_s": timeout})
+    tmp = _path().with_suffix(".tmp")
+    tmp.write_text(json.dumps(out, ensure_ascii=False, indent=1), encoding="utf-8")
+    tmp.replace(_path())
+    return out
+
+
+def _argv(cmd):
+    """命令串 → 参数列表。Windows 反斜杠路径保真（posix=False），支持引号分组；
+    分词后剥掉 token 首尾引号（CreateProcess 不认字面引号路径）。"""
+    toks = shlex.split(str(cmd or ""), posix=False)
+    out = []
+    for t in toks:
+        if len(t) >= 2 and t[0] == t[-1] and t[0] in ('"', "'"):
+            t = t[1:-1]
+        if t:
+            out.append(t)
+    return out
+
+
+def _run_one(h, payload):
+    """跑单条钩子。返回注入文本或 None（失败/超时/空输出）。"""
+    try:
+        argv = _argv(h.get("cmd"))
+    except ValueError as e:
+        log.warning("hook[%s %s] 命令解析失败：%s", h.get("name"), h.get("event"), str(e)[:120])
+        return None
+    if not argv:
+        return None
+    try:
+        proc = subprocess.run(
+            argv, shell=False,
+            input=json.dumps(payload, ensure_ascii=False).encode("utf-8"),
+            capture_output=True, timeout=int(h.get("timeout_s") or _DEFAULT_TIMEOUT),
+            creationflags=_CREATE_NO_WINDOW)
+    except subprocess.TimeoutExpired:
+        log.warning("hook[%s %s] 超时，已跳过", h.get("name"), h.get("event"))
+        return None
+    except Exception as e:
+        log.warning("hook[%s %s] 执行失败：%s", h.get("name"), h.get("event"), str(e)[:120])
+        return None
+    out = (proc.stdout or b"").decode("utf-8", "replace").strip()
+    if not out:
+        return None
+    try:
+        data = json.loads(out)
+        if isinstance(data, dict):
+            return str(data.get("inject") or "") or None
+    except Exception:
+        pass
+    return out
+
+
+def run_event(event, ctx=None, task_id=None, run_id=None, text=None):
+    """触发事件：依次跑启用的钩子，合并注入文本。任何异常不外抛。
+
+    ctx 附带任务/运行摘要；text 仅 message_submit 时传用户消息原文。
+    返回拼接好的注入文本（可为空串）。"""
+    if event not in EVENTS:
+        return ""
+    try:
+        items = [h for h in load_list() if h.get("enabled") and h.get("event") == event]
+    except Exception:
+        return ""
+    if not items:
+        return ""
+    payload = {"event": event, "task_id": task_id or "", "run_id": run_id or "",
+               "text": text or ""}
+    if ctx is not None:
+        payload["ctx"] = ctx
+    outs = []
+    for h in items:
+        piece = _run_one(h, payload)
+        if piece:
+            outs.append(piece.strip())
+    return "\n\n".join(outs)
+
+
+def test_one(cmd, event="task_start", timeout_s=None):
+    """设置页「测试」：手动跑一条钩子，返回 (ok, 输出/错误人话)。"""
+    h = {"name": "test", "event": event if event in EVENTS else "task_start",
+         "cmd": cmd, "timeout_s": timeout_s or _DEFAULT_TIMEOUT}
+    piece = _run_one(h, {"event": h["event"], "task_id": "", "run_id": "", "text": ""})
+    return True, piece if piece else "（无输出，未注入）"