kira-glasses-bridge 2.35.0 → 2.36.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kira-glasses-bridge",
-  "version": "2.35.0",
+  "version": "2.36.0",
   "description": "Connects your Mac to Kira, the assistant for Even G2 glasses: Claude Code sessions, files, folders and apps, by voice.",
   "type": "module",
   "bin": {

package/src/claude-sessions.mjs

@@ -5,29 +5,22 @@ import { getSessionInfo, getSessionMessages, listSessions as sdkListSessions } f
 import { open, readdir, stat } from 'node:fs/promises'
 import { homedir } from 'node:os'
 import { basename, join } from 'node:path'
+import { doingOf, itemsOf, lastTurns, turnsOf } from './claude-transcript.mjs'
 
 const ACTIVE_WINDOW_MS = 3 * 60 * 1000
+const TEXT_CAP = 2000
 
-function textOf(message) {
-  const c = message?.content
-  if (typeof c === 'string') return c
-  if (Array.isArray(c)) return c.filter(b => b?.type === 'text').map(b => b.text).join('\n')
-  return ''
-}
-
-/** The conversation as said: user and Claude text, without tool results, system blocks or subagents. */
-async function turnsOf(sessionId, dir) {
+/** The session as it happened: its turns and the tool calls between them (claude-transcript.mjs). */
+async function itemsFor(sessionId, dir) {
   const messages = await getSessionMessages(sessionId, dir ? { dir } : undefined)
-  const turns = []
-  for (const m of messages) {
-    if (m.parent_tool_use_id) continue
-    const text = textOf(m.message).trim()
-    if (!text || text.startsWith('<')) continue // tool results / system blocks
-    turns.push({ role: m.type === 'user' ? 'user' : 'claude', text, at: m.timestamp ?? null })
-  }
-  return turns
+  return itemsOf(messages, dir ?? homedir())
 }
 
+/** The branch, unless the checkout is detached ("HEAD"). */
+const branchOf = s => (s.gitBranch && s.gitBranch !== 'HEAD' ? s.gitBranch : null)
+
+const capText = item => (item.kind === 'turn' ? { ...item, text: item.text.slice(0, TEXT_CAP) } : item)
+
 /**
  * The SDK reads a session's folder from the start of its transcript, and misses it when the
  * transcript opens with large snapshot entries. Then: the first "cwd" in the first MB of the file.
@@ -59,18 +52,22 @@ export async function listSessions(max = 10) {
   for (const s of await sdkListSessions({ limit: n })) {
     try {
       const cwd = await cwdOf(s)
-      const turns = await turnsOf(s.sessionId, cwd)
-      const lastUser = [...turns].reverse().find(t => t.role === 'user')
-      const lastClaude = [...turns].reverse().find(t => t.role === 'claude')
+      const items = await itemsFor(s.sessionId, cwd)
+      const turns = turnsOf(items)
+      const lastUser = turns.findLast(t => t.role === 'user')
+      const lastClaude = turns.findLast(t => t.role === 'claude')
+      const active = activeOf(s)
       sessions.push({
         session_id: s.sessionId,
         title: titleOf(s) ?? (lastUser ? lastUser.text.slice(0, 60) : '(untitled)'),
         project: cwd ? cwd.split('/').slice(-2).join('/') : null,
         cwd,
-        active: activeOf(s),
+        active,
         last_active_at: new Date(s.lastModified).toISOString(),
         last_user_message: lastUser ? lastUser.text.slice(0, 200) : null,
         last_claude_message: lastClaude ? lastClaude.text.slice(0, 200) : null,
+        branch: branchOf(s),
+        doing: active ? doingOf(items) : null,
       })
     } catch {
       /* unreadable transcript */
@@ -79,13 +76,28 @@ export async function listSessions(max = 10) {
   return { count: sessions.length, sessions }
 }
 
-export async function readSession(sessionId, turns = 6) {
+/**
+ * A session's last `turns` turns; with `items`, the tool calls between them too (the phone asks for
+ * them; Kira's own reads don't, to keep them short).
+ */
+export async function readSession(sessionId, turns = 6, { items: withItems = false } = {}) {
   const info = await getSessionInfo(sessionId).catch(() => undefined)
   if (!info) return { error: `No session ${sessionId} on this machine` }
   const cwd = await cwdOf(info)
-  const all = await turnsOf(sessionId, cwd)
+  const items = await itemsFor(sessionId, cwd)
   const n = Math.min(Math.max(Number(turns) || 6, 1), 30)
-  return { session_id: info.sessionId, title: titleOf(info), cwd, active: activeOf(info), last_active_at: new Date(info.lastModified).toISOString(), turns: all.slice(-n).map(t => ({ ...t, text: t.text.slice(0, 2000) })) }
+  const recent = lastTurns(items, n).map(capText)
+  return {
+    session_id: info.sessionId,
+    title: titleOf(info),
+    cwd,
+    active: activeOf(info),
+    last_active_at: new Date(info.lastModified).toISOString(),
+    turns: turnsOf(recent),
+    ...(withItems ? { items: recent } : {}),
+    branch: branchOf(info),
+    doing: activeOf(info) ? doingOf(items) : null,
+  }
 }
 
 /** Project folders Claude Code has been used in (that still exist), newest first. */

package/src/claude-transcript.mjs

@@ -0,0 +1,114 @@
+// A Claude Code transcript (the Agent SDK's session messages) as the conversation shows it: what was
+// said and, between the turns, the tool calls Claude made, described the way its jobs describe them
+// (agents/claude-calls.mjs). The shape is @kira/genui's claudeSessionItems.ts.
+import { describeAction, short } from './agents/claude-calls.mjs'
+
+/** How much of an edit, a write or a command a call carries for its detail. */
+const DETAIL_CAP = 1500
+
+function textOf(message) {
+  const c = message?.content
+  if (typeof c === 'string') return c
+  if (Array.isArray(c)) return c.filter(b => b?.type === 'text').map(b => b.text).join('\n')
+  return ''
+}
+
+/** An edit's lines: the old and new text without the lines they share at the start and the end. */
+function diffCounts(old, now) {
+  const a = String(old ?? '').split('\n')
+  const b = String(now ?? '').split('\n')
+  let start = 0
+  while (start < a.length && start < b.length && a[start] === b[start]) start++
+  let end = 0
+  while (end < a.length - start && end < b.length - start && a[a.length - 1 - end] === b[b.length - 1 - end]) end++
+  return { adds: b.length - start - end, dels: a.length - start - end }
+}
+
+/** Lines an edit or a write adds and takes out; null for any other call. */
+export function lineCounts(name, input) {
+  const i = input ?? {}
+  if (name === 'Write') return { adds: i.content ? String(i.content).split('\n').length : 0, dels: 0 }
+  if (name === 'Edit') return diffCounts(i.old_string, i.new_string)
+  if (name !== 'MultiEdit') return null
+  const each = (i.edits ?? []).map(e => diffCounts(e.old_string, e.new_string))
+  return { adds: each.reduce((n, c) => n + c.adds, 0), dels: each.reduce((n, c) => n + c.dels, 0) }
+}
+
+/**
+ * A change's detail, shorter than a job's: the conversation polls it every few seconds. A command
+ * has none (its target is the command).
+ */
+function shortDetail(d) {
+  const cut = e => ({ ...e, old: short(e.old, DETAIL_CAP), new: short(e.new, DETAIL_CAP) })
+  if (d.edit) return { edit: cut(d.edit) }
+  if (d.edits) return { edits: d.edits.slice(0, 5).map(cut) }
+  return d.content !== undefined ? { content: short(d.content, DETAIL_CAP) } : undefined
+}
+
+/** One tool_use block as a call. */
+function toolCall(block, cwd) {
+  const act = describeAction(block.name, block.input, cwd)
+  const detail = act.detail ? shortDetail(act.detail) : undefined
+  return {
+    id: block.id,
+    type: act.type,
+    label: act.label,
+    target: act.target,
+    ...(lineCounts(block.name, block.input) ?? {}),
+    ...(detail ? { detail } : {}),
+  }
+}
+
+/**
+ * Everything said and done, in order: the user's and Claude's turns, and each run of tool calls
+ * between them as one item. Subagents' own messages and system blocks (text starting "<") are left out.
+ */
+export function itemsOf(messages, cwd) {
+  const items = []
+  const calls = new Map()
+  let group = null
+  const say = (role, text, at) => {
+    group = null
+    if (text && !text.startsWith('<')) items.push({ kind: 'turn', role, text, at })
+  }
+  for (const m of messages) {
+    if (m.parent_tool_use_id) continue
+    const at = m.timestamp ?? null
+    const content = Array.isArray(m.message?.content) ? m.message.content : []
+    if (m.type === 'assistant') {
+      for (const b of content) {
+        if (b?.type === 'text') say('claude', String(b.text ?? '').trim(), at)
+        if (b?.type !== 'tool_use') continue
+        if (!group) items.push((group = { kind: 'tools', at, calls: [] }))
+        const call = toolCall(b, cwd)
+        calls.set(call.id, call)
+        group.calls.push(call)
+      }
+    } else if (m.type === 'user') {
+      for (const b of content) {
+        if (b?.type === 'tool_result' && b.is_error && calls.has(b.tool_use_id)) calls.get(b.tool_use_id).failed = true
+      }
+      const text = textOf(m.message).trim()
+      if (text) say('user', text, at)
+    }
+  }
+  return items
+}
+
+/** Just the turns (what read_claude_session has always returned). */
+export const turnsOf = items => items.filter(i => i.kind === 'turn').map(({ kind, ...turn }) => turn)
+
+/** The last `n` turns and the tool calls among and after them. */
+export function lastTurns(items, n) {
+  let seen = 0
+  for (let i = items.length - 1; i >= 0; i--) if (items[i].kind === 'turn' && ++seen === n) return items.slice(i)
+  return items
+}
+
+/** The last call when nothing was said after it: what the session is doing (or did last). */
+export function doingOf(items) {
+  const last = items.at(-1)
+  if (last?.kind !== 'tools') return null
+  const { detail, ...call } = last.calls.at(-1)
+  return call
+}

package/src/session-tools.mjs

@@ -15,6 +15,6 @@ export const sessionTools = {
     return listSessions(args.max)
   },
   async read_claude_session(args) {
-    return readSession(String(args.session_id ?? ''), args.turns)
+    return readSession(String(args.session_id ?? ''), args.turns, { items: args.items === true })
   },
 }