commitrocket 0.1.1__py3-none-any.whl

commitrocket/security.py

@@ -0,0 +1,50 @@
+"""Small helpers that keep untrusted text from doing harm."""
+
+import os
+import re
+
+from commitrocket.errors import CommitRocketError
+
+# user:password@ inside a URL, e.g. https://name:token@host/path
+_CREDENTIALS = re.compile(r"(?i)\b([a-z][a-z0-9+.\-]*://)[^/\s@]+@")
+_CONTROL = re.compile(r"[\x00-\x1f\x7f]")
+
+
+def redact(text):
+    """Hide credentials embedded in URLs before text is logged or shown."""
+    return _CREDENTIALS.sub(r"\1***@", text)
+
+
+def redact_value(value):
+    """redact() applied to every string inside nested dicts and lists."""
+    if isinstance(value, str):
+        return redact(value)
+    if isinstance(value, dict):
+        return {key: redact_value(item) for key, item in value.items()}
+    if isinstance(value, (list, tuple)):
+        return [redact_value(item) for item in value]
+    return value
+
+
+def has_control_chars(text):
+    return bool(_CONTROL.search(text))
+
+
+def validate_ref_part(value, label):
+    """Reject remote and branch names that Git could read as options."""
+    if not value or value.startswith("-") or has_control_chars(value) or any(
+        char.isspace() for char in value
+    ):
+        raise CommitRocketError(
+            f"Invalid {label} {value!r}: it must not be empty, start with '-', "
+            "or contain spaces or control characters."
+        )
+    return value
+
+
+def restrict_permissions(path):
+    """Make a file readable and writable by its owner only (best effort)."""
+    try:
+        os.chmod(path, 0o600)
+    except OSError:
+        pass

commitrocket/template.py

@@ -0,0 +1,37 @@
+from datetime import date
+
+DEFAULT_TEMPLATE = "{message} #{n}"
+
+PLACEHOLDERS = ("message", "n", "batch", "files", "size", "first", "date")
+
+
+def render_message(template, message, n, batch, files, size_mib, first):
+    """Fill in a commit message template for one batch.
+
+    {message} the --message text, {n} the commit number, {batch} the position
+    in this run, {files} the file count, {size} the size in MiB, {first} the
+    first file's path and {date} today's date (YYYY-MM-DD).
+    """
+    return template.format(
+        message=message.rstrip(),
+        n=n,
+        batch=batch,
+        files=files,
+        size=size_mib,
+        first=first,
+        date=date.today().isoformat(),
+    ).strip()
+
+
+def validate_template(template):
+    """Return an error string if the template can't be rendered, else None."""
+    try:
+        text = render_message(template, "msg", 1, 1, 1, 1.0, "a.txt")
+    except (KeyError, IndexError, ValueError, AttributeError) as exc:
+        return (
+            f"invalid --message-template ({exc!r}); "
+            f"available placeholders: {', '.join(PLACEHOLDERS)}"
+        )
+    if not text:
+        return "--message-template renders an empty commit message"
+    return None

commitrocket/ui.py

