fix: correctly cache shared objects

Author: damienbutt

internal/cache/artifacts.go

@@ -66,7 +66,7 @@ func RestoreArtifacts(cacheDir, destDir string, outputs []string) error {
 // CollectOutputs scans for compiled output files specific to the given source file.
 // It checks two locations:
 //  1. The source file directory for .ush header files
-//  2. The SPlsWork directory for other artifacts
+//  2. The SPlsWork directory for source-specific artifacts
 //
 // Returns paths relative to the source directory (e.g., "example.ush", "SPlsWork/example.dll")
 func CollectOutputs(sourceFile string) ([]string, error) {
@@ -118,6 +118,85 @@ func CollectOutputs(sourceFile string) ([]string, error) {
 	return outputs, nil
 }
 
+// CollectSharedFiles scans the SPlsWork directory for shared library files
+// that are not specific to any source file (DLLs, config files, etc.)
+// Returns paths relative to the source directory (e.g., "SPlsWork/Version.ini")
+func CollectSharedFiles(sourceDir string) ([]string, error) {
+	var sharedFiles []string
+
+	splsWorkDir := filepath.Join(sourceDir, "SPlsWork")
+
+	entries, err := os.ReadDir(splsWorkDir)
+	if err != nil {
+		if os.IsNotExist(err) {
+			return nil, nil // No SPlsWork directory
+		}
+		return nil, fmt.Errorf("failed to read SPlsWork directory: %w", err)
+	}
+
+	for _, entry := range entries {
+		if entry.IsDir() {
+			continue
+		}
+
+		name := entry.Name()
+
+		// Check if this is a shared file (not matching any source pattern)
+		// Shared files: *.dll, *.dat, *.xml, *.ini (except source-specific ones)
+		if isSharedFile(name) {
+			sharedFiles = append(sharedFiles, filepath.Join("SPlsWork", name))
+		}
+	}
+
+	return sharedFiles, nil
+}
+
+// isSharedFile checks if a file is a shared library/config file
+func isSharedFile(filename string) bool {
+	// Common shared file patterns in SPlsWork
+	ext := filepath.Ext(filename)
+	baseName := filename[:len(filename)-len(ext)]
+
+	// DLL files that don't match source patterns
+	if ext == ".dll" {
+		// Check if it's NOT a source-specific DLL (which would be in format "sourcename.dll")
+		// Shared DLLs have names like "ManagedUtilities.dll", "SplusLibrary.dll"
+		// If it contains certain keywords, it's shared
+		sharedKeywords := []string{"Managed", "Simpl", "Sharp", "Splus", "Smart", "Utilities", "Newtonsoft", "Json"}
+		for _, keyword := range sharedKeywords {
+			if containsIgnoreCase(baseName, keyword) {
+				return true
+			}
+		}
+	}
+
+	// Config/data files are always shared
+	if ext == ".ini" || ext == ".xml" || ext == ".dat" || ext == ".der" {
+		return true
+	}
+
+	return false
+}
+
+// containsIgnoreCase checks if a string contains a substring (case-insensitive)
+func containsIgnoreCase(s, substr string) bool {
+	s = filepath.Base(s) // normalize
+	return len(s) >= len(substr) &&
+		(s == substr ||
+			len(s) > len(substr) &&
+				(s[:len(substr)] == substr || s[len(s)-len(substr):] == substr ||
+					findSubstring(s, substr)))
+}
+
+func findSubstring(s, substr string) bool {
+	for i := 0; i <= len(s)-len(substr); i++ {
+		if s[i:i+len(substr)] == substr {
+			return true
+		}
+	}
+	return false
+}
+
 // isOutputFile checks if a filename belongs to the given source base name
 func isOutputFile(filename, baseName string) bool {
 	fileBase := filename[:len(filename)-len(filepath.Ext(filename))]

internal/cache/cache.go

@@ -167,6 +167,38 @@ func (c *Cache) Store(sourceFile string, cfg *config.Config, success bool) error
 		}
 	}
 
+	// Cache shared files (only once, if not already cached)
+	if success {
+		sourceDir := filepath.Dir(sourceFile)
+		if err := c.cacheSharedFiles(sourceDir); err != nil {
+			// Don't fail the whole operation if shared files caching fails
+			fmt.Fprintf(os.Stderr, "Warning: Failed to cache shared files: %v\n", err)
+		}
+	}
+
+	return nil
+}
+
+// cacheSharedFiles caches shared library files if not already cached
+func (c *Cache) cacheSharedFiles(sourceDir string) error {
+	// Check if shared files are already cached
+	sharedDir := filepath.Join(c.root, "shared")
+	if _, err := os.Stat(sharedDir); err == nil {
+		// Already cached, skip
+		return nil
+	}
+
+	// Collect shared files
+	sharedFiles, err := CollectSharedFiles(sourceDir)
+	if err != nil || len(sharedFiles) == 0 {
+		return err
+	}
+
+	// Copy shared files to cache
+	if err := CopyArtifacts(sourceDir, sharedDir, sharedFiles); err != nil {
+		return fmt.Errorf("failed to copy shared files: %w", err)
+	}
+
 	return nil
 }
 
