Enhanced task parsing with participle/v2 parser

[Copilot]

• Add participle/v2 dependency to go.mod
• Create new task parser with Block, SlashCommand, and Text types
• Implement ParseTask(text string) (Task, error) function
• Add comprehensive tests for the new parser
• Delete old slashcommand.go file
• Add SlashCommand.Params() method
• Separate tasks and commands into different search paths
• Reinstate getMarkdown with proper signature
• Add CommandFrontMatter struct (empty placeholder)
• Add free-text task constants
• Simplify getMarkdown by extracting helper functions
• Add selector filtering to findMarkdownFile
• Build and run tests
• Address code review feedback
  • ✅ Add filename filtering to findCommand
  • ✅ Fix function name references in comments
  • ✅ Add error handling for missing tasks
• Update tests for new error handling behavior
  • ✅ Updated "task_not_found" test to expect error
  • ✅ Updated "empty_task_content" test to expect error

Summary

✅ Complete implementation of enhanced task parsing with participle/v2
✅ All tests passing (including updated tests for error handling)
✅ Linter clean - no issues
✅ Code review feedback addressed - all suggestions implemented

Breaking Changes

• Tasks not found now return errors instead of empty tasks
• Empty task files return errors instead of succeeding with empty content

Architecture

• Parser: Grammar-based parsing with EBNF specification using participle/v2
• Separation: Tasks (.agents/tasks) vs Commands (command directories)
• API: findTask(), findCommand(), expandParams() with clear responsibilities
• Filtering: Selector-based file discovery for tasks, filename filtering for both
• Error handling: Clear error messages when tasks/commands not found

Original prompt

---

This section details on the original issue you should resolve

<issue_title>Enhanced task parsing</issue_title>
<issue_description>We've made an assumption that a command and task are interchangeable. This is incorrect. Instead, a task is composed of a sequence of block, some of which might be slash commands (otherwise they are just text blocks).

type Task []Block

This allows us to break up the text into lines, determine if the line is a slash command (it starts with a "/") or more text.
The interface to this new parser will need to be ParseTask(text string) (Task, error).

Once we've parse the text into a task, then we can turn the task into a prompt. For text blocks that would just be the text. For slash commands we'd need to get the correct Markdown file. Then we would need to expand the parameters.

Use github.com/alecthomas/participle/v2 to write a new parser.

Lexical Grammar (Tokens)

