claude-nb 0.3.0

package/lib/__init__.py

@@ -0,0 +1 @@
+# lib/ package — Python modules for cnb

package/lib/board_admin.py

@@ -0,0 +1,128 @@
+"""board_admin — suspend / resume / kudos / kudos-list."""
+
+import subprocess
+import time
+
+from lib.board_db import BoardDB, ts
+
+
+def cmd_suspend(db: BoardDB, identity: str, args: list[str]) -> None:
+    name = identity.lower()
+    if not args:
+        print("Usage: ./board --as <name> suspend <session>")
+        raise SystemExit(1)
+    target = args[0].lower()
+
+    session_exists = db.scalar("SELECT COUNT(*) FROM sessions WHERE name=?", (target,))
+    if not session_exists:
+        print(f"ERROR: 会话 '{target}' 不存在")
+        raise SystemExit(1)
+
+    already = db.scalar("SELECT COUNT(*) FROM suspended WHERE name=?", (target,))
+    if already:
+        print(f"{target} 已在停工名单中")
+        return
+
+    db.execute("INSERT INTO suspended(name, suspended_by) VALUES (?, ?)", (target, name))
+
+    sf = db.env.suspended_file
+    lines = sf.read_text().splitlines() if sf.exists() else []
+    if target not in lines:
+        lines.append(target)
+        sf.write_text("\n".join(lines) + "\n")
+
+    print(f"{target}: 已停工")
+
+    prefix = db.env.prefix
+    sess = f"{prefix}-{target}"
+    r = subprocess.run(["tmux", "has-session", "-t", sess], capture_output=True)
+    if r.returncode == 0:
+        subprocess.run(
+            ["tmux", "send-keys", "-t", sess, "/exit", "Enter"],
+            capture_output=True,
+        )
+        time.sleep(2)
+        subprocess.run(["tmux", "kill-session", "-t", sess], capture_output=True)
+        print(f"{target}: tmux session 已关闭")
+
+    now = ts()
+    db.execute(
+        "INSERT INTO messages(ts, sender, recipient, body) VALUES (?, 'SYSTEM', 'all', ?)",
+        (now, f"SUSPEND {target} by {name}"),
+    )
+
+
+def cmd_resume(db: BoardDB, identity: str, args: list[str]) -> None:
+    name = identity.lower()
+    if not args:
+        print("Usage: ./board --as <name> resume <session>")
+        raise SystemExit(1)
+    target = args[0].lower()
+
+    exists = db.scalar("SELECT COUNT(*) FROM suspended WHERE name=?", (target,))
+    if not exists:
+        print(f"ERROR: {target} 不在停工名单中")
+        raise SystemExit(1)
+
+    db.execute("DELETE FROM suspended WHERE name=?", (target,))
+
+    sf = db.env.suspended_file
+    if sf.exists():
+        lines = [l for l in sf.read_text().splitlines() if l != target]
+        sf.write_text("\n".join(lines) + "\n" if lines else "")
+
+    print(f"{target}: 已恢复")
+    now = ts()
+    db.execute(
+        "INSERT INTO messages(ts, sender, recipient, body) VALUES (?, 'SYSTEM', 'all', ?)",
+        (now, f"RESUME {target} by {name}"),
+    )
+
+
+def cmd_kudos(db: BoardDB, identity: str, args: list[str]) -> None:
+    name = identity.lower()
+    if len(args) < 2:
+        print("Usage: ./board --as <name> kudos <target> <reason> [--evidence <commit/link>]")
+        raise SystemExit(1)
+
+    evidence = ""
+    clean_args = []
+    i = 0
+    while i < len(args):
+        if args[i] in ("--evidence", "-e") and i + 1 < len(args):
+            evidence = args[i + 1]
+            i += 2
+            continue
+        clean_args.append(args[i])
+        i += 1
+
+    target = clean_args[0].lower()
+    reason = " ".join(clean_args[1:])
+
+    if name == target:
+        print("ERROR: cannot kudos yourself")
+        raise SystemExit(1)
+
+    db.execute(
+        "INSERT INTO kudos(sender, target, reason, evidence) VALUES (?, ?, ?, ?)",
+        (name, target, reason, evidence or None),
+    )
+    now = ts()
+    db.execute(
+        "INSERT INTO messages(ts, sender, recipient, body) VALUES (?, ?, 'all', ?)",
+        (now, name, f"[KUDOS] → {target}: {reason}"),
+    )
+    print(f"OK kudos sent to {target} (visible to all)")
+
+
+def cmd_kudos_list(db: BoardDB) -> None:
+    print("=== Kudos Board ===\n")
+    print("Leaderboard:")
+    for who, count in db.query("SELECT target, COUNT(*) as c FROM kudos GROUP BY target ORDER BY c DESC"):
+        print(f"  {who}: {count} kudos")
+    print("\nRecent:")
+    rows = db.query(
+        "SELECT '[' || ts || '] ' || sender || ' → ' || target || ': ' || reason FROM kudos ORDER BY id DESC LIMIT 10"
+    )
+    for (line,) in reversed(rows):
+        print(f"  {line}")

