saeeol 1.4.2 → 1.4.3

package/src/overlay/plan-followup.ts

@@ -1,173 +0,0 @@
-import { Telemetry } from "@saeeol/telemetry"
-import { Flag } from "@saeeol/core/flag/flag"
-import { Global } from "@saeeol/core/global"
-import { Instance } from "@/project/instance"
-import { ProviderID, ModelID } from "@/provider/schema"
-import { Question } from "@/question"
-import { Session } from "@/session/session"
-import { SessionID, PartID } from "@/session/schema"
-import { MessageV2 } from "@/session/message-v2"
-import * as Log from "@saeeol/core/util/log"
-import { SaeeolSessionPromptQueue } from "@/saeeol/session/prompt-queue"
-import path from "path"
-import z from "zod"
-import { pending, PlanFollowupRuntime, toText } from "./plan-followup-runtime"
-import { startNew } from "./plan-followup-session"
-
-export { formatTodos, generateHandover } from "./plan-followup-handover"
-export { PlanFollowupRuntime } from "./plan-followup-runtime"
-
-export namespace PlanFollowup {
-  const log = Log.create({ service: "plan.followup" })
-
-  export const PLAN_PREFIX = "Implement the following plan:"
-  export const ANSWER_NEW_SESSION = "Start new session"
-  export const ANSWER_CONTINUE = "Continue here"
-
-  export function abort(sessionID: SessionID) {
-    const ctl = pending.get(sessionID)
-    if (!ctl) return false
-    pending.delete(sessionID)
-    ctl.abort()
-    return true
-  }
-
-  function resolveVariant(value: string | undefined, model: { variants?: Record<string, unknown> } | undefined) {
-    if (!value) return undefined
-    if (!model?.variants?.[value]) return undefined
-    return value
-  }
-
-  const ModelState = z
-    .object({
-      model: z.record(z.string(), z.object({ providerID: ProviderID.zod, modelID: ModelID.zod })).optional(),
-      variant: z.record(z.string(), z.string().optional()).optional(),
-    })
-    .passthrough()
-
-  async function resolveCodeModel(input: Pick<MessageV2.User, "model">) {
-    const state =
-      Flag.SAEEOL_CLIENT === "cli"
-        ? await Bun.file(path.join(Global.Path.state, "model.json"))
-            .text()
-            .then((raw) => ModelState.safeParse(JSON.parse(raw)))
-            .then((r) => (r.success ? r.data : undefined))
-            .catch(() => undefined)
-        : undefined
-    const saved = state?.model?.code
-    if (saved) {
-      const full = await PlanFollowupRuntime.model(saved.providerID, saved.modelID).catch(() => undefined)
-      if (full) {
-        const key = `${saved.providerID}/${saved.modelID}`
-        return { model: { ...saved, variant: resolveVariant(state?.variant?.[key], full) } }
-      }
-    }
-    const entry = await PlanFollowupRuntime.agent("code")
-    if (entry?.model) {
-      const full = await PlanFollowupRuntime.model(entry.model.providerID, entry.model.modelID).catch(() => undefined)
-      if (full) return { model: { ...entry.model, variant: resolveVariant(entry.variant, full) } }
-    }
-    return input
-  }
-
-  async function resolvePlan(input: {
-    assistant?: MessageV2.WithParts
-    messages: MessageV2.WithParts[]
-    sessionID: SessionID
-  }) {
-    if (input.assistant) {
-      const text = toText(input.assistant)
-      if (text) return text
-    }
-    const lastUserIdx = input.messages.findLastIndex((m) => m.info.role === "user")
-    const assistantMessages = input.messages.slice(lastUserIdx + 1).filter((m) => m.info.role === "assistant")
-    const text = assistantMessages.map(toText).filter(Boolean).join("\n\n").trim()
-    if (text) return text
-    const session = await Session.get(SessionID.make(input.sessionID))
-    const file = Bun.file(Session.plan(session, Instance.current))
-    const plan = await file.text().catch(() => "")
-    return plan.trim()
-  }
-
-  async function inject(input: {
-    sessionID: SessionID; agent: string; model: MessageV2.User["model"]; text: string; synthetic?: boolean
-  }) {
-    const msg: MessageV2.User = {
-      id: (await import("@/session/schema")).MessageID.ascending(),
-      sessionID: input.sessionID, role: "user",
-      time: { created: Date.now() }, agent: input.agent, model: input.model,
-    }
-    await Session.updateMessage(msg)
-    await Session.updatePart({
-      id: PartID.ascending(), messageID: msg.id, sessionID: input.sessionID,
-      type: "text", text: input.text, synthetic: input.synthetic ?? true,
-    } satisfies MessageV2.TextPart)
-    return msg
-  }
-
-  function prompt(input: { sessionID: SessionID; abort: AbortSignal }) {
-    const promise = PlanFollowupRuntime.question.ask({
-      sessionID: input.sessionID,
-      questions: [{
-        question: "Ready to implement?", questionKey: "plan.followup.question",
-        header: "Implement", headerKey: "plan.followup.header",
-        custom: Flag.SAEEOL_CLIENT === "cli",
-        options: [
-          { label: ANSWER_NEW_SESSION, labelKey: "plan.followup.answer.newSession",
-            description: "Implement in a fresh session with a clean context",
-            descriptionKey: "plan.followup.answer.newSession.description" },
-          { label: ANSWER_CONTINUE, labelKey: "plan.followup.answer.continue",
-            description: "Implement the plan in this session",
-            descriptionKey: "plan.followup.answer.continue.description", mode: "code" },
-        ],
-      }],
-    })
-    const listener = () =>
-      PlanFollowupRuntime.question.list().then((qs) => {
-        const match = qs.find((q) => q.sessionID === input.sessionID)
-        if (match) PlanFollowupRuntime.question.reject(match.id)
-      })
-    input.abort.addEventListener("abort", listener, { once: true })
-    return promise
-      .catch((error) => { if (error instanceof Question.RejectedError) return undefined; throw error })
-      .finally(() => { input.abort.removeEventListener("abort", listener) })
-  }
-
-  export async function ask(input: {
-    sessionID: SessionID; messages: MessageV2.WithParts[]; abort: AbortSignal
-  }): Promise<"continue" | "break"> {
-    if (input.abort.aborted) return "break"
-    const latest = input.messages.slice().reverse()
-    const assistant = latest.find((msg) => msg.info.role === "assistant")
-    if (!assistant) return "break"
-    const plan = await resolvePlan({ assistant, messages: input.messages, sessionID: input.sessionID })
-    if (!plan) return "break"
-    const user = latest.find((msg) => msg.info.role === "user")?.info
-    if (!user || user.role !== "user" || !user.model) return "break"
-
-    const answers = await prompt({ sessionID: input.sessionID, abort: input.abort })
-    if (!answers) { Telemetry.trackPlanFollowup(input.sessionID, "dismissed"); return "break" }
-    const answer = answers[0]?.[0]?.trim()
-    if (!answer) { Telemetry.trackPlanFollowup(input.sessionID, "dismissed"); return "break" }
-
-    if (answer === ANSWER_NEW_SESSION) {
-      Telemetry.trackPlanFollowup(input.sessionID, "new_session")
-      await startNew({ sessionID: input.sessionID, plan, messages: input.messages,
-        model: user.model, abort: input.abort, resolveCodeModel })
-      return "break"
-    }
-
-    if (answer === ANSWER_CONTINUE) {
-      Telemetry.trackPlanFollowup(input.sessionID, "continue")
-      const code = await resolveCodeModel({ model: user.model })
-      const msg = await inject({ sessionID: input.sessionID, agent: "code", model: code.model, text: "Implement the plan above." })
-      SaeeolSessionPromptQueue.retarget(input.sessionID, msg.id)
-      return "continue"
-    }
-
-    Telemetry.trackPlanFollowup(input.sessionID, "custom")
-    const msg = await inject({ sessionID: input.sessionID, agent: "plan", model: user.model, text: answer })
-    SaeeolSessionPromptQueue.retarget(input.sessionID, msg.id)
-    return "continue"
-  }
-}

