Merge pull request #19 from gruntwork-io/rename-blocks

Rename and improve blocks

Author: josh-padnick

.cursorrules

@@ -1,3 +1,11 @@
 The Go server runs on port 7825 by default.
 
-We use bun, so prefer that to npm.
+We use bun, so prefer that to npm.
+
+We use https://taskfile.dev/ over makefiles. Look for the Taskfile.yml to see what command can you can run.
+
+Docs are located in /docs 
+
+The frontend is located in /web 
+
+The backend is spread across /api, /browser, and /cmd. When the user requests something, make sure you know if they're asking to update the docs, frontend, or backend.

api/boilerplate_render.go

@@ -101,7 +101,28 @@ func determineOutputDirectory(cliOutputPath string, apiRequestOutputPath *string
 	return outputDir, nil
 }
 
-// This handler renders a boilerplate template with the provided variables.
+// prepareOutputDirectory determines the output directory path and creates it if needed.
+// This is shared logic used by both HandleBoilerplateRender and HandleBoilerplateRenderInline.
+//
+// Parameters:
+//   - cliOutputPath: The base output path from CLI flag
+//   - apiOutputPath: Optional subdirectory from API request (validated for security)
+//
+// Returns the absolute output directory path or an error.
+func prepareOutputDirectory(cliOutputPath string, apiOutputPath *string) (string, error) {
+	// Determine the final output directory path
+	outputDir, err := determineOutputDirectory(cliOutputPath, apiOutputPath)
+	if err != nil {
+		return "", fmt.Errorf("failed to determine output directory: %w", err)
+	}
+
+	// Create the output directory if it doesn't exist
+	if err := os.MkdirAll(outputDir, 0755); err != nil {
+		return "", fmt.Errorf("failed to create output directory: %w", err)
+	}
+
+	return outputDir, nil
+}
 
 // HandleBoilerplateRender renders a boilerplate template with the provided variables
 func HandleBoilerplateRender(runbookPath string, cliOutputPath string) gin.HandlerFunc {
@@ -140,33 +161,13 @@ func HandleBoilerplateRender(runbookPath string, cliOutputPath string) gin.Handl
 			return
 		}
 
-		// Determine the output directory
-		outputDir, err := determineOutputDirectory(cliOutputPath, req.OutputPath)
+		// Prepare the output directory (determine path and create it)
+		// Files accumulate across multiple template renders in the same runbook
+		outputDir, err := prepareOutputDirectory(cliOutputPath, req.OutputPath)
 		if err != nil {
-			slog.Error("Failed to determine output directory", "error", err)
-			c.JSON(http.StatusBadRequest, gin.H{
-				"error":   "Invalid output path",
-				"details": err.Error(),
-			})
-			return
-		}
-
-		// Create the output directory if it doesn't exist
-		if err := os.MkdirAll(outputDir, 0755); err != nil {
-			slog.Error("Failed to create output directory", "error", err)
-			c.JSON(http.StatusInternalServerError, gin.H{
-				"error":   "Failed to create output directory",
-				"details": err.Error(),
-			})
-			return
-		}
-
-		// Clear any existing files in the output directory before rendering
-		// This ensures each render starts fresh without leftover files from previous renders
-		if err := deleteDirectoryContents(outputDir); err != nil {
-			slog.Error("Failed to clear output directory", "error", err)
+			slog.Error("Failed to prepare output directory", "error", err)
 			c.JSON(http.StatusInternalServerError, gin.H{
-				"error":   "Failed to clear output directory",
+				"error":   "Failed to prepare output directory",
 				"details": err.Error(),
 			})
 			return
@@ -318,7 +319,7 @@ func preConvertJSONTypes(value any, variableType bpVariables.BoilerplateType) an
 }
 
 // HandleBoilerplateRenderInline renders boilerplate templates provided directly in the request body
