0. 前言

Open code 的配置一直是比较繁琐的，虽然开箱即用，但如果想配置转发站就有点头疼了。在网上找了很多教程，但大都简略，很多第三方转发站的文档写的也不明白（点名Right Code）。

有很多佬友开发了可视化 / 后端插件，如 AI-toolbox，OCCM，CLIProxyAPI。这些都很好用！感谢佬友们！你们的贡献让社区变得如此美好，也深深激励了我

在使用了一段时间后，我发现掌握一些模型 config 配置原理是有必要的。插件只能帮忙切换 provider，每个模型的进阶参数如思考预算，仍然要自己配置。懂得如何修改配置文件也能让我们把这些插件用的更好.

所以写一篇教程，从 0 开始配置 opencode.json. 希望能帮到各位尝试 opencode（并想在 opencode 中配置使用自定义转发站）的佬友，同时也记录自己学习各类官方文档的过程

篇幅所限，本篇教程大部分内容是折叠的！！！请点击黑色三角形展开查看！！！
篇幅所限，本篇教程大部分内容是折叠的！！！请点击黑色三角形展开查看！！！
篇幅所限，本篇教程大部分内容是折叠的！！！请点击黑色三角形展开查看！！！

1. 初始化

2.Provider 配置

2.1 官方 Provider 配置

如果你使用的是 Opencode 官方支持的 Provider，例如 Opencode Zen，GLM Coding Plan，那么基本上只需要在安装好的 opencode TUI 中输入 /connect 并回车即可。

如果你想在这篇文档中找到含截图配置教学，请展开以下三角形

action 2：连接 Github Copilot 作为 Provider

打开 opencode，输入 /connect

选择 github copilot 或其他 official provider

按提示操作

恭喜你！验证成功！ 现在可以通过 opencode 使用 copilot 或其他 official provider 了。

注意：只需要重新走一遍此流程就能覆盖之前的认证
Provider auth 的文件在这里：C:\Users <你的用户名>.local\share\opencode
如果对此流程具体涉及的文件感兴趣，拓展阅读在 2.2 节 action4 提供

2.2 自定义 API Key / 转发站 Provider 配置

站内轮子：OpenCode 自定义服务商（中转站）接入指南

如果你想在这篇文档中找到含截图配置教学，请展开以下三角形

action 3：通过可视化方式连接 Right Code（转发站）作为 Provider（推荐）

如果使用 action3，最好也看一下 action4
以便于理解后续 Models 配置部分对.json 的自定义修改。

Opencode 的逻辑是由开发者来列出所有合法的 provider 供连接，非常全。但 Right Code 这样的转发站理论上确实不受 opencode 支持。

大部分佬友遇到的困难集中在使用 opencode 命令打开 TUI (Terminal UI) 界面后，/connect 的 provider 中没有 "other" 或者 "custom" 选项。我们可以看到 Other 选项是个标题，确实不能选 Other 选项，而且经过搜索 Other 里面也没有 Right Code 这样的转发站。

不过，我们仍然可以通过配置 opencode.json 来解决这个问题。
@coulsontl
使用佬友的项目 AI-toolbox 可视化配置 opencode.json 和 auth：

• step 1：下载并安装 releases.

  

• step 2：填写你想自定义的供应商名和显示名

  

• step 3：按照图片填写 NPM 包和 BaseURL 即可

  

• step 4: 点击 “获取模型”，在列表中添加想用的模型

  
  
  
  
  
  
  

• step 5：已经可以使用了。Oh-My-Opencode 也可以配置此种模式导入的模型。

  
  
  
  

非常好用！感谢 coulsontl 佬友！

不支持自定义 Options/Variants 配置，导入新 Provider 会覆写旧文件

也许后续我会提 PR？

如想知道如何填写 NPM 包和 BaseURL，请参考 document-reading 1！

action 4：通过 /connect 方式连接 Right Code（转发站）作为 Provider

Opencode 的逻辑是由开发者来列出所有合法的 provider 供连接，非常全。但 Right Code 这样的转发站理论上确实不受 opencode 支持。大部分佬友遇到的困难集中在使用 opencode 命令打开 TUI (Terminal UI) 界面后，/connect 的 provider 中没有 "other" 或者 "custom" 选项。我们可以看到 Other 选项是个标题，确实不能选 Other 选项，而且经过搜索 Other 里面也没有 Right Code 这样的转发站。

TUI 中 /connect 选项设置基于默认的合法 auth。不过，我们只需要随意在没有连接的选项中选一个然后改成我们的 auth 就可以了。

这里选择 privatemode AI，随意填写一个 api key

随意选择一个模型

虽然看起来能用，但这显然这是不能用的。

接下来的才是重点：我们去修改这个 auth 为 Right Code 的 auth 和 model。

Provider auth 的文件在这里：C:\Users <你的用户名>.local\share\opencode
如果你之前连接过其他的方案，例如 github copilot，也会在这里显示。同时，你可以删除这里面的配置，TUI 里会同步更新，相信可能会有佬友配错了想 disconnected 但找不到路子的，请修改这个文件，删除对应部分即可。

我们可以看到这个文件中已经新增了刚才我们选择的 Provider privatemode AI 的 Auth，key 为 666。

然后，修改 provider name 为一个你喜欢的名字，我这里修改为 RC Codex，key 填写为你的 apikey。需要修改，否则自动识别，勿与 opencode 的内置 provider（例如刚才的 privatemode AI）同名。

（我这里填写 666 是为了占位，请在转发站生成 api key 并填写。下图为获取 api-key 的界面）

那么 auth 就配置完成了！
接下来请转到 C:\Users <你的用户名>.config\opencode
查看是否有 opencode.json 或.jsonc
我这里就没有。如果没有，创建一个。

可以把 auth.json 复制过来创建。如果右键创建，记得显示扩展名。

此处 jsonc 和 json 的区别是 jsonc 可以写批注。c 是 comment 的意思。其他没有区别。

创建完毕后，写入对应于 provider auth 的 model 内容，参考示例如下。具体需要配置的部分都进行了注释，将由 document-reading 1 来详细讲解，以便大家知道为什么这么配置，进而配置不同的转发站。

{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "RC-Codex": {  // 和auth中修改的名称一致 "npm": "@ai-sdk/openai", // 兼容的SDK，将于后续document-reading 1详细讲解 "name": "RingCode-CodeX",  // 在 TUI 中显示的名称 "options": {
        "baseURL": "https://www.right.codes/codex/v1",  // 中转站 API 地址（必须以 /v1 结尾或符合 OpenAI 格式），将于document-reading 1中详细讲解 "apiKey": "666"// 明文填写你的api-key，懂得引用的佬友可以用引用形式 // 如果中转站需要自定义 headers，可添加： // "headers": { //   "X-Custom-Header": "your-value" // }
      },
      "models": {
        "gpt-5.1-codex-max": {  // 中转站支持的模型ID，例如 gpt-4o、claude-3-5-sonnet 等，将于document-reading 1中详细讲解 "name": "Codex-5.1-max(RC-Codex)" //自定义显示名称
        },
        "gpt-5.1": {
          "name": "Gpt-5.1(RC-Codex)"
        }
        // 添加更多模型...
      }
    }
  }
}

此 opencode-config.json 参考来源

- document-reading 1
- 官方文档：https://opencode.ai/docs/models/
- 站内轮子：https://linux.do/t/topic/1329050 

配置完成后，我们就可以愉快地重启 opencode，选择 codex 模型了。

什么…? 你用的不是 Right Code 不知道注释的地方填什么？你需要阅读官方文档！

请在document-reading 1和我一起阅读文档！
来看看我是怎么在Right Code文档完全一坨的前提下填写这些字段的。
（声明：Right Code是我最喜欢的转发站之一，codex量大管饱，没有不喜欢的意思，但是文档和网站确实需要改进）

action 5：通过 auth login 方式连接 Right Code（转发站）作为 Provider

通过在 powershell 中输入 opencode auth login 配置
TUI 的打开命令是 opencode，那么其实 opencode 是一个程序，TUI 其实就是无参运行这个程序。可以想象，其实带参运行这个程序是才是触发程序中内置的功能比较常见的途径。那么 /connect 对应的带参运行其实就是 opencode auth login.

输入 opencode auth login 后，可以自由键入 provider 名字然后 enter，找不到也没事，这是区别于（1）选项重要的一点。
其余选项，对于文件的修改都相同，请参考 action 4。
注意起名勿与 opencode 的内置 provider 同名。

document-reading 1：通过阅读 Opencode 和转发站官方文档配置 Provider

RightCode 的文档和网站是最草率的那一批，但我们仍然可以获得足够的信息。

