bingo-light 2.1.1 → 2.1.3

package/bingo-light

@@ -234,6 +234,7 @@ def _format_conflict_analyze(result: dict) -> str:
     conflicts = result.get("conflicts", [])
     if not conflicts:
         return f"{_c(GREEN, 'OK')} No conflicts detected."
+
     lines = [f"{_c(YELLOW, '!')} {len(conflicts)} conflicting file(s):"]
     for c in conflicts:
         f = c.get("file", "?")
@@ -241,6 +242,33 @@ def _format_conflict_analyze(result: dict) -> str:
         lines.append(f"  {_c(RED, f)}")
         if hint:
             lines.append(f"    hint: {hint}")
+
+    intent = result.get("patch_intent")
+    if intent and intent.get("name"):
+        lines.append("")
+        lines.append(
+            f"{_c(BOLD, 'Patch intent:')} "
+            f"{intent['name']} \u2014 {intent.get('subject', '')}"
+        )
+        meta = intent.get("meta") or {}
+        if meta.get("reason"):
+            lines.append(f"  reason: {meta['reason']}")
+        if meta.get("tags"):
+            lines.append(f"  tags: {', '.join(meta['tags'])}")
+        sp = intent.get("stack_position")
+        if sp:
+            lines.append(f"  position: {sp['index']}/{sp['total']}")
+
+    verify = result.get("verify")
+    if verify:
+        lines.append("")
+        lines.append(f"{_c(BOLD, 'Verify suggestions:')}")
+        tc = verify.get("test_command")
+        if tc:
+            lines.append(f"  test.command: {tc}")
+        for h in verify.get("file_hints", []):
+            lines.append(f"  [{h['kind']}] {h['command']}")
+
     return "\n".join(lines)
 
 
@@ -261,10 +289,18 @@ def _format_conflict_resolve(result: dict) -> str:
         )
 
     if result.get("sync_complete"):
-        return (
-            f"{_c(GREEN, 'OK')} Resolved {resolved} "
-            f"\u2014 sync complete!"
-        )
+        out = f"{_c(GREEN, 'OK')} Resolved {resolved} \u2014 sync complete!"
+        vr = result.get("verify_result")
+        if vr:
+            if vr.get("skipped"):
+                out += f"\n  verify: skipped ({vr.get('reason', '')})"
+            elif vr.get("test") == "pass":
+                out += f"\n  {_c(GREEN, 'verify: PASS')} ({vr.get('command', '')})"
+            elif vr.get("test") == "fail":
+                out += f"\n  {_c(RED, 'verify: FAIL')} ({vr.get('command', '')})"
+            else:
+                out += f"\n  verify: {vr.get('test', '?')}"
+        return out
 
     if result.get("conflict"):
         patch = result.get("current_patch", "")
@@ -284,10 +320,18 @@ def _format_conflict_resolve(result: dict) -> str:
         return "\n".join(lines)
 
     if result.get("rebase_continued"):
-        return (
-            f"{_c(GREEN, 'OK')} Resolved {resolved} "
-            f"\u2014 rebase continued."
-        )
+        out = f"{_c(GREEN, 'OK')} Resolved {resolved} \u2014 rebase continued."
+        vr = result.get("verify_result")
+        if vr:
+            if vr.get("skipped"):
+                out += f"\n  verify: skipped ({vr.get('reason', '')})"
+            elif vr.get("test") == "pass":
+                out += f"\n  {_c(GREEN, 'verify: PASS')} ({vr.get('command', '')})"
+            elif vr.get("test") == "fail":
+                out += f"\n  {_c(RED, 'verify: FAIL')} ({vr.get('command', '')})"
+            else:
+                out += f"\n  verify: {vr.get('test', '?')}"
+        return out
 
     return f"{_c(GREEN, 'OK')} Resolved {resolved}."
 
