Issue 概要

issue：#1，标题“测试测试”，状态 open
版本 / 分支 / 环境：
- 失败复现 1：2026-03-19 06:52:20 UTC，issues 事件，run 23283418220，main 分支，提交 e10afb2f97c6b20ed53c45dcbde49542f47b69ac
- 失败复现 2：2026-03-19 06:54:55 UTC，issue_comment 事件，run 23283488426，同一提交 e10afb2f97c6b20ed53c45dcbde49542f47b69ac
- 当前观察到的新运行：2026-06-08 10:12:48 UTC，workflow_dispatch，codex 分支，提交 db4001425f13dead3eeb33af4daafc66a9341d20，读取时仍为 in_progress
任务 / 入口 / 相关设置：AI Issue Analysis composite action；早期版本使用 Copilot CLI 和 copilot_answer.md，当前分支已切到 Codex CLI 和 answer.md
关键提示 / 报错文案：
- Copilot did not produce a final answer file: copilot_answer.md
- Copilot answer file not found: copilot_answer.md
用户现象：Issue 正文只给了一个 MaaEnd 代码链接作为测试输入；action 创建评论后未产出最终分析结论，评论中只显示“未生成最终答案文件”。

附件概览

实际可读文件：
- Issue 正文和 4 条评论
- 3 次 GitHub Actions run 的公开元数据
- 失败 run 的 job 元数据和 artifact 列表
- 当前仓库 action.yml、README.md
- 失败 run 对应提交 e10afb2f97c6b20ed53c45dcbde49542f47b69ac 的 action.yml
- Issue 正文链接到的 MaaEnd Button.json 片段
缺失或未上传的证据：
- artifact zip 下载需要 GitHub 认证，无法直接读取 copilot-output-* 和 final-conclusion-* 的内容。
- 公开评论里的折叠分析过程为空，因此没有 Copilot CLI 原始 stderr/stdout 细节。

关键证据

点击此处展开

issue 正文 / 评论：
- Issue 正文只有一个外部代码链接：https://github.com/MaaEnd/MaaEnd/blob/f2de4c61367ad03d4d8a13ce823139c6237f2a55/assets/resource/pipeline/Common/Button.json#L14-L20
- 2026-03-19 06:52:26 UTC 的 bot 评论显示：Copilot did not produce a final answer file: copilot_answer.md
- 2026-03-19 06:54:52 UTC 用户评论为 @github-actions
- 2026-03-19 06:55:01 UTC 的 bot 评论再次显示：Copilot did not produce a final answer file: copilot_answer.md
Actions 元数据：
- run 23283418220：event=issues，status=completed，conclusion=failure，head commit e10afb2f97c6b20ed53c45dcbde49542f47b69ac
- run 23283488426：event=issue_comment，status=completed，conclusion=failure，head commit 同上
- run 27130782272：event=workflow_dispatch，head commit db4001425f13dead3eeb33af4daafc66a9341d20，读取时 status=in_progress
Artifact 元数据：
- 两次失败 run 都生成了 copilot-output-issue-1-comment-* 和 final-conclusion-issue-1-comment-*，但体积很小，且最终评论仍是“未生成答案文件”。

代码依据：

失败提交的默认答案文件为 copilot_answer.md：

ai-issue-analysis/action.yml

Lines 59 to 62 in e10afb2

    
           copilot-answer-file: 
        
             description: File path where the prompt asks Copilot to write the final answer. 
        
             required: false 
        
             default: copilot_answer.md

失败提交把 {{copilot_answer_file}} 注入 prompt：

ai-issue-analysis/action.yml

Lines 155 to 190 in e10afb2

    
               - name: Build analysis prompt 
        
                 shell: bash 
        
                 env: 
        
                   EVENT_NAME: ${{ github.event_name }} 
        
                   ISSUE_NUMBER: ${{ steps.issue_number.outputs.issue_number }} 
        
                   BOT_NAME: ${{ inputs.bot-name }} 
        
                   ANALYSIS_PROMPT_FILE: ${{ steps.runtime.outputs.analysis_prompt_file }} 
        
                   COPILOT_ANSWER_FILE: ${{ inputs.copilot-answer-file }} 
        
                   PROMPT_TEMPLATE: ${{ inputs.prompt-template }} 
        
                   COMMENT_PROMPT_TEMPLATE: ${{ inputs.comment-prompt-template }} 
        
                   REPOSITORY: ${{ github.repository }} 
        
                 run: | 
        
                   python <<'PY' 
        
                   import json 
        
                   import os 
        
                   import re 
        
                   from pathlib import Path 
        
                   event_name = os.environ["EVENT_NAME"] 
        
                   issue_number = os.environ["ISSUE_NUMBER"] 
        
                   bot_name = os.environ["BOT_NAME"] 
        
                   analysis_prompt_file = Path(os.environ["ANALYSIS_PROMPT_FILE"]) 
        
                   copilot_answer_file = os.environ["COPILOT_ANSWER_FILE"] 
        
                   prompt_template = os.environ["PROMPT_TEMPLATE"] 
        
                   comment_prompt_template = os.environ["COMMENT_PROMPT_TEMPLATE"] 
        
                   repository = os.environ["REPOSITORY"] 
        
                   event = json.loads(Path(os.environ["GITHUB_EVENT_PATH"]).read_text(encoding="utf-8")) 
        
                   raw_comment = "" 
        
                   if event_name == "issue_comment": 
        
                       raw_comment = event.get("comment", {}).get("body", "") 
        
                   cleaned_comment = raw_comment 
        
                   if bot_name: 
        
                       cleaned_comment = re.sub(rf"{re.escape(bot_name)}\b", "", cleaned_comment, flags=re.IGNORECASE) 
        
                   cleaned_comment = re.sub(r"^[\s,，.。!！?？:：]+", "", cleaned_comment).strip()

失败提交运行 Copilot CLI，并等待该进程结束：

ai-issue-analysis/action.yml

Lines 249 to 340 in e10afb2

    
               - name: Run Copilot analysis with streaming updates 
        
                 shell: bash 
        
                 env: 
        
                   COPILOT_GITHUB_TOKEN: ${{ steps.resolve_copilot_token.outputs.copilot_token }} 
        
                   GITHUB_TOKEN: ${{ inputs.github-token }} 
        
                   GITHUB_SERVER_URL: ${{ github.server_url }} 
        
                   COMMENT_ID: ${{ steps.initial_comment.outputs.comment-id }} 
        
                   ISSUE_NUMBER: ${{ steps.issue_number.outputs.issue_number }} 
        
                   REPO: ${{ github.repository }} 
        
                   ANALYSIS_PROMPT_FILE: ${{ steps.runtime.outputs.analysis_prompt_file }} 
        
                   OUTPUT_FILE: ${{ steps.runtime.outputs.copilot_output_file }} 
        
                   EXECUTION_LOG_FILE: ${{ steps.runtime.outputs.copilot_execution_log_file }} 
        
                   BODY_FILE: ${{ steps.runtime.outputs.comment_body_file }} 
        
                   INITIAL_BODY: ${{ inputs.initial-comment-body }} 
        
                   ACTION_LINK: ${{ steps.runtime.outputs.action_link }} 
        
                   DETAILS_BEGIN: ${{ steps.runtime.outputs.details_begin }} 
        
                   DETAILS_END: ${{ steps.runtime.outputs.details_end }} 
        
                   COPILOT_MODEL: ${{ inputs.copilot-model }} 
        
                   COPILOT_REASONING_EFFORT: ${{ inputs.copilot-reasoning-effort }} 
        
                   STREAM_UPDATE_INTERVAL: ${{ inputs.stream-update-interval-seconds }} 
        
                 run: | 
        
                   COMMENT_URL="$GITHUB_SERVER_URL/$REPO/issues/$ISSUE_NUMBER#issuecomment-$COMMENT_ID" 
        
                   : > "$OUTPUT_FILE" 
        
                   : > "$EXECUTION_LOG_FILE" 
        
                   { 
        
                     echo "Copilot invocation parameters:" 
        
                     echo "  repo: $REPO" 
        
                     echo "  issue-number: $ISSUE_NUMBER" 
        
                     echo "  comment-id: $COMMENT_ID" 
        
                     echo "  comment-url: $COMMENT_URL" 
        
                     echo "  model: $COPILOT_MODEL" 
        
                     echo "  reasoning-effort: $COPILOT_REASONING_EFFORT" 
        
                     echo "  copilot-token-count: ${{ steps.resolve_copilot_token.outputs.copilot_token_count }}" 
        
                     echo "  stream-update-interval-seconds: $STREAM_UPDATE_INTERVAL" 
        
                     echo "  analysis-prompt-file: $ANALYSIS_PROMPT_FILE" 
        
                     echo "  output-file: $OUTPUT_FILE" 
        
                     echo "  body-file: $BODY_FILE" 
        
                     echo "  command: copilot --yolo --model \"$COPILOT_MODEL\" --reasoning-effort \"$COPILOT_REASONING_EFFORT\" --prompt \"<contents of $ANALYSIS_PROMPT_FILE>\"" 
        
                     echo "Prompt content begins" 
        
                     cat "$ANALYSIS_PROMPT_FILE" 
        
                     echo "Prompt content ends" 
        
                   } | tee -a "$EXECUTION_LOG_FILE" 
        
                   copilot --yolo --model "$COPILOT_MODEL" --reasoning-effort "$COPILOT_REASONING_EFFORT" \ 
        
                     --prompt "$(cat "$ANALYSIS_PROMPT_FILE")" > "$OUTPUT_FILE" 2>&1 & 
        
                   COPILOT_PID=$! 
        
                   echo "Copilot started with PID $COPILOT_PID" | tee -a "$EXECUTION_LOG_FILE" 
        
                   last_content="" 
        
                   while true; do 
        
                     sleep "$STREAM_UPDATE_INTERVAL" & 
        
                     sleep_pid=$! 
        
                     wait -n "$COPILOT_PID" "$sleep_pid" 2>/dev/null || true 
        
                     if ! kill -0 "$COPILOT_PID" 2>/dev/null; then 
        
                       kill "$sleep_pid" 2>/dev/null || true 
        
                       break 
        
                     fi 
        
                     if [ -f "$OUTPUT_FILE" ]; then 
        
                       current_content=$(cat "$OUTPUT_FILE") 
        
                       if [ "$current_content" != "$last_content" ] && [ -n "$current_content" ]; then 
        
                         { 
        
                           echo "$INITIAL_BODY" 
        
                           echo 
        
                           echo "---" 
        
                           echo 
        
                           echo "$DETAILS_BEGIN" 
        
                           echo "$current_content" 
        
                           echo "$DETAILS_END" 
        
                           echo 
        
                           echo "$ACTION_LINK" 
        
                         } > "$BODY_FILE" 
        
                         jq -n --arg body "$(cat "$BODY_FILE")" '{"body":$body}' | \ 
        
                           curl -s -L -X PATCH \ 
        
                             -H "Authorization: token $GITHUB_TOKEN" \ 
        
                             -H "Accept: application/vnd.github.v3+json" \ 
        
                             "https://api.github.com/repos/$REPO/issues/comments/$COMMENT_ID" \ 
        
                             -d @- 
        
                         last_content="$current_content" 
        
                         echo "Comment updated at $(date)" 
        
                       fi 
        
                     fi 
        
                   done 
        
                   wait "$COPILOT_PID"

失败提交在没有 copilot_answer.md 时写入最终评论占位文本：

ai-issue-analysis/action.yml

Lines 351 to 400 in e10afb2

    
               - name: Full analysis 
        
                 if: ${{ always() }} 
        
                 shell: bash 
        
                 env: 
        
                   COPILOT_OUTPUT_FILE: ${{ steps.runtime.outputs.copilot_execution_log_file }} 
        
                   COPILOT_ANSWER_FILE: ${{ inputs.copilot-answer-file }} 
        
                 run: | 
        
                   if [ -f "$COPILOT_OUTPUT_FILE" ]; then 
        
                     cat "$COPILOT_OUTPUT_FILE" 
        
                   fi 
        
                   echo 
        
                   echo "---" 
        
                   echo 
        
                   if [ -f "$COPILOT_ANSWER_FILE" ]; then 
        
                     cat "$COPILOT_ANSWER_FILE" 
        
                   else 
        
                     echo "Copilot answer file not found: $COPILOT_ANSWER_FILE" 
        
                   fi 
        
               - name: Prepare final comment 
        
                 if: ${{ always() }} 
        
                 shell: bash 
        
                 env: 
        
                   COPILOT_ANSWER_FILE: ${{ inputs.copilot-answer-file }} 
        
                   COPILOT_OUTPUT_FILE: ${{ steps.runtime.outputs.copilot_output_file }} 
        
                   FINAL_COMMENT_FILE: ${{ steps.runtime.outputs.final_comment_file }} 
        
                   ACTION_LINK: ${{ steps.runtime.outputs.action_link }} 
        
                   DETAILS_BEGIN: ${{ steps.runtime.outputs.details_begin }} 
        
                   DETAILS_END: ${{ steps.runtime.outputs.details_end }} 
        
                 run: | 
        
                   : > "$FINAL_COMMENT_FILE" 
        
                   if [ -f "$COPILOT_ANSWER_FILE" ]; then 
        
                     cat "$COPILOT_ANSWER_FILE" >> "$FINAL_COMMENT_FILE" 
        
                   else 
        
                     echo "Copilot did not produce a final answer file: $COPILOT_ANSWER_FILE" >> "$FINAL_COMMENT_FILE" 
        
                   fi 
        
                   { 
        
                     echo 
        
                     echo "---" 
        
                     echo 
        
                     echo "$DETAILS_BEGIN" 
        
                     if [ -f "$COPILOT_OUTPUT_FILE" ]; then 
        
                       cat "$COPILOT_OUTPUT_FILE" 
        
                     fi 
        
                     echo "$DETAILS_END" 
        
                     echo 
        
                     echo "$ACTION_LINK" 
        
                   } >> "$FINAL_COMMENT_FILE"

