mosscode 0.1.0__py3-none-any.whl

mosscode/skills/__init__.py

@@ -0,0 +1,455 @@
+"""Skills: reusable procedures in SKILL.md directories, optionally with tools in tool.json."""
+
+from __future__ import annotations
+
+import json
+import re
+from collections.abc import Iterable
+from dataclasses import dataclass, field, replace
+from importlib import resources
+from pathlib import Path
+from typing import Literal
+
+import yaml
+
+from ..paths import mosscode_home
+
+NAME = re.compile(r"[a-z][a-z0-9-]*")
+TOOL_NAME = re.compile(r"[a-z][a-z0-9_]*")
+NAME_LIMIT = 64
+TOOL_SHORT_LIMIT = 32
+TOOL_NAME_LIMIT = 64  # Provider tool-name limit.
+FILE_LIMIT = 64 * 1024
+DEFAULT_TIMEOUT, MAX_TIMEOUT = 120.0, 600.0
+DESCRIPTION_LIMIT = 250
+CATALOG_LIMIT = 8000
+LOAD_SKILL = "load_skill"
+# Names known before MCP connects. load_skill is a system tool and always allowed.
+BUILTIN_TOOLS = frozenset(
+    {"read_file", "write_file", "edit_file", "execute_command", "glob", "grep", "memory", "exit_plan_mode"}
+)
+CLAUDE_TOOLS = {
+    "Read": "read_file",
+    "Write": "write_file",
+    "Edit": "edit_file",
+    "Bash": "execute_command",
+    "Glob": "glob",
+    "Grep": "grep",
+}
+Source = Literal["builtin", "user", "project"]
+SOURCE_LABELS = {"builtin": "内置", "user": "用户", "project": "项目"}
+
+
+class SkillError(ValueError):
+    """One skill directory is unusable; the message names the file and the field."""
+
+
+@dataclass(frozen=True)
+class SkillToolDef:
+    name: str  # Short name, unique within the skill.
+    full_name: str  # skill__<skill>__<name>
+    description: str
+    input_schema: dict
+    command: tuple[str, ...]  # argv before ${SKILL_DIR} / ${PYTHON} substitution
+    timeout: float = DEFAULT_TIMEOUT
+
+
+@dataclass(frozen=True)
+class SkillDef:
+    name: str
+    description: str
+    body: str
+    path: Path  # SKILL.md
+    source: Source
+    mode: Literal["inline", "fork"] = "inline"
+    fork_context: Literal["none", "recent", "full"] = "none"
+    allowed_tools: tuple[str, ...] = ()  # Claude Code names mapped; own tools expanded to full names.
+    model: str | None = None
+    argument_hint: str = ""
+    model_invocable: bool = True
+    user_invocable: bool = True
+    tools: tuple[SkillToolDef, ...] = ()
+    overrides: tuple[Path, ...] = ()  # Same-named SKILL.md files this one replaced.
+
+    @property
+    def directory(self) -> Path:
+        return self.path.parent
+
+    def render(self, arguments: str = "", *, fork: bool = False) -> str:
+        """Where it comes from, the suggested tools (not for a fork child) and the body."""
+        lines = [f"Skill {self.name}（目录：{self.directory}）"]
+        if self.tools:
+            lines.append("专属工具：" + "、".join(tool.full_name for tool in self.tools))
+        if self.allowed_tools and not fork:
+            lines.append("本 Skill 建议使用的工具：" + "、".join(self.allowed_tools))
+        return "\n".join(lines) + "\n\n" + expand_arguments(self.body, arguments)
+
+
+def expand_arguments(body: str, arguments: str) -> str:
+    arguments = arguments.strip()
+    if "$ARGUMENTS" in body:
+        return body.replace("$ARGUMENTS", arguments)
+    return body + (f"\n\n补充要求：{arguments}" if arguments else "")
+
+
+def tool_full_name(skill: str, tool: str) -> str:
+    return f"skill__{skill.replace('-', '_')}__{tool}"
+
+
+# Parsing ----------------------------------------------------------------------------------
+
+
+def _read(path: Path) -> str:
+    try:
+        data = path.read_bytes()
+    except OSError as exc:
+        raise SkillError(f"{path}：无法读取（{exc.strerror or exc}）。") from None
+    if len(data) > FILE_LIMIT:
+        raise SkillError(f"{path}：文件超过 64 KB。")
+    try:
+        return data.decode("utf-8-sig")
+    except UnicodeDecodeError:
+        raise SkillError(f"{path}：不是 UTF-8 编码。") from None
+
+
+def _split(text: str, path: Path) -> tuple[dict, str]:
+    lines = text.splitlines()
+    if not lines or lines[0].rstrip() != "---":
+        raise SkillError(f"{path}：缺少 YAML frontmatter（第一行应为 ---）。")
+    end = next((i for i in range(1, len(lines)) if lines[i].rstrip() == "---"), None)
+    if end is None:
+        raise SkillError(f"{path}：frontmatter 没有结束的 ---。")
+    try:
+        meta = yaml.safe_load("\n".join(lines[1:end])) or {}
+    except yaml.YAMLError as exc:
+        raise SkillError(f"{path}：frontmatter 不是合法的 YAML（{getattr(exc, 'problem', None) or exc}）。") from None
+    if not isinstance(meta, dict):
+        raise SkillError(f"{path}：frontmatter 必须是键值对。")
+    return meta, "\n".join(lines[end + 1 :]).strip()
+
+
+def _field(meta: dict, path: Path, *names: str):
+    present = [name for name in names if name in meta]
+    if len(present) > 1:
+        raise SkillError(f"{path}：{' 和 '.join(present)} 只能写一个。")
+    return (present[0], meta[present[0]]) if present else (names[0], None)
+
+
+def _text(meta, path, *names, required=False) -> str:
+    key, value = _field(meta, path, *names)
+    if value is None:
+        if required:
+            raise SkillError(f"{path}：缺少 {key}。")
+        return ""
+    if not isinstance(value, str) or (required and not value.strip()):
+        raise SkillError(f"{path}：{key} 必须是非空字符串。")
+    return value.strip()
+
+
+def _flag(meta, path, *names, default: bool) -> bool:
+    key, value = _field(meta, path, *names)
+    if value is None:
+        return default
+    if not isinstance(value, bool):
+        raise SkillError(f"{path}：{key} 必须是 true 或 false。")
+    return value
+
+
+def _choice(meta, path, key, choices, default):
+    value = meta.get(key)
+    if value is None:
+        return default
+    if value not in choices:
+        raise SkillError(f"{path}：{key} 只能是 {' / '.join(choices)}，当前为 {value!r}。")
+    return value
+
+
+def split_tool_list(value: str) -> list[str]:
+    """Commas or whitespace separate names; both may appear inside Bash(git commit:*)."""
+    items, current, depth = [], "", 0
+    for char in value:
+        if char == "(":
+            depth += 1
+        elif char == ")":
+            depth = max(depth - 1, 0)
+        if depth == 0 and (char == "," or char.isspace()):
+            if current:
+                items.append(current)
+            current = ""
+        else:
+            current += char
+    return items + ([current] if current else [])
+
+
+def _allowed(meta, path) -> list[str]:
+    key, value = _field(meta, path, "allowed_tools", "allowed-tools")
+    if value is None:
+        return []
+    if isinstance(value, str):
+        raw = split_tool_list(value)
+    elif isinstance(value, list) and all(isinstance(item, str) for item in value):
+        raw = [item.strip() for item in value if item.strip()]
+    else:
+        raise SkillError(f"{path}：{key} 必须是工具名列表或用逗号分隔的字符串。")
+    names = []
+    for item in raw:
+        name = item.split("(", 1)[0].strip()  # Bash(git:*) -> Bash: the argument part is ignored.
+        names.append(CLAUDE_TOOLS.get(name, name))
+    return list(dict.fromkeys(names))
+
+
+def _tool(item, index: int, skill: str, path: Path) -> SkillToolDef:
+    where = f"{path} 第 {index + 1} 项"
+    if not isinstance(item, dict):
+        raise SkillError(f"{where}：必须是对象。")
+    name = item.get("name")
+    if not isinstance(name, str) or not TOOL_NAME.fullmatch(name) or len(name) > TOOL_SHORT_LIMIT:
+        raise SkillError(f"{where}：name 须以小写字母开头，只含小写字母、数字和 _，最长 {TOOL_SHORT_LIMIT} 个字符。")
+    full = tool_full_name(skill, name)
+    if len(full) > TOOL_NAME_LIMIT:
+        raise SkillError(f"{where}：工具全名 {full} 超过 {TOOL_NAME_LIMIT} 个字符。")
+    description = item.get("description")
+    if not isinstance(description, str) or not description.strip():
+        raise SkillError(f"{where}（{name}）：description 必须是非空字符串。")
+    schema = item.get("input_schema")
+    try:
+        from ..mcp_client import check_schema
+
+        check_schema(schema)
+    except Exception as exc:  # ValueError or jsonschema.SchemaError
+        raise SkillError(
+            f"{where}（{name}）：input_schema 不合法（{getattr(exc, 'message', None) or exc}）。"
+        ) from None
+    command = item.get("command")
+    if not isinstance(command, list) or not command or not all(isinstance(part, str) and part for part in command):
+        raise SkillError(f"{where}（{name}）：command 必须是非空字符串组成的非空数组。")
+    timeout = item.get("timeout", DEFAULT_TIMEOUT)
+    if type(timeout) not in (int, float) or not 0 < timeout <= MAX_TIMEOUT:
+        raise SkillError(f"{where}（{name}）：timeout 必须是 0 到 {MAX_TIMEOUT:g} 之间的秒数。")
+    return SkillToolDef(name, full, description.strip(), schema, tuple(command), float(timeout))
+
+
+def _tools(directory: Path, skill: str) -> tuple[SkillToolDef, ...]:
+    path = directory / "tool.json"
+    if not path.is_file():
+        return ()
+    try:
+        items = json.loads(_read(path))
+    except ValueError as exc:
+        raise SkillError(f"{path}：不是合法的 JSON（{exc}）。") from None
+    if not isinstance(items, list):
+        raise SkillError(f"{path}：必须是工具对象组成的数组。")
+    tools = tuple(_tool(item, index, skill, path) for index, item in enumerate(items))
+    names = [tool.name for tool in tools]
+    duplicate = next((name for name in names if names.count(name) > 1), None)
+    if duplicate:
+        raise SkillError(f"{path}：工具名 {duplicate} 重复。")
+    return tools
+
+
+def parse_skill(directory: Path, source: Source) -> SkillDef:
+    """Read and check one skill directory, its tool whitelist included."""
+    path = directory / "SKILL.md"
+    if not path.is_file():
+        raise SkillError(f"{directory}：没有 SKILL.md。")
+    meta, body = _split(_read(path), path)
+    name = _text(meta, path, "name", required=True)
+    if not NAME.fullmatch(name) or len(name) > NAME_LIMIT:
+        raise SkillError(f"{path}：name 须以小写字母开头，只含小写字母、数字和 -，最长 {NAME_LIMIT} 个字符。")
+    if name != directory.name:
+        raise SkillError(f"{path}：name（{name}）必须与目录名（{directory.name}）相同。")
+    description = " ".join(_text(meta, path, "description", required=True).split())
+    if not body:
+        raise SkillError(f"{path}：正文为空。")
+    mode = _choice(meta, path, "mode", ("inline", "fork"), None)
+    context = _choice(meta, path, "context", ("fork",), None)
+    if context and mode == "inline":
+        raise SkillError(f"{path}：mode: inline 与 context: fork 矛盾。")
+    mode = "fork" if context else mode or "inline"
+    model = _text(meta, path, "model") or None
+    tools = _tools(directory, name)
+    own = {tool.name: tool.full_name for tool in tools}
+    allowed = []
+    for item in _allowed(meta, path):
+        item = own.get(item, item)
+        if item == LOAD_SKILL:
+            continue  # A system tool: never narrowed, so listing it changes nothing.
+        if item not in BUILTIN_TOOLS and item not in own.values() and not item.startswith("mcp__"):
+            raise SkillError(f"Skill {name}：allowed_tools 中的 {item} 不是已知工具（{path}）。")
+        allowed.append(item)
+    return SkillDef(
+        name,
+        description,
+        body,
+        path,
+        source,
+        mode,
+        _choice(meta, path, "fork_context", ("none", "recent", "full"), "none"),
+        tuple(allowed),
+        model,
+        _text(meta, path, "argument-hint", "argument_hint"),
+        not _flag(meta, path, "disable-model-invocation", "disable_model_invocation", default=False),
+        _flag(meta, path, "user-invocable", "user_invocable", default=True),
+        tools,
+    )
+
+
+# Catalog ----------------------------------------------------------------------------------
+
+
+def builtin_dir() -> Path:
+    return Path(str(resources.files(__name__).joinpath("builtin")))
+
+
+def skill_dirs(root: Path, home: Path | None = None, builtin: Path | None = None) -> list[tuple[Source, Path]]:
+    """Lowest priority first."""
+    return [
+        ("builtin", builtin if builtin is not None else builtin_dir()),
+        ("user", mosscode_home(home) / "skills"),
+        ("project", root / ".mosscode" / "skills"),
+    ]
+
+
+@dataclass
+class SkillCatalog:
+    skills: dict[str, SkillDef] = field(default_factory=dict)
+    problems: tuple[str, ...] = ()
+    _latest: dict[str, SkillDef] = field(default_factory=dict, repr=False)
+    _origin: tuple = field(default=(), repr=False)  # load() arguments, for reload().
+
+    @classmethod
+    def load(
+        cls, root: Path, home: Path | None = None, *, reserved: Iterable[str] = (), builtin: Path | None = None
+    ) -> SkillCatalog:
+        """Scan the three places; a later place replaces a same-named skill of an earlier one."""
+        reserved = set(reserved)
+        skills: dict[str, SkillDef] = {}
+        problems: list[str] = []
+        for source, base in skill_dirs(root, home, builtin):
+            try:
+                children = sorted(
+                    child for child in base.iterdir() if child.is_dir() and not child.name.startswith(".")
+                )
+            except OSError:
+                continue  # A missing place is not a problem.
+            for directory in children:
+                if directory.name == "__pycache__":
+                    continue
+                try:
+                    skill = parse_skill(directory, source)
+                except SkillError as exc:
+                    problems.append(f"Skill 已跳过：{exc}")
+                    continue
+                if skill.name in reserved:
+                    problems.append(f"Skill {skill.name} 已跳过：与内置命令 /{skill.name} 冲突（{skill.path}）。")
+                    continue
+                previous = skills.get(skill.name)
+                if previous is not None:
+                    skill = replace(skill, overrides=previous.overrides + (previous.path,))
+                skills[skill.name] = skill
+        return cls(dict(sorted(skills.items())), tuple(problems), _origin=(root, home, tuple(reserved), builtin))
+
+    def reload(self) -> SkillCatalog:
+        """Scan the same places again; a catalog that was not loaded from disk stays as it is."""
+        if not self._origin:
+            return self
+        root, home, reserved, builtin = self._origin
+        return SkillCatalog.load(root, home, reserved=reserved, builtin=builtin)
+
+    def get(self, name: str) -> SkillDef | None:
+        return self.skills.get(name)
+
+    def fresh(self, name: str) -> tuple[SkillDef, str | None]:
+        """Read the files again; on failure keep the last version that loaded."""
+        cached = self._latest.get(name) or self.skills[name]
+        try:
+            skill = parse_skill(cached.directory, cached.source)
+        except SkillError as exc:
+            return cached, f"Skill {name} 重新读取失败，已使用缓存版本：{exc}"
+        skill = replace(skill, overrides=cached.overrides)
+        self._latest[name] = skill
+        return skill, None
+
+    def catalog_section(self) -> tuple[str, str | None]:
+        """What the model sees before loading; returns the section and a notice when cut."""
+        lines, size, left = [], 0, 0
+        for skill in self.skills.values():
+            if not skill.model_invocable:
+                continue
+            description = skill.description
+            if len(description) > DESCRIPTION_LIMIT:
+                description = description[: DESCRIPTION_LIMIT - 1] + "…"
+            line = f"- {skill.name}：{description}"
+            if size + len(line) + 1 > CATALOG_LIMIT:
+                left += 1
+                continue
+            lines.append(line)
+            size += len(line) + 1
+        if not lines:
+            return "", None
+        text = (
+            "## Skill\nSkill 是可复用的操作规程。用户的请求与下列某个 Skill 的描述相符时，先调用 load_skill 加载它，"
+            "再按加载后的规程执行；不要凭描述猜测规程的内容。用户用 /<名称> 直接调用的 Skill 已附带规程，不需要再加载。\n\n"
+            + "\n".join(lines)
+        )
+        notice = f"有 {left} 个 Skill 未列入模型可见的目录，仍可用命令调用。" if left else None
+        return text, notice
+
+
+def missing_tools(skill: SkillDef, available: Iterable[str]) -> list[str]:
+    """Names that are not registered now; the skill's own tools count as available."""
+    available = set(available) | {tool.full_name for tool in skill.tools}
+    return [name for name in skill.allowed_tools if name not in available]
+
+
+@dataclass(frozen=True)
+class ForkRequest:
+    """An explicit /<name> of a fork skill; prompt is its rendered SOP."""
+
+    skill: SkillDef
+    prompt: str
+
+
+ACTIVE_LIMIT = 40000  # Characters of pinned SOPs in all.
+
+
+@dataclass(frozen=True)
+class ActiveSkill:
+    skill: SkillDef
+    arguments: str
+    text: str  # Rendered SOP
+
+
+class ActiveSkills:
+    """Skills the model loaded, in load order; loading one again refreshes it in place."""
+
+    def __init__(self) -> None:
+        self._items: dict[str, ActiveSkill] = {}
+
+    def __bool__(self) -> bool:
+        return bool(self._items)
+
+    def __contains__(self, name: str) -> bool:
+        return name in self._items
+
+    @property
+    def names(self) -> tuple[str, ...]:
+        return tuple(self._items)
+
+    def items(self) -> tuple[ActiveSkill, ...]:
+        return tuple(self._items.values())
+
+    def texts(self) -> tuple[str, ...]:
+        return tuple(item.text for item in self._items.values())
+
+    def size(self, without: str = "") -> int:
+        return sum(len(item.text) for name, item in self._items.items() if name != without)
+
+    def activate(self, skill: SkillDef, arguments: str, text: str) -> None:
+        self._items[skill.name] = ActiveSkill(skill, arguments, text)
+
+    def remove(self, name: str) -> None:
+        self._items.pop(name, None)
+
+    def clear(self) -> None:
+        self._items.clear()

