Create a BuildCloneStep function that returns a step struct that inherits from models.Step

Signed-off-by: Evan Jarrett <[e-mail]>

spindle/engines/nixery/engine.go

···
 	setup := &setupSteps{}
 
 	setup.addStep(nixConfStep())
-	setup.addStep(cloneStep(twf, *tpl.TriggerMetadata, e.cfg.Server.Dev))
+	setup.addStep(models.BuildCloneStep(twf, *tpl.TriggerMetadata, workspaceDir, e.cfg.Server.Dev))
 	// this step could be empty
 	if s := dependencyStep(dwf.Dependencies); s != nil {
 		setup.addStep(*s)

spindle/engines/nixery/setup_steps.go

···
 import (
 	"fmt"
 	"strings"
-
-	"tangled.org/core/api/tangled"
-	"tangled.org/core/spindle/workflow"
 )
 
 func nixConfStep() Step {
···
 	return Step{
 		command: setupCmd,
 		name:    "Configure Nix",
-	}
-}
-
-// cloneStep uses the shared clone step builder to generate git clone commands.
-// The shared builder handles:
-// - git init
-// - git remote add origin <url>
-// - git fetch --depth=<d> --recurse-submodules=<yes|no> <sha>
-// - git checkout FETCH_HEAD
-// And supports all trigger types (push, PR, manual) and clone options.
-func cloneStep(twf tangled.Pipeline_Workflow, tr tangled.Pipeline_TriggerMetadata, dev bool) Step {
-	info, err := workflow.GetCloneInfo(workflow.CloneOptions{
-		Workflow:        twf,
-		TriggerMetadata: tr,
-		DevMode:         dev,
-		WorkspaceDir:    workspaceDir,
-	})
-	if err != nil {
-		return Step{
-			command: fmt.Sprintf("echo 'Failed to get clone info: %s' && exit 1", err.Error()),
-			name:    "Clone repository into workspace (error)",
-		}
-	}
-
-	if info.Skip {
-		return Step{}
-	}
-
-	return Step{
-		command: strings.Join(info.Commands, "\n"),
-		name:    "Clone repository into workspace",
 	}
 }
 

spindle/models/clone_test.go

···
+package models
+
+import (
+	"strings"
+	"testing"
+
+	"tangled.org/core/api/tangled"
+	"tangled.org/core/workflow"
+)
+
+func TestBuildCloneStep_PushTrigger(t *testing.T) {
+	twf := tangled.Pipeline_Workflow{
+		Clone: &tangled.Pipeline_CloneOpts{
+			Depth:      1,
+			Submodules: false,
+			Skip:       false,
+		},
+	}
+	tr := tangled.Pipeline_TriggerMetadata{
+		Kind: string(workflow.TriggerKindPush),
+		Push: &tangled.Pipeline_PushTriggerData{
+			NewSha: "abc123",
+			OldSha: "def456",
+			Ref:    "refs/heads/main",
+		},
+		Repo: &tangled.Pipeline_TriggerRepo{
+			Knot: "example.com",
+			Did:  "did:plc:user123",
+			Repo: "my-repo",
+		},
+	}
+
+	step := BuildCloneStep(twf, tr, "/tangled/workspace", false)
+
+	if step.Kind() != StepKindSystem {
+		t.Errorf("Expected StepKindSystem, got %v", step.Kind())
+	}
+
+	if step.Name() != "Clone repository into workspace" {
+		t.Errorf("Expected 'Clone repository into workspace', got '%s'", step.Name())
+	}
+
+	commands := step.Commands()
+	if len(commands) != 5 {
+		t.Errorf("Expected 5 commands, got %d", len(commands))
+	}
+
+	// Verify commands contain expected git operations
+	allCmds := strings.Join(commands, " ")
+	if !strings.Contains(allCmds, "git init") {
+		t.Error("Commands should contain 'git init'")
+	}
+	if !strings.Contains(allCmds, "git remote add origin") {
+		t.Error("Commands should contain 'git remote add origin'")
+	}
+	if !strings.Contains(allCmds, "git fetch") {
+		t.Error("Commands should contain 'git fetch'")
+	}
+	if !strings.Contains(allCmds, "abc123") {
+		t.Error("Commands should contain commit SHA")
+	}
+	if !strings.Contains(allCmds, "git checkout FETCH_HEAD") {
+		t.Error("Commands should contain 'git checkout FETCH_HEAD'")
+	}
+	if !strings.Contains(allCmds, "https://example.com/did:plc:user123/my-repo") {
+		t.Error("Commands should contain expected repo URL")
+	}
+}
+
+func TestBuildCloneStep_PullRequestTrigger(t *testing.T) {
+	twf := tangled.Pipeline_Workflow{
+		Clone: &tangled.Pipeline_CloneOpts{
+			Depth: 1,
+			Skip:  false,
+		},
+	}
+	tr := tangled.Pipeline_TriggerMetadata{
+		Kind: string(workflow.TriggerKindPullRequest),
+		PullRequest: &tangled.Pipeline_PullRequestTriggerData{
+			SourceSha:    "pr-sha-789",
+			SourceBranch: "feature-branch",
+			TargetBranch: "main",
+			Action:       "opened",
+		},
+		Repo: &tangled.Pipeline_TriggerRepo{
+			Knot: "example.com",
+			Did:  "did:plc:user123",
+			Repo: "my-repo",
+		},
+	}
+
+	step := BuildCloneStep(twf, tr, "/tangled/workspace", false)
+
+	allCmds := strings.Join(step.Commands(), " ")
+	if !strings.Contains(allCmds, "pr-sha-789") {
+		t.Error("Commands should contain PR commit SHA")
+	}
+}
+
+func TestBuildCloneStep_ManualTrigger(t *testing.T) {
+	twf := tangled.Pipeline_Workflow{
+		Clone: &tangled.Pipeline_CloneOpts{
+			Depth: 1,
+			Skip:  false,
+		},
+	}
+	tr := tangled.Pipeline_TriggerMetadata{
+		Kind: string(workflow.TriggerKindManual),
+		Manual: &tangled.Pipeline_ManualTriggerData{
+			Inputs: nil,
+		},
+		Repo: &tangled.Pipeline_TriggerRepo{
+			Knot: "example.com",
+			Did:  "did:plc:user123",
+			Repo: "my-repo",
+		},
+	}
+
+	step := BuildCloneStep(twf, tr, "/tangled/workspace", false)
+
+	// Manual triggers don't have a SHA yet (TODO), so git fetch won't include a SHA
+	allCmds := strings.Join(step.Commands(), " ")
+	// Should still have basic git commands
+	if !strings.Contains(allCmds, "git init") {
+		t.Error("Commands should contain 'git init'")
+	}
+	if !strings.Contains(allCmds, "git fetch") {
+		t.Error("Commands should contain 'git fetch'")
+	}
+}
+
+func TestBuildCloneStep_SkipFlag(t *testing.T) {
+	twf := tangled.Pipeline_Workflow{
+		Clone: &tangled.Pipeline_CloneOpts{
+			Skip: true,
+		},
+	}
+	tr := tangled.Pipeline_TriggerMetadata{
+		Kind: string(workflow.TriggerKindPush),
+		Push: &tangled.Pipeline_PushTriggerData{
+			NewSha: "abc123",
+		},
+		Repo: &tangled.Pipeline_TriggerRepo{
+			Knot: "example.com",
+			Did:  "did:plc:user123",
+			Repo: "my-repo",
+		},
+	}
+
+	step := BuildCloneStep(twf, tr, "/tangled/workspace", false)
+
+	// Empty step when skip is true
+	if step.Name() != "" {
+		t.Error("Expected empty step name when Skip is true")
+	}
+	if len(step.Commands()) != 0 {
+		t.Errorf("Expected no commands when Skip is true, got %d commands", len(step.Commands()))
+	}
+}
+
+func TestBuildCloneStep_DevMode(t *testing.T) {
+	twf := tangled.Pipeline_Workflow{
+		Clone: &tangled.Pipeline_CloneOpts{
+			Depth: 1,
+			Skip:  false,
+		},
+	}
+	tr := tangled.Pipeline_TriggerMetadata{
+		Kind: string(workflow.TriggerKindPush),
+		Push: &tangled.Pipeline_PushTriggerData{
+			NewSha: "abc123",
+		},
+		Repo: &tangled.Pipeline_TriggerRepo{
+			Knot: "localhost:3000",
+			Did:  "did:plc:user123",
+			Repo: "my-repo",
+		},
+	}
+
+	step := BuildCloneStep(twf, tr, "/tangled/workspace", true)
+
+	// In dev mode, should use http:// and replace localhost with host.docker.internal
+	allCmds := strings.Join(step.Commands(), " ")
+	expectedURL := "http://host.docker.internal:3000/did:plc:user123/my-repo"
+	if !strings.Contains(allCmds, expectedURL) {
+		t.Errorf("Expected dev mode URL '%s' in commands", expectedURL)
+	}
+}
+
+func TestBuildCloneStep_DepthAndSubmodules(t *testing.T) {
+	twf := tangled.Pipeline_Workflow{
+		Clone: &tangled.Pipeline_CloneOpts{
+			Depth:      10,
+			Submodules: true,
+			Skip:       false,
+		},
+	}
+	tr := tangled.Pipeline_TriggerMetadata{
+		Kind: string(workflow.TriggerKindPush),
+		Push: &tangled.Pipeline_PushTriggerData{
+			NewSha: "abc123",
+		},
+		Repo: &tangled.Pipeline_TriggerRepo{
+			Knot: "example.com",
+			Did:  "did:plc:user123",
+			Repo: "my-repo",
+		},
+	}
+
+	step := BuildCloneStep(twf, tr, "/tangled/workspace", false)
+
+	allCmds := strings.Join(step.Commands(), " ")
+	if !strings.Contains(allCmds, "--depth=10") {
+		t.Error("Commands should contain '--depth=10'")
+	}
+
+	if !strings.Contains(allCmds, "--recurse-submodules=yes") {
+		t.Error("Commands should contain '--recurse-submodules=yes'")
+	}
+}
+
+func TestBuildCloneStep_DefaultDepth(t *testing.T) {
+	twf := tangled.Pipeline_Workflow{
+		Clone: &tangled.Pipeline_CloneOpts{
+			Depth: 0, // Default should be 1
+			Skip:  false,
+		},
+	}
+	tr := tangled.Pipeline_TriggerMetadata{
+		Kind: string(workflow.TriggerKindPush),
+		Push: &tangled.Pipeline_PushTriggerData{
+			NewSha: "abc123",
+		},
+		Repo: &tangled.Pipeline_TriggerRepo{
+			Knot: "example.com",
+			Did:  "did:plc:user123",
+			Repo: "my-repo",
+		},
+	}
+
+	step := BuildCloneStep(twf, tr, "/tangled/workspace", false)
+
+	allCmds := strings.Join(step.Commands(), " ")
+	if !strings.Contains(allCmds, "--depth=1") {
+		t.Error("Commands should default to '--depth=1'")
+	}
+}
+
+func TestBuildCloneStep_NilPushData(t *testing.T) {
+	twf := tangled.Pipeline_Workflow{
+		Clone: &tangled.Pipeline_CloneOpts{
+			Depth: 1,
+			Skip:  false,
+		},
+	}
+	tr := tangled.Pipeline_TriggerMetadata{
+		Kind: string(workflow.TriggerKindPush),
+		Push: nil, // Nil push data should create error step
+		Repo: &tangled.Pipeline_TriggerRepo{
+			Knot: "example.com",
+			Did:  "did:plc:user123",
+			Repo: "my-repo",
+		},
+	}
+
+	step := BuildCloneStep(twf, tr, "/tangled/workspace", false)
+
+	// Should return an error step
+	if !strings.Contains(step.Name(), "error") {
+		t.Error("Expected error in step name when push data is nil")
+	}
+
+	allCmds := strings.Join(step.Commands(), " ")
+	if !strings.Contains(allCmds, "Failed to get clone info") {
+		t.Error("Commands should contain error message")
+	}
+	if !strings.Contains(allCmds, "exit 1") {
+		t.Error("Commands should exit with error")
+	}
+}
+
+func TestBuildCloneStep_NilPRData(t *testing.T) {
+	twf := tangled.Pipeline_Workflow{
+		Clone: &tangled.Pipeline_CloneOpts{
+			Depth: 1,
+			Skip:  false,
+		},
+	}
+	tr := tangled.Pipeline_TriggerMetadata{
+		Kind:        string(workflow.TriggerKindPullRequest),
+		PullRequest: nil, // Nil PR data should create error step
+		Repo: &tangled.Pipeline_TriggerRepo{
+			Knot: "example.com",
+			Did:  "did:plc:user123",
+			Repo: "my-repo",
+		},
+	}
+
+	step := BuildCloneStep(twf, tr, "/tangled/workspace", false)
+
+	// Should return an error step
+	if !strings.Contains(step.Name(), "error") {
+		t.Error("Expected error in step name when pull request data is nil")
+	}
+
+	allCmds := strings.Join(step.Commands(), " ")
+	if !strings.Contains(allCmds, "Failed to get clone info") {
+		t.Error("Commands should contain error message")
+	}
+}
+
+func TestBuildCloneStep_CustomWorkspace(t *testing.T) {
+	twf := tangled.Pipeline_Workflow{
+		Clone: &tangled.Pipeline_CloneOpts{
+			Depth: 1,
+			Skip:  false,
+		},
+	}
+	tr := tangled.Pipeline_TriggerMetadata{
+		Kind: string(workflow.TriggerKindPush),
+		Push: &tangled.Pipeline_PushTriggerData{
+			NewSha: "abc123",
+		},
+		Repo: &tangled.Pipeline_TriggerRepo{
+			Knot: "example.com",
+			Did:  "did:plc:user123",
+			Repo: "my-repo",
+		},
+	}
+
+	step := BuildCloneStep(twf, tr, "/custom/path", false)
+
+	allCmds := strings.Join(step.Commands(), " ")
+	if !strings.Contains(allCmds, "/custom/path") {
+		t.Error("Commands should use custom workspace directory")
+	}
+}
+
+func TestBuildCloneStep_DefaultWorkspace(t *testing.T) {
+	twf := tangled.Pipeline_Workflow{
+		Clone: &tangled.Pipeline_CloneOpts{
+			Depth: 1,
+			Skip:  false,
+		},
+	}
+	tr := tangled.Pipeline_TriggerMetadata{
+		Kind: string(workflow.TriggerKindPush),
+		Push: &tangled.Pipeline_PushTriggerData{
+			NewSha: "abc123",
+		},
+		Repo: &tangled.Pipeline_TriggerRepo{
+			Knot: "example.com",
+			Did:  "did:plc:user123",
+			Repo: "my-repo",
+		},
+	}
+
+	step := BuildCloneStep(twf, tr, "", false) // Empty should default to /tangled/workspace
+
+	allCmds := strings.Join(step.Commands(), " ")
+	if !strings.Contains(allCmds, "/tangled/workspace") {
+		t.Error("Commands should default to /tangled/workspace")
+	}
+}

spindle/workflow/clone.go spindle/models/clone.go

···
-package workflow
+package models
 
 import (
 	"fmt"
···
 	"tangled.org/core/workflow"
 )
 
-type CloneOptions struct {
-	Workflow        tangled.Pipeline_Workflow
-	TriggerMetadata tangled.Pipeline_TriggerMetadata
-	DevMode         bool
-	WorkspaceDir    string
+type CloneStep struct {
+	name        string
+	kind        StepKind
+	commands     []string
+}
+
+func (s CloneStep) Name() string {
+	return s.name
+}
+
+func (s CloneStep) Commands() []string {
+	return s.commands
+}
+
+func (s CloneStep) Command() string {
+	return strings.Join(s.commands, "\n")
 }
 
-type CloneInfo struct {
-	Commands  []string
-	RepoURL   string
-	CommitSHA string
-	Skip      bool
+func (s CloneStep) Kind() StepKind {
+	return s.kind
 }
 
-// GetCloneInfo generates git clone commands and metadata from pipeline trigger metadata
-func GetCloneInfo(opts CloneOptions) (*CloneInfo, error) {
-	if opts.Workflow.Clone != nil && opts.Workflow.Clone.Skip {
-		return &CloneInfo{Skip: true}, nil
+// BuildCloneStep generates git clone commands.
+// The shared builder handles:
+// - git init
+// - git remote add origin <url>
+// - git fetch --depth=<d> --recurse-submodules=<yes|no> <sha>
+// - git checkout FETCH_HEAD
+// And supports all trigger types (push, PR, manual) and clone options.
+func BuildCloneStep(twf tangled.Pipeline_Workflow, tr tangled.Pipeline_TriggerMetadata, workspaceDir string, dev bool) CloneStep {
+	if twf.Clone != nil && twf.Clone.Skip {
+		return CloneStep{}
 	}
 
-	commitSHA, err := extractCommitSHA(opts.TriggerMetadata)
+	commitSHA, err := extractCommitSHA(tr)
 	if err != nil {
-		return nil, fmt.Errorf("failed to extract commit SHA: %w", err)
+	 return CloneStep{
+			kind: StepKindSystem,
+			name:    "Clone repository into workspace (error)",
+			commands: []string{fmt.Sprintf("echo 'Failed to get clone info: %s' && exit 1", err.Error())},
+		}
 	}
 
-	repoURL := buildRepoURL(opts.TriggerMetadata, opts.DevMode)
+	repoURL := buildRepoURL(tr, dev)
 
-	workspaceDir := opts.WorkspaceDir
 	if workspaceDir == "" {
 		workspaceDir = "/tangled/workspace"
 	}
···
 	remoteCmd := fmt.Sprintf("git remote add origin %s", repoURL)
 
 	var cloneOpts tangled.Pipeline_CloneOpts
-	if opts.Workflow.Clone != nil {
-		cloneOpts = *opts.Workflow.Clone
+	if twf.Clone != nil {
+		cloneOpts = *twf.Clone
 	}
 	fetchArgs := buildFetchArgs(cloneOpts, commitSHA)
 	fetchCmd := fmt.Sprintf("git fetch %s", strings.Join(fetchArgs, " "))
-
 	checkoutCmd := "git checkout FETCH_HEAD"
-
-	commands := []string{
-		initCmd,
-		fmt.Sprintf("cd %s", workspaceDir),
-		remoteCmd,
-		fetchCmd,
-		checkoutCmd,
+	
+	return CloneStep{
+		kind: StepKindSystem,
+		name: "Clone repository into workspace",
+		commands: []string{
+			initCmd,
+			fmt.Sprintf("cd %s", workspaceDir),
+			remoteCmd,
+			fetchCmd,
+			checkoutCmd,
+		},
 	}
-
-	return &CloneInfo{
-		Commands:  commands,
-		RepoURL:   repoURL,
-		CommitSHA: commitSHA,
-		Skip:      false,
-	}, nil
 }
 
 // extractCommitSHA extracts the commit SHA from trigger metadata based on trigger type

spindle/workflow/clone_test.go

···
-package workflow
-
-import (
-	"strings"
-	"testing"
-
-	"tangled.org/core/api/tangled"
-	"tangled.org/core/workflow"
-)
-
-func TestGetCloneInfo_PushTrigger(t *testing.T) {
-	cfg := CloneOptions{
-		Workflow: tangled.Pipeline_Workflow{
-			Clone: &tangled.Pipeline_CloneOpts{
-				Depth:      1,
-				Submodules: false,
-				Skip:       false,
-			},
-		},
-		TriggerMetadata: tangled.Pipeline_TriggerMetadata{
-			Kind: string(workflow.TriggerKindPush),
-			Push: &tangled.Pipeline_PushTriggerData{
-				NewSha: "abc123",
-				OldSha: "def456",
-				Ref:    "refs/heads/main",
-			},
-			Repo: &tangled.Pipeline_TriggerRepo{
-				Knot: "example.com",
-				Did:  "did:plc:user123",
-				Repo: "my-repo",
-			},
-		},
-		DevMode:      false,
-		WorkspaceDir: "/tangled/workspace",
-	}
-
-	info, err := GetCloneInfo(cfg)
-	if err != nil {
-		t.Fatalf("GetCloneInfo failed: %v", err)
-	}
-
-	if info.Skip {
-		t.Error("Expected Skip to be false")
-	}
-
-	if info.CommitSHA != "abc123" {
-		t.Errorf("Expected CommitSHA 'abc123', got '%s'", info.CommitSHA)
-	}
-
-	expectedURL := "https://example.com/did:plc:user123/my-repo"
-	if info.RepoURL != expectedURL {
-		t.Errorf("Expected RepoURL '%s', got '%s'", expectedURL, info.RepoURL)
-	}
-
-	if len(info.Commands) != 5 {
-		t.Errorf("Expected 5 commands, got %d", len(info.Commands))
-	}
-
-	// Verify commands contain expected git operations
-	allCmds := strings.Join(info.Commands, " ")
-	if !strings.Contains(allCmds, "git init") {
-		t.Error("Commands should contain 'git init'")
-	}
-	if !strings.Contains(allCmds, "git remote add origin") {
-		t.Error("Commands should contain 'git remote add origin'")
-	}
-	if !strings.Contains(allCmds, "git fetch") {
-		t.Error("Commands should contain 'git fetch'")
-	}
-	if !strings.Contains(allCmds, "abc123") {
-		t.Error("Commands should contain commit SHA")
-	}
-	if !strings.Contains(allCmds, "git checkout FETCH_HEAD") {
-		t.Error("Commands should contain 'git checkout FETCH_HEAD'")
-	}
-}
-
-func TestGetCloneInfo_PullRequestTrigger(t *testing.T) {
-	cfg := CloneOptions{
-		Workflow: tangled.Pipeline_Workflow{
-			Clone: &tangled.Pipeline_CloneOpts{
-				Depth: 1,
-				Skip:  false,
-			},
-		},
-		TriggerMetadata: tangled.Pipeline_TriggerMetadata{
-			Kind: string(workflow.TriggerKindPullRequest),
-			PullRequest: &tangled.Pipeline_PullRequestTriggerData{
-				SourceSha:    "pr-sha-789",
-				SourceBranch: "feature-branch",
-				TargetBranch: "main",
-				Action:       "opened",
-			},
-			Repo: &tangled.Pipeline_TriggerRepo{
-				Knot: "example.com",
-				Did:  "did:plc:user123",
-				Repo: "my-repo",
-			},
-		},
-		DevMode:      false,
-		WorkspaceDir: "/tangled/workspace",
-	}
-
-	info, err := GetCloneInfo(cfg)
-	if err != nil {
-		t.Fatalf("GetCloneInfo failed: %v", err)
-	}
-
-	if info.CommitSHA != "pr-sha-789" {
-		t.Errorf("Expected CommitSHA 'pr-sha-789', got '%s'", info.CommitSHA)
-	}
-
-	allCmds := strings.Join(info.Commands, " ")
-	if !strings.Contains(allCmds, "pr-sha-789") {
-		t.Error("Commands should contain PR commit SHA")
-	}
-}
-
-func TestGetCloneInfo_ManualTrigger(t *testing.T) {
-	cfg := CloneOptions{
-		Workflow: tangled.Pipeline_Workflow{
-			Clone: &tangled.Pipeline_CloneOpts{
-				Depth: 1,
-				Skip:  false,
-			},
-		},
-		TriggerMetadata: tangled.Pipeline_TriggerMetadata{
-			Kind: string(workflow.TriggerKindManual),
-			Manual: &tangled.Pipeline_ManualTriggerData{
-				Inputs: nil,
-			},
-			Repo: &tangled.Pipeline_TriggerRepo{
-				Knot: "example.com",
-				Did:  "did:plc:user123",
-				Repo: "my-repo",
-			},
-		},
-		DevMode:      false,
-		WorkspaceDir: "/tangled/workspace",
-	}
-
-	info, err := GetCloneInfo(cfg)
-	if err != nil {
-		t.Fatalf("GetCloneInfo failed: %v", err)
-	}
-
-	// Manual triggers don't have a SHA yet (TODO)
-	if info.CommitSHA != "" {
-		t.Errorf("Expected empty CommitSHA for manual trigger, got '%s'", info.CommitSHA)
-	}
-}
-
-func TestGetCloneInfo_SkipFlag(t *testing.T) {
-	cfg := CloneOptions{
-		Workflow: tangled.Pipeline_Workflow{
-			Clone: &tangled.Pipeline_CloneOpts{
-				Skip: true,
-			},
-		},
-		TriggerMetadata: tangled.Pipeline_TriggerMetadata{
-			Kind: string(workflow.TriggerKindPush),
-			Push: &tangled.Pipeline_PushTriggerData{
-				NewSha: "abc123",
-			},
-			Repo: &tangled.Pipeline_TriggerRepo{
-				Knot: "example.com",
-				Did:  "did:plc:user123",
-				Repo: "my-repo",
-			},
-		},
-	}
-
-	info, err := GetCloneInfo(cfg)
-	if err != nil {
-		t.Fatalf("GetCloneInfo failed: %v", err)
-	}
-
-	if !info.Skip {
-		t.Error("Expected Skip to be true")
-	}
-
-	if len(info.Commands) != 0 {
-		t.Errorf("Expected no commands when Skip is true, got %d commands", len(info.Commands))
-	}
-}
-
-func TestGetCloneInfo_DevMode(t *testing.T) {
-	cfg := CloneOptions{
-		Workflow: tangled.Pipeline_Workflow{
-			Clone: &tangled.Pipeline_CloneOpts{
-				Depth: 1,
-				Skip:  false,
-			},
-		},
-		TriggerMetadata: tangled.Pipeline_TriggerMetadata{
-			Kind: string(workflow.TriggerKindPush),
-			Push: &tangled.Pipeline_PushTriggerData{
-				NewSha: "abc123",
-			},
-			Repo: &tangled.Pipeline_TriggerRepo{
-				Knot: "localhost:3000",
-				Did:  "did:plc:user123",
-				Repo: "my-repo",
-			},
-		},
-		DevMode:      true,
-		WorkspaceDir: "/tangled/workspace",
-	}
-
-	info, err := GetCloneInfo(cfg)
-	if err != nil {
-		t.Fatalf("GetCloneInfo failed: %v", err)
-	}
-
-	// In dev mode, should use http:// and replace localhost with host.docker.internal
-	expectedURL := "http://host.docker.internal:3000/did:plc:user123/my-repo"
-	if info.RepoURL != expectedURL {
-		t.Errorf("Expected dev mode URL '%s', got '%s'", expectedURL, info.RepoURL)
-	}
-}
-
-func TestGetCloneInfo_DepthAndSubmodules(t *testing.T) {
-	cfg := CloneOptions{
-		Workflow: tangled.Pipeline_Workflow{
-			Clone: &tangled.Pipeline_CloneOpts{
-				Depth:      10,
-				Submodules: true,
-				Skip:       false,
-			},
-		},
-		TriggerMetadata: tangled.Pipeline_TriggerMetadata{
-			Kind: string(workflow.TriggerKindPush),
-			Push: &tangled.Pipeline_PushTriggerData{
-				NewSha: "abc123",
-			},
-			Repo: &tangled.Pipeline_TriggerRepo{
-				Knot: "example.com",
-				Did:  "did:plc:user123",
-				Repo: "my-repo",
-			},
-		},
-		DevMode:      false,
-		WorkspaceDir: "/tangled/workspace",
-	}
-
-	info, err := GetCloneInfo(cfg)
-	if err != nil {
-		t.Fatalf("GetCloneInfo failed: %v", err)
-	}
-
-	allCmds := strings.Join(info.Commands, " ")
-	if !strings.Contains(allCmds, "--depth=10") {
-		t.Error("Commands should contain '--depth=10'")
-	}
-
-	if !strings.Contains(allCmds, "--recurse-submodules=yes") {
-		t.Error("Commands should contain '--recurse-submodules=yes'")
-	}
-}
-
-func TestGetCloneInfo_DefaultDepth(t *testing.T) {
-	cfg := CloneOptions{
-		Workflow: tangled.Pipeline_Workflow{
-			Clone: &tangled.Pipeline_CloneOpts{
-				Depth: 0, // Default should be 1
-				Skip:  false,
-			},
-		},
-		TriggerMetadata: tangled.Pipeline_TriggerMetadata{
-			Kind: string(workflow.TriggerKindPush),
-			Push: &tangled.Pipeline_PushTriggerData{
-				NewSha: "abc123",
-			},
-			Repo: &tangled.Pipeline_TriggerRepo{
-				Knot: "example.com",
-				Did:  "did:plc:user123",
-				Repo: "my-repo",
-			},
-		},
-		WorkspaceDir: "/tangled/workspace",
-	}
-
-	info, err := GetCloneInfo(cfg)
-	if err != nil {
-		t.Fatalf("GetCloneInfo failed: %v", err)
-	}
-
-	allCmds := strings.Join(info.Commands, " ")
-	if !strings.Contains(allCmds, "--depth=1") {
-		t.Error("Commands should default to '--depth=1'")
-	}
-}
-
-func TestGetCloneInfo_NilPushData(t *testing.T) {
-	cfg := CloneOptions{
-		Workflow: tangled.Pipeline_Workflow{
-			Clone: &tangled.Pipeline_CloneOpts{
-				Depth: 1,
-				Skip:  false,
-			},
-		},
-		TriggerMetadata: tangled.Pipeline_TriggerMetadata{
-			Kind: string(workflow.TriggerKindPush),
-			Push: nil, // Nil push data should return error
-			Repo: &tangled.Pipeline_TriggerRepo{
-				Knot: "example.com",
-				Did:  "did:plc:user123",
-				Repo: "my-repo",
-			},
-		},
-		WorkspaceDir: "/tangled/workspace",
-	}
-
-	_, err := GetCloneInfo(cfg)
-	if err == nil {
-		t.Error("Expected error when push data is nil")
-	}
-
-	if !strings.Contains(err.Error(), "push trigger metadata is nil") {
-		t.Errorf("Expected error about nil push metadata, got: %v", err)
-	}
-}
-
-func TestGetCloneInfo_NilPRData(t *testing.T) {
-	cfg := CloneOptions{
-		Workflow: tangled.Pipeline_Workflow{
-			Clone: &tangled.Pipeline_CloneOpts{
-				Depth: 1,
-				Skip:  false,
-			},
-		},
-		TriggerMetadata: tangled.Pipeline_TriggerMetadata{
-			Kind:        string(workflow.TriggerKindPullRequest),
-			PullRequest: nil, // Nil PR data should return error
-			Repo: &tangled.Pipeline_TriggerRepo{
-				Knot: "example.com",
-				Did:  "did:plc:user123",
-				Repo: "my-repo",
-			},
-		},
-		WorkspaceDir: "/tangled/workspace",
-	}
-
-	_, err := GetCloneInfo(cfg)
-	if err == nil {
-		t.Error("Expected error when pull request data is nil")
-	}
-
-	if !strings.Contains(err.Error(), "pull request trigger metadata is nil") {
-		t.Errorf("Expected error about nil PR metadata, got: %v", err)
-	}
-}
-
-func TestGetCloneInfo_CustomWorkspace(t *testing.T) {
-	cfg := CloneOptions{
-		Workflow: tangled.Pipeline_Workflow{
-			Clone: &tangled.Pipeline_CloneOpts{
-				Depth: 1,
-				Skip:  false,
-			},
-		},
-		TriggerMetadata: tangled.Pipeline_TriggerMetadata{
-			Kind: string(workflow.TriggerKindPush),
-			Push: &tangled.Pipeline_PushTriggerData{
-				NewSha: "abc123",
-			},
-			Repo: &tangled.Pipeline_TriggerRepo{
-				Knot: "example.com",
-				Did:  "did:plc:user123",
-				Repo: "my-repo",
-			},
-		},
-		DevMode:      false,
-		WorkspaceDir: "/custom/path",
-	}
-
-	info, err := GetCloneInfo(cfg)
-	if err != nil {
-		t.Fatalf("GetCloneInfo failed: %v", err)
-	}
-
-	allCmds := strings.Join(info.Commands, " ")
-	if !strings.Contains(allCmds, "/custom/path") {
-		t.Error("Commands should use custom workspace directory")
-	}
-}
-
-func TestGetCloneInfo_DefaultWorkspace(t *testing.T) {
-	cfg := CloneOptions{
-		Workflow: tangled.Pipeline_Workflow{
-			Clone: &tangled.Pipeline_CloneOpts{
-				Depth: 1,
-				Skip:  false,
-			},
-		},
-		TriggerMetadata: tangled.Pipeline_TriggerMetadata{
-			Kind: string(workflow.TriggerKindPush),
-			Push: &tangled.Pipeline_PushTriggerData{
-				NewSha: "abc123",
-			},
-			Repo: &tangled.Pipeline_TriggerRepo{
-				Knot: "example.com",
-				Did:  "did:plc:user123",
-				Repo: "my-repo",
-			},
-		},
-		DevMode:      false,
-		WorkspaceDir: "", // Empty should default to /tangled/workspace
-	}
-
-	info, err := GetCloneInfo(cfg)
-	if err != nil {
-		t.Fatalf("GetCloneInfo failed: %v", err)
-	}
-
-	allCmds := strings.Join(info.Commands, " ")
-	if !strings.Contains(allCmds, "/tangled/workspace") {
-		t.Error("Commands should default to /tangled/workspace")
-	}
-}