@neurocode-ai/tui 1.18.8

package/src/prompt/frecency.tsx

@@ -0,0 +1,80 @@
+import path from "path"
+import { onMount } from "solid-js"
+import { createStore } from "solid-js/store"
+import { createSimpleContext } from "../context/helper"
+import { useTuiPaths } from "../context/runtime"
+import { appendText, readText, writeText } from "../util/persistence"
+
+type FrecencyEntry = { path: string; frequency: number; lastOpen: number }
+
+export const MAX_FRECENCY_ENTRIES = 1000
+
+export function parseFrecency(text: string) {
+  const latest = text
+    .split("\n")
+    .filter(Boolean)
+    .map((line) => {
+      try {
+        return JSON.parse(line) as FrecencyEntry
+      } catch {
+        return undefined
+      }
+    })
+    .filter((line): line is FrecencyEntry => line !== undefined)
+    .reduce<Record<string, FrecencyEntry>>((result, entry) => {
+      result[entry.path] = entry
+      return result
+    }, {})
+  return Object.values(latest)
+    .sort((a, b) => b.lastOpen - a.lastOpen)
+    .slice(0, MAX_FRECENCY_ENTRIES)
+}
+
+function calculateFrecency(entry?: { frequency: number; lastOpen: number }) {
+  if (!entry) return 0
+  return entry.frequency / (1 + (Date.now() - entry.lastOpen) / 86400000)
+}
+
+export const { use: useFrecency, provider: FrecencyProvider } = createSimpleContext({
+  name: "Frecency",
+  init: () => {
+    const paths = useTuiPaths()
+    const frecencyPath = path.join(paths.state, "frecency.jsonl")
+    onMount(async () => {
+      const lines = parseFrecency(await readText(frecencyPath).catch(() => ""))
+      setStore(
+        "data",
+        Object.fromEntries(
+          lines.map((entry) => [entry.path, { frequency: entry.frequency, lastOpen: entry.lastOpen }]),
+        ),
+      )
+      if (lines.length > 0)
+        writeText(frecencyPath, lines.map((entry) => JSON.stringify(entry)).join("\n") + "\n").catch(() => {})
+    })
+
+    const [store, setStore] = createStore({ data: {} as Record<string, { frequency: number; lastOpen: number }> })
+
+    function updateFrecency(filePath: string) {
+      const absolutePath = path.resolve(paths.cwd, filePath)
+      const newEntry = { frequency: (store.data[absolutePath]?.frequency || 0) + 1, lastOpen: Date.now() }
+      setStore("data", absolutePath, newEntry)
+      appendText(frecencyPath, JSON.stringify({ path: absolutePath, ...newEntry }) + "\n").catch(() => {})
+
+      if (Object.keys(store.data).length <= MAX_FRECENCY_ENTRIES) return
+      const sorted = Object.entries(store.data)
+        .sort(([, a], [, b]) => b.lastOpen - a.lastOpen)
+        .slice(0, MAX_FRECENCY_ENTRIES)
+      setStore("data", Object.fromEntries(sorted))
+      writeText(
+        frecencyPath,
+        sorted.map(([entryPath, entry]) => JSON.stringify({ path: entryPath, ...entry })).join("\n") + "\n",
+      ).catch(() => {})
+    }
+
+    return {
+      getFrecency: (filePath: string) => calculateFrecency(store.data[path.resolve(paths.cwd, filePath)]),
+      updateFrecency,
+      data: () => store.data,
+    }
+  },
+})

package/src/prompt/history.tsx

