@yeaft/webchat-agent 0.0.233 → 0.0.235

package/crew/role-output.js

@@ -0,0 +1,315 @@
+/**
+ * Crew — 角色输出处理
+ * processRoleOutput（核心流式输出处理循环）
+ */
+import { sendCrewMessage, sendCrewOutput, sendStatusUpdate, endRoleStreaming } from './ui-messages.js';
+import { saveRoleSessionId, clearRoleSessionId, classifyRoleError, createRoleQuery } from './role-query.js';
+import { parseRoutes, executeRoute, dispatchToRole } from './routing.js';
+import { parseCompletedTasks, updateFeatureIndex, appendChangelog, saveRoleWorkSummary, updateKanban } from './task-files.js';
+
+// Context 使用率阈值常量
+const MAX_CONTEXT = 128000;       // API max_prompt_tokens 限制
+const CLEAR_THRESHOLD = 0.85;     // 85% → 直接 clear + rebuild（不再走 compact）
+
+/**
+ * 处理角色的流式输出
+ */
+export async function processRoleOutput(session, roleName, roleQuery, roleState) {
+  try {
+    for await (const message of roleQuery) {
+      // 检查 session 是否已停止或暂停
+      if (session.status === 'stopped' || session.status === 'paused') break;
+
+      if (message.type === 'system' && message.subtype === 'init') {
+        roleState.claudeSessionId = message.session_id;
+        console.log(`[Crew] ${roleName} session: ${message.session_id}`);
+        continue;
+      }
+
+      if (message.type === 'assistant') {
+        const content = message.message?.content;
+        if (content) {
+          if (typeof content === 'string') {
+            roleState.accumulatedText += content;
+            sendCrewOutput(session, roleName, 'text', message);
+          } else if (Array.isArray(content)) {
+            let hasText = false;
+            for (const block of content) {
+              if (block.type === 'text') {
+                roleState.accumulatedText += block.text;
+                hasText = true;
+              } else if (block.type === 'tool_use') {
+                endRoleStreaming(session, roleName);
+                roleState.currentTool = block.name;
+                sendCrewOutput(session, roleName, 'tool_use', message);
+              }
+            }
+            if (hasText) {
+              sendCrewOutput(session, roleName, 'text', message);
+            }
+          }
+        }
+      } else if (message.type === 'user') {
+        roleState.currentTool = null;
+        sendCrewOutput(session, roleName, 'tool_result', message);
+      } else if (message.type === 'result') {
+        // Turn 完成
+        console.log(`[Crew] ${roleName} turn completed`);
+        roleState.consecutiveErrors = 0;
+
+        endRoleStreaming(session, roleName);
+
+        // 更新费用（差值计算）
+        if (message.total_cost_usd != null) {
+          const costDelta = message.total_cost_usd - roleState.lastCostUsd;
+          if (costDelta > 0) session.costUsd += costDelta;
+          roleState.lastCostUsd = message.total_cost_usd;
+        }
+        if (message.usage) {
+          const inputDelta = (message.usage.input_tokens || 0) - (roleState.lastInputTokens || 0);
+          const outputDelta = (message.usage.output_tokens || 0) - (roleState.lastOutputTokens || 0);
+          if (inputDelta > 0) session.totalInputTokens += inputDelta;
+          if (outputDelta > 0) session.totalOutputTokens += outputDelta;
+          roleState.lastInputTokens = message.usage.input_tokens || 0;
+          roleState.lastOutputTokens = message.usage.output_tokens || 0;
+        }
+
+        // 持久化 sessionId
+        if (roleState.claudeSessionId) {
+          saveRoleSessionId(session.sharedDir, roleName, roleState.claudeSessionId)
+            .catch(e => console.warn(`[Crew] Failed to save sessionId for ${roleName}:`, e.message));
+        }
+
+        // context 使用率监控
+        const inputTokens = message.usage?.input_tokens || 0;
+        if (inputTokens > 0) {
+          sendCrewMessage({
+            type: 'crew_context_usage',
+            sessionId: session.id,
+            role: roleName,
+            inputTokens,
+            maxTokens: MAX_CONTEXT,
+            percentage: Math.min(100, Math.round((inputTokens / MAX_CONTEXT) * 100))
+          });
+        }
+
+        const contextPercentage = inputTokens / MAX_CONTEXT;
+        const needClear = contextPercentage >= CLEAR_THRESHOLD;
+
+        // 解析路由
+        const routes = parseRoutes(roleState.accumulatedText);
+
+        // 决策者 turn 完成：检测 TASKS block 中新完成的任务
+        const roleConfig = session.roles.get(roleName);
+        if (roleConfig?.isDecisionMaker) {
+          const nowCompleted = parseCompletedTasks(roleState.accumulatedText);
+          if (nowCompleted.size > 0) {
+            const prev = session._completedTaskIds || new Set();
+            const newlyDone = [];
+            for (const tid of nowCompleted) {
+              if (!prev.has(tid)) {
+                prev.add(tid);
+                newlyDone.push(tid);
+              }
+            }
+            session._completedTaskIds = prev;
+            if (newlyDone.length > 0) {
+              updateFeatureIndex(session).catch(e => console.warn('[Crew] Failed to update feature index:', e.message));
+              for (const tid of newlyDone) {
+                const feature = session.features.get(tid);
+                const title = feature?.taskTitle || tid;
+                appendChangelog(session, tid, title).catch(e => console.warn(`[Crew] Failed to append changelog for ${tid}:`, e.message));
+                updateKanban(session, { taskId: tid, completed: true }).catch(e => console.warn(`[Crew] Failed to update kanban for ${tid}:`, e.message));
+              }
+            }
+          }
+        }
+
+        // 保存 accumulatedText 供后续 saveRoleWorkSummary 使用（清空前）
+        const turnText = roleState.accumulatedText;
+        roleState.accumulatedText = '';
+        roleState.turnActive = false;
+
+        sendCrewMessage({
+          type: 'crew_turn_completed',
+          sessionId: session.id,
+          role: roleName
+        });
+
+        sendStatusUpdate(session);
+
+        // Context 超限：保存工作摘要后 clear + rebuild
+        if (needClear) {
+          console.log(`[Crew] ${roleName} context at ${Math.round(contextPercentage * 100)}%, clearing and rebuilding`);
+
+          // 保存工作摘要到 feature 文件
+          await saveRoleWorkSummary(session, roleName, turnText).catch(e =>
+            console.warn(`[Crew] Failed to save work summary for ${roleName}:`, e.message));
+
+          // Clear 角色
+          await clearRoleSessionId(session.sharedDir, roleName);
+          roleState.claudeSessionId = null;
+
+          if (roleState.abortController) roleState.abortController.abort();
+          roleState.query = null;
+          roleState.inputStream = null;
+
+          sendCrewMessage({
+            type: 'crew_role_cleared',
+            sessionId: session.id,
+            role: roleName,
+            contextPercentage: Math.round(contextPercentage * 100),
+            reason: 'context_limit'
+          });
+
+          // 继承 task 到路由（如有）
+          const currentTask = roleState.currentTask;
+          if (routes.length > 0) {
+            for (const route of routes) {
+              if (!route.taskId && currentTask) {
+                route.taskId = currentTask.taskId;
+                route.taskTitle = currentTask.taskTitle;
+              }
+            }
+          }
+
+          // 执行路由
+          if (routes.length > 0) {
+            session.round++;
+            const results = await Promise.allSettled(routes.map(route =>
+              executeRoute(session, roleName, route)
+            ));
+            for (const r of results) {
+              if (r.status === 'rejected') {
+                console.warn(`[Crew] Route execution failed:`, r.reason);
+              }
+            }
+          }
+          return; // query 已清空，退出
+        }
+
+        // 执行路由（无需 clear 时）
+        if (routes.length > 0) {
+          session.round++;
+
+          const currentTask = roleState.currentTask;
+          for (const route of routes) {
+            if (!route.taskId && currentTask) {
+              route.taskId = currentTask.taskId;
+              route.taskTitle = currentTask.taskTitle;
+            }
+          }
+
+          const results = await Promise.allSettled(routes.map(route =>
+            executeRoute(session, roleName, route)
+          ));
+          for (const r of results) {
+            if (r.status === 'rejected') {
+              console.warn(`[Crew] Route execution failed:`, r.reason);
+            }
+          }
+        } else {
+          const { processHumanQueue } = await import('./human-interaction.js');
+          await processHumanQueue(session);
+        }
+      }
+    }
+  } catch (error) {
+    if (error.name === 'AbortError') {
+      console.log(`[Crew] ${roleName} aborted`);
+      if (session.status === 'paused' && roleState.accumulatedText) {
+        const routes = parseRoutes(roleState.accumulatedText);
+        if (routes.length > 0 && session.pendingRoutes.length === 0) {
+          session.pendingRoutes = routes.map(route => ({ fromRole: roleName, route }));
+          console.log(`[Crew] Saved ${routes.length} pending route(s) from aborted ${roleName}`);
+        }
+        roleState.accumulatedText = '';
+      }
+    } else {
+      console.error(`[Crew] ${roleName} error:`, error.message);
+
+      // Step 1: 清理 roleState
+      endRoleStreaming(session, roleName);
+      const errorTurnText = roleState.accumulatedText;
+      roleState.query = null;
+      roleState.inputStream = null;
+      roleState.turnActive = false;
+      roleState.accumulatedText = '';
+
+      // Step 2: 错误分类
+      const classification = classifyRoleError(error);
+      roleState.consecutiveErrors++;
+
+      // Step 3: 通知前端
+      sendCrewMessage({
+        type: 'crew_role_error',
+        sessionId: session.id,
+        role: roleName,
+        error: error.message.substring(0, 500),
+        reason: classification.reason,
+        recoverable: classification.recoverable,
+        retryCount: roleState.consecutiveErrors
+      });
+      sendStatusUpdate(session);
+
+      // Step 4: 判断是否重试
+      const MAX_RETRIES = 3;
+      if (!classification.recoverable || roleState.consecutiveErrors > MAX_RETRIES) {
+        const exhausted = roleState.consecutiveErrors > MAX_RETRIES;
+        const errDetail = exhausted
+          ? `角色 ${roleName} 连续 ${MAX_RETRIES} 次错误后停止重试。最后错误: ${error.message}`
+          : `角色 ${roleName} 不可恢复错误: ${error.message}`;
+        if (roleName !== session.decisionMaker) {
+          await dispatchToRole(session, session.decisionMaker, errDetail, 'system');
+        } else {
+          session.status = 'waiting_human';
+          sendCrewMessage({
+            type: 'crew_human_needed',
+            sessionId: session.id,
+            fromRole: roleName,
+            reason: 'error',
+            message: errDetail
+          });
+          sendStatusUpdate(session);
+        }
+        return;
+      }
+
+      // Step 5: 可恢复 → 保存摘要后 clear + 重建重试
+      console.log(`[Crew] ${roleName} attempting recovery (${classification.reason}), retry ${roleState.consecutiveErrors}/${MAX_RETRIES}`);
+
+      sendCrewOutput(session, 'system', 'system', {
+        type: 'assistant',
+        message: { role: 'assistant', content: [{
+          type: 'text',
+          text: `${roleName} 遇到 ${classification.reason}，正在自动恢复 (${roleState.consecutiveErrors}/${MAX_RETRIES})...`
+        }] }
+      });
+
+      if (roleState.lastDispatchContent) {
+        // 保存工作摘要
+        await saveRoleWorkSummary(session, roleName, errorTurnText).catch(e =>
+          console.warn(`[Crew] Failed to save work summary for ${roleName}:`, e.message));
+
+        // 所有可恢复错误统一 clear + rebuild
+        await clearRoleSessionId(session.sharedDir, roleName);
+        const consecutiveErrors = roleState.consecutiveErrors;
+        await dispatchToRole(
+          session, roleName,
+          roleState.lastDispatchContent,
+          roleState.lastDispatchFrom || 'system',
+          roleState.lastDispatchTaskId,
+          roleState.lastDispatchTaskTitle
+        );
+        // 保持错误计数
+        const newState = session.roleStates.get(roleName);
+        if (newState) newState.consecutiveErrors = consecutiveErrors;
+      } else {
+        const msg = `角色 ${roleName} 已恢复（${classification.reason}），但无待重试消息。`;
+        if (roleName !== session.decisionMaker) {
+          await dispatchToRole(session, session.decisionMaker, msg, 'system');
+        }
+      }
+    }
+  }
+}

