savant-code 0.0.19 → 0.0.21

package/cli/src/state/publish-store.ts

@@ -1,141 +0,0 @@
-import { create } from 'zustand'
-import { immer } from 'zustand/middleware/immer'
-
-export type PublishStep = 'selection' | 'confirmation' | 'success' | 'error'
-
-export interface PublishSuccessResult {
-  publisherId: string
-  agents: Array<{
-    id: string
-    version: string
-    displayName: string
-  }>
-}
-
-export interface PublishErrorResult {
-  error: string
-  details?: string
-  hint?: string
-}
-
-interface PublishState {
-  publishMode: boolean
-  selectedAgentIds: Set<string>
-  searchQuery: string
-  currentStep: PublishStep
-  focusedIndex: number
-  isPublishing: boolean
-  successResult: PublishSuccessResult | null
-  errorResult: PublishErrorResult | null
-  /** Whether to include agents that spawn the selected agents (reverse dependencies) */
-  includeDependents: boolean
-}
-
-interface PublishActions {
-  openPublishMode: () => void
-  closePublish: () => void
-  toggleAgentSelection: (agentId: string) => void
-  setSearchQuery: (query: string) => void
-  goToConfirmation: () => void
-  goBackToSelection: () => void
-  setFocusedIndex: (index: number) => void
-  preSelectAgents: (agentIds: string[]) => void
-  setIsPublishing: (publishing: boolean) => void
-  setSuccessResult: (result: PublishSuccessResult) => void
-  setErrorResult: (result: PublishErrorResult) => void
-  setIncludeDependents: (include: boolean) => void
-  reset: () => void
-}
-
-type PublishStore = PublishState & PublishActions
-
-const createInitialState = (publishMode = false): PublishState => ({
-  publishMode,
-  selectedAgentIds: new Set(),
-  searchQuery: '',
-  currentStep: 'selection',
-  focusedIndex: 0,
-  isPublishing: false,
-  successResult: null,
-  errorResult: null,
-  includeDependents: false,
-})
-
-const initialState: PublishState = createInitialState()
-
-export const usePublishStore = create<PublishStore>()(
-  immer((set) => ({
-    ...initialState,
-
-    openPublishMode: () => set(() => createInitialState(true)),
-
-    closePublish: () => set(() => createInitialState(false)),
-
-    toggleAgentSelection: (agentId) =>
-      set((state) => {
-        if (state.selectedAgentIds.has(agentId)) {
-          state.selectedAgentIds.delete(agentId)
-        } else {
-          state.selectedAgentIds.add(agentId)
-        }
-      }),
-
-    setSearchQuery: (query) =>
-      set((state) => {
-        state.searchQuery = query
-        state.focusedIndex = 0 // Reset focus when search changes
-      }),
-
-    goToConfirmation: () =>
-      set((state) => {
-        state.currentStep = 'confirmation'
-        state.focusedIndex = 0
-      }),
-
-    goBackToSelection: () =>
-      set((state) => {
-        state.currentStep = 'selection'
-        state.focusedIndex = 0
-      }),
-
-    setFocusedIndex: (index) =>
-      set((state) => {
-        state.focusedIndex = index
-      }),
-
-    preSelectAgents: (agentIds) =>
-      set(() => {
-        const nextState = createInitialState(true)
-        nextState.selectedAgentIds = new Set(agentIds)
-        // Stay on selection step so user can review/modify before confirming
-        nextState.currentStep = 'selection'
-        return nextState
-      }),
-
-    setIsPublishing: (publishing) =>
-      set((state) => {
-        state.isPublishing = publishing
-      }),
-
-    setSuccessResult: (result) =>
-      set((state) => {
-        state.successResult = result
-        state.currentStep = 'success'
-        state.isPublishing = false
-      }),
-
-    setErrorResult: (result) =>
-      set((state) => {
-        state.errorResult = result
-        state.currentStep = 'error'
-        state.isPublishing = false
-      }),
-
-    setIncludeDependents: (include) =>
-      set((state) => {
-        state.includeDependents = include
-      }),
-
-    reset: () => set(() => createInitialState(false)),
-  })),
-)

package/cli/src/state/review-store.ts

@@ -1,24 +0,0 @@
-import { create } from 'zustand'
-import { immer } from 'zustand/middleware/immer'
-
-interface ReviewState {
-  reviewMode: boolean
-  openReviewScreen: () => void
-  closeReviewScreen: () => void
-}
-
-export const useReviewStore = create<ReviewState>()(
-  immer((set) => ({
-    reviewMode: false,
-    openReviewScreen: () => {
-      set((state) => {
-        state.reviewMode = true
-      })
-    },
-    closeReviewScreen: () => {
-      set((state) => {
-        state.reviewMode = false
-      })
-    },
-  })),
-)

