@chroxify/eunoe 1.2.2 → 1.3.1

package/src/proxy/sources.ts

@@ -0,0 +1,35 @@
+import { type Config, claudeConfigDirs } from "../config"
+import type { Message } from "../context/content"
+import { searchGuide } from "../context/prompts"
+import type { ThreadSources } from "../core/rewrite"
+import { findSessionByPrefix } from "../transcript/locate"
+import { sessionMessages } from "../transcript/messages"
+import type { TranscriptRef } from "../transcript/search"
+import { subagentChunks } from "../transcript/subagents"
+import { titleOf } from "./sessions"
+
+function readSession(file: string): Message[] {
+  try {
+    return sessionMessages(file)
+  } catch {
+    return []
+  }
+}
+
+export function sessionSources(transcript: TranscriptRef | null, config: Config, sessionId: string | null): ThreadSources {
+  const handoffs = {
+    findHandoff: (id: string) => {
+      const file = findSessionByPrefix(id, claudeConfigDirs(config), sessionId ?? undefined)
+      return file ? { label: titleOf(file) ?? id, source: file } : null
+    },
+    readHandoff: readSession,
+  }
+  if (!transcript) return handoffs
+  return {
+    ...handoffs,
+    guide: searchGuide(transcript),
+    transcriptDir: transcript.mode !== "jsonl" ? transcript.dir : null,
+    readHistory: () => sessionMessages(transcript.jsonl),
+    listSubagentChunks: () => subagentChunks(transcript.jsonl),
+  }
+}

package/src/proxy/state.ts

@@ -1,21 +1,7 @@
 import { mkdirSync, readFileSync, statSync, writeFileSync } from "node:fs"
 import path from "node:path"
 import { paths } from "../config/paths"
