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

package/src/app/gatewayEvents.ts

@@ -1,203 +0,0 @@
-// Maps a GatewayEvent to a turn-reducer Action plus fire-and-forget side effects.
-
-import * as perf from "../utils/perf"
-import * as spawnHistory from "./spawnHistory"
-import type { GatewayEvent, GatewaySkin, SessionInfo } from "../utils/gateway-types"
-import type { Action } from "./turnReducer"
-import { pid, type Usage } from "../types/message"
-
-export type Side = {
-  onReady?: () => void
-  onSessionInfo?: (info: SessionInfo) => void
-  onUsage?: (u: Usage) => void
-  onTurnComplete?: () => void
-  onBackground?: (task_id: string, text: string) => void
-  onBtw?: (text: string) => void
-  onStatus?: (text: string) => void
-  onSkin?: (skin: GatewaySkin | null | undefined) => void
-}
-
-function count(o: Record<string, string[]> | undefined): number {
-  return o ? Object.values(o).reduce((n, v) => n + v.length, 0) : 0
-}
-
-export function mapEvent(ev: GatewayEvent, side: Side): Action | null {
-  switch (ev.type) {
-    case "gateway.ready":
-      side.onReady?.()
-      if (ev.payload?.skin) side.onSkin?.(ev.payload.skin)
-      return null
-
-    case "session.info": {
-      const si = ev.payload
-      side.onSessionInfo?.(si)
-      const label = si.model
-        ? `Connected — ${si.model} · ${count(si.tools)} tools · ${count(si.skills)} skills`
-        : "Connected to Hermes"
-      if (si.credential_warning) side.onStatus?.(si.credential_warning)
-      return { kind: "system", text: label }
-    }
-
-    case "message.start":
-      perf.count("stream:start")
-      perf.mem("stream-start")
-      return { kind: "message.start" }
-
-    case "message.delta": {
-      const chunk = ev.payload?.text ?? ""
-      if (!chunk) return null
-      perf.count("stream:chunk")
-      return { kind: "message.delta", chunk }
-    }
-
-    case "message.complete": {
-      perf.count("stream:done")
-      perf.mem("stream-done")
-      const p = ev.payload
-      if (p?.usage) side.onUsage?.(p.usage)
-      side.onTurnComplete?.()
-      // The gateway reports in-agent failures via status (exceptions come
-      // as a separate `error` event). Without this branch a failed API
-      // call ends the turn with no visible output.
-      if (p?.status === "error")
-        return { kind: "error", text: p.text || "request failed — see messages above" }
-      if (p?.status === "interrupted")
-        return { kind: "message.complete", text: (p.text || "") + "\n\n*[interrupted]*", usage: p?.usage }
-      return { kind: "message.complete", text: p?.text ?? undefined, usage: p?.usage }
-    }
-
-    case "tool.start":
-      return {
-        kind: "tool.start",
-        id: ev.payload.tool_id,
-        name: ev.payload.name ?? "unknown",
-        preview: ev.payload.context,
-      }
-
-    case "tool.progress":
-      return { kind: "tool.progress", name: ev.payload.name, preview: ev.payload.preview }
-
-    case "tool.generating":
-      return { kind: "tool.generating", name: ev.payload.name }
-
-    case "tool.complete":
-      return {
-        kind: "tool.complete",
-        id: ev.payload.tool_id,
-        summary: ev.payload.summary,
-        error: ev.payload.error,
-        inline_diff: ev.payload.inline_diff,
-      }
-
-    case "thinking.delta":
-      // Cosmetic spinner text from the agent's status line, not model
-      // reasoning. Surface as transient status only.
-      side.onStatus?.(ev.payload?.text ?? "")
-      return null
-
-    case "reasoning.delta":
-    case "reasoning.available": {
-      const text = ev.payload?.text
-      if (!text) return null
-      return { kind: "thinking", text, final: ev.type === "reasoning.available" }
-    }
-
-    case "subagent.start":
-    case "subagent.thinking":
-    case "subagent.tool":
-    case "subagent.progress":
-    case "subagent.complete": {
-      const sub = ev.type.slice(9) as "start" | "thinking" | "tool" | "progress" | "complete"
-      // Feed the turn-wide accumulator so the completed tree can be
-      // persisted (spawn_tree.save) and the Agents tab can read live
-      // tool trails without its own event listener.
-      spawnHistory.record(sub, ev.payload)
-      return { kind: "subagent", event: sub, payload: ev.payload }
-    }
-
-    case "error":
-      return { kind: "error", text: ev.payload?.message ?? "Unknown error" }
-
-    case "clarify.request":
-      return { kind: "prompt", id: ev.payload.request_id,
-               req: { variant: "clarify", ...ev.payload } }
-
-    case "approval.request":
-      // Approval has no request_id upstream — the gateway's approval
-      // responder is a single pending slot. Mint a unique part id so
-      // multiple approvals in one turn don't alias each other when
-      // prompt.answered updates by id.
-      return { kind: "prompt", id: `approval-${pid()}`,
-               req: { variant: "approval", ...ev.payload } }
-
-    case "sudo.request":
-      return { kind: "prompt", id: ev.payload.request_id,
-               req: { variant: "sudo", ...ev.payload } }
-
-    case "secret.request":
-      return { kind: "prompt", id: ev.payload.request_id,
-               req: { variant: "secret", ...ev.payload } }
-
-    case "background.complete":
-      side.onBackground?.(ev.payload.task_id, ev.payload.text)
-      return null
-
-    case "review.summary": {
-      // Self-improvement background review saved a skill patch or
-      // memory entry. Upstream tui_gateway emits this so clients can
-      // surface the mutation — without it, the file change happens
-      // silently. Python side already formats the text with a 💾
-      // prefix, so we pass through verbatim (trimmed). Guard blank
-      // payloads: upstream does the same, and a blank system line is
-      // noise. No toast — these fire stochastically post-turn and
-      // per-event toasting would spam.
-      const text = String(ev.payload?.text ?? "").trim()
-      if (!text) return null
-      return { kind: "system", text }
-    }
-
-    case "btw.complete":
-      side.onBtw?.(ev.payload.text)
-      return null
-
-    case "gateway.stderr": {
-      // Error-ish stderr lines (tracebacks, HTTP 4xx/5xx, auth failures)
-      // surface inline; benign chatter stays in gw.tail() only (/logs).
-      const line = ev.payload.line
-      if (/error|fail|traceback|exception|\b[45]\d\d\b|refused|denied|unauthori/i.test(line))
-        return { kind: "system", text: line.slice(0, 200) }
-      return null
-    }
-
-    case "skin.changed":
-      side.onSkin?.(ev.payload)
-      return null
-
-    case "gateway.start_timeout":
-      return { kind: "error", text: `gateway startup timed out (${ev.payload?.python ?? "python"} @ ${ev.payload?.cwd ?? "?"})` }
-
-    case "gateway.protocol_error":
-      return { kind: "system", text: `protocol error: ${ev.payload?.preview ?? "?"}` }
-
-    case "browser.progress": {
-      // Streamed during /browser connect (upstream e75082901). Surface as
-      // transcript rows so long CDP attach work isn't a 60s black box.
-      const text = ev.payload?.message ?? ""
-      if (!text) return null
-      return ev.payload?.level === "error"
-        ? { kind: "error", text }
-        : { kind: "system", text: `· ${text}` }
-    }
-
-    case "status.update": {
-      const kind = ev.payload?.kind
-      const text = ev.payload?.text ?? ""
-      side.onStatus?.(text)
-      // Generic "status" is cosmetic; lifecycle/error/warn carry real
-      // signal (retries, fallbacks, auth failures) and must persist.
-      if (!kind || kind === "status") return null
-      return { kind: "system", text }
-    }
-  }
-  return null
-}