package/cli/src/state/rewind-picker-store.ts

@@ -1,74 +0,0 @@
-import { create } from 'zustand'
-
-import type { TurnSummary } from '@savant-code/sdk'
-
-/** FID-2026-0803-004 rewind modes. */
-export type RewindMode = 'code' | 'conversation' | 'both' | 'fork'
-
-export const REWIND_MODES: ReadonlyArray<{ id: RewindMode; label: string }> = [
-  { id: 'code', label: 'Code only' },
-  { id: 'conversation', label: 'Conversation only' },
-  { id: 'both', label: 'Code + conversation' },
-  { id: 'fork', label: 'Fork from here' },
-]
-
-/**
- * Drives the interactive /rewind picker overlay (FID-2026-0803-004).
- *
- * Two-stage flow, mirroring the model/provider pickers:
- *   - stage 'choose': list persisted turn checkpoints (prompt · time · touched
- *     files). Arrow keys navigate, Enter selects a turn, Esc closes.
- *   - stage 'mode': choose the restore mode (code / conversation / both /
- *     fork) for the selected turn. Enter confirms, Esc goes back.
- *
- * The chat screen renders the overlay and runs the restore on confirm; this
- * store stays side-effect free.
- */
-interface RewindPickerStore {
-  isOpen: boolean
-  turns: TurnSummary[]
-  selectedIndex: number
-  stage: 'choose' | 'mode'
-  mode: RewindMode
-  open: (turns: TurnSummary[]) => void
-  close: () => void
-  setSelectedIndex: (index: number) => void
-  setStage: (stage: 'choose' | 'mode') => void
-  setMode: (mode: RewindMode) => void
-}
-
-export const useRewindPickerStore = create<RewindPickerStore>((set) => ({
-  isOpen: false,
-  turns: [],
-  selectedIndex: 0,
-  stage: 'choose',
-  mode: 'both',
-  open: (turns) =>
-    set({
-      isOpen: true,
-      turns,
-      selectedIndex: 0,
-      stage: 'choose',
-      mode: 'both',
-    }),
-  close: () =>
-    set({
-      isOpen: false,
-      turns: [],
-      selectedIndex: 0,
-      stage: 'choose',
-      mode: 'both',
-    }),
-  setSelectedIndex: (index) => set({ selectedIndex: index }),
-  setStage: (stage) => set({ stage, selectedIndex: 0 }),
-  setMode: (mode) => set({ mode }),
-}))
-
-/** Imperative read for non-React callers (commands). */
-export const openRewindPicker = (turns: TurnSummary[]): void => {
-  useRewindPickerStore.getState().open(turns)
-}
-
-export const closeRewindPicker = (): void => {
-  useRewindPickerStore.getState().close()
-}

package/cli/src/state/savant-free-model-store.ts

@@ -1,59 +0,0 @@
-import {
-  DEFAULT_SAVANT_FREE_MODEL_ID,
-  resolveAvailableSavantFreeModel,
-} from '@savant-code/common/constants/savant-free-models'
-import { create } from 'zustand'
-
-import { IS_SAVANT_FREE } from '../utils/constants'
-import {
-  loadSavantFreeModelPreference,
-  saveSavantFreeModelPreference,
-} from '../utils/settings'
-
-/**
- * Single source of truth for the active model.
- *
- * All model changes MUST go through `switchModel()` — it updates both the
- * in-memory store AND the persisted settings file atomically.
- *
- * Callers:
- *  - GUI model picker (`startSavantFreeSession`)
- *  - `/model <id>` command
- *  - Server-driven auto-flips (model_locked, takeover) — in-memory only via
- *    `setSelectedModel` to avoid overwriting user preference
- *
- * The sidebar, API calls, and billing all read from this store via
- * `getSelectedSavantFreeModel()`. No other store holds the model.
- */
-interface SavantFreeModelStore {
-  selectedModel: string
-  /** In-memory only — used by server-driven auto-flips that should NOT persist. */
-  setSelectedModel: (model: string) => void
-  /** Unified: updates store + persists to settings. All user-initiated model changes go here. */
-  switchModel: (model: string) => void
-}
-
-export const useSavantFreeModelStore = create<SavantFreeModelStore>((set) => ({
-  selectedModel: (() => {
-    const saved = loadSavantFreeModelPreference()
-    if (saved) {
-      // In paid mode, trust the user's raw model ID (e.g. "opencode-go/mimo-v2.5")
-      // directly. resolveAvailableSavantFreeModel() only recognizes free-tier
-      // model IDs and would strip paid models to a fallback, silently switching
-      // the user to an unintended (and potentially expensive) model.
-      return IS_SAVANT_FREE ? resolveAvailableSavantFreeModel(saved) : saved
-    }
-    return DEFAULT_SAVANT_FREE_MODEL_ID
-  })(),
-  setSelectedModel: (model) => set({ selectedModel: model }),
-  switchModel: (model) => {
-    set({ selectedModel: model })
-    saveSavantFreeModelPreference(model)
-  },
-}))
-
-/** Imperative read for non-React callers (the session hook's tick loop and
- *  the chat-completions metadata builder). */
-export function getSelectedSavantFreeModel(): string {
-  return useSavantFreeModelStore.getState().selectedModel
-}

