aicodeswitch 5.1.2 → 5.2.0

package/dist/server/session-migration.js

@@ -0,0 +1,419 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractSessionContent = extractSessionContent;
+exports.previewMigration = previewMigration;
+exports.migrateSession = migrateSession;
+function parseSSEChunks(sourceText) {
+    const chunks = sourceText.split('\n').map(item => item.trim()).join('\n')
+        .split('\n\n').filter(s => s.trim());
+    const events = [];
+    for (const chunk of chunks) {
+        let event = '';
+        let dataLines = [];
+        let dataInsert = 0;
+        const lines = chunk.split('\n');
+        lines.forEach((line) => {
+            if (/^[a-z]+:/.test(line)) {
+                const at = line.indexOf(':');
+                const type = line.slice(0, at).trim();
+                const content = line.slice(at + 1).trim();
+                if (type === 'event') {
+                    event = content;
+                }
+                else if (type === 'data') {
+                    dataLines.push(content);
+                    dataInsert = 1;
+                }
+                else if (dataLines.length) {
+                    dataInsert = -1;
+                }
+            }
+            else if (dataInsert === 1) {
+                dataLines.push(line);
+            }
+        });
+        if (dataLines.length) {
+            const raw = dataLines.join('\n');
+            let parsed = raw;
+            try {
+                parsed = JSON.parse(raw);
+            }
+            catch ( /* keep raw string */_a) { /* keep raw string */ }
+            events.push({ event, data: parsed, raw });
+        }
+    }
+    return events;
+}
+function assembleStreamText(events) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
+    let text = '', thinking = '';
+    let inTextBlock = false, inThinkingBlock = false;
+    let reasoningAccumulated = false;
+    for (const ev of events) {
+        const data = ev.data;
+        if (!data)
+            continue;
+        // Claude format
+        if (typeof data === 'object' && data.type) {
+            if (data.type === 'content_block_start') {
+                if (((_a = data.content_block) === null || _a === void 0 ? void 0 : _a.type) === 'text')
+                    inTextBlock = true;
+                else if (((_b = data.content_block) === null || _b === void 0 ? void 0 : _b.type) === 'thinking')
+                    inThinkingBlock = true;
+            }
+            if (data.type === 'content_block_delta') {
+                if (((_c = data.delta) === null || _c === void 0 ? void 0 : _c.type) === 'text_delta' && inTextBlock)
+                    text += data.delta.text || '';
+                if (((_d = data.delta) === null || _d === void 0 ? void 0 : _d.type) === 'thinking_delta' && inThinkingBlock)
+                    thinking += data.delta.thinking || '';
+            }
+            if (data.type === 'content_block_stop') {
+                inTextBlock = false;
+                inThinkingBlock = false;
+            }
+        }
+        // Responses API format
+        if (typeof data === 'object' && data.type) {
+            if (data.type === 'response.reasoning_text.delta') {
+                thinking += data.delta || '';
+                reasoningAccumulated = true;
+            }
+            if (data.type === 'response.content_part.done') {
+                if (((_e = data.part) === null || _e === void 0 ? void 0 : _e.type) === 'output_text' && ((_f = data.part) === null || _f === void 0 ? void 0 : _f.text)) {
+                    text += data.part.text;
+                }
+                if (((_g = data.part) === null || _g === void 0 ? void 0 : _g.type) === 'reasoning_text' && ((_h = data.part) === null || _h === void 0 ? void 0 : _h.text) && !reasoningAccumulated) {
+                    thinking += data.part.text;
+                }
+            }
+        }
+        // OpenAI Chat format
+        if (typeof data === 'object' && ((_k = (_j = data.choices) === null || _j === void 0 ? void 0 : _j[0]) === null || _k === void 0 ? void 0 : _k.delta)) {
+            const delta = data.choices[0].delta;
+            if (delta.content)
+                text += delta.content;
+            if ((_l = delta.thinking) === null || _l === void 0 ? void 0 : _l.content)
+                thinking += delta.thinking.content;
+        }
+        // DeepSeek direct format
+        if (typeof data === 'object' && (data.reasoning_content || data.thinking)) {
+            thinking += data.reasoning_content || data.thinking;
+        }
+    }
+    return { text, thinking };
+}
+// ─── 工具调用摘要化 ───
+const TOOL_SUMMARIES = {
+    Bash: (i) => `🔧 执行命令: \`${i.command || i.cmd || ''}\``,
+    Read: (i) => `📖 读取文件: ${i.file_path || ''}`,
+    Write: (i) => `📝 写入文件: ${i.file_path || ''}`,
+    Edit: (i) => `✏️ 编辑文件: ${i.file_path || i.target_file || ''}`,
+    Glob: (i) => `🔍 搜索文件: ${i.pattern || ''}`,
+    Grep: (i) => `🔍 搜索内容: ${i.pattern || ''}`,
+    TodoWrite: () => `📋 更新任务列表`,
+    Agent: () => `🤖 启动子代理`,
+    TaskOutput: () => `📤 获取任务输出`,
+    SendMessage: () => `💬 发送消息`,
+    shell: (i) => `🔧 执行命令: \`${i.command || ''}\``,
+    apply_diff: (_i) => `✏️ 应用代码变更`,
+    create_file: (_i) => `📝 创建文件`,
+};
+function summarizeToolCall(toolName, input) {
+    const summarizer = TOOL_SUMMARIES[toolName];
+    if (summarizer) {
+        try {
+            return summarizer(input);
+        }
+        catch (_a) {
+            return `🔧 调用工具: ${toolName}`;
+        }
+    }
+    return `🔧 调用工具: ${toolName}`;
+}
+function extractUserTextFromClaudeMessages(messages) {
+    const userMsgs = messages.filter(m => m.role === 'user');
+    if (!userMsgs.length)
+        return '';
+    const lastMsg = userMsgs[userMsgs.length - 1];
+    if (typeof lastMsg.content === 'string')
+        return lastMsg.content;
+    if (Array.isArray(lastMsg.content)) {
+        return lastMsg.content
+            .filter(b => b.type === 'text' && b.text)
+            .map(b => b.text)
+            .join('\n');
+    }
+    return '';
+}
+function extractToolCallsFromClaudeMessage(msg) {
+    if (!Array.isArray(msg.content))
+        return [];
+    return msg.content
+        .filter(b => b.type === 'tool_use')
+        .map(b => summarizeToolCall(b.name || 'unknown', b.input || {}));
+}
+function extractUserTextFromCodexInput(inputArr) {
+    const userItems = inputArr.filter(i => i.type === 'message' && i.role === 'user');
+    if (!userItems.length)
+        return '';
+    const lastItem = userItems[userItems.length - 1];
+    if (typeof lastItem.content === 'string')
+        return lastItem.content;
+    if (Array.isArray(lastItem.content)) {
+        return lastItem.content
+            .filter((b) => b.type === 'input_text' && b.text)
+            .map((b) => b.text)
+            .join('\n');
+    }
+    return '';
+}
+function extractToolCallsFromCodexInput(inputArr) {
+    return inputArr
+        .filter(i => i.type === 'function_call')
+        .map(i => summarizeToolCall(i.name || 'unknown', typeof i.arguments === 'string' ? JSON.parse(i.arguments || '{}') : (i.arguments || {})));
+}
+function extractAssistantResponseFromLog(log) {
+    var _a, _b, _c;
+    let text = '', thinking = '';
+    // 1. Try downstreamResponseBody (SSE)
+    const sourceText = log.downstreamResponseBody;
+    if (typeof sourceText === 'string' && (sourceText.includes('event:') || sourceText.includes('data:'))) {
+        const events = parseSSEChunks(sourceText);
+        const assembled = assembleStreamText(events);
+        text = assembled.text;
+        thinking = assembled.thinking;
+    }
+    // 2. Try responseBody (JSON)
+    if (!text && !thinking && log.responseBody) {
+        try {
+            const parsed = typeof log.responseBody === 'string' ? JSON.parse(log.responseBody) : log.responseBody;
+            if (parsed.content) {
+                if (Array.isArray(parsed.content)) {
+                    const parts = [];
+                    for (const block of parsed.content) {
+                        if (block.type === 'text' && block.text)
+                            parts.push(block.text);
+                        else if (block.type === 'thinking' && block.thinking)
+                            thinking += block.thinking;
+                    }
+                    text = parts.join('\n\n');
+                }
+                else if (typeof parsed.content === 'string') {
+                    text = parsed.content;
+                }
+            }
+            if (!text && ((_c = (_b = (_a = parsed.choices) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.message) === null || _c === void 0 ? void 0 : _c.content)) {
+                text = parsed.choices[0].message.content;
+            }
+            if (!text && parsed.output) {
+                const parts = [];
+                for (const item of parsed.output) {
+                    if (item.type === 'message') {
+                        if (Array.isArray(item.content)) {
+                            for (const c of item.content) {
+                                if (c.type === 'output_text' && c.text)
+                                    parts.push(c.text);
+                            }
+                        }
+                    }
+                }
+                text = parts.join('\n\n');
+            }
+        }
+        catch ( /* ignore parse errors */_d) { /* ignore parse errors */ }
+    }
+    // 3. Try streamChunks
+    if (!text && Array.isArray(log.streamChunks)) {
+        const chunksText = log.streamChunks.join('');
+        if (chunksText.includes('event:') || chunksText.includes('data:')) {
+            const events = parseSSEChunks(chunksText);
+            const assembled = assembleStreamText(events);
+            text = assembled.text;
+            thinking = assembled.thinking;
+        }
+    }
+    return { text: text.trim(), thinking: thinking.trim() };
+}
+function isClaudeCodeBody(body) {
+    return (body === null || body === void 0 ? void 0 : body.messages) && Array.isArray(body.messages);
+}
+function isCodexBody(body) {
+    return (body === null || body === void 0 ? void 0 : body.input) && Array.isArray(body.input);
+}
+// ─── Token 估算 ───
+function estimateTokens(text) {
+    let cjk = 0, other = 0;
+    for (const ch of text) {
+        const code = ch.charCodeAt(0);
+        if ((code >= 0x4E00 && code <= 0x9FFF) ||
+            (code >= 0x3400 && code <= 0x4DBF) ||
+            (code >= 0x20000 && code <= 0x2A6DF) ||
+            (code >= 0xF900 && code <= 0xFAFF)) {
+            cjk++;
+        }
+        else {
+            other++;
+        }
+    }
+    return Math.ceil(cjk + other * 0.25);
+}
+// ─── 迁移 Prompt 生成 ───
+function formatSessionTitle(title) {
+    if (!title)
+        return '(无标题)';
+    return title.replace(/<\/?session>/g, '').trim() || '(无标题)';
+}
+function generateMigrationPrompt(content, targetTool) {
+    const toolLabels = {
+        'claude-code': 'Claude Code',
+        'codex': 'Codex',
+    };
+    const sourceLabel = toolLabels[content.sourceTool];
+    const targetLabel = toolLabels[targetTool];
+    const lines = [];
+    lines.push(`# 会话迁移上下文`);
+    lines.push('');
+    lines.push(`> 以下内容从 ${sourceLabel} 会话「${formatSessionTitle(content.sessionTitle)}」迁移而来`);
+    lines.push(`> 目标工具：${targetLabel}`);
+    lines.push(`> 迁移时间：${new Date().toISOString()}`);
+    lines.push(`> 原始会话共 ${content.totalRounds} 轮对话，此处包含最近 ${content.extractedRounds} 轮`);
+    lines.push('');
+    lines.push('---');
+    lines.push('');
+    lines.push('## 对话历史');
+    lines.push('');
+    for (const round of content.rounds) {
+        lines.push(`### 👤 用户`);
+        lines.push(round.userMessage || '(无文本内容)');
+        lines.push('');
+        if (round.toolCallSummaries.length > 0) {
+            for (const summary of round.toolCallSummaries) {
+                lines.push(`> ${summary}`);
+            }
+            lines.push('');
+        }
+        lines.push(`### 🤖 助手`);
+        lines.push(round.assistantResponse || '(无文本内容)');
+        lines.push('');
+        if (round.thinking) {
+            lines.push('<details>');
+            lines.push('<summary>思考过程</summary>');
+            lines.push('');
+            lines.push(round.thinking);
+            lines.push('');
+            lines.push('</details>');
+            lines.push('');
+        }
+        lines.push('---');
+        lines.push('');
+    }
+    lines.push(`> ⚠️ 注意：以上对话历史和工具操作仅为上下文摘要，实际的文件修改和工具执行结果不会在目标工具中生效。`);
+    lines.push(`> 请基于以上上下文继续工作。`);
+    return lines.join('\n');
+}
+// ─── 主要导出 ───
+function extractSessionContent(dbManager, sessionId, options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const logs = yield dbManager.getLogsBySessionId(sessionId, 10000);
+        const session = dbManager.getSession(sessionId);
+        if (!session) {
+            throw new Error(`Session not found: ${sessionId}`);
+        }
+        const sortedLogs = logs.sort((a, b) => a.timestamp - b.timestamp);
+        const rounds = [];
+        for (let i = 0; i < sortedLogs.length; i++) {
+            const log = sortedLogs[i];
+            const body = log.body
+                ? (typeof log.body === 'string' ? JSON.parse(log.body) : log.body)
+                : null;
+            if (!body)
+                continue;
+            // Extract user message
+            let userMessage = '';
+            let toolCallSummaries = [];
+            if (isClaudeCodeBody(body)) {
+                userMessage = extractUserTextFromClaudeMessages(body.messages);
+                // Extract tool calls from assistant messages
+                if (options.includeToolCalls !== false && body.messages) {
+                    for (const msg of body.messages) {
+                        if (msg.role === 'assistant') {
+                            toolCallSummaries.push(...extractToolCallsFromClaudeMessage(msg));
+                        }
+                    }
+                }
+            }
+            else if (isCodexBody(body)) {
+                userMessage = extractUserTextFromCodexInput(body.input);
+                if (options.includeToolCalls !== false) {
+                    toolCallSummaries = extractToolCallsFromCodexInput(body.input);
+                }
+            }
+            if (!userMessage && !toolCallSummaries.length)
+                continue;
+            // Extract assistant response
+            const { text, thinking } = extractAssistantResponseFromLog(log);
+            rounds.push({
+                index: rounds.length + 1,
+                userMessage,
+                assistantResponse: text,
+                toolCallSummaries,
+                thinking: options.includeThinking ? (thinking || undefined) : undefined,
+                timestamp: log.timestamp,
+            });
+        }
+        const maxRounds = options.maxRounds || 0;
+        const extractedRounds = maxRounds > 0 ? rounds.slice(-maxRounds) : rounds;
+        return {
+            sessionId,
+            sessionTitle: session.title || '',
+            sourceTool: session.targetType,
+            rounds: extractedRounds,
+            totalRounds: sortedLogs.length,
+            extractedRounds: extractedRounds.length,
+        };
+    });
+}
+function previewMigration(content, targetTool) {
+    const warnings = [];
+    const prompt = generateMigrationPrompt(content, targetTool);
+    const estimatedTokens = estimateTokens(prompt);
+    if (content.totalRounds > content.extractedRounds && content.extractedRounds > 0) {
+        warnings.push(`会话较长（${content.totalRounds} 轮），已截断到最近 ${content.extractedRounds} 轮对话`);
+    }
+    if (estimatedTokens > 100000) {
+        warnings.push(`迁移 Prompt 约 ${estimatedTokens.toLocaleString()} tokens，可能超过目标模型的上下文窗口`);
+    }
+    if (content.totalRounds === 0) {
+        warnings.push('该会话没有可提取的对话内容');
+    }
+    return {
+        content,
+        generatedPrompt: prompt,
+        estimatedTokens,
+        warnings,
+    };
+}
+function migrateSession(content, targetTool, editedPrompt) {
+    const prompt = editedPrompt || generateMigrationPrompt(content, targetTool);
+    const estimatedTokens = estimateTokens(prompt);
+    const warnings = [];
+    if (estimatedTokens > 100000) {
+        warnings.push(`迁移 Prompt 约 ${estimatedTokens.toLocaleString()} tokens，可能超过目标模型的上下文窗口`);
+    }
+    return {
+        success: true,
+        prompt,
+        format: 'markdown',
+        estimatedTokens,
+        warnings,
+    };
+}

