bake 0.1.0__py3-none-any.whl

bake/__init__.py

@@ -0,0 +1 @@
+"""Bake package."""

bake/cli.py

@@ -0,0 +1,40 @@
+import sys
+
+from dotenv import load_dotenv
+
+from bake import dpkg, install
+
+load_dotenv()
+
+
+def main():
+    if len(sys.argv) < 2:
+        print("Error: No command provided")
+        print("Usage: bake <command> [args...]")
+        print("")
+        print("Available commands:")
+        print("")
+        print("  install       Initialize Bake")
+        print("  dpkg          Bake package manager")
+        print("")
+        sys.exit(1)
+
+    command = sys.argv[1]
+    command_args = sys.argv[2:]
+    original_argv = sys.argv
+    sys.argv = ["bake " + command] + command_args
+
+    try:
+        if command == "install":
+            install.main()
+        elif command == "dpkg":
+            dpkg.main()
+        else:
+            print(f"Error: Unknown command '{command}'")
+            sys.exit(1)
+    finally:
+        sys.argv = original_argv
+
+
+if __name__ == "__main__":
+    main()

bake/commands/__init__.py

@@ -0,0 +1 @@
+"""Bake command modules."""

bake/commands/dpkg/__init__.py

@@ -0,0 +1 @@
+"""Package management command modules for Bake."""

bake/commands/dpkg/bake_dpkg_command.py

@@ -0,0 +1,45 @@
+from pathlib import Path
+
+from bake.exceptions import BakePathNotConfiguredException, ErrorCopyingException
+from bake.output_style import OutputStyle
+from bake.system.copy_subprocess import CopySubprocess
+from bake.utils.bake_setup import BakeSetup
+
+
+class BakeDpkgCommand:
+    def __init__(self, output_style: OutputStyle, bake_setup: BakeSetup):
+        self.output_style = output_style
+        self.bake_setup = bake_setup
+
+    def sync_configurations(self):
+        """Synchronize default bake definitions into BAKE_PATH."""
+        try:
+            bake_path = self.bake_setup.bake_path()
+        except BakePathNotConfiguredException:
+            self.output_style.writeln("No Bake path set", "error")
+            return
+
+        built_in_tools_dir = self._built_in_tools_dir()
+        try:
+            CopySubprocess().copy(
+                str(built_in_tools_dir), bake_path + "/", ["-Rf"]
+            )
+        except ErrorCopyingException as exc:
+            self.output_style.writeln(
+                "Error copying default configuration files: " + str(exc), "error"
+            )
+            return
+
+        self.output_style.writeln(
+            "Built-in tools directory copied successfully.", "success"
+        )
+
+    def _built_in_tools_dir(self) -> Path:
+        built_in_tools_dir = Path(__file__).resolve().parents[3] / "tools" / "config"
+        if not built_in_tools_dir.exists():
+            raise MissingBuiltInToolsDirException(
+                "No built-in tools directory found at "
+                + str(built_in_tools_dir.absolute())
+            )
+
+        return built_in_tools_dir

bake/commands/init/__init__.py

@@ -0,0 +1 @@
+"""Initialization command modules for Bake."""

bake/commands/init/bake_downloader.py

@@ -0,0 +1,52 @@
+import json
+
+from bake.exceptions import (
+    BakeAlreadyExistsException,
+    ErrorReadingBakeConfigException,
+    MissingConfigurationKeysException,
+)
+from bake.output_style import OutputStyle
+from bake.system.git_subprocess import GitSubprocess
+from bake.utils.bake_setup import BakeSetup
+
+
+class BakeDownloader:
+    """Download Bake-managed repositories from config definitions."""
+
+    def __init__(self):
+        self.output = OutputStyle()
+        self.git_subprocess = GitSubprocess()
+        self.bake_setup = BakeSetup()
+
+    def list_available_bakes(self):
+        bake_list = []
+        for config_file in self.bake_setup.config_path().glob("*.json"):
+            try:
+                with open(config_file, "r") as config_stream:
+                    config = json.load(config_stream)
+                bake_list.append(config)
+            except Exception as exc:
+                raise ErrorReadingBakeConfigException(
+                    "Error reading bake configuration "
+                    + str(config_file.absolute())
+                    + ": "
+                    + str(exc)
+                ) from exc
+        return bake_list
+
+    def download_bake(self, config):
+        name = config.get("name")
+        repo_url = config.get("repo_url")
+
+        if not name or not repo_url:
+            raise MissingConfigurationKeysException(
+                "Invalid configuration: missing name or repo_url"
+            )
+
+        target_path = self.bake_setup.repositories_path() / name
+        if target_path.exists():
+            raise BakeAlreadyExistsException(
+                "Bake " + name + " already exists at " + str(target_path.absolute())
+            )
+
+        return self.git_subprocess.clone(repo_url, target_path)

