@ranger1/dx 0.1.76 → 0.1.78

package/@opencode/commands/oh_attach.json

@@ -1,92 +0,0 @@
-{  
-  "sisyphus_agent": {
-    "disabled": false,
-    "default_builder_enabled": true,
-    "planner_enabled": true,
-    "replace_plan": false
-  },
- "agents": {
-    "sisyphus": {
-      "model": "openai/gpt-5.3-codex",
-      "variant": "none"
-    },
-    "oracle": {
-      "model": "openai/gpt-5.3-codex",
-      "variant": "high"
-    },
-    "librarian": {
-      "model": "openai/gpt-5.3-codex"
-    },
-    "explore": {
-      "model": "openai/gpt-5.3-codex"
-    },
-    "multimodal-looker": {
-      "model": "openai/gpt-5.3-codex"
-    },
-    "prometheus": {
-      "model": "gpt-5.3-codex",
-      "variant": "max"
-    },
-    "metis": {
-      "model": "gpt-5.3-codex",
-      "variant": "max"
-    },
-    "momus": {
-      "model": "openai/gpt-5.2",
-      "variant": "medium"
-    },
-    "atlas": {
-      "model": "openai/gpt-5.3-codex"
-    },
-    "codex-reviewer": {
-      "model": "openai/gpt-5.3-codex",
-      "variant": "xhigh",
-      "temperature": 0.1
-    },
-    "gemini-reviewer": {
-      "model": "openai/gpt-5.3-codex",
-      "variant": "max"
-    },
-    "claude-reviewer": {
-      "model": "openai/gpt-5.3-codex",
-      "variant": "high"
-    },
-    "pr-fixer": {
-      "model": "openai/gpt-5.3-codex",
-      "variant": "xhigh",
-      "temperature": 0.1
-    }
-  },
-  "concurrency": 5,
-  "categories": {
-    "visual-engineering": {
-      "model": "openai/gpt-5.3-codex",
-      "variant": "high"
-    },
-    "ultrabrain": {
-      "model": "openai/gpt-5.3-codex",
-      "variant": "xhigh"
-    },
-    "artistry": {
-      "model": "openai/gpt-5.3-codex",
-      "variant": "max"
-    },
-    "quick": {
-      "model": "openai/gpt-5.1-codex-min"
-    },
-    "middle": {
-      "model": "openai/gpt-5.3-codex"
-    },
-    "unspecified-low": {
-      "model": "openai/gpt-5.1-codex-min",
-      "variant": "medium"
-    },
-    "unspecified-high": {
-      "model": "openai/gpt-5.3-codex",
-      "variant": "medium"
-    },
-    "writing": {
-      "model": "openai/gpt-5.3-codex"
-    }
-  }
-}

package/@opencode/commands/opencode_attach.json

@@ -1,29 +0,0 @@
-{
-  "instructions": [
-    "AGENTS.md",
-    "ruler/**/*.md"
-  ],
-  "plugin": [
-    "opencode-antigravity-auth",
-    "oh-my-opencode",
-    "opencode-openai-codex-auth"
-  ],
-  "agent": {
-    "quick": {
-      "model": "openai/gpt-5.1-codex-min"
-    },
-    "middle": {
-      "model": "openai/gpt-5.3-codex"
-    },
-    "documenter": {
-      "model": "openai/gpt-5.3-codex"
-    }
-  },
-  "permission": {
-    "read": {
-      "*.env": "allow",
-      "*.env.*": "allow"
-    }
-  },  
-  "model": "openai/gpt-5.3-codex"
-}

package/@opencode/commands/opencode_attach.py

