saeeol 1.4.1 → 1.4.3

package/src/cli/cmd/tui/util/editor.ts

@@ -1,37 +0,0 @@
-import { defer } from "@/util/defer"
-import { rm } from "node:fs/promises"
-import { tmpdir } from "node:os"
-import { join } from "node:path"
-import { CliRenderer } from "@opentui/core"
-import { Filesystem } from "@/util/filesystem"
-import { Process } from "@/util/process"
-
-export async function open(opts: { value: string; renderer: CliRenderer }): Promise<string | undefined> {
-  const editor = process.env["VISUAL"] || process.env["EDITOR"]
-  if (!editor) return
-
-  const filepath = join(tmpdir(), `${Date.now()}.md`)
-  await using _ = defer(async () => rm(filepath, { force: true }))
-
-  await Filesystem.write(filepath, opts.value)
-  opts.renderer.suspend()
-  opts.renderer.currentRenderBuffer.clear()
-  try {
-    const parts = editor.split(" ")
-    const proc = Process.spawn([...parts, filepath], {
-      stdin: "inherit",
-      stdout: "inherit",
-      stderr: "inherit",
-      shell: process.platform === "win32",
-    })
-    await proc.exited
-    const content = await Filesystem.readText(filepath)
-    return content || undefined
-  } finally {
-    opts.renderer.currentRenderBuffer.clear()
-    opts.renderer.resume()
-    opts.renderer.requestRender()
-  }
-}
-
-export * as Editor from "./editor"

package/src/cli/cmd/tui/util/markdown.ts

