@sleepy-ai/cli 0.1.5 → 0.1.7

package/src/cli/cmd/tui/feature-plugins/sidebar/context.tsx

@@ -1,267 +0,0 @@
-import type { AssistantMessage } from "@sleepy-ai/sdk/v2"
-import type { TuiPlugin, TuiPluginApi, TuiPluginModule } from "@sleepy-ai/plugin/tui"
-import { Show, createEffect, createMemo, createSignal, onCleanup, onMount } from "solid-js"
-import { completedTPS, formatTPS, streamingTPS } from "./tps"
-import fs from "fs"
-import path from "path"
-import { Global } from "@/global"
-
-const id = "internal:sidebar-context"
-const REFRESH_MS = 1000
-
-function formatTokens(n: number): string {
-  if (n >= 1_000_000) return `${(n / 1_000_000).toFixed(1)}M`
-  if (n >= 1_000) return `${(n / 1_000).toFixed(1)}K`
-  return `${n}`
-}
-
-function View(props: { api: TuiPluginApi; session_id: string }) {
-  const theme = () => props.api.theme.current
-  const msg = createMemo(() => props.api.state.session.messages(props.session_id))
-  const cost = createMemo(() => {
-    const msgs = msg()
-    let total = 0
-    for (const item of msgs) {
-      if (item.role !== "assistant") continue
-      const t = item.tokens
-      const model = props.api.state.provider.find((p) => p.id === item.providerID)?.models[item.modelID]
-      if (!model) continue
-      total += (t.input * model.cost.input) / 1_000_000
-      total += ((t.output + t.reasoning) * model.cost.output) / 1_000_000
-      total += (t.cache.read * model.cost.cache.read) / 1_000_000
-      total += (t.cache.write * model.cost.cache.write) / 1_000_000
-    }
-    return total
-  })
-
-  const stats = createMemo(() => {
-    const assistants = msg().filter((m): m is AssistantMessage => m.role === "assistant")
-    const input = assistants.reduce((s, m) => s + m.tokens.input, 0)
-    const output = assistants.reduce((s, m) => s + m.tokens.output + m.tokens.reasoning, 0)
-    return { input, output, total: input + output }
-  })
-
-  const state = createMemo(() => {
-    const last = msg().findLast((item): item is AssistantMessage => item.role === "assistant" && item.tokens.output > 0)
-    if (!last) {
-      return {
-        tokens: 0,
-        limit: 128000,
-        percent: null,
-      }
-    }
-
-    const tokens =
-      last.tokens.input + last.tokens.output + last.tokens.reasoning + last.tokens.cache.read + last.tokens.cache.write
-    const model = props.api.state.provider.find((item) => item.id === last.providerID)?.models[last.modelID]
-    const limit = model?.limit.context ?? 128000
-    return {
-      tokens,
-      limit,
-      percent: model?.limit.context ? Math.round((tokens / model.limit.context) * 100) : null,
-    }
-  })
-
-  const [tick, setTick] = createSignal(Date.now())
-  const [expanded, setExpanded] = createSignal(true)
-  const [tier, setTier] = createSignal("free")
-  const [totalCost, setTotalCost] = createSignal(0)
-  const [creditUSD, setCreditUSD] = createSignal(5.0)
-  const [balanceUSD, setBalanceUSD] = createSignal(0.0)
-  const [monthlyUsageUSD, setMonthlyUsageUSD] = createSignal(0.0)
-  const [monthlyAllowanceUSD, setMonthlyAllowanceUSD] = createSignal(5.0)
-  const [limit5h, setLimit5h] = createSignal(0.5)
-  const [limit24h, setLimit24h] = createSignal(1.5)
-  const [limitWeekly, setLimitWeekly] = createSignal(3.5)
-  const [limitMonthly, setLimitMonthly] = createSignal(5.0)
-  const [rpmLimit, setRpmLimit] = createSignal(15)
-  const [cost5h, setCost5h] = createSignal(0)
-  const [cost24h, setCost24h] = createSignal(0)
-  const [costWeekly, setCostWeekly] = createSignal(0)
-  const [costMonthly, setCostMonthly] = createSignal(0)
-
-  onMount(() => {
-    let active = true;
-    const poll = async () => {
-      try {
-        const configPath = path.join(Global.Path.config, "gateway.json")
-        if (!fs.existsSync(configPath)) return
-        const sleepyConfig = JSON.parse(fs.readFileSync(configPath, "utf-8"))
-        const token = sleepyConfig.access_token || sleepyConfig.token
-        const dashboardUrl = sleepyConfig.dashboard_url || "https://www.sleepyai.org"
-
-        if (!token) return
-
-        const res = await fetch(`${dashboardUrl}/api/usage?days=30`, {
-          headers: { Authorization: `Bearer ${token}` }
-        })
-        if (!res.ok || !active) return
-        const data = await res.json()
-        setTier(data.tier ?? "free")
-        setTotalCost(data.totalCost ?? 0)
-        setBalanceUSD(data.balanceUSD ?? 0.0)
-        setMonthlyUsageUSD(data.monthlyUsageUSD ?? 0.0)
-        setMonthlyAllowanceUSD(data.monthlyAllowanceUSD ?? 5.0)
-        if (data.limits) {
-          setCreditUSD(data.limits.creditUSD ?? 5.0)
-          setLimit5h(data.limits.limit5h ?? 0.5)
-          setLimit24h(data.limits.limit24h ?? 1.5)
-          setLimitWeekly(data.limits.limitWeekly ?? 3.5)
-          setLimitMonthly(data.limits.limitMonthly ?? 5.0)
-          setRpmLimit(data.limits.rpmLimit ?? 15)
-        }
-        if (data.usageByWindow) {
-          setCost5h(data.usageByWindow.cost5h ?? 0)
-          setCost24h(data.usageByWindow.cost24h ?? 0)
-          setCostWeekly(data.usageByWindow.costWeekly ?? 0)
-          setCostMonthly(data.usageByWindow.costMonthly ?? 0)
-        }
-      } catch {
-      }
-    };
-
-    void poll();
-    const handle = setInterval(poll, 15000)
-    onCleanup(() => {
-      active = false
-      clearInterval(handle)
-    })
-  })
-
-  const bar = (used: number, max: number) => {
-    const pct = Math.min(100, Math.max(0, max > 0 ? (used / max) * 100 : 0))
-    const filled = Math.round(pct / 10)
-    const empty = 10 - filled
-    return `[${"█".repeat(filled)}${"░".repeat(empty)}] ${pct.toFixed(0)}%`
-  }
-
-  const contextBar = createMemo(() => {
-    const used = state().tokens
-    const max = state().limit ?? 128000
-    const percent = Math.min(100, Math.max(0, (used / max) * 100))
-    const filledLength = Math.round(percent / 10)
-    const emptyLength = 10 - filledLength
-    const bar = "█".repeat(filledLength) + "░".repeat(emptyLength)
-    return `[${bar}] ${percent.toFixed(0)}%`
-  })
-
-  const lastAssistant = createMemo(() =>
-    msg().findLast((item): item is AssistantMessage => item.role === "assistant"),
-  )
-
-  const latency = createMemo(() => {
-    const last = lastAssistant()
-    if (!last || last.time.completed === undefined) return undefined
-    const duration = last.time.completed - last.time.created
-    return duration > 0 ? `${Math.round(duration)}ms` : undefined
-  })
-
-  const isStreaming = createMemo(() => {
-    const m = lastAssistant()
-    return m !== undefined && !m.time.completed
-  })
-
-  createEffect(() => {
-    if (!isStreaming()) return
-    const handle = setInterval(() => setTick(Date.now()), REFRESH_MS)
-    onCleanup(() => clearInterval(handle))
-  })
-
-  const tps = createMemo<number | null>(() => {
-    const m = lastAssistant()
-    if (!m) return null
-
-    if (isStreaming()) {
-      tick() // reactivity dep so the readout updates between deltas
-      const parts = props.api.state.part(m.id)
-      const combined = parts
-        .filter((p) => p.type === "text" || p.type === "reasoning")
-        .map((p) => p.text)
-        .join("")
-      return streamingTPS(combined, m.time.created, Date.now())
-    }
-
-    const idleTarget = msg().findLast(
-      (item): item is AssistantMessage =>
-        item.role === "assistant" &&
-        item.time.completed !== undefined &&
-        item.tokens.output + item.tokens.reasoning > 0,
-    )
-    if (!idleTarget || idleTarget.time.completed === undefined) return null
-    return completedTPS(
-      idleTarget.tokens.output,
-      idleTarget.tokens.reasoning,
-      idleTarget.time.created,
-      idleTarget.time.completed,
-    )
-  })
-
-  const tpsLabel = createMemo(() => formatTPS(tps()))
-
-  return (
-    <box gap={1}>
-      <box>
-        <text fg={theme().text}>
-          <b>Context</b>
-        </text>
-        <text fg={theme().textMuted}>
-          Limit: {state().limit.toLocaleString()} / Used: {state().tokens.toLocaleString()} ({state().percent ?? 0}%)
-        </text>
-        <text fg={theme().accent}>{contextBar()}</text>
-        <Show when={tpsLabel()}>{(label) => <text fg={theme().textMuted}>{label()}</text>}</Show>
-        <text fg={theme().textMuted}>{cost().toFixed(4)} spent</text>
-        <Show when={latency()}>
-          {(l) => (
-            <text fg={theme().textMuted}>
-              Gateway: <span style={{ fg: theme().success }}>{l()}</span>
-            </text>
-          )}
-        </Show>
-      </box>
-      <box>
-        <text fg={theme().text}><b>Session</b></text>
-        <text fg={theme().textMuted}>
-          In {formatTokens(stats().input)} / Out {formatTokens(stats().output)} / Total {formatTokens(stats().total)}
-        </text>
-      </box>
-      <box>
-        <text fg={theme().text} onMouseUp={() => setExpanded(!expanded())}>
-          <b>Plan & Limits</b> {expanded() ? "▼" : "▶"}
-        </text>
-        <Show when={expanded()}>
-          <text fg={theme().textMuted}>Tier: {tier().charAt(0).toUpperCase() + tier().slice(1)}</text>
-          <text fg={theme().textMuted}>Plan Allowance: ${creditUSD().toFixed(2)}/month</text>
-          <text fg={theme().textMuted}>5h limit ({cost5h().toFixed(4)}/${limit5h().toFixed(2)})</text>
-          <text fg={theme().warning}>{bar(cost5h(), limit5h())}</text>
-          <text fg={theme().textMuted}>24h limit ({cost24h().toFixed(4)}/${limit24h().toFixed(2)})</text>
-          <text fg={theme().warning}>{bar(cost24h(), limit24h())}</text>
-          <text fg={theme().textMuted}>Weekly limit ({costWeekly().toFixed(4)}/${limitWeekly().toFixed(2)})</text>
-          <text fg={theme().warning}>{bar(costWeekly(), limitWeekly())}</text>
-          <text fg={theme().textMuted}>Monthly limit ({costMonthly().toFixed(4)}/${limitMonthly().toFixed(2)})</text>
-          <text fg={theme().warning}>{bar(costMonthly(), limitMonthly())}</text>
-          <Show when={balanceUSD() > 0}>
-            <text fg={theme().textMuted}>Extra balance: ${balanceUSD().toFixed(2)}</text>
-          </Show>
-        </Show>
-      </box>
-    </box>
-  )
-}
-
-const tui: TuiPlugin = async (api) => {
-  api.slots.register({
-    order: 100,
-    slots: {
-      sidebar_content(_ctx, props) {
-        return <View api={api} session_id={props.session_id} />
-      },
-    },
-  })
-}
-
-const plugin: TuiPluginModule & { id: string } = {
-  id,
-  tui,
-}
-
-export default plugin

