@chroxify/eunoe 1.0.0 → 1.2.0

package/src/cli/sessions.ts

@@ -1,25 +0,0 @@
-import { SESSION_ID_PATTERN } from "../config/constants"
-import { seenSessions } from "../proxy/sessions"
-import { flagValues } from "./args"
-import { SHORT_ID_LENGTH } from "./constants"
-import { fail } from "./ui"
-
-export const shortId = (sessionId: string) => sessionId.slice(0, SHORT_ID_LENGTH)
-
-function resolve(input: string): string {
-  if (!SESSION_ID_PATTERN.test(input)) fail(`Not a session id: ${input}`)
-  const seen = seenSessions().map(([id]) => id)
-  if (seen.includes(input)) return input
-  const matches = seen.filter((id) => id.startsWith(input))
-  if (matches.length === 1) return matches[0]
-  if (matches.length > 1) fail(`${input} matches ${matches.length} sessions`, "Use more of the id.")
-  return input
-}
-
-export function sessionArgs(args: string[]): string[] {
-  return [...new Set(flagValues(args, "--session").map(resolve))]
-}
-
-export function isKnown(sessionId: string) {
-  return seenSessions().some(([id]) => id === sessionId)
-}

package/src/config/constants.ts

@@ -1,39 +0,0 @@
-import { homedir } from "node:os"
-import path from "node:path"
-import type { Config, Mode, Scope, SearchMode, Tunable } from "./types"
-
-export const EUNOE_DIR = process.env.EUNOE_DIR ?? path.join(homedir(), ".eunoe")
-
-export const paths = {
-  config: path.join(EUNOE_DIR, "config.json"),
-  requests: path.join(EUNOE_DIR, "requests.jsonl"),
-  threads: path.join(EUNOE_DIR, "threads"),
-  transcripts: path.join(EUNOE_DIR, "transcripts"),
-  models: path.join(EUNOE_DIR, "models.json"),
-  sessions: path.join(EUNOE_DIR, "sessions.json"),
-  proxyLog: path.join(EUNOE_DIR, "proxy.log"),
-  typesafeKey: path.join(EUNOE_DIR, "typesafe-key"),
-}
-
-export const RERANK_OFF = "off"
-
-export const DEFAULTS: Config = {
-  mode: "default",
-  scope: "all",
-  sessions: {},
-  port: 8788,
-  compactAt: 0.9,
-  keepTurns: "all",
-  keep: 3,
-  budget: 100_000,
-  search: "markdown",
-  rerank: "jev-preview",
-  upstream: "https://api.anthropic.com",
-  claudeConfigDirs: [],
-}
-
-export const MODES: Mode[] = ["default", "compact", "off"]
-export const SEARCH_MODES: SearchMode[] = ["jsonl", "markdown", "xml", "qmd"]
-export const TUNABLES: Tunable[] = ["keep", "budget", "compactAt", "keepTurns", "search", "rerank"]
-export const SCOPES: Scope[] = ["all", "sessions"]
-export const SESSION_ID_PATTERN = /^[a-zA-Z0-9-]+$/

package/src/config/types.ts

@@ -1,50 +0,0 @@
-export type Mode = "off" | "compact" | "default"
-export type SearchMode = "jsonl" | "markdown" | "xml" | "qmd"
-export type Scope = "all" | "sessions"
-
-export interface RollingConfig {
-  keep: number
-  budget: number
-}
-
-export interface RerankConfig {
-  model: string
-  candidates?: number
-}
-
-export interface EvalConfig {
-  strategy?: "tail" | "guide" | "trim"
-  rolling?: RollingConfig
-  tailTurns?: number
-  forceCut?: boolean
-  trustHeaders?: boolean
-  evidence?: boolean
-  recall?: boolean
-  rerank?: RerankConfig
-}
-
-export interface Tunables {
-  compactAt: number
-  keepTurns: number | "all"
-  keep: number
-  budget: number
-  search: SearchMode
-  rerank: string
-}
-
-export type Tunable = keyof Tunables
-
-export interface SessionSettings extends Partial<Tunables> {
-  mode?: Mode
-}
-
-export interface Config extends Tunables {
-  mode: Mode
-  scope: Scope
-  sessions: Record<string, SessionSettings>
-  port: number
-  upstream: string
-  claudeConfigDirs: string[]
-  window?: number
-  eval?: EvalConfig
-}

package/src/context/constants.ts

