bakefile 0.0.5__py3-none-any.whl → 0.0.7__py3-none-any.whl

bake/__init__.py

@@ -2,8 +2,8 @@ from bake.bakebook.bakebook import Bakebook
 from bake.bakebook.decorator import command
 from bake.cli.common.context import BakeCommand, Context
 from bake.cli.utils.version import _get_version
-from bake.ui import console
+from bake.ui import console, params
 
 __version__ = _get_version()
 
-__all__ = ["BakeCommand", "Bakebook", "Context", "__version__", "command", "console"]
+__all__ = ["BakeCommand", "Bakebook", "Context", "__version__", "command", "console", "params"]

bake/cli/bakefile/export.py

@@ -0,0 +1,212 @@
+import shlex
+from collections.abc import Callable, Hashable
+from pathlib import Path
+from typing import Annotated, Any, Literal
+
+import orjson
+import typer
+import yaml
+from pydantic_settings import BaseSettings
+
+from bake.cli.common.context import Context
+from bake.ui import console
+
+ExportFormat = Literal["sh", "dotenv", "json", "yaml"]
+JsonValue = str | float | bool | None | list[Any] | dict[Hashable, Any]
+
+
+def _format_shell_value(value: JsonValue) -> str:
+    """Format a value for shell export.
+
+    Expects JSON-serializable types (str, int, float, bool, None, list, dict).
+    Raises TypeError for unexpected types.
+
+    SecretStr values are masked for security.
+
+    Parameters
+    ----------
+    value : Any
+        The value to format for shell export
+
+    Returns
+    -------
+    str
+        Shell-formatted string ready for export
+
+    Raises
+    ------
+    TypeError
+        If value is not one of the expected types
+    """
+
+    if isinstance(value, (list, dict)):
+        # Complex types: JSON string, then shell-quote it
+        return shlex.quote(orjson.dumps(value).decode())
+    elif isinstance(value, str):
+        # Strings: shell-quote directly
+        return shlex.quote(value)
+    elif value is None:
+        # None becomes empty string
+        return ""
+    elif isinstance(value, bool):
+        # Booleans: lowercase true/false for shell compatibility
+        return str(value).lower()
+    elif isinstance(value, (int, float)):
+        # Numbers: convert to string, no quoting needed
+        return str(value)
+    raise TypeError(
+        f"Unexpected type for shell export: {type(value).__name__}. "
+        f"Expected one of: str, int, float, bool, None, list, dict"
+    )
+
+
+def _format_dotenv_value(value: JsonValue) -> str:
+    """Format a value for dotenv export.
+
+    Uses smart quote selection to produce valid dotenv format that
+    python-dotenv's parser can handle.
+
+    Parameters
+    ----------
+    value : JsonValue
+        The value to format for dotenv export
+
+    Returns
+    -------
+    str
+        Dotenv-formatted string ready for export
+
+    Raises
+    ------
+    TypeError
+        If value is not one of the expected types
+    """
+    if isinstance(value, (list, dict)):
+        # Complex types: JSON string, then wrap in double quotes
+        json_str = orjson.dumps(value).decode()
+        return '"' + json_str.replace("\\", "\\\\").replace('"', '\\"') + '"'
+    elif isinstance(value, str):
+        # Strings: use smart quote selection
+        if value.isalnum():
+            return value
+        if "'" in value and '"' not in value:
+            # Has single quotes only: use double quotes
+            return f'"{value}"'
+        if '"' in value and "'" not in value:
+            # Has double quotes only: use single quotes
+            return f"'{value}'"
+        # Has both or special chars: use double quotes with escaping
+        return '"' + value.replace("\\", "\\\\").replace('"', '\\"') + '"'
+    elif value is None:
+        return ""
+    elif isinstance(value, bool):
+        return str(value).lower()
+    elif isinstance(value, (int, float)):
+        return str(value)
+    raise TypeError(
+        f"Unexpected type for dotenv export: {type(value).__name__}. "
+        f"Expected one of: str, int, float, bool, None, list, dict"
+    )
+
+
+def _format_vars(data: dict, value_formatter: Callable[[JsonValue], str], prefix: str = "") -> str:
+    lines: list[str] = []
+    for field_name, value in data.items():
+        formatted_val = value_formatter(value)
+        lines.append(f"{prefix}{field_name.upper()}={formatted_val}")
+    return "\n".join(lines)
+
+
+class ExportFormatter:
+    def __call__(self, data: dict[str, Any]) -> str:
+        raise NotImplementedError("....")
+
+
+class ShExportFormatter(ExportFormatter):
+    def __call__(self, data: dict[str, Any]) -> str:
+        return _format_vars(data, value_formatter=_format_shell_value, prefix="export ")
+
+
+class DotEnvExportFormatter(ExportFormatter):
+    def __call__(self, data: dict[str, Any]) -> str:
+        return _format_vars(data, value_formatter=_format_dotenv_value, prefix="")
+
+
+class JsonExportFormatter(ExportFormatter):
+    def __call__(self, data: dict[str, Any]) -> str:
+        return orjson.dumps(data, option=orjson.OPT_INDENT_2).decode()
+
+
+class YamlExportFormatter(ExportFormatter):
+    def __call__(self, data: dict[str, Any]) -> str:
+        return yaml.dump(data, default_flow_style=False, sort_keys=False)
+
+
+def _export(
+    bakebook: BaseSettings,
+    format: ExportFormat = "sh",
+    output: Path | None = None,
+) -> None:
+    formatters: dict[str, ExportFormatter] = {
+        "sh": ShExportFormatter(),
+        "dotenv": DotEnvExportFormatter(),
+        "json": JsonExportFormatter(),
+        "yaml": YamlExportFormatter(),
+    }
+
+    formatter = formatters.get(format)
+    if formatter is None:
+        raise ValueError(f"Unknown format: {format}")
+
+    data: dict[str, Any] = bakebook.model_dump(mode="json")
+    content = formatter(data)
+
+    if output:
+        output.parent.mkdir(parents=True, exist_ok=True)
+        output.write_text(content, encoding="utf-8")
+    elif content != "":
+        console.echo(content, overflow="ignore", crop=False)
+
+
+def export(
+    ctx: Context,
+    format: Annotated[
+        ExportFormat,
+        typer.Option(
+            "--format",
+            "-f",
+            help="Output format",
+        ),
+    ] = "sh",
+    output: Annotated[
+        Path | None,
+        typer.Option(
+            "--output",
+            "-o",
+            help="Output file path (default: stdout)",
+            exists=False,
+        ),
+    ] = None,
+) -> None:
+    """Export bakebook args to external formats.
+
+    Export Pydantic-validated bakebook args to various formats for use
+    outside Python runtime (shell scripts, GitHub Actions, .env files, etc.).
+
+    Examples:
+        # Export to shell for eval
+        bakefile export --format sh
+
+        # Export to dotenv file
+        bakefile export --format dotenv --output .env
+
+        # Export to JSON
+        bakefile export --format json --output config.json
+    """
+    if ctx.obj.bakebook is None:
+        ctx.obj.get_bakebook(allow_missing=False)
+
+    if ctx.obj.bakebook is None:
+        raise RuntimeError("Bakebook not found.")
+
+    _export(bakebook=ctx.obj.bakebook, format=format, output=output)

