saeeol 1.1.0 → 1.1.1

package/src/cli/cmd/tui/component/prompt/frecency.tsx

@@ -0,0 +1,90 @@
+import path from "path"
+import { Global } from "@saeeol/core/global"
+import { Filesystem } from "@/util/filesystem"
+import { onMount } from "solid-js"
+import { createStore } from "solid-js/store"
+import { createSimpleContext } from "../../context/helper"
+import { appendFile, writeFile } from "fs/promises"
+
+function calculateFrecency(entry?: { frequency: number; lastOpen: number }): number {
+  if (!entry) return 0
+  const daysSince = (Date.now() - entry.lastOpen) / 86400000 // ms per day
+  const weight = 1 / (1 + daysSince)
+  return entry.frequency * weight
+}
+
+const MAX_FRECENCY_ENTRIES = 1000
+
+export const { use: useFrecency, provider: FrecencyProvider } = createSimpleContext({
+  name: "Frecency",
+  init: () => {
+    const frecencyPath = path.join(Global.Path.state, "frecency.jsonl")
+    onMount(async () => {
+      const text = await Filesystem.readText(frecencyPath).catch(() => "")
+      const lines = text
+        .split("\n")
+        .filter(Boolean)
+        .map((line) => {
+          try {
+            return JSON.parse(line) as { path: string; frequency: number; lastOpen: number }
+          } catch {
+            return null
+          }
+        })
+        .filter((line): line is { path: string; frequency: number; lastOpen: number } => line !== null)
+
+      const latest = lines.reduce(
+        (acc, entry) => {
+          acc[entry.path] = entry
+          return acc
+        },
+        {} as Record<string, { path: string; frequency: number; lastOpen: number }>,
+      )
+
+      const sorted = Object.values(latest)
+        .sort((a, b) => b.lastOpen - a.lastOpen)
+        .slice(0, MAX_FRECENCY_ENTRIES)
+
+      setStore(
+        "data",
+        Object.fromEntries(
+          sorted.map((entry) => [entry.path, { frequency: entry.frequency, lastOpen: entry.lastOpen }]),
+        ),
+      )
+
+      if (sorted.length > 0) {
+        const content = sorted.map((entry) => JSON.stringify(entry)).join("\n") + "\n"
+        writeFile(frecencyPath, content).catch(() => {})
+      }
+    })
+
+    const [store, setStore] = createStore({
+      data: {} as Record<string, { frequency: number; lastOpen: number }>,
+    })
+
+    function updateFrecency(filePath: string) {
+      const absolutePath = path.resolve(process.cwd(), filePath)
+      const newEntry = {
+        frequency: (store.data[absolutePath]?.frequency || 0) + 1,
+        lastOpen: Date.now(),
+      }
+      setStore("data", absolutePath, newEntry)
+      appendFile(frecencyPath, JSON.stringify({ path: absolutePath, ...newEntry }) + "\n").catch(() => {})
+
+      if (Object.keys(store.data).length > MAX_FRECENCY_ENTRIES) {
+        const sorted = Object.entries(store.data)
+          .sort(([, a], [, b]) => b.lastOpen - a.lastOpen)
+          .slice(0, MAX_FRECENCY_ENTRIES)
+        setStore("data", Object.fromEntries(sorted))
+        const content = sorted.map(([path, entry]) => JSON.stringify({ path, ...entry })).join("\n") + "\n"
+        writeFile(frecencyPath, content).catch(() => {})
+      }
+    }
+
+    return {
+      getFrecency: (filePath: string) => calculateFrecency(store.data[path.resolve(process.cwd(), filePath)]),
+      updateFrecency,
+      data: () => store.data,
+    }
+  },
+})

package/src/cli/cmd/tui/component/prompt/history.tsx

