claude-nb 0.3.0 → 0.5.1

package/lib/concerns/digest_scheduler.py

@@ -0,0 +1,109 @@
+"""DigestScheduler — sends daily/weekly digests at scheduled times."""
+
+from __future__ import annotations
+
+from datetime import datetime
+from pathlib import Path
+
+from lib.digest import generate_daily_digest
+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
+
+
+class DigestScheduler(Concern):
+    interval = 30
+
+    def __init__(self, cfg: DispatcherConfig) -> None:
+        super().__init__()
+        self.cfg = cfg
+        self._last_daily_date: str = ""
+        self._last_weekly_date: str = ""
+
+    def _config_path(self) -> Path:
+        return self.cfg.claudes_dir / "notifications.toml"
+
+    def _already_sent_today(self, notif_type: str, date_str: str) -> bool:
+        try:
+            count = db(self.cfg).scalar(
+                "SELECT COUNT(*) FROM notification_log WHERE notif_type=? AND ref_id=?",
+                (notif_type, f"digest-{date_str}"),
+            )
+            return bool(count)
+        except Exception:
+            return False
+
+    def _record_digest(self, notif_type: str, recipient: str, date_str: 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, "digest", f"digest-{date_str}", channel),
+                )
+        except Exception as e:
+            warn(f"digest record: {e}")
+
+    def tick(self, now: int) -> None:
+        d = datetime.now()
+        if d.hour != 9 or d.minute > 5:
+            return
+
+        date_str = d.strftime("%Y-%m-%d")
+
+        if date_str != self._last_daily_date:
+            self._send_daily(date_str)
+            self._last_daily_date = date_str
+
+        if d.weekday() == 0 and date_str != self._last_weekly_date:
+            self._send_weekly(date_str)
+            self._last_weekly_date = date_str
+
+    def _send_daily(self, date_str: str) -> None:
+        if self._already_sent_today("daily-digest", date_str):
+            log(f"Daily digest already sent for {date_str}, skipping")
+            return
+
+        config = load_config(self._config_path())
+        members = get_dev_sessions(self.cfg)
+        subscribers = config.subscribers_for("daily-digest", members)
+
+        if not subscribers:
+            return
+
+        try:
+            board = db(self.cfg)
+            digest_text = generate_daily_digest(board)
+        except Exception as e:
+            warn(f"digest generation failed: {e}")
+            return
+
+        for member in subscribers:
+            channel = config.channel_for(member)
+            if channel == "board-inbox":
+                board_send(self.cfg, member, digest_text)
+            else:
+                log(f"[digest] {channel} delivery not implemented for {member}")
+            self._record_digest("daily-digest", member, date_str, channel)
+
+        log(f"Daily digest sent to {len(subscribers)} subscribers")
+
+    def _send_weekly(self, date_str: str) -> None:
+        if self._already_sent_today("weekly-report", date_str):
+            log(f"Weekly report already sent for {date_str}, skipping")
+            return
+
+        config = load_config(self._config_path())
+        members = get_dev_sessions(self.cfg)
+        subscribers = config.subscribers_for("weekly-report", members)
+
+        if not subscribers:
+            return
+
+        board_send(self.cfg, "all", f"[Weekly Report] {date_str} — 本周报告待实现")
+        for member in subscribers:
+            channel = config.channel_for(member)
+            self._record_digest("weekly-report", member, date_str, channel)
+
+        log(f"Weekly report sent to {len(subscribers)} subscribers")

package/lib/concerns/file_watcher.py

@@ -8,16 +8,16 @@ from lib.common import is_suspended
 from .base import Concern
 from .config import DispatcherConfig
 from .helpers import log
-from .inbox_nudger import InboxNudger
+from .nudge_coordinator import NudgeCoordinator
 
 
 class FileWatcher(Concern):
     interval = 1
 
