savant-code 0.0.17 → 0.0.19

package/cli/src/commands/__tests__/new-command-rotates-chat.test.ts

@@ -0,0 +1,87 @@
+import { describe, expect, test } from 'bun:test'
+
+describe('/new command', () => {
+  test('rotates the chat id so the previous chat is not overwritten', () => {
+    const commandRegistryUrl = new URL(
+      '../command-registry.ts',
+      import.meta.url,
+    ).href
+    const projectFilesUrl = new URL('../../project-files.ts', import.meta.url)
+      .href
+    const activeRunUrl = new URL('../../utils/active-run.ts', import.meta.url)
+      .href
+
+    const result = Bun.spawnSync({
+      cmd: [
+        'bun',
+        '--eval',
+        `
+          import { findCommand } from ${JSON.stringify(commandRegistryUrl)}
+          import { getCurrentChatId, setCurrentChatId } from ${JSON.stringify(projectFilesUrl)}
+          import { setActiveRunAborter } from ${JSON.stringify(activeRunUrl)}
+
+          setCurrentChatId('previous-chat-id')
+
+          // Simulate an in-flight run: record which chat was current when the
+          // abort fired.
+          let abortedAtChatId = null
+          setActiveRunAborter('run-1', () => {
+            abortedAtChatId = getCurrentChatId()
+          })
+
+          const newCommand = findCommand('new')
+          if (!newCommand) throw new Error('new command missing')
+
+          const noop = () => {}
+          newCommand.handler(
+            {
+              setMessages: noop,
+              clearMessages: noop,
+              saveToHistory: noop,
+              inputValue: '/new',
+              setInputValue: noop,
+              stopStreaming: noop,
+              setCanProcessQueue: noop,
+            },
+            '',
+          )
+
+          if (getCurrentChatId() === 'previous-chat-id') {
+            throw new Error(
+              '/new did not rotate the chat id — the next save would overwrite the previous chat',
+            )
+          }
+
+          if (abortedAtChatId === null) {
+            throw new Error(
+              '/new did not abort the in-flight run — an orphaned run would keep checkpointing across the chat switch',
+            )
+          }
+          if (abortedAtChatId !== 'previous-chat-id') {
+            throw new Error(
+              '/new aborted the run only after rotating the chat id — late writes could land in the new chat',
+            )
+          }
+        `,
+      ],
+      cwd: process.cwd(),
+      env: {
+        ...process.env,
+        NODE_ENV: 'test',
+        NEXT_PUBLIC_CB_ENVIRONMENT: 'test',
+        NEXT_PUBLIC_SAVANT_CODE_APP_URL: 'https://app.savant-code.test',
+        NEXT_PUBLIC_SUPPORT_EMAIL: 'support@savant-code.test',
+        NEXT_PUBLIC_POSTHOG_API_KEY: 'phc_test_key',
+        NEXT_PUBLIC_POSTHOG_HOST_URL: 'https://posthog.savant-code.test',
+        NEXT_PUBLIC_STRIPE_PUBLISHABLE_KEY: 'pk_test_123',
+        NEXT_PUBLIC_STRIPE_CUSTOMER_PORTAL: 'https://stripe.savant-code.test',
+        NEXT_PUBLIC_WEB_PORT: '3000',
+      },
+      stderr: 'pipe',
+      stdout: 'pipe',
+    })
+
+    const stderr = new TextDecoder().decode(result.stderr)
+    expect(result.exitCode, stderr).toBe(0)
+  })
+})

package/cli/src/commands/__tests__/permissions-command.test.ts