package/src/app/launch.ts

@@ -1,41 +0,0 @@
-// Launch intent parsed from argv before the renderer starts.
-// Bare `herm` → fresh session (splash shows continue-prompt).
-// `-c` / `--continue` / `--resume [id]` → resume, no splash.
-
-import pkg from "../../package.json" with { type: "json" }
-
-export const VERSION = pkg.version
-
-export type Launch =
-  | { mode: "new"; splash?: boolean }
-  | { mode: "resume"; sid?: string }
-
-/** Parse process argv (everything after the script path). No deps. */
-export function parseLaunch(argv: readonly string[]): Launch {
-  let splash = true
-  for (let i = 0; i < argv.length; i++) {
-    const a = argv[i]
-    if (a === "--no-splash") { splash = false; continue }
-    if (a === "-c" || a === "--continue") return { mode: "resume" }
-    if (a === "--resume") {
-      const next = argv[i + 1]
-      // Treat a following non-flag token as the session id.
-      return next && !next.startsWith("-")
-        ? { mode: "resume", sid: next }
-        : { mode: "resume" }
-    }
-  }
-  return { mode: "new", splash }
-}
-
-export const HELP = `\
-herm — OpenTUI client for hermes-agent
-
-Usage:
-  herm                    start a fresh session
-  herm -c, --continue     resume the last real TUI session
-  herm --resume [id]      resume last (or the given) session
-  herm --no-splash        skip the launch splash
-  herm -v, --version      print version
-  herm -h, --help         show this help
-`

package/src/app/skin.tsx