package/lib/board_bbs.py

@@ -0,0 +1,99 @@
+"""board_bbs — forum commands: post / reply / thread / threads."""
+
+import hashlib
+
+from lib.board_db import BoardDB, ts
+
+
+def cmd_post(db: BoardDB, identity: str, args: list[str]) -> None:
+    name = identity.lower()
+    if len(args) < 2:
+        print("Usage: ./board --as <name> post <标题> <内容>")
+        raise SystemExit(1)
+    title = args[0]
+    now = ts()
+    tid = hashlib.sha256(f"{title}{now}{identity}".encode()).hexdigest()[:6]
+
+    db.execute(
+        "INSERT INTO threads(id, title, author) VALUES (?, ?, ?)",
+        (tid, title, name),
+    )
+    db.execute(
+        "INSERT INTO messages(ts, sender, recipient, body) VALUES (?, ?, 'all', ?)",
+        (now, name, f"[BBS] 新帖「{title}」({tid})"),
+    )
+    print(f"OK 帖子已创建: {tid}")
+    print(f"  标题: {title}")
+    print(f"  查看: ./board --as <name> thread {tid}")
+
+
+def cmd_reply(db: BoardDB, identity: str, args: list[str]) -> None:
+    name = identity.lower()
+    if len(args) < 2:
+        print("Usage: ./board --as <name> reply <帖子ID> <内容>")
+        raise SystemExit(1)
+    tid = args[0]
+    body = " ".join(args[1:])
+
+    full_tid = db.scalar(
+        "SELECT id FROM threads WHERE id LIKE ? ESCAPE '\\' LIMIT 1",
+        (tid + "%",),
+    )
+    if not full_tid:
+        print(f"ERROR: 帖子 {tid} 不存在")
+        raise SystemExit(1)
+
+    db.execute(
+        "INSERT INTO thread_replies(thread_id, author, body) VALUES (?, ?, ?)",
+        (full_tid, name, body),
+    )
+    title = db.scalar("SELECT title FROM threads WHERE id=?", (full_tid,))
+    now = ts()
+    db.execute(
+        "INSERT INTO messages(ts, sender, recipient, body) VALUES (?, ?, 'all', ?)",
+        (now, name, f"[BBS] 回帖「{title}」({full_tid})"),
+    )
+    print(f"OK 回帖成功 (帖子: {full_tid})")
+
+
+def cmd_thread(db: BoardDB, args: list[str]) -> None:
+    if not args:
+        print("Usage: ./board thread <帖子ID>")
+        raise SystemExit(1)
+    tid = args[0]
+    full_tid = db.scalar(
+        "SELECT id FROM threads WHERE id LIKE ? ESCAPE '\\' LIMIT 1",
+        (tid + "%",),
+    )
+    if not full_tid:
+        print(f"ERROR: 帖子 {tid} 不存在")
+        raise SystemExit(1)
+
+    row = db.query_one("SELECT title, author, created_at FROM threads WHERE id=?", (full_tid,))
+    title, author, created = row
+    print(f"# {title}")
+    print(f"> @{author} — {created}\n")
+
+    for rauthor, rbody, rts in db.query(
+        "SELECT author, body, ts FROM thread_replies WHERE thread_id=? ORDER BY id",
+        (full_tid,),
+    ):
+        print("---")
+        print(f"> @{rauthor} — {rts}\n")
+        print(rbody)
+
+
+def cmd_threads(db: BoardDB) -> None:
+    print("=== BBS 话题列表 ===\n")
+    rows = db.query(
+        "SELECT t.id, t.title, t.author, t.created_at, "
+        "(SELECT COUNT(*) FROM thread_replies r WHERE r.thread_id=t.id) "
+        "FROM threads t ORDER BY t.created_at DESC"
+    )
+    if not rows:
+        print("  (暂无话题)\n")
+        print("  发帖: ./board --as <name> post <标题> <内容>")
+    else:
+        for tid, title, author, date, replies in rows:
+            print(f"  [{tid}] {title}  ({replies} 回帖)  by {author}  {date}")
+    print()

