[4/5] Aitools: list command, flat structure, --skills/--agents/--include-experimental flags (#4813)

## PR Stack

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

Manifest v2 PR: databricks/databricks-agent-skills#35

**Base**: `simonfaltum/aitools-pr3-lifecycle` (PR 3)

## Why

Commands are nested under `skills` which burns namespace for future
component types (hooks, etc.). There's no way to install specific
skills, target specific agents from the CLI, or see installed status in
the list output.

## Changes

**New `list` command**: Table output with skill names, versions,
installed status, `[experimental]` tags. Sorted alphabetically. Uses
`tabwriter` for alignment.

**Flat command structure**: `aitools
install/update/uninstall/list/version` at the top level. Hidden `skills
install` and `skills list` aliases for backward compat.

**Flags**:
- `--skills` (string, comma-separated) on install, update, uninstall:
operate on specific skills
- `--skills` (bool) on list, version: show detailed skills view
- `--agents` (string, comma-separated) on install: target specific
agents, validates against registry, skips interactive prompt
- `--include-experimental` on install: include experimental skills

**Selective uninstall**: `--skills` on uninstall removes only named
skills, preserves state file with remaining.

## Test plan

- [x] `install --skills`, `--agents`, `--include-experimental` flags
work
- [x] `--agents` validates against registry, errors on unknown
- [x] `uninstall --skills` selective removal, state preserved
- [x] `update --skills` selective update
- [x] `list` shows detailed table
- [x] `skills install` and `skills list` hidden aliases work (Execute
path tested)
- [x] `cmd/apps/init.go` integration preserved
- [x] All lint checks pass

Author: simonfaltum

experimental/aitools/cmd/aitools.go

@@ -18,11 +18,12 @@ Provides commands to:
 	}
 
 	cmd.AddCommand(newInstallCmd())
-	cmd.AddCommand(newSkillsCmd())
-	cmd.AddCommand(newToolsCmd())
 	cmd.AddCommand(newUpdateCmd())
 	cmd.AddCommand(newUninstallCmd())
+	cmd.AddCommand(newListCmd())
 	cmd.AddCommand(newVersionCmd())
+	cmd.AddCommand(newSkillsCmd())
+	cmd.AddCommand(newToolsCmd())
 
 	return cmd
 }

experimental/aitools/cmd/flags.go

@@ -0,0 +1,23 @@
+package aitools
+
+import "strings"
+
+// splitAndTrim splits a comma-separated string, trims whitespace from each
+// element, and drops empty entries.
+func splitAndTrim(s string) []string {
+	if s == "" {
+		return nil
+	}
+	parts := strings.Split(s, ",")
+	var result []string
+	for _, p := range parts {
+		p = strings.TrimSpace(p)
+		if p != "" {
+			result = append(result, p)
+		}
+	}
+	if len(result) == 0 {
+		return nil
+	}
+	return result
+}

experimental/aitools/cmd/flags_test.go

@@ -0,0 +1,27 @@
+package aitools
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestSplitAndTrim(t *testing.T) {
+	tests := []struct {
+		name     string
+		input    string
+		expected []string
+	}{
+		{"simple", "a,b", []string{"a", "b"}},
+		{"whitespace", "a, b , c", []string{"a", "b", "c"}},
+		{"empty input", "", nil},
+		{"trailing comma", "a,b,", []string{"a", "b"}},
+		{"only commas", ",,", nil},
+		{"single value", "a", []string{"a"}},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			assert.Equal(t, tt.expected, splitAndTrim(tt.input))
+		})
+	}
+}

experimental/aitools/cmd/install.go

@@ -1,23 +1,120 @@
 package aitools
 
 import (
+	"context"
+	"errors"
+	"fmt"
+	"strings"
+
+	"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"
 )
 
 func newInstallCmd() *cobra.Command {
+	var skillsFlag, agentsFlag string
 	var includeExperimental bool
 
 	cmd := &cobra.Command{
-		Use:   "install [skill-name]",
-		Short: "Alias for skills install",
-		Long: `Alias for "databricks experimental aitools skills install".
+		Use:   "install",
+		Short: "Install AI skills for coding agents",
+		Long: `Install Databricks AI skills for detected coding agents.
+
+Skills are installed globally to each agent's skills directory.
+When multiple agents are detected, skills are stored in a canonical location
+and symlinked to each agent to avoid duplication.
 
-Installs Databricks skills for detected coding agents.`,
+Supported agents: Claude Code, Cursor, Codex CLI, OpenCode, GitHub Copilot, Antigravity`,
+		Args: cobra.NoArgs,
 		RunE: func(cmd *cobra.Command, args []string) error {
-			return runSkillsInstall(cmd.Context(), args, includeExperimental)
+			ctx := cmd.Context()
+
+			// Resolve target agents.
+			var targetAgents []*agents.Agent
+			if agentsFlag != "" {
+				var err error
+				targetAgents, err = resolveAgentNames(ctx, agentsFlag)
+				if err != nil {
+					return err
+				}
+			} else {
+				detected := agents.DetectInstalled(ctx)
+				if len(detected) == 0 {
+					printNoAgentsMessage(ctx)
+					return nil
+				}
+
+				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:
+					targetAgents = detected
+				}
+			}
+
+			// Build install options.
+			opts := installer.InstallOptions{
+				IncludeExperimental: includeExperimental,
+			}
+			opts.SpecificSkills = splitAndTrim(skillsFlag)
+
+			installer.PrintInstallingFor(ctx, targetAgents)
+
+			src := &installer.GitHubManifestSource{}
+			return installSkillsForAgentsFn(ctx, src, targetAgents, opts)
 		},
 	}
 
+	cmd.Flags().StringVar(&skillsFlag, "skills", "", "Specific skills to install (comma-separated)")
+	cmd.Flags().StringVar(&agentsFlag, "agents", "", "Agents to install for (comma-separated, e.g. claude-code,cursor)")
 	cmd.Flags().BoolVar(&includeExperimental, "experimental", false, "Include experimental skills")
 	return cmd
 }
+
+// resolveAgentNames parses a comma-separated list of agent names and validates
+// them against the registry. Returns an error for unrecognized names.
+func resolveAgentNames(ctx context.Context, names string) ([]*agents.Agent, error) {
+	available := make(map[string]*agents.Agent, len(agents.Registry))
+	var availableNames []string
+	for i := range agents.Registry {
+		a := &agents.Registry[i]
+		available[a.Name] = a
+		availableNames = append(availableNames, a.Name)
+	}
+
+	var result []*agents.Agent
+	seen := make(map[string]bool)
+	for _, name := range strings.Split(names, ",") {
+		name = strings.TrimSpace(name)
+		if name == "" || seen[name] {
+			continue
+		}
+		seen[name] = true
+		agent, ok := available[name]
+		if !ok {
+			return nil, fmt.Errorf("unknown agent %q. Available agents: %s", name, strings.Join(availableNames, ", "))
+		}
+		result = append(result, agent)
+	}
+
+	if len(result) == 0 {
+		return nil, errors.New("no agents specified")
+	}
+	return result, nil
+}
+
+// printNoAgentsMessage prints the "no agents detected" message.
+func printNoAgentsMessage(ctx context.Context) {
+	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.")
+}