dsh-plugin-t-expert 0.1.0

package/lib/plan-check.js

@@ -0,0 +1,171 @@
+/**
+ * DAG 预检（只读）：把「打算创建的一整套任务」先跑一遍引擎的校验，**一次报出全部问题**。
+ *
+ * 为什么需要它：引擎建任务是**逐条**的（依赖只能引用已存在的任务），每条硬校验都单独拒绝，
+ * 中途失败会留下半成品，模型再重试就容易出现重复任务（本机实测踩过）。
+ * 这里复用引擎自己的 `validateCreateTask`（契约/写域重叠/质量门槛），再补上引擎在
+ * `validateStagedGraph`（未导出）里做的引用与环检查，全部在内存里模拟、不写任何状态。
+ */
+import { CAPTAIN_KEY, readTeam } from "./teams/state.js";
+import { validateCreateTask } from "./teams/quality-gates.js";
+
+/** 与引擎 `validateStagedGraph` 对齐的引用/环检查（该函数未导出，这里按同规则复刻）。 */
+function graphProblems(tasks) {
+  const problems = [];
+  const ids = new Set(tasks.map((task) => task.id));
+  for (const task of tasks) {
+    if (String(task.subject ?? "").trim() === "") problems.push(`任务 ${task.id} 缺少 subject`);
+    for (const dependency of task.dependencies ?? []) {
+      if (dependency === task.id) problems.push(`任务 ${task.id} 不能依赖自己`);
+      else if (!ids.has(dependency)) problems.push(`任务 ${task.id} 依赖不存在的 ${dependency}`);
+    }
+  }
+  // 环路检测（DFS 三色）
+  const visiting = new Set();
+  const visited = new Set();
+  const byId = new Map(tasks.map((task) => [task.id, task]));
+  const walk = (id, trail) => {
+    if (visiting.has(id)) {
+      problems.push(`依赖成环：${[...trail, id].join(" → ")}`);
+      return;
+    }
+    if (visited.has(id)) return;
+    visiting.add(id);
+    for (const dependency of byId.get(id)?.dependencies ?? []) walk(dependency, [...trail, id]);
+    visiting.delete(id);
+    visited.add(id);
+  };
+  for (const task of tasks) walk(task.id, []);
+  return [...new Set(problems)];
+}
+
+/** 拓扑序（依赖在前）；有环时返回已排好的部分。 */
+function topologicalOrder(tasks) {
+  const ids = new Set(tasks.map((task) => task.id));
+  const byId = new Map(tasks.map((task) => [task.id, task]));
+  const done = new Set();
+  const order = [];
+  const visit = (id) => {
+    if (done.has(id)) return;
+    done.add(id);
+    for (const dependency of byId.get(id)?.dependencies ?? []) if (ids.has(dependency)) visit(dependency);
+    order.push(id);
+  };
+  for (const task of tasks) visit(task.id);
+  return order;
+}
+
+/**
+ * @param team 引擎的团队状态（`readTeam` 的返回值）
+ * @param tasks 拟创建的任务数组；每项可带 `id`（本批内互相引用的标签，可省略）、`subject`、`kind`、
+ *              `dependencies`、`inScope`、`outOfScope`、`verify`、`acceptance`、`objective`、`assignee` 等
+ * @returns `{ ok, problems, warnings, order, existing }`
+ */
+export function checkPlan(team, tasks) {
+  const proposed = Array.isArray(tasks) ? tasks : [];
+  const existing = Array.isArray(team?.tasks) ? team.tasks : [];
+  const problems = [];
+  const warnings = [];
+  if (proposed.length === 0) problems.push("没有要检查的任务（tasks 为空）");
+
+  // 成员名集合：assignee 必须是活跃成员或 captain
+  const memberNames = new Set(
+    (team?.members ?? []).filter((member) => member.status !== "removed").map((member) => member.name),
+  );
+
+  // 逐条模拟：先做静态检查，再跑引擎的 validateCreateTask（它只看已存在的任务 + 已接受的模拟任务）
+  const sim = { ...(team ?? {}), tasks: [...existing] };
+  const taken = new Set(existing.map((task) => task.id));
+  const labels = new Map(); // 本批 id → 模拟 id
+  let counter = existing.length;
+  const report = [];
+
+  proposed.forEach((raw, index) => {
+    const local = [];
+    const wantId = typeof raw?.id === "string" && raw.id.trim() !== "" ? raw.id.trim() : undefined;
+    let simulatedId;
+    do {
+      counter += 1;
+      simulatedId = `t${counter}`;
+    } while (taken.has(simulatedId));
+    taken.add(simulatedId);
+    if (wantId !== undefined) labels.set(wantId, simulatedId);
+
+    const subject = String(raw?.subject ?? "").trim();
+    if (subject === "") local.push("缺少 subject");
+    const kind = typeof raw?.kind === "string" && raw.kind !== "" ? raw.kind : "work";
+    const dependencies = (Array.isArray(raw?.dependencies) ? raw.dependencies : [])
+      .map((dependency) => String(dependency))
+      .map((dependency) => labels.get(dependency) ?? dependency);
+    if (dependencies.includes(simulatedId)) local.push("不能依赖自己");
+    const unknown = dependencies.filter(
+      (dependency) => !taken.has(dependency) && !existing.some((task) => task.id === dependency),
+    );
+    if (unknown.length > 0) local.push(`依赖不存在的任务：${unknown.join(", ")}`);
+    const assignee = typeof raw?.assignee === "string" && raw.assignee.trim() !== "" ? raw.assignee.trim() : undefined;
+    if (assignee !== undefined && assignee !== CAPTAIN_KEY && !memberNames.has(assignee)) {
+      local.push(`assignee「${assignee}」不是当前成员（用 t_team_status 看成员名，或先 add_member）`);
+    }
+
+    // 引擎的契约/写域/质量门槛校验
+    let contract = "";
+    if (local.length === 0) {
+      const verdict = validateCreateTask(sim, {
+        ...raw,
+        subject,
+        kind,
+        dependencies,
+        assignee,
+      });
+      if (verdict.ok !== true) {
+        contract = String(verdict.error ?? "校验未通过");
+        local.push(contract);
+      } else {
+        sim.tasks.push({ ...verdict.task, id: simulatedId, dependencies });
+      }
+    }
+
+    if (local.length > 0) problems.push({ index, id: wantId ?? simulatedId, subject, error: local.join("；") });
+    report.push({ index, id: wantId ?? simulatedId, simulatedId, subject, ok: local.length === 0, error: local.join("；") });
+  });
+
+  // 环检查（含已存在的任务）
+  problems.push(...graphProblems(sim.tasks).map((error) => ({ index: -1, id: "graph", subject: "", error })));
+
+  // 提示（不阻塞）：成员同时只能有 1 个未完成任务（引擎在 claim/reassign 时才会拒）
+  const openStatuses = new Set(["pending", "claimed", "in_progress"]);
+  const busy = new Map();
+  for (const task of existing) {
+    if (task.assignee !== undefined && openStatuses.has(task.status)) busy.set(task.assignee, task.id);
+  }
+  for (const item of report) {
+    if (!item.ok) continue;
+    const assignee = proposed[item.index]?.assignee;
+    if (typeof assignee !== "string" || assignee === "" || assignee === CAPTAIN_KEY) continue;
+    const current = busy.get(assignee);
+    if (current !== undefined) {
+      warnings.push(`成员「${assignee}」已有未完成任务 ${current}（一个成员同时只能有 1 个未完成任务，新任务要等它结束）`);
+    }
+    busy.set(assignee, item.simulatedId);
+  }
+  if (report.length >= 3) {
+    const duplicated = report.map((item) => item.subject).filter((subject, index, all) => subject !== "" && all.indexOf(subject) !== index);
+    if (duplicated.length > 0) warnings.push(`有重复的 subject：${[...new Set(duplicated)].join("、")}（确认不是同一件事被建了两次）`);
+  }
+
+  return {
+    ok: problems.length === 0,
+    problems,
+    warnings: [...new Set(warnings)],
+    order: topologicalOrder(sim.tasks).filter((id) => !existing.some((task) => task.id === id)),
+    existing: existing.map((task) => ({ id: task.id, status: task.status, kind: task.kind ?? "work", assignee: task.assignee ?? "" })),
+  };
+}
+
+/** 从磁盘读当前团队（captain 会话 → 团队）。 */
+export async function readCaptainTeam({ stateRoot, captainSessionId, findTeamByCaptain }) {
+  const team = await findTeamByCaptain(stateRoot, captainSessionId);
+  return team;
+}
+
+export { readTeam };

