repoactive 0.0.1.dev0__py3-none-any.whl

repoactive/cli.py

@@ -0,0 +1,83 @@
+import logging
+from importlib.metadata import version
+from pathlib import Path
+from typing import Annotated
+
+import typer
+
+from repoactive.config import load_config
+from repoactive.platforms import get_platform
+from repoactive.runner import run_all
+
+app = typer.Typer(no_args_is_help=True)
+
+_DEFAULT_CONFIG = Path(".repoactive.toml")
+_DEFAULT_REPO = Path()
+
+
+def _version_callback(value: bool) -> None:
+    if value:
+        typer.echo(version("repoactive"))
+        raise typer.Exit()
+
+
+@app.callback()
+def callback(
+    _version: Annotated[
+        bool,
+        typer.Option(
+            "--version", callback=_version_callback, is_eager=True, help="Show version and exit."
+        ),
+    ] = False,
+) -> None:
+    """Script-driven code changes with automated merge requests."""
+
+
+@app.command()
+def run(
+    config: Annotated[
+        list[Path] | None,
+        typer.Option("--config", "-c", help="Config file; repeat to merge, later files win."),
+    ] = None,
+    repo: Annotated[
+        Path, typer.Option("--repo", "-r", help="Path to the jj repository.")
+    ] = _DEFAULT_REPO,
+    local: Annotated[
+        bool, typer.Option("--local", help="Skip pushing branches and MR creation/update.")
+    ] = False,
+    debug: Annotated[bool, typer.Option("--debug", "-d", help="Enable debug logging.")] = False,
+    jobs: Annotated[
+        list[str] | None,
+        typer.Argument(help="Jobs to run (default: all); dependencies are auto-included."),
+    ] = None,
+) -> None:
+    """Apply jobs and create or update merge requests."""
+    if debug:
+        logging.basicConfig(level=logging.DEBUG)
+    cfg = load_config(config or [_DEFAULT_CONFIG])
+    platform = None if local else get_platform(cfg.platform, repo)
+    summary = run_all(
+        config=cfg, repo_path=repo, platform=platform, requested_jobs=jobs or None, local=local
+    )
+    if not summary.ok:
+        raise typer.Exit(code=1)
+
+
+@app.command("validate-config")
+def validate_config(
+    config: Annotated[
+        list[Path] | None,
+        typer.Option("--config", "-c", help="Config file; repeat to merge, later files win."),
+    ] = None,
+) -> None:
+    """Validate configuration and exit."""
+    try:
+        cfg = load_config(config or [_DEFAULT_CONFIG])
+    except Exception as e:
+        typer.echo(f"Invalid config: {e}", err=True)
+        raise typer.Exit(code=1) from e
+    typer.echo(f"Config OK: {len(cfg.jobs)} job(s) defined.")
+
+
+def main() -> None:
+    app()

repoactive/config.py

