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

package/src/utils/memory-activity.ts

@@ -1,140 +0,0 @@
-// Recent memory-tool invocations scraped from state.db.
-//
-// No gateway RPC or audit log exists for this; messages.tool_calls on
-// assistant rows carries the full invocation JSON, so read sqlite
-// directly (same pattern as hermes-analytics.ts).
-
-import { Database } from "bun:sqlite"
-import { hermesPath } from "./hermes-home"
-
-type MemoryOp = "write" | "read"
-
-export type MemoryActivity = {
-  ts: number
-  provider: string
-  tool: string
-  op: MemoryOp
-  /** Human verb: add, replace, remove, conclude, search, … */
-  verb: string
-  /** Short payload summary (query text, content head, target). */
-  summary: string
-  sessionId: string
-  sessionTitle: string
-}
-
-// Tool-name → provider. Built from plugins/memory/*/__init__.py tool
-// defs + the core `memory` tool.
-const WRITE: Record<string, string> = {
-  memory: "builtin",
-  mem0_conclude: "mem0",
-  honcho_conclude: "honcho",
-  hindsight_retain: "hindsight", hindsight_reflect: "hindsight",
-  fact_store: "holographic", fact_feedback: "holographic",
-  viking_remember: "openviking", viking_add_resource: "openviking",
-  retaindb_remember: "retaindb", retaindb_forget: "retaindb",
-  supermemory_store: "supermemory", supermemory_forget: "supermemory",
-  brv_curate: "byterover",
-}
-const READ: Record<string, string> = {
-  mem0_search: "mem0", mem0_profile: "mem0",
-  honcho_search: "honcho", honcho_profile: "honcho",
-  honcho_reasoning: "honcho", honcho_context: "honcho",
-  hindsight_recall: "hindsight",
-  viking_search: "openviking", viking_read: "openviking", viking_browse: "openviking",
-  retaindb_search: "retaindb", retaindb_profile: "retaindb", retaindb_context: "retaindb",
-  supermemory_search: "supermemory", supermemory_profile: "supermemory",
-  brv_query: "byterover", brv_status: "byterover",
-}
-
-const MEMORY_TOOLS = { ...WRITE, ...READ }
-
-const trunc = (s: unknown, n = 80): string => {
-  const t = String(s ?? "").replace(/\s+/g, " ").trim()
-  return t.length > n ? t.slice(0, n - 1) + "…" : t
-}
-
-const stripPrefix = (name: string): string =>
-  name.replace(/^(mem0|honcho|hindsight|viking|retaindb|supermemory|brv|fact)_/, "")
-
-type Args = Record<string, unknown>
-
-const describe = (name: string, args: Args): { verb: string; summary: string } => {
-  if (name === "memory") {
-    const action = String(args.action ?? "")
-    const target = String(args.target ?? "")
-    const body = action === "remove" ? args.old_text : args.content ?? args.old_text
-    return { verb: action, summary: `${target}: ${trunc(body)}` }
-  }
-  const verb = stripPrefix(name)
-  for (const k of ["conclusion", "content", "query", "text", "fact", "question", "note", "path"])
-    if (k in args) return { verb, summary: trunc(args[k]) }
-  const first = Object.values(args).find(v => typeof v === "string")
-  return { verb, summary: trunc(first ?? "") }
-}
-
-type Row = {
-  ts: number
-  tool_calls: string
-  session_id: string
-  title: string | null
-}
-
-/** Parse memory-tool calls out of a single assistant row. Exported for test. */
-export const extract = (r: Row): MemoryActivity[] => {
-  let calls: Array<{ function?: { name?: string; arguments?: string } }>
-  try { calls = JSON.parse(r.tool_calls) } catch { return [] }
-  if (!Array.isArray(calls)) return []
-  const out: MemoryActivity[] = []
-  for (const c of calls) {
-    const name = c.function?.name
-    if (!name || !(name in MEMORY_TOOLS)) continue
-    let args: Args = {}
-    try { args = JSON.parse(c.function?.arguments ?? "{}") } catch { /* keep {} */ }
-    const { verb, summary } = describe(name, args)
-    out.push({
-      ts: r.ts,
-      provider: MEMORY_TOOLS[name],
-      tool: name,
-      op: name in WRITE ? "write" : "read",
-      verb, summary,
-      sessionId: r.session_id,
-      sessionTitle: r.title ?? r.session_id,
-    })
-  }
-  return out
-}
-
-/**
- * Scan recent assistant rows for memory-tool invocations.
- *
- * Bounded by `scan` (row window), not DB size — tool_calls isn't indexed
- * and json_each over the whole table is unbounded. 2000 rows ≈ a few
- * days of heavy use.
- */
-export function readMemoryActivity(limit = 100, scan = 2000): MemoryActivity[] {
-  let db: Database
-  try {
-    db = new Database(hermesPath("state.db"), { readonly: true })
-  } catch {
-    return []
-  }
-  try {
-    const rows = db.query<Row, [number]>(
-      `SELECT m.timestamp ts, m.tool_calls, m.session_id,
-              s.title
-       FROM messages m LEFT JOIN sessions s ON m.session_id = s.id
-       WHERE m.role = 'assistant' AND m.tool_calls IS NOT NULL
-       ORDER BY m.id DESC LIMIT ?`,
-    ).all(scan)
-    const out: MemoryActivity[] = []
-    for (const r of rows) {
-      for (const a of extract(r)) {
-        out.push(a)
-        if (out.length >= limit) return out
-      }
-    }
-    return out
-  } finally {
-    db.close()
-  }
-}

