@ranger1/dx 0.1.35 → 0.1.37

package/@opencode/agents/gh-thread-reviewer.md

@@ -0,0 +1,105 @@
+---
+description: review (GitHub Harvest)
+mode: subagent
+model: openai/gpt-5.2
+temperature: 0.2
+tools:
+  write: true
+  edit: false
+  bash: true
+---
+
+# PR Reviewer (GitHub Harvest)
+
+Harvest all GitHub PR review feedback (humans + bots, including Copilot) and normalize into a standard `reviewFile`.
+
+## 输入（prompt 必须包含）
+
+- `PR #<number>`
+- `round: <number>`
+- `runId: <string>`（必须透传，禁止自行生成）
+- `contextFile: <filename>`
+
+## Cache 约定（强制）
+
+- 缓存目录固定为 `./.cache/`；交接一律传 `./.cache/<file>`（repo 相对路径），禁止 basename-only（如 `foo.md`）。
+
+## 输出（强制）
+
+只输出一行：
+
+`reviewFile: ./.cache/<file>.md`
+
+## reviewFile 格式（强制）
+
+```md
+# Review (GHR)
+
+PR: <PR_NUMBER>
+Round: <ROUND>
+
+## Summary
+
+P0: <n>
+P1: <n>
+P2: <n>
+P3: <n>
+
+## Findings
+
+- id: GHR-RC-2752827557
+  priority: P1
+  category: quality|performance|security|architecture
+  file: <path>
+  line: <number|null>
+  title: <short>
+  description: <single-line text>
+  suggestion: <single-line text>
+```
+
+## ID 规则（强制）
+
+- Inline 评审（discussion_r...）：`GHR-RC-<databaseId>`（databaseId 可映射到 `#discussion_r<databaseId>`）
+- PR Review 总评：`GHR-RV-<reviewId>`
+- PR 普通评论：`GHR-IC-<issueCommentId>`
+
+## 执行步骤（强制）
+
+1) Harvest（确定性）
+
+- 调用脚本生成 raw JSON：
+
+```bash
+python3 ~/.opencode/agents/gh_review_harvest.py \
+  --pr <PR_NUMBER> \
+  --round <ROUND> \
+  --run-id <RUN_ID>
+```
+
+- 脚本 stdout 会输出一行 JSON：`{"rawFile":"./.cache/...json"}`，从中取 `rawFile`。
+
+2) Normalize（LLM 分类）
+
+- 读取 `rawFile`（JSON）后，提取“建议/问题”并生成 findings：
+  - 覆盖 humans + bots（不做作者白名单）。
+  - 去噪：丢弃任何 body 中包含 `<!-- pr-review-loop-marker` 的内容。
+  - 忽略纯审批/无内容：如 `LGTM`、`Looks good`、`Approved` 等。
+  - 默认策略：
+    - `isResolved=true` 或 `isOutdated=true` 的 thread 在 harvest 阶段直接丢弃（不进入 rawFile，不消耗 LLM token）。
+  - 分类规则（大致）：
+    - P0: 明确安全漏洞/数据泄漏/资金损失/远程执行
+    - P1: 逻辑 bug/权限绕过/会导致线上错误
+    - P2: 潜在 bug/鲁棒性/边界条件/可维护性重大问题
+    - P3: 风格/命名/小优化/可选建议
+  - `category` 只能取：quality|performance|security|architecture
+
+3) 写入 reviewFile
+
+- 文件名固定：`./.cache/review-GHR-pr<PR_NUMBER>-r<ROUND>-<RUN_ID>.md`
+- 重要：`title/description/suggestion` 必须是单行；原文有换行时用 `\\n` 转义。
+
+## 禁止事项（强制）
+
+- ⛔ 不发布 GitHub 评论（不调用 `gh pr comment/review`）
+- ⛔ 不修改代码（只输出 reviewFile）
+- ⛔ 不生成/伪造 runId

package/@opencode/agents/gh_review_harvest.py

