cmd2 2.4.2__py3-none-any.whl → 2.5.9__py3-none-any.whl

cmd2/cmd2.py

@@ -21,6 +21,7 @@ is used in place of `print`.
 
 Git repository on GitHub at https://github.com/python-cmd2/cmd2
 """
+
 # This module has many imports, quite a few of which are only
 # infrequently utilized. To reduce the initial overhead of
 # import this module, many of these imports are lazy-loaded
@@ -30,6 +31,7 @@ Git repository on GitHub at https://github.com/python-cmd2/cmd2
 # setting is True
 import argparse
 import cmd
+import copy
 import functools
 import glob
 import inspect
@@ -37,6 +39,7 @@ import os
 import pydoc
 import re
 import sys
+import tempfile
 import threading
 from code import (
     InteractiveConsole,
@@ -53,6 +56,8 @@ from types import (
     ModuleType,
 )
 from typing import (
+    IO,
+    TYPE_CHECKING,
     Any,
     Callable,
     Dict,
@@ -83,7 +88,6 @@ from .argparse_custom import (
     CompletionItem,
 )
 from .clipboard import (
-    can_clip,
     get_paste_buffer,
     write_to_paste_buffer,
 )
@@ -98,6 +102,7 @@ from .constants import (
     HELP_FUNC_PREFIX,
 )
 from .decorators import (
+    CommandParent,
     as_subcommand_to,
     with_argparser,
 )
@@ -114,6 +119,7 @@ from .exceptions import (
 from .history import (
     History,
     HistoryItem,
+    single_line_format,
 )
 from .parsing import (
     Macro,
@@ -122,11 +128,20 @@ from .parsing import (
     StatementParser,
     shlex_split,
 )
+
+# NOTE: When using gnureadline with Python 3.13, start_ipython needs to be imported before any readline-related stuff
+try:
+    from IPython import start_ipython  # type: ignore[import]
+except ImportError:
+    pass
+
 from .rl_utils import (
     RlType,
     rl_escape_prompt,
+    rl_get_display_prompt,
     rl_get_point,
     rl_get_prompt,
+    rl_in_search_mode,
     rl_set_prompt,
     rl_type,
     rl_warning,
@@ -140,6 +155,7 @@ from .utils import (
     Settable,
     get_defining_class,
     strip_doc_annotations,
+    suggest_similar,
 )
 
 # Set up readline
@@ -155,13 +171,10 @@ else:
     orig_rl_delims = readline.get_completer_delims()
 
     if rl_type == RlType.PYREADLINE:
-
         # Save the original pyreadline3 display completion function since we need to override it and restore it
-        # noinspection PyProtectedMember,PyUnresolvedReferences
         orig_pyreadline_display = readline.rl.mode._display_completions
 
     elif rl_type == RlType.GNU:
-
         # Get the readline lib so we can make changes to it
         import ctypes
 
@@ -197,6 +210,89 @@ class _SavedCmd2Env:
 DisabledCommand = namedtuple('DisabledCommand', ['command_function', 'help_function', 'completer_function'])
 
 
+if TYPE_CHECKING:  # pragma: no cover
+    StaticArgParseBuilder = staticmethod[[], argparse.ArgumentParser]
+    ClassArgParseBuilder = classmethod[Union['Cmd', CommandSet], [], argparse.ArgumentParser]
+else:
+    StaticArgParseBuilder = staticmethod
+    ClassArgParseBuilder = classmethod
+
+
+class _CommandParsers:
+    """
+    Create and store all command method argument parsers for a given Cmd instance.
+
+    Parser creation and retrieval are accomplished through the get() method.
+    """
+
+    def __init__(self, cmd: 'Cmd') -> None:
+        self._cmd = cmd
+
+        # Keyed by the fully qualified method names. This is more reliable than
+        # the methods themselves, since wrapping a method will change its address.
+        self._parsers: Dict[str, argparse.ArgumentParser] = {}
+
+    @staticmethod
+    def _fully_qualified_name(command_method: CommandFunc) -> str:
+        """Return the fully qualified name of a method or None if a method wasn't passed in."""
+        try:
+            return f"{command_method.__module__}.{command_method.__qualname__}"
+        except AttributeError:
+            return ""
+
+    def __contains__(self, command_method: CommandFunc) -> bool:
+        """
+        Return whether a given method's parser is in self.
+
+        If the parser does not yet exist, it will be created if applicable.
+        This is basically for checking if a method is argarse-based.
+        """
+        parser = self.get(command_method)
+        return bool(parser)
+
+    def get(self, command_method: CommandFunc) -> Optional[argparse.ArgumentParser]:
+        """
+        Return a given method's parser or None if the method is not argparse-based.
+
+        If the parser does not yet exist, it will be created.
+        """
+        full_method_name = self._fully_qualified_name(command_method)
+        if not full_method_name:
+            return None
+
+        if full_method_name not in self._parsers:
+            if not command_method.__name__.startswith(COMMAND_FUNC_PREFIX):
+                return None
+            command = command_method.__name__[len(COMMAND_FUNC_PREFIX) :]
+
+            parser_builder = getattr(command_method, constants.CMD_ATTR_ARGPARSER, None)
+            parent = self._cmd.find_commandset_for_command(command) or self._cmd
+            parser = self._cmd._build_parser(parent, parser_builder)
+            if parser is None:
+                return None
+
+            # argparser defaults the program name to sys.argv[0], but we want it to be the name of our command
+            from .decorators import (
+                _set_parser_prog,
+            )
+
+            _set_parser_prog(parser, command)
+
+            # If the description has not been set, then use the method docstring if one exists
+            if parser.description is None and hasattr(command_method, '__wrapped__') and command_method.__wrapped__.__doc__:
+                parser.description = strip_doc_annotations(command_method.__wrapped__.__doc__)
+
+            self._parsers[full_method_name] = parser
+
+        return self._parsers.get(full_method_name)
+
+    def remove(self, command_method: CommandFunc) -> None:
+        """Remove a given method's parser if it exists."""
+        full_method_name = self._fully_qualified_name(command_method)
+        if full_method_name in self._parsers:
+            del self._parsers[full_method_name]
+
+
 class Cmd(cmd.Cmd):
     """An easy but powerful framework for writing line-oriented command interpreters.
 
@@ -209,7 +305,7 @@ class Cmd(cmd.Cmd):
     DEFAULT_EDITOR = utils.find_editor()
 
     INTERNAL_COMMAND_EPILOG = (
-        "Notes:\n" "  This command is for internal use and is not intended to be called from the\n" "  command line."
+        "Notes:\n  This command is for internal use and is not intended to be called from the\n  command line."
     )
 
     # Sorting keys for strings
@@ -236,6 +332,8 @@ class Cmd(cmd.Cmd):
         shortcuts: Optional[Dict[str, str]] = None,
         command_sets: Optional[Iterable[CommandSet]] = None,
         auto_load_commands: bool = True,
+        allow_clipboard: bool = True,
+        suggest_similar_command: bool = False,
     ) -> None:
         """An easy but powerful framework for writing line-oriented command
         interpreters. Extends Python's cmd package.
@@ -251,7 +349,7 @@ class Cmd(cmd.Cmd):
                                        suppressed. Anything written to stderr will still display.
         :param include_py: should the "py" command be included for an embedded Python shell
         :param include_ipy: should the "ipy" command be included for an embedded IPython shell
-        :param allow_cli_args: if ``True``, then :meth:`cmd2.Cmd.__init__` will process command
+        :param allow_cli_args: if ``True``, then [cmd2.Cmd.__init__][] will process command
                                line arguments as either commands to be run or, if ``-t`` or
                                ``--test`` are given, transcript files to run. This should be
                                set to ``False`` if your application parses its own command line
@@ -283,6 +381,10 @@ class Cmd(cmd.Cmd):
                                    that are currently loaded by Python and automatically
                                    instantiate and register all commands. If False, CommandSets
                                    must be manually installed with `register_command_set`.
+        :param allow_clipboard: If False, cmd2 will disable clipboard interactions
+        :param suggest_similar_command: If ``True``, ``cmd2`` will attempt to suggest the most
+                                        similar command when the user types a command that does
+                                        not exist. Default: ``False``.
         """
         # Check if py or ipy need to be disabled in this instance
         if not include_py:
@@ -308,6 +410,7 @@ class Cmd(cmd.Cmd):
         self.editor = Cmd.DEFAULT_EDITOR
         self.feedback_to_output = False  # Do not include nonessentials in >, | output by default (things like timing)
         self.quiet = False  # Do not suppress nonessential output
+        self.scripts_add_to_history = True  # Scripts and pyscripts add commands to history
         self.timing = False  # Prints elapsed time for each command
 
         # The maximum number of CompletionItems to display during tab completion. If the number of completion
@@ -335,6 +438,7 @@ class Cmd(cmd.Cmd):
         self.hidden_commands = ['eof', '_relative_run_script']
 
         # Initialize history
+        self.persistent_history_file = ''
         self._persistent_history_length = persistent_history_length
         self._initialize_history(persistent_history_file)
 
@@ -389,7 +493,7 @@ class Cmd(cmd.Cmd):
         self.help_error = "No help on {}"
 
         # The error that prints when a non-existent command is run
-        self.default_error = "{} is not a recognized command, alias, or macro"
+        self.default_error = "{} is not a recognized command, alias, or macro."
 
         # If non-empty, this string will be displayed if a broken pipe error occurs
         self.broken_pipe_warning = ''
@@ -436,8 +540,8 @@ class Cmd(cmd.Cmd):
             self.pager = 'less -RXF'
             self.pager_chop = 'less -SRXF'
 
-        # This boolean flag determines whether or not the cmd2 application can interact with the clipboard
-        self._can_clip = can_clip
+        # This boolean flag stores whether cmd2 will allow clipboard related features
+        self.allow_clipboard = allow_clipboard
 
         # This determines the value returned by cmdloop() when exiting the application
         self.exit_code = 0
@@ -507,6 +611,12 @@ class Cmd(cmd.Cmd):
         # This does not affect self.formatted_completions.
         self.matches_sorted = False
 
+        # Command parsers for this Cmd instance.
+        self._command_parsers = _CommandParsers(self)
+
+        # Add functions decorated to be subcommands
+        self._register_subcommands(self)
+
         ############################################################################################################
         # The following code block loads CommandSets, verifies command names, and registers subcommands.
         # This block should appear after all attributes have been created since the registration code
@@ -526,8 +636,11 @@ class Cmd(cmd.Cmd):
             if not valid:
                 raise ValueError(f"Invalid command name '{cur_cmd}': {errmsg}")
 
-        # Add functions decorated to be subcommands
-        self._register_subcommands(self)
+        self.suggest_similar_command = suggest_similar_command
+        self.default_suggestion_message = "Did you mean {}?"
+
+        # the current command being executed
+        self.current_command: Optional[Statement] = None
 
     def find_commandsets(self, commandset_type: Type[CommandSet], *, subclass_match: bool = False) -> List[CommandSet]:
         """
@@ -541,7 +654,7 @@ class Cmd(cmd.Cmd):
         return [
             cmdset
             for cmdset in self._installed_command_sets
-            if type(cmdset) == commandset_type or (subclass_match and isinstance(cmdset, commandset_type))
+            if type(cmdset) == commandset_type or (subclass_match and isinstance(cmdset, commandset_type))  # noqa: E721
         ]
 
     def find_commandset_for_command(self, command_name: str) -> Optional[CommandSet]:
@@ -601,22 +714,25 @@ class Cmd(cmd.Cmd):
                     raise CommandSetRegistrationError(f'Duplicate settable {key} is already registered')
 
         cmdset.on_register(self)