package/src/cli/cmd/tui/feature-plugins/sidebar/cwd.tsx

@@ -1,45 +0,0 @@
-import type { TuiPlugin, TuiPluginApi, TuiPluginModule } from "@sleepy-ai/plugin/tui"
-import { createMemo } from "solid-js"
-import { Global } from "@/global"
-import { useLanguage } from "@tui/context/language"
-
-const id = "internal:sidebar-cwd"
-
-function View(props: { api: TuiPluginApi; session_id: string }) {
-  const theme = () => props.api.theme.current
-  const t = useLanguage().t
-  const cwd = createMemo(() => props.api.state.session.cwd(props.session_id))
-  const projectDir = createMemo(() => props.api.state.path.directory)
-  const display = createMemo(() => {
-    const dir = cwd() || projectDir()
-    if (!dir) return ""
-    return dir.replace(Global.Path.home, "~")
-  })
-
-  return (
-    <box>
-      <text fg={theme().text}>
-        <b>{t("tui.sidebar.cwd")}</b>
-      </text>
-      <text fg={theme().textMuted}>{display()}</text>
-    </box>
-  )
-}
-
-const tui: TuiPlugin = async (api) => {
-  api.slots.register({
-    order: 125,
-    slots: {
-      sidebar_content(_ctx, props) {
-        return <View api={api} session_id={props.session_id} />
-      },
-    },
-  })
-}
-
-const plugin: TuiPluginModule & { id: string } = {
-  id,
-  tui,
-}
-
-export default plugin

