claude-nb 0.3.0 → 0.5.1

package/lib/concerns/notification_push.py

@@ -0,0 +1,171 @@
+"""NotificationPushConcern — realtime notification delivery for mentions and issue activity."""
+
+from __future__ import annotations
+
+import re
+import time
+from pathlib import Path
+
+from lib.notification_config import NotificationConfig
+from lib.notification_config import load as load_config
+
+from .base import Concern
+from .config import DispatcherConfig
+from .helpers import board_send, db, get_dev_sessions, log, warn
+
+MENTION_RE = re.compile(r"(?<![a-zA-Z0-9.])@([a-z][a-z0-9_-]*)", re.IGNORECASE)
+
+
+class NotificationPushConcern(Concern):
+    interval = 10
+
+    def __init__(self, cfg: DispatcherConfig) -> None:
+        super().__init__()
+        self.cfg = cfg
+        self._config: NotificationConfig | None = None
+        self._config_mtime: float = 0
+        self._last_msg_id: int = 0
+        self._last_bug_check: str = ""
+        self._init_watermarks()
+
+    def _config_path(self) -> Path:
+        return self.cfg.claudes_dir / "notifications.toml"
+
+    def _load_config(self) -> NotificationConfig:
+        path = self._config_path()
+        try:
+            mtime = path.stat().st_mtime if path.exists() else 0
+        except OSError:
+            mtime = 0
+        if self._config is None or mtime != self._config_mtime:
+            self._config = load_config(path)
+            self._config_mtime = mtime
+        return self._config
+
+    def _init_watermarks(self) -> None:
+        try:
+            d = db(self.cfg)
+            row = d.query_one("SELECT MAX(id) FROM messages")
+            self._last_msg_id = (row[0] or 0) if row else 0
+            self._last_bug_check = time.strftime("%Y-%m-%d %H:%M:%S")
+        except Exception:
+            pass
+
+    def _already_sent(self, notif_type: str, recipient: str, ref_id: str) -> bool:
+        try:
+            count = db(self.cfg).scalar(
+                "SELECT COUNT(*) FROM notification_log WHERE notif_type=? AND recipient=? AND ref_id=?",
+                (notif_type, recipient, ref_id),
+            )
+            return bool(count)
+        except Exception:
+            return False
+
+    def _record(self, notif_type: str, recipient: str, ref_type: str, ref_id: str, channel: str) -> None:
+        try:
+            with db(self.cfg).conn() as c:
+                c.execute(
+                    "INSERT INTO notification_log(notif_type, recipient, ref_type, ref_id, channel) VALUES(?,?,?,?,?)",
+                    (notif_type, recipient, ref_type, ref_id, channel),
+                )
+        except Exception as e:
+            warn(f"notification_log insert: {e}")
+
+    def _deliver(self, config: NotificationConfig, recipient: str, notif_type: str, message: str, ref_id: str) -> None:
+        channel = config.channel_for(recipient)
+        if channel == "board-inbox":
+            board_send(self.cfg, recipient, message)
+        else:
+            log(f"[notify] {channel} delivery not yet implemented for {recipient}: {message[:60]}")
+        self._record(notif_type, recipient, "message" if notif_type == "mention" else "bug", ref_id, channel)
+
+    def _scan_mentions(self, config: NotificationConfig) -> None:
+        try:
+            rows = db(self.cfg).query(
+                "SELECT id, sender, recipient, body FROM messages WHERE id > ?",
+                (self._last_msg_id,),
+            )
+        except Exception:
+            return
+        if not rows:
+            return
+
+        members = [s for s in get_dev_sessions(self.cfg)]
+        max_id = self._last_msg_id
+
+        for row in rows:
+            msg_id, sender, _recipient, body = row[0], row[1], row[2], row[3]
+            if msg_id > max_id:
+                max_id = msg_id
+            mentioned = set(m.lower() for m in MENTION_RE.findall(body))
+            for name in mentioned:
+                if name == sender.lower():
+                    continue
+                if not config.is_subscribed(name, "mention"):
+                    continue
+                if name not in members and name != "human":
+                    continue
+                ref = f"msg-{msg_id}"
+                if self._already_sent("mention", name, ref):
+                    continue
+                preview = body[:80].replace("\n", " ")
+                self._deliver(config, name, "mention", f"[通知] {sender} 提到了你: {preview}", ref)
+
+        self._last_msg_id = max_id
+
+    def _scan_bugs(self, config: NotificationConfig) -> None:
+        try:
+            rows = db(self.cfg).query(
+                "SELECT id, severity, reporter, assignee, status, description, reported_at FROM bugs WHERE reported_at > ?",
+                (self._last_bug_check,),
+            )
+        except Exception:
+            return
+
+        members = [s for s in get_dev_sessions(self.cfg)]
+        now_ts = time.strftime("%Y-%m-%d %H:%M:%S")
+
+        for row in rows:
+            bug_id, severity, reporter, assignee, _status, desc, _reported = (
+                row[0],
+                row[1],
+                row[2],
+                row[3],
+                row[4],
+                row[5],
+                row[6],
+            )
+            ref = f"bug-{bug_id}"
+
+            for name in members:
+                if not config.is_subscribed(name, "issue-activity"):
+                    continue
+                if self._already_sent("issue-activity", name, ref):
+                    continue
+                preview = desc[:60].replace("\n", " ")
+                self._deliver(
+                    config,
+                    name,
+                    "issue-activity",
+                    f"[Bug {severity}] {reporter} 报告: {preview}",
+                    ref,
+                )
+
+            if assignee and assignee.lower() in [m.lower() for m in members]:
+                target = assignee.lower()
+                assign_ref = f"bug-assign-{bug_id}"
+                if not self._already_sent("mention", target, assign_ref):
+                    self._deliver(
+                        config,
+                        target,
+                        "mention",
+                        f"[通知] 你被指派了 Bug {bug_id} ({severity}): {desc[:60]}",
+                        assign_ref,
+                    )
+
+        self._last_bug_check = now_ts
+
+    def tick(self, now: int) -> None:
+        config = self._load_config()
+        self._scan_mentions(config)
+        self._scan_bugs(config)

