@sleepy-ai/cli 0.1.6 → 0.1.8

package/src/cli/cmd/tui/plugin/slots.tsx

@@ -1,60 +0,0 @@
-import type { TuiPluginApi, TuiSlotContext, TuiSlotMap, TuiSlotProps } from "@sleepy-ai/plugin/tui"
-import { createSlot, createSolidSlotRegistry, type JSX, type SolidPlugin } from "@opentui/solid"
-import { isRecord } from "@/util/record"
-
-type RuntimeSlotMap = TuiSlotMap<Record<string, object>>
-
-type Slot = <Name extends string>(props: TuiSlotProps<Name>) => JSX.Element | null
-export type HostSlotPlugin<Slots extends Record<string, object> = {}> = SolidPlugin<TuiSlotMap<Slots>, TuiSlotContext>
-
-export type HostPluginApi = TuiPluginApi
-export type HostSlots = {
-  register: {
-    (plugin: HostSlotPlugin): () => void
-    <Slots extends Record<string, object>>(plugin: HostSlotPlugin<Slots>): () => void
-  }
-}
-
-function empty<Name extends string>(_props: TuiSlotProps<Name>) {
-  return null
-}
-
-let view: Slot = empty
-
-export const Slot: Slot = (props) => view(props)
-
-function isHostSlotPlugin(value: unknown): value is HostSlotPlugin<Record<string, object>> {
-  if (!isRecord(value)) return false
-  if (typeof value.id !== "string") return false
-  if (!isRecord(value.slots)) return false
-  return true
-}
-
-export function setupSlots(api: HostPluginApi): HostSlots {
-  const reg = createSolidSlotRegistry<RuntimeSlotMap, TuiSlotContext>(
-    api.renderer,
-    {
-      theme: api.theme,
-    },
-    {
-      onPluginError(event) {
-        console.error("[tui.slot] plugin error", {
-          plugin: event.pluginId,
-          slot: event.slot,
-          phase: event.phase,
-          source: event.source,
-          message: event.error.message,
-        })
-      },
-    },
-  )
-
-  const slot = createSlot<RuntimeSlotMap, TuiSlotContext>(reg)
-  view = (props) => slot(props)
-  return {
-    register(plugin: HostSlotPlugin) {
-      if (!isHostSlotPlugin(plugin)) return () => {}
-      return reg.register(plugin)
-    },
-  }
-}

package/src/cli/cmd/tui/routes/home.tsx