package/src/utils/open-file.ts

@@ -1,13 +0,0 @@
-/**
- * open-file.ts — Open files and URLs using the OS default handler.
- *
- * Uses the `open` package (cross-platform: xdg-open on Linux, open on macOS, start on Windows).
- * Fire-and-forget — does not block the TUI.
- */
-
-import open from "open";
-
-/** Open a file in the OS default handler for its type */
-export function openFile(path: string): void {
-  open(path).catch(() => {});
-}

package/src/utils/paths.ts

@@ -1,52 +0,0 @@
-// Filesystem locations herm writes to. Central so the default stays
-// consistent across callers and the legacy-path migration only lives
-// in one spot.
-//
-// Defaults
-//   HERM_CONFIG_DIR → $HERMES_HOME/herm (typically ~/.hermes/herm)
-//   HERMES_HOME     → ~/.hermes
-//
-// Legacy layout (pre-0.1): ~/.config/herm — we auto-migrate any files
-// sitting there into the new location on first access, once.
-
-import { homedir } from "os"
-import { join } from "path"
-import { existsSync, mkdirSync, readdirSync, renameSync } from "fs"
-
-const HOME = () => process.env.HOME || homedir()
-const HERMES_HOME = () => process.env.HERMES_HOME || join(HOME(), ".hermes")
-
-let migrated = false
-
-/** Where herm-specific prefs, history, and caches live. */
-export function configDir(): string {
-  const dir = process.env.HERM_CONFIG_DIR || join(HERMES_HOME(), "herm")
-  if (!migrated) {
-    migrated = true
-    maybeMigrateLegacy(dir)
-  }
-  return dir
-}
-
-/** One-time migration: ~/.config/herm/* → new configDir if empty. */
-function maybeMigrateLegacy(target: string): void {
-  // Respect explicit override: if the user set HERM_CONFIG_DIR we
-  // never touch the legacy path.
-  if (process.env.HERM_CONFIG_DIR) return
-  const legacy = join(HOME(), ".config", "herm")
-  if (!existsSync(legacy) || legacy === target) return
-  // Only migrate when the target doesn't already hold data — never
-  // clobber a fresh install.
-  try {
-    if (existsSync(target) && readdirSync(target).length > 0) return
-    mkdirSync(target, { recursive: true })
-    for (const name of readdirSync(legacy)) {
-      const src = join(legacy, name)
-      const dst = join(target, name)
-      if (existsSync(dst)) continue
-      try { renameSync(src, dst) } catch { /* cross-device or locked — skip */ }
-    }
-  } catch {
-    // Best-effort; a failed migration should never block startup.
-  }
-}

package/src/utils/perf.ts

