skill

type Call struct {
	Name      string `json:"name"`
	Arguments string `json:"arguments,omitempty"`
}

type Config struct {
	// ProjectDir is the project root: the base of paths patterns, of
	// relative file paths and of file rules, the working directory of
	// injected commands, and ${CLAUDE_PROJECT_DIR}. Empty means the
	// process's working directory.
	ProjectDir string

	// Shell enables Claude Code's dynamic context injection: !`command`
	// and “`! blocks in a skill run when the skill is invoked and their
	// output replaces them. It runs shell commands written in skill files
	// with the process's privileges, so enable it only for skills you
	// trust. Without it the placeholders are left as written.
	//
	// Commands run with bash, or sh if bash is missing (cmd.exe on
	// Windows), or with PowerShell for skills with "shell: powershell". A
	// command that exits with a non-zero status, except 1 from search and
	// comparison commands such as grep and diff, fails the invocation.
	// Arguments reach commands through the environment variables
	// ARGUMENTS, ARGUMENTS_0, ARGUMENTS_1, ... and those of declared
	// argument names, and with sh or bash also as $0, $1, ..., so they are
	// never parsed as shell code.
	Shell bool
	// ShellTimeout bounds each injected command; zero means
	// DefaultShellTimeout.
	ShellTimeout time.Duration
	// ShellOutputLimit bounds the output of each injected command in
	// bytes; zero means 30000.
	ShellOutputLimit int

	// Effort is the effort level ${CLAUDE_EFFORT} expands to when no
	// active skill sets one.
	Effort string
	// Fork runs context: fork skills in a sub-agent. Without it they run
	// inline, like other skills.
	Fork Forker
	// Models resolves the model field of an inline skill. A nil result, or
	// a nil Models, sends the name as model.Request.Model to the agent's
	// model instead. "inherit" keeps the current model.
	Models func(name string) model.Model
	// HookOptions builds the hooks of skills; see hook.SettingsOptions.
	HookOptions hook.SettingsOptions
	// Files returns the files a tool call reads or edits, which make
	// skills with paths available; nil means FilesOf.
	Files func(call *model.ToolCall) []string
	// MatchTool reports whether a rule of allowed-tools or disallowed-tools
	// matches a tool call; nil means MatchTool with ProjectDir.
	MatchTool func(rule string, call *model.ToolCall) bool
}

type Conflict struct {
	Name string
	// Kept and Shadowed are the directories of the skill that is used and
	// of the one that is not.
	Kept, Shadowed string
}

type DiscoverConfig struct {
	// Dir is the working directory; empty means the process's.
	Dir string
	// Root is the project root: project skills load from Dir and each of
	// its parents up to Root. Empty means the nearest directory, from Dir
	// upwards, that contains .git (a repository or worktree root), or Dir
	// if there is none.
	Root string
	// Home, when set, enables the user's skills in Home/.claude/skills and
	// Home/.agents/skills, for example with os.UserHomeDir. They are off
	// by default, so a program does not pick up skills from the home
	// directory of whoever runs it unless it asks to.
	Home string
	// Managed, when set, is a managed settings directory whose skills take
	// precedence over all others, like Claude Code's enterprise skills.
	Managed string
	// AdditionalDirs are more directories whose skill folders load, like
	// Claude Code's --add-dir, after the project's.
	AdditionalDirs []string
	// Nested also loads the skill folders of directories below Dir. As in
	// Claude Code, such a skill is offered to the model only once it works
	// with a file in that directory (see Scoped), and when its name is
	// taken it is renamed "<dir>:<name>", with dir relative to Dir.
	// Hidden directories and node_modules are not searched.
	Nested bool
	// Folders are the skill folders searched in each directory, in
	// precedence order; nil means DefaultFolders.
	Folders []string
	// ProjectFirst gives project skills precedence over the user's, as
	// Gemini CLI does. By default the user's win, as in Claude Code.
	ProjectFirst bool
	// Strict loads skills with the Strict option.
	Strict bool
}

