dsh-collab-workbench 0.0.0-stage → 0.1.2

package/src/host/memory.js

@@ -0,0 +1,175 @@
+// memory.js —— 记忆（P1：个人记忆 + 团队记忆，Markdown 存储，工具 + RPC 管理）。
+// 格式（参考 AgentMemoryRepo 行格式，自研实现）：
+//   每条一行：`- 内容 [added: YYYY-MM-DD]`
+// 存储：$home/memory/person-<id>/MEMORY.md 与 $home/memory/team/MEMORY.md
+// 注入：群会话种子消息带记忆摘要；工具 dwb_remember/dwb_forget/dwb_recall 供人员随时读写。
+import { mkdir, readFile, writeFile } from 'node:fs/promises'
+import { defineTool } from '@deepseek-ai/dsh-tools'
+import { join } from 'node:path'
+
+const MAX_ENTRIES = 200 // 每个作用域条目上限
+const MAX_LINE = 300 // 单条最多 300 字符
+
+function today() {
+  const d = new Date()
+  const p = (n) => String(n).padStart(2, '0')
+  return `${d.getFullYear()}-${p(d.getMonth() + 1)}-${p(d.getDate())}`
+}
+
+export function install(rt) {
+  const { ctx } = rt
+
+  const memRoot = () => join(rt.home, 'memory')
+  const personPath = (roleId) => join(memRoot(), `person-${roleId}`, 'MEMORY.md')
+  const teamPath = () => join(memRoot(), 'team', 'MEMORY.md')
+
+  async function readScope(path) {
+    try {
+      const raw = await readFile(path, 'utf8')
+      return raw.split('\n')
+        .map(l => l.trim())
+        .filter(l => l.startsWith('- '))
+        .map(l => {
+          const m = l.match(/^- (.*) \[added: (\d{4}-\d{2}-\d{2})\]$/)
+          if (m) return { text: m[1], added: m[2] }
+          // 容错：无日期尾注的行
+          return { text: l.slice(2).replace(/ \[added: [^\]]*\]$/, ''), added: '' }
+        })
+    } catch {
+      return []
+    }
+  }
+
+  async function writeScope(path, entries) {
+    await mkdir(join(path, '..'), { recursive: true })
+    const body = entries.slice(0, MAX_ENTRIES)
+      .map(e => `- ${e.text} [added: ${e.added || today()}]`)
+      .join('\n')
+    await writeFile(path, body ? body + '\n' : '', 'utf8')
+  }
+
+  const scopePath = (scope, roleId) => (scope === 'team' ? teamPath() : personPath(roleId))
+
+  // ---- RPC 面（client 记忆面板） ----
+  rt.memoryList = async (roleId) => ({
+    own: roleId ? await readScope(personPath(roleId)) : [],
+    team: await readScope(teamPath()),
+  })
+  rt.memoryAdd = async (roleId, scope, text) => {
+    const clean = String(text ?? '').trim().slice(0, MAX_LINE)
+    if (!clean) throw new Error('记忆内容不能为空')
+    if (/api[_-]?key|password|token|secret|密钥|密码/i.test(clean)) {
+      throw new Error('记忆不允许保存密钥/密码类内容')
+    }
+    const path = scopePath(scope, roleId)
+    const entries = await readScope(path)
+    if (entries.length >= MAX_ENTRIES) throw new Error(`记忆已达上限（${MAX_ENTRIES} 条），请先清理`)
+    entries.push({ text: clean, added: today() })
+    await writeScope(path, entries)
+    return entries.length
+  }
+  rt.memoryRemove = async (roleId, scope, index) => {
+    const path = scopePath(scope, roleId)
+    const entries = await readScope(path)
+    if (index < 0 || index >= entries.length) throw new Error('条目不存在')
+    entries.splice(index, 1)
+    await writeScope(path, entries)
+    return entries.length
+  }
+
+  // 种子消息用的记忆摘要（各作用域最多取 12 条）。
+  rt.memoryDigest = async (roleId) => {
+    const [own, team] = await Promise.all([
+      readScope(personPath(roleId)),
+      readScope(teamPath()),
+    ])
+    const parts = []
+    if (own.length > 0) parts.push(`【你的记忆】\n${own.slice(-12).map(e => `- ${e.text}`).join('\n')}`)
+    if (team.length > 0) parts.push(`【团队记忆】\n${team.slice(-12).map(e => `- ${e.text}`).join('\n')}`)
+    return parts.join('\n')
+  }
+
+  // ---- 人员工具面 ----
+  const OUTPUT = {
+    schema: { type: 'string' },
+    render: (_args, value) => [{ type: 'text', text: String(value) }],
+  }
+
+  ctx.tools.register(defineTool({
+    name: 'dwb_remember',
+    description: '保存一条记忆（跨对话持久）。scope=me 存入你的个人记忆，scope=team 存入团队共享记忆（管理员/群管理员可用）。单条 ≤300 字符，禁止保存密钥/密码。',
+    parameters: {
+      text: { type: 'string', description: '要记住的内容（偏好/决策/纠错/事实）', required: true },
+      scope: { type: 'string', enum: ['me', 'team'], description: 'me=个人（默认），team=团队共享' },
+      roleId: { type: 'string', description: '你的角色 id（dwb_post_group_message 同款）' },
+    },
+    output: OUTPUT,
+    async execute(args) {
+      const me = args.roleId ?? currentRoleId.get()
+      if (!me) return '请提供你的 roleId'
+      if (args.scope === 'team') {
+        // 团队记忆：管理员或任意群管理员可写
+        const role = rt.getRole(me)
+        const isAdmin = (rt.listGroups() ?? []).some(g => (g.admins ?? []).includes(me))
+        if (!isAdmin && role?.type !== '研发负责人') {
+          return '团队记忆仅管理员可写；个人记忆请用 scope=me'
+        }
+      }
+      const n = await rt.memoryAdd(me, args.scope ?? 'me', args.text)
+      return `已记住（${args.scope === 'team' ? '团队' : '个人'}，共 ${n} 条）`
+    },
+  }))
+
+  ctx.tools.register(defineTool({
+    name: 'dwb_forget',
+    description: '删除一条记忆：给出要删除内容的完整原文或前缀。',
+    parameters: {
+      text: { type: 'string', description: '要删除的记忆内容（原文或明显前缀）', required: true },
+      roleId: { type: 'string', description: '你的角色 id' },
+    },
+    output: OUTPUT,
+    async execute(args) {
+      const me = args.roleId ?? currentRoleId.get()
+      if (!me) return '请提供你的 roleId'
+      for (const scope of ['me', 'team']) {
+        const path = scopePath(scope, me)
+        const entries = await readScope(path)
+        const idx = entries.findIndex(e => e.text === args.text || e.text.startsWith(args.text))
+        if (idx >= 0) {
+          entries.splice(idx, 1)
+          await writeScope(path, entries)
+          return `已从${scope === 'team' ? '团队' : '个人'}记忆删除 1 条`
+        }
+      }
+      return '未找到匹配的记忆'
+    },
+  }))
+
+  ctx.tools.register(defineTool({
+    name: 'dwb_recall',
+    description: '搜索记忆（个人 + 团队）。query 为空时列出全部条目。',
+    parameters: {
+      query: { type: 'string', description: '关键词（空=列出全部）' },
+      roleId: { type: 'string', description: '你的角色 id' },
+    },
+    output: OUTPUT,
+    async execute(args) {
+      const me = args.roleId ?? currentRoleId.get()
+      if (!me) return '请提供你的 roleId'
+      const { own, team } = await rt.memoryList(me)
+      const q = String(args.query ?? '').trim().toLowerCase()
+      const hit = (list) => (q ? list.filter(e => e.text.toLowerCase().includes(q)) : list)
+      const fmt = (list) => list.map(e => `- ${e.text}${e.added ? `（${e.added}）` : ''}`).join('\n') || '（无）'
+      return `【个人记忆】\n${fmt(hit(own))}\n\n【团队记忆】\n${fmt(hit(team))}`
+    },
+  }))
+
+  // 当前投递上下文中的人员 id（deliverToMember 投递时登记，工具执行时可读到）。
+  const currentRoleId = {
+    value: null,
+    get: () => currentRoleId.value,
+    set: (v) => { currentRoleId.value = v },
+  }
+  rt.setCurrentDeliveryRole = currentRoleId.set
+}
+