@@ -0,0 +1,93 @@
+import { describe, test, expect, mock, beforeEach } from 'bun:test'
+
+import { useChatStore } from '../../state/chat-store'
+import { findCommand } from '../command-registry'
+
+import type { RouterParams } from '../command-registry'
+
+const createMockParams = (
+  overrides: Partial<RouterParams> = {},
+): RouterParams =>
+  ({
+    abortControllerRef: { current: null },
+    agentMode: 'EDIT',
+    inputRef: { current: null },
+    inputValue: '/permissions',
+    isChainInProgressRef: { current: false },
+    isStreaming: false,
+    logoutMutation: {} as RouterParams['logoutMutation'],
+    streamMessageIdRef: { current: null },
+    addToQueue: mock(() => {}),
+    clearMessages: mock(() => {}),
+    saveToHistory: mock(() => {}),
+    scrollToLatest: mock(() => {}),
+    sendMessage: mock(async () => {}),
+    setCanProcessQueue: mock(() => {}),
+    setInputFocused: mock(() => {}),
+    setInputValue: mock(() => {}),
+    setIsAuthenticated: mock(() => {}),
+    setMessages: mock(() => {}),
+    setUser: mock(() => {}),
+    stopStreaming: mock(() => {}),
+    ...overrides,
+  }) as RouterParams
+
+describe('/permissions command', () => {
+  beforeEach(() => {
+    useChatStore.getState().setPermissionMode('prompt')
+  })
+
+  test('command exists in registry', () => {
+    const command = findCommand('permissions')
+    expect(command).toBeDefined()
+    expect(command?.name).toBe('permissions')
+    expect(command?.acceptsArgs).toBe(true)
+  })
+
+  test('aliases resolve to permissions', () => {
+    const sandbox = findCommand('sandbox')
+    const safety = findCommand('safety')
+    expect(sandbox?.name).toBe('permissions')
+    expect(safety?.name).toBe('permissions')
+  })
+
+  test('/permissions with no args shows current mode', () => {
+    const command = findCommand('permissions')
+    const setMessages = mock(() => {})
+    const params = createMockParams({ setMessages })
+
+    command!.handler(params, '')
+
+    expect(setMessages).toHaveBeenCalled()
+    expect(params.saveToHistory).toHaveBeenCalledWith('/permissions')
+  })
+
+  test('/permissions safe sets safe mode', () => {
+    const command = findCommand('permissions')
+    const params = createMockParams()
+
+    command!.handler(params, 'safe')
+
+    expect(useChatStore.getState().permissionMode).toBe('safe')
+  })
+
+  test('/permissions unsafe sets unsafe mode', () => {
+    const command = findCommand('permissions')
+    const params = createMockParams()
+
+    command!.handler(params, 'unsafe')
+
+    expect(useChatStore.getState().permissionMode).toBe('unsafe')
+  })
+
+  test('/permissions unknown prints usage and does not change mode', () => {
+    const command = findCommand('permissions')
+    const setMessages = mock(() => {})
+    const params = createMockParams({ setMessages })
+
+    command!.handler(params, 'banana')
+
+    expect(useChatStore.getState().permissionMode).toBe('prompt')
+    expect(setMessages).toHaveBeenCalled()
+  })
+})

package/cli/src/commands/__tests__/process-diagnostics.test.ts

@@ -0,0 +1,54 @@
+import { describe, expect, test } from 'bun:test'
+
+import {
+  collectProcessDiagnostics,
+  formatProcessDiagnostics,
+} from '../process-diagnostics'
+
+import type { ProcessDiagnosticsSnapshot } from '../process-diagnostics'
+
+const snapshot: ProcessDiagnosticsSnapshot = {
+  product: 'SavantFree',
+  version: '1.2.3',
+  runtime: 'Bun 1.3.14',
+  platform: 'darwin',
+  architecture: 'arm64',
+  uptimeSeconds: 3_661,
+  cpuUserMicros: 1_500_000,
+  cpuSystemMicros: 500_000,
+  memory: {
+    rss: 100 * 1024 * 1024,
+    heapTotal: 50 * 1024 * 1024,
+    heapUsed: 25 * 1024 * 1024,
+    external: 0,
+    arrayBuffers: 0,
+  },
+  parentPid: 100,
+  cliPid: 200,
+  watchdog: { armed: true, external: false, pid: 250 },
+  activeTools: [{ pid: 300, processGroupId: 300 }],
+}
+
+describe('process diagnostics', () => {
+  test('formats owned process IDs without sensitive command data', () => {
+    const output = formatProcessDiagnostics(snapshot)
+
+    expect(output).toContain('### SavantFree process diagnostics')
+    expect(output).toContain('CLI uptime: 01:01:01')
+    expect(output).toContain('parent/wrapper: PID 100')
+    expect(output).toContain('CLI binary: PID 200')
+    expect(output).toContain('terminal watchdog: PID 250')
+    expect(output).toContain('PID 300, PGID 300')
+    expect(output).toContain(
+      'Command lines and environment variables are omitted',
+    )
+  })
+
+  test('collects runtime-local process information', () => {
+    const result = collectProcessDiagnostics()
+
+    expect(result.cliPid).toBe(process.pid)
+    expect(result.parentPid).toBe(process.ppid)
+    expect(result.memory.rss).toBeGreaterThan(0)
+  })
+})

