rebake 0.0.1__tar.gz

rebake-0.0.1/.github/workflows/release.yml

@@ -0,0 +1,35 @@
+name: Release
+
+on:
+  push:
+    tags:
+      - '*'
+
+jobs:
+  deploy:
+    runs-on: ubuntu-latest
+    permissions:
+      id-token: write
+    environment:
+      name: pypi
+      url: https://pypi.org/p/rebake
+
+    steps:
+    - uses: actions/checkout@v4
+      with:
+        fetch-depth: 0
+    - name: Set up the latest version of uv
+      uses: astral-sh/setup-uv@v7
+      with:
+        enable-cache: true
+    - name: Build
+      run: uv build
+
+    - name: upload dists
+      uses: actions/upload-artifact@v4
+      with:
+        name: release-dists
+        path: dist/
+
+    - name: Publish package distributions to PyPI
+      uses: pypa/gh-action-pypi-publish@release/v1

rebake-0.0.1/.github/workflows/test.yml

@@ -0,0 +1,78 @@
+name: Tests
+
+on:
+  push:
+    branches: [ main ]
+  pull_request:
+    branches: [ main ]
+
+jobs:
+  test:
+    name: Test Python ${{ matrix.python-version }}
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ["3.12", "3.13"]
+
+    steps:
+    - uses: actions/checkout@v4
+
+    - name: Set up Python ${{ matrix.python-version }}
+      uses: actions/setup-python@v5
+      with:
+        python-version: ${{ matrix.python-version }}
+
+    - name: Install uv
+      uses: astral-sh/setup-uv@v5
+
+    - name: Install dependencies
+      run: uv sync --all-extras
+
+    - name: Run tests
+      run: uv run pytest
+
+  lint:
+    name: Lint
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v4
+
+    - name: Set up Python
+      uses: actions/setup-python@v5
+      with:
+        python-version: "3.13"
+
+    - name: Install uv
+      uses: astral-sh/setup-uv@v5
+
+    - name: Install dependencies
+      run: uv sync --all-extras
+
+    - name: Run ruff check
+      run: uv run ruff check
+
+    - name: Run ruff format check
+      run: uv run ruff format --check
+
+  type-check:
+    name: Type Check
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v4
+
+    - name: Set up Python
+      uses: actions/setup-python@v5
+      with:
+        python-version: "3.13"
+
+    - name: Install uv
+      uses: astral-sh/setup-uv@v5
+
+    - name: Install dependencies
+      run: uv sync --all-extras
+
+    - name: Run type check
+      run: uv run pyrefly check

rebake-0.0.1/.gitignore

@@ -0,0 +1 @@
+__pycache__/

rebake-0.0.1/.python-version

@@ -0,0 +1 @@
+3.12

rebake-0.0.1/PKG-INFO

