@yottameta/yotta-dev-mcp 0.2.1 → 0.2.2

package/CHANGELOG.md

@@ -1,3 +1,14 @@
+## v0.2.2 (2026-09-26)
+
+新增工具分组 `--tools core|full`（与元忆同口径），供需要把工具表常驻上下文的宿主使用。
+
+- `core` = 5 工具：`repo_map` / `find_code` / `review_code` / `review_diff` / `verify_change`；紧凑 JSON schema 3,883 字符。
+- `full` = 全部 18 工具（默认，行为与 0.2.1 一致）；同一口径下 schema 13,230 字符。
+- 背景：产品侧实测 18 工具 `schemaChars 8174`，超过其 8,000 硬上限，无法默认常驻；core 档按同一比例约 2.4k，留有充足余量。
+- `core` 模式下调用 full 专属工具会返回明确提示（"属于 full 分组，请用 --tools full 重新启动"），不做静默失败。
+- `--help` / `--version` 支持；非法分组值以中文用法错误 + 退出码 2 拒绝。
+- 回归：新增 7 项分档用例（默认 full / core 列表与顺序 / core 拒绝 full 专属工具 / schema 预算 / 非法值拒绝 / stdio 两种端到端）；元开全量 189/189（1 skip）。
+
 # Changelog
 
 ## v0.2.1 (2026-09-25)

package/README.md

@@ -126,8 +126,13 @@ python scripts/dev_engine.py mcp-doctor
 
 ## Current version
 
-`0.2.1` (2026-09-25) is a defect-fix release: `mcp_doctor` now covers Codex,
-WorkBuddy, OpenCode, Cursor and other hosts with a coverage report;
+`0.2.2` (2026-09-26) adds tool profiles. Start the server with `--tools core`
+for a five-tool set (`repo_map` / `find_code` / `review_code` / `review_diff` /
+`verify_change`, ~3.9k characters of compact JSON schema) so hosts that keep the
+tool table resident stay inside their schema budget; `--tools full` (default)
+keeps all 18 tools. Calling a full-only tool in `core` mode returns an explicit
+message instead of failing silently. Previous `0.2.1`: `mcp_doctor` covers
+Codex, WorkBuddy, OpenCode, Cursor and other hosts with a coverage report;
 `self_test(mode="installed")` is distribution-aware; `repo_map` resolves
 `from . import X`; `scan_secrets` filters path/hash/filename noise; and
 `review_code` ignores temporary directories.

package/README.zh-CN.md

@@ -114,10 +114,15 @@ python scripts/dev_engine.py mcp-doctor
 
 ## 当前版本
 
-`0.2.1`（2026-09-25）是缺陷修复批次：`mcp_doctor` 覆盖 Codex / WorkBuddy /
-OpenCode / Cursor 等宿主并返回 coverage；`self_test(mode="installed")`
-按分发形态判断 banner；`repo_map` 修复 `from . import X`；`scan_secrets`
-过滤路径 / 哈希 / 文件名噪声；`review_code` 忽略临时目录。
+`0.2.2`（2026-09-26）新增工具分组：用 `--tools core` 启动只暴露 5 个工具
+（`repo_map` / `find_code` / `review_code` / `review_diff` / `verify_change`，
+紧凑 JSON schema 约 3.9k 字符），供需要把工具表常驻上下文的宿主留在自己的
+schema 预算内；`--tools full`（默认）保持全部 18 个工具。core 模式下调用
+full 专属工具会返回明确提示，不做静默失败。上一版 `0.2.1`：`mcp_doctor`
+覆盖 Codex / WorkBuddy / OpenCode / Cursor 等宿主并返回 coverage；
+`self_test(mode="installed")` 按分发形态判断 banner；`repo_map` 修复
+`from . import X`；`scan_secrets` 过滤路径 / 哈希 / 文件名噪声；
+`review_code` 忽略临时目录。
 
 `0.2.0`（2026-09-25）在原有十二个确定性工具之上新增 `system_model`、
 `architecture_review`、`impact_analysis`、`verify_change`、`self_test`、

