saeeol 1.1.0 → 1.2.0

package/src/cli/cmd/tui/component/prompt/stash.tsx

@@ -0,0 +1,101 @@
+import path from "path"
+import { Global } from "@saeeol/core/global"
+import { Filesystem } from "@/util/filesystem"
+import { onMount } from "solid-js"
+import { createStore, produce, unwrap } from "solid-js/store"
+import { createSimpleContext } from "../../context/helper"
+import { appendFile, writeFile } from "fs/promises"
+import type { PromptInfo } from "./history"
+
+export type StashEntry = {
+  input: string
+  parts: PromptInfo["parts"]
+  timestamp: number
+}
+
+const MAX_STASH_ENTRIES = 50
+
+export const { use: usePromptStash, provider: PromptStashProvider } = createSimpleContext({
+  name: "PromptStash",
+  init: () => {
+    const stashPath = path.join(Global.Path.state, "prompt-stash.jsonl")
+    onMount(async () => {
+      const text = await Filesystem.readText(stashPath).catch(() => "")
+      const lines = text
+        .split("\n")
+        .filter(Boolean)
+        .map((line) => {
+          try {
+            return JSON.parse(line)
+          } catch {
+            return null
+          }
+        })
+        .filter((line): line is StashEntry => line !== null)
+        .slice(-MAX_STASH_ENTRIES)
+
+      setStore("entries", lines)
+
+      // Rewrite file with only valid entries to self-heal corruption
+      if (lines.length > 0) {
+        const content = lines.map((line) => JSON.stringify(line)).join("\n") + "\n"
+        writeFile(stashPath, content).catch(() => {})
+      }
+    })
+
+    const [store, setStore] = createStore({
+      entries: [] as StashEntry[],
+    })
+
+    return {
+      list() {
+        return store.entries
+      },
+      push(entry: Omit<StashEntry, "timestamp">) {
+        const stash = structuredClone(unwrap({ ...entry, timestamp: Date.now() }))
+        let trimmed = false
+        setStore(
+          produce((draft) => {
+            draft.entries.push(stash)
+            if (draft.entries.length > MAX_STASH_ENTRIES) {
+              draft.entries = draft.entries.slice(-MAX_STASH_ENTRIES)
+              trimmed = true
+            }
+          }),
+        )
+
+        if (trimmed) {
+          const content = store.entries.map((line) => JSON.stringify(line)).join("\n") + "\n"
+          writeFile(stashPath, content).catch(() => {})
+          return
+        }
+
+        appendFile(stashPath, JSON.stringify(stash) + "\n").catch(() => {})
+      },
+      pop() {
+        if (store.entries.length === 0) return undefined
+        const entry = store.entries[store.entries.length - 1]
+        setStore(
+          produce((draft) => {
+            draft.entries.pop()
+          }),
+        )
+        const content =
+          store.entries.length > 0 ? store.entries.map((line) => JSON.stringify(line)).join("\n") + "\n" : ""
+        writeFile(stashPath, content).catch(() => {})
+        return entry
+      },
+      remove(index: number) {
+        if (index < 0 || index >= store.entries.length) return
+        setStore(
+          produce((draft) => {
+            draft.entries.splice(index, 1)
+          }),
+        )
+        const content =
+          store.entries.length > 0 ? store.entries.map((line) => JSON.stringify(line)).join("\n") + "\n" : ""
+        writeFile(stashPath, content).catch(() => {})
+      },
+    }
+  },
+})

package/src/cli/cmd/tui/component/prompt/traits.ts

@@ -0,0 +1,31 @@
+import type { EditorTraits } from "@opentui/core"
+
+export type PromptMode = "normal" | "shell"
+
+export interface PromptTraitsInput {
+  mode: PromptMode
+  disabled: boolean
+  autocompleteVisible: boolean
+}
+
+/**
+ * Compute the textarea editor traits for the prompt.
+ *
+ * `traits.suspend` gates the textarea's keybinding actions (backspace,
+ * delete-word, arrow movement, undo/redo, etc.). Shell mode is an active
+ * editing mode — only `disabled` should suspend the textarea, otherwise
+ * users can type in shell mode but cannot delete or move the cursor.
+ */
+export function computePromptTraits(input: PromptTraitsInput): EditorTraits {
+  const capture =
+    input.mode === "normal"
+      ? input.autocompleteVisible
+        ? (["escape", "navigate", "submit", "tab"] as const)
+        : (["tab"] as const)
+      : undefined
+  return {
+    capture,
+    suspend: input.disabled,
+    status: input.mode === "shell" ? "SHELL" : undefined,
+  }
+}

