cmd2 4.2.3__tar.gz → 4.2.4__tar.gz

{cmd2-4.2.3 → cmd2-4.2.4}/.pre-commit-config.yaml

@@ -15,7 +15,7 @@ repos:
       - id: trailing-whitespace
 
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: "v0.16.5"
+    rev: "v0.16.6"
     hooks:
       - id: ruff-format
         args: [--config=ruff.toml]

{cmd2-4.2.3 → cmd2-4.2.4}/CHANGELOG.md

@@ -1,3 +1,16 @@
+## 4.2.4 (September 8, 2026)
+
+- Bug Fixes
+    - Fixed output redirection and piping raising `UnicodeEncodeError` and leaving an empty file
+      behind. Command output is rendered by Rich and contains box-drawing characters, which no
+      `cp125x` Windows ANSI code page can represent, so redirecting or piping it failed. This
+      affects current Windows 11 with default settings on Python 3.11 through 3.14, not only older
+      systems. Redirection targets and pipes now use UTF-8 explicitly
+    - Fixed the right prompt being redrawn beside every accepted command line in the scrollback.
+      prompt-toolkit includes it in the final frame of each prompt, which is the frame left on the
+      terminal; it is now hidden there, as the bottom toolbar already was, and stays on the live
+      prompt line only
+
 ## 4.2.3 (September 2, 2026)
 
 - Bug Fixes

cmd2-4.2.4/CLAUDE.md

