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

bake/ui/run/splitter.py

@@ -0,0 +1,237 @@
+import os
+import select
+import subprocess
+import sys
+import threading
+import time
+
+# No PTY locks needed - each thread reads from its own PTY fd independently
+# Locks were causing race conditions where threads waited while their process exited
+
+
+class OutputSplitter:
+    def __init__(
+        self,
+        stream: bool = True,
+        capture: bool = True,
+        pty_fd: int | None = None,
+        encoding: str | None = None,
+    ):
+        self._stream = stream
+        self._capture = capture
+        self._pty_fd = pty_fd
+        self._encoding = encoding
+        self._stdout_data = b""
+        self._stderr_data = b""
+
+    def _read_stream(self, stream, target, output_list):
+        for line in iter(stream.readline, b""):
+            if self._stream:
+                target.buffer.write(line)
+                target.buffer.flush()
+            if self._capture:
+                output_list.append(line)
+        stream.close()
+
+    def _handle_data(self, data: bytes, target, output_list) -> bool:
+        """Handle data chunk: return False if data is empty (EOF)."""
+        if not data:
+            return False
+        if self._stream:
+            target.buffer.write(data)
+            target.buffer.flush()
+        if self._capture:
+            output_list.append(data)
+        return True
+
+    def _read_pty(self, pty_fd: int, target, output_list, proc: subprocess.Popen):
+        """Read from PTY file descriptor in chunks and stream to output."""
+        import fcntl
+
+        try:
+            while True:
+                # Try immediate non-blocking read first (catches fast-exiting processes)
+                try:
+                    # Set non-blocking mode
+                    flags = fcntl.fcntl(pty_fd, fcntl.F_GETFL)
+                    fcntl.fcntl(pty_fd, fcntl.F_SETFL, flags | os.O_NONBLOCK)
+
+                    data = os.read(pty_fd, 4096)
+                    if not self._handle_data(data, target, output_list):
+                        break
+
+                    # Restore blocking mode
+                    fcntl.fcntl(pty_fd, fcntl.F_SETFL, flags)
+                except BlockingIOError:
+                    # No data available yet, restore blocking mode and wait with select
+                    fcntl.fcntl(pty_fd, fcntl.F_SETFL, flags)
+
+                    # Wait for data to be available
+                    ready, _, _ = select.select([pty_fd], [], [], 0.1)
+
+                    if ready:
+                        data = os.read(pty_fd, 4096)
+                        if not self._handle_data(data, target, output_list):
+                            break
+
+                # Check if process exited after reading data
+                if proc.poll() is not None:
+                    self._drain_pty(pty_fd, target, output_list)
+                    break
+        finally:
+            os.close(pty_fd)
+
+    def _read_pty_data(self, pty_fd: int, target, output_list) -> bool:
+        """Read and handle available PTY data. Returns False on EOF/error."""
+        try:
+            data = os.read(pty_fd, 4096)
+            return self._handle_data(data, target, output_list)
+        except OSError:
+            return False
+
+    def _try_select_read(self, pty_fd: int, timeout: float) -> tuple[bool, bool]:
+        """Try to read using select.select().
+
+        Returns:
+            (success, has_data): success if select worked, has_data if ready
+        """
+        try:
+            ready, _, _ = select.select([pty_fd], [], [], timeout)
+            return True, bool(ready)
+        except OSError:
+            # On Windows, select.select() raises OSError for non-socket file descriptors
+            return False, False
+
+    def _read_and_handle(self, pty_fd: int, target, output_list) -> bool:
+        """Read from PTY and handle data.
+
+        Returns:
+            True if data was handled, False if EOF/error
+        """
+        try:
+            data = os.read(pty_fd, 4096)
+            return self._handle_data(data, target, output_list)
+        except OSError:
+            return False
+
+    def _handle_data_ready(self, pty_fd: int, target, output_list) -> bool:
+        """Handle data ready from select.
+
+        Returns:
+            True if should continue draining, False if done
+        """
+        return self._read_and_handle(pty_fd, target, output_list)
+
+    def _handle_timeout(
+        self,
+        pty_fd: int,
+        target,
+        output_list,
+        select_works: bool,
+        consecutive_timeouts: int,
+    ) -> tuple[bool, int]:
+        """Handle timeout when no data ready.
+
+        Returns:
+            (should_continue, new_timeout_count)
+        """
+        # Try direct read after 2 consecutive timeouts or if select doesn't work
+        if not select_works or consecutive_timeouts >= 2:
+            if not self._read_and_handle(pty_fd, target, output_list):
+                return False, 0
+            return True, 0  # Got data, reset timeout counter
+        return True, consecutive_timeouts + 1
+
+    def _drain_pty(self, pty_fd: int, target, output_list):
+        """Drain remaining data from PTY after process exits.
+
+        We need to handle OS timing: proc.poll() may return exit code before the
+        PTY buffer is fully flushed. We use select to wait for data with increasing
+        timeouts, and also try direct reads as a fallback in case select doesn't
+        detect readiness (e.g., in tests with mocked os.read or on Windows with
+        non-socket file descriptors).
+        """
+        time.sleep(0.005)
+
+        timeout = 0.05
+        consecutive_timeouts = 0
+        max_timeouts = 4
+        select_works = True
+
+        try:
+            while consecutive_timeouts < max_timeouts:
+                # Check if data is ready via select
+                if select_works:
+                    select_works, ready = self._try_select_read(pty_fd, timeout)
+                else:
+                    ready = False
+
+                if ready:
+                    # Data ready - read and handle
+                    if not self._handle_data_ready(pty_fd, target, output_list):
+                        return
+                    consecutive_timeouts = 0
+                    timeout = 0.02
+                    continue
+
+                # No data ready - increment timeout and try direct read
+                timeout = min(timeout * 1.5, 0.2)
+
+                should_continue, consecutive_timeouts = self._handle_timeout(
+                    pty_fd, target, output_list, select_works, consecutive_timeouts
+                )
+                if not should_continue:
+                    return
+        except OSError:
+            pass
+
+    def attach(self, proc: subprocess.Popen):
+        threads = []
+
+        # Handle PTY stdout (for color-preserving output on Unix)
+        if self._pty_fd is not None:
+            stdout_list = []
+            t = threading.Thread(
+                target=self._read_pty, args=(self._pty_fd, sys.stdout, stdout_list, proc)
+            )
+            t.daemon = True
+            t.start()
+            threads.append((t, stdout_list, "stdout"))
+
+        # Handle regular stdout
+        elif proc.stdout:
+            stdout_list = []
+            t = threading.Thread(
+                target=self._read_stream, args=(proc.stdout, sys.stdout, stdout_list)
+            )
+            t.daemon = True
+            t.start()
+            threads.append((t, stdout_list, "stdout"))
+
+        # Handle stderr (regular pipe)
+        if proc.stderr:
+            stderr_list = []
+            t = threading.Thread(
+                target=self._read_stream, args=(proc.stderr, sys.stderr, stderr_list)
+            )
+            t.daemon = True
+            t.start()
+            threads.append((t, stderr_list, "stderr"))
+
+        return threads
+
+    def finalize(self, threads):
+        for t, data_list, name in threads:
+            t.join()
+            if name == "stdout":
+                self._stdout_data = b"".join(data_list)
+            else:
+                self._stderr_data = b"".join(data_list)
+
+    @property
+    def stdout(self) -> bytes:
+        return self._stdout_data
+
+    @property
+    def stderr(self) -> bytes:
+        return self._stderr_data

