boilersync 1.2.16__tar.gz → 1.2.18__tar.gz

{boilersync-1.2.16 → boilersync-1.2.18}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: boilersync
-Version: 1.2.16
+Version: 1.2.18
 Summary: BoilerSync
 Project-URL: Repository, https://github.com/gabemontague/boilersync
 Project-URL: Issues, https://github.com/gabemontague/boilersync/issues
@@ -10,9 +10,8 @@ Classifier: Environment :: Console
 Classifier: Intended Audience :: Developers
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Topic :: Software Development :: Version Control :: Git
-Requires-Python: >=3.9
+Requires-Python: >=3.10
 Requires-Dist: click>=8.2.0
 Requires-Dist: gitpython>=3.1.44
 Requires-Dist: jinja2>=3.1.6
@@ -56,7 +55,13 @@ boilersync init your-org/your-templates#python/service-template --non-interactiv
 # 3) Pull template updates into the current project when needed
 boilersync pull
 
-# 4) Push committed project changes back into the template source
+# 4) Check project divergence from the current template
+boilersync diff
+
+# 5) Create a reviewable pull proposal without mutating the project
+boilersync pull-proposal create
+
+# 6) Push committed project changes back into the template source
 boilersync push
 ```
 
@@ -65,7 +70,11 @@ boilersync push
 - `boilersync init TEMPLATE_REF`: create a project from a template (empty target directory).
 - `boilersync init TEMPLATE_REF --non-interactive`: create a project without prompts when defaults and automatic values cover all inputs.
 - `boilersync check-pull`: compare the project's recorded template repo commit against the current cached template repo HEAD.
+- `boilersync diff`: render the upstream template with the project's saved variables and show how the current project has diverged.
 - `boilersync pull [TEMPLATE_REF]`: apply template updates to an existing project.
+- `boilersync pull-proposal create`: create a temp git repo containing proposed pull changes for review.
+- `boilersync pull-proposal apply-file PROPOSAL_DIR PATH`: copy one proposed file into the current project.
+- `boilersync pull-proposal apply-patch PATCH`: apply selected hunks from a saved patch.
 - `boilersync push`: review and copy committed project changes back to the template.
 - `boilersync templates init`: clone a template source repository into the local cache.
 
@@ -75,7 +84,9 @@ Use command help for full flags:
 boilersync --help
 boilersync init --help
 boilersync check-pull --help
+boilersync diff --help
 boilersync pull --help
+boilersync pull-proposal --help
 boilersync push --help
 boilersync templates --help
 ```

{boilersync-1.2.16 → boilersync-1.2.18}/README.md

@@ -30,7 +30,13 @@ boilersync init your-org/your-templates#python/service-template --non-interactiv
 # 3) Pull template updates into the current project when needed
 boilersync pull
 
-# 4) Push committed project changes back into the template source
+# 4) Check project divergence from the current template
+boilersync diff
+
+# 5) Create a reviewable pull proposal without mutating the project
+boilersync pull-proposal create
+
+# 6) Push committed project changes back into the template source
 boilersync push
 ```
 
@@ -39,7 +45,11 @@ boilersync push
 - `boilersync init TEMPLATE_REF`: create a project from a template (empty target directory).
 - `boilersync init TEMPLATE_REF --non-interactive`: create a project without prompts when defaults and automatic values cover all inputs.
 - `boilersync check-pull`: compare the project's recorded template repo commit against the current cached template repo HEAD.
+- `boilersync diff`: render the upstream template with the project's saved variables and show how the current project has diverged.
 - `boilersync pull [TEMPLATE_REF]`: apply template updates to an existing project.
+- `boilersync pull-proposal create`: create a temp git repo containing proposed pull changes for review.
+- `boilersync pull-proposal apply-file PROPOSAL_DIR PATH`: copy one proposed file into the current project.
+- `boilersync pull-proposal apply-patch PATCH`: apply selected hunks from a saved patch.
 - `boilersync push`: review and copy committed project changes back to the template.
 - `boilersync templates init`: clone a template source repository into the local cache.
 
@@ -49,7 +59,9 @@ Use command help for full flags:
 boilersync --help
 boilersync init --help
 boilersync check-pull --help
+boilersync diff --help
 boilersync pull --help
+boilersync pull-proposal --help
 boilersync push --help
 boilersync templates --help
 ```

