commitrocket 0.1.1__py3-none-any.whl

commitrocket/journal.py

@@ -0,0 +1,31 @@
+import json
+from pathlib import Path
+
+from commitrocket.git import run_git
+
+
+class Journal:
+    """Remembers the batch being staged so an interrupted run can be resumed.
+
+    It lives inside .git, is written before `git add` and removed once the commit
+    exists. Staged files that match it are ours; any other staged file is not.
+    """
+
+    def __init__(self, repo):
+        relative = run_git(
+            repo, "rev-parse", "--git-path", "commitrocket-journal.json"
+        ).stdout.strip()
+        self.path = Path(repo) / relative
+
+    def read(self):
+        try:
+            return json.loads(self.path.read_text(encoding="utf-8"))
+        except (OSError, ValueError):
+            return None
+
+    def write(self, files, message, number):
+        entry = {"files": list(files), "message": message, "number": number}
+        self.path.write_text(json.dumps(entry), encoding="utf-8")
+
+    def clear(self):
+        self.path.unlink(missing_ok=True)

commitrocket/lfs.py

@@ -0,0 +1,212 @@
+import os
+import re
+import shutil
+import subprocess
+import sys
+from pathlib import Path, PurePosixPath
+
+from commitrocket.errors import CommitRocketError
+from commitrocket.git import get_file_size, run_git
+from commitrocket.security import has_control_chars
+
+# Git hosts reject pushes containing files larger than this.
+HOST_LIMIT_MIB = 100
+
+# Files above this size go through LFS by default (--lfs-threshold-mib; 0 = all).
+LFS_THRESHOLD_MIB = HOST_LIMIT_MIB
+
+# Files that must stay ordinary blobs even when every file goes through LFS.
+LFS_EXCLUDED = (".gitattributes", ".gitignore", ".lfsconfig")
+
+
+def find_lfs_candidates(repo, files, threshold_bytes, max_bytes):
+    """Files above the LFS threshold that are still within the max file size."""
+    return [
+        path
+        for path in files
+        if threshold_bytes < get_file_size(repo, path) <= max_bytes
+    ]
+
+
+def attribute_line(path):
+    """A .gitattributes-style rule that sends exactly this file through LFS."""
+    if has_control_chars(path):
+        # A newline here would let a file name add rules of its own.
+        raise CommitRocketError(
+            f"Cannot create an LFS rule for {path!r}: the file name contains "
+            "control characters. Rename the file and try again."
+        )
+    glob_escaped = re.sub(r"([*?\[\]\\])", r"\\\1", path)
+    quoted = glob_escaped.replace("\\", "\\\\").replace('"', '\\"')
+    return f'"/{quoted}" filter=lfs diff=lfs merge=lfs -text'
+
+
+def committed_rule_lines(paths):
+    """Rules for .gitattributes: one per file extension, exact path if it has none.
+
+    Extension rules also cover future files of the same type.
+    """
+    lines = set()
+    for path in paths:
+        pure = PurePosixPath(path)
+        if pure.name in LFS_EXCLUDED:
+            continue
+        suffix = pure.suffix
+        if suffix and not re.search(r"[\s*?\[\]\\\"]", suffix):
+            lines.add(f"*{suffix} filter=lfs diff=lfs merge=lfs -text")
+        else:
+            lines.add(attribute_line(path))
+    return sorted(lines)
+
+
+def all_files_rules():
+    """Rules sending every file through LFS, except the Git config files."""
+    rules = ["* filter=lfs diff=lfs merge=lfs -text"]
+    rules += [f"{name} !filter !diff !merge !text" for name in LFS_EXCLUDED]
+    return rules
+
+
+def is_lfs_available():
+    result = subprocess.run(["git", "lfs", "version"], capture_output=True)
+    return result.returncode == 0
+
+
+def install_command():
+    """Package-manager command that installs git-lfs, or None if unsupported."""
+    if sys.platform == "win32" and shutil.which("winget"):
+        return [
+            "winget",
+            "install",
+            "--id",
+            "GitHub.GitLFS",
+            "-e",
+            "--accept-source-agreements",
+            "--accept-package-agreements",
+        ]
+    if sys.platform == "darwin" and shutil.which("brew"):
+        return ["brew", "install", "git-lfs"]
+    if sys.platform.startswith("linux") and shutil.which("apt-get"):
+        command = ["apt-get", "install", "-y", "git-lfs"]
+        if os.geteuid() != 0 and shutil.which("sudo"):
+            command.insert(0, "sudo")
+        return command
+    return None
+
+
+def ensure_git_lfs(console, force):
+    """Make sure the git-lfs binary is available, installing it if needed."""
+    if is_lfs_available():
+        return
+
+    command = install_command()
+    if command is None:
+        raise CommitRocketError(
+            "git-lfs is not installed and no supported package manager was "
+            "found. Install it from https://git-lfs.com and try again."
+        )
+
+    if not force:
+        answer = (
+            console.input(
+                "[yellow]git-lfs is not installed. Run "
+                f"'{' '.join(command)}'? [y/N][/yellow] "
+            )
+            .strip()
+            .lower()
+        )
+        if answer not in {"y", "yes"}:
+            raise CommitRocketError("git-lfs is required for --use-lfs.")
+
+    console.print("[bold cyan]Installing git-lfs...[/bold cyan]")
+    if subprocess.run(command).returncode != 0:
+        raise CommitRocketError("Installing git-lfs failed.")
+
+    if not is_lfs_available():
+        raise CommitRocketError(
+            "git-lfs was installed but is not on PATH yet. "
+            "Restart your terminal and run the command again."
+        )
+
+
+class LfsSession:
+    """Route large files through LFS for one run, with nothing committed.
+
+    The rules go into .git/info/attributes, which Git honours but never
+    commits, and are taken back out by close().
+    """
+
+    def __init__(self, repo):
+        self.repo = repo
+        self.attributes_path = None
+        self.original = None
+        self.installed = False
+
+    def enable(self, paths, all_files=False):
+        """Route paths through LFS, or every file when all_files is set."""
+        info_path = run_git(
+            self.repo, "rev-parse", "--git-path", "info/attributes"
+        ).stdout.strip()
+        self.attributes_path = Path(self.repo) / info_path
+        self.original = (
+            self.attributes_path.read_bytes() if self.attributes_path.exists() else None
+        )
+
+        self.install_hooks()
+
+        lines = all_files_rules() if all_files else map(attribute_line, paths)
+        rules = "".join(f"{line}\n" for line in lines)
+        existing = (self.original or b"").decode("utf-8", errors="replace")
+        if existing and not existing.endswith("\n"):
+            existing += "\n"
+
+        self.attributes_path.parent.mkdir(parents=True, exist_ok=True)
+        self.attributes_path.write_text(existing + rules, encoding="utf-8")
+
+    def install_hooks(self):
+        """Install LFS in this repository only, so pushes upload LFS files."""
+        run_git(self.repo, "lfs", "install", "--local")
+        self.installed = True
+
+    def write_committed_rules(self, paths):
+        """Append extension rules for paths to .gitattributes, to be committed.
+
+        Returns True if the file changed.
+        """
+        dirty = run_git(
+            self.repo, "status", "--porcelain", "--", ".gitattributes"
+        ).stdout.strip()
+        if dirty:
+            raise CommitRocketError(
+                ".gitattributes has uncommitted changes. Commit or discard "
+                "them before using --lfs-commit-rules."
+            )
+
+        target = Path(self.repo) / ".gitattributes"
+        existing = target.read_text(encoding="utf-8") if target.exists() else ""
+        known = {line.strip() for line in existing.splitlines()}
+        missing = [line for line in committed_rule_lines(paths) if line not in known]
+        if not missing:
+            return False
+
+        if existing and not existing.endswith("\n"):
+            existing += "\n"
+        rules = "".join(f"{line}\n" for line in missing)
+        target.write_text(existing + rules, encoding="utf-8")
+        return True
+
+    def close(self, uninstall_hooks=True):
+        """Restore the attributes file and remove the local LFS setup.
+
+        Pass uninstall_hooks=False to keep the hooks, which unpushed commits
+        containing LFS files still need to upload their data.
+        """
+        if self.attributes_path is not None:
+            if self.original is None:
+                self.attributes_path.unlink(missing_ok=True)
+            else:
+                self.attributes_path.write_bytes(self.original)
+            self.attributes_path = None
+
+        if self.installed and uninstall_hooks:
+            run_git(self.repo, "lfs", "uninstall", "--local", check=False)
+            self.installed = False