package/src/cli/cmd/tui/feature-plugins/sidebar/files.tsx

@@ -1,62 +0,0 @@
-import type { TuiPlugin, TuiPluginApi, TuiPluginModule } from "@sleepy-ai/plugin/tui"
-import { createMemo, For, Show, createSignal } from "solid-js"
-
-const id = "internal:sidebar-files"
-
-function View(props: { api: TuiPluginApi; session_id: string }) {
-  const [open, setOpen] = createSignal(true)
-  const theme = () => props.api.theme.current
-  const list = createMemo(() => props.api.state.session.diff(props.session_id))
-
-  return (
-    <Show when={list().length > 0}>
-      <box>
-        <box flexDirection="row" gap={1} onMouseDown={() => list().length > 2 && setOpen((x) => !x)}>
-          <Show when={list().length > 2}>
-            <text fg={theme().text}>{open() ? "▼" : "▶"}</text>
-          </Show>
-          <text fg={theme().text}>
-            <b>Modified Files</b>
-          </text>
-        </box>
-        <Show when={list().length <= 2 || open()}>
-          <For each={list()}>
-            {(item) => (
-              <box flexDirection="row" gap={1} justifyContent="space-between">
-                <text fg={theme().textMuted} wrapMode="none">
-                  {item.file}
-                </text>
-                <box flexDirection="row" gap={1} flexShrink={0}>
-                  <Show when={item.additions}>
-                    <text fg={theme().diffAdded}>+{item.additions}</text>
-                  </Show>
-                  <Show when={item.deletions}>
-                    <text fg={theme().diffRemoved}>-{item.deletions}</text>
-                  </Show>
-                </box>
-              </box>
-            )}
-          </For>
-        </Show>
-      </box>
-    </Show>
-  )
-}
-
-const tui: TuiPlugin = async (api) => {
-  api.slots.register({
-    order: 500,
-    slots: {
-      sidebar_content(_ctx, props) {
-        return <View api={api} session_id={props.session_id} />
-      },
-    },
-  })
-}
-
-const plugin: TuiPluginModule & { id: string } = {
-  id,
-  tui,
-}
-
-export default plugin

