feat(skill): support Codex and Cursor in stack skill install (#68)

* feat(skill): support Codex and Cursor in `stack skill install`

`stack skill install` now auto-detects which AI coding tools are installed
(Claude Code, Codex, Cursor) and installs the skill for all of them.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* feat(skill): keep manual install section in README

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>

Author: javoire

README.md

@@ -105,19 +105,19 @@ Or use the interactive helper:
 stack config set
 ```
 
-## Claude Code Skill
+## AI Coding Tools
 
-Stackinator includes a [Claude Code](https://claude.ai/code) skill that teaches Claude how to manage stacked branches.
-
-### Quick install
+Stackinator includes a skill that teaches AI coding tools how to manage stacked branches. Supported tools: [Claude Code](https://claude.ai/code), [Codex](https://openai.com/index/introducing-codex/), and [Cursor](https://cursor.com/).
 
 ```bash
 stack skill install
 ```
 
+This auto-detects which tools are installed and installs the skill for all of them.
+
 ### Manual install
 
-In Claude Code, run:
+For Claude Code, run:
 
 ```
 /plugin marketplace add javoire/stackinator

cmd/skill.go

@@ -4,27 +4,36 @@ import (
 	"fmt"
 	"os"
 	"os/exec"
+	"path/filepath"
+	"strings"
 
 	"github.com/javoire/stackinator/internal/ui"
+	skillcontent "github.com/javoire/stackinator/plugins/stack/skills/stack"
 	"github.com/spf13/cobra"
 )
 
+type aiTool struct {
+	Name    string
+	Detect  func() bool
+	Install func() error
+}
+
 var skillCmd = &cobra.Command{
 	Use:   "skill",
-	Short: "Manage Claude Code skills",
-	Long:  `Manage Claude Code skills for the stack CLI.`,
+	Short: "Manage AI coding tool skills",
+	Long:  `Manage AI coding tool skills for the stack CLI.`,
 	Annotations: map[string]string{
 		"skipGitValidation": "true",
 	},
 }
 
 var skillInstallCmd = &cobra.Command{
 	Use:   "install",
-	Short: "Install the stack skill for Claude Code",
-	Long: `Install the stack skill so Claude Code knows how to use the stack CLI.
+	Short: "Install the stack skill for AI coding tools",
+	Long: `Install the stack skill so AI coding tools know how to use the stack CLI.
 
-This requires the Claude Code CLI (claude) to be installed.
-See https://claude.ai/code for installation instructions.`,
+Supported tools: Claude Code, Codex, Cursor.
+Automatically detects which tools are installed and installs for all of them.`,
 	Annotations: map[string]string{
 		"skipGitValidation": "true",
 	},
@@ -38,11 +47,48 @@ func init() {
 	rootCmd.AddCommand(skillCmd)
 }
 
-func runSkillInstall() error {
-	if _, err := exec.LookPath("claude"); err != nil {
-		return fmt.Errorf("claude CLI not found in PATH. Install it from https://claude.ai/code")
+func getAITools() []aiTool {
+	return []aiTool{
+		{Name: "Claude Code", Detect: detectClaude, Install: installClaude},
+		{Name: "Codex", Detect: detectCodex, Install: installCodex},
+		{Name: "Cursor", Detect: detectCursor, Install: installCursor},
+	}
+}
+
+func detectClaude() bool {
+	_, err := exec.LookPath("claude")
+	return err == nil
+}
+
+func detectCodex() bool {
+	_, err := exec.LookPath("codex")
+	return err == nil
+}
+
+func detectCursor() bool {
+	if _, err := exec.LookPath("cursor"); err == nil {
+		return true
+	}
+	home, err := os.UserHomeDir()
+	if err != nil {
+		return false
 	}
+	_, err = os.Stat(filepath.Join(home, ".cursor"))
+	return err == nil
+}
+
+// skillBody returns the SKILL.md content with YAML frontmatter stripped.
+func skillBody() string {
+	content := skillcontent.SkillMD
+	if strings.HasPrefix(content, "---") {
+		if idx := strings.Index(content[3:], "---"); idx != -1 {
+			content = strings.TrimLeft(content[3+idx+3:], "\n")
+		}
+	}
+	return content
+}
 
+func installClaude() error {
 	fmt.Println("Adding stackinator marketplace...")
 	addCmd := exec.Command("claude", "plugin", "marketplace", "add", "javoire/stackinator")
 	addCmd.Stdout = os.Stdout
@@ -58,7 +104,75 @@ func runSkillInstall() error {
 	if err := installCmd.Run(); err != nil {
 		return fmt.Errorf("failed to install skill: %w", err)
 	}
+	return nil
+}
+
+func installCodex() error {
+	home, err := os.UserHomeDir()
+	if err != nil {
+		return fmt.Errorf("failed to get home directory: %w", err)
+	}
+
+	dir := filepath.Join(home, ".agents", "skills", "stack")
+	if err := os.MkdirAll(dir, 0755); err != nil {
+		return fmt.Errorf("failed to create directory %s: %w", dir, err)
+	}
+
+	dest := filepath.Join(dir, "SKILL.md")
+	if err := os.WriteFile(dest, []byte(skillcontent.SkillMD), 0644); err != nil {
+		return fmt.Errorf("failed to write %s: %w", dest, err)
+	}
+
+	fmt.Printf("Wrote %s\n", dest)
+	return nil
+}
+
+func installCursor() error {
+	home, err := os.UserHomeDir()
+	if err != nil {
+		return fmt.Errorf("failed to get home directory: %w", err)
+	}
+
+	dir := filepath.Join(home, ".cursor", "rules")
+	if err := os.MkdirAll(dir, 0755); err != nil {
+		return fmt.Errorf("failed to create directory %s: %w", dir, err)
+	}
+
+	body := skillBody()
+	mdc := "---\ndescription: Manage stacked branches with the stack CLI. Covers branch creation, navigation, syncing, and PR management.\nalwaysApply: true\n---\n\n" + body
+
+	dest := filepath.Join(dir, "stack.mdc")
+	if err := os.WriteFile(dest, []byte(mdc), 0644); err != nil {
+		return fmt.Errorf("failed to write %s: %w", dest, err)
+	}
+
+	fmt.Printf("Wrote %s\n", dest)
+	return nil
+}
+
+func runSkillInstall() error {
+	tools := getAITools()
+
+	var detected []aiTool
+	for _, t := range tools {
+		if t.Detect() {
+			detected = append(detected, t)
+		}
+	}
+
+	if len(detected) == 0 {
+		return fmt.Errorf("no supported AI coding tools found. Supported tools: Claude Code (claude), Codex (codex), Cursor (cursor or ~/.cursor/)")
+	}
+
+	var installed []string
+	for _, t := range detected {
+		fmt.Printf("Installing for %s...\n", t.Name)
+		if err := t.Install(); err != nil {
+			return fmt.Errorf("failed to install for %s: %w", t.Name, err)
+		}
+		installed = append(installed, t.Name)
+	}
 
-	fmt.Println(ui.Success("Stack skill installed! Claude Code now knows how to use the stack CLI."))
+	fmt.Println(ui.Success(fmt.Sprintf("Stack skill installed for: %s", strings.Join(installed, ", "))))
 	return nil
 }

cmd/skill_test.go

@@ -2,31 +2,73 @@ package cmd
 
 import (
 	"os"
-	"os/exec"
+	"path/filepath"
+	"strings"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
-func TestRunSkillInstall_ClaudeNotFound(t *testing.T) {
-	// Set PATH to empty so claude can't be found
-	originalPath := os.Getenv("PATH")
+func TestRunSkillInstall_NoToolsFound(t *testing.T) {
 	t.Setenv("PATH", "")
-	defer func() { os.Setenv("PATH", originalPath) }()
+	t.Setenv("HOME", t.TempDir())
 
-	// Clear the exec.LookPath cache by ensuring fresh lookup
 	err := runSkillInstall()
 	assert.Error(t, err)
-	assert.Contains(t, err.Error(), "claude CLI not found")
+	assert.Contains(t, err.Error(), "no supported AI coding tools found")
 }
 
-func TestRunSkillInstall_ClaudeFound(t *testing.T) {
-	// Skip if claude is not installed
-	if _, err := exec.LookPath("claude"); err != nil {
-		t.Skip("claude CLI not installed, skipping integration test")
-	}
+func TestInstallCodex(t *testing.T) {
+	home := t.TempDir()
+	t.Setenv("HOME", home)
 
-	// This would actually run the commands, so we just verify claude is found
-	// A full integration test would require mocking exec.Command
-	t.Log("claude CLI found in PATH")
+	err := installCodex()
+	require.NoError(t, err)
+
+	dest := filepath.Join(home, ".agents", "skills", "stack", "SKILL.md")
+	content, err := os.ReadFile(dest)
+	require.NoError(t, err)
+	assert.Contains(t, string(content), "name: stack")
+	assert.Contains(t, string(content), "## Common Commands")
+}
+
+func TestInstallCursor(t *testing.T) {
+	home := t.TempDir()
+	t.Setenv("HOME", home)
+
+	err := installCursor()
+	require.NoError(t, err)
+
+	dest := filepath.Join(home, ".cursor", "rules", "stack.mdc")
+	content, err := os.ReadFile(dest)
+	require.NoError(t, err)
+	assert.Contains(t, string(content), "alwaysApply: true")
+	assert.Contains(t, string(content), "description:")
+	assert.Contains(t, string(content), "## Common Commands")
+	// Should not contain SKILL.md frontmatter
+	assert.NotContains(t, string(content), "name: stack")
+}
+
+func TestSkillBody(t *testing.T) {
+	body := skillBody()
+	assert.False(t, strings.HasPrefix(body, "---"))
+	assert.Contains(t, body, "## Common Commands")
+}
+
+func TestDetectCursor_WithDir(t *testing.T) {
+	home := t.TempDir()
+	t.Setenv("HOME", home)
+	t.Setenv("PATH", "")
+
+	require.NoError(t, os.MkdirAll(filepath.Join(home, ".cursor"), 0755))
+	assert.True(t, detectCursor())
+}
+
+func TestDetectCursor_NothingFound(t *testing.T) {
+	home := t.TempDir()
+	t.Setenv("HOME", home)
+	t.Setenv("PATH", "")
+
+	assert.False(t, detectCursor())
 }

docs/commands.md

@@ -156,9 +156,13 @@ Flags:
 
 ## `stack skill install`
 
-Install the Claude Code skill so Claude knows how to use the stack CLI.
+Install the stack skill for AI coding tools so they know how to use the stack CLI.
 
-Requires the [Claude Code CLI](https://claude.ai/code) to be installed.
+Automatically detects which supported tools are installed and installs for all of them:
+
+- **Claude Code** - via plugin marketplace (`claude` CLI required)
+- **Codex** - writes `SKILL.md` to `~/.agents/skills/stack/` (`codex` CLI required)
+- **Cursor** - writes `stack.mdc` to `~/.cursor/rules/` (`cursor` CLI or `~/.cursor/` directory required)
 
 ```bash
 stack skill install

plugins/stack/skills/stack/content.go

@@ -0,0 +1,6 @@
+package skillcontent
+
+import _ "embed"
+
+//go:embed SKILL.md
+var SkillMD string