heyquilt 0.0.1 → 0.3.106

package/src/agents/claude-code.js

@@ -0,0 +1,187 @@
+// Reads Claude Code conversation transcripts for one project folder and turns
+// them into feed entries. Transcripts are JSONL files under
+// ~/.claude/projects/<slug>/<sessionId>.jsonl, appended to as the chat goes on.
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import { describeAction } from './actions.js'
+import { capText } from './common.js'
+
+const POLL_MS = 750
+const IDLE_AFTER_MS = 2 * 60 * 1000
+const BACKFILL_MS = 60 * 60 * 1000
+const BACKFILL_ENTRIES = 50
+const TITLE_CHARS = 80
+
+export const slugFor = (dir) => path.resolve(dir).replace(/[^A-Za-z0-9]/g, '-')
+
+export function claudeProjectsDir (home = os.homedir()) {
+  const base = process.env.CLAUDE_CONFIG_DIR || path.join(home, '.claude')
+  return path.join(base, 'projects')
+}
+
+/**
+ * @param {object} o
+ * @param {string} o.dir            synced folder
+ * @param {(entries: object[]) => void} o.onEntries
+ * @param {(state: object) => void} o.onState
+ * @param {(line: string) => void} [o.onLog]
+ * @param {string} [o.home]
+ * @param {string} [o.chatDir]      folder the AI works from, if not `dir` (an agent that synced into a subfolder)
+ */
+export function startClaudeCodeReader ({ dir, chatDir, onEntries, onState, onLog = () => {}, home, pollMs = POLL_MS, now = Date.now }) {
+  dir = path.resolve(dir)
+  const chatRoot = path.resolve(chatDir || dir)
+  const root = claudeProjectsDir(home)
+  const slug = slugFor(chatRoot)
+  const files = new Map() // path -> { offset, partial, seen: Set<path> }
+  let status = null
+  // Each conversation mid-turn, by its transcript file, with when it last wrote: the tool is working
+  // while any of them is, so one conversation ending its turn never makes another's edits look like a
+  // person's (they'd go unboxed). A conversation silent for IDLE_AFTER_MS counts as done.
+  const midTurn = new Map()
+  const settle = () => setStatus(midTurn.size ? 'working' : 'idle')
+  let stopped = false
+  let failed = false
+  let first = true
+
+  const setStatus = (s) => {
+    if (s === status) return
+    status = s
+    onState({ tool: 'Claude Code', status: s })
+  }
+  setStatus('idle')
+
+  const inside = (cwd) => typeof cwd === 'string' && (cwd === chatRoot || cwd.startsWith(chatRoot + path.sep))
+
+  function parseLine (line, file, st) {
+    let j
+    try { j = JSON.parse(line) } catch { return null }
+    // The conversation's title, as the person sees it in Claude Code's list (its own name for the
+    // chat, or one they gave it). These lines carry no folder, so they're read before the check.
+    // Entries from here on carry it, so the Loom and the feed can name the conversation the same way.
+    if (j && (j.type === 'custom-title' || j.type === 'agent-name')) {
+      const t = String(j.customTitle || j.agentName || '').replace(/\s+/g, ' ').trim().slice(0, TITLE_CHARS)
+      if (t && (j.type === 'custom-title' || !st.title)) st.title = t
+      return null
+    }
+    if (!j || j.isSidechain || !inside(j.cwd)) return null
+    const ts = Date.parse(j.timestamp) || now()
+    const conv = j.sessionId || path.basename(file, '.jsonl')
+    const out = []
+    const msg = j.message || {}
+
+    if (j.type === 'user' && !j.isMeta) {
+      const text = typeof msg.content === 'string'
+        ? msg.content
+        : Array.isArray(msg.content) ? msg.content.filter((b) => b && b.type === 'text').map((b) => b.text).join('\n\n') : ''
+      if (text.trim() && !isSystemText(text)) {
+        out.push({ id: j.uuid, tool: 'Claude Code', conv, kind: 'prompt', text: capText(text.trim()), ts })
+      }
+    } else if (j.type === 'assistant' && Array.isArray(msg.content)) {
+      msg.content.forEach((b, i) => {
+        if (!b) return
+        const id = `${j.uuid}:${i}`
+        if (b.type === 'text' && b.text && b.text.trim()) {
+          out.push({ id, tool: 'Claude Code', conv, kind: 'reply', text: capText(b.text.trim()), ts })
+        } else if (b.type === 'tool_use') {
+          const target = b.input && (b.input.file_path || b.input.notebook_path)
+          const abs = target ? path.resolve(dir, target) : null
+          const text = describeAction(b.name, b.input, dir, { existed: (p) => st.seen.has(p) })
+          if (abs) st.seen.add(abs)
+          out.push({ id, tool: 'Claude Code', conv, kind: 'action', text, ts })
+        }
+      })
+    }
+    if (st.title) for (const e of out) e.title = st.title
+    return { entries: out, endTurn: j.type === 'assistant' && msg.stop_reason === 'end_turn', relevant: j.type === 'user' || j.type === 'assistant' }
+  }
+
+  function readFile (file, backfill) {
+    let st = files.get(file)
+    const size = fs.statSync(file).size
+    if (!st) {
+      st = { offset: 0, partial: '', seen: new Set() }
+      files.set(file, st)
+      if (!backfill) {
+        // Older conversation: only watch it from here on.
+        st.offset = size
+        return []
+      }
+    }
+    if (size < st.offset) { st.offset = 0; st.partial = '' } // truncated or replaced
+    if (size === st.offset) return []
+    const fd = fs.openSync(file, 'r')
+    let chunk
+    try {
+      const buf = Buffer.alloc(size - st.offset)
+      fs.readSync(fd, buf, 0, buf.length, st.offset)
+      chunk = buf.toString('utf8')
+    } finally {
+      fs.closeSync(fd)
+    }
+    st.offset = size
+    const text = st.partial + chunk
+    const lines = text.split('\n')
+    st.partial = lines.pop() // incomplete last line (no newline yet)
+    const entries = []
+    for (const line of lines) {
+      if (!line.trim()) continue
+      const r = parseLine(line, file, st)
+      if (!r) continue
+      entries.push(...r.entries)
+      if (r.relevant) {
+        if (!backfill) {
+          if (r.endTurn) midTurn.delete(file); else midTurn.set(file, now())
+          settle()
+        }
+      }
+    }
+    return backfill ? entries.slice(-BACKFILL_ENTRIES) : entries
+  }
+
+  function tick () {
+    if (stopped) return
+    try {
+      let dirs = []
+      try {
+        dirs = fs.readdirSync(root, { withFileTypes: true })
+          .filter((d) => d.isDirectory() && d.name.startsWith(slug))
+          .map((d) => path.join(root, d.name))
+      } catch {} // Claude Code not used yet here
+      const out = []
+      for (const d of dirs) {
+        let names = []
+        try { names = fs.readdirSync(d).filter((n) => n.endsWith('.jsonl')) } catch { continue }
+        for (const n of names) {
+          const file = path.join(d, n)
+          const known = files.has(file)
+          let backfill = false
+          if (!known) {
+            // On startup, pick up recent conversations; after that, any new file is live.
+            backfill = !first || now() - fs.statSync(file).mtimeMs < BACKFILL_MS
+          }
+          try { out.push(...readFile(file, backfill)) } catch (err) {
+            if (!failed) { failed = true; onLog(`Claude Code feed: could not read ${n}: ${err.message}`) }
+          }
+        }
+      }
+      first = false
+      for (const [f, at] of midTurn) if (now() - at > IDLE_AFTER_MS) midTurn.delete(f)
+      settle()
+      if (out.length) onEntries(out.sort((a, b) => a.ts - b.ts))
+    } catch (err) {
+      if (!failed) { failed = true; onLog(`Claude Code feed error: ${err.message}`) }
+    }
+  }
+
+  tick()
+  const timer = setInterval(tick, pollMs)
+  return { stop () { stopped = true; clearInterval(timer) }, tick }
+}
+
+// Slash commands, hook output and similar plumbing that show up as "user" lines.
+function isSystemText (text) {
+  return /^\s*<(command-name|command-message|command-args|local-command-stdout|local-command-stderr|system-reminder|user-memory-input|bash-input|bash-stdout|bash-stderr|task-notification)\b/.test(text) ||
+    text.startsWith('Caveat: The messages below were generated by the user while running local commands')
+}

