saeeol 1.2.2 → 1.2.4

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

@@ -0,0 +1,713 @@
+import type {
+  Message,
+  Agent,
+  Provider,
+  Session,
+  Part,
+  Config,
+  Todo,
+  Command,
+  PermissionRequest,
+  QuestionRequest,
+  SuggestionRequest, 
+  SessionNetworkWait, 
+  LspStatus,
+  McpStatus,
+  McpResource,
+  FormatterStatus,
+  SessionStatus,
+  ProviderListResponse,
+  ProviderAuthMethod,
+  VcsInfo,
+} from "@saeeol/sdk/v2"
+import { createStore, produce, reconcile } from "solid-js/store"
+import { useProject } from "@tui/context/project"
+import { useEvent } from "@tui/context/event"
+import { useSDK } from "@tui/context/sdk"
+import { Binary } from "@saeeol/core/util/binary"
+import { createSimpleContext } from "./helper"
+import type { Snapshot } from "@/snapshot"
+import { useExit } from "../runtime/exit"
+import { useArgs } from "./args"
+import { batch, createEffect, on, onMount } from "solid-js" 
+import { handleSuggestionEvent } from "@/saeeol/suggestion/tui/sync" 
+import { useToast } from "@tui/ui/toast" 
+import * as Log from "@saeeol/core/util/log"
+import { emptyConsoleState, type ConsoleState } from "@/config/console-state"
+import type { IndexingStatus } from "@saeeol/indexing/status" 
+import { SaeeolIndexing } from "@/saeeol/indexing" 
+import path from "path"
+import { useKV } from "../runtime/kv"
+
+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
+      console_state: ConsoleState
+      provider_auth: Record<string, ProviderAuthMethod[]>
+      agent: Agent[]
+      command: Command[]
+      permission: {
+        [sessionID: string]: PermissionRequest[]
+      }
+      question: {
+        [sessionID: string]: QuestionRequest[]
+      }
+      suggestion: {
+        [sessionID: string]: SuggestionRequest[]
+      }
+      network: {
+        [sessionID: string]: SessionNetworkWait[]
+      }
+      config: Config
+      globalConfig: Config 
+      session: Session[]
+      session_status: {
+        [sessionID: string]: SessionStatus
+      }
+      session_diff: {
+        [sessionID: string]: Omit<Snapshot.FileDiff, "before" | "after">[] 
+      }
+      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
+      indexing: IndexingStatus 
+    }>({
+      provider_next: {
+        all: [],
+        default: {},
+        connected: [],
+        failed: [], 
+      },
+      console_state: emptyConsoleState,
+      provider_auth: {},
+      config: {},
+      globalConfig: {}, 
+      status: "loading",
+      agent: [],
+      permission: {},
+      question: {},
+      suggestion: {},
+      network: {},
+      command: [],
+      provider: [],
+      provider_default: {},
+      session: [],
+      session_status: {},
+      session_diff: {},
+      todo: {},
+      message: {},
+      part: {},
+      lsp: [],
+      mcp: {},
+      mcp_resource: {},
+      formatter: [],
+      vcs: undefined,
+      indexing: { state: "Disabled", message: "Indexing disabled.", processedFiles: 0, totalFiles: 0, percent: 0 }, 
+    })
+
+    const event = useEvent()
+    const project = useProject()
+    const sdk = useSDK()
+    const toast = useToast() 
+    const kv = useKV()
+    function evict(sessionID: string) {
+      // Collect child session IDs so we can evict them too.
+      const children = store.session.filter((s) => s.parentID === sessionID).map((s) => s.id)
+      setStore(
+        produce((draft) => {
+          const messages = draft.message[sessionID]
+          if (messages) {
+            for (const msg of messages) delete draft.part[msg.id]
+          }
+          delete draft.message[sessionID]
+          delete draft.session_diff[sessionID]
+          delete draft.session_status[sessionID]
+          delete draft.todo[sessionID]
+          delete draft.permission[sessionID]
+          delete draft.question[sessionID]
+          delete draft.suggestion[sessionID]
+          delete draft.network[sessionID]
+        }),
+      )
+      fullSyncedSessions.delete(sessionID)
+      for (const child of children) evict(child)
+    }
+
+    // Strip summary.diffs from user messages — the TUI never reads them
+    // and they can carry multi-MB before/after file content strings.
+    function strip(msg: Message): Message {
+      if (msg.role !== "user" || !msg.summary?.diffs) return msg
+      return { ...msg, summary: { ...msg.summary, diffs: [] } } as Message
+    }
+
+    const fullSyncedSessions = new Set<string>()
+    let syncedWorkspace = project.workspace.current()
+
+    function sessionListQuery(): { scope?: "project"; path?: string } {
+      if (!kv.get("session_directory_filter_enabled", true)) return { scope: "project" }
+      if (!project.data.instance.path.worktree || !project.data.instance.path.directory) return { scope: "project" }
+      return {
+        path: path
+          .relative(path.resolve(project.data.instance.path.worktree), project.data.instance.path.directory)
+          .replaceAll("\\", "/"),
+      }
+    }
+
+    function listSessions() {
+      return sdk.client.session
+        .list({ start: Date.now() - 30 * 24 * 60 * 60 * 1000, ...sessionListQuery() })
+        .then((x) => (x.data ?? []).toSorted((a, b) => a.id.localeCompare(b.id)))
+    }
+
+    event.subscribe((event) => {
+      switch (event.type) {
+        case "server.instance.disposed":
+          void 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 "session.network.replied":
+        case "session.network.rejected": {
+          const requests = store.network[event.properties.sessionID]
+          if (!requests) break
+          const match = Binary.search(requests, event.properties.requestID, (r) => r.id)
+          if (!match.found) break
+          setStore(
+            "network",
+            event.properties.sessionID,
+            produce((draft) => {
+              draft.splice(match.index, 1)
+            }),
+          )
+          break
+        }
+        case "suggestion.accepted":
+        case "suggestion.dismissed":
+        case "suggestion.shown": {
+          handleSuggestionEvent(event, store, setStore)
+          break
+        }
+
+        case "session.network.restored": {
+          const requests = store.network[event.properties.sessionID]
+          if (!requests) break
+          const match = Binary.search(requests, event.properties.requestID, (r) => r.id)
+          if (match.found) {
+            setStore("network", event.properties.sessionID, match.index, "restored", true)
+            setStore("network", event.properties.sessionID, match.index, "time", "restored", event.properties.time) 
+          }
+          break
+        }
+
+        case "session.network.asked": {
+          const request = event.properties
+          const requests = store.network[request.sessionID]
+          if (!requests) {
+            setStore("network", request.sessionID, [request])
+            break
+          }
+          const match = Binary.search(requests, request.id, (r) => r.id)
+          if (match.found) {
+            setStore("network", request.sessionID, match.index, reconcile(request))
+            break
+          }
+          setStore(
+            "network",
+            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 sid = event.properties.info.id
+          const match = Binary.search(store.session, sid, (s) => s.id)
+          if (match.found) {
+            setStore(
+              "session",
+              produce((draft) => {
+                draft.splice(match.index, 1)
+              }),
+            )
+          }
+          evict(sid)
+          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 info = strip(event.properties.info)
+          const messages = store.message[info.sessionID]
+          if (!messages) {
+            setStore("message", info.sessionID, [info])
+            break
+          }
+          const result = Binary.search(messages, info.id, (m) => m.id)
+          if (result.found) {
+            setStore("message", info.sessionID, result.index, reconcile(info))
+            break
+          }
+          setStore(
+            "message",
+            info.sessionID,
+            produce((draft) => {
+              draft.splice(result.index, 0, info)
+            }),
+          )
+          const updated = store.message[info.sessionID]
+          if (updated.length > 100) {
+            const oldest = updated[0]
+            batch(() => {
+              setStore(
+                "message",
+                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]
+          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.delta": {
+          const parts = store.part[event.properties.messageID]
+          if (!parts) break
+          const result = Binary.search(parts, event.properties.partID, (p) => p.id)
+          if (!result.found) break
+          setStore(
+            "part",
+            event.properties.messageID,
+            produce((draft) => {
+              const part = draft[result.index]
+              const field = event.properties.field as keyof typeof part
+              const existing = part[field] as string | undefined
+              ;(part[field] as string) = (existing ?? "") + event.properties.delta
+            }),
+          )
+          break
+        }
+
+        case "message.part.removed": {
+          const parts = store.part[event.properties.messageID]
+          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": {
+          const workspace = project.workspace.current()
+          void sdk.client.lsp.status({ workspace }).then((x) => setStore("lsp", x.data ?? []))
+          break
+        }
+
+        case "mcp.tools.changed": {
+          const workspace = project.workspace.current()
+          void sdk.client.mcp.status({ workspace }).then((x) => setStore("mcp", reconcile(x.data ?? {})))
+          break
+        }
+
+        case "vcs.branch.updated": {
+          setStore("vcs", { branch: event.properties.branch })
+          break
+        }
+        case "global.config.updated": {
+          sdk.client.global.config.get().then((x) => {
+            if (x.data) setStore("globalConfig", reconcile(x.data))
+          })
+          sdk.client.config.get().then((x) => {
+            if (x.data) setStore("config", reconcile(x.data))
+          })
+          break
+        }
+        case "indexing.status": {
+          setStore("indexing", reconcile(event.properties.status))
+          break
+        }
+      }
+    })
+
+    const exit = useExit()
+    const args = useArgs()
+
+    async function bootstrap(input: { fatal?: boolean } = {}) {
+      const fatal = input.fatal ?? true
+      const workspace = project.workspace.current()
+      if (workspace !== syncedWorkspace) {
+        fullSyncedSessions.clear()
+        syncedWorkspace = workspace
+      }
+      const projectPromise = project.sync()
+      const sessionListPromise = projectPromise.then(() => listSessions())
+
+      // blocking - include session.list when continuing a session
+      const providersPromise = sdk.client.config.providers({ workspace }, { throwOnError: true })
+      const providerListPromise = sdk.client.provider.list({ workspace }, { throwOnError: true })
+      const consoleStatePromise = sdk.client.experimental.console
+        .get({ workspace }, { throwOnError: true })
+        .then((x) => x.data)
+        .catch(() => emptyConsoleState)
+      const agentsPromise = sdk.client.app.agents({ workspace }, { throwOnError: true })
+      const configPromise = sdk.client.config.get({ workspace }, { throwOnError: true })
+      const globalConfigPromise = sdk.client.global.config.get({ throwOnError: true }) 
+      const blockingRequests: Promise<unknown>[] = [
+        providersPromise,
+        providerListPromise,
+        agentsPromise,
+        configPromise,
+        globalConfigPromise, 
+        projectPromise,
+        ...(args.continue ? [sessionListPromise] : []),
+      ]
+
+      await Promise.all(blockingRequests)
+        .then(async () => {
+          const providersResponse = providersPromise.then((x) => x.data!)
+          const providerListResponse = providerListPromise.then((x) => x.data!)
+          const consoleStateResponse = consoleStatePromise
+          const agentsResponse = agentsPromise.then((x) => x.data ?? [])
+          const configResponse = configPromise.then((x) => x.data!)
+          const globalConfigResponse = globalConfigPromise.then((x) => x.data!) 
+          const sessionListResponse = args.continue ? sessionListPromise : undefined
+
+          return Promise.all([
+            providersResponse,
+            providerListResponse,
+            consoleStateResponse,
+            agentsResponse,
+            configResponse,
+            globalConfigResponse, 
+            ...(sessionListResponse ? [sessionListResponse] : []),
+          ]).then((responses) => {
+            const providers = responses[0]
+            const providerList = responses[1]
+            const consoleState = responses[2]
+            const agents = responses[3]
+            const config = responses[4]
+            const globalConfig = responses[5] 
+            const sessions = responses[6] 
+
+            batch(() => {
+              setStore("provider", reconcile(providers.providers))
+              setStore("provider_default", reconcile(providers.default))
+              setStore("provider_next", reconcile(providerList))
+              setStore("console_state", reconcile(consoleState))
+              setStore("agent", reconcile(agents))
+              setStore("config", reconcile(config))
+              setStore("globalConfig", reconcile(globalConfig)) 
+              if (sessions !== undefined) setStore("session", reconcile(sessions))
+            })
+          })
+        })
+        .then(() => {
+          if (store.status !== "complete") setStore("status", "partial")
+          // non-blocking
+          void Promise.all([
+            ...(args.continue ? [] : [sessionListPromise.then((sessions) => setStore("session", reconcile(sessions)))]),
+            consoleStatePromise.then((consoleState) => setStore("console_state", reconcile(consoleState))),
+            sdk.client.command.list({ workspace }).then((x) => setStore("command", reconcile(x.data ?? []))),
+            sdk.client.lsp.status({ workspace }).then((x) => setStore("lsp", reconcile(x.data ?? []))),
+            sdk.client.mcp.status({ workspace }).then((x) => setStore("mcp", reconcile(x.data ?? {}))),
+            sdk.client.experimental.resource
+              .list({ workspace })
+              .then((x) => setStore("mcp_resource", reconcile(x.data ?? {}))),
+            sdk.client.formatter.status({ workspace }).then((x) => setStore("formatter", reconcile(x.data!))), 
+            sdk.client.network.list().then((x) => {
+              const next: Record<string, SessionNetworkWait[]> = {}
+              for (const item of x.data ?? []) {
+                if (!next[item.sessionID]) next[item.sessionID] = []
+                next[item.sessionID].push(item)
+              }
+              setStore("network", reconcile(next))
+            }),
+            sdk.client.session.status({ workspace }).then((x) => {
+              setStore("session_status", reconcile(x.data ?? {}))
+            }),
+            sdk.client.provider.auth({ workspace }).then((x) => setStore("provider_auth", reconcile(x.data ?? {}))),
+            sdk.client.vcs.get({ workspace }).then((x) => setStore("vcs", reconcile(x.data))),
+            project.workspace.sync(),
+            sdk.client.config
+              .warnings()
+              .then((x) => {
+                const list = x.data ?? []
+                if (list.length === 0) return
+                const first = list[0]
+                const suffix = list.length > 1 ? ` (and ${list.length - 1} more)` : ""
+                toast.show({
+                  title: "Config Warning",
+                  message: first.message + suffix,
+                  variant: "warning",
+                  duration: 0,
+                })
+              })
+              .catch(() => {}),
+            SaeeolIndexing.current().then((x) => setStore("indexing", reconcile(x))),
+          ]).then(() => {
+            setStore("status", "complete")
+            // Re-fetch MCP status after bootstrap completes to catch
+            // servers that finished connecting during the initial load.
+            setTimeout(() => {
+              const ws = project.workspace.current()
+              void sdk.client.mcp.status({ workspace: ws }).then((x) => setStore("mcp", reconcile(x.data ?? {})))
+            }, 3000)
+          })
+        })
+        .catch(async (e) => {
+          Log.Default.error("tui bootstrap failed", {
+            error: e instanceof Error ? e.message : String(e),
+            name: e instanceof Error ? e.name : undefined,
+            stack: e instanceof Error ? e.stack : undefined,
+          })
+          if (fatal) {
+            await exit(e)
+          } else {
+            throw e
+          }
+        })
+    }
+
+    onMount(() => {
+      void bootstrap()
+    })
+    createEffect(
+      on(
+        () => project.workspace.current(),
+        () => {
+          fullSyncedSessions.clear()
+          void bootstrap()
+        },
+        { defer: true },
+      ),
+    )
+
+    const result = {
+      data: store,
+      set: setStore,
+      get status() {
+        return store.status
+      },
+      get ready() {
+        // return true 
+        if (process.env.SAEEOL_FAST_BOOT) return true
+        return store.status !== "loading"
+      },
+      get path() {
+        return project.instance.path()
+      },
+      session: {
+        get(sessionID: string) {
+          const match = Binary.search(store.session, sessionID, (s) => s.id)
+          if (match.found) return store.session[match.index]
+          return undefined
+        },
+        query() {
+          return sessionListQuery()
+        },
+        async refresh() {
+          const list = await listSessions()
+          setStore("session", reconcile(list))
+        },
+        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) => strip(x.info)) 
+              for (const message of messages.data!) {
+                draft.part[message.info.id] = message.parts
+              }
+              draft.session_diff[sessionID] = diff.data ?? []
+            }),
+          )
+          fullSyncedSessions.add(sessionID)
+        },
+        evict, 
+      },
+      bootstrap,
+    }
+    return result
+  },
+})