@@ -0,0 +1,269 @@
+#!/usr/bin/env python3
+
+# Deterministic GitHub PR review harvester.
+#
+# - Fetches inline review threads via GraphQL (reviewThreads) with pagination.
+# - Fetches PR reviews and PR issue comments via REST (gh api) with pagination.
+# - Writes a raw JSON file into project cache: ./.cache/
+# - Prints exactly one JSON object to stdout: {"rawFile":"./.cache/...json"}
+
+import argparse
+import json
+import os
+import subprocess
+import sys
+from datetime import datetime, timezone
+from pathlib import Path
+
+
+def _repo_root():
+    try:
+        p = subprocess.run(
+            ["git", "rev-parse", "--show-toplevel"],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.DEVNULL,
+            text=True,
+        )
+        out = (p.stdout or "").strip()
+        if p.returncode == 0 and out:
+            return Path(out)
+    except Exception:
+        pass
+    return Path.cwd()
+
+
+def _cache_dir(repo_root):
+    return (repo_root / ".cache").resolve()
+
+
+def _repo_relpath(repo_root, p):
+    try:
+        rel = p.resolve().relative_to(repo_root.resolve())
+        return "./" + rel.as_posix()
+    except Exception:
+        return os.path.basename(str(p))
+
+
+REPO_ROOT = _repo_root()
+CACHE_DIR = _cache_dir(REPO_ROOT)
+
+
+def _json_out(obj):
+    sys.stdout.write(json.dumps(obj, ensure_ascii=True))
+    sys.stdout.write("\n")
+
+
+def _run_capture(cmd):
+    try:
+        p = subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+        return p.returncode, p.stdout, p.stderr
+    except FileNotFoundError as e:
+        return 127, "", str(e)
+
+
+def _require_gh_auth():
+    rc, out, err = _run_capture(["gh", "auth", "status"])
+    if rc == 127:
+        return False, "GH_CLI_NOT_FOUND", "gh not found in PATH"
+    if rc != 0:
+        detail = (err or out or "").strip()
+        if len(detail) > 4000:
+            detail = detail[-4000:]
+        return False, "GH_NOT_AUTHENTICATED", detail
+    return True, None, None
+
+
+def _resolve_owner_repo(explicit_repo):
+    if explicit_repo:
+        s = str(explicit_repo).strip()
+        if s and "/" in s:
+            return s
+    rc, out, _ = _run_capture(["gh", "repo", "view", "--json", "nameWithOwner", "--jq", ".nameWithOwner"])
+    owner_repo = out.strip() if rc == 0 else ""
+    return owner_repo or None
+
+
+def _gh_api_json(args):
+    rc, out, err = _run_capture(["gh", "api"] + args)
+    if rc != 0:
+        raise RuntimeError(f"GH_API_FAILED: {(err or out or '').strip()}")
+    try:
+        return json.loads(out or "null")
+    except Exception:
+        raise RuntimeError("GH_API_JSON_PARSE_FAILED")
+
+
+def _gh_api_graphql(query, variables):
+    cmd = ["gh", "api", "graphql", "-f", f"query={query}"]
+    for k, v in (variables or {}).items():
+        if isinstance(v, int):
+            cmd.extend(["-F", f"{k}={v}"])
+        elif v is None:
+            cmd.extend(["-f", f"{k}="])
+        else:
+            cmd.extend(["-f", f"{k}={v}"])
+
+    rc, out, err = _run_capture(cmd)
+    if rc != 0:
+        raise RuntimeError(f"GH_GRAPHQL_FAILED: {(err or out or '').strip()}")
+    try:
+        return json.loads(out or "null")
+    except Exception:
+        raise RuntimeError("GH_GRAPHQL_JSON_PARSE_FAILED")
+
+
+def _flatten_threads(gql_data):
+    threads = []
+    pr = (((gql_data or {}).get("data") or {}).get("repository") or {}).get("pullRequest") or {}
+    conn = pr.get("reviewThreads") or {}
+    nodes = conn.get("nodes") or []
+    for t in nodes:
+        is_resolved = bool((t or {}).get("isResolved"))
+        is_outdated = bool((t or {}).get("isOutdated"))
+        if is_resolved or is_outdated:
+            continue
+        comments_conn = (t or {}).get("comments") or {}
+        comments_nodes = comments_conn.get("nodes") or []
+        comments = []
+        for c in comments_nodes:
+            author = (c or {}).get("author") or {}
+            comments.append(
+                {
+                    "id": (c or {}).get("id"),
+                    "databaseId": (c or {}).get("databaseId"),
+                    "url": (c or {}).get("url"),
+                    "author": {
+                        "login": author.get("login"),
+                        "type": author.get("__typename"),
+                    },
+                    "body": (c or {}).get("body") or "",
+                    "bodyText": (c or {}).get("bodyText") or "",
+                    "createdAt": (c or {}).get("createdAt"),
+                    "updatedAt": (c or {}).get("updatedAt"),
+                }
+            )
+        threads.append(
+            {
+                "id": (t or {}).get("id"),
+                "isResolved": False,
+                "isOutdated": False,
+                "path": (t or {}).get("path"),
+                "line": (t or {}).get("line"),
+                "originalLine": (t or {}).get("originalLine"),
+                "startLine": (t or {}).get("startLine"),
+                "originalStartLine": (t or {}).get("originalStartLine"),
+                "comments": comments,
+            }
+        )
+
+    page_info = conn.get("pageInfo") or {}
+    return threads, {
+        "hasNextPage": bool(page_info.get("hasNextPage")),
+        "endCursor": page_info.get("endCursor"),
+    }
+
+
+def _fetch_all_review_threads(owner, repo, pr_number):
+    query = (
+        "query($owner:String!,$repo:String!,$prNumber:Int!,$after:String){"
+        "repository(owner:$owner,name:$repo){"
+        "pullRequest(number:$prNumber){"
+        "reviewThreads(first:100,after:$after){"
+        "pageInfo{hasNextPage endCursor}"
+        "nodes{"
+        "id isResolved isOutdated path line originalLine startLine originalStartLine "
+        "comments(first:100){nodes{"
+        "id databaseId url body bodyText createdAt updatedAt author{login __typename}"
+        "}}"
+        "}"
+        "}"
+        "}"
+        "}"
+        "}"
+    )
+
+    after = None
+    all_threads = []
+    while True:
+        data = _gh_api_graphql(query, {"owner": owner, "repo": repo, "prNumber": pr_number, "after": after})
+        threads, page = _flatten_threads(data)
+        all_threads.extend(threads)
+        if not page.get("hasNextPage"):
+            break
+        after = page.get("endCursor")
+        if not after:
+            break
+    return all_threads
+
+
+def main(argv):
+    class _ArgParser(argparse.ArgumentParser):
+        def error(self, message):
+            raise ValueError(message)
+
+    parser = _ArgParser(add_help=False)
+    parser.add_argument("--pr", type=int, required=True)
+    parser.add_argument("--round", type=int, default=1)
+    parser.add_argument("--run-id", required=True)
+    parser.add_argument("--repo")
+
+    try:
+        args = parser.parse_args(argv)
+    except ValueError:
+        _json_out({"error": "INVALID_ARGS"})
+        return 2
+
+    ok, code, detail = _require_gh_auth()
+    if not ok:
+        _json_out({"error": code, "detail": detail})
+        return 1
+
+    owner_repo = _resolve_owner_repo(args.repo)
+    if not owner_repo:
+        _json_out({"error": "REPO_NOT_FOUND"})
+        return 1
+    if "/" not in owner_repo:
+        _json_out({"error": "INVALID_REPO"})
+        return 1
+
+    owner, repo = owner_repo.split("/", 1)
+    pr_number = int(args.pr)
+    round_num = int(args.round)
+    run_id = str(args.run_id).strip()
+    if not run_id:
+        _json_out({"error": "MISSING_RUN_ID"})
+        return 1
+
+    CACHE_DIR.mkdir(parents=True, exist_ok=True)
+    raw_basename = f"gh-review-raw-pr{pr_number}-r{round_num}-{run_id}.json"
+    raw_path = CACHE_DIR / raw_basename
+
+    try:
+        threads = _fetch_all_review_threads(owner, repo, pr_number)
+
+        reviews = _gh_api_json([f"repos/{owner_repo}/pulls/{pr_number}/reviews", "--paginate"])
+        issue_comments = _gh_api_json([f"repos/{owner_repo}/issues/{pr_number}/comments", "--paginate"])
+
+        now = datetime.now(timezone.utc).isoformat()
+        payload = {
+            "repo": owner_repo,
+            "pr": pr_number,
+            "round": round_num,
+            "runId": run_id,
+            "generatedAt": now,
+            "reviewThreads": threads,
+            "reviews": reviews if isinstance(reviews, list) else [],
+            "issueComments": issue_comments if isinstance(issue_comments, list) else [],
+        }
+
+        raw_path.write_text(json.dumps(payload, ensure_ascii=True), encoding="utf-8", newline="\n")
+    except Exception as e:
+        _json_out({"error": "HARVEST_FAILED", "detail": str(e)[:800]})
+        return 1
+
+    _json_out({"rawFile": _repo_relpath(REPO_ROOT, raw_path)})
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main(sys.argv[1:]))

