chore(internal/librarian): move helper methods for clean to command.go (#1875)

Cleanup to move helper methods only used by cleanAndCopyLibrary()
together with it.

https://github.com/googleapis/librarian/blob/e6f38712f12a60bb48e36d56b609c277b3f04eeb/internal/librarian/command.go#L201

cleanAndCopyLibrary() is moved to command.go, the method clean() and its
helper methods are still left in generate.go. This creates an
unnecessary dependency from the command.go file to the generate.go file.
Move these methods and relevant tests.

Author: zhumin8

internal/librarian/command.go

@@ -19,11 +19,13 @@ import (
 	"errors"
 	"fmt"
 	"io"
+	"io/fs"
 	"log/slog"
 	"os"
 	"path"
 	"path/filepath"
 	"regexp"
+	"slices"
 	"strings"
 	"time"
 
@@ -389,3 +391,155 @@ func copyFile(dst, src string) (err error) {
 
 	return err
 }
+
+// clean removes files and directories from a root directory based on remove and preserve patterns.
+//
+// It first determines the paths to remove by applying the removePatterns and then excluding any paths
+// that match the preservePatterns. It then separates the remaining paths into files and directories and
+// removes them, ensuring that directories are removed last.
+//
+// This logic is ported from owlbot logic: https://github.com/googleapis/repo-automation-bots/blob/12dad68640960290910b660e4325630c9ace494b/packages/owl-bot/src/copy-code.ts#L1027
+func clean(rootDir string, removePatterns, preservePatterns []string) error {
+	slog.Info("cleaning directory", "path", rootDir)
+	finalPathsToRemove, err := deriveFinalPathsToRemove(rootDir, removePatterns, preservePatterns)
+	if err != nil {
+		return err
+	}
+
+	filesToRemove, dirsToRemove, err := separateFilesAndDirs(rootDir, finalPathsToRemove)
+	if err != nil {
+		return err
+	}
+
+	// Remove files first, then directories.
+	for _, file := range filesToRemove {
+		slog.Info("removing file", "path", file)
+		if err := os.Remove(filepath.Join(rootDir, file)); err != nil {
+			return err
+		}
+	}
+
+	sortDirsByDepth(dirsToRemove)
+
+	for _, dir := range dirsToRemove {
+		slog.Info("removing directory", "path", dir)
+		if err := os.Remove(filepath.Join(rootDir, dir)); err != nil {
+			// It's possible the directory is not empty due to preserved files.
+			slog.Warn("failed to remove directory, it may not be empty", "dir", dir, "err", err)
+		}
+	}
+
+	return nil
+}
+
+// sortDirsByDepth sorts directories by depth (descending) to remove children first.
+func sortDirsByDepth(dirs []string) {
+	slices.SortFunc(dirs, func(a, b string) int {
+		return strings.Count(b, string(filepath.Separator)) - strings.Count(a, string(filepath.Separator))
+	})
+}
+
+// allPaths walks the directory tree rooted at rootDir and returns a slice of all
+// file and directory paths, relative to rootDir.
+func allPaths(rootDir string) ([]string, error) {
+	var paths []string
+	err := filepath.WalkDir(rootDir, func(path string, d fs.DirEntry, err error) error {
+		if err != nil {
+			return err
+		}
+		relPath, err := filepath.Rel(rootDir, path)
+		if err != nil {
+			return err
+		}
+		paths = append(paths, relPath)
+		return nil
+	})
+	return paths, err
+}
+
+// filterPaths returns a new slice containing only the paths from the input slice
+// that match at least one of the provided regular expressions.
+func filterPaths(paths []string, regexps []*regexp.Regexp) []string {
+	var filtered []string
+	for _, path := range paths {
+		for _, re := range regexps {
+			if re.MatchString(path) {
+				filtered = append(filtered, path)
+				break
+			}
+		}
+	}
+	return filtered
+}
+
+// deriveFinalPathsToRemove determines the final set of paths to be removed. It
+// starts with all paths under rootDir, filters them based on removePatterns,
+// and then excludes any paths that match preservePatterns.
+func deriveFinalPathsToRemove(rootDir string, removePatterns, preservePatterns []string) ([]string, error) {
+	removeRegexps, err := compileRegexps(removePatterns)
+	if err != nil {
+		return nil, err
+	}
+	preserveRegexps, err := compileRegexps(preservePatterns)
+	if err != nil {
+		return nil, err
+	}
+
+	allPaths, err := allPaths(rootDir)
+	if err != nil {
+		return nil, err
+	}
+
+	pathsToRemove := filterPaths(allPaths, removeRegexps)
+	pathsToPreserve := filterPaths(pathsToRemove, preserveRegexps)
+
+	// delete pathsToPreserve from pathsToRemove.
+	pathsToDelete := make(map[string]bool)
+	for _, p := range pathsToPreserve {
+		pathsToDelete[p] = true
+	}
+	finalPathsToRemove := slices.DeleteFunc(pathsToRemove, func(path string) bool {
+		return pathsToDelete[path]
+	})
+	return finalPathsToRemove, nil
+}
+
+// separateFilesAndDirs takes a list of paths and categorizes them into files
+// and directories. It uses os.Lstat to avoid following symlinks, treating them
+// as files. Paths that do not exist are silently ignored.
+func separateFilesAndDirs(rootDir string, paths []string) ([]string, []string, error) {
+	var files, dirs []string
+	for _, path := range paths {
+		info, err := os.Lstat(filepath.Join(rootDir, path))
+		if err != nil {
+			if errors.Is(err, os.ErrNotExist) {
+				// The file or directory may have already been removed.
+				continue
+			}
+			// For any other error (permissions, I/O, etc.)
+			return nil, nil, fmt.Errorf("failed to stat path %q: %w", path, err)
+
+		}
+		if info.IsDir() {
+			dirs = append(dirs, path)
+		} else {
+			files = append(files, path)
+		}
+	}
+	return files, dirs, nil
+}
+
+// compileRegexps takes a slice of string patterns and compiles each one into a
+// regular expression. It returns a slice of compiled regexps or an error if any
+// pattern is invalid.
+func compileRegexps(patterns []string) ([]*regexp.Regexp, error) {
+	var regexps []*regexp.Regexp
+	for _, pattern := range patterns {
+		re, err := regexp.Compile(pattern)
+		if err != nil {
+			return nil, fmt.Errorf("invalid regex %q: %w", pattern, err)
+		}
+		regexps = append(regexps, re)
+	}
+	return regexps, nil
+}