clawtan 0.1.4 → 0.1.9

package/clawtan/cli.py

@@ -66,6 +66,9 @@ def _base() -> str:
     return url.rstrip("/")
 
 
+_DEBUG = os.environ.get("CLAWTAN_DEBUG", "").lower() in ("1", "true", "yes")
+
+
 def _req(method: str, path: str, data=None, token=None):
     url = f"{_base()}{path}"
     body = json.dumps(data).encode() if data is not None else None
@@ -76,17 +79,32 @@ def _req(method: str, path: str, data=None, token=None):
     if token:
         headers["Authorization"] = token
     req = urllib.request.Request(url, data=body, headers=headers, method=method)
+
+    if _DEBUG:
+        print(f"[DEBUG] {method} {url}", file=sys.stderr)
+        if body:
+            print(f"[DEBUG] Body: {body.decode()}", file=sys.stderr)
+
     try:
         with urllib.request.urlopen(req) as r:
-            return json.loads(r.read())
+            raw = r.read()
+            if _DEBUG:
+                print(f"[DEBUG] {r.status} ({len(raw)} bytes)", file=sys.stderr)
+            return json.loads(raw)
     except urllib.error.HTTPError as e:
+        raw_body = e.read()
+        if _DEBUG:
+            print(f"[DEBUG] HTTP {e.code}: {raw_body[:500]}", file=sys.stderr)
+            print(f"[DEBUG] Headers: {dict(e.headers)}", file=sys.stderr)
         try:
-            detail = json.loads(e.read()).get("detail", str(e))
+            detail = json.loads(raw_body).get("detail", str(e))
         except Exception:
             detail = str(e)
         raise APIError(e.code, detail)
     except urllib.error.URLError as e:
         reason = str(e.reason)
+        if _DEBUG:
+            print(f"[DEBUG] URLError: {reason}", file=sys.stderr)
         if isinstance(e.reason, ssl.SSLError) or "SSL" in reason or "CERTIFICATE" in reason:
             raise APIError(
                 0,
@@ -173,6 +191,17 @@ def _my_status(state: dict, color: str) -> dict | None:
     }
 
 
+def _all_player_resources(state: dict) -> dict:
+    """Return {color: {resource: count}} for every player."""
+    ps = state.get("player_state", {})
+    colors = state.get("colors", [])
+    result = {}
+    for i, c in enumerate(colors):
+        p = f"P{i}_"
+        result[c] = {r: ps.get(f"{p}{r}_IN_HAND", 0) for r in RESOURCES}
+    return result
+
+
 def _opponents(state: dict, color: str) -> list:
     ps = state.get("player_state", {})
     colors = state.get("colors", [])
@@ -202,9 +231,9 @@ def _opponents(state: dict, color: str) -> list:
     return result
 
 
-# ---------------------------------------------------------------------------
+# --------------------------------------------------------------------------
 # Text formatters
-# ---------------------------------------------------------------------------
+# --------------------------------------------------------------------------
 def _header(title: str):
     print(f"\n=== {title} ===")
 
@@ -259,26 +288,76 @@ def _print_opponents(opponents: list):
         print(line)
 
 
-def _print_actions(actions: list):
+_ACTION_HINTS = {
+    "RELEASE_CATCH": (
+        "Discard cards. Run with no value to discard randomly:\n"
+        "    CLI: clawtan act RELEASE_CATCH\n"
+        "    Or pick specific cards (freqdeck=[DRIFTWOOD,CORAL,SHRIMP,KELP,PEARL]):\n"
+        "    CLI: clawtan act RELEASE_CATCH '[1,0,0,1,0]'"
+    ),
+    "MOVE_THE_KRAKEN": (
+        "Move robber: value = [coordinate, victim_color_or_null, null].\n"
+        "    CLI: clawtan act MOVE_THE_KRAKEN '[[0,1,-1],\"BLUE\",null]'"
+    ),
+    "OCEAN_TRADE": (
+        "Maritime trade: give 4 (or 3/2 with port) of one resource, receive 1.\n"
+        "    Value = list of resources: first N are given, last 1 is received.\n"
+        "    CLI: clawtan act OCEAN_TRADE '[\"KELP\",\"KELP\",\"KELP\",\"KELP\",\"SHRIMP\"]'"
+    ),
+    "PLAY_BOUNTIFUL_HARVEST": (
+        "Year of Plenty: pick 2 free resources.\n"
+        "    CLI: clawtan act PLAY_BOUNTIFUL_HARVEST '[\"DRIFTWOOD\",\"CORAL\"]'"
+    ),
+}
+
+
+def _print_actions(actions: list, my_color: str | None = None):
     _section("Available Actions")
-    grouped = defaultdict(list)
+
+    my_actions = []
+    other_colors = set()
     for a in actions:
+        if isinstance(a, list) and len(a) > 1:
+            action_color = a[0]
+            if my_color and action_color and action_color != my_color:
+                other_colors.add(action_color)
+                continue
+        my_actions.append(a)
+
+    if not my_actions and other_colors:
+        print(f"  (none for you -- waiting on: {', '.join(sorted(other_colors))})")
+        return
+
+    grouped = defaultdict(list)
+    for a in my_actions:
         atype = a[1] if isinstance(a, list) and len(a) > 1 else str(a)
         val = a[2] if isinstance(a, list) and len(a) > 2 else None
         grouped[atype].append(val)
 
     for atype, values in grouped.items():