@@ -1,142 +0,0 @@
-#!/usr/bin/env python3
-
-import argparse
-import json
-import os
-import shutil
-import sys
-import time
-from pathlib import Path
-
-
-def _is_plain_object(value):
-    return isinstance(value, dict)
-
-
-def deep_merge_in_place(target, source):
-    if not _is_plain_object(target) or not _is_plain_object(source):
-        raise TypeError("deep_merge_in_place expects dicts")
-
-    for key, s_val in source.items():
-        if _is_plain_object(s_val):
-            t_val = target.get(key)
-            if not _is_plain_object(t_val):
-                t_val = {}
-                target[key] = t_val
-            deep_merge_in_place(t_val, s_val)
-        else:
-            target[key] = s_val
-
-    return target
-
-
-def load_json_file(path):
-    raw = path.read_text(encoding="utf-8")
-    return json.loads(raw)
-
-
-def atomic_write_json(path, data):
-    path.parent.mkdir(parents=True, exist_ok=True)
-    tmp_path = path.with_name(f"{path.name}.tmp.{os.getpid()}")
-    serialized = json.dumps(data, ensure_ascii=False, indent=2) + "\n"
-    tmp_path.write_text(serialized, encoding="utf-8")
-    os.replace(tmp_path, path)
-
-
-def backup_file(path):
-    if not path.exists():
-        return None
-    ts = time.strftime("%Y%m%d%H%M%S")
-    bak = path.with_name(f"{path.name}.bak.{ts}")
-    shutil.copy2(path, bak)
-    return bak
-
-
-def attach(source_path, target_path, *, make_backup=True, dry_run=False):
-    source = load_json_file(source_path)
-    if not _is_plain_object(source):
-        raise ValueError(f"Source JSON root must be an object: {source_path}")
-
-    if target_path.exists():
-        target = load_json_file(target_path)
-        if not _is_plain_object(target):
-            raise ValueError(f"Target JSON root must be an object: {target_path}")
-    else:
-        target = {}
-
-    merged = deep_merge_in_place(target, source)
-
-    bak = None
-    if make_backup and target_path.exists() and not dry_run:
-        bak = backup_file(target_path)
-
-    if not dry_run:
-        atomic_write_json(target_path, merged)
-
-    return bak
-
-
-def main(argv):
-    parser = argparse.ArgumentParser(
-        description=(
-            "Attach JSON fragments into OpenCode global config files. "
-            "Rule: deep-merge objects; replace arrays/primitives; preserve other keys."
-        )
-    )
-    parser.add_argument(
-        "--oh-source",
-        default=str(Path(__file__).resolve().parents[1] / "commands" / "oh_attach.json"),
-        help="Path to oh_attach.json",
-    )
-    parser.add_argument(
-        "--opencode-source",
-        default=str(Path(__file__).resolve().parents[1] / "commands" / "opencode_attach.json"),
-        help="Path to opencode_attach.json",
-    )
-    parser.add_argument(
-        "--config-dir",
-        default=str(Path.home() / ".config" / "opencode"),
-        help="Config directory (default: ~/.config/opencode)",
-    )
-    parser.add_argument("--no-backup", action="store_true", help="Do not create .bak files")
-    parser.add_argument("--dry-run", action="store_true", help="Do not write files")
-
-    args = parser.parse_args(argv)
-
-    config_dir = Path(os.path.expanduser(args.config_dir)).resolve()
-    oh_target = config_dir / "oh-my-opencode.json"
-    opencode_target = config_dir / "opencode.json"
-
-    oh_source = Path(args.oh_source).resolve()
-    opencode_source = Path(args.opencode_source).resolve()
-
-    if not oh_source.exists():
-        raise FileNotFoundError(f"Missing source file: {oh_source}")
-    if not opencode_source.exists():
-        raise FileNotFoundError(f"Missing source file: {opencode_source}")
-
-    make_backup = not args.no_backup
-    dry_run = args.dry_run
-
-    bak1 = attach(oh_source, oh_target, make_backup=make_backup, dry_run=dry_run)
-    bak2 = attach(opencode_source, opencode_target, make_backup=make_backup, dry_run=dry_run)
-
-    if dry_run:
-        print("DRY_RUN: no files written")
-        return 0
-
-    if bak1:
-        print(f"backup: {bak1}")
-    if bak2:
-        print(f"backup: {bak2}")
-    print(f"updated: {oh_target}")
-    print(f"updated: {opencode_target}")
-    return 0
-
-
-if __name__ == "__main__":
-    try:
-        raise SystemExit(main(sys.argv[1:]))
-    except Exception as e:
-        print(f"ERROR: {e}", file=sys.stderr)
-        raise SystemExit(1)

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