{boilersync-1.2.16 → boilersync-1.2.18}/boilersync/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '1.2.16'
-__version_tuple__ = version_tuple = (1, 2, 16)
+__version__ = version = '1.2.18'
+__version_tuple__ = version_tuple = (1, 2, 18)
 
 __commit_id__ = commit_id = None

{boilersync-1.2.16 → boilersync-1.2.18}/boilersync/cli.py

@@ -3,8 +3,10 @@ import click
 from boilersync._version import __version__
 from boilersync.cli_helpers import common_command_wrapper
 from boilersync.commands.check_pull import check_pull_cmd
+from boilersync.commands.diff import diff_cmd
 from boilersync.commands.init import init_cmd
 from boilersync.commands.pull import pull_cmd
+from boilersync.commands.pull_proposal import pull_proposal_cmd
 from boilersync.commands.push import push_cmd
 from boilersync.commands.templates import templates_cmd
 
@@ -33,7 +35,9 @@ def main():
 # Register commands
 main.add_command(common_command_wrapper(init_cmd))
 main.add_command(common_command_wrapper(check_pull_cmd))
+main.add_command(common_command_wrapper(diff_cmd))
 main.add_command(common_command_wrapper(pull_cmd))
+main.add_command(pull_proposal_cmd)
 main.add_command(common_command_wrapper(push_cmd))
 main.add_command(templates_cmd)
 

boilersync-1.2.18/boilersync/commands/diff.py