-
-export interface Handoff {
-  label: string
-  source: string
-  text: string
-}
-
-export interface ThreadState {
-  handoffs?: Record<string, Handoff | null>
-  cut?: string
-  keep?: number
-  cleared?: number
-  ratio?: number
-  recalls?: Record<string, string>
-}
+import type { ThreadState, ThreadStore } from "../core/state"
 
 function stateFile(key: string) {
   return path.join(paths.threads, `${key.replace(/[^a-zA-Z0-9_-]/g, "_")}.json`)
@@ -63,8 +49,4 @@ export function saveState(key: string, state: ThreadState) {
   if (version !== null) remember(file, version, structuredClone(state))
 }
 
-export function resetCut(state: ThreadState) {
-  delete state.cut
-  delete state.keep
-  delete state.cleared
-}
+export const fileStore: ThreadStore = { read: readState, save: saveState }

package/src/proxy/window.ts

@@ -1,5 +1,6 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs"
 import { EUNOE_DIR, paths } from "../config/paths"
+import { createWindowLookup } from "../core/window"
 
 function readCache(): Map<string, number> {
   try {
@@ -9,40 +10,9 @@ function readCache(): Map<string, number> {
   }
 }
 
-const windows = readCache()
-const lookups = new Map<string, Promise<number | null>>()
-
-function lookupHeaders(requestHeaders: Headers): Headers {
-  const headers = new Headers()
-  for (const name of ["authorization", "x-api-key", "anthropic-version", "anthropic-beta"]) {
-    const value = requestHeaders.get(name)
-    if (value) headers.set(name, value)
-  }
-  if (!headers.has("anthropic-version")) headers.set("anthropic-version", "2023-06-01")
-  return headers
-}
-
-async function lookup(id: string, requestHeaders: Headers, upstream: string): Promise<number | null> {
-  const response = await fetch(`${upstream}/v1/models/${encodeURIComponent(id)}`, { headers: lookupHeaders(requestHeaders), signal: AbortSignal.timeout(5_000) })
-  if (!response.ok) return null
-  const info = (await response.json()) as { max_input_tokens?: number }
-  if (typeof info.max_input_tokens !== "number" || info.max_input_tokens <= 0) return null
-  windows.set(id, info.max_input_tokens)
+function saveCache(windows: Map<string, number>) {
   mkdirSync(EUNOE_DIR, { recursive: true })
   writeFileSync(paths.models, JSON.stringify(Object.fromEntries(windows), null, 2))
-  return info.max_input_tokens
 }
 
-export function resolveWindow(model: unknown, requestHeaders: Headers, upstream: string): Promise<number | null> {
-  const id = String(model ?? "").replace(/\[[^\]]*\]$/, "")
-  if (!id) return Promise.resolve(null)
-  const known = windows.get(id)
-  if (known) return Promise.resolve(known)
-  const inFlight = lookups.get(id)
-  if (inFlight) return inFlight
-  const pending = lookup(id, requestHeaders, upstream)
-    .catch(() => null)
-    .finally(() => lookups.delete(id))
-  lookups.set(id, pending)
-  return pending
-}
+export const resolveWindow = createWindowLookup({ known: readCache(), onLearn: saveCache })

package/src/transcript/format.ts

@@ -1,9 +1,8 @@
 import { clip } from "../context/content"
 import type { ToolPart, TranscriptFormat, Turn } from "./parse"
-import type { SubagentRun } from "./subagents"
 
 export interface SubagentRecord {
-  run: SubagentRun
+  run: { description: string }
   turns: Turn[]
   parentTurn: number
   file: string

package/src/transcript/subagents.ts

@@ -2,7 +2,8 @@ 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"
@@ -163,8 +164,7 @@ export function subagentChunks(sessionFile: string): RecallChunk[] {
     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
   })

package/src/proxy/recall.ts

@@ -1,58 +0,0 @@
-import { type Body, blocks, resultText } from "../context/content"
-import { livePrompt, type RecallChunk, type Reranker, recallChunks, recallFor, recallForWith, withRecall } from "../context/recall"
-import { sessionMessages } from "../transcript/messages"
-import { subagentChunks } from "../transcript/subagents"
-import { messageFingerprint } from "./fingerprint"
-import { activeHandoffs, handoffChunks } from "./handoff"
-import type { Rewrite, RewriteInput } from "./rewrite"
-import { readState, saveState } from "./state"
-
-export const wantsRecall = (input: RewriteInput) => (input.config.eval?.recall ?? true) && input.config.mode !== "off"
-
-export const activeRecalls = (recalls: Record<string, string> = {}) => Object.fromEntries(Object.entries(recalls).filter(([, text]) => text))
-
-const touched = (input: RewriteInput, result: Rewrite) => result.threadKey !== null && !(result.body === input.body && result.note.action === "pass")
-
-function droppedChunks(input: RewriteInput, result: Rewrite): RecallChunk[] {
-  const transcript = input.transcript?.jsonl ?? null
-  const kept = new Map<string, string>()
-  for (const message of result.body.messages) for (const b of blocks(message)) if (b.type === "tool_result") kept.set(b.tool_use_id, resultText(b))
-  const own = recallChunks(input.body.messages, kept)
-  const session = own.length > 0 || !transcript ? own : recallChunks([...sessionMessages(transcript), { role: "user", content: "" }], kept)
-  const withSubagents = transcript ? [...session, ...subagentChunks(transcript)] : session
-  const handoffs = result.threadKey ? activeHandoffs(readState(result.threadKey).handoffs) : {}
-  return [...handoffChunks(handoffs), ...withSubagents]
-}
-
-function recallTarget(original: Body, result: Rewrite): { key: string; text: string } | null {
-  const live = livePrompt(original.messages)
-  return live && result.threadKey ? { key: messageFingerprint(original.messages[live.index]), text: live.text } : null
-}
-
-export function applyRecall(input: RewriteInput, result: Rewrite): Rewrite {
-  if (!touched(input, result) || !result.threadKey) return result
-  const state = readState(result.threadKey)
-  state.recalls ??= {}
-  const target = recallTarget(input.body, result)
-  let note = result.note
-  if (target && !(target.key in state.recalls)) {
-    state.recalls[target.key] = recallFor(target.text, droppedChunks(input, result), input.config.eval?.recallOptions) ?? ""
-    saveState(result.threadKey, state)
-    note = { ...note, recalled: state.recalls[target.key].length }
-  }
-  const messages = withRecall(result.body.messages, messageFingerprint, activeRecalls(state.recalls))
-  return messages === result.body.messages ? { ...result, note } : { ...result, body: { ...result.body, messages }, note }
-}
-
-export async function prefetchFor(input: RewriteInput, result: Rewrite, rerank: Reranker): Promise<number | null> {
-  if (!touched(input, result) || !result.threadKey) return null
-  const target = recallTarget(input.body, result)
-  if (!target) return null
-  const state = readState(result.threadKey)
-  state.recalls ??= {}
-  if (target.key in state.recalls) return null
-  const options = { candidates: input.config.eval?.rerank?.candidates, ...input.config.eval?.recallOptions }
-  state.recalls[target.key] = (await recallForWith(target.text, droppedChunks(input, result), rerank, options)) ?? ""
-  saveState(result.threadKey, state)
-  return state.recalls[target.key].length
-}