@@ -500,6 +544,118 @@ def _format_patch_meta(result: dict) -> str:
     return f"  {k}: {v}" if k else f"{_c(GREEN, 'OK')} Done."
 
 
+def _format_patch_lock(result: dict) -> str:
+    """Format patch lock/unlock result."""
+    if result.get("ok") is False:
+        return f"{_c(RED, 'x')} {result.get('error', 'Failed.')}"
+    patch = result.get("patch", "")
+    owner = result.get("owner", "")
+    if result.get("was_locked") is False:
+        return f"{_c(GREEN, 'OK')} {patch} was not locked."
+    if "locked_at" in result:
+        reason = result.get("reason", "")
+        msg = f"{_c(GREEN, 'OK')} Locked {_c(BOLD, patch)} by {owner}"
+        if reason:
+            msg += f" ({reason})"
+        return msg
+    prev = result.get("previous_owner", "")
+    if prev and prev != owner:
+        return f"{_c(GREEN, 'OK')} Unlocked {_c(BOLD, patch)} (was locked by {prev})"
+    return f"{_c(GREEN, 'OK')} Unlocked {_c(BOLD, patch)}"
+
+
+def _format_patch_check(result: dict) -> str:
+    """Format patch check (obsolescence detection) result."""
+    if result.get("ok") is False:
+        return f"{_c(RED, 'x')} {result.get('error', 'Failed.')}"
+    patches = result.get("patches", [])
+    if not patches:
+        return "No patches to check."
+    lines = []
+    for p in patches:
+        status = p.get("status", "unknown")
+        name = p.get("name", "?")
+        reason = p.get("reason", "")
+        if status == "obsolete":
+            lines.append(f"  {_c(YELLOW, 'OBSOLETE')} {_c(BOLD, name)} — {reason}")
+        elif status == "active":
+            lines.append(f"  {_c(GREEN, 'ACTIVE')}   {_c(BOLD, name)} — {reason}")
+        else:
+            lines.append(f"  {_c(DIM, 'UNKNOWN')}  {name} — {reason}")
+    header = f"Checked {len(patches)} patch(es):"
+    return header + "\n" + "\n".join(lines)
+
+
+def _format_patch_upstream(result: dict) -> str:
+    """Format patch upstream (PR-ready export) result."""
+    if result.get("ok") is False:
+        return f"{_c(RED, 'x')} {result.get('error', 'Failed.')}"
+    name = result.get("patch", "")
+    desc = result.get("description", "")
+    files = result.get("files", [])
+    stats = result.get("stats", "")
+    diff = result.get("diff", "")
+    lines = [
+        f"{_c(BOLD, 'PR-ready export:')} {name}",
+        f"  Description: {desc}",
+        f"  Files: {', '.join(files)}",
+    ]
+    if stats:
+        lines.append(f"  Stats: {stats}")
+    lines.append("")
+    lines.append(diff)
+    return "\n".join(lines)
+
+
+def _format_patch_expire(result: dict) -> str:
+    """Format patch expire result."""
+    if result.get("ok") is False:
+        return f"{_c(RED, 'x')} {result.get('error', 'Failed.')}"
+    expired = result.get("expired", [])
+    expiring = result.get("expiring_soon", [])
+    if not expired and not expiring:
+        return f"{_c(GREEN, 'OK')} No expired or expiring patches."
+    lines = []
+    if expired:
+        lines.append(f"{_c(RED, 'Expired')} ({len(expired)}):")
+        for e in expired:
+            lines.append(f"  {_c(RED, 'x')} {_c(BOLD, e['name'])} — expired {e['expires']} ({abs(e['days_left'])}d ago)")
+    if expiring:
+        lines.append(f"{_c(YELLOW, 'Expiring soon')} ({len(expiring)}):")
+        for e in expiring:
+            lines.append(f"  {_c(YELLOW, '!')} {_c(BOLD, e['name'])} — expires {e['expires']} ({e['days_left']}d left)")
+    return "\n".join(lines)
+
+
+def _format_patch_stats(result: dict) -> str:
+    """Format patch stats result."""
+    if result.get("ok") is False:
+        return f"{_c(RED, 'x')} {result.get('error', 'Failed.')}"
+    patches = result.get("patches", [])
+    if not patches:
+        return "No patches."
+    lines = [f"{'#':>3}  {'Name':<20} {'Age':>6} {'Size':>10} {'Syncs':>6} {'Status':<12} {'Owner':<15}"]
+    lines.append("─" * 80)
+    for i, p in enumerate(patches, 1):
+        age = f"{p['age_days']}d" if p.get("age_days", -1) >= 0 else "?"
+        size = f"+{p.get('insertions', 0)}/-{p.get('deletions', 0)}"
+        syncs = str(p.get("syncs_survived", 0))
+        status = p.get("status", "")
+        owner = p.get("owner", "") or p.get("locked_by", "") or ""
+        lines.append(f"{i:>3}  {p['name']:<20} {age:>6} {size:>10} {syncs:>6} {status:<12} {owner:<15}")
+    return "\n".join(lines)
+
+
+def _format_report(result: dict) -> str:
+    """Format fork health report."""
+    if result.get("ok") is False:
+        return f"{_c(RED, 'x')} {result.get('error', 'Failed.')}"
+    report = result.get("report", "")
+    if report:
+        return report
+    return f"{_c(GREEN, 'OK')} Report generated."
+
+
 def _format_undo(result: dict) -> str:
     """Format undo result."""
     if result.get("ok") is False:
@@ -517,6 +673,72 @@ def _format_setup(result: dict) -> str:
     return ""
 
 
+def _format_dep(result: dict) -> str:
+    """Format dep subcommand results."""
+    if result.get("ok") is False:
+        return f"{_c(RED, 'x')} {result.get('error', 'Failed')}"
+
+    lines = []
+
+    # dep patch result
+    if "patch" in result and "package" in result:
+        lines.append(f"{_c(GREEN, '✓')} {result['package']}@{result.get('version', '?')} "
+                     f"→ {result['patch']} ({result.get('files_changed', 0)} file(s))")
+        return "\n".join(lines)
+
+    # dep status
+    if "packages" in result and "total_patches" in result:
+        pkgs = result["packages"]
+        if not pkgs:
+            return f"{_c(DIM, '⊘')} No dependency patches tracked"
+        lines.append(f"  {_c(BOLD, 'Dependency Patches:')}")
+        lines.append("")
+        for p in pkgs:
+            status_color = GREEN if p["status"] == "ok" else YELLOW
+            icon = "✓" if p["status"] == "ok" else "!" if p["status"] == "version_mismatch" else "?"
+            lines.append(f"  {_c(status_color, icon)} {p['package']}  "
+                         f"{_c(DIM, p['manager'])}  "
+                         f"{p['patched_version']}"
+                         f"{' → ' + p['installed_version'] if p['status'] == 'version_mismatch' else ''}  "
+                         f"({p['patches']} patch(es))")
+        lines.append("")
+        return "\n".join(lines)
+
+    # dep list
+    if "patches" in result and isinstance(result["patches"], list):
+        patches = result["patches"]
+        if not patches:
+            return f"{_c(DIM, '⊘')} No patches"
+        for p in patches:
+            icon = _c(GREEN, "✓") if p.get("exists", True) else _c(RED, "✗")
+            desc = f"  {_c(DIM, p['description'])}" if p.get("description") else ""
+            lines.append(f"  {icon} {p['package']}/{p['patch']}  {_c(DIM, 'v' + p.get('version', '?'))}{desc}")
+        return "\n".join(lines)
+
+    # dep apply / dep sync
+    if "applied" in result or "results" in result:
+        applied = result.get("applied", 0)
+        failed = result.get("failed", 0)
+        if isinstance(applied, int):
+            lines.append(f"{_c(GREEN, '✓')} {applied} applied, {failed} failed")
+        # Show sync conflicts
+        for r in result.get("results", []):
+            pkg = r.get("package", "?")
+            status = r.get("status", "?")
+            if status == "conflict":
+                for c in r.get("conflicts", []):
+                    lines.append(f"  {_c(YELLOW, '!')} {pkg}/{c['patch']}: {c.get('error', '?')}")
+                    if c.get("hint"):
+                        lines.append(f"    {_c(DIM, c['hint'])}")
+        return "\n".join(lines)
+
+    # dep drop
+    if "dropped" in result:
+        return f"{_c(GREEN, '✓')} Dropped {result.get('package', '?')}/{result['dropped']}"
+
+    return f"{_c(GREEN, '✓')} Done"
+
+
 def _format_generic(result: dict) -> str:
     """Fallback formatter: show message or OK."""
     if result.get("ok") is False:
@@ -582,6 +804,14 @@ def show_help() -> str:
     {cy}config{r} get|set|list             Manage configuration
     {cy}test{r}                            Run configured test suite
 
+  {b}Dependency Patching:{r}
+    {cy}dep patch{r} <package> [name]      Patch a modified npm/pip dependency
+    {cy}dep apply{r} [package]             Re-apply patches after install
+    {cy}dep sync{r}                        Re-apply patches after update, detect conflicts
+    {cy}dep status{r}                      Show patch health for all dependencies
+    {cy}dep list{r}                        List all dependency patches
+    {cy}dep drop{r} <package> [patch]      Remove a dependency patch
+
   {b}Automation:{r}
     {cy}auto-sync{r}                       Generate GitHub Actions workflow
 
@@ -666,7 +896,11 @@ def build_parser() -> argparse.ArgumentParser:
     sub.add_parser("diff", aliases=["d"], add_help=False)
 
     # doctor
-    sub.add_parser("doctor", add_help=False)
+    p_doctor = sub.add_parser("doctor", add_help=False)
+    p_doctor.add_argument("--report", action="store_true")
+
+    # report
+    sub.add_parser("report", add_help=False)
 
     # log
     sub.add_parser("log", add_help=False)
@@ -681,6 +915,8 @@ def build_parser() -> argparse.ArgumentParser:
     cr = sub.add_parser("conflict-resolve", add_help=False)
     cr.add_argument("resolve_file", nargs="?", default="")
     cr.add_argument("--content-stdin", action="store_true")
+    cr.add_argument("--verify", action="store_true",
+                    help="Run test.command after the final rebase continues")
 
     # session
     p_session = sub.add_parser("session", add_help=False)
@@ -737,6 +973,23 @@ def build_parser() -> argparse.ArgumentParser:
     pp_meta.add_argument("meta_key", nargs="?", default="")
     pp_meta.add_argument("meta_value", nargs="?", default="")
 
+    pp_lock = patch_sub.add_parser("lock", add_help=False)
+    pp_lock.add_argument("target")
+    pp_lock.add_argument("--reason", default="")
+
+    pp_unlock = patch_sub.add_parser("unlock", add_help=False)
+    pp_unlock.add_argument("target")
+    pp_unlock.add_argument("--force", action="store_true")
+
+    pp_check = patch_sub.add_parser("check", add_help=False)
+    pp_check.add_argument("target", nargs="?", default="")
+
+    pp_upstream = patch_sub.add_parser("upstream", add_help=False)
+    pp_upstream.add_argument("target")
+
+    patch_sub.add_parser("expire", add_help=False)
+    patch_sub.add_parser("stats", add_help=False)
+
     # workspace
     p_ws = sub.add_parser("workspace", aliases=["ws"], add_help=False)
     ws_sub = p_ws.add_subparsers(dest="ws_command")
