@chroxify/eunoe 0.0.0-stage → 0.1.0

package/src/proxy/window.ts

@@ -0,0 +1,50 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs"
+import { EUNOE_DIR, paths } from "../config/constants"
+import { ANTHROPIC_VERSION, MODEL_HEADERS, MODEL_LOOKUP_TIMEOUT_MS } from "./constants"
+
+const CACHE = paths.models
+
+function readCache(): Map<string, number> {
+  try {
+    return new Map(existsSync(CACHE) ? Object.entries(JSON.parse(readFileSync(CACHE, "utf8"))) : [])
+  } catch {
+    return new Map()
+  }
+}
+
+const windows = readCache()
+const lookups = new Map<string, Promise<number | null>>()
+
+function modelId(model: unknown) {
+  return String(model ?? "").replace(/\[[^\]]*\]$/, "")
+}
+
+export async function resolveWindow(model: unknown, requestHeaders: Headers, upstream: string): Promise<number | null> {
+  const id = modelId(model)
+  if (!id) return null
+  const known = windows.get(id)
+  if (known) return known
+  let lookup = lookups.get(id)
+  if (!lookup) {
+    const headers = new Headers()
+    for (const name of MODEL_HEADERS) {
+      const value = requestHeaders.get(name)
+      if (value) headers.set(name, value)
+    }
+    if (!headers.has("anthropic-version")) headers.set("anthropic-version", ANTHROPIC_VERSION)
+    lookup = fetch(`${upstream}/v1/models/${encodeURIComponent(id)}`, { headers, signal: AbortSignal.timeout(MODEL_LOOKUP_TIMEOUT_MS) })
+      .then(async (response) => {
+        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)
+        mkdirSync(EUNOE_DIR, { recursive: true })
+        writeFileSync(CACHE, JSON.stringify(Object.fromEntries(windows), null, 2))
+        return info.max_input_tokens
+      })
+      .catch(() => null)
+      .finally(() => lookups.delete(id))
+    lookups.set(id, lookup)
+  }
+  return lookup
+}

package/src/transcript/constants.ts

@@ -0,0 +1,16 @@
+export const OUTPUT_CAP = 40_000
+
+export const CALL_COMMAND_CHARS = 300
+export const CALL_PATTERN_CHARS = 120
+export const CALL_DESCRIPTION_CHARS = 160
+export const CALL_INPUT_CHARS = 200
+
+export const INDEX_PROMPT_CHARS = 140
+export const INDEX_REPLY_CHARS = 160
+
+export const RENDER_STAMP = ".rendered"
+export const TURN_COUNT_FILE = ".turns"
+export const INDEX_FILE = "index.md"
+export const QMD_DIR = ".qmd"
+
+export const SESSION_ID_PATTERN = /^[a-zA-Z0-9-]+$/

package/src/transcript/format.ts

@@ -0,0 +1,68 @@
+import { clip } from "../context/content"
+import { INDEX_PROMPT_CHARS, INDEX_REPLY_CHARS } from "./constants"
+import type { TranscriptFormat, Turn } from "./types"
+
+export function turnFile(turn: Turn, format: TranscriptFormat) {
+  return `turn-${String(turn.number).padStart(4, "0")}.${format === "xml" ? "xml" : "md"}`
+}
+
+export function renderMarkdown(turn: Turn) {
+  const work = turn.parts.map((part) => part.kind === "say"
+    ? `> ${part.text.replace(/\n/g, "\n> ")}`
+    : [
+        `### [tool ${part.n}/${turn.calls}] ${part.name}: ${part.call}`,
+        part.body,
+        part.output ? `[output of tool ${part.n}${part.error ? ", error" : ""}]\n\`\`\`\n${part.output}\n\`\`\`` : `[tool ${part.n}: no output]`,
+      ].filter(Boolean).join("\n\n"))
+  return [
+    `# Turn ${turn.number}${turn.time ? ` · ${turn.time}` : ""}`,
+    "",
+    "## User",
+    "",
+    turn.prompt,
+    "",
+    `## Work (${turn.calls} tool call${turn.calls === 1 ? "" : "s"})`,
+    "",
+    work.join("\n\n") || "_No tool calls._",
+    "",
+    "## Final reply",
+    "",
+    turn.final || "_No final reply: the turn was interrupted or is still running._",
+    "",
+  ].join("\n")
+}
+
+function attr(value: string) {
+  return value.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/\n/g, " ")
+}
+
+export function renderXml(turn: Turn) {
+  const work = turn.parts.map((part) => part.kind === "say"
+    ? `<said>\n${part.text}\n</said>`
+    : [
+        `<tool n="${part.n}" of="${turn.calls}" name="${attr(part.name)}">`,
+        `<call>${part.call.replace(/^`|`$/g, "")}</call>`,
+        part.body ? `<input>\n${part.body}\n</input>` : "",
+        part.output ? `<output${part.error ? ' error="true"' : ""}>\n${part.output}\n</output>` : "<output/>",
+        "</tool>",
+      ].filter(Boolean).join("\n"))
+  return [
+    `<turn n="${turn.number}"${turn.time ? ` time="${turn.time}"` : ""} tool_calls="${turn.calls}">`,
+    `<user>\n${turn.prompt}\n</user>`,
+    ...work,
+    turn.final ? `<final_reply>\n${turn.final}\n</final_reply>` : `<final_reply interrupted="true"/>`,
+    "</turn>",
+    "",
+  ].join("\n")
+}
+
+export function renderIndex(turns: Turn[], format: TranscriptFormat) {
+  return [
+    "# Session index",
+    "",
+    `One line per turn: what the user asked → how the turn ended. Open turn-NNNN.${format === "xml" ? "xml" : "md"} for everything that happened in it.`,
+    "",
+    ...turns.map((turn) => `- **${turnFile(turn, format)}** (${turn.time}, ${turn.calls} calls): ${clip(turn.prompt, INDEX_PROMPT_CHARS)} → ${turn.final ? clip(turn.final, INDEX_REPLY_CHARS) : "_(no final reply)_"}`),
+    "",
+  ].join("\n")
+}