@@ -0,0 +1,256 @@
+import json
+from dataclasses import dataclass
+from pathlib import Path
+
+import click
+
+from boilersync.comparison import (
+    build_comparison_workspace,
+    diff_entries,
+    git_diff,
+)
+from boilersync.paths import paths
+
+
+@dataclass(frozen=True)
+class ProjectDiff:
+    project_dir: Path
+    template_ref: str | None
+    comparison_dir: Path | None
+    entries: list[dict[str, object]]
+    output: str
+    error: str | None = None
+
+
+def collect_project_dirs(
+    root_dir: Path, *, include_children: bool, recursive: bool
+) -> list[Path]:
+    project_dirs = [root_dir]
+    if not include_children and not recursive:
+        return project_dirs
+
+    visited = {root_dir.resolve()}
+    queue = [root_dir]
+
+    while queue:
+        parent = queue.pop(0)
+        for child in paths.get_children_from_boilersync(parent / ".boilersync"):
+            resolved_child = child.resolve()
+            if resolved_child in visited:
+                continue
+            visited.add(resolved_child)
+            project_dirs.append(child)
+            if recursive:
+                queue.append(child)
+
+    return project_dirs
+
+
+def create_project_diff(
+    project_dir: Path,
+    *,
+    include_starter: bool,
+    mode: str,
+) -> ProjectDiff:
+    comparison = build_comparison_workspace(project_dir)
+    entries = diff_entries(comparison, include_starter=include_starter)
+    output = git_diff(comparison, include_starter=include_starter, mode=mode)
+    return ProjectDiff(
+        project_dir=project_dir,
+        template_ref=comparison.template_ref,
+        comparison_dir=comparison.comparison_dir,
+        entries=entries,
+        output=output,
+    )
+
+
+def create_child_error(project_dir: Path, error: Exception) -> ProjectDiff:
+    return ProjectDiff(
+        project_dir=project_dir,
+        template_ref=None,
+        comparison_dir=None,
+        entries=[],
+        output="",
+        error=str(error),
+    )
+
+
+def create_diffs(
+    root_dir: Path,
+    *,
+    include_starter: bool,
+    include_children: bool,
+    recursive: bool,
+    mode: str,
+) -> list[ProjectDiff]:
+    project_dirs = collect_project_dirs(
+        root_dir,
+        include_children=include_children,
+        recursive=recursive,
+    )
+    results = [
+        create_project_diff(project_dirs[0], include_starter=include_starter, mode=mode)
+    ]
+
+    for project_dir in project_dirs[1:]:
+        try:
+            results.append(
+                create_project_diff(
+                    project_dir,
+                    include_starter=include_starter,
+                    mode=mode,
+                )
+            )
+        except Exception as error:
+            results.append(create_child_error(project_dir, error))
+
+    return results
+
+
+def results_to_json(
+    results: list[ProjectDiff],
+    *,
+    include_starter: bool,
+) -> str:
+    payload = {
+        "include_starter": include_starter,
+        "projects": [
+            {
+                "project_dir": str(result.project_dir),
+                "template_ref": result.template_ref,
+                "comparison_dir": str(result.comparison_dir)
+                if result.comparison_dir
+                else None,
+                "changed_count": len(result.entries),
+                "changed_files": result.entries,
+                "error": result.error,
+            }
+            for result in results
+        ],
+    }
+    return json.dumps(payload, indent=2)
+
+
+def results_to_text(results: list[ProjectDiff]) -> str:
+    sections = []
+    for result in results:
+        header = f"Project: {result.project_dir}"
+        if result.error:
+            sections.append(f"{header}\nError: {result.error}")
+            continue
+        if not result.output.strip():
+            sections.append(f"{header}\nNo divergence from template.")
+            continue
+        sections.append(
+            "\n".join(
+                [
+                    header,
+                    f"Template: {result.template_ref}",
+                    f"Comparison directory: {result.comparison_dir}",
+                    result.output,
+                ]
+            )
+        )
+    return "\n\n".join(sections)
+
+
+def resolve_mode(stat: bool, name_status: bool, patch: bool, json_output: bool) -> str:
+    selected = [
+        option
+        for option, enabled in (
+            ("stat", stat),
+            ("name-status", name_status),
+            ("patch", patch),
+            ("json", json_output),
+        )
+        if enabled
+    ]
+    if len(selected) > 1:
+        raise click.UsageError(
+            "Choose only one of --stat, --name-status, --patch, or --json."
+        )
+    return selected[0] if selected else "stat"
+
+
+def diff(
+    *,
+    include_starter: bool = False,
+    include_children: bool = False,
+    recursive: bool = False,
+    mode: str = "stat",
+) -> str:
+    output_mode = "name-status" if mode == "json" else mode
+    results = create_diffs(
+        paths.root_dir,
+        include_starter=include_starter,
+        include_children=include_children,
+        recursive=recursive,
+        mode=output_mode,
+    )
+    if mode == "json":
+        return results_to_json(results, include_starter=include_starter)
+    return results_to_text(results)
+
+
+@click.command(name="diff")
+@click.option(
+    "--stat",
+    "stat",
+    is_flag=True,
+    help="Show a diffstat summary. This is the default text mode.",
+)
+@click.option(
+    "--name-status",
+    "name_status",
+    is_flag=True,
+    help="Show changed file names and statuses.",
+)
+@click.option("--patch", "patch", is_flag=True, help="Show the full patch.")
+@click.option("--json", "json_output", is_flag=True, help="Emit JSON summary output.")
+@click.option(
+    "--include-starter",
+    is_flag=True,
+    help="Include files derived from .starter template files.",
+)
+@click.option(
+    "--children",
+    "include_children",
+    is_flag=True,
+    help="Include direct child projects listed in .boilersync.",
+)
+@click.option(
+    "--recursive",
+    is_flag=True,
+    help="Include child projects recursively.",
+)
+@click.option(
+    "--output",
+    "output_path",
+    type=click.Path(dir_okay=False, path_type=Path),
+    help="Write output to a file instead of stdout.",
+)
+def diff_cmd(
+    stat: bool,
+    name_status: bool,
+    patch: bool,
+    json_output: bool,
+    include_starter: bool,
+    include_children: bool,
+    recursive: bool,
+    output_path: Path | None,
+) -> None:
+    """Show how the current project has diverged from its upstream template."""
+    mode = resolve_mode(stat, name_status, patch, json_output)
+    result = diff(
+        include_starter=include_starter,
+        include_children=include_children,
+        recursive=recursive,
+        mode=mode,
+    )
+
+    if output_path:
+        output_path.expanduser().write_text(result + "\n", encoding="utf-8")
+        click.echo(f"Wrote BoilerSync diff to {output_path}")
+        return
+
+    click.echo(result)

boilersync-1.2.18/boilersync/commands/pull_proposal.py

