Merge pull request #97 from pergatore/verbose_mode

feat(functionality): add -v, --verbose flag that prints output

Author: RoseSecurity

README.md

@@ -127,6 +127,7 @@ Flags:
   -b, --tf-binary string       Path to Terraform binary (env: TERRAMAID_TF_BINARY)
   -p, --tf-plan string         Path to Terraform plan file (env: TERRAMAID_TF_PLAN)
   -w, --working-dir string     Working directory for Terraform (env: TERRAMAID_WORKING_DIR) (default ".")
+  -v, --verbose bool           Verbose output to terminal (env: TERRAMAID_VERBOSE) (default false)
 
 Use "terramaid [command] --help" for more information about a command.
 ```

cmd/root.go

@@ -33,6 +33,9 @@ func init() {
 	rootCmd.AddCommand(docsCmd)
 	rootCmd.AddCommand(versionCmd)
 
+	// Add global flags
+	rootCmd.PersistentFlags().BoolP("verbose", "v", false, "Enable verbose output")
+
 	// Disable auto-generated string from documentation so that documentation is cleanly built and updated
 	rootCmd.DisableAutoGenTag = true
 }

cmd/run.go

@@ -22,6 +22,7 @@ type options struct {
 	Direction    string `env:"DIRECTION" envDefault:"TD"`
 	SubgraphName string `env:"SUBGRAPH_NAME" envDefault:"Terraform"`
 	ChartType    string `env:"CHART_TYPE" envDefault:"flowchart"`
+	Verbose      bool   `env:"VERBOSE" envDefault:"false"`
 }
 
 var opts options // Global variable for flags and env variables
@@ -38,6 +39,17 @@ var runCmd = &cobra.Command{
 }
 
 func generateDiagrams(opts *options) error {
+	if opts.Verbose {
+		utils.LogVerbose("Starting Terramaid with the following options:")
+		utils.LogVerbose("- Working Directory: %s", opts.WorkingDir)
+		utils.LogVerbose("- Terraform Plan: %s", opts.TFPlan)
+		utils.LogVerbose("- Terraform Binary: %s", opts.TFBinary)
+		utils.LogVerbose("- Output File: %s", opts.Output)
+		utils.LogVerbose("- Direction: %s", opts.Direction)
+		utils.LogVerbose("- Subgraph Name: %s", opts.SubgraphName)
+		utils.LogVerbose("- Chart Type: %s", opts.ChartType)
+	}
+
 	if opts.WorkingDir != "" {
 		exists, err := utils.TerraformFilesExist(opts.WorkingDir)
 		if err != nil {
@@ -46,6 +58,9 @@ func generateDiagrams(opts *options) error {
 		if !exists {
 			return fmt.Errorf("Terraform files do not exist in directory \"%s\"", opts.WorkingDir)
 		}
+		if opts.Verbose {
+			utils.LogVerbose("Confirmed Terraform files exist in %s", opts.WorkingDir)
+		}
 	}
 
 	// Validate directories and files
@@ -60,26 +75,38 @@ func generateDiagrams(opts *options) error {
 			return fmt.Errorf("error finding Terraform binary: %w", err)
 		}
 		opts.TFBinary = tfBinary
+		if opts.Verbose {
+			utils.LogVerbose("Terraform binary found at: %s", opts.TFBinary)
+		}
 	}
 
 	// Spinner initialization and graph parsing
 	sp := utils.NewSpinner("Generating Terramaid Diagrams")
 	sp.Start()
 
-	graph, err := internal.ParseTerraform(opts.WorkingDir, opts.TFBinary, opts.TFPlan)
+	if opts.Verbose {
+		utils.LogVerbose("Initializing Terraform and building graph...")
+	}
+	graph, err := internal.ParseTerraform(opts.WorkingDir, opts.TFBinary, opts.TFPlan, opts.Verbose)
 	if err != nil {
 		sp.Stop()
 		return fmt.Errorf("error parsing Terraform: %w", err)
 	}
 
 	// Generate the Mermaid diagram
-	mermaidDiagram, err := internal.GenerateMermaidFlowchart(graph, opts.Direction, opts.SubgraphName)
+	if opts.Verbose {
+		utils.LogVerbose("Generating Mermaid flowchart...")
+	}
+	mermaidDiagram, err := internal.GenerateMermaidFlowchart(graph, opts.Direction, opts.SubgraphName, opts.Verbose)
 	if err != nil {
 		sp.Stop()
 		return fmt.Errorf("error generating Mermaid diagram: %w", err)
 	}
 
 	// Write the Mermaid diagram to the specified output file
+	if opts.Verbose {
+		utils.LogVerbose("Writing Mermaid diagram to %s", opts.Output)
+	}
 	if err := os.WriteFile(opts.Output, []byte(mermaidDiagram), 0o644); err != nil {
 		sp.Stop()
 		return fmt.Errorf("error writing to file: %w", err)
@@ -105,6 +132,7 @@ func init() {
 	runCmd.Flags().StringVarP(&opts.TFPlan, "tf-plan", "p", opts.TFPlan, "Path to Terraform plan file (env: TERRAMAID_TF_PLAN)")
 	runCmd.Flags().StringVarP(&opts.TFBinary, "tf-binary", "b", opts.TFBinary, "Path to Terraform binary (env: TERRAMAID_TF_BINARY)")
 	runCmd.Flags().StringVarP(&opts.WorkingDir, "working-dir", "w", opts.WorkingDir, "Working directory for Terraform (env: TERRAMAID_WORKING_DIR)")
+	runCmd.Flags().BoolVarP(&opts.Verbose, "verbose", "v", opts.Verbose, "Enable verbose output (env: TERRAMAID_VERBOSE)")
 
 	// Disable auto-generated string from documentation so that documentation is cleanly built and updated
 	runCmd.DisableAutoGenTag = true

internal/flowchart.go

@@ -8,6 +8,7 @@ import (
 	"regexp"
 	"strings"
 
+	"github.com/RoseSecurity/terramaid/pkg/utils"
 	"github.com/awalterschulze/gographviz"
 )
 
@@ -39,12 +40,19 @@ func CleanLabel(label string) string {
 }
 
 // GenerateMermaidFlowchart generates a Mermaid diagram from a gographviz graph
-func GenerateMermaidFlowchart(graph *gographviz.Graph, direction string, subgraphName string) (string, error) {
+func GenerateMermaidFlowchart(graph *gographviz.Graph, direction string, subgraphName string, verbose bool) (string, error) {
 	validDirections := map[string]bool{"TB": true, "TD": true, "BT": true, "RL": true, "LR": true}
 	if !validDirections[direction] {
 		return "", fmt.Errorf("invalid direction %s: valid options are TB, TD, BT, RL, LR", direction)
 	}
 
+	if verbose {
+		utils.LogVerbose("Generating Mermaid flowchart with direction: %s", direction)
+		if subgraphName != "" {
+			utils.LogVerbose("Using subgraph name: %s", subgraphName)
+		}
+	}
+
 	var sb strings.Builder
 	sb.WriteString(fmt.Sprintf("```mermaid\nflowchart %s\n", direction))
 
