vibe-pomo 0.1.3 → 0.2.0

package/install.mjs

@@ -7,45 +7,45 @@ import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'node:fs'
 import { homedir } from 'node:os'
 import { join, dirname } from 'node:path'
 import { fileURLToPath } from 'node:url'
-import { createRequire } from 'node:module'
 
 const __dirname = dirname(fileURLToPath(import.meta.url))
 const HOOKS_DIR = join(__dirname, 'src', 'hooks')
 const SETTINGS_PATH = join(homedir(), '.claude', 'settings.json')
 
+// Normalize path separators for bash compatibility on Windows.
+// Claude Code runs hooks via bash even on Windows, so backslashes must
+// become forward slashes. E.g. E:\path\node.exe → E:/path/node.exe
+const normPath = (p) => p.replace(/\\/g, '/')
+
+// Quote a path only if it contains spaces.
+const q = (p) => { const n = normPath(p); return n.includes(' ') ? `"${n}"` : n }
+
+// The hook script files vibe-pomo owns — used to detect and replace stale entries.
+const HOOK_SCRIPTS = ['preToolUse.mjs', 'notification.mjs', 'stop.mjs']
+
+function isVibePomоHook(hookEntry) {
+  return hookEntry.hooks?.some((h) =>
+    HOOK_SCRIPTS.some((f) => h.command?.includes(f))
+  )
+}
+
 export function runInstall() {
-  const nodeExec = process.execPath
-  // On Windows, backslashes in paths break bash (used by Claude Code hooks).
-  // Convert to forward slashes, which work in both cmd/PowerShell and Git Bash.
-  const normPath = (p) => p.replace(/\\/g, '/')
-  const q = (p) => { const n = normPath(p); return n.includes(' ') ? `"${n}"` : n }
+  // Use 'node' from PATH rather than process.execPath so the command works
+  // across all shells (bash, PowerShell, cmd) without platform-specific path issues.
+  const nodeCmd = 'node'
+  const scriptPath = (name) => q(join(HOOKS_DIR, name))
 
   const hookDefs = {
-    PreToolUse: [
-      {
-        matcher: '.*',
-        hooks: [{
-          type: 'command',
-          command: `${q(nodeExec)} ${q(join(HOOKS_DIR, 'preToolUse.mjs'))}`,
-        }],
-      },
-    ],
-    Notification: [
-      {
-        hooks: [{
-          type: 'command',
-          command: `${q(nodeExec)} ${q(join(HOOKS_DIR, 'notification.mjs'))}`,
-        }],
-      },
-    ],
-    Stop: [
-      {
-        hooks: [{
-          type: 'command',
-          command: `${q(nodeExec)} ${q(join(HOOKS_DIR, 'stop.mjs'))}`,
-        }],
-      },
-    ],
+    PreToolUse: [{
+      matcher: '.*',
+      hooks: [{ type: 'command', command: `${nodeCmd} ${scriptPath('preToolUse.mjs')}` }],
+    }],
+    Notification: [{
+      hooks: [{ type: 'command', command: `${nodeCmd} ${scriptPath('notification.mjs')}` }],
+    }],
+    Stop: [{
+      hooks: [{ type: 'command', command: `${nodeCmd} ${scriptPath('stop.mjs')}` }],
+    }],
   }
 
   // Read existing settings
@@ -61,33 +61,21 @@ export function runInstall() {
     mkdirSync(dirname(SETTINGS_PATH), { recursive: true })
   }
 
-  // Merge hooks — avoid duplicates by checking command paths
   settings.hooks = settings.hooks ?? {}
 
-  let added = 0
+  // Replace any existing vibe-pomo hooks (removes stale/duplicate entries
+  // from previous installs that may have used backslash paths or full node paths).
   for (const [event, defs] of Object.entries(hookDefs)) {
-    settings.hooks[event] = settings.hooks[event] ?? []
-    for (const def of defs) {
-      const commandToAdd = def.hooks[0].command
-      const alreadyRegistered = settings.hooks[event].some(
-        (existing) => existing.hooks?.some((h) => h.command === commandToAdd)
-      )
-      if (!alreadyRegistered) {
-        settings.hooks[event].push(def)
-        added++
-      }
-    }
+    settings.hooks[event] = (settings.hooks[event] ?? []).filter(
+      (entry) => !isVibePomоHook(entry)
+    )
+    settings.hooks[event].push(...defs)
   }
 
   writeFileSync(SETTINGS_PATH, JSON.stringify(settings, null, 2) + '\n', 'utf8')
+  console.log(`✓ Registered hooks in ${SETTINGS_PATH}`)
 
-  if (added > 0) {
-    console.log(`✓ Registered ${added} hook(s) in ${SETTINGS_PATH}`)
-  } else {
-    console.log(`Hooks already registered in ${SETTINGS_PATH}`)
-  }
-
-  // Also install project-local slash command
+  // Also install project-local slash commands
   installSlashCommand()
 }
 
