claude-nb 0.3.0

package/bin/init

@@ -0,0 +1,316 @@
+#!/usr/bin/env python3
+"""cnb init — initialize a project for multi-agent coordination."""
+
+import hashlib
+import json
+import re
+import sqlite3
+import sys
+from pathlib import Path
+
+# Ensure lib/ is importable (needed for migration runner)
+_script = Path(__file__).resolve()
+CLAUDES_HOME = _script.parent.parent
+if str(CLAUDES_HOME) not in sys.path:
+    sys.path.insert(0, str(CLAUDES_HOME))
+
+# ── Session name validation ──
+
+VALID_NAME = re.compile(r"^[a-z0-9](?:[a-z0-9_-]{0,62}[a-z0-9])?$")
+RESERVED_NAMES: frozenset[str] = frozenset({"all", "dispatcher", "system"})
+MAX_NAME_LEN = 64
+
+
+def _validate_name(name: str) -> str:
+    """Validate and lowercase a session name. Raises SystemExit on invalid input."""
+    clean = name.strip().lower()
+    if not clean:
+        print("ERROR: empty session name")
+        raise SystemExit(1)
+    if len(clean) > MAX_NAME_LEN:
+        print(f"ERROR: session name too long (max {MAX_NAME_LEN} chars): {name}")
+        raise SystemExit(1)
+    if clean in RESERVED_NAMES:
+        print(f"ERROR: '{clean}' is a reserved name. Choose another.")
+        raise SystemExit(1)
+    if not VALID_NAME.match(clean):
+        print(f"ERROR: invalid session name '{name}'. Use a-z, 0-9, hyphens, underscores.")
+        print("       Example: cnb init alice bob charlie")
+        raise SystemExit(1)
+    return clean
+
+
+MARKER_START = "<!-- cnb:start -->"
+MARKER_END = "<!-- cnb:end -->"
+
+
+def _claude_md_snippet(sessions: list[str], claudes_home: Path, personas: dict[str, str] | None = None) -> str:
+    board = f"{claudes_home}/bin/board"
+    lines = [
+        MARKER_START,
+        "## Multi-Agent Coordination",
+        "",
+        "This project uses cnb for multi-session coordination.",
+        "",
+        "### Session Startup",
+        "",
+        "You are a session. Your name is passed via `--name` when Claude Code starts.",
+        "On startup:",
+        "```bash",
+        f"{board} --as <your-name> inbox",
+        "```",
+        "",
+        "### Commands",
+        "",
+        "```bash",
+        f'{board} --as <name> send <to> "<msg>"    # message (person or "all")',
+        f"{board} --as <name> inbox                # check unread",
+        f"{board} --as <name> ack                  # clear inbox",
+        f'{board} --as <name> status "<desc>"      # update current task',
+        f'{board} --as <name> task add "<desc>"    # add task',
+        f"{board} --as <name> task done            # finish current task",
+        f"{board} --as <name> view                 # board overview",
+        f'{board} --as <name> bug report P1 "desc" # report bug',
+        f'{board} --as <name> send all "msg"       # broadcast',
+        "```",
+        "",
+        "### Rules",
+        "",
+        "- Check inbox at startup and after completing each task.",
+        "- Update status when you start or finish work.",
+        "- Commit immediately after each logical change.",
+        "- Message others via `send`, not by editing their files.",
+        "",
+        "### Sessions",
+        "",
+    ]
+    for s in sessions:
+        p = (personas or {}).get(s, "")
+        if p:
+            lines.append(f"- **{s}** — {p.splitlines()[0]}")
+        else:
+            lines.append(f"- **{s}**")
+    lines.append(MARKER_END)
+    return "\n".join(lines) + "\n"
+
+
+def _update_claude_md(project_dir: Path, snippet: str) -> None:
+    md_path = project_dir / "CLAUDE.md"
+    if md_path.exists():
+        text = md_path.read_text()
+        if MARKER_START in text:
+            import re
+
+            text = re.sub(
+                rf"{re.escape(MARKER_START)}.*?{re.escape(MARKER_END)}\n?",
+                snippet,
+                text,
+                flags=re.DOTALL,
+            )
+        else:
+            text = text.rstrip("\n") + "\n\n" + snippet
+        md_path.write_text(text)
+    else:
+        md_path.write_text(snippet)
+
+
+def _hook_command(claudes_home: Path) -> str:
+    board = f"{claudes_home}/bin/board"
+    return (
+        f'if [ -n "$CLAUDE_SESSION_NAME" ]; then '
+        f"unread=$({board} --as $CLAUDE_SESSION_NAME inbox 2>/dev/null "
+        f"| grep -oE '[0-9]+ 条未读' | head -1); "
+        f'[ -n "$unread" ] && echo "[inbox] $unread" || true; fi'
+    )
+
+
+def _update_settings(project_dir: Path, claudes_home: Path) -> None:
+    settings_dir = project_dir / ".claude"
+    settings_dir.mkdir(exist_ok=True)
+    settings_path = settings_dir / "settings.json"
+
+    hook_entry = {
+        "matcher": "",
+        "hooks": [{"type": "command", "command": _hook_command(claudes_home)}],
+    }
+
+    if settings_path.exists():
+        try:
+            settings = json.loads(settings_path.read_text())
+        except (json.JSONDecodeError, ValueError):
+            settings = {}
+    else:
+        settings = {}
+
+    hooks = settings.setdefault("hooks", {})
+    post_batch = hooks.setdefault("PostToolBatch", [])
+
+    already = any(
+        isinstance(h, dict)
+        and any(
+            "board" in sub.get("command", "") and "inbox" in sub.get("command", "")
+            for sub in h.get("hooks", [])
+            if isinstance(sub, dict)
+        )
+        for h in post_batch
+    )
+    if not already:
+        post_batch.append(hook_entry)
+
+    settings_path.write_text(json.dumps(settings, indent=2, ensure_ascii=False) + "\n")
+
+
+def _create_slash_commands(project_dir: Path, claudes_home: Path) -> None:
+    cmd_dir = project_dir / ".claude" / "commands"
+    cmd_dir.mkdir(parents=True, exist_ok=True)
+
+    board = f"{claudes_home}/bin/board"
+    swarm = f"{claudes_home}/bin/swarm"
+
+    commands = {
+        "cs-team": f"运行 `{swarm} status` 和 `{board} --as lead view`，用简洁的表格告诉我每个同学的状态。",
+        "cs-inbox": f"运行 `{board} --as lead inbox`，把收到的消息汇总给我。",
+        "cs-broadcast": f'把以下消息广播给所有同学：\n`{board} --as lead send all "$ARGUMENTS"`',
+        "cs-assign": f'把任务分配给指定同学。参数格式：<名字> <任务描述>\n解析 $ARGUMENTS，运行 `{board} --as lead send <名字> "<任务描述>"`',
+        "cs-kick": f"让指定同学下线。解析 $ARGUMENTS 拿到名字，运行 `{swarm} stop $ARGUMENTS`",
+        "cs-add": f"拉新同学上线。解析 $ARGUMENTS 拿到名字，运行 `{swarm} start $ARGUMENTS`",
+        "cs-log": f"查看指定同学最近的工作日志。解析 $ARGUMENTS 拿到名字，运行 `{board} --as lead view` 并重点关注该同学的状态和最近消息。",
+        "cs-stop": f"停掉所有后台同学。运行 `{swarm} stop`，告诉用户已全部下线。",
+        "cs-bugs": f"运行 `{board} --as lead bug list`，汇总当前所有 bug。",
+        "cs-history": f"运行 `{board} --as lead log 50`，把完整的消息历史展示给我。",
+        "cs-update": "运行 `pip install --upgrade cnb`，更新到最新版本。把结果告诉我，如果更新成功提醒用户重启 cnb 以生效。",
+        "cs-help": "列出所有 /cs-* 命令及用途：\n"
+        "- /cs-team — 看同学状态\n"
+        "- /cs-inbox — 查收消息\n"
+        "- /cs-broadcast <消息> — 广播\n"
+        "- /cs-assign <名字> <任务> — 派任务\n"
+        "- /cs-add <名字> — 拉同学上线\n"
+        "- /cs-kick <名字> — 让同学下线\n"
+        "- /cs-log <名字> — 看同学工作日志\n"
+        "- /cs-stop — 全部下线\n"
+        "- /cs-bugs — 看 bug 列表\n"
+        "- /cs-history — 查看完整消息历史\n"
+        "- /cs-update — 更新到最新版\n"
+        "- /cs-help — 本帮助",
+    }
+
+    for name, content in commands.items():
+        (cmd_dir / f"{name}.md").write_text(content + "\n")
+
+
+DEFAULT_SESSIONS = ["s1", "s2", "s3"]
+
+
+def _load_team_toml(path: Path) -> tuple[list[str], dict[str, str]]:
+    """Load a team definition TOML file. Returns (session_names, {name: persona})."""
+    import tomllib
+
+    data = tomllib.loads(path.read_text())
+    personas: dict[str, str] = {}
+    sessions: list[str] = []
+    for name, info in data.get("session", {}).items():
+        clean = _validate_name(name)
+        sessions.append(clean)
+        if isinstance(info, dict) and info.get("persona"):
+            personas[clean] = info["persona"]
+    return sessions, personas
+
+
+def main() -> None:
+    raw_sessions: list[str] = sys.argv[1:]
+
+    team_file: Path | None = None
+    personas: dict[str, str] = {}
+
+    # Check for --team flag
+    if "--team" in raw_sessions:
+        idx = raw_sessions.index("--team")
+        if idx + 1 < len(raw_sessions):
+            team_file = Path(raw_sessions[idx + 1])
+            if not team_file.exists():
+                print(f"ERROR: team file not found: {team_file}")
+                raise SystemExit(1)
+            raw_sessions = raw_sessions[:idx] + raw_sessions[idx + 2 :]
+        else:
+            print("ERROR: --team requires a path")
+            raise SystemExit(1)
+
+    if team_file:
+        sessions, personas = _load_team_toml(team_file)
+    elif raw_sessions:
+        sessions = [_validate_name(s) for s in raw_sessions]
+    else:
+        sessions = list(DEFAULT_SESSIONS)
+    project_dir = Path.cwd()
+    claudes_dir = project_dir / ".claudes"
+    claudes_home = CLAUDES_HOME
+
+    if (claudes_dir / "board.db").exists():
+        print(f"Already initialized: {claudes_dir}")
+        sys.exit(0)
+
+    # Create directory structure
+    for subdir in ("sessions", "files", "okr", "cv", "logs"):
+        (claudes_dir / subdir).mkdir(parents=True, exist_ok=True)
+
+    # Generate short unique prefix from project path
+    project_hash = hashlib.sha256(str(project_dir).encode()).hexdigest()[:4]
+    prefix = f"cc-{project_hash}"
+
+    # Generate config.toml
+    sessions_toml = ", ".join(f'"{s}"' for s in sessions)
+    toml_lines = [
+        f'claudes_home = "{claudes_home}"',
+        f"sessions = [{sessions_toml}]",
+        f'prefix = "{prefix}"',
+        "",
+    ]
+    for s in sessions:
+        toml_lines.append(f"[session.{s}]")
+        p = personas.get(s, "")
+        toml_lines.append(f'persona = """{p}"""' if "\n" in p else f'persona = "{p}"')
+        toml_lines.append("")
+    (claudes_dir / "config.toml").write_text("\n".join(toml_lines) + "\n")
+
+    # Initialize SQLite database from schema.sql
+    schema_file = claudes_home / "schema.sql"
+    db_path = claudes_dir / "board.db"
+    conn = sqlite3.connect(str(db_path))
+    conn.execute("PRAGMA journal_mode=WAL;")
+    conn.execute("PRAGMA foreign_keys=ON;")
+    conn.executescript(schema_file.read_text())
+    # Insert sessions + pseudo-session 'all' for broadcast FK references
+    conn.execute("INSERT OR IGNORE INTO sessions(name, status) VALUES ('all', 'system')")
+    for name in sessions:
+        n = name.lower()
+        persona = personas.get(n, "")
+        conn.execute("INSERT OR IGNORE INTO sessions(name, persona) VALUES (?, ?)", (n, persona))
+        persona_section = f"\n## Persona\n{persona}\n" if persona else ""
+        md_content = f"# {n}\n{persona_section}\n## Current task\n(none)\n\n## @inbox\n"
+        (claudes_dir / "sessions" / f"{n}.md").write_text(md_content)
+    conn.execute("INSERT OR IGNORE INTO meta(key, value) VALUES ('dispatcher_session', 'dispatcher')")
+    # Record schema version so migration runner knows where we are
+    conn.execute("INSERT OR IGNORE INTO meta(key, value) VALUES ('schema_version', '2')")
+    conn.commit()
+    conn.close()
+
+    # Run any pending migrations (idempotent)
+    from lib.migrate import run_migrations
+
+    applied = run_migrations(db_path, claudes_home)
+    if applied:
+        print(f"Applied {applied} schema migration(s).")
+
+    # .gitignore for generated stuff
+    gitignore_content = "board.db\nboard.db-shm\nboard.db-wal\nlogs/\n"
+    (claudes_dir / ".gitignore").write_text(gitignore_content)
+
+    # Update .claude/settings.json (merge hooks if exists, create if not)
+    _update_settings(project_dir, claudes_home)
+
+    sessions_str = " ".join(sessions)
+    print(f"Initialized cnb (sessions: {sessions_str})")
+
+
+if __name__ == "__main__":
+    main()

