repoactive 0.2.3.dev2__tar.gz → 0.2.4.dev2__tar.gz

{repoactive-0.2.3.dev2 → repoactive-0.2.4.dev2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: repoactive
-Version: 0.2.3.dev2
+Version: 0.2.4.dev2
 Summary: Script-driven code changes with automated merge requests
 License-Expression: GPL-3.0-or-later
 License-File: LICENSE

{repoactive-0.2.3.dev2 → repoactive-0.2.4.dev2}/pyproject.toml

@@ -10,7 +10,7 @@ only-include = ["src"]
 
 [project]
 name = "repoactive"
-version = "0.2.3.dev2"
+version = "0.2.4.dev2"
 description = "Script-driven code changes with automated merge requests"
 readme = "README.md"
 requires-python = ">=3.11"

{repoactive-0.2.3.dev2 → repoactive-0.2.4.dev2}/src/repoactive/jj.py

@@ -1,6 +1,7 @@
 """Wrapper around the jj (Jujutsu) CLI for managing colocated jj+git repositories."""
 
 import contextlib
+import enum
 import logging
 import shutil
 import subprocess
@@ -8,13 +9,19 @@ import tempfile
 import time
 from collections.abc import Generator
 from dataclasses import dataclass
-from datetime import datetime
+from datetime import UTC, datetime
 from pathlib import Path
 
 from repoactive.constants import JOB_TRAILER_KEY
 
 logger = logging.getLogger(__name__)
 
+
+class Colocation(enum.Enum):
+    COLOCATED = "colocated"
+    PLAIN = "plain"
+
+
 # Prefix for the temporary workspaces repoactive creates for each job. It is not
 # configurable so that stale workspaces (left behind by a killed run) can always
 # be recognised and reclaimed by name (see JJ.forget_stale_workspaces).
@@ -181,9 +188,9 @@ class JJ:
             )
             raise CommandFailedError(program, args, e.stderr) from e
         logger.debug(
-            "%s %s -> %d bytes in %.3fs",
+            "%s %s ... -> %d bytes in %.3fs",
             program,
-            " ".join(args),
+            " ".join(args[:1]),
             len(result.stdout),
             time.monotonic() - start,
         )
@@ -215,8 +222,8 @@ class JJ:
     def edit(self, revision: str) -> None:
         self._run("edit", revision)
 
-    def restore(self, source: str) -> None:
-        self._run("restore", "--changes-in", source)
+    def restore(self, *, source_rev: str, destination_rev: str) -> None:
+        self._run("restore", "--from", source_rev, "--into", destination_rev)
 
     def rebase(self, *onto: str) -> None:
         onto_args = [arg for parent in onto for arg in ("--onto", parent)]
@@ -400,8 +407,10 @@ class JJ:
             if name.strip()
         }
 
-    def has_recent_job_commit(self, *, job_name: str, base: str, since: datetime) -> bool:
-        """Whether ``base`` already carries a recent commit from the given job.
+    def last_job_commit_date(
+        self, *, job_name: str, base: str, since: datetime
+    ) -> datetime | None:
+        """Return the committer date of the most recent job commit on ``base``, or ``None``.
 
         Matches commits that have a ``Repoactive-Job: <job_name>`` trailer and a
         committer date at or after ``since``. Used to throttle jobs: a recent
@@ -410,16 +419,22 @@ class JJ:
         The trailer is matched via jj's trailer parsing, which only considers the
         final paragraph of the description, so a stray matching line in the body
         is correctly ignored.
