saeeol 1.4.2 → 1.4.4

package/src/overlay/components/model-info-panel.tsx

@@ -1,149 +0,0 @@
-import { TextAttributes } from "@opentui/core"
-import { useTerminalDimensions } from "@opentui/solid"
-import { createMemo, Show } from "solid-js"
-import { useTheme } from "@tui/context/theme"
-import type { Model } from "@saeeol/sdk/v2"
-import { avgPrice, fmtCachedPrice, fmtContext, fmtDate, fmtPrice } from "./model-info-panel-utils"
-
-interface Props {
-  model: Model
-  provider: string
-}
-
-export function ModelInfoPanel(props: Props) {
-  const { theme } = useTheme()
-  const m = () => props.model
-  const dimensions = useTerminalDimensions()
-
-  const maxHeight = createMemo(() => Math.floor(dimensions().height / 2) - 3)
-
-  const cost = () => m().cost
-  const cached = () => (cost() ? fmtCachedPrice(cost()) : null)
-  const avg = () => (cost() ? avgPrice(cost()) : undefined)
-  const caps = () => m().capabilities
-  const inputs = () => caps()?.input
-  const outputs = () => caps()?.output
-  const activeInputModalities = () => {
-    if (!inputs()) return [] as string[]
-    return Object.entries(inputs())
-      .filter(([k, v]) => v && k !== "text")
-      .map(([k]) => k.charAt(0).toUpperCase() + k.slice(1))
-  }
-  const activeOutputModalities = () => {
-    if (!outputs()) return [] as string[]
-    return Object.entries(outputs())
-      .filter(([k, v]) => v && k !== "text")
-      .map(([k]) => k.charAt(0).toUpperCase() + k.slice(1))
-  }
-  const inputLine = () => {
-    const mods = activeInputModalities()
-    return mods.length > 0 ? `In: ${mods.join(", ")}` : null
-  }
-  const outputLine = () => {
-    const mods = activeOutputModalities()
-    return mods.length > 0 ? `Out: ${mods.join(", ")}` : null
-  }
-  const desc = () => {
-    const d = m().options?.description
-    return typeof d === "string" && d.trim() ? d : null
-  }
-
-  return (
-    <box
-      width={30}
-      border={["left"]}
-      borderColor={theme.border}
-      paddingLeft={2}
-      paddingRight={2}
-      paddingTop={1}
-      gap={1}
-      flexShrink={0}
-    >
-      <scrollbox maxHeight={maxHeight()} paddingRight={1}>
-        <box>
-          <text fg={theme.text} attributes={TextAttributes.BOLD}>
-            {m().name ?? m().id ?? "Model"}
-          </text>
-          <text fg={theme.textMuted}>{props.provider ?? m().providerID ?? ""}</text>
-        </box>
-        <Show when={m().isFree}>
-          <box>
-            <text fg={theme.text}>Free</text>
-          </box>
-        </Show>
-        <Show when={m().family}>
-          <box flexDirection="row" justifyContent="space-between">
-            <text fg={theme.textMuted}>Family</text>
-            <text fg={theme.text}>{m().family!.charAt(0).toUpperCase() + m().family!.slice(1)}</text>
-          </box>
-        </Show>
-        <Show when={m().release_date}>
-          <box flexDirection="row" justifyContent="space-between">
-            <text fg={theme.textMuted}>Released</text>
-            <text fg={theme.text}>{fmtDate(m().release_date)}</text>
-          </box>
-        </Show>
-        <Show when={!m().isFree}>
-          <box>
-            <box flexDirection="row" justifyContent="space-between">
-              <text fg={theme.textMuted}>Input</text>
-              <text fg={theme.text}>{m() ? fmtPrice(m().cost.input) : "—"}</text>
-            </box>
-            <box flexDirection="row" justifyContent="space-between">
-              <text fg={theme.textMuted}>Output</text>
-              <text fg={theme.text}>{m() ? fmtPrice(m().cost.output) : "—"}</text>
-            </box>
-            <Show when={cached()}>
-              <box flexDirection="row" justifyContent="space-between">
-                <text fg={theme.textMuted}>Cached</text>
-                <text fg={theme.text}>{cached()}</text>
-              </box>
-            </Show>
-            <Show when={avg() !== undefined}>
-              <box flexDirection="row" justifyContent="space-between">
-                <text fg={theme.textMuted}>Avg Cost</text>
-                <text fg={theme.text}>{m() ? fmtPrice(avg()!) : "—"}</text>
-              </box>
-            </Show>
-            <box flexDirection="row" justifyContent="space-between">
-              <text fg={theme.textMuted}>Context</text>
-              <text fg={theme.text}>{m() ? fmtContext(m().limit.context) : "—"}</text>
-            </box>
-          </box>
-        </Show>
-        <Show when={caps()?.reasoning || inputLine() || outputLine()}>
-          <box flexDirection="column">
-            <Show when={caps()?.reasoning}>
-              <box flexDirection="row" justifyContent="space-between">
-                <text fg={theme.textMuted}>Reasoning</text>
-                <text fg={theme.text}>Yes</text>
-              </box>
-            </Show>
-            <Show when={inputLine()}>
-              {(line) => (
-                <box flexDirection="row" justifyContent="space-between">
-                  <text fg={theme.textMuted}>Caps</text>
-                  <text fg={theme.text}>{line().replace(/^In:\s*/, "")}</text>
-                </box>
-              )}
-            </Show>
-            <Show when={outputLine()}>
-              {(line) => (
-                <box flexDirection="row" justifyContent="space-between">
-                  <text fg={theme.textMuted}>Out</text>
-                  <text fg={theme.text}>{line().replace(/^Out:\s*/, "")}</text>
-                </box>
-              )}
-            </Show>
-          </box>
-        </Show>
-        <Show when={desc()}>
-          <text fg={theme.textMuted}> </text>
-          <text fg={theme.textMuted} width={23}>
-            {desc()}
-          </text>
-        </Show>
-      </scrollbox>
-    </box>
-  )
-}