bake/commands/init/bake_init_command.py

@@ -0,0 +1,217 @@
+from pathlib import Path
+
+from bake.commands.init.bake_downloader import BakeDownloader
+from bake.commands.init.bake_installer import BakeInstaller
+from bake.commands.init.bake_path import BakePath
+from bake.exceptions import (
+    BakeAlreadyExistsException,
+    BakePathNotConfiguredException,
+    ErrorCopyingException,
+    ErrorReadingBakeConfigException,
+    MissingConfigurationKeysException,
+    NoInstallableBakesException,
+)
+from bake.output_style import OutputStyle
+from bake.system.copy_subprocess import CopySubprocess
+from bake.utils.bake_setup import BakeSetup
+
+
+class BakeInitCommand:
+    def __init__(self, bake_path: BakePath):
+        self.bake_path = bake_path
+        self.output = OutputStyle()
+        self.bake_setup = BakeSetup()
+
+    def execute(self):
+        self.set_bake_path()
+        self.setup_bake_directories()
+        self.download_bakes()
+        self.install_bakes()
+
+    def set_bake_path(self):
+        self.output.writeln("Initializing Bake...", "success")
+        self.output.writeln()
+
+        try:
+            current_path = self.bake_setup.bake_path()
+        except BakePathNotConfiguredException:
+            current_path = None
+
+        if current_path:
+            self.output.writeln(f"Current Bake path: {current_path}", "info")
+        else:
+            self.output.writeln("No Bake path configured yet.", "warning")
+            self.output.writeln("Suggested paths:")
+            for idx, path in enumerate(self.bake_path.get_suggested_paths(), 1):
+                self.output.writeln(f"  {idx}. {path}", "info")
+
+        while True:
+            if current_path:
+                self.output.writeln("Press Enter to keep this path or enter a new one:")
+            else:
+                self.output.writeln("Enter the path where Bake repositories will live:")
+
+            new_path = input().strip()
+            final_path = new_path if new_path else current_path
+            if final_path:
+                break
+
+            self.output.writeln("Invalid path. Please try again.", "error")
+
+        if self.bake_path.path_exists(final_path):
+            self.output.writeln(f"Directory already exists: {final_path}", "success")
+        else:
+            success, message = self.bake_path.create_directory(final_path)
+            self.output.writeln(message, "success" if success else "error")
+            if not success:
+                return
+
+        self.bake_path.save_env_file("BAKE_PATH", final_path)
+        self.output.writeln(f"Bake path configured: {final_path}", "success")
+
+    def setup_bake_directories(self):
+        try:
+            bake_path = self.bake_setup.bake_path()
+        except BakePathNotConfiguredException:
+            self.output.writeln("Bake path not configured", "error")
+            return
+
+        self.output.writeln()
+        self.output.writeln("Setting up Bake directories...", "info")
+
+        if not self.bake_setup.config_dir_exists() or self.bake_setup.is_config_dir_empty():
+            self.bake_setup.setup_config_dir()
+            self.output.writeln("Config directory created", "success")
+
+            built_in_tools_dir = self._built_in_tools_dir()
+            try:
+                CopySubprocess().copy(
+                    str(built_in_tools_dir), bake_path + "/", ["-R"]
+                )
+            except ErrorCopyingException as exc:
+                self.output.writeln(
+                    "Error copying built-in tools: " + str(exc), "error"
+                )
+                return
+
+            self.output.writeln("Built-in tools directory copied", "success")
+
+        if not self.bake_setup.repositories_dir_exists():
+            self.bake_setup.setup_repositories_dir()
+            self.output.writeln("Repositories directory created", "success")
+
+        if not self.bake_setup.bin_dir_exists():
+            self.bake_setup.setup_bin_dir()
+            self.output.writeln("Bin directory created", "success")
+
+    def download_bakes(self):
+        try:
+            self.bake_setup.bake_path()
+        except BakePathNotConfiguredException:
+            self.output.writeln("Bake path not configured", "error")
+            return
+
+        downloader = BakeDownloader()
+        try:
+            bakes = downloader.list_available_bakes()
+            self.output.writeln()
+            self.output.writeln(f"Available bakes ({len(bakes)}):", "info")
+            for idx, config in enumerate(bakes, 1):
+                self.output.writeln(f"  {idx}. {config.get('name', 'Unknown')}", "info")
+                self.output.writeln(
+                    f"     Description: {config.get('description', 'No description')}",
+                    "info",
+                )
+                self.output.writeln(
+                    f"     Repository: {config.get('repo_url', 'No URL')}", "info"
+                )
+        except ErrorReadingBakeConfigException as exc:
+            self.output.writeln("Error listing available bakes: " + str(exc), "error")
+            return
+
+        self.output.writeln()
+        self.output.writeln("Download available bakes? (y/n):", "info")
+        if input().strip().lower() not in ["y", "yes"]:
+            return
+
+        self.output.writeln()
+        success_count = 0
+        for config in bakes:
+            name = config.get("name", "Unknown")
+            self.output.writeln(f"Processing: {name}", "info")
+            try:
+                downloader.download_bake(config)
+                success_count += 1
+            except BakeAlreadyExistsException:
+                self.output.writeln(f"{name} already exists", "info")
+            except MissingConfigurationKeysException as exc:
+                self.output.writeln(f"Error downloading {name}: {exc}", "error")
+
+        self.output.writeln()
+        self.output.writeln(
+            f"Successfully downloaded {success_count}/{len(bakes)} bakes", "success"
+        )
+
+    def install_bakes(self):
+        try:
+            self.bake_setup.bake_path()
+        except BakePathNotConfiguredException:
+            self.output.writeln("Bake path not configured", "error")
+            return
+
+        installer = BakeInstaller()
+        try:
+            installable_bakes = installer.list_installable_bakes()
+            self.output.writeln()
+            self.output.writeln(
+                f"Installable bakes ({len(installable_bakes)}):", "info"
+            )
+            for idx, bake_name in enumerate(installable_bakes, 1):
+                self.output.writeln(f"  {idx}. {bake_name}", "info")
+        except NoInstallableBakesException as exc:
+            self.output.writeln(str(exc), "error")
+            return
+
+        self.output.writeln()
+        self.output.writeln("Install available bakes? (y/n):", "info")
+        if input().strip().lower() not in ["y", "yes"]:
+            return
+
+        self.output.writeln()
+        self.output.writeln("Installing bakes...", "info")
+        results = installer.install_all_bakes()
+        success_count = 0
+        failed_count = 0
+
+        for bake_name, result in results.items():
+            if result["success"]:
+                success_count += 1
+                self.output.writeln(f"{bake_name}: installed", "success")
+            else:
+                failed_count += 1
+                self.output.writeln(f"{bake_name}: failed", "error")
+                self.output.writeln(f"  Error: {result.get('error', 'Unknown')}", "error")
+
+        self.output.writeln()
+        if failed_count == 0:
+            self.output.writeln("Bake initialization completed successfully!", "success")
+            self.output.writeln("Add this to your shell profile:", "info")
+            self.output.writeln(
+                f'  export PATH="$PATH:{self.bake_setup.bin_path()}"', "warning"
+            )
+        else:
+            self.output.writeln(
+                f"{success_count} bakes installed successfully, {failed_count} failed.",
+                "warning",
+            )
+
+    def _built_in_tools_dir(self) -> Path:
+        # First look for packaged configs (works from wheel/sdist installs).
+        built_in_tools_dir = Path(__file__).resolve().parents[3] / "tools" / "config"
+        if not built_in_tools_dir.exists():
+            raise MissingBuiltInToolsDirException(
+                "No built-in tools directory found at "
+                + str(built_in_tools_dir.absolute())
+            )
+
+        return built_in_tools_dir