@@ -1,42 +0,0 @@
-export const SUMMARY_COMMAND_CHARS = 100
-export const SUMMARY_ARGUMENT_CHARS = 60
-export const SUMMARY_LAST_WORDS_CHARS = 600
-export const SUMMARY_CALLS_SHOWN = 20
-
-export const CLEARED_INPUT_THRESHOLD = 2_000
-export const CLEARED_INPUT_KEPT = 500
-
-export const REMINDER_ONLY = /^\s*(?:<system-reminder>[\s\S]*?<\/system-reminder>\s*)+$/
-
-export const REREADABLE_TOOLS = new Set(["Read", "Grep", "Glob", "LS", "NotebookRead", "WebFetch", "WebSearch", "TodoWrite", "Edit", "Write", "MultiEdit", "NotebookEdit"])
-export const EVIDENCE_LINES_PER_CALL = 12
-export const EVIDENCE_LINE_CHARS = 220
-export const EVIDENCE_TURN_CHARS = 4_000
-export const EVIDENCE_SCAN_LINES = 1_000_000
-export const EVIDENCE_MIN_SCORE = 2
-export const EVIDENCE_RANKED = true
-export const EVIDENCE_LABELS = true
-export const EVIDENCE_CALL_FLOOR = 2
-export const ERROR_LINE = /\b(?:error|errors|fail|fails|failed|failure|fatal|exception|panic|denied|refused|timed? ?out|traceback|cannot|unable to)\b/i
-export const ERROR_CODE = /\b[A-Z][A-Z0-9]*_[A-Z0-9_]{2,}\b|\bSIG[A-Z]{2,}\d*\b|\b[A-Z]{2,}\d{2,}\b|\bE(?:NOENT|ACCES|PERM|EXIST|CONN(?:REFUSED|RESET|ABORTED)|PIPE|ADDRINUSE|TIMEDOUT|NOTFOUND|INVAL|BUSY|MFILE|AGAIN|HOSTUNREACH|NOTDIR|ISDIR|BADF|NOSPC|AI_[A-Z]+)\b/
-export const VALUE_TOKEN = /\b[a-z]{2,}[_-](?=[a-z0-9]*\d)[a-z0-9]{6,}\b|\b(?=[0-9a-f]*\d)(?=[0-9a-f]*[a-f])[0-9a-f]{7,}\b|https?:\/\/[^\s)"']+|\b\d{4,}\b|\b\d{6,}_[a-z0-9_]{3,}\b|\bv?\d+\.\d+\.\d+\b|\b\d+(?:\.\d+)?\s?(?:ms|s|[KMGT]i?B|kB|%)(?![a-z])|\bsha\d*:[0-9a-f]+|@[a-z][\w-]+|--[a-z][\w-]*=\S+|\b\d+ (?:pass(?:ed|ing)?|fail(?:ed|ing)?|tests?|files? changed|insertions?|deletions?|rows?|errors?|warnings?)\b|[$€£]\d+(?:[.,]\d+)?|\b(?:status|HTTP\/\d(?:\.\d)?)\s*[:=]?\s*[45]\d{2}\b|\bexit(?: code| status)?\s*[:=]?\s*(?!0\b)\d{1,3}\b/i
-export const ID_TOKEN = /\b[a-z]{2,}[_-](?=[a-z0-9]*\d)[a-z0-9]{6,}\b|\b(?=[0-9a-f]*\d)(?=[0-9a-f]*[a-f])[0-9a-f]{7,}\b|https?:\/\/[^\s)"']+|\b\d{6,}_[a-z0-9_]{3,}\b|\bv?\d+\.\d+\.\d+\b|\bsha\d*:[0-9a-f]+|@[a-z][\w-]+|--[a-z][\w-]*=\S+/i
-export const KEY_VALUE =/^[\w .\-/()]{2,48}[:=]\s*\S/
-export const VALUE_LABEL = /\b(?:ids?|hash|sha(?:256)?|checksum|trace|deploy(?:ment)?|preview|url|version|rows|p9[59]|exit(?: code)?|signal|request[_-]?id|job|migration|applied|bundle|build|status|took|updated|created)\b/i
-
-export const RECALL_WINDOW_LINES = 6
-export const RECALL_SHOWN_LINES = 8
-export const RECALL_PER_QUERY = 12
-export const RECALL_MAX_CHARS = 18_000
-export const RECALL_MAX_CHARS_MULTI = 30_000
-export const RECALL_MIN_TERMS = 2
-export const RECALL_SALIENT_EXCERPT = true
-export const RECALL_NARRATIVE = true
-export const RECALL_LINE_CHARS = 240
-export const RECALL_RERANK_CANDIDATES = 30
-export const RERANK_ENDPOINT = "https://api.typesafe.ai/v1/systemone"
-export const RERANK_TIMEOUT_MS = 4_000
-export const RERANK_LINE_CHARS = 240
-export const BM25_K1 = 1.2
-export const BM25_B = 0.75
-export const STOPWORDS = new Set("the and for with that this what which when where who how was were did does done from into onto have has had you your our out not but are can could would should will just then than them they there their its it's about after before again also any each other some such only own same very more most over under while because been being into".split(" "))

