bingo-light 2.1.1 → 2.1.2

package/bingo_core/dep_npm.py

@@ -0,0 +1,113 @@
+"""
+bingo_core.dep_npm — npm/pnpm/yarn backend for dependency patching.
+
+Detects npm projects, fetches original packages from registry,
+resolves install paths in node_modules/.
+
+Python 3.8+ stdlib only.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import tarfile
+from typing import List, Optional
+from urllib.request import urlopen
+
+from bingo_core.dep import DepBackend
+
+
+class NpmBackend(DepBackend):
+    """Backend for npm/pnpm/yarn packages."""
+
+    name = "npm"
+
+    def detect(self, cwd: str) -> bool:
+        """Detect npm project by presence of package.json or node_modules/."""
+        return (
+            os.path.isfile(os.path.join(cwd, "package.json"))
+            or os.path.isdir(os.path.join(cwd, "node_modules"))
+        )
+
+    def get_installed_version(self, package: str, cwd: str) -> Optional[str]:
+        """Get installed version from node_modules/<package>/package.json."""
+        pkg_json = os.path.join(cwd, "node_modules", package, "package.json")
+        if not os.path.isfile(pkg_json):
+            # Try scoped package
+            if "/" in package:
+                pkg_json = os.path.join(cwd, "node_modules", package, "package.json")
+            if not os.path.isfile(pkg_json):
+                return None
+        try:
+            with open(pkg_json) as f:
+                data = json.load(f)
+            return data.get("version")
+        except (json.JSONDecodeError, OSError):
+            return None
+
+    def get_install_path(self, package: str, cwd: str) -> Optional[str]:
+        """Get the filesystem path of the installed package."""
+        path = os.path.join(cwd, "node_modules", package)
+        if os.path.isdir(path):
+            return path
+        return None
+
+    def fetch_original(self, package: str, version: str, dest: str) -> bool:
+        """Download original package from npm registry and extract to dest.
+
+        Uses the npm registry API to get the tarball URL, downloads and
+        extracts it. The tarball contains a 'package/' prefix which we strip.
+        """
+        try:
+            # Fetch package metadata from registry
+            # Handle scoped packages: @scope/name -> @scope%2Fname
+            encoded = package.replace("/", "%2F")
+            url = f"https://registry.npmjs.org/{encoded}/{version}"
+            with urlopen(url, timeout=30) as resp:
+                meta = json.loads(resp.read().decode())
+
+            tarball_url = meta.get("dist", {}).get("tarball")
+            if not tarball_url:
+                return False
+
+            # Download tarball
+            tmptar = os.path.join(dest, "_pkg.tgz")
+            with urlopen(tarball_url, timeout=60) as resp:
+                with open(tmptar, "wb") as f:
+                    f.write(resp.read())
+
+            # Extract (npm tarballs have a 'package/' prefix)
+            with tarfile.open(tmptar, "r:gz") as tar:
+                for member in tar.getmembers():
+                    # Strip the 'package/' prefix
+                    if member.name.startswith("package/"):
+                        member.name = member.name[len("package/"):]
+                    elif member.name == "package":
+                        continue
+                    # Security: skip absolute paths and ..
+                    if member.name.startswith("/") or ".." in member.name:
+                        continue
+                    tar.extract(member, dest, filter="data" if hasattr(tarfile, 'data_filter') else None)
+
+            os.remove(tmptar)
+            return True
+
+        except Exception:
+            return False
+
+    def list_files(self, package: str, cwd: str) -> List[str]:
+        """List all files in the installed package."""
+        install_path = self.get_install_path(package, cwd)
+        if not install_path:
+            return []
+        result = []
+        for root, _dirs, files in os.walk(install_path):
+            for f in files:
+                full = os.path.join(root, f)
+                rel = os.path.relpath(full, install_path)
+                result.append(rel)
+        return sorted(result)
+
+    def install_hook_command(self) -> str:
+        return "bingo-light dep apply"

package/bingo_core/dep_pip.py

@@ -0,0 +1,178 @@
+"""
+bingo_core.dep_pip — pip/pipx backend for dependency patching.
+
+Detects Python projects, fetches original packages from PyPI,
+resolves install paths in site-packages/.
+
+Python 3.8+ stdlib only.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import site
+import zipfile
+from typing import List, Optional
+from urllib.request import urlopen
+
+from bingo_core.dep import DepBackend
+
+
+class PipBackend(DepBackend):
+    """Backend for pip/pipx Python packages."""
+
+    name = "pip"
+
+    def detect(self, cwd: str) -> bool:
+        """Detect Python project by presence of requirements.txt, pyproject.toml, or venv."""
+        indicators = [
+            "requirements.txt",
+            "pyproject.toml",
+            "setup.py",
+            "setup.cfg",
+            "Pipfile",
+            ".venv",
+            "venv",
+        ]
+        return any(
+            os.path.exists(os.path.join(cwd, f)) for f in indicators
+        )
+
+    def _find_site_packages(self, cwd: str) -> List[str]:
+        """Find site-packages directories, preferring project venvs."""
+        dirs = []
+
+        # Check for project venv
+        for venv_name in (".venv", "venv"):
+            venv_path = os.path.join(cwd, venv_name)
+            if os.path.isdir(venv_path):
+                # Find site-packages inside venv
+                for root, dirnames, _files in os.walk(venv_path):
+                    if "site-packages" in dirnames:
+                        dirs.append(os.path.join(root, "site-packages"))
+                        break
+
+        # System/user site-packages
+        dirs.extend(site.getsitepackages())
+        user_site = site.getusersitepackages()
+        if isinstance(user_site, str):
+            dirs.append(user_site)
+
+        return [d for d in dirs if os.path.isdir(d)]
+
+    def get_installed_version(self, package: str, cwd: str) -> Optional[str]:
+        """Get installed version via importlib.metadata or dist-info."""
+        # Normalize package name
+        normalized = package.replace("-", "_").lower()
+
+        for sp_dir in self._find_site_packages(cwd):
+            # Check dist-info directories
+            for entry in os.listdir(sp_dir):
+                if entry.endswith(".dist-info"):
+                    dist_name = entry.rsplit("-", 1)[0].replace("-", "_").lower()
+                    if dist_name == normalized:
+                        metadata_path = os.path.join(sp_dir, entry, "METADATA")
+                        if os.path.isfile(metadata_path):
+                            with open(metadata_path) as f:
+                                for line in f:
+                                    if line.startswith("Version:"):
+                                        return line.split(":", 1)[1].strip()
+        return None
+
+    def get_install_path(self, package: str, cwd: str) -> Optional[str]:
+        """Get the filesystem path of the installed package."""
+        normalized = package.replace("-", "_").lower()
+
+        for sp_dir in self._find_site_packages(cwd):
+            # Direct package directory
+            for entry in os.listdir(sp_dir):
+                if entry.replace("-", "_").lower() == normalized:
+                    full = os.path.join(sp_dir, entry)
+                    if os.path.isdir(full):
+                        return full
+        return None
+
+    def fetch_original(self, package: str, version: str, dest: str) -> bool:
+        """Download original package from PyPI and extract to dest.
+
+        Prefers wheel (.whl) for consistency, falls back to sdist.
+        """
+        try:
+            # Fetch package metadata from PyPI JSON API
+            url = f"https://pypi.org/pypi/{package}/{version}/json"
+            with urlopen(url, timeout=30) as resp:
+                meta = json.loads(resp.read().decode())
+
+            # Find wheel URL (prefer), then sdist
+            download_url = None
+            is_wheel = False
+            for file_info in meta.get("urls", []):
+                if file_info.get("packagetype") == "bdist_wheel":
+                    download_url = file_info["url"]
+                    is_wheel = True
+                    break
+            if not download_url:
+                for file_info in meta.get("urls", []):
+                    if file_info.get("packagetype") == "sdist":
+                        download_url = file_info["url"]
+                        break
+
+            if not download_url:
+                return False
+
+            # Download
+            tmp_file = os.path.join(dest, "_pkg.tmp")
+            with urlopen(download_url, timeout=60) as resp:
+                with open(tmp_file, "wb") as f:
+                    f.write(resp.read())
+
+            if is_wheel:
+                # Wheel is a zip file
+                normalized = package.replace("-", "_").lower()
+                with zipfile.ZipFile(tmp_file) as zf:
+                    for member in zf.namelist():
+                        # Extract only the package directory
+                        parts = member.split("/")
+                        if parts[0].replace("-", "_").lower() == normalized:
+                            zf.extract(member, dest)
+                        elif parts[0].endswith(".dist-info") or parts[0].endswith(".data"):
+                            continue  # Skip metadata
+                        else:
+                            # Single-file module
+                            if member.endswith(".py"):
+                                zf.extract(member, dest)
+                # Move extracted package dir to dest root
+                extracted = os.path.join(dest, normalized)
+                if os.path.isdir(extracted):
+                    # Already in right place
+                    pass
+            else:
+                # Sdist: tar.gz — extract and find the package dir
+                import tarfile
+                with tarfile.open(tmp_file, "r:gz") as tar:
+                    tar.extractall(dest)
+                # Find the actual package inside the extracted tree
+                # Sdist typically has project-version/ at top level
+
+            os.remove(tmp_file)
+            return True
+
+        except Exception:
+            return False
+
+    def list_files(self, package: str, cwd: str) -> List[str]:
+        """List all files in the installed package."""
+        install_path = self.get_install_path(package, cwd)
+        if not install_path:
+            return []
+        result = []
+        for root, _dirs, files in os.walk(install_path):
+            for f in files:
+                full = os.path.join(root, f)
+                rel = os.path.relpath(full, install_path)
+                result.append(rel)
+        return sorted(result)
+
+    def install_hook_command(self) -> str:
+        return "bingo-light dep apply"