bake/commands/init/bake_installer.py

@@ -0,0 +1,234 @@
+import json
+import os
+import subprocess
+
+from bake.exceptions import (
+    BakeNotFoundException,
+    ErrorCreatingSymlinkException,
+    ErrorReadingBakeConfigException,
+    NoInstallableBakesException,
+    SetupCommandFailedException,
+)
+from bake.utils.bake_setup import BakeSetup
+
+
+class BakeInstaller:
+    """Install Bake-managed repositories and expose runnable binaries."""
+
+    def __init__(self):
+        self.bake_setup = BakeSetup()
+
+    def get_installed_bakes(self):
+        if not self.bake_setup.repositories_dir_exists():
+            return []
+        return [
+            d.name
+            for d in self.bake_setup.repositories_path().iterdir()
+            if d.is_dir()
+        ]
+
+    def load_bake_config(self, bake_name):
+        config_file = self.bake_setup.config_path() / f"{bake_name}.json"
+        if not config_file.exists():
+            raise ErrorReadingBakeConfigException(
+                f"Configuration file not found: {config_file}"
+            )
+
+        try:
+            with open(config_file, "r") as config_stream:
+                return json.load(config_stream)
+        except json.JSONDecodeError as exc:
+            raise ErrorReadingBakeConfigException(
+                f"Invalid JSON in {config_file}: {exc}"
+            ) from exc
+        except Exception as exc:
+            raise ErrorReadingBakeConfigException(
+                f"Error reading {config_file}: {exc}"
+            ) from exc
+
+    def run_setup_script(self, bake_name, script_commands):
+        bake_path = self.bake_setup.repositories_path() / bake_name
+        if not bake_path.exists():
+            raise BakeNotFoundException(f"Bake {bake_name} not found at {bake_path}")
+
+        original_dir = os.getcwd()
+        os.chdir(bake_path)
+        try:
+            results = []
+            for command in script_commands:
+                if command.startswith("source"):
+                    result = subprocess.run(
+                        ["bash", "-c", command], capture_output=True, text=True
+                    )
+                else:
+                    result = subprocess.run(
+                        command.split(), capture_output=True, text=True
+                    )
+
+                output = result.stdout or result.stderr or ""
+                results.append(
+                    {"command": command, "code": result.returncode, "output": output}
+                )
+
+                if result.returncode != 0:
+                    raise SetupCommandFailedException(
+                        f"Command failed: {command}. Error: {result.stderr}"
+                    )
+
+            return results
+        except SetupCommandFailedException:
+            raise
+        except Exception as exc:
+            raise SetupCommandFailedException(
+                f"Error running setup script for {bake_name}: {exc}"
+            ) from exc
+        finally:
+            os.chdir(original_dir)
+
+    def create_binary_symlinks(self, bake_name, binaries):
+        if not binaries:
+            return []
+
+        bake_path = self.bake_setup.repositories_path() / bake_name
+        bin_path = self.bake_setup.bin_path()
+
+        if not bake_path.exists():
+            raise BakeNotFoundException(f"Bake {bake_name} not found at {bake_path}")
+        if not bin_path.exists():
+            raise ErrorCreatingSymlinkException(f"Bin directory not found at {bin_path}")
+
+        created_links = []
+        for binary_config in binaries:
+            if isinstance(binary_config, str):
+                binary_path = binary_config
+                alias = (
+                    binary_path.replace(".py", "")
+                    if binary_path.endswith(".py")
+                    else binary_path
+                )
+                chdir = False
+                executor = self._get_default_executor(binary_path)
+            elif isinstance(binary_config, dict):
+                binary_path = binary_config.get("path")
+                alias = binary_config.get("alias")
+                chdir = binary_config.get("chdir", False)
+                executor = binary_config.get(
+                    "executor", self._get_default_executor(binary_path)
+                )
+                if not binary_path:
+                    raise ErrorCreatingSymlinkException(
+                        f"Binary configuration missing 'path': {binary_config}"
+                    )
+                if not alias:
+                    alias = (
+                        binary_path.replace(".py", "")
+                        if binary_path.endswith(".py")
+                        else binary_path
+                    )
+            else:
+                raise ErrorCreatingSymlinkException(
+                    f"Invalid binary configuration format: {binary_config}"
+                )
+
+            source_path = bake_path / binary_path
+            if not source_path.exists():
+                raise ErrorCreatingSymlinkException(
+                    f"Binary {binary_path} not found in {bake_name} at {source_path}"
+                )
+
+            link_path = bin_path / alias
+            try:
+                if link_path.exists() or link_path.is_symlink():
+                    link_path.unlink()
+
+                if chdir:
+                    self._create_chdir_wrapper(bake_path, source_path, link_path, executor)
+                else:
+                    link_path.symlink_to(source_path)
+                created_links.append(alias)
+            except Exception as exc:
+                raise ErrorCreatingSymlinkException(
+                    f"Error creating symbolic link for {binary_path} as {alias}: {exc}"
+                ) from exc
+
+        return created_links
+
+    def _create_chdir_wrapper(self, bake_path, source_path, link_path, executor):
+        if executor == "uv run":
+            exec_command = f'exec uv run "{source_path}" "$@"'
+        elif executor == "source":
+            exec_command = f'. "{source_path}" "$@"'
+        elif executor == "direct":
+            exec_command = f'exec "{source_path}" "$@"'
+        else:
+            exec_command = f'exec uv run "{source_path}" "$@"'
+
+        wrapper_content = f"""#!/usr/bin/env bash
+# Wrapper script for {source_path.name}
+# Ensures execution in repository directory.
+
+cd "{bake_path}"
+{exec_command}
+"""
+        with open(link_path, "w") as wrapper:
+            wrapper.write(wrapper_content)
+        link_path.chmod(0o755)
+
+    def _get_default_executor(self, binary_path):
+        if binary_path.endswith(".py"):
+            return "uv run"
+        if binary_path.endswith(".sh"):
+            return "source"
+        return "direct"
+
+    def install_bake(self, bake_name):
+        try:
+            config = self.load_bake_config(bake_name)
+            scripts = config.get("scripts", {})
+            install_scripts = scripts.get("install", [])
+            if not install_scripts:
+                install_scripts = config.get(
+                    "installation_scripts", config.get("setup_scripts", [])
+                )
+            binaries = config.get("binaries", [])
+
+            results = {"setup": None, "symlinks": []}
+
+            if install_scripts:
+                results["setup"] = self.run_setup_script(bake_name, install_scripts)
+            elif not binaries:
+                raise SetupCommandFailedException(
+                    f"No installation scripts or binaries defined for {bake_name}"
+                )
+
+            if binaries:
+                results["symlinks"] = self.create_binary_symlinks(bake_name, binaries)
+            return results
+        except ErrorReadingBakeConfigException as exc:
+            raise SetupCommandFailedException(
+                f"Error loading configuration for {bake_name}: {exc}"
+            ) from exc
+
+    def install_all_bakes(self):
+        installed_bakes = self.get_installed_bakes()
+        if not installed_bakes:
+            raise NoInstallableBakesException("No bakes found to install")
+
+        results = {}
+        for bake_name in installed_bakes:
+            try:
+                result = self.install_bake(bake_name)
+                results[bake_name] = {"success": True, "result": result}
+            except (
+                BakeNotFoundException,
+                SetupCommandFailedException,
+                ErrorReadingBakeConfigException,
+            ) as exc:
+                results[bake_name] = {"success": False, "error": str(exc)}
+        return results
+
+    def list_installable_bakes(self):
+        installed_bakes = self.get_installed_bakes()
+        if not installed_bakes:
+            raise NoInstallableBakesException("No bakes found to install")
+        return installed_bakes