package/lib/board_bug.py

@@ -0,0 +1,161 @@
+"""board_bug — bug tracker: report / assign / fix / list / overdue."""
+
+import time
+from datetime import datetime
+
+from lib.board_db import BoardDB, ts
+from lib.common import is_terminal_bug_status
+
+
+def cmd_bug(db: BoardDB, identity: str, args: list[str]) -> None:
+    subcmd = args[0] if args else "list"
+    rest = args[1:] if len(args) > 1 else []
+    dispatch = {
+        "report": lambda: _bug_report(db, identity, rest),
+        "assign": lambda: _bug_assign(db, identity, rest),
+        "fix": lambda: _bug_fix(db, identity, rest),
+        "list": lambda: _bug_list(db, rest),
+        "overdue": lambda: _bug_overdue(db),
+    }
+    fn = dispatch.get(subcmd)
+    if not fn:
+        print("Usage: ./board --as <name> bug {report|assign|fix|list|overdue}")
+        raise SystemExit(1)
+    fn()
+
+
+def _bug_report(db: BoardDB, identity: str, args: list[str]) -> None:
+    name = identity.lower()
+    if len(args) < 2:
+        print("Usage: ./board --as <name> bug report <P0|P1|P2> <description>")
+        raise SystemExit(1)
+    severity = args[0].upper()
+    if severity not in ("P0", "P1", "P2"):
+        print("ERROR: severity must be P0, P1, or P2")
+        raise SystemExit(1)
+    desc = " ".join(args[1:])
+    sla = {"P0": "immediate", "P1": "4h", "P2": "24h"}[severity]
+
+    now = ts()
+
+    with db.conn() as c:
+        max_id = db.scalar("SELECT COALESCE(MAX(CAST(SUBSTR(id, 5) AS INTEGER)), 0) FROM bugs", c=c)
+        next_id = f"BUG-{max_id + 1:03d}"
+        db.execute(
+            "INSERT INTO bugs(id, severity, sla, reporter, status, description) VALUES (?, ?, ?, ?, 'OPEN', ?)",
+            (next_id, severity, sla, name, desc),
+            c=c,
+        )
+        msg_id = db.execute(
+            "INSERT INTO messages(ts, sender, recipient, body) VALUES (?, ?, 'all', ?)",
+            (now, name, f"[{next_id}/{severity}] {desc}"),
+            c=c,
+        )
+        db.deliver_to_inbox(name, "all", msg_id, c=c)
+    print(f"OK {next_id} ({severity}) created")
+
+
+def _bug_assign(db: BoardDB, identity: str, args: list[str]) -> None:
+    name = identity.lower()
+    if len(args) < 2:
+        print("Usage: ./board --as <name> bug assign <BUG-NNN> <session>")
+        raise SystemExit(1)
+    bugid = args[0].upper()
+    if not bugid.startswith("BUG-"):
+        bugid = f"BUG-{bugid}"
+    assignee = args[1].lower()
+
+    exists = db.scalar("SELECT COUNT(*) FROM bugs WHERE id=?", (bugid,))
+    if not exists:
+        print(f"ERROR: {bugid} not found")
+        raise SystemExit(1)
+
+    now = ts()
+    with db.conn() as c:
+        db.execute("UPDATE bugs SET assignee=?, status='ASSIGNED' WHERE id=?", (assignee, bugid), c=c)
+        db.execute(
+            "INSERT INTO messages(ts, sender, recipient, body) VALUES (?, ?, ?, ?)",
+            (now, name, assignee, f"[{bugid}] assigned to you"),
+            c=c,
+        )
+    print(f"OK {bugid} assigned to {assignee}")
+
+
+def _bug_fix(db: BoardDB, identity: str, args: list[str]) -> None:
+    name = identity.lower()
+    if len(args) < 2:
+        print("Usage: ./board --as <name> bug fix <BUG-NNN> <evidence>")
+        raise SystemExit(1)
+    bugid = args[0].upper()
+    if not bugid.startswith("BUG-"):
+        bugid = f"BUG-{bugid}"
+    evidence = " ".join(args[1:])
+
+    row = db.query_one("SELECT status FROM bugs WHERE id=?", (bugid,))
+    if not row:
+        print(f"ERROR: {bugid} not found")
+        raise SystemExit(1)
+
+    if is_terminal_bug_status(row["status"]):
+        print(f"Bug {bugid} is already {row['status']}.")
+        return
+
+    now = ts()
+    with db.conn() as c:
+        db.execute("UPDATE bugs SET status='FIXED', fixed_at=?, evidence=? WHERE id=?", (now, evidence, bugid), c=c)
+        db.execute(
+            "INSERT INTO messages(ts, sender, recipient, body) VALUES (?, ?, 'all', ?)",
+            (now, name, f"[{bugid}] FIXED — {evidence}"),
+            c=c,
+        )
+    print(f"OK {bugid} marked FIXED")
+
+
+def _bug_list(db: BoardDB, args: list[str]) -> None:
+    filt = args[0] if args else "open"
+    print("=== Bug Tracker ===")
+
+    if filt == "open":
+        rows = db.query(
+            "SELECT id, severity, status, assignee, reporter, reported_at, description "
+            "FROM bugs WHERE status != 'FIXED' ORDER BY reported_at"
+        )
+    elif filt == "all":
+        rows = db.query(
+            "SELECT id, severity, status, assignee, reporter, reported_at, description FROM bugs ORDER BY reported_at"
+        )
+    else:
+        rows = db.query(
+            "SELECT id, severity, status, assignee, reporter, reported_at, description "
+            "FROM bugs WHERE status = ? ORDER BY reported_at",
+            (filt.upper(),),
+        )
+
+    if not rows:
+        print(f"  (no bugs matching filter: {filt})")
+    else:
+        for bid, sev, status, assignee, reporter, reported, desc in rows:
+            print(f"\n  {bid} [{sev}] {status}")
+            print(f"    Reporter: {reporter}  Assignee: {assignee or 'unassigned'}")
+            print(f"    Reported: {reported}")
+            print(f"    {desc}")
+    print()
+
+
+def _bug_overdue(db: BoardDB) -> None:
+    now_epoch = int(time.time())
+    rows = db.query("SELECT id, severity, reported_at FROM bugs WHERE status != 'FIXED'")
+    found = False
+    for bid, sev, reported in rows:
+        try:
+            dt = datetime.strptime(reported, "%Y-%m-%d %H:%M")
+            rep_epoch = int(dt.timestamp())
+        except (ValueError, TypeError):
+            continue
+        elapsed = now_epoch - rep_epoch
+        limit = {"P0": 0, "P1": 14400, "P2": 86400}.get(sev, 0)
+        if elapsed > limit:
+            found = True
+            print(f"OVERDUE: {bid} [{sev}] — {elapsed // 60}min since reported")
+    if not found:
+        print("No overdue bugs.")