当前分支默认答案文件已改为 answer.md：

ai-issue-analysis/action.yml

Lines 63 to 66 in db40014

    
           answer-file: 
        
             description: File path where the prompt asks the AI to write the final answer. 
        
             required: false 
        
             default: answer.md

当前分支已把 prompt 变量改为 {{answer_file}}，并运行 codex exec：

ai-issue-analysis/action.yml

Lines 216 to 232 in db40014

    
                   def render(template: str) -> str: 
        
                       return ( 
        
                           template 
        
                           .replace("{{issue_number}}", issue_number) 
        
                           .replace("{{answer_file}}", answer_file) 
        
                           .replace("{{comment_body}}", cleaned_comment) 
        
                           .replace("{{repository}}", repository) 
        
                           .replace("{{event_name}}", event_name) 
        
                       ) 
        
                   prompt = render(prompt_template).strip() 
        
                   extra_prompt = render(comment_prompt_template).strip() if cleaned_comment else "" 
        
                   if extra_prompt: 
        
                       prompt = f"{prompt}\n\n{extra_prompt}" if prompt else extra_prompt 
        
                   analysis_prompt_file.write_text(f"{prompt}\n", encoding="utf-8")

、

ai-issue-analysis/action.yml

Lines 301 to 405 in db40014

    
               - name: Run Codex analysis with streaming updates 
        
                 shell: bash 
        
                 env: 
        
                   CODEX_API_KEY: ${{ steps.resolve_codex_key.outputs.codex_api_key }} 
        
                   COMMENT_GITHUB_TOKEN: ${{ inputs.github-token }} 
        
                   GITHUB_SERVER_URL: ${{ github.server_url }} 
        
                   COMMENT_ID: ${{ steps.initial_comment.outputs.comment-id }} 
        
                   ISSUE_NUMBER: ${{ steps.issue_number.outputs.issue_number }} 
        
                   REPO: ${{ github.repository }} 
        
                   ANALYSIS_PROMPT_FILE: ${{ steps.runtime.outputs.analysis_prompt_file }} 
        
                   OUTPUT_FILE: ${{ steps.runtime.outputs.codex_output_file }} 
        
                   EXECUTION_LOG_FILE: ${{ steps.runtime.outputs.codex_execution_log_file }} 
        
                   BODY_FILE: ${{ steps.runtime.outputs.comment_body_file }} 
        
                   INITIAL_BODY: ${{ inputs.initial-comment-body }} 
        
                   ACTION_LINK: ${{ steps.runtime.outputs.action_link }} 
        
                   DETAILS_BEGIN: ${{ steps.runtime.outputs.details_begin }} 
        
                   DETAILS_END: ${{ steps.runtime.outputs.details_end }} 
        
                   CODEX_MODEL: ${{ inputs.codex-model }} 
        
                   STREAM_UPDATE_INTERVAL: ${{ inputs.stream-update-interval-seconds }} 
        
                   EXTRA_COMMENT_CONTENT: ${{ inputs.extra-comment-content }} 
        
                 run: | 
        
                   COMMENT_URL="$GITHUB_SERVER_URL/$REPO/issues/$ISSUE_NUMBER#issuecomment-$COMMENT_ID" 
        
                   : > "$OUTPUT_FILE" 
        
                   : > "$EXECUTION_LOG_FILE" 
        
                   { 
        
                     echo "Codex invocation parameters:" 
        
                     echo "  repo: $REPO" 
        
                     echo "  issue-number: $ISSUE_NUMBER" 
        
                     echo "  comment-id: $COMMENT_ID" 
        
                     echo "  comment-url: $COMMENT_URL" 
        
                     echo "  model: $CODEX_MODEL" 
        
                     echo "  api-key-count: ${{ steps.resolve_codex_key.outputs.codex_key_count }}" 
        
                     echo "  stream-update-interval-seconds: $STREAM_UPDATE_INTERVAL" 
        
                     echo "  analysis-prompt-file: $ANALYSIS_PROMPT_FILE" 
        
                     echo "  output-file: $OUTPUT_FILE" 
        
                     echo "  body-file: $BODY_FILE" 
        
                     echo "  codex config:" 
        
                     cat ~/.codex/config.toml 
        
                     echo "  command: codex exec --dangerously-bypass-approvals-and-sandbox \"<contents of $ANALYSIS_PROMPT_FILE>\"" 
        
                     echo "Prompt content begins" 
        
                     cat "$ANALYSIS_PROMPT_FILE" 
        
                     echo "Prompt content ends" 
        
                   } | tee -a "$EXECUTION_LOG_FILE" 
        
                   codex exec --dangerously-bypass-approvals-and-sandbox \ 
        
                     "$(cat "$ANALYSIS_PROMPT_FILE")" > "$OUTPUT_FILE" 2>&1 & 
        
                   CODEX_PID=$! 
        
                   echo "Codex started with PID $CODEX_PID" | tee -a "$EXECUTION_LOG_FILE" 
        
                   last_content="" 
        
                   while true; do 
        
                     sleep "$STREAM_UPDATE_INTERVAL" & 
        
                     sleep_pid=$! 
        
                     wait -n "$CODEX_PID" "$sleep_pid" 2>/dev/null || true 
        
                     if ! kill -0 "$CODEX_PID" 2>/dev/null; then 
        
                       kill "$sleep_pid" 2>/dev/null || true 
        
                       break 
        
                     fi 
        
                     if [ -f "$OUTPUT_FILE" ]; then 
        
                       current_content=$(cat "$OUTPUT_FILE") 
        
                       if [ "$current_content" != "$last_content" ] && [ -n "$current_content" ]; then 
        
                         truncated_content="$current_content" 
        
                         if [ "${#truncated_content}" -gt 55000 ]; then 
        
                           truncated_content="${truncated_content:0:55000}"$'\n\n[truncated for comment size limit]' 
        
                         fi 
        
                         { 
        
                           echo "$INITIAL_BODY" 
        
                           echo 
        
                           echo "---" 
        
                           echo 
        
                           echo "$DETAILS_BEGIN" 
        
                           echo 
        
                           echo '```text' 
        
                           echo "$truncated_content" 
        
                           echo '```' 
        
                           echo 
        
                           echo "$DETAILS_END" 
        
                           echo 
        
                           echo "$ACTION_LINK" 
        
                           if [ -n "$EXTRA_COMMENT_CONTENT" ]; then 
        
                             echo 
        
                             echo "$EXTRA_COMMENT_CONTENT" 
        
                           fi 
        
                         } > "$BODY_FILE" 
        
                         jq -Rs '{"body":.}' < "$BODY_FILE" | \ 
        
                           curl -s -L -X PATCH \ 
        
                             -H "Authorization: token $COMMENT_GITHUB_TOKEN" \ 
        
                             -H "Accept: application/vnd.github.v3+json" \ 
        
                             "https://api.github.com/repos/$REPO/issues/comments/$COMMENT_ID" \ 
        
                             -d @- 
        
                         last_content="$current_content" 
        
                         echo "Comment updated at $(date)" 
        
                       fi 
        
                     fi 
        
                   done 
        
                   wait "$CODEX_PID" 
        
                   CODEX_EXIT=$?

根因判断

直接结论：Issue 测试测试 #1 的两次历史失败不是 MaaEnd Button.json 片段本身的问题，而是当时 ai-issue-analysis 的 Copilot 版 action 没有生成约定的最终答案文件 copilot_answer.md，导致最终评论只能输出 fallback 文案，并使 workflow 失败。
证据链：
- 两次失败 run 都发生在同一提交 e10afb2f97c6b20ed53c45dcbde49542f47b69ac。
- 该提交明确要求 Copilot 把最终结论写入 copilot_answer.md。
- 该提交的最终评论逻辑在文件不存在时固定写出 Copilot did not produce a final answer file: copilot_answer.md。
- Issue 评论实际出现的文案与这段 fallback 逻辑完全一致。
- 公开元数据只能证明 job 失败和答案文件缺失；由于 artifact 内容无法匿名下载，不能进一步确认 Copilot CLI 失败的底层原因是认证、CLI 参数、模型名、网络，还是模型未按 prompt 写文件。
当前主线是否可能已修复：
- 当前 codex 分支已从 Copilot CLI 迁移到 Codex CLI，答案文件也改为 answer.md，这避开了早期 copilot_answer.md 路径和 Copilot CLI 流程。
- 但 2026-06-08 的最新 run 在读取时仍为 in_progress，尚不能仅凭当前公开信息确认问题已经完全修复。

修复方案

代码 / 配置 / 资源层修复
- 保持 prompt 中的答案文件变量、运行时检查文件、artifact 导出文件三处完全一致。
- 对 AI 进程退出码做显式记录和传播；当前 Codex 版已记录 CODEX_EXIT，建议在最终评论中也展示“AI 进程失败 / 答案文件缺失”的更具体原因。
- 如果继续支持旧 Copilot 版，需要下载失败 run 的 copilot-output artifact，确认 Copilot CLI 失败点后再修复 CLI 参数、认证或模型配置。
需要补充的测试、日志或截图
- 增加一个最小 workflow 测试：给一个固定 issue number 和 mock prompt，验证最终确实生成 answer.md 并上传 final-conclusion-* artifact。
- 在最终评论中保留 AI 命令退出码、答案文件路径、工作目录和输出文件路径，避免只有“未生成文件”的弱提示。
如问题属于不支持场景，应如何限制入口或改进提示
- 如果某些触发事件没有足够上下文或 token 权限，应在 action 开始阶段直接 fail fast，并给出缺失输入名，而不是等 AI 运行后才表现为答案文件缺失。

给用户的建议

用户现在可以直接尝试的动作：
- 重新触发当前 codex 分支上的 workflow，等 run 27130782272 完成后查看最终评论和 artifacts。
- 如果仍失败，优先查看 codex-output-issue-1-comment-* artifact 中的 Codex exit code 和 stderr。
是否建议升级 / 重下完整包 / 重置配置 / 更换环境：
- 建议使用当前 Codex 版 action，而不是 2026-03-19 的 Copilot 版提交。
- 调用方配置需要同步改为当前输入名：codex-api-key、codex-base-url、codex-model、answer-file，不要继续传旧的 copilot-* 输入。
是否有临时绕过方案：
- 可以把 answer-file 显式设为 answer.md，并在 prompt-template 中明确写“把最终结论写到 {{answer_file}}”。
- 如果只想避免空最终评论，可把 result-error-message 设置为包含排查指引的自定义文案。

给修复 AI 的建议（可复制）

点击此处展开

现象：
Issue #1 的 AI 分析 workflow 运行失败，最终评论显示没有生成最终答案文件。

关键证据：
2026-03-19 两次失败 run 的 bot 评论都显示：
Copilot did not produce a final answer file: copilot_answer.md

失败 run：
- 23283418220，event=issues，commit=e10afb2f97c6b20ed53c45dcbde49542f47b69ac，conclusion=failure
- 23283488426，event=issue_comment，同一 commit，conclusion=failure

失败提交 action.yml：
- 默认 copilot-answer-file 为 copilot_answer.md
- prompt 使用 {{copilot_answer_file}}
- 最终评论逻辑在文件不存在时写出上述 fallback 文案

可能相关线索（待验证）：
底层原因还需读取 copilot-output artifact。公开证据只能确认“AI 进程没有产出约定文件”，不能确认是 Copilot CLI 认证、模型名、参数、网络、权限，还是模型未按 prompt 写文件。
当前 codex 分支已迁移到 answer.md/Codex CLI，应验证最新 run 是否成功生成 answer.md。

置信度

中
已能高置信确认的部分：两次历史失败的直接原因是 copilot_answer.md 未生成，最终评论来自 action 的 fallback 分支。
还缺什么证据：失败 run 的完整 copilot-output artifact 或 job log，用于判断 Copilot CLI 未生成文件的底层原因；2026-06-08 最新 Codex run 的完成状态和最终 artifact，用于判断当前分支是否完全修复。

点击此处展开分析过程

Reading additional input from stdin...
OpenAI Codex v0.137.0
--------
workdir: /home/runner/work/ai-issue-analysis/ai-issue-analysis
model: gpt-5.5
provider: custom
approval: never
sandbox: danger-full-access
reasoning effort: none
reasoning summaries: none
session id: 019ea6b8-b656-7ec1-bffa-5cc57aab593d
--------
user
分析 GitHub Issue 1。把最终结论写到 answer.md。
codex
我会使用 `generic-issue-log-analysis` 技能来分析当前仓库的 GitHub Issue 1，并把结论落到 `answer.md`。先读取技能说明和仓库上下文，确认 issue 来源与需要的证据。
exec
/bin/bash -lc "sed -n '1,220p' /home/runner/work/ai-issue-analysis/ai-issue-analysis/.claude/skills/generic-issue-log-analysis/SKILL.md" in /home/runner/work/ai-issue-analysis/ai-issue-analysis
 succeeded in 0ms:
---
name: generic-issue-log-analysis
description: 分析当前仓库或用户明确指定的公开 GitHub issue（完整 URL 或 `#1234`）。优先读取 issue 正文和评论，按需下载日志包、截图、配置导出和崩溃转储，建立时间线后结合仓库代码、文档和必要的上游依赖判断根因，并给出修复建议或下一步排查建议。
---