package/src/overlay/plugins/home-footer.tsx

@@ -1,168 +0,0 @@
-/**
- * Saeeol-specific home footer plugin.
- *
- * Replaces the upstream `home_footer` slot (order 101 > upstream 100)
- * to inject the RemoteIndicator alongside the standard directory, MCP,
- * and version information.
- */
-import type { TuiPlugin, TuiPluginApi, TuiPluginModule } from "@saeeol/plugin/tui"
-import { createMemo, createSignal, Match, onCleanup, onMount, Show, Switch } from "solid-js"
-import { Global } from "@saeeol/core/global"
-import { indexingEnabled } from "../indexing-feature"
-import { formatIndexingLabel } from "../indexing-label"
-import { useSync } from "@/cli/cmd/tui/context/sync"
-
-const id = "internal:saeeol-home-footer"
-
-type Status = {
-  enabled: boolean
-  connected: boolean
-}
-
-// ---------------------------------------------------------------------------
-// RemoteIndicator – adapted from @/saeeol/remote-tui for plugin API usage
-// ---------------------------------------------------------------------------
-
-function RemoteIndicator(props: { api: TuiPluginApi; saeeol: boolean }) {
-  const theme = () => props.api.theme.current
-  const [status, setStatus] = createSignal<Status | null>(null)
-
-  onMount(() => {
-    void props.api.client.remote
-      .status()
-      .then((res: { data?: Status }) => {
-        if (res.data) setStatus(res.data)
-      })
-      .catch(() => undefined)
-    const off = props.api.event.on("saeeol-sessions.remote-status-changed" as any, (evt: any) => setStatus(evt.properties))
-    onCleanup(off)
-  })
-
-  return (
-    <Show when={props.saeeol && status()?.enabled}>
-      <text fg={status()?.connected ? theme().success : theme().warning}>
-        ◆ Remote{status()?.connected ? "" : " …"}
-      </text>
-    </Show>
-  )
-}
-
-// ---------------------------------------------------------------------------
-// Sub-components (mirror upstream home/footer with saeeol additions)
-// ---------------------------------------------------------------------------
-
-function Directory(props: { api: TuiPluginApi }) {
-  const theme = () => props.api.theme.current
-  const dir = createMemo(() => {
-    const d = props.api.state.path.directory || process.cwd()
-    const out = d.replace(Global.Path.home, "~")
-    const branch = props.api.state.vcs?.branch
-    if (branch) return out + ":" + branch
-    return out
-  })
-
-  return <text fg={theme().textMuted}>{dir()}</text>
-}
-
-function Mcp(props: { api: TuiPluginApi }) {
-  const theme = () => props.api.theme.current
-  const list = createMemo(() => props.api.state.mcp())
-  const has = createMemo(() => list().length > 0)
-  const err = createMemo(() => list().some((item) => item.status === "failed"))
-  const count = createMemo(() => list().filter((item) => item.status === "connected").length)
-
-  return (
-    <Show when={has()}>
-      <box gap={1} flexDirection="row" flexShrink={0}>
-        <text fg={theme().text}>
-          <Switch>
-            <Match when={err()}>
-              <span style={{ fg: theme().error }}>⊙ </span>
-            </Match>
-            <Match when={true}>
-              <span style={{ fg: count() > 0 ? theme().success : theme().textMuted }}>⊙ </span>
-            </Match>
-          </Switch>
-          {count()} MCP
-        </text>
-        <text fg={theme().textMuted}>/status</text>
-      </box>
-    </Show>
-  )
-}
-
-function Version(props: { api: TuiPluginApi }) {
-  const theme = () => props.api.theme.current
-
-  return (
-    <box flexShrink={0}>
-      <text fg={theme().textMuted}>{props.api.app.version}</text>
-    </box>
-  )
-}
-
-// ---------------------------------------------------------------------------
-// Main footer view
-// ---------------------------------------------------------------------------
-
-function View(props: { api: TuiPluginApi }) {
-  const saeeol = createMemo(() => props.api.state.provider.some((p) => p.id === "saeeol"))
-  const theme = () => props.api.theme.current
-  const sync = useSync()
-  const indexingOn = createMemo(() => indexingEnabled(sync.data.config))
-  const indexing = createMemo(() => sync.data.indexing)
-  const indexingLabel = createMemo(() => formatIndexingLabel(indexing()))
-  const indexingColor = createMemo(() => {
-    if (indexing().state === "Complete") return theme().success
-    if (indexing().state === "Error") return theme().error
-    if (indexing().state === "In Progress") return theme().warning
-    if (indexing().state === "Standby") return theme().textMuted
-    return theme().textMuted
-  })
-
-  return (
-    <box
-      width="100%"
-      paddingTop={1}
-      paddingBottom={1}
-      paddingLeft={2}
-      paddingRight={2}
-      flexDirection="row"
-      flexShrink={0}
-      gap={2}
-    >
-      <Directory api={props.api} />
-      <box gap={1} flexDirection="row" flexShrink={0}>
-        <RemoteIndicator api={props.api} saeeol={saeeol()} />
-        <Mcp api={props.api} />
-        <Show when={indexingOn()}>
-          <text fg={indexingColor()}>{indexingLabel().slice(0, 48)}</text>
-        </Show>
-      </box>
-      <box flexGrow={1} />
-      <Version api={props.api} />
-    </box>
-  )
-}
-
-// ---------------------------------------------------------------------------
-// Plugin registration
-// ---------------------------------------------------------------------------
-
-const tui: TuiPlugin = async (api) => {
-  api.slots.register({
-    order: 99,
-    slots: {
-      home_footer() {
-        return <View api={api} />
-      },
-    },
-  })
-}
-
-const plugin: TuiPluginModule & { id: string } = {
-  id,
-  tui,
-}
-
-export default plugin

