Add render skills install command (#269)

## Summary

Add `render skills` commands for managing Render agent skills across AI coding tools.

## What's included

- **`skills install`** — Interactive or CLI-driven installation of skills from the Render skills repo to detected AI coding tools (Codex, OpenCode, Gemini CLI, and all Vercel-registry agents)
- **`skills update`** — Content-hash-based update detection (SHA-256) with interactive selection of outdated skills
- **`skills remove`** — Remove skills interactively or via `--skill`, `--tool`, and `--all` flags
- **`skills list`** — Display installed skills and detected tools from local state (offline)
- **Skills hub** — `render skills` opens a TUI palette for quick access to all subcommands

## Key design decisions

- **Shared skills directory** (`~/.agents/skills`) used by most tools, with tool-specific paths where needed (e.g. `~/.gemini/skills`)
- **Scope support** — Skills can be installed at user or project scope, with scope-aware state management and labeling
- **TUI-first** — All commands use Bubble Tea views with state machines; `--tool`/`--skill`/`--scope` flags available for CI
- **go-git** for cloning instead of shelling out to `git`
- **State persistence** in `~/.render/skills.yaml` tracking versions, content hashes, scopes, and directory names

Author: R4ph-t

cmd/skills.go

@@ -0,0 +1,78 @@
+package cmd
+
+import (
+	"context"
+
+	tea "github.com/charmbracelet/bubbletea"
+	"github.com/spf13/cobra"
+
+	"github.com/render-oss/cli/pkg/tui"
+	"github.com/render-oss/cli/pkg/tui/views"
+)
+
+var skillsCmd = &cobra.Command{
+	Use:   "skills",
+	Short: "Manage Render agent skills for AI coding tools",
+	Long: `Install and manage Render agent skills for AI coding tools such as
+Claude Code, Codex, OpenCode, and Cursor.
+
+Skills add deployment, debugging, and monitoring capabilities to your
+AI coding assistant.`,
+	RunE: func(cmd *cobra.Command, args []string) error {
+		ctx := cmd.Context()
+		stack := tui.GetStackFromContext(ctx)
+
+		commands := []views.PaletteCommand{
+			{
+				Name:        "list",
+				Description: "List installed skills and detected tools",
+				Action: func(ctx context.Context, args []string) tea.Cmd {
+					return pushSkillsView(ctx, views.NewSkillsListView(""), "List Skills")
+				},
+			},
+			{
+				Name:        "install",
+				Description: "Install skills to AI coding tools",
+				Action: func(ctx context.Context, args []string) tea.Cmd {
+					return pushSkillsView(ctx, views.NewSkillsInstallView(views.SkillsInstallViewInput{}), "Install Skills")
+				},
+			},
+			{
+				Name:        "update",
+				Description: "Update previously installed skills",
+				Action: func(ctx context.Context, args []string) tea.Cmd {
+					return pushSkillsView(ctx, views.NewSkillsUpdateView(false, ""), "Update Skills")
+				},
+			},
+			{
+				Name:        "remove",
+				Description: "Remove installed skills from tools",
+				Action: func(ctx context.Context, args []string) tea.Cmd {
+					return pushSkillsView(ctx, views.NewSkillsRemoveView(""), "Remove Skills")
+				},
+			},
+		}
+
+		palette := views.NewPaletteView(ctx, commands)
+		stack.Push(tui.ModelWithCmd{
+			Model:      palette,
+			Breadcrumb: "Skills",
+		})
+		return nil
+	},
+}
+
+func init() {
+	rootCmd.AddCommand(skillsCmd)
+}
+
+// pushSkillsView pushes a skills view onto the TUI stack.
+// Skills views are pushed directly (not via AddToStackFunc) because
+// they are purely local — there's no CLI command string to copy.
+func pushSkillsView(ctx context.Context, model tea.Model, breadcrumb string) tea.Cmd {
+	stack := tui.GetStackFromContext(ctx)
+	return stack.Push(tui.ModelWithCmd{
+		Model:      model,
+		Breadcrumb: breadcrumb,
+	})
+}

cmd/skillsinstall.go

@@ -0,0 +1,101 @@
+package cmd
+
+import (
+	"github.com/spf13/cobra"
+
+	"github.com/render-oss/cli/pkg/command"
+	"github.com/render-oss/cli/pkg/skills"
+	"github.com/render-oss/cli/pkg/text"
+	"github.com/render-oss/cli/pkg/tui"
+	"github.com/render-oss/cli/pkg/tui/views"
+)
+
+// SkillsInstallInput holds the CLI input for skills install.
+type SkillsInstallInput struct {
+	Tool   string   `cli:"tool"`
+	Skills []string `cli:"skill"`
+	DryRun bool     `cli:"dry-run"`
+	Scope  string   `cli:"scope"`
+}
+
+var skillsInstallCmd = &cobra.Command{
+	Use:   "install",
+	Short: "Install Render skills to AI coding tools",
+	Long: `Install Render agent skills from https://github.com/render-oss/skills to
+detected AI coding tools.
+
+Supported tools: Claude Code, Codex, OpenCode, Cursor.
+
+Skills can be installed at two scopes:
+  - user:    Install to ~/.{tool}/skills/ (default, current user only)
+  - project: Install to ./.{tool}/skills/ (committed to git, all collaborators)
+
+By default an interactive prompt lets you pick scope, tools, and skills.
+Use --scope, --tool, and --skill flags to skip the prompts (useful for CI).`,
+	SilenceUsage: true,
+}
+
+func init() {
+	skillsCmd.AddCommand(skillsInstallCmd)
+	skillsInstallCmd.Flags().String("tool", "", "install to a specific tool only (claude, codex, opencode, cursor)")
+	skillsInstallCmd.Flags().StringSlice("skill", nil, "install specific skills only (e.g. --skill render-deploy --skill render-debug)")
+	skillsInstallCmd.Flags().Bool("dry-run", false, "show what would be installed without making changes")
+	skillsInstallCmd.Flags().String("scope", "", "installation scope: user (default) or project")
+
+	skillsInstallCmd.RunE = func(cmd *cobra.Command, args []string) error {
+		var input SkillsInstallInput
+		if err := command.ParseCommand(cmd, args, &input); err != nil {
+			return err
+		}
+
+		// Parse scope if provided
+		var scope skills.Scope
+		if input.Scope != "" {
+			var err error
+			scope, err = skills.ParseScope(input.Scope)
+			if err != nil {
+				return err
+			}
+		}
+
+		// Non-interactive path: use command.NonInteractive
+		if nonInteractive, err := command.NonInteractive(cmd, func() (*skills.InstallResult, error) {
+			return skills.Install(skills.InstallInput{
+				ToolFilter:  input.Tool,
+				SkillFilter: input.Skills,
+				DryRun:      input.DryRun,
+				Scope:       scope,
+			})
+		}, func(r *skills.InstallResult) string {
+			action := "Installed"
+			if r.DryRun {
+				action = "Would install"
+			}
+			return text.FormatStringF("%s %d skill(s) to %d tool(s)", action, len(r.Skills), len(r.Tools))
+		}); err != nil {
+			return err
+		} else if nonInteractive {
+			return nil
+		}
+
+		// Interactive path: launch TUI with pre-populated input
+		interactiveSkillsInstall(cmd, input, scope)
+		return nil
+	}
+}
+
+// interactiveSkillsInstall launches the TUI, skipping steps based on provided flags.
+func interactiveSkillsInstall(cmd *cobra.Command, input SkillsInstallInput, scope skills.Scope) {
+	ctx := cmd.Context()
+	stack := tui.GetStackFromContext(ctx)
+
+	// Pass input to the view so it can skip steps if flags are provided
+	stack.Push(tui.ModelWithCmd{
+		Model: views.NewSkillsInstallView(views.SkillsInstallViewInput{
+			ToolFilter:  input.Tool,
+			SkillFilter: input.Skills,
+			Scope:       scope,
+		}),
+		Breadcrumb: "Install Skills",
+	})
+}

cmd/skillslist.go

@@ -0,0 +1,48 @@
+package cmd
+
+import (
+	"github.com/spf13/cobra"
+
+	"github.com/render-oss/cli/pkg/skills"
+	"github.com/render-oss/cli/pkg/tui"
+	"github.com/render-oss/cli/pkg/tui/views"
+)
+
+var skillsListCmd = &cobra.Command{
+	Use:   "list",
+	Short: "List installed Render skills and detected tools",
+	Long: `Show which Render skills are currently installed and which AI coding tools
+they are installed to. This reads from local state only — no network
+access is required.
+
+Use --scope to filter by installation scope (user or project).`,
+	SilenceUsage: true,
+	RunE: func(cmd *cobra.Command, args []string) error {
+		scopeFilter, _ := cmd.Flags().GetString("scope")
+
+		var scope skills.Scope
+		if scopeFilter != "" {
+			var err error
+			scope, err = skills.ParseScope(scopeFilter)
+			if err != nil {
+				return err
+			}
+		}
+
+		// Push TUI view onto the stack.
+		// We push directly (not via AddToStackFunc) because skills are
+		// purely local — there's no CLI command string to copy.
+		ctx := cmd.Context()
+		stack := tui.GetStackFromContext(ctx)
+		stack.Push(tui.ModelWithCmd{
+			Model:      views.NewSkillsListView(scope),
+			Breadcrumb: "List Skills",
+		})
+		return nil
+	},
+}
+
+func init() {
+	skillsCmd.AddCommand(skillsListCmd)
+	skillsListCmd.Flags().String("scope", "", "filter by scope: user or project")
+}