package/src/context/evidence.ts

@@ -1,92 +0,0 @@
-import { ERROR_CODE, ERROR_LINE, EVIDENCE_CALL_FLOOR, EVIDENCE_LABELS, EVIDENCE_LINE_CHARS, EVIDENCE_LINES_PER_CALL, EVIDENCE_MIN_SCORE, EVIDENCE_RANKED, EVIDENCE_SCAN_LINES, EVIDENCE_TURN_CHARS, ID_TOKEN, KEY_VALUE, REREADABLE_TOOLS, VALUE_LABEL, VALUE_TOKEN } from "./constants"
-import { blocks, clip, describeToolCall, resultText } from "./content"
-import type { Block, EvidenceOptions, Message } from "./types"
-
-interface Scored {
-  index: number
-  line: string
-  score: number
-}
-
-export function isSalient(line: string): boolean {
-  return ERROR_LINE.test(line) || ERROR_CODE.test(line) || VALUE_TOKEN.test(line)
-}
-
-function scoreLines(text: string, options: EvidenceOptions): Scored[] {
-  const scan = options.scanLines ?? EVIDENCE_SCAN_LINES
-  const lineChars = options.lineChars ?? EVIDENCE_LINE_CHARS
-  const minScore = options.minScore ?? EVIDENCE_MIN_SCORE
-  const scored = text.split("\n").slice(0, scan).flatMap((raw, index) => {
-    const line = raw.trim()
-    if (line.length < 4) return []
-    const error = ERROR_LINE.test(line) || ERROR_CODE.test(line)
-    const value = VALUE_TOKEN.test(line)
-    if (!error && !value) return []
-    const score = (error ? 3 : 0) + (value ? (ID_TOKEN.test(line) ? 3 : 2) : 0) + (KEY_VALUE.test(line) ? 1 : 0) + (line.length < 120 ? 1 : 0) + ((options.labels ?? EVIDENCE_LABELS) && VALUE_LABEL.test(line) ? 1 : 0)
-    return score >= minScore ? [{ index, line: clip(line, lineChars), score }] : []
-  })
-  const seen = new Set<string>()
-  return scored.sort((a, b) => b.score - a.score || a.index - b.index).filter((s) => !seen.has(s.line) && seen.add(s.line))
-}
-
-export function salientLines(text: string, options: EvidenceOptions = {}): string[] {
-  return scoreLines(text, options)
-    .slice(0, options.linesPerCall ?? EVIDENCE_LINES_PER_CALL)
-    .sort((a, b) => a.index - b.index)
-    .map((s) => s.line)
-}
-
-export function toolPairs(turn: Message[]): Array<{ call: Block; result: Block }> {
-  const results = new Map<string, Block>()
-  for (const message of turn) {
-    if (message.role !== "user") continue
-    for (const block of blocks(message)) if (block.type === "tool_result") results.set(block.tool_use_id, block)
-  }
-  return turn
-    .filter((m) => m.role === "assistant")
-    .flatMap((m) => blocks(m).filter((b) => b.type === "tool_use"))
-    .flatMap((call) => (results.has(call.id) ? [{ call, result: results.get(call.id)! }] : []))
-}
-
-function render(entries: Array<{ head: string; lines: string[] }>): string | null {
-  const body = entries.filter((e) => e.lines.length).map((e) => `- ${e.head}:\n${e.lines.map((l) => `    ${l}`).join("\n")}`)
-  return body.length ? `<tool-evidence>\nKey lines of command output from this turn, kept verbatim (the full output is in the transcript):\n${body.join("\n")}\n</tool-evidence>` : null
-}
-
-export function turnEvidence(turn: Message[], options: EvidenceOptions = {}): string | null {
-  const turnChars = options.turnChars ?? EVIDENCE_TURN_CHARS
-  const perCall = options.linesPerCall ?? EVIDENCE_LINES_PER_CALL
-  const pairs = toolPairs(turn).filter(({ call }) => options.allTools || !REREADABLE_TOOLS.has(call.name))
-  const heads = pairs.map(({ call, result }) => `${describeToolCall(call)}${result.is_error ? " (failed)" : ""}`)
-  if (!(options.ranked ?? EVIDENCE_RANKED)) {
-    const entries: Array<{ head: string; lines: string[] }> = []
-    let used = 0
-    pairs.forEach(({ result }, i) => {
-      const lines = salientLines(resultText(result), options)
-      if (!lines.length) return
-      const size = heads[i].length + 4 + lines.reduce((s, l) => s + l.length + 5, 0)
-      if (used + size > turnChars) return
-      entries.push({ head: heads[i], lines })
-      used += size
-    })
-    return render(entries)
-  }
-  const floor = options.callFloor ?? EVIDENCE_CALL_FLOOR
-  const perCallLines = pairs.map(({ result }) => scoreLines(resultText(result), options))
-  const chosen = new Map<number, Scored[]>()
-  let used = 0
-  const take = (call: number, line: Scored) => {
-    const bucket = chosen.get(call) ?? []
-    const cost = line.line.length + 5 + (bucket.length ? 0 : heads[call].length + 4)
-    if (bucket.length >= perCall || used + cost > turnChars) return
-    bucket.push(line)
-    chosen.set(call, bucket)
-    used += cost
-  }
-  perCallLines.forEach((lines, call) => lines.slice(0, floor).forEach((line) => take(call, line)))
-  perCallLines
-    .flatMap((lines, call) => lines.slice(floor).map((line) => ({ line, call })))
-    .sort((a, b) => b.line.score - a.line.score || a.call - b.call || a.line.index - b.line.index)
-    .forEach(({ line, call }) => take(call, line))
-  return render(heads.map((head, i) => ({ head, lines: (chosen.get(i) ?? []).sort((a, b) => a.index - b.index).map((s) => s.line) })))
-}

