feat: use plugin manifest (#4469)

## Changes
<!-- Brief summary of your changes that is easy to understand -->

- Replace the hardcoded features package with a manifest-driven system
that reads appkit.plugins.json from templates, enabling templates to
declaratively define their plugins, resources, and dependencies without
CLI code changes
- Add Helm-style --set flag (--set plugin.resourceKey.field=value) for
non-interactive resource configuration, replacing the static
--warehouse-id flag
- Introduce interactive resource pickers for all 11 resource types (SQL
warehouses, jobs, serving endpoints, secrets, databases, genie spaces,
volumes, UC functions, UC connections, vector search indexes,
experiments) with multi-step pickers for hierarchical resources (catalog
→ schema → volume/function, instance → database, scope → key) and
back-navigation support

## Key design decisions
- **resourceKey** is the unique identifier — not type. This allows
multiple resources of the same type per plugin (e.g., two genie spaces
with different keys)
- **appResourceSpecs** data-driven map — Centralizes the mapping from
manifest resource types to DABs YAML structure, eliminating per-type
switch statements
- Templates without appkit.plugins.json work gracefully — The app is
created normally, just without resource configuration
- **app** resource type is filtered out at runtime (with TODOs) until
DABs supports it as an app resource

---------

Co-authored-by: MarioCadenas <MarioCadenas@users.noreply.github.com>

Author: MarioCadenas

cmd/apps/init.go

@@ -1,9 +1,11 @@
 package apps
 
 import (
+	"context"
 	"errors"
 	"testing"
 
+	"github.com/databricks/cli/libs/apps/manifest"
 	"github.com/databricks/cli/libs/apps/prompt"
 	"github.com/spf13/cobra"
 	"github.com/stretchr/testify/assert"
@@ -64,15 +66,15 @@ func TestIsTextFile(t *testing.T) {
 	}
 }
 
-func TestSubstituteVars(t *testing.T) {
+func TestExecuteTemplate(t *testing.T) {
+	ctx := context.Background()
 	vars := templateVars{
 		ProjectName:    "my-app",
-		SQLWarehouseID: "warehouse123",
 		AppDescription: "My awesome app",
 		Profile:        "default",
 		WorkspaceHost:  "https://dbc-123.cloud.databricks.com",
-		PluginImport:   "analytics",
-		PluginUsage:    "analytics()",
+		PluginImports:  "analytics",
+		PluginUsages:   "analytics()",
 	}
 
 	tests := []struct {
@@ -85,11 +87,6 @@ func TestSubstituteVars(t *testing.T) {
 			input:    "name: {{.project_name}}",
 			expected: "name: my-app",
 		},
-		{
-			name:     "warehouse id substitution",
-			input:    "warehouse: {{.sql_warehouse_id}}",
-			expected: "warehouse: warehouse123",
-		},
 		{
 			name:     "description substitution",
 			input:    "description: {{.app_description}}",
@@ -102,17 +99,17 @@ func TestSubstituteVars(t *testing.T) {
 		},
 		{
 			name:     "workspace host substitution",
-			input:    "host: {{workspace_host}}",
+			input:    "host: {{.workspace_host}}",
 			expected: "host: https://dbc-123.cloud.databricks.com",
 		},
 		{
 			name:     "plugin import substitution",
-			input:    "import { {{.plugin_import}} } from 'appkit'",
+			input:    "import { {{.plugin_imports}} } from 'appkit'",
 			expected: "import { analytics } from 'appkit'",
 		},
 		{
 			name:     "plugin usage substitution",
-			input:    "plugins: [{{.plugin_usage}}]",
+			input:    "plugins: [{{.plugin_usages}}]",
 			expected: "plugins: [analytics()]",
 		},
 		{
@@ -129,22 +126,20 @@ func TestSubstituteVars(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			result := substituteVars(tt.input, vars)
-			assert.Equal(t, tt.expected, result)
+			result, err := executeTemplate(ctx, "test.txt", []byte(tt.input), vars)
+			require.NoError(t, err)
+			assert.Equal(t, tt.expected, string(result))
 		})
 	}
 }
 
-func TestSubstituteVarsNoPlugins(t *testing.T) {
-	// Test plugin cleanup when no plugins are selected
+func TestExecuteTemplateEmptyPlugins(t *testing.T) {
+	ctx := context.Background()
 	vars := templateVars{
 		ProjectName:    "my-app",
-		SQLWarehouseID: "",
 		AppDescription: "My app",
-		Profile:        "",
-		WorkspaceHost:  "",
-		PluginImport:   "", // No plugins
-		PluginUsage:    "",
+		PluginImports:  "",
+		PluginUsages:   "",
 	}
 
 	tests := []struct {
@@ -153,25 +148,35 @@ func TestSubstituteVarsNoPlugins(t *testing.T) {
 		expected string
 	}{
 		{
-			name:     "removes plugin import with comma",
-			input:    "import { core, {{.plugin_import}} } from 'appkit'",
+			name:     "empty plugin imports render as empty",
+			input:    "import { core{{if .plugin_imports}}, {{.plugin_imports}}{{end}} } from 'appkit'",
 			expected: "import { core } from 'appkit'",
 		},
 		{
-			name:     "removes plugin usage line",
-			input:    "plugins: [\n    {{.plugin_usage}},\n]",
-			expected: "plugins: [\n]",
+			name:     "empty plugin usages render as empty",
+			input:    "plugins: [{{if .plugin_usages}}\n    {{.plugin_usages}},\n{{end}}]",
+			expected: "plugins: []",
 		},
 	}
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			result := substituteVars(tt.input, vars)
-			assert.Equal(t, tt.expected, result)
+			result, err := executeTemplate(ctx, "test.txt", []byte(tt.input), vars)
+			require.NoError(t, err)
+			assert.Equal(t, tt.expected, string(result))
 		})
 	}
 }
 
+func TestExecuteTemplateInvalidSyntaxReturnsOriginal(t *testing.T) {
+	ctx := context.Background()
+	vars := templateVars{ProjectName: "my-app"}
+	input := "some content with bad {{ syntax"
+	result, err := executeTemplate(ctx, "test.js", []byte(input), vars)
+	require.NoError(t, err)
+	assert.Equal(t, input, string(result))
+}
+
 func TestInitCmdBranchAndVersionMutuallyExclusive(t *testing.T) {
 	cmd := newInitCmd()
 	cmd.PreRunE = nil // skip workspace client setup for flag validation test
@@ -283,3 +288,168 @@ func TestParseDeployAndRunFlags(t *testing.T) {
 		})
 	}
 }