package/cli/src/commands/__tests__/prompt-builders.test.ts

@@ -0,0 +1,69 @@
+import { beforeEach, describe, expect, test } from 'bun:test'
+
+import {
+  buildPlanPrompt,
+  buildReviewPrompt,
+  buildReviewPromptFromArgs,
+} from '../prompt-builders'
+
+// Inject the ChatGPT connection state so we can drive both branches of the
+// connected/not-connected prompt selection deterministically, without
+// mocking the `chatgpt-oauth` module (mock.module() is process-global in
+// Bun and leaks into unrelated test files run later in the same process).
+let connected = false
+const isChatGptConnected = () => connected
+
+describe('prompt-builders ChatGPT-aware base prompts', () => {
+  beforeEach(() => {
+    connected = false
+  })
+
+  describe('when ChatGPT is connected', () => {
+    beforeEach(() => {
+      connected = true
+    })
+
+    test('/plan delegates to @thinker-gpt', () => {
+      expect(buildPlanPrompt('add OAuth login', isChatGptConnected)).toContain(
+        '@thinker-gpt',
+      )
+    })
+
+    test('/review delegates to @thinker-gpt', () => {
+      expect(
+        buildReviewPrompt('uncommitted', undefined, isChatGptConnected),
+      ).toContain('@thinker-gpt')
+      expect(
+        buildReviewPromptFromArgs('the parser', isChatGptConnected),
+      ).toContain('@thinker-gpt')
+    })
+  })
+
+  describe('when ChatGPT is not connected', () => {
+    test('/plan runs on the selected model (no @thinker-gpt spawn)', () => {
+      const prompt = buildPlanPrompt('add OAuth login', isChatGptConnected)
+      expect(prompt).not.toContain('@thinker-gpt')
+      expect(prompt).toContain('add OAuth login')
+    })
+
+    test('/review runs on the selected model (no @thinker-gpt spawn)', () => {
+      expect(
+        buildReviewPrompt('uncommitted', undefined, isChatGptConnected),
+      ).not.toContain('@thinker-gpt')
+      expect(
+        buildReviewPromptFromArgs('the parser', isChatGptConnected),
+      ).not.toContain('@thinker-gpt')
+    })
+  })
+
+  test('user input is preserved regardless of connection state', () => {
+    connected = true
+    expect(buildPlanPrompt('do the thing', isChatGptConnected)).toContain(
+      'do the thing',
+    )
+    connected = false
+    expect(buildPlanPrompt('do the thing', isChatGptConnected)).toContain(
+      'do the thing',
+    )
+  })
+})

package/cli/src/commands/__tests__/registry-gating.test.ts

