@andypai/orb 0.1.1

package/src/services/session.ts

@@ -0,0 +1,204 @@
+import { promises as fs } from 'node:fs'
+import path from 'node:path'
+import os from 'node:os'
+import crypto from 'node:crypto'
+
+import type {
+  AgentSession,
+  AnthropicModel,
+  LlmProvider,
+  OpenAiSession,
+  SavedSession,
+} from '../types'
+
+const SESSION_VERSION = 2
+const SESSION_DIR = path.join('.orb', 'sessions')
+const MAX_SESSION_AGE_DAYS = 30
+
+function isFileNotFoundError(err: unknown): boolean {
+  return (err as { code?: string })?.code === 'ENOENT'
+}
+
+function getSessionDir(): string {
+  return path.join(os.homedir(), SESSION_DIR)
+}
+
+function sanitizeFilename(value: string): string {
+  const sanitized = value.trim().replace(/[^a-zA-Z0-9._-]+/g, '-')
+  return sanitized || 'project'
+}
+
+function hashProjectPath(projectPath: string): string {
+  return crypto.createHash('sha256').update(projectPath).digest('hex').slice(0, 12)
+}
+
+export function getSessionPath(projectPath: string): string {
+  const resolved = path.resolve(projectPath)
+  const base = sanitizeFilename(path.basename(resolved))
+  const hash = hashProjectPath(resolved)
+  return path.join(getSessionDir(), `${base}-${hash}.json`)
+}
+
+interface SavedSessionV1 {
+  version: 1
+  projectPath: string
+  sessionId: string
+  model: AnthropicModel
+  lastModified: string
+  history: SavedSession['history']
+}
+
+function isSavedSessionV1(value: unknown): value is SavedSessionV1 {
+  if (!value || typeof value !== 'object') return false
+  const session = value as SavedSessionV1
+  return (
+    session.version === 1 &&
+    typeof session.projectPath === 'string' &&
+    typeof session.sessionId === 'string' &&
+    typeof session.model === 'string' &&
+    typeof session.lastModified === 'string' &&
+    Array.isArray(session.history)
+  )
+}
+
+function isSavedSessionV2(value: unknown): value is SavedSession {
+  if (!value || typeof value !== 'object') return false
+  const session = value as SavedSession
+  return (
+    session.version === SESSION_VERSION &&
+    typeof session.projectPath === 'string' &&
+    typeof session.llmProvider === 'string' &&
+    typeof session.llmModel === 'string' &&
+    typeof session.lastModified === 'string' &&
+    Array.isArray(session.history)
+  )
+}
+
+function normalizeSessionProvider(provider: string): LlmProvider | undefined {
+  if (provider === 'anthropic' || provider === 'openai') return provider
+  return undefined
+}
+
+function isValidOpenAiSession(value: unknown): value is OpenAiSession {
+  if (!value || typeof value !== 'object') return false
+  const session = value as Partial<OpenAiSession>
+  return (
+    session.provider === 'openai' &&
+    typeof session.previousResponseId === 'string' &&
+    session.previousResponseId.trim().length > 0
+  )
+}
+
+function normalizeAgentSession(session?: AgentSession): AgentSession | undefined {
+  if (!session) return undefined
+
+  switch (session.provider) {
+    case 'anthropic':
+      return session.sessionId?.length > 0 ? session : undefined
+    case 'openai':
+      return isValidOpenAiSession(session) ? session : undefined
+    default:
+      return undefined
+  }
+}
+
+async function cleanupOldSessions(maxAgeDays = MAX_SESSION_AGE_DAYS): Promise<void> {
+  const sessionDir = getSessionDir()
+  const maxAgeMs = maxAgeDays * 24 * 60 * 60 * 1000
+
+  let filenames: string[]
+  try {
+    filenames = await fs.readdir(sessionDir)
+  } catch (err) {
+    if (isFileNotFoundError(err)) return
+    throw err
+  }
+
+  const now = Date.now()
+
+  await Promise.all(
+    filenames
+      .filter((name) => name.endsWith('.json'))
+      .map(async (name) => {
+        const filePath = path.join(sessionDir, name)
+        try {
+          const stats = await fs.stat(filePath)
+          if (stats.isFile() && now - stats.mtimeMs > maxAgeMs) {
+            await fs.unlink(filePath)
+          }
+        } catch {
+          // Ignore errors for individual files
+        }
+      }),
+  )
+}
+
+export async function loadSession(projectPath: string): Promise<SavedSession | null> {
+  const resolved = path.resolve(projectPath)
+  const sessionPath = getSessionPath(resolved)
+  const sessionFile = Bun.file(sessionPath)
+
+  void cleanupOldSessions().catch((err) => {
+    console.warn('Failed to clean up old sessions:', err)
+  })
+
+  try {
+    const parsed = (await sessionFile.json()) as unknown
+    if (isSavedSessionV2(parsed)) {
+      if (path.resolve(parsed.projectPath) !== resolved) {
+        return null
+      }
+      return {
+        ...parsed,
+        llmProvider: normalizeSessionProvider(parsed.llmProvider) ?? 'anthropic',
+        agentSession: normalizeAgentSession(parsed.agentSession),
+      }
+    }
+
+    if (isSavedSessionV1(parsed)) {
+      if (path.resolve(parsed.projectPath) !== resolved) {
+        return null
+      }
+      const migrated: SavedSession = {
+        version: SESSION_VERSION,
+        projectPath: parsed.projectPath,
+        llmProvider: 'anthropic',
+        llmModel: parsed.model,
+        agentSession: parsed.sessionId
+          ? { provider: 'anthropic', sessionId: parsed.sessionId }
+          : undefined,
+        lastModified: parsed.lastModified,
+        history: parsed.history,
+      }
+      return migrated
+    }
+
+    console.warn('Invalid session format, starting fresh.')
+    return null
+  } catch (err) {
+    if (isFileNotFoundError(err)) return null
+    console.warn('Failed to load session, starting fresh:', err)
+    return null
+  }
+}
+
+export async function saveSession(session: SavedSession): Promise<void> {
+  const resolved = path.resolve(session.projectPath)
+  const sessionPath = getSessionPath(resolved)
+  const sessionDir = path.dirname(sessionPath)
+
+  await fs.mkdir(sessionDir, { recursive: true })
+
+  const payload: SavedSession = {
+    ...session,
+    version: SESSION_VERSION,
+    projectPath: resolved,
+    llmProvider: normalizeSessionProvider(session.llmProvider) ?? 'anthropic',
+    agentSession: normalizeAgentSession(session.agentSession),
+    lastModified: new Date().toISOString(),
+  }
+
+  const tempPath = `${sessionPath}.${process.pid}.${Date.now()}.tmp`
+  await Bun.write(tempPath, JSON.stringify(payload, null, 2))
+  await fs.rename(tempPath, sessionPath)
+}