package/src/transcript/locate.ts

@@ -0,0 +1,28 @@
+import { existsSync, readdirSync } from "node:fs"
+import path from "node:path"
+import { SESSION_ID_PATTERN } from "./constants"
+
+const found = new Map<string, string>()
+
+export function findSessionFile(sessionId: string, configDirs: string[]): string | null {
+  const hit = found.get(sessionId)
+  if (hit && existsSync(hit)) return hit
+  if (!SESSION_ID_PATTERN.test(sessionId)) return null
+  for (const configDir of configDirs) {
+    const projects = path.join(configDir, "projects")
+    let dirs: string[]
+    try {
+      dirs = readdirSync(projects)
+    } catch {
+      continue
+    }
+    for (const dir of dirs) {
+      const file = path.join(projects, dir, `${sessionId}.jsonl`)
+      if (existsSync(file)) {
+        found.set(sessionId, file)
+        return file
+      }
+    }
+  }
+  return null
+}

package/src/transcript/parse.ts

@@ -0,0 +1,93 @@
+import { contentBlocks } from "../context/content"
+import type { Block } from "../context/types"
+import { CALL_COMMAND_CHARS, CALL_DESCRIPTION_CHARS, CALL_INPUT_CHARS, CALL_PATTERN_CHARS, OUTPUT_CAP } from "./constants"
+import type { SessionEntry, ToolPart, Turn } from "./types"
+
+function stripReminders(text: string) {
+  return text
+    .replace(/<system-reminder>[\s\S]*?<\/system-reminder>/g, "")
+    .replace(/<system-message>[\s\S]*?<\/system-message>/g, "")
+    .trim()
+}
+
+function isPrompt(entry: SessionEntry) {
+  if (entry.type !== "user" || entry.isMeta || entry.isCompactSummary || entry.isSidechain) return false
+  const content = contentBlocks(entry.message?.content)
+  if (content.some((block) => block.type === "tool_result")) return false
+  const text = stripReminders(content.filter((block) => block.type === "text").map((block) => block.text ?? "").join("\n"))
+  return Boolean(text) || content.some((block) => block.type === "image")
+}
+
+function describeCall(block: Block): string {
+  const input = block.input ?? {}
+  if (typeof input.command === "string") return `${block.name}: \`${input.command.replace(/\s+/g, " ").slice(0, CALL_COMMAND_CHARS)}\``
+  if (typeof input.file_path === "string") return `${block.name}: ${input.file_path}`
+  if (typeof input.pattern === "string") return `${block.name}: "${input.pattern.slice(0, CALL_PATTERN_CHARS)}"${input.path ? ` in ${input.path}` : ""}`
+  if (typeof input.url === "string") return `${block.name}: ${input.url}`
+  if (typeof input.description === "string") return `${block.name}: ${input.description.slice(0, CALL_DESCRIPTION_CHARS)}`
+  return `${block.name}: ${JSON.stringify(input).slice(0, CALL_INPUT_CHARS)}`
+}
+
+function callBody(block: Block): string {
+  const input = block.input ?? {}
+  if (typeof input.new_string === "string") return `Replaced:\n\`\`\`\n${input.old_string ?? ""}\n\`\`\`\nWith:\n\`\`\`\n${input.new_string}\n\`\`\``
+  if (typeof input.content === "string" && block.name === "Write") return `\`\`\`\n${input.content.slice(0, OUTPUT_CAP)}\n\`\`\``
+  return ""
+}
+
+function resultText(block: Block): string {
+  const content = typeof block.content === "string"
+    ? block.content
+    : contentBlocks(block.content).map((part) => (part.type === "text" ? part.text : `[${part.type}]`)).join("\n")
+  return content.length > OUTPUT_CAP ? `${content.slice(0, OUTPUT_CAP)}\n… [${content.length - OUTPUT_CAP} more characters]` : content
+}
+
+export function parseTurns(entries: SessionEntry[]): Turn[] {
+  const turns: Turn[] = []
+  const pending = new Map<string, ToolPart>()
+  let narration = ""
+  for (const entry of entries) {
+    if (entry.isSidechain) continue
+    if (isPrompt(entry)) {
+      const text = stripReminders(contentBlocks(entry.message.content).filter((block) => block.type === "text").map((block) => block.text).join("\n"))
+      turns.push({ number: turns.length + 1, time: String(entry.timestamp ?? "").slice(0, 16).replace("T", " "), prompt: text || "[image]", parts: [], final: "", calls: 0 })
+      continue
+    }
+    const turn = turns.at(-1)
+    if (!turn) continue
+    if (entry.type === "system" && entry.subtype === "compact_boundary") {
+      turn.parts.push({ kind: "say", text: "(Claude Code compacted the context here.)" })
+      continue
+    }
+    if (entry.type === "assistant") {
+      for (const block of contentBlocks(entry.message?.content)) {
+        if (block.type === "text" && String(block.text).trim()) {
+          narration = String(block.text).trim()
+          turn.final = narration
+        }
+        if (block.type === "tool_use") {
+          turn.calls += 1
+          if (narration) {
+            turn.parts.push({ kind: "say", text: narration })
+            narration = ""
+          }
+          turn.final = ""
+          const call: ToolPart = { kind: "tool", n: turn.calls, name: block.name, call: describeCall(block).slice(block.name.length + 2), body: callBody(block), output: "", error: false }
+          pending.set(block.id, call)
+          turn.parts.push(call)
+        }
+      }
+    }
+    if (entry.type === "user") {
+      for (const block of contentBlocks(entry.message?.content)) {
+        if (block.type !== "tool_result") continue
+        const call = pending.get(block.tool_use_id)
+        if (!call) continue
+        pending.delete(block.tool_use_id)
+        call.output = resultText(block).trim()
+        call.error = Boolean(block.is_error)
+      }
+    }
+  }
+  return turns
+}