bake/commands/init/bake_path.py

@@ -0,0 +1,58 @@
+import os
+import platform
+from pathlib import Path
+
+
+class BakePath:
+    """Path helpers for Bake home directory configuration."""
+
+    def get_default_path(self):
+        return os.getenv("BAKE_PATH", "")
+
+    def get_suggested_paths(self):
+        home = Path.home()
+        common_paths = [
+            str(home / "bake"),
+            str(home / ".bake"),
+            str(home / "Documents" / "bake"),
+            str(home / "Desktop" / "bake"),
+        ]
+
+        if platform.system().lower() == "linux":
+            return common_paths + [
+                str(home / ".local" / "share" / "bake"),
+                str(home / ".config" / "bake"),
+            ]
+
+        return common_paths
+
+    def path_exists(self, path_str):
+        return Path(path_str).exists()
+
+    def create_directory(self, path_str):
+        path_obj = Path(path_str)
+        try:
+            path_obj.mkdir(parents=True, exist_ok=True)
+            return True, f"Created directory: {path_str}"
+        except PermissionError:
+            return False, f"Permission denied creating directory: {path_str}"
+        except OSError as exc:
+            return False, f"Error creating directory: {exc}"
+
+    def save_env_file(self, key, value):
+        env_file = Path(".env")
+        existing_vars = {}
+
+        if env_file.exists():
+            with open(env_file, "r") as env:
+                for line in env:
+                    line = line.strip()
+                    if line and not line.startswith("#") and "=" in line:
+                        k, v = line.split("=", 1)
+                        existing_vars[k] = v
+
+        existing_vars[key] = value
+
+        with open(env_file, "w") as env:
+            for k, v in existing_vars.items():
+                env.write(f"{k}={v}\n")