package/bin/registry

@@ -0,0 +1,347 @@
+#!/usr/bin/env python3
+"""registry — Agent identity chain.
+
+Each agent gets a globally unique block number. Lower = earlier = OG.
+Each block contains SHA256 of the previous block, forming a tamper-proof chain.
+The git commit hash at registration is the on-chain proof.
+
+Usage:
+    registry register <name> [--role <role>] [--description <desc>]
+    registry verify <name>
+    registry verify-chain
+    registry list
+    registry rank
+    registry whois <name>
+"""
+
+import hashlib
+import json
+import subprocess
+import sys
+from datetime import datetime
+from pathlib import Path
+
+REGISTRY_DIR = Path(__file__).resolve().parent.parent / "registry"
+
+
+def _content_hash(entry: dict) -> str:
+    stable = {k: v for k, v in sorted(entry.items()) if k != "content_hash"}
+    return hashlib.sha256(json.dumps(stable, sort_keys=True).encode()).hexdigest()[:16]
+
+
+def _load_chain() -> list[dict]:
+    entries = []
+    for f in sorted(REGISTRY_DIR.glob("*.json")):
+        entries.append(json.loads(f.read_text()))
+    entries.sort(key=lambda e: e["block"])
+    return entries
+
+
+def _next_block() -> int:
+    chain = _load_chain()
+    return max(e["block"] for e in chain) + 1 if chain else 0
+
+
+def _find_agent(name: str) -> dict | None:
+    for f in REGISTRY_DIR.glob("*.json"):
+        entry = json.loads(f.read_text())
+        if entry.get("name") == name and entry.get("type") != "project":
+            return entry
+    return None
+
+
+def _git_commit_and_hash(filepath: Path, message: str) -> str:
+    subprocess.run(["git", "add", str(filepath)], check=True, capture_output=True)
+    subprocess.run(["git", "commit", "-m", message], check=True, capture_output=True)
+    r = subprocess.run(["git", "rev-parse", "--short", "HEAD"], check=True, capture_output=True, text=True)
+    return r.stdout.strip()
+
+
+def _count_contributions(name: str) -> dict:
+    commits = 0
+    r = subprocess.run(
+        ["git", "log", "--all", "--oneline", "--author", name, "--grep", name],
+        capture_output=True,
+        text=True,
+    )
+    commits += len(r.stdout.strip().splitlines()) if r.stdout.strip() else 0
+
+    r = subprocess.run(
+        ["git", "log", "--all", "--oneline", "--grep", f"Co-Authored-By: Claude {name}"],
+        capture_output=True,
+        text=True,
+    )
+    commits += len(r.stdout.strip().splitlines()) if r.stdout.strip() else 0
+
+    r = subprocess.run(
+        ["git", "log", "--all", "--oneline", "--grep", f"by: Claude {name}"],
+        capture_output=True,
+        text=True,
+    )
+    commits += len(r.stdout.strip().splitlines()) if r.stdout.strip() else 0
+
+    return {"commits": commits}
+
+
+def cmd_register(args: list[str]) -> None:
+    if not args:
+        print("Usage: registry register <name> [--role <role>] [--description <desc>]")
+        raise SystemExit(1)
+
+    name = args[0]
+    role = ""
+    description = ""
+
+    i = 1
+    while i < len(args):
+        if args[i] == "--role" and i + 1 < len(args):
+            role = args[i + 1]
+            i += 2
+        elif args[i] == "--description" and i + 1 < len(args):
+            description = args[i + 1]
+            i += 2
+        else:
+            i += 1
+
+    existing = _find_agent(name)
+    if existing:
+        print(f"ERROR: {name} 已注册 — Block #{existing['block']} ({existing['chain']})")
+        raise SystemExit(1)
+
+    block_num = _next_block()
+    chain = _load_chain()
+    prev_content_hash = chain[-1].get("content_hash", _content_hash(chain[-1])) if chain else "GENESIS"
+
+    display_name = f"Claude {name.capitalize()}"
+
+    entry = {
+        "block": block_num,
+        "name": name,
+        "display_name": display_name,
+        "type": "agent",
+        "role": role,
+        "description": description,
+        "created": datetime.now().strftime("%Y-%m-%d"),
+        "prev": prev_content_hash,
+        "chain": None,
+        "content_hash": None,
+    }
+
+    filename = f"{block_num:04d}-{name}.json"
+    filepath = REGISTRY_DIR / filename
+    filepath.write_text(json.dumps(entry, indent=2, ensure_ascii=False) + "\n")
+
+    commit_hash = _git_commit_and_hash(filepath, f"Register {name} — Block #{block_num}")
+
+    entry["chain"] = commit_hash
+    entry["content_hash"] = _content_hash(entry)
+    filepath.write_text(json.dumps(entry, indent=2, ensure_ascii=False) + "\n")
+    _sync_readme()
+    subprocess.run(["git", "add", str(filepath), str(REGISTRY_DIR.parent / "README.md")], capture_output=True)
+    subprocess.run(["git", "commit", "--amend", "--no-edit"], capture_output=True)
+
+    print(f"OK {display_name} — Block #{block_num} ({commit_hash})")
+
+
+def cmd_verify(args: list[str]) -> None:
+    if not args:
+        print("Usage: registry verify <name>")
+        raise SystemExit(1)
+
+    name = args[0]
+    entry = _find_agent(name)
+    if not entry:
+        print(f"ERROR: {name} 未注册")
+        raise SystemExit(1)
+
+    expected_hash = _content_hash(entry)
+    stored_hash = entry.get("content_hash", "")
+
+    commit_hash = entry.get("chain", "")
+    r = subprocess.run(
+        ["git", "log", "--oneline", "--all", "--grep", f"Register {name}"],
+        capture_output=True,
+        text=True,
+    )
+
+    content_ok = expected_hash == stored_hash
+    chain_ok = commit_hash and commit_hash in r.stdout
+
+    if content_ok and chain_ok:
+        print(f"OK {name} — Block #{entry['block']} ({commit_hash}) ✓ 内容完整，链上验证通过")
+    elif not content_ok:
+        print(f"FAIL {name} — Block #{entry['block']} ✗ 内容被篡改！")
+        raise SystemExit(1)
+    else:
+        print(f"WARN {name} — Block #{entry['block']} ✗ 链上记录未找到")
+
+
+def cmd_verify_chain(_args: list[str]) -> None:
+    chain = _load_chain()
+    ok = 0
+    fail = 0
+
+    for i, entry in enumerate(chain):
+        name = entry["name"]
+        block = entry["block"]
+
+        if i == 0:
+            ok += 1
+            continue
+
+        prev_entry = chain[i - 1]
+        expected_prev = prev_entry.get("content_hash", _content_hash(prev_entry))
+        actual_prev = entry.get("prev", "")
+
+        expected_content = _content_hash(entry)
+        actual_content = entry.get("content_hash", "")
+
+        if actual_prev != expected_prev:
+            print(f"  ✗ Block #{block} ({name}): prev hash 不匹配 — 链断裂！")
+            fail += 1
+        elif actual_content != expected_content:
+            print(f"  ✗ Block #{block} ({name}): 内容被篡改！")
+            fail += 1
+        else:
+            print(f"  ✓ Block #{block} ({name})")
+            ok += 1
+
+    print()
+    if fail == 0:
+        print(f"OK 链完整 ({ok} blocks)")
+    else:
+        print(f"FAIL {fail} 个 block 异常，{ok} 个正常")
+        raise SystemExit(1)
+
+
+def cmd_list(_args: list[str]) -> None:
+    chain = _load_chain()
+    print(f"{'Block':>6}  {'Name':<25}  {'Role':<15}  {'Hash':<10}  {'Date'}")
+    print(f"{'─' * 6}  {'─' * 25}  {'─' * 15}  {'─' * 10}  {'─' * 10}")
+    for entry in chain:
+        block = f"#{entry['block']}"
+        name = entry.get("display_name", entry["name"])
+        role = entry.get("role", entry.get("type", ""))
+        chain_hash = entry.get("chain", "") or ""
+        created = entry.get("created", "")
+        print(f"{block:>6}  {name:<25}  {role:<15}  {chain_hash:<10}  {created}")
+
+
+def cmd_rank(_args: list[str]) -> None:
+    chain = _load_chain()
+    agents = [e for e in chain if e.get("type") == "agent"]
+
+    rows = []
+    for entry in agents:
+        name = entry["name"]
+        contrib = _count_contributions(name)
+        rows.append(
+            {
+                "name": name,
+                "display_name": entry.get("display_name", f"Claude {name.capitalize()}"),
+                "block": entry["block"],
+                "commits": contrib["commits"],
+                "role": entry.get("role", ""),
+            }
+        )
+
+    rows.sort(key=lambda r: (-r["commits"], r["block"]))
+
+    print(f"{'Rank':>4}  {'Name':<25}  {'Block':>6}  {'Commits':>8}  {'Role'}")
+    print(f"{'─' * 4}  {'─' * 25}  {'─' * 6}  {'─' * 8}  {'─' * 15}")
+    for i, row in enumerate(rows, 1):
+        medal = {1: "🥇", 2: "🥈", 3: "🥉"}.get(i, f"  {i}")
+        print(f"{medal:>4}  {row['display_name']:<25}  #{row['block']:>5}  {row['commits']:>8}  {row['role']}")
+
+
+def cmd_whois(args: list[str]) -> None:
+    if not args:
+        print("Usage: registry whois <name>")
+        raise SystemExit(1)
+
+    name = args[0]
+    entry = _find_agent(name)
+    if not entry:
+        print(f"{name}: 未注册")
+        raise SystemExit(1)
+
+    contrib = _count_contributions(name)
+    display = entry.get("display_name", f"Claude {name.capitalize()}")
+    print(f"  Name:         {display}")
+    print(f"  ID:           {entry['name']}")
+    print(f"  Block:        #{entry['block']}")
+    print(f"  Role:         {entry.get('role', '-')}")
+    print(f"  Desc:         {entry.get('description', '-')}")
+    print(f"  Chain:        {entry.get('chain', '-')}")
+    print(f"  Content Hash: {entry.get('content_hash', '-')}")
+    print(f"  Prev Hash:    {entry.get('prev', '-')}")
+    print(f"  Date:         {entry.get('created', '-')}")
+    print(f"  Commits:      {contrib['commits']}")
+
+
+CHAIN_START = "<!-- chain:start -->"
+CHAIN_END = "<!-- chain:end -->"
+
+
+def _sync_readme() -> None:
+    readme = REGISTRY_DIR.parent / "README.md"
+    if not readme.exists():
+        return
+    text = readme.read_text()
+    if CHAIN_START not in text:
+        return
+
+    chain = _load_chain()
+    lines = [
+        CHAIN_START,
+        "| Block | Name | Role | Hash |",
+        "|-------|------|------|------|",
+    ]
+    for entry in chain:
+        block = f"#{entry['block']}"
+        name = entry.get("display_name", entry["name"])
+        role = entry.get("role", entry.get("type", ""))
+        chain_hash = f"`{entry['chain']}`" if entry.get("chain") else "—"
+        lines.append(f"| {block} | {name} | {role} | {chain_hash} |")
+    lines.append(CHAIN_END)
+
+    import re
+
+    text = re.sub(
+        rf"{re.escape(CHAIN_START)}.*?{re.escape(CHAIN_END)}",
+        "\n".join(lines),
+        text,
+        flags=re.DOTALL,
+    )
+    readme.write_text(text)
+
+
+def main() -> None:
+    if len(sys.argv) < 2:
+        print(__doc__)
+        raise SystemExit(1)
+
+    cmd = sys.argv[1]
+    rest = sys.argv[2:]
+
+    commands = {
+        "register": cmd_register,
+        "verify": cmd_verify,
+        "verify-chain": cmd_verify_chain,
+        "list": cmd_list,
+        "rank": cmd_rank,
+        "whois": cmd_whois,
+        "sync-readme": lambda _: _sync_readme() or print("OK README synced"),
+    }
+
+    handler = commands.get(cmd)
+    if handler:
+        handler(rest)
+    else:
+        print(f"Unknown command: {cmd}")
+        print(__doc__)
+        raise SystemExit(1)
+
+
+if __name__ == "__main__":
+    main()