@@ -1,211 +0,0 @@
----
-allowed-tools: [Bash, Read, Glob, TodoWrite, Edit, Grep, Task]
-description: '循环审核修复'
----
-
-# PR Review Loop
-
-## Stacked PR / PR -> PR（重要）
-
-- 本流程的 diff 基准来自 GitHub PR 元数据的 `baseRefName`（不是硬编码 main/master），因此天然支持“PR 合并到另一个 PR 分支”的 stacked PR。
-- 当 `baseRefName` 缺失时：会回退到仓库默认分支（`defaultBranchRef.name`）。
-- 当 base 分支 fetch 失败时：会直接报错终止（不再静默回退到 main/master），避免 review/changed-files 基准悄悄跑偏。
-
-## 输入
-
-- `{{PR_NUMBER}}`
-- `round`（默认 1，由调用者/循环控制）
-
-## 唯一标识 runId（强制）
-
-- 全局唯一标识 `runId` 格式：`<PR>-<ROUND>-<HEAD_SHORT>`
-- 其中：
-  - `<PR>`：PR 编号
-  - `<ROUND>`：当前轮次
-  - `<HEAD_SHORT>`：`headOid` 的前 7 位（git rev-parse --short HEAD）
-- 生成者：
-  - 第 1 步 `pr-context` 负责计算并返回 `runId`（基于当前 checkout 的 headOid）
-  - 后续所有步骤（reviewers, aggregate, fix）必须透传并使用该 `runId`
-  - 禁止任何下游步骤自行生成或篡改 `runId`
-
-## Cache 约定（强制）
-
-- 本流程所有中间文件都存放在项目内：`./.cache/`
-- agent/命令之间传递**repo 相对路径**（例如：`./.cache/pr-context-...md`），不要只传 basename
-
-## 固定 subagent_type（直接用 Task 调用，不要反复确认）
-
-- `pr-precheck`
-- `pr-context`
-- `codex-reviewer`
-
-- `claude-reviewer`
-- `gemini-reviewer`
-- `gh-thread-reviewer`
-- `pr-review-aggregate`
-- `pr-fix`
-
-
-## 预检
-
-0. Task: `pr-precheck`（强制 gate：编译/预检必须先通过）
-
-- prompt 必须包含：`PR #{{PR_NUMBER}}`、`round: <ROUND>`（precheck 需计算并返回 runId，格式同 context）
-- 若返回 `{"error":"..."}`：立即终止本轮并回传错误
-- 若返回 `{"ok":false,"fixFile":"..."}`：
-  - 预检阶段 runId 同样基于 `headOid` 生成（`<PR>-<ROUND>-<HEAD_SHORT>`），可直接传给 fix。
-  - 最多修复 2 次（防止无限循环）：
-    - 第 1 次：Task `pr-fix`（传入 `fixFile`, `runId`, `round`）→ 再 Task `pr-precheck`
-    - 若仍返回 `{"ok":false,"fixFile":"..."}`：第 2 次 Task `pr-fix` → 再 Task `pr-precheck`
-  - 若仍不是 `{"ok":true}`：终止并回传错误（建议：`{"error":"PRECHECK_NOT_CLEAN_AFTER_FIX"}`）
-- 注意：预检失败产生的修复也应记录在 Decision Log 中（essence: `__precheck__` 或具体错误信息，file: `__precheck__`），以便后续追踪。
-
-## 循环（最多 3 轮）
-
-**⚠️ 严格串行执行要求（Critical）**:
-
-- 每个 Step 必须完成（收到返回值）后才能开始下一个 Step
-- **禁止任何步骤并行执行**（除了 Step 2 的三个 reviewer 可并行）
-- 如果任何步骤失败或超时，必须立即终止当前轮次，不能跳过或重试
-- 每个步骤的 Task 调用必须 await 返回结果，不能 fire-and-forget
-
-每轮按顺序执行：
-
-1. Task: `pr-context` **（必须先完成，不可与 Step 2 并行）**
-
-- prompt 必须包含：`PR #{{PR_NUMBER}}`、`round: <ROUND>`
-- 若返回 `{"error":"..."}`：立即终止本轮并回传错误（不再调用 reviewers）
-- 取出：`contextFile`、`runId`、`headOid`
-- **runId 校验**：确认返回的 `runId` 符合 `<PR>-<ROUND>-<HEAD_SHORT>` 格式
-- **CRITICAL**: 必须等待此 Task 成功完成并获取到 `contextFile` 后，才能进入 Step 2
-
-**检查 Decision Log**：
-- 检查是否存在 `./.cache/decision-log-pr{{PR_NUMBER}}.md`
-- 如存在，将路径记录为 `decisionLogFile`（用于后续步骤）
-- 如不存在，`decisionLogFile` 为空或不传递
-
-2. Task（并行）: `codex-reviewer` + `claude-reviewer` + `gemini-reviewer` + `gh-thread-reviewer` **（依赖 Step 1 的 contextFile 和 decisionLogFile）**
-
-- **DEPENDENCY**: 这些 reviewers 依赖 Step 1 返回的 `contextFile` 和 `decisionLogFile`（如存在），因此**必须等 Step 1 完成后才能并行启动**
-- 每个 reviewer prompt 必须包含：
-  - `PR #{{PR_NUMBER}}`
-  - `round: <ROUND>`
-  - `runId: <RUN_ID>`（来自 Step 1 的输出，必须透传，禁止自行生成）
-  - `contextFile: ./.cache/<file>.md`（来自 Step 1 的输出）
-  - `decisionLogFile: ./.cache/decision-log-pr{{PR_NUMBER}}.md`（如存在）
-- reviewer 默认读 `contextFile`；如果 `decisionLogFile` 存在，reviewer 应在 prompt 中提供该文件路径以参考前轮决策；必要时允许用 `git/gh` 只读命令拿 diff
-- 忽略问题：1.格式化代码引起的噪音 2.已经lint检查以外的格式问题 3.忽略单元测试不足的问题
-- 对于重构代码，不必考虑和以前版本数据的兼容性问题，直接切换就行
-- 特别关注: 逻辑、安全、性能、可维护性
-- 遵守 Decision Log：
-  - 已修复（Fixed）：不再提
-  - 已拒绝（Rejected）：除非优先级升级（P_new - P_old >= 2），否则不再提
-  - 任何新发现必须基于当前 `runId` 对应的代码状态
-- 每个 reviewer 输出：`reviewFile: ./.cache/<file>.md`（Markdown）
-
-3. Task: `pr-review-aggregate`
-
-- prompt 必须包含：`PR #{{PR_NUMBER}}`、`round: <ROUND>`、`runId: <RUN_ID>`、`contextFile: ./.cache/<file>.md`、以及 1+ 条 `reviewFile: ./.cache/<file>.md`、以及 `decisionLogFile: ./.cache/decision-log-pr{{PR_NUMBER}}.md`（如存在）
-- 输出：`{"stop":true}` 或 `{"stop":false,"fixFile":"..."}`
-- 若 `stop=true`：本轮结束并退出循环
-- **唯一性约束**: 每轮只能发布一次 Review Summary；脚本内置幂等检查，重复调用不会重复发布
-- 智能聚合：
-  - 使用 LLM 对比 decision-log 中的 `essence` 与新 finding
-  - 仅当问题本质相同且优先级 delta < 2 时，自动归为 Repeated/Ignored
-  - 否则视为 New Issue 或 Escalation
-
-4. Task: `pr-fix`
-
-- prompt 必须包含：
-  - `PR #{{PR_NUMBER}}`
-  - `round: <ROUND>`
-  - `runId: <RUN_ID>`（来自 Step 1 的输出，必须透传，禁止自行生成）
-  - `fixFile: ./.cache/<file>.md`
-- 约定：`pr-fix` 对每个 findingId 单独 commit + push（一个 findingId 一个 commit），结束后再 `git push` 兜底
-- 决策记录：
-  - 修复成功：追加 Fixed 记录（含 `essence`）到 Decision Log
-  - 拒绝/无法修复：追加 Rejected 记录（含 `reason`, `essence`）到 Decision Log
-  - 范围限制：essence 匹配必须在 **同一个文件** 内（不支持跨文件/重命名追踪）
-- pr-fix 输出：`fixReportFile: ./.cache/<file>.md`（Markdown）
-
-
-5. Task: `pr-review-aggregate`（发布修复评论）
-
-- prompt 必须包含：`PR #{{PR_NUMBER}}`、`round: <ROUND>`、`runId: <RUN_ID>`、`fixReportFile: ./.cache/<file>.md`
-- 输出：`{"ok":true}`
-- **唯一性约束**: 每轮只能发布一次 Fix Report；脚本内置幂等检查，重复调用不会重复发布
-
-**Decision Log 更新**：
-- `pr-fix` agent 在修复过程中会在 `./.cache/decision-log-pr{{PR_NUMBER}}.md` 中追加本轮决策（Fixed/Rejected）
-- 下一轮 review 将自动使用更新后的 decision-log，避免重复提出已决策问题
-
-6. 下一轮
-
-- 回到 1（进入下一轮 reviewers）
-
-## 本地验证（脚本直跑）
-
-```bash
-# 0) 先确保 gh 已认证（host 从 git remote origin 推断；必要时用 --hostname）
-gh auth status
-
-# 1) precheck（round 1）
-python3 "~/.opencode/agents/pr_precheck.py" --pr <PR_NUMBER> --round 1
-
-# 2) context（round 1）
-python3 "~/.opencode/agents/pr_context.py" --pr <PR_NUMBER> --round 1
-
-# 3) 校验：两者都必须输出单行 JSON，且 runId 必须一致
-python3 "~/.opencode/agents/pr_precheck.py" --pr <PR_NUMBER> --round 1 > ./.cache/_precheck.json
-python3 "~/.opencode/agents/pr_context.py" --pr <PR_NUMBER> --round 1 > ./.cache/_context.json
-python3 - <<'PY'
-import json
-p=json.load(open('./.cache/_precheck.json'))
-c=json.load(open('./.cache/_context.json'))
-assert p.get('runId') == c.get('runId'), (p.get('runId'), c.get('runId'))
-print('OK', p.get('runId'))
-PY
-
-# 4) 运行脚本相关测试（注意：pytest 把 @ 当作 argfile；必须加 ./ 并加引号）
-python3 -m pytest -q "~/.opencode/agents/test_pr_review_aggregate.py"
-```
-
-## 终止与收尾（强制）
-
-循环结束时，必须发布一个最终评论到 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
-
-[自动生成的总结]
-```