package/@opencode/agents/pr-review-aggregate.md

@@ -21,7 +21,7 @@ tools:
 - `round: <number>`
 - `runId: <string>`
 - `contextFile: <path>`（例如：`./.cache/pr-context-...md`）
-- `reviewFile: <path>`（三行，分别对应 CDX/CLD/GMN，例如：`./.cache/review-...md`）
+- `reviewFile: <path>`（多行，1+ 条；例如：`./.cache/review-...md`）
 
 ### 模式 B：发布修复评论（基于 fixReportFile）
 
@@ -53,7 +53,7 @@ runId: abcdef123456
 
 ## 重复分组（仅作为脚本入参）
 
-你需要基于 3 份 `reviewFile` 内容判断重复 finding 分组，生成**一行 JSON**（不要代码块、不要解释文字、不要换行）。
+你需要基于所有 `reviewFile` 内容判断重复 finding 分组，生成**一行 JSON**（不要代码块、不要解释文字、不要换行）。
 
 注意：这行 JSON **不是你的最终输出**，它只用于生成 `--duplicate-groups-b64` 传给脚本。
 

package/@opencode/agents/pr_review_aggregate.py

@@ -318,13 +318,66 @@ def _counts(findings):
     return c
 
 
-def _post_pr_comment(pr_number, body_ref):
+def _check_existing_comment(pr_number, run_id, round_num, comment_type):
+    """
+    Check if a comment with same runId/round/type already exists.
+    Returns True if duplicate exists (should skip posting).
+    
+    comment_type: "review-summary" or "fix-report" or "final-report"
+    """
+    try:
+        result = subprocess.run(
+            ["gh", "api", f"repos/:owner/:repo/issues/{pr_number}/comments", "--paginate"],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.DEVNULL,
+            text=True,
+        )
+        if result.returncode != 0:
+            return False
+        
+        comments = json.loads(result.stdout or "[]")
+        
+        if comment_type == "review-summary":
+            type_header = f"## Review Summary (Round {round_num})"
+        elif comment_type == "fix-report":
+            type_header = f"## Fix Report (Round {round_num})"
+        elif comment_type == "final-report":
+            type_header = "## Final Report"
+        else:
+            return False
+        
+        run_id_pattern = f"RunId: {run_id}"
+        
+        for comment in comments:
+            body = comment.get("body", "")
+            if MARKER in body and type_header in body and run_id_pattern in body:
+                return True
+        
+        return False
+    except Exception:
+        return False
+
+
+def _post_pr_comment(pr_number, body_ref, run_id=None, round_num=None, comment_type=None):
+    """
+    Post a PR comment with idempotency check.
+    
+    If run_id, round_num, and comment_type are provided, checks for existing
+    duplicate before posting and skips if already posted.
+    
+    Returns: True if posted successfully or skipped (idempotent), False on error
+    """
     if isinstance(body_ref, Path):
         p = body_ref
     else:
         p = _resolve_ref(REPO_ROOT, CACHE_DIR, body_ref)
     if not p:
         return False
