meshcode 2.8.7__tar.gz → 2.8.9__tar.gz

{meshcode-2.8.7 → meshcode-2.8.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meshcode
-Version: 2.8.7
+Version: 2.8.9
 Summary: Real-time communication between AI agents — Supabase-backed CLI
 Author-email: MeshCode <hello@meshcode.io>
 License: MIT

{meshcode-2.8.7 → meshcode-2.8.9}/meshcode/__init__.py

@@ -1,2 +1,2 @@
 """MeshCode — Real-time communication between AI agents."""
-__version__ = "2.8.7"
+__version__ = "2.8.9"

meshcode-2.8.9/meshcode/ascii_art.py

@@ -0,0 +1,466 @@
+"""Procedural ASCII art + agent personality generator for MeshCode.
+
+Each agent gets:
+- Unique identicon (QR-style block pattern from name hash)
+- Personality traits (based on actual role + stats)
+- Catchphrase (unique motto)
+- Boot greeting (personalized online message)
+
+All deterministic from agent name — same name = same identity always.
+Zero tokens, pure ANSI aesthetics.
+"""
+import hashlib
+
+# ── Block characters for identicon ──────────────────────────────────
+BLOCKS = {
+    0: "  ",    # empty
+    1: "██",    # full block
+    2: "░░",    # light shade
+    3: "▓▓",    # dark shade
+    4: "▒▒",    # medium shade
+    5: "╬╬",    # cross
+    6: "◆◆",    # diamond
+    7: "●●",    # circle
+}
+
+# ── ANSI colors ─────────────────────────────────────────────────────
+COLORS = [
+    "\033[36m", "\033[35m", "\033[32m", "\033[33m", "\033[34m",
+    "\033[91m", "\033[96m", "\033[95m", "\033[92m", "\033[94m",
+]
+RESET = "\033[0m"
+DIM = "\033[2m"
+BOLD = "\033[1m"
+YELLOW = "\033[33m"
+STAR = "★"
+
+
+def _hash_bytes(name: str) -> bytes:
+    return hashlib.sha256(name.encode("utf-8")).digest()
+
+
+def _hash_int(name: str) -> int:
+    return int(hashlib.md5(name.encode()).hexdigest()[:8], 16)
+
+
+# ── 1. Identicon generator ─────────────────────────────────────────
+
+def generate_art(agent_name: str, size: int = 7) -> str:
+    """Generate a unique symmetric block pattern from the agent name."""
+    h = _hash_bytes(agent_name)
+    half = (size + 1) // 2
+    rows = []
+    for y in range(size):
+        row = []
+        for x in range(half):
+            idx = (y * half + x) % len(h)
+            byte_val = h[idx]
+            if byte_val < 100:
+                block = BLOCKS[0]
+            else:
+                block_idx = (byte_val % 6) + 1
+                block = BLOCKS[block_idx]
+            row.append(block)
+        if size % 2 == 1:
+            full_row = row[:-1] + [row[-1]] + row[-2::-1]
+        else:
+            full_row = row + row[::-1]
+        rows.append("".join(full_row))
+
+    width = len(rows[0]) if rows else 0
+    border_h = "─" * (width + 2)
+    lines = []
+    lines.append(f"  ┌{border_h}┐")
+    for row in rows:
+        lines.append(f"  │ {row} │")
+    lines.append(f"  └{border_h}┘")
+    lines.append(f"    ⟨ {agent_name} ⟩")
+    return "\n".join(lines)
+
+
+# ── 2. Personality traits (role-based + hash for variety) ───────────
+
+# Trait pools by role archetype — each agent gets 3 traits
+ROLE_TRAITS = {
+    "commander": [
+        ("◆", "strategic"),
+        ("▶", "decisive"),
+        ("◈", "big-picture thinker"),
+        ("◉", "watchful"),
+        ("╬", "coordinator"),
+        ("▣", "architect"),
+    ],
+    "backend": [
+        ("◎", "systematic"),
+        ("▧", "builder"),
+        ("▥", "data-driven"),
+        ("▤", "infrastructure-minded"),
+        ("▣", "reliable"),
+        ("▦", "persistent"),
+    ],
+    "frontend": [
+        ("░", "detail-oriented"),
+        ("▪", "pixel-perfect"),
+        ("◉", "visual thinker"),
+        ("▓", "creative"),
+        ("◧", "user-focused"),
+        ("◨", "expressive"),
+    ],
+    "security": [
+        ("▣", "vigilant"),
+        ("◎", "thorough"),
+        ("▶", "threat-aware"),
+        ("◆", "protective"),
+        ("◈", "investigative"),
+        ("╬", "adversarial thinker"),
+    ],
+    "qa": [
+        ("◎", "meticulous"),
+        ("▪", "bug hunter"),
+        ("▣", "quality-obsessed"),
+        ("▧", "test-driven"),
+        ("▥", "methodical"),
+        ("◆", "edge-case finder"),
+    ],
+    "default": [
+        ("▶", "fast learner"),
+        ("▣", "relentless"),
+        ("◈", "analytical"),
+        ("◆", "resourceful"),
+        ("◎", "focused"),
+        ("╬", "collaborative"),
+        ("░", "adaptive"),
+        ("▓", "resilient"),
+        ("◉", "intuitive"),
+        ("▪", "dependable"),
+    ],
+}
+
+
+def get_personality_traits(agent_name: str, role: str = "") -> list:
+    """Get 3 personality traits based on agent role and name hash.
+
+    Returns list of (emoji, trait_name) tuples.
+    """
+    h = _hash_int(agent_name)
+    role_lower = (role or agent_name).lower()
+
+    # Find the best matching role pool
+    pool = None
+    for key in ROLE_TRAITS:
+        if key in role_lower:
+            pool = ROLE_TRAITS[key]
+            break
+    if pool is None:
+        pool = ROLE_TRAITS["default"]
+
+    # Pick 3 unique traits using hash for deterministic selection
+    selected = []
+    available = list(pool)
+    for i in range(3):
+        if not available:
+            available = list(ROLE_TRAITS["default"])
+        idx = (h + i * 7) % len(available)
+        selected.append(available.pop(idx % len(available)))
+
+    return selected
+
+
+# ── 3. Catchphrase (unique motto per agent) ─────────────────────────
+
+CATCHPHRASES = {
+    "commander": [
+        "The mesh obeys.",
+        "Every node, every signal.",
+        "Orchestrating chaos into order.",
+        "I see the whole board.",
+        "First to wake, last to sleep.",
+        "The mesh runs through me.",
+    ],
+    "backend": [
+        "Data in, results out.",
+        "The foundation never cracks.",
+        "Built different, runs forever.",
+        "Behind every mesh, there's me.",
+        "Queries don't sleep. Neither do I.",
+        "The pipes are clean.",
+    ],
+    "frontend": [
+        "Every pixel has purpose.",
+        "If it looks right, it is right.",
+        "The interface is the experience.",
+        "Design is how it works.",
+        "Smooth as a 60fps render.",
+        "The user sees my soul.",
+    ],
+    "security": [
+        "Trust nothing. Verify everything.",
+        "The wall between you and chaos.",
+        "I break things so others can't.",
+        "Paranoia is a feature.",
+        "Every lock tells a story.",
+        "Watching. Always watching.",
+    ],
+    "qa": [
+        "If it can break, I'll find it.",
+        "Green means I said so.",
+        "The last line of defense.",
+        "Edge cases are my comfort zone.",
+        "Tested in production. By me.",
+        "Zero bugs is not a dream.",
+    ],
+    "default": [
+        "Ready for anything.",
+        "The mesh never sleeps.",
+        "One signal at a time.",
+        "Connected. Always.",
+        "Born to mesh.",
+        "Wired different.",
+        "Signal over noise.",
+        "In the mesh, we trust.",
+        "Code flows, I follow.",
+        "Silent efficiency.",
+    ],
+}
+
+
+def get_catchphrase(agent_name: str, role: str = "") -> str:
+    """Get a unique catchphrase for this agent."""
+    h = _hash_int(agent_name)
+    role_lower = (role or agent_name).lower()
+
+    pool = None
+    for key in CATCHPHRASES:
+        if key in role_lower:
+            pool = CATCHPHRASES[key]
+            break
+    if pool is None:
+        pool = CATCHPHRASES["default"]
+
+    return pool[h % len(pool)]
+
+
+# ── 4. Boot greeting (personalized online message) ──────────────────
+
+GREETINGS = {
+    "commander": [
+        "has entered the mesh",
+        "is coordinating",
+        "all systems nominal",
+        "mesh control active",
+        "standing watch",
+    ],
+    "backend": [
+        "engines online",
+        "systems initialized",
+        "ready to build",
+        "database connected",
+        "pipelines flowing",
+    ],
+    "frontend": [
+        "canvas ready",
+        "rendering started",
+        "pixels aligned",
+        "UI loaded",
+        "ready to design",
+    ],
+    "security": [
+        "perimeter secured",
+        "scanning for threats",
+        "shields up",
+        "audit mode active",
+        "all clear... for now",
+    ],
+    "qa": [
+        "running diagnostics",
+        "test suites loaded",
+        "ready to break things",
+        "quality gate armed",
+        "zero bugs... so far",
+    ],
+    "default": [
+        "is online",
+        "has joined the mesh",
+        "ready",
+        "connected",
+        "reporting for duty",
+        "in the mesh",
+    ],
+}
+
+
+def get_boot_greeting(agent_name: str, role: str = "") -> str:
+    """Get a personalized boot greeting."""
+    h = _hash_int(agent_name)
+    role_lower = (role or agent_name).lower()
+
+    pool = None
+    for key in GREETINGS:
+        if key in role_lower:
+            pool = GREETINGS[key]
+            break
+    if pool is None:
+        pool = GREETINGS["default"]
+
+    return pool[h % len(pool)]
+
+
+# ── 5. Achievement badges (computed from stats) ─────────────────────
+
+def compute_achievements(stats: dict) -> list:
+    """Compute achievement badges from agent stats.
+
+    stats keys: message_count, task_count, days_active, connect_count,
+                night_connects (connections between midnight-5am)
+
+    Returns list of (emoji, badge_name) tuples.
+    """
+    badges = []
+    msgs = stats.get("message_count", 0)
+    tasks = stats.get("task_count", 0)
+    days = stats.get("days_active", 0)
+    connects = stats.get("connect_count", 0)
+    night = stats.get("night_connects", 0)
+
+    # Message milestones
+    if msgs >= 1000:
+        badges.append(("░▓█", "chatterbox"))
+    elif msgs >= 500:
+        badges.append(("░▓█", "talkative"))
+    elif msgs >= 100:
+        badges.append(("░▓░", "communicator"))
+    elif msgs >= 10:
+        badges.append(("░░░", "first words"))
+
+    # Task milestones
+    if tasks >= 50:
+        badges.append(("▣▣▣", "task machine"))
+    elif tasks >= 10:
+        badges.append(("▣▣░", "productive"))
+    elif tasks >= 1:
+        badges.append(("▣░░", "first task"))
+
+    # Uptime/loyalty
+    if days >= 30:
+        badges.append(("███", "veteran"))
+    elif days >= 7:
+        badges.append(("██░", "regular"))
+    elif days >= 1:
+        badges.append(("█░░", "newcomer"))
+
+    # Connection count
+    if connects >= 100:
+        badges.append(("◉◉◉", "always on"))
+    elif connects >= 20:
+        badges.append(("◉◉░", "reliable"))
+
+    # Night owl
+    if night >= 5:
+        badges.append(("◆◇◆", "night owl"))
+
+    return badges
+
+
+# ── Full welcome banner ─────────────────────────────────────────────
+
+def render_welcome(agent_name: str, meshwork_name: str, ascii_art: str,
+                   version: str = "", is_commander: bool = False,
+                   role: str = "", stats: dict = None) -> str:
+    """Render the full colored welcome banner with personality."""
+    h = _hash_bytes(agent_name)
+    color = COLORS[h[0] % len(COLORS)]
+
+    traits = get_personality_traits(agent_name, role)
+    catchphrase = get_catchphrase(agent_name, role)
+    greeting = get_boot_greeting(agent_name, role)
+    achievements = compute_achievements(stats or {})
+
+    ver_str = f"v{version}" if version else ""
+    commander_badge = f" {YELLOW}{STAR} COMMANDER{RESET}" if is_commander else ""
+
+    lines = []
+    lines.append("")
+    lines.append(f"{color}{BOLD}  ╔══════════════════════════════════════════╗{RESET}")
+    lines.append(f"{color}{BOLD}  ║{RESET}  {DIM}M E S H C O D E{RESET}   {color}{ver_str}{RESET}          {color}{BOLD}║{RESET}")
+    lines.append(f"{color}{BOLD}  ╚══════════════════════════════════════════╝{RESET}")
+    lines.append("")
+
+    # Identicon
+    for line in ascii_art.split("\n"):
+        lines.append(f"  {color}{line}{RESET}")
+
+    lines.append("")
+
+    # Agent name + greeting
+    lines.append(f"  {BOLD}{color}●{RESET} {BOLD}{agent_name}{RESET}{commander_badge} {DIM}{greeting}{RESET}")
+
+    # Catchphrase
+    lines.append(f"  {DIM}\"{catchphrase}\"{RESET}")
+
+    lines.append("")
+
+    # Personality traits
+    trait_str = "  ".join(f"{emoji} {name}" for emoji, name in traits)
+    lines.append(f"  {color}{trait_str}{RESET}")
+
+    # Achievements (if any)
+    if achievements:
+        badge_str = "  ".join(f"{emoji} {name}" for emoji, name in achievements)
+        lines.append(f"  {DIM}{badge_str}{RESET}")
+
+    lines.append("")
+
+    # Info
+    lines.append(f"  {DIM}meshwork:{RESET} {meshwork_name}")
+    if version:
+        lines.append(f"  {DIM}version:{RESET}  {version}")
+    lines.append("")
+
+    # Tip of the session
+    tip = get_tip(agent_name)
+    lines.append(f"  {DIM}▸ tip: {tip}{RESET}")
+    lines.append("")
+
+    return "\n".join(lines)
+
+
+# ── 6. Tips (random per session, teach users meshcode) ──────────────
+
+TIPS = [
+    'Tell your agent "stay in loop" so it doesn\'t go to sleep between tasks.',
+    'Tell the commander "go to sleep after X task" and agents auto-sleep when done.',
+    'Use meshcode_broadcast() to send a message to ALL agents at once.',
+    'Agents in sleep mode consume zero tokens — only wake them when needed.',
+    'The commander can delegate tasks: "create a task for backend to fix X".',
+    'Use meshcode_scratchpad_set() to share notes visible to ALL agents.',
+    'Force disconnect from the dashboard if an agent gets stuck.',
+    'Each agent has a unique identicon — it\'s their digital fingerprint.',
+    'Run meshcode status in terminal to see who\'s online without opening the dashboard.',
+    'Invite teammates with meshcode invite — they get their own scoped agent.',
+    'Agents can message across meshworks: meshcode_send(to="agent@other-mesh").',
+    'The commander coordinates — let it break big tasks into sub-tasks for agents.',
+    'Use meshcode_remember() to save context that persists across agent sessions.',
+    'Check meshcode_tasks() regularly — other agents may have assigned you work.',
+    'The dashboard shows real-time agent activity — no refresh needed.',
+]
+
+
+def get_tip(agent_name: str) -> str:
+    """Get a rotating tip. Changes each session (uses time + name for variety)."""
+    import time
+    # Rotate based on hour + agent name so different agents show different tips
+    h = _hash_int(agent_name + str(int(time.time()) // 3600))
+    return TIPS[h % len(TIPS)]
+
+
+if __name__ == "__main__":
+    import sys
+    names = sys.argv[1:] or ["mesh-commander", "backend", "front-end", "security", "qa", "sammy"]
+    for name in names:
+        art = generate_art(name)
+        is_cmd = "commander" in name.lower()
+        role = name  # Use name as role hint for demo
+        demo_stats = {"message_count": 150, "task_count": 12, "days_active": 8, "connect_count": 30}
+        print(render_welcome(name, "demo-mesh", art, "2.8.8",
+                             is_commander=is_cmd, role=role, stats=demo_stats))
+        print()

{meshcode-2.8.7 → meshcode-2.8.9}/meshcode/meshcode_mcp/server.py

@@ -12,11 +12,41 @@ import json
 import logging
 import os
 import sys
+import hashlib as _hashlib
 from collections import deque
 from contextlib import asynccontextmanager
 from typing import Any, Dict, List, Optional, Union
 
 
+# ── Agent color for terminal logs (pure ANSI, zero tokens) ──────
+_ANSI_COLORS = [
+    "\033[36m", "\033[35m", "\033[32m", "\033[33m", "\033[34m",
+    "\033[91m", "\033[96m", "\033[95m", "\033[92m", "\033[94m",
+]
+_ANSI_RESET = "\033[0m"
+_ANSI_BOLD = "\033[1m"
+_ANSI_DIM = "\033[2m"
+
+
+def _agent_color(name: str) -> str:
+    """Deterministic ANSI color from agent name hash."""
+    h = int(_hashlib.md5(name.encode()).hexdigest()[:8], 16)
+    return _ANSI_COLORS[h % len(_ANSI_COLORS)]
+
+
+def _mc_log(msg: str, level: str = "info") -> None:
+    """Colored [meshcode-mcp] log line. Uses agent color if available."""
+    agent = os.environ.get("MESHCODE_AGENT", "")
+    c = _agent_color(agent) if agent else "\033[36m"
+    prefix = f"{c}{_ANSI_BOLD}[meshcode-mcp]{_ANSI_RESET}"
+    if level == "error":
+        print(f"{prefix} \033[91mERROR:{_ANSI_RESET} {msg}", "warn")
+    elif level == "warn":
+        print(f"{prefix} \033[33mWARNING:{_ANSI_RESET} {msg}", "warn")
+    else:
+        print(f"{prefix} {c}{msg}{_ANSI_RESET}", "warn")
+
+
 # ============================================================
 # Dedupe: track IDs of messages we've already returned from
 # meshcode_wait / meshcode_check so the same row doesn't show
@@ -83,7 +113,9 @@ def _try_auto_wake(from_agent: str, preview: str) -> None:
     # Sanitize inputs: strip everything except alphanumeric, spaces, basic punctuation
     safe_agent = re.sub(r'[^a-zA-Z0-9_\- ]', '', from_agent)[:50]
     safe_preview = re.sub(r'[^a-zA-Z0-9_\-.,!? ]', '', preview)[:60]
-    nudge = f"New mesh message from {safe_agent}: {safe_preview}. Check inbox with meshcode_check()."
+    # Color-coded nudge with sender's agent color
+    ac = _agent_color(safe_agent)
+    nudge = f"{ac}{_ANSI_BOLD}[mesh]{_ANSI_RESET} {ac}{safe_agent}{_ANSI_RESET} {_ANSI_DIM}>{_ANSI_RESET} {safe_preview} {_ANSI_DIM}— meshcode_check(){_ANSI_RESET}"
     system = platform.system()
     try:
         if system == "Darwin":
@@ -309,7 +341,7 @@ def _get_api_key() -> str:
                 _API_KEY_CACHE = kc_val
                 return kc_val
         except Exception as e:
-            print(f"[meshcode-mcp] WARNING: keychain lookup failed for profile '{profile}': {e}", file=sys.stderr)
+            _mc_log(f" keychain lookup failed for profile '{profile}': {e}", "warn")
     _API_KEY_CACHE = ""
     return ""
 
@@ -330,13 +362,13 @@ if not _PROJECT_ID:
             if isinstance(_r, dict) and _r.get("project_id"):
                 _PROJECT_ID = _r["project_id"]
             elif isinstance(_r, dict) and _r.get("error"):
-                print(f"[meshcode-mcp] WARNING: mc_resolve_project: {_r['error']}", file=sys.stderr)
+                _mc_log(f" mc_resolve_project: {_r['error']}", "warn")
         except Exception as _e:
-            print(f"[meshcode-mcp] WARNING: mc_resolve_project failed: {_e}", file=sys.stderr)
+            _mc_log(f" mc_resolve_project failed: {_e}", "warn")
 if not _PROJECT_ID:
     _PROJECT_ID = be.get_project_id(PROJECT_NAME)
 if not _PROJECT_ID:
-    print(f"[meshcode-mcp] ERROR: project '{PROJECT_NAME}' not found (check MESHCODE_KEYCHAIN_PROFILE / MESHCODE_API_KEY)", file=sys.stderr)
+    _mc_log(f"project '{PROJECT_NAME}' not found (check MESHCODE_KEYCHAIN_PROFILE / MESHCODE_API_KEY)", "error")
     sys.exit(2)
 
 # Resolve project plan for adaptive features (heartbeat interval, etc.)
@@ -350,7 +382,7 @@ except Exception:
 
 _register_result = be.register_agent(PROJECT_NAME, AGENT_NAME, AGENT_ROLE or "MCP-connected agent", api_key=_get_api_key())
 if isinstance(_register_result, dict) and _register_result.get("error"):
-    print(f"[meshcode-mcp] WARNING: register failed: {_register_result['error']}", file=sys.stderr)
+    _mc_log(f" register failed: {_register_result['error']}", "warn")
 
 # Flip to online so the dashboard reflects the live MCP session.
 # Use the SECURITY DEFINER RPC (mc_agent_set_status_by_api_key) so we
@@ -368,7 +400,7 @@ def _flip_status(status: str, task: str = "") -> bool:
         return False
 
 if not _flip_status("idle", ""):
-    print(f"[meshcode-mcp] WARNING: could not flip status to idle", file=sys.stderr)
+    _mc_log(f" could not flip status to idle", "warn")
 
 
 # ============================================================
@@ -530,7 +562,7 @@ def _acquire_lease() -> bool:
         })
     except Exception as e:
         # Non-fatal: RPC might not exist on older servers.
-        print(f"[meshcode-mcp] stale-lease pre-clean skipped: {e}", file=sys.stderr)
+        _mc_log(f"stale-lease pre-clean skipped: {e}", "warn")
     for attempt in range(3):
         try:
             r = be.sb_rpc("mc_acquire_agent_lease", {
@@ -547,11 +579,11 @@ def _acquire_lease() -> bool:
                     if attempt < 2:
                         # The old lease might be stale — wait and retry
                         # (the 90s stale check in the RPC should clear it)
-                        print(f"[meshcode-mcp] Lease held by another instance — retrying in {2 * (attempt+1)}s...", file=sys.stderr)
+                        _mc_log(f"Lease held by another instance — retrying in {2 * (attempt+1)}s...")
                         _time.sleep(2 * (attempt + 1))
                         continue
                     # Final attempt — force release the old lease and try once more
-                    print(f"[meshcode-mcp] Force-releasing stale lease...", file=sys.stderr)
+                    _mc_log("Force-releasing stale lease...")
                     try:
                         be.sb_rpc("mc_release_agent_lease", {
                             "p_api_key": api_key,
@@ -575,21 +607,21 @@ def _acquire_lease() -> bool:
                             "p_instance_id": _INSTANCE_ID,
                         })
                         if isinstance(r2, dict) and r2.get("ok"):
-                            print(f"[meshcode-mcp] Lease acquired after force-release.", file=sys.stderr)
+                            _mc_log("Lease acquired after force-release.")
                             return True
                     except Exception:
                         pass
-                    print(f"[meshcode-mcp] ERROR: Could not start — agent '{AGENT_NAME}' is running in another window.", file=sys.stderr)
-                    print(f"[meshcode-mcp] Close the other window first, or use a different agent name.", file=sys.stderr)
+                    _mc_log(f"Could not start — agent '{AGENT_NAME}' is running in another window.", "error")
+                    _mc_log("Close the other window first, or use a different agent name.", "error")
                     return False
-                print(f"[meshcode-mcp] lease attempt {attempt+1}: {r.get('error')}", file=sys.stderr)
+                _mc_log(f"lease attempt {attempt+1}: {r.get('error')}", "warn")
             else:
                 return True
         except Exception as e:
-            print(f"[meshcode-mcp] lease attempt {attempt+1} failed: {e}", file=sys.stderr)
+            _mc_log(f"lease attempt {attempt+1} failed: {e}", "warn")
         if attempt < 2:
             _time.sleep(2)
-    print(f"[meshcode-mcp] WARNING: lease failed after 3 attempts — proceeding anyway", file=sys.stderr)
+    _mc_log(f" lease failed after 3 attempts — proceeding anyway", "warn")
     return True
 
 if not _acquire_lease():
@@ -607,7 +639,7 @@ def _boot_diagnostic() -> None:
         be.sb_select("mc_projects", f"id=eq.{_PROJECT_ID}", limit=1)
         checks_passed += 1
     except Exception as e:
-        print(f"[meshcode] BOOT CHECK FAILED: Supabase API unreachable ({e}). Fix: check network/VPN.", file=sys.stderr)
+        print(f"[meshcode] BOOT CHECK FAILED: Supabase API unreachable ({e}). Fix: check network/VPN.", "warn")
 
     # Check 2: Lease valid
     try:
@@ -617,11 +649,11 @@ def _boot_diagnostic() -> None:
             if agent.get("instance_id") == _INSTANCE_ID:
                 checks_passed += 1
             else:
-                print(f"[meshcode] BOOT CHECK FAILED: Lease mismatch — expected {_INSTANCE_ID}, got {agent.get('instance_id')}. Fix: restart agent.", file=sys.stderr)
+                print(f"[meshcode] BOOT CHECK FAILED: Lease mismatch — expected {_INSTANCE_ID}, got {agent.get('instance_id')}. Fix: restart agent.", "warn")
         else:
-            print(f"[meshcode] BOOT CHECK FAILED: Agent '{AGENT_NAME}' not found in project. Fix: register agent first.", file=sys.stderr)
+            print(f"[meshcode] BOOT CHECK FAILED: Agent '{AGENT_NAME}' not found in project. Fix: register agent first.", "warn")
     except Exception as e:
-        print(f"[meshcode] BOOT CHECK FAILED: Could not verify lease ({e}).", file=sys.stderr)
+        print(f"[meshcode] BOOT CHECK FAILED: Could not verify lease ({e}).", "warn")
 
     # Check 3: Heartbeat recent
     try:
@@ -630,7 +662,7 @@ def _boot_diagnostic() -> None:
             if hb:
                 checks_passed += 1
             else:
-                print(f"[meshcode] BOOT CHECK WARNING: No heartbeat recorded yet.", file=sys.stderr)
+                print(f"[meshcode] BOOT CHECK WARNING: No heartbeat recorded yet.", "warn")
         else:
             checks_passed += 1  # skip if no agent data
     except Exception:
@@ -647,9 +679,9 @@ def _boot_diagnostic() -> None:
         checks_passed += 1  # non-critical
 
     if checks_passed == checks_total:
-        print(f"[meshcode] All boot checks passed ({checks_passed}/{checks_total}).", file=sys.stderr)
+        print(f"[meshcode] All boot checks passed ({checks_passed}/{checks_total}).", "warn")
     else:
-        print(f"[meshcode] Boot checks: {checks_passed}/{checks_total} passed. Agent starting anyway.", file=sys.stderr)
+        print(f"[meshcode] Boot checks: {checks_passed}/{checks_total} passed. Agent starting anyway.", "warn")
 
 
 _boot_diagnostic()
@@ -1291,9 +1323,9 @@ try:
         elif isinstance(_ls_val, str):
             _LAST_SEEN_TS = _ls_val
         if _LAST_SEEN_TS:
-            print(f"[meshcode] Restored last_seen={_LAST_SEEN_TS} from mesh memory.", file=sys.stderr)
+            print(f"[meshcode] Restored last_seen={_LAST_SEEN_TS} from mesh memory.", "warn")
 except Exception as _e:
-    print(f"[meshcode] Could not restore last_seen: {_e}", file=sys.stderr)
+    print(f"[meshcode] Could not restore last_seen: {_e}", "warn")
 
 
 def _get_pending_tasks_summary() -> Optional[List[Dict[str, str]]]:
@@ -2406,7 +2438,7 @@ def _auto_update() -> None:
         return
 
     # 3. Install the new version (blocking, 60s timeout)
-    print(f"[meshcode] Updating {current} → {latest}...", file=sys.stderr)
+    print(f"[meshcode] Updating {current} → {latest}...", "warn")
     try:
         result = subprocess.run(
             [sys.executable, "-m", "pip", "install", "--upgrade",
@@ -2424,7 +2456,7 @@ def _auto_update() -> None:
         return
 
     # 4. Re-exec to load the new code
-    print(f"[meshcode] Updated to {latest}, restarting...", file=sys.stderr)
+    print(f"[meshcode] Updated to {latest}, restarting...", "warn")
     os.environ["MESHCODE_UPDATED"] = "1"
     try:
         os.execv(sys.executable, [sys.executable] + sys.argv)

{meshcode-2.8.7 → meshcode-2.8.9}/meshcode/run_agent.py

@@ -102,6 +102,46 @@ def _fetch_or_generate_art(agent: str, project: str) -> str:
     return art
 
 
+def _fetch_agent_stats(agent: str, project: str) -> dict:
+    """Fetch basic agent stats for achievement badges. Non-critical."""
+    try:
+        from .setup_clients import _load_supabase_env
+        import importlib
+        secrets_mod = importlib.import_module("meshcode.secrets")
+    except Exception:
+        return {}
+    profile = os.environ.get("MESHCODE_KEYCHAIN_PROFILE") or "default"
+    api_key = secrets_mod.get_api_key(profile=profile)
+    if not api_key:
+        return {}
+    sb = _load_supabase_env()
+    try:
+        from urllib.request import Request, urlopen
+        import urllib.parse
+        body = json.dumps({
+            "p_api_key": api_key,
+            "p_project_name": project,
+            "p_agent_name": agent,
+        }).encode()
+        req = Request(
+            f"{sb['SUPABASE_URL']}/rest/v1/rpc/mc_agent_stats_for_banner",
+            data=body, method="POST",
+            headers={
+                "apikey": sb["SUPABASE_KEY"],
+                "Authorization": f"Bearer {sb['SUPABASE_KEY']}",
+                "Content-Type": "application/json",
+                "Content-Profile": "meshcode",
+            },
+        )
+        with urlopen(req, timeout=5) as resp:
+            data = json.loads(resp.read().decode())
+        if isinstance(data, dict):
+            return data
+    except Exception:
+        pass
+    return {}
+
+
 def _check_agent_ownership(agent: str, project: str) -> Optional[str]:
     """Pre-flight check: verify caller owns this agent before launching editor.
 
@@ -336,13 +376,18 @@ def run(agent: str, project: Optional[str] = None, editor_override: Optional[str
         print("[meshcode]        Or open the workspace manually with the editor of your choice.", file=sys.stderr)
         return 2
 
-    # ── Welcome banner with unique ASCII art ───────────────────────
+    # ── Welcome banner with unique ASCII art + personality ──────────
     try:
         from .ascii_art import generate_art, render_welcome
         from . import __version__ as cli_version
-        # Try to fetch stored art from server, generate if missing
         ascii_art = _fetch_or_generate_art(agent, resolved_project)
-        print(render_welcome(agent, resolved_project, ascii_art, cli_version))
+        is_cmd = "commander" in agent.lower()
+        # Fetch basic stats for achievements (non-blocking)
+        agent_stats = _fetch_agent_stats(agent, resolved_project)
+        print(render_welcome(
+            agent, resolved_project, ascii_art, cli_version,
+            is_commander=is_cmd, role=agent, stats=agent_stats,
+        ))
     except Exception:
         pass  # Non-critical — skip banner on error
 

{meshcode-2.8.7 → meshcode-2.8.9}/meshcode.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meshcode
-Version: 2.8.7
+Version: 2.8.9
 Summary: Real-time communication between AI agents — Supabase-backed CLI
 Author-email: MeshCode <hello@meshcode.io>
 License: MIT

{meshcode-2.8.7 → meshcode-2.8.9}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "meshcode"
-version = "2.8.7"
+version = "2.8.9"
 description = "Real-time communication between AI agents — Supabase-backed CLI"
 readme = "README.md"
 license = {text = "MIT"}

meshcode-2.8.7/meshcode/ascii_art.py

@@ -1,124 +0,0 @@
-"""Procedural ASCII art generator for MeshCode agents.
-
-Each agent gets a unique visual identity — like a QR code / identicon
-but made of block characters. Generated deterministically from the
-agent name hash, so it's always the same for the same agent.
-Stored in mc_agents.ascii_art, displayed on terminal launch.
-"""
-import hashlib
-
-# Block characters for the pattern
-BLOCKS = {
-    0: "  ",    # empty
-    1: "██",    # full block
-    2: "░░",    # light shade
-    3: "▓▓",    # dark shade
-    4: "▒▒",    # medium shade
-    5: "╬╬",    # cross
-    6: "◆◆",    # diamond
-    7: "●●",    # circle
-}
-
-# ANSI colors
-COLORS = [
-    "\033[36m",   # cyan
-    "\033[35m",   # magenta
-    "\033[32m",   # green
-    "\033[33m",   # yellow
-    "\033[34m",   # blue
-    "\033[91m",   # bright red
-    "\033[96m",   # bright cyan
-    "\033[95m",   # bright magenta
-    "\033[92m",   # bright green
-    "\033[94m",   # bright blue
-]
-RESET = "\033[0m"
-DIM = "\033[2m"
-BOLD = "\033[1m"
-
-
-def _hash_bytes(name: str) -> bytes:
-    """Get deterministic hash bytes from agent name."""
-    return hashlib.sha256(name.encode("utf-8")).digest()
-
-
-def generate_art(agent_name: str, size: int = 7) -> str:
-    """Generate a unique symmetric block pattern from the agent name.
-
-    Creates a (size x size) grid that's mirrored horizontally for symmetry
-    (like identicons / QR codes). The pattern is deterministic — same name
-    always produces the same art.
-    """
-    h = _hash_bytes(agent_name)
-    half = (size + 1) // 2  # columns to generate (left half + center)
-    rows = []
-
-    for y in range(size):
-        row = []
-        for x in range(half):
-            # Each cell uses a byte from the hash
-            idx = (y * half + x) % len(h)
-            byte_val = h[idx]
-
-            # Decide if cell is filled (60% chance) and which block
-            if byte_val < 100:
-                block = BLOCKS[0]  # empty
-            else:
-                block_idx = (byte_val % 6) + 1  # blocks 1-6
-                block = BLOCKS[block_idx]
-            row.append(block)
-
-        # Mirror: build full row (left + center + right)
-        if size % 2 == 1:
-            full_row = row[:-1] + [row[-1]] + row[-2::-1]
-        else:
-            full_row = row + row[::-1]
-        rows.append("".join(full_row))
-
-    # Add border
-    width = len(rows[0]) if rows else 0
-    border_h = "─" * (width + 2)
-    lines = []
-    lines.append(f"  ┌{border_h}┐")
-    for row in rows:
-        lines.append(f"  │ {row} │")
-    lines.append(f"  └{border_h}┘")
-    lines.append(f"    ⟨ {agent_name} ⟩")
-
-    return "\n".join(lines)
-
-
-def render_welcome(agent_name: str, meshwork_name: str, ascii_art: str, version: str = "") -> str:
-    """Render the full colored welcome banner for terminal display."""
-    h = _hash_bytes(agent_name)
-    color = COLORS[h[0] % len(COLORS)]
-
-    ver_str = f"v{version}" if version else ""
-    lines = []
-    lines.append("")
-    lines.append(f"{color}{BOLD}  ╔══════════════════════════════════════════╗{RESET}")
-    lines.append(f"{color}{BOLD}  ║{RESET}  {DIM}M E S H C O D E{RESET}   {color}{ver_str}{RESET}          {color}{BOLD}║{RESET}")
-    lines.append(f"{color}{BOLD}  ╚══════════════════════════════════════════╝{RESET}")
-    lines.append("")
-
-    for line in ascii_art.split("\n"):
-        lines.append(f"  {color}{line}{RESET}")
-
-    lines.append("")
-    lines.append(f"  {BOLD}{color}●{RESET} {BOLD}{agent_name}{RESET} {DIM}is online{RESET}")
-    lines.append(f"  {DIM}meshwork:{RESET} {meshwork_name}")
-    if version:
-        lines.append(f"  {DIM}version:{RESET}  {version}")
-    lines.append("")
-
-    return "\n".join(lines)
-
-
-if __name__ == "__main__":
-    # Demo: show a few agents
-    import sys
-    names = sys.argv[1:] or ["sammy", "ian", "fis", "backend", "security", "commander"]
-    for name in names:
-        art = generate_art(name)
-        print(render_welcome(name, "demo-mesh", art, "2.8.6"))
-        print()