package/src/agents/common.js

@@ -0,0 +1,21 @@
+export const MAX_ENTRY_CHARS = 8000
+
+export function capText (text) {
+  text = String(text ?? '')
+  return text.length > MAX_ENTRY_CHARS ? text.slice(0, MAX_ENTRY_CHARS) + '…(truncated)' : text
+}
+
+/** "claude-code" -> "Claude Code" etc., from the MCP client's name or an agent provider. */
+export function toolLabel (client) {
+  const n = String(client || '')
+  if (/claude/i.test(n)) return 'Claude Code'
+  if (/cursor/i.test(n)) return 'Cursor'
+  if (/codex/i.test(n)) return 'Codex'
+  if (/windsurf|codeium/i.test(n)) return 'Windsurf'
+  if (/zed/i.test(n)) return 'Zed'
+  // Model providers (agents often register these, not the host IDE).
+  if (/\bxai\b|grok/i.test(n)) return 'xAI'
+  if (/chatgpt|openai/i.test(n)) return 'Codex'
+  if (/gemini/i.test(n)) return 'Other'
+  return n || 'AI agent'
+}

package/src/agents/cursor-transcripts.js

@@ -0,0 +1,177 @@
+// Reads Cursor agent transcripts for one project folder. Current Cursor stores
+// the agent chat as JSONL under ~/.cursor/projects/<slug>/agent-transcripts/,
+// not in the composer database the older reader polls. The slug is Cursor's:
+// any character that is not a letter or digit becomes a hyphen.
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import { describeAction } from './actions.js'
+import { capText } from './common.js'
+
+const POLL_MS = 750
+const IDLE_AFTER_MS = 2 * 60 * 1000
+const BACKFILL_MS = 60 * 60 * 1000
+const BACKFILL_ENTRIES = 50
+
+export function cursorProjectsDir (home = os.homedir()) {
+  return path.join(home, '.cursor', 'projects')
+}
+
+/** Cursor's ~/.cursor/projects folder name for an absolute path.
+ *  Every character that is not a letter or digit becomes a hyphen, runs of
+ *  hyphens collapse, and hyphens at either end are removed.
+ *  `C:\Quilt Test (1)` -> `C-Quilt-Test-1`, `/Users/a/my app` -> `Users-a-my-app`. */
+export function slugCursorPath (absPath) {
+  return String(absPath).replace(/[^a-zA-Z0-9]/g, '-').replace(/-+/g, '-').replace(/^-+|-+$/g, '')
+}
+
+export function cursorProjectSlug (dir) {
+  return slugCursorPath(path.resolve(dir))
+}
+
+export function projectMatches (name, dir) {
+  const slug = cursorProjectSlug(dir)
+  if (!slug) return false
+  return process.platform === 'win32' ? name.toLowerCase() === slug.toLowerCase() : name === slug
+}
+
+/** Cursor wraps the typed message in timestamp and user_query tags. Share only the message. */
+export function cursorPromptText (text) {
+  const raw = String(text || '')
+  const queries = [...raw.matchAll(/<user_query>\s*([\s\S]*?)\s*<\/user_query>/gi)].map((m) => m[1].trim()).filter(Boolean)
+  if (queries.length) return queries.join('\n\n')
+  return raw.replace(/<timestamp>[\s\S]*?<\/timestamp>/gi, '').trim()
+}
+
+export function startCursorTranscriptReader ({ dir, onEntries, onState, onLog = () => {}, projectsDir, pollMs = POLL_MS, now = Date.now }) {
+  dir = path.resolve(dir)
+  const root = projectsDir || cursorProjectsDir()
+  const files = new Map() // path -> { offset, partial, lineNo }
+  let status = null
+  // Each conversation mid-turn, by its transcript file, with when it last wrote: the tool is working
+  // while any of them is, so one conversation ending its turn never makes another's edits look like a
+  // person's (they'd go unboxed). A conversation silent for IDLE_AFTER_MS counts as done.
+  const midTurn = new Map()
+  const settle = () => setStatus(midTurn.size ? 'working' : 'idle')
+  let stopped = false
+  let failed = false
+  let first = true
+
+  const setStatus = (s) => {
+    if (s === status) return
+    status = s
+    onState({ tool: 'Cursor', status: s })
+  }
+  setStatus('idle')
+
+  function parseLine (line, conv, lineNo) {
+    let j
+    try { j = JSON.parse(line) } catch { return null }
+    const ts = now() + lineNo
+    const content = j.message && Array.isArray(j.message.content) ? j.message.content : []
+    const out = []
+    if (j.role === 'user') {
+      const text = cursorPromptText(content.filter((b) => b && b.type === 'text' && b.text).map((b) => b.text).join('\n\n'))
+      if (text.trim()) out.push({ id: `${conv}:${lineNo}`, tool: 'Cursor', conv, kind: 'prompt', text: capText(text.trim()), ts })
+    } else if (j.role === 'assistant') {
+      content.forEach((b, i) => {
+        if (!b || b.type === 'thinking') return
+        const id = `${conv}:${lineNo}:${i}`
+        if (b.type === 'text' && b.text && b.text.trim()) out.push({ id, tool: 'Cursor', conv, kind: 'reply', text: capText(b.text.trim()), ts })
+        else if (b.type === 'tool_use' && b.name) out.push({ id, tool: 'Cursor', conv, kind: 'action', text: describeAction(b.name, b.input, dir), ts })
+      })
+    }
+    return { entries: out, endTurn: j.type === 'turn_ended', relevant: j.role === 'user' || j.role === 'assistant' || j.type === 'turn_ended' }
+  }
+
+  function readFile (file, backfill) {
+    let st = files.get(file)
+    const size = fs.statSync(file).size
+    if (!st) {
+      st = { offset: 0, partial: '', lineNo: 0 }
+      files.set(file, st)
+      if (!backfill) { st.offset = size; return [] }
+    }
+    if (size < st.offset) { st.offset = 0; st.partial = ''; st.lineNo = 0 }
+    if (size === st.offset) return []
+    const fd = fs.openSync(file, 'r')
+    let chunk
+    try {
+      const buf = Buffer.alloc(size - st.offset)
+      fs.readSync(fd, buf, 0, buf.length, st.offset)
+      chunk = buf.toString('utf8')
+    } finally {
+      fs.closeSync(fd)
+    }
+    st.offset = size
+    const text = st.partial + chunk
+    const lines = text.split('\n')
+    st.partial = lines.pop()
+    const conv = path.basename(file, '.jsonl')
+    const entries = []
+    for (const line of lines) {
+      if (!line.trim()) continue
+      st.lineNo++
+      const r = parseLine(line, conv, st.lineNo)
+      if (!r) continue
+      entries.push(...r.entries)
+      if (r.relevant) {
+        {
+          if (r.endTurn) midTurn.delete(file); else midTurn.set(file, now())
+          settle()
+        }
+      }
+    }
+    return backfill ? entries.slice(-BACKFILL_ENTRIES) : entries
+  }
+
+  function transcripts (projectDir) {
+    const base = path.join(projectDir, 'agent-transcripts')
+    const out = []
+    const walk = (d, depth) => {
+      if (depth > 3) return
+      let entries = []
+      try { entries = fs.readdirSync(d, { withFileTypes: true }) } catch { return }
+      for (const e of entries) {
+        const p = path.join(d, e.name)
+        if (e.isDirectory()) walk(p, depth + 1)
+        else if (e.name.endsWith('.jsonl')) out.push(p)
+      }
+    }
+    walk(base, 0)
+    return out
+  }
+
+  function tick () {
+    if (stopped) return
+    try {
+      let dirs = []
+      try {
+        dirs = fs.readdirSync(root, { withFileTypes: true })
+          .filter((d) => d.isDirectory() && projectMatches(d.name, dir))
+          .map((d) => path.join(root, d.name))
+      } catch {}
+      const out = []
+      for (const d of dirs) {
+        for (const file of transcripts(d)) {
+          const known = files.has(file)
+          let backfill = false
+          if (!known) backfill = !first || now() - fs.statSync(file).mtimeMs < BACKFILL_MS
+          try { out.push(...readFile(file, backfill)) } catch (err) {
+            if (!failed) { failed = true; onLog(`Cursor feed: could not read ${path.basename(file)}: ${err.message}`) }
+          }
+        }
+      }
+      first = false
+      for (const [f, at] of midTurn) if (now() - at > IDLE_AFTER_MS) midTurn.delete(f)
+      settle()
+      if (out.length) onEntries(out)
+    } catch (err) {
+      if (!failed) { failed = true; onLog(`Cursor feed error: ${err.message}`) }
+    }
+  }
+
+  tick()
+  const timer = setInterval(tick, pollMs)
+  return { stop () { stopped = true; clearInterval(timer) } }
+}