esengine--deepseek-reasonix
wehub-resource-sync
964 行
28 KiB
Go
964 行
28 KiB
Go
package cli
|
||
|
||
import (
|
||
"os"
|
||
"path/filepath"
|
||
"strings"
|
||
"testing"
|
||
|
||
tea "charm.land/bubbletea/v2"
|
||
|
||
"reasonix/internal/i18n"
|
||
"reasonix/internal/skill"
|
||
)
|
||
|
||
func makeTestSkills() []skill.Skill {
|
||
return []skill.Skill{
|
||
{Name: "review", Description: "Review code changes for correctness", Scope: skill.ScopeProject, Path: "/fake/proj/.reasonix/skills/review/SKILL.md", RunAs: skill.RunSubagent, Body: "# Review\n\nReview code."},
|
||
{Name: "explore", Description: "Fast read-only search agent", Scope: skill.ScopeBuiltin, Path: "(builtin)", RunAs: skill.RunSubagent, Body: "# Explore\n\nSearch the codebase."},
|
||
{Name: "test", Description: "Run tests and validate behavior", Scope: skill.ScopeProject, Path: "/fake/proj/.reasonix/skills/test.md", RunAs: skill.RunInline, Body: "# Test\n\nRun the tests."},
|
||
}
|
||
}
|
||
|
||
func TestSkillPickerRenderSmoke(t *testing.T) {
|
||
skills := makeTestSkills()
|
||
m := chatTUI{
|
||
width: 80,
|
||
skills: skills,
|
||
skillPick: &skillPicker{
|
||
mode: pickerSkills,
|
||
skills: skills,
|
||
roots: nil,
|
||
},
|
||
}
|
||
|
||
out := m.renderSkillPicker()
|
||
if out == "" {
|
||
t.Fatal("renderSkillPicker returned empty string")
|
||
}
|
||
if !strings.Contains(out, "Manage skills") {
|
||
t.Fatalf("render missing title:\n%s", out)
|
||
}
|
||
if !strings.Contains(out, "review") {
|
||
t.Fatalf("render missing skill name:\n%s", out)
|
||
}
|
||
if !strings.Contains(out, "explore") {
|
||
t.Fatalf("render missing builtin skill:\n%s", out)
|
||
}
|
||
}
|
||
|
||
func TestSkillPickerClosed(t *testing.T) {
|
||
m := chatTUI{width: 80, skillPick: nil}
|
||
if out := m.renderSkillPicker(); out != "" {
|
||
t.Fatalf("closed picker rendered %q", out)
|
||
}
|
||
}
|
||
|
||
func TestSkillPickerEnterClosesWithoutChanges(t *testing.T) {
|
||
skills := makeTestSkills()
|
||
m := newTestChatTUI()
|
||
m.skills = skills
|
||
m.skillPick = &skillPicker{
|
||
mode: pickerSkills,
|
||
skills: skills,
|
||
sel: 0,
|
||
enabled: map[string]bool{"review": true},
|
||
originalEnabled: map[string]bool{"review": true},
|
||
}
|
||
m.input.SetValue("old input")
|
||
|
||
next, _ := m.saveSkillPick()
|
||
cm := next.(chatTUI)
|
||
if val := cm.input.Value(); val != "old input" {
|
||
t.Fatalf("saveSkillPick changed input to %q, want old input", val)
|
||
}
|
||
if cm.skillPick != nil {
|
||
t.Fatal("saveSkillPick did not close the picker")
|
||
}
|
||
}
|
||
|
||
func TestSkillsBareOpensPicker(t *testing.T) {
|
||
m := newTestChatTUI()
|
||
m.width = 80
|
||
m.skills = makeTestSkills()
|
||
|
||
m.runSkillSubcommand("/skills")
|
||
if m.skillPick == nil {
|
||
t.Fatal("bare /skills should open the interactive picker")
|
||
}
|
||
}
|
||
|
||
func TestSkillsManageOpensPicker(t *testing.T) {
|
||
m := newTestChatTUI()
|
||
m.width = 80
|
||
m.skills = makeTestSkills()
|
||
|
||
m.runSkillSubcommand("/skills manage")
|
||
if m.skillPick == nil {
|
||
t.Fatal("/skills manage should open the interactive picker")
|
||
}
|
||
}
|
||
|
||
func TestSkillsQuestionOpensSubcommandCompletion(t *testing.T) {
|
||
m := newTestChatTUI()
|
||
m.width = 80
|
||
m.skills = makeTestSkills()
|
||
m.input.SetValue("/skills?")
|
||
m.updateCompletion()
|
||
if !m.completion.active || m.completion.kind != compSlashArg {
|
||
t.Fatalf("/skills? should open subcommand completion: %+v", m.completion)
|
||
}
|
||
if hasLabel(m.completion.items, "manage") {
|
||
t.Fatalf("redundant manage subcommand should be hidden from /skills? menu: %+v", m.completion.items)
|
||
}
|
||
if hasLabel(m.completion.items, "list") {
|
||
t.Fatalf("redundant list subcommand should be hidden from /skills? menu: %+v", m.completion.items)
|
||
}
|
||
if !hasLabel(m.completion.items, "show") {
|
||
t.Fatalf("/skills? should include useful subcommands: %+v", m.completion.items)
|
||
}
|
||
m.input.SetValue("/skills ")
|
||
m.updateCompletion()
|
||
if m.completion.active {
|
||
t.Fatalf("/skills <space> should not open subcommand completion: %+v", m.completion)
|
||
}
|
||
}
|
||
|
||
func TestSkillsEnterSubmitsExactSlashCommand(t *testing.T) {
|
||
m := newTestChatTUI()
|
||
m.width = 80
|
||
m.skills = makeTestSkills()
|
||
m.input.SetValue("/skills")
|
||
m.updateCompletion()
|
||
if !m.completion.active {
|
||
t.Fatal("typing /skills should show slash completion before Enter")
|
||
}
|
||
if m.completion.kind == compSlashArg {
|
||
t.Fatalf("typing exact /skills should not open subcommand completion: %+v", m.completion)
|
||
}
|
||
|
||
next, _ := m.update(tea.KeyPressMsg{Code: tea.KeyEnter})
|
||
cm := next.(chatTUI)
|
||
if cm.skillPick == nil {
|
||
t.Fatal("Enter on exact /skills should open the interactive picker")
|
||
}
|
||
if got := cm.input.Value(); got != "" {
|
||
t.Fatalf("input after submitting /skills = %q, want empty", got)
|
||
}
|
||
}
|
||
|
||
func TestSkillsListRendersScrollback(t *testing.T) {
|
||
m := newTestChatTUI()
|
||
m.width = 80
|
||
m.skills = makeTestSkills()
|
||
|
||
m.runSkillSubcommand("/skills list")
|
||
if m.skillPick != nil {
|
||
t.Fatal("/skills list should render a static list, not open the picker")
|
||
}
|
||
if len(m.transcript) == 0 {
|
||
t.Fatal("/skills list should commit a list to scrollback")
|
||
}
|
||
got := strings.Join(m.transcript, "\n")
|
||
if !strings.Contains(got, "skills") || !strings.Contains(got, "/review") {
|
||
t.Fatalf("/skills list output missing expected content:\n%s", got)
|
||
}
|
||
}
|
||
|
||
func TestSkillPickerSearch(t *testing.T) {
|
||
skills := makeTestSkills()
|
||
m := chatTUI{
|
||
width: 80,
|
||
skills: skills,
|
||
skillPick: &skillPicker{
|
||
mode: pickerSkills,
|
||
skills: skills,
|
||
searchActive: true,
|
||
query: "rev",
|
||
sel: 0,
|
||
},
|
||
}
|
||
|
||
out := m.renderSkillPicker()
|
||
if out == "" {
|
||
t.Fatal("renderSkillPicker returned empty string")
|
||
}
|
||
if !strings.Contains(out, "rev") {
|
||
t.Fatalf("search mode missing query:\n%s", out)
|
||
}
|
||
if footer := m.renderMainManagerFooter(); !strings.Contains(footer, "search") && !strings.Contains(footer, "搜索") {
|
||
t.Fatalf("search mode missing footer hint:\n%s", footer)
|
||
}
|
||
if !strings.Contains(out, "review") {
|
||
t.Fatalf("search filter should include review:\n%s", out)
|
||
}
|
||
if strings.Contains(out, "explore") || strings.Contains(out, "test") {
|
||
t.Fatalf("search filter should exclude non-matching skills:\n%s", out)
|
||
}
|
||
}
|
||
|
||
func TestSkillPickerRenderDialogStyle(t *testing.T) {
|
||
i18n.DetectLanguage("en")
|
||
t.Cleanup(func() { i18n.DetectLanguage("en") })
|
||
|
||
var skills []skill.Skill
|
||
for i := 0; i < 24; i++ {
|
||
skills = append(skills, skill.Skill{
|
||
Name: "skill-" + strings.Repeat("x", i%4) + string(rune('a'+i)),
|
||
Description: "this long description should stay out of the default picker list",
|
||
Scope: skill.ScopeGlobal,
|
||
Body: "short body",
|
||
})
|
||
}
|
||
m := chatTUI{
|
||
width: 80,
|
||
height: 24,
|
||
skills: skills,
|
||
skillPick: &skillPicker{
|
||
mode: pickerSkills,
|
||
skills: skills,
|
||
sel: 0,
|
||
},
|
||
}
|
||
|
||
out := m.renderSkillPicker()
|
||
if !strings.Contains(out, "Search skills") {
|
||
t.Fatalf("dialog render missing search box:\n%s", out)
|
||
}
|
||
if !strings.Contains(out, "/ Search skills") {
|
||
t.Fatalf("dialog render should use slash search prompt, not a tiny glyph:\n%s", out)
|
||
}
|
||
if !strings.Contains(out, "more below") {
|
||
t.Fatalf("dialog render missing overflow indicator:\n%s", out)
|
||
}
|
||
if strings.Contains(out, "this long description") {
|
||
t.Fatalf("default picker list should not render long descriptions:\n%s", out)
|
||
}
|
||
}
|
||
|
||
func TestSkillPickerSearchEmptyResult(t *testing.T) {
|
||
skills := makeTestSkills()
|
||
m := chatTUI{
|
||
width: 80,
|
||
skills: skills,
|
||
skillPick: &skillPicker{
|
||
mode: pickerSkills,
|
||
skills: skills,
|
||
searchActive: true,
|
||
query: "zzz_nonexistent",
|
||
sel: 0,
|
||
},
|
||
}
|
||
|
||
out := m.renderSkillPicker()
|
||
if !strings.Contains(out, "match") && !strings.Contains(out, "匹配") {
|
||
t.Fatalf("empty search should show empty state:\n%s", out)
|
||
}
|
||
}
|
||
|
||
func TestSkillPickerDetail(t *testing.T) {
|
||
skills := makeTestSkills()
|
||
m := chatTUI{
|
||
width: 80,
|
||
skills: skills,
|
||
skillPick: &skillPicker{
|
||
mode: pickerDetail,
|
||
skills: skills,
|
||
detailSkill: skills[0],
|
||
detailBack: pickerSkills,
|
||
},
|
||
}
|
||
|
||
out := m.renderSkillPicker()
|
||
if !strings.Contains(out, "subagent") {
|
||
t.Fatalf("detail should show subagent tag:\n%s", out)
|
||
}
|
||
if !strings.Contains(out, "Scope") && !strings.Contains(out, "范围") {
|
||
t.Fatalf("detail should show scope:\n%s", out)
|
||
}
|
||
}
|
||
|
||
func TestSkillPickerSourceView(t *testing.T) {
|
||
skills := makeTestSkills()
|
||
roots := []skillRootLine{
|
||
{dir: "/fake/proj/.reasonix/skills", scope: skill.ScopeProject, status: skill.StatusOK, skills: 2, diagnostic: true},
|
||
{dir: i18nSkillPickerBuiltinSource(), scope: skill.ScopeBuiltin, status: skill.StatusOK, skills: 1, diagnostic: true},
|
||
}
|
||
m := chatTUI{
|
||
width: 80,
|
||
skills: skills,
|
||
skillPick: &skillPicker{
|
||
mode: pickerSources,
|
||
skills: skills,
|
||
roots: roots,
|
||
sourceSel: 0,
|
||
},
|
||
}
|
||
|
||
out := m.renderSkillPicker()
|
||
if !strings.Contains(out, "Sources") && !strings.Contains(out, "来源") {
|
||
t.Fatalf("source view missing title:\n%s", out)
|
||
}
|
||
if !strings.Contains(out, ".reasonix") {
|
||
t.Fatalf("source view should show root path:\n%s", out)
|
||
}
|
||
}
|
||
|
||
// i18nSkillPickerBuiltinSource returns SkillPickerBuiltinSource regardless of locale.
|
||
// In tests the i18n package is initialized to English by default.
|
||
func i18nSkillPickerBuiltinSource() string {
|
||
return "builtin"
|
||
}
|
||
|
||
func TestSkillPickerDiagnostics(t *testing.T) {
|
||
roots := []skillRootLine{
|
||
{dir: "/conf", scope: skill.ScopeCustom, status: skill.StatusOK, skills: 0, configured: true},
|
||
{dir: "/proj/.reasonix/skills", scope: skill.ScopeProject, status: skill.StatusOK, skills: 1, diagnostic: true},
|
||
{dir: "/proj/.agents/skills", scope: skill.ScopeProject, status: skill.StatusMissing, skills: 0, diagnostic: true},
|
||
{dir: "/proj/.agent/skills", scope: skill.ScopeProject, status: skill.StatusMissing, skills: 0, diagnostic: true},
|
||
}
|
||
|
||
p := &skillPicker{mode: pickerSources, roots: roots}
|
||
|
||
// Default: diagnostics hidden.
|
||
visible := p.visibleRoots()
|
||
if len(visible) != 2 {
|
||
t.Fatalf("default visibleRoots got %d, want 2 (configured custom + active project): %v", len(visible), visible)
|
||
}
|
||
|
||
// Show diagnostics.
|
||
p.showDiagnostics = true
|
||
visible = p.visibleRoots()
|
||
if len(visible) != 4 {
|
||
t.Fatalf("with diagnostics visibleRoots got %d, want 4: %v", len(visible), visible)
|
||
}
|
||
}
|
||
|
||
func TestFilteredSkills(t *testing.T) {
|
||
skills := makeTestSkills()
|
||
p := &skillPicker{skills: skills, query: "review"}
|
||
filtered := p.filteredSkills()
|
||
if len(filtered) != 1 || filtered[0].Name != "review" {
|
||
t.Fatalf("filteredSkills(review) = %v", filtered)
|
||
}
|
||
|
||
p.query = "code"
|
||
filtered = p.filteredSkills()
|
||
if len(filtered) != 1 || filtered[0].Name != "review" {
|
||
t.Fatalf("filteredSkills(code) should match description: %v", filtered)
|
||
}
|
||
|
||
p.query = "zzz"
|
||
filtered = p.filteredSkills()
|
||
if len(filtered) != 0 {
|
||
t.Fatalf("filteredSkills(zzz) should be empty: %v", filtered)
|
||
}
|
||
|
||
p.query = ""
|
||
filtered = p.filteredSkills()
|
||
if len(filtered) != 3 {
|
||
t.Fatalf("filteredSkills(empty) should return all: %v", filtered)
|
||
}
|
||
}
|
||
|
||
func TestSkillPickerSummaryDefault(t *testing.T) {
|
||
skills := makeTestSkills()
|
||
p := &skillPicker{skills: skills}
|
||
s := skillPickerSummary(p)
|
||
if !strings.Contains(s, "available") && !strings.Contains(s, "可用") {
|
||
t.Fatalf("summary missing 'available': %q", s)
|
||
}
|
||
if !strings.Contains(s, "project") && !strings.Contains(s, "项目") {
|
||
t.Fatalf("summary missing project count: %q", s)
|
||
}
|
||
if !strings.Contains(s, "builtin") && !strings.Contains(s, "内置") {
|
||
t.Fatalf("summary missing builtin count: %q", s)
|
||
}
|
||
}
|
||
|
||
func TestSkillPickerSummarySearch(t *testing.T) {
|
||
skills := makeTestSkills()
|
||
p := &skillPicker{skills: skills, searchActive: true, query: "rev"}
|
||
s := skillPickerSummary(p)
|
||
if !strings.Contains(s, "matching") && !strings.Contains(s, "匹配") {
|
||
t.Fatalf("search summary missing 'matching': %q", s)
|
||
}
|
||
// Should mention total count.
|
||
if !strings.Contains(s, "3") {
|
||
t.Fatalf("search summary missing total count: %q", s)
|
||
}
|
||
}
|
||
|
||
func TestSkillSourceSummary(t *testing.T) {
|
||
roots := []skillRootLine{
|
||
{dir: "/a", skills: 2},
|
||
{dir: "/b", skills: 1},
|
||
{dir: "/c", skills: 0},
|
||
}
|
||
s := skillSourceSummary(roots)
|
||
if !strings.Contains(s, "active") && !strings.Contains(s, "有效") {
|
||
t.Fatalf("source summary missing 'active': %q", s)
|
||
}
|
||
|
||
empty := skillSourceSummary([]skillRootLine{{dir: "/x", skills: 0}})
|
||
if empty != "" {
|
||
t.Fatalf("source summary with no active roots should be empty: %q", empty)
|
||
}
|
||
}
|
||
|
||
func TestSkillPickerEscCloses(t *testing.T) {
|
||
skills := makeTestSkills()
|
||
m := chatTUI{
|
||
width: 80,
|
||
skills: skills,
|
||
skillPick: &skillPicker{
|
||
mode: pickerSkills,
|
||
skills: skills,
|
||
},
|
||
}
|
||
|
||
next, _ := m.handleSkillPickerKey(tea.KeyPressMsg{Code: 27}) // Esc
|
||
cm := next.(chatTUI)
|
||
if cm.skillPick != nil {
|
||
t.Fatal("Esc did not close skill picker")
|
||
}
|
||
}
|
||
|
||
func TestSkillPickerSearchEscExitsSearch(t *testing.T) {
|
||
skills := makeTestSkills()
|
||
m := chatTUI{
|
||
width: 80,
|
||
skills: skills,
|
||
skillPick: &skillPicker{
|
||
mode: pickerSkills,
|
||
skills: skills,
|
||
searchActive: true,
|
||
query: "rev",
|
||
},
|
||
}
|
||
|
||
next, _ := m.handleSkillPickerKey(tea.KeyPressMsg{Code: 27}) // Esc
|
||
cm := next.(chatTUI)
|
||
if cm.skillPick == nil {
|
||
t.Fatal("Esc closed picker instead of exiting search")
|
||
}
|
||
if cm.skillPick.searchActive {
|
||
t.Fatal("Esc did not exit search mode")
|
||
}
|
||
}
|
||
|
||
func TestSkillPickerSSwitchesToSources(t *testing.T) {
|
||
skills := makeTestSkills()
|
||
m := chatTUI{
|
||
width: 80,
|
||
skills: skills,
|
||
skillPick: &skillPicker{
|
||
mode: pickerSkills,
|
||
skills: skills,
|
||
},
|
||
}
|
||
|
||
next, _ := m.handleSkillPickerKey(tea.KeyPressMsg{Code: 's'})
|
||
cm := next.(chatTUI)
|
||
if cm.skillPick.mode != pickerSources {
|
||
t.Fatalf("s did not switch to source view, mode=%s", cm.skillPick.mode)
|
||
}
|
||
}
|
||
|
||
func TestSkillPickerSourceEnterShowsRootSkills(t *testing.T) {
|
||
skills := makeTestSkills()
|
||
m := chatTUI{
|
||
width: 80,
|
||
skills: skills,
|
||
skillPick: &skillPicker{
|
||
mode: pickerSources,
|
||
skills: skills,
|
||
roots: []skillRootLine{
|
||
{dir: "/fake/proj/.reasonix/skills", scope: skill.ScopeProject, status: skill.StatusOK, skills: 2, diagnostic: true},
|
||
},
|
||
},
|
||
}
|
||
|
||
next, _ := m.handleSkillPickerKey(tea.KeyPressMsg{Code: tea.KeyEnter})
|
||
cm := next.(chatTUI)
|
||
if cm.skillPick.mode != pickerSourceSkills {
|
||
t.Fatalf("Enter did not open source skill list, mode=%s", cm.skillPick.mode)
|
||
}
|
||
out := cm.renderSkillPicker()
|
||
if !strings.Contains(out, "review") || !strings.Contains(out, "test") {
|
||
t.Fatalf("source skill list missing project skills:\n%s", out)
|
||
}
|
||
if strings.Contains(out, "explore") {
|
||
t.Fatalf("source skill list should not include builtin skill:\n%s", out)
|
||
}
|
||
}
|
||
|
||
func TestSkillPickerSpaceTogglesEnabled(t *testing.T) {
|
||
skills := makeTestSkills()
|
||
m := chatTUI{
|
||
width: 80,
|
||
skills: skills,
|
||
skillPick: &skillPicker{
|
||
mode: pickerSkills,
|
||
skills: skills,
|
||
sel: 0,
|
||
enabled: map[string]bool{"review": true},
|
||
originalEnabled: map[string]bool{"review": true},
|
||
},
|
||
}
|
||
|
||
// Space toggles the selected skill off.
|
||
next, _ := m.handleSkillPickerKey(tea.KeyPressMsg{Code: ' '})
|
||
cm := next.(chatTUI)
|
||
if cm.skillPick.skillEnabled("review") {
|
||
t.Fatal("Space did not disable the selected skill")
|
||
}
|
||
|
||
// Space toggles it back on.
|
||
next2, _ := cm.handleSkillPickerKey(tea.KeyPressMsg{Code: ' '})
|
||
cm2 := next2.(chatTUI)
|
||
if !cm2.skillPick.skillEnabled("review") {
|
||
t.Fatal("second Space did not enable the selected skill")
|
||
}
|
||
}
|
||
|
||
func TestSkillPickerDetailDeleteRequiresConfirmation(t *testing.T) {
|
||
dir := t.TempDir()
|
||
path := filepath.Join(dir, "review", skill.SkillFile)
|
||
if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
if err := os.WriteFile(path, []byte("# Review"), 0o644); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
skills := []skill.Skill{
|
||
{Name: "review", Description: "Review code", Scope: skill.ScopeProject, Path: path, RunAs: skill.RunSubagent, Body: "# Review"},
|
||
}
|
||
p := &skillPicker{
|
||
mode: pickerDetail,
|
||
skills: skills,
|
||
detailSkill: skills[0],
|
||
detailBack: pickerSkills,
|
||
detailAction: 1,
|
||
}
|
||
m := chatTUI{width: 80, skills: skills, skillPick: p}
|
||
|
||
next, _ := m.handleSkillPickerKey(tea.KeyPressMsg{Code: tea.KeyEnter})
|
||
cm := next.(chatTUI)
|
||
if cm.skillPick.mode != pickerConfirmDelete {
|
||
t.Fatalf("delete action should open confirmation, mode=%s", cm.skillPick.mode)
|
||
}
|
||
if cm.skillPick.confirm != 1 {
|
||
t.Fatalf("delete confirmation should default to cancel, got %d", cm.skillPick.confirm)
|
||
}
|
||
}
|
||
|
||
func TestSkillPickerDetailShowsActionsBeforeBodyPreview(t *testing.T) {
|
||
s := skill.Skill{
|
||
Name: "review",
|
||
Description: "Review code",
|
||
Scope: skill.ScopeProject,
|
||
Path: "/proj/.reasonix/skills/review/SKILL.md",
|
||
RunAs: skill.RunSubagent,
|
||
Body: "# Review\n\n" + strings.Repeat("BODY_LINE\n", 40),
|
||
}
|
||
m := chatTUI{
|
||
width: 80,
|
||
skills: []skill.Skill{s},
|
||
skillPick: &skillPicker{
|
||
mode: pickerDetail,
|
||
skills: []skill.Skill{s},
|
||
detailSkill: s,
|
||
enabled: map[string]bool{s.Name: true},
|
||
originalEnabled: map[string]bool{s.Name: true},
|
||
},
|
||
}
|
||
|
||
out := m.renderSkillPickerDetail()
|
||
actionAt := strings.Index(out, i18n.M.SkillPickerActionToggle)
|
||
bodyAt := strings.Index(out, "BODY_LINE")
|
||
if actionAt < 0 {
|
||
t.Fatalf("detail missing action row:\n%s", out)
|
||
}
|
||
if bodyAt < 0 {
|
||
t.Fatalf("detail missing body preview:\n%s", out)
|
||
}
|
||
if actionAt > bodyAt {
|
||
t.Fatalf("detail action should render before body preview:\n%s", out)
|
||
}
|
||
}
|
||
|
||
func TestDeleteSkillPickRemovesDirectoryTarget(t *testing.T) {
|
||
dir := t.TempDir()
|
||
path := filepath.Join(dir, "review", skill.SkillFile)
|
||
targetDir := filepath.Dir(path)
|
||
if err := os.MkdirAll(targetDir, 0o755); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
if err := os.WriteFile(path, []byte("# Review"), 0o644); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
s := skill.Skill{Name: "review", Scope: skill.ScopeProject, Path: path, RunAs: skill.RunSubagent, Body: "# Review"}
|
||
m := newTestChatTUI()
|
||
m.skills = []skill.Skill{s}
|
||
m.skillPick = &skillPicker{
|
||
mode: pickerConfirmDelete,
|
||
skills: []skill.Skill{s},
|
||
deleteSkill: s,
|
||
enabled: map[string]bool{s.Name: true},
|
||
originalEnabled: map[string]bool{s.Name: true},
|
||
}
|
||
|
||
next, _ := m.deleteSkillPick(s)
|
||
cm := next.(chatTUI)
|
||
if _, err := os.Stat(targetDir); !os.IsNotExist(err) {
|
||
t.Fatalf("deleteSkillPick target still exists or unexpected error: %v", err)
|
||
}
|
||
if cm.skillPick == nil || cm.skillPick.mode != pickerSkills {
|
||
t.Fatalf("delete should return to skills list, picker=%v", cm.skillPick)
|
||
}
|
||
}
|
||
|
||
func TestSkillDeleteTargetDirectoryAndFlatFile(t *testing.T) {
|
||
dir := t.TempDir()
|
||
nested := filepath.Join(dir, "review", skill.SkillFile)
|
||
if err := os.MkdirAll(filepath.Dir(nested), 0o755); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
if err := os.WriteFile(nested, []byte("# Review"), 0o644); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
target, ok, err := skillDeleteTarget(skill.Skill{Name: "review", Scope: skill.ScopeProject, Path: nested})
|
||
if err != nil || !ok {
|
||
t.Fatalf("skillDeleteTarget directory = %q %v %v", target, ok, err)
|
||
}
|
||
if target != filepath.Dir(nested) {
|
||
t.Fatalf("directory target = %q, want %q", target, filepath.Dir(nested))
|
||
}
|
||
|
||
flat := filepath.Join(dir, "flat.md")
|
||
if err := os.WriteFile(flat, []byte("# Flat"), 0o644); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
target, ok, err = skillDeleteTarget(skill.Skill{Name: "flat", Scope: skill.ScopeProject, Path: flat})
|
||
if err != nil || !ok {
|
||
t.Fatalf("skillDeleteTarget flat = %q %v %v", target, ok, err)
|
||
}
|
||
if target != flat {
|
||
t.Fatalf("flat target = %q, want %q", target, flat)
|
||
}
|
||
|
||
if _, ok, err := skillDeleteTarget(skill.Skill{Name: "explore", Scope: skill.ScopeBuiltin, Path: "(builtin)"}); err != nil || ok {
|
||
t.Fatalf("builtin target ok=%v err=%v, want not removable", ok, err)
|
||
}
|
||
}
|
||
|
||
func TestClampSel(t *testing.T) {
|
||
items := []int{10, 20, 30}
|
||
if got := clampSel(0, items); got != 0 {
|
||
t.Fatalf("clampSel(0) = %d", got)
|
||
}
|
||
if got := clampSel(2, items); got != 2 {
|
||
t.Fatalf("clampSel(2) = %d", got)
|
||
}
|
||
if got := clampSel(5, items); got != 2 {
|
||
t.Fatalf("clampSel(5) = %d, want 2", got)
|
||
}
|
||
if got := clampSel(-1, items); got != 0 {
|
||
t.Fatalf("clampSel(-1) = %d, want 0", got)
|
||
}
|
||
if got := clampSel(0, []int{}); got != 0 {
|
||
t.Fatalf("clampSel(0, []) = %d, want 0", got)
|
||
}
|
||
}
|
||
|
||
func TestSkillRowLabelHasSubagentTag(t *testing.T) {
|
||
s := skill.Skill{Name: "review", Description: "Review code", Scope: skill.ScopeProject, RunAs: skill.RunSubagent}
|
||
row := renderSkillRow(1, false, s, true, 80)
|
||
if !strings.Contains(row, "subagent") && !strings.Contains(row, "子代理") {
|
||
t.Fatalf("subagent skill missing tag: %q", row)
|
||
}
|
||
if !strings.Contains(row, "review") {
|
||
t.Fatalf("missing skill name: %q", row)
|
||
}
|
||
}
|
||
|
||
func TestRenderSkillRowSelected(t *testing.T) {
|
||
s := skill.Skill{Name: "test", Description: "A test skill", Scope: skill.ScopeGlobal, RunAs: skill.RunInline}
|
||
row := renderSkillRow(5, true, s, true, 80)
|
||
if !strings.Contains(row, "›") {
|
||
t.Fatalf("selected row missing arrow: %q", row)
|
||
}
|
||
// Selected row differs from unselected: has arrow, no dim prefix.
|
||
unsel := renderSkillRow(5, false, s, true, 80)
|
||
if row == unsel {
|
||
t.Fatal("selected and unselected rows should differ")
|
||
}
|
||
}
|
||
|
||
func TestRenderSkillRowScopeMeta(t *testing.T) {
|
||
s := skill.Skill{Name: "example", Description: "desc", Scope: skill.ScopeGlobal, RunAs: skill.RunInline}
|
||
row := renderSkillRow(1, false, s, true, 80)
|
||
if !strings.Contains(row, "global") && !strings.Contains(row, "全局") {
|
||
t.Fatalf("row missing scope label: %q", row)
|
||
}
|
||
if !strings.Contains(row, "tok") {
|
||
t.Fatalf("row missing approximate token count: %q", row)
|
||
}
|
||
}
|
||
|
||
func TestRenderSkillRowLongNameTruncated(t *testing.T) {
|
||
s := skill.Skill{
|
||
Name: "this-is-a-very-long-skill-name-that-exceeds-26-chars",
|
||
Description: "desc",
|
||
Scope: skill.ScopeBuiltin,
|
||
}
|
||
row := renderSkillRow(1, false, s, true, 80)
|
||
if !strings.Contains(row, "…") {
|
||
t.Fatalf("long name not truncated with …: %q", row)
|
||
}
|
||
}
|
||
|
||
func TestRenderSkillRowChineseBadgeFitsWidth(t *testing.T) {
|
||
i18n.DetectLanguage("zh")
|
||
t.Cleanup(func() { i18n.DetectLanguage("en") })
|
||
|
||
s := skill.Skill{
|
||
Name: "browser-testing-with-devtools",
|
||
Description: "Tests in real browsers. Use when building or debugging anything that runs in a browser.",
|
||
Scope: skill.ScopeGlobal,
|
||
RunAs: skill.RunSubagent,
|
||
}
|
||
row := renderSkillRow(13, true, s, true, 80)
|
||
if got := visibleWidth(row); got > 80 {
|
||
t.Fatalf("row visible width = %d, want <= 80:\n%q", got, row)
|
||
}
|
||
if strings.Contains(row, "\n") {
|
||
t.Fatalf("row should stay single-line: %q", row)
|
||
}
|
||
}
|
||
|
||
func TestSortedSkills(t *testing.T) {
|
||
skills := []skill.Skill{
|
||
{Name: "z-builtin", Scope: skill.ScopeBuiltin},
|
||
{Name: "a-project", Scope: skill.ScopeProject},
|
||
{Name: "b-project", Scope: skill.ScopeProject},
|
||
{Name: "c-global", Scope: skill.ScopeGlobal},
|
||
{Name: "d-custom", Scope: skill.ScopeCustom},
|
||
}
|
||
sorted := sortedSkills(skills)
|
||
// Project first, then custom, global, builtin; alphabetical within.
|
||
want := []string{"a-project", "b-project", "d-custom", "c-global", "z-builtin"}
|
||
for i, s := range sorted {
|
||
if i >= len(want) || s.Name != want[i] {
|
||
t.Fatalf("sorted[%d] = %s, want %s", i, s.Name, want[i])
|
||
}
|
||
}
|
||
}
|
||
|
||
func TestSkillPickerRendersInMainArea(t *testing.T) {
|
||
m := newTestChatTUI()
|
||
m.width = 80
|
||
m.height = 40
|
||
m.skillPick = &skillPicker{
|
||
mode: pickerSkills,
|
||
skills: []skill.Skill{
|
||
{Name: "a", Description: "desc", Scope: skill.ScopeBuiltin},
|
||
{Name: "b", Description: "desc", Scope: skill.ScopeBuiltin},
|
||
{Name: "c", Description: "desc", Scope: skill.ScopeBuiltin},
|
||
},
|
||
}
|
||
|
||
rows := m.bottomRows()
|
||
footerRows := strings.Count(m.renderMainManagerFooter(), "\n") + 1
|
||
if want := footerRows + 2; rows != want {
|
||
t.Fatalf("bottomRows with skill picker open got %d, want %d (footer + status rows)", rows, want)
|
||
}
|
||
if !m.hideComposer() {
|
||
t.Fatal("skill picker should hide the composer")
|
||
}
|
||
if out := m.renderMainManager(); !strings.Contains(out, "Manage skills") {
|
||
t.Fatalf("skill picker should render as a main manager:\n%s", out)
|
||
}
|
||
}
|
||
|
||
func TestBottomRowsIncludesResumePicker(t *testing.T) {
|
||
m := newTestChatTUI()
|
||
m.width = 80
|
||
m.height = 40
|
||
m.resumePick = &resumePicker{
|
||
sessions: nil,
|
||
sel: 0,
|
||
active: -1,
|
||
}
|
||
|
||
// Not testing exact row count (resumePicker needs sessions for rendering),
|
||
// just verifying that bottomRows doesn't panic and returns a non-zero value.
|
||
rows := m.bottomRows()
|
||
if rows < 3 {
|
||
t.Fatalf("bottomRows with resume picker got %d", rows)
|
||
}
|
||
}
|
||
|
||
func TestRescanInSearchModeClampsToFiltered(t *testing.T) {
|
||
skills := []skill.Skill{
|
||
{Name: "alpha", Description: "first", Scope: skill.ScopeBuiltin},
|
||
{Name: "beta", Description: "second", Scope: skill.ScopeBuiltin},
|
||
{Name: "gamma", Description: "third", Scope: skill.ScopeBuiltin},
|
||
}
|
||
p := &skillPicker{
|
||
mode: pickerSkills,
|
||
skills: skills,
|
||
searchActive: true,
|
||
query: "beta",
|
||
sel: 2, // beyond filtered results (only "beta" matches)
|
||
}
|
||
p.sel = clampSel(p.sel, skills) // simulating old behavior
|
||
|
||
// Fix: clamp to filtered when search is active.
|
||
if p.searchActive && p.query != "" {
|
||
p.sel = clampSel(p.sel, p.filteredSkills())
|
||
}
|
||
if p.sel != 0 {
|
||
t.Fatalf("sel after clamp to filtered should be 0, got %d", p.sel)
|
||
}
|
||
}
|
||
|
||
func TestPathBoundaryMatching(t *testing.T) {
|
||
skills := []skill.Skill{
|
||
{Name: "alpha", Scope: skill.ScopeProject, Path: "/proj/.reasonix/skills/alpha/SKILL.md"},
|
||
{Name: "beta", Scope: skill.ScopeProject, Path: "/proj/.reasonix/skills-extra/beta/SKILL.md"},
|
||
}
|
||
lines := []skillRootLine{
|
||
{dir: "/proj/.reasonix/skills", scope: skill.ScopeProject, status: skill.StatusOK},
|
||
{dir: "/proj/.reasonix/skills-extra", scope: skill.ScopeProject, status: skill.StatusOK},
|
||
}
|
||
|
||
// Count skills per root with directory-boundary match.
|
||
for _, s := range skills {
|
||
if s.Scope == skill.ScopeBuiltin {
|
||
continue
|
||
}
|
||
cleanPath := filepath.Clean(s.Path)
|
||
for i := range lines {
|
||
if lines[i].scope != s.Scope {
|
||
continue
|
||
}
|
||
prefix := filepath.Clean(lines[i].dir) + string(filepath.Separator)
|
||
if strings.HasPrefix(cleanPath, prefix) {
|
||
lines[i].skills++
|
||
break
|
||
}
|
||
}
|
||
}
|
||
|
||
if lines[0].skills != 1 {
|
||
t.Fatalf("/skills root should have 1 skill, got %d", lines[0].skills)
|
||
}
|
||
if lines[1].skills != 1 {
|
||
t.Fatalf("/skills-extra root should have 1 skill, got %d", lines[1].skills)
|
||
}
|
||
}
|
||
|
||
func TestSourceRowLabelUsesI18n(t *testing.T) {
|
||
i18n.DetectLanguage("zh")
|
||
t.Cleanup(func() { i18n.DetectLanguage("en") })
|
||
|
||
r := skillRootLine{
|
||
dir: "/proj/.reasonix/skills",
|
||
scope: skill.ScopeProject,
|
||
status: skill.StatusOK,
|
||
skills: 3,
|
||
}
|
||
label := sourceRowLabel(r, 80)
|
||
if !strings.Contains(label, "项目") || strings.Contains(label, "project") {
|
||
t.Fatalf("source row should use localized scope label, got %q", label)
|
||
}
|
||
// Check that skills unit is used
|
||
if !strings.Contains(label, "skills") && !strings.Contains(label, "skill") {
|
||
t.Fatalf("source row missing skills unit: %q", label)
|
||
}
|
||
}
|
||
|
||
func TestStatusLabelI18n(t *testing.T) {
|
||
if l := statusLabel(skill.StatusOK); l == "" {
|
||
t.Fatal("statusLabel(ok) empty")
|
||
}
|
||
if l := statusLabel(skill.StatusMissing); l == "" {
|
||
t.Fatal("statusLabel(missing) empty")
|
||
}
|
||
if l := statusLabel(skill.StatusNotDirectory); l == "" {
|
||
t.Fatal("statusLabel(not-directory) empty")
|
||
}
|
||
if l := statusLabel(skill.StatusUnreadable); l == "" {
|
||
t.Fatal("statusLabel(unreadable) empty")
|
||
}
|
||
// Unknown status falls back to raw string.
|
||
if l := statusLabel(skill.PathStatus("custom-status")); l != "custom-status" {
|
||
t.Fatalf("statusLabel(unknown) = %q, want 'custom-status'", l)
|
||
}
|
||
}
|
||
|
||
func TestRenderSkillDetailUsesI18nMeta(t *testing.T) {
|
||
s := skill.Skill{
|
||
Name: "review",
|
||
Description: "Review code",
|
||
Scope: skill.ScopeProject,
|
||
Path: "/proj/.reasonix/skills/review/SKILL.md",
|
||
RunAs: skill.RunSubagent,
|
||
Body: "# Review\n\nLine 1\nLine 2",
|
||
}
|
||
out := renderSkillDetail(s, 80)
|
||
// Detail should use i18n meta format (not raw "Scope:" when in Chinese).
|
||
if !strings.Contains(out, "Scope") && !strings.Contains(out, "范围") {
|
||
t.Fatalf("detail missing scope label:\n%s", out)
|
||
}
|
||
if !strings.Contains(out, "Run as") && !strings.Contains(out, "运行") {
|
||
t.Fatalf("detail missing run-as label:\n%s", out)
|
||
}
|
||
}
|
||
|
||
func TestLegacySkillShowUnchanged(t *testing.T) {
|
||
s := skill.Skill{
|
||
Name: "my-skill",
|
||
Description: "A test skill",
|
||
Scope: skill.ScopeProject,
|
||
Path: "/fake/proj/.reasonix/skills/my-skill.md",
|
||
Body: "# My Skill\n\nSome body text.",
|
||
}
|
||
out := renderSkillShow(80, s, false)
|
||
if !strings.Contains(out, "skill:") && !strings.Contains(out, "my-skill") {
|
||
t.Fatalf("legacy skill show broken:\n%s", out)
|
||
}
|
||
}
|
||
|
||
func TestLegacySkillPathsUnchanged(t *testing.T) {
|
||
roots := []skill.Root{
|
||
{Dir: "/proj/.reasonix/skills", Scope: skill.ScopeProject, Priority: 0, Status: skill.StatusOK},
|
||
}
|
||
out := renderSkillPaths(80, roots)
|
||
if !strings.Contains(out, "skill paths") {
|
||
t.Fatalf("legacy skill paths broken:\n%s", out)
|
||
}
|
||
}
|
||
|
||
func TestSkillPickerRenderWidthNarrow(t *testing.T) {
|
||
skills := makeTestSkills()
|
||
m := chatTUI{
|
||
width: 30,
|
||
skills: skills,
|
||
skillPick: &skillPicker{
|
||
mode: pickerSkills,
|
||
skills: skills,
|
||
},
|
||
}
|
||
|
||
out := m.renderSkillPicker()
|
||
if out == "" {
|
||
t.Fatal("narrow render returned empty")
|
||
}
|
||
if !strings.Contains(out, "Manage skills") {
|
||
t.Fatalf("narrow render missing title:\n%s", out)
|
||
}
|
||
}
|