@@ -53,9 +61,12 @@ func GenerateMermaidFlowchart(graph *gographviz.Graph, direction string, subgrap
 	}
 
 	addedNodes := make(map[string]string)
-
 	addedProviders := make(map[string]bool)
 
+	if verbose {
+		utils.LogVerbose("Processing %d nodes", len(graph.Nodes.Nodes))
+	}
+
 	for _, node := range graph.Nodes.Nodes {
 		nodeID := CleanID(node.Name)
 		nodeLabel := CleanLabel(node.Attrs["label"])
@@ -69,18 +80,28 @@ func GenerateMermaidFlowchart(graph *gographviz.Graph, direction string, subgrap
 				continue
 			}
 			addedProviders[nodeID] = true
+			if verbose {
+				utils.LogVerbose("Added provider node: %s", nodeID)
+			}
 		}
 
 		if _, exists := addedNodes[nodeID]; !exists {
 			sb.WriteString(fmt.Sprintf("        %s[\"%s\"]\n", nodeID, nodeLabel))
 			addedNodes[nodeID] = nodeLabel
+			if verbose && !strings.HasPrefix(nodeLabel, "provider:") {
+				utils.LogVerbose("Added node: %s", nodeID)
+			}
 		}
 	}
 
 	if subgraphName != "" {
 		sb.WriteString("    end\n")
 	}
 
