@openhands/extensions 0.20.0 → 0.22.0

package/skills/github-pr-reviewer/scripts/main.py

@@ -8,10 +8,10 @@ GitHub `labeled` event has not already been processed by this automation.
 Each repository is polled independently and keeps its own state document, so
 pull-request numbers never collide across repositories.
 
-The script owns the repository checkout: it downloads the pull request's head
-commit as a tarball, hands the agent that directory as its workspace, and
-removes it once the review has finished. The agent never clones, checks out, or
-deletes anything.
+This standalone script owns the repository checkout: it downloads the pull
+request's head commit as a tarball, hands the agent that directory as its
+workspace, and removes it once the review has finished. Catalog workers may
+instead reuse its prompt builder with their own workspace instructions.
 """
 
 import io
@@ -26,7 +26,9 @@ import urllib.error
 import urllib.request
 from collections.abc import Callable
 from pathlib import Path, PurePosixPath
-from urllib.parse import urlencode
+
+from github_client import github_request as _github_request
+from github_client import github_paginate as _github_paginate
 
 # Configuration. Two setup paths write it, and both end up here:
 #
@@ -336,46 +338,6 @@ def save_state(repo: str, state: dict) -> None:
     print(f"  State saved to {path}")
 
 
-def _github_request(
-    token: str,
-    method: str,
-    path: str,
-    params: dict | None = None,
-    body: dict | None = None,
-    accept: str = "application/vnd.github+json",
-) -> tuple:
-    url = f"https://api.github.com{path}"
-    if params:
-        url = f"{url}?{urlencode(params)}"
-    headers = {
-        "Authorization": f"Bearer {token}",
-        "Accept": accept,
-        "X-GitHub-Api-Version": "2022-11-28",
-        "Content-Type": "application/json",
-    }
-    data = json.dumps(body).encode() if body is not None else None
-    req = urllib.request.Request(url, data=data, headers=headers, method=method)
-    with urllib.request.urlopen(req) as r:
-        raw = r.read()
-        return (json.loads(raw) if raw.strip() else {}), dict(r.headers)
-
-
-def _github_paginate(token: str, path: str, params: dict | None = None) -> list:
-    results = []
-    page = 1
-    base_params = dict(params or {})
-    base_params.setdefault("per_page", 100)
-    while True:
-        base_params["page"] = page
-        data, _ = _github_request(token, "GET", path, params=base_params)
-        if not isinstance(data, list):
-            break
-        results.extend(data)
-        if len(data) < base_params["per_page"]:
-            break
-        page += 1
-    return results
-
 
 def _resolve_github_token() -> str:
     try:
@@ -770,7 +732,16 @@ def _load_repo_review_guide(workspace_dir: Path) -> str | None:
     return None
 
 
-def _build_review_prompt(repo: str, pr: dict, head_sha: str, label_event: dict, repo_review_guide: str | None = None) -> str:
+def _build_review_prompt(
+    repo: str,
+    pr: dict,
+    head_sha: str,
+    label_event: dict,
+    repo_review_guide: str | None = None,
+    *,
+    workspace_instructions: str | None = None,
+    github_token_secret: str = "GITHUB_PERSONAL_ACCESS_TOKEN",
+) -> str:
     number = pr.get("number", "?")
     title = pr.get("title", "(no title)")
     body = (pr.get("body") or "").strip() or "(no description)"
@@ -790,6 +761,10 @@ def _build_review_prompt(repo: str, pr: dict, head_sha: str, label_event: dict,
         f"\n\nRepo-specific review guide (from {REPO_REVIEW_GUIDE_PATH}):\n---\n{repo_review_guide}\n---\n"
         if repo_review_guide else ""
     )
+    workspace = workspace_instructions or (
+        "The workspace is already the repository root at the exact Head SHA above. "
+        "Do not clone, fetch, check out, or delete the repository."
+    )
 
     return (
         "You are an AI code reviewer. Review the GitHub pull request below and publish "
@@ -806,8 +781,7 @@ def _build_review_prompt(repo: str, pr: dict, head_sha: str, label_event: dict,
         f"URL        : {html_url}\n"
         f"\nPR Description:\n---\n{body}\n---\n\n"
         "Required workflow:\n"
-        "1. The workspace is already the repository root at the exact Head SHA above. "
-        "Do not clone, fetch, check out, or delete the repository.\n"
+        f"1. {workspace}\n"
         "2. Before reviewing, you MUST read the repository's own guidance to understand the repo first.\n"
         "   Read `AGENTS.md` at the repository root (and any nested `AGENTS.md` covering the "
         "changed files), plus other relevant docs when present - e.g. `CONTRIBUTING.md`, "
@@ -815,7 +789,7 @@ def _build_review_prompt(repo: str, pr: dict, head_sha: str, label_event: dict,
         "guidance to your review.\n"
         "   Then inspect the PR discussion, existing review comments, changed files, and the diff, "
         "together with the surrounding code in the workspace.\n"
-        "   Use `gh` or GitHub REST API calls with `GITHUB_PERSONAL_ACCESS_TOKEN`; never print secret values.\n"
+        f"   Use `gh` or GitHub REST API calls with `{github_token_secret}`; never print secret values.\n"
         "3. Ground every finding in the workspace code. Before using an inline location, verify that "
         "the path and line are part of this pull request's diff.\n"
         f"4. Publish one review with `POST /repos/{repo}/pulls/{number}/reviews`, using "

package/skills/github-pr-reviewer/scripts/worker.py

@@ -0,0 +1,94 @@
+"""Select labeled PR heads and delegate each review to a sandboxed agent."""
+
+import json
+
+import main as workflow
+from agent_conversation import AgentConversationDispatcher
+from github_client import GitHubRepository, run_repositories
+
+
+class PullRequestReviewer(GitHubRepository):
+    name = "github-pr-reviewer"
+
+    def _prompt(self, pr, label_event):
+        number = pr["number"]
+        sha = pr["head"]["sha"]
+        label = self.config.get("trigger_label", workflow.TRIGGER_LABEL)
+        token = self.token_name
+        workspace = (
+            "The workspace contains an empty Git repository. Before fetching, run "
+            f"`GH_TOKEN=${{{token}}} gh auth setup-git` so Git uses the "
+            "profile-scoped credential without storing it in the remote URL. Set "
+            f"the plain HTTPS origin to `https://github.com/{self.repository}.git`, "
+            f"fetch PR #{number}, and check out exact head `{sha}` in detached-HEAD "
+            "mode. Set `GIT_TERMINAL_PROMPT=0` on Git network commands so a missing "
+            "permission fails immediately instead of waiting for input."
+        )
+        prompt = workflow._build_review_prompt(
+            self.repository,
+            pr,
+            sha,
+            label_event,
+            workspace_instructions=workspace,
+            github_token_secret=token,
+        )
+        return (
+            prompt + "\n\nAcceptance reporting:\n"
+            "- Inspect the current GitHub Actions results for the exact head and run "
+            "the repository's appropriate focused tests in the workspace. Do not "
+            "modify tracked files.\n"
+            f"- Re-read {self.repository} PR #{number} immediately before reporting. "
+            f"If its head is no longer `{sha}`, publish no status and leave `{label}` "
+            "in place so the new head is reviewed.\n"
+            "- After the readable native review is accepted by GitHub, set commit "
+            "status `software-factory/review` to success only for an `✅ APPROVED` "
+            "verdict, otherwise failure. Set `software-factory/tests` to success only "
+            "when the relevant checks and tests pass, otherwise failure. Use the exact "
+            f"head `{sha}` for both statuses.\n"
+            f"- After both statuses are visible on that head, remove the `{label}` "
+            "label. Never paste JSON artifacts or full command logs into comments."
+        )
+
+    def run(self):
+        repository_id = self.gh("GET", "")["id"]
+        label = self.config.get("trigger_label", workflow.TRIGGER_LABEL)
+        prs = self.gh_pages("/pulls?state=open&sort=updated&direction=asc")
+        for candidate in prs:
+            if label not in {item["name"] for item in candidate.get("labels", [])}:
+                continue
+            try:
+                pr = self.gh("GET", f"/pulls/{candidate['number']}")
+                event = workflow._latest_trigger_label_event(
+                    self.token, self.repository, pr["number"]
+                )
+                if event is None:
+                    continue
+                sha = pr["head"]["sha"]
+                result = self.dispatcher.deliver(
+                    subject=f"{repository_id}:pr:{pr['number']}",
+                    delivery=f"{event['id']}:{sha}",
+                    prompt=self._prompt(pr, event),
+                )
+                print(
+                    json.dumps(
+                        {
+                            "repository": self.repository,
+                            "pr": pr["number"],
+                            "head_sha": sha,
+                            "disposition": result["disposition"],
+                            "conversation_id": result["conversation_id"],
+                        }
+                    ),
+                    flush=True,
+                )
+            except Exception as exc:  # noqa: BLE001 - one PR must not block the scan
+                print(
+                    f"Failed to submit {self.repository} PR "
+                    f"#{candidate.get('number', '?')}: {exc}",
+                    flush=True,
+                )
+
+
+if __name__ == "__main__":
+    with AgentConversationDispatcher() as dispatcher:
+        run_repositories(PullRequestReviewer, dispatcher=dispatcher)

package/skills/github-repo-monitor/.claude-plugin/plugin.json

@@ -0,0 +1,22 @@
+{
+  "name": "github-repo-monitor",
+  "version": "1.0.0",
+  "description": "Create a cron automation that polls a GitHub repository for issue and PR comments containing a configurable trigger phrase (@OpenHands by default). Starts an OpenHands conversation with full issue/PR context, posts acknowledgement comments with a conversation link, and summarises results back to the issue/PR when the agent finishes.",
+  "author": {
+    "name": "OpenHands",
+    "email": "contact@all-hands.dev"
+  },
+  "homepage": "https://github.com/OpenHands/extensions",
+  "repository": "https://github.com/OpenHands/extensions",
+  "license": "MIT",
+  "keywords": [
+    "github",
+    "monitor",
+    "issues",
+    "pull-requests",
+    "trigger",
+    "cron",
+    "automation",
+    "integration"
+  ]
+}

package/skills/github-repo-monitor/.codex-plugin/plugin.json

@@ -0,0 +1,22 @@
+{
+  "name": "github-repo-monitor",
+  "version": "1.0.0",
+  "description": "Create a cron automation that polls a GitHub repository for issue and PR comments containing a configurable trigger phrase (@OpenHands by default). Starts an OpenHands conversation with full issue/PR context, posts acknowledgement comments with a conversation link, and summarises results back to the issue/PR when the agent finishes.",
+  "author": {
+    "name": "OpenHands",
+    "email": "contact@all-hands.dev"
+  },
+  "homepage": "https://github.com/OpenHands/extensions",
+  "repository": "https://github.com/OpenHands/extensions",
+  "license": "MIT",
+  "keywords": [
+    "github",
+    "monitor",
+    "issues",
+    "pull-requests",
+    "trigger",
+    "cron",
+    "automation",
+    "integration"
+  ]
+}

package/skills/github-repo-monitor/SKILL.md

@@ -37,6 +37,10 @@ On every subsequent run:
 
 ---
 
+The script imports shared GitHub transport from
+`scripts/github_client.py`, installed with this skill. Include it beside
+`main.py` when packaging manually, as shown below.
+
 ## Prerequisites
 
 ### Required secret
@@ -181,9 +185,11 @@ constant substitutions near the top of the file:
 | `ALLOWED_GITHUB_LOGINS = ["<TOKEN_OWNER>"]` | `ALLOWED_GITHUB_LOGINS = {allowed_logins_list}` |
 | `DEFAULT_OPENHANDS_URL = "http://localhost:8000"` | `DEFAULT_OPENHANDS_URL = "{url}"` (keep default if the user has no preference) |
 
-Write the customised script to a temporary build directory:
+Run these commands from this skill's directory and write the customised script
+to a temporary build directory:
 ```bash
 mkdir -p /tmp/github-monitor-build
+cp -L scripts/github_client.py /tmp/github-monitor-build/github_client.py
 # (write the customised main.py to /tmp/github-monitor-build/main.py)
 ```
 

package/skills/github-repo-monitor/scripts/github_client.py

@@ -0,0 +1,230 @@
+"""Shared GitHub transport and repository operations for GitHub automations."""
+
+import argparse
+import json
+import os
+import re
+import subprocess
+from functools import cached_property
+from pathlib import Path
+from urllib.error import HTTPError
+from urllib.parse import parse_qsl, urlencode, urlsplit
+from urllib.request import Request, urlopen
+
+
+def _load_secret(name: str) -> str:
+    """Read one named secret from the environment or configured Agent Server."""
+    value = os.environ.get(name)
+    if value:
+        return value
+
+    from openhands.sdk.workspace import RemoteWorkspace
+
+    workspace = RemoteWorkspace(
+        host=os.environ["AGENT_SERVER_URL"],
+        api_key=os.environ["SESSION_API_KEY"],
+        working_dir=os.environ.get("WORKSPACE_BASE", "/workspace"),
+    )
+    try:
+        secret = workspace.get_secrets([name]).get(name)
+        value = secret.get_value() if secret else None
+    finally:
+        workspace.reset_client()
+    if not value:
+        raise ValueError(f"The GitHub credential {name} is unavailable")
+    return value
+
+
+def github_request(
+    token: str,
+    method: str,
+    path: str,
+    params: dict | None = None,
+    body: dict | None = None,
+    accept: str = "application/vnd.github+json",
+) -> tuple:
+    url = f"https://api.github.com{path}"
+    if params:
+        url = f"{url}?{urlencode(params)}"
+    headers = {
+        "Authorization": f"Bearer {token}",
+        "Accept": accept,
+        "X-GitHub-Api-Version": "2022-11-28",
+        "Content-Type": "application/json",
+    }
+    data = json.dumps(body).encode() if body is not None else None
+    req = Request(url, data=data, headers=headers, method=method)
+    with urlopen(req, timeout=90) as r:
+        raw = r.read()
+        return (json.loads(raw) if raw.strip() else {}), dict(r.headers)
+
+
+def github_paginate(token: str, path: str, params: dict | None = None) -> list:
+    results = []
+    base_params = dict(params or {})
+    base_params.setdefault("per_page", 100)
+    for page in range(1, 101):
+        base_params["page"] = page
+        data, _ = github_request(token, "GET", path, params=base_params)
+        if not isinstance(data, list):
+            raise TypeError("Expected a paginated GitHub list")
+        results.extend(data)
+        if len(data) < int(base_params["per_page"]):
+            return results
+    raise RuntimeError("GitHub pagination exceeded limit")
+
+
+class GitHubRepository:
+    name = "GitHub automation"
+
+    def __init__(
+        self,
+        config_path=Path("config.json"),
+        *,
+        github_token_secret,
+        repository=None,
+        conversation=None,
+        dispatcher=None,
+    ):
+        self.config = json.loads(Path(config_path).read_text())
+        self.repository = repository or self.config["repository"]
+        if not re.fullmatch(r"[A-Za-z0-9_.-]+/[A-Za-z0-9_.-]+", self.repository):
+            raise ValueError("repository must be owner/repo")
+        if not re.fullmatch(r"[A-Z_][A-Z0-9_]*", github_token_secret):
+            raise ValueError(
+                "Expected the environment variable containing the GitHub token"
+            )
+        self.token_name = github_token_secret
+        self.token = _load_secret(github_token_secret)
+        self.conversation = conversation
+        self.conversation_id = str(conversation.id) if conversation else None
+        self.dispatcher = dispatcher
+        self.workspace = Path(os.environ["WORKSPACE_BASE"])
+        self.project = self.workspace
+        self.evidence = self.workspace / "evidence"
+        self.evidence.mkdir(exist_ok=True)
+        self._completed_dependencies = {}
+
+    @cached_property
+    def base_branch(self):
+        return self.config.get("base_branch") or self.gh("GET", "")["default_branch"]
+
+    @property
+    def github_instructions(self):
+        return (
+            f"Use `GH_TOKEN=${self.token_name} gh api` for GitHub requests. "
+            "Never print the credential value. "
+            f"Only {self.repository} is in scope. Work in {self.project}. "
+            "Do not modify the automation bundle or its configuration."
+        )
+
+    def gh(self, method, path, body=None):
+        return github_request(
+            self.token, method, f"/repos/{self.repository}" + path, body=body
+        )[0]
+
+    def shell(self, args, cwd=None, timeout=300):
+        result = subprocess.run(
+            args,
+            cwd=cwd or self.project,
+            text=True,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,
+            timeout=timeout,
+            check=False,
+        )
+        if result.returncode:
+            raise RuntimeError(
+                f"{args[0]} failed: {result.stdout[-4000:].replace(self.token, '[REDACTED]')}"
+            )
+        return result.stdout.strip()
+
+    def comment(self, number, text):
+        return self.gh(
+            "POST",
+            f"/issues/{number}/comments",
+            {
+                "body": text
+                + f"\n\nFactory role: `{self.name}`; conversation: `{self.conversation_id}`."
+                + "\n\n_This comment was posted by an AI agent (OpenHands)._"
+            },
+        )
+
+    def open_issues(self):
+        return [
+            i for i in self.gh_pages("/issues?state=open") if "pull_request" not in i
+        ]
+
+    def statuses(self, sha):
+        result = {}
+        for item in self.gh_pages(f"/commits/{sha}/statuses"):
+            result.setdefault(item["context"], item["state"])
+        return result
+
+    def completed_dependency(self, number):
+        if number in self._completed_dependencies:
+            return self._completed_dependencies[number]
+        try:
+            dependency = self.gh("GET", f"/issues/{number}")
+        except HTTPError as exc:
+            if exc.code == 404:
+                return False
+            raise
+        completed = (
+            dependency["state"] == "closed"
+            and dependency.get("state_reason") == "completed"
+        )
+        self._completed_dependencies[number] = completed
+        return completed
+
+    def dependencies_complete(self, issue):
+        """Honor explicit Depends on lines; unknown/incomplete issues remain blocked."""
+        for line in re.findall(
+            "^Depends on:\\s*(.+)$",
+            issue.get("body") or "",
+            re.MULTILINE | re.IGNORECASE,
+        ):
+            for number in re.findall("#(\\d+)", line):
+                if not self.completed_dependency(number):
+                    return False
+        return True
+
+    def gh_pages(self, endpoint):
+        split = urlsplit(endpoint)
+        return github_paginate(
+            self.token,
+            f"/repos/{self.repository}" + split.path,
+            params=dict(parse_qsl(split.query)),
+        )
+
+
+def run_repositories(automation_type, conversation=None, dispatcher=None):
+    parser = argparse.ArgumentParser(description=automation_type.__doc__)
+    parser.add_argument("--github-token-secret")
+    args = parser.parse_args()
+    config = json.loads(Path("config.json").read_text())
+    token_name = args.github_token_secret or config.get(
+        "github_token_secret", "GITHUB_PERSONAL_ACCESS_TOKEN"
+    )
+    repositories = config.get("repos") or [config["repository"]]
+    failures = []
+    for repository in repositories:
+        options = dict(
+            github_token_secret=token_name,
+            repository=repository,
+            conversation=conversation,
+        )
+        if dispatcher is not None:
+            options["dispatcher"] = dispatcher
+        automation = automation_type(**options)
+        try:
+            automation.run()
+        except Exception as exc:  # noqa: BLE001 - one repository must not block others
+            failures.append(repository)
+            print(
+                json.dumps({"repository": repository, "error": type(exc).__name__}),
+                flush=True,
+            )
+    if failures:
+        raise RuntimeError("Automation failed for: " + ", ".join(failures))
+    return str(conversation.id) if conversation else None

package/skills/github-repo-monitor/scripts/main.py

@@ -34,7 +34,10 @@ import time
 import urllib.error
 import urllib.request
 from datetime import datetime, timedelta, timezone
-from urllib.parse import urlencode
+
+from github_client import github_request as _github_request
+from github_client import github_paginate as _github_paginate
+
 
 # ── Embedded configuration (filled in by the skill at creation time) ──────────
 REPO = "owner/repo"                     # e.g. "microsoft/vscode"
@@ -210,51 +213,6 @@ def save_state(state: dict) -> None:
 
 # ── GitHub API helpers ─────────────────────────────────────────────────────────
 
-def _github_request(
-    token: str,
-    method: str,
-    path: str,
-    params: dict | None = None,
-    body: dict | None = None,
-) -> tuple[dict | list, dict]:
-    """Low-level GitHub API call.  Returns (parsed_body, response_headers).
-    Raises urllib.error.HTTPError on non-2xx responses.
-    """
-    base = "https://api.github.com"
-    url = f"{base}{path}"
-    if params:
-        url = f"{url}?{urlencode(params)}"
-    headers = {
-        "Authorization": f"Bearer {token}",
-        "Accept": "application/vnd.github+json",
-        "X-GitHub-Api-Version": "2022-11-28",
-        "Content-Type": "application/json",
-    }
-    data = json.dumps(body).encode() if body is not None else None
-    req = urllib.request.Request(url, data=data, headers=headers, method=method)
-    with urllib.request.urlopen(req) as r:
-        resp_headers = dict(r.headers)
-        raw = r.read()
-        return (json.loads(raw) if raw.strip() else {}), resp_headers
-
-
-def _github_paginate(token: str, path: str, params: dict | None = None) -> list:
-    """Fetch all pages from a GitHub list endpoint."""
-    results = []
-    page = 1
-    base_params = dict(params or {})
-    base_params.setdefault("per_page", 100)
-    while True:
-        base_params["page"] = page
-        data, _ = _github_request(token, "GET", path, params=base_params)
-        if not isinstance(data, list):
-            break
-        results.extend(data)
-        if len(data) < base_params["per_page"]:
-            break
-        page += 1
-    return results
-
 
 def _resolve_github_token() -> str:
     """Fetch GITHUB_PERSONAL_ACCESS_TOKEN from secrets.  Raises RuntimeError if absent."""

package/skills/gitlab/.claude-plugin/plugin.json

@@ -0,0 +1,17 @@
+{
+  "name": "gitlab",
+  "version": "1.0.0",
+  "description": "Interact with GitLab repositories, merge requests, and APIs using the GITLAB_TOKEN environment variable. Use when working with code hosted on GitLab or managing GitLab resources.",
+  "author": {
+    "name": "OpenHands",
+    "email": "contact@all-hands.dev"
+  },
+  "homepage": "https://github.com/OpenHands/extensions",
+  "repository": "https://github.com/OpenHands/extensions",
+  "license": "MIT",
+  "keywords": [
+    "gitlab",
+    "git",
+    "merge-request"
+  ]
+}

package/skills/gitlab/.codex-plugin/plugin.json

@@ -0,0 +1,17 @@
+{
+  "name": "gitlab",
+  "version": "1.0.0",
+  "description": "Interact with GitLab repositories, merge requests, and APIs using the GITLAB_TOKEN environment variable. Use when working with code hosted on GitLab or managing GitLab resources.",
+  "author": {
+    "name": "OpenHands",
+    "email": "contact@all-hands.dev"
+  },
+  "homepage": "https://github.com/OpenHands/extensions",
+  "repository": "https://github.com/OpenHands/extensions",
+  "license": "MIT",
+  "keywords": [
+    "gitlab",
+    "git",
+    "merge-request"
+  ]
+}

package/skills/gitlab-issue-to-mr/.claude-plugin/plugin.json

@@ -0,0 +1,19 @@
+{
+  "name": "gitlab-issue-to-mr",
+  "version": "1.0.0",
+  "description": "Create an automation that implements GitLab issues when a configurable trigger label is applied. It clones the default branch, starts one OpenHands conversation per label event, then commits, pushes, and opens the merge request itself, without ever handing the agent a push credential.",
+  "author": {
+    "name": "OpenHands",
+    "email": "contact@all-hands.dev"
+  },
+  "homepage": "https://github.com/OpenHands/extensions",
+  "repository": "https://github.com/OpenHands/extensions",
+  "license": "MIT",
+  "keywords": [
+    "gitlab",
+    "issue",
+    "merge-request",
+    "automation",
+    "integration"
+  ]
+}

package/skills/gitlab-issue-to-mr/.codex-plugin/plugin.json

@@ -0,0 +1,19 @@
+{
+  "name": "gitlab-issue-to-mr",
+  "version": "1.0.0",
+  "description": "Create an automation that implements GitLab issues when a configurable trigger label is applied. It clones the default branch, starts one OpenHands conversation per label event, then commits, pushes, and opens the merge request itself, without ever handing the agent a push credential.",
+  "author": {
+    "name": "OpenHands",
+    "email": "contact@all-hands.dev"
+  },
+  "homepage": "https://github.com/OpenHands/extensions",
+  "repository": "https://github.com/OpenHands/extensions",
+  "license": "MIT",
+  "keywords": [
+    "gitlab",
+    "issue",
+    "merge-request",
+    "automation",
+    "integration"
+  ]
+}

package/skills/gitlab-issue-to-mr/.plugin/plugin.json

@@ -0,0 +1,19 @@
+{
+  "name": "gitlab-issue-to-mr",
+  "version": "1.0.0",
+  "description": "Create an automation that implements GitLab issues when a configurable trigger label is applied. It clones the default branch, starts one OpenHands conversation per label event, then commits, pushes, and opens the merge request itself, without ever handing the agent a push credential.",
+  "author": {
+    "name": "OpenHands",
+    "email": "contact@all-hands.dev"
+  },
+  "homepage": "https://github.com/OpenHands/extensions",
+  "repository": "https://github.com/OpenHands/extensions",
+  "license": "MIT",
+  "keywords": [
+    "gitlab",
+    "issue",
+    "merge-request",
+    "automation",
+    "integration"
+  ]
+}