package/src/cli/cmd/tui/component/prompt/use-extmark-sync.ts

@@ -0,0 +1,93 @@
+import type { TextareaRenderable } from "@opentui/core"
+import { produce, type SetStoreFunction } from "solid-js/store"
+import type { PromptInfo } from "./history"
+import type { StoreShape } from "./use-prompt-store"
+
+export type ExtmarkSyncDeps = {
+  getInput: () => TextareaRenderable
+  setStore: SetStoreFunction<StoreShape>
+  fileStyleId: number
+  agentStyleId: number
+  pasteStyleId: number
+  promptPartTypeId: number
+}
+
+export function restoreExtmarksFromParts(deps: ExtmarkSyncDeps, parts: PromptInfo["parts"]) {
+  const input = deps.getInput()
+  input.extmarks.clear()
+  deps.setStore("extmarkToPartIndex", new Map())
+
+  parts.forEach((part, partIndex) => {
+    let start = 0
+    let end = 0
+    let virtualText = ""
+    let styleId: number | undefined
+
+    if (part.type === "file" && part.source?.text) {
+      start = part.source.text.start
+      end = part.source.text.end
+      virtualText = part.source.text.value
+      styleId = deps.fileStyleId
+    } else if (part.type === "agent" && part.source) {
+      start = part.source.start
+      end = part.source.end
+      virtualText = part.source.value
+      styleId = deps.agentStyleId
+    } else if (part.type === "text" && part.source?.text) {
+      start = part.source.text.start
+      end = part.source.text.end
+      virtualText = part.source.text.value
+      styleId = deps.pasteStyleId
+    }
+
+    if (virtualText) {
+      const extmarkId = input.extmarks.create({
+        start,
+        end,
+        virtual: true,
+        styleId,
+        typeId: deps.promptPartTypeId,
+      })
+      deps.setStore("extmarkToPartIndex", (map: Map<number, number>) => {
+        const newMap = new Map(map)
+        newMap.set(extmarkId, partIndex)
+        return newMap
+      })
+    }
+  })
+}
+
+export function syncExtmarksWithPromptParts(deps: ExtmarkSyncDeps) {
+  const input = deps.getInput()
+  const allExtmarks = input.extmarks.getAllForTypeId(deps.promptPartTypeId)
+  deps.setStore(
+    produce((draft) => {
+      const newMap = new Map<number, number>()
+      const newParts: typeof draft.prompt.parts = []
+
+      for (const extmark of allExtmarks) {
+        const partIndex = draft.extmarkToPartIndex.get(extmark.id)
+        if (partIndex !== undefined) {
+          const part = draft.prompt.parts[partIndex]
+          if (part) {
+            if (part.type === "agent" && part.source) {
+              part.source.start = extmark.start
+              part.source.end = extmark.end
+            } else if (part.type === "file" && part.source?.text) {
+              part.source.text.start = extmark.start
+              part.source.text.end = extmark.end
+            } else if (part.type === "text" && part.source?.text) {
+              part.source.text.start = extmark.start
+              part.source.text.end = extmark.end
+            }
+            newMap.set(extmark.id, newParts.length)
+            newParts.push(part)
+          }
+        }
+      }
+
+      draft.extmarkToPartIndex = newMap
+      draft.prompt.parts = newParts
+    }),
+  )
+}

package/src/cli/cmd/tui/component/prompt/use-prompt-commands.tsx

