@alumbwe/anvil 1.0.0

package/src/commands/command-registry.ts

@@ -0,0 +1,726 @@
+import { safeOpen } from '../utils/open-url'
+
+import { handleAdsEnable, handleAdsDisable } from './ads'
+import { handleCopyConversationCommand } from './copy-conversation'
+import { handleHelpCommand } from './help'
+import { handleImageCommand } from './image'
+import { handleInitializationFlowLocally } from './init'
+import {
+  collectProcessDiagnostics,
+  formatProcessDiagnostics,
+} from './process-diagnostics'
+import { buildInterviewPrompt, buildPlanPrompt, buildReviewPromptFromArgs } from './prompt-builders'
+import { runBashCommand } from './router'
+import { handleUsageCommand } from './usage'
+import { returnToFreebuffLanding } from '../hooks/use-freebuff-session'
+import { useThemeStore } from '../hooks/use-theme'
+import { LOGIN_WEBSITE_URL, WEBSITE_URL } from '../login/constants'
+import { startNewChat } from '../project-files'
+import { useChatStore } from '../state/chat-store'
+import { stopActiveRun } from '../utils/active-run'
+import { useFeedbackStore } from '../state/feedback-store'
+import { useLoginStore } from '../state/login-store'
+import { AGENT_MODES, END_SESSION_MESSAGE, IS_FREEBUFF } from '../utils/constants'
+import { exitCliCleanly } from '../utils/exit-cleanly'
+import { getSystemMessage, getUserMessage } from '../utils/message-history'
+import { capturePendingAttachments } from '../utils/pending-attachments'
+import { getSkillByName } from '../utils/skill-registry'
+
+import type { MultilineInputHandle } from '../components/multiline-input'
+import type { InputValue, PendingAttachment } from '../types/store'
+import type { ChatMessage } from '../types/chat'
+import type { SendMessageFn } from '../types/contracts/send-message'
+import type { User } from '../utils/auth'
+import type { AgentMode } from '../utils/constants'
+import type { UseMutationResult } from '@tanstack/react-query'
+
+export type RouterParams = {
+  agentMode: AgentMode
+  inputRef: React.MutableRefObject<MultilineInputHandle | null>
+  inputValue: string
+  isChainInProgressRef: React.MutableRefObject<boolean>
+  isStreaming: boolean
+  logoutMutation: UseMutationResult<boolean, Error, void, unknown>
+  streamMessageIdRef: React.MutableRefObject<string | null>
+  addToQueue: (message: string, attachments?: PendingAttachment[]) => void
+  clearMessages: () => void
+  saveToHistory: (message: string) => void
+  scrollToLatest: () => void
+  sendMessage: SendMessageFn
+  setCanProcessQueue: (value: React.SetStateAction<boolean>) => void
+  setInputFocused: (focused: boolean) => void
+  setInputValue: (
+    value: InputValue | ((prev: InputValue) => InputValue),
+  ) => void
+  setIsAuthenticated: (value: React.SetStateAction<boolean | null>) => void
+  setMessages: (
+    value: ChatMessage[] | ((prev: ChatMessage[]) => ChatMessage[]),
+  ) => void
+  setUser: (value: React.SetStateAction<User | null>) => void
+}
+
+export type CommandResult = {
+  openFeedbackMode?: boolean
+  openPublishMode?: boolean
+  openChatHistory?: boolean
+  openReviewScreen?: boolean
+  openQueuePanel?: boolean
+  preSelectAgents?: string[]
+} | void
+
+export type CommandHandler = (
+  params: RouterParams,
+  args: string,
+) => Promise<CommandResult> | CommandResult
+
+export type CommandDefinition = {
+  name: string
+  aliases: string[]
+  handler: CommandHandler
+  /** Whether this command accepts arguments. Set automatically by the factory functions. */
+  acceptsArgs: boolean
+}
+
+/**
+ * Handler type for commands that don't accept arguments.
+ */
+type CommandHandlerNoArgs = (
+  params: RouterParams,
+) => Promise<CommandResult> | CommandResult
+
+/**
+ * Handler type for commands that accept arguments.
+ */
+type CommandHandlerWithArgs = (
+  params: RouterParams,
+  args: string,
+) => Promise<CommandResult> | CommandResult
+
+/**
+ * Configuration for defining a command that does NOT accept arguments.
+ */
+type CommandConfig = {
+  name: string
+  aliases?: string[]
+  handler: CommandHandlerNoArgs
+}
+
+/**
+ * Configuration for defining a command that accepts arguments.
+ */
+type CommandWithArgsConfig = {
+  name: string
+  aliases?: string[]
+  handler: CommandHandlerWithArgs
+}
+
+/**
+ * Factory for commands that do NOT accept arguments.
+ * Any args passed are gracefully ignored.
+ *
+ * @example
+ * defineCommand({
+ *   name: 'new',
+ *   aliases: ['n', 'clear'],
+ *   handler: (params) => {
+ *     params.setMessages(() => [])
+ *   },
+ * })
+ */
+export function defineCommand(config: CommandConfig): CommandDefinition {
+  return {
+    name: config.name,
+    aliases: config.aliases ?? [],
+    acceptsArgs: false,
+    handler: (params) => {
+      // Args are gracefully ignored for commands that don't accept them
+      return config.handler(params)
+    },
+  }
+}
+
+/**
+ * Factory for commands that accept arguments.
+ * The handler receives both params and args.
+ *
+ * @example
+ * defineCommandWithArgs({
+ *   name: 'bash',
+ *   aliases: ['!'],
+ *   handler: (params, args) => {
+ *     if (args.trim()) {
+ *       runBashCommand(args.trim())
+ *     }
+ *   },
+ * })
+ */
+export function defineCommandWithArgs(
+  config: CommandWithArgsConfig,
+): CommandDefinition {
+  return {
+    name: config.name,
+    aliases: config.aliases ?? [],
+    acceptsArgs: true,
+    handler: config.handler,
+  }
+}
+
+const clearInput = (params: RouterParams) => {
+  params.setInputValue({ text: '', cursorPosition: 0, lastEditDueToNav: false })
+}
+
+const FREEBUFF_REMOVED_COMMANDS = new Set([
+  'ads:enable',
+  'ads:disable',
+  'usage',
+  'subscribe',
+  'image',
+  'publish',
+  'gpt-5-agent',
+])
+
+const FREEBUFF_ONLY_COMMANDS = new Set([
+  'plan',
+  'end-session',
+  'dashboard',
+])
+
+const ALL_COMMANDS: CommandDefinition[] = [
+  defineCommand({
+    name: 'ads:enable',
+    handler: (params) => {
+      const { postUserMessage } = handleAdsEnable()
+      params.setMessages((prev) => postUserMessage(prev))
+      params.saveToHistory(params.inputValue.trim())
+      clearInput(params)
+    },
+  }),
+  defineCommand({
+    name: 'ads:disable',
+    handler: (params) => {
+      const { postUserMessage } = handleAdsDisable()
+      params.setMessages((prev) => postUserMessage(prev))
+      params.saveToHistory(params.inputValue.trim())
+      clearInput(params)
+    },
+  }),
+  defineCommand({
+    name: 'help',
+    aliases: ['h', '?'],
+    handler: async (params) => {
+      const { postUserMessage } = await handleHelpCommand()
+      params.setMessages((prev) => postUserMessage(prev))
+      params.saveToHistory(params.inputValue.trim())
+      clearInput(params)
+    },
+  }),
+  defineCommand({
+    name: 'diagnostics',
+    aliases: ['diag', 'processes'],
+    handler: (params) => {
+      const diagnostics = formatProcessDiagnostics(collectProcessDiagnostics())
+      params.setMessages((prev) => [...prev, getSystemMessage(diagnostics)])
+      params.saveToHistory(params.inputValue.trim())
+      clearInput(params)
+    },
+  }),
+  defineCommand({
+    name: 'copy',
+    aliases: ['copy-chat', 'export'],
+    handler: async (params) => {
+      await handleCopyConversationCommand(params)
+    },
+  }),
+  defineCommandWithArgs({
+    name: 'feedback',
+    aliases: ['bug', 'report'],
+    handler: (params, args) => {
+      const trimmedArgs = args.trim()
+
+      // If user provided feedback text directly, pre-populate the form
+      if (trimmedArgs) {
+        useFeedbackStore.getState().setFeedbackText(trimmedArgs)
+        useFeedbackStore.getState().setFeedbackCursor(trimmedArgs.length)
+      }
+
+      params.saveToHistory(params.inputValue.trim())
+      clearInput(params)
+      return { openFeedbackMode: true }
+    },
+  }),
+  defineCommandWithArgs({
+    name: 'bash',
+    aliases: ['!'],
+    handler: (params, args) => {
+      const trimmedArgs = args.trim()
+
+      // If user provided a command directly, execute it immediately
+      if (trimmedArgs) {
+        const commandWithBang = '!' + trimmedArgs
+        params.saveToHistory(commandWithBang)
+        clearInput(params)
+        runBashCommand(trimmedArgs)
+        return
+      }
+
+      // Otherwise enter bash mode
+      useChatStore.getState().setInputMode('bash')
+      params.saveToHistory(params.inputValue.trim())
+      clearInput(params)
+    },
+  }),
+  defineCommand({
+    name: 'login',
+    aliases: ['signin'],
+    handler: (params) => {
+      params.setMessages((prev) => [
+        ...prev,
+        getSystemMessage(
+          "You're already in the app. Use /logout to switch accounts.",
+        ),
+      ])
+      clearInput(params)
+    },
+  }),
+  defineCommand({
+    name: 'logout',
+    aliases: ['signout'],
+    handler: (params) => {
+      stopActiveRun('logout')
+
+      const { resetLoginState } = useLoginStore.getState()
+      params.logoutMutation.mutate(undefined, {
+        onSettled: () => {
+          resetLoginState()
+          params.setMessages((prev) => [
+            ...prev,
+            getSystemMessage('Logged out.'),
+          ])
+          clearInput(params)
+          setTimeout(() => {
+            // The confirmation remains visible briefly; fence that window too
+            // before unmounting the authenticated runtime.
+            stopActiveRun('logout')
+            params.setUser(null)
+            params.setIsAuthenticated(false)
+          }, 300)
+        },
+      })
+    },
+  }),
+  defineCommand({
+    name: 'exit',
+    aliases: ['quit', 'q'],
+    handler: () => {
+      void exitCliCleanly()
+    },
+  }),
+  defineCommandWithArgs({
+    name: 'new',
+    aliases: ['n', 'clear', 'c', 'reset'],
+    handler: (params, args) => {
+      const trimmedArgs = args.trim()
+
+      // Abort any in-flight run BEFORE clearing state and rotating the chat
+      // id: an orphaned run would keep streaming after the switch and its
+      // late checkpoints/final save would persist the old conversation's
+      // state under the new chat (or vice versa).
+      stopActiveRun('new-chat')
+
+      // Clear the conversation and rotate to a fresh chat directory, so the
+      // next message doesn't overwrite the previous conversation's history
+      params.setMessages(() => [])
+      params.clearMessages()
+      startNewChat()
+      params.saveToHistory(params.inputValue.trim())
+      clearInput(params)
+      // If user provided a message, send it as the first message in the new chat
+      if (trimmedArgs) {
+        // Re-enable queue processing so the message can be sent
+        params.setCanProcessQueue(true)
+        params.sendMessage({
+          content: trimmedArgs,
+          agentMode: params.agentMode,
+        })
+        setTimeout(() => {
+          params.scrollToLatest()
+        }, 0)
+      } else {
+        // Only disable queue if we're not sending a message
+        params.setCanProcessQueue(false)
+      }
+    },
+  }),
+  defineCommand({
+    name: 'init',
+    handler: async (params) => {
+      const { postUserMessage } = handleInitializationFlowLocally()
+      const trimmed = params.inputValue.trim()
+
+      params.saveToHistory(trimmed)
+      clearInput(params)
+
+      // Check streaming/queue state
+      if (
+        params.isStreaming ||
+        params.streamMessageIdRef.current ||
+        params.isChainInProgressRef.current
+      ) {
+        const pendingAttachments = capturePendingAttachments()
+        params.addToQueue(trimmed, pendingAttachments)
+        params.setInputFocused(true)
+        params.inputRef.current?.focus()
+        return
+      }
+
+      params.sendMessage({
+        content: trimmed,
+        agentMode: params.agentMode,
+        postUserMessage,
+      })
+      setTimeout(() => {
+        params.scrollToLatest()
+      }, 0)
+    },
+  }),
+  defineCommand({
+    name: 'usage',
+    aliases: ['credits'],
+    handler: async (params) => {
+      const { postUserMessage } = await handleUsageCommand()
+      params.setMessages((prev) => postUserMessage(prev))
+      params.saveToHistory(params.inputValue.trim())
+      clearInput(params)
+    },
+  }),
+  defineCommand({
+    name: 'subscribe',
+    aliases: ['strong', 'sub', 'buy-credits'],
+    handler: (params) => {
+      safeOpen(WEBSITE_URL + '/subscribe')
+      clearInput(params)
+    },
+  }),
+  defineCommand({
+    name: 'dashboard',
+    // Freebuff-only (see FREEBUFF_ONLY_COMMANDS): the hub is a Freebuff web
+    // surface, and Anvil has its own credits-shaped `/usage` banner.
+    //
+    // `usage` is one of the aliases because Freebuff removes that command —
+    // its banner is credits- and subscription-shaped — leaving the product
+    // with no answer at all to "how much have I used?". The word now lands
+    // somewhere, and only in the build where nothing else claims it.
+    aliases: ['usage', 'stats', 'streak'],
+    handler: (params) => {
+      const url = `${LOGIN_WEBSITE_URL}/account`
+      params.setMessages((prev) => [
+        ...prev,
+        getUserMessage(params.inputValue.trim()),
+        getSystemMessage(
+          `Opening your dashboard: ${url}\n\nStreak, activity, tokens, sessions and settings for your account — across the CLI, Desktop and web.`,
+        ),
+      ])
+      // Best-effort: `safeOpen` skips headless Linux and a locked-down WSL
+      // rather than risking the process, so the URL above is printed first and
+      // stays useful when nothing opens.
+      void safeOpen(url)
+      params.saveToHistory(params.inputValue.trim())
+      clearInput(params)
+    },
+  }),
+  defineCommandWithArgs({
+    name: 'image',
+    aliases: ['img', 'attach'],
+    handler: async (params, args) => {
+      const trimmedArgs = args.trim()
+
+      // If user provided a path directly, process it immediately
+      if (trimmedArgs) {
+        await handleImageCommand(trimmedArgs)
+        params.saveToHistory(params.inputValue.trim())
+        clearInput(params)
+        return
+      }
+
+      // Otherwise enter image mode
+      useChatStore.getState().setInputMode('image')
+      params.saveToHistory(params.inputValue.trim())
+      clearInput(params)
+    },
+  }),
+  // Mode commands generated from AGENT_MODES (excluded in Freebuff)
+  ...(IS_FREEBUFF ? [] : AGENT_MODES).map((mode) =>
+    defineCommandWithArgs({
+      name: `mode:${mode.toLowerCase()}`,
+      aliases: [`model:${mode.toLowerCase()}`],
+      handler: (params, args) => {
+        const trimmedArgs = args.trim()
+
+        useChatStore.getState().setAgentMode(mode)
+        params.setMessages((prev) => [
+          ...prev,
+          getUserMessage(params.inputValue.trim()),
+          getSystemMessage(`Switched to ${mode} mode.`),
+        ])
+        params.saveToHistory(params.inputValue.trim())
+        clearInput(params)
+
+        // If user provided a message, send it in the new mode
+        if (trimmedArgs) {
+          params.setCanProcessQueue(true)
+          params.sendMessage({
+            content: trimmedArgs,
+            agentMode: mode,
+          })
+          setTimeout(() => {
+            params.scrollToLatest()
+          }, 0)
+        }
+      },
+    }),
+  ),
+  defineCommandWithArgs({
+    name: 'publish',
+    handler: (params, args) => {
+      const trimmedArgs = args.trim()
+      params.saveToHistory(params.inputValue.trim())
+      clearInput(params)
+
+      // If user provided agent ids directly, skip to confirmation step
+      if (trimmedArgs) {
+        const agentIds = trimmedArgs.split(/\s+/).filter(Boolean)
+        return { openPublishMode: true, preSelectAgents: agentIds }
+      }
+
+      // Otherwise open selection UI
+      return { openPublishMode: true }
+    },
+  }),
+  defineCommand({
+    name: 'gpt-5-agent',
+    handler: (params) => {
+      // Insert @ GPT-5 Agent into the input field (UI shortcut, not a real command)
+      params.setInputValue({
+        text: '@GPT-5 Agent ',
+        cursorPosition: '@GPT-5 Agent '.length,
+        lastEditDueToNav: false,
+      })
+      params.inputRef.current?.focus()
+      // Don't save to history - this is just a UI shortcut
+    },
+  }),
+  defineCommand({
+    name: 'history',
+    aliases: ['chats'],
+    handler: (params) => {
+      params.saveToHistory(params.inputValue.trim())
+      clearInput(params)
+      return { openChatHistory: true }
+    },
+  }),
+  defineCommandWithArgs({
+    name: 'interview',
+    handler: (params, args) => {
+      const trimmedArgs = args.trim()
+
+      params.saveToHistory(params.inputValue.trim())
+      clearInput(params)
+
+      // If user provided text directly, send it immediately
+      if (trimmedArgs) {
+        params.sendMessage({
+          content: buildInterviewPrompt(trimmedArgs),
+          agentMode: params.agentMode,
+        })
+        setTimeout(() => {
+          params.scrollToLatest()
+        }, 0)
+        return
+      }
+
+      // Otherwise enter interview mode
+      useChatStore.getState().setInputMode('interview')
+    },
+  }),
+  defineCommandWithArgs({
+    name: 'plan',
+    handler: (params, args) => {
+      // /plan runs on the selected model. No gate.
+      const trimmedArgs = args.trim()
+
+      params.saveToHistory(params.inputValue.trim())
+      clearInput(params)
+
+      // If user provided plan text directly, send it immediately
+      if (trimmedArgs) {
+        params.sendMessage({
+          content: buildPlanPrompt(trimmedArgs),
+          agentMode: params.agentMode,
+        })
+        setTimeout(() => {
+          params.scrollToLatest()
+        }, 0)
+        return
+      }
+
+      // Otherwise enter plan mode
+      useChatStore.getState().setInputMode('plan')
+    },
+  }),
+  defineCommandWithArgs({
+    name: 'review',
+    handler: (params, args) => {
+      // /review runs on the selected model. No gate.
+      const trimmedArgs = args.trim()
+
+      params.saveToHistory(params.inputValue.trim())
+      clearInput(params)
+
+      // If user provided review text directly, send it immediately without showing the screen
+      if (trimmedArgs) {
+        params.sendMessage({
+          content: buildReviewPromptFromArgs(trimmedArgs),
+          agentMode: params.agentMode,
+        })
+        setTimeout(() => {
+          params.scrollToLatest()
+        }, 0)
+        return
+      }
+
+      // Otherwise open the selection UI
+      return { openReviewScreen: true }
+    },
+  }),
+  defineCommand({
+    // No `/q` alias: that one already quits the CLI, and a queue editor is not
+    // worth the chance of a mis-fired exit.
+    name: 'queue',
+    aliases: ['queued'],
+    handler: (params) => {
+      params.saveToHistory(params.inputValue.trim())
+      clearInput(params)
+      return { openQueuePanel: true }
+    },
+  }),
+  defineCommand({
+    name: 'theme:toggle',
+    handler: (params) => {
+      const { theme, setThemeName } = useThemeStore.getState()
+      const newTheme = theme.name === 'dark' ? 'light' : 'dark'
+      setThemeName(newTheme)
+      params.setMessages((prev) => [
+        ...prev,
+        getUserMessage(params.inputValue.trim()),
+        getSystemMessage(`Switched to ${newTheme} theme.`),
+      ])
+      clearInput(params)
+    },
+  }),
+  // /end-session (freebuff-only) — end the active session early and drop back
+  // to the model picker. The hook flips status to 'none', which unmounts
+  // <Chat> and mounts <FreebuffLandingScreen>, where the user picks a model
+  // and hits Enter to start a new session.
+  defineCommand({
+    name: 'end-session',
+    aliases: ['model'],
+    handler: (params) => {
+      params.setMessages((prev) => [
+        ...prev,
+        getUserMessage(params.inputValue.trim()),
+        getSystemMessage(END_SESSION_MESSAGE),
+      ])
+      params.saveToHistory(params.inputValue.trim())
+      clearInput(params)
+      returnToFreebuffLanding({ resetChat: true }).catch(() => {
+        // The hook surfaces poll errors via the session store; nothing to do
+        // here beyond letting the chat history reflect the attempt.
+      })
+    },
+  }),
+]
+
+export const COMMAND_REGISTRY: CommandDefinition[] = IS_FREEBUFF
+  ? ALL_COMMANDS.filter((cmd) => !FREEBUFF_REMOVED_COMMANDS.has(cmd.name))
+  : ALL_COMMANDS.filter((cmd) => !FREEBUFF_ONLY_COMMANDS.has(cmd.name))
+
+export function findCommand(cmd: string): CommandDefinition | undefined {
+  const lowerCmd = cmd.toLowerCase()
+
+  // First check the static command registry
+  const staticCommand = COMMAND_REGISTRY.find(
+    (def) => def.name === lowerCmd || def.aliases.includes(lowerCmd),
+  )
+  if (staticCommand) {
+    return staticCommand
+  }
+
+  // Check if this is a skill command (prefixed with "skill:")
+  if (lowerCmd.startsWith('skill:')) {
+    const skillName = lowerCmd.slice('skill:'.length)
+    const skill = getSkillByName(skillName)
+    if (skill) {
+      return createSkillCommand(skill.name)
+    }
+  }
+
+  return undefined
+}
+
+/**
+ * Creates a dynamic command definition for a skill.
+ * When invoked, the skill's content is sent to the agent.
+ */
+function createSkillCommand(skillName: string): CommandDefinition {
+  return defineCommandWithArgs({
+    name: skillName,
+    handler: (params, args) => {
+      const skill = getSkillByName(skillName)
+      if (!skill) {
+        params.setMessages((prev) => [
+          ...prev,
+          getUserMessage(params.inputValue.trim()),
+          getSystemMessage(`Skill not found: ${skillName}`),
+        ])
+        params.saveToHistory(params.inputValue.trim())
+        params.setInputValue({ text: '', cursorPosition: 0, lastEditDueToNav: false })
+        return
+      }
+
+      const trimmed = params.inputValue.trim()
+      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)
+        params.setInputFocused(true)
+        params.inputRef.current?.focus()
+        return
+      }
+
+      params.sendMessage({
+        content: userPrompt,
+        agentMode: params.agentMode,
+      })
+      setTimeout(() => {
+        params.scrollToLatest()
+      }, 0)
+    },
+  })
+}