merge: resolve conflict in command-registry.ts

Keep both doctor imports and new buildSkillPrompt import from upstream.

🤖 Generated with Codebuff
Co-Authored-By: Codebuff <noreply@codebuff.com>

Author: MukeshVermaLegit

bun.lock

@@ -1,6 +1,6 @@
 {
   "name": "codebuff",
-  "version": "1.0.685",
+  "version": "1.0.686",
   "description": "AI coding agent",
   "license": "MIT",
   "bin": {

cli/release/package.json

@@ -535,6 +535,7 @@ export const Chat = ({
           logoutMutation,
           streamMessageIdRef,
           addToQueue,
+          hasQueuedMessages: () => queuedCount > 0,
           clearMessages,
           saveToHistory,
           scrollToLatest,

cli/src/chat.tsx

@@ -0,0 +1,128 @@
+import { afterEach, beforeEach, describe, expect, mock, test } from 'bun:test'
+
+import { useChatStore } from '../../state/chat-store'
+import {
+  __resetSteeringForTests,
+  activateSteering,
+  drainSteeringMessages,
+} from '../../utils/steering-buffer'
+import { routeUserPrompt } from '../router'
+
+import type { RouterParams } from '../command-registry'
+
+const createMockParams = (overrides: Partial<RouterParams> = {}): RouterParams =>
+  ({
+    agentMode: 'DEFAULT',
+    inputRef: { current: null },
+    inputValue: '',
+    isChainInProgressRef: { current: false },
+    isStreaming: false,
+    logoutMutation: {} as RouterParams['logoutMutation'],
+    streamMessageIdRef: { current: null },
+    addToQueue: mock(() => {}),
+    hasQueuedMessages: () => false,
+    clearMessages: mock(() => {}),
+    saveToHistory: mock(() => {}),
+    scrollToLatest: mock(() => {}),
+    sendMessage: mock(async () => {}),
+    setCanProcessQueue: mock(() => {}),
+    setInputFocused: mock(() => {}),
+    setInputValue: mock(() => {}),
+    setIsAuthenticated: mock(() => {}),
+    setMessages: mock(() => {}),
+    setUser: mock(() => {}),
+    ...overrides,
+  }) as RouterParams
+
+beforeEach(() => {
+  useChatStore.getState().clearPendingBashMessages()
+})
+
+afterEach(() => {
+  __resetSteeringForTests()
+  useChatStore.getState().clearPendingBashMessages()
+})
+
+describe('mid-turn routing', () => {
+  test('plain text steers the active run and echoes a bubble immediately', async () => {
+    activateSteering('run-1')
+    const params = createMockParams({
+      inputValue: 'actually use zod for validation',
+      isStreaming: true,
+    })
+    await routeUserPrompt(params)
+
+    expect(params.addToQueue).not.toHaveBeenCalled()
+    expect(params.sendMessage).not.toHaveBeenCalled()
+    // Bubble echoed at push time so the submit is visible right away.
+    expect(params.setMessages).toHaveBeenCalledTimes(1)
+    const drained = drainSteeringMessages('run-1')
+    expect(drained.map((entry) => entry.text)).toEqual([
+      'actually use zod for validation',
+    ])
+    expect(drained[0]!.messageId).toStartWith('user-')
+  })
+
+  test('falls back to the queue when no run is accepting steering', async () => {
+    const params = createMockParams({
+      inputValue: 'between chained runs',
+      isStreaming: true,
+    })
+    await routeUserPrompt(params)
+
+    expect(params.addToQueue).toHaveBeenCalledTimes(1)
+    const [queued] = (params.addToQueue as ReturnType<typeof mock>).mock
+      .calls[0] as [string]
+    expect(queued).toBe('between chained runs')
+  })
+
+  test('queues instead of steering when earlier messages are already queued', async () => {
+    activateSteering('run-1')
+    const params = createMockParams({
+      inputValue: 'this must not overtake the queue',
+      isStreaming: true,
+      hasQueuedMessages: () => true,
+    })
+    await routeUserPrompt(params)
+
+    expect(drainSteeringMessages('run-1')).toEqual([])
+    expect(params.addToQueue).toHaveBeenCalledTimes(1)
+  })
+
+  test('queues instead of steering while bash output is pending', async () => {
+    activateSteering('run-1')
+    useChatStore.getState().addPendingBashMessage({
+      command: 'bun test',
+      output: '3 fail',
+    } as never)
+    const params = createMockParams({
+      inputValue: 'fix those failures',
+      isStreaming: true,
+    })
+    await routeUserPrompt(params)
+
+    expect(drainSteeringMessages('run-1')).toEqual([])
+    expect(params.addToQueue).toHaveBeenCalledTimes(1)
+  })
+
+  test('slash commands never steer', async () => {
+    activateSteering('run-1')
+    const params = createMockParams({
+      inputValue: '/definitely-not-a-command',
+      isStreaming: true,
+    })
+    await routeUserPrompt(params)
+
+    expect(drainSteeringMessages('run-1')).toEqual([])
+    expect(params.addToQueue).toHaveBeenCalledTimes(1)
+  })
+
+  test('idle submits are unaffected and send normally', async () => {
+    activateSteering('run-1')
+    const params = createMockParams({ inputValue: 'a fresh task' })
+    await routeUserPrompt(params)
+
+    expect(params.sendMessage).toHaveBeenCalledTimes(1)
+    expect(drainSteeringMessages('run-1')).toEqual([])
+  })
+})

cli/src/commands/__tests__/router-steering.test.ts

@@ -0,0 +1,156 @@
+import { afterEach, beforeEach, describe, expect, mock, test } from 'bun:test'
+
+import { useChatStore } from '../../state/chat-store'
+import {
+  __resetSkillRegistryForTests,
+  __setSkillsForTests,
+} from '../../utils/skill-registry'
+import { findCommand } from '../command-registry'
+import { buildSkillPrompt } from '../prompt-builders'
+import { routeUserPrompt } from '../router'
+
+import type { RouterParams } from '../command-registry'
+import type { SkillDefinition } from '@codebuff/common/types/skill'
+
+const TEST_SKILL: SkillDefinition = {
+  name: 'release-notes',
+  description: 'Draft release notes from recent commits',
+  content:
+    '---\nname: release-notes\ndescription: Draft release notes\n---\n\nDo the thing.',
+  filePath: '/tmp/skills/release-notes/SKILL.md',
+}
+
+const createMockParams = (overrides: Partial<RouterParams> = {}): RouterParams =>
+  ({
+    agentMode: 'DEFAULT',
+    inputRef: { current: null },
+    inputValue: '',
+    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(() => {}),
+    ...overrides,
+  }) as RouterParams
+
+const resetChatStore = () => {
+  useChatStore.getState().setInputMode('default')
+  useChatStore.getState().setPendingSkillName(null)
+}
+
+beforeEach(() => {
+  __setSkillsForTests({ [TEST_SKILL.name]: TEST_SKILL })
+  resetChatStore()
+})
+
+afterEach(() => {
+  __resetSkillRegistryForTests()
+  resetChatStore()
+})
+
+describe('/skill:<name> command', () => {
+  test('bare invocation enters skill input mode instead of sending', async () => {
+    const command = findCommand('skill:release-notes')
+    expect(command).toBeDefined()
+
+    const params = createMockParams({ inputValue: '/skill:release-notes' })
+    await command!.handler(params, '')
+
+    expect(useChatStore.getState().inputMode).toBe('skill')
+    expect(useChatStore.getState().pendingSkillName).toBe('release-notes')
+    expect(params.sendMessage).not.toHaveBeenCalled()
+    expect(params.addToQueue).not.toHaveBeenCalled()
+  })
+
+  test('invocation with trailing text sends immediately', async () => {
+    const command = findCommand('skill:release-notes')
+    const params = createMockParams({
+      inputValue: '/skill:release-notes for v2.1 only',
+    })
+    await command!.handler(params, 'for v2.1 only')
+
+    expect(useChatStore.getState().inputMode).toBe('default')
+    expect(params.sendMessage).toHaveBeenCalledTimes(1)
+    const [{ content }] = (params.sendMessage as ReturnType<typeof mock>).mock
+      .calls[0] as [{ content: string }]
+    expect(content).toBe(buildSkillPrompt(TEST_SKILL, 'for v2.1 only'))
+    expect(content).toContain('<skill name="release-notes">')
+    expect(content).toContain('User request: for v2.1 only')
+  })
+})
+
+describe('skill input mode submit', () => {
+  const enterSkillMode = () => {
+    useChatStore.getState().setInputMode('skill')
+    useChatStore.getState().setPendingSkillName(TEST_SKILL.name)
+  }
+
+  test('submit with text sends the skill plus the user request', async () => {
+    enterSkillMode()
+    const params = createMockParams({ inputValue: 'focus on the API changes' })
+    await routeUserPrompt(params)
+
+    expect(useChatStore.getState().inputMode).toBe('default')
+    expect(useChatStore.getState().pendingSkillName).toBeNull()
+    expect(params.sendMessage).toHaveBeenCalledTimes(1)
+    const [{ content }] = (params.sendMessage as ReturnType<typeof mock>).mock
+      .calls[0] as [{ content: string }]
+    expect(content).toBe(
+      buildSkillPrompt(TEST_SKILL, 'focus on the API changes'),
+    )
+  })
+
+  test('empty submit runs the skill without a user request', async () => {
+    enterSkillMode()
+    const params = createMockParams({ inputValue: '' })
+    await routeUserPrompt(params)
+
+    expect(params.sendMessage).toHaveBeenCalledTimes(1)
+    const [{ content }] = (params.sendMessage as ReturnType<typeof mock>).mock
+      .calls[0] as [{ content: string }]
+    expect(content).toBe(buildSkillPrompt(TEST_SKILL, ''))
+    expect(content).not.toContain('User request:')
+  })
+
+  test('submit while a turn is running queues instead of sending', async () => {
+    enterSkillMode()
+    const params = createMockParams({
+      inputValue: 'and be brief',
+      isStreaming: true,
+    })
+    await routeUserPrompt(params)
+
+    expect(params.sendMessage).not.toHaveBeenCalled()
+    expect(params.addToQueue).toHaveBeenCalledTimes(1)
+    const [queued] = (params.addToQueue as ReturnType<typeof mock>).mock
+      .calls[0] as [string]
+    expect(queued).toBe(buildSkillPrompt(TEST_SKILL, 'and be brief'))
+  })
+
+  test('a skill deleted mid-session reports instead of sending nothing', async () => {
+    enterSkillMode()
+    __resetSkillRegistryForTests()
+    const params = createMockParams({ inputValue: 'anything' })
+    await routeUserPrompt(params)
+
+    expect(params.sendMessage).not.toHaveBeenCalled()
+    expect(params.setMessages).toHaveBeenCalled()
+    expect(useChatStore.getState().inputMode).toBe('default')
+  })
+
+  test('leaving skill mode clears the pending skill', () => {
+    enterSkillMode()
+    useChatStore.getState().setInputMode('default')
+    expect(useChatStore.getState().pendingSkillName).toBeNull()
+  })
+})

cli/src/commands/__tests__/skill-command.test.ts

@@ -13,7 +13,7 @@ import {
   collectDoctorReport,
   formatDoctorReport,
 } from './doctor'
-import { buildInterviewPrompt, buildPlanPrompt, buildReviewPromptFromArgs } from './prompt-builders'
+import { buildInterviewPrompt, buildPlanPrompt, buildReviewPromptFromArgs, buildSkillPrompt } from './prompt-builders'
 import { handleReasoningCommand } from './reasoning'
 import { runBashCommand } from './router'
 import { handleUsageCommand } from './usage'
@@ -48,6 +48,9 @@ export type RouterParams = {
   logoutMutation: UseMutationResult<boolean, Error, void, unknown>
   streamMessageIdRef: React.MutableRefObject<string | null>
   addToQueue: (message: string, attachments?: PendingAttachment[]) => void
+  /** Whether the message queue currently holds anything. Steering checks it
+   *  so a mid-turn submit can't overtake earlier queued submissions. */
+  hasQueuedMessages?: () => boolean
   clearMessages: () => void
   saveToHistory: (message: string) => void
   scrollToLatest: () => void
@@ -730,36 +733,50 @@ function createSkillCommand(skillName: string): CommandDefinition {
       params.saveToHistory(trimmed)
       params.setInputValue({ text: '', cursorPosition: 0, lastEditDueToNav: false })
 
-      // Build the message content with skill context and optional user args
-      const skillContext = `<skill name="${skill.name}">
-${skill.content}
-</skill>`
-
-      const userPrompt = `I invoke the following skill:\n\n${skillContext}\n\n`
-        + (args.trim()
-          ? `User request: ${args.trim()}`
-          : '')
-
-      // Check streaming/queue state
-      if (
-        params.isStreaming ||
-        params.streamMessageIdRef.current ||
-        params.isChainInProgressRef.current
-      ) {
-        const pendingAttachments = capturePendingAttachments()
-        params.addToQueue(userPrompt, pendingAttachments)
+      // Bare invocation: like /interview, drop into an input mode so the
+      // user can add instructions before the skill is sent. Enter with an
+      // empty composer still runs the skill as-is (the router's skill-mode
+      // branch), so a no-args run costs one extra keystroke, not a feature.
+      if (!args.trim()) {
+        useChatStore.getState().enterSkillMode(skill.name)
         params.setInputFocused(true)
         params.inputRef.current?.focus()
         return
       }
 
-      params.sendMessage({
-        content: userPrompt,
-        agentMode: params.agentMode,
-      })
-      setTimeout(() => {
-        params.scrollToLatest()
-      }, 0)
+      dispatchSkillPrompt(params, skill, args)
     },
   })
 }
+
+/**
+ * Send (or queue, mid-turn) a user-invoked skill prompt. Shared by the
+ * /skill:<name> args form and the skill input mode's submit (router), so the
+ * two entry paths for the same feature cannot drift.
+ */
+export function dispatchSkillPrompt(
+  params: RouterParams,
+  skill: { name: string; content: string },
+  input: string,
+): void {
+  const userPrompt = buildSkillPrompt(skill, input)
+
+  if (
+    params.isStreaming ||
+    params.streamMessageIdRef.current ||
+    params.isChainInProgressRef.current
+  ) {
+    params.addToQueue(userPrompt, capturePendingAttachments())
+    params.setInputFocused(true)
+    params.inputRef.current?.focus()
+    return
+  }
+
+  params.sendMessage({
+    content: userPrompt,
+    agentMode: params.agentMode,
+  })
+  setTimeout(() => {
+    params.scrollToLatest()
+  }, 0)
+}