herm-tui 1.0.0-dev.1

package/src/utils/tips.ts

@@ -0,0 +1,67 @@
+// Hermes CLI ships ~200 one-line tips in hermes_cli/tips.py. There's
+// no `tips.list` RPC (see UPSTREAM.md); rather than shell.exec a python
+// one-liner on every boot, read the source file once and scrape the
+// string literals out of the `TIPS = [ ... ]` block. Brittle-by-design
+// but zero-cost; falls back to a small built-in set if the file moved.
+
+import { readFileSync } from "node:fs"
+import { join } from "node:path"
+import { hermesAgentRoot } from "./gateway-client"
+
+const FALLBACK = [
+  "`@file:path/to/file.py` injects file contents directly into your message.",
+  "`/title <name>` names the session — resume it later from the Sessions tab.",
+  "Ctrl+G opens $EDITOR seeded with the composer contents.",
+  "Ctrl+Z suspends to the shell; `fg` resumes.",
+  "Pasting 5+ lines collapses to a `[Pasted #N …]` placeholder.",
+  "Click a user message in the transcript to rewind to that point.",
+]
+
+// Tokens worth accenting in a tip line: /slash, @refs, keybinds,
+// `code`, "quoted".
+const HL = /(\/[a-z][\w-]*|@[\w:./-]+|(?:Ctrl|Alt|Shift)\+\S+|`[^`]+`|"[^"]+")/g
+
+type TipPart = { t: string; hl: boolean }
+
+export function splitTip(tip: string): TipPart[] {
+  const out: TipPart[] = []
+  let i = 0
+  for (const m of tip.matchAll(HL)) {
+    const j = m.index
+    if (j > i) out.push({ t: tip.slice(i, j), hl: false })
+    out.push({ t: m[0].replace(/^`|`$/g, ""), hl: true })
+    i = j + m[0].length
+  }
+  if (i < tip.length) out.push({ t: tip.slice(i), hl: false })
+  return out
+}
+
+let cache: string[] | null = null
+
+export function loadTips(): string[] {
+  if (cache) return cache
+  try {
+    const src = readFileSync(join(hermesAgentRoot(), "hermes_cli", "tips.py"), "utf8")
+    const body = src.split(/^TIPS\s*=\s*\[/m)[1]?.split(/^\]/m)[0] ?? ""
+    // Each tip is a double-quoted single-line string literal. Pull the
+    // inner text, unescape \" and \\, drop comments/blank lines.
+    const tips: string[] = []
+    for (const line of body.split("\n")) {
+      const m = line.match(/^\s+"((?:[^"\\]|\\.)*)",?\s*$/)
+      if (m) tips.push(m[1].replace(/\\"/g, '"').replace(/\\\\/g, "\\"))
+    }
+    cache = tips.length > 10 ? tips : FALLBACK
+  } catch {
+    cache = FALLBACK
+  }
+  return cache
+}
+
+/** Random tip; never the same twice in a row. */
+export function randomTip(prev?: string): string {
+  const t = loadTips()
+  if (t.length < 2) return t[0] ?? ""
+  let pick = t[Math.floor(Math.random() * t.length)]
+  while (pick === prev) pick = t[Math.floor(Math.random() * t.length)]
+  return pick
+}

package/src/utils/tokens.ts

@@ -0,0 +1,87 @@
+/**
+ * Token count estimator.
+ *
+ * Uses gpt-tokenizer with o200k_base (GPT-4o / GPT-5 / Claude-close-enough)
+ * for accurate counts on static blocks. Falls back to chars/4 if the
+ * tokenizer import fails at runtime (shouldn't in production, but keeps
+ * tests resilient and prevents a bad dep from breaking renders).
+ *
+ * Load-time: gpt-tokenizer is 55MB and costs ~170ms to import — roughly
+ * half the cold-start import graph. Nothing on the first-frame path
+ * (splash, composer, sidebar) needs real token counts, so the module is
+ * require()'d lazily on first count() call. Bun's require() is sync and
+ * cached, so the first call takes the hit and subsequent calls are free.
+ * Background warmup() lets app.tsx kick the import after first render
+ * so the first Context-tab visit doesn't stall.
+ *
+ * Cached by content hash (DJB2) so repeated counts of the same text
+ * are free. The grid recomputes on every snapshot refresh (10s) but
+ * most content is stable across refreshes — skills, tool schemas, SOUL.
+ */
+
+type Enc = { countTokens: (s: string) => number }
+let enc: Enc | null | undefined
+
+const load = (): Enc | null => {
+  if (enc !== undefined) return enc
+  try { enc = require("gpt-tokenizer") as Enc }
+  catch { enc = null }
+  return enc
+}
+
+/** Kick the lazy import off the hot path. Fire-and-forget. */
+export const warmup = () => { queueMicrotask(load) }
+
+// Simple DJB2 hash — fast, collision-tolerant for cache keys.
+const hash = (s: string): string => {
+  let h = 5381
+  for (let i = 0; i < s.length; i++) h = ((h << 5) + h + s.charCodeAt(i)) | 0
+  return String(h)
+}
+
+const cache = new Map<string, number>()
+const CACHE_MAX = 1024
+
+// Fallback when tokenizer unavailable — matches the old chars/4 behavior.
+const roughCount = (s: string): number => Math.ceil(s.length / 4)
+
+/**
+ * Count tokens in a string. Cached by content hash.
+ * Returns 0 for empty string.
+ */
+export function count(s: string): number {
+  if (!s) return 0
+  const k = hash(s)
+  const hit = cache.get(k)
+  if (hit !== undefined) return hit
+  let n: number
+  try { n = load()?.countTokens(s) ?? roughCount(s) }
+  catch { n = roughCount(s) }
+  if (cache.size >= CACHE_MAX) {
+    const first = cache.keys().next().value
+    if (first !== undefined) cache.delete(first)
+  }
+  cache.set(k, n)
+  return n
+}
+
+/** Clear the count cache. For tests. */
+export function clearCache(): void {
+  cache.clear()
+}
+
+/**
+ * Human-format a token count for compact display:
+ *   999 → "999"   1_000 → "1.0K"   10_000 → "10K"
+ *   258_000 → "258K"   1_000_000 → "1M"   1_250_000 → "1.2M"
+ */
+export function formatTokens(n: number): string {
+  if (!Number.isFinite(n) || n < 0) return "0"
+  if (n >= 1_000_000) {
+    const m = n / 1_000_000
+    return m === Math.floor(m) ? `${m}M` : `${m.toFixed(1)}M`
+  }
+  if (n >= 10_000) return `${Math.round(n / 1000)}K`
+  if (n >= 1_000) return `${(n / 1000).toFixed(1)}K`
+  return String(Math.round(n))
+}