package/dist/server/transformers/chunk-collector.js

@@ -23,7 +23,7 @@ function isClientDisconnectError(error) {
  * 这个Transform会记录所有经过它的数据块,同时将数据原封不动地传递给下一个stream
  */
 class ChunkCollectorTransform extends stream_1.Transform {
-    constructor() {
+    constructor(refreshCallback) {
         super({ writableObjectMode: true, readableObjectMode: true });
         Object.defineProperty(this, "chunks", {
             enumerable: true,
@@ -43,6 +43,25 @@ class ChunkCollectorTransform extends stream_1.Transform {
             writable: true,
             value: new string_decoder_1.StringDecoder('utf8')
         });
+        Object.defineProperty(this, "lastRefreshTime", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        Object.defineProperty(this, "refreshCallback", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "REFRESH_INTERVAL", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 5000
+        }); // 每5秒最多刷新一次
+        this.refreshCallback = refreshCallback;
         this.on('error', (err) => {
             if (isClientDisconnectError(err)) {
                 console.warn('[ChunkCollectorTransform] Stream closed (client disconnected)');
@@ -69,6 +88,14 @@ class ChunkCollectorTransform extends stream_1.Transform {
             }
             // 将chunk传递给下一个stream
             this.push(chunk);
+            // 节流刷新规则使用状态（仅在有数据流过时触发）
+            if (this.refreshCallback) {
+                const now = Date.now();
+                if (now - this.lastRefreshTime >= this.REFRESH_INTERVAL) {
+                    this.lastRefreshTime = now;
+                    this.refreshCallback();
+                }
+            }
             callback();
         }
         catch (error) {

package/dist/server/transformers/model-rewrite-transform.js

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModelRewriteTransform = void 0;
+exports.rewriteResponseModel = rewriteResponseModel;
+const stream_1 = require("stream");
+const string_decoder_1 = require("string_decoder");
+/**
+ * 流式 SSE 响应中的 model 字段回写 Transform。
+ *
+ * 插入位置：SSESerializerTransform 之后、ChunkCollectorTransform 之前。
+ * 输入/输出均为 text mode（字符串），通过正则替换 SSE data 行中的
+ * "model":"上游模型名" → "model":"客户端原始模型名"。
+ */
+class ModelRewriteTransform extends stream_1.Transform {
+    constructor(originalModel) {
+        super({
+            writableObjectMode: false, // 接收序列化后的文本
+            readableObjectMode: false, // 输出文本
+        });
+        Object.defineProperty(this, "modelRegex", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "replacement", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "modelVersionRegex", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "modelVersionReplacement", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "stringDecoder", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new string_decoder_1.StringDecoder('utf8')
+        });
+        Object.defineProperty(this, "buffer", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ''
+        });
+        // 转义原始模型名中的特殊字符，防止 JSON 注入
+        const escaped = originalModel.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+        this.replacement = `"model":"${escaped}"`;
+        this.modelRegex = /"model"\s*:\s*"[^"]*"/g;
+        // 处理 Gemini 直通场景中的 modelVersion 字段
+        if (originalModel) {
+            this.modelVersionReplacement = `"modelVersion":"${escaped}"`;
+            this.modelVersionRegex = /"modelVersion"\s*:\s*"[^"]*"/g;
+        }
+    }
+    _transform(chunk, _encoding, callback) {
+        try {
+            this.buffer += this.stringDecoder.write(chunk);
+            // 按行处理（SSE 协议以 \n 分隔）
+            const lines = this.buffer.split('\n');
+            this.buffer = lines.pop() || '';
+            for (const line of lines) {
+                this.push(this.rewriteLine(line) + '\n');
+            }
+            callback();
+        }
+        catch (error) {
+            callback(error);
+        }
+    }
+    _flush(callback) {
+        try {
+            const remaining = this.stringDecoder.end();
+            if (remaining)
+                this.buffer += remaining;
+            if (this.buffer) {
+                this.push(this.rewriteLine(this.buffer));
+            }
+            callback();
+        }
+        catch (error) {
+            callback(error);
+        }
+    }
+    rewriteLine(line) {
+        // 只处理 SSE data 行
+        if (!line.startsWith('data:'))
+            return line;
+        let result = line;
+        // 重置正则 lastIndex（因为带 g 标志）
+        this.modelRegex.lastIndex = 0;
+        result = result.replace(this.modelRegex, this.replacement);
+        if (this.modelVersionRegex && this.modelVersionReplacement) {
+            this.modelVersionRegex.lastIndex = 0;
+            result = result.replace(this.modelVersionRegex, this.modelVersionReplacement);
+        }
+        return result;
+    }
+}
+exports.ModelRewriteTransform = ModelRewriteTransform;
+/**
+ * 非流式响应中的 model 字段回写。
+ *
+ * 将响应对象的 model（以及 Gemini 的 modelVersion）改写为客户端原始模型名。
+ * 直接修改传入对象（原地修改）。
+ */
+function rewriteResponseModel(responseData, originalModel) {
+    if (!responseData || !originalModel || typeof responseData !== 'object')
+        return;
+    // 所有格式在转换后统一使用 "model" 字段
+    if ('model' in responseData) {
+        responseData.model = originalModel;
+    }
+    // Gemini 直通场景可能保留 modelVersion
+    if ('modelVersion' in responseData) {
+        responseData.modelVersion = originalModel;
+    }
+}