bake/cli/bakefile/main.py

@@ -8,6 +8,7 @@ from bake.cli.common.obj import get_bakefile_object
 
 from . import uv
 from .add_inline import add_inline
+from .export import export
 from .find_python import find_python
 from .init import init
 from .lint import lint
@@ -33,6 +34,7 @@ def main():
     bakefile_app.command()(add_inline)
     bakefile_app.command()(find_python)
     bakefile_app.command()(lint)
+    bakefile_app.command()(export)
     bakefile_app.command(context_settings=uv_commands_context_settings)(uv.sync)
     bakefile_app.command(context_settings=uv_commands_context_settings)(uv.lock)
     bakefile_app.command(context_settings=uv_commands_context_settings)(uv.add)

bake/cli/common/app.py

@@ -24,7 +24,7 @@ from bake.utils.constants import (
 from .obj import BakefileObject
 
 rich_markup_mode: MarkupMode = "rich" if not console.out.no_color else None
-add_completion = False
+add_completion = True
 
 
 class BakefileApp(typer.Typer):

bake/cli/common/context.py

@@ -1,4 +1,6 @@
 import subprocess
+from collections.abc import Generator
+from contextlib import contextmanager
 from pathlib import Path
 from typing import TYPE_CHECKING, Literal, overload
 
@@ -6,6 +8,7 @@ import click
 import typer
 from typer.core import TyperCommand
 
+from bake.ui.run import CmdType
 from bake.ui.run import run as _run
 from bake.ui.run.script import run_script as _run_script
 
@@ -22,6 +25,19 @@ class Context(typer.Context):
     def dry_run(self) -> bool:
         return self.obj.dry_run
 
+    @dry_run.setter
+    def dry_run(self, value: bool) -> None:
+        self.obj.dry_run = value
+
+    @contextmanager
+    def override_dry_run(self, dry_run: bool) -> Generator[None, None, None]:
+        original = self.obj.dry_run
+        self.obj.dry_run = dry_run
+        try:
+            yield
+        finally:
+            self.obj.dry_run = original
+
     @property
     def verbosity(self) -> int:
         return self.obj.verbosity
@@ -33,37 +49,7 @@ class Context(typer.Context):
     @overload
     def run(
         self,
-        cmd: str,
-        *,
-        capture_output: Literal[True] = True,
-        check: bool = True,
-        cwd: Path | str | None = None,
-        stream: bool = True,
-        shell: bool | None = None,
-        echo: bool = True,
-        dry_run: bool | None = None,
-        **kwargs,
-    ) -> subprocess.CompletedProcess[str]: ...
-
-    @overload
-    def run(
-        self,
-        cmd: str,
-        *,
-        capture_output: Literal[False],
-        check: bool = True,
-        cwd: Path | str | None = None,
-        stream: bool = True,
-        shell: bool | None = None,
-        echo: bool = True,
-        dry_run: bool | None = None,
-        **kwargs,
-    ) -> subprocess.CompletedProcess[None]: ...
-
-    @overload
-    def run(
-        self,
-        cmd: list[str] | tuple[str, ...],
+        cmd: CmdType,
         *,
         capture_output: Literal[True] = True,
         check: bool = True,
@@ -72,13 +58,15 @@ class Context(typer.Context):
         shell: bool | None = None,
         echo: bool = True,
         dry_run: bool | None = None,
+        keep_temp_file: bool = False,
+        env: dict[str, str] | None = None,
         **kwargs,
     ) -> subprocess.CompletedProcess[str]: ...
 
     @overload
     def run(
         self,
-        cmd: list[str] | tuple[str, ...],
+        cmd: CmdType,
         *,
         capture_output: Literal[False],
         check: bool = True,
@@ -87,12 +75,14 @@ class Context(typer.Context):
         shell: bool | None = None,
         echo: bool = True,
         dry_run: bool | None = None,
+        keep_temp_file: bool = False,
+        env: dict[str, str] | None = None,
         **kwargs,
     ) -> subprocess.CompletedProcess[None]: ...
 
     def run(
         self,
-        cmd: str | list[str] | tuple[str, ...],
+        cmd: CmdType,
         *,
         capture_output: bool = True,
         check: bool = True,
@@ -101,6 +91,9 @@ class Context(typer.Context):
         shell: bool | None = None,
         echo: bool = True,
         dry_run: bool | None = None,
+        keep_temp_file: bool = False,
+        env: dict[str, str] | None = None,
+        _encoding: str | None = None,
         **kwargs,
     ) -> subprocess.CompletedProcess[str] | subprocess.CompletedProcess[None]:
         return _run(
@@ -112,6 +105,9 @@ class Context(typer.Context):
             shell=shell,
             echo=echo,
             dry_run=self.obj.dry_run if dry_run is None else dry_run,
+            keep_temp_file=keep_temp_file,
+            env=env,
+            _encoding=_encoding,
             **kwargs,
         )
 
@@ -126,6 +122,8 @@ class Context(typer.Context):
         stream: bool = True,
         echo: bool = True,
         dry_run: bool | None = None,
+        keep_temp_file: bool = False,
+        env: dict[str, str] | None = None,
         **kwargs,
     ) -> subprocess.CompletedProcess[str] | subprocess.CompletedProcess[None]:
         return _run_script(
@@ -137,6 +135,8 @@ class Context(typer.Context):
             stream=stream,
             echo=echo,
             dry_run=self.obj.dry_run if dry_run is None else dry_run,
+            keep_temp_file=keep_temp_file,
+            env=env,
             **kwargs,
         )
 

