Add --raw-field flag to run command for workflow_dispatch inputs

cmd/gh-aw/main.go

@@ -274,7 +274,8 @@ Examples:
   gh aw run daily-perf-improver --ref main  # Run on specific branch
   gh aw run daily-perf-improver --repeat 3  # Run 3 times total
   gh aw run daily-perf-improver --enable-if-needed # Enable if disabled, run, then restore state
-  gh aw run daily-perf-improver --auto-merge-prs # Auto-merge any PRs created during execution`,
+  gh aw run daily-perf-improver --auto-merge-prs # Auto-merge any PRs created during execution
+  gh aw run daily-perf-improver -f name=value -f env=prod  # Pass workflow inputs`,
 	Args: cobra.MinimumNArgs(1),
 	RunE: func(cmd *cobra.Command, args []string) error {
 		repeatCount, _ := cmd.Flags().GetInt("repeat")
@@ -284,12 +285,13 @@ Examples:
 		refOverride, _ := cmd.Flags().GetString("ref")
 		autoMergePRs, _ := cmd.Flags().GetBool("auto-merge-prs")
 		pushSecrets, _ := cmd.Flags().GetBool("use-local-secrets")
+		inputs, _ := cmd.Flags().GetStringArray("raw-field")
 
 		if err := validateEngine(engineOverride); err != nil {
 			return err
 		}
 
-		return cli.RunWorkflowsOnGitHub(args, repeatCount, enable, engineOverride, repoOverride, refOverride, autoMergePRs, pushSecrets, verboseFlag)
+		return cli.RunWorkflowsOnGitHub(args, repeatCount, enable, engineOverride, repoOverride, refOverride, autoMergePRs, pushSecrets, inputs, verboseFlag)
 	},
 }
 
@@ -475,6 +477,7 @@ Use "` + constants.CLIExtensionPrefix + ` help all" to show help for all command
 	runCmd.Flags().String("ref", "", "Branch or tag name to run the workflow on (default: current branch)")
 	runCmd.Flags().Bool("auto-merge-prs", false, "Auto-merge any pull requests created during the workflow execution")
 	runCmd.Flags().Bool("use-local-secrets", false, "Use local environment API key secrets for workflow execution (pushes and cleans up secrets in repository)")
+	runCmd.Flags().StringArrayP("raw-field", "f", []string{}, "Add a string parameter in key=value format (can be used multiple times)")
 	// Register completions for run command
 	runCmd.ValidArgsFunction = cli.CompleteWorkflowNames
 	cli.RegisterEngineFlagCompletion(runCmd)

pkg/cli/commands_test.go

