feat: change logs and update format command

Author: anket-cd

cmd/stf/plan.go

@@ -1,8 +1,6 @@
 package stf
 
 import (
-	"os"
-
 	"github.com/clouddrove/smurf/internal/terraform"
 	"github.com/spf13/cobra"
 )
@@ -18,10 +16,7 @@ var planCmd = &cobra.Command{
 	Short:        "Generate and show an execution plan for Terraform",
 	SilenceUsage: true,
 	RunE: func(cmd *cobra.Command, args []string) error {
-		err := terraform.Plan(planVarNameValue, planVarFile, planDir, planDestroy)
-		if err != nil {
-			os.Exit(1)
-		}
+		terraform.Plan(planVarNameValue, planVarFile, planDir, planDestroy)
 		return nil
 	},
 	Example: `

internal/terraform/drift.go

@@ -2,49 +2,51 @@ package terraform
 
 import (
 	"context"
+	"fmt"
 	"os"
 
 	"github.com/hashicorp/terraform-exec/tfexec"
-	"github.com/pterm/pterm"
 )
 
 // DetectDrift checks for drift between the Terraform state and the actual infrastructure.
 // It performs a `plan` with refresh enabled to detect any changes that differ
 // from the current state. If drift is detected, it lists the affected resources.
-// Provides user feedback through spinners and colored messages for better UX.
+// Provides user feedback through spinners and consistent Smurf log style.
 func DetectDrift(dir string) error {
 	tf, err := GetTerraform(dir)
 	if err != nil {
+		Error("Failed to initialize Terraform: %v", err)
 		return err
 	}
 
 	planFile := "drift.plan"
-	pterm.Info.Println("Checking for drift...")
-	spinner, _ := pterm.DefaultSpinner.Start("Running terraform plan for drift detection")
-	_, err = tf.Plan(context.Background(), tfexec.Out(planFile), tfexec.Refresh(true))
 
+	Info("Starting Terraform drift detection...")
+
+	// Generate drift plan
+	_, err = tf.Plan(context.Background(), tfexec.Out(planFile), tfexec.Refresh(true))
 	if err != nil {
-		spinner.Fail("Terraform plan for drift detection failed")
-		pterm.Error.Printf("Terraform plan for drift detection failed: %v\n", err)
+		Error("Failed to execute Terraform plan for drift detection: %v", err)
 		return err
 	}
-	spinner.Success("Terraform drift detection plan completed")
 
+	tf.SetStderr(os.Stderr)
+
+	// Parse plan file
 	plan, err := tf.ShowPlanFile(context.Background(), planFile)
 	if err != nil {
-		pterm.Error.Printf("Error showing plan file: %v\n", err)
+		Error("Failed to read drift plan file: %v", err)
 		return err
 	}
 
-	tf.SetStderr(os.Stderr)
-
 	if len(plan.ResourceChanges) > 0 {
-		pterm.Warning.Println("Drift detected:")
+		Warn("Drift detected in your infrastructure:")
 		for _, change := range plan.ResourceChanges {
-			pterm.Println(pterm.Yellow("- %s: %s", change.Address, change.Change.Actions))
+			fmt.Printf("  - %s: %v\n", change.Address, change.Change.Actions)
 		}
+		Warn("Run 'terraform apply' to reconcile drifted resources.")
 	} else {
-		pterm.Success.Println("No drift detected.")
+		Success("No drift detected. Your infrastructure is in sync.")
 	}
 
 	return nil

internal/terraform/format.go

@@ -10,10 +10,9 @@ import (
 	"strings"
 
 	"github.com/hashicorp/terraform-exec/tfexec"
-	"github.com/pterm/pterm"
 )
 
-// FormatError represents a single formatting error with its details
+// FormatError represents a single formatting error with details
 type FormatError struct {
 	ErrorType   string
 	Description string
@@ -32,13 +31,10 @@ type CustomFormatter struct {
 
 // NewCustomFormatter creates a new formatter instance
 func NewCustomFormatter(tf *tfexec.Terraform, workDir string) *CustomFormatter {
-	return &CustomFormatter{
-		tf:      tf,
-		workDir: workDir,
-	}
+	return &CustomFormatter{tf: tf, workDir: workDir}
 }
 
-// findTerraformFiles finds all .tf files in the given directory
+// findTerraformFiles finds all `.tf` files in the given directory
 func (cf *CustomFormatter) findTerraformFiles(root string, recursive bool) ([]string, error) {
 	var files []string
 
@@ -62,51 +58,48 @@ func (cf *CustomFormatter) findTerraformFiles(root string, recursive bool) ([]st
 		return nil
 	}
 
-	err := filepath.Walk(root, walkFn)
-	if err != nil {
+	if err := filepath.Walk(root, walkFn); err != nil {
 		return nil, err
 	}
-
 	return files, nil
 }
 
 // formatError formats a single formatting error in Terraform style
 func (cf *CustomFormatter) formatError(err FormatError) string {
 	var sb strings.Builder
 
-	errorSymbol := pterm.Red("│")
-	errorPrefix := pterm.Red("Error: ")
-	locationColor := pterm.White(err.Location)
-	lineNumColor := pterm.White(fmt.Sprintf("line %d", err.LineNumber))
-
-	sb.WriteString("╷\n")
-	sb.WriteString(fmt.Sprintf("%s %s%s\n", errorSymbol, errorPrefix, err.Description))
-	sb.WriteString(fmt.Sprintf("%s\n", errorSymbol))
-	sb.WriteString(fmt.Sprintf("%s   on %s %s:\n", errorSymbol, locationColor, lineNumColor))
-	sb.WriteString(fmt.Sprintf("%s   %d:   %s\n", errorSymbol, err.LineNumber, err.LineContent))
+	sb.WriteString("\n╷\n")
+	sb.WriteString(fmt.Sprintf("│ %s%s\n", RedText("Error: "), err.Description))
+	sb.WriteString("│\n")
+	sb.WriteString(fmt.Sprintf("│   on %s line %d:\n", GreyText(err.Location), err.LineNumber))
+	sb.WriteString(fmt.Sprintf("│   %d:   %s\n", err.LineNumber, err.LineContent))
 	if err.NextLine != "" {
-		sb.WriteString(fmt.Sprintf("%s   %d:   %s\n", errorSymbol, err.LineNumber+1, err.NextLine))
+		sb.WriteString(fmt.Sprintf("│   %d:   %s\n", err.LineNumber+1, err.NextLine))
 	}
 	if err.HelpText != "" {
-		sb.WriteString(fmt.Sprintf("%s\n", errorSymbol))
-		sb.WriteString(fmt.Sprintf("%s %s\n", errorSymbol, err.HelpText))
+		sb.WriteString("│\n")
+		sb.WriteString(fmt.Sprintf("│   %s\n", GreyText(err.HelpText)))
 	}
 	sb.WriteString("╵\n")
-
 	return sb.String()
 }
 
-// FormatWithDetails performs formatting and returns detailed output
+// FormatWithDetails performs Terraform formatting with rich logging
 func (cf *CustomFormatter) FormatWithDetails(ctx context.Context, dir string, recursive bool) error {
-	spinner, _ := pterm.DefaultSpinner.Start("Formatting Terraform configuration files...")
+	Info("Starting Terraform formatting process...")
 
 	files, err := cf.findTerraformFiles(dir, recursive)
 	if err != nil {
-		spinner.Fail("Failed to find Terraform files")
+		Error("Failed to find Terraform files: %v", err)
 		return fmt.Errorf("error finding Terraform files: %w", err)
 	}
 
-	formatted := make([]string, 0)
+	if len(files) == 0 {
+		Warn("No Terraform (.tf) files found in the directory.")
+		return nil
+	}
+
+	formatted := []string{}
 	var formatErrors []FormatError
 
 	for _, file := range files {
@@ -116,7 +109,6 @@ func (cf *CustomFormatter) FormatWithDetails(ctx context.Context, dir string, re
 				ErrorType:   "File read failed",
 				Description: err.Error(),
 				Location:    file,
-				LineNumber:  0,
 				HelpText:    "Failed to read file for formatting check",
 			})
 			continue
@@ -129,7 +121,6 @@ func (cf *CustomFormatter) FormatWithDetails(ctx context.Context, dir string, re
 				ErrorType:   "Terraform init failed",
 				Description: err.Error(),
 				Location:    file,
-				LineNumber:  0,
 				HelpText:    "Failed to initialize Terraform for formatting",
 			})
 			continue
@@ -143,7 +134,7 @@ func (cf *CustomFormatter) FormatWithDetails(ctx context.Context, dir string, re
 		}
 
 		if bytes.Equal(content, outputBuffer.Bytes()) {
-			continue
+			continue // Already properly formatted
 		}
 
 		err = os.WriteFile(file, outputBuffer.Bytes(), 0644)
@@ -152,7 +143,6 @@ func (cf *CustomFormatter) FormatWithDetails(ctx context.Context, dir string, re
 				ErrorType:   "File write failed",
 				Description: err.Error(),
 				Location:    file,
-				LineNumber:  0,
 				HelpText:    "Failed to write formatted content to file",
 			})
 			continue
@@ -162,21 +152,21 @@ func (cf *CustomFormatter) FormatWithDetails(ctx context.Context, dir string, re
 	}
 
 	if len(formatErrors) > 0 {
-		spinner.Fail(fmt.Sprintf("Formatting failed with %d errors", len(formatErrors)))
-		for _, err := range formatErrors {
-			fmt.Print(cf.formatError(err))
+		for _, e := range formatErrors {
+			fmt.Print(cf.formatError(e))
 		}
+		Error("Formatting failed with %d errors", len(formatErrors))
 		return fmt.Errorf("formatting failed with %d errors", len(formatErrors))
 	}
 
 	if len(formatted) > 0 {
-		spinner.Success("Terraform files formatted successfully")
-		pterm.Info.Println("\nFormatted files:")
+		Success("Terraform files formatted successfully ✅")
+		Info("Formatted files:")
 		for _, file := range formatted {
-			pterm.Info.Printf("- %s\n", file)
+			fmt.Printf("   %s\n", CyanText(file))
 		}
 	} else {
-		spinner.Success("No files needed formatting")
+		Success("No Terraform file changes detected")
 	}
 
 	return nil
@@ -189,42 +179,44 @@ func (cf *CustomFormatter) parseFormatError(err error, file string) FormatError
 		Description: err.Error(),
 		Location:    file,
 		LineNumber:  1,
-		LineContent: "",
-		HelpText:    "Please check the file syntax and try again",
+		HelpText:    "Please check file syntax and try again",
 	}
 }
 
+// GetFmtTerraform initializes and returns a Terraform executor
 func GetFmtTerraform() (*tfexec.Terraform, error) {
 	workDir, err := os.Getwd()
 	if err != nil {
+		Error("Failed to get working directory: %v", err)
 		return nil, fmt.Errorf("failed to get working directory: %w", err)
 	}
 
 	terraformPath, err := exec.LookPath("terraform")
 	if err != nil {
+		Error("Terraform executable not found: %v", err)
 		return nil, fmt.Errorf("terraform executable not found: %w", err)
 	}
 
 	tf, err := tfexec.NewTerraform(workDir, terraformPath)
 	if err != nil {
+		Error("Failed to create Terraform executor: %v", err)
 		return nil, fmt.Errorf("failed to create Terraform executor: %w", err)
 	}
 
 	return tf, nil
 }
 
-// Format applies a canonical format to Terraform configuration files.
-// It runs `terraform fmt` in the current directory to ensure that all
-// Terraform files adhere to the standard formatting conventions.
+// Format applies canonical formatting to all Terraform files.
 func Format(recursive bool) error {
-	workDir, err := os.Getwd()
+	tf, err := GetFmtTerraform()
 	if err != nil {
-		return fmt.Errorf("failed to get working directory: %w", err)
+		return err
 	}
 
-	tf, err := GetFmtTerraform()
+	workDir, err := os.Getwd()
 	if err != nil {
-		return err
+		Error("Failed to get working directory: %v", err)
+		return fmt.Errorf("failed to get working directory: %w", err)
 	}
 
 	formatter := NewCustomFormatter(tf, workDir)

internal/terraform/graph.go

@@ -7,35 +7,38 @@ import (
 
 	"github.com/hashicorp/terraform-exec/tfexec"
 	tfjson "github.com/hashicorp/terraform-json"
-	"github.com/pterm/pterm"
 )
 
-// Graph generates a visual representation of Terraform resources
+// Graph generates a visual representation of Terraform resources.
+// It produces the Terraform DOT graph output, which can be visualized with Graphviz.
+// Uses Smurf unified logs for consistent and readable output.
 func Graph(dir string) error {
 	tf, err := GetTerraform(dir)
 	if err != nil {
+		Error("Failed to initialize Terraform: %v", err)
 		return err
 	}
 
-	spinner, err := pterm.DefaultSpinner.Start("Reading state...")
-	if err != nil {
-		spinner.Fail("Failed to read state")
-	}
+	Info("Starting Terraform graph generation...")
+
 	graphDOT, err := tf.Graph(context.Background(), tfexec.DrawCycles(true))
 	if err != nil {
-		spinner.Fail("Failed to generate graph")
-		return fmt.Errorf("error generating graph: %v", err)
+		Error("Error generating Terraform graph: %v", err)
+		return err
 	}
 
-	fmt.Print(graphDOT)
-
-	spinner.Success("Graph generated successfully")
+	fmt.Println()
+	Success("Terraform Dependency Graph (DOT Format):")
+	fmt.Println("-------------------------------------------------")
+	fmt.Println(graphDOT)
+	fmt.Println("-------------------------------------------------")
+	Info("You can visualize this graph using Graphviz, e.g.:\n  dot -Tpng graph.dot -o graph.png")
 
 	return nil
 }
 
-// generateDOTGraph generates a DOT graph from the Terraform state
-// that can be rendered using Graphviz
+// generateDOTGraph creates a DOT graph from the Terraform state.
+// This is an alternate approach for rendering using tfjson.State.
 func generateDOTGraph(state *tfjson.State) string {
 	var sb strings.Builder
 
@@ -48,12 +51,11 @@ func generateDOTGraph(state *tfjson.State) string {
 	}
 
 	sb.WriteString("}\n")
-
 	return sb.String()
 }
 
-// processModule processes a module and its resources to generate a DOT graph
-// representation of the Terraform state
+// processModule processes a Terraform module and its resources
+// to generate a DOT-compatible graph structure.
 func processModule(sb *strings.Builder, module *tfjson.StateModule, prefix string, processedNodes map[string]bool) {
 	if module == nil {
 		return
@@ -62,8 +64,8 @@ func processModule(sb *strings.Builder, module *tfjson.StateModule, prefix strin
 	moduleName := strings.TrimPrefix(prefix, ".")
 	if moduleName != "" {
 		sb.WriteString(fmt.Sprintf("  subgraph \"cluster_%s\" {\n", moduleName))
-		sb.WriteString(fmt.Sprintf("    label = \"%s\"\n", moduleName))
-		sb.WriteString("    fontname = \"sans-serif\"\n")
+		sb.WriteString(fmt.Sprintf("    label = \"%s\";\n", moduleName))
+		sb.WriteString("    fontname = \"sans-serif\";\n")
 	}
 
 	for _, resource := range module.Resources {
@@ -101,7 +103,7 @@ func processModule(sb *strings.Builder, module *tfjson.StateModule, prefix strin
 	}
 }
 
-// getResourceAddress returns the full address of a resource
+// getResourceAddress returns the full resource address including prefixes.
 func getResourceAddress(resource *tfjson.StateResource, prefix string) string {
 	if prefix == "" {
 		return resource.Address