repoactive 0.2.1__tar.gz → 0.2.3.dev1__tar.gz

{repoactive-0.2.1 → repoactive-0.2.3.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: repoactive
-Version: 0.2.1
+Version: 0.2.3.dev1
 Summary: Script-driven code changes with automated merge requests
 License-Expression: GPL-3.0-or-later
 License-File: LICENSE
@@ -50,6 +50,7 @@ and (with `--mode publish`) the full MR lifecycle.
 - [Configuration](#configuration)
 - [Selecting jobs with tags](#selecting-jobs-with-tags)
 - [Disabling jobs](#disabling-jobs)
+- [Gating jobs with `run_only_if_changed`](#gating-jobs-with-run_only_if_changed)
 - [Throttling jobs with `cooldown_period`](#throttling-jobs-with-cooldown_period)
 - [Limiting job runtime with `timeout`](#limiting-job-runtime-with-timeout)
 - [Generating jobs dynamically](#generating-jobs-dynamically)
@@ -145,7 +146,13 @@ need to write is the script that produces the change.
 2. It runs the job's script against the working tree.
 3. If the script produced a diff, it records the change. With `--mode push`
    or `--mode publish`, it pushes the branch; with `--mode publish`, it also
-   creates or updates the merge request.
+   creates or updates the merge request. On a re-run, if the diff matches
+   what is already on the branch, the commit and branch are left untouched —
+   avoiding an unnecessary push that would re-trigger CI pipelines. The
+   commit is updated (and the branch pushed) only when the diff itself
+   changes or when `title`/`commit_title_prefix` changed. Command output
+   alone changing does not update the commit. The MR title and description
+   are always brought up to date, including any changed command output.
 4. If the script produced no diff, the empty commit is discarded and no MR
    is opened. A branch left over from an earlier run that did produce a diff
    is now stale, so it is deleted; with `--mode push` or `--mode publish`,
@@ -507,6 +514,11 @@ disabled = false
 # Optional: override branch_prefix/mr_title_prefix/commit_title_prefix from
 # job-defaults for this job only.
 mr_title_prefix = "[api] "
+# Optional: only run this job if at least one of the named jobs produced a
+# diff in the current run. If none of them changed anything, this job is
+# skipped (with a no-op result so dependents still run). Names need not be
+# in depends_on; any job that ran before this one can be listed.
+# run_only_if_changed = ["other-job"]
 # Optional: minimum time between landed changes for this job. If a commit
 # from this job landed on the base branch within this window, the job is
 # skipped. Format: <number><unit>, unit one of s, m, h, d, w (e.g. "7d").
@@ -751,6 +763,45 @@ The lock is an advisory `flock` on `.jj/repoactive.lock`; the OS releases it
 automatically if a run is killed, so a crashed run never leaves the
 repository locked.
 
+## Gating jobs with `run_only_if_changed`
+
+`run_only_if_changed` lets a job declare that it should only run when
+specific upstream jobs actually produced a diff. If none of the named jobs
+changed anything in the current run, the job is skipped.
+
+```toml
+[job.prek-autoupdate]
+command = "./scripts/prek.sh autoupdate"
+title = "ci: update pre-commit hooks"
+tags = ["weekly"]
+
+[job.prek-run-all]
+command = "sh -c './scripts/prek.sh run -a; true'"
+title = "ci: apply pre-commit fixes"
+depends_on = ["prek-autoupdate"]
+run_only_if_changed = ["prek-autoupdate"]
+tags = ["weekly"]
+```
+
+Here `prek-run-all` is only useful when `prek-autoupdate` changed something:
+if `prek-autoupdate` found no hooks to update, running `prek-run-all` would
+produce an empty diff anyway. With `run_only_if_changed`, the skip is
+explicit and immediate — `prek-run-all` never even starts.
+
+Key behaviour:
+
+- **At least one must have changed.** The job runs if any named job produced
+  a diff; it is skipped only when _all_ of them were empty.
+- **Missing results count as no diff.** If a named job failed or was itself
+  skipped, it is treated as having produced no diff.
+- **Dependents are unaffected.** A skipped job records a no-op result (like
+  a job on cooldown), so any job that `depends_on` it still runs on the base
+  branch — the skip does not cascade.
+- **No ordering constraint.** Names in `run_only_if_changed` do not have to
+  appear in `depends_on`. Any job that runs before this one in topological
+  order can be listed; in practice most usages name a direct dependency, as
+  in the example above.
+
 ## Throttling jobs with `cooldown_period`
 
 Every commit `repoactive` creates carries a `Repoactive-Job: <name>` trailer

{repoactive-0.2.1 → repoactive-0.2.3.dev1}/README.md

@@ -23,6 +23,7 @@ and (with `--mode publish`) the full MR lifecycle.
 - [Configuration](#configuration)
 - [Selecting jobs with tags](#selecting-jobs-with-tags)
 - [Disabling jobs](#disabling-jobs)
+- [Gating jobs with `run_only_if_changed`](#gating-jobs-with-run_only_if_changed)
 - [Throttling jobs with `cooldown_period`](#throttling-jobs-with-cooldown_period)
 - [Limiting job runtime with `timeout`](#limiting-job-runtime-with-timeout)
 - [Generating jobs dynamically](#generating-jobs-dynamically)
@@ -118,7 +119,13 @@ need to write is the script that produces the change.
 2. It runs the job's script against the working tree.
 3. If the script produced a diff, it records the change. With `--mode push`
    or `--mode publish`, it pushes the branch; with `--mode publish`, it also
-   creates or updates the merge request.
+   creates or updates the merge request. On a re-run, if the diff matches
+   what is already on the branch, the commit and branch are left untouched —
+   avoiding an unnecessary push that would re-trigger CI pipelines. The
+   commit is updated (and the branch pushed) only when the diff itself
+   changes or when `title`/`commit_title_prefix` changed. Command output
+   alone changing does not update the commit. The MR title and description
+   are always brought up to date, including any changed command output.
 4. If the script produced no diff, the empty commit is discarded and no MR
    is opened. A branch left over from an earlier run that did produce a diff
    is now stale, so it is deleted; with `--mode push` or `--mode publish`,
@@ -480,6 +487,11 @@ disabled = false
 # Optional: override branch_prefix/mr_title_prefix/commit_title_prefix from
 # job-defaults for this job only.
 mr_title_prefix = "[api] "
+# Optional: only run this job if at least one of the named jobs produced a
+# diff in the current run. If none of them changed anything, this job is
+# skipped (with a no-op result so dependents still run). Names need not be
+# in depends_on; any job that ran before this one can be listed.
+# run_only_if_changed = ["other-job"]
 # Optional: minimum time between landed changes for this job. If a commit
 # from this job landed on the base branch within this window, the job is
 # skipped. Format: <number><unit>, unit one of s, m, h, d, w (e.g. "7d").
@@ -724,6 +736,45 @@ The lock is an advisory `flock` on `.jj/repoactive.lock`; the OS releases it
 automatically if a run is killed, so a crashed run never leaves the
 repository locked.
 
+## Gating jobs with `run_only_if_changed`
+
+`run_only_if_changed` lets a job declare that it should only run when
+specific upstream jobs actually produced a diff. If none of the named jobs
+changed anything in the current run, the job is skipped.
+
+```toml
+[job.prek-autoupdate]
+command = "./scripts/prek.sh autoupdate"
+title = "ci: update pre-commit hooks"
+tags = ["weekly"]
+
+[job.prek-run-all]
+command = "sh -c './scripts/prek.sh run -a; true'"
+title = "ci: apply pre-commit fixes"
+depends_on = ["prek-autoupdate"]
+run_only_if_changed = ["prek-autoupdate"]
+tags = ["weekly"]
+```
+
+Here `prek-run-all` is only useful when `prek-autoupdate` changed something:
+if `prek-autoupdate` found no hooks to update, running `prek-run-all` would
+produce an empty diff anyway. With `run_only_if_changed`, the skip is
+explicit and immediate — `prek-run-all` never even starts.
+
+Key behaviour:
+
+- **At least one must have changed.** The job runs if any named job produced
+  a diff; it is skipped only when _all_ of them were empty.
+- **Missing results count as no diff.** If a named job failed or was itself
+  skipped, it is treated as having produced no diff.
+- **Dependents are unaffected.** A skipped job records a no-op result (like
+  a job on cooldown), so any job that `depends_on` it still runs on the base
+  branch — the skip does not cascade.
+- **No ordering constraint.** Names in `run_only_if_changed` do not have to
+  appear in `depends_on`. Any job that runs before this one in topological
+  order can be listed; in practice most usages name a direct dependency, as
+  in the example above.
+
 ## Throttling jobs with `cooldown_period`
 
 Every commit `repoactive` creates carries a `Repoactive-Job: <name>` trailer

{repoactive-0.2.1 → repoactive-0.2.3.dev1}/pyproject.toml

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

{repoactive-0.2.1 → repoactive-0.2.3.dev1}/src/repoactive/config.py

@@ -20,6 +20,7 @@ from pydantic import (
     ConfigDict,
     Field,
     ValidationError,
+    ValidationInfo,
     field_validator,
     model_validator,
 )
@@ -78,6 +79,13 @@ class InvalidTagError(ValueError):
         super().__init__(f"invalid tag {tag!r}: only letters, digits, '-', and '_' are allowed")
 
 
+class NewlineInTitleError(ValueError):
+    """Raised when a title or prefix field contains a newline character."""
+
+    def __init__(self, field: str, value: str) -> None:
+        super().__init__(f"{field} must not contain newline characters, got {value!r}")
+
+
 class DisabledAndTagsError(ValueError):
     """Raised when a job sets both 'disabled' and 'tags'."""
 
@@ -95,6 +103,15 @@ class UnknownDependencyError(ValueError):
         super().__init__(f"job '{name}' depends_on unknown jobs: {unknown}")
 
 
+class UnknownRunOnlyIfChangedError(ValueError):
+    """Raised when run_only_if_changed references a job that does not exist."""
+
+    def __init__(self, name: str, unknown: list[str]) -> None:
+        super().__init__(
+            f"job '{name}' run_only_if_changed references unknown job(s): {', '.join(unknown)}"
+        )
+
+
 class JobNameInBodyError(ValueError):
     """Raised when a [job.<name>] table also sets a 'name' field.
 
@@ -253,6 +270,14 @@ class JobDefaults(BaseModel):
     cooldown_period: _Duration | None = None
     timeout: _Duration | None = "2m"
 
+    @field_validator("mr_title_prefix", "commit_title_prefix")
+    @classmethod
+    def _check_no_newline(cls, value: str, info: ValidationInfo) -> str:
+        if "\n" in value:
+            assert info.field_name is not None
+            raise NewlineInTitleError(info.field_name, value)
+        return value
+
 
 # Fields Job.resolve fills in from JobDefaults when the job does not set them
 # itself. labels is absent on purpose: it is merged, not replaced (see resolve).
@@ -279,6 +304,7 @@ class Job(BaseModel):
     disabled: bool = False
     tags: list[str] = Field(default_factory=list)
     depends_on: list[str] = Field(default_factory=list)
+    run_only_if_changed: list[str] = Field(default_factory=list)
     output_in_commit: bool = True
     # When true, the command does not produce a diff to commit; instead it writes
     # one or more *.toml job fragments into the directory named by the
@@ -305,6 +331,14 @@ class Job(BaseModel):
             raise InvalidJobNameError(value)
         return value
 
+    @field_validator("title", "commit_title_prefix")
+    @classmethod
+    def _check_no_newline(cls, value: str, info: ValidationInfo) -> str:
+        if "\n" in value:
+            assert info.field_name is not None
+            raise NewlineInTitleError(info.field_name, value)
+        return value
+
     @field_validator("tags")
     @classmethod
     def _check_tags(cls, value: list[str]) -> list[str]:
@@ -443,6 +477,15 @@ class Config(BaseModel):
         detect_dependency_cycle(self.jobs)
         return self
 
+    @model_validator(mode="after")
+    def validate_run_only_if_changed(self) -> Config:
+        names = {j.name for j in self.jobs}
+        for job in self.jobs:
+            unknown = sorted(set(job.run_only_if_changed) - names)
+            if unknown:
+                raise UnknownRunOnlyIfChangedError(job.name, unknown)
+        return self
+
     def _resolved_jobs(self) -> list[Job]:
         return [job.resolve(self.job_defaults) for job in self.jobs]
 
@@ -521,8 +564,21 @@ def _merge_named_tables(*, base: dict, override: dict) -> dict:
 
 
 def merge_jobs(*, base: dict, override: dict) -> dict:
-    """Merge two job tables keyed by name (see ``_merge_named_tables``)."""
-    return _merge_named_tables(base=base, override=override)
+    """Merge two job tables keyed by name (see ``_merge_named_tables``).
+
+    When the override sets ``disabled = true``, any ``tags`` carried over from
+    the base are removed, and when the override sets ``tags``, any ``disabled``
+    carried over from the base is removed.  This keeps the mutual-exclusion
+    invariant intact across multi-source merges.
+    """
+    result = _merge_named_tables(base=base, override=override)
+    for name, override_body in override.items():
+        merged_body = result[name]
+        if override_body.get("disabled") and "tags" not in override_body:
+            merged_body.pop("tags", None)
+        elif override_body.get("tags") and "disabled" not in override_body:
+            merged_body.pop("disabled", None)
+    return result
 
 
 def merge_platforms(*, base: dict, override: dict) -> dict:

{repoactive-0.2.1 → repoactive-0.2.3.dev1}/src/repoactive/jj.py

@@ -273,9 +273,9 @@ class JJ:
         """Abandon a specific revision (not the working copy)."""
         self._run("abandon", revision)
 
-    def diff_content(self, revision: str = "@") -> str:
-        """Return the full diff of ``revision`` relative to its parents."""
-        return self._run("diff", "-r", revision)
+    def same_content(self, rev1: str, rev2: str) -> bool:
+        """Return True if ``rev1`` and ``rev2`` have identical tree contents."""
+        return not self._run("diff", "--git", "--from", rev1, "--to", rev2).strip()
 
     def bookmark_change_id(self, name: str) -> str | None:
         """Return the change-id of the local bookmark ``name``, or None if absent."""
@@ -290,6 +290,10 @@ class JJ:
         """Set the commit message of a specific revision without touching ``@``."""
         self._run("describe", "-r", revision, "--message", message)
 
+    def get_description(self, revision: str) -> str:
+        """Return the commit message of a specific revision."""
+        return self._run("log", "--no-graph", "-r", revision, "-T", "description")
+
     def children_job_names(self, bookmarks: list[str]) -> set[str]:
         """Job names from unmerged commits that are direct children of any of ``bookmarks``.
 

{repoactive-0.2.1 → repoactive-0.2.3.dev1}/src/repoactive/runner.py

@@ -26,6 +26,7 @@ from repoactive.config import (
     jobs_table,
     merge_jobs,
 )
+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.jobtree import format_job_forest, print_job_table
@@ -374,6 +375,19 @@ def _boxquote(msg: str, title: str = "") -> str:
     return f"{top}\n{body}\n`----"
 
 
+def _strip_boxquote_and_trailers(message: str) -> str:
+    """Strip the boxquote section and trailers paragraph from a commit message.
+
+    Returns only the title line and description field.
+    Note: inaccurate when the description itself contains a ,---- boxquote (ignored edge case).
+    """
+    if "\n\n,----" in message:
+        return message[: message.index("\n\n,----")]
+    if f"\n\n{JOB_TRAILER_KEY}" in message:
+        return message[: message.index(f"\n\n{JOB_TRAILER_KEY}")]
+    return message
+
+
 def _build_commit_message(job: Job, command_result: CommandResult) -> str:
     """Build the commit message recorded for a job's change.
 
@@ -788,6 +802,24 @@ def _dispatch_job(  # noqa: PLR0913
         blocked.add(job.name)
         return []
 
+    if job.run_only_if_changed:
+        any_changed = any(
+            r.produced_diff
+            for d in job.run_only_if_changed
+            if (r := summary.results.get(d)) is not None
+        )
+        if not any_changed:
+            resolved_job = job.resolve(config.job_defaults)
+            parents = _compute_parents(resolved_job, summary.results)
+            print(
+                f"==> [{job.name}] skipped"
+                f" (run_only_if_changed: none of {job.run_only_if_changed} produced changes)"
+            )
+            summary.results[job.name] = JobResult(
+                job=resolved_job, effective_revsets=parents, produced_diff=False
+            )
+            return []
+
     resolved_job = job.resolve(config.job_defaults)
     parents = _compute_parents(resolved_job, summary.results)
     logger.debug("[%s] computed parents: %s", job.name, parents)
@@ -921,12 +953,6 @@ def _absorb_results(
     with contextlib.ExitStack() as stack:
         abs_ws: JJ | None = None
 
-        def _get_abs_ws() -> JJ:
-            nonlocal abs_ws
-            if abs_ws is None:
-                abs_ws = stack.enter_context(repo.temp_workspace("repoactive-absorb"))
-            return abs_ws
-
         # Maps each phase-1 new_change_id to the canonical change-id post-absorb so
         # dependent jobs are rebased onto the right commit, not the abandoned fresh one.
         absorbed: dict[str, str] = {}
@@ -967,19 +993,23 @@ def _absorb_results(
             if result.old_change_id:
                 old_cid = result.old_change_id
                 repo.rebase_revision(old_cid, *canonical_parents)
-                old_diff = repo.diff_content(old_cid)
-                new_diff = repo.diff_content(new_cid)
+                content_unchanged = repo.same_content(old_cid, new_cid)
                 logger.debug(
                     "absorb: [%s] rebased %s onto %s, content %s",
                     job.name,
                     old_cid,
                     canonical_parents,
-                    "unchanged" if old_diff == new_diff else "differs, restoring",
+                    "unchanged" if content_unchanged else "differs, restoring",
                 )
-                if old_diff != new_diff:
-                    ws = _get_abs_ws()
-                    ws.edit(old_cid)
-                    ws.restore(new_cid)
+                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)
+                    repo.describe_revision(old_cid, message)
+                elif _strip_boxquote_and_trailers(
+                    repo.get_description(old_cid)
+                ) != _strip_boxquote_and_trailers(message):
                     repo.describe_revision(old_cid, message)
                 repo.abandon_revision(new_cid)
                 # No bookmark_set needed: the bookmark follows old_cid through