@neurocode-ai/tui 1.18.8

package/src/context/data.tsx

@@ -0,0 +1,569 @@
+import type {
+  AgentV2Info,
+  CommandV2Info,
+  IntegrationInfo,
+  LocationRef,
+  ModelV2Info,
+  PermissionSavedInfo,
+  PermissionV2Request,
+  ProviderV2Info,
+  QuestionV2Request,
+  ReferenceInfo,
+  SessionMessage,
+  SessionMessageAssistant,
+  SessionMessageAssistantReasoning,
+  SessionMessageAssistantText,
+  SessionMessageAssistantTool,
+  SessionV2Info,
+  SkillV2Info,
+  V2Event,
+} from "@neurocode-ai/sdk/v2"
+import { createStore, produce } from "solid-js/store"
+import { createSimpleContext } from "./helper"
+import { useSDK } from "./sdk"
+import { useEvent } from "./event"
+import { createSignal, onCleanup, onMount } from "solid-js"
+
+type LocationData = {
+  agent?: AgentV2Info[]
+  command?: CommandV2Info[]
+  integration?: IntegrationInfo[]
+  model?: ModelV2Info[]
+  provider?: ProviderV2Info[]
+  reference?: ReferenceInfo[]
+  skill?: SkillV2Info[]
+}
+
+type Data = {
+  session: {
+    info: Record<string, SessionV2Info>
+    message: Record<string, SessionMessage[]>
+    permission: Record<string, PermissionV2Request[]>
+    question: Record<string, QuestionV2Request[]>
+  }
+  project: {
+    permission: Record<string, PermissionSavedInfo[]>
+  }
+  location: Record<string, LocationData>
+}
+
+function locationKey(location: LocationRef) {
+  return JSON.stringify([location.directory, location.workspaceID])
+}
+
+function locationQuery(ref?: LocationRef) {
+  return ref ? { directory: ref.directory, workspace: ref.workspaceID } : undefined
+}
+
+export const { use: useData, provider: DataProvider } = createSimpleContext({
+  name: "Data",
+  init: () => {
+    const [store, setStore] = createStore<Data>({
+      session: {
+        info: {},
+        message: {},
+        permission: {},
+        question: {},
+      },
+      project: {
+        permission: {},
+      },
+      location: {},
+    })
+
+    const sdk = useSDK()
+    const events = useEvent()
+    const [defaultLocation, setDefaultLocation] = createSignal<LocationRef>({
+      directory: sdk.directory ?? process.cwd(),
+    })
+
+    const message = {
+      update(sessionID: string, fn: (messages: SessionMessage[]) => void) {
+        setStore(
+          "session",
+          "message",
+          produce((draft) => {
+            fn((draft[sessionID] ??= []))
+          }),
+        )
+      },
+      prepend(messages: SessionMessage[], item: SessionMessage) {
+        if (messages.some((existing) => existing.id === item.id)) return
+        messages.unshift(item)
+      },
+      activeAssistant(messages: SessionMessage[]) {
+        const item = messages.find((item) => item.type === "assistant" && !item.time.completed)
+        return item?.type === "assistant" ? item : undefined
+      },
+      assistant(messages: SessionMessage[], messageID: string) {
+        const item = messages.find((item) => item.type === "assistant" && item.id === messageID)
+        return item?.type === "assistant" ? item : undefined
+      },
+      activeShell(messages: SessionMessage[], callID: string) {
+        const item = messages.find((item) => item.type === "shell" && item.callID === callID)
+        return item?.type === "shell" ? item : undefined
+      },
+      latestTool(assistant: SessionMessageAssistant | undefined, callID?: string) {
+        return assistant?.content.findLast(
+          (item): item is SessionMessageAssistantTool =>
+            item.type === "tool" && (callID === undefined || item.id === callID),
+        )
+      },
+      latestText(assistant: SessionMessageAssistant | undefined, textID: string) {
+        return assistant?.content.findLast(
+          (item): item is SessionMessageAssistantText => item.type === "text" && item.id === textID,
+        )
+      },
+      latestReasoning(assistant: SessionMessageAssistant | undefined, reasoningID: string) {
+        return assistant?.content.findLast(
+          (item): item is SessionMessageAssistantReasoning => item.type === "reasoning" && item.id === reasoningID,
+        )
+      },
+    }
+
+    function handleEvent(event: V2Event) {
+      switch (event.type) {
+        case "catalog.updated":
+          void Promise.all([
+            result.location.model.refresh(event.location),
+            result.location.provider.refresh(event.location),
+          ])
+          break
+        case "session.next.agent.switched":
+          message.update(event.data.sessionID, (draft) => {
+            message.prepend(draft, {
+              id: event.data.messageID,
+              type: "agent-switched",
+              agent: event.data.agent,
+              time: { created: event.data.timestamp },
+            })
+          })
+          break
+        case "session.next.model.switched":
+          message.update(event.data.sessionID, (draft) => {
+            message.prepend(draft, {
+              id: event.data.messageID,
+              type: "model-switched",
+              model: event.data.model,
+              time: { created: event.data.timestamp },
+            })
+          })
+          break
+        case "session.next.prompted": {
+          message.update(event.data.sessionID, (draft) => {
+            message.prepend(draft, {
+              id: event.data.messageID,
+              type: "user",
+              text: event.data.prompt.text,
+              files: event.data.prompt.files,
+              agents: event.data.prompt.agents,
+              time: { created: event.data.timestamp },
+            })
+          })
+          break
+        }
+        case "session.next.prompt.admitted":
+          break
+        case "session.next.context.updated":
+          message.update(event.data.sessionID, (draft) => {
+            message.prepend(draft, {
+              id: event.data.messageID,
+              type: "system",
+              text: event.data.text,
+              time: { created: event.data.timestamp },
+            })
+          })
+          break
+        case "session.next.synthetic":
+          message.update(event.data.sessionID, (draft) => {
+            message.prepend(draft, {
+              id: event.data.messageID,
+              type: "synthetic",
+              sessionID: event.data.sessionID,
+              text: event.data.text,
+              time: { created: event.data.timestamp },
+            })
+          })
+          break
+        case "session.next.shell.started":
+          message.update(event.data.sessionID, (draft) => {
+            message.prepend(draft, {
+              id: event.data.messageID,
+              type: "shell",
+              callID: event.data.callID,
+              command: event.data.command,
+              output: "",
+              time: { created: event.data.timestamp },
+            })
+          })
+          break
+        case "session.next.shell.ended":
+          message.update(event.data.sessionID, (draft) => {
+            const match = message.activeShell(draft, event.data.callID)
+            if (!match) return
+            match.output = event.data.output
+            match.time.completed = event.data.timestamp
+          })
+          break
+        case "session.next.step.started":
+          message.update(event.data.sessionID, (draft) => {
+            if (draft.some((message) => message.id === event.data.assistantMessageID)) return
+            const currentAssistant = message.activeAssistant(draft)
+            if (currentAssistant) currentAssistant.time.completed = event.data.timestamp
+            message.prepend(draft, {
+              id: event.data.assistantMessageID,
+              type: "assistant",
+              agent: event.data.agent,
+              model: event.data.model,
+              content: [],
+              snapshot: event.data.snapshot ? { start: event.data.snapshot } : undefined,
+              time: { created: event.data.timestamp },
+            })
+          })
+          break
+        case "session.next.step.ended":
+          message.update(event.data.sessionID, (draft) => {
+            const currentAssistant = message.assistant(draft, event.data.assistantMessageID)
+            if (!currentAssistant) return
+            currentAssistant.time.completed = event.data.timestamp
+            currentAssistant.finish = event.data.finish
+            currentAssistant.cost = event.data.cost
+            currentAssistant.tokens = event.data.tokens
+            if (event.data.snapshot)
+              currentAssistant.snapshot = { ...currentAssistant.snapshot, end: event.data.snapshot }
+          })
+          break
+        case "session.next.step.failed":
+          message.update(event.data.sessionID, (draft) => {
+            const currentAssistant = message.assistant(draft, event.data.assistantMessageID)
+            if (!currentAssistant) return
+            currentAssistant.time.completed = event.data.timestamp
+            currentAssistant.finish = "error"
+            currentAssistant.error = event.data.error
+          })
+          break
+        case "session.next.text.started":
+          message.update(event.data.sessionID, (draft) => {
+            message.assistant(draft, event.data.assistantMessageID)?.content.push({
+              type: "text",
+              id: event.data.textID,
+              text: "",
+            })
+          })
+          break
+        case "session.next.text.delta":
+          message.update(event.data.sessionID, (draft) => {
+            const match = message.latestText(message.assistant(draft, event.data.assistantMessageID), event.data.textID)
+            if (match) match.text += event.data.delta
+          })
+          break
+        case "session.next.text.ended":
+          message.update(event.data.sessionID, (draft) => {
+            const match = message.latestText(message.assistant(draft, event.data.assistantMessageID), event.data.textID)
+            if (match) match.text = event.data.text
+          })
+          break
+        case "session.next.tool.input.started":
+          message.update(event.data.sessionID, (draft) => {
+            message.assistant(draft, event.data.assistantMessageID)?.content.push({
+              type: "tool",
+              id: event.data.callID,
+              name: event.data.name,
+              time: { created: event.data.timestamp },
+              state: { status: "pending", input: "" },
+            })
+          })
+          break
+        case "session.next.tool.input.delta":
+          message.update(event.data.sessionID, (draft) => {
+            const match = message.latestTool(message.assistant(draft, event.data.assistantMessageID), event.data.callID)
+            if (match?.state.status === "pending") match.state.input += event.data.delta
+          })
+          break
+        case "session.next.tool.input.ended":
+          message.update(event.data.sessionID, (draft) => {
+            const match = message.latestTool(message.assistant(draft, event.data.assistantMessageID), event.data.callID)
+            if (match?.state.status === "pending") match.state.input = event.data.text
+          })
+          break
+        case "session.next.tool.called":
+          message.update(event.data.sessionID, (draft) => {
+            const match = message.latestTool(message.assistant(draft, event.data.assistantMessageID), event.data.callID)
+            if (!match) return
+            match.time.ran = event.data.timestamp
+            match.provider = event.data.provider
+            match.state = { status: "running", input: event.data.input, structured: {}, content: [] }
+          })
+          break
+        case "session.next.tool.progress":
+          message.update(event.data.sessionID, (draft) => {
+            const match = message.latestTool(message.assistant(draft, event.data.assistantMessageID), event.data.callID)
+            if (match?.state.status !== "running") return
+            match.state.structured = event.data.structured
+            match.state.content = [...event.data.content]
+          })
+          break
+        case "session.next.tool.success":
+          message.update(event.data.sessionID, (draft) => {
+            const match = message.latestTool(message.assistant(draft, event.data.assistantMessageID), event.data.callID)
+            if (match?.state.status !== "running") return
+            match.state = {
+              status: "completed",
+              input: match.state.input,
+              structured: event.data.structured,
+              content: [...event.data.content],
+              result: event.data.result,
+            }
+            match.provider = {
+              executed: event.data.provider.executed || match.provider?.executed === true,
+              metadata: match.provider?.metadata,
+              resultMetadata: event.data.provider.metadata,
+            }
+            match.time.completed = event.data.timestamp
+          })
+          break
+        case "session.next.tool.failed":
+          message.update(event.data.sessionID, (draft) => {
+            const match = message.latestTool(message.assistant(draft, event.data.assistantMessageID), event.data.callID)
+            if (!match || (match.state.status !== "pending" && match.state.status !== "running")) return
+            match.state = {
+              status: "error",
+              error: event.data.error,
+              input: typeof match.state.input === "string" ? {} : match.state.input,
+              structured: match.state.status === "running" ? match.state.structured : {},
+              content: match.state.status === "running" ? match.state.content : [],
+              result: event.data.result,
+            }
+            match.provider = {
+              executed: event.data.provider.executed || match.provider?.executed === true,
+              metadata: match.provider?.metadata,
+              resultMetadata: event.data.provider.metadata,
+            }
+            match.time.completed = event.data.timestamp
+          })
+          break
+        case "session.next.reasoning.started":
+          message.update(event.data.sessionID, (draft) => {
+            message.assistant(draft, event.data.assistantMessageID)?.content.push({
+              type: "reasoning",
+              id: event.data.reasoningID,
+              text: "",
+              providerMetadata: event.data.providerMetadata,
+            })
+          })
+          break
+        case "session.next.reasoning.delta":
+          message.update(event.data.sessionID, (draft) => {
+            const match = message.latestReasoning(
+              message.assistant(draft, event.data.assistantMessageID),
+              event.data.reasoningID,
+            )
+            if (match) match.text += event.data.delta
+          })
+          break
+        case "session.next.reasoning.ended":
+          message.update(event.data.sessionID, (draft) => {
+            const match = message.latestReasoning(
+              message.assistant(draft, event.data.assistantMessageID),
+              event.data.reasoningID,
+            )
+            if (match) {
+              match.text = event.data.text
+              if (event.data.providerMetadata !== undefined) match.providerMetadata = event.data.providerMetadata
+            }
+          })
+          break
+        case "session.next.retried":
+        case "session.next.compaction.started":
+        case "session.next.compaction.delta":
+          break
+        case "session.next.compaction.ended":
+          message.update(event.data.sessionID, (draft) => {
+            message.prepend(draft, {
+              id: event.data.messageID,
+              type: "compaction",
+              reason: event.data.reason,
+              summary: event.data.text,
+              recent: event.data.recent,
+              time: { created: event.data.timestamp },
+            })
+          })
+          break
+        case "reference.updated":
+          void result.location.reference.refresh()
+          break
+        case "integration.updated":
+          void Promise.all([
+            result.location.integration.refresh(event.location),
+            result.location.model.refresh(event.location),
+            result.location.provider.refresh(event.location),
+          ])
+          break
+      }
+    }
+
+    onMount(() => {
+      const unsub = events.subscribe((event, metadata) => {
+        handleEvent({
+          ...event,
+          data: event.properties,
+          location: { directory: metadata.directory, workspaceID: metadata.workspace },
+        } as V2Event)
+      })
+      onCleanup(unsub)
+    })
+
+    const result = {
+      session: {
+        get(sessionID: string) {
+          return store.session.info[sessionID]
+        },
+        async refresh(sessionID: string) {
+          const result = await sdk.client.v2.session.get({ sessionID }, { throwOnError: true })
+          setStore("session", "info", sessionID, result.data.data)
+        },
+        message: {
+          list(sessionID: string) {
+            return store.session.message[sessionID]
+          },
+          async refresh(sessionID: string) {
+            const result = await sdk.client.v2.session.messages({ sessionID }, { throwOnError: true })
+            setStore("session", "message", sessionID, result.data.data)
+          },
+        },
+        permission: {
+          list(sessionID: string) {
+            return store.session.permission[sessionID]
+          },
+          async refresh(sessionID: string) {
+            const result = await sdk.client.v2.session.permission.list({ sessionID }, { throwOnError: true })
+            setStore("session", "permission", sessionID, result.data.data)
+          },
+        },
+        question: {
+          list(sessionID: string) {
+            return store.session.question[sessionID]
+          },
+          async refresh(sessionID: string) {
+            const result = await sdk.client.v2.session.question.list({ sessionID }, { throwOnError: true })
+            setStore("session", "question", sessionID, result.data.data)
+          },
+        },
+      },
+      project: {
+        permission: {
+          list(projectID: string) {
+            return store.project.permission[projectID]
+          },
+          async refresh(projectID: string) {
+            const result = await sdk.client.v2.permission.saved.list({ projectID }, { throwOnError: true })
+            setStore("project", "permission", projectID, result.data.data)
+          },
+        },
+      },
+      location: {
+        default() {
+          return defaultLocation()
+        },
+        async refresh(ref?: LocationRef) {
+          const response = await sdk.client.v2.location.get({ location: locationQuery(ref) }, { throwOnError: true })
+          const location = response.data
+          const key = locationKey(location)
+          if (!store.location[key]) setStore("location", key, {})
+          if (!ref) setDefaultLocation({ directory: location.directory, workspaceID: location.workspaceID })
+        },
+        agent: {
+          list(location?: LocationRef) {
+            return store.location[locationKey(location ?? defaultLocation())]?.agent
+          },
+          async refresh(ref?: LocationRef) {
+            const result = await sdk.client.v2.agent.list({ location: locationQuery(ref) }, { throwOnError: true })
+            const key = locationKey(result.data.location)
+            setStore("location", key, "agent", result.data.data)
+          },
+        },
+        command: {
+          list(location?: LocationRef) {
+            return store.location[locationKey(location ?? defaultLocation())]?.command
+          },
+          async refresh(ref?: LocationRef) {
+            const result = await sdk.client.v2.command.list({ location: locationQuery(ref) }, { throwOnError: true })
+            const key = locationKey(result.data.location)
+            setStore("location", key, "command", result.data.data)
+          },
+        },
+        integration: {
+          list(location?: LocationRef) {
+            return store.location[locationKey(location ?? defaultLocation())]?.integration
+          },
+          async refresh(ref?: LocationRef) {
+            const result = await sdk.client.v2.integration.list(
+              { location: locationQuery(ref) },
+              { throwOnError: true },
+            )
+            const key = locationKey(result.data.location)
+            setStore("location", key, "integration", result.data.data)
+          },
+        },
+        model: {
+          list(location?: LocationRef) {
+            return store.location[locationKey(location ?? defaultLocation())]?.model
+          },
+          async refresh(ref?: LocationRef) {
+            const result = await sdk.client.v2.model.list({ location: locationQuery(ref) }, { throwOnError: true })
+            const key = locationKey(result.data.location)
+            setStore("location", key, "model", result.data.data)
+          },
+        },
+        provider: {
+          list(location?: LocationRef) {
+            return store.location[locationKey(location ?? defaultLocation())]?.provider
+          },
+          async refresh(ref?: LocationRef) {
+            const result = await sdk.client.v2.provider.list({ location: locationQuery(ref) }, { throwOnError: true })
+            const key = locationKey(result.data.location)
+            setStore("location", key, "provider", result.data.data)
+          },
+        },
+        reference: {
+          list(location?: LocationRef) {
+            return store.location[locationKey(location ?? defaultLocation())]?.reference
+          },
+          async refresh(ref?: LocationRef) {
+            const result = await sdk.client.v2.reference.list({ location: locationQuery(ref) }, { throwOnError: true })
+            const key = locationKey(result.data.location)
+            setStore("location", key, "reference", result.data.data)
+          },
+        },
+        skill: {
+          list(location?: LocationRef) {
+            return store.location[locationKey(location ?? defaultLocation())]?.skill
+          },
+          async refresh(ref?: LocationRef) {
+            const result = await sdk.client.v2.skill.list({ location: locationQuery(ref) }, { throwOnError: true })
+            const key = locationKey(result.data.location)
+            setStore("location", key, "skill", result.data.data)
+          },
+        },
+      },
+    }
+
+    onMount(() => {
+      void Promise.allSettled([
+        result.location.refresh(),
+        result.location.agent.refresh(),
+        result.location.integration.refresh(),
+        result.location.model.refresh(),
+        result.location.provider.refresh(),
+        result.location.reference.refresh(),
+        result.location.command.refresh(),
+        result.location.skill.refresh(),
+      ]).then((settled) => {
+        for (const failure of settled.filter((item) => item.status === "rejected"))
+          console.error("Failed to refresh default location data", failure.reason)
+      })
+    })
+
+    return result
+  },
+})

package/src/context/directory.ts

@@ -0,0 +1,17 @@
+import { createMemo } from "solid-js"
+import { useProject } from "./project"
+import { useSync } from "./sync"
+import { abbreviateHome } from "../runtime"
+import { useTuiPaths } from "./runtime"
+
+export function useDirectory() {
+  const project = useProject()
+  const sync = useSync()
+  const paths = useTuiPaths()
+  return createMemo(() => {
+    const directory = project.instance.path().directory || paths.cwd
+    const result = abbreviateHome(directory, paths.home)
+    if (sync.data.vcs?.branch) return result + ":" + sync.data.vcs.branch
+    return result
+  })
+}