@@ -0,0 +1,111 @@
+import path from "path"
+import { onMount } from "solid-js"
+import { createStore, produce, unwrap } from "solid-js/store"
+import type { AgentPart, FilePart, TextPart } from "@neurocode-ai/sdk/v2"
+import { createSimpleContext } from "../context/helper"
+import { useTuiPaths } from "../context/runtime"
+import { appendText, readText, writeText } from "../util/persistence"
+
+export type PromptInfo = {
+  input: string
+  mode?: "normal" | "shell"
+  parts: (
+    | Omit<FilePart, "id" | "messageID" | "sessionID">
+    | Omit<AgentPart, "id" | "messageID" | "sessionID">
+    | (Omit<TextPart, "id" | "messageID" | "sessionID"> & {
+        source?: {
+          text: {
+            start: number
+            end: number
+            value: string
+          }
+        }
+      })
+  )[]
+}
+
+export const MAX_HISTORY_ENTRIES = 50
+
+export function parsePromptHistory(text: string) {
+  return text
+    .split("\n")
+    .filter(Boolean)
+    .map((line) => {
+      try {
+        return JSON.parse(line) as PromptInfo
+      } catch {
+        return undefined
+      }
+    })
+    .filter((line): line is PromptInfo => line !== undefined)
+    .slice(-MAX_HISTORY_ENTRIES)
+}
+
+export function isDuplicateEntry(previous: PromptInfo | undefined, next: PromptInfo): boolean {
+  if (!previous) return false
+  return JSON.stringify(previous) === JSON.stringify(next)
+}
+
+export const { use: usePromptHistory, provider: PromptHistoryProvider } = createSimpleContext({
+  name: "PromptHistory",
+  init: () => {
+    const paths = useTuiPaths()
+    const historyPath = path.join(paths.state, "prompt-history.jsonl")
+    onMount(async () => {
+      const lines = parsePromptHistory(await readText(historyPath).catch(() => ""))
+      setStore("history", lines)
+
+      // Rewrite valid retained entries to self-heal corruption and enforce the limit.
+      if (lines.length > 0)
+        writeText(historyPath, lines.map((line) => JSON.stringify(line)).join("\n") + "\n").catch(() => {})
+    })
+
+    const [store, setStore] = createStore({
+      index: 0,
+      history: [] as PromptInfo[],
+    })
+
+    return {
+      move(direction: 1 | -1, input: string) {
+        if (!store.history.length) return undefined
+        const current = store.history.at(store.index)
+        if (!current) return undefined
+        if (current.input !== input && input.length) return
+        setStore(
+          produce((draft) => {
+            const next = store.index + direction
+            if (Math.abs(next) > store.history.length) return
+            if (next > 0) return
+            draft.index = next
+          }),
+        )
+        if (store.index === 0) return { input: "", parts: [] }
+        return store.history.at(store.index)
+      },
+      append(item: PromptInfo) {
+        const entry = structuredClone(unwrap(item))
+        if (isDuplicateEntry(store.history.at(-1), entry)) {
+          setStore("index", 0)
+          return
+        }
+        let trimmed = false
+        setStore(
+          produce((draft) => {
+            draft.history.push(entry)
+            if (draft.history.length > MAX_HISTORY_ENTRIES) {
+              draft.history = draft.history.slice(-MAX_HISTORY_ENTRIES)
+              trimmed = true
+            }
+            draft.index = 0
+          }),
+        )
+
+        if (trimmed) {
+          writeText(historyPath, store.history.map((line) => JSON.stringify(line)).join("\n") + "\n").catch(() => {})
+          return
+        }
+        appendText(historyPath, JSON.stringify(entry) + "\n").catch(() => {})
+      },
+    }
+  },
+})

package/src/prompt/part.ts

@@ -0,0 +1,29 @@
+import { displaySlice } from "./display"
+
+export function stripPromptPartIDs<Part extends { id: string; messageID: string; sessionID: string }>(part: Part) {
+  const { id: _id, messageID: _messageID, sessionID: _sessionID, ...rest } = part
+  return rest
+}
+
+export function expandPastedTextPlaceholders(text: string, parts: readonly unknown[]) {
+  return parts.reduce<string>((result, part) => {
+    if (!isPastedTextPart(part)) return result
+    return result.replace(part.source.text.value, part.text)
+  }, text)
+}
+
+function isPastedTextPart(part: unknown): part is { type: "text"; text: string; source: { text: { value: string } } } {
+  if (!part || typeof part !== "object" || !("type" in part) || part.type !== "text") return false
+  if (!("text" in part) || typeof part.text !== "string" || !("source" in part)) return false
+  const source = part.source
+  if (!source || typeof source !== "object" || !("text" in source)) return false
+  const text = source.text
+  return Boolean(text && typeof text === "object" && "value" in text && typeof text.value === "string")
+}
+
+export function expandTrackedPastedText(text: string, ranges: { start: number; end: number; text: string }[]) {
+  return ranges
+    .slice()
+    .sort((a, b) => b.start - a.start)
+    .reduce((result, part) => displaySlice(result, 0, part.start) + part.text + displaySlice(result, part.end), text)
+}

