@chroxify/eunoe 1.2.1 → 1.3.0

package/src/transcript/search.ts

@@ -1,7 +1,8 @@
 import { existsSync } from "node:fs"
 import path from "node:path"
 import type { SearchMode } from "../config"
-import { renderTranscript, transcriptDir } from "./render"
+import { transcriptDir } from "./render"
+import type { RenderDone, RenderJob } from "./render-worker"
 
 export interface TranscriptRef {
   mode: SearchMode
@@ -32,13 +33,53 @@ function indexWithQmd(dir: string) {
   return next
 }
 
+const queued = new Map<string, { mode: SearchMode; sessionFile: string }>()
+let renderer: Worker | null = null
+let rendering: { dir: string; mode: SearchMode } | null = null
+let drained: Array<() => void> = []
+
+function finished(changed: boolean) {
+  if (rendering?.mode === "qmd" && (changed || !isIndexed(rendering.dir))) void indexWithQmd(rendering.dir)
+  rendering = null
+  renderNext()
+}
+
+function startRenderer(): Worker {
+  const worker = new Worker(new URL("./render-worker.ts", import.meta.url))
+  worker.onmessage = ({ data }: MessageEvent<RenderDone>) => finished(data.changed)
+  worker.onerror = () => {
+    renderer = null
+    finished(false)
+  }
+  ;(worker as Worker & { unref(): void }).unref()
+  return worker
+}
+
+function renderNext() {
+  const next = queued.entries().next()
+  if (next.done) {
+    const waiting = drained
+    drained = []
+    for (const resolve of waiting) resolve()
+    return
+  }
+  const [dir, { mode, sessionFile }] = next.value
+  queued.delete(dir)
+  rendering = { dir, mode }
+  renderer ??= startRenderer()
+  renderer.postMessage({ dir, sessionFile, format: mode === "xml" ? "xml" : "markdown" } satisfies RenderJob)
+}
+
+export function flushTranscripts(): Promise<void> {
+  if (!rendering && queued.size === 0) return Promise.resolve()
+  return new Promise((resolve) => drained.push(resolve))
+}
+
 export function prepareTranscript(mode: SearchMode, sessionFile: string, key: string): TranscriptRef {
   const dir = transcriptDir(key)
   if (mode !== "jsonl") {
-    try {
-      const { changed } = renderTranscript(sessionFile, key, dir, mode === "xml" ? "xml" : "markdown")
-      if (mode === "qmd" && (changed || !isIndexed(dir))) void indexWithQmd(dir)
-    } catch {}
+    queued.set(dir, { mode, sessionFile })
+    if (!rendering) renderNext()
   }
   return { mode, jsonl: sessionFile, dir }
 }

package/src/transcript/subagents.ts

@@ -2,10 +2,12 @@ import { readFileSync, statSync } from "node:fs"
 import path from "node:path"
 import { blocks, clip, contentBlocks, type Message } from "../context/content"
 import { splitTurns } from "../context/fold/turns"
-import { type RecallChunk, recallChunks } from "../context/recall"
+import type { RecallChunk } from "../context/recall"
+import { subagentRecall } from "../core/subagents"
+import { readSessionEntries } from "./entries"
 import { listEntries } from "./locate"
 import { sessionMessages } from "./messages"
-import { entryMessages, parseJsonl, type SessionEntry } from "./parse"
+import { entryMessages, type SessionEntry } from "./parse"
 
 export interface SubagentRun {
   id: string
@@ -20,7 +22,7 @@ export interface SubagentRun {
 
 const INLINE_ID = "sidechain"
 
-const entryCache = new Map<string, { mtimeMs: number; entries: SessionEntry[] }>()
+const runCache = new Map<string, SubagentRun>()
 const chunkCache = new Map<string, { mtimeMs: number; parentTurn: number; chunks: RecallChunk[] }>()
 
 function mtimeOf(file: string): number | null {
@@ -31,16 +33,6 @@ function mtimeOf(file: string): number | null {
   }
 }
 
-function readEntries(file: string): SessionEntry[] {
-  const mtimeMs = mtimeOf(file)
-  if (mtimeMs === null) return []
-  const hit = entryCache.get(file)
-  if (hit?.mtimeMs === mtimeMs) return hit.entries
-  const entries = parseJsonl(readFileSync(file, "utf8"))
-  entryCache.set(file, { mtimeMs, entries })
-  return entries
-}
-
 function firstPrompt(entries: SessionEntry[]): string {
   for (const entry of entries) {
     if (entry.type !== "user" || !entry.message) continue
@@ -72,10 +64,13 @@ function fileRuns(sessionFile: string): SubagentRun[] {
     .filter((name) => name.startsWith("agent-") && name.endsWith(".jsonl"))
     .map((name) => {
       const file = path.join(dir, name)
-      const entries = readEntries(file)
+      const mtimeMs = mtimeOf(file) ?? 0
+      const known = runCache.get(file)
+      if (known?.mtimeMs === mtimeMs) return known
+      const entries = readSessionEntries(file)
       const meta = readMeta(file)
       const prompt = firstPrompt(entries)
-      return {
+      const run: SubagentRun = {
         id: name.slice("agent-".length, -".jsonl".length),
         file,
         inline: false,
@@ -83,17 +78,21 @@ function fileRuns(sessionFile: string): SubagentRun[] {
         toolUseId: meta.toolUseId ? String(meta.toolUseId) : null,
         prompt,
         started: String(entries[0]?.timestamp ?? ""),
-        mtimeMs: mtimeOf(file) ?? 0,
+        mtimeMs,
       }
+      runCache.set(file, run)
+      return run
     })
 }
 
 function inlineRuns(sessionFile: string, known: Set<string>): SubagentRun[] {
   const byAgent = new Map<string, SessionEntry[]>()
-  for (const entry of readEntries(sessionFile)) {
+  for (const entry of readSessionEntries(sessionFile)) {
     if (!entry.isSidechain) continue
     const id = entry.agentId ?? INLINE_ID
-    byAgent.set(id, [...(byAgent.get(id) ?? []), entry])
+    const group = byAgent.get(id)
+    if (group) group.push(entry)
+    else byAgent.set(id, [entry])
   }
   return [...byAgent]
     .filter(([id]) => !known.has(id))
@@ -110,7 +109,7 @@ export function subagentRuns(sessionFile: string): SubagentRun[] {
 }
 
 export function subagentEntries(run: SubagentRun): SessionEntry[] {
-  const entries = readEntries(run.file)
+  const entries = readSessionEntries(run.file)
   if (!run.inline) return entries
   return entries.filter((entry) => entry.isSidechain && (entry.agentId ?? INLINE_ID) === run.id)
 }
@@ -119,31 +118,53 @@ export function subagentMessages(run: SubagentRun): Message[] {
   return entryMessages(subagentEntries(run))
 }
 
-function launchedBy(run: SubagentRun, call: { id?: unknown; name?: unknown; prompt?: unknown }): boolean {
-  if (run.toolUseId) return call.id === run.toolUseId
-  return (call.name === "Agent" || call.name === "Task") && String(call.prompt ?? "") === run.prompt
+interface Launches {
+  byId: Map<unknown, number>
+  byPrompt: Map<string, number>
+}
+
+function launchesIn(parentMessages: Message[]): Launches {
+  const launches: Launches = { byId: new Map(), byPrompt: new Map() }
+  splitTurns(parentMessages).turns.forEach((turn, index) => {
+    for (const message of turn) {
+      if (message.role !== "assistant") continue
+      for (const block of blocks(message)) {
+        if (block.type !== "tool_use") continue
+        if (!launches.byId.has(block.id)) launches.byId.set(block.id, index + 1)
+        const prompt = String(block.input?.prompt ?? "")
+        if ((block.name === "Agent" || block.name === "Task") && !launches.byPrompt.has(prompt)) launches.byPrompt.set(prompt, index + 1)
+      }
+    }
+  })
+  return launches
 }
 
+const launchTurn = (run: SubagentRun, launches: Launches) => (run.toolUseId ? launches.byId.get(run.toolUseId) : launches.byPrompt.get(run.prompt)) ?? 0
+
 export function parentTurnOf(run: SubagentRun, parentMessages: Message[]): number {
-  const { turns } = splitTurns(parentMessages)
-  const index = turns.findIndex((turn) =>
-    turn
-      .filter((message) => message.role === "assistant")
-      .flatMap(blocks)
-      .some((block) => block.type === "tool_use" && launchedBy(run, { id: block.id, name: block.name, prompt: block.input?.prompt })),
-  )
-  return index + 1
+  return launchTurn(run, launchesIn(parentMessages))
+}
+
+const KEPT_LAUNCHES = 8
+const launchCache = new Map<Message[], Launches>()
+
+function cachedLaunches(parentMessages: Message[]): Launches {
+  const known = launchCache.get(parentMessages)
+  if (known) return known
+  const launches = launchesIn(parentMessages)
+  launchCache.set(parentMessages, launches)
+  if (launchCache.size > KEPT_LAUNCHES) launchCache.delete(launchCache.keys().next().value as Message[])
+  return launches
 }
 
 export function subagentChunks(sessionFile: string): RecallChunk[] {
-  const parent = sessionMessages(sessionFile)
+  const launches = cachedLaunches(sessionMessages(sessionFile))
   return subagentRuns(sessionFile).flatMap((run) => {
     const key = `${run.file}#${run.id}`
-    const parentTurn = parentTurnOf(run, parent)
+    const parentTurn = launchTurn(run, launches)
     const hit = chunkCache.get(key)
     if (hit && hit.mtimeMs === run.mtimeMs && hit.parentTurn === parentTurn) return hit.chunks
-    const from = `subagent "${run.description}"`
-    const chunks = recallChunks([...subagentMessages(run), { role: "user", content: "" }], new Map()).map((chunk) => ({ ...chunk, from, turn: parentTurn }))
+    const chunks = subagentRecall(subagentMessages(run), run.description, parentTurn)
     chunkCache.set(key, { mtimeMs: run.mtimeMs, parentTurn, chunks })
     return chunks
   })