feat: Implement chat creation from object nodes, enhancing user interaction with detailed context and lineage information

experdot · experdot · commit b7c0b899c7b5 · 2025-07-15T20:00:31.000+08:00
diff --git a/src/renderer/src/components/common/PageLineageDisplay.tsx b/src/renderer/src/components/common/PageLineageDisplay.tsx
@@ -91,7 +91,7 @@ const PageLineageDisplay: React.FC<PageLineageDisplayProps> = ({
       case 'crosstab_to_chat':
         return '从交叉分析表生成'
       case 'object_to_chat':
-        return '从对象页面生成'
+        return '从对象节点生成'
       case 'chat_to_object':
         return '从聊天页面生成'
       default:
diff --git a/src/renderer/src/components/pages/object/ObjectBrowser.tsx b/src/renderer/src/components/pages/object/ObjectBrowser.tsx
@@ -62,6 +62,7 @@ const ObjectBrowser: React.FC<ObjectBrowserProps> = ({ chatId }) => {
           onDelete={() => handleNodeDelete(nodeId)}
           onClearChildren={() => handleClearChildren(nodeId)}
           onSaveEdit={(id, newValue) => handleSaveEdit(id, newValue)}
+          onCreateChat={(id, name) => handleCreateChat(id, name)}
         />
       ),
       key: nodeId,
@@ -200,6 +201,230 @@ const ObjectBrowser: React.FC<ObjectBrowserProps> = ({ chatId }) => {
     [dispatch, chat.id, nodes, modal]
   )
 
+  // 获取节点上下文信息
+  const getNodeContext = useCallback((currentNode: ObjectNodeType) => {
+    if (!currentNode) return ''
+
+    // 获取节点完整信息
+    const getNodeInformation = (node: ObjectNodeType): string => {
+      let information = `# 节点 - [${node.name}]\n${node.description || ''}`
+
+      // 添加属性信息
+      if (node.properties && Object.keys(node.properties).length > 0) {
+        const properties = Object.entries(node.properties).map(([key, value]) => ({
+          Name: key,
+          Value: value
+        }))
+        information += `\n## 属性列表\n${JSON.stringify(properties)}`
+      }
+
+      // 添加子节点信息
+      if (node.children && node.children.length > 0) {
+        const children = node.children
+          .map((childId) => {
+            const childNode = nodes[childId]
+            return childNode
+              ? childNode.description
+                ? {
+                    Name: childNode.name,
+                    Description: childNode.description
+                  }
+                : {
+                    Name: childNode.name
+                  }
+              : null
+          })
+          .filter(Boolean)
+
+        if (children.length > 0) {
+          information += `\n## 子节点列表\n${JSON.stringify(children)}`
+        }
+      }
+
+      // 添加引用信息
+      if (node.references && node.references.length > 0) {
+        const references = node.references.map((ref) => {
+          const refNode = nodes[ref.id]
+          return {
+            Name: ref.name,
+            Description: ref.description || '',
+            Type: ref.type,
+            Strength: ref.strength,
+            NodeExists: !!refNode,
+            NodeDescription: refNode?.description || ''
+          }
+        })
+        information += `\n## 引用关系\n${JSON.stringify(references)}`
+      }
+
+      return information
+    }
+
+    // 从当前节点向上追踪到根节点，构建完整链路
+    const buildAncestorChain = (node: ObjectNodeType): ObjectNodeType[] => {
+      const chain: ObjectNodeType[] = []
+      let current = node
+
+      // 向上追踪到根节点
+      while (current) {
+        chain.unshift(current)
+        if (current.parentId && nodes[current.parentId]) {
+          current = nodes[current.parentId]
+        } else {
+          break
+        }
+      }
+
+      return chain
+    }
+
+    // 获取同级节点
+    const getSiblings = (node: ObjectNodeType): ObjectNodeType[] => {
+      if (!node.parentId) return []
+      const parent = nodes[node.parentId]
+      if (!parent || !parent.children) return []
+      return parent.children
+        .filter((id) => id !== node.id)
+        .map((id) => nodes[id])
+        .filter(Boolean)
+    }
+
+    // 获取当前节点的引用信息
+    const getCurrentReferences = (node: ObjectNodeType) => {
+      if (!node.references) return []
+      return node.references.map((ref) => ({
+        ...ref,
+        referencedNode: nodes[ref.id] || null
+      }))
+    }
+
+    // 获取引用当前节点的其他节点（反向引用）
+    const getIncomingReferences = (node: ObjectNodeType) => {
+      const incomingRefs: Array<{
+        fromNode: ObjectNodeType
+        reference: any
+      }> = []
+      
+      Object.values(nodes).forEach((otherNode) => {
+        if (otherNode.id !== node.id && otherNode.references) {
+          otherNode.references.forEach((ref) => {
+            if (ref.id === node.id) {
+              incomingRefs.push({
+                fromNode: otherNode,
+                reference: ref
+              })
+            }
+          })
+        }
+      })
+      
+      return incomingRefs
+    }
+
+    const ancestorChain = buildAncestorChain(currentNode)
+    const siblings = getSiblings(currentNode)
+    const currentReferences = getCurrentReferences(currentNode)
+    const incomingReferences = getIncomingReferences(currentNode)
+
+    // 构建完整的上下文信息
+    let contextInfo = '# 完整上下文信息\n\n'
+
+    // 添加层级结构信息
+    contextInfo += '## 节点层级结构\n'
+    contextInfo += '从根节点到当前节点的完整路径：\n'
+    ancestorChain.forEach((ancestor, index) => {
+      const indent = '  '.repeat(index)
+      contextInfo += `${indent}- ${ancestor.name}`
+      if (ancestor.description) {
+        contextInfo += ` (${ancestor.description})`
+      }
+      contextInfo += '\n'
+    })
+
+    // 添加每个层级节点的详细信息
+    contextInfo += '\n## 路径节点详细信息\n'
+    ancestorChain.forEach((ancestor, index) => {
+      contextInfo += `\n### 第${index + 1}层节点\n`
+      contextInfo += getNodeInformation(ancestor)
+      contextInfo += '\n'
+    })
+
+    // 添加同级节点信息
+    if (siblings.length > 0) {
+      contextInfo += '\n## 同级节点信息\n'
+      siblings.forEach((sibling) => {
+        contextInfo += `\n### 同级节点 - ${sibling.name}\n`
+        contextInfo += getNodeInformation(sibling)
+        contextInfo += '\n'
+      })
+    } else {
+      contextInfo += '\n## 同级节点信息\n无同级节点\n'
+    }
+
+    // 添加引用关系信息
+    if (currentReferences.length > 0) {
+      contextInfo += '\n## 当前节点的引用关系\n'
+      currentReferences.forEach((ref) => {
+        contextInfo += `\n### 引用节点 - ${ref.name}\n`
+        contextInfo += `- **引用类型**: ${ref.type}\n`
+        contextInfo += `- **引用强度**: ${ref.strength}\n`
+        if (ref.description) {
+          contextInfo += `- **引用描述**: ${ref.description}\n`
+        }
+        if (ref.referencedNode) {
+          contextInfo += `- **节点存在**: 是\n`
+          contextInfo += `- **节点描述**: ${ref.referencedNode.description || '无'}\n`
+        } else {
+          contextInfo += `- **节点存在**: 否（可能已被删除）\n`
+        }
+        contextInfo += '\n'
+      })
+    } else {
+      contextInfo += '\n## 当前节点的引用关系\n当前节点无引用其他节点\n'
+    }
+
+    // 添加反向引用信息
+    if (incomingReferences.length > 0) {
+      contextInfo += '\n## 被其他节点引用的情况\n'
+      incomingReferences.forEach((incomingRef) => {
+        contextInfo += `\n### 来自节点 - ${incomingRef.fromNode.name}\n`
+        contextInfo += `- **引用类型**: ${incomingRef.reference.type}\n`
+        contextInfo += `- **引用强度**: ${incomingRef.reference.strength}\n`
+        if (incomingRef.reference.description) {
+          contextInfo += `- **引用描述**: ${incomingRef.reference.description}\n`
+        }
+        contextInfo += `- **来源节点描述**: ${incomingRef.fromNode.description || '无'}\n`
+        contextInfo += '\n'
+      })
+    } else {
+      contextInfo += '\n## 被其他节点引用的情况\n当前节点未被其他节点引用\n'
+    }
+
+    return contextInfo
+  }, [nodes])
+
+  // 处理创建对话
+  const handleCreateChat = useCallback(
+    (nodeId: string, nodeName: string) => {
+      const node = nodes[nodeId]
+      if (!node) return
+
+      const nodeContext = getNodeContext(node)
+
+      dispatch({
+        type: 'CREATE_CHAT_FROM_OBJECT_NODE',
+        payload: {
+          folderId: chat.folderId,
+          nodeId,
+          nodeName,
+          nodeContext,
+          sourcePageId: chatId
+        }
+      })
+    },
+    [dispatch, chat.folderId, chatId, nodes, getNodeContext]
+  )
+
   // 搜索处理
   const handleSearch = useCallback((e: React.ChangeEvent<HTMLInputElement>) => {
     const query = e.target.value
diff --git a/src/renderer/src/components/pages/object/ObjectTreeNode.tsx b/src/renderer/src/components/pages/object/ObjectTreeNode.tsx
@@ -4,7 +4,8 @@ import {
   EditOutlined,
   DeleteOutlined,
   ClearOutlined,
-  MoreOutlined
+  MoreOutlined,
+  CommentOutlined
 } from '@ant-design/icons'
 import type { MenuProps } from 'antd'
 import { ObjectNode as ObjectNodeType } from '../../../types'
@@ -19,6 +20,7 @@ interface ObjectTreeNodeProps {
   onDelete?: () => void
   onClearChildren?: () => void
   onSaveEdit?: (nodeId: string, newValue: string) => void
+  onCreateChat?: (nodeId: string, nodeName: string) => void
 }
 
 export default function ObjectTreeNode({
@@ -28,7 +30,8 @@ export default function ObjectTreeNode({
   onEdit,
   onDelete,
   onClearChildren,
-  onSaveEdit
+  onSaveEdit,
+  onCreateChat
 }: ObjectTreeNodeProps) {
   const [isHovered, setIsHovered] = useState(false)
   const [isInlineEditing, setIsInlineEditing] = useState(false)
@@ -74,6 +77,18 @@ export default function ObjectTreeNode({
       }
     ]
 
+    if (onCreateChat) {
+      items.push({
+        key: 'chat',
+        label: '创建对话',
+        icon: <CommentOutlined />,
+        onClick: (e) => {
+          e?.domEvent?.stopPropagation()
+          onCreateChat(node.id, node.name)
+        }
+      })
+    }
+
     if (!isRoot) {
       items.push({
         key: 'delete',
diff --git a/src/renderer/src/store/reducers/chatReducer.ts b/src/renderer/src/store/reducers/chatReducer.ts
@@ -160,6 +160,89 @@ ${cellContent}
       }
     }
 
+    case 'CREATE_CHAT_FROM_OBJECT_NODE': {
+      const { folderId, nodeId, nodeName, nodeContext, sourcePageId } = action.payload
+
+      // 构建用户提示词
+      const prompt = `# 基于对象节点的深度分析
+
+## 节点信息
+- **节点名称**: ${nodeName}
+- **节点ID**: ${nodeId}
+
+## 节点上下文
+${nodeContext}
+
+## 请求
+请基于以上节点信息和上下文进行深度分析，你可以：
+1. 详细解释这个节点的含义、作用和在整个对象结构中的位置
+2. 分析节点的层级关系、属性特征和引用关系
+3. 基于上下文信息提供相关的扩展见解和建议
+4. 探讨可能的改进方向、相关问题或进一步的发展方向
+
+请开始你的分析：`
+
+      // 生成聊天标题
+      const chatTitle = `${nodeName} - 深度分析`
+
+      // 创建用户消息
+      const userMessage = {
+        id: uuidv4(),
+        role: 'user' as const,
+        content: prompt,
+        timestamp: Date.now()
+      }
+
+      // 创建溯源信息
+      const lineage = {
+        source: 'object_to_chat' as const,
+        sourcePageId,
+        sourceContext: {
+          customContext: {
+            nodeId,
+            nodeName,
+            context: nodeContext
+          }
+        },
+        generatedPageIds: [],
+        generatedAt: Date.now(),
+        description: `从对象页面的节点 "${nodeName}" 生成的深度分析聊天`
+      }
+
+      // 创建并打开新的普通聊天窗口
+      const newChat = createNewChat(chatTitle, folderId, lineage)
+      const regularChat = newChat as RegularChat
+      regularChat.messages = [userMessage]
+      regularChat.currentPath = [userMessage.id]
+
+      const newOpenTabs = state.openTabs.includes(newChat.id)
+        ? state.openTabs
+        : [...state.openTabs, newChat.id]
+
+      // 更新源页面的generatedPageIds
+      const updatedPages = state.pages.map((page) => {
+        if (page.id === sourcePageId && page.lineage) {
+          return {
+            ...page,
+            lineage: {
+              ...page.lineage,
+              generatedPageIds: [...page.lineage.generatedPageIds, newChat.id]
+            }
+          }
+        }
+        return page
+      })
+
+      return {
+        ...state,
+        pages: [...updatedPages, newChat],
+        openTabs: newOpenTabs,
+        activeTabId: newChat.id,
+        selectedNodeId: newChat.id,
+        selectedNodeType: 'chat'
+      }
+    }
+
     case 'CREATE_CROSSTAB_CHAT': {
       const newCrosstabChat = createNewCrosstabChat(
         action.payload.title,
diff --git a/src/renderer/src/types/index.ts b/src/renderer/src/types/index.ts
