feat(capability/skills): 可复用工作流技能（Skill 模型 + Store + YAML Loader + Runner 展开 + 注册）
This commit is contained in:
Aska committed
1 parent
d947ec41a9
commit
915aa8a100
10 files changed
+1235
No files matched your search
@@ -0,0 +1,68 @@
|
||||
package skills
|
||||
|
||||
import (
|
||||
"context"
|
||||
"io"
|
||||
"log/slog"
|
||||
"os"
|
||||
"testing"
|
||||
|
||||
"git.yeij.top/AskaEth/Cyrene_v2/internal/db"
|
||||
"git.yeij.top/AskaEth/Cyrene_v2/pkg/plugins/sdk"
|
||||
)
|
||||
|
||||
// testLogger returns a logger that writes nowhere, keeping test output clean.
|
||||
func testLogger() *slog.Logger {
|
||||
return slog.New(slog.NewTextHandler(io.Discard, nil))
|
||||
}
|
||||
|
||||
// makeSkill builds a deterministic skill populated with one step, one ref, and
|
||||
// one guardrail, so tests can assert the full round trip.
|
||||
func makeSkill(t *testing.T, name string) *Skill {
|
||||
t.Helper()
|
||||
sk, err := New(name, "desc "+name, "prompt "+name,
|
||||
[]sdk.Step{{Name: "s1", Prompt: "step prompt"}},
|
||||
[]sdk.Ref{{Name: "r1", Type: "tool", Value: "v1", Optional: false}},
|
||||
[]sdk.Guardrail{{ID: "g1", Message: "msg", Enforced: true}},
|
||||
)
|
||||
if err != nil {
|
||||
t.Fatalf("New(%q): %v", name, err)
|
||||
}
|
||||
return sk
|
||||
}
|
||||
|
||||
// mockSkill is a minimal sdk.Skill used to feed invalid inputs (blank name) and
|
||||
// to exercise the store's generic sdk.Skill handling.
|
||||
type mockSkill struct{ name string }
|
||||
|
||||
func (m mockSkill) Name() string { return m.name }
|
||||
func (m mockSkill) Description() string { return "desc" }
|
||||
func (m mockSkill) Prompt() string { return "prompt" }
|
||||
func (m mockSkill) Steps() []sdk.Step { return nil }
|
||||
func (m mockSkill) Refs() []sdk.Ref { return nil }
|
||||
func (m mockSkill) Guardrails() []sdk.Guardrail { return nil }
|
||||
|
||||
// newTestStore opens an isolated in-memory SQLite database and builds a Store
|
||||
// over it. It is cleaned up when the test finishes.
|
||||
func newTestStore(t *testing.T) *Store {
|
||||
t.Helper()
|
||||
ctx := context.Background()
|
||||
database, err := db.Open(ctx, ":memory:", testLogger())
|
||||
if err != nil {
|
||||
t.Fatalf("db.Open(:memory:): %v", err)
|
||||
}
|
||||
t.Cleanup(func() { _ = database.Close() })
|
||||
store, err := NewStore(ctx, database, testLogger())
|
||||
if err != nil {
|
||||
t.Fatalf("NewStore: %v", err)
|
||||
}
|
||||
return store
|
||||
}
|
||||
|
||||
// writeFile writes content to path, failing the test on error.
|
||||
func writeFile(t *testing.T, path, content string) {
|
||||
t.Helper()
|
||||
if err := os.WriteFile(path, []byte(content), 0o644); err != nil {
|
||||
t.Fatalf("write %s: %v", path, err)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,135 @@
|
||||
package skills
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"io"
|
||||
"log/slog"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"strings"
|
||||
|
||||
"gopkg.in/yaml.v3"
|
||||
|
||||
"git.yeij.top/AskaEth/Cyrene_v2/pkg/plugins/sdk"
|
||||
)
|
||||
|
||||
// Loader loads Skill definitions from YAML — a single stream (Load), a file
|
||||
// (LoadFile), or a directory of configs/skills/*.yaml files (LoadDir). It does
|
||||
// not persist; persist via Store or publish via Register.
|
||||
type Loader struct {
|
||||
log *slog.Logger
|
||||
}
|
||||
|
||||
// NewLoader builds a Loader. log may be nil.
|
||||
func NewLoader(log *slog.Logger) *Loader {
|
||||
return &Loader{log: sourcedLog(log)}
|
||||
}
|
||||
|
||||
// skillYAML is the on-disk YAML shape of a skill.
|
||||
type skillYAML struct {
|
||||
Name string `yaml:"name"`
|
||||
Description string `yaml:"description"`
|
||||
Prompt string `yaml:"prompt"`
|
||||
Steps []yamlStep `yaml:"steps"`
|
||||
Refs []yamlRef `yaml:"refs"`
|
||||
Guardrails []yamlGuardrail `yaml:"guardrails"`
|
||||
}
|
||||
|
||||
type yamlStep struct {
|
||||
Name string `yaml:"name"`
|
||||
Prompt string `yaml:"prompt"`
|
||||
Depends []string `yaml:"depends"`
|
||||
}
|
||||
|
||||
type yamlRef struct {
|
||||
Name string `yaml:"name"`
|
||||
Type string `yaml:"type"`
|
||||
Value string `yaml:"value"`
|
||||
Optional bool `yaml:"optional"`
|
||||
}
|
||||
|
||||
type yamlGuardrail struct {
|
||||
ID string `yaml:"id"`
|
||||
Message string `yaml:"message"`
|
||||
Enforced bool `yaml:"enforced"`
|
||||
}
|
||||
|
||||
// Load parses one skill from r. It returns ErrInvalidSkill when the document has
|
||||
// a blank name.
|
||||
func (l *Loader) Load(r io.Reader) (*Skill, error) {
|
||||
if r == nil {
|
||||
return nil, fmt.Errorf("skills: loader: load: %w", ErrInvalidSkill)
|
||||
}
|
||||
var doc skillYAML
|
||||
if err := yaml.NewDecoder(r).Decode(&doc); err != nil {
|
||||
return nil, fmt.Errorf("skills: loader: decode: %w", err)
|
||||
}
|
||||
skill, err := doc.toSkill()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
l.log.Info("skill loaded", "skill", skill.Name())
|
||||
return skill, nil
|
||||
}
|
||||
|
||||
// LoadFile loads the single skill YAML file at path.
|
||||
func (l *Loader) LoadFile(path string) (*Skill, error) {
|
||||
f, err := os.Open(path)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("skills: loader: open %q: %w", path, err)
|
||||
}
|
||||
defer f.Close()
|
||||
skill, err := l.Load(f)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("skills: loader: file %q: %w", path, err)
|
||||
}
|
||||
return skill, nil
|
||||
}
|
||||
|
||||
// LoadDir loads every *.yaml/*.yml skill file in dir, in readdir order. A file
|
||||
// that fails to parse stops the load. Non-YAML files are skipped.
|
||||
func (l *Loader) LoadDir(dir string) ([]*Skill, error) {
|
||||
entries, err := os.ReadDir(dir)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("skills: loader: read dir %q: %w", dir, err)
|
||||
}
|
||||
out := make([]*Skill, 0, len(entries))
|
||||
for _, e := range entries {
|
||||
if e.IsDir() || !isYAML(e.Name()) {
|
||||
continue
|
||||
}
|
||||
path := filepath.Join(dir, e.Name())
|
||||
skill, err := l.LoadFile(path)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("skills: loader: dir %q: %w", path, err)
|
||||
}
|
||||
out = append(out, skill)
|
||||
}
|
||||
return out, nil
|
||||
}
|
||||
|
||||
// toSkill converts the YAML document into a Skill, validating the required name.
|
||||
func (d skillYAML) toSkill() (*Skill, error) {
|
||||
steps := make([]sdk.Step, 0, len(d.Steps))
|
||||
for _, st := range d.Steps {
|
||||
steps = append(steps, sdk.Step{Name: st.Name, Prompt: st.Prompt, Depends: st.Depends})
|
||||
}
|
||||
refs := make([]sdk.Ref, 0, len(d.Refs))
|
||||
for _, rf := range d.Refs {
|
||||
refs = append(refs, sdk.Ref{Name: rf.Name, Type: rf.Type, Value: rf.Value, Optional: rf.Optional})
|
||||
}
|
||||
guardrails := make([]sdk.Guardrail, 0, len(d.Guardrails))
|
||||
for _, g := range d.Guardrails {
|
||||
guardrails = append(guardrails, sdk.Guardrail{ID: g.ID, Message: g.Message, Enforced: g.Enforced})
|
||||
}
|
||||
skill, err := New(d.Name, d.Description, d.Prompt, steps, refs, guardrails)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("skills: loader: invalid skill %q: %w", d.Name, err)
|
||||
}
|
||||
return skill, nil
|
||||
}
|
||||
|
||||
func isYAML(name string) bool {
|
||||
lower := strings.ToLower(name)
|
||||
return strings.HasSuffix(lower, ".yaml") || strings.HasSuffix(lower, ".yml")
|
||||
}
|
||||
@@ -0,0 +1,176 @@
|
||||
package skills
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"path/filepath"
|
||||
"strings"
|
||||
"testing"
|
||||
)
|
||||
|
||||
const validSkillYAML = `
|
||||
name: daily-brief
|
||||
description: Morning briefing
|
||||
prompt: You are a briefing assistant.
|
||||
steps:
|
||||
- name: collect
|
||||
prompt: Gather data
|
||||
depends: []
|
||||
- name: summarize
|
||||
prompt: Summarize the picks
|
||||
depends: [collect]
|
||||
refs:
|
||||
- name: calendar
|
||||
type: tool
|
||||
value: calendar-tool
|
||||
optional: false
|
||||
guardrails:
|
||||
- id: no-pii
|
||||
message: Never output PII
|
||||
enforced: true
|
||||
`
|
||||
|
||||
func TestLoader_Load_正常(t *testing.T) {
|
||||
t.Parallel()
|
||||
l := NewLoader(testLogger())
|
||||
sk, err := l.Load(strings.NewReader(validSkillYAML))
|
||||
if err != nil {
|
||||
t.Fatalf("Load: %v", err)
|
||||
}
|
||||
if sk.Name() != "daily-brief" {
|
||||
t.Fatalf("Name = %q, want daily-brief", sk.Name())
|
||||
}
|
||||
if sk.Description() != "Morning briefing" {
|
||||
t.Fatalf("Description = %q, want Morning briefing", sk.Description())
|
||||
}
|
||||
if sk.Prompt() != "You are a briefing assistant." {
|
||||
t.Fatalf("Prompt = %q, want base prompt", sk.Prompt())
|
||||
}
|
||||
steps := sk.Steps()
|
||||
if len(steps) != 2 {
|
||||
t.Fatalf("Steps length = %d, want 2", len(steps))
|
||||
}
|
||||
if steps[0].Name != "collect" || steps[0].Prompt != "Gather data" {
|
||||
t.Fatalf("Steps[0] = %+v, want collect/Gather data", steps[0])
|
||||
}
|
||||
if len(steps[0].Depends) != 0 {
|
||||
t.Fatalf("Steps[0].Depends = %+v, want empty", steps[0].Depends)
|
||||
}
|
||||
if steps[1].Name != "summarize" || len(steps[1].Depends) != 1 || steps[1].Depends[0] != "collect" {
|
||||
t.Fatalf("Steps[1] = %+v, want summarize depending on collect", steps[1])
|
||||
}
|
||||
refs := sk.Refs()
|
||||
if len(refs) != 1 || refs[0].Name != "calendar" || refs[0].Type != "tool" || refs[0].Value != "calendar-tool" || refs[0].Optional {
|
||||
t.Fatalf("Refs = %+v, want calendar/tool/calendar-tool/non-optional", refs)
|
||||
}
|
||||
guards := sk.Guardrails()
|
||||
if len(guards) != 1 || guards[0].ID != "no-pii" || guards[0].Message != "Never output PII" || !guards[0].Enforced {
|
||||
t.Fatalf("Guardrails = %+v, want no-pii/Never output PII/enforced", guards)
|
||||
}
|
||||
}
|
||||
|
||||
func TestLoader_Load_MissingName_异常(t *testing.T) {
|
||||
t.Parallel()
|
||||
l := NewLoader(testLogger())
|
||||
src := "description: x\nprompt: y\n"
|
||||
_, err := l.Load(strings.NewReader(src))
|
||||
if !errors.Is(err, ErrInvalidSkill) {
|
||||
t.Fatalf("Load err = %v, want ErrInvalidSkill", err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestLoader_Load_InvalidYAML_异常(t *testing.T) {
|
||||
t.Parallel()
|
||||
l := NewLoader(testLogger())
|
||||
if _, err := l.Load(strings.NewReader("name: [unclosed")); err == nil {
|
||||
t.Fatalf("expected a YAML decode error, got nil")
|
||||
}
|
||||
}
|
||||
|
||||
func TestLoader_Load_NilReader_异常(t *testing.T) {
|
||||
t.Parallel()
|
||||
l := NewLoader(testLogger())
|
||||
if _, err := l.Load(nil); !errors.Is(err, ErrInvalidSkill) {
|
||||
t.Fatalf("Load(nil) err = %v, want ErrInvalidSkill", err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestLoader_LoadFile_正常(t *testing.T) {
|
||||
t.Parallel()
|
||||
path := filepath.Join(t.TempDir(), "skill.yaml")
|
||||
writeFile(t, path, validSkillYAML)
|
||||
l := NewLoader(testLogger())
|
||||
sk, err := l.LoadFile(path)
|
||||
if err != nil {
|
||||
t.Fatalf("LoadFile: %v", err)
|
||||
}
|
||||
if sk.Name() != "daily-brief" {
|
||||
t.Fatalf("Name = %q, want daily-brief", sk.Name())
|
||||
}
|
||||
}
|
||||
|
||||
func TestLoader_LoadFile_Missing_异常(t *testing.T) {
|
||||
t.Parallel()
|
||||
l := NewLoader(testLogger())
|
||||
if _, err := l.LoadFile(filepath.Join(t.TempDir(), "nope.yaml")); err == nil {
|
||||
t.Fatalf("expected error for missing file, got nil")
|
||||
}
|
||||
}
|
||||
|
||||
func TestLoader_LoadDir_正常(t *testing.T) {
|
||||
t.Parallel()
|
||||
dir := t.TempDir()
|
||||
writeFile(t, filepath.Join(dir, "a.yaml"), validSkillYAML)
|
||||
writeFile(t, filepath.Join(dir, "b.yml"), strings.Replace(validSkillYAML, "daily-brief", "code-review", 1))
|
||||
writeFile(t, filepath.Join(dir, "notes.txt"), "not a skill") // skipped
|
||||
|
||||
l := NewLoader(testLogger())
|
||||
got, err := l.LoadDir(dir)
|
||||
if err != nil {
|
||||
t.Fatalf("LoadDir: %v", err)
|
||||
}
|
||||
if len(got) != 2 {
|
||||
t.Fatalf("LoadDir returned %d skills, want 2", len(got))
|
||||
}
|
||||
if got[0].Name() != "daily-brief" || got[1].Name() != "code-review" {
|
||||
t.Fatalf("LoadDir names = %q,%q, want daily-brief,code-review", got[0].Name(), got[1].Name())
|
||||
}
|
||||
}
|
||||
|
||||
func TestLoader_LoadDir_BadFile_异常(t *testing.T) {
|
||||
t.Parallel()
|
||||
dir := t.TempDir()
|
||||
writeFile(t, filepath.Join(dir, "bad.yaml"), "name: [broken")
|
||||
writeFile(t, filepath.Join(dir, "ok.yaml"), validSkillYAML)
|
||||
|
||||
l := NewLoader(testLogger())
|
||||
if _, err := l.LoadDir(dir); err == nil {
|
||||
t.Fatalf("expected error for malformed yaml in dir, got nil")
|
||||
}
|
||||
}
|
||||
|
||||
func TestLoader_LoadDir_NotFound_异常(t *testing.T) {
|
||||
t.Parallel()
|
||||
l := NewLoader(testLogger())
|
||||
if _, err := l.LoadDir(filepath.Join(t.TempDir(), "nothing")); err == nil {
|
||||
t.Fatalf("expected error for missing dir, got nil")
|
||||
}
|
||||
}
|
||||
|
||||
// TestLoader_LoadDir_OnlyYAML confirms non-YAML files are skipped rather than
|
||||
// treated as skills.
|
||||
func TestLoader_LoadDir_OnlyYAML_正常(t *testing.T) {
|
||||
t.Parallel()
|
||||
dir := t.TempDir()
|
||||
writeFile(t, filepath.Join(dir, "one.yaml"), validSkillYAML)
|
||||
writeFile(t, filepath.Join(dir, "two.yml"), validSkillYAML)
|
||||
writeFile(t, filepath.Join(dir, "readme.md"), "# docs")
|
||||
|
||||
l := NewLoader(testLogger())
|
||||
got, err := l.LoadDir(dir)
|
||||
if err != nil {
|
||||
t.Fatalf("LoadDir: %v", err)
|
||||
}
|
||||
if len(got) != 2 {
|
||||
t.Fatalf("LoadDir returned %d skills, want 2", len(got))
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,28 @@
|
||||
package skills
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
|
||||
"git.yeij.top/AskaEth/Cyrene_v2/internal/capability/registry"
|
||||
"git.yeij.top/AskaEth/Cyrene_v2/pkg/plugins/sdk"
|
||||
)
|
||||
|
||||
// Register publishes list into reg as KindSkill capabilities so they become
|
||||
// globally available to every character and mode. It returns ErrNilRegistrar
|
||||
// when reg is nil, ErrInvalidSkill when a skill is nil, and the registry's error
|
||||
// (for example registry.ErrDuplicate) on the first failed registration; earlier
|
||||
// skills in list stay registered.
|
||||
func Register(reg *registry.Registry, list ...sdk.Skill) error {
|
||||
if reg == nil {
|
||||
return ErrNilRegistrar
|
||||
}
|
||||
for _, s := range list {
|
||||
if s == nil {
|
||||
return fmt.Errorf("skills: register: %w", ErrInvalidSkill)
|
||||
}
|
||||
if err := reg.RegisterSkill(s); err != nil {
|
||||
return fmt.Errorf("skills: register %q: %w", s.Name(), err)
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
@@ -0,0 +1,56 @@
|
||||
package skills
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"testing"
|
||||
|
||||
"git.yeij.top/AskaEth/Cyrene_v2/internal/capability/registry"
|
||||
"git.yeij.top/AskaEth/Cyrene_v2/pkg/plugins/sdk"
|
||||
)
|
||||
|
||||
func TestRegister_正常(t *testing.T) {
|
||||
t.Parallel()
|
||||
reg := registry.New()
|
||||
if err := Register(reg, makeSkill(t, "a"), makeSkill(t, "b")); err != nil {
|
||||
t.Fatalf("Register: %v", err)
|
||||
}
|
||||
cap, err := reg.Get("a")
|
||||
if err != nil {
|
||||
t.Fatalf("Get a: %v", err)
|
||||
}
|
||||
if cap.Kind != registry.KindSkill {
|
||||
t.Fatalf("Kind = %q, want %q", cap.Kind, registry.KindSkill)
|
||||
}
|
||||
sk, ok := cap.Value.(sdk.Skill)
|
||||
if !ok {
|
||||
t.Fatalf("Value is %T, want sdk.Skill", cap.Value)
|
||||
}
|
||||
if sk.Name() != "a" || sk.Description() != "desc a" {
|
||||
t.Fatalf("registered skill = %q/%q, want a/desc a", sk.Name(), sk.Description())
|
||||
}
|
||||
}
|
||||
|
||||
func TestRegister_NilRegistrar_异常(t *testing.T) {
|
||||
t.Parallel()
|
||||
if err := Register(nil, makeSkill(t, "a")); !errors.Is(err, ErrNilRegistrar) {
|
||||
t.Fatalf("Register(nil) err = %v, want ErrNilRegistrar", err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestRegister_NilSkill_异常(t *testing.T) {
|
||||
t.Parallel()
|
||||
if err := Register(registry.New(), nil); !errors.Is(err, ErrInvalidSkill) {
|
||||
t.Fatalf("Register(nil skill) err = %v, want ErrInvalidSkill", err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestRegister_Duplicate_异常(t *testing.T) {
|
||||
t.Parallel()
|
||||
reg := registry.New()
|
||||
if err := Register(reg, makeSkill(t, "review")); err != nil {
|
||||
t.Fatalf("first Register: %v", err)
|
||||
}
|
||||
if err := Register(reg, makeSkill(t, "review")); !errors.Is(err, registry.ErrDuplicate) {
|
||||
t.Fatalf("second Register err = %v, want registry.ErrDuplicate", err)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,86 @@
|
||||
package skills
|
||||
|
||||
import (
|
||||
"context"
|
||||
"fmt"
|
||||
"log/slog"
|
||||
"strings"
|
||||
|
||||
"git.yeij.top/AskaEth/Cyrene_v2/internal/capability/registry"
|
||||
"git.yeij.top/AskaEth/Cyrene_v2/pkg/plugins/sdk"
|
||||
)
|
||||
|
||||
// Workflow is a Skill expanded into its executable form: the base system prompt
|
||||
// plus the ordered steps, references, and guardrails, ready to be handed to the
|
||||
// loop/agent executor (M2). The Runner only assembles workflows; it does not
|
||||
// execute commands.
|
||||
type Workflow struct {
|
||||
Name string
|
||||
Description string
|
||||
Prompt string
|
||||
Steps []sdk.Step
|
||||
Refs []sdk.Ref
|
||||
Guardrails []sdk.Guardrail
|
||||
}
|
||||
|
||||
// Runner expands skills into workflows. It is the M5 placeholder for the
|
||||
// skill-execution wrapper: expansion (the real deliverable) is wired now, while
|
||||
// Run awaits M12/loop integration.
|
||||
type Runner struct {
|
||||
reg *registry.Registry
|
||||
log *slog.Logger
|
||||
}
|
||||
|
||||
// NewRunner builds a Runner over the given registry, used by ExpandByName to
|
||||
// look up registered skills. log may be nil.
|
||||
func NewRunner(reg *registry.Registry, log *slog.Logger) *Runner {
|
||||
return &Runner{reg: reg, log: sourcedLog(log)}
|
||||
}
|
||||
|
||||
// Expand converts s into a Workflow, copying the step, ref, and guardrail slices
|
||||
// so the caller owns the result. It returns ErrInvalidSkill when s is nil or has
|
||||
// a blank name.
|
||||
func (r *Runner) Expand(ctx context.Context, s sdk.Skill) (Workflow, error) {
|
||||
if err := ctx.Err(); err != nil {
|
||||
return Workflow{}, fmt.Errorf("skills: runner: expand: %w", err)
|
||||
}
|
||||
if s == nil || strings.TrimSpace(s.Name()) == "" {
|
||||
return Workflow{}, fmt.Errorf("skills: runner: expand: %w", ErrInvalidSkill)
|
||||
}
|
||||
wf := Workflow{
|
||||
Name: s.Name(),
|
||||
Description: s.Description(),
|
||||
Prompt: s.Prompt(),
|
||||
Steps: cloneSteps(s.Steps()),
|
||||
Refs: cloneRefs(s.Refs()),
|
||||
Guardrails: cloneGuardrails(s.Guardrails()),
|
||||
}
|
||||
r.log.Info("skill expanded", "skill", wf.Name)
|
||||
return wf, nil
|
||||
}
|
||||
|
||||
// ExpandByName looks up a skill in the registry by name and expands it. It
|
||||
// returns ErrNilRegistrar when the runner has no registry, the registry's error
|
||||
// (registry.ErrNotFound) when the name is absent, and ErrNotFound when the
|
||||
// registered value is not a Skill.
|
||||
func (r *Runner) ExpandByName(ctx context.Context, name string) (Workflow, error) {
|
||||
if r.reg == nil {
|
||||
return Workflow{}, fmt.Errorf("skills: runner: expand %q: %w", name, ErrNilRegistrar)
|
||||
}
|
||||
cap, err := r.reg.Get(name)
|
||||
if err != nil {
|
||||
return Workflow{}, fmt.Errorf("skills: runner: expand %q: %w", name, err)
|
||||
}
|
||||
skill, ok := cap.Value.(sdk.Skill)
|
||||
if !ok {
|
||||
return Workflow{}, fmt.Errorf("skills: runner: expand %q: %w", name, ErrNotFound)
|
||||
}
|
||||
return r.Expand(ctx, skill)
|
||||
}
|
||||
|
||||
// Run is a placeholder for executing a registered skill end to end. Execution
|
||||
// lands in the loop/agent executor (M2) and the full wiring (M12); it always
|
||||
// returns ErrRunPending.
|
||||
func (r *Runner) Run(_ context.Context, _ string, _ any) (any, error) {
|
||||
return nil, ErrRunPending
|
||||
}
|
||||
@@ -0,0 +1,115 @@
|
||||
package skills
|
||||
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"testing"
|
||||
|
||||
"git.yeij.top/AskaEth/Cyrene_v2/internal/capability/registry"
|
||||
)
|
||||
|
||||
func TestRunner_Expand_正常(t *testing.T) {
|
||||
t.Parallel()
|
||||
r := NewRunner(registry.New(), testLogger())
|
||||
wf, err := r.Expand(context.Background(), makeSkill(t, "review"))
|
||||
if err != nil {
|
||||
t.Fatalf("Expand: %v", err)
|
||||
}
|
||||
if wf.Name != "review" {
|
||||
t.Fatalf("Name = %q, want review", wf.Name)
|
||||
}
|
||||
if wf.Description != "desc review" {
|
||||
t.Fatalf("Description = %q, want desc review", wf.Description)
|
||||
}
|
||||
if wf.Prompt != "prompt review" {
|
||||
t.Fatalf("Prompt = %q, want prompt review", wf.Prompt)
|
||||
}
|
||||
if len(wf.Steps) != 1 || wf.Steps[0].Name != "s1" {
|
||||
t.Fatalf("Steps = %+v, want one step s1", wf.Steps)
|
||||
}
|
||||
if len(wf.Refs) != 1 || wf.Refs[0].Name != "r1" {
|
||||
t.Fatalf("Refs = %+v, want one ref r1", wf.Refs)
|
||||
}
|
||||
if len(wf.Guardrails) != 1 || wf.Guardrails[0].ID != "g1" {
|
||||
t.Fatalf("Guardrails = %+v, want one guardrail g1", wf.Guardrails)
|
||||
}
|
||||
}
|
||||
|
||||
func TestRunner_Expand_Nil_异常(t *testing.T) {
|
||||
t.Parallel()
|
||||
r := NewRunner(registry.New(), testLogger())
|
||||
if _, err := r.Expand(context.Background(), nil); !errors.Is(err, ErrInvalidSkill) {
|
||||
t.Fatalf("Expand(nil) err = %v, want ErrInvalidSkill", err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestRunner_Expand_BlankName_异常(t *testing.T) {
|
||||
t.Parallel()
|
||||
r := NewRunner(registry.New(), testLogger())
|
||||
if _, err := r.Expand(context.Background(), mockSkill{name: " "}); !errors.Is(err, ErrInvalidSkill) {
|
||||
t.Fatalf("Expand(blank) err = %v, want ErrInvalidSkill", err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestRunner_Expand_ContextCanceled_异常(t *testing.T) {
|
||||
t.Parallel()
|
||||
r := NewRunner(registry.New(), testLogger())
|
||||
ctx, cancel := context.WithCancel(context.Background())
|
||||
cancel()
|
||||
if _, err := r.Expand(ctx, makeSkill(t, "review")); !errors.Is(err, context.Canceled) {
|
||||
t.Fatalf("Expand(canceled) err = %v, want context.Canceled", err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestRunner_ExpandByName_正常(t *testing.T) {
|
||||
t.Parallel()
|
||||
reg := registry.New()
|
||||
if err := Register(reg, makeSkill(t, "review")); err != nil {
|
||||
t.Fatalf("Register: %v", err)
|
||||
}
|
||||
r := NewRunner(reg, testLogger())
|
||||
wf, err := r.ExpandByName(context.Background(), "review")
|
||||
if err != nil {
|
||||
t.Fatalf("ExpandByName: %v", err)
|
||||
}
|
||||
if wf.Name != "review" || len(wf.Steps) != 1 {
|
||||
t.Fatalf("Workflow = %+v, want review with one step", wf)
|
||||
}
|
||||
}
|
||||
|
||||
func TestRunner_ExpandByName_NotSkill_异常(t *testing.T) {
|
||||
t.Parallel()
|
||||
reg := registry.New()
|
||||
// Register a capability whose Value is not a Skill (rendered via the raw API).
|
||||
if err := reg.Register(registry.Capability{Name: "notaskill", Kind: registry.KindTool, Value: "x"}); err != nil {
|
||||
t.Fatalf("register tool-cap: %v", err)
|
||||
}
|
||||
r := NewRunner(reg, testLogger())
|
||||
if _, err := r.ExpandByName(context.Background(), "notaskill"); !errors.Is(err, ErrNotFound) {
|
||||
t.Fatalf("ExpandByName(non-skill) err = %v, want ErrNotFound", err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestRunner_ExpandByName_NotFound_异常(t *testing.T) {
|
||||
t.Parallel()
|
||||
r := NewRunner(registry.New(), testLogger())
|
||||
if _, err := r.ExpandByName(context.Background(), "missing"); !errors.Is(err, registry.ErrNotFound) {
|
||||
t.Fatalf("ExpandByName(missing) err = %v, want registry.ErrNotFound", err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestRunner_ExpandByName_NilRegistrar_异常(t *testing.T) {
|
||||
t.Parallel()
|
||||
r := NewRunner(nil, testLogger())
|
||||
if _, err := r.ExpandByName(context.Background(), "x"); !errors.Is(err, ErrNilRegistrar) {
|
||||
t.Fatalf("ExpandByName(nil reg) err = %v, want ErrNilRegistrar", err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestRunner_Run_Placeholder_异常(t *testing.T) {
|
||||
t.Parallel()
|
||||
r := NewRunner(registry.New(), testLogger())
|
||||
if _, err := r.Run(context.Background(), "review", nil); !errors.Is(err, ErrRunPending) {
|
||||
t.Fatalf("Run err = %v, want ErrRunPending", err)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,134 @@
|
||||
// Package skills implements the M5 reusable-workflow capability: a Skill is a
|
||||
// higher-order, persistable workflow — an ordered set of steps plus a base
|
||||
// prompt, references, and guardrails — that builds on pkg/plugins/sdk and is
|
||||
// more structured than a Tool (DevDocs/design/09 §0/§3).
|
||||
//
|
||||
// The package provides five pieces:
|
||||
//
|
||||
// - Skill: the concrete in-memory model implementing pkg/plugins/sdk.Skill.
|
||||
// - Store: persistence of skills in a SQLite skills table.
|
||||
// - Loader: loading Skill definitions from YAML (a single stream or a
|
||||
// configs/skills/*.yaml directory).
|
||||
// - Runner: expanding a Skill into an executable Workflow for the loop/agent
|
||||
// executor (the actual execution itself lands in M2/M12).
|
||||
// - Register: publishing skills to the global capability registry
|
||||
// (internal/capability/registry) as KindSkill capabilities.
|
||||
package skills
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"fmt"
|
||||
"io"
|
||||
"log/slog"
|
||||
"strings"
|
||||
|
||||
"git.yeij.top/AskaEth/Cyrene_v2/internal/logger"
|
||||
"git.yeij.top/AskaEth/Cyrene_v2/pkg/plugins/sdk"
|
||||
)
|
||||
|
||||
// Sentinel errors returned by the skills package. Use errors.Is to test.
|
||||
var (
|
||||
// ErrInvalidSkill is returned when a skill is nil or has a blank name.
|
||||
ErrInvalidSkill = errors.New("skills: invalid skill")
|
||||
// ErrNotFound is returned by Store when a skill is absent.
|
||||
ErrNotFound = errors.New("skills: skill not found")
|
||||
// ErrNilRegistrar is returned by Register/NewRunner when no registry was
|
||||
// supplied.
|
||||
ErrNilRegistrar = errors.New("skills: nil registrar")
|
||||
// ErrNilDB is returned by NewStore when no *sql.DB was supplied.
|
||||
ErrNilDB = errors.New("skills: nil db")
|
||||
// ErrRunPending is returned by Runner.Run, which awaits M12 wiring.
|
||||
ErrRunPending = errors.New("skills: run pending")
|
||||
)
|
||||
|
||||
// Skill is the concrete, persistable form of a skill (see pkg/plugins/sdk.Skill):
|
||||
// a reusable workflow (ordered steps with dependencies), a base prompt,
|
||||
// references, and guardrails. It is more structured than a Tool and is the
|
||||
// higher-order capability described in DevDocs/design/09 §0.
|
||||
//
|
||||
// Skill is immutable after construction; its getters return copies of the slice
|
||||
// fields, so a *Skill is safe for concurrent use as the sdk.Skill contract
|
||||
// requires.
|
||||
type Skill struct {
|
||||
name string
|
||||
description string
|
||||
prompt string
|
||||
steps []sdk.Step
|
||||
refs []sdk.Ref
|
||||
guardrails []sdk.Guardrail
|
||||
}
|
||||
|
||||
// compile-time assertion that *Skill satisfies the SDK Skill interface.
|
||||
var _ sdk.Skill = (*Skill)(nil)
|
||||
|
||||
// New builds a Skill. It returns ErrInvalidSkill when name is blank. The step,
|
||||
// ref, and guardrail slices are copied, so the caller remains free to mutate
|
||||
// them afterwards.
|
||||
func New(name, description, prompt string, steps []sdk.Step, refs []sdk.Ref, guardrails []sdk.Guardrail) (*Skill, error) {
|
||||
if strings.TrimSpace(name) == "" {
|
||||
return nil, fmt.Errorf("skills: new: %w", ErrInvalidSkill)
|
||||
}
|
||||
return &Skill{
|
||||
name: name,
|
||||
description: description,
|
||||
prompt: prompt,
|
||||
steps: cloneSteps(steps),
|
||||
refs: cloneRefs(refs),
|
||||
guardrails: cloneGuardrails(guardrails),
|
||||
}, nil
|
||||
}
|
||||
|
||||
// Name returns the unique skill identifier.
|
||||
func (s *Skill) Name() string { return s.name }
|
||||
|
||||
// Description explains what the Skill accomplishes; the model uses it to select
|
||||
// a Skill for a task.
|
||||
func (s *Skill) Description() string { return s.description }
|
||||
|
||||
// Prompt returns the base system prompt for the Skill.
|
||||
func (s *Skill) Prompt() string { return s.prompt }
|
||||
|
||||
// Steps returns a copy of the ordered workflow steps.
|
||||
func (s *Skill) Steps() []sdk.Step { return cloneSteps(s.steps) }
|
||||
|
||||
// Refs returns a copy of the references the Skill may draw on.
|
||||
func (s *Skill) Refs() []sdk.Ref { return cloneRefs(s.refs) }
|
||||
|
||||
// Guardrails returns a copy of the constraints the Skill enforces.
|
||||
func (s *Skill) Guardrails() []sdk.Guardrail { return cloneGuardrails(s.guardrails) }
|
||||
|
||||
func cloneSteps(in []sdk.Step) []sdk.Step {
|
||||
if len(in) == 0 {
|
||||
return nil
|
||||
}
|
||||
out := make([]sdk.Step, len(in))
|
||||
copy(out, in)
|
||||
return out
|
||||
}
|
||||
|
||||
func cloneRefs(in []sdk.Ref) []sdk.Ref {
|
||||
if len(in) == 0 {
|
||||
return nil
|
||||
}
|
||||
out := make([]sdk.Ref, len(in))
|
||||
copy(out, in)
|
||||
return out
|
||||
}
|
||||
|
||||
func cloneGuardrails(in []sdk.Guardrail) []sdk.Guardrail {
|
||||
if len(in) == 0 {
|
||||
return nil
|
||||
}
|
||||
out := make([]sdk.Guardrail, len(in))
|
||||
copy(out, in)
|
||||
return out
|
||||
}
|
||||
|
||||
// sourcedLog returns a source-tagged logger suitable for this package, falling
|
||||
// back to a discard logger when l is nil so callers can pass nil safely.
|
||||
func sourcedLog(l *slog.Logger) *slog.Logger {
|
||||
if l == nil {
|
||||
l = slog.New(slog.NewTextHandler(io.Discard, nil))
|
||||
}
|
||||
return logger.WithSource(l, "capability/skills")
|
||||
}
|
||||
@@ -0,0 +1,236 @@
|
||||
package skills
|
||||
|
||||
import (
|
||||
"context"
|
||||
"crypto/rand"
|
||||
"database/sql"
|
||||
"encoding/hex"
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"fmt"
|
||||
"log/slog"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
"git.yeij.top/AskaEth/Cyrene_v2/pkg/plugins/sdk"
|
||||
)
|
||||
|
||||
// Store persists skill definitions in SQLite (the skills table). It is safe for
|
||||
// concurrent use — the underlying *sql.DB serializes writes — and every query is
|
||||
// parameterized, so values are never interpolated into SQL.
|
||||
type Store struct {
|
||||
db *sql.DB
|
||||
log *slog.Logger
|
||||
}
|
||||
|
||||
// createSkillsTable creates the skills schema. id is an opaque primary key;
|
||||
// name is the stable, unique skill identifier used for Upsert/Get/Delete
|
||||
// lookups. The desc column is double-quoted because DESC is a SQL keyword in
|
||||
// ordering context.
|
||||
const createSkillsTable = `
|
||||
CREATE TABLE IF NOT EXISTS skills (
|
||||
id TEXT PRIMARY KEY,
|
||||
name TEXT NOT NULL,
|
||||
"desc" TEXT NOT NULL DEFAULT '',
|
||||
prompt TEXT NOT NULL DEFAULT '',
|
||||
steps_json TEXT NOT NULL DEFAULT '[]',
|
||||
refs_json TEXT NOT NULL DEFAULT '[]',
|
||||
guardrails_json TEXT NOT NULL DEFAULT '[]',
|
||||
created_at TEXT NOT NULL,
|
||||
updated_at TEXT NOT NULL
|
||||
);
|
||||
CREATE UNIQUE INDEX IF NOT EXISTS idx_skills_name ON skills (name);
|
||||
`
|
||||
|
||||
// upsertSkillSQL inserts a skill, updating the existing row when the name
|
||||
// already exists; created_at is preserved across an update.
|
||||
const upsertSkillSQL = `
|
||||
INSERT INTO skills (id, name, "desc", prompt, steps_json, refs_json, guardrails_json, created_at, updated_at)
|
||||
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
|
||||
ON CONFLICT(name) DO UPDATE SET
|
||||
"desc" = excluded."desc",
|
||||
prompt = excluded.prompt,
|
||||
steps_json = excluded.steps_json,
|
||||
refs_json = excluded.refs_json,
|
||||
guardrails_json = excluded.guardrails_json,
|
||||
updated_at = excluded.updated_at
|
||||
`
|
||||
|
||||
const (
|
||||
getSkillSQL = `SELECT name, "desc", prompt, steps_json, refs_json, guardrails_json FROM skills WHERE name = ?`
|
||||
listSkillsSQL = `SELECT name, "desc", prompt, steps_json, refs_json, guardrails_json FROM skills ORDER BY name`
|
||||
deleteSkillSQL = `DELETE FROM skills WHERE name = ?`
|
||||
)
|
||||
|
||||
// idByteLen is the size in bytes of the random skill id (128-bit).
|
||||
const idByteLen = 16
|
||||
|
||||
// NewStore builds a Store, creating the skills table if needed. It returns
|
||||
// ErrNilDB when db is nil. ctx is used for the schema creation statement.
|
||||
func NewStore(ctx context.Context, db *sql.DB, log *slog.Logger) (*Store, error) {
|
||||
if db == nil {
|
||||
return nil, fmt.Errorf("skills: store: %w", ErrNilDB)
|
||||
}
|
||||
s := &Store{db: db, log: sourcedLog(log)}
|
||||
if _, err := db.ExecContext(ctx, createSkillsTable); err != nil {
|
||||
return nil, fmt.Errorf("skills: store: create skills table: %w", err)
|
||||
}
|
||||
s.log.Info("skills table ready")
|
||||
return s, nil
|
||||
}
|
||||
|
||||
// Upsert stores skill, inserting a new row or updating the existing row that
|
||||
// shares its name. It returns ErrInvalidSkill when skill is nil or has a blank
|
||||
// name.
|
||||
func (s *Store) Upsert(ctx context.Context, skill sdk.Skill) error {
|
||||
if skill == nil || strings.TrimSpace(skill.Name()) == "" {
|
||||
return fmt.Errorf("skills: store: upsert: %w", ErrInvalidSkill)
|
||||
}
|
||||
name := skill.Name()
|
||||
stepsJSON, err := marshalJSON(skill.Steps())
|
||||
if err != nil {
|
||||
return fmt.Errorf("skills: store: upsert %q: steps: %w", name, err)
|
||||
}
|
||||
refsJSON, err := marshalJSON(skill.Refs())
|
||||
if err != nil {
|
||||
return fmt.Errorf("skills: store: upsert %q: refs: %w", name, err)
|
||||
}
|
||||
guardrailsJSON, err := marshalJSON(skill.Guardrails())
|
||||
if err != nil {
|
||||
return fmt.Errorf("skills: store: upsert %q: guardrails: %w", name, err)
|
||||
}
|
||||
now := time.Now().UTC().Format(time.RFC3339Nano)
|
||||
if _, err := s.db.ExecContext(ctx, upsertSkillSQL,
|
||||
newID(), name, skill.Description(), skill.Prompt(),
|
||||
stepsJSON, refsJSON, guardrailsJSON, now, now,
|
||||
); err != nil {
|
||||
return fmt.Errorf("skills: store: upsert %q: %w", name, err)
|
||||
}
|
||||
s.log.Info("skill upserted", "skill", name)
|
||||
return nil
|
||||
}
|
||||
|
||||
// Get returns the skill registered under name, or ErrNotFound when absent.
|
||||
func (s *Store) Get(ctx context.Context, name string) (*Skill, error) {
|
||||
row := s.db.QueryRowContext(ctx, getSkillSQL, name)
|
||||
skill, err := scanSkill(row, name)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return skill, nil
|
||||
}
|
||||
|
||||
// List returns every stored skill, ordered by name.
|
||||
func (s *Store) List(ctx context.Context) ([]*Skill, error) {
|
||||
rows, err := s.db.QueryContext(ctx, listSkillsSQL)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("skills: store: list: %w", err)
|
||||
}
|
||||
defer rows.Close()
|
||||
|
||||
out := make([]*Skill, 0)
|
||||
for rows.Next() {
|
||||
skill, err := scanSkill(rows, "")
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
out = append(out, skill)
|
||||
}
|
||||
if err := rows.Err(); err != nil {
|
||||
return nil, fmt.Errorf("skills: store: list: iterate: %w", err)
|
||||
}
|
||||
return out, nil
|
||||
}
|
||||
|
||||
// Delete removes the skill named name. It returns ErrNotFound when no such skill
|
||||
// exists.
|
||||
func (s *Store) Delete(ctx context.Context, name string) error {
|
||||
res, err := s.db.ExecContext(ctx, deleteSkillSQL, name)
|
||||
if err != nil {
|
||||
return fmt.Errorf("skills: store: delete %q: %w", name, err)
|
||||
}
|
||||
n, err := res.RowsAffected()
|
||||
if err != nil {
|
||||
return fmt.Errorf("skills: store: delete %q: rows affected: %w", name, err)
|
||||
}
|
||||
if n == 0 {
|
||||
return fmt.Errorf("skills: store: delete %q: %w", name, ErrNotFound)
|
||||
}
|
||||
s.log.Info("skill deleted", "skill", name)
|
||||
return nil
|
||||
}
|
||||
|
||||
// rowScanner is the subset of *sql.Row and *sql.Rows that scanSkill needs.
|
||||
type rowScanner interface{ Scan(dest ...any) error }
|
||||
|
||||
// scanSkill reads one skills row and builds a *Skill. key is the lookup name
|
||||
// used only in error messages.
|
||||
func scanSkill(sc rowScanner, key string) (*Skill, error) {
|
||||
var name, desc, prompt, stepsJSON, refsJSON, guardrailsJSON string
|
||||
if err := sc.Scan(&name, &desc, &prompt, &stepsJSON, &refsJSON, &guardrailsJSON); err != nil {
|
||||
if errors.Is(err, sql.ErrNoRows) {
|
||||
return nil, fmt.Errorf("skills: store: get %q: %w", key, ErrNotFound)
|
||||
}
|
||||
return nil, fmt.Errorf("skills: store: scan skill: %w", err)
|
||||
}
|
||||
steps, err := unmarshalSteps(stepsJSON)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("skills: store: skill %q: steps: %w", name, err)
|
||||
}
|
||||
refs, err := unmarshalRefs(refsJSON)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("skills: store: skill %q: refs: %w", name, err)
|
||||
}
|
||||
guardrails, err := unmarshalGuardrails(guardrailsJSON)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("skills: store: skill %q: guardrails: %w", name, err)
|
||||
}
|
||||
skill, err := New(name, desc, prompt, steps, refs, guardrails)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("skills: store: skill %q: %w", name, err)
|
||||
}
|
||||
return skill, nil
|
||||
}
|
||||
|
||||
func marshalJSON(v any) (string, error) {
|
||||
b, err := json.Marshal(v)
|
||||
if err != nil {
|
||||
return "", err
|
||||
}
|
||||
return string(b), nil
|
||||
}
|
||||
|
||||
func unmarshalSteps(s string) ([]sdk.Step, error) {
|
||||
var out []sdk.Step
|
||||
if err := json.Unmarshal([]byte(s), &out); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return out, nil
|
||||
}
|
||||
|
||||
func unmarshalRefs(s string) ([]sdk.Ref, error) {
|
||||
var out []sdk.Ref
|
||||
if err := json.Unmarshal([]byte(s), &out); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return out, nil
|
||||
}
|
||||
|
||||
func unmarshalGuardrails(s string) ([]sdk.Guardrail, error) {
|
||||
var out []sdk.Guardrail
|
||||
if err := json.Unmarshal([]byte(s), &out); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return out, nil
|
||||
}
|
||||
|
||||
// newID returns a random 128-bit hex identifier for a skill row.
|
||||
func newID() string {
|
||||
var b [idByteLen]byte
|
||||
if _, err := rand.Read(b[:]); err != nil {
|
||||
// crypto/rand is effectively infallible; fall back to a nanosecond
|
||||
// timestamp so the store never blocks on a missing identifier.
|
||||
return fmt.Sprintf("%d", time.Now().UnixNano())
|
||||
}
|
||||
return hex.EncodeToString(b[:])
|
||||
}
|
||||
@@ -0,0 +1,201 @@
|
||||
package skills
|
||||
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"testing"
|
||||
|
||||
"git.yeij.top/AskaEth/Cyrene_v2/pkg/plugins/sdk"
|
||||
)
|
||||
|
||||
func TestStore_UpsertGet_正常(t *testing.T) {
|
||||
t.Parallel()
|
||||
s := newTestStore(t)
|
||||
ctx := context.Background()
|
||||
|
||||
if err := s.Upsert(ctx, makeSkill(t, "daily-brief")); err != nil {
|
||||
t.Fatalf("Upsert: %v", err)
|
||||
}
|
||||
got, err := s.Get(ctx, "daily-brief")
|
||||
if err != nil {
|
||||
t.Fatalf("Get: %v", err)
|
||||
}
|
||||
if got.Name() != "daily-brief" {
|
||||
t.Fatalf("Name = %q, want daily-brief", got.Name())
|
||||
}
|
||||
if got.Description() != "desc daily-brief" {
|
||||
t.Fatalf("Description = %q, want desc daily-brief", got.Description())
|
||||
}
|
||||
if got.Prompt() != "prompt daily-brief" {
|
||||
t.Fatalf("Prompt = %q, want prompt daily-brief", got.Prompt())
|
||||
}
|
||||
steps := got.Steps()
|
||||
if len(steps) != 1 || steps[0].Name != "s1" || steps[0].Prompt != "step prompt" {
|
||||
t.Fatalf("Steps = %+v, want one step s1/step prompt", steps)
|
||||
}
|
||||
refs := got.Refs()
|
||||
if len(refs) != 1 || refs[0].Name != "r1" || refs[0].Type != "tool" || refs[0].Value != "v1" || refs[0].Optional {
|
||||
t.Fatalf("Refs = %+v, want r1/tool/v1/non-optional", refs)
|
||||
}
|
||||
guards := got.Guardrails()
|
||||
if len(guards) != 1 || guards[0].ID != "g1" || guards[0].Message != "msg" || !guards[0].Enforced {
|
||||
t.Fatalf("Guardrails = %+v, want g1/msg/enforced", guards)
|
||||
}
|
||||
}
|
||||
|
||||
func TestStore_Upsert_Update_正常(t *testing.T) {
|
||||
t.Parallel()
|
||||
s := newTestStore(t)
|
||||
ctx := context.Background()
|
||||
|
||||
if err := s.Upsert(ctx, makeSkill(t, "review")); err != nil {
|
||||
t.Fatalf("first Upsert: %v", err)
|
||||
}
|
||||
// Same name, changed description/prompt — must update in place, not duplicate.
|
||||
updated, err := New("review", "v2 desc", "v2 prompt", nil, nil, nil)
|
||||
if err != nil {
|
||||
t.Fatalf("New: %v", err)
|
||||
}
|
||||
if err := s.Upsert(ctx, updated); err != nil {
|
||||
t.Fatalf("second Upsert: %v", err)
|
||||
}
|
||||
got, err := s.Get(ctx, "review")
|
||||
if err != nil {
|
||||
t.Fatalf("Get: %v", err)
|
||||
}
|
||||
if got.Description() != "v2 desc" || got.Prompt() != "v2 prompt" {
|
||||
t.Fatalf("updated skill = %q/%q, want v2 desc/v2 prompt", got.Description(), got.Prompt())
|
||||
}
|
||||
all, err := s.List(ctx)
|
||||
if err != nil {
|
||||
t.Fatalf("List: %v", err)
|
||||
}
|
||||
if len(all) != 1 {
|
||||
t.Fatalf("List after update has %d rows, want 1", len(all))
|
||||
}
|
||||
}
|
||||
|
||||
func TestStore_Get_NotFound_异常(t *testing.T) {
|
||||
t.Parallel()
|
||||
s := newTestStore(t)
|
||||
_, err := s.Get(context.Background(), "missing")
|
||||
if !errors.Is(err, ErrNotFound) {
|
||||
t.Fatalf("Get(missing) err = %v, want ErrNotFound", err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestStore_List_正常(t *testing.T) {
|
||||
t.Parallel()
|
||||
s := newTestStore(t)
|
||||
ctx := context.Background()
|
||||
for _, n := range []string{"b", "a", "c"} {
|
||||
if err := s.Upsert(ctx, makeSkill(t, n)); err != nil {
|
||||
t.Fatalf("Upsert(%s): %v", n, err)
|
||||
}
|
||||
}
|
||||
got, err := s.List(ctx)
|
||||
if err != nil {
|
||||
t.Fatalf("List: %v", err)
|
||||
}
|
||||
if len(got) != 3 {
|
||||
t.Fatalf("List length = %d, want 3", len(got))
|
||||
}
|
||||
if got[0].Name() != "a" || got[1].Name() != "b" || got[2].Name() != "c" {
|
||||
t.Fatalf("List order = %q,%q,%q, want a,b,c", got[0].Name(), got[1].Name(), got[2].Name())
|
||||
}
|
||||
}
|
||||
|
||||
func TestStore_Delete_正常(t *testing.T) {
|
||||
t.Parallel()
|
||||
s := newTestStore(t)
|
||||
ctx := context.Background()
|
||||
if err := s.Upsert(ctx, makeSkill(t, "x")); err != nil {
|
||||
t.Fatalf("Upsert: %v", err)
|
||||
}
|
||||
if err := s.Delete(ctx, "x"); err != nil {
|
||||
t.Fatalf("Delete: %v", err)
|
||||
}
|
||||
if _, err := s.Get(ctx, "x"); !errors.Is(err, ErrNotFound) {
|
||||
t.Fatalf("Get after Delete err = %v, want ErrNotFound", err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestStore_Delete_NotFound_异常(t *testing.T) {
|
||||
t.Parallel()
|
||||
s := newTestStore(t)
|
||||
if err := s.Delete(context.Background(), "missing"); !errors.Is(err, ErrNotFound) {
|
||||
t.Fatalf("Delete(missing) err = %v, want ErrNotFound", err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestStore_Upsert_Invalid_异常(t *testing.T) {
|
||||
t.Parallel()
|
||||
s := newTestStore(t)
|
||||
ctx := context.Background()
|
||||
cases := []struct {
|
||||
name string
|
||||
sk sdk.Skill
|
||||
}{
|
||||
{name: "nil skill", sk: nil},
|
||||
{name: "blank name", sk: mockSkill{name: " "}},
|
||||
}
|
||||
for _, tc := range cases {
|
||||
tc := tc
|
||||
t.Run(tc.name, func(t *testing.T) {
|
||||
t.Parallel()
|
||||
if err := s.Upsert(ctx, tc.sk); !errors.Is(err, ErrInvalidSkill) {
|
||||
t.Fatalf("Upsert(%s) err = %v, want ErrInvalidSkill", tc.name, err)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
// TestStore_SQLInjection_安全 stores a name/description that looks like SQL and
|
||||
// verifies the values round-trip verbatim (parameterized statements), that the
|
||||
// table survives, and that unrelated rows are unaffected.
|
||||
func TestStore_SQLInjection_安全(t *testing.T) {
|
||||
t.Parallel()
|
||||
s := newTestStore(t)
|
||||
ctx := context.Background()
|
||||
name := "x'); DROP TABLE skills; --"
|
||||
desc := "'; SELECT * FROM skills; --"
|
||||
|
||||
if err := s.Upsert(ctx, mockSkill{name: name}); err != nil {
|
||||
t.Fatalf("Upsert injection name: %v", err)
|
||||
}
|
||||
got, err := s.Get(ctx, name)
|
||||
if err != nil {
|
||||
t.Fatalf("Get injection name: %v", err)
|
||||
}
|
||||
if got.Name() != name {
|
||||
t.Fatalf("Name = %q, want the injection string stored verbatim", got.Name())
|
||||
}
|
||||
|
||||
// A description carrying SQL must also be stored as-is.
|
||||
sk, err := New("inject-desc", desc, "p", nil, nil, nil)
|
||||
if err != nil {
|
||||
t.Fatalf("New: %v", err)
|
||||
}
|
||||
if err := s.Upsert(ctx, sk); err != nil {
|
||||
t.Fatalf("Upsert injection desc: %v", err)
|
||||
}
|
||||
got2, err := s.Get(ctx, "inject-desc")
|
||||
if err != nil {
|
||||
t.Fatalf("Get inject-desc: %v", err)
|
||||
}
|
||||
if got2.Description() != desc {
|
||||
t.Fatalf("Description = %q, want verbatim injection", got2.Description())
|
||||
}
|
||||
|
||||
// The table must still be intact and usable.
|
||||
if err := s.Upsert(ctx, makeSkill(t, "after")); err != nil {
|
||||
t.Fatalf("Upsert after injection: %v", err)
|
||||
}
|
||||
all, err := s.List(ctx)
|
||||
if err != nil {
|
||||
t.Fatalf("List after injection: %v", err)
|
||||
}
|
||||
if len(all) != 3 {
|
||||
t.Fatalf("List after injection has %d rows, want 3", len(all))
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user