@chroxify/eunoe 0.0.0-stage → 1.0.0

package/src/cli/prompt.ts

@@ -0,0 +1,91 @@
+import { c, useColor } from "./ui"
+
+export interface Choice<T extends string = string> {
+  value: T
+  label?: string
+  hint?: string
+}
+
+export const interactive = Boolean(process.stdin.isTTY && process.stdout.isTTY)
+
+function keys(onKey: (key: string) => boolean | void): Promise<void> {
+  return new Promise((resolve) => {
+    const stdin = process.stdin
+    stdin.setRawMode(true)
+    stdin.resume()
+    stdin.setEncoding("utf8")
+    const handler = (chunk: string) => {
+      if (onKey(chunk) === true) {
+        stdin.off("data", handler)
+        stdin.setRawMode(false)
+        stdin.pause()
+        resolve()
+      }
+    }
+    stdin.on("data", handler)
+  })
+}
+
+function render(title: string, choices: Choice[], index: number, width: number) {
+  const lines = [`  ${c.bold(title)}`, ""]
+  for (const [i, choice] of choices.entries()) {
+    const label = (choice.label ?? choice.value).padEnd(width)
+    const marker = i === index ? c.green("●") : c.dim("○")
+    lines.push(`  ${marker} ${i === index ? c.bold(label) : label}${choice.hint ? `  ${c.dim(choice.hint)}` : ""}`)
+  }
+  lines.push("", `  ${c.dim("↑↓ move · enter choose · esc cancel")}`)
+  return lines
+}
+
+export async function select<T extends string>(title: string, choices: Choice<T>[], current?: T): Promise<T | null> {
+  let index = Math.max(0, choices.findIndex((choice) => choice.value === current))
+  const width = Math.max(...choices.map((choice) => (choice.label ?? choice.value).length))
+  let drawn = 0
+  const draw = () => {
+    const lines = render(title, choices, index, width)
+    if (drawn) process.stdout.write(`\x1b[${drawn}A\x1b[J`)
+    process.stdout.write(lines.join("\n") + "\n")
+    drawn = lines.length
+  }
+  let chosen: T | null = null
+  process.stdout.write(useColor ? "\x1b[?25l" : "")
+  draw()
+  await keys((key) => {
+    if (key === "\x1b[A" || key === "k") index = (index + choices.length - 1) % choices.length
+    else if (key === "\x1b[B" || key === "j") index = (index + 1) % choices.length
+    else if (key === "\r" || key === "\n") {
+      chosen = choices[index].value
+      return true
+    } else if (key === "\x1b" || key === "q" || key === "\x03") return true
+    draw()
+  })
+  process.stdout.write(`\x1b[${drawn}A\x1b[J`)
+  process.stdout.write(useColor ? "\x1b[?25h" : "")
+  return chosen
+}
+
+export async function input(title: string, placeholder: string, initial = ""): Promise<string | null> {
+  let value = initial
+  let drawn = 0
+  const draw = () => {
+    const shown = value ? value : c.dim(placeholder)
+    const lines = [`  ${c.bold(title)}`, `  ${c.cyan("›")} ${shown}`, "", `  ${c.dim("enter save · esc cancel")}`]
+    if (drawn) process.stdout.write(`\x1b[${drawn}A\x1b[J`)
+    process.stdout.write(lines.join("\n") + "\n")
+    drawn = lines.length
+  }
+  let result: string | null = null
+  draw()
+  await keys((key) => {
+    if (key === "\r" || key === "\n") {
+      result = value
+      return true
+    }
+    if (key === "\x1b" || key === "\x03") return true
+    if (key === "\x7f" || key === "\b") value = value.slice(0, -1)
+    else if (key >= " " && !key.startsWith("\x1b")) value += key
+    draw()
+  })
+  process.stdout.write(`\x1b[${drawn}A\x1b[J`)
+  return result
+}

package/src/cli/service.ts