package/src/overlay/components/news.tsx

@@ -1,64 +0,0 @@
-/**
- * Saeeol News Component
- *
- * Self-contained component that fetches and displays Saeeol news/notifications.
- * Shows a banner on the home screen; clicking opens a dialog with all news items.
- */
-
-import { createEffect, createMemo, createSignal, on, Show } from "solid-js"
-import { useSync } from "@tui/context/sync"
-import { useSDK } from "@tui/context/sdk"
-import { useDialog } from "@tui/ui/dialog"
-import type { SaeeolNotification } from "@saeeol/gateway"
-import { NotificationBanner } from "./notification-banner.js"
-import { DialogNotifications } from "./dialog-notifications.js"
-
-export function SaeeolNews() {
-  const sync = useSync()
-  const sdk = useSDK()
-  const dialog = useDialog()
-
-  const [notifications, setNotifications] = createSignal<SaeeolNotification[]>([])
-  const [fetched, setFetched] = createSignal(false)
-  const isSaeeolConnected = createMemo(() => sync.data.provider_next.connected.includes("saeeol"))
-
-  const openNewsDialog = () => {
-    const items = notifications()
-    if (items.length > 0) {
-      dialog.replace(() => <DialogNotifications notifications={items} />)
-    }
-  }
-
-  // Reactively wait for sync to complete, then fetch notifications once
-  createEffect(
-    on(
-      () => sync.status,
-      async (status) => {
-        if (status !== "complete") return
-        if (fetched()) return
-        setFetched(true)
-
-        if (!isSaeeolConnected()) return
-
-        const result = await sdk.client.saeeol.notifications()
-        const items = result.data?.filter(({ showIn }: SaeeolNotification) => !showIn || showIn.includes("cli"))
-        if (items && items.length > 0) {
-          setNotifications(items)
-        }
-      },
-    ),
-  )
-
-  // Always render the container to reserve layout space and prevent shift.
-  // The banner content appears once notifications are loaded; the fixed-height
-  // placeholder keeps the surrounding elements stable during the async fetch.
-  return (
-    <Show when={notifications().length > 0} fallback={<box height={3} />}>
-      <NotificationBanner
-        notification={notifications()[0]}
-        totalCount={notifications().length}
-        onClick={openNewsDialog}
-      />
-    </Show>
-  )
-}

