793 lines
25 KiB
TypeScript
793 lines
25 KiB
TypeScript
import { ref } from 'vue'
|
||
import { defineStore } from 'pinia'
|
||
import { v4 as uuidv4 } from 'uuid'
|
||
import { store } from '../index'
|
||
import type { IRawStepTask, IApiStepTask } from './agents'
|
||
import type { Node, Edge } from '@vue-flow/core'
|
||
import { useAgentsStoreHook } from './agents'
|
||
|
||
/**
|
||
* 分支数据接口
|
||
* @description 用于存储流程图中的分支节点和边数据
|
||
*/
|
||
export interface IBranchData {
|
||
/** 分支唯一 ID */
|
||
id: string
|
||
/** 父节点 ID（根节点或任务节点） */
|
||
parentNodeId: string
|
||
/** 分支需求内容 */
|
||
branchContent: string
|
||
/** 分支类型 */
|
||
branchType: 'root' | 'task'
|
||
/** 分支包含的所有节点 */
|
||
nodes: Node[]
|
||
/** 分支包含的所有边 */
|
||
edges: Edge[]
|
||
/** 分支的任务数据 */
|
||
tasks: IRawStepTask[]
|
||
/** 创建时间 */
|
||
createdAt: number
|
||
}
|
||
|
||
export const useSelectionStore = defineStore('selection', () => {
|
||
// ==================== 任务大纲探索分支数据存储 ====================
|
||
|
||
/** 流程图分支列表 */
|
||
const flowBranches = ref<IBranchData[]>([])
|
||
|
||
/**
|
||
* 添加流程图分支
|
||
* @param data 分支数据
|
||
* @returns 分支 ID
|
||
*/
|
||
function addFlowBranch(data: {
|
||
parentNodeId: string
|
||
branchContent: string
|
||
branchType: 'root' | 'task'
|
||
nodes: Node[]
|
||
edges: Edge[]
|
||
tasks: IRawStepTask[]
|
||
}): string {
|
||
const branchId = `flow-branch-${uuidv4()}`
|
||
const newBranch: IBranchData = {
|
||
id: branchId,
|
||
parentNodeId: data.parentNodeId,
|
||
branchContent: data.branchContent,
|
||
branchType: data.branchType,
|
||
nodes: data.nodes,
|
||
edges: data.edges,
|
||
tasks: data.tasks,
|
||
createdAt: Date.now(),
|
||
}
|
||
flowBranches.value.push(newBranch)
|
||
return branchId
|
||
}
|
||
|
||
/**
|
||
* 获取所有流程图分支
|
||
* @returns 所有流程图分支数据
|
||
*/
|
||
function getAllFlowBranches(): IBranchData[] {
|
||
return flowBranches.value
|
||
}
|
||
|
||
/**
|
||
* 根据父节点 ID 获取流程图分支
|
||
* @param parentNodeId 父节点 ID
|
||
* @returns 匹配的流程图分支列表
|
||
*/
|
||
function getFlowBranchesByParent(parentNodeId: string): IBranchData[] {
|
||
return flowBranches.value.filter((branch) => branch.parentNodeId === parentNodeId)
|
||
}
|
||
|
||
/**
|
||
* 删除流程图分支
|
||
* @param branchId 分支 ID
|
||
* @returns 是否删除成功
|
||
*/
|
||
function removeFlowBranch(branchId: string): boolean {
|
||
const index = flowBranches.value.findIndex((branch) => branch.id === branchId)
|
||
if (index > -1) {
|
||
flowBranches.value.splice(index, 1)
|
||
return true
|
||
}
|
||
return false
|
||
}
|
||
|
||
/** 清除所有流程图分支 */
|
||
function clearFlowBranches() {
|
||
flowBranches.value = []
|
||
}
|
||
|
||
/**
|
||
* 根据父节点 ID 清除流程图分支
|
||
* @param parentNodeId 父节点 ID
|
||
*/
|
||
function clearFlowBranchesByParent(parentNodeId: string) {
|
||
flowBranches.value = flowBranches.value.filter((branch) => branch.parentNodeId !== parentNodeId)
|
||
}
|
||
|
||
// ==================== 任务过程探索分支数据存储 ====================
|
||
/**
|
||
* 任务过程分支数据映射
|
||
* @description 存储结构: Map<taskStepId, Map<agentGroupKey, IBranchData[]>>
|
||
* - taskStepId: 任务步骤 ID
|
||
* - agentGroupKey: agent 组合的唯一标识（排序后的 JSON 字符串）
|
||
* - IBranchData[]: 该 agent 组合在该任务下的所有分支数据
|
||
*/
|
||
const taskProcessBranchesMap = ref<Map<string, Map<string, IBranchData[]>>>(new Map())
|
||
|
||
/**
|
||
* 添加任务过程分支
|
||
* @param taskStepId 任务步骤 ID
|
||
* @param agents Agent 列表
|
||
* @param data 分支数据
|
||
* @returns 分支 ID
|
||
*/
|
||
function addTaskProcessBranch(
|
||
taskStepId: string,
|
||
agents: string[],
|
||
data: {
|
||
parentNodeId: string
|
||
branchContent: string
|
||
branchType: 'root' | 'task'
|
||
nodes: Node[]
|
||
edges: Edge[]
|
||
tasks: IRawStepTask[]
|
||
id?: string // 允许传入自定义 id
|
||
},
|
||
): string {
|
||
const branchId = data.id || `task-process-branch-${uuidv4()}`
|
||
console.log('[store.addTaskProcessBranch] 生成的 branchId:', branchId, '传入的 id:', data.id)
|
||
const agentGroupKey = getAgentGroupKey(agents)
|
||
|
||
const newBranch: IBranchData = {
|
||
id: branchId,
|
||
parentNodeId: data.parentNodeId,
|
||
branchContent: data.branchContent,
|
||
branchType: data.branchType,
|
||
nodes: data.nodes,
|
||
edges: data.edges,
|
||
tasks: data.tasks,
|
||
createdAt: Date.now(),
|
||
}
|
||
|
||
// 获取或创建该任务步骤的 Map
|
||
if (!taskProcessBranchesMap.value.has(taskStepId)) {
|
||
taskProcessBranchesMap.value.set(taskStepId, new Map())
|
||
}
|
||
|
||
// 获取或创建该 agent 组合的分支列表
|
||
const agentMap = taskProcessBranchesMap.value.get(taskStepId)!
|
||
if (!agentMap.has(agentGroupKey)) {
|
||
agentMap.set(agentGroupKey, [])
|
||
}
|
||
agentMap.get(agentGroupKey)!.push(newBranch)
|
||
|
||
return branchId
|
||
}
|
||
|
||
/**
|
||
* 获取指定任务步骤和 agent 组合的所有分支
|
||
* @param taskStepId 任务步骤 ID
|
||
* @param agents Agent 列表
|
||
* @returns 匹配的任务过程分支列表
|
||
*/
|
||
function getTaskProcessBranches(taskStepId: string, agents: string[]): IBranchData[] {
|
||
const agentGroupKey = getAgentGroupKey(agents)
|
||
return taskProcessBranchesMap.value.get(taskStepId)?.get(agentGroupKey) || []
|
||
}
|
||
|
||
/**
|
||
* 获取所有任务过程分支
|
||
* @returns 所有任务过程分支数据映射
|
||
*/
|
||
function getAllTaskProcessBranches(): Map<string, Map<string, IBranchData[]>> {
|
||
return taskProcessBranchesMap.value
|
||
}
|
||
|
||
/**
|
||
* 根据父节点 ID 获取任务过程分支
|
||
* @param taskStepId 任务步骤 ID
|
||
* @param agents Agent 列表
|
||
* @param parentNodeId 父节点 ID
|
||
* @returns 匹配的任务过程分支列表
|
||
*/
|
||
function getTaskProcessBranchesByParent(
|
||
taskStepId: string,
|
||
agents: string[],
|
||
parentNodeId: string,
|
||
): IBranchData[] {
|
||
const agentGroupKey = getAgentGroupKey(agents)
|
||
const branches = taskProcessBranchesMap.value.get(taskStepId)?.get(agentGroupKey) || []
|
||
return branches.filter((branch) => branch.parentNodeId === parentNodeId)
|
||
}
|
||
|
||
/**
|
||
* 删除任务过程分支
|
||
* @param taskStepId 任务步骤 ID
|
||
* @param agents Agent 列表
|
||
* @param branchId 分支 ID
|
||
* @returns 是否删除成功
|
||
*/
|
||
function removeTaskProcessBranch(
|
||
taskStepId: string,
|
||
agents: string[],
|
||
branchId: string,
|
||
): boolean {
|
||
const agentGroupKey = getAgentGroupKey(agents)
|
||
const branches = taskProcessBranchesMap.value.get(taskStepId)?.get(agentGroupKey)
|
||
if (branches) {
|
||
const index = branches.findIndex((branch) => branch.id === branchId)
|
||
if (index > -1) {
|
||
branches.splice(index, 1)
|
||
return true
|
||
}
|
||
}
|
||
return false
|
||
}
|
||
|
||
/**
|
||
* 精准删除分支中的单个节点
|
||
* @param taskStepId 任务步骤 ID
|
||
* @param agents Agent 列表
|
||
* @param branchId 分支 ID
|
||
* @param nodeId 要删除的节点 ID
|
||
* @param incomingEdges 入边（用于更新 edges）
|
||
* @param outgoingEdges 出边（用于更新 edges）
|
||
* @param newEdges 新创建的边（用于重新连接）
|
||
* @returns 是否删除成功
|
||
*/
|
||
function removeNodeFromBranch(
|
||
taskStepId: string,
|
||
agents: string[],
|
||
branchId: string,
|
||
nodeId: string,
|
||
incomingEdges: any[] = [],
|
||
outgoingEdges: any[] = [],
|
||
newEdges: any[] = [],
|
||
): boolean {
|
||
const agentGroupKey = getAgentGroupKey(agents)
|
||
const branches = taskProcessBranchesMap.value.get(taskStepId)?.get(agentGroupKey)
|
||
if (!branches) return false
|
||
|
||
const branchIndex = branches.findIndex((branch) => branch.id === branchId)
|
||
if (branchIndex === -1) return false
|
||
|
||
const branch = branches[branchIndex]
|
||
if (!branch || !branch.nodes || !branch.tasks) return false
|
||
|
||
// 找到节点在分支中的索引
|
||
const nodeIndex = branch.nodes.findIndex((n: any) => n.id === nodeId)
|
||
if (nodeIndex === -1) return false
|
||
|
||
// 精准删除：只删除对应索引的节点和任务
|
||
branch.nodes.splice(nodeIndex, 1)
|
||
branch.tasks.splice(nodeIndex, 1)
|
||
|
||
// 更新 edges：移除相关边，添加新边
|
||
if (incomingEdges.length > 0 || outgoingEdges.length > 0) {
|
||
const relatedEdgeIds = [
|
||
...incomingEdges.map((e: any) => e.id),
|
||
...outgoingEdges.map((e: any) => e.id),
|
||
]
|
||
// 过滤掉相关的旧边
|
||
branch.edges = (branch.edges || []).filter((e: any) => !relatedEdgeIds.includes(e.id))
|
||
// 添加新边
|
||
if (newEdges.length > 0) {
|
||
branch.edges.push(...newEdges)
|
||
}
|
||
}
|
||
|
||
return true
|
||
}
|
||
|
||
/**
|
||
* 清除指定任务步骤和 agent 组合的所有分支
|
||
* @param taskStepId 任务步骤 ID
|
||
* @param agents Agent 列表（可选，不传则清除该任务步骤的所有分支）
|
||
*/
|
||
function clearTaskProcessBranches(taskStepId: string, agents?: string[]) {
|
||
if (agents) {
|
||
// 清除指定 agent 组合的分支
|
||
const agentGroupKey = getAgentGroupKey(agents)
|
||
const agentMap = taskProcessBranchesMap.value.get(taskStepId)
|
||
if (agentMap) {
|
||
agentMap.delete(agentGroupKey)
|
||
}
|
||
} else {
|
||
// 清除该任务步骤的所有分支（所有 agent 组合）
|
||
taskProcessBranchesMap.value.delete(taskStepId)
|
||
}
|
||
}
|
||
|
||
// ==================== 数据库持久化方法 ====================
|
||
|
||
/**
|
||
* 从数据库恢复分支数据
|
||
* @param dbBranches 从数据库读取的分支数据数组
|
||
*/
|
||
function restoreBranchesFromDB(dbBranches: IBranchData[]) {
|
||
// 清除现有分支
|
||
clearFlowBranches()
|
||
|
||
// 恢复分支数据到 store
|
||
dbBranches.forEach((branch) => {
|
||
if (branch && branch.id && branch.tasks) {
|
||
addFlowBranch({
|
||
parentNodeId: branch.parentNodeId,
|
||
branchContent: branch.branchContent,
|
||
branchType: branch.branchType,
|
||
nodes: branch.nodes || [],
|
||
edges: branch.edges || [],
|
||
tasks: branch.tasks,
|
||
})
|
||
}
|
||
})
|
||
}
|
||
|
||
/**
|
||
* 保存分支数据到数据库
|
||
* @param taskId 任务ID
|
||
* @returns Promise<boolean> 是否保存成功
|
||
*/
|
||
async function saveBranchesToDB(taskId: string): Promise<boolean> {
|
||
// 导入 api（避免循环导入问题）
|
||
const { default: api } = await import('@/api')
|
||
|
||
const branches = getAllFlowBranches()
|
||
const result = await api.saveBranches(taskId, branches)
|
||
|
||
return result
|
||
}
|
||
|
||
/**
|
||
* 保存任务过程分支数据到数据库
|
||
* @param TaskID 大任务ID（数据库主键）
|
||
* @returns Promise<boolean> 是否保存成功
|
||
* @description 存储结构: Map<taskStepId, Map<agentGroupKey, IBranchData[]>>
|
||
*/
|
||
async function saveTaskProcessBranchesToDB(TaskID: string): Promise<boolean> {
|
||
// 导入 api（避免循环导入问题）
|
||
const { default: api } = await import('@/api')
|
||
|
||
// 将 Map 转换为普通对象，便于序列化
|
||
const branchesMap = getAllTaskProcessBranches()
|
||
const branchesObj: Record<string, Record<string, any[]>> = {}
|
||
|
||
for (const [taskStepId, agentMap] of branchesMap.entries()) {
|
||
branchesObj[taskStepId] = {}
|
||
for (const [agentGroupKey, branches] of agentMap.entries()) {
|
||
branchesObj[taskStepId][agentGroupKey] = branches
|
||
}
|
||
}
|
||
|
||
const result = await api.saveTaskProcessBranches(TaskID, branchesObj)
|
||
|
||
return result
|
||
}
|
||
|
||
/**
|
||
* 从数据库删除指定分支
|
||
* @param TaskID 大任务ID（数据库主键）
|
||
* @param stepId 小任务ID
|
||
* @param branchId 要删除的分支ID
|
||
* @returns Promise<boolean> 是否删除成功
|
||
*/
|
||
async function deleteTaskProcessBranchFromDB(
|
||
TaskID: string,
|
||
stepId: string,
|
||
branchId: string,
|
||
): Promise<boolean> {
|
||
// 导入 api（避免循环导入问题）
|
||
const { default: api } = await import('@/api')
|
||
|
||
const result = await api.deleteTaskProcessBranch(TaskID, stepId, branchId)
|
||
|
||
return result
|
||
}
|
||
|
||
/**
|
||
* 从数据库删除指定节点
|
||
* @param TaskID 大任务ID（数据库主键）
|
||
* @param stepId 小任务ID
|
||
* @param branchId 分支ID
|
||
* @param nodeId 要删除的节点ID
|
||
* @returns Promise<boolean> 是否删除成功
|
||
*/
|
||
async function deleteTaskProcessNodeFromDB(
|
||
TaskID: string,
|
||
stepId: string,
|
||
branchId: string,
|
||
nodeId: string,
|
||
edges: any[] = [],
|
||
): Promise<boolean> {
|
||
// 导入 api（避免循环导入问题）
|
||
const { default: api } = await import('@/api')
|
||
|
||
const result = await api.deleteTaskProcessNode(TaskID, stepId, branchId, nodeId, edges)
|
||
|
||
return result
|
||
}
|
||
|
||
/**
|
||
* 从数据库恢复任务过程分支数据
|
||
* @param dbBranches 从数据库读取的任务过程分支数据
|
||
* @param TaskID 大任务ID（用于获取全局 __CURRENT_TASK_ID__）
|
||
* @description 数据格式: { stepId（小任务UUID）: { agentGroupKey: [IBranchData...] } }
|
||
*/
|
||
function restoreTaskProcessBranchesFromDB(dbBranches: Record<string, Record<string, any[]>>) {
|
||
// 清除现有数据
|
||
taskProcessBranchesMap.value.clear()
|
||
|
||
if (!dbBranches) {
|
||
return
|
||
}
|
||
|
||
// 恢复数据
|
||
for (const [taskStepId, agentMap] of Object.entries(dbBranches)) {
|
||
if (typeof agentMap !== 'object' || agentMap === null) {
|
||
continue
|
||
}
|
||
|
||
// 获取或创建该步骤的 Map
|
||
if (!taskProcessBranchesMap.value.has(taskStepId)) {
|
||
taskProcessBranchesMap.value.set(taskStepId, new Map())
|
||
}
|
||
const stepMap = taskProcessBranchesMap.value.get(taskStepId)!
|
||
|
||
// 恢复 agent combinations
|
||
for (const [agentGroupKey, branches] of Object.entries(agentMap)) {
|
||
if (Array.isArray(branches)) {
|
||
stepMap.set(agentGroupKey, branches)
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
// ==================== Agent 组合 TaskProcess 数据存储 ====================
|
||
/**
|
||
* Agent 组合 TaskProcess 数据映射
|
||
* @description 用于存储 fill_stepTask_TaskProcess 接口返回的数据
|
||
* 存储结构: Map<taskId, Map<agentGroupKey, IApiStepTask>>
|
||
* - taskId: 任务 ID
|
||
* - agentGroupKey: agent 组合的唯一标识（排序后的 JSON 字符串）
|
||
* - IApiStepTask: 该 agent 组合的完整 TaskProcess 数据
|
||
*/
|
||
const agentTaskProcessMap = ref<Map<string, Map<string, IApiStepTask>>>(new Map())
|
||
|
||
/**
|
||
* 生成 agent 组合的唯一 key
|
||
* @description 排序后保证一致性
|
||
* @param agents Agent 列表
|
||
* @returns Agent 组合的唯一标识
|
||
*/
|
||
function getAgentGroupKey(agents: string[]): string {
|
||
// 处理 undefined 或 null 的情况
|
||
if (!agents || !Array.isArray(agents)) {
|
||
return JSON.stringify([])
|
||
}
|
||
return JSON.stringify([...agents].sort())
|
||
}
|
||
|
||
/**
|
||
* 存储 agent 组合的 TaskProcess 数据
|
||
* @param stepId 步骤 ID（小任务 UUID，用于作为 agentTaskProcessMap 的第一层主键）
|
||
* @param agents Agent 列表
|
||
* @param taskProcess TaskProcess 数据（支持完整格式或简化格式）
|
||
* @description 存储结构: Map<stepId, Map<agentGroupKey, { process, brief }>>
|
||
* agentTaskProcessMap = { stepId: { agentGroupKey: { process, brief } } }
|
||
* 注意：简化格式 { process, brief } 与后端数据库格式一致
|
||
*/
|
||
function setAgentTaskProcess(
|
||
stepId: string,
|
||
agents: string[],
|
||
taskProcess: IApiStepTask | { process: any; brief: any },
|
||
) {
|
||
const groupKey = getAgentGroupKey(agents)
|
||
|
||
// 获取或创建该步骤的 Map
|
||
if (!agentTaskProcessMap.value.has(stepId)) {
|
||
agentTaskProcessMap.value.set(stepId, new Map())
|
||
}
|
||
const stepMap = agentTaskProcessMap.value.get(stepId)!
|
||
|
||
// 统一转换为简化格式 { process, brief }，与后端期望格式一致
|
||
const simplifiedData = {
|
||
process: (taskProcess as IApiStepTask).process || taskProcess.process || [],
|
||
brief: (taskProcess as IApiStepTask).brief || taskProcess.brief || {},
|
||
}
|
||
|
||
// 存储该 agent 组合的 TaskProcess 数据
|
||
stepMap.set(groupKey, simplifiedData)
|
||
}
|
||
|
||
/**
|
||
* 获取 agent 组合的 TaskProcess 数据
|
||
* @param taskId 任务 ID
|
||
* @param agents Agent 列表
|
||
* @returns TaskProcess 数据
|
||
*/
|
||
function getAgentTaskProcess(taskId: string, agents: string[]): IApiStepTask | undefined {
|
||
const groupKey = getAgentGroupKey(agents)
|
||
return agentTaskProcessMap.value.get(taskId)?.get(groupKey)
|
||
}
|
||
|
||
/**
|
||
* 检查 agent 组合是否已有 TaskProcess 数据
|
||
* @param taskId 任务 ID
|
||
* @param agents Agent 列表
|
||
* @returns 是否存在数据
|
||
*/
|
||
function hasAgentTaskProcess(taskId: string, agents: string[]): boolean {
|
||
const groupKey = getAgentGroupKey(agents)
|
||
return agentTaskProcessMap.value.get(taskId)?.has(groupKey) || false
|
||
}
|
||
|
||
/**
|
||
* 删除指定任务的某个 agent 组合的 TaskProcess 数据
|
||
* @param taskId 任务 ID
|
||
* @param agents Agent 列表
|
||
*/
|
||
function removeAgentTaskProcess(taskId: string, agents: string[]) {
|
||
const groupKey = getAgentGroupKey(agents)
|
||
agentTaskProcessMap.value.get(taskId)?.delete(groupKey)
|
||
}
|
||
|
||
/**
|
||
* 清除指定任务的所有 agent 组合 TaskProcess 数据
|
||
* @param taskId 任务 ID
|
||
*/
|
||
function clearAgentTaskProcess(taskId: string) {
|
||
agentTaskProcessMap.value.delete(taskId)
|
||
}
|
||
|
||
/** 清除所有任务的 agent 组合 TaskProcess 数据 */
|
||
function clearAllAgentTaskProcess() {
|
||
agentTaskProcessMap.value.clear()
|
||
}
|
||
|
||
/**
|
||
* 获取指定步骤的所有 agent 组合的 TaskProcess 数据
|
||
* @param stepId 步骤 ID（小任务 UUID）
|
||
* @returns agent_combinations 对象格式 { "[\"AgentA\",\"AgentB\"]": { process, brief }, ... }
|
||
* @description 存储结构: Map<stepId, Map<agentGroupKey, { process, brief }>>
|
||
* 注意：简化设计后，第一层 key 就是 stepId
|
||
*/
|
||
function getAgentCombinations(
|
||
stepId: string,
|
||
): Record<string, { process: any; brief: any }> | undefined {
|
||
// 直接使用 stepId 作为第一层 key
|
||
const stepMap = agentTaskProcessMap.value.get(stepId)
|
||
if (!stepMap) {
|
||
return undefined
|
||
}
|
||
|
||
// 将 Map 转换为普通对象
|
||
const result: Record<string, { process: any; brief: any }> = {}
|
||
for (const [key, value] of stepMap.entries()) {
|
||
result[key] = value
|
||
}
|
||
return result
|
||
}
|
||
|
||
// ==================== 数据库持久化恢复方法 ====================
|
||
|
||
/**
|
||
* 从数据库 assigned_agents 字段恢复 agent 组合数据
|
||
* @param assignedAgents 从数据库读取的 assigned_agents 数据
|
||
* @param taskId 大任务 ID（此参数已不再使用，因为简化后直接用 stepId 作为 key）
|
||
* @description 数据格式: { step_id（小任务UUID）: { current: [...], confirmed_groups: [...], agent_combinations: {...} } }
|
||
* 存储结构: Map<stepId, Map<agentGroupKey, IApiStepTask>>
|
||
* agentTaskProcessMap = { stepId: { agentGroupKey: data } }
|
||
*/
|
||
function restoreAgentCombinationsFromDB(assignedAgents: Record<string, any>, taskId: string) {
|
||
// 获取 agents store 实例
|
||
const agentsStore = useAgentsStoreHook()
|
||
|
||
// 清除现有数据
|
||
clearAllAgentTaskProcess()
|
||
agentsStore.clearAllConfirmedAgentGroups()
|
||
|
||
if (!assignedAgents) {
|
||
return
|
||
}
|
||
|
||
// 🆕 简化版本：直接使用 stepId 作为第一层 key
|
||
// 遍历每个步骤的数据
|
||
for (const [stepId, stepData] of Object.entries(assignedAgents)) {
|
||
if (typeof stepData !== 'object' || stepData === null) {
|
||
continue
|
||
}
|
||
|
||
// 获取或创建该步骤的 Map
|
||
if (!agentTaskProcessMap.value.has(stepId)) {
|
||
agentTaskProcessMap.value.set(stepId, new Map<string, IApiStepTask>())
|
||
}
|
||
const stepMap = agentTaskProcessMap.value.get(stepId)!
|
||
|
||
// 恢复 agent_combinations 到 stepMap
|
||
// 格式: { agentGroupKey: { process, brief } }
|
||
if (stepData.agent_combinations) {
|
||
for (const [agentGroupKey, combinationData] of Object.entries(
|
||
stepData.agent_combinations,
|
||
)) {
|
||
stepMap.set(agentGroupKey, combinationData as IApiStepTask)
|
||
}
|
||
}
|
||
|
||
// 恢复 confirmed_groups
|
||
if (stepData.confirmed_groups) {
|
||
agentsStore.setConfirmedAgentGroups(stepId, stepData.confirmed_groups)
|
||
}
|
||
|
||
// 恢复 current（当前选中的 agent 组合）
|
||
if (stepData.current) {
|
||
agentsStore.setSelectedAgentGroup(stepId, stepData.current)
|
||
|
||
// 同步更新 agentRawPlan 中对应步骤的 AgentSelection
|
||
const planData = agentsStore.agentRawPlan.data
|
||
if (planData && planData['Collaboration Process']) {
|
||
const process = planData['Collaboration Process']
|
||
const step = process.find((s: any) => s.Id === stepId)
|
||
if (step) {
|
||
step.AgentSelection = stepData.current
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
// ==================== 当前生效的任务过程分支 ====================
|
||
/**
|
||
* 当前生效的任务过程分支映射
|
||
* @description 记录每个任务步骤和 agent 组合当前生效的分支 ID（持久化选中状态）
|
||
* 存储结构: Map<taskStepId, Map<agentGroupKey, branchId>>
|
||
* - taskStepId: 任务步骤 ID
|
||
* - agentGroupKey: agent 组合的唯一标识
|
||
* - branchId: 当前选中的分支 ID
|
||
*/
|
||
const activeTaskProcessBranchMap = ref<Map<string, Map<string, string>>>(new Map())
|
||
|
||
/**
|
||
* 当前生效的 TaskProcess 数据映射
|
||
* @description 用于外部组件显示职责分配
|
||
* 存储结构: Map<taskStepId, Map<agentGroupKey, TaskProcess[]>>
|
||
*/
|
||
const activeTaskProcessDataMap = ref<Map<string, Map<string, any[]>>>(new Map())
|
||
|
||
/**
|
||
* 设置当前生效的分支
|
||
* @param taskStepId 任务步骤 ID
|
||
* @param agents Agent 列表
|
||
* @param branchId 分支 ID
|
||
*/
|
||
function setActiveTaskProcessBranch(taskStepId: string, agents: string[], branchId: string) {
|
||
const agentGroupKey = getAgentGroupKey(agents)
|
||
|
||
// 获取或创建该任务步骤的 Map
|
||
if (!activeTaskProcessBranchMap.value.has(taskStepId)) {
|
||
activeTaskProcessBranchMap.value.set(taskStepId, new Map())
|
||
}
|
||
|
||
activeTaskProcessBranchMap.value.get(taskStepId)!.set(agentGroupKey, branchId)
|
||
}
|
||
|
||
/**
|
||
* 设置当前生效的 TaskProcess 数据
|
||
* @param taskStepId 任务步骤 ID
|
||
* @param agents Agent 列表
|
||
* @param taskProcess TaskProcess 数据
|
||
*/
|
||
function setActiveTaskProcessData(taskStepId: string, agents: string[], taskProcess: any[]) {
|
||
const agentGroupKey = getAgentGroupKey(agents)
|
||
|
||
// 获取或创建该任务步骤的 Map
|
||
if (!activeTaskProcessDataMap.value.has(taskStepId)) {
|
||
activeTaskProcessDataMap.value.set(taskStepId, new Map())
|
||
}
|
||
|
||
activeTaskProcessDataMap.value.get(taskStepId)!.set(agentGroupKey, taskProcess)
|
||
}
|
||
|
||
/**
|
||
* 获取当前生效的分支 ID
|
||
* @param taskStepId 任务步骤 ID
|
||
* @param agents Agent 列表
|
||
* @returns 分支 ID
|
||
*/
|
||
function getActiveTaskProcessBranch(taskStepId: string, agents: string[]): string | undefined {
|
||
const agentGroupKey = getAgentGroupKey(agents)
|
||
return activeTaskProcessBranchMap.value.get(taskStepId)?.get(agentGroupKey)
|
||
}
|
||
|
||
/**
|
||
* 获取当前生效的 TaskProcess 数据
|
||
* @param taskStepId 任务步骤 ID
|
||
* @param agents Agent 列表
|
||
* @returns TaskProcess 数据
|
||
*/
|
||
function getActiveTaskProcessData(taskStepId: string, agents: string[]): any[] | undefined {
|
||
const agentGroupKey = getAgentGroupKey(agents)
|
||
return activeTaskProcessDataMap.value.get(taskStepId)?.get(agentGroupKey)
|
||
}
|
||
|
||
/**
|
||
* 清除生效分支
|
||
* @param taskStepId 任务步骤 ID
|
||
* @param agents Agent 列表（可选，不传则清除该任务步骤的所有生效分支）
|
||
*/
|
||
function clearActiveTaskProcessBranch(taskStepId: string, agents?: string[]) {
|
||
if (agents) {
|
||
// 清除指定 agent 组合的生效分支
|
||
const agentGroupKey = getAgentGroupKey(agents)
|
||
activeTaskProcessBranchMap.value.get(taskStepId)?.delete(agentGroupKey)
|
||
activeTaskProcessDataMap.value.get(taskStepId)?.delete(agentGroupKey)
|
||
} else {
|
||
// 清除该任务步骤的所有生效分支（所有 agent 组合）
|
||
activeTaskProcessBranchMap.value.delete(taskStepId)
|
||
activeTaskProcessDataMap.value.delete(taskStepId)
|
||
}
|
||
}
|
||
|
||
return {
|
||
// ==================== 状态 ====================
|
||
flowBranches,
|
||
taskProcessBranchesMap,
|
||
agentTaskProcessMap,
|
||
activeTaskProcessBranchMap,
|
||
activeTaskProcessDataMap,
|
||
|
||
// ==================== 任务大纲分支管理方法 ====================
|
||
addFlowBranch,
|
||
getAllFlowBranches,
|
||
getFlowBranchesByParent,
|
||
removeFlowBranch,
|
||
clearFlowBranches,
|
||
clearFlowBranchesByParent,
|
||
|
||
// ==================== 任务过程分支管理方法 ====================
|
||
addTaskProcessBranch,
|
||
getTaskProcessBranches,
|
||
getAllTaskProcessBranches,
|
||
getTaskProcessBranchesByParent,
|
||
removeTaskProcessBranch,
|
||
removeNodeFromBranch,
|
||
clearTaskProcessBranches,
|
||
|
||
// ==================== 任务过程分支生效状态管理方法 ====================
|
||
setActiveTaskProcessBranch,
|
||
setActiveTaskProcessData,
|
||
getActiveTaskProcessBranch,
|
||
getActiveTaskProcessData,
|
||
clearActiveTaskProcessBranch,
|
||
|
||
// ==================== Agent 组合 TaskProcess 数据管理方法 ====================
|
||
getAgentGroupKey,
|
||
setAgentTaskProcess,
|
||
getAgentTaskProcess,
|
||
hasAgentTaskProcess,
|
||
removeAgentTaskProcess,
|
||
clearAgentTaskProcess,
|
||
getAgentCombinations,
|
||
clearAllAgentTaskProcess,
|
||
|
||
// ==================== 数据库持久化方法 ====================
|
||
restoreBranchesFromDB,
|
||
saveBranchesToDB,
|
||
restoreAgentCombinationsFromDB,
|
||
saveTaskProcessBranchesToDB,
|
||
deleteTaskProcessBranchFromDB,
|
||
deleteTaskProcessNodeFromDB,
|
||
restoreTaskProcessBranchesFromDB,
|
||
}
|
||
})
|
||
|
||
/**
|
||
* 用于在组件外部使用 Selection Store
|
||
* @returns Selection Store 实例
|
||
*/
|
||
export function useSelectionStoreHook() {
|
||
return useSelectionStore(store)
|
||
}
|