package/src/host/policy.js

@@ -0,0 +1,43 @@
+// policy.js —— 工作台规范（V2：职责字段只存纯净内容，不注入模板）。
+// 早期版本把「工作台铁律」模板注入 role.instructions，导致：
+//   a) 序号错乱（rules[3] 误覆盖第 3 条）、职责行重复；
+//   b) 编辑弹窗带着模板往返存储，越改越乱。
+// 现改为：instructions 只存用户职责；历史损坏数据由 migrateRoleInstructions 清洗。
+export const MESSAGE_POLICY = '群聊只发需要用户知道、决定或处理的信息：负责人统一启动一次，仅重要变化汇报进度，最终交付一次（结果、入口、验证情况及遗留问题）；成员不逐个宣告开工、不发收到/确认、不重复转述。开发报结果与验证，测试报通过与否、覆盖范围及未解决风险，产品/架构只报影响范围或实现方向的关键结论。独立执行用 dwb_report_execution 留存完整摘要与 evidence，系统生成简短回执，不再另发同一成果或阻塞；普通执行中状态不刷群。仅需对方行动时 @协调；阻塞说明问题、影响及需要谁做什么，相同阻塞不重复播报。决策说明问题、推荐选项和主要影响，需求明确不二次确认。普通消息尽量 100 字、最多 150 字；技术细节和完整证据留在文档/任务记录，通过 dwb_task_execution 查询。'
+
+export const IRON_RULES = [
+  '所有沟通只发生在群组中，用 @角色名 点名；',
+  '不存在任何一对一私聊通道；',
+  '收到群消息后，把结论/进展/疑问回复到群组，保持群内可见。',
+]
+
+// 清洗历史注入的模板：去掉铁律 boilerplate，提取纯职责。
+// 兼容损坏样本（缺第3条、职责行重复、序号 3/4 不一）：
+// 取所有「N. 你的角色职责：」行中第一个冒号后非空的内容作为纯职责。
+export function sanitizeInstructions(text) {
+  const raw = String(text ?? '')
+  if (!raw.includes('【工作台铁律】')) return raw
+  const lines = raw.split('\n')
+  for (const line of lines) {
+    const m = line.trim().match(/^\d+\.\s*你的角色职责：(.*)$/)
+    if (m && m[1].trim()) return m[1].trim()
+  }
+  return ''
+}
+
+export function install(rt) {
+  // 一次性迁移：清洗所有角色的 instructions（幂等，重启安全）。
+  rt.migrateRoleInstructions = () => {
+    let changed = false
+    for (const role of rt.state.roles.items) {
+      const clean = sanitizeInstructions(role.instructions ?? '')
+      if (clean !== (role.instructions ?? '')) {
+        role.instructions = clean
+        role.updatedAt = Date.now()
+        changed = true
+      }
+    }
+    if (changed) rt.touch()
+    return changed
+  }
+}