-    def __init__(self, cfg: DispatcherConfig, inbox: InboxNudger) -> None:
+    def __init__(self, cfg: DispatcherConfig, nudge: NudgeCoordinator) -> None:
         super().__init__()
         self.cfg = cfg
-        self.inbox = inbox
+        self.nudge = nudge
         self._queue: list[str] = []
         self._lock = threading.Lock()
         self._stop = threading.Event()
@@ -41,77 +41,82 @@ class FileWatcher(Concern):
         import select as sel
 
         kq = sel.kqueue()
-        watch_dir = str(self.cfg.sessions_dir)
-        dir_fd = os.open(watch_dir, os.O_RDONLY)
-        kq.control(
-            [
-                sel.kevent(
-                    dir_fd,
-                    filter=sel.KQ_FILTER_VNODE,
-                    flags=sel.KQ_EV_ADD | sel.KQ_EV_CLEAR,
-                    fflags=sel.KQ_NOTE_WRITE,
-                )
-            ],
-            0,
-        )
+        dir_fd = -1
         file_fds: dict[str, int] = {}
+        try:
+            watch_dir = str(self.cfg.sessions_dir)
+            dir_fd = os.open(watch_dir, os.O_RDONLY)
+            kq.control(
+                [
+                    sel.kevent(
+                        dir_fd,
+                        filter=sel.KQ_FILTER_VNODE,
+                        flags=sel.KQ_EV_ADD | sel.KQ_EV_CLEAR,
+                        fflags=sel.KQ_NOTE_WRITE,
+                    )
+                ],
+                0,
+            )
 
-        def refresh() -> None:
-            for f in os.listdir(watch_dir):
-                if not f.endswith(".md"):
+            def refresh() -> None:
+                for f in os.listdir(watch_dir):
+                    if not f.endswith(".md"):
+                        continue
+                    path = os.path.join(watch_dir, f)
+                    if path in file_fds:
+                        continue
+                    fd = -1
+                    try:
+                        fd = os.open(path, os.O_RDONLY)
+                        kq.control(
+                            [
+                                sel.kevent(
+                                    fd,
+                                    filter=sel.KQ_FILTER_VNODE,
+                                    flags=sel.KQ_EV_ADD | sel.KQ_EV_CLEAR,
+                                    fflags=sel.KQ_NOTE_WRITE | sel.KQ_NOTE_EXTEND,
+                                )
+                            ],
+                            0,
+                        )
+                        file_fds[path] = fd
+                    except OSError:
+                        if fd >= 0:
+                            os.close(fd)
+
+            refresh()
+            while not self._stop.is_set():
+                fd_to_path = {fd: p for p, fd in file_fds.items()}
+                try:
+                    events = kq.control(None, 8, 2.0)
+                except (InterruptedError, OSError):
+                    if self._stop.is_set():
+                        break
                     continue
-                path = os.path.join(watch_dir, f)
-                if path in file_fds:
+                if not events:
+                    refresh()
                     continue
+                changed: set[str] = set()
+                for ev in events:
+                    if ev.ident == dir_fd:
+                        refresh()
+                    elif ev.ident in fd_to_path:
+                        changed.add(os.path.basename(fd_to_path[ev.ident]).replace(".md", ""))
+                if changed:
+                    with self._lock:
+                        self._queue.extend(changed)
+        finally:
+            for fd in file_fds.values():
                 try:
-                    fd = os.open(path, os.O_RDONLY)
-                    kq.control(
-                        [
-                            sel.kevent(
-                                fd,
-                                filter=sel.KQ_FILTER_VNODE,
-                                flags=sel.KQ_EV_ADD | sel.KQ_EV_CLEAR,
-                                fflags=sel.KQ_NOTE_WRITE | sel.KQ_NOTE_EXTEND,
-                            )
-                        ],
-                        0,
-                    )
-                    file_fds[path] = fd
+                    os.close(fd)
                 except OSError:
                     pass