package/cli/src/state/savant-free-session-store.ts

@@ -1,32 +0,0 @@
-import { create } from 'zustand'
-
-import type { SavantFreeSession } from '../types/savant-free-session'
-
-/**
- * Shared state for the savant-free free session.
- *
- * The hook in `use-savant-free-session.ts` owns the poll loop and writes into
- * this store; React components subscribe via selectors, and non-React code
- * reads via `useSavantFreeSessionStore.getState()`.
- *
- * Imperative session controls (force re-POST, mark superseded/ended) live on
- * the module exports of `use-savant-free-session.ts` rather than on this store —
- * that way callers don't need to null-check a "driver" slot whose lifetime
- * is tied to the React tree.
- */
-interface SavantFreeSessionStore {
-  session: SavantFreeSession | null
-  error: string | null
-
-  setSession: (session: SavantFreeSession | null) => void
-  setError: (error: string | null) => void
-}
-
-export const useSavantFreeSessionStore = create<SavantFreeSessionStore>(
-  (set) => ({
-    session: null,
-    error: null,
-    setSession: (session) => set({ session }),
-    setError: (error) => set({ error }),
-  }),
-)

package/cli/src/test-setup.ts

@@ -1,20 +0,0 @@
-import { beforeEach } from 'bun:test'
-
-/**
- * Global test setup for the CLI workspace.
- *
- * The repository's local dev environment often has `DIRECT_PROVIDER` and/or
- * `INFERENCE_BASE_URL` set so the app boots in direct-provider mode. Most unit
- * tests, however, exercise the SavantCode API client against a mocked backend
- * and expect backend-mode behavior. This setup clears those variables before
- * every test so that `isDirectProviderMode()` and the SDK's dev-mode bypass
- * return false by default.
- *
- * Tests that specifically want to verify direct-provider behavior can still
- * set these variables in their own `beforeEach`, which runs after this global
- * setup.
- */
-beforeEach(() => {
-  process.env.DIRECT_PROVIDER = ''
-  process.env.INFERENCE_BASE_URL = ''
-})

package/cli/src/testing/env.ts

@@ -1,46 +0,0 @@
-import { createTestBaseEnv } from '@savant-code/common/testing-env-process'
-
-import type { CliEnv } from '../types/env'
-
-/**
- * Test-only CLI env builder.
- */
-export const createTestCliEnv = (overrides: Partial<CliEnv> = {}): CliEnv => ({
-  ...createTestBaseEnv(),
-
-  // CLI-specific defaults
-  SSH_CLIENT: undefined,
-  SSH_TTY: undefined,
-  SSH_CONNECTION: undefined,
-  KITTY_WINDOW_ID: undefined,
-  SIXEL_SUPPORT: undefined,
-  ZED_NODE_ENV: undefined,
-  ZED_TERM: undefined,
-  ZED_SHELL: undefined,
-  COLORTERM: undefined,
-  VSCODE_THEME_KIND: undefined,
-  VSCODE_COLOR_THEME_KIND: undefined,
-  VSCODE_GIT_IPC_HANDLE: undefined,
-  VSCODE_PID: undefined,
-  VSCODE_CWD: undefined,
-  VSCODE_NLS_CONFIG: undefined,
-  CURSOR_PORT: undefined,
-  CURSOR: undefined,
-  JETBRAINS_REMOTE_RUN: undefined,
-  IDEA_INITIAL_DIRECTORY: undefined,
-  IDE_CONFIG_DIR: undefined,
-  JB_IDE_CONFIG_DIR: undefined,
-  VISUAL: undefined,
-  EDITOR: undefined,
-  SAVANT_CODE_CLI_EDITOR: undefined,
-  SAVANT_CODE_EDITOR: undefined,
-  OPEN_TUI_THEME: undefined,
-  OPENTUI_THEME: undefined,
-  SAVANT_CODE_IS_BINARY: undefined,
-  SAVANT_CODE_CLI_VERSION: undefined,
-  SAVANT_CODE_CLI_TARGET: undefined,
-  SAVANT_CODE_RG_PATH: undefined,
-  SAVANT_CODE_SCROLL_MULTIPLIER: undefined,
-  SAVANT_FREE_MODE: undefined,
-  ...overrides,
-})