@@ -176,8 +208,72 @@ func (c *Cache) Restore(entry *Entry, destDir string) error {
 		return fmt.Errorf("cannot restore failed build or build with no outputs")
 	}
 
+	// Restore source-specific artifacts
 	artifactDir := c.artifactDir(entry.Hash)
-	return RestoreArtifacts(artifactDir, destDir, entry.Outputs)
+	if err := RestoreArtifacts(artifactDir, destDir, entry.Outputs); err != nil {
+		return err
+	}
+
+	// Restore shared files if needed (if SPlsWork exists but shared files are missing)
+	if err := c.restoreSharedFiles(destDir); err != nil {
+		// Don't fail if shared files restoration fails - they might already exist
+		// or will be recreated on next full compile
+		fmt.Fprintf(os.Stderr, "Warning: Failed to restore shared files: %v\n", err)
+	}
+
+	return nil
+}
+
+// restoreSharedFiles restores shared library files if they're missing
+func (c *Cache) restoreSharedFiles(destDir string) error {
+	sharedDir := filepath.Join(c.root, "shared")
+
+	// Check if we have cached shared files
+	if _, err := os.Stat(sharedDir); os.IsNotExist(err) {
+		return nil // No shared files cached, skip
+	}
+
+	// Check if shared files already exist in destination
+	splsWorkDir := filepath.Join(destDir, "SPlsWork")
+	if needsSharedFiles, err := checkSharedFilesExist(splsWorkDir); err != nil || !needsSharedFiles {
+		return err // Either error or files already exist
+	}
+
+	// Collect what shared files we have cached
+	entries, err := os.ReadDir(filepath.Join(sharedDir, "SPlsWork"))
+	if err != nil {
+		return err
+	}
+
+	var sharedFiles []string
+	for _, entry := range entries {
+		if !entry.IsDir() {
+			sharedFiles = append(sharedFiles, filepath.Join("SPlsWork", entry.Name()))
+		}
+	}
+
+	// Restore shared files
+	return RestoreArtifacts(sharedDir, destDir, sharedFiles)
+}
+
+// checkSharedFilesExist checks if shared files are missing from SPlsWork
+// Returns true if shared files need to be restored
+func checkSharedFilesExist(splsWorkDir string) (bool, error) {
+	// If SPlsWork doesn't exist, we definitely need shared files
+	if _, err := os.Stat(splsWorkDir); os.IsNotExist(err) {
+		return true, nil
+	}
+
+	// Check for presence of at least one common shared file
+	commonSharedFiles := []string{"Version.ini", "ManagedUtilities.dll", "SplusLibrary.dll"}
+	for _, file := range commonSharedFiles {
+		if _, err := os.Stat(filepath.Join(splsWorkDir, file)); err == nil {
+			return false, nil // At least one shared file exists, assume others are there
+		}
+	}
+
+	// No shared files found, need to restore them
+	return true, nil
 }
 
 // Clear removes all cache entries and artifacts