package/src/prompt/stash.tsx

@@ -0,0 +1,89 @@
+import path from "path"
+import { onMount } from "solid-js"
+import { createStore, produce, unwrap } from "solid-js/store"
+import { createSimpleContext } from "../context/helper"
+import { useTuiPaths } from "../context/runtime"
+import { appendText, readText, writeText } from "../util/persistence"
+import type { PromptInfo } from "./history"
+
+export type StashEntry = {
+  input: string
+  parts: PromptInfo["parts"]
+  timestamp: number
+}
+
+export const MAX_STASH_ENTRIES = 50
+
+export function parsePromptStash(text: string) {
+  return text
+    .split("\n")
+    .filter(Boolean)
+    .map((line) => {
+      try {
+        return JSON.parse(line) as StashEntry
+      } catch {
+        return undefined
+      }
+    })
+    .filter((line): line is StashEntry => line !== undefined)
+    .slice(-MAX_STASH_ENTRIES)
+}
+
+export const { use: usePromptStash, provider: PromptStashProvider } = createSimpleContext({
+  name: "PromptStash",
+  init: () => {
+    const paths = useTuiPaths()
+    const stashPath = path.join(paths.state, "prompt-stash.jsonl")
+    onMount(async () => {
+      const lines = parsePromptStash(await readText(stashPath).catch(() => ""))
+      setStore("entries", lines)
+      if (lines.length > 0)
+        writeText(stashPath, lines.map((line) => JSON.stringify(line)).join("\n") + "\n").catch(() => {})
+    })
+
+    const [store, setStore] = createStore({ entries: [] as StashEntry[] })
+
+    return {
+      list() {
+        return store.entries
+      },
+      push(entry: Omit<StashEntry, "timestamp">) {
+        const stash = structuredClone(unwrap({ ...entry, timestamp: Date.now() }))
+        let trimmed = false
+        setStore(
+          produce((draft) => {
+            draft.entries.push(stash)
+            if (draft.entries.length > MAX_STASH_ENTRIES) {
+              draft.entries = draft.entries.slice(-MAX_STASH_ENTRIES)
+              trimmed = true
+            }
+          }),
+        )
+
+        if (trimmed) {
+          writeText(stashPath, store.entries.map((line) => JSON.stringify(line)).join("\n") + "\n").catch(() => {})
+          return
+        }
+        appendText(stashPath, JSON.stringify(stash) + "\n").catch(() => {})
+      },
+      pop() {
+        if (store.entries.length === 0) return undefined
+        const entry = store.entries[store.entries.length - 1]
+        setStore(produce((draft) => void draft.entries.pop()))
+        writeText(
+          stashPath,
+          store.entries.length > 0 ? store.entries.map((line) => JSON.stringify(line)).join("\n") + "\n" : "",
+        ).catch(() => {})
+        return entry
+      },
+      remove(index: number) {
+        if (index < 0 || index >= store.entries.length) return
+        setStore(produce((draft) => void draft.entries.splice(index, 1)))
+        writeText(
+          stashPath,
+          store.entries.length > 0 ? store.entries.map((line) => JSON.stringify(line)).join("\n") + "\n" : "",
+        ).catch(() => {})
+      },
+    }
+  },
+})

package/src/prompt/traits.ts

@@ -0,0 +1,29 @@
+import type { EditorTraits } from "@opentui/core"
+
+export type PromptMode = "normal" | "shell"
+
+export interface PromptTraitsInput {
+  mode: PromptMode
+  autocompleteVisible: boolean
+}
+
+export type PromptTraits = EditorTraits & {
+  owner: "neurocode"
+  role: "prompt"
+}
+
+/** The managed textarea keymap owns `suspend`; these traits only describe capture and status. */
+export function computePromptTraits(input: PromptTraitsInput): PromptTraits {
+  const capture =
+    input.mode === "normal"
+      ? input.autocompleteVisible
+        ? (["escape", "navigate", "submit", "tab"] as const)
+        : (["tab"] as const)
+      : undefined
+  return {
+    capture,
+    status: input.mode === "shell" ? "SHELL" : undefined,
+    owner: "neurocode",
+    role: "prompt",
+  }
+}