@@ -0,0 +1,125 @@
+import { describe, expect, it } from 'bun:test'
+
+import {
+  SAVANT_FREE_ONLY_COMMAND_IDS,
+  SAVANT_FREE_REMOVED_COMMAND_IDS,
+  SLASH_COMMANDS,
+} from '../../data/slash-commands'
+import { getProviderSetupGuidance } from '../../utils/provider-setup'
+import {
+  ALL_COMMAND_DEFINITIONS,
+  COMMAND_REGISTRY,
+  SAVANT_FREE_ONLY_COMMAND_NAMES,
+  SAVANT_FREE_REMOVED_COMMAND_NAMES,
+  filterCommandsForBuild,
+  findCommand,
+} from '../command-registry'
+
+/**
+ * FID-2026-0802-007 V4 / U1 / D1 / D2: free-vs-paid gating parity between the
+ * command registry and the slash-command menu, plus the guidance/registry
+ * contract and /dev definition identity.
+ *
+ * The gating split lives in TWO files (command-registry.ts and
+ * data/slash-commands.ts) with independently-maintained removal sets — this
+ * test keeps them in lockstep so a D1-class drift (menu hides a command the
+ * registry still executes, or vice versa) fails CI.
+ */
+describe('registry gating matrix (FID-007)', () => {
+  const freeRegistry = filterCommandsForBuild(ALL_COMMAND_DEFINITIONS, true)
+  const paidRegistry = filterCommandsForBuild(ALL_COMMAND_DEFINITIONS, false)
+
+  it('free and paid registries exclude exactly their gated command sets', () => {
+    const freeNames = new Set(freeRegistry.map((c) => c.name))
+    const paidNames = new Set(paidRegistry.map((c) => c.name))
+
+    // Free build removes ads/usage/subscribe/image/publish.
+    for (const name of SAVANT_FREE_REMOVED_COMMAND_NAMES) {
+      expect(freeNames.has(name)).toBe(false)
+      expect(paidNames.has(name)).toBe(true)
+    }
+    // Paid build removes the free-only commands (connect/plan/end-session).
+    for (const name of SAVANT_FREE_ONLY_COMMAND_NAMES) {
+      expect(paidNames.has(name)).toBe(false)
+      expect(freeNames.has(name)).toBe(true)
+    }
+  })
+
+  it('menu and registry removal sets are in lockstep (D1 drift guard)', () => {
+    // Every command hidden from the free menu must also be excluded from the
+    // free registry (a hidden command must not still execute).
+    for (const id of SAVANT_FREE_REMOVED_COMMAND_IDS) {
+      expect(SAVANT_FREE_REMOVED_COMMAND_NAMES.has(id)).toBe(true)
+    }
+    for (const name of SAVANT_FREE_REMOVED_COMMAND_NAMES) {
+      expect(SAVANT_FREE_REMOVED_COMMAND_IDS.has(name)).toBe(true)
+    }
+    // Same for the free-only sets.
+    for (const id of SAVANT_FREE_ONLY_COMMAND_IDS) {
+      expect(SAVANT_FREE_ONLY_COMMAND_NAMES.has(id)).toBe(true)
+    }
+    for (const name of SAVANT_FREE_ONLY_COMMAND_NAMES) {
+      expect(SAVANT_FREE_ONLY_COMMAND_IDS.has(name)).toBe(true)
+    }
+  })
+
+  it('every slash-menu command resolves in the matching registry (both flavors)', () => {
+    // The test environment is the paid flavor, so SLASH_COMMANDS is the paid
+    // menu. Reconstruct the free menu from the shared sets: paid menu ids +
+    // free-only ids (stripped from the paid menu) - free-removed ids.
+    const paidMenuIds = new Set(SLASH_COMMANDS.map((cmd) => cmd.id))
+    const freeMenuIds = new Set([
+      ...paidMenuIds,
+      ...SAVANT_FREE_ONLY_COMMAND_IDS,
+    ])
+    for (const id of SAVANT_FREE_REMOVED_COMMAND_IDS) {
+      freeMenuIds.delete(id)
+    }
+
+    const allNames = new Set(ALL_COMMAND_DEFINITIONS.map((cmd) => cmd.name))
+    const freeRegistryNames = new Set(freeRegistry.map((cmd) => cmd.name))
+
+    for (const id of paidMenuIds) {
+      expect(findCommand(id), `paid menu ${id} should resolve`).toBeDefined()
+    }
+    for (const id of freeMenuIds) {
+      // Only ids that correspond to an actual command definition (e.g.
+      // connect is CHATGPT_OAUTH-gated) must resolve in the free registry.
+      if (allNames.has(id)) {
+        expect(
+          freeRegistryNames.has(id),
+          `free menu ${id} should resolve in the free registry`,
+        ).toBe(true)
+      }
+    }
+    // And every registry command name is discoverable via the menu or is a
+    // known hidden command (/dev, skill: prefix).
+    for (const cmd of COMMAND_REGISTRY) {
+      const inMenu = SLASH_COMMANDS.some((m) => m.id === cmd.name)
+      const hidden = cmd.name === 'dev' || cmd.name.startsWith('skill:')
+      expect(
+        inMenu || hidden,
+        `registry ${cmd.name} should be discoverable`,
+      ).toBe(true)
+    }
+  })
+
+  it('U1 guard: guidance references only commands registered in the build that shows it', () => {
+    // getProviderSetupGuidance tells users to run /provider — that command is
+    // registered in the paid build (where the guidance is shown after FID-007).
+    const guidance = getProviderSetupGuidance({
+      provider: 'opencode-go',
+      envVar: 'OPENCODE_GO_API_KEY',
+      label: 'OpenCode Go',
+      baseUrl: 'https://opencode.ai/zen/go/v1',
+    })
+    expect(guidance).toContain('/provider')
+    expect(findCommand('provider')).toBeDefined()
+    expect(findCommand('model')).toBeDefined()
+  })
+
+  it('D2: findCommand returns a stable /dev definition identity', () => {
+    expect(findCommand('dev')).toBe(findCommand('dev'))
+    expect(findCommand('/dev')).toBe(findCommand('/dev'))
+  })
+})

