feat(skills): add support for user invocable skills

Author: taciturnaxolotl

internal/commands/commands.go

@@ -12,6 +12,7 @@ import (
 	"github.com/charmbracelet/crush/internal/agent/tools/mcp"
 	"github.com/charmbracelet/crush/internal/config"
 	"github.com/charmbracelet/crush/internal/home"
+	"github.com/charmbracelet/crush/internal/skills"
 )
 
 var namedArgPattern = regexp.MustCompile(`\$([A-Z][A-Z0-9_]*)`)
@@ -45,6 +46,8 @@ type CustomCommand struct {
 	Name      string
 	Content   string
 	Arguments []Argument
+	// Skill is set when this command represents a user-invocable skill
+	Skill *skills.Skill
 }
 
 type commandSource struct {
@@ -58,6 +61,70 @@ func LoadCustomCommands(cfg *config.Config) ([]CustomCommand, error) {
 	return loadAll(buildCommandSources(cfg))
 }
 
+// LoadSkillCommands loads user-invocable skills as custom commands.
+func LoadSkillCommands() []CustomCommand {
+	var commands []CustomCommand
+
+	// Load from global skills directories with "user:" prefix
+	for _, dir := range config.GlobalSkillsDirs() {
+		commands = append(commands, loadInvocableSkillsFromDir(dir, userCommandPrefix)...)
+	}
+
+	return commands
+}
+
+// LoadProjectSkillCommands loads user-invocable skills from project directories as custom commands.
+func LoadProjectSkillCommands(workingDir string) []CustomCommand {
+	var commands []CustomCommand
+
+	// Load from project skills directories with "project:" prefix
+	for _, dir := range config.ProjectSkillsDir(workingDir) {
+		commands = append(commands, loadInvocableSkillsFromDir(dir, projectCommandPrefix)...)
+	}
+
+	return commands
+}
+
+func loadInvocableSkillsFromDir(dir, prefix string) []CustomCommand {
+	if _, err := os.Stat(dir); os.IsNotExist(err) {
+		return nil
+	}
+
+	var commands []CustomCommand
+
+	entries, err := os.ReadDir(dir)
+	if err != nil {
+		return nil
+	}
+
+	for _, entry := range entries {
+		if !entry.IsDir() {
+			continue
+		}
+
+		skillPath := filepath.Join(dir, entry.Name(), skills.SkillFileName)
+		skill, err := skills.Parse(skillPath)
+		if err != nil {
+			continue
+		}
+
+		if !skill.UserInvocable {
+			continue
+		}
+
+		name := prefix + skill.Name
+		commands = append(commands, CustomCommand{
+			ID:        name,
+			Name:      name,
+			Content:   skill.Instructions,
+			Arguments: nil,
+			Skill:     skill,
+		})
+	}
+
+	return commands
+}
+
 // LoadMCPPrompts loads custom commands from available MCP servers.
 func LoadMCPPrompts() ([]MCPPrompt, error) {
 	var commands []MCPPrompt

internal/skills/skills.go

@@ -36,6 +36,7 @@ var (
 type Skill struct {
 	Name          string            `yaml:"name" json:"name"`
 	Description   string            `yaml:"description" json:"description"`
+	UserInvocable bool              `yaml:"user-invocable" json:"user_invocable"`
 	License       string            `yaml:"license,omitempty" json:"license,omitempty"`
 	Compatibility string            `yaml:"compatibility,omitempty" json:"compatibility,omitempty"`
 	Metadata      map[string]string `yaml:"metadata,omitempty" json:"metadata,omitempty"`
@@ -279,6 +280,20 @@ func ToPromptXML(skills []*Skill) string {
 	return sb.String()
 }
 
+// FormatInvocation generates XML for a skill when invoked as a user command.
+func (s *Skill) FormatInvocation() string {
+	var sb strings.Builder
+	sb.WriteString("<loaded_skill>\n")
+	fmt.Fprintf(&sb, "  <name>%s</name>\n", escape(s.Name))
+	fmt.Fprintf(&sb, "  <description>%s</description>\n", escape(s.Description))
+	fmt.Fprintf(&sb, "  <location>%s</location>\n", escape(s.SkillFilePath))
+	sb.WriteString("  <instructions>\n")
+	sb.WriteString(escape(s.Instructions))
+	sb.WriteString("\n  </instructions>\n")
+	sb.WriteString("</loaded_skill>")
+	return sb.String()
+}
+
 func escape(s string) string {
 	return promptReplacer.Replace(s)
 }

internal/ui/chat/user.go

@@ -1,6 +1,7 @@
 package chat
 
 import (
+	"encoding/xml"
 	"strings"
 
 	tea "charm.land/bubbletea/v2"
@@ -11,6 +12,14 @@ import (
 	"github.com/charmbracelet/crush/internal/ui/styles"
 )
 
+// skillInvocation represents the XML structure for a loaded skill.
+type skillInvocation struct {
+	Name        string `xml:"name"`
+	Description string `xml:"description"`
+	Location    string `xml:"location"`
+	Instructions string `xml:"instructions"`
+}
+
 // UserMessageItem represents a user message in the chat UI.
 type UserMessageItem struct {
 	*highlightableMessageItem
@@ -44,9 +53,18 @@ func (m *UserMessageItem) RawRender(width int) string {
 		return m.renderHighlighted(content, cappedWidth, height)
 	}
 
+	msgContent := strings.TrimSpace(m.message.Content().Text)
+
+	// Check if this is a skill invocation (loaded_skill XML)
+	if strings.HasPrefix(msgContent, "<loaded_skill>") {
+		content = m.renderSkillInvocation(msgContent, cappedWidth)
+		height = lipgloss.Height(content)
+		m.setCachedRender(content, cappedWidth, height)
+		return m.renderHighlighted(content, cappedWidth, height)
+	}
+
 	renderer := common.MarkdownRenderer(m.sty, cappedWidth)
 
-	msgContent := strings.TrimSpace(m.message.Content().Text)
 	result, err := renderer.Render(msgContent)
 	if err != nil {
 		content = msgContent
@@ -68,6 +86,22 @@ func (m *UserMessageItem) RawRender(width int) string {
 	return m.renderHighlighted(content, cappedWidth, height)
 }
 
+// renderSkillInvocation renders a loaded_skill XML as a special UI element.
+func (m *UserMessageItem) renderSkillInvocation(content string, width int) string {
+	var skill skillInvocation
+	if err := xml.Unmarshal([]byte(content), &skill); err != nil {
+		// If parsing fails, just render as markdown
+		renderer := common.MarkdownRenderer(m.sty, width)
+		result, err := renderer.Render(content)
+		if err != nil {
+			return content
+		}
+		return strings.TrimSuffix(result, "\n")
+	}
+
+	return toolOutputSkillContent(m.sty, skill.Name, skill.Description)
+}
+
 // Render implements MessageItem.
 func (m *UserMessageItem) Render(width int) string {
 	var prefix string

internal/ui/dialog/actions.go

@@ -14,6 +14,7 @@ import (
 	"github.com/charmbracelet/crush/internal/oauth"
 	"github.com/charmbracelet/crush/internal/permission"
 	"github.com/charmbracelet/crush/internal/session"
+	"github.com/charmbracelet/crush/internal/skills"
 	"github.com/charmbracelet/crush/internal/ui/common"
 	"github.com/charmbracelet/crush/internal/ui/util"
 )
@@ -71,6 +72,7 @@ type (
 		Content   string
 		Arguments []commands.Argument
 		Args      map[string]string // Actual argument values
+		Skill     *skills.Skill     // Set when this is a skill command
 	}
 	// ActionRunMCPPrompt is a message to run a custom command.
 	ActionRunMCPPrompt struct {

internal/ui/dialog/commands.go

@@ -393,6 +393,7 @@ func (c *Commands) setCommandItems(commandType CommandType) {
 			action := ActionRunCustomCommand{
 				Content:   cmd.Content,
 				Arguments: cmd.Arguments,
+				Skill:     cmd.Skill,
 			}
 			commandItems = append(commandItems, NewCommandItem(c.com.Styles, "custom_"+cmd.ID, cmd.Name, "", action))
 		}

internal/ui/model/ui.go

@@ -467,6 +467,10 @@ func (m *UI) loadCustomCommands() tea.Cmd {
 		if err != nil {
 			slog.Error("Failed to load custom commands", "error", err)
 		}
+		// Append user-invocable skills as commands
+		skillCommands := commands.LoadSkillCommands()
+		skillCommands = append(skillCommands, commands.LoadProjectSkillCommands(m.com.Workspace.WorkingDir())...)
+		customCommands = append(customCommands, skillCommands...)
 		return userCommandsLoadedMsg{Commands: customCommands}
 	}
 }
@@ -1540,6 +1544,10 @@ func (m *UI) handleDialogMsg(msg tea.Msg) tea.Cmd {
 		if msg.Args != nil {
 			content = substituteArgs(content, msg.Args)
 		}
+		// If this is a skill command, format it using the skill's FormatInvocation method
+		if msg.Skill != nil {
+			content = msg.Skill.FormatInvocation()
+		}
 		cmds = append(cmds, m.sendMessage(content))
 		m.dialog.CloseFrontDialog()
 	case dialog.ActionRunMCPPrompt: