yamlvalidator

https://github.com/yakwilik/go-yamlvalidator
Admin
A flexible, production-ready YAML validation library for Go with support for type checking, custom...
Tokens:89,909
Snippets:630
Trust Score:6.6
License:Apache-2.0
Update:3 weeks ago
Show doc for...
Tokens:
Raw
### Run bundled examples with go run and go test

Source: https://github.com/yakwilik/go-yamlvalidator/blob/master/skills/go-yamlvalidator/references/installation.md

Run the native and JSON Schema examples and test all examples from the library checkout. An installed skill may be outside any Go module; its check-examples.sh script copies bundled examples into a temporary module, pins v1.0.0, and runs tests. Pass --local /path/to/go-yamlvalidator to test a checkout without editing the application's go.mod.

```bash
go run ./skills/go-yamlvalidator/examples/native
go run ./skills/go-yamlvalidator/examples/jsonschema
go test ./skills/go-yamlvalidator/examples/...

```

--------------------------------

### Install go-yamlvalidator with go get

Source: https://github.com/yakwilik/go-yamlvalidator/blob/master/README.md

Install the library at version v1.0.0. Requires Go 1.24 or newer.

```bash
go get github.com/Yakwilik/go-yamlvalidator@v1.0.0
```

--------------------------------

### Run check-examples.sh for external skill

Source: https://github.com/yakwilik/go-yamlvalidator/blob/master/skills/go-yamlvalidator/examples/recipes/README.md

Run the checker for a skill installed outside the library repository. The first form creates a temporary module, requires v1.0.0, and tests the example files there without changing the caller's module. The second form compares the examples with a local checkout and does not prove compatibility with the published version; run the first form for that check. The optional --race flag enables Go's race detector.

```bash
bash /path/to/go-yamlvalidator-skill/scripts/check-examples.sh
bash /path/to/go-yamlvalidator-skill/scripts/check-examples.sh --local /path/to/go-yamlvalidator
```

--------------------------------

### Install standalone skill with npx

Source: https://github.com/yakwilik/go-yamlvalidator/blob/master/docs/agent-plugin.md

Install the standalone skill via the skills CLI. This installs an agent skill, not the Go library.

```bash
npx skills add Yakwilik/go-yamlvalidator

```

--------------------------------

### Install go-yamlvalidator v1.0.0 with go get

Source: https://github.com/yakwilik/go-yamlvalidator/blob/master/skills/go-yamlvalidator/references/installation.md

Check the Go version, list the current module version, and add the v1.0.0 dependency. The go get command modifies the current module and may download dependencies; run it only when installation is part of the task. The module path has no /v1 suffix and preserves uppercase Yakwilik.

```bash
go version
go list -m github.com/Yakwilik/go-yamlvalidator
go get github.com/Yakwilik/go-yamlvalidator@v1.0.0

```

--------------------------------

### Run example tests with go test

Source: https://github.com/yakwilik/go-yamlvalidator/blob/master/skills/go-yamlvalidator/SKILL.md

Run the executable examples and regressions for both validation surfaces from a library checkout.

```bash
go test ./skills/go-yamlvalidator/examples/...
```

--------------------------------

### NewValidator usage example

Source: https://github.com/yakwilik/go-yamlvalidator/blob/master/_autodocs/api-reference/validator.md

Example of creating a Validator with NewValidator, passing a FieldSchema with TypeMap and UnknownKeyError settings.

```go
v := NewValidator(&FieldSchema{
    Type:             TypeMap,
    UnknownKeyPolicy: UnknownKeyError,
})

```

--------------------------------

### Full validation pipeline example

Source: https://github.com/yakwilik/go-yamlvalidator/blob/master/_autodocs/api-reference/validation-result.md

Full pipeline example: validates bytes, checks for errors, prints formatted errors with source context (sorted by position), exits if errors, then prints each error via the collector's Errors method.

```go
result := validator.ValidateBytes(data)
if result.HasErrors() {
    fmt.Print(result.FormatAll(true)) // true = sort by position
    os.Exit(1)
}
for _, err := range result.Collector.Errors() {
    fmt.Println(err) // ValidationError.Error()
}
```

--------------------------------

### ParsePathTokens usage example

Source: https://github.com/yakwilik/go-yamlvalidator/blob/master/_autodocs/api-reference/diagnostics.md