package/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: yotta-dev-mcp
 description: 元开（yotta-dev-mcp）—— 本地、确定性的开发工具 MCP，把只读默认的开发能力暴露为 stdio MCP server：repo_map / system_model / architecture_review / impact_analysis / verify_change / self_test / run_adapter / find_code / compress_output / review_code / review_diff / mcp_doctor / scan_secrets / scan_dependencies / check_publish_readiness / run_checks / scaffold_skill / workflow_state。触发：让 AI 在陌生项目里先做结构盘点、构建系统模型或架构契约（.yotta/architecture.json）、按契约评审架构、分析改动影响锥与回归面、按验证阶梯产出证据账本、对元开自身做完整性 / 反证自测、探测或显式运行 import-linter / dependency-cruiser / Repomix 可选适配器、定位代码、评审改动、扫描密钥/依赖、检查发布就绪、运行白名单检查、生成脚手架或读取 .workflow 状态时；或用户说 元开 / 开发能力 MCP / yotta-dev-mcp / 代码库地图 / 系统模型 / 架构契约 / 架构评审 / 影响分析 / 验证账本 / 反证自测 / 代码评审 MCP / 适配器 等。边界：Python 3.8+ 标准库、离线默认；除 run_checks（显式 allow_execute）、verify_change 的 L2-L4 策略检查（显式 allow_execute）与 self_test 的测试子集（显式 allow_execute）、run_adapter 的 action=run（显式 allow_execute）、scaffold_skill / workflow_state 的显式 apply 外均为只读；不上传源码、不自动修改、不提交、不联网查询包是否存在、不自动安装或下载适配器。
-version: 0.2.1
+version: 0.2.2
 license: MIT
 ---
 