commitrocket/logs.py

@@ -0,0 +1,67 @@
+import logging
+import os
+import sys
+from datetime import datetime
+from pathlib import Path
+
+from commitrocket.security import redact, restrict_permissions
+
+LOG_LEVELS = ("DEBUG", "INFO", "WARNING", "ERROR")
+DEFAULT_LEVEL = "INFO"
+LOGGER_NAME = "commitrocket"
+
+
+class RedactingFormatter(logging.Formatter):
+    """Hides credentials embedded in URLs, including in tracebacks."""
+
+    def format(self, record):
+        return redact(super().format(record))
+
+
+def default_log_dir():
+    """The conventional per-user log folder for the current OS."""
+    home = Path.home()
+
+    if sys.platform == "win32":
+        base = Path(os.environ.get("LOCALAPPDATA") or home / "AppData" / "Local")
+        return base / "CommitRocket" / "Logs"
+    if sys.platform == "darwin":
+        return home / "Library" / "Logs" / "CommitRocket"
+
+    state = os.environ.get("XDG_STATE_HOME")
+    return (Path(state) if state else home / ".local" / "state") / "commitrocket"
+
+
+def setup_logging(level=DEFAULT_LEVEL, log_file=None):
+    """Log to a file for this run. Returns its path, or None if it can't be opened."""
+    logger = logging.getLogger(LOGGER_NAME)
+    logger.setLevel(getattr(logging, level.upper()))
+    logger.propagate = False
+    close_logging()
+
+    if log_file:
+        path = Path(log_file).expanduser()
+    else:
+        stamp = datetime.now().strftime("%Y%m%d-%H%M%S")
+        path = default_log_dir() / f"commitrocket-{stamp}.log"
+
+    try:
+        path.parent.mkdir(parents=True, exist_ok=True)
+        handler = logging.FileHandler(path, encoding="utf-8")
+    except OSError:
+        logger.addHandler(logging.NullHandler())
+        return None
+
+    restrict_permissions(path)
+    handler.setFormatter(
+        RedactingFormatter("%(asctime)s %(levelname)-7s %(name)s: %(message)s")
+    )
+    logger.addHandler(handler)
+    return path.resolve()
+
+
+def close_logging():
+    logger = logging.getLogger(LOGGER_NAME)
+    for handler in list(logger.handlers):
+        handler.close()
+        logger.removeHandler(handler)