@@ -0,0 +1,108 @@
+import path from "path"
+import { Global } from "@saeeol/core/global"
+import { Filesystem } from "@/util/filesystem"
+import { onMount } from "solid-js"
+import { createStore, produce, unwrap } from "solid-js/store"
+import { createSimpleContext } from "../../context/helper"
+import { appendFile, writeFile } from "fs/promises"
+import type { AgentPart, FilePart, TextPart } from "@saeeol/sdk/v2"
+
+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
+          }
+        }
+      })
+  )[]
+}
+
+const MAX_HISTORY_ENTRIES = 50
+
+export const { use: usePromptHistory, provider: PromptHistoryProvider } = createSimpleContext({
+  name: "PromptHistory",
+  init: () => {
+    const historyPath = path.join(Global.Path.state, "prompt-history.jsonl")
+    onMount(async () => {
+      const text = await Filesystem.readText(historyPath).catch(() => "")
+      const lines = text
+        .split("\n")
+        .filter(Boolean)
+        .map((line) => {
+          try {
+            return JSON.parse(line)
+          } catch {
+            return null
+          }
+        })
+        .filter((line): line is PromptInfo => line !== null)
+        .slice(-MAX_HISTORY_ENTRIES)
+
+      setStore("history", lines)
+
+      // Rewrite file with only valid entries to self-heal corruption
+      if (lines.length > 0) {
+        const content = lines.map((line) => JSON.stringify(line)).join("\n") + "\n"
+        writeFile(historyPath, content).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))
+        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) {
+          const content = store.history.map((line) => JSON.stringify(line)).join("\n") + "\n"
+          writeFile(historyPath, content).catch(() => {})
+          return
+        }
+
+        appendFile(historyPath, JSON.stringify(entry) + "\n").catch(() => {})
+      },
+    }
+  },
+})

package/src/cli/cmd/tui/component/prompt/index.tsx

