jonsoc 1.1.48 → 1.1.50

package/src/cli/cmd/tui/context/route.tsx

@@ -1,51 +0,0 @@
-import { createStore } from "solid-js/store"
-import { createSimpleContext } from "./helper"
-import type { PromptInfo } from "../component/prompt/history"
-
-export type HomeRoute = {
-  type: "home"
-  initialPrompt?: PromptInfo
-}
-
-export type SessionRoute = {
-  type: "session"
-  sessionID: string
-  initialPrompt?: PromptInfo
-}
-
-export type UISettingsRoute = {
-  type: "ui-settings"
-  returnTo?: Route
-}
-
-export type Route = HomeRoute | SessionRoute | UISettingsRoute
-
-export const { use: useRoute, provider: RouteProvider } = createSimpleContext({
-  name: "Route",
-  init: () => {
-    const [store, setStore] = createStore<Route>(
-      process.env["OPENCODE_ROUTE"]
-        ? JSON.parse(process.env["OPENCODE_ROUTE"])
-        : {
-            type: "home",
-          },
-    )
-
-    return {
-      get data() {
-        return store
-      },
-      navigate(route: Route) {
-        console.log("navigate", route)
-        setStore(route)
-      },
-    }
-  },
-})
-
-export type RouteContext = ReturnType<typeof useRoute>
-
-export function useRouteData<T extends Route["type"]>(type: T) {
-  const route = useRoute()
-  return route.data as Extract<Route, { type: typeof type }>
-}

package/src/cli/cmd/tui/context/sdk.tsx

@@ -1,94 +0,0 @@
-import { createOpencodeClient, type Event } from "@jonsoc/sdk/v2"
-import { createSimpleContext } from "./helper"
-import { createGlobalEmitter } from "@solid-primitives/event-bus"
-import { batch, onCleanup, onMount } from "solid-js"
-
-export type EventSource = {
-  on: (handler: (event: Event) => void) => () => void
-}
-
-export const { use: useSDK, provider: SDKProvider } = createSimpleContext({
-  name: "SDK",
-  init: (props: { url: string; directory?: string; fetch?: typeof fetch; events?: EventSource }) => {
-    const abort = new AbortController()
-    const sdk = createOpencodeClient({
-      baseUrl: props.url,
-      signal: abort.signal,
-      directory: props.directory,
-      fetch: props.fetch,
-    })
-
-    const emitter = createGlobalEmitter<{
-      [key in Event["type"]]: Extract<Event, { type: key }>
-    }>()
-
-    let queue: Event[] = []
-    let timer: Timer | undefined
-    let last = 0
-
-    const flush = () => {
-      if (queue.length === 0) return
-      const events = queue
-      queue = []
-      timer = undefined
-      last = Date.now()
-      // Batch all event emissions so all store updates result in a single render
-      batch(() => {
-        for (const event of events) {
-          emitter.emit(event.type, event)
-        }
-      })
-    }
-
-    const handleEvent = (event: Event) => {
-      queue.push(event)
-      const elapsed = Date.now() - last
-
-      if (timer) return
-      // If we just flushed recently (within 16ms), batch this with future events
-      // Otherwise, process immediately to avoid latency
-      if (elapsed < 16) {
-        timer = setTimeout(flush, 16)
-        return
-      }
-      flush()
-    }
-
-    onMount(async () => {
-      // If an event source is provided, use it instead of SSE
-      if (props.events) {
-        const unsub = props.events.on(handleEvent)
-        onCleanup(unsub)
-        return
-      }
-
-      // Fall back to SSE
-      while (true) {
-        if (abort.signal.aborted) break
-        const events = await sdk.event.subscribe(
-          {},
-          {
-            signal: abort.signal,
-          },
-        )
-
-        for await (const event of events.stream) {
-          handleEvent(event)
-        }
-
-        // Flush any remaining events
-        if (timer) clearTimeout(timer)
-        if (queue.length > 0) {
-          flush()
-        }
-      }
-    })
-
-    onCleanup(() => {
-      abort.abort()
-      if (timer) clearTimeout(timer)
-    })
-
-    return { client: sdk, event: emitter, url: props.url }
-  },
-})