-
-        refresh()
-        while not self._stop.is_set():
-            fd_to_path = {fd: p for p, fd in file_fds.items()}
-            try:
-                events = kq.control(None, 8, 2.0)
-            except (InterruptedError, OSError):
-                if self._stop.is_set():
-                    break
-                continue
-            if not events:
-                refresh()
-                continue
-            changed: set[str] = set()
-            for ev in events:
-                if ev.ident == dir_fd:
-                    refresh()
-                elif ev.ident in fd_to_path:
-                    changed.add(os.path.basename(fd_to_path[ev.ident]).replace(".md", ""))
-            if changed:
-                with self._lock:
-                    self._queue.extend(changed)
-
-        for fd in file_fds.values():
-            try:
-                os.close(fd)
-            except OSError:
-                pass
-        try:
-            os.close(dir_fd)
-        except OSError:
-            pass
-        kq.close()
+            if dir_fd >= 0:
+                try:
+                    os.close(dir_fd)
+                except OSError:
+                    pass
+            kq.close()
 
     def stop(self) -> None:
         self._stop.set()
@@ -124,4 +129,4 @@ class FileWatcher(Concern):
             self._queue.clear()
         for name in names:
             if not is_suspended(name, self.cfg.suspended_file):
-                self.inbox.nudge_if_unread(name)
+                self.nudge.check_session(name, now)

package/lib/concerns/health.py