package/src/context/recall.ts

@@ -1,155 +0,0 @@
-import { BM25_B, BM25_K1, RECALL_LINE_CHARS, RECALL_MAX_CHARS, RECALL_MAX_CHARS_MULTI, RECALL_MIN_TERMS, RECALL_NARRATIVE, RECALL_PER_QUERY, RECALL_RERANK_CANDIDATES, RECALL_SALIENT_EXCERPT, RECALL_SHOWN_LINES, RECALL_WINDOW_LINES, STOPWORDS } from "./constants"
-import { blocks, clip, describeToolCall, resultText } from "./content"
-import { isSalient, toolPairs } from "./evidence"
-import { isPrompt, splitTurns } from "./turns"
-import type { Message, RecallChunk, RecallOptions, RecallPick, Reranker } from "./types"
-
-const REMINDERS = /<(system-reminder|system-message|recalled-context|tool-evidence)>[\s\S]*?<\/\1>/g
-
-export function terms(text: string): string[] {
-  return (text.toLowerCase().match(/[a-z0-9_@$][a-z0-9_.:/@$-]*[a-z0-9_]|[a-z0-9]/g) ?? [])
-    .flatMap((term) => (/[._:/-]/.test(term) ? [term, ...term.split(/[._:/-]+/)] : [term]))
-    .filter((term) => term.length >= 3 && !STOPWORDS.has(term))
-}
-
-function promptText(message: Message): string {
-  return blocks(message).filter((b) => b.type === "text").map((b) => String(b.text ?? "")).join("\n").replace(REMINDERS, "").trim()
-}
-
-function windows(lines: string[], size: number): string[][] {
-  const out: string[][] = []
-  for (let start = 0; start < lines.length; start += size) out.push(lines.slice(start, start + size))
-  return out
-}
-
-export function recallChunks(messages: Message[], keptIds: Map<string, string>, options: RecallOptions = {}): RecallChunk[] {
-  const { turns } = splitTurns(messages)
-  const size = options.windowLines ?? RECALL_WINDOW_LINES
-  const weight = Math.max(1, options.callWeight ?? 1)
-  const chunks: RecallChunk[] = []
-  turns.slice(0, -1).forEach((turn, turnIndex) => {
-    for (const { call, result } of toolPairs(turn)) {
-      const text = resultText(result)
-      if (keptIds.get(call.id) === text || !text.trim()) continue
-      const head = describeToolCall(call)
-      const headTerms = Array.from({ length: weight }, () => terms(head)).flat()
-      for (const window of windows(text.split("\n"), size)) {
-        chunks.push({ turn: turnIndex + 1, call: head, lines: window, terms: [...headTerms, ...terms(window.join("\n"))] })
-      }
-    }
-    if (!(options.narrative ?? RECALL_NARRATIVE)) return
-    const said = turn.slice(1, -1).filter((m) => m.role === "assistant").flatMap((m) => blocks(m).filter((b) => b.type === "text").map((b) => String(b.text ?? "").trim())).filter(Boolean)
-    for (const window of windows(said.join("\n").split("\n"), size)) {
-      chunks.push({ turn: turnIndex + 1, call: "agent", lines: window, terms: terms(window.join("\n")) })
-    }
-  })
-  return chunks
-}
-
-export function rank(query: string[], chunks: RecallChunk[], minTerms = RECALL_MIN_TERMS) {
-  const df = new Map<string, number>()
-  for (const chunk of chunks) for (const term of new Set(chunk.terms)) df.set(term, (df.get(term) ?? 0) + 1)
-  const average = chunks.reduce((s, c) => s + c.terms.length, 0) / Math.max(1, chunks.length)
-  const wanted = [...new Set(query)].filter((t) => df.has(t))
-  return chunks.map((chunk, index) => {
-    const tf = new Map<string, number>()
-    for (const term of chunk.terms) tf.set(term, (tf.get(term) ?? 0) + 1)
-    let score = 0
-    let matched = 0
-    for (const term of wanted) {
-      const f = tf.get(term) ?? 0
-      if (!f) continue
-      matched += 1
-      const idf = Math.log(1 + (chunks.length - df.get(term)! + 0.5) / (df.get(term)! + 0.5))
-      score += idf * (f * (BM25_K1 + 1)) / (f + BM25_K1 * (1 - BM25_B + BM25_B * chunk.terms.length / average))
-    }
-    return { index, score, matched }
-  }).filter((r) => r.matched >= Math.min(minTerms, wanted.length) && r.score > 0).sort((a, b) => b.score - a.score)
-}
-
-function excerpt(chunk: RecallChunk, query: Set<string>, salient: boolean): string[] {
-  const hits = chunk.lines.map((line, i) => (terms(line).some((t) => query.has(t)) ? i : -1)).filter((i) => i >= 0)
-  const shown = new Set<number>()
-  for (const i of hits) for (const j of [i - 1, i, i + 1]) if (j >= 0 && j < chunk.lines.length) shown.add(j)
-  if (salient) for (let i = 0; i < chunk.lines.length && shown.size < RECALL_SHOWN_LINES + 2; i += 1) if (isSalient(chunk.lines[i])) shown.add(i)
-  const ordered = [...shown].sort((a, b) => a - b).slice(0, salient ? RECALL_SHOWN_LINES + 2 : RECALL_SHOWN_LINES)
-  return (ordered.length ? ordered : [0]).map((i) => clip(chunk.lines[i], RECALL_LINE_CHARS)).filter(Boolean)
-}
-
-export function queriesOf(prompt: string): string[] {
-  const lines = prompt.split("\n").map((l) => l.trim()).filter((l) => terms(l).length >= 2)
-  return lines.length > 1 ? lines : [prompt]
-}
-
-export function pickRecall(prompt: string, chunks: RecallChunk[], options: RecallOptions = {}): RecallPick[] {
-  const perQuery = options.perQuery ?? RECALL_PER_QUERY
-  const picked = new Map<number, Set<string>>()
-  for (const query of queriesOf(prompt)) {
-    const q = terms(query)
-    for (const hit of rank(q, chunks, options.minTerms).slice(0, perQuery)) {
-      if (!picked.has(hit.index)) picked.set(hit.index, new Set())
-      for (const t of q) picked.get(hit.index)!.add(t)
-    }
-  }
-  return [...picked.entries()].map(([index, query]) => ({ index, query }))
-}
-
-export async function pickRecallWith(prompt: string, chunks: RecallChunk[], rerank: Reranker, options: RecallOptions = {}): Promise<RecallPick[]> {
-  const perQuery = options.perQuery ?? RECALL_PER_QUERY
-  const width = options.candidates ?? RECALL_RERANK_CANDIDATES
-  const picked = new Map<number, Set<string>>()
-  for (const query of queriesOf(prompt)) {
-    const q = terms(query)
-    const candidates = rank(q, chunks, options.minTerms).slice(0, width).map((hit) => hit.index)
-    for (const index of (await rerank(query, chunks, candidates)).slice(0, perQuery)) {
-      if (!picked.has(index)) picked.set(index, new Set())
-      for (const t of q) picked.get(index)!.add(t)
-    }
-  }
-  return [...picked.entries()].map(([index, query]) => ({ index, query }))
-}
-
-export function renderRecall(prompt: string, chunks: RecallChunk[], picks: RecallPick[], options: RecallOptions = {}): string | null {
-  if (!picks.length) return null
-  const budget = queriesOf(prompt).length > 1 ? options.maxCharsMulti ?? RECALL_MAX_CHARS_MULTI : options.maxChars ?? RECALL_MAX_CHARS
-  const entries: string[] = []
-  let used = 0
-  for (const pick of [...picks].sort((a, b) => chunks[a.index].turn - chunks[b.index].turn || a.index - b.index)) {
-    const chunk = chunks[pick.index]
-    const entry = `[turn ${chunk.turn}] ${chunk.call}:\n${excerpt(chunk, pick.query, options.salientExcerpt ?? RECALL_SALIENT_EXCERPT).map((l) => `    ${l}`).join("\n")}`
-    if (used + entry.length > budget) continue
-    entries.push(entry)
-    used += entry.length
-  }
-  return entries.length
-    ? `<recalled-context>\nExcerpts from earlier in this session that match this message: tool output that is no longer in your context, quoted exactly, oldest first. Where the same thing appears twice, the later turn is current. Use them if they answer what was asked; ignore them otherwise.\n\n${entries.join("\n")}\n</recalled-context>`
-    : null
-}
-
-export function recallFor(prompt: string, chunks: RecallChunk[], options: RecallOptions = {}): string | null {
-  if (!chunks.length) return null
-  return renderRecall(prompt, chunks, pickRecall(prompt, chunks, options), options)
-}
-
-export async function recallForWith(prompt: string, chunks: RecallChunk[], rerank: Reranker, options: RecallOptions = {}): Promise<string | null> {
-  if (!chunks.length) return null
-  return renderRecall(prompt, chunks, await pickRecallWith(prompt, chunks, rerank, options), options)
-}
-
-export function livePrompt(messages: Message[]): { index: number; text: string } | null {
-  const { preamble, turns } = splitTurns(messages)
-  if (turns.length < 2) return null
-  const first = turns.at(-1)![0]
-  if (!isPrompt(first)) return null
-  const index = preamble.length + turns.slice(0, -1).reduce((s, t) => s + t.length, 0)
-  return { index, text: promptText(first) }
-}
-
-export function withRecall(messages: Message[], fingerprint: (message: Message) => string, recalls: Record<string, string>): Message[] {
-  if (!Object.keys(recalls).length) return messages
-  return messages.map((message) => {
-    if (!isPrompt(message)) return message
-    const text = recalls[fingerprint(message)]
-    return text ? { ...message, content: [...blocks(message), { type: "text", text }] } : message
-  })
-}

