bingo-light 2.1.1 → 2.1.3

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/bingo_core/state.py

@@ -184,7 +184,7 @@ class State:
             for t in (v.strip() for v in value.split(",")):
                 if t and t not in tags_list:
                     tags_list.append(t)
-        elif key in ("reason", "expires", "upstream_pr", "status"):
+        elif key in ("reason", "expires", "upstream_pr", "status", "owner"):
             p[key] = value
         self._save_metadata(data)
 

package/bingo_core/team.py

@@ -0,0 +1,170 @@
+"""
+bingo_core.team — Team collaboration state (.bingo/team.json).
+
+Manages patch locks and team membership for multi-person fork maintenance.
+Advisory locking: prevents accidental concurrent edits, not a security boundary.
+
+Storage:
+    .bingo/team.json
+    {
+        "locks": {
+            "<patch_name>": {
+                "owner": "<user>",
+                "locked_at": "ISO8601",
+                "reason": ""
+            }
+        }
+    }
+
+Python 3.8+ stdlib only.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import tempfile
+from datetime import datetime, timezone
+from typing import List, Optional
+
+from bingo_core import BINGO_DIR
+from bingo_core.exceptions import BingoError
+
+
+class TeamState:
+    """Manages .bingo/team.json for patch locking and team coordination."""
+
+    def __init__(self, repo_dir: str, git=None):
+        self.repo_dir = repo_dir
+        self._git = git  # optional Git instance for get_user()
+        self.bingo_dir = os.path.join(repo_dir, BINGO_DIR)
+        self.team_file = os.path.join(self.bingo_dir, "team.json")
+
+    def _load(self) -> dict:
+        """Load team.json, returning empty structure if missing."""
+        if not os.path.isfile(self.team_file):
+            return {"locks": {}}
+        try:
+            with open(self.team_file) as f:
+                data = json.load(f)
+            if "locks" not in data:
+                data["locks"] = {}
+            return data
+        except (json.JSONDecodeError, IOError):
+            return {"locks": {}}
+
+    def _save(self, data: dict) -> None:
+        """Atomically write team.json."""
+        os.makedirs(self.bingo_dir, exist_ok=True)
+        dir_name = os.path.dirname(self.team_file)
+        fd, tmp_path = tempfile.mkstemp(suffix=".tmp", dir=dir_name)
+        try:
+            with os.fdopen(fd, "w") as f:
+                json.dump(data, f, indent=2)
+            os.replace(tmp_path, self.team_file)
+        except Exception:
+            try:
+                os.unlink(tmp_path)
+            except FileNotFoundError:
+                pass
+            raise
+
+    def get_user(self) -> str:
+        """Detect current user from git config or environment."""
+        if self._git:
+            for key in ("user.name", "user.email"):
+                try:
+                    val = self._git.run("config", key, check=False)
+                    if val and val.strip():
+                        return val.strip()
+                except Exception:
+                    pass
+        return os.environ.get("USER", "unknown")
+
+    def lock(self, patch_name: str, owner: str = "", reason: str = "") -> dict:
+        """Lock a patch for exclusive editing.
+
+        Returns {"ok": True, "patch": ..., "owner": ..., "locked_at": ...}
+        Raises BingoError if already locked by another user.
+        """
+        if not owner:
+            owner = self.get_user()
+        data = self._load()
+        existing = data["locks"].get(patch_name)
+        if existing and existing["owner"] != owner:
+            raise BingoError(
+                f"Patch '{patch_name}' is locked by {existing['owner']} "
+                f"(since {existing['locked_at']}). "
+                f"They must unlock it first, or use --force."
+            )
+        now = datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+        data["locks"][patch_name] = {
+            "owner": owner,
+            "locked_at": now,
+            "reason": reason,
+        }
+        self._save(data)
+        return {
+            "ok": True,
+            "patch": patch_name,
+            "owner": owner,
+            "locked_at": now,
+            "reason": reason,
+        }
+
+    def unlock(self, patch_name: str, owner: str = "", force: bool = False) -> dict:
+        """Unlock a patch.
+
+        Returns {"ok": True, "patch": ..., "owner": ...}
+        Raises BingoError if locked by someone else (unless force=True).
+        """
+        if not owner:
+            owner = self.get_user()
+        data = self._load()
+        existing = data["locks"].get(patch_name)
+        if not existing:
+            return {"ok": True, "patch": patch_name, "owner": owner, "was_locked": False}
+        if existing["owner"] != owner and not force:
+            raise BingoError(
+                f"Patch '{patch_name}' is locked by {existing['owner']}. "
+                "Use --force to override."
+            )
+        del data["locks"][patch_name]
+        self._save(data)
+        return {
+            "ok": True,
+            "patch": patch_name,
+            "owner": owner,
+            "was_locked": True,
+            "previous_owner": existing["owner"],
+        }
+
+    def get_lock(self, patch_name: str) -> Optional[dict]:
+        """Get lock info for a patch, or None if unlocked."""
+        data = self._load()
+        return data["locks"].get(patch_name)
+
+    def is_locked_by_other(self, patch_name: str, current_user: str = "") -> bool:
+        """Check if a patch is locked by someone other than current_user."""
+        if not current_user:
+            current_user = self.get_user()
+        lock = self.get_lock(patch_name)
+        if not lock:
+            return False
+        return lock["owner"] != current_user
+
+    def list_locks(self) -> List[dict]:
+        """List all active locks.
+
+        Returns list of {"patch": ..., "owner": ..., "locked_at": ..., "reason": ...}
+        """
+        data = self._load()
+        result = []
+        for patch_name, info in data["locks"].items():
+            result.append({
+                "patch": patch_name,
+                "owner": info.get("owner", ""),
+                "locked_at": info.get("locked_at", ""),
+                "reason": info.get("reason", ""),
+            })
+        return result

package/completions/bingo-light.bash

@@ -10,11 +10,11 @@ _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 report"
     local -r toplevel_aliases="p s st d ws"
     local -r all_toplevel="${toplevel_commands} ${toplevel_aliases}"
 
-    local -r patch_subcommands="new list show edit drop export import reorder squash meta"
+    local -r patch_subcommands="new list show edit drop export import reorder squash meta lock unlock check upstream expire stats"
     local -r patch_aliases="ls add create rm remove"
     local -r all_patch="${patch_subcommands} ${patch_aliases}"
 
@@ -36,7 +36,10 @@ _bingo_light() {
             diff|d)
                 cmd="diff"
                 ;;
-            init|setup|doctor|auto-sync|log|undo|version|help|conflict-analyze|conflict-resolve|config|history|test|workspace|ws|smart-sync|session)
+            dep)
+                cmd="dep"
+                ;;
+            init|setup|doctor|auto-sync|log|undo|version|help|conflict-analyze|conflict-resolve|config|history|test|workspace|ws|smart-sync|session|report)
                 cmd="${words[i]}"
                 ;;
             *)
@@ -91,6 +94,26 @@ _bingo_light() {
         return
     fi
 
+    # Inside "conflict-resolve"
+    if [[ "$cmd" == "conflict-resolve" ]]; then
+        COMPREPLY=( $(compgen -W "--verify --content-stdin --help -h" -- "$cur") )
+        return
+    fi
+
+    # Inside "dep" -- complete subcommands
+    if [[ "$cmd" == "dep" ]]; then
+        if [[ -z "$subcmd" ]]; then
+            COMPREPLY=( $(compgen -W "patch apply sync status list drop override fork" -- "$cur") )
+        elif [[ "$subcmd" == "override" ]]; then
+            COMPREPLY=( $(compgen -W "list check add drop" -- "$cur") )
+        elif [[ "$subcmd" == "fork" ]]; then
+            COMPREPLY=( $(compgen -W "list check sync" -- "$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'
@@ -85,6 +86,7 @@ complete -c bingo-light -n __bingo_light_needs_command -a test    -d 'Run config
 complete -c bingo-light -n __bingo_light_needs_command -a workspace -d 'Manage multiple forks'
 complete -c bingo-light -n __bingo_light_needs_command -a smart-sync -d 'Smart sync with circuit breaker and partial state'
 complete -c bingo-light -n __bingo_light_needs_command -a session -d 'Manage session memory'
+complete -c bingo-light -n __bingo_light_needs_command -a report  -d 'Generate fork health report'
 
 # Short aliases
 complete -c bingo-light -n __bingo_light_needs_command -a p  -d 'Alias for patch'
@@ -122,9 +124,11 @@ complete -c bingo-light -n '__bingo_light_using_command version'   -s h -l help
 
 # ---- conflict-resolve flags ----
 complete -c bingo-light -n '__bingo_light_using_command conflict-resolve' -s h -l help -d 'Show help'
+complete -c bingo-light -n '__bingo_light_using_command conflict-resolve' -l verify -d 'Run test.command after the final rebase continues'
+complete -c bingo-light -n '__bingo_light_using_command conflict-resolve' -l content-stdin -d 'Read resolved content from stdin'
 
 # ---- 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 report' -d 'Command'
 
 # ---- patch subcommands (also alias "p") ----
 complete -c bingo-light -n __bingo_light_patch_needs_subcommand -a new     -d 'Create a new patch'
@@ -137,6 +141,12 @@ complete -c bingo-light -n __bingo_light_patch_needs_subcommand -a import  -d 'I
 complete -c bingo-light -n __bingo_light_patch_needs_subcommand -a reorder -d 'Reorder the patch stack'
 complete -c bingo-light -n __bingo_light_patch_needs_subcommand -a squash  -d 'Squash two patches into one'
 complete -c bingo-light -n __bingo_light_patch_needs_subcommand -a meta    -d 'Get/set patch metadata'
+complete -c bingo-light -n __bingo_light_patch_needs_subcommand -a lock    -d 'Lock a patch for exclusive editing'
+complete -c bingo-light -n __bingo_light_patch_needs_subcommand -a unlock  -d 'Unlock a patch'
+complete -c bingo-light -n __bingo_light_patch_needs_subcommand -a check   -d 'Check if patches are still needed'
+complete -c bingo-light -n __bingo_light_patch_needs_subcommand -a upstream -d 'Export patch as PR-ready diff'
+complete -c bingo-light -n __bingo_light_patch_needs_subcommand -a expire  -d 'List expired patches'
+complete -c bingo-light -n __bingo_light_patch_needs_subcommand -a stats   -d 'Show patch health metrics'
 
 # Patch short aliases
 complete -c bingo-light -n __bingo_light_patch_needs_subcommand -a ls     -d 'Alias for list'
@@ -162,6 +172,39 @@ complete -c bingo-light -n '__bingo_light_patch_using_subcommand import'
 complete -c bingo-light -n '__bingo_light_patch_using_subcommand reorder'           -s h -l help -d 'Show help'
 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'
+complete -c bingo-light -n '__bingo_light_patch_using_subcommand lock'              -s h -l help -d 'Show help'
+complete -c bingo-light -n '__bingo_light_patch_using_subcommand lock'              -l reason   -d 'Reason for locking'
+complete -c bingo-light -n '__bingo_light_patch_using_subcommand unlock'            -s h -l help -d 'Show help'
+complete -c bingo-light -n '__bingo_light_patch_using_subcommand unlock'            -l force    -d 'Force unlock even if locked by someone else'
+complete -c bingo-light -n '__bingo_light_patch_using_subcommand check'             -s h -l help -d 'Show help'
+complete -c bingo-light -n '__bingo_light_patch_using_subcommand upstream'          -s h -l help -d 'Show help'
+complete -c bingo-light -n '__bingo_light_patch_using_subcommand expire'            -s h -l help -d 'Show help'
+complete -c bingo-light -n '__bingo_light_patch_using_subcommand stats'             -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'
+complete -c bingo-light -n __bingo_light_dep_needs_subcommand -a override -d 'Manage npm overrides/resolutions'
+complete -c bingo-light -n __bingo_light_dep_needs_subcommand -a fork     -d 'Track fork-as-dependency drift'
 
 # ---- workspace subcommands (also alias "ws") ----
 
@@ -195,3 +238,5 @@ complete -c bingo-light -n '__bingo_light_using_command test'             -s h -
 complete -c bingo-light -n '__bingo_light_using_command workspace ws'     -s h -l help -d 'Show help'
 complete -c bingo-light -n '__bingo_light_using_command smart-sync'      -s h -l help -d 'Show help'
 complete -c bingo-light -n '__bingo_light_using_command session'         -s h -l help -d 'Show help'
+complete -c bingo-light -n '__bingo_light_using_command report'          -s h -l help -d 'Show help'
+complete -c bingo-light -n '__bingo_light_using_command doctor'          -l report    -d 'Include team, expiry, and dep checks'

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'
@@ -29,6 +30,7 @@ _bingo-light() {
         'workspace:Manage multiple forks'
         'smart-sync:Smart sync with circuit breaker and partial state'
         'session:Manage session memory'
+        'report:Generate fork health report'
     )
 
     local -a toplevel_aliases=(
@@ -50,6 +52,12 @@ _bingo-light() {
         'reorder:Reorder the patch stack'
         'squash:Squash two patches into one'
         'meta:Get/set patch metadata'
+        'lock:Lock a patch for exclusive editing'
+        'unlock:Unlock a patch'
+        'check:Check if patches are still needed'
+        'upstream:Export patch as PR-ready diff'
+        'expire:List expired patches'
+        'stats:Show patch health metrics'
     )
 
     local -a patch_aliases=(
@@ -120,7 +128,7 @@ _bingo-light() {
                                 list|ls)
                                     _arguments $patch_list_flags
                                     ;;
-                                new|add|create|show|edit|drop|rm|remove|export|import|reorder|squash|meta)
+                                new|add|create|show|edit|drop|rm|remove|export|import|reorder|squash|meta|lock|unlock|check|upstream|expire|stats)
                                     _arguments $help_flag
                                     ;;
                             esac
@@ -136,6 +144,27 @@ _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'
+                        'override:Manage npm overrides/resolutions'
+                        'fork:Track fork-as-dependency drift'
+                    )
+                    _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'
@@ -155,7 +184,14 @@ _bingo-light() {
                             ;;
                     esac
                     ;;
-                init|setup|doctor|auto-sync|log|undo|version|conflict-analyze|conflict-resolve|config|history|test|smart-sync|session)
+                conflict-resolve)
+                    _arguments \
+                        '--verify[Run test.command after the final rebase continues]' \
+                        '--content-stdin[Read resolved content from stdin]' \
+                        $help_flag \
+                        '*:file:_files'
+                    ;;
+                init|setup|doctor|auto-sync|log|undo|version|conflict-analyze|config|history|test|smart-sync|session|report)
                     _arguments $help_flag
                     ;;
                 help)