feat(github): add configurable GitOps command prefix

- Users can set a GitOps command prefix in the Repository CR
  to run /<prefix> test, /<prefix> retest, /<prefix> cancel.
- Configure prefix in Repository CR's settings field.
- Apply prefix-aware matching for GitHub issue/commit comments,
  including ok-to-test SHA validation and target selection.
- Update repo schema/docs and opscomments helpers for prefixed
  regex matching and command extraction.
- Add provider parse tests and e2e coverage for GitHub prefix
  flows to validate behavior end-to-end.
- Add documentation explaining the feature thoroughly.

https://issues.redhat.com/browse/SRVKP-7197

Signed-off-by: Zaki Shaikh <zashaikh@redhat.com>

Author: zakisk

config/300-repositories.yaml

@@ -507,6 +507,11 @@ spec:
                             - update
                           type: string
                       type: object
+                    gitops_command_prefix:
+                      description: |-
+                        GitOpsCommandPrefix configures the prefix for the GitOps command.
+                        This is used to identify the GitOps command in the PipelineRun.
+                      type: string
                     pipelinerun_provenance:
                       description: |-
                         PipelineRunProvenance configures how PipelineRun definitions are fetched.

docs/content/docs/guides/gitops-commands/advanced.md

@@ -46,6 +46,47 @@ This ensures the comment is correctly formatted when processed.
 
 For a practical example, see the [pac-boussole](https://github.com/openshift-pipelines/pac-boussole) project, which uses the `on-comment` annotation to create a PipelineRun experience similar to [Prow](https://docs.prow.k8s.io/).
 
+## GitOps Command Prefix
+
+{{< support_matrix github_app="true" github_webhook="true" forgejo="false" gitlab="false" bitbucket_cloud="false" bitbucket_datacenter="false" >}}
+
+You can configure a custom prefix for GitOps commands in the Repository CR. This allows you to use commands like `/pac test` instead of the standard `/test`. This is useful when both [prow](https://docs.prow.k8s.io/) CI and Pipelines-as-Code are configured on a Repository and making comments causes issues and confusion.
+
+Please note that custom GitOps commands are excluded from this prefix settings.
+
+To configure a custom GitOps command prefix, set the `gitops_command_prefix` field in your Repository CR's `settings` section:
+
+```yaml
+apiVersion: "pipelinesascode.tekton.dev/v1alpha1"
+kind: Repository
+metadata:
+  name: my-repository
+  namespace: pipelines-as-code
+spec:
+  url: "https://github.com/organization/repository"
+  settings:
+    gitops_command_prefix: "pac"
+```
+
+Note: Set the prefix as a plain word (e.g. `pac`). The Forward slash (`/`) is added automatically by Pipelines-as-Code.
+
+With this configuration, you can use the following prefixed commands:
+
+- `/pac test` - Trigger all matching PipelineRuns
+- `/pac test <pipelinerun-name>` - Trigger a specific PipelineRun
+- `/pac retest` - Retest failed PipelineRuns
+- `/pac retest <pipelinerun-name>` - Retest specific PipelineRun
+- `/pac cancel` - Cancel all running PipelineRuns
+- `/pac cancel <pipelinerun-name>` - Cancel Specific PipelineRun
+- `/pac ok-to-test` - Approve CI for external contributors
+- `/pac ok-to-test SHA` - Approve CI for external contributors for a specific SHA
+
+Example:
+
+```text
+/pac test
+```
+
 ## Cancelling a PipelineRun
 
 **What it does:** The `/cancel` command stops running PipelineRuns by commenting on the pull request.

pkg/apis/pipelinesascode/v1alpha1/types.go

@@ -150,6 +150,11 @@ type Settings struct {
 	// +kubebuilder:validation:Enum=source;default_branch
 	PipelineRunProvenance string `json:"pipelinerun_provenance,omitempty"`
 
+	// GitOpsCommandPrefix configures the prefix for the GitOps command.
+	// This is used to identify the GitOps command in the PipelineRun.
+	// +optional
+	GitOpsCommandPrefix string `json:"gitops_command_prefix,omitempty"`
+
 	// Policy defines authorization policies for the repository, controlling who can
 	// trigger PipelineRuns under different conditions.
 	// +optional

pkg/opscomments/comments.go

@@ -5,23 +5,11 @@ import (
 	"regexp"
 	"strings"
 
-	"go.uber.org/zap"
-
-	"github.com/openshift-pipelines/pipelines-as-code/pkg/acl"
 	"github.com/openshift-pipelines/pipelines-as-code/pkg/apis/pipelinesascode/v1alpha1"
 	"github.com/openshift-pipelines/pipelines-as-code/pkg/events"
 	"github.com/openshift-pipelines/pipelines-as-code/pkg/params/info"
 	"github.com/openshift-pipelines/pipelines-as-code/pkg/params/triggertype"
-)
-
-var (
-	testAllRegex      = regexp.MustCompile(`(?m)^/test\s*$`)
-	retestAllRegex    = regexp.MustCompile(`(?m)^/retest\s*$`)
-	testSingleRegex   = regexp.MustCompile(`(?m)^/test[ \t]+\S+`)
-	retestSingleRegex = regexp.MustCompile(`(?m)^/retest[ \t]+\S+`)
-	oktotestRegex     = regexp.MustCompile(acl.OKToTestCommentRegexp)
-	cancelAllRegex    = regexp.MustCompile(`(?m)^(/cancel)\s*$`)
-	cancelSingleRegex = regexp.MustCompile(`(?m)^(/cancel)[ \t]+\S+`)
+	"go.uber.org/zap"
 )
 
 type EventType string
@@ -42,56 +30,93 @@ var (
 	OkToTestCommentEventType     = EventType("ok-to-test-comment")
 )
 
-const (
-	testComment   = "/test"
-	retestComment = "/retest"
-	cancelComment = "/cancel"
-)
+func RetestAllRegex(prefix string) *regexp.Regexp {
+	return regexp.MustCompile(fmt.Sprintf(`(?m)^\s*%sretest\s*$`, prefix))
+}
+
+func RetestSingleRegex(prefix string) *regexp.Regexp {
+	return regexp.MustCompile(fmt.Sprintf(`(?m)^\s*%sretest[ \t]+\S+`, prefix))
+}
+
+func TestAllRegex(prefix string) *regexp.Regexp {
+	return regexp.MustCompile(fmt.Sprintf(`(?m)^\s*%stest\s*$`, prefix))
+}
+
+func TestSingleRegex(prefix string) *regexp.Regexp {
+	return regexp.MustCompile(fmt.Sprintf(`(?m)^\s*%stest[ \t]+\S+`, prefix))
+}
+
+func OkToTestRegex(prefix string) *regexp.Regexp {
+	return regexp.MustCompile(fmt.Sprintf(`(^|\n)\s*%sok-to-test(?:\s+([a-fA-F0-9]{7,40}))?\s*(\r\n|\r|\n|$)`, prefix))
+}
+
+func CancelAllRegex(prefix string) *regexp.Regexp {
+	return regexp.MustCompile(fmt.Sprintf(`(?m)^\s*%scancel\s*$`, prefix))
+}
+
+func CancelSingleRegex(prefix string) *regexp.Regexp {
+	return regexp.MustCompile(fmt.Sprintf(`(?m)^\s*%scancel[ \t]+\S+`, prefix))
+}
 
-func CommentEventType(comment string) EventType {
+func CommentEventType(comment, prefix string) EventType {
 	switch {
-	case retestAllRegex.MatchString(comment):
+	case RetestAllRegex(prefix).MatchString(comment):
 		return RetestAllCommentEventType
-	case retestSingleRegex.MatchString(comment):
+	case RetestSingleRegex(prefix).MatchString(comment):
 		return RetestSingleCommentEventType
-	case testAllRegex.MatchString(comment):
+	case TestAllRegex(prefix).MatchString(comment):
 		return TestAllCommentEventType
-	case testSingleRegex.MatchString(comment):
+	case TestSingleRegex(prefix).MatchString(comment):
 		return TestSingleCommentEventType
-	case oktotestRegex.MatchString(comment):
+	case OkToTestRegex(prefix).MatchString(comment):
 		return OkToTestCommentEventType
-	case cancelAllRegex.MatchString(comment):
+	case CancelAllRegex(prefix).MatchString(comment):
 		return CancelCommentAllEventType
-	case cancelSingleRegex.MatchString(comment):
+	case CancelSingleRegex(prefix).MatchString(comment):
 		return CancelCommentSingleEventType
 	default:
 		return NoOpsCommentEventType
 	}
 }
 
 // SetEventTypeAndTargetPR function will set the event type and target test pipeline run in an event.
-func SetEventTypeAndTargetPR(event *info.Event, comment string) {
-	commentType := CommentEventType(comment)
-	if commentType == RetestSingleCommentEventType || commentType == TestSingleCommentEventType {
-		event.TargetTestPipelineRun = GetPipelineRunFromTestComment(comment)
+func SetEventTypeAndTargetPR(event *info.Event, comment, prefix string) {
+	commentType := CommentEventType(comment, prefix)
+	if commentType == RetestSingleCommentEventType {
+		typeOfComment := prefix + "retest"
+		event.TargetTestPipelineRun = getNameFromComment(typeOfComment, comment)
+	}
+	if commentType == TestSingleCommentEventType {
+		typeOfComment := prefix + "test"
+		event.TargetTestPipelineRun = getNameFromComment(typeOfComment, comment)
 	}
 	if commentType == CancelCommentAllEventType || commentType == CancelCommentSingleEventType {
 		event.CancelPipelineRuns = true
 	}
 	if commentType == CancelCommentSingleEventType {
-		event.TargetCancelPipelineRun = GetPipelineRunFromCancelComment(comment)
+		typeOfComment := prefix + "cancel"
+		event.TargetCancelPipelineRun = getNameFromComment(typeOfComment, comment)
 	}
 	event.EventType = commentType.String()
 	event.TriggerComment = comment
 }
 
-func IsOkToTestComment(comment string) bool {
-	return oktotestRegex.MatchString(comment)
+func IsOkToTestComment(comment, prefix string) bool {
+	return OkToTestRegex(prefix).MatchString(comment)
+}
+
+func IsTestRetestComment(comment, prefix string) bool {
+	return TestSingleRegex(prefix).MatchString(comment) || TestAllRegex(prefix).MatchString(comment) ||
+		RetestSingleRegex(prefix).MatchString(comment) || RetestAllRegex(prefix).MatchString(comment)
+}
+
+func IsCancelComment(comment, prefix string) bool {
+	return CancelAllRegex(prefix).MatchString(comment) || CancelSingleRegex(prefix).MatchString(comment)
 }
 
 // GetSHAFromOkToTestComment extracts the optional SHA from an /ok-to-test comment.
-func GetSHAFromOkToTestComment(comment string) string {
-	matches := oktotestRegex.FindStringSubmatch(comment)
+func GetSHAFromOkToTestComment(comment, prefix string) string {
+	matches := OkToTestRegex(prefix).FindStringSubmatch(comment)
 	if len(matches) > 2 {
 		return strings.TrimSpace(matches[2])
 	}
@@ -143,17 +168,6 @@ func AnyOpsKubeLabelInSelector() string {
 		OnCommentEventType.String())
 }
 
-func GetPipelineRunFromTestComment(comment string) string {
-	if strings.Contains(comment, testComment) {
-		return getNameFromComment(testComment, comment)
-	}
-	return getNameFromComment(retestComment, comment)
-}
-
-func GetPipelineRunFromCancelComment(comment string) string {
-	return getNameFromComment(cancelComment, comment)
-}
-
 func getNameFromComment(typeOfComment, comment string) string {
 	splitTest := strings.Split(strings.TrimSpace(comment), typeOfComment)
 	if len(splitTest) < 2 {
@@ -171,48 +185,3 @@ func getNameFromComment(typeOfComment, comment string) string {
 	// trim spaces
 	return strings.TrimSpace(firstArg[1])
 }
-
-func GetPipelineRunAndBranchNameFromTestComment(comment string) (string, string, error) {
-	if strings.Contains(comment, testComment) {
-		return getPipelineRunAndBranchNameFromComment(testComment, comment)
-	}
-	return getPipelineRunAndBranchNameFromComment(retestComment, comment)
-}
-
-func GetPipelineRunAndBranchNameFromCancelComment(comment string) (string, string, error) {
-	return getPipelineRunAndBranchNameFromComment(cancelComment, comment)
-}
-
-// getPipelineRunAndBranchNameFromComment function will take GitOps comment and split the comment
-// by /test, /retest or /cancel to return branch name and pipelinerun name.
-func getPipelineRunAndBranchNameFromComment(typeOfComment, comment string) (string, string, error) {
-	var prName, branchName string
-	splitTest := strings.Split(comment, typeOfComment)
-
-	// after the split get the second part of the typeOfComment (/test, /retest or /cancel)
-	// as second part can be branch name or pipelinerun name and branch name
-	// ex: /test branch:nightly, /test prname branch:nightly
-	if splitTest[1] != "" && strings.Contains(splitTest[1], ":") {
-		branchData := strings.Split(splitTest[1], ":")
-
-		// make sure no other word is supported other than branch word
-		if !strings.Contains(branchData[0], "branch") {
-			return prName, branchName, fmt.Errorf("the GitOps comment%s does not contain a branch word", branchData[0])
-		}
-		branchName = strings.Split(strings.TrimSpace(branchData[1]), " ")[0]
-
-		// if data after the split contains prname then fetch that
-		prData := strings.Split(strings.TrimSpace(branchData[0]), " ")
-		if len(prData) > 1 {
-			prName = strings.TrimSpace(prData[0])
-		}
-	} else {
-		// get the second part of the typeOfComment (/test, /retest or /cancel)
-		// as second part contains pipelinerun name
-		// ex: /test prname
-		getFirstLine := strings.Split(splitTest[1], "\n")
-		// trim spaces
-		prName = strings.TrimSpace(getFirstLine[0])
-	}
-	return prName, branchName, nil
-}