package/src/routes/home/session-destination.tsx

@@ -0,0 +1,41 @@
+import {
+  createContext,
+  createMemo,
+  createSignal,
+  useContext,
+  type Accessor,
+  type ParentProps,
+  type Setter,
+} from "solid-js"
+import { useSync } from "../../context/sync"
+import { useTuiPaths } from "../../context/runtime"
+
+export type HomeSessionDestination = { type: "directory"; directory: string; subdirectory: boolean } | { type: "new" }
+
+type Context = {
+  destination: Accessor<HomeSessionDestination | undefined>
+  setDestination: Setter<HomeSessionDestination | undefined>
+  clear: () => void
+}
+
+const HomeSessionDestinationContext = createContext<Context>()
+
+export function HomeSessionDestinationProvider(props: ParentProps) {
+  const sync = useSync()
+  const paths = useTuiPaths()
+  const [selected, setDestination] = createSignal<HomeSessionDestination>()
+  const destination = createMemo<HomeSessionDestination>(
+    () => selected() ?? { type: "directory", directory: sync.path.directory || paths.cwd, subdirectory: false },
+  )
+  return (
+    <HomeSessionDestinationContext.Provider
+      value={{ destination, setDestination, clear: () => setDestination(undefined) }}
+    >
+      {props.children}
+    </HomeSessionDestinationContext.Provider>
+  )
+}
+
+export function useHomeSessionDestination() {
+  return useContext(HomeSessionDestinationContext)
+}

package/src/routes/home.tsx

@@ -0,0 +1,95 @@
+import { Prompt, type PromptRef } from "../component/prompt"
+import { createEffect, createMemo, createSignal, onMount } from "solid-js"
+import { Logo } from "../component/logo"
+import { useSync } from "../context/sync"
+import { Toast } from "../ui/toast"
+import { useArgs } from "../context/args"
+import { useRouteData } from "../context/route"
+import { usePromptRef } from "../context/prompt"
+import { useLocal } from "../context/local"
+import { usePluginRuntime } from "../plugin/runtime"
+import { useEditorContext } from "../context/editor"
+import { useTerminalDimensions } from "@opentui/solid"
+import { useTuiConfig } from "../config"
+import { HomeSessionDestinationProvider } from "./home/session-destination"
+
+let once = false
+const placeholder = {
+  normal: ["Fix a TODO in the codebase", "What is the tech stack of this project?", "Fix broken tests"],
+  shell: ["ls -la", "git status", "pwd"],
+}
+
+export function Home() {
+  const pluginRuntime = usePluginRuntime()
+  const sync = useSync()
+  const route = useRouteData("home")
+  const promptRef = usePromptRef()
+  const [ref, setRef] = createSignal<PromptRef | undefined>()
+  const args = useArgs()
+  const local = useLocal()
+  const editor = useEditorContext()
+  const dimensions = useTerminalDimensions()
+  const tuiConfig = useTuiConfig()
+  const promptMaxWidth = createMemo(() => {
+    const configured = tuiConfig.prompt?.max_width
+    if (configured === "auto") return Math.max(75, Math.floor(dimensions().width * 0.7))
+    return configured ?? 75
+  })
+  let sent = false
+
+  onMount(() => {
+    editor.clearSelection()
+  })
+
+  const bind = (r: PromptRef | undefined) => {
+    setRef(r)
+    promptRef.set(r)
+    if (once || !r) return
+    if (route.prompt) {
+      r.set(route.prompt)
+      once = true
+      return
+    }
+    if (!args.prompt) return
+    r.set({ input: args.prompt, parts: [] })
+    once = true
+  }
+
+  // Wait for sync and model store to be ready before auto-submitting --prompt
+  createEffect(() => {
+    const r = ref()
+    if (sent) return
+    if (!r) return
+    if (!sync.ready || !local.model.ready) return
+    if (!args.prompt) return
+    if (r.current.input !== args.prompt) return
+    sent = true
+    r.submit()
+  })
+
+  return (
+    <HomeSessionDestinationProvider>
+      <box flexGrow={1} alignItems="center" paddingLeft={2} paddingRight={2}>
+        <box flexGrow={1} minHeight={0} />
+        <box height={4} minHeight={0} flexShrink={1} />
+        <box flexShrink={0}>
+          <pluginRuntime.Slot name="home_logo" mode="replace">
+            <Logo />
+          </pluginRuntime.Slot>
+        </box>
+        <box height={1} minHeight={0} flexShrink={1} />
+        <box width="100%" maxWidth={promptMaxWidth()} zIndex={1000} paddingTop={1} flexShrink={0}>
+          <pluginRuntime.Slot name="home_prompt" mode="replace" ref={bind}>
+            <Prompt ref={bind} right={<pluginRuntime.Slot name="home_prompt_right" />} placeholders={placeholder} />
+          </pluginRuntime.Slot>
+        </box>
+        <pluginRuntime.Slot name="home_bottom" />
+        <box flexGrow={1} minHeight={0} />
+        <Toast />
+      </box>
+      <box width="100%" flexShrink={0}>
+        <pluginRuntime.Slot name="home_footer" mode="single_winner" />
+      </box>
+    </HomeSessionDestinationProvider>
+  )
+}

