vibe-pomo 0.1.0

package/src/daemon/db.mjs

@@ -0,0 +1,209 @@
+import Database from 'better-sqlite3'
+import { homedir } from 'node:os'
+import { join } from 'node:path'
+import { mkdirSync } from 'node:fs'
+
+const DB_PATH = join(homedir(), '.claude', 'pomodoro.db')
+
+function openDb() {
+  mkdirSync(join(homedir(), '.claude'), { recursive: true })
+  const db = new Database(DB_PATH)
+  db.pragma('journal_mode = WAL')
+
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS sessions (
+      id             INTEGER PRIMARY KEY AUTOINCREMENT,
+      project_hash   TEXT NOT NULL,
+      project_path   TEXT NOT NULL,
+      started_at     INTEGER NOT NULL,
+      ended_at       INTEGER,
+      planned_ms     INTEGER NOT NULL,
+      actual_ms      INTEGER,
+      cycles         INTEGER DEFAULT 1,
+      status         TEXT NOT NULL,
+      task           TEXT,
+      agent_summary  TEXT,   -- from .claude/pomodoro-summary.md
+      user_activity  TEXT    -- what the user did during this session (entered at session end)
+    );
+
+    -- Migrate existing tables: add new columns if they don't exist yet
+    -- (SQLite doesn't support IF NOT EXISTS for columns, so we use a safe approach)
+
+
+    CREATE TABLE IF NOT EXISTS notifications (
+      id                INTEGER PRIMARY KEY AUTOINCREMENT,
+      session_id        INTEGER REFERENCES sessions(id),
+      received_at       INTEGER NOT NULL,
+      released_at       INTEGER,
+      notification_json TEXT NOT NULL
+    );
+
+    CREATE VIEW IF NOT EXISTS project_stats AS
+    SELECT
+      project_path,
+      COUNT(*)               AS total_sessions,
+      SUM(cycles)            AS total_cycles,
+      SUM(actual_ms) / 60000 AS total_minutes,
+      MAX(started_at)        AS last_active
+    FROM sessions
+    WHERE status != 'broken'
+    GROUP BY project_path;
+  `)
+
+  // Safe column migrations for existing databases
+  const cols = db.prepare(`PRAGMA table_info(sessions)`).all().map((c) => c.name)
+  if (!cols.includes('agent_summary')) {
+    db.exec(`ALTER TABLE sessions ADD COLUMN agent_summary TEXT`)
+  }
+  if (!cols.includes('user_activity')) {
+    db.exec(`ALTER TABLE sessions ADD COLUMN user_activity TEXT`)
+  }
+
+  return db
+}
+
+let _db = null
+function getDb() {
+  if (!_db) _db = openDb()
+  return _db
+}
+
+export function startSession({ projectHash, projectPath, plannedMs, task }) {
+  const db = getDb()
+  const result = db.prepare(`
+    INSERT INTO sessions (project_hash, project_path, started_at, planned_ms, task, status)
+    VALUES (?, ?, ?, ?, ?, 'running')
+  `).run(projectHash, projectPath, Date.now(), plannedMs, task ?? null)
+  return result.lastInsertRowid
+}
+
+export function endSession(sessionId, { actualMs, status, agentSummary }) {
+  const db = getDb()
+  db.prepare(`
+    UPDATE sessions
+    SET ended_at = ?, actual_ms = ?, status = ?, agent_summary = ?
+    WHERE id = ?
+  `).run(Date.now(), actualMs, status, agentSummary ?? null, sessionId)
+}
+
+export function updateSessionActivity(sessionId, { userActivity }) {
+  const db = getDb()
+  db.prepare(`UPDATE sessions SET user_activity = ? WHERE id = ?`)
+    .run(userActivity ?? null, sessionId)
+}
+
+export function saveNotification(sessionId, { notificationJson, receivedAt, releasedAt }) {
+  const db = getDb()
+  db.prepare(`
+    INSERT INTO notifications (session_id, received_at, released_at, notification_json)
+    VALUES (?, ?, ?, ?)
+  `).run(sessionId, receivedAt, releasedAt ?? null, notificationJson)
+}
+
+/** Return stats for Dashboard TUI */
+export function getStats() {
+  const db = getDb()
+  const projects = db.prepare(`
+    SELECT project_path, total_sessions, total_cycles, total_minutes, last_active
+    FROM project_stats ORDER BY last_active DESC LIMIT 10
+  `).all()
+
+  const recent = db.prepare(`
+    SELECT project_path, task, actual_ms, status, started_at, agent_summary, user_activity
+    FROM sessions ORDER BY started_at DESC LIMIT 8
+  `).all()
+
+  return { projects, recent }
+}
+
+/** Return all sessions for a project, for detailed review */
+export function getProjectSessions(projectPath) {
+  const db = getDb()
+  return db.prepare(`
+    SELECT id, task, started_at, ended_at, actual_ms, status, agent_summary, user_activity
+    FROM sessions
+    WHERE project_path = ?
+    ORDER BY started_at DESC
+  `).all(projectPath)
+}
+
+/** Print stats to stdout as a formatted table */
+export function printStats() {
+  const db = getDb()
+
+  const projects = db.prepare(`
+    SELECT
+      project_path,
+      total_sessions,
+      total_cycles,
+      total_minutes,
+      last_active
+    FROM project_stats
+    ORDER BY last_active DESC
+  `).all()
+
+  if (projects.length === 0) {
+    console.log('No completed sessions yet.')
+    return
+  }
+
+  console.log('\nProject Statistics\n' + '─'.repeat(72))
+  console.log(
+    'Project'.padEnd(36) +
+    'Sessions'.padStart(9) +
+    'Cycles'.padStart(8) +
+    'Minutes'.padStart(9) +
+    '  Last Active'
+  )
+  console.log('─'.repeat(72))
+
+  for (const row of projects) {
+    const path = row.project_path.replace(homedir(), '~')
+    const truncated = path.length > 35 ? '…' + path.slice(-34) : path
+    const date = new Date(row.last_active).toLocaleDateString()
+    console.log(
+      truncated.padEnd(36) +
+      String(row.total_sessions).padStart(9) +
+      String(row.total_cycles).padStart(8) +
+      String(row.total_minutes ?? 0).padStart(9) +
+      `  ${date}`
+    )
+  }
+
+  // Recent sessions
+  const recent = db.prepare(`
+    SELECT project_path, task, actual_ms, cycles, status, started_at
+    FROM sessions
+    ORDER BY started_at DESC
+    LIMIT 10
+  `).all()
+
+  console.log('\nRecent Sessions\n' + '─'.repeat(72))
+  console.log(
+    'Task'.padEnd(38) +
+    'Min'.padStart(5) +
+    'Cyc'.padStart(5) +
+    '  Status'.padEnd(14) +
+    '  Date'
+  )
+  console.log('─'.repeat(72))
+
+  for (const s of recent) {
+    const taskLabel = (s.task ?? '(no task)').slice(0, 37).padEnd(38)
+    const mins = s.actual_ms ? String(Math.round(s.actual_ms / 60000)).padStart(5) : '   —'
+    const cyc = String(s.cycles).padStart(5)
+    const status = s.status.padEnd(12)
+    const date = new Date(s.started_at).toLocaleDateString()
+    console.log(`${taskLabel}${mins}${cyc}  ${status}  ${date}`)
+    if (s.agent_summary) {
+      const line = s.agent_summary.split('\n')[0].slice(0, 68)
+      console.log(`  🤖 ${line}`)
+    }
+    if (s.user_activity) {
+      const line = s.user_activity.slice(0, 68)
+      console.log(`  👤 ${line}`)
+    }
+  }
+
+  console.log()
+}

package/src/daemon/index.mjs

@@ -0,0 +1,212 @@
+/**
+ * Global Pomodoro Daemon
+ * Manages multiple concurrent sessions across all Claude Code projects.
+ *
+ * Started by `pomodoro daemon` (foreground, inside Dashboard TUI)
+ * or spawned detached if no dashboard is running.
+ */
+import { createHash } from 'node:crypto'
+import { getSocketPath, writeLock, removeLock, projectHash } from '../shared/lockfile.mjs'
+import { EVT, MSG, STATE, DECISION } from '../shared/protocol.mjs'
+import { IpcServer } from './ipc.mjs'
+import { Session } from './session.mjs'
+import { readFileSync, existsSync } from 'node:fs'
+import { join } from 'node:path'
+import { startSession, endSession, saveNotification, updateSessionActivity } from './db.mjs'
+
+const ipc = new IpcServer()
+
+/** sessionId → Session */
+const sessions = new Map()
+
+/** sessionId → DB row id */
+const dbIds = new Map()
+
+// ── IPC Handlers ─────────────────────────────────────────────────────────────
+
+ipc.on(MSG.QUERY, () => ({
+  sessions: [...sessions.values()].map((s) => s.snapshot()),
+}))
+
+ipc.on(MSG.SESSION_QUERY, (msg) => {
+  const session = sessions.get(msg.sessionId)
+  if (!session) return { error: 'session not found' }
+  return session.snapshot()
+})
+
+ipc.on(MSG.SESSION_CREATE, (msg) => {
+  const { projectDir, task, plannedMs, decisionStrategy = DECISION.WAIT } = msg
+  const hash = projectHash(projectDir ?? process.cwd())
+
+  const session = new Session({
+    projectDir: projectDir ?? process.cwd(),
+    projectHash: hash,
+    task: task ?? '',
+    plannedMs: plannedMs ?? 25 * 60 * 1000,
+    decisionStrategy,
+  })
+
+  sessions.set(session.id, session)
+  wireSessionEvents(session)
+
+  const dbId = startSession({
+    projectHash: hash,
+    projectPath: projectDir ?? process.cwd(),
+    plannedMs: session.plannedMs,
+    task: session.task,
+  })
+  dbIds.set(session.id, dbId)
+
+  // Broadcast snapshot to dashboard subscribers
+  ipc.broadcast({ type: EVT.SNAPSHOT, sessions: [...sessions.values()].map((s) => s.snapshot()) })
+
+  return { sessionId: session.id, ...session.snapshot() }
+})
+
+ipc.on(MSG.SESSION_END, (msg) => {
+  const session = sessions.get(msg.sessionId)
+  if (!session) return { error: 'session not found' }
+  session.end()
+  return { ok: true }
+})
+
+ipc.on(MSG.SESSION_BREAK, (msg) => {
+  const session = sessions.get(msg.sessionId)
+  if (!session) return { error: 'session not found' }
+  session.break()
+  return { ok: true }
+})
+
+ipc.on(MSG.SESSION_UPDATE_ACTIVITY, (msg) => {
+  const dbId = dbIds.get(msg.sessionId)
+  if (!dbId) return { error: 'session not found' }
+  updateSessionActivity(dbId, { userActivity: msg.userActivity })
+  return { ok: true }
+})
+
+ipc.on(MSG.QUEUE_NOTIFICATION, (msg) => {
+  const session = sessions.get(msg.sessionId)
+  if (!session) return { ok: false, error: 'session not found' }
+  session.enqueueNotification(msg.notification)
+  return { ok: true, queued: session.queueSize }
+})
+
+ipc.on(MSG.AGENT_STOPPING, (msg) => {
+  const session = sessions.get(msg.sessionId)
+  if (!session || session.state === STATE.ENDED) return { action: 'allow' }
+
+  if (session.decisionStrategy === DECISION.BREAK) {
+    session.break()
+    return { action: 'allow' }
+  }
+
+  // Default: WAIT
+  return {
+    action: 'block',
+    remainingFormatted: formatMs(session.remaining),
+  }
+})
+
+// ── Session event wiring ──────────────────────────────────────────────────────
+
+function wireSessionEvents(session) {
+  session.on('tick', (data) => {
+    ipc.broadcast({ type: EVT.TICK, ...data })
+  })
+
+  session.on('overtime', () => {
+    const now = Date.now()
+    session.flushNotifications((item) => {
+      const releasedAt = now
+      const event = {
+        type: EVT.NOTIFICATION,
+        sessionId: session.id,
+        notification: item.notification,
+        receivedAt: item.receivedAt,
+        releasedAt,
+      }
+      ipc.broadcast(event)
+      const dbId = dbIds.get(session.id)
+      if (dbId) saveNotification(dbId, {
+        notificationJson: JSON.stringify(item.notification),
+        receivedAt: item.receivedAt,
+        releasedAt,
+      })
+    })
+  })
+
+  session.on('ended', ({ sessionId, status, actualMs }) => {
+    // Flush remaining notifications (if ended before overtime)
+    const now = Date.now()
+    session.flushNotifications((item) => {
+      const releasedAt = now
+      const event = {
+        type: EVT.NOTIFICATION,
+        sessionId,
+        notification: item.notification,
+        receivedAt: item.receivedAt,
+        releasedAt,
+      }
+      ipc.broadcast(event)
+      const dbId = dbIds.get(sessionId)
+      if (dbId) saveNotification(dbId, {
+        notificationJson: JSON.stringify(item.notification),
+        receivedAt: item.receivedAt,
+        releasedAt,
+      })
+    })
+
+    const dbId = dbIds.get(sessionId)
+    if (dbId) {
+      const agentSummary = readAgentSummary(session.projectDir)
+      endSession(dbId, { actualMs, status, agentSummary })
+    }
+
+    sessions.delete(sessionId)
+    dbIds.delete(sessionId)
+
+    ipc.broadcast({ type: EVT.SESSION_ENDED, sessionId, status, actualMs })
+    ipc.broadcast({ type: EVT.SNAPSHOT, sessions: [...sessions.values()].map((s) => s.snapshot()) })
+  })
+}
+
+// ── Startup ───────────────────────────────────────────────────────────────────
+
+export async function startDaemon() {
+  const socketPath = getSocketPath()
+  await ipc.listen(socketPath)
+
+  writeLock({ pid: process.pid, socketPath, startedAt: Date.now() })
+
+  process.on('SIGTERM', shutdown)
+  process.on('SIGINT', shutdown)
+
+  return ipc
+}
+
+function shutdown() {
+  for (const session of sessions.values()) session.break()
+  removeLock()
+  ipc.close()
+  setTimeout(() => process.exit(0), 300)
+}
+
+// ── Helpers ───────────────────────────────────────────────────────────────────
+
+function formatMs(ms) {
+  const m = Math.floor(ms / 60000)
+  const s = Math.floor((ms % 60000) / 1000)
+  return `${String(m).padStart(2, '0')}:${String(s).padStart(2, '0')}`
+}
+
+function readAgentSummary(projectDir) {
+  const summaryPath = join(projectDir, '.claude', 'pomodoro-summary.md')
+  if (!existsSync(summaryPath)) return null
+  try {
+    const text = readFileSync(summaryPath, 'utf8').trim()
+    // Keep first 500 chars for storage; full file stays on disk
+    return text.slice(0, 500) || null
+  } catch {
+    return null
+  }
+}

package/src/daemon/ipc.mjs

@@ -0,0 +1,96 @@
+import net from 'node:net'
+import { existsSync, unlinkSync } from 'node:fs'
+import { encode, EVT } from '../shared/protocol.mjs'
+
+/**
+ * Unix domain socket server for daemon IPC.
+ * Handles message routing between hooks/TUI and the daemon.
+ */
+export class IpcServer {
+  #server = null
+  #subscribers = new Set()
+  #handlers = {}
+
+  /**
+   * Register a handler for incoming message type.
+   * Handler receives (parsedMsg, socket) and should return a response object or null.
+   */
+  on(type, handler) {
+    this.#handlers[type] = handler
+  }
+
+  async listen(socketPath) {
+    // Clean up stale socket file
+    if (existsSync(socketPath)) {
+      unlinkSync(socketPath)
+    }
+
+    return new Promise((resolve, reject) => {
+      this.#server = net.createServer((socket) => {
+        this.#handleConnection(socket)
+      })
+
+      this.#server.once('error', reject)
+      this.#server.listen(socketPath, () => {
+        this.#server.removeListener('error', reject)
+        this.#server.on('error', (err) => {
+          console.error('[ipc] server error:', err.message)
+        })
+        resolve()
+      })
+    })
+  }
+
+  #handleConnection(socket) {
+    let buffer = ''
+
+    socket.on('data', async (chunk) => {
+      buffer += chunk.toString()
+      let newline
+      while ((newline = buffer.indexOf('\n')) !== -1) {
+        const line = buffer.slice(0, newline).trim()
+        buffer = buffer.slice(newline + 1)
+        if (!line) continue
+
+        let msg
+        try { msg = JSON.parse(line) } catch { continue }
+
+        if (msg.type === 'subscribe') {
+          this.#subscribers.add(socket)
+          socket.once('close', () => this.#subscribers.delete(socket))
+          // Send current state immediately on subscribe
+          const handler = this.#handlers['query']
+          if (handler) {
+            const state = await handler(msg, socket)
+            if (state) socket.write(encode({ type: EVT.STATE, ...state }))
+          }
+          continue
+        }
+
+        const handler = this.#handlers[msg.type]
+        if (handler) {
+          const response = await handler(msg, socket)
+          if (response !== null && response !== undefined) {
+            socket.write(encode(response))
+          }
+        }
+      }
+    })
+
+    socket.on('error', () => {
+      this.#subscribers.delete(socket)
+    })
+  }
+
+  /** Broadcast an event to all subscribed clients (TUI) */
+  broadcast(event) {
+    const data = encode(event)
+    for (const socket of this.#subscribers) {
+      try { socket.write(data) } catch {}
+    }
+  }
+
+  close() {
+    this.#server?.close()
+  }
+}

package/src/daemon/notificationQueue.mjs

@@ -0,0 +1,39 @@
+/**
+ * Holds notifications intercepted during a Pomodoro session.
+ * Released all at once when the session enters overtime or ends.
+ */
+export class NotificationQueue {
+  #queue = []
+  #onFlush = null
+
+  /** Register callback invoked with each notification when flushed */
+  onFlush(cb) {
+    this.#onFlush = cb
+  }
+
+  enqueue(notification) {
+    this.#queue.push({
+      notification,
+      receivedAt: Date.now(),
+    })
+  }
+
+  flush() {
+    const items = [...this.#queue]
+    this.#queue = []
+    if (this.#onFlush) {
+      for (const item of items) {
+        this.#onFlush(item)
+      }
+    }
+    return items
+  }
+
+  get size() {
+    return this.#queue.length
+  }
+
+  toArray() {
+    return [...this.#queue]
+  }
+}

package/src/daemon/session.mjs

@@ -0,0 +1,109 @@
+import { EventEmitter } from 'node:events'
+import { randomUUID } from 'node:crypto'
+import { STATE } from '../shared/protocol.mjs'
+import { NotificationQueue } from './notificationQueue.mjs'
+
+/**
+ * A single Pomodoro session with its own timer and notification queue.
+ */
+export class Session extends EventEmitter {
+  id
+  projectDir
+  projectHash
+  task
+  plannedMs
+  decisionStrategy
+  startedAt
+
+  #state = STATE.RUNNING
+  #overtimeAt = null
+  #interval = null
+  #queue = new NotificationQueue()
+
+  constructor({ projectDir, projectHash, task, plannedMs, decisionStrategy }) {
+    super()
+    this.id = randomUUID()
+    this.projectDir = projectDir
+    this.projectHash = projectHash
+    this.task = task
+    this.plannedMs = plannedMs
+    this.decisionStrategy = decisionStrategy
+    this.startedAt = Date.now()
+
+    this.#interval = setInterval(() => this.#tick(), 1000)
+    this.#tick()
+  }
+
+  get state() { return this.#state }
+
+  get remaining() {
+    if (this.#state === STATE.OVERTIME || this.#state === STATE.ENDED) return 0
+    return Math.max(0, this.plannedMs - (Date.now() - this.startedAt))
+  }
+
+  get overtime() {
+    if (!this.#overtimeAt) return 0
+    return Date.now() - this.#overtimeAt
+  }
+
+  get actualMs() {
+    return Date.now() - this.startedAt
+  }
+
+  get queueSize() {
+    return this.#queue.size
+  }
+
+  snapshot() {
+    return {
+      sessionId: this.id,
+      projectDir: this.projectDir,
+      task: this.task,
+      plannedMs: this.plannedMs,
+      state: this.#state,
+      remaining: this.remaining,
+      overtime: this.overtime,
+      queuedNotifications: this.#queue.size,
+      startedAt: this.startedAt,
+    }
+  }
+
+  enqueueNotification(notification) {
+    this.#queue.enqueue(notification)
+  }
+
+  flushNotifications(onItem) {
+    this.#queue.onFlush(onItem)
+    this.#queue.flush()
+  }
+
+  /** User pressed [E] End Session */
+  end() { this.#finish('completed') }
+
+  /** User pressed [B] Break */
+  break() { this.#finish('broken') }
+
+  #tick() {
+    if (this.#state === STATE.RUNNING && this.remaining === 0) {
+      this.#state = STATE.OVERTIME
+      this.#overtimeAt = Date.now()
+      this.emit('overtime')
+    }
+    if (this.#state !== STATE.ENDED) {
+      this.emit('tick', {
+        sessionId: this.id,
+        state: this.#state,
+        remaining: this.remaining,
+        overtime: this.overtime,
+        queuedNotifications: this.#queue.size,
+      })
+    }
+  }
+
+  #finish(status) {
+    if (this.#state === STATE.ENDED) return
+    clearInterval(this.#interval)
+    this.#state = STATE.ENDED
+    this.emit('ended', { sessionId: this.id, status, actualMs: this.actualMs })
+  }
+}