fix: add involves edge from task to agent:nomos at creation

Plus sync vendor directory for Docker build compatibility.
2026-08-11 22:03:12 +02:00
parent 7d6a3320d4
commit febc153b7f
3384 changed files with 945212 additions and 2 deletions
--- a/vendor/github.com/getkin/kin-openapi/openapi3/components.go
+++ b/vendor/github.com/getkin/kin-openapi/openapi3/components.go
@@ -0,0 +1,308 @@
+package openapi3
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"maps"
+
+	"github.com/go-openapi/jsonpointer"
+)
+
+type Callbacks map[string]*CallbackRef             // Callbacks represents components' named callbacks
+type Examples map[string]*ExampleRef               // Examples represents components' named examples
+type Headers map[string]*HeaderRef                 // Headers represents components' named headers
+type Links map[string]*LinkRef                     // Links represents components' named links
+type ParametersMap map[string]*ParameterRef        // ParametersMap represents components' named parameters
+type RequestBodies map[string]*RequestBodyRef      // RequestBodies represents components' named request bodies
+type ResponseBodies map[string]*ResponseRef        // ResponseBodies represents components' named response bodies
+type Schemas map[string]*SchemaRef                 // Schemas represents components' named schemas
+type SecuritySchemes map[string]*SecuritySchemeRef // SecuritySchemes represents components' named security schemes
+
+// Components is specified by OpenAPI/Swagger standard version 3.
+// See https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.0.3.md#components-object
+type Components struct {
+	Extensions map[string]any `json:"-" yaml:"-"`
+	Origin     *Origin        `json:"-" yaml:"-"`
+
+	Schemas         Schemas         `json:"schemas,omitempty" yaml:"schemas,omitempty"`
+	Parameters      ParametersMap   `json:"parameters,omitempty" yaml:"parameters,omitempty"`
+	Headers         Headers         `json:"headers,omitempty" yaml:"headers,omitempty"`
+	RequestBodies   RequestBodies   `json:"requestBodies,omitempty" yaml:"requestBodies,omitempty"`
+	Responses       ResponseBodies  `json:"responses,omitempty" yaml:"responses,omitempty"`
+	SecuritySchemes SecuritySchemes `json:"securitySchemes,omitempty" yaml:"securitySchemes,omitempty"`
+	Examples        Examples        `json:"examples,omitempty" yaml:"examples,omitempty"`
+	Links           Links           `json:"links,omitempty" yaml:"links,omitempty"`
+	Callbacks       Callbacks       `json:"callbacks,omitempty" yaml:"callbacks,omitempty"`
+}
+
+func NewComponents() Components {
+	return Components{}
+}
+
+// MarshalJSON returns the JSON encoding of Components.
+func (components Components) MarshalJSON() ([]byte, error) {
+	x, err := components.MarshalYAML()
+	if err != nil {
+		return nil, err
+	}
+	return json.Marshal(x)
+}
+
+// MarshalYAML returns the YAML encoding of Components.
+func (components Components) MarshalYAML() (any, error) {
+	m := make(map[string]any, 9+len(components.Extensions))
+	maps.Copy(m, components.Extensions)
+	if x := components.Schemas; len(x) != 0 {
+		m["schemas"] = x
+	}
+	if x := components.Parameters; len(x) != 0 {
+		m["parameters"] = x
+	}
+	if x := components.Headers; len(x) != 0 {
+		m["headers"] = x
+	}
+	if x := components.RequestBodies; len(x) != 0 {
+		m["requestBodies"] = x
+	}
+	if x := components.Responses; len(x) != 0 {
+		m["responses"] = x
+	}
+	if x := components.SecuritySchemes; len(x) != 0 {
+		m["securitySchemes"] = x
+	}
+	if x := components.Examples; len(x) != 0 {
+		m["examples"] = x
+	}
+	if x := components.Links; len(x) != 0 {
+		m["links"] = x
+	}
+	if x := components.Callbacks; len(x) != 0 {
+		m["callbacks"] = x
+	}
+	return m, nil
+}
+
+// UnmarshalJSON sets Components to a copy of data.
+func (components *Components) UnmarshalJSON(data []byte) error {
+	type ComponentsBis Components
+	var x ComponentsBis
+	if err := json.Unmarshal(data, &x); err != nil {
+		return unmarshalError(err)
+	}
+	_ = json.Unmarshal(data, &x.Extensions)
+	delete(x.Extensions, "schemas")
+	delete(x.Extensions, "parameters")
+	delete(x.Extensions, "headers")
+	delete(x.Extensions, "requestBodies")
+	delete(x.Extensions, "responses")
+	delete(x.Extensions, "securitySchemes")
+	delete(x.Extensions, "examples")
+	delete(x.Extensions, "links")
+	delete(x.Extensions, "callbacks")
+	if len(x.Extensions) == 0 {
+		x.Extensions = nil
+	}
+	*components = Components(x)
+	return nil
+}
+
+// Validate returns an error if Components does not comply with the OpenAPI spec.
+func (components *Components) Validate(ctx context.Context, opts ...ValidationOption) error {
+	ctx = WithValidationOptions(ctx, opts...)
+	me := newErrCollector(ctx)
+
+	validateMap := func(label string, names []string, validate func(k string) error) error {
+		for _, k := range names {
+			if idErr := ValidateIdentifier(k); idErr != nil {
+				if err := me.emit(&ComponentValidationError{Section: label, Name: k, Cause: idErr}); err != nil {
+					return err
+				}
+				// Skip validating the component's value when its name is
+				// invalid: any leaf error from validate(k) would surface as
+				// "<bad-name>: <leaf-error>" and has no resolution path
+				// until the name is fixed. The continue keeps the noise
+				// per component bounded to a single, actionable finding.
+				continue
+			}
+			wrap := func(e error) error { return &ComponentValidationError{Section: label, Name: k, Cause: e} }
+			if err := me.emitWrapped(wrap, validate(k)); err != nil {
+				return err
+			}
+		}
+		return nil
+	}
+
+	if err := validateMap("schema", componentNames(components.Schemas), func(k string) error {
+		return components.Schemas[k].Validate(ctx)
+	}); err != nil {
+		return err
+	}
+
+	if err := validateMap("parameter", componentNames(components.Parameters), func(k string) error {
+		return components.Parameters[k].Validate(ctx)
+	}); err != nil {
+		return err
+	}
+
+	if err := validateMap("request body", componentNames(components.RequestBodies), func(k string) error {
+		return components.RequestBodies[k].Validate(ctx)
+	}); err != nil {
+		return err
+	}
+
+	if err := validateMap("response", componentNames(components.Responses), func(k string) error {
+		return components.Responses[k].Validate(ctx)
+	}); err != nil {
+		return err
+	}
+
+	if err := validateMap("header", componentNames(components.Headers), func(k string) error {
+		return components.Headers[k].Validate(ctx)
+	}); err != nil {
+		return err
+	}
+
+	if err := validateMap("security scheme", componentNames(components.SecuritySchemes), func(k string) error {
+		return components.SecuritySchemes[k].Validate(ctx)
+	}); err != nil {
+		return err
+	}
+
+	if err := validateMap("example", componentNames(components.Examples), func(k string) error {
+		return components.Examples[k].Validate(ctx)
+	}); err != nil {
+		return err
+	}
+
+	if err := validateMap("link", componentNames(components.Links), func(k string) error {
+		return components.Links[k].Validate(ctx)
+	}); err != nil {
+		return err
+	}
+
+	if err := validateMap("callback", componentNames(components.Callbacks), func(k string) error {
+		return components.Callbacks[k].Validate(ctx)
+	}); err != nil {
+		return err
+	}
+
+	return me.finalize(validateExtensions(ctx, components.Extensions, components.Origin))
+}
+
+var _ jsonpointer.JSONPointable = (*Schemas)(nil)
+
+// JSONLookup implements https://pkg.go.dev/github.com/go-openapi/jsonpointer#JSONPointable
+func (m Schemas) JSONLookup(token string) (any, error) {
+	if v, ok := m[token]; !ok || v == nil {
+		return nil, fmt.Errorf("no schema %q", token)
+	} else if ref := v.Ref; ref != "" {
+		return &Ref{Ref: ref}, nil
+	} else {
+		return v.Value, nil
+	}
+}
+
+var _ jsonpointer.JSONPointable = (*ParametersMap)(nil)
+
+// JSONLookup implements https://pkg.go.dev/github.com/go-openapi/jsonpointer#JSONPointable
+func (m ParametersMap) JSONLookup(token string) (any, error) {
+	if v, ok := m[token]; !ok || v == nil {
+		return nil, fmt.Errorf("no parameter %q", token)
+	} else if ref := v.Ref; ref != "" {
+		return &Ref{Ref: ref}, nil
+	} else {
+		return v.Value, nil
+	}
+}
+
+var _ jsonpointer.JSONPointable = (*Headers)(nil)
+
+// JSONLookup implements https://pkg.go.dev/github.com/go-openapi/jsonpointer#JSONPointable
+func (m Headers) JSONLookup(token string) (any, error) {
+	if v, ok := m[token]; !ok || v == nil {
+		return nil, fmt.Errorf("no header %q", token)
+	} else if ref := v.Ref; ref != "" {
+		return &Ref{Ref: ref}, nil
+	} else {
+		return v.Value, nil
+	}
+}
+
+var _ jsonpointer.JSONPointable = (*RequestBodyRef)(nil)
+
+// JSONLookup implements https://pkg.go.dev/github.com/go-openapi/jsonpointer#JSONPointable
+func (m RequestBodies) JSONLookup(token string) (any, error) {
+	if v, ok := m[token]; !ok || v == nil {
+		return nil, fmt.Errorf("no request body %q", token)
+	} else if ref := v.Ref; ref != "" {
+		return &Ref{Ref: ref}, nil
+	} else {
+		return v.Value, nil
+	}
+}
+
+var _ jsonpointer.JSONPointable = (*ResponseRef)(nil)
+
+// JSONLookup implements https://pkg.go.dev/github.com/go-openapi/jsonpointer#JSONPointable
+func (m ResponseBodies) JSONLookup(token string) (any, error) {
+	if v, ok := m[token]; !ok || v == nil {
+		return nil, fmt.Errorf("no response body %q", token)
+	} else if ref := v.Ref; ref != "" {
+		return &Ref{Ref: ref}, nil
+	} else {
+		return v.Value, nil
+	}
+}
+
+var _ jsonpointer.JSONPointable = (*SecuritySchemes)(nil)
+
+// JSONLookup implements https://pkg.go.dev/github.com/go-openapi/jsonpointer#JSONPointable
+func (m SecuritySchemes) JSONLookup(token string) (any, error) {
+	if v, ok := m[token]; !ok || v == nil {
+		return nil, fmt.Errorf("no security scheme body %q", token)
+	} else if ref := v.Ref; ref != "" {
+		return &Ref{Ref: ref}, nil
+	} else {
+		return v.Value, nil
+	}
+}
+
+var _ jsonpointer.JSONPointable = (*Examples)(nil)
+
+// JSONLookup implements https://pkg.go.dev/github.com/go-openapi/jsonpointer#JSONPointable
+func (m Examples) JSONLookup(token string) (any, error) {
+	if v, ok := m[token]; !ok || v == nil {
+		return nil, fmt.Errorf("no example body %q", token)
+	} else if ref := v.Ref; ref != "" {
+		return &Ref{Ref: ref}, nil
+	} else {
+		return v.Value, nil
+	}
+}
+
+var _ jsonpointer.JSONPointable = (*Links)(nil)
+
+// JSONLookup implements https://pkg.go.dev/github.com/go-openapi/jsonpointer#JSONPointable
+func (m Links) JSONLookup(token string) (any, error) {
+	if v, ok := m[token]; !ok || v == nil {
+		return nil, fmt.Errorf("no link body %q", token)
+	} else if ref := v.Ref; ref != "" {
+		return &Ref{Ref: ref}, nil
+	} else {
+		return v.Value, nil
+	}
+}
+
+var _ jsonpointer.JSONPointable = (*Callbacks)(nil)
+
+// JSONLookup implements https://pkg.go.dev/github.com/go-openapi/jsonpointer#JSONPointable
+func (m Callbacks) JSONLookup(token string) (any, error) {
+	if v, ok := m[token]; !ok || v == nil {
+		return nil, fmt.Errorf("no callback body %q", token)
+	} else if ref := v.Ref; ref != "" {
+		return &Ref{Ref: ref}, nil
+	} else {
+		return v.Value, nil
+	}
+}