# Generic Issue Log Analysis

## Scope

- 默认把 `#1234` 视为当前仓库 issue。
- 如果用户给了完整 issue URL，则以该 URL 为准。
- 只分析可以直接访问的公开 issue、评论、截图和附件。
- 如果缺少日志、现场图、配置导出或崩溃信息，要先明确说明证据不足，再基于现有材料给出初步判断。
- 如果问题依赖私有环境、外部服务或用户本地状态，而仓库内证据不足，要明确列出还缺哪些材料。

## Workflow

1. 规范化输入。

   - `#1234` 视为当前仓库 issue。
   - 完整 issue URL 以 URL 为准。
   - 如果用户给的是模糊描述，先在 issue 文本里定位编号、链接或关键上下文。

2. 获取 issue 内容。

   - 读取正文和评论。
   - 提取这些信息：版本、分支、平台、环境、任务或入口、预期行为、实际行为、复现步骤、维护者评论、附件链接。
   - 如果维护者、机器人或其他评论已经给出结论，不要直接照抄；仍要用日志、代码和文档自行验证。

3. 提取附件和现场证据。

   - 优先关注日志包、截图、配置导出、崩溃转储、诊断报告和资源导出。
   - 不要假定附件命名固定；除了项目约定命名，也要留意 `log`、`report`、`debug`、`crash`、`dump`、`config`、`trace`、`screenshot` 等常见关键词。
   - 如果同一个 issue 有多份日志，先看最新一次复现；如果 issue 在对比不同版本、不同环境或不同控制器，再补看旧样本。

4. 下载并解压附件。

   - 二进制附件不要只靠网页抓取工具直接分析，应先下载到工作区临时目录，例如 `.cache/issue-logs/issue-<number>/`。
   - 解压后先列目录，不要假定内部结构固定。
   - 只读取和结论直接相关的文件，不要把整份大日志、整份配置或整个转储内容直接塞进回复。

5. 建立时间线。

   - 先从 issue 文本确定“用户认为出问题的时刻”和复现条件。
   - 再把界面日志、服务日志、运行时日志、截图、配置快照和崩溃信息串成一条时间线。
   - 优先锁定这次复现对应的 `task_id`、`session_id`、请求 ID、时间戳或其他稳定标识，再追踪细节。

6. 回溯到代码和文档。

   - 先看本仓库文档、配置定义和实现代码。
   - 如果问题明显落在上游依赖、共享组件、绑定层或外部工具，再按需查看相关仓库或文档。
   - 只看真正相关的模块，不要为了“完整”而把整个依赖栈都扫一遍。

7. 区分 issue 当时环境和当前分支。

   - 先以 issue 文本、附件、配置快照和缓存资源还原用户当时的实际环境。
   - 再对照当前仓库代码，判断问题是当前仍存在，还是当时存在但现在可能已修复。
   - 如果 issue 很旧，或日志流程与当前主线明显不一致，必要时按对应 tag、release 或历史提交复核旧逻辑。
   - 输出给用户时，如果提到任务名、入口名、设置项、按钮名、错误提示或日志前缀，先在仓库里搜索翻译 / 本地化文件，不要直接把 `t("...")`、`i18n.t("...")`、`LocalizationHelper.GetString("...")`、`DynamicResource` key、枚举名或内部 ID 当成最终展示文本。

8. 输出结论。

   - 明确区分“已证实的根因”“高概率怀疑点”“证据不足的待确认项”。
   - 给出能执行的下一步，例如修复方向、需要补充的材料、临时绕过方案、是否建议升级或回滚。

## Artifact Map

### Runtime / Core Logs

- 模块归属：核心运行时、执行引擎、任务调度层。
- 最适合看：
  - 实际执行路径
  - 识别、调用、动作失败
  - 超时、重试、异常栈
- 对任务行为和底层错误通常最权威。

### UI / Frontend Logs

- 模块归属：GUI、前端或用户交互层。
- 最适合看：
  - 用户到底点了什么
  - 参数是否真的提交
  - 用户可见报错和时间线入口

### Service / Bridge / Agent Logs

- 模块归属：后台服务、桥接层、agent、进程编排或 IPC 层。
- 最适合看：
  - 服务启动失败
  - 子进程异常
  - IPC、HTTP、RPC、FFI、资源加载或实例生命周期错误

### Config Snapshots

- 模块归属：配置快照、导出配置、任务参数、缓存配置。
- 最适合看：
  - 实际启用了哪些选项
  - issue 文字里说的配置是否真和日志一致
  - 当前行为是配置问题还是实现问题

### Screenshots / On-Error Artifacts

- 模块归属：出错现场图、保存的识别图、界面截图。
- 最适合看：
  - 当时停留画面
  - 是否被弹窗、遮罩、加载态、分辨率、缩放、主题或权限影响
  - 日志和用户描述冲突时，画面证据是否支持其中一方

### Dumps / Crash Reports

- 模块归属：崩溃现场、转储、调用栈、诊断报告。
- 最适合看：
  - 闪退、崩溃、进程退出
  - 是否需要进一步用符号表、调试器或上游信息分析

### Exported Resources / Cached Definitions

- 模块归属：缓存资源、导出的任务定义、运行时生成的元数据。
- 最适合看：
  - issue 当时到底使用了哪一版资源或配置定义
  - 当前主线和用户当时环境是否不一致

## How To Filter Evidence

1. 先从 issue 文本拿到这些锚点：

   - 版本、分支、提交、发布日期
   - 平台、设备、环境、控制方式
   - 任务名、入口名、操作路径
   - 用户说“出问题”的具体时间、阶段或界面

2. 再从日志里找高价值信号：

   - `Error`、`Warn`、`Fatal`
   - `timeout`、`retry`
   - `failed`、`exception`
   - `task_id`、`session_id`、请求 ID
   - 保存截图、导出现场、崩溃恢复、资源加载失败

3. 先锁定“这一次复现”再下钻。

   - 一个日志包里通常会混有很多历史运行。
   - 如果 issue 文本说失败，但对应这次复现的任务最终成功，要明确写出“本次日志未复现用户描述的问题”。

4. 区分表象和根因。

   - 高层日志、UI 提示或机器人评论经常只是表象。
   - 如果更靠近执行层的日志已经给出更直接的错误链路，应优先以那层为准，再回头解释用户看到的现象。

5. 回答时只保留关键片段。

   - 只摘足够支撑结论的少量证据。
   - 不要把整份日志、整段 issue 讨论或整份配置直接倾倒进回复。

## Common Patterns

- 维护者评论已经给出判断，但日志和代码证据并不支持：
  - 以可验证证据为准，把维护者评论当成补强而不是唯一依据。

- issue 文本说“失败 / 卡死 / 误点”，但对应复现日志最终成功：
  - 先明确“本次日志没有复现出用户描述的问题”。
  - 再区分是用户补错了日志，还是代码里确实存在脆弱点但这次没触发。

- 用户日志里的流程与当前主线代码明显不一致：
  - 先确认 issue 当时的版本、tag 或 release。
  - 不要用当前主线直接否定旧版本问题。

- 配置快照和实际运行日志不一致：
  - 不要立刻认定是用户表述错误。
  - 先确认配置是否在复现后又被修改、是否有多个配置文件、是否存在缓存或导出时机差异。

- 日志显示现场图、诊断包或转储已保存，但附件里没有对应文件：
  - 把“缺失的关键证据”单独写出来。
  - 不要假装已经验证过那部分现场。

- 多层架构项目里某一层日志只暴露表象：
  - 先在最接近问题根因的那层日志定性，再回到上层解释用户看到的现象。

- 证据更接近“场景不支持”而不是“实现缺陷”：
  - 必须给出代码、配置白名单、文档限制或运行时分支依据，而不是只给主观判断。

## Correlating With Code

- 先看 issue 模板、README、开发文档、排障文档。
- 再看任务入口、配置定义、流水线或调度定义。
- 然后看运行时、服务层、桥接层、前端或 GUI 实现。
- 只有当证据已经明显指向上游依赖时，才继续看外部仓库、SDK、框架或绑定层。

## Localized Copy

- 总结任务、入口、设置项、按钮、错误提示、日志前缀等用户可见文案时，先在仓库里主动搜索翻译 / 本地化文件。
- 优先搜索这些常见目录、文件名和关键词：
  - `locale`、`locales`、`i18n`、`lang`、`langs`、`translations`、`messages`
  - `zh-cn`、`zh_cn`、`zh-hans`、`zhHans`、`zh`
  - `*.json`、`*.yaml`、`*.yml`、`*.toml`、`*.resx`、`*.xaml`、`*.ts`、`*.js`
- 再从实际代码调用反查 key：
  - `t("...")`、`i18n.t("...")`、`intl.formatMessage(...)`
  - `LocalizationHelper.GetString("...")`、`GetString("...")`
  - `DynamicResource SomeKey`、`StaticResource SomeKey`
  - 其他项目自定义的资源读取函数
- 查找顺序建议：
  - 先从报错日志、配置字段、界面代码里提取疑似 key / id / 枚举名
  - 再在本地化文件中找对应中文文案
  - 如果同时存在多语言，优先使用简体中文；若没有简体中文，则退回 issue 正文更接近的语言或仓库主语言，并说明未找到中文文案
- 如果配置或日志里带有用户自定义名称，输出时优先保留用户自定义名称；必要时再括号补默认任务 / 入口文案或原始 key。
- 如果仓库里确实找不到翻译 / 本地化文件，要明确说明“未发现可用的翻译文件 / 本地化资源”，再退回原始 key、英文字符串或内部 ID。

## Linking Code Evidence

- 如果要指向具体代码行，不要写本地路径加行号，也不要写绝对路径。
- 统一给出对应仓库的远端 GitHub `blob` 行号链接，用尖括号包裹。
- 链接格式：
  - `https://github.com/<owner>/<repo>/blob/<commit>/<path>#L14-L20`
- `<owner>/<repo>` 应使用本次实际分析的代码仓库；如果引用的是上游依赖或外部仓库，就用那个仓库自己的链接。
- `<commit>` 必须是本次分析实际依据的代码版本：
  - 默认使用当前检出的 `HEAD`
  - 如果为了复核旧 issue 切到了某个 tag / commit，就使用那个版本解析后的 SHA
- 如果引用的是文档、配置样例或资源定义，也尽量给对应远端链接，而不是本地路径。

## Output Format

exec
/bin/bash -lc "pwd && rg --files -g '"'!*node_modules*'"' -g '"'!*.png'"' -g '"'!*.jpg'"' | sed -n '1,120p'" in /home/runner/work/ai-issue-analysis/ai-issue-analysis
 succeeded in 0ms:
/home/runner/work/ai-issue-analysis/ai-issue-analysis
README.md
LICENSE
action.yml

exec
/bin/bash -lc 'git remote -v' in /home/runner/work/ai-issue-analysis/ai-issue-analysis
 succeeded in 0ms:
origin	https://github.com/MistEO/ai-issue-analysis (fetch)
origin	https://github.com/MistEO/ai-issue-analysis (push)

codex
技能说明要求先读 issue 正文和评论，再回到仓库代码核对。当前仓库文件很少，我会先抓取 `MistEO/ai-issue-analysis#1` 的讨论内容，再确认是否有附件或外部证据需要下载。
exec
/bin/bash -lc "sed -n '220,420p' .claude/skills/generic-issue-log-analysis/SKILL.md" in /home/runner/work/ai-issue-analysis/ai-issue-analysis
 succeeded in 0ms:
## Output Format

最终回答用这个结构：

```markdown
## Issue 概要

- issue：`#1234`
- 版本 / 分支 / 环境：
- 任务 / 入口 / 相关设置：优先写翻译文件里的用户可见文案；必要时再补 key / id / 枚举名
- 关键提示 / 报错文案：优先写翻译文件中的实际显示文本
- 用户现象：

## 附件概览

- 实际可读文件：
- 缺失或未上传的证据：

## 关键证据

<details><summary>点击此处展开</summary>

- issue 正文 / 评论：
- 运行时日志：
- UI / 服务日志：
- 配置快照：
- 现场图 / 转储：
- 代码依据：如需指向具体实现，直接附远端 GitHub 行号链接

</details>

## 根因判断

- 直接结论：
- 证据链：
- 当前主线是否可能已修复：

## 修复方案

1. 代码 / 配置 / 资源层修复
2. 需要补充的测试、日志或截图
3. 如问题属于不支持场景，应如何限制入口或改进提示

## 给用户的建议

- 用户现在可以直接尝试的动作：
- 是否建议升级 / 重下完整包 / 重置配置 / 更换环境：
- 是否有临时绕过方案：

## 给修复 AI 的建议（可复制）

<details><summary>点击此处展开</summary>

~~~text
现象：
[一句话描述用户可见的问题]

关键证据：
[粘贴原始日志、堆栈、监控截图中的关键文本]

可能相关线索（待验证）：
[根据日志/现象推测的可能方向，不保证准确，供参考]
~~~

</details>

## 置信度

- 高 / 中 / 低
- 还缺什么证据

Reminders

不要只看一个日志文件下结论。
不要把 issue 评论、机器人提示或维护者判断当成唯一证据。
不要把当前分支代码直接当成 issue 当时的真实环境。
日志和截图冲突时，优先解释冲突，再决定更可信的证据链。
如果问题本身没有在当前日志中复现，要明确写“证据未复现”，不要硬凑结论。
如果 issue 版本较旧，要明确区分“当时的根因”和“当前主线是否已修复”。
如果回答里出现任务名、入口名、设置项、按钮名、提示文案，优先先搜索项目里的翻译 / 本地化文件，再使用实际用户可见文案；必要时才补原始 key / id。
如果回答里引用了具体代码行，直接给远端 GitHub blob 行号链接，用尖括号包裹，不要给本地路径加行号。
如果证据表明问题已在新版本修复，明确建议升级；如果怀疑安装包、资源文件或配置损坏，明确建议重建；如果判断为真实代码缺陷且暂无 workaround，明确建议等待修复。

