indesign-cli 0.2.0__py3-none-any.whl

cli_anything/indesign/README.md

@@ -0,0 +1,32 @@
+# indesign-cli
+
+Agent 专用 InDesign CLI harness。
+
+常用命令：
+
+```powershell
+indesign-cli --version
+indesign-cli tool domains
+indesign-cli tool list --domain template
+indesign-cli tool schema template.run_jsx_file
+indesign-cli tool call template.run_jsx_file --args args.json
+indesign-cli script run scripts/check.jsx
+indesign-cli script run --stdin
+indesign-cli export verify output/result.pdf
+indesign-cli server setup
+indesign-cli server health
+indesign-cli session show
+indesign-cli skill install --target D:\AI\html-indesign
+```
+
+`cli-anything-indesign` 仍可作为旧项目兼容别名使用。
+
+`script run` 是 Agent 做真实 InDesign 验证的主入口：
+
+- 文件模式保留 `$.fileName` 和相对 `#include` 行为。
+- stdin 模式适合临时探针脚本，并支持中文输入。
+- JSX 可以返回普通字符串，也可以返回 `JSON.stringify(...)` 的字符串。
+- 返回 JSON 字符串时，CLI 输出会包含 `data.result_json`，避免调用方二次解析 `data.parsed.result`。
+- 成功和失败都会记录到当前目录的 `.indesign-cli/session.json`。
+
+本 CLI 复用当前项目的 MCP server 和 ExtendScript/COM 执行链路，不重新实现 InDesign 自动化能力。

cli_anything/indesign/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.2.0"

cli_anything/indesign/__main__.py

@@ -0,0 +1,5 @@
+from .indesign_cli import main
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

cli_anything/indesign/core/artifacts.py

@@ -0,0 +1,57 @@
+from __future__ import annotations
+
+import zipfile
+from datetime import datetime
+from pathlib import Path
+import re
+from typing import Any
+
+from .errors import CliError
+from .paths import scrub_path
+
+
+def parse_timestamp(value: str) -> datetime:
+    normalized = value.strip()
+    if normalized.endswith("Z"):
+        normalized = normalized[:-1] + "+00:00"
+    normalized = re.sub(r"(\.\d{6})\d+([+-]\d{2}:\d{2})$", r"\1\2", normalized)
+    return datetime.fromisoformat(normalized)
+
+
+def verify_artifact(path: Path, created_after: datetime | None = None, cwd: Path | None = None) -> dict[str, Any]:
+    path_info = scrub_path(str(path), cwd or Path.cwd())
+    if not path.exists():
+        raise CliError("Artifact not found", code="ARTIFACT_NOT_FOUND", details={"path": path_info})
+    stat = path.stat()
+    if stat.st_size <= 0:
+        raise CliError("Artifact is empty", code="ARTIFACT_EMPTY", details={"path": path_info})
+    if created_after and datetime.fromtimestamp(stat.st_mtime, created_after.tzinfo) < created_after:
+        raise CliError("Artifact is older than expected", code="ARTIFACT_TOO_OLD", details={"path": path_info})
+
+    suffix = path.suffix.lower()
+    if suffix == ".pdf":
+        with path.open("rb") as handle:
+            if handle.read(4) != b"%PDF":
+                raise CliError("PDF signature is invalid", code="ARTIFACT_SIGNATURE_INVALID")
+        return {
+            "path": path_info,
+            "kind": "pdf",
+            "size_bytes": stat.st_size,
+            "signature_ok": True,
+            "mtime": stat.st_mtime,
+        }
+    if suffix == ".idml":
+        try:
+            with zipfile.ZipFile(path) as archive:
+                if "designmap.xml" not in archive.namelist():
+                    raise CliError("IDML designmap.xml missing", code="ARTIFACT_SIGNATURE_INVALID")
+        except zipfile.BadZipFile as exc:
+            raise CliError("IDML ZIP structure is invalid", code="ARTIFACT_SIGNATURE_INVALID") from exc
+        return {
+            "path": path_info,
+            "kind": "idml",
+            "size_bytes": stat.st_size,
+            "signature_ok": True,
+            "mtime": stat.st_mtime,
+        }
+    raise CliError(f"Unsupported artifact type: {suffix}", code="ARTIFACT_UNSUPPORTED")

cli_anything/indesign/core/catalog.py