bake/dpkg.py

@@ -0,0 +1,32 @@
+import argparse
+import sys
+
+from bake.commands.dpkg.bake_dpkg_command import BakeDpkgCommand
+from bake.output_style import OutputStyle
+from bake.utils.bake_setup import BakeSetup
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Bake package manager commands",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    parser.add_argument("command", help="Command to execute")
+    args = parser.parse_args()
+
+    if args.command == "sync-config":
+        BakeDpkgCommand(OutputStyle(), BakeSetup()).sync_configurations()
+        return
+
+    print("Error: Invalid command provided")
+    print("Usage: bake dpkg <command>")
+    print("")
+    print("Available commands:")
+    print("")
+    print("  sync-config    Synchronize bake definitions")
+    print("")
+    sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

bake/exceptions.py

@@ -0,0 +1,56 @@
+class BakePathNotConfiguredException(Exception):
+    pass
+
+
+class BakeAlreadyExistsException(Exception):
+    pass
+
+
+class BakeNotFoundException(Exception):
+    pass
+
+
+class MissingConfigurationKeysException(Exception):
+    pass
+
+
+class ErrorReadingBakeConfigException(Exception):
+    pass
+
+
+class SetupCommandFailedException(Exception):
+    pass
+
+
+class NoInstallableBakesException(Exception):
+    pass
+
+
+class ErrorCreatingSymlinkException(Exception):
+    pass
+
+
+class ErrorCopyingException(Exception):
+    pass
+
+class MissingBuiltInToolsDirException(Exception):
+    pass
+
+class ErrorCreatingConfigFolderException(Exception):
+    pass
+
+
+class ErrorCreatingRepoFolderException(Exception):
+    pass
+
+
+class NoConfigurationsFolderException(Exception):
+    pass
+
+
+class MissingPackageException(Exception):
+    pass
+
+
+class ErrorCloningRepositoryException(Exception):
+    pass