package/src/context/rerank.ts

@@ -1,44 +0,0 @@
-import { existsSync, readFileSync } from "node:fs"
-import { paths } from "../config/constants"
-import { RERANK_ENDPOINT, RERANK_LINE_CHARS, RERANK_TIMEOUT_MS } from "./constants"
-import type { RecallChunk, Reranker } from "./types"
-
-export function rerankKey(): string | null {
-  const env = process.env.TYPESAFE_API_KEY?.trim()
-  if (env) return env
-  return existsSync(paths.typesafeKey) ? readFileSync(paths.typesafeKey, "utf8").trim() : null
-}
-
-export function rerankState(chunks: RecallChunk[], candidates: number[]): string {
-  return candidates.map((index, n) => `### ${n}\n[turn ${chunks[index].turn}] ${chunks[index].call}\n${chunks[index].lines.map((l) => l.slice(0, RERANK_LINE_CHARS)).join("\n")}`).join("\n\n")
-}
-
-export function orderByProbability(candidates: number[], probabilities: Record<string, number>): number[] {
-  return candidates.map((_, n) => n).sort((a, b) => (probabilities[String(b)] ?? 0) - (probabilities[String(a)] ?? 0) || a - b).map((n) => candidates[n])
-}
-
-export function jevReranker(model: string, key: string, endpoint = RERANK_ENDPOINT): Reranker {
-  return async (query, chunks, candidates) => {
-    if (candidates.length < 2) return candidates
-    try {
-      const response = await fetch(endpoint, {
-        method: "POST",
-        headers: { authorization: `Bearer ${key}`, "content-type": "application/json" },
-        signal: AbortSignal.timeout(RERANK_TIMEOUT_MS),
-        body: JSON.stringify({
-          model,
-          state: rerankState(chunks, candidates),
-          questions: {
-            where: { type: "choice", instructions: `Which excerpt contains the exact answer to the developer's question about this coding session: "${query}"?`, criteria: Object.fromEntries(candidates.map((_, n) => [String(n), null])) },
-          },
-        }),
-      })
-      if (!response.ok) return candidates
-      const json: any = await response.json()
-      const probabilities = json?.answers?.where?.probabilities
-      return probabilities && typeof probabilities === "object" ? orderByProbability(candidates, probabilities) : candidates
-    } catch {
-      return candidates
-    }
-  }
-}

