cmd2.pt_utils

def get_completions(self, document: Document, _complete_event: object) -> Iterable[Completion]:
    """Get completions for the current input."""
    # Find the beginning of the current word based on delimiters
    line = document.text
    cursor_pos = document.cursor_position

    # Define delimiters for completion to match cmd2/readline behavior
    delimiters = BASE_DELIMITERS
    delimiters += "".join(self._cmd_app.statement_parser.terminators)

    # Find last delimiter before cursor to determine the word being completed
    begidx = 0
    for i in range(cursor_pos - 1, -1, -1):
        if line[i] in delimiters:
            begidx = i + 1
            break

    endidx = cursor_pos
    text = line[begidx:endidx]

    completions = self._cmd_app.complete(
        text, line=line, begidx=begidx, endidx=endidx, custom_settings=self.custom_settings
    )

    if completions.error:
        print_formatted_text(pt_filter_style(completions.error))
        return

    # Print completion table if present
    if completions.table is not None:
        console = ru.Cmd2GeneralConsole(file=self._cmd_app.stdout)
        with console.capture() as capture:
            console.print(completions.table, end="", soft_wrap=False)
        print_formatted_text(pt_filter_style("\n" + capture.get()))

    if not completions:
        # Print hint if present
        if completions.hint:
            print_formatted_text(pt_filter_style(completions.hint))
        return

    # The length of the user's input minus any shortcut.
    search_text_length = len(text) - completions._search_text_offset

    # If matches require quoting but the word isn't quoted yet, we insert the
    # opening quote directly into the buffer. We do this because if any completions
    # change text before the cursor (like prepending a quote), prompt-toolkit will
    # not return a common prefix to the command line. By modifying the buffer
    # and returning early, we trigger a new completion cycle where the quote
    # is already present, allowing for proper common prefix calculation.
    if completions._add_opening_quote and search_text_length > 0:
        buffer = get_app().current_buffer

        buffer.cursor_left(search_text_length)
        buffer.insert_text(completions._quote_char)
        buffer.cursor_right(search_text_length)
        return

    # Return the completions
    for item in completions:
        # Set offset to the start of the current word to overwrite it with the completion
        start_position = -len(text)
        match_text = item.text

        # If we need a quote but didn't interrupt (because text was empty),
        # prepend the quote here so it's included in the insertion.
        if completions._add_opening_quote:
            match_text = (
                match_text[: completions._search_text_offset]
                + completions._quote_char
                + match_text[completions._search_text_offset :]
            )

        # Finalize if there's only one match
        if len(completions) == 1 and completions.allow_finalization:
            # Close any open quote
            if completions._quote_char:
                match_text += completions._quote_char

            # Add trailing space if the cursor is at the end of the line
            if endidx == len(line):
                match_text += " "

        yield Completion(
            match_text,
            start_position=start_position,
            display=pt_filter_style(item.display),
            display_meta=pt_filter_style(item.display_meta),
        )

def append_string(self, string: str) -> None:
    """Override to filter our consecutive duplicates."""
    # History is sorted newest to oldest, so we compare to the first element.
    if string and (not self._loaded_strings or self._loaded_strings[0] != string):
        super().append_string(string)

def store_string(self, string: str) -> None:
    """No-op: Persistent history data is stored in cmd2.Cmd.history."""

def load_history_strings(self) -> Iterable[str]:
    """Yield strings from newest to oldest."""
    yield from self._loaded_strings

def clear(self) -> None:
    """Clear the UI history navigation data."""
    self._loaded_strings.clear()

def lex_document(self, document: Document) -> Callable[[int], Any]:
    """Lex the document."""
    # Get redirection tokens and terminators to avoid highlighting them as values
    exclude_tokens = set(constants.REDIRECTION_TOKENS)
    exclude_tokens.update(self._cmd_app.statement_parser.terminators)
    arg_pattern = re.compile(r'(\s+)|(--?[^\s\'"]+)|("[^"]*"?|\'[^\']*\'?)|([^\s\'"]+)')

    def highlight_args(text: str, tokens: list[tuple[str, str]]) -> None:
        """Highlight arguments in a string."""
        for m in arg_pattern.finditer(text):
            space, flag, quoted, word = m.groups()
            match_text = m.group(0)

            if space:
                tokens.append(("", match_text))
            elif flag:
                tokens.append((self.FLAG_STYLE, match_text))
            elif (quoted or word) and match_text not in exclude_tokens:
                tokens.append((self.ARGUMENT_STYLE, match_text))
            else:
                tokens.append(("", match_text))

    def get_line(lineno: int) -> list[tuple[str, str]]:
        """Return the tokens for the given line number."""
        line = document.lines[lineno]
        tokens: list[tuple[str, str]] = []

        # No syntax highlighting if styles are disallowed
        if ru.ALLOW_STYLE == ru.AllowStyle.NEVER:
            tokens.append(("", line))
            return tokens

        # Only attempt to match a command on the first line
        if lineno == 0:
            # Use cmd2's command pattern to find the first word (the command)
            match = self._cmd_app.statement_parser._command_pattern.search(line)
            if match:
                # Group 1 is the command, Group 2 is the character(s) that terminated the command match
                command = match.group(1)
                cmd_start = match.start(1)
                cmd_end = match.end(1)

                # Add any leading whitespace
                if cmd_start > 0:
                    tokens.append(("", line[:cmd_start]))

                if command:
                    # Determine the style for the command
                    shortcut_found = False
                    for shortcut, _ in self._cmd_app.statement_parser.shortcuts:
                        if command.startswith(shortcut):
                            # Add the shortcut with the command style
                            tokens.append((self.COMMAND_STYLE, shortcut))

                            # If there's more in the command word, it's an argument
                            if len(command) > len(shortcut):
                                tokens.append((self.ARGUMENT_STYLE, command[len(shortcut) :]))

                            shortcut_found = True
                            break

                    if not shortcut_found:
                        style = ""
                        if command in self._cmd_app.get_all_commands():
                            style = self.COMMAND_STYLE
                        elif command in self._cmd_app.aliases:
                            style = self.ALIAS_STYLE
                        elif command in self._cmd_app.macros:
                            style = self.MACRO_STYLE

                        # Add the command with the determined style
                        tokens.append((style, command))

                # Add the rest of the line as arguments
                if cmd_end < len(line):
                    highlight_args(line[cmd_end:], tokens)
            else:
                # No command match found on the first line
                tokens.append(("", line))
        else:
            # All other lines are treated as arguments
            highlight_args(line, tokens)

        return tokens

    return get_line