bake/install.py

@@ -0,0 +1,10 @@
+from bake.commands.init.bake_init_command import BakeInitCommand
+from bake.commands.init.bake_path import BakePath
+
+
+def main():
+    BakeInitCommand(BakePath()).execute()
+
+
+if __name__ == "__main__":
+    main()

bake/output_style.py

@@ -0,0 +1,24 @@
+from rich.console import Console
+from rich.theme import Theme
+
+
+class OutputStyle:
+    """Styled terminal output for Bake."""
+
+    def __init__(self):
+        self.console = Console(
+            theme=Theme(
+                {
+                    "info": "cyan",
+                    "warning": "yellow",
+                    "error": "red bold",
+                    "success": "green",
+                }
+            )
+        )
+
+    def write(self, message: str, style: str = "") -> None:
+        self.console.print(message, end="", style=style, soft_wrap=True)
+
+    def writeln(self, message: str = "", style: str = "") -> None:
+        self.console.print(message, style=style, soft_wrap=True)

bake/system/__init__.py

@@ -0,0 +1 @@
+"""System subprocess wrappers for Bake."""

bake/system/copy_subprocess.py

@@ -0,0 +1,21 @@
+import subprocess
+
+from bake.exceptions import ErrorCopyingException
+
+
+class CopySubprocess:
+    """Copy files and directories via subprocess."""
+
+    def copy(self, source, destination, options=None):
+        if options is None:
+            options = []
+
+        command = ["cp"] + options + [source, destination]
+        result = subprocess.run(command, capture_output=True, text=True)
+
+        if result.returncode != 0:
+            raise ErrorCopyingException(
+                "Error copying default configuration files: " + str(result.stderr)
+            )
+
+        return result

bake/system/git_subprocess.py

@@ -0,0 +1,29 @@
+import subprocess
+
+from bake.exceptions import ErrorCloningRepositoryException, MissingPackageException
+
+
+class GitSubprocess:
+    def clone(self, repo_url, target_path):
+        """Clone a git repository to the target path."""
+        try:
+            version_check = subprocess.run(
+                ["git", "--version"], capture_output=True, text=True
+            )
+            if version_check.returncode != 0:
+                raise MissingPackageException("git is not installed or not available in PATH")
+
+            result = subprocess.run(
+                ["git", "clone", repo_url, str(target_path)],
+                capture_output=True,
+                text=True,
+            )
+            if result.returncode != 0:
+                raise ErrorCloningRepositoryException(
+                    f"Failed to clone {repo_url}: {result.stderr}"
+                )
+            return result.stdout
+        except Exception as exc:
+            raise ErrorCloningRepositoryException(
+                f"Failed to clone {repo_url}: {exc}"
+            ) from exc

