feat: implement caching

Author: damienbutt

.gitignore

@@ -37,6 +37,9 @@ bin/
 build/
 dist/
 
+# Cache
+.spc-cache/
+
 # Local History
 .history/
 

cmd/build.go

@@ -2,7 +2,10 @@ package cmd
 
 import (
 	"fmt"
+	"os"
+	"path/filepath"
 
+	"github.com/Norgate-AV/spc/internal/cache"
 	"github.com/Norgate-AV/spc/internal/compiler"
 	"github.com/Norgate-AV/spc/internal/config"
 	"github.com/Norgate-AV/spc/internal/utils"
@@ -29,19 +32,96 @@ func runBuild(cmd *cobra.Command, args []string) error {
 		return err
 	}
 
-	// Build compiler command arguments
+	// Check if cache is disabled
+	noCache, _ := cmd.Flags().GetBool("no-cache")
+
+	// Initialize cache (unless disabled)
+	var buildCache *cache.Cache
+	if !noCache {
+		buildCache, err = cache.New("")
+		if err != nil {
+			fmt.Fprintf(os.Stderr, "Warning: Failed to initialize cache: %v\n", err)
+			// Continue without cache
+			noCache = true
+		} else {
+			defer buildCache.Close()
+		}
+	}
+
+	// Process each source file
+	for _, file := range args {
+		absFile, err := filepath.Abs(file)
+		if err != nil {
+			return fmt.Errorf("failed to resolve path for %s: %w", file, err)
+		}
+
+		// Check cache (if enabled)
+		if !noCache && buildCache != nil {
+			entry, err := buildCache.Get(absFile, cfg)
+			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 {
+					fmt.Fprintf(os.Stderr, "Warning: Failed to restore from cache: %v\n", err)
+				} else {
+					if cfg.Verbose {
+						fmt.Printf("✓ Using cached build for %s\n", filepath.Base(file))
+					}
+					continue // Skip compilation
+				}
+			}
+		}
+
+		// Cache miss or disabled - compile
+		if cfg.Verbose {
+			fmt.Printf("Compiling %s...\n", filepath.Base(file))
+		}
+
+		success := true
+		if err := compileSingle(cfg, absFile); err != nil {
+			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)
+			}
+			return err
+		}
+
+		// Store successful build in cache
+		if !noCache && buildCache != nil {
+			outputDir := getOutputDir(absFile)
+			if err := buildCache.Store(absFile, cfg, outputDir, success); err != nil {
+				fmt.Fprintf(os.Stderr, "Warning: Failed to cache build: %v\n", err)
+			}
+		}
+	}
+
+	return nil
+}
+
+// compileSingle compiles a single source file
+func compileSingle(cfg *config.Config, sourceFile string) error {
 	builder := compiler.NewCommandBuilder()
-	cmdArgs, err := builder.BuildCommandArgs(cfg, args)
+	cmdArgs, err := builder.BuildCommandArgs(cfg, []string{sourceFile})
 	if err != nil {
 		return err
 	}
 
 	// Print build info if verbose mode is enabled
 	if cfg.Verbose {
 		series := utils.ParseTarget(cfg.Target)
-		builder.PrintBuildInfo(cfg, series, args, cmdArgs)
+		builder.PrintBuildInfo(cfg, series, []string{sourceFile}, cmdArgs)
 	}
 
 	// 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")
+}

cmd/root.go