@@ -1,165 +0,0 @@
-import { Prompt, type PromptRef } from "@tui/component/prompt"
-import { createEffect, createMemo, createSignal, Show } from "solid-js"
-import path from "path"
-import { Logo } from "../component/logo"
-import { logoThin, logos, type LogoKey } from "@/cli/logo"
-import { StarryBackground } from "../component/starry-background"
-import { BackgroundImage } from "../component/background-image"
-import { useProject } from "../context/project"
-import { useSync } from "../context/sync"
-import { Toast } from "../ui/toast"
-import { useArgs } from "../context/args"
-import { useRouteData } from "@tui/context/route"
-import { usePromptRef } from "../context/prompt"
-import { useLocal } from "../context/local"
-import { useKV } from "../context/kv"
-import { useLanguage } from "@tui/context/language"
-import { TuiPluginRuntime } from "../plugin"
-import { Global } from "@/global"
-import { isPlainTerminal } from "../util/terminal"
-
-let once = false
-
-export function Home() {
-  const sync = useSync()
-  const project = useProject()
-  const route = useRouteData("home")
-  const promptRef = usePromptRef()
-  const [ref, setRef] = createSignal<PromptRef | undefined>()
-  const args = useArgs()
-  const local = useLocal()
-  const kv = useKV()
-  const t = useLanguage().t
-  const plainTerminal = isPlainTerminal()
-  const bgImagePath = createMemo(() => {
-    const filename = kv.get("background_image")
-    if (!filename || typeof filename !== "string") return undefined
-    return path.join(Global.Path.config, "backgrounds", filename)
-  })
-  const logoKey = createMemo(() => {
-    const key = kv.get("logo_design")
-    return typeof key === "string" && key in logos ? (key as LogoKey) : "thin"
-  })
-  // 所有 logo 变体(含默认的 thin 纤细半块)都显示流星特效。
-  const showMeteor = () => true
-  const placeholder = {
-    get normal() {
-      return [
-        t("tui.home.placeholder.example.todo"),
-        t("tui.home.placeholder.example.stack"),
-        t("tui.home.placeholder.example.tests"),
-      ]
-    },
-    shell: ["ls -la", "git status", "pwd"],
-  }
-  let sent = false
-
-  const bind = (r: PromptRef | undefined) => {
-    setRef(r)
-    promptRef.set(r)
-    if (once || !r) return
-    if (route.prompt) {
-      r.set(route.prompt)
-      once = true
-      return
-    }
-    if (!args.prompt) return
-    r.set({ input: args.prompt, parts: [] })
-    once = true
-  }
-
-  // Wait for sync and model store to be ready before auto-submitting --prompt
-  createEffect(() => {
-    const r = ref()
-    if (sent) return
-    if (!r) return
-    if (!sync.ready || !local.model.ready) return
-    if (!args.prompt) return
-    if (r.current.input !== args.prompt) return
-    sent = true
-    r.submit()
-  })
-
-  return (
-    <>
-      <Show when={!plainTerminal}>
-        <Show when={bgImagePath()} fallback={<StarryBackground meteor={showMeteor} />}>
-          {(p) => <BackgroundImage path={p()} />}
-        </Show>
-      </Show>
-      <box flexGrow={1} alignItems="center" paddingLeft={8} paddingRight={8} zIndex={1}>
-        <box flexGrow={1} minHeight={0} />
-        <box height={4} minHeight={0} flexShrink={1} />
-        <box flexShrink={0}>
-          <Show
-            when={plainTerminal}
-            fallback={
-              <TuiPluginRuntime.Slot name="home_logo" mode="replace">
-                <Show when={logoKey()} keyed>
-                  {(k) => <Logo shape={logos[k]} sweep />}
-                </Show>
-              </TuiPluginRuntime.Slot>
-            }
-          >
-            <box flexDirection="column" flexShrink={0}>
-              {logoThin.left.slice(2).map((line, index) => (
-                <box flexDirection="row" gap={1} flexShrink={0}>
-                  <text selectable={false}>{line}</text>
-                  <text selectable={false}>{logoThin.right[index + 2] ?? ""}</text>
-                </box>
-              ))}
-            </box>
-          </Show>
-        </box>
-        <box height={1} minHeight={0} flexShrink={1} />
-        <box
-          width="100%"
-          maxWidth={75}
-          zIndex={1000}
-          paddingTop={1}
-          flexShrink={0}
-        >
-          <Show
-            when={plainTerminal}
-            fallback={
-              <TuiPluginRuntime.Slot
-                name="home_prompt"
-                mode="replace"
-                workspace_id={project.workspace.current()}
-                ref={bind}
-              >
-                <Prompt
-                  ref={bind}
-                  workspaceID={project.workspace.current()}
-                  right={<TuiPluginRuntime.Slot name="home_prompt_right" workspace_id={project.workspace.current()} />}
-                  placeholders={placeholder}
-                />
-              </TuiPluginRuntime.Slot>
-            }
-          >
-            <Prompt
-              ref={bind}
-              workspaceID={project.workspace.current()}
-              placeholders={placeholder}
-            />
-          </Show>
-        </box>
-        <Show when={plainTerminal}>
-          <box paddingTop={1} flexShrink={0}>
-            <text selectable={false}>{t("tui.tips.plain_terminal")}</text>
-          </box>
-        </Show>
-        <Show when={!plainTerminal}>
-          <TuiPluginRuntime.Slot name="home_bottom" />
-        </Show>
-        <box flexGrow={1} minHeight={0} />
-        <Toast />
-      </box>
-      <Show when={!plainTerminal}>
-        <box width="100%" flexShrink={0}>
-          <TuiPluginRuntime.Slot name="home_footer" mode="single_winner" />
-        </box>
-      </Show>
-    </>
-  )
-}

package/src/cli/cmd/tui/routes/session/dialog-fork-from-timeline.tsx

