base-cli 0.2.0__tar.gz → 0.3.0__tar.gz

{base_cli-0.2.0/lib/python/base_cli.egg-info → base_cli-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: base-cli
-Version: 0.2.0
+Version: 0.3.0
 Summary: A small, consumer-neutral Python CLI framework
 Author: Base Foundry
 License: Apache-2.0
@@ -10,6 +10,9 @@ Project-URL: Issues, https://github.com/basefoundry/base-cli/issues
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX :: Linux
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3 :: Only
 Classifier: Programming Language :: Python :: 3.10
@@ -477,12 +480,22 @@ explicitly and return a clear usage error or actionable message.
 The generic profile uses the configured cache root and an application namespace
 to create per-run logs, caches, and temporary directories. Pass
 `cache_root` to `CliProfile.generic()` for deterministic placement in tests or
-applications; otherwise the platform cache directory is used. The generic
+applications; otherwise the platform cache directory is used. Linux and WSL2
+follow `XDG_CACHE_HOME` or `~/.cache`, macOS uses `~/Library/Caches`, and
+Windows uses `%LOCALAPPDATA%` (falling back to `~/AppData/Local`). Set
+`BASE_CLI_CACHE_DIR` to override the default on any platform. The generic
 profile does not prescribe a product-wide cache name or cleanup command.
 
-Each invocation is a run bundle containing private (`0600`) `run.json`,
-`logs/`, and `tmp/`, while persistent component caches live in the
-bundle's cache directory.
+Each invocation is a run bundle containing a private `run.json`, `logs/`, and
+`tmp/`, while persistent component caches live in the bundle's cache directory.
+On POSIX, base-cli enforces owner-only `0600`/`0700` modes. On Windows, the
+default user-local cache root relies on inherited user-profile ACLs; consumers
+using a custom cache root must provide the appropriate ACL themselves.
+
+See [Platform support](docs/platform-support.md) for the supported Linux,
+WSL2, macOS, and native Windows boundaries. Native Windows support covers the
+generic `base-cli` framework; it does not imply native Windows support for
+Base or `basectl`.
 
 Use `ctx.on_cleanup()` for cleanup work that should happen even when helper code
 does not own the main command wrapper:
@@ -523,8 +536,9 @@ def test_command(tmp_path: Path) -> None:
     assert "hello Ada" in result.stdout
 ```
 
-The helper wraps Click's `CliRunner`, sets `HOME` when requested, and supplies
-`cwd` to the invocation for the duration of the test. Calls that use
+The helper wraps Click's `CliRunner`, sets `HOME` plus the relevant
+`USERPROFILE`, `LOCALAPPDATA`, and `XDG_CACHE_HOME` values when requested, and
+supplies `cwd` to the invocation for the duration of the test. Calls that use
 `cwd` are serialized and the caller's cwd is restored afterward, but this
 remains process-global: do not use it concurrently with code that changes cwd
 outside `invoke()` or from threads spawned by the invoked command. A

{base_cli-0.2.0 → base_cli-0.3.0}/README.md

@@ -448,12 +448,22 @@ explicitly and return a clear usage error or actionable message.
 The generic profile uses the configured cache root and an application namespace
 to create per-run logs, caches, and temporary directories. Pass
 `cache_root` to `CliProfile.generic()` for deterministic placement in tests or
-applications; otherwise the platform cache directory is used. The generic
+applications; otherwise the platform cache directory is used. Linux and WSL2
+follow `XDG_CACHE_HOME` or `~/.cache`, macOS uses `~/Library/Caches`, and
+Windows uses `%LOCALAPPDATA%` (falling back to `~/AppData/Local`). Set
+`BASE_CLI_CACHE_DIR` to override the default on any platform. The generic
 profile does not prescribe a product-wide cache name or cleanup command.
 
-Each invocation is a run bundle containing private (`0600`) `run.json`,
-`logs/`, and `tmp/`, while persistent component caches live in the
-bundle's cache directory.
+Each invocation is a run bundle containing a private `run.json`, `logs/`, and
+`tmp/`, while persistent component caches live in the bundle's cache directory.
+On POSIX, base-cli enforces owner-only `0600`/`0700` modes. On Windows, the
+default user-local cache root relies on inherited user-profile ACLs; consumers
+using a custom cache root must provide the appropriate ACL themselves.
+
+See [Platform support](docs/platform-support.md) for the supported Linux,
+WSL2, macOS, and native Windows boundaries. Native Windows support covers the
+generic `base-cli` framework; it does not imply native Windows support for
+Base or `basectl`.
 
 Use `ctx.on_cleanup()` for cleanup work that should happen even when helper code
 does not own the main command wrapper:
@@ -494,8 +504,9 @@ def test_command(tmp_path: Path) -> None:
     assert "hello Ada" in result.stdout
 ```
 
-The helper wraps Click's `CliRunner`, sets `HOME` when requested, and supplies
-`cwd` to the invocation for the duration of the test. Calls that use
+The helper wraps Click's `CliRunner`, sets `HOME` plus the relevant
+`USERPROFILE`, `LOCALAPPDATA`, and `XDG_CACHE_HOME` values when requested, and
+supplies `cwd` to the invocation for the duration of the test. Calls that use
 `cwd` are serialized and the caller's cwd is restored afterward, but this
 remains process-global: do not use it concurrently with code that changes cwd
 outside `invoke()` or from threads spawned by the invoked command. A

base_cli-0.3.0/VERSION

@@ -0,0 +1 @@
+0.3.0

{base_cli-0.2.0 → base_cli-0.3.0}/lib/python/base_cli/_private_files.py

@@ -10,12 +10,25 @@ from typing import Any
 
 
 PRIVATE_FILE_MODE = 0o600
+PRIVATE_DIRECTORY_MODE = 0o700
 
 
 def restrict_file(path: Path) -> None:
-    """Ensure an existing runtime file is readable and writable only by its owner."""
+    """Apply owner-only POSIX permissions where mode bits are meaningful.
 
-    path.chmod(PRIVATE_FILE_MODE)
+    Windows inherits ACLs from the containing directory instead; the generic
+    package deliberately does not pretend that ``chmod`` can rewrite them.
+    """
+
+    if os.name != "nt":
+        path.chmod(PRIVATE_FILE_MODE)
+
+
+def restrict_directory(path: Path) -> None:
+    """Apply owner-only POSIX directory permissions when supported."""
+
+    if os.name != "nt":
+        path.chmod(PRIVATE_DIRECTORY_MODE)
 
 
 def write_private_json(path: Path, value: Mapping[str, Any]) -> None:
@@ -25,7 +38,7 @@ def write_private_json(path: Path, value: Mapping[str, Any]) -> None:
     fd = os.open(path, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, PRIVATE_FILE_MODE)
     try:
         fchmod = getattr(os, "fchmod", None)
-        if fchmod is not None:
+        if os.name != "nt" and fchmod is not None:
             fchmod(fd, PRIVATE_FILE_MODE)
         stream = os.fdopen(fd, "w", encoding="utf-8")
         fd = -1

{base_cli-0.2.0 → base_cli-0.3.0}/lib/python/base_cli/_runtime.py

@@ -2,10 +2,11 @@ from __future__ import annotations
 
 import json
 import logging
+import os
 from dataclasses import dataclass
 from pathlib import Path
 
-from ._private_files import write_private_json
+from ._private_files import restrict_directory, write_private_json
 from .paths import runtime_run_directory_name, runtime_slug
 
 
@@ -57,9 +58,9 @@ def create_runtime_directory(path: Path, cache_root: Path) -> None:
     restrict_permissions = _is_within(path, cache_root)
     try:
         path.mkdir(parents=True, exist_ok=True)
-        if restrict_permissions:
+        if restrict_permissions and os.name != "nt":
             for directory in [path, *missing]:
-                directory.chmod(0o700)
+                restrict_directory(directory)
     except OSError as exc:
         raise RuntimeError(_runtime_directory_error(path, cache_root, exc)) from exc
 

{base_cli-0.2.0 → base_cli-0.3.0}/lib/python/base_cli/history.py

@@ -84,7 +84,7 @@ def build_finished_record(
         "project_root": compact_optional_path(context.project_root),
         "manifest": compact_optional_path(context.manifest_path),
         "workspace_root": compact_optional_path(context.workspace_root),
-        "shell": os.environ.get("SHELL"),
+        "shell": current_shell(),
         "scope": context.history_scope,
         "parent_run_id": context.history_parent_run_id,
     }
@@ -188,13 +188,14 @@ def update_run_metadata(run_root: Path, record: dict[str, Any]) -> None:
 
 
 def append_history_line(path: Path, line: str) -> None:
-    fd = os.open(path, os.O_WRONLY | os.O_CREAT | os.O_APPEND, 0o600)
+    binary_flag = getattr(os, "O_BINARY", 0)
+    fd = os.open(path, os.O_WRONLY | os.O_CREAT | os.O_APPEND | binary_flag, 0o600)
     lock_fd = fd
     sidecar_fd: int | None = None
     try:
         if _fcntl is None and _msvcrt is not None:
             sidecar_path = path.with_name(f".{path.name}.lock")
-            sidecar_fd = os.open(sidecar_path, os.O_RDWR | os.O_CREAT, 0o600)
+            sidecar_fd = os.open(sidecar_path, os.O_RDWR | os.O_CREAT | binary_flag, 0o600)
             if os.fstat(sidecar_fd).st_size == 0:
                 os.write(sidecar_fd, b"0")
             restrict_file(sidecar_path)
@@ -285,6 +286,12 @@ def normalized_os() -> str:
     return system or platform.platform()
 
 
+def current_shell() -> str | None:
+    """Return the active shell identifier across POSIX and Windows."""
+
+    return os.environ.get("SHELL") or os.environ.get("COMSPEC")
+
+
 def redact_history_argv(argv: list[str], sensitive_options: set[str]) -> list[str]:
     redacted = redact_argv(argv, sensitive_options)
     result: list[str] = []
@@ -315,20 +322,24 @@ def redact_history_text(value: str) -> str:
     return compact_home_text(redact_text_value(value))
 
 
-def compact_optional_path(path: Path | None) -> str | None:
+def compact_optional_path(path: Path | None, *, home: Path | str | None = None) -> str | None:
     if path is None:
         return None
-    return compact_path(path)
+    return compact_path(path, home=home)
 
 
-def compact_path(path: Path) -> str:
-    return compact_home_text(str(path.expanduser().resolve(strict=False)))
+def compact_path(path: Path, *, home: Path | str | None = None) -> str:
+    return compact_home_text(str(path.expanduser().resolve(strict=False)), home=home)
 
 
-def compact_home_text(value: str) -> str:
-    home = str(Path.home().expanduser().resolve(strict=False))
-    if value == home:
+def compact_home_text(value: str, *, home: Path | str | None = None) -> str:
+    home_text = str(home) if home is not None else str(Path.home().expanduser().resolve(strict=False))
+    normalized_value = value.replace("\\", "/")
+    normalized_home = home_text.replace("\\", "/").rstrip("/")
+    comparison_value = normalized_value.lower() if os.name == "nt" else normalized_value
+    comparison_home = normalized_home.lower() if os.name == "nt" else normalized_home
+    if comparison_value == comparison_home:
         return "~"
-    if value.startswith(f"{home}/"):
-        return f"~/{value[len(home) + 1:]}"
+    if comparison_value.startswith(f"{comparison_home}/"):
+        return f"~/{normalized_value[len(normalized_home) + 1:]}"
     return value

{base_cli-0.2.0 → base_cli-0.3.0}/lib/python/base_cli/logging.py

@@ -8,6 +8,7 @@ import time
 from pathlib import Path
 from typing import TextIO
 
+from ._private_files import restrict_file
 from .context import get_current_context
 from .paths import current_working_dir
 from .redaction import redact_argv
@@ -68,16 +69,16 @@ def _handler_formatter(formatter: logging.Formatter | None, *, use_color: bool)
 
 
 def _use_color(stream: TextIO) -> bool:
-    return (
-        os.environ.get("BASE_CLI_COLOR") != "0"
-        and "NO_COLOR" not in os.environ
-        and hasattr(stream, "isatty")
-        and stream.isatty()
-    )
+    if os.environ.get("BASE_CLI_COLOR") == "0" or "NO_COLOR" in os.environ:
+        return False
+    try:
+        return bool(stream.isatty())
+    except (AttributeError, OSError, ValueError):
+        return False
 
 
 def secure_log_file_permissions(log_file: Path) -> None:
-    log_file.chmod(0o600)
+    restrict_file(log_file)
 
 
 class SecureLogFileHandler(logging.FileHandler):
@@ -85,7 +86,7 @@ class SecureLogFileHandler(logging.FileHandler):
         fd = os.open(self.baseFilename, _secure_log_file_open_flags(self.mode), 0o600)
         try:
             fchmod = getattr(os, "fchmod", None)
-            if fchmod is not None:
+            if os.name != "nt" and fchmod is not None:
                 fchmod(fd, 0o600)
             return open(fd, self.mode, encoding=self.encoding, errors=self.errors, closefd=True)
         except BaseException:

{base_cli-0.2.0 → base_cli-0.3.0}/lib/python/base_cli/output.py

@@ -30,7 +30,7 @@ def is_terminal(stream: TextIO | None = None) -> bool:
     candidate = stream if stream is not None else sys.stdout
     try:
         return bool(candidate.isatty())
-    except (AttributeError, OSError):
+    except (AttributeError, OSError, ValueError):
         return False
 
 

{base_cli-0.2.0 → base_cli-0.3.0}/lib/python/base_cli/paths.py

@@ -2,10 +2,12 @@ from __future__ import annotations
 
 import contextlib
 import contextvars
+import os
 import re
+import sys
 import time
 import uuid
-from collections.abc import Iterator
+from collections.abc import Iterator, Mapping
 from pathlib import Path
 
 _WORKING_DIRECTORY_OVERRIDE: contextvars.ContextVar[Path | None] = contextvars.ContextVar(
@@ -14,6 +16,38 @@ _WORKING_DIRECTORY_OVERRIDE: contextvars.ContextVar[Path | None] = contextvars.C
 )
 
 
+def default_cache_root(
+    *,
+    environ: Mapping[str, str] | None = None,
+    home: Path | None = None,
+    platform_name: str | None = None,
+) -> Path:
+    """Return the platform-default cache root for the generic profile.
+
+    ``BASE_CLI_CACHE_DIR`` always wins so consumers and tests can provide an
+    explicit location. Linux follows ``XDG_CACHE_HOME`` when it is set,
+    macOS uses ``Library/Caches``, and Windows uses ``LOCALAPPDATA``.
+    """
+
+    environment = os.environ if environ is None else environ
+    configured = environment.get("BASE_CLI_CACHE_DIR")
+    if configured:
+        return Path(configured).expanduser()
+
+    root = home.expanduser() if home is not None else Path.home()
+    system = platform_name or sys.platform
+    if system == "darwin":
+        return root / "Library" / "Caches"
+    if system.startswith("win"):
+        local_app_data = environment.get("LOCALAPPDATA")
+        return Path(local_app_data).expanduser() if local_app_data else root / "AppData" / "Local"
+
+    xdg_cache_home = environment.get("XDG_CACHE_HOME")
+    if xdg_cache_home:
+        return Path(xdg_cache_home).expanduser()
+    return root / ".cache"
+
+
 def current_working_dir() -> Path:
     return _WORKING_DIRECTORY_OVERRIDE.get() or Path.cwd()
 

{base_cli-0.2.0 → base_cli-0.3.0}/lib/python/base_cli/profile.py

@@ -1,7 +1,5 @@
 from __future__ import annotations
 
-import os
-import sys
 from collections.abc import Callable
 from dataclasses import dataclass
 from datetime import datetime
@@ -10,7 +8,7 @@ from typing import Any
 
 from ._runtime import RuntimeLayout, runtime_layout
 from .config import load_yaml_file
-from .paths import make_run_id
+from .paths import default_cache_root, make_run_id
 
 
 @dataclass(frozen=True)
@@ -124,7 +122,7 @@ def _generic_runtime_resolver(
     application_home: Path | None,
 ) -> RuntimeResolver:
     def resolve_runtime(cli_name: str, project: ProjectInfo | None) -> RuntimeBinding:
-        root = cache_root.expanduser().resolve() if cache_root is not None else _default_cache_root()
+        root = (cache_root if cache_root is not None else default_cache_root()).expanduser().resolve()
         run_id = make_run_id()
         project_root = project.root if project is not None else None
         project_name = project.name if project is not None else None
@@ -147,13 +145,3 @@ def _generic_runtime_resolver(
         )
 
     return resolve_runtime
-
-
-def _default_cache_root() -> Path:
-    configured = os.environ.get("BASE_CLI_CACHE_DIR")
-    if configured:
-        return Path(configured).expanduser().resolve()
-    root = Path.home()
-    if sys.platform == "darwin":
-        return root / "Library" / "Caches"
-    return root / ".cache"

{base_cli-0.2.0 → base_cli-0.3.0}/lib/python/base_cli/testing.py

@@ -33,6 +33,9 @@ def invoke(
     invoke_env = dict(env or {})
     if home is not None:
         invoke_env.setdefault("HOME", str(home))
+        invoke_env.setdefault("USERPROFILE", str(home))
+        invoke_env.setdefault("LOCALAPPDATA", str(home / "AppData" / "Local"))
+        invoke_env.setdefault("XDG_CACHE_HOME", str(home / ".cache"))
         invoke_env.setdefault("BASE_CLI_CACHE_DIR", str(home / ".cache"))
     runner_kwargs = {}
     if "mix_stderr" in inspect.signature(CliRunner).parameters:

{base_cli-0.2.0 → base_cli-0.3.0/lib/python/base_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: base-cli
-Version: 0.2.0
+Version: 0.3.0
 Summary: A small, consumer-neutral Python CLI framework
 Author: Base Foundry
 License: Apache-2.0
@@ -10,6 +10,9 @@ Project-URL: Issues, https://github.com/basefoundry/base-cli/issues
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX :: Linux
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3 :: Only
 Classifier: Programming Language :: Python :: 3.10
@@ -477,12 +480,22 @@ explicitly and return a clear usage error or actionable message.
 The generic profile uses the configured cache root and an application namespace
 to create per-run logs, caches, and temporary directories. Pass
 `cache_root` to `CliProfile.generic()` for deterministic placement in tests or
-applications; otherwise the platform cache directory is used. The generic
+applications; otherwise the platform cache directory is used. Linux and WSL2
+follow `XDG_CACHE_HOME` or `~/.cache`, macOS uses `~/Library/Caches`, and
+Windows uses `%LOCALAPPDATA%` (falling back to `~/AppData/Local`). Set
+`BASE_CLI_CACHE_DIR` to override the default on any platform. The generic
 profile does not prescribe a product-wide cache name or cleanup command.
 
-Each invocation is a run bundle containing private (`0600`) `run.json`,
-`logs/`, and `tmp/`, while persistent component caches live in the
-bundle's cache directory.
+Each invocation is a run bundle containing a private `run.json`, `logs/`, and
+`tmp/`, while persistent component caches live in the bundle's cache directory.
+On POSIX, base-cli enforces owner-only `0600`/`0700` modes. On Windows, the
+default user-local cache root relies on inherited user-profile ACLs; consumers
+using a custom cache root must provide the appropriate ACL themselves.
+
+See [Platform support](docs/platform-support.md) for the supported Linux,
+WSL2, macOS, and native Windows boundaries. Native Windows support covers the
+generic `base-cli` framework; it does not imply native Windows support for
+Base or `basectl`.
 
 Use `ctx.on_cleanup()` for cleanup work that should happen even when helper code
 does not own the main command wrapper:
@@ -523,8 +536,9 @@ def test_command(tmp_path: Path) -> None:
     assert "hello Ada" in result.stdout
 ```
 
-The helper wraps Click's `CliRunner`, sets `HOME` when requested, and supplies
-`cwd` to the invocation for the duration of the test. Calls that use
+The helper wraps Click's `CliRunner`, sets `HOME` plus the relevant
+`USERPROFILE`, `LOCALAPPDATA`, and `XDG_CACHE_HOME` values when requested, and
+supplies `cwd` to the invocation for the duration of the test. Calls that use
 `cwd` are serialized and the caller's cwd is restored afterward, but this
 remains process-global: do not use it concurrently with code that changes cwd
 outside `invoke()` or from threads spawned by the invoked command. A

{base_cli-0.2.0 → base_cli-0.3.0}/lib/python/base_cli.egg-info/SOURCES.txt

@@ -37,9 +37,11 @@ tests/test_command_filters.py
 tests/test_command_protocol.py
 tests/test_context_workspace.py
 tests/test_generic_core.py
+tests/test_history.py
 tests/test_inspection.py
 tests/test_logging.py
 tests/test_output.py
+tests/test_paths.py
 tests/test_profile.py
 tests/test_public_api.py
 tests/test_testing.py

{base_cli-0.2.0 → base_cli-0.3.0}/pyproject.toml

@@ -18,6 +18,9 @@ classifiers = [
   "Development Status :: 3 - Alpha",
   "Intended Audience :: Developers",
   "License :: OSI Approved :: Apache Software License",
+  "Operating System :: MacOS",
+  "Operating System :: Microsoft :: Windows",
+  "Operating System :: POSIX :: Linux",
   "Programming Language :: Python :: 3",
   "Programming Language :: Python :: 3 :: Only",
   "Programming Language :: Python :: 3.10",

{base_cli-0.2.0 → base_cli-0.3.0}/tests/test_app_runtime_errors.py

@@ -42,7 +42,7 @@ class AppRuntimeErrorTests(unittest.TestCase):
                 invoke(app, [])
 
     @unittest.skipUnless(importlib.util.find_spec("click"), "Click is not installed")
-    def test_run_app_reports_unwritable_cache_root_without_traceback(self) -> None:
+    def test_run_app_reports_unusable_cache_root_without_traceback(self) -> None:
         app = generic_app(name="cache-failure", version="0.1.0")
 
         @app.command()
@@ -55,18 +55,17 @@ class AppRuntimeErrorTests(unittest.TestCase):
             home = root / "home"
             cache_root = root / "cache-root"
             home.mkdir()
-            cache_root.mkdir()
-            cache_root.chmod(0o500)
+            # A regular file is unusable as a cache root on every platform and
+            # also behaves consistently when the test suite runs as root in a
+            # Linux distribution container (where mode bits are bypassed).
+            cache_root.write_text("not a directory", encoding="utf-8")
             stderr = io.StringIO()
-            try:
-                with mock.patch.dict(os.environ, {"HOME": str(home), "BASE_CLI_CACHE_DIR": str(cache_root)}):
-                    with redirect_stderr(stderr):
-                        try:
-                            exit_code = base_cli.run_app(app, [])
-                        except PermissionError as exc:
-                            self.fail(f"run_app should handle context creation permission errors: {exc}")
-            finally:
-                cache_root.chmod(0o700)
+            with mock.patch.dict(os.environ, {"HOME": str(home), "BASE_CLI_CACHE_DIR": str(cache_root)}):
+                with redirect_stderr(stderr):
+                    try:
+                        exit_code = base_cli.run_app(app, [])
+                    except PermissionError as exc:
+                        self.fail(f"run_app should handle context creation permission errors: {exc}")
 
         error = stderr.getvalue()
         self.assertEqual(exit_code, 1)

base_cli-0.3.0/tests/test_history.py

@@ -0,0 +1,61 @@
+from __future__ import annotations
+
+import json
+import tempfile
+import unittest
+from concurrent.futures import ThreadPoolExecutor
+from pathlib import Path
+from unittest import mock
+
+from base_cli import history
+
+
+class _FakeMsvcrt:
+    LK_LOCK = 1
+    LK_UNLCK = 2
+
+    def __init__(self) -> None:
+        self.calls: list[tuple[int, int]] = []
+
+    def locking(self, _fd: int, mode: int, size: int) -> None:
+        self.calls.append((mode, size))
+
+
+class HistoryAppendTests(unittest.TestCase):
+    def test_current_shell_falls_back_to_comspec(self) -> None:
+        with mock.patch.dict("os.environ", {"COMSPEC": r"C:\Windows\System32\cmd.exe"}, clear=True):
+            self.assertEqual(history.current_shell(), r"C:\Windows\System32\cmd.exe")
+
+    def test_current_shell_prefers_shell(self) -> None:
+        with mock.patch.dict(
+            "os.environ",
+            {"SHELL": "/bin/zsh", "COMSPEC": r"C:\Windows\System32\cmd.exe"},
+            clear=True,
+        ):
+            self.assertEqual(history.current_shell(), "/bin/zsh")
+
+    def test_concurrent_appends_produce_complete_records(self) -> None:
+        with tempfile.TemporaryDirectory() as tmpdir:
+            path = Path(tmpdir) / "history.jsonl"
+            lines = [json.dumps({"run": index}) + "\n" for index in range(24)]
+
+            with ThreadPoolExecutor(max_workers=8) as executor:
+                list(executor.map(lambda line: history.append_history_line(path, line), lines))
+
+            records = [json.loads(line) for line in path.read_text(encoding="utf-8").splitlines()]
+
+        self.assertEqual(sorted(record["run"] for record in records), list(range(24)))
+
+    def test_msvcrt_backend_uses_a_private_sidecar_lock(self) -> None:
+        fake_msvcrt = _FakeMsvcrt()
+        with tempfile.TemporaryDirectory() as tmpdir:
+            path = Path(tmpdir) / "history.jsonl"
+            with mock.patch.object(history, "_fcntl", None), mock.patch.object(
+                history, "_msvcrt", fake_msvcrt
+            ):
+                history.append_history_line(path, '{"run": 1}\n')
+
+            self.assertEqual(path.read_text(encoding="utf-8"), '{"run": 1}\n')
+            self.assertTrue(path.with_name(".history.jsonl.lock").is_file())
+
+        self.assertEqual(fake_msvcrt.calls, [(_FakeMsvcrt.LK_LOCK, 1), (_FakeMsvcrt.LK_UNLCK, 1)])

{base_cli-0.2.0 → base_cli-0.3.0}/tests/test_logging.py

@@ -105,6 +105,20 @@ class ConfigureLoggerTests(unittest.TestCase):
 
         self.assertNotIn("\033[", stream.getvalue())
 
+    def test_configure_logger_handles_streams_that_reject_isatty(self) -> None:
+        class ClosedStream(io.StringIO):
+            def isatty(self) -> bool:
+                raise ValueError("stream is closed")
+
+        stream = ClosedStream()
+
+        with mock.patch.dict(os.environ, {}, clear=True):
+            logger = base_cli.configure_logger("closed-stream", None, debug=False, stream=stream)
+            logger.info("hello closed stream")
+
+        self.assertNotIn("\033[", stream.getvalue())
+        self.assertIn("hello closed stream", stream.getvalue())
+
     def test_configure_logger_uses_custom_formatter_for_file_handler(self) -> None:
         formatter = logging.Formatter("%(levelname)s:%(message)s")
         user_stream = io.StringIO()

{base_cli-0.2.0 → base_cli-0.3.0}/tests/test_output.py

@@ -18,6 +18,11 @@ class _Stream(io.StringIO):
         return self.terminal
 
 
+class _ClosedStream(io.StringIO):
+    def isatty(self) -> bool:
+        raise ValueError("stream is closed")
+
+
 RECORDS = (
     {"name": "base", "path": "/work/base"},
     {"name": "demo,one", "path": "/work/demo\tone"},
@@ -26,6 +31,9 @@ COLUMNS = (("PROJECT", "name"), ("PATH", "path"))
 
 
 class OutputTest(unittest.TestCase):
+    def test_closed_stream_is_not_treated_as_terminal(self) -> None:
+        self.assertEqual(resolve_output_format("text", stream=_ClosedStream()), "tsv")
+
     def test_text_is_pretty_on_terminal(self) -> None:
         stream = _Stream(terminal=True)
 

base_cli-0.3.0/tests/test_paths.py

@@ -0,0 +1,86 @@
+from __future__ import annotations
+
+import unittest
+from pathlib import Path
+
+from base_cli.history import compact_home_text
+from base_cli.paths import default_cache_root
+
+
+class DefaultCacheRootTests(unittest.TestCase):
+    def test_explicit_cache_override_wins_on_every_platform(self) -> None:
+        root = default_cache_root(
+            environ={
+                "BASE_CLI_CACHE_DIR": "/custom/cache",
+                "LOCALAPPDATA": "/local/app-data",
+                "XDG_CACHE_HOME": "/xdg/cache",
+            },
+            home=Path("/home/alice"),
+            platform_name="win32",
+        )
+
+        self.assertEqual(root, Path("/custom/cache"))
+
+    def test_linux_prefers_xdg_cache_home(self) -> None:
+        root = default_cache_root(
+            environ={"XDG_CACHE_HOME": "/xdg/cache"},
+            home=Path("/home/alice"),
+            platform_name="linux",
+        )
+
+        self.assertEqual(root, Path("/xdg/cache"))
+
+    def test_linux_falls_back_to_home_cache(self) -> None:
+        root = default_cache_root(
+            environ={},
+            home=Path("/home/alice"),
+            platform_name="linux",
+        )
+
+        self.assertEqual(root, Path("/home/alice/.cache"))
+
+    def test_macos_uses_library_caches(self) -> None:
+        root = default_cache_root(
+            environ={"XDG_CACHE_HOME": "/xdg/cache"},
+            home=Path("/Users/alice"),
+            platform_name="darwin",
+        )
+
+        self.assertEqual(root, Path("/Users/alice/Library/Caches"))
+
+    def test_windows_prefers_local_app_data(self) -> None:
+        root = default_cache_root(
+            environ={"LOCALAPPDATA": r"C:\Users\alice\AppData\Local"},
+            home=Path(r"C:\Users\alice"),
+            platform_name="win32",
+        )
+
+        self.assertEqual(root, Path(r"C:\Users\alice\AppData\Local"))
+
+    def test_windows_falls_back_to_home_local_app_data(self) -> None:
+        root = default_cache_root(
+            environ={},
+            home=Path(r"C:\Users\alice"),
+            platform_name="win32",
+        )
+
+        self.assertEqual(root, Path(r"C:\Users\alice") / "AppData" / "Local")
+
+
+class HomePathCompactionTests(unittest.TestCase):
+    def test_compacts_home_paths_with_posix_separators(self) -> None:
+        self.assertEqual(
+            compact_home_text("/home/alice/project", home=Path("/home/alice")),
+            "~/project",
+        )
+
+    def test_compacts_home_paths_with_windows_separators(self) -> None:
+        self.assertEqual(
+            compact_home_text(r"C:\Users\Alice\project", home=r"C:\Users\Alice"),
+            "~/project",
+        )
+
+    def test_leaves_paths_outside_home_unchanged(self) -> None:
+        value = r"C:\Users\Bob\project"
+
+        self.assertEqual(compact_home_text(value, home=r"C:\Users\Alice"), value)

base_cli-0.2.0/VERSION

@@ -1 +0,0 @@
-0.2.0