package/src/services/streaming-tts.ts

@@ -0,0 +1,483 @@
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { unlink } from 'node:fs/promises'
+import { TTSError, type AppConfig } from '../types'
+import {
+  cleanTextForSpeech,
+  generateAudio,
+  playAudio,
+  stopSpeaking,
+  wasPlaybackStopped,
+  resetPlaybackStoppedFlag,
+} from './tts'
+
+export interface StreamingSpeechCallbacks {
+  onSpeakingStart?: () => void
+  onSpeakingEnd?: () => void
+  onError?: (error: TTSError) => void
+}
+
+export interface StreamingSpeechController {
+  feedText(chunk: string): void
+  finalize(): void
+  stop(): void
+  waitForCompletion(): Promise<void>
+  isActive(): boolean
+}
+
+interface QueuedAudio {
+  path: string
+  sentence: string
+}
+
+const STRONG_BOUNDARY = /[.!?]+["')\]]*(?:\s|$)/g
+const SOFT_BOUNDARY = /[,;:](?:\s|$)/g
+
+function findLastMatchIndex(text: string, re: RegExp): number {
+  const flags = re.flags.includes('g') ? re.flags : `${re.flags}g`
+  const pattern = new RegExp(re.source, flags)
+  let lastIndex = -1
+
+  while (pattern.exec(text) !== null) {
+    lastIndex = pattern.lastIndex
+  }
+
+  return lastIndex
+}
+
+function findLastWhitespaceIndex(text: string): number {
+  const lastSpace = Math.max(text.lastIndexOf(' '), text.lastIndexOf('\t'), text.lastIndexOf('\n'))
+  return lastSpace >= 0 ? lastSpace + 1 : -1
+}
+
+function extractStrongChunks(text: string): { chunks: string[]; consumed: number } {
+  const chunks: string[] = []
+  const pattern = new RegExp(STRONG_BOUNDARY.source, STRONG_BOUNDARY.flags)
+  let lastIndex = 0
+
+  while (pattern.exec(text) !== null) {
+    const end = pattern.lastIndex
+    const slice = text.slice(lastIndex, end)
+    const trimmed = slice.trimEnd()
+    if (trimmed.trim()) {
+      chunks.push(trimmed)
+    }
+    lastIndex = end
+  }
+
+  return { chunks, consumed: lastIndex }
+}
+
+function extractChunkAtBoundary(
+  text: string,
+  boundary: number,
+  minLength: number,
+  forceFlush: boolean,
+): { chunk: string | null; consumed: number } {
+  if (boundary <= 0) return { chunk: null, consumed: 0 }
+
+  const trimmed = text.slice(0, boundary).trimEnd()
+  const hasContent = trimmed.trim().length > 0
+  const meetsMinLength = forceFlush || minLength <= 0 || trimmed.trim().length >= minLength
+
+  if (!hasContent || !meetsMinLength) {
+    return { chunk: null, consumed: 0 }
+  }
+
+  return { chunk: trimmed, consumed: boundary }
+}
+
+export function createStreamingSpeechController(
+  config: AppConfig,
+  callbacks: StreamingSpeechCallbacks = {},
+): StreamingSpeechController {
+  let textBuffer = ''
+  let processedOffset = 0
+  let lastCleanedText = ''
+  let finalized = false
+  let stopped = false
+  let speakingStarted = false
+  let completed = false
+  let lastFlushAt = Date.now()
+  let maxWaitTimeout: ReturnType<typeof setTimeout> | null = null
+  let graceTimeout: ReturnType<typeof setTimeout> | null = null
+  let pendingGrace = false
+
+  const sentenceQueue: string[] = []
+  const audioQueue: QueuedAudio[] = []
+
+  let isGenerating = false
+  let isPlaying = false
+  let generationAbortController: AbortController | null = null
+  let completionResolve: (() => void) | null = null
+  let completionReject: ((error: TTSError) => void) | null = null
+  let completionPromise: Promise<void> | null = null
+  let fatalError: TTSError | null = null
+
+  function clearTimers(): void {
+    if (maxWaitTimeout) {
+      clearTimeout(maxWaitTimeout)
+      maxWaitTimeout = null
+    }
+    if (graceTimeout) {
+      clearTimeout(graceTimeout)
+      graceTimeout = null
+    }
+    pendingGrace = false
+  }
+
+  async function cleanupAudioPath(path: string): Promise<void> {
+    await unlink(path).catch(() => {})
+  }
+
+  function clearAudioQueue(): void {
+    for (const audio of audioQueue) {
+      void cleanupAudioPath(audio.path)
+    }
+    audioQueue.length = 0
+  }
+
+  function enqueueChunk(chunk: string, now: number): void {
+    if (!chunk.trim()) return
+    sentenceQueue.push(chunk)
+    lastFlushAt = now
+  }
+
+  function reconcileProcessedOffset(cleanedText: string): void {
+    if (!lastCleanedText) {
+      lastCleanedText = cleanedText
+      processedOffset = Math.min(processedOffset, cleanedText.length)
+      return
+    }
+
+    if (cleanedText !== lastCleanedText) {
+      const maxCheck = Math.min(processedOffset, cleanedText.length, lastCleanedText.length)
+      let index = 0
+
+      while (index < maxCheck && cleanedText[index] === lastCleanedText[index]) {
+        index += 1
+      }
+
+      if (processedOffset > index) {
+        processedOffset = index
+      }
+      lastCleanedText = cleanedText
+    }
+
+    if (processedOffset > cleanedText.length) {
+      processedOffset = cleanedText.length
+    }
+  }
+
+  function getPendingText(cleanedText: string): string {
+    reconcileProcessedOffset(cleanedText)
+    return cleanedText.slice(processedOffset)
+  }
+
+  function tryExtractAtBoundary(
+    cleanedText: string,
+    pending: string,
+    boundary: number,
+    minLength: number,
+    forceFlush: boolean,
+    now: number,
+  ): string {
+    const result = extractChunkAtBoundary(pending, boundary, minLength, forceFlush)
+    if (result.consumed > 0) {
+      if (result.chunk) enqueueChunk(result.chunk, now)
+      processedOffset += result.consumed
+      return getPendingText(cleanedText)
+    }
+    return pending
+  }
+
+  function extractChunksFromCleaned(
+    cleanedText: string,
+    options: { forceFlush: boolean; finalized: boolean; now: number },
+  ): string {
+    let pending = getPendingText(cleanedText)
+    if (!pending.trim()) return pending
+
+    const strong = extractStrongChunks(pending)
+    if (strong.chunks.length > 0) {
+      for (const chunk of strong.chunks) enqueueChunk(chunk, options.now)
+      processedOffset += strong.consumed
+      pending = getPendingText(cleanedText)
+    }
+
+    if (options.finalized) {
+      if (pending.trim()) enqueueChunk(pending.trimEnd(), options.now)
+      processedOffset = cleanedText.length
+      return ''
+    }
+
+    if (!pending.trim()) return pending
+
+    const { ttsMinChunkLength: minLength, ttsClauseBoundaries: allowClauses } = config
+
+    if (allowClauses) {
+      const softBoundary = findLastMatchIndex(pending, SOFT_BOUNDARY)
+      pending = tryExtractAtBoundary(
+        cleanedText,
+        pending,
+        softBoundary,
+        minLength,
+        options.forceFlush,
+        options.now,
+      )
+    }
+
+    if (!options.forceFlush || !pending.trim()) return pending
+
+    const maxChunkLength = 200
+    const wsBoundary = findLastWhitespaceIndex(pending)
+    if (wsBoundary > 0) {
+      pending = tryExtractAtBoundary(cleanedText, pending, wsBoundary, minLength, true, options.now)
+    } else if (pending.length > 0) {
+      // No whitespace boundary found - emit at max length or flush all if shorter
+      const emitLength = Math.min(pending.length, maxChunkLength)
+      enqueueChunk(pending.slice(0, emitLength), options.now)
+      processedOffset += emitLength
+      pending = pending.slice(emitLength)
+    }
+
+    return pending
+  }
+
+  function extractChunks(options: { forceFlush: boolean; finalized: boolean }): string {
+    const cleanedText = cleanTextForSpeech(textBuffer)
+    const now = Date.now()
+    return extractChunksFromCleaned(cleanedText, { ...options, now })
+  }
+
+  function shouldGrace(pending: string): boolean {
+    return /[\s.,!?;:]["')\]]?$/.test(pending)
+  }
+
+  function resetFlushTimers(pendingText: string): void {
+    clearTimers()
+    if (stopped || finalized) return
+    if (config.ttsMaxWaitMs <= 0) return
+    if (!pendingText.trim()) return
+
+    const elapsed = Date.now() - lastFlushAt
+    const delay = Math.max(config.ttsMaxWaitMs - elapsed, 0)
+    maxWaitTimeout = setTimeout(handleMaxWait, delay)
+  }
+
+  function handleMaxWait(): void {
+    if (stopped || finalized) return
+
+    const cleanedText = cleanTextForSpeech(textBuffer)
+    const pendingText = getPendingText(cleanedText)
+    if (!pendingText.trim()) {
+      return
+    }
+
+    if (config.ttsGraceWindowMs > 0 && shouldGrace(pendingText) && !pendingGrace) {
+      pendingGrace = true
+      graceTimeout = setTimeout(() => {
+        pendingGrace = false
+        const remaining = extractChunks({ forceFlush: true, finalized: false })
+        maybeStartGeneration()
+        resetFlushTimers(remaining)
+      }, config.ttsGraceWindowMs)
+      return
+    }
+
+    const lastFlush = lastFlushAt
+    const remaining = extractChunksFromCleaned(cleanedText, {
+      forceFlush: true,
+      finalized: false,
+      now: Date.now(),
+    })
+    if (remaining.trim() && lastFlushAt === lastFlush) {
+      lastFlushAt = Date.now()
+    }
+    maybeStartGeneration()
+    resetFlushTimers(remaining)
+  }
+
+  async function processGenerationQueue(): Promise<void> {
+    if (isGenerating || stopped) return
+
+    const sentence = sentenceQueue.shift()
+    if (!sentence) {
+      checkCompletion()
+      return
+    }
+
+    isGenerating = true
+    generationAbortController = new AbortController()
+    const audioPath = join(
+      tmpdir(),
+      `tts-stream-${Date.now()}-${Math.random().toString(36).slice(2, 8)}.${
+        config.ttsMode === 'generate' ? 'aiff' : 'wav'
+      }`,
+    )
+
+    try {
+      await generateAudio(sentence, config, audioPath, generationAbortController.signal)
+      if (!stopped) {
+        audioQueue.push({ path: audioPath, sentence })
+        processPlaybackQueue()
+      } else {
+        await cleanupAudioPath(audioPath)
+      }
+    } catch (err) {
+      const ttsError =
+        err instanceof TTSError ? err : new TTSError(String(err), 'generation_failed')
+      callbacks.onError?.(ttsError)
+      fail(ttsError)
+    } finally {
+      generationAbortController = null
+      isGenerating = false
+      if (!stopped) {
+        processGenerationQueue()
+      }
+    }
+  }
+
+  async function processPlaybackQueue(): Promise<void> {
+    if (isPlaying || stopped) return
+
+    const audio = audioQueue.shift()
+    if (!audio) {
+      checkCompletion()
+      return
+    }
+
+    isPlaying = true
+    resetPlaybackStoppedFlag()
+
+    // Notify that speaking has started
+    if (!speakingStarted) {
+      speakingStarted = true
+      callbacks.onSpeakingStart?.()
+    }
+
+    try {
+      await playAudio(audio.path, config.ttsSpeed)
+    } catch (err) {
+      // Check if playback was stopped manually (not an error)
+      if (!wasPlaybackStopped()) {
+        const ttsError = err instanceof TTSError ? err : new TTSError(String(err), 'audio_playback')
+        callbacks.onError?.(ttsError)
+        fail(ttsError)
+      }
+    } finally {
+      await cleanupAudioPath(audio.path)
+
+      isPlaying = false
+      if (!stopped) {
+        processPlaybackQueue()
+      }
+    }
+  }
+
+  function hasWorkRemaining(): boolean {
+    return isGenerating || isPlaying || sentenceQueue.length > 0 || audioQueue.length > 0
+  }
+
+  function markComplete(): void {
+    if (completed) return
+    completed = true
+    if (speakingStarted) callbacks.onSpeakingEnd?.()
+    completionResolve?.()
+  }
+
+  function fail(error: TTSError): void {
+    if (completed) return
+    fatalError = error
+    stopped = true
+    completed = true
+    sentenceQueue.length = 0
+    clearAudioQueue()
+    completionReject?.(error)
+  }
+
+  function checkCompletion(): void {
+    if (finalized && !stopped && !hasWorkRemaining() && !completed) {
+      markComplete()
+    }
+  }
+
+  function maybeStartGeneration(): void {
+    if (stopped || isGenerating) return
+    if (sentenceQueue.length >= config.ttsBufferSentences || finalized) {
+      processGenerationQueue()
+    }
+  }
+
+  return {
+    feedText(chunk: string): void {
+      if (stopped || !config.ttsEnabled) return
+      textBuffer += chunk
+      const remaining = extractChunks({ forceFlush: false, finalized: false })
+      maybeStartGeneration()
+      resetFlushTimers(remaining)
+    },
+
+    finalize(): void {
+      if (stopped || finalized) return
+      finalized = true
+      clearTimers()
+
+      if (!config.ttsEnabled) {
+        completionResolve?.()
+        return
+      }
+
+      // Extract any remaining chunks
+      extractChunks({ forceFlush: true, finalized: true })
+      processGenerationQueue()
+      checkCompletion()
+    },
+
+    stop(): void {
+      stopped = true
+      completed = true
+      clearTimers()
+      sentenceQueue.length = 0
+
+      clearAudioQueue()
+
+      generationAbortController?.abort()
+      generationAbortController = null
+
+      // Stop current playback
+      stopSpeaking()
+
+      // Resolve completion promise
+      completionResolve?.()
+    },
+
+    waitForCompletion(): Promise<void> {
+      if (completionPromise) return completionPromise
+
+      completionPromise = new Promise((resolve, reject) => {
+        completionResolve = resolve
+        completionReject = reject
+
+        if (fatalError) {
+          reject(fatalError)
+          return
+        }
+
+        const alreadyDone = stopped || completed || !config.ttsEnabled
+        const justFinished = finalized && !hasWorkRemaining()
+
+        if (alreadyDone || justFinished) {
+          markComplete()
+          resolve()
+        }
+      })
+
+      return completionPromise
+    },
+
+    isActive(): boolean {
+      return !stopped && (hasWorkRemaining() || speakingStarted)
+    },
+  }
+}