package/src/overlay/components/notification-banner.tsx

@@ -1,58 +0,0 @@
-/**
- * Saeeol Notification Banner
- *
- * Displays a notification teaser on the home screen.
- * Clicking opens the full notifications dialog.
- *
- * Layout:
- *   ● Title (N new)
- *     Message text with word wrap...
- */
-
-import { createSignal, Show } from "solid-js"
-import { useTheme } from "@tui/context/theme"
-import type { SaeeolNotification } from "@saeeol/gateway"
-
-interface NotificationBannerProps {
-  notification: SaeeolNotification
-  totalCount: number
-  onClick?: () => void
-}
-
-export function NotificationBanner(props: NotificationBannerProps) {
-  const { theme } = useTheme()
-  const [hover, setHover] = createSignal(false)
-
-  return (
-    <box
-      flexDirection="column"
-      maxWidth="100%"
-      backgroundColor={hover() ? theme.backgroundElement : undefined}
-      onMouseOver={() => setHover(true)}
-      onMouseOut={() => setHover(false)}
-      onMouseUp={props.onClick}
-    >
-      {/* Line 1: Icon + Title + Count */}
-      <box flexDirection="row" gap={1}>
-        <text flexShrink={0} style={{ fg: hover() ? theme.primary : theme.info }}>
-          ●
-        </text>
-        <text wrapMode="none" style={{ fg: hover() ? theme.primary : theme.text }}>
-          {props.notification.title}
-        </text>
-        <Show when={props.totalCount > 1}>
-          <text flexShrink={0} style={{ fg: hover() ? theme.primary : theme.textMuted }}>
-            ({props.totalCount} new)
-          </text>
-        </Show>
-      </box>
-
-      {/* Line 2: Message (indented to align under title) */}
-      <box paddingLeft={2}>
-        <text style={{ fg: hover() ? theme.text : theme.textMuted }} wrapMode="word">
-          {props.notification.message}
-        </text>
-      </box>
-    </box>
-  )
-}

package/src/overlay/components/session-indexing.tsx

@@ -1,30 +0,0 @@
-import { createMemo, Show } from "solid-js"
-import { useSync } from "@tui/context/sync"
-import { useTheme } from "@tui/context/theme"
-import { indexingEnabled } from "../indexing-feature"
-import { formatIndexingLabel } from "../indexing-label"
-import type { IndexingStatusState } from "@saeeol/indexing/status"
-
-function tone(state: IndexingStatusState, theme: ReturnType<typeof useTheme>["theme"]) {
-  if (state === "Complete") return theme.success
-  if (state === "Error") return theme.error
-  if (state === "In Progress") return theme.warning
-  if (state === "Standby") return theme.textMuted
-  return theme.textMuted
-}
-
-export function SessionIndexing() {
-  const { theme } = useTheme()
-  const sync = useSync()
-  const enabled = createMemo(() => indexingEnabled(sync.data.config))
-  const indexing = createMemo(() => sync.data.indexing)
-  const label = createMemo(() => formatIndexingLabel(indexing()))
-
-  return (
-    <Show when={enabled()}>
-      <box flexShrink={0} flexDirection="row" paddingLeft={2} paddingRight={2}>
-        <text fg={tone(indexing().state, theme)}>{label().slice(0, 48)}</text>
-      </box>
-    </Show>
-  )
-}

package/src/overlay/components/tips.tsx