@@ -758,6 +1011,47 @@ def build_parser() -> argparse.ArgumentParser:
     p_setup = sub.add_parser("setup", add_help=False)
     p_setup.add_argument("--no-completions", dest="no_completions", action="store_true")
 
+    # dep (dependency patching)
+    p_dep = sub.add_parser("dep", add_help=False)
+    dep_sub = p_dep.add_subparsers(dest="dep_command")
+
+    dp_patch = dep_sub.add_parser("patch", add_help=False)
+    dp_patch.add_argument("dep_package")
+    dp_patch.add_argument("dep_patch_name", nargs="?", default="")
+
+    dp_apply = dep_sub.add_parser("apply", add_help=False)
+    dp_apply.add_argument("dep_package", nargs="?", default="")
+
+    dep_sub.add_parser("list", add_help=False)
+
+    dep_sub.add_parser("status", add_help=False)
+
+    dep_sub.add_parser("sync", add_help=False)
+
+    dp_drop = dep_sub.add_parser("drop", add_help=False)
+    dp_drop.add_argument("dep_package")
+    dp_drop.add_argument("dep_patch_name", nargs="?", default="")
+
+    # dep override subcommands
+    dp_override = dep_sub.add_parser("override", add_help=False)
+    override_sub = dp_override.add_subparsers(dest="override_command")
+    override_sub.add_parser("list", add_help=False)
+    override_sub.add_parser("check", add_help=False)
+    ov_add = override_sub.add_parser("add", add_help=False)
+    ov_add.add_argument("override_package")
+    ov_add.add_argument("override_version")
+    ov_add.add_argument("--reason", dest="override_reason", default="")
+    ov_drop = override_sub.add_parser("drop", add_help=False)
+    ov_drop.add_argument("override_package")
+
+    # dep fork subcommands
+    dp_fork = dep_sub.add_parser("fork", add_help=False)
+    fork_sub = dp_fork.add_subparsers(dest="fork_command")
+    fork_sub.add_parser("list", add_help=False)
+    fork_sub.add_parser("check", add_help=False)
+    fk_sync = fork_sub.add_parser("sync", add_help=False)
+    fk_sync.add_argument("fork_package")
+
     # help
     sub.add_parser("help", add_help=False)
 
@@ -771,6 +1065,51 @@ def dispatch(args: argparse.Namespace, json_mode: bool) -> Optional[dict]:
     """Dispatch a parsed command to the Repo method and return the result dict."""
     cmd = args.command
 