@@ -95,25 +83,22 @@ function installSlashCommand() {
   const globalCommandsDir = join(homedir(), '.claude', 'commands')
   mkdirSync(globalCommandsDir, { recursive: true })
 
+  const pomodoroPath = q(join(__dirname, 'bin', 'pomodoro.mjs'))
+
   const commands = [
-    { file: 'pomodoro.md',       writer: writePomodoroCommand },
-    { file: 'pomodoro-stats.md', writer: writeStatsCommand },
-    { file: 'pomodoro-stop.md',  writer: writeStopCommand },
+    { file: 'pomodoro.md',       content: pomodoroCommand(pomodoroPath) },
+    { file: 'pomodoro-stats.md', content: statsCommand(pomodoroPath) },
+    { file: 'pomodoro-stop.md',  content: stopCommand(pomodoroPath) },
   ]
 
-  for (const { file, writer } of commands) {
-    const dest = join(globalCommandsDir, file)
-    writer(dest)
+  for (const { file, content } of commands) {
+    writeFileSync(join(globalCommandsDir, file), content, 'utf8')
     console.log(`✓ Slash command: ~/.claude/commands/${file}`)
   }
 }
 
-function writePomodoroCommand(dest) {
-  const pomodoroPath = join(__dirname, 'bin', 'pomodoro.mjs')
-  const nodeExec = process.execPath
-  const normPath = (p) => p.replace(/\\/g, '/')
-  const q = (p) => { const n = normPath(p); return n.includes(' ') ? `"${n}"` : n }
-  writeFileSync(dest, `---
+function pomodoroCommand(pomodoroPath) {
+  return `---
 description: Start a Pomodoro focus session — agent works autonomously until timer ends
 argument-hint: "[duration e.g. 25m] [task description]"
 ---
@@ -121,7 +106,7 @@ argument-hint: "[duration e.g. 25m] [task description]"
 ## Step 1: Start the Pomodoro timer
 
 \`\`\`bash
-${q(nodeExec)} ${q(pomodoroPath)} start $ARGUMENTS
+node ${pomodoroPath} start $ARGUMENTS
 \`\`\`
 
 ## Step 2: Work autonomously during the focus session
@@ -135,43 +120,35 @@ The user has started a Pomodoro focus session and **will not be checking the scr
 - Do not send notifications or ask questions — the user is in focus mode
 - When you have done all you can, write a summary to \`.claude/pomodoro-summary.md\`
 - Then wait quietly — the Pomodoro hook will manage the session lifecycle
-`, 'utf8')
+`
 }
 
-function writeStatsCommand(dest) {
-  const pomodoroPath = join(__dirname, 'bin', 'pomodoro.mjs')
-  const nodeExec = process.execPath
-  const normPath = (p) => p.replace(/\\/g, '/')
-  const q = (p) => { const n = normPath(p); return n.includes(' ') ? `"${n}"` : n }
-  writeFileSync(dest, `---
+function statsCommand(pomodoroPath) {
+  return `---
 description: Show Pomodoro time tracking statistics
 ---
 
 Run the following command and display the output to the user:
 
 \`\`\`bash
-${q(nodeExec)} ${q(pomodoroPath)} stats
+node ${pomodoroPath} stats
 \`\`\`
-`, 'utf8')
+`
 }
 
-function writeStopCommand(dest) {
-  const pomodoroPath = join(__dirname, 'bin', 'pomodoro.mjs')
-  const nodeExec = process.execPath
-  const normPath = (p) => p.replace(/\\/g, '/')
-  const q = (p) => { const n = normPath(p); return n.includes(' ') ? `"${n}"` : n }
-  writeFileSync(dest, `---
+function stopCommand(pomodoroPath) {
+  return `---
 description: Break (stop) the current Pomodoro session
 ---
 
 Run the following command to break the active Pomodoro session:
 
 \`\`\`bash
-${q(nodeExec)} ${q(pomodoroPath)} stop
+node ${pomodoroPath} stop
 \`\`\`
 
 Then confirm to the user that the session has been stopped.
-`, 'utf8')
+`
 }
 
 // Run directly if called as script

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vibe-pomo",
-  "version": "0.1.3",
+  "version": "0.2.0",
   "description": "You and your agent, both in flow. A Pomodoro timer for Claude Code that keeps agents working autonomously while you stay deep in focus — uninterrupted.",
   "type": "module",
   "bin": {
@@ -33,14 +33,12 @@
     "tui": "tsx src/tui/index.tsx"
   },
   "dependencies": {
-    "better-sqlite3": "^9.4.3",
     "ink": "^5.1.0",
     "ink-text-input": "^6.0.0",
     "react": "^18.3.1",
     "tsx": "^4.19.2"
   },
   "devDependencies": {
-    "@types/better-sqlite3": "^7.6.8",
     "@types/react": "^18.3.1"
   },
   "engines": {

package/src/daemon/db.mjs

@@ -1,146 +1,130 @@
-import Database from 'better-sqlite3'
 import { homedir } from 'node:os'
 import { join } from 'node:path'
-import { mkdirSync } from 'node:fs'
+import { mkdirSync, readFileSync, writeFileSync, existsSync } from 'node:fs'
 
-const DB_PATH = join(homedir(), '.claude', 'pomodoro.db')
+const DATA_PATH = join(homedir(), '.claude', 'pomodoro-data.json')
 
-function openDb() {
+// ── In-memory store (loaded once, flushed on every write) ─────────────────────
+
+let _data = null
+
+function load() {
+  if (_data) return _data
   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 (existsSync(DATA_PATH)) {
+    try { _data = JSON.parse(readFileSync(DATA_PATH, 'utf8')) } catch {}
   }
-  if (!cols.includes('user_activity')) {
-    db.exec(`ALTER TABLE sessions ADD COLUMN user_activity TEXT`)
+  if (!_data) _data = { sessions: [], notifications: [], nextId: 1 }
+  // Backfill nextId in case file was created without it
+  if (!_data.nextId) {
+    const maxId = Math.max(0, ...(_data.sessions ?? []).map((s) => s.id ?? 0))
+    _data.nextId = maxId + 1
   }
-
-  return db
+  return _data
 }
 
-let _db = null
-function getDb() {
-  if (!_db) _db = openDb()
-  return _db
+function flush() {
+  writeFileSync(DATA_PATH, JSON.stringify(_data, null, 2), 'utf8')
 }
 
+// ── Public API (mirrors the old better-sqlite3 interface exactly) ─────────────
+
 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
+  const data = load()
+  const id = data.nextId++
+  data.sessions.push({
+    id,
+    project_hash:   projectHash,
+    project_path:   projectPath,
+    started_at:     Date.now(),
+    ended_at:       null,
+    planned_ms:     plannedMs,
+    actual_ms:      null,
+    cycles:         1,
+    status:         'running',
+    task:           task ?? null,
+    agent_summary:  null,
+    user_activity:  null,
+  })
+  flush()
+  return id
 }
 
-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 endSession(id, { actualMs, status, agentSummary }) {
+  const data = load()
+  const s = data.sessions.find((s) => s.id === id)
+  if (!s) return
+  s.ended_at     = Date.now()
+  s.actual_ms    = actualMs
+  s.status       = status
+  s.agent_summary = agentSummary ?? null
+  flush()
 }
 
-export function updateSessionActivity(sessionId, { userActivity }) {
-  const db = getDb()
-  db.prepare(`UPDATE sessions SET user_activity = ? WHERE id = ?`)
-    .run(userActivity ?? null, sessionId)
+export function updateSessionActivity(id, { userActivity }) {
+  const data = load()
+  const s = data.sessions.find((s) => s.id === id)
+  if (!s) return
+  s.user_activity = userActivity ?? null
+  flush()
 }
 
 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)
+  const data = load()
+  data.notifications.push({
+    id:                data.nextId++,
+    session_id:        sessionId,
+    received_at:       receivedAt,
+    released_at:       releasedAt ?? null,
+    notification_json: notificationJson,
+  })
+  flush()
+}
+
+// ── Aggregation helpers ───────────────────────────────────────────────────────
+
+function projectStats() {
+  const data = load()
+  const map = new Map()
+  for (const s of data.sessions) {
+    if (s.status === 'broken') continue
+    const key = s.project_path
+    if (!map.has(key)) map.set(key, { project_path: key, total_sessions: 0, total_cycles: 0, total_minutes: 0, last_active: 0 })
+    const row = map.get(key)
+    row.total_sessions++
+    row.total_cycles  += s.cycles ?? 1
+    row.total_minutes += Math.floor((s.actual_ms ?? 0) / 60000)
+    if (s.started_at > row.last_active) row.last_active = s.started_at
+  }
+  return [...map.values()].sort((a, b) => b.last_active - a.last_active)
 }
 
 /** 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()
-
+  const data = load()
+  const projects = projectStats().slice(0, 10)
+  const recent = [...data.sessions]
+    .sort((a, b) => b.started_at - a.started_at)
+    .slice(0, 8)
+    .map(({ project_path, task, actual_ms, status, started_at, agent_summary, user_activity }) =>
+      ({ project_path, task, actual_ms, status, started_at, agent_summary, user_activity }))
   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)
+  const data = load()
+  return data.sessions
+    .filter((s) => s.project_path === projectPath)
+    .sort((a, b) => b.started_at - a.started_at)
+    .map(({ id, task, started_at, ended_at, actual_ms, status, agent_summary, user_activity }) =>
+      ({ id, task, started_at, ended_at, actual_ms, status, agent_summary, user_activity }))
 }
 
 /** 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()
+  const data = load()
+  const projects = projectStats()
 
   if (projects.length === 0) {
     console.log('No completed sessions yet.')
@@ -165,18 +149,14 @@ export function printStats() {
       truncated.padEnd(36) +
       String(row.total_sessions).padStart(9) +
       String(row.total_cycles).padStart(8) +
-      String(row.total_minutes ?? 0).padStart(9) +
+      String(row.total_minutes).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()
+  const recent = [...data.sessions]
+    .sort((a, b) => b.started_at - a.started_at)
+    .slice(0, 10)
 
   console.log('\nRecent Sessions\n' + '─'.repeat(72))
   console.log(
@@ -191,17 +171,15 @@ export function printStats() {
   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 cyc = String(s.cycles ?? 1).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}`)
+      console.log(`  🤖 ${s.agent_summary.split('\n')[0].slice(0, 68)}`)
     }
     if (s.user_activity) {
-      const line = s.user_activity.slice(0, 68)
-      console.log(`  👤 ${line}`)
+      console.log(`  👤 ${s.user_activity.slice(0, 68)}`)
     }
   }