@@ -1,235 +0,0 @@
-/**
- * perf.ts — Zero-cost profiling for herm.
- *
- * Gate: set PERF=1 to activate. When disabled, every export
- * is a no-op or passthrough — no allocations, no timers, no overhead.
- *
- * Usage:
- *   PERF=1 bun run dev          # periodic memory + event stats
- *   PERF=verbose bun run dev    # ^ plus per-event timing logs
- *
- * API:
- *   mark(label)      — start timing, returns end() → ms
- *   count(label)     — increment a named counter
- *   mem(label)       — snapshot RSS/heap at a labeled point
- *   monitor(ms)      — start periodic memory reporter, returns cleanup
- *   report()         — dump all collected stats to stderr
- *   onRender(...)    — React <Profiler> onRender callback
- */
-
-const level = process.env.PERF ?? ""
-const enabled = level === "1" || level === "verbose"
-const verbose = level === "verbose"
-
-// ── Timing ────────────────────────────────────────────────────────────
-
-type Timing = { count: number; total: number; min: number; max: number; last: number }
-
-const timings = new Map<string, Timing>()
-
-const noop = () => 0
-
-/** Start a timing mark. Returns end() which returns elapsed ms. */
-export const mark = enabled
-  ? (label: string): (() => number) => {
-    const start = Bun.nanoseconds()
-    return () => {
-      const ms = (Bun.nanoseconds() - start) / 1e6
-      const t = timings.get(label)
-      if (t) {
-        t.count++
-        t.total += ms
-        if (ms < t.min) t.min = ms
-        if (ms > t.max) t.max = ms
-        t.last = ms
-      } else {
-        timings.set(label, { count: 1, total: ms, min: ms, max: ms, last: ms })
-      }
-      if (verbose) log(`⏱ ${label}: ${ms.toFixed(2)}ms`)
-      return ms
-    }
-  }
-  : (_: string) => noop
-
-// ── Boot stages ───────────────────────────────────────────────────────
-// One-shot milestones measured from process start (Bun.nanoseconds()
-// origin). ESM imports hoist, so mark() can't bracket the import graph;
-// callers pass the absolute ms-since-spawn instead.
-const stages: Array<[string, number]> = []
-export const boot = (label: string, ms: number) => {
-  stages.push([label, ms])
-  if (enabled) log(`🚀 boot:${label} ${ms.toFixed(1)}ms`)
-}
-
-// ── Counters ──────────────────────────────────────────────────────────
-
-const counters = new Map<string, number>()
-
-/** Increment a named counter. */
-export const count = enabled
-  ? (label: string, n = 1) => {
-    counters.set(label, (counters.get(label) ?? 0) + n)
-  }
-  : (_label: string, _n?: number) => {}
-
-// ── Memory ────────────────────────────────────────────────────────────
-
-type Snapshot = { label: string; rss: number; heap: number; external: number; ts: number }
-
-const snapshots: Snapshot[] = []
-
-const mb = (n: number) => (n / 1024 / 1024).toFixed(1)
-
-/** Snapshot memory at a labeled point. */
-export const mem = enabled
-  ? (label: string) => {
-    const m = process.memoryUsage()
-    snapshots.push({ label, rss: m.rss, heap: m.heapUsed, external: m.external, ts: Date.now() })
-    log(`📊 [${label}] RSS=${mb(m.rss)}MB heap=${mb(m.heapUsed)}MB ext=${mb(m.external)}MB`)
-  }
-  : (_: string) => {}
-
-/** Start periodic memory reporter. Returns cleanup function. */
-export const monitor = enabled
-  ? (ms = 10_000): (() => void) => {
-    const id = setInterval(() => {
-      const m = process.memoryUsage()
-      const gc = Bun.gc(false)
-      log(
-        `\x1b[90m[mem] RSS=${mb(m.rss)}MB heap=${mb(m.heapUsed)}/${mb(m.heapTotal)}MB`
-        + ` ext=${mb(m.external)}MB gcRuns=${(gc as unknown as Record<string, unknown>)?.eden_collections ?? "?"}/${(gc as unknown as Record<string, unknown>)?.full_collections ?? "?"}\x1b[0m`
-      )
-    }, ms)
-    return () => clearInterval(id)
-  }
-  : (_ms?: number) => noop
-
-// ── React Profiler ────────────────────────────────────────────────────
-
-type RenderEntry = { count: number; total: number; max: number; last: number }
-
-const renders = new Map<string, RenderEntry>()
-
-/**
- * Drop-in for React <Profiler onRender={perf.onRender}>.
- * Tracks render count, total time, and max render time per id.
- */
-export const onRender = enabled
-  ? (id: string, phase: "mount" | "update" | "nested-update", actual: number) => {
-    const r = renders.get(id)
-    if (r) {
-      r.count++
-      r.total += actual
-      if (actual > r.max) r.max = actual
-      r.last = actual
-    } else {
-      renders.set(id, { count: 1, total: actual, max: actual, last: actual })
-    }
-    if (verbose && actual > 1) {
-      log(`🔄 [${id}] ${phase}: ${actual.toFixed(2)}ms`)
-    }
-  }
-  : (_id: string, _phase: string, _actual: number) => {}
-
-// ── Report ────────────────────────────────────────────────────────────
-
-/** Dump all collected profiling data to stderr. */
-const report = () => {
-  if (!enabled) return
-
-  const lines: string[] = ["\n\x1b[1m═══ PERF REPORT ═══\x1b[0m\n"]
-
-  // Memory snapshots
-  if (snapshots.length > 0) {
-    lines.push("\x1b[1mMemory Snapshots:\x1b[0m")
-    for (const s of snapshots) {
-      lines.push(`  ${s.label}: RSS=${mb(s.rss)}MB heap=${mb(s.heap)}MB ext=${mb(s.external)}MB`)
-    }
-    const first = snapshots[0]
-    const last = snapshots[snapshots.length - 1]
-    const drift = last.rss - first.rss
-    lines.push(`  Δ RSS: ${drift > 0 ? "+" : ""}${mb(drift)}MB (${first.label} → ${last.label})`)
-    lines.push("")
-  }
-
-  // Timings
-  if (timings.size > 0) {
-    lines.push("\x1b[1mTimings:\x1b[0m")
-    const sorted = [...timings.entries()].sort((a, b) => b[1].total - a[1].total)
-    for (const [label, t] of sorted) {
-      const avg = t.total / t.count
-      lines.push(
-        `  ${label}: ${t.count}× avg=${avg.toFixed(2)}ms`
-        + ` min=${t.min.toFixed(2)}ms max=${t.max.toFixed(2)}ms total=${t.total.toFixed(0)}ms`
-      )
-    }
-    lines.push("")
-  }
-
-  // Render profiler
-  if (renders.size > 0) {
-    lines.push("\x1b[1mReact Renders:\x1b[0m")
-    const sorted = [...renders.entries()].sort((a, b) => b[1].count - a[1].count)
-    for (const [id, r] of sorted) {
-      const avg = r.total / r.count
-      lines.push(
-        `  <${id}>: ${r.count}× avg=${avg.toFixed(2)}ms max=${r.max.toFixed(2)}ms total=${r.total.toFixed(0)}ms`
-      )
-    }
-    lines.push("")
-  }
-
-  // Counters
-  if (counters.size > 0) {
-    lines.push("\x1b[1mCounters:\x1b[0m")
-    const sorted = [...counters.entries()].sort((a, b) => b[1] - a[1])
-    for (const [label, n] of sorted) {
-      lines.push(`  ${label}: ${n}`)
-    }
-    lines.push("")
-  }
-
-  log(lines.join("\n"))
-}
-
-/** Return all profiling data as a plain object (for JSON API). */
-export const data = () => {
-  if (!enabled) return null
-  const m = process.memoryUsage()
-  return {
-    boot: Object.fromEntries(stages.map(([l, ms]) => [l, +ms.toFixed(1)])),
-    memory: {
-      rss: Math.round(m.rss / 1024 / 1024),
-      heap: Math.round(m.heapUsed / 1024 / 1024),
-      heapTotal: Math.round(m.heapTotal / 1024 / 1024),
-      external: Math.round(m.external / 1024 / 1024),
-    },
-    snapshots: snapshots.map(s => ({
-      label: s.label,
-      rss: Math.round(s.rss / 1024 / 1024),
-      heap: Math.round(s.heap / 1024 / 1024),
-      external: Math.round(s.external / 1024 / 1024),
-    })),
-    timings: Object.fromEntries(
-      [...timings.entries()].sort((a, b) => b[1].total - a[1].total)
-        .map(([k, v]) => [k, { count: v.count, avg: +(v.total / v.count).toFixed(2), min: +v.min.toFixed(2), max: +v.max.toFixed(2), total: Math.round(v.total) }])
-    ),
-    renders: Object.fromEntries(
-      [...renders.entries()].sort((a, b) => b[1].count - a[1].count)
-        .map(([k, v]) => [k, { count: v.count, avg: +(v.total / v.count).toFixed(2), max: +v.max.toFixed(2), total: Math.round(v.total) }])
-    ),
-    counters: Object.fromEntries(
-      [...counters.entries()].sort((a, b) => b[1] - a[1])
-    ),
-  }
-}
-
-// ── Internal ──────────────────────────────────────────────────────────
-
-const log = (msg: string) => process.stderr.write(msg + "\n")
-
-// Dump report on exit
-if (enabled) {
-  process.on("exit", report)
-  process.on("SIGINT", () => { report(); process.exit(0) })
-}