@@ -0,0 +1,123 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this
+repository.
+
+## Project
+
+`cmd2` is a framework for building interactive command-line applications (REPLs) in Python. It
+extends the stdlib `cmd` module and is built on **prompt-toolkit** (interactive input, key bindings,
+completion, toolbars) and **Rich** / **rich-argparse** (all output rendering, help formatting,
+theming). Requires Python >= 3.11. Environment/package management is **uv**.
+
+## Commands
+
+All work happens inside the uv-managed venv — run Python via `uv run ...`, and `uvx ...` for one-off
+tools. Never `pip install`; if a new dependency is needed, state why before adding it.
+
+```bash
+make install     # create the venv, install prek git hooks + prettier (one time)
+make check       # lock check + prek (ruff format/lint, prettier, typos) + ty + mypy
+make test        # pytest with coverage over tests/
+make docs-test   # verify the docs build cleanly (zensical)
+make docs        # build + serve docs with live reload
+make help        # list all targets
+```
+
+`make check`, `make test`, and `make docs-test` must all pass before committing. Run `make check`
+before creating or modifying any `.py` file as well.
+
+Narrower targets: `make format`, `make lint`, `make mypy`, `make ty`, `make typecheck`.
+
+Running a single test or file (coverage flags come from `pyproject.toml` `addopts`, so pass
+`--no-cov` when you just want a fast run):
+
+```bash
+uv run pytest tests/test_cmd2.py --no-cov
+uv run pytest tests/test_cmd2.py::test_base_help -x --no-cov
+uv run pytest -k "toolbar" --no-cov
+```
+
+On Windows-sensitive code, note `make test` runs pytest under `python -Xutf8`.
+
+## Architecture
+
+### Command dispatch
+
+`cmd2/cmd2.py` (the `Cmd` class) is the core and by far the largest module. The flow for one line of
+input is:
+
+1. `cmdloop()` → `_cmdloop()` drives a prompt-toolkit `PromptSession` (created in
+   `_create_prompt_session`), not readline. Completion, history, lexing, and key bindings are all
+   supplied by prompt-toolkit adapters in `cmd2/pt_utils.py` (`Cmd2Completer`, `Cmd2History`,
+   `Cmd2Lexer`).
+2. `onecmd_plus_hooks()` parses the line into a `Statement` (`cmd2/parsing.py` — handles shortcuts,
+   aliases, macros, terminators, multiline commands, redirection and pipe tokens), then runs the
+   plugin hook chain.
+3. `_redirect_output()` swaps `self.stdout` for a file or subprocess pipe when the statement has
+   redirection, and restores it in the `finally` path.
+4. `onecmd()` looks up and calls the `do_*` method.
+
+Hooks (`cmd2/plugin.py` dataclasses, registered via `register_postparsing_hook`,
+`register_precmd_hook`, `register_postcmd_hook`, `register_cmdfinalization_hook`,
+`register_preloop_hook`, `register_postloop_hook`) are the supported extension points; the legacy
+`precmd`/`postcmd` overrides still exist but are weaker.
+
+### Argument parsing and completion
+
+Three layers, all producing a `Cmd2ArgumentParser`:
+
+- `cmd2/argparse_utils.py` — `Cmd2ArgumentParser` plus monkey-patching that extends argparse with
+  range `nargs` tuples, per-argument completion metadata, and subcommand records.
+- `cmd2/decorators.py` — `@with_argparser`, `@with_argument_list`, `@with_category`,
+  `@as_subcommand_to` attach parsers/metadata to `do_*` methods.
+- `cmd2/annotated.py` — the newer, still-experimental Typer-style path: `@with_annotated` builds a
+  parser from a function's type hints, with `Argument`/`Option` metadata via `typing.Annotated`.
+
+Parsers are built lazily and cached by the `CommandParsers` class in `cmd2.py` (`_build_parser`), so
+that `CommandSet`-supplied subcommands can be attached and detached at runtime.
+`cmd2/argparse_completer.py` walks a parser to produce tab completions; completion results are
+`Completions`/`CompletionItem` objects from `cmd2/completion.py`.
+
+### Output and theming
+
+Never print directly — go through `Cmd.print_to` / `poutput` / `perror` / `pwarning` / `pfeedback` /
+`ppaged`, which route to Rich consoles defined in `cmd2/rich_utils.py` (`Cmd2GeneralConsole`,
+`Cmd2RichArgparseConsole`, `Cmd2ExceptionConsole`). Styling flows one way: `cmd2/styles.py`
+(style-name StrEnum + defaults) → `cmd2/theme.py` (single global theme, updated in-place for Rich
+and exposed to prompt-toolkit through a `DynamicStyle`) → `cmd2/pt_utils.py` (`rich_to_pt_style`
+converts Rich styles into prompt-toolkit ones). Adding a color or style means touching
+`styles.py`/`colors.py`/`theme.py`, not hardcoding ANSI.
+
+`cmd2/command_toolbar.py` and `cmd2/pager.py` are the trickiest parts of the codebase: they keep a
+prompt-toolkit application alive _during_ synchronous command execution (bottom toolbar refresh,
+paging) while stdout is proxied and redirection may be active. Changes there need care around
+threads, signals, and Windows behavior.
+
+### Modularity
+
+`cmd2/command_set.py` (`CommandSet`) lets commands live in separate classes that are registered and
+unregistered at runtime via `Cmd.register_command_set`; `cmd2/py_bridge.py` exposes the app to
+embedded Python/IPython shells and `run_pyscript` while keeping isolation.
+
+## Conventions
+
+- Ruff is authoritative for format and lint (`ruff.toml`, line length 127, double quotes). Do not
+  suppress lint errors in code you write; broad ignores already exist for `examples/` and `tests/`.
+- Both `mypy --strict` and `ty` must pass on the `cmd2` package. Full type annotations are required
+  on all library code (excluded: `tests/`, `examples/`, `docs/`).
+- Docstrings are enforced by pydocstyle rules; public API items are documented in `docs/api/*.md`
+  and rendered by mkdocstrings, so keep docstrings accurate when changing signatures.
+- Anything not documented under `docs/api/` is not public API (`cmd2/constants.py` says so
+  explicitly).
+- Add user-visible changes to `CHANGELOG.md` under the current in-progress version heading.
+- `main` is the branch for the next PATCH release; MAJOR/MINOR work happens on a branch named for
+  the target version. Releases are tagged and published from `main`.
+- Do not commit spec, plan, or markdown documents without asking first. Save plans to
+  `~/.superpowers/plans/` rather than the project directory.
+
+## Commit conventions
+
+Never add "Co-Authored-By" lines to commits. Do not include Claude attribution in commit messages,
+PR descriptions, or any git metadata. Do not include Claude session URL in commit messages, PR
+descriptions, or any git metadata.