package/src/cli/cmd/tui/context/sync.tsx

@@ -1,449 +0,0 @@
-import type {
-  Message,
-  Agent,
-  Provider,
-  Session,
-  Part,
-  Config,
-  Todo,
-  Command,
-  PermissionRequest,
-  QuestionRequest,
-  LspStatus,
-  McpStatus,
-  McpResource,
-  FormatterStatus,
-  SessionStatus,
-  ProviderListResponse,
-  ProviderAuthMethod,
-  VcsInfo,
-} from "@jonsoc/sdk/v2"
-import { createStore, produce, reconcile } from "solid-js/store"
-import { useSDK } from "@tui/context/sdk"
-import { Binary } from "@jonsoc/util/binary"
-import { createSimpleContext } from "./helper"
-import type { Snapshot } from "@/snapshot"
-import { useExit } from "./exit"
-import { useArgs } from "./args"
-import { batch, onMount } from "solid-js"
-import { Log } from "@/util/log"
-import type { Path } from "@jonsoc/sdk"
-
-export const { use: useSync, provider: SyncProvider } = createSimpleContext({
-  name: "Sync",
-  init: () => {
-    const [store, setStore] = createStore<{
-      status: "loading" | "partial" | "complete"
-      provider: Provider[]
-      provider_default: Record<string, string>
-      provider_next: ProviderListResponse
-      provider_auth: Record<string, ProviderAuthMethod[]>
-      agent: Agent[]
-      command: Command[]
-      permission: {
-        [sessionID: string]: PermissionRequest[]
-      }
-      question: {
-        [sessionID: string]: QuestionRequest[]
-      }
-      config: Config
-      session: Session[]
-      session_status: {
-        [sessionID: string]: SessionStatus
-      }
-      session_diff: {
-        [sessionID: string]: Snapshot.FileDiff[]
-      }
-      todo: {
-        [sessionID: string]: Todo[]
-      }
-      message: {
-        [sessionID: string]: Message[]
-      }
-      part: {
-        [messageID: string]: Part[]
-      }
-      lsp: LspStatus[]
-      mcp: {
-        [key: string]: McpStatus
-      }
-      mcp_resource: {
-        [key: string]: McpResource
-      }
-      formatter: FormatterStatus[]
-      vcs: VcsInfo | undefined
-      path: Path
-    }>({
-      provider_next: {
-        all: [],
-        default: {},
-        connected: [],
-      },
-      provider_auth: {},
-      config: {},
-      status: "loading",
-      agent: [],
-      permission: {},
-      question: {},
-      command: [],
-      provider: [],
-      provider_default: {},
-      session: [],
-      session_status: {},
-      session_diff: {},
-      todo: {},
-      message: {},
-      part: {},
-      lsp: [],
-      mcp: {},
-      mcp_resource: {},
-      formatter: [],
-      vcs: undefined,
-      path: { state: "", config: "", worktree: "", directory: "" },
-    })
-
-    const sdk = useSDK()
-
-    sdk.event.listen((e) => {
-      const event = e.details
-      switch (event.type) {
-        case "server.instance.disposed":
-          bootstrap()
-          break
-        case "permission.replied": {
-          const requests = store.permission[event.properties.sessionID]
-          if (!requests) break
-          const match = Binary.search(requests, event.properties.requestID, (r) => r.id)
-          if (!match.found) break
-          setStore(
-            "permission",
-            event.properties.sessionID,
-            produce((draft) => {
-              draft.splice(match.index, 1)
-            }),
-          )
-          break
-        }
-
-        case "permission.asked": {
-          const request = event.properties
-          const requests = store.permission[request.sessionID]
-          if (!requests) {
-            setStore("permission", request.sessionID, [request])
-            break
-          }
-          const match = Binary.search(requests, request.id, (r) => r.id)
-          if (match.found) {
-            setStore("permission", request.sessionID, match.index, reconcile(request))
-            break
-          }
-          setStore(
-            "permission",
-            request.sessionID,
-            produce((draft) => {
-              draft.splice(match.index, 0, request)
-            }),
-          )
-          break
-        }
-
-        case "question.replied":
-        case "question.rejected": {
-          const requests = store.question[event.properties.sessionID]
-          if (!requests) break
-          const match = Binary.search(requests, event.properties.requestID, (r) => r.id)
-          if (!match.found) break
-          setStore(
-            "question",
-            event.properties.sessionID,
-            produce((draft) => {
-              draft.splice(match.index, 1)
-            }),
-          )
-          break
-        }
-
-        case "question.asked": {
-          const request = event.properties
-          const requests = store.question[request.sessionID]
-          if (!requests) {
-            setStore("question", request.sessionID, [request])
-            break
-          }
-          const match = Binary.search(requests, request.id, (r) => r.id)
-          if (match.found) {
-            setStore("question", request.sessionID, match.index, reconcile(request))
-            break
-          }
-          setStore(
-            "question",
-            request.sessionID,
-            produce((draft) => {
-              draft.splice(match.index, 0, request)
-            }),
-          )
-          break
-        }
-
-        case "todo.updated":
-          setStore("todo", event.properties.sessionID, event.properties.todos)
-          break
-
-        case "session.diff":
-          setStore("session_diff", event.properties.sessionID, event.properties.diff)
-          break
-
-        case "session.deleted": {
-          const result = Binary.search(store.session, event.properties.info.id, (s) => s.id)
-          if (result.found) {
-            setStore(
-              "session",
-              produce((draft) => {
-                draft.splice(result.index, 1)
-              }),
-            )
-          }
-          break
-        }
-        case "session.updated": {
-          const result = Binary.search(store.session, event.properties.info.id, (s) => s.id)
-          if (result.found) {
-            setStore("session", result.index, reconcile(event.properties.info))
-            break
-          }
-          setStore(
-            "session",
-            produce((draft) => {
-              draft.splice(result.index, 0, event.properties.info)
-            }),
-          )
-          break
-        }
-
-        case "session.status": {
-          setStore("session_status", event.properties.sessionID, event.properties.status)
-          break
-        }
-
-        case "message.updated": {
-          const messages = store.message[event.properties.info.sessionID]
-          if (!messages) {
-            setStore("message", event.properties.info.sessionID, [event.properties.info])
-            break
-          }
-          const result = Binary.search(messages, event.properties.info.id, (m) => m.id)
-          if (result.found) {
-            setStore("message", event.properties.info.sessionID, result.index, reconcile(event.properties.info))
-            break
-          }
-          setStore(
-            "message",
-            event.properties.info.sessionID,
-            produce((draft) => {
-              draft.splice(result.index, 0, event.properties.info)
-            }),
-          )
-          const updated = store.message[event.properties.info.sessionID]
-          if (updated && updated.length > 100) {
-            const oldest = updated[0]
-            batch(() => {
-              setStore(
-                "message",
-                event.properties.info.sessionID,
-                produce((draft) => {
-                  draft.shift()
-                }),
-              )
-              setStore(
-                "part",
-                produce((draft) => {
-                  delete draft[oldest.id]
-                }),
-              )
-            })
-          }
-          break
-        }
-        case "message.removed": {
-          const messages = store.message[event.properties.sessionID]
-          if (!messages) break
-          const result = Binary.search(messages, event.properties.messageID, (m) => m.id)
-          if (result.found) {
-            setStore(
-              "message",
-              event.properties.sessionID,
-              produce((draft) => {
-                draft.splice(result.index, 1)
-              }),
-            )
-          }
-          break
-        }
-        case "message.part.updated": {
-          const parts = store.part[event.properties.part.messageID]
-          if (!parts) {
-            setStore("part", event.properties.part.messageID, [event.properties.part])
-            break
-          }
-          const result = Binary.search(parts, event.properties.part.id, (p) => p.id)
-          if (result.found) {
-            setStore("part", event.properties.part.messageID, result.index, reconcile(event.properties.part))
-            break
-          }
-          setStore(
-            "part",
-            event.properties.part.messageID,
-            produce((draft) => {
-              draft.splice(result.index, 0, event.properties.part)
-            }),
-          )
-          break
-        }
-
-        case "message.part.removed": {
-          const parts = store.part[event.properties.messageID]
-          if (!parts) break
-          const result = Binary.search(parts, event.properties.partID, (p) => p.id)
-          if (result.found)
-            setStore(
-              "part",
-              event.properties.messageID,
-              produce((draft) => {
-                draft.splice(result.index, 1)
-              }),
-            )
-          break
-        }
-
-        case "lsp.updated": {
-          sdk.client.lsp.status().then((x) => setStore("lsp", x.data!))
-          break
-        }
-
-        case "vcs.branch.updated": {
-          setStore("vcs", { branch: event.properties.branch })
-          break
-        }
-      }
-    })
-
-    const exit = useExit()
-    const args = useArgs()
-
-    async function bootstrap() {
-      console.log("bootstrapping")
-      const start = Date.now() - 30 * 24 * 60 * 60 * 1000
-      const sessionListPromise = sdk.client.session
-        .list({ start: start })
-        .then((x) => setStore("session", reconcile((x.data ?? []).toSorted((a, b) => a.id.localeCompare(b.id)))))
-
-      // blocking - include session.list when continuing a session
-      const blockingRequests: Promise<unknown>[] = [
-        sdk.client.config.providers({}, { throwOnError: true }).then((x) => {
-          batch(() => {
-            setStore("provider", reconcile(x.data!.providers))
-            setStore("provider_default", reconcile(x.data!.default))
-          })
-        }),
-        sdk.client.provider.list({}, { throwOnError: true }).then((x) => {
-          batch(() => {
-            setStore("provider_next", reconcile(x.data!))
-          })
-        }),
-        sdk.client.app.agents({}, { throwOnError: true }).then((x) => setStore("agent", reconcile(x.data ?? []))),
-        sdk.client.config.get({}, { throwOnError: true }).then((x) => setStore("config", reconcile(x.data!))),
-        ...(args.continue ? [sessionListPromise] : []),
-      ]
-
-      await Promise.all(blockingRequests)
-        .then(() => {
-          if (store.status !== "complete") setStore("status", "partial")
-          // non-blocking
-          Promise.all([
-            ...(args.continue ? [] : [sessionListPromise]),
-            sdk.client.command.list().then((x) => setStore("command", reconcile(x.data ?? []))),
-            sdk.client.lsp.status().then((x) => setStore("lsp", reconcile(x.data!))),
-            sdk.client.mcp.status().then((x) => setStore("mcp", reconcile(x.data!))),
-            sdk.client.experimental.resource.list().then((x) => setStore("mcp_resource", reconcile(x.data ?? {}))),
-            sdk.client.formatter.status().then((x) => setStore("formatter", reconcile(x.data!))),
-            sdk.client.session.status().then((x) => {
-              setStore("session_status", reconcile(x.data!))
-            }),
-            sdk.client.provider.auth().then((x) => setStore("provider_auth", reconcile(x.data ?? {}))),
-            sdk.client.vcs.get().then((x) => setStore("vcs", reconcile(x.data))),
-            sdk.client.path.get().then((x) => setStore("path", reconcile(x.data!))),
-          ]).then(() => {
-            console.log("Sync complete")
-            setStore("status", "complete")
-          })
-        })
-        .catch(async (e) => {
-          Log.Default.error("tui bootstrap failed", {
-            error: e instanceof Error ? e.message : JSON.stringify(e),
-            name: e instanceof Error ? e.name : undefined,
-            stack: e instanceof Error ? e.stack : undefined,
-            raw: e,
-          })
-          await exit(e)
-        })
-    }
-
-    onMount(() => {
-      bootstrap()
-    })
-
-    const fullSyncedSessions = new Set<string>()
-    const result = {
-      data: store,
-      set: setStore,
-      get status() {
-        return store.status
-      },
-      get ready() {
-        return store.status !== "loading"
-      },
-      session: {
-        get(sessionID: string) {
-          const match = Binary.search(store.session, sessionID, (s) => s.id)
-          if (match.found) return store.session[match.index]
-          return undefined
-        },
-        status(sessionID: string) {
-          const session = result.session.get(sessionID)
-          if (!session) return "idle"
-          if (session.time.compacting) return "compacting"
-          const messages = store.message[sessionID] ?? []
-          const last = messages.at(-1)
-          if (!last) return "idle"
-          if (last.role === "user") return "working"
-          return last.time.completed ? "idle" : "working"
-        },
-        async sync(sessionID: string) {
-          if (fullSyncedSessions.has(sessionID)) return
-          const [session, messages, todo, diff] = await Promise.all([
-            sdk.client.session.get({ sessionID }, { throwOnError: true }),
-            sdk.client.session.messages({ sessionID, limit: 100 }),
-            sdk.client.session.todo({ sessionID }),
-            sdk.client.session.diff({ sessionID }),
-          ])
-          setStore(
-            produce((draft) => {
-              const match = Binary.search(draft.session, sessionID, (s) => s.id)
-              if (match.found) draft.session[match.index] = session.data!
-              if (!match.found) draft.session.splice(match.index, 0, session.data!)
-              draft.todo[sessionID] = todo.data ?? []
-              draft.message[sessionID] = messages.data!.map((x) => x.info)
-              for (const message of messages.data!) {
-                draft.part[message.info.id] = message.parts
-              }
-              draft.session_diff[sessionID] = diff.data ?? []
-            }),
-          )
-          fullSyncedSessions.add(sessionID)
-        },
-      },
-      bootstrap,
-    }
-    return result
-  },
-})