bake/utils/__init__.py

@@ -0,0 +1 @@
+"""Utility modules for Bake."""

bake/utils/bake_setup.py

@@ -0,0 +1,82 @@
+import os
+from pathlib import Path
+
+from bake.exceptions import (
+    BakePathNotConfiguredException,
+    ErrorCreatingConfigFolderException,
+    ErrorCreatingRepoFolderException,
+    NoConfigurationsFolderException,
+)
+
+
+class BakeSetup:
+    def bake_path(self):
+        bake_path = self.__get_env_path()
+        if not bake_path:
+            raise BakePathNotConfiguredException()
+        return bake_path
+
+    def config_path(self):
+        return Path(self.bake_path()) / "config"
+
+    def repositories_path(self):
+        return Path(self.bake_path()) / "repositories"
+
+    def bin_path(self):
+        return Path(self.bake_path()) / "bin"
+
+    def config_dir_exists(self):
+        return self.config_path().exists()
+
+    def repositories_dir_exists(self):
+        return self.repositories_path().exists()
+
+    def bin_dir_exists(self):
+        return self.bin_path().exists()
+
+    def is_config_dir_empty(self):
+        if not self.config_dir_exists():
+            raise NoConfigurationsFolderException(
+                "No bake configuration path found at "
+                + str(self.config_path().absolute())
+            )
+        return not os.listdir(self.config_path())
+
+    def setup_config_dir(self):
+        try:
+            if not self.config_dir_exists():
+                self.config_path().mkdir(parents=True, exist_ok=True)
+        except Exception as exc:
+            raise ErrorCreatingConfigFolderException(
+                "Error creating configuration folder "
+                + str(self.config_path().absolute())
+                + ": "
+                + str(exc)
+            ) from exc
+
+    def setup_repositories_dir(self):
+        try:
+            if not self.repositories_dir_exists():
+                self.repositories_path().mkdir(parents=True, exist_ok=True)
+        except Exception as exc:
+            raise ErrorCreatingRepoFolderException(
+                "Error creating repositories folder "
+                + str(self.repositories_path().absolute())
+                + ": "
+                + str(exc)
+            ) from exc
+
+    def setup_bin_dir(self):
+        try:
+            if not self.bin_dir_exists():
+                self.bin_path().mkdir(parents=True, exist_ok=True)
+        except Exception as exc:
+            raise ErrorCreatingRepoFolderException(
+                "Error creating bin folder "
+                + str(self.bin_path().absolute())
+                + ": "
+                + str(exc)
+            ) from exc
+
+    def __get_env_path(self):
+        return os.getenv("BAKE_PATH", "")

bake-0.1.0.dist-info/METADATA

@@ -0,0 +1,87 @@
+Metadata-Version: 2.4
+Name: bake
+Version: 0.1.0
+Summary: Bake orchestrates internal CLI tools, setup scripts, and repeatable automation workflows.
+Keywords: automation,cli,developer-tools,scripts,workflow
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Build Tools
+Classifier: Topic :: Utilities
+Requires-Python: >=3.11
+Requires-Dist: python-dotenv>=1.1.1
+Requires-Dist: rich>=14.1.0
+Description-Content-Type: text/markdown
+
+# Bake
+
+Bake is a CLI automation orchestrator for managing internal tool repositories,
+setup scripts, and reusable command workflows.
+
+## Why Bake
+
+- Organize automation in one place instead of scattered shell scripts.
+- Bootstrap and install tool repositories from JSON definitions.
+- Expose runnable binaries in a shared `bin` directory.
+- Keep local setup repeatable across developers.
+
+## Install
+
+```bash
+uv venv
+source .venv/bin/activate
+uv pip install -e .
+```
+
+After installation, the main command is:
+
+```bash
+bake
+```
+
+## Commands
+
+### `bake install`
+
+Interactive initialization flow that:
+
+- Configures `BAKE_PATH` in `.env`.
+- Creates `config`, `repositories`, and `bin` folders.
+- Copies default configuration templates from `tools/config`.
+- Optionally downloads and installs configured repositories.
+
+### `bake dpkg sync-config`
+
+Synchronizes default configuration definitions from `tools/config` into
+`$BAKE_PATH/config`.
+
+## Configuration Model
+
+Bake uses JSON files in `tools/config`, for example:
+
+```json
+{
+  "name": "aws-cli-toolkit",
+  "repo_url": "https://github.com/darioriverat/aws-cli-toolkit",
+  "description": "A comprehensive command-line toolkit for managing AWS services",
+  "scripts": {
+    "install": [
+      "uv venv",
+      "source .venv/bin/activate",
+      "uv pip install -e ."
+    ]
+  }
+}
+```
+
+Optional `binaries` entries can create symlinks/wrappers in `$BAKE_PATH/bin`.
+
+## Notes
+
+- `BAKE_PATH` is the environment variable used by Bake.
+- `bake` is the canonical command.