@@ -1,119 +0,0 @@
-import { For } from "solid-js"
-import { DEFAULT_THEMES, useTheme } from "@tui/context/theme"
-
-const themeCount = Object.keys(DEFAULT_THEMES).length
-const themeTip = `Use {highlight}/themes{/highlight} or {highlight}Ctrl+X T{/highlight} to switch between ${themeCount} built-in themes`
-
-type TipPart = { text: string; highlight: boolean }
-
-function parse(tip: string): TipPart[] {
-  const parts: TipPart[] = []
-  const regex = /\{highlight\}(.*?)\{\/highlight\}/g
-  const found = Array.from(tip.matchAll(regex))
-  const state = found.reduce(
-    (acc, match) => {
-      const start = match.index ?? 0
-      if (start > acc.index) {
-        acc.parts.push({ text: tip.slice(acc.index, start), highlight: false })
-      }
-      acc.parts.push({ text: match[1], highlight: true })
-      acc.index = start + match[0].length
-      return acc
-    },
-    { parts, index: 0 },
-  )
-
-  if (state.index < tip.length) {
-    parts.push({ text: tip.slice(state.index), highlight: false })
-  }
-
-  return parts
-}
-
-export function Tips(props: { tip?: string }) {
-  const theme = useTheme().theme
-  const parts = parse(props.tip ?? TIPS[Math.floor(Math.random() * TIPS.length)])
-
-  return (
-    <box flexDirection="row" maxWidth="100%">
-      <text flexShrink={0} style={{ fg: theme.warning }}>
-        ● Tip{" "}
-      </text>
-      <text flexShrink={1}>
-        <For each={parts}>
-          {(part) => <span style={{ fg: part.highlight ? theme.text : theme.textMuted }}>{part.text}</span>}
-        </For>
-      </text>
-    </box>
-  )
-}
-
-// Curated tips for Saeeol CLI
-const TIPS = [
-  "Type {highlight}@{/highlight} followed by a filename to fuzzy search and attach files",
-  "Start a message with {highlight}!{/highlight} to run shell commands directly (e.g., {highlight}!ls -la{/highlight})",
-  "Press {highlight}Tab{/highlight} to cycle between Code and Plan agents",
-  "Use {highlight}/undo{/highlight} to revert the last message and file changes",
-  "Use {highlight}/redo{/highlight} to restore previously undone messages and file changes",
-  "Drag and drop images into the terminal to add them as context",
-  "Press {highlight}Ctrl+V{/highlight} to paste images from your clipboard into the prompt",
-  "Press {highlight}Ctrl+X E{/highlight} or {highlight}/editor{/highlight} to compose messages in your external editor",
-  "Run {highlight}/init{/highlight} to auto-generate project rules based on your codebase",
-  "Run {highlight}/models{/highlight} or {highlight}Ctrl+X M{/highlight} to see and switch between available AI models",
-  themeTip,
-  "Press {highlight}Ctrl+X N{/highlight} or {highlight}/new{/highlight} to start a fresh conversation session",
-  "Use {highlight}/sessions{/highlight} or {highlight}Ctrl+X L{/highlight} to list and continue previous conversations",
-  "Run {highlight}/compact{/highlight} to summarize long sessions near context limits",
-  "Press {highlight}Ctrl+X X{/highlight} or {highlight}/export{/highlight} to save the conversation as Markdown",
-  "Press {highlight}Ctrl+X Y{/highlight} to copy the assistant's last message to clipboard",
-  "Press {highlight}Ctrl+P{/highlight} to see all available actions and commands",
-  "Run {highlight}/connect{/highlight} to add API keys for 75+ supported LLM providers",
-  "The leader key is {highlight}Ctrl+X{/highlight}; combine with other keys for quick actions",
-  "Press {highlight}F2{/highlight} to quickly switch between recently used models",
-  "Press {highlight}Ctrl+X B{/highlight} to show/hide the sidebar panel",
-  "Use {highlight}PageUp{/highlight}/{highlight}PageDown{/highlight} to navigate through conversation history",
-  "Press {highlight}Ctrl+G{/highlight} or {highlight}Home{/highlight} to jump to the beginning of the conversation",
-  "Press {highlight}Ctrl+Alt+G{/highlight} or {highlight}End{/highlight} to jump to the most recent message",
-  "Press {highlight}Shift+Enter{/highlight} or {highlight}Ctrl+J{/highlight} to add newlines in your prompt",
-  "Press {highlight}Ctrl+C{/highlight} when typing to clear the input field",
-  "Press {highlight}Escape{/highlight} to stop the AI mid-response",
-  "Switch to {highlight}Plan{/highlight} agent to get suggestions without making actual changes",
-  "Use {highlight}@agent-name{/highlight} in prompts to invoke specialized subagents",
-  "Press {highlight}Ctrl+X Right/Left{/highlight} to cycle through parent and child sessions",
-  "Saeeol can {highlight}configure itself{/highlight} if you ask it",
-  "Ask Saeeol to {highlight}add Supabase MCP globally{/highlight}",
-  "Ask Saeeol to {highlight}create a review agent for this project{/highlight}",
-  "Ask Saeeol to {highlight}add a plugin for desktop alerts{/highlight}",
-  "Ask Saeeol to {highlight}set Claude Sonnet as my default model{/highlight}",
-  "Ask Saeeol to {highlight}make my review agent read-only{/highlight}",
-  "Ask Saeeol to {highlight}require approval before git push{/highlight}",
-  "Ask Saeeol to {highlight}turn off auto-formatting{/highlight}",
-  "Ask Saeeol to {highlight}block access to .env files{/highlight}",
-  "Ask Saeeol to {highlight}turn off the F2 shortcut{/highlight}",
-  "Ask Saeeol to {highlight}match my terminal theme{/highlight}",
-  "Ask Saeeol to {highlight}disable sharing for all sessions{/highlight}",
-  "Ask Saeeol to {highlight}add rules from docs/ai-rules.md{/highlight}",
-  "Ask Saeeol to {highlight}enable tui.scroll_acceleration{/highlight} for smooth macOS-style scrolling",
-  "Ask Saeeol to {highlight}save this workflow as a /command{/highlight}",
-  "Saeeol auto-handles OAuth for remote MCP servers requiring auth",
-  "Saeeol auto-formats files using prettier, gofmt, ruff, and more",
-  "Saeeol uses LSP servers for intelligent code analysis",
-  "Use {highlight}saeeol run{/highlight} for non-interactive scripting",
-  "Use {highlight}saeeol --continue{/highlight} to resume the last session",
-  "Use {highlight}saeeol run -f file.ts{/highlight} to attach files via CLI",
-  "Use {highlight}--format json{/highlight} for machine-readable output in scripts",
-  "Run {highlight}saeeol serve{/highlight} for headless API access to Saeeol",
-  "Use {highlight}saeeol run --attach{/highlight} to connect to a running server",
-  "Run {highlight}saeeol upgrade{/highlight} to update to the latest version",
-  "Run {highlight}saeeol auth list{/highlight} to see all configured providers",
-  "Run {highlight}/unshare{/highlight} to remove a session from public access",
-  "Use {highlight}--print-logs{/highlight} flag to see detailed logs in stderr",
-  "Press {highlight}Ctrl+X G{/highlight} or {highlight}/timeline{/highlight} to jump to specific messages",
-  "Press {highlight}Ctrl+X S{/highlight} or {highlight}/status{/highlight} to see config paths, MCP servers, and system info",
-  "Toggle username display in chat via command palette ({highlight}Ctrl+P{/highlight})",
-  "Commit your project's {highlight}AGENTS.md{/highlight} file to Git for team sharing",
-  "Use {highlight}/review{/highlight} to review uncommitted changes, branches, or PRs",
-  "Run {highlight}/help{/highlight} to show the help dialog",
-  "Use {highlight}/rename{/highlight} to rename the current session",
-  "Press {highlight}Ctrl+Z{/highlight} to suspend the terminal and return to your shell",
-]