package/src/cli/cmd/tui/context/theme/aura.json

@@ -1,69 +0,0 @@
-{
-  "$schema": "https://jonsoc.com/theme.json",
-  "defs": {
-    "darkBg": "#0f0f0f",
-    "darkBgPanel": "#15141b",
-    "darkBorder": "#2d2d2d",
-    "darkFgMuted": "#6d6d6d",
-    "darkFg": "#edecee",
-    "purple": "#a277ff",
-    "pink": "#f694ff",
-    "blue": "#82e2ff",
-    "red": "#ff6767",
-    "orange": "#ffca85",
-    "cyan": "#61ffca",
-    "green": "#9dff65"
-  },
-  "theme": {
-    "primary": "purple",
-    "secondary": "pink",
-    "accent": "purple",
-    "error": "red",
-    "warning": "orange",
-    "success": "cyan",
-    "info": "purple",
-    "text": "darkFg",
-    "textMuted": "darkFgMuted",
-    "background": "darkBg",
-    "backgroundPanel": "darkBgPanel",
-    "backgroundElement": "darkBgPanel",
-    "border": "darkBorder",
-    "borderActive": "darkFgMuted",
-    "borderSubtle": "darkBorder",
-    "diffAdded": "cyan",
-    "diffRemoved": "red",
-    "diffContext": "darkFgMuted",
-    "diffHunkHeader": "darkFgMuted",
-    "diffHighlightAdded": "cyan",
-    "diffHighlightRemoved": "red",
-    "diffAddedBg": "#354933",
-    "diffRemovedBg": "#3f191a",
-    "diffContextBg": "darkBgPanel",
-    "diffLineNumber": "darkBorder",
-    "diffAddedLineNumberBg": "#162620",
-    "diffRemovedLineNumberBg": "#26161a",
-    "markdownText": "darkFg",
-    "markdownHeading": "purple",
-    "markdownLink": "pink",
-    "markdownLinkText": "purple",
-    "markdownCode": "cyan",
-    "markdownBlockQuote": "darkFgMuted",
-    "markdownEmph": "orange",
-    "markdownStrong": "purple",
-    "markdownHorizontalRule": "darkFgMuted",
-    "markdownListItem": "purple",
-    "markdownListEnumeration": "purple",
-    "markdownImage": "pink",
-    "markdownImageText": "purple",
-    "markdownCodeBlock": "darkFg",
-    "syntaxComment": "darkFgMuted",
-    "syntaxKeyword": "pink",
-    "syntaxFunction": "purple",
-    "syntaxVariable": "purple",
-    "syntaxString": "cyan",
-    "syntaxNumber": "green",
-    "syntaxType": "purple",
-    "syntaxOperator": "pink",
-    "syntaxPunctuation": "darkFg"
-  }
-}