package/lib/concerns/notifications.py

@@ -0,0 +1,145 @@
+"""Notifications: inbox nudging, time announcements, bug SLA checks, queued message flushing."""
+
+import subprocess
+
+from .base import Concern
+from .config import DispatcherConfig
+from .coral import CoralPoker
+from .helpers import board_send, db, get_dev_sessions, is_claude_running, log, tmux, tmux_ok, tmux_send
+
+
+class InboxNudger(Concern):
+    interval = 5
+
+    def __init__(self, cfg: DispatcherConfig) -> None:
+        super().__init__()
+        self.cfg = cfg
+
+    def nudge_if_unread(self, name: str) -> None:
+        if not self.cfg.board_db.exists():
+            return
+        try:
+            unread = db(self.cfg).scalar("SELECT COUNT(*) FROM inbox WHERE session=? AND read=0", (name,)) or 0
+        except Exception:
+            return
+        if unread <= 0:
+            return
+
+        sess = f"{self.cfg.prefix}-{name}"
+        if not tmux_ok("has-session", "-t", sess) or not is_claude_running(sess):
+            return
+
+        log(f"INBOX: {name} has {unread} unread -> nudging")
+        tmux_send(sess, f"./board --as {name} inbox")
+
+    def tick(self, now: int) -> None:
+        for name in get_dev_sessions(self.cfg):
+            self.nudge_if_unread(name)
+
+
+class TimeAnnouncer(Concern):
+    interval = 30
+
+    def __init__(self, cfg: DispatcherConfig) -> None:
+        super().__init__()
+        self.cfg = cfg
+        from datetime import datetime as dt
+
+        self.last_hour = dt.now().hour
+
+    def _already_sent(self, hour_ts: str) -> bool:
+        """Check DB for a clock message already sent this hour (prevents duplicate announcements)."""
+        try:
+            count = db(self.cfg).scalar(
+                "SELECT COUNT(*) FROM messages WHERE sender='dispatcher' AND body LIKE '%[Clock]%' AND ts LIKE ?",
+                (f"{hour_ts}%",),
+            )
+            return bool(count)
+        except Exception:
+            return False
+
+    def tick(self, now: int) -> None:
+        from datetime import datetime as dt
+
+        d = dt.now()
+        if d.minute != 0 or d.hour == self.last_hour:
+            return
+        self.last_hour = d.hour
+        ts = d.strftime("%Y-%m-%d %H:%M")
+
+        if self._already_sent(ts):
+            log(f"Hourly announcement: {d.hour}:00 (already sent, skipping)")
+            return
+
+        if d.hour == 9:
+            board_send(
+                self.cfg,
+                "All",
+                f"[Clock] {ts} ({d.strftime('%A')}) — 新一天。检查 KR 列表，确认优先级。",
+            )
+            log("Daily announcement sent")
+        else:
+            board_send(self.cfg, "All", f"[Clock] 现在是 {ts}。")
+            log(f"Hourly announcement: {d.hour}:00")
+
+
+class QueuedMessageFlusher(Concern):
+    """Detect queued messages in idle agent panes and send Enter to flush them.
+
+    When nudge injects a command while Claude Code is busy, it gets queued.
+    The pane shows 'queued message' and waits for Enter. This concern
+    auto-flushes that queue when the agent becomes idle.
+    """
+
+    interval = 5
+    COOLDOWN = 30
+
+    def __init__(self, cfg: DispatcherConfig) -> None:
+        super().__init__()
+        self.cfg = cfg
+        self.last_flush: dict[str, int] = {}
+
+    def tick(self, now: int) -> None:
+        for name in get_dev_sessions(self.cfg):
+            sess = f"{self.cfg.prefix}-{name}"
+            if not tmux_ok("has-session", "-t", sess) or not is_claude_running(sess):
+                continue
+            if (now - self.last_flush.get(name, 0)) < self.COOLDOWN:
+                continue
+
+            content = tmux("capture-pane", "-t", sess, "-p") or ""
+            if "queued message" not in content.lower():
+                continue
+
+            lines = content.splitlines()[-5:]
+            has_empty_prompt = any(line.rstrip() == "❯" for line in lines)
+            if not has_empty_prompt:
+                continue
+
+            log(f"{name}: flushing queued message")
+            subprocess.run(["tmux", "send-keys", "-t", sess, "Enter"], capture_output=True, timeout=5)
+            self.last_flush[name] = now
+
+
+class BugSLAChecker(Concern):
+    interval = 600
+
+    def __init__(self, cfg: DispatcherConfig, poker: CoralPoker) -> None:
+        super().__init__()
+        self.cfg = cfg
+        self.poker = poker
+
+    def tick(self, now: int) -> None:
+        try:
+            r = subprocess.run(
+                [self.cfg.board_sh, "bug", "overdue"],
+                capture_output=True,
+                text=True,
+                timeout=10,
+            )
+            overdue = r.stdout.strip()
+        except Exception:
+            return
+        if overdue and "No overdue" not in overdue:
+            log(f"Bug SLA alert: {overdue}")
+            self.poker.poke(f"[Dispatcher] Bug SLA 超时: {overdue}")