@@ -1,211 +0,0 @@
-
-/**
- * Formats markdown tables with fixed-width columns, similar to VS Code's behavior.
- * This normalizes column widths so tables render with aligned columns.
- */
-
-type TableRow = string[]
-
-interface Table {
-  startIndex: number
-  endIndex: number
-  rows: TableRow[]
-  alignments: ("left" | "center" | "right" | "none")[]
-}
-
-/**
- * Parses a single table row, splitting by | and trimming cells
- */
-function parseRow(line: string): TableRow | null {
-  // Must start and end with | (after trimming)
-  const trimmed = line.trim()
-  if (!trimmed.startsWith("|") || !trimmed.endsWith("|")) return null
-
-  // Split by | and remove first/last empty elements
-  const cells = trimmed.split("|").slice(1, -1)
-  return cells.map((cell) => cell.trim())
-}
-
-/**
- * Checks if a row is a separator row (contains only dashes, colons, and spaces)
- */
-function isSeparatorRow(cells: TableRow): boolean {
-  return cells.every((cell) => /^:?-+:?$/.test(cell))
-}
-
-/**
- * Extracts alignment from separator row cells
- */
-function getAlignment(cell: string): "left" | "center" | "right" | "none" {
-  const left = cell.startsWith(":")
-  const right = cell.endsWith(":")
-  if (left && right) return "center"
-  if (right) return "right"
-  if (left) return "left"
-  return "none"
-}
-
-/**
- * Gets the display width of a string, accounting for wide characters
- */
-function getDisplayWidth(str: string): number {
-  let width = 0
-  for (const char of str) {
-    const code = char.codePointAt(0)!
-    // Check for wide characters (CJK, etc.)
-    if (
-      (code >= 0x1100 && code <= 0x115f) || // Hangul Jamo
-      (code >= 0x2e80 && code <= 0x9fff) || // CJK
-      (code >= 0xac00 && code <= 0xd7a3) || // Hangul Syllables
-      (code >= 0xf900 && code <= 0xfaff) || // CJK Compatibility Ideographs
-      (code >= 0xfe10 && code <= 0xfe1f) || // Vertical forms
-      (code >= 0xfe30 && code <= 0xfe6f) || // CJK Compatibility Forms
-      (code >= 0xff00 && code <= 0xff60) || // Fullwidth Forms
-      (code >= 0xffe0 && code <= 0xffe6) || // Fullwidth symbols
-      (code >= 0x20000 && code <= 0x2fffd) || // CJK Extension B-F
-      (code >= 0x30000 && code <= 0x3fffd) // CJK Extension G
-    ) {
-      width += 2
-    } else {
-      width += 1
-    }
-  }
-  return width
-}
-
-/**
- * Pads a string to a target display width
- */
-function padToWidth(str: string, width: number, align: "left" | "center" | "right" | "none"): string {
-  const currentWidth = getDisplayWidth(str)
-  const padding = width - currentWidth
-  if (padding <= 0) return str
-
-  switch (align) {
-    case "center": {
-      const left = Math.floor(padding / 2)
-      const right = padding - left
-      return " ".repeat(left) + str + " ".repeat(right)
-    }
-    case "right":
-      return " ".repeat(padding) + str
-    default:
-      return str + " ".repeat(padding)
-  }
-}
-
-/**
- * Finds all markdown tables in the content
- */
-function findTables(lines: string[]): Table[] {
-  const tables: Table[] = []
-  let i = 0
-
-  while (i < lines.length) {
-    // Try to parse as table row
-    const headerCells = parseRow(lines[i])
-    if (!headerCells || headerCells.length === 0) {
-      i++
-      continue
-    }
-
-    // Check if next line is separator
-    if (i + 1 >= lines.length) {
-      i++
-      continue
-    }
-
-    const separatorCells = parseRow(lines[i + 1])
-    if (!separatorCells || !isSeparatorRow(separatorCells)) {
-      i++
-      continue
-    }
-
-    // Found a table! Parse all rows
-    const table: Table = {
-      startIndex: i,
-      endIndex: i + 1,
-      rows: [headerCells, separatorCells],
-      alignments: separatorCells.map(getAlignment),
-    }
-
-    // Continue parsing data rows
-    let j = i + 2
-    while (j < lines.length) {
-      const rowCells = parseRow(lines[j])
-      if (!rowCells) break
-      table.rows.push(rowCells)
-      table.endIndex = j
-      j++
-    }
-
-    tables.push(table)
-    i = j
-  }
-
-  return tables
-}
-
-/**
- * Formats a table with fixed-width columns
- */
-function formatTable(table: Table): string[] {
-  const columnCount = Math.max(...table.rows.map((row) => row.length))
-
-  // Calculate max width for each column
-  const columnWidths: number[] = Array(columnCount).fill(0)
-
-  for (const row of table.rows) {
-    for (let col = 0; col < columnCount; col++) {
-      const cell = row[col] ?? ""
-      // For separator rows, we use a minimum width of 3 (---)
-      if (isSeparatorRow(row)) {
-        columnWidths[col] = Math.max(columnWidths[col], 3)
-      } else {
-        columnWidths[col] = Math.max(columnWidths[col], getDisplayWidth(cell))
-      }
-    }
-  }
-
-  // Format each row
-  return table.rows.map((row, rowIndex) => {
-    const cells: string[] = []
-    for (let col = 0; col < columnCount; col++) {
-      const cell = row[col] ?? ""
-      const width = columnWidths[col]
-      const align = table.alignments[col] ?? "none"
-
-      if (rowIndex === 1) {
-        // Separator row - create dashes to match column width
-        const hasLeft = align === "left" || align === "center"
-        const hasRight = align === "right" || align === "center"
-        const dashCount = width - (hasLeft ? 1 : 0) - (hasRight ? 1 : 0)
-        const dashes = "-".repeat(Math.max(dashCount, 1))
-        cells.push((hasLeft ? ":" : "") + dashes + (hasRight ? ":" : ""))
-      } else {
-        cells.push(padToWidth(cell, width, align))
-      }
-    }
-    return "| " + cells.join(" | ") + " |"
-  })
-}
-
-/**
- * Formats all markdown tables in the content with fixed-width columns.
- * Tables that don't follow standard markdown table syntax are left unchanged.
- */
-export function formatMarkdownTables(content: string): string {
-  const lines = content.split("\n")
-  const tables = findTables(lines)
-
-  if (tables.length === 0) return content
-
-  // Process tables in reverse order to maintain correct indices
-  for (let i = tables.length - 1; i >= 0; i--) {
-    const table = tables[i]
-    const formatted = formatTable(table)
-    lines.splice(table.startIndex, table.endIndex - table.startIndex + 1, ...formatted)
-  }
-
-  return lines.join("\n")
-}