exec
/bin/bash -lc "sed -n '1,220p' README.md && sed -n '1,220p' action.yml && git rev-parse HEAD" in /home/runner/work/ai-issue-analysis/ai-issue-analysis
succeeded in 0ms:

ai-issue-analysis

一个通用的 GitHub composite action，用来在 Issue 打开或被评论时调用 Codex CLI 做分析，并把分析过程和最终结论持续回写到同一条评论里。

实战效果展示：

快速接入

准备一个 OpenAI 兼容的 API Key（OpenAI 官方、Azure、或其他兼容服务均可）
在你的 GitHub 仓库 - Settings - secrets - actions - new repository secret
- Name: CODEX_API_KEY
- Secret: 你的 API Key
如果你使用非 OpenAI 官方端点，还需要额外添加：
- Name: CODEX_BASE_URL
- Secret: 你的 API base URL（例如 https://your-proxy.example.com/v1）
把下面两个文件拷贝到你的仓库里，文件夹不要变
- .github/workflows/ai-issue-analysis.yml
- .claude/skills/generic-issue-log-analysis/SKILL.md
新提个 issue 测试下能否正常运行了，或者在以前的 issue 里 @github-actions

[!TIP]

如果你的项目有固定的日志包命名、关键日志路径、附件目录、模块映射或上游依赖，建议在这个通用版基础上微调 SKILL.md，分析质量会更高。最佳实践参考：

MaaEnd

MaaAssistantArknights

输入说明

issue-number: Issue 编号，通常可以不传：
- issues / issue_comment 事件会自动读取 github.event.issue.number
- workflow_dispatch 会自动读取输入名为 issue_number 的 dispatch 参数
如果你的 workflow_dispatch 输入名不是 issue_number，或者你在其他事件里调用这个 action，就显式传 issue-number。
github-token: 用于创建和更新 Issue 评论
codex-api-key: Codex CLI 使用的 API Key（会设为 OPENAI_API_KEY 环境变量），支持传多个 key，每行一个，action 会随机选择一个使用
codex-base-url: API 端点 base URL（会设为 OPENAI_BASE_URL 环境变量），留空则使用 OpenAI 默认端点
codex-model: 模型名称，默认 o3
codex-package: 安装的 npm 包名，默认 @openai/codex
bot-name: 从 issue_comment 正文中剥离掉的 bot mention，比如 @YourBot
initial-comment-body: 开始分析时先发出的评论正文
action-link-text: 评论里展示的运行链接文字
details-summary: 分析过程折叠块的标题
prompt-template: 基础分析提示词模板
comment-prompt-template: 有评论补充要求时追加的提示词模板
stream-update-interval-seconds: 流式更新评论的间隔秒数，默认 30
checkout-repository: 是否在 action 内部自动执行 actions/checkout，默认 true
answer-file: AI 写入最终结论的文件路径，默认 answer.md
extra-comment-content: 始终追加在每次评论最末尾的额外内容，默认为空

输出说明

issue-number: 本次运行实际解析出的 Issue 编号
comment-id: 创建并持续更新的评论 ID
comment-url: 创建并持续更新的评论 URL
analysis-prompt: 本次最终传给 Codex 的 prompt
codex-output: 完整执行日志，包含 Codex 启动前的参数打印、prompt 正文，以及 Codex CLI 输出
final-conclusion: Codex 写入 answer-file 的最终结论
analysis-prompt、codex-output 和 final-conclusion 在过长时会为适配 GitHub Actions output 大小限制而被截断；完整内容优先从 artifacts 读取

上传产物

codex-output-issue-<issue-number>-comment-<comment-id>: 完整执行日志，包含启动前参数、prompt 正文和 Codex CLI 输出
final-conclusion-issue-<issue-number>-comment-<comment-id>: 最终结论文本

Skill 配合

这个 action 只负责 GitHub Actions 编排、评论更新、Codex CLI 调用和 prompt 拼接，不内置项目领域知识
对需要分析 issue 附件、日志包、运行时配置、跨仓库代码路径的项目，建议配套提供项目自己的 issue 分析 skill
一个可行的 skill 一般至少会覆盖这些步骤：读取 issue 正文和评论、定位并下载日志附件、先建立时间线再筛证据、最后回溯到代码和文档做归因
如果没有这层 skill，action 仍然能运行，但对日志包、截图、跨模块调用链这类问题，分析质量通常会明显下降
最佳实践参考，MaaEnd: https://github.com/MaaEnd/MaaEnd/blob/v2/.claude/skills/maaend-issue-log-analysis/SKILL.md
最佳实践参考，MaaAssistantArknights: https://github.com/MaaAssistantArknights/MaaAssistantArknights/blob/dev-v2/.claude/skills/maa-issue-log-analysis/SKILL.md

模板变量：

{{issue_number}}
{{answer_file}}
{{comment_body}}
{{repository}}
{{event_name}}

行为说明：

action 内部会自动 checkout 调用方仓库
如果调用方已经自己 checkout，或者前置步骤会生成工作区文件，可以把 checkout-repository 设为 false
会自动安装 @openai/codex
会先创建一条评论，然后持续更新这条评论
会导出 comment-id、comment-url、analysis-prompt、codex-output、final-conclusion 等 action outputs
codex-output 会包含 Codex 启动前的参数打印和 prompt 正文，不再只是 Codex 进程本身的 stdout/stderr
会上传 Codex 原始输出和最终结论两个 artifacts
最终评论会包含最终结论、完整分析过程折叠块，以及当前 Actions 运行链接
codex-api-key 兼容单个 key，也兼容多个 key 按行填写；传多个时每次运行会随机选一个
name: AI Issue Analysis
description: Analyze a GitHub issue with Codex CLI and keep a comment updated with progress and the final result.
author: MistEO

inputs:
issue-number:
description: Issue number to analyze. If empty, the action infers it from the current event or a workflow_dispatch input named issue_number.
required: false
default: ""
github-token:
description: GitHub token used to create and update issue comments.
required: true
codex-api-key:
description: API key for the Codex CLI (set as OPENAI_API_KEY). Supports multiple keys, one per line, and randomly picks one.
required: true
codex-base-url:
description: Base URL for the Codex CLI API endpoint (set as OPENAI_BASE_URL). Leave empty to use the default OpenAI endpoint.
required: false
default: ""
codex-model:
description: Model name passed to the Codex CLI via --model.
required: false
default: gpt-5.5
codex-package:
description: NPM package to install for the Codex CLI.
required: false
default: "@openai/codex"
bot-name:
description: Bot mention to strip from issue_comment messages before appending extra requirements.
required: false
default: ""
initial-comment-body:
description: Initial comment body shown before the analysis finishes.
required: false
default: |
🤖 AI 正在分析该 Issue...

  感谢您的反馈！AI 正在自动分析该问题，预计耗时约 10 分钟。

action-link-text:
description: Link text shown for the current GitHub Actions run.
required: false
default: GitHub Action 运行记录
details-summary:
description: Summary text used in the HTML details block that wraps the streaming output.
required: false
default: 点击此处展开分析过程
prompt-template:
description: Base prompt template. Supported placeholders are {{issue_number}}, {{answer_file}}, {{repository}}, and {{event_name}}.
required: false
default: 分析 GitHub Issue {{issue_number}}。把最终结论写到 {{answer_file}}。
comment-prompt-template:
description: Extra prompt appended when the triggering issue comment still has content after removing the bot mention. Supported placeholders also include {{comment_body}}.
required: false
default: 补充要求：{{comment_body}}
stream-update-interval-seconds:
description: Number of seconds between streamed comment updates.
required: false
default: "30"
cache-dir:
description: Directory used for temporary prompt, output, and comment files.
required: false
default: .cache
answer-file:
description: File path where the prompt asks the AI to write the final answer.
required: false
default: answer.md
checkout-repository:
description: Whether to run actions/checkout inside the action before analysis.
required: false
default: "true"
process-error-message:
description: Fallback message shown in the full analysis log when the answer file is not found.
required: false
default: 分析过程出现错误，请重试。
result-error-message:
description: Fallback message written into the final issue comment when the answer file is not found.
required: false
default: 分析结果出现错误，请重试。
extra-comment-content:
description: Extra content always appended at the bottom of every comment update. Empty by default.
required: false
default: ""

outputs:
issue-number:
description: Resolved issue number used for the run.
value: ${{ steps.issue_number.outputs.issue_number }}
comment-id:
description: The issue comment ID that was created and then updated.
value: ${{ steps.initial_comment.outputs.comment-id }}
comment-url:
description: The URL of the issue comment that was created and then updated.
value: ${{ steps.export_results.outputs.comment-url }}
analysis-prompt:
description: Final rendered prompt passed to Codex for this run.
value: ${{ steps.export_results.outputs.analysis-prompt }}
codex-output:
description: Execution log including pre-run parameters, prompt, and Codex stdout and stderr.
value: ${{ steps.export_results.outputs.codex-output }}
final-conclusion:
description: Final conclusion content produced by Codex.
value: ${{ steps.export_results.outputs.final-conclusion }}

runs:
using: composite
steps:
- name: Checkout repository
if: ${{ inputs.checkout-repository == 'true' }}
uses: actions/checkout@v4

- name: Link .claude to .codex
  shell: bash
  run: |
    if [ -d ".claude" ] && [ ! -e ".codex" ]; then
      ln -s .claude .codex
      echo "Linked .claude -> .codex"
    elif [ -d ".codex" ]; then
      echo ".codex already exists, skipping"
    else
      echo "No .claude or .codex directory found"
    fi

- name: Determine issue number
  id: issue_number
  shell: bash
  env:
    INPUT_ISSUE_NUMBER: ${{ inputs.issue-number }}
    EVENT_NAME: ${{ github.event_name }}
  run: |
    python <<'PY'
    import json
    import os
    from pathlib import Path

    event_name = os.environ["EVENT_NAME"]
    issue_number = os.environ["INPUT_ISSUE_NUMBER"].strip()
    event = json.loads(Path(os.environ["GITHUB_EVENT_PATH"]).read_text(encoding="utf-8"))

    if not issue_number:
        if event_name in {"issues", "issue_comment"}:
            issue_number = str(event["issue"]["number"])
        elif event_name == "workflow_dispatch":
            issue_number = str(event.get("inputs", {}).get("issue_number", "")).strip()

    if not issue_number:
        raise SystemExit("Unable to determine issue number. Pass input issue-number or expose workflow_dispatch input issue_number.")

    with open(os.environ["GITHUB_OUTPUT"], "a", encoding="utf-8") as fh:
        fh.write(f"issue_number={issue_number}\n")
    PY

- name: Prepare runtime files
  id: runtime
  shell: bash
  env:
    CACHE_DIR: ${{ inputs.cache-dir }}
    DETAILS_SUMMARY: ${{ inputs.details-summary }}
    ACTION_LINK_TEXT: ${{ inputs.action-link-text }}
  run: |
    mkdir -p "$CACHE_DIR"

    {
      echo "analysis_prompt_file=$CACHE_DIR/analysis_prompt.txt"
      echo "codex_output_file=$CACHE_DIR/codex_output.log"
      echo "codex_execution_log_file=$CACHE_DIR/codex_execution.log"
      echo "codex_output_artifact_file=$CACHE_DIR/codex_output.txt"
      echo "comment_body_file=$CACHE_DIR/comment_body.txt"
      echo "final_comment_file=$CACHE_DIR/final_comment.md"
      echo "final_conclusion_artifact_file=$CACHE_DIR/final_conclusion.md"
      echo "details_end=</details>"
      echo "action_link<<EOF"
      echo "🔗 [$ACTION_LINK_TEXT](${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }})"
      echo "EOF"
      echo "details_begin<<EOF"
      echo "<details><summary>$DETAILS_SUMMARY</summary>"
      echo "EOF"
    } >> "$GITHUB_OUTPUT"