package/lib/concerns/nudge_coordinator.py

@@ -0,0 +1,148 @@
+"""NudgeCoordinator — unified nudge orchestrator replacing InboxNudger, QueuedMessageFlusher, IdleNudger.
+
+Consolidates all nudge decisions into a single Concern with:
+  - per-session cooldown across all nudge types
+  - nudge-type priority: inbox > queued_flush > idle
+  - post-nudge effectiveness tracking with backoff
+  - cached session status checks (one tmux call per session per tick)
+"""
+
+from dataclasses import dataclass
+
+from lib.common import is_suspended
+
+from .base import Concern
+from .config import DispatcherConfig
+from .helpers import db, get_dev_sessions, is_claude_running, log, tmux, tmux_ok, tmux_send
+
+
+@dataclass
+class NudgeRecord:
+    time: int = 0
+    nudge_type: str = ""
+    consecutive_ineffective: int = 0
+
+
+class NudgeCoordinator(Concern):
+    interval = 5
+    COOLDOWN = 15
+    MAX_BACKOFF_MULTIPLIER = 8
+
+    def __init__(self, cfg: DispatcherConfig, idle) -> None:
+        super().__init__()
+        self.cfg = cfg
+        self.idle = idle
+        self._records: dict[str, NudgeRecord] = {}
+        self._session_ok: dict[str, bool] = {}
+        self._cache_tick: int = 0
+
+    def _session_ready(self, name: str, now: int) -> bool:
+        if now != self._cache_tick:
+            self._session_ok.clear()
+            self._cache_tick = now
+        if name not in self._session_ok:
+            sess = f"{self.cfg.prefix}-{name}"
+            self._session_ok[name] = tmux_ok("has-session", "-t", sess) and is_claude_running(sess)
+        return self._session_ok[name]
+
+    def _effective_cooldown(self, name: str) -> int:
+        rec = self._records.get(name)
+        if not rec or rec.consecutive_ineffective <= 1:
+            return self.COOLDOWN
+        backoff_exp = min(rec.consecutive_ineffective - 1, 3)
+        return int(self.COOLDOWN * min(2**backoff_exp, self.MAX_BACKOFF_MULTIPLIER))
+
+    def _can_nudge(self, name: str, now: int) -> bool:
+        rec = self._records.get(name)
+        if not rec:
+            return True
+        return (now - rec.time) >= self._effective_cooldown(name)
+
+    def _check_effectiveness(self, name: str) -> None:
+        rec = self._records.get(name)
+        if not rec:
+            return
+        sess = f"{self.cfg.prefix}-{name}"
+        if self.idle.is_idle(sess):
+            rec.consecutive_ineffective += 1
+        else:
+            rec.consecutive_ineffective = 0
+
+    def _record(self, name: str, nudge_type: str, now: int) -> None:
+        rec = self._records.get(name)
+        old_ineffective = rec.consecutive_ineffective if rec else 0
+        self._records[name] = NudgeRecord(time=now, nudge_type=nudge_type, consecutive_ineffective=old_ineffective)
+        log(f"NUDGE [{nudge_type}] {name}")
+
+    def _try_inbox(self, name: str) -> bool:
+        if not self.cfg.board_db.exists():
+            return False
+        try:
+            unread = db(self.cfg).scalar("SELECT COUNT(*) FROM inbox WHERE session=? AND read=0", (name,)) or 0
+        except Exception:
+            return False
+        if unread <= 0:
+            return False
+        sess = f"{self.cfg.prefix}-{name}"
+        tmux_send(sess, f"./board --as {name} inbox")
+        return True
+
+    def _try_queued_flush(self, name: str) -> bool:
+        sess = f"{self.cfg.prefix}-{name}"
+        content = tmux("capture-pane", "-t", sess, "-p") or ""
+        if "queued message" not in content.lower():
+            return False
+        lines = content.splitlines()[-5:]
+        if not any(line.rstrip() == "❯" for line in lines):
+            return False
+        tmux_send(sess, "")
+        return True
+
+    def _try_idle(self, name: str) -> bool:
+        sess = f"{self.cfg.prefix}-{name}"
+        if not self.idle.is_idle(sess):
+            return False
+        tmux_send(
+            sess,
+            f"继续工作。检查你的 OKR ({self.cfg.okr_dir}/{name}.md)，推进你的活跃 KR。自己决定优先级。",
+        )
+        return True
+
+    def get_nudge_stats(self, name: str) -> dict:
+        rec = self._records.get(name)
+        if not rec:
+            return {"consecutive_ineffective": 0, "last_nudge_type": "", "last_nudge_time": 0}
+        return {
+            "consecutive_ineffective": rec.consecutive_ineffective,
+            "last_nudge_type": rec.nudge_type,
+            "last_nudge_time": rec.time,
+        }
+
+    def _process_session(self, name: str, now: int) -> None:
+        if is_suspended(name, self.cfg.suspended_file):
+            return
+        if not self._session_ready(name, now):
+            return
+
+        if name in self._records:
+            self._check_effectiveness(name)
+
+        if not self._can_nudge(name, now):
+            return
+
+        for nudge_type, try_fn in [
+            ("inbox", self._try_inbox),
+            ("flush", self._try_queued_flush),
+            ("idle", self._try_idle),
+        ]:
+            if try_fn(name):
+                self._record(name, nudge_type, now)
+                break
+
+    def check_session(self, name: str, now: int) -> None:
+        """Check and nudge a specific session (used by FileWatcher for instant inbox detection)."""
+        self._process_session(name, now)
+
+    def tick(self, now: int) -> None:
+        for name in get_dev_sessions(self.cfg):
+            self._process_session(name, now)