package/src/cli/cmd/tui/util/model.ts

@@ -1,23 +0,0 @@
-import type { Provider } from "@saeeol/sdk/v2"
-
-export function index(list: Provider[] | undefined) {
-  return new Map((list ?? []).map((item) => [item.id, item] as const))
-}
-
-export function get(list: Provider[] | ReadonlyMap<string, Provider> | undefined, providerID: string, modelID: string) {
-  const provider =
-    list instanceof Map
-      ? list.get(providerID)
-      : Array.isArray(list)
-        ? list.find((item) => item.id === providerID)
-        : undefined
-  return provider?.models?.[modelID]
-}
-
-export function name(
-  list: Provider[] | ReadonlyMap<string, Provider> | undefined,
-  providerID: string,
-  modelID: string,
-) {
-  return get(list, providerID, modelID)?.name ?? modelID
-}

package/src/cli/cmd/tui/util/provider-origin.ts

@@ -1,7 +0,0 @@
-const contains = (consoleManagedProviders: string[] | ReadonlySet<string>, providerID: string) =>
-  Array.isArray(consoleManagedProviders)
-    ? consoleManagedProviders.includes(providerID)
-    : consoleManagedProviders.has(providerID)
-
-export const isConsoleManagedProvider = (consoleManagedProviders: string[] | ReadonlySet<string>, providerID: string) =>
-  contains(consoleManagedProviders, providerID)

package/src/cli/cmd/tui/util/revert-diff.ts