@@ -0,0 +1,216 @@
+import { BoxRenderable, TextareaRenderable, RGBA } from "@opentui/core"
+import { createEffect, createMemo, createSignal } from "solid-js"
+import { useTheme, tint } from "@tui/context/theme"
+import { SplitBorder } from "@tui/component/border"
+import { useCommandDialog } from "../dialog-command"
+import { type AutocompleteRef, Autocomplete } from "./autocomplete"
+import { usePromptHistory, type PromptInfo } from "./history"
+import { usePromptStash } from "./stash"
+import { usePromptStore } from "./use-prompt-store"
+import { usePromptMemos } from "./use-prompt-memos"
+import { usePromptSubmit } from "./use-prompt-submit"
+import { usePromptCommands } from "./use-prompt-commands"
+import { restoreExtmarksFromParts, syncExtmarksWithPromptParts, type ExtmarkSyncDeps } from "./use-extmark-sync"
+import { PromptMeta } from "./PromptMeta"
+import { PromptStatusBar } from "./PromptStatusBar"
+import { PromptTextarea } from "./prompt-textarea"
+import { useLocal } from "@tui/context/local"
+
+export type PromptProps = {
+  sessionID?: string
+  workspaceID?: string
+  visible?: boolean
+  disabled?: boolean
+  onSubmit?: () => void
+  ref?: (ref: PromptRef | undefined) => void
+  hint?: import("@opentui/solid").JSX.Element
+  right?: import("@opentui/solid").JSX.Element
+  showPlaceholder?: boolean
+  placeholders?: { normal?: string[]; shell?: string[] }
+}
+
+export type PromptRef = {
+  focused: boolean
+  current: PromptInfo
+  set(prompt: PromptInfo): void
+  reset(): void
+  blur(): void
+  focus(): void
+  submit(): void
+}
+
+function fadeColor(color: RGBA, alpha: number) {
+  return RGBA.fromValues(color.r, color.g, color.b, color.a * alpha)
+}
+
+export function Prompt(props: PromptProps) {
+  let input!: TextareaRenderable
+  let anchor!: BoxRenderable
+  let autocomplete!: AutocompleteRef
+  let promptPartTypeId = 0
+
+  const local = useLocal()
+  const { theme, syntax } = useTheme()
+  const command = useCommandDialog()
+  const history = usePromptHistory()
+  const stash = usePromptStash()
+  const [auto, setAuto] = createSignal<AutocompleteRef>()
+
+  const fileStyleId = syntax().getStyleId("extmark.file")!
+  const agentStyleId = syntax().getStyleId("extmark.agent")!
+  const pasteStyleId = syntax().getStyleId("extmark.paste")!
+
+  function getInput() { return input }
+
+  const extmarkSync: ExtmarkSyncDeps = {
+    getInput,
+    get setStore() { return _setStore },
+    fileStyleId,
+    agentStyleId,
+    pasteStyleId,
+    get promptPartTypeId() { return promptPartTypeId },
+  }
+
+  function restoreExtmarks(parts: PromptInfo["parts"]) {
+    restoreExtmarksFromParts(extmarkSync, parts)
+  }
+
+  function syncExtmarks() {
+    syncExtmarksWithPromptParts(extmarkSync)
+  }
+
+  const list = createMemo(() => props.placeholders?.normal ?? [])
+
+  const { store, setStore: _setStore, ref, setAuto: _setAuto } = usePromptStore({
+    props,
+    getInput,
+    extmarkSync,
+    restoreExtmarks,
+    list,
+  })
+
+  const memos = usePromptMemos({ props, store })
+
+  const lastSubmittedEditorSelectionKey = { value: undefined as string | undefined }
+
+  const { submit, pasteText, pasteAttachment } = usePromptSubmit({
+    props,
+    getInput,
+    store,
+    setStore: _setStore,
+    autocomplete: () => autocomplete,
+    extmarkSync,
+    syncExtmarks,
+    history,
+    lastSubmittedEditorSelectionKey,
+    editorContext: memos.editorContext,
+    exit: async () => { const { useExit } = await import("../../context/exit"); await useExit()() },
+  })
+
+  _setAuto((r: any) => { autocomplete = r; setAuto(() => r as any); return r })
+
+  const { dismissEditorContext } = usePromptCommands({
+    props,
+    getInput,
+    store,
+    setStore: _setStore,
+    autocomplete: () => autocomplete,
+    extmarkSync,
+    restoreExtmarks,
+    submit,
+    pasteAttachment,
+    status: memos.status,
+    editorContext: memos.editorContext,
+    stash,
+    command,
+    history,
+    lastSubmittedEditorSelectionKey,
+    setDismissedEditorSelectionKey: memos.setDismissedEditorSelectionKey,
+    promptPartTypeId: { get value() { return promptPartTypeId } },
+  })
+
+  createEffect(() => {
+    if (!input) return
+    if (props.disabled) input.cursorColor = theme.backgroundElement
+    if (!props.disabled) input.cursorColor = theme.text
+  })
+
+  const showVariant = createMemo(() => {
+    const variants = local.model.variant.list()
+    if (variants.length === 0) return false
+    return !!local.model.variant.current()
+  })
+
+  return (
+    <>
+      <Autocomplete
+        sessionID={props.sessionID}
+        ref={(r) => { autocomplete = r; setAuto(() => r) }}
+        anchor={() => anchor}
+        input={() => input}
+        setPrompt={(cb) => _setStore("prompt", cb as any)}
+        setExtmark={(partIndex, extmarkId) => {
+          _setStore("extmarkToPartIndex", (map: Map<number, number>) => {
+            const newMap = new Map(map); newMap.set(extmarkId, partIndex); return newMap
+          })
+        }}
+        value={store.prompt.input}
+        fileStyleId={fileStyleId}
+        agentStyleId={agentStyleId}
+        promptPartTypeId={() => promptPartTypeId}
+      />
+      <box ref={(r) => (anchor = r)} visible={props.visible !== false}>
+        <box border={["left"]} borderColor={memos.borderHighlight()} customBorderChars={{ ...SplitBorder.customBorderChars, bottomLeft: "╹" }}>
+          <box paddingLeft={2} paddingRight={2} paddingTop={1} flexShrink={0} backgroundColor={theme.backgroundElement} flexGrow={1}>
+            <PromptTextarea
+              props={props}
+              getStore={() => store}
+              setStore={(k: string, ...a: any[]) => (_setStore as any)(k, ...a)}
+              setStoreFull={(k: any, v: any) => (_setStore as any)(k, v)}
+              getInput={getInput}
+              autocomplete={autocomplete as any}
+              submit={submit}
+              pasteText={pasteText}
+              pasteAttachment={pasteAttachment}
+              restoreExtmarks={restoreExtmarks}
+              syncExtmarks={syncExtmarks}
+              history={history as any}
+              placeholderText={memos.placeholderText}
+              promptPartTypeId={promptPartTypeId}
+              ref={ref}
+            />
+            <PromptMeta
+              mode={store.mode}
+              agentName={local.agent.current()?.name}
+              agentDisplayName={local.agent.current()?.displayName}
+              highlight={memos.highlight()}
+              agentAlpha={memos.agentMetaAlpha()}
+              modelAlpha={memos.modelMetaAlpha()}
+              variantAlpha={memos.variantMetaAlpha()}
+              textMuted={theme.textMuted}
+              textColor={theme.text}
+              providerLabel={memos.currentProviderLabel()}
+              modelName={local.model.parsed().model}
+              showVariant={showVariant()}
+              variantName={local.model.variant.current()}
+              warningColor={theme.warning}
+              hasRightContent={!!props.right}
+              right={props.right}
+            />
+          </box>
+        </box>
+        <PromptStatusBar
+          sessionID={props.sessionID}
+          status={memos.status}
+          store={store}
+          hint={props.hint}
+          usage={memos.usage}
+          borderHighlight={memos.borderHighlight}
+          spinnerDef={memos.spinnerDef}
+          editorFileLabelDisplay={memos.editorFileLabelDisplay}
+          onDismissEditorContext={dismissEditorContext}
+        />
+      </box>
+    </>
+  )
+}

package/src/cli/cmd/tui/component/prompt/part.ts

@@ -0,0 +1,16 @@
+import { PartID } from "@/session/schema"
+import type { PromptInfo } from "./history"
+
+type Item = PromptInfo["parts"][number]
+
+export function strip(part: Item & { id: string; messageID: string; sessionID: string }): Item {
+  const { id: _id, messageID: _messageID, sessionID: _sessionID, ...rest } = part
+  return rest
+}
+
+export function assign(part: Item): Item & { id: PartID } {
+  return {
+    ...part,
+    id: PartID.ascending(),
+  }
+}

package/src/cli/cmd/tui/component/prompt/prompt-textarea.tsx

@@ -0,0 +1,180 @@
+/** Textarea JSX + 이벤트 핸들러 — index.tsx에서 분리 */
+
+import type { TextareaRenderable, PasteEvent, MouseEvent } from "@opentui/core"
+import { decodePasteBytes } from "@opentui/core"
+import { fileURLToPath } from "url"
+import path from "path"
+import { Filesystem } from "@/util/filesystem"
+import { iife } from "@/util/iife"
+import * as Clipboard from "../../util/clipboard"
+import { useKeybind } from "@tui/context/keybind"
+import { useTheme } from "@tui/context/theme"
+import { useExit } from "../../context/exit"
+import { useRenderer } from "@opentui/solid"
+import { useKV } from "../../context/kv"
+import { useSync } from "@tui/context/sync"
+import { useTextareaKeybindings } from "../textarea-keybindings"
+import type { PromptInfo } from "./history"
+import type { PromptRef } from "."
+import type { StoreShape } from "./use-prompt-store"
+
+export type TextareaDeps = {
+  props: {
+    visible?: boolean
+    disabled?: boolean
+    showPlaceholder?: boolean
+    placeholders?: { normal?: string[]; shell?: string[] }
+    ref?: (ref: PromptRef | undefined) => void
+  }
+  getStore: () => StoreShape
+  setStore: (key: string, ...args: any[]) => void
+  setStoreFull: (key: any, value: any) => void
+  getInput: () => TextareaRenderable
+  autocomplete: { onInput: (v: string) => void; onKeyDown: (e: any) => void; onCursorChange: () => void; visible: boolean }
+  submit: () => Promise<boolean>
+  pasteText: (text: string, virtualText: string) => void
+  pasteAttachment: (file: { filename?: string; filepath?: string; content: string; mime: string }) => Promise<void>
+  restoreExtmarks: (parts: PromptInfo["parts"]) => void
+  syncExtmarks: () => void
+  history: { move: (dir: number, text: string) => PromptInfo | undefined }
+  placeholderText: () => string | undefined
+  promptPartTypeId: number
+  ref: PromptRef
+}
+
+export function PromptTextarea(deps: TextareaDeps) {
+  const keybind = useKeybind()
+  const { theme, syntax } = useTheme()
+  const exit = useExit()
+  const renderer = useRenderer()
+  const kv = useKV()
+  const sync = useSync()
+  const textareaKeybindings = useTextareaKeybindings()
+
+  return (
+    <textarea
+      placeholder={deps.placeholderText()}
+      placeholderColor={theme.textMuted}
+      textColor={keybind.leader ? theme.textMuted : theme.text}
+      focusedTextColor={keybind.leader ? theme.textMuted : theme.text}
+      minHeight={1}
+      maxHeight={6}
+      onContentChange={() => {
+        const input = deps.getInput()
+        const value = input.plainText
+        deps.setStore("prompt", "input", value)
+        deps.autocomplete.onInput(value)
+        deps.syncExtmarks()
+      }}
+      onCursorChange={() => {
+        const store = deps.getStore()
+        if (store.mode === "normal") deps.autocomplete.onCursorChange()
+      }}
+      keyBindings={textareaKeybindings()}
+      onKeyDown={async (e) => {
+        const input = deps.getInput()
+        const store = deps.getStore()
+        if (deps.props.disabled) { e.preventDefault(); return }
+        if (keybind.match("input_paste", e)) {
+          const content = await Clipboard.read()
+          if (content?.mime.startsWith("image/")) {
+            e.preventDefault()
+            await deps.pasteAttachment({ filename: "clipboard", mime: content.mime, content: content.data })
+            return
+          }
+        }
+        if (keybind.match("input_clear", e) && store.prompt.input !== "") {
+          input.clear(); input.extmarks.clear()
+          deps.setStoreFull("prompt", { input: "", parts: [] })
+          deps.setStoreFull("extmarkToPartIndex", new Map())
+          return
+        }
+        if (keybind.match("app_exit", e)) {
+          if (store.prompt.input === "") {
+            if (e.ctrl && e.name === "c") {
+              deps.setStore("exitPress", store.exitPress + 1)
+              setTimeout(() => deps.setStore("exitPress", 0), 1000)
+              if (store.exitPress >= 2) { await exit(); e.preventDefault(); return }
+              e.preventDefault(); return
+            }
+            await exit(); e.preventDefault(); return
+          }
+        }
+        if (e.name === "!" && input.visualCursor.offset === 0) {
+          deps.setStoreFull("placeholder", Math.floor(Math.random() * ((deps.props.placeholders?.shell?.length ?? 0) || 1)))
+          deps.setStore("mode", "shell"); e.preventDefault(); return
+        }
+        if (store.mode === "shell") {
+          if ((e.name === "backspace" && input.visualCursor.offset === 0) || e.name === "escape") {
+            deps.setStore("mode", "normal"); e.preventDefault(); return
+          }
+        }
+        if (store.mode === "normal") deps.autocomplete.onKeyDown(e)
+        if (!deps.autocomplete.visible) {
+          if ((keybind.match("history_previous", e) && input.cursorOffset === 0) || (keybind.match("history_next", e) && input.cursorOffset === input.plainText.length)) {
+            const direction = keybind.match("history_previous", e) ? -1 : 1
+            const item = deps.history.move(direction, input.plainText)
+            if (item) {
+              input.setText(item.input)
+              deps.setStoreFull("prompt", item)
+              deps.setStoreFull("mode", item.mode ?? "normal")
+              deps.restoreExtmarks(item.parts)
+              e.preventDefault()
+              if (direction === -1) input.cursorOffset = 0
+              if (direction === 1) input.cursorOffset = input.plainText.length
+            }
+            return
+          }
+          if (keybind.match("history_previous", e) && input.visualCursor.visualRow === 0) input.cursorOffset = 0
+          if (keybind.match("history_next", e) && input.visualCursor.visualRow === input.height - 1) input.cursorOffset = input.plainText.length
+        }
+      }}
+      onSubmit={() => setTimeout(() => setTimeout(() => deps.submit(), 0), 0)}
+      onPaste={async (event: PasteEvent) => {
+        const input = deps.getInput()
+        if (deps.props.disabled) { event.preventDefault(); return }
+        const normalizedText = decodePasteBytes(event.bytes).replace(/\r\n/g, "\n").replace(/\r/g, "\n")
+        const pastedContent = normalizedText.trim()
+        if (!pastedContent) return
+        event.preventDefault()
+        const filepath = iife(() => {
+          const raw = pastedContent.replace(/^['"]+|['"]+$/g, "")
+          if (raw.startsWith("file://")) { try { return fileURLToPath(raw) } catch {} }
+          if (process.platform === "win32") return raw
+          return raw.replace(/\\(.)/g, "$1")
+        })
+        const isUrl = /^(https?):\/\//.test(filepath)
+        if (!isUrl) {
+          try {
+            const mime = await Filesystem.mimeType(filepath)
+            const filename = path.basename(filepath)
+            if (mime === "image/svg+xml") {
+              const content = await Filesystem.readText(filepath).catch(() => {})
+              if (content) { deps.pasteText(content, `[SVG: ${filename ?? "image"}]`); return }
+            }
+            if (mime.startsWith("image/") || mime === "application/pdf") {
+              const content = await Filesystem.readArrayBuffer(filepath).then((b) => Buffer.from(b).toString("base64")).catch(() => {})
+              if (content) { await deps.pasteAttachment({ filename, filepath, mime, content }); return }
+            }
+          } catch {}
+        }
+        const lineCount = (pastedContent.match(/\n/g)?.length ?? 0) + 1
+        if ((lineCount >= 5 || pastedContent.length > 800) && kv.get("paste_summary_enabled", !sync.data.config.experimental?.disable_paste_summary)) {
+          deps.pasteText(pastedContent, `[Pasted ~${lineCount} lines]`); return
+        }
+        input.insertText(normalizedText)
+        setTimeout(() => { if (!input || input.isDestroyed) return; input.getLayoutNode().markDirty(); renderer.requestRender() }, 0)
+      }}
+      ref={(r: TextareaRenderable) => {
+        const ppti = deps.promptPartTypeId
+        if (ppti === 0) (deps as any).promptPartTypeId = r.extmarks.registerType("prompt-part")
+        deps.props.ref?.(deps.ref)
+        setTimeout(() => { if (!r || r.isDestroyed) return; r.cursorColor = theme.text }, 0)
+      }}
+      onMouseDown={(r: MouseEvent) => r.target?.focus()}
+      focusedBackgroundColor={theme.backgroundElement}
+      cursorColor={theme.text}
+      syntaxStyle={syntax()}
+    />
+  )
+}