Function Encode

internal/artifact/encode.go:23–83

Encode serializes an Artifact to its portable on-disk form: --- --- Output is deterministic: two Encode calls on the same Artifact produce byte-identical output. The body is emitted verbatim, normalized to end with exactly one trailing newline, separated from the clo

(a Artifact)

// exactly one trailing newline, separated from the closing fence by exactly
// one blank line.
func Encode(a Artifact) ([]byte, error) {
	keys, err := FieldKeysForKind(a.Kind)
	if err != nil {
		return nil, fmt.Errorf("encode: %w", err)
	}

	fm := frontmatter{
		PadArtifact:   a.Kind,
		FormatVersion: a.FormatVersion,
		Title:         a.Title,
		Provenance:    a.Provenance,
	}
	if fm.FormatVersion == 0 {
		fm.FormatVersion = FormatVersion
	}
	if fm.Provenance.FormatVersion == 0 {
		fm.Provenance.FormatVersion = FormatVersion
	}

	for _, k := range keys {
		v, ok := a.Fields[k]
		if !ok || v == nil {
			continue
		}
		switch k {
		case "status":
			fm.Status = toString(v)
		case "trigger":
			fm.Trigger = toString(v)
		case "scope":
			fm.Scope = toString(v)
		case "invocation_slug":
			fm.InvocationSlug = toString(v)
		case "priority":
			fm.Priority = toString(v)
		case "role":
			fm.Role = toString(v)
		case "arguments":
			fm.Arguments = normalizeArguments(v)
		}
	}

	var buf bytes.Buffer
	enc := yaml.NewEncoder(&buf)
	enc.SetIndent(2)
	if err := enc.Encode(&fm); err != nil {
		return nil, fmt.Errorf("encode: marshal frontmatter: %w", err)
	}
	if err := enc.Close(); err != nil {
		return nil, fmt.Errorf("encode: close encoder: %w", err)
	}

	body := normalizeBody(a.Body)

	var out bytes.Buffer
	out.WriteString("---\n")
	out.Write(buf.Bytes())
	out.WriteString("---\n\n")