fix: correctly cache ush files

Author: damienbutt

cmd/build.go

@@ -61,9 +61,9 @@ func runBuild(cmd *cobra.Command, args []string) error {
 			if err != nil {
 				fmt.Fprintf(os.Stderr, "Warning: Cache lookup failed: %v\n", err)
 			} else if entry != nil && entry.Success {
-				// Cache hit!
-				outputDir := getOutputDir(absFile)
-				if err := buildCache.Restore(entry, outputDir); err != nil {
+				// Cache hit! Restore to source directory
+				sourceDir := filepath.Dir(absFile)
+				if err := buildCache.Restore(entry, sourceDir); err != nil {
 					fmt.Fprintf(os.Stderr, "Warning: Failed to restore from cache: %v\n", err)
 				} else {
 					if cfg.Verbose {
@@ -84,16 +84,14 @@ func runBuild(cmd *cobra.Command, args []string) error {
 			success = false
 			// Store failed build in cache too (so we don't retry immediately)
 			if !noCache && buildCache != nil {
-				outputDir := getOutputDir(absFile)
-				_ = buildCache.Store(absFile, cfg, outputDir, false)
+				_ = buildCache.Store(absFile, cfg, false)
 			}
 			return err
 		}
 
 		// Store successful build in cache
 		if !noCache && buildCache != nil {
-			outputDir := getOutputDir(absFile)
-			if err := buildCache.Store(absFile, cfg, outputDir, success); err != nil {
+			if err := buildCache.Store(absFile, cfg, success); err != nil {
 				fmt.Fprintf(os.Stderr, "Warning: Failed to cache build: %v\n", err)
 			}
 		}
@@ -119,9 +117,3 @@ func compileSingle(cfg *config.Config, sourceFile string) error {
 	// Execute the compiler command
 	return builder.ExecuteCommand(cfg.CompilerPath, cmdArgs)
 }
-
-// getOutputDir returns the SPlsWork directory for a source file
-func getOutputDir(sourceFile string) string {
-	dir := filepath.Dir(sourceFile)
-	return filepath.Join(dir, "SPlsWork")
-}

internal/cache/artifacts.go

@@ -1,3 +1,20 @@
+// Package cache provides artifact management for SIMPL+ build caching.
+//
+// The Crestron SIMPL+ compiler (SPlusCC.exe) generates output files in two locations:
+//  1. A shared "SPlsWork" directory adjacent to source files (for most artifacts)
+//  2. A .ush header file placed adjacent to the source file itself
+//
+// Multiple SIMPL+ source files in the same directory all output to the same SPlsWork
+// folder, making it critical to filter artifacts by source file name when caching.
+//
+// For a source file named "example.usp", the compiler generates:
+//   - Adjacent: example.ush (header file in same directory as source)
+//   - SPlsWork: example.dll, example.cs, example.inf
+//   - SPlsWork: S2_example.c, S2_example.h, S2_example.elf, etc.
+//
+// This package handles selective copying/restoration of only the artifacts
+// belonging to a specific source file, ignoring shared libraries and other
+// source files' artifacts.
 package cache
 
 import (
@@ -7,14 +24,15 @@ import (
 	"path/filepath"
 )
 
-// CopyArtifacts copies compiled outputs from source to cache
-func CopyArtifacts(sourceDir, destDir string, outputs []string) error {
+// CopyArtifacts copies compiled outputs from a base directory to cache
+// The outputs paths are relative to baseDir (e.g., "SPlsWork/example.dll", "example.ush")
+func CopyArtifacts(baseDir, destDir string, outputs []string) error {
 	if err := os.MkdirAll(destDir, 0o755); err != nil {
 		return fmt.Errorf("failed to create artifact directory: %w", err)
 	}
 
 	for _, output := range outputs {
-		src := filepath.Join(sourceDir, output)
+		src := filepath.Join(baseDir, output)
 		dst := filepath.Join(destDir, output)
 
 		if err := copyFile(src, dst); err != nil {
@@ -25,16 +43,18 @@ func CopyArtifacts(sourceDir, destDir string, outputs []string) error {
 	return nil
 }
 
-// RestoreArtifacts copies cached outputs back to the working directory
+// RestoreArtifacts copies cached outputs back to the base directory
+// The outputs paths are relative to destDir (e.g., "SPlsWork/example.dll", "example.ush")
 func RestoreArtifacts(cacheDir, destDir string, outputs []string) error {
-	if err := os.MkdirAll(destDir, 0o755); err != nil {
-		return fmt.Errorf("failed to create output directory: %w", err)
-	}
-
 	for _, output := range outputs {
 		src := filepath.Join(cacheDir, output)
 		dst := filepath.Join(destDir, output)
 
+		// Create parent directory if needed (e.g., for SPlsWork/...)
+		if err := os.MkdirAll(filepath.Dir(dst), 0o755); err != nil {
+			return fmt.Errorf("failed to create output directory: %w", err)
+		}
+
 		if err := copyFile(src, dst); err != nil {
 			return fmt.Errorf("failed to restore %s: %w", output, err)
 		}
@@ -43,33 +63,81 @@ func RestoreArtifacts(cacheDir, destDir string, outputs []string) error {
 	return nil
 }
 
-// CollectOutputs scans a directory and returns a list of compiled output files
-func CollectOutputs(dir string) ([]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
+//
+// Returns paths relative to the source directory (e.g., "example.ush", "SPlsWork/example.dll")
+func CollectOutputs(sourceFile string) ([]string, error) {
 	var outputs []string
 
-	entries, err := os.ReadDir(dir)
+	// Extract base name without extension (e.g., "example1" from "example1.usp")
+	baseName := filepath.Base(sourceFile)
+	baseName = baseName[:len(baseName)-len(filepath.Ext(baseName))]
+
+	sourceDir := filepath.Dir(sourceFile)
+	splsWorkDir := filepath.Join(sourceDir, "SPlsWork")
+
+	// Check for .ush file adjacent to source
+	ushFile := baseName + ".ush"
+	ushPath := filepath.Join(sourceDir, ushFile)
+	if _, err := os.Stat(ushPath); err == nil {
+		outputs = append(outputs, ushFile)
+	}
+
+	// Scan SPlsWork directory
+	entries, err := os.ReadDir(splsWorkDir)
 	if err != nil {
 		if os.IsNotExist(err) {
-			return nil, nil // No outputs yet
+			return outputs, nil // No SPlsWork directory yet
 		}
-		return nil, fmt.Errorf("failed to read output directory: %w", err)
+		return nil, fmt.Errorf("failed to read SPlsWork directory: %w", err)
 	}
 
 	for _, entry := range entries {
 		if entry.IsDir() {
 			continue
 		}
 
-		// Only collect actual output files, skip metadata
 		name := entry.Name()
-		if name != "metadata.json" {
-			outputs = append(outputs, name)
+
+		// Skip metadata files
+		if name == "metadata.json" {
+			continue
+		}
+
+		// Check if this file belongs to our source file
+		// Match patterns: {basename}.* or S2_{basename}.*
+		if isOutputFile(name, baseName) {
+			// Store with SPlsWork/ prefix for proper path handling
+			outputs = append(outputs, filepath.Join("SPlsWork", name))
 		}
 	}
 
 	return outputs, nil
 }
 
+// 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))]
+
+	// Direct match: example1.dll, example1.cs, etc.
+	if fileBase == baseName {
+		return true
+	}
+
+	// Target-prefixed match: S2_example1.c, S2_example1.h, etc.
+	if len(fileBase) > 3 && fileBase[0] == 'S' && fileBase[2] == '_' {
+		// Extract after "S2_" prefix
+		if fileBase[3:] == baseName {
+			return true
+		}
+	}
+
+	return false
+}
+
 // copyFile copies a file from src to dst
 func copyFile(src, dst string) error {
 	srcFile, err := os.Open(src)

internal/cache/cache.go

@@ -1,3 +1,16 @@
+// Package cache provides build caching functionality for SIMPL+ compilation.
+//
+// The cache system addresses the challenge of shared output directories (SPlsWork)
+// where the Crestron compiler places artifacts from multiple source files together.
+// Rather than caching entire directories, the cache:
+//
+//  1. Filters artifacts by source file name (e.g., example1.dll, S2_example1.c)
+//  2. Stores only relevant artifacts per source file in separate cache entries
+//  3. Uses SHA256 hashing of source content + configuration for cache keys
+//  4. Stores metadata in BoltDB and artifacts in the filesystem
+//
+// This allows incremental compilation where each source file can be cached
+// and restored independently, even when multiple files share the same output directory.
 package cache
 
 import (
@@ -106,14 +119,14 @@ func (c *Cache) Get(sourceFile string, cfg *config.Config) (*Entry, error) {
 }
 
 // Store saves a cache entry and copies artifacts
-func (c *Cache) Store(sourceFile string, cfg *config.Config, outputDir string, success bool) error {
+func (c *Cache) Store(sourceFile string, cfg *config.Config, success bool) error {
 	hash, err := HashSource(sourceFile, cfg)
 	if err != nil {
 		return fmt.Errorf("failed to hash source: %w", err)
 	}
 
-	// Collect outputs from build directory
-	outputs, err := CollectOutputs(outputDir)
+	// Collect outputs from both source dir and SPlsWork dir
+	outputs, err := CollectOutputs(sourceFile)
 	if err != nil {
 		return fmt.Errorf("failed to collect outputs: %w", err)
 	}
@@ -145,18 +158,19 @@ func (c *Cache) Store(sourceFile string, cfg *config.Config, outputDir string, s
 		return fmt.Errorf("failed to store cache entry: %w", err)
 	}
 
-	// Copy artifacts to cache
+	// Copy artifacts to cache (outputs are relative to source directory)
 	if success && len(outputs) > 0 {
 		artifactDir := c.artifactDir(hash)
-		if err := CopyArtifacts(outputDir, artifactDir, outputs); err != nil {
+		sourceDir := filepath.Dir(sourceFile)
+		if err := CopyArtifacts(sourceDir, artifactDir, outputs); err != nil {
 			return fmt.Errorf("failed to copy artifacts: %w", err)
 		}
 	}
 
 	return nil
 }
 
-// Restore copies cached artifacts back to the output directory
+// Restore copies cached artifacts back to the source directory
 func (c *Cache) Restore(entry *Entry, destDir string) error {
 	if !entry.Success || len(entry.Outputs) == 0 {
 		return fmt.Errorf("cannot restore failed build or build with no outputs")