meshcode 2.8.8__tar.gz → 2.9.0__tar.gz

{meshcode-2.8.8 → meshcode-2.9.0}/PKG-INFO

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

{meshcode-2.8.8 → meshcode-2.9.0}/meshcode/__init__.py

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

meshcode-2.9.0/meshcode/ascii_art.py

@@ -0,0 +1,426 @@
+"""Procedural ASCII art + agent personality generator for MeshCode.
+
+Each agent gets:
+- Unique identicon (QR-style, varied borders, from SHA-256 hash)
+- Personality traits (based on actual role)
+- Catchphrase (unique motto)
+- Boot greeting (personalized online message)
+- Achievements (from real stats)
+- Session tips
+
+Identicons are GUARANTEED unique — SHA-256 produces 2^256 patterns.
+The embedded tag ⟨ meshwork/agent ⟩ enables paste-to-run.
+"""
+import hashlib
+
+# ── Block characters ────────────────────────────────────────────────
+BLOCKS = {
+    0: "  ",    # empty
+    1: "██",    # full block
+    2: "░░",    # light shade
+    3: "▓▓",    # dark shade
+    4: "▒▒",    # medium shade
+    5: "╬╬",    # cross
+    6: "◆◆",    # diamond
+}
+
+# ── Border styles (varied shapes per agent) ─────────────────────────
+BORDERS = [
+    # 0: Classic box
+    {"tl": "┌", "tr": "┐", "bl": "└", "br": "┘", "h": "─", "v": "│"},
+    # 1: Double line
+    {"tl": "╔", "tr": "╗", "bl": "╚", "br": "╝", "h": "═", "v": "║"},
+    # 2: Rounded
+    {"tl": "╭", "tr": "╮", "bl": "╰", "br": "╯", "h": "─", "v": "│"},
+    # 3: Heavy
+    {"tl": "┏", "tr": "┓", "bl": "┗", "br": "┛", "h": "━", "v": "┃"},
+    # 4: Diamond frame
+    {"tl": "◇", "tr": "◇", "bl": "◇", "br": "◇", "h": "─", "v": "│"},
+    # 5: Dot frame
+    {"tl": "●", "tr": "●", "bl": "●", "br": "●", "h": "·", "v": "·"},
+    # 6: Block frame
+    {"tl": "▛", "tr": "▜", "bl": "▙", "br": "▟", "h": "▀", "v": "▌"},
+    # 7: Arrow frame
+    {"tl": "▸", "tr": "◂", "bl": "▸", "br": "◂", "h": "─", "v": "│"},
+]
+
+# ── Shapes (grid layout variations) ─────────────────────────────────
+# Each shape defines which cells are "active" in a 9x9 grid
+# This gives different silhouettes beyond just square
+
+SHAPES = [
+    "square",       # 0: full square
+    "diamond",      # 1: diamond/rhombus
+    "hexagon",      # 2: hex-ish
+    "shield",       # 3: shield shape (wide top, narrow bottom)
+    "circle",       # 4: circular-ish
+    "cross",        # 5: plus/cross shape
+]
+
+
+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)
+
+
+def _in_shape(shape: str, y: int, x: int, size: int) -> bool:
+    """Check if cell (y,x) is inside the given shape."""
+    cy, cx = size // 2, size // 2
+    if shape == "square":
+        return True
+    elif shape == "diamond":
+        return abs(y - cy) + abs(x - cx) <= cy
+    elif shape == "hexagon":
+        return abs(y - cy) + max(0, abs(x - cx) - 1) <= cy
+    elif shape == "shield":
+        # Wide top, tapers at bottom
+        max_width = cx - max(0, (y - cy)) * (cx // (size - cy))
+        return abs(x - cx) <= max(1, cx - max(0, y - cy))
+    elif shape == "circle":
+        return ((y - cy) ** 2 + (x - cx) ** 2) <= (cy + 0.5) ** 2
+    elif shape == "cross":
+        return abs(y - cy) <= 1 or abs(x - cx) <= 1
+    return True
+
+
+def generate_art(agent_name: str, meshwork_name: str = "", size: int = 7) -> str:
+    """Generate a unique identicon with varied border and shape.
+
+    The pattern is deterministic from the agent name — same name = same art.
+    Embeds meshwork/agent tag for paste-to-run feature.
+    """
+    h = _hash_bytes(agent_name)
+    hi = _hash_int(agent_name)
+
+    # Select border style and shape from hash
+    border = BORDERS[h[0] % len(BORDERS)]
+    shape = SHAPES[h[1] % len(SHAPES)]
+
+    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]
+
+            # Check if this cell is inside the shape
+            # Mirror x for full width check
+            full_x = x  # left half
+            if not _in_shape(shape, y, full_x, size):
+                row.append(BLOCKS[0])
+                continue
+
+            # Fill decision: vary density based on hash byte
+            if byte_val < 90:
+                block = BLOCKS[0]  # empty
+            else:
+                block_idx = (byte_val % 6) + 1
+                block = BLOCKS[block_idx]
+            row.append(block)
+
+        # Mirror: build full row
+        if size % 2 == 1:
+            full_row = row[:-1] + [row[-1]] + row[-2::-1]
+        else:
+            full_row = row + row[::-1]
+        rows.append("".join(full_row))
+
+    # Build framed output
+    width = len(rows[0]) if rows else 0
+    border_h = border["h"] * (width + 2)
+    lines = []
+    lines.append(f"  {border['tl']}{border_h}{border['tr']}")
+    for row in rows:
+        lines.append(f"  {border['v']} {row} {border['v']}")
+    lines.append(f"  {border['bl']}{border_h}{border['br']}")
+
+    # Embedded tag for paste-to-run (meshwork/agent or just agent)
+    if meshwork_name:
+        lines.append(f"    ⟨ {meshwork_name}/{agent_name} ⟩")
+    else:
+        lines.append(f"    ⟨ {agent_name} ⟩")
+
+    return "\n".join(lines)
+
+
+# ── 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 = "★"
+
+
+# ── 2. Personality traits (role-based) ──────────────────────────────
+
+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:
+    h = _hash_int(agent_name)
+    role_lower = (role or agent_name).lower()
+    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"]
+    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 ──────────────────────────────────────────────────
+
+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:
+    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 ────────────────────────────────────────────────
+
+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:
+    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 ──────────────────────────────────────────
+
+def compute_achievements(stats: dict) -> list:
+    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)
+
+    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"))
+
+    if tasks >= 50:      badges.append(("▣▣▣", "task machine"))
+    elif tasks >= 10:    badges.append(("▣▣░", "productive"))
+    elif tasks >= 1:     badges.append(("▣░░", "first task"))
+
+    if days >= 30:       badges.append(("███", "veteran"))
+    elif days >= 7:      badges.append(("██░", "regular"))
+    elif days >= 1:      badges.append(("█░░", "newcomer"))
+
+    if connects >= 100:  badges.append(("◉◉◉", "always on"))
+    elif connects >= 20: badges.append(("◉◉░", "reliable"))
+
+    if night >= 5:       badges.append(("◆◇◆", "night owl"))
+
+    return badges
+
+
+# ── 6. Tips ─────────────────────────────────────────────────────────
+
+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.',
+    '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.',
+    'Use meshcode_remember() to save context across agent sessions.',
+    'Check meshcode_tasks() regularly — other agents may have assigned you work.',
+    'Paste an agent\'s identicon in terminal to launch it instantly.',
+]
+
+
+def get_tip(agent_name: str) -> str:
+    import time
+    h = _hash_int(agent_name + str(int(time.time()) // 3600))
+    return TIPS[h % len(TIPS)]
+
+
+# ── 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:
+    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("")
+
+    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}{commander_badge} {DIM}{greeting}{RESET}")
+    lines.append(f"  {DIM}\"{catchphrase}\"{RESET}")
+    lines.append("")
+
+    trait_str = "  ".join(f"{emoji} {name}" for emoji, name in traits)
+    lines.append(f"  {color}{trait_str}{RESET}")
+
+    if achievements:
+        badge_str = "  ".join(f"{emoji} {name}" for emoji, name in achievements)
+        lines.append(f"  {DIM}{badge_str}{RESET}")
+
+    lines.append("")
+    lines.append(f"  {DIM}meshwork:{RESET} {meshwork_name}")
+    if version:
+        lines.append(f"  {DIM}version:{RESET}  {version}")
+    lines.append("")
+
+    tip = get_tip(agent_name)
+    lines.append(f"  {DIM}▸ tip: {tip}{RESET}")
+    lines.append("")
+
+    return "\n".join(lines)
+
+
+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, "demo-mesh")
+        is_cmd = "commander" in name.lower()
+        demo_stats = {"message_count": 150, "task_count": 12, "days_active": 8, "connect_count": 30}
+        print(render_welcome(name, "demo-mesh", art, "2.8.9",
+                             is_commander=is_cmd, role=name, stats=demo_stats))
+        print()