package/src/transcript/render.ts

@@ -0,0 +1,36 @@
+import { existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from "node:fs"
+import path from "node:path"
+import { paths } from "../config/constants"
+import { INDEX_FILE, RENDER_STAMP, TURN_COUNT_FILE } from "./constants"
+import { renderIndex, renderMarkdown, renderXml, turnFile } from "./format"
+import { parseTurns } from "./parse"
+import type { RenderResult, TranscriptFormat } from "./types"
+
+export function transcriptDir(sessionId: string) {
+  return path.join(paths.transcripts, sessionId)
+}
+
+export function renderTranscript(sessionFile: string, sessionId: string, outDir = transcriptDir(sessionId), format: TranscriptFormat = "markdown"): RenderResult {
+  mkdirSync(outDir, { recursive: true })
+  const stampFile = path.join(outDir, RENDER_STAMP)
+  const mtime = String(statSync(sessionFile).mtimeMs)
+  if (existsSync(stampFile) && readFileSync(stampFile, "utf8") === mtime) {
+    return { dir: outDir, changed: false, turns: Number(readFileSync(path.join(outDir, TURN_COUNT_FILE), "utf8") || 0) }
+  }
+  const entries = readFileSync(sessionFile, "utf8").split("\n").flatMap((line) => {
+    try { return line ? [JSON.parse(line)] : [] } catch { return [] }
+  })
+  const turns = parseTurns(entries)
+  let changed = false
+  const write = (file: string, content: string) => {
+    const target = path.join(outDir, file)
+    if (existsSync(target) && readFileSync(target, "utf8") === content) return
+    writeFileSync(target, content)
+    changed = true
+  }
+  for (const turn of turns) write(turnFile(turn, format), format === "xml" ? renderXml(turn) : renderMarkdown(turn))
+  write(INDEX_FILE, renderIndex(turns, format))
+  writeFileSync(stampFile, mtime)
+  writeFileSync(path.join(outDir, TURN_COUNT_FILE), String(turns.length))
+  return { dir: outDir, changed, turns: turns.length }
+}

package/src/transcript/search.ts

@@ -0,0 +1,80 @@
+import { existsSync } from "node:fs"
+import path from "node:path"
+import type { SearchMode } from "../config/types"
+import { QMD_DIR } from "./constants"
+import { renderTranscript, transcriptDir } from "./render"
+import type { TranscriptRef } from "./types"
+
+const indexing = new Map<string, Promise<void>>()
+
+async function qmd(cwd: string, args: string[]) {
+  await Bun.spawn(["qmd", ...args], { cwd, stdout: "ignore", stderr: "ignore" }).exited
+}
+
+function indexWithQmd(dir: string) {
+  const previous = indexing.get(dir) ?? Promise.resolve()
+  const next = previous.then(async () => {
+    if (!existsSync(path.join(dir, QMD_DIR))) {
+      await qmd(dir, ["init"])
+      await qmd(dir, ["collection", "add", ".", "--name", "transcript"])
+    }
+    await qmd(dir, ["update"])
+    await qmd(dir, ["embed"])
+  }).catch(() => undefined)
+  indexing.set(dir, next)
+  return next
+}
+
+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 || !existsSync(path.join(dir, QMD_DIR)))) void indexWithQmd(dir)
+    } catch {}
+  }
+  return { mode, jsonl: sessionFile, dir }
+}
+
+export function searchGuide(ref: TranscriptRef): string {
+  if (ref.mode === "jsonl") {
+    return [
+      `The full transcript is Claude Code's session file: ${ref.jsonl}`,
+      "It is JSONL, one entry per line. Your tool calls are `tool_use` blocks in `assistant` entries; their output is in the `tool_result` blocks of the `user` entries that follow. It is large: search it narrowly and never read it whole. For example:",
+      `  grep -n 'distinctive text' ${ref.jsonl} | cut -c1-400`,
+      `  jq -r 'select(.type=="assistant") | .message.content[]? | select(.type=="tool_use") | "\\(.name) \\(.input | tostring | .[0:200])"' ${ref.jsonl}`,
+    ].join("\n")
+  }
+  const ext = ref.mode === "xml" ? "xml" : "md"
+  const layout = ref.mode === "xml"
+    ? [
+        `The full transcript is a folder with one XML file per turn: ${ref.dir}`,
+        "- `index.md`: one line per turn, what the user asked and how the turn ended. Skim it to find the turn you need.",
+        "- `turn-0001.xml`, …: one turn each, `<turn n>` with `<user>` (the message), `<said>` (what you wrote while working), `<tool n name>` holding `<call>`, `<input>` and `<output>`, and `<final_reply>`.",
+      ]
+    : [
+        `The full transcript is a folder of markdown files: ${ref.dir}`,
+        "- `index.md`: one line per turn, what the user asked and how the turn ended. Skim it to find the turn you need.",
+        "- `turn-0001.md`, …: one turn each. `## User` (the message), `### [tool 3/12] Bash: …` for every tool call with `[output of tool 3]` below it, and `## Final reply`.",
+      ]
+  const habits = "Search for more than one phrasing (the exact term, a synonym, a file or function name, an error string) before you conclude something isn't there. Read the whole turn file around a hit: the answer is often a few calls before or after it."
+  if (ref.mode === "markdown" || ref.mode === "xml") {
+    return [
+      ...layout,
+      "To find something:",
+      `  grep -ril 'distinctive words' ${ref.dir}        # which turns mention it`,
+      `  grep -n -i 'distinctive words' ${ref.dir}/*.${ext} | cut -c1-300`,
+      `  then Read ${ref.dir}/turn-NNNN.${ext}`,
+      habits,
+    ].join("\n")
+  }
+  return [
+    ...layout,
+    "It is indexed with qmd. Run qmd from inside that folder:",
+    `  cd ${ref.dir} && qmd query "a natural-language question"   # semantic + keyword, best when you don't know the exact words (5–20s)`,
+    `  cd ${ref.dir} && qmd search "exact words"                 # keyword only, instant`,
+    `  then Read ${ref.dir}/turn-NNNN.md (or qmd get turn-NNNN.md)`,
+    "If qmd isn't ready yet (the index builds in the background), grep the folder instead.",
+    habits,
+  ].join("\n")
+}

package/src/transcript/types.ts

@@ -0,0 +1,43 @@
+import type { SearchMode } from "../config/types"
+
+export type SessionEntry = Record<string, any>
+
+export type TranscriptFormat = "markdown" | "xml"
+
+export interface ToolPart {
+  kind: "tool"
+  n: number
+  name: string
+  call: string
+  body: string
+  output: string
+  error: boolean
+}
+
+export interface SayPart {
+  kind: "say"
+  text: string
+}
+
+export type TurnPart = SayPart | ToolPart
+
+export interface Turn {
+  number: number
+  time: string
+  prompt: string
+  parts: TurnPart[]
+  final: string
+  calls: number
+}
+
+export interface RenderResult {
+  dir: string
+  changed: boolean
+  turns: number
+}
+
+export interface TranscriptRef {
+  mode: SearchMode
+  jsonl: string
+  dir: string
+}

package/src/version.ts

@@ -0,0 +1,3 @@
+import pkg from "../package.json"
+
+export const VERSION: string = pkg.version