package/lib/digest.py

@@ -0,0 +1,62 @@
+"""digest — generate daily/weekly activity summaries from board data."""
+
+from __future__ import annotations
+
+from datetime import datetime, timedelta
+
+from lib.board_db import BoardDB
+
+
+def generate_daily_digest(board: BoardDB, since: datetime | None = None) -> str:
+    if since is None:
+        since = datetime.now() - timedelta(hours=24)
+    since_str = since.strftime("%Y-%m-%d %H:%M:%S")
+
+    sections: list[str] = []
+
+    msg_count = board.scalar("SELECT COUNT(*) FROM messages WHERE ts > ?", (since_str,)) or 0
+    if msg_count:
+        top_senders = board.query(
+            "SELECT sender, COUNT(*) as cnt FROM messages WHERE ts > ? GROUP BY sender ORDER BY cnt DESC LIMIT 5",
+            (since_str,),
+        )
+        sender_str = ", ".join(f"{r[0]}({r[1]})" for r in (top_senders or []))
+        sections.append(f"消息: {msg_count} 条 — {sender_str}")
+
+    bugs_opened = board.query(
+        "SELECT id, severity, reporter, description FROM bugs WHERE reported_at > ? AND status='OPEN'",
+        (since_str,),
+    )
+    if bugs_opened:
+        bug_lines = [f"  {r[0]} [{r[1]}] {r[3][:40]}" for r in bugs_opened]
+        sections.append(f"新 Bug: {len(bugs_opened)} 个\n" + "\n".join(bug_lines))
+
+    bugs_fixed = board.query(
+        "SELECT id, severity, assignee FROM bugs WHERE fixed_at > ?",
+        (since_str,),
+    )
+    if bugs_fixed:
+        fix_lines = [f"  {r[0]} [{r[1]}] by {r[2]}" for r in bugs_fixed]
+        sections.append(f"修复: {len(bugs_fixed)} 个\n" + "\n".join(fix_lines))
+
+    tasks_done = board.query(
+        "SELECT session, description FROM tasks WHERE done_at > ? AND status='done'",
+        (since_str,),
+    )
+    if tasks_done:
+        task_lines = [f"  {r[0]}: {r[1][:50]}" for r in tasks_done]
+        sections.append(f"完成任务: {len(tasks_done)} 个\n" + "\n".join(task_lines))
+
+    kudos_list = board.query(
+        "SELECT sender, target, reason FROM kudos WHERE ts > ?",
+        (since_str,),
+    )
+    if kudos_list:
+        kudos_lines = [f"  {r[0]} → {r[1]}: {r[2][:40]}" for r in kudos_list]
+        sections.append(f"Kudos: {len(kudos_list)} 个\n" + "\n".join(kudos_lines))
+
+    if not sections:
+        return "[Daily Digest] 过去 24h 无活动。"
+
+    header = f"[Daily Digest] {datetime.now().strftime('%Y-%m-%d')} 活动摘要"
+    return header + "\n" + "\n".join(sections)

