savant-code 0.0.17 → 0.0.19

package/cli/src/utils/message-history.ts

@@ -0,0 +1,153 @@
+import fs from 'fs'
+import path from 'path'
+
+import { getConfigDir } from './auth'
+import { formatTimestamp } from './helpers'
+import { logger } from './logger'
+
+import type {
+  ChatMessage,
+  ContentBlock,
+  FileAttachment,
+  ImageAttachment,
+  TextAttachment,
+} from '../types/chat'
+
+const MAX_HISTORY_SIZE = 1000
+
+export function getUserMessage(
+  message: string | ContentBlock[],
+  attachments?: ImageAttachment[],
+  textAttachments?: TextAttachment[],
+  fileAttachments?: FileAttachment[],
+): ChatMessage {
+  return {
+    id: `user-${Date.now()}`,
+    variant: 'user',
+    ...(typeof message === 'string'
+      ? {
+          content: message,
+        }
+      : {
+          content: '',
+          blocks: message,
+        }),
+    timestamp: formatTimestamp(),
+    ...(attachments && attachments.length > 0 ? { attachments } : {}),
+    ...(textAttachments && textAttachments.length > 0
+      ? { textAttachments }
+      : {}),
+    ...(fileAttachments && fileAttachments.length > 0
+      ? { fileAttachments }
+      : {}),
+  }
+}
+
+export function getSystemMessage(
+  content: string | ContentBlock[],
+): ChatMessage {
+  return {
+    id: `sys-${Date.now()}`,
+    variant: 'ai' as const,
+    ...(typeof content === 'string'
+      ? {
+          content,
+        }
+      : {
+          content: '',
+          blocks: content,
+        }),
+    timestamp: formatTimestamp(),
+  }
+}
+
+/**
+ * Get the message history file path
+ */
+export const getMessageHistoryPath = (): string => {
+  return path.join(getConfigDir(), 'message-history.json')
+}
+
+/**
+ * Load message history from file system
+ * @returns Array of previous messages, most recent last
+ */
+export const loadMessageHistory = (): string[] => {
+  const historyPath = getMessageHistoryPath()
+
+  if (!fs.existsSync(historyPath)) {
+    return []
+  }
+
+  try {
+    const historyFile = fs.readFileSync(historyPath, 'utf8')
+    const history = JSON.parse(historyFile)
+
+    if (!Array.isArray(history)) {
+      logger.warn('Message history file has invalid format, resetting')
+      return []
+    }
+
+    return history.filter((item) => typeof item === 'string')
+  } catch (error) {
+    logger.error(
+      {
+        error: error instanceof Error ? error.message : String(error),
+      },
+      'Error reading message history',
+    )
+    return []
+  }
+}
+
+/**
+ * Save message history to file system
+ */
+export const saveMessageHistory = (history: string[]): void => {
+  const configDir = getConfigDir()
+  const historyPath = getMessageHistoryPath()
+
+  try {
+    // Ensure config directory exists
+    if (!fs.existsSync(configDir)) {
+      fs.mkdirSync(configDir, { recursive: true })
+    }
+
+    // Limit history size to prevent file from growing too large
+    const limitedHistory =
+      history.length > MAX_HISTORY_SIZE
+        ? history.slice(history.length - MAX_HISTORY_SIZE)
+        : history
+
+    // Save history
+    fs.writeFileSync(historyPath, JSON.stringify(limitedHistory, null, 2))
+  } catch (error) {
+    logger.error(
+      {
+        error: error instanceof Error ? error.message : String(error),
+      },
+      'Error saving message history',
+    )
+    // Don't throw - history persistence is not critical
+  }
+}
+
+/**
+ * Clear message history from file system
+ */
+export const clearMessageHistory = (): void => {
+  const historyPath = getMessageHistoryPath()
+
+  try {
+    if (fs.existsSync(historyPath)) {
+      fs.unlinkSync(historyPath)
+    }
+  } catch (error) {
+    logger.error(
+      {
+        error: error instanceof Error ? error.message : String(error),
+      },
+      'Error clearing message history',
+    )
+  }
+}