• step1：获得转发站 baseurl 以填写 baseurl 字段
  在 RightCode 官方文档中没有提到 Opencode 如何配置，也没写 BaseUrl。
  在模型列表可用端口处点击复制按钮，
  分别得到 https://www.right.codes/claude-aws
  和 https://www.right.codes/codex，那么加上 v1，这就是两个模型池分别的 BaseUrl。
  
  
  
  为什么加上 v1：
  RightCode 文档里也加了。v1 是通用的接口规范，如果接口请求不对，没有 v1 就加上 v1
  
  
  
  通过以上信息可以填写如下的 baseurl 和 apikey 部分（apikey 获取此处省略）

 "options": { "baseURL": "https://www.right.codes/codex/v1", // 中转站 API 地址（必须以 /v1 结尾或符合 OpenAI 格式），将于document-reading 1中详细讲解 "apiKey": "666"// 明文填写你的api-key，懂得引用的佬友可以用引用形式 // 如果中转站需要自定义 headers，可添加： // "headers": { //   "X-Custom-Header": "your-value" // } }, 

• step2：填写 models
  在模型广场里找到了如下的模型
  
  
  
  在使用文档也里找到了如下的 models 可以填写。
  
  
  
  因此可以填写 config 文件中对应的这几行。（注意：实际支持 5.2codex，以模型广场为准。这文档不全）

 "models": { "gpt-5.1-codex-max": { // 中转站支持的模型ID，例如 gpt-4o、claude-3-5-sonnet 等，将于document-reading 1中详细讲解 "name": "Codex-5.1-max(RC-Codex)" //自定义显示名称 }, "gpt-5.1": { "name": "Gpt-5.1(RC-Codex)" } 

• step3：获得转发站支持的接口以填写 npm 字段
  我们可以看到 Right Code 支持了 Openai 新版 responses 和老版 chat/completions 接口，也支持了 Antropic 新版 messages 接口。
  
  
  
  那么知道了支持的接口该怎么填写 npm 字段呢？这个字段好像也不是接口。

不知道什么意思的时候就请查看 Opencode 官方文档。

根据 Models | OpenCode opencode 是基于 Vercel 的 AI SDK 项目（实际上大部分 AI 工具都基于 AI-SDK 转发请求）和 models.dev 项目的。所以去查看这两个项目的官方文档。models.dev 看了之后和我们的需求没什么关系，opencode.json 的实现是依赖于 AI-SDK 的。AI-SDK 表示接口的实现依赖于对应的 npm 包。也就是说一个包对应一个接口。

查 AI SDK 的文档 Foundations: Providers and Models

进去之后发现左上角 navigator 有一个 Providers，那么层级应该是 Provider/Model，所以应该要从这里进去了。

如果你没注意到 navigator，其实也可以从左边目录的 Provider and Models 进去。如果 “官方文档里没有”，那你可能要从更高层级上找一找。这是看大部分组织良好的官方文档的小技巧。

点进去以后来到了这个页面

AI SDK Providers

分别查看 openai,openai-compatible-providers 和 claude 的接口标准

AI SDK Providers: OpenAI
AI SDK Providers: Anthropic
OpenAI Compatible Providers

能看到文档中说明 openai Provider 包含有 /responses 请求接口的实现，openai-compatible-providers 包含 /chat/completions 接口的实现，claude 包含有 /messages 接口的实现。这就对应上了。（反过来怎么找到这的：在官方文档中使用搜索，搜索对应接口去找对应 Provider.）

因此我们可以配置接口部分：
"npm": "@ai-sdk/openai", // responses接口对应的SDK
由于官方文档中提到，Right Code 也支持了老版的 /chat/completions 接口，所以这个地方的 SDK 也可以配置为 openai-compatible.
`“npm”: “@ai-sdk/openai-compatible”, // 兼容的 SDK

完整的初步配置文件：

{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "RC-Codex": {  // 和auth中修改的名称一致 "npm": "@ai-sdk/openai", // /responses接口对应的SDK "name": "RingCode-CodeX",  // 在 TUI 中显示的名称 "options": {
        "baseURL": "https://www.right.codes/codex/v1", 
        "apiKey": "666"

      },
      "models": {
        "gpt-5.1-codex-max": {  // 中转站支持的模型ID "name": "Codex-5.1-max(RC-Codex)" //自定义显示名称
        },
        "gpt-5.1": {
          "name": "Gpt-5.1(RC-Codex)"
        }
      }
    }
  }
}

现在就可以用了。在后续 Options 中将提及如何优化模型体验，包括设置思考预算。

3.Models 配置

3.1 Options 配置

配好了转发站，但是模型用起来不好用，可能是因为没有配置 Options。Options 是厂商自定义的参数列表，例如 Codex 的思考预算，佬友们常说的 Xhigh / high 都在 options 设置。

3.1.1 Options 作用

（以 Right Code 转发站的 Codex 端点为例展示）

example 1：使用 Right Code 转发站转发 /codex 端点，默认配置

可以看到，虽然能返回，但 codex-max 在每次调用后马上就返回了，也没有展示思考，使用体验很不好。难道 codex-max 这么蠢吗？或者是被降智了？

example 2：使用 Right Code 转发站转发 /codex 端点，增加 Options 配置

但是如 example 2 所示，同样的模型和转发站，没有一步一停，也展示了思考内容，花费 2 分钟。

"RightCodes-OAI": {
      "npm": "@ai-sdk/openai",
      "name": "Rightcodes-OAI",
      "options": {
        "baseURL": "https://www.right.codes/codex/v1",
        "apiKey": "用你的api-key代替",
      },
      "models": {
        "gpt-5.1-codex-max": {
          "name": "gpt-5.1-codex-max",
        }
      }
    }

"RightCodes-OAI": {
      "npm": "@ai-sdk/openai",
      "name": "Rightcodes-OAI",
      "options": {
        "baseURL": "https://www.right.codes/codex/v1",
        "apiKey": "用你的api-key代替",
      },
      "models": {
        "gpt-5.1-codex-max": {
          "name": "gpt-5.1-codex-max",
          "options":{
            "reasoningEffort": "high",
            "textVerbosity": "medium",
            "reasoningSummary": "auto"
	        }
        },
      }
    }

可以看出，问题的关键在于我在 options 中配置了三个选项 reasoningEffort：high，textVerbosity：medium和reasoningSummary：auto 。

3.1.2 Options 配置

document-reading 3：通过阅读 OPENAI 官方文档进一步配置 codex 模型 options

AI-SDK 的文档当然已经非常够用了，不过如果你想更深程度的了解究竟有哪些 options，那么 AI-SDK 的文档里还是没有写的完全清楚，例如在 include 这里，AI-SDK 只写了两个支持的值，实际上这里不止两个值可以填。

其实我们还可以去检查 OPENAI 和 ANTROPIC 的官方文档来确认究竟有哪些 options。

这里以 OPENAI 为例：我们查找官方文档中关于 Reponses API 的部分（善用文档库自带的搜索框）可以看到 include 列表一共有七个可选的值。

有任何关于你想要的模型自主设置也可以继续在 responses api 里探索。responses api 是许多模型共用的接口，你使用的模型可能并不支持该接口的所有功能。
https://platform.openai.com/docs/api-reference/responses/create

notification 2：不同中转站实现的接口可能不同

本文以配置 Right Code 家的 codex 和 claude 为例。在 RightCode 官方文档 中，codex 实现的接口为 OPENAI 官方的 responses 接口，因此应该遵循 responses 接口的 options 设置。claude 实现的接口为 ANTROPIC 官方的 messages 接口，因此应该遵循 messages 接口的 options 设置。

3.2 Variants 配置

Variants 实际上就是一个 List，其中的每个元素是一个 Options 设置。通过切换不同的 Variants，我们实际上能够切换不同的 Options 组合。参考文档：Models | OpenCode

原配置一个模型只能有一个设置：

 "gpt-5.2-codex": { "name": "gpt-5.2-codex", "options":{ "reasoningEffort": "high", "textVerbosity": "medium", "reasoningSummary": "auto" } }, 

现在我想针对这个模型切换不同的 Options 组合，则把它们打包到 Variants 列表里.

 "gpt-5.2-codex": { "name": "gpt-5.2-codex", "variants": { "high": { "reasoningEffort": "high", "textVerbosity": "low", }, "xhigh": { "reasoningEffort": "xhigh", "textVerbosity": "medium", }, }, }, 

可以看到，现在可以调整 xhigh 和 high 进行推理了.

4. 留言

Plugins 配置，如 Oh-My-Opencode 配置等站内已有其他轮子，不再赘述；

exercise 1：完善 Right Code/Claude 4.5 Opus 模型的初始 opencode.json 文件

题目：

{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "RCS-Claude": {
      "npm": "@ai-sdk/anthropic",
      "name": "RC中转站Claude端点(awsq)",
      "options": {
        "baseURL": "https://www.right.codes/claude-aws/v1",
        "apiKey": "666"
      },
      "models": {
        "claude-opus-4-5-20251101": {
          "name": "claude-opus-4-5-20251101"
        }
      }
    }
  },
  "model": "RCS-Codex/gpt-5.1",
  "small_model": "opencode/grok-code"
}

答案供参考：

{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "RCS-Claude": {
      "npm": "@ai-sdk/anthropic",
      "name": "RC中转站Claude端点(awsq)",
      "options": {
        "baseURL": "https://www.right.codes/claude-aws/v1",
        "apiKey": "666"
      },
      "models": {
        "claude-opus-4-5-20251101": {
          "name": "claude-opus-4-5-20251101",
           "variants":{ 
              "very-lazy": {
                "effort": "low" 
              },
              "think-2000":{
                "thinking": { "type": "enabled", "budgetTokens": 2000 },
              },
              "think-1w6":{
                "thinking": { "type": "enabled", "budgetTokens": 16000 },
              },
            }
        }
      }
    }
  },
  "model": "RCS-Codex/gpt-5.1",
  "small_model": "opencode/grok-code"
}

参考文档：
AI-SDK Provider:Antropic

Antropic Message 接口官方文档

不兼容的 options 不会生效，但问题在于也不会报错。它们只是影响你的模型 "智力".

习题 1 参考答案效果展示：opus4.5 very-lazy（不进行思考，努力值为低，即 “降智”）

努力值不设置时默认为高

习题 1 参考答案效果展示：opus4.5 think-2000：（思考预算为 2000）

习题 1 参考答案效果展示：opus4.5 think-16000：（思考预算为 16000）

同一个模型显示出三种不同的效果，展示了 options 配置的必要性.

感谢你看到这里！

下载 key 到同目录下的 keys.txt

#!/usr/bin/env python3
import argparse
import json
import os
import queue
import random
import ssl
import threading
import time
import urllib.error
import urllib.request


def parse_args() -> argparse.Namespace:
    parser = argparse.ArgumentParser(
        description="Check OpenAI API keys and list available models per key."
    )
    parser.add_argument(
        "--input",
        default="keys.txt",
        help="Input txt file, one key per line. Default: keys.txt.",
    )
    parser.add_argument(
        "--output",
        default="valid_models.txt",
        help="Output txt file for valid keys and their models.",
    )
    parser.add_argument(
        "--bad-output",
        default="",
        help="Optional txt file for invalid keys and errors.",
    )
    parser.add_argument("--concurrency", type=int, default=64)
    parser.add_argument("--queue-size", type=int, default=4096)
    parser.add_argument("--timeout", type=float, default=12.0)
    parser.add_argument("--max-retries", type=int, default=3)
    parser.add_argument("--backoff-base", type=float, default=0.5)
    parser.add_argument("--backoff-max", type=float, default=8.0)
    parser.add_argument("--log-every", type=int, default=5000)
    parser.add_argument("--flush-every", type=int, default=1000)
    parser.add_argument(
        "--base-url",
        default=os.environ.get("OPENAI_BASE_URL", "https://api.openai.com"),
    )
    parser.add_argument(
        "--organization",
        default=os.environ.get("OPENAI_ORG") or os.environ.get("OPENAI_ORGANIZATION"),
    )
    parser.add_argument("--project", default=os.environ.get("OPENAI_PROJECT"))
    parser.add_argument(
        "--extra-header",
        action="append",
        default=[],
        help='Extra header, format "Name: Value". Can be repeated.',
    )
    return parser.parse_args()


def normalize_key(line: str) -> str | None:
    stripped = line.strip()
    if not stripped or stripped.startswith("#"):
        return None
    return stripped.split()[0]


def parse_extra_headers(items: list[str]) -> dict[str, str]:
    headers: dict[str, str] = {}
    for item in items:
        if ":" not in item:
            raise ValueError(f"Invalid --extra-header value: {item}")
        name, value = item.split(":", 1)
        name = name.strip()
        value = value.strip()
        if not name:
            raise ValueError(f"Invalid --extra-header name: {item}")
        headers[name] = value
    return headers


def compute_sleep(attempt: int, backoff_base: float, backoff_max: float, retry_after: str | None) -> float:
    if retry_after:
        try:
            return min(backoff_max, float(retry_after))
        except ValueError:
            pass
    jitter = random.random() * 0.2
    return min(backoff_max, backoff_base * (2 ** attempt)) + jitter


def fetch_models_for_key(
        key: str,
        base_url: str,
        base_headers: dict[str, str],
        timeout: float,
        max_retries: int,
        backoff_base: float,
        backoff_max: float,
        ssl_context: ssl.SSLContext,
) -> tuple[list[str] | None, str, str]:
    headers = dict(base_headers)
    headers["Authorization"] = f"Bearer {key}"
    url = f"{base_url}/v1/models"

    for attempt in range(max_retries + 1):
        try:
            req = urllib.request.Request(url, headers=headers, method="GET")
            with urllib.request.urlopen(req, timeout=timeout, context=ssl_context) as resp:
                status = resp.getcode()
                body = resp.read()
            if status == 200:
                try:
                    payload = json.loads(body)
                except json.JSONDecodeError:
                    return None, "invalid_json", ""
                data = payload.get("data")
                if not isinstance(data, list):
                    return None, "invalid_response", ""
                models = sorted(
                    {item.get("id") for item in data if isinstance(item, dict) and item.get("id")}
                )
                return models, "ok", ""
            if status in (401, 403):
                return None, "unauthorized", f"http_{status}"
            if status == 429 or status >= 500:
                if attempt < max_retries:
                    time.sleep(compute_sleep(attempt, backoff_base, backoff_max, None))
                    continue
                return None, "retry_exhausted", f"http_{status}"
            return None, "http_error", f"http_{status}"
        except urllib.error.HTTPError as exc:
            status = exc.code
            retry_after = exc.headers.get("Retry-After") if exc.headers else None
            if status in (401, 403):
                return None, "unauthorized", f"http_{status}"
            if status == 429 or status >= 500:
                if attempt < max_retries:
                    time.sleep(compute_sleep(attempt, backoff_base, backoff_max, retry_after))
                    continue
                return None, "retry_exhausted", f"http_{status}"
            return None, "http_error", f"http_{status}"
        except urllib.error.URLError as exc:
            if attempt < max_retries:
                time.sleep(compute_sleep(attempt, backoff_base, backoff_max, None))
                continue
            return None, "network_error", str(exc)
        except Exception as exc:  # noqa: BLE001
            return None, "exception", str(exc)

    return None, "retry_exhausted", "unknown"


class Stats:
    def __init__(self, log_every: int) -> None:
        self.log_every = log_every
        self.lock = threading.Lock()
        self.processed = 0
        self.ok = 0
        self.bad = 0
        self.error = 0
        self.total = 0
        self.start = time.time()

    def set_total(self, total: int) -> None:
        with self.lock:
            self.total = total

    def update(self, status: str) -> None:
        with self.lock:
            self.processed += 1
            if status == "ok":
                self.ok += 1
            elif status == "unauthorized":
                self.bad += 1
            else:
                self.error += 1
            if self.log_every > 0 and self.processed % self.log_every == 0:
                elapsed = max(time.time() - self.start, 0.001)
                rate = self.processed / elapsed
                if self.total > 0:
                    remaining = max(self.total - self.processed, 0)
                    eta = remaining / rate if rate > 0 else 0.0
                    pct = (self.processed / self.total) * 100
                    print(
                        f"processed={self.processed}/{self.total} "
                        f"({pct:.1f}%) ok={self.ok} bad={self.bad} "
                        f"error={self.error} rate={rate:.1f}/s eta={eta:.0f}s",
                        flush=True,
                    )
                else:
                    print(
                        f"processed={self.processed} ok={self.ok} "
                        f"bad={self.bad} error={self.error} rate={rate:.1f}/s",
                        flush=True,
                    )


def worker(
        key_queue: queue.Queue,
        result_queue: queue.Queue,
        stats: Stats,
        base_url: str,
        base_headers: dict[str, str],
        timeout: float,
        max_retries: int,
        backoff_base: float,
        backoff_max: float,
        ssl_context: ssl.SSLContext,
) -> None:
    while True:
        key = key_queue.get()
        try:
            if key is None:
                return
            models, status, detail = fetch_models_for_key(
                key=key,
                base_url=base_url,
                base_headers=base_headers,
                timeout=timeout,
                max_retries=max_retries,
                backoff_base=backoff_base,
                backoff_max=backoff_max,
                ssl_context=ssl_context,
            )
            result_queue.put((key, models, status, detail))
            stats.update(status)
        finally:
            key_queue.task_done()


def writer(
        result_queue: queue.Queue,
        output_path: str,
        bad_output_path: str | None,
        flush_every: int,
) -> None:
    out_fp = open(output_path, "w", encoding="utf-8")
    bad_fp = open(bad_output_path, "w", encoding="utf-8") if bad_output_path else None
    written = 0
    bad_written = 0
    try:
        while True:
            item = result_queue.get()
            try:
                if item is None:
                    return
                key, models, status, detail = item
                if status == "ok" and models is not None:
                    out_fp.write(f"{key}\t{','.join(models)}\n")
                    written += 1
                    if flush_every > 0 and written % flush_every == 0:
                        out_fp.flush()
                elif bad_fp is not None:
                    bad_fp.write(f"{key}\t{status}\t{detail}\n")
                    bad_written += 1
                    if flush_every > 0 and bad_written % flush_every == 0:
                        bad_fp.flush()
            finally:
                result_queue.task_done()
    finally:
        out_fp.flush()
        out_fp.close()
        if bad_fp is not None:
            bad_fp.flush()
            bad_fp.close()


def main() -> int:
    args = parse_args()
    if args.concurrency <= 0:
        raise SystemExit("--concurrency must be > 0")
    if args.queue_size <= 0:
        raise SystemExit("--queue-size must be > 0")

    base_url = args.base_url.rstrip("/")
    base_headers = {"Accept": "application/json"}
    if args.organization:
        base_headers["OpenAI-Organization"] = args.organization
    if args.project:
        base_headers["OpenAI-Project"] = args.project
    if args.extra_header:
        base_headers.update(parse_extra_headers(args.extra_header))

    key_queue: queue.Queue = queue.Queue(maxsize=args.queue_size)
    result_queue: queue.Queue = queue.Queue(maxsize=args.queue_size)
    stats = Stats(log_every=args.log_every)
    ssl_context = ssl.create_default_context()

    bad_output = args.bad_output.strip() or None
    writer_thread = threading.Thread(
        target=writer,
        args=(result_queue, args.output, bad_output, args.flush_every),
        daemon=True,
    )
    writer_thread.start()

    print(
        "start "
        f"input={args.input} output={args.output} bad_output={bad_output or '-'} "
        f"concurrency={args.concurrency} queue_size={args.queue_size} "
        f"timeout={args.timeout} max_retries={args.max_retries}",
        flush=True,
    )

    workers: list[threading.Thread] = []
    for _ in range(args.concurrency):
        t = threading.Thread(
            target=worker,
            args=(
                key_queue,
                result_queue,
                stats,
                base_url,
                base_headers,
                args.timeout,
                args.max_retries,
                args.backoff_base,
                args.backoff_max,
                ssl_context,
            ),
            daemon=True,
        )
        t.start()
        workers.append(t)

    queued = 0
    with open(args.input, "r", encoding="utf-8", errors="ignore") as handle:
        for line in handle:
            key = normalize_key(line)
            if not key:
                continue
            key_queue.put(key)
            queued += 1
            if args.log_every > 0 and queued % args.log_every == 0:
                print(f"queued={queued}", flush=True)

    stats.set_total(queued)
    print(f"queued_total={queued}", flush=True)

    for _ in range(args.concurrency):
        key_queue.put(None)

    key_queue.join()
    for t in workers:
        t.join()

    result_queue.join()
    result_queue.put(None)
    writer_thread.join()

    elapsed = max(time.time() - stats.start, 0.001)
    print(
        f"done processed={stats.processed} ok={stats.ok} bad={stats.bad} "
        f"error={stats.error} seconds={elapsed:.1f}",
        flush=True,
    )
    return 0


if __name__ == "__main__":
    raise SystemExit(main())

关联 https://linux.do/t/topic/1496409/26

OpenCode GUI - VSCode 扩展版

基于哈雷佬的 Claudix 改造，将 OpenCode 带入 VSCode 侧边栏。

一句话介绍

在 VSCode 里直接使用 OpenCode，自动连接本地 server。

核心功能

• 侧边栏聊天 - 复用 Claudix 的精美 UI，在 VSCode 侧边栏直接对话
• 自动启动 - 配置本地地址后，扩展自动拉起 opencode serve
• 快速上下文 - Ctrl+L 发送选中代码，右键菜单添加文件
• 配置管理 - 设置页可视化编辑 OpenCode 配置（含 oh-my-opencode）
  
  
  

开发状态

早期版本，未经深度测试！ 可能存在各种 bug，欢迎试用并在 Issues 反馈问题。

安装

下载 最新 Release，在 VSCode 中：扩展 → “从 VSIX 安装…”

前置要求

• VS Code >= 1.98
• 已安装 OpenCode CLI (安装文档)

项目地址

致谢

感谢 @Haleclipse 提供的 Claudix UI 基础

佬们有这个需求，我调研了一下，droid 果然不赖，而且明显比 codex 内工具调用快。

现在不光挂载了 droid cc 和 cx 可以调度 droid， 且，droid 也可以调度 cc cx ge 和 oc! 这样完全可以以 droid 为主 ai。 也变相实现了 codex 的并发。

肝坏了，掌声和在哪里。

给不了解 ccb 的 l 佬一句话介绍，一键打开 1-5 个不同 ai 工具完全版，然后他们之间可以相互通讯和调度，可见可控拉满。打个麻将斗个地主，甚至形成牛马链：a 发任务给 b b 再发给 c，形成 ai 蜈蚣，不在话下。 想怎么玩怎么玩。

用了就离不开 群友都这么说！可加群 github 有

嗯，和七牛云学的
貌似直接 github 登录即可，貌似有 200 元余额赠送，目前完全免费
别和我说不知道长亭科技，雷池防火墙就是他们搞得

AutoGLM-GUI v1.5 正式发布啦。这个版本主要聚焦在生产力场景，让 AI
自动化真正可以投入日常使用。

从 v1.4.1 到 v1.5.5，经过 65 个提交，新增了大量功能：

• 定时任务系统
• Docker 部署支持
• 对话历史保存
• 模拟器零配置直连
• MCP 服务器集成

核心功能更新

1. 定时任务系统 - 自动化的自动化

现在可以设置定时任务，让 AI 自动执行重复性操作。比如：

• 每天早上 8 点自动打卡
• 每周定时清理应用缓存
• 定期执行数据同步操作

使用场景：

• 工作日自动处理固定流程
• 定期维护设备状态
• 批量任务的定时执行

一行命令部署到服务器，配合定时任务实现真正的无人值守：

docker run -p 8000:8000 Package autoglm-gui · GitHub

特性：

• 支持 x86_64 和 ARM64 架构
• 开箱即用，无需配置环境
• 配合 ADB over Network 实现远程控制

实际场景：
你可以把 AutoGLM-GUI 部署在家里的 NAS 或者云服务器上，通过 ADB WiFi 连接手机，实现：

• 远程执行自动化任务
• 服务器端定时任务调度
• 多设备集中管理

1. 对话历史 - 所有任务都有记录

现在所有的对话和操作都会自动保存到本地数据库，支持：

• 查看完整执行记录
• 检索历史对话
• 统计任务执行情况

实用价值：

• 出问题时可以回溯完整执行过程
• 优化任务提示词的参考依据
• 任务执行日志的长期保存

4. 模拟器直连 - 开发环境零配置

Android 模拟器（Android Studio、雷电、夜神等）现在可以直接连接，无需任何配置：

• 自动检测本地模拟器
• 无需 QR 码配对
• 即插即用

开发者友好：
如果你在开发环境测试自动化流程，现在可以直接用模拟器，省去真机配对的麻烦。

5. MCP 服务器 - 成为其他 AI 的工具

AutoGLM-GUI 现在内置了 MCP (Model Context Protocol) 服务器，可以作为工具被其他 AI
应用调用。

工作原理

MCP 服务器集成在 AutoGLM-GUI 的 FastAPI 应用中，通过 HTTP 协议提供服务。你需要先启动 AutoGLM-GUI 服务，然后其他 AI 应用就能通过 MCP 协议调用它的功能。

提供的能力

・chat (device_id, message) - 向设备发送自然语言任务
・list_devices () - 列出所有已连接的设备和状态

使用示例

场景 1：从 Claude Desktop 控制手机

你：帮我用手机打开微信
Claude：[调用 MCP chat 工具] → AutoGLM-GUI 执行 → 返回结果

场景 2：在 Cursor/Cline 中集成

agent.run("帮我清理后台应用")
# → 自动调用 MCP 工具操作你的设备 

场景 3：自定义 AI 工作流

• 定时任务触发 MCP 工具
• 多设备批量操作
• AI 决策调用手机操作

配置方式

首先启动 AutoGLM-GUI 服务：

autoglm-gui --base-url YOUR_API_ENDPOINT --port 8000

MCP 服务器端点为 http://localhost:8000/mcp（使用 SSE 传输协议）。

根据你使用的 MCP 客户端（Claude Desktop、Cursor、Cline 等），在配置文件中添加 MCP 服务器连接。具体配置方式请参考各客户端的 MCP 集成文档。

好不好用先不说，但它免费啊

FriendlyAI 的 K-EXAONE 236B 在 1/28 前都可以免费使用。
K-EXAONE 236B 是由 LG AI Research 所建立的模型。

经过我不断的尝试，发现还是直接抄 Claude Code 的 vs code 拓展的界面比较好看

关于我的 App

前几个月写了一个用大模型处理文字内容的 App。可以在 Windows 和 macOS 里通过快捷键 + 选中文字来快速的调用大模型。

比如，我在阅读一个技术文档，内容实在是太多了，我想让 AI 给我总结一下内容。那么我就选中所有的文字，然后通过快捷键让 AI 给我解释。

又或者，你看到一段非中文的内容，想让 AI 翻译一下。你再也不需要复制粘帖了，或者像谷歌翻译那样，要选择输入 + 输出的语言。现在只要选中文字再按下快捷键就可以了！

用法

1，下载，安装
2，给快捷键绑定提示词。比如，我想把翻译的功能绑定到 cmd+shift+T
3，在系统的任何地方选中文字，按下快捷键。
4，享受效率的提升！

展示

总结一段文字

或者，把你随意写的一段中文翻译成任何语言。也可以把任何语言翻译成中文，无需设置源语言。

为什么要做这个 App

我日常工作会经常的用到翻译之类的功能，一般是我写一段中文，然后让 AI 帮助我翻译成英文，或者是直接写英文，然后让 AI 帮助我挑一下语法错误。以前每次都要打开一个聊天界面然后把选中的文字输入进去，效率非常低。寻找一番后也没有找到我想要的软件，所以就自己做了一个。

后来我发现其实豆包和 CherryStudio 也有类似的功能，但是跟我想要的还是有差距。他们都是通过划词实现的，我无法接受划词弹出的那个小框。平时工作需要经常给别人共享屏幕，那个小窗口着实令人尴尬。而我的应用非常的 “隐形”，而且界面和功能很简单。对我这种有点强迫症的人非常友好。

下载

• 官网：Snap Mind - Instant Recall with a Keystroke
• 或者，直接在 github release 下载
  
  • windows 选择 setup.exe 或 portable.exe
  • mac 按照自己的 cpu 选择对应的 dmg 文件

项目介绍

GoogleManager 是一款专业的谷歌账号资产管理系统，适合需要管理多个谷歌账号的用户。

功能特性

• 账号管理 - 批量导入、单个导入、智能搜索、状态筛选
• 2FA 验证码 - 一键生成 TOTP 验证码，实时倒计时
• 快捷复制 - 一键复制完整账号信息
• 出售状态 - 标记已售 / 未售，二次确认机制
• 修改历史 - 记录密码、2FA、恢复邮箱等修改记录
• 安全特性 - 管理员密码保护、7 天登录有效期、IP 封禁机制
• 暗色 / 亮色模式 - 支持主题切换

技术栈

仓库链接：

快速开始

# 安装依赖
pip install -r requirements.txt
cd frontend && npm install

# 构建并启动
npm run build && cd ..
python run.py

从正在构造多对一替换词库，让 suno 能唱一切中文歌，过程中发现了一个有趣的拼音 “zhei” 继续讨论：
小工具封面标题也算话题封面:

引用的话题目的是构建一个替换词库，让 AI 在写歌词的时候 额外给出一个版本 根据自己写的歌词的每一个字的拼音将他们替换为我整理出来的更加可行的字…
但是

让 AI 自己判断，你放心吗？

经过几个小时的耕耘
三天的努力
最终确定了一个基本可行的替换词库
部分字我已经通过官网提供的免费 4.5 模型进行了验证可行～

但是，必须强调 似乎 如果 suno 发现前几行是中文，他不会好好唱的。

a → 啊
ai → 爱
an → 安
ang → 昂
ao → 熬
ba → 八
bai → 白
ban → 班
bang → 帮
bao → 包
bei → 杯
ben → 本
beng → 崩
bi → 比
bian → 边
biao → 标
bie → 别
bin → 冰
bing → 冰
bo → 波
bu → 不
ca → 擦
cai → 才
can → 产
cang → 仓
cao → 草
ce → 测
cen → 成
ceng → 成
cha → 查
chai → 才
chan → 产
chang → 尝
chao → 超
che → 车
chen → 晨
cheng → 城
chi → 吃
chong → 冲
chou → 抽
chu → 出
chuan → 传
chuang → 窗
chui → 吹
chun → 春
chuo → 错
ci → 词
cong → 从
cou → 抽
cu → 粗
cuan → 传
cui → 催
cun → 村
cuo → 错
da → 大
dai → 带
dan → 单
dang → 当
dao → 刀
de → 的
deng → 灯
di → 滴
dian → 点
diao → 掉
die → 蝶
ding → 丁
diu → 丢
dong → 东
dou → 都
du → 读
duan → 段
dui → 对
dun → 盾
duo → 多
e → 饿
ei → 诶(该拼音也不常用，建议禁用)
en → 恩
er → 儿
fa → 发
fan → 凡
fang → 方
fei → 飞
fen → 分
feng → 风
fo → 佛(禁用音)
fou → 否(禁用)
fu → 负
ga → 嘎(禁用音)
gai → 该
gan → 干
gang → 刚
gao → 高
ge → 哥
gei → 给
gen → 跟
geng → 更
gong → 工
gou → 勾
gu → 姑
gua → 瓜
guai → 乖
guan → 关
guang → 光
gui → 归
gun → 棍
guo → 国
ha → 哈
hai → 海
han → 汉
hang → 行
hao → 好
he → 和
hei → 黑
hen → 很
heng → 横
hong → 红
hou → 后
hu → 胡
hua → 花
huai → 怀
huan → 欢
huang → 黄
hui → 回
hun → 昏
huo → 火
ji → 几
jia → 家
jian → 间
jiang → 江
jiao → 交
jie → 接
jin → 金
jing → 京
jiong → 囧(禁用)
jiu → 九
ju → 居
juan → 卷
jue → 决
jun → 军
ka → 卡
kai → 开
kan → 看
kang → 抗
kao → 考
ke → 可
ken → 肯
keng → 坑
kong → 空
kou → 口
ku → 哭
kua → 夸
kuai → 快
kuan → 宽
kuang → 狂
kui → 亏
kun → 困
kuo → 扩
la → 拉
lai → 来
lan → 兰
lang → 狼
lao → 老
le → 乐
lei → 雷
leng → 冷
li → 力
lian → 连
liang → 良
liao → 疗
lie → 列
lin → 林
ling → 零
liu → 流
long → 龙
lou → 楼
lu → 路
luan → 乱
lun → 轮
luo → 罗
lü → 驴
lüe → 略
ma → 妈
mai → 买
man → 满
mang → 忙
mao → 毛
mei → 没
men → 门
meng → 蒙
mi → 米
mian → 面
miao → 苗
mie → 灭
min → 民
ming → 明
miu → 缪(禁用)
mo → 莫
mou → 谋
mu → 木
na → 那
nai → 奶
nan → 男
nang → 囊(禁用)
nao → 脑
ne → 呢
nei → 内
nen → 嫩(禁用)
neng → 能
ni → 你
nian → 年
niang → 凉
niao → 鸟
nie → 捏(禁用)
nin → 宁
ning → 宁
niu → 牛
nong → 农
nu → 努
nuan → 暖
nuo → 诺
nü → 女
nüe → 略
o → 哦
ou → 欧
pa → 趴
pai → 拍
pan → 盘
pang → 胖
pao → 跑
pei → 陪
pen → 盆
peng → 朋
pi → 皮
pian → 偏
piao → 飘
pie → 撇(禁用)
pin → 品
ping → 平
po → 破
pou → 剖(禁用)
pu → 扑
qi → 七
qia → 恰
qian → 千
qiang → 墙
qiao → 桥
qie → 切
qin → 亲
qing → 青
qiong → 穷
qiu → 秋
qu → 区
quan → 全
que → 缺
qun → 群
ran → 然
rang → 让
rao → 绕
re → 热
ren → 人
reng → 仍
ri → 日
rong → 容
rou → 肉
ru → 如
ruan → 软
rui → 锐
run → 润
ruo → 若
sa → 撒
sai → 赛
san → 三
sang → 桑
sao → 扫
se → 色
sen → 生
sha → 沙
shai → 晒(禁用)
shan → 山
shang → 上
shao → 少
she → 社
shen → 身
sheng → 声
shi → 是
shou → 手
shu → 书
shua → 刷
shuai → 帅
shuan → 拴(禁用)
shuang → 双
shui → 水
shun → 顺
shuo → 所
si → 四
song → 松
sou → 搜
su → 苏
suan → 酸
sui → 随
sun → 孙
suo → 所
ta → 他
tai → 太
tan → 谈
tang → 唐
tao → 桃
te → 特
teng → 疼
ti → 踢
tian → 天
tiao → 条
tie → 贴
ting → 听
tong → 同
tou → 头
tu → 土
tuan → 团
tui → 推
tun → 吞(禁用)
tuo → 托
wa → 哇
wai → 外
wan → 万
wang → 王
wei → 为
wen → 文
weng → 文
wo → 我
wu → 无
xi → 西
xia → 下
xian → 先
xiang → 香
xiao → 小
xie → 写
xin → 心
xing → 星
xiong → 熊
xiu → 休
xu → 须
xuan → 宣
xue → 学
xun → 寻
ya → 呀
yan → 言
yang → 阳
yao → 腰
ye → 叶
yi → 一
yin → 音
ying → 英
yo → 哟
yong → 用
you → 有
yu → 于
yuan → 元
yue → 月
yun → 云
za → 扎
zai → 在
zan → 赞
zang → 杖
zao → 早
ze → 择
zen → 珍
zeng → 增
zha → 炸
zhai → 摘
zhan → 占
zhang → 张
zhao → 招
zhe → 着
zhen → 真
zheng → 正
zhi → 之
zhong → 中
zhou → 周
zhu → 朱
zhua → 抓
zhuai → 拽(禁用)
zhuan → 专
zhuang → 庄
zhui → 追
zhun → 准
zhuo → 捉
zi → 子
zong → 宗
zou → 走
zu → 足
zuan → 钻
zui → 最
zun → 尊
zuo → 做

原版不是这样的

我们经过长时间的调查取证
我们先去除了 zhei shei
lia
den eng nun
下面是特殊：同样去除 但是:
dei (常用词只能对应一个 “得” 但是这个确实比较特殊 对于这一个字需要有一条小小的规则，明确规定 禁止在歌词中尝试使用 dei 这个字 而不选择表示 de 意的创作 ) 同时那个学校规则中也明确规定 chua (只能对应歘) 同样禁止使用 (得是多音字，并且确实很常用，所以特殊要求 而歘只有这一个读音，并且是这个读音的唯一一个常用字，所以相对来说更不重要，但还是概率会用上，所以明确一下禁用这个词 因为这个词 ai 确实不认识 可以这么理解 直接去除不额外写规则的 就是完全放心，你不会用上 也不应该用上 而明确规定的 就是怕你用上 提前阻止你用上 算是一个预防) 和 chua 地位相同的还有 dia (嗲) 这里再明确一下 这些有明确规则的，他们同样从我们的替换库中除名 (也就是从系列中去除)，只在专属的规则中提到 然后是 zei (只能对应一个贼 也不是好词，以后就不用了 当然一定要脑袋清晰的认识到，这是对歌词的处理，不是说全局禁用这些字，虽然大部分确实用不上 到现在为止，反反复复补充了好多内容。很多内容确实需要记录到规则中的，不是听一下就可以了 要谨慎对待这些补充语言哦) 然后是 seng (只能对应僧 我们禁用) chuai (踹和揣 前者不好，后者不常用 因此明确禁用这两个字 以上禁用的都是字，毕竟他们就是这个音能对应的非极生僻字的全部，所以禁用所有字相当于禁用音)

上面这一大段话是我对 AI 说的喵
只是为了把他们从库中删除
不过最终库还是我自己写的 w
毕竟所有替换词都是我最终自己决定的 400 个呀

所以为了解决开篇提出的问题，我们实现了代码化，我们使用了 pinyin-Pro 这个优良的库.
它甚至支持智能的多音字识别！

正式推出我的小工具

灵晖译影

也叫 lumen trans (流明转换 流明就是灵感的意思)

警告！

代码存在未知错误 需要排查

…

http://lumen-trans.stellafortuna.dpdns.org/
预览:

彻底的全量替换 确实看上去很奇怪，但一定能唱…
神奇的是 AI 即使面对这完全毫无逻辑的语言，他也可以用完全符合原版歌词的声调唱出来 (因为音乐通常都不在意声调 都是根据语境来的～这一点来说 AI 真的挺强的)

我的流明诺特也终于升级到正式的新年版本了！

26-0122!

社区孵化

人工智能软件开发

Hi 各位佬，

最近我高强度的在使用 Claude Code 和 Codex CLI 做开发。不得不说，AI 确实能极大提高效率，但用久了大家可能也有类似的感觉：信任成本很高。

主要体现在几个方面：

1. 既当裁判又当运动员：让 AI 既写代码又写测试，它倾向于写一些容易通过的测试，甚至直接修改测试逻辑来适配有问题的代码。
2. “西西弗斯” 式的完成：有时候它会在文档里信誓旦旦地写上 [x] Completed，但当去检查代码，发现只是一堆 TODO 或者只是个空壳。
3. 上下文漂移：聊得多了，它就忘了最初 Design 文档里的约束，开始自由发挥。
4. 缺乏长期思维：AI 输出的设计和代码有时候会不考虑长期演进，而只为了完成短期任务或者跑通测试。

为了解决这些问题，我开发了一个叫 Dev-PlayBooks 的项目（项目地址：github.com/ozbombor/dev-playbooks-cn）

本质上是一套结构化的 Prompt 策略配合 Shell 脚本工具链。目的是把软件工程里那些能够对抗 AI 缺陷的最佳实践，应用到 AI 的工作流里，约束 AI 的开发行为。

主要有这么几个特性：

1. 角色隔离

这是 Dev-PlayBooks 最核心的原则 —— 不再在一个对话框里完成所有任务。

设计阶段

• Proposal Author：负责提出提案。它的目标是把变更的 Why（为什么做）、What（做什么）和 Impact（影响范围）说清楚，并给出初步的设计方案。
• Proposal Challenger：专门负责 “挑刺” 和查漏补缺。它会质疑 Author 的假设，指出风险、不一致和设计缺陷，并寻找缺失的验收标准。
• Proposal Judge：负责最终裁决。它会综合 Author 的提案和 Challenger 的质疑，做出 Approved、Revise 或 Rejected（实际上不会发生，AI 还是很保守的） 并将理由记录在 Decision Log 中。

只有通过裁决，变更流程才会进入 Design 阶段。当然，如果觉得流程过重，也可以跳过 Challenger 和 Judge，直接进入设计。

编码阶段 分为 Test 组（包含 Test Owner 和 Test Reviewer）和 Coding 组（包含 Coder 和 Code Reviewer）：

• Test Owner：在一个独立的 Session 里工作。它的任务是根据设计文档写测试（Verification）。最重要的是，它被禁止读取实现代码（src/）。这就逼着它必须基于契约（Contract）来写测试。
• Coder：在另一个 Session 里工作。它的任务是让测试变绿。最重要的是，它被禁止修改测试代码（tests/）。Coder 就没法通过改测试来作弊，必须老老实实地通过红绿循环。
• Reviewer：审计生成的生产代码和测试代码的质量、完成度，并且提出修改建议或者通过提议。

2. 编码计划的颗粒度控制与无偏见思考

颗粒度控制

我发现 AI 在生成编码计划的时候，倾向于把所有东西一股脑放在计划里面，甚至会囊括所有的实现代码。这会导致 AI 在编码阶段直接陷入实现细节，丧失了计划阶段应该有的全局视野。

为此在 Dev-PlayBooks 里面，AI 被要求关注规划优势与抽象优势。Planner 的职责是把注意力分配到全局的模块划分、接口契约和验收锚点上，而不是去写具体的函数实现。那些不需要全局视野的实现细节，刻意留白给 Coder 去发挥。这样既保证了整体架构不走样，又给了编码阶段足够的灵活性。

无偏见

在现实项目中，tests/ 目录下通常已经成千上万行代码。如果允许 Planner 读取 tests/，AI 看到现有的 UserTest.java，它会下意识地把新功能的计划写成 “修改 UserTest.java”，而不是根据新设计思考 “我们需要一个新的 OAuth2Verification 模块”。

后果是，编码计划会不自觉地被旧架构引导，试图把新功能塞进旧的测试结构里，而不是按照新 Design 的意图去规划。所以 Planner 被要求禁止访问 tests/，隔离旧测试的干扰，强制它基于设计文档进行零基准思考，而不是基于现有代码做增量修补。

3. 归档阶段通过脚本验证作为硬闸门

Dev-PlayBooks 认为归档对质量控制也相当重要。Archiver Skill 是整个工作流的唯一出口，它不是简单的文件移动，而是一次严格的全量审计：

• 强制脚本验证：归档前必须运行 change-check.sh --mode strict。如果脚本返回非零（比如 AC 覆盖率未达 100%、Evidence 目录为空、Task 未全部打勾），归档流程立即终止。
• 自动回写设计：如果开发过程中发现了 Design Gap（记录在 deviation-log.md），Archiver 会自动将其回写到 design.md，确保文档永远反映项目的真实状态。
• 规格合并：将本次变更产生的 Specs 和 Contracts 合并到项目的 “真理源”（Truth Root），为下一次变更积累上下文。

只有通过了这一系列严苛检查的变更，才有资格进入 archive 目录，否则它就只能继续停留在 changes 目录里等待修复。

4. 代码质量监控

Dev-PlayBooks 引入了系统熵的概念。其实就是定期跑脚本统计圈复杂度、代码流失率、依赖深度等指标，生成一个 history.json。 这主要是为了防止 AI 为了实现功能堆砌代码。当熵值曲线异常升高时，就能知道：该停下来维护代码质量了。

更多特性，可以进入仓库页面查看。

目前这个项目支持 Claude Code、Codex CLI、Qoder 等主流 AI 编程工具。

安装方法

1. npm install -g dev-playbooks-cn
2. dev-playbooks-cn init：进入初始化页面，选择需要配置的 AI 编程工具，确认后会自动把 Spec 文档结构和 Skills 初始化进入项目。

更新方法

项目根目录下运行：dev-playbooks-cn update

迁移

如果你已经在使用 OpenSpec 或者 SpecKit，可以通过 dev-playbooks-cn --help 获取迁移指令，一键迁移到 Dev-PlayBooks，并自动适配 CLAUDE.md 和 AGENTS.md。

本项目的规范使用起来比较重，适合那些大型项目、复杂任务、对代码质量要求高的佬友。

项目地址：github.com/ozbombor/dev-playbooks-cn

欢迎大家试用、提 Issue、提 PR。

最近有给公司几十台机器做大内网的需求，需要用到 Cloudflare WARP+ 这个基础设施

由于官方的客户端收集数据太多，有过度收集的忧虑；而且配置繁琐，不利于大规模部署

调研过一些支持 Zero Trust Team 的脚本，也不满足我的需求

干脆花了两天的时间自己写了一个，把获取 WireGuard 配置的步骤简化，快速生成配置文件，抛弃官方客户端

API 网址

特点

1. 支持快速创建免费版（Free）/ 团队版（Team） 账号，团队版需要参考 Connect WARP before Windows login · Cloudflare One docs 文档中的步骤 1 & 2，事先获取并配置 Service Token 权限
2. 多种客户端支持：WireGuard 官方客户端（部分地区无法连接）/ 其他流行代理客户端
3. 完全隐私：仅代理登陆请求，不收集任何数据，不会也无法获取私钥（可完全本地生成，仅需要提交公钥）

使用方法
请阅读其中的 API 文档，恕不提供技术支持，也无开源计划（后续设备管理面板也许会开源）

开卡想法

之前看到群里佬友发布的 365 领取，尝试了一番，Google Pay 的中国 Visa 卡被限制区域无法交易。于是为了抓住这次机会，决定付诸实践去卡一张 Fiat24 的卡，没有到是 “一波三折”，经过 “辛苦卓绝” 的尝试后终于开通了…

开卡历程

步骤一：Bitget Wallet 钱包充值

依据群里佬友的指令，通过 Google Play 下载了 Bitget Wallet 的软件，成功创建加密钱包。没想到第一个 “折” 就来了…

“第一折”：钱包充值

因为想要获取 Fiat24 的卡，首先需要往钱包充值。但充值方式提供使用链上充值（在中国网络境内）及 Google Pay（免手续费，1：1 兑换）、C2C 等。想着正好账号绑定了卡可以 Google Pay 支付，没想到又提示失败。。。。C2C 在中国境内好像比较困难，剩下好像只有一条路链上充值。
之前没有真实接触过虚拟货币，但看多了也知道有个币安，尝试一下能否从币安进行充值。没想到 “第二折” 来了…

“第二折”：金额转出

在币安顺利的安装，完成实名认证；本着最少金额投入，通过 C2C 恰好购买了 10.0 几的 USDT 资金。没想到这是第二折的开始（后悔没注意到之前佬友有提示，转入了 11USDC）。

网络主链

在币安购入的 USDT 是在 BSC 网络下的，在尝试转账时 Bitget 上标的是 BNB 网络，一时不确定，经过查询和客服确认。在 Bitget 上标识的 BNB Chain 其实就是 BSC （BNB smart Chain，又称 BEP20），确定了两个是同一个。

Gas 费

在准备尝试转入时，提示需要资金账户要有 BNB 网络本币 BNB 作为 Gas 费，尝试交易购买，购买金额比 10USD 还有多… 最后通过闪兑，以高于交易价格买入了 0.00013… 的 BNB 币。顺利转出后…

“第三折”：金额不够

当在 Bitget 的钱包的金额 “正正好” 达到 10USD 后，参考佬友的文章，顺利开完卡后，第三折来了…

网络状态不一致，币种不一致

当尝试从 Bitget Wallet 钱包给卡充值 10USD 以上，激活卡片时。发现只支持从 airbitrum 的 USDC 转入，在 Bitget Wallet 进行跨链转换从 BNB 的 USDT 转至 airbitrum 的 USDC 时，通过闪兑，10USD 只剩 9.8 几，为了避免不到 10USD，突发奇想，把钱包加入到币安中，进行转换，转完后，正好宇 10.0000 几 USD，心想这下够了。

金额不够

冲入卡片时，说是不收手续费，其实是把手续费转为 ETH 货币返回，没想到充到卡里，只剩 9.9…。

为了最后。。。。

…
…
为了激活卡，不浪费 9.9USD，又冲了 10USD。
最后卡终于激活了！！！
…
…

上次在 Linuxdo 开源了小红书商业分析调研 agent:

开源地址：

基于这一个小例子，展示效果如何：

具体操作资料：
scraping_complete.json 爬虫 xhs 详细数据：

combined_analysis_complete.json 汇总分析数据：

comments_tag_analysis_complete.json 评论分析数据：

analysis_complete.json 完全分析数据：

github 开源地址，欢迎 star 和提意见：

大家好，分享一个我做的开源项目 ThinkFlow AI ：把「大模型的发散能力」变成「可视化的结构化思维树」，用来做选题拆解、方案推演、学习笔记、写作大纲都挺顺手。

• 在线体验： https://thinkflow-ai.lz-t.top/
• GitHub： GitHub - liu-ziting/ThinkFlowAI: ThinkFlow AI 是一个轻量、偏本地化（Local-first）的 “从想法到结构化图谱” 的工作台：输入一个核心想法，应用会把它扩展为可浏览的知识图谱（模块 / 子模块）。每个节点支持继续追问扩展、深挖详情，以及可选的配图生成。

它和传统脑图不一样的点

• 输入一个核心想法，AI 自动生成 3–5 个子分支，快速破除 “白纸焦虑”
• 每个节点都带 “从根到当前节点的路径上下文”，在节点里继续追问（Follow-up）会更贴合你的推理链路
• 节点支持「回答 / 深挖」（Markdown 富文本渲染）、以及「节点配图」增强记忆
• 一键「全图总结」提炼主线逻辑；一键「导出 Markdown」保留结构与深挖内容
• 子树折叠 + 树形布局 + 联动拖拽，图大了也能管得住

隐私与接口

• 本地优先：配置保存在浏览器本地
• 支持自定义任何 OpenAI 兼容接口（自定义模式下浏览器直连，不走中转）
• 默认提供演示接口（Cloudflare Workers/Pages 转发，可能有频率 / 额度限制）

如果你觉得这个方向有意思，求一个 Star 支持一下；也欢迎提 Issue/PR，一起把它打磨成更好用的 “思考画布”。

青年大学习之坠机的 GitHub 账号恢复:

猪波被 suspended 一次 + flagged 一次，记录一下恢复流程:

Suspended:

具体表现:

登录不上 GitHub 账号；所有 git 操作显示被 suspended; 其他人看你的仓库显示 404; 本地仓库 push 显示 suspended, 如图:

重要！
请第一时间前往 https://api.github.com/users/[username]/starred 查看你是否还能看到 star 过的仓库并备份 star 列表，如出现 404 那似透了，如没有出现 404 请在被 suspended 后的 6 个月以内立即使用本文的恢复方式提交工单

Flagged:

可以登录 GitHub 账号但是三方 GitHub Auth 认证全掉；所有 git 操作全被 ban; 其他人看你的仓库显示 404, 同时会重定向到 GitHub 首页显示下图:

如何恢复:

1. 前往 Sign in for Software Support and Product Help - GitHub 支持 用海外实体卡接码 (不会绑定手机号只是接码打开工单界面即可)
2. 根据不同情况搓恩情小作文:
   若 suspended 请先自己检查所有仓库为何频繁违反 GitHub DMCA 协议 , 同时在小作文里向安全与支持部门委婉描述清除违规 repo (彻底删除否则不让你登录), 参考邮件如下
   
   
   
   恩情小作文参考:

Does your claim involve content on GitHub or npm.js?

GitHub

What is the username and repository or package name that was impacted?

vmoranv

Why are you requesting reinstatement? If you are requesting support for your account not related to moderation limits made on your account by GitHub please raise a support ticket instead.

My account was disabled and I can’t login

Have you previously contacted GitHub about this claim?

No

Would you like to provide any additional information or context that would be helpful for our review of your reinstatement request?

Hello GitHub Support Team,

I’m writing regarding my account under the username vmoranv — it was suddenly suspended while I was submitting an issue to “IMG_PROMPT_API.” This account is critically important to me and my entire team.

I do not believe we have engaged in any activity that violates GitHub’s Terms of Service or Community Guidelines, and I’m not aware of any suspicious behavior originating from our account. We use this repository collaboratively and rely on it for project coordination and issue tracking.

Could you please inform me of the specific reason(s) for the suspension? If possible, I kindly request that you re-enable the account at your earliest convenience. If there has been some misunderstanding or false alarm, I would appreciate any guidance on how to rectify any issues or comply with your requirements.

Thank you for your time and assistance. We highly value GitHub as a platform for our work and hope to continue contributing as soon as possible.

Kind regards,
vmoranv
On behalf of the vmoranv team

I have reviewed and understand the GitHub Acceptable Use Policies and Community Guidelines.

此处我自己检查到这个 repo 的 issue 传瑟图了 (虽然不露点但是包含暗示), 请求安全部永久删除对应 repo

若 flagged 请第一时间记录下任何在 GitHub 上的活动如 init repo|git commit | 授权三方站点 | fork 三方仓库等，并在工单中说明自己被误封狡辩 , 参考小作文如下:

vmoranv
Jan 21, 2026, 10:40 AM UTC

Would you like to provide any additional information or context that would be helpful for our review of your reinstatement request?
Dear sir or madam:
I am writing to seek your help. My GitHub account has been flagged and my profile is hidden from public. It brings me a whole lot of trouble because I can't log in any third party site with GitHub auth. I doubt whether this problem has something to do with my recent network fluctuation or repo init recently. I would appreciate your help if you unflagged my account. Thank you so much!

您的主张是否涉及 GitHub 或 npm.js 上的内容？
github

What is the username and repository or package name that was impacted?
vmoranv

Why are you requesting reinstatement?
account-not-visible

Have you previously contacted GitHub about this claim?
no

confirm-notice
confirmed

请等待安全与支持部检查你的账号违规部分再回应
重要

1. 千万不要提交多个工单
2. 指出出问题的 repo 并删除即可，不要要求恢复
3. 如果在提交工单后一个星期内没有回复你的邮件可以尝试去 community · Discussions · GitHub 开一个小号并指出工单未受理 参考 Suspended Account Recovery · community · Discussion #181760 · GitHub
4. 如果在 discussions 中仍然未受理只能期望在 X 上 at https://x.com/GitHub 发帖问候他们是否有空审理你的工单并贴上工单号
5. 如果在 6 个月内都没有回应说明你的号连撒旦都嫌弃，似的透透的了，重开吧

参考资料:GitHub 申诉和恢复 - GitHub 文档

总所周知 cf 只转发指定端口
但是我买的低价 nat 鸡，那些端口都被别人占用了，
于是想着能不能任意端口都能经过 cf 的转发，
那个 cf 的隧道就能实现。
cf 主页的这个：

在网络 - 连接器中创建隧道：

选 cf 的这个就行了：

然后我的 nat 鸡是 debian13，选这个：

建议上面的代码分开执行，反正我一键复制执行就不行：

最后执行下面的那个启动隧道就是了。
然后自己添加最右边那个：

我懒得折腾证书了，直接用域名：80 端口就算了，反正都是连接到 cf，管他什么安全性的，唉

然后 3x-ui，里面整个 vmess 的 ws，主机名肯定是自己上面整的域名

nat 鸡肯定需要端口映射，自己整吧，
首先确认自己的 vmess 是能连通的：

然后直接，改成隧道的域名，和 80 端口：

然后发现也是通的：

然后直接改成 cf 的优选域名，（优选域名一大堆自己随便搜索，找一个自己 ping 低的就行了）：

然后就能低延迟一点，连接到辣鸡节点了，
测速图：

我的网络就 100m, 没办法。

这个的优点：辣鸡节点能套 cf 加速下载，延迟也能低一点；
缺点：晚上必寄，只有白天才舒服，晚上直接卡死。

所以我一般整来下载东西吧，不过需求也不大，不过白天用用也是不错的，至少能加速连接，加速下载。

这几天我对派奇智图的底层代码进行了一次脱胎换骨式的重构，让项目结构更加清晰，耦合性更低。

我在项目底层增加了对 OPFS(Origin private file system) 的支持，简单来说 OPFS 是浏览器提供的私有的高性能本地存储空间。图片生成后会默认下载并保存到临时的 OPFS 存储空间，这样在本地查看或操作图片时就无需再从网络上下载文件，也无需担心文件短时间内过期的问题。通过 OPFS，我实现了在无服务器（浏览器本地）直接使用画廊功能。 这样很多没有 S3 服务或者 WebDAV 的朋友也可以使用画廊功能，保存自己喜欢的图片了 。

增加了对 A4F 免费模型的支持。免费用户一天可以使用 300 次创作，允许使用的模型包括 Z-Image Turbo、Google Imagine 4 和 Google Imagine 3.5。不过目前测试下来，A4F 的免费服务稳定性不高，经常会出现生成失败的情况，不确定是我网络问题还是这个网站服务的问题。另外他们对图片尺寸的支持性很低，很多图片生成的尺寸都不遵循参数

我对 Hugging Face 的请求进行了重构，使用了通用的 Queue API，这个 API 可以更清楚的返回错误信息，稳定性也更高。

您可以通过我的 Demo 网站：Peinture 快速体验此项目。

另外此项目也有服务器版本，支持自部署，方便您与您的朋友共享您的图片生成服务。

如果您喜欢此项目，不妨 star 此项目

时间过得真快，距离上次发话题已经过去几个月，成年人的时间真是不经用。马上过年了，想罢年前一定要发点东西出来的。预祝大家新年快乐。

老实说，我在使用 AI coding 时，最抓狂的不是它写不出代码，而是它 太喜欢 “一口闷” 了。

场景通常是这样的：
我让 Claude Code 查一个 Bug，它二话不说读取了一个 5000 行的 server.log 或者把整个 utils.py 塞进上下文。结果就是：

1. Token 燃烧：我的钱包在滴血。
2. 上下文污染：关键信息被淹没在几千行无关代码里，它的智商瞬间掉线，开始胡言乱语。
3. 响应变慢：处理大量 Token 需要时间。

这其实就是典型的 上下文过载（Context Overload。模型就像一个贪婪的读者，如果你不限制它，它会试图把整个图书馆搬回家，而不是只借那一本它需要的书。

最近我在研究 Anthropic 提倡的 渐进式披露（Progressive Disclosure），并折腾出了一套强制性的文件读取策略。今天分享给大家，亲测能让 Claude Code 的脑子清醒不少。

什么是 “渐进式披露”？

别被这个学术名词吓到。用人话说是：不要给 AI 看全图，除非它问你要。

这就好比你作为一个人类程序员接手新项目，你不会上来就把 10 万行代码从头读到尾。你会先看目录结构（ls），再搜关键字（grep），最后只打开相关的那几十行代码（read）。

Anthropic 的文档里一直强调这一点：让模型先通过搜索定位，再通过切片读取。

但在实际的 CLI 工具中，Claude 有时候很懒，或者说 “太勤快”，默认行为往往是直接 Read 全文。所以，我们需要给它装一个 “防呆开关”。

这个 Hook 是怎么工作的？

我写了一个 Python 脚本作为 PreToolUse 的 Hook（工具调用前拦截器），配合 CLAUDE.md 的提示词，搞了一套 软硬兼施 的组合拳。

核心逻辑

这个方案由两部分组成：

1. “软” 规则（Prompt）：在系统提示词里告诉它，读文件必须加 offset（起始行）和 limit（行数限制）。
2. “硬” 拦截（Hook 脚本）：这是关键。当 Claude Code 试图调用 Read 工具时，脚本会检查目标文件的大小。

• 如果文件超过 1000 行 或 ，且 Claude Code 没有 指定 offset/limit：
• 拦截操作！返回 Exit Code 2。
• 杀手锏：在 stderr 里返回一段精心设计的报错信息。这段报错不仅告诉它 “你错了”，还告诉它 “你应该怎么做”（比如：推荐你先用 Grep 搜一下，然后只读第 X 行附近的 50 行）。

为什么它非常 Work？

这利用了 LLM 的一个特性：它们非常听 “报错信息” 的话。

当 Tool Use 失败并返回一个明确的 “推荐路径” 时，Claude 会立刻在这个报错的 Context 下进行自我修正。

• Claude: “我要读 app.log。” (未指定范围)
• Hook: (拦截) “不行，文件太大了。你必须指定读取范围。建议先用 Grep 搜一下关键词。”
• Claude: (收到报错) “噢，抱歉。那我们就先用 Grep 搜一下 ‘Error’ 关键字吧。”

看，这就强行把它拽回了 “渐进式披露” 的最佳实践路径上。

如何食用

你需要两个东西：一个是配置在项目根目录的规则文件，一个是实际执行拦截的 Python 脚本。

1. 提示词 (CLAUDE.md)

把这段加到你的项目提示词文件中。这相当于 “先礼后兵”，先告诉它规则。

中文版本

### 文件读取策略

** 强制规则 **：每次调用 Read 工具时 ** 必须 ** 指定 `offset` 和 `limit` 参数，禁止使用默认值。

#### 参数要求

| 参数   | 要求           | 说明                          |
| ------ | -------------- | ----------------------------- |
| `offset` | ** 必须指定 ** | 起始行号（从 0 开始）         |
| `limit`  | ** 必须指定 ** | 读取行数，单次不超过 500 行   |

#### 读取流程 1. ** 侦察 **：先用 Grep 了解文件结构，或定位目标关键词行号。

2. ** 精准打击 **：使用 offset + limit 精确读取目标区域。

3. ** 扩展 **：如果需要更多上下文，再调整 offset 继续读取。



** 目标 **：保持上下文精准、最小化。如果不遵守，工具调用将被 Hook 拦截。

English Version

### File Reading Strategy **MANDATORY RULE**: Every `Read` tool call **MUST** verify `offset` and `limit` parameters. Default full-file reads are prohibited for non-trivial files.

#### Parameter Requirements

| Param    | Requirement    | Description                   |
| -------- | -------------- | ----------------------------- |
| `offset` | **REQUIRED** | Start line number (0-indexed) |
| `limit`  | **REQUIRED** | Max lines to read (Max 500)   |

#### Workflow 1. **Recon**: Use `Grep` first to understand structure or locate keywords.
2. **Surgical Read**: Use `offset` + `limit` to read only the relevant section.
3. **Expand**: Adjust `offset` to read more context only if strictly necessary.

**Goal**: Keep context precise and minimal. Violations will be blocked by the PreToolUse hook.

2. The Hook (Python 脚本)

保存为 read_limit_hook.py，并在你的 Claude CLI 配置 hook（如果你不会可以直接把文件给 claude code 让它代劳）。

(这个脚本稍微有点长，但逻辑很简单：检查文件大小 → 检查参数 → 决定是放行、自动修正还是报错拦截)

#!/usr/bin/env python3 """

PreToolUse hook for Read tool - Enforce offset/limit and block large file reads.

""" import json
import sys
import os
from datetime import datetime

# --- 配置区域 ---
MAX_FILE_LINES = 1000 # 超过这个行数必须切片读
MAX_FILE_BYTES = 50 * 1024 
MAX_SINGLE_READ_LINES = 500 # 一次最多读 500 行
MAX_SINGLE_READ_BYTES = 20 * 1024 # 跳过不需要检查的二进制文件
SKIP_EXTENSIONS = {'.png', '.jpg', '.jpeg', '.gif', '.pdf', '.exe', '.dll', '.so', '.dylib', '.zip', '.tar', '.gz'}

# 日志文件（可选，帮你分析它浪费了多少次尝试）
LOG_FILE = os.path.expandvars ("$USERPROFILE/.claude/hooks/read-stats.log")

def get_file_stats (file_path):
    try:
        if not os.path.exists (file_path): return None, None
        size = os.path.getsize (file_path)
        with open (file_path, 'r', encoding='utf-8', errors='ignore') as f:
            lines = sum (1 for _ in f)
        return lines, size
    except:
        return None, None def format_bytes (size):
    if size >= 1024 * 1024: return f"{size / (1024 * 1024):.1f} MB" if size >= 1024: return f"{size / 1024:.1f} KB" return f"{size} B" def main ():
    try:
        input_data = json.load (sys.stdin)
    except:
        sys.exit (0) # 甚至不是 JSON，不管了

    tool_name = input_data.get ("tool_name", "")
    tool_input = input_data.get ("tool_input", {})

    # 只管 Read 工具 if tool_name != "Read":
        sys.exit (0)

    file_path = tool_input.get ("file_path", "")
    offset = tool_input.get ("offset")
    limit = tool_input.get ("limit")

    # 1. 扩展名检查
    ext = os.path.splitext (file_path)[1].lower ()
    if ext in SKIP_EXTENSIONS: sys.exit (0)

    lines, size = get_file_stats (file_path)
    if lines is None: sys.exit (0) # 读不到文件，让 Claude 自己处理错误 # 2. 检查是否是大文件
    is_large_file = lines > MAX_FILE_LINES or size > MAX_FILE_BYTES

    if is_large_file:
        # 如果是大文件，且没有指定 offset 或 limit -> 拦截！ if offset is None or limit is None:
            reason = f"{lines} lines / {format_bytes (size)}"
            error_msg = (
                f"BLOCKED: File is too large ({reason}) for a full read.\n" f"You MUST use 'offset' and 'limit' to read specific sections.\n\n" f"Strategy:\n" f"1. Use`Grep`to find the line number of your function/variable.\n" f"2. Then`Read`with offset=LINE_NUM, limit=50.\n" f"DO NOT try to read the whole file again."
            )
            print (error_msg, file=sys.stderr)
            sys.exit (2) # 2 通常表示操作被拒绝 # 3. 检查单次读取是否贪得无厌 if limit is not None and limit > MAX_SINGLE_READ_LINES:
        print (f"BLOCKED: Limit {limit} is too high. Max allowed is {MAX_SINGLE_READ_LINES}.", file=sys.stderr)
        sys.exit (2)

    # 4. 贴心的小功能：如果有 offset 没 limit，自动帮它补上 limit，防止它犯傻 if offset is not None and limit is None:
        output = {
            "hookSpecificOutput": {
                "permissionDecision": "allow",
                "updatedInput": { "limit": MAX_SINGLE_READ_LINES }
            }
        }
        print (json.dumps (output))
        sys.exit (0)

    sys.exit (0)

if __name__ == "__main__":
    main ()

效果

装上这一套之后，你会发现 Claude 的行为模式变了：

• 以前：读取 main.c (3000 行) → 思考 → 修改。
• 现在：尝试读取 main.c → 被拦截 → 思考 “哦，我应该先搜一下” → Grep main 函数 → 读取 main 函数周围 50 行 → 思考 → 修改。

虽然多了一步交互，但 上下文极其干净，Token 消耗量能降低 80% 以上，而且修改的准确率反而提高了。

试一下吧，让你的 Claude Code 甚至其他 Agent 学会渐进式的读取。