@@ -1,41 +0,0 @@
-import { parseUnifiedDiff, type DiffHunk } from "@/boxes/diff-apply"
-
-interface ParsedFile {
-  filename: string
-  additions: number
-  deletions: number
-}
-
-export function getRevertDiffFiles(diffText: string): ParsedFile[] {
-  if (!diffText) return []
-
-  try {
-    // Parse file headers from the diff text to extract filenames
-    const files: ParsedFile[] = []
-    const fileBlocks = diffText.split(/(?=diff --git )/)
-
-    for (const block of fileBlocks) {
-      if (!block.startsWith("diff --git")) continue
-
-      const headerMatch = block.match(/^diff --git (?:a\/(.+?) b\/(.+?)|(.+?) (.+?))\n/)
-      if (!headerMatch) continue
-
-      const candidates = [headerMatch[1], headerMatch[2], headerMatch[3], headerMatch[4]]
-      const filename = candidates.find((c) => c && c !== "/dev/null") ?? "unknown"
-      const hunks = parseUnifiedDiff(block)
-
-      const additions = hunks.reduce(
-        (sum, h) => sum + h.lines.filter((l) => l.startsWith("+")).length, 0,
-      )
-      const deletions = hunks.reduce(
-        (sum, h) => sum + h.lines.filter((l) => l.startsWith("-")).length, 0,
-      )
-
-      files.push({ filename: filename.replace(/^[ab]\//, ""), additions, deletions })
-    }
-
-    return files
-  } catch {
-    return []
-  }
-}

package/src/cli/cmd/tui/util/scroll.ts

@@ -1,23 +0,0 @@
-import { MacOSScrollAccel, type ScrollAcceleration } from "@opentui/core"
-import type { TuiConfig } from "@/cli/cmd/tui/config/tui"
-
-export class CustomSpeedScroll implements ScrollAcceleration {
-  constructor(private speed: number) {}
-
-  tick(_now?: number): number {
-    return this.speed
-  }
-
-  reset(): void {}
-}
-
-export function getScrollAcceleration(tuiConfig?: TuiConfig.Info): ScrollAcceleration {
-  if (tuiConfig?.scroll_acceleration?.enabled) {
-    return new MacOSScrollAccel()
-  }
-  if (tuiConfig?.scroll_speed !== undefined) {
-    return new CustomSpeedScroll(tuiConfig.scroll_speed)
-  }
-
-  return new CustomSpeedScroll(3)
-}

package/src/cli/cmd/tui/util/selection.ts

@@ -1,25 +0,0 @@
-import * as Clipboard from "./clipboard"
-
-type Toast = {
-  show: (input: { message: string; variant: "info" | "success" | "warning" | "error" }) => void
-  error: (err: unknown) => void
-}
-
-type Renderer = {
-  getSelection: () => { getSelectedText: () => string } | null
-  clearSelection: () => void
-}
-
-export function copy(renderer: Renderer, toast: Toast): boolean {
-  const text = renderer.getSelection()?.getSelectedText()
-  if (!text) return false
-
-  Clipboard.copy(text)
-    .then(() => toast.show({ message: "Copied to clipboard", variant: "info" }))
-    .catch(toast.error)
-
-  renderer.clearSelection()
-  return true
-}
-
-export * as Selection from "./selection"

package/src/cli/cmd/tui/util/signal.ts

@@ -1,41 +0,0 @@
-import { createEffect, createSignal, on, onCleanup, type Accessor } from "solid-js"
-import { debounce, type Scheduled } from "@solid-primitives/scheduled"
-
-export function createDebouncedSignal<T>(value: T, ms: number): [Accessor<T>, Scheduled<[value: T]>] {
-  const [get, set] = createSignal(value)
-  return [get, debounce((v: T) => set(() => v), ms)]
-}
-
-export function createFadeIn(show: Accessor<boolean>, enabled: Accessor<boolean>) {
-  const [alpha, setAlpha] = createSignal(show() ? 1 : 0)
-  let revealed = show()
-
-  createEffect(
-    on([show, enabled], ([visible, animate]) => {
-      if (!visible) {
-        setAlpha(0)
-        return
-      }
-
-      if (!animate || revealed) {
-        revealed = true
-        setAlpha(1)
-        return
-      }
-
-      const start = performance.now()
-      revealed = true
-      setAlpha(0)
-
-      const timer = setInterval(() => {
-        const progress = Math.min((performance.now() - start) / 160, 1)
-        setAlpha(progress * progress * (3 - 2 * progress))
-        if (progress >= 1) clearInterval(timer)
-      }, 16)
-
-      onCleanup(() => clearInterval(timer))
-    }),
-  )
-
-  return alpha
-}

package/src/cli/cmd/tui/util/sound.ts

@@ -1,156 +0,0 @@
-import { Player } from "cli-sound"
-import { mkdirSync } from "node:fs"
-import { tmpdir } from "node:os"
-import { basename, join } from "node:path"
-import { Process } from "@/util/process"
-import { which } from "@/util/which"
-import pulseA from "../asset/pulse-a.wav" with { type: "file" }
-import pulseB from "../asset/pulse-b.wav" with { type: "file" }
-import pulseC from "../asset/pulse-c.wav" with { type: "file" }
-import charge from "../asset/charge.wav" with { type: "file" }
-
-const FILE = [pulseA, pulseB, pulseC]
-
-const HUM = charge
-const DIR = join(tmpdir(), "saeeol-sfx")
-
-const LIST = [
-  "ffplay",
-  "mpv",
-  "mpg123",
-  "mpg321",
-  "mplayer",
-  "afplay",
-  "play",
-  "omxplayer",
-  "aplay",
-  "cmdmp3",
-  "cvlc",
-  "powershell.exe",
-] as const
-
-type Kind = (typeof LIST)[number]
-
-function args(kind: Kind, file: string, volume: number) {
-  if (kind === "ffplay") return [kind, "-autoexit", "-nodisp", "-af", `volume=${volume}`, file]
-  if (kind === "mpv")
-    return [kind, "--no-video", "--audio-display=no", "--volume", String(Math.round(volume * 100)), file]
-  if (kind === "mpg123" || kind === "mpg321") return [kind, "-g", String(Math.round(volume * 100)), file]
-  if (kind === "mplayer") return [kind, "-vo", "null", "-volume", String(Math.round(volume * 100)), file]
-  if (kind === "afplay" || kind === "omxplayer" || kind === "aplay" || kind === "cmdmp3") return [kind, file]
-  if (kind === "play") return [kind, "-v", String(volume), file]
-  if (kind === "cvlc") return [kind, `--gain=${volume}`, "--play-and-exit", file]
-  return [kind, "-c", `(New-Object Media.SoundPlayer '${file.replace(/'/g, "''")}').PlaySync()`]
-}
-
-let item: Player | null | undefined
-let kind: Kind | null | undefined
-let proc: Process.Child | undefined
-let tail: ReturnType<typeof setTimeout> | undefined
-let cache: Promise<{ hum: string; pulse: string[] }> | undefined
-let seq = 0
-let shot = 0
-
-function load() {
-  if (item !== undefined) return item
-  try {
-    item = new Player({ volume: 0.35 })
-  } catch {
-    item = null
-  }
-  return item
-}
-
-async function file(path: string) {
-  mkdirSync(DIR, { recursive: true })
-  const next = join(DIR, basename(path))
-  const out = Bun.file(next)
-  if (await out.exists()) return next
-  await Bun.write(out, Bun.file(path))
-  return next
-}
-
-function asset() {
-  cache ??= Promise.all([file(HUM), Promise.all(FILE.map(file))]).then(([hum, pulse]) => ({ hum, pulse }))
-  return cache
-}
-
-function pick() {
-  if (kind !== undefined) return kind
-  kind = LIST.find((item) => which(item)) ?? null
-  return kind
-}
-
-function run(file: string, volume: number) {
-  const kind = pick()
-  if (!kind) return
-  return Process.spawn(args(kind, file, volume), {
-    stdin: "ignore",
-    stdout: "ignore",
-    stderr: "ignore",
-  })
-}
-
-function clear() {
-  if (!tail) return
-  clearTimeout(tail)
-  tail = undefined
-}
-
-function play(file: string, volume: number) {
-  const item = load()
-  if (!item) return run(file, volume)?.exited
-  return item.play(file, { volume }).catch(() => run(file, volume)?.exited)
-}
-
-export function start() {
-  stop()
-  const id = ++seq
-  void asset().then(({ hum }) => {
-    if (id !== seq) return
-    const next = run(hum, 0.24)
-    if (!next) return
-    proc = next
-    void next.exited.then(
-      () => {
-        if (id !== seq) return
-        if (proc === next) proc = undefined
-      },
-      () => {
-        if (id !== seq) return
-        if (proc === next) proc = undefined
-      },
-    )
-  })
-}
-
-export function stop(delay = 0) {
-  seq++
-  clear()
-  if (!proc) return
-  const next = proc
-  if (delay <= 0) {
-    proc = undefined
-    void Process.stop(next).catch(() => undefined)
-    return
-  }
-  tail = setTimeout(() => {
-    tail = undefined
-    if (proc === next) proc = undefined
-    void Process.stop(next).catch(() => undefined)
-  }, delay)
-}
-
-export function pulse(scale = 1) {
-  stop(140)
-  const index = shot++ % FILE.length
-  void asset()
-    .then(({ pulse }) => play(pulse[index], 0.26 + 0.14 * scale))
-    .catch(() => undefined)
-}
-
-export function dispose() {
-  stop()
-}
-
-export * as Sound from "./sound"

package/src/cli/cmd/tui/util/transcript.ts

@@ -1,112 +0,0 @@
-import type { AssistantMessage, Part, Provider, UserMessage } from "@saeeol/sdk/v2"
-import { Locale } from "@/util/locale"
-import * as Model from "./model"
-
-export type TranscriptOptions = {
-  thinking: boolean
-  toolDetails: boolean
-  assistantMetadata: boolean
-  providers?: Provider[]
-}
-
-export type SessionInfo = {
-  id: string
-  title: string
-  time: {
-    created: number
-    updated: number
-  }
-}
-
-export type MessageWithParts = {
-  info: UserMessage | AssistantMessage
-  parts: Part[]
-}
-
-export function formatTranscript(
-  session: SessionInfo,
-  messages: MessageWithParts[],
-  options: TranscriptOptions,
-): string {
-  const providers = Model.index(options.providers)
-  let transcript = `# ${session.title}\n\n`
-  transcript += `**Session ID:** ${session.id}\n`
-  transcript += `**Created:** ${new Date(session.time.created).toLocaleString()}\n`
-  transcript += `**Updated:** ${new Date(session.time.updated).toLocaleString()}\n\n`
-  transcript += `---\n\n`
-
-  for (const msg of messages) {
-    transcript += formatMessage(msg.info, msg.parts, options, providers)
-    transcript += `---\n\n`
-  }
-
-  return transcript
-}
-
-export function formatMessage(
-  msg: UserMessage | AssistantMessage,
-  parts: Part[],
-  options: TranscriptOptions,
-  providers?: Provider[] | ReadonlyMap<string, Provider>,
-): string {
-  let result = ""
-
-  if (msg.role === "user") {
-    result += `## User\n\n`
-  } else {
-    result += formatAssistantHeader(msg, options.assistantMetadata, providers ?? options.providers)
-  }
-
-  for (const part of parts) {
-    result += formatPart(part, options)
-  }
-
-  return result
-}
-
-export function formatAssistantHeader(
-  msg: AssistantMessage,
-  includeMetadata: boolean,
-  providers?: Provider[] | ReadonlyMap<string, Provider>,
-): string {
-  if (!includeMetadata) {
-    return `## Assistant\n\n`
-  }
-
-  const duration =
-    msg.time.completed && msg.time.created ? ((msg.time.completed - msg.time.created) / 1000).toFixed(1) + "s" : ""
-
-  const modelName = Model.name(providers, msg.providerID, msg.modelID)
-
-  return `## Assistant (${Locale.titlecase(msg.agent)} · ${modelName}${duration ? ` · ${duration}` : ""})\n\n`
-}
-
-export function formatPart(part: Part, options: TranscriptOptions): string {
-  if (part.type === "text" && !part.synthetic) {
-    return `${part.text}\n\n`
-  }
-
-  if (part.type === "reasoning") {
-    if (options.thinking) {
-      return `_Thinking:_\n\n${part.text}\n\n`
-    }
-    return ""
-  }
-
-  if (part.type === "tool") {
-    let result = `**Tool: ${part.tool}**\n`
-    if (options.toolDetails && part.state.input) {
-      result += `\n**Input:**\n\`\`\`json\n${JSON.stringify(part.state.input, null, 2)}\n\`\`\`\n`
-    }
-    if (options.toolDetails && part.state.status === "completed" && part.state.output) {
-      result += `\n**Output:**\n\`\`\`\n${part.state.output}\n\`\`\`\n`
-    }
-    if (options.toolDetails && part.state.status === "error" && part.state.error) {
-      result += `\n**Error:**\n\`\`\`\n${part.state.error}\n\`\`\`\n`
-    }
-    result += `\n`
-    return result
-  }
-
-  return ""
-}