Align API types between Porch and kpt (#4341)

* Sync kpt type definitions across kpt and porch

Signed-off-by: liamfallon <liam.fallon@est.tech>

* Add copy-merge strategy to kpt

Signed-off-by: liamfallon <liam.fallon@est.tech>

* Fix copyrights

Signed-off-by: liamfallon <liam.fallon@est.tech>

* Fix lint errors

Signed-off-by: liamfallon <liam.fallon@est.tech>

* Use template YEAR in boilerplate

Signed-off-by: liamfallon <liam.fallon@est.tech>

---------

Signed-off-by: liamfallon <liam.fallon@est.tech>

Author: liamfallon

internal/util/pkgutil/pkgutil.go

@@ -1,4 +1,4 @@
-// Copyright 2020 The kpt Authors
+// Copyright 2020,2026 The kpt Authors
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -12,6 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+// Package pkgutil contains utility functions for packages
 package pkgutil
 
 import (
@@ -169,6 +170,62 @@ func CopyPackage(src, dst string, copyRootKptfile bool, matcher pkg.SubpackageMa
 	return nil
 }
 
+// RemoveStaleItems removes files and directories from the dst package that were present in the org package,
+// but are not present in the src package. It does not remove the root Kptfile of the dst package.
+func RemoveStaleItems(org, src, dst string, _ bool, _ pkg.SubpackageMatcher) error {
+	var dirsToDelete []string
+	walkErr := filepath.Walk(dst, func(path string, info os.FileInfo, err error) error {
+		if err != nil {
+			return err
+		}
+		// The root directory should never be deleted.
+		if path == dst {
+			return nil
+		}
+
+		relPath, err := filepath.Rel(dst, path)
+		if err != nil {
+			return err
+		}
+
+		// Skip the root Kptfile
+		if relPath == kptfilev1.KptFileName {
+			return nil
+		}
+
+		srcPath := filepath.Join(src, relPath)
+		orgPath := filepath.Join(org, relPath)
+
+		_, srcErr := os.Stat(srcPath)
+		_, orgErr := os.Stat(orgPath)
+
+		// Only remove if:
+		// - not present in src (srcErr is os.IsNotExist)
+		// - present in org (orgErr is nil)
+		if os.IsNotExist(srcErr) && orgErr == nil {
+			if info.IsDir() {
+				dirsToDelete = append(dirsToDelete, path)
+			} else {
+				if err := os.Remove(path); err != nil {
+					return err
+				}
+			}
+		}
+		return nil
+	})
+	if walkErr != nil {
+		return walkErr
+	}
+	sort.Slice(dirsToDelete, SubPkgFirstSorter(dirsToDelete))
+	for _, dir := range dirsToDelete {
+		if err := os.Remove(dir); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
 func RemovePackageContent(path string, removeRootKptfile bool) error {
 	// Walk the package (while ignoring subpackages) and delete all files.
 	// We capture the paths to any subdirectories in the package so we
@@ -209,7 +266,6 @@ func RemovePackageContent(path string, removeRootKptfile bool) error {
 		if err != nil {
 			return err
 		}
-		defer f.Close()
 		// List up to one file or folder in the directory.
 		_, err = f.Readdirnames(1)
 		if err != nil && err != io.EOF {

internal/util/pkgutil/pkgutil_test.go

@@ -1,4 +1,4 @@
-// Copyright 2021 The kpt Authors
+// Copyright 2021,2026 The kpt Authors
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -549,3 +549,42 @@ func TestFindLocalRecursiveSubpackagesForPaths(t *testing.T) {
 		})
 	}
 }
+
+func TestRemoveStaleItems_RemovesFile(t *testing.T) {
+	org := t.TempDir()
+	src := t.TempDir()
+	dst := t.TempDir()
+
+	// Create a file in org and dst, but not in src
+	fileName := "file.txt"
+	assert.NoError(t, os.WriteFile(filepath.Join(org, fileName), []byte("content"), 0644))
+	assert.NoError(t, os.WriteFile(filepath.Join(dst, fileName), []byte("content"), 0644))
+
+	// Should remove file.txt from dst
+	err := pkgutil.RemoveStaleItems(org, src, dst, true, pkg.All)
+	assert.NoError(t, err)
+	_, err = os.Stat(filepath.Join(dst, fileName))
+	assert.True(t, os.IsNotExist(err))
+}
+
+func TestRemoveStaleItems_ErrorOnRemove(t *testing.T) {
+	org := t.TempDir()
+	src := t.TempDir()
+	dst := t.TempDir()
+
+	fileName := "file.txt"
+	filePathDst := filepath.Join(dst, fileName)
+	filePathOrg := filepath.Join(org, fileName)
+
+	assert.NoError(t, os.WriteFile(filePathOrg, []byte("content"), 0644))
+	assert.NoError(t, os.WriteFile(filePathDst, []byte("content"), 0644))
+
+	// Replace file in dst with a non-empty directory to force os.Remove error
+	assert.NoError(t, os.Remove(filePathDst))
+	assert.NoError(t, os.Mkdir(filePathDst, 0755))
+	assert.NoError(t, os.WriteFile(filepath.Join(filePathDst, "dummy"), []byte("x"), 0644))
+
+	err := pkgutil.RemoveStaleItems(org, src, dst, true, pkg.All)
+	assert.Error(t, err)
+	assert.Contains(t, err.Error(), "directory not empty")
+}

internal/util/update/copy-merge.go

@@ -0,0 +1,51 @@
+// Copyright 2026 The kpt Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package update
+
+import (
+	"github.com/kptdev/kpt/internal/errors"
+	"github.com/kptdev/kpt/internal/pkg"
+	"github.com/kptdev/kpt/internal/util/pkgutil"
+	"github.com/kptdev/kpt/pkg/kptfile/kptfileutil"
+	"github.com/kptdev/kpt/pkg/lib/types"
+)
+
+// CopyMergeUpdater is responsible for synchronizing the destination package
+// with the source package by updating the Kptfile and copying and replacing package contents.
+type CopyMergeUpdater struct{}
+
+// Update synchronizes the destination/local package with the source/update package by updating the Kptfile
+// and copying package contents. It deletes resources from the destination package if they were present
+// in the original package, but not present anymore in the source package.
+// It takes an Options struct as input, which specifies the paths
+// and other parameters for the update operation. Returns an error if the update fails.
+func (u CopyMergeUpdater) Update(options Options) error {
+	const op errors.Op = "update.Update"
+
+	dst := options.LocalPath
+	src := options.UpdatedPath
+	org := options.OriginPath
+
+	if err := kptfileutil.UpdateKptfile(dst, src, options.OriginPath, true); err != nil {
+		return errors.E(op, types.UniquePath(dst), err)
+	}
+	if err := pkgutil.CopyPackage(src, dst, options.IsRoot, pkg.All); err != nil {
+		return errors.E(op, types.UniquePath(dst), err)
+	}
+	if err := pkgutil.RemoveStaleItems(org, src, dst, options.IsRoot, pkg.All); err != nil {
+		return errors.E(op, types.UniquePath(dst), err)
+	}
+	return nil
+}