@@ -0,0 +1,120 @@
+from __future__ import annotations
+
+import logging
+import tomllib
+from pathlib import Path
+from typing import Literal
+
+from pydantic import BaseModel, ConfigDict, Field, model_validator
+
+logger = logging.getLogger(__name__)
+
+
+class PlatformConfig(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    type: Literal["gitlab", "github"]
+    url: str | None = None
+    token_env: str
+    # Project path ("namespace/repo"). Auto-detected from remote URL if omitted.
+    repo: str | None = None
+
+
+class Defaults(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    branch_prefix: str = "repoactive/"
+    mr_title_prefix: str = "[repoactive] "
+    commit_title_prefix: str = "[repoactive] "
+    labels: list[str] = Field(default_factory=list)
+
+
+class Job(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    name: str
+    command: str
+    title: str
+    description: str | None = None
+    labels: list[str] = Field(default_factory=list)
+    base_branch: str | None = None
+    draft: bool = False
+    create_mr: bool = True
+    disabled: bool = False
+    depends_on: list[str] = Field(default_factory=list)
+    output_in_commit: bool = True
+
+    def branch_name(self, prefix: str) -> str:
+        return f"{prefix}{self.name}"
+
+
+class Config(BaseModel):
+    model_config = ConfigDict(populate_by_name=True, extra="forbid")
+
+    platform: PlatformConfig
+    defaults: Defaults = Field(default_factory=Defaults)
+    jobs: list[Job] = Field(default_factory=list, alias="job")
+
+    @model_validator(mode="after")
+    def validate_depends_on(self) -> Config:
+        names = {j.name for j in self.jobs}
+        for job in self.jobs:
+            unknown = set(job.depends_on) - names
+            if unknown:
+                raise ValueError(f"Job '{job.name}' depends_on unknown jobs: {sorted(unknown)}")
+        by_name = {j.name: j for j in self.jobs}
+        visiting: set[str] = set()
+        visited: set[str] = set()
+
+        def detect_cycle(name: str) -> None:
+            if name in visiting:
+                raise ValueError(f"Circular dependency involving '{name}'")
+            if name in visited:
+                return
+            visiting.add(name)
+            for dep in by_name[name].depends_on:
+                detect_cycle(dep)
+            visiting.discard(name)
+            visited.add(name)
+
+        for job in self.jobs:
+            detect_cycle(job.name)
+        return self
+
+
+def _deep_merge(base: dict, override: dict) -> dict:
+    result = dict(base)
+    for key, value in override.items():
+        if key in result and isinstance(result[key], dict) and isinstance(value, dict):
+            result[key] = _deep_merge(result[key], value)
+        else:
+            result[key] = value
+    return result
+
+
+def _merge_jobs(base: list[dict], override: list[dict]) -> list[dict]:
+    """Merge two job lists by name: order is preserved, override fields win, new names appended."""
+    job_by_name: dict[str, dict] = {}
+    result: list[dict] = []
+    for job in base + override:
+        name = job["name"]
+        if name in job_by_name:
+            job_by_name[name].update(job)
+        else:
+            job_by_name[name] = dict(job)
+            result.append(job_by_name[name])
+
+    return result
+
+
+def load_config(paths: list[Path]) -> Config:
+    assert paths
+    configs = [tomllib.loads(path.read_text()) for path in paths]
+    merged = {}
+    for data in configs:
+        jobs = _merge_jobs(merged.get("job", []), data.get("job", []))
+        merged = _deep_merge(merged, data)
+        merged["job"] = jobs
+        config = Config.model_validate(merged)  # ensure it's valid after each merge
+    logger.debug("loaded config: %s", config.model_dump_json(indent=2))
+    return config

repoactive/jj.py

@@ -0,0 +1,67 @@
+import logging
+import subprocess
+from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+
+class JJError(Exception):
+    pass
+
+
+def _run(*args: str, cwd: Path | None = None) -> str:
+    try:
+        result = subprocess.run(
+            ["jj", "--no-pager", "--color=never", *args],
+            cwd=cwd,
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+        return result.stdout
+    except subprocess.CalledProcessError as e:
+        raise JJError(f"jj {' '.join(args)} failed:\n{e.stderr.strip()}") from e
+
+
+def new(*parents: str, cwd: Path | None = None) -> None:
+    _run("new", *parents, cwd=cwd)
+
+
+def bookmark_set(name: str, revision: str = "@", cwd: Path | None = None) -> None:
+    _run("bookmark", "set", name, "--revision", revision, "--allow-backwards", cwd=cwd)
+
+
+def bookmark_exists(name: str, cwd: Path | None = None) -> bool:
+    try:
+        _run("bookmark", "list", name, cwd=cwd)
+        return True
+    except JJError:
+        return False
+
+
+def is_empty(cwd: Path | None = None) -> bool:
+    output = _run("log", "-r", "@", "--no-graph", "--template", "json(self.empty())", cwd=cwd)
+    result = output.strip() == "true"
+    logger.debug("is_empty: jj output=%r result=%r", output.strip(), result)
+    return result
+
+
+def abandon(cwd: Path | None = None) -> None:
+    _run("abandon", "@", cwd=cwd)
+
+
+def describe(message: str, cwd: Path | None = None) -> None:
+    _run("describe", "--message", message, cwd=cwd)
+
+
+def git_push(bookmark: str, cwd: Path | None = None) -> None:
+    _run("git", "push", "--bookmark", bookmark, cwd=cwd)
+
+
+def get_remote_url(remote: str = "origin", cwd: Path | None = None) -> str:
+    output = _run("git", "remote", "list", cwd=cwd)
+    for line in output.splitlines():
+        parts = line.split()
+        if parts and parts[0] == remote:
+            return parts[1]
+    raise JJError(f"Remote '{remote}' not found")

repoactive/platforms/__init__.py

@@ -0,0 +1,27 @@
+import os
+from pathlib import Path
+
+from repoactive import jj
+from repoactive.config import PlatformConfig
+from repoactive.platforms.base import Platform, parse_repo_from_url
+from repoactive.platforms.github import GitHubPlatform
+from repoactive.platforms.gitlab import GitLabPlatform
+
+
+def get_platform(config: PlatformConfig, repo_path: Path) -> Platform:
+    token = os.environ.get(config.token_env)
+    if not token:
+        raise RuntimeError(
+            f"Platform token not set: environment variable '{config.token_env}' is empty"
+        )
+
+    repo = config.repo
+    if not repo:
+        remote_url = jj.get_remote_url(cwd=repo_path)
+        repo = parse_repo_from_url(remote_url)
+
+    if config.type == "gitlab":
+        return GitLabPlatform(url=config.url, token=token, repo=repo)
+    if config.type == "github":
+        return GitHubPlatform(url=config.url, token=token, repo=repo)
+    raise RuntimeError(f"Unsupported platform type: {config.type!r}")

repoactive/platforms/base.py

@@ -0,0 +1,32 @@
+import re
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+
+
+@dataclass
+class MRParams:
+    source_branch: str
+    target_branch: str
+    title: str
+    description: str
+    labels: list[str]
+    draft: bool
+
+
+class Platform(ABC):
+    @abstractmethod
+    def default_branch(self) -> str:
+        """Return the repository's default branch name."""
+
+    @abstractmethod
+    def ensure_mr(self, params: MRParams) -> str:
+        """Create or update an MR/PR. Returns the MR/PR URL."""
+
+
+def parse_repo_from_url(url: str) -> str:
+    """Extract 'namespace/repo' from an HTTPS or SSH git remote URL."""
+    ssh = re.match(r"git@[^:]+:(.+?)(?:\.git)?$", url)
+    if ssh:
+        return ssh.group(1)
+    # HTTPS
+    return re.sub(r"https?://[^/]+/", "", url).removesuffix(".git")

repoactive/platforms/github.py

@@ -0,0 +1,46 @@
+from github import Github
+
+from repoactive.platforms.base import MRParams, Platform
+
+_DEFAULT_API_URL = "https://api.github.com"
+
+
+class GitHubPlatform(Platform):
+    def __init__(self, url: str | None, token: str, repo: str) -> None:
+        base_url = (url.rstrip("/") + "/api/v3") if url else _DEFAULT_API_URL
+        self._gh = Github(token, base_url=base_url)
+        self._repo = self._gh.get_repo(repo)
+
+    def default_branch(self) -> str:
+        return self._repo.default_branch
+
+    def ensure_mr(self, params: MRParams) -> str:
+        owner = self._repo.owner.login
+        existing = list(
+            self._repo.get_pulls(
+                state="open",
+                head=f"{owner}:{params.source_branch}",
+                base=params.target_branch,
+            )
+        )
+        if existing:
+            pr = existing[0]
+            pr.edit(
+                title=params.title,
+                body=params.description,
+                # PyGithub does not support converting to/from draft via edit;
+                # draft state can only be set at creation time.
+            )
+            # Labels are set separately
+            pr.set_labels(*params.labels)
+        else:
+            pr = self._repo.create_pull(
+                title=params.title,
+                body=params.description,
+                head=params.source_branch,
+                base=params.target_branch,
+                draft=params.draft,
+            )
+            if params.labels:
+                pr.set_labels(*params.labels)
+        return pr.html_url

repoactive/platforms/gitlab.py

@@ -0,0 +1,43 @@
+import gitlab
+
+from repoactive.platforms.base import MRParams, Platform
+
+_DRAFT_PREFIX = "Draft: "
+
+
+def _mr_title(title: str, *, draft: bool) -> str:
+    return f"{_DRAFT_PREFIX}{title}" if draft else title
+
+
+class GitLabPlatform(Platform):
+    def __init__(self, url: str | None, token: str, repo: str) -> None:
+        self._gl = gitlab.Gitlab(url or "https://gitlab.com", private_token=token)
+        self._project = self._gl.projects.get(repo)
+
+    def default_branch(self) -> str:
+        return self._project.default_branch
+
+    def ensure_mr(self, params: MRParams) -> str:
+        title = _mr_title(params.title, draft=params.draft)
+        existing = self._project.mergerequests.list(
+            source_branch=params.source_branch,
+            state="opened",
+            iterator=False,
+        )
+        if existing:
+            mr = existing[0]
+            mr.title = title
+            mr.description = params.description
+            mr.labels = params.labels
+            mr.save()
+        else:
+            mr = self._project.mergerequests.create(
+                {
+                    "source_branch": params.source_branch,
+                    "target_branch": params.target_branch,
+                    "title": title,
+                    "description": params.description,
+                    "labels": params.labels,
+                }
+            )
+        return mr.web_url