From 2a70068c5dcb888dd021a048fc1a091e526e65bf Mon Sep 17 00:00:00 2001 From: probe Date: Wed, 21 Oct 2026 20:45:23 +0800 Subject: [PATCH] =?UTF-8?q?feat(buddy):=20=E6=94=AF=E6=8C=81=E5=A4=8D?= =?UTF-8?q?=E5=88=B6=E4=BC=9A=E8=AF=9D=E4=B8=BA=20Markdown?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../src/app/bootstrap/DesktopAppProvider.vue | 3 +- apps/buddy/src/i18n/locales/en-US/tasks.ts | 5 + apps/buddy/src/i18n/locales/zh-CN/tasks.ts | 5 + apps/buddy/src/modules/tasks/index.ts | 1 + .../__tests__/conversationMarkdown.spec.ts | 113 +++++++ .../__tests__/conversationMarkdownFixtures.ts | 22 ++ .../model/transcript/conversationMarkdown.ts | 318 ++++++++++++++++++ .../__tests__/conversationExport.spec.ts | 119 +++++++ .../state/conversations/conversationExport.ts | 105 ++++++ apps/buddy/src/modules/tasks/taskContext.ts | 2 + .../__tests__/useTaskMenuActions.spec.ts | 89 +++++ .../widgets/task-index/useTaskMenuActions.ts | 26 +- 12 files changed, 806 insertions(+), 2 deletions(-) create mode 100644 apps/buddy/src/modules/tasks/model/transcript/__tests__/conversationMarkdown.spec.ts create mode 100644 apps/buddy/src/modules/tasks/model/transcript/__tests__/conversationMarkdownFixtures.ts create mode 100644 apps/buddy/src/modules/tasks/model/transcript/conversationMarkdown.ts create mode 100644 apps/buddy/src/modules/tasks/state/conversations/__tests__/conversationExport.spec.ts create mode 100644 apps/buddy/src/modules/tasks/state/conversations/conversationExport.ts create mode 100644 apps/buddy/src/modules/tasks/widgets/task-index/__tests__/useTaskMenuActions.spec.ts diff --git a/apps/buddy/src/app/bootstrap/DesktopAppProvider.vue b/apps/buddy/src/app/bootstrap/DesktopAppProvider.vue index b8dbb5afa..bb3c11dc8 100644 --- a/apps/buddy/src/app/bootstrap/DesktopAppProvider.vue +++ b/apps/buddy/src/app/bootstrap/DesktopAppProvider.vue @@ -16,7 +16,7 @@ import { useDesktopOnboarding, useFeatureDiscovery } from '@/modules/onboarding' import { useCloudBackupFeedback, usePluginSettings, useProvideSettingsContext, useSettingsRegistry } from '@/modules/settings' import { useProvideSkillsContext } from '@/modules/skills' import { DesktopSkillReviewHost } from '@/modules/skills/ui' -import { provideExecutionEnvironment, sessionReferenceNavigationKey, useProvideTaskEnvironment, useTaskIndex, useTaskResourcePanel } from '@/modules/tasks' +import { createConversationExport, provideExecutionEnvironment, sessionReferenceNavigationKey, useProvideTaskEnvironment, useTaskIndex, useTaskResourcePanel } from '@/modules/tasks' import { useProvideDesktopUpdates } from '@/modules/updates' import { DesktopUpdateHost } from '@/modules/updates/ui' import DesktopBrowserGuestHost from '@/platform/browser/DesktopBrowserGuestHost.vue' @@ -327,6 +327,7 @@ useProvideTaskEnvironment({ browser: api.browser, browserGuests, clipboard: api.clipboard, + conversationExport: createConversationExport({ api: api.localChat.conversations, clipboard: api.clipboard }), notificationTarget, }) useProvideSettingsContext({ diff --git a/apps/buddy/src/i18n/locales/en-US/tasks.ts b/apps/buddy/src/i18n/locales/en-US/tasks.ts index 4dbdf99c2..8d9f73d6f 100644 --- a/apps/buddy/src/i18n/locales/en-US/tasks.ts +++ b/apps/buddy/src/i18n/locales/en-US/tasks.ts @@ -81,6 +81,11 @@ export default { 'desktop.tasks.taskReference': 'Task reference', 'desktop.tasks.taskId': 'Task ID', 'desktop.tasks.title': 'Title', + 'desktop.tasks.copyMarkdown': 'Copy as Markdown', + 'desktop.tasks.copyMarkdownLoading': 'Preparing conversation…', + 'desktop.tasks.copyMarkdownSuccess': 'Copied “{title}” as Markdown', + 'desktop.tasks.copyMarkdownFailed': 'Copy failed. Please try again.', + 'desktop.tasks.copyMarkdownTooLarge': 'This conversation is too large to copy at once.', 'desktop.tasks.untitled': 'Untitled task', 'desktop.tasks.tasksSection': 'Tasks', 'desktop.tasks.unpin': 'Unpin', diff --git a/apps/buddy/src/i18n/locales/zh-CN/tasks.ts b/apps/buddy/src/i18n/locales/zh-CN/tasks.ts index ad8f8395b..b2f8071bc 100644 --- a/apps/buddy/src/i18n/locales/zh-CN/tasks.ts +++ b/apps/buddy/src/i18n/locales/zh-CN/tasks.ts @@ -79,6 +79,11 @@ export default { 'desktop.tasks.taskReference': '任务引用', 'desktop.tasks.taskId': '任务 ID', 'desktop.tasks.title': '标题', + 'desktop.tasks.copyMarkdown': '复制为 Markdown', + 'desktop.tasks.copyMarkdownLoading': '正在整理会话…', + 'desktop.tasks.copyMarkdownSuccess': '已将“{title}”复制为 Markdown', + 'desktop.tasks.copyMarkdownFailed': '复制失败，请重试', + 'desktop.tasks.copyMarkdownTooLarge': '会话内容过大，暂无法一次复制', 'desktop.tasks.untitled': '未命名任务', 'desktop.tasks.tasksSection': '任务', 'desktop.tasks.unpin': '取消置顶', diff --git a/apps/buddy/src/modules/tasks/index.ts b/apps/buddy/src/modules/tasks/index.ts index 7886269da..c90e2980f 100644 --- a/apps/buddy/src/modules/tasks/index.ts +++ b/apps/buddy/src/modules/tasks/index.ts @@ -1,6 +1,7 @@ export type { TaskCapability, TaskChatWorkspace } from './contracts' export type { TaskContextTab } from './model/context-panel/taskContextPanel' export { useTaskResourcePanel } from './state/context-panel/useTaskResourcePanel' +export { createConversationExport } from './state/conversations/conversationExport' export { provideExecutionEnvironment } from './state/runs/chatExecutionContext' export { useTaskIndex } from './state/task-index/useTaskIndex' export type { TaskIndexController } from './state/task-index/useTaskIndex' diff --git a/apps/buddy/src/modules/tasks/model/transcript/__tests__/conversationMarkdown.spec.ts b/apps/buddy/src/modules/tasks/model/transcript/__tests__/conversationMarkdown.spec.ts new file mode 100644 index 000000000..7996cf573 --- /dev/null +++ b/apps/buddy/src/modules/tasks/model/transcript/__tests__/conversationMarkdown.spec.ts @@ -0,0 +1,113 @@ +import type { LocalConversationTimelinePage } from '@buddy-shared/conversation/conversationApi' +import { describe, expect, it } from 'vitest' +import { ConversationExportSizeError, formatConversationMarkdown, markdownFence } from '../conversationMarkdown' +import { at, conversation, event, message, page, run, terminal } from './conversationMarkdownFixtures' + +function format(timeline: LocalConversationTimelinePage, extra: Partial[0]> = {}) { + return formatConversationMarkdown({ conversation: conversation(), title: '排查启动失败', exportedAt: at, language: 'en-US', timeline, ...extra }) +} + +describe('conversation Markdown', () => { + it('copies original Markdown, metadata, localized roles and an empty conversation', () => { + const body = '**原文**\n\n```ts\nconst a = 1\n```' + const output = format(page({ items: [message('user', 'user', body), message('answer', 'assistant', '回答', { runId: null })] }), { language: 'zh-CN', title: '# 标题\n[链接]' }) + expect(output).toContain('# \\# 标题 \\[链接\\]') + expect(output).toContain('- 会话 ID: conversation') + expect(output).toContain('- 分支 ID: branch') + expect(output).toContain('## 用户') + expect(output).toContain(body) + expect(output.indexOf(body)).toBeLessThan(output.indexOf('回答')) + expect(format(page())).toContain('_No messages._') + }) + + it('restores commentary and terminal deltas once, in event order even at identical timestamps', () => { + const events = [ + event(1, 'message.completed', { messageId: 'commentary', phase: 'commentary', content: { text: '先检查命令' } }), + event(2, 'tool.started', { toolCallId: 'call', toolName: 'powershell', presentation: terminal('first') }), + event(3, 'tool.updated', { toolCallId: 'call', toolName: 'powershell', presentationDelta: { card: 'terminal', outputStart: 5, outputDelta: '\nsecond', truncated: true } }), + event(4, 'tool.completed', { toolCallId: 'call', toolName: 'powershell', isError: true, presentation: { ...terminal('first\nsecond'), exitCode: 1, truncated: true } }), + event(5, 'message.completed', { messageId: 'answer', phase: 'final_answer', content: { text: '最终答案' } }), + ] + const output = format(page({ runs: [run()], runEvents: events.reverse(), items: [message('user', 'user', '问题'), message('commentary', 'assistant', '先检查命令'), message('answer', 'assistant', '最终答案')] })) + expect(output.match(/先检查命令/g)).toHaveLength(1) + expect(output.match(/最终答案/g)).toHaveLength(1) + expect(output.match(/first\nsecond/g)).toHaveLength(1) + expect(output).toContain('Exit code: 1') + expect(output).toContain('Status: failed (error)') + expect(output).toContain('Tool output truncated by the source.') + expect(output.indexOf('问题')).toBeLessThan(output.indexOf('先检查命令')) + expect(output.indexOf('先检查命令')).toBeLessThan(output.indexOf('### Tool:')) + expect(output.indexOf('### Tool:')).toBeLessThan(output.indexOf('最终答案')) + }) + + it('restores a running final response not yet persisted without exporting reasoning or internal tool messages', () => { + const output = format(page({ runs: [run({ status: 'running', completedAt: null })], items: [message('user', 'user', 'question'), message('internal', 'tool', { text: 'PRIVATE_TOOL_PAYLOAD' })], runEvents: [ + event(1, 'message.block.completed', { messageId: 'reasoning', contentIndex: 0, kind: 'reasoning', content: 'PRIVATE_REASONING' }), + event(2, 'message.started', { messageId: 'stream' }), + event(3, 'message.delta', { messageId: 'stream', phase: 'final_answer', delta: 'partial answer' }), + ] })) + expect(output).toContain('partial answer') + expect(output).toContain('Status: running') + expect(output).not.toContain('PRIVATE_REASONING') + expect(output).not.toContain('PRIVATE_TOOL_PAYLOAD') + }) + + it.each(['cancelled', 'failed'] as const)('marks %s runs and interrupted/truncated persisted replies', (status) => { + const output = format(page({ runs: [run({ status, errorCode: 'TEST_ERROR' })], items: [message('user', 'user', 'question'), message('answer', 'assistant', { state: 'interrupted', text: 'partial', truncated: true })], runEvents: [event(1, 'run.failed', { errorMessage: 'reported failure' })] })) + expect(output).toContain(`Status: ${status}`) + expect(output).toContain('TEST\\_ERROR') + expect(output).toContain('Message interrupted; content truncated.') + if (status === 'failed') + expect(output).toContain('reported failure') + }) + + it('copies saved references and attachment metadata without preview URLs or following references', () => { + const output = format(page({ items: [message('user', 'user', { + resourceSnapshots: [], + userContent: { version: 1, body: [{ type: 'paragraph', content: [{ type: 'text', text: '请继续' }] }], panelResourceIds: [], sessionReferences: [{ id: 'other', title: '另一会话' }], quotes: [{ id: 'q', text: 'saved quote', source: { conversationId: 'other', branchId: 'old', messageId: 'quoted', role: 'assistant', runId: null } }], resourceQuotes: [{ id: 'file-q', text: 'saved file quote', source: { kind: 'file', title: 'notes', file: { spaceId: 'space', directoryId: 'directory', revision: 1, path: 'notes.txt' }, format: 'source' } }] }, + }, { attachments: [{ attachmentId: 'image', name: '# image\nname.png', kind: 'image', mimeType: 'image/png', sizeBytes: 123, previewUrl: 'PRIVATE_PREVIEW_URL' }] })] })) + expect(output).toContain('Referenced conversation: 另一会话 (ID: other)') + expect(output).toContain('saved quote') + expect(output).toContain('saved file quote') + expect(output).toContain('notes.txt') + expect(output).toContain('Attachment: \\# image name.png') + expect(output).not.toContain('PRIVATE_PREVIEW_URL') + }) + + it('recovers interrupted event snapshots and omits internal compaction messages', () => { + const output = format(page({ runs: [run({ status: 'cancelled' }), run({ id: 'compact-run', purpose: 'conversation.compaction' })], items: [message('user', 'user', 'question'), message('compact-answer', 'assistant', 'PRIVATE_COMPACTION_SUMMARY', { runId: 'compact-run' })], runEvents: [ + event(1, 'message.interrupted', { messageId: 'interrupted', role: 'assistant', content: { state: 'interrupted', text: 'PUBLIC_PARTIAL_REPLY', truncated: true } }), + event(1, 'message.completed', { messageId: 'compact-answer', phase: 'final_answer', content: { text: 'PRIVATE_COMPACTION_SUMMARY' } }, 'compact-run'), + ] })) + expect(output).toContain('PUBLIC_PARTIAL_REPLY') + expect(output).toContain('Message interrupted; content truncated.') + expect(output).not.toContain('PRIVATE_COMPACTION_SUMMARY') + }) + + it('lists local references without embedding their contents', () => { + const output = format(page({ items: [message('user', 'user', { resourceSnapshots: [{ resourceId: 'file', localReference: { kind: 'file', name: 'local.txt', path: 'D:\\project\\local.txt', mimeType: 'text/plain', sizeBytes: 500 } }], userContent: { version: 1, body: [{ type: 'paragraph', content: [{ type: 'resource_ref', resourceId: 'file' }] }], panelResourceIds: [] } })] })) + expect(output).toContain('@local.txt') + expect(output).toContain('Attachment: local.txt (text/plain, 500 bytes)') + expect(output).toContain('Path: D:') + }) + + it('uses a longer fence for logs containing Markdown fences and checks UTF-8 bytes', () => { + expect(markdownFence('before\n````js\ncode\n````')).toBe('`````text\nbefore\n````js\ncode\n````\n`````') + expect(() => format(page({ items: [message('user', 'user', '中'.repeat(1_000))] }), { maxBytes: 2_500 })).toThrow(ConversationExportSizeError) + }) + + it('copies generic tools, denied calls, artifact metadata and compact/plugin status without raw event payloads', () => { + const output = format(page({ items: [message('user', 'user', 'question'), { kind: 'compaction', id: 'compact', conversationId: 'conversation', branchId: 'branch', createdAt: at, completedAt: at, errorCode: null, estimatedTokensAfter: 10, tokensBefore: 100, status: 'completed' }, { kind: 'extension-action', id: 'ext', conversationId: 'conversation', branchId: 'branch', sourceMessageId: 'user', extensionId: 'plugin', extensionName: '插件', actionId: 'action', title: '检查', trigger: 'user', status: 'failed', message: 'plugin failed', createdAt: at, completedAt: at }], runs: [run()], runEvents: [ + event(1, 'tool.started', { toolCallId: 'call', toolName: 'fetch', presentation: { card: 'generic', argumentNames: ['url'], description: null, output: 'public output', truncated: false }, privateField: 'PRIVATE_EVENT_VALUE' }), + event(2, 'tool.denied', { toolCallId: 'call', toolName: 'fetch', denialCode: 'APPROVAL_DENIED' }), + ], outputs: [{ createdAt: at, runId: 'run', sourceToolCallId: 'call', artifacts: [{ artifactId: 'artifact', conversationId: 'conversation', runId: 'run', sourceToolCallId: 'call', sourceArtifactId: null, createdAt: at, updatedAt: at, kind: 'file', mimeType: 'text/plain', name: 'result.md', path: 'out/result.md', sizeBytes: 10, previewUrl: 'PRIVATE_ARTIFACT_URL' }] }] })) + expect(output).toContain('public output') + expect(output).toContain('Status: denied') + expect(output).toContain('APPROVAL\\_DENIED') + expect(output).toContain('Context compaction') + expect(output).toContain('plugin failed') + expect(output).toContain('out/result.md') + expect(output).not.toContain('PRIVATE_EVENT_VALUE') + expect(output).not.toContain('PRIVATE_ARTIFACT_URL') + }) +}) diff --git a/apps/buddy/src/modules/tasks/model/transcript/__tests__/conversationMarkdownFixtures.ts b/apps/buddy/src/modules/tasks/model/transcript/__tests__/conversationMarkdownFixtures.ts new file mode 100644 index 000000000..16c7d1fcf --- /dev/null +++ b/apps/buddy/src/modules/tasks/model/transcript/__tests__/conversationMarkdownFixtures.ts @@ -0,0 +1,22 @@ +import type { LocalConversation, LocalConversationTimelinePage, LocalMessage } from '@buddy-shared/conversation/conversationApi' +import type { LocalRun, LocalRunEvent } from '@buddy-shared/runs/runApi' + +export const at = '2026-10-21T08:00:00.000Z' +export function conversation(patch: Partial = {}): LocalConversation { + return { id: 'conversation', buddyId: 'default', title: '排查启动失败', activeBranchId: 'branch', spaceId: null, approvalPolicy: 'policy', executionProfile: 'workspace_write', modelSelection: null, createdAt: at, updatedAt: at, deletedAt: null, ...patch } +} +export function page(patch: Partial = {}): LocalConversationTimelinePage { + return { items: [], runs: [], runEvents: [], outputs: [], changeSets: [], nextCursor: null, ...patch } +} +export function message(id: string, role: LocalMessage['role'], content: LocalMessage['content'], patch: Partial = {}): LocalMessage & { kind: 'message' } { + return { kind: 'message', id, role, content, conversationId: 'conversation', branchId: 'branch', runId: role === 'user' ? null : 'run', createdAt: at, attachments: [], ...patch } +} +export function run(patch: Partial = {}): LocalRun { + return { id: 'run', conversationId: 'conversation', branchId: 'branch', buddyId: 'default', triggeringMessageId: 'user', modelId: 'model', providerId: 'provider', reasoningLevel: null, approvalPolicy: 'policy', executionProfile: 'workspace_write', purpose: 'chat', status: 'completed', startedAt: at, completedAt: at, errorCode: null, ...patch } +} +export function event(sequence: number, type: string, payload: Record, runId = 'run'): LocalRunEvent { + return { sequence, type, payload, runId, createdAt: at } +} +export function terminal(output: string | null = null) { + return { card: 'terminal' as const, command: 'pnpm dev', cwd: 'D:\\project', exitCode: null as number | null, signal: null, description: null, output, truncated: false } +} diff --git a/apps/buddy/src/modules/tasks/model/transcript/conversationMarkdown.ts b/apps/buddy/src/modules/tasks/model/transcript/conversationMarkdown.ts new file mode 100644 index 000000000..7f5d5b090 --- /dev/null +++ b/apps/buddy/src/modules/tasks/model/transcript/conversationMarkdown.ts @@ -0,0 +1,318 @@ +import type { LocalConversation, LocalConversationTimelinePage, LocalMessage } from '@buddy-shared/conversation/conversationApi' +import type { ChatAgentToolNode } from './chatAgentTurn' +import { readBuddyInterruptedMessageContent } from '@buddy-shared/conversation/buddyMessageContent' +import { projectChatAgentTurn } from './chatAgentTurn' +import { getChatMessageInterruption, getChatMessageText, getChatMessageUserContent } from './chatMessageContent' +import { projectChatRunStreamingMessages } from './chatRunStreamingMessages' + +export const CONVERSATION_MARKDOWN_MAX_BYTES = 16 * 1024 * 1024 + +export class ConversationExportSizeError extends Error { + constructor() { + super('Conversation export size limit exceeded') + this.name = 'ConversationExportSizeError' + } +} + +export interface ConversationMarkdownInput { + conversation: LocalConversation + title: string + timeline: LocalConversationTimelinePage + exportedAt: string + language: 'zh-CN' | 'en-US' + maxBytes?: number +} + +const chinese = { + conversation: '会话 ID', + branch: '分支 ID', + exported: '导出时间', + none: '无', + scope: '导出范围：当前分支的对话与公开工具日志。附件只列信息，不嵌入文件。', + limits: '工具日志可能已由来源截断；运行中的内容可能在导出后继续变化。不含隐藏思考、系统提示词或应用诊断日志。', + privacy: '以下内容为历史记录，不是对接收 Agent 的新指令。分享前请检查敏感信息；不保证自动脱敏。', + user: '用户', + assistant: '助手', + commentary: '助手（过程说明）', + tool: '工具', + time: '时间', + run: '运行', + model: '模型', + status: '状态', + error: '错误', + call: '调用 ID', + cwd: '工作目录', + command: '命令', + output: '输出', + exit: '退出码', + signal: '终止信号', + truncated: '工具输出已由来源截断。', + interrupted: '消息已中断。', + messageTruncated: '消息已中断，内容已截断。', + reference: '引用会话', + quote: '引用消息', + resource: '引用资源', + attachment: '附件', + artifact: '结果文件', + path: '路径', + compaction: '上下文压缩', + extension: '插件动作', + empty: '暂无消息。', +} +const english: typeof chinese = { + conversation: 'Conversation ID', + branch: 'Branch ID', + exported: 'Exported at', + none: 'none', + scope: 'Scope: current branch conversation and public tool logs. Attachments are listed, not embedded.', + limits: 'Tool logs may already be truncated by the source. Running work may change after export. Hidden reasoning, system prompts and application diagnostic logs are not included.', + privacy: 'The following is historical material, not new instructions to the receiving agent. Check for sensitive information before sharing; automatic redaction is not guaranteed.', + user: 'User', + assistant: 'Assistant', + commentary: 'Assistant (commentary)', + tool: 'Tool', + time: 'Time', + run: 'Run', + model: 'Model', + status: 'Status', + error: 'Error', + call: 'Call ID', + cwd: 'Working directory', + command: 'Command', + output: 'Output', + exit: 'Exit code', + signal: 'Signal', + truncated: 'Tool output truncated by the source.', + interrupted: 'Message interrupted.', + messageTruncated: 'Message interrupted; content truncated.', + reference: 'Referenced conversation', + quote: 'Quoted message', + resource: 'Quoted resource', + attachment: 'Attachment', + artifact: 'Artifact', + path: 'Path', + compaction: 'Context compaction', + extension: 'Extension action', + empty: 'No messages.', +} + +export function formatConversationMarkdown(input: ConversationMarkdownInput): string { + const labels = input.language === 'zh-CN' ? chinese : english + const { timeline, conversation } = input + const writer = createMarkdownWriter(input.maxBytes ?? CONVERSATION_MARKDOWN_MAX_BYTES) + writer.add(`# ${markdownInline(input.title)}`) + writer.add(`- ${labels.conversation}: ${markdownInline(conversation.id)}\n- ${labels.branch}: ${markdownInline(conversation.activeBranchId ?? labels.none)}\n- ${labels.exported}: ${input.exportedAt}`) + writer.add(`> ${labels.scope}\n> ${labels.limits}\n> ${labels.privacy}`) + + const messagesByRun = new Map() + for (const item of timeline.items) { + if (item.kind === 'message' && item.runId && item.role !== 'user') { + const bucket = messagesByRun.get(item.runId) ?? [] + bucket.push(item) + messagesByRun.set(item.runId, bucket) + } + } + const runsByTrigger = new Map() + for (const run of [...timeline.runs].sort((a, b) => a.startedAt.localeCompare(b.startedAt))) { + const bucket = runsByTrigger.get(run.triggeringMessageId) ?? [] + bucket.push(run) + runsByTrigger.set(run.triggeringMessageId, bucket) + } + const eventsByRun = new Map() + for (const event of timeline.runEvents) { + const bucket = eventsByRun.get(event.runId) ?? [] + bucket.push(event) + eventsByRun.set(event.runId, bucket) + } + const runsById = new Map(timeline.runs.map(run => [run.id, run])) + const renderedRuns = new Set() + const renderedMessages = new Set() + const renderedArtifacts = new Set() + + function addMessage(message: LocalMessage) { + if (renderedMessages.has(message.id)) + return + renderedMessages.add(message.id) + const body = formatMessage(message, labels) + if (body) + writer.add(body) + } + + function addRun(run: typeof timeline.runs[number]) { + if (renderedRuns.has(run.id)) + return + renderedRuns.add(run.id) + if (run.purpose === 'conversation.compaction') + return + const events = [...eventsByRun.get(run.id) ?? []].sort((a, b) => a.sequence - b.sequence) + const turn = projectChatAgentTurn(run, events) + writer.add(`### ${labels.run}\n\n- ID: ${markdownInline(run.id)}\n- ${labels.model}: ${markdownInline(run.providerId)} / ${markdownInline(run.modelId)}\n- ${labels.status}: ${run.status}\n- ${labels.time}: ${run.startedAt}${run.errorCode ? `\n- ${labels.error}: ${markdownInline(run.errorCode)}` : ''}`) + // The existing projector preserves event sequence, including equal timestamps. + const processIds = new Set() + for (const node of turn.nodes) { + if (node.kind === 'tool') { + writer.add(formatTool(node, labels, turn.nodeStartedAt?.[node.id] ?? run.startedAt)) + } + else if (node.kind === 'text' && node.text) { + processIds.add(node.messageId) + writer.add(`## ${labels.commentary}\n\n- ${labels.time}: ${turn.nodeStartedAt?.[node.id] ?? run.startedAt}\n\n${node.text}`) + } + else if (node.kind === 'compaction') { + writer.add(`### ${labels.compaction}\n\n- ${labels.status}: ${node.status}\n- ${labels.time}: ${turn.nodeStartedAt?.[node.id] ?? run.startedAt}`) + } + // Hidden reasoning and panel internals are never copied. + } + for (const id of processIds) + renderedMessages.add(id) + for (const message of messagesByRun.get(run.id) ?? []) + addMessage(message) + const recovered = new Map(projectChatRunStreamingMessages(run, events).map(item => [item.message.id, item.message])) + for (const event of events) { + if (event.type !== 'message.interrupted' || event.payload.role !== 'assistant' || typeof event.payload.messageId !== 'string') + continue + const content = readBuddyInterruptedMessageContent(event.payload.content) + if (content) { + recovered.set(event.payload.messageId, { + id: event.payload.messageId, + role: 'assistant', + content: { ...content }, + conversationId: run.conversationId, + branchId: run.branchId, + runId: run.id, + createdAt: event.createdAt, + attachments: [], + }) + } + } + for (const message of recovered.values()) + addMessage(message) + if (turn.failureMessage) + writer.add(`### ${labels.error}\n\n${markdownFence(turn.failureMessage)}`) + for (const output of timeline.outputs.filter(output => output.runId === run.id)) { + for (const artifact of output.artifacts) { + if (renderedArtifacts.has(artifact.artifactId)) + continue + renderedArtifacts.add(artifact.artifactId) + writer.add(`### ${labels.artifact}: ${markdownInline(artifact.name)}\n\n- ID: ${markdownInline(artifact.artifactId)}\n- ${labels.path}: ${markdownInline(artifact.path)}\n- ${labels.time}: ${artifact.createdAt}`) + } + } + } + + // Keep the branch timeline, including inherited ancestor messages. Group a run + // after its triggering user message, matching the conversation reading model. + for (const item of timeline.items) { + if (item.kind === 'message') { + const run = item.role !== 'user' && item.runId ? runsById.get(item.runId) : undefined + if (run) + addRun(run) + else + addMessage(item) + if (item.role === 'user') { + for (const triggered of runsByTrigger.get(item.id) ?? []) + addRun(triggered) + } + } + else if (item.kind === 'compaction') { + writer.add(`### ${labels.compaction}\n\n- ${labels.status}: ${item.status}\n- ${labels.time}: ${item.createdAt}${item.errorCode ? `\n- ${labels.error}: ${markdownInline(item.errorCode)}` : ''}`) + } + else { + writer.add(`### ${labels.extension}: ${markdownInline(item.title)}\n\n- ${labels.extension}: ${markdownInline(item.extensionName)}\n- ${labels.status}: ${item.status}\n- ${labels.time}: ${item.createdAt}${item.message ? `\n\n${markdownFence(item.message)}` : ''}`) + } + } + for (const run of timeline.runs) + addRun(run) + if (!timeline.items.length && !timeline.runs.length) + writer.add(`_${labels.empty}_`) + return writer.finish() +} + +function formatMessage(message: LocalMessage, labels: typeof chinese): string { + // Tool messages are internal provider payloads; export public tool nodes only. + if (message.role === 'tool') + return '' + const text = getChatMessageText(message) + const structured = getChatMessageUserContent(message) + const content = structured?.userContent + const parts: string[] = [] + if (text) + parts.push(text) + for (const reference of content?.sessionReferences ?? []) + parts.push(`- ${labels.reference}: ${markdownInline(reference.title)} (ID: ${markdownInline(reference.id)})`) + for (const quote of content?.quotes ?? []) + parts.push(`### ${labels.quote}: ${markdownInline(quote.source.messageId)}\n\n${markdownFence(quote.text)}`) + for (const quote of content?.resourceQuotes ?? []) + parts.push(`### ${labels.resource}\n\n${markdownFence(JSON.stringify(quote.source, null, 2), 'json')}\n\n${markdownFence(quote.text)}`) + for (const attachment of message.attachments) + parts.push(`- ${labels.attachment}: ${markdownInline(attachment.name)} (${markdownInline(attachment.mimeType)}, ${attachment.sizeBytes} bytes; ID: ${markdownInline(attachment.attachmentId)})`) + for (const snapshot of structured?.resourceSnapshots ?? []) { + const local = snapshot.localReference + if (local) + parts.push(`- ${labels.attachment}: ${markdownInline(local.name)} (${markdownInline(local.mimeType)}, ${local.sizeBytes} bytes); ${labels.path}: ${markdownInline(local.path)}`) + } + const interruption = getChatMessageInterruption(message) + if (interruption) + parts.push(`> ${interruption.truncated ? labels.messageTruncated : labels.interrupted}`) + if (!parts.length) + return '' + return [`## ${message.role === 'user' ? labels.user : labels.assistant}`, `- ${labels.time}: ${message.createdAt}`, ...parts].join('\n\n') +} + +function formatTool(node: ChatAgentToolNode, labels: typeof chinese, at: string): string { + const presentation = node.presentation + const parts = [ + `### ${labels.tool}: ${markdownInline(node.toolLabel ?? node.toolName)}`, + `- ${labels.status}: ${node.status}${node.isError ? ' (error)' : ''}\n- ${labels.time}: ${at}${node.toolCallId ? `\n- ${labels.call}: ${markdownInline(node.toolCallId)}` : ''}`, + ] + if (node.errorCode || node.denialCode) + parts.push(`- ${labels.error}: ${markdownInline(node.errorCode ?? node.denialCode ?? '')}`) + if (node.description) + parts.push(markdownFence(node.description)) + if (presentation.card === 'terminal') { + if (presentation.cwd) + parts.push(`${labels.cwd}: ${markdownInline(presentation.cwd)}`) + parts.push(`${labels.command}:\n\n${markdownFence(presentation.command)}`) + if (presentation.exitCode !== null) + parts.push(`${labels.exit}: ${presentation.exitCode}`) + if (presentation.signal) + parts.push(`${labels.signal}: ${markdownInline(presentation.signal)}`) + } + else { + const fields = Object.fromEntries(Object.entries(presentation).filter(([key, value]) => + !['output', 'diff', 'truncated', 'description'].includes(key) && value !== null)) + parts.push(markdownFence(JSON.stringify(fields, null, 2), 'json')) + } + if ('diff' in presentation && presentation.diff) + parts.push(markdownFence(presentation.diff, 'diff')) + if ('output' in presentation && presentation.output) + parts.push(`${labels.output}:\n\n${markdownFence(presentation.output)}`) + if ('truncated' in presentation && presentation.truncated) + parts.push(`> ${labels.truncated}`) + return parts.join('\n\n') +} + +export function markdownFence(value: string, language = 'text'): string { + let length = 3 + for (const match of value.matchAll(/`+/g)) + length = Math.max(length, match[0].length + 1) + const delimiter = '`'.repeat(length) + return `${delimiter}${language}\n${value}\n${delimiter}` +} + +export function markdownInline(value: string): string { + return value.replace(/[\r\n\u2028\u2029]+/g, ' ').replace(/([\\`*_[\]<>#!|])/g, '\\$1') +} + +function createMarkdownWriter(maxBytes: number) { + const parts: string[] = [] + const encoder = new TextEncoder() + let bytes = 0 + return { + add(part: string) { + bytes += encoder.encode(part).byteLength + 2 + if (bytes > maxBytes) + throw new ConversationExportSizeError() + parts.push(part) + }, + finish: () => `${parts.join('\n\n')}\n`, + } +} diff --git a/apps/buddy/src/modules/tasks/state/conversations/__tests__/conversationExport.spec.ts b/apps/buddy/src/modules/tasks/state/conversations/__tests__/conversationExport.spec.ts new file mode 100644 index 000000000..870d0900a --- /dev/null +++ b/apps/buddy/src/modules/tasks/state/conversations/__tests__/conversationExport.spec.ts @@ -0,0 +1,119 @@ +import type { LocalConversationTimelinePage } from '@buddy-shared/conversation/conversationApi' +import { deferred } from '@buddy-tests/deferred' +import { describe, expect, it, vi } from 'vitest' +import { conversation, event, message, page, run, terminal } from '@/modules/tasks/model/transcript/__tests__/conversationMarkdownFixtures' +import { ConversationExportSizeError } from '@/modules/tasks/model/transcript/conversationMarkdown' +import { createConversationExport } from '../conversationExport' + +function fixture(pages: LocalConversationTimelinePage[] = [page()]) { + const get = vi.fn().mockResolvedValue(conversation()) + const listTimeline = vi.fn() + for (const value of pages) + listTimeline.mockResolvedValueOnce(value) + const writeText = vi.fn().mockResolvedValue(undefined) + const options = { api: { get, listTimeline }, clipboard: { writeText } } + return { get, listTimeline, writeText, options, exporter: createConversationExport(options) } +} + +describe('conversation export', () => { + it('reads all pages on a fixed branch, keeps first run snapshots and copies exactly once', async () => { + const firstRun = run() + const firstEvent = event(1, 'tool.completed', { toolCallId: 'call', toolName: 'powershell', presentation: terminal('LATEST_LOG') }) + const answer = message('answer', 'assistant', 'ANSWER') + const f = fixture([ + page({ items: [answer], nextCursor: 'older', runs: [firstRun], runEvents: [firstEvent] }), + page({ items: [message('user', 'user', 'OLD_QUESTION', { branchId: 'ancestor' }), answer], runs: [run({ status: 'running' })], runEvents: [event(1, 'tool.completed', { ...firstEvent.payload, presentation: terminal('STALE_LOG') }), event(2, 'message.delta', { messageId: 'late', delta: 'LATE_EVENT' })] }), + ]) + expect(await f.exporter.copy('conversation', 'fallback', 'en-US')).toEqual({ title: '排查启动失败' }) + expect(f.listTimeline.mock.calls.map(call => call[0])).toEqual([ + { conversationId: 'conversation', branchId: 'branch', cursor: undefined, limit: 500 }, + { conversationId: 'conversation', branchId: 'branch', cursor: 'older', limit: 500 }, + ]) + expect(f.get).toHaveBeenNthCalledWith(2, 'conversation') + expect(f.writeText).toHaveBeenCalledTimes(1) + const output = f.writeText.mock.calls[0]![0] as string + expect(output.indexOf('OLD_QUESTION')).toBeLessThan(output.indexOf('ANSWER')) + expect(output.match(/ANSWER/g)).toHaveLength(1) + expect(output).toContain('LATEST_LOG') + expect(output).not.toContain('STALE_LOG') + expect(output).not.toContain('LATE_EVENT') + expect(output).toContain('Status: completed') + expect(f.exporter.busy.value).toBe(false) + }) + + it('rejects overlapping calls across menus and releases the shared lock', async () => { + const waiting = deferred() + const f = fixture() + f.listTimeline.mockReset().mockReturnValue(waiting.promise) + const copy = f.exporter.copy('conversation', 'first', 'en-US') + expect(f.exporter.busy.value).toBe(true) + expect(await f.exporter.copy('different', 'second', 'zh-CN')).toBeNull() + waiting.resolve(page()) + await copy + expect(f.get.mock.calls.every(call => call[0] === 'conversation')).toBe(true) + expect(f.writeText).toHaveBeenCalledTimes(1) + expect(f.exporter.busy.value).toBe(false) + }) + + it('does not change branch when the target active branch changes during reading', async () => { + const f = fixture([page({ items: [message('user', 'user', 'ORIGINAL')], nextCursor: 'older' }), page()]) + f.get.mockResolvedValueOnce(conversation()).mockResolvedValue(conversation({ activeBranchId: 'new-branch' })) + await f.exporter.copy('conversation', 'fallback', 'en-US') + expect(f.listTimeline.mock.calls.every(call => call[0].branchId === 'branch')).toBe(true) + expect(f.writeText.mock.calls[0]![0]).toContain('Branch ID: branch') + }) + + it('fails on a repeated cursor rather than silently exporting partial history', async () => { + const f = fixture([page({ nextCursor: 'same' }), page({ nextCursor: 'same' })]) + await expect(f.exporter.copy('conversation', 'fallback', 'en-US')).rejects.toThrow('pagination') + expect(f.writeText).not.toHaveBeenCalled() + expect(f.listTimeline).toHaveBeenCalledTimes(2) + expect(f.exporter.busy.value).toBe(false) + }) + + it('preserves the clipboard on a later page failure and allows retry', async () => { + const f = fixture([page({ nextCursor: 'older' })]) + f.listTimeline.mockRejectedValueOnce(new Error('offline')) + await expect(f.exporter.copy('conversation', 'fallback', 'en-US')).rejects.toThrow('offline') + expect(f.writeText).not.toHaveBeenCalled() + expect(f.exporter.busy.value).toBe(false) + f.listTimeline.mockResolvedValue(page()) + await f.exporter.copy('conversation', 'fallback', 'en-US') + expect(f.writeText).toHaveBeenCalledTimes(1) + }) + + it.each(['read', 'markdown'])('enforces the %s budget without writing a partial result', async (budget) => { + const f = fixture([page({ items: [message('user', 'user', '中'.repeat(100))], nextCursor: 'older' })]) + const exporter = createConversationExport({ ...f.options, ...(budget === 'read' ? { maxReadBytes: 10 } : { maxMarkdownBytes: 10 }) }) + if (budget === 'markdown') + f.listTimeline.mockResolvedValueOnce(page()) + await expect(exporter.copy('conversation', 'fallback', 'en-US')).rejects.toThrow(ConversationExportSizeError) + expect(f.writeText).not.toHaveBeenCalled() + expect(exporter.busy.value).toBe(false) + if (budget === 'read') + expect(f.listTimeline).toHaveBeenCalledTimes(1) + }) + + it('checks deletion again before writing', async () => { + const f = fixture() + f.get.mockResolvedValueOnce(conversation()).mockResolvedValueOnce(conversation({ deletedAt: '2026-10-21T09:00:00.000Z' })) + await expect(f.exporter.copy('conversation', 'fallback', 'en-US')).rejects.toThrow('no longer available') + expect(f.writeText).not.toHaveBeenCalled() + }) + + it('handles an empty branch without requesting a timeline and uses fallback titles', async () => { + const f = fixture() + f.get.mockResolvedValue(conversation({ activeBranchId: null, title: null })) + await f.exporter.copy('conversation', 'fallback title', 'en-US') + expect(f.listTimeline).not.toHaveBeenCalled() + expect(f.writeText.mock.calls[0]![0]).toContain('# fallback title') + expect(f.writeText.mock.calls[0]![0]).toContain('_No messages._') + }) + + it('propagates clipboard failures and releases the lock', async () => { + const f = fixture() + f.writeText.mockRejectedValueOnce(new Error('clipboard unavailable')) + await expect(f.exporter.copy('conversation', 'fallback', 'en-US')).rejects.toThrow('clipboard unavailable') + expect(f.exporter.busy.value).toBe(false) + }) +}) diff --git a/apps/buddy/src/modules/tasks/state/conversations/conversationExport.ts b/apps/buddy/src/modules/tasks/state/conversations/conversationExport.ts new file mode 100644 index 000000000..b01296669 --- /dev/null +++ b/apps/buddy/src/modules/tasks/state/conversations/conversationExport.ts @@ -0,0 +1,105 @@ +import type { LocalChatApi } from '@buddy-electron/shared/localChatApi' +import type { LocalConversationTimelineItem, LocalConversationTimelinePage } from '@buddy-shared/conversation/conversationApi' +import { readonly, shallowRef } from 'vue' +import { ConversationExportSizeError, formatConversationMarkdown } from '../../model/transcript/conversationMarkdown' + +export interface ConversationExportOptions { + api: Pick + clipboard: { writeText: (text: string) => Promise } + maxReadBytes?: number + maxMarkdownBytes?: number +} + +export function createConversationExport(options: ConversationExportOptions) { + const busy = shallowRef(false) + return { + busy: readonly(busy), + async copy(conversationId: string, fallbackTitle: string, language: 'zh-CN' | 'en-US'): Promise<{ title: string } | null> { + if (busy.value) + return null + busy.value = true + try { + const conversation = await options.api.get(conversationId) + if (conversation.deletedAt || conversation.id !== conversationId) + throw new Error('Conversation is no longer available') + const branchId = conversation.activeBranchId + const title = conversation.title || fallbackTitle + const items = new Set() + const runs = new Map() + const events = new Map() + const outputs = new Map() + const itemPages: LocalConversationTimelineItem[][] = [] + const cursors = new Set() + const encoder = new TextEncoder() + let readBytes = 0 + let cursor: string | undefined + if (branchId) { + do { + const page = await options.api.listTimeline({ conversationId, branchId, cursor, limit: 500 }) + readBytes += encoder.encode(JSON.stringify(page)).byteLength + if (readBytes > (options.maxReadBytes ?? 64 * 1024 * 1024)) + throw new ConversationExportSizeError() + const newItems: LocalConversationTimelineItem[] = [] + for (const item of page.items) { + const key = `${item.kind}:${item.id}` + if (!items.has(key)) { + items.add(key) + newItems.push(item) + } + } + itemPages.push(newItems) + // Keep each run's first snapshot; older pages may contain newer events. + const newRunIds = new Set(page.runs.filter(run => !runs.has(run.id)).map(run => run.id)) + for (const run of page.runs) { + if (!runs.has(run.id)) + runs.set(run.id, run) + } + for (const event of page.runEvents) { + if (newRunIds.has(event.runId)) + events.set(`${event.runId}:${event.sequence}`, event) + } + for (const output of page.outputs) { + const key = `${output.runId}:${output.sourceToolCallId}` + if (newRunIds.has(output.runId) && !outputs.has(key)) + outputs.set(key, output) + } + cursor = page.nextCursor ?? undefined + if (cursor && (cursors.has(cursor) || cursors.size >= 2_000)) + throw new Error('Conversation export pagination did not advance') + if (cursor) { + cursors.add(cursor) + // Yield so progress feedback can paint during long reads. + await new Promise(resolve => setTimeout(resolve, 0)) + } + } while (cursor) + } + const markdown = formatConversationMarkdown({ + conversation, + title, + language, + exportedAt: new Date().toISOString(), + maxBytes: options.maxMarkdownBytes, + timeline: { + items: itemPages.reverse().flat(), + runs: [...runs.values()], + runEvents: [...events.values()], + outputs: [...outputs.values()], + changeSets: [], + nextCursor: null, + }, + }) + // Do not copy a conversation deleted during a long read. + const current = await options.api.get(conversationId) + if (current.deletedAt || current.id !== conversationId) + throw new Error('Conversation is no longer available') + await options.clipboard.writeText(markdown) + return { title } + } + finally { + busy.value = false + } + }, + } +} + +export type ConversationExport = ReturnType diff --git a/apps/buddy/src/modules/tasks/taskContext.ts b/apps/buddy/src/modules/tasks/taskContext.ts index 524c0ea6e..97706e4f1 100644 --- a/apps/buddy/src/modules/tasks/taskContext.ts +++ b/apps/buddy/src/modules/tasks/taskContext.ts @@ -1,6 +1,7 @@ import type { LexoraDesktopApi } from '@buddy-electron/shared/desktopApi' import type { Ref } from 'vue' import type { TaskCapability, TaskResourcePanel } from './contracts' +import type { ConversationExport } from './state/conversations/conversationExport' import type { DesktopBrowserGuestSurfaceHost } from '@/platform/browser/browserGuestSurface' import { createInjectionState } from '@vueuse/core' @@ -8,6 +9,7 @@ export interface TaskEnvironment { browser: LexoraDesktopApi['browser'] browserGuests: DesktopBrowserGuestSurfaceHost clipboard: LexoraDesktopApi['clipboard'] + conversationExport: ConversationExport notificationTarget: Readonly> resources: TaskResourcePanel } diff --git a/apps/buddy/src/modules/tasks/widgets/task-index/__tests__/useTaskMenuActions.spec.ts b/apps/buddy/src/modules/tasks/widgets/task-index/__tests__/useTaskMenuActions.spec.ts new file mode 100644 index 000000000..7f16873e2 --- /dev/null +++ b/apps/buddy/src/modules/tasks/widgets/task-index/__tests__/useTaskMenuActions.spec.ts @@ -0,0 +1,89 @@ +import type { DropdownOption } from 'naive-ui' +import type { TaskEnvironment } from '@/modules/tasks/taskContext' +import { deferred } from '@buddy-tests/deferred' +import { beforeEach, describe, expect, it, vi } from 'vitest' +import { shallowRef } from 'vue' +import { parseSessionReferenceClipboard } from '@/modules/tasks/model/sessionReferenceClipboard' +import { conversation, page } from '@/modules/tasks/model/transcript/__tests__/conversationMarkdownFixtures' +import { createConversationExport } from '@/modules/tasks/state/conversations/conversationExport' +import { useTaskMenuActions } from '../useTaskMenuActions' + +const state = vi.hoisted(() => ({ environment: {} as TaskEnvironment, destroy: vi.fn(), success: vi.fn(), error: vi.fn(), loading: vi.fn() })) +vi.mock('@/modules/tasks/taskContext', () => ({ useTaskEnvironment: () => state.environment })) +vi.mock('naive-ui', async original => ({ + ...await original(), + useMessage: () => ({ success: state.success, error: state.error, loading: state.loading }), +})) +beforeEach(() => { + state.loading.mockReturnValue({ destroy: state.destroy }) +}) +function fixture() { + const get = vi.fn().mockResolvedValue(conversation()) + const listTimeline = vi.fn().mockResolvedValue(page()) + const writeText = vi.fn().mockResolvedValue(undefined) + const exporter = createConversationExport({ api: { get, listTimeline }, clipboard: { writeText } }) + state.environment = { clipboard: { writeText }, conversationExport: exporter } as unknown as TaskEnvironment + const task = shallowRef({ taskId: 'conversation' as string | null, title: 'original title', marks: [], marksBusy: false }) + const options = { task: () => task.value, language: () => 'zh-CN' as const, assignMark: vi.fn(), clearMarks: vi.fn(), setRead: vi.fn() } + const first = useTaskMenuActions(options) + const second = useTaskMenuActions(options) + const markdownItem = (menu = first) => (menu.actions.value.find(option => option.key === 'copy') as DropdownOption).children!.find(option => option.key === 'copy-markdown') as DropdownOption + return { first, second, task, get, listTimeline, writeText, markdownItem, exporter } +} + +describe('task copy menu', () => { + it('exposes Markdown in the shared menu and leaves all existing copy payloads unchanged', async () => { + const f = fixture() + expect(f.markdownItem().label).toBe('复制为 Markdown') + const children = (f.first.actions.value.find(option => option.key === 'copy') as DropdownOption).children! + expect(children.map(option => option.key)).toEqual(['copy-task-reference', 'copy-reference-divider', 'copy-task-id', 'copy-title', 'copy-markdown']) + expect(children[1]).toMatchObject({ type: 'divider' }) + f.first.select('copy-title') + f.first.select('copy-task-id') + f.first.select('copy-task-reference') + expect(f.writeText.mock.calls[0]![0]).toBe('original title') + expect(f.writeText.mock.calls[1]![0]).toBe('conversation') + expect(parseSessionReferenceClipboard(f.writeText.mock.calls[2]![0])).toEqual({ references: [{ id: 'conversation', title: 'original title' }], text: '' }) + expect(f.listTimeline).not.toHaveBeenCalled() + f.task.value = { ...f.task.value, taskId: null } + expect(f.first.actions.value).toEqual([]) + f.first.select('copy-markdown') + expect(state.loading).not.toHaveBeenCalled() + }) + + it('disables both menus during export, binds the original target, and reports the actual title', async () => { + const f = fixture() + const waiting = deferred>() + f.listTimeline.mockReturnValue(waiting.promise) + f.first.select('copy-markdown') + expect(f.markdownItem().disabled).toBe(true) + expect(f.markdownItem(f.second).disabled).toBe(true) + f.task.value = { ...f.task.value, taskId: 'different', title: 'different title' } + f.second.select('copy-markdown') + waiting.resolve(page()) + await vi.waitFor(() => expect(state.success).toHaveBeenCalledWith('已将“排查启动失败”复制为 Markdown')) + expect(f.get.mock.calls.every(call => call[0] === 'conversation')).toBe(true) + expect(f.writeText).toHaveBeenCalledTimes(1) + expect(state.loading).toHaveBeenCalledTimes(1) + expect(state.destroy).toHaveBeenCalledTimes(1) + expect(f.markdownItem().disabled).toBe(false) + }) + + it.each(['read', 'clipboard', 'size'])('reports a %s failure without a success toast', async (failure) => { + const f = fixture() + if (failure === 'read') + f.listTimeline.mockRejectedValue(new Error('offline')) + if (failure === 'clipboard') + f.writeText.mockRejectedValue(new Error('unavailable')) + if (failure === 'size') + state.environment.conversationExport = createConversationExport({ api: { get: f.get, listTimeline: f.listTimeline }, clipboard: { writeText: f.writeText }, maxReadBytes: 1 }) + // Recreate the menu after replacing the environment capability. + const menu = useTaskMenuActions({ task: () => f.task.value, language: () => 'zh-CN', assignMark() {}, clearMarks() {}, setRead() {} }) + menu.select('copy-markdown') + await vi.waitFor(() => expect(state.error).toHaveBeenCalledWith(failure === 'size' ? '会话内容过大，暂无法一次复制' : '复制失败，请重试')) + expect(state.success).not.toHaveBeenCalled() + expect(state.destroy).toHaveBeenCalledTimes(1) + if (failure !== 'clipboard') + expect(f.writeText).not.toHaveBeenCalled() + }) +}) diff --git a/apps/buddy/src/modules/tasks/widgets/task-index/useTaskMenuActions.ts b/apps/buddy/src/modules/tasks/widgets/task-index/useTaskMenuActions.ts index 952074a12..82a4ece2a 100644 --- a/apps/buddy/src/modules/tasks/widgets/task-index/useTaskMenuActions.ts +++ b/apps/buddy/src/modules/tasks/widgets/task-index/useTaskMenuActions.ts @@ -6,6 +6,7 @@ import { useMessage } from 'naive-ui' import { computed, h } from 'vue' import { useBuddyI18n } from '@/i18n/buddyI18n' import { formatSessionReferenceClipboard } from '@/modules/tasks/model/sessionReferenceClipboard' +import { ConversationExportSizeError } from '@/modules/tasks/model/transcript/conversationMarkdown' import { useTaskEnvironment } from '@/modules/tasks/taskContext' import DesktopIcon from '@/shared/ui/icon/DesktopIcon.vue' import DesktopTaskMarkOption from './DesktopTaskMarkOption.vue' @@ -28,7 +29,7 @@ export function useTaskMenuActions(options: { manageMarks?: () => void }) { const { t } = useBuddyI18n(options.language) - const { clipboard } = useTaskEnvironment() + const { clipboard, conversationExport } = useTaskEnvironment() const notification = useMessage() const actions = computed(() => { const task = options.task() @@ -61,17 +62,40 @@ export function useTaskMenuActions(options: { label: t('desktop.tasks.copy'), children: [ { key: 'copy-task-reference', label: t('desktop.tasks.taskReference') }, + { type: 'divider', key: 'copy-reference-divider' }, { key: 'copy-task-id', label: t('desktop.tasks.taskId') }, { key: 'copy-title', label: t('desktop.tasks.title') }, + { key: 'copy-markdown', label: t('desktop.tasks.copyMarkdown'), disabled: conversationExport.busy.value }, ], }, ] }) + async function copyMarkdown(taskId: string, title: string) { + if (conversationExport.busy.value) + return + const loading = notification.loading(t('desktop.tasks.copyMarkdownLoading'), { duration: 0 }) + try { + const result = await conversationExport.copy(taskId, title, options.language()) + if (result) + notification.success(t('desktop.tasks.copyMarkdownSuccess', { title: result.title })) + } + catch (error) { + notification.error(t(error instanceof ConversationExportSizeError ? 'desktop.tasks.copyMarkdownTooLarge' : 'desktop.tasks.copyMarkdownFailed')) + } + finally { + loading.destroy() + } + } + function select(action: string | number) { const task = options.task() if (!task.taskId) return + if (action === 'copy-markdown') { + void copyMarkdown(task.taskId, task.title) + return + } if (action === 'read') options.setRead(task.taskId, task.markState?.unread === true) if (action === 'clear-marks')