@@ -0,0 +1,234 @@
+import type { TextareaRenderable } from "@opentui/core"
+import { produce, type SetStoreFunction } from "solid-js/store"
+import { useSDK } from "@tui/context/sdk"
+import { useSync } from "@tui/context/sync"
+import { useDialog } from "@tui/ui/dialog"
+import * as Editor from "@tui/util/editor"
+import { useRenderer } from "@opentui/solid"
+import { DialogSkill } from "../dialog-skill"
+import { DialogStash } from "../dialog-stash"
+import { editorSelectionKey } from "@tui/context/editor"
+import type { PromptInfo } from "./history"
+import type { AutocompleteRef } from "./autocomplete"
+import type { ExtmarkSyncDeps } from "./use-extmark-sync"
+import type { PromptProps } from "."
+import type { StoreShape } from "./use-prompt-store"
+
+export type CommandDeps = {
+  props: PromptProps
+  getInput: () => TextareaRenderable
+  store: StoreShape
+  setStore: SetStoreFunction<StoreShape>
+  autocomplete: () => AutocompleteRef | undefined
+  extmarkSync: ExtmarkSyncDeps
+  restoreExtmarks: (parts: PromptInfo["parts"]) => void
+  submit: () => Promise<boolean>
+  pasteAttachment: (file: { filename?: string; filepath?: string; content: string; mime: string }) => Promise<void>
+  status: () => { type: string }
+  editorContext: () => any
+  stash: { list: () => any[]; push: (entry: any) => void; pop: () => any }
+  command: any
+  history: any
+  lastSubmittedEditorSelectionKey: { value: string | undefined }
+  setDismissedEditorSelectionKey: (v: string | undefined) => void
+  promptPartTypeId: { value: number }
+}
+
+export function usePromptCommands(deps: CommandDeps) {
+  const sdk = useSDK()
+  const sync = useSync()
+  const dialog = useDialog()
+  const renderer = useRenderer()
+
+  function dismissEditorContext() {
+    deps.setDismissedEditorSelectionKey(editorSelectionKey(deps.editorContext()))
+  }
+
+  deps.command.register(() => {
+    return [
+      {
+        title: "Clear prompt",
+        value: "prompt.clear",
+        category: "Prompt",
+        hidden: true,
+        onSelect: (d: any) => {
+          const input = deps.getInput()
+          input.extmarks.clear()
+          input.clear()
+          d.clear()
+        },
+      },
+      {
+        title: "Submit prompt",
+        value: "prompt.submit",
+        keybind: "input_submit",
+        category: "Prompt",
+        hidden: true,
+        onSelect: async (d: any) => {
+          const input = deps.getInput()
+          if (!input.focused) return
+          const handled = await deps.submit()
+          if (!handled) return
+          d.clear()
+        },
+      },
+      {
+        title: "Remove editor context",
+        value: "prompt.editor_context.clear",
+        category: "Prompt",
+        enabled: Boolean(deps.editorContext()),
+        onSelect: (d: any) => {
+          dismissEditorContext()
+          d.clear()
+        },
+      },
+      {
+        title: "Paste",
+        value: "prompt.paste",
+        keybind: "input_paste",
+        category: "Prompt",
+        hidden: true,
+        onSelect: async () => {
+          const Clipboard = await import("../../util/clipboard")
+          const content = await Clipboard.read()
+          if (content?.mime.startsWith("image/")) {
+            await deps.pasteAttachment({ filename: "clipboard", mime: content.mime, content: content.data })
+          }
+        },
+      },
+      {
+        title: "Interrupt session",
+        value: "session.interrupt",
+        keybind: "session_interrupt",
+        category: "Session",
+        hidden: true,
+        enabled: deps.status().type !== "idle",
+        onSelect: (d: any) => {
+          const input = deps.getInput()
+          if (deps.autocomplete()?.visible) return
+          if (!input.focused) return
+          if (deps.store.mode === "shell") {
+            deps.setStore("mode", "normal")
+            return
+          }
+          if (!deps.props.sessionID) return
+          deps.setStore("interrupt", deps.store.interrupt + 1)
+          setTimeout(() => { deps.setStore("interrupt", 0) }, 5000)
+          if (deps.store.interrupt >= 2) {
+            void sdk.client.session.abort({ sessionID: deps.props.sessionID })
+            deps.setStore("interrupt", 0)
+          }
+          d.clear()
+        },
+      },
+      {
+        title: "Open editor",
+        category: "Session",
+        keybind: "editor_open",
+        value: "prompt.editor",
+        slash: { name: "editor" },
+        onSelect: async (d: any) => {
+          d.clear()
+          const input = deps.getInput()
+          const text = deps.store.prompt.parts
+            .filter((p) => p.type === "text")
+            .reduce((acc, p) => { if (!p.source) return acc; return acc.replace(p.source.text.value, p.text) }, deps.store.prompt.input)
+          const nonTextParts = deps.store.prompt.parts.filter((p) => p.type !== "text")
+          const content = await Editor.open({ value: text, renderer })
+          if (!content) return
+          input.setText(content)
+          const updated = nonTextParts.map((part) => {
+            let vt = ""
+            if (part.type === "file" && part.source?.text) vt = part.source.text.value
+            else if (part.type === "agent" && part.source) vt = part.source.value
+            if (!vt) return part
+            const idx = content.indexOf(vt)
+            if (idx === -1) return null
+            const end = idx + vt.length
+            if (part.type === "file" && part.source?.text) return { ...part, source: { ...part.source, text: { ...part.source.text, start: idx, end } } }
+            if (part.type === "agent" && part.source) return { ...part, source: { ...part.source, start: idx, end } }
+            return part
+          }).filter((p) => p !== null)
+          deps.setStore("prompt", { input: content, parts: updated })
+          deps.restoreExtmarks(updated)
+          input.cursorOffset = Bun.stringWidth(content)
+        },
+      },
+      {
+        title: "Skills",
+        value: "prompt.skills",
+        category: "Prompt",
+        slash: { name: "skills" },
+        onSelect: () => {
+          dialog.replace(() => (
+            <DialogSkill
+              onSelect={(skill: string) => {
+                const input = deps.getInput()
+                input.setText(`/${skill} `)
+                deps.setStore("prompt", { input: `/${skill} `, parts: [] })
+                input.gotoBufferEnd()
+              }}
+            />
+          ))
+        },
+      },
+    ]
+  })
+
+  deps.command.register(() => [
+    {
+      title: "Stash prompt",
+      value: "prompt.stash",
+      category: "Prompt",
+      enabled: !!deps.store.prompt.input,
+      onSelect: (d: any) => {
+        if (!deps.store.prompt.input) return
+        const input = deps.getInput()
+        deps.stash.push({ input: deps.store.prompt.input, parts: deps.store.prompt.parts })
+        input.extmarks.clear()
+        input.clear()
+        deps.setStore("prompt", { input: "", parts: [] })
+        deps.setStore("extmarkToPartIndex", new Map())
+        d.clear()
+      },
+    },
+    {
+      title: "Stash pop",
+      value: "prompt.stash.pop",
+      category: "Prompt",
+      enabled: deps.stash.list().length > 0,
+      onSelect: (d: any) => {
+        const entry = deps.stash.pop()
+        if (entry) {
+          const input = deps.getInput()
+          input.setText(entry.input)
+          deps.setStore("prompt", { input: entry.input, parts: entry.parts })
+          deps.restoreExtmarks(entry.parts)
+          input.gotoBufferEnd()
+        }
+        d.clear()
+      },
+    },
+    {
+      title: "Stash list",
+      value: "prompt.stash.list",
+      category: "Prompt",
+      enabled: deps.stash.list().length > 0,
+      onSelect: () => {
+        dialog.replace(() => (
+          <DialogStash
+            onSelect={(entry: any) => {
+              const input = deps.getInput()
+              input.setText(entry.input)
+              deps.setStore("prompt", { input: entry.input, parts: entry.parts })
+              deps.restoreExtmarks(entry.parts)
+              input.gotoBufferEnd()
+            }}
+          />
+        ))
+      },
+    },
+  ])
+
+  return { dismissEditorContext }
+}