type Discovery struct {
	// Skills are the skills found, one per name, in precedence order.
	Skills []Skill
	// Sources maps skill names to where they were found.
	Sources map[string]Source
	// Conflicts lists skills hidden by others of the same name.
	Conflicts []Conflict
}

type Forker func(ctx context.Context, s Skill, task string) (*tool.Result, error)

type LoadOption func(*loadOptions)

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

type Metadata struct {
	// Name is the skill name, by default the name of its directory.
	Name string
	// Description says what the skill does and when to use it. When the
	// frontmatter has none, the loader uses the first non-empty line of
	// the body, as Claude Code does.
	Description string
	// WhenToUse is "when_to_use": more context for when to invoke the
	// skill, appended to Description in the skill listing.
	WhenToUse string
	// ArgumentHint is "argument-hint", such as "[issue-number]", shown to
	// users and to the model.
	ArgumentHint string
	// Arguments names the positional arguments, so $name expands to the
	// argument at that name's position.
	Arguments []string
	// DisableModelInvocation hides the skill from the model: it is not
	// listed and the skill tool refuses it, but users can invoke it; see
	// Registry.Invoke.
	DisableModelInvocation bool
	// UserInvocable is false when "user-invocable: false" hides the skill
	// from users; the model can still invoke it. Nil means true.
	UserInvocable *bool
	// AllowedTools are tool rules, such as "read_file" or
	// "Bash(git add *)", that need no approval while the skill is active.
	// They do not restrict other tools.
	AllowedTools []string
	// DisallowedTools are tool rules removed from the model while the skill
	// is active.
	DisallowedTools []string
	// Model is the model to use while the skill is active, or for its
	// sub-agent with context: fork. "inherit" keeps the current model.
	Model string
	// Effort is the reasoning effort while the skill is active: low,
	// medium, high, xhigh or max.
	Effort string
	// Context is "fork" to run the skill in an isolated sub-agent.
	Context string
	// Agent names the sub-agent of a context: fork skill; the default is
	// general-purpose.
	Agent string
	// Background is false when a forked skill should block the turn that
	// invoked it. agentx always waits for a forked skill's result, as
	// Claude Code does in the Agent SDK; the field is informational.
	Background *bool
	// Hooks holds hooks, in the format of the "hooks" block of a Claude
	// Code settings file, that are registered for the session when the
	// skill is invoked. Values are JSON types.
	Hooks map[string]any
	// Paths are glob patterns: a skill with paths is offered to the model
	// only once it works with matching files.
	Paths []string
	// Shell is the shell of injected commands: bash (the default) or
	// powershell.
	Shell string
	// License, Compatibility and Metadata are fields of the Agent Skills
	// specification that agentx does not act on. Metadata values are
	// strings, []any or map[string]any.
	License       string
	Compatibility string
	Metadata      map[string]any
	// Extra holds frontmatter keys that are not recognized. Sequences are
	// joined with ", " and mappings encoded as JSON.
	Extra map[string]string
}

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

type Scope int

type Scoped interface {
	// ScopeDir is the directory, absolute or relative to the project root.
	ScopeDir() string
}

type Skill interface {
	Metadata() Metadata
	// Content returns the instructions without frontmatter.
	Content(ctx context.Context) (string, error)
	// Dir is the skill's base directory, used to resolve bundled files. It is
	// empty for skills that are not backed by a directory.
	Dir() string
}

type Source struct {
	Scope Scope
	// Folder is the skill folder, such as /repo/.claude/skills.
	Folder string
}

type Vars struct {
	// Arguments is the argument string, as a user would type it after the
	// skill's name.
	Arguments string
	// SessionID replaces ${CLAUDE_SESSION_ID}.
	SessionID string
	// ProjectDir replaces ${CLAUDE_PROJECT_DIR}.
	ProjectDir string
	// Effort replaces ${CLAUDE_EFFORT}.
	Effort string
}