bestviber 0.2.0 → 0.3.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bestviber",
-  "version": "0.2.0",
+  "version": "0.3.1",
   "description": "Focus timer and focus analytics for you and your AI agents. Start, pause and finish sessions, and get daily, weekly and monthly stats from the terminal.",
   "keywords": [
     "focus",

package/src/commands.mjs

@@ -326,7 +326,7 @@ export const commands = {
   hook: {
     summary: 'Claude Code hook entry point',
     actions: [
-      'get_active_session',
+      'list_open_sessions',
       'start_focus_session',
       'pause_focus_session',
       'resume_focus_session',

package/src/format.mjs

@@ -41,6 +41,10 @@ export function stats(stats) {
   lines.push(`${title}  (${range.tz})`)
   lines.push('')
   lines.push(`  focused     ${duration(stats.totalMs)}`)
+  if (stats.parallelMs > 0)
+    lines.push(
+      `  in parallel ${duration(stats.parallelMs)} (up to ${stats.maxParallel} sessions at once; ${duration(stats.sessionTimeMs)} of session time)`,
+    )
   lines.push(`  sessions    ${stats.sessionCount}`)
   if (stats.sessionCount) {
     lines.push(`  average     ${duration(stats.averageSessionMs)}`)

package/src/hooks.mjs

@@ -87,22 +87,42 @@ export async function runHookWorker() {
     const e = JSON.parse(process.env.BESTVIBER_HOOK_EVENT || '{}')
     const event = trackerEvent(e)
     if (!event || !(await token())) return
+    // Each Claude Code window has its own focus session, so windows on
+    // different repositories record in parallel.
+    const agentSession = String(e.session_id || 'default')
     await withLock(async () => {
-      const state = await readState()
+      const all = await readStates()
+      const state = all[agentSession] ?? EMPTY_STATE
       const project = detectProject(e.cwd || process.cwd())
-      const open =
-        event === 'reply'
-          ? state.sessionId
-            ? { id: state.sessionId, status: 'active', project: state.project }
-            : null
-          : await call('get_active_session')
-      const result = decide({ state, open, event, now: new Date(), project })
+      /** @type {import('./tracker.mjs').OpenSession} */
+      let open = null
+      if (event === 'reply')
+        open = state.sessionId
+          ? { id: state.sessionId, status: 'active', project: state.project }
+          : null
+      else if (state.sessionId) {
+        const list = await call('list_open_sessions')
+        open =
+          (list ?? []).find(
+            (/** @type {any} */ s) => s.id === state.sessionId,
+          ) ?? null
+      }
+      const result = decide({
+        state,
+        open,
+        event,
+        now: new Date(),
+        project,
+        agentSession,
+      })
       const next = { ...result.state }
       for (const c of result.calls) {
         const res = await call(c.name, c.input)
         if (c.name === 'start_focus_session') next.sessionId = res?.id ?? null
       }
-      await writeState(next)
+      if (next.sessionId || next.lastActivity) all[agentSession] = next
+      else delete all[agentSession]
+      await writeStates(all)
     })
   } catch (err) {
     await log(String(/** @type {Error} */ (err)?.stack ?? err))
@@ -130,20 +150,28 @@ function detectProject(/** @type {string} */ cwd) {
   })
 }
 
-async function readState() {
+/** @returns {Promise<Record<string, import('./tracker.mjs').TrackerState>>} */
+async function readStates() {
   try {
-    return {
-      ...EMPTY_STATE,
-      ...JSON.parse(await readFile(statePath(), 'utf8')),
-    }
+    const data = JSON.parse(await readFile(statePath(), 'utf8'))
+    return data && typeof data.sessions === 'object' ? data.sessions : {}
   } catch {
-    return EMPTY_STATE
+    return {}
   }
 }
 
-async function writeState(/** @type {object} */ state) {
+async function writeStates(
+  /** @type {Record<string, import('./tracker.mjs').TrackerState>} */ sessions,
+) {
+  // Forget windows quiet for two days: they closed without an exit event.
+  const cutoff = Date.now() - 2 * 86_400_000
+  for (const [k, v] of Object.entries(sessions))
+    if (!v.lastActivity || Date.parse(v.lastActivity) < cutoff)
+      delete sessions[k]
   await mkdir(stateDir(), { recursive: true, mode: 0o700 })
-  await writeFile(statePath(), JSON.stringify(state) + '\n', { mode: 0o600 })
+  await writeFile(statePath(), JSON.stringify({ sessions }) + '\n', {
+    mode: 0o600,
+  })
 }
 
 export async function clearTrackingState() {

package/src/tracker.mjs

@@ -5,14 +5,17 @@
 // hook runner (hooks.mjs) does the I/O; the tests drive this directly.
 //
 // Rules (agreed with the product owner):
-// - A prompt, or Claude Code starting, makes sure a session is running for
-//   the current project. A different project's session is closed first.
+// - Each agent session (a Claude Code window) has its own focus session, so
+//   several windows record in parallel.
+// - A prompt, or Claude Code starting, makes sure that window's session is
+//   running for the current project; a project change closes the old one.
 // - Claude finishing a reply counts as activity; no API call is needed.
 // - Quiet under GRACE (reading a reply) still counts as focus.
 // - Quiet from GRACE up to FINISH is recorded as a pause in the same session.
 // - Quiet of FINISH or more ends the session when the quiet began; the next
 //   prompt starts a new one.
-// - A session someone started by hand (CLI, app, agent) is left alone.
+// - Every call names its session by id, so sessions started by hand or by
+//   other windows are never touched.
 
 export const GRACE_MS = 2 * 60_000
 export const FINISH_MS = 10 * 60_000
@@ -32,47 +35,49 @@ export const EMPTY_STATE = {
 }
 
 /**
- * @param {{ state: TrackerState, open: OpenSession, event: TrackerEvent, now: Date, project: string }} input
+ * @param {{ state: TrackerState, open: OpenSession, event: TrackerEvent, now: Date, project: string, agentSession: string }} input
+ *   `state` and `open` are this agent session's own: `open` is its focus
+ *   session if still running or paused, else null.
  * @returns {{ calls: Array<Call>, state: TrackerState }}
  */
-export function decide({ state, open, event, now, project }) {
+export function decide({ state, open, event, now, project, agentSession }) {
   const nowIso = now.toISOString()
   const last = state.lastActivity ? new Date(state.lastActivity) : null
   const gap = last ? now.getTime() - last.getTime() : 0
-  const ours = open !== null && open.id === state.sessionId
+  const id = state.sessionId
+  const ours = open !== null && id !== null && open.id === id
   /** When the work in the open session really stopped. */
   const endedAt = last && gap >= GRACE_MS ? state.lastActivity : nowIso
 
-  // Someone else's session is open: stay out of its way.
-  if (open && !ours)
-    return {
-      calls: [],
-      state: { sessionId: null, project: null, lastActivity: nowIso },
-    }
-
   if (event === 'reply')
     return { calls: [], state: { ...state, lastActivity: nowIso } }
 
-  if (event === 'end') {
-    if (!ours) return { calls: [], state: EMPTY_STATE }
+  if (event === 'end')
     return {
-      calls: [{ name: 'finish_focus_session', input: { at: endedAt } }],
+      calls: ours
+        ? [{ name: 'finish_focus_session', input: { id, at: endedAt } }]
+        : [],
       state: EMPTY_STATE,
     }
-  }
 
-  // 'start' or 'prompt': make sure this project's session is running.
+  // 'start' or 'prompt': make sure this window's session is running.
   /** @type {Array<Call>} */
   const calls = []
-  const start = { name: 'start_focus_session', input: { project } }
+  const start = {
+    name: 'start_focus_session',
+    input: { project, agentSession },
+  }
 
   if (!ours) calls.push(start)
   else if (open.project !== project || gap >= FINISH_MS) {
-    calls.push({ name: 'finish_focus_session', input: { at: endedAt } }, start)
+    calls.push(
+      { name: 'finish_focus_session', input: { id, at: endedAt } },
+      start,
+    )
   } else if (gap >= GRACE_MS) {
     calls.push(
-      { name: 'pause_focus_session', input: { at: state.lastActivity } },
-      { name: 'resume_focus_session', input: {} },
+      { name: 'pause_focus_session', input: { id, at: state.lastActivity } },
+      { name: 'resume_focus_session', input: { id } },
     )
   }
 
@@ -81,7 +86,7 @@ export function decide({ state, open, event, now, project }) {
     // A new session's id comes back from start_focus_session; the runner
     // fills it in.
     state: {
-      sessionId: calls.includes(start) ? null : state.sessionId,
+      sessionId: calls.includes(start) ? null : id,
       project,
       lastActivity: nowIso,
     },

package/src/tracker.test.mjs

@@ -18,132 +18,78 @@ const tracking = (lastHm, overrides = {}) => ({
 })
 
 describe('automatic tracking', () => {
-  test('the first prompt starts a session for the project', () => {
-    const r = decide({
-      state: EMPTY_STATE,
-      open: null,
-      event: 'prompt',
-      now: at('09:00'),
-      project: P,
-    })
-    expect(r.calls).toEqual([
-      { name: 'start_focus_session', input: { project: P } },
-    ])
+  const W = 'claude-window-1'
+  const go = (state, open, event, hm, project = P) =>
+    decide({ state, open, event, now: at(hm), project, agentSession: W })
+  const start = (project = P) => ({
+    name: 'start_focus_session',
+    input: { project, agentSession: W },
+  })
+
+  test('the first prompt starts a session for the project and this window', () => {
+    const r = go(EMPTY_STATE, null, 'prompt', '09:00')
+    expect(r.calls).toEqual([start()])
     expect(r.state.lastActivity).toBe(iso('09:00'))
   })
 
   test('a quick next prompt changes nothing', () => {
-    const r = decide({
-      state: tracking('09:00'),
-      open: mine(),
-      event: 'prompt',
-      now: at('09:01'),
-      project: P,
-    })
+    const r = go(tracking('09:00'), mine(), 'prompt', '09:01')
     expect(r.calls).toEqual([])
     expect(r.state.sessionId).toBe('s1')
   })
 
   test('quiet between 2 and 10 minutes becomes a pause in the same session', () => {
-    const r = decide({
-      state: tracking('09:00'),
-      open: mine(),
-      event: 'prompt',
-      now: at('09:06'),
-      project: P,
-    })
+    const r = go(tracking('09:00'), mine(), 'prompt', '09:06')
     expect(r.calls).toEqual([
-      { name: 'pause_focus_session', input: { at: iso('09:00') } },
-      { name: 'resume_focus_session', input: {} },
+      { name: 'pause_focus_session', input: { id: 's1', at: iso('09:00') } },
+      { name: 'resume_focus_session', input: { id: 's1' } },
     ])
     expect(r.state.sessionId).toBe('s1')
   })
 
   test('quiet of 10 minutes or more ends the session when the quiet began', () => {
-    const r = decide({
-      state: tracking('09:00'),
-      open: mine(),
-      event: 'prompt',
-      now: at('09:30'),
-      project: P,
-    })
+    const r = go(tracking('09:00'), mine(), 'prompt', '09:30')
     expect(r.calls).toEqual([
-      { name: 'finish_focus_session', input: { at: iso('09:00') } },
-      { name: 'start_focus_session', input: { project: P } },
+      { name: 'finish_focus_session', input: { id: 's1', at: iso('09:00') } },
+      start(),
     ])
     expect(r.state.sessionId).toBeNull()
   })
 
-  test('switching repositories closes the old project and starts the new one', () => {
-    const r = decide({
-      state: tracking('09:00'),
-      open: mine(),
-      event: 'prompt',
-      now: at('09:01'),
-      project: 'amar/website',
-    })
+  test('switching repositories in a window closes its old project and starts the new one', () => {
+    const r = go(tracking('09:00'), mine(), 'prompt', '09:01', 'amar/website')
     expect(r.calls).toEqual([
-      { name: 'finish_focus_session', input: { at: iso('09:01') } },
-      { name: 'start_focus_session', input: { project: 'amar/website' } },
+      { name: 'finish_focus_session', input: { id: 's1', at: iso('09:01') } },
+      start('amar/website'),
     ])
   })
 
   test('a finished reply is activity, with no API call', () => {
-    const r = decide({
-      state: tracking('09:00'),
-      open: mine(),
-      event: 'reply',
-      now: at('09:04'),
-      project: P,
-    })
+    const r = go(tracking('09:00'), mine(), 'reply', '09:04')
     expect(r.calls).toEqual([])
     expect(r.state.lastActivity).toBe(iso('09:04'))
   })
 
   test('Claude Code exiting finishes the session, at the last activity if it was quiet', () => {
-    expect(
-      decide({
-        state: tracking('09:00'),
-        open: mine(),
-        event: 'end',
-        now: at('09:20'),
-        project: P,
-      }).calls,
-    ).toEqual([{ name: 'finish_focus_session', input: { at: iso('09:00') } }])
-    expect(
-      decide({
-        state: tracking('09:00'),
-        open: mine(),
-        event: 'end',
-        now: at('09:01'),
-        project: P,
-      }).calls,
-    ).toEqual([{ name: 'finish_focus_session', input: { at: iso('09:01') } }])
+    expect(go(tracking('09:00'), mine(), 'end', '09:20').calls).toEqual([
+      { name: 'finish_focus_session', input: { id: 's1', at: iso('09:00') } },
+    ])
+    expect(go(tracking('09:00'), mine(), 'end', '09:01').calls).toEqual([
+      { name: 'finish_focus_session', input: { id: 's1', at: iso('09:01') } },
+    ])
   })
 
-  test('a session someone started by hand is left alone', () => {
-    const r = decide({
-      state: EMPTY_STATE,
-      open: { id: 'manual', status: 'active', project: null },
-      event: 'prompt',
-      now: at('09:00'),
-      project: P,
-    })
-    expect(r.calls).toEqual([])
-    expect(r.state.sessionId).toBeNull()
+  test("another window's session is never touched: every call names its own id", () => {
+    // Window 2 starts while window 1's session s1 is open elsewhere.
+    const r = go(EMPTY_STATE, null, 'prompt', '09:00', 'amar/website')
+    expect(r.calls).toEqual([start('amar/website')])
+    for (const c of go(tracking('09:00'), mine(), 'prompt', '09:30').calls)
+      if (c.name !== 'start_focus_session') expect(c.input.id).toBe('s1')
   })
 
   test('if our session was closed elsewhere, the next prompt starts a new one', () => {
-    const r = decide({
-      state: tracking('09:00'),
-      open: null,
-      event: 'prompt',
-      now: at('09:01'),
-      project: P,
-    })
-    expect(r.calls).toEqual([
-      { name: 'start_focus_session', input: { project: P } },
-    ])
+    const r = go(tracking('09:00'), null, 'prompt', '09:01')
+    expect(r.calls).toEqual([start()])
   })
 })