fix: [ML-1268]: fetch prompts based on module and mode (#113)

* add appropriate error messgaes

* modify test

* add cd module architect mode pormpt and change prompt name to uppercase module id

* Merge branch 'master' into ML-1268

* added test for register prompts method

* modify go directive

* allow architect mode only for internal mode

* allow architect mode only for internal mode

* merge

* change file structure and names

* change to argument passing logic

* fix: [ML-1268]: fetch prompts based on module and mode

Author: prachi-shah-harness

pkg/harness/prompts/fetcher.go

@@ -4,23 +4,24 @@ import (
 	"embed"
 )
 
-//go:embed files/**/*.txt
+//go:embed files/internal/**/*.txt files/**/*.txt
 var PromptFiles embed.FS // Exported to be accessible from other packages
 
 // GetModulePrompts retrieves prompts for a specific module from a given filesystem
 // GetModulePrompts retrieves prompts for a specific module from a given filesystem.
 // It loads common prompts from the "files/common" directory and mode-specific prompts
 // from the "files/internal" or "files/external" directory, depending on the value of `isInternal`.
 // It returns a slice of PromptFile containing the loaded prompts.
-func GetModulePrompts(fs embed.FS, module string, isInternal bool) ([]PromptFile, error) {
+func GetModulePrompts(fs embed.FS, module string, isInternal bool, mode string) ([]PromptFile, error) {
 	// Use embedded filesystem instead of file system paths
 	// Use the provided embedded filesystem
 	fileLoader := NewEmbedFileLoader(fs)
 
 	var allPrompts []PromptFile
 
+	filename := module + ".txt"
 	// Load common prompt for the module directly
-	commonPath := "files/common/" + module + ".txt"
+	commonPath := "files/common/" + filename
 	commonPrompt, err := fileLoader.loadPromptFileFromEmbed(commonPath)
 	if err == nil {
 		allPrompts = append(allPrompts, commonPrompt)
@@ -29,9 +30,9 @@ func GetModulePrompts(fs embed.FS, module string, isInternal bool) ([]PromptFile
 	// Load mode-specific prompt for the module directly
 	var modePath string
 	if isInternal {
-		modePath = "files/internal/" + module + ".txt"
+		modePath = "files/internal/" + mode + "/" + filename
 	} else {
-		modePath = "files/external/" + module + ".txt"
+		modePath = "files/external/" + filename
 	}
 
 	modePrompt, err := fileLoader.loadPromptFileFromEmbed(modePath)

pkg/harness/prompts/files/internal/architect/cd.txt

@@ -0,0 +1,25 @@
+---
+name: CD
+description: CI/CD Pipeline Assistant
+result_description: CI/CD pipeline configuration
+module: CD
+---
+
+***You are an opinionated DevOps expert.*** The user is a novice (e.g., a VP of Engineering or developer unfamiliar with DevOps), and they don't know what Harness can do. But ***you do***, because you have access to Harness documentation, templates, MCP context, and DevOps best practices.
+
+***Your task is to guide them in building a CI/CD pipeline.***
+***Engage in a dialog*** to understand their goals—such as quality, security, resiliency, and compliance—and recommend a pipeline structure accordingly.
+
+**Always use the minimum number of stages needed to achieve the user's requirements. Keep the initial pipeline as simple as possible.**
+
+**Ask about their goals first, rather than directly asking about security or compliance steps.**  
+
+**Always ask one question at a time, waiting for their response before moving to the next.**
+
+***Check for existing Harness entities*** (Secrets, Services, Environments, Connectors, Templates) using MCP APIs.
+
+If multiple are found, ***show names and descriptions and ask the user to select***. If none exist, recommend creating them and include the request in the final DevOps Agent prompt.
+
+When appropriate, ***ask if there are any compliance or policy requirements***, but only after discussing broader goals. If unsure, have the user describe them in English.
+
+***Before generating YAML, summarize your plan and show the DevOps Agent prompt. Only proceed once the user confirms.***

pkg/harness/prompts/files/internal/ccm.txt renamed to pkg/harness/prompts/files/internal/standard/ccm.txt

@@ -1,6 +1,8 @@
 package modules
 
 import (
+	"encoding/json"
+	"fmt"
 	"log/slog"
 	"strings"
 
@@ -101,57 +103,94 @@ func (r *ModuleRegistry) RegisterPrompts(mcpServer *server.MCPServer) error {
 }
 
 func registerPrompts(moduleID string, cfg *config.Config, mcpServer *server.MCPServer) error {
-	// Get module-specific prompts
-	modulePrompts, err := prompts.GetModulePrompts(prompts.PromptFiles, strings.ToLower(moduleID), cfg.Internal)
-	if err != nil {
-		return err
-	}
-
-	if len(modulePrompts) == 0 {
-		// No prompts for this module
-		return nil
-	}
-
-	// Combine all prompt contents into a single prompt
-	var combinedContent strings.Builder
-
-	// Use the first prompt's metadata for description and result description if available
-	description := ""
-	if len(modulePrompts) > 0 && modulePrompts[0].Metadata.Description != "" {
-		description = modulePrompts[0].Metadata.Description
-	}
-
-	resultDescription := ""
-	if len(modulePrompts) > 0 && modulePrompts[0].Metadata.ResultDescription != "" {
-		resultDescription = modulePrompts[0].Metadata.ResultDescription
-	}
-
-	// Combine all prompt contents
-	for i, promptFile := range modulePrompts {
-		if promptFile.Content != "" {
-			if i > 0 {
-				combinedContent.WriteString("\n\n")
-			}
-			combinedContent.WriteString(promptFile.Content)
-		}
-	}
-
-	// Create a single MCP prompt with the module ID as the name
-	mcpPrompt := p.NewPrompt().
-		SetName(moduleID). // Use moduleID as the prompt name
-		SetDescription(description).
-		SetResultDescription(resultDescription).
-		SetText(combinedContent.String()).
-		Build()
-
-	// Create a Prompts collection with the single prompt
-	mcpPrompts := p.Prompts{}
-	mcpPrompts.Append(mcpPrompt)
-
-	slog.Info("Registering prompt for module", "module", moduleID, "contentLength", len(combinedContent.String()))
-
-	// Register the prompt with the MCP server
-	p.AddPrompts(mcpPrompts, mcpServer)
-
-	return nil
+    // Create a map to store prompts by mode
+    modulePromptsByMode := map[string][]prompts.PromptFile{
+        string(p.Standard): {},
+        string(p.Architect): {},
+    }
+    
+    // Get module-specific prompts for standard mode
+    standardPrompts, err := prompts.GetModulePrompts(prompts.PromptFiles, strings.ToLower(moduleID), cfg.Internal, string(p.Standard))
+    if err != nil {
+        return fmt.Errorf("failed to get standard prompts for module %s: %v", moduleID, err)
+    }
+    modulePromptsByMode[string(p.Standard)] = standardPrompts
+    
+    // Get module-specific prompts for architect mode (only for internal)
+    if cfg.Internal {
+        architectPrompts, err := prompts.GetModulePrompts(prompts.PromptFiles, strings.ToLower(moduleID), cfg.Internal, string(p.Architect))
+        if err != nil {
+            return fmt.Errorf("failed to get architect prompts for module %s: %v", moduleID, err)
+        }
+        modulePromptsByMode[string(p.Architect)] = architectPrompts
+    }
+    
+    // Check if we have any prompts for this module
+    totalPrompts := len(modulePromptsByMode[string(p.Standard)]) + len(modulePromptsByMode[string(p.Architect)])
+    if totalPrompts == 0 {
+        // No prompts for this module
+        return nil
+    }
+
+    // Create a map to store combined content for each mode
+    modeContents := make(map[string]string)
+    
+    // Get description and result description from the first available prompt
+    description := ""
+    resultDescription := ""
+    
+    // Process each mode separately to build the content map
+    for mode, modePrompts := range modulePromptsByMode {
+        if len(modePrompts) == 0 {
+            continue // Skip empty modes
+        }
+        
+        // Use the first prompt's metadata for description and result description if not already set
+        if description == "" && modePrompts[0].Metadata.Description != "" {
+            description = modePrompts[0].Metadata.Description
+        }
+        
+        if resultDescription == "" && modePrompts[0].Metadata.ResultDescription != "" {
+            resultDescription = modePrompts[0].Metadata.ResultDescription
+        }
+        
+        // Combine all prompt contents for this mode
+        var combinedContent strings.Builder
+        for i, promptFile := range modePrompts {
+            if promptFile.Content != "" {
+                if i > 0 {
+                    combinedContent.WriteString("\n\n")
+                }
+                combinedContent.WriteString(promptFile.Content)
+            }
+        }
+        
+        // Store the combined content for this mode
+        modeContents[mode] = combinedContent.String()
+    }
+    
+    // Convert the mode contents map to JSON
+    contentJSON, err := json.Marshal(modeContents)
+    if err != nil {
+        return fmt.Errorf("failed to marshal mode contents: %v", err)
+    }
+    
+    // Create a single MCP prompt with the module ID as the name
+    mcpPrompt := p.NewPrompt().
+        SetName(strings.ToUpper(moduleID)). // Use moduleID as the prompt name
+        SetDescription(description).
+        SetResultDescription(resultDescription).
+        SetText(string(contentJSON)). // Store the JSON map as the prompt text
+        Build()
+    
+    // Create a Prompts collection with the single prompt
+    mcpPrompts := p.Prompts{}
+    mcpPrompts.Append(mcpPrompt)
+    
+    slog.Info("Registering prompt for", "module", moduleID, "contentLength", len(contentJSON))
+    
+    // Register the prompt with the MCP server
+    p.AddPrompts(mcpPrompts, mcpServer)
+    
+    return nil
 }

pkg/modules/registry.go

@@ -2,6 +2,8 @@ package prompts
 
 import (
 	"context"
+	"encoding/json"
+	"fmt"
 	"log/slog"
 	"github.com/mark3labs/mcp-go/mcp"
 	"github.com/mark3labs/mcp-go/server"
@@ -13,11 +15,18 @@ import (
 // Role represents the role of the prompt creator, either User or Assistant.
 type Role int
 
+type Mode string
+
 const (
 	User      Role = iota // 0
 	Assistant             // 1
 )
 
+const (
+	Standard Mode = "standard"
+	Architect Mode = "architect"
+)
+
 // Prompt represents the prompt data needed to add to the MCP server.
 type Prompt struct {
 	Name              string
@@ -93,18 +102,44 @@ func AddPrompts(prompts Prompts, mcpServer *server.MCPServer) {
 	}
 }
 
-// createPrompt converts a Prompt into an MCP prompt and defines its handler function.
 func createPrompt(prompt *Prompt) (mcp.Prompt, server.PromptHandlerFunc) {
 	role := mcp.RoleUser
 	if prompt.Role == Assistant {
 		role = mcp.RoleAssistant
 	}
 
-	return mcp.NewPrompt(prompt.Name, mcp.WithPromptDescription(prompt.Description)),
+	return mcp.NewPrompt(
+			prompt.Name,
+			mcp.WithPromptDescription(prompt.Description),
+			mcp.WithArgument("mode", mcp.ArgumentDescription("Selects the prompt mode: 'standard' or 'architect'")),
+		),
 		func(ctx context.Context, request mcp.GetPromptRequest) (*mcp.GetPromptResult, error) {
-			return mcp.NewGetPromptResult(
-				prompt.ResultDescription,
-				[]mcp.PromptMessage{mcp.NewPromptMessage(role, mcp.NewTextContent(prompt.Text))},
-			), nil
+			// Determine mode (default to "standard") and return different prompt text accordingly.
+			mode := string(Standard) // Default to standard mode
+            if v, ok := request.Params.Arguments["mode"]; ok && v != "" {
+                mode = v
+            }
+
+            // Parse the JSON-encoded map of prompt contents
+            var modeContents map[string]string
+            if err := json.Unmarshal([]byte(prompt.Text), &modeContents); err != nil {
+                slog.Error("Failed to parse prompt content JSON", "error", err, "promptName", prompt.Name)
+                return nil, err
+            }
+
+            // Get the content for the requested mode, fallback to standard if not found
+            text, ok := modeContents[mode]
+            if !ok {
+                // If the requested mode is not available, fall back to standard mode
+                text, ok = modeContents[string(Standard)]
+                if !ok {
+                    return nil, fmt.Errorf("prompt mode %s not found for prompt %s", mode, prompt.Name)
+                }
+            }
+
+            return mcp.NewGetPromptResult(
+                prompt.ResultDescription,
+                []mcp.PromptMessage{mcp.NewPromptMessage(role, mcp.NewTextContent(text))},
+            ), nil
 		}
-}
+}