herm-tui 1.0.0-dev.1 → 1.0.0-dev.10

package/src/utils/chafa.ts

@@ -1,173 +0,0 @@
-// Parse a single line of chafa `--format=symbols --colors=full` output
-// into renderable cells. chafa emits SGR escapes interleaved with cell
-// characters. Each cell is a single Unicode codepoint preceded by zero or
-// more SGR sequences that set fg/bg/reverse. We flatten that stream into
-// { ch, fg, bg } records and let the caller build spans.
-//
-// Grammar (informal):
-//   LINE        := (SGR* CELL)*
-//   SGR         := ESC '[' PARAMS 'm'
-//   PARAMS      := N (';' N)*           // e.g. "38;2;255;0;0" or "0" or "7"
-//   CELL        := any single codepoint, not ESC
-//
-// State mutations from SGR params, reading left to right:
-//   0            → fg = bg = null; reverse = false
-//   7            → reverse = true (swap fg/bg for following cells)
-//   38;2;R;G;B   → fg = rgb(R,G,B)
-//   48;2;R;G;B   → bg = rgb(R,G,B)
-//   everything else is ignored (chafa doesn't emit 256-color in full mode,
-//   and basic 16-color shouldn't appear — but silent-skip is safer than
-//   throw on an unexpected byte).
-
-export type RGB = { r: number; g: number; b: number }
-export type Cell = { ch: string; fg: RGB | null; bg: RGB | null }
-
-const ESC = 0x1b
-const LSQ = 0x5b // '['
-
-export function parseChafaLine(line: string): Cell[] {
-  const out: Cell[] = []
-  let fg: RGB | null = null
-  let bg: RGB | null = null
-  let reverse = false
-  let i = 0
-  const N = line.length
-
-  while (i < N) {
-    const code = line.charCodeAt(i)
-    // SGR run
-    if (code === ESC && line.charCodeAt(i + 1) === LSQ) {
-      const end = line.indexOf("m", i + 2)
-      if (end < 0) { i = N; break }
-      const params = line.slice(i + 2, end).split(";").map(x => parseInt(x, 10) || 0)
-      let p = 0
-      while (p < params.length) {
-        const n = params[p]
-        if (n === 0) { fg = null; bg = null; reverse = false; p++; continue }
-        if (n === 7) { reverse = true; p++; continue }
-        if (n === 27) { reverse = false; p++; continue }
-        if (n === 38 && params[p + 1] === 2) {
-          fg = { r: params[p + 2] | 0, g: params[p + 3] | 0, b: params[p + 4] | 0 }
-          p += 5; continue
-        }
-        if (n === 48 && params[p + 1] === 2) {
-          bg = { r: params[p + 2] | 0, g: params[p + 3] | 0, b: params[p + 4] | 0 }
-          p += 5; continue
-        }
-        if (n === 39) { fg = null; p++; continue }
-        if (n === 49) { bg = null; p++; continue }
-        p++
-      }
-      i = end + 1
-      continue
-    }
-    // A cell — consume one codepoint (handles surrogate pairs)
-    const cp = line.codePointAt(i)!
-    const ch = String.fromCodePoint(cp)
-    i += ch.length
-    const efg = reverse ? bg : fg
-    const ebg = reverse ? fg : bg
-    out.push({ ch, fg: efg, bg: ebg })
-  }
-  return out
-}
-
-/** Parse a multi-line chafa output into rows. */
-export function parseChafa(text: string): Cell[][] {
-  return text.split("\n").filter(s => s.length > 0).map(parseChafaLine)
-}
-
-/** Hex color helper for OpenTUI fg/bg props. */
-export function hex(c: RGB | null): string | undefined {
-  if (!c) return undefined
-  return `#${c.r.toString(16).padStart(2, "0")}${c.g.toString(16).padStart(2, "0")}${c.b.toString(16).padStart(2, "0")}`
-}
-
-// ─── Rendering pipeline ─────────────────────────────────────────────────
-//
-// renderChafa() shells the chafa binary and returns parsed rows. Cached by
-// (resolved path, mtime, width) — re-renders on the same file at the same
-// width are free. Cache is an LRU capped at ~50 entries to bound memory
-// for a scrollback with lots of images. Height is omitted from the key
-// because we always pass chafa a 4:1 w/h cap and let it pick the actual
-// row count to preserve aspect.
-
-import { spawnSync } from "child_process"
-import { existsSync, statSync } from "fs"
-
-const CHAFA_PATHS = [
-  "/usr/sbin/chafa",
-  "/usr/bin/chafa",
-  "/usr/local/bin/chafa",
-  "/opt/homebrew/bin/chafa",
-  "/home/linuxbrew/.linuxbrew/bin/chafa",
-]
-
-let cachedBin: string | null | undefined = undefined
-
-/** Locate the chafa binary once per process. null → not installed. */
-export function chafaBin(): string | null {
-  if (cachedBin !== undefined) return cachedBin
-  for (const p of CHAFA_PATHS) if (existsSync(p)) { cachedBin = p; return p }
-  cachedBin = null
-  return null
-}
-
-/** Expand ~ in a user-supplied path. Returns the absolute path or null
- *  if the file doesn't exist. */
-export function resolveImage(path: string): string | null {
-  const full = path.startsWith("~")
-    ? (process.env.HOME ?? "") + path.slice(1)
-    : path
-  return existsSync(full) ? full : null
-}
-
-export type Rendered = { rows: Cell[][] } | { err: string }
-
-const CACHE = new Map<string, Cell[][]>()
-const CACHE_CAP = 50
-
-function cacheGet(k: string): Cell[][] | undefined {
-  const v = CACHE.get(k)
-  if (!v) return undefined
-  // LRU touch: re-insert at tail
-  CACHE.delete(k)
-  CACHE.set(k, v)
-  return v
-}
-
-function cachePut(k: string, v: Cell[][]): void {
-  if (CACHE.size >= CACHE_CAP) CACHE.delete(CACHE.keys().next().value!)
-  CACHE.set(k, v)
-}
-
-/** Render an image to parsed cells at the given cell-width. Height is
- *  capped at roughly width/3 so a 2:1-ish image fits most message widths.
- *  Returns { err } on any failure (caller should fall back to MediaChip). */
-export function renderChafa(path: string, width: number, height?: number): Rendered {
-  const bin = chafaBin()
-  if (!bin) return { err: "chafa not installed" }
-  const full = resolveImage(path)
-  if (!full) return { err: `not found: ${path}` }
-
-  let mtime = 0
-  try { mtime = statSync(full).mtimeMs | 0 } catch { /* ignore — cache key is still unique */ }
-  const h = height ?? Math.max(6, Math.round(width / 3))
-  const key = `${full}:${mtime}:${width}x${h}`
-  const cached = cacheGet(key)
-  if (cached) return { rows: cached }
-
-  const r = spawnSync(bin, [
-    `--size=${width}x${h}`,
-    "--format=symbols",
-    "--symbols=block",
-    "--colors=full",
-    full,
-  ], { encoding: "utf8", timeout: 5_000 })
-  if (r.error) return { err: r.error.message }
-  if (r.status !== 0) return { err: (r.stderr || `chafa exit ${r.status}`).trim() }
-
-  const rows = parseChafa(r.stdout)
-  cachePut(key, rows)
-  return { rows }
-}