bake/cli/common/obj.py

@@ -81,9 +81,11 @@ class BakefileObject:
             self.bakebook = get_bakebook_from_target_dir_path(
                 target_dir_path=self.bakefile_path, bakebook_name=self.bakebook_name
             )
-        except BakefileNotFoundError:
+        except BakefileNotFoundError as e:
             if allow_missing:
                 return
+            console.error(str(e))
+            raise SystemExit(1) from e
         except BakebookError as e:
             if allow_missing:
                 return

bake/manage/write_bakefile.py

@@ -1,8 +1,15 @@
 import types
 from pathlib import Path
 
+from bake.samples import simple
 from bake.utils.constants import BAKEBOOK_NAME_IN_SAMPLES
 
+# Allowed sample modules
+# This dictionary acts as a whitelist for security - only these modules can be used
+ALLOWED_SAMPLE_MODULES: dict[str, types.ModuleType] = {
+    simple.__name__: simple,
+}
+
 
 def write_bakefile(
     bakefile_path: Path, bakebook_name: str, sample_module: types.ModuleType
@@ -12,9 +19,21 @@ def write_bakefile(
             f"Module `{sample_module.__name__}` must have `{BAKEBOOK_NAME_IN_SAMPLES}` attribute"
         )
 
-    if sample_module.__file__ is None:
-        raise ValueError(f"Could not find `{sample_module.__name__}`")
+    module_name = sample_module.__name__
+    if module_name not in ALLOWED_SAMPLE_MODULES:
+        raise ValueError(
+            f"Module `{module_name}` is not in the allowed sample modules list. "
+            f"Allowed modules: {list(ALLOWED_SAMPLE_MODULES.keys())}"
+        )
+
+    allowed_module = ALLOWED_SAMPLE_MODULES[module_name]
+    if sample_module is not allowed_module:
+        raise ValueError(f"Module `{module_name}` does not match the allowed module object")
+
+    if allowed_module.__file__ is None:
+        raise ValueError(f"Could not find file for module `{module_name}`")
 
-    original_bakefile_content = Path(sample_module.__file__).read_text()
+    source_file_path = Path(allowed_module.__file__)
+    original_bakefile_content = source_file_path.read_text()
     customized_content = original_bakefile_content.replace(BAKEBOOK_NAME_IN_SAMPLES, bakebook_name)
     bakefile_path.write_text(customized_content)

bake/samples/simple.py

@@ -1,5 +1,4 @@
-from bake.bakebook.bakebook import Bakebook
-from bake.ui import console
+from bake import Bakebook, console
 
 __bakebook__ = Bakebook()
 

bake/ui/__init__.py

@@ -1,9 +1,10 @@
-from bake.ui import console
+from bake.ui import console, params
 from bake.ui.logger.setup import setup_logging
 from bake.ui.run import run, run_uv
 
 __all__ = [
     "console",
+    "params",
     "run",
     "run_uv",
     "setup_logging",

bake/ui/params.py

@@ -0,0 +1,5 @@
+from typing import Annotated
+
+import typer
+
+verbose_bool = Annotated[bool, typer.Option("-v", "--verbose", help="Run with verbose output")]

bake/ui/run/__init__.py

@@ -1,11 +1,5 @@
-"""Subprocess execution utilities for bake UI.
-
-Provides functions for running commands with real-time output streaming
-and capture capabilities.
-"""
-
-from bake.ui.run.run import OutputSplitter, run
+from bake.ui.run.run import CmdType, OutputSplitter, run
 from bake.ui.run.script import run_script
 from bake.ui.run.uv import run_uv
 
-__all__ = ["OutputSplitter", "run", "run_script", "run_uv"]
+__all__ = ["CmdType", "OutputSplitter", "run", "run_script", "run_uv"]

bake/ui/run/run.py

@@ -6,6 +6,7 @@ import sys
 import tempfile
 import threading
 import time
+from dataclasses import dataclass
 from pathlib import Path
 from typing import Literal, overload
 
@@ -25,6 +26,13 @@ logger = logging.getLogger(__name__)
 _subprocess_create_lock = threading.Lock()
 
 
+@dataclass(frozen=True, slots=True)
+class StreamSetup:
+    proc: subprocess.Popen
+    splitter: OutputSplitter
+    threads: list
+
+
 def _parse_shebang(script: str) -> str | None:
     """Parse shebang line, return interpreter path or None."""
     lines = script.strip().splitlines()
@@ -285,26 +293,17 @@ def run(
     logger.debug(f"[run] {cmd_str}", extra={"cwd": cwd})
     start = time.perf_counter()
 
-    if stream:
-        result = _run_with_stream(
-            cmd=cmd,
-            shell=shell,
-            cwd=cwd,
-            capture_output=capture_output,
-            env=env,
-            _encoding=_encoding,
-            **kwargs,
-        )
-    else:
-        result = _run_without_stream(
-            cmd=cmd,
-            shell=shell,
-            cwd=cwd,
-            capture_output=capture_output,
-            env=env,
-            _encoding=_encoding,
-            **kwargs,
-        )
+    _run = _run_with_stream if stream else _run_without_stream
+
+    result = _run(
+        cmd=cmd,
+        shell=shell,
+        cwd=cwd,
+        capture_output=capture_output,
+        env=env,
+        _encoding=_encoding,
+        **kwargs,
+    )
 
     _check_exit_code(returncode=result.returncode, check=check, cmd_str=cmd_str)
 
@@ -398,27 +397,41 @@ def _setup_pty_stream(
     env: dict[str, str] | None = None,
     _encoding: str | None = None,
     **kwargs,
-) -> tuple[subprocess.Popen, OutputSplitter]:
+) -> StreamSetup:
     # subprocess.Popen is not thread-safe, protect with lock
     # See: https://bugs.python.org/issue2320
     with _subprocess_create_lock:
-        stdout_fd, slave_fd = pty.openpty()
+        stdout_fd, slave_stdout = pty.openpty()
+
+        # Always create stderr PTY when streaming to ensure output goes through
+        # our thread which writes to sys.stderr (allows pytest to capture it)
+        stderr_fd, slave_stderr = pty.openpty()
+
         env = _prepare_subprocess_env(env)
         proc = subprocess.Popen(
             cmd,
             cwd=cwd,
-            stdout=slave_fd,
-            stderr=subprocess.PIPE if capture_output else None,
+            stdout=slave_stdout,
+            stderr=slave_stderr,
             shell=shell,
             env=env,
             **kwargs,
         )
-        os.close(slave_fd)
+        os.close(slave_stdout)
+        os.close(slave_stderr)
 
+    # Attach threads BEFORE releasing lock to ensure reader is ready
+    # when fast-exiting processes complete
     splitter = OutputSplitter(
-        stream=True, capture=capture_output, pty_fd=stdout_fd, encoding=_encoding
+        stream=True,
+        capture=capture_output,
+        pty_fd=stdout_fd,
+        stderr_pty_fd=stderr_fd,
+        encoding=_encoding,
     )
-    return proc, splitter
+    threads = splitter.attach(proc)
+
+    return StreamSetup(proc=proc, splitter=splitter, threads=threads)
 
 
 def _setup_pipe_stream(
@@ -429,7 +442,7 @@ def _setup_pipe_stream(
     env: dict[str, str] | None = None,
     _encoding: str | None = None,
     **kwargs,
-) -> tuple[subprocess.Popen, OutputSplitter, list]:
+) -> StreamSetup:
     # subprocess.Popen is not thread-safe, protect with lock
     # See: https://bugs.python.org/issue2320
     with _subprocess_create_lock:
@@ -448,7 +461,7 @@ def _setup_pipe_stream(
         splitter = OutputSplitter(stream=True, capture=capture_output, encoding=_encoding)
         threads = splitter.attach(proc)
 
-    return proc, splitter, threads
+    return StreamSetup(proc=proc, splitter=splitter, threads=threads)
 
 
 def _run_with_stream(
@@ -462,32 +475,22 @@ def _run_with_stream(
 ) -> subprocess.CompletedProcess[str] | subprocess.CompletedProcess[None]:
     use_pty = sys.platform != "win32"
 
-    if use_pty:
-        proc, splitter = _setup_pty_stream(
-            cmd=cmd,
-            shell=shell,
-            cwd=cwd,
-            capture_output=capture_output,
-            env=env,
-            _encoding=_encoding,
-            **kwargs,
-        )
-        threads = splitter.attach(proc)
-    else:
-        proc, splitter, threads = _setup_pipe_stream(
-            cmd=cmd,
-            shell=shell,
-            cwd=cwd,
-            capture_output=capture_output,
-            env=env,
-            _encoding=_encoding,
-            **kwargs,
-        )
+    _setup = _setup_pty_stream if use_pty else _setup_pipe_stream
+
+    setup = _setup(
+        cmd=cmd,
+        shell=shell,
+        cwd=cwd,
+        capture_output=capture_output,
+        env=env,
+        _encoding=_encoding,
+        **kwargs,
+    )
 
-    proc.wait()
-    splitter.finalize(threads)
+    setup.proc.wait()
+    setup.splitter.finalize(setup.threads)
 
-    return _process_stream_output(splitter, proc, cmd, capture_output)
+    return _process_stream_output(setup.splitter, setup.proc, cmd, capture_output)
 
 
 def _run_without_stream(
@@ -504,7 +507,7 @@ def _run_without_stream(
 
     # Use specified encoding with errors="replace", or fall back to text=True (platform default)
     if _encoding:
-        return subprocess.run(
+        result = subprocess.run(
             cmd,
             cwd=cwd,
             capture_output=capture_output,
@@ -516,7 +519,7 @@ def _run_without_stream(
             **kwargs,
         )
     else:
-        return subprocess.run(
+        result = subprocess.run(
             cmd,
             cwd=cwd,
             capture_output=capture_output,
@@ -527,6 +530,8 @@ def _run_without_stream(
             **kwargs,
         )
 
+    return result
+
 
 def _log_completion(cmd_str: str, result: subprocess.CompletedProcess, start: float) -> None:
     elapsed_seconds = time.perf_counter() - start

bake/ui/run/splitter.py

@@ -15,11 +15,13 @@ class OutputSplitter:
         stream: bool = True,
         capture: bool = True,
         pty_fd: int | None = None,
+        stderr_pty_fd: int | None = None,
         encoding: str | None = None,
     ):
         self._stream = stream
         self._capture = capture
         self._pty_fd = pty_fd
+        self._stderr_pty_fd = stderr_pty_fd
         self._encoding = encoding
         self._stdout_data = b""
         self._stderr_data = b""
@@ -208,7 +210,17 @@ class OutputSplitter:
             t.start()
             threads.append((t, stdout_list, "stdout"))
 
-        # Handle stderr (regular pipe)
+        # Handle PTY stderr (for color-preserving stderr on Unix)
+        if self._stderr_pty_fd is not None:
+            stderr_list = []
+            t = threading.Thread(
+                target=self._read_pty, args=(self._stderr_pty_fd, sys.stderr, stderr_list, proc)
+            )
+            t.daemon = True
+            t.start()
+            threads.append((t, stderr_list, "stderr"))
+
+        # Handle stderr (regular pipe) - use separate if, not elif
         if proc.stderr:
             stderr_list = []
             t = threading.Thread(

{bakefile-0.0.5.dist-info → bakefile-0.0.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: bakefile
-Version: 0.0.5
+Version: 0.0.7
 Summary: Add your description here
 Author: Wisaroot Lertthaweedech
 Author-email: Wisaroot Lertthaweedech <l.wisaroot@gmail.com>
@@ -10,6 +10,7 @@ Requires-Dist: loguru>=0.7.3
 Requires-Dist: orjson>=3.11.5
 Requires-Dist: pydantic-settings>=2.0.0
 Requires-Dist: pydantic>=2.12.5
+Requires-Dist: pyyaml>=6.0.3
 Requires-Dist: rich>=14.2.0
 Requires-Dist: ruff>=0.14.10
 Requires-Dist: tomli>=2.0.0 ; python_full_version < '3.11'

{bakefile-0.0.5.dist-info → bakefile-0.0.7.dist-info}/RECORD

@@ -1,4 +1,4 @@
-bake/__init__.py,sha256=SG-g8MVoBbXURlAP-OhtjMUMnRPTfi9lQ9WQD0EX7IE,338
+bake/__init__.py,sha256=ikK9AMD9ELxzcH3_JRZt3bnNLS0vCzlaH82gpGi_dNE,356
 bake/bakebook/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 bake/bakebook/bakebook.py,sha256=o1sp8Wewxdqr7k12qT-Q4ZrKQ7c7jDliiNCYrVG93NA,2939
 bake/bakebook/decorator.py,sha256=t2I6Pf1vdTk7k8lTzZCqq71-hzcXFvFYbuFV_Wvg45Q,1545
@@ -11,17 +11,18 @@ bake/cli/bake/reinvocation.py,sha256=Ifqc8ZAM7NMyrKU2jkmw1agCEI-Sx7yvLLBiFRi23_0
 bake/cli/bakefile/__init__.py,sha256=_zD3rXQHLr6EWHADdPLAmnc2A5C3dhmBuvP5uJ-_A58,60
 bake/cli/bakefile/__main__.py,sha256=FVntzkZdzdygSWjMzyneXCXsM-MDTPmC3GUk4JZiYFU,137
 bake/cli/bakefile/add_inline.py,sha256=V98T50SLMPqnWVtyEO_6hL17r4n3ZtkSC8NSEqdyHzc,919
+bake/cli/bakefile/export.py,sha256=m9X0u6FgbjUzneQuh39H1CaFUT444jOPTFBNjnjs_Dg,6326
 bake/cli/bakefile/find_python.py,sha256=J2HDs_nfNODqCHBZCNM64ESB4kVZK-C04i-KNmVUoSs,539
 bake/cli/bakefile/init.py,sha256=0QuvADFOZZUBN2BUJfK90aEY1oUzoSNVRiljlUSjLu0,1825
 bake/cli/bakefile/lint.py,sha256=DJkIJNBOef6JvgwQ3iL9jTrLqgUyn66Mhv6cuAgqXk0,2509
-bake/cli/bakefile/main.py,sha256=5O08RTx8tKHTMio8-RdEsLC6bUD7AKQ6rPNLBZqQiJ0,1352
+bake/cli/bakefile/main.py,sha256=jbpzNQa55thbzhpcmEtys1M1CvNUJBvi5UmgVzSbOM8,1414
 bake/cli/bakefile/uv.py,sha256=PMFG3BdofzGWkor4fMEi3GE4G7hGtclCgPm2xlaPDso,4013
 bake/cli/common/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-bake/cli/common/app.py,sha256=ViRqRX2DsLoKAunGKd6vOiwk4Xqmug1Gkux4_1RZX_U,1444
+bake/cli/common/app.py,sha256=_XzBOy0OK2GB14E-cyfLV6CBCn70G62QqjUscj_DHfA,1443
 bake/cli/common/callback.py,sha256=NmrZUl5eRr95nluomTwcKjTU7dSKjWcQVli5VEdZk-4,439
-bake/cli/common/context.py,sha256=p3_YCExH4NIIgB4ZTax2fYFOjI__Ig4FffbqegtPE8Q,3699
+bake/cli/common/context.py,sha256=RtFHUDCZLcD88Ys17u_zXoHUq-12jkoXc9f_D4jh_7M,3871
 bake/cli/common/exception_handler.py,sha256=2vLbqMeZlLxKqNWUkTs3cA-8l6IjK0dU3SyZlRb96YI,1759
-bake/cli/common/obj.py,sha256=O23DCxdoAV7Pujxk_ylrSKHL-7DSS1-7BZuxpa0Hv5M,7016
+bake/cli/common/obj.py,sha256=ShDsQtHCxex17IrKb9kSdC1t459qBsam53SFCUB_DSA,7094
 bake/cli/common/params.py,sha256=rhLa34SY92nXfUaKo0SQMKK__xRnrmHejHa25tRyKdg,2002
 bake/cli/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 bake/cli/utils/version.py,sha256=aiweLD0vDezBlJAcCC99oMms71WGD9CWSJuZ4i3VLHA,390
@@ -30,20 +31,21 @@ bake/manage/add_inline.py,sha256=yefHmF33ghCB8NZ-v61ybeVsaeE8iDFvfRGeTAKg4I8,224
 bake/manage/find_python.py,sha256=oVmd8KaSsgDQWHuGZpYiQx-DHn50P9EkRi6-YIad99E,7165
 bake/manage/lint.py,sha256=OqwYFF8GGvzHGVPuJcWMRAv5esXEIX4nQXdGcChnkqA,2394
 bake/manage/run_uv.py,sha256=QzlKeVpr20dXNDcwUgyJqnXT4MofRqK-6XkWpzBbUhE,3234
-bake/manage/write_bakefile.py,sha256=efGViLk7sh-QX9Mox7yQw_A1Tp7EOuc_vmSTbFmXUm0,736
+bake/manage/write_bakefile.py,sha256=ZlBL2XBy0XIY8_4t56szvq2c6-DwEyRuNljjZI3m0ls,1487
 bake/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 bake/samples/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-bake/samples/simple.py,sha256=tTL2OVqQXMYwIlgd1K5gtUKDzxx2CDEb24JLzXkadYg,192
-bake/ui/__init__.py,sha256=DeuVKFwrmhEcwcZnstItPecnvYugpLcPM_a7YEhnqD8,187
+bake/samples/simple.py,sha256=hP2TW-D7BQBGJseqRPpilxkoQ8ScTuZZePICupyvFKA,155
+bake/ui/__init__.py,sha256=6OhZVKjfC9aumbhraxkGtx7KLpV1ouepeHRA2dUVoSo,209
 bake/ui/console.py,sha256=C5wrbsOc-wwcx0hGmCozHvGCNTWgGhsh-5vxl880xS4,1689
 bake/ui/logger/__init__.py,sha256=bup2cssTHhergh47s6uYbGtY2dJNxlKKH6otBc4ECFM,728
 bake/ui/logger/capsys.py,sha256=KZL6k7Werp_8styfJKfIvQyv0-gJq54vY3hSJFIacEM,5267
 bake/ui/logger/setup.py,sha256=OrX9UiY0iBGfWWfhMJCdfqCRJsL5yC3rIdIEOn7rveo,1377
 bake/ui/logger/utils.py,sha256=dcppxoS_pX92AFcHIerJGI2_JBHBNghRQmQqlZmmj2Q,7218
-bake/ui/run/__init__.py,sha256=RLQN4f6mY2wyWtqe2e9B1jKwR5P9IyBcZGLdOwj91Ds,336
-bake/ui/run/run.py,sha256=5ve7qbl37hRTpbLFf-wDtmG3RuVKYPlSUOsRlSZ9nUU,17390
+bake/ui/params.py,sha256=yNDChJQkbeZSxQzXTSBrAPCbwsJ5zOK4s4sFHQPSnHs,140
+bake/ui/run/__init__.py,sha256=A671l5YVTRAtS47ewvaMCNwPRim_Wkof1am0WibxA2I,205
+bake/ui/run/run.py,sha256=qfDgy-YqcexJyHhSjnQ5IXipBDoK-umwKq-wAn8ZITU,17504
 bake/ui/run/script.py,sha256=fk7KiDklYDYpFGkH3wu-hZGI4OnvgcB8z5jtNt41Hg0,2263
-bake/ui/run/splitter.py,sha256=92h4KaomqoYsxi9xZoLoSvk-7JdBF0YL-QNPpVaXqEA,8139
+bake/ui/run/splitter.py,sha256=sQt0prFGR6WCCMDr1wqk1GXBQmUSV9MNHzYzMu9Pwik,8643
 bake/ui/run/uv.py,sha256=3NpnjgAwQNijJiUT_H6U-3mTHQgBZPlJbNWEeYCZY1g,2077
 bake/ui/style.py,sha256=v9dferzV317Acb0GHpVK_niCj_s2HtL-yiToBZtXky4,70
 bake/utils/__init__.py,sha256=GUu_xlJy3RAHo6UcZXu2x4khxGqLHMA9Zos4hDiQIY8,326
@@ -52,10 +54,10 @@ bake/utils/env.py,sha256=bzNdH_2bTJebQaw7D0uVJv-vzZ-uYl0pCAS8oQONVsA,190
 bake/utils/exceptions.py,sha256=pwsQnKH5ljMNxmqEREutXa7TohiBHATHg_D5kQUPT30,519
 bakelib/__init__.py,sha256=sZeRiNINWL8xI3b1MxkGyF3f2lKMjyhjKt7qyCCAufs,126
 bakelib/space/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-bakelib/space/base.py,sha256=HzJYzwbeX5YN6Esmxt4fSDRGJNUk4OfZ3Zf9m0bNsX4,2103
-bakelib/space/python.py,sha256=rlEJW5y1q00lGMHwYXicwTt1a4NUXfSei-T_pg88oMA,1223
-bakelib/space/utils.py,sha256=SfNRFeAm35zfF01-fdxKXTlw2uL6DyU0TJXDFkUG7Zk,1471
-bakefile-0.0.5.dist-info/WHEEL,sha256=XjEbIc5-wIORjWaafhI6vBtlxDBp7S9KiujWF1EM7Ak,79
-bakefile-0.0.5.dist-info/entry_points.txt,sha256=Ecvvh7BYHCPJ0UdntrDc3Od6AZdRPXN5Z7o_7ok_0Qw,107
-bakefile-0.0.5.dist-info/METADATA,sha256=vBmhYvnlTTuO2x4IpgNudcEBITAy23VZGvmYahT99kY,2302
-bakefile-0.0.5.dist-info/RECORD,,
+bakelib/space/base.py,sha256=bJlpPkP85xBu8X5fJoVaHrMzX27rQrYTEPSObwBANJ8,6008
+bakelib/space/python.py,sha256=UEr4Jo76T2cbAQdClVu7RvJYzflLE9i_xFohcNhjFjw,2597
+bakelib/space/utils.py,sha256=xx4X_txhDH_p97CKJ-KuvFpgfNBC0y_din1IBlUVusU,2983
+bakefile-0.0.7.dist-info/WHEEL,sha256=XV0cjMrO7zXhVAIyyc8aFf1VjZ33Fen4IiJk5zFlC3g,80
+bakefile-0.0.7.dist-info/entry_points.txt,sha256=Ecvvh7BYHCPJ0UdntrDc3Od6AZdRPXN5Z7o_7ok_0Qw,107
+bakefile-0.0.7.dist-info/METADATA,sha256=zVQg9_SCgUUvIT_rosZIW8pf658SG3pDTfyp4I5qMek,2331
+bakefile-0.0.7.dist-info/RECORD,,

{bakefile-0.0.5.dist-info → bakefile-0.0.7.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: uv 0.9.25
+Generator: uv 0.9.26
 Root-Is-Purelib: true
-Tag: py3-none-any
+Tag: py3-none-any

bakelib/space/base.py

@@ -1,30 +1,49 @@
-from typing import Annotated
+from pathlib import Path
+from typing import Annotated, Literal
 
+import orjson
 import typer
 
 from bake import Bakebook, Context, command
 from bake.ui import console
 
-from .utils import remove_git_clean_candidates
+from .utils import (
+    HOMWBREW_BIN,
+    LOCAL_BIN,
+    VENV_BIN,
+    PlatformType,
+    ToolInfo,
+    get_expected_paths,
+    get_platform,
+    remove_git_clean_candidates,
+    setup_brew,
+    setup_bun,
+    setup_uv,
+    setup_uv_tool,
+)
 
 
 class BaseSpace(Bakebook):
+    def _no_implementation(self, ctx: Context | None = None, *args, **kwargs):
+        _ = ctx, args, kwargs
+        console.error("No implementation")
+        raise typer.Exit(1)
+
     @command(help="Run linters and formatters")
     def lint(self, ctx: Context) -> None:
-        ctx.run(
-            [
-                "bunx",
-                "prettier@latest",
-                "--write",
-                "**/*.{js,jsx,ts,tsx,css,json,json5,yaml,yml,md}",
-            ]
-        )
+        ctx.run('bunx prettier@latest --write "**/*.{js,jsx,ts,tsx,css,json,json5,yaml,yml,md\'}"')
 
     @command(help="Run unit tests")
     def test(self, ctx: Context) -> None:
-        _ = ctx
-        console.error("No implementation")
-        raise typer.Exit(1)
+        self._no_implementation(ctx)
+
+    @command(help="Run integration tests")
+    def test_integration(self, ctx: Context) -> None:
+        self._no_implementation(ctx)
+
+    @command(help="Run all tests")
+    def test_all(self, ctx: Context) -> None:
+        self._no_implementation(ctx)
 
     @command(help="Clean gitignored files with optional exclusions")
     def clean(
@@ -66,8 +85,109 @@ class BaseSpace(Bakebook):
     def clean_all(self, ctx: Context) -> None:
         ctx.run("git clean -fdX")
 
+    def setup_tool_managers(self, ctx: Context, platform: PlatformType) -> None:
+        _ = platform
+        setup_brew(ctx)
+
+    def setup_tools(self, ctx: Context, platform: PlatformType) -> None:
+        _ = platform
+        setup_bun(ctx)
+        setup_uv(ctx)
+        setup_uv_tool(ctx)
+
+    def setup_project(self, ctx: Context) -> None:
+        ctx.run("uv run pre-commit install")
+
     @command(help="Setup development environment")
     def setup_dev(self, ctx: Context) -> None:
+        platform = get_platform()
+        console.echo(f"Detected platform: {platform}")
+
+        if platform != "macos":
+            console.warning(f"Platform '{platform}' is not supported. Running in dry-run mode.")
+            overridden_dry_run = True
+        else:
+            overridden_dry_run = ctx.dry_run
+
+        with ctx.override_dry_run(overridden_dry_run):
+            self.clean(ctx=ctx)
+            self.setup_tool_managers(ctx=ctx, platform=platform)
+            self.setup_tools(ctx=ctx, platform=platform)
+            self.setup_project(ctx=ctx)
+
+    def _assert_which_path(
+        self,
+        ctx: Context,
+        tool_name: str,
+        tool_info: ToolInfo,
+    ) -> bool:
+        result = ctx.run(f"which {tool_name}", stream=False)
+        if ctx.dry_run:
+            return True
+        actual_path = Path(result.stdout.strip())
+
+        if actual_path in set(tool_info.expected_paths):
+            console.success(f"{tool_name}: {actual_path}")
+            return True
+
+        console.warning(f"{tool_name}: unexpected location (got {actual_path})")
+        return False
+
+    def _get_tools(self) -> dict[str, ToolInfo]:
+        return {
+            # homebrew only
+            "bun": ToolInfo(expected_paths=get_expected_paths("bun", {HOMWBREW_BIN})),
+            # homebrew or venv
+            "uv": ToolInfo(expected_paths=get_expected_paths("uv", {HOMWBREW_BIN, VENV_BIN})),
+            # local or venv
+            "bakefile": ToolInfo(
+                expected_paths=get_expected_paths("bakefile", {LOCAL_BIN, VENV_BIN})
+            ),
+            "pre-commit": ToolInfo(
+                expected_paths=get_expected_paths("pre-commit", {LOCAL_BIN, VENV_BIN})
+            ),
+        }
+
+    @command(help="List development tools")
+    def tools(
+        self,
+        ctx: Context,
+        format: Annotated[
+            Literal["json", "names"],
+            typer.Option("--format", "-f", help="Output format"),
+        ] = "json",
+    ) -> None:
         _ = ctx
-        console.error("No implementation")
-        raise typer.Exit(1)
+        tools = self._get_tools()
+        if format == "json":
+            output: dict[str, dict[str, str | None]] = {k: v.model_dump() for k, v in tools.items()}
+            console.echo(orjson.dumps(output, option=orjson.OPT_INDENT_2).decode())
+        else:
+            console.echo("\n".join(sorted(tools.keys())))
+
+    @command(help="Assert development environment setup")
+    def assert_setup_dev(
+        self,
+        ctx: Context,
+        skip_test: Annotated[
+            bool,
+            typer.Option(
+                "--skip-test",
+                "-s",
+                help="Skip running tests",
+                is_flag=True,
+            ),
+        ] = False,
+    ) -> None:
+        tools = self._get_tools()
+        for tool_name, tool_info in tools.items():
+            self._assert_which_path(ctx, tool_name, tool_info)
+
+        self.lint(ctx)
+        if not skip_test:
+            self.test(ctx)
+
+    @command(help="Upgrade all dependencies")
+    def update(self, ctx: Context) -> None:
+        ctx.run("uv python upgrade")
+        ctx.run("uv tool upgrade --all")

bakelib/space/python.py

@@ -1,42 +1,80 @@
-from bake import Context
+from pathlib import Path
 
-from .base import BaseSpace
+from bake import Context, params
+
+from .base import BaseSpace, ToolInfo
+from .utils import VENV_BIN, get_expected_paths
+
+
+def _get_python_version() -> str | None:
+    path = Path(".python-version")
+    if not path.exists():
+        return None
+    return path.read_text().strip()
 
 
 class PythonSpace(BaseSpace):
+    def _get_tools(self) -> dict[str, ToolInfo]:
+        tools = super()._get_tools()
+        tools["python"] = ToolInfo(
+            version=_get_python_version(),
+            expected_paths=list(get_expected_paths("python", {VENV_BIN})),
+        )
+        return tools
+
     def lint(self, ctx: Context) -> None:
         super().lint(ctx=ctx)
 
         ctx.run(
-            [
-                "uv",
-                "run",
-                "toml-sort",
-                "--sort-inline-arrays",
-                "--in-place",
-                "--sort-first=project,dependency-groups",
-                "pyproject.toml",
-            ]
+            "uv run toml-sort --sort-inline-arrays --in-place "
+            "--sort-first=project,dependency-groups pyproject.toml"
         )
-        ctx.run(["uv", "run", "ruff", "format", "--exit-non-zero-on-format", "."])
-        ctx.run(["uv", "run", "ruff", "check", "--fix", "--exit-non-zero-on-fix", "."])
-        ctx.run(["uv", "run", "ty", "check", "--error-on-warning", "."])
-        ctx.run(["uv", "run", "deptry", "."])
+        ctx.run("uv run ruff format --exit-non-zero-on-format .")
+        ctx.run("uv run ruff check --fix --exit-non-zero-on-fix .")
+        ctx.run("uv run ty check --error-on-warning --no-progress .")
+        ctx.run("uv run deptry .")
 
-    def test(self, ctx: Context) -> None:
-        ctx.run(
-            [
-                "uv",
-                "run",
-                "pytest",
-                "tests/",
-                "--cov=src",
-                "--cov-report=html",
-                "--cov-report=term-missing",
-                "--cov-report=xml",
-            ]
+    def _test(self, ctx: Context, *, tests_path: str, verbose: bool = False) -> None:
+        cmd = (
+            f"uv run pytest {tests_path} --cov=src --cov-report=html"
+            " --cov-report=term-missing --cov-report=xml"
         )
 
-    def setup_dev(self, ctx: Context) -> None:
-        super().clean(ctx=ctx)
+        if verbose:
+            cmd += " -s -v"
+
+        ctx.run(cmd)
+
+    def test_integration(
+        self,
+        ctx: Context,
+        verbose: params.verbose_bool = False,
+    ) -> None:
+        integration_tests_path = "tests/integration/"
+        if Path(integration_tests_path).exists():
+            tests_path = integration_tests_path
+            self._test(ctx, tests_path=tests_path, verbose=verbose)
+        else:
+            self._no_implementation(ctx)
+
+    def test(self, ctx: Context) -> None:
+        unit_tests_path = "tests/unit/"
+        tests_path = unit_tests_path if Path(unit_tests_path).exists() else "tests/"
+        self._test(ctx, tests_path=tests_path)
+
+    def test_all(self, ctx: Context) -> None:
+        unit_tests_path = "tests/unit/"
+        if Path(unit_tests_path).exists():
+            tests_path = "tests/"
+            self._test(ctx, tests_path=tests_path)
+        else:
+            self._no_implementation(ctx)
+
+    def setup_project(self, ctx: Context) -> None:
+        super().setup_project(ctx=ctx)
         ctx.run("uv sync --all-extras --all-groups --frozen")
+
+    def update(self, ctx: Context) -> None:
+        super().update(ctx=ctx)
+        ctx.run("uv lock --upgrade")
+        ctx.run("uv sync --all-extras --all-groups")

bakelib/space/utils.py

@@ -1,12 +1,75 @@
 import shutil
+import sys
+from enum import Enum
 from pathlib import Path
+from typing import Literal
 
 import pathspec
 from pathspec.patterns.gitignore.basic import GitIgnoreBasicPattern
+from pydantic import BaseModel, Field
 
+from bake import Context
 from bake.ui import console
 
 
+def setup_brew(ctx: Context) -> None:
+    ctx.run("brew update")
+    ctx.run("brew upgrade")
+    ctx.run("brew cleanup")
+    ctx.run("brew list")
+    ctx.run("brew leaves")
+
+
+class ToolInfo(BaseModel):
+    version: str | None = None
+    expected_paths: list[Path] = Field(default_factory=list, exclude=True)
+
+
+class Platform(Enum):
+    MACOS = "macos"
+    LINUX = "linux"
+    WINDOWS = "windows"
+    OTHER = "other"
+
+
+PlatformType = Literal["macos", "linux", "windows", "other"]
+
+
+def get_platform() -> PlatformType:
+    if sys.platform == "darwin":
+        return Platform.MACOS.value
+    elif sys.platform == "linux":
+        return Platform.LINUX.value
+    elif sys.platform == "win32":
+        return Platform.WINDOWS.value
+    return Platform.OTHER.value
+
+
+def setup_uv(ctx: Context) -> None:
+    ctx.run("brew install uv")
+    ctx.run("uv python upgrade")
+    ctx.run("uv tool upgrade --all")
+    ctx.run("uv tool update-shell")
+
+
+def setup_bun(ctx: Context) -> None:
+    ctx.run("brew install oven-sh/bun/bun")
+
+
+def setup_uv_tool(ctx: Context) -> None:
+    ctx.run("uv tool install bakefile")
+    ctx.run("uv tool install pre-commit")
+
+
+HOMWBREW_BIN = Path("/opt/homebrew/bin")
+LOCAL_BIN = Path.home() / ".local" / "bin"
+VENV_BIN = Path.cwd() / ".venv" / "bin"
+
+
+def get_expected_paths(tool: str, locations: set[Path]) -> list[Path]:
+    return [loc / tool for loc in locations]
+
+
 def _skip_msg(path: Path, suffix: str, dry_run: bool) -> None:
     verb = "Would skip" if dry_run else "Skipping"
     console.echo(f"[yellow]~[/yellow] {verb} {suffix}{path}")