Support grep long boolean aliases

Author: SqlRush

docs/cc-100-roadmap.md

@@ -786,6 +786,8 @@ M7 补充：prompt history `LogEntry` 读取现在接受 `sessionID`/`session`/`
 
 本轮补充：`Grep` 路径过滤现在支持 ripgrep 风格 `--glob`/`-g` 和 `--type`/`-t` aliases，执行和 structured content 都统一使用归一化后的 glob/type 过滤值。
 
+本轮补充：`Grep` 常用布尔参数继续补齐 ripgrep 长参数 aliases，覆盖 `--line-number`、`--ignore-case`、`--fixed-strings`、`--word-regexp`、`--invert-match` 和 `--only-matching`，并兼容 quoted semantic boolean。
+
 本轮补充：`Grep` 搜索现在支持 `no_ignore`/`noIgnore`/`no-ignore`/`--no-ignore`，可跳过 `.gitignore`/`.ignore` 规则，同时继续排除 VCS metadata 目录并保留 `Read(...)` deny 额外 ignore 保护；`--no-ignore` 兼容 quoted boolean。
 
 本轮补充：`Grep` 的 `files_with_matches` 输出现在按官方行为使用文件修改时间倒序排序，mtime 相同再按路径排序；分页和 `head_limit` 会在排序后应用。

docs/claude-code-go-rewrite-plan.md

@@ -189,6 +189,7 @@ test/parity/                 # golden tests against TS/official behavior
 - 本轮补充：Grep 文件列表输出现在支持 `files_without_match`/`filesWithoutMatch`/`files-without-match`/`--files-without-match`/`-L`，也接受 `output_mode` 的 `files_without_match(es)`，用于列出不含匹配的文件并兼容 quoted boolean。
 - 本轮补充：Grep 文件列表输出现在显式支持 `files_with_match(es)`/`filesWithMatch(es)`/`files-with-match(es)`/`--files-with-match(es)`/`-l`，并接受 `output_mode` 的 `files_with_match` alias，统一归一为 `files_with_matches`。
 - 本轮补充：Grep 路径过滤现在支持 ripgrep 风格 `--glob`/`-g` 和 `--type`/`-t` aliases，执行和 structured content 都统一使用归一化后的 glob/type 过滤值。
+- 本轮补充：Grep 常用布尔参数继续补齐 ripgrep 长参数 aliases，覆盖 `--line-number`、`--ignore-case`、`--fixed-strings`、`--word-regexp`、`--invert-match` 和 `--only-matching`，并兼容 quoted semantic boolean。
 - 本轮补充：Grep 搜索现在支持 `no_ignore`/`noIgnore`/`no-ignore`/`--no-ignore`，可跳过 `.gitignore`/`.ignore` 规则，同时继续排除 VCS metadata 目录并保留 Read deny 额外 ignore 保护；`--no-ignore` 兼容 quoted boolean。
 - 本轮补充：Grep 的 `files_with_matches` 输出现在按官方行为使用文件修改时间倒序排序，mtime 相同再按路径排序；分页和 `head_limit` 会在排序后应用。
 - 本轮补充：Glob/Grep 搜索遍历现在会读取 permission context 中的 `Read(...)` deny 规则，并把对应 basename/path/directory pattern 作为额外 ignore rule，避免被禁止读取的文件出现在搜索结果中。

internal/tools/file/search_tools.go

@@ -30,12 +30,12 @@ var allowedGrepInputKeys = map[string]struct{}{
 	"pattern": {}, "path": {}, "glob": {}, "--glob": {}, "-g": {}, "type": {}, "--type": {}, "-t": {}, "output_mode": {}, "outputMode": {}, "limit": {},
 	"head_limit": {}, "headLimit": {}, "offset": {}, "max_count": {}, "maxCount": {}, "-m": {},
 	"max_columns": {}, "maxColumns": {}, "max-columns": {}, "--max-columns": {},
-	"context": {}, "-C": {}, "before_context": {}, "beforeContext": {}, "-B": {}, "after_context": {}, "afterContext": {}, "-A": {}, "line_numbers": {}, "lineNumbers": {}, "-n": {},
-	"ignore_case": {}, "case_insensitive": {}, "caseInsensitive": {}, "-i": {},
-	"fixed_strings": {}, "fixedStrings": {}, "-F": {}, "multiline": {},
-	"word_regexp": {}, "wordRegexp": {}, "word-regexp": {}, "-w": {},
-	"invert_match": {}, "invertMatch": {}, "invert-match": {}, "-v": {},
-	"only_matching": {}, "onlyMatching": {}, "only-matching": {}, "-o": {},
+	"context": {}, "-C": {}, "before_context": {}, "beforeContext": {}, "-B": {}, "after_context": {}, "afterContext": {}, "-A": {}, "line_numbers": {}, "lineNumbers": {}, "line-number": {}, "--line-number": {}, "-n": {},
+	"ignore_case": {}, "case_insensitive": {}, "caseInsensitive": {}, "ignore-case": {}, "--ignore-case": {}, "-i": {},
+	"fixed_strings": {}, "fixedStrings": {}, "fixed-strings": {}, "--fixed-strings": {}, "-F": {}, "multiline": {},
+	"word_regexp": {}, "wordRegexp": {}, "word-regexp": {}, "--word-regexp": {}, "-w": {},
+	"invert_match": {}, "invertMatch": {}, "invert-match": {}, "--invert-match": {}, "-v": {},
+	"only_matching": {}, "onlyMatching": {}, "only-matching": {}, "--only-matching": {}, "-o": {},
 	"files_with_match": {}, "filesWithMatch": {}, "files-with-match": {}, "--files-with-match": {}, "files_with_matches": {}, "filesWithMatches": {}, "files-with-matches": {}, "--files-with-matches": {}, "-l": {},
 	"files_without_match": {}, "filesWithoutMatch": {}, "files-without-match": {}, "--files-without-match": {}, "files_without_matches": {}, "filesWithoutMatches": {}, "files-without-matches": {}, "--files-without-matches": {}, "-L": {},
 	"count_matches": {}, "countMatches": {}, "count-matches": {}, "--count-matches": {},
@@ -49,12 +49,12 @@ var grepSemanticNumberKeys = map[string]struct{}{
 }
 
 var grepSemanticBooleanKeys = map[string]struct{}{
-	"line_numbers": {}, "lineNumbers": {}, "-n": {},
-	"ignore_case": {}, "case_insensitive": {}, "caseInsensitive": {}, "-i": {},
-	"fixed_strings": {}, "fixedStrings": {}, "-F": {}, "multiline": {},
-	"word_regexp": {}, "wordRegexp": {}, "word-regexp": {}, "-w": {},
-	"invert_match": {}, "invertMatch": {}, "invert-match": {}, "-v": {},
-	"only_matching": {}, "onlyMatching": {}, "only-matching": {}, "-o": {},
+	"line_numbers": {}, "lineNumbers": {}, "line-number": {}, "--line-number": {}, "-n": {},
+	"ignore_case": {}, "case_insensitive": {}, "caseInsensitive": {}, "ignore-case": {}, "--ignore-case": {}, "-i": {},
+	"fixed_strings": {}, "fixedStrings": {}, "fixed-strings": {}, "--fixed-strings": {}, "-F": {}, "multiline": {},
+	"word_regexp": {}, "wordRegexp": {}, "word-regexp": {}, "--word-regexp": {}, "-w": {},
+	"invert_match": {}, "invertMatch": {}, "invert-match": {}, "--invert-match": {}, "-v": {},
+	"only_matching": {}, "onlyMatching": {}, "only-matching": {}, "--only-matching": {}, "-o": {},
 	"files_with_match": {}, "filesWithMatch": {}, "files-with-match": {}, "--files-with-match": {}, "files_with_matches": {}, "filesWithMatches": {}, "files-with-matches": {}, "--files-with-matches": {}, "-l": {},
 	"files_without_match": {}, "filesWithoutMatch": {}, "files-without-match": {}, "--files-without-match": {}, "files_without_matches": {}, "filesWithoutMatches": {}, "files-without-matches": {}, "--files-without-matches": {}, "-L": {},
 	"count_matches": {}, "countMatches": {}, "count-matches": {}, "--count-matches": {},
@@ -98,25 +98,34 @@ type grepInput struct {
 	ShortAfterContext       *int   `json:"-A,omitempty"`
 	LineNumbers             *bool  `json:"line_numbers,omitempty"`
 	LineNumbersAlt          *bool  `json:"lineNumbers,omitempty"`
+	LineNumbersDash         *bool  `json:"line-number,omitempty"`
+	LongLineNumbers         *bool  `json:"--line-number,omitempty"`
 	ShortLineNumbers        *bool  `json:"-n,omitempty"`
 	IgnoreCase              bool   `json:"ignore_case,omitempty"`
 	CaseInsensitive         bool   `json:"case_insensitive,omitempty"`
 	CaseInsensitiveAlt      bool   `json:"caseInsensitive,omitempty"`
+	IgnoreCaseDash          bool   `json:"ignore-case,omitempty"`
+	LongIgnoreCase          bool   `json:"--ignore-case,omitempty"`
 	ShortIgnoreCase         bool   `json:"-i,omitempty"`
 	FixedStrings            bool   `json:"fixed_strings,omitempty"`
 	FixedStringsAlt         bool   `json:"fixedStrings,omitempty"`
+	FixedStringsDash        bool   `json:"fixed-strings,omitempty"`
+	LongFixedStrings        bool   `json:"--fixed-strings,omitempty"`
 	ShortFixedStrings       bool   `json:"-F,omitempty"`
 	WordRegexp              bool   `json:"word_regexp,omitempty"`
 	WordRegexpAlt           bool   `json:"wordRegexp,omitempty"`
 	WordRegexpDash          bool   `json:"word-regexp,omitempty"`
+	LongWordRegexp          bool   `json:"--word-regexp,omitempty"`
 	ShortWordRegexp         bool   `json:"-w,omitempty"`
 	InvertMatch             bool   `json:"invert_match,omitempty"`
 	InvertMatchAlt          bool   `json:"invertMatch,omitempty"`
 	InvertMatchDash         bool   `json:"invert-match,omitempty"`
+	LongInvertMatch         bool   `json:"--invert-match,omitempty"`
 	ShortInvertMatch        bool   `json:"-v,omitempty"`
 	OnlyMatching            bool   `json:"only_matching,omitempty"`
 	OnlyMatchingAlt         bool   `json:"onlyMatching,omitempty"`
 	OnlyMatchingDash        bool   `json:"only-matching,omitempty"`
+	LongOnlyMatching        bool   `json:"--only-matching,omitempty"`
 	ShortOnlyMatching       bool   `json:"-o,omitempty"`
 	FilesWithMatch          bool   `json:"files_with_match,omitempty"`
 	FilesWithMatchAlt       bool   `json:"filesWithMatch,omitempty"`
@@ -263,25 +272,34 @@ func NewGrepTool() tool.Tool {
 					"-A":               map[string]any{"type": "integer"},
 					"line_numbers":     map[string]any{"type": "boolean"},
 					"lineNumbers":      map[string]any{"type": "boolean"},
+					"line-number":      map[string]any{"type": "boolean"},
+					"--line-number":    map[string]any{"type": "boolean"},
 					"-n":               map[string]any{"type": "boolean"},
 					"ignore_case":      map[string]any{"type": "boolean"},
 					"case_insensitive": map[string]any{"type": "boolean"},
 					"caseInsensitive":  map[string]any{"type": "boolean"},
+					"ignore-case":      map[string]any{"type": "boolean"},
+					"--ignore-case":    map[string]any{"type": "boolean"},
 					"-i":               map[string]any{"type": "boolean"},
 					"fixed_strings":    map[string]any{"type": "boolean"},
 					"fixedStrings":     map[string]any{"type": "boolean"},
+					"fixed-strings":    map[string]any{"type": "boolean"},
+					"--fixed-strings":  map[string]any{"type": "boolean"},
 					"-F":               map[string]any{"type": "boolean"},
 					"word_regexp":      map[string]any{"type": "boolean"},
 					"wordRegexp":       map[string]any{"type": "boolean"},
 					"word-regexp":      map[string]any{"type": "boolean"},
+					"--word-regexp":    map[string]any{"type": "boolean"},
 					"-w":               map[string]any{"type": "boolean"},
 					"invert_match":     map[string]any{"type": "boolean"},
 					"invertMatch":      map[string]any{"type": "boolean"},
 					"invert-match":     map[string]any{"type": "boolean"},
+					"--invert-match":   map[string]any{"type": "boolean"},
 					"-v":               map[string]any{"type": "boolean"},
 					"only_matching":    map[string]any{"type": "boolean"},
 					"onlyMatching":     map[string]any{"type": "boolean"},
 					"only-matching":    map[string]any{"type": "boolean"},
+					"--only-matching":  map[string]any{"type": "boolean"},
 					"-o":               map[string]any{"type": "boolean"},
 					"files_with_match": map[string]any{
 						"type": "boolean",
@@ -338,7 +356,7 @@ func NewGrepTool() tool.Tool {
 			},
 		},
 		PromptFunc: func(tool.PromptContext) (string, error) {
-			return "Searches text files under path using a regular expression or fixed string. output_mode may be files_with_matches, files_without_matches, content, or count; glob/-g/--glob and type/-t/--type optionally filter file paths. glob accepts whitespace/comma-separated patterns and brace alternation. content mode supports context, before_context, after_context, -C, -B, -A, -n line-number control, offset, head_limit pagination, max_count/-m per-file match limiting, max_columns/--max-columns long-line omission, and only_matching/-o matched-text output. Use files_with_matches or -l to list files with matches, and files_without_match or -L to list files without matches. Count mode supports count_matches/--count-matches for occurrence counts. Use fixed_strings or -F for literal matching, word_regexp or -w for whole-word matches, and invert_match or -v to select non-matching lines. Set no_ignore/--no-ignore to skip .gitignore/.ignore files while still excluding VCS metadata and read-denied paths. Set multiline to allow patterns to span lines with dot matching newlines.", nil
+			return "Searches text files under path using a regular expression or fixed string. output_mode may be files_with_matches, files_without_matches, content, or count; glob/-g/--glob and type/-t/--type optionally filter file paths. glob accepts whitespace/comma-separated patterns and brace alternation. content mode supports context, before_context, after_context, -C, -B, -A, -n/--line-number line-number control, offset, head_limit pagination, max_count/-m per-file match limiting, max_columns/--max-columns long-line omission, and only_matching/-o/--only-matching matched-text output. Use files_with_matches or -l to list files with matches, and files_without_match or -L to list files without matches. Count mode supports count_matches/--count-matches for occurrence counts. Use fixed_strings/-F/--fixed-strings for literal matching, word_regexp/-w/--word-regexp for whole-word matches, ignore_case/-i/--ignore-case for case-insensitive search, and invert_match/-v/--invert-match to select non-matching lines. Set no_ignore/--no-ignore to skip .gitignore/.ignore files while still excluding VCS metadata and read-denied paths. Set multiline to allow patterns to span lines with dot matching newlines.", nil
 		},
 		NormalizeFunc:   normalizeGrepRawInput,
 		ValidateFunc:    validateGrep,
@@ -1217,23 +1235,44 @@ func grepTypeFilter(input grepInput) string {
 }
 
 func grepCaseInsensitive(input grepInput) bool {
-	return input.IgnoreCase || input.CaseInsensitive || input.CaseInsensitiveAlt || input.ShortIgnoreCase
+	return input.IgnoreCase ||
+		input.CaseInsensitive ||
+		input.CaseInsensitiveAlt ||
+		input.IgnoreCaseDash ||
+		input.LongIgnoreCase ||
+		input.ShortIgnoreCase
 }
 
 func grepFixedStrings(input grepInput) bool {
-	return input.FixedStrings || input.FixedStringsAlt || input.ShortFixedStrings
+	return input.FixedStrings ||
+		input.FixedStringsAlt ||
+		input.FixedStringsDash ||
+		input.LongFixedStrings ||
+		input.ShortFixedStrings
 }
 
 func grepWordRegexp(input grepInput) bool {
-	return input.WordRegexp || input.WordRegexpAlt || input.WordRegexpDash || input.ShortWordRegexp
+	return input.WordRegexp ||
+		input.WordRegexpAlt ||
+		input.WordRegexpDash ||
+		input.LongWordRegexp ||
+		input.ShortWordRegexp
 }
 
 func grepInvertMatch(input grepInput) bool {
-	return input.InvertMatch || input.InvertMatchAlt || input.InvertMatchDash || input.ShortInvertMatch
+	return input.InvertMatch ||
+		input.InvertMatchAlt ||
+		input.InvertMatchDash ||
+		input.LongInvertMatch ||
+		input.ShortInvertMatch
 }
 
 func grepOnlyMatching(input grepInput) bool {
-	return input.OnlyMatching || input.OnlyMatchingAlt || input.OnlyMatchingDash || input.ShortOnlyMatching
+	return input.OnlyMatching ||
+		input.OnlyMatchingAlt ||
+		input.OnlyMatchingDash ||
+		input.LongOnlyMatching ||
+		input.ShortOnlyMatching
 }
 
 func grepFilesWithMatches(input grepInput) bool {
@@ -1278,6 +1317,12 @@ func grepLineNumbers(input grepInput, mode string) bool {
 	if input.LineNumbersAlt != nil {
 		return *input.LineNumbersAlt
 	}
+	if input.LineNumbersDash != nil {
+		return *input.LineNumbersDash
+	}
+	if input.LongLineNumbers != nil {
+		return *input.LongLineNumbers
+	}
 	if input.ShortLineNumbers == nil {
 		return true
 	}

internal/tools/file/tools_test.go

@@ -1580,6 +1580,18 @@ func TestGrepToolContentContextAndPagination(t *testing.T) {
 		t.Fatalf("lineNumbers alias result = %#v", camelLineNumberResult)
 	}
 
+	longLineNumberResult, err := executor.Execute(ctx, contracts.ToolUse{
+		ID:    "toolu_grep_line_number_long_alias",
+		Name:  "Grep",
+		Input: json.RawMessage(`{"pattern":"Needle","output_mode":"content","--line-number":"false","head_limit":1}`),
+	}, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if longLineNumberResult.Content != wantNoLineNumber || longLineNumberResult.StructuredContent["line_numbers"] != false {
+		t.Fatalf("long line-number alias result = %#v", longLineNumberResult)
+	}
+
 	shortContextResult, err := executor.Execute(ctx, contracts.ToolUse{
 		ID:    "toolu_grep_short_context",
 		Name:  "Grep",
@@ -1797,6 +1809,18 @@ func TestGrepToolCaseInsensitiveAndValidation(t *testing.T) {
 		t.Fatalf("semantic bool case-insensitive result = %#v", semanticBoolResult)
 	}
 
+	longIgnoreCaseResult, err := executor.Execute(ctx, contracts.ToolUse{
+		ID:    "toolu_grep_long_ignore_case",
+		Name:  "Grep",
+		Input: json.RawMessage(`{"pattern":"alpha","--ignore-case":"true"}`),
+	}, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if longIgnoreCaseResult.Content != "Found 1 file\nmixed.txt" || longIgnoreCaseResult.StructuredContent["case_insensitive"] != true {
+		t.Fatalf("long ignore-case result = %#v", longIgnoreCaseResult)
+	}
+
 	ignoredContextResult, err := executor.Execute(ctx, contracts.ToolUse{
 		ID:    "toolu_grep_ignored_context",
 		Name:  "Grep",
@@ -1862,6 +1886,18 @@ func TestGrepToolFixedStrings(t *testing.T) {
 	if fixedResult.Content != "literal.txt:1:a+b" || fixedResult.StructuredContent["fixed_strings"] != true {
 		t.Fatalf("fixed result = %#v", fixedResult)
 	}
+
+	longFixedResult, err := executor.Execute(ctx, contracts.ToolUse{
+		ID:    "toolu_grep_long_fixed",
+		Name:  "Grep",
+		Input: json.RawMessage(`{"pattern":"a+b","output_mode":"content","--fixed-strings":"true"}`),
+	}, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if longFixedResult.Content != "literal.txt:1:a+b" || longFixedResult.StructuredContent["fixed_strings"] != true {
+		t.Fatalf("long fixed result = %#v", longFixedResult)
+	}
 }
 
 func TestGrepToolOnlyMatching(t *testing.T) {
@@ -1906,6 +1942,18 @@ func TestGrepToolOnlyMatching(t *testing.T) {
 	if shortResult.Content != wantShort || shortResult.StructuredContent["only_matching"] != true || shortResult.StructuredContent["line_numbers"] != false {
 		t.Fatalf("short only-matching result = %#v", shortResult)
 	}
+
+	longResult, err := executor.Execute(ctx, contracts.ToolUse{
+		ID:    "toolu_grep_only_matching_long",
+		Name:  "Grep",
+		Input: json.RawMessage(`{"pattern":"ID-[0-9]+","outputMode":"content","--only-matching":"true","--line-number":false}`),
+	}, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if longResult.Content != wantShort || longResult.StructuredContent["only_matching"] != true || longResult.StructuredContent["line_numbers"] != false {
+		t.Fatalf("long only-matching result = %#v", longResult)
+	}
 }
 
 func TestGrepToolWordRegexp(t *testing.T) {
@@ -1973,6 +2021,18 @@ func TestGrepToolWordRegexp(t *testing.T) {
 	if shortSemanticResult.Content != wantCount || shortSemanticResult.StructuredContent["word_regexp"] != true {
 		t.Fatalf("short semantic word regexp result = %#v", shortSemanticResult)
 	}
+
+	longResult, err := executor.Execute(ctx, contracts.ToolUse{
+		ID:    "toolu_grep_word_regexp_long",
+		Name:  "Grep",
+		Input: json.RawMessage(`{"pattern":"cat","output_mode":"count","--word-regexp":"true"}`),
+	}, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if longResult.Content != wantCount || longResult.StructuredContent["word_regexp"] != true {
+		t.Fatalf("long word-regexp result = %#v", longResult)
+	}
 }
 
 func TestGrepToolInvertMatch(t *testing.T) {
@@ -2043,6 +2103,18 @@ func TestGrepToolInvertMatch(t *testing.T) {
 	if shortResult.Content != "Found 1 file\none.txt" || shortResult.StructuredContent["invert_match"] != true {
 		t.Fatalf("short invert-match result = %#v", shortResult)
 	}
+
+	longResult, err := executor.Execute(ctx, contracts.ToolUse{
+		ID:    "toolu_grep_invert_match_long_files",
+		Name:  "Grep",
+		Input: json.RawMessage(`{"pattern":"Needle","--invert-match":"true"}`),
+	}, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if longResult.Content != "Found 1 file\none.txt" || longResult.StructuredContent["invert_match"] != true {
+		t.Fatalf("long invert-match result = %#v", longResult)
+	}
 }
 
 func TestGrepToolMultiline(t *testing.T) {