@@ -1,31 +0,0 @@
-// Active Hermes skin — branding strings surfaced to UI.
-// The gateway emits skin.changed with the full skin payload;
-// app.tsx reduces it into this context. Consumers read agentName
-// (message headers, announcements) and the raw branding map for
-// future needs (prompt_symbol, welcome, etc.).
-
-import { createContext, useContext, memo, type ReactNode } from "react"
-import type { GatewaySkin } from "../utils/gateway-types"
-
-export type SkinState = {
-  skin?: GatewaySkin
-  /** Preferred display label for the assistant in chat. */
-  agentName: string
-}
-
-const DEFAULT: SkinState = { agentName: "Hermes" }
-
-const Ctx = createContext<SkinState>(DEFAULT)
-
-export function deriveSkin(skin?: GatewaySkin | null): SkinState {
-  const name = skin?.branding?.agent_name?.trim()
-  return { skin: skin ?? undefined, agentName: name || "Hermes" }
-}
-
-export const SkinProvider = memo(({ value, children }: { value: SkinState; children: ReactNode }) => (
-  <Ctx.Provider value={value}>{children}</Ctx.Provider>
-))
-
-export function useSkin(): SkinState {
-  return useContext(Ctx)
-}

package/src/app/spawnHistory.ts

@@ -1,75 +0,0 @@
-// Accumulates subagent.* events across a turn so the completed spawn
-// tree can be persisted via `spawn_tree.save` and later browsed with
-// `spawn_tree.list`/`load`. The accumulator is module-level (one turn
-// runs at a time per session); `flush()` is called from the app-level
-// onTurnComplete side-effect.
-
-import type { Gateway } from "./gateway"
-import type { SubagentPayload, SpawnSubagent } from "../utils/gateway-types"
-
-type Event = "start" | "thinking" | "tool" | "progress" | "complete"
-
-const TRAIL_MAX = 20
-const acc = new Map<string, SpawnSubagent>()
-
-export function record(ev: Event, p: SubagentPayload): void {
-  const id = p.subagent_id
-  if (!id) return
-  const now = Date.now() / 1000
-
-  if (ev === "start") {
-    acc.set(id, {
-      subagent_id: id,
-      parent_id: p.parent_id ?? null,
-      depth: p.depth ?? 0,
-      goal: p.goal,
-      model: p.model,
-      started_at: now,
-      tool_count: 0,
-      status: "running",
-      trail: [],
-    })
-    return
-  }
-
-  const r = acc.get(id)
-  if (!r) return
-
-  if (ev === "tool" && p.tool_name) {
-    r.tool_count++
-    r.trail = [...(r.trail ?? []), { name: p.tool_name, preview: p.tool_preview }].slice(-TRAIL_MAX)
-    return
-  }
-
-  if (ev === "complete") {
-    r.status = p.status ?? "completed"
-    r.finished_at = now
-    r.input_tokens = p.input_tokens
-    r.output_tokens = p.output_tokens
-    r.cost_usd = p.cost_usd
-  }
-}
-
-/** Live read for the Agents-tab detail panel (running children only). */
-export function trail(id: string): ReadonlyArray<{ name: string; preview?: string }> {
-  return acc.get(id)?.trail ?? []
-}
-
-/** Persist the turn's tree (best-effort) and clear the accumulator. */
-export function flush(gw: Gateway, sessionId: string): void {
-  if (acc.size === 0) return
-  const subagents = [...acc.values()]
-  acc.clear()
-
-  const roots = subagents.filter(s => s.parent_id == null)
-  const label = (roots.slice(0, 2).map(s => s.goal).join(" · ") || `${subagents.length} subagents`).slice(0, 120)
-  const started = Math.min(...subagents.map(s => s.started_at))
-
-  gw.request("spawn_tree.save", {
-    session_id: sessionId,
-    label,
-    started_at: started,
-    finished_at: Date.now() / 1000,
-    subagents,
-  }).catch(() => {})
-}

package/src/app/tabs.ts

@@ -1,23 +0,0 @@
-export const TABS = [
-  { name: "Chat",      description: "Main chat interface" },
-  { name: "Context",   description: "Context and session info" },
-  { name: "Sessions",  description: "Session history" },
-  { name: "Agents",    description: "Profiles and running subagents" },
-  { name: "Analytics", description: "Token usage and costs" },
-  { name: "Skills",    description: "Installed skills browser" },
-  { name: "Cron",      description: "Scheduled job manager" },
-  { name: "Toolsets",  description: "Available toolsets manager" },
-  { name: "Config",    description: "Configuration editor" },
-  { name: "Env",       description: "API keys & env variables" },
-  { name: "Memory",    description: "Agent memory browser" },
-  { name: "Kanban",    description: "Multi-agent task board" },
-] as const
-
-export const TAB_MAX = TABS.length - 1
-export const CHAT_TAB = 0
-
-/** Slash-command names that jump to a tab (F5.3). */
-export const TAB_SLASH: Record<string, number> = Object.fromEntries(
-  TABS.map((t, i) => [t.name.toLowerCase(), i]),
-)
-TAB_SLASH.insights = TAB_SLASH.analytics