@@ -1,76 +0,0 @@
-import { createMemo, onMount } from "solid-js"
-import { useSync } from "@tui/context/sync"
-import { DialogSelect, type DialogSelectOption } from "@tui/ui/dialog-select"
-import type { TextPart } from "@sleepy-ai/sdk/v2"
-import { Locale } from "@/util"
-import { useSDK } from "@tui/context/sdk"
-import { useRoute } from "@tui/context/route"
-import { useDialog, type DialogContext } from "../../ui/dialog"
-import type { PromptInfo } from "@tui/component/prompt/history"
-import { strip } from "@tui/component/prompt/part"
-
-export function DialogForkFromTimeline(props: { sessionID: string; onMove: (messageID?: string) => void }) {
-  const sync = useSync()
-  const dialog = useDialog()
-  const sdk = useSDK()
-  const route = useRoute()
-
-  onMount(() => {
-    dialog.setSize("large")
-  })
-
-  const options = createMemo((): DialogSelectOption<string | undefined>[] => {
-    const messages = sync.data.message[props.sessionID]?.["main"] ?? []
-    const fullSession = {
-      title: "Full session",
-      value: undefined,
-      onSelect: async (dialog: DialogContext) => {
-        const forked = await sdk.client.session.fork({ sessionID: props.sessionID })
-        route.navigate({
-          sessionID: forked.data!.id,
-          type: "session",
-        })
-        dialog.clear()
-      },
-    } satisfies DialogSelectOption<string | undefined>
-    const result = [] as DialogSelectOption<string | undefined>[]
-    for (const message of messages) {
-      if (message.role !== "user") continue
-      const part = (sync.data.part[message.id] ?? []).find(
-        (x) => x.type === "text" && !x.synthetic && !x.ignored,
-      ) as TextPart
-      if (!part) continue
-      result.push({
-        title: part.text.replace(/\n/g, " "),
-        value: message.id,
-        footer: Locale.time(message.time.created),
-        onSelect: async (dialog) => {
-          const forked = await sdk.client.session.fork({
-            sessionID: props.sessionID,
-            messageID: message.id,
-          })
-          const parts = sync.data.part[message.id] ?? []
-          const prompt = parts.reduce(
-            (agg, part) => {
-              if (part.type === "text") {
-                if (!part.synthetic) agg.input += part.text
-              }
-              if (part.type === "file") agg.parts.push(strip(part))
-              return agg
-            },
-            { input: "", parts: [] as PromptInfo["parts"] },
-          )
-          route.navigate({
-            sessionID: forked.data!.id,
-            type: "session",
-            prompt,
-          })
-          dialog.clear()
-        },
-      })
-    }
-    return [fullSession, ...result.reverse()]
-  })
-
-  return <DialogSelect onMove={(option) => props.onMove(option.value)} title="Fork session" options={options()} />
-}

package/src/cli/cmd/tui/routes/session/dialog-message.tsx

@@ -1,116 +0,0 @@
-import { createMemo } from "solid-js"
-import { useSync } from "@tui/context/sync"
-import { DialogSelect } from "@tui/ui/dialog-select"
-import { useSDK } from "@tui/context/sdk"
-import { useRoute } from "@tui/context/route"
-import * as Clipboard from "@tui/util/clipboard"
-import type { PromptInfo } from "@tui/component/prompt/history"
-import { strip } from "@tui/component/prompt/part"
-
-export function DialogMessage(props: {
-  messageID: string
-  sessionID: string
-  setPrompt?: (prompt: PromptInfo) => void
-}) {
-  const sync = useSync()
-  const sdk = useSDK()
-  const message = createMemo(() => {
-    const buckets = sync.data.message[props.sessionID]
-    if (!buckets) return undefined
-    for (const aid of Object.keys(buckets)) {
-      const found = buckets[aid].find((x) => x.id === props.messageID)
-      if (found) return found
-    }
-    return undefined
-  })
-  const route = useRoute()
-
-  return (
-    <DialogSelect
-      title="Message Actions"
-      options={[
-        {
-          title: "Revert",
-          value: "session.revert",
-          description: "undo messages and file changes",
-          onSelect: (dialog) => {
-            const msg = message()
-            if (!msg) return
-
-            void sdk.client.session.revert({
-              sessionID: props.sessionID,
-              messageID: msg.id,
-            })
-
-            if (props.setPrompt) {
-              const parts = sync.data.part[msg.id]
-              const promptInfo = parts.reduce(
-                (agg, part) => {
-                  if (part.type === "text") {
-                    if (!part.synthetic) agg.input += part.text
-                  }
-                  if (part.type === "file") agg.parts.push(strip(part))
-                  return agg
-                },
-                { input: "", parts: [] as PromptInfo["parts"] },
-              )
-              props.setPrompt(promptInfo)
-            }
-
-            dialog.clear()
-          },
-        },
-        {
-          title: "Copy",
-          value: "message.copy",
-          description: "message text to clipboard",
-          onSelect: async (dialog) => {
-            const msg = message()
-            if (!msg) return
-
-            const parts = sync.data.part[msg.id]
-            const text = parts.reduce((agg, part) => {
-              if (part.type === "text" && !part.synthetic) {
-                agg += part.text
-              }
-              return agg
-            }, "")
-
-            await Clipboard.copy(text)
-            dialog.clear()
-          },
-        },
-        {
-          title: "Fork",
-          value: "session.fork",
-          description: "create a new session",
-          onSelect: async (dialog) => {
-            const result = await sdk.client.session.fork({
-              sessionID: props.sessionID,
-              messageID: props.messageID,
-            })
-            const msg = message()
-            const prompt = msg
-              ? sync.data.part[msg.id].reduce(
-                  (agg, part) => {
-                    if (part.type === "text") {
-                      if (!part.synthetic) agg.input += part.text
-                    }
-                    if (part.type === "file") agg.parts.push(part)
-                    return agg
-                  },
-                  { input: "", parts: [] as PromptInfo["parts"] },
-                )
-              : undefined
-            route.navigate({
-              sessionID: result.data!.id,
-              type: "session",
-              prompt,
-            })
-            dialog.clear()
-          },
-        },
-      ]}
-    />
-  )
-}