Example usage of ParsePathTokens with a display path. Iterates over the returned tokens and prints their kind and name.

```go
tokens, err := v.ParsePathTokens("doc[1].spec.containers[0].image")
for _, tok := range tokens {
    fmt.Printf("%s %v\n", tok.Kind, tok.Name)
}
```

--------------------------------

### Run example tests in library checkout

Source: https://github.com/yakwilik/go-yamlvalidator/blob/master/skills/go-yamlvalidator/examples/recipes/README.md

Run the executable recipes from the library checkout. The first command runs tests once; the second enables Go's race detector.

```bash
go test -count=1 ./skills/go-yamlvalidator/examples/...
go test -race ./skills/go-yamlvalidator/examples/...
```

--------------------------------

### Native serialized schema example

Source: https://github.com/yakwilik/go-yamlvalidator/blob/master/skills/go-yamlvalidator/references/cli.md

Example of the native serialized schema format supported by schema_loader.go. Only the listed fields are allowed; unknown fields are rejected.

```yaml
type: map
required: true
unknownKeyPolicy: error
allowedKeys:
  name:
    type: string
    required: true
    validators:
      - name: nonempty
  port:
    type: integer
    validators:
      - name: range
        min: 1
        max: 65535
```

--------------------------------

### Install and run yamlvalidator with JSON Schema

Source: https://github.com/yakwilik/go-yamlvalidator/blob/master/skills/go-yamlvalidator/references/cli.md

Install the CLI and run it with a JSON Schema file. The -schema-format flag must be set to 'jsonschema' for JSON Schema documents.

```bash
go install github.com/Yakwilik/go-yamlvalidator/cmd/yamlvalidator@v1.0.0
yamlvalidator -schema schema.json -schema-format jsonschema -file config.yaml
```

--------------------------------

### CompileFieldSchema usage example

Source: https://github.com/yakwilik/go-yamlvalidator/blob/master/_autodocs/api-reference/validator.md

Example of compiling a schema and using the resulting validator to validate YAML bytes. The error is checked before calling ValidateBytes.

```go
validator, err := v.CompileFieldSchema(schema)
if err != nil {
    return err
}
result := validator.ValidateBytes(data)

```

--------------------------------

### ValidateBytes usage example

Source: https://github.com/yakwilik/go-yamlvalidator/blob/master/_autodocs/api-reference/validator.md

Shows how to call ValidateBytes with a YAML byte slice and check for errors. If errors exist, it prints them using FormatAll(true).

```go
result := v.ValidateBytes([]byte("name: api\nport: 8080\n"))
if result.HasErrors() {
    fmt.Print(result.FormatAll(true))
}
```

--------------------------------

### JSONSchemaFileResolver usage example

Source: https://github.com/yakwilik/go-yamlvalidator/blob/master/_autodocs/api-reference/jsonschema-resolvers.md

Shows how to create a file resolver from a schema file's directory and compile a schema with it. The resolver enforces that all file:// URLs stay within the root directory.

```go
resolver, err := v.NewJSONSchemaFileResolver(filepath.Dir(schemaPath))
if err != nil {
    return nil, err
}
schema, err := v.CompileJSONSchemaWithOptions(data, v.JSONSchemaCompileOptions{
    SchemaURL: (&url.URL{Scheme: "file", Path: filepath.ToSlash(schemaPath)}).String(),
    Resolver:  resolver,
})
```

--------------------------------

### Example error output with line and column

Source: https://github.com/yakwilik/go-yamlvalidator/blob/master/README.md

Shows the diagnostic format produced by the library, including the error message, line/column, and a visual pointer to the offending line.

```text
[ERROR] line 3:1: unknown key "plugin"; did you mean "plugins"? (path: generate.plugin)
>    3 | plugin:
       | ^
```

--------------------------------

### Warnings-only workflow example

Source: https://github.com/yakwilik/go-yamlvalidator/blob/master/_autodocs/api-reference/validation-result.md

Warnings-only workflow: validates bytes, iterates over warnings from the collector, and prints each warning with source context using FormatErrorWithSource.

```go
result := v.ValidateBytes(data)
for _, warn := range result.Collector.Warnings() {
    fmt.Println(v.FormatErrorWithSource(warn, result.SourceLines))
}
```

--------------------------------

### JSONSchemaCachingResolver usage example