package/lib/health.py

@@ -110,8 +110,8 @@ def print_health_report() -> None:
     sessions = get_sessions(prefix)
 
     print()
-    print("  Session\t\tStatus\t\tRestarts\tUptime\t\tAgent")
-    print("  -------\t\t------\t\t--------\t------\t\t-----")
+    print("  Session\t\tStatus\t\tRestarts\tUptime\t\tEngine")
+    print("  -------\t\t------\t\t--------\t------\t\t------")
 
     total = 0
     alive = 0

package/lib/inject.py

@@ -129,7 +129,7 @@ def inject(target: str, message: str, prefix: str | None = None, sessions: list
     mode = detect_mode(prefix)
     if mode == "none":
         print("ERROR: neither tmux nor screen found", file=sys.stderr)
-        sys.exit(1)
+        raise SystemExit(1)
 
     send_fn = send_tmux if mode == "tmux" else send_screen
     target_lower = target.lower()
@@ -153,7 +153,7 @@ def main() -> None:
             '  ./inject.py alice "what\'s blocking P0?"\n'
             '  ./inject.py all "everyone check inbox"',
         )
-        sys.exit(1)
+        raise SystemExit(1)
 
     target = sys.argv[1]
     message = " ".join(sys.argv[2:])

package/lib/migrate.py