+
+        Returns the newest matching committer timestamp, or ``None`` if no match.
         """
         revset = f'::{base} & committer_date(after:"{_jj_timestamp(since)}")'
         template = f"""
         if (trailers.any(|t| t.key() == "{JOB_TRAILER_KEY}" && t.value() == "{job_name}"),
-             "x",
+             committer.timestamp().utc().format("%Y-%m-%dT%H:%M:%S") ++ "\\n",
              ""
         )
         """
         output = self._run("log", "--no-graph", "-r", revset, "-T", template)
-        return bool(output.strip())
+        lines = [line.strip() for line in output.splitlines() if line.strip()]
+        if not lines:
+            return None
+        # jj log returns newest-first; take the first line.
+        return datetime.fromisoformat(lines[0]).replace(tzinfo=UTC)
 
     def git_push_bookmarks(self, *bookmarks: str) -> None:
         """Push bookmarks to the remote.
@@ -464,7 +479,7 @@ class JJ:
         """Sync the colocated git checkout (HEAD and index) to the jj working copy.
 
         jj only exports git HEAD in the default workspace; workspaces colocated
-        via workspace_add() need this after the working copy moves (new, edit,
+        via _workspace_add() need this after the working copy moves (new, edit,
         rebase). No-op if the workspace is not colocated.
         """
         if not self.is_colocated():
@@ -500,9 +515,11 @@ class JJ:
         if stale:
             self.git_worktree_prune()
 
-    def workspace_add(self, name: str, path: Path) -> None:
+    def _workspace_add(
+        self, name: str, path: Path, colocation: Colocation = Colocation.COLOCATED
+    ) -> None:
         self._run("workspace", "add", "--name", name, str(path))
-        if self.is_colocated():
+        if colocation is Colocation.COLOCATED and self.is_colocated():
             self._colocate_workspace(name, path)
 
     def _colocate_workspace(self, name: str, path: Path) -> None:
@@ -533,7 +550,9 @@ class JJ:
         self._run("workspace", "forget", name)
 
     @contextlib.contextmanager