@@ -0,0 +1,33 @@
+import path from "node:path"
+import { paths } from "../config/constants"
+import type { Config } from "../config/types"
+import { proxyUrl } from "./claude-settings"
+import { START_POLL_MS, START_TIMEOUT_MS } from "./constants"
+import { probe } from "./inspect"
+import * as launchd from "./launchd"
+import { c, line, ok, warn } from "./ui"
+
+async function waitForProxy(port: number) {
+  const deadline = Date.now() + START_TIMEOUT_MS
+  while (Date.now() < deadline) {
+    if (await probe(port)) return true
+    await Bun.sleep(START_POLL_MS)
+  }
+  return false
+}
+
+export async function startService(config: Config) {
+  if (!launchd.supported) {
+    if (await probe(config.port)) return true
+    warn("No launchd here, so keep the proxy running yourself:")
+    line(`    ${c.cyan("eunoe serve")}`)
+    return false
+  }
+  launchd.installAgent([process.execPath, path.join(import.meta.dir, "main.ts"), "serve"], paths.proxyLog)
+  if (await waitForProxy(config.port)) {
+    ok(`Proxy running in the background on ${c.cyan(proxyUrl(config.port))}`)
+    return true
+  }
+  warn(`The proxy didn't answer on ${proxyUrl(config.port)} yet. Check ${paths.proxyLog}.`)
+  return false
+}

package/src/cli/sessions.ts

@@ -0,0 +1,25 @@
+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/cli/stats.ts

@@ -0,0 +1,73 @@
+import { STATUS_WINDOW_MS } from "./constants"
+import type { RequestRecord } from "./types"
+
+export interface SessionStats {
+  context: number
+  plain: number | null
+  turns: number | null
+  requests: number
+  folds: number
+  lastSeen: string
+}
+
+export interface Totals {
+  requests: number
+  cacheRead: number
+  cacheWrite: number
+  uncached: number
+  folds: number
+  lastFold: string | null
+  sent: number
+  saved: number
+}
+
+const THREAD_SUFFIX = /-[0-9a-f]{24}$/
+
+export const sessionOf = (record: RequestRecord): string | null => (typeof record.thread === "string" ? record.thread.replace(THREAD_SUFFIX, "") : null)
+
+const plainTokens = (record: RequestRecord): number | null => (record.charsIn > 0 && record.charsOut > 0 && record.input > 0 ? Math.round(record.input * record.charsIn / record.charsOut) : null)
+
+export function withinWindow(records: RequestRecord[], now = Date.now(), window = STATUS_WINDOW_MS): RequestRecord[] {
+  return records.filter((record) => now - Date.parse(record.ts) <= window)
+}
+
+export function perSession(records: RequestRecord[]): Map<string, SessionStats> {
+  const stats = new Map<string, SessionStats>()
+  for (const record of records) {
+    const id = sessionOf(record)
+    if (!id || !(record.input > 0)) continue
+    const previous = stats.get(id)
+    stats.set(id, {
+      context: record.input,
+      plain: plainTokens(record),
+      turns: typeof record.turns === "number" ? record.turns : previous?.turns ?? null,
+      requests: (previous?.requests ?? 0) + 1,
+      folds: (previous?.folds ?? 0) + (record.compacted ? 1 : 0),
+      lastSeen: record.ts,
+    })
+  }
+  return stats
+}
+
+export function totals(records: RequestRecord[]): Totals {
+  const out: Totals = { requests: 0, cacheRead: 0, cacheWrite: 0, uncached: 0, folds: 0, lastFold: null, sent: 0, saved: 0 }
+  for (const record of records) {
+    if (!(record.input > 0)) continue
+    out.requests += 1
+    out.cacheRead += record.cacheRead ?? 0
+    out.cacheWrite += record.cacheWrite ?? 0
+    out.uncached += record.uncached ?? 0
+    if (record.compacted) {
+      out.folds += 1
+      out.lastFold = record.ts
+    }
+    const plain = plainTokens(record)
+    if (plain !== null) {
+      out.sent += record.input
+      out.saved += plain - record.input
+    }
+  }
+  return out
+}
+
+export const savedShare = (context: number, plain: number | null): number | null => (plain && plain > context ? 1 - context / plain : plain ? 0 : null)

