go-cli-path-resolution-both-layouts

Answer

Root cause. helix-prompt register/list hard-coded the nested layout prompts/<c>/<v>/prompt.md, but the repo stores prompts flat as prompts/<c>/v<N>.md (per AGENTS.md and the commit-msg hook). The fix centralizes resolution in a ResolvePromptPath helper that tries nested first, then falls back to flat; list globs the flat layout and flags unregistered files.

1. ResolvePromptPath — nested first, then flat glob (both v<N>.md and <N>.md)

// ResolvePromptPath resolves (category, version) to an existing prompt file.
// It tries the nested layout first, then the flat layout. The flat layout is
// matched by glob so a non-canonical spelling (e.g. V1.md) still resolves.
func ResolvePromptPath(promptsDir, category, version string) (string, error) {
    if promptsDir == "" {
        promptsDir = "prompts"
    }
    if category == "" || version == "" {
        return "", fmt.Errorf("prompt category and version are required")
    }

    // 1. Nested layout: prompts/<category>/<version>/prompt.md
    nested := filepath.Join(promptsDir, category, version, "prompt.md")
    if fi, err := os.Stat(nested); err == nil && !fi.IsDir() {
        return nested, nil
    }

    // 2. Flat layout: prompts/<category>/v<N>.md and prompts/<category>/<N>.md
    for _, pat := range []string{
        filepath.Join(promptsDir, category, "v"+version+".md"),
        filepath.Join(promptsDir, category, version+".md"),
    } {
        matches, err := filepath.Glob(pat)
        if err != nil {
            continue
        }
        for _, m := range matches {
            if fi, err := os.Stat(m); err == nil && !fi.IsDir() {
                return m, nil
            }
        }
    }
    return "", fmt.Errorf("prompt %s/%s not found (tried nested %q, flat v%s.md and %s.md)",
        category, version, nested, version, version)
}

2. list — glob prompts/*/v*.md, show unregistered flat prompts

var flatFileRe = regexp.MustCompile(`^(?:v)?(\d+)\.md$`) // v1.md, 1.md, v10.md

func ListFlatPrompts(promptsDir string) ([]FlatPrompt, error) {
    if promptsDir == "" {
        promptsDir = "prompts"
    }
    seen := map[string]bool{}
    var out []FlatPrompt
    for _, pat := range []string{
        filepath.Join(promptsDir, "*", "v*.md"),          // canonical flat spelling
        filepath.Join(promptsDir, "*", "[0-9]*.md"),      // bare <N>.md spelling
    } {
        for _, p := range mustGlob(pat) {
            if seen[p] {
                continue
            }
            base := filepath.Base(p)
            if m := flatFileRe.FindStringSubmatch(base); m != nil {
                seen[p] = true
                out = append(out, FlatPrompt{Category: filepath.Base(filepath.Dir(p)), Version: m[1], File: base, Path: p})
            }
        }
    }
    sortFlatPrompts(out) // by category, then numeric version (v2 < v10)
    return out, nil
}

3. register integration — resolve via the helper, persist to registry.json, and have list consult it:

path, err := ResolvePromptPath(*promptsDir, category, version) // nested→flat
if err != nil {
    return err
}
reg.Prompts[category+"/"+version] = path
return reg.Save(*promptsDir) // writes prompts/registry.json

// in list:
for _, p := range flat {
    key := p.Category + "/" + p.Version
    status := "unregistered"
    if _, ok := reg.Prompts[key]; ok {
        status = "registered"
    }
    fmt.Printf("[%s] %s -> %s\n", status, key, p.File)
}