+	if verbose {
+		utils.LogVerbose("Processing %d edges", len(graph.Edges.Edges))
+	}
+
 	for _, edge := range graph.Edges.Edges {
 		fromID := CleanID(edge.Src)
 		toID := CleanID(edge.Dst)
@@ -90,6 +111,9 @@ func GenerateMermaidFlowchart(graph *gographviz.Graph, direction string, subgrap
 			if fromLabel != "" {
 				sb.WriteString(fmt.Sprintf("        %s[\"%s\"]\n", fromID, fromLabel))
 				addedNodes[fromID] = fromLabel
+				if verbose {
+					utils.LogVerbose("Added source node from edge: %s", fromID)
+				}
 			}
 		}
 
@@ -98,12 +122,25 @@ func GenerateMermaidFlowchart(graph *gographviz.Graph, direction string, subgrap
 			if toLabel != "" {
 				sb.WriteString(fmt.Sprintf("        %s[\"%s\"]\n", toID, toLabel))
 				addedNodes[toID] = toLabel
+				if verbose {
+					utils.LogVerbose("Added destination node from edge: %s", toID)
+				}
 			}
 		}
 
 		sb.WriteString(fmt.Sprintf("    %s --> %s\n", fromID, toID))
+		if verbose {
+			utils.LogVerbose("Added edge: %s --> %s", fromID, toID)
+		}
 	}
 
 	sb.WriteString("```\n")
+	
+	if verbose {
+		nodeCount := len(addedNodes)
+		edgeCount := len(graph.Edges.Edges)
+		utils.LogVerbose("Mermaid diagram generation complete with %d nodes and %d edges", nodeCount, edgeCount)
+	}
+	
 	return sb.String(), nil
 }

internal/parse.go

@@ -7,6 +7,7 @@ import (
 	"context"
 	"fmt"
 
+	"github.com/RoseSecurity/terramaid/pkg/utils"
 	"github.com/awalterschulze/gographviz"
 	"github.com/hashicorp/terraform-exec/tfexec"
 )
@@ -20,23 +21,42 @@ const emptyGraph = `digraph G {
 `
 
 // ParseTerraform parses the Terraform plan and returns the generated graph
-func ParseTerraform(workingDir, tfPath, planFile string) (*gographviz.Graph, error) {
+func ParseTerraform(workingDir, tfPath, planFile string, verbose bool) (*gographviz.Graph, error) {
 	ctx := context.Background()
+	
+	if verbose {
+		utils.LogVerbose("Initializing Terraform with working directory: %s", workingDir)
+		utils.LogVerbose("Using Terraform binary: %s", tfPath)
+	}
+	
 	tf, err := tfexec.NewTerraform(workingDir, tfPath)
 	if err != nil {
 		return nil, err
 	}
 
+	if verbose {
+		utils.LogVerbose("Running terraform init with upgrade=true")
+	}
+	
 	if err := tf.Init(ctx, tfexec.Upgrade(true)); err != nil {
 		return nil, err
 	}
 
 	opts := &tfexec.GraphPlanOption{}
 
 	if planFile != "" {
+		if verbose {
+			utils.LogVerbose("Using plan file for graph generation: %s", planFile)
+		}
 		opts = tfexec.GraphPlan(planFile)
+	} else if verbose {
+		utils.LogVerbose("No plan file specified, using current state")
 	}
 
+	if verbose {
+		utils.LogVerbose("Running terraform graph command")
+	}
+	
 	output, err := tf.Graph(ctx, opts)
 	if err != nil {
 		return nil, err
@@ -46,6 +66,11 @@ func ParseTerraform(workingDir, tfPath, planFile string) (*gographviz.Graph, err
 		return nil, fmt.Errorf("no output from terraform graph")
 	}
 
+	if verbose {
+		utils.LogVerbose("Successfully retrieved graph output from Terraform")
+		utils.LogVerbose("Parsing DOT output")
+	}
+
 	// Parse the DOT output
 	graphAst, err := gographviz.ParseString(string(output))
 	if err != nil {
@@ -54,9 +79,18 @@ func ParseTerraform(workingDir, tfPath, planFile string) (*gographviz.Graph, err
 
 	graph := gographviz.NewGraph()
 
+	if verbose {
+		utils.LogVerbose("Analyzing graph structure")
+	}
+
 	if err := gographviz.Analyse(graphAst, graph); err != nil {
 		return nil, err
 	}
 
+	if verbose {
+		utils.LogVerbose("Graph analysis complete")
+		utils.LogVerbose("Found %d nodes and %d edges", len(graph.Nodes.Nodes), len(graph.Edges.Edges))
+	}
+
 	return graph, nil
 }

pkg/utils/logging.go

@@ -5,6 +5,7 @@ package utils
 
 import (
 	"errors"
+	"fmt"
 	"os"
 	"os/exec"
 
@@ -45,3 +46,10 @@ func LogError(err error) {
 		}
 	}
 }
+
+// LogVerbose logs messages in verbose mode
+func LogVerbose(format string, a ...interface{}) {
+	c := color.New(color.FgBlue)
+	message := fmt.Sprintf(format, a...)
+	c.Fprintf(color.Output, "[VERBOSE] %s\n", message)
+}