0dee4377b8
Connect the existing plugin loader infrastructure to both slash command dispatch paths (executor and slashcommand tool), enabling namespaced commands like /daplug:run-prompt to resolve and execute. - Add plugin discovery to executor.ts discoverAllCommands() - Add plugin discovery to command-discovery.ts discoverCommandsSync() - Add "plugin" to CommandScope type - Remove blanket colon-rejection error (replaced with standard not-found) - Update slash command regex to accept namespaced commands - Thread claude_code.plugins config toggle through dispatch chain - Add unit tests for plugin command discovery and dispatch Closes #2019 🤖 Generated with [Claude Code](https://claude.ai/code) Co-Authored-By: Claude <noreply@anthropic.com> Co-Authored-By: Codex <noreply@openai.com>
310 lines
8.6 KiB
TypeScript
310 lines
8.6 KiB
TypeScript
import { describe, expect, it } from "bun:test"
|
|
import {
|
|
parseSlashCommand,
|
|
detectSlashCommand,
|
|
isExcludedCommand,
|
|
removeCodeBlocks,
|
|
extractPromptText,
|
|
} from "./detector"
|
|
|
|
describe("auto-slash-command detector", () => {
|
|
describe("removeCodeBlocks", () => {
|
|
it("should remove markdown code blocks", () => {
|
|
// given text with code blocks
|
|
const text = "Hello ```code here``` world"
|
|
|
|
// when removing code blocks
|
|
const result = removeCodeBlocks(text)
|
|
|
|
// then code blocks should be removed
|
|
expect(result).toBe("Hello world")
|
|
})
|
|
|
|
it("should remove multiline code blocks", () => {
|
|
// given text with multiline code blocks
|
|
const text = `Before
|
|
\`\`\`javascript
|
|
/command-inside-code
|
|
\`\`\`
|
|
After`
|
|
|
|
// when removing code blocks
|
|
const result = removeCodeBlocks(text)
|
|
|
|
// then code blocks should be removed
|
|
expect(result).toContain("Before")
|
|
expect(result).toContain("After")
|
|
expect(result).not.toContain("/command-inside-code")
|
|
})
|
|
|
|
it("should handle text without code blocks", () => {
|
|
// given text without code blocks
|
|
const text = "Just regular text"
|
|
|
|
// when removing code blocks
|
|
const result = removeCodeBlocks(text)
|
|
|
|
// then text should remain unchanged
|
|
expect(result).toBe("Just regular text")
|
|
})
|
|
})
|
|
|
|
describe("parseSlashCommand", () => {
|
|
it("should parse simple command without args", () => {
|
|
// given a simple slash command
|
|
const text = "/commit"
|
|
|
|
// when parsing
|
|
const result = parseSlashCommand(text)
|
|
|
|
// then should extract command correctly
|
|
expect(result).not.toBeNull()
|
|
expect(result?.command).toBe("commit")
|
|
expect(result?.args).toBe("")
|
|
})
|
|
|
|
it("should parse command with arguments", () => {
|
|
// given a slash command with arguments
|
|
const text = "/plan create a new feature for auth"
|
|
|
|
// when parsing
|
|
const result = parseSlashCommand(text)
|
|
|
|
// then should extract command and args
|
|
expect(result).not.toBeNull()
|
|
expect(result?.command).toBe("plan")
|
|
expect(result?.args).toBe("create a new feature for auth")
|
|
})
|
|
|
|
it("should parse command with quoted arguments", () => {
|
|
// given a slash command with quoted arguments
|
|
const text = '/execute "build the API"'
|
|
|
|
// when parsing
|
|
const result = parseSlashCommand(text)
|
|
|
|
// then should extract command and args
|
|
expect(result).not.toBeNull()
|
|
expect(result?.command).toBe("execute")
|
|
expect(result?.args).toBe('"build the API"')
|
|
})
|
|
|
|
it("should parse command with hyphen in name", () => {
|
|
// given a slash command with hyphen
|
|
const text = "/frontend-template-creator project"
|
|
|
|
// when parsing
|
|
const result = parseSlashCommand(text)
|
|
|
|
// then should extract full command name
|
|
expect(result).not.toBeNull()
|
|
expect(result?.command).toBe("frontend-template-creator")
|
|
expect(result?.args).toBe("project")
|
|
})
|
|
|
|
it("should parse namespaced marketplace commands", () => {
|
|
// given a namespaced command
|
|
const text = "/daplug:run-prompt build bridge"
|
|
|
|
// when parsing
|
|
const result = parseSlashCommand(text)
|
|
|
|
// then should keep full namespaced command
|
|
expect(result).not.toBeNull()
|
|
expect(result?.command).toBe("daplug:run-prompt")
|
|
expect(result?.args).toBe("build bridge")
|
|
})
|
|
|
|
it("should return null for non-slash text", () => {
|
|
// given text without slash
|
|
const text = "regular text"
|
|
|
|
// when parsing
|
|
const result = parseSlashCommand(text)
|
|
|
|
// then should return null
|
|
expect(result).toBeNull()
|
|
})
|
|
|
|
it("should return null for slash not at start", () => {
|
|
// given text with slash in middle
|
|
const text = "some text /command"
|
|
|
|
// when parsing
|
|
const result = parseSlashCommand(text)
|
|
|
|
// then should return null (slash not at start)
|
|
expect(result).toBeNull()
|
|
})
|
|
|
|
it("should return null for just a slash", () => {
|
|
// given just a slash
|
|
const text = "/"
|
|
|
|
// when parsing
|
|
const result = parseSlashCommand(text)
|
|
|
|
// then should return null
|
|
expect(result).toBeNull()
|
|
})
|
|
|
|
it("should return null for slash followed by number", () => {
|
|
// given slash followed by number
|
|
const text = "/123"
|
|
|
|
// when parsing
|
|
const result = parseSlashCommand(text)
|
|
|
|
// then should return null (command must start with letter)
|
|
expect(result).toBeNull()
|
|
})
|
|
|
|
it("should handle whitespace before slash", () => {
|
|
// given command with leading whitespace
|
|
const text = " /commit"
|
|
|
|
// when parsing
|
|
const result = parseSlashCommand(text)
|
|
|
|
// then should parse after trimming
|
|
expect(result).not.toBeNull()
|
|
expect(result?.command).toBe("commit")
|
|
})
|
|
})
|
|
|
|
describe("isExcludedCommand", () => {
|
|
it("should exclude ralph-loop", () => {
|
|
// given ralph-loop command
|
|
// when checking exclusion
|
|
// then should be excluded
|
|
expect(isExcludedCommand("ralph-loop")).toBe(true)
|
|
})
|
|
|
|
it("should exclude cancel-ralph", () => {
|
|
// given cancel-ralph command
|
|
// when checking exclusion
|
|
// then should be excluded
|
|
expect(isExcludedCommand("cancel-ralph")).toBe(true)
|
|
})
|
|
|
|
it("should be case-insensitive for exclusion", () => {
|
|
// given uppercase variants
|
|
// when checking exclusion
|
|
// then should still be excluded
|
|
expect(isExcludedCommand("RALPH-LOOP")).toBe(true)
|
|
expect(isExcludedCommand("Cancel-Ralph")).toBe(true)
|
|
})
|
|
|
|
it("should not exclude regular commands", () => {
|
|
// given regular commands
|
|
// when checking exclusion
|
|
// then should not be excluded
|
|
expect(isExcludedCommand("commit")).toBe(false)
|
|
expect(isExcludedCommand("plan")).toBe(false)
|
|
expect(isExcludedCommand("execute")).toBe(false)
|
|
})
|
|
})
|
|
|
|
describe("detectSlashCommand", () => {
|
|
it("should detect slash command in plain text", () => {
|
|
// given plain text with slash command
|
|
const text = "/commit fix typo"
|
|
|
|
// when detecting
|
|
const result = detectSlashCommand(text)
|
|
|
|
// then should detect
|
|
expect(result).not.toBeNull()
|
|
expect(result?.command).toBe("commit")
|
|
expect(result?.args).toBe("fix typo")
|
|
})
|
|
|
|
it("should NOT detect slash command inside code block", () => {
|
|
// given slash command inside code block
|
|
const text = "```bash\n/command\n```"
|
|
|
|
// when detecting
|
|
const result = detectSlashCommand(text)
|
|
|
|
// then should not detect (only code block content)
|
|
expect(result).toBeNull()
|
|
})
|
|
|
|
it("should detect command when text has code blocks elsewhere", () => {
|
|
// given slash command before code block
|
|
const text = "/commit fix\n```code```"
|
|
|
|
// when detecting
|
|
const result = detectSlashCommand(text)
|
|
|
|
// then should detect the command
|
|
expect(result).not.toBeNull()
|
|
expect(result?.command).toBe("commit")
|
|
})
|
|
|
|
it("should NOT detect excluded commands", () => {
|
|
// given excluded command
|
|
const text = "/ralph-loop do something"
|
|
|
|
// when detecting
|
|
const result = detectSlashCommand(text)
|
|
|
|
// then should not detect
|
|
expect(result).toBeNull()
|
|
})
|
|
|
|
it("should return null for non-command text", () => {
|
|
// given regular text
|
|
const text = "Just some regular text"
|
|
|
|
// when detecting
|
|
const result = detectSlashCommand(text)
|
|
|
|
// then should return null
|
|
expect(result).toBeNull()
|
|
})
|
|
})
|
|
|
|
describe("extractPromptText", () => {
|
|
it("should extract text from parts", () => {
|
|
// given message parts
|
|
const parts = [
|
|
{ type: "text", text: "Hello " },
|
|
{ type: "tool_use", id: "123" },
|
|
{ type: "text", text: "world" },
|
|
]
|
|
|
|
// when extracting
|
|
const result = extractPromptText(parts)
|
|
|
|
// then should join text parts
|
|
expect(result).toBe("Hello world")
|
|
})
|
|
|
|
it("should handle empty parts", () => {
|
|
// given empty parts
|
|
const parts: Array<{ type: string; text?: string }> = []
|
|
|
|
// when extracting
|
|
const result = extractPromptText(parts)
|
|
|
|
// then should return empty string
|
|
expect(result).toBe("")
|
|
})
|
|
|
|
it("should handle parts without text", () => {
|
|
// given parts without text content
|
|
const parts = [
|
|
{ type: "tool_use", id: "123" },
|
|
{ type: "tool_result", output: "result" },
|
|
]
|
|
|
|
// when extracting
|
|
const result = extractPromptText(parts)
|
|
|
|
// then should return empty string
|
|
expect(result).toBe("")
|
|
})
|
|
})
|
|
})
|