feat(cli): add implicit command support for slashless invocation

- Add implicitCommand property to SlashCommand interface
- Enable init, new, help, exit, and logout commands to work without slash prefix
- Create unified parseCommandInput() function for consistent command parsing
- Add IMPLICIT_COMMAND_IDS derived Set for efficient lookups

Author: brandonkachen

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

@@ -6,6 +6,7 @@ import {
   parseCommand,
   isSlashCommand,
   isReferralCode,
+  parseCommandInput,
 } from '../router-utils'
 import { SLASH_COMMANDS } from '../../data/slash-commands'
 
@@ -138,6 +139,84 @@ describe('router-utils', () => {
     })
   })
 
+  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',

cli/src/commands/router-utils.ts

@@ -1,3 +1,5 @@
+import { SLASHLESS_COMMAND_IDS } from '../data/slash-commands'
+
 /**
  * Normalize user input by stripping the leading slash if present.
  * This is used for referral codes which work with or without the slash.
@@ -87,6 +89,54 @@ const REFERRAL_PREFIX = 'ref-'
 export function normalizeReferralCode(code: string): string {
   const trimmed = code.trim()
   const hasPrefix = trimmed.toLowerCase().startsWith(REFERRAL_PREFIX)
-  const codeWithoutPrefix = hasPrefix ? trimmed.slice(REFERRAL_PREFIX.length) : trimmed
+  const codeWithoutPrefix = hasPrefix
+    ? trimmed.slice(REFERRAL_PREFIX.length)
+    : trimmed
   return `${REFERRAL_PREFIX}${codeWithoutPrefix}`
 }
+
+/**
+ * Result of parsing a command-like input.
+ */
+export type ParsedCommandInput = {
+  command: string
+  args: string
+  implicitCommand: boolean
+}
+
+/**
+ * Parse a command from user input.
+ * Supports:
+ * - Standard slash commands: "/command args"
+ * - Slashless exact commands: "init" (only if configured)
+ *
+ * Returns null when the input should be treated as a normal message.
+ *
+ * @example
+ * parseCommandInput('/help') // => { command: 'help', args: '', implicitCommand: false }
+ * parseCommandInput('/usage stats') // => { command: 'usage', args: 'stats', implicitCommand: false }
+ * parseCommandInput('init') // => { command: 'init', args: '', implicitCommand: true }
+ * parseCommandInput('init something') // => null
+ */
+export function parseCommandInput(input: string): ParsedCommandInput | null {
+  const trimmed = input.trim()
+  if (!trimmed) return null
+
+  if (trimmed.startsWith('/')) {
+    const command = parseCommand(trimmed)
+    if (!command) return null
+    const args = trimmed.slice(1 + command.length).trim()
+    return { command, args, implicitCommand: false }
+  }
+
+  if (/\s/.test(trimmed)) {
+    return null
+  }
+
+  const normalized = trimmed.toLowerCase()
+  if (!SLASHLESS_COMMAND_IDS.has(normalized)) {
+    return null
+  }
+
+  return { command: normalized, args: '', implicitCommand: true }
+}

cli/src/commands/router.ts

@@ -9,11 +9,11 @@ import {
 } from './command-registry'
 import { handleReferralCode } from './referral'
 import {
-  parseCommand,
   isSlashCommand,
   isReferralCode,
   extractReferralCode,
   normalizeReferralCode,
+  parseCommandInput,
 } from './router-utils'
 import { handleClaudeAuthCode } from '../components/claude-connect-banner'
 import { getProjectRoot } from '../project-files'
@@ -413,25 +413,25 @@ export async function routeUserPrompt(
     return
   }
 
-  // Only process slash commands if input starts with '/'
-  if (isSlashCommand(trimmed)) {
-    const cmd = parseCommand(trimmed)
-    const args = trimmed.slice(1 + cmd.length).trim()
-
-    // Look up command in registry
-    const commandDef = findCommand(cmd)
+  // Handle slash commands or configured slashless exact commands.
+  const parsedCommand = parseCommandInput(trimmed)
+  if (parsedCommand) {
+    const commandDef = findCommand(parsedCommand.command)
     if (commandDef) {
-      // Track slash command usage
-      trackEvent(AnalyticsEvent.SLASH_COMMAND_USED, {
+      const argsLength = parsedCommand.args.length
+      const analyticsPayload = {
         command: commandDef.name,
-        hasArgs: args.trim().length > 0,
-        argsLength: args.trim().length,
+        hasArgs: argsLength > 0,
+        argsLength,
         agentMode,
-      })
+        ...(parsedCommand.implicitCommand ? { implicitCommand: true } : {}),
+      }
+
+      trackEvent(AnalyticsEvent.SLASH_COMMAND_USED, analyticsPayload)
 
       // The command handler (via defineCommand/defineCommandWithArgs factories)
       // is responsible for validating and handling args
-      return await commandDef.handler(params, args)
+      return await commandDef.handler(params, parsedCommand.args)
     }
   }
 
@@ -465,7 +465,7 @@ export async function routeUserPrompt(
   // Unknown slash command - show error
   if (isSlashCommand(trimmed)) {
     // Track invalid/unknown command (only log command name, not full input for privacy)
-    const attemptedCmd = parseCommand(trimmed)
+    const attemptedCmd = trimmed.slice(1).split(/\s+/)[0]?.toLowerCase() || ''
     trackEvent(AnalyticsEvent.INVALID_COMMAND, {
       attemptedCommand: attemptedCmd,
       inputLength: trimmed.length,

cli/src/data/slash-commands.ts

@@ -5,6 +5,11 @@ export interface SlashCommand {
   label: string
   description: string
   aliases?: string[]
+  /**
+   * If true, this command can be invoked without a leading slash when the
+   * input matches the command id exactly (no arguments).
+   */
+  implicitCommand?: boolean
 }
 
 // Generate mode commands from the AGENT_MODES constant
@@ -35,6 +40,7 @@ export const SLASH_COMMANDS: SlashCommand[] = [
     id: 'init',
     label: 'init',
     description: 'Create a starter knowledge.md file',
+    implicitCommand: true,
   },
   // {
   //   id: 'undo',
@@ -62,6 +68,7 @@ export const SLASH_COMMANDS: SlashCommand[] = [
     label: 'new',
     description: 'Start a fresh conversation session',
     aliases: ['n', 'clear', 'c', 'reset'],
+    implicitCommand: true,
   },
   {
     id: 'history',
@@ -91,6 +98,7 @@ export const SLASH_COMMANDS: SlashCommand[] = [
     label: 'help',
     description: 'Display keyboard shortcuts and tips',
     aliases: ['h', '?'],
+    implicitCommand: true,
   },
   ...MODE_COMMANDS,
   {
@@ -109,11 +117,19 @@ export const SLASH_COMMANDS: SlashCommand[] = [
     label: 'logout',
     description: 'Sign out of your session',
     aliases: ['signout'],
+    implicitCommand: true,
   },
   {
     id: 'exit',
     label: 'exit',
     description: 'Quit the CLI',
     aliases: ['quit', 'q'],
+    implicitCommand: true,
   },
 ]
+
+export const SLASHLESS_COMMAND_IDS = new Set(
+  SLASH_COMMANDS.filter((cmd) => cmd.implicitCommand).map((cmd) =>
+    cmd.id.toLowerCase(),
+  ),
+)