feat(wanda): Add BuildWithDeps to build dependency chains

Implement build integration for wanda dependency resolution. The CLI
now automatically builds all dependencies in topological order before
building the target spec.

- Add BuildWithDeps function that builds specs in dependency order
- Tag each built image with spec.Name for @ref resolution
- Update CLI to use BuildWithDeps (backward compatible)
- In RayCI mode, skip dep building (handled by prior pipeline steps)
- Add test fixtures and tests for dependency chain builds

Topic: wanda-build-deps
Relative: wanda-deps
Labels: draft

Generated with help from Claude Opus 4.5

Signed-off-by: andrew <andrew@anyscale.com>

Author: andrew-anyscale

wanda/forge.go

@@ -35,6 +35,64 @@ func Build(specFile string, config *ForgeConfig) error {
 	return forge.Build(spec)
 }
 
+// BuildWithDeps builds a spec and all its dependencies in topological order.
+// In RayCI mode, deps are assumed built by prior pipeline steps; only the root is built.
+func BuildWithDeps(specFile string, config *ForgeConfig) error {
+	if config == nil {
+		config = &ForgeConfig{}
+	}
+
+	// In RayCI mode, only build the root spec (deps built by prior steps)
+	if config.RayCI {
+		return Build(specFile, config)
+	}
+
+	graph, err := BuildDepGraph(specFile, os.LookupEnv)
+	if err != nil {
+		return fmt.Errorf("build dep graph: %w", err)
+	}
+
+	if err := graph.ValidateDeps(); err != nil {
+		return fmt.Errorf("validate deps: %w", err)
+	}
+
+	forge, err := NewForge(config)
+	if err != nil {
+		return fmt.Errorf("make forge: %w", err)
+	}
+
+	for _, name := range graph.Order() {
+		rs := graph.Get(name)
+		spec := rs.Spec
+
+		log.Printf("building %s (from %s)", name, rs.Path)
+
+		if err := forge.buildWithLocalTag(spec); err != nil {
+			return fmt.Errorf("build %s: %w", name, err)
+		}
+	}
+
+	return nil
+}
+
+// buildWithLocalTag builds a spec and ensures it's tagged with spec.Name
+// so that @name references can resolve it.
+func (f *Forge) buildWithLocalTag(spec *Spec) error {
+	if !hasTag(spec.Tags, spec.Name) {
+		spec.Tags = append(spec.Tags, spec.Name)
+	}
+	return f.Build(spec)
+}
+
+func hasTag(tags []string, tag string) bool {
+	for _, t := range tags {
+		if t == tag {
+			return true
+		}
+	}
+	return false
+}
+
 // Forge is a forge to build container images.
 type Forge struct {
 	config *ForgeConfig

wanda/forge_test.go

@@ -455,6 +455,54 @@ func TestForgeWithRemoteWorkRepo(t *testing.T) {
 	}
 }
 
+func TestBuildWithDeps(t *testing.T) {
+	config := &ForgeConfig{WorkDir: "testdata"}
+
+	if err := BuildWithDeps("testdata/dep-top.wanda.yaml", config); err != nil {
+		t.Fatalf("BuildWithDeps: %v", err)
+	}
+
+	// Verify dep-top was built and contains content from all layers
+	ref, err := name.ParseReference("dep-top")
+	if err != nil {
+		t.Fatalf("parse reference: %v", err)
+	}
+
+	img, err := daemon.Image(ref)
+	if err != nil {
+		t.Fatalf("read image: %v", err)
+	}
+
+	layers, err := img.Layers()
+	if err != nil {
+		t.Fatalf("read layers: %v", err)
+	}
+
+	// Should have 3 layers: dep-base, dep-middle, dep-top
+	if len(layers) != 3 {
+		t.Fatalf("got %d layers, want 3", len(layers))
+	}
+
+	// Check that dep-middle's world.txt is in the image
+	files, err := filesInLayer(layers[1])
+	if err != nil {
+		t.Fatalf("read layer: %v", err)
+	}
+
+	if got := files["opt/app/world.txt"]; got != worldDotTxt {
+		t.Errorf("world.txt in image, got %q, want %q", got, worldDotTxt)
+	}
+}
+
+func TestBuildWithDeps_NoDeps(t *testing.T) {
+	config := &ForgeConfig{WorkDir: "testdata"}
+
+	// BuildWithDeps should work for specs without deps (backward compat)
+	if err := BuildWithDeps("testdata/hello.wanda.yaml", config); err != nil {
+		t.Fatalf("BuildWithDeps: %v", err)
+	}
+}
+
 func TestForgeLocal_withNamePrefix(t *testing.T) {
 	if runtime.GOOS != "linux" {
 		t.Skip("skipping test on non-linux")

wanda/testdata/Dockerfile.dep-base

@@ -0,0 +1,3 @@
+FROM scratch
+
+COPY Dockerfile.dep-base /opt/app/Dockerfile

wanda/testdata/Dockerfile.dep-middle

@@ -0,0 +1,3 @@
+FROM dep-base
+
+COPY world.txt /opt/app/world.txt

wanda/testdata/Dockerfile.dep-top

@@ -0,0 +1,3 @@
+FROM dep-middle
+
+COPY Dockerfile.dep-top /opt/app/top.txt

wanda/testdata/dep-base.wanda.yaml

@@ -1,2 +1,2 @@
 name: dep-base
-dockerfile: Dockerfile.hello
+dockerfile: Dockerfile.dep-base

wanda/testdata/dep-middle.wanda.yaml

@@ -1,6 +1,6 @@
 name: dep-middle
 deps: [dep-base.wanda.yaml]
 froms: ["@dep-base"]
-dockerfile: Dockerfile.world
+dockerfile: Dockerfile.dep-middle
 srcs:
   - world.txt

wanda/testdata/dep-top.wanda.yaml

@@ -1,4 +1,4 @@
 name: dep-top
 deps: [dep-middle.wanda.yaml]
 froms: ["@dep-middle"]
-dockerfile: Dockerfile.local
+dockerfile: Dockerfile.dep-top

wanda/wanda/main.go

@@ -85,7 +85,7 @@ func main() {
 		ReadOnlyCache: *readOnly,
 	}
 
-	if err := wanda.Build(input, config); err != nil {
+	if err := wanda.BuildWithDeps(input, config); err != nil {
 		log.Fatal(err)
 	}
 }