package/src/context/strategies.ts

@@ -1,89 +0,0 @@
-import { CLEARED_INPUT_KEPT, CLEARED_INPUT_THRESHOLD } from "./constants"
-import { blocks, truncate, withoutCacheControl } from "./content"
-import { compactionNotice, truncationNotice } from "./prompts"
-import { hasContent, isHarness, reduceTurn, splitTurns } from "./turns"
-import type { Block, Body, CompactOptions, Message, ReduceOptions } from "./types"
-
-export function trimMessages(messages: Message[], options: ReduceOptions = {}): Message[] {
-  const { preamble, turns } = splitTurns(messages)
-  if (turns.length < 2) return messages
-  return [...preamble, ...turns.slice(0, -1).flatMap((turn) => reduceTurn(turn, options)), ...turns.at(-1)!]
-}
-
-export function compactMessages(
-  messages: Message[],
-  cutIndex: number,
-  options: CompactOptions,
-): Message[] {
-  const { preamble, turns } = splitTurns(messages)
-  if (cutIndex <= 0 || cutIndex >= turns.length) return messages
-  const keptFrom = Math.max(1, cutIndex - options.keepTurns)
-  const notice = compactionNotice({ omitted: keptFrom - 1 + (options.omittedBefore ?? 0), kept: cutIndex - keptFrom, guide: options.guide })
-  const removed = [...turns[0].slice(1), ...turns.slice(1, keptFrom).flat()]
-  const carried = removed
-    .filter((m) => isHarness(m) && hasContent(m))
-    .flatMap((m) => blocks(m).filter((b) => b.type === "text"))
-    .map((b) => ({ type: "text", text: `<system-reminder>\n${b.text}\n</system-reminder>` }))
-  return [
-    ...preamble,
-    turns[0][0],
-    { role: "user", content: [{ type: "text", text: notice }, ...carried] },
-    ...turns.slice(keptFrom, cutIndex).flatMap((turn) => reduceTurn(turn, options)),
-    ...turns.slice(cutIndex).flat(),
-  ]
-}
-
-export function tailMessages(messages: Message[], from: number, guide: string | null): Message[] {
-  const { preamble, turns } = splitTurns(messages)
-  if (turns.length === 0 || from <= 1) return messages
-  const notice = truncationNotice({ omitted: from - 1, kept: turns.length - from, guide })
-  return [
-    ...preamble,
-    turns[0][0],
-    { role: "user", content: [{ type: "text", text: notice }] },
-    ...turns.slice(from).flat(),
-  ]
-}
-
-export function countToolResults(messages: Message[], from: number): number {
-  return messages.slice(from).reduce((total, m) => total + (m.role === "user" ? blocks(m).filter((b) => b.type === "tool_result").length : 0), 0)
-}
-
-export function clearToolResults(messages: Message[], from: number, count: number, placeholder: string): Message[] {
-  let left = count
-  const cleared = new Set<string>()
-  const results = messages.map((message, index) => {
-    if (left <= 0 || index < from || message.role !== "user" || typeof message.content === "string") return message
-    if (!message.content.some((b) => b.type === "tool_result")) return message
-    return {
-      ...message,
-      content: message.content.map((b) => {
-        if (b.type !== "tool_result" || left <= 0) return b
-        left -= 1
-        cleared.add(b.tool_use_id)
-        return { type: "tool_result", tool_use_id: b.tool_use_id, ...(b.is_error ? { is_error: true } : {}), content: placeholder }
-      }),
-    }
-  })
-  return results.map((message) => {
-    if (message.role !== "assistant" || typeof message.content === "string") return message
-    if (!message.content.some((b) => b.type === "tool_use" && cleared.has(b.id))) return message
-    return { ...message, content: message.content.map((b) => (b.type === "tool_use" && cleared.has(b.id) ? { ...b, input: shortenInput(b.input) } : b)) }
-  })
-}
-
-function shortenInput(input: unknown): unknown {
-  if (typeof input === "string") return input.length > CLEARED_INPUT_THRESHOLD ? `${truncate(input, CLEARED_INPUT_KEPT)}… [${input.length - CLEARED_INPUT_KEPT} chars cleared; in the transcript]` : input
-  if (Array.isArray(input)) return input.map(shortenInput)
-  if (input && typeof input === "object") return Object.fromEntries(Object.entries(input).map(([k, v]) => [k, shortenInput(v)]))
-  return input
-}
-
-export function appendSystem(system: Body["system"], text: string): Block[] {
-  const list: Block[] = typeof system === "string" ? [{ type: "text", text: system }] : [...(system ?? [])]
-  const lastCached = list.findLastIndex((b) => b.cache_control)
-  const cacheControl = lastCached >= 0 ? list[lastCached].cache_control : undefined
-  if (lastCached >= 0) list[lastCached] = withoutCacheControl(list[lastCached])
-  list.push({ type: "text", text, ...(cacheControl ? { cache_control: cacheControl } : {}) })
-  return list
-}