-        methods = inspect.getmembers(
-            cmdset,
-            predicate=lambda meth: isinstance(meth, Callable)  # type: ignore[arg-type]
-            and hasattr(meth, '__name__')
-            and meth.__name__.startswith(COMMAND_FUNC_PREFIX),
+        methods = cast(
+            List[Tuple[str, Callable[..., Any]]],
+            inspect.getmembers(
+                cmdset,
+                predicate=lambda meth: isinstance(meth, Callable)  # type: ignore[arg-type]
+                and hasattr(meth, '__name__')
+                and meth.__name__.startswith(COMMAND_FUNC_PREFIX),
+            ),
         )
 
         default_category = getattr(cmdset, CLASS_ATTR_DEFAULT_HELP_CATEGORY, None)
 
         installed_attributes = []
         try:
-            for method_name, method in methods:
-                command = method_name[len(COMMAND_FUNC_PREFIX) :]
+            for cmd_func_name, command_method in methods:
+                command = cmd_func_name[len(COMMAND_FUNC_PREFIX) :]
 
-                self._install_command_function(command, method, type(cmdset).__name__)
-                installed_attributes.append(method_name)
+                self._install_command_function(cmd_func_name, command_method, type(cmdset).__name__)
+                installed_attributes.append(cmd_func_name)
 
                 completer_func_name = COMPLETER_FUNC_PREFIX + command
                 cmd_completer = getattr(cmdset, completer_func_name, None)
@@ -632,8 +748,8 @@ class Cmd(cmd.Cmd):
 
                 self._cmd_to_command_sets[command] = cmdset
 
-                if default_category and not hasattr(method, constants.CMD_ATTR_HELP_CATEGORY):
-                    utils.categorize(method, default_category)
+                if default_category and not hasattr(command_method, constants.CMD_ATTR_HELP_CATEGORY):
+                    utils.categorize(command_method, default_category)
 
             self._installed_command_sets.add(cmdset)
 
@@ -650,12 +766,54 @@ class Cmd(cmd.Cmd):
             cmdset.on_unregistered()
             raise
 
-    def _install_command_function(self, command: str, command_wrapper: Callable[..., Any], context: str = '') -> None:
-        cmd_func_name = COMMAND_FUNC_PREFIX + command
+    def _build_parser(
+        self,
+        parent: CommandParent,
+        parser_builder: Optional[
+            Union[
+                argparse.ArgumentParser,
+                Callable[[], argparse.ArgumentParser],
+                StaticArgParseBuilder,
+                ClassArgParseBuilder,
+            ]
+        ],
+    ) -> Optional[argparse.ArgumentParser]:
+        parser: Optional[argparse.ArgumentParser] = None
+        if isinstance(parser_builder, staticmethod):
+            parser = parser_builder.__func__()
+        elif isinstance(parser_builder, classmethod):
+            parser = parser_builder.__func__(parent if not None else self)  # type: ignore[arg-type]
+        elif callable(parser_builder):
+            parser = parser_builder()
+        elif isinstance(parser_builder, argparse.ArgumentParser):
+            parser = copy.deepcopy(parser_builder)
+        return parser
+
+    def _install_command_function(self, command_func_name: str, command_method: CommandFunc, context: str = '') -> None:
+        """
+        Install a new command function into the CLI.
+
+        :param command_func_name: name of command function to add
+                                  This points to the command method and may differ from the method's
+                                  name if it's being used as a synonym. (e.g. do_exit = do_quit)
+        :param command_method: the actual command method which runs when the command function is called
+        :param context: optional info to provide in error message. (e.g. class this function belongs to)
+        :raises CommandSetRegistrationError: if the command function fails to install
+        """
+
+        # command_func_name must begin with COMMAND_FUNC_PREFIX to be identified as a command by cmd2.
+        if not command_func_name.startswith(COMMAND_FUNC_PREFIX):
+            raise CommandSetRegistrationError(f"{command_func_name} does not begin with '{COMMAND_FUNC_PREFIX}'")
+
+        # command_method must start with COMMAND_FUNC_PREFIX for use in self._command_parsers.
+        if not command_method.__name__.startswith(COMMAND_FUNC_PREFIX):
+            raise CommandSetRegistrationError(f"{command_method.__name__} does not begin with '{COMMAND_FUNC_PREFIX}'")
+
+        command = command_func_name[len(COMMAND_FUNC_PREFIX) :]
 
         # Make sure command function doesn't share name with existing attribute
-        if hasattr(self, cmd_func_name):
-            raise CommandSetRegistrationError(f'Attribute already exists: {cmd_func_name} ({context})')
+        if hasattr(self, command_func_name):
+            raise CommandSetRegistrationError(f'Attribute already exists: {command_func_name} ({context})')
 
         # Check if command has an invalid name
         valid, errmsg = self.statement_parser.is_valid_command(command)
@@ -672,7 +830,7 @@ class Cmd(cmd.Cmd):
             self.pwarning(f"Deleting macro '{command}' because it shares its name with a new command")
             del self.macros[command]
 
-        setattr(self, cmd_func_name, command_wrapper)
+        setattr(self, command_func_name, command_method)
 
     def _install_completer_function(self, cmd_name: str, cmd_completer: CompleterFunc) -> None:
         completer_func_name = COMPLETER_FUNC_PREFIX + cmd_name
@@ -699,67 +857,66 @@ class Cmd(cmd.Cmd):
             cmdset.on_unregister()
             self._unregister_subcommands(cmdset)
 
-            methods = inspect.getmembers(
+            methods: List[Tuple[str, Callable[..., Any]]] = inspect.getmembers(
                 cmdset,
                 predicate=lambda meth: isinstance(meth, Callable)  # type: ignore[arg-type]
                 and hasattr(meth, '__name__')
                 and meth.__name__.startswith(COMMAND_FUNC_PREFIX),
             )
 
-            for method in methods:
-                cmd_name = method[0][len(COMMAND_FUNC_PREFIX) :]
+            for cmd_func_name, command_method in methods:
+                command = cmd_func_name[len(COMMAND_FUNC_PREFIX) :]
 
                 # Enable the command before uninstalling it to make sure we remove both
                 # the real functions and the ones used by the DisabledCommand object.
-                if cmd_name in self.disabled_commands:
-                    self.enable_command(cmd_name)
+                if command in self.disabled_commands:
+                    self.enable_command(command)
 
-                if cmd_name in self._cmd_to_command_sets:
-                    del self._cmd_to_command_sets[cmd_name]
+                if command in self._cmd_to_command_sets:
+                    del self._cmd_to_command_sets[command]
 
-                delattr(self, COMMAND_FUNC_PREFIX + cmd_name)
+                # Only remove the parser if this is the actual
+                # command since command synonyms don't own it.
+                if cmd_func_name == command_method.__name__:
+                    self._command_parsers.remove(command_method)
 
-                if hasattr(self, COMPLETER_FUNC_PREFIX + cmd_name):
-                    delattr(self, COMPLETER_FUNC_PREFIX + cmd_name)
-                if hasattr(self, HELP_FUNC_PREFIX + cmd_name):
-                    delattr(self, HELP_FUNC_PREFIX + cmd_name)
+                if hasattr(self, COMPLETER_FUNC_PREFIX + command):
+                    delattr(self, COMPLETER_FUNC_PREFIX + command)
+                if hasattr(self, HELP_FUNC_PREFIX + command):
+                    delattr(self, HELP_FUNC_PREFIX + command)
+
+                delattr(self, cmd_func_name)
 
             cmdset.on_unregistered()
             self._installed_command_sets.remove(cmdset)
 
     def _check_uninstallable(self, cmdset: CommandSet) -> None:
-        methods = inspect.getmembers(
+        def check_parser_uninstallable(parser: argparse.ArgumentParser) -> None:
+            for action in parser._actions:
+                if isinstance(action, argparse._SubParsersAction):
+                    for subparser in action.choices.values():
+                        attached_cmdset = getattr(subparser, constants.PARSER_ATTR_COMMANDSET, None)
+                        if attached_cmdset is not None and attached_cmdset is not cmdset:
+                            raise CommandSetRegistrationError(
+                                'Cannot uninstall CommandSet when another CommandSet depends on it'
+                            )
+                        check_parser_uninstallable(subparser)
+                    break
+
+        methods: List[Tuple[str, Callable[..., Any]]] = inspect.getmembers(
             cmdset,
             predicate=lambda meth: isinstance(meth, Callable)  # type: ignore[arg-type]
             and hasattr(meth, '__name__')
             and meth.__name__.startswith(COMMAND_FUNC_PREFIX),
         )
 
-        for method in methods:
-            command_name = method[0][len(COMMAND_FUNC_PREFIX) :]
-
-            # Search for the base command function and verify it has an argparser defined
-            if command_name in self.disabled_commands:
-                command_func = self.disabled_commands[command_name].command_function
-            else:
-                command_func = self.cmd_func(command_name)
-
-            command_parser = cast(argparse.ArgumentParser, getattr(command_func, constants.CMD_ATTR_ARGPARSER, None))
-
-            def check_parser_uninstallable(parser: argparse.ArgumentParser) -> None:
-                for action in parser._actions:
-                    if isinstance(action, argparse._SubParsersAction):
-                        for subparser in action.choices.values():
-                            attached_cmdset = getattr(subparser, constants.PARSER_ATTR_COMMANDSET, None)
-                            if attached_cmdset is not None and attached_cmdset is not cmdset:
-                                raise CommandSetRegistrationError(
-                                    'Cannot uninstall CommandSet when another CommandSet depends on it'
-                                )
-                            check_parser_uninstallable(subparser)
-                        break
-
-            if command_parser is not None:
-                check_parser_uninstallable(command_parser)
+        for cmd_func_name, command_method in methods:
+            # We only need to check if it's safe to remove the parser if this
+            # is the actual command since command synonyms don't own it.
+            if cmd_func_name == command_method.__name__:
+                command_parser = self._command_parsers.get(command_method)
+                if command_parser is not None:
+                    check_parser_uninstallable(command_parser)
 
     def _register_subcommands(self, cmdset: Union[CommandSet, 'Cmd']) -> None:
         """
@@ -783,7 +940,7 @@ class Cmd(cmd.Cmd):
         for method_name, method in methods:
             subcommand_name: str = getattr(method, constants.SUBCMD_ATTR_NAME)
             full_command_name: str = getattr(method, constants.SUBCMD_ATTR_COMMAND)
-            subcmd_parser = getattr(method, constants.CMD_ATTR_ARGPARSER)
+            subcmd_parser_builder = getattr(method, constants.CMD_ATTR_ARGPARSER)
 
             subcommand_valid, errmsg = self.statement_parser.is_valid_command(subcommand_name, is_subcommand=True)
             if not subcommand_valid:
@@ -803,7 +960,7 @@ class Cmd(cmd.Cmd):
                 raise CommandSetRegistrationError(
                     f"Could not find command '{command_name}' needed by subcommand: {str(method)}"
                 )
-            command_parser = getattr(command_func, constants.CMD_ATTR_ARGPARSER, None)
+            command_parser = self._command_parsers.get(command_func)
             if command_parser is None:
                 raise CommandSetRegistrationError(
                     f"Could not find argparser for command '{command_name}' needed by subcommand: {str(method)}"
@@ -823,16 +980,17 @@ class Cmd(cmd.Cmd):
 
             target_parser = find_subcommand(command_parser, subcommand_names)
 
+            subcmd_parser = cast(argparse.ArgumentParser, self._build_parser(cmdset, subcmd_parser_builder))
+            from .decorators import (
+                _set_parser_prog,
+            )
+
+            _set_parser_prog(subcmd_parser, f'{command_name} {subcommand_name}')
+            if subcmd_parser.description is None and method.__doc__:
+                subcmd_parser.description = strip_doc_annotations(method.__doc__)
+
             for action in target_parser._actions:
                 if isinstance(action, argparse._SubParsersAction):
-                    # Temporary workaround for avoiding subcommand help text repeatedly getting added to
-                    # action._choices_actions. Until we have instance-specific parser objects, we will remove
-                    # any existing subcommand which has the same name before replacing it. This problem is
-                    # exercised when more than one cmd2.Cmd-based object is created and the same subcommands
-                    # get added each time. Argparse overwrites the previous subcommand but keeps growing the help
-                    # text which is shown by running something like 'alias -h'.
-                    action.remove_parser(subcommand_name)  # type: ignore[arg-type,attr-defined]
-
                     # Get the kwargs for add_parser()
                     add_parser_kwargs = getattr(method, constants.SUBCMD_ATTR_ADD_PARSER_KWARGS, {})
 
@@ -904,7 +1062,7 @@ class Cmd(cmd.Cmd):
                 raise CommandSetRegistrationError(
                     f"Could not find command '{command_name}' needed by subcommand: {str(method)}"
                 )
-            command_parser = getattr(command_func, constants.CMD_ATTR_ARGPARSER, None)
+            command_parser = self._command_parsers.get(command_func)
             if command_parser is None:  # pragma: no cover
                 # This really shouldn't be possible since _register_subcommands would prevent this from happening
                 # but keeping in case it does for some strange reason
@@ -1012,12 +1170,7 @@ class Cmd(cmd.Cmd):
         )
 
         self.add_settable(
-            Settable(
-                'always_show_hint',
-                bool,
-                'Display tab completion hint even when completion suggestions print',
-                self,
-            )
+            Settable('always_show_hint', bool, 'Display tab completion hint even when completion suggestions print', self)
         )
         self.add_settable(Settable('debug', bool, "Show full traceback on exception", self))
         self.add_settable(Settable('echo', bool, "Echo command issued into output", self))
@@ -1027,6 +1180,7 @@ class Cmd(cmd.Cmd):
             Settable('max_completion_items', int, "Maximum number of CompletionItems to display during tab completion", self)
         )
         self.add_settable(Settable('quiet', bool, "Don't print nonessential feedback", self))
+        self.add_settable(Settable('scripts_add_to_history', bool, 'Scripts and pyscripts add commands to history', self))
         self.add_settable(Settable('timing', bool, "Report execution times", self))
 
     # -----  Methods related to presenting output to the user -----
@@ -1056,18 +1210,25 @@ class Cmd(cmd.Cmd):
         """
         return ansi.strip_style(self.prompt)
 
-    def poutput(self, msg: Any = '', *, end: str = '\n') -> None:
-        """Print message to self.stdout and appends a newline by default
-
-        Also handles BrokenPipeError exceptions for when a command's output has
-        been piped to another process and that process terminates before the
-        cmd2 command is finished executing.
+    def print_to(
+        self,
+        dest: IO[str],
+        msg: Any,
+        *,
+        end: str = '\n',
+        style: Optional[Callable[[str], str]] = None,
+    ) -> None:
+        """
+        Print message to a given file object.
 
+        :param dest: the file object being written to
         :param msg: object to print
         :param end: string appended after the end of the message, default a newline
+        :param style: optional style function to format msg with (e.g. ansi.style_success)
         """
+        final_msg = style(msg) if style is not None else msg
         try:
-            ansi.style_aware_write(self.stdout, f"{msg}{end}")
+            ansi.style_aware_write(dest, f'{final_msg}{end}')
         except BrokenPipeError:
             # This occurs if a command's output is being piped to another
             # process and that process closes before the command is
@@ -1077,7 +1238,14 @@ class Cmd(cmd.Cmd):
             if self.broken_pipe_warning:
                 sys.stderr.write(self.broken_pipe_warning)
 
-    # noinspection PyMethodMayBeStatic
+    def poutput(self, msg: Any = '', *, end: str = '\n') -> None:
+        """Print message to self.stdout and appends a newline by default
+
+        :param msg: object to print
+        :param end: string appended after the end of the message, default a newline
+        """
+        self.print_to(self.stdout, msg, end=end)
+
     def perror(self, msg: Any = '', *, end: str = '\n', apply_style: bool = True) -> None:
         """Print message to sys.stderr
 
@@ -1086,22 +1254,24 @@ class Cmd(cmd.Cmd):
         :param apply_style: If True, then ansi.style_error will be applied to the message text. Set to False in cases
                             where the message text already has the desired style. Defaults to True.
         """
-        if apply_style:
-            final_msg = ansi.style_error(msg)
-        else:
-            final_msg = str(msg)
-        ansi.style_aware_write(sys.stderr, final_msg + end)
+        self.print_to(sys.stderr, msg, end=end, style=ansi.style_error if apply_style else None)
+
+    def psuccess(self, msg: Any = '', *, end: str = '\n') -> None:
+        """Wraps poutput, but applies ansi.style_success by default
 
-    def pwarning(self, msg: Any = '', *, end: str = '\n', apply_style: bool = True) -> None:
+        :param msg: object to print
+        :param end: string appended after the end of the message, default a newline
+        """
+        msg = ansi.style_success(msg)
+        self.poutput(msg, end=end)
+
+    def pwarning(self, msg: Any = '', *, end: str = '\n') -> None:
         """Wraps perror, but applies ansi.style_warning by default
 
         :param msg: object to print
         :param end: string appended after the end of the message, default a newline
-        :param apply_style: If True, then ansi.style_warning will be applied to the message text. Set to False in cases
-                            where the message text already has the desired style. Defaults to True.
         """
-        if apply_style:
-            msg = ansi.style_warning(msg)
+        msg = ansi.style_warning(msg)
         self.perror(msg, end=end, apply_style=False)
 
     def pexcept(self, msg: Any, *, end: str = '\n', apply_style: bool = True) -> None:
@@ -1147,7 +1317,7 @@ class Cmd(cmd.Cmd):
     def ppaged(self, msg: Any, *, end: str = '\n', chop: bool = False) -> None:
         """Print output using a pager if it would go off screen and stdout isn't currently being redirected.
 
-        Never uses a pager inside of a script (Python or text) or when output is being redirected or piped or when
+        Never uses a pager inside a script (Python or text) or when output is being redirected or piped or when
         stdout or stdin are not a fully functional terminal.
 
         :param msg: object to print
@@ -1160,48 +1330,41 @@ class Cmd(cmd.Cmd):
 
         WARNING: On Windows, the text always wraps regardless of what the chop argument is set to
         """
-        # msg can be any type, so convert to string before checking if it's blank
-        msg_str = str(msg)
-
-        # Consider None to be no data to print
-        if msg is None or msg_str == '':
-            return
-
-        try:
-            import subprocess
-
-            # Attempt to detect if we are not running within a fully functional terminal.
-            # Don't try to use the pager when being run by a continuous integration system like Jenkins + pexpect.
-            functional_terminal = False
+        # Attempt to detect if we are not running within a fully functional terminal.
+        # Don't try to use the pager when being run by a continuous integration system like Jenkins + pexpect.
+        functional_terminal = False
 
-            if self.stdin.isatty() and self.stdout.isatty():
-                if sys.platform.startswith('win') or os.environ.get('TERM') is not None:
-                    functional_terminal = True
+        if self.stdin.isatty() and self.stdout.isatty():
+            if sys.platform.startswith('win') or os.environ.get('TERM') is not None:
+                functional_terminal = True
 
-            # Don't attempt to use a pager that can block if redirecting or running a script (either text or Python)
-            # Also only attempt to use a pager if actually running in a real fully functional terminal
-            if functional_terminal and not self._redirecting and not self.in_pyscript() and not self.in_script():
-                if ansi.allow_style == ansi.AllowStyle.NEVER:
-                    msg_str = ansi.strip_style(msg_str)
-                msg_str += end
+        # Don't attempt to use a pager that can block if redirecting or running a script (either text or Python).
+        # Also only attempt to use a pager if actually running in a real fully functional terminal.
+        if functional_terminal and not self._redirecting and not self.in_pyscript() and not self.in_script():
+            final_msg = f"{msg}{end}"
+            if ansi.allow_style == ansi.AllowStyle.NEVER:
+                final_msg = ansi.strip_style(final_msg)
 
-                pager = self.pager
-                if chop:
-                    pager = self.pager_chop
+            pager = self.pager
+            if chop:
+                pager = self.pager_chop
 
+            try:
                 # Prevent KeyboardInterrupts while in the pager. The pager application will
                 # still receive the SIGINT since it is in the same process group as us.
                 with self.sigint_protection:
-                    pipe_proc = subprocess.Popen(pager, shell=True, stdin=subprocess.PIPE)
-                    pipe_proc.communicate(msg_str.encode('utf-8', 'replace'))
-            else:
-                self.poutput(msg_str, end=end)
-        except BrokenPipeError:
-            # This occurs if a command's output is being piped to another process and that process closes before the
-            # command is finished. If you would like your application to print a warning message, then set the
-            # broken_pipe_warning attribute to the message you want printed.`
-            if self.broken_pipe_warning:
-                sys.stderr.write(self.broken_pipe_warning)
+                    import subprocess
+
+                    pipe_proc = subprocess.Popen(pager, shell=True, stdin=subprocess.PIPE, stdout=self.stdout)
+                    pipe_proc.communicate(final_msg.encode('utf-8', 'replace'))
+            except BrokenPipeError:
+                # This occurs if a command's output is being piped to another process and that process closes before the
+                # command is finished. If you would like your application to print a warning message, then set the
+                # broken_pipe_warning attribute to the message you want printed.`
+                if self.broken_pipe_warning:
+                    sys.stderr.write(self.broken_pipe_warning)
+        else:
+            self.poutput(msg, end=end)
 
     # -----  Methods related to tab completion -----
 
@@ -1222,7 +1385,6 @@ class Cmd(cmd.Cmd):
         if rl_type == RlType.GNU:
             readline.set_completion_display_matches_hook(self._display_matches_gnu_readline)
         elif rl_type == RlType.PYREADLINE:
-            # noinspection PyUnresolvedReferences
             readline.rl.mode._display_completions = self._display_matches_pyreadline
 
     def tokens_for_completion(self, line: str, begidx: int, endidx: int) -> Tuple[List[str], List[str]]:
@@ -1289,7 +1451,6 @@ class Cmd(cmd.Cmd):
 
         return tokens, raw_tokens
 
-    # noinspection PyMethodMayBeStatic, PyUnusedLocal
     def basic_complete(
         self,
         text: str,
@@ -1480,7 +1641,6 @@ class Cmd(cmd.Cmd):
 
         return matches
 
-    # noinspection PyUnusedLocal
     def path_complete(
         self, text: str, line: str, begidx: int, endidx: int, *, path_filter: Optional[Callable[[str], bool]] = None
     ) -> List[str]:
@@ -1498,7 +1658,6 @@ class Cmd(cmd.Cmd):
 
         # Used to complete ~ and ~user strings
         def complete_users() -> List[str]:
-
             users = []
 
             # Windows lacks the pwd module so we can't get a list of users.
@@ -1516,10 +1675,8 @@ class Cmd(cmd.Cmd):
 
                 # Iterate through a list of users from the password database
                 for cur_pw in pwd.getpwall():
-
                     # Check if the user has an existing home dir
                     if os.path.isdir(cur_pw.pw_dir):
-
                         # Add a ~ to the user to match against text
                         cur_user = '~' + cur_pw.pw_name
                         if cur_user.startswith(text):
@@ -1605,7 +1762,6 @@ class Cmd(cmd.Cmd):
 
             # Build display_matches and add a slash to directories
             for index, cur_match in enumerate(matches):
-
                 # Display only the basename of this path in the tab completion suggestions
                 self.display_matches.append(os.path.basename(cur_match))
 
@@ -1674,7 +1830,6 @@ class Cmd(cmd.Cmd):
 
         # Must at least have the command
         if len(raw_tokens) > 1:
-
             # True when command line contains any redirection tokens
             has_redirection = False
 
@@ -1766,7 +1921,6 @@ class Cmd(cmd.Cmd):
         :param longest_match_length: longest printed length of the matches
         """
         if rl_type == RlType.GNU:
-
             # Print hint if one exists and we are supposed to display it
             hint_printed = False
             if self.always_show_hint and self.completion_hint:
@@ -1806,7 +1960,6 @@ class Cmd(cmd.Cmd):
 
                 # rl_display_match_list() expects matches to be in argv format where
                 # substitution is the first element, followed by the matches, and then a NULL.
-                # noinspection PyCallingNonCallable,PyTypeChecker
                 strings_array = cast(List[Optional[bytes]], (ctypes.c_char_p * (1 + len(encoded_matches) + 1))())
 
                 # Copy in the encoded strings and add a NULL to the end
@@ -1826,7 +1979,6 @@ class Cmd(cmd.Cmd):
         :param matches: the tab completion matches to display
         """
         if rl_type == RlType.PYREADLINE:
-
             # Print hint if one exists and we are supposed to display it
             hint_printed = False
             if self.always_show_hint and self.completion_hint:
@@ -1865,9 +2017,8 @@ class Cmd(cmd.Cmd):
         :param parser: the parser to examine
         :return: type of ArgparseCompleter
         """
-        completer_type: Optional[
-            Type[argparse_completer.ArgparseCompleter]
-        ] = parser.get_ap_completer_type()  # type: ignore[attr-defined]
+        Completer = Optional[Type[argparse_completer.ArgparseCompleter]]
+        completer_type: Completer = parser.get_ap_completer_type()  # type: ignore[attr-defined]
 
         if completer_type is None:
             completer_type = argparse_completer.DEFAULT_AP_COMPLETER
@@ -1898,11 +2049,14 @@ class Cmd(cmd.Cmd):
 
             expanded_line = statement.command_and_args
 
-            # We overwrote line with a properly formatted but fully stripped version
-            # Restore the end spaces since line is only supposed to be lstripped when
-            # passed to completer functions according to Python docs
-            rstripped_len = len(line) - len(line.rstrip())
-            expanded_line += ' ' * rstripped_len
+            if not expanded_line[-1:].isspace():
+                # Unquoted trailing whitespace gets stripped by parse_command_only().
+                # Restore it since line is only supposed to be lstripped when passed
+                # to completer functions according to the Python cmd docs. Regardless
+                # of what type of whitespace (' ', \n) was stripped, just append spaces
+                # since shlex treats whitespace characters the same when splitting.
+                rstripped_len = len(line) - len(line.rstrip())
+                expanded_line += ' ' * rstripped_len
 
             # Fix the index values if expanded_line has a different size than line
             if len(expanded_line) != len(line):
@@ -1934,12 +2088,12 @@ class Cmd(cmd.Cmd):
                 else:
                     # There's no completer function, next see if the command uses argparse
                     func = self.cmd_func(command)
-                    argparser: Optional[argparse.ArgumentParser] = getattr(func, constants.CMD_ATTR_ARGPARSER, None)
+                    argparser = None if func is None else self._command_parsers.get(func)
 
                     if func is not None and argparser is not None:
                         # Get arguments for complete()
                         preserve_quotes = getattr(func, constants.CMD_ATTR_PRESERVE_QUOTES)
-                        cmd_set = self._cmd_to_command_sets[command] if command in self._cmd_to_command_sets else None
+                        cmd_set = self.find_commandset_for_command(command)
 
                         # Create the argparse completer
                         completer_type = self._determine_ap_completer_type(argparser)
@@ -1980,7 +2134,6 @@ class Cmd(cmd.Cmd):
 
         # Check if the token being completed has an opening quote
         if raw_completion_token and raw_completion_token[0] in constants.QUOTES:
-
             # Since the token is still being completed, we know the opening quote is unclosed.
             # Save the quote so we can add a matching closing quote later.
             completion_token_quote = raw_completion_token[0]
@@ -2005,7 +2158,6 @@ class Cmd(cmd.Cmd):
         self.completion_matches = self._redirect_complete(text, line, begidx, endidx, completer_func)
 
         if self.completion_matches:
-
             # Eliminate duplicates
             self.completion_matches = utils.remove_duplicates(self.completion_matches)
             self.display_matches = utils.remove_duplicates(self.display_matches)
@@ -2020,7 +2172,6 @@ class Cmd(cmd.Cmd):
 
             # Check if we need to add an opening quote
             if not completion_token_quote:
-
                 add_quote = False
 
                 # This is the tab completion text that will appear on the command line.
@@ -2073,7 +2224,6 @@ class Cmd(cmd.Cmd):
         :param custom_settings: used when not tab completing the main command line
         :return: the next possible completion for text or None
         """
-        # noinspection PyBroadException
         try:
             if state == 0:
                 self._reset_completion_defaults()
@@ -2081,7 +2231,7 @@ class Cmd(cmd.Cmd):
                 # Check if we are completing a multiline command
                 if self._at_continuation_prompt:
                     # lstrip and prepend the previously typed portion of this multiline command
-                    lstripped_previous = self._multiline_in_progress.lstrip().replace(constants.LINE_FEED, ' ')
+                    lstripped_previous = self._multiline_in_progress.lstrip()
                     line = lstripped_previous + readline.get_line_buffer()
 
                     # Increment the indexes to account for the prepended text
@@ -2103,7 +2253,7 @@ class Cmd(cmd.Cmd):
                 # from text and update the indexes. This only applies if we are at the beginning of the command line.
                 shortcut_to_restore = ''
                 if begidx == 0 and custom_settings is None:
-                    for (shortcut, _) in self.statement_parser.shortcuts:
+                    for shortcut, _ in self.statement_parser.shortcuts:
                         if text.startswith(shortcut):
                             # Save the shortcut to restore later
                             shortcut_to_restore = shortcut
@@ -2251,14 +2401,13 @@ class Cmd(cmd.Cmd):
         # Filter out hidden and disabled commands
         return [topic for topic in all_topics if topic not in self.hidden_commands and topic not in self.disabled_commands]
 
-    # noinspection PyUnusedLocal
-    def sigint_handler(self, signum: int, _: FrameType) -> None:
+    def sigint_handler(self, signum: int, _: Optional[FrameType]) -> None:
         """Signal handler for SIGINTs which typically come from Ctrl-C events.
 
-        If you need custom SIGINT behavior, then override this function.
+        If you need custom SIGINT behavior, then override this method.
 
         :param signum: signal number
-        :param _: required param for signal handlers
+        :param _: the current stack frame or None
         """
         if self._cur_pipe_proc_reader is not None:
             # Pass the SIGINT to the current pipe process
@@ -2266,7 +2415,30 @@ class Cmd(cmd.Cmd):
 
         # Check if we are allowed to re-raise the KeyboardInterrupt
         if not self.sigint_protection:
-            self._raise_keyboard_interrupt()
+            raise_interrupt = True
+            if self.current_command is not None:
+                command_set = self.find_commandset_for_command(self.current_command.command)
+                if command_set is not None:
+                    raise_interrupt = not command_set.sigint_handler()
+            if raise_interrupt:
+                self._raise_keyboard_interrupt()
+
+    def termination_signal_handler(self, signum: int, _: Optional[FrameType]) -> None:
+        """
+        Signal handler for SIGHUP and SIGTERM. Only runs on Linux and Mac.
+
+        SIGHUP - received when terminal window is closed
+        SIGTERM - received when this app has been requested to terminate
+
+        The basic purpose of this method is to call sys.exit() so our exit handler will run
+        and save the persistent history file. If you need more complex behavior like killing
+        threads and performing cleanup, then override this method.
+
+        :param signum: signal number
+        :param _: the current stack frame or None
+        """
+        # POSIX systems add 128 to signal numbers for the exit code
+        sys.exit(128 + signum)
 
     def _raise_keyboard_interrupt(self) -> None:
         """Helper function to raise a KeyboardInterrupt"""
@@ -2274,50 +2446,47 @@ class Cmd(cmd.Cmd):
 
     def precmd(self, statement: Union[Statement, str]) -> Statement:
         """Hook method executed just before the command is executed by
-        :meth:`~cmd2.Cmd.onecmd` and after adding it to history.
+        [cmd2.Cmd.onecmd][] and after adding it to history.
 
         :param statement: subclass of str which also contains the parsed input
         :return: a potentially modified version of the input Statement object
 
-        See :meth:`~cmd2.Cmd.register_postparsing_hook` and
-        :meth:`~cmd2.Cmd.register_precmd_hook` for more robust ways
+        See [cmd2.Cmd.register_postparsing_hook][] and
+        [cmd2.Cmd.register_precmd_hook][] for more robust ways
         to run hooks before the command is executed. See
-        :ref:`features/hooks:Postparsing Hooks` and
-        :ref:`features/hooks:Precommand Hooks` for more information.
+        [Hooks](../features/hooks.md) for more information.
         """
         return Statement(statement) if not isinstance(statement, Statement) else statement
 
     def postcmd(self, stop: bool, statement: Union[Statement, str]) -> bool:
         """Hook method executed just after a command is executed by
-        :meth:`~cmd2.Cmd.onecmd`.
+        [cmd2.Cmd.onecmd][].
 
         :param stop: return `True` to request the command loop terminate
         :param statement: subclass of str which also contains the parsed input
 
-        See :meth:`~cmd2.Cmd.register_postcmd_hook` and :meth:`~cmd2.Cmd.register_cmdfinalization_hook` for more robust ways
+        See [cmd2.Cmd.register_postcmd_hook][] and [cmd2.Cmd.register_cmdfinalization_hook][] for more robust ways
         to run hooks after the command is executed. See
-        :ref:`features/hooks:Postcommand Hooks` and
-        :ref:`features/hooks:Command Finalization Hooks` for more information.
+        [Hooks](../features/hooks.md) for more information.
         """
         return stop
 
     def preloop(self) -> None:
-        """Hook method executed once when the :meth:`~.cmd2.Cmd.cmdloop()`
+        """Hook method executed once when the [cmd2.Cmd.cmdloop][]
         method is called.
 
-        See :meth:`~cmd2.Cmd.register_preloop_hook` for a more robust way
+        See [cmd2.Cmd.register_preloop_hook][] for a more robust way
         to run hooks before the command loop begins. See
-        :ref:`features/hooks:Application Lifecycle Hooks` for more information.
+        [Hooks](../features/hooks.md) for more information.
         """
         pass
 
     def postloop(self) -> None:
-        """Hook method executed once when the :meth:`~.cmd2.Cmd.cmdloop()`
-        method is about to return.
+        """Hook method executed once when the [cmd2.Cmd.cmdloop][] method is about to return.
 
-        See :meth:`~cmd2.Cmd.register_postloop_hook` for a more robust way
+        See [cmd2.Cmd.register_postloop_hook][] for a more robust way
         to run hooks after the command loop completes. See
-        :ref:`features/hooks:Application Lifecycle Hooks` for more information.
+        [Hooks](../features/hooks.md) for more information.
         """
         pass
 
@@ -2335,7 +2504,13 @@ class Cmd(cmd.Cmd):
         return statement.command, statement.args, statement.command_and_args
 
     def onecmd_plus_hooks(
-        self, line: str, *, add_to_history: bool = True, raise_keyboard_interrupt: bool = False, py_bridge_call: bool = False
+        self,
+        line: str,
+        *,
+        add_to_history: bool = True,
+        raise_keyboard_interrupt: bool = False,
+        py_bridge_call: bool = False,
+        orig_rl_history_length: Optional[int] = None,
     ) -> bool:
         """Top-level function called by cmdloop() to handle parsing a line and running the command and all of its hooks.
 
@@ -2347,6 +2522,9 @@ class Cmd(cmd.Cmd):
         :param py_bridge_call: This should only ever be set to True by PyBridge to signify the beginning
                                of an app() call from Python. It is used to enable/disable the storage of the
                                command's stdout.
+        :param orig_rl_history_length: Optional length of the readline history before the current command was typed.
+                                       This is used to assist in combining multiline readline history entries and is only
+                                       populated by cmd2. Defaults to None.
         :return: True if running of commands should stop
         """
         import datetime
@@ -2356,7 +2534,7 @@ class Cmd(cmd.Cmd):
 
         try:
             # Convert the line into a Statement
-            statement = self._input_line_to_statement(line)
+            statement = self._input_line_to_statement(line, orig_rl_history_length=orig_rl_history_length)
 
             # call the postparsing hooks
             postparsing_data = plugin.PostparsingData(False, statement)
@@ -2431,7 +2609,8 @@ class Cmd(cmd.Cmd):
             if raise_keyboard_interrupt and not stop:
                 raise ex
         except SystemExit as ex:
-            self.exit_code = ex.code
+            if isinstance(ex.code, int):
+                self.exit_code = ex.code
             stop = True
         except PassThroughException as ex:
             raise ex.wrapped_ex
@@ -2444,7 +2623,8 @@ class Cmd(cmd.Cmd):
                 if raise_keyboard_interrupt and not stop:
                     raise ex
             except SystemExit as ex:
-                self.exit_code = ex.code
+                if isinstance(ex.code, int):
+                    self.exit_code = ex.code
                 stop = True
             except PassThroughException as ex:
                 raise ex.wrapped_ex
@@ -2508,7 +2688,7 @@ class Cmd(cmd.Cmd):
 
         return False
 
-    def _complete_statement(self, line: str) -> Statement:
+    def _complete_statement(self, line: str, *, orig_rl_history_length: Optional[int] = None) -> Statement:
         """Keep accepting lines of input until the command is complete.
 
         There is some pretty hacky code here to handle some quirks of
@@ -2517,10 +2697,29 @@ class Cmd(cmd.Cmd):
         backwards compatibility with the standard library version of cmd.
 
         :param line: the line being parsed
+        :param orig_rl_history_length: Optional length of the readline history before the current command was typed.
+                                       This is used to assist in combining multiline readline history entries and is only
+                                       populated by cmd2. Defaults to None.
         :return: the completed Statement
         :raises: Cmd2ShlexError if a shlex error occurs (e.g. No closing quotation)
         :raises: EmptyStatement when the resulting Statement is blank
         """
+
+        def combine_rl_history(statement: Statement) -> None:
+            """Combine all lines of a multiline command into a single readline history entry"""
+            if orig_rl_history_length is None or not statement.multiline_command:
+                return
+
+            # Remove all previous lines added to history for this command
+            while readline.get_current_history_length() > orig_rl_history_length:
+                readline.remove_history_item(readline.get_current_history_length() - 1)
+
+            formatted_command = single_line_format(statement)
+
+            # If formatted command is different than the previous history item, add it
+            if orig_rl_history_length == 0 or formatted_command != readline.get_history_item(orig_rl_history_length):
+                readline.add_history(formatted_command)
+
         while True:
             try:
                 statement = self.statement_parser.parse(line)
@@ -2532,7 +2731,7 @@ class Cmd(cmd.Cmd):
                     # so we are done
                     break
             except Cmd2ShlexError:
-                # we have unclosed quotation marks, lets parse only the command
+                # we have an unclosed quotation mark, let's parse only the command
                 # and see if it's a multiline
                 statement = self.statement_parser.parse_command_only(line)
                 if not statement.multiline_command:
@@ -2548,6 +2747,7 @@ class Cmd(cmd.Cmd):
                 # Save the command line up to this point for tab completion
                 self._multiline_in_progress = line + '\n'
 
+                # Get next line of this command
                 nextline = self._read_command_line(self.continuation_prompt)
                 if nextline == 'eof':
                     # they entered either a blank line, or we hit an EOF
@@ -2556,7 +2756,14 @@ class Cmd(cmd.Cmd):
                     # terminator
                     nextline = '\n'
                     self.poutput(nextline)
-                line = f'{self._multiline_in_progress}{nextline}'
+
+                line += f'\n{nextline}'
+
+                # Combine all history lines of this multiline command as we go.
+                if nextline:
+                    statement = self.statement_parser.parse_command_only(line)
+                    combine_rl_history(statement)
+
             except KeyboardInterrupt:
                 self.poutput('^C')
                 statement = self.statement_parser.parse('')
@@ -2566,13 +2773,20 @@ class Cmd(cmd.Cmd):
 
         if not statement.command:
             raise EmptyStatement
+        else:
+            # If necessary, update history with completed multiline command.
+            combine_rl_history(statement)
+
         return statement
 
-    def _input_line_to_statement(self, line: str) -> Statement:
+    def _input_line_to_statement(self, line: str, *, orig_rl_history_length: Optional[int] = None) -> Statement:
         """
         Parse the user's input line and convert it to a Statement, ensuring that all macros are also resolved
 
         :param line: the line being parsed
+        :param orig_rl_history_length: Optional length of the readline history before the current command was typed.
+                                       This is used to assist in combining multiline readline history entries and is only
+                                       populated by cmd2. Defaults to None.
         :return: parsed command line as a Statement
         :raises: Cmd2ShlexError if a shlex error occurs (e.g. No closing quotation)
         :raises: EmptyStatement when the resulting Statement is blank
@@ -2583,11 +2797,13 @@ class Cmd(cmd.Cmd):
         # Continue until all macros are resolved
         while True:
             # Make sure all input has been read and convert it to a Statement
-            statement = self._complete_statement(line)
+            statement = self._complete_statement(line, orig_rl_history_length=orig_rl_history_length)
 
-            # Save the fully entered line if this is the first loop iteration
+            # If this is the first loop iteration, save the original line and stop
+            # combining multiline history entries in the remaining iterations.
             if orig_line is None:
                 orig_line = statement.raw
+                orig_rl_history_length = None
 
             # Check if this command matches a macro and wasn't already processed to avoid an infinite loop
             if statement.command in self.macros.keys() and statement.command not in used_macros:
@@ -2732,13 +2948,8 @@ class Cmd(cmd.Cmd):
                 sys.stdout = self.stdout = new_stdout
 
         elif statement.output:
-            import tempfile
-
-            if (not statement.output_to) and (not self._can_clip):
-                raise RedirectionError("Cannot redirect to paste buffer; missing 'pyperclip' and/or pyperclip dependencies")
-
-            # Redirecting to a file
-            elif statement.output_to:
+            if statement.output_to:
+                # redirecting to a file
                 # statement.output can only contain REDIRECTION_APPEND or REDIRECTION_OUTPUT
                 mode = 'a' if statement.output == constants.REDIRECTION_APPEND else 'w'
                 try:
@@ -2750,14 +2961,26 @@ class Cmd(cmd.Cmd):
                 redir_saved_state.redirecting = True
                 sys.stdout = self.stdout = new_stdout
 
-            # Redirecting to a paste buffer
             else:
+                # Redirecting to a paste buffer
+                # we are going to direct output to a temporary file, then read it back in and
+                # put it in the paste buffer later
+                if not self.allow_clipboard:
+                    raise RedirectionError("Clipboard access not allowed")
+
+                # attempt to get the paste buffer, this forces pyperclip to go figure
+                # out if it can actually interact with the paste buffer, and will throw exceptions
+                # if it's not gonna work. That way we throw the exception before we go
+                # run the command and queue up all the output. if this is going to fail,
+                # no point opening up the temporary file
+                current_paste_buffer = get_paste_buffer()
+                # create a temporary file to store output
                 new_stdout = cast(TextIO, tempfile.TemporaryFile(mode="w+"))
                 redir_saved_state.redirecting = True
                 sys.stdout = self.stdout = new_stdout
 
                 if statement.output == constants.REDIRECTION_APPEND:
-                    self.stdout.write(get_paste_buffer())
+                    self.stdout.write(current_paste_buffer)
                     self.stdout.flush()
 
         # These are updated regardless of whether the command redirected
@@ -2802,27 +3025,18 @@ class Cmd(cmd.Cmd):
 
         :param command: the name of the command
 
-        :Example:
+        Example:
 
-        >>> helpfunc = self.cmd_func('help')
+        ```py
+        helpfunc = self.cmd_func('help')
+        ```
 
         helpfunc now contains a reference to the ``do_help`` method
         """
-        func_name = self._cmd_func_name(command)
-        if func_name:
-            return cast(Optional[CommandFunc], getattr(self, func_name))
-        return None
-
-    def _cmd_func_name(self, command: str) -> str:
-        """Get the method name associated with a given command.
+        func_name = constants.COMMAND_FUNC_PREFIX + command
+        func = getattr(self, func_name, None)
+        return cast(CommandFunc, func) if callable(func) else None
 
-        :param command: command to look up method name which implements it
-        :return: method name which implements the given command
-        """
-        target = constants.COMMAND_FUNC_PREFIX + command
-        return target if callable(getattr(self, target, None)) else ''
-
-    # noinspection PyMethodOverriding
     def onecmd(self, statement: Union[Statement, str], *, add_to_history: bool = True) -> bool:
         """This executes the actual do_* method for a command.
 
@@ -2847,7 +3061,11 @@ class Cmd(cmd.Cmd):
             ):
                 self.history.append(statement)
 
-            stop = func(statement)
+            try:
+                self.current_command = statement
+                stop = func(statement)
+            finally:
+                self.current_command = None
 
         else:
             stop = self.default(statement)
@@ -2863,15 +3081,19 @@ class Cmd(cmd.Cmd):
             if 'shell' not in self.exclude_from_history:
                 self.history.append(statement)
 
-            # noinspection PyTypeChecker
             return self.do_shell(statement.command_and_args)
         else:
             err_msg = self.default_error.format(statement.command)
+            if self.suggest_similar_command and (suggested_command := self._suggest_similar_command(statement.command)):
+                err_msg += f"\n{self.default_suggestion_message.format(suggested_command)}"
 
-            # Set apply_style to False so default_error's style is not overridden
+            # Set apply_style to False so styles for default_error and default_suggestion_message are not overridden
             self.perror(err_msg, apply_style=False)
             return None
 
+    def _suggest_similar_command(self, command: str) -> Optional[str]:
+        return suggest_similar(command, self.get_visible_commands())
+
     def read_input(
         self,
         prompt: str,
@@ -2926,7 +3148,7 @@ class Cmd(cmd.Cmd):
             nonlocal saved_history
             nonlocal parser
 
-            if readline_configured:  # pragma: no cover
+            if readline_configured or rl_type == RlType.NONE:  # pragma: no cover
                 return
 
             # Configure tab completion
@@ -2935,7 +3157,7 @@ class Cmd(cmd.Cmd):
 
                 # Disable completion
                 if completion_mode == utils.CompletionMode.NONE:
-                    # noinspection PyUnusedLocal
+
                     def complete_none(text: str, state: int) -> Optional[str]:  # pragma: no cover
                         return None
 
@@ -2966,7 +3188,6 @@ class Cmd(cmd.Cmd):
             if completion_mode != utils.CompletionMode.COMMANDS or history is not None:
                 saved_history = []
                 for i in range(1, readline.get_current_history_length() + 1):
-                    # noinspection PyArgumentList
                     saved_history.append(readline.get_history_item(i))
 
                 readline.clear_history()
@@ -2979,7 +3200,7 @@ class Cmd(cmd.Cmd):
         def restore_readline() -> None:
             """Restore readline tab completion and history"""
             nonlocal readline_configured
-            if not readline_configured:  # pragma: no cover
+            if not readline_configured or rl_type == RlType.NONE:  # pragma: no cover
                 return
 
             if self._completion_supported():
@@ -3063,8 +3284,13 @@ class Cmd(cmd.Cmd):
         """
         readline_settings = _SavedReadlineSettings()
 
-        if self._completion_supported():
+        if rl_type == RlType.GNU:
+            # To calculate line count when printing async_alerts, we rely on commands wider than
+            # the terminal to wrap across multiple lines. The default for horizontal-scroll-mode
+            # is "off" but a user may have overridden it in their readline initialization file.
+            readline.parse_and_bind("set horizontal-scroll-mode off")
 
+        if self._completion_supported():
             # Set up readline for our tab completion needs
             if rl_type == RlType.GNU:
                 # GNU readline automatically adds a closing quote if the text being completed has an opening quote.
@@ -3098,7 +3324,6 @@ class Cmd(cmd.Cmd):
         :param readline_settings: the readline settings to restore
         """
         if self._completion_supported():
-
             # Restore what we changed in readline
             readline.set_completer(readline_settings.completer)
             readline.set_completer_delims(readline_settings.delims)
@@ -3107,7 +3332,6 @@ class Cmd(cmd.Cmd):
                 readline.set_completion_display_matches_hook(None)
                 rl_basic_quote_characters.value = readline_settings.basic_quotes
             elif rl_type == RlType.PYREADLINE:
-                # noinspection PyUnresolvedReferences
                 readline.rl.mode._display_completions = orig_pyreadline_display
 
     def _cmdloop(self) -> None:
@@ -3129,6 +3353,13 @@ class Cmd(cmd.Cmd):
             self._startup_commands.clear()
 
             while not stop:
+                # Used in building multiline readline history entries. Only applies
+                # when command line is read by input() in a terminal.
+                if rl_type != RlType.NONE and self.use_rawinput and sys.stdin.isatty():
+                    orig_rl_history_length = readline.get_current_history_length()
+                else:
+                    orig_rl_history_length = None
+
                 # Get commands from user
                 try:
                     line = self._read_command_line(self.prompt)
@@ -3137,7 +3368,7 @@ class Cmd(cmd.Cmd):
                     line = ''
 
                 # Run the command along with all associated pre and post hooks
-                stop = self.onecmd_plus_hooks(line)
+                stop = self.onecmd_plus_hooks(line, orig_rl_history_length=orig_rl_history_length)
         finally:
             # Get sigint protection while we restore readline settings
             with self.sigint_protection:
@@ -3149,11 +3380,10 @@ class Cmd(cmd.Cmd):
     #############################################################
 
     # Top-level parser for alias
-    alias_description = "Manage aliases\n" "\n" "An alias is a command that enables replacement of a word by another string."
-    alias_epilog = "See also:\n" "  macro"
+    alias_description = "Manage aliases\n\nAn alias is a command that enables replacement of a word by another string."
+    alias_epilog = "See also:\n  macro"
     alias_parser = argparse_custom.DEFAULT_ARGUMENT_PARSER(description=alias_description, epilog=alias_epilog)
-    alias_subparsers = alias_parser.add_subparsers(dest='subcommand', metavar='SUBCOMMAND')
-    alias_subparsers.required = True
+    alias_parser.add_subparsers(metavar='SUBCOMMAND', required=True)
 
     # Preserve quotes since we are passing strings to other commands
     @with_argparser(alias_parser, preserve_quotes=True)
@@ -3318,11 +3548,10 @@ class Cmd(cmd.Cmd):
     #############################################################
 
     # Top-level parser for macro
-    macro_description = "Manage macros\n" "\n" "A macro is similar to an alias, but it can contain argument placeholders."
-    macro_epilog = "See also:\n" "  alias"
+    macro_description = "Manage macros\n\nA macro is similar to an alias, but it can contain argument placeholders."
+    macro_epilog = "See also:\n  alias"
     macro_parser = argparse_custom.DEFAULT_ARGUMENT_PARSER(description=macro_description, epilog=macro_epilog)
-    macro_subparsers = macro_parser.add_subparsers(dest='subcommand', metavar='SUBCOMMAND')
-    macro_subparsers.required = True
+    macro_parser.add_subparsers(metavar='SUBCOMMAND', required=True)
 
     # Preserve quotes since we are passing strings to other commands
     @with_argparser(macro_parser, preserve_quotes=True)
@@ -3570,16 +3799,14 @@ class Cmd(cmd.Cmd):
             return []
 
         # Check if this command uses argparse
-        func = self.cmd_func(command)
-        argparser = getattr(func, constants.CMD_ATTR_ARGPARSER, None)
-        if func is None or argparser is None:
+        if (func := self.cmd_func(command)) is None or (argparser := self._command_parsers.get(func)) is None:
             return []
 
         completer = argparse_completer.DEFAULT_AP_COMPLETER(argparser, self)
         return completer.complete_subcommand_help(text, line, begidx, endidx, arg_tokens['subcommands'])
 
     help_parser = argparse_custom.DEFAULT_ARGUMENT_PARSER(
-        description="List available commands or provide " "detailed help for a specific command"
+        description="List available commands or provide detailed help for a specific command"
     )
     help_parser.add_argument(
         '-v', '--verbose', action='store_true', help="print a list of all commands with descriptions of each"
@@ -3607,7 +3834,7 @@ class Cmd(cmd.Cmd):
             # Getting help for a specific command
             func = self.cmd_func(args.command)
             help_func = getattr(self, constants.HELP_FUNC_PREFIX + args.command, None)
-            argparser = getattr(func, constants.CMD_ATTR_ARGPARSER, None)
+            argparser = None if func is None else self._command_parsers.get(func)
 
             # If the command function uses argparse, then use argparse's help
             if func is not None and argparser is not None:
@@ -3652,7 +3879,7 @@ class Cmd(cmd.Cmd):
 
     def columnize(self, str_list: Optional[List[str]], display_width: int = 80) -> None:
         """Display a list of single-line strings as a compact set of columns.
-        Override of cmd's print_topics() to handle strings with ANSI style sequences and wide characters
+        Override of cmd's columnize() to handle strings with ANSI style sequences and wide characters
 
         Each column is only as wide as necessary.
         Columns are separated by two spaces (one was not legible enough).
@@ -3688,9 +3915,10 @@ class Cmd(cmd.Cmd):
             if totwidth <= display_width:
                 break
         else:
+            # The output is wider than display_width. Print 1 column with each string on its own row.
             nrows = len(str_list)
             ncols = 1
-            colwidths = [0]
+            colwidths = [1]
         for row in range(nrows):
             texts = []
             for col in range(ncols):
@@ -3728,28 +3956,29 @@ class Cmd(cmd.Cmd):
     def _build_command_info(self) -> Tuple[Dict[str, List[str]], List[str], List[str], List[str]]:
         # Get a sorted list of help topics
         help_topics = sorted(self.get_help_topics(), key=self.default_sort_key)
+
         # Get a sorted list of visible command names
         visible_commands = sorted(self.get_visible_commands(), key=self.default_sort_key)
         cmds_doc: List[str] = []
         cmds_undoc: List[str] = []
         cmds_cats: Dict[str, List[str]] = {}
         for command in visible_commands:
-            func = self.cmd_func(command)
+            func = cast(CommandFunc, self.cmd_func(command))
             has_help_func = False
+            has_parser = func in self._command_parsers
 
             if command in help_topics:
                 # Prevent the command from showing as both a command and help topic in the output
                 help_topics.remove(command)
 
                 # Non-argparse commands can have help_functions for their documentation
-                if not hasattr(func, constants.CMD_ATTR_ARGPARSER):
-                    has_help_func = True
+                has_help_func = not has_parser
 
             if hasattr(func, constants.CMD_ATTR_HELP_CATEGORY):
                 category: str = getattr(func, constants.CMD_ATTR_HELP_CATEGORY)
                 cmds_cats.setdefault(category, [])
                 cmds_cats[category].append(command)
-            elif func.__doc__ or has_help_func:
+            elif func.__doc__ or has_help_func or has_parser:
                 cmds_doc.append(command)
             else:
                 cmds_undoc.append(command)
@@ -3784,11 +4013,17 @@ class Cmd(cmd.Cmd):
                 # Try to get the documentation string for each command
                 topics = self.get_help_topics()
                 for command in cmds:
-                    cmd_func = self.cmd_func(command)
+                    if (cmd_func := self.cmd_func(command)) is None:
+                        continue
+
                     doc: Optional[str]
 
+                    # If this is an argparse command, use its description.
+                    if (cmd_parser := self._command_parsers.get(cmd_func)) is not None:
+                        doc = cmd_parser.description
+
                     # Non-argparse commands can have help_functions for their documentation
-                    if not hasattr(cmd_func, constants.CMD_ATTR_ARGPARSER) and command in topics:
+                    elif command in topics:
                         help_func = getattr(self, constants.HELP_FUNC_PREFIX + command)
                         result = io.StringIO()
 
@@ -3841,7 +4076,6 @@ class Cmd(cmd.Cmd):
         self.poutput()
 
         # self.last_result will be set by do_quit()
-        # noinspection PyTypeChecker
         return self.do_quit('')
 
     quit_parser = argparse_custom.DEFAULT_ARGUMENT_PARSER(description="Exit this application")
@@ -3878,7 +4112,7 @@ class Cmd(cmd.Cmd):
                     fulloptions.append((opt[0], opt[1]))
                 except IndexError:
                     fulloptions.append((opt[0], opt[0]))
-        for (idx, (_, text)) in enumerate(fulloptions):
+        for idx, (_, text) in enumerate(fulloptions):
             self.poutput('  %2d. %s' % (idx + 1, text))
 
         while True:
@@ -3976,12 +4210,11 @@ class Cmd(cmd.Cmd):
                 # Try to update the settable's value
                 try:
                     orig_value = settable.get_value()
-                    new_value = settable.set_value(utils.strip_quotes(args.value))
-                # noinspection PyBroadException
+                    settable.set_value(utils.strip_quotes(args.value))
                 except Exception as ex:
                     self.perror(f"Error setting {args.param}: {ex}")
                 else:
-                    self.poutput(f"{args.param} - was: {orig_value!r}\nnow: {new_value!r}")
+                    self.poutput(f"{args.param} - was: {orig_value!r}\nnow: {settable.get_value()!r}")
                     self.last_result = True
                 return
 
@@ -4113,7 +4346,6 @@ class Cmd(cmd.Cmd):
         if rl_type != RlType.NONE:
             # Save cmd2 history
             for i in range(1, readline.get_current_history_length() + 1):
-                # noinspection PyArgumentList
                 cmd2_env.history.append(readline.get_history_item(i))
 
             readline.clear_history()
@@ -4147,7 +4379,6 @@ class Cmd(cmd.Cmd):
                 if rl_type == RlType.GNU:
                     readline.set_completion_display_matches_hook(None)
                 elif rl_type == RlType.PYREADLINE:
-                    # noinspection PyUnresolvedReferences
                     readline.rl.mode._display_completions = orig_pyreadline_display
 
                 # Save off the current completer and set a new one in the Python console
@@ -4182,7 +4413,6 @@ class Cmd(cmd.Cmd):
             # Save py's history
             self._py_history.clear()
             for i in range(1, readline.get_current_history_length() + 1):
-                # noinspection PyArgumentList
                 self._py_history.append(readline.get_history_item(i))
 
             readline.clear_history()
@@ -4226,7 +4456,8 @@ class Cmd(cmd.Cmd):
             PyBridge,
         )
 
-        py_bridge = PyBridge(self)
+        add_to_history = self.scripts_add_to_history if pyscript else True
+        py_bridge = PyBridge(self, add_to_history=add_to_history)
         saved_sys_path = None
 
         if self.in_pyscript():
@@ -4278,7 +4509,6 @@ class Cmd(cmd.Cmd):
 
             # Check if we are running Python code
             if py_code_to_run:
-                # noinspection PyBroadException
                 try:
                     interp.runcode(py_code_to_run)  # type: ignore[arg-type]
                 except BaseException:
@@ -4296,7 +4526,6 @@ class Cmd(cmd.Cmd):
 
                 saved_cmd2_env = None
 
-                # noinspection PyBroadException
                 try:
                     # Get sigint protection while we set up the Python shell environment
                     with self.sigint_protection:
@@ -4377,7 +4606,6 @@ class Cmd(cmd.Cmd):
 
     ipython_parser = argparse_custom.DEFAULT_ARGUMENT_PARSER(description="Run an interactive IPython shell")
 
-    # noinspection PyPackageRequirements
     @with_argparser(ipython_parser)
     def do_ipy(self, _: argparse.Namespace) -> Optional[bool]:  # pragma: no cover
         """
@@ -4390,9 +4618,13 @@ class Cmd(cmd.Cmd):
         # Detect whether IPython is installed
         try:
             import traitlets.config.loader as TraitletsLoader  # type: ignore[import]
-            from IPython import (  # type: ignore[import]
-                start_ipython,
-            )
+
+            # Allow users to install ipython from a cmd2 prompt when needed and still have ipy command work
+            try:
+                start_ipython  # noqa F823
+            except NameError:
+                from IPython import start_ipython  # type: ignore[import]
+
             from IPython.terminal.interactiveshell import (  # type: ignore[import]
                 TerminalInteractiveShell,
             )
@@ -4426,14 +4658,14 @@ class Cmd(cmd.Cmd):
                 local_vars['self'] = self
 
             # Configure IPython
-            config = TraitletsLoader.Config()
+            config = TraitletsLoader.Config()  # type: ignore
             config.InteractiveShell.banner2 = (
                 'Entering an IPython shell. Type exit, quit, or Ctrl-D to exit.\n'
                 f'Run CLI commands with: {self.py_bridge_name}("command ...")\n'
             )
 
             # Start IPython
-            start_ipython(config=config, argv=[], user_ns=local_vars)
+            start_ipython(config=config, argv=[], user_ns=local_vars)  # type: ignore[no-untyped-call]
             self.poutput("Now exiting IPython shell...")
 
             # The IPython application is a singleton and won't be recreated next time
@@ -4467,22 +4699,22 @@ class Cmd(cmd.Cmd):
 
     history_format_group = history_parser.add_argument_group(title='formatting')
     history_format_group.add_argument(
-        '-s', '--script', action='store_true', help='output commands in script format, i.e. without command\n' 'numbers'
+        '-s', '--script', action='store_true', help='output commands in script format, i.e. without command\nnumbers'
     )
     history_format_group.add_argument(
         '-x',
         '--expanded',
         action='store_true',
-        help='output fully parsed commands with any aliases and\n' 'macros expanded, instead of typed commands',
+        help='output fully parsed commands with any aliases and\nmacros expanded, instead of typed commands',
     )
     history_format_group.add_argument(
         '-v',
         '--verbose',
         action='store_true',
-        help='display history and include expanded commands if they\n' 'differ from the typed command',
+        help='display history and include expanded commands if they\ndiffer from the typed command',
     )
     history_format_group.add_argument(
-        '-a', '--all', action='store_true', help='display all commands, including ones persisted from\n' 'previous sessions'
+        '-a', '--all', action='store_true', help='display all commands, including ones persisted from\nprevious sessions'
     )
 
     history_arg_help = (
@@ -4548,8 +4780,6 @@ class Cmd(cmd.Cmd):
                 self.last_result = True
                 return stop
         elif args.edit:
-            import tempfile
-
             fd, fname = tempfile.mkstemp(suffix='.txt', text=True)
             fobj: TextIO
             with os.fdopen(fd, 'w') as fobj:
@@ -4562,7 +4792,6 @@ class Cmd(cmd.Cmd):
                 self.run_editor(fname)
 
                 # self.last_resort will be set by do_run_script()
-                # noinspection PyTypeChecker
                 return self.do_run_script(utils.quote_string(fname))
             finally:
                 os.remove(fname)
@@ -4622,11 +4851,9 @@ class Cmd(cmd.Cmd):
                           previous sessions will be included. Additionally, all history will be written
                           to this file when the application exits.
         """
-        import json
-        import lzma
-
         self.history = History()
-        # with no persistent history, nothing else in this method is relevant
+
+        # With no persistent history, nothing else in this method is relevant
         if not hist_file:
             self.persistent_history_file = hist_file
             return
@@ -4647,64 +4874,96 @@ class Cmd(cmd.Cmd):
             self.perror(f"Error creating persistent history file directory '{hist_file_dir}': {ex}")
             return
 
-        # Read and process history file
+        # Read history file
         try:
             with open(hist_file, 'rb') as fobj:
                 compressed_bytes = fobj.read()
-            history_json = lzma.decompress(compressed_bytes).decode(encoding='utf-8')
-            self.history = History.from_json(history_json)
         except FileNotFoundError:
-            # Just use an empty history
-            pass
+            compressed_bytes = bytes()
         except OSError as ex:
             self.perror(f"Cannot read persistent history file '{hist_file}': {ex}")
             return
-        except (json.JSONDecodeError, lzma.LZMAError, KeyError, UnicodeDecodeError, ValueError) as ex:
+
+        # Register a function to write history at save
+        import atexit
+
+        self.persistent_history_file = hist_file
+        atexit.register(self._persist_history)
+
+        # Empty or nonexistent history file. Nothing more to do.
+        if not compressed_bytes:
+            return
+
+        # Decompress history data
+        try:
+            import lzma as decompress_lib
+
+            decompress_exceptions: Tuple[type[Exception]] = (decompress_lib.LZMAError,)
+        except ModuleNotFoundError:  # pragma: no cover
+            import bz2 as decompress_lib  # type: ignore[no-redef]
+
+            decompress_exceptions: Tuple[type[Exception]] = (OSError, ValueError)  # type: ignore[no-redef]
+
+        try:
+            history_json = decompress_lib.decompress(compressed_bytes).decode(encoding='utf-8')
+        except decompress_exceptions as ex:
+            self.perror(
+                f"Error decompressing persistent history data '{hist_file}': {ex}\n"
+                f"The history file will be recreated when this application exits."
+            )
+            return
+
+        # Decode history json
+        import json
+
+        try:
+            self.history = History.from_json(history_json)
+        except (json.JSONDecodeError, KeyError, ValueError) as ex:
             self.perror(
-                f"Error processing persistent history file '{hist_file}': {ex}\n"
+                f"Error processing persistent history data '{hist_file}': {ex}\n"
                 f"The history file will be recreated when this application exits."
             )
+            return
 
         self.history.start_session()
-        self.persistent_history_file = hist_file
 
-        # populate readline history
+        # Populate readline history
         if rl_type != RlType.NONE:
-            last = None
             for item in self.history:
-                # Break the command into its individual lines
-                for line in item.raw.splitlines():
-                    # readline only adds a single entry for multiple sequential identical lines
-                    # so we emulate that behavior here
-                    if line != last:
-                        readline.add_history(line)
-                        last = line
-
-        # register a function to write history at save
-        # if the history file is in plain text format from 0.9.12 or lower
-        # this will fail, and the history in the plain text file will be lost
-        import atexit
+                formatted_command = single_line_format(item.statement)
 
-        atexit.register(self._persist_history)
+                # If formatted command is different than the previous history item, add it
+                cur_history_length = readline.get_current_history_length()
+                if cur_history_length == 0 or formatted_command != readline.get_history_item(cur_history_length):
+                    readline.add_history(formatted_command)
 
     def _persist_history(self) -> None:
         """Write history out to the persistent history file as compressed JSON"""
-        import lzma
-
         if not self.persistent_history_file:
             return
 
-        self.history.truncate(self._persistent_history_length)
         try:
-            history_json = self.history.to_json()
-            compressed_bytes = lzma.compress(history_json.encode(encoding='utf-8'))
+            import lzma as compress_lib
+        except ModuleNotFoundError:  # pragma: no cover
+            import bz2 as compress_lib  # type: ignore[no-redef]
+
+        self.history.truncate(self._persistent_history_length)
+        history_json = self.history.to_json()
+        compressed_bytes = compress_lib.compress(history_json.encode(encoding='utf-8'))
 
+        try:
             with open(self.persistent_history_file, 'wb') as fobj:
                 fobj.write(compressed_bytes)
         except OSError as ex:
             self.perror(f"Cannot write persistent history file '{self.persistent_history_file}': {ex}")
 
-    def _generate_transcript(self, history: Union[List[HistoryItem], List[str]], transcript_file: str) -> None:
+    def _generate_transcript(
+        self,
+        history: Union[List[HistoryItem], List[str]],
+        transcript_file: str,
+        *,
+        add_to_history: bool = True,
+    ) -> None:
         """Generate a transcript file from a given history of commands"""
         self.last_result = False
 
@@ -4754,7 +5013,11 @@ class Cmd(cmd.Cmd):
 
                 # then run the command and let the output go into our buffer
                 try:
-                    stop = self.onecmd_plus_hooks(history_item, raise_keyboard_interrupt=True)
+                    stop = self.onecmd_plus_hooks(
+                        history_item,
+                        add_to_history=add_to_history,
+                        raise_keyboard_interrupt=True,
+                    )
                 except KeyboardInterrupt as ex:
                     self.perror(ex)
                     stop = True
@@ -4826,7 +5089,6 @@ class Cmd(cmd.Cmd):
         if file_path:
             command += " " + utils.quote_string(os.path.expanduser(file_path))
 
-        # noinspection PyTypeChecker
         self.do_shell(command)
 
     @property
@@ -4899,9 +5161,17 @@ class Cmd(cmd.Cmd):
 
             if args.transcript:
                 # self.last_resort will be set by _generate_transcript()
-                self._generate_transcript(script_commands, os.path.expanduser(args.transcript))
+                self._generate_transcript(
+                    script_commands,
+                    os.path.expanduser(args.transcript),
+                    add_to_history=self.scripts_add_to_history,
+                )
             else:
-                stop = self.runcmds_plus_hooks(script_commands, stop_on_keyboard_interrupt=True)
+                stop = self.runcmds_plus_hooks(
+                    script_commands,
+                    add_to_history=self.scripts_add_to_history,
+                    stop_on_keyboard_interrupt=True,
+                )
                 self.last_result = True
                 return stop
 
@@ -4919,7 +5189,7 @@ class Cmd(cmd.Cmd):
         "interpreted relative to the already-running script's directory."
     )
 
-    relative_run_script_epilog = "Notes:\n" "  This command is intended to only be used within text file scripts."
+    relative_run_script_epilog = "Notes:\n  This command is intended to only be used within text file scripts."
 
     relative_run_script_parser = argparse_custom.DEFAULT_ARGUMENT_PARSER(
         description=relative_run_script_description, epilog=relative_run_script_epilog
@@ -4938,7 +5208,6 @@ class Cmd(cmd.Cmd):
         relative_path = os.path.join(self._current_script_dir or '', file_path)
 
         # self.last_result will be set by do_run_script()
-        # noinspection PyTypeChecker
         return self.do_run_script(utils.quote_string(relative_path))
 
     def _run_transcript_tests(self, transcript_paths: List[str]) -> None:
@@ -4981,7 +5250,6 @@ class Cmd(cmd.Cmd):
         sys.argv = [sys.argv[0]]  # the --test argument upsets unittest.main()
         testcase = TestMyAppCase()
         stream = cast(TextIO, utils.StdSim(sys.stderr))
-        # noinspection PyTypeChecker
         runner = unittest.TextTestRunner(stream=stream)
         start_time = time.time()
         test_results = runner.run(testcase)
@@ -4989,8 +5257,8 @@ class Cmd(cmd.Cmd):
         if test_results.wasSuccessful():
             ansi.style_aware_write(sys.stderr, stream.read())
             finish_msg = f' {num_transcripts} transcript{plural} passed in {execution_time:.3f} seconds '
-            finish_msg = ansi.style_success(utils.align_center(finish_msg, fill_char='='))
-            self.poutput(finish_msg)
+            finish_msg = utils.align_center(finish_msg, fill_char='=')
+            self.psuccess(finish_msg)
         else:
             # Strip off the initial traceback which isn't particularly useful for end users
             error_str = stream.read()
@@ -5007,16 +5275,16 @@ class Cmd(cmd.Cmd):
     def async_alert(self, alert_msg: str, new_prompt: Optional[str] = None) -> None:  # pragma: no cover
         """
         Display an important message to the user while they are at a command line prompt.
-        To the user it appears as if an alert message is printed above the prompt and their current input
-        text and cursor location is left alone.
+        To the user it appears as if an alert message is printed above the prompt and their
+        current input text and cursor location is left alone.
 
-        IMPORTANT: This function will not print an alert unless it can acquire self.terminal_lock to ensure
-                   a prompt is onscreen. Therefore, it is best to acquire the lock before calling this function
-                   to guarantee the alert prints and to avoid raising a RuntimeError.
+        This function needs to acquire self.terminal_lock to ensure a prompt is on screen.
+        Therefore, it is best to acquire the lock before calling this function to avoid
+        raising a RuntimeError.
 
-                   This function is only needed when you need to print an alert while the main thread is blocking
-                   at the prompt. Therefore, this should never be called from the main thread. Doing so will
-                   raise a RuntimeError.
+        This function is only needed when you need to print an alert or update the prompt while the
+        main thread is blocking at the prompt. Therefore, this should never be called from the main
+        thread. Doing so will raise a RuntimeError.
 
         :param alert_msg: the message to display to the user
         :param new_prompt: If you also want to change the prompt that is displayed, then include it here.
@@ -5032,7 +5300,6 @@ class Cmd(cmd.Cmd):
 
         # Sanity check that can't fail if self.terminal_lock was acquired before calling this function
         if self.terminal_lock.acquire(blocking=False):
-
             # Windows terminals tend to flicker when we redraw the prompt and input lines.
             # To reduce how often this occurs, only update terminal if there are changes.
             update_terminal = False
@@ -5044,20 +5311,21 @@ class Cmd(cmd.Cmd):
             if new_prompt is not None:
                 self.prompt = new_prompt
 
-            # Check if the prompt to display has changed from what's currently displayed
-            cur_onscreen_prompt = rl_get_prompt()
-            new_onscreen_prompt = self.continuation_prompt if self._at_continuation_prompt else self.prompt
-
-            if new_onscreen_prompt != cur_onscreen_prompt:
+            # Check if the onscreen prompt needs to be refreshed to match self.prompt.
+            if self.need_prompt_refresh():
                 update_terminal = True
+                rl_set_prompt(self.prompt)
 
             if update_terminal:
                 import shutil
 
-                # Generate the string which will replace the current prompt and input lines with the alert
+                # Prior to Python 3.11 this can return 0, so use a fallback if needed.
+                terminal_columns = shutil.get_terminal_size().columns or constants.DEFAULT_TERMINAL_WIDTH
+
+                # Print a string which replaces the onscreen prompt and input lines with the alert.
                 terminal_str = ansi.async_alert_str(
-                    terminal_columns=shutil.get_terminal_size().columns,
-                    prompt=cur_onscreen_prompt,
+                    terminal_columns=terminal_columns,
+                    prompt=rl_get_display_prompt(),
                     line=readline.get_line_buffer(),
                     cursor_offset=rl_get_point(),
                     alert_msg=alert_msg,
@@ -5066,12 +5334,8 @@ class Cmd(cmd.Cmd):
                     sys.stderr.write(terminal_str)
                     sys.stderr.flush()
                 elif rl_type == RlType.PYREADLINE:
-                    # noinspection PyUnresolvedReferences
                     readline.rl.mode.console.write(terminal_str)
 
-                # Update Readline's prompt before we redraw it
-                rl_set_prompt(new_onscreen_prompt)
-
                 # Redraw the prompt and input lines below the alert
                 rl_force_redisplay()
 
@@ -5082,23 +5346,17 @@ class Cmd(cmd.Cmd):
 
     def async_update_prompt(self, new_prompt: str) -> None:  # pragma: no cover
         """
-        Update the command line prompt while the user is still typing at it. This is good for alerting the user to
-        system changes dynamically in between commands. For instance you could alter the color of the prompt to
-        indicate a system status or increase a counter to report an event. If you do alter the actual text of the
-        prompt, it is best to keep the prompt the same width as what's on screen. Otherwise the user's input text will
-        be shifted and the update will not be seamless.
+        Update the command line prompt while the user is still typing at it.
 
-        IMPORTANT: This function will not update the prompt unless it can acquire self.terminal_lock to ensure
-                   a prompt is onscreen. Therefore, it is best to acquire the lock before calling this function
-                   to guarantee the prompt changes and to avoid raising a RuntimeError.
+        This is good for alerting the user to system changes dynamically in between commands.
+        For instance you could alter the color of the prompt to indicate a system status or increase a
+        counter to report an event. If you do alter the actual text of the prompt, it is best to keep
+        the prompt the same width as what's on screen. Otherwise the user's input text will be shifted
+        and the update will not be seamless.
 
-                   This function is only needed when you need to update the prompt while the main thread is blocking
-                   at the prompt. Therefore, this should never be called from the main thread. Doing so will
-                   raise a RuntimeError.
-
-                   If user is at a continuation prompt while entering a multiline command, the onscreen prompt will
-                   not change. However, self.prompt will still be updated and display immediately after the multiline
-                   line command completes.
+        If user is at a continuation prompt while entering a multiline command, the onscreen prompt will
+        not change. However, self.prompt will still be updated and display immediately after the multiline
+        line command completes.
 
         :param new_prompt: what to change the prompt to
         :raises RuntimeError: if called from the main thread.
@@ -5106,6 +5364,32 @@ class Cmd(cmd.Cmd):
         """
         self.async_alert('', new_prompt)
 
+    def async_refresh_prompt(self) -> None:  # pragma: no cover
+        """
+        Refresh the oncreen prompt to match self.prompt.
+
+        One case where the onscreen prompt and self.prompt can get out of sync is
+        when async_alert() is called while a user is in search mode (e.g. Ctrl-r).
+        To prevent overwriting readline's onscreen search prompt, self.prompt is updated
+        but readline's saved prompt isn't.
+
+        Therefore when a user aborts a search, the old prompt is still on screen until they
+        press Enter or this method is called. Call need_prompt_refresh() in an async print
+        thread to know when a refresh is needed.
+
+        :raises RuntimeError: if called from the main thread.
+        :raises RuntimeError: if called while another thread holds `terminal_lock`
+        """
+        self.async_alert('')
+
+    def need_prompt_refresh(self) -> bool:  # pragma: no cover
+        """Check whether the onscreen prompt needs to be asynchronously refreshed to match self.prompt."""
+        if not (vt100_support and self.use_rawinput):
+            return False
+
+        # Don't overwrite a readline search prompt or a continuation prompt.
+        return not rl_in_search_mode() and not self._at_continuation_prompt and self.prompt != rl_get_prompt()
+
     @staticmethod
     def set_window_title(title: str) -> None:  # pragma: no cover
         """
@@ -5136,12 +5420,13 @@ class Cmd(cmd.Cmd):
         if command not in self.disabled_commands:
             return
 
+        cmd_func_name = constants.COMMAND_FUNC_PREFIX + command
         help_func_name = constants.HELP_FUNC_PREFIX + command
         completer_func_name = constants.COMPLETER_FUNC_PREFIX + command
 
         # Restore the command function to its original value
         dc = self.disabled_commands[command]
-        setattr(self, self._cmd_func_name(command), dc.command_function)
+        setattr(self, cmd_func_name, dc.command_function)
 
         # Restore the help function to its original value
         if dc.help_function is None:
@@ -5189,6 +5474,7 @@ class Cmd(cmd.Cmd):
         if command_function is None:
             raise AttributeError(f"'{command}' does not refer to a command")
 
+        cmd_func_name = constants.COMMAND_FUNC_PREFIX + command
         help_func_name = constants.HELP_FUNC_PREFIX + command
         completer_func_name = constants.COMPLETER_FUNC_PREFIX + command
 
@@ -5203,7 +5489,7 @@ class Cmd(cmd.Cmd):
         new_func = functools.partial(
             self._report_disabled_command_usage, message_to_print=message_to_print.replace(constants.COMMAND_NAME, command)
         )
-        setattr(self, self._cmd_func_name(command), new_func)
+        setattr(self, cmd_func_name, new_func)
         setattr(self, help_func_name, new_func)
 
         # Set the completer to a function that returns a blank list
@@ -5249,15 +5535,22 @@ class Cmd(cmd.Cmd):
         """
         # cmdloop() expects to be run in the main thread to support extensive use of KeyboardInterrupts throughout the
         # other built-in functions. You are free to override cmdloop, but much of cmd2's features will be limited.
-        if not threading.current_thread() is threading.main_thread():
+        if threading.current_thread() is not threading.main_thread():
             raise RuntimeError("cmdloop must be run in the main thread")
 
-        # Register a SIGINT signal handler for Ctrl+C
+        # Register signal handlers
         import signal
 
         original_sigint_handler = signal.getsignal(signal.SIGINT)
         signal.signal(signal.SIGINT, self.sigint_handler)
 
+        if not sys.platform.startswith('win'):
+            original_sighup_handler = signal.getsignal(signal.SIGHUP)
+            signal.signal(signal.SIGHUP, self.termination_signal_handler)
+
+            original_sigterm_handler = signal.getsignal(signal.SIGTERM)
+            signal.signal(signal.SIGTERM, self.termination_signal_handler)
+
         # Grab terminal lock before the command line prompt has been drawn by readline
         self.terminal_lock.acquire()
 
@@ -5290,9 +5583,13 @@ class Cmd(cmd.Cmd):
         # This will also zero the lock count in case cmdloop() is called again
         self.terminal_lock.release()
 
-        # Restore the original signal handler
+        # Restore original signal handlers
         signal.signal(signal.SIGINT, original_sigint_handler)
 
+        if not sys.platform.startswith('win'):
+            signal.signal(signal.SIGHUP, original_sighup_handler)
+            signal.signal(signal.SIGTERM, original_sigterm_handler)
+
         return self.exit_code
 
     ###
@@ -5374,7 +5671,7 @@ class Cmd(cmd.Cmd):
             raise TypeError(f'{func.__name__} does not have a declared return type, expected {data_type}')
         if signature.return_annotation != data_type:
             raise TypeError(
-                f'{func.__name__} has incompatible return type {signature.return_annotation}, expected ' f'{data_type}'
+                f'{func.__name__} has incompatible return type {signature.return_annotation}, expected {data_type}'
             )
 
     def register_precmd_hook(self, func: Callable[[plugin.PrecommandData], plugin.PrecommandData]) -> None:
@@ -5443,7 +5740,7 @@ class Cmd(cmd.Cmd):
                 func_self = None
                 candidate_sets: List[CommandSet] = []
                 for installed_cmd_set in self._installed_command_sets:
-                    if type(installed_cmd_set) == func_class:
+                    if type(installed_cmd_set) == func_class:  # noqa: E721
                         # Case 2: CommandSet is an exact type match for the function's CommandSet
                         func_self = installed_cmd_set
                         break