bake/ui/run/uv.py

@@ -0,0 +1,83 @@
+import subprocess
+from pathlib import Path
+from typing import Literal, overload
+
+from uv import find_uv_bin
+
+from bake.ui import console
+from bake.ui.run.run import run
+
+
+@overload
+def run_uv(
+    cmd: list[str] | tuple[str, ...],
+    *,
+    capture_output: Literal[True] = True,
+    check: bool = True,
+    cwd: Path | str | None = None,
+    stream: bool = False,
+    shell: bool | None = None,
+    echo: bool = True,
+    dry_run: bool = False,
+    keep_temp_file: bool = False,
+    env: dict[str, str] | None = None,
+    _encoding: str | None = None,
+    **kwargs,
+) -> subprocess.CompletedProcess[str]: ...
+
+
+@overload
+def run_uv(
+    cmd: list[str] | tuple[str, ...],
+    *,
+    capture_output: Literal[False],
+    check: bool = True,
+    cwd: Path | str | None = None,
+    stream: bool = False,
+    echo: bool = True,
+    dry_run: bool = False,
+    keep_temp_file: bool = False,
+    env: dict[str, str] | None = None,
+    _encoding: str | None = None,
+    **kwargs,
+) -> subprocess.CompletedProcess[None]: ...
+
+
+def run_uv(
+    cmd: list[str] | tuple[str, ...],
+    *,
+    capture_output: bool = True,
+    check: bool = True,
+    cwd: Path | str | None = None,
+    stream: bool = False,
+    echo: bool = True,
+    dry_run: bool = False,
+    keep_temp_file: bool = False,
+    env: dict[str, str] | None = None,
+    _encoding: str | None = None,
+    **kwargs,
+) -> subprocess.CompletedProcess[str] | subprocess.CompletedProcess[None]:
+    uv_bin = find_uv_bin()
+
+    # Build display string: "uv" + command parts (no full binary path)
+    display_cmd = "uv " + " ".join(cmd)
+
+    # Echo command to console if requested
+    if echo:
+        console.cmd(display_cmd)
+
+    # Call run with full uv binary path, echo=False (already displayed), pass through options
+    return run(
+        [uv_bin, *cmd],
+        capture_output=capture_output,
+        check=check,
+        cwd=cwd,
+        stream=stream,
+        shell=False,
+        echo=False,
+        dry_run=dry_run,
+        keep_temp_file=keep_temp_file,
+        env=env,
+        _encoding=_encoding,
+        **kwargs,
+    )