- name: Build analysis prompt
  shell: bash
  env:
    EVENT_NAME: ${{ github.event_name }}
    ISSUE_NUMBER: ${{ steps.issue_number.outputs.issue_number }}
    BOT_NAME: ${{ inputs.bot-name }}
    ANALYSIS_PROMPT_FILE: ${{ steps.runtime.outputs.analysis_prompt_file }}
    ANSWER_FILE: ${{ inputs.answer-file }}
    PROMPT_TEMPLATE: ${{ inputs.prompt-template }}
    COMMENT_PROMPT_TEMPLATE: ${{ inputs.comment-prompt-template }}
    REPOSITORY: ${{ github.repository }}
  run: |
    python <<'PY'
    import json
    import os
    import re
    from pathlib import Path

    event_name = os.environ["EVENT_NAME"]
    issue_number = os.environ["ISSUE_NUMBER"]
    bot_name = os.environ["BOT_NAME"]
    analysis_prompt_file = Path(os.environ["ANALYSIS_PROMPT_FILE"])
    answer_file = os.environ["ANSWER_FILE"]
    prompt_template = os.environ["PROMPT_TEMPLATE"]
    comment_prompt_template = os.environ["COMMENT_PROMPT_TEMPLATE"]
    repository = os.environ["REPOSITORY"]
    event = json.loads(Path(os.environ["GITHUB_EVENT_PATH"]).read_text(encoding="utf-8"))

    raw_comment = ""
    if event_name == "issue_comment":
        raw_comment = event.get("comment", {}).get("body", "")

    cleaned_comment = raw_comment
    if bot_name:
        cleaned_comment = re.sub(rf"{re.escape(bot_name)}\b", "", cleaned_comment, flags=re.IGNORECASE)
    cleaned_comment = re.sub(r"^[\s,，.。!！?？:：]+", "", cleaned_comment).strip()

    def render(template: str) -> str:
        return (
            template
            .replace("{{issue_number}}", issue_number)
            .replace("{{answer_file}}", answer_file)

db40014

exec
/bin/bash -lc 'gh issue view 1 --repo MistEO/ai-issue-analysis --comments --json number,title,state,author,createdAt,updatedAt,body,comments,labels,url' in /home/runner/work/ai-issue-analysis/ai-issue-analysis
exited 4 in 199ms:
gh: To use GitHub CLI in a GitHub Actions workflow, set the GH_TOKEN environment variable. Example:
env:
GH_TOKEN: ${{ github.token }}

codex
gh 在当前 Actions 环境没有令牌，不能直接读 issue；我会改用公开 GitHub API/网页读取。README 和 action.yml 显示这是一个 composite action，核心逻辑在 action.yml，下一步会重点核对 Issue 1 提到的行为是否由脚本实现导致。
exec
/bin/bash -lc "sed -n '220,520p' action.yml" in /home/runner/work/ai-issue-analysis/ai-issue-analysis
succeeded in 0ms:
.replace("{{answer_file}}", answer_file)
.replace("{{comment_body}}", cleaned_comment)
.replace("{{repository}}", repository)
.replace("{{event_name}}", event_name)
)

    prompt = render(prompt_template).strip()
    extra_prompt = render(comment_prompt_template).strip() if cleaned_comment else ""

    if extra_prompt:
        prompt = f"{prompt}\n\n{extra_prompt}" if prompt else extra_prompt

    analysis_prompt_file.write_text(f"{prompt}\n", encoding="utf-8")
    PY

- name: Create initial comment
  id: initial_comment
  uses: peter-evans/create-or-update-comment@v4
  with:
    issue-number: ${{ steps.issue_number.outputs.issue_number }}
    token: ${{ inputs.github-token }}
    body: |
      ${{ inputs.initial-comment-body }}
      ---
      ${{ steps.runtime.outputs.action_link }}

- name: Install Codex CLI
  shell: bash
  run: npm install -g "${{ inputs.codex-package }}"

- name: Resolve Codex API key and configure Codex CLI
  id: resolve_codex_key
  shell: bash
  env:
    INPUT_CODEX_API_KEY: ${{ inputs.codex-api-key }}
    INPUT_CODEX_BASE_URL: ${{ inputs.codex-base-url }}
    INPUT_CODEX_MODEL: ${{ inputs.codex-model }}
  run: |
    python <<'PY'
    import os
    import secrets
    from pathlib import Path

    raw_value = os.environ["INPUT_CODEX_API_KEY"]
    keys = [line.strip() for line in raw_value.splitlines() if line.strip()]

    if not keys:
        raise SystemExit("Input codex-api-key is empty after trimming blank lines.")

    selected_key = secrets.choice(keys)

    base_url = os.environ["INPUT_CODEX_BASE_URL"].strip()
    model = os.environ["INPUT_CODEX_MODEL"].strip()

    codex_home = Path.home() / ".codex"
    codex_home.mkdir(parents=True, exist_ok=True)
    config_path = codex_home / "config.toml"

    lines = [f'model = "{model}"']
    if base_url:
        lines.append(f'model_provider = "custom"')
        lines.append("")
        lines.append("[model_providers.custom]")
        lines.append(f'name = "Custom Provider"')
        lines.append(f'base_url = "{base_url}"')
        lines.append(f'env_key = "CODEX_API_KEY"')
        lines.append(f'wire_api = "responses"')
        lines.append(f'supports_websockets = false')
        lines.append(f'requires_openai_auth = false')
    else:
        lines.append(f'openai_base_url = "https://api.openai.com/v1"')

    config_path.write_text("\n".join(lines) + "\n", encoding="utf-8")
    print(f"Codex config written to {config_path}:")
    print(config_path.read_text(encoding="utf-8"))

    with open(os.environ["GITHUB_OUTPUT"], "a", encoding="utf-8") as fh:
        fh.write(f"codex_api_key={selected_key}\n")
        fh.write(f"codex_key_count={len(keys)}\n")
    PY

- name: Run Codex analysis with streaming updates
  shell: bash
  env:
    CODEX_API_KEY: ${{ steps.resolve_codex_key.outputs.codex_api_key }}
    COMMENT_GITHUB_TOKEN: ${{ inputs.github-token }}
    GITHUB_SERVER_URL: ${{ github.server_url }}
    COMMENT_ID: ${{ steps.initial_comment.outputs.comment-id }}
    ISSUE_NUMBER: ${{ steps.issue_number.outputs.issue_number }}
    REPO: ${{ github.repository }}
    ANALYSIS_PROMPT_FILE: ${{ steps.runtime.outputs.analysis_prompt_file }}
    OUTPUT_FILE: ${{ steps.runtime.outputs.codex_output_file }}
    EXECUTION_LOG_FILE: ${{ steps.runtime.outputs.codex_execution_log_file }}
    BODY_FILE: ${{ steps.runtime.outputs.comment_body_file }}
    INITIAL_BODY: ${{ inputs.initial-comment-body }}
    ACTION_LINK: ${{ steps.runtime.outputs.action_link }}
    DETAILS_BEGIN: ${{ steps.runtime.outputs.details_begin }}
    DETAILS_END: ${{ steps.runtime.outputs.details_end }}
    CODEX_MODEL: ${{ inputs.codex-model }}
    STREAM_UPDATE_INTERVAL: ${{ inputs.stream-update-interval-seconds }}
    EXTRA_COMMENT_CONTENT: ${{ inputs.extra-comment-content }}
  run: |
    COMMENT_URL="$GITHUB_SERVER_URL/$REPO/issues/$ISSUE_NUMBER#issuecomment-$COMMENT_ID"

    : > "$OUTPUT_FILE"
    : > "$EXECUTION_LOG_FILE"
    {
      echo "Codex invocation parameters:"
      echo "  repo: $REPO"
      echo "  issue-number: $ISSUE_NUMBER"
      echo "  comment-id: $COMMENT_ID"
      echo "  comment-url: $COMMENT_URL"
      echo "  model: $CODEX_MODEL"
      echo "  api-key-count: ${{ steps.resolve_codex_key.outputs.codex_key_count }}"
      echo "  stream-update-interval-seconds: $STREAM_UPDATE_INTERVAL"
      echo "  analysis-prompt-file: $ANALYSIS_PROMPT_FILE"
      echo "  output-file: $OUTPUT_FILE"
      echo "  body-file: $BODY_FILE"
      echo "  codex config:"
      cat ~/.codex/config.toml
      echo "  command: codex exec --dangerously-bypass-approvals-and-sandbox \"<contents of $ANALYSIS_PROMPT_FILE>\""
      echo "Prompt content begins"
      cat "$ANALYSIS_PROMPT_FILE"
      echo "Prompt content ends"
    } | tee -a "$EXECUTION_LOG_FILE"

    codex exec --dangerously-bypass-approvals-and-sandbox \
      "$(cat "$ANALYSIS_PROMPT_FILE")" > "$OUTPUT_FILE" 2>&1 &
    CODEX_PID=$!
    echo "Codex started with PID $CODEX_PID" | tee -a "$EXECUTION_LOG_FILE"

    last_content=""

    while true; do
      sleep "$STREAM_UPDATE_INTERVAL" &
      sleep_pid=$!

      wait -n "$CODEX_PID" "$sleep_pid" 2>/dev/null || true

      if ! kill -0 "$CODEX_PID" 2>/dev/null; then
        kill "$sleep_pid" 2>/dev/null || true
        break
      fi

      if [ -f "$OUTPUT_FILE" ]; then
        current_content=$(cat "$OUTPUT_FILE")
        if [ "$current_content" != "$last_content" ] && [ -n "$current_content" ]; then
          truncated_content="$current_content"
          if [ "${#truncated_content}" -gt 55000 ]; then
            truncated_content="${truncated_content:0:55000}"$'\n\n[truncated for comment size limit]'
          fi
          {
            echo "$INITIAL_BODY"
            echo
            echo "---"
            echo
            echo "$DETAILS_BEGIN"
            echo
            echo '```text'
            echo "$truncated_content"
            echo '```'
            echo
            echo "$DETAILS_END"
            echo
            echo "$ACTION_LINK"
            if [ -n "$EXTRA_COMMENT_CONTENT" ]; then
              echo
              echo "$EXTRA_COMMENT_CONTENT"
            fi
          } > "$BODY_FILE"

          jq -Rs '{"body":.}' < "$BODY_FILE" | \
            curl -s -L -X PATCH \
              -H "Authorization: token $COMMENT_GITHUB_TOKEN" \
              -H "Accept: application/vnd.github.v3+json" \
              "https://api.github.com/repos/$REPO/issues/comments/$COMMENT_ID" \
              -d @-

          last_content="$current_content"
          echo "Comment updated at $(date)"
        fi
      fi
    done

    wait "$CODEX_PID"
    CODEX_EXIT=$?

    {
      echo
      echo "Codex output begins"
      if [ -f "$OUTPUT_FILE" ]; then
        cat "$OUTPUT_FILE"
      fi
      echo
      echo "Codex output ends"
      echo "Codex exit code: $CODEX_EXIT"
    } >> "$EXECUTION_LOG_FILE"

    exit "$CODEX_EXIT"

- name: Full analysis
  if: ${{ always() }}
  shell: bash
  env:
    CODEX_OUTPUT_FILE: ${{ steps.runtime.outputs.codex_execution_log_file }}
    ANSWER_FILE: ${{ inputs.answer-file }}
    PROCESS_ERROR_MESSAGE: ${{ inputs.process-error-message }}
  run: |
    if [ -f "$CODEX_OUTPUT_FILE" ]; then
      cat "$CODEX_OUTPUT_FILE"
    fi
    echo
    echo "---"
    echo
    if [ -f "$ANSWER_FILE" ]; then
      cat "$ANSWER_FILE"
    else
      echo "$PROCESS_ERROR_MESSAGE"
    fi

- name: Prepare final comment
  if: ${{ always() }}
  shell: bash
  env:
    ANSWER_FILE: ${{ inputs.answer-file }}
    CODEX_OUTPUT_FILE: ${{ steps.runtime.outputs.codex_output_file }}
    FINAL_COMMENT_FILE: ${{ steps.runtime.outputs.final_comment_file }}
    ACTION_LINK: ${{ steps.runtime.outputs.action_link }}
    DETAILS_BEGIN: ${{ steps.runtime.outputs.details_begin }}
    DETAILS_END: ${{ steps.runtime.outputs.details_end }}
    EXTRA_COMMENT_CONTENT: ${{ inputs.extra-comment-content }}
    RESULT_ERROR_MESSAGE: ${{ inputs.result-error-message }}
  run: |
    : > "$FINAL_COMMENT_FILE"

    if [ -f "$ANSWER_FILE" ]; then
      cat "$ANSWER_FILE" >> "$FINAL_COMMENT_FILE"
    else
      echo "$RESULT_ERROR_MESSAGE" >> "$FINAL_COMMENT_FILE"
    fi

    {
      echo
      echo "---"
      echo
      echo "$DETAILS_BEGIN"
      echo
      echo '```text'
      if [ -f "$CODEX_OUTPUT_FILE" ]; then
        cat "$CODEX_OUTPUT_FILE"
      fi
      echo '```'
      echo
      echo "$DETAILS_END"
      echo
      echo "$ACTION_LINK"
      if [ -n "$EXTRA_COMMENT_CONTENT" ]; then
        echo
        echo "$EXTRA_COMMENT_CONTENT"
      fi
    } >> "$FINAL_COMMENT_FILE"

- name: Export action results
  id: export_results
  if: ${{ always() }}
  shell: bash
  env:
    COMMENT_ID: ${{ steps.initial_comment.outputs.comment-id }}
    GITHUB_SERVER_URL: ${{ github.server_url }}
    ISSUE_NUMBER: ${{ steps.issue_number.outputs.issue_number }}
    REPOSITORY: ${{ github.repository }}
    ANALYSIS_PROMPT_FILE: ${{ steps.runtime.outputs.analysis_prompt_file }}
    CODEX_OUTPUT_FILE: ${{ steps.runtime.outputs.codex_execution_log_file }}
    CODEX_OUTPUT_ARTIFACT_FILE: ${{ steps.runtime.outputs.codex_output_artifact_file }}
    ANSWER_FILE: ${{ inputs.answer-file }}
    FINAL_CONCLUSION_ARTIFACT_FILE: ${{ steps.runtime.outputs.final_conclusion_artifact_file }}
  run: |
    python <<'PY'
    import os
    import uuid
    from pathlib import Path

    github_output = Path(os.environ["GITHUB_OUTPUT"])
    comment_id = os.environ["COMMENT_ID"]
    github_server_url = os.environ["GITHUB_SERVER_URL"]
    issue_number = os.environ["ISSUE_NUMBER"]
    repository = os.environ["REPOSITORY"]
    analysis_prompt_file = Path(os.environ["ANALYSIS_PROMPT_FILE"])
    codex_output_file = Path(os.environ["CODEX_OUTPUT_FILE"])
    codex_output_artifact_file = Path(os.environ["CODEX_OUTPUT_ARTIFACT_FILE"])
    answer_file = Path(os.environ["ANSWER_FILE"])
    final_conclusion_artifact_file = Path(os.environ["FINAL_CONCLUSION_ARTIFACT_FILE"])
    comment_url = (
        f"{github_server_url}/{repository}/issues/{issue_number}#issuecomment-{comment_id}"
        if comment_id
        else ""
    )

    def read_or_placeholder(path: Path, missing_message: str) -> str:
        if path.is_file():
            return path.read_text(encoding="utf-8")