mosscode/skills/builtin/commit/SKILL.md

@@ -0,0 +1,15 @@
+---
+name: commit
+description: 把与当前任务相关的改动提交为一次 git commit（不推送）
+allowed_tools: [execute_command, read_file]
+argument-hint: "[对提交说明的要求]"
+---
+
+请把当前仓库中与本次任务相关的改动提交为一次 git commit。
+
+1. 用 git status 和 git diff HEAD 查看改动；不是 git 仓库或没有可提交的改动时，直接说明并结束。
+2. 用 git log -n 5 --oneline 查看最近的提交说明，沿用仓库的语言和格式。
+3. 只暂存与本次任务相关的文件，用 git add <路径> 逐个列出；不要用 git add -A 或 git add .。看起来含密钥或凭据的文件（如 .env）不要暂存，并提醒用户。
+4. 写一条说明改动目的的提交说明，执行 git commit。不要 --amend，不要 --no-verify，不要推送。
+5. 提交钩子失败时报告原因；修复后重新提交，不改写已有提交。
+6. 完成后用 git status 和 git log -n 1 确认结果并汇报。

mosscode/skills/builtin/review/SKILL.md

@@ -0,0 +1,15 @@
+---
+name: review
+description: 审查当前仓库中尚未提交的改动（只读），按严重程度列出问题
+mode: fork
+fork_context: none
+allowed_tools: [read_file, glob, grep, execute_command]
+argument-hint: "[范围或侧重点]"
+---
+
+请审查当前仓库中尚未提交的改动。
+
+1. 先用 git status 和 git diff HEAD 查看改动范围；不是 git 仓库或没有改动时，直接说明并结束。
+2. 阅读改动涉及的上下文代码，找出正确性问题、边界条件、错误处理、安全隐患，以及与周边代码约定不一致的地方。
+3. 只审查，不修改文件，不运行会改变仓库或环境状态的命令。
+4. 按严重程度从高到低列出问题，每条写出 文件:行号、问题、触发场景和修改建议；没有发现问题时明确说明。