package/src/cli/cmd/tui/routes/session/dialog-subagent.tsx

@@ -1,47 +0,0 @@
-import { DialogSelect } from "@tui/ui/dialog-select"
-import { useRoute } from "@tui/context/route"
-import { useSync } from "@tui/context/sync"
-import { createMemo } from "solid-js"
-
-export function DialogSubagent(props: { sessionID: string }) {
-  const route = useRoute()
-  const sync = useSync()
-
-  const actors = createMemo(() =>
-    (sync.data.actor[props.sessionID] ?? [])
-      .filter((a) => a.mode === "subagent" || a.mode === "peer")
-      .toSorted((a, b) => a.time_created - b.time_created),
-  )
-
-  const options = createMemo(() => {
-    const list = actors()
-    if (list.length === 0) {
-      return [
-        {
-          title: "(no subagents in this session)",
-          value: "empty",
-          description: "spawn one via the actor tool",
-          onSelect: (dialog: { clear: () => void }) => dialog.clear(),
-        },
-      ]
-    }
-    return list.map((a) => ({
-      title: `${a.actor_id}  ${a.agent}  ${a.status}`,
-      value: a.actor_id,
-      description: a.description,
-      onSelect: (dialog: { clear: () => void }) => {
-        if (a.mode === "subagent") {
-          if (route.data.type === "session") {
-            route.navigate({ ...route.data, agentID: a.actor_id })
-          }
-        } else {
-          // peer mode: navigate to the actor's own session, viewing its own slice
-          route.navigate({ type: "session", sessionID: a.session_id, agentID: a.actor_id })
-        }
-        dialog.clear()
-      },
-    }))
-  })
-
-  return <DialogSelect title="Subagents" options={options()} />
-}

package/src/cli/cmd/tui/routes/session/dialog-timeline.tsx