commitrocket/notify.py

@@ -0,0 +1,162 @@
+import json
+import logging
+import os
+import shutil
+import subprocess
+import sys
+import urllib.error
+import urllib.request
+from urllib.parse import urlparse
+
+from commitrocket.eta import format_duration
+from commitrocket.report import (
+    ABORTED,
+    CANCELLED,
+    DEFERRED,
+    FAILED,
+    INTERRUPTED,
+    SUCCESS,
+)
+from commitrocket.security import redact
+
+logger = logging.getLogger(__name__)
+
+# Windows PowerShell's own AppUserModelID, which Windows already trusts to show toasts.
+WINDOWS_APP_ID = (
+    "{1AC14E77-02E7-4E5D-B744-2EB1AE5198B7}\\WindowsPowerShell\\v1.0\\powershell.exe"
+)
+WINDOWS_SCRIPT = f"""
+[Windows.UI.Notifications.ToastNotificationManager, Windows.UI.Notifications, ContentType = WindowsRuntime] | Out-Null
+$xml = [Windows.UI.Notifications.ToastNotificationManager]::GetTemplateContent([Windows.UI.Notifications.ToastTemplateType]::ToastText02)
+$text = $xml.GetElementsByTagName('text')
+$text.Item(0).AppendChild($xml.CreateTextNode($env:CR_TITLE)) | Out-Null
+$text.Item(1).AppendChild($xml.CreateTextNode($env:CR_BODY)) | Out-Null
+$toast = [Windows.UI.Notifications.ToastNotification]::new($xml)
+[Windows.UI.Notifications.ToastNotificationManager]::CreateToastNotifier('{WINDOWS_APP_ID}').Show($toast)
+"""  # noqa: E501
+MACOS_SCRIPT = (
+    'display notification (system attribute "CR_BODY") '
+    'with title (system attribute "CR_TITLE")'
+)
+
+DESKTOP_TIMEOUT = 15
+WEBHOOK_TIMEOUT = 10
+
+HEADLINES = {
+    SUCCESS: "finished",
+    DEFERRED: "finished, some files were skipped",
+    CANCELLED: "cancelled",
+    ABORTED: "stopped before starting",
+    INTERRUPTED: "interrupted",
+    FAILED: "failed",
+}
+
+
+def build_message(report):
+    """(title, body) describing how the run ended."""
+    title = f"CommitRocket {HEADLINES.get(report.status, report.status)}"
+
+    parts = []
+    if report.batches:
+        mib = report.total_bytes / (1024 * 1024)
+        verb = "committed" if report.settings.get("no_push") else "pushed"
+        parts.append(
+            f"{len(report.batches)} batch(es) {verb}, {report.total_files} file(s), "
+            f"{mib:.1f} MiB"
+        )
+    if report.deferred:
+        parts.append(f"{len(report.deferred)} file(s) skipped for size")
+    if report.error:
+        parts.append(report.error.strip().splitlines()[0])
+    if report.target:
+        parts.append(f"to {report.target}")
+    if report.duration_seconds is not None:
+        parts.append(f"in {format_duration(report.duration_seconds)}")
+
+    return title, redact("; ".join(parts) or "No changes were made.")
+
+
+def _run_quietly(command, env):
+    result = subprocess.run(
+        command,
+        env={**os.environ, **env},
+        stdout=subprocess.DEVNULL,
+        stderr=subprocess.DEVNULL,
+        timeout=DESKTOP_TIMEOUT,
+    )
+    return result.returncode == 0
+
+
+def notify_desktop(title, body):
+    """Show a native notification. Returns the method used; 'bell' if none worked."""
+    env = {"CR_TITLE": title, "CR_BODY": body}
+    try:
+        if sys.platform == "win32" and shutil.which("powershell"):
+            command = ["powershell", "-NoProfile", "-NonInteractive", "-Command"]
+            if _run_quietly(command + [WINDOWS_SCRIPT], env):
+                return "windows-toast"
+        elif sys.platform == "darwin" and shutil.which("osascript"):
+            if _run_quietly(["osascript", "-e", MACOS_SCRIPT], env):
+                return "macos-notification"
+        elif shutil.which("notify-send"):
+            command = ["notify-send", "--app-name=CommitRocket", title, body]
+            if _run_quietly(command, env):
+                return "notify-send"
+    except (OSError, subprocess.SubprocessError) as exc:
+        logger.warning("Desktop notification failed: %s", exc)
+
+    sys.stdout.write("\a")
+    sys.stdout.flush()
+    return "bell"
+
+
+def is_valid_webhook(url):
+    parsed = urlparse(url)
+    return parsed.scheme in ("http", "https") and bool(parsed.netloc)
+
+
+def notify_webhook(url, title, body, report):
+    """POST a JSON summary. 'text' and 'content' suit Slack/Teams and Discord."""
+    payload = {
+        "text": f"{title}: {body}",
+        "content": f"{title}: {body}",
+        "title": title,
+        "message": body,
+        "status": report.status,
+        "exit_code": report.exit_code,
+        "repo": report.repo,
+        "target": redact(report.target) if report.target else None,
+        "batches": len(report.batches),
+        "files": report.total_files,
+        "size_bytes": report.total_bytes,
+        "duration_seconds": report.duration_seconds,
+    }
+    request = urllib.request.Request(
+        url,
+        data=json.dumps(payload).encode("utf-8"),
+        headers={
+            "Content-Type": "application/json",
+            "Title": title.encode("ascii", "replace").decode("ascii"),
+            "User-Agent": "commitrocket",
+        },
+        method="POST",
+    )
+    with urllib.request.urlopen(request, timeout=WEBHOOK_TIMEOUT) as response:
+        return response.status
+
+
+def send_notifications(console, report, desktop=False, webhook=None):
+    """Notify about the finished run. Failures are reported but never raised."""
+    title, body = build_message(report)
+
+    if desktop:
+        method = notify_desktop(title, body)
+        logger.info("Desktop notification sent via %s", method)
+
+    if webhook:
+        try:
+            status = notify_webhook(webhook, title, body, report)
+            logger.info("Webhook notified (HTTP %s)", status)
+        except (urllib.error.URLError, OSError, ValueError) as exc:
+            logger.warning("Webhook notification failed: %s", exc)
+            console.print(f"[yellow]Could not notify the webhook: {exc}[/yellow]")