bake/ui/style.py

@@ -0,0 +1,2 @@
+def code(message: str) -> str:
+    return f"`[cyan]{message}[/cyan]`"

bake/utils/__init__.py

@@ -0,0 +1,11 @@
+from bake.utils.constants import DEFAULT_BAKEBOOK_NAME, DEFAULT_FILE_NAME
+from bake.utils.env import should_use_colors
+from bake.utils.exceptions import BakebookError, BaseBakefileError
+
+__all__ = [
+    "DEFAULT_BAKEBOOK_NAME",
+    "DEFAULT_FILE_NAME",
+    "BakebookError",
+    "BaseBakefileError",
+    "should_use_colors",
+]

bake/utils/constants.py

@@ -0,0 +1,21 @@
+from pathlib import Path
+
+# Default value
+DEFAULT_CHDIR = Path(".")
+DEFAULT_FILE_NAME = "bakefile.py"
+DEFAULT_BAKEBOOK_NAME = "bakebook"
+DEFAULT_IS_CHAIN_COMMAND = False
+
+# CLI command names
+CMD_BAKE = "bake"
+CMD_BAKEFILE = "bakefile"
+CMD_INIT = "init"
+CMD_ADD_INLINE = "add-inline"
+CMD_LINT = "lint"
+
+# Bakefile app command name
+GET_BAKEFILE_OBJECT = "get_bakefile_object"
+
+# Others
+BAKEBOOK_NAME_IN_SAMPLES = "__bakebook__"
+BAKE_COMMAND_KWARGS = "_bake_command_kwargs"

{bakefile → bake/utils}/env.py

@@ -2,7 +2,9 @@ import os
 
 ENV_NO_COLOR = "NO_COLOR"
 
+_BAKE_REINVOKED = "_BAKE_REINVOKED"
+
 
 def should_use_colors() -> bool:
     value = os.environ.get(ENV_NO_COLOR)
-    return not (value == "" or value is None)
+    return value == "" or value is None

bake/utils/exceptions.py

@@ -0,0 +1,17 @@
+"""Custom exceptions for bakefile."""
+
+
+class BaseBakefileError(Exception):
+    """Base exception for all bakefile errors."""
+
+
+class BakebookError(BaseBakefileError):
+    """Exception raised when bakebook cannot be loaded or validated (unexpected error)."""
+
+
+class BakefileNotFoundError(BakebookError):
+    """Exception raised when bakefile.py is not found (expected/suppressable error)."""
+
+
+class PythonNotFoundError(BaseBakefileError):
+    """Exception raised when Python executable cannot be found or created."""

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