{cmd2-4.2.3 → cmd2-4.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cmd2
-Version: 4.2.3
+Version: 4.2.4
 Summary: cmd2 - quickly build feature-rich and user-friendly interactive command line applications in Python
 Author: cmd2 Contributors
 License-Expression: MIT
@@ -251,6 +251,7 @@ reproduce the bug. At a minimum, please state the following:
 | [Falcon Toolkit](https://github.com/CrowdStrike/Falcon-Toolkit) | Unleash the power of the CrowdStrike Falcon Platform at the CLI                                                                  | [CrowdStrike](https://github.com/CrowdStrike)                         |
 | [EXPLIoT](https://gitlab.com/expliot_framework/expliot)         | Internet of Things Security Testing and Exploitation framework                                                                   | [expliot_framework](https://gitlab.com/expliot_framework/)            |
 | [Pobshell](https://github.com/pdalloz/pobshell)                 | A Bash‑like shell for live Python objects: `cd`, `ls`, `cat`, `find` and _CLI piping_ for object code, str values & more         | [Peter Dalloz](https://www.linkedin.com/in/pdalloz)                   |
+| [Wtsh](https://gitee.com/wazzge/wtsh)                           | WTSH is a shell built with Python cmd2(v4), which uses third-party plugins to construct a universal shell installed via Pip      | [wazzge](https://gitee.com/wazzge)                                    |
 
 Possibly defunct but still good examples
 

{cmd2-4.2.3 → cmd2-4.2.4}/README.md

@@ -222,6 +222,7 @@ reproduce the bug. At a minimum, please state the following:
 | [Falcon Toolkit](https://github.com/CrowdStrike/Falcon-Toolkit) | Unleash the power of the CrowdStrike Falcon Platform at the CLI                                                                  | [CrowdStrike](https://github.com/CrowdStrike)                         |
 | [EXPLIoT](https://gitlab.com/expliot_framework/expliot)         | Internet of Things Security Testing and Exploitation framework                                                                   | [expliot_framework](https://gitlab.com/expliot_framework/)            |
 | [Pobshell](https://github.com/pdalloz/pobshell)                 | A Bash‑like shell for live Python objects: `cd`, `ls`, `cat`, `find` and _CLI piping_ for object code, str values & more         | [Peter Dalloz](https://www.linkedin.com/in/pdalloz)                   |
+| [Wtsh](https://gitee.com/wazzge/wtsh)                           | WTSH is a shell built with Python cmd2(v4), which uses third-party plugins to construct a universal shell installed via Pip      | [wazzge](https://gitee.com/wazzge)                                    |
 
 Possibly defunct but still good examples
 

{cmd2-4.2.3 → cmd2-4.2.4}/cmd2/annotated.py

@@ -313,6 +313,7 @@ from .rich_utils import Cmd2HelpFormatter, HelpContent
 from .types import (
     BoundCommandFunc,
     CmdOrSetT,
+    CmdOrSetT_contra,
     UnboundChoicesProvider,
     UnboundCompleter,
 )
@@ -2907,23 +2908,25 @@ class _BoundAnnotatedCommand(Protocol[_CommandParams, _CommandReturn_co]):
     def __call__(self, *args: _CommandParams.args, **kwargs: _CommandParams.kwargs) -> _CommandReturn_co: ...
 
 
-class _AnnotatedCommand(Protocol[CmdOrSetT, _CommandParams, _CommandReturn_co]):
+class _AnnotatedCommand(Protocol[CmdOrSetT_contra, _CommandParams, _CommandReturn_co]):
     """A callable command method with the metadata used by ``with_annotated``."""
 
     __name__: str
     __qualname__: str
 
     def __call__(
-        self, __self: CmdOrSetT, /, *args: _CommandParams.args, **kwargs: _CommandParams.kwargs
+        self, __self: CmdOrSetT_contra, /, *args: _CommandParams.args, **kwargs: _CommandParams.kwargs
     ) -> _CommandReturn_co: ...
 
     @overload
     def __get__(
         self, instance: None, owner: Any = ...
-    ) -> "_AnnotatedCommand[CmdOrSetT, _CommandParams, _CommandReturn_co]": ...
+    ) -> "_AnnotatedCommand[CmdOrSetT_contra, _CommandParams, _CommandReturn_co]": ...
 
     @overload
-    def __get__(self, instance: CmdOrSetT, owner: Any = ...) -> _BoundAnnotatedCommand[_CommandParams, _CommandReturn_co]: ...
+    def __get__(
+        self, instance: CmdOrSetT_contra, owner: Any = ...
+    ) -> _BoundAnnotatedCommand[_CommandParams, _CommandReturn_co]: ...
 
 
 class _WithAnnotatedDecorator(Protocol):

{cmd2-4.2.3 → cmd2-4.2.4}/cmd2/cmd2.py

@@ -80,6 +80,8 @@ from prompt_toolkit.input import DummyInput, create_input
 from prompt_toolkit.key_binding import KeyBindings
 from prompt_toolkit.key_binding.key_processor import KeyPress, KeyPressEvent
 from prompt_toolkit.keys import Keys
+from prompt_toolkit.layout import Window, walk
+from prompt_toolkit.layout.containers import ConditionalContainer, FloatContainer
 from prompt_toolkit.output import DummyOutput, create_output
 from prompt_toolkit.patch_stdout import patch_stdout
 from prompt_toolkit.shortcuts import CompleteStyle, PromptSession, choice, set_title
@@ -552,6 +554,8 @@ class Cmd:
             enable_rprompt=enable_rprompt,
             refresh_interval=refresh_interval,
         )
+        if enable_rprompt:
+            self._hide_rprompt_when_done(self.main_session)
 
         # The session currently holding focus (either the main REPL or a command's
         # custom prompt). Completion and UI logic should reference this variable
@@ -845,6 +849,30 @@ class Cmd:
         )
         return PromptSession(**kwargs)
 
+    @staticmethod
+    def _hide_rprompt_when_done(session: PromptSession[str]) -> None:
+        """Keep the right prompt out of the frame that is committed to the scrollback.
+
+        prompt-toolkit ends every ``Application.run()`` with a final render, and that
+        frame is what stays on the terminal. Its bottom toolbar container is filtered
+        with ``~is_done`` so it is excluded, but the right prompt is a plain ``Float``
+        with no such filter, which left a copy of the right prompt beside every
+        accepted command line. This applies the same rule the toolbar already gets.
+
+        The right prompt is cosmetic, so an upstream layout change must not stop the
+        application from starting. If the float cannot be found, nothing happens and
+        the previous behavior remains.
+
+        :param session: the PromptSession whose right prompt should be hidden when done
+        """
+        for container in walk(session.layout.container):
+            if not isinstance(container, FloatContainer):
+                continue
+            for float_ in container.floats:
+                content = float_.content
+                if isinstance(content, Window) and content.style == "class:rprompt":
+                    float_.content = ConditionalContainer(content, filter=~filters.is_done)
+
     def find_commandsets(
         self, commandset_type: type[CommandSet[Any]], *, subclass_match: bool = False
     ) -> list[CommandSet[Any]]:
@@ -3296,9 +3324,11 @@ class Cmd:
             # Create a pipe with read and write sides
             read_fd, write_fd = os.pipe()
 
-            # Open each side of the pipe
-            subproc_stdin = open(read_fd)  # noqa: SIM115
-            new_stdout: TextIO = cast(TextIO, open(write_fd, "w"))  # noqa: SIM115
+            # Open each side of the pipe. Both ends are given an explicit encoding:
+            # command output is rendered by Rich and routinely contains non-ASCII, which
+            # the locale encoding cannot always represent.
+            subproc_stdin = open(read_fd, encoding="utf-8")  # noqa: SIM115
+            new_stdout: TextIO = cast(TextIO, open(write_fd, "w", encoding="utf-8"))  # noqa: SIM115
 
             # Create pipe process in a separate group to isolate our signals from it. If a Ctrl-C event occurs,
             # our sigint handler will forward it only to the most recent pipe process. This makes sure pipe
@@ -3347,8 +3377,15 @@ class Cmd:
                 # statement.output can only contain REDIRECTION_APPEND or REDIRECTION_OUTPUT
                 mode = "a" if statement.redirector == constants.REDIRECTION_APPEND else "w"
                 try:
-                    # Use line buffering
-                    new_stdout = cast(TextIO, open(su.strip_quotes(statement.redirect_to), mode=mode, buffering=1))  # noqa: SIM115
+                    # Use line buffering. The encoding is explicit rather than the
+                    # locale's: command output is rendered by Rich and routinely contains
+                    # non-ASCII, so on a non-UTF-8 system -- a default Windows console,
+                    # for instance -- redirection would otherwise fail and leave an empty
+                    # file behind.
+                    new_stdout = cast(
+                        TextIO,
+                        open(su.strip_quotes(statement.redirect_to), mode=mode, buffering=1, encoding="utf-8"),  # noqa: SIM115
+                    )
                 except OSError as ex:
                     raise RedirectionError("Failed to redirect output") from ex
 

{cmd2-4.2.3 → cmd2-4.2.4}/cmd2/types.py

@@ -58,6 +58,9 @@ CommandSetT = TypeVar("CommandSetT", bound="CommandSet[Any]")
 # Tracks the specific subclass instance (either a Cmd or CommandSet)
 CmdOrSetT = TypeVar("CmdOrSetT", bound=CmdOrSet)
 
+# For protocols that accept a Cmd or CommandSet instance
+CmdOrSetT_contra = TypeVar("CmdOrSetT_contra", bound=CmdOrSet, contravariant=True)
+
 # Tracks the specific class itself (either a Cmd or CommandSet class)
 CmdOrSetClassT = TypeVar("CmdOrSetClassT", bound=CmdOrSetClass)
 
@@ -88,20 +91,20 @@ class BoundCommandFunc(Protocol[P]):
 
 # An unbound cmd2 command function (e.g. the class method do_command).
 # The 'self' argument can be either a Cmd or CommandSet instance.
-class UnboundCommandFunc(Protocol[CmdOrSetT, P]):
+class UnboundCommandFunc(Protocol[CmdOrSetT_contra, P]):
     """Protocol for an unbound command function."""
 
     __name__: str
     __qualname__: str
 
-    def __call__(self, __self: CmdOrSetT, /, *args: P.args, **kwargs: P.kwargs) -> bool | None:
+    def __call__(self, __self: CmdOrSetT_contra, /, *args: P.args, **kwargs: P.kwargs) -> bool | None:
         """Invoke the unbound command function with its command instance."""
 
     @overload
-    def __get__(self, instance: None, owner: Any = ...) -> "UnboundCommandFunc[CmdOrSetT, P]": ...
+    def __get__(self, instance: None, owner: Any = ...) -> "UnboundCommandFunc[CmdOrSetT_contra, P]": ...
 
     @overload
-    def __get__(self, instance: CmdOrSetT, owner: Any = ...) -> BoundCommandFunc[P]: ...
+    def __get__(self, instance: CmdOrSetT_contra, owner: Any = ...) -> BoundCommandFunc[P]: ...
 
 
 ##################################################################################################

{cmd2-4.2.3 → cmd2-4.2.4}/cmd2.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cmd2
-Version: 4.2.3
+Version: 4.2.4
 Summary: cmd2 - quickly build feature-rich and user-friendly interactive command line applications in Python
 Author: cmd2 Contributors
 License-Expression: MIT
@@ -251,6 +251,7 @@ reproduce the bug. At a minimum, please state the following:
 | [Falcon Toolkit](https://github.com/CrowdStrike/Falcon-Toolkit) | Unleash the power of the CrowdStrike Falcon Platform at the CLI                                                                  | [CrowdStrike](https://github.com/CrowdStrike)                         |
 | [EXPLIoT](https://gitlab.com/expliot_framework/expliot)         | Internet of Things Security Testing and Exploitation framework                                                                   | [expliot_framework](https://gitlab.com/expliot_framework/)            |
 | [Pobshell](https://github.com/pdalloz/pobshell)                 | A Bash‑like shell for live Python objects: `cd`, `ls`, `cat`, `find` and _CLI piping_ for object code, str values & more         | [Peter Dalloz](https://www.linkedin.com/in/pdalloz)                   |
+| [Wtsh](https://gitee.com/wazzge/wtsh)                           | WTSH is a shell built with Python cmd2(v4), which uses third-party plugins to construct a universal shell installed via Pip      | [wazzge](https://gitee.com/wazzge)                                    |
 
 Possibly defunct but still good examples
 

{cmd2-4.2.3 → cmd2-4.2.4}/cmd2.egg-info/SOURCES.txt

@@ -4,6 +4,7 @@
 .typos.toml
 AGENTS.md
 CHANGELOG.md
+CLAUDE.md
 GEMINI.md
 LICENSE
 MANIFEST.in
@@ -199,6 +200,7 @@ tests/test_py_completion.py
 tests/test_rich_utils.py
 tests/test_run_pyscript.py
 tests/test_string_utils.py
+tests/test_suite_environment.py
 tests/test_theme.py
 tests/test_utils.py
 tests/test_utils_defining_class.py

{cmd2-4.2.3 → cmd2-4.2.4}/cmd2.egg-info/scm_file_list.json

@@ -18,6 +18,7 @@
     ".typos.toml",
     "AGENTS.md",
     "CHANGELOG.md",
+    "CLAUDE.md",
     "GEMINI.md",
     "LICENSE",
     "MANIFEST.in",
@@ -222,6 +223,7 @@
     "tests/test_rich_utils.py",
     "tests/test_run_pyscript.py",
     "tests/test_string_utils.py",
+    "tests/test_suite_environment.py",
     "tests/test_theme.py",
     "tests/test_utils.py",
     "tests/test_utils_defining_class.py",

cmd2-4.2.4/cmd2.egg-info/scm_version.json

@@ -0,0 +1,8 @@
+{
+  "tag": "4.2.4",
+  "distance": 0,
+  "node": "g3aa75c80675c0b0edc510aec302029a3fe62bf74",
+  "dirty": false,
+  "branch": "main",
+  "node_date": "2026-09-08"
+}

{cmd2-4.2.3 → cmd2-4.2.4}/pyproject.toml

@@ -64,7 +64,7 @@ test = [
     "pytest-cov>=5",
     "pytest-mock>=3.14.1",
 ]
-validate = ["mypy>=2.3.1", "ruff>=0.16.0", "ty>=0.0.75", "types-setuptools>=80.8.0"]
+validate = ["ipython>=8.23", "mypy>=2.3.1", "ty>=0.0.75", "types-setuptools>=80.8.0"]
 
 [tool.mypy]
 disallow_incomplete_defs = true

{cmd2-4.2.3 → cmd2-4.2.4}/tests/conftest.py

@@ -80,6 +80,23 @@ def run_cmd(app: cmd2.Cmd, cmd: str) -> tuple[list[str], list[str]]:
     return normalize(out), normalize(err)
 
 
+#: Environment variables that change how Rich and cmd2 render output. Left inherited,
+#: they make unrelated tests fail depending on who runs the suite: NO_COLOR fails 15
+#: tests, FORCE_COLOR and TTY_COMPATIBLE 53 each.
+COLOR_ENVIRONMENT = ("NO_COLOR", "FORCE_COLOR", "TTY_COMPATIBLE", "TTY_INTERACTIVE")
+
+
+@pytest.fixture(autouse=True)
+def neutral_color_environment(monkeypatch: pytest.MonkeyPatch) -> None:
+    """Render output the same way regardless of the caller's environment.
+
+    Tests that exercise these variables set them explicitly, which still works because
+    a test's own monkeypatching runs after this fixture.
+    """
+    for name in COLOR_ENVIRONMENT:
+        monkeypatch.delenv(name, raising=False)
+
+
 @pytest.fixture
 def base_app() -> cmd2.Cmd:
     return cmd2.Cmd(include_py=True, include_ipy=True)

{cmd2-4.2.3 → cmd2-4.2.4}/tests/test_cmd2.py

@@ -13,6 +13,7 @@ from typing import (
 from unittest import mock
 
 import pytest
+from prompt_toolkit.application import create_app_session, get_app
 from prompt_toolkit.auto_suggest import AutoSuggestFromHistory
 from prompt_toolkit.completion import DummyCompleter
 from prompt_toolkit.input import DummyInput, create_pipe_input
@@ -4444,6 +4445,40 @@ def test_enable_rprompt() -> None:
     assert custom_app.main_session.rprompt is None
 
 
+def test_rprompt_is_not_drawn_into_the_committed_line() -> None:
+    """The right prompt belongs to the live prompt line, not to the scrollback.
+
+    prompt-toolkit renders the right prompt as a Float with no ``~is_done`` filter,
+    unlike its bottom toolbar container, so by default it is part of the final frame
+    that gets committed to the terminal. That left a copy of the right prompt beside
+    every accepted command line in the scrollback.
+    """
+    drawn_while_done = []
+
+    class RPromptApp(cmd2.Cmd):
+        def get_rprompt(self):
+            drawn_while_done.append(get_app().is_done)
+            return [("", "RPROMPT")]
+
+    output = DummyOutput()
+    # Bind the ambient app session to this input and output. Without it, prompt-toolkit
+    # builds a real one on demand for calls such as patch_stdout() in _read_raw_input(),
+    # which needs a Windows console that CI does not provide.
+    with create_pipe_input() as pipe_input, create_app_session(input=pipe_input, output=output):
+        app = RPromptApp(allow_cli_args=False, enable_rprompt=True)
+        app.main_session = PromptSession(
+            input=pipe_input,
+            output=output,
+            rprompt=app.get_rprompt,
+        )
+        cmd2.cmd2.Cmd._hide_rprompt_when_done(app.main_session)
+        pipe_input.send_text("hello\n")
+        assert app._read_raw_input("(Cmd) ", app.main_session) == "hello"
+
+    assert drawn_while_done, "the right prompt was never rendered at all"
+    assert True not in drawn_while_done, "the right prompt was drawn into the committed final frame"
+
+
 def test_get_bottom_toolbar(base_app: cmd2.Cmd) -> None:
     assert base_app.get_bottom_toolbar() is None
 

{cmd2-4.2.3 → cmd2-4.2.4}/tests/test_run_pyscript.py

@@ -246,7 +246,7 @@ def test_run_pyscript_print_redirection(base_app, request, tmp_path, capsys) ->
     out, err = capsys.readouterr()
 
     # Verify the output file contains what we expect from print()
-    content = pathlib.Path(out_file).read_text()
+    content = pathlib.Path(out_file).read_text(encoding="utf-8")
 
     # Look for everything written to self.stdout
     assert len(content.splitlines()) == 4

cmd2-4.2.4/tests/test_suite_environment.py

@@ -0,0 +1,59 @@
+"""Guards that the suite renders output independently of the developer's environment.
+
+Rich and cmd2 both consult environment variables when deciding whether to emit styling.
+Inheriting them makes large numbers of unrelated tests fail depending on who runs them,
+which is expensive to diagnose because the failures look like product regressions.
+"""
+
+import os
+import sys
+
+import pytest
+
+import cmd2
+
+#: Variables that change how output is rendered. Rich reads all of these; cmd2 reads
+#: NO_COLOR directly. Tests that exercise them set them explicitly instead.
+COLOR_ENVIRONMENT = ("NO_COLOR", "FORCE_COLOR", "TTY_COMPATIBLE", "TTY_INTERACTIVE")
+
+
+@pytest.mark.parametrize("name", COLOR_ENVIRONMENT)
+def test_color_environment_does_not_leak_into_tests(name: str) -> None:
+    """A developer exporting any of these must not change the suite's results."""
+    assert name not in os.environ, (
+        f"{name} leaked into the test environment; output-rendering assertions would depend on who is running the suite"
+    )
+
+
+class EncodingProbe(cmd2.Cmd):
+    """Reports the encoding of whatever stream output is currently going to."""
+
+    def do_show_encoding(self, _: str) -> None:
+        """Print the current output stream's encoding."""
+        self.poutput(f"ENCODING={getattr(self.stdout, 'encoding', None)}")
+
+
+def test_redirection_to_a_file_uses_utf8(tmp_path) -> None:
+    """cmd2 renders non-ASCII, so a redirect target must not use the locale encoding.
+
+    Opened with the locale encoding, redirecting styled output raises UnicodeEncodeError
+    on any non-UTF-8 system -- which includes a default Windows console -- leaving the
+    user an empty file and an error.
+    """
+    app = EncodingProbe(allow_cli_args=False)
+    target = tmp_path / "out.txt"
+    app.onecmd_plus_hooks(f'show_encoding > "{target}"')
+    assert "ENCODING=utf-8" in target.read_text(encoding="utf-8")
+
+
+#: A pass-through filter, run with this interpreter so the test does not depend on Unix
+#: utilities being installed. `cmd.exe` has no `cat`, and this fix exists for Windows.
+PASS_THROUGH = "import sys; sys.stdin.reconfigure(encoding='utf-8'); sys.stdout.write(sys.stdin.read())"
+
+
+def test_piping_uses_utf8(tmp_path) -> None:
+    """The same applies to the pipe the subprocess reads from."""
+    app = EncodingProbe(allow_cli_args=False)
+    target = tmp_path / "piped.txt"
+    app.onecmd_plus_hooks(f'show_encoding | "{sys.executable}" -c "{PASS_THROUGH}" > "{target}"')
+    assert "ENCODING=utf-8" in target.read_text(encoding="utf-8")

cmd2-4.2.3/cmd2.egg-info/scm_version.json

@@ -1,8 +0,0 @@
-{
-  "tag": "4.2.3",
-  "distance": 0,
-  "node": "g0e90fd16f425411f2a5850b8b0373aafb1d1122a",
-  "dirty": false,
-  "branch": "main",
-  "node_date": "2026-09-02"
-}