commitrocket/options.py

@@ -0,0 +1,38 @@
+from dataclasses import dataclass, field
+
+from commitrocket.batching import DETERMINISTIC
+from commitrocket.lfs import LFS_THRESHOLD_MIB
+from commitrocket.template import DEFAULT_TEMPLATE
+
+
+@dataclass
+class RunOptions:
+    """Everything a run needs, as parsed from the command line and config file."""
+
+    repo: str = "."
+    message: str = ""
+    number: int = 1
+    force: bool = False
+    limit_mib: int = 100
+    max_mib: int = 300
+    batch_type: str = DETERMINISTIC
+    message_template: str = DEFAULT_TEMPLATE
+    remote: str | None = None
+    branch: str | None = None
+    no_push: bool = False
+    dry_run: bool = False
+    retries: int = 3
+    post_buffer_mib: int | None = None
+    compression_threads: int | None = None
+    use_lfs: bool = False
+    lfs_threshold_mib: int = LFS_THRESHOLD_MIB
+    lfs_threads: int | None = None
+    lfs_batch_mib: int | None = None
+    lfs_commit_rules: bool = False
+    include: list = field(default_factory=list)
+    exclude: list = field(default_factory=list)
+    include_from: list = field(default_factory=list)
+    exclude_from: list = field(default_factory=list)
+    # Files the run itself writes; they are never committed, even inside the repo.
+    log_file: str | None = None
+    report: str | None = None