@agentprojectcontext/apx 1.25.0 → 1.27.1

package/src/tui/context/sync-apx.tsx

@@ -1,284 +0,0 @@
-import { createStore, produce, reconcile } from "solid-js/store"
-import { batch, onMount } from "solid-js"
-import { createSimpleContext } from "./helper"
-import { useSDK } from "./sdk-apx"
-import type { ApxEvent } from "./sdk-apx"
-
-export type ApxSession = {
-  id: string
-  title: string
-  updatedAt?: number
-}
-
-export type ApxMessage = {
-  id: string
-  sessionID: string
-  role: "user" | "assistant" | "shell"
-  text: string
-  streaming?: boolean
-  error?: boolean
-  // Shell-specific
-  shellID?: string
-  command?: string
-  cwd?: string
-  exitCode?: number | null
-}
-
-export const { use: useApxSync, provider: ApxSyncProvider } = createSimpleContext({
-  name: "ApxSync",
-  init: () => {
-    const sdk = useSDK()
-
-    const [store, setStore] = createStore<{
-      status: "loading" | "ready"
-      sessions: ApxSession[]
-      messages: Record<string, ApxMessage[]>
-      currentSessionID: string | undefined
-      previousMessages: Array<{ role: string; content: string }>
-      usage: { input: number; output: number }
-    }>({
-      status: "loading",
-      sessions: [],
-      messages: {},
-      currentSessionID: undefined,
-      previousMessages: [],
-      usage: { input: 0, output: 0 },
-    })
-
-    // Listen to APX stream events
-    sdk.event.on("event", (ev: ApxEvent) => {
-      if (ev.type === "user") {
-        const e = ev
-        batch(() => {
-          setStore(
-            "messages",
-            produce((draft) => {
-              ;(draft[e.sessionID] ??= []).push({
-                id: `user-${Date.now()}`,
-                sessionID: e.sessionID,
-                role: "user",
-                text: e.text,
-              })
-            }),
-          )
-          setStore("previousMessages", (prev) => [...prev, { role: "user", content: e.text }])
-          setStore("currentSessionID", e.sessionID)
-          setStore(
-            "sessions",
-            produce((draft) => {
-              if (!draft.some((s) => s.id === e.sessionID)) {
-                draft.unshift({ id: e.sessionID, title: e.text.slice(0, 60) || "New session" })
-              }
-            }),
-          )
-        })
-      }
-
-      if (ev.type === "chunk") {
-        const e = ev
-        setStore(
-          "messages",
-          produce((draft) => {
-            const msgs = (draft[e.sessionID] ??= [])
-            const last = msgs[msgs.length - 1]
-            if (last?.role === "assistant" && last.streaming) {
-              last.text += e.chunk
-            } else {
-              msgs.push({
-                id: `msg-${Date.now()}`,
-                sessionID: e.sessionID,
-                role: "assistant",
-                text: e.chunk,
-                streaming: true,
-              })
-            }
-          }),
-        )
-      }
-
-      if (ev.type === "final") {
-        const e = ev
-        setStore(
-          "messages",
-          produce((draft) => {
-            const msgs = (draft[e.sessionID] ??= [])
-            const last = msgs[msgs.length - 1]
-            if (last?.role === "assistant" && last.streaming) {
-              // A streaming bubble already exists (chunk events arrived) — finalize it.
-              last.text = e.text
-              last.streaming = false
-            } else {
-              // The super-agent delivers the whole reply in `final` with no
-              // preceding chunks — create the assistant bubble here.
-              msgs.push({
-                id: `msg-${Date.now()}`,
-                sessionID: e.sessionID,
-                role: "assistant",
-                text: e.text,
-                streaming: false,
-              })
-            }
-          }),
-        )
-        setStore("previousMessages", (prev) => [...prev, { role: "assistant", content: e.text }])
-        if (e.usage) {
-          setStore("usage", (u) => ({
-            input: u.input + (e.usage?.input_tokens ?? 0),
-            output: u.output + (e.usage?.output_tokens ?? 0),
-          }))
-        }
-      }
-
-      if (ev.type === "shell.start") {
-        const e = ev
-        setStore(
-          "messages",
-          produce((draft) => {
-            ;(draft[e.sessionID] ??= []).push({
-              id: e.shellID,
-              sessionID: e.sessionID,
-              role: "shell",
-              text: "",
-              streaming: true,
-              shellID: e.shellID,
-              command: e.command,
-              cwd: e.cwd,
-            })
-          }),
-        )
-      }
-
-      if (ev.type === "shell.output") {
-        const e = ev
-        setStore(
-          "messages",
-          produce((draft) => {
-            const msgs = draft[e.sessionID]
-            if (!msgs) return
-            const target = msgs.find((m) => m.role === "shell" && m.shellID === e.shellID)
-            if (target) target.text += e.chunk
-          }),
-        )
-      }
-
-      if (ev.type === "shell.done") {
-        const e = ev
-        setStore(
-          "messages",
-          produce((draft) => {
-            const msgs = draft[e.sessionID]
-            if (!msgs) return
-            const target = msgs.find((m) => m.role === "shell" && m.shellID === e.shellID)
-            if (target) {
-              target.streaming = false
-              target.exitCode = e.exitCode
-              if (e.signal) target.text += `\n[killed by signal ${e.signal}]`
-            }
-          }),
-        )
-      }
-
-      if (ev.type === "error") {
-        const e = ev
-        setStore(
-          "messages",
-          produce((draft) => {
-            const msgs = (draft[e.sessionID] ??= [])
-            const last = msgs[msgs.length - 1]
-            if (last?.role === "assistant" && last.streaming) {
-              last.streaming = false
-              last.error = true
-            } else {
-              msgs.push({
-                id: `err-${Date.now()}`,
-                sessionID: e.sessionID,
-                role: "assistant",
-                text: e.error,
-                streaming: false,
-                error: true,
-              })
-            }
-          }),
-        )
-      }
-    })
-
-    async function loadSessions() {
-      const list = await sdk.listSessions()
-      setStore("sessions", reconcile(list))
-    }
-
-    async function ensureSession(): Promise<string> {
-      if (store.currentSessionID) return store.currentSessionID
-      const id = await sdk.createSession()
-      setStore("currentSessionID", id)
-      setStore(
-        "sessions",
-        produce((draft) => {
-          draft.unshift({ id, title: "New session" })
-        }),
-      )
-      return id
-    }
-
-    async function runShell(command: string, cwd?: string) {
-      const sessionID = await ensureSession()
-      await sdk.runShell(sessionID, command, cwd ?? process.cwd())
-    }
-
-    async function sendMessage(text: string) {
-      const sessionID = await ensureSession()
-      const userMsg: ApxMessage = {
-        id: `user-${Date.now()}`,
-        sessionID,
-        role: "user",
-        text,
-      }
-      batch(() => {
-        setStore(
-          "messages",
-          produce((draft) => {
-            ;(draft[sessionID] ??= []).push(userMsg)
-          }),
-        )
-        setStore("previousMessages", (prev) => [...prev, { role: "user", content: text }])
-      })
-      await sdk.streamChat(sessionID, text, store.previousMessages.slice(-20))
-    }
-
-    onMount(() => {
-      void loadSessions().finally(() => setStore("status", "ready"))
-    })
-
-    return {
-      data: store,
-      get status() {
-        return store.status
-      },
-      get ready() {
-        return store.status === "ready"
-      },
-      session: {
-        get(sessionID: string) {
-          return store.sessions.find((s) => s.id === sessionID)
-        },
-        list() {
-          return store.sessions
-        },
-        current() {
-          return store.currentSessionID
-        },
-        setCurrent(id: string) {
-          setStore("currentSessionID", id)
-        },
-        messages(sessionID: string) {
-          return store.messages[sessionID] ?? []
-        },
-        async refresh() {},
-      },
-      sendMessage,
-      runShell,
-      ensureSession,
-    }
-  },
-})

