Add named parameter support to slash commands (#128)

* Initial plan

* Add named parameter support to slash commands

Extended slash command parsing to support named parameters in key="value" format
alongside existing positional parameters. Named parameters can be mixed with
positional arguments and do not count toward positional numbering.

Examples:
- /fix-bug issue="PROJ-123" -> ${issue} = "PROJ-123"
- /task arg1 key="value" arg2 -> ${1}="arg1", ${2}="arg2", ${key}="value"

Co-authored-by: alexec <1142830+alexec@users.noreply.github.com>

* Fix review comments: clarify parseNamedParam documentation

Co-authored-by: alexec <1142830+alexec@users.noreply.github.com>

* Fix: Named parameters now count toward positional numbering

Updated slash command parsing so that named parameters (key="value") are also
included as positional arguments in their original form. This addresses the
feedback that `/task arg1 issue="PROJ-123" arg2` should result in:
- ${1} = arg1
- ${2} = issue="PROJ-123"
- ${3} = arg2
- ${issue} = PROJ-123

Also added protections:
- Reserved key ARGUMENTS cannot be used as a named parameter key
- Numeric keys (1, 2, etc.) cannot be used as named parameter keys
- Duplicate named parameter keys: last value wins (documented behavior)

Co-authored-by: alexec <1142830+alexec@users.noreply.github.com>

* Make double quotes mandatory for named parameters

Per @alexec's feedback, named parameters now require mandatory double quotes.
- Unquoted values like `key=value` are treated as positional arguments
- Single-quoted values like `key='value'` are also treated as positional arguments
- Only `key="value"` format is recognized as a named parameter

Updated parseNamedParamWithQuotes to validate double quote requirement.
Added tests for unquoted and single-quoted edge cases.
Updated documentation to clarify mandatory double quotes.

Co-authored-by: alexec <1142830+alexec@users.noreply.github.com>

* Simplify numeric key check using strconv.Atoi

Replaced manual character-by-character numeric check with strconv.Atoi
for cleaner, more idiomatic Go code.

Co-authored-by: alexec <1142830+alexec@users.noreply.github.com>

* Simplify parseBashArgsWithNamed to return map[string]string

Changed return type from ([]string, map[string]string, error) to
(map[string]string, error). The map now contains both positional keys
("1", "2", "3", etc.) and named parameter keys, eliminating the need
for a separate allArgs slice.

Co-authored-by: alexec <1142830+alexec@users.noreply.github.com>

* Remove protection for reserved keys (ARGUMENTS, numeric keys)

Per @alexec's feedback, removed the validation that prevented named
parameters from using ARGUMENTS or numeric keys. Users would have to
misuse the system greatly for this to cause problems.

Co-authored-by: alexec <1142830+alexec@users.noreply.github.com>

---------

Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com>
Co-authored-by: alexec <1142830+alexec@users.noreply.github.com>
Co-authored-by: Alex Collins <alexec@users.noreply.github.com>

Author: Copilot

docs/reference/cli.md

@@ -395,7 +395,31 @@ This enables dynamic task execution with inline arguments.
 /task-name arg1 "arg with spaces" arg3
 ```
 
-### Example
+### Positional Parameters
+
+Positional arguments are automatically numbered starting from 1:
+- `/fix-bug 123` → `$1` = `123`
+- `/task arg1 arg2 arg3` → `$1` = `arg1`, `$2` = `arg2`, `$3` = `arg3`
+
+Quoted arguments preserve spaces:
+- `/code-review "PR #42"` → `$1` = `PR #42`
+
+### Named Parameters
+
+Named parameters use the format `key="value"` with **mandatory double quotes**:
+- `/fix-bug issue="PROJ-123"` → `$1` = `issue="PROJ-123"`, `$issue` = `PROJ-123`
+- `/deploy env="production" version="1.2.3"` → `$1` = `env="production"`, `$2` = `version="1.2.3"`, `$env` = `production`, `$version` = `1.2.3`
+
+Named parameters are counted as positional arguments (retaining their original form) while also being available by their key name:
+- `/task arg1 key="value" arg2` → `$1` = `arg1`, `$2` = `key="value"`, `$3` = `arg2`, `$key` = `value`
+
+Named parameter values can contain spaces and special characters:
+- `/run message="Hello, World!"` → `$1` = `message="Hello, World!"`, `$message` = `Hello, World!`
+- `/config query="x=y+z"` → `$1` = `query="x=y+z"`, `$query` = `x=y+z`
+
+**Note:** Unquoted values (e.g., `key=value`) or single-quoted values (e.g., `key='value'`) are treated as regular positional arguments, not named parameters.
+
+### Example with Positional Parameters
 
 Create a task file (`implement-feature.md`):
 ```yaml
@@ -429,6 +453,43 @@ This is equivalent to manually running:
 coding-context -p 1=login -p 2="Add OAuth support" /implement-feature
 ```
 
+### Example with Named Parameters
+
+Create a wrapper task (`fix-issue-wrapper.md`):
+```yaml
+---
+task_name: fix-issue-wrapper
+---
+/fix-bug issue="PROJ-456" priority="high"
+```
+
+The target task (`fix-bug.md`):
+```yaml
+---
+task_name: fix-bug
+---
+# Fix Bug: ${issue}
+
+Priority: ${priority}
+```
+
+When you run:
+```bash
+coding-context fix-issue-wrapper
+```
+
+The output will be:
+```
+# Fix Bug: PROJ-456
+
+Priority: high
+```
+
+This is equivalent to manually running:
+```bash
+coding-context -p issue=PROJ-456 -p priority=high fix-bug
+```
+
 ## See Also
 
 - [File Formats Reference](./file-formats) - Task and rule file specifications

pkg/codingcontext/slashcommand.go

@@ -2,33 +2,41 @@ package codingcontext
 
 import (
 	"fmt"
+	"strconv"
 	"strings"
 )
 
 // parseSlashCommand parses a slash command string and extracts the task name and parameters.
 // It searches for a slash command anywhere in the input string, not just at the beginning.
-// The expected format is: /task-name arg1 "arg 2" arg3
+// The expected format is: /task-name arg1 "arg 2" arg3 key="value"
 //
 // The function will find the slash command even if it's embedded in other text. For example:
 //   - "Please /fix-bug 123 today" -> taskName: "fix-bug", params: {"ARGUMENTS": "123 today", "1": "123", "2": "today"}, found: true
 //   - "Some text /code-review" -> taskName: "code-review", params: {}, found: true
 //
 // Arguments are parsed like Bash:
 //   - Quoted arguments can contain spaces
-//   - Both single and double quotes are supported
+//   - Both single and double quotes are supported for positional arguments
 //   - Quotes are removed from the parsed arguments
 //   - Arguments are extracted until end of line
 //
+// Named parameters:
+//   - Named parameters use key="value" format with mandatory double quotes
+//   - Named parameters are also counted as positional arguments (retaining their original form)
+//
 // Examples:
 //   - "/fix-bug 123" -> taskName: "fix-bug", params: {"ARGUMENTS": "123", "1": "123"}, found: true
 //   - "/code-review \"PR #42\" high" -> taskName: "code-review", params: {"ARGUMENTS": "\"PR #42\" high", "1": "PR #42", "2": "high"}, found: true
+//   - "/fix-bug issue=\"PROJ-123\"" -> taskName: "fix-bug", params: {"ARGUMENTS": "issue=\"PROJ-123\"", "1": "issue=\"PROJ-123\"", "issue": "PROJ-123"}, found: true
+//   - "/task arg1 key=\"val\" arg2" -> taskName: "task", params: {"ARGUMENTS": "arg1 key=\"val\" arg2", "1": "arg1", "2": "key=\"val\"", "3": "arg2", "key": "val"}, found: true
 //   - "no command here" -> taskName: "", params: nil, found: false
 //
 // Returns:
 //   - taskName: the task name (without the leading slash)
 //   - params: a map containing:
 //   - "ARGUMENTS": the full argument string (with quotes preserved)
-//   - "1", "2", "3", etc.: positional arguments (with quotes removed)
+//   - "1", "2", "3", etc.: all arguments in order (with quotes removed), including named parameters in their original form
+//   - "key": named parameter value (with quotes removed)
 //   - found: true if a slash command was found, false otherwise
 //   - err: an error if the command format is invalid (e.g., unclosed quotes)
 func parseSlashCommand(command string) (taskName string, params map[string]string, found bool, err error) {
@@ -79,24 +87,30 @@ func parseSlashCommand(command string) (taskName string, params map[string]strin
 		return taskName, params, true, nil
 	}
 
-	// Parse positional arguments using bash-like parsing
-	args, err := parseBashArgs(argsString)
+	// Parse arguments using bash-like parsing, handling both positional and named parameters
+	parsedParams, err := parseBashArgsWithNamed(argsString)
 	if err != nil {
 		return "", nil, false, err
 	}
 
-	// Add positional arguments as $1, $2, $3, etc.
-	for i, arg := range args {
-		params[fmt.Sprintf("%d", i+1)] = arg
+	// Merge parsed params into params
+	for key, value := range parsedParams {
+		params[key] = value
 	}
 
 	return taskName, params, true, nil
 }
 
-// parseBashArgs parses a string into arguments like bash does, respecting quoted values
-func parseBashArgs(s string) ([]string, error) {
-	var args []string
+// parseBashArgsWithNamed parses a string into a map of parameters.
+// The map contains positional keys ("1", "2", "3", etc.) and named parameter keys.
+// Named parameters must use key="value" format with mandatory double quotes.
+// Returns the parameters map and any error.
+func parseBashArgsWithNamed(s string) (map[string]string, error) {
+	params := make(map[string]string)
+	argNum := 1
+
 	var current strings.Builder
+	var rawArg strings.Builder // Tracks the raw argument including quotes
 	inQuotes := false
 	quoteChar := byte(0)
 	escaped := false
@@ -107,13 +121,15 @@ func parseBashArgs(s string) ([]string, error) {
 
 		if escaped {
 			current.WriteByte(ch)
+			rawArg.WriteByte(ch)
 			escaped = false
 			continue
 		}
 
 		if ch == '\\' && inQuotes && quoteChar == '"' {
 			// Only recognize escape in double quotes
 			escaped = true
+			rawArg.WriteByte(ch)
 			continue
 		}
 
@@ -122,34 +138,109 @@ func parseBashArgs(s string) ([]string, error) {
 			inQuotes = true
 			quoteChar = ch
 			justClosedQuotes = false
+			rawArg.WriteByte(ch)
 		} else if ch == quoteChar && inQuotes {
 			// End of quoted string - mark that we just closed quotes
 			inQuotes = false
 			quoteChar = 0
 			justClosedQuotes = true
+			rawArg.WriteByte(ch)
 		} else if (ch == ' ' || ch == '\t') && !inQuotes {
 			// Whitespace outside quotes - end of argument
 			if current.Len() > 0 || justClosedQuotes {
-				args = append(args, current.String())
+				arg := current.String()
+				rawArgStr := rawArg.String()
+
+				// Add as positional argument
+				params[strconv.Itoa(argNum)] = rawArgStr
+				argNum++
+
+				// Check if this is also a named parameter with mandatory double quotes
+				if key, value, isNamed := parseNamedParamWithQuotes(rawArgStr); isNamed {
+					params[key] = value
+				} else {
+					// For non-named params, use stripped value as positional
+					params[strconv.Itoa(argNum-1)] = arg
+				}
+
 				current.Reset()
+				rawArg.Reset()
 				justClosedQuotes = false
 			}
 		} else {
 			// Regular character
 			current.WriteByte(ch)
+			rawArg.WriteByte(ch)
 			justClosedQuotes = false
 		}
 	}
 
 	// Add the last argument
 	if current.Len() > 0 || justClosedQuotes {
-		args = append(args, current.String())
+		arg := current.String()
+		rawArgStr := rawArg.String()
+
+		// Add as positional argument
+		params[strconv.Itoa(argNum)] = rawArgStr
+
+		// Check if this is also a named parameter with mandatory double quotes
+		if key, value, isNamed := parseNamedParamWithQuotes(rawArgStr); isNamed {
+			params[key] = value
+		} else {
+			// For non-named params, use stripped value as positional
+			params[strconv.Itoa(argNum)] = arg
+		}
 	}
 
 	// Check for unclosed quotes
 	if inQuotes {
 		return nil, fmt.Errorf("unclosed quote in arguments")
 	}
 
-	return args, nil
+	return params, nil
+}
+
+// parseNamedParamWithQuotes checks if an argument is a named parameter in key="value" format.
+// Double quotes are mandatory for the value portion.
+// Returns the key, value (with quotes stripped), and whether it was a valid named parameter.
+// Key must be non-empty and cannot contain spaces or tabs.
+func parseNamedParamWithQuotes(rawArg string) (key string, value string, isNamed bool) {
+	// Find the equals sign
+	eqIdx := strings.Index(rawArg, "=")
+	if eqIdx == -1 {
+		return "", "", false
+	}
+
+	key = rawArg[:eqIdx]
+	// Key must be a valid identifier (non-empty, no spaces or tabs)
+	if key == "" || strings.ContainsAny(key, " \t") {
+		return "", "", false
+	}
+
+	// The value portion (after '=')
+	valuePart := rawArg[eqIdx+1:]
+
+	// Value must start with double quote (mandatory)
+	if len(valuePart) < 2 || valuePart[0] != '"' {
+		return "", "", false
+	}
+
+	// Value must end with double quote
+	if valuePart[len(valuePart)-1] != '"' {
+		return "", "", false
+	}
+
+	// Extract the value between quotes and handle escaped quotes
+	quotedValue := valuePart[1 : len(valuePart)-1]
+	var unescaped strings.Builder
+	for i := 0; i < len(quotedValue); i++ {
+		if quotedValue[i] == '\\' && i+1 < len(quotedValue) && quotedValue[i+1] == '"' {
+			unescaped.WriteByte('"')
+			i++ // Skip the escaped quote
+		} else {
+			unescaped.WriteByte(quotedValue[i])
+		}
+	}
+
+	return key, unescaped.String(), true
 }