package/cli/src/types/chat-state.ts

@@ -1,15 +0,0 @@
-/**
- * Type definitions for chat state management.
- * Re-exports types from the extracted hooks for convenience.
- */
-
-// Re-export types from the extracted hooks
-export type { ChatStateRefs, UseChatStateReturn } from '../hooks/use-chat-state'
-
-export type {
-  UseChatMessagesOptions,
-  UseChatMessagesReturn,
-} from '../hooks/use-chat-messages'
-
-// Re-export StreamStatus from use-message-queue for convenience
-export type { StreamStatus } from '../hooks/use-message-queue'

package/cli/src/types/chat.ts

@@ -1,242 +0,0 @@
-import type { ChatTheme } from './theme-system'
-import type { JSONValue } from '@savant-code/common/types/json'
-import type { ToolName } from '@savant-code/sdk'
-import type { ReactNode } from 'react'
-
-/**
- * isCollapsed/userOpened are duplicated across block types intentionally - each UI
- * element tracks collapse state independently for different defaults and to persist
- * user intent vs programmatic state.
- */
-
-export type ChatVariant = 'ai' | 'user' | 'agent' | 'error'
-
-export type ThinkingCollapseState = 'expanded' | 'preview' | 'hidden'
-
-export type TextContentBlock = {
-  type: 'text'
-  content: string
-  color?: string
-  marginTop?: number
-  marginBottom?: number
-  status?: 'running' | 'complete'
-  textType?: 'reasoning' | 'text'
-  isCollapsed?: boolean
-  thinkingId?: string
-  userOpened?: boolean
-  /** True if this is a reasoning block from a <think> tag that hasn't been closed yet */
-  thinkingOpen?: boolean
-  thinkingCollapseState?: ThinkingCollapseState
-}
-/** Renders dynamic React content. NOT serializable - don't use for persistent data. */
-export type HtmlContentBlock = {
-  type: 'html'
-  marginTop?: number
-  marginBottom?: number
-  render: (context: { textColor: string; theme: ChatTheme }) => ReactNode
-}
-export type ToolContentBlock = {
-  type: 'tool'
-  toolCallId: string
-  toolName: ToolName
-  input: Record<string, JSONValue>
-  output?: string
-  outputRaw?: unknown
-  agentId?: string
-  includeToolCall?: boolean
-  isCollapsed?: boolean
-  userOpened?: boolean
-}
-export type AgentContentBlock = {
-  type: 'agent'
-  agentId: string
-  agentName: string
-  agentType: string
-  content: string
-  status: 'running' | 'complete' | 'failed' | 'cancelled'
-  blocks?: ContentBlock[]
-  initialPrompt?: string
-  params?: Record<string, JSONValue>
-  isCollapsed?: boolean
-  userOpened?: boolean
-  /** The spawn_agents tool call ID that created this block, used to match results */
-  spawnToolCallId?: string
-  /** The index within the spawn_agents call, used to match the correct result */
-  spawnIndex?: number
-}
-export type AgentListContentBlock = {
-  type: 'agent-list'
-  id: string
-  agents: Array<{ id: string; displayName: string }>
-  agentsDir: string
-  isCollapsed?: boolean
-  userOpened?: boolean
-}
-export type ModeDividerContentBlock = {
-  type: 'mode-divider'
-  mode: string
-}
-
-export type PlanContentBlock = {
-  type: 'plan'
-  content: string
-}
-
-export type AskUserContentBlock = {
-  type: 'ask-user'
-  toolCallId: string
-  questions: Array<{
-    question: string
-    header?: string
-    options: Array<{
-      label: string
-      description?: string
-    }>
-    multiSelect?: boolean
-    validation?: {
-      maxLength?: number
-      minLength?: number
-      pattern?: string
-      patternError?: string
-    }
-  }>
-  answers?: Array<{
-    questionIndex: number
-    selectedOption?: string
-    selectedOptions?: string[]
-    otherText?: string
-  }>
-  skipped?: boolean
-}
-
-export type ImageContentBlock = {
-  type: 'image'
-  image: string // base64 encoded
-  mediaType: string
-  filename?: string
-  size?: number
-  width?: number
-  height?: number
-  isCollapsed?: boolean
-  userOpened?: boolean
-}
-
-export type ImageAttachment = {
-  filename: string
-  path: string
-  size?: number
-}
-
-export type TextAttachment = {
-  id: string
-  content: string
-  preview: string
-  charCount: number
-}
-
-export type FileAttachment = {
-  path: string
-  filename: string
-  isDirectory: boolean
-  note?: string
-}
-
-export type ContentBlock =
-  | AgentContentBlock
-  | AgentListContentBlock
-  | AskUserContentBlock
-  | HtmlContentBlock
-  | ImageContentBlock
-  | ModeDividerContentBlock
-  | TextContentBlock
-  | ToolContentBlock
-  | PlanContentBlock
-
-export type AgentMessage = {
-  agentName: string
-  agentType: string
-  responseCount: number
-  subAgentCount?: number
-}
-
-export type ChatMessageMetadata = {
-  /** Working directory where a bash command was executed */
-  bashCwd?: string
-  /** UI-only marker for a response created in this process. Restored messages
-   * strip it so ads are never fetched retroactively into settled history. */
-  allowInlineAds?: boolean
-  /** Whether this message/agent is collapsed in the UI */
-  isCollapsed?: boolean
-  /** Whether the user manually opened this collapsed item */
-  userOpened?: boolean
-  /** RunState stored after completion */
-  runState?: unknown
-}
-
-export type ChatMessage = {
-  id: string
-  variant: ChatVariant
-  content: string
-  blocks?: ContentBlock[]
-  timestamp: string
-  parentId?: string
-  agent?: AgentMessage
-  isCompletion?: boolean
-  credits?: number
-  completionTime?: string
-  isComplete?: boolean
-  metadata?: ChatMessageMetadata
-  validationErrors?: Array<{ id: string; message: string }>
-  /**
-   * UI-only runtime error displayed in UserErrorBanner (not sent to LLM).
-   * Set by setError() when an error occurs during message streaming.
-   * Can be cleared by clearUserError() when starting a new successful interaction.
-   */
-  userError?: string
-  attachments?: ImageAttachment[]
-  textAttachments?: TextAttachment[]
-  fileAttachments?: FileAttachment[]
-}
-
-// Type guard functions for safe type narrowing
-export function isTextBlock(block: ContentBlock): block is TextContentBlock {
-  return block.type === 'text'
-}
-
-export function isToolBlock(block: ContentBlock): block is ToolContentBlock {
-  return block.type === 'tool'
-}
-
-export function isAgentBlock(block: ContentBlock): block is AgentContentBlock {
-  return block.type === 'agent'
-}
-
-export function isHtmlBlock(block: ContentBlock): block is HtmlContentBlock {
-  return block.type === 'html'
-}
-
-export function isAgentListBlock(
-  block: ContentBlock,
-): block is AgentListContentBlock {
-  return block.type === 'agent-list'
-}
-
-export function isPlanBlock(block: ContentBlock): block is PlanContentBlock {
-  return block.type === 'plan'
-}
-
-export function isModeDividerBlock(
-  block: ContentBlock,
-): block is ModeDividerContentBlock {
-  return block.type === 'mode-divider'
-}
-
-export function isAskUserBlock(
-  block: ContentBlock,
-): block is AskUserContentBlock {
-  return block.type === 'ask-user'
-}
-
-export function isImageBlock(block: ContentBlock): block is ImageContentBlock {
-  return block.type === 'image'
-}

package/cli/src/types/contracts/send-message.ts

@@ -1,16 +0,0 @@
-import type { AgentMode } from '../../utils/constants'
-import type { ChatMessage } from '../chat'
-import type { PendingAttachment } from '../store'
-
-export type PostUserMessageFn = (prev: ChatMessage[]) => ChatMessage[]
-
-export type SendMessageOutcome = 'success' | 'failure'
-
-export type SendMessageFn = (params: {
-  content: string
-  agentMode: AgentMode
-  postUserMessage?: PostUserMessageFn
-  attachments?: PendingAttachment[]
-  /** Optional observer used by recurring jobs to distinguish handled errors. */
-  onRunOutcome?: (outcome: SendMessageOutcome) => void
-}) => Promise<void>