dsh-plugin-t-expert 0.3.88 → 0.3.89

package/data/team-profiles.py

@@ -1,367 +0,0 @@
-#!/usr/bin/env python3
-"""把 T专家 的小队定义（teams.json）编译成内置团队引擎的 profiles 配置。
-
-职责分工：T专家 管「人」（名册 + 中文 + 人格），内置引擎 管「队」（成员生命周期、任务 DAG、
-调度、邮箱、面板）。本脚本只做**数据转换**：读 teams.json + experts/ + zh/，把每位专家的
-中文名与人格正文写成 profile 成员的 executionPrompt，然后写进 `t-team.config.json`
-（引擎由 T专家 在 apply 时挂载并读这份配置）。
-
-用法：
-    python3 team-profiles.py                 # 生成并写入 t-team.config.json（+ teams.resolved.json）
-    python3 team-profiles.py --dry-run       # 只打印校验与**将要写入的内容**（预览 == 产物）
-    python3 team-profiles.py --mode full     # 成员人格用完整正文（默认 summary 摘录）
-    python3 team-profiles.py --no-write      # 同上，但不动文件
-
-注意（两个已确认的坑）：
-  1) **不要把 stateDir 写进 t-team.config.json**：状态目录的唯一真源是插件侧 Config.stateDir，
-     数据文件里再留一份就会出现「文件里一个值、实际生效另一个值」的双来源（审计 D-1）。
-  2) AgentTeams 的 profile key 只支持 ASCII（中文 key 不会生成命令别名），中文放 description/aliases。
-"""
-from __future__ import annotations
-
-import argparse
-import copy
-import json
-import os
-import re
-import shutil
-import sys
-import unicodedata
-from datetime import datetime
-
-HOME = os.path.expanduser("~")
-# 默认值相对**脚本自身位置**解析：本脚本与数据（teams.json / experts / zh）同目录，
-# 所以插件包内快照被播种到任意数据目录后都能直接跑，不依赖某台机器的目录布局。
-DATA_DIR = os.path.dirname(os.path.abspath(__file__))
-DEFAULT_TEAMS = os.path.join(DATA_DIR, "teams.json")
-DEFAULT_EXPERTS = os.path.join(DATA_DIR, "experts")
-DEFAULT_ZH = os.path.join(DATA_DIR, "zh")
-# profile patch 只用于清理历史遗留的 agent-teams 配置块（现在引擎由插件内置挂载）。
-# 目标 profile 不同时用 --patch 或 T_TEAM_PATCH 覆盖；文件不存在时静默跳过。
-DEFAULT_PATCH = os.environ.get("T_TEAM_PATCH", os.path.join(HOME, ".dsh", "profiles", "desktop", "cordis.patch.yml"))
-
-MARKER_START = "# >>> t-team teams（由 team-profiles.py 生成，勿手改；改 teams.json 后重跑）"
-MARKER_END = "# <<< t-team teams"
-
-MAX_PROFILES = 48          # 引擎侧 lib/teams/profiles.js 已把 MAX_TEAM_PROFILES 调到 48（原默认 16）
-# 一个 profile 的成员数上限（经验值：队长上下文压力）。
-# 只是**默认**：插件侧 Config.maxMembers 经 --max-members 覆盖它，两边同一个真源；
-# 直接跑本脚本（不带该参数）时行为与从前完全一致。
-MAX_MEMBERS = 8
-MAX_SEED_TASKS = 32        # AgentTeams: MAX_PROFILE_TASKS
-PROFILE_KEY_RE = re.compile(r"^[a-z0-9]+(?:-[a-z0-9]+)*$")
-NAME_FIELD = re.compile(r"^name\s*:", re.M)
-
-
-def sanitize_key(value: str) -> str:
-    """与 AgentTeams 的 state.js sanitizeKey 同规则（用于预检成员名撞键）。"""
-    cleaned = unicodedata.normalize("NFC", str(value)).strip().lower()
-    cleaned = re.sub(r"[^\w\u4e00-\u9fff]+", "-", cleaned, flags=re.UNICODE).strip("-")
-    return cleaned or "k-empty"
-
-
-def read_persona(path: str) -> str:
-    text = open(path, encoding="utf-8", errors="replace").read()
-    if text.startswith("\ufeff"):
-        text = text[1:]
-    match = re.match(r"^---\r?\n.*?\r?\n---\r?\n?(.*)$", text, re.S)
-    return (match.group(1) if match else text).strip()
-
-
-def summarize(body: str, budget: int) -> str:
-    """按行截取到预算内，避免从句子中间切断。"""
-    if len(body) <= budget:
-        return body
-    out, used = [], 0
-    for line in body.splitlines():
-        if used + len(line) + 1 > budget and out:
-            break
-        out.append(line)
-        used += len(line) + 1
-    text = "\n".join(out).rstrip()
-    return text + f"\n\n（以上为该专家的人格摘录，来自 T专家 名册；完整正文可用 summon_t_expert 获取。）"
-
-
-def load_roster(experts_root: str, zh_root: str) -> dict[str, dict]:
-    names_path = os.path.join(zh_root, "names.json")
-    desc_path = os.path.join(zh_root, "descriptions.json")
-    names = json.load(open(names_path, encoding="utf-8")) if os.path.isfile(names_path) else {}
-    descs = json.load(open(desc_path, encoding="utf-8")) if os.path.isfile(desc_path) else {}
-    roster: dict[str, dict] = {}
-    for dirpath, _dirs, files in os.walk(experts_root):
-        for name in files:
-            if not name.endswith(".md"):
-                continue
-            slug = name[:-3]
-            path = os.path.join(dirpath, name)
-            head = open(path, encoding="utf-8", errors="replace").read(600)
-            if not (head.startswith("---") and NAME_FIELD.search(head)):
-                continue
-            rel = os.path.relpath(path, experts_root)
-            zh_path = os.path.join(zh_root, rel)
-            roster[slug] = {
-                "slug": slug,
-                "path": zh_path if os.path.isfile(zh_path) else path,   # 中文侧车优先
-                "zhBody": os.path.isfile(zh_path),
-                "division": rel.split(os.sep)[0],
-                "nameZh": names.get(slug),
-                "descriptionZh": descs.get(slug),
-            }
-    return roster
-
-
-def build_members(slugs: list[str], roster: dict[str, dict], mode: str, budget: int,
-                  errors: list[str], where: str, max_members: int = MAX_MEMBERS) -> list[dict]:
-    members, used_names = [], {}
-    if len(slugs) > max_members:
-        errors.append(f"{where}: 成员 {len(slugs)} 位超过上限 {max_members}")
-    for slug in slugs:
-        expert = roster.get(slug)
-        if expert is None:
-            errors.append(f"{where}: 名册里没有专家 {slug}")
-            continue
-        display = expert["nameZh"] or slug
-        key = sanitize_key(display)
-        if key in used_names and used_names[key] != display:
-            errors.append(f"{where}: 成员名「{display}」与「{used_names[key]}」会撞同一个键（{key}）")
-            continue
-        used_names[key] = display
-        body = read_persona(expert["path"])
-        if mode == "reference":
-            prompt = (f'你是 T专家 名册里的「{display}」（{slug}）。开始工作前先调用\n'
-                      f'summon_t_expert("{display}", "<本次分配给你的任务>") 取得完整工作准则，再按其产出交付。')
-        elif mode == "full":
-            prompt = body
-        else:
-            prompt = summarize(body, budget)
-        members.append({"name": display, "role": slug, "executionPrompt": prompt, "zh": expert["zhBody"]})
-    return members
-
-
-def yaml_scalar(value: str) -> str:
-    """极窄的 YAML 标量输出（本脚本只需写字符串）：只在必要时加引号。"""
-    text = str(value)
-    needs_quote = (
-        text == ""
-        or text != text.strip()
-        or text[0] in "-?:,[]{}#&*!|>'\"%@`"
-        or ": " in text
-        or " #" in text
-        or "\n" in text
-    )
-    if needs_quote:
-        escaped = text.replace("\\", "\\\\").replace('"', '\\"').replace("\n", "\\n")
-        return f'"{escaped}"'
-    return text
-
-
-def emit_member(member: dict, indent: str) -> str:
-    lines = [f"{indent}- name: {yaml_scalar(member['name'])}",
-             f"{indent}  role: {yaml_scalar(member['role'])}",
-             f"{indent}  executionPrompt: |"]
-    for line in member["executionPrompt"].splitlines() or [""]:
-        lines.append(f"{indent}    {line}".rstrip())
-    return "\n".join(lines)
-
-
-def build_engine_config(spec: dict, profiles: dict[str, dict]) -> dict:
-    """构造**真正会写下去**的引擎配置（`t-team.config.json` 的那份对象）。
-
-    预览与落盘共用这一个构造点，两者不可能再漂移 —— 这是「预览必须等于产物」的实现方式。
-
-    注意：**不要**把 stateDir 写进这份 JSON。状态目录的唯一真源是插件侧 Config.stateDir
-    （lib/index.js 用它挂载引擎、找团队状态、跑 t_team_plan_check）。这里再写一份，就会出现
-    「数据文件里一个值、实际生效另一个值」的双来源：改开 Config.stateDir 的部署两边失明且无报错
-    （审计 D-1）。历史数据文件里的该字段已删除，且插件不再读它。
-    """
-    return {
-        "memberProvider": (spec.get("engine") or {}).get("memberProvider", "spawn"),
-        "profiles": {
-            key: {
-                "description": profile["description"],
-                "taskPlanning": profile["taskPlanning"],
-                "members": [
-                    {"name": m["name"], "role": m["role"], "executionPrompt": m["executionPrompt"]}
-                    for m in profile["members"]
-                ],
-                **({"tasks": profile["tasks"]} if profile.get("tasks") else {}),
-            }
-            for key, profile in profiles.items()
-        },
-    }
-
-
-def remove_patch_block(patch_path: str, dry_run: bool) -> bool:
-    """历史版本把 profiles 写进 profile patch 的 agent-teams 行；现在引擎由 T专家 内置挂载，
-    这里把那个标记块移除（幂等）。"""
-    if not os.path.isfile(patch_path):
-        return False
-    old = open(patch_path, encoding="utf-8").read()
-    pattern = re.compile(re.escape(MARKER_START) + r".*?" + re.escape(MARKER_END) + r"\n?", re.S)
-    if not pattern.search(old):
-        return False
-    if dry_run:
-        return True
-    shutil.copy2(patch_path, f"{patch_path}.bak.{datetime.now():%Y%m%d-%H%M%S}")
-    open(patch_path, "w", encoding="utf-8").write(pattern.sub("", old).rstrip("\n") + "\n")
-    return True
-
-
-def read_engine_state_dir(engine_config_path: str) -> object:
-    """读盘上那份产物里的 stateDir 死字段（只为让预览如实说明「它会被丢弃」；读不到就返回 None）。"""
-    if not os.path.isfile(engine_config_path):
-        return None
-    try:
-        return json.load(open(engine_config_path, encoding="utf-8")).get("stateDir")
-    except (OSError, json.JSONDecodeError):
-        return None
-
-
-def main() -> int:
-    ap = argparse.ArgumentParser()
-    ap.add_argument("--teams", default=DEFAULT_TEAMS)
-    ap.add_argument("--experts", default=DEFAULT_EXPERTS)
-    ap.add_argument("--zh", default=DEFAULT_ZH)
-    ap.add_argument("--patch", default=DEFAULT_PATCH)
-    ap.add_argument("--mode", choices=["summary", "full", "reference"], help="覆盖默认人格模式")
-    ap.add_argument("--max-members", type=int, default=MAX_MEMBERS,
-                    help=f"一个 profile 的成员数上限（默认 {MAX_MEMBERS}；插件侧由 Config.maxMembers 透传）")
-    ap.add_argument("--dry-run", action="store_true")
-    ap.add_argument("--no-write", action="store_true")
-    args = ap.parse_args()
-
-    if args.max_members < 1:
-        print(f"错误：--max-members 必须是正整数，收到 {args.max_members}", file=sys.stderr)
-        return 1
-    if not os.path.isfile(args.teams):
-        print(f"错误：找不到小队定义 {args.teams}", file=sys.stderr)
-        return 1
-    spec = json.load(open(args.teams, encoding="utf-8"))
-    defaults = spec.get("defaults") or {}
-    roster = load_roster(args.experts, args.zh)
-    if not roster:
-        print(f"错误：{args.experts} 里没有专家，先跑 sync.sh", file=sys.stderr)
-        return 1
-
-    errors: list[str] = []
-    profiles: dict[str, dict] = {}
-    aliases: dict[str, str] = {}
-    raw_profiles = spec.get("profiles") or {}
-    if len(raw_profiles) > MAX_PROFILES:
-        errors.append(f"小队 {len(raw_profiles)} 支超过 AgentTeams 上限 {MAX_PROFILES}")
-
-    disabled = [key for key, profile in raw_profiles.items() if profile.get("enabled") is False]
-    for key in disabled:
-        print(f"  跳过（已关停）：{key}")
-
-    for key, profile in raw_profiles.items():
-        if profile.get("enabled") is False:
-            continue
-        if not PROFILE_KEY_RE.match(key):
-            errors.append(f"小队 key「{key}」不合法：只能用 a-z0-9 与 -（AgentTeams 的 profile key 必须是 ASCII）")
-            continue
-        for alias in profile.get("aliases") or []:
-            if alias in aliases:
-                errors.append(f"别名「{alias}」被 {aliases[alias]} 与 {key} 同时使用")
-            elif alias in raw_profiles and alias != key:
-                errors.append(f"别名「{alias}」与另一支小队的 key 冲突")
-            else:
-                aliases[alias] = key
-        mode = args.mode or profile.get("personaMode") or defaults.get("personaMode") or "summary"
-        budget = int(profile.get("personaBudget") or defaults.get("personaBudget") or 1600)
-        members = build_members(list(profile.get("members") or []), roster, mode, budget, errors, key, args.max_members)
-        if not members:
-            errors.append(f"{key}: 没有任何有效成员")
-            continue
-        tasks = profile.get("tasks") or []
-        if len(tasks) > MAX_SEED_TASKS:
-            errors.append(f"{key}: 固定任务 {len(tasks)} 条超过上限 {MAX_SEED_TASKS}")
-        described = profile.get("description") or f"{key}"
-        profiles[key] = {
-            "description": described,
-            "taskPlanning": profile.get("taskPlanning") or defaults.get("taskPlanning") or "captain",
-            "members": members,
-            "tasks": tasks,
-            "aliases": list(profile.get("aliases") or []),
-            "mode": mode,
-        }
-
-    print(f"名册专家      : {len(roster)}")
-    print(f"小队          : {len(profiles)} / {MAX_PROFILES} 支")
-    for key, profile in profiles.items():
-        zh_count = sum(1 for m in profile["members"] if m["zh"])
-        names = "、".join(m["name"] for m in profile["members"])
-        line = (f"  {key:20} {len(profile['members'])} 人 · {profile['taskPlanning']} · "
-                f"{profile['mode']} · {profile['description']}")
-        print(line)
-        if profile["aliases"]:
-            print(f"    {'':18}别名: {'/'.join(profile['aliases'])}")
-        print(f"    {'':18}成员: {names}")
-        print(f"    {'':18}人格语言: 中文 {zh_count}/{len(profile['members'])}（缺中文的用英文原文）")
-
-    if errors:
-        print("\n校验失败：", file=sys.stderr)
-        for error in errors:
-            print("  ✗", error, file=sys.stderr)
-        return 1
-
-    # 引擎配置：T专家 在 apply 时读它并 ctx.plugin(内置引擎, 该配置)
-    engine_config_path = os.path.join(os.path.dirname(os.path.abspath(args.teams)), "t-team.config.json")
-    engine_config = build_engine_config(spec, profiles)
-
-    if args.dry_run or args.no_write:
-        # 预览必须等于产物：这里打印的就是上面那个 engine_config 对象。
-        # 旧实现在这里打印一段带 `- id: agent-teams` / `stateDir: .agent-teams` 的**遗留 patch 块**，
-        # 既与实际产物不符，又与 build_engine_config 的「不要把 stateDir 写进这份 JSON」注释自相矛盾
-        # —— 预览是给人看的，看到的东西必须等于真正会写下去的东西（复核 F-1）。
-        preview = copy.deepcopy(engine_config)
-        legacy_state_dir = read_engine_state_dir(engine_config_path)
-        # 预览的键集合必须与产物一致，所以 stateDir **不作为产物键**出现；
-        # 盘上若还留着历史死字段，另起一行如实说明它会被丢弃（不塞进 JSON 里假装是产物）。
-        print("\n" + "=" * 60)
-        print(f"预览：将写入 {engine_config_path}（内容与该文件实际写入的完全一致）：\n")
-        print(json.dumps(preview, ensure_ascii=False, indent=2))
-        print("\nstateDir：不是本文件的产物字段（预览与产物都不含它）。"
-              "状态目录的唯一真源是插件侧 Config.stateDir（审计 D-1）；"
-              f"历史遗留字段{'会被丢弃（盘上当前值 ' + repr(legacy_state_dir) + '）' if legacy_state_dir is not None else '已不在盘上'}。")
-        if args.dry_run:
-            print("（dry-run，未写盘）")
-        return 0
-
-    with open(engine_config_path, "w", encoding="utf-8") as handle:
-        json.dump(engine_config, handle, ensure_ascii=False, indent=2)
-        handle.write("\n")
-    print(f"  引擎配置    : {engine_config_path}")
-
-    removed = remove_patch_block(args.patch, args.dry_run)
-
-    # 同时写一份「已解析」的小队清单：/t 的列表用它显示中文成员名
-    resolved_path = os.path.join(os.path.dirname(os.path.abspath(args.teams)), "teams.resolved.json")
-    json.dump({
-        "generatedAt": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
-        "source": os.path.basename(args.teams),
-        "profiles": {
-            key: {
-                "description": profile["description"],
-                "aliases": profile["aliases"],
-                "taskPlanning": profile["taskPlanning"],
-                "mode": profile["mode"],
-                "members": [{"name": m["name"], "role": m["role"]} for m in profile["members"]],
-            }
-            for key, profile in profiles.items()
-        },
-    }, open(resolved_path, "w", encoding="utf-8"), ensure_ascii=False, indent=2)
-    open(resolved_path, "a", encoding="utf-8").write("\n")
-    print(f"  解析清单    : {resolved_path}")
-    total = sum(len(m["executionPrompt"]) for p in profiles.values() for m in p["members"])
-    if removed:
-        print(f"\n已从 {args.patch} 移除旧的 agent-teams 配置块（团队引擎现由 T专家 内置挂载）")
-    print(f"  成员人格体积: {total} 字符（{len(profiles)} 支小队）")
-    print("\n下一步：重启 DSH Desktop 让新配置生效，然后就能用：")
-    for key, profile in profiles.items():
-        print(f"  /t {profile['aliases'][0] if profile['aliases'] else key} <目标>     或  /t --profile {key} <目标>")
-    return 0
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())