@@ -0,0 +1,136 @@
+"""Health monitoring: session keepalive, periodic health checks, resource monitoring."""
+
+import time
+
+from lib.common import date_to_epoch, is_suspended
+from lib.resources import check_battery, check_cpu, check_memory
+
+from .base import Concern
+from .config import DispatcherConfig
+from .coral import CoralManager, CoralPoker
+from .helpers import (
+    board_send,
+    db,
+    get_dev_sessions,
+    is_claude_running,
+    log,
+    tmux_ok,
+    tmux_send,
+)
+
+
+class SessionKeepAlive(Concern):
+    interval = 5
+
+    def __init__(self, cfg: DispatcherConfig) -> None:
+        super().__init__()
+        self.cfg = cfg
+
+    def tick(self, now: int) -> None:
+        for name in get_dev_sessions(self.cfg):
+            if is_suspended(name, self.cfg.suspended_file):
+                continue
+            sess = f"{self.cfg.prefix}-{name}"
+            if tmux_ok("has-session", "-t", sess) and not is_claude_running(sess):
+                log(f"{name}: 同学已退出, NOT restarting (idle policy)")
+
+
+class HealthChecker(Concern):
+    INITIAL = 600
+    MAX = 3600
+    IDLE_THRESHOLD = 1800
+
+    def __init__(self, cfg: DispatcherConfig, poker: CoralPoker, coral: CoralManager) -> None:
+        super().__init__()
+        self.cfg = cfg
+        self.interval = self.INITIAL
+        self.poker = poker
+        self.coral = coral
+        self.last_idle_alert: int = 0
+
+    def tick(self, now: int) -> None:
+        parts = []
+        for name in get_dev_sessions(self.cfg):
+            on = "on" if tmux_ok("has-session", "-t", f"{self.cfg.prefix}-{name}") else "off"
+            parts.append(f"{name}:{on}")
+        status = " ".join(parts)
+
+        log(f"Health check (interval:{self.interval}s): {status}")
+        self.poker.poke(f"[Dispatcher] 健康巡检 {time.strftime('%H:%M:%S')}: {status}")
+        self.interval = min(self.interval * 2, self.MAX)
+        self._check_team_idle(now)
+
+    def _check_team_idle(self, now: int) -> None:
+        if not self.cfg.board_db.exists():
+            return
+        idle_list: list[str] = []
+        total = 0
+        d = db(self.cfg)
+
+        for name in get_dev_sessions(self.cfg):
+            if is_suspended(name, self.cfg.suspended_file):
+                continue
+            sess = f"{self.cfg.prefix}-{name}"
+            if not tmux_ok("has-session", "-t", sess) or not is_claude_running(sess):
+                continue
+            if self.coral.in_grace_period(name, now):
+                continue
+
+            total += 1
+            try:
+                updated = d.scalar("SELECT updated_at FROM sessions WHERE name=?", (name,)) or ""
+            except Exception:
+                continue
+            if updated:
+                age = now - date_to_epoch(updated)
+                if age > self.IDLE_THRESHOLD:
+                    idle_list.append(f"{name}({age}s)")
+
+        if idle_list and len(idle_list) == total and (now - self.last_idle_alert) > 3600:
+            log(f"All sessions idle: {' '.join(idle_list)}")
+            board_send(
+                self.cfg,
+                "lead",
+                f"[Dispatcher] 全员空闲超过 {self.IDLE_THRESHOLD // 60} 分钟:{' '.join(idle_list)}。可能需要分配工作。",
+            )
+            self.last_idle_alert = now
+
+
+class ResourceMonitor(Concern):
+    interval = 60
+
+    def __init__(self, cfg: DispatcherConfig) -> None:
+        super().__init__()
+        self.cfg = cfg
+        self.last_state = ""
+
+    def tick(self, now: int) -> None:
+        batt = check_battery()
+        mem = check_memory()
+        cpu = check_cpu()
+
+        state = f"{batt.status}|{batt.pct}|{mem.status}|{mem.pressure}|{cpu.status}|{cpu.usage}"
+        if state == self.last_state:
+            return
+        self.last_state = state
+
+        if batt.status == "CRITICAL":
+            log(f"RESOURCE: Battery CRITICAL ({batt.pct}%)")
+            board_send(self.cfg, "All", f"[Resource] 电池严重不足 ({batt.pct}%)，暂停非关键 session。")
+            for name in get_dev_sessions(self.cfg):
+                sess = f"{self.cfg.prefix}-{name}"
+                if is_claude_running(sess):
+                    tmux_send(sess, "[系统] 电池严重不足，请立即保存状态。")
+        elif batt.status == "LOW":
+            log(f"RESOURCE: Battery LOW ({batt.pct}%)")
+            board_send(self.cfg, "All", f"[Resource] 电池低 ({batt.pct}%)，建议减少活跃 session 到 2-3 个。")
+
+        if mem.status == "CRITICAL":
+            log("RESOURCE: Memory pressure CRITICAL")
+            board_send(self.cfg, "All", "[Resource] 内存压力严重！建议重启最大的 session 释放内存。")
+        elif mem.status == "WARNING":
+            log("RESOURCE: Memory pressure WARNING")
+            board_send(self.cfg, "All", "[Resource] 内存压力升高，关注中。")
+
+        if cpu.status == "SATURATED":
+            log(f"RESOURCE: CPU saturated ({cpu.usage}%)")

package/lib/concerns/helpers.py

@@ -70,11 +70,7 @@ def get_dev_sessions(cfg: DispatcherConfig) -> list[str]:
         return []
     pfx = f"{cfg.prefix}-"
     protected = {"dispatcher", "lead"}
-    return [
-        line[len(pfx) :]
-        for line in raw.splitlines()
-        if line.startswith(pfx) and line[len(pfx) :] not in protected
-    ]
+    return [line[len(pfx) :] for line in raw.splitlines() if line.startswith(pfx) and line[len(pfx) :] not in protected]
 
 
 def pane_md5(sess: str) -> str:

package/lib/concerns/idle.py

