@sleepy-ai/cli 0.0.0-main-202607032053 → 0.1.4

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

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

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

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

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

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

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

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