f146aeff0f
* style(tests): normalize BDD comments from '// #given' to '// given' - Replace 4,668 Python-style BDD comments across 107 test files - Patterns changed: // #given -> // given, // #when -> // when, // #then -> // then - Also handles no-space variants: //#given -> // given * fix(rules-injector): prefer output.metadata.filePath over output.title - Extract file path resolution to dedicated output-path.ts module - Prefer metadata.filePath which contains actual file path - Fall back to output.title only when metadata unavailable - Fixes issue where rules weren't injected when tool output title was a label * feat(slashcommand): add optional user_message parameter - Add user_message optional parameter for command arguments - Model can now call: command='publish' user_message='patch' - Improves error messages with clearer format guidance - Helps LLMs understand correct parameter usage * feat(hooks): restore compaction-context-injector hook - Restore hook deleted in cbbc7bd0 for session compaction context - Injects 7 mandatory sections: User Requests, Final Goal, Work Completed, Remaining Tasks, Active Working Context, MUST NOT Do, Agent Verification State - Re-register in hooks/index.ts and main plugin entry * refactor(background-agent): split manager.ts into focused modules - Extract constants.ts for TTL values and internal types (52 lines) - Extract state.ts for TaskStateManager class (204 lines) - Extract spawner.ts for task creation logic (244 lines) - Extract result-handler.ts for completion handling (265 lines) - Reduce manager.ts from 1377 to 755 lines (45% reduction) - Maintain backward compatible exports * refactor(agents): split prometheus-prompt.ts into subdirectory - Move 1196-line prometheus-prompt.ts to prometheus/ subdirectory - Organize prompt sections into separate files for maintainability - Update agents/index.ts exports * refactor(delegate-task): split tools.ts into focused modules - Extract categories.ts for category definitions and routing - Extract executor.ts for task execution logic - Extract helpers.ts for utility functions - Extract prompt-builder.ts for prompt construction - Reduce tools.ts complexity with cleaner separation of concerns * refactor(builtin-skills): split skills.ts into individual skill files - Move each skill to dedicated file in skills/ subdirectory - Create barrel export for backward compatibility - Improve maintainability with focused skill modules * chore: update import paths and lockfile - Update prometheus import path after refactor - Update bun.lock * fix(tests): complete BDD comment normalization - Fix remaining #when/#then patterns missed by initial sed - Affected: state.test.ts, events.test.ts --------- Co-authored-by: justsisyphus <justsisyphus@users.noreply.github.com>
297 lines
8.1 KiB
TypeScript
297 lines
8.1 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 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("")
|
|
})
|
|
})
|
|
})
|