package/src/routes/session/dialog-fork-from-timeline.tsx

@@ -0,0 +1,76 @@
+import { createMemo, onMount } from "solid-js"
+import { useSync } from "../../context/sync"
+import { DialogSelect, type DialogSelectOption } from "../../ui/dialog-select"
+import type { TextPart } from "@neurocode-ai/sdk/v2"
+import { Locale } from "../../util/locale"
+import { useSDK } from "../../context/sdk"
+import { useRoute } from "../../context/route"
+import { useDialog, type DialogContext } from "../../ui/dialog"
+import type { PromptInfo } from "../../component/prompt/history"
+import { stripPromptPartIDs as strip } from "../../prompt/part"
+
+export function DialogForkFromTimeline(props: { sessionID: string; onMove: (messageID?: string) => void }) {
+  const sync = useSync()
+  const dialog = useDialog()
+  const sdk = useSDK()
+  const route = useRoute()
+
+  onMount(() => {
+    dialog.setSize("large")
+  })
+
+  const options = createMemo((): DialogSelectOption<string | undefined>[] => {
+    const messages = sync.data.message[props.sessionID] ?? []
+    const fullSession = {
+      title: "Full session",
+      value: undefined,
+      onSelect: async (dialog: DialogContext) => {
+        const forked = await sdk.client.session.fork({ sessionID: props.sessionID })
+        route.navigate({
+          sessionID: forked.data!.id,
+          type: "session",
+        })
+        dialog.clear()
+      },
+    } satisfies DialogSelectOption<string | undefined>
+    const result = [] as DialogSelectOption<string | undefined>[]
+    for (const message of messages) {
+      if (message.role !== "user") continue
+      const part = (sync.data.part[message.id] ?? []).find(
+        (x) => x.type === "text" && !x.synthetic && !x.ignored,
+      ) as TextPart
+      if (!part) continue
+      result.push({
+        title: part.text.replace(/\n/g, " "),
+        value: message.id,
+        footer: Locale.time(message.time.created),
+        onSelect: async (dialog) => {
+          const forked = await sdk.client.session.fork({
+            sessionID: props.sessionID,
+            messageID: message.id,
+          })
+          const parts = sync.data.part[message.id] ?? []
+          const prompt = parts.reduce(
+            (agg, part) => {
+              if (part.type === "text") {
+                if (!part.synthetic) agg.input += part.text
+              }
+              if (part.type === "file") agg.parts.push(strip(part))
+              return agg
+            },
+            { input: "", parts: [] as PromptInfo["parts"] },
+          )
+          route.navigate({
+            sessionID: forked.data!.id,
+            type: "session",
+            prompt,
+          })
+          dialog.clear()
+        },
+      })
+    }
+    return [fullSession, ...result.reverse()]
+  })
+
+  return <DialogSelect onMove={(option) => props.onMove(option.value)} title="Fork session" options={options()} />
+}