package/src/host/tasks.js

@@ -0,0 +1,117 @@
+// Tasks retain the existing UI status vocabulary; execution details live in execution.runs.
+export const PRIORITIES = ['高', '中', '低']
+export const TASK_STATUSES = ['待办', '进行中', '已完成']
+const PATCH_FIELDS = new Set(['title', 'description', 'assignees', 'priority', 'status', 'dependencies'])
+
+export function install(rt) {
+  rt.validatePriority = (value = '中') => {
+    if (!PRIORITIES.includes(value)) throw new Error(`优先级必须是 ${PRIORITIES.join('/')}`)
+    return value
+  }
+  rt.validateTaskStatus = (value = '待办') => {
+    if (!TASK_STATUSES.includes(value)) throw new Error(`状态必须是 ${TASK_STATUSES.join('/')}`)
+    return value
+  }
+  const validateAssignees = (values, group) => {
+    if (!Array.isArray(values) || !values.length) throw new Error('任务至少指派 1 名工程师')
+    const ids = [...new Set(values.map(String))]
+    for (const id of ids) {
+      const role = rt.getRole(id)
+      if (!role) throw new Error(`指派角色 ${id} 不存在`)
+      if (role.status !== 'active') throw new Error(`指派角色「${role.name}」已停用`)
+      if (!(group.members ?? []).includes(id)) throw new Error(`指派角色「${role.name}」必须是群组成员`)
+    }
+    return ids
+  }
+  const validateDependencies = (values = [], group, ownId) => {
+    if (!Array.isArray(values)) throw new Error('dependencies 必须是任务 id 数组')
+    const ids = [...new Set(values.map(String))]
+    const visit = (id, seen = new Set()) => {
+      if (id === ownId) throw new Error('任务依赖不能形成循环')
+      if (seen.has(id)) return
+      seen.add(id)
+      const t = rt.getTask(id)
+      if (!t || t.groupId !== group.id) throw new Error(`依赖任务 ${id} 必须存在且属于同一群组`)
+      for (const next of t.dependencies ?? []) visit(next, seen)
+    }
+    ids.forEach(id => visit(id))
+    return ids
+  }
+  const ready = async () => { await rt.loadAll(); await rt.executionReady }
+  const groupFor = id => {
+    const group = rt.getGroup(id)
+    if (!group || group.status !== 'active') throw new Error('群组不存在、已归档或正在删除')
+    return group
+  }
+  const notify = async (task, text, fromRoleId) => {
+    try {
+      const post = rt.postSystemGroupMessage ?? rt.postGroupMessage
+      await post({ groupId: task.groupId, taskId: task.id, text, fromRoleId, noWake: true })
+    } catch (error) {
+      // A task already committed is not a failed create; caller retries must not duplicate it.
+      task.notificationError = String(error?.message ?? error)
+      rt.touch()
+    }
+  }
+  rt.createTask = async ({ title, description, groupId, assignees, priority, dependencies, fromRoleId, autoPost = true }) => {
+    await ready()
+    const cleanTitle = String(title ?? '').trim()
+    if (!cleanTitle) throw new Error('任务标题不能为空')
+    const group = groupFor(groupId)
+    fromRoleId = rt.resolveGroupActor?.(group, fromRoleId) ?? fromRoleId
+    if (group.pendingDecision) throw new Error('群内有未回复的决策，等待用户拍板后再创建任务')
+    const task = {
+      id: rt.nextId('task'), title: cleanTitle, description: String(description ?? ''), groupId: group.id,
+      assignees: validateAssignees(assignees, group), priority: rt.validatePriority(priority),
+      dependencies: validateDependencies(dependencies, group), schedulerVersion: 1, revision: 1, status: '待办',
+      createdAt: Date.now(), updatedAt: Date.now(), completedAt: null,
+    }
+    rt.addTask(task)
+    // Persist task + run intents before notification or model execution.
+    await rt.taskCreated?.(task)
+    await rt.saveAll?.()
+    if (autoPost) await notify(task, `【新任务 ${task.id}】${task.title}\n优先级：${task.priority}\n描述：${task.description || '（无）'}\n指派：${task.assignees.map(id => `@${rt.getRole(id)?.name ?? id}`).join(' ')}\n已进入系统执行队列。`, fromRoleId)
+    rt.kickExecution?.()
+    return task
+  }
+  rt.updateTask = async (id, patch, { fromRoleId, autoPost = true } = {}) => {
+    await ready()
+    const task = rt.getTask(id)
+    if (!task) throw new Error(`任务 ${id} 不存在`)
+    const group = groupFor(task.groupId)
+    fromRoleId = rt.resolveGroupActor?.(group, fromRoleId) ?? fromRoleId
+    for (const key of Object.keys(patch)) if (!PATCH_FIELDS.has(key)) throw new Error(`不允许修改任务字段 ${key}`)
+    const next = { ...patch }
+    if (next.title !== undefined) {
+      next.title = String(next.title).trim()
+      if (!next.title) throw new Error('任务标题不能为空')
+    }
+    if (next.description !== undefined) next.description = String(next.description)
+    if (next.assignees !== undefined) next.assignees = validateAssignees(next.assignees, group)
+    if (next.priority !== undefined) next.priority = rt.validatePriority(next.priority)
+    if (next.dependencies !== undefined) next.dependencies = validateDependencies(next.dependencies, group, task.id)
+    if (next.status !== undefined) {
+      next.status = rt.validateTaskStatus(next.status)
+      next.completedAt = next.status === '已完成' ? (task.completedAt ?? Date.now()) : null
+    }
+    await rt.validateExecutionTaskUpdate?.(task, next)
+    if (['title','description','assignees','dependencies'].some(key => next[key] !== undefined && JSON.stringify(next[key]) !== JSON.stringify(task[key]))) next.revision = (task.revision ?? 1) + 1
+    const updated = rt.updateTaskRecord(id, { ...next, updatedAt: Date.now() })
+    await rt.taskChanged?.(updated, task)
+    await rt.saveAll?.()
+    if (autoPost) await notify(updated, `【任务更新 ${updated.id}】${updated.title}\n状态：${updated.status}\n优先级：${updated.priority}`, fromRoleId)
+    rt.kickExecution?.()
+    return updated
+  }
+  rt.listTasks = groupId => {
+    const canonical = groupId ? (rt.getGroup(groupId)?.id ?? groupId) : null
+    return rt.state.tasks.items.filter(t => !canonical || t.groupId === canonical)
+  }
+  rt.updateTaskRecord = (id, patch) => {
+    const index = rt.state.tasks.items.findIndex(t => t.id === id)
+    if (index < 0) return undefined
+    rt.state.tasks.items[index] = { ...rt.state.tasks.items[index], ...patch }
+    rt.touch()
+    return rt.state.tasks.items[index]
+  }
+}