registry

type AgentSkill struct {
	// --- Frontmatter fields (from YAML between --- delimiters) ---
	Name          string            `yaml:"name" json:"name"`
	Description   string            `yaml:"description" json:"description"`
	License       string            `yaml:"license,omitempty" json:"license,omitempty"`
	Compatibility string            `yaml:"compatibility,omitempty" json:"compatibility,omitempty"`
	Metadata      map[string]string `yaml:"metadata,omitempty" json:"metadata,omitempty"`
	AllowedTools  string            `yaml:"allowed-tools,omitempty" json:"allowedTools,omitempty"`
	// AcceptanceCriteria documents expected skill behavior as human-readable
	// Given/When/Then scenarios. Gridctl extension; not part of agentskills.io spec.
	// See https://agentskills.io/specification
	AcceptanceCriteria []string `yaml:"acceptance_criteria,omitempty" json:"acceptanceCriteria,omitempty"`

	// --- Gridctl extensions (not in agentskills.io spec) ---
	State ItemState `yaml:"state,omitempty" json:"state"`

	// --- Parsed from file content (not in frontmatter YAML) ---
	Body string `yaml:"-" json:"body"` // Markdown content after frontmatter

	// --- Computed fields (not serialized to YAML) ---
	FileCount int    `yaml:"-" json:"fileCount"`     // Number of supporting files (scripts/, references/, assets/)
	Dir       string `yaml:"-" json:"dir,omitempty"` // Relative path from skills/ root (e.g., "git-workflow/branch-fork")

	// --- Typed-skill fields (Phase C) ---
	// Set when a skill.go or skill.ts sibling is present alongside
	// SKILL.md. The walker discovers the handler at load time but
	// does not load or compile it; runtime dispatch happens through
	// the registry server's typed-skill path.
	HandlerLanguage string `yaml:"-" json:"handlerLanguage,omitempty"` // "go", "ts", or empty
	HandlerPath     string `yaml:"-" json:"handlerPath,omitempty"`     // Relative path from skill dir (e.g., "skill.ts")
}

type DeterministicEvaluator struct{}

type Evaluator interface {
	// Name identifies the evaluator backend for the TestReport.
	Name() string

	// Evaluate produces a verdict for criterion idx against skill.
	// Implementations MUST NOT return both a TestResult and an error;
	// transient infrastructure failures should be returned via a
	// TestResult with Severity = TestSeverityError so the report
	// remains complete for the user.
	Evaluate(ctx context.Context, skill *AgentSkill, idx int, criterion string) TestResult
}

type ItemState string

type LLMEvaluator struct {
	// Model is the canonical model ID handed to ChatRequest.Model.
	// Falls back to defaultJudgeModel when empty.
	Model string

	// Provider is the gridctl LLM provider. Required; constructing
	// the evaluator without one and calling Evaluate produces
	// TestSeverityError on every criterion.
	Provider agent.ChatModel

	// MaxTokens caps the judge's output. Defaults to 256 — verdicts
	// fit comfortably in a few sentences.
	MaxTokens int
}

type RegistryStatus struct {
	TotalSkills  int `json:"totalSkills"`
	ActiveSkills int `json:"activeSkills"`
}

type RunOptions struct {
	// CriterionIndex, when non-negative, scopes the run to a single
	// criterion. -1 (the zero value via NewRunOptions) means "all".
	CriterionIndex int

	// DryRun lists criteria without evaluating them. Severity on each
	// result is empty.
	DryRun bool

	// Now overrides the wall-clock used for EvaluatedAt and
	// GeneratedAt. Tests inject a fixed time; production callers
	// leave this zero so the runner defaults to time.Now().
	Now time.Time
}

type Server struct {
	// contains filtered or unexported fields
}

type SkillFile struct {
	Path  string `json:"path"`  // Relative path within the skill dir (e.g., "scripts/lint.sh")
	Size  int64  `json:"size"`  // File size in bytes
	IsDir bool   `json:"isDir"` // True for directories
}

type SkillRegistry interface {
	Tools() []mcp.Tool
	CallTool(ctx context.Context, name string, arguments map[string]any) (*mcp.ToolCallResult, error)
}

type Store struct {
	// contains filtered or unexported fields
}

type TSDispatcher interface {
	Dispatch(ctx context.Context, name, sourcePath string, arguments map[string]any) (*mcp.ToolCallResult, error)
}

type TestReport struct {
	// SkillName echoes the skill the runner ran against.
	SkillName string `json:"skill_name"`

	// Results is the per-criterion verdicts in criterion order.
	Results []TestResult `json:"results"`

	// PassCount, FailCount, ErrorCount summarize Results so callers
	// don't re-tally.
	PassCount  int `json:"pass_count"`
	FailCount  int `json:"fail_count"`
	ErrorCount int `json:"error_count"`

	// Evaluator names the backend that ran the criteria (e.g. "llm",
	// "deterministic"). Surfaced in JSON output so CI logs make the
	// provenance explicit.
	Evaluator string `json:"evaluator"`

	// DryRun is true when Results was populated by listing criteria
	// without executing them. Each TestResult in that case carries
	// Severity = "" so renderers can show "—" instead of a verdict.
	DryRun bool `json:"dry_run,omitempty"`

	// GeneratedAt is the wall-clock time the report was assembled.
	GeneratedAt time.Time `json:"generated_at"`
}

type TestResult struct {
	// Index is the criterion's position in the skill's
	// AcceptanceCriteria slice (zero-based). Stable across runs.
	Index int `json:"index"`

	// Criterion is the verbatim Given/When/Then string from the
	// skill's frontmatter.
	Criterion string `json:"criterion"`

	// Severity classifies the outcome.
	Severity TestSeverity `json:"severity"`

	// Message is a short human-readable rationale. Required for fail
	// and error; optional for pass.
	Message string `json:"message,omitempty"`

	// EvaluatedAt is the wall-clock time the verdict was rendered.
	EvaluatedAt time.Time `json:"evaluated_at"`
}

type TestSeverity string

type ValidationResult struct {
	Errors   []string // Fatal validation failures
	Warnings []string // Non-fatal advisories (e.g., body too long)
}