165 lines
5.1 KiB
Go
165 lines
5.1 KiB
Go
package skillcurator
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/samcharles93/archie-core/internal/domain/curator"
|
|
"github.com/samcharles93/archie-core/internal/skill"
|
|
)
|
|
|
|
// Name is the identifier this curator registers under.
|
|
const Name = "skill"
|
|
|
|
// DefaultInterval is the check-in cadence used when nothing more specific
|
|
// configures one. No config surface for per-curator intervals exists yet
|
|
// (this is the first real curator registered); this constant is the
|
|
// obvious place a future one would read from.
|
|
const DefaultInterval = time.Hour
|
|
|
|
const (
|
|
// ActionInvalid records a skill whose SKILL.md failed to parse.
|
|
ActionInvalid = "skill.invalid"
|
|
// ActionIncomplete records a skill that parsed but is missing a
|
|
// required frontmatter field.
|
|
ActionIncomplete = "skill.incomplete"
|
|
// ActionNormalized records a skill whose content was rewritten by
|
|
// whitespace normalization.
|
|
ActionNormalized = "skill.normalized"
|
|
)
|
|
|
|
// Curator implements domain/curator.CuratorEngine.
|
|
type Curator struct {
|
|
interval time.Duration
|
|
host curator.Registrar
|
|
}
|
|
|
|
// New builds a skill curator that checks in every interval.
|
|
func New(interval time.Duration) *Curator {
|
|
return &Curator{interval: interval}
|
|
}
|
|
|
|
func (c *Curator) Name() string { return Name }
|
|
func (c *Curator) Version() string { return "1" }
|
|
|
|
func (c *Curator) Manifest() curator.Manifest {
|
|
return curator.Manifest{Interval: c.interval, Skills: true}
|
|
}
|
|
|
|
func (c *Curator) Bind(host curator.Registrar) { c.host = host }
|
|
|
|
func (c *Curator) Start(context.Context) error { return nil }
|
|
|
|
func (c *Curator) Health(context.Context) curator.Health {
|
|
return curator.Health{Status: curator.HealthHealthy}
|
|
}
|
|
|
|
func (c *Curator) Stop(context.Context) error { return nil }
|
|
|
|
// Check reports whether there is anything to review. Cheap by
|
|
// construction: a directory listing, no model calls, no parsing.
|
|
func (c *Curator) Check(ctx context.Context) (bool, error) {
|
|
refs, err := c.host.Skills.List(ctx)
|
|
if err != nil {
|
|
return false, err
|
|
}
|
|
return len(refs) > 0, nil
|
|
}
|
|
|
|
// Pass reviews every skill currently on disk. There is no per-skill "already
|
|
// reviewed" state: each pass re-checks everything, which is cheap (file reads,
|
|
// no model calls) and errs toward catching a regression over missing one.
|
|
func (c *Curator) Pass(ctx context.Context, in curator.PassInput) (curator.PassResult, error) {
|
|
refs, err := c.host.Skills.List(ctx)
|
|
if err != nil {
|
|
return curator.PassResult{}, err
|
|
}
|
|
|
|
var actions []curator.Action
|
|
for _, ref := range refs {
|
|
acts, err := c.reviewOne(ctx, ref.Name)
|
|
if err != nil {
|
|
return curator.PassResult{}, fmt.Errorf("skill %q: %w", ref.Name, err)
|
|
}
|
|
actions = append(actions, acts...)
|
|
}
|
|
return curator.PassResult{Actions: actions}, nil
|
|
}
|
|
|
|
// reviewOne classifies one skill and writes back a normalized version when
|
|
// possible. It returns at most one Action.
|
|
func (c *Curator) reviewOne(ctx context.Context, name string) ([]curator.Action, error) {
|
|
sk, err := c.host.Skills.Read(ctx, name)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
fm, _, fail := skill.Parse([]byte(sk.Content))
|
|
if fail != nil {
|
|
// A parse failure is a per-skill finding to report, not an execution
|
|
// error to propagate: Pass()'s loop aborts the whole batch on a non-nil
|
|
// error, which would stop reviewing every other skill over one bad
|
|
// file.
|
|
return invalidFinding(name, fail)
|
|
}
|
|
|
|
if missing := missingField(fm); missing != "" {
|
|
return []curator.Action{{
|
|
Type: ActionIncomplete,
|
|
Detail: name,
|
|
Reason: "missing " + missing,
|
|
}}, nil
|
|
}
|
|
|
|
normalized := normalizeWhitespace(sk.Content)
|
|
if normalized == sk.Content {
|
|
return nil, nil
|
|
}
|
|
if err := c.host.Skills.Write(ctx, curator.Skill{Name: name, Content: normalized}); err != nil {
|
|
return nil, err
|
|
}
|
|
return []curator.Action{{
|
|
Type: ActionNormalized,
|
|
Detail: name,
|
|
Reason: "trailing whitespace or missing final newline",
|
|
}}, nil
|
|
}
|
|
|
|
// invalidFinding converts a parse error into a per-skill action. Parse
|
|
// failures are expected findings, so they must not abort the rest of Pass.
|
|
func invalidFinding(name string, parseErr error) ([]curator.Action, error) {
|
|
return []curator.Action{{
|
|
Type: ActionInvalid,
|
|
Detail: name,
|
|
Reason: parseErr.Error(),
|
|
}}, nil
|
|
}
|
|
|
|
// missingField returns the name of the first required frontmatter field
|
|
// fm lacks, or "" if both are present. Order (name before description)
|
|
// only affects which single reason is reported when both are missing;
|
|
// either is worth flagging on its own.
|
|
func missingField(fm *skill.Frontmatter) string {
|
|
if strings.TrimSpace(fm.Name) == "" {
|
|
return "name"
|
|
}
|
|
if strings.TrimSpace(fm.Description) == "" {
|
|
return "description"
|
|
}
|
|
return ""
|
|
}
|
|
|
|
// normalizeWhitespace trims trailing whitespace from every line and
|
|
// ensures the content ends in exactly one newline. It never touches
|
|
// leading whitespace (meaningful in YAML frontmatter and Markdown list
|
|
// nesting) or blank-line structure.
|
|
func normalizeWhitespace(content string) string {
|
|
lines := strings.Split(content, "\n")
|
|
for i, line := range lines {
|
|
lines[i] = strings.TrimRight(line, " \t")
|
|
}
|
|
return strings.TrimRight(strings.Join(lines, "\n"), "\n") + "\n"
|
|
}
|