package/src/overlay/plugins/home-news.tsx

@@ -1,44 +0,0 @@
-import type { TuiPlugin, TuiPluginModule } from "@saeeol/plugin/tui"
-import { createMemo, Show } from "solid-js"
-import { SaeeolNews } from "@/saeeol/components/news"
-
-const id = "internal:home-news"
-
-const tui: TuiPlugin = async (api) => {
-  api.command.register(() => [
-    {
-      title: api.kv.get("news_hidden", false) ? "Show news" : "Hide news",
-      value: "news.toggle",
-      keybind: "news_toggle",
-      category: "System",
-      hidden: api.route.current.name !== "home",
-      onSelect() {
-        api.kv.set("news_hidden", !api.kv.get("news_hidden", false))
-        api.ui.dialog.clear()
-      },
-    },
-  ])
-
-  api.slots.register({
-    order: 50,
-    slots: {
-      home_bottom() {
-        const hidden = createMemo(() => api.kv.get("news_hidden", false))
-        return (
-          <box width="100%" maxWidth={75} alignItems="center" paddingTop={2}>
-            <Show when={!hidden()}>
-              <SaeeolNews />
-            </Show>
-          </box>
-        )
-      },
-    },
-  })
-}
-
-const plugin: TuiPluginModule & { id: string } = {
-  id,
-  tui,
-}
-
-export default plugin

