Add conditional verbose logging for debugging

- Add --verbose-logs CLI flag (disabled by default)
- Generate log statements in BindApp/Render only when flag is enabled
- Only generate guix_helpers_gen.go when verbose logging is enabled
- Enable verbose logging in CI/CD workflows for easier debugging
- Keep generated files clean (no logs) in repository by default

This makes it easier to debug component lifecycle issues in test
pipelines while keeping production code clean and efficient.

Author: claude

.github/workflows/e2e.yml

@@ -30,7 +30,7 @@ jobs:
 
       - name: Generate and build counter example
         run: |
-          ./guix generate -p examples/counter
+          ./guix generate -p examples/counter --verbose-logs
           cd examples/counter
           # Copy wasm_exec.js from Go installation
           GOROOT="$(go env GOROOT)"
@@ -89,7 +89,7 @@ jobs:
 
       - name: Generate and build calculator example
         run: |
-          ./guix generate -p examples/calculator
+          ./guix generate -p examples/calculator --verbose-logs
           cd examples/calculator
 
           # Copy wasm_exec.js from Go installation

cmd/guix/main.go

@@ -52,6 +52,10 @@ func main() {
 						Name:  "verbose",
 						Usage: "Verbose output",
 					},
+					&cli.BoolFlag{
+						Name:  "verbose-logs",
+						Usage: "Generate verbose logging statements in code (for debugging)",
+					},
 				},
 				Action: runGenerate,
 			},
@@ -115,6 +119,7 @@ func runGenerate(c *cli.Context) error {
 	watchMode := c.Bool("watch")
 	lazy := c.Bool("lazy")
 	verbose := c.Bool("verbose")
+	verboseLogs := c.Bool("verbose-logs")
 
 	// Load or create cache
 	var genCache *cache.Cache
@@ -127,13 +132,15 @@ func runGenerate(c *cli.Context) error {
 		}
 	}
 