@@ -37,6 +37,18 @@ npx -y @yottameta/yotta-dev-mcp
 python scripts/yotta_dev_mcp.py
 ```
 
+工具分组（`--tools`，与元忆同口径）：
+
+```bash
+python scripts/yotta_dev_mcp.py --tools core   # 5 工具：repo_map / find_code / review_code / review_diff / verify_change
+python scripts/yotta_dev_mcp.py --tools full   # 18 工具（默认）
+```
+
+`core` 给「需要把工具表常驻在上下文里」的宿主用：schema 体积约为 `full` 的 29%
+（5 工具 3,883 字符 vs 18 工具 13,230 字符，紧凑 JSON 口径），适合默认启用；
+`full` 暴露全部工具，适合按需调用、不常驻的场景。`core` 模式下调用 full 专属工具会返回
+明确提示（提示用 `--tools full` 重启）。
+
 自动接入说明：AI 首次协助配置时，必须先展示目标配置文件、完整配置片段和影响，
 并获得用户明确同意后再写入 `mcpServers`。用户拒绝时不要写文件，直接提供上面的启动命令
 让用户手动接入。

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yottameta/yotta-dev-mcp",
-  "version": "0.2.1",
+  "version": "0.2.2",
   "description": "YuanKai (yotta-dev-mcp) - deterministic local development tools exposed over stdio MCP: repo_map, system_model, architecture_review, impact_analysis, verify_change, self_test, run_adapter, find_code, compress_output, review_code, review_diff, mcp_doctor, scan_secrets, scan_dependencies, check_publish_readiness, run_checks, scaffold_skill and workflow_state. Reads an optional .yotta/architecture.json contract plus .yotta/verification.json policy for architecture reviews, change impact cones and the L0-L5 evidence ledger. Optional explicit adapters integrate import-linter, dependency-cruiser and Repomix without auto-install or network access. Python 3.8+ standard library, offline by default; writes and command execution require explicit flags.",
   "license": "MIT",
   "keywords": [

package/scripts/dev_engine.py

@@ -41,7 +41,7 @@ from dev_model import (
 )
 from dev_rules import REVIEW_RULES
 
-VERSION = "0.2.1"
+VERSION = "0.2.2"
 
 
 

package/scripts/dev_selftest.py

@@ -52,22 +52,23 @@ def _protocol_tool_contracts(source_text):
     tree = ast.parse(source_text)
     function = None
     for node in tree.body:
-        if isinstance(node, ast.FunctionDef) and node.name == "mcp_tools":
+        # v0.2.2 起工具清单字面量在 _all_tools()；mcp_tools(profile) 只做分档过滤。
+        if isinstance(node, ast.FunctionDef) and node.name in ("_all_tools", "mcp_tools"):
             function = node
             break
     if function is None:
-        raise ValueError("mcp_tools() not found")
+        raise ValueError("tool list function not found")
     list_node = None
     for node in ast.walk(function):
         if isinstance(node, ast.Return) and isinstance(node.value, ast.List):
             list_node = node.value
             break
     if list_node is None:
-        raise ValueError("mcp_tools() does not return a literal tool list")
+        raise ValueError("tool list function does not return a literal tool list")
     contracts = []
     for element in list_node.elts:
         if not isinstance(element, ast.Dict):
-            raise ValueError("mcp_tools() contains a non-literal tool entry")
+            raise ValueError("tool list contains a non-literal tool entry")
         values = {}
         for key, value in zip(element.keys, element.values):
             if _string_constant(key):

package/scripts/yotta_dev_mcp.py

@@ -25,6 +25,25 @@ MCP_PROTOCOL_MODERN = "2026-07-28"
 MCP_PROTOCOL_LEGACY = "2025-11-25"
 SERVER_INFO = {"name": TOOL_NAME, "version": VERSION}
 
+# 工具分组（v0.2.2）：与元忆 `--tools core|full` 同口径。core 是给「需要在上下文里
+# 常驻工具表」的宿主用小档（5 工具，schema 远低于 8000 字符硬上限）；full 保持 18 工具。
+CORE_TOOL_NAMES = (
+    "repo_map",
+    "find_code",
+    "review_code",
+    "review_diff",
+    "verify_change",
+)
+TOOL_PROFILES = ("core", "full")
+DEFAULT_TOOL_PROFILE = "full"
+
+
+def normalize_tool_profile(value):
+    profile = str(value or "").strip().lower() or DEFAULT_TOOL_PROFILE
+    if profile not in TOOL_PROFILES:
+        raise ValueError("未知工具分组: %s（可用: core / full）" % value)
+    return profile
+
 
 def _text_result(payload):
     return {
@@ -63,7 +82,7 @@ TOOL_HANDLERS = {
 }
 
 
-def mcp_tools():
+def _all_tools():
     return [
         {
             "name": "repo_map",
@@ -521,6 +540,15 @@ def mcp_tools():
     ]
 
 
+def mcp_tools(profile=None):
+    """按工具分档返回 tools/list 内容（core 5 个 / full 18 个）。"""
+    tools = _all_tools()
+    if normalize_tool_profile(profile) == "core":
+        by_name = {tool["name"]: tool for tool in tools}
+        return [by_name[name] for name in CORE_TOOL_NAMES]
+    return tools
+
+
 def _req_version(params):
     meta = (params or {}).get("_meta") or {}
     return meta.get("io.modelcontextprotocol/protocolVersion")
@@ -548,7 +576,7 @@ def _unsupported_version(rid, protocol_version):
     }
 
 
-def handle_message(msg):
+def handle_message(msg, tool_profile=None):
     if not isinstance(msg, dict) or msg.get("jsonrpc") != "2.0":
         rid = msg.get("id") if isinstance(msg, dict) else None
         return {"jsonrpc": "2.0", "id": rid,
@@ -578,7 +606,9 @@ def handle_message(msg):
                         "verify_change for change-centered evidence, self_test for integrity "
                         "checks, and run_adapter to probe or explicitly run optional local "
                         "architecture adapters. Tools are offline and read-only unless an "
-                        "explicit write or execute flag is set."
+                        "explicit write or execute flag is set. Current tool profile: "
+                        + normalize_tool_profile(tool_profile)
+                        + " (start with --tools core|full)."
                     ),
                 }, (3600000, "public")),
             }
@@ -588,11 +618,20 @@ def handle_message(msg):
             return {
                 "jsonrpc": "2.0",
                 "id": rid,
-                "result": _modern_ok({"tools": mcp_tools()}, (300000, "public")),
+                "result": _modern_ok({"tools": mcp_tools(tool_profile)}, (300000, "public")),
             }
         if method == "tools/call":
             name = params.get("name")
             arguments = params.get("arguments") or {}
+            if (normalize_tool_profile(tool_profile) == "core"
+                    and name not in CORE_TOOL_NAMES):
+                return {
+                    "jsonrpc": "2.0",
+                    "id": rid,
+                    "result": _modern_ok(_tool_error(
+                        "工具 %s 属于 full 分组，当前以 --tools core 启动。"
+                        "需要完整工具集时请用 --tools full 重新启动。" % name)),
+                }
             handler = TOOL_HANDLERS.get(name)
             if not handler:
                 return {
@@ -626,10 +665,16 @@ def handle_message(msg):
     if method == "ping":
         return {"jsonrpc": "2.0", "id": rid, "result": {}}
     if method == "tools/list":
-        return {"jsonrpc": "2.0", "id": rid, "result": {"tools": mcp_tools()}}
+        return {"jsonrpc": "2.0", "id": rid,
+                "result": {"tools": mcp_tools(tool_profile)}}
     if method == "tools/call":
         name = params.get("name")
         arguments = params.get("arguments") or {}
+        if (normalize_tool_profile(tool_profile) == "core"
+                and name not in CORE_TOOL_NAMES):
+            return {"jsonrpc": "2.0", "id": rid, "result": _tool_error(
+                "工具 %s 属于 full 分组，当前以 --tools core 启动。"
+                "需要完整工具集时请用 --tools full 重新启动。" % name)}
         handler = TOOL_HANDLERS.get(name)
         if not handler:
             return {
@@ -642,7 +687,42 @@ def handle_message(msg):
             "error": {"code": -32601, "message": "Method not found: " + str(method)}}
 
 
+def parse_args(argv):
+    """解析启动参数：`--tools core|full`（默认 full）、`--version`、`--help`。"""
+    profile = DEFAULT_TOOL_PROFILE
+    index = 0
+    while index < len(argv):
+        arg = argv[index]
+        if arg == "--tools":
+            index += 1
+            if index >= len(argv):
+                sys.stderr.write("用法错误: --tools 需要一个值（core / full）\n")
+                raise SystemExit(2)
+            raw = argv[index]
+        elif arg.startswith("--tools="):
+            raw = arg.split("=", 1)[1]
+        elif arg in ("--version", "-v"):
+            print("%s %s" % (TOOL_NAME, VERSION))
+            raise SystemExit(0)
+        elif arg in ("--help", "-h"):
+            print("用法: yotta-dev-mcp [--tools core|full]")
+            print("  core: 5 工具（%s）" % " / ".join(CORE_TOOL_NAMES))
+            print("  full: 18 工具（默认）")
+            raise SystemExit(0)
+        else:
+            sys.stderr.write("用法错误: 未知参数 %s\n" % arg)
+            raise SystemExit(2)
+        try:
+            profile = normalize_tool_profile(raw)
+        except ValueError as exc:
+            sys.stderr.write("用法错误: %s\n" % exc)
+            raise SystemExit(2)
+        index += 1
+    return profile
+
+
 def main():
+    tool_profile = parse_args(sys.argv[1:])
     try:
         sys.stdin.reconfigure(encoding="utf-8")
         sys.stdout.reconfigure(encoding="utf-8")
@@ -659,7 +739,7 @@ def main():
             response = {"jsonrpc": "2.0", "id": None,
                         "error": {"code": -32700, "message": "parse error"}}
         else:
-            response = handle_message(message)
+            response = handle_message(message, tool_profile)
         if response is not None:
             sys.stdout.write(json.dumps(response, ensure_ascii=False) + "\n")
             sys.stdout.flush()

package/server.json

@@ -6,12 +6,12 @@
     "url": "https://github.com/YottaMeta/yotta-dev-mcp",
     "source": "github"
   },
-  "version": "0.2.1",
+  "version": "0.2.2",
   "packages": [
     {
       "registryType": "npm",
       "identifier": "@yottameta/yotta-dev-mcp",
-      "version": "0.2.1",
+      "version": "0.2.2",
       "transport": {
         "type": "stdio"
       }