vibe-pomo 0.1.0

package/src/daemon/timer.mjs

@@ -0,0 +1,100 @@
+import { EventEmitter } from 'node:events'
+import { STATE } from '../shared/protocol.mjs'
+
+/**
+ * Timer state machine:
+ *   idle → running → overtime → ended
+ *
+ * Transitions:
+ *   start()  : idle → running
+ *   (tick)   : running → overtime when remaining hits 0
+ *   end()    : running|overtime → ended (user-initiated)
+ *   break()  : running|overtime → ended (user pressed Break)
+ *
+ * Events emitted:
+ *   'tick'     { state, remaining, overtime }  — every second
+ *   'overtime' {}                              — first tick at 0
+ *   'ended'    { status }                     — final state
+ */
+export class Timer extends EventEmitter {
+  #state = STATE.IDLE
+  #plannedMs
+  #startedAt = null
+  #overtimeAt = null
+  #interval = null
+
+  constructor(plannedMs) {
+    super()
+    this.#plannedMs = plannedMs
+  }
+
+  get state() { return this.#state }
+  get startedAt() { return this.#startedAt }
+
+  get remaining() {
+    if (!this.#startedAt) return this.#plannedMs
+    if (this.#state === STATE.OVERTIME || this.#state === STATE.ENDED) return 0
+    const elapsed = Date.now() - this.#startedAt
+    return Math.max(0, this.#plannedMs - elapsed)
+  }
+
+  get overtime() {
+    if (!this.#overtimeAt) return 0
+    return Date.now() - this.#overtimeAt
+  }
+
+  get actualMs() {
+    if (!this.#startedAt) return 0
+    return Date.now() - this.#startedAt
+  }
+
+  snapshot() {
+    return {
+      state: this.#state,
+      remaining: this.remaining,
+      overtime: this.overtime,
+      plannedMs: this.#plannedMs,
+      startedAt: this.#startedAt,
+    }
+  }
+
+  start() {
+    if (this.#state !== STATE.IDLE) return
+    this.#state = STATE.RUNNING
+    this.#startedAt = Date.now()
+    this.#interval = setInterval(() => this.#tick(), 1000)
+    this.#tick() // immediate first tick
+  }
+
+  /** User-initiated end (End Session button) */
+  end() {
+    this.#finish('completed')
+  }
+
+  /** User-initiated break (Break button) */
+  break() {
+    this.#finish('broken')
+  }
+
+  #tick() {
+    if (this.#state === STATE.RUNNING && this.remaining === 0) {
+      this.#state = STATE.OVERTIME
+      this.#overtimeAt = Date.now()
+      this.emit('overtime')
+    }
+
+    this.emit('tick', {
+      state: this.#state,
+      remaining: this.remaining,
+      overtime: this.overtime,
+    })
+  }
+
+  #finish(status) {
+    if (this.#state === STATE.ENDED) return
+    clearInterval(this.#interval)
+    this.#interval = null
+    this.#state = STATE.ENDED
+    this.emit('ended', { status, actualMs: this.actualMs })
+  }
+}

package/src/hooks/notification.mjs

@@ -0,0 +1,53 @@
+/**
+ * Notification hook — queue notifications during an active Pomodoro session.
+ */
+import { readLock, projectHash } from '../shared/lockfile.mjs'
+import { sendAndReceive } from '../shared/ipcClient.mjs'
+import { STATE, MSG } from '../shared/protocol.mjs'
+
+async function readStdin() {
+  return new Promise((resolve) => {
+    if (process.stdin.isTTY) return resolve('')
+    let data = ''
+    process.stdin.setEncoding('utf8')
+    process.stdin.on('data', (c) => { data += c })
+    process.stdin.on('end', () => resolve(data))
+  })
+}
+
+async function main() {
+  const lock = readLock()
+  if (!lock) process.exit(0)
+
+  const projectDir = process.env.CLAUDE_PROJECT_DIR ?? process.cwd()
+  const hash = projectHash(projectDir)
+
+  let state
+  try {
+    state = await sendAndReceive({ type: MSG.QUERY })
+  } catch {
+    process.exit(0)
+  }
+
+  const active = state.sessions?.find(
+    (s) => s.projectHash === hash &&
+           (s.state === STATE.RUNNING || s.state === STATE.OVERTIME)
+  )
+  if (!active) process.exit(0)
+
+  const raw = await readStdin()
+  let notification = {}
+  try { notification = JSON.parse(raw) } catch {}
+
+  try {
+    await sendAndReceive({
+      type: MSG.QUEUE_NOTIFICATION,
+      sessionId: active.sessionId,
+      notification,
+    })
+  } catch {}
+
+  process.exit(0)
+}
+
+main().catch(() => process.exit(0))

package/src/hooks/preToolUse.mjs

@@ -0,0 +1,38 @@
+/**
+ * PreToolUse hook — auto-approve tool calls during an active Pomodoro session.
+ * Transparency: if no daemon running or no active session for this project, exits 0.
+ */
+import { readLock, projectHash } from '../shared/lockfile.mjs'
+import { sendAndReceive } from '../shared/ipcClient.mjs'
+import { STATE, MSG } from '../shared/protocol.mjs'
+
+async function main() {
+  const lock = readLock()
+  if (!lock) process.exit(0)
+
+  const projectDir = process.env.CLAUDE_PROJECT_DIR ?? process.cwd()
+
+  let state
+  try {
+    state = await sendAndReceive({ type: MSG.QUERY })
+  } catch {
+    process.exit(0)
+  }
+
+  // Find an active session for this project
+  const hash = projectHash(projectDir)
+  const active = state.sessions?.find(
+    (s) => s.projectHash === hash &&
+           (s.state === STATE.RUNNING || s.state === STATE.OVERTIME)
+  )
+
+  if (active) {
+    process.stdout.write(JSON.stringify({
+      hookSpecificOutput: { permissionDecision: 'allow' }
+    }) + '\n')
+  }
+
+  process.exit(0)
+}
+
+main().catch(() => process.exit(0))

package/src/hooks/stop.mjs

@@ -0,0 +1,70 @@
+/**
+ * Stop hook — called when Claude Code agent finishes.
+ * Blocks the agent if a Pomodoro is active for this project.
+ */
+import { readLock, projectHash } from '../shared/lockfile.mjs'
+import { sendAndReceive } from '../shared/ipcClient.mjs'
+import { STATE, MSG } from '../shared/protocol.mjs'
+
+async function readStdin() {
+  return new Promise((resolve) => {
+    if (process.stdin.isTTY) return resolve('')
+    let data = ''
+    process.stdin.setEncoding('utf8')
+    process.stdin.on('data', (c) => { data += c })
+    process.stdin.on('end', () => resolve(data))
+  })
+}
+
+async function main() {
+  const lock = readLock()
+  if (!lock) process.exit(0)
+
+  const projectDir = process.env.CLAUDE_PROJECT_DIR ?? process.cwd()
+  const hash = projectHash(projectDir)
+
+  let state
+  try {
+    state = await sendAndReceive({ type: MSG.QUERY })
+  } catch {
+    process.exit(0)
+  }
+
+  const active = state.sessions?.find(
+    (s) => s.projectHash === hash &&
+           (s.state === STATE.RUNNING || s.state === STATE.OVERTIME)
+  )
+  if (!active) process.exit(0)
+
+  const raw = await readStdin()
+  let input = {}
+  try { input = JSON.parse(raw) } catch {}
+
+  let resp
+  try {
+    resp = await sendAndReceive({
+      type: MSG.AGENT_STOPPING,
+      sessionId: active.sessionId,
+      stopReason: input.stop_reason ?? input.reason,
+    })
+  } catch {
+    process.exit(0)
+  }
+
+  if (resp.action === 'block') {
+    process.stdout.write(JSON.stringify({
+      decision: 'block',
+      reason: `Pomodoro active (${resp.remainingFormatted} remaining). Waiting for user to end session.`,
+      systemMessage: [
+        'The Pomodoro focus session is still running.',
+        `Time remaining: ${resp.remainingFormatted}.`,
+        'The user is not available. Do not send messages or notifications.',
+        'Record any pending decisions in `.claude/pomodoro-pending.md` and wait quietly.',
+      ].join(' '),
+    }) + '\n')
+  }
+
+  process.exit(0)
+}
+
+main().catch(() => process.exit(0))

package/src/shared/config.mjs

@@ -0,0 +1,58 @@
+import { readFileSync, existsSync, writeFileSync, mkdirSync } from 'node:fs'
+import { homedir } from 'node:os'
+import { join, dirname } from 'node:path'
+import { DECISION } from './protocol.mjs'
+
+const CONFIG_PATH = join(homedir(), '.claude', 'pomodoro.json')
+
+const DEFAULTS = {
+  defaultDurationMs: 25 * 60 * 1000,   // 25 minutes
+  decisionStrategy: DECISION.WAIT,
+  terminalEmulator: 'auto',
+  soundOnOvertime: true,
+}
+
+export function loadConfig() {
+  if (!existsSync(CONFIG_PATH)) {
+    return { ...DEFAULTS }
+  }
+  try {
+    const raw = JSON.parse(readFileSync(CONFIG_PATH, 'utf8'))
+    return { ...DEFAULTS, ...raw }
+  } catch {
+    return { ...DEFAULTS }
+  }
+}
+
+export function ensureConfigFile() {
+  if (!existsSync(CONFIG_PATH)) {
+    mkdirSync(dirname(CONFIG_PATH), { recursive: true })
+    writeFileSync(CONFIG_PATH, JSON.stringify(DEFAULTS, null, 2) + '\n', 'utf8')
+    return true
+  }
+  return false
+}
+
+export function formatDuration(ms) {
+  const totalSec = Math.floor(ms / 1000)
+  const m = Math.floor(totalSec / 60)
+  const s = totalSec % 60
+  return `${String(m).padStart(2, '0')}:${String(s).padStart(2, '0')}`
+}
+
+/**
+ * Parse duration string like "25m", "1h", "90s", or plain number (minutes).
+ * Returns milliseconds.
+ */
+export function parseDuration(str) {
+  if (!str) return null
+  const s = String(str).trim()
+  const match = s.match(/^(\d+)(m|h|s)?$/)
+  if (!match) return null
+  const n = parseInt(match[1], 10)
+  const unit = match[2] || 'm'
+  if (unit === 'h') return n * 60 * 60 * 1000
+  if (unit === 'm') return n * 60 * 1000
+  if (unit === 's') return n * 1000
+  return null
+}

package/src/shared/ipcClient.mjs

@@ -0,0 +1,73 @@
+import net from 'node:net'
+import { encode } from './protocol.mjs'
+import { getSocketPath } from './lockfile.mjs'
+
+const DEFAULT_TIMEOUT_MS = 500
+
+/**
+ * Send one message, receive one JSON response.
+ * Used by hook scripts and CLI commands.
+ */
+export function sendAndReceive(msgObj, timeoutMs = DEFAULT_TIMEOUT_MS) {
+  const socketPath = getSocketPath()
+  return new Promise((resolve, reject) => {
+    const client = net.createConnection(socketPath)
+    let buffer = ''
+    let settled = false
+
+    const timer = setTimeout(() => {
+      if (!settled) { settled = true; client.destroy(); reject(new Error('IPC timeout')) }
+    }, timeoutMs)
+
+    client.once('connect', () => client.write(encode(msgObj)))
+
+    client.on('data', (chunk) => {
+      buffer += chunk.toString()
+      const newline = buffer.indexOf('\n')
+      if (newline !== -1 && !settled) {
+        settled = true
+        clearTimeout(timer)
+        client.destroy()
+        try { resolve(JSON.parse(buffer.slice(0, newline))) }
+        catch { reject(new Error('Invalid JSON response')) }
+      }
+    })
+
+    client.on('error', (err) => {
+      if (!settled) { settled = true; clearTimeout(timer); reject(err) }
+    })
+  })
+}
+
+/**
+ * Subscribe to daemon push events (for TUI clients).
+ * Returns { send(msg), close() }.
+ */
+export function subscribe(onEvent, onError) {
+  const socketPath = getSocketPath()
+  const client = net.createConnection(socketPath)
+  let buffer = ''
+
+  client.once('connect', () => {
+    client.write(encode({ type: 'subscribe' }))
+  })
+
+  client.on('data', (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
+      try { onEvent(JSON.parse(line)) } catch {}
+    }
+  })
+
+  client.on('error', (err) => { if (onError) onError(err) })
+  client.on('close', () => { if (onError) onError(new Error('Connection closed')) })
+
+  return {
+    send(msgObj) { try { client.write(encode(msgObj)) } catch {} },
+    close() { client.destroy() },
+  }
+}

package/src/shared/lockfile.mjs

@@ -0,0 +1,51 @@
+import { createHash } from 'node:crypto'
+import { readFileSync, writeFileSync, unlinkSync, existsSync } from 'node:fs'
+import { homedir } from 'node:os'
+import { join } from 'node:path'
+
+const CLAUDE_DIR = join(homedir(), '.claude')
+const LOCK_PATH = join(CLAUDE_DIR, 'pomodoro.lock')
+const SOCKET_PATH = join(CLAUDE_DIR, 'pomodoro.sock')
+
+export function getSocketPath() {
+  return SOCKET_PATH
+}
+
+export function getLockPath() {
+  return LOCK_PATH
+}
+
+/**
+ * Read global lock. Returns null if file missing, malformed, or PID dead.
+ */
+export function readLock() {
+  if (!existsSync(LOCK_PATH)) return null
+  let data
+  try {
+    data = JSON.parse(readFileSync(LOCK_PATH, 'utf8'))
+  } catch {
+    return null
+  }
+  try {
+    process.kill(data.pid, 0)
+  } catch {
+    try { unlinkSync(LOCK_PATH) } catch {}
+    try { unlinkSync(SOCKET_PATH) } catch {}
+    return null
+  }
+  return data
+}
+
+export function writeLock(data) {
+  writeFileSync(LOCK_PATH, JSON.stringify(data), 'utf8')
+}
+
+export function removeLock() {
+  try { unlinkSync(LOCK_PATH) } catch {}
+  try { unlinkSync(SOCKET_PATH) } catch {}
+}
+
+/** Stable short ID for a project directory */
+export function projectHash(dir) {
+  return createHash('sha1').update(dir).digest('hex').slice(0, 12)
+}

package/src/shared/protocol.mjs

@@ -0,0 +1,44 @@
+/**
+ * IPC message type constants and builders.
+ * All messages are newline-delimited JSON over Unix domain socket.
+ */
+
+// Client → Daemon
+export const MSG = {
+  QUERY:               'query',          // get daemon state + all sessions
+  SESSION_QUERY:       'sessionQuery',   // get single session state
+  SESSION_CREATE:      'sessionCreate',  // start a new session
+  SESSION_END:         'sessionEnd',     // user ends session (End button)
+  SESSION_BREAK:       'sessionBreak',   // user breaks session (Break button)
+  AGENT_STOPPING:      'agentStopping',  // stop hook: agent finished
+  QUEUE_NOTIFICATION:  'queueNotification',
+  SUBSCRIBE:                'subscribe',
+  SUBSCRIBE_SESSION:        'subscribeSession',
+  SESSION_UPDATE_ACTIVITY:  'sessionUpdateActivity', // save user's own activity note
+}
+
+// Daemon → Client (push)
+export const EVT = {
+  TICK:         'tick',          // { sessionId, state, remaining, overtime }
+  NOTIFICATION: 'notification',  // { sessionId, notification, receivedAt, releasedAt }
+  SESSION_ENDED:'sessionEnded',  // { sessionId, status, actualMs }
+  SNAPSHOT:     'snapshot',      // full daemon state (on subscribe)
+}
+
+// Timer states
+export const STATE = {
+  IDLE:     'idle',
+  RUNNING:  'running',
+  OVERTIME: 'overtime',
+  ENDED:    'ended',
+}
+
+// Decision strategies
+export const DECISION = {
+  WAIT:  'wait',   // block agent silently until user ends session
+  BREAK: 'break',  // immediately end session
+}
+
+export function encode(obj) {
+  return JSON.stringify(obj) + '\n'
+}

package/src/tui/App.tsx

@@ -0,0 +1,149 @@
+import React, { useState, useEffect, useCallback } from 'react'
+import { Box, Text, useInput, useStdout } from 'ink'
+import { Timer } from './components/Timer.js'
+import { TaskBar } from './components/TaskBar.js'
+import { NotificationLog } from './components/NotificationLog.js'
+import { TuiIpcClient } from './ipcClient.mjs'
+import { STATE } from '../shared/protocol.mjs'
+
+interface AppProps {
+  socketPath: string
+  task: string
+  plannedMs: number
+}
+
+interface TickState {
+  state: string
+  remaining: number
+  overtime: number
+  queuedNotifications?: number
+}
+
+interface NotificationEntry {
+  notification: Record<string, unknown>
+  receivedAt: number
+  releasedAt: number
+}
+
+export function App({ socketPath, task: initialTask, plannedMs }: AppProps) {
+  const { stdout } = useStdout()
+  const width = stdout?.columns ?? 60
+
+  const [tick, setTick] = useState<TickState>({
+    state: STATE.RUNNING,
+    remaining: plannedMs,
+    overtime: 0,
+    queuedNotifications: 0,
+  })
+  const [notifications, setNotifications] = useState<NotificationEntry[]>([])
+  const [task, setTask] = useState(initialTask)
+  const [connectionError, setConnectionError] = useState<string | null>(null)
+  const [ipc] = useState(() => new TuiIpcClient(socketPath))
+
+  useEffect(() => {
+    ipc.connect({
+      onTick: (event) => {
+        setTick({
+          state: event.state,
+          remaining: event.remaining ?? 0,
+          overtime: event.overtime ?? 0,
+          queuedNotifications: event.queuedNotifications ?? 0,
+        })
+        if (event.task) setTask(event.task)
+      },
+      onNotification: (event) => {
+        setNotifications((prev) => [...prev, {
+          notification: event.notification,
+          receivedAt: event.receivedAt,
+          releasedAt: event.releasedAt,
+        }])
+      },
+      onEnded: () => {
+        setTick((prev) => ({ ...prev, state: STATE.ENDED }))
+        // Give time for final notifications to render, then exit
+        setTimeout(() => process.exit(0), 3000)
+      },
+      onError: (err) => {
+        if (tick.state !== STATE.ENDED) {
+          setConnectionError(err.message)
+        }
+      },
+    })
+
+    return () => ipc.close()
+  }, [])
+
+  const handleEnd = useCallback(async () => {
+    await ipc.sendEnd()
+  }, [ipc])
+
+  const handleBreak = useCallback(async () => {
+    await ipc.sendBreak()
+  }, [ipc])
+
+  useInput((input, key) => {
+    if (tick.state === STATE.ENDED) {
+      if (input === 'q' || key.escape) process.exit(0)
+      return
+    }
+    if (input === 'e' || input === 'E') handleEnd()
+    if (input === 'b' || input === 'B') handleBreak()
+    if (input === 'q' || key.escape) process.exit(0)
+  })
+
+  const isOvertime = tick.state === STATE.OVERTIME
+  const isEnded = tick.state === STATE.ENDED
+
+  const keybindings = isEnded
+    ? '[Q] Quit'
+    : isOvertime
+      ? '[E] End Session    [B] Break    [Q] Quit'
+      : '[B] Break    [Q] Quit'
+
+  return (
+    <Box flexDirection="column" width={width} paddingX={2} paddingY={1}>
+      {/* Header */}
+      <Box marginBottom={1}>
+        <Text bold color={isOvertime ? 'yellow' : isEnded ? 'gray' : 'red'}>
+          🍅 Pomodoro
+        </Text>
+      </Box>
+
+      {/* Timer */}
+      <Timer
+        state={tick.state}
+        remaining={tick.remaining}
+        overtime={tick.overtime}
+      />
+
+      {/* Task */}
+      <TaskBar task={task} width={width} />
+
+      {/* Notification log */}
+      <NotificationLog
+        notifications={notifications}
+        queued={tick.queuedNotifications ?? 0}
+        width={width - 4}
+      />
+
+      {/* Error */}
+      {connectionError && (
+        <Box marginTop={1}>
+          <Text color="red">Connection lost: {connectionError}</Text>
+        </Box>
+      )}
+
+      {/* Ended message */}
+      {isEnded && (
+        <Box marginTop={1}>
+          <Text color="green" bold>Session complete. Press Q to exit.</Text>
+        </Box>
+      )}
+
+      {/* Keybindings */}
+      <Box marginTop={1}>
+        <Text color="gray" dimColor>{keybindings}</Text>
+      </Box>
+    </Box>
+  )
+}

package/src/tui/components/NotificationLog.tsx

@@ -0,0 +1,60 @@
+import React from 'react'
+import { Box, Text } from 'ink'
+
+interface NotificationEntry {
+  notification: Record<string, unknown>
+  receivedAt: number
+  releasedAt: number
+}
+
+interface NotificationLogProps {
+  notifications: NotificationEntry[]
+  queued: number
+  width: number
+}
+
+function formatTime(ms: number): string {
+  return new Date(ms).toLocaleTimeString()
+}
+
+export function NotificationLog({ notifications, queued, width }: NotificationLogProps) {
+  const maxVisible = 8
+
+  return (
+    <Box flexDirection="column" marginTop={1}>
+      <Box marginBottom={0}>
+        <Text bold color="white"> Notifications </Text>
+        {queued > 0 && (
+          <Text color="yellow"> ({queued} queued, releasing at overtime…)</Text>
+        )}
+        {queued === 0 && notifications.length === 0 && (
+          <Text color="gray"> (will appear when timer ends)</Text>
+        )}
+      </Box>
+
+      <Box
+        flexDirection="column"
+        borderStyle="single"
+        borderColor="gray"
+        paddingX={1}
+        width={width - 2}
+      >
+        {notifications.length === 0 ? (
+          <Text color="gray" dimColor> —</Text>
+        ) : (
+          notifications.slice(-maxVisible).map((entry, i) => {
+            const n = entry.notification as any
+            const title = n?.title ?? n?.message ?? JSON.stringify(n).slice(0, 60)
+            const time = formatTime(entry.releasedAt)
+            return (
+              <Box key={i}>
+                <Text color="gray">{time}  </Text>
+                <Text>{title}</Text>
+              </Box>
+            )
+          })
+        )}
+      </Box>
+    </Box>
+  )
+}