exec
/bin/bash -lc 'curl -sS https://api.github.com/repos/MistEO/ai-issue-analysis/issues/1' in /home/runner/work/ai-issue-analysis/ai-issue-analysis
exec
/bin/bash -lc 'curl -sS https://api.github.com/repos/MistEO/ai-issue-analysis/issues/1/comments' in /home/runner/work/ai-issue-analysis/ai-issue-analysis
succeeded in 141ms:
{
"url": "https://api.github.com/repos/MistEO/ai-issue-analysis/issues/1",
"repository_url": "https://api.github.com/repos/MistEO/ai-issue-analysis",
"labels_url": "https://api.github.com/repos/MistEO/ai-issue-analysis/issues/1/labels{/name}",
"comments_url": "https://api.github.com/repos/MistEO/ai-issue-analysis/issues/1/comments",
"events_url": "https://api.github.com/repos/MistEO/ai-issue-analysis/issues/1/events",
"html_url": "#1",
"id": 4099729656,
"node_id": "I_kwDORo_lYc70XOj4",
"number": 1,
"title": "测试测试",
"user": {
"login": "MistEO",
"id": 18511905,
"node_id": "MDQ6VXNlcjE4NTExOTA1",
"avatar_url": "https://avatars.githubusercontent.com/u/18511905?v=4",
"gravatar_id": "",
"url": "https://api.github.com/users/MistEO",
"html_url": "https://github.com/MistEO",
"followers_url": "https://api.github.com/users/MistEO/followers",
"following_url": "https://api.github.com/users/MistEO/following{/other_user}",
"gists_url": "https://api.github.com/users/MistEO/gists{/gist_id}",
"starred_url": "https://api.github.com/users/MistEO/starred{/owner}{/repo}",
"subscriptions_url": "https://api.github.com/users/MistEO/subscriptions",
"organizations_url": "https://api.github.com/users/MistEO/orgs",
"repos_url": "https://api.github.com/users/MistEO/repos",
"events_url": "https://api.github.com/users/MistEO/events{/privacy}",
"received_events_url": "https://api.github.com/users/MistEO/received_events",
"type": "User",
"user_view_type": "public",
"site_admin": false
},
"labels": [

],
"state": "open",
"locked": false,
"assignees": [

],
"milestone": null,
"comments": 4,
"created_at": "2026-03-19T06:52:16Z",
"updated_at": "2026-06-08T10:12:56Z",
"closed_at": null,
"assignee": null,
"author_association": "OWNER",
"active_lock_reason": null,
"sub_issues_summary": {
"total": 0,
"completed": 0,
"percent_completed": 0
},
"issue_dependencies_summary": {
"blocked_by": 0,
"total_blocked_by": 0,
"blocking": 0,
"total_blocking": 0
},
"body": "https://github.com/MaaEnd/MaaEnd/blob/f2de4c61367ad03d4d8a13ce823139c6237f2a55/assets/resource/pipeline/Common/Button.json#L14-L20",
"closed_by": null,
"reactions": {
"url": "https://api.github.com/repos/MistEO/ai-issue-analysis/issues/1/reactions",
"total_count": 0,
"+1": 0,
"-1": 0,
"laugh": 0,
"hooray": 0,
"confused": 0,
"heart": 0,
"rocket": 0,
"eyes": 0
},
"timeline_url": "https://api.github.com/repos/MistEO/ai-issue-analysis/issues/1/timeline",
"performed_via_github_app": null,
"state_reason": null,
"pinned_comment": null
}

succeeded in 155ms:
[
{
"url": "https://api.github.com/repos/MistEO/ai-issue-analysis/issues/comments/4088185166",
"html_url": "https://github.com//issues/1#issuecomment-4088185166",
"issue_url": "https://api.github.com/repos//issues/1",
"id": 4088185166,
"node_id": "IC_kwDORo_lYc7zrMFO",
"user": {
"login": "github-actions[bot]",
"id": 41898282,
"node_id": "MDM6Qm90NDE4OTgyODI=",
"avatar_url": "https://avatars.githubusercontent.com/in/15368?v=4",
"gravatar_id": "",
"url": "https://api.github.com/users/github-actions%5Bbot%5D",
"html_url": "https://github.com/apps/github-actions",
"followers_url": "https://api.github.com/users/github-actions%5Bbot%5D/followers",
"following_url": "https://api.github.com/users/github-actions%5Bbot%5D/following{/other_user}",
"gists_url": "https://api.github.com/users/github-actions%5Bbot%5D/gists{/gist_id}",
"starred_url": "https://api.github.com/users/github-actions%5Bbot%5D/starred{/owner}{/repo}",
"subscriptions_url": "https://api.github.com/users/github-actions%5Bbot%5D/subscriptions",
"organizations_url": "https://api.github.com/users/github-actions%5Bbot%5D/orgs",
"repos_url": "https://api.github.com/users/github-actions%5Bbot%5D/repos",
"events_url": "https://api.github.com/users/github-actions%5Bbot%5D/events{/privacy}",
"received_events_url": "https://api.github.com/users/github-actions%5Bbot%5D/received_events",
"type": "Bot",
"user_view_type": "public",
"site_admin": false
},
"created_at": "2026-03-19T06:52:26Z",
"updated_at": "2026-03-19T06:52:33Z",
"body": "Copilot did not produce a final answer file: copilot_answer.md\n\n---\n\n

点击此处展开分析过程

\n\n🔗 GitHub Action 运行记录\n",
"author_association": "NONE",
"pin": null,
"reactions": {
"url": "https://api.github.com/repos/MistEO/ai-issue-analysis/issues/comments/4088185166/reactions",
"total_count": 0,
"+1": 0,
"-1": 0,
"laugh": 0,
"hooray": 0,
"confused": 0,
"heart": 0,
"rocket": 0,
"eyes": 0
},
"performed_via_github_app": {
"id": 15368,
"client_id": "Iv1.05c79e9ad1f6bdfa",
"slug": "github-actions",
"node_id": "MDM6QXBwMTUzNjg=",
"owner": {
"login": "github",
"id": 9919,
"node_id": "MDEyOk9yZ2FuaXphdGlvbjk5MTk=",
"avatar_url": "https://avatars.githubusercontent.com/u/9919?v=4",
"gravatar_id": "",
"url": "https://api.github.com/users/github",
"html_url": "https://github.com/github",
"followers_url": "https://api.github.com/users/github/followers",
"following_url": "https://api.github.com/users/github/following{/other_user}",
"gists_url": "https://api.github.com/users/github/gists{/gist_id}",
"starred_url": "https://api.github.com/users/github/starred{/owner}{/repo}",
"subscriptions_url": "https://api.github.com/users/github/subscriptions",
"organizations_url": "https://api.github.com/users/github/orgs",
"repos_url": "https://api.github.com/users/github/repos",
"events_url": "https://api.github.com/users/github/events{/privacy}",
"received_events_url": "https://api.github.com/users/github/received_events",
"type": "Organization",
"user_view_type": "public",
"site_admin": false
},
"name": "GitHub Actions",
"description": "Automate your workflow from idea to production",
"external_url": "https://help.github.com/en/actions",
"html_url": "https://github.com/apps/github-actions",
"created_at": "2018-07-30T09:30:17Z",
"updated_at": "2026-05-05T14:51:38Z",
"permissions": {
"actions": "write",
"administration": "read",
"artifact_metadata": "write",
"attestations": "write",
"checks": "write",
"code_quality": "write",
"contents": "write",
"copilot_requests": "write",
"deployments": "write",
"discussions": "write",
"issues": "write",
"merge_queues": "write",
"metadata": "read",
"models": "read",
"packages": "write",
"pages": "write",
"pull_requests": "write",
"repository_hooks": "write",
"repository_projects": "write",
"security_events": "write",
"statuses": "write",
"vulnerability_alerts": "read"
},
"events": [
"branch_protection_rule",
"check_run",
"check_suite",
"create",
"delete",
"deployment",
"deployment_status",
"discussion",
"discussion_comment",
"fork",
"gollum",
"issues",
"issue_comment",
"label",
"merge_group",
"milestone",
"page_build",
"public",
"pull_request",
"pull_request_review",
"pull_request_review_comment",
"push",
"registry_package",
"release",
"repository",
"repository_dispatch",
"status",
"watch",
"workflow_dispatch",
"workflow_run"
]
}
},
{
"url": "https://api.github.com/repos/MistEO/ai-issue-analysis/issues/comments/4088194409",
"html_url": "https://github.com//issues/1#issuecomment-4088194409",
"issue_url": "https://api.github.com/repos//issues/1",
"id": 4088194409,
"node_id": "IC_kwDORo_lYc7zrOVp",
"user": {
"login": "MistEO",
"id": 18511905,
"node_id": "MDQ6VXNlcjE4NTExOTA1",
"avatar_url": "https://avatars.githubusercontent.com/u/18511905?v=4",
"gravatar_id": "",
"url": "https://api.github.com/users/MistEO",
"html_url": "https://github.com/MistEO",
"followers_url": "https://api.github.com/users/MistEO/followers",
"following_url": "https://api.github.com/users/MistEO/following{/other_user}",
"gists_url": "https://api.github.com/users/MistEO/gists{/gist_id}",
"starred_url": "https://api.github.com/users/MistEO/starred{/owner}{/repo}",
"subscriptions_url": "https://api.github.com/users/MistEO/subscriptions",
"organizations_url": "https://api.github.com/users/MistEO/orgs",
"repos_url": "https://api.github.com/users/MistEO/repos",
"events_url": "https://api.github.com/users/MistEO/events{/privacy}",
"received_events_url": "https://api.github.com/users/MistEO/received_events",
"type": "User",
"user_view_type": "public",
"site_admin": false
},
"created_at": "2026-03-19T06:54:52Z",
"updated_at": "2026-03-19T06:54:52Z",
"body": "@github-actions ",
"author_association": "OWNER",
"pin": null,
"reactions": {
"url": "https://api.github.com/repos/MistEO/ai-issue-analysis/issues/comments/4088194409/reactions",
"total_count": 0,
"+1": 0,
"-1": 0,
"laugh": 0,
"hooray": 0,
"confused": 0,
"heart": 0,
"rocket": 0,
"eyes": 0
},
"performed_via_github_app": null
},
{
"url": "https://api.github.com/repos/MistEO/ai-issue-analysis/issues/comments/4088195112",
"html_url": "https://github.com//issues/1#issuecomment-4088195112",
"issue_url": "https://api.github.com/repos//issues/1",
"id": 4088195112,
"node_id": "IC_kwDORo_lYc7zrOgo",
"user": {
"login": "github-actions[bot]",
"id": 41898282,
"node_id": "MDM6Qm90NDE4OTgyODI=",
"avatar_url": "https://avatars.githubusercontent.com/in/15368?v=4",
"gravatar_id": "",
"url": "https://api.github.com/users/github-actions%5Bbot%5D",
"html_url": "https://github.com/apps/github-actions",
"followers_url": "https://api.github.com/users/github-actions%5Bbot%5D/followers",
"following_url": "https://api.github.com/users/github-actions%5Bbot%5D/following{/other_user}",
"gists_url": "https://api.github.com/users/github-actions%5Bbot%5D/gists{/gist_id}",
"starred_url": "https://api.github.com/users/github-actions%5Bbot%5D/starred{/owner}{/repo}",
"subscriptions_url": "https://api.github.com/users/github-actions%5Bbot%5D/subscriptions",
"organizations_url": "https://api.github.com/users/github-actions%5Bbot%5D/orgs",
"repos_url": "https://api.github.com/users/github-actions%5Bbot%5D/repos",
"events_url": "https://api.github.com/users/github-actions%5Bbot%5D/events{/privacy}",
"received_events_url": "https://api.github.com/users/github-actions%5Bbot%5D/received_events",
"type": "Bot",
"user_view_type": "public",
"site_admin": false
},
"created_at": "2026-03-19T06:55:01Z",
"updated_at": "2026-03-19T06:55:06Z",
"body": "Copilot did not produce a final answer file: copilot_answer.md\n\n---\n\n

点击此处展开分析过程

\n\n🔗 GitHub Action 运行记录\n",
"author_association": "NONE",
"pin": null,
"reactions": {
"url": "https://api.github.com/repos/MistEO/ai-issue-analysis/issues/comments/4088195112/reactions",
"total_count": 0,
"+1": 0,
"-1": 0,
"laugh": 0,
"hooray": 0,
"confused": 0,
"heart": 0,
"rocket": 0,
"eyes": 0
},
"performed_via_github_app": {
"id": 15368,
"client_id": "Iv1.05c79e9ad1f6bdfa",
"slug": "github-actions",
"node_id": "MDM6QXBwMTUzNjg=",
"owner": {
"login": "github",
"id": 9919,
"node_id": "MDEyOk9yZ2FuaXphdGlvbjk5MTk=",
"avatar_url": "https://avatars.githubusercontent.com/u/9919?v=4",
"gravatar_id": "",
"url": "https://api.github.com/users/github",
"html_url": "https://github.com/github",
"followers_url": "https://api.github.com/users/github/followers",
"following_url": "https://api.github.com/users/github/following{/other_user}",
"gists_url": "https://api.github.com/users/github/gists{/gist_id}",
"starred_url": "https://api.github.com/users/github/starred{/owner}{/repo}",
"subscriptions_url": "https://api.github.com/users/github/subscriptions",
"organizations_url": "https://api.github.com/users/github/orgs",
"repos_url": "https://api.github.com/users/github/repos",
"events_url": "https://api.github.com/users/github/events{/privacy}",
"received_events_url": "https://api.github.com/users/github/received_events",
"type": "Organization",
"user_view_type": "public",
"site_admin": false
},
"name": "GitHub Actions",
"description": "Automate your workflow from idea to production",
"external_url": "https://help.github.com/en/actions",
"html_url": "https://github.com/apps/github-actions",
"created_at": "2018-07-30T09:30:17Z",
"updated_at": "2026-05-05T14:51:38Z",
"permissions": {
"actions": "write",
"administration": "read",
"artifact_metadata": "write",
"attestations": "write",
"checks": "write",
"code_quality": "write",
"contents": "write",
"copilot_requests": "write",
"deployments": "write",
"discussions": "write",
"issues": "write",
"merge_queues": "write",
"metadata": "read",
"models": "read",
"packages": "write",
"pages": "write",
"pull_requests": "write",
"repository_hooks": "write",
"repository_projects": "write",
"security_events": "write",
"statuses": "write",
"vulnerability_alerts": "read"
},
"events": [
"branch_protection_rule",
"check_run",
"check_suite",
"create",
"delete",
"deployment",
"deployment_status",
"discussion",
"discussion_comment",
"fork",
"gollum",
"issues",
"issue_comment",
"label",
"merge_group",
"milestone",
"page_build",
"public",
"pull_request",
"pull_request_review",
"pull_request_review_comment",
"push",
"registry_package",
"release",
"repository",
"repository_dispatch",
"status",
"watch",
"workflow_dispatch",
"workflow_run"
]
}
},
{
"url": "https://api.github.com/repos/MistEO/ai-issue-analysis/issues/comments/4647821760",
"html_url": "https://github.com//issues/1#issuecomment-4647821760",
"issue_url": "https://api.github.com/repos//issues/1",
"id": 4647821760,
"node_id": "IC_kwDORo_lYc8AAAABFQghwA",
"user": {
"login": "github-actions[bot]",
"id": 41898282,
"node_id": "MDM6Qm90NDE4OTgyODI=",
"avatar_url": "https://avatars.githubusercontent.com/in/15368?v=4",
"gravatar_id": "",
"url": "https://api.github.com/users/github-actions%5Bbot%5D",
"html_url": "https://github.com/apps/github-actions",
"followers_url": "https://api.github.com/users/github-actions%5Bbot%5D/followers",
"following_url": "https://api.github.com/users/github-actions%5Bbot%5D/following{/other_user}",
"gists_url": "https://api.github.com/users/github-actions%5Bbot%5D/gists{/gist_id}",
"starred_url": "https://api.github.com/users/github-actions%5Bbot%5D/starred{/owner}{/repo}",
"subscriptions_url": "https://api.github.com/users/github-actions%5Bbot%5D/subscriptions",
"organizations_url": "https://api.github.com/users/github-actions%5Bbot%5D/orgs",
"repos_url": "https://api.github.com/users/github-actions%5Bbot%5D/repos",
"events_url": "https://api.github.com/users/github-actions%5Bbot%5D/events{/privacy}",
"received_events_url": "https://api.github.com/users/github-actions%5Bbot%5D/received_events",
"type": "Bot",
"user_view_type": "public",
"site_admin": false
},
"created_at": "2026-06-08T10:12:56Z",
"updated_at": "2026-06-08T10:12:56Z",
"body": "🤖 AI 正在分析该 Issue... \n\n感谢您的反馈！AI 正在自动分析该问题，预计耗时约 10 分钟。\n\n---\n🔗 GitHub Action 运行记录",
"author_association": "NONE",
"pin": null,
"reactions": {
"url": "https://api.github.com/repos/MistEO/ai-issue-analysis/issues/comments/4647821760/reactions",
"total_count": 0,
"+1": 0,
"-1": 0,
"laugh": 0,
"hooray": 0,
"confused": 0,
"heart": 0,
"rocket": 0,
"eyes": 0
},
"performed_via_github_app": {
"id": 15368,
"client_id": "Iv1.05c79e9ad1f6bdfa",
"slug": "github-actions",
"node_id": "MDM6QXBwMTUzNjg=",
"owner": {
"login": "github",
"id": 9919,
"node_id": "MDEyOk9yZ2FuaXphdGlvbjk5MTk=",
"avatar_url": "https://avatars.githubusercontent.com/u/9919?v=4",
"gravatar_id": "",
"url": "https://api.github.com/users/github",
"html_url": "https://github.com/github",
"followers_url": "https://api.github.com/users/github/followers",
"following_url": "https://api.github.com/users/github/following{/other_user}",
"gists_url": "https://api.github.com/users/github/gists{/gist_id}",
"starred_url": "https://api.github.com/users/github/starred{/owner}{/repo}",
"subscriptions_url": "https://api.github.com/users/github/subscriptions",
"organizations_url": "https://api.github.com/users/github/orgs",
"repos_url": "https://api.github.com/users/github/repos",
"events_url": "https://api.github.com/users/github/events{/privacy}",
"received_events_url": "https://api.github.com/users/github/received_events",
"type": "Organization",
"user_view_type": "public",
"site_admin": false
},
"name": "GitHub Actions",
"description": "Automate your workflow from idea to production",
"external_url": "https://help.github.com/en/actions",
"html_url": "https://github.com/apps/github-actions",
"created_at": "2018-07-30T09:30:17Z",
"updated_at": "2026-05-05T14:51:38Z",
"permissions": {
"actions": "write",
"administration": "read",
"artifact_metadata": "write",
"attestations": "write",
"checks": "write",
"code_quality": "write",
"contents": "write",
"copilot_requests": "write",
"deployments": "write",
"discussions": "write",
"issues": "write",
"merge_queues": "write",
"metadata": "read",
"models": "read",
"packages": "write",
"pages": "write",
"pull_requests": "write",
"repository_hooks": "write",
"repository_projects": "write",
"security_events": "write",
"statuses": "write",
"vulnerability_alerts": "read"
},
"events": [
"branch_protection_rule",
"check_run",
"check_suite",
"create",
"delete",
"deployment",
"deployment_status",
"discussion",
"discussion_comment",
"fork",
"gollum",
"issues",
"issue_comment",
"label",
"merge_group",
"milestone",
"page_build",
"public",
"pull_request",
"pull_request_review",
"pull_request_review_comment",
"push",
"registry_package",
"release",
"repository",
"repository_dispatch",
"status",
"watch",
"workflow_dispatch",
"workflow_run"
]
}
}
]