package/lib/remote.js

@@ -0,0 +1,353 @@
+/**
+ * T专家 remote 服务：把 host 侧的名册/启用状态/persona 通过 Typert Gateway 暴露给客户端面板。
+ *
+ * 服务名（wire namespace）= "tTeam"，与其它专家插件的 wire namespace 不冲突；
+ * 客户端用 ctx.remote.$mount(描述符) + ctx.get("remote.tTeam") 取得代理。
+ */
+import { Remote, RemoteError, TypertRemoteService } from "@deepseek-ai/dsh-typert-protocol";
+import { z } from "zod";
+import { CATALOG_SERVICE, SETTINGS_NAMESPACE, SQUAD_SERVICE, TEAM_SERVICE } from "./index.js";
+
+const expertSchema = z.object({
+  slug: z.string(),
+  name: z.string(),
+  nameEn: z.string(),
+  description: z.string(),
+  descriptionEn: z.string(),
+  emoji: z.string(),
+  division: z.string(),
+  divisionZh: z.string(),
+  divisionEn: z.string(),
+  conflict: z.boolean().optional(),
+});
+
+const catalogSnapshotSchema = z.object({
+  experts: z.array(expertSchema),
+  enabled: z.array(z.string()),
+  revision: z.number().int().min(0),
+});
+
+const enabledStateSchema = z.object({
+  enabled: z.array(z.string()),
+  revision: z.number().int().min(0),
+});
+
+const promptSchema = z.object({ prompt: z.string() });
+
+const squadMemberSchema = z.object({
+  slug: z.string(),
+  role: z.string(),
+  name: z.string(),
+  nameZh: z.string(),
+  division: z.string(),
+  divisionZh: z.string(),
+  known: z.boolean(),
+});
+
+const squadSchema = z.object({
+  key: z.string(),
+  description: z.string(),
+  aliases: z.array(z.string()),
+  taskPlanning: z.enum(["captain", "seed"]),
+  enabled: z.boolean(),
+  members: z.array(squadMemberSchema),
+});
+
+const rosterExpertSchema = z.object({
+  slug: z.string(),
+  name: z.string(),
+  nameZh: z.string(),
+  division: z.string(),
+  divisionZh: z.string(),
+  enabled: z.boolean(),
+  conflict: z.boolean(),
+});
+
+const squadsSnapshotSchema = z.object({
+  revision: z.string(),
+  squads: z.array(squadSchema),
+  experts: z.array(rosterExpertSchema),
+  lastBuild: z.object({ at: z.number(), ok: z.boolean(), output: z.string() }),
+});
+
+const teamMemberSchema = z.object({
+  name: z.string(),
+  role: z.string(),
+  status: z.string(),
+  activity: z.string(),
+  done: z.number(),
+  total: z.number(),
+});
+
+const teamSchema = z.object({
+  teamId: z.string(),
+  name: z.string(),
+  workspace: z.string(),
+  captainSessionId: z.string(),
+  phase: z.string(),
+  halted: z.boolean(),
+  members: z.array(teamMemberSchema),
+  tasks: z.array(z.object({ id: z.string(), subject: z.string(), status: z.string(), assignee: z.string() })),
+});
+
+const teamsSnapshotSchema = z.object({ teams: z.array(teamSchema) });
+const startResultSchema = z.object({
+  profile: z.string(),
+  label: z.string(),
+  members: z.number(),
+});
+const stopResultSchema = z.object({
+  teamName: z.string(),
+  cancelledTasks: z.number(),
+  alreadyHalted: z.boolean(),
+});
+
+/** 面板提交的小队定义（saveSquads 的入参）。 */
+const squadInputSchema = z.object({
+  key: z.string().min(1).max(64),
+  description: z.string(),
+  aliases: z.array(z.string()),
+  taskPlanning: z.enum(["captain", "seed"]),
+  enabled: z.boolean(),
+  members: z.array(z.string()),
+});
+
+/** 一个 direct 调用描述符。 */
+function descriptor(method, parameters, typeSymbol, schema) {
+  return {
+    id: `dsh-plugin-t-expert#tTeam/${method}`,
+    service: "tTeam",
+    namespace: "tTeam",
+    method,
+    invocation: { kind: "direct" },
+    parameters,
+    result: { mode: "strict", typeSymbol, schema },
+  };
+}
+
+const DESCRIPTORS = [
+  descriptor("getCatalog", [], "TTeamCatalog", catalogSnapshotSchema),
+  descriptor("setEnabled", [
+    {
+      name: "enabled",
+      wire: "enabled",
+      source: "json",
+      codec: { mode: "strict", typeSymbol: "string[]", schema: z.array(z.string()) },
+    },
+    {
+      name: "expectedRevision",
+      wire: "expectedRevision",
+      source: "json",
+      codec: { mode: "strict", typeSymbol: "number", schema: z.number().int().min(0) },
+    },
+  ], "TTeamEnabledState", enabledStateSchema),
+  descriptor("getPrompt", [
+    {
+      name: "slug",
+      wire: "slug",
+      source: "json",
+      codec: { mode: "strict", typeSymbol: "string", schema: z.string().min(1).max(128) },
+    },
+    {
+      name: "division",
+      wire: "division",
+      source: "json",
+      codec: { mode: "strict", typeSymbol: "string", schema: z.string().min(1).max(64) },
+    },
+  ], "TTeamPrompt", promptSchema),
+  descriptor("getSquads", [], "TTeamSquads", squadsSnapshotSchema),
+  descriptor("saveSquads", [
+    {
+      name: "squads",
+      wire: "squads",
+      source: "json",
+      codec: { mode: "strict", typeSymbol: "TTeamSquadInput[]", schema: z.array(squadInputSchema).min(1).max(48) },
+    },
+    {
+      name: "expectedRevision",
+      wire: "expectedRevision",
+      source: "json",
+      codec: { mode: "strict", typeSymbol: "string", schema: z.string().max(64) },
+    },
+  ], "TTeamSquads", squadsSnapshotSchema),
+  descriptor("startSquad", [
+    {
+      name: "profileKey",
+      wire: "profileKey",
+      source: "json",
+      codec: { mode: "strict", typeSymbol: "string", schema: z.string().min(1).max(64) },
+    },
+    {
+      name: "sessionId",
+      wire: "sessionId",
+      source: "json",
+      codec: { mode: "strict", typeSymbol: "string", schema: z.string().max(128) },
+    },
+  ], "TTeamStartResult", startResultSchema),
+  descriptor("getTeams", [
+    {
+      name: "archived",
+      wire: "archived",
+      source: "json",
+      codec: { mode: "strict", typeSymbol: "boolean", schema: z.boolean() },
+    },
+  ], "TTeamTeams", teamsSnapshotSchema),
+  descriptor("stopTeam", [
+    {
+      name: "teamId",
+      wire: "teamId",
+      source: "json",
+      codec: { mode: "strict", typeSymbol: "string", schema: z.string().min(1).max(128) },
+    },
+  ], "TTeamStopResult", stopResultSchema),
+];
+
+/** Host 严格描述符表；Gateway 优先读取它，避免启动期 SRC 扫描漏掉后加载的外部插件服务。 */
+const TYPERT = {
+  package: "dsh-plugin-t-expert",
+  face: "host",
+  schemas: [],
+  model: { services: [], events: [], objects: [] },
+  invocations: DESCRIPTORS,
+};
+
+/**
+ * 手写 JS 里没有标准装饰器语法，这里用官方 `Remote(exportName)` 装饰器函数
+ * 手工打标记：伪造一个符合 TC39 decorator context 的对象，并让 addInitializer
+ * 以「原型指向宿主类原型」的假实例立即执行，从而把标记写到真正的 prototype 上。
+ */
+function exposeRemoteMethods(Class, methods) {
+  for (const method of methods) {
+    const context = {
+      kind: "method",
+      name: method,
+      static: false,
+      private: false,
+      access: { has: (object) => method in object, get: (object) => object[method] },
+      addInitializer: (initializer) => initializer.call(Object.create(Class.prototype)),
+    };
+    Remote(method)(Class.prototype[method], context);
+  }
+}
+
+class TTeamRemote extends TypertRemoteService {
+  static inject = ["settings", "typert"];
+
+  constructor(ctx) {
+    super(ctx, "tTeam");
+    this.ctx.typert.register(TYPERT);
+  }
+
+  /** 名册服务由 host 主插件通过 ctx.reflect.provide 提供。 */
+  catalog() {
+    const service = this.ctx.get(CATALOG_SERVICE);
+    if (service === undefined) throw new Error("T专家 名册服务不可用（host 插件未加载或已卸载）");
+    return service;
+  }
+
+  /** 动态名册：完整专家列表 + 已启用 slug + 修订号。 */
+  async getCatalog() {
+    return this.catalog().snapshot();
+  }
+
+  /** 整体替换启用列表；过期修订号由 settings 服务拒绝。 */
+  async setEnabled(enabled, expectedRevision) {
+    try {
+      return await this.catalog().setEnabled(enabled, expectedRevision);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      const code = typeof error === "object" && error !== null ? error.code : undefined;
+      // 裸 Error 过线会退化成 gateway/internal 并丢掉 code，所以业务错误统一转成 RemoteError。
+      if (code === "SETTINGS_CONFLICT" || /changed since it was read|another window|其他窗口/.test(message)) {
+        throw new RemoteError("tTeam/conflict", message, { expectedRevision: String(expectedRevision) });
+      }
+      if (message.includes("未知专家")) {
+        throw new RemoteError("tTeam/unknown-expert", message, {});
+      }
+      throw error;
+    }
+  }
+
+  /** 小队定义服务（设置页「小队」标签）。 */
+  squads() {
+    const service = this.ctx.get(SQUAD_SERVICE);
+    if (service === undefined) throw new Error("T专家 小队服务不可用（host 插件未加载）");
+    return service;
+  }
+
+  /** 团队运行服务（设置页「团队」标签）。 */
+  teams() {
+    const service = this.ctx.get(TEAM_SERVICE);
+    if (service === undefined) throw new Error("T专家 团队服务不可用（host 插件未加载）");
+    return service;
+  }
+
+  /** 小队定义 + 名册（成员选择器要的数据）。 */
+  async getSquads() {
+    try {
+      return this.squads().list();
+    } catch (error) {
+      throw this.businessError(error, "tTeam/squads-unreadable");
+    }
+  }
+
+  /** 写回小队定义并重编译引擎配置（失败自动回滚）。 */
+  async saveSquads(squads, expectedRevision) {
+    try {
+      return this.squads().save(squads, expectedRevision);
+    } catch (error) {
+      throw this.businessError(error, "tTeam/squads-invalid");
+    }
+  }
+
+  /** 从面板/弹窗里直接拉起一支小队（等价于用户敲 `/t <小队>`）。 */
+  async startSquad(profileKey, sessionId) {
+    try {
+      return await this.teams().start(profileKey, sessionId);
+    } catch (error) {
+      throw this.businessError(error, "tTeam/start-failed");
+    }
+  }
+
+  /** 活动团队 / 归档团队快照。 */
+  async getTeams(archived) {
+    try {
+      const teams = await this.teams().list(archived === true);
+      return { teams };
+    } catch (error) {
+      throw this.businessError(error, "tTeam/teams-unavailable");
+    }
+  }
+
+  /** 停止一个团队（等价于活动面板里的停止）。 */
+  async stopTeam(teamId) {
+    try {
+      return await this.teams().stop(teamId);
+    } catch (error) {
+      throw this.businessError(error, "tTeam/stop-failed");
+    }
+  }
+
+  /** 业务错误统一转 RemoteError（裸 Error 过线会退化成 gateway/internal 并丢掉 code）。 */
+  businessError(error, fallbackCode) {
+    if (error instanceof RemoteError) return error;
+    const message = error instanceof Error ? error.message : String(error);
+    const code = typeof error === "object" && error !== null && typeof error.code === "string" ? error.code : fallbackCode;
+    return new RemoteError(code, message, {});
+  }
+
+  /** 按需读取一位专家的 persona 正文（面板预览用）。 */
+  async getPrompt(slug, division) {
+    try {
+      return await this.catalog().prompt(slug, division);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      throw new RemoteError("tTeam/missing-expert", message, { slug });
+    }
+  }
+}
+
+exposeRemoteMethods(TTeamRemote, ["getCatalog", "setEnabled", "getPrompt", "getSquads", "saveSquads", "getTeams", "stopTeam", "startSquad"]);
+
+export { SETTINGS_NAMESPACE, DESCRIPTORS, TYPERT };
+export default TTeamRemote;