package/src/tui/routes/session/index.tsx

@@ -1,274 +0,0 @@
-/**
- * APX session chat view.
- *
- * A self-contained chat interface that streams messages through the APX daemon
- * using the APX sync context. The complex opencode session view is replaced with
- * a simple but functional chat layout, plus an APX-tailored sidebar.
- */
-import { For, Show, createMemo, createSignal, onCleanup } from "solid-js"
-import { TextareaRenderable } from "@opentui/core"
-import { useTerminalDimensions } from "@opentui/solid"
-import { useTheme } from "@tui/context/theme"
-import { useRoute } from "@tui/context/route"
-import { useApxSync } from "@tui/context/sync-apx"
-import { useToast, Toast } from "@tui/ui/toast"
-import { useExit } from "@tui/context/exit"
-import { usePromptRef } from "@tui/context/prompt"
-import type { ApxMessage } from "@tui/context/sync-apx"
-import { SidebarApx } from "./sidebar-apx"
-
-/** Split a daemon error like "fetch failed (trace: abc-123)" into message + trace. */
-function parseError(raw: string): { message: string; trace?: string; hint?: string } {
-  const m = raw.match(/^([\s\S]*?)\s*\(trace:\s*([^)]+)\)\s*$/)
-  const message = (m ? m[1] : raw).trim()
-  const trace = m ? m[2].trim() : undefined
-  let hint: string | undefined
-  if (/fetch failed/i.test(message))
-    hint = "No se pudo contactar el modelo. Verificá que el proveedor esté disponible (p. ej. Ollama corriendo)."
-  else if (/not enabled/i.test(message)) hint = "El super-agent está deshabilitado en ~/.apx/config.json."
-  else if (/\b401\b|unauthorized|api[_ ]?key/i.test(message)) hint = "Revisá la API key del proveedor en ~/.apx/config.json."
-  return { message, trace, hint }
-}
-
-function UserBubble(props: { msg: ApxMessage }) {
-  const { theme } = useTheme()
-  return (
-    <box flexDirection="column" marginBottom={1} paddingLeft={2} paddingRight={2}>
-      <text color={theme.primary} bold>
-        You
-      </text>
-      <text color={theme.text} wrap>
-        {props.msg.text}
-      </text>
-    </box>
-  )
-}
-
-function ErrorBubble(props: { msg: ApxMessage }) {
-  const { theme } = useTheme()
-  const parsed = createMemo(() => parseError(props.msg.text))
-  return (
-    <box flexDirection="column" marginBottom={1} paddingLeft={2} paddingRight={2}>
-      <text color={theme.error} bold>
-        ⚠ Error
-      </text>
-      <text color={theme.error} wrap>
-        {parsed().message}
-      </text>
-      <Show when={parsed().hint}>
-        {(hint) => (
-          <text color={theme.textMuted} wrap>
-            {hint()}
-          </text>
-        )}
-      </Show>
-      <Show when={parsed().trace}>
-        {(trace) => <text color={theme.textMuted}>trace: {trace()}</text>}
-      </Show>
-    </box>
-  )
-}
-
-function AssistantBubble(props: { msg: ApxMessage }) {
-  const { theme, syntax } = useTheme()
-  const hasText = () => props.msg.text.trim().length > 0
-  return (
-    <box flexDirection="column" marginBottom={1} paddingLeft={2} paddingRight={2}>
-      <text color={theme.success} bold>
-        {props.msg.streaming ? "Assistant ▸" : "Assistant"}
-      </text>
-      <Show when={hasText()} fallback={<text color={theme.textMuted}>…</text>}>
-        <box flexShrink={0}>
-          <code
-            filetype="markdown"
-            drawUnstyledText={false}
-            streaming={props.msg.streaming ?? false}
-            syntaxStyle={syntax()}
-            content={props.msg.text.trim()}
-            conceal={true}
-            fg={theme.text}
-          />
-        </box>
-      </Show>
-    </box>
-  )
-}
-
-function ShellBubble(props: { msg: ApxMessage }) {
-  const { theme } = useTheme()
-  const header = () => {
-    const code = props.msg.exitCode
-    const status = props.msg.streaming
-      ? "running"
-      : code === 0
-        ? "exit 0"
-        : code == null
-          ? "ended"
-          : `exit ${code}`
-    return `$ ${props.msg.command ?? ""}  · ${status}`
-  }
-  const body = () => props.msg.text || (props.msg.streaming ? "…" : "(no output)")
-  return (
-    <box flexDirection="column" marginBottom={1} paddingLeft={2} paddingRight={2}>
-      <text color={theme.warning ?? theme.primary} bold>
-        {header()}
-      </text>
-      <text color={props.msg.exitCode && props.msg.exitCode !== 0 ? theme.error : theme.text} wrap>
-        {body()}
-      </text>
-    </box>
-  )
-}
-
-export function Session() {
-  const dims = useTerminalDimensions()
-  const { theme } = useTheme()
-  const route = useRoute()
-  const sync = useApxSync()
-  const toast = useToast()
-  const exit = useExit()
-  const promptRef = usePromptRef()
-  const [sending, setSending] = createSignal(false)
-  let inputEl: TextareaRenderable | undefined
-
-  const sessionID = createMemo(() => {
-    if (route.data.type === "session") return route.data.sessionID
-    return sync.session.current() ?? ""
-  })
-
-  const messages = createMemo(() => sync.session.messages(sessionID()))
-
-  onCleanup(() => {
-    promptRef.set(undefined)
-  })
-
-  function makeRef(r: TextareaRenderable) {
-    return {
-      get focused() {
-        return r.focused
-      },
-      get current() {
-        return { input: r.plainText, parts: [] as any[] }
-      },
-      set(prompt: { input: string; parts: any[] }) {
-        r.setText(prompt.input)
-      },
-      reset() {
-        r.clear()
-      },
-      blur() {
-        r.blur()
-      },
-      focus() {
-        r.focus()
-      },
-      submit() {
-        void handleSubmit()
-      },
-    }
-  }
-
-  async function handleSubmit() {
-    if (!inputEl) return
-    const text = inputEl.plainText.trim()
-    if (!text || sending()) return
-
-    // Check for exit commands
-    if (text === "exit" || text === "quit" || text === ":q") {
-      void exit()
-      return
-    }
-
-    inputEl.clear()
-    setSending(true)
-    try {
-      if (text.startsWith("!") && text.length > 1) {
-        await sync.runShell(text.slice(1).trim())
-      } else {
-        await sync.sendMessage(text)
-      }
-    } catch (e) {
-      toast.error(e instanceof Error ? e : new Error(String(e)))
-    } finally {
-      setSending(false)
-    }
-  }
-
-  return (
-    <box flexDirection="column" flexGrow={1} width={dims().width} height={dims().height}>
-      <box flexDirection="row" flexGrow={1} minHeight={0}>
-        {/* Chat column */}
-        <box flexDirection="column" flexGrow={1} minWidth={0}>
-          {/* Message list */}
-          <scrollbox
-            flexGrow={1}
-            stickyScroll
-            stickyStart="bottom"
-            verticalScrollbarOptions={{ visible: true }}
-          >
-            <box flexDirection="column">
-              <Show
-                when={messages().length > 0}
-                fallback={
-                  <box paddingLeft={2} paddingTop={2}>
-                    <text color={theme.textMuted} italic>
-                      Type a message to chat, or prefix with ! to run a shell command (e.g. !ls).
-                    </text>
-                  </box>
-                }
-              >
-                <For each={messages()}>
-                  {(msg) => {
-                    if (msg.role === "user") return <UserBubble msg={msg} />
-                    if (msg.role === "shell") return <ShellBubble msg={msg} />
-                    if (msg.error) return <ErrorBubble msg={msg} />
-                    return <AssistantBubble msg={msg} />
-                  }}
-                </For>
-              </Show>
-              <box height={1} />
-            </box>
-          </scrollbox>
-
-          {/* Input area */}
-          <box
-            flexShrink={0}
-            flexDirection="column"
-            borderTop={1}
-            borderColor={theme.border}
-            backgroundColor={theme.backgroundElement}
-          >
-            <box paddingLeft={2} paddingRight={2} paddingTop={1}>
-              <textarea
-                ref={(r: TextareaRenderable) => {
-                  inputEl = r
-                  promptRef.set(makeRef(r))
-                }}
-                placeholder={sending() ? "Waiting for response…" : "Ask anything... (prefix ! to run shell, e.g. !ls)"}
-                placeholderColor={theme.textMuted}
-                textColor={theme.text}
-                focusedTextColor={theme.text}
-                minHeight={1}
-                maxHeight={6}
-                onSubmit={() => {
-                  setTimeout(() => setTimeout(() => handleSubmit(), 0), 0)
-                }}
-              />
-            </box>
-            <box height={1} paddingLeft={2} paddingRight={2} justifyContent="space-between" flexDirection="row">
-              <Show when={sending()} fallback={<text color={theme.textMuted}>enter send · ! shell · exit quit</text>}>
-                <text color={theme.textMuted} italic>
-                  Streaming…
-                </text>
-              </Show>
-            </box>
-          </box>
-        </box>
-
-        {/* Sidebar */}
-        <SidebarApx sessionID={sessionID()} />
-      </box>
-      <Toast />
-    </box>
-  )
-}

