instructions per project comments (#2091)

* update instructions for project specific commands

Author: breardon2011

cli/pkg/digger/digger.go

@@ -13,7 +13,6 @@ import (
 	"github.com/diggerhq/digger/libs/backendapi"
 	"github.com/diggerhq/digger/libs/ci"
 	comment_updater "github.com/diggerhq/digger/libs/comment_utils/summary"
-	coreutils "github.com/diggerhq/digger/libs/comment_utils/utils"
 	"github.com/diggerhq/digger/libs/execution"
 	locking2 "github.com/diggerhq/digger/libs/locking"
 	"github.com/diggerhq/digger/libs/policy"
@@ -170,12 +169,12 @@ func RunJobs(jobs []orchestrator.Job, prService ci.PullRequestService, orgServic
 func reportPolicyError(projectName string, command string, requestedBy string, reporter reporting.Reporter) string {
 	msg := fmt.Sprintf("User %s is not allowed to perform action: %s. Check your policies :x:", requestedBy, command)
 	if reporter.SupportsMarkdown() {
-		_, _, err := reporter.Report(msg, coreutils.AsCollapsibleComment(fmt.Sprintf("Policy violation for <b>%v - %v</b>", projectName, command), false))
+		_, _, err := reporter.Report(msg, reporting.AsCollapsibleComment(fmt.Sprintf("Policy violation for <b>%v - %v</b>", projectName, command), false))
 		if err != nil {
 			slog.Error("Error publishing comment", "error", err)
 		}
 	} else {
-		_, _, err := reporter.Report(msg, coreutils.AsComment(fmt.Sprintf("Policy violation for %v - %v", projectName, command)))
+		_, _, err := reporter.Report(msg, reporting.AsComment(fmt.Sprintf("Policy violation for %v - %v", projectName, command)))
 		if err != nil {
 			slog.Error("Error publishing comment", "error", err)
 		}
@@ -295,9 +294,9 @@ func run(command string, job orchestrator.Job, policyChecker policy.Checker, org
 				var planPolicyFormatter func(report string) string
 				summary := fmt.Sprintf("Terraform plan validation check (%v)", job.ProjectName)
 				if reporter.SupportsMarkdown() {
-					planPolicyFormatter = coreutils.AsCollapsibleComment(summary, false)
+					planPolicyFormatter = reporting.AsCollapsibleComment(summary, false)
 				} else {
-					planPolicyFormatter = coreutils.AsComment(summary)
+					planPolicyFormatter = reporting.AsComment(summary)
 				}
 
 				planSummary, err := iacUtils.GetSummarizePlan(planJsonOutput)
@@ -326,6 +325,10 @@ func run(command string, job orchestrator.Job, policyChecker policy.Checker, org
 						slog.Error("Failed to report plan.", "error", err)
 					}
 					reportPlanSummary(reporter, planSummary)
+
+					if err := reporting.FormatAndReportExampleCommands(job.ProjectName, reporter); err != nil {
+						slog.Error("Failed to report example commands.", "error", err)
+					}
 				}
 			} else {
 				reportEmptyPlanOutput(reporter, projectLock.LockId())
@@ -497,12 +500,12 @@ func reportApplyMergeabilityError(reporter reporting.Reporter) string {
 	slog.Error(comment)
 
 	if reporter.SupportsMarkdown() {
-		_, _, err := reporter.Report(comment, coreutils.AsCollapsibleComment("Apply error", false))
+		_, _, err := reporter.Report(comment, reporting.AsCollapsibleComment("Apply error", false))
 		if err != nil {
 			slog.Error("error publishing comment", "error", err)
 		}
 	} else {
-		_, _, err := reporter.Report(comment, coreutils.AsComment("Apply error"))
+		_, _, err := reporter.Report(comment, reporting.AsComment("Apply error"))
 		if err != nil {
 			slog.Error("error publishing comment", "error", err)
 		}
@@ -514,9 +517,9 @@ func reportTerraformPlanOutput(reporter reporting.Reporter, projectId string, pl
 	var formatter func(string) string
 
 	if reporter.SupportsMarkdown() {
-		formatter = coreutils.GetTerraformOutputAsCollapsibleComment("Plan output", true)
+		formatter = reporting.GetTerraformOutputAsCollapsibleComment("Plan output", true)
 	} else {
-		formatter = coreutils.GetTerraformOutputAsComment("Plan output")
+		formatter = reporting.GetTerraformOutputAsComment("Plan output")
 	}
 
 	_, _, err := reporter.Report(plan, formatter)
@@ -529,9 +532,9 @@ func reportPlanSummary(reporter reporting.Reporter, summary string) {
 	var formatter func(string) string
 
 	if reporter.SupportsMarkdown() {
-		formatter = coreutils.AsCollapsibleComment("Plan summary", false)
+		formatter = reporting.AsCollapsibleComment("Plan summary", false)
 	} else {
-		formatter = coreutils.AsComment("Plan summary")
+		formatter = reporting.AsComment("Plan summary")
 	}
 
 	_, _, err := reporter.Report("\n"+summary, formatter)

libs/comment_utils/utils/comments.go renamed to libs/comment_utils/reporting/comments.go

@@ -1,6 +1,8 @@
-package utils
+package reporting
 
-import "fmt"
+import (
+	"fmt"
+)
 
 func GetTerraformOutputAsCollapsibleComment(summary string, open bool) func(string) string {
 	var openTag string

libs/comment_utils/reporting/instructions.go

@@ -0,0 +1,50 @@
+package reporting
+
+import (
+	"fmt"
+	"strings"
+)
+
+func FormatAndReportExampleCommands(projectName string, reporter Reporter) error {
+	// Escape special shell characters to prevent command injection
+	escapedProjectName := strings.NewReplacer(
+		"`", "\\`",
+		" ", "\\ ",
+		"\"", "\\\"",
+		"'", "\\'",
+		"$", "\\$",
+		"&", "\\&",
+		"|", "\\|",
+		";", "\\;",
+		"(", "\\(",
+		")", "\\)",
+	).Replace(projectName)
+
+	commands := fmt.Sprintf(`
+▶️ To apply these changes, run the following command:
+
+`+"```"+`bash
+digger apply -p %s
+`+"```"+`
+
+⏩ To apply all changes in this PR:
+`+"```"+`bash
+digger apply
+`+"```"+`
+
+🚮 To unlock all projects in this PR:
+`+"```"+`bash
+digger unlock
+`+"```"+`
+`, escapedProjectName)
+
+	var formatter func(string) string
+	if reporter.SupportsMarkdown() {
+		formatter = AsCollapsibleComment("Instructions", false)
+	} else {
+		formatter = AsComment("Instructions")
+	}
+
+	_, _, err := reporter.Report(commands, formatter)
+	return err
+}

libs/comment_utils/reporting/reporting.go

@@ -7,7 +7,6 @@ import (
 	"time"
 
 	"github.com/diggerhq/digger/libs/ci"
-	"github.com/diggerhq/digger/libs/comment_utils/utils"
 )
 
 type CiReporter struct {
@@ -147,9 +146,9 @@ func upsertComment(ciService ci.PullRequestService, PrNumber int, report string,
 	if commentIdForThisRun == "" {
 		var commentMessage string
 		if !supportsCollapsible {
-			commentMessage = utils.AsComment(reportTitle)(report)
+			commentMessage = AsComment(reportTitle)(report)
 		} else {
-			commentMessage = utils.AsCollapsibleComment(reportTitle, false)(report)
+			commentMessage = AsCollapsibleComment(reportTitle, false)(report)
 		}
 		comment, err := ciService.PublishComment(PrNumber, commentMessage)
 		if err != nil {
@@ -168,9 +167,9 @@ func upsertComment(ciService ci.PullRequestService, PrNumber int, report string,
 
 	var completeComment string
 	if !supportsCollapsible {
-		completeComment = utils.AsComment(reportTitle)(commentBody)
+		completeComment = AsComment(reportTitle)(commentBody)
 	} else {
-		completeComment = utils.AsCollapsibleComment(reportTitle, false)(commentBody)
+		completeComment = AsCollapsibleComment(reportTitle, false)(commentBody)
 	}
 
 	err := ciService.EditComment(PrNumber, commentIdForThisRun, completeComment)

libs/comment_utils/reporting/source_grouping.go

@@ -6,7 +6,6 @@ import (
 	"log/slog"
 
 	"github.com/diggerhq/digger/libs/ci"
-	"github.com/diggerhq/digger/libs/comment_utils/utils"
 	"github.com/diggerhq/digger/libs/digger_config"
 	"github.com/diggerhq/digger/libs/iac_utils"
 	"github.com/diggerhq/digger/libs/scheduler"
@@ -94,7 +93,7 @@ func (r SourceGroupingReporter) UpdateComment(sourceDetails []SourceDetails, loc
 			continue
 		}
 		expanded := i == 0 || !allSimilarInGroup
-		commenter := utils.GetTerraformOutputAsCollapsibleComment(fmt.Sprintf("Plan for %v", project), expanded)
+		commenter := GetTerraformOutputAsCollapsibleComment(fmt.Sprintf("Plan for %v", project), expanded)
 		message = message + commenter(terraformOutputs[project]) + "\n"
 	}
 

libs/execution/execution.go

@@ -10,7 +10,6 @@ import (
 	"strconv"
 	"strings"
 
-	"github.com/diggerhq/digger/libs/comment_utils/utils"
 	"github.com/diggerhq/digger/libs/iac_utils"
 	"github.com/diggerhq/digger/libs/locking"
 	"github.com/diggerhq/digger/libs/scheduler"
@@ -345,12 +344,12 @@ func (d DiggerExecutor) postProcessPlan(stdout string) (string, string, *iac_uti
 
 func reportError(r reporting.Reporter, stderr string) {
 	if r.SupportsMarkdown() {
-		_, _, commentErr := r.Report(stderr, utils.AsCollapsibleComment("Error during init.", false))
+		_, _, commentErr := r.Report(stderr, reporting.AsCollapsibleComment("Error during init.", false))
 		if commentErr != nil {
 			slog.Error("error publishing comment", "error", commentErr)
 		}
 	} else {
-		_, _, commentErr := r.Report(stderr, utils.AsComment("Error during init."))
+		_, _, commentErr := r.Report(stderr, reporting.AsComment("Error during init."))
 		if commentErr != nil {
 			slog.Error("error publishing comment", "error", commentErr)
 		}
@@ -439,12 +438,12 @@ func (d DiggerExecutor) Apply() (*iac_utils.IacSummary, bool, string, error) {
 
 func reportApplyError(r reporting.Reporter, err error) {
 	if r.SupportsMarkdown() {
-		_, _, commentErr := r.Report(err.Error(), utils.AsCollapsibleComment("Error during applying.", false))
+		_, _, commentErr := r.Report(err.Error(), reporting.AsCollapsibleComment("Error during applying.", false))
 		if commentErr != nil {
 			slog.Error("error publishing comment", "error", err)
 		}
 	} else {
-		_, _, commentErr := r.Report(err.Error(), utils.AsComment("Error during applying."))
+		_, _, commentErr := r.Report(err.Error(), reporting.AsComment("Error during applying."))
 		if commentErr != nil {
 			slog.Error("error publishing comment", "error", err)
 		}
@@ -454,9 +453,9 @@ func reportApplyError(r reporting.Reporter, err error) {
 func reportTerraformApplyOutput(r reporting.Reporter, projectId string, applyOutput string) {
 	var formatter func(string) string
 	if r.SupportsMarkdown() {
-		formatter = utils.GetTerraformOutputAsCollapsibleComment("Apply output", false)
+		formatter = reporting.GetTerraformOutputAsCollapsibleComment("Apply output", false)
 	} else {
-		formatter = utils.GetTerraformOutputAsComment("Apply output")
+		formatter = reporting.GetTerraformOutputAsComment("Apply output")
 	}
 
 	_, _, commentErr := r.Report(applyOutput, formatter)
@@ -467,12 +466,12 @@ func reportTerraformApplyOutput(r reporting.Reporter, projectId string, applyOut
 
 func reportTerraformError(r reporting.Reporter, stderr string) {
 	if r.SupportsMarkdown() {
-		_, _, commentErr := r.Report(stderr, utils.GetTerraformOutputAsCollapsibleComment("Error during init.", false))
+		_, _, commentErr := r.Report(stderr, reporting.GetTerraformOutputAsCollapsibleComment("Error during init.", false))
 		if commentErr != nil {
 			slog.Error("error publishing comment", "error", commentErr)
 		}
 	} else {
-		_, _, commentErr := r.Report(stderr, utils.GetTerraformOutputAsComment("Error during init."))
+		_, _, commentErr := r.Report(stderr, reporting.GetTerraformOutputAsComment("Error during init."))
 		if commentErr != nil {
 			slog.Error("error publishing comment", "error", commentErr)
 		}
@@ -482,9 +481,9 @@ func reportTerraformError(r reporting.Reporter, stderr string) {
 func reportAdditionalOutput(r reporting.Reporter, projectId string) {
 	var formatter func(string) string
 	if r.SupportsMarkdown() {
-		formatter = utils.GetTerraformOutputAsCollapsibleComment("Additional output for <b>"+projectId+"</b>", false)
+		formatter = reporting.GetTerraformOutputAsCollapsibleComment("Additional output for <b>"+projectId+"</b>", false)
 	} else {
-		formatter = utils.GetTerraformOutputAsComment("Additional output for " + projectId)
+		formatter = reporting.GetTerraformOutputAsComment("Additional output for " + projectId)
 	}
 	diggerOutPath := os.Getenv("DIGGER_OUT")
 	if _, err := os.Stat(diggerOutPath); err == nil {

libs/locking/locking.go

@@ -10,7 +10,6 @@ import (
 	"strings"
 
 	"github.com/diggerhq/digger/libs/ci"
-	"github.com/diggerhq/digger/libs/comment_utils/utils"
 	"github.com/diggerhq/digger/libs/locking/aws"
 	"github.com/diggerhq/digger/libs/locking/azure"
 	"github.com/diggerhq/digger/libs/locking/gcp"
@@ -96,12 +95,12 @@ func (projectLock *PullRequestLock) Lock() (bool, error) {
 
 func reportLockingFailed(r reporting.Reporter, comment string) {
 	if r.SupportsMarkdown() {
-		_, _, err := r.Report(comment, utils.AsCollapsibleComment("Locking failed", false))
+		_, _, err := r.Report(comment, reporting.AsCollapsibleComment("Locking failed", false))
 		if err != nil {
 			slog.Error("Failed to publish comment", "error", err)
 		}
 	} else {
-		_, _, err := r.Report(comment, utils.AsComment("Locking failed"))
+		_, _, err := r.Report(comment, reporting.AsComment("Locking failed"))
 		if err != nil {
 			slog.Error("Failed to publish comment", "error", err)
 		}
@@ -173,12 +172,12 @@ func (projectLock *PullRequestLock) Unlock() (bool, error) {
 
 func reportSuccessfulUnlocking(r reporting.Reporter, comment string) {
 	if r.SupportsMarkdown() {
-		_, _, err := r.Report(comment, utils.AsCollapsibleComment("Unlocking successful", false))
+		_, _, err := r.Report(comment, reporting.AsCollapsibleComment("Unlocking successful", false))
 		if err != nil {
 			slog.Error("Failed to publish comment", "error", err)
 		}
 	} else {
-		_, _, err := r.Report(comment, utils.AsComment("Unlocking successful"))
+		_, _, err := r.Report(comment, reporting.AsComment("Unlocking successful"))
 		if err != nil {
 			slog.Error("Failed to publish comment", "error", err)
 		}