package/src/utils/clipboard.ts

@@ -1,67 +0,0 @@
-import { platform } from "os"
-
-/**
- * Writes text to clipboard via OSC 52 escape sequence.
- * Works over SSH by having the terminal emulator handle it locally.
- */
-function writeOsc52(text: string): void {
-  if (!process.stdout.isTTY) return
-  const base64 = Buffer.from(text).toString("base64")
-  const osc52 = `\x1b]52;c;${base64}\x07`
-  const pass = process.env["TMUX"] || process.env["STY"]
-  const seq = pass ? `\x1bPtmux;\x1b${osc52}\x1b\\` : osc52
-  process.stdout.write(seq)
-}
-
-async function nativeCopy(text: string): Promise<void> {
-  const os = platform()
-
-  if (os === "darwin") {
-    const proc = Bun.spawn(["pbcopy"], { stdin: "pipe" })
-    proc.stdin.write(text)
-    proc.stdin.end()
-    await proc.exited
-    return
-  }
-
-  if (os === "linux") {
-    if (process.env["WAYLAND_DISPLAY"]) {
-      try {
-        const proc = Bun.spawn(["wl-copy"], { stdin: "pipe", stdout: "ignore", stderr: "ignore" })
-        proc.stdin.write(text)
-        proc.stdin.end()
-        await proc.exited
-        return
-      } catch {}
-    }
-    try {
-      const proc = Bun.spawn(["xclip", "-selection", "clipboard"], { stdin: "pipe", stdout: "ignore", stderr: "ignore" })
-      proc.stdin.write(text)
-      proc.stdin.end()
-      await proc.exited
-      return
-    } catch {}
-    try {
-      const proc = Bun.spawn(["xsel", "--clipboard", "--input"], { stdin: "pipe", stdout: "ignore", stderr: "ignore" })
-      proc.stdin.write(text)
-      proc.stdin.end()
-      await proc.exited
-      return
-    } catch {}
-  }
-}
-
-export async function copy(text: string): Promise<void> {
-  writeOsc52(text)
-  await nativeCopy(text).catch(() => {})
-}
-
-export function copySelection(renderer: { getSelection: () => { getSelectedText: () => string } | null; clearSelection: () => void }): boolean {
-  const sel = renderer.getSelection()
-  const text = sel?.getSelectedText()
-  if (!text) return false
-
-  copy(text).catch(() => {})
-  renderer.clearSelection()
-  return true
-}