-	// Generate helpers file first
-	if err := generateHelpersFile(path); err != nil {
-		return fmt.Errorf("failed to generate helpers: %w", err)
+	// Generate helpers file first (only if verbose logs are enabled)
+	if verboseLogs {
+		if err := generateHelpersFile(path); err != nil {
+			return fmt.Errorf("failed to generate helpers: %w", err)
+		}
 	}
 
 	// Generate all files initially
-	if err := generateAll(path, genCache, verbose); err != nil {
+	if err := generateAll(path, genCache, verbose, verboseLogs); err != nil {
 		return err
 	}
 
@@ -146,13 +153,13 @@ func runGenerate(c *cli.Context) error {
 
 	// Watch mode
 	if watchMode {
-		return watchFiles(path, genCache, verbose, lazy)
+		return watchFiles(path, genCache, verbose, verboseLogs, lazy)
 	}
 
 	return nil
 }
 
-func generateAll(root string, genCache *cache.Cache, verbose bool) error {
+func generateAll(root string, genCache *cache.Cache, verbose bool, verboseLogs bool) error {
 	p, err := parser.New()
 	if err != nil {
 		return fmt.Errorf("failed to create parser: %w", err)
@@ -191,7 +198,7 @@ func generateAll(root string, genCache *cache.Cache, verbose bool) error {
 			}
 		}
 
-		if err := generateFile(path, p, verbose); err != nil {
+		if err := generateFile(path, p, verbose, verboseLogs); err != nil {
 			return fmt.Errorf("failed to generate %s: %w", path, err)
 		}
 
@@ -231,7 +238,7 @@ func formatFile(path string) error {
 	return nil
 }
 
-func generateFile(srcPath string, p *parser.Parser, verbose bool) error {
+func generateFile(srcPath string, p *parser.Parser, verbose bool, verboseLogs bool) error {
 	if verbose {
 		log.Printf("Generating %s", srcPath)
 	}
@@ -255,6 +262,7 @@ func generateFile(srcPath string, p *parser.Parser, verbose bool) error {
 
 	// Generate Go code
 	gen := codegen.New(file.Package)
+	gen.SetVerbose(verboseLogs)
 	output, err := gen.Generate(file)
 	if err != nil {
 		return err
@@ -278,7 +286,7 @@ func generateFile(srcPath string, p *parser.Parser, verbose bool) error {
 	return nil
 }
 
-func watchFiles(root string, genCache *cache.Cache, verbose bool, lazy bool) error {
+func watchFiles(root string, genCache *cache.Cache, verbose bool, verboseLogs bool, lazy bool) error {
 	watcher, err := fsnotify.NewWatcher()
 	if err != nil {
 		return fmt.Errorf("failed to create watcher: %w", err)
@@ -346,7 +354,7 @@ func watchFiles(root string, genCache *cache.Cache, verbose bool, lazy bool) err
 
 					log.Printf("File changed: %s", event.Name)
 
-					if err := generateFile(event.Name, p, verbose); err != nil {
+					if err := generateFile(event.Name, p, verbose, verboseLogs); err != nil {
 						log.Printf("Error generating %s: %v", event.Name, err)
 					} else {
 						log.Printf("Successfully regenerated %s", event.Name)

examples/calculator/app_gen.go

@@ -29,6 +29,7 @@ type Generator struct {
 	currentCompBody     *guixast.Body                            // Current component body being generated
 	currentComp         *guixast.Component                       // Current component being generated
 	componentParams     map[string]bool                          // Track current component's parameter names
+	verbose             bool                                     // Generate verbose logging statements
 }
 
 // New creates a new code generator
@@ -37,9 +38,15 @@ func New(pkg string) *Generator {
 		fset:       token.NewFileSet(),
 		pkg:        pkg,
 		components: make(map[string]bool),
+		verbose:    false, // Verbose logging disabled by default
 	}
 }
 
+// SetVerbose enables or disables verbose logging in generated code
+func (g *Generator) SetVerbose(verbose bool) {
+	g.verbose = verbose
+}
+
 // isComponentFunc checks if a function is a UI component (returns Component interface)
 // or just a regular helper function
 func (g *Generator) isComponentFunc(comp *guixast.Component) bool {
@@ -854,10 +861,12 @@ func (g *Generator) generateRenderMethod(comp *guixast.Component) *ast.FuncDecl
 				},
 			},
 		},
-		Body: &ast.BlockStmt{
-			List: []ast.Stmt{
-				// log("ComponentName: Render called")
-				&ast.ExprStmt{
+		Body: func() *ast.BlockStmt {
+			stmts := []ast.Stmt{}
+
+			// Add verbose logging if enabled
+			if g.verbose {
+				stmts = append(stmts, &ast.ExprStmt{
 					X: &ast.CallExpr{
 						Fun: ast.NewIdent("log"),
 						Args: []ast.Expr{
@@ -867,12 +876,16 @@ func (g *Generator) generateRenderMethod(comp *guixast.Component) *ast.FuncDecl
 							},
 						},
 					},
-				},
-				&ast.ReturnStmt{
-					Results: []ast.Expr{body},
-				},
-			},
-		},
+				})
+			}
+
+			// Add return statement
+			stmts = append(stmts, &ast.ReturnStmt{
+				Results: []ast.Expr{body},
+			})
+
+			return &ast.BlockStmt{List: stmts}
+		}(),
 	}
 }
 
@@ -1941,9 +1954,11 @@ func (g *Generator) generateUpdateMethod(comp *guixast.Component) *ast.FuncDecl
 
 // generateBindAppMethod generates the BindApp method for components with channels
 func (g *Generator) generateBindAppMethod(comp *guixast.Component) *ast.FuncDecl {
-	stmts := []ast.Stmt{
-		// log("ComponentName: BindApp called")
-		&ast.ExprStmt{
+	stmts := []ast.Stmt{}
+
+	// Add verbose logging if enabled
+	if g.verbose {
+		stmts = append(stmts, &ast.ExprStmt{
 			X: &ast.CallExpr{
 				Fun: ast.NewIdent("log"),
 				Args: []ast.Expr{
@@ -1953,8 +1968,11 @@ func (g *Generator) generateBindAppMethod(comp *guixast.Component) *ast.FuncDecl
 					},
 				},
 			},
-		},
-		// c.app = app
+		})
+	}
+
+	// c.app = app
+	stmts = append(stmts,
 		&ast.AssignStmt{
 			Lhs: []ast.Expr{
 				&ast.SelectorExpr{
@@ -1965,7 +1983,7 @@ func (g *Generator) generateBindAppMethod(comp *guixast.Component) *ast.FuncDecl
 			Tok: token.ASSIGN,
 			Rhs: []ast.Expr{ast.NewIdent("app")},
 		},
-	}
+	)
 
 	// Check if component has channel parameters
 	hasChannels := g.hasChannelParams(comp)