Source: https://github.com/yakwilik/go-yamlvalidator/blob/master/_autodocs/api-reference/jsonschema-resolvers.md

Shows how to create a caching resolver with a custom JSONSchemaResolverFunc that loads schema resources. The resolver is used to cache resolutions for subsequent calls.

```go
resolver := v.NewJSONSchemaCachingResolver(
    v.JSONSchemaResolverFunc(func(ctx context.Context, url string) ([]byte, error) {
        return loadSchemaResource(ctx, url)
    }),
)
```

--------------------------------

### Custom validator building child paths example

Source: https://github.com/yakwilik/go-yamlvalidator/blob/master/_autodocs/api-reference/diagnostics.md

Example of a custom validator using AppendPropertyPath and AppendIndexPath to build child paths. Handles the error from AppendIndexPath for negative indexes.

```go
func (v childValidator) Validate(node *yaml.Node, path string, ctx *v.ValidationContext) {
    childPath := v.AppendPropertyPath(path, "name")
    idxPath, err := v.AppendIndexPath(path, 2)
    if err != nil {
        return
    }
    _ = childPath
    _ = idxPath
}
```

--------------------------------

### In-memory resource map example

Source: https://github.com/yakwilik/go-yamlvalidator/blob/master/_autodocs/api-reference/jsonschema-resolvers.md

Creates an in-memory resolver mapping a URL to schema bytes. Use when the map must satisfy the JSONSchemaResolver interface; otherwise prefer JSONSchemaCompileOptions.Resources.

```go
resources := v.JSONSchemaResourceMap{
    "https://schemas.example.com/common.json": commonSchema,
}
```

--------------------------------

### Start Claude Code with the go-yamlvalidator plugin

Source: https://github.com/yakwilik/go-yamlvalidator/blob/master/README.md

Launches a local Claude Code session with the plugin directory specified. The plugin version is independent of the library version; adding it here does not publish it to an external marketplace.

```bash
claude --plugin-dir /absolute/path/to/go-yamlvalidator
```

--------------------------------

### Native FieldSchema schema example

Source: https://github.com/yakwilik/go-yamlvalidator/blob/master/_autodocs/api-reference/cli.md

Example native FieldSchema schema file. It defines a map with required key 'name' (string) and optional 'port' (int), sets an empty validators list, and uses unknownKeyPolicy 'error'.

```yaml
type: map
allowedKeys:
  name: {type: string, required: true}
  port: {type: int}
validators: []
unknownKeyPolicy: error

```

--------------------------------

### Go function adapter for ValueValidator

Source: https://github.com/yakwilik/go-yamlvalidator/blob/master/skills/go-yamlvalidator/references/native-validators.md

Complete example of a function adapter implementing the ValueValidator interface. The adapter wraps a function of type func(*yaml.Node, string, *v.ValidationContext) and calls it in Validate. The example also includes a forbidReserved callback that adds a validation error when the node is null and value is 'reserved'.

```go
type valueCheck func(*yaml.Node, string, *v.ValidationContext)

func (f valueCheck) Validate(node *yaml.Node, path string, ctx *v.ValidationContext) {
    f(node, path, ctx)
}

func forbidReserved(node *yaml.Node, path string, ctx *v.ValidationContext) {
    if node.Tag == "!!null" || node.Value != "reserved" {
        return
    }
    ctx.AddError(v.ValidationError{
        Level: v.LevelError,
        Code: "reserved_name",
        Path: path,
        Line: node.Line,
        Column: node.Column,
        Message: "name is reserved",
    })
}
```

--------------------------------

### RangeValidator usage example

Source: https://github.com/yakwilik/go-yamlvalidator/blob/master/_autodocs/api-reference/valuevalidators.md

Shows how to configure RangeValidator in a Validators slice, using either legacy float64 bounds or exact bounds for values not safely representable as float64.

```go
Validators: []v.ValueValidator{
    valv.RangeValidator{Min: v.Ptr[float64](1), Max: v.Ptr[float64](100)},
    // Or exact bounds for values not safely representable as float64:
    valv.RangeValidator{MinExact: valv.MustExactNumber("9007199254740993")},
},
```

--------------------------------

### LengthValidator usage example

Source: https://github.com/yakwilik/go-yamlvalidator/blob/master/_autodocs/api-reference/valuevalidators.md

