RubyGems - aia - Versions diffs - 0.3.4 → 0.3.20 - Mend

aia 0.3.4 → 0.3.20

Files changed (35) hide show

checksums.yaml +4 -4
data/.semver +6 -0
data/CHANGELOG.md +16 -0
data/README.md +165 -55
data/Rakefile +2 -0
data/justfile +167 -0
data/lib/aia/cli.rb +228 -115
data/lib/aia/config.rb +7 -0
data/lib/aia/logging.rb +49 -12
data/lib/aia/main.rb +46 -15
data/lib/aia/prompt_processing.rb +208 -4
data/lib/aia/tools/editor.rb +52 -0
data/lib/aia/{external → tools}/mods.rb +108 -12
data/lib/aia/{external → tools}/sgpt.rb +12 -7
data/lib/aia/{external → tools}/subl.rb +32 -11
data/lib/aia/tools/temp.md +97 -0
data/lib/aia/tools/vim.rb +93 -0
data/lib/aia/tools.rb +50 -0
data/lib/aia/version.rb +5 -1
data/lib/aia.rb +18 -3
data/main.just +56 -0
data/man/aia.1 +134 -0
data/man/aia.1.md +107 -0
metadata +87 -18
data/lib/aia/configuration.rb +0 -39
data/lib/aia/external/,keep +0 -0
data/lib/aia/external/.irbrc +0 -11
data/lib/aia/external/ag.rb +0 -103
data/lib/aia/external/bat.rb +0 -189
data/lib/aia/external/fzf.rb +0 -147
data/lib/aia/external/glow.rb +0 -37
data/lib/aia/external/rg.rb +0 -1163
data/lib/aia/external/tool.rb +0 -73
data/lib/aia/external.rb +0 -259
data/lib/aia/external_two.rb +0 -43

data/lib/aia/external/rg.rb DELETED Viewed

