feat(diff): add list-modified-envs flag to tk diff command (#1623)

* Add functionality

* Use list modified envs

* Use the new flag

* Lint

* Remove placeholder comments

* Add tests and sort outputs

* Changes according to reviewer's comments

Author: dsotirakis

cmd/tk/workflow.go

@@ -232,6 +232,7 @@ func diffCmd(ctx context.Context) *cli.Command {
 	cmd.Flags().BoolVarP(&opts.Summarize, "summarize", "s", false, "print summary of the differences, not the actual contents")
 	cmd.Flags().BoolVarP(&opts.WithPrune, "with-prune", "p", false, "include objects deleted from the configuration in the differences")
 	cmd.Flags().BoolVarP(&opts.ExitZero, "exit-zero", "z", false, "Exit with 0 even when differences are found.")
+	cmd.Flags().BoolVar(&opts.ListModifiedEnvs, "list-modified-envs", false, "List environments with changes")
 
 	vars := workflowFlags(cmd.Flags())
 	getJsonnetOpts := jsonnetFlags(cmd.Flags())
@@ -257,13 +258,27 @@ func diffCmd(ctx context.Context) *cli.Command {
 		}
 
 		if changes == nil {
-			fmt.Fprintln(os.Stderr, "No differences.")
+			if opts.ListModifiedEnvs {
+				fmt.Fprintln(os.Stderr, "No environments with changes.")
+			} else {
+				fmt.Fprintln(os.Stderr, "No differences.")
+			}
 			os.Exit(ExitStatusClean)
 		}
 
-		r := term.Colordiff(*changes)
-		if err := fPageln(r); err != nil {
-			return err
+		// For special modes, print output directly without color processing
+		if opts.ListModifiedEnvs {
+			fmt.Print(*changes)
+		} else {
+			r := term.Colordiff(*changes)
+			if err := fPageln(r); err != nil {
+				return err
+			}
+		}
+
+		// For --list-modified-envs, always exit with success code
+		if opts.ListModifiedEnvs {
+			os.Exit(ExitStatusClean)
 		}
 
 		exitStatusDiff := ExitStatusDiff

pkg/kubernetes/client/client.go

@@ -19,6 +19,9 @@ type Client interface {
 	// result in `diff(1)` format
 	DiffServerSide(data manifest.List) (*string, error)
 
+	// DiffExitCode performs kubectl diff and returns true if there are changes, false if no changes
+	DiffExitCode(data manifest.List) (bool, error)
+
 	// Delete the specified object(s) from the cluster
 	Delete(namespace, apiVersion, kind, name string, opts DeleteOpts) error
 

pkg/kubernetes/client/diff.go

@@ -37,6 +37,38 @@ func (k Kubectl) DiffClientSide(data manifest.List) (*string, error) {
 	return k.diff(data, false)
 }
 
+// DiffExitCode performs a kubectl diff and returns true if there are changes (exit code 1), false if no changes (exit code 0)
+func (k Kubectl) DiffExitCode(data manifest.List) (bool, error) {
+	fw := FilterWriter{filters: []*regexp.Regexp{regexp.MustCompile(`exit status \d`)}}
+
+	args := []string{"-f", "-"}
+	cmd := k.ctl("diff", args...)
+
+	cmd.Stdout = &bytes.Buffer{}
+	cmd.Stderr = &fw
+	cmd.Stdin = strings.NewReader(data.String())
+
+	err := cmd.Run()
+	exitErr, ok := err.(exitError)
+	if !ok && err != nil {
+		return false, err
+	}
+
+	if !ok {
+		// exit code 0 - no changes
+		return false, nil
+	}
+
+	switch exitErr.ExitCode() {
+	case 0:
+		return false, nil
+	case 1:
+		return true, nil
+	default:
+		return false, err
+	}
+}
+
 func (k Kubectl) diff(data manifest.List, serverSide bool) (*string, error) {
 	fw := FilterWriter{filters: []*regexp.Regexp{regexp.MustCompile(`exit status \d`)}}
 

pkg/kubernetes/client/diff_test.go

@@ -68,3 +68,47 @@ func (e *dummyExitError) Error() string {
 func (e *dummyExitError) ExitCode() int {
 	return e.exitCode
 }
+
+func TestDiffExitCodeMapping(t *testing.T) {
+	cases := []struct {
+		name      string
+		err       error
+		expect    bool
+		expectErr bool
+	}{
+		{name: "nilErrorNoChanges", err: nil, expect: false, expectErr: false},
+		{name: "exit0NoChanges", err: &dummyExitError{exitCode: 0}, expect: false, expectErr: false},
+		{name: "exit1HasChanges", err: &dummyExitError{exitCode: 1}, expect: true, expectErr: false},
+	}
+
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			var got bool
+			var err error
+
+			if exitErr, ok := tc.err.(exitError); !ok {
+				if tc.err != nil {
+					err = tc.err
+				} else {
+					got = false
+				}
+			} else {
+				switch exitErr.ExitCode() {
+				case 0:
+					got = false
+				case 1:
+					got = true
+				default:
+					err = tc.err
+				}
+			}
+
+			if tc.expectErr {
+				require.Error(t, err)
+				return
+			}
+			require.NoError(t, err)
+			require.Equal(t, tc.expect, got)
+		})
+	}
+}

pkg/kubernetes/diff.go

@@ -100,6 +100,12 @@ Please upgrade kubectl to at least version 1.18.1`)
 	return d, nil
 }
 
+// HasChanges performs a lightweight check to determine if there are any changes
+// between the desired state and cluster using kubectl diff --exit-code (no output)
+func (k *Kubernetes) HasChanges(state manifest.List) (bool, error) {
+	return k.ctl.DiffExitCode(state)
+}
+
 type separateOpts struct {
 	namespaces map[string]bool
 	resources  client.Resources

pkg/tanka/workflow.go

@@ -4,13 +4,18 @@ import (
 	"context"
 	"fmt"
 	"os"
+	"sort"
+	"strings"
+	"sync"
 
 	"github.com/fatih/color"
 	"github.com/rs/zerolog/log"
+	"golang.org/x/sync/errgroup"
 
 	"github.com/grafana/tanka/pkg/kubernetes"
 	"github.com/grafana/tanka/pkg/kubernetes/client"
 	"github.com/grafana/tanka/pkg/kubernetes/manifest"
+	"github.com/grafana/tanka/pkg/spec/v1alpha1"
 	"github.com/grafana/tanka/pkg/term"
 )
 
@@ -170,6 +175,8 @@ type DiffOpts struct {
 	WithPrune bool
 	// Exit with 0 even when differences are found
 	ExitZero bool
+	// List all available environments and exit
+	ListModifiedEnvs bool
 }
 
 // Diff parses the environment at the given directory (a `baseDir`) and returns
@@ -178,6 +185,10 @@ type DiffOpts struct {
 // The cluster information is retrieved from the environments `spec.json`.
 // NOTE: This function requires on `diff(1)` and `kubectl(1)`
 func Diff(ctx context.Context, baseDir string, opts DiffOpts) (*string, error) {
+	if opts.ListModifiedEnvs {
+		return ListChangedEnvironments(ctx, baseDir, opts)
+	}
+
 	l, err := Load(ctx, baseDir, opts.Opts)
 	if err != nil {
 		return nil, err
@@ -195,6 +206,91 @@ func Diff(ctx context.Context, baseDir string, opts DiffOpts) (*string, error) {
 	})
 }
 
+// ListChangedEnvironments performs a high-level check using kubectl dry-run to identify environments with changes
+func ListChangedEnvironments(ctx context.Context, baseDir string, opts DiffOpts) (*string, error) {
+	// Find all environments in the directory
+	envMetas, err := FindEnvs(ctx, baseDir, FindOpts{
+		JsonnetOpts:           opts.JsonnetOpts,
+		JsonnetImplementation: opts.JsonnetImplementation,
+		Parallelism:           8, // magic number for now
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	changed := CheckEnvironmentsForChanges(ctx, envMetas, opts)
+	if len(changed) == 0 {
+		return nil, nil
+	}
+
+	sort.Strings(changed)
+
+	result := strings.Join(changed, "\n")
+	return &result, nil
+}
+
+// CheckEnvironmentsForChanges performs a high-level parallel check using kubectl diff --exit-code
+func CheckEnvironmentsForChanges(ctx context.Context, envs []*v1alpha1.Environment, opts DiffOpts) []string {
+	var mu sync.Mutex
+	var changed []string
+
+	g, ctx := errgroup.WithContext(ctx)
+	g.SetLimit(4)
+
+	for _, env := range envs {
+		envLoop := env
+		g.Go(func() error {
+			if hasChanges, envName := checkSingleEnvironmentChanges(ctx, envLoop, opts); hasChanges {
+				mu.Lock()
+				changed = append(changed, envName)
+				mu.Unlock()
+			}
+			return nil
+		})
+	}
+
+	if err := g.Wait(); err != nil {
+		log.Warn().Err(err).Msg("Failed to check environments for changes")
+	}
+	return changed
+}
+
+// checkSingleEnvironmentChanges uses kubectl diff to quickly check for changes
+func checkSingleEnvironmentChanges(ctx context.Context, env *v1alpha1.Environment, opts DiffOpts) (bool, string) {
+	envName := env.Spec.Namespace
+	if env.Metadata.Name != "" {
+		envName = env.Metadata.Name
+	}
+
+	// Load only this single environment to get its resources
+	tempOpts := opts.Opts
+	tempOpts.Name = env.Metadata.Name
+
+	// Use the environment's path for loading
+	envPath := env.Metadata.Namespace
+	l, err := Load(ctx, envPath, tempOpts)
+	if err != nil {
+		log.Warn().Err(err).Str("env", envName).Msg("Failed to load environment, assuming no changes")
+		return false, envName
+	}
+
+	kube, err := l.Connect()
+	if err != nil {
+		log.Warn().Err(err).Str("env", envName).Msg("Failed to connect, assuming no changes")
+		return false, envName
+	}
+	defer kube.Close()
+
+	// Use a lightweight check via `kubectl diff --exit-code`
+	hasChanges, err := kube.HasChanges(l.Resources)
+	if err != nil {
+		log.Warn().Err(err).Str("env", envName).Msg("Failed to check changes, assuming changes exist")
+		return true, envName
+	}
+
+	return hasChanges, envName
+}
+
 // DeleteOpts specify additional properties for the Delete operation
 type DeleteOpts struct {
 	ApplyBaseOpts