Configures a LengthValidator with minimum length 1 and maximum length 255. Use v.Ptr[int] to create pointer values for the Min and Max fields.

```go
Validators: []v.ValueValidator{
    valv.LengthValidator{Min: v.Ptr[int](1), Max: v.Ptr[int](255)},
},
```

--------------------------------

### Quick start: validate YAML bytes

Source: https://github.com/yakwilik/go-yamlvalidator/blob/master/README.md

Defines a schema for a map with required 'name' and optional 'port', validates a YAML byte slice, and prints errors if any. Uses NewValidator for direct validation.

```go
package main

import (
    "fmt"

    v "github.com/Yakwilik/go-yamlvalidator"
)

func main() {
    schema := &v.FieldSchema{
        Type:             v.TypeMap,
        UnknownKeyPolicy: v.UnknownKeyError,
        AllowedKeys: map[string]*v.FieldSchema{
            "name": {Type: v.TypeString, Required: true},
            "port": {Type: v.TypeInt},
        },
    }

    data := []byte("name: api\nport: 8080\n")
    result := v.NewValidator(schema).ValidateBytes(data)

    if result.HasErrors() {
        fmt.Print(result.FormatAll(true))
    }
}
```

--------------------------------

### AnyOf: At Least One Group

Source: https://github.com/yakwilik/go-yamlvalidator/blob/master/README.md

Defines an AnyOf rule requiring at least one of the listed field groups to be present. In this example, either 'configFile' alone, or both 'host' and 'port' together must be provided.

```go
// Either configFile, OR both host AND port
AnyOf: [][]string{{"configFile"}, {"host", "port"}}
```

--------------------------------

### RegexValidator usage example

Source: https://github.com/yakwilik/go-yamlvalidator/blob/master/_autodocs/api-reference/valuevalidators.md

Shows how to attach a RegexValidator with a custom pattern and message. Validates that a value matches '^[a-z]+$' and uses the custom message 'must be lowercase letters'.

```go
Validators: []v.ValueValidator{
    valv.RegexValidator{
        Pattern: regexp.MustCompile(`^[a-z]+$`),
        Message: "must be lowercase letters",
    },
},
```

--------------------------------

### Simple functional keyword example (x-require-property)

Source: https://github.com/yakwilik/go-yamlvalidator/blob/master/_autodocs/api-reference/jsonschema-extensions.md

Shows how to define a simple custom keyword using the Validate field. The keyword checks that a property exists in the instance object. It uses ctx.MarkPropertyEvaluated and ctx.AddErrorAt to report errors. The keyword is registered via Options.Keywords and lives in an internal vocabulary with URL "urn:go-yamlvalidator:custom-keywords".

```go
keyword := v.JSONSchemaKeyword{
    Name: "x-require-property",
    Validate: func(raw, instance any, ctx *v.JSONSchemaKeywordValidationContext) {
        property, ok := raw.(string)
        if !ok {
            ctx.AddError("x-require-property expects a string")
            return
        }
        object, ok := instance.(map[string]any)
        if !ok {
            return
        }
        ctx.MarkPropertyEvaluated(property)
        if _, ok := object[property]; !ok {
            ctx.AddErrorAt([]string{property}, "required by x-require-property")
        }
    },
}

schema, err := v.CompileJSONSchemaWithOptions(schemaJSON, v.JSONSchemaCompileOptions{
    Keywords: []v.JSONSchemaKeyword{keyword},
})

```

--------------------------------

### Custom keyword with per-branch nested schemas using CompileWithContext

Source: https://github.com/yakwilik/go-yamlvalidator/blob/master/_autodocs/api-reference/jsonschema-extensions.md

Example of a custom keyword with per-branch nested schemas using CompileWithContext. It compiles each property as a subschema and dispatches validation based on the instance's "kind" field, adding an error for unknown kinds.

```go
keyword := v.JSONSchemaKeyword{
    Name: "x-dispatch",
    Subschemas: []v.JSONSchemaSubschemaPath{
        {v.JSONSchemaSubschemaAllProperties()},
    },
    CompileWithContext: func(
        ctx *v.JSONSchemaKeywordCompileContext,
        raw any,
    ) (v.JSONSchemaKeywordValidateFunc, error) {
        config := raw.(map[string]any)
        branches := make(map[string]*v.JSONSchemaSubschema, len(config))
        for name := range config {
            branches[name] = ctx.Subschema(name)
        }
        return func(instance any, validation *v.JSONSchemaKeywordValidationContext) {
            object, _ := instance.(map[string]any)
            kind, _ := object["kind"].(string)
            if branch := branches[kind]; branch != nil {
                validation.ValidateSubschema(branch, instance, nil)
            } else {
                validation.AddErrorAt([]string{"kind"}, "unknown kind")
            }
        }, nil
    },
}
```