+        hint = _ACTION_HINTS.get(atype)
         if all(v is None for v in values):
             print(f"  {atype}")
+            if hint:
+                print(f"    ({hint})")
         else:
             formatted = [json.dumps(v, separators=(",", ":")) for v in values]
-            joined = " | ".join(formatted)
-            if len(joined) + len(atype) + 4 <= 120:
-                print(f"  {atype}: {joined}")
-            else:
+            if hint:
                 print(f"  {atype} ({len(values)} options):")
+                print(f"    ({hint})")
                 for f in formatted:
                     print(f"    {f}")
+            else:
+                joined = " | ".join(formatted)
+                if len(joined) + len(atype) + 4 <= 120:
+                    print(f"  {atype}: {joined}")
+                else:
+                    print(f"  {atype} ({len(values)} options):")
+                    for f in formatted:
+                        print(f"    {f}")
+
+    if other_colors:
+        print(f"\n  (other players still need to act: {', '.join(sorted(other_colors))})")
 
 
 def _print_history(records: list, since: int = 0):
@@ -459,18 +538,65 @@ def cmd_wait(args):
 
     actions = state.get("current_playable_actions", [])
     if actions:
-        _print_actions(actions)
+        _print_actions(actions, my_color=color)
 
     robber = state.get("robber_coordinate")
     if robber:
         print(f"\n  Robber: {robber}")
 
 
+def _print_roll_result(state: dict, pre_resources: dict | None):
+    """Show dice result and per-player resource gains after a roll."""
+    # Extract the roll value from the last action record
+    records = state.get("action_records", [])
+    roll_val = None
+    for r in reversed(records):
+        if isinstance(r, list) and len(r) >= 2 and r[1] == "ROLL_THE_SHELLS":
+            roll_val = r[2] if len(r) > 2 else None
+            break
+
+    if roll_val is not None:
+        if isinstance(roll_val, list) and len(roll_val) == 2:
+            print(f"  Rolled: {roll_val[0]} + {roll_val[1]} = {sum(roll_val)}")
+        else:
+            print(f"  Rolled: {roll_val}")
+
+    # Diff resources to show what was distributed
+    if pre_resources:
+        post_resources = _all_player_resources(state)
+        _section("Resources Distributed")
+        any_gains = False
+        for c in state.get("colors", []):
+            pre = pre_resources.get(c, {})
+            post = post_resources.get(c, {})
+            gains = []
+            for res in RESOURCES:
+                diff = post.get(res, 0) - pre.get(res, 0)
+                if diff > 0:
+                    gains.append(f"+{diff} {res}")
+                elif diff < 0:
+                    gains.append(f"{diff} {res}")
+            if gains:
+                any_gains = True
+                print(f"  {c}: {', '.join(gains)}")
+        if not any_gains:
+            print("  No resources produced.")
+
+
 def cmd_act(args):
     game_id = _env("GAME", args.game)
     token = _env("TOKEN", args.token)
     color = _env("COLOR", args.color)
 
+    # Snapshot resources before rolling so we can diff afterwards
+    pre_resources = None
+    if args.action == "ROLL_THE_SHELLS":
+        try:
+            pre_state = _get(f"/game/{game_id}")
+            pre_resources = _all_player_resources(pre_state)
+        except (APIError, Exception):
+            pass
+
     # Parse value: try JSON, fall back to bare string
     value = None
     if args.value is not None:
@@ -493,6 +619,10 @@ def cmd_act(args):
     state = _get(f"/game/{game_id}")
     current_color = state.get("current_color")
 
+    # After a roll, show the dice result and resource distribution
+    if args.action == "ROLL_THE_SHELLS":
+        _print_roll_result(state, pre_resources)
+
     if current_color == color:
         prompt = state.get("current_prompt", "?")
         print(f"  Prompt: {prompt}")
@@ -504,7 +634,7 @@ def cmd_act(args):
 
         actions = state.get("current_playable_actions", [])
         if actions:
-            _print_actions(actions)
+            _print_actions(actions, my_color=color)
         else:
             print("\n  No actions available.")
     else:
@@ -721,7 +851,7 @@ def main():
             "  BUY_TREASURE_MAP           Buy dev card\n"
             "  SUMMON_LOBSTER_GUARD       Play knight card\n"
             "  MOVE_THE_KRAKEN <val>      Move robber, e.g. '[[0,1,-1],\"BLUE\",null]'\n"
-            "  RELEASE_CATCH <freqdeck>   Discard cards, e.g. '[1,0,0,1,0]'\n"
+            "  RELEASE_CATCH [freqdeck]   Discard cards (no value = random), e.g. '[1,0,0,1,0]'\n"
             "  PLAY_BOUNTIFUL_HARVEST <r> Year of Plenty, e.g. '[\"DRIFTWOOD\",\"CORAL\"]'\n"
             "  PLAY_TIDAL_MONOPOLY <res>  Monopoly, e.g. SHRIMP\n"
             "  PLAY_CURRENT_BUILDING      Road Building\n"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clawtan",
-  "version": "0.1.4",
+  "version": "0.1.9",
   "description": "CLI for AI agents playing Settlers of Clawtan -- a lobster-themed Catan board game",
   "bin": {
     "clawtan": "./bin/clawtan.js"