package/cli/src/commands/__tests__/rewind-command.test.ts

@@ -0,0 +1,227 @@
+import * as fs from 'node:fs'
+import * as os from 'node:os'
+import * as path from 'node:path'
+
+import {
+  openTurn,
+  captureSnapshot,
+  closeTurn,
+  getTurn,
+  listTurns,
+} from '@savant-code/sdk'
+import { afterEach, beforeEach, describe, expect, test } from 'bun:test'
+
+import { useChatStore } from '../../state/chat-store'
+import {
+  executeRewind,
+  resolveTurnArg,
+  truncateRunStateToHistoryLength,
+} from '../../utils/rewind'
+import { setChatDirOverrideForTesting } from '../../utils/run-state-storage'
+
+import type { ChatMessage } from '../../types/chat'
+import type { RunState } from '@savant-code/sdk'
+
+let tmpDir: string
+
+beforeEach(() => {
+  tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'rewind-cli-'))
+  setChatDirOverrideForTesting(tmpDir)
+  useChatStore.getState().reset()
+})
+
+afterEach(() => {
+  setChatDirOverrideForTesting(undefined)
+  fs.rmSync(tmpDir, { recursive: true, force: true })
+})
+
+const checkpointDir = () => path.join(tmpDir, 'checkpoints')
+
+function write(p: string, content: string): void {
+  fs.mkdirSync(path.dirname(p), { recursive: true })
+  fs.writeFileSync(p, content, 'utf8')
+}
+
+/** Seeds a checkpoint for turnId with one modified file. */
+function seedTurn(turnId: string, fileName: string): void {
+  const file = path.join(tmpDir, fileName)
+  write(file, 'original')
+  openTurn({
+    checkpointDir: checkpointDir(),
+    turnId,
+    prompt: `prompt ${turnId}`,
+  })
+  captureSnapshot({ checkpointDir: checkpointDir(), turnId, filePath: file })
+  write(file, 'edited')
+  closeTurn({
+    checkpointDir: checkpointDir(),
+    turnId,
+    prompt: `prompt ${turnId}`,
+  })
+}
+
+describe('resolveTurnArg', () => {
+  const turns = [
+    {
+      turnId: 'aaa',
+      startedAt: 3,
+      endedAt: 3,
+      prompt: 'newest',
+      fileCount: 1,
+      paths: ['x.ts'],
+    },
+    {
+      turnId: 'bbb',
+      startedAt: 2,
+      endedAt: 2,
+      prompt: 'older',
+      fileCount: 1,
+      paths: ['y.ts'],
+    },
+  ]
+
+  test('resolves a 1-based index into newest-first order', () => {
+    expect(resolveTurnArg(turns, '1')?.turnId).toBe('aaa')
+    expect(resolveTurnArg(turns, '2')?.turnId).toBe('bbb')
+  })
+
+  test('resolves a full turnId', () => {
+    expect(resolveTurnArg(turns, 'bbb')?.turnId).toBe('bbb')
+  })
+
+  test('returns undefined for out-of-range index or unknown id', () => {
+    expect(resolveTurnArg(turns, '3')).toBeUndefined()
+    expect(resolveTurnArg(turns, 'zzz')).toBeUndefined()
+    expect(resolveTurnArg(turns, undefined)).toBeUndefined()
+  })
+})
+
+describe('truncateRunStateToHistoryLength', () => {
+  test('truncates messageHistory to the checkpoint boundary', () => {
+    const runState = {
+      output: { type: 'success' as const, message: '' },
+      sessionState: {
+        fileContext: {},
+        mainAgentState: {
+          messageHistory: [
+            { role: 'user', content: 'a' },
+            { role: 'assistant', content: 'b' },
+            { role: 'user', content: 'c' },
+          ],
+        },
+      },
+    } as unknown as RunState
+
+    const truncated = truncateRunStateToHistoryLength(runState, 1)
+    expect(
+      (
+        truncated!.sessionState!.mainAgentState as unknown as {
+          messageHistory: Array<{ role: string }>
+        }
+      ).messageHistory.map((m) => m.role),
+    ).toEqual(['user'])
+  })
+
+  test('returns the state unchanged when history is already short enough', () => {
+    const runState = {
+      sessionState: {
+        mainAgentState: {
+          messageHistory: [{ role: 'user', content: 'a' }],
+        },
+      },
+    } as unknown as RunState
+    expect(truncateRunStateToHistoryLength(runState, 5)).toBe(runState)
+  })
+
+  test('returns null input untouched', () => {
+    expect(truncateRunStateToHistoryLength(null, 5)).toBeNull()
+  })
+})
+
+describe('executeRewind', () => {
+  const setMessages: (
+    value: ChatMessage[] | ((prev: ChatMessage[]) => ChatMessage[]),
+  ) => void = (value) => {
+    useChatStore.getState().setMessages(value)
+  }
+
+  test('code mode restores files to pre-edit content', () => {
+    seedTurn('t1', 'a.ts')
+    const file = path.join(tmpDir, 'a.ts')
+    expect(fs.readFileSync(file, 'utf8')).toBe('edited')
+
+    const message = executeRewind({
+      checkpointDir: checkpointDir(),
+      projectRoot: tmpDir,
+      turnId: 't1',
+      mode: 'code',
+      setMessages,
+    })
+    expect(fs.readFileSync(file, 'utf8')).toBe('original')
+    expect(message).toContain('Rewound 1 file')
+  })
+
+  test('conversation mode truncates the transcript to the turn boundary', () => {
+    // Seed a checkpoint recording a 2-message boundary at turn start.
+    const file = path.join(tmpDir, 'a.ts')
+    write(file, 'original')
+    openTurn({
+      checkpointDir: checkpointDir(),
+      turnId: 't1',
+      prompt: 'p',
+      messageCount: 2,
+      historyLength: 1,
+    })
+    captureSnapshot({
+      checkpointDir: checkpointDir(),
+      turnId: 't1',
+      filePath: file,
+    })
+    write(file, 'edited')
+    closeTurn({
+      checkpointDir: checkpointDir(),
+      turnId: 't1',
+      prompt: 'p',
+      messageCount: 2,
+      historyLength: 1,
+    })
+
+    // Store has more messages than the boundary.
+    useChatStore
+      .getState()
+      .setMessages([
+        { id: 'm1', role: 'user', content: 'one' } as never,
+        { id: 'm2', role: 'assistant', content: 'two' } as never,
+        { id: 'm3', role: 'user', content: 'three' } as never,
+      ])
+
+    executeRewind({
+      checkpointDir: checkpointDir(),
+      projectRoot: tmpDir,
+      turnId: 't1',
+      mode: 'conversation',
+      setMessages,
+    })
+
+    expect(useChatStore.getState().messages.length).toBe(2)
+  })
+
+  test('unknown turn returns a warning message', () => {
+    const message = executeRewind({
+      checkpointDir: checkpointDir(),
+      projectRoot: tmpDir,
+      turnId: 'nope',
+      mode: 'code',
+      setMessages,
+    })
+    expect(message).toContain('No checkpoint found')
+  })
+
+  test('listTurns sees the persisted checkpoint after close', () => {
+    seedTurn('t1', 'a.ts')
+    const turns = listTurns(checkpointDir())
+    expect(turns.length).toBe(1)
+    expect(turns[0].prompt).toBe('prompt t1')
+    expect(getTurn(checkpointDir(), 't1')).not.toBeNull()
+  })
+})