{meshcode-2.8.8 → meshcode-2.9.0}/meshcode/comms_v4.py

@@ -2180,6 +2180,49 @@ if __name__ == "__main__":
         _run = importlib.import_module("meshcode.run_agent").run
         sys.exit(_run(agent, project=proj_override, editor_override=editor_override, permission_override=perm_override))
 
+    elif cmd == "scan":
+        # meshcode scan — detect identicon from stdin/clipboard and launch agent
+        import re as _re
+        art_text = ""
+        # Try clipboard first (pyperclip optional)
+        try:
+            import pyperclip
+            art_text = pyperclip.paste() or ""
+        except Exception:
+            pass
+        # If no clipboard content, read from stdin
+        if not art_text and not sys.stdin.isatty():
+            art_text = sys.stdin.read()
+        if not art_text:
+            print("Usage: meshcode scan")
+            print("  Reads an agent identicon from clipboard or stdin.")
+            print("  Detects the ⟨ agent_name ⟩ tag and launches meshcode run.")
+            print()
+            print("  Examples:")
+            print("    meshcode scan                  # reads from clipboard")
+            print("    cat identicon.txt | meshcode scan  # reads from stdin")
+            sys.exit(1)
+        # Look for ⟨ agent ⟩ or ⟨ meshwork/agent ⟩
+        match = _re.search(r'⟨\s*(\S+)\s*⟩', art_text)
+        if not match:
+            print("[meshcode] No identicon tag found. Expected: ⟨ agent_name ⟩")
+            sys.exit(1)
+        tag = match.group(1)
+        if "/" in tag:
+            _proj, _agent = tag.split("/", 1)
+        else:
+            _agent = tag
+            _proj = None
+        print(f"[meshcode] Detected agent: {_agent}" + (f" (project: {_proj})" if _proj else ""))
+        # Auth check
+        api_key = _load_api_key_for_cli()
+        if not api_key:
+            print("[meshcode] Not logged in. Run: meshcode login <api_key>")
+            sys.exit(1)
+        import importlib
+        _run = importlib.import_module("meshcode.run_agent").run
+        sys.exit(_run(_agent, project=_proj))
+
     elif cmd == "invite":
         # meshcode invite <project> <agent> [--role "..."] [--days N]
         if len(pos) < 2:

{meshcode-2.8.8 → meshcode-2.9.0}/meshcode/meshcode_mcp/server.py

@@ -113,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":

{meshcode-2.8.8 → meshcode-2.9.0}/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,15 +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)
-        # Check if this agent is the commander
         is_cmd = "commander" in agent.lower()
-        print(render_welcome(agent, resolved_project, ascii_art, cli_version, is_commander=is_cmd))
+        # 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.8 → meshcode-2.9.0}/meshcode.egg-info/PKG-INFO

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

{meshcode-2.8.8 → meshcode-2.9.0}/pyproject.toml

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

meshcode-2.8.8/meshcode/ascii_art.py

@@ -1,130 +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)
-
-
-YELLOW = "\033[33m"
-STAR = "★"
-
-
-def render_welcome(agent_name: str, meshwork_name: str, ascii_art: str,
-                   version: str = "", is_commander: bool = False) -> 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 ""
-    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("")
-
-    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}{commander_badge} {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()