+    # dep doesn't need a Repo (works with package managers, not git)
+    if cmd == "dep":
+        from bingo_core.dep import DepManager
+        dm = DepManager()
+        dcmd = getattr(args, "dep_command", "")
+        if dcmd == "patch":
+            desc = os.environ.get("BINGO_DESCRIPTION", "")
+            return dm.patch(args.dep_package, args.dep_patch_name, desc)
+        if dcmd == "apply":
+            return dm.apply(getattr(args, "dep_package", "") or "")
+        if dcmd == "list":
+            return dm.list_patches()
+        if dcmd == "status":
+            return dm.status()
+        if dcmd == "sync":
+            return dm.sync()
+        if dcmd == "drop":
+            return dm.drop(args.dep_package, getattr(args, "dep_patch_name", ""))
+        if dcmd == "override":
+            ocmd = getattr(args, "override_command", "")
+            if ocmd == "list":
+                return dm.override_list()
+            if ocmd == "check":
+                return dm.override_check()
+            if ocmd == "add":
+                return dm.override_add(
+                    args.override_package, args.override_version,
+                    getattr(args, "override_reason", ""),
+                )
+            if ocmd == "drop":
+                return dm.override_drop(args.override_package)
+            return {"ok": False, "error": f"Unknown override subcommand: {ocmd}"}
+        if dcmd == "fork":
+            from bingo_core.dep_fork import ForkTracker
+            ft = ForkTracker()
+            fcmd = getattr(args, "fork_command", "")
+            if fcmd == "list":
+                return ft.fork_list()
+            if fcmd == "check":
+                return ft.fork_check()
+            if fcmd == "sync":
+                return ft.fork_sync(args.fork_package)
+            return {"ok": False, "error": f"Unknown fork subcommand: {fcmd}"}
+        return {"ok": False, "error": f"Unknown dep subcommand: {dcmd}"}
+
     # setup doesn't need a Repo (works outside git repos)
     if cmd == "setup":
         return run_setup(
@@ -804,7 +1143,10 @@ def dispatch(args: argparse.Namespace, json_mode: bool) -> Optional[dict]:
         return repo.diff()
 
     if cmd == "doctor":
-        return repo.doctor()
+        return repo.doctor(report=getattr(args, "report", False))
+
+    if cmd == "report":
+        return repo.report()
 
     if cmd == "log":
         return repo.history()
@@ -820,7 +1162,9 @@ def dispatch(args: argparse.Namespace, json_mode: bool) -> Optional[dict]:
         if args.content_stdin:
             import sys as _sys
             content = _sys.stdin.read()
-        return repo.conflict_resolve(args.resolve_file, content)
+        return repo.conflict_resolve(
+            args.resolve_file, content, verify=args.verify
+        )
 
     if cmd == "session":
         update = (args.session_action == "update")
@@ -903,6 +1247,24 @@ def _dispatch_patch(args: argparse.Namespace, repo: Repo) -> dict:
             value=meta_value,
         )
 
+    if pcmd == "lock":
+        return repo.patch_lock(args.target, reason=getattr(args, "reason", ""))
+
+    if pcmd == "unlock":
+        return repo.patch_unlock(args.target, force=getattr(args, "force", False))
+
+    if pcmd == "check":
+        return repo.patch_check(getattr(args, "target", ""))
+
+    if pcmd == "upstream":
+        return repo.patch_upstream(args.target)
+
+    if pcmd == "expire":
+        return repo.patch_expire()
+
+    if pcmd == "stats":
+        return repo.patch_stats()
+
     raise BingoError(f"Unknown patch subcommand: {pcmd}")
 
 
@@ -959,6 +1321,8 @@ _FORMATTERS: Dict[str, Any] = {
     "undo": _format_undo,
     "smart-sync": _format_smart_sync,
     "setup": _format_setup,
+    "dep": _format_dep,
+    "report": _format_report,
 }
 
 
@@ -983,6 +1347,16 @@ def _get_formatter(args: argparse.Namespace):
             return _format_patch_import
         if pcmd == "meta":
             return _format_patch_meta
+        if pcmd in ("lock", "unlock"):
+            return _format_patch_lock
+        if pcmd == "check":
+            return _format_patch_check
+        if pcmd == "upstream":
+            return _format_patch_upstream
+        if pcmd == "expire":
+            return _format_patch_expire
+        if pcmd == "stats":
+            return _format_patch_stats
         return _format_generic
 
     # workspace subcommands

package/bingo_core/__init__.py

@@ -14,7 +14,7 @@ import re
 
 # --- Constants ---
 
-VERSION = "2.1.1"
+VERSION = "2.1.3"
 PATCH_PREFIX = "[bl]"
 CONFIG_FILE = ".bingolight"
 BINGO_DIR = ".bingo"
@@ -42,6 +42,7 @@ from bingo_core.models import PatchInfo, ConflictInfo  # noqa: E402
 from bingo_core.git import Git  # noqa: E402
 from bingo_core.config import Config  # noqa: E402
 from bingo_core.state import State  # noqa: E402
+from bingo_core.team import TeamState  # noqa: E402
 from bingo_core.repo import Repo  # noqa: E402
 
 __all__ = [
@@ -73,5 +74,6 @@ __all__ = [
     "Git",
     "Config",
     "State",
+    "TeamState",
     "Repo",
 ]