@@ -1,12 +1,24 @@
 Metadata-Version: 2.3
 Name: bakefile
-Version: 0.0.4
+Version: 0.0.5
 Summary: Add your description here
 Author: Wisaroot Lertthaweedech
 Author-email: Wisaroot Lertthaweedech <l.wisaroot@gmail.com>
+Requires-Dist: beautysh>=6.4.2
+Requires-Dist: click>=8.3.1
+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: typer>=0.0.1
+Requires-Dist: rich>=14.2.0
+Requires-Dist: ruff>=0.14.10
+Requires-Dist: tomli>=2.0.0 ; python_full_version < '3.11'
+Requires-Dist: ty>=0.0.8
+Requires-Dist: typer>=0.21.0
+Requires-Dist: uv>=0.9.20
+Requires-Dist: pathspec>=1.0.3 ; extra == 'lib'
 Requires-Python: >=3.10
+Provides-Extra: lib
 Description-Content-Type: text/markdown
 
 [![tests](https://img.shields.io/github/actions/workflow/status/wislertt/bakefile/cd.yml?branch=main&label=tests&logo=github)](https://github.com/wislertt/bakefile/actions/workflows/cd.yml)

bakefile-0.0.5.dist-info/RECORD

@@ -0,0 +1,61 @@
+bake/__init__.py,sha256=SG-g8MVoBbXURlAP-OhtjMUMnRPTfi9lQ9WQD0EX7IE,338
+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
+bake/bakebook/get.py,sha256=fx5WV66OIBrywPN0thePXAJk2gt7wvTVAxYQqZ_PMao,5807
+bake/cli/__init__.py,sha256=da1PTClDMl-IBkrSvq6JC1lnS-K_BASzCvxVhNxN5Ls,13
+bake/cli/bake/__init__.py,sha256=CJokSP1t1KXaIqjkjFQ8_gbaSZ9RRB4YdemIoSTqRcI,56
+bake/cli/bake/__main__.py,sha256=5Ui5_OD1-oG1ou6boak63EPQDmRsW9sGOVVDgXJaNec,133
+bake/cli/bake/main.py,sha256=Lr6eyfaf4-zDRrF0GK9bjjFWop66ydewV5tNUluDd9M,2262
+bake/cli/bake/reinvocation.py,sha256=Ifqc8ZAM7NMyrKU2jkmw1agCEI-Sx7yvLLBiFRi23_0,1985
+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/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/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/callback.py,sha256=NmrZUl5eRr95nluomTwcKjTU7dSKjWcQVli5VEdZk-4,439
+bake/cli/common/context.py,sha256=p3_YCExH4NIIgB4ZTax2fYFOjI__Ig4FffbqegtPE8Q,3699
+bake/cli/common/exception_handler.py,sha256=2vLbqMeZlLxKqNWUkTs3cA-8l6IjK0dU3SyZlRb96YI,1759
+bake/cli/common/obj.py,sha256=O23DCxdoAV7Pujxk_ylrSKHL-7DSS1-7BZuxpa0Hv5M,7016
+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
+bake/manage/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+bake/manage/add_inline.py,sha256=yefHmF33ghCB8NZ-v61ybeVsaeE8iDFvfRGeTAKg4I8,2245
+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/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/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/run/script.py,sha256=fk7KiDklYDYpFGkH3wu-hZGI4OnvgcB8z5jtNt41Hg0,2263
+bake/ui/run/splitter.py,sha256=92h4KaomqoYsxi9xZoLoSvk-7JdBF0YL-QNPpVaXqEA,8139
+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
+bake/utils/constants.py,sha256=mRq5IpgOTdlHOTWPq5dx0A-LwhiFkWgYHfr8cLWG7rY,471
+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,,

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

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

bakefile-0.0.5.dist-info/entry_points.txt

@@ -0,0 +1,5 @@
+[console_scripts]
+bake = bake.cli.bake:main
+bakefile = bake.cli.bakefile:main
+bf = bake.cli.bakefile:main
+

bakelib/__init__.py

@@ -0,0 +1,4 @@
+from bakelib.space.base import BaseSpace
+from bakelib.space.python import PythonSpace
+
+__all__ = ["BaseSpace", "PythonSpace"]

bakelib/space/base.py

@@ -0,0 +1,73 @@
+from typing import Annotated
+
+import typer
+
+from bake import Bakebook, Context, command
+from bake.ui import console
+
+from .utils import remove_git_clean_candidates
+
+
+class BaseSpace(Bakebook):
+    @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}",
+            ]
+        )
+
+    @command(help="Run unit tests")
+    def test(self, ctx: Context) -> None:
+        _ = ctx
+        console.error("No implementation")
+        raise typer.Exit(1)
+
+    @command(help="Clean gitignored files with optional exclusions")
+    def clean(
+        self,
+        ctx: Context,
+        exclude_patterns: Annotated[
+            list[str] | None,
+            typer.Option(
+                "--exclude-patterns",
+                "-e",
+                help="Patterns to exclude",
+            ),
+        ] = None,
+        use_default_excludes: Annotated[
+            bool,
+            typer.Option(
+                "--no-default-excludes",
+                help="Do not apply default exclude patterns",
+                is_flag=True,
+            ),
+        ] = False,
+    ) -> None:
+        results = ctx.run("git clean -fdX -n", stream=False, dry_run=False, echo=True)
+
+        exclude_patterns: set[str] = set(exclude_patterns if exclude_patterns else [])
+
+        if not use_default_excludes:
+            exclude_patterns |= {".env", ".cache"}
+
+        console.err.print(f"Exclude pattens: {exclude_patterns}")
+
+        remove_git_clean_candidates(
+            git_clean_dry_run_output=results.stdout,
+            exclude_patterns=exclude_patterns,
+            dry_run=ctx.dry_run,
+        )
+
+    @command(help="Clean all gitignored files")
+    def clean_all(self, ctx: Context) -> None:
+        ctx.run("git clean -fdX")
+
+    @command(help="Setup development environment")
+    def setup_dev(self, ctx: Context) -> None:
+        _ = ctx
+        console.error("No implementation")
+        raise typer.Exit(1)