package/src/utils/preferences.ts

@@ -1,150 +0,0 @@
-/**
- * Local TUI preferences — persisted to ~/.config/herm/tui.json
- *
- * Compatible with OpenCode's tui.json schema pattern:
- *   - JSON file in XDG config dir
- *   - Optional fields with sensible defaults
- *   - Deep-merged from multiple sources (global → project)
- *   - Read once at startup, written on change
- *
- * Herm-specific extensions (beyond OpenCode compat):
- *   - lastSessionId: resume previous session on startup
- */
-
-import { join } from "path"
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs"
-import { useSyncExternalStore } from "react"
-
-// ─── Schema ──────────────────────────────────────────────────────────
-
-export type DetailMode = "hidden" | "collapsed" | "expanded"
-
-interface TuiPreferences {
-  /** JSON schema reference (for editor autocomplete) */
-  $schema?: string
-  /** Theme name — must match a built-in or custom theme */
-  theme?: string
-  /** Mouse capture enabled */
-  mouse?: boolean
-  /** Target render FPS */
-  targetFps?: number
-
-  // ─── Herm extensions ─────────────────────────────────────────────
-  /** Last active session ID — stub-reuse check on fresh launch */
-  lastSessionId?: string
-  /** Path to a .eikon avatar file for the sidebar */
-  eikonPath?: string
-  /** Spinner/avatar frame animations (off → static glyphs) */
-  animations?: boolean
-  /** Thought-cloud tool trail verbosity */
-  toolDetails?: DetailMode
-  /** User keybinding overrides (ActionId → chord string) */
-  keys?: Record<string, string>
-  /** Clock style for time-of-day formatters */
-  timeFormat?: "12h" | "24h"
-  /** List-column timestamps: "2h ago" vs "14:32" / "May 1" */
-  timeStyle?: "relative" | "absolute"
-}
-
-const DEFAULTS: Required<Pick<TuiPreferences, "mouse" | "targetFps">> = {
-  mouse: true,
-  targetFps: 30,
-}
-
-// ─── Paths ───────────────────────────────────────────────────────────
-
-import { configDir } from "./paths"
-
-function configFile() { return join(configDir(), "tui.json") }
-
-// ─── Load ────────────────────────────────────────────────────────────
-
-let cached: TuiPreferences | null = null
-
-/** Test-only: drop the cached snapshot so the next load() re-reads disk. */
-export function reset(): void {
-  cached = null
-}
-
-/**
- * Load preferences from disk. Returns cached copy on subsequent calls.
- * Never throws — returns defaults on missing/corrupt file.
- */
-export function load(): TuiPreferences {
-  if (cached) return cached
-
-  const CONFIG_FILE = configFile()
-  try {
-    if (!existsSync(CONFIG_FILE)) {
-      const prefs = { ...DEFAULTS }
-      cached = prefs
-      return prefs
-    }
-    const raw = JSON.parse(readFileSync(CONFIG_FILE, "utf-8"))
-    const prefs = { ...DEFAULTS, ...raw }
-    cached = prefs
-    return prefs
-  } catch {
-    const prefs = { ...DEFAULTS }
-    cached = prefs
-    return prefs
-  }
-}
-
-// ─── Save ────────────────────────────────────────────────────────────
-
-/**
- * Persist current preferences to disk.
- * Merges provided partial into existing prefs before writing.
- */
-function save(partial?: Partial<TuiPreferences>): void {
-  const current = load()
-  if (partial) Object.assign(current, partial)
-  cached = current
-
-  try {
-    const CONFIG_DIR = configDir()
-    if (!existsSync(CONFIG_DIR)) {
-      mkdirSync(CONFIG_DIR, { recursive: true })
-    }
-    // Write with sorted keys for stable diffs
-    const json = JSON.stringify(current, null, 2) + "\n"
-    writeFileSync(configFile(), json, "utf-8")
-  } catch (err) {
-    // Silently fail — preferences are non-critical
-    if (process.env.PERF) {
-      console.error("[preferences] failed to save:", err)
-    }
-  }
-}
-
-// ─── Convenience ─────────────────────────────────────────────────────
-
-/** Get a single preference value */
-export function get<K extends keyof TuiPreferences>(key: K): TuiPreferences[K] {
-  return load()[key]
-}
-
-/** Set a single preference value and persist */
-export function set<K extends keyof TuiPreferences>(key: K, value: TuiPreferences[K]): void {
-  save({ [key]: value } as Partial<TuiPreferences>)
-  for (const l of listeners) l()
-}
-
-// ─── Reactive ────────────────────────────────────────────────────────
-
-const listeners = new Set<() => void>()
-
-function subscribe(l: () => void): () => void {
-  listeners.add(l)
-  return () => listeners.delete(l)
-}
-
-/**
- * Subscribe a component to a preference key. Re-renders on set().
- * Writes go through the imperative `set(key, value)` — this hook is
- * read-only by design so writes always persist through one path.
- */
-export function usePref<K extends keyof TuiPreferences>(key: K): TuiPreferences[K] {
-  return useSyncExternalStore(subscribe, () => load()[key])
-}