wehub-resource-sync
219 lines
7.1 KiB
Go
219 lines
7.1 KiB
Go
// Package command loads custom slash commands from Markdown files. A command is
|
|
// a prompt template: invoking /name substitutes the arguments into the body and
|
|
// sends the result as a chat turn. Loading is pure and dependency-free — a small
|
|
// "key: value" frontmatter parser keeps Reasonix's single-(TOML)-dependency promise
|
|
// rather than pulling in a YAML library.
|
|
package command
|
|
|
|
import (
|
|
"fmt"
|
|
"os"
|
|
"path/filepath"
|
|
"regexp"
|
|
"sort"
|
|
"strconv"
|
|
"strings"
|
|
|
|
fileencoding "reasonix/internal/fileutil/encoding"
|
|
"reasonix/internal/frontmatter"
|
|
)
|
|
|
|
// Command is a custom slash command loaded from a .md file.
|
|
type Command struct {
|
|
Name string // "review" or "git:commit", derived from the file path
|
|
Description string // from frontmatter
|
|
ArgHint string // from frontmatter (argument-hint)
|
|
Body string // template with $ARGUMENTS / $1..$N / $$
|
|
Source string // originating file path, for diagnostics
|
|
Plugin string // installed plugin package name; empty for user/project commands
|
|
ShortName string // original plugin command name before the package qualifier
|
|
Hidden bool // compatibility-only short alias; invocable but omitted from listings
|
|
}
|
|
|
|
// Root is one command directory and its optional plugin-package owner. Plugin
|
|
// ownership is carried through loading so plugin commands can use stable,
|
|
// package-qualified display names without losing unambiguous short-name
|
|
// compatibility.
|
|
type Root struct {
|
|
Path string
|
|
Plugin string
|
|
}
|
|
|
|
// substRe matches the substitution tokens recognised in a command body.
|
|
var substRe = regexp.MustCompile(`\$(\$|ARGUMENTS|[0-9]+)`)
|
|
|
|
// Render substitutes args into the command body: $ARGUMENTS is all args joined
|
|
// by spaces, $1..$N are positional (empty when absent), and $$ is a literal $.
|
|
func (c Command) Render(args []string) string {
|
|
return substRe.ReplaceAllStringFunc(c.Body, func(m string) string {
|
|
switch tok := m[1:]; tok {
|
|
case "$":
|
|
return "$"
|
|
case "ARGUMENTS":
|
|
return strings.Join(args, " ")
|
|
default:
|
|
n, _ := strconv.Atoi(tok) // regex guarantees digits
|
|
if n >= 1 && n <= len(args) {
|
|
return args[n-1]
|
|
}
|
|
return ""
|
|
}
|
|
})
|
|
}
|
|
|
|
// Load reads every *.md command file under each dir, in order, so a later dir
|
|
// overrides an earlier one on a name clash (pass the user dir first, project
|
|
// dir last). Missing dirs are skipped. Individual file failures are collected
|
|
// into the returned error but don't prevent the others from loading. The result
|
|
// is sorted by name.
|
|
func Load(dirs ...string) ([]Command, error) {
|
|
roots := make([]Root, 0, len(dirs))
|
|
for _, dir := range dirs {
|
|
roots = append(roots, Root{Path: dir})
|
|
}
|
|
return LoadRoots(roots...)
|
|
}
|
|
|
|
// LoadRoots is Load with optional plugin ownership. Every plugin command is
|
|
// exposed canonically as /<plugin>:<name>. A short /<name> compatibility alias
|
|
// is retained only when exactly one plugin contributes that name and no user or
|
|
// project command owns it; the alias is hidden from completion and model-visible
|
|
// listings. An explicit command occupying the qualified name still wins.
|
|
func LoadRoots(roots ...Root) ([]Command, error) {
|
|
byName := map[string]Command{}
|
|
pluginCommands := map[string]map[string]Command{}
|
|
var errs []string
|
|
for _, spec := range roots {
|
|
root, err := filepath.Abs(spec.Path)
|
|
if err != nil {
|
|
continue
|
|
}
|
|
// A symlink-following walk (filepath.WalkDir does not follow links), so a
|
|
// symlinked command directory or a symlinked <name>.md is picked up like a
|
|
// real one. visited (keyed by resolved path) guards against symlink cycles.
|
|
visited := map[string]bool{}
|
|
if real, err := filepath.EvalSymlinks(root); err == nil {
|
|
visited[real] = true
|
|
} else {
|
|
visited[root] = true
|
|
}
|
|
walkCommands(root, root, visited, func(path string) {
|
|
c, perr := parseFile(root, path)
|
|
if perr != nil {
|
|
errs = append(errs, perr.Error())
|
|
return
|
|
}
|
|
c.Plugin = strings.TrimSpace(spec.Plugin)
|
|
if c.Plugin == "" {
|
|
byName[c.Name] = c
|
|
} else {
|
|
if pluginCommands[c.Plugin] == nil {
|
|
pluginCommands[c.Plugin] = map[string]Command{}
|
|
}
|
|
pluginCommands[c.Plugin][c.Name] = c
|
|
}
|
|
})
|
|
}
|
|
byShortName := map[string][]Command{}
|
|
for plugin, commands := range pluginCommands {
|
|
for shortName, pluginCommand := range commands {
|
|
pluginCommand.ShortName = shortName
|
|
byShortName[shortName] = append(byShortName[shortName], pluginCommand)
|
|
qualified := plugin + ":" + shortName
|
|
if _, occupied := byName[qualified]; occupied {
|
|
continue
|
|
}
|
|
pluginCommand.Name = qualified
|
|
byName[qualified] = pluginCommand
|
|
}
|
|
}
|
|
for shortName, candidates := range byShortName {
|
|
if _, occupied := byName[shortName]; occupied || len(candidates) != 1 {
|
|
continue
|
|
}
|
|
compat := candidates[0]
|
|
compat.Name = shortName
|
|
compat.Hidden = true
|
|
byName[shortName] = compat
|
|
}
|
|
cmds := make([]Command, 0, len(byName))
|
|
for _, c := range byName {
|
|
cmds = append(cmds, c)
|
|
}
|
|
sort.Slice(cmds, func(i, j int) bool { return cmds[i].Name < cmds[j].Name })
|
|
if len(errs) > 0 {
|
|
return cmds, fmt.Errorf("command load: %s", strings.Join(errs, "; "))
|
|
}
|
|
return cmds, nil
|
|
}
|
|
|
|
// walkCommands recursively visits dir, following symlinks, and calls fn with the
|
|
// path of every *.md file (including symlinked files and files under symlinked
|
|
// directories). visited (resolved-path set) prevents infinite recursion through
|
|
// a symlink cycle. Unreadable directories are skipped, never fatal.
|
|
func walkCommands(root, dir string, visited map[string]bool, fn func(path string)) {
|
|
entries, err := os.ReadDir(dir)
|
|
if err != nil {
|
|
return
|
|
}
|
|
for _, e := range entries {
|
|
full := filepath.Join(dir, e.Name())
|
|
isDir := e.IsDir()
|
|
isFile := e.Type().IsRegular()
|
|
if e.Type()&os.ModeSymlink != 0 {
|
|
info, serr := os.Stat(full) // follow the link
|
|
if serr != nil {
|
|
continue // broken link
|
|
}
|
|
isDir = info.IsDir()
|
|
isFile = info.Mode().IsRegular()
|
|
}
|
|
switch {
|
|
case isDir:
|
|
real, rerr := filepath.EvalSymlinks(full)
|
|
if rerr != nil {
|
|
real = full
|
|
}
|
|
if visited[real] {
|
|
continue
|
|
}
|
|
visited[real] = true
|
|
walkCommands(root, full, visited, fn)
|
|
case isFile && strings.EqualFold(filepath.Ext(e.Name()), ".md"):
|
|
fn(full)
|
|
}
|
|
}
|
|
}
|
|
|
|
// parseFile reads one command file and derives its name from the path relative
|
|
// to root: drop the .md suffix and turn subdirectories into ":" namespaces
|
|
// (git/commit.md → git:commit).
|
|
func parseFile(root, path string) (Command, error) {
|
|
b, err := fileencoding.ReadFileUTF8(path)
|
|
if err != nil {
|
|
return Command{}, err
|
|
}
|
|
rel, err := filepath.Rel(root, path)
|
|
if err != nil {
|
|
rel = filepath.Base(path)
|
|
}
|
|
name := strings.ReplaceAll(strings.TrimSuffix(filepath.ToSlash(rel), ".md"), "/", ":")
|
|
|
|
// Normalise line endings and strip a leading UTF-8 BOM if present.
|
|
content := strings.TrimPrefix(strings.ReplaceAll(string(b), "\r\n", "\n"), string(rune(0xFEFF)))
|
|
fm, body := frontmatter.Split(content)
|
|
return Command{
|
|
Name: name,
|
|
Description: fm["description"],
|
|
ArgHint: fm["argument-hint"],
|
|
Body: strings.TrimSpace(body),
|
|
Source: path,
|
|
}, nil
|
|
}
|
|
|
|
// splitFrontmatter is a thin wrapper kept for test compatibility; the real
|
|
// parser lives in internal/frontmatter.
|
|
func splitFrontmatter(s string) (map[string]string, string) {
|
|
return frontmatter.Split(s)
|
|
}
|