@sleepy-ai/cli 0.1.6 → 0.1.8

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

@@ -1,110 +0,0 @@
-import { RGBA } from "@opentui/core"
-
-export type Colors = Awaited<ReturnType<typeof colors>>
-
-export function isMacNativeTerminal(input?: { platform?: NodeJS.Platform; termProgram?: string }) {
-  return (
-    (input?.platform ?? process.platform) === "darwin" &&
-    (input?.termProgram ?? process.env.TERM_PROGRAM) === "Apple_Terminal"
-  )
-}
-
-export function isPlainTerminal(input?: { platform?: NodeJS.Platform; termProgram?: string; plain?: string }) {
-  const plain = input?.plain ?? process.env.SLEEPYCODE_TUI_PLAIN
-  if (plain === "false" || plain === "0") return false
-  if (plain === "true" || plain === "1") return true
-  return isMacNativeTerminal(input)
-}
-
-function parse(color: string): RGBA | null {
-  if (color.startsWith("rgb:")) {
-    const parts = color.substring(4).split("/")
-    return RGBA.fromInts(parseInt(parts[0], 16) >> 8, parseInt(parts[1], 16) >> 8, parseInt(parts[2], 16) >> 8, 255)
-  }
-  if (color.startsWith("#")) {
-    return RGBA.fromHex(color)
-  }
-  if (color.startsWith("rgb(")) {
-    const parts = color.substring(4, color.length - 1).split(",")
-    return RGBA.fromInts(parseInt(parts[0]), parseInt(parts[1]), parseInt(parts[2]), 255)
-  }
-  return null
-}
-
-/**
- * Query terminal colors including background, foreground, and palette (0-15).
- * Uses OSC escape sequences to retrieve actual terminal color values.
- *
- * Note: OSC 4 (palette) queries may not work through tmux as responses are filtered.
- * OSC 10/11 (foreground/background) typically work in most environments.
- *
- * Returns an object with background, foreground, and colors array.
- * Any query that fails will be null/empty.
- */
-export async function colors(): Promise<{
-  background: RGBA | null
-  foreground: RGBA | null
-  colors: RGBA[]
-}> {
-  if (!process.stdin.isTTY) return { background: null, foreground: null, colors: [] }
-
-  return new Promise((resolve) => {
-    let background: RGBA | null = null
-    let foreground: RGBA | null = null
-    const paletteColors: RGBA[] = []
-    let timeout: NodeJS.Timeout
-
-    const cleanup = () => {
-      process.stdin.setRawMode(false)
-      process.stdin.removeListener("data", handler)
-      clearTimeout(timeout)
-    }
-
-    const handler = (data: Buffer) => {
-      const str = data.toString()
-
-      // Match OSC 11 (background color)
-      const bgMatch = str.match(/\x1b]11;([^\x07\x1b]+)/)
-      if (bgMatch) {
-        background = parse(bgMatch[1])
-      }
-
-      // Match OSC 10 (foreground color)
-      const fgMatch = str.match(/\x1b]10;([^\x07\x1b]+)/)
-      if (fgMatch) {
-        foreground = parse(fgMatch[1])
-      }
-
-      // Match OSC 4 (palette colors)
-      const paletteMatches = str.matchAll(/\x1b]4;(\d+);([^\x07\x1b]+)/g)
-      for (const match of paletteMatches) {
-        const index = parseInt(match[1])
-        const color = parse(match[2])
-        if (color) paletteColors[index] = color
-      }
-
-      // Return immediately if we have all 16 palette colors
-      if (paletteColors.filter((c) => c !== undefined).length === 16) {
-        cleanup()
-        resolve({ background, foreground, colors: paletteColors })
-      }
-    }
-
-    process.stdin.setRawMode(true)
-    process.stdin.on("data", handler)
-
-    // Query background (OSC 11)
-    process.stdout.write("\x1b]11;?\x07")
-    // Query foreground (OSC 10)
-    process.stdout.write("\x1b]10;?\x07")
-    // Query palette colors 0-15 (OSC 4)
-    for (let i = 0; i < 16; i++) {
-      process.stdout.write(`\x1b]4;${i};?\x07`)
-    }
-
-    timeout = setTimeout(() => {
-      cleanup()
-      resolve({ background, foreground, colors: paletteColors })
-    }, 1000)
-  })
-}

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

@@ -1,112 +0,0 @@
-import type { AssistantMessage, Part, Provider, UserMessage } from "@sleepy-ai/sdk/v2"
-import { Locale } from "@/util"
-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 ""
-}

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

