feat: Enhance schema generation and dependency handling

apis/dev/v1alpha1/project_types.go

@@ -136,6 +136,13 @@ type ProjectSchemas struct {
 	// Supported values are "go", "json", "kcl", and "python". If not
 	// specified, schemas are generated for all supported languages.
 	Languages []string `json:"languages,omitempty"`
+
+	// APIGroups restricts schema generation to resources whose API group
+	// matches one of the listed globs, e.g. "*.aws.upbound.io" or
+	// "kubernetes.crossplane.io". Use it to avoid generating thousands of files
+	// for provider APIs the project never uses. If not specified, schemas are
+	// generated for all API groups.
+	APIGroups []string `json:"apiGroups,omitempty"`
 }
 
 // GetLanguages returns the configured schema languages, or nil if no Schemas
@@ -147,6 +154,15 @@ func (s *ProjectSchemas) GetLanguages() []string {
 	return s.Languages
 }
 
+// GetAPIGroups returns the configured API group globs, or nil if no Schemas
+// config is set. It is safe to call on a nil receiver.
+func (s *ProjectSchemas) GetAPIGroups() []string {
+	if s == nil {
+		return nil
+	}
+	return s.APIGroups
+}
+
 // ProjectPaths configures the locations of various parts of the project, for
 // use at build time. All paths must be relative to the project root.
 type ProjectPaths struct {

apis/dev/v1alpha1/validate.go

@@ -18,6 +18,7 @@ package v1alpha1
 
 import (
 	"fmt"
+	"path"
 	"path/filepath"
 	"slices"
 	"strings"
@@ -109,6 +110,20 @@ func (s *ProjectSchemas) Validate() []error {
 	if s == nil {
 		return nil
 	}
+	errs := s.validateLanguages()
+	for i, glob := range s.APIGroups {
+		if glob == "" {
+			errs = append(errs, errors.Errorf("schemas.apiGroups[%d]: glob must not be empty", i))
+			continue
+		}
+		if _, err := path.Match(glob, ""); err != nil {
+			errs = append(errs, errors.Wrapf(err, "schemas.apiGroups[%d]: %q is not a valid glob", i, glob))
+		}
+	}
+	return errs
+}
+
+func (s *ProjectSchemas) validateLanguages() []error {
 	if s.Languages == nil {
 		return nil
 	}

apis/dev/v1alpha1/validate_test.go

@@ -185,6 +185,51 @@ func TestValidate(t *testing.T) {
 				`schemas.languages[1]: "fortran" is not a supported schema language`,
 			},
 		},
+		"ValidAPIGroupGlobs": {
+			input: &Project{
+				ObjectMeta: metav1.ObjectMeta{
+					Name: "my-project",
+				},
+				Spec: ProjectSpec{
+					Repository: "xpkg.upbound.io/acmeco/my-project",
+					Schemas: &ProjectSchemas{
+						APIGroups: []string{"*.m.upbound.io", "kubernetes.crossplane.io"},
+					},
+				},
+			},
+		},
+		"EmptyAPIGroupGlob": {
+			input: &Project{
+				ObjectMeta: metav1.ObjectMeta{
+					Name: "my-project",
+				},
+				Spec: ProjectSpec{
+					Repository: "xpkg.upbound.io/acmeco/my-project",
+					Schemas: &ProjectSchemas{
+						APIGroups: []string{""},
+					},
+				},
+			},
+			expectedErrors: []string{
+				"schemas.apiGroups[0]: glob must not be empty",
+			},
+		},
+		"MalformedAPIGroupGlob": {
+			input: &Project{
+				ObjectMeta: metav1.ObjectMeta{
+					Name: "my-project",
+				},
+				Spec: ProjectSpec{
+					Repository: "xpkg.upbound.io/acmeco/my-project",
+					Schemas: &ProjectSchemas{
+						APIGroups: []string{"*.aws.upbound.io", "[a-"},
+					},
+				},
+			},
+			expectedErrors: []string{
+				`schemas.apiGroups[1]: "[a-" is not a valid glob`,
+			},
+		},
 		"ValidAPIDependency": {
 			input: &Project{
 				ObjectMeta: metav1.ObjectMeta{

cmd/crossplane/composition/generate.go

@@ -36,12 +36,9 @@ import (
 	pkgv1 "github.com/crossplane/crossplane/apis/v2/pkg/v1"
 
 	"github.com/crossplane/cli/v2/apis/dev/v1alpha1"
-	"github.com/crossplane/cli/v2/internal/config"
 	"github.com/crossplane/cli/v2/internal/dependency"
 	"github.com/crossplane/cli/v2/internal/project/projectfile"
-	"github.com/crossplane/cli/v2/internal/schemas/generator"
 	"github.com/crossplane/cli/v2/internal/terminal"
-	clixpkg "github.com/crossplane/cli/v2/internal/xpkg"
 
 	_ "embed"
 )
@@ -73,49 +70,17 @@ func (c *generateCmd) Help() string {
 }
 
 // AfterApply sets up the project filesystem.
-func (c *generateCmd) AfterApply(cfg *config.Config) error {
-	projFilePath, err := filepath.Abs(c.ProjectFile)
-	if err != nil {
-		return err
-	}
-	projDirPath := filepath.Dir(projFilePath)
-	c.projFS = afero.NewBasePathFs(afero.NewOsFs(), projDirPath)
-
-	proj, err := projectfile.Parse(c.projFS, filepath.Base(c.ProjectFile))
+func (c *generateCmd) AfterApply() error {
+	proj, projFS, err := projectfile.Load(c.ProjectFile)
 	if err != nil {
 		return err
 	}
 
+	c.projFS = projFS
 	c.proj = proj
 	c.apisFS = afero.NewBasePathFs(c.projFS, proj.Spec.Paths.APIs)
-	cacheDir := c.CacheDir
-	if cacheDir == "" {
-		cacheDir = dependency.DefaultCacheDir()
-	}
-
-	client, err := clixpkg.NewClient(
-		clixpkg.NewRemoteFetcher(),
-		clixpkg.WithCacheDir(afero.NewOsFs(), cacheDir),
-		clixpkg.WithImageConfigs(proj.Spec.ImageConfigs),
-	)
-	if err != nil {
-		return err
-	}
-	resolver := clixpkg.NewResolver(client)
-
-	c.depManager = dependency.NewManager(proj, c.projFS,
-		dependency.WithProjectFile(filepath.Base(c.ProjectFile)),
-		dependency.WithSchemaGenerators(generator.Filter(
-			generator.AllLanguages(
-				generator.WithGoModelAccessors(cfg.Features.GenerateGoModelAccessors),
-				generator.WithGoRuntimeObjects(cfg.Features.GenerateGoRuntimeObjects),
-			),
-			proj.Spec.Schemas.GetLanguages(),
-		)),
-		dependency.WithXpkgClient(client),
-		dependency.WithResolver(resolver),
-	)
-	return nil
+	c.depManager, err = dependency.NewCachedManager(proj, c.projFS, c.ProjectFile, c.CacheDir)
+	return err
 }
 
 func (c *generateCmd) Run(sp terminal.SpinnerPrinter) error {

cmd/crossplane/dependency/add.go

@@ -18,22 +18,18 @@ package dependency
 
 import (
 	"context"
-	"path/filepath"
 	"strings"
 
 	"github.com/google/go-containerregistry/pkg/name"
-	"github.com/spf13/afero"
 
 	"github.com/crossplane/crossplane-runtime/v2/pkg/errors"
 	"github.com/crossplane/crossplane-runtime/v2/pkg/logging"
 
 	"github.com/crossplane/cli/v2/apis/dev/v1alpha1"
-	"github.com/crossplane/cli/v2/internal/config"
 	"github.com/crossplane/cli/v2/internal/dependency"
+	"github.com/crossplane/cli/v2/internal/git"
 	"github.com/crossplane/cli/v2/internal/project/projectfile"
-	"github.com/crossplane/cli/v2/internal/schemas/generator"
 	"github.com/crossplane/cli/v2/internal/terminal"
-	clixpkg "github.com/crossplane/cli/v2/internal/xpkg"
 
 	_ "embed"
 )
@@ -43,6 +39,8 @@ var addHelp string
 
 // addCmd adds a dependency to the current project.
 type addCmd struct {
+	git.HTTPSAuthFlags `embed:""`
+
 	Package     string `arg:""                      help:"Package to add (xpkg OCI reference, k8s:<version>, git repository URL, or HTTP(S) URL)."`
 	ProjectFile string `default:"${project_file}"   help:"Path to project definition file."                                                        short:"f"`
 	CacheDir    string `env:"CROSSPLANE_XPKG_CACHE" help:"Directory for cached xpkg package contents."                                             name:"cache-dir"`
@@ -58,48 +56,20 @@ func (c *addCmd) Help() string {
 }
 
 // Run executes the add command.
-func (c *addCmd) Run(logger logging.Logger, sp terminal.SpinnerPrinter, cfg *config.Config) error {
+func (c *addCmd) Run(logger logging.Logger, sp terminal.SpinnerPrinter) error {
 	ctx := context.Background()
 
-	projFilePath, err := filepath.Abs(c.ProjectFile)
-	if err != nil {
-		return err
-	}
-	projDirPath := filepath.Dir(projFilePath)
-	projFS := afero.NewBasePathFs(afero.NewOsFs(), projDirPath)
-
-	proj, err := projectfile.Parse(projFS, filepath.Base(c.ProjectFile))
+	proj, projFS, err := projectfile.Load(c.ProjectFile)
 	if err != nil {
 		return err
 	}
 
-	cacheDir := c.CacheDir
-	if cacheDir == "" {
-		cacheDir = dependency.DefaultCacheDir()
-	}
-
-	client, err := clixpkg.NewClient(
-		clixpkg.NewRemoteFetcher(),
-		clixpkg.WithCacheDir(afero.NewOsFs(), cacheDir),
-		clixpkg.WithImageConfigs(proj.Spec.ImageConfigs),
+	m, err := dependency.NewCachedManager(proj, projFS, c.ProjectFile, c.CacheDir,
+		dependency.WithGitAuthProvider(c.AuthProvider()),
 	)
 	if err != nil {
 		return err
 	}
-	resolver := clixpkg.NewResolver(client)
-
-	m := dependency.NewManager(proj, projFS,
-		dependency.WithProjectFile(c.ProjectFile),
-		dependency.WithSchemaGenerators(generator.Filter(
-			generator.AllLanguages(
-				generator.WithGoModelAccessors(cfg.Features.GenerateGoModelAccessors),
-				generator.WithGoRuntimeObjects(cfg.Features.GenerateGoRuntimeObjects),
-			),
-			proj.Spec.Schemas.GetLanguages(),
-		)),
-		dependency.WithXpkgClient(client),
-		dependency.WithResolver(resolver),
-	)
 
 	dep, err := c.buildDependency()
 	if err != nil {

cmd/crossplane/dependency/add_test.go

@@ -0,0 +1,80 @@
+/*
+Copyright 2026 The Crossplane Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package dependency
+
+import (
+	"testing"
+
+	"github.com/alecthomas/kong"
+	"github.com/google/go-cmp/cmp"
+
+	"github.com/crossplane/cli/v2/internal/git"
+)
+
+func TestAddGitAuth(t *testing.T) {
+	type args struct {
+		cmd []string
+		env map[string]string
+	}
+	type want struct {
+		auth git.AuthProvider
+	}
+
+	cases := map[string]struct {
+		reason string
+		args   args
+		want   want
+	}{
+		"Defaults": {
+			reason: "Without flags the username defaults to x-access-token and there is no token.",
+			args:   args{cmd: []string{"add", "pkg"}},
+			want:   want{auth: &git.HTTPSAuthProvider{Username: "x-access-token"}},
+		},
+		"Flags": {
+			reason: "The git flags configure the auth provider.",
+			args:   args{cmd: []string{"add", "pkg", "--git-token", "t", "--git-username", "u"}},
+			want:   want{auth: &git.HTTPSAuthProvider{Username: "u", Password: "t"}},
+		},
+		"Env": {
+			reason: "The git environment variables configure the auth provider.",
+			args: args{
+				cmd: []string{"add", "pkg"},
+				env: map[string]string{"CROSSPLANE_GIT_TOKEN": "t", "CROSSPLANE_GIT_USERNAME": "u"},
+			},
+			want: want{auth: &git.HTTPSAuthProvider{Username: "u", Password: "t"}},
+		},
+	}
+
+	for name, tc := range cases {
+		t.Run(name, func(t *testing.T) {
+			var c Cmd
+			parser, err := kong.New(&c, kong.Vars{"project_file": "crossplane-project.yaml"})
+			if err != nil {
+				t.Fatalf("kong.New(): %v", err)
+			}
+			for k, v := range tc.args.env {
+				t.Setenv(k, v)
+			}
+			if _, err := parser.Parse(tc.args.cmd); err != nil {
+				t.Fatalf("%s\nParse(%v): %v", tc.reason, tc.args.cmd, err)
+			}
+			if diff := cmp.Diff(tc.want.auth, c.Add.AuthProvider()); diff != "" {
+				t.Errorf("%s\nAuthProvider(): -want, +got:\n%s", tc.reason, diff)
+			}
+		})
+	}
+}