@@ -0,0 +1,405 @@
+from __future__ import annotations
+
+import re
+from collections import Counter
+from pathlib import Path
+from typing import Any
+
+from .domains import DOMAINS, infer_domain
+from .errors import CliError
+from .hidden_handler_schemas import HIDDEN_HANDLER_SCHEMAS
+from .plugins.manifest import PluginRecord
+
+
+CLI_PRIMITIVES = [
+    {
+        "id": "export.verify",
+        "domain": "export",
+        "name": "verify",
+        "one_line_purpose": "验证 PDF 或 IDML 产物是否存在且格式正确",
+        "arg_names": ["path", "created_after"],
+        "source": "cli",
+        "rank": 1,
+        "schema_size": "small",
+        "availability": "exposed",
+        "callable": True,
+        "requires": [],
+        "side_effects": [],
+        "artifact_kinds": ["pdf", "idml"],
+        "destructive": False,
+        "target_scope": "filesystem",
+        "needs_indesign": False,
+        "produces_artifacts": False,
+    },
+    {
+        "id": "server.health",
+        "domain": "server",
+        "name": "health",
+        "one_line_purpose": "检查 CLI、Node 入口和可选 InDesign 后端状态",
+        "arg_names": ["deep"],
+        "source": "cli",
+        "rank": 1,
+        "schema_size": "small",
+        "availability": "exposed",
+        "callable": True,
+        "requires": [],
+        "side_effects": [],
+        "artifact_kinds": [],
+        "destructive": False,
+        "target_scope": "project",
+        "needs_indesign": False,
+        "produces_artifacts": False,
+    },
+    {
+        "id": "server.setup",
+        "domain": "server",
+        "name": "setup",
+        "one_line_purpose": "在 CLI 内置 server 目录执行 npm install",
+        "arg_names": [],
+        "source": "cli",
+        "rank": 2,
+        "schema_size": "small",
+        "availability": "exposed",
+        "callable": True,
+        "requires": ["node", "npm"],
+        "side_effects": ["filesystem_write"],
+        "artifact_kinds": [],
+        "destructive": False,
+        "target_scope": "project",
+        "needs_indesign": False,
+        "produces_artifacts": False,
+    },
+    {
+        "id": "session.show",
+        "domain": "session",
+        "name": "show",
+        "one_line_purpose": "读取当前工作目录下的精简 CLI session",
+        "arg_names": ["verbose"],
+        "source": "cli",
+        "rank": 1,
+        "schema_size": "small",
+        "availability": "exposed",
+        "callable": True,
+        "requires": [],
+        "side_effects": [],
+        "artifact_kinds": [],
+        "destructive": False,
+        "target_scope": "workspace",
+        "needs_indesign": False,
+        "produces_artifacts": False,
+    },
+    {
+        "id": "session.clear",
+        "domain": "session",
+        "name": "clear",
+        "one_line_purpose": "清空当前工作目录下的 CLI session",
+        "arg_names": [],
+        "source": "cli",
+        "rank": 2,
+        "schema_size": "small",
+        "availability": "exposed",
+        "callable": True,
+        "requires": [],
+        "side_effects": ["session_write"],
+        "artifact_kinds": [],
+        "destructive": True,
+        "target_scope": "workspace",
+        "needs_indesign": False,
+        "produces_artifacts": False,
+    },
+    {
+        "id": "script.run",
+        "domain": "script",
+        "name": "run",
+        "one_line_purpose": "执行 JSX 文件或 stdin 临时脚本",
+        "arg_names": ["file", "stdin", "timeout"],
+        "source": "script",
+        "rank": 1,
+        "schema_size": "small",
+        "availability": "exposed",
+        "callable": True,
+        "requires": ["indesign_com"],
+        "side_effects": ["indesign_mutation"],
+        "artifact_kinds": [],
+        "destructive": False,
+        "target_scope": "indesign",
+        "needs_indesign": True,
+        "produces_artifacts": False,
+    },
+    {
+        "id": "skill.install",
+        "domain": "skill",
+        "name": "install",
+        "one_line_purpose": "把内置 indesign-cli skill 安装到目标项目",
+        "arg_names": ["target"],
+        "source": "cli",
+        "rank": 1,
+        "schema_size": "small",
+        "availability": "exposed",
+        "callable": True,
+        "requires": [],
+        "side_effects": ["filesystem_write"],
+        "artifact_kinds": [],
+        "destructive": False,
+        "target_scope": "workspace",
+        "needs_indesign": False,
+        "produces_artifacts": True,
+    },
+]
+
+
+HIDDEN_HANDLER_FILES = {
+    "book": "src/handlers/bookHandlers.js",
+    "presentation": "src/handlers/presentationHandlers.js",
+}
+
+VALID_SOURCES = {"cli", "script", "advanced", "classic", "hidden_handler", "plugin"}
+
+
+def _camel_to_snake(value: str) -> str:
+    value = re.sub(r"(.)([A-Z][a-z]+)", r"\1_\2", value)
+    return re.sub(r"([a-z0-9])([A-Z])", r"\1_\2", value).lower()
+
+
+def _schema_size(schema: dict[str, Any]) -> str:
+    count = len(schema.get("properties", {}))
+    if count <= 3:
+        return "small"
+    if count <= 8:
+        return "medium"
+    return "large"
+
+
+def _side_effects(tool_name: str, domain: str) -> list[str]:
+    if tool_name.startswith(("get_", "list_", "inspect_", "find_", "search_")):
+        return []
+    if domain == "export" or "export" in tool_name or "package" in tool_name:
+        return ["filesystem_write"]
+    return ["indesign_mutation"]
+
+
+def _artifact_kinds(tool_name: str) -> list[str]:
+    kinds: list[str] = []
+    lowered = tool_name.lower()
+    if "pdf" in lowered:
+        kinds.append("pdf")
+    if "idml" in lowered:
+        kinds.append("idml")
+    if "image" in lowered or "png" in lowered or "jpg" in lowered:
+        kinds.append("image")
+    if "epub" in lowered:
+        kinds.append("epub")
+    return kinds
+
+
+def _target_scope(domain: str, tool_name: str) -> str:
+    if domain == "export":
+        return "filesystem"
+    if "document" in tool_name or domain == "document":
+        return "active_document"
+    if domain in {"server", "session"}:
+        return "workspace"
+    return "indesign"
+
+
+def exposed_tool_entries(tools: list[dict[str, Any]], source: str) -> list[dict[str, Any]]:
+    entries: list[dict[str, Any]] = []
+    for index, tool in enumerate(tools):
+        name = tool["name"]
+        description = tool.get("description", "")
+        domain = infer_domain(name, description)
+        schema = tool.get("inputSchema", {})
+        arg_names = list(schema.get("properties", {}).keys())
+        artifact_kinds = _artifact_kinds(name)
+        entries.append(
+            {
+                "id": f"{domain}.{name}",
+                "domain": domain,
+                "name": name,
+                "one_line_purpose": description.splitlines()[0] if description else name,
+                "arg_names": arg_names,
+                "source": source,
+                "rank": (10 if source == "advanced" else 20) + index,
+                "schema_size": _schema_size(schema),
+                "availability": "exposed",
+                "callable": True,
+                "requires": ["indesign_com"],
+                "side_effects": _side_effects(name, domain),
+                "artifact_kinds": artifact_kinds,
+                "destructive": any(part in name for part in ("delete", "clear", "close")),
+                "target_scope": _target_scope(domain, name),
+                "needs_indesign": True,
+                "produces_artifacts": bool(artifact_kinds),
+            }
+        )
+    return entries
+
+
+def plugin_tool_entries(record: PluginRecord, tools: list[dict[str, Any]]) -> list[dict[str, Any]]:
+    entries: list[dict[str, Any]] = []
+    for index, tool in enumerate(tools):
+        tool_id = str(tool.get("id") or "")
+        name = str(tool.get("name") or tool_id.split(".", 1)[-1])
+        entries.append(
+            {
+                "id": tool_id,
+                "domain": str(tool.get("domain") or record.domain),
+                "name": name,
+                "one_line_purpose": str(tool.get("one_line_purpose") or tool.get("description") or name),
+                "arg_names": list(tool.get("arg_names") or []),
+                "source": "plugin",
+                "plugin": record.id,
+                "rank": int(tool.get("rank") or (70 + index)),
+                "schema_size": str(tool.get("schema_size") or "medium"),
+                "availability": "exposed",
+                "callable": bool(tool.get("callable", True)),
+                "requires": list(tool.get("requires") or []),
+                "side_effects": list(tool.get("side_effects") or []),
+                "artifact_kinds": list(tool.get("artifact_kinds") or []),
+                "destructive": bool(tool.get("destructive", False)),
+                "target_scope": str(tool.get("target_scope") or "workspace"),
+                "needs_indesign": bool(tool.get("needs_indesign", False)),
+                "produces_artifacts": bool(tool.get("produces_artifacts", False)),
+            }
+        )
+    return entries
+
+
+class Catalog:
+    def __init__(
+        self,
+        repo_root: Path,
+        tools: list[dict[str, Any]] | None = None,
+        domains: dict[str, str] | None = None,
+        plugin_records: dict[str, PluginRecord] | None = None,
+    ) -> None:
+        self.repo_root = repo_root
+        self._tools = tools or [*CLI_PRIMITIVES, *self._hidden_handler_entries()]
+        self._domains = domains or dict(DOMAINS)
+        self._plugin_records = plugin_records or {}
+
+    def with_exposed_tools(
+        self,
+        *,
+        advanced_tools: list[dict[str, Any]] | None = None,
+        classic_tools: list[dict[str, Any]] | None = None,
+        plugin_tools: list[dict[str, Any]] | None = None,
+        plugin_domain_summaries: dict[str, str] | None = None,
+        plugin_records: dict[str, PluginRecord] | None = None,
+    ) -> "Catalog":
+        tools = [*CLI_PRIMITIVES]
+        tools.extend(exposed_tool_entries(advanced_tools or [], "advanced"))
+        tools.extend(exposed_tool_entries(classic_tools or [], "classic"))
+        exposed_ids = {tool["id"] for tool in tools}
+        tools.extend(tool for tool in self._hidden_handler_entries() if tool["id"] not in exposed_ids)
+        existing_ids = {tool["id"] for tool in tools}
+        for plugin_tool in plugin_tools or []:
+            if plugin_tool["id"] in existing_ids:
+                raise CliError("Plugin tool id conflicts with an existing tool", code="PLUGIN_TOOL_CONFLICT", details={"tool_id": plugin_tool["id"]})
+            existing_ids.add(plugin_tool["id"])
+            tools.append(plugin_tool)
+        domains = dict(DOMAINS)
+        domains.update(plugin_domain_summaries or {})
+        return Catalog(repo_root=self.repo_root, tools=tools, domains=domains, plugin_records=plugin_records or {})
+
+    def domains(self) -> list[dict[str, Any]]:
+        source_counts: dict[str, Counter[str]] = {domain: Counter() for domain in self._domains}
+        top_tools: dict[str, list[dict[str, Any]]] = {domain: [] for domain in self._domains}
+        for tool in self._tools:
+            domain = tool["domain"]
+            source_counts.setdefault(domain, Counter())[tool["source"]] += 1
+            top_tools.setdefault(domain, []).append(tool)
+
+        result = []
+        for domain, summary in self._domains.items():
+            ranked = sorted(top_tools.get(domain, []), key=lambda item: (item["rank"], item["id"]))
+            callable_ranked = [item for item in ranked if item["callable"]]
+            result.append(
+                {
+                    "domain": domain,
+                    "summary": summary,
+                    "count_by_source": dict(source_counts.get(domain, Counter())),
+                    "top_tools": [item["id"] for item in callable_ranked[:5]],
+                }
+            )
+        return result
+
+    def list_tools(
+        self,
+        *,
+        domain: str | None = None,
+        source: str | None = None,
+        callable_only: bool = False,
+        query: str | None = None,
+    ) -> list[dict[str, Any]]:
+        tools = self._tools
+        if domain:
+            if domain not in self._domains:
+                raise CliError(
+                    f"Unknown domain: {domain}",
+                    code="DOMAIN_NOT_FOUND",
+                    details={"domain": domain, "available": list(self._domains)},
+                )
+            tools = [tool for tool in tools if tool["domain"] == domain]
+        if source:
+            if source not in VALID_SOURCES:
+                raise CliError(
+                    f"Unknown source: {source}",
+                    code="SOURCE_NOT_FOUND",
+                    details={"source": source, "available": sorted(VALID_SOURCES)},
+                )
+            tools = [tool for tool in tools if tool["source"] == source]
+        if callable_only:
+            tools = [tool for tool in tools if tool["callable"]]
+        if query:
+            needle = query.lower()
+            tools = [
+                tool
+                for tool in tools
+                if needle in tool["id"].lower()
+                or needle in tool["name"].lower()
+                or needle in tool["one_line_purpose"].lower()
+            ]
+        return sorted(tools, key=lambda item: (item["rank"], item["id"]))
+
+    def plugin_record(self, plugin_id: str) -> PluginRecord:
+        try:
+            return self._plugin_records[plugin_id]
+        except KeyError as exc:
+            raise CliError("Plugin record missing from catalog", code="PLUGIN_RECORD_NOT_FOUND", details={"plugin": plugin_id}) from exc
+
+    def _hidden_handler_entries(self) -> list[dict[str, Any]]:
+        entries: list[dict[str, Any]] = []
+        for domain, relative_path in HIDDEN_HANDLER_FILES.items():
+            path = self.repo_root / relative_path
+            if not path.exists():
+                continue
+            content = path.read_text(encoding="utf-8")
+            for method in re.findall(r"static\s+async\s+([A-Za-z0-9_]+)\s*\(", content):
+                name = _camel_to_snake(method)
+                tool_id = f"{domain}.{name}"
+                schema = HIDDEN_HANDLER_SCHEMAS.get(tool_id, {"type": "object", "properties": {}})
+                arg_names = list(schema.get("properties", {}).keys())
+                callable_handler = tool_id in HIDDEN_HANDLER_SCHEMAS
+                entries.append(
+                    {
+                        "id": tool_id,
+                        "domain": domain,
+                        "name": name,
+                        "one_line_purpose": f"调用已有 {domain} handler 能力",
+                        "arg_names": arg_names,
+                        "source": "hidden_handler",
+                        "rank": 90,
+                        "schema_size": _schema_size(schema) if callable_handler else "unknown",
+                        "availability": "exposed" if callable_handler else "hidden_handler",
+                        "callable": callable_handler,
+                        "requires": ["indesign_com"],
+                        "side_effects": ["indesign_mutation"],
+                        "artifact_kinds": _artifact_kinds(name),
+                        "destructive": any(part in name for part in ("delete", "clear", "close")),
+                        "target_scope": _target_scope(domain, name),
+                        "needs_indesign": True,
+                        "produces_artifacts": bool(_artifact_kinds(name)),
+                    }
+                )
+        return entries