-    def temp_workspace(self, name: str) -> Generator["JJ"]:
+    def temp_workspace(
+        self, name: str, colocation: Colocation = Colocation.COLOCATED
+    ) -> Generator["JJ"]:
         """Create a workspace named ``name`` in a temp directory, cleaning up on exit.
 
         Adds a jj workspace inside a fresh temp directory and yields a JJ bound
@@ -544,7 +563,7 @@ class JJ:
         tmp_root = Path(tempfile.mkdtemp(prefix="repoactive-workspace-"))
         workspace_path = tmp_root / "workspace"
         logger.debug("adding workspace %s at %s", name, workspace_path)
-        self.workspace_add(name, workspace_path)
+        self._workspace_add(name, workspace_path, colocation)
         try:
             yield JJ(workspace_path)
         finally:
@@ -552,5 +571,6 @@ class JJ:
             with contextlib.suppress(JJError):
                 self.workspace_forget(name)
             shutil.rmtree(tmp_root, ignore_errors=True)
-            with contextlib.suppress(JJError):
-                self.git_worktree_prune()
+            if colocation is Colocation.COLOCATED:
+                with contextlib.suppress(JJError):
+                    self.git_worktree_prune()

{repoactive-0.2.3.dev2 → repoactive-0.2.4.dev2}/src/repoactive/platforms/gitlab.py

@@ -1,7 +1,7 @@
 """GitLab platform implementation using python-gitlab."""
 
 import gitlab
-from gitlab.exceptions import GitlabError
+from gitlab.exceptions import GitlabError, GitlabMRClosedError
 
 from repoactive.platforms.base import MRParams, Platform, PlatformError
 
@@ -50,5 +50,8 @@ class GitLabPlatform(Platform):
                 }
             )
         if params.auto_merge:
-            mr.merge(merge_when_pipeline_succeeds=True)
+            try:
+                mr.merge(merge_when_pipeline_succeeds=True)
+            except GitlabMRClosedError as e:
+                print(f"  warning: could not enable auto-merge ({e})")
         return mr.web_url

{repoactive-0.2.3.dev2 → repoactive-0.2.4.dev2}/src/repoactive/runner.py

@@ -28,7 +28,7 @@ from repoactive.config import (
 )
 from repoactive.constants import JOB_TRAILER_KEY
 from repoactive.graph import CircularDependencyError, detect_dependency_cycle, topological_sort
-from repoactive.jj import JJ, workspace_name
+from repoactive.jj import JJ, Colocation, workspace_name
 from repoactive.jobtree import format_job_forest, print_job_table
 from repoactive.lock import run_lock
 from repoactive.platforms.base import MRParams, Platform
@@ -622,22 +622,43 @@ def _build_generated_jobs(
     return emitted
 
 
-def _on_cooldown(job: Job, repo_path: Path) -> bool:
-    """Whether the job landed on its base branch within its cooldown_period window."""
+def _format_duration(seconds: float) -> str:
+    """Format a duration in seconds as a human-readable string like '3d 2h' or '45m'."""
+    seconds = int(seconds)
+    days, seconds = divmod(seconds, 86400)
+    hours, seconds = divmod(seconds, 3600)
+    minutes, seconds = divmod(seconds, 60)
+    if days:
+        parts = [f"{days}d"]
+        if hours:
+            parts.append(f"{hours}h")
+        return " ".join(parts)
+    if hours:
+        parts = [f"{hours}h"]
+        if minutes:
+            parts.append(f"{minutes}m")
+        return " ".join(parts)
+    if minutes:
+        return f"{minutes}m"
+    return f"{seconds}s"
+
+
+def _on_cooldown(job: Job, repo_path: Path) -> datetime | None:
+    """Return the last-run timestamp if the job is still on cooldown, else None."""
     delta = job.cooldown_timedelta()
     if delta is None:
-        return False
+        return None
     base = job.base_branch or "trunk()"
     since = datetime.now(UTC) - delta
-    on_cooldown = JJ(repo_path).has_recent_job_commit(job_name=job.name, base=base, since=since)
+    last_run = JJ(repo_path).last_job_commit_date(job_name=job.name, base=base, since=since)
     logger.debug(
-        "[%s] cooldown check: base=%s since=%s -> on_cooldown=%s",
+        "[%s] cooldown check: base=%s since=%s -> last_run=%s",
         job.name,
         base,
         since.isoformat(),
-        on_cooldown,
+        last_run,
     )
-    return on_cooldown
+    return last_run
 
 
 def _validate_selection(
@@ -828,8 +849,13 @@ def _dispatch_job(  # noqa: PLR0913
     # emits nothing, throttling its whole fan-out as a unit (the dual trailer
     # records a recent child landing as the generator's). See
     # docs/adr/0004-job-generators.md.
-    if _on_cooldown(resolved_job, repo_path):
-        print(f"==> [{job.name}] on cooldown ({resolved_job.cooldown_period}), skipped")
+    if last_run := _on_cooldown(resolved_job, repo_path):
+        elapsed = datetime.now(UTC) - last_run
+        elapsed_str = _format_duration(elapsed.total_seconds())
+        print(
+            f"==> [{job.name}] on cooldown ({resolved_job.cooldown_period}),"
+            f" last run {elapsed_str} ago, skipped"
+        )
         summary.on_cooldown.add(job.name)
         # Treat like a no-op run so dependents proceed on the base branch.
         summary.results[job.name] = JobResult(
@@ -1004,9 +1030,10 @@ def _absorb_results(
                 )
                 if not content_unchanged:
                     if abs_ws is None:
-                        abs_ws = stack.enter_context(repo.temp_workspace("repoactive-absorb"))
-                    abs_ws.edit(old_cid)
-                    abs_ws.restore(new_cid)
+                        abs_ws = stack.enter_context(
+                            repo.temp_workspace("repoactive-absorb", Colocation.PLAIN)
+                        )
+                    abs_ws.restore(source_rev=new_cid, destination_rev=old_cid)
                     repo.describe_revision(old_cid, message)
                 elif _strip_boxquote_and_trailers(
                     repo.get_description(old_cid)