@alumbwe/anvil 1.0.0

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

@@ -0,0 +1,91 @@
+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 { registerActiveRun } 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
+          let stopReason = null
+          registerActiveRun('run-1', (reason) => {
+            abortedAtChatId = getCurrentChatId()
+            stopReason = reason
+          })
+
+          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,
+              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',
+            )
+          }
+          if (stopReason !== 'new-chat') {
+            throw new Error('/new did not use the new-chat cancellation policy')
+          }
+        `,
+      ],
+      cwd: process.cwd(),
+      env: {
+        ...process.env,
+        NODE_ENV: 'test',
+        NEXT_PUBLIC_CB_ENVIRONMENT: 'test',
+        NEXT_PUBLIC_ANVIL_APP_URL: 'https://app.codebuff.test',
+        NEXT_PUBLIC_SUPPORT_EMAIL: 'support@codebuff.test',
+        NEXT_PUBLIC_POSTHOG_API_KEY: 'phc_test_key',
+        NEXT_PUBLIC_POSTHOG_HOST_URL: 'https://posthog.codebuff.test',
+        NEXT_PUBLIC_STRIPE_PUBLISHABLE_KEY: 'pk_test_123',
+        NEXT_PUBLIC_STRIPE_CUSTOMER_PORTAL: 'https://stripe.codebuff.test',
+        NEXT_PUBLIC_WEB_PORT: '3000',
+      },
+      stderr: 'pipe',
+      stdout: 'pipe',
+    })
+
+    const stderr = new TextDecoder().decode(result.stderr)
+    expect(result.exitCode, stderr).toBe(0)
+  })
+})

package/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: 'Freebuff',
+  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('### Freebuff 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/src/commands/__tests__/prompt-builders.test.ts

@@ -0,0 +1,28 @@
+import { describe, expect, test } from 'bun:test'
+
+import {
+  buildPlanPrompt,
+  buildReviewPrompt,
+  buildReviewPromptFromArgs,
+} from '../prompt-builders'
+
+describe('prompt-builders base prompts', () => {
+  // These used to branch on whether the user had connected a ChatGPT account,
+  // delegating the deep-thinking step to @thinker-gpt if so. That integration
+  // is gone, so there is one branch: the user's selected model does the work.
+  test('/plan runs on the selected model', () => {
+    const prompt = buildPlanPrompt('add OAuth login')
+    expect(prompt).not.toContain('@thinker-gpt')
+    expect(prompt).toContain('think carefully about how to implement')
+    expect(prompt).toContain('add OAuth login')
+  })
+
+  test('/review runs on the selected model', () => {
+    expect(buildReviewPrompt('uncommitted')).not.toContain('@thinker-gpt')
+    expect(buildReviewPrompt('uncommitted')).toContain('carefully review')
+    expect(buildReviewPromptFromArgs('the parser')).not.toContain(
+      '@thinker-gpt',
+    )
+    expect(buildReviewPromptFromArgs('the parser')).toContain('the parser')
+  })
+})

package/src/commands/__tests__/router-input.test.ts

@@ -0,0 +1,298 @@
+import { describe, test, expect } from 'bun:test'
+
+import { SLASH_COMMANDS } from '../../data/slash-commands'
+import { findCommand, COMMAND_REGISTRY } from '../command-registry'
+import {
+  parseCommand,
+  isSlashCommand,
+  parseCommandInput,
+} from '../router-utils'
+
+describe('router-utils', () => {
+  describe('isSlashCommand', () => {
+    test('returns true for input starting with /', () => {
+      expect(isSlashCommand('/help')).toBe(true)
+      expect(isSlashCommand('/logout')).toBe(true)
+      expect(isSlashCommand('/ref-abc123')).toBe(true)
+      expect(isSlashCommand('/')).toBe(true)
+    })
+
+    test('returns false for input not starting with /', () => {
+      expect(isSlashCommand('help')).toBe(false)
+      expect(isSlashCommand('logout')).toBe(false)
+      expect(isSlashCommand('ref-abc123')).toBe(false)
+      expect(isSlashCommand('')).toBe(false)
+    })
+
+    test('handles whitespace correctly', () => {
+      expect(isSlashCommand('  /help')).toBe(true)
+      expect(isSlashCommand('  help')).toBe(false)
+    })
+  })
+
+  describe('parseCommand', () => {
+    test('extracts command from slashed input', () => {
+      expect(parseCommand('/help')).toBe('help')
+      expect(parseCommand('/logout')).toBe('logout')
+      expect(parseCommand('/usage')).toBe('usage')
+    })
+
+    test('returns empty string for unslashed input (not a slash command)', () => {
+      expect(parseCommand('help')).toBe('')
+      expect(parseCommand('logout')).toBe('')
+      expect(parseCommand('usage')).toBe('')
+      expect(parseCommand('login to my database')).toBe('')
+    })
+
+    test('extracts first word as command when there are arguments', () => {
+      expect(parseCommand('/help me')).toBe('help')
+      expect(parseCommand('/usage stats')).toBe('usage')
+    })
+
+    test('converts command to lowercase', () => {
+      expect(parseCommand('/HELP')).toBe('help')
+      expect(parseCommand('/LOGOUT')).toBe('logout')
+      expect(parseCommand('/UsAgE')).toBe('usage')
+    })
+
+    test('handles empty string', () => {
+      expect(parseCommand('')).toBe('')
+    })
+
+    test('handles whitespace-only input', () => {
+      expect(parseCommand('   ')).toBe('')
+    })
+
+    test('handles only slash', () => {
+      expect(parseCommand('/')).toBe('')
+    })
+
+    test('handles multiple spaces between words', () => {
+      expect(parseCommand('/help   me')).toBe('help')
+    })
+  })
+
+  describe('parseCommandInput', () => {
+    test('returns command info for exact slashless matches', () => {
+      expect(parseCommandInput('init')).toEqual({
+        command: 'init',
+        args: '',
+        implicitCommand: true,
+      })
+      expect(parseCommandInput('new')).toEqual({
+        command: 'new',
+        args: '',
+        implicitCommand: true,
+      })
+    })
+
+    test('is case-insensitive and trims whitespace for slashless matches', () => {
+      expect(parseCommandInput('INIT')).toEqual({
+        command: 'init',
+        args: '',
+        implicitCommand: true,
+      })
+      expect(parseCommandInput('  new  ')).toEqual({
+        command: 'new',
+        args: '',
+        implicitCommand: true,
+      })
+    })
+
+    test('returns null for slashless commands with arguments', () => {
+      expect(parseCommandInput('init something')).toBe(null)
+      expect(parseCommandInput('new my message')).toBe(null)
+    })
+
+    test('returns null for commands not configured for slashless invocation', () => {
+      expect(parseCommandInput('usage')).toBe(null)
+      expect(parseCommandInput('bash')).toBe(null)
+      expect(parseCommandInput('feedback')).toBe(null)
+    })
+
+    test('distinguishes slashed and slashless invocation', () => {
+      expect(parseCommandInput('/init')).toEqual({
+        command: 'init',
+        args: '',
+        implicitCommand: false,
+      })
+    })
+
+    test('does not match aliases for slashless commands', () => {
+      const newCmd = SLASH_COMMANDS.find((cmd) => cmd.id === 'new')
+      for (const alias of newCmd?.aliases ?? []) {
+        expect(parseCommandInput(alias)).toBe(null)
+      }
+    })
+
+    test('returns null for empty input', () => {
+      expect(parseCommandInput('')).toBe(null)
+      expect(parseCommandInput('   ')).toBe(null)
+    })
+
+    test('commands with implicitCommand are configured correctly', () => {
+      const initCmd = SLASH_COMMANDS.find((cmd) => cmd.id === 'init')
+      const newCmd = SLASH_COMMANDS.find((cmd) => cmd.id === 'new')
+
+      expect(initCmd?.implicitCommand).toBe(true)
+      expect(newCmd?.implicitCommand).toBe(true)
+    })
+
+    test('parseCommandInput matches all implicitCommand commands', () => {
+      const implicitCommands = SLASH_COMMANDS.filter((cmd) => cmd.implicitCommand)
+      for (const cmd of implicitCommands) {
+        expect(parseCommandInput(cmd.id)).toEqual({
+          command: cmd.id.toLowerCase(),
+          args: '',
+          implicitCommand: true,
+        })
+      }
+    })
+  })
+
+  describe('slash commands only work with / prefix', () => {
+    const slashCommands = [
+      'login',
+      'logout',
+      'usage',
+      'credits',
+      'exit',
+      'clear',
+      'new',
+      'init',
+      'bash',
+      'feedback',
+    ]
+
+    for (const cmd of slashCommands) {
+      test(`"/${cmd}" is recognized as slash command`, () => {
+        expect(parseCommand(`/${cmd}`)).toBe(cmd)
+      })
+
+      test(`"${cmd}" without slash is NOT a slash command (sent to agent)`, () => {
+        expect(parseCommand(cmd)).toBe('')
+      })
+    }
+  })
+
+  describe('words that look like commands but are not', () => {
+    const nonCommands = [
+      'login to my account',
+      'I need help with logout functionality',
+      'please help me',
+      'usage of this function',
+      'clear the database',
+    ]
+
+    for (const input of nonCommands) {
+      test(`"${input}" is NOT a slash command`, () => {
+        expect(parseCommand(input)).toBe('')
+      })
+    }
+  })
+
+})
+
+describe('command-registry', () => {
+  describe('findCommand', () => {
+    test('finds command by name', () => {
+      const login = findCommand('login')
+      expect(login).toBeDefined()
+      expect(login?.name).toBe('login')
+
+      const usage = findCommand('usage')
+      expect(usage).toBeDefined()
+      expect(usage?.name).toBe('usage')
+    })
+
+    test('finds command by alias', () => {
+      const credits = findCommand('credits')
+      expect(credits).toBeDefined()
+      expect(credits?.name).toBe('usage')
+
+      const modelDefault = findCommand('model:default')
+      expect(modelDefault).toBeDefined()
+      expect(modelDefault?.name).toBe('mode:default')
+
+      const quit = findCommand('quit')
+      expect(quit).toBeDefined()
+      expect(quit?.name).toBe('exit')
+
+      const signin = findCommand('signin')
+      expect(signin).toBeDefined()
+      expect(signin?.name).toBe('login')
+    })
+
+    test('returns undefined for unknown command', () => {
+      expect(findCommand('unknown')).toBeUndefined()
+      expect(findCommand('notacommand')).toBeUndefined()
+    })
+
+    test('is case insensitive', () => {
+      expect(findCommand('LOGIN')?.name).toBe('login')
+      expect(findCommand('UsAgE')?.name).toBe('usage')
+      expect(findCommand('CREDITS')?.name).toBe('usage')
+    })
+  })
+
+  describe('COMMAND_REGISTRY', () => {
+    test('all commands have unique names', () => {
+      const names = COMMAND_REGISTRY.map((c) => c.name)
+      const uniqueNames = new Set(names)
+      expect(names.length).toBe(uniqueNames.size)
+    })
+
+    test('all aliases are unique across all commands', () => {
+      const allAliases = COMMAND_REGISTRY.flatMap((c) => c.aliases)
+      const uniqueAliases = new Set(allAliases)
+      expect(allAliases.length).toBe(uniqueAliases.size)
+    })
+
+    test('no alias conflicts with command names', () => {
+      const names = new Set(COMMAND_REGISTRY.map((c) => c.name))
+      const allAliases = COMMAND_REGISTRY.flatMap((c) => c.aliases)
+      for (const alias of allAliases) {
+        expect(names.has(alias)).toBe(false)
+      }
+    })
+
+    test('slash command metadata maps to registered commands', () => {
+      const registered = new Set([
+        ...COMMAND_REGISTRY.map((c) => c.name),
+        ...COMMAND_REGISTRY.flatMap((c) => c.aliases),
+      ])
+
+      // Commands with insertText are UI-only shortcuts that insert text into
+      // the input field instead of executing a command.
+      const executableCommands = SLASH_COMMANDS.filter((cmd) => !cmd.insertText)
+
+      for (const slashCommand of executableCommands) {
+        expect(registered.has(slashCommand.id)).toBe(true)
+        for (const alias of slashCommand.aliases ?? []) {
+          expect(registered.has(alias)).toBe(true)
+        }
+      }
+    })
+
+    test('mode commands expose model aliases for slash suggestions', () => {
+      const modeCommands = SLASH_COMMANDS.filter((cmd) =>
+        cmd.id.startsWith('mode:'),
+      )
+      expect(modeCommands.length).toBeGreaterThan(0)
+
+      for (const command of modeCommands) {
+        const modeName = command.id.slice('mode:'.length)
+        expect(command.aliases).toContain(`model:${modeName}`)
+      }
+    })
+
+    test('the ChatGPT connect command is gone from both products', () => {
+      // It was freebuff-only while it existed; the integration has since been
+      // removed, so neither the slash menu nor the router knows the name.
+      expect(SLASH_COMMANDS.some((cmd) => cmd.id === 'connect')).toBe(false)
+      expect(findCommand('connect')).toBeUndefined()
+      expect(findCommand('connect:chatgpt')).toBeUndefined()
+      expect(findCommand('chatgpt')).toBeUndefined()
+    })
+  })
+})

package/src/commands/ads.ts

@@ -0,0 +1,44 @@
+import { useChatStore } from '../state/chat-store'
+import { IS_FREEBUFF } from '../utils/constants'
+import { logger } from '../utils/logger'
+import { getSystemMessage } from '../utils/message-history'
+import { saveSettings, loadSettings } from '../utils/settings'
+
+import type { ChatMessage } from '../types/chat'
+
+export const handleAdsEnable = (): {
+  postUserMessage: (messages: ChatMessage[]) => ChatMessage[]
+} => {
+  logger.info('[gravity] Enabling ads')
+
+  saveSettings({ adsEnabled: true })
+
+  return {
+    postUserMessage: (messages) => [
+      ...messages,
+      getSystemMessage('Ads enabled. You will see contextual ads above the input and in the chat.'),
+    ],
+  }
+}
+
+export const handleAdsDisable = (): {
+  postUserMessage: (messages: ChatMessage[]) => ChatMessage[]
+} => {
+  logger.info('[gravity] Disabling ads')
+  saveSettings({ adsEnabled: false })
+
+  return {
+    postUserMessage: (messages) => [
+      ...messages,
+      getSystemMessage('Ads disabled.'),
+    ],
+  }
+}
+
+export const getAdsEnabled = (): boolean => {
+  if (IS_FREEBUFF) return true
+
+  // Anvil LITE is a paid mode now, so use the normal saved setting.
+  const settings = loadSettings()
+  return settings.adsEnabled ?? false
+}