kira-glasses-bridge 1.0.0 → 1.1.0

package/package.json

@@ -1,18 +1,31 @@
 {
   "name": "kira-glasses-bridge",
-  "version": "1.0.0",
+  "version": "1.1.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": { "kira-bridge": "./src/cli.mjs" },
-  "files": ["src", "README.md"],
-  "engines": { "node": ">=20" },
+  "bin": {
+    "kira-bridge": "src/cli.mjs"
+  },
+  "files": [
+    "src",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
   "scripts": {
     "start": "node src/cli.mjs run"
   },
   "dependencies": {
     "ws": "^8.18.0"
   },
-  "keywords": ["even-realities", "g2", "smart-glasses", "claude-code", "kira"],
+  "keywords": [
+    "even-realities",
+    "g2",
+    "smart-glasses",
+    "claude-code",
+    "kira"
+  ],
   "license": "MIT",
   "homepage": "https://hackchild.xyz/kira"
 }

package/src/claude-run.mjs

@@ -2,7 +2,7 @@
 import { spawn } from 'node:child_process'
 import { existsSync } from 'node:fs'
 import { homedir } from 'node:os'
-import { join } from 'node:path'
+import { isAbsolute, join, resolve } from 'node:path'
 
 /**
  * Find the claude binary. The bridge may be started from a shell whose PATH
@@ -23,32 +23,41 @@ export function findClaude() {
 
 const MAX_MS = 15 * 60 * 1000
 
+/** Kira's paths are relative to home unless absolute, like the file tools. */
+export function resolveCwd(cwd) {
+  if (!cwd) return homedir()
+  const s = String(cwd).replace(/^~(?=\/|$)/, homedir())
+  return isAbsolute(s) ? resolve(s) : resolve(homedir(), s)
+}
+
 export function runClaude({ prompt, sessionId, cwd }) {
-  return new Promise(resolve => {
+  return new Promise(done => {
+    const dir = resolveCwd(cwd)
+    if (!existsSync(dir)) return done({ error: `folder not found: ${dir}` })
     const args = ['-p', '--output-format', 'json', '--permission-mode', 'acceptEdits']
     if (sessionId) args.push('--resume', sessionId)
     args.push(prompt)
-    const child = spawn(findClaude(), args, { cwd: cwd || process.env.HOME, env: process.env, stdio: ['ignore', 'pipe', 'pipe'] })
+    const child = spawn(findClaude(), args, { cwd: dir, env: process.env, stdio: ['ignore', 'pipe', 'pipe'] })
     let out = ''
     let err = ''
     const timer = setTimeout(() => {
       child.kill('SIGTERM')
-      resolve({ error: `Claude did not finish within ${MAX_MS / 60000} minutes` })
+      done({ error: `Claude did not finish within ${MAX_MS / 60000} minutes` })
     }, MAX_MS)
     child.stdout.on('data', d => (out += d))
     child.stderr.on('data', d => (err += d))
     child.on('error', e => {
       clearTimeout(timer)
       const hint = e.code === 'ENOENT' ? 'Claude Code is not installed or not on the bridge\'s PATH. Install it, or set KIRA_CLAUDE_BIN=/path/to/claude when starting the bridge.' : e.message
-      resolve({ error: `could not start claude: ${hint}` })
+      done({ error: `could not start claude: ${hint}` })
     })
     child.on('close', code => {
       clearTimeout(timer)
       try {
         const j = JSON.parse(out)
-        resolve({ session_id: j.session_id, result: j.result, is_error: !!j.is_error, cost_usd: j.total_cost_usd, duration_ms: j.duration_ms, num_turns: j.num_turns })
+        done({ session_id: j.session_id, result: j.result, is_error: !!j.is_error, cost_usd: j.total_cost_usd, duration_ms: j.duration_ms, num_turns: j.num_turns })
       } catch {
-        resolve({ error: `claude exited with code ${code}: ${(err || out).slice(0, 500)}` })
+        done({ error: `claude exited with code ${code}: ${(err || out).slice(0, 500)}` })
       }
     })
   })

package/src/files.mjs

@@ -93,7 +93,7 @@ export async function createFolder({ path }) {
  * Refuses to overwrite unless `overwrite` is true, so a slip of the tongue
  * cannot clobber something.
  */
-export async function writeUserFile({ path, content, overwrite }) {
+export async function writeUserFile({ path, content, overwrite, append }) {
   const full = resolveUserPath(String(path ?? ''))
   if (full === HOME) throw new Error('give the file a name')
   const { mkdir, stat, writeFile } = await import('node:fs/promises')
@@ -101,12 +101,19 @@ export async function writeUserFile({ path, content, overwrite }) {
   try {
     const st = await stat(full)
     if (st.isDirectory()) throw new Error(`${display(full)} is a folder`)
-    if (!overwrite) return { path: display(full), written: false, error: `${display(full)} already exists. Say "overwrite it" to replace it.` }
+    if (!overwrite && !append) return { path: display(full), written: false, error: `${display(full)} already exists. Use append to add to it, or overwrite to replace it.` }
   } catch (err) {
     if (err.code !== 'ENOENT') throw err
   }
   await mkdir(dirname(full), { recursive: true })
   const text = String(content ?? '')
+  if (append) {
+    const { appendFile, readFile } = await import('node:fs/promises')
+    const existing = await readFile(full, 'utf8').catch(() => '')
+    const sep = existing && !existing.endsWith('\n') ? '\n' : ''
+    await appendFile(full, sep + text + (text.endsWith('\n') ? '' : '\n'), 'utf8')
+    return { path: display(full), written: true, appended: true, bytes: Buffer.byteLength(text, 'utf8') }
+  }
   await writeFile(full, text, 'utf8')
   return { path: display(full), written: true, bytes: Buffer.byteLength(text, 'utf8') }
 }

package/src/git.mjs

@@ -0,0 +1,136 @@
+// What Claude changed on disk, from git: a snapshot before a job and the
+// difference after it. Everything is read-only; the working tree is never
+// touched. Missing git or a folder outside a repo simply yields null.
+import { execFile } from 'node:child_process'
+import { homedir } from 'node:os'
+import { relative } from 'node:path'
+
+const DIFF_CAP = 400 * 1024 // bytes of unified diff kept per change
+const UNTRACKED_CAP = 30 // new files whose content is included
+const COMMIT_CAP = 20
+
+function git(cwd, args, { ok = [0] } = {}) {
+  return new Promise(resolve => {
+    execFile('git', args, { cwd, maxBuffer: 16 * 1024 * 1024, env: { ...process.env, GIT_OPTIONAL_LOCKS: '0' } }, (err, stdout) => {
+      if (err && !ok.includes(err.code)) return resolve(null)
+      resolve(String(stdout ?? ''))
+    })
+  })
+}
+
+export function display(full) {
+  const rel = relative(homedir(), full)
+  return rel && !rel.startsWith('..') ? `~/${rel}` : full
+}
+
+/** Repo identity plus the head and dirty files right now; null when not a git repo. */
+export async function snapshot(dir) {
+  const root = (await git(dir, ['rev-parse', '--show-toplevel']))?.trim()
+  if (!root) return null
+  const [head, branch, remote, status] = await Promise.all([
+    git(root, ['rev-parse', 'HEAD']),
+    git(root, ['rev-parse', '--abbrev-ref', 'HEAD']),
+    git(root, ['remote', 'get-url', 'origin']),
+    git(root, ['status', '--porcelain=v1', '--untracked-files=all']),
+  ])
+  return {
+    root,
+    cwd: display(root),
+    head: head?.trim() || null, // null on an empty repo
+    branch: branch?.trim() || null,
+    repo: remoteToRepo(remote?.trim()),
+    dirty: parseStatus(status ?? ''),
+  }
+}
+
+function remoteToRepo(url) {
+  if (!url) return null
+  const m = /github\.com[:/]([^/\s]+\/[^/\s]+?)(?:\.git)?$/.exec(url)
+  return m ? m[1] : null
+}
+
+function parseStatus(out) {
+  return out
+    .split('\n')
+    .filter(Boolean)
+    .map(l => ({ status: l.slice(0, 2).trim() || 'M', path: l.slice(3).replace(/^"|"$/g, '') }))
+}
+
+/**
+ * Everything different between the pre-job head and the working tree now:
+ * commits made since, per-file stats, and one unified diff (committed and
+ * uncommitted alike, new files included). Files that were already dirty
+ * before the job are flagged so a reader can discount them.
+ */
+export async function changesSince(before) {
+  const { root } = before
+  const base = before.head
+  const dirtyBefore = new Set(before.dirty.map(d => d.path))
+  const [headNow, numstat, nameStatus, diff, untrackedOut] = await Promise.all([
+    git(root, ['rev-parse', 'HEAD']),
+    base ? git(root, ['diff', '--numstat', '-M', base]) : Promise.resolve(''),
+    base ? git(root, ['diff', '--name-status', '-M', base]) : Promise.resolve(''),
+    base ? git(root, ['diff', '-M', '--no-color', base]) : Promise.resolve(''),
+    git(root, ['ls-files', '--others', '--exclude-standard']),
+  ])
+  const files = new Map()
+  for (const line of (numstat ?? '').split('\n').filter(Boolean)) {
+    const [a, d, ...rest] = line.split('\t')
+    const path = rest.join('\t').replace(/^.*\{(.*) => (.*)\}.*$/, (m, o, n) => m.replace(`{${o} => ${n}}`, n)).replace(/^(.*) => (.*)$/, '$2')
+    files.set(path, { path, adds: a === '-' ? 0 : Number(a), dels: d === '-' ? 0 : Number(d), binary: a === '-', status: 'M' })
+  }
+  for (const line of (nameStatus ?? '').split('\n').filter(Boolean)) {
+    const [st, ...rest] = line.split('\t')
+    const path = rest[rest.length - 1]
+    const f = files.get(path)
+    if (f) f.status = st[0]
+  }
+  let text = diff ?? ''
+  const untracked = (untrackedOut ?? '').split('\n').filter(Boolean)
+  let shown = 0
+  for (const path of untracked) {
+    const isNew = !dirtyBefore.has(path)
+    const content = shown < UNTRACKED_CAP ? await git(root, ['diff', '--no-index', '--no-color', '--', '/dev/null', path], { ok: [0, 1] }) : null
+    let adds = 0
+    if (content) {
+      adds = (content.match(/^\+(?!\+\+)/gm) ?? []).length
+      if (text.length < DIFF_CAP) text += content
+      shown++
+    }
+    files.set(path, { path, adds, dels: 0, binary: content === null && shown < UNTRACKED_CAP, status: 'A', untracked: true, preexisting: !isNew })
+  }
+  for (const f of files.values()) if (dirtyBefore.has(f.path)) f.preexisting = true
+  const truncated = text.length > DIFF_CAP
+  if (truncated) text = text.slice(0, DIFF_CAP) + '\n… diff truncated …\n'
+
+  const commits = []
+  if (base && headNow && headNow.trim() !== base) {
+    const log = await git(root, ['log', '--format=%H%x1f%s%x1f%cI', `${base}..HEAD`, `--max-count=${COMMIT_CAP}`])
+    for (const line of (log ?? '').split('\n').filter(Boolean)) {
+      const [sha, title, at] = line.split('\x1f')
+      const ns = await git(root, ['show', '--numstat', '--format=', sha])
+      let adds = 0, dels = 0, n = 0
+      for (const l of (ns ?? '').split('\n').filter(Boolean)) {
+        const [a, d] = l.split('\t')
+        if (a !== '-') adds += Number(a)
+        if (d !== '-') dels += Number(d)
+        n++
+      }
+      commits.push({ sha, short: sha.slice(0, 7), title, at, files: n, adds, dels })
+    }
+  }
+  const list = [...files.values()]
+  if (list.length === 0 && commits.length === 0) return null
+  return {
+    cwd: before.cwd,
+    repo: before.repo,
+    branch: (await git(root, ['rev-parse', '--abbrev-ref', 'HEAD']))?.trim() || before.branch,
+    head_before: base,
+    head_after: headNow?.trim() || null,
+    commits,
+    files: list,
+    stats: { files: list.length, adds: list.reduce((s, f) => s + f.adds, 0), dels: list.reduce((s, f) => s + f.dels, 0) },
+    diff: text,
+    truncated,
+  }
+}

package/src/index.mjs

@@ -3,9 +3,10 @@
 // machine on the user's behalf. Env: KIRA_BRIDGE_URL, KIRA_BRIDGE_TOKEN.
 import WebSocket from 'ws'
 import { listProjects, listSessions, readSession } from './claude-sessions.mjs'
-import { runClaude, findClaude } from './claude-run.mjs'
+import { snapshot, changesSince, display } from './git.mjs'
+import { runClaude, findClaude, resolveCwd } from './claude-run.mjs'
 import { openApp, installedApps } from './apps.mjs'
-import { listFiles, readUserFile, createFolder, writeUserFile, trashPath } from './files.mjs'
+import { listFiles, readUserFile, createFolder, writeUserFile, trashPath, resolveUserPath } from './files.mjs'
 
 import { createRequire } from 'node:module'
 const { version: BRIDGE_VERSION } = createRequire(import.meta.url)('../package.json')
@@ -34,16 +35,16 @@ const tools = {
     return readUserFile(args)
   },
   async create_folder(args) {
-    return createFolder(args)
+    return withChange(args.path, () => createFolder(args))
   },
   async write_file(args) {
-    return writeUserFile(args)
+    return withChange(args.path, () => writeUserFile(args))
   },
   async open_app(args) {
     return openApp(args)
   },
   async delete_path(args) {
-    return trashPath(args)
+    return withChange(args.path, () => trashPath(args))
   },
   async list_apps() {
     return { apps: await installedApps() }
@@ -60,17 +61,56 @@ const tools = {
   // Acknowledge now, report the result as a job when Claude finishes.
   async ask_claude(args, ws) {
     const jobId = String(args.job_id ?? '')
-    const prompt = String(args.prompt ?? '')
+    const prompt = String(args.prompt ?? args.message ?? args.text ?? args.instruction ?? '').trim()
     if (!prompt) return { error: 'prompt is required' }
-    log(`ask_claude job=${jobId.slice(0, 8)} session=${args.session_id ?? 'new'}: ${prompt.slice(0, 80)}`)
-    void runClaude({ prompt, sessionId: args.session_id, cwd: args.cwd }).then(result => {
-      log(`job ${jobId.slice(0, 8)} ${result.error ? 'error' : 'done'}`)
-      send(ws, { type: 'job', jobId, status: result.error ? 'error' : 'done', result, error: result.error })
+    // A resumed session runs in its own folder even when the caller did not say which.
+    let cwd = args.cwd
+    if (!cwd && args.session_id) {
+      const s = await readSession(String(args.session_id), 1)
+      if (s?.cwd) cwd = s.cwd
+    }
+    const dir = resolveCwd(cwd)
+    log(`ask_claude job=${jobId.slice(0, 8)} session=${args.session_id ?? 'new'} in ${display(dir)}: ${prompt.slice(0, 80)}`)
+    // Git before and after, so the API can show exactly what this job changed.
+    const before = await snapshot(dir).catch(() => null)
+    void runClaude({ prompt, sessionId: args.session_id, cwd: dir }).then(async result => {
+      let change = null
+      if (before) change = await changesSince(before).catch(err => (log(`git after job failed: ${err.message}`), null))
+      log(`job ${jobId.slice(0, 8)} ${result.error ? 'error' : 'done'}${change ? ` · ${change.stats.files} files +${change.stats.adds} -${change.stats.dels}, ${change.commits.length} commits` : ''}`)
+      send(ws, { type: 'job', jobId, status: result.error ? 'error' : 'done', result: { ...result, cwd: display(dir), change }, error: result.error })
     })
-    return { started: true }
+    return { started: true, cwd: display(dir), git: before ? { repo: before.repo, branch: before.branch, head: before.head?.slice(0, 7) ?? null } : null }
+  },
+
+  /** Read-only git facts for a folder: repo, branch, head, dirty files. */
+  async git_status(args) {
+    const s = await snapshot(resolveCwd(args.path ?? args.cwd))
+    if (!s) return { error: 'not a git repository' }
+    return { cwd: s.cwd, repo: s.repo, branch: s.branch, head: s.head?.slice(0, 7) ?? null, dirty: s.dirty.slice(0, 50), dirty_count: s.dirty.length }
   },
 }
 
+/**
+ * Run a file-changing tool with a git snapshot around it, so the API can show
+ * the diff the same way it does for Claude jobs. Outside a repo: no change.
+ */
+async function withChange(pathArg, fn) {
+  let before = null
+  try {
+    const full = resolveUserPath(String(pathArg ?? ''))
+    const { dirname } = await import('node:path')
+    const { stat } = await import('node:fs/promises')
+    const isDir = await stat(full).then(s => s.isDirectory()).catch(() => false)
+    before = await snapshot(isDir ? full : dirname(full))
+  } catch {
+    before = null
+  }
+  const result = await fn()
+  if (!before || (result && result.error)) return result
+  const change = await changesSince(before).catch(() => null)
+  return change ? { ...result, change } : result
+}
+
 let backoff = 1000
 function connect() {
   const ws = new WebSocket(`${URL_}?token=${encodeURIComponent(TOKEN)}`)