Add debug logging to core compilation and CLI files (#3860)

Author: github-actions[bot]

pkg/cli/compile_command.go

@@ -265,9 +265,13 @@ func CompileWorkflows(config CompileConfig) ([]*workflow.WorkflowData, error) {
 
 	// Set validation based on the validate flag (false by default for compatibility)
 	compiler.SetSkipValidation(!validate)
+	compileLog.Printf("Validation enabled: %v", validate)
 
 	// Set noEmit flag to validate without generating lock files
 	compiler.SetNoEmit(noEmit)
+	if noEmit {
+		compileLog.Print("No-emit mode enabled: validating without generating lock files")
+	}
 
 	// Set strict mode if specified
 	compiler.SetStrictMode(strict)
@@ -302,6 +306,7 @@ func CompileWorkflows(config CompileConfig) ([]*workflow.WorkflowData, error) {
 	var workflowDataList []*workflow.WorkflowData
 
 	if len(markdownFiles) > 0 {
+		compileLog.Printf("Compiling %d specific workflow files", len(markdownFiles))
 		// Compile specific workflow files
 		var compiledCount int
 		var errorCount int
@@ -855,6 +860,7 @@ func watchAndCompileWorkflows(markdownFile string, compiler *workflow.Compiler,
 
 // compileAllWorkflowFiles compiles all markdown files in the workflows directory
 func compileAllWorkflowFiles(compiler *workflow.Compiler, workflowsDir string, verbose bool) (*CompilationStats, error) {
+	compileLog.Printf("Compiling all workflow files in directory: %s", workflowsDir)
 	// Reset warning count before compilation
 	compiler.ResetWarningCount()
 
@@ -868,12 +874,15 @@ func compileAllWorkflowFiles(compiler *workflow.Compiler, workflowsDir string, v
 	}
 
 	if len(mdFiles) == 0 {
+		compileLog.Printf("No markdown files found in %s", workflowsDir)
 		if verbose {
 			fmt.Printf("No markdown files found in %s\n", workflowsDir)
 		}
 		return stats, nil
 	}
 
+	compileLog.Printf("Found %d markdown files to compile", len(mdFiles))
+
 	// Compile each file
 	for _, file := range mdFiles {
 		stats.Total++

pkg/workflow/compiler_yaml.go

@@ -162,8 +162,11 @@ func (c *Compiler) generateYAML(data *WorkflowData, markdownPath string) (string
 }
 
 func (c *Compiler) generateMainJobSteps(yaml *strings.Builder, data *WorkflowData) {
+	compilerYamlLog.Printf("Generating main job steps for workflow: %s", data.Name)
+
 	// Determine if we need to add a checkout step
 	needsCheckout := c.shouldAddCheckoutStep(data)
+	compilerYamlLog.Printf("Checkout step needed: %t", needsCheckout)
 
 	// Add checkout step first if needed
 	if needsCheckout {
@@ -192,6 +195,7 @@ func (c *Compiler) generateMainJobSteps(yaml *strings.Builder, data *WorkflowDat
 	// Runtime detection now smartly filters out runtimes that already have setup actions
 	runtimeRequirements := DetectRuntimeRequirements(data)
 	runtimeSetupSteps := GenerateRuntimeSetupSteps(runtimeRequirements)
+	compilerYamlLog.Printf("Detected runtime requirements: %d runtimes, %d setup steps", len(runtimeRequirements), len(runtimeSetupSteps))
 	for _, step := range runtimeSetupSteps {
 		for _, line := range step {
 			yaml.WriteString(line + "\n")
@@ -245,6 +249,7 @@ func (c *Compiler) generateMainJobSteps(yaml *strings.Builder, data *WorkflowDat
 
 	// Add engine-specific installation steps (includes Node.js setup for npm-based engines)
 	installSteps := engine.GetInstallationSteps(data)
+	compilerYamlLog.Printf("Adding %d engine installation steps for %s", len(installSteps), engine.GetID())
 	for _, step := range installSteps {
 		for _, line := range step {
 			yaml.WriteString(line + "\n")
@@ -565,6 +570,8 @@ func splitContentIntoChunks(content string) []string {
 }
 
 func (c *Compiler) generatePrompt(yaml *strings.Builder, data *WorkflowData) {
+	compilerYamlLog.Printf("Generating prompt for workflow: %s (markdown size: %d bytes)", data.Name, len(data.MarkdownContent))
+
 	// Clean the markdown content
 	cleanedMarkdownContent := removeXMLComments(data.MarkdownContent)
 
@@ -587,6 +594,7 @@ func (c *Compiler) generatePrompt(yaml *strings.Builder, data *WorkflowData) {
 
 	// Split content into manageable chunks
 	chunks := splitContentIntoChunks(cleanedMarkdownContent)
+	compilerYamlLog.Printf("Split prompt into %d chunks", len(chunks))
 
 	// Create the initial prompt file step
 	yaml.WriteString("      - name: Create prompt\n")

pkg/workflow/expressions.go

@@ -212,12 +212,15 @@ func (c *ContainsNode) Render() string {
 
 // buildConditionTree creates a condition tree from existing if condition and new draft condition
 func buildConditionTree(existingCondition string, draftCondition string) ConditionNode {
+	expressionsLog.Printf("Building condition tree: existing=%q, draft=%q", existingCondition, draftCondition)
 	draftNode := &ExpressionNode{Expression: draftCondition}
 
 	if existingCondition == "" {
+		expressionsLog.Print("No existing condition, using draft only")
 		return draftNode
 	}
 
+	expressionsLog.Print("Combining existing and draft conditions with AND")
 	existingNode := &ExpressionNode{Expression: existingCondition}
 	return &AndNode{Left: existingNode, Right: draftNode}
 }
@@ -232,6 +235,7 @@ func buildAnd(left ConditionNode, right ConditionNode) ConditionNode {
 
 // buildReactionCondition creates a condition tree for the add_reaction job
 func buildReactionCondition() ConditionNode {
+	expressionsLog.Print("Building reaction condition for multiple event types")
 	// Build a list of event types that should trigger reactions using the new expression nodes
 	var terms []ConditionNode
 
@@ -563,6 +567,7 @@ func ParseExpression(expression string) (ConditionNode, error) {
 
 // tokenize breaks the expression string into tokens
 func (p *ExpressionParser) tokenize(expression string) ([]token, error) {
+	expressionsLog.Printf("Tokenizing expression of length %d", len(expression))
 	var tokens []token
 	i := 0
 
@@ -717,6 +722,9 @@ func (p *ExpressionParser) parseUnaryExpression() (ConditionNode, error) {
 
 // parsePrimaryExpression parses literals and parenthesized expressions
 func (p *ExpressionParser) parsePrimaryExpression() (ConditionNode, error) {
+	if expressionsLog.Enabled() {
+		expressionsLog.Printf("Parsing primary expression at token: %s", p.current().value)
+	}
 	switch p.current().kind {
 	case tokenLeftParen:
 		p.advance() // consume (

pkg/workflow/mcp-config.go

@@ -253,6 +253,7 @@ func renderAgenticWorkflowsMCPConfigTOML(yaml *strings.Builder) {
 // renderCustomMCPConfigWrapper generates custom MCP server configuration wrapper
 // This is a shared function used by both Claude and Custom engines
 func renderCustomMCPConfigWrapper(yaml *strings.Builder, toolName string, toolConfig map[string]any, isLast bool) error {
+	mcpLog.Printf("Rendering custom MCP config wrapper for tool: %s", toolName)
 	fmt.Fprintf(yaml, "              \"%s\": {\n", toolName)
 
 	// Use the shared MCP config renderer with JSON format
@@ -708,20 +709,25 @@ func getMCPConfig(toolConfig map[string]any, toolName string) (*parser.MCPServer
 
 	// Infer type from fields if not explicitly provided
 	if typeStr, hasType := config.GetString("type"); hasType {
+		mcpLog.Printf("MCP type explicitly set to: %s", typeStr)
 		// Normalize "local" to "stdio"
 		if typeStr == "local" {
 			result.Type = "stdio"
 		} else {
 			result.Type = typeStr
 		}
 	} else {
+		mcpLog.Print("No explicit MCP type, inferring from fields")
 		// Infer type from presence of fields
 		if _, hasURL := config.GetString("url"); hasURL {
 			result.Type = "http"
+			mcpLog.Printf("Inferred MCP type as http (has url field)")
 		} else if _, hasCommand := config.GetString("command"); hasCommand {
 			result.Type = "stdio"
+			mcpLog.Printf("Inferred MCP type as stdio (has command field)")
 		} else if _, hasContainer := config.GetString("container"); hasContainer {
 			result.Type = "stdio"
+			mcpLog.Printf("Inferred MCP type as stdio (has container field)")
 		} else {
 			return nil, fmt.Errorf("unable to determine MCP type for tool '%s': missing type, url, command, or container", toolName)
 		}
@@ -733,6 +739,7 @@ func getMCPConfig(toolConfig map[string]any, toolName string) (*parser.MCPServer
 	}
 
 	// Extract fields based on type
+	mcpLog.Printf("Extracting fields for MCP type: %s", result.Type)
 	switch result.Type {
 	case "stdio":
 		if command, hasCommand := config.GetString("command"); hasCommand {

pkg/workflow/safe_outputs.go

@@ -61,6 +61,8 @@ func generateSafeOutputsPromptSection(yaml *strings.Builder, safeOutputs *SafeOu
 		return
 	}
 
+	safeOutputsLog.Print("Generating safe outputs prompt section")
+
 	// Add output instructions for all engines (GH_AW_SAFE_OUTPUTS functionality)
 	yaml.WriteString("          \n")
 	yaml.WriteString("          ---\n")
@@ -624,10 +626,12 @@ type SafeOutputJobConfig struct {
 // 3. Invoke buildGitHubScriptStep
 // 4. Create Job with standard metadata
 func (c *Compiler) buildSafeOutputJob(data *WorkflowData, config SafeOutputJobConfig) (*Job, error) {
+	safeOutputsLog.Printf("Building safe output job: %s", config.JobName)
 	var steps []string
 
 	// Add pre-steps if provided (e.g., checkout, git config for create-pull-request)
 	if len(config.PreSteps) > 0 {
+		safeOutputsLog.Printf("Adding %d pre-steps to job", len(config.PreSteps))
 		steps = append(steps, config.PreSteps...)
 	}
 
@@ -651,6 +655,7 @@ func (c *Compiler) buildSafeOutputJob(data *WorkflowData, config SafeOutputJobCo
 	// Determine job condition
 	jobCondition := config.Condition
 	if jobCondition == nil {
+		safeOutputsLog.Printf("No custom condition provided, using default for job: %s", config.JobName)
 		jobCondition = BuildSafeOutputType(config.JobName)
 	}
 
@@ -659,6 +664,7 @@ func (c *Compiler) buildSafeOutputJob(data *WorkflowData, config SafeOutputJobCo
 	if len(needs) == 0 {
 		needs = []string{config.MainJobName}
 	}
+	safeOutputsLog.Printf("Job %s needs: %v", config.JobName, needs)
 
 	// Create the job with standard configuration
 	job := &Job{
@@ -680,6 +686,7 @@ func generateSafeOutputsConfig(data *WorkflowData) string {
 	if data.SafeOutputs == nil {
 		return ""
 	}
+	safeOutputsLog.Print("Generating safe outputs configuration for workflow")
 	// Create a simplified config object for validation
 	safeOutputsConfig := make(map[string]any)