codex
Issue 1 本身只有一个 MaaEnd 代码链接，评论里早期两次运行都显示缺少最终答案文件 copilot_answer.md。我还需要打开该外部代码片段以及仓库历史配置，判断这是测试输入、上游问题，还是本 action 早期配置/脚本问题。
exec
/bin/bash -lc "sed -n '520,760p' action.yml" in /home/runner/work/ai-issue-analysis/ai-issue-analysis
succeeded in 0ms:
return path.read_text(encoding="utf-8")
return f"{missing_message}\n"

    def truncate_for_output(value: str, label: str, max_bytes: int = 300000) -> str:
        encoded = value.encode("utf-8")
        if len(encoded) <= max_bytes:
            return value

        suffix = (
            f"\n\n[Truncated {label} for GitHub Actions output size limits. "
            "Use the uploaded artifact for the full content.]\n"
        )
        suffix_bytes = suffix.encode("utf-8")
        trimmed = encoded[: max_bytes - len(suffix_bytes)].decode("utf-8", errors="ignore")
        return f"{trimmed}{suffix}"

    codex_output = read_or_placeholder(
        codex_output_file,
        f"Codex output file not found: {codex_output_file}",
    )
    final_conclusion = read_or_placeholder(
        answer_file,
        f"Answer file not found: {answer_file}",
    )
    analysis_prompt = read_or_placeholder(
        analysis_prompt_file,
        f"Analysis prompt file not found: {analysis_prompt_file}",
    )

    codex_output_artifact_file.write_text(codex_output, encoding="utf-8")
    final_conclusion_artifact_file.write_text(final_conclusion, encoding="utf-8")

    def write_multiline_output(name: str, value: str) -> None:
        delimiter = f"EOF_{uuid.uuid4().hex}"
        normalized_value = value if value.endswith("\n") else f"{value}\n"
        with github_output.open("a", encoding="utf-8") as fh:
            fh.write(f"{name}<<{delimiter}\n")
            fh.write(normalized_value)
            fh.write(f"{delimiter}\n")

    with github_output.open("a", encoding="utf-8") as fh:
        fh.write(f"comment-id={comment_id}\n")
        fh.write(f"comment-url={comment_url}\n")

    write_multiline_output(
        "analysis-prompt",
        truncate_for_output(analysis_prompt, "analysis-prompt"),
    )
    write_multiline_output(
        "codex-output",
        truncate_for_output(codex_output, "codex-output"),
    )
    write_multiline_output(
        "final-conclusion",
        truncate_for_output(final_conclusion, "final-conclusion"),
    )
    PY

- name: Upload Codex output artifact
  if: ${{ always() }}
  uses: actions/upload-artifact@v4
  with:
    name: codex-output-issue-${{ steps.issue_number.outputs.issue_number }}-comment-${{ steps.initial_comment.outputs.comment-id || 'none' }}
    path: ${{ steps.runtime.outputs.codex_output_artifact_file }}
    if-no-files-found: error

- name: Upload final conclusion artifact
  if: ${{ always() }}
  uses: actions/upload-artifact@v4
  with:
    name: final-conclusion-issue-${{ steps.issue_number.outputs.issue_number }}-comment-${{ steps.initial_comment.outputs.comment-id || 'none' }}
    path: ${{ steps.runtime.outputs.final_conclusion_artifact_file }}
    if-no-files-found: error

- name: Update comment with analysis result
  if: ${{ always() && steps.initial_comment.outputs.comment-id != '' }}
  uses: peter-evans/create-or-update-comment@v4
  with:
    comment-id: ${{ steps.initial_comment.outputs.comment-id }}
    edit-mode: replace
    body-path: ${{ steps.runtime.outputs.final_comment_file }}
    token: ${{ inputs.github-token }}