--------------------------------

### Compile JSON Schema with custom content encodings and media types

Source: https://github.com/yakwilik/go-yamlvalidator/blob/master/README.md

Compiles a JSON Schema with options for content assertion, custom content encodings, and media types. Requires a schemaJSON byte slice and a yamlData variable. The example shows how to register custom decoders and validators.

```go
schema, err := v.CompileJSONSchemaWithOptions(schemaJSON, v.JSONSchemaCompileOptions{
    AssertContent: true,
    ContentEncodings: []v.JSONSchemaContentEncoding{
        {
            Name:   "my-encoding",
            Decode: decodeMyEncoding,
        },
    },
    ContentMediaTypes: []v.JSONSchemaContentMediaType{
        {
            Name:     "application/x-example",
            Validate: validateExampleMediaType,
        },
    },
})
```

--------------------------------

### Example output of FormatErrorWithSource

Source: https://github.com/yakwilik/go-yamlvalidator/blob/master/_autodocs/api-reference/diagnostics.md

Shows the expected output format when FormatErrorWithSource is called with a ValidationError and source lines. Includes the error header, preceding line, offending line with caret under the offending column, and following line.

```text
[ERROR] line 2:13: invalid value "v3" (expected one of [v1 v1beta1 apps/v1], got v3) (path: apiVersion)
     1 |
>    2 | apiVersion: v3
       |             ^
     3 | kind: Deployment
```

--------------------------------

### Labels map with RegexKeyValidator

Source: https://github.com/yakwilik/go-yamlvalidator/blob/master/_autodocs/api-reference/keyvalidators.md

Example of a labels map schema with format-validated keys. The map values are strings, and the key validator enforces a pattern that starts with an alphanumeric character and allows alphanumerics, dots, underscores, and hyphens. The custom message 'invalid label key format' is used.

```go
"labels": {
    Type:                 v.TypeMap,
    AdditionalProperties: &v.FieldSchema{Type: v.TypeString},
    KeyValidators: []v.KeyValidator{
        keyv.RegexKeyValidator{
            Pattern: regexp.MustCompile(`^[a-zA-Z0-9][a-zA-Z0-9._-]*$`),
            Message: "invalid label key format",
        },
    },
},
```

--------------------------------

### Run go test, race test, and vet

Source: https://github.com/yakwilik/go-yamlvalidator/blob/master/skills/go-yamlvalidator/references/execution-and-testing.md

Commands to run the standard testing suite, race detection, and vet checks within the repository.

```bash
go test ./...
go test -race ./...
go vet ./...
```

--------------------------------

### Compile schema from file with filesystem resolver

Source: https://github.com/yakwilik/go-yamlvalidator/blob/master/skills/go-yamlvalidator/references/resolvers.md

A complete helper that compiles a schema from a file path, setting up a file resolver rooted at the file's directory. Errors are propagated. The resolver rejects unsupported file URL hosts and paths outside the root, and resolves symlinks before reading.

```go
func CompileSchemaFile(path string) (*v.FieldSchema, error) {
    absolute, err := filepath.Abs(path)
    if err != nil { return nil, err }
    data, err := os.ReadFile(absolute)
    if err != nil { return nil, err }
    resolver, err := v.NewJSONSchemaFileResolver(filepath.Dir(absolute))
    if err != nil { return nil, err }
    uri := (&url.URL{Scheme: "file", Path: filepath.ToSlash(absolute)}).String()
    return v.CompileJSONSchemaWithOptions(data, v.JSONSchemaCompileOptions{
        SchemaURL: uri,
        Resolver: resolver,
    })
}
```

--------------------------------

### Use helper functions for pointers

Source: https://github.com/yakwilik/go-yamlvalidator/blob/master/README.md

Provides pointer helper functions for setting minimum and maximum values.

```go
MinItems: Ptr[int](1)
Max:      Ptr[float64](100)
```

--------------------------------