-func HandleBoilerplateRenderInline() gin.HandlerFunc {
+func HandleBoilerplateRenderInline(cliOutputPath string) gin.HandlerFunc {
 	return func(c *gin.Context) {
 		var req RenderInlineRequest
 		if err := c.ShouldBindJSON(&req); err != nil {
@@ -376,21 +377,22 @@ func HandleBoilerplateRenderInline() gin.HandlerFunc {
 			slog.Debug("Wrote template file", "path", fullPath)
 		}
 
-		// Create a temporary output directory
-		outputDir, err := os.MkdirTemp("", "boilerplate-output-*")
+		// Always render to a temp directory first for inline templates.
+		// This prevents boilerplate from clearing existing files in the persistent output.
+		tempOutputDir, err := os.MkdirTemp("", "boilerplate-output-*")
 		if err != nil {
-			slog.Error("Failed to create output directory", "error", err)
+			slog.Error("Failed to create temp output directory", "error", err)
 			c.JSON(http.StatusInternalServerError, gin.H{
 				"error":   "Failed to create output directory",
 				"details": err.Error(),
 			})
 			return
 		}
-		defer os.RemoveAll(outputDir) // Clean up output directory when done
-		slog.Info("Created temporary output directory", "outputDir", outputDir)
+		defer os.RemoveAll(tempOutputDir)
+		slog.Info("Created temporary output directory", "outputDir", tempOutputDir)
 
-		// Render the template using the boilerplate package
-		err = renderBoilerplateTemplate(tempDir, outputDir, req.Variables)
+		// Render the template to the temp directory
+		err = renderBoilerplateTemplate(tempDir, tempOutputDir, req.Variables)
 		if err != nil {
 			slog.Error("Failed to render boilerplate template", "error", err)
 			c.JSON(http.StatusInternalServerError, gin.H{
@@ -402,8 +404,8 @@ func HandleBoilerplateRenderInline() gin.HandlerFunc {
 
 		slog.Info("Successfully rendered boilerplate template")
 
-		// Read all rendered files from the output directory
-		renderedFiles, err := readAllFilesInDirectory(outputDir)
+		// Read all rendered files from the temp output directory
+		renderedFiles, err := readAllFilesInDirectory(tempOutputDir)
 		if err != nil {
 			slog.Error("Failed to read rendered files", "error", err)
 			c.JSON(http.StatusInternalServerError, gin.H{
@@ -413,8 +415,53 @@ func HandleBoilerplateRenderInline() gin.HandlerFunc {
 			return
 		}
 
-		// Build file tree from the generated output
-		fileTree, err := buildFileTreeWithRoot(outputDir, "")
+		// If generateFile is true, copy rendered files to the persistent output directory
+		// This merges with existing files instead of replacing them
+		var persistentOutputDir string
+		if req.GenerateFile {
+			persistentOutputDir, err = prepareOutputDirectory(cliOutputPath, nil)
+			if err != nil {
+				slog.Error("Failed to prepare output directory", "error", err)
+				c.JSON(http.StatusInternalServerError, gin.H{
+					"error":   "Failed to prepare output directory",
+					"details": err.Error(),
+				})
+				return
+			}
+
+			// Copy each rendered file to the persistent output (merging with existing files)
+			for relPath, file := range renderedFiles {
+				fullPath := filepath.Join(persistentOutputDir, relPath)
+				
+				// Create parent directories if needed
+				if err := os.MkdirAll(filepath.Dir(fullPath), 0755); err != nil {
+					slog.Error("Failed to create directory", "path", filepath.Dir(fullPath), "error", err)
+					c.JSON(http.StatusInternalServerError, gin.H{
+						"error":   "Failed to create directory structure",
+						"details": err.Error(),
+					})
+					return
+				}
+
+				if err := os.WriteFile(fullPath, []byte(file.Content), 0644); err != nil {
+					slog.Error("Failed to write file", "path", fullPath, "error", err)
+					c.JSON(http.StatusInternalServerError, gin.H{
+						"error":   "Failed to write file",
+						"details": err.Error(),
+					})
+					return
+				}
+				slog.Debug("Copied file to persistent output", "path", fullPath)
+			}
+			slog.Info("Successfully copied files to persistent output", "outputDir", persistentOutputDir)
+		}
+
+		// Build file tree - use persistent dir if files were generated, otherwise temp
+		fileTreeDir := tempOutputDir
+		if persistentOutputDir != "" {
+			fileTreeDir = persistentOutputDir
+		}
+		fileTree, err := buildFileTreeWithRoot(fileTreeDir, "")
 		if err != nil {
 			slog.Error("Failed to build file tree", "error", err)
 			c.JSON(http.StatusInternalServerError, gin.H{

api/server.go

@@ -33,7 +33,7 @@ func setupCommonRoutes(r *gin.Engine, runbookPath string, outputPath string, reg
 	r.POST("/api/boilerplate/render", HandleBoilerplateRender(runbookPath, outputPath))
 
 	// API endpoint to render boilerplate templates from inline template files
-	r.POST("/api/boilerplate/render-inline", HandleBoilerplateRenderInline())
+	r.POST("/api/boilerplate/render-inline", HandleBoilerplateRenderInline(outputPath))
 
 	// API endpoint to get registered executables
 	r.GET("/api/runbook/executables", HandleExecutablesRequest(registry))

api/types.go

@@ -1,5 +1,10 @@
 package api
 
+import (
+	"encoding/json"
+	"fmt"
+)
+
 // Core data types
 // ---
 
@@ -44,12 +49,51 @@ type RenderResponse struct {
 	FileTree     []FileTreeNode `json:"fileTree"`
 }
 
+// FlexibleBool is a boolean type that can be unmarshaled from both JSON boolean and string values.
+// This handles cases where MDX authors write generateFile="true" instead of generateFile={true}.
+type FlexibleBool bool
+
+// UnmarshalJSON implements json.Unmarshaler for FlexibleBool
+func (fb *FlexibleBool) UnmarshalJSON(data []byte) error {
+	// Try to unmarshal as bool first
+	var b bool
+	if err := json.Unmarshal(data, &b); err == nil {
+		*fb = FlexibleBool(b)
+		return nil
+	}
+	
+	// Try to unmarshal as string
+	var s string
+	if err := json.Unmarshal(data, &s); err == nil {
+		switch s {
+		case "true", "True", "TRUE", "1":
+			*fb = true
+		case "false", "False", "FALSE", "0", "":
+			*fb = false
+		default:
+			return fmt.Errorf("invalid boolean string: %s", s)
+		}
+		return nil
+	}
+	
+	return fmt.Errorf("cannot unmarshal %s into FlexibleBool", string(data))
+}
+
 // RenderInlineRequest represents a request to render template files provided in the request body
 type RenderInlineRequest struct {
 	// Map of relative file paths to their contents
 	// Example: {"boilerplate.yml": "...", "main.tf": "..."}
 	TemplateFiles map[string]string `json:"templateFiles"`
 	Variables     map[string]any    `json:"variables"`
+	// GenerateFile indicates whether to write files to the persistent output directory.
+	// When false (default), files are only rendered and returned in the response.
+	// When true, files are also written to the output directory (CLI-configured path + OutputPath).
+	// Accepts both boolean and string values (e.g., true, "true", "false").
+	GenerateFile  FlexibleBool      `json:"generateFile,omitempty"`
+	// OutputPath is an optional subdirectory within the CLI-configured output path.
+	// Only used when GenerateFile is true.
+	// SECURITY: Must be a relative path without ".." to prevent directory traversal attacks.
+	OutputPath    *string           `json:"outputPath,omitempty"`
 }
 
 // RenderInlineResponse represents the response from the inline render endpoint