Always include license and readme files in packages

internal/packager/archive.go

@@ -23,6 +23,7 @@ func (p *Packager) processArchive(spec config.PackageSpec) error {
 
 	// If a subpath is specified, use it directly; otherwise unwrap single top-level dirs
 	// (common in archives like "firebase-unity-sdk-12.0.0/...")
+	archiveRoot := extractDir
 	srcDir := extractDir
 	if spec.Path != "" {
 		srcDir = filepath.Join(extractDir, spec.Path)
@@ -31,6 +32,7 @@ func (p *Packager) processArchive(spec config.PackageSpec) error {
 		}
 	} else {
 		srcDir = unwrapSingleDir(extractDir)
+		archiveRoot = srcDir
 	}
 
 	destDir := filepath.Join(p.packagesDir, spec.Name)
@@ -43,6 +45,10 @@ func (p *Packager) processArchive(spec config.PackageSpec) error {
 			return fmt.Errorf("copying archive package %q: %w", spec.Name, err)
 		}
 
+		if err := CopyLegalFiles(srcDir, destDir); err != nil {
+			return fmt.Errorf("copying legal files for %q: %w", spec.Name, err)
+		}
+
 		if err := unity.WriteCscRspForAsmdefs(destDir, spec.SuppressWarnings); err != nil {
 			return fmt.Errorf("writing csc.rsp for %q: %w", spec.Name, err)
 		}
@@ -75,6 +81,10 @@ func (p *Packager) processArchive(spec config.PackageSpec) error {
 		if err := unity.WriteCscRsp(runtimeDir, spec.SuppressWarnings); err != nil {
 			return fmt.Errorf("writing csc.rsp for %q: %w", spec.Name, err)
 		}
+
+		if err := CopyLegalFilesSearchingUp(srcDir, archiveRoot, destDir); err != nil {
+			return fmt.Errorf("copying legal files for %q: %w", spec.Name, err)
+		}
 	}
 
 	if err := GenerateMetaFiles(destDir, spec.Name); err != nil {

internal/packager/git.go

@@ -32,6 +32,11 @@ func (p *Packager) processGitUnity(spec config.PackageSpec) error {
 		return fmt.Errorf("copying git-unity package %q: %w", spec.Name, err)
 	}
 
+	// Ensure license/readme files survive exclude filters
+	if err := CopyLegalFiles(srcDir, destDir); err != nil {
+		return fmt.Errorf("copying legal files for %q: %w", spec.Name, err)
+	}
+
 	if err := unity.WriteCscRspForAsmdefs(destDir, spec.SuppressWarnings); err != nil {
 		return fmt.Errorf("writing csc.rsp for %q: %w", spec.Name, err)
 	}
@@ -44,14 +49,15 @@ func (p *Packager) processGitUnity(spec config.PackageSpec) error {
 }
 
 func (p *Packager) processGitRaw(spec config.PackageSpec) error {
-	srcDir, err := p.cloneOrCache(spec.URL, spec.Ref)
+	cloneDir, err := p.cloneOrCache(spec.URL, spec.Ref)
 	if err != nil {
 		return err
 	}
 
 	// If a subpath is specified, use it
+	srcDir := cloneDir
 	if spec.Path != "" {
-		srcDir = filepath.Join(srcDir, spec.Path)
+		srcDir = filepath.Join(cloneDir, spec.Path)
 	}
 
 	destDir := filepath.Join(p.packagesDir, spec.Name)
@@ -88,6 +94,11 @@ func (p *Packager) processGitRaw(spec config.PackageSpec) error {
 		return fmt.Errorf("writing csc.rsp for %q: %w", spec.Name, err)
 	}
 
+	// Copy license/readme to package root, searching upward to repo root
+	if err := CopyLegalFilesSearchingUp(srcDir, cloneDir, destDir); err != nil {
+		return fmt.Errorf("copying legal files for %q: %w", spec.Name, err)
+	}
+
 	// Generate meta files for everything
 	if err := GenerateMetaFiles(destDir, spec.Name); err != nil {
 		return fmt.Errorf("generating meta files for %q: %w", spec.Name, err)

internal/packager/legalfiles.go

@@ -0,0 +1,172 @@
+package packager
+
+import (
+	"archive/zip"
+	"io"
+	"os"
+	"path/filepath"
+	"strings"
+)
+
+// legalFilePatterns are base names (case-insensitive) of files that should always
+// be included in the package root, regardless of exclude filters.
+var legalFilePatterns = []string{
+	"license",
+	"licence",
+	"license.md",
+	"licence.md",
+	"license.txt",
+	"licence.txt",
+	"license.rst",
+	"licence.rst",
+	"readme",
+	"readme.md",
+	"readme.txt",
+	"readme.rst",
+	"notice",
+	"notice.md",
+	"notice.txt",
+	"third-party-notices",
+	"third-party-notices.md",
+	"third-party-notices.txt",
+	"thirdpartynotices",
+	"thirdpartynotices.txt",
+}
+
+// isLegalFile returns true if the filename (base name only) matches a known
+// license/readme/notice pattern.
+func isLegalFile(name string) bool {
+	lower := strings.ToLower(name)
+	for _, pattern := range legalFilePatterns {
+		if lower == pattern {
+			return true
+		}
+	}
+	return false
+}
+
+// CopyLegalFiles copies license, readme, and notice files from srcDir (top-level only)
+// to destDir, regardless of any exclude patterns. Files already present in destDir are
+// not overwritten.
+func CopyLegalFiles(srcDir, destDir string) error {
+	entries, err := os.ReadDir(srcDir)
+	if err != nil {
+		return err
+	}
+
+	for _, entry := range entries {
+		if entry.IsDir() {
+			continue
+		}
+		if !isLegalFile(entry.Name()) {
+			continue
+		}
+
+		destPath := filepath.Join(destDir, entry.Name())
+		// Don't overwrite if already present (e.g., copied by CopyFiltered)
+		if _, err := os.Stat(destPath); err == nil {
+			continue
+		}
+
+		srcPath := filepath.Join(srcDir, entry.Name())
+		info, err := entry.Info()
+		if err != nil {
+			return err
+		}
+		if err := copyFile(srcPath, destPath, info.Mode()); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+// CopyLegalFilesSearchingUp copies legal files from srcDir to destDir, searching
+// upward through parent directories up to (and including) rootDir. This ensures
+// license files at a repository root are found even when a subpath is used.
+// Files found closer to srcDir take precedence over those found higher up.
+func CopyLegalFilesSearchingUp(srcDir, rootDir, destDir string) error {
+	srcAbs, err := filepath.Abs(srcDir)
+	if err != nil {
+		return err
+	}
+	rootAbs, err := filepath.Abs(rootDir)
+	if err != nil {
+		return err
+	}
+
+	// Collect directories from srcDir up to rootDir
+	var dirs []string
+	current := srcAbs
+	for {
+		dirs = append(dirs, current)
+		if current == rootAbs {
+			break
+		}
+		parent := filepath.Dir(current)
+		if parent == current {
+			break
+		}
+		current = parent
+	}
+
+	// Search from closest to furthest — CopyLegalFiles won't overwrite existing files
+	for _, dir := range dirs {
+		if err := CopyLegalFiles(dir, destDir); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+// ExtractLegalFilesFromZip extracts license, readme, and notice files from a zip
+// archive's root to destDir. Used for nupkg files where these are at the archive root.
+func ExtractLegalFilesFromZip(zipPath, destDir string) error {
+	r, err := zip.OpenReader(zipPath)
+	if err != nil {
+		return err
+	}
+	defer r.Close()
+
+	for _, f := range r.File {
+		if f.FileInfo().IsDir() {
+			continue
+		}
+
+		// Only look at root-level files in the archive
+		if strings.Contains(f.Name, "/") {
+			continue
+		}
+
+		if !isLegalFile(f.Name) {
+			continue
+		}
+
+		destPath := filepath.Join(destDir, f.Name)
+		// Don't overwrite
+		if _, err := os.Stat(destPath); err == nil {
+			continue
+		}
+
+		rc, err := f.Open()
+		if err != nil {
+			return err
+		}
+
+		outFile, err := os.Create(destPath)
+		if err != nil {
+			rc.Close()
+			return err
+		}
+
+		_, copyErr := io.Copy(outFile, rc)
+		rc.Close()
+		outFile.Close()
+		if copyErr != nil {
+			return copyErr
+		}
+	}
+
+	return nil
+}