bake-0.1.0.dist-info/RECORD

@@ -0,0 +1,23 @@
+bake/__init__.py,sha256=C2nrEhouHcXSnMN-0auN78UG3TiKuHO5gyWQ7KQ2HHU,20
+bake/cli.py,sha256=KPf2SC1NQRvqzWOHftS6B8h2b1XG_b87TyxGbqt_lD8,882
+bake/dpkg.py,sha256=1--Jb-SOOds1OTOx3A-TebA3P1Yr7B4N34MlfEjh334,849
+bake/exceptions.py,sha256=XC3fnWPO0RC2gj2p2uvc1Goqdg-ABfMO_lcninffRHE,873
+bake/install.py,sha256=eYjPlqi8-AYKq0qPUTMKcqYeDPf68B6IIg5kgSC3PIM,211
+bake/output_style.py,sha256=ngXYLgiBIW0bd1_2bjALt5c0xVNI2ddt4IfxamcpJHs,693
+bake/commands/__init__.py,sha256=i3puFYleYrC9wrXzAgXeRtsHaooBuMR25FKps4_k08c,28
+bake/commands/dpkg/__init__.py,sha256=K-J8KlEr6xHMMX46PoPT9xrqIUnl5hQG3fnuzVanqe0,51
+bake/commands/dpkg/bake_dpkg_command.py,sha256=QefP45ZemarzVS9dGbHwfameeth1NWeVc9GF-7KZhWo,1611
+bake/commands/init/__init__.py,sha256=5zqy0RkAbIKvllKF3zM7cAMS3izJxjz08ZxNcnbMTks,47
+bake/commands/init/bake_downloader.py,sha256=Nuqv4AjzTOYLwPjNeVU3DoKNli_Y2XJR90174pPkVHQ,1740
+bake/commands/init/bake_init_command.py,sha256=l0X96TtgLJexbKBwk5nwEzAhyWrgnRBYNPJxbhD5_2M,8368
+bake/commands/init/bake_installer.py,sha256=hk1DLR3rZEO2Mw2n4nMy63TxHazCIKbOjyF8Mfq2BKQ,8609
+bake/commands/init/bake_path.py,sha256=MdwJ5Fyl3qo8kh1TnhJqYliaYVGhF5-ajgGEhuibFyA,1760
+bake/system/__init__.py,sha256=E3Uyp47qDRFGTmUa6rV-87k2vaV5j0Fd3RqiVOm0ul0,43
+bake/system/copy_subprocess.py,sha256=QxJX92XC3bzMJSmjBtwF0fdiPJTzE9Luk5Lhv4gIb6s,585
+bake/system/git_subprocess.py,sha256=GBBF_-Qyle4-Ae2ERvdDU5KhWN8ARmkfQ1pMB_3BOho,1059
+bake/utils/__init__.py,sha256=VhOkMFl6hqC5ezszTwSdb1hKjktf6Npjezn7-aDEe8c,32
+bake/utils/bake_setup.py,sha256=96Xi77YMx_93DjbzTt_F4Kat0-MBzbsfG19YB2y0fxY,2538
+bake-0.1.0.dist-info/METADATA,sha256=JfqyQ8veefEUQJkl3wcx6ojpf6obrIbVX0G751J0pak,2306
+bake-0.1.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+bake-0.1.0.dist-info/entry_points.txt,sha256=L7IwlY_HKD-yw5GyQyBYeYdN5oium1yWGmsNiMktjRI,39
+bake-0.1.0.dist-info/RECORD,,

bake-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

bake-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+bake = bake.cli:main