@@ -0,0 +1,216 @@
+import time
+
+from rich.markup import escape
+from rich.panel import Panel
+from rich.progress import (
+    BarColumn,
+    Progress,
+    ProgressColumn,
+    SpinnerColumn,
+    TaskProgressColumn,
+    TextColumn,
+    TimeElapsedColumn,
+)
+from rich.table import Table
+from rich.text import Text
+
+from commitrocket.batching import MIB
+from commitrocket.eta import format_duration
+from commitrocket.git import get_file_size, get_pending_files
+
+
+class EtaColumn(ProgressColumn):
+    """Shows the run's own ETA for tasks created with an `estimator` field."""
+
+    def render(self, task):
+        estimator = task.fields.get("estimator")
+        if estimator is None:
+            return Text("")
+
+        remaining = estimator.estimate(task.completed, task.total or 0)
+        if remaining is None:
+            return Text("ETA estimating…", style="dim")
+        return Text(f"ETA {format_duration(remaining)}", style="progress.remaining")
+
+
+def make_progress(console):
+    return Progress(
+        SpinnerColumn(),
+        TextColumn("[bold cyan]{task.description}"),
+        BarColumn(),
+        TaskProgressColumn(),
+        TimeElapsedColumn(),
+        EtaColumn(),
+        console=console,
+    )
+
+
+def print_run_info(console, repo, branch, upstream, limit_mib, max_mib, number):
+    info = Table.grid(padding=(0, 2))
+    info.add_column(style="bold cyan")
+    info.add_column()
+    info.add_row("Repository", Text(str(repo)))
+    info.add_row("Branch", Text(branch))
+    info.add_row("Push target", Text(upstream))
+    info.add_row("Normal batch limit", f"{limit_mib} MiB")
+    info.add_row("Maximum file size", f"{max_mib} MiB")
+    info.add_row("Starting commit #", str(number))
+
+    console.print(Panel(info, title="Git Batch Push", border_style="cyan"))
+
+
+def print_lfs_required(console, repo, paths, threshold_mib):
+    table = Table(title=f"Files over {threshold_mib} MiB", show_lines=True)
+    table.add_column("File", overflow="fold")
+    table.add_column("Size (MiB)", justify="right")
+
+    for path in sorted(paths):
+        table.add_row(Text(path), f"{get_file_size(repo, path) / MIB:.2f}")
+
+    console.print(table)
+    console.print(
+        f"\n[bold red]These files exceed the {threshold_mib} MiB limit of most "
+        "Git hosts and the push would be rejected.[/bold red]\n"
+        "[yellow]Nothing was committed. Run again with [bold]--use-lfs[/bold] "
+        "to store them with Git LFS.[/yellow]"
+    )
+
+
+def print_resume(console, staged, entry, unpushed):
+    lines = []
+    if staged:
+        lines.append(
+            f"{len(staged)} file(s) were staged by an interrupted run and will be "
+            f"committed as: {entry['message']}"
+        )
+    if unpushed:
+        lines.append(f"{len(unpushed)} unpushed commit(s) will be pushed first:")
+        lines.extend(f"  {commit}" for commit in unpushed[:10])
+        if len(unpushed) > 10:
+            lines.append(f"  ... and {len(unpushed) - 10} more")
+
+    panel = Panel(Text("\n".join(lines)), title="Resuming", border_style="yellow")
+    console.print(panel)
+
+
+def print_dry_run(
+    console, batches, deferred, messages, lfs_files, lfs_scope, no_push=False
+):
+    table = Table(title="Dry run: planned batches", show_lines=True)
+    table.add_column("Batch", justify="right")
+    table.add_column("Commit message")
+    table.add_column("Files", justify="right")
+    table.add_column("Size (MiB)", justify="right")
+    table.add_column("Via LFS", justify="right")
+
+    total_files = 0
+    total_bytes = 0
+    for index, (paths, size) in enumerate(batches):
+        lfs_count = len(set(paths) & set(lfs_files))
+        table.add_row(
+            str(index + 1),
+            Text(messages[index]),
+            str(len(paths)),
+            f"{size / MIB:.2f}",
+            str(lfs_count) if lfs_count else "-",
+        )
+        total_files += len(paths)
+        total_bytes += size
+
+    console.print(table)
+    console.print(
+        f"{len(batches)} batch(es), {total_files} file(s), "
+        f"{total_bytes / MIB:.2f} MiB in total."
+    )
+    if lfs_scope:
+        console.print(f"[cyan]{lfs_scope}[/cyan]")
+
+    if deferred:
+        details = Table(title="Would be deferred (over --max-mib)", show_lines=True)
+        details.add_column("File", overflow="fold")
+        details.add_column("Size (MiB)", justify="right")
+        for path, size in sorted(deferred):
+            details.add_row(Text(path), f"{size / MIB:.2f}")
+        console.print(details)
+
+    if no_push:
+        console.print("[dim]--no-push: batches would be committed, not pushed.[/dim]")
+
+    console.print(
+        "\n[bold green]Dry run only: nothing was staged, committed, pushed or "
+        "changed.[/bold green]"
+    )
+
+
+def print_stuck_commits(console, commits, blobs, upstream, threshold_mib):
+    table = Table(title=f"Unpushed files over {threshold_mib} MiB", show_lines=True)
+    table.add_column("File", overflow="fold")
+    table.add_column("Size (MiB)", justify="right")
+
+    for path, size in blobs:
+        table.add_row(Text(path), f"{size / MIB:.2f}")
+
+    console.print(table)
+    console.print(f"\n[bold]{len(commits)} unpushed local commit(s):[/bold]")
+    for commit in commits:
+        console.print(Text(f"  {commit}"))
+
+    console.print(
+        f"\n[bold red]These commits already contain files over {threshold_mib} "
+        "MiB, so pushing them would be rejected.[/bold red]\n"
+        "[yellow]Nothing was changed. To drop those commits and keep your files "
+        "as untracked changes, run:[/yellow]\n\n"
+        f"  git reset --mixed {escape(upstream)}\n\n"
+        "[yellow]then run CommitRocket again (the commits stay recoverable via "
+        "'git reflog').[/yellow]"
+    )
+
+
+def print_final_summary(
+    console, repo, batch_count, started_at, max_mib, pending_files=None, pushed=True
+):
+    """Report files still deferred after all eligible batches finish."""
+    elapsed = time.monotonic() - started_at
+    pending = pending_files() if pending_files else get_pending_files(repo)
+
+    deferred = []
+    for path in pending:
+        size = get_file_size(repo, path)
+        if size > max_mib * MIB:
+            deferred.append((path, size))
+
+    table = Table(title="Execution Summary", show_lines=True)
+    table.add_column("Metric", style="cyan")
+    table.add_column("Value", justify="right")
+
+    label = "Batches pushed" if pushed else "Batches committed"
+    table.add_row(label, str(batch_count))
+    table.add_row("Elapsed time", f"{elapsed:.1f} seconds")
+    table.add_row("Deferred files", str(len(deferred)))
+
+    console.print()
+    console.print(Panel(table, border_style="green" if not deferred else "yellow"))
+
+    if not deferred:
+        console.print("[bold green]All eligible files processed.[/bold green]")
+        return 0
+
+    details = Table(title="Deferred Files — Final Report", show_lines=True)
+    details.add_column("File", overflow="fold")
+    details.add_column("Size (MiB)", justify="right")
+    details.add_column("Reason", overflow="fold")
+
+    for path, size in sorted(deferred):
+        details.add_row(
+            Text(path),
+            f"{size / MIB:.2f}",
+            f"Exceeds --max-mib ({max_mib} MiB)",
+        )
+
+    console.print(details)
+    console.print(
+        "\n[yellow]Increase --max-mib to include these files. "
+        "Deferred files were not committed by this run.[/yellow]"
+    )
+
+    return 2

