refactor(cmd): Factor out runtime and pipeline from down

cmd/down.go

@@ -1,13 +1,12 @@
 package cmd
 
 import (
-	"context"
 	"fmt"
+	"os"
 
 	"github.com/spf13/cobra"
 	"github.com/windsorcli/cli/pkg/di"
-	"github.com/windsorcli/cli/pkg/pipelines"
-	"github.com/windsorcli/cli/pkg/runtime"
+	"github.com/windsorcli/cli/pkg/project"
 )
 
 var (
@@ -23,61 +22,57 @@ var downCmd = &cobra.Command{
 	Long:         "Tear down the Windsor environment by executing necessary shell commands.",
 	SilenceUsage: true,
 	RunE: func(cmd *cobra.Command, args []string) error {
-		// Get shared dependency injector from context
 		injector := cmd.Context().Value(injectorKey).(di.Injector)
 
-		// First, set up environment variables using runtime
-		deps := &runtime.Dependencies{
-			Injector: injector,
-		}
-		if err := runtime.NewRuntime(deps).
-			LoadShell().
-			CheckTrustedDirectory().
-			LoadConfig().
-			LoadSecretsProviders().
-			LoadEnvVars(runtime.EnvVarsOptions{
-				Decrypt: true,
-				Verbose: verbose,
-			}).
-			ExecutePostEnvHook(verbose).
-			Do(); err != nil {
-			return fmt.Errorf("failed to set up environment: %w", err)
-		}
-
-		// Then, run the init pipeline to initialize the environment
-		var initPipeline pipelines.Pipeline
-		initPipeline, err := pipelines.WithPipeline(injector, cmd.Context(), "initPipeline")
+		proj, err := project.NewProject(injector, "")
 		if err != nil {
-			return fmt.Errorf("failed to set up init pipeline: %w", err)
+			return err
 		}
-		if err := initPipeline.Execute(cmd.Context()); err != nil {
-			return fmt.Errorf("failed to initialize environment: %w", err)
+
+		if err := proj.Context.Shell.CheckTrustedDirectory(); err != nil {
+			return fmt.Errorf("not in a trusted directory. If you are in a Windsor project, run 'windsor init' to approve")
 		}
 
-		// Finally, run the down pipeline for infrastructure teardown
-		downPipeline, err := pipelines.WithPipeline(injector, cmd.Context(), "downPipeline")
-		if err != nil {
-			return fmt.Errorf("failed to set up down pipeline: %w", err)
+		if err := proj.Configure(nil); err != nil {
+			return err
 		}
 
-		// Create execution context with flags
-		ctx := cmd.Context()
-		if cleanFlag {
-			ctx = context.WithValue(ctx, "clean", true)
+		if err := proj.Initialize(false); err != nil {
+			if !verbose {
+				return nil
+			}
+			return err
 		}
-		if skipK8sFlag {
-			ctx = context.WithValue(ctx, "skipK8s", true)
+
+		if !skipK8sFlag {
+			if err := proj.Composer.BlueprintHandler.Down(); err != nil {
+				return fmt.Errorf("error running blueprint cleanup: %w", err)
+			}
+		} else {
+			fmt.Fprintln(os.Stderr, "Skipping Kubernetes cleanup (--skip-k8s set)")
 		}
-		if skipTerraformFlag {
-			ctx = context.WithValue(ctx, "skipTerraform", true)
+
+		if !skipTerraformFlag {
+			blueprint := proj.Composer.BlueprintHandler.Generate()
+			if err := proj.Provisioner.Down(blueprint); err != nil {
+				return fmt.Errorf("error tearing down infrastructure: %w", err)
+			}
+		} else {
+			fmt.Fprintln(os.Stderr, "Skipping Terraform cleanup (--skip-tf set)")
 		}
-		if skipDockerFlag {
-			ctx = context.WithValue(ctx, "skipDocker", true)
+
+		if proj.Workstation != nil && !skipDockerFlag {
+			if err := proj.Workstation.Down(); err != nil {
+				return fmt.Errorf("error tearing down workstation: %w", err)
+			}
+		} else if skipDockerFlag {
+			fmt.Fprintln(os.Stderr, "Skipping Docker container cleanup (--skip-docker set)")
 		}
 
-		// Execute the down pipeline
-		if err := downPipeline.Execute(ctx); err != nil {
-			return fmt.Errorf("Error executing down pipeline: %w", err)
+		if cleanFlag {
+			if err := proj.PerformCleanup(); err != nil {
+				return fmt.Errorf("error performing cleanup: %w", err)
+			}
 		}
 
 		return nil