cli_anything/indesign/core/domains.py

@@ -0,0 +1,178 @@
+from __future__ import annotations
+
+
+DOMAINS = {
+    "template": "模板槽位、脚本标签、母版占位和模板填充",
+    "document": "打开、保存、关闭、文档信息",
+    "page": "页面、页面尺寸和页面基础操作",
+    "spread": "跨页、跨页布局和跨页范围操作",
+    "master": "母版、母版跨页和母版对象",
+    "layer": "图层创建、查询、锁定、显示和删除",
+    "object": "页面对象、对象组、几何位置、脚本标签",
+    "text": "文本框、文本内容、段落和字符操作",
+    "graphics": "图片、图形框、适配和基础绘制",
+    "style": "段落样式、字符样式、对象样式",
+    "export": "PDF、IDML、图片等导出和产物验证",
+    "book": "InDesign Book 文件、章节和书籍级同步",
+    "presentation": "演示型版面、页面序列和 presentation handler 能力",
+    "script": "JSX 文件执行和 stdin 临时脚本",
+    "session": "CLI 本地状态、最近文档和最近输出",
+    "server": "依赖、后端、InDesign COM 健康检查",
+    "skill": "把内置 Agent skill 安装到目标项目",
+    "utility": "难以归入以上域的辅助能力",
+}
+
+
+EXACT_TOOL_DOMAINS = {
+    "run_jsx_file": "template",
+    "inspect_template_blueprint": "template",
+    "list_template_blueprints": "template",
+    "create_page_with_template": "template",
+    "populate_template_slots": "template",
+    "execute_indesign_code": "script",
+    "help": "utility",
+}
+
+
+NAME_DOMAIN_RULES = [
+    ("export_", "export"),
+    ("package_", "export"),
+    ("create_presentation_", "presentation"),
+    ("add_cover_page", "presentation"),
+    ("add_section_page", "presentation"),
+    ("add_full_bleed_image", "presentation"),
+    ("add_image_grid", "presentation"),
+    ("master_", "master"),
+    ("create_master_", "master"),
+    ("delete_master_", "master"),
+    ("duplicate_master_", "master"),
+    ("apply_master_", "master"),
+    ("get_master_", "master"),
+    ("detach_master_", "master"),
+    ("remove_master_", "master"),
+    ("list_spreads", "spread"),
+    ("get_spread_", "spread"),
+    ("duplicate_spread", "spread"),
+    ("move_spread", "spread"),
+    ("delete_spread", "spread"),
+    ("set_spread_", "spread"),
+    ("create_spread_", "spread"),
+    ("place_file_on_spread", "spread"),
+    ("place_xml_on_spread", "spread"),
+    ("select_spread", "spread"),
+    ("add_page", "page"),
+    ("delete_page", "page"),
+    ("duplicate_page", "page"),
+    ("navigate_to_page", "page"),
+    ("get_page_", "page"),
+    ("move_page", "page"),
+    ("set_page_", "page"),
+    ("adjust_page_", "page"),
+    ("resize_page", "page"),
+    ("create_page_", "page"),
+    ("place_file_on_page", "page"),
+    ("place_xml_on_page", "page"),
+    ("snapshot_page_", "page"),
+    ("delete_page_layout_", "page"),
+    ("reframe_page", "page"),
+    ("select_page", "page"),
+    ("create_layer", "layer"),
+    ("set_active_layer", "layer"),
+    ("list_layers", "layer"),
+    ("create_text_", "text"),
+    ("edit_text_", "text"),
+    ("create_table", "text"),
+    ("populate_table", "text"),
+    ("find_replace_text", "text"),
+    ("find_text_", "text"),
+    ("create_paragraph_style", "style"),
+    ("create_character_style", "style"),
+    ("apply_paragraph_style", "style"),
+    ("apply_character_style", "style"),
+    ("create_object_style", "style"),
+    ("list_object_styles", "style"),
+    ("apply_object_style", "style"),
+    ("apply_color", "style"),
+    ("create_color_swatch", "style"),
+    ("list_color_swatches", "style"),
+    ("create_rectangle", "graphics"),
+    ("create_ellipse", "graphics"),
+    ("create_polygon", "graphics"),
+    ("place_image", "graphics"),
+    ("get_image_", "graphics"),
+    ("create_group", "object"),
+    ("ungroup", "object"),
+    ("get_group_", "object"),
+    ("add_items_to_group", "object"),
+    ("remove_items_from_group", "object"),
+    ("get_all_page_items", "object"),
+    ("get_page_item_", "object"),
+    ("move_page_item", "object"),
+    ("resize_page_item", "object"),
+    ("rotate_page_item", "object"),
+    ("delete_page_item", "object"),
+    ("set_page_item_", "object"),
+    ("get_page_items_by_label", "object"),
+    ("set_page_item_label", "object"),
+    ("get_document_info", "document"),
+    ("create_document", "document"),
+    ("open_document", "document"),
+    ("save_document", "document"),
+    ("close_document", "document"),
+    ("preflight_document", "document"),
+    ("data_merge", "document"),
+    ("get_document_", "document"),
+    ("set_document_", "document"),
+    ("organize_document_", "document"),
+    ("create_document_", "document"),
+    ("export_document_", "document"),
+    ("save_document_", "document"),
+    ("open_cloud_document", "document"),
+    ("validate_document", "document"),
+    ("cleanup_document", "document"),
+]
+
+
+KEYWORD_DOMAINS = {
+    "template": "template",
+    "blueprint": "template",
+    "slot": "template",
+    "document": "document",
+    "page": "page",
+    "spread": "spread",
+    "master": "master",
+    "layer": "layer",
+    "item": "object",
+    "object": "object",
+    "group": "object",
+    "label": "object",
+    "text": "text",
+    "paragraph": "style",
+    "character": "style",
+    "style": "style",
+    "graphic": "graphics",
+    "image": "graphics",
+    "export": "export",
+    "pdf": "export",
+    "idml": "export",
+    "book": "book",
+    "presentation": "presentation",
+    "session": "session",
+    "health": "server",
+    "skill": "skill",
+    "help": "utility",
+}
+
+
+def infer_domain(tool_name: str, description: str = "") -> str:
+    exact = EXACT_TOOL_DOMAINS.get(tool_name)
+    if exact:
+        return exact
+    for prefix, domain in NAME_DOMAIN_RULES:
+        if tool_name.startswith(prefix):
+            return domain
+    haystack = f"{tool_name} {description}".lower()
+    for keyword, domain in KEYWORD_DOMAINS.items():
+        if keyword in haystack:
+            return domain
+    return "utility"