bakelib/space/python.py

@@ -0,0 +1,42 @@
+from bake import Context
+
+from .base import BaseSpace
+
+
+class PythonSpace(BaseSpace):
+    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",
+            ]
+        )
+        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", "."])
+
+    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 setup_dev(self, ctx: Context) -> None:
+        super().clean(ctx=ctx)
+        ctx.run("uv sync --all-extras --all-groups --frozen")

bakelib/space/utils.py

@@ -0,0 +1,55 @@
+import shutil
+from pathlib import Path
+
+import pathspec
+from pathspec.patterns.gitignore.basic import GitIgnoreBasicPattern
+
+from bake.ui import console
+
+
+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}")
+
+
+def _remove_msg(path: Path, dry_run: bool) -> None:
+    verb = "Would remove" if dry_run else "Removing"
+    console.echo(f"[red]-[/red] [dim]{verb}[/dim] {path}")
+
+
+def _should_remove_path(path: Path, dry_run: bool) -> None:
+    _remove_msg(path, dry_run)
+    if dry_run:
+        return
+
+    if path.is_dir():
+        shutil.rmtree(path)
+    else:
+        path.unlink(missing_ok=True)
+
+
+def remove_git_clean_candidates(
+    git_clean_dry_run_output: str, exclude_patterns: set[str], dry_run: bool
+) -> None:
+    spec = pathspec.PathSpec.from_lines(
+        GitIgnoreBasicPattern,
+        exclude_patterns,
+    )
+
+    for line in git_clean_dry_run_output.splitlines():
+        line = line.strip()
+        if not line.startswith("Would remove "):
+            continue
+
+        rel_path = line.removeprefix("Would remove ").strip()
+        path = Path(rel_path)
+
+        if spec.match_file(rel_path):
+            _skip_msg(path, "", dry_run)
+            continue
+
+        if path.is_dir() and (path / ".git").exists():
+            _skip_msg(path, "git repository ", dry_run)
+            continue
+
+        _should_remove_path(path, dry_run)