package/bingo_core/setup.py

@@ -151,39 +151,85 @@ def _get_tools() -> List[AITool]:
 # ─── MCP Server Path Detection ──────────────────────────────────────────────
 
 
+def _find_python_for_mcp() -> str:
+    """Find the correct python3 for running the MCP server.
+
+    When installed via pipx, system python3 can't import bingo_core.
+    We need to use the same python that runs bingo-light itself.
+    """
+    # Use the same python interpreter that's running this code
+    return sys.executable
+
+
 def find_mcp_server() -> Tuple[str, List[str]]:
     """Find the MCP server command and args.
 
-    Returns (command, args) tuple. Tries:
-    1. Installed `bingo-light-mcp` on PATH
-    2. mcp-server.py next to the running script
-    3. mcp-server.py next to bingo_core package
+    Returns (command, args) tuple.
     """
-    # 1. Installed binary on PATH
+    python = _find_python_for_mcp()
+
+    # 1. Installed binary on PATH (npm installs bingo-light-mcp)
     for name in ("bingo-light-mcp", "mcp-server.py"):
         mcp_bin = shutil.which(name)
         if mcp_bin:
-            return ("python3", [mcp_bin])
+            return (python, [mcp_bin])
 
     # 2. Relative to running script
     script_dir = os.path.dirname(os.path.abspath(sys.argv[0]))
     candidate = os.path.join(script_dir, "mcp-server.py")
     if os.path.isfile(candidate):