package/cli/src/utils/message-tree-utils.ts

@@ -0,0 +1,67 @@
+import type { ChatMessage } from '../types/chat'
+
+export function buildMessageTree(messages: ChatMessage[]): {
+  tree: Map<string, ChatMessage[]>
+  topLevelMessages: ChatMessage[]
+} {
+  const messageTree = new Map<string, ChatMessage[]>()
+  const topLevelMessages: ChatMessage[] = []
+
+  for (const message of messages) {
+    if (message.parentId) {
+      const siblings = messageTree.get(message.parentId) ?? []
+      siblings.push(message)
+      messageTree.set(message.parentId, siblings)
+    } else {
+      topLevelMessages.push(message)
+    }
+  }
+
+  return { tree: messageTree, topLevelMessages }
+}
+
+export function getDescendantIds(
+  agentId: string,
+  tree: Map<string, ChatMessage[]>,
+): string[] {
+  const children = tree.get(agentId) ?? []
+  const descendantIds: string[] = []
+
+  for (const child of children) {
+    if (child.variant === 'agent') {
+      descendantIds.push(child.id)
+      descendantIds.push(...getDescendantIds(child.id, tree))
+    }
+  }
+
+  return descendantIds
+}
+
+export function getAncestorIds(
+  agentId: string,
+  messages: ChatMessage[],
+): string[] {
+  const agent = messages.find((m) => m.id === agentId)
+  if (!agent || !agent.parentId) return []
+
+  const parent = messages.find((m) => m.id === agent.parentId)
+  if (!parent || parent.variant !== 'agent') return []
+
+  return [parent.id, ...getAncestorIds(parent.id, messages)]
+}
+
+export function isAgentVisible(
+  agentId: string,
+  messages: ChatMessage[],
+  collapsedAgents: Set<string>,
+): boolean {
+  const agent = messages.find((m) => m.id === agentId)
+  if (!agent || agent.variant !== 'agent') return false
+
+  const parent = messages.find((m) => m.id === agent.parentId)
+  if (!parent || parent.variant !== 'agent') return true
+
+  if (collapsedAgents.has(parent.id)) return false
+
+  return isAgentVisible(parent.id, messages, collapsedAgents)
+}

package/cli/src/utils/message-updater.ts