package/src/overlay/config/config-core.ts

@@ -1,130 +0,0 @@
-import path from "path"
-import { existsSync } from "fs"
-import { Effect, Schema } from "effect"
-import { mergeDeep } from "remeda"
-import * as Log from "@saeeol/core/util/log"
-import type { AppFileSystem } from "@saeeol/core/filesystem"
-import { isRecord } from "@/util/record"
-import type { Config } from "../../config/config"
-
-const log = Log.create({ service: "saeeol.config" })
-
-export const CommitMessageSchema = Schema.optional(
-  Schema.Struct({
-    prompt: Schema.optional(Schema.String).annotate({
-      description:
-        "Custom system prompt for AI commit message generation. When set, replaces the default conventional commits prompt entirely.",
-    }),
-  }),
-).annotate({ description: "Configuration for AI-generated commit messages" })
-
-export const SAEEOL_CONFIG_FILES = ["saeeol.jsonc", "saeeol.json"] as const
-
-export const ALL_CONFIG_FILES = ["saeeol.jsonc", "saeeol.json"] as const
-
-export const SAEEOL_DIR_SUFFIXES = [".saeeol"] as const
-
-export const ALL_CONFIG_DIR_SUFFIXES = [".saeeol"] as const
-
-export const AGENT_PATTERNS = ["/.saeeol/agent/", "/.saeeol/agents/"] as const
-
-export const COMMAND_PATTERNS = [
-  "/.saeeol/command/",
-  "/.saeeol/commands/",
-] as const
-
-export const projectConfigUpdateTarget = Effect.fn("SaeeolConfig.projectConfigUpdateTarget")(function* (input: {
-  fs: AppFileSystem.Interface
-  directory: string
-  worktree?: string
-}) {
-  const dirs = yield* input.fs
-    .up({ targets: [...ALL_CONFIG_DIR_SUFFIXES], start: input.directory, stop: input.worktree })
-    .pipe(Effect.orDie)
-  const roots = yield* input.fs
-    .up({ targets: [...ALL_CONFIG_FILES], start: input.directory, stop: input.worktree })
-    .pipe(Effect.orDie)
-  const files = [...dirs.flatMap((dir) => ALL_CONFIG_FILES.map((file) => path.join(dir, file))), ...roots]
-  return files.find((file) => existsSync(file)) ?? path.join(input.directory, ".saeeol", "saeeol.json")
-})
-
-type UpdateProjectConfigInput = {
-  fs: AppFileSystem.Interface
-  directory: string
-  worktree?: string
-  config: Config.Info
-  read: (file: string) => Effect.Effect<string | undefined>
-  parse: (input: string, file: string) => Config.Info
-  patch: (input: string, config: Config.Info) => string
-  writable: (config: Config.Info) => Config.Info
-}
-
-export const updateProjectConfig: (input: UpdateProjectConfigInput) => Effect.Effect<void> = Effect.fn("SaeeolConfig.updateProjectConfig")(function* (input: UpdateProjectConfigInput) {
-  const file = yield* projectConfigUpdateTarget(input)
-  const source = yield* input.read(file)
-  const before = source ?? "{}"
-  const patch = input.writable(input.config)
-
-  if (file.endsWith(".jsonc")) {
-    const updated = input.patch(before, patch)
-    yield* input.fs.writeWithDirs(file, updated).pipe(Effect.orDie)
-    return
-  }
-
-  const existing = input.parse(before, file)
-  const merged = mergeConfig(input.writable(existing), patch)
-  if (source === undefined && Object.keys(merged).length === 0) return
-  yield* input.fs.writeWithDirs(file, JSON.stringify(merged, null, 2)).pipe(Effect.orDie)
-})
-
-export function scopeIndexing(info: Config.Info, scope: "global" | "local"): Config.Info {
-  if (scope !== "global") return info
-  return stripGlobalIndexing(info)
-}
-
-function stripGlobalIndexing(info: Config.Info): Config.Info {
-  if (info.indexing?.enabled === undefined) return info
-  const indexing = Object.fromEntries(Object.entries(info.indexing).filter(([key]) => key !== "enabled"))
-  if (Object.keys(indexing).length > 0) return { ...info, indexing }
-  const copy = { ...info }
-  delete copy.indexing
-  return copy
-}
-
-export function stripNulls(obj: Record<string, unknown>): Record<string, unknown> {
-  const result: Record<string, unknown> = {}
-  for (const [key, value] of Object.entries(obj)) {
-    if (value === null) continue
-    if (isRecord(value)) {
-      const stripped = stripNulls(value)
-      if (Object.keys(stripped).length > 0) result[key] = stripped
-    } else {
-      result[key] = value
-    }
-  }
-  return result
-}
-
-export function mergeConfig(existing: Config.Info, patch: Config.Info): Config.Info {
-  const e = { ...existing } as Record<string, unknown>
-  const p = patch as Record<string, unknown>
-
-  const existingPerm = e.permission
-  const patchPerm = p.permission
-  if (isRecord(existingPerm) && isRecord(patchPerm)) {
-    const cloned = { ...existingPerm }
-    for (const [key, value] of Object.entries(patchPerm)) {
-      const existing = cloned[key]
-      if (typeof existing === "string" && isRecord(value)) {
-        cloned[key] = { "*": existing }
-      }
-    }
-    e.permission = cloned
-  }
-
-  return stripNulls(mergeDeep(e, p) as Record<string, unknown>) as Config.Info
-}
-
-export function isConfigDir(dir: string, flagDir?: string): boolean {
-  return dir.endsWith(".saeeol") || dir === flagDir
-}