exec
/bin/bash -lc 'rg -n "copilot_answer|answer-file|final answer|Copilot|claude|codex|answer.md|final-conclusion" -S .' in /home/runner/work/ai-issue-analysis/ai-issue-analysis
succeeded in 0ms:
./README.md:27: - .claude/skills/generic-issue-log-analysis/SKILL.md
./README.md:34:> - MaaEnd
./README.md:35:> - MaaAssistantArknights
./README.md:47:- codex-api-key: Codex CLI 使用的 API Key（会设为 OPENAI_API_KEY 环境变量），支持传多个 key，每行一个，action 会随机选择一个使用
./README.md:48:- codex-base-url: API 端点 base URL（会设为 OPENAI_BASE_URL 环境变量），留空则使用 OpenAI 默认端点
./README.md:49:- codex-model: 模型名称，默认 o3
./README.md:50:- codex-package: 安装的 npm 包名，默认 @openai/codex
./README.md:59:- answer-file: AI 写入最终结论的文件路径，默认 answer.md
./README.md:68:- codex-output: 完整执行日志，包含 Codex 启动前的参数打印、prompt 正文，以及 Codex CLI 输出
./README.md:69:- final-conclusion: Codex 写入 answer-file 的最终结论
./README.md:70:- analysis-prompt、codex-output 和 final-conclusion 在过长时会为适配 GitHub Actions output 大小限制而被截断；完整内容优先从 artifacts 读取
./README.md:74:- codex-output-issue-<issue-number>-comment-<comment-id>: 完整执行日志，包含启动前参数、prompt 正文和 Codex CLI 输出
./README.md:75:- final-conclusion-issue-<issue-number>-comment-<comment-id>: 最终结论文本
./README.md:83:- 最佳实践参考，MaaEnd: https://github.com/MaaEnd/MaaEnd/blob/v2/.claude/skills/maaend-issue-log-analysis/SKILL.md
./README.md:84:- 最佳实践参考，MaaAssistantArknights: https://github.com/MaaAssistantArknights/MaaAssistantArknights/blob/dev-v2/.claude/skills/maa-issue-log-analysis/SKILL.md
./README.md:98:- 会自动安装 @openai/codex
./README.md:100:- 会导出 `...[Comment body truncated]

	copilot-answer-file:
	description: File path where the prompt asks Copilot to write the final answer.
	required: false
	default: copilot_answer.md

	- name: Build analysis prompt
	shell: bash
	env:
	EVENT_NAME: ${{ github.event_name }}
	ISSUE_NUMBER: ${{ steps.issue_number.outputs.issue_number }}
	BOT_NAME: ${{ inputs.bot-name }}
	ANALYSIS_PROMPT_FILE: ${{ steps.runtime.outputs.analysis_prompt_file }}
	COPILOT_ANSWER_FILE: ${{ inputs.copilot-answer-file }}
	PROMPT_TEMPLATE: ${{ inputs.prompt-template }}
	COMMENT_PROMPT_TEMPLATE: ${{ inputs.comment-prompt-template }}
	REPOSITORY: ${{ github.repository }}
	run: \|
	python <<'PY'
	import json
	import os
	import re
	from pathlib import Path

	event_name = os.environ["EVENT_NAME"]
	issue_number = os.environ["ISSUE_NUMBER"]
	bot_name = os.environ["BOT_NAME"]
	analysis_prompt_file = Path(os.environ["ANALYSIS_PROMPT_FILE"])
	copilot_answer_file = os.environ["COPILOT_ANSWER_FILE"]
	prompt_template = os.environ["PROMPT_TEMPLATE"]
	comment_prompt_template = os.environ["COMMENT_PROMPT_TEMPLATE"]
	repository = os.environ["REPOSITORY"]
	event = json.loads(Path(os.environ["GITHUB_EVENT_PATH"]).read_text(encoding="utf-8"))

	raw_comment = ""
	if event_name == "issue_comment":
	raw_comment = event.get("comment", {}).get("body", "")

	cleaned_comment = raw_comment
	if bot_name:
	cleaned_comment = re.sub(rf"{re.escape(bot_name)}\b", "", cleaned_comment, flags=re.IGNORECASE)
	cleaned_comment = re.sub(r"^[\s,，.。!！?？:：]+", "", cleaned_comment).strip()

	- name: Run Copilot analysis with streaming updates
	shell: bash
	env:
	COPILOT_GITHUB_TOKEN: ${{ steps.resolve_copilot_token.outputs.copilot_token }}
	GITHUB_TOKEN: ${{ inputs.github-token }}
	GITHUB_SERVER_URL: ${{ github.server_url }}
	COMMENT_ID: ${{ steps.initial_comment.outputs.comment-id }}
	ISSUE_NUMBER: ${{ steps.issue_number.outputs.issue_number }}
	REPO: ${{ github.repository }}
	ANALYSIS_PROMPT_FILE: ${{ steps.runtime.outputs.analysis_prompt_file }}
	OUTPUT_FILE: ${{ steps.runtime.outputs.copilot_output_file }}
	EXECUTION_LOG_FILE: ${{ steps.runtime.outputs.copilot_execution_log_file }}
	BODY_FILE: ${{ steps.runtime.outputs.comment_body_file }}
	INITIAL_BODY: ${{ inputs.initial-comment-body }}
	ACTION_LINK: ${{ steps.runtime.outputs.action_link }}
	DETAILS_BEGIN: ${{ steps.runtime.outputs.details_begin }}
	DETAILS_END: ${{ steps.runtime.outputs.details_end }}
	COPILOT_MODEL: ${{ inputs.copilot-model }}
	COPILOT_REASONING_EFFORT: ${{ inputs.copilot-reasoning-effort }}
	STREAM_UPDATE_INTERVAL: ${{ inputs.stream-update-interval-seconds }}
	run: \|
	COMMENT_URL="$GITHUB_SERVER_URL/$REPO/issues/$ISSUE_NUMBER#issuecomment-$COMMENT_ID"

	: > "$OUTPUT_FILE"
	: > "$EXECUTION_LOG_FILE"
	{
	echo "Copilot invocation parameters:"
	echo " repo: $REPO"
	echo " issue-number: $ISSUE_NUMBER"
	echo " comment-id: $COMMENT_ID"
	echo " comment-url: $COMMENT_URL"
	echo " model: $COPILOT_MODEL"
	echo " reasoning-effort: $COPILOT_REASONING_EFFORT"
	echo " copilot-token-count: ${{ steps.resolve_copilot_token.outputs.copilot_token_count }}"
	echo " stream-update-interval-seconds: $STREAM_UPDATE_INTERVAL"
	echo " analysis-prompt-file: $ANALYSIS_PROMPT_FILE"
	echo " output-file: $OUTPUT_FILE"
	echo " body-file: $BODY_FILE"
	echo " command: copilot --yolo --model \"$COPILOT_MODEL\" --reasoning-effort \"$COPILOT_REASONING_EFFORT\" --prompt \"<contents of $ANALYSIS_PROMPT_FILE>\""
	echo "Prompt content begins"
	cat "$ANALYSIS_PROMPT_FILE"
	echo "Prompt content ends"
	} \| tee -a "$EXECUTION_LOG_FILE"

	copilot --yolo --model "$COPILOT_MODEL" --reasoning-effort "$COPILOT_REASONING_EFFORT" \
	--prompt "$(cat "$ANALYSIS_PROMPT_FILE")" > "$OUTPUT_FILE" 2>&1 &
	COPILOT_PID=$!
	echo "Copilot started with PID $COPILOT_PID" \| tee -a "$EXECUTION_LOG_FILE"

	last_content=""

	while true; do
	sleep "$STREAM_UPDATE_INTERVAL" &
	sleep_pid=$!

	wait -n "$COPILOT_PID" "$sleep_pid" 2>/dev/null \|\| true

	if ! kill -0 "$COPILOT_PID" 2>/dev/null; then
	kill "$sleep_pid" 2>/dev/null \|\| true
	break
	fi

	if [ -f "$OUTPUT_FILE" ]; then
	current_content=$(cat "$OUTPUT_FILE")
	if [ "$current_content" != "$last_content" ] && [ -n "$current_content" ]; then
	{
	echo "$INITIAL_BODY"
	echo
	echo "---"
	echo
	echo "$DETAILS_BEGIN"
	echo "$current_content"
	echo "$DETAILS_END"
	echo
	echo "$ACTION_LINK"
	} > "$BODY_FILE"

	jq -n --arg body "$(cat "$BODY_FILE")" '{"body":$body}' \| \
	curl -s -L -X PATCH \
	-H "Authorization: token $GITHUB_TOKEN" \
	-H "Accept: application/vnd.github.v3+json" \
	"https://api.github.com/repos/$REPO/issues/comments/$COMMENT_ID" \
	-d @-

	last_content="$current_content"
	echo "Comment updated at $(date)"
	fi
	fi
	done

	wait "$COPILOT_PID"

	- name: Full analysis
	if: ${{ always() }}
	shell: bash
	env:
	COPILOT_OUTPUT_FILE: ${{ steps.runtime.outputs.copilot_execution_log_file }}
	COPILOT_ANSWER_FILE: ${{ inputs.copilot-answer-file }}
	run: \|
	if [ -f "$COPILOT_OUTPUT_FILE" ]; then
	cat "$COPILOT_OUTPUT_FILE"
	fi
	echo
	echo "---"
	echo
	if [ -f "$COPILOT_ANSWER_FILE" ]; then
	cat "$COPILOT_ANSWER_FILE"
	else
	echo "Copilot answer file not found: $COPILOT_ANSWER_FILE"
	fi

	- name: Prepare final comment
	if: ${{ always() }}
	shell: bash
	env:
	COPILOT_ANSWER_FILE: ${{ inputs.copilot-answer-file }}
	COPILOT_OUTPUT_FILE: ${{ steps.runtime.outputs.copilot_output_file }}
	FINAL_COMMENT_FILE: ${{ steps.runtime.outputs.final_comment_file }}
	ACTION_LINK: ${{ steps.runtime.outputs.action_link }}
	DETAILS_BEGIN: ${{ steps.runtime.outputs.details_begin }}
	DETAILS_END: ${{ steps.runtime.outputs.details_end }}
	run: \|
	: > "$FINAL_COMMENT_FILE"

	if [ -f "$COPILOT_ANSWER_FILE" ]; then
	cat "$COPILOT_ANSWER_FILE" >> "$FINAL_COMMENT_FILE"
	else
	echo "Copilot did not produce a final answer file: $COPILOT_ANSWER_FILE" >> "$FINAL_COMMENT_FILE"
	fi

	{
	echo
	echo "---"
	echo
	echo "$DETAILS_BEGIN"
	if [ -f "$COPILOT_OUTPUT_FILE" ]; then
	cat "$COPILOT_OUTPUT_FILE"
	fi
	echo "$DETAILS_END"
	echo
	echo "$ACTION_LINK"
	} >> "$FINAL_COMMENT_FILE"

	answer-file:
	description: File path where the prompt asks the AI to write the final answer.
	required: false
	default: answer.md

	def render(template: str) -> str:
	return (
	template
	.replace("{{issue_number}}", issue_number)
	.replace("{{answer_file}}", answer_file)
	.replace("{{comment_body}}", cleaned_comment)
	.replace("{{repository}}", repository)
	.replace("{{event_name}}", event_name)
	)

	prompt = render(prompt_template).strip()
	extra_prompt = render(comment_prompt_template).strip() if cleaned_comment else ""

	if extra_prompt:
	prompt = f"{prompt}\n\n{extra_prompt}" if prompt else extra_prompt

	analysis_prompt_file.write_text(f"{prompt}\n", encoding="utf-8")

	- name: Run Codex analysis with streaming updates
	shell: bash
	env:
	CODEX_API_KEY: ${{ steps.resolve_codex_key.outputs.codex_api_key }}
	COMMENT_GITHUB_TOKEN: ${{ inputs.github-token }}
	GITHUB_SERVER_URL: ${{ github.server_url }}
	COMMENT_ID: ${{ steps.initial_comment.outputs.comment-id }}
	ISSUE_NUMBER: ${{ steps.issue_number.outputs.issue_number }}
	REPO: ${{ github.repository }}
	ANALYSIS_PROMPT_FILE: ${{ steps.runtime.outputs.analysis_prompt_file }}
	OUTPUT_FILE: ${{ steps.runtime.outputs.codex_output_file }}
	EXECUTION_LOG_FILE: ${{ steps.runtime.outputs.codex_execution_log_file }}
	BODY_FILE: ${{ steps.runtime.outputs.comment_body_file }}
	INITIAL_BODY: ${{ inputs.initial-comment-body }}
	ACTION_LINK: ${{ steps.runtime.outputs.action_link }}
	DETAILS_BEGIN: ${{ steps.runtime.outputs.details_begin }}
	DETAILS_END: ${{ steps.runtime.outputs.details_end }}
	CODEX_MODEL: ${{ inputs.codex-model }}
	STREAM_UPDATE_INTERVAL: ${{ inputs.stream-update-interval-seconds }}
	EXTRA_COMMENT_CONTENT: ${{ inputs.extra-comment-content }}
	run: \|
	COMMENT_URL="$GITHUB_SERVER_URL/$REPO/issues/$ISSUE_NUMBER#issuecomment-$COMMENT_ID"

	: > "$OUTPUT_FILE"
	: > "$EXECUTION_LOG_FILE"
	{
	echo "Codex invocation parameters:"
	echo " repo: $REPO"
	echo " issue-number: $ISSUE_NUMBER"
	echo " comment-id: $COMMENT_ID"
	echo " comment-url: $COMMENT_URL"
	echo " model: $CODEX_MODEL"
	echo " api-key-count: ${{ steps.resolve_codex_key.outputs.codex_key_count }}"
	echo " stream-update-interval-seconds: $STREAM_UPDATE_INTERVAL"
	echo " analysis-prompt-file: $ANALYSIS_PROMPT_FILE"
	echo " output-file: $OUTPUT_FILE"
	echo " body-file: $BODY_FILE"
	echo " codex config:"
	cat ~/.codex/config.toml
	echo " command: codex exec --dangerously-bypass-approvals-and-sandbox \"<contents of $ANALYSIS_PROMPT_FILE>\""
	echo "Prompt content begins"
	cat "$ANALYSIS_PROMPT_FILE"
	echo "Prompt content ends"
	} \| tee -a "$EXECUTION_LOG_FILE"

	codex exec --dangerously-bypass-approvals-and-sandbox \
	"$(cat "$ANALYSIS_PROMPT_FILE")" > "$OUTPUT_FILE" 2>&1 &
	CODEX_PID=$!
	echo "Codex started with PID $CODEX_PID" \| tee -a "$EXECUTION_LOG_FILE"

	last_content=""

	while true; do
	sleep "$STREAM_UPDATE_INTERVAL" &
	sleep_pid=$!

	wait -n "$CODEX_PID" "$sleep_pid" 2>/dev/null \|\| true

	if ! kill -0 "$CODEX_PID" 2>/dev/null; then
	kill "$sleep_pid" 2>/dev/null \|\| true
	break
	fi

	if [ -f "$OUTPUT_FILE" ]; then
	current_content=$(cat "$OUTPUT_FILE")
	if [ "$current_content" != "$last_content" ] && [ -n "$current_content" ]; then
	truncated_content="$current_content"
	if [ "${#truncated_content}" -gt 55000 ]; then
	truncated_content="${truncated_content:0:55000}"$'\n\n[truncated for comment size limit]'
	fi
	{
	echo "$INITIAL_BODY"
	echo
	echo "---"
	echo
	echo "$DETAILS_BEGIN"
	echo
	echo '```text'
	echo "$truncated_content"
	echo '```'
	echo
	echo "$DETAILS_END"
	echo
	echo "$ACTION_LINK"
	if [ -n "$EXTRA_COMMENT_CONTENT" ]; then
	echo
	echo "$EXTRA_COMMENT_CONTENT"
	fi
	} > "$BODY_FILE"

	jq -Rs '{"body":.}' < "$BODY_FILE" \| \
	curl -s -L -X PATCH \
	-H "Authorization: token $COMMENT_GITHUB_TOKEN" \
	-H "Accept: application/vnd.github.v3+json" \
	"https://api.github.com/repos/$REPO/issues/comments/$COMMENT_ID" \
	-d @-

	last_content="$current_content"
	echo "Comment updated at $(date)"
	fi
	fi
	done

	wait "$CODEX_PID"
	CODEX_EXIT=$?

测试测试 #1

Description

Metadata

Metadata

Assignees

Labels

Projects

Milestone

Relationships

Development

Issue actions