package/src/routes/session/dialog-message.tsx

@@ -0,0 +1,109 @@
+import { createMemo } from "solid-js"
+import { useSync } from "../../context/sync"
+import { DialogSelect } from "../../ui/dialog-select"
+import { useSDK } from "../../context/sdk"
+import { useRoute } from "../../context/route"
+import { useClipboard } from "../../context/clipboard"
+import type { PromptInfo } from "../../component/prompt/history"
+import { stripPromptPartIDs as strip } from "../../prompt/part"
+
+export function DialogMessage(props: {
+  messageID: string
+  sessionID: string
+  setPrompt?: (prompt: PromptInfo) => void
+}) {
+  const sync = useSync()
+  const sdk = useSDK()
+  const message = createMemo(() => sync.data.message[props.sessionID]?.find((x) => x.id === props.messageID))
+  const route = useRoute()
+  const clipboard = useClipboard()
+
+  return (
+    <DialogSelect
+      title="Message Actions"
+      options={[
+        {
+          title: "Revert",
+          value: "session.revert",
+          description: "undo messages and file changes",
+          onSelect: (dialog) => {
+            const msg = message()
+            if (!msg) return
+
+            void sdk.client.session.revert({
+              sessionID: props.sessionID,
+              messageID: msg.id,
+            })
+
+            if (props.setPrompt) {
+              const parts = sync.data.part[msg.id]
+              const promptInfo = parts.reduce(
+                (agg, part) => {
+                  if (part.type === "text") {
+                    if (!part.synthetic) agg.input += part.text
+                  }
+                  if (part.type === "file") agg.parts.push(strip(part))
+                  return agg
+                },
+                { input: "", parts: [] as PromptInfo["parts"] },
+              )
+              props.setPrompt(promptInfo)
+            }
+
+            dialog.clear()
+          },
+        },
+        {
+          title: "Copy",
+          value: "message.copy",
+          description: "message text to clipboard",
+          onSelect: async (dialog) => {
+            const msg = message()
+            if (!msg) return
+
+            const parts = sync.data.part[msg.id]
+            const text = parts.reduce((agg, part) => {
+              if (part.type === "text" && !part.synthetic) {
+                agg += part.text
+              }
+              return agg
+            }, "")
+
+            await clipboard.write?.(text)
+            dialog.clear()
+          },
+        },
+        {
+          title: "Fork",
+          value: "session.fork",
+          description: "create a new session",
+          onSelect: async (dialog) => {
+            const result = await sdk.client.session.fork({
+              sessionID: props.sessionID,
+              messageID: props.messageID,
+            })
+            const msg = message()
+            const prompt = msg
+              ? sync.data.part[msg.id].reduce(
+                  (agg, part) => {
+                    if (part.type === "text") {
+                      if (!part.synthetic) agg.input += part.text
+                    }
+                    if (part.type === "file") agg.parts.push(part)
+                    return agg
+                  },
+                  { input: "", parts: [] as PromptInfo["parts"] },
+                )
+              : undefined
+            route.navigate({
+              sessionID: result.data!.id,
+              type: "session",
+              prompt,
+            })
+            dialog.clear()
+          },
+        },
+      ]}
+    />
+  )
+}

package/src/routes/session/dialog-subagent.tsx

@@ -0,0 +1,26 @@
+import { DialogSelect } from "../../ui/dialog-select"
+import { useRoute } from "../../context/route"
+
+export function DialogSubagent(props: { sessionID: string }) {
+  const route = useRoute()
+
+  return (
+    <DialogSelect
+      title="Subagent Actions"
+      options={[
+        {
+          title: "Open",
+          value: "subagent.view",
+          description: "the subagent's session",
+          onSelect: (dialog) => {
+            route.navigate({
+              type: "session",
+              sessionID: props.sessionID,
+            })
+            dialog.clear()
+          },
+        },
+      ]}
+    />
+  )
+}