[2/5] Aitools: install writes state, interactive agent selection, idempotent install (#4811)

## PR Stack

1. [1/5] State + release discovery + directory rename (#4810)
2. **[2/5] Install writes state + interactive agent selection** (this
PR)
3. [3/5] Update + uninstall + version commands (#4812)
4. [4/5] List improvements + command restructuring + flags (#4813)
5. [5/5] Project scope (--project/--global) (pending)

**Base**: `simonfaltum/aitools-pr1-state` (PR 1)

## Why

Install currently has no state tracking, no filtering, and outputs every
file download to the console. Users can't tell what version they have,
and there's no way to install for specific agents.

## Changes

Before: `skills install` downloads everything, prints every file, has no
state, no filtering, no agent selection.

Now:
- `InstallSkillsForAgents(ctx, src, agents, opts)` as the core install
function. `InstallAllSkills` becomes a thin wrapper (signature preserved
for `cmd/apps/init.go` compat).
- State written to `.state.json` after successful install. Merges with
existing state (doesn't overwrite).
- Idempotent: second install skips already-present skills with matching
versions.
- Experimental filtering: skip `experimental: true` skills by default.
- `min_cli_version` enforcement: skip incompatible skills with warning
(hard error for single-skill install).
- Interactive agent selection via `charmbracelet/huh` multi-select. Skip
prompt for 1 agent, all detected for non-interactive.
- Legacy install detection: prints "reinstall" message when old install
found without state.
- Concise default output (2 lines). Per-file detail only at debug level.

## Test plan

- [x] State created after install-all and install-single
- [x] Experimental filtering (skip by default, include with flag)
- [x] min_cli_version: warning for all, hard error for single
- [x] Idempotent: skip same version, update changed
- [x] Legacy detection with helpful message
- [x] Interactive prompt for 2+ agents, skip for 1
- [x] Non-interactive: all detected, no prompt
- [x] `InstallAllSkills` signature preserved
- [x] Concise output, per-file at debug level

Author: simonfaltum

experimental/aitools/cmd/install.go

@@ -5,14 +5,19 @@ import (
 )
 
 func newInstallCmd() *cobra.Command {
-	return &cobra.Command{
+	var includeExperimental bool
+
+	cmd := &cobra.Command{
 		Use:   "install [skill-name]",
 		Short: "Alias for skills install",
 		Long: `Alias for "databricks experimental aitools skills install".
 
 Installs Databricks skills for detected coding agents.`,
 		RunE: func(cmd *cobra.Command, args []string) error {
-			return runSkillsInstall(cmd.Context(), args)
+			return runSkillsInstall(cmd.Context(), args, includeExperimental)
 		},
 	}
+
+	cmd.Flags().BoolVar(&includeExperimental, "experimental", false, "Include experimental skills")
+	return cmd
 }

experimental/aitools/cmd/install_test.go

@@ -1,75 +1,199 @@
 package aitools
 
 import (
+	"bufio"
 	"context"
+	"os"
+	"path/filepath"
 	"testing"
 
+	"github.com/databricks/cli/experimental/aitools/lib/agents"
+	"github.com/databricks/cli/experimental/aitools/lib/installer"
+	"github.com/databricks/cli/libs/cmdio"
 	"github.com/spf13/cobra"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
 
+func setupInstallMock(t *testing.T) *[]installCall {
+	t.Helper()
+	orig := installSkillsForAgentsFn
+	t.Cleanup(func() { installSkillsForAgentsFn = orig })
+
+	var calls []installCall
+	installSkillsForAgentsFn = func(_ context.Context, _ installer.ManifestSource, targetAgents []*agents.Agent, opts installer.InstallOptions) error {
+		names := make([]string, len(targetAgents))
+		for i, a := range targetAgents {
+			names[i] = a.Name
+		}
+		calls = append(calls, installCall{agents: names, opts: opts})
+		return nil
+	}
+	return &calls
+}
+
+type installCall struct {
+	agents []string
+	opts   installer.InstallOptions
+}
+
+func setupTestAgents(t *testing.T) string {
+	t.Helper()
+	tmp := t.TempDir()
+	t.Setenv("HOME", tmp)
+	// Create config dirs for two agents.
+	require.NoError(t, os.MkdirAll(filepath.Join(tmp, ".claude"), 0o755))
+	require.NoError(t, os.MkdirAll(filepath.Join(tmp, ".cursor"), 0o755))
+	return tmp
+}
+
 func TestInstallCommandsDelegateToSkillsInstall(t *testing.T) {
-	originalInstallAllSkills := installAllSkills
-	originalInstallSkill := installSkill
-	t.Cleanup(func() {
-		installAllSkills = originalInstallAllSkills
-		installSkill = originalInstallSkill
-	})
+	setupTestAgents(t)
+	calls := setupInstallMock(t)
 
 	tests := []struct {
-		name           string
-		newCmd         func() *cobra.Command
-		args           []string
-		wantAllCalls   int
-		wantSkillCalls []string
+		name             string
+		newCmd           func() *cobra.Command
+		args             []string
+		flags            []string
+		wantAgents       int
+		wantSkills       []string
+		wantExperimental bool
 	}{
 		{
-			name:         "skills install installs all skills",
-			newCmd:       newSkillsInstallCmd,
-			wantAllCalls: 1,
+			name:       "skills install installs all skills for all agents",
+			newCmd:     newSkillsInstallCmd,
+			wantAgents: 2,
+		},
+		{
+			name:       "skills install forwards skill name",
+			newCmd:     newSkillsInstallCmd,
+			args:       []string{"bundle/review"},
+			wantAgents: 2,
+			wantSkills: []string{"bundle/review"},
 		},
 		{
-			name:           "skills install forwards skill name",
-			newCmd:         newSkillsInstallCmd,
-			args:           []string{"bundle/review"},
-			wantSkillCalls: []string{"bundle/review"},
+			name:             "skills install with --experimental",
+			newCmd:           newSkillsInstallCmd,
+			flags:            []string{"--experimental"},
+			wantAgents:       2,
+			wantExperimental: true,
 		},
 		{
-			name:         "top level install installs all skills",
-			newCmd:       newInstallCmd,
-			wantAllCalls: 1,
+			name:       "top level install installs all skills",
+			newCmd:     newInstallCmd,
+			wantAgents: 2,
 		},
 		{
-			name:           "top level install forwards skill name",
-			newCmd:         newInstallCmd,
-			args:           []string{"bundle/review"},
-			wantSkillCalls: []string{"bundle/review"},
+			name:       "top level install forwards skill name",
+			newCmd:     newInstallCmd,
+			args:       []string{"bundle/review"},
+			wantAgents: 2,
+			wantSkills: []string{"bundle/review"},
+		},
+		{
+			name:             "top level install with --experimental",
+			newCmd:           newInstallCmd,
+			flags:            []string{"--experimental"},
+			wantAgents:       2,
+			wantExperimental: true,
 		},
 	}
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			allCalls := 0
-			var skillCalls []string
-
-			installAllSkills = func(context.Context) error {
-				allCalls++
-				return nil
-			}
-			installSkill = func(_ context.Context, skillName string) error {
-				skillCalls = append(skillCalls, skillName)
-				return nil
-			}
+			*calls = nil
 
+			ctx := cmdio.MockDiscard(t.Context())
 			cmd := tt.newCmd()
-			cmd.SetContext(t.Context())
+			cmd.SetContext(ctx)
+			if len(tt.flags) > 0 {
+				require.NoError(t, cmd.ParseFlags(tt.flags))
+			}
 
 			err := cmd.RunE(cmd, tt.args)
 			require.NoError(t, err)
 
-			assert.Equal(t, tt.wantAllCalls, allCalls)
-			assert.Equal(t, tt.wantSkillCalls, skillCalls)
+			require.Len(t, *calls, 1)
+			assert.Len(t, (*calls)[0].agents, tt.wantAgents)
+			assert.Equal(t, tt.wantSkills, (*calls)[0].opts.SpecificSkills)
+			assert.Equal(t, tt.wantExperimental, (*calls)[0].opts.IncludeExperimental)
 		})
 	}
 }
+
+func TestRunSkillsInstallInteractivePrompt(t *testing.T) {
+	setupTestAgents(t)
+	calls := setupInstallMock(t)
+
+	origPrompt := promptAgentSelection
+	t.Cleanup(func() { promptAgentSelection = origPrompt })
+
+	promptCalled := false
+	promptAgentSelection = func(_ context.Context, detected []*agents.Agent) ([]*agents.Agent, error) {
+		promptCalled = true
+		// Return only the first agent.
+		return detected[:1], nil
+	}
+
+	// Use SetupTest with PromptSupported=true to simulate interactive terminal.
+	ctx, test := cmdio.SetupTest(t.Context(), cmdio.TestOptions{PromptSupported: true})
+	defer test.Done()
+
+	// Drain both pipes in background to prevent blocking.
+	drain := func(r *bufio.Reader) {
+		buf := make([]byte, 4096)
+		for {
+			_, err := r.Read(buf)
+			if err != nil {
+				return
+			}
+		}
+	}
+	go drain(test.Stdout)
+	go drain(test.Stderr)
+
+	err := runSkillsInstall(ctx, nil, false)
+	require.NoError(t, err)
+
+	assert.True(t, promptCalled, "prompt should be called when 2+ agents detected and interactive")
+	require.Len(t, *calls, 1)
+	assert.Len(t, (*calls)[0].agents, 1, "only the selected agent should be passed")
+}
+
+func TestRunSkillsInstallNonInteractiveUsesAllAgents(t *testing.T) {
+	setupTestAgents(t)
+	calls := setupInstallMock(t)
+
+	origPrompt := promptAgentSelection
+	t.Cleanup(func() { promptAgentSelection = origPrompt })
+
+	promptCalled := false
+	promptAgentSelection = func(_ context.Context, detected []*agents.Agent) ([]*agents.Agent, error) {
+		promptCalled = true
+		return detected, nil
+	}
+
+	// MockDiscard gives a non-interactive context.
+	ctx := cmdio.MockDiscard(t.Context())
+
+	err := runSkillsInstall(ctx, nil, false)
+	require.NoError(t, err)
+
+	assert.False(t, promptCalled, "prompt should not be called in non-interactive mode")
+	require.Len(t, *calls, 1)
+	assert.Len(t, (*calls)[0].agents, 2, "all detected agents should be used")
+}
+
+func TestRunSkillsInstallNoAgents(t *testing.T) {
+	// Set HOME to empty dir so no agents are detected.
+	tmp := t.TempDir()
+	t.Setenv("HOME", tmp)
+
+	calls := setupInstallMock(t)
+	ctx := cmdio.MockDiscard(t.Context())
+
+	err := runSkillsInstall(ctx, nil, false)
+	require.NoError(t, err)
+	assert.Empty(t, *calls, "install should not be called when no agents detected")
+}

experimental/aitools/cmd/skills.go

@@ -2,16 +2,52 @@ package aitools
 
 import (
 	"context"
+	"errors"
 
+	"github.com/charmbracelet/huh"
+	"github.com/databricks/cli/experimental/aitools/lib/agents"
 	"github.com/databricks/cli/experimental/aitools/lib/installer"
+	"github.com/databricks/cli/libs/cmdio"
+	"github.com/fatih/color"
 	"github.com/spf13/cobra"
 )
 
+// Package-level vars for testability.
 var (
-	installAllSkills = installer.InstallAllSkills
-	installSkill     = installer.InstallSkill
+	promptAgentSelection     = defaultPromptAgentSelection
+	installSkillsForAgentsFn = installer.InstallSkillsForAgents
 )
 
+func defaultPromptAgentSelection(ctx context.Context, detected []*agents.Agent) ([]*agents.Agent, error) {
+	options := make([]huh.Option[string], 0, len(detected))
+	agentsByName := make(map[string]*agents.Agent, len(detected))
+	for _, a := range detected {
+		options = append(options, huh.NewOption(a.DisplayName, a.Name).Selected(true))
+		agentsByName[a.Name] = a
+	}
+
+	var selected []string
+	err := huh.NewMultiSelect[string]().
+		Title("Select coding agents to install skills for").
+		Description("space to toggle, enter to confirm").
+		Options(options...).
+		Value(&selected).
+		Run()
+	if err != nil {
+		return nil, err
+	}
+
+	if len(selected) == 0 {
+		return nil, errors.New("at least one agent must be selected")
+	}
+
+	result := make([]*agents.Agent, 0, len(selected))
+	for _, name := range selected {
+		result = append(result, agentsByName[name])
+	}
+	return result, nil
+}
+
 func newSkillsCmd() *cobra.Command {
 	cmd := &cobra.Command{
 		Use:   "skills",
@@ -36,7 +72,9 @@ func newSkillsListCmd() *cobra.Command {
 }
 
 func newSkillsInstallCmd() *cobra.Command {
-	return &cobra.Command{
+	var includeExperimental bool
+
+	cmd := &cobra.Command{
 		Use:   "install [skill-name]",
 		Short: "Install Databricks skills for detected coding agents",
 		Long: `Install Databricks skills to all detected coding agents.
@@ -47,15 +85,48 @@ and symlinked to each agent to avoid duplication.
 
 Supported agents: Claude Code, Cursor, Codex CLI, OpenCode, GitHub Copilot, Antigravity`,
 		RunE: func(cmd *cobra.Command, args []string) error {
-			return runSkillsInstall(cmd.Context(), args)
+			return runSkillsInstall(cmd.Context(), args, includeExperimental)
 		},
 	}
+
+	cmd.Flags().BoolVar(&includeExperimental, "experimental", false, "Include experimental skills")
+	return cmd
 }
 
-func runSkillsInstall(ctx context.Context, args []string) error {
+func runSkillsInstall(ctx context.Context, args []string, includeExperimental bool) error {
+	detected := agents.DetectInstalled(ctx)
+	if len(detected) == 0 {
+		cmdio.LogString(ctx, color.YellowString("No supported coding agents detected."))
+		cmdio.LogString(ctx, "")
+		cmdio.LogString(ctx, "Supported agents: Claude Code, Cursor, Codex CLI, OpenCode, GitHub Copilot, Antigravity")
+		cmdio.LogString(ctx, "Please install at least one coding agent first.")
+		return nil
+	}
+
+	var targetAgents []*agents.Agent
+	switch {
+	case len(detected) == 1:
+		targetAgents = detected
+	case cmdio.IsPromptSupported(ctx):
+		var err error
+		targetAgents, err = promptAgentSelection(ctx, detected)
+		if err != nil {
+			return err
+		}
+	default:
+		// Non-interactive: install for all detected agents.
+		targetAgents = detected
+	}
+
+	installer.PrintInstallingFor(ctx, targetAgents)
+
+	opts := installer.InstallOptions{
+		IncludeExperimental: includeExperimental,
+	}
 	if len(args) > 0 {
-		return installSkill(ctx, args[0])
+		opts.SpecificSkills = []string{args[0]}
 	}
 
-	return installAllSkills(ctx)
+	src := &installer.GitHubManifestSource{}
+	return installSkillsForAgentsFn(ctx, src, targetAgents, opts)
 }