@@ -1,47 +0,0 @@
-import { createMemo, onMount } from "solid-js"
-import { useSync } from "@tui/context/sync"
-import { DialogSelect, type DialogSelectOption } from "@tui/ui/dialog-select"
-import type { TextPart } from "@sleepy-ai/sdk/v2"
-import { Locale } from "@/util"
-import { DialogMessage } from "./dialog-message"
-import { useDialog } from "../../ui/dialog"
-import type { PromptInfo } from "../../component/prompt/history"
-
-export function DialogTimeline(props: {
-  sessionID: string
-  onMove: (messageID: string) => void
-  setPrompt?: (prompt: PromptInfo) => void
-}) {
-  const sync = useSync()
-  const dialog = useDialog()
-
-  onMount(() => {
-    dialog.setSize("large")
-  })
-
-  const options = createMemo((): DialogSelectOption<string>[] => {
-    const messages = sync.data.message[props.sessionID]?.["main"] ?? []
-    const result = [] as DialogSelectOption<string>[]
-    for (const message of messages) {
-      if (message.role !== "user") continue
-      const part = (sync.data.part[message.id] ?? []).find(
-        (x) => x.type === "text" && !x.synthetic && !x.ignored,
-      ) as TextPart
-      if (!part) continue
-      result.push({
-        title: part.text.replace(/\n/g, " "),
-        value: message.id,
-        footer: Locale.time(message.time.created),
-        onSelect: (dialog) => {
-          dialog.replace(() => (
-            <DialogMessage messageID={message.id} sessionID={props.sessionID} setPrompt={props.setPrompt} />
-          ))
-        },
-      })
-    }
-    result.reverse()
-    return result
-  })
-
-  return <DialogSelect onMove={(option) => props.onMove(option.value)} title="Timeline" options={options()} />
-}

package/src/cli/cmd/tui/routes/session/footer.tsx

@@ -1,91 +0,0 @@
-import { createMemo, Match, onCleanup, onMount, Show, Switch } from "solid-js"
-import { useTheme } from "../../context/theme"
-import { useSync } from "../../context/sync"
-import { useDirectory } from "../../context/directory"
-import { useConnected } from "../../component/dialog-model"
-import { createStore } from "solid-js/store"
-import { useRoute } from "../../context/route"
-
-export function Footer() {
-  const { theme } = useTheme()
-  const sync = useSync()
-  const route = useRoute()
-  const mcp = createMemo(() => Object.values(sync.data.mcp).filter((x) => x.status === "connected").length)
-  const mcpError = createMemo(() => Object.values(sync.data.mcp).some((x) => x.status === "failed"))
-  const lsp = createMemo(() => Object.keys(sync.data.lsp))
-  const permissions = createMemo(() => {
-    if (route.data.type !== "session") return []
-    return sync.data.permission[route.data.sessionID] ?? []
-  })
-  const directory = useDirectory()
-  const connected = useConnected()
-
-  const [store, setStore] = createStore({
-    welcome: false,
-  })
-
-  onMount(() => {
-    // Track all timeouts to ensure proper cleanup
-    const timeouts: ReturnType<typeof setTimeout>[] = []
-
-    function tick() {
-      if (connected()) return
-      if (!store.welcome) {
-        setStore("welcome", true)
-        timeouts.push(setTimeout(() => tick(), 5000))
-        return
-      }
-
-      if (store.welcome) {
-        setStore("welcome", false)
-        timeouts.push(setTimeout(() => tick(), 10_000))
-        return
-      }
-    }
-    timeouts.push(setTimeout(() => tick(), 10_000))
-
-    onCleanup(() => {
-      timeouts.forEach(clearTimeout)
-    })
-  })
-
-  return (
-    <box flexDirection="row" justifyContent="space-between" gap={1} flexShrink={0}>
-      <text fg={theme.textMuted}>{directory()}</text>
-      <box gap={2} flexDirection="row" flexShrink={0}>
-        <Switch>
-          <Match when={store.welcome}>
-            <text fg={theme.text}>
-              Get started <span style={{ fg: theme.textMuted }}>/connect</span>
-            </text>
-          </Match>
-          <Match when={connected()}>
-            <Show when={permissions().length > 0}>
-              <text fg={theme.warning}>
-                <span style={{ fg: theme.warning }}>△</span> {permissions().length} Permission
-                {permissions().length > 1 ? "s" : ""}
-              </text>
-            </Show>
-            <text fg={theme.text}>
-              <span style={{ fg: lsp().length > 0 ? theme.success : theme.textMuted }}>•</span> {lsp().length} LSP
-            </text>
-            <Show when={mcp()}>
-              <text fg={theme.text}>
-                <Switch>
-                  <Match when={mcpError()}>
-                    <span style={{ fg: theme.error }}>⊙ </span>
-                  </Match>
-                  <Match when={true}>
-                    <span style={{ fg: theme.success }}>⊙ </span>
-                  </Match>
-                </Switch>
-                {mcp()} MCP
-              </text>
-            </Show>
-            <text fg={theme.textMuted}>/status</text>
-          </Match>
-        </Switch>
-      </box>
-    </box>
-  )
-}