feat(foreachdirectory): allow skip if not exist (#16)

Adds additional field to foreachdirectory

`skip_on_not_exist: true`

This intentionally skips the command on the `os.ErrNotExist` error.

Author: matt-FFFFFF

DEVELOPER.md

@@ -1,4 +1,3 @@
-
 # Developer Guide for Porch
 
 ## Extending Porch

examples/foreachdirectory-skip-test.yml

@@ -0,0 +1,46 @@
+name: "For Each Directory Example"
+description: "Example showing nested serial and parallel commands"
+commands:
+  - type: "foreachdirectory"
+    name: "For Each Directory OK"
+    working_directory: "./cmd"
+    mode: "parallel"
+    working_directory_strategy: "item_relative"
+    depth: 1
+    commands:
+      - type: "shell"
+        name: "echo pwd"
+        command_line: "echo $(pwd)"
+      - type: "shell"
+        name: skip test
+        command_line: "exit 2"
+        skip_exit_codes:
+          - 2
+      - type: "shell"
+        name: should not run
+        command_line: "echo should not run"
+
+  - type: "foreachdirectory"
+    name: "For Each Directory Does Not Exist"
+    working_directory: "./does-not-exist"
+    skip_on_not_exist: true
+    mode: "parallel"
+    working_directory_strategy: "item_relative"
+    depth: 1
+    commands:
+      - type: "shell"
+        name: "echo pwd"
+        command_line: "echo $(pwd)"
+
+  - type: "foreachdirectory"
+    name: "For Each Directory Does Not Exist Fail"
+    working_directory: "./does-not-exist"
+    runs_on_condition: always
+    skip_on_not_exist: false
+    mode: "parallel"
+    working_directory_strategy: "item_relative"
+    depth: 1
+    commands:
+      - type: "shell"
+        name: "echo pwd"
+        command_line: "echo $(pwd)"

internal/commands/foreachdirectory/commander.go

@@ -8,6 +8,7 @@ import (
 	"errors"
 	"fmt"
 	"io"
+	"os"
 
 	"github.com/goccy/go-yaml"
 	"github.com/matt-FFFFFF/porch/internal/commands"
@@ -66,11 +67,19 @@ func (c *Commander) Create(
 		return nil, fmt.Errorf("failed to parse working directory strategy: %q %w", def.WorkingDirectoryStrategy, err)
 	}
 
+	itemsSkipOnErrors := []error{}
+	if def.SkipOnNotExist {
+		itemsSkipOnErrors = append(itemsSkipOnErrors, os.ErrNotExist)
+	}
+
 	forEachCommand := &runbatch.ForEachCommand{
-		BaseCommand:   base,
-		ItemsProvider: foreachproviders.ListDirectoriesDepth(def.Depth, foreachproviders.IncludeHidden(def.IncludeHidden)),
-		Mode:          mode,
-		CwdStrategy:   strat,
+		BaseCommand: base,
+		ItemsProvider: foreachproviders.ListDirectoriesDepth(
+			def.Depth, foreachproviders.IncludeHidden(def.IncludeHidden),
+		),
+		Mode:              mode,
+		CwdStrategy:       strat,
+		ItemsSkipOnErrors: itemsSkipOnErrors,
 	}
 
 	// Determine which commands to use
@@ -149,6 +158,7 @@ func (c *Commander) GetExampleDefinition() interface{} {
 		Depth:                    2, //nolint:mnd
 		IncludeHidden:            false,
 		WorkingDirectoryStrategy: "item_relative",
+		SkipOnNotExist:           false,
 		Commands: []any{
 			map[string]any{
 				"type":         "shellcommand",

internal/commands/foreachdirectory/definition.go

@@ -32,6 +32,8 @@ type Definition struct {
 	Commands []any `yaml:"commands,omitempty" docdesc:"List of commands to execute in each directory"`
 	// CommandGroup is a reference to a named command group
 	CommandGroup string `yaml:"command_group,omitempty" docdesc:"Reference to a named command group"`
+	// SkipOnNotExist specifies whether to skip directories that do not exist.
+	SkipOnNotExist bool `yaml:"skip_on_not_exist" docdesc:"Whether to skip directories that do not exist"`
 }
 
 // Validate ensures that commands and command_group are not both specified,

internal/commands/foreachdirectory/foreachdirectory_integration_test.go

@@ -5,6 +5,7 @@ package foreachdirectory
 
 import (
 	"fmt"
+	"os"
 	"testing"
 
 	"github.com/matt-FFFFFF/porch/internal/commandregistry"
@@ -129,3 +130,41 @@ commands:
 		})
 	}
 }
+
+func TestForEachDirectorySkipNotExist(t *testing.T) {
+	yamlPayload := `type: "foreachdirectory"
+name: "For Each Directory"
+working_directory: "./does-not-exist"
+mode: serial
+depth: 1
+skip_on_not_exist: true
+include_hidden: false
+commands:
+  - type: "shell"
+    name: "echo item var"
+    command_line: "echo $ITEM"
+`
+	commander := &Commander{}
+	f := commandregistry.New(
+		serialcommand.Register,
+		parallelcommand.Register,
+		shellcommand.Register,
+		copycwdtotemp.Register,
+		Register,
+	)
+
+	runnable, err := commander.Create(t.Context(), f, []byte(yamlPayload))
+	require.NoError(t, err)
+	require.NotNil(t, runnable)
+	forEachCommand, ok := runnable.(*runbatch.ForEachCommand)
+	require.True(t, ok, "Expected ForEachCommand, got %T", runnable)
+	assert.Equal(t, forEachCommand.ItemsSkipOnErrors[0], os.ErrNotExist, "Expected skip error to be os.ErrNotExist")
+
+	results := runnable.Run(t.Context())
+	require.NotNil(t, results)
+	require.Len(t, results, 1, "Expected 1 result for foreach command")
+	assert.Equal(t, "For Each Directory", results[0].Label)
+	assert.Equal(t, runbatch.ResultStatusSkipped, results[0].Status,
+		"Expected result to be skipped due to non-existent working directory",
+	)
+}

internal/runbatch/foreachCommand.go

@@ -116,6 +116,9 @@ type ForEachCommand struct {
 	Mode ForEachMode
 	// CwdStrategy is for modifying the current working directory for each item
 	CwdStrategy ForEachCwdStrategy
+	// ItemsSkipOnErrors is a list of errors that will not cause the foreach items provider to fail.
+	// Must be a list of errors that can be used with errors.Is.
+	ItemsSkipOnErrors []error
 }
 
 // ParseForEachMode converts a string to a ForEachMode.
@@ -143,6 +146,15 @@ func (f *ForEachCommand) Run(ctx context.Context) Results {
 	// Get the items to iterate over
 	items, err := f.ItemsProvider(ctx, f.Cwd)
 	if err != nil {
+		for _, skipErr := range f.ItemsSkipOnErrors {
+			// If the error is in the skip list, treat it as a skipped result.
+			if errors.Is(err, skipErr) {
+				result.Status = ResultStatusSkipped
+				return Results{result}
+			}
+		}
+
+		// If the error is not in the skip list, return an error result.
 		return Results{{
 			Label:    f.Label,
 			ExitCode: -1,

internal/runbatch/progressiveForEachCommand.go

@@ -5,9 +5,11 @@ package runbatch
 
 import (
 	"context"
+	"errors"
 	"fmt"
 	"maps"
 	"path/filepath"
+	"time"
 
 	"github.com/matt-FFFFFF/porch/internal/progress"
 )
@@ -42,9 +44,42 @@ func (f *ForEachCommand) runWithProgressiveChildren(ctx context.Context, reporte
 	// Get the items to iterate over
 	items, err := f.ItemsProvider(ctx, f.Cwd)
 	if err != nil {
-		result.Error = err
-		result.ExitCode = -1
+		for _, skipErr := range f.ItemsSkipOnErrors {
+			// If the error is in the skip list, treat it as a skipped result.
+			if errors.Is(err, skipErr) {
+				result.Status = ResultStatusSkipped
+				result.Error = ErrSkipIntentional
+				reporter.Report(progress.Event{
+					CommandPath: []string{f.Label},
+					Type:        progress.EventSkipped,
+					Message:     result.Error.Error(),
+					Timestamp:   time.Now(),
+					Data: progress.EventData{
+						ExitCode:   result.ExitCode,
+						Error:      result.Error,
+						OutputLine: fmt.Sprintf("%v: %v", ErrSkipIntentional, err),
+					},
+				})
+
+				return Results{result}
+			}
+		}
+
+		// If the error is not in the skip list, return an error result.
+		result.Error = fmt.Errorf("%w: %v", ErrItemsProviderFailed, err)
 		result.Status = ResultStatusError
+		result.ExitCode = -1
+
+		reporter.Report(progress.Event{
+			CommandPath: []string{f.Label},
+			Type:        progress.EventFailed,
+			Message:     result.Error.Error(),
+			Timestamp:   time.Now(),
+			Data: progress.EventData{
+				ExitCode: result.ExitCode,
+				Error:    result.Error,
+			},
+		})
 
 		return Results{result}
 	}

internal/runbatch/progressiveSerialBatch.go

@@ -65,6 +65,9 @@ OuterLoop:
 					Type:        progress.EventSkipped,
 					Message:     "Command skipped intentionally",
 					Timestamp:   time.Now(),
+					Data: progress.EventData{
+						Error: ErrSkipIntentional,
+					},
 				})
 
 				results = append(results, &Result{
@@ -81,6 +84,9 @@ OuterLoop:
 					Type:        progress.EventSkipped,
 					Message:     "Command skipped due to previous error",
 					Timestamp:   time.Now(),
+					Data: progress.EventData{
+						Error: ErrSkipOnError,
+					},
 				})
 
 				results = append(results, &Result{

internal/tui/model.go

@@ -34,6 +34,8 @@ const (
 	StatusSuccess
 	// StatusFailed indicates the command failed.
 	StatusFailed
+	// StatusSkipped indicates the command was skipped.
+	StatusSkipped
 )
 
 const (
@@ -188,6 +190,7 @@ type Styles struct {
 	Pending    lipgloss.Style
 	Running    lipgloss.Style
 	Success    lipgloss.Style
+	Skipped    lipgloss.Style
 	Failed     lipgloss.Style
 	Output     lipgloss.Style
 	Error      lipgloss.Style
@@ -211,6 +214,9 @@ func NewStyles() *Styles {
 			Bold(true),
 		Success: lipgloss.NewStyle().
 			Foreground(lipgloss.Color("10")),
+		Skipped: lipgloss.NewStyle().
+			Foreground(lipgloss.Color("14")).
+			Italic(true),
 		Failed: lipgloss.NewStyle().
 			Foreground(lipgloss.Color("9")),
 		Output: lipgloss.NewStyle().
@@ -396,10 +402,23 @@ func (m *Model) processProgressEvent(event progress.Event) tea.Cmd {
 
 	case progress.EventSkipped:
 		node := m.getOrCreateNode(event.CommandPath, commandName)
-		node.UpdateStatus(StatusPending) // Keep as pending for skipped commands
+		node.UpdateStatus(StatusSkipped)
+
+		if event.Data.OutputLine != "" {
+			node.UpdateOutput(event.Data.OutputLine)
+		}
+
+		// Set error message from either stderr output or error message (for skip reasons)
+		if event.Data.OutputLine != "" {
+			// Prefer stderr output line if available
+			node.UpdateError(event.Data.OutputLine)
+		} else if event.Data.Error != nil {
+			// Fall back to error message if no stderr output
+			node.UpdateError(event.Data.Error.Error())
+		}
 	}
 
-	// Trigger immediate UI update on failure
+	// Trigger immediate UI update
 	return tea.Tick(teaTickInterval, func(_ time.Time) tea.Msg {
 		return tea.WindowSizeMsg{Width: m.width, Height: m.height}
 	})
@@ -586,7 +605,7 @@ func (m *Model) updateNodeErrorsFromResults(basePath []string, results runbatch.
 		pathKey := pathToString(commandPath)
 		if node, exists := m.nodeMap[pathKey]; exists {
 			// Update error message if this result has a specific error
-			if result.Error != nil && result.Status == runbatch.ResultStatusError {
+			if result.Error != nil && (result.Status == runbatch.ResultStatusError) {
 				// Only update if we have a more specific error than the generic one
 				if !errors.Is(result.Error, runbatch.ErrResultChildrenHasError) {
 					node.UpdateError(result.Error.Error())

internal/tui/update.go

@@ -372,6 +372,9 @@ func (m *Model) renderCommandNode(b *strings.Builder, node *CommandNode, prefix
 	case StatusFailed:
 		statusIcon = "❌"
 		styledName = m.styles.Failed.Render(name)
+	case StatusSkipped:
+		statusIcon = "⏩"
+		styledName = m.styles.Skipped.Render(name)
 	default:
 		statusIcon = "❓"
 		styledName = m.styles.Pending.Render(name)
@@ -391,7 +394,7 @@ func (m *Model) renderCommandNode(b *strings.Builder, node *CommandNode, prefix
 			elapsed = endTime.Sub(*startTime)
 		}
 
-		durStr := "(" + elapsed.Round(commandDurationRounding).String() + ")"
+		durStr := " (" + elapsed.Round(commandDurationRounding).String() + ")"
 		leftColumn += m.styles.Output.Render(durStr)
 	}
 
@@ -417,19 +420,19 @@ func (m *Model) renderCommandNode(b *strings.Builder, node *CommandNode, prefix
 	// Build the right column (output or error)
 	var rightColumn string
 
-	if errorMsg != "" && status == StatusFailed {
-		rightColumn = m.styles.Error.Render(fmt.Sprintf("Error: %s", errorMsg))
-	} else {
-		switch status {
-		case StatusFailed:
-			rightColumn = m.styles.Error.Render(
-				formatColumn(output, rightWidth),
-			)
-		case StatusRunning:
-			rightColumn = m.styles.Output.Render(
-				formatColumn(output, rightWidth),
-			)
-		}
+	switch status {
+	case StatusFailed:
+		rightColumn = m.styles.Error.Render(
+			formatColumn(errorMsg, rightWidth),
+		)
+	case StatusSkipped:
+		rightColumn = m.styles.Skipped.Render(
+			formatColumn(errorMsg, rightWidth),
+		)
+	case StatusRunning:
+		rightColumn = m.styles.Output.Render(
+			formatColumn(output, rightWidth),
+		)
 	}
 
 	// Add the row to the table