package/crew/role-query.js

@@ -0,0 +1,309 @@
+/**
+ * Crew — 角色 Query 管理
+ * createRoleQuery, buildRoleSystemPrompt, sessionId 持久化, 错误分类
+ */
+import { query, Stream } from '../sdk/index.js';
+import { promises as fs } from 'fs';
+import { join } from 'path';
+import { getMessages } from '../crew-i18n.js';
+
+/** Format role label */
+function roleLabel(r) {
+  return r.icon ? `${r.icon} ${r.displayName}` : r.displayName;
+}
+
+// =====================================================================
+// Session Persistence (role sessionId)
+// =====================================================================
+
+/**
+ * 保存角色的 claudeSessionId 到文件
+ */
+export async function saveRoleSessionId(sharedDir, roleName, claudeSessionId) {
+  const sessionsDir = join(sharedDir, 'sessions');
+  await fs.mkdir(sessionsDir, { recursive: true });
+  const filePath = join(sessionsDir, `${roleName}.json`);
+  await fs.writeFile(filePath, JSON.stringify({
+    claudeSessionId,
+    savedAt: Date.now()
+  }));
+  console.log(`[Crew] Saved sessionId for ${roleName}: ${claudeSessionId}`);
+}
+
+/**
+ * 从文件加载角色的 claudeSessionId
+ */
+export async function loadRoleSessionId(sharedDir, roleName) {
+  const filePath = join(sharedDir, 'sessions', `${roleName}.json`);
+  try {
+    const data = JSON.parse(await fs.readFile(filePath, 'utf-8'));
+    return data.claudeSessionId || null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * 清除角色的 savedSessionId（用于强制新建 conversation）
+ */
+export async function clearRoleSessionId(sharedDir, roleName) {
+  const filePath = join(sharedDir, 'sessions', `${roleName}.json`);
+  try {
+    await fs.unlink(filePath);
+    console.log(`[Crew] Cleared sessionId for ${roleName} (force new conversation)`);
+  } catch {
+    // 文件不存在也正常
+  }
+}
+
+/**
+ * 判断角色错误是否可恢复
+ */
+export function classifyRoleError(error) {
+  const msg = error.message || '';
+  if (/context.*(window|limit|exceeded)|token.*limit|too.*(long|large)|max.*token/i.test(msg)) {
+    return { recoverable: true, reason: 'context_exceeded' };
+  }
+  if (/compact|compress|context.*reduc/i.test(msg)) {
+    return { recoverable: true, reason: 'compact_failed' };
+  }
+  if (/rate.?limit|429|overloaded|503|502|timeout|ECONNRESET|ETIMEDOUT/i.test(msg)) {
+    return { recoverable: true, reason: 'transient_api_error' };
+  }
+  if (/exited with code [1-9]/i.test(msg) && msg.length < 100) {
+    return { recoverable: true, reason: 'process_crashed' };
+  }
+  if (/spawn|ENOENT|not found/i.test(msg)) {
+    return { recoverable: false, reason: 'spawn_failed' };
+  }
+  return { recoverable: true, reason: 'unknown' };
+}
+
+// =====================================================================
+// Role Query Management
+// =====================================================================
+
+/**
+ * 为角色创建持久 query 实例
+ */
+export async function createRoleQuery(session, roleName) {
+  const role = session.roles.get(roleName);
+  if (!role) throw new Error(`Role not found: ${roleName}`);
+
+  // Lazy import to avoid circular dependency
+  const { processRoleOutput } = await import('./role-output.js');
+
+  const inputStream = new Stream();
+  const abortController = new AbortController();
+
+  const systemPrompt = buildRoleSystemPrompt(role, session);
+
+  // 尝试加载之前保存的 sessionId
+  const savedSessionId = await loadRoleSessionId(session.sharedDir, roleName);
+
+  // cwd 设为角色目录
+  const roleCwd = join(session.sharedDir, 'roles', roleName);
+
+  const queryOptions = {
+    cwd: roleCwd,
+    permissionMode: 'bypassPermissions',
+    abort: abortController.signal,
+    model: role.model || undefined,
+    appendSystemPrompt: systemPrompt
+  };
+
+  if (savedSessionId) {
+    queryOptions.resume = savedSessionId;
+    console.log(`[Crew] Resuming ${roleName} with sessionId: ${savedSessionId}`);
+  }
+
+  const roleQuery = query({
+    prompt: inputStream,
+    options: queryOptions
+  });
+
+  const roleState = {
+    query: roleQuery,
+    inputStream,
+    abortController,
+    accumulatedText: '',
+    turnActive: false,
+    claudeSessionId: savedSessionId,
+    lastCostUsd: 0,
+    lastInputTokens: 0,
+    lastOutputTokens: 0,
+    consecutiveErrors: 0,
+    lastDispatchContent: null,
+    lastDispatchFrom: null,
+    lastDispatchTaskId: null,
+    lastDispatchTaskTitle: null
+  };
+
+  session.roleStates.set(roleName, roleState);
+
+  // 异步处理角色输出
+  processRoleOutput(session, roleName, roleQuery, roleState);
+
+  return roleState;
+}
+
+/**
+ * 构建角色的 system prompt
+ */
+export function buildRoleSystemPrompt(role, session) {
+  const allRoles = Array.from(session.roles.values());
+
+  let routeTargets;
+  if (role.groupIndex > 0) {
+    routeTargets = allRoles.filter(r =>
+      r.name !== role.name && (r.groupIndex === role.groupIndex || r.groupIndex === 0)
+    );
+  } else {
+    routeTargets = allRoles.filter(r => r.name !== role.name);
+  }
+
+  const m = getMessages(session.language || 'zh-CN');
+
+  let prompt = `${m.teamCollab}
+${m.teamCollabIntro()}
+
+${m.teamMembers}
+${allRoles.map(r => `- ${roleLabel(r)}: ${r.description}${r.isDecisionMaker ? ` (${m.decisionMakerTag})` : ''}`).join('\n')}`;
+
+  const hasMultiInstance = allRoles.some(r => r.groupIndex > 0);
+
+  if (routeTargets.length > 0) {
+    prompt += `\n\n${m.routingRules}
+${m.routingIntro}
+
+\`\`\`
+---ROUTE---
+to: <roleName>
+summary: <brief description>
+---END_ROUTE---
+\`\`\`
+
+${m.routeTargets}
+${routeTargets.map(r => `- ${r.name}: ${roleLabel(r)} — ${r.description}`).join('\n')}
+- human: ${m.humanTarget}
+
+${m.routeNotes(session.decisionMaker)}`;
+  }
+
+  // 决策者额外 prompt
+  if (role.isDecisionMaker) {
+    const isDevTeam = session.teamType === 'dev';
+
+    prompt += `\n\n${m.toolUsage}
+${m.toolUsageContent(isDevTeam)}`;
+
+    prompt += `\n\n${m.dmRole}
+${m.dmRoleContent}`;
+
+    if (isDevTeam) {
+      prompt += m.dmDevExtra;
+    }
+
+    if (!isDevTeam) {
+      prompt += `\n\n${m.collabMode}
+${m.collabModeContent}`;
+    }
+
+    if (isDevTeam && hasMultiInstance) {
+      const maxGroup = Math.max(...allRoles.map(r => r.groupIndex));
+      const groupLines = [];
+      for (let g = 1; g <= maxGroup; g++) {
+        const members = allRoles.filter(r => r.groupIndex === g);
+        const memberStrs = members.map(r => {
+          const state = session.roleStates.get(r.name);
+          const busy = state?.turnActive;
+          const task = state?.currentTask;
+          if (busy && task) return `${r.name}(${m.groupBusy(task.taskId + ' ' + task.taskTitle)})`;
+          if (busy) return `${r.name}(${m.groupBusyShort})`;
+          return `${r.name}(${m.groupIdle})`;
+        });
+        groupLines.push(`${m.groupLabel(g)}: ${memberStrs.join(' ')}`);
+      }
+
+      prompt += `\n\n${m.execGroupStatus}
+${groupLines.join(' / ')}
+
+${m.parallelRules}
+${m.parallelRulesContent(maxGroup)}
+
+\`\`\`
+---ROUTE---
+to: dev-1
+task: task-1
+taskTitle: ${m.implLoginPage}
+summary: ${m.implLoginSummary}
+---END_ROUTE---
+
+---ROUTE---
+to: dev-2
+task: task-2
+taskTitle: ${m.implRegisterPage}
+summary: ${m.implRegisterSummary}
+---END_ROUTE---
+\`\`\`
+
+${m.parallelExample}`;
+    }
+
+    prompt += `\n
+${m.workflowEnd}
+${m.workflowEndContent(isDevTeam)}
+
+${m.taskList}
+${m.taskListContent}
+
+\`\`\`
+${m.taskExample}
+\`\`\`
+
+${m.taskListNotes}`;
+  }
+
+  // Feature 进度文件说明
+  prompt += `\n\n${m.featureRecordTitle}
+${m.featureRecordContent}
+
+${m.contextRestartTitle}
+${m.contextRestartContent}`;
+
+  // 执行者角色的组绑定 prompt
+  if (role.groupIndex > 0 && role.roleType === 'developer') {
+    const gi = role.groupIndex;
+    const rev = allRoles.find(r => r.roleType === 'reviewer' && r.groupIndex === gi);
+    const test = allRoles.find(r => r.roleType === 'tester' && r.groupIndex === gi);
+    if (rev && test) {
+      prompt += `\n\n${m.devGroupBinding}
+${m.devGroupBindingContent(gi, roleLabel(rev), rev.name, roleLabel(test), test.name)}
+
+\`\`\`
+---ROUTE---
+to: ${rev.name}
+summary: ${m.reviewCode}
+---END_ROUTE---
+
+---ROUTE---
+to: ${test.name}
+summary: ${m.testFeature}
+---END_ROUTE---
+\`\`\`
+
+${m.devGroupBindingNote}`;
+    }
+  }
+
+  // Language instruction
+  if (session.language === 'en') {
+    prompt += `\n\n# Language
+Always respond in English. Use English for all explanations, comments, and communications with the user. Technical terms and code identifiers should remain in their original form.`;
+  } else {
+    prompt += `\n\n# Language
+Always respond in 中文. Use 中文 for all explanations, comments, and communications with the user. Technical terms and code identifiers should remain in their original form.`;
+  }
+
+  return prompt;
+}