@@ -83,6 +83,7 @@ def run_migrations(db_path: Path, claudes_home: Path) -> int:
 # CLI
 # ---------------------------------------------------------------------------
 
+
 def main() -> None:
     """Run pending migrations. Called from init and doctor."""
     # Resolve CLAUDES_HOME relative to this file

package/lib/monitor.py

@@ -75,6 +75,7 @@ class KqueueWatcher:
             path = os.path.join(self.watch_dir, f)
             if path in self.file_fds:
                 continue
+            fd = -1
             try:
                 fd = os.open(path, os.O_RDONLY)
                 ev = select.kevent(
@@ -86,7 +87,8 @@ class KqueueWatcher:
                 self.kq.control([ev], 0)
                 self.file_fds[path] = fd
             except OSError:
-                pass
+                if fd >= 0:
+                    os.close(fd)
 
     def poll(self, timeout: float = 5.0) -> set:
         """Block up to *timeout* seconds, return set of changed file paths."""
@@ -144,11 +146,13 @@ class InotifyWatcher:
         import selectors
 
         sel = selectors.DefaultSelector()
-        sel.register(self.proc.stdout, selectors.EVENT_READ)
+        stdout = self.proc.stdout
+        assert stdout is not None
+        sel.register(stdout, selectors.EVENT_READ)
         changed = set()
         events = sel.select(timeout=timeout)
         for key, _ in events:
-            line = key.fileobj.readline().strip()
+            line = key.fileobj.readline().strip()  # type: ignore[union-attr]
             if line:
                 changed.add(line)
         sel.close()
@@ -231,24 +235,7 @@ def handle_change(file_path: str, env: ClaudesEnv) -> None:
             pass
 
     if unread > 0:
-        sess = f"{env.prefix}-{name}"
-        try:
-            r = subprocess.run(
-                ["tmux", "has-session", "-t", sess],
-                capture_output=True,
-                timeout=5,
-            )
-            if r.returncode == 0:
-                log(f"EVENT: {name} has {unread} unread -- nudging")
-                subprocess.run(
-                    ["tmux", "send-keys", "-t", sess, "-l", f"./board --as {name} inbox"],
-                    timeout=5,
-                )
-                subprocess.run(["tmux", "send-keys", "-t", sess, "Enter"], timeout=5)
-            else:
-                log(f"EVENT: {name} has {unread} unread -- session not running")
-        except Exception:
-            pass
+        log(f"EVENT: {name} has {unread} unread")
 
 
 # ---------------------------------------------------------------------------
@@ -366,7 +353,7 @@ def main() -> None:
         print("  --benchmark  Compare event vs polling")
     else:
         print(f"Unknown: {arg}", file=sys.stderr)
-        sys.exit(1)
+        raise SystemExit(1)
 
 
 if __name__ == "__main__":