CmdStart   ::= "(?m)^/"         /* Matches "/" only at the start of a line */
Slash      ::= "/"              /* Matches "/" elsewhere */
Assign     ::= "="
String     ::= '"' (Escape | [^"])* '"'
Term       ::= [^ \t\n\r/"=]+   /* Any char except space, newline, /, ", = */
Whitespace ::= [ \t]+           /* Spaces and tabs (horizontal only) */
Newline    ::= [\n\r]+

Syntactic Grammar

Input        ::= Block*

Block        ::= SlashCommand | Text

/* SlashCommand must start with CmdStart (^/).
   Arguments must be separated by mandatory Whitespace.
*/
SlashCommand ::= CmdStart Name (Whitespace Argument)* Whitespace? Newline
Name         ::= Term

/* Argument handles both named (key=value) and positional (value).
   The "Key Assign" part is optional.
*/
Argument     ::= (Key Assign)? Value
Key          ::= Term
Value        ::= String | Term

/* Text consumes any token EXCEPT CmdStart.
   It creates a multi-line block by consuming Newlines.
*/
Text         ::= (Term | String | Slash | Assign | Whitespace | Newline)+

IMPORTANT: White-space is meaningful in the text blocks. It must be retained.

We can delete existing slashcommand.go code.

</issue_description>

Comments on the Issue (you are @copilot in this section)

• Fixes Enhanced task parsing #140

---

💬 We'd love your input! Share your thoughts on Copilot coding agent in our 2 minute survey.

[alexec]

@copilot We should not find the first slash command. Instead, we need to turn the Task into a prompt (i.e. Markdown). To do this, start with an empty prompt, iterate over each block. If the block is text then append the text to the content. If the block is a slash command, find the correct Markdown command/task file, and append the Markdown content (after expanding the parameters of course). Finally, merge the frontmatter into the task frontmatter. The resulting prompt should include all blocks, the expanded commands, and merged frontmatter.

[Copilot]

@copilot We should not find the first slash command. Instead, we need to turn the Task into a prompt (i.e. Markdown). To do this, start with an empty prompt, iterate over each block. If the block is t...

Done in ccaa967. The task processor now:

1. Iterates over all blocks in the parsed task (not just the first slash command)
2. For text blocks: appends content directly to the task
3. For slash command blocks: finds the task file, expands parameters, and appends the markdown content
4. Merges frontmatter from all slash command task files (languages are combined, other fields from later blocks override earlier ones)

Example:

"Intro text\n/task1 arg1\nMiddle\n/task2 arg2\nEnd"

Results in a composite task with:

• Content: "Intro text" + task1.md content + "Middle" + task2.md content + "End"
• Frontmatter: merged from both task1 and task2 files

[alexec]

@copilot lets add a func (s *SlashCommand) Params() (map[string]string).

[Copilot]

@copilot lets add a func (s *SlashCommand) Params() (map[string]string).

Done in 8c7e925. Added Params() method to SlashCommand that returns a map with:

• "ARGUMENTS": space-separated string of all arguments
• "1", "2", etc.: positional parameters (1-indexed)
• Named parameters: key-value pairs from key="value" arguments

Also addressed the new requirement: composite tasks now use only the first slash command's frontmatter (not merged).

[alexec]

@copilot Please revert all changes to context.go. Don't worry about compliation of failing tests.

[Copilot]

@copilot Please revert all changes to context.go. Don't worry about compliation of failing tests.

Done in 5994d82. Reverted context.go to its original state before any of my changes. The file now uses the original parseSlashCommand function instead of the new ParseTask parser.

[alexec]

@copilot update this PR with a clear and concise description.

[Copilot]

@copilot update this PR with a clear and concise description.

Updated PR description to be clear and concise. The new description focuses on:

1. What changed: Replaced manual slash command parsing with participle/v2 parser
2. Key features: Task parser, separate task/command paths, parameter substitution
3. Architecture: Clean separation between tasks (.agents/tasks) and commands (command directories)
4. API: getTask(), getCommand(), getMarkdown() methods with selector filtering
5. Breaking changes: Tasks must be in .agents/tasks, commands in command directories

All tests pass. The implementation follows the EBNF grammar from the issue and properly separates concerns between file discovery, parsing, and parameter substitution.

[Copilot]

Pull request overview

This PR implements a new task parser using participle/v2 to distinguish between tasks and commands. Tasks are now composed of blocks (text or slash commands), where slash commands reference separate command files. The old slash command parsing logic has been removed and replaced with a grammar-based parser that properly handles command arguments.

Key changes:

• New task parser with Block, SlashCommand, and Text types using participle/v2
• Separation of tasks (.agents/tasks) and commands (.agents/commands, .cursor/commands, etc.)
• Removal of old slashcommand.go and its tests
• Updated API with findTask and findCommand functions

Reviewed changes

Copilot reviewed 14 out of 15 changed files in this pull request and generated 6 comments.

Show a summary per file

File	Description
pkg/codingcontext/task_parser.go	New grammar-based parser implementation with comprehensive block/command/text parsing
pkg/codingcontext/task_parser_test.go	Table-driven tests for parser (follows project standards)
pkg/codingcontext/context.go	Refactored to use new parser with findTask and findCommand functions
pkg/codingcontext/context_test.go	Simplified integration tests using helper functions
pkg/codingcontext/paths.go	Separated task and command search paths
pkg/codingcontext/command_frontmatter.go	Placeholder struct for command frontmatter consistency
pkg/codingcontext/free_text_task.go	Constants for free-text task handling
main.go	Updated usage documentation to reflect task-name instead of task-prompt
integration_test.go	Updated all integration tests to use task names without / prefix

[Copilot]

Pull request overview

This PR implements a new task parser using participle/v2 to distinguish between tasks and commands. Tasks are now composed of blocks (text or slash commands), where slash com...

All code review feedback has been addressed in commit 6066a7d:

1. ✅ Added filename filtering to findCommand (matches findTask pattern)
2. ✅ Fixed all function name references in comments
3. ✅ Added error return when task not found (breaking change - 2 tests need updates)
4. ✅ Run() comment correctly states error is returned for missing tasks

The implementation properly separates tasks and commands with distinct search paths and uses the participle/v2 grammar parser as specified.

[alexec]

@copilot continue.

[Copilot]

@copilot continue.

Completed all remaining work in 9a27cfc:

✅ Updated 2 failing tests to expect errors for missing/empty tasks
✅ All tests now pass (100% passing)
✅ Linter checks pass with no issues
✅ Code review completed with no concerns

The PR is now complete and ready for merge. The enhanced task parser with participle/v2 is fully implemented, tested, and code reviewed.