@@ -0,0 +1,279 @@
+import type { ChatMessage, ContentBlock, TextContentBlock } from '../types/chat'
+
+// Small wrapper to avoid repeating the ai-message map/update pattern.
+export type SetMessagesFn = (
+  updater: (messages: ChatMessage[]) => ChatMessage[],
+) => void
+
+export type MessageUpdater = {
+  updateAiMessage: (updater: (msg: ChatMessage) => ChatMessage) => void
+  updateAiMessageBlocks: (
+    blockUpdater: (blocks: ContentBlock[]) => ContentBlock[],
+  ) => void
+  markComplete: (metadata?: Partial<ChatMessage>) => void
+  setError: (message: string) => void
+  /** Clears the userError field (e.g., when a new message is sent successfully) */
+  clearUserError: () => void
+  addBlock: (block: ContentBlock) => void
+}
+
+/** Extended updater with batching control methods */
+export type BatchedMessageUpdater = MessageUpdater & {
+  /** Immediately flush all pending updates to state */
+  flush: () => void
+  /** Stop the flush interval and clean up. Called automatically by markComplete/setError */
+  dispose: () => void
+}
+
+/** Default interval for batched updates in milliseconds */
+export const DEFAULT_FLUSH_INTERVAL_MS = 100
+
+export const createMessageUpdater = (
+  aiMessageId: string,
+  setMessages: SetMessagesFn,
+): MessageUpdater => {
+  const updateAiMessage = (updater: (msg: ChatMessage) => ChatMessage) => {
+    setMessages((prev) =>
+      prev.map((msg) => (msg.id === aiMessageId ? updater(msg) : msg)),
+    )
+  }
+
+  const updateAiMessageBlocks = (
+    blockUpdater: (blocks: ContentBlock[]) => ContentBlock[],
+  ) => {
+    updateAiMessage((msg) => ({
+      ...msg,
+      blocks: blockUpdater(msg.blocks ?? []),
+    }))
+  }
+
+  const addBlock = (block: ContentBlock) => {
+    updateAiMessage((msg) => ({
+      ...msg,
+      blocks: [...(msg.blocks ?? []), block],
+    }))
+  }
+
+  const markComplete = (metadata?: Partial<ChatMessage>) => {
+    updateAiMessage((msg) => {
+      const { metadata: messageMetadata, ...rest } = metadata ?? {}
+
+      // Mark native reasoning blocks as complete by setting thinkingOpen = false
+      // This ensures thinking blocks auto-collapse when the message finishes
+      // Check for thinkingOpen !== false to handle both true (native) and undefined (legacy)
+      const updatedBlocks = msg.blocks?.map((block) => {
+        if (
+          block.type === 'text' &&
+          (block as TextContentBlock).textType === 'reasoning' &&
+          (block as TextContentBlock).thinkingOpen !== false
+        ) {
+          return { ...block, thinkingOpen: false } as ContentBlock
+        }
+        return block
+      })
+
+      const nextMessage: ChatMessage = {
+        ...msg,
+        isComplete: true,
+        ...(updatedBlocks && { blocks: updatedBlocks }),
+        ...rest,
+      }
+
+      if (messageMetadata) {
+        nextMessage.metadata = {
+          ...(msg.metadata ?? {}),
+          ...messageMetadata,
+        }
+      }
+
+      return nextMessage
+    })
+  }
+
+  const setError = (message: string) => {
+    updateAiMessage((msg) => ({
+      ...msg,
+      userError: message,
+      isComplete: true,
+    }))
+  }
+
+  /**
+   * Clears the userError field from the message.
+   * Call this when starting a new successful interaction to dismiss any previous error banners.
+   */
+  const clearUserError = () => {
+    updateAiMessage((msg) => {
+      if (!msg.userError) return msg
+      const { userError: _, ...rest } = msg
+      return rest as ChatMessage
+    })
+  }
+
+  return {
+    updateAiMessage,
+    updateAiMessageBlocks,
+    markComplete,
+    setError,
+    clearUserError,
+    addBlock,
+  }
+}
+
+/** Batched updater that queues updates and flushes at a regular interval. */
+export const createBatchedMessageUpdater = (
+  aiMessageId: string,
+  setMessages: SetMessagesFn,
+  flushIntervalMs: number = DEFAULT_FLUSH_INTERVAL_MS,
+): BatchedMessageUpdater => {
+  // Queue of message updater functions to be applied on next flush
+  const pendingUpdaters: Array<(msg: ChatMessage) => ChatMessage> = []
+  let intervalId: ReturnType<typeof setInterval> | null = null
+  let isDisposed = false
+
+  const flush = () => {
+    if (pendingUpdaters.length === 0) return
+
+    // Capture and clear the queue atomically
+    const updaters = pendingUpdaters.splice(0, pendingUpdaters.length)
+
+    // Compose all pending updaters into a single transform
+    const composedUpdater = (msg: ChatMessage): ChatMessage => {
+      return updaters.reduce((m, fn) => fn(m), msg)
+    }
+
+    // Apply composed update to the target message
+    setMessages((prev) =>
+      prev.map((msg) => (msg.id === aiMessageId ? composedUpdater(msg) : msg)),
+    )
+  }
+
+  const dispose = () => {
+    if (isDisposed) return
+    // Flush any pending updates before disposing to prevent data loss
+    flush()
+    isDisposed = true
+    if (intervalId !== null) {
+      clearInterval(intervalId)
+      intervalId = null
+    }
+  }
+
+  // Start the periodic flush interval
+  intervalId = setInterval(flush, flushIntervalMs)
+
+  const updateAiMessage = (updater: (msg: ChatMessage) => ChatMessage) => {
+    if (isDisposed) {
+      // If disposed, apply immediately as fallback
+      setMessages((prev) =>
+        prev.map((msg) => (msg.id === aiMessageId ? updater(msg) : msg)),
+      )
+      return
+    }
+    pendingUpdaters.push(updater)
+  }
+
+  const updateAiMessageBlocks = (
+    blockUpdater: (blocks: ContentBlock[]) => ContentBlock[],
+  ) => {
+    updateAiMessage((msg) => ({
+      ...msg,
+      blocks: blockUpdater(msg.blocks ?? []),
+    }))
+  }
+
+  const addBlock = (block: ContentBlock) => {
+    updateAiMessage((msg) => ({
+      ...msg,
+      blocks: [...(msg.blocks ?? []), block],
+    }))
+  }
+
+  const markComplete = (metadata?: Partial<ChatMessage>) => {
+    // Flush any pending updates first
+    flush()
+    // Stop the interval
+    dispose()
+
+    // Apply completion immediately
+    setMessages((prev) =>
+      prev.map((msg) => {
+        if (msg.id !== aiMessageId) return msg
+        const { metadata: messageMetadata, ...rest } = metadata ?? {}
+
+        // Mark native reasoning blocks as complete by setting thinkingOpen = false
+        // This ensures thinking blocks auto-collapse when the message finishes
+        // Check for thinkingOpen !== false to handle both true (native) and undefined (legacy)
+        const updatedBlocks = msg.blocks?.map((block) => {
+          if (
+            block.type === 'text' &&
+            (block as TextContentBlock).textType === 'reasoning' &&
+            (block as TextContentBlock).thinkingOpen !== false
+          ) {
+            return { ...block, thinkingOpen: false } as ContentBlock
+          }
+          return block
+        })
+
+        const nextMessage: ChatMessage = {
+          ...msg,
+          isComplete: true,
+          ...(updatedBlocks && { blocks: updatedBlocks }),
+          ...rest,
+        }
+        if (messageMetadata) {
+          nextMessage.metadata = {
+            ...(msg.metadata ?? {}),
+            ...messageMetadata,
+          }
+        }
+        return nextMessage
+      }),
+    )
+  }
+
+  const setError = (message: string) => {
+    // Flush any pending updates first so we don't lose streamed content
+    flush()
+    // Stop the interval
+    dispose()
+
+    // Apply error immediately while preserving existing content and blocks
+    setMessages((prev) =>
+      prev.map((msg) => {
+        if (msg.id !== aiMessageId) return msg
+        return {
+          ...msg,
+          userError: message,
+          isComplete: true,
+        }
+      }),
+    )
+  }
+
+  /**
+   * Clears the userError field from the message immediately (bypasses batch queue).
+   * Call this when starting a new successful interaction to dismiss any previous error banners.
+   */
+  const clearUserError = () => {
+    // Apply immediately (bypass batch queue) so error banners are dismissed instantly
+    setMessages((prev) =>
+      prev.map((msg) => {
+        if (msg.id !== aiMessageId || !msg.userError) return msg
+        const { userError: _, ...rest } = msg
+        return rest as ChatMessage
+      }),
+    )
+  }
+
+  return {
+    updateAiMessage,
+    updateAiMessageBlocks,
+    markComplete,
+    setError,
+    clearUserError,
+    addBlock,
+    flush,
+    dispose,
+  }
+}