@@ -1,1163 +0,0 @@
-# lib/aia/external/rg.rb
-class AIA::External::Rg < AIA::External::Tool
-  def initialize
-    super
-    @role     = :search
-    @desc     = "Search tool like grep and The Silver Searcher"
-    @url      = "https://github.com/BurntSushi/ripgrep"
-  end
-  def command(search_term, options = {})
-    rg_command = "rg --color=always --line-number --no-heading --smart-case #{search_term}"
-    "#{rg_command} | fzf #{options[:fzf_options]}"
-  end
-end
-__END__
-ripgrep 13.0.0
-Andrew Gallant <jamslam@gmail.com>
-ripgrep (rg) recursively searches the current directory for a regex pattern.
-By default, ripgrep will respect gitignore rules and automatically skip hidden
-files/directories and binary files.
-Use -h for short descriptions and --help for more details.
-Project home page: https://github.com/BurntSushi/ripgrep
-USAGE:
-    rg [OPTIONS] PATTERN [PATH ...]
-    rg [OPTIONS] -e PATTERN ... [PATH ...]
-    rg [OPTIONS] -f PATTERNFILE ... [PATH ...]
-    rg [OPTIONS] --files [PATH ...]
-    rg [OPTIONS] --type-list
-    command | rg [OPTIONS] PATTERN
-    rg [OPTIONS] --help
-    rg [OPTIONS] --version
-ARGS:
-    <PATTERN>
-            A regular expression used for searching. To match a pattern beginning with a
-            dash, use the -e/--regexp flag.
-            For example, to search for the literal '-foo', you can use this flag:
-                rg -e -foo
-            You can also use the special '--' delimiter to indicate that no more flags
-            will be provided. Namely, the following is equivalent to the above:
-                rg -- -foo
-    <PATH>...
-            A file or directory to search. Directories are searched recursively. File paths
-            specified on the command line override glob and ignore rules.
-OPTIONS:
-    -A, --after-context <NUM>
-            Show NUM lines after each match.
-            This overrides the --context and --passthru flags.
-        --auto-hybrid-regex
-            DEPRECATED. Use --engine instead.
-            When this flag is used, ripgrep will dynamically choose between supported regex
-            engines depending on the features used in a pattern. When ripgrep chooses a
-            regex engine, it applies that choice for every regex provided to ripgrep (e.g.,
-            via multiple -e/--regexp or -f/--file flags).
-            As an example of how this flag might behave, ripgrep will attempt to use
-            its default finite automata based regex engine whenever the pattern can be
-            successfully compiled with that regex engine. If PCRE2 is enabled and if the
-            pattern given could not be compiled with the default regex engine, then PCRE2
-            will be automatically used for searching. If PCRE2 isn't available, then this
-            flag has no effect because there is only one regex engine to choose from.
-            In the future, ripgrep may adjust its heuristics for how it decides which
-            regex engine to use. In general, the heuristics will be limited to a static
-            analysis of the patterns, and not to any specific runtime behavior observed
-            while searching files.
-            The primary downside of using this flag is that it may not always be obvious
-            which regex engine ripgrep uses, and thus, the match semantics or performance
-            profile of ripgrep may subtly and unexpectedly change. However, in many cases,
-            all regex engines will agree on what constitutes a match and it can be nice
-            to transparently support more advanced regex features like look-around and
-            backreferences without explicitly needing to enable them.
-            This flag can be disabled with --no-auto-hybrid-regex.
-    -B, --before-context <NUM>
-            Show NUM lines before each match.
-            This overrides the --context and --passthru flags.
-        --binary
-            Enabling this flag will cause ripgrep to search binary files. By default,
-            ripgrep attempts to automatically skip binary files in order to improve the
-            relevance of results and make the search faster.
-            Binary files are heuristically detected based on whether they contain a NUL
-            byte or not. By default (without this flag set), once a NUL byte is seen,
-            ripgrep will stop searching the file. Usually, NUL bytes occur in the beginning
-            of most binary files. If a NUL byte occurs after a match, then ripgrep will
-            still stop searching the rest of the file, but a warning will be printed.
-            In contrast, when this flag is provided, ripgrep will continue searching a file
-            even if a NUL byte is found. In particular, if a NUL byte is found then ripgrep
-            will continue searching until either a match is found or the end of the file is
-            reached, whichever comes sooner. If a match is found, then ripgrep will stop
-            and print a warning saying that the search stopped prematurely.
-            If you want ripgrep to search a file without any special NUL byte handling at
-            all (and potentially print binary data to stdout), then you should use the
-            '-a/--text' flag.
-            The '--binary' flag is a flag for controlling ripgrep's automatic filtering
-            mechanism. As such, it does not need to be used when searching a file
-            explicitly or when searching stdin. That is, it is only applicable when
-            recursively searching a directory.
-            Note that when the '-u/--unrestricted' flag is provided for a third time, then
-            this flag is automatically enabled.
-            This flag can be disabled with '--no-binary'. It overrides the '-a/--text'
-            flag.
-        --block-buffered
-            When enabled, ripgrep will use block buffering. That is, whenever a matching
-            line is found, it will be written to an in-memory buffer and will not be
-            written to stdout until the buffer reaches a certain size. This is the default
-            when ripgrep's stdout is redirected to a pipeline or a file. When ripgrep's
-            stdout is connected to a terminal, line buffering will be used. Forcing block
-            buffering can be useful when dumping a large amount of contents to a terminal.
-            Forceful block buffering can be disabled with --no-block-buffered. Note that
-            using --no-block-buffered causes ripgrep to revert to its default behavior of
-            automatically detecting the buffering strategy. To force line buffering, use
-            the --line-buffered flag.
-    -b, --byte-offset
-            Print the 0-based byte offset within the input file before each line of output.
-            If -o (--only-matching) is specified, print the offset of the matching part
-            itself.
-            If ripgrep does transcoding, then the byte offset is in terms of the the result
-            of transcoding and not the original data. This applies similarly to another
-            transformation on the source, such as decompression or a --pre filter. Note
-            that when the PCRE2 regex engine is used, then UTF-8 transcoding is done by
-            default.
-    -s, --case-sensitive
-            Search case sensitively.
-            This overrides the -i/--ignore-case and -S/--smart-case flags.
-        --color <WHEN>
-            This flag controls when to use colors. The default setting is 'auto', which
-            means ripgrep will try to guess when to use colors. For example, if ripgrep is
-            printing to a terminal, then it will use colors, but if it is redirected to a
-            file or a pipe, then it will suppress color output. ripgrep will suppress color
-            output in some other circumstances as well. For example, if the TERM
-            environment variable is not set or set to 'dumb', then ripgrep will not use
-            colors.
-            The possible values for this flag are:
-                never    Colors will never be used.
-                auto     The default. ripgrep tries to be smart.
-                always   Colors will always be used regardless of where output is sent.
-                ansi     Like 'always', but emits ANSI escapes (even in a Windows console).
-            When the --vimgrep flag is given to ripgrep, then the default value for the
-            --color flag changes to 'never'.
-        --colors <COLOR_SPEC>...
-            This flag specifies color settings for use in the output. This flag may be
-            provided multiple times. Settings are applied iteratively. Colors are limited
-            to one of eight choices: red, blue, green, cyan, magenta, yellow, white and
-            black. Styles are limited to nobold, bold, nointense, intense, nounderline
-            or underline.
-            The format of the flag is '{type}:{attribute}:{value}'. '{type}' should be
-            one of path, line, column or match. '{attribute}' can be fg, bg or style.
-            '{value}' is either a color (for fg and bg) or a text style. A special format,
-            '{type}:none', will clear all color settings for '{type}'.
-            For example, the following command will change the match color to magenta and
-            the background color for line numbers to yellow:
-                rg --colors 'match:fg:magenta' --colors 'line:bg:yellow' foo.
-            Extended colors can be used for '{value}' when the terminal supports ANSI color
-            sequences. These are specified as either 'x' (256-color) or 'x,x,x' (24-bit
-            truecolor) where x is a number between 0 and 255 inclusive. x may be given as
-            a normal decimal number or a hexadecimal number, which is prefixed by `0x`.
-            For example, the following command will change the match background color to
-            that represented by the rgb value (0,128,255):
-                rg --colors 'match:bg:0,128,255'
-            or, equivalently,
-                rg --colors 'match:bg:0x0,0x80,0xFF'
-            Note that the the intense and nointense style flags will have no effect when
-            used alongside these extended color codes.
-        --column
-            Show column numbers (1-based). This only shows the column numbers for the first
-            match on each line. This does not try to account for Unicode. One byte is equal
-            to one column. This implies --line-number.
-            This flag can be disabled with --no-column.
-    -C, --context <NUM>
-            Show NUM lines before and after each match. This is equivalent to providing
-            both the -B/--before-context and -A/--after-context flags with the same value.
-            This overrides both the -B/--before-context and -A/--after-context flags,
-            in addition to the --passthru flag.
-        --context-separator <SEPARATOR>
-            The string used to separate non-contiguous context lines in the output. This
-            is only used when one of the context flags is used (-A, -B or -C). Escape
-            sequences like \x7F or \t may be used. The default value is --.
-            When the context separator is set to an empty string, then a line break
-            is still inserted. To completely disable context separators, use the
-            --no-context-separator flag.
-    -c, --count
-            This flag suppresses normal output and shows the number of lines that match
-            the given patterns for each file searched. Each file containing a match has its
-            path and count printed on each line. Note that this reports the number of lines
-            that match and not the total number of matches, unless -U/--multiline is
-            enabled. In multiline mode, --count is equivalent to --count-matches.
-            If only one file is given to ripgrep, then only the count is printed if there
-            is a match. The --with-filename flag can be used to force printing the file
-            path in this case. If you need a count to be printed regardless of whether
-            there is a match, then use --include-zero.
-            This overrides the --count-matches flag. Note that when --count is combined
-            with --only-matching, then ripgrep behaves as if --count-matches was given.
-        --count-matches
-            This flag suppresses normal output and shows the number of individual
-            matches of the given patterns for each file searched. Each file
-            containing matches has its path and match count printed on each line.
-            Note that this reports the total number of individual matches and not
-            the number of lines that match.
-            If only one file is given to ripgrep, then only the count is printed if there
-            is a match. The --with-filename flag can be used to force printing the file
-            path in this case.
-            This overrides the --count flag. Note that when --count is combined with
-            --only-matching, then ripgrep behaves as if --count-matches was given.
-        --crlf
-            When enabled, ripgrep will treat CRLF ('\r\n') as a line terminator instead
-            of just '\n'.
-            Principally, this permits '$' in regex patterns to match just before CRLF
-            instead of just before LF. The underlying regex engine may not support this
-            natively, so ripgrep will translate all instances of '$' to '(?:\r??$)'. This
-            may produce slightly different than desired match offsets. It is intended as a
-            work-around until the regex engine supports this natively.
-            CRLF support can be disabled with --no-crlf.
-        --debug
-            Show debug messages. Please use this when filing a bug report.
-            The --debug flag is generally useful for figuring out why ripgrep skipped
-            searching a particular file. The debug messages should mention all files
-            skipped and why they were skipped.
-            To get even more debug output, use the --trace flag, which implies --debug
-            along with additional trace data. With --trace, the output could be quite
-            large and is generally more useful for development.
-        --dfa-size-limit <NUM+SUFFIX?>
-            The upper size limit of the regex DFA. The default limit is 10M. This should
-            only be changed on very large regex inputs where the (slower) fallback regex
-            engine may otherwise be used if the limit is reached.
-            The argument accepts the same size suffixes as allowed in with the
-            --max-filesize flag.
-    -E, --encoding <ENCODING>
-            Specify the text encoding that ripgrep will use on all files searched. The
-            default value is 'auto', which will cause ripgrep to do a best effort automatic
-            detection of encoding on a per-file basis. Automatic detection in this case
-            only applies to files that begin with a UTF-8 or UTF-16 byte-order mark (BOM).
-            No other automatic detection is performed. One can also specify 'none' which
-            will then completely disable BOM sniffing and always result in searching the
-            raw bytes, including a BOM if it's present, regardless of its encoding.
-            Other supported values can be found in the list of labels here:
-            https://encoding.spec.whatwg.org/#concept-encoding-get
-            For more details on encoding and how ripgrep deals with it, see GUIDE.md.
-            This flag can be disabled with --no-encoding.
-        --engine <ENGINE>
-            Specify which regular expression engine to use. When you choose a regex engine,
-            it applies that choice for every regex provided to ripgrep (e.g., via multiple
-            -e/--regexp or -f/--file flags).
-            Accepted values are 'default', 'pcre2', or 'auto'.
-            The default value is 'default', which is the fastest and should be good for
-            most use cases. The 'pcre2' engine is generally useful when you want to use
-            features such as look-around or backreferences. 'auto' will dynamically choose
-            between supported regex engines depending on the features used in a pattern on
-            a best effort basis.
-            Note that the 'pcre2' engine is an optional ripgrep feature. If PCRE2 wasn't
-            included in your build of ripgrep, then using this flag will result in ripgrep
-            printing an error message and exiting.
-            This overrides previous uses of --pcre2 and --auto-hybrid-regex flags.
-              [default: default]
-        --field-context-separator <SEPARATOR>
-            Set the field context separator, which is used to delimit file paths, line
-            numbers, columns and the context itself, when printing contextual lines. The
-            separator may be any number of bytes, including zero. Escape sequences like
-            \x7F or \t may be used. The default value is -.
-        --field-match-separator <SEPARATOR>
-            Set the field match separator, which is used to delimit file paths, line
-            numbers, columns and the match itself. The separator may be any number of
-            bytes, including zero. Escape sequences like \x7F or \t may be used. The
-            default value is -.
-    -f, --file <PATTERNFILE>...
-            Search for patterns from the given file, with one pattern per line. When this
-            flag is used multiple times or in combination with the -e/--regexp flag,
-            then all patterns provided are searched. Empty pattern lines will match all
-            input lines, and the newline is not counted as part of the pattern.
-            A line is printed if and only if it matches at least one of the patterns.
-        --files
-            Print each file that would be searched without actually performing the search.
-            This is useful to determine whether a particular file is being searched or not.
-    -l, --files-with-matches
-            Print the paths with at least one match and suppress match contents.
-            This overrides --files-without-match.
-        --files-without-match
-            Print the paths that contain zero matches and suppress match contents. This
-            inverts/negates the --files-with-matches flag.
-            This overrides --files-with-matches.
-    -F, --fixed-strings
-            Treat the pattern as a literal string instead of a regular expression. When
-            this flag is used, special regular expression meta characters such as .(){}*+
-            do not need to be escaped.
-            This flag can be disabled with --no-fixed-strings.
-    -L, --follow
-            When this flag is enabled, ripgrep will follow symbolic links while traversing
-            directories. This is disabled by default. Note that ripgrep will check for
-            symbolic link loops and report errors if it finds one.
-            This flag can be disabled with --no-follow.
-    -g, --glob <GLOB>...
-            Include or exclude files and directories for searching that match the given
-            glob. This always overrides any other ignore logic. Multiple glob flags may be
-            used. Globbing rules match .gitignore globs. Precede a glob with a ! to exclude
-            it. If multiple globs match a file or directory, the glob given later in the
-            command line takes precedence.
-            As an extension, globs support specifying alternatives: *-g ab{c,d}* is
-            equivalet to *-g abc -g abd*. Empty alternatives like *-g ab{,c}* are not
-            currently supported. Note that this syntax extension is also currently enabled
-            in gitignore files, even though this syntax isn't supported by git itself.
-            ripgrep may disable this syntax extension in gitignore files, but it will
-            always remain available via the -g/--glob flag.
-            When this flag is set, every file and directory is applied to it to test for
-            a match. So for example, if you only want to search in a particular directory
-            'foo', then *-g foo* is incorrect because 'foo/bar' does not match the glob
-            'foo'. Instead, you should use *-g 'foo/**'*.
-        --glob-case-insensitive
-            Process glob patterns given with the -g/--glob flag case insensitively. This
-            effectively treats --glob as --iglob.
-            This flag can be disabled with the --no-glob-case-insensitive flag.
-    -h, --help
-            Prints help information. Use --help for more details.
-        --heading
-            This flag prints the file path above clusters of matches from each file instead
-            of printing the file path as a prefix for each matched line. This is the
-            default mode when printing to a terminal.
-            This overrides the --no-heading flag.
-    -., --hidden
-            Search hidden files and directories. By default, hidden files and directories
-            are skipped. Note that if a hidden file or a directory is whitelisted in an
-            ignore file, then it will be searched even if this flag isn't provided.
-            A file or directory is considered hidden if its base name starts with a dot
-            character ('.'). On operating systems which support a `hidden` file attribute,
-            like Windows, files with this attribute are also considered hidden.
-            This flag can be disabled with --no-hidden.
-        --iglob <GLOB>...
-            Include or exclude files and directories for searching that match the given
-            glob. This always overrides any other ignore logic. Multiple glob flags may be
-            used. Globbing rules match .gitignore globs. Precede a glob with a ! to exclude
-            it. Globs are matched case insensitively.
-    -i, --ignore-case
-            When this flag is provided, the given patterns will be searched case
-            insensitively. The case insensitivity rules used by ripgrep conform to
-            Unicode's "simple" case folding rules.
-            This flag overrides -s/--case-sensitive and -S/--smart-case.
-        --ignore-file <PATH>...
-            Specifies a path to one or more .gitignore format rules files. These patterns
-            are applied after the patterns found in .gitignore and .ignore are applied
-            and are matched relative to the current working directory. Multiple additional
-            ignore files can be specified by using the --ignore-file flag several times.
-            When specifying multiple ignore files, earlier files have lower precedence
-            than later files.
-            If you are looking for a way to include or exclude files and directories
-            directly on the command line, then used -g instead.
-        --ignore-file-case-insensitive
-            Process ignore files (.gitignore, .ignore, etc.) case insensitively. Note that
-            this comes with a performance penalty and is most useful on case insensitive
-            file systems (such as Windows).
-            This flag can be disabled with the --no-ignore-file-case-insensitive flag.
-        --include-zero
-            When used with --count or --count-matches, print the number of matches for
-            each file even if there were zero matches. This is disabled by default but can
-            be enabled to make ripgrep behave more like grep.
-    -v, --invert-match
-            Invert matching. Show lines that do not match the given patterns.
-        --json
-            Enable printing results in a JSON Lines format.
-            When this flag is provided, ripgrep will emit a sequence of messages, each
-            encoded as a JSON object, where there are five different message types:
-            **begin** - A message that indicates a file is being searched and contains at
-            least one match.
-            **end** - A message the indicates a file is done being searched. This message
-            also include summary statistics about the search for a particular file.
-            **match** - A message that indicates a match was found. This includes the text
-            and offsets of the match.
-            **context** - A message that indicates a contextual line was found. This
-            includes the text of the line, along with any match information if the search
-            was inverted.
-            **summary** - The final message emitted by ripgrep that contains summary
-            statistics about the search across all files.
-            Since file paths or the contents of files are not guaranteed to be valid UTF-8
-            and JSON itself must be representable by a Unicode encoding, ripgrep will emit
-            all data elements as objects with one of two keys: 'text' or 'bytes'. 'text' is
-            a normal JSON string when the data is valid UTF-8 while 'bytes' is the base64
-            encoded contents of the data.
-            The JSON Lines format is only supported for showing search results. It cannot
-            be used with other flags that emit other types of output, such as --files,
-            --files-with-matches, --files-without-match, --count or --count-matches.
-            ripgrep will report an error if any of the aforementioned flags are used in
-            concert with --json.
-            Other flags that control aspects of the standard output such as
-            --only-matching, --heading, --replace, --max-columns, etc., have no effect
-            when --json is set.
-            A more complete description of the JSON format used can be found here:
-            https://docs.rs/grep-printer/*/grep_printer/struct.JSON.html
-            The JSON Lines format can be disabled with --no-json.
-        --line-buffered
-            When enabled, ripgrep will use line buffering. That is, whenever a matching
-            line is found, it will be flushed to stdout immediately. This is the default
-            when ripgrep's stdout is connected to a terminal, but otherwise, ripgrep will
-            use block buffering, which is typically faster. This flag forces ripgrep to
-            use line buffering even if it would otherwise use block buffering. This is
-            typically useful in shell pipelines, e.g.,
-            'tail -f something.log | rg foo --line-buffered | rg bar'.
-            Forceful line buffering can be disabled with --no-line-buffered. Note that
-            using --no-line-buffered causes ripgrep to revert to its default behavior of
-            automatically detecting the buffering strategy. To force block buffering, use
-            the --block-buffered flag.
-    -n, --line-number
-            Show line numbers (1-based). This is enabled by default when searching in a
-            terminal.
-    -x, --line-regexp
-            Only show matches surrounded by line boundaries. This is equivalent to putting
-            ^...$ around all of the search patterns. In other words, this only prints lines
-            where the entire line participates in a match.
-            This overrides the --word-regexp flag.
-    -M, --max-columns <NUM>
-            Don't print lines longer than this limit in bytes. Longer lines are omitted,
-            and only the number of matches in that line is printed.
-            When this flag is omitted or is set to 0, then it has no effect.
-        --max-columns-preview
-            When the '--max-columns' flag is used, ripgrep will by default completely
-            replace any line that is too long with a message indicating that a matching
-            line was removed. When this flag is combined with '--max-columns', a preview
-            of the line (corresponding to the limit size) is shown instead, where the part
-            of the line exceeding the limit is not shown.
-            If the '--max-columns' flag is not set, then this has no effect.
-            This flag can be disabled with '--no-max-columns-preview'.
-    -m, --max-count <NUM>
-            Limit the number of matching lines per file searched to NUM.
-        --max-depth <NUM>
-            Limit the depth of directory traversal to NUM levels beyond the paths given. A
-            value of zero only searches the explicitly given paths themselves.
-            For example, 'rg --max-depth 0 dir/' is a no-op because dir/ will not be
-            descended into. 'rg --max-depth 1 dir/' will search only the direct children of
-            'dir'.
-        --max-filesize <NUM+SUFFIX?>
-            Ignore files larger than NUM in size. This does not apply to directories.
-            The input format accepts suffixes of K, M or G which correspond to kilobytes,
-            megabytes and gigabytes, respectively. If no suffix is provided the input is
-            treated as bytes.
-            Examples: --max-filesize 50K or --max-filesize 80M
-        --mmap
-            Search using memory maps when possible. This is enabled by default when ripgrep
-            thinks it will be faster.
-            Memory map searching doesn't currently support all options, so if an
-            incompatible option (e.g., --context) is given with --mmap, then memory maps
-            will not be used.
-            Note that ripgrep may abort unexpectedly when --mmap if it searches a file that
-            is simultaneously truncated.
-            This flag overrides --no-mmap.
-    -U, --multiline
-            Enable matching across multiple lines.
-            When multiline mode is enabled, ripgrep will lift the restriction that a match
-            cannot include a line terminator. For example, when multiline mode is not
-            enabled (the default), then the regex '\p{any}' will match any Unicode
-            codepoint other than '\n'. Similarly, the regex '\n' is explicitly forbidden,
-            and if you try to use it, ripgrep will return an error. However, when multiline
-            mode is enabled, '\p{any}' will match any Unicode codepoint, including '\n',
-            and regexes like '\n' are permitted.
-            An important caveat is that multiline mode does not change the match semantics
-            of '.'. Namely, in most regex matchers, a '.' will by default match any
-            character other than '\n', and this is true in ripgrep as well. In order to
-            make '.' match '\n', you must enable the "dot all" flag inside the regex.
-            For example, both '(?s).' and '(?s:.)' have the same semantics, where '.' will
-            match any character, including '\n'. Alternatively, the '--multiline-dotall'
-            flag may be passed to make the "dot all" behavior the default. This flag only
-            applies when multiline search is enabled.
-            There is no limit on the number of the lines that a single match can span.
-            **WARNING**: Because of how the underlying regex engine works, multiline
-            searches may be slower than normal line-oriented searches, and they may also
-            use more memory. In particular, when multiline mode is enabled, ripgrep
-            requires that each file it searches is laid out contiguously in memory
-            (either by reading it onto the heap or by memory-mapping it). Things that
-            cannot be memory-mapped (such as stdin) will be consumed until EOF before
-            searching can begin. In general, ripgrep will only do these things when
-            necessary. Specifically, if the --multiline flag is provided but the regex
-            does not contain patterns that would match '\n' characters, then ripgrep
-            will automatically avoid reading each file into memory before searching it.
-            Nevertheless, if you only care about matches spanning at most one line, then it
-            is always better to disable multiline mode.
-            This flag can be disabled with --no-multiline.
-        --multiline-dotall
-            This flag enables "dot all" in your regex pattern, which causes '.' to match
-            newlines when multiline searching is enabled. This flag has no effect if
-            multiline searching isn't enabled with the --multiline flag.
-            Normally, a '.' will match any character except newlines. While this behavior
-            typically isn't relevant for line-oriented matching (since matches can span at
-            most one line), this can be useful when searching with the -U/--multiline flag.
-            By default, the multiline mode runs without this flag.
-            This flag is generally intended to be used in an alias or your ripgrep config
-            file if you prefer "dot all" semantics by default. Note that regardless of
-            whether this flag is used, "dot all" semantics can still be controlled via
-            inline flags in the regex pattern itself, e.g., '(?s:.)' always enables "dot
-            all" whereas '(?-s:.)' always disables "dot all".
-            This flag can be disabled with --no-multiline-dotall.
-        --no-config
-            Never read configuration files. When this flag is present, ripgrep will not
-            respect the RIPGREP_CONFIG_PATH environment variable.
-            If ripgrep ever grows a feature to automatically read configuration files in
-            pre-defined locations, then this flag will also disable that behavior as well.
-    -I, --no-filename
-            Never print the file path with the matched lines. This is the default when
-            ripgrep is explicitly instructed to search one file or stdin.
-            This flag overrides --with-filename.
-        --no-heading
-            Don't group matches by each file. If --no-heading is provided in addition to
-            the -H/--with-filename flag, then file paths will be printed as a prefix for
-            every matched line. This is the default mode when not printing to a terminal.
-            This overrides the --heading flag.
-        --no-ignore
-            Don't respect ignore files (.gitignore, .ignore, etc.). This implies
-            --no-ignore-dot, --no-ignore-exclude, --no-ignore-global, no-ignore-parent and
-            --no-ignore-vcs.
-            This does *not* imply --no-ignore-files, since --ignore-file is specified
-            explicitly as a command line argument.
-            When given only once, the -u flag is identical in behavior to --no-ignore and
-            can be considered an alias. However, subsequent -u flags have additional
-            effects; see --unrestricted.
-            This flag can be disabled with the --ignore flag.
-        --no-ignore-dot
-            Don't respect .ignore files.
-            This does *not* affect whether ripgrep will ignore files and directories
-            whose names begin with a dot. For that, see the -./--hidden flag.
-            This flag can be disabled with the --ignore-dot flag.
-        --no-ignore-exclude
-            Don't respect ignore files that are manually configured for the repository
-            such as git's '.git/info/exclude'.
-            This flag can be disabled with the --ignore-exclude flag.
-        --no-ignore-files
-            When set, any --ignore-file flags, even ones that come after this flag, are
-            ignored.
-            This flag can be disabled with the --ignore-files flag.
-        --no-ignore-global
-            Don't respect ignore files that come from "global" sources such as git's
-            `core.excludesFile` configuration option (which defaults to
-            `$HOME/.config/git/ignore`).
-            This flag can be disabled with the --ignore-global flag.
-        --no-ignore-messages
-            Suppresses all error messages related to parsing ignore files such as .ignore
-            or .gitignore.
-            This flag can be disabled with the --ignore-messages flag.
-        --no-ignore-parent
-            Don't respect ignore files (.gitignore, .ignore, etc.) in parent directories.
-            This flag can be disabled with the --ignore-parent flag.
-        --no-ignore-vcs
-            Don't respect version control ignore files (.gitignore, etc.). This implies
-            --no-ignore-parent for VCS files. Note that .ignore files will continue to be
-            respected.
-            This flag can be disabled with the --ignore-vcs flag.
-    -N, --no-line-number
-            Suppress line numbers. This is enabled by default when not searching in a
-            terminal.
-        --no-messages
-            Suppress all error messages related to opening and reading files. Error
-            messages related to the syntax of the pattern given are still shown.
-            This flag can be disabled with the --messages flag.
-        --no-mmap
-            Never use memory maps, even when they might be faster.
-            This flag overrides --mmap.
-        --no-pcre2-unicode
-            DEPRECATED. Use --no-unicode instead.
-            This flag is now an alias for --no-unicode. And --pcre2-unicode is an alias
-            for --unicode.
-        --no-require-git
-            By default, ripgrep will only respect global gitignore rules, .gitignore rules
-            and local exclude rules if ripgrep detects that you are searching inside a
-            git repository. This flag allows you to relax this restriction such that
-            ripgrep will respect all git related ignore rules regardless of whether you're
-            searching in a git repository or not.
-            This flag can be disabled with --require-git.
-        --no-unicode
-            By default, ripgrep will enable "Unicode mode" in all of its regexes. This
-            has a number of consequences:
-            * '.' will only match valid UTF-8 encoded scalar values.
-            * Classes like '\w', '\s', '\d' are all Unicode aware and much bigger
-              than their ASCII only versions.
-            * Case insensitive matching will use Unicode case folding.
-            * A large array of classes like '\p{Emoji}' are available.
-            * Word boundaries ('\b' and '\B') use the Unicode definition of a word
-              character.
-            In some cases it can be desirable to turn these things off. The --no-unicode
-            flag will do exactly that.
-            For PCRE2 specifically, Unicode mode represents a critical trade off in the
-            user experience of ripgrep. In particular, unlike the default regex engine,
-            PCRE2 does not support the ability to search possibly invalid UTF-8 with
-            Unicode features enabled. Instead, PCRE2 *requires* that everything it searches
-            when Unicode mode is enabled is valid UTF-8. (Or valid UTF-16/UTF-32, but for
-            the purposes of ripgrep, we only discuss UTF-8.) This means that if you have
-            PCRE2's Unicode mode enabled and you attempt to search invalid UTF-8, then
-            the search for that file will halt and print an error. For this reason, when
-            PCRE2's Unicode mode is enabled, ripgrep will automatically "fix" invalid
-            UTF-8 sequences by replacing them with the Unicode replacement codepoint. This
-            penalty does not occur when using the default regex engine.
-            If you would rather see the encoding errors surfaced by PCRE2 when Unicode mode
-            is enabled, then pass the --no-encoding flag to disable all transcoding.
-            The --no-unicode flag can be disabled with --unicode. Note that
-            --no-pcre2-unicode and --pcre2-unicode are aliases for --no-unicode and
-            --unicode, respectively.
-    -0, --null
-            Whenever a file path is printed, follow it with a NUL byte. This includes
-            printing file paths before matches, and when printing a list of matching files
-            such as with --count, --files-with-matches and --files. This option is useful
-            for use with xargs.
-        --null-data
-            Enabling this option causes ripgrep to use NUL as a line terminator instead of
-            the default of '\n'.
-            This is useful when searching large binary files that would otherwise have very
-            long lines if '\n' were used as the line terminator. In particular, ripgrep
-            requires that, at a minimum, each line must fit into memory. Using NUL instead
-            can be a useful stopgap to keep memory requirements low and avoid OOM (out of
-            memory) conditions.
-            This is also useful for processing NUL delimited data, such as that emitted
-            when using ripgrep's -0/--null flag or find's --print0 flag.
-            Using this flag implies -a/--text.
-        --one-file-system
-            When enabled, ripgrep will not cross file system boundaries relative to where
-            the search started from.
-            Note that this applies to each path argument given to ripgrep. For example, in
-            the command 'rg --one-file-system /foo/bar /quux/baz', ripgrep will search both
-            '/foo/bar' and '/quux/baz' even if they are on different file systems, but will
-            not cross a file system boundary when traversing each path's directory tree.
-            This is similar to find's '-xdev' or '-mount' flag.
-            This flag can be disabled with --no-one-file-system.
-    -o, --only-matching
-            Print only the matched (non-empty) parts of a matching line, with each such
-            part on a separate output line.
-        --passthru
-            Print both matching and non-matching lines.
-            Another way to achieve a similar effect is by modifying your pattern to match
-            the empty string. For example, if you are searching using 'rg foo' then using
-            'rg "^|foo"' instead will emit every line in every file searched, but only
-            occurrences of 'foo' will be highlighted. This flag enables the same behavior
-            without needing to modify the pattern.
-            This overrides the --context, --after-context and --before-context flags.
-        --path-separator <SEPARATOR>
-            Set the path separator to use when printing file paths. This defaults to your
-            platform's path separator, which is / on Unix and \ on Windows. This flag is
-            intended for overriding the default when the environment demands it (e.g.,
-            cygwin). A path separator is limited to a single byte.
-    -P, --pcre2
-            When this flag is present, ripgrep will use the PCRE2 regex engine instead of
-            its default regex engine.
-            This is generally useful when you want to use features such as look-around
-            or backreferences.
-            Note that PCRE2 is an optional ripgrep feature. If PCRE2 wasn't included in
-            your build of ripgrep, then using this flag will result in ripgrep printing
-            an error message and exiting. PCRE2 may also have worse user experience in
-            some cases, since it has fewer introspection APIs than ripgrep's default regex
-            engine. For example, if you use a '\n' in a PCRE2 regex without the
-            '-U/--multiline' flag, then ripgrep will silently fail to match anything
-            instead of reporting an error immediately (like it does with the default
-            regex engine).
-            Related flags: --no-pcre2-unicode
-            This flag can be disabled with --no-pcre2.
-        --pcre2-version
-            When this flag is present, ripgrep will print the version of PCRE2 in use,
-            along with other information, and then exit. If PCRE2 is not available, then
-            ripgrep will print an error message and exit with an error code.
-        --pre <COMMAND>
-            For each input FILE, search the standard output of COMMAND FILE rather than the
-            contents of FILE. This option expects the COMMAND program to either be an
-            absolute path or to be available in your PATH. Either an empty string COMMAND
-            or the '--no-pre' flag will disable this behavior.
-                WARNING: When this flag is set, ripgrep will unconditionally spawn a
-                process for every file that is searched. Therefore, this can incur an
-                unnecessarily large performance penalty if you don't otherwise need the
-                flexibility offered by this flag. One possible mitigation to this is to use
-                the '--pre-glob' flag to limit which files a preprocessor is run with.
-            A preprocessor is not run when ripgrep is searching stdin.
-            When searching over sets of files that may require one of several decoders
-            as preprocessors, COMMAND should be a wrapper program or script which first
-            classifies FILE based on magic numbers/content or based on the FILE name and
-            then dispatches to an appropriate preprocessor. Each COMMAND also has its
-            standard input connected to FILE for convenience.
-            For example, a shell script for COMMAND might look like:
-                case "$1" in
-                *.pdf)
-                    exec pdftotext "$1" -
-                    ;;
-                *)
-                    case $(file "$1") in
-                    *Zstandard*)
-                        exec pzstd -cdq
-                        ;;
-                    *)
-                        exec cat
-                        ;;
-                    esac
-                    ;;
-                esac
-            The above script uses `pdftotext` to convert a PDF file to plain text. For
-            all other files, the script uses the `file` utility to sniff the type of the
-            file based on its contents. If it is a compressed file in the Zstandard format,
-            then `pzstd` is used to decompress the contents to stdout.
-            This overrides the -z/--search-zip flag.
-        --pre-glob <GLOB>...
-            This flag works in conjunction with the --pre flag. Namely, when one or more
-            --pre-glob flags are given, then only files that match the given set of globs
-            will be handed to the command specified by the --pre flag. Any non-matching
-            files will be searched without using the preprocessor command.
-            This flag is useful when searching many files with the --pre flag. Namely,
-            it permits the ability to avoid process overhead for files that don't need
-            preprocessing. For example, given the following shell script, 'pre-pdftotext':
-                #!/bin/sh
-                pdftotext "$1" -
-            then it is possible to use '--pre pre-pdftotext --pre-glob '*.pdf'' to make
-            it so ripgrep only executes the 'pre-pdftotext' command on files with a '.pdf'
-            extension.
-            Multiple --pre-glob flags may be used. Globbing rules match .gitignore globs.
-            Precede a glob with a ! to exclude it.
-            This flag has no effect if the --pre flag is not used.
-    -p, --pretty
-            This is a convenience alias for '--color always --heading --line-number'. This
-            flag is useful when you still want pretty output even if you're piping ripgrep
-            to another program or file. For example: 'rg -p foo | less -R'.
-    -q, --quiet
-            Do not print anything to stdout. If a match is found in a file, then ripgrep
-            will stop searching. This is useful when ripgrep is used only for its exit
-            code (which will be an error if no matches are found).
-            When --files is used, then ripgrep will stop finding files after finding the
-            first file that matches all ignore rules.
-        --regex-size-limit <NUM+SUFFIX?>
-            The upper size limit of the compiled regex. The default limit is 10M.
-            The argument accepts the same size suffixes as allowed in the --max-filesize
-            flag.
-    -e, --regexp <PATTERN>...
-            A pattern to search for. This option can be provided multiple times, where
-            all patterns given are searched. Lines matching at least one of the provided
-            patterns are printed. This flag can also be used when searching for patterns
-            that start with a dash.
-            For example, to search for the literal '-foo', you can use this flag:
-                rg -e -foo
-            You can also use the special '--' delimiter to indicate that no more flags
-            will be provided. Namely, the following is equivalent to the above:
-                rg -- -foo
-    -r, --replace <REPLACEMENT_TEXT>
-            Replace every match with the text given when printing results. Neither this
-            flag nor any other ripgrep flag will modify your files.
-            Capture group indices (e.g., $5) and names (e.g., $foo) are supported in the
-            replacement string. Capture group indices are numbered based on the position of
-            the opening parenthesis of the group, where the leftmost such group is $1. The
-            special $0 group corresponds to the entire match.
-            In shells such as Bash and zsh, you should wrap the pattern in single quotes
-            instead of double quotes. Otherwise, capture group indices will be replaced by
-            expanded shell variables which will most likely be empty.
-            To write a literal '$', use '$$'.
-            Note that the replacement by default replaces each match, and NOT the entire
-            line. To replace the entire line, you should match the entire line.
-            This flag can be used with the -o/--only-matching flag.
-    -z, --search-zip
-            Search in compressed files. Currently gzip, bzip2, xz, LZ4, LZMA, Brotli and
-            Zstd files are supported. This option expects the decompression binaries to be
-            available in your PATH.
-            This flag can be disabled with --no-search-zip.
-    -S, --smart-case
-            Searches case insensitively if the pattern is all lowercase. Search case
-            sensitively otherwise.
-            A pattern is considered all lowercase if both of the following rules hold:
-            First, the pattern contains at least one literal character. For example, 'a\w'
-            contains a literal ('a') but just '\w' does not.
-            Second, of the literals in the pattern, none of them are considered to be
-            uppercase according to Unicode. For example, 'foo\pL' has no uppercase
-            literals but 'Foo\pL' does.
-            This overrides the -s/--case-sensitive and -i/--ignore-case flags.
-        --sort <SORTBY>
-            This flag enables sorting of results in ascending order. The possible values
-            for this flag are:
-                none      (Default) Do not sort results. Fastest. Can be multi-threaded.
-                path      Sort by file path. Always single-threaded.
-                modified  Sort by the last modified time on a file. Always single-threaded.
-                accessed  Sort by the last accessed time on a file. Always single-threaded.
-                created   Sort by the creation time on a file. Always single-threaded.
-            If the chosen (manually or by-default) sorting criteria isn't available on your
-            system (for example, creation time is not available on ext4 file systems), then
-            ripgrep will attempt to detect this, print an error and exit without searching.
-            To sort results in reverse or descending order, use the --sortr flag. Also,
-            this flag overrides --sortr.
-            Note that sorting results currently always forces ripgrep to abandon
-            parallelism and run in a single thread.
-        --sortr <SORTBY>
-            This flag enables sorting of results in descending order. The possible values
-            for this flag are:
-                none      (Default) Do not sort results. Fastest. Can be multi-threaded.
-                path      Sort by file path. Always single-threaded.
-                modified  Sort by the last modified time on a file. Always single-threaded.
-                accessed  Sort by the last accessed time on a file. Always single-threaded.
-                created   Sort by the creation time on a file. Always single-threaded.
-            If the chosen (manually or by-default) sorting criteria isn't available on your
-            system (for example, creation time is not available on ext4 file systems), then
-            ripgrep will attempt to detect this, print an error and exit without searching.
-            To sort results in ascending order, use the --sort flag. Also, this flag
-            overrides --sort.
-            Note that sorting results currently always forces ripgrep to abandon
-            parallelism and run in a single thread.
-        --stats
-            Print aggregate statistics about this ripgrep search. When this flag is
-            present, ripgrep will print the following stats to stdout at the end of the
-            search: number of matched lines, number of files with matches, number of files
-            searched, and the time taken for the entire search to complete.
-            This set of aggregate statistics may expand over time.
-            Note that this flag has no effect if --files, --files-with-matches or
-            --files-without-match is passed.
-            This flag can be disabled with --no-stats.
-    -a, --text
-            Search binary files as if they were text. When this flag is present, ripgrep's
-            binary file detection is disabled. This means that when a binary file is
-            searched, its contents may be printed if there is a match. This may cause
-            escape codes to be printed that alter the behavior of your terminal.
-            When binary file detection is enabled it is imperfect. In general, it uses
-            a simple heuristic. If a NUL byte is seen during search, then the file is
-            considered binary and search stops (unless this flag is present).
-            Alternatively, if the '--binary' flag is used, then ripgrep will only quit
-            when it sees a NUL byte after it sees a match (or searches the entire file).
-            This flag can be disabled with '--no-text'. It overrides the '--binary' flag.
-    -j, --threads <NUM>
-            The approximate number of threads to use. A value of 0 (which is the default)
-            causes ripgrep to choose the thread count using heuristics.
-        --trim
-            When set, all ASCII whitespace at the beginning of each line printed will be
-            trimmed.
-            This flag can be disabled with --no-trim.
-    -t, --type <TYPE>...
-            Only search files matching TYPE. Multiple type flags may be provided. Use the
-            --type-list flag to list all available types.
-            This flag supports the special value 'all', which will behave as if --type
-            was provided for every file type supported by ripgrep (including any custom
-            file types). The end result is that '--type all' causes ripgrep to search in
-            "whitelist" mode, where it will only search files it recognizes via its type
-            definitions.
-        --type-add <TYPE_SPEC>...
-            Add a new glob for a particular file type. Only one glob can be added at a
-            time. Multiple --type-add flags can be provided. Unless --type-clear is used,
-            globs are added to any existing globs defined inside of ripgrep.
-            Note that this MUST be passed to every invocation of ripgrep. Type settings are
-            NOT persisted. See CONFIGURATION FILES for a workaround.
-            Example:
-                rg --type-add 'foo:*.foo' -tfoo PATTERN.
-            --type-add can also be used to include rules from other types with the special
-            include directive. The include directive permits specifying one or more other
-            type names (separated by a comma) that have been defined and its rules will
-            automatically be imported into the type specified. For example, to create a
-            type called src that matches C++, Python and Markdown files, one can use:
-                --type-add 'src:include:cpp,py,md'
-            Additional glob rules can still be added to the src type by using the
-            --type-add flag again:
-                --type-add 'src:include:cpp,py,md' --type-add 'src:*.foo'
-            Note that type names must consist only of Unicode letters or numbers.
-            Punctuation characters are not allowed.
-        --type-clear <TYPE>...
-            Clear the file type globs previously defined for TYPE. This only clears the
-            default type definitions that are found inside of ripgrep.
-            Note that this MUST be passed to every invocation of ripgrep. Type settings are
-            NOT persisted. See CONFIGURATION FILES for a workaround.
-        --type-list
-            Show all supported file types and their corresponding globs.
-    -T, --type-not <TYPE>...
-            Do not search files matching TYPE. Multiple type-not flags may be provided. Use
-            the --type-list flag to list all available types.
-    -u, --unrestricted
-            Reduce the level of "smart" searching. A single -u won't respect .gitignore
-            (etc.) files (--no-ignore). Two -u flags will additionally search hidden files
-            and directories (-./--hidden). Three -u flags will additionally search binary
-            files (--binary).
-            'rg -uuu' is roughly equivalent to 'grep -r'.
-    -V, --version
-            Prints version information
-        --vimgrep
-            Show results with every match on its own line, including line numbers and
-            column numbers. With this option, a line with more than one match will be
-            printed more than once.
-    -H, --with-filename
-            Display the file path for matches. This is the default when more than one
-            file is searched. If --heading is enabled (the default when printing to a
-            terminal), the file path will be shown above clusters of matches from each
-            file; otherwise, the file name will be shown as a prefix for each matched line.
-            This flag overrides --no-filename.
-    -w, --word-regexp
-            Only show matches surrounded by word boundaries. This is roughly equivalent to
-            putting \b before and after all of the search patterns.
-            This overrides the --line-regexp flag.