package/src/utils/context-segments.ts

@@ -1,317 +0,0 @@
-/**
- * context-segments.ts — Parse the Hermes system prompt into sections,
- * group them into a two-level hierarchy, and generate grids.
- *
- * Level 0 (top):  System Prompt | System Tools | MCP Tools | Memory |
- *                 Skills | Conversation | Free
- * Level 1 (drill): Children of a group, e.g. Memory → SOUL | Notes |
- *                 User Profile | Mem0 | Providers
- *
- * The grid always fills 256 cells. At top level, percentages are relative
- * to the full context length. At drill level, relative to the parent group.
- */
-
-import type { Source, ToolInfo } from "./hermes-home"
-import { makeSource } from "./hermes-home"
-import { count as tok } from "./tokens"
-
-// ─── Types ───────────────────────────────────────────────────────────
-
-/** A parsed section of the system prompt */
-export type Section = {
-  readonly id: string
-  readonly label: string
-  readonly chars: number
-  readonly tokens: number
-  readonly text: string
-  readonly source?: Source
-}
-
-/** A segment in the grid — leaf or group */
-export type Segment = {
-  readonly id: string
-  readonly label: string
-  readonly tokens: number
-  readonly percent: number
-  readonly children?: ReadonlyArray<Segment>
-  readonly section?: Section
-}
-
-/** Grid cell */
-type Cell = { readonly id: string }
-
-// ─── Constants ───────────────────────────────────────────────────────
-
-const GRID = 256
-// Chars-per-token fallback for ToolInfo (description/param lengths are
-// char counts; the text itself is not retained in the snapshot — so we
-// can't run the real tokenizer until upstream ToolInfo carries text).
-const CPT = 4
-
-/** Parsed-section IDs that belong to the Memory top-level category */
-const MEMORY_IDS = new Set(["soul", "memory", "user", "mem0"])
-
-/** Parsed-section IDs that are residual system-prompt framing */
-const SYSTEM_PROMPT_IDS = new Set(["project", "meta", "other"])
-
-// ─── System Prompt Parser ────────────────────────────────────────────
-
-/** Parse raw system prompt text into sections by structural delimiters */
-export function parse(text: string): Section[] {
-  if (!text) return []
-
-  const sections: Section[] = []
-  const used = new Array(text.length).fill(false)
-
-  const mark = (start: number, end: number, id: string, label: string, source?: Source) => {
-    const slice = text.slice(start, end)
-    if (slice.trim().length === 0) return
-    for (let i = start; i < end; i++) used[i] = true
-    sections.push({ id, label, chars: slice.length, tokens: tok(slice), text: slice, source })
-  }
-
-  // SOUL.md — start to first ══════
-  const bar1 = text.indexOf("══════")
-  if (bar1 > 0) mark(0, bar1, "soul", "SOUL.md", makeSource("SOUL.md"))
-
-  // MEMORY block
-  const memH = text.indexOf("MEMORY (your personal notes)")
-  if (memH >= 0) {
-    const s = text.lastIndexOf("══════", memH)
-    const after = text.indexOf("\n", text.indexOf("══════", memH + 1))
-    const next = text.indexOf("══════", after > 0 ? after : memH + 40)
-    const e = next > 0 ? text.lastIndexOf("\n", next) + 1 : text.length
-    if (s >= 0) mark(s, e, "memory", "Memory Notes", makeSource("memories/MEMORY.md", "MEMORY.md"))
-  }
-
-  // USER PROFILE block
-  const userH = text.indexOf("USER PROFILE (who the user is)")
-  if (userH >= 0) {
-    const s = text.lastIndexOf("══════", userH)
-    const after = text.indexOf("\n", text.indexOf("══════", userH + 1))
-    const rest = text.slice(after > 0 ? after : userH + 40)
-    const next = rest.search(/\n#\s/)
-    const e = next >= 0 ? (after > 0 ? after : userH + 40) + next + 1 : text.length
-    if (s >= 0) mark(s, e, "user", "User Profile", makeSource("memories/USER.md", "USER.md"))
-  }
-
-  // Mem0 Memory
-  const m0 = text.indexOf("# Mem0 Memory")
-  if (m0 >= 0) {
-    const rest = text.slice(m0 + 1)
-    const next = rest.search(/\n##?\s/)
-    mark(m0, next >= 0 ? m0 + 1 + next + 1 : text.length, "mem0", "Mem0 Memory")
-  }
-
-  // Skills catalog
-  const skH = text.indexOf("## Skills (mandatory)")
-  const skE = text.indexOf("</available_skills>")
-  if (skH >= 0 && skE >= 0) {
-    let end = text.indexOf("\n", skE)
-    while (end < text.length && end >= 0) {
-      const nl = text.indexOf("\n", end + 1)
-      if (nl < 0) { end = text.length; break }
-      const line = text.slice(end + 1, nl).trim()
-      if (line.startsWith("#")) break
-      if (line === "") {
-        const peek = text.slice(nl + 1, text.indexOf("\n", nl + 1)).trim()
-        if (peek.startsWith("#")) { end = nl; break }
-      }
-      end = nl
-    }
-    mark(skH, end + 1, "skills", "Skills Catalog", makeSource("skills", "skills/"))
-  }
-
-  // Project Context
-  const proj = text.indexOf("# Project Context")
-  if (proj >= 0) {
-    const conv = text.indexOf("Conversation started:")
-    mark(proj, conv > proj ? conv : text.length, "project", "Project Context", makeSource("AGENTS.md"))
-  }
-
-  // Session metadata
-  const conv = text.indexOf("Conversation started:")
-  if (conv >= 0) mark(conv, text.length, "meta", "Session Metadata")
-
-  // Unmarked regions → "other"
-  let start = -1
-  for (let i = 0; i <= text.length; i++) {
-    if (i < text.length && !used[i]) {
-      if (start < 0) start = i
-    } else if (start >= 0) {
-      const slice = text.slice(start, i)
-      if (slice.trim().length > 0) {
-        sections.push({ id: "other", label: "Other", chars: slice.length, tokens: tok(slice), text: slice })
-      }
-      start = -1
-    }
-  }
-
-  return sections.sort((a, b) => text.indexOf(a.text) - text.indexOf(b.text))
-}
-
-// ─── Tool Classification ─────────────────────────────────────────────
-
-/** Classify tools by origin. MCP tools always have `mcp_` prefix — this is
- *  a guaranteed convention (mcp_tool.py:2394 collision guard). */
-export function classifyTools(
-  tools: ReadonlyArray<ToolInfo>,
-): { system: ToolInfo[]; mcp: ToolInfo[] } {
-  const system: ToolInfo[] = []
-  const mcp: ToolInfo[] = []
-  for (const t of tools) {
-    if (t.name.startsWith("mcp_")) mcp.push(t)
-    else system.push(t)
-  }
-  return { system, mcp }
-}
-
-/** Token estimate for a tool's schema entry. chars/4 fallback — ToolInfo
- *  only carries lengths, not text. */
-export function toolTokens(tool: ToolInfo): number {
-  return Math.ceil((tool.descriptionLength + tool.paramsLength) / CPT)
-}
-
-// ─── Segment Builder ─────────────────────────────────────────────────
-
-type Opts = {
-  contextLength: number
-  inputTokens: number
-  sections: ReadonlyArray<Section>
-  conversationTokens: number
-  tools: ReadonlyArray<ToolInfo>
-  /** Optional — total tokens consumed by installed skills (name+description
-   *  per skill). When absent, falls back to the "skills" section from parse()
-   *  (which reflects what's actually injected into the system prompt). */
-  skillsTokens?: number
-}
-
-/**
- * Build the two-level segment hierarchy.
- * Returns top-level groups. Groups with children can be drilled into.
- *
- * Top-level categories (in display order):
- *   system_prompt | system_tools | mcp_tools | memory | skills | conversation | free
- */
-export function build(opts: Opts): Segment[] {
-  const pct = (t: number) => opts.contextLength > 0 ? (t / opts.contextLength) * 100 : 0
-  const result: Segment[] = []
-
-  const byId = new Map<string, Section>()
-  for (const s of opts.sections) byId.set(s.id, s)
-
-  // ── 1. System Prompt (framing only — project + meta + other) ──
-  const promptChildren: Segment[] = opts.sections
-    .filter(sec => SYSTEM_PROMPT_IDS.has(sec.id) && sec.tokens > 0)
-    .map(sec => ({
-      id: sec.id,
-      label: sec.label,
-      tokens: sec.tokens,
-      percent: pct(sec.tokens),
-      section: sec,
-    }))
-  const promptTok = promptChildren.reduce((s, c) => s + c.tokens, 0)
-  if (promptTok > 0) {
-    result.push({
-      id: "system_prompt",
-      label: "System Prompt",
-      tokens: promptTok,
-      percent: pct(promptTok),
-      children: promptChildren,
-    })
-  }
-
-  // ── 2. System Tools (non-MCP) ──
-  const { system: sysTools, mcp: mcpTools } = classifyTools(opts.tools)
-  const sysToolsTok = sysTools.reduce((s, t) => s + toolTokens(t), 0)
-  if (sysToolsTok > 0) {
-    result.push({
-      id: "system_tools",
-      label: "System Tools",
-      tokens: sysToolsTok,
-      percent: pct(sysToolsTok),
-    })
-  }
-
-  // ── 3. MCP Tools ──
-  const mcpToolsTok = mcpTools.reduce((s, t) => s + toolTokens(t), 0)
-  if (mcpToolsTok > 0) {
-    result.push({
-      id: "mcp_tools",
-      label: "MCP Tools",
-      tokens: mcpToolsTok,
-      percent: pct(mcpToolsTok),
-    })
-  }
-
-  // ── 4. Memory (SOUL + Notes + Profile + Mem0) ──
-  const memChildren: Segment[] = opts.sections
-    .filter(sec => MEMORY_IDS.has(sec.id) && sec.tokens > 0)
-    .map(sec => ({
-      id: sec.id,
-      label: sec.label,
-      tokens: sec.tokens,
-      percent: pct(sec.tokens),
-      section: sec,
-    }))
-  const memTok = memChildren.reduce((s, c) => s + c.tokens, 0)
-  if (memTok > 0) {
-    result.push({
-      id: "memory",
-      label: "Memory",
-      tokens: memTok,
-      percent: pct(memTok),
-      children: memChildren,
-    })
-  }
-
-  // ── 5. Skills (catalog injected into system prompt) ──
-  const skillsSec = byId.get("skills")
-  const skillsTok = skillsSec?.tokens ?? opts.skillsTokens ?? 0
-  if (skillsTok > 0) {
-    result.push({
-      id: "skills",
-      label: "Skills",
-      tokens: skillsTok,
-      percent: pct(skillsTok),
-      section: skillsSec,
-    })
-  }
-
-  // ── 6. Conversation ──
-  if (opts.conversationTokens > 0) {
-    const ct = Math.min(opts.conversationTokens, opts.inputTokens || opts.conversationTokens)
-    result.push({ id: "conversation", label: "Conversation", tokens: ct, percent: pct(ct) })
-  }
-
-  // ── 7. Free ──
-  const taken = result.reduce((s, g) => s + g.tokens, 0)
-  const free = Math.max(0, opts.contextLength - taken)
-  result.push({ id: "free", label: "Free", tokens: free, percent: pct(free) })
-
-  return result
-}
-
-/**
- * Get drilled-in segments for a group, with percentages rescaled
- * to fill the grid relative to the group's total.
- */
-export function drill(group: Segment): Segment[] {
-  if (!group.children || group.children.length === 0) return []
-  const total = group.tokens
-  return group.children.map(c => ({
-    ...c,
-    percent: total > 0 ? (c.tokens / total) * 100 : 0,
-  }))
-}
-
-// ─── Grid Generator ──────────────────────────────────────────────────
-
-/** Generate 256 cells from segments, proportional to percent */
-export function cells(segments: ReadonlyArray<Segment>, fallback = "free"): Cell[] {
-  const filled = segments.flatMap(seg =>
-    Array.from({ length: Math.round((seg.percent / 100) * GRID) }, () => ({ id: seg.id }))
-  )
-  const pad = Array.from({ length: Math.max(0, GRID - filled.length) }, () => ({ id: fallback }))
-  return [...filled, ...pad].slice(0, GRID)
-}