@@ -32,6 +32,7 @@ func init() {
 	rootCmd.PersistentFlags().BoolP("verbose", "v", false, "Verbose output")
 	rootCmd.PersistentFlags().StringP("out", "o", "", "Output file for compilation logs")
 	rootCmd.PersistentFlags().StringSliceP("usersplusfolder", "u", []string{}, "User SIMPL+ folders")
+	rootCmd.PersistentFlags().Bool("no-cache", false, "Disable build cache")
 	rootCmd.AddCommand(buildCmd)
 
 	viper.SetDefault("compiler_path", "C:/Program Files (x86)/Crestron/Simpl/SPlusCC.exe")

go.mod

@@ -478,6 +478,7 @@ require (
 	gitlab.com/gitlab-org/api/client-go v0.148.1 // indirect
 	go-simpler.org/musttag v0.13.0 // indirect
 	go-simpler.org/sloglint v0.9.0 // indirect
+	go.etcd.io/bbolt v1.4.3 // indirect
 	go.mongodb.org/mongo-driver v1.17.3 // indirect
 	go.opencensus.io v0.24.0 // indirect
 	go.opentelemetry.io/auto/sdk v1.1.0 // indirect

go.sum

@@ -1490,6 +1490,8 @@ go-simpler.org/musttag v0.13.0 h1:Q/YAW0AHvaoaIbsPj3bvEI5/QFP7w696IMUpnKXQfCE=
 go-simpler.org/musttag v0.13.0/go.mod h1:FTzIGeK6OkKlUDVpj0iQUXZLUO1Js9+mvykDQy9C5yM=
 go-simpler.org/sloglint v0.9.0 h1:/40NQtjRx9txvsB/RN022KsUJU+zaaSb/9q9BSefSrE=
 go-simpler.org/sloglint v0.9.0/go.mod h1:G/OrAF6uxj48sHahCzrbarVMptL2kjWTaUeC8+fOGww=
+go.etcd.io/bbolt v1.4.3 h1:dEadXpI6G79deX5prL3QRNP6JB8UxVkqo4UPnHaNXJo=
+go.etcd.io/bbolt v1.4.3/go.mod h1:tKQlpPaYCVFctUIgFKFnAlvbmB3tpy1vkTnDWohtc0E=
 go.mongodb.org/mongo-driver v1.17.3 h1:TQyXhnsWfWtgAhMtOgtYHMTkZIfBTpMTsMnd9ZBeHxQ=
 go.mongodb.org/mongo-driver v1.17.3/go.mod h1:Hy04i7O2kC4RS06ZrhPRqj/u4DTYkFDAAccj+rVKqgQ=
 go.opencensus.io v0.21.0/go.mod h1:mSImk1erAIZhrmZN+AvHh14ztQfjbGwt4TtuofqLduU=

internal/cache/artifacts.go

@@ -0,0 +1,103 @@
+package cache
+
+import (
+	"fmt"
+	"io"
+	"os"
+	"path/filepath"
+)
+
+// CopyArtifacts copies compiled outputs from source to cache
+func CopyArtifacts(sourceDir, 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)
+		dst := filepath.Join(destDir, output)
+
+		if err := copyFile(src, dst); err != nil {
+			return fmt.Errorf("failed to copy %s: %w", output, err)
+		}
+	}
+
+	return nil
+}
+
+// RestoreArtifacts copies cached outputs back to the working directory
+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)
+
+		if err := copyFile(src, dst); err != nil {
+			return fmt.Errorf("failed to restore %s: %w", output, err)
+		}
+	}
+
+	return nil
+}
+
+// CollectOutputs scans a directory and returns a list of compiled output files
+func CollectOutputs(dir string) ([]string, error) {
+	var outputs []string
+
+	entries, err := os.ReadDir(dir)
+	if err != nil {
+		if os.IsNotExist(err) {
+			return nil, nil // No outputs yet
+		}
+		return nil, fmt.Errorf("failed to read output 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)
+		}
+	}
+
+	return outputs, nil
+}
+
+// copyFile copies a file from src to dst
+func copyFile(src, dst string) error {
+	srcFile, err := os.Open(src)
+	if err != nil {
+		return err
+	}
+	defer srcFile.Close()
+
+	// Create parent directory if needed
+	if err := os.MkdirAll(filepath.Dir(dst), 0o755); err != nil {
+		return err
+	}
+
+	dstFile, err := os.Create(dst)
+	if err != nil {
+		return err
+	}
+	defer dstFile.Close()
+
+	if _, err := io.Copy(dstFile, srcFile); err != nil {
+		return err
+	}
+
+	// Preserve file permissions
+	srcInfo, err := os.Stat(src)
+	if err != nil {
+		return err
+	}
+
+	return os.Chmod(dst, srcInfo.Mode())
+}