package/src/cli/cmd/tui/component/prompt/use-prompt-memos.ts

@@ -0,0 +1,210 @@
+import { createMemo, createSignal } from "solid-js"
+import { RGBA } from "@opentui/core"
+import path from "path"
+import { useLocal } from "@tui/context/local"
+import { tint, useTheme } from "@tui/context/theme"
+import { useSync } from "@tui/context/sync"
+import { useEditorContext, editorSelectionKey, type EditorSelection } from "@tui/context/editor"
+import { useTerminalDimensions } from "@opentui/solid"
+import { useKeybind } from "@tui/context/keybind"
+import { useKV } from "../../context/kv"
+import { clamp } from "@saeeol/boxes/clamp"
+import { Locale } from "@/util/locale"
+import { createFadeIn } from "../../util/signal"
+import { createColors, createFrames } from "../../ui/spinner"
+import type { AssistantMessage } from "@saeeol/sdk/v2"
+import type { PromptProps } from "."
+import type { PromptInfo } from "./history"
+
+export const money = new Intl.NumberFormat("en-US", {
+  style: "currency",
+  currency: "USD",
+})
+
+export function hasEditorRangeSelection(selection: EditorSelection["ranges"][number]) {
+  return (
+    selection.selection.start.line !== selection.selection.end.line ||
+    selection.selection.start.character !== selection.selection.end.character
+  )
+}
+
+export function getEditorRangeLabel(selection: EditorSelection["ranges"][number]) {
+  if (!hasEditorRangeSelection(selection)) return
+  if (selection.selection.start.line === selection.selection.end.line) return `#${selection.selection.start.line}`
+  return `#${selection.selection.start.line}-${selection.selection.end.line}`
+}
+
+export function formatEditorContext(selection: EditorSelection) {
+  const selected = selection.ranges.filter(hasEditorRangeSelection)
+  if (selected.length === 0)
+    return `<system-reminder>Note: The user opened the file "${selection.filePath}". This may or may not be relevant to the current task.</system-reminder>\n`
+  const ranges = selected.map((range, index) => {
+    const prefix = selected.length > 1 ? `Selection ${index + 1}: ` : ""
+    return `Note: The user selected ${prefix}${getEditorRangeLabel(range)} from "${selection.filePath}". \`\`\`${range.text}\`\`\`\n\n`
+  })
+  return `<system-reminder>${ranges.join("\n")} This may or may not be relevant to the current task.</system-reminder>\n`
+}
+
+export type PromptMemos = {
+  status: () => { type: string }
+  usage: () => { context: string; cost?: string; health: string; remaining?: number; pct: number } | undefined
+  currentProviderLabel: () => string
+  hasRightContent: () => boolean
+  editorContext: () => EditorSelection | undefined
+  editorPath: () => string | undefined
+  editorSelectionLabel: () => string | undefined
+  editorFileLabel: () => string | undefined
+  editorFileLabelDisplay: () => string | undefined
+  highlight: () => RGBA
+  showVariant: () => boolean
+  agentMetaAlpha: () => number
+  modelMetaAlpha: () => number
+  variantMetaAlpha: () => number
+  borderHighlight: () => RGBA
+  placeholderText: () => string | undefined
+  spinnerDef: () => { frames: any; color: any }
+  list: () => string[]
+  shell: () => string[]
+  dismissedEditorSelectionKey: () => string | undefined
+  setDismissedEditorSelectionKey: (v: string | undefined) => void
+}
+
+export type MemoDeps = {
+  props: PromptProps
+  store: {
+    prompt: PromptInfo
+    mode: "normal" | "shell"
+    placeholder: number
+  }
+}
+
+export function usePromptMemos(deps: MemoDeps): PromptMemos {
+  const local = useLocal()
+  const sync = useSync()
+  const editor = useEditorContext()
+  const { theme, syntax } = useTheme()
+  const keybind = useKeybind()
+  const dimensions = useTerminalDimensions()
+  const kv = useKV()
+
+  const animationsEnabled = createMemo(() => kv.get("animations_enabled", true))
+  const list = createMemo(() => deps.props.placeholders?.normal ?? [])
+  const shell = createMemo(() => deps.props.placeholders?.shell ?? [])
+  const fileContextEnabled = createMemo(() => kv.get("file_context_enabled", true))
+  const [dismissedEditorSelectionKey, setDismissedEditorSelectionKey] = createSignal<string>()
+
+  const status = createMemo(() => sync.data.session_status?.[deps.props.sessionID ?? ""] ?? { type: "idle" })
+
+  const editorContext = createMemo(() => {
+    const selection = fileContextEnabled() ? editor.selection() : undefined
+    if (!selection) return
+    return editorSelectionKey(selection) === dismissedEditorSelectionKey() ? undefined : selection
+  })
+
+  const editorPath = createMemo(() => editorContext()?.filePath)
+  const editorSelectionLabel = createMemo(() => {
+    const ranges = editorContext()?.ranges
+    if (!ranges) return
+    const first = ranges.find(hasEditorRangeSelection) ?? ranges[0]
+    if (!first) return
+    return [getEditorRangeLabel(first), ranges.length > 1 ? `+${ranges.length - 1}` : undefined]
+      .filter(Boolean)
+      .join(" ")
+  })
+  const editorFileLabel = createMemo(() => {
+    const value = editorPath()
+    if (!value) return
+    const filename = path.basename(value)
+    const file = /^index\.[^./]+$/.test(filename)
+      ? [path.basename(path.dirname(value)), filename].filter(Boolean).join("/")
+      : filename
+    return `${file.split(path.sep).join("/")}${editorSelectionLabel() ?? ""}`
+  })
+  const editorFileLabelDisplay = createMemo(() => {
+    const file = editorFileLabel()
+    if (!file) return
+    return Locale.truncateMiddle(file, clamp(Math.floor(dimensions().width / 3), 12, 48))
+  })
+  const currentProviderLabel = createMemo(() => local.model.parsed().provider)
+  const hasRightContent = createMemo(() => Boolean(deps.props.right))
+
+  const lastUserMessage = createMemo(() => {
+    if (!deps.props.sessionID) return undefined
+    const messages = sync.data.message[deps.props.sessionID]
+    if (!messages) return undefined
+    return messages.findLast((m): m is import("@saeeol/sdk/v2").UserMessage => m.role === "user")
+  })
+
+  const usage = createMemo(() => {
+    if (!deps.props.sessionID) return
+    const msg = sync.data.message[deps.props.sessionID] ?? []
+    const last = msg.findLast((item): item is AssistantMessage => item.role === "assistant" && item.tokens.output > 0)
+    if (!last) return
+    const tokens = last.tokens.input + last.tokens.output + last.tokens.reasoning + last.tokens.cache.read + last.tokens.cache.write
+    if (tokens <= 0) return
+    const model = sync.data.provider.find((item) => item.id === last.providerID)?.models?.[last.modelID]
+    const contextLimit = model?.limit.context ?? 0
+    const pct = contextLimit ? Math.round((tokens / contextLimit) * 100) : 0
+    const cost = msg.reduce((sum, item) => sum + (item.role === "assistant" ? item.cost : 0), 0)
+    const health = !contextLimit ? "ok" : pct >= 90 ? "critical" : pct >= 75 ? "warning" : "ok"
+    const remaining = contextLimit ? Math.max(0, contextLimit - tokens) : undefined
+    return {
+      context: contextLimit ? `${Locale.number(tokens)} (${pct}%)` : Locale.number(tokens),
+      cost: cost > 0 ? money.format(cost) : undefined,
+      health,
+      remaining,
+      pct,
+    }
+  })
+
+  const highlight = createMemo(() => {
+    if (keybind.leader) return theme.border
+    if (deps.store.mode === "shell") return theme.primary
+    const agent = local.agent.current()
+    if (!agent) return theme.border
+    return local.agent.color(agent.name ?? "")
+  })
+
+  const showVariant = createMemo(() => {
+    const variants = local.model.variant.list()
+    if (variants.length === 0) return false
+    const current = local.model.variant.current()
+    return !!current
+  })
+
+  const agentMetaAlpha = createFadeIn(() => !!local.agent.current(), animationsEnabled)
+  const modelMetaAlpha = createFadeIn(() => !!local.agent.current() && deps.store.mode === "normal", animationsEnabled)
+  const variantMetaAlpha = createFadeIn(
+    () => !!local.agent.current() && deps.store.mode === "normal" && showVariant(),
+    animationsEnabled,
+  )
+  const borderHighlight = createMemo(() => tint(theme.border, highlight(), agentMetaAlpha()))
+
+  const placeholderText = createMemo(() => {
+    if (deps.props.showPlaceholder === false) return undefined
+    if (deps.store.mode === "shell") {
+      if (!shell().length) return undefined
+      const example = shell()[deps.store.placeholder % shell().length]
+      return `Run a command... "${example}"`
+    }
+    if (!list().length) return undefined
+    return `Ask anything... "${list()[deps.store.placeholder % list().length]}"`
+  })
+
+  const spinnerDef = createMemo(() => {
+    const agent = local.agent.current()
+    const color = agent ? local.agent.color(agent.name ?? "") : theme.border
+    return {
+      frames: createFrames({ color, style: "blocks", inactiveFactor: 0.6, minAlpha: 0.3 }),
+      color: createColors({ color, style: "blocks", inactiveFactor: 0.6, minAlpha: 0.3 }),
+    }
+  })
+
+  return {
+    status, usage, currentProviderLabel, hasRightContent,
+    editorContext, editorPath, editorSelectionLabel, editorFileLabel, editorFileLabelDisplay,
+    highlight, showVariant, agentMetaAlpha, modelMetaAlpha, variantMetaAlpha,
+    borderHighlight, placeholderText, spinnerDef, list, shell,
+    dismissedEditorSelectionKey, setDismissedEditorSelectionKey,
+  }
+}