publish ai summaries

backend/controllers/github.go

@@ -511,7 +511,18 @@ func handlePullRequestEvent(gh utils.GithubClientProvider, payload *github.PullR
 		log.Printf("strconv.ParseInt error: %v", err)
 		commentReporterManager.UpdateComment(fmt.Sprintf(":x: could not handle commentId: %v", err))
 	}
-	batchId, _, err := utils.ConvertJobsToDiggerJobs(*diggerCommand, models.DiggerVCSGithub, organisationId, impactedJobsMap, impactedProjectsMap, projectsGraph, installationId, branch, prNumber, repoOwner, repoName, repoFullName, commitSha, commentId, diggerYmlStr, 0)
+
+	var aiSummaryCommentId = ""
+	if config.Reporting.AiSummary {
+		aiSummaryComment, err := ghService.PublishComment(prNumber, "AI Summary will be posted here after completion")
+		if err != nil {
+			log.Printf("could not post ai summary comment: %v", err)
+			commentReporterManager.UpdateComment(fmt.Sprintf(":x: could not post ai comment summary comment id: %v", err))
+		}
+		aiSummaryCommentId = aiSummaryComment.Id
+	}
+
+	batchId, _, err := utils.ConvertJobsToDiggerJobs(*diggerCommand, models.DiggerVCSGithub, organisationId, impactedJobsMap, impactedProjectsMap, projectsGraph, installationId, branch, prNumber, repoOwner, repoName, repoFullName, commitSha, commentId, diggerYmlStr, 0, aiSummaryCommentId, config.ReportTerraformOutputs)
 	if err != nil {
 		log.Printf("ConvertJobsToDiggerJobs error: %v", err)
 		commentReporterManager.UpdateComment(fmt.Sprintf(":x: ConvertJobsToDiggerJobs error: %v", err))
@@ -902,7 +913,17 @@ func handleIssueCommentEvent(gh utils.GithubClientProvider, payload *github.Issu
 		return fmt.Errorf("comment reporter error: %v", err)
 	}
 
-	batchId, _, err := utils.ConvertJobsToDiggerJobs(*diggerCommand, "github", orgId, impactedProjectsJobMap, impactedProjectsMap, projectsGraph, installationId, *branch, issueNumber, repoOwner, repoName, repoFullName, *commitSha, reporterCommentId, diggerYmlStr, 0)
+	var aiSummaryCommentId = ""
+	if config.Reporting.AiSummary {
+		aiSummaryComment, err := ghService.PublishComment(issueNumber, "AI Summary will be posted here after completion")
+		if err != nil {
+			log.Printf("could not post ai summary comment: %v", err)
+			commentReporterManager.UpdateComment(fmt.Sprintf(":x: could not post ai comment summary comment id: %v", err))
+		}
+		aiSummaryCommentId = aiSummaryComment.Id
+	}
+
+	batchId, _, err := utils.ConvertJobsToDiggerJobs(*diggerCommand, "github", orgId, impactedProjectsJobMap, impactedProjectsMap, projectsGraph, installationId, *branch, issueNumber, repoOwner, repoName, repoFullName, *commitSha, reporterCommentId, diggerYmlStr, 0, aiSummaryCommentId, config.ReportTerraformOutputs)
 	if err != nil {
 		log.Printf("ConvertJobsToDiggerJobs error: %v", err)
 		commentReporterManager.UpdateComment(fmt.Sprintf(":x: ConvertJobsToDiggerJobs error: %v", err))

backend/controllers/github_test.go

@@ -731,7 +731,7 @@ func TestJobsTreeWithOneJobsAndTwoProjects(t *testing.T) {
 	graph, err := configuration.CreateProjectDependencyGraph(projects)
 	assert.NoError(t, err)
 
-	_, result, err := utils.ConvertJobsToDiggerJobs("", "github", 1, jobs, projectMap, graph, 41584295, "", 2, "diggerhq", "parallel_jobs_demo", "diggerhq/parallel_jobs_demo", "", 123, "test", 0)
+	_, result, err := utils.ConvertJobsToDiggerJobs("", "github", 1, jobs, projectMap, graph, 41584295, "", 2, "diggerhq", "parallel_jobs_demo", "diggerhq/parallel_jobs_demo", "", 123, "test", 0, "", false)
 	assert.NoError(t, err)
 	assert.Equal(t, 1, len(result))
 	parentLinks, err := models.DB.GetDiggerJobParentLinksChildId(&result["dev"].DiggerJobID)
@@ -760,7 +760,7 @@ func TestJobsTreeWithTwoDependantJobs(t *testing.T) {
 	projectMap["dev"] = project1
 	projectMap["prod"] = project2
 
-	_, result, err := utils.ConvertJobsToDiggerJobs("", "github", 1, jobs, projectMap, graph, 123, "", 2, "", "", "test", "", 123, "test", 0)
+	_, result, err := utils.ConvertJobsToDiggerJobs("", "github", 1, jobs, projectMap, graph, 123, "", 2, "", "", "test", "", 123, "test", 0, "", false)
 	assert.NoError(t, err)
 	assert.Equal(t, 2, len(result))
 
@@ -793,7 +793,7 @@ func TestJobsTreeWithTwoIndependentJobs(t *testing.T) {
 	projectMap["dev"] = project1
 	projectMap["prod"] = project2
 
-	_, result, err := utils.ConvertJobsToDiggerJobs("", "github", 1, jobs, projectMap, graph, 123, "", 2, "", "", "test", "", 123, "test", 0)
+	_, result, err := utils.ConvertJobsToDiggerJobs("", "github", 1, jobs, projectMap, graph, 123, "", 2, "", "", "test", "", 123, "test", 0, "", false)
 	assert.NoError(t, err)
 	assert.Equal(t, 2, len(result))
 	parentLinks, err := models.DB.GetDiggerJobParentLinksChildId(&result["dev"].DiggerJobID)
@@ -838,7 +838,7 @@ func TestJobsTreeWithThreeLevels(t *testing.T) {
 	projectMap["555"] = project5
 	projectMap["666"] = project6
 
-	_, result, err := utils.ConvertJobsToDiggerJobs("", "github", 1, jobs, projectMap, graph, 123, "", 2, "", "", "test", "", 123, "test", 0)
+	_, result, err := utils.ConvertJobsToDiggerJobs("", "github", 1, jobs, projectMap, graph, 123, "", 2, "", "", "test", "", 123, "test", 0, "", false)
 	assert.NoError(t, err)
 	assert.Equal(t, 6, len(result))
 	parentLinks, err := models.DB.GetDiggerJobParentLinksChildId(&result["111"].DiggerJobID)

backend/controllers/projects.go

@@ -17,6 +17,7 @@ import (
 	"gorm.io/gorm"
 	"log"
 	"net/http"
+	"os"
 	"strconv"
 	"strings"
 	"time"
@@ -323,7 +324,6 @@ type SetJobStatusRequest struct {
 	Footprint       *iac_utils.IacPlanFootprint `json:"job_plan_footprint"`
 	PrCommentUrl    string                      `json:"pr_comment_url"`
 	TerraformOutput string                      `json:"terraform_output"`
-
 }
 
 func (d DiggerController) SetJobStatusForProject(c *gin.Context) {
@@ -488,6 +488,12 @@ func (d DiggerController) SetJobStatusForProject(c *gin.Context) {
 		c.JSON(http.StatusInternalServerError, gin.H{"error": "Error merging PR with automerge option"})
 	}
 
+	err = CreateTerraformPlansSummary(d.GithubClientProvider, batch)
+	if err != nil {
+		log.Printf("could not generate terraform plans summary: %v", err)
+		c.JSON(http.StatusInternalServerError, gin.H{"error": "could not generate terraform plans summary"})
+	}
+
 	// return batch summary to client
 	res, err := batch.MapToJsonStruct()
 	if err != nil {
@@ -648,6 +654,58 @@ func GetPrServiceFromBatch(batch *models.DiggerBatch, gh utils.GithubClientProvi
 	return nil, fmt.Errorf("could not retrieive a service for %v", batch.VCS)
 }
 
+func CreateTerraformPlansSummary(gh utils.GithubClientProvider, batch *models.DiggerBatch) error {
+	diggerYmlString := batch.DiggerConfig
+	diggerConfigYml, err := digger_config.LoadDiggerConfigYamlFromString(diggerYmlString)
+	if err != nil {
+		log.Printf("Error loading digger config from batch: %v", err)
+		return fmt.Errorf("error loading digger config from batch: %v", err)
+	}
+
+	config, _, err := digger_config.ConvertDiggerYamlToConfig(diggerConfigYml)
+
+	if batch.Status == orchestrator_scheduler.BatchJobSucceeded && config.Reporting.AiSummary == true {
+		prService, err := GetPrServiceFromBatch(batch, gh)
+		if err != nil {
+			log.Printf("Error getting github service: %v", err)
+			return fmt.Errorf("error getting github service: %v", err)
+		}
+
+		summaryEndpoint := os.Getenv("DIGGER_AI_SUMMARY_ENDPOINT")
+		if summaryEndpoint == "" {
+			log.Printf("could not generate AI summary, ai summary endpoint missing")
+			return fmt.Errorf("could not generate AI summary, ai summary endpoint missing")
+		}
+		apiToken := os.Getenv("DIGGER_AI_SUMMARY_API_TOKEN")
+
+		jobs, err := models.DB.GetDiggerJobsForBatch(batch.ID)
+		var terraformOutputs = ""
+		for _, job := range jobs {
+			var jobSpec orchestrator_scheduler.JobJson
+			err := json.Unmarshal(job.SerializedJobSpec, &jobSpec)
+			if err != nil {
+				log.Printf("could not summarise plans due to unmarshalling error: %v", err)
+				return fmt.Errorf("could not summarise plans due to unmarshalling error: %v", err)
+			}
+			projectName := jobSpec.ProjectName
+			terraformOutputs += fmt.Sprintf("terraform output for %v \n\n", projectName) + job.TerraformOutput
+		}
+		summary, err := utils.GetAiSummaryFromTerraformPlans(terraformOutputs, summaryEndpoint, apiToken)
+		if err != nil {
+			log.Printf("could not summarise terraform outputs: %v", err)
+			return fmt.Errorf("could not summarise terraform outputs: %v", err)
+		}
+
+		if batch.AiSummaryCommentId == "" {
+			log.Printf("could not post summary comment, initial comment not found")
+			return fmt.Errorf("could not post summary comment, initial comment not found")
+		}
+
+		prService.EditComment(batch.PrNumber, batch.AiSummaryCommentId, summary)
+	}
+	return nil
+}
+
 func AutomergePRforBatchIfEnabled(gh utils.GithubClientProvider, batch *models.DiggerBatch) error {
 	diggerYmlString := batch.DiggerConfig
 	diggerConfigYml, err := digger_config.LoadDiggerConfigYamlFromString(diggerYmlString)
@@ -663,13 +721,6 @@ func AutomergePRforBatchIfEnabled(gh utils.GithubClientProvider, batch *models.D
 		automerge = false
 	}
 	if batch.Status == orchestrator_scheduler.BatchJobSucceeded && batch.BatchType == orchestrator_scheduler.DiggerCommandApply && automerge == true {
-		//ghService, _, err := utils.GetGithubService(
-		//	gh,
-		//	batch.GithubInstallationId,
-		//	batch.RepoFullName,
-		//	batch.RepoOwner,
-		//	batch.RepoName,
-		//)
 		prService, err := GetPrServiceFromBatch(batch, gh)
 		if err != nil {
 			log.Printf("Error getting github service: %v", err)

backend/models/scheduler.go

@@ -22,19 +22,21 @@ const DiggerVCSGithub DiggerVCSType = "github"
 const DiggerVCSGitlab DiggerVCSType = "gitlab"
 
 type DiggerBatch struct {
-	ID                   uuid.UUID `gorm:"primary_key"`
-	VCS                  DiggerVCSType
-	PrNumber             int
-	CommentId            *int64
-	Status               orchestrator_scheduler.DiggerBatchStatus
-	BranchName           string
-	DiggerConfig         string
-	GithubInstallationId int64
-	GitlabProjectId      int
-	RepoFullName         string
-	RepoOwner            string
-	RepoName             string
-	BatchType            orchestrator_scheduler.DiggerCommand
+	ID                     uuid.UUID `gorm:"primary_key"`
+	VCS                    DiggerVCSType
+	PrNumber               int
+	CommentId              *int64
+	AiSummaryCommentId     string
+	Status                 orchestrator_scheduler.DiggerBatchStatus
+	BranchName             string
+	DiggerConfig           string
+	GithubInstallationId   int64
+	GitlabProjectId        int
+	RepoFullName           string
+	RepoOwner              string
+	RepoName               string
+	BatchType              orchestrator_scheduler.DiggerCommand
+	ReportTerraformOutputs bool
 	// used for module source grouping comments
 	SourceDetails []byte
 }

backend/models/storage.go

@@ -617,22 +617,24 @@ func (db *Database) GetDiggerBatch(batchId *uuid.UUID) (*DiggerBatch, error) {
 	return batch, nil
 }
 
-func (db *Database) CreateDiggerBatch(vcsType DiggerVCSType, githubInstallationId int64, repoOwner string, repoName string, repoFullname string, PRNumber int, diggerConfig string, branchName string, batchType scheduler.DiggerCommand, commentId *int64, gitlabProjectId int) (*DiggerBatch, error) {
+func (db *Database) CreateDiggerBatch(vcsType DiggerVCSType, githubInstallationId int64, repoOwner string, repoName string, repoFullname string, PRNumber int, diggerConfig string, branchName string, batchType scheduler.DiggerCommand, commentId *int64, gitlabProjectId int, aiSummaryCommentId string, reportTerraformOutputs bool) (*DiggerBatch, error) {
 	uid := uuid.New()
 	batch := &DiggerBatch{
-		ID:                   uid,
-		VCS:                  vcsType,
-		GithubInstallationId: githubInstallationId,
-		RepoOwner:            repoOwner,
-		RepoName:             repoName,
-		RepoFullName:         repoFullname,
-		PrNumber:             PRNumber,
-		CommentId:            commentId,
-		Status:               scheduler.BatchJobCreated,
-		BranchName:           branchName,
-		DiggerConfig:         diggerConfig,
-		BatchType:            batchType,
-		GitlabProjectId:      gitlabProjectId,
+		ID:                     uid,
+		VCS:                    vcsType,
+		GithubInstallationId:   githubInstallationId,
+		RepoOwner:              repoOwner,
+		RepoName:               repoName,
+		RepoFullName:           repoFullname,
+		PrNumber:               PRNumber,
+		CommentId:              commentId,
+		Status:                 scheduler.BatchJobCreated,
+		BranchName:             branchName,
+		DiggerConfig:           diggerConfig,
+		BatchType:              batchType,
+		GitlabProjectId:        gitlabProjectId,
+		AiSummaryCommentId:     aiSummaryCommentId,
+		ReportTerraformOutputs: reportTerraformOutputs,
 	}
 	result := db.GormDB.Save(batch)
 	if result.Error != nil {

backend/models/storage_test.go

@@ -151,7 +151,7 @@ func TestGetDiggerJobsForBatchPreloadsSummary(t *testing.T) {
 	resourcesUpdated := uint(2)
 	resourcesDeleted := uint(3)
 
-	batch, err := DB.CreateDiggerBatch(DiggerVCSGithub, 123, repoOwner, repoName, repoFullName, prNumber, diggerconfig, branchName, batchType, &commentId, 0)
+	batch, err := DB.CreateDiggerBatch(DiggerVCSGithub, 123, repoOwner, repoName, repoFullName, prNumber, diggerconfig, branchName, batchType, &commentId, 0, "", false)
 	assert.NoError(t, err)
 
 	job, err := DB.CreateDiggerJob(batch.ID, []byte(jobSpec), "workflow_file.yml")

backend/services/spec.go

@@ -116,8 +116,9 @@ func GetSpecFromJob(job models.DiggerJob) (*spec.Spec, error) {
 		CommentId: strconv.FormatInt(*batch.CommentId, 10),
 		Job:       jobSpec,
 		Reporter: spec.ReporterSpec{
-			ReportingStrategy: "comments_per_run",
-			ReporterType:      "lazy",
+			ReportingStrategy:     "comments_per_run",
+			ReporterType:          "lazy",
+			ReportTerraformOutput: batch.ReportTerraformOutputs,
 		},
 		Lock: spec.LockSpec{
 			LockType: "noop",

backend/tasks/runs_test.go

@@ -143,7 +143,7 @@ func TestThatRunQueueItemMovesFromQueuedToPlanningAfterPickup(t *testing.T) {
 
 	for i, testParam := range testParameters {
 		ciService := github2.MockCiService{}
-		batch, _ := models.DB.CreateDiggerBatch(models.DiggerVCSGithub, 123, "", "", "", 22, "", "", "", nil, 0)
+		batch, _ := models.DB.CreateDiggerBatch(models.DiggerVCSGithub, 123, "", "", "", 22, "", "", "", nil, 0, "", false)
 		project, _ := models.DB.CreateProject(fmt.Sprintf("test%v", i), nil, nil, false, false)
 		planStage, _ := models.DB.CreateDiggerRunStage(batch.ID.String())
 		applyStage, _ := models.DB.CreateDiggerRunStage(batch.ID.String())

backend/utils/ai.go

@@ -5,6 +5,7 @@ import (
 	"encoding/json"
 	"fmt"
 	"io"
+	"log"
 	"net/http"
 )
 
@@ -67,3 +68,64 @@ func GenerateTerraformCode(appCode string, generationEndpoint string, apiToken s
 	return response.Result, nil
 
 }
+
+func GetAiSummaryFromTerraformPlans(plans string, summaryEndpoint string, apiToken string) (string, error) {
+
+	payload := map[string]string{
+		"terraform_plans": plans,
+	}
+
+	// Convert payload to JSON
+	jsonData, err := json.Marshal(payload)
+	if err != nil {
+		return "", fmt.Errorf("Error marshalling JSON: %v\n", err)
+	}
+
+	// Create request
+	req, err := http.NewRequest("POST", summaryEndpoint, bytes.NewBuffer(jsonData))
+	if err != nil {
+		return "", fmt.Errorf("Error creating request: %v\n", err)
+	}
+
+	// Set headers
+	req.Header.Set("Content-Type", "application/json")
+	req.Header.Set("Authorization", "Bearer "+apiToken)
+
+	// Make the request
+	client := &http.Client{}
+	resp, err := client.Do(req)
+	if err != nil {
+		return "", fmt.Errorf("Error making request: %v\n", err)
+	}
+	defer resp.Body.Close()
+
+	// Read response
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return "", fmt.Errorf("Error reading response: %v\n", err)
+	}
+
+	// Print response
+	if resp.StatusCode == 400 {
+		log.Printf("error while generating summary: %v", body)
+		return "", fmt.Errorf("unable to generate summary")
+	}
+
+	if resp.StatusCode != 200 {
+		return "", fmt.Errorf("unexpected error occured while generating code")
+	}
+
+	type GeneratorResponse struct {
+		Result string `json:"result"`
+		Status string `json:"status"`
+	}
+
+	var response GeneratorResponse
+	err = json.Unmarshal(body, &response)
+	if err != nil {
+		return "", fmt.Errorf("unable to parse generator response: %v", err)
+	}
+
+	return response.Result, nil
+
+}

backend/utils/graphs.go

@@ -14,7 +14,7 @@ import (
 )
 
 // ConvertJobsToDiggerJobs jobs is map with project name as a key and a Job as a value
-func ConvertJobsToDiggerJobs(jobType scheduler.DiggerCommand, vcsType models.DiggerVCSType, organisationId uint, jobsMap map[string]scheduler.Job, projectMap map[string]configuration.Project, projectsGraph graph.Graph[string, configuration.Project], githubInstallationId int64, branch string, prNumber int, repoOwner string, repoName string, repoFullName string, commitSha string, commentId int64, diggerConfigStr string, gitlabProjectId int) (*uuid.UUID, map[string]*models.DiggerJob, error) {
+func ConvertJobsToDiggerJobs(jobType scheduler.DiggerCommand, vcsType models.DiggerVCSType, organisationId uint, jobsMap map[string]scheduler.Job, projectMap map[string]configuration.Project, projectsGraph graph.Graph[string, configuration.Project], githubInstallationId int64, branch string, prNumber int, repoOwner string, repoName string, repoFullName string, commitSha string, commentId int64, diggerConfigStr string, gitlabProjectId int, aiSummaryCommentId string, reportTerraformOutput bool) (*uuid.UUID, map[string]*models.DiggerJob, error) {
 	result := make(map[string]*models.DiggerJob)
 	organisation, err := models.DB.GetOrganisationById(organisationId)
 	if err != nil {
@@ -43,7 +43,7 @@ func ConvertJobsToDiggerJobs(jobType scheduler.DiggerCommand, vcsType models.Dig
 
 	log.Printf("marshalledJobsMap: %v\n", marshalledJobsMap)
 
-	batch, err := models.DB.CreateDiggerBatch(vcsType, githubInstallationId, repoOwner, repoName, repoFullName, prNumber, diggerConfigStr, branch, jobType, &commentId, gitlabProjectId)
+	batch, err := models.DB.CreateDiggerBatch(vcsType, githubInstallationId, repoOwner, repoName, repoFullName, prNumber, diggerConfigStr, branch, jobType, &commentId, gitlabProjectId, aiSummaryCommentId, reportTerraformOutput)
 	if err != nil {
 		return nil, nil, fmt.Errorf("failed to create batch: %v", err)
 	}

ee/backend/controllers/gitlab.go

@@ -333,7 +333,7 @@ func handlePullRequestEvent(gitlabProvider utils.GitlabProvider, payload *gitlab
 		log.Printf("strconv.ParseInt error: %v", err)
 		utils.InitCommentReporter(glService, prNumber, fmt.Sprintf(":x: could not handle commentId: %v", err))
 	}
-	batchId, _, err := utils.ConvertJobsToDiggerJobs(*diggerCommand, models.DiggerVCSGitlab, organisationId, impactedJobsMap, impactedProjectsMap, projectsGraph, 0, branch, prNumber, repoOwner, repoName, repoFullName, commitSha, commentId, diggeryamlStr, projectId)
+	batchId, _, err := utils.ConvertJobsToDiggerJobs(*diggerCommand, models.DiggerVCSGitlab, organisationId, impactedJobsMap, impactedProjectsMap, projectsGraph, 0, branch, prNumber, repoOwner, repoName, repoFullName, commitSha, commentId, diggeryamlStr, projectId, "", false)
 	if err != nil {
 		log.Printf("ConvertJobsToDiggerJobs error: %v", err)
 		utils.InitCommentReporter(glService, prNumber, fmt.Sprintf(":x: ConvertJobsToDiggerJobs error: %v", err))
@@ -524,7 +524,7 @@ func handleIssueCommentEvent(gitlabProvider utils.GitlabProvider, payload *gitla
 		log.Printf("ParseInt err: %v", err)
 		return fmt.Errorf("parseint error: %v", err)
 	}
-	batchId, _, err := utils.ConvertJobsToDiggerJobs(*diggerCommand, models.DiggerVCSGitlab, organisationId, impactedProjectsJobMap, impactedProjectsMap, projectsGraph, 0, branch, issueNumber, repoOwner, repoName, repoFullName, commitSha, commentId64, diggerYmlStr, projectId)
+	batchId, _, err := utils.ConvertJobsToDiggerJobs(*diggerCommand, models.DiggerVCSGitlab, organisationId, impactedProjectsJobMap, impactedProjectsMap, projectsGraph, 0, branch, issueNumber, repoOwner, repoName, repoFullName, commitSha, commentId64, diggerYmlStr, projectId, "", false)
 	if err != nil {
 		log.Printf("ConvertJobsToDiggerJobs error: %v", err)
 		utils.InitCommentReporter(glService, issueNumber, fmt.Sprintf(":x: ConvertJobsToDiggerJobs error: %v", err))