package/src/tui/routes/session/sidebar-apx.tsx

@@ -1,90 +0,0 @@
-/**
- * APX session sidebar.
- *
- * A self-contained panel tailored to APX data (session, agent, model, token
- * usage, working directory). Replaces opencode's plugin-driven sidebar.tsx,
- * which depends on feature plugins APX does not ship.
- */
-import { createMemo, Show } from "solid-js"
-import { useTheme } from "@tui/context/theme"
-import { useApxSync } from "@tui/context/sync-apx"
-import { useSDK } from "@tui/context/sdk-apx"
-import pkg from "../../../../package.json"
-
-function titlecase(value: string) {
-  if (!value) return value
-  return value.charAt(0).toUpperCase() + value.slice(1)
-}
-
-function Section(props: { title: string; children: any }) {
-  const { theme } = useTheme()
-  return (
-    <box flexDirection="column" flexShrink={0} marginBottom={1}>
-      <text fg={theme.text}>
-        <b>{props.title}</b>
-      </text>
-      {props.children}
-    </box>
-  )
-}
-
-export function SidebarApx(props: { sessionID: string }) {
-  const { theme } = useTheme()
-  const sync = useApxSync()
-  const sdk = useSDK()
-
-  const session = createMemo(() => sync.session.get(props.sessionID))
-  const messages = createMemo(() => sync.session.messages(props.sessionID))
-  const usage = createMemo(() => sync.data.usage)
-  const totalTokens = createMemo(() => usage().input + usage().output)
-
-  return (
-    <box
-      backgroundColor={theme.backgroundPanel}
-      width={40}
-      height="100%"
-      flexShrink={0}
-      flexDirection="column"
-      paddingTop={1}
-      paddingBottom={1}
-      paddingLeft={2}
-      paddingRight={2}
-    >
-      <box flexGrow={1} flexDirection="column">
-        <Section title="Sesión">
-          <text fg={theme.textMuted}>{session()?.title || "chat local"}</text>
-        </Section>
-
-        <Section title="Agente">
-          <text fg={theme.textMuted}>{titlecase(sdk.agent)}</text>
-        </Section>
-
-        <Section title="Modelo">
-          <text fg={theme.textMuted} wrap>
-            {sdk.model}
-          </text>
-        </Section>
-
-        <Section title="Contexto">
-          <text fg={theme.textMuted}>{totalTokens().toLocaleString()} tokens</text>
-          <text fg={theme.textMuted}>
-            {usage().input.toLocaleString()} in · {usage().output.toLocaleString()} out
-          </text>
-          <text fg={theme.textMuted}>{messages().length} mensajes</text>
-        </Section>
-
-        <Section title="Directorio">
-          <text fg={theme.textMuted} wrap>
-            {process.cwd()}
-          </text>
-        </Section>
-      </box>
-
-      <box flexShrink={0} paddingTop={1}>
-        <text fg={theme.textMuted}>
-          <span style={{ fg: theme.success }}>•</span> <b>APX</b> <span>{pkg.version}</span>
-        </text>
-      </box>
-    </box>
-  )
-}