@chroxify/eunoe 0.1.0 → 1.1.0

package/src/config/types.ts

@@ -1,21 +0,0 @@
-export type Mode = "off" | "trim" | "compact"
-export type SearchMode = "jsonl" | "markdown" | "xml" | "qmd"
-
-export interface EvalConfig {
-  strategy?: "tail" | "guide"
-  tailTurns?: number
-  forceCut?: boolean
-  trustHeaders?: boolean
-}
-
-export interface Config {
-  mode: Mode
-  port: number
-  compactAt: number
-  keepTurns: number | "all"
-  search: SearchMode
-  upstream: string
-  claudeConfigDirs: string[]
-  window?: number
-  eval?: EvalConfig
-}

package/src/context/constants.ts

@@ -1,7 +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

package/src/context/strategies.ts

@@ -1,89 +0,0 @@
-import { CLEARED_INPUT_KEPT, CLEARED_INPUT_THRESHOLD } from "./constants"
-import { blocks, withoutCacheControl } from "./content"
-import { compactionNotice, truncationNotice } from "./prompts"
-import { hasContent, isHarness, reduceTurn, splitTurns } from "./turns"
-import type { Block, Body, CompactOptions, Message } from "./types"
-
-export function trimMessages(messages: Message[]): Message[] {
-  const { preamble, turns } = splitTurns(messages)
-  if (turns.length < 2) return messages
-  return [...preamble, ...turns.slice(0, -1).flatMap(reduceTurn), ...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(reduceTurn),
-    ...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 ? `${input.slice(0, 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,82 +0,0 @@
-import { SUMMARY_ARGUMENT_CHARS, SUMMARY_CALLS_SHOWN, SUMMARY_COMMAND_CHARS, SUMMARY_LAST_WORDS_CHARS } from "./constants"
-import { blocks, clean, clip, withoutCacheControl } from "./content"
-import type { Block, Message } 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 describeToolCall(block: Block): string {
-  const input = block.input ?? {}
-  if (typeof input.command === "string") return `${block.name} \`${clip(input.command, SUMMARY_COMMAND_CHARS)}\``
-  if (typeof input.file_path === "string") return `${block.name} ${input.file_path}`
-  if (typeof input.pattern === "string") return `${block.name} "${clip(input.pattern, SUMMARY_ARGUMENT_CHARS)}"`
-  return `${block.name} ${clip(JSON.stringify(input), SUMMARY_ARGUMENT_CHARS)}`
-}
-
-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 ? `${lastWords.slice(0, 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")
-}
-
-export function reduceTurn(turn: Message[]): Message[] {
-  const opening: Message[] = []
-  for (let i = 0; i < turn.length && turn[i].role !== "assistant"; i += 1) {
-    if (turn[i].role === "user") opening.push(clean(turn[i]))
-  }
-  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 }]
-}

package/src/context/types.ts

@@ -1,24 +0,0 @@
-export type Block = { type: string; [key: string]: any }
-
-export type Message = { role: string; content: string | Block[] }
-
-export type Body = {
-  model?: string
-  system?: string | Block[]
-  messages: Message[]
-  tools?: unknown[]
-  metadata?: { user_id?: string }
-  [key: string]: any
-}
-
-export interface CompactOptions {
-  keepTurns: number
-  guide: string | null
-  omittedBefore?: number
-}
-
-export interface NoticeCounts {
-  omitted: number
-  kept: number
-  guide: string | null
-}

package/src/proxy/constants.ts

@@ -1,19 +0,0 @@
-export const HEALTH_PATH = "/_eunoe/health"
-export const SESSION_HEADER = "x-claude-code-session-id"
-export const TRANSCRIPT_HEADER = "x-eunoe-transcript"
-export const OMITTED_BEFORE_HEADER = "x-eunoe-omitted-before"
-
-export const TARGET_SHARE = 0.3
-export const PROTECTED_OUTPUTS = 5
-
-export const DEFAULT_RATIO = 1 / 3.6
-export const MEDIA_CHARS = 5_800
-export const MEDIA_MIN_LENGTH = 2_000
-
-export const MODEL_HEADERS = ["authorization", "x-api-key", "anthropic-version", "anthropic-beta"]
-export const ANTHROPIC_VERSION = "2023-06-01"
-export const MODEL_LOOKUP_TIMEOUT_MS = 5_000
-
-export const MAX_EVENT_BUFFER = 4_000_000
-export const LOGGED_ERROR_CHARS = 500
-export const IDLE_TIMEOUT_SECONDS = 255

package/src/proxy/types.ts

@@ -1,58 +0,0 @@
-import type { Config } from "../config/types"
-import type { Body, Message } from "../context/types"
-import type { TranscriptRef } from "../transcript/types"
-
-export interface ThreadState {
-  cut?: string
-  keep?: number
-  cleared?: number
-  ratio?: number
-}
-
-export type Note = Record<string, unknown>
-
-export interface RewriteInput {
-  body: Body
-  sessionId: string | null
-  config: Config
-  transcript: TranscriptRef | null
-  window: number | null
-  mayCompact: boolean
-  omittedBefore?: number
-}
-
-export interface Rewrite {
-  body: Body
-  threadKey: string | null
-  note: Note
-}
-
-export interface CompactInput {
-  body: Body
-  config: Config
-  state: ThreadState
-  window: number | null
-  guide: string | null
-  mayCompact: boolean
-  omittedBefore?: number
-}
-
-export interface CompactResult {
-  messages: Message[]
-  stateChanged: boolean
-  note: Note
-}
-
-export interface Estimator {
-  of: (messages: Message[]) => number
-  fixed: number
-}
-
-export type Usage = Record<string, number>
-
-export interface Health {
-  ok: boolean
-  version: string
-  mode: Config["mode"]
-  pid: number
-}

package/src/transcript/constants.ts

@@ -1,16 +0,0 @@
-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/types.ts

@@ -1,43 +0,0 @@
-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
-}