@@ -336,39 +336,39 @@ func TestDisableWorkflowsFailureScenarios(t *testing.T) {
 
 func TestRunWorkflowOnGitHub(t *testing.T) {
 	// Test with empty workflow name
-	err := RunWorkflowOnGitHub("", false, "", "", "", false, false, false, false)
+	err := RunWorkflowOnGitHub("", false, "", "", "", false, false, false, []string{}, false)
 	if err == nil {
 		t.Error("RunWorkflowOnGitHub should return error for empty workflow name")
 	}
 
 	// Test with nonexistent workflow (this will fail but gracefully)
-	err = RunWorkflowOnGitHub("nonexistent-workflow", false, "", "", "", false, false, false, false)
+	err = RunWorkflowOnGitHub("nonexistent-workflow", false, "", "", "", false, false, false, []string{}, false)
 	if err == nil {
 		t.Error("RunWorkflowOnGitHub should return error for non-existent workflow")
 	}
 }
 
 func TestRunWorkflowsOnGitHub(t *testing.T) {
 	// Test with empty workflow list
-	err := RunWorkflowsOnGitHub([]string{}, 0, false, "", "", "", false, false, false)
+	err := RunWorkflowsOnGitHub([]string{}, 0, false, "", "", "", false, false, []string{}, false)
 	if err == nil {
 		t.Error("RunWorkflowsOnGitHub should return error for empty workflow list")
 	}
 
 	// Test with workflow list containing empty name
-	err = RunWorkflowsOnGitHub([]string{"valid-workflow", ""}, 0, false, "", "", "", false, false, false)
+	err = RunWorkflowsOnGitHub([]string{"valid-workflow", ""}, 0, false, "", "", "", false, false, []string{}, false)
 	if err == nil {
 		t.Error("RunWorkflowsOnGitHub should return error for workflow list containing empty name")
 	}
 
 	// Test with nonexistent workflows (this will fail but gracefully)
-	err = RunWorkflowsOnGitHub([]string{"nonexistent-workflow1", "nonexistent-workflow2"}, 0, false, "", "", "", false, false, false)
+	err = RunWorkflowsOnGitHub([]string{"nonexistent-workflow1", "nonexistent-workflow2"}, 0, false, "", "", "", false, false, []string{}, false)
 	if err == nil {
 		t.Error("RunWorkflowsOnGitHub should return error for non-existent workflows")
 	}
 
 	// Test with negative repeat seconds (should work as 0)
-	err = RunWorkflowsOnGitHub([]string{"nonexistent-workflow"}, -1, false, "", "", "", false, false, false)
+	err = RunWorkflowsOnGitHub([]string{"nonexistent-workflow"}, -1, false, "", "", "", false, false, []string{}, false)
 	if err == nil {
 		t.Error("RunWorkflowsOnGitHub should return error for non-existent workflow regardless of repeat value")
 	}
@@ -421,12 +421,16 @@ Test workflow for command existence.`
 			_, err := CompileWorkflows(config)
 			return err
 		}, false, "CompileWorkflows"},
-		{func() error { return RemoveWorkflows("nonexistent", false) }, false, "RemoveWorkflows"},                                           // Should handle missing directory gracefully
-		{func() error { return StatusWorkflows("nonexistent", false, false, "", "") }, false, "StatusWorkflows"},                            // Should handle missing directory gracefully
-		{func() error { return EnableWorkflows("nonexistent") }, true, "EnableWorkflows"},                                                   // Should now error when no workflows found to enable
-		{func() error { return DisableWorkflows("nonexistent") }, true, "DisableWorkflows"},                                                 // Should now also error when no workflows found to disable
-		{func() error { return RunWorkflowOnGitHub("", false, "", "", "", false, false, false, false) }, true, "RunWorkflowOnGitHub"},       // Should error with empty workflow name
-		{func() error { return RunWorkflowsOnGitHub([]string{}, 0, false, "", "", "", false, false, false) }, true, "RunWorkflowsOnGitHub"}, // Should error with empty workflow list
+		{func() error { return RemoveWorkflows("nonexistent", false) }, false, "RemoveWorkflows"},                // Should handle missing directory gracefully
+		{func() error { return StatusWorkflows("nonexistent", false, false, "", "") }, false, "StatusWorkflows"}, // Should handle missing directory gracefully
+		{func() error { return EnableWorkflows("nonexistent") }, true, "EnableWorkflows"},                        // Should now error when no workflows found to enable
+		{func() error { return DisableWorkflows("nonexistent") }, true, "DisableWorkflows"},                      // Should now also error when no workflows found to disable
+		{func() error {
+			return RunWorkflowOnGitHub("", false, "", "", "", false, false, false, []string{}, false)
+		}, true, "RunWorkflowOnGitHub"}, // Should error with empty workflow name
+		{func() error {
+			return RunWorkflowsOnGitHub([]string{}, 0, false, "", "", "", false, false, []string{}, false)
+		}, true, "RunWorkflowsOnGitHub"}, // Should error with empty workflow list
 	}
 
 	for _, test := range tests {
@@ -1073,13 +1077,13 @@ func TestCalculateTimeRemaining(t *testing.T) {
 
 func TestRunWorkflowOnGitHubWithEnable(t *testing.T) {
 	// Test with enable flag enabled (should not error for basic validation)
-	err := RunWorkflowOnGitHub("nonexistent-workflow", true, "", "", "", false, false, false, false)
+	err := RunWorkflowOnGitHub("nonexistent-workflow", true, "", "", "", false, false, false, []string{}, false)
 	if err == nil {
 		t.Error("RunWorkflowOnGitHub should return error for non-existent workflow even with enable flag")
 	}
 
 	// Test with empty workflow name and enable flag
-	err = RunWorkflowOnGitHub("", true, "", "", "", false, false, false, false)
+	err = RunWorkflowOnGitHub("", true, "", "", "", false, false, false, []string{}, false)
 	if err == nil {
 		t.Error("RunWorkflowOnGitHub should return error for empty workflow name regardless of enable flag")
 	}

pkg/cli/run_command.go

@@ -21,13 +21,25 @@ import (
 var runLog = logger.New("cli:run_command")
 
 // RunWorkflowOnGitHub runs an agentic workflow on GitHub Actions
-func RunWorkflowOnGitHub(workflowIdOrName string, enable bool, engineOverride string, repoOverride string, refOverride string, autoMergePRs bool, pushSecrets bool, waitForCompletion bool, verbose bool) error {
-	runLog.Printf("Starting workflow run: workflow=%s, enable=%v, engineOverride=%s, repo=%s, ref=%s, wait=%v", workflowIdOrName, enable, engineOverride, repoOverride, refOverride, waitForCompletion)
+func RunWorkflowOnGitHub(workflowIdOrName string, enable bool, engineOverride string, repoOverride string, refOverride string, autoMergePRs bool, pushSecrets bool, waitForCompletion bool, inputs []string, verbose bool) error {
+	runLog.Printf("Starting workflow run: workflow=%s, enable=%v, engineOverride=%s, repo=%s, ref=%s, wait=%v, inputs=%v", workflowIdOrName, enable, engineOverride, repoOverride, refOverride, waitForCompletion, inputs)
 
 	if workflowIdOrName == "" {
 		return fmt.Errorf("workflow name or ID is required")
 	}
 
+	// Validate input format early before attempting workflow validation
+	for _, input := range inputs {
+		if !strings.Contains(input, "=") {
+			return fmt.Errorf("invalid input format '%s': expected key=value", input)
+		}
+		// Check that key (before '=') is not empty
+		parts := strings.SplitN(input, "=", 2)
+		if len(parts[0]) == 0 {
+			return fmt.Errorf("invalid input format '%s': key cannot be empty", input)
+		}
+	}
+
 	if verbose {
 		fmt.Printf("Running workflow on GitHub Actions: %s\n", workflowIdOrName)
 	}
@@ -303,6 +315,14 @@ func RunWorkflowOnGitHub(workflowIdOrName string, enable bool, engineOverride st
 		args = append(args, "--ref", ref)
 	}
 
+	// Add workflow inputs if provided
+	if len(inputs) > 0 {
+		for _, input := range inputs {
+			// Add as raw field flag to gh workflow run
+			args = append(args, "-f", input)
+		}
+	}
+
 	// Record the start time for auto-merge PR filtering
 	workflowStartTime := time.Now()
 
@@ -318,6 +338,11 @@ func RunWorkflowOnGitHub(workflowIdOrName string, enable bool, engineOverride st
 		if ref != "" {
 			cmdParts = append(cmdParts, "--ref", ref)
 		}
+		if len(inputs) > 0 {
+			for _, input := range inputs {
+				cmdParts = append(cmdParts, "-f", input)
+			}
+		}
 		fmt.Printf("Executing: %s\n", strings.Join(cmdParts, " "))
 	}
 
@@ -427,7 +452,7 @@ func RunWorkflowOnGitHub(workflowIdOrName string, enable bool, engineOverride st
 }
 
 // RunWorkflowsOnGitHub runs multiple agentic workflows on GitHub Actions, optionally repeating a specified number of times
-func RunWorkflowsOnGitHub(workflowNames []string, repeatCount int, enable bool, engineOverride string, repoOverride string, refOverride string, autoMergePRs bool, pushSecrets bool, verbose bool) error {
+func RunWorkflowsOnGitHub(workflowNames []string, repeatCount int, enable bool, engineOverride string, repoOverride string, refOverride string, autoMergePRs bool, pushSecrets bool, inputs []string, verbose bool) error {
 	if len(workflowNames) == 0 {
 		return fmt.Errorf("at least one workflow name or ID is required")
 	}
@@ -474,7 +499,7 @@ func RunWorkflowsOnGitHub(workflowNames []string, repeatCount int, enable bool,
 				fmt.Println(console.FormatProgressMessage(fmt.Sprintf("Running workflow %d/%d: %s", i+1, len(workflowNames), workflowName)))
 			}
 
-			if err := RunWorkflowOnGitHub(workflowName, enable, engineOverride, repoOverride, refOverride, autoMergePRs, pushSecrets, waitForCompletion, verbose); err != nil {
+			if err := RunWorkflowOnGitHub(workflowName, enable, engineOverride, repoOverride, refOverride, autoMergePRs, pushSecrets, waitForCompletion, inputs, verbose); err != nil {
 				return fmt.Errorf("failed to run workflow '%s': %w", workflowName, err)
 			}
 

pkg/cli/run_command_test.go

@@ -133,10 +133,10 @@ func TestProgressFlagSignature(t *testing.T) {
 	// This is a compile-time check more than a runtime check
 
 	// RunWorkflowOnGitHub should NOT accept progress parameter anymore
-	_ = RunWorkflowOnGitHub("test", false, "", "", "", false, false, false, false)
+	_ = RunWorkflowOnGitHub("test", false, "", "", "", false, false, false, []string{}, false)
 
 	// RunWorkflowsOnGitHub should NOT accept progress parameter anymore
-	_ = RunWorkflowsOnGitHub([]string{"test"}, 0, false, "", "", "", false, false, false)
+	_ = RunWorkflowsOnGitHub([]string{"test"}, 0, false, "", "", "", false, false, []string{}, false)
 
 	// getLatestWorkflowRunWithRetry should NOT accept progress parameter anymore
 	_, _ = getLatestWorkflowRunWithRetry("test.lock.yml", "", false)
@@ -146,23 +146,103 @@ func TestProgressFlagSignature(t *testing.T) {
 func TestRefFlagSignature(t *testing.T) {
 	// Test that RunWorkflowOnGitHub accepts refOverride parameter
 	// This is a compile-time check that ensures the refOverride parameter exists
-	_ = RunWorkflowOnGitHub("test", false, "", "", "main", false, false, false, false)
+	_ = RunWorkflowOnGitHub("test", false, "", "", "main", false, false, false, []string{}, false)
 
 	// Test that RunWorkflowsOnGitHub accepts refOverride parameter
-	_ = RunWorkflowsOnGitHub([]string{"test"}, 0, false, "", "", "main", false, false, false)
+	_ = RunWorkflowsOnGitHub([]string{"test"}, 0, false, "", "", "main", false, false, []string{}, false)
 }
 
 // TestRunWorkflowOnGitHubWithRef tests that the ref parameter is handled correctly
 func TestRunWorkflowOnGitHubWithRef(t *testing.T) {
 	// Test with explicit ref override (should still fail for non-existent workflow, but syntax is valid)
-	err := RunWorkflowOnGitHub("nonexistent-workflow", false, "", "", "main", false, false, false, false)
+	err := RunWorkflowOnGitHub("nonexistent-workflow", false, "", "", "main", false, false, false, []string{}, false)
 	if err == nil {
 		t.Error("RunWorkflowOnGitHub should return error for non-existent workflow even with ref flag")
 	}
 
 	// Test with ref override and repo override
-	err = RunWorkflowOnGitHub("nonexistent-workflow", false, "", "owner/repo", "feature-branch", false, false, false, false)
+	err = RunWorkflowOnGitHub("nonexistent-workflow", false, "", "owner/repo", "feature-branch", false, false, false, []string{}, false)
 	if err == nil {
 		t.Error("RunWorkflowOnGitHub should return error for non-existent workflow with both ref and repo")
 	}
 }
+
+// TestInputFlagSignature tests that the inputs parameter is supported
+func TestInputFlagSignature(t *testing.T) {
+	// Test that RunWorkflowOnGitHub accepts inputs parameter
+	// This is a compile-time check that ensures the inputs parameter exists
+	_ = RunWorkflowOnGitHub("test", false, "", "", "", false, false, false, []string{"key=value"}, false)
+
+	// Test that RunWorkflowsOnGitHub accepts inputs parameter
+	_ = RunWorkflowsOnGitHub([]string{"test"}, 0, false, "", "", "", false, false, []string{"key=value"}, false)
+}
+
+// TestInputValidation tests that input validation works correctly
+func TestInputValidation(t *testing.T) {
+	tests := []struct {
+		name        string
+		inputs      []string
+		shouldError bool
+		errorMsg    string
+	}{
+		{
+			name:        "valid single input",
+			inputs:      []string{"name=value"},
+			shouldError: false,
+		},
+		{
+			name:        "valid multiple inputs",
+			inputs:      []string{"name=value", "env=prod"},
+			shouldError: false,
+		},
+		{
+			name:        "valid input with special characters",
+			inputs:      []string{"message=hello world", "path=/tmp/file.txt"},
+			shouldError: false,
+		},
+		{
+			name:        "invalid input without equals",
+			inputs:      []string{"namevalue"},
+			shouldError: true,
+			errorMsg:    "invalid input format",
+		},
+		{
+			name:        "invalid input - empty key",
+			inputs:      []string{"=value"},
+			shouldError: true,
+			errorMsg:    "key cannot be empty",
+		},
+		{
+			name:        "invalid input - empty value",
+			inputs:      []string{"name="},
+			shouldError: false, // Empty value is valid
+		},
+		{
+			name:        "mixed valid and invalid",
+			inputs:      []string{"name=value", "invalid"},
+			shouldError: true,
+			errorMsg:    "invalid input format",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			// Since we can't actually run workflows in tests, we'll just test the validation
+			// by checking if the function would error before attempting to run
+			err := RunWorkflowOnGitHub("nonexistent-workflow", false, "", "owner/repo", "", false, false, false, tt.inputs, false)
+
+			if tt.shouldError {
+				if err == nil {
+					t.Errorf("Expected error for inputs %v, got nil", tt.inputs)
+				} else if tt.errorMsg != "" && !strings.Contains(err.Error(), tt.errorMsg) {
+					t.Errorf("Expected error containing %q, got: %v", tt.errorMsg, err)
+				}
+			}
+			// Note: For non-error cases, we still expect an error because the workflow doesn't exist,
+			// but the error should not be about input validation
+			if !tt.shouldError && err != nil && strings.Contains(err.Error(), "invalid input format") {
+				t.Errorf("Got unexpected input validation error: %v", err)
+			}
+		})
+	}
+}

pkg/workflow/action_mode.go

@@ -51,18 +51,18 @@ func DetectActionMode() ActionMode {
 	// 2. Running on a release tag (refs/tags/*)
 	// 3. Running on a release event
 	if strings.HasPrefix(githubRef, "refs/heads/release") ||
-	   strings.HasPrefix(githubRef, "refs/tags/") ||
-	   githubEventName == "release" {
+		strings.HasPrefix(githubRef, "refs/tags/") ||
+		githubEventName == "release" {
 		return ActionModeRelease
 	}
 
 	// Dev mode conditions:
 	// 1. Running on a PR (refs/pull/*)
 	// 2. Running locally (no GITHUB_REF)
 	// 3. Running on any other branch (including main)
-	if strings.HasPrefix(githubRef, "refs/pull/") || 
-	   githubRef == "" ||
-	   strings.HasPrefix(githubRef, "refs/heads/") {
+	if strings.HasPrefix(githubRef, "refs/pull/") ||
+		githubRef == "" ||
+		strings.HasPrefix(githubRef, "refs/heads/") {
 		return ActionModeDev
 	}