rhiza 0.10.0__tar.gz → 0.10.1__tar.gz

rhiza-0.10.1/.rhiza/.rhiza-version

@@ -0,0 +1 @@
+0.10.0

{rhiza-0.10.0 → rhiza-0.10.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rhiza
-Version: 0.10.0
+Version: 0.10.1
 Summary: Reusable configuration templates for modern Python projects
 Project-URL: Homepage, https://github.com/jebel-quant/rhiza-cli
 Project-URL: Repository, https://github.com/jebel-quant/rhiza-cli

{rhiza-0.10.0 → rhiza-0.10.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "rhiza"
-version = "0.10.0"
+version = "0.10.1"
 description = "Reusable configuration templates for modern Python projects"
 readme = "README.md"
 requires-python = ">=3.11"

{rhiza-0.10.0 → rhiza-0.10.1}/src/rhiza/bundle_resolver.py

@@ -1,7 +1,7 @@
 """Bundle resolution logic for template configuration.
 
 This module provides functions to load and resolve bundle configurations
-from the template repository's bundles.yml file.
+from the template repository's template_bundles.yml file.
 """
 
 from pathlib import Path
@@ -10,19 +10,19 @@ from rhiza.models import RhizaBundles, RhizaTemplate
 
 
 def load_bundles_from_clone(tmp_dir: Path) -> RhizaBundles | None:
-    """Load .rhiza/bundles.yml from cloned template repo.
+    """Load .rhiza/template_bundles.yml from cloned template repo.
 
     Args:
         tmp_dir: Path to the cloned template repository.
 
     Returns:
-        RhizaBundles if bundles.yml exists, None otherwise.
+        RhizaBundles if template_bundles.yml exists, None otherwise.
 
     Raises:
-        yaml.YAMLError: If bundles.yml is malformed.
-        ValueError: If bundles.yml is invalid.
+        yaml.YAMLError: If template_bundles.yml is malformed.
+        ValueError: If template_bundles.yml is invalid.
     """
-    bundles_file = tmp_dir / ".rhiza" / "bundles.yml"
+    bundles_file = tmp_dir / ".rhiza" / "template_bundles.yml"
     if not bundles_file.exists():
         return None
     return RhizaBundles.from_yaml(bundles_file)
@@ -54,7 +54,7 @@ def resolve_include_paths(
     # Resolve templates to paths if specified
     if template.templates:
         if not bundles_config:
-            msg = "Template uses templates but bundles.yml not found in template repository"
+            msg = "Template uses templates but template_bundles.yml not found in template repository"
             raise ValueError(msg)
         paths.extend(bundles_config.resolve_to_paths(template.templates))
 

{rhiza-0.10.0 → rhiza-0.10.1}/src/rhiza/commands/materialize.py

@@ -121,7 +121,7 @@ def _validate_and_load_template(target: Path, branch: str) -> tuple[RhizaTemplat
     excluded_paths = template.exclude
 
     # Note: We'll resolve templates to paths after cloning the template repo,
-    # since we need access to bundles.yml from the template
+    # since we need access to template_bundles.yml from the template
     include_paths = template.include
 
     # Validate that we have either templates or include paths
@@ -545,11 +545,11 @@ def materialize(target: Path, branch: str, target_branch: str | None, force: boo
     logger.debug(f"Temporary directory: {tmp_dir}")
 
     try:
-        # Clone with initial minimal checkout to load bundles.yml if needed
+        # Clone with initial minimal checkout to load template_bundles.yml if needed
         initial_paths = [".rhiza"] if template.templates else include_paths
         _clone_template_repository(tmp_dir, git_url, rhiza_branch, initial_paths, git_executable, git_env)
 
-        # Load bundles.yml and resolve templates to paths if using template mode
+        # Load template_bundles.yml and resolve templates to paths if using template mode
         if template.templates:
             logger.info("Resolving templates to file paths...")
             try:

{rhiza-0.10.0 → rhiza-0.10.1}/src/rhiza/models.py

@@ -64,7 +64,7 @@ def _normalize_to_list(value: str | list[str] | None) -> list[str]:
 
 @dataclass
 class BundleDefinition:
-    """Represents a single bundle from bundles.yml.
+    """Represents a single bundle from template_bundles.yml.
 
     Attributes:
         name: The bundle identifier (e.g., "core", "tests", "github").
@@ -87,7 +87,7 @@ class BundleDefinition:
 
 @dataclass
 class RhizaBundles:
-    """Represents the structure of bundles.yml.
+    """Represents the structure of template_bundles.yml.
 
     Attributes:
         version: Version string of the bundles configuration format.
@@ -102,7 +102,7 @@ class RhizaBundles:
         """Load RhizaBundles from a YAML file.
 
         Args:
-            file_path: Path to the bundles.yml file.
+            file_path: Path to the template_bundles.yml file.
 
         Returns:
             The loaded bundles configuration.
@@ -163,7 +163,7 @@ class RhizaBundles:
         # Validate all bundles exist
         for name in bundle_names:
             if name not in self.bundles:
-                raise ValueError(f"Bundle '{name}' not found in bundles.yml")  # noqa: TRY003
+                raise ValueError(f"Bundle '{name}' not found in template_bundles.yml")  # noqa: TRY003
 
         resolved: list[str] = []
         visiting: set[str] = set()

{rhiza-0.10.0 → rhiza-0.10.1}/tests/test_bundle_resolver.py

@@ -170,8 +170,8 @@ class TestRhizaBundles:
         assert result.index("tests1.txt") < result.index("docs1.txt")
 
     def test_from_yaml_valid(self, tmp_path):
-        """Test loading valid bundles.yml."""
-        bundles_file = tmp_path / "bundles.yml"
+        """Test loading valid template_bundles.yml."""
+        bundles_file = tmp_path / "template_bundles.yml"
         bundles_file.write_text("""
 version: "1.0"
 bundles:
@@ -200,24 +200,24 @@ bundles:
         assert result.bundles["tests"].depends_on == ["core"]
 
     def test_from_yaml_empty(self, tmp_path):
-        """Test loading empty bundles.yml."""
-        bundles_file = tmp_path / "bundles.yml"
+        """Test loading empty template_bundles.yml."""
+        bundles_file = tmp_path / "template_bundles.yml"
         bundles_file.write_text("")
 
         with pytest.raises(ValueError, match="Bundles file is empty"):
             RhizaBundles.from_yaml(bundles_file)
 
     def test_from_yaml_missing_version(self, tmp_path):
-        """Test loading bundles.yml without version."""
-        bundles_file = tmp_path / "bundles.yml"
+        """Test loading template_bundles.yml without version."""
+        bundles_file = tmp_path / "template_bundles.yml"
         bundles_file.write_text("bundles: {}")
 
         with pytest.raises(ValueError, match="missing required field: version"):
             RhizaBundles.from_yaml(bundles_file)
 
     def test_from_yaml_invalid_bundles_type(self, tmp_path):
-        """Test loading bundles.yml with invalid bundles type."""
-        bundles_file = tmp_path / "bundles.yml"
+        """Test loading template_bundles.yml with invalid bundles type."""
+        bundles_file = tmp_path / "template_bundles.yml"
         bundles_file.write_text("version: '1.0'\nbundles: 'invalid'")
 
         with pytest.raises(TypeError, match="Bundles must be a dictionary"):
@@ -322,7 +322,7 @@ class TestResolveIncludePaths:
             templates=["core"],
         )
 
-        with pytest.raises(ValueError, match=r"Template uses templates but bundles\.yml not found"):
+        with pytest.raises(ValueError, match=r"Template uses templates but template_bundles\.yml not found"):
             resolve_include_paths(template, None)
 
     def test_no_configuration(self) -> None:
@@ -339,10 +339,10 @@ class TestLoadBundlesFromClone:
     """Test load_bundles_from_clone function."""
 
     def test_load_existing_bundles(self, tmp_path):
-        """Test loading bundles.yml from cloned repo."""
+        """Test loading template_bundles.yml from cloned repo."""
         rhiza_dir = tmp_path / ".rhiza"
         rhiza_dir.mkdir()
-        bundles_file = rhiza_dir / "bundles.yml"
+        bundles_file = rhiza_dir / "template_bundles.yml"
         bundles_file.write_text("""
 version: "1.0"
 bundles:
@@ -359,6 +359,6 @@ bundles:
         assert "core" in result.bundles
 
     def test_load_missing_bundles(self, tmp_path):
-        """Test that missing bundles.yml returns None."""
+        """Test that missing template_bundles.yml returns None."""
         result = load_bundles_from_clone(tmp_path)
         assert result is None

{rhiza-0.10.0 → rhiza-0.10.1}/tests/test_commands/test_materialize_bundles.py

@@ -7,7 +7,7 @@ from rhiza.models import RhizaTemplate
 
 @pytest.fixture
 def template_repo(tmp_path):
-    """Create a mock template repository with bundles.yml."""
+    """Create a mock template repository with template_bundles.yml."""
     repo = tmp_path / "template-repo"
     repo.mkdir()
 
@@ -18,10 +18,10 @@ def template_repo(tmp_path):
     subprocess.run(["git", "config", "user.email", "test@example.com"], cwd=repo, capture_output=True, check=True)
     subprocess.run(["git", "config", "user.name", "Test User"], cwd=repo, capture_output=True, check=True)
 
-    # Create bundles.yml
+    # Create template_bundles.yml
     rhiza_dir = repo / ".rhiza"
     rhiza_dir.mkdir()
-    bundles_file = rhiza_dir / "bundles.yml"
+    bundles_file = rhiza_dir / "template_bundles.yml"
     bundles_file.write_text("""
 version: "1.0"
 bundles:

{rhiza-0.10.0 → rhiza-0.10.1}/uv.lock

@@ -919,7 +919,7 @@ wheels = [
 
 [[package]]
 name = "rhiza"
-version = "0.10.0"
+version = "0.10.1"
 source = { editable = "." }
 dependencies = [
     { name = "jinja2" },

rhiza-0.10.0/.github/workflows/rhiza_benchmarks.yml

@@ -1,87 +0,0 @@
-# This file is part of the jebel-quant/rhiza repository
-# (https://github.com/jebel-quant/rhiza).
-#
-# Workflow: Performance Benchmarks
-#
-# Purpose: Run performance benchmarks and detect regressions.
-#
-# Trigger: On push to main/master branches, PRs, and manual trigger.
-#
-# Regression Detection:
-#   - Compares against previous benchmark results stored in gh-pages branch
-#   - Alerts if performance degrades by more than 150% (configurable)
-#   - PRs will show a warning comment but not fail
-#   - Main branch updates the baseline for future comparisons
-
-name: "(RHIZA) BENCHMARKS"
-
-permissions:
-  contents: write
-  pull-requests: write
-
-on:
-  push:
-    branches: [ main, master ]
-  pull_request:
-    branches: [ main, master ]
-  workflow_dispatch:
-
-jobs:
-  benchmark:
-    runs-on: ubuntu-latest
-
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v6.0.2
-        with:
-          lfs: true
-
-      - name: Install uv
-        uses: astral-sh/setup-uv@v7.2.1
-        with:
-          version: "0.9.30"
-
-      - name: Configure git auth for private packages
-        uses: ./.github/actions/configure-git-auth
-        with:
-          token: ${{ secrets.GH_PAT }}
-
-      - name: Run benchmarks
-        env:
-          UV_EXTRA_INDEX_URL: ${{ secrets.UV_EXTRA_INDEX_URL }}
-        run: |
-          make benchmark
-
-      - name: Upload benchmark results
-        uses: actions/upload-artifact@v6.0.0
-        if: always()
-        with:
-          name: benchmark-results
-          path: |
-            _benchmarks/benchmarks.json
-            _benchmarks/benchmarks.svg
-            _benchmarks/benchmarks.html
-
-      # Regression detection using github-action-benchmark
-      # Stores benchmark history in gh-pages branch under /benchmarks
-      # Alerts if performance degrades by more than 150% of baseline
-      - name: Store benchmark result and check for regression
-        uses: benchmark-action/github-action-benchmark@v1
-        # run this only if _benchmarks/benchmarks.json exists
-        if: hashFiles('_benchmarks/benchmarks.json') != ''
-        with:
-          tool: 'pytest'
-          output-file-path: _benchmarks/benchmarks.json
-          # Store benchmark data in gh-pages branch
-          gh-pages-branch: gh-pages
-          benchmark-data-dir-path: benchmarks
-          # Only update baseline on main branch push (not PRs)
-          auto-push: ${{ github.event_name == 'push' && github.ref == 'refs/heads/main' }}
-          # Alert if performance degrades by more than 150%
-          alert-threshold: '150%'
-          # Post comment on PR if regression detected
-          comment-on-alert: ${{ github.event_name == 'pull_request' }}
-          # Fail workflow if regression detected (disabled for PRs to allow investigation)
-          fail-on-alert: ${{ github.event_name == 'push' }}
-          # GitHub token for pushing to gh-pages and commenting
-          github-token: ${{ secrets.GITHUB_TOKEN }}

rhiza-0.10.0/.github/workflows/rhiza_book.yml

@@ -1,82 +0,0 @@
-# This file is part of the jebel-quant/rhiza repository
-# (https://github.com/jebel-quant/rhiza).
-#
-# Workflow: Book
-# Purpose: This workflow builds and deploys comprehensive documentation for the project.
-#          It combines API documentation, test coverage reports, test results, and
-#          interactive notebooks into a single GitHub Pages site.
-#
-# Trigger: This workflow runs on every push to the main or master branch
-#
-# Components:
-#   - 📓 Process Marimo notebooks
-#   - 📖 Generate API documentation with pdoc
-#   - 🧪 Run tests and generate coverage reports
-#   - 🚀 Deploy combined documentation to GitHub Pages
-
-name: "(RHIZA) BOOK"
-
-on:
-  push:
-    branches:
-      - main
-      - master
-
-jobs:
-  book:
-    runs-on: "ubuntu-latest"
-
-    environment:
-      name: github-pages  # 👈 this is the critical missing piece
-
-    permissions:
-      contents: read
-      pages: write            # Permission to deploy to Pages
-      id-token: write         # Permission to verify deployment origin
-
-    steps:
-      # Check out the repository code
-      - uses: actions/checkout@v6.0.2
-        with:
-          lfs: true
-
-      - name: Install uv
-        uses: astral-sh/setup-uv@v7.2.1
-        with:
-          version: "0.9.30"
-
-      - name: Configure git auth for private packages
-        uses: ./.github/actions/configure-git-auth
-        with:
-          token: ${{ secrets.GH_PAT }}
-
-      - name: "Sync the virtual environment for ${{ github.repository }}"
-        shell: bash
-        env:
-          UV_EXTRA_INDEX_URL: ${{ secrets.UV_EXTRA_INDEX_URL }}
-        run: |
-          # will just use .python-version?
-          uv sync --all-extras --all-groups --frozen
-
-      - name: "Make the book"
-        env:
-          UV_EXTRA_INDEX_URL: ${{ secrets.UV_EXTRA_INDEX_URL }}
-        run: |
-          make book
-
-      # Step 5: Package all artifacts for GitHub Pages deployment
-      # This prepares the combined outputs for deployment by creating a single artifact
-      - name: Upload static files as artifact
-        uses: actions/upload-pages-artifact@v4.0.0  # Official GitHub Pages artifact upload action
-        with:
-          path: _book/  # Path to the directory containing all artifacts to deploy
-
-      # Step 6: Deploy the packaged artifacts to GitHub Pages
-      # This step publishes the content to GitHub Pages
-      # The deployment is conditional based on whether the repository is a fork and the PUBLISH_COMPANION_BOOK variable is set
-      # If the repository is a fork, deployment is skipped to avoid unauthorised publishing
-      # If PUBLISH_COMPANION_BOOK is not set, it defaults to allowing deployment
-      - name: Deploy to GitHub Pages
-        if: ${{ !github.event.repository.fork && (vars.PUBLISH_COMPANION_BOOK == 'true' || vars.PUBLISH_COMPANION_BOOK == '') }}
-        uses: actions/deploy-pages@v4.0.5  # Official GitHub Pages deployment action
-        continue-on-error: true

rhiza-0.10.0/.github/workflows/rhiza_marimo.yml

@@ -1,108 +0,0 @@
-# This file is part of the jebel-quant/rhiza repository
-# (https://github.com/jebel-quant/rhiza).
-#
-# Workflow: Marimo Notebooks
-#
-# Purpose: This workflow discovers and executes all Marimo notebooks in the
-#          repository. It builds a dynamic matrix to run each notebook in
-#          parallel to surface errors early and keep notebooks reproducible.
-#
-# Trigger: This workflow runs on every push and on pull requests to main/master
-#          branches (including from forks)
-#
-# Components:
-#   - 🔎 Discover notebooks in book/marimo
-#   - 🧪 Run each notebook in parallel using a matrix strategy
-#   - ✅ Fail-fast disabled to report all failing notebooks
-
-name: "(RHIZA) MARIMO"
-
-permissions:
-  contents: read
-
-on:
-  push:
-    branches: [ main, master ]
-  pull_request:
-    branches: [ main, master ]
-
-jobs:
-  # Build a matrix of notebooks to test
-  list-notebooks:
-    runs-on: ubuntu-latest
-    outputs:
-      notebook-list: ${{ steps.notebooks.outputs.matrix }}
-    steps:
-      # Check out the repository code
-      - uses: actions/checkout@v6.0.2
-
-      # Find all Python files in the marimo folder and create a matrix for parallel execution
-      - name: Find notebooks and build matrix
-        id: notebooks
-        run: |
-          # Extract MARIMO_FOLDER from the project configuration (via Makefile)
-          # shellcheck disable=SC2016 # Single quotes intentional - Make syntax, not shell expansion
-          NOTEBOOK_DIR=$(make -s -f Makefile -f - <<< 'print: ; @echo $(or $(MARIMO_FOLDER),marimo)' print)
-
-          echo "Searching notebooks in: $NOTEBOOK_DIR"
-          # Check if directory exists
-          if [ ! -d "$NOTEBOOK_DIR" ]; then
-            echo "Directory $NOTEBOOK_DIR does not exist. Setting empty matrix."
-            echo "matrix=[]" >> "$GITHUB_OUTPUT"
-            exit 0
-          fi
-
-          # Find notebooks and handle empty results
-          if [ -z "$(find "$NOTEBOOK_DIR" -maxdepth 1 -name "*.py" 2>/dev/null)" ]; then
-            echo "No notebooks found in $NOTEBOOK_DIR. Setting empty matrix."
-            echo "matrix=[]" >> "$GITHUB_OUTPUT"
-          else
-            notebooks=$(find "$NOTEBOOK_DIR" -maxdepth 1 -name "*.py" -print0 | xargs -0 -n1 echo | jq -R -s -c 'split("\n")[:-1]')
-            echo "matrix=$notebooks" >> "$GITHUB_OUTPUT"
-          fi
-        shell: bash
-
-  # Create one job per notebook using the matrix strategy for parallel execution
-  test-notebooks:
-    if: needs.list-notebooks.outputs.notebook-list != '[]'
-    runs-on: ubuntu-latest
-    needs: list-notebooks
-    strategy:
-      matrix:
-        notebook: ${{ fromJson(needs.list-notebooks.outputs.notebook-list) }}
-      # Don't fail the entire workflow if one notebook fails
-      fail-fast: false
-    name: Run notebook ${{ matrix.notebook }}
-    steps:
-      # Check out the repository code
-      - uses: actions/checkout@v6.0.2
-        with:
-          lfs: true
-
-      # Install uv/uvx
-      - name: Install uv
-        uses: astral-sh/setup-uv@v7.2.1
-        with:
-          version: "0.9.30"
-
-      - name: Configure git auth for private packages
-        uses: ./.github/actions/configure-git-auth
-        with:
-          token: ${{ secrets.GH_PAT }}
-
-      # Execute the notebook with the appropriate runner based on its content
-      - name: Run notebook
-        env:
-          UV_EXTRA_INDEX_URL: ${{ secrets.UV_EXTRA_INDEX_URL }}
-        run: |
-          uvx uv run "${{ matrix.notebook }}"
-          # uvx → creates a fresh ephemeral environment
-          # uv run → runs the notebook as a script in that ephemeral env
-          # No project packages are pre-installed
-          # ✅ This forces the notebook to explicitly handle dependencies (e.g., uv install ., or pip install inside the script).
-          # ✅ It’s a true integration smoke test.
-          # Benefits of this pattern
-          # Confirms the notebook can bootstrap itself in a fresh environment
-          # Catches missing uv install or pip steps early
-          # Ensures CI/other users can run the notebook without manual setup
-        shell: bash

rhiza-0.10.0/.rhiza/.rhiza-version

@@ -1 +0,0 @@
-0.9.0

rhiza-0.10.0/.rhiza/make.d/02-book.mk

@@ -1,108 +0,0 @@
-## book.mk - Book-building targets
-# This file is included by the main Makefile.
-# It provides targets for exporting Marimo notebooks to HTML (marimushka)
-# and compiling a companion book (minibook).
-
-# Declare phony targets (they don't produce files)
-.PHONY: marimushka book
-
-# Define a default no-op marimushka target that will be used
-# when book/marimo/marimo.mk doesn't exist or doesn't define marimushka
-marimushka:: install-uv
-	@if [ ! -d "book/marimo" ]; then \
-	  printf "${BLUE}[INFO] No Marimo directory found, creating placeholder${RESET}\n"; \
-	  mkdir -p "${MARIMUSHKA_OUTPUT}"; \
-	  printf '%s\n' '<html><head><title>Marimo Notebooks</title></head>' \
-	    '<body><h1>Marimo Notebooks</h1><p>No notebooks found.</p></body></html>' \
-	    > "${MARIMUSHKA_OUTPUT}/index.html"; \
-	fi
-
-# Default output directory for Marimushka (HTML exports of notebooks)
-MARIMUSHKA_OUTPUT ?= _marimushka
-
-# ----------------------------
-# Book sections (declarative)
-# ----------------------------
-# format:
-#   name | source index | book-relative index | source dir | book dir
-
-BOOK_SECTIONS := \
-  "API|_pdoc/index.html|pdoc/index.html|_pdoc|pdoc" \
-  "Coverage|_tests/html-coverage/index.html|tests/html-coverage/index.html|_tests/html-coverage|tests/html-coverage" \
-  "Test Report|_tests/html-report/report.html|tests/html-report/report.html|_tests/html-report|tests/html-report" \
-  "Notebooks|_marimushka/index.html|marimushka/index.html|_marimushka|marimushka"
-
-##@ Book
-
-# The 'book' target assembles the final documentation book.
-# 1. Aggregates API docs, coverage, test reports, and notebooks into _book.
-# 2. Generates links.json to define the book structure.
-# 3. Uses 'minibook' to compile the final HTML site.
-book:: test docs marimushka ## compile the companion book
-	@printf "${BLUE}[INFO] Building combined documentation...${RESET}\n"
-	@rm -rf _book && mkdir -p _book
-
-	@if [ -f "_tests/coverage.json" ]; then \
-	  printf "${BLUE}[INFO] Generating coverage badge JSON...${RESET}\n"; \
-	  mkdir -p _book/tests; \
-	  ${UV_BIN} run python -c "\
-import json; \
-data = json.load(open('_tests/coverage.json')); \
-pct = int(data['totals']['percent_covered']); \
-color = 'brightgreen' if pct >= 90 else 'green' if pct >= 80 else 'yellow' if pct >= 70 else 'orange' if pct >= 60 else 'red'; \
-badge = {'schemaVersion': 1, 'label': 'coverage', 'message': f'{pct}%', 'color': color}; \
-json.dump(badge, open('_book/tests/coverage-badge.json', 'w'))"; \
-	  printf "${BLUE}[INFO] Coverage badge JSON:${RESET}\n"; \
-	  cat _book/tests/coverage-badge.json; \
-	  printf "\n"; \
-	else \
-	  printf "${YELLOW}[WARN] No coverage.json found, skipping badge generation${RESET}\n"; \
-	fi
-
-	@printf "{\n" > _book/links.json
-	@first=1; \
-	for entry in $(BOOK_SECTIONS); do \
-	  name=$${entry%%|*}; \
-	  rest=$${entry#*|}; \
-	  src_index=$${rest%%|*}; rest=$${rest#*|}; \
-	  book_index=$${rest%%|*}; rest=$${rest#*|}; \
-	  src_dir=$${rest%%|*}; book_dir=$${rest#*|}; \
-	  if [ -f "$$src_index" ]; then \
-	    printf "${BLUE}[INFO] Adding $$name...${RESET}\n"; \
-	    mkdir -p "_book/$$book_dir"; \
-	    cp -r "$$src_dir/"* "_book/$$book_dir"; \
-	    if [ $$first -eq 0 ]; then \
-	      printf ",\n" >> _book/links.json; \
-	    fi; \
-	    printf "  \"%s\": \"./%s\"" "$$name" "$$book_index" >> _book/links.json; \
-	    first=0; \
-	  else \
-	    printf "${YELLOW}[WARN] Missing $$name, skipping${RESET}\n"; \
-	  fi; \
-	done; \
-	printf "\n}\n" >> _book/links.json
-
-	@printf "${BLUE}[INFO] Generated links.json:${RESET}\n"
-	@cat _book/links.json
-
-	@TEMPLATE_ARG=""; \
-	if [ -f "$(BOOK_TEMPLATE)" ]; then \
-	  TEMPLATE_ARG="--template $(BOOK_TEMPLATE)"; \
-	  printf "${BLUE}[INFO] Using book template $(BOOK_TEMPLATE)${RESET}\n"; \
-	fi; \
-	if [ -n "$(LOGO_FILE)" ]; then \
-	  if [ -f "$(LOGO_FILE)" ]; then \
-	    cp "$(LOGO_FILE)" "_book/logo$$(echo $(LOGO_FILE) | sed 's/.*\./\./')"; \
-	    printf "${BLUE}[INFO] Copying logo: $(LOGO_FILE)${RESET}\n"; \
-	  else \
-	    printf "${YELLOW}[WARN] Logo file $(LOGO_FILE) not found, skipping${RESET}\n"; \
-	  fi; \
-	fi; \
-	"$(UVX_BIN)" minibook \
-	  --title "$(BOOK_TITLE)" \
-	  --subtitle "$(BOOK_SUBTITLE)" \
-	  $$TEMPLATE_ARG \
-	  --links "$$(python3 -c 'import json;print(json.dumps(json.load(open("_book/links.json"))))')" \
-	  --output "_book"
-
-	@touch "_book/.nojekyll"