@@ -0,0 +1,130 @@
+"""Idle detection, nudging, and killing for dispatcher sessions."""
+
+import re
+
+from lib.common import is_suspended
+
+from .base import Concern
+from .config import DispatcherConfig
+from .coral import CoralManager
+from .helpers import (
+    board_send,
+    get_dev_sessions,
+    has_tool_process,
+    is_claude_running,
+    log,
+    pane_md5,
+    tmux,
+    tmux_ok,
+    tmux_send,
+)
+
+
+class IdleDetector(Concern):
+    interval = 5
+
+    def __init__(self, cfg: DispatcherConfig) -> None:
+        super().__init__()
+        self.cfg = cfg
+        self.cache: dict[str, str] = {}  # sess -> "idle" | "busy"
+        self._prev_snap: dict[str, str] = {}  # sess -> md5 from previous tick
+
+    def is_idle(self, sess: str) -> bool:
+        return self.cache.get(sess) == "idle"
+
+    def tick(self, now: int) -> None:
+        self.cache.clear()
+        raw = tmux("list-sessions", "-F", "#{session_name}")
+        if not raw:
+            self._prev_snap.clear()
+            return
+
+        all_sessions = [s for s in raw.splitlines() if s.startswith(f"{self.cfg.prefix}-")]
+        need_snapshot: list[str] = []
+
+        for sess in all_sessions:
+            pane = tmux("capture-pane", "-t", sess, "-p") or ""
+            prompts = [l for l in pane.splitlines() if l.startswith("❯")]
+            if prompts and re.match(r"^❯ .{3,}", prompts[-1]):
+                self.cache[sess] = "busy"
+                continue
+            if has_tool_process(sess):
+                self.cache[sess] = "busy"
+                continue
+            need_snapshot.append(sess)
+
+        current_snap: dict[str, str] = {}
+        for sess in need_snapshot:
+            md5 = pane_md5(sess)
+            current_snap[sess] = md5
+            if sess in self._prev_snap and self._prev_snap[sess] == md5:
+                self.cache[sess] = "idle"
+            else:
+                self.cache[sess] = "busy"
+
+        self._prev_snap = {s: pane_md5(s) for s in all_sessions if s not in self.cache or self.cache[s] != "busy"}
+        self._prev_snap.update(current_snap)
+
+
+class IdleKiller(Concern):
+    interval = 5
+    THRESHOLD = 1800
+
+    def __init__(self, cfg: DispatcherConfig, idle: IdleDetector, coral: CoralManager) -> None:
+        super().__init__()
+        self.cfg = cfg
+        self.idle = idle
+        self.coral = coral
+        self.idle_since: 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):
+                self.idle_since.pop(name, None)
+                continue
+
+            if name not in self.coral.boot_times:
+                self.coral.record_boot(name)
+            if self.coral.in_grace_period(name, now):
+                continue
+
+            if self.idle.is_idle(sess):
+                since = self.idle_since.setdefault(name, now)
+                if (now - since) >= self.THRESHOLD:
+                    log(f"{name}: idle {now - since}s (>30min), killing session")
+                    tmux("kill-session", "-t", sess)
+                    self.idle_since.pop(name, None)
+                    board_send(self.cfg, "All", f"[Dispatcher] {name} 闲置超过 30 分钟，已终止。")
+            else:
+                self.idle_since.pop(name, None)
+
+
+class IdleNudger(Concern):
+    interval = 5
+    COOLDOWN = 300
+
+    def __init__(self, cfg: DispatcherConfig, idle: IdleDetector) -> None:
+        super().__init__()
+        self.cfg = cfg
+        self.idle = idle
+        self.last_nudge: dict[str, int] = {}
+
+    def tick(self, now: int) -> None:
+        for name in get_dev_sessions(self.cfg):
+            if is_suspended(name, self.cfg.suspended_file):
+                continue
+            sess = f"{self.cfg.prefix}-{name}"
+            if not tmux_ok("has-session", "-t", sess) or not is_claude_running(sess):
+                continue
+            if not self.idle.is_idle(sess):
+                continue
+            if (now - self.last_nudge.get(name, 0)) < self.COOLDOWN:
+                continue
+
+            log(f"{name}: idle, nudging autonomous loop")
+            tmux_send(
+                sess,
+                f"继续工作。检查你的 OKR ({self.cfg.okr_dir}/{name}.md)，推进你的活跃 KR。自己决定优先级。",
+            )
+            self.last_nudge[name] = now