aws-runtime-bridge 1.9.22 → 1.9.31

package/dist/routes/git.js

@@ -1171,30 +1171,257 @@ gitRouter.post('/git/diff-file', validateToken, async (req, res) => {
     }
 });
 /**
- * 调用 OpenAI-compatible API 生成 Git 提交信息。
- * 具体功能：将暂存区 diff 作为上下文发送给 AI，返回生成的提交信息文本。
+ * 提交信息生成器的 system prompt。
+ *
+ * 设计要点:
+ *   1. 角色与硬约束(STRICTLY / NEVER / MUST)放在最前,降低被忽略的概率。
+ *   2. few-shot 示例用 `<example>...</example>` 包裹,显式标明"输出只能是 message 行"。
+ *   3. description 使用中文(与项目语言一致),首行 type(scope) 用英文。
+ *   4. 显式禁止 AI 解释自己"在做什么",这正是截图中出现"我们被问到..."问题的根因。
  */
-export async function callAiForCommitMessage(aiBaseUrl, aiApiKey, aiModel, diffContent) {
-    const url = `${aiBaseUrl.replace(/\/+$/, '')}/chat/completions`;
-    const systemPrompt = [
-        'You are a Git commit message generator. Generate concise, structured commit messages based on code diffs.',
+const COMMIT_MESSAGE_SYSTEM_PROMPT = [
+    'STRICTLY act as a Git commit message generator. NEVER explain, narrate, or describe your task.',
+    'NEVER start your reply with phrases like "我们被问到", "以下是", "好的", "Sure", "Here is", "I will", "I can", "Let me", "根据", "下面".',
+    'NEVER include any meta-language or thinking out loud. Output ONLY the commit message text.',
+    '',
+    'Format (Conventional Commits, 1 line, optional body):',
+    '  <type>(<scope>): <description>',
+    '',
+    'Allowed types: feat, fix, refactor, test, docs, style, chore, perf, ci, build, revert.',
+    'First line MUST be <= 72 characters. <description> MUST be in Chinese.',
+    'Add a body (separated by a blank line) ONLY when the change needs more context.',
+].join('\n');
+/**
+ * 用户提示词:直接给出 diff,要求"输出"提交信息,不引导模型解释任务。
+ */
+function buildCommitMessageUserPrompt(diffContent) {
+    return [
+        '请直接输出上述格式的提交信息,不要任何额外文字。',
+        '以下是暂存区 diff:',
         '',
-        'Rules:',
-        '- Use conventional commit format: type(scope): description',
-        '- Types: feat, fix, refactor, test, docs, style, chore, perf, ci, build, revert',
-        '- Keep the first line under 72 characters',
-        '- Include a brief body only if the change needs explanation',
-        '- Write in Chinese for the description part',
-        '- Respond with ONLY the commit message, no explanations',
+        diffContent,
     ].join('\n');
+}
+/**
+ * 识别 conventional commit 消息开头的 type 模式: type(scope)?: description。
+ * 这是 sanitizeCommitMessage 的主策略 — 只要能定位到真正的 type,就直接截断,
+ * 避免 AI 元描述前缀(如"我们被问到..."/"以下是...")污染首行。
+ */
+const COMMIT_TYPE_PATTERN = /\b(?:feat|fix|chore|docs|style|refactor|perf|test|build|ci|revert)(?:\s*\([^)]*\))?\s*:/i;
+/**
+ * 宽松的 commit type 模式，用于识别不包含 scope 的 commit 消息。
+ * 例如 "fix: 修复登录问题" 或 "feat: 添加新功能"
+ */
+const COMMIT_TYPE_LOOSE_PATTERN = /^(?:feat|fix|chore|docs|style|refactor|perf|test|build|ci|revert)\s*:/i;
+/**
+ * 判断文本首行是否看起来像有效的 commit 消息（有实际内容，不是纯元描述）。
+ * 有效特征：包含中文/英文描述、不是纯噪声词汇、长度合理
+ */
+function looksLikeValidCommitMessage(text) {
+    const firstLine = text.split('\n')[0]?.trim() ?? '';
+    if (!firstLine || firstLine.length < 3) {
+        return false;
+    }
+    // 检查是否包含有意义的描述（至少 2 个中文字符或 2 个英文字母序列）
+    const chineseChars = (firstLine.match(/[\u4e00-\u9fa5]/g) || []).length;
+    const englishWords = (firstLine.match(/[a-zA-Z]{2,}/g) || []).length;
+    // 无中文且无英文单词时，如果首行只有符号/数字，判定无效
+    if (chineseChars === 0 && englishWords === 0) {
+        return false;
+    }
+    // 排除明显是元描述的前缀（还没被剥离干净的）
+    const metaPrefixes = [
+        /^以下是/,
+        /^上面是/,
+        /^生成的/,
+        /^这是/,
+        /^下面/,
+        /^(?:Here|This|This is|That is)/i,
+    ];
+    for (const prefix of metaPrefixes) {
+        if (prefix.test(firstLine)) {
+            return false;
+        }
+    }
+    return chineseChars >= 2 || englishWords >= 2;
+}
+/**
+ * 已知会污染输出的"AI 元描述"前缀(pattern 列表),作为主策略失败时的兜底。
+ * 当 AI 输出不包含可识别的 commit type(例如只输出元描述)时,按列表依次剥离。
+ */
+const COMMIT_NOISE_PREFIX_PATTERNS = [
+    // 中文: "我们被问到..." / "我需要..." / "我将先..." / "我们先..."
+    // 注意: 字符集排除 `.` `:` 全角 `:` 换行,但允许 `,` 和中文 `,`,
+    // 这样 "我们被问到根据 diff 生成提交信息,好的以下是:" 这种带逗号前缀的也能被剥光
+    /^\s*(?:我们|我)\s*(?:被\s*)?(?:问[到过]?|需要|要|将|来|先)[^.：\n]{0,60}?(?:提交信息|commit\s*message|[:：,，。])/i,
+    // 中文: "好的, ..." / "好: ..." / "好的以下是:"
+    /^\s*(?:好的|好)\s*[,，:：]/i,
+    // 中文: "好的以下是..." / "好以下是..." — 前一条 pattern 剥离后残留
+    /^\s*(?:好的|好)\s*(?:以下是|上面是|提供|生成|给出)[^.：\n]{0,20}?[:：]?/i,
+    // 中文: "是:" / "是：" — 前一条 pattern 剥离 "提从信息" 后残留的 "是:"
+    /^\s*是\s*[:：]/i,
+    // 英文: "Sure, ..." / "Here is..." / "I will..." / "Let me..." / "Certainly:" / "Of course:"
+    /^\s*(?:Sure|Here(?:'s|\s+is)|We(?:'re| are)|I\s+(?:will|can|'ll)|Let\s+me|Certainly|Of\s+course)[^.：\n]{0,40}?[,，:：.]/i,
+    // 中文: "根据您/你提供的 diff, " / "根据上述 diff" / "根据所给 diff"
+    /^\s*根据\s*(?:您|你|您所|你所|所)?\s*(?:提供|上述|给[我您你])?\s*(?:的)?\s*diff\s*[,，:：]?/i,
+    // 中文: "以下是xxx提交信息: " / "下面是xxx提交信息," / "以下是符合 conventional commit 规范的提交信息: "
+    /^\s*(?:以下|下面)[^,，:：\n]{0,30}?提交信息\s*[,，:：]?/i,
+    // 中文: "以下是:" / "下面是:" — 不带"提交信息"的简化版,剥离前一条未命中的残留
+    /^\s*(?:以下|下面)\s*是\s*[,，:：]/i,
+    // 中文: "生成xxx提交信息: " / "生成一条 conventional commit 提交信息,"
+    /^\s*生成\s*(?:一条|一个|了)?\s*(?:符合|新的)?\s*(?:conventional\s*commit|git)?\s*提交信息\s*[,，:：]?/i,
+    // 开头 markdown 代码块 fence
+    /^\s*```(?:text|markdown|bash|shell)?\s*\n?/i,
+];
+/**
+ * 清洗 AI 返回的提交信息,去掉元描述/代码块/超长首行等噪声。
+ *
+ * 主流程:
+ *   1. 主策略: 查找最早的 conventional commit type 模式(type(scope)?:),直接截取
+ *      这一段之前的元描述全部丢弃。位置限定在 80 字符内,避免把 body 中提到的
+ *      "feat" 等字眼误当作开头。
+ *   2. 兜底: 主策略未命中时,反复剥离已知元描述前缀 pattern(最多 5 次)
+ *   3. 截断到首个空行,丢弃 body 中混入的元描述
+ *   4. 去掉尾部 markdown 代码块
+ *   5. 首行 > 100 字符视为模型仍在解释,只保留首行
+ *   6. 最终为空时返回 "chore: update staged changes" 兜底
+ */
+export function sanitizeCommitMessage(raw) {
+    if (!raw) {
+        logger.info(`[Git/sanitize] 输入为空, 返回 fallback`);
+        return 'chore: update staged changes';
+    }
+    let text = raw.replace(/\r\n/g, '\n').trim();
+    const rawPreview = JSON.stringify(raw.substring(0, 120));
+    // 1. 主策略: 定位 commit type 模式并截断
+    const typeMatch = text.match(COMMIT_TYPE_PATTERN);
+    if (typeMatch && typeMatch.index !== undefined && typeMatch.index <= 80) {
+        text = text.slice(typeMatch.index);
+    }
+    else {
+        // 2. 兜底: 反复剥离元描述前缀
+        for (let i = 0; i < 5; i += 1) {
+            const before = text;
+            for (const pattern of COMMIT_NOISE_PREFIX_PATTERNS) {
+                text = text.replace(pattern, '');
+            }
+            text = text.replace(/^[\s*\-`,，']+/, '').trim();
+            if (text === before)
+                break;
+        }
+        // 2.5 兜底强化: 剥离后检查是否还有有效内容
+        const firstLineAfterStrip = text.split('\n')[0]?.trim() ?? '';
+        // 条件 A: 文本中包含 commit type（严格模式），保留
+        // 条件 B: 文本中包含 commit type（宽松模式，如 "fix: xxx" 无 scope），保留
+        // 条件 C: 文本首行看起来像有效的 commit 消息且有实际描述内容，保留
+        // 条件 D: 首行很长(> 100 字符)可能是模型在解释，保留首行
+        const hasStrictType = !!text.match(COMMIT_TYPE_PATTERN);
+        const hasLooseType = !!text.match(COMMIT_TYPE_LOOSE_PATTERN);
+        const looksValid = looksLikeValidCommitMessage(text);
+        const firstLineTooLong = firstLineAfterStrip.length > 100;
+        if (!hasStrictType && !hasLooseType && !looksValid && !firstLineTooLong) {
+            logger.info(`[Git/sanitize] 剥离后无有效内容, 返回 fallback. raw=${rawPreview}, afterStrip=${JSON.stringify(text.substring(0, 100))}`);
+            return 'chore: update staged changes';
+        }
+        // 如果剥离后有有效内容但没有 strict commit type，尝试提取首行
+        if (!hasStrictType && (hasLooseType || looksValid || firstLineTooLong)) {
+            text = firstLineAfterStrip || text;
+        }
+    }
+    // 3. 截断到首个空行
+    const firstBlankIndex = text.search(/\n\s*\n/);
+    if (firstBlankIndex > 0) {
+        text = text.slice(0, firstBlankIndex);
+    }
+    // 4. 去掉尾部 markdown 代码块 fence
+    text = text.replace(/\n+\s*```\s*$/g, '').trim();
+    if (!text) {
+        logger.info(`[Git/sanitize] 截断后为空, 返回 fallback. raw=${rawPreview}`);
+        return 'chore: update staged changes';
+    }
+    // 5. 首行超过 100 字符极可能是模型仍在解释,只保留首行
+    const firstLine = text.split('\n')[0]?.trim() ?? '';
+    if (firstLine.length > 100) {
+        logger.info(`[Git/sanitize] 首行超过 100 字符, 仅保留首行. raw=${rawPreview}, firstLine=${JSON.stringify(firstLine.substring(0, 100))}`);
+        return firstLine;
+    }
+    logger.info(`[Git/sanitize] 结果: ${JSON.stringify(text.substring(0, 120))} (from raw=${rawPreview})`);
+    return text;
+}
+/**
+ * 从 OpenAI-compatible SSE chunk 文本中提取增量文本。
+ * 处理:空行 / 缺少 data 字段 / [DONE] 哨兵 / 非 JSON 行的容错。
+ */
+export function extractOpenAiStreamDelta(chunkText) {
+    const lines = chunkText.split(/\r?\n/);
+    let buffer = '';
+    for (const rawLine of lines) {
+        const line = rawLine.trim();
+        if (!line.startsWith('data:'))
+            continue;
+        const data = line.slice(5).trim();
+        if (!data || data === '[DONE]')
+            continue;
+        try {
+            const parsed = JSON.parse(data);
+            const delta = parsed?.choices?.[0]?.delta?.content;
+            if (typeof delta === 'string' && delta.length > 0) {
+                buffer += delta;
+            }
+        }
+        catch {
+            // 忽略单行解析失败,继续读后续 chunk
+        }
+    }
+    return buffer;
+}
+/**
+ * 调试级: 记录 AI stream 的前 N 个 chunk 的完整 JSON 结构,用于诊断
+ * 模型返回格式与标准 OpenAI 格式不同导致 delta 无法提取的问题。
+ */
+export function debugAiStreamChunk(chunkText, index) {
+    if (index > 5)
+        return; // 只记前 5 个
+    const lines = chunkText.split(/\r?\n/);
+    for (const rawLine of lines) {
+        const line = rawLine.trim();
+        if (!line.startsWith('data:'))
+            continue;
+        const data = line.slice(5).trim();
+        if (!data || data === '[DONE]')
+            continue;
+        try {
+            const parsed = JSON.parse(data);
+            const keys = Object.keys(parsed);
+            const choices = parsed?.choices;
+            const firstChoice = Array.isArray(choices) ? choices[0] : null;
+            const deltaKeys = firstChoice?.delta ? Object.keys(firstChoice.delta) : null;
+            const deltaContent = firstChoice?.delta?.content;
+            logger.info(`[Git/extract] chunk#${index} structure: topKeys=${JSON.stringify(keys)}, ` +
+                `choicesLen=${Array.isArray(choices) ? choices.length : typeof choices}, ` +
+                `deltaKeys=${JSON.stringify(deltaKeys)}, content=${JSON.stringify(deltaContent?.substring(0, 50))}, ` +
+                `finishReason=${JSON.stringify(firstChoice?.finish_reason)}`);
+        }
+        catch { /* ignore */ }
+    }
+}
+/**
+ * 调用 OpenAI-compatible API(非流式)生成 Git 提交信息。
+ *
+ * 主流程:组装 prompt → 调 chat/completions → 清洗回复 → 返回。
+ * 保留此接口为同步路径的兜底(测试 / 旧调用方),新场景请优先使用 `streamAiForCommitMessage`。
+ */
+export async function callAiForCommitMessage(aiBaseUrl, aiApiKey, aiModel, diffContent) {
+    const url = `${aiBaseUrl.replace(/\/+$/, '')}/chat/completions`;
     const response = await axios.post(url, {
         model: aiModel,
+        stream: false,
         messages: [
-            { role: 'system', content: systemPrompt },
-            { role: 'user', content: `以下是暂存区代码变更内容，请生成一条 Git 提交信息：\n\n${diffContent}` },
+            { role: 'system', content: COMMIT_MESSAGE_SYSTEM_PROMPT },
+            { role: 'user', content: buildCommitMessageUserPrompt(diffContent) },
         ],
-        max_tokens: 300,
-        temperature: 0.3,
+        max_tokens: 200,
+        temperature: 0.2,
     }, {
         headers: {
             'Content-Type': 'application/json',
@@ -1204,16 +1431,192 @@ export async function callAiForCommitMessage(aiBaseUrl, aiApiKey, aiModel, diffC
     });
     const data = response.data;
     const content = data?.choices?.[0]?.message?.content?.trim() || '';
-    return content || 'AI 生成失败：返回内容为空';
+    return sanitizeCommitMessage(content);
+}
+/**
+ * 流式调用 OpenAI-compatible API 生成 Git 提交信息。
+ *
+ * 主流程:
+ *   1. 发起 stream:true 的 chat/completions 请求
+ *   2. 逐 chunk 解析 SSE,把 delta 文本回调给调用方(`onDelta`)
+ *   3. 全部读取完成后,把累积内容交给 `sanitizeCommitMessage` 清洗
+ *   4. 返回清洗后的最终提交信息
+ *
+ * 入参:
+ *   - onDelta: 每次收到增量时调用,用于把"打字机"效果推给上层
+ *   - abortSignal: 调用方可中止请求(用户取消时使用)
+ */
+export async function streamAiForCommitMessage(aiBaseUrl, aiApiKey, aiModel, diffContent, onDelta, abortSignal) {
+    const url = `${aiBaseUrl.replace(/\/+$/, '')}/chat/completions`;
+    const response = await axios.post(url, {
+        model: aiModel,
+        stream: true,
+        messages: [
+            { role: 'system', content: COMMIT_MESSAGE_SYSTEM_PROMPT },
+            { role: 'user', content: buildCommitMessageUserPrompt(diffContent) },
+        ],
+        max_tokens: 200,
+        temperature: 0.2,
+    }, {
+        headers: {
+            'Content-Type': 'application/json',
+            'Authorization': `Bearer ${aiApiKey}`,
+            'Accept': 'text/event-stream',
+        },
+        timeout: Number(process.env.AWS_AI_STREAM_TIMEOUT_MS) || 60000,
+        responseType: 'stream',
+        signal: abortSignal,
+    });
+    const stream = response.data;
+    let buffer = '';
+    let accumulated = '';
+    let pendingData = '';
+    let onDataChunkCount = 0;
+    let onDataDeltaCount = 0;
+    logger.info(`[Git/streamAi] AI 流开始: aiModel=${aiModel}`);
+    return await new Promise((resolve, reject) => {
+        const finish = (value) => {
+            stream.removeAllListeners('data');
+            stream.removeAllListeners('end');
+            stream.removeAllListeners('error');
+            stream.removeAllListeners('aborted');
+            logger.info(`[Git/streamAi] AI 流结束: totalChunks=${onDataChunkCount}, totalDeltas=${onDataDeltaCount}, bufferLength=${buffer.length}, sanitized=${JSON.stringify(value).substring(0, 200)}`);
+            resolve(value);
+        };
+        stream.on('data', (chunk) => {
+            const text = typeof chunk === 'string' ? chunk : chunk.toString('utf8');
+            onDataChunkCount++;
+            pendingData += text;
+            if (onDataChunkCount <= 3) {
+                logger.info(`[Git/streamAi] chunk#${onDataChunkCount}: length=${text.length}, preview=${JSON.stringify(text.substring(0, 80))}`);
+            }
+            // 调试: 记录前 5 个 chunk 的完整 JSON 结构
+            debugAiStreamChunk(text, onDataChunkCount);
+            // SSE 事件以 \n\n 分隔,逐事件解析
+            const events = pendingData.split(/\n\n/);
+            pendingData = events.pop() ?? '';
+            for (const eventText of events) {
+                const delta = extractOpenAiStreamDelta(eventText);
+                if (delta) {
+                    onDataDeltaCount++;
+                    buffer += delta;
+                    accumulated = sanitizeCommitMessage(buffer);
+                    onDelta(delta, accumulated);
+                }
+            }
+        });
+        stream.on('end', () => {
+            // 处理尾部可能残留的最后一个事件
+            if (pendingData.trim()) {
+                const delta = extractOpenAiStreamDelta(pendingData);
+                if (delta) {
+                    logger.info(`[Git/streamAi] 尾部残留 delta: length=${delta.length}`);
+                    buffer += delta;
+                }
+                else {
+                    logger.info(`[Git/streamAi] 尾部残留无 delta, pendingData=${JSON.stringify(pendingData.substring(0, 100))}`);
+                }
+            }
+            finish(sanitizeCommitMessage(buffer));
+        });
+        stream.on('error', (err) => {
+            logger.error(`[Git/streamAi] 流错误: ${err.message}`);
+            reject(err);
+        });
+        stream.on('aborted', () => {
+            logger.info(`[Git/streamAi] 流被中止, bufferLength=${buffer.length}`);
+            finish(sanitizeCommitMessage(buffer));
+        });
+    });
 }
 /**
- * 根据暂存区文件列表和 AI 源生成提交信息。
+ * 把 git diff --cached 内容聚合成单段文本,限制长度防止超 token。
+ * 供同步和流式两个生成 commit 消息的路由共用。
  *
- * 主干流程：
- *   1. 收集暂存文件路径，对每个文件执行 git diff --cached 获取变更摘要
- *   2. 合并所有文件变更内容
- *   3. 调用外部 AI API 生成提交信息
- *   4. 返回生成的提交信息
+ * 主流程:
+ *   1. 对每个 stagedFile 调用 git diff --cached 收集单文件 diff
+ *   2. 若逐文件均无 diff(可能因路径规整失败),回落到全量 git diff --cached
+ *   3. 拼接并截断(> 15000 字符追加截断标记)
+ *
+ * 返回: { truncatedDiff: string } 表示收集成功,空字符串表示暂存区无变更。
+ */
+async function collectStagedDiffForAi(repositoryPath, workspacePath, stagedFiles) {
+    const context = await resolveGitRepositoryContext(String(repositoryPath || workspacePath).trim());
+    if (!context.hasRepository || !context.repositoryRootPath) {
+        logger.warn(`[Git/collectDiff] 不在 Git 仓库中: workspacePath=${workspacePath}`);
+        return { truncatedDiff: '', error: { status: 400, message: 'workspace is not inside a git repository' } };
+    }
+    const filePaths = stagedFiles
+        .map(f => f.path)
+        .filter(Boolean);
+    logger.info(`[Git/collectDiff] 开始收集 ${filePaths.length} 个暂存文件差异: ${filePaths.join(', ').substring(0, 200)}`);
+    const diffParts = [];
+    for (const filePath of filePaths) {
+        const repositoryRelativePath = resolveRepositoryRelativeFilePath(filePath, context);
+        const result = await execGitCommand(context.repositoryRootPath, [
+            'diff', '--cached', '--', repositoryRelativePath,
+        ]);
+        if (result.exitCode === 0 && result.stdout.trim()) {
+            diffParts.push(`--- ${filePath} ---\n${result.stdout.trim()}`);
+        }
+        else {
+            logger.info(`[Git/collectDiff] 文件无暂存差异或获取失败: ${filePath}, exitCode=${result.exitCode}, stdout.length=${result.stdout.length}`);
+        }
+    }
+    if (diffParts.length === 0) {
+        // Fallback: 尝试获取所有暂存区变更
+        logger.info(`[Git/collectDiff] 逐文件 diff 为空, 回退到全量 diff --cached`);
+        const result = await execGitCommand(context.repositoryRootPath, [
+            'diff', '--cached',
+        ]);
+        if (result.exitCode === 0 && result.stdout.trim()) {
+            diffParts.push(result.stdout.trim());
+            logger.info(`[Git/collectDiff] 全量 diff 获取成功: length=${result.stdout.trim().length}`);
+        }
+        else {
+            logger.info(`[Git/collectDiff] 全量 diff 也为空, exitCode=${result.exitCode}`);
+        }
+    }
+    if (diffParts.length === 0) {
+        logger.info(`[Git/collectDiff] 暂存区没有差异内容 (diffParts 为空)`);
+        return { truncatedDiff: '' };
+    }
+    const diffContent = diffParts.join('\n\n');
+    const maxDiffLength = 15000;
+    const truncatedDiff = diffContent.length > maxDiffLength
+        ? `${diffContent.slice(0, maxDiffLength)}\n...(diff truncated due to length)`
+        : diffContent;
+    logger.info(`[Git/collectDiff] 收集完成: diffContent.length=${diffContent.length}, truncated=${truncatedDiff.length}`);
+    return { truncatedDiff };
+}
+/**
+ * 写入一条 SSE 事件到响应流,失败时吞掉(连接已关闭时不再报错)。
+ *
+ * SSE 要求每条事件数据实时推送到客户端,不能依赖 Node.js 内部流缓冲。
+ * post-flush 保障:
+ *   - res.flushHeaders() 已预先发送响应头,后续 write 直接走 socket
+ *   - socket.setNoDelay(true) 已关闭 Nagle 算法,每次 write 立即经内核发出
+ *   - 额外的 res.write('') + res.flushHeaders() 兜底 flush,
+ *     兼容部分 Node.js 版本/补丁对 _send 的缓冲行为
+ */
+function writeSseEvent(res, event, data) {
+    try {
+        res.write(`event: ${event}\n`);
+        res.write(`data: ${JSON.stringify(data)}\n\n`);
+        // 不调用 res.flushHeaders(): 首次调用已在 SSE 路由开头完成 (L2062)，
+        // 后续调用为 no-op。实时性依赖 socket.setNoDelay(true) + 内核 TCP_NODELAY。
+    }
+    catch {
+        // 连接已断开,忽略
+    }
+}
+/**
+ * 根据暂存区文件列表和 AI 源生成提交信息(同步路径,保留作为旧客户端兜底)。
+ *
+ * 主干流程:
+ *   1. 收集暂存区 diff 内容(由 collectStagedDiffForAi 完成)
+ *   2. 调用非流式 AI 接口生成完整提交信息
+ *   3. 返回清洗后的文本
  *
  * POST /runtime/git/generate-commit-message
  */
@@ -1232,51 +1635,137 @@ gitRouter.post('/git/generate-commit-message', validateToken, async (req, res) =
         return;
     }
     try {
-        const context = await resolveGitRepositoryContext(String(repositoryPath || workspacePath).trim());
-        if (!context.hasRepository || !context.repositoryRootPath) {
-            res.status(400).json({ error: 'workspace is not inside a git repository' });
+        const { truncatedDiff, error } = await collectStagedDiffForAi(String(repositoryPath || ''), String(workspacePath), stagedFiles);
+        if (error) {
+            res.status(error.status).json({ error: error.message });
             return;
         }
-        // 为每个暂存文件获取 staged diff
-        const filePaths = stagedFiles
-            .map(f => f.path)
-            .filter(Boolean);
-        const diffParts = [];
-        for (const filePath of filePaths) {
-            const repositoryRelativePath = resolveRepositoryRelativeFilePath(filePath, context);
-            const result = await execGitCommand(context.repositoryRootPath, [
-                'diff', '--cached', '--', repositoryRelativePath,
-            ]);
-            if (result.exitCode === 0 && result.stdout.trim()) {
-                diffParts.push(`--- ${filePath} ---\n${result.stdout.trim()}`);
-            }
-        }
-        if (diffParts.length === 0) {
-            // Fallback: 尝试获取所有暂存区变更
-            const result = await execGitCommand(context.repositoryRootPath, [
-                'diff', '--cached',
-            ]);
-            if (result.exitCode === 0 && result.stdout.trim()) {
-                diffParts.push(result.stdout.trim());
-            }
-        }
-        if (diffParts.length === 0) {
+        if (!truncatedDiff) {
             res.json({ message: '暂存区没有变更内容' });
             return;
         }
-        const diffContent = diffParts.join('\n\n');
-        // 限制 diff 长度，防止超过 token 限制
-        const maxDiffLength = 15000;
-        const truncatedDiff = diffContent.length > maxDiffLength
-            ? diffContent.slice(0, maxDiffLength) + '\n...(diff truncated due to length)'
-            : diffContent;
         const generatedMessage = await callAiForCommitMessage(aiBaseUrl, aiApiKey, aiModel, truncatedDiff);
         res.json({ message: generatedMessage });
     }
-    catch (error) {
-        const err = error;
-        logger.error(`[Git] generate commit message failed: ${err.message}`);
-        res.status(500).json({ error: err.message || 'generate commit message failed' });
+    catch (err) {
+        const error = err;
+        logger.error(`[Git] generate commit message failed: ${error.message}`);
+        res.status(500).json({ error: error.message || 'generate commit message failed' });
+    }
+});
+/**
+ * 流式 SSE 版本:把 AI 生成过程以 delta 事件持续推给前端,实现打字机效果。
+ *
+ * 主干流程:
+ *   1. 收集暂存区 diff(共用 collectStagedDiffForAi)
+ *   2. 设置 SSE 响应头(res.writeHead + chunked transfer)
+ *   3. 调 streamAiForCommitMessage,每收到一段 delta 立刻 write 一条 SSE 事件
+ *      delta 事件 data 包含 contentDelta(原始增量)与 message(经过 sanitize 的累计内容)
+ *   4. AI 完成后写一条 done 事件,data 包含最终 message
+ *   5. 任何异常写一条 error 事件,前端据此退出"生成中"状态
+ *
+ * POST /runtime/git/generate-commit-message-stream
+ */
+gitRouter.post('/git/generate-commit-message-stream', validateToken, async (req, res) => {
+    const { workspacePath, repositoryPath, stagedFiles, aiBaseUrl, aiApiKey, aiModel } = req.body || {};
+    if (!workspacePath || !String(workspacePath).trim()) {
+        res.status(400).json({ error: 'workspacePath is required' });
+        return;
+    }
+    if (!Array.isArray(stagedFiles) || stagedFiles.length === 0) {
+        res.status(400).json({ error: 'stagedFiles is required and must be a non-empty array' });
+        return;
+    }
+    if (!aiBaseUrl || !String(aiBaseUrl).trim() || !aiApiKey || !String(aiApiKey).trim() || !aiModel || !String(aiModel).trim()) {
+        res.status(400).json({ error: 'aiBaseUrl, aiApiKey and aiModel are required' });
+        return;
+    }
+    logger.info(`[Git/SSE] 收到 generate-commit-message-stream 请求: workspacePath=${String(workspacePath || '').substring(0, 40)}, ` +
+        `stagedFiles=${stagedFiles?.length ?? 0}, aiModel=${aiModel}, aiBaseUrl=${aiBaseUrl}`);
+    // 设置 SSE 响应头(必须在 write 任何数据前完成)
+    res.status(200);
+    res.setHeader('Content-Type', 'text/event-stream; charset=utf-8');
+    res.setHeader('Cache-Control', 'no-cache, no-transform');
+    res.setHeader('Connection', 'keep-alive');
+    res.setHeader('X-Accel-Buffering', 'no');
+    // 禁用 Nagle 算法: SSE 每条数据都很小(< 1460 bytes),默认 TCP_NODELAY=false
+    // 会导致内核延迟发送,将多个小数据包合并后再发出,造成前端 SSE 事件接收延迟甚至超时。
+    // 设置 true 后每次 write 立即经内核发送,不等待合并,确保事件实时到达。
+    req.socket?.setNoDelay(true);
+    res.flushHeaders?.();
+    // 客户端中断时主动中止上游 AI 请求
+    let aborted = false;
+    let abortController = null;
+    let responseFinished = false;
+    const sseEventCount = { delta: 0 };
+    const requestPeer = `${req.ip}:${req.socket?.remotePort ?? '?'}`;
+    req.on('close', () => {
+        if (!aborted) {
+            aborted = true;
+            // 即使连接断开，也不主动 abort AI 请求 — 让 AI 调用自然完成，
+            // 之后同步 API 兜底时可能命中缓存（某些 AI provider 有结果缓存）。
+            // 但若 abortController 已在后续创建，仍可安全终止。
+            logger.info(`[Git/SSE] 客户端断开连接: workspacePath=${String(workspacePath || '').substring(0, 40)}, deltaEventsSent=${sseEventCount.delta}, peer=${requestPeer}`);
+        }
+    });
+    // 发送一条 init SSE 事件, 确保响应体已有数据输出。
+    // 目的: 让 Java 后端确认连接活跃,
+    // 避免 HTTP 客户端在收到 SSE 响应头后、collectDiff/AI 输出前因
+    // 无数据到达而关闭连接。
+    writeSseEvent(res, 'init', { status: 'generating' });
+    try {
+        const { truncatedDiff, error } = await collectStagedDiffForAi(String(repositoryPath || ''), String(workspacePath), stagedFiles);
+        if (error) {
+            logger.warn(`[Git/SSE] collectStagedDiffForAi 返回错误: ${error.message}`);
+            writeSseEvent(res, 'error', { message: error.message });
+            res.end();
+            return;
+        }
+        if (!truncatedDiff) {
+            logger.info(`[Git/SSE] 暂存区没有变更内容, 直接返回 done`);
+            writeSseEvent(res, 'delta', { contentDelta: '', message: '暂存区没有变更内容' });
+            writeSseEvent(res, 'done', { message: '暂存区没有变更内容' });
+            res.end();
+            return;
+        }
+        logger.info(`[Git/SSE] 收集到 diff: truncatedDiff.length=${truncatedDiff.length}`);
+        if (aborted) {
+            // init 事件已在 collectDiff 前发出, 但客户端在此期间断开了连接。
+            // 不跳过早退: 因为 writeSseEvent 的 try/catch 会吞掉已断开连接的写入错误,
+            // 继续执行 streamAiForCommitMessage 不会造成额外负面影响。
+            // 让 AI 调用完成并尝试发送 done 事件, 这样如果客户端重连或中间代理恢复,
+            // 仍有可能收到完整的提交信息。
+            logger.info(`[Git/SSE] 客户端在 collectDiff 期间断开, 但仍尝试 AI 调用`);
+        }
+        logger.info(`[Git/SSE] 开始调用 AI streamAiForCommitMessage: aiModel=${aiModel}`);
+        // 在 AI 调用前才创建 AbortController, 避免 req.on('close') 在 collectDiff 期间
+        // 提前 abort 尚未开始的 AI 请求
+        abortController = new AbortController();
+        let lastEmitted = '';
+        const finalMessage = await streamAiForCommitMessage(aiBaseUrl, aiApiKey, aiModel, truncatedDiff, (delta, accumulated) => {
+            sseEventCount.delta++;
+            // 仅在 sanitize 后的内容相对上次发送有变化时再推送,避免重复渲染
+            if (accumulated !== lastEmitted) {
+                lastEmitted = accumulated;
+                writeSseEvent(res, 'delta', { contentDelta: delta, message: accumulated });
+            }
+            else {
+                writeSseEvent(res, 'delta', { contentDelta: delta, message: accumulated });
+            }
+        }, abortController.signal);
+        logger.info(`[Git/SSE] AI streamAiForCommitMessage 完成: finalMessage=${JSON.stringify(finalMessage).substring(0, 200)}, deltaEventsSent=${sseEventCount.delta}`);
+        if (!aborted) {
+            writeSseEvent(res, 'done', { message: finalMessage });
+        }
+        res.end();
+    }
+    catch (err) {
+        const error = err;
+        logger.error(`[Git/SSE] stream commit message failed: ${error.message}${error.stack ? '\n' + error.stack : ''}`);
+        if (!aborted) {
+            writeSseEvent(res, 'error', { message: error.message || 'generate commit message failed' });
+        }
+        res.end();
     }
 });
 /**
@@ -1379,3 +1868,33 @@ gitRouter.post('/git/restore-files', validateToken, async (req, res) => {
         res.status(500).json({ error: err.message || 'git restore files failed' });
     }
 });
+/**
+ * 获取暂存区文件差异内容（纯 diff 文本，不调用 AI）。
+ * 供 Java 后端直接调用 AI 时使用，避免 AI API 密钥经由 bridge 转发。
+ *
+ * POST /runtime/git/diff-content
+ */
+gitRouter.post('/git/diff-content', validateToken, async (req, res) => {
+    const { workspacePath, repositoryPath, stagedFiles } = req.body || {};
+    if (!workspacePath || !String(workspacePath).trim()) {
+        res.status(400).json({ error: 'workspacePath is required' });
+        return;
+    }
+    if (!Array.isArray(stagedFiles) || stagedFiles.length === 0) {
+        res.status(400).json({ error: 'stagedFiles is required and must be a non-empty array' });
+        return;
+    }
+    try {
+        const { truncatedDiff, error } = await collectStagedDiffForAi(String(repositoryPath || ''), String(workspacePath), stagedFiles);
+        if (error) {
+            res.status(error.status).json({ error: error.message });
+            return;
+        }
+        res.json({ ok: true, diff: truncatedDiff || '' });
+    }
+    catch (err) {
+        const error = err;
+        logger.error(`[Git/diff-content] 获取暂存区差异失败: ${error.message}`);
+        res.status(500).json({ error: error.message || 'get diff content failed' });
+    }
+});