package/lib/board_db.py

@@ -0,0 +1,262 @@
+"""board_db — DB connection, helpers, and .md file sync."""
+
+from __future__ import annotations
+
+import sqlite3
+from collections.abc import Generator
+from contextlib import contextmanager
+from pathlib import Path
+from typing import Any
+
+from lib.common import (  # noqa: F401 — re-export ts for board_* modules
+    BaseDB,
+    ClaudesEnv,
+    Signal,
+    sanitize_session_name,
+    ts,
+)
+
+# Emitted when deliver_to_inbox() delivers a message. Session name is the arg.
+# Subscribers (e.g., FileWatcher) can react instantly without polling.
+inbox_delivered = Signal[str]()
+
+
+class BoardDB(BaseDB):
+    """Unified SQLite wrapper — new connection per call, no pooling.
+
+    Accepts either a ClaudesEnv (production) or a bare Path/str (tests, lightweight callers).
+    Adds .md file sync helpers on top of the BaseDB interface.
+    """
+
+    def __init__(self, env_or_path: ClaudesEnv | Path | str):
+        if isinstance(env_or_path, ClaudesEnv):
+            self.env: ClaudesEnv | None = env_or_path
+            self.db_path = env_or_path.board_db
+            if not self.db_path.exists():
+                print("ERROR: board.db not found. Run: cnb init <session-names>", flush=True)
+                raise SystemExit(1)
+            # Auto-apply pending schema migrations (idempotent, fast if up-to-date)
+            self._auto_migrate()
+        else:
+            self.env = None
+            self.db_path = Path(env_or_path)
+
+    def _auto_migrate(self) -> None:
+        """Apply pending schema migrations on first load (idempotent).
+
+        Only prints output when migrations were actually applied.
+        """
+        try:
+            from lib.migrate import run_migrations
+
+            install_home = self.env.install_home if self.env else Path(__file__).resolve().parent.parent
+            run_migrations(self.db_path, install_home)
+        except SystemExit:
+            raise
+        except Exception as e:
+            print(f"WARNING: migration check failed: {e}", flush=True)
+
+    @contextmanager
+    def conn(self) -> Generator[sqlite3.Connection, None, None]:
+        """New connection per call. Commits on success, rolls back on exception."""
+        c = sqlite3.connect(str(self.db_path))
+        c.execute("PRAGMA journal_mode=WAL")
+        c.execute("PRAGMA foreign_keys=ON")
+        c.row_factory = sqlite3.Row
+        try:
+            yield c
+            c.commit()
+        except Exception:
+            c.rollback()
+            raise
+        finally:
+            c.close()
+
+    def query(
+        self, sql: str, params: tuple[Any, ...] = (), *, c: sqlite3.Connection | None = None
+    ) -> list[sqlite3.Row]:
+        if c is not None:
+            return c.execute(sql, params).fetchall()
+        with self.conn() as conn:
+            return conn.execute(sql, params).fetchall()
+
+    def query_one(
+        self, sql: str, params: tuple[Any, ...] = (), *, c: sqlite3.Connection | None = None
+    ) -> sqlite3.Row | None:
+        rows = self.query(sql, params, c=c)
+        return rows[0] if rows else None
+
+    def scalar(self, sql: str, params: tuple[Any, ...] = (), *, c: sqlite3.Connection | None = None) -> Any:
+        row = self.query_one(sql, params, c=c)
+        return row[0] if row else None
+
+    def execute(self, sql: str, params: tuple[Any, ...] = (), *, c: sqlite3.Connection | None = None) -> int:
+        if c is not None:
+            return c.execute(sql, params).lastrowid
+        with self.conn() as conn:
+            cur = conn.execute(sql, params)
+            return cur.lastrowid
+
+    def execute_changes(self, sql: str, params: tuple[Any, ...] = (), *, c: sqlite3.Connection | None = None) -> int:
+        if c is not None:
+            c.execute(sql, params)
+            return c.execute("SELECT changes()").fetchone()[0]
+        with self.conn() as conn:
+            conn.execute(sql, params)
+            return conn.execute("SELECT changes()").fetchone()[0]
+
+    def ensure_session(self, name: str, *, c: sqlite3.Connection | None = None) -> None:
+        n = name.lower()
+        existing = self.scalar("SELECT COUNT(*) FROM sessions WHERE name=?", (n,), c=c)
+        if existing == 0:
+            self.execute("INSERT INTO sessions(name) VALUES (?)", (n,), c=c)
+
+    # --- .md file sync ---
+    #
+    # All writes use temp-file + atomic rename to avoid corruption on
+    # crash mid-write.  Section detection is strict: ## heading must be
+    # followed by space or end-of-line (not e.g. "## @收件箱-extra").
+
+    INBOX_HEADINGS: tuple[str, ...] = ("## @inbox", "## @收件箱")
+    TASK_HEADINGS: tuple[str, ...] = ("## Current task", "## 当前任务")
+
+    @staticmethod
+    def _replace_section(
+        text: str,
+        headings: tuple[str, ...],
+        replacement: str | None,
+    ) -> str | None:
+        """Replace or remove the content of a named Markdown section.
+
+        If *replacement* is None, the section is removed.  Returns the new
+        text, or None if the section was not found and no append is needed.
+
+        Heading detection: a line is a section boundary if it starts with "## "
+        (after stripping leading whitespace). Target headings are matched
+        case-insensitively against the normalized prefix.
+        """
+        lines = text.split("\n")
+        out: list[str] = []
+        in_section = False
+        found = False
+
+        normalized_headings = tuple(h.strip().lower() for h in headings)
+
+        for line in lines:
+            stripped = line.strip().lower()
+            if any(stripped == h or stripped.startswith(h + " ") for h in normalized_headings):
+                found = True
+                in_section = True
+                if replacement is not None:
+                    out.append(line)
+                    out.append(replacement)
+                continue
+            if in_section and stripped.startswith("## "):
+                in_section = False
+                out.append("")
+                out.append(line)
+                continue
+            if in_section:
+                continue
+            out.append(line)
+
+        if not found:
+            return None
+        return "\n".join(out)
+
+    def _atomic_write(self, path: Path, content: str) -> None:
+        """Write *content* to *path* atomically (temp + rename)."""
+        tmp = path.with_suffix(path.suffix + ".tmp")
+        try:
+            tmp.write_text(content)
+            tmp.replace(path)
+        except OSError:
+            pass
+
+    # ── inbox sync ──
+
+    def sync_inbox_to_file(self, target: str, *, c: sqlite3.Connection | None = None) -> None:
+        """Sync unread inbox messages to {target}.md file.
+
+        Accepts an optional *c* to use the caller's connection (so that
+        uncommitted inbox rows are visible within a transaction).
+        """
+        if not self.env:
+            return
+        sf = self.env.sessions_dir / f"{target}.md"
+        if not sf.exists():
+            return
+        rows = self.query(
+            "SELECT '- [' || m.ts || '] **' || m.sender || '**: ' || substr(m.body, 1, 60) "
+            "FROM inbox i JOIN messages m ON i.message_id=m.id "
+            "WHERE i.session=? AND i.read=0 ORDER BY m.ts",
+            (target,),
+            c=c,
+        )
+        inbox_lines = "\n".join(r[0] for r in rows) if rows else ""
+
+        try:
+            text = sf.read_text()
+        except OSError:
+            return
+
+        result = self._replace_section(text, self.INBOX_HEADINGS, inbox_lines or None)
+        if result is not None:
+            self._atomic_write(sf, result)
+        elif inbox_lines:
+            heading = self.INBOX_HEADINGS[1]  # canonical: Chinese heading
+            self._atomic_write(sf, text.rstrip("\n") + f"\n\n{heading}\n{inbox_lines}\n")
+
+    def clear_inbox_file(self, target: str) -> None:
+        if not self.env:
+            return
+        sf = self.env.sessions_dir / f"{target}.md"
+        if not sf.exists():
+            return
+        try:
+            text = sf.read_text()
+        except OSError:
+            return
+        result = self._replace_section(text, self.INBOX_HEADINGS, None)
+        if result is not None:
+            self._atomic_write(sf, result)
+
+    # ── status sync ──
+
+    def sync_status_to_file(self, target: str, status: str) -> None:
+        if not self.env:
+            return
+        sf = self.env.sessions_dir / f"{target}.md"
+        if not sf.exists():
+            return
+        try:
+            text = sf.read_text()
+        except OSError:
+            return
+        result = self._replace_section(text, self.TASK_HEADINGS, status)
+        if result is not None:
+            self._atomic_write(sf, result)
+
+    def deliver_to_inbox(
+        self, sender: str, recipient: str, msg_id: int, *, c: sqlite3.Connection | None = None
+    ) -> None:
+        if recipient == "all":
+            sessions = self.query("SELECT name FROM sessions WHERE name != ?", (sender,), c=c)
+            for (target,) in sessions:
+                self.execute(
+                    "INSERT INTO inbox(session, message_id) VALUES (?, ?)",
+                    (target, msg_id),
+                    c=c,
+                )
+            for (target,) in sessions:
+                self.sync_inbox_to_file(target, c=c)
+                inbox_delivered.emit(target)
+        else:
+            self.ensure_session(recipient, c=c)
+            self.execute(
+                "INSERT INTO inbox(session, message_id) VALUES (?, ?)",
+                (recipient, msg_id),
+                c=c,
+            )
+            self.sync_inbox_to_file(recipient, c=c)
+            inbox_delivered.emit(recipient)