agent-brain-cli 10.4.0__tar.gz → 10.5.0__tar.gz

{agent_brain_cli-10.4.0 → agent_brain_cli-10.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: agent-brain-cli
-Version: 10.4.0
+Version: 10.5.0
 Summary: Agent Brain CLI - Command-line interface for managing AI agent memory and knowledge retrieval
 Home-page: https://github.com/SpillwaveSolutions/agent-brain
 License: MIT
@@ -23,6 +23,7 @@ Requires-Dist: psutil (>=6.0,<7.0)
 Requires-Dist: pydantic (>=2.10.0,<3.0.0)
 Requires-Dist: pyyaml (>=6.0.0,<7.0.0)
 Requires-Dist: rich (>=13.9.0,<14.0.0)
+Requires-Dist: tomlkit (>=0.13.0,<0.14.0)
 Project-URL: Documentation, https://github.com/SpillwaveSolutions/agent-brain/wiki
 Project-URL: Repository, https://github.com/SpillwaveSolutions/agent-brain
 Description-Content-Type: text/markdown

{agent_brain_cli-10.4.0 → agent_brain_cli-10.5.0}/agent_brain_cli/__init__.py

@@ -1,3 +1,3 @@
 """Doc-Serve CLI - Command-line interface for managing Doc-Serve server."""
 
-__version__ = "10.4.0"
+__version__ = "10.5.0"

{agent_brain_cli-10.4.0 → agent_brain_cli-10.5.0}/agent_brain_cli/commands/install_agent.py

@@ -1,6 +1,8 @@
 """Install-agent command for installing runtime-specific plugin files."""
 
 import json
+import os
+from collections.abc import Callable
 from pathlib import Path
 from typing import Any
 
@@ -10,7 +12,12 @@ from rich.panel import Panel
 
 from agent_brain_cli.runtime.claude_converter import ClaudeConverter
 from agent_brain_cli.runtime.codex_converter import CodexConverter
-from agent_brain_cli.runtime.gemini_converter import GeminiConverter
+from agent_brain_cli.runtime.mcp_registration import (
+    McpRegistrationResult,
+    register_claude_mcp,
+    register_codex_mcp,
+    register_opencode_mcp,
+)
 from agent_brain_cli.runtime.opencode_converter import OpenCodeConverter
 from agent_brain_cli.runtime.parser import parse_plugin_dir
 from agent_brain_cli.runtime.skill_runtime_converter import SkillRuntimeConverter
@@ -28,10 +35,6 @@ INSTALL_DIRS: dict[str, dict[str, str]] = {
         "project": ".opencode/plugins/agent-brain",
         "global": "~/.config/opencode/plugins/agent-brain",
     },
-    "gemini": {
-        "project": ".gemini/plugins/agent-brain",
-        "global": "~/.config/gemini/plugins/agent-brain",
-    },
     "codex": {
         "project": ".codex/skills/agent-brain",
         "global": "~/.codex/skills/agent-brain",
@@ -42,17 +45,12 @@ INSTALL_DIRS: dict[str, dict[str, str]] = {
 DIR_REQUIRED_RUNTIMES = {"skill-runtime"}
 
 ConverterType = type[
-    ClaudeConverter
-    | OpenCodeConverter
-    | GeminiConverter
-    | SkillRuntimeConverter
-    | CodexConverter
+    ClaudeConverter | OpenCodeConverter | SkillRuntimeConverter | CodexConverter
 ]
 
 CONVERTERS: dict[str, ConverterType] = {
     "claude": ClaudeConverter,
     "opencode": OpenCodeConverter,
-    "gemini": GeminiConverter,
     "skill-runtime": SkillRuntimeConverter,
     "codex": CodexConverter,
 }
@@ -94,7 +92,89 @@ def _resolve_target_dir(
     return project_root / dir_template
 
 
-RUNTIME_CHOICES = ["claude", "opencode", "gemini", "skill-runtime", "codex"]
+RUNTIME_CHOICES = ["claude", "opencode", "skill-runtime", "codex"]
+
+# Runtimes for which we can auto-register the MCP server today, mapped to the
+# writer that knows that runtime's config schema. All writers share the
+# ``(config_path, state_dir, *, backend, auth, dry_run)`` signature.
+MCP_REGISTRARS: dict[str, Callable[..., McpRegistrationResult]] = {
+    "claude": register_claude_mcp,
+    "opencode": register_opencode_mcp,
+    "codex": register_codex_mcp,
+}
+
+
+def _codex_config_path() -> Path:
+    """Return Codex's MCP config file, honoring ``$CODEX_HOME``."""
+    codex_home = os.environ.get("CODEX_HOME")
+    base = Path(codex_home) if codex_home else Path.home() / ".codex"
+    return base / "config.toml"
+
+
+def _resolve_mcp_paths(
+    agent: str, scope: str, project_root: Path | None
+) -> tuple[Path, Path]:
+    """Return (config_path, state_dir) for MCP registration.
+
+    The config file follows each runtime's own discovery rules:
+
+    * **claude** — project ``.mcp.json`` at the root, global ``~/.claude.json``.
+    * **opencode** — project ``opencode.json`` at the root (highest-precedence
+      project config), global ``~/.config/opencode/opencode.json``.
+    * **codex** — always ``$CODEX_HOME/config.toml`` (default
+      ``~/.codex/config.toml``); Codex has no project-level MCP config, so the
+      file is shared and the project's ``.agent-brain`` is pinned via the entry.
+    """
+    root = project_root if project_root is not None else Path.cwd()
+    if agent == "opencode":
+        if scope == "global":
+            config = Path.home() / ".config" / "opencode" / "opencode.json"
+            return config, Path.home() / ".agent-brain"
+        return root / "opencode.json", root / ".agent-brain"
+    if agent == "codex":
+        state_dir = (
+            Path.home() / ".agent-brain" if scope == "global" else root / ".agent-brain"
+        )
+        return _codex_config_path(), state_dir
+    # claude (and any future mcpServers-style runtime)
+    if scope == "global":
+        return Path.home() / ".claude.json", Path.home() / ".agent-brain"
+    return root / ".mcp.json", root / ".agent-brain"
+
+
+def _register_mcp(
+    agent: str,
+    scope: str,
+    project_root: Path | None,
+    mcp_auth: str,
+    mcp_backend: str,
+    dry_run: bool,
+) -> dict[str, Any]:
+    """Register the MCP server for supported runtimes; report what happened."""
+    registrar = MCP_REGISTRARS.get(agent)
+    if registrar is None:
+        return {
+            "skipped": True,
+            "reason": (
+                f"MCP auto-registration is currently supported only for "
+                f"{', '.join(sorted(MCP_REGISTRARS))}; configure "
+                f"{agent} manually (see the configuring-agent-brain skill)."
+            ),
+        }
+    config_path, state_dir = _resolve_mcp_paths(agent, scope, project_root)
+    result = registrar(
+        config_path,
+        state_dir,
+        backend=mcp_backend,
+        auth=mcp_auth,
+        dry_run=dry_run,
+    )
+    return {
+        "skipped": False,
+        "action": result.action,
+        "path": str(result.path),
+        "server_name": result.server_name,
+    }
 
 
 @click.command("install-agent")
@@ -146,6 +226,23 @@ RUNTIME_CHOICES = ["claude", "opencode", "gemini", "skill-runtime", "codex"]
     type=click.Path(exists=True, file_okay=False, resolve_path=True),
     help="Project path for --project scope (default: cwd)",
 )
+@click.option(
+    "--with-mcp",
+    is_flag=True,
+    help="Also register the agent-brain MCP server (Claude Code, OpenCode, Codex)",
+)
+@click.option(
+    "--mcp-auth",
+    type=click.Choice(["none", "oauth"]),
+    default="none",
+    help="MCP client auth mode written into the registration (default: none)",
+)
+@click.option(
+    "--mcp-backend",
+    type=click.Choice(["auto", "uds", "http"]),
+    default="auto",
+    help="How the MCP server reaches agent-brain-serve (default: auto)",
+)
 def install_agent_command(
     agent: str,
     scope: str,
@@ -154,6 +251,9 @@ def install_agent_command(
     dry_run: bool,
     json_output: bool,
     path: str | None,
+    with_mcp: bool,
+    mcp_auth: str,
+    mcp_backend: str,
 ) -> None:
     """Install Agent Brain plugin for a specific runtime.
 
@@ -164,7 +264,7 @@ def install_agent_command(
     Examples:
       agent-brain install-agent --agent claude --project
       agent-brain install-agent --agent opencode --global
-      agent-brain install-agent --agent gemini --dry-run
+      agent-brain install-agent --agent claude --dry-run
       agent-brain install-agent --agent skill-runtime --dir ./my-skills
       agent-brain install-agent --agent codex
     """
@@ -220,6 +320,12 @@ def install_agent_command(
         converter = converter_cls()
         scope_enum = Scope.GLOBAL if scope == "global" else Scope.PROJECT
 
+        mcp_summary: dict[str, Any] | None = None
+        if with_mcp:
+            mcp_summary = _register_mcp(
+                agent, scope, project_root, mcp_auth, mcp_backend, dry_run
+            )
+
         if dry_run:
             _handle_dry_run(
                 converter,
@@ -229,6 +335,7 @@ def install_agent_command(
                 agent,
                 scope,
                 json_output,
+                mcp_summary,
             )
             return
 
@@ -250,6 +357,8 @@ def install_agent_command(
                 "files_created": len(files),
                 "source_dir": str(source),
             }
+            if mcp_summary is not None:
+                result["mcp_registration"] = mcp_summary
             click.echo(json.dumps(result, indent=2))
         else:
             console.print(
@@ -263,6 +372,7 @@ def install_agent_command(
                     border_style="green",
                 )
             )
+            _print_mcp_summary(mcp_summary)
 
     except SystemExit:
         raise
@@ -276,11 +386,7 @@ def install_agent_command(
 
 def _handle_dry_run(
     converter: (
-        ClaudeConverter
-        | OpenCodeConverter
-        | GeminiConverter
-        | SkillRuntimeConverter
-        | CodexConverter
+        ClaudeConverter | OpenCodeConverter | SkillRuntimeConverter | CodexConverter
     ),
     bundle: Any,
     target: Path,
@@ -288,18 +394,26 @@ def _handle_dry_run(
     agent: str,
     scope: str,
     json_output: bool,
+    mcp_summary: dict[str, Any] | None = None,
 ) -> None:
     """Handle dry-run mode: simulate install in temp dir."""
     import tempfile
 
     with tempfile.TemporaryDirectory() as tmp:
-        tmp_target = Path(tmp)
         # For Codex, pass tmp as project_root so AGENTS.md lands in tmpdir
         if isinstance(converter, CodexConverter):
+            tmp_target = Path(tmp)
             files = converter.install(
                 bundle, tmp_target, scope_enum, project_root=Path(tmp)
             )
         else:
+            # Mirror the real target's full structure under tmp so converters
+            # that write *outside* target_dir stay inside the sandbox — e.g.
+            # OpenCode writes opencode.json at target_dir.parent.parent, which
+            # escapes to an unwritable ancestor (CI: "/") if the temp target is
+            # shallow. Rooting at tmp + the target's relative path keeps every
+            # parent the converter computes inside the throwaway dir.
+            tmp_target = Path(tmp) / target.relative_to(target.anchor)
             files = converter.install(bundle, tmp_target, scope_enum)
         # Remap paths to real target
         planned: list[Path] = []
@@ -311,19 +425,17 @@ def _handle_dry_run(
                 planned.append(f)
 
     if json_output:
-        click.echo(
-            json.dumps(
-                {
-                    "dry_run": True,
-                    "agent": agent,
-                    "scope": scope,
-                    "target_dir": str(target),
-                    "files": [str(f) for f in planned],
-                    "file_count": len(planned),
-                },
-                indent=2,
-            )
-        )
+        payload: dict[str, Any] = {
+            "dry_run": True,
+            "agent": agent,
+            "scope": scope,
+            "target_dir": str(target),
+            "files": [str(f) for f in planned],
+            "file_count": len(planned),
+        }
+        if mcp_summary is not None:
+            payload["mcp_registration"] = mcp_summary
+        click.echo(json.dumps(payload, indent=2))
     else:
         console.print(
             Panel(
@@ -338,3 +450,17 @@ def _handle_dry_run(
         )
         for f in planned:
             console.print(f"  [dim]{f}[/]")
+        _print_mcp_summary(mcp_summary)
+
+
+def _print_mcp_summary(mcp_summary: dict[str, Any] | None) -> None:
+    """Render the MCP registration outcome for human-readable output."""
+    if mcp_summary is None:
+        return
+    if mcp_summary.get("skipped"):
+        console.print(f"[yellow]MCP:[/] {mcp_summary['reason']}")
+        return
+    console.print(
+        f"[green]MCP server registered[/] ([bold]{mcp_summary['action']}[/]) "
+        f"→ {mcp_summary['path']}"
+    )

{agent_brain_cli-10.4.0 → agent_brain_cli-10.5.0}/agent_brain_cli/runtime/__init__.py

@@ -12,7 +12,6 @@ from agent_brain_cli.runtime.parser import (
 )
 from agent_brain_cli.runtime.tool_maps import (
     CLAUDE_TOOLS,
-    GEMINI_TOOLS,
     OPENCODE_TOOLS,
     map_tool_name,
     map_tools,
@@ -33,7 +32,6 @@ from agent_brain_cli.runtime.types import (
 
 __all__ = [
     "CLAUDE_TOOLS",
-    "GEMINI_TOOLS",
     "OPENCODE_TOOLS",
     "PluginAgent",
     "PluginBundle",

agent_brain_cli-10.5.0/agent_brain_cli/runtime/mcp_registration.py

@@ -0,0 +1,316 @@
+"""Register the Agent Brain MCP server into a runtime's config file.
+
+Each runtime discovers MCP servers from its own JSON config:
+
+* **Claude Code** — an ``mcpServers`` object in a project-level ``.mcp.json`` (or
+  the user-level ``~/.claude.json`` for global scope). Each entry is
+  ``{command, args, env}``.
+* **OpenCode** — an ``mcp`` object in the project-root ``opencode.json`` (or
+  ``~/.config/opencode/opencode.json`` for global scope). Each entry is
+  ``{type: "local", command: [...], enabled: true, environment: {...}}`` — the
+  executable and its args are fused into one ``command`` array.
+* **Codex** — a ``[mcp_servers.<name>]`` TOML table in
+  ``$CODEX_HOME/config.toml`` (default ``~/.codex/config.toml``). The entry
+  shape mirrors Claude's (``command`` string, ``args`` array, ``env`` table) but
+  the file is TOML, so it is merged with tomlkit to preserve the user's other
+  servers, top-level keys, and comments.
+
+These writers deliberately do NOT shell out to a runtime CLI (``claude mcp add``
+etc.): the file-based path is dependency-free, deterministic, dry-run friendly,
+and matches the file-writing pattern the rest of ``install-agent`` already uses.
+"""
+
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+import tomlkit
+from tomlkit.exceptions import TOMLKitError
+
+MCP_SERVER_NAME = "agent-brain"
+MCP_COMMAND = "agent-brain-mcp"
+OPENCODE_SCHEMA_URL = "https://opencode.ai/config.json"
+
+
+def _build_env(state_dir: Path, auth: str) -> dict[str, str]:
+    """Build the environment block shared by every runtime's entry.
+
+    The state dir is resolved to an absolute path — MCP clients launch the
+    server from an unknown cwd, so a relative path would break discovery.
+    ``oauth`` opts the client into the OAuth dance via ``AGENT_BRAIN_MCP_AUTH``.
+    """
+    env: dict[str, str] = {
+        "AGENT_BRAIN_STATE_DIR": str(state_dir.expanduser().resolve())
+    }
+    if auth == "oauth":
+        env["AGENT_BRAIN_MCP_AUTH"] = "oauth"
+    return env
+
+
+def build_mcp_server_entry(
+    state_dir: Path,
+    backend: str = "auto",
+    auth: str = "none",
+) -> dict[str, Any]:
+    """Build the Claude Code ``mcpServers`` entry for the Agent Brain MCP server.
+
+    Args:
+        state_dir: The ``.agent-brain`` state directory the MCP server should use.
+        backend: How the MCP server reaches ``agent-brain-serve``
+            (``auto`` | ``uds`` | ``http``).
+        auth: ``none`` (default) or ``oauth``.
+
+    Returns:
+        A dict suitable for ``mcpServers[<name>]``.
+    """
+    return {
+        "command": MCP_COMMAND,
+        "args": ["--backend", backend],
+        "env": _build_env(state_dir, auth),
+    }
+
+
+def build_opencode_mcp_entry(
+    state_dir: Path,
+    backend: str = "auto",
+    auth: str = "none",
+) -> dict[str, Any]:
+    """Build the OpenCode ``mcp`` entry for the Agent Brain MCP server.
+
+    OpenCode fuses the executable and its args into one ``command`` array, uses
+    ``environment`` (not ``env``), and marks local servers with
+    ``type: "local"`` and ``enabled: true``.
+
+    Args:
+        state_dir: The ``.agent-brain`` state directory the MCP server should use.
+        backend: How the MCP server reaches ``agent-brain-serve``
+            (``auto`` | ``uds`` | ``http``).
+        auth: ``none`` (default) or ``oauth``.
+
+    Returns:
+        A dict suitable for ``mcp[<name>]`` in ``opencode.json``.
+    """
+    return {
+        "type": "local",
+        "command": [MCP_COMMAND, "--backend", backend],
+        "enabled": True,
+        "environment": _build_env(state_dir, auth),
+    }
+
+
+@dataclass
+class McpRegistrationResult:
+    """Outcome of an MCP registration attempt."""
+
+    path: Path
+    action: str  # "created" | "updated" | "unchanged"
+    server_name: str
+    entry: dict[str, Any]
+
+
+def _merge_json_mcp(
+    config_path: Path,
+    *,
+    servers_key: str,
+    entry: dict[str, Any],
+    top_level_defaults: dict[str, Any] | None = None,
+    dry_run: bool = False,
+) -> McpRegistrationResult:
+    """Merge an MCP entry into a JSON config under ``servers_key``.
+
+    Shared skeleton for every JSON-config runtime: read (fail closed on corrupt
+    JSON), compare the existing ``agent-brain`` entry, classify the action, and
+    write only when something changed. Other servers and top-level keys are
+    preserved.
+
+    Args:
+        config_path: Path to the runtime's JSON config file.
+        servers_key: Top-level key holding the server map
+            (``mcpServers`` for Claude, ``mcp`` for OpenCode).
+        entry: The fully-built entry to store under ``[servers_key][name]``.
+        top_level_defaults: Keys applied via ``setdefault`` when writing
+            (e.g. OpenCode's ``$schema``); only touched on create/update.
+        dry_run: When True, compute the action but write nothing.
+
+    Returns:
+        An :class:`McpRegistrationResult` describing what (would have) changed.
+
+    Raises:
+        ValueError: If an existing config file is not valid JSON.
+    """
+    data: dict[str, Any]
+    file_existed = config_path.exists()
+    if file_existed:
+        try:
+            data = json.loads(config_path.read_text())
+        except json.JSONDecodeError as exc:
+            raise ValueError(
+                f"Existing {config_path.name} is not valid JSON: {exc}. "
+                "Fix or remove it, then re-run."
+            ) from exc
+    else:
+        data = {}
+
+    servers = data.setdefault(servers_key, {})
+    existing = servers.get(MCP_SERVER_NAME)
+
+    if existing == entry:
+        action = "unchanged"
+    elif not file_existed:
+        action = "created"
+    else:
+        action = "updated"
+
+    if action != "unchanged" and not dry_run:
+        for key, value in (top_level_defaults or {}).items():
+            data.setdefault(key, value)
+        servers[MCP_SERVER_NAME] = entry
+        config_path.parent.mkdir(parents=True, exist_ok=True)
+        config_path.write_text(json.dumps(data, indent=2) + "\n")
+
+    return McpRegistrationResult(
+        path=config_path,
+        action=action,
+        server_name=MCP_SERVER_NAME,
+        entry=entry,
+    )
+
+
+def register_claude_mcp(
+    config_path: Path,
+    state_dir: Path,
+    *,
+    backend: str = "auto",
+    auth: str = "none",
+    dry_run: bool = False,
+) -> McpRegistrationResult:
+    """Merge the Agent Brain MCP entry into a Claude Code config file.
+
+    Args:
+        config_path: Path to ``.mcp.json`` (project) or ``~/.claude.json`` (global).
+        state_dir: The ``.agent-brain`` state directory for the server.
+        backend: MCP backend selector passed to the server.
+        auth: ``none`` or ``oauth``.
+        dry_run: When True, compute the action but write nothing.
+
+    Returns:
+        An :class:`McpRegistrationResult` describing what (would have) changed.
+
+    Raises:
+        ValueError: If an existing config file is not valid JSON.
+    """
+    return _merge_json_mcp(
+        config_path,
+        servers_key="mcpServers",
+        entry=build_mcp_server_entry(state_dir, backend=backend, auth=auth),
+        dry_run=dry_run,
+    )
+
+
+def register_opencode_mcp(
+    config_path: Path,
+    state_dir: Path,
+    *,
+    backend: str = "auto",
+    auth: str = "none",
+    dry_run: bool = False,
+) -> McpRegistrationResult:
+    """Merge the Agent Brain MCP entry into an OpenCode config file.
+
+    Args:
+        config_path: Path to the project-root ``opencode.json`` (project) or
+            ``~/.config/opencode/opencode.json`` (global).
+        state_dir: The ``.agent-brain`` state directory for the server.
+        backend: MCP backend selector passed to the server.
+        auth: ``none`` or ``oauth``.
+        dry_run: When True, compute the action but write nothing.
+
+    Returns:
+        An :class:`McpRegistrationResult` describing what (would have) changed.
+
+    Raises:
+        ValueError: If an existing config file is not valid JSON.
+    """
+    return _merge_json_mcp(
+        config_path,
+        servers_key="mcp",
+        entry=build_opencode_mcp_entry(state_dir, backend=backend, auth=auth),
+        top_level_defaults={"$schema": OPENCODE_SCHEMA_URL},
+        dry_run=dry_run,
+    )
+
+
+def register_codex_mcp(
+    config_path: Path,
+    state_dir: Path,
+    *,
+    backend: str = "auto",
+    auth: str = "none",
+    dry_run: bool = False,
+) -> McpRegistrationResult:
+    """Merge the Agent Brain MCP entry into a Codex ``config.toml`` file.
+
+    Codex stores MCP servers as ``[mcp_servers.<name>]`` TOML tables. The entry
+    fields match Claude's (``command``/``args``/``env``), so the value is built
+    with :func:`build_mcp_server_entry`; only the on-disk format differs. tomlkit
+    parses and re-emits the document so the user's other servers, top-level keys,
+    and comments are preserved.
+
+    Args:
+        config_path: Path to ``$CODEX_HOME/config.toml`` (default
+            ``~/.codex/config.toml``). Codex has no project-level MCP config, so
+            both install scopes target this user-level file.
+        state_dir: The ``.agent-brain`` state directory for the server.
+        backend: MCP backend selector passed to the server.
+        auth: ``none`` or ``oauth``.
+        dry_run: When True, compute the action but write nothing.
+
+    Returns:
+        An :class:`McpRegistrationResult` describing what (would have) changed.
+
+    Raises:
+        ValueError: If an existing config file is not valid TOML.
+    """
+    entry = build_mcp_server_entry(state_dir, backend=backend, auth=auth)
+
+    file_existed = config_path.exists()
+    if file_existed:
+        try:
+            doc = tomlkit.parse(config_path.read_text())
+        except TOMLKitError as exc:
+            raise ValueError(
+                f"Existing {config_path.name} is not valid TOML: {exc}. "
+                "Fix or remove it, then re-run."
+            ) from exc
+    else:
+        doc = tomlkit.document()
+
+    servers = doc.get("mcp_servers")
+    if servers is None:
+        servers = tomlkit.table()
+        doc["mcp_servers"] = servers
+
+    existing = servers.get(MCP_SERVER_NAME)
+    existing_plain = existing.unwrap() if existing is not None else None
+
+    if existing_plain == entry:
+        action = "unchanged"
+    elif not file_existed:
+        action = "created"
+    else:
+        action = "updated"
+
+    if action != "unchanged" and not dry_run:
+        servers[MCP_SERVER_NAME] = entry
+        config_path.parent.mkdir(parents=True, exist_ok=True)
+        config_path.write_text(tomlkit.dumps(doc))
+
+    return McpRegistrationResult(
+        path=config_path,
+        action=action,
+        server_name=MCP_SERVER_NAME,
+        entry=entry,
+    )

{agent_brain_cli-10.4.0 → agent_brain_cli-10.5.0}/agent_brain_cli/runtime/tool_maps.py

@@ -36,25 +36,10 @@ OPENCODE_TOOLS: dict[str, str] = {
     "TodoWrite": "todowrite",
 }
 
-# Gemini CLI — different tool name convention
-GEMINI_TOOLS: dict[str, str] = {
-    "Bash": "run_shell_command",
-    "Read": "read_file",
-    "Write": "write_file",
-    "Edit": "replace",
-    "Glob": "glob",
-    "Grep": "grep",
-    "Agent": "agent",
-    "WebFetch": "web_fetch",
-    "WebSearch": "web_search",
-    "NotebookEdit": "notebook_edit",
-}
-
 # Mapping from RuntimeType to tool map
 TOOL_MAPS: dict[str, dict[str, str]] = {
     "claude": CLAUDE_TOOLS,
     "opencode": OPENCODE_TOOLS,
-    "gemini": GEMINI_TOOLS,
 }
 
 
@@ -67,7 +52,7 @@ def map_tool_name(tool: str, runtime: str) -> str:
 
     Args:
         tool: Canonical tool name (e.g., "Bash", "Write(.agent-brain/**)").
-        runtime: Target runtime ("claude", "opencode", "gemini").
+        runtime: Target runtime ("claude", "opencode").
 
     Returns:
         Mapped tool name, or the lowercased base name if no mapping exists.

{agent_brain_cli-10.4.0 → agent_brain_cli-10.5.0}/agent_brain_cli/runtime/types.py

@@ -9,7 +9,6 @@ class RuntimeType(str, Enum):
 
     CLAUDE = "claude"
     OPENCODE = "opencode"
-    GEMINI = "gemini"
     SKILL_RUNTIME = "skill-runtime"
     CODEX = "codex"
 

{agent_brain_cli-10.4.0 → agent_brain_cli-10.5.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "agent-brain-cli"
-version = "10.4.0"
+version = "10.5.0"
 description = "Agent Brain CLI - Command-line interface for managing AI agent memory and knowledge retrieval"
 authors = ["Spillwave Solutions"]
 readme = "README.md"
@@ -26,6 +26,7 @@ click = "^8.1.0"
 httpx = "^0.28.0"
 rich = "^13.9.0"
 pyyaml = "^6.0.0"
+tomlkit = "^0.13.0"
 pydantic = "^2.10.0"
 agent-brain-rag = "^10.4.0"
 agent-brain-uds = "^10.3.0"

agent_brain_cli-10.4.0/agent_brain_cli/runtime/gemini_converter.py

@@ -1,119 +0,0 @@
-"""Gemini CLI runtime converter.
-
-Gemini uses different tool names and doesn't support some fields:
-- Tool names: Read→read_file, Write→write_file, Edit→replace, Bash→run_shell_command
-- No `color` field support
-- Skills use `tools` list with Gemini-mapped names
-"""
-
-import logging
-from pathlib import Path
-
-import yaml
-
-from agent_brain_cli.runtime.tool_maps import map_tools
-from agent_brain_cli.runtime.types import (
-    PluginAgent,
-    PluginBundle,
-    PluginCommand,
-    PluginSkill,
-    RuntimeType,
-    Scope,
-)
-
-logger = logging.getLogger(__name__)
-
-LEGACY_PATH = ".claude/agent-brain"
-NEW_PATH = ".agent-brain"
-
-
-def _replace_paths(text: str) -> str:
-    return text.replace(LEGACY_PATH, NEW_PATH)
-
-
-def _rebuild_file(frontmatter: dict, body: str) -> str:  # type: ignore[type-arg]
-    yaml_str = yaml.dump(frontmatter, default_flow_style=False, sort_keys=False)
-    return f"---\n{yaml_str}---\n{body}\n"
-
-
-class GeminiConverter:
-    """Converter for Gemini CLI runtime."""
-
-    @property
-    def runtime_type(self) -> RuntimeType:
-        return RuntimeType.GEMINI
-
-    def convert_command(self, command: PluginCommand) -> str:
-        fm: dict[str, object] = {
-            "name": command.name,
-            "description": command.description,
-            "parameters": [
-                {
-                    "name": p.name,
-                    "description": p.description,
-                    "required": p.required,
-                    **({"default": p.default} if p.default else {}),
-                }
-                for p in command.parameters
-            ],
-            "skills": command.skills,
-        }
-        return _rebuild_file(fm, _replace_paths(command.body))
-
-    def convert_agent(self, agent: PluginAgent) -> str:
-        fm: dict[str, object] = {
-            "name": agent.name,
-            "description": agent.description,
-            "triggers": [
-                {"pattern": t.pattern, "type": t.type} for t in agent.triggers
-            ],
-            "skills": agent.skills,
-        }
-        return _rebuild_file(fm, _replace_paths(agent.body))
-
-    def convert_skill(self, skill: PluginSkill) -> str:
-        """Convert skill with Gemini-mapped tool names, no color field."""
-        mapped_tools = map_tools(skill.allowed_tools, "gemini")
-        # Filter out unsupported metadata fields
-        clean_metadata = {k: v for k, v in skill.metadata.items() if k != "color"}
-        fm: dict[str, object] = {
-            "name": skill.name,
-            "description": skill.description,
-            "license": skill.license,
-            "allowed-tools": mapped_tools,
-            "metadata": clean_metadata,
-        }
-        return _rebuild_file(fm, _replace_paths(skill.body))
-
-    def install(
-        self,
-        bundle: PluginBundle,
-        target_dir: Path,
-        scope: Scope,
-    ) -> list[Path]:
-        """Install Gemini CLI plugin files."""
-        created: list[Path] = []
-
-        cmds_dir = target_dir / "commands"
-        cmds_dir.mkdir(parents=True, exist_ok=True)
-        for cmd in bundle.commands:
-            out = cmds_dir / f"{cmd.name}.md"
-            out.write_text(self.convert_command(cmd), encoding="utf-8")
-            created.append(out)
-
-        agents_dir = target_dir / "agents"
-        agents_dir.mkdir(parents=True, exist_ok=True)
-        for agent in bundle.agents:
-            out = agents_dir / f"{agent.name}.md"
-            out.write_text(self.convert_agent(agent), encoding="utf-8")
-            created.append(out)
-
-        skills_dir = target_dir / "skills"
-        for skill in bundle.skills:
-            skill_out = skills_dir / skill.name
-            skill_out.mkdir(parents=True, exist_ok=True)
-            skill_file = skill_out / "SKILL.md"
-            skill_file.write_text(self.convert_skill(skill), encoding="utf-8")
-            created.append(skill_file)
-
-        return created