@alumbwe/anvil 1.0.0 → 1.0.1

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

@@ -1,91 +0,0 @@
-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

@@ -1,54 +0,0 @@
-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

@@ -1,28 +0,0 @@
-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

@@ -1,298 +0,0 @@
-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

@@ -1,44 +0,0 @@
-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
-}