@craftsamo/git-tools 0.1.0 → 0.2.1

package/src/hermes/git_tools_hermes/approval.py

@@ -162,18 +162,13 @@ def resolve_target(
     """What ``target`` prints: ``["*"]`` for resources that cannot be told, no description for one absent or bad.
 
     ``language`` is the plugin's ``language`` setting and ``harness_language`` reads Hermes' display language
-    per call; neither may fail the run, and ``target`` picks among them. ``option_flags`` are the flags of the
-    plugin's tool options, which the call's description may read as ``run`` does.
+    per call; neither may fail the run, and ``target`` picks among them.
     """
     try:
         result = runtime.run(
             [
-                "target",
-                tool_id,
-                "--cwd",
-                agent_cwd(),
-                *language_flags(language, _known(harness_language)),
-                *(option_flags or []),
+                "target", tool_id, "--cwd", agent_cwd(),
+                *language_flags(language, _known(harness_language)), *(option_flags or []),
             ],
             stdin=json.dumps(run_arguments(args)),
             timeout=TARGET_TIMEOUT_SECONDS,
@@ -232,8 +227,7 @@ def make_hook(
 
     Whether a person is there to ask, and what happens when none is, is
     Hermes' own gate to decide. ``language`` is the plugin's ``language``
-    setting; ``harness_language`` is read on every call; ``option_flags``
-    are the flags of the plugin's tool options, passed to ``target``. When ``pins`` is
+    setting; ``harness_language`` is read on every call. When ``pins`` is
     given, the pin ``target`` answered is kept in it under the call's
     ``pin_key`` for the pin hook; the decision is the same either way.
     """
@@ -309,7 +303,6 @@ def register_approval(
 ) -> None:
     """Hold every non-read call of ``tools`` for approval, with the card in ``language`` (the plugin's setting).
 
-    ``option_flags`` are the flags of the plugin's tool options, which ``target`` reads as ``run`` does.
     Two hooks, in this order, since Hermes runs them in registration order: the approval hook
     stashes the pin of what the card shows, then the pin hook gives it to the call.
     """
@@ -317,12 +310,7 @@ def register_approval(
     ctx.register_hook(
         HOOK_NAME,
         make_hook(
-            runtime,
-            tools,
-            surface=lambda: session_surface(ctx),
-            language=language,
-            pins=pins,
-            option_flags=option_flags,
+            runtime, tools, surface=lambda: session_surface(ctx), language=language, pins=pins, option_flags=option_flags
         ),
     )
     ctx.register_hook(HOOK_NAME, make_pin_hook(tools, pins))

package/src/hermes/git_tools_hermes/plugin.py

@@ -9,7 +9,7 @@ from .context import PluginContext
 from .listing import list_tools
 from . import project
 from .runtime import Unavailable, locate_runtime
-from .settings import SettingsError, language_setting, option_flags, settings_flags
+from .settings import SettingsError, emoji_setting, language_setting, option_flags, settings_flags
 from .skills import register_skills
 from .tools import register_tools
 
@@ -33,6 +33,6 @@ def register(ctx: PluginContext) -> None:
         logger.warning("%s is not available and registers nothing: %s", project.PLUGIN_NAME, error)
         return
 
-    register_tools(ctx, runtime, tools, flags)
+    register_tools(ctx, runtime, tools, flags, emoji_setting(ctx))
     register_approval(ctx, runtime, tools, language_setting(ctx), option_flags(ctx))
     register_skills(ctx, runtime.skills_dir, {tool.toolset for tool in tools})

package/src/hermes/git_tools_hermes/project.py

@@ -14,9 +14,10 @@ SKILL_PREFIX = "git-"
 #: The emoji each toolset is shown with; empty by default until a project adds its own.
 TOOLSET_EMOJI: dict[str, str] = {}
 
-#: The settings the tools themselves read, beside the ones every plugin takes: each holds text and is named in
-#: snake_case, as in ``src/project.ts``. A setting ``a_b`` becomes the flag ``--a-b`` of the command line.
-OPTIONS: tuple[str, ...] = ("published_text_rules", "worktree_root")
+#: The settings the tools themselves read: each snake_case name and a type (``text``, ``boolean``, ``number``,
+#: ``list``, ``path`` or ``paths``) or a dict with ``type`` and optional bounds (``integer``, ``min``, ``max``),
+#: as in ``src/project.ts``. Write OPTIONS on one line with double quotes. A setting ``a_b`` becomes ``--a-b``.
+OPTIONS: dict[str, str | dict[str, object]] = {"published_text_rules": "text", "worktree_root": "text"}
 
 __all__ = [
     "CLI_NAME",

package/src/hermes/git_tools_hermes/settings.py

@@ -2,6 +2,8 @@
 
 from __future__ import annotations
 
+import math
+from collections.abc import Mapping
 from typing import Any
 
 from . import project
@@ -31,30 +33,60 @@ def language_setting(ctx: PluginContext) -> str | None:
     return (value.strip() or None) if isinstance(value, str) else None
 
 
-def option_flags(ctx: PluginContext) -> list[str]:
-    """Read the tool options (``project.OPTIONS``) and return the flags that say the same, each ``--a-b <text>``.
+def emoji_setting(ctx: PluginContext, defaults: Mapping[str, str] | None = None) -> dict[str, str]:
+    """The emoji per toolset: ``defaults`` (``project.TOOLSET_EMOJI``) with string entries of ``emoji`` merged over it.
 
-    An option that is absent or blank gives no flag, so the command line's own
-    variable (``GIT_TOOLS_<OPTION>``) applies. These are the only flags
-    ``target`` takes beside its language ones.
+    A setting that is not a ``dict``, and an entry whose key or value is not a
+    ``str``, are ignored so a typo never takes every tool away. It is no flag
+    of ``settings_flags``.
+    """
+    merged = dict(project.TOOLSET_EMOJI if defaults is None else defaults)
+    value = ctx.get_config("emoji")
+    if isinstance(value, dict):
+        merged.update({key: item for key, item in value.items() if isinstance(key, str) and isinstance(item, str)})
+    return merged
 
-    Raises:
-        SettingsError: an option is not text.
+
+def _option_flag(name: str, declaration: str | dict[str, object], value: Any) -> list[str]:
+    kind = declaration["type"] if isinstance(declaration, dict) else declaration
+    flag = f"--{name.replace('_', '-')}"
+    if kind in ("text", "path"):
+        if not isinstance(value, str):
+            expected = "a path" if kind == "path" else "text"
+            raise SettingsError(f'setting "{name}" must be {expected}')
+        return [flag, text] if (text := value.strip()) else []
+    if kind == "boolean":
+        if not isinstance(value, bool):
+            raise SettingsError(f'setting "{name}" must be true or false')
+        return [flag] if value else []
+    if kind == "number":
+        if isinstance(value, bool) or not isinstance(value, (int, float)) or not math.isfinite(value):
+            raise SettingsError(f'setting "{name}" must be a finite number')
+        return [flag, str(value)]
+    if kind in ("list", "paths"):
+        if not isinstance(value, list) or not all(isinstance(item, str) and "," not in item for item in value):
+            expected = "paths" if kind == "paths" else "strings"
+            raise SettingsError(f'setting "{name}" must be a list of {expected} without commas')
+        items = [item.strip() for item in value if item.strip()]
+        return [flag, ",".join(items)] if items else []
+    raise SettingsError(f'unknown option type "{kind}" for "{name}"')
+
+
+def option_flags(ctx: PluginContext, options: Mapping[str, str | dict[str, object]] | None = None) -> list[str]:
+    """The package's tool options as flags, with absent settings left to the command line's environment.
+
+    Bounds and path absoluteness are checked by the command line, not here.
     """
     flags: list[str] = []
-    for name in project.OPTIONS:
+    for name, declaration in (project.OPTIONS if options is None else options).items():
         value = ctx.get_config(name)
-        if value is None:
-            continue
-        if not isinstance(value, str):
-            raise SettingsError(f'setting "{name}" must be text')
-        if text := value.strip():
-            flags += [f"--{name.replace('_', '-')}", text]
+        if value is not None:
+            flags += _option_flag(name, declaration, value)
     return flags
 
 
 def settings_flags(ctx: PluginContext) -> list[str]:
-    """Read ``toolsets``, ``read_only``, ``tools``, ``exclude_tools`` and the tool options and return the flags that say the same.
+    """Read ``toolsets``, ``read_only``, ``tools`` and ``exclude_tools`` and return the flags that say the same.
 
     A setting that is absent gives no flag, so the command line's own defaults
     (and ``GIT_TOOLS_*`` variables) apply. A wrong type is refused rather

package/src/hermes/git_tools_hermes/tools.py

@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 import json
-from collections.abc import Callable
+from collections.abc import Callable, Mapping
 from typing import Any
 
 from .approval import PIN_ARGUMENT, parse_pin, run_arguments
@@ -76,14 +76,21 @@ def make_handler(runtime: Runtime, tool_id: str, flags: list[str]) -> Callable[.
     return handler
 
 
-def register_tools(ctx: PluginContext, runtime: Runtime, tools: list[ToolInfo], flags: list[str]) -> None:
+def register_tools(
+    ctx: PluginContext,
+    runtime: Runtime,
+    tools: list[ToolInfo],
+    flags: list[str],
+    emoji: Mapping[str, str] | None = None,
+) -> None:
     """Register each listed tool under its own ID, grouped in one Hermes toolset per package toolset."""
+    toolset_emoji = TOOLSET_EMOJI if emoji is None else emoji
     for tool in tools:
         ctx.register_tool(
             name=tool.id,
             toolset=TOOLSET_PREFIX + tool.toolset.replace("_", "-"),
             schema={"name": tool.id, "description": tool.description, "parameters": tool.input_schema},
             handler=make_handler(runtime, tool.id, flags),
-            emoji=TOOLSET_EMOJI.get(tool.toolset, ""),
+            emoji=toolset_emoji.get(tool.toolset, ""),
             description=tool.title,
         )