package/src/context/turns.ts

@@ -1,87 +0,0 @@
-import { REMINDER_ONLY, SUMMARY_CALLS_SHOWN, SUMMARY_LAST_WORDS_CHARS } from "./constants"
-import { blocks, clean, describeToolCall, truncate, withoutCacheControl } from "./content"
-import { turnEvidence } from "./evidence"
-import type { Block, Message, ReduceOptions } from "./types"
-
-export function isPrompt(message: Message) {
-  if (message.role !== "user") return false
-  const content = blocks(message)
-  return !content.some((block) => block.type === "tool_result")
-    && content.some((block) => block.type === "text" || block.type === "image" || block.type === "document")
-}
-
-export function splitTurns(messages: Message[]): { preamble: Message[]; turns: Message[][] } {
-  const preamble: Message[] = []
-  const turns: Message[][] = []
-  for (const message of messages) {
-    if (isPrompt(message) && !(turns.length > 0 && turns.at(-1)!.every((m) => m.role === "user"))) {
-      turns.push([message])
-    } else if (turns.length > 0) {
-      turns.at(-1)!.push(message)
-    } else {
-      preamble.push(message)
-    }
-  }
-  return { preamble, turns }
-}
-
-export function turnFingerprint(turn: Message[]): string {
-  const hasher = new Bun.CryptoHasher("sha256")
-  hasher.update(JSON.stringify(blocks(turn[0]).map(withoutCacheControl)))
-  return hasher.digest("hex").slice(0, 24)
-}
-
-export function isHarness(message: Message) {
-  return message.role === "system"
-}
-
-export function hasContent(message: Message) {
-  return blocks(message).some((block) => block.type !== "text" || String(block.text ?? "").trim())
-}
-
-function mergedHarness(turn: Message[]): Message[] {
-  const content = turn.filter((m) => isHarness(m) && hasContent(m)).flatMap((m) => blocks(m).map(withoutCacheControl))
-  return content.length > 0 ? [{ role: "system", content }] : []
-}
-
-function interruptedSummary(turn: Message[]): string {
-  const assistant = turn.filter((m) => m.role === "assistant")
-  const lastWords = [...assistant].reverse()
-    .map((m) => blocks(m).filter((b) => b.type === "text").map((b) => String(b.text ?? "")).join("\n").trim())
-    .find(Boolean)
-  const calls = assistant.flatMap((m) => blocks(m).filter((b) => b.type === "tool_use")).map(describeToolCall)
-  const shown = calls.slice(-SUMMARY_CALLS_SHOWN)
-  return [
-    "[This turn was interrupted before a final reply.]",
-    lastWords ? `Last thing you said: ${lastWords.length > SUMMARY_LAST_WORDS_CHARS ? `${truncate(lastWords, SUMMARY_LAST_WORDS_CHARS)}…` : lastWords}` : "",
-    calls.length > 0 ? `Tool calls (${calls.length}${calls.length > shown.length ? `, last ${shown.length} shown` : ""}): ${shown.join("; ")}` : "",
-    "Their output is in the full transcript.",
-  ].filter(Boolean).join("\n")
-}
-
-function carriedText(messages: Message[]): Block[] {
-  return messages
-    .filter((m) => m.role === "user")
-    .flatMap((m) => blocks(m).filter((b) => b.type === "text" && String(b.text ?? "").trim() && !REMINDER_ONLY.test(String(b.text))))
-    .map((b) => ({ type: "text", text: b.text }))
-}
-
-export function reduceTurn(turn: Message[], options: ReduceOptions = {}): Message[] {
-  const opening: Message[] = []
-  let i = 0
-  for (; i < turn.length && turn[i].role !== "assistant"; i += 1) {
-    if (turn[i].role === "user") opening.push(clean(turn[i]))
-  }
-  const carried = carriedText(turn.slice(i))
-  if (carried.length > 0) opening.push({ role: "user", content: carried })
-  const evidence = options.evidence ? turnEvidence(turn) : null
-  if (evidence) opening.push({ role: "user", content: [{ type: "text", text: evidence }] })
-  opening.push(...mergedHarness(turn))
-  const last = [...turn].reverse().find((m) => m.role !== "system")!
-  const content = last.role === "assistant" ? blocks(last) : []
-  const text = content.filter((b) => b.type === "text" && String(b.text ?? "").trim())
-  const final = text.length > 0 && !content.some((b) => b.type === "tool_use")
-    ? text.map((b) => ({ type: "text", text: b.text }))
-    : [{ type: "text", text: interruptedSummary(turn) }]
-  return [...opening, { role: "assistant", content: final }]
-}