feat(project): add alpha project simulate on the ported crossplane-diff engine

.gitignore

@@ -13,8 +13,8 @@ Zone.Identifier
 build/
 
 # Nix build output symlinks
-result
-result-*
+/result
+/result-*
 
 # Exclude the ko data dir
 kodata/
@@ -48,3 +48,4 @@ AGENTS.md
 
 # Integration test coverage (nix run .#integration-test)
 /coverage-integration.txt
+/coverage-merged.txt

cmd/crossplane/main.go

@@ -122,7 +122,7 @@ func main() {
 	flagVal, err := configFlag(os.Args[1:])
 	if err != nil {
 		fmt.Fprintf(os.Stderr, "crossplane: %v\n", err)
-		os.Exit(exitUsageError)
+		os.Exit(isimulate.ExitCodeUsage)
 	}
 	cfgPath := config.ResolvePath(flagVal)
 
@@ -210,10 +210,6 @@ func exitOnSignal(tty bool) {
 	os.Exit(130)
 }
 
-// exitUsageError is the status kong exits with on a parse error. Kong does
-// not export it, so it is mirrored here for flag errors found before Parse.
-const exitUsageError = 80
-
 // configFlag scans argv for the --config flag and returns its value or "" if
 // the config flag is not present.
 func configFlag(args []string) (string, error) {

cmd/crossplane/project/build.go

@@ -140,7 +140,7 @@ func (c *buildCmd) Run(logger logging.Logger, sp terminal.SpinnerPrinter, cfg *c
 	var imgMap project.ImageTagMap
 	err = sp.WrapAsyncWithSuccessSpinners(func(ch async.EventChannel) error {
 		var buildErr error
-		imgMap, buildErr = b.Build(ctx, c.proj, c.projFS,
+		imgMap, _, buildErr = b.Build(ctx, c.proj, c.projFS,
 			project.BuildWithLogger(logger),
 			project.BuildWithEventChannel(ch),
 		)

cmd/crossplane/project/help/simulate.md

@@ -0,0 +1,44 @@
+The `project simulate` command previews how applying a project's Compositions
+would change the composite resources in a cluster. It renders each affected
+composite resource and shows the difference from what's in the cluster. It
+doesn't change the cluster.
+
+The `-f` flag names the project file, `crossplane-project.yaml` by default. The
+command builds the project's embedded functions and loads them into the local
+Docker daemon, resolves its function dependencies, and collects the
+Compositions under its APIs path. It renders each composite resource that uses
+one of those Compositions with the project's version of the Composition, using
+the project's functions in place of the cluster's functions of the same name.
+`--max-concurrency` caps the concurrent function builds, and `--cache-dir` sets
+where package contents are cached.
+
+The command connects to the cluster in your current Kubernetes context, or the
+one `--context` names.
+
+The command needs Docker, to build and run functions, and read access to the
+cluster's Crossplane resources. It verifies the rendered resources with
+server-side dry-run requests, so it also needs the `create` and `patch` verbs on
+them. Use `--as`, `--as-group`, and `--as-uid` to simulate as another user.
+
+For example, a run with `--skip-plan` whose project changes a Composition
+prints a plan like this:
+
+```
+[~] Composition.apiextensions.crossplane.io xnetworks.example.org (update)
+    Applying this creates a new CompositionRevision, which 1 composite would adopt.
+    spec:
+      pipeline[0]:
+        input:
+          ~ region: "us-west-1" -> "us-east-1"
+
+XR: XNetwork.example.org team-a/prod-network
+  [~] VPC.ec2.aws.upbound.io prod-network (update)
+      spec:
+        forProvider:
+          ~ region: "us-west-1" -> "us-east-1"
+
+Plan: 0 to add, 2 to change, 0 to destroy.
+
+Note: Provider plan skipped (--skip-plan).
+```
+

cmd/crossplane/project/help/simulate_examples.md

@@ -0,0 +1,45 @@
+
+## Examples
+
+Simulate the project in the current directory against the current context:
+
+```shell
+crossplane project simulate
+```
+
+Simulate the project in another directory:
+
+```shell
+crossplane project simulate -f path/to/crossplane-project.yaml
+```
+
+Simulate against another context, only for composite resources in one
+namespace:
+
+```shell
+crossplane project simulate --context=staging -n team-a
+```
+
+Simulate a single namespaced composite resource:
+
+```shell
+crossplane project simulate -n team-a --name=my-database
+```
+
+Simulate two composite resources in different namespaces:
+
+```shell
+crossplane project simulate --name=team-a/my-database --name=team-b/my-database
+```
+
+Print the plan as JSON:
+
+```shell
+crossplane project simulate -o json
+```
+
+Print a line diff of each changed resource:
+
+```shell
+crossplane project simulate -o diff
+```

cmd/crossplane/project/integration_main_test.go

@@ -0,0 +1,23 @@
+//go:build integration
+
+package project
+
+import (
+	"fmt"
+	"os"
+	"testing"
+
+	"github.com/crossplane/cli/v2/internal/testutils/integration"
+)
+
+// TestMain runs before all tests.
+func TestMain(m *testing.M) {
+	// Kill envtest servers that an earlier run left behind when it died abnormally.
+	integration.ReapOrphanedEnvtest(func(format string, args ...any) { fmt.Fprintf(os.Stderr, format+"\n", args...) })
+
+	// Run all tests
+	exitCode := m.Run()
+
+	// Exit with the test suite's exit code
+	os.Exit(exitCode)
+}