@@ -1,229 +0,0 @@
-import wasmPath from "../asset/ten_vad.wasm" with { type: "file" }
-import createVADModule from "../asset/ten_vad_loader.js"
-
-const HOP_SIZE = 256
-const VAD_SAMPLE_RATE = 16000
-
-interface WasmModule {
-  _ten_vad_create(handlePtr: number, hopSize: number, threshold: number): number
-  _ten_vad_process(handle: number, audioDataPtr: number, audioDataLength: number, outProbabilityPtr: number, outFlagPtr: number): number
-  _ten_vad_destroy(handlePtr: number): number
-  _malloc(size: number): number
-  _free(ptr: number): void
-  HEAP16: Int16Array
-  HEAPF32: Float32Array
-  HEAP32: Int32Array
-  HEAPU8: Uint8Array
-}
-
-let modulePromise: Promise<WasmModule> | undefined
-
-async function loadModule(): Promise<WasmModule> {
-  const wasmBinary = await Bun.file(wasmPath).arrayBuffer()
-  const mod = await createVADModule({
-    wasmBinary: new Uint8Array(wasmBinary),
-    locateFile: () => wasmPath,
-    noInitialRun: false,
-    noExitRuntime: true,
-  })
-
-  if (!mod.getValue) {
-    mod.getValue = (ptr: number, type: string) => {
-      if (type === "i32") return mod.HEAP32[ptr >> 2]
-      if (type === "float") return mod.HEAPF32[ptr >> 2]
-      return 0
-    }
-  }
-
-  return mod as WasmModule
-}
-
-function getModule(): Promise<WasmModule> {
-  modulePromise ??= loadModule()
-  return modulePromise
-}
-
-export interface VADSegment {
-  audio: Int16Array
-  startS: number
-  endS: number
-}
-
-export class RealtimeVAD {
-  private mod: WasmModule | null = null
-  private handle = 0
-  private handlePtr = 0
-  private audioPtr = 0
-  private probPtr = 0
-  private flagPtr = 0
-
-  private buffer: Int16Array = new Int16Array(0)
-  private bufferOffset = 0
-
-  private srcBuffer: Int16Array = new Int16Array(0)
-  private srcBufferOffset = 0
-
-  private active = false
-  private activeStartS = 0
-  private sumPositiveS = 0
-  private silenceStartS: number | null = null
-
-  private startThreshold: number
-  private endThreshold: number
-  private padStartS: number
-  private minSilenceS: number
-  private maxSegmentS: number
-
-  private onSegment: (segment: VADSegment) => void
-  private onActiveChange?: (active: boolean) => void
-
-  constructor(opts: {
-    onSegment: (segment: VADSegment) => void
-    onActiveChange?: (active: boolean) => void
-    startThreshold?: number
-    endThreshold?: number
-    padStartS?: number
-    minSilenceS?: number
-    maxSegmentS?: number
-  }) {
-    this.onSegment = opts.onSegment
-    this.onActiveChange = opts.onActiveChange
-    this.startThreshold = opts.startThreshold ?? 0.8
-    this.endThreshold = opts.endThreshold ?? 0.7
-    this.padStartS = opts.padStartS ?? 0.6
-    this.minSilenceS = opts.minSilenceS ?? 0.8
-    this.maxSegmentS = opts.maxSegmentS ?? 60
-  }
-
-  async init() {
-    this.mod = await getModule()
-    this.handlePtr = this.mod._malloc(4)
-    const result = this.mod._ten_vad_create(this.handlePtr, HOP_SIZE, this.startThreshold)
-    if (result !== 0) throw new Error("Failed to create VAD instance")
-    this.handle = this.mod.HEAP32[this.handlePtr >> 2]
-    this.audioPtr = this.mod._malloc(HOP_SIZE * 2)
-    this.probPtr = this.mod._malloc(4)
-    this.flagPtr = this.mod._malloc(4)
-
-    const silence = new Int16Array(HOP_SIZE)
-    for (let i = 0; i < 25; i++) this.processFrame(silence)
-  }
-
-  push(audio: Int16Array) {
-    const newSrc = new Int16Array(this.srcBuffer.length + audio.length)
-    newSrc.set(this.srcBuffer)
-    newSrc.set(audio, this.srcBuffer.length)
-    this.srcBuffer = newSrc
-
-    const newBuf = new Int16Array(this.buffer.length + audio.length)
-    newBuf.set(this.buffer)
-    newBuf.set(audio, this.buffer.length)
-    this.buffer = newBuf
-
-    let processed = 0
-    for (let pos = 0; pos <= this.buffer.length - HOP_SIZE; pos += HOP_SIZE) {
-      processed = pos + HOP_SIZE
-      const frame = this.buffer.slice(pos, pos + HOP_SIZE)
-      const chunkOffsetS = (this.bufferOffset + pos) / VAD_SAMPLE_RATE
-      this.processChunk(chunkOffsetS, frame)
-    }
-
-    if (processed > 0) {
-      this.buffer = this.buffer.slice(processed)
-      this.bufferOffset += processed
-    }
-  }
-
-  flush() {
-    if (!this.active) return
-    const audio = this.srcBuffer.slice(0, this.srcBuffer.length)
-    if (audio.length > VAD_SAMPLE_RATE * 0.2) {
-      const startS = this.srcBufferOffset / VAD_SAMPLE_RATE
-      const endS = startS + audio.length / VAD_SAMPLE_RATE
-      this.onSegment({ audio, startS, endS })
-    }
-    this.onActiveChange?.(false)
-    this.reset()
-  }
-
-  destroy() {
-    if (!this.mod) return
-    if (this.audioPtr) this.mod._free(this.audioPtr)
-    if (this.probPtr) this.mod._free(this.probPtr)
-    if (this.flagPtr) this.mod._free(this.flagPtr)
-    if (this.handlePtr) {
-      this.mod._ten_vad_destroy(this.handlePtr)
-      this.mod._free(this.handlePtr)
-    }
-    this.mod = null
-    this.handle = 0
-    this.handlePtr = 0
-    this.audioPtr = 0
-    this.probPtr = 0
-    this.flagPtr = 0
-  }
-
-  private reset() {
-    this.active = false
-    this.sumPositiveS = 0
-    this.silenceStartS = null
-    this.srcBuffer = new Int16Array(0)
-    this.srcBufferOffset = this.bufferOffset
-  }
-
-  private processFrame(frame: Int16Array): number {
-    if (!this.mod) return 0
-    this.mod.HEAP16.set(frame, this.audioPtr / 2)
-    this.mod._ten_vad_process(this.handle, this.audioPtr, HOP_SIZE, this.probPtr, this.flagPtr)
-    return this.mod.HEAPF32[this.probPtr >> 2]
-  }
-
-  private processChunk(chunkOffsetS: number, frame: Int16Array) {
-    const prob = this.processFrame(frame)
-    const hopS = HOP_SIZE / VAD_SAMPLE_RATE
-
-    if (!this.active) {
-      if (prob >= this.startThreshold) {
-        this.active = true
-        this.activeStartS = chunkOffsetS
-        this.sumPositiveS = hopS
-        this.onActiveChange?.(true)
-      } else {
-        const newSrcOffset = Math.floor((chunkOffsetS - this.padStartS) * VAD_SAMPLE_RATE)
-        const cutPos = newSrcOffset - this.srcBufferOffset
-        if (cutPos > 0) {
-          this.srcBuffer = this.srcBuffer.slice(cutPos)
-          this.srcBufferOffset = newSrcOffset
-        }
-      }
-      return
-    }
-
-    if (prob >= this.endThreshold) {
-      this.silenceStartS = null
-      this.sumPositiveS += hopS
-    } else if (this.silenceStartS === null) {
-      this.silenceStartS = chunkOffsetS
-    }
-
-    const shouldCut =
-      (this.silenceStartS !== null && chunkOffsetS - this.silenceStartS >= this.minSilenceS) ||
-      (chunkOffsetS - this.activeStartS >= this.maxSegmentS)
-
-    if (shouldCut) {
-      const cutSrcPos = Math.floor(chunkOffsetS * VAD_SAMPLE_RATE) - this.srcBufferOffset
-      const audio = this.srcBuffer.slice(0, cutSrcPos)
-      if (audio.length > VAD_SAMPLE_RATE * 0.2) {
-        const startS = this.srcBufferOffset / VAD_SAMPLE_RATE
-        const endS = startS + audio.length / VAD_SAMPLE_RATE
-        this.onSegment({ audio, startS, endS })
-      }
-      this.srcBuffer = this.srcBuffer.slice(cutSrcPos)
-      this.srcBufferOffset += cutSrcPos
-      this.active = false
-      this.sumPositiveS = 0
-      this.silenceStartS = null
-      this.onActiveChange?.(false)
-    }
-  }
-}