package/src/cli/types.ts

@@ -0,0 +1,14 @@
+export type Settings = Record<string, any>
+
+export type OptionRow = [flag: string, description: string]
+
+export interface Command {
+  summary: string
+  usage: string
+  details?: string[]
+  options?: OptionRow[]
+  hidden?: boolean
+  run: (args: string[]) => void | Promise<void>
+}
+
+export type RequestRecord = Record<string, any>

package/src/cli/ui.ts

@@ -0,0 +1,106 @@
+import { homedir } from "node:os"
+import { TYPO_DISTANCE } from "./constants"
+
+const colorFor = (stream: NodeJS.WriteStream) => Boolean(stream.isTTY) && !process.env.NO_COLOR && process.env.TERM !== "dumb"
+export const useColor = colorFor(process.stdout)
+export const trueColor = /^(truecolor|24bit)$/i.test(process.env.COLORTERM ?? "")
+const useColorErr = colorFor(process.stderr)
+
+const paint = (open: number, close: number, enabled = useColor) => (text: string) => (enabled ? `\x1b[${open}m${text}\x1b[${close}m` : text)
+
+export const c = {
+  bold: paint(1, 22),
+  dim: paint(2, 22),
+  italic: paint(3, 23),
+  cyan: paint(36, 39),
+  green: paint(32, 39),
+  yellow: paint(33, 39),
+  red: paint(31, 39),
+  magenta: paint(35, 39),
+}
+
+const errRed = paint(31, 39, useColorErr)
+const errDim = paint(2, 22, useColorErr)
+
+export function line(text = "") {
+  console.log(text)
+}
+
+export function ok(text: string) {
+  console.log(`${c.green("✓")} ${text}`)
+}
+
+export function note(text: string) {
+  console.log(`${c.dim("·")} ${text}`)
+}
+
+export function warn(text: string) {
+  console.log(`${c.yellow("!")} ${text}`)
+}
+
+export function fail(text: string, hint?: string): never {
+  console.error(`${errRed("✗")} ${text}`)
+  if (hint) console.error(`  ${errDim(hint)}`)
+  process.exit(1)
+}
+
+export function listFiles(files: string[]) {
+  for (const file of files) line(`    ${c.dim(tilde(file))}`)
+}
+
+export function rows(entries: Array<[string, string]>, indent = 2) {
+  const width = Math.max(...entries.map(([label]) => label.length))
+  for (const [label, value] of entries) console.log(`${" ".repeat(indent)}${c.dim(label.padEnd(width))}  ${value}`)
+}
+
+const visible = (text: string) => text.replace(/\x1b\[[0-9;]*m/g, "")
+
+export function table(entries: string[][], indent = 4, gap = 2) {
+  const columns = Math.max(...entries.map((row) => row.length))
+  const widths = Array.from({ length: columns }, (_, column) => Math.max(...entries.map((row) => visible(row[column] ?? "").length)))
+  for (const row of entries) {
+    const cells = widths.map((width, column) => (row[column] ?? "") + " ".repeat(Math.max(0, width - visible(row[column] ?? "").length)))
+    console.log(`${" ".repeat(indent)}${cells.join(" ".repeat(gap)).trimEnd()}`)
+  }
+}
+
+export function percent(share: number) {
+  return `${Math.round(share * 100)}%`
+}
+
+export function tilde(file: string) {
+  const home = homedir()
+  return file.startsWith(home) ? `~${file.slice(home.length)}` : file
+}
+
+export function tokens(count: number) {
+  if (count >= 1_000_000) return `${(count / 1_000_000).toFixed(count >= 10_000_000 ? 0 : 1)}M`
+  if (count >= 1_000) return `${(count / 1_000).toFixed(count >= 10_000 ? 0 : 1)}k`
+  return String(count)
+}
+
+export function ago(iso: string) {
+  const seconds = Math.max(0, Math.round((Date.now() - Date.parse(iso)) / 1000))
+  if (seconds < 60) return "just now"
+  if (seconds < 3_600) return `${Math.round(seconds / 60)}m ago`
+  if (seconds < 86_400) return `${Math.round(seconds / 3_600)}h ago`
+  return `${Math.round(seconds / 86_400)}d ago`
+}
+
+export function closest(input: string, options: string[]) {
+  const distance = (a: string, b: string) => {
+    const row = Array.from({ length: b.length + 1 }, (_, i) => i)
+    for (let i = 1; i <= a.length; i += 1) {
+      let previous = row[0]
+      row[0] = i
+      for (let j = 1; j <= b.length; j += 1) {
+        const current = row[j]
+        row[j] = Math.min(row[j] + 1, row[j - 1] + 1, previous + (a[i - 1] === b[j - 1] ? 0 : 1))
+        previous = current
+      }
+    }
+    return row[b.length]
+  }
+  const [best] = options.map((option) => [option, distance(input, option)] as const).sort((x, y) => x[1] - y[1])
+  return best && best[1] <= TYPO_DISTANCE ? best[0] : null
+}

package/src/config/constants.ts

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

@@ -0,0 +1,98 @@
+import { existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from "node:fs"
+import { homedir } from "node:os"
+import path from "node:path"
+import { DEFAULTS, EUNOE_DIR, MODES, paths, SCOPES, SEARCH_MODES, TUNABLES } from "./constants"
+import type { Config, Mode, SessionSettings, Tunable, Tunables } from "./types"
+
+const VALID: { [K in Tunable]: (value: unknown) => value is Tunables[K] } = {
+  compactAt: (value): value is number => typeof value === "number" && value > 0 && value <= 1,
+  keepTurns: (value): value is number | "all" => value === "all" || (Number.isInteger(value) && (value as number) >= 0),
+  keep: (value): value is number => Number.isInteger(value) && (value as number) >= 1,
+  budget: (value): value is number => Number.isInteger(value) && (value as number) >= 1_000,
+  search: (value): value is Tunables["search"] => SEARCH_MODES.includes(value as Tunables["search"]),
+  rerank: (value): value is string => typeof value === "string" && /^[\w.-]+$/.test(value),
+}
+
+const TEXT_TUNABLES: Tunable[] = ["search", "rerank"]
+
+const isMode = (value: unknown): value is Mode => MODES.includes(value as Mode)
+
+export function parseTunable<K extends Tunable>(key: K, raw: string): Tunables[K] | null {
+  const value = TEXT_TUNABLES.includes(key) || raw === "all" ? raw : Number(raw.replace(/[_,]/g, ""))
+  return VALID[key](value) ? value as Tunables[K] : null
+}
+
+function normalizeSession(value: unknown): SessionSettings | null {
+  if (value === null) return {}
+  if (isMode(value)) return { mode: value }
+  if (!value || typeof value !== "object" || Array.isArray(value)) return null
+  const raw = value as Record<string, unknown>
+  const settings: SessionSettings = isMode(raw.mode) ? { mode: raw.mode } : {}
+  for (const key of TUNABLES) if (VALID[key](raw[key])) Object.assign(settings, { [key]: raw[key] })
+  return settings
+}
+
+export function normalizeConfig(raw: Record<string, any>): Config {
+  const config: Config = { ...DEFAULTS, ...raw }
+  if (!isMode(config.mode)) config.mode = DEFAULTS.mode
+  if (!SCOPES.includes(config.scope)) config.scope = DEFAULTS.scope
+  for (const key of TUNABLES) if (!VALID[key](config[key])) Object.assign(config, { [key]: DEFAULTS[key] })
+  const sessions = config.sessions && typeof config.sessions === "object" && !Array.isArray(config.sessions) ? config.sessions : {}
+  config.sessions = Object.fromEntries(Object.entries(sessions).flatMap(([id, value]) => {
+    const settings = normalizeSession(value)
+    return settings ? [[id, settings]] : []
+  }))
+  if (!Number.isInteger(config.port)) config.port = DEFAULTS.port
+  if (!Array.isArray(config.claudeConfigDirs)) config.claudeConfigDirs = []
+  return config
+}
+
+let cached: { mtimeMs: number; config: Config } | null = null
+
+export function loadConfig(): Config {
+  let mtimeMs: number
+  try {
+    mtimeMs = statSync(paths.config).mtimeMs
+  } catch {
+    return DEFAULTS
+  }
+  if (cached?.mtimeMs === mtimeMs) return cached.config
+  let config = DEFAULTS
+  try {
+    config = normalizeConfig(JSON.parse(readFileSync(paths.config, "utf8")))
+  } catch (error) {
+    console.error(`[eunoe] ${paths.config} is not valid JSON; using defaults`, error)
+  }
+  cached = { mtimeMs, config }
+  return config
+}
+
+export function saveConfig(patch: Partial<Config>) {
+  mkdirSync(EUNOE_DIR, { recursive: true })
+  const current = existsSync(paths.config) ? JSON.parse(readFileSync(paths.config, "utf8")) : {}
+  writeFileSync(paths.config, JSON.stringify({ ...current, ...patch }, null, 2) + "\n")
+}
+
+export function claudeConfigDirs(config: Config): string[] {
+  const dirs = new Set([path.join(homedir(), ".claude")])
+  if (process.env.CLAUDE_CONFIG_DIR) dirs.add(process.env.CLAUDE_CONFIG_DIR)
+  for (const dir of config.claudeConfigDirs) dirs.add(dir.replace(/^~(?=$|\/)/, homedir()))
+  return [...dirs]
+}
+
+export function modeFor(config: Config, sessionId: string | null): Mode {
+  if (sessionId && sessionId in config.sessions) return config.sessions[sessionId].mode ?? config.mode
+  return config.scope === "all" ? config.mode : "off"
+}
+
+export function overrides(settings: SessionSettings | undefined): Partial<Tunables> {
+  return Object.fromEntries(TUNABLES.filter((key) => settings?.[key] !== undefined).map((key) => [key, settings![key]]))
+}
+
+export function settingsFor(config: Config, sessionId: string | null): Config {
+  return { ...config, ...overrides(sessionId ? config.sessions[sessionId] : undefined), mode: modeFor(config, sessionId) }
+}
+
+export function compactionOwner(config: Config): Mode {
+  return config.scope === "all" ? config.mode : "off"
+}

package/src/config/types.ts

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

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

@@ -0,0 +1,46 @@
+import { SUMMARY_ARGUMENT_CHARS, SUMMARY_COMMAND_CHARS } from "./constants"
+import type { Block, Message } from "./types"
+
+export function contentBlocks(content: unknown): Block[] {
+  return typeof content === "string" ? [{ type: "text", text: content }] : Array.isArray(content) ? content : []
+}
+
+export function blocks(message: Message): Block[] {
+  return contentBlocks(message.content)
+}
+
+export function withoutCacheControl(block: Block): Block {
+  if (!("cache_control" in block)) return block
+  const { cache_control: _, ...rest } = block
+  return rest
+}
+
+export function clean(message: Message): Message {
+  return { role: message.role, content: blocks(message).map(withoutCacheControl) }
+}
+
+export function truncate(text: string, max: number): string {
+  const cut = text.slice(0, max)
+  return /[\uD800-\uDBFF]$/.test(cut) ? cut.slice(0, -1) : cut
+}
+
+export function wellFormed(_key: string, value: unknown): unknown {
+  return typeof value === "string" ? value.toWellFormed() : value
+}
+
+export function clip(value: unknown, max: number): string {
+  const text = String(value).replace(/\s+/g, " ").trim()
+  return text.length > max ? `${truncate(text, max)}…` : text
+}
+
+export 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)}`
+}
+
+export function resultText(block: Block): string {
+  return typeof block.content === "string" ? block.content : contentBlocks(block.content).filter((b) => b.type === "text").map((b) => String(b.text ?? "")).join("\n")
+}