package/src/overlay/plugins/home-onboarding.tsx

@@ -1,40 +0,0 @@
-import type { TuiPlugin, TuiPluginModule } from "@saeeol/plugin/tui"
-import { createMemo, Show } from "solid-js"
-import { Tips } from "@/saeeol/components/tips"
-
-const id = "internal:home-onboarding"
-
-const ONBOARDING_TIP = "Using a free model \u2014 run {highlight}/connect{/highlight} to add your API key"
-
-const tui: TuiPlugin = async (api) => {
-  api.slots.register({
-    order: 99,
-    slots: {
-      home_bottom() {
-        const hidden = createMemo(() => api.kv.get("tips_hidden", false))
-        const first = createMemo(() => api.state.session.count() === 0)
-        const connected = createMemo(() =>
-          api.state.provider.some(
-            (x) => (x.id !== "saeeol" && x.id !== "saeeol") || Object.values(x.models).some((y) => y.cost?.input !== 0),
-          ),
-        )
-        const onboarding = createMemo(() => first() && !connected())
-        const show = createMemo(() => onboarding() && !hidden())
-        return (
-          <Show when={show()}>
-            <box height={4} minHeight={0} width="100%" maxWidth={75} alignItems="center" paddingTop={3} flexShrink={1}>
-              <Tips tip={ONBOARDING_TIP} />
-            </box>
-          </Show>
-        )
-      },
-    },
-  })
-}
-
-const plugin: TuiPluginModule & { id: string } = {
-  id,
-  tui,
-}
-
-export default plugin

package/src/overlay/plugins/sidebar-footer.tsx

@@ -1,95 +0,0 @@
-import type { TuiPlugin, TuiPluginApi, TuiPluginModule } from "@saeeol/plugin/tui"
-import { createMemo, Show } from "solid-js"
-import { Global } from "@saeeol/core/global"
-
-const id = "internal:saeeol-sidebar-footer"
-
-function View(props: { api: TuiPluginApi }) {
-  const theme = () => props.api.theme.current
-  const has = createMemo(() =>
-    props.api.state.provider.some(
-      (item) =>
-        (item.id !== "saeeol" && item.id !== "saeeol") ||
-        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}>Saeeol 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>{" "}
-        <span style={{ fg: theme().text }}>
-          <b>Saeeol</b>
-        </span>{" "}
-        <span>{props.api.app.version}</span>
-      </text>
-    </box>
-  )
-}
-
-const tui: TuiPlugin = async (api) => {
-  api.slots.register({
-    order: 99,
-    slots: {
-      sidebar_footer() {
-        return <View api={api} />
-      },
-    },
-  })
-}
-
-const plugin: TuiPluginModule & { id: string } = {
-  id,
-  tui,
-}
-
-export default plugin