### InferNodeType usage example

Source: https://github.com/yakwilik/go-yamlvalidator/blob/master/_autodocs/api-reference/validator.md

Example usage of InferNodeType, as used by OneOfTypeValidator in pkg/valuevalidator. Calls the method on a validator instance with a YAML node and a validation context, storing the result in a variable named actual.

```go
actual := v.InferNodeType(node, ctx)
```

--------------------------------

### JSON Schema example for YAML validation

Source: https://github.com/yakwilik/go-yamlvalidator/blob/master/skills/go-yamlvalidator/references/json-schema.md

Example schema using standard JSON Schema keywords to validate an object with a required name, an array of unique worker strings, and an optional comment that can be null. Demonstrates that required alone does not imply type, so types are specified explicitly.

```json
{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "type": "object",
  "properties": {
    "name": {"type": "string", "minLength": 1},
    "workers": {
      "type": "array",
      "minItems": 1,
      "items": {"type": "string"},
      "uniqueItems": true
    },
    "comment": {"type": ["string", "null"]}
  },
  "required": ["name"],
  "additionalProperties": false
}
```

--------------------------------

### Using NonEmptyValidator in a Validators slice

Source: https://github.com/yakwilik/go-yamlvalidator/blob/master/_autodocs/api-reference/valuevalidators.md

Shows how to use NonEmptyValidator in a Validators slice. This is a usage example for the NonEmptyValidator.

```go
Validators: []v.ValueValidator{valv.NonEmptyValidator{}},
```

--------------------------------

### Custom value validator example

Source: https://github.com/yakwilik/go-yamlvalidator/blob/master/_autodocs/api-reference/fieldschema.md

Example custom ValueValidator that checks if a node's value equals "expected" and reports an error otherwise. Custom validators may run concurrently when the compiled validator is reused across goroutines; keep state immutable or synchronize. For child-node diagnostics use AppendPropertyPath / AppendIndexPath instead of string concatenation.

```go
type MyValidator struct{}

func (v MyValidator) Validate(node *yaml.Node, path string, ctx *ValidationContext) {
    if node.Value != "expected" {
        ctx.AddError(ValidationError{
            Level:   LevelError,
            Path:    path,
            Line:    node.Line,
            Column:  node.Column,
            Message: "value is not expected",
            Got:     node.Value,
        })
    }
}
```

--------------------------------

### Example output for multi-document error

Source: https://github.com/yakwilik/go-yamlvalidator/blob/master/README.md

Shows the error output for a multi-document YAML, with the error prefixed by 'doc[2].' to indicate the document index.

```text
[ERROR] line 5:1: required field "name" is missing (path: doc[2].name)
```

--------------------------------

### Plugin and skill directory layout

Source: https://github.com/yakwilik/go-yamlvalidator/blob/master/docs/agent-plugin.md

Directory layout of the plugin and skill, showing the manifest at the repository root and the skill directory containing all its files.

```text
.claude-plugin/plugin.json
skills/go-yamlvalidator/
  SKILL.md
  references/
  examples/native/
  examples/jsonschema/
  examples/recipes/
  assets/
  evals/
  scripts/check-examples.sh

```

--------------------------------

### EnumValidator usage example

Source: https://github.com/yakwilik/go-yamlvalidator/blob/master/_autodocs/api-reference/valuevalidators.md

Shows how to attach an EnumValidator to a schema's Validators list. Validates that a value is one of 'v1', 'v2', or 'v3'.

```go
Validators: []v.ValueValidator{
    valv.EnumValidator{Allowed: []string{"v1", "v2", "v3"}},
},
```

--------------------------------

### Run CLI with JSON Schema and format assertions

Source: https://github.com/yakwilik/go-yamlvalidator/blob/master/_autodocs/api-reference/cli.md

Command to run the CLI with a JSON Schema, enabling format assertions, setting a regexp timeout of 500ms, and limiting input to 2MB.

```bash
go run ./cmd/yamlvalidator \
  -schema ./schemas/config.schema.json \
  -schema-format jsonschema \
  -file ./config.yaml \
  -assert-format \
  -regexp-timeout 500ms \
  -max-bytes 2097152

```

--------------------------------

### Run CLI with native FieldSchema

Source: https://github.com/yakwilik/go-yamlvalidator/blob/master/_autodocs/api-reference/cli.md

