saeeol 1.1.0 → 1.1.1

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

@@ -0,0 +1,149 @@
+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/saeeol/components/news.tsx

@@ -0,0 +1,64 @@
+/**
+ * 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/saeeol/components/notification-banner.tsx

@@ -0,0 +1,58 @@
+/**
+ * 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/saeeol/components/session-indexing.tsx

@@ -0,0 +1,30 @@
+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/saeeol/components/tips.tsx

@@ -0,0 +1,119 @@
+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/saeeol/config/config-core.ts

@@ -0,0 +1,130 @@
+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/saeeol/config/config-helpers.ts

@@ -0,0 +1,71 @@
+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
+}