+
+// testManifest returns a manifest with an "analytics" plugin for testing parseSetValues.
+func testManifest() *manifest.Manifest {
+	return &manifest.Manifest{
+		Plugins: map[string]manifest.Plugin{
+			"analytics": {
+				Name: "analytics",
+				Resources: manifest.Resources{
+					Required: []manifest.Resource{
+						{
+							Type:        "sql_warehouse",
+							Alias:       "SQL Warehouse",
+							ResourceKey: "sql-warehouse",
+							Fields:      map[string]manifest.ResourceField{"id": {Env: "WH_ID"}},
+						},
+					},
+					Optional: []manifest.Resource{
+						{
+							Type:        "database",
+							Alias:       "Database",
+							ResourceKey: "database",
+							Fields: map[string]manifest.ResourceField{
+								"instance_name": {Env: "DB_INST"},
+								"database_name": {Env: "DB_NAME"},
+							},
+						},
+						{
+							Type:        "secret",
+							Alias:       "Secret",
+							ResourceKey: "secret",
+							Fields: map[string]manifest.ResourceField{
+								"scope": {Env: "SECRET_SCOPE"},
+								"key":   {Env: "SECRET_KEY"},
+							},
+						},
+					},
+				},
+			},
+		},
+	}
+}
+
+func TestParseSetValues(t *testing.T) {
+	m := testManifest()
+
+	tests := []struct {
+		name      string
+		setValues []string
+		wantRV    map[string]string
+		wantErr   string
+	}{
+		{
+			name:      "single field",
+			setValues: []string{"analytics.sql-warehouse.id=abc123"},
+			wantRV:    map[string]string{"sql-warehouse.id": "abc123"},
+		},
+		{
+			name:      "multi-field complete",
+			setValues: []string{"analytics.database.instance_name=inst", "analytics.database.database_name=mydb"},
+			wantRV:    map[string]string{"database.instance_name": "inst", "database.database_name": "mydb"},
+		},
+		{
+			name:      "later set overrides earlier",
+			setValues: []string{"analytics.sql-warehouse.id=first", "analytics.sql-warehouse.id=second"},
+			wantRV:    map[string]string{"sql-warehouse.id": "second"},
+		},
+		{
+			name:      "empty set values",
+			setValues: nil,
+			wantRV:    map[string]string{},
+		},
+		{
+			name:      "missing equals sign",
+			setValues: []string{"analytics.sql-warehouse.id"},
+			wantErr:   "invalid --set format",
+		},
+		{
+			name:      "too few key parts",
+			setValues: []string{"sql-warehouse.id=abc"},
+			wantErr:   "invalid --set key",
+		},
+		{
+			name:      "unknown plugin",
+			setValues: []string{"nosuch.sql-warehouse.id=abc"},
+			wantErr:   `unknown plugin "nosuch"`,
+		},
+		{
+			name:      "unknown resource key",
+			setValues: []string{"analytics.nosuch.id=abc"},
+			wantErr:   `has no resource with key "nosuch"`,
+		},
+		{
+			name:      "unknown field",
+			setValues: []string{"analytics.sql-warehouse.nosuch=abc"},
+			wantErr:   `field "nosuch"`,
+		},
+		{
+			name:      "multi-field incomplete database",
+			setValues: []string{"analytics.database.instance_name=inst"},
+			wantErr:   `incomplete resource "database"`,
+		},
+		{
+			name:      "multi-field incomplete secret",
+			setValues: []string{"analytics.secret.scope=myscope"},
+			wantErr:   `incomplete resource "secret"`,
+		},
+		{
+			name: "all fields together",
+			setValues: []string{
+				"analytics.sql-warehouse.id=wh1",
+				"analytics.database.instance_name=inst",
+				"analytics.database.database_name=mydb",
+				"analytics.secret.scope=s",
+				"analytics.secret.key=k",
+			},
+			wantRV: map[string]string{
+				"sql-warehouse.id":       "wh1",
+				"database.instance_name": "inst",
+				"database.database_name": "mydb",
+				"secret.scope":           "s",
+				"secret.key":             "k",
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			rv, err := parseSetValues(tt.setValues, m)
+			if tt.wantErr != "" {
+				require.Error(t, err)
+				assert.Contains(t, err.Error(), tt.wantErr)
+			} else {
+				require.NoError(t, err)
+				assert.Equal(t, tt.wantRV, rv)
+			}
+		})
+	}
+}
+
+func TestPluginHasResourceField(t *testing.T) {
+	m := testManifest()
+	p := m.GetPluginByName("analytics")
+	require.NotNil(t, p)
+
+	assert.True(t, pluginHasResourceField(p, "sql-warehouse", "id"))
+	assert.True(t, pluginHasResourceField(p, "database", "instance_name"))
+	assert.True(t, pluginHasResourceField(p, "secret", "scope"))
+	assert.False(t, pluginHasResourceField(p, "sql-warehouse", "nosuch"))
+	assert.False(t, pluginHasResourceField(p, "nosuch", "id"))
+}
+
+func TestAppendUnique(t *testing.T) {
+	result := appendUnique([]string{"a", "b"}, "b", "c", "a", "d")
+	assert.Equal(t, []string{"a", "b", "c", "d"}, result)
+}
+
+func TestAppendUniqueEmptyBase(t *testing.T) {
+	result := appendUnique(nil, "x", "y", "x")
+	assert.Equal(t, []string{"x", "y"}, result)
+}
+
+func TestAppendUniqueNoValues(t *testing.T) {
+	result := appendUnique([]string{"a", "b"})
+	assert.Equal(t, []string{"a", "b"}, result)
+}