@@ -0,0 +1,108 @@
+Metadata-Version: 2.4
+Name: rebake
+Version: 0.0.1
+Summary: A spiritual successor to cruft for managing cookiecutter projects
+Author-email: Ryo Kitagawa <kitadrum50@gmail.com>
+Requires-Python: >=3.12
+Requires-Dist: cookiecutter>=2.6.0
+Requires-Dist: gitpython>=3.1.44
+Requires-Dist: rich>=13.9.4
+Requires-Dist: typer>=0.15.1
+Description-Content-Type: text/markdown
+
+# rebake
+
+A spiritual successor to [cruft](https://github.com/cruft/cruft) for managing [cookiecutter](https://github.com/cookiecutter/cookiecutter) projects.
+
+rebake improves on cruft in two key areas:
+
+1. **Better conflict UX** — uses `git apply -3` to produce inline conflict markers instead of `.rej` files
+2. **New variable detection** — prompts for variables added to the template since the project was last updated
+
+## Requirements
+
+- Python 3.12+
+- [uv](https://docs.astral.sh/uv/)
+- Git
+
+## Installation
+
+```bash
+uv tool install rebake
+```
+
+Or add it to a project:
+
+```bash
+uv add rebake
+```
+
+## Usage
+
+### `rebake check`
+
+Check whether the project is up-to-date with its template.
+
+```bash
+rebake check [PROJECT_DIR]
+```
+
+Exit codes:
+- `0` — up-to-date
+- `1` — outdated
+- `2` — error (e.g. `.cruft.json` not found)
+
+### `rebake update`
+
+Apply the latest template changes to the project.
+
+```bash
+rebake update [PROJECT_DIR]
+```
+
+rebake will:
+1. Abort if there are uncommitted changes (commit or stash first)
+2. Detect new variables added to the template and prompt for their values
+3. Generate a diff between the old and new rendered templates
+4. Apply the diff with `git apply -3` — conflicts appear as inline markers
+5. Update `.cruft.json` with the new commit hash and any newly added variables
+
+## Migrating from cruft
+
+rebake reads `.cruft.json` as-is. No migration needed — just replace `cruft` with `rebake` in your commands.
+
+```bash
+# before
+cruft check
+cruft update
+
+# after
+rebake check
+rebake update
+```
+
+## `.cruft.json` format
+
+```json
+{
+  "template": "https://github.com/owner/template",
+  "commit": "abc123...",
+  "checkout": "main",
+  "context": {
+    "cookiecutter": {
+      "project_name": "my-project",
+      "author": "Jane Doe"
+    }
+  },
+  "skip": ["go.sum", "*.lock"]
+}
+```
+
+## Development
+
+```bash
+git clone https://github.com/kitagry/rebake
+cd rebake
+uv sync
+uv run pytest
+```

rebake-0.0.1/README.md

@@ -0,0 +1,96 @@
+# rebake
+
+A spiritual successor to [cruft](https://github.com/cruft/cruft) for managing [cookiecutter](https://github.com/cookiecutter/cookiecutter) projects.
+
+rebake improves on cruft in two key areas:
+
+1. **Better conflict UX** — uses `git apply -3` to produce inline conflict markers instead of `.rej` files
+2. **New variable detection** — prompts for variables added to the template since the project was last updated
+
+## Requirements
+
+- Python 3.12+
+- [uv](https://docs.astral.sh/uv/)
+- Git
+
+## Installation
+
+```bash
+uv tool install rebake
+```
+
+Or add it to a project:
+
+```bash
+uv add rebake
+```
+
+## Usage
+
+### `rebake check`
+
+Check whether the project is up-to-date with its template.
+
+```bash
+rebake check [PROJECT_DIR]
+```
+
+Exit codes:
+- `0` — up-to-date
+- `1` — outdated
+- `2` — error (e.g. `.cruft.json` not found)
+
+### `rebake update`
+
+Apply the latest template changes to the project.
+
+```bash
+rebake update [PROJECT_DIR]
+```
+
+rebake will:
+1. Abort if there are uncommitted changes (commit or stash first)
+2. Detect new variables added to the template and prompt for their values
+3. Generate a diff between the old and new rendered templates
+4. Apply the diff with `git apply -3` — conflicts appear as inline markers
+5. Update `.cruft.json` with the new commit hash and any newly added variables
+
+## Migrating from cruft
+
+rebake reads `.cruft.json` as-is. No migration needed — just replace `cruft` with `rebake` in your commands.
+
+```bash
+# before
+cruft check
+cruft update
+
+# after
+rebake check
+rebake update
+```
+
+## `.cruft.json` format
+
+```json
+{
+  "template": "https://github.com/owner/template",
+  "commit": "abc123...",
+  "checkout": "main",
+  "context": {
+    "cookiecutter": {
+      "project_name": "my-project",
+      "author": "Jane Doe"
+    }
+  },
+  "skip": ["go.sum", "*.lock"]
+}
+```
+
+## Development
+
+```bash
+git clone https://github.com/kitagry/rebake
+cd rebake
+uv sync
+uv run pytest
+```

rebake-0.0.1/pyproject.toml

@@ -0,0 +1,49 @@
+[project]
+name = "rebake"
+description = "A spiritual successor to cruft for managing cookiecutter projects"
+readme = "README.md"
+authors = [
+    { name = "Ryo Kitagawa", email = "kitadrum50@gmail.com" }
+]
+requires-python = ">=3.12"
+dynamic = ["version"]
+dependencies = [
+    "cookiecutter>=2.6.0",
+    "typer>=0.15.1",
+    "gitpython>=3.1.44",
+    "rich>=13.9.4",
+]
+
+[project.scripts]
+rebake = "rebake.cli:app"
+
+[dependency-groups]
+dev = [
+    "pytest>=8.3.5",
+    "pytest-mock>=3.14.0",
+    "ruff>=0.9.0",
+    "pyrefly>=0.17.0",
+]
+
+[tool.pytest.ini_options]
+markers = ["e2e: end-to-end tests using real git and cookiecutter"]
+
+[tool.ruff]
+target-version = "py312"
+line-length = 120
+
+[tool.ruff.lint]
+select = ["E", "F", "I"]
+
+[tool.hatch.version]
+source = "uv-dynamic-versioning"
+
+[tool.uv-dynamic-versioning]
+enable = true
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/rebake"]
+
+[build-system]
+requires = ["hatchling", "uv-dynamic-versioning"]
+build-backend = "hatchling.build"

rebake-0.0.1/src/rebake/check.py

@@ -0,0 +1,21 @@
+from __future__ import annotations
+
+from enum import Enum
+from pathlib import Path
+
+from rebake.config import CruftConfig
+from rebake.utils.git import get_template_head_commit
+
+
+class CheckResult(Enum):
+    UP_TO_DATE = "up-to-date"
+    OUTDATED = "outdated"
+
+
+def is_up_to_date(project_dir: Path = Path(".")) -> CheckResult:
+    """Check whether the project is up-to-date with its template."""
+    config = CruftConfig.load(project_dir)
+    head_commit = get_template_head_commit(config.template, checkout=config.checkout)
+    if config.commit == head_commit:
+        return CheckResult.UP_TO_DATE
+    return CheckResult.OUTDATED

rebake-0.0.1/src/rebake/cli.py

@@ -0,0 +1,45 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+import typer
+from rich.console import Console
+
+from rebake.check import CheckResult, is_up_to_date
+
+app = typer.Typer(help="A spiritual successor to cruft for managing cookiecutter projects.")
+console = Console()
+err_console = Console(stderr=True)
+
+
+@app.command()
+def check(
+    project_dir: Path = typer.Argument(Path("."), help="Path to the project directory"),
+) -> None:
+    """Check if the project is up-to-date with its template."""
+    try:
+        result = is_up_to_date(project_dir)
+    except FileNotFoundError as e:
+        err_console.print(f"[red]Error:[/red] {e}")
+        raise typer.Exit(code=2)
+
+    if result == CheckResult.UP_TO_DATE:
+        console.print("[green]✓[/green] Project is up-to-date.")
+        raise typer.Exit(code=0)
+    else:
+        console.print("[yellow]![/yellow] Project is outdated.")
+        raise typer.Exit(code=1)
+
+
+@app.command()
+def update(
+    project_dir: Path = typer.Argument(Path("."), help="Path to the project directory"),
+) -> None:
+    """Apply the latest template changes to the project."""
+    from rebake.update import run_update
+
+    try:
+        run_update(project_dir)
+    except Exception as e:
+        err_console.print(f"[red]Error:[/red] {e}")
+        raise typer.Exit(code=1)

rebake-0.0.1/src/rebake/config.py

@@ -0,0 +1,44 @@
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+CRUFT_FILE = ".cruft.json"
+
+
+@dataclass
+class CruftConfig:
+    template: str
+    commit: str
+    context: dict[str, Any]
+    checkout: str | None = None
+    skip: list[str] = field(default_factory=list)
+
+    @classmethod
+    def load(cls, project_dir: Path = Path(".")) -> "CruftConfig":
+        cruft_file = project_dir / CRUFT_FILE
+        if not cruft_file.exists():
+            raise FileNotFoundError(f"{CRUFT_FILE} not found in {project_dir}")
+        data = json.loads(cruft_file.read_text())
+        return cls(
+            template=data["template"],
+            commit=data["commit"],
+            context=data.get("context", {}),
+            checkout=data.get("checkout"),
+            skip=data.get("skip", []),
+        )
+
+    def save(self, project_dir: Path = Path(".")) -> None:
+        cruft_file = project_dir / CRUFT_FILE
+        data: dict[str, Any] = {
+            "template": self.template,
+            "commit": self.commit,
+            "context": self.context,
+        }
+        if self.checkout is not None:
+            data["checkout"] = self.checkout
+        if self.skip:
+            data["skip"] = self.skip
+        cruft_file.write_text(json.dumps(data, indent=2, ensure_ascii=False) + "\n")

rebake-0.0.1/src/rebake/update.py

@@ -0,0 +1,90 @@
+from __future__ import annotations
+
+import tempfile
+from pathlib import Path
+
+from rich.console import Console
+
+from rebake.config import CruftConfig
+from rebake.utils.git import (
+    apply_patch,
+    clone_at_commit,
+    generate_diff,
+    get_template_head_commit,
+    is_working_tree_clean,
+)
+from rebake.utils.template import render_template
+from rebake.utils.variables import detect_new_variables, prompt_new_variables
+
+console = Console()
+
+
+def run_update(project_dir: Path = Path(".")) -> None:
+    """Apply the latest template changes to the project.
+
+    Raises RuntimeError when the working tree has uncommitted changes.
+    """
+    # Resolve to absolute path before any subprocess/cookiecutter calls that may change CWD
+    project_dir = project_dir.resolve()
+
+    if not is_working_tree_clean(project_dir):
+        raise RuntimeError("Project has uncommitted changes. Please commit or stash them before updating.")
+
+    config = CruftConfig.load(project_dir)
+    old_commit = config.commit
+    new_commit = get_template_head_commit(config.template, checkout=config.checkout)
+
+    console.print(f"Updating from [cyan]{old_commit[:8]}[/cyan] → [cyan]{new_commit[:8]}[/cyan]")
+
+    old_context = config.context.get("cookiecutter", {})
+
+    with tempfile.TemporaryDirectory() as tmpdir:
+        tmp = Path(tmpdir)
+
+        # Clone template at old and new commits to compute the diff
+        old_template_dir = tmp / "old_template"
+        new_template_dir = tmp / "new_template"
+        clone_at_commit(config.template, old_commit, old_template_dir)
+        clone_at_commit(config.template, new_commit, new_template_dir)
+
+        # Detect variables added in the new template and prompt the user
+        new_vars = detect_new_variables(new_template_dir, old_context)
+        extra_context = {}
+        if new_vars:
+            console.print("[yellow]New template variables detected. Please provide values:[/yellow]")
+            extra_context = prompt_new_variables(new_vars)
+
+        merged_context = {**old_context, **extra_context}
+
+        # Render both template versions with the merged context
+        old_output = tmp / "old_output"
+        new_output = tmp / "new_output"
+        old_output.mkdir()
+        new_output.mkdir()
+        old_rendered = render_template(old_template_dir, merged_context, old_output)
+        new_rendered = render_template(new_template_dir, merged_context, new_output)
+
+        patch = generate_diff(old_rendered, new_rendered)
+
+    if patch:
+        success, stderr = apply_patch(patch, project_dir)
+        if not success:
+            rej_files = sorted(project_dir.rglob("*.rej"))
+            console.print("[yellow]![/yellow] Some hunks could not be applied.")
+            if rej_files:
+                console.print("Resolve conflicts and delete the following [bold].rej[/bold] files:")
+                for f in rej_files:
+                    console.print(f"  [bold]{f.relative_to(project_dir)}[/bold]")
+            if stderr:
+                console.print(stderr)
+        else:
+            console.print("[green]✓[/green] Patch applied successfully.")
+    else:
+        console.print("[green]✓[/green] No changes to apply.")
+
+    # Persist the new commit hash and any newly prompted variables.
+    # Save even on partial apply so the next run starts from the new baseline
+    # rather than re-applying the same diff.
+    config.commit = new_commit
+    config.context["cookiecutter"] = merged_context
+    config.save(project_dir)