package/src/cli/cmd/tui/feature-plugins/sidebar/footer.tsx

@@ -1,93 +0,0 @@
-import type { TuiPlugin, TuiPluginApi, TuiPluginModule } from "@sleepy-ai/plugin/tui"
-import { createMemo, Show } from "solid-js"
-import { Global } from "@/global"
-
-const id = "internal:sidebar-footer"
-
-function View(props: { api: TuiPluginApi }) {
-  const theme = () => props.api.theme.current
-  const has = createMemo(() =>
-    props.api.state.provider.some(
-      (item) => item.id !== "opencode" || Object.values(item.models).some((model) => model.cost?.input !== 0),
-    ),
-  )
-  const done = createMemo(() => props.api.kv.get("dismissed_getting_started", false))
-  const show = createMemo(() => !has() && !done())
-  const path = createMemo(() => {
-    const dir = props.api.state.path.directory || process.cwd()
-    const out = dir.replace(Global.Path.home, "~")
-    const text = props.api.state.vcs?.branch ? out + ":" + props.api.state.vcs.branch : out
-    const list = text.split("/")
-    return {
-      parent: list.slice(0, -1).join("/"),
-      name: list.at(-1) ?? "",
-    }
-  })
-
-  return (
-    <box gap={1}>
-      <Show when={show()}>
-        <box
-          backgroundColor={theme().backgroundElement}
-          paddingTop={1}
-          paddingBottom={1}
-          paddingLeft={2}
-          paddingRight={2}
-          flexDirection="row"
-          gap={1}
-        >
-          <text flexShrink={0} fg={theme().text}>
-            ⬖
-          </text>
-          <box flexGrow={1} gap={1}>
-            <box flexDirection="row" justifyContent="space-between">
-              <text fg={theme().text}>
-                <b>Getting started</b>
-              </text>
-              <text fg={theme().textMuted} onMouseDown={() => props.api.kv.set("dismissed_getting_started", true)}>
-                ✕
-              </text>
-            </box>
-            <text fg={theme().textMuted}>Sleepy Code includes free models so you can start immediately.</text>
-            <text fg={theme().textMuted}>
-              Connect from 75+ providers to use other models, including Claude, GPT, Gemini etc
-            </text>
-            <box flexDirection="row" gap={1} justifyContent="space-between">
-              <text fg={theme().text}>Connect provider</text>
-              <text fg={theme().textMuted}>/connect</text>
-            </box>
-          </box>
-        </box>
-      </Show>
-      <text>
-        <span style={{ fg: theme().textMuted }}>{path().parent}/</span>
-        <span style={{ fg: theme().text }}>{path().name}</span>
-      </text>
-      <text fg={theme().textMuted}>
-        <span style={{ fg: theme().success }}>•</span> <b>Sleepy</b>
-        <span style={{ fg: theme().text }}>
-          <b>Code</b>
-        </span>{" "}
-        <span>{props.api.app.version}</span>
-      </text>
-    </box>
-  )
-}
-
-const tui: TuiPlugin = async (api) => {
-  api.slots.register({
-    order: 100,
-    slots: {
-      sidebar_footer() {
-        return <View api={api} />
-      },
-    },
-  })
-}
-
-const plugin: TuiPluginModule & { id: string } = {
-  id,
-  tui,
-}
-
-export default plugin