package/src/overlay/config/config-helpers.ts

@@ -1,71 +0,0 @@
-import z from "zod"
-import * as Log from "@saeeol/core/util/log"
-import { NamedError } from "@saeeol/core/util/error"
-import { Bus } from "@/bus"
-import { ConfigError } from "../../config/error"
-import type { Config } from "../../config/config"
-
-const log = Log.create({ service: "saeeol.config" })
-
-export function toWarning(err: unknown): Config.Warning | undefined {
-  if (ConfigError.JsonError.isInstance(err))
-    return {
-      path: err.data.path,
-      message: `Config file at ${err.data.path} is not valid JSON(C)`,
-      detail: err.data.message || undefined,
-    }
-  if (ConfigError.InvalidError.isInstance(err)) {
-    const text = err.data.issues ? formatIssues(err.data.issues) : err.data.message
-    return {
-      path: err.data.path,
-      message: text
-        ? `Configuration is invalid at ${err.data.path}: ${text}`
-        : `Configuration is invalid at ${err.data.path}`,
-    }
-  }
-  return undefined
-}
-
-export function formatIssues(issues: z.core.$ZodIssue[]) {
-  return issues
-    .map((issue) => {
-      const loc = issue.path.map(String).join(".")
-      if (!loc) return issue.message
-      return `${loc}: ${issue.message}`
-    })
-    .join("\n")
-}
-
-export async function handleInvalid(
-  kind: "agent" | "command",
-  item: string,
-  issues: z.core.$ZodIssue[],
-  cause: Error,
-  warnings?: Config.Warning[],
-) {
-  const text = formatIssues(issues)
-  const message = text ? `Config file at ${item} is invalid: ${text}` : `Config file at ${item} is invalid`
-  const err = new ConfigError.InvalidError({ path: item, issues }, { cause })
-  if (warnings) warnings.push({ path: item, message, detail: text || undefined })
-  try {
-    const { Session } = await import("@/session/session")
-    Bus.publish(Session.Event.Error, { error: new NamedError.Unknown({ message }).toObject() })
-  } catch (e) {
-    log.warn("could not publish session error", { message, err: e })
-  }
-  if (kind === "command") {
-    log.error("failed to load command", { command: item, err, message })
-    return
-  }
-  log.error("failed to load agent", { agent: item, err, message })
-}
-
-export function caught(warnings: Config.Warning[], source: string, err: unknown) {
-  const w = toWarning(err)
-  if (w) {
-    warnings.push(w)
-    log.warn("skipped config due to error", { source, err })
-    return
-  }
-  throw err
-}