Command to run the CLI with a native FieldSchema schema. Uses -schema-format field and -strict-keys to treat unknown keys as errors.

```bash
go run ./cmd/yamlvalidator \
  -schema /tmp/schema.yaml \
  -schema-format field \
  -file ./path/to/config.yaml \
  -strict-keys

```

--------------------------------

### Using URLValidator with scheme constraints

Source: https://github.com/yakwilik/go-yamlvalidator/blob/master/_autodocs/api-reference/valuevalidators.md

Shows how to use URLValidator with RequireScheme set to true and an allow-list of schemes. This configuration requires a scheme and only allows http and https.

```go
Validators: []v.ValueValidator{
    valv.URLValidator{RequireScheme: true, AllowedSchemes: []string{"http", "https"}},
},
```

--------------------------------

### Example output of formatted validation errors

Source: https://github.com/yakwilik/go-yamlvalidator/blob/master/README.md

Shows the formatted output of validation errors, including source context with line numbers and carets pointing to the offending values.

```text
[ERROR] line 2:13: invalid value "v3" (expected one of [v1 v1beta1 apps/v1], got v3) (path: apiVersion)
     1 |
>    2 | apiVersion: v3
       |             ^
     3 | kind: Deployment

[ERROR] line 5:9: must be lowercase DNS-compatible name (got MyApp) (path: metadata.name)
     4 | metadata:
>    5 |   name: MyApp
       |         ^
     6 |   namespace: production
```

--------------------------------

### ParseExactNumber usage example

Source: https://github.com/yakwilik/go-yamlvalidator/blob/master/_autodocs/api-reference/valuevalidators.md

Parses a large integer literal that cannot be represented exactly as float64. Returns an error if parsing fails; the resulting ExactNumber can be used as a bound in RangeValidator.

```go
bound, err := valv.ParseExactNumber("9007199254740993")
if err != nil {
    return err
}
```

--------------------------------

### Configure ValidationContext for ValidateWithOptions

Source: https://github.com/yakwilik/go-yamlvalidator/blob/master/_autodocs/configuration.md

Example of passing a ValidationContext struct to the ValidateWithOptions method to define validation constraints such as byte limits, document counts, and strict key checking.

```go
result := v.ValidateWithOptions(yaml, ValidationContext{
    StrictKeys:     true,
    StopOnFirst:    false,
    StrictTypes:    false,
    YAML11Booleans: false,

    MaxBytes:       2 << 20, // 2 MiB; 0 = unlimited
    MaxDocuments:   10,
    MaxDepth:       100,
    MaxDiagnostics: 100,
})
if result.Truncated {
    // MaxDiagnostics reached
}
```

--------------------------------

### Custom key validator implementation

Source: https://github.com/yakwilik/go-yamlvalidator/blob/master/README.md

Defines a custom key validator that flags keys starting with an underscore as warnings. It uses LevelWarning and includes the key value in the error.

```go
type MyKeyValidator struct{}

func (v MyKeyValidator) ValidateKey(key string, keyNode *yaml.Node, path string, ctx *ValidationContext) {
    if strings.HasPrefix(key, "_") {
        ctx.AddError(ValidationError{
            Level:   LevelWarning,
            Path:    path,
            Line:    keyNode.Line,
            Column:  keyNode.Column,
            Message: "keys starting with underscore are reserved",
            Got:     key,
        })
    }
}
```

--------------------------------

### Validate plugin and run tests

Source: https://github.com/yakwilik/go-yamlvalidator/blob/master/docs/agent-plugin.md

Commands to validate the plugin and run tests from the repository root. The last command tests against the published v1.0.0 module in a temporary workspace; it may download modules and does not alter the current module.

```bash
claude plugin validate .
go test -count=1 -run '^TestAgentPlugin' .
go test -count=1 ./skills/go-yamlvalidator/examples/...
go test -race ./skills/go-yamlvalidator/examples/...
bash skills/go-yamlvalidator/scripts/check-examples.sh

```

--------------------------------

### Multi-document YAML validation example

Source: https://github.com/yakwilik/go-yamlvalidator/blob/master/README.md

Shows a multi-document YAML input separated by '---'. The validator automatically handles such documents, and errors in subsequent documents are prefixed with 'doc[N].'.

```yaml
name: first
---
name: second
---
name: third
```
Tokens:
Raw