package/src/cli/cmd/tui/feature-plugins/sidebar/goal.tsx

@@ -1,84 +0,0 @@
-import type { TuiPlugin, TuiPluginApi, TuiPluginModule } from "@sleepy-ai/plugin/tui"
-import { createMemo, Show } from "solid-js"
-
-const id = "internal:sidebar-goal"
-
-function View(props: { api: TuiPluginApi; session_id: string }) {
-  const theme = () => props.api.theme.current
-  const goal = createMemo(() => props.api.state.session.goal(props.session_id))
-  // The latest verdict (keyed by the most recently judged turn) drives the
-  // status line; per-turn reasons live inline on the message stream.
-  const latest = createMemo(() => {
-    const g = goal()
-    if (!g?.lastMessageID) return undefined
-    return g.verdicts[g.lastMessageID]
-  })
-
-  // Show whenever there is an active goal, or a verdict survives from a goal
-  // that just cleared (so the ✓/⊘ result lingers briefly).
-  const show = createMemo(() => Boolean(goal()?.condition || latest()))
-
-  const status = createMemo(() => {
-    const v = latest()
-    if (!v) return undefined
-    if (v.error) return { dot: theme().textMuted, label: "error (stopped)" }
-    if (v.ok) return { dot: theme().success, label: "met" }
-    if (v.impossible) return { dot: theme().error, label: "impossible" }
-    return { dot: theme().warning, label: `round ${v.attempt} · not met` }
-  })
-
-  return (
-    <Show when={show()}>
-      <box>
-        <box flexDirection="row" gap={1}>
-          <text fg={theme().text}>
-            <b>Goal</b>
-          </text>
-        </box>
-        <Show when={goal()?.condition}>
-          {(condition) => (
-            <box flexDirection="row" gap={1}>
-              <text flexShrink={0} fg={theme().primary}>
-                •
-              </text>
-              <text fg={theme().textMuted} wrapMode="word">
-                {condition()}
-              </text>
-            </box>
-          )}
-        </Show>
-        <Show when={status()}>
-          {(s) => (
-            <box flexDirection="row" gap={1}>
-              <text flexShrink={0} fg={s().dot}>
-                •
-              </text>
-              <text fg={theme().textMuted} wrapMode="word">
-                Judge: {s().label}
-              </text>
-            </box>
-          )}
-        </Show>
-      </box>
-    </Show>
-  )
-}
-
-const tui: TuiPlugin = async (api) => {
-  api.slots.register({
-    // Just below LSP (300) so the goal status sits beneath the LSP block.
-    order: 350,
-    slots: {
-      sidebar_content(_ctx, props) {
-        return <View api={api} session_id={props.session_id} />
-      },
-    },
-  })
-}
-
-const plugin: TuiPluginModule & { id: string } = {
-  id,
-  tui,
-}
-
-export default plugin