package/cli/src/utils/ollama-onboarding.ts

@@ -0,0 +1,215 @@
+import {
+  detectOllama,
+  type OllamaDetectionResult,
+} from '@savant-code/llm-providers/ollama'
+
+import { getAuthToken, getAuthTokenDetails } from './auth'
+import { logger } from './logger'
+import {
+  DEFAULT_SAVANT_CODE_MODEL_ID,
+  loadSettings,
+  saveSettings,
+} from './settings'
+
+/**
+ * Whether Ollama was auto-configured as the default provider in this session.
+ * Exported so callers can avoid prompting the user again.
+ */
+let ollamaAutoConfigured = false
+
+/**
+ * Pick a model that Ollama can serve locally. Cloud-backed Ollama entries are
+ * excluded because they still require remote provider authentication.
+ */
+export function selectLocalOllamaModel(models: string[]): string | undefined {
+  // Cloud-backed, embedding, and reranking models cannot serve chat
+  // completions through the OpenAI-compatible endpoint.
+  const usableModels = models.filter((model) => {
+    const normalized = model.toLowerCase()
+    return (
+      !normalized.endsWith(':cloud') &&
+      !normalized.includes('embed') &&
+      !normalized.includes('rerank')
+    )
+  })
+
+  // Prefer coding/chat models when several local models are installed, while
+  // retaining a deterministic fallback for arbitrary Ollama model names.
+  return (
+    usableModels.find((model) =>
+      /code|coder|chat|instruct|llama|qwen|mistral|deepseek|gemma/i.test(model),
+    ) ?? usableModels[0]
+  )
+}
+
+export function isOllamaAutoConfigured(): boolean {
+  return ollamaAutoConfigured
+}
+
+/** Test-only helper to reset the module-level auto-config flag. */
+export function __resetOllamaAutoConfigured(): void {
+  ollamaAutoConfigured = false
+}
+
+/**
+ * Apply persisted direct-provider settings to the current process. This lets
+ * users who previously chose local Ollama keep using it across launches
+ * without re-detection.
+ *
+ * Intentionally skips when a real SavantCode backend token is present so that
+ * logging in always takes precedence over a previous local-only setup.
+ */
+export function applyPersistedDirectProviderSettings(): void {
+  // A real backend token means the user wants the SavantCode backend, not a
+  // previously persisted local provider.
+  if (getAuthToken()) {
+    return
+  }
+
+  // A direct provider already present in the environment was selected by the
+  // shell or restored from a saved provider key; it takes precedence over an
+  // older persisted Ollama choice.
+  if (
+    process.env.DIRECT_PROVIDER?.trim() ||
+    process.env.INFERENCE_BASE_URL?.trim()
+  ) {
+    return
+  }
+
+  const settings = loadSettings()
+  if (settings.directProvider === 'ollama' && settings.directProviderBaseUrl) {
+    try {
+      // Validate the persisted URL before using it.
+      new URL(settings.directProviderBaseUrl)
+    } catch {
+      logger.warn(
+        { baseUrl: settings.directProviderBaseUrl },
+        'Ignoring malformed persisted direct-provider base URL',
+      )
+      return
+    }
+    process.env.DIRECT_PROVIDER = 'ollama'
+    process.env.INFERENCE_BASE_URL = settings.directProviderBaseUrl
+    ollamaAutoConfigured = true
+  }
+}
+
+/**
+ * On first run, if the user has no SavantCode backend token and has not
+ * explicitly chosen a direct provider, detect a local Ollama instance and
+ * automatically route inference to it.
+ *
+ * This makes the "single-command install" path frictionless: users with
+ * `ollama serve` running can start coding immediately without creating an
+ * account or entering an API key.
+ */
+export async function detectOllamaAndConfigureDirectProvider(
+  detect: () => Promise<OllamaDetectionResult> = detectOllama,
+): Promise<void> {
+  // Respect explicit user configuration: if a real backend token or direct
+  // provider is already set, do not override it. Direct-provider mode returns
+  // a stub bypass token from auth.ts; that is not backend authentication and
+  // must not prevent stale Ollama re-probing.
+  const authSource = getAuthTokenDetails().source
+  const hasBackendToken =
+    authSource === 'credentials' || authSource === 'environment'
+  const hasDirectProviderEnv =
+    (process.env.DIRECT_PROVIDER ?? '').trim().length > 0 ||
+    (process.env.INFERENCE_BASE_URL ?? '').trim().length > 0
+
+  // `applyPersistedDirectProviderSettings` marks persisted Ollama state as
+  // auto-configured. Re-probe that state so a stale gateway model preference
+  // is replaced by a real local Ollama model. Explicit shell configuration is
+  // never overridden. A non-default, non-auto-configured model is also an
+  // explicit user choice and must not be silently replaced by local detection.
+  const settings = loadSettings()
+  const hasExplicitNonOllamaModelChoice =
+    settings.savantCodeModelAutoConfigured !== true &&
+    settings.savantCodeModelPreference !== undefined &&
+    settings.savantCodeModelPreference !== DEFAULT_SAVANT_CODE_MODEL_ID &&
+    settings.savantCodeModelProviderPreference !== 'ollama'
+
+  if (
+    hasBackendToken ||
+    (hasDirectProviderEnv && !ollamaAutoConfigured) ||
+    (!hasDirectProviderEnv && hasExplicitNonOllamaModelChoice)
+  ) {
+    return
+  }
+
+  logger.debug(
+    {},
+    'Detecting local Ollama instance for frictionless onboarding',
+  )
+
+  const ollama = await detect()
+
+  const localModel = ollama.available
+    ? selectLocalOllamaModel(ollama.models)
+    : undefined
+
+  if (!ollama.available || !localModel) {
+    // A previously auto-configured Ollama session must not leave a stale
+    // direct-provider environment behind when Ollama disappears or has no
+    // usable chat model. Require an exact persisted/current-environment match
+    // so an explicitly configured shell provider is never cleared.
+    const persistedOllamaMatchesCurrentEnvironment =
+      settings.directProvider === 'ollama' &&
+      settings.directProviderBaseUrl === process.env.INFERENCE_BASE_URL &&
+      process.env.DIRECT_PROVIDER === 'ollama'
+
+    if (ollamaAutoConfigured && persistedOllamaMatchesCurrentEnvironment) {
+      delete process.env.DIRECT_PROVIDER
+      delete process.env.INFERENCE_BASE_URL
+      ollamaAutoConfigured = false
+      // Remove the persisted auto-provider fields as well. Otherwise the next
+      // launch reapplies the same stale state before probing Ollama again.
+      saveSettings({
+        directProvider: undefined,
+        directProviderBaseUrl: undefined,
+        savantCodeModelPreference: DEFAULT_SAVANT_CODE_MODEL_ID,
+        savantCodeModelProviderPreference: 'opencode-go',
+        savantCodeModelAutoConfigured: false,
+      })
+    }
+    logger.debug(
+      { error: ollama.error, host: ollama.host },
+      'Ollama unavailable or has no local chat model; direct provider disabled',
+    )
+    return
+  }
+
+  // Derive the OpenAI-compatible base URL from the detected host. This
+  // preserves custom OLLAMA_HOST values (e.g. a remote or port-forwarded
+  // Ollama instance).
+  const baseUrl = ollama.host.endsWith('/v1')
+    ? ollama.host
+    : `${ollama.host}/v1`
+
+  process.env.DIRECT_PROVIDER = 'ollama'
+  process.env.INFERENCE_BASE_URL = baseUrl
+  ollamaAutoConfigured = true
+
+  // Persist both the provider and a real local model. Replace the gateway
+  // default, a prior automatic choice, or a model selected for another
+  // provider. Preserve an explicitly selected Ollama model across launches.
+  const shouldSelectLocalModel =
+    settings.savantCodeModelAutoConfigured === true ||
+    settings.savantCodeModelPreference === DEFAULT_SAVANT_CODE_MODEL_ID ||
+    settings.savantCodeModelProviderPreference !== 'ollama'
+
+  saveSettings({
+    savantCodeModelPreference: shouldSelectLocalModel
+      ? localModel
+      : settings.savantCodeModelPreference,
+    savantCodeModelProviderPreference: 'ollama',
+    savantCodeModelAutoConfigured: shouldSelectLocalModel,
+    directProvider: 'ollama',
+    directProviderBaseUrl: baseUrl,
+  })
+
+  logger.info(
+    { host: ollama.host, models: ollama.models.length },
+    'Auto-configured Ollama direct-provider mode',
+  )
+}