mosscode/skills/builtin/test/SKILL.md

@@ -0,0 +1,13 @@
+---
+name: test
+description: 检测项目类型并运行测试，失败时分析原因
+allowed_tools: [detect, execute_command, read_file, glob, grep]
+argument-hint: "[测试范围]"
+---
+
+请运行本项目的测试。
+
+1. 先调用 skill__test__detect 获取建议的测试命令；结果为空时，查看 README、AGENTS.md 等项目说明找测试方式，仍找不到就说明并结束。
+2. 有补充要求时（如只测某个文件或用例）按要求缩小范围。
+3. 运行测试命令。
+4. 全部通过时汇报结果；有失败时阅读失败用例和相关代码，说明原因和修改建议。用户没有要求修复时不修改文件。

mosscode/skills/builtin/test/scripts/detect.py

@@ -0,0 +1,96 @@
+"""Suggest test commands for the project in the working directory; prints a JSON array.
+
+Each item is {"kind", "command", "evidence"}. Only reads files; never runs anything. Standard library only.
+"""
+
+import configparser
+import json
+import sys
+import tomllib
+from pathlib import Path
+
+
+def _text(path: Path) -> str:
+    try:
+        return path.read_text(encoding="utf-8", errors="replace")
+    except OSError:
+        return ""
+
+
+def _python(root: Path) -> dict | None:
+    evidence = []
+    try:
+        pyproject = tomllib.loads(_text(root / "pyproject.toml")) if (root / "pyproject.toml").is_file() else {}
+    except tomllib.TOMLDecodeError:
+        pyproject = {}
+    if "pytest" in pyproject.get("tool", {}):
+        evidence.append("pyproject.toml 含 [tool.pytest]")
+    if (root / "pytest.ini").is_file():
+        evidence.append("pytest.ini")
+    for name, section in (("tox.ini", "pytest"), ("setup.cfg", "tool:pytest")):
+        if (root / name).is_file():
+            parser = configparser.ConfigParser(interpolation=None)
+            try:
+                parser.read_string(_text(root / name))
+            except configparser.Error:
+                continue
+            if parser.has_section(section):
+                evidence.append(f"{name} 含 [{section}]")
+    if (root / "tests").is_dir():
+        evidence.append("tests/ 目录")
+    if not evidence:
+        return None
+    python = "python"
+    for candidate in (".venv/Scripts/python.exe", ".venv/bin/python"):
+        if (root / candidate).is_file():
+            python = candidate.removesuffix(".exe")
+            evidence.append(f"{candidate} 存在")
+            break
+    return {"kind": "python", "command": f"{python} -m pytest", "evidence": "；".join(evidence)}
+
+
+def _node(root: Path) -> dict | None:
+    try:
+        package = json.loads(_text(root / "package.json")) if (root / "package.json").is_file() else {}
+    except ValueError:
+        return None
+    script = package.get("scripts", {}).get("test") if isinstance(package, dict) else None
+    if not isinstance(script, str) or not script.strip() or "no test specified" in script:
+        return None  # npm init's placeholder fails on purpose; it is not a test suite.
+    for lock, tool in (("pnpm-lock.yaml", "pnpm"), ("yarn.lock", "yarn")):
+        if (root / lock).is_file():
+            return {"kind": "node", "command": f"{tool} test", "evidence": f"package.json 的 scripts.test；{lock}"}
+    return {"kind": "node", "command": "npm test", "evidence": "package.json 的 scripts.test"}
+
+
+def _jvm(root: Path) -> dict | None:
+    if (root / "pom.xml").is_file():
+        return {"kind": "maven", "command": "mvn test", "evidence": "pom.xml"}
+    for name in ("build.gradle", "build.gradle.kts"):
+        if (root / name).is_file():
+            wrapper = (root / "gradlew").is_file() or (root / "gradlew.bat").is_file()
+            return {
+                "kind": "gradle",
+                "command": "./gradlew test" if wrapper else "gradle test",
+                "evidence": name + ("；gradlew" if wrapper else ""),
+            }
+    return None
+
+
+def detect(root: Path) -> list[dict]:
+    found = [_python(root), _node(root)]
+    if (root / "go.mod").is_file():
+        found.append({"kind": "go", "command": "go test ./...", "evidence": "go.mod"})
+    if (root / "Cargo.toml").is_file():
+        found.append({"kind": "rust", "command": "cargo test", "evidence": "Cargo.toml"})
+    found.append(_jvm(root))
+    return [item for item in found if item is not None]
+
+
+def main() -> None:
+    sys.stdin.read()  # The arguments object; this tool takes none.
+    print(json.dumps(detect(Path.cwd()), ensure_ascii=False))
+
+
+if __name__ == "__main__":
+    main()

mosscode/skills/builtin/test/tool.json

@@ -0,0 +1,9 @@
+[
+  {
+    "name": "detect",
+    "description": "检测项目类型，返回建议的测试命令及依据（只读取项目文件，不运行测试）",
+    "input_schema": {"type": "object", "properties": {}, "additionalProperties": false},
+    "command": ["${PYTHON}", "${SKILL_DIR}/scripts/detect.py"],
+    "timeout": 30
+  }
+]