package/src/cli/cmd/tui/feature-plugins/sidebar/instructions.tsx

@@ -1,54 +0,0 @@
-import type { TuiPlugin, TuiPluginApi, TuiPluginModule } from "@sleepy-ai/plugin/tui"
-import { createMemo, For, Show } from "solid-js"
-import { useLanguage } from "@tui/context/language"
-
-const id = "internal:sidebar-instructions"
-
-function View(props: { api: TuiPluginApi }) {
-  const theme = () => props.api.theme.current
-  const t = useLanguage().t
-  const list = createMemo(() => props.api.state.instructions())
-
-  return (
-    <Show when={list().length > 0}>
-      <box>
-        <box flexDirection="row" gap={1}>
-          <text fg={theme().text}>
-            <b>{t("tui.sidebar.instructions")}</b>
-          </text>
-        </box>
-        <For each={list()}>
-          {(file) => (
-            <box flexDirection="row" gap={1}>
-              <text flexShrink={0} fg={theme().primary}>
-                •
-              </text>
-              <text fg={theme().textMuted} wrapMode="none">
-                {file}
-              </text>
-            </box>
-          )}
-        </For>
-      </box>
-    </Show>
-  )
-}
-
-const tui: TuiPlugin = async (api) => {
-  api.slots.register({
-    // Just below Context (100) so loaded instruction files sit near the top.
-    order: 150,
-    slots: {
-      sidebar_content() {
-        return <View api={api} />
-      },
-    },
-  })
-}
-
-const plugin: TuiPluginModule & { id: string } = {
-  id,
-  tui,
-}
-
-export default plugin

package/src/cli/cmd/tui/feature-plugins/sidebar/lsp.tsx

@@ -1,66 +0,0 @@
-import type { TuiPlugin, TuiPluginApi, TuiPluginModule } from "@sleepy-ai/plugin/tui"
-import { createMemo, For, Show, createSignal } from "solid-js"
-
-const id = "internal:sidebar-lsp"
-
-function View(props: { api: TuiPluginApi }) {
-  const [open, setOpen] = createSignal(true)
-  const theme = () => props.api.theme.current
-  const list = createMemo(() => props.api.state.lsp())
-  const off = createMemo(() => props.api.state.config.lsp === false)
-
-  return (
-    <box>
-      <box flexDirection="row" gap={1} onMouseDown={() => list().length > 2 && setOpen((x) => !x)}>
-        <Show when={list().length > 2}>
-          <text fg={theme().text}>{open() ? "▼" : "▶"}</text>
-        </Show>
-        <text fg={theme().text}>
-          <b>LSP</b>
-        </text>
-      </box>
-      <Show when={list().length <= 2 || open()}>
-        <Show when={list().length === 0}>
-          <text fg={theme().textMuted}>
-            {off() ? "LSPs have been disabled in settings" : "LSPs will activate as files are read"}
-          </text>
-        </Show>
-        <For each={list()}>
-          {(item) => (
-            <box flexDirection="row" gap={1}>
-              <text
-                flexShrink={0}
-                style={{
-                  fg: item.status === "connected" ? theme().success : theme().error,
-                }}
-              >
-                •
-              </text>
-              <text fg={theme().textMuted}>
-                {item.id} {item.root}
-              </text>
-            </box>
-          )}
-        </For>
-      </Show>
-    </box>
-  )
-}
-
-const tui: TuiPlugin = async (api) => {
-  api.slots.register({
-    order: 300,
-    slots: {
-      sidebar_content() {
-        return <View api={api} />
-      },
-    },
-  })
-}
-
-const plugin: TuiPluginModule & { id: string } = {
-  id,
-  tui,
-}
-
-export default plugin