-        return ("python3", [candidate])
+        return (python, [candidate])
 
     # 3. Relative to bingo_core package
     pkg_dir = os.path.dirname(os.path.abspath(__file__))
     candidate = os.path.join(os.path.dirname(pkg_dir), "mcp-server.py")
     if os.path.isfile(candidate):
-        return ("python3", [candidate])
+        return (python, [candidate])
 
     # Fallback
-    return ("python3", ["bingo-light-mcp"])
+    return (python, ["bingo-light-mcp"])
 
 
 # ─── Config Writer ───────────────────────────────────────────────────────────
 
 
+def _configure_claude_code_via_cli(
+    command: str,
+    args: List[str],
+    server_name: str = "bingo-light",
+) -> Optional[Dict[str, Any]]:
+    """Try to configure Claude Code using `claude mcp add` CLI.
+
+    Returns result dict if successful, None if claude CLI not available.
+    """
+    claude_bin = shutil.which("claude")
+    if not claude_bin:
+        return None
+
+    import subprocess
+    # Remove existing entry first (ignore errors if not present)
+    subprocess.run(
+        [claude_bin, "mcp", "remove", server_name],
+        capture_output=True, text=True,
+    )
+    # Add new entry: claude mcp add <name> -- <command> <args...>
+    cmd = [claude_bin, "mcp", "add", server_name, "--", command] + args
+    result = subprocess.run(cmd, capture_output=True, text=True)
+    if result.returncode == 0:
+        return {
+            "ok": True,
+            "tool": "claude-code",
+            "name": "Claude Code",
+            "config_path": "~/.claude.json (via claude mcp add)",
+            "action": "created",
+        }
+    return {
+        "ok": False,
+        "tool": "claude-code",
+        "error": result.stderr.strip() or "claude mcp add failed",
+    }
+
+
 def write_mcp_config(
     tool: AITool,
     command: str,
@@ -194,6 +240,13 @@ def write_mcp_config(
 
     Returns dict with ok, tool, config_path, action (created|updated|error).
     """
+    # Claude Code: prefer `claude mcp add` CLI (writes to correct location)
+    if tool.id == "claude-code":
+        cli_result = _configure_claude_code_via_cli(command, args, server_name)
+        if cli_result:
+            return cli_result
+        # Fall through to JSON file method if claude CLI not available
+
     config_path = tool.expand_path()
     config_dir = os.path.dirname(config_path)
 
@@ -594,17 +647,20 @@ def _get_skill_targets() -> List[SkillTarget]:
 
 def find_skill_file() -> Optional[str]:
     """Find the bingo.md skill file in common locations."""
-    candidates = []
-
-    script_dir = os.path.dirname(os.path.abspath(sys.argv[0]))
-    candidates.append(os.path.join(script_dir, ".claude", "commands", "bingo.md"))
-
     pkg_dir = os.path.dirname(os.path.abspath(__file__))
+    script_dir = os.path.dirname(os.path.abspath(sys.argv[0]))
     repo_dir = os.path.dirname(pkg_dir)
-    candidates.append(os.path.join(repo_dir, ".claude", "commands", "bingo.md"))
 
-    # npm package layout
-    candidates.append(os.path.join(script_dir, "..", ".claude", "commands", "bingo.md"))
+    candidates = [
+        # Bundled inside bingo_core/ (pip/npm installs)
+        os.path.join(pkg_dir, "_skill.md"),
+        # Repo layout
+        os.path.join(repo_dir, ".claude", "commands", "bingo.md"),
+        # Script-relative (install.sh)
+        os.path.join(script_dir, ".claude", "commands", "bingo.md"),
+        # npm package layout
+        os.path.join(script_dir, "..", ".claude", "commands", "bingo.md"),
+    ]
 
     for c in candidates:
         if os.path.isfile(c):

package/completions/bingo-light.bash

@@ -10,7 +10,7 @@ _bingo_light() {
     local cur prev words cword
     _init_completion || return
 
-    local -r toplevel_commands="init setup patch sync status doctor auto-sync log undo diff version help conflict-analyze conflict-resolve config history test workspace smart-sync session"
+    local -r toplevel_commands="init setup patch dep sync status doctor auto-sync log undo diff version help conflict-analyze conflict-resolve config history test workspace smart-sync session"
     local -r toplevel_aliases="p s st d ws"
     local -r all_toplevel="${toplevel_commands} ${toplevel_aliases}"
 
@@ -36,6 +36,9 @@ _bingo_light() {
             diff|d)
                 cmd="diff"
                 ;;
+            dep)
+                cmd="dep"
+                ;;
             init|setup|doctor|auto-sync|log|undo|version|help|conflict-analyze|conflict-resolve|config|history|test|workspace|ws|smart-sync|session)
                 cmd="${words[i]}"
                 ;;
@@ -91,6 +94,16 @@ _bingo_light() {
         return
     fi
 
+    # Inside "dep" -- complete subcommands
+    if [[ "$cmd" == "dep" ]]; then
+        if [[ -z "$subcmd" ]]; then
+            COMPREPLY=( $(compgen -W "patch apply sync status list drop" -- "$cur") )
+        else
+            COMPREPLY=( $(compgen -W "--help -h" -- "$cur") )
+        fi
+        return
+    fi
+
     # Inside "workspace" (or alias "ws") -- complete subcommands
     if [[ "$cmd" == "workspace" || "$cmd" == "ws" ]]; then
         if [[ -z "$subcmd" ]]; then

package/completions/bingo-light.fish

@@ -68,6 +68,7 @@ complete -c bingo-light -f
 complete -c bingo-light -n __bingo_light_needs_command -a init    -d 'Initialize a new bingo-light project'
 complete -c bingo-light -n __bingo_light_needs_command -a setup   -d 'Configure MCP for AI tools (interactive)'
 complete -c bingo-light -n __bingo_light_needs_command -a patch   -d 'Manage patches'
+complete -c bingo-light -n __bingo_light_needs_command -a dep     -d 'Patch npm/pip dependencies'
 complete -c bingo-light -n __bingo_light_needs_command -a sync    -d 'Synchronize changes with upstream'
 complete -c bingo-light -n __bingo_light_needs_command -a status  -d 'Show current status'
 complete -c bingo-light -n __bingo_light_needs_command -a doctor  -d 'Diagnose and fix common problems'
@@ -124,7 +125,7 @@ complete -c bingo-light -n '__bingo_light_using_command version'   -s h -l help
 complete -c bingo-light -n '__bingo_light_using_command conflict-resolve' -s h -l help -d 'Show help'
 
 # ---- help: complete with command names ----
-complete -c bingo-light -n '__bingo_light_using_command help' -a 'init setup patch sync status doctor auto-sync log undo diff version conflict-analyze conflict-resolve config history test workspace smart-sync session' -d 'Command'
+complete -c bingo-light -n '__bingo_light_using_command help' -a 'init setup patch dep sync status doctor auto-sync log undo diff version conflict-analyze conflict-resolve config history test workspace smart-sync session' -d 'Command'
 
 # ---- patch subcommands (also alias "p") ----
 complete -c bingo-light -n __bingo_light_patch_needs_subcommand -a new     -d 'Create a new patch'
@@ -163,6 +164,29 @@ complete -c bingo-light -n '__bingo_light_patch_using_subcommand reorder'
 complete -c bingo-light -n '__bingo_light_patch_using_subcommand squash'            -s h -l help -d 'Show help'
 complete -c bingo-light -n '__bingo_light_patch_using_subcommand meta'              -s h -l help -d 'Show help'
 
+# ---- dep subcommands ----
+
+function __bingo_light_dep_needs_subcommand
+    set -l cmd (commandline -opc)
+    if test (count $cmd) -lt 2
+        return 1
+    end
+    if test "$cmd[2]" != dep
+        return 1
+    end
+    if test (count $cmd) -eq 2
+        return 0
+    end
+    return 1
+end
+
+complete -c bingo-light -n __bingo_light_dep_needs_subcommand -a patch  -d 'Patch a modified dependency'
+complete -c bingo-light -n __bingo_light_dep_needs_subcommand -a apply  -d 'Re-apply patches after install'
+complete -c bingo-light -n __bingo_light_dep_needs_subcommand -a sync   -d 'Re-apply after update, detect conflicts'
+complete -c bingo-light -n __bingo_light_dep_needs_subcommand -a status -d 'Show patch health'
+complete -c bingo-light -n __bingo_light_dep_needs_subcommand -a list   -d 'List all dependency patches'
+complete -c bingo-light -n __bingo_light_dep_needs_subcommand -a drop   -d 'Remove a dependency patch'
+
 # ---- workspace subcommands (also alias "ws") ----
 
 # Returns true when we are inside "workspace" (or "ws") and need a workspace subcommand.

package/completions/bingo-light.zsh

@@ -11,6 +11,7 @@ _bingo-light() {
     local -a toplevel_commands=(
         'init:Initialize a new bingo-light project'
         'patch:Manage patches'
+        'dep:Patch npm/pip dependencies'
         'setup:Configure MCP for AI tools (interactive)'
         'sync:Synchronize changes with upstream'
         'status:Show current status'
@@ -136,6 +137,25 @@ _bingo-light() {
                 diff|d)
                     _arguments $help_flag
                     ;;
+                dep)
+                    local -a dep_subcommands=(
+                        'patch:Patch a modified dependency'
+                        'apply:Re-apply patches after install'
+                        'sync:Re-apply after update, detect conflicts'
+                        'status:Show patch health'
+                        'list:List all dependency patches'
+                        'drop:Remove a dependency patch'
+                    )
+                    _arguments -C \
+                        '(- *)'{-h,--help}'[Show help]' \
+                        '1:subcommand:->dep_subcmd' && return
+
+                    case $state in
+                        dep_subcmd)
+                            _describe -t subcommands 'dep subcommand' dep_subcommands
+                            ;;
+                    esac
+                    ;;
                 workspace|ws)
                     local -a ws_subcommands=(
                         'init:Initialize workspace'

package/mcp-server.py

@@ -469,6 +469,86 @@ TOOLS = [
             "required": ["cwd"]
         }
     },
+    # ── Dependency Patching Tools ─────────────────────────────────────────
+    {
+        "name": "bingo_dep_patch",
+        "description": (
+            "Create a patch for a modified npm/pip dependency. After modifying files in "
+            "node_modules/ or site-packages/, call this to generate a .patch file. "
+            "The patch survives npm install / pip install via `bingo_dep_apply`."
+        ),
+        "inputSchema": {
+            "type": "object",
+            "properties": {
+                "cwd": {"type": "string", "description": "Project directory"},
+                "package": {"type": "string", "description": "Package name (e.g. 'lodash', 'requests')"},
+                "patch_name": {"type": "string", "description": "Optional patch name"},
+                "description": {"type": "string", "description": "What this patch fixes"}
+            },
+            "required": ["cwd", "package"]
+        }
+    },
+    {
+        "name": "bingo_dep_apply",
+        "description": (
+            "Re-apply all dependency patches after npm install / pip install. "
+            "Call this as a postinstall hook or after any package manager update."
+        ),
+        "inputSchema": {
+            "type": "object",
+            "properties": {
+                "cwd": {"type": "string", "description": "Project directory"},
+                "package": {"type": "string", "description": "Optional: apply only this package's patches"}
+            },
+            "required": ["cwd"]
+        }
+    },
+    {
+        "name": "bingo_dep_status",
+        "description": (
+            "Show health of all dependency patches. Reports version mismatches "
+            "(upstream updated but patches were generated against old version)."
+        ),
+        "inputSchema": {
+            "type": "object",
+            "properties": {"cwd": {"type": "string", "description": "Project directory"}},
+            "required": ["cwd"]
+        }
+    },
+    {
+        "name": "bingo_dep_sync",
+        "description": (
+            "After npm update / pip install --upgrade, re-apply patches and detect conflicts. "
+            "Returns ok if all patches apply cleanly, or conflict details if patches broke."
+        ),
+        "inputSchema": {
+            "type": "object",
+            "properties": {"cwd": {"type": "string", "description": "Project directory"}},
+            "required": ["cwd"]
+        }
+    },
+    {
+        "name": "bingo_dep_list",
+        "description": "List all dependency patches across all tracked packages.",
+        "inputSchema": {
+            "type": "object",
+            "properties": {"cwd": {"type": "string", "description": "Project directory"}},
+            "required": ["cwd"]
+        }
+    },
+    {
+        "name": "bingo_dep_drop",
+        "description": "Remove a dependency patch or all patches for a package.",
+        "inputSchema": {
+            "type": "object",
+            "properties": {
+                "cwd": {"type": "string", "description": "Project directory"},
+                "package": {"type": "string", "description": "Package name"},
+                "patch_name": {"type": "string", "description": "Specific patch to drop (omit for all)"}
+            },
+            "required": ["cwd", "package"]
+        }
+    },
 ]
 
 # ─── Command Mapping ──────────────────────────────────────────────────────────
@@ -629,6 +709,31 @@ def handle_tool_call(name: str, arguments: dict) -> dict:
         elif name == "bingo_workspace_status":
             return _result(repo.workspace_status())
 
+        # ── Dependency patching tools ────────────────────────────────────
+        elif name.startswith("bingo_dep_"):
+            from bingo_core.dep import DepManager
+            dm = DepManager(cwd)
+
+            if name == "bingo_dep_patch":
+                return _result(dm.patch(
+                    arguments["package"],
+                    arguments.get("patch_name", ""),
+                    arguments.get("description", ""),
+                ))
+            elif name == "bingo_dep_apply":
+                return _result(dm.apply(arguments.get("package", "")))
+            elif name == "bingo_dep_status":
+                return _result(dm.status())
+            elif name == "bingo_dep_sync":
+                return _result(dm.sync())
+            elif name == "bingo_dep_list":
+                return _result(dm.list_patches())
+            elif name == "bingo_dep_drop":
+                return _result(dm.drop(
+                    arguments["package"],
+                    arguments.get("patch_name", ""),
+                ))
+
         else:
             return {
                 "content": [{"type": "text", "text": f"Unknown tool: {name}"}],
@@ -754,7 +859,7 @@ def main():
                 "capabilities": {"tools": {}},
                 "serverInfo": {
                     "name": "bingo-light",
-                    "version": "2.1.1",
+                    "version": "2.1.2",
                 },
             }))