@@ -0,0 +1,233 @@
+import hashlib
+import os
+import shutil
+import subprocess
+import tempfile
+from dataclasses import dataclass
+from pathlib import Path
+
+import click
+from git import Repo
+
+from boilersync.commands.pull import pull
+from boilersync.file_ignores import copy_project_files_to_directory
+from boilersync.paths import paths
+from boilersync.project_context import resolve_project_template_context
+
+
+@dataclass(frozen=True)
+class PullProposal:
+    project_dir: Path
+    workspace_dir: Path
+    proposal_dir: Path
+    changed_files: list[dict[str, str]]
+
+
+def _is_safe_relative_path(path: Path) -> bool:
+    return not path.is_absolute() and ".." not in path.parts
+
+
+def _copy_project_to_proposal(project_dir: Path, proposal_dir: Path) -> None:
+    shutil.rmtree(proposal_dir, ignore_errors=True)
+    proposal_dir.mkdir(parents=True, exist_ok=True)
+    copy_project_files_to_directory(project_dir, proposal_dir)
+
+
+def _commit_proposal_baseline(proposal_dir: Path) -> Repo:
+    repo = Repo.init(proposal_dir)
+    with repo.config_writer() as config:
+        config.set_value("user", "name", "BoilerSync")
+        config.set_value("user", "email", "boilersync@example.invalid")
+    repo.git.add(A=True)
+    repo.index.commit("Current project before BoilerSync pull")
+    return repo
+
+
+def _changed_files(repo: Repo) -> list[dict[str, str]]:
+    output = repo.git.diff("--name-status")
+    entries: list[dict[str, str]] = []
+    for line in output.splitlines():
+        parts = line.split("\t")
+        if not parts:
+            continue
+        if len(parts) == 2:
+            entries.append({"status": parts[0], "path": parts[1]})
+        elif len(parts) >= 3:
+            entries.append({"status": parts[0], "old_path": parts[1], "path": parts[2]})
+    return entries
+
+
+def create_pull_proposal(
+    project_dir: Path | None = None,
+    *,
+    include_starter: bool = False,
+    include_children: bool = False,
+    workspace_dir: Path | None = None,
+) -> PullProposal:
+    resolved_project_dir = (project_dir or paths.root_dir).resolve()
+    path_hash = hashlib.md5(str(resolved_project_dir).encode()).hexdigest()[:8]
+    resolved_workspace_dir = (
+        workspace_dir.expanduser()
+        if workspace_dir
+        else Path(tempfile.gettempdir()) / f"boilersync-pull-{path_hash}"
+    )
+    proposal_dir = resolved_workspace_dir / "proposal"
+
+    _copy_project_to_proposal(resolved_project_dir, proposal_dir)
+    repo = _commit_proposal_baseline(proposal_dir)
+    project_context = resolve_project_template_context(proposal_dir)
+    collected_variables = dict(project_context.variables)
+    if project_context.name_snake is not None:
+        collected_variables["name_snake"] = project_context.name_snake
+    if project_context.name_pretty is not None:
+        collected_variables["name_pretty"] = project_context.name_pretty
+
+    original_cwd = Path.cwd()
+    try:
+        click.echo(f"Creating pull proposal in {proposal_dir}", err=True)
+        os.chdir(proposal_dir)
+        pull(
+            project_context.template_ref,
+            collected_variables=collected_variables,
+            allow_non_empty=True,
+            include_starter=include_starter,
+            no_input=True,
+            target_dir=proposal_dir,
+            _recursive=include_children,
+        )
+        repo.git.add("-N", A=True)
+    finally:
+        os.chdir(original_cwd)
+
+    return PullProposal(
+        project_dir=resolved_project_dir,
+        workspace_dir=resolved_workspace_dir,
+        proposal_dir=proposal_dir,
+        changed_files=_changed_files(repo),
+    )
+
+
+def proposal_to_json(proposal: PullProposal) -> str:
+    payload = {
+        "project_dir": str(proposal.project_dir),
+        "workspace_dir": str(proposal.workspace_dir),
+        "proposal_dir": str(proposal.proposal_dir),
+        "changed_count": len(proposal.changed_files),
+        "changed_files": proposal.changed_files,
+    }
+    return json.dumps(payload, indent=2)
+
+
+def proposal_to_text(proposal: PullProposal) -> str:
+    lines = [
+        f"Project: {proposal.project_dir}",
+        f"Proposal: {proposal.proposal_dir}",
+        "",
+        "Review proposed changes with:",
+        f"  git -C {proposal.proposal_dir} diff",
+        "",
+        "Apply a whole proposed file from the project root with:",
+        f"  boilersync pull-proposal apply-file {proposal.proposal_dir} PATH",
+        "",
+        "Apply selected hunks by saving a patch and running:",
+        "  boilersync pull-proposal apply-patch PATCH",
+        "",
+        f"Changed files: {len(proposal.changed_files)}",
+    ]
+    for entry in proposal.changed_files:
+        path = entry.get("path", "")
+        lines.append(f"  {entry.get('status', '')}\t{path}")
+    return "\n".join(lines)
+
+
+def apply_proposed_file(
+    proposal_dir: Path,
+    relative_path: Path,
+    *,
+    project_dir: Path | None = None,
+) -> Path:
+    if not _is_safe_relative_path(relative_path):
+        raise ValueError(
+            f"Path must be relative and stay inside the project: {relative_path}"
+        )
+
+    resolved_project_dir = (project_dir or paths.root_dir).resolve()
+    source_path = proposal_dir.expanduser() / relative_path
+    target_path = resolved_project_dir / relative_path
+
+    if not source_path.exists() or not source_path.is_file():
+        raise FileNotFoundError(f"Proposed file does not exist: {source_path}")
+
+    target_path.parent.mkdir(parents=True, exist_ok=True)
+    shutil.copy2(source_path, target_path)
+    return target_path
+
+
+def apply_patch_file(
+    patch_path: Path,
+    *,
+    project_dir: Path | None = None,
+) -> None:
+    resolved_project_dir = (project_dir or paths.root_dir).resolve()
+    subprocess.run(
+        ["git", "apply", str(patch_path.expanduser())],
+        cwd=resolved_project_dir,
+        check=True,
+    )
+
+
+@click.group(name="pull-proposal")
+def pull_proposal_cmd() -> None:
+    """Create and apply reviewable BoilerSync pull proposals."""
+
+
+@pull_proposal_cmd.command(name="create")
+@click.option(
+    "--include-starter",
+    is_flag=True,
+    help="Include starter files in the proposed pull.",
+)
+@click.option(
+    "--children",
+    "include_children",
+    is_flag=True,
+    help="Include child projects in the proposed pull.",
+)
+@click.option(
+    "--workspace-dir",
+    type=click.Path(file_okay=False, path_type=Path),
+    help="Directory for the proposal workspace. Defaults to /tmp/boilersync-pull-<hash>.",
+)
+@click.option("--json", "json_output", is_flag=True, help="Emit JSON output.")
+def create_cmd(
+    include_starter: bool,
+    include_children: bool,
+    workspace_dir: Path | None,
+    json_output: bool,
+) -> None:
+    """Create a temp git repo containing proposed pull changes."""
+    proposal = create_pull_proposal(
+        include_starter=include_starter,
+        include_children=include_children,
+        workspace_dir=workspace_dir,
+    )
+    click.echo(
+        proposal_to_json(proposal) if json_output else proposal_to_text(proposal)
+    )
+
+
+@pull_proposal_cmd.command(name="apply-file")
+@click.argument("proposal_dir", type=click.Path(file_okay=False, path_type=Path))
+@click.argument("path", type=click.Path(dir_okay=False, path_type=Path))
+def apply_file_cmd(proposal_dir: Path, path: Path) -> None:
+    """Copy one file from a proposal into the current project."""
+    target_path = apply_proposed_file(proposal_dir, path)
+    click.echo(f"Applied proposed file: {target_path}")
+
+
+@pull_proposal_cmd.command(name="apply-patch")
+@click.argument("patch_path", type=click.Path(dir_okay=False, path_type=Path))
+def apply_patch_cmd(patch_path: Path) -> None:
+    """Apply a selected patch to the current project with git apply."""
+    apply_patch_file(patch_path)
+    click.echo(f"Applied patch: {patch_path}")