+    
+    if run_id and round_num and comment_type:
+        if _check_existing_comment(pr_number, run_id, round_num, comment_type):
+            return True
+    
     body_path = str(p)
     rc = subprocess.run(
         ["gh", "pr", "comment", str(pr_number), "--body-file", body_path],
@@ -397,6 +450,32 @@ def _render_mode_b_comment(pr_number, round_num, run_id, fix_report_md):
     return "\n".join(body)
 
 
+def _render_final_comment(pr_number, round_num, run_id, status):
+    lines = []
+    lines.append(MARKER)
+    lines.append("")
+    lines.append("## Final Report")
+    lines.append("")
+    lines.append(f"- PR: #{pr_number}")
+    lines.append(f"- Total Rounds: {round_num}")
+    lines.append(f"- RunId: {run_id}")
+    lines.append("")
+    
+    if status == "RESOLVED":
+        lines.append("### Status: ✅ All issues resolved")
+        lines.append("")
+        lines.append("All P0/P1/P2 issues from the automated review have been addressed.")
+        lines.append("The PR is ready for human review and merge.")
+    else:
+        lines.append("### Status: ⚠️ Max rounds reached")
+        lines.append("")
+        lines.append("The automated review loop has completed the maximum number of rounds (3).")
+        lines.append("Some issues may still remain. Please review the PR comments above for details.")
+    
+    lines.append("")
+    return "\n".join(lines)
+
+
 def main(argv):
     class _ArgParser(argparse.ArgumentParser):
         def error(self, message):
@@ -409,6 +488,7 @@ def main(argv):
     parser.add_argument("--context-file")
     parser.add_argument("--review-file", action="append", default=[])
     parser.add_argument("--fix-report-file")
+    parser.add_argument("--final-report")
     parser.add_argument("--duplicate-groups-json")
     parser.add_argument("--duplicate-groups-b64")
 
@@ -422,6 +502,7 @@ def main(argv):
     round_num = args.round
     run_id = str(args.run_id)
 
+    final_report = (args.final_report or "").strip() or None
     fix_report_file = (args.fix_report_file or "").strip() or None
     context_file = (args.context_file or "").strip() or None
     review_files = []
@@ -430,6 +511,17 @@ def main(argv):
         if s:
             review_files.append(s)
 
+    if final_report:
+        body = _render_final_comment(pr_number, round_num, run_id, final_report)
+        body_basename = f"review-aggregate-final-pr{pr_number}-{run_id}.md"
+        body_ref = _repo_relpath(REPO_ROOT, CACHE_DIR / body_basename)
+        _write_cache_text(body_ref, body)
+        if not _post_pr_comment(pr_number, body_ref, run_id=run_id, round_num=round_num, comment_type="final-report"):
+            _json_out({"error": "GH_PR_COMMENT_FAILED"})
+            return 1
+        _json_out({"ok": True, "final": True})
+        return 0
+
     if fix_report_file:
         fix_p = _resolve_ref(REPO_ROOT, CACHE_DIR, fix_report_file)
         if not fix_p or not fix_p.exists():
@@ -440,7 +532,7 @@ def main(argv):
         body_basename = f"review-aggregate-fix-comment-pr{pr_number}-r{round_num}-{run_id}.md"
         body_ref = _repo_relpath(REPO_ROOT, CACHE_DIR / body_basename)
         _write_cache_text(body_ref, body)
-        if not _post_pr_comment(pr_number, body_ref):
+        if not _post_pr_comment(pr_number, body_ref, run_id=run_id, round_num=round_num, comment_type="fix-report"):
             _json_out({"error": "GH_PR_COMMENT_FAILED"})
             return 1
         _json_out({"ok": True})
@@ -488,7 +580,7 @@ def main(argv):
     body_basename = f"review-aggregate-comment-pr{pr_number}-r{round_num}-{run_id}.md"
     body_ref = _repo_relpath(REPO_ROOT, CACHE_DIR / body_basename)
     _write_cache_text(body_ref, body)
-    if not _post_pr_comment(pr_number, body_ref):
+    if not _post_pr_comment(pr_number, body_ref, run_id=run_id, round_num=round_num, comment_type="review-summary"):
         _json_out({"error": "GH_PR_COMMENT_FAILED"})
         return 1
 

package/@opencode/commands/pr-review-loop.md

@@ -22,6 +22,7 @@ agent: sisyphus
 - `codex-reviewer`
 - `claude-reviewer`
 - `gemini-reviewer`
+- `gh-thread-reviewer`
 - `pr-review-aggregate`
 - `pr-fix`
 
@@ -41,6 +42,13 @@ agent: sisyphus
 
 ## 循环（最多 3 轮）
 
+**⚠️ 严格串行执行要求（Critical）**:
+
+- 每个 Step 必须完成（收到返回值）后才能开始下一个 Step
+- **禁止任何步骤并行执行**（除了 Step 2 的三个 reviewer 可并行）
+- 如果任何步骤失败或超时，必须立即终止当前轮次，不能跳过或重试
+- 每个步骤的 Task 调用必须 await 返回结果，不能 fire-and-forget
+
 每轮按顺序执行：
 
 1. Task: `pr-context` **（必须先完成，不可与 Step 2 并行）**
@@ -50,9 +58,9 @@ agent: sisyphus
 - 取出：`contextFile`、`runId`、`headOid`（如有）
 - **CRITICAL**: 必须等待此 Task 成功完成并获取到 `contextFile` 后，才能进入 Step 2
 
-2. Task（并行）: `codex-reviewer` + `claude-reviewer` + `gemini-reviewer` **（依赖 Step 1 的 contextFile）**
+2. Task（并行）: `codex-reviewer` + `claude-reviewer` + `gemini-reviewer` + `gh-thread-reviewer` **（依赖 Step 1 的 contextFile）**
 
-- **DEPENDENCY**: 这三个 reviewers 依赖 Step 1 返回的 `contextFile`，因此**必须等 Step 1 完成后才能并行启动**
+- **DEPENDENCY**: 这些 reviewers 依赖 Step 1 返回的 `contextFile`，因此**必须等 Step 1 完成后才能并行启动**
 - 每个 reviewer prompt 必须包含：
   - `PR #{{PR_NUMBER}}`
   - `round: <ROUND>`
@@ -67,9 +75,10 @@ agent: sisyphus
 
 3. Task: `pr-review-aggregate`
 
-- prompt 必须包含：`PR #{{PR_NUMBER}}`、`round: <ROUND>`、`runId: <RUN_ID>`、`contextFile: ./.cache/<file>.md`、三条 `reviewFile: ./.cache/<file>.md`
+- prompt 必须包含：`PR #{{PR_NUMBER}}`、`round: <ROUND>`、`runId: <RUN_ID>`、`contextFile: ./.cache/<file>.md`、以及 1+ 条 `reviewFile: ./.cache/<file>.md`
 - 输出：`{"stop":true}` 或 `{"stop":false,"fixFile":"..."}`
 - 若 `stop=true`：本轮结束并退出循环
+- **唯一性约束**: 每轮只能发布一次 Review Summary；脚本内置幂等检查，重复调用不会重复发布
 
 4. Task: `pr-fix`
 
@@ -86,7 +95,49 @@ agent: sisyphus
 
 - prompt 必须包含：`PR #{{PR_NUMBER}}`、`round: <ROUND>`、`runId: <RUN_ID>`、`fixReportFile: ./.cache/<file>.md`
 - 输出：`{"ok":true}`
+- **唯一性约束**: 每轮只能发布一次 Fix Report；脚本内置幂等检查，重复调用不会重复发布
 
 6. 下一轮
 
 - 回到 1（进入下一轮 reviewers）
+
+
+## 终止与收尾（强制）
+
+循环结束时，必须发布一个最终评论到 PR，格式如下：
+
+### 情况 A: 所有问题已解决（stop=true）
+
+当 Step 3 返回 `{"stop":true}` 时，调用 `pr-review-aggregate` 发布收尾评论：
+
+- prompt 必须包含：
+  - `PR #{{PR_NUMBER}}`
+  - `round: <ROUND>`
+  - `runId: <RUN_ID>`
+  - `--final-report "RESOLVED"`（新增参数，表示所有问题已解决）
+
+### 情况 B: 达到最大轮次（3 轮后仍有问题）
+
+当循环完成 3 轮后仍未 stop，调用 `pr-review-aggregate` 发布收尾评论：
+
+- prompt 必须包含：
+  - `PR #{{PR_NUMBER}}`
+  - `round: 3`
+  - `runId: <RUN_ID>`
+  - `--final-report "MAX_ROUNDS_REACHED"`（新增参数，表示达到最大轮次）
+
+### 最终评论格式（由脚本生成）
+
+```markdown
+<!-- pr-review-loop-marker -->
+
+## Final Report
+
+- PR: #<PR_NUMBER>
+- Total Rounds: <N>
+- Status: ✅ All issues resolved / ⚠️ Max rounds reached (some issues may remain)
+
+### Summary
+
+[自动生成的总结]
+```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ranger1/dx",
-  "version": "0.1.35",
+  "version": "0.1.37",
   "type": "module",
   "license": "MIT",
   "repository": {