commitrocket/verify.py

@@ -0,0 +1,129 @@
+import logging
+import subprocess
+import time
+from pathlib import PurePosixPath
+
+from commitrocket.errors import CommitRocketError, GitError
+from commitrocket.git import get_remote_head, run_git
+from commitrocket.lfs import LFS_EXCLUDED
+
+logger = logging.getLogger(__name__)
+
+POINTER_PREFIX = b"version https://git-lfs.github.com/spec/v1"
+MAX_POINTER_BYTES = 1024
+
+
+def verify_remote_head(repo, remote, ref, retries=0, sleep=time.sleep):
+    """Raise unless the remote's branch points at the local HEAD."""
+    local = run_git(repo, "rev-parse", "HEAD").stdout.strip()
+
+    attempt = 0
+    while True:
+        try:
+            remote_head = get_remote_head(repo, remote, ref)
+            break
+        except GitError:
+            if attempt >= retries:
+                raise
+            attempt += 1
+            sleep(2**attempt)
+
+    if remote_head != local:
+        raise CommitRocketError(
+            f"Push verification failed: {remote} {ref} is at "
+            f"{(remote_head or 'nothing')[:10]} but local HEAD is {local[:10]}."
+        )
+    logger.info("Verified %s %s is at %s", remote, ref, local[:10])
+
+
+def expected_lfs_paths(selected, lfs_paths):
+    """Files in a batch that should have been stored as LFS pointers."""
+    wanted = set(lfs_paths)
+    return [
+        path
+        for path in selected
+        if path in wanted and PurePosixPath(path).name not in LFS_EXCLUDED
+    ]
+
+
+def _git_cat_file(repo, mode, specs):
+    result = subprocess.run(
+        ["git", "-C", str(repo), "cat-file", mode],
+        input="".join(f"{spec}\n" for spec in specs).encode("utf-8"),
+        capture_output=True,
+    )
+    if result.returncode != 0:
+        error = result.stderr.decode(errors="replace")
+        raise GitError(f"git cat-file failed:\n{error}")
+    return result.stdout
+
+
+def _is_pointer(content):
+    return content.startswith(POINTER_PREFIX)
+
+
+def unpushed_has_lfs_pointers(repo, revs):
+    """True if commits not yet pushed contain LFS pointer files.
+
+    Pushing those without the LFS hooks installed would publish pointers whose
+    data was never uploaded.
+    """
+    objects = run_git(repo, "rev-list", "--objects", *revs).stdout
+    if not objects.strip():
+        return False
+
+    info = _git_cat_file(
+        repo,
+        "--batch-check=%(objecttype) %(objectname) %(objectsize) %(rest)",
+        objects.splitlines(),
+    )
+    small = []
+    for line in info.decode("utf-8", errors="replace").splitlines():
+        kind, name, size = (line.split(" ", 3) + ["", "", ""])[:3]
+        if kind == "blob" and size.isdigit() and int(size) <= MAX_POINTER_BYTES:
+            small.append(name)
+
+    if not small:
+        return False
+
+    data = _git_cat_file(repo, "--batch", small)
+    position = 0
+    for _ in small:
+        newline = data.index(b"\n", position)
+        size = int(data[position:newline].split()[2])
+        content = data[newline + 1 : newline + 1 + size]
+        position = newline + 1 + size + 1
+        if _is_pointer(content):
+            return True
+    return False
+
+
+def find_non_pointers(repo, paths):
+    """Paths whose committed content in HEAD is not an LFS pointer."""
+    if not paths:
+        return []
+
+    specs = [f"HEAD:{path}" for path in paths]
+    sizes = _git_cat_file(repo, "--batch-check=%(objectsize)", specs)
+    sizes = sizes.decode("utf-8", errors="replace").splitlines()
+
+    bad = []
+    small = []
+    for path, size in zip(paths, sizes, strict=True):
+        if size.endswith("missing") or int(size) > MAX_POINTER_BYTES:
+            bad.append(path)
+        else:
+            small.append(path)
+
+    if small:
+        data = _git_cat_file(repo, "--batch", [f"HEAD:{path}" for path in small])
+        position = 0
+        for path in small:
+            newline = data.index(b"\n", position)
+            size = int(data[position:newline].split()[2])
+            content = data[newline + 1 : newline + 1 + size]
+            position = newline + 1 + size + 1
+            if not content.startswith(POINTER_PREFIX):
+                bad.append(path)
+
+    return bad