Show meaningful paths in kpt pkg diff output

Signed-off-by: Aravindhan Ayyanathan <aravindhan.a@est.tech>

Author: aravindtga

pkg/lib/pkg/diff/diff.go

@@ -16,6 +16,7 @@
 package diff
 
 import (
+	"bytes"
 	"context"
 	"fmt"
 	"io"
@@ -245,6 +246,7 @@ func (c *Command) DefaultValues() {
 			DiffToolOpts: c.DiffToolOpts,
 			Debug:        c.Debug,
 			Output:       c.Output,
+			LocalPath:    c.Path,
 		}
 	}
 }
@@ -271,15 +273,19 @@ type defaultPkgDiffer struct {
 	// Output is an io.Writer where command will write the output of the
 	// command.
 	Output io.Writer
+
+	// LocalPath is the original local package path on the user's filesystem.
+	// Used to replace temp staging paths in diff output with the real path.
+	LocalPath string
 }
 
 func (d *defaultPkgDiffer) Diff(pkgs ...string) error {
 	// add merge comments before comparing so that there are no unwanted diffs
 	if err := addmergecomment.Process(pkgs...); err != nil {
 		return err
 	}
-	for _, pkg := range pkgs {
-		if err := d.prepareForDiff(pkg); err != nil {
+	for _, pkgPath := range pkgs {
+		if err := d.prepareForDiff(pkgPath); err != nil {
 			return err
 		}
 	}
@@ -291,8 +297,11 @@ func (d *defaultPkgDiffer) Diff(pkgs ...string) error {
 		args = pkgs
 	}
 	cmd := exec.Command(d.DiffTool, args...)
-	cmd.Stdout = d.Output
-	cmd.Stderr = d.Output
+
+	// Capture output so we can replace temp paths with meaningful ones
+	var buf bytes.Buffer
+	cmd.Stdout = &buf
+	cmd.Stderr = &buf
 
 	if d.Debug {
 		fmt.Fprintf(d.Output, "%s\n", strings.Join(cmd.Args, " "))
@@ -310,6 +319,21 @@ func (d *defaultPkgDiffer) Diff(pkgs ...string) error {
 			fmt.Printf(exitCodeDiffWarning, d.DiffTool, d.DiffType)
 		}
 	}
+
+	// Replace temp staging paths with meaningful ones in the output.
+	// The local staging path is replaced with the real filesystem path.
+	// Remote staging paths are replaced with their semantic directory name.
+	output := buf.String()
+	for _, stagingPath := range pkgs {
+		name := filepath.Base(stagingPath)
+		if d.LocalPath != "" && strings.HasPrefix(name, LocalPackageSource+"-") {
+			output = strings.ReplaceAll(output, stagingPath, d.LocalPath)
+		} else {
+			output = strings.ReplaceAll(output, stagingPath, name)
+		}
+	}
+	fmt.Fprint(d.Output, output)
+
 	return err
 }
 

pkg/lib/pkg/diff/diff_test.go

@@ -503,3 +503,85 @@ func TestStagingDirectoryNames(t *testing.T) {
 		})
 	}
 }
+
+// TestCommand_DiffOutputPaths verifies that diff output shows meaningful paths
+// instead of raw temp directory paths (https://github.com/kptdev/kpt/issues/591).
+func TestCommand_DiffOutputPaths(t *testing.T) {
+	g := &testutil.TestSetupManager{
+		T: t,
+		ReposChanges: map[string][]testutil.Content{
+			testutil.Upstream: {
+				{
+					Pkg: pkgbuilder.NewRootPkg().
+						WithResource(pkgbuilder.DeploymentResource),
+					Branch: "main",
+					Tag:    "v1",
+				},
+				{
+					Pkg: pkgbuilder.NewRootPkg().
+						WithResource(pkgbuilder.DeploymentResource,
+							pkgbuilder.SetFieldPath("5", "spec", "replicas")),
+				},
+			},
+		},
+		GetRef: "v1",
+		LocalChanges: []testutil.Content{
+			{
+				Pkg: pkgbuilder.NewRootPkg().
+					WithKptfile(
+						pkgbuilder.NewKptfile().
+							WithUpstreamRef(testutil.Upstream, "/", "v1", "resource-merge").
+							WithUpstreamLockRef(testutil.Upstream, "/", "v1", 0),
+					).
+					WithResource(pkgbuilder.DeploymentResource,
+						pkgbuilder.SetFieldPath("10", "spec", "replicas")),
+			},
+		},
+	}
+	defer g.Clean()
+	if !g.Init() {
+		return
+	}
+
+	localPath := g.LocalWorkspace.FullPackagePath()
+
+	tests := []struct {
+		name       string
+		diffType   diff.Type
+		diffTool   string
+		wantLocal  bool
+		wantLabels []string
+	}{
+		{"local", diff.TypeLocal, "diff", true, []string{"remote-v1/"}},
+		{"remote", diff.TypeRemote, "diff", false, []string{"remote-v1/", "target-main/"}},
+		{"combined", diff.TypeCombined, "diff", true, []string{"target-main/"}},
+		{"3way", diff.Type3Way, "echo", true, []string{"remote-v1", "target-main"}},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			var out bytes.Buffer
+			diffToolOpts := "-r -i -w"
+			if tt.diffTool == "echo" {
+				diffToolOpts = ""
+			}
+			err := (&diff.Command{
+				Path:         localPath,
+				Ref:          "main",
+				DiffType:     tt.diffType,
+				DiffTool:     tt.diffTool,
+				DiffToolOpts: diffToolOpts,
+				Output:       &out,
+			}).Run(fake.CtxWithDefaultPrinter())
+			assert.NoError(t, err)
+
+			output := out.String()
+			if tt.wantLocal {
+				assert.Contains(t, output, localPath)
+			}
+			for _, label := range tt.wantLabels {
+				assert.Contains(t, output, label)
+			}
+		})
+	}
+}