Files
narratio/internal/config/effective_pipeline.go

504 lines
17 KiB
Go
Raw Normal View History

package config
import (
"bytes"
"fmt"
2026-08-30 14:56:22 +00:00
"path/filepath"
"sort"
"strings"
configkit "go.maximumdirect.net/configkit"
)
// EffectivePipelineRootPath reports the absolute root pipeline path retained
// while resolving cfg. It is empty for a pipeline not loaded through the
// production loader.
func EffectivePipelineRootPath(cfg *PipelineConfig) string {
if cfg == nil || cfg.resolution == nil {
return ""
}
return cfg.resolution.rootPath
}
2026-08-30 14:56:22 +00:00
// EffectivePipelineImports reports the ordered, absolute import paths that
// contributed to cfg.
func EffectivePipelineImports(cfg *PipelineConfig) []string {
if cfg == nil || cfg.resolution == nil {
return nil
}
return append([]string(nil), cfg.resolution.imports...)
}
// NormalizedConfigurationPath returns a clean absolute path when possible for
// display-only configuration provenance.
func NormalizedConfigurationPath(path string) string {
return normalizedProvenancePath(path)
}
// EffectivePipelineSourceRecord identifies one effective logical field and a
// safe source that contributed to it. Generated values intentionally have two
// records: their family declaration and the canonical party that supplied the
// member-specific value.
type EffectivePipelineSourceRecord struct {
Path string
Role string
Source string
}
// EmptyImportSelection describes a native optional selection that acquired no source.
type EmptyImportSelection struct {
Source string
Path string
Selector string
Line int
Column int
}
func emptyImportSelections[T any](result *configkit.Result[T]) []EmptyImportSelection {
if result == nil {
return nil
}
var selections []EmptyImportSelection
for _, listed := range result.Sources() {
source, ok := result.Source(listed.ID)
if !ok {
continue
}
name := source.Path
if name == "" {
name = source.Label
}
for _, item := range source.EmptyImportSelections {
selections = append(selections, EmptyImportSelection{Source: name, Path: item.Path.String(), Selector: string(item.Selector), Line: item.Location.Line, Column: item.Location.Column})
}
}
return selections
}
// EffectiveEmptyImports reports only optional selections that acquired nothing.
func EffectiveEmptyImports(pipeline *PipelineConfig, campaign *CampaignConfig) []EmptyImportSelection {
var result []EmptyImportSelection
if pipeline != nil && pipeline.resolution != nil {
result = append(result, emptyImportSelections(pipeline.resolution.authoring)...)
}
if campaign != nil && campaign.resolution != nil {
result = append(result, emptyImportSelections(campaign.resolution.campaign)...)
}
return result
}
// EffectivePipelineValueRecord identifies one normalized, secret-free
// effective configuration value. Values use deterministic compact JSON
// representations so command output can be compared without raw YAML layout.
type EffectivePipelineValueRecord struct {
Path string
Value string
}
// EffectivePipelineValues projects a fully resolved pipeline into sorted
// logical configuration values. Mappings are flattened, while sequences remain
// atomic values. The projection uses the same normalized effective mapping as
2026-09-07 03:54:41 +00:00
// config show and therefore excludes loader directives and family declarations.
func EffectivePipelineValues(cfg *PipelineConfig) ([]EffectivePipelineValueRecord, error) {
if cfg == nil {
return nil, fmt.Errorf("pipeline config is required")
}
return projectionValueRecords(projectEffectivePipeline(cfg))
}
2026-08-30 14:56:22 +00:00
// EffectivePipelineSources projects pipeline ownership after defaults and
// optional family expansion. It never includes effective values or raw secret
// material, only logical paths and source identifiers.
func EffectivePipelineSources(cfg *PipelineConfig, party ResolvedParty) ([]EffectivePipelineSourceRecord, error) {
if cfg == nil {
return nil, fmt.Errorf("pipeline config is required")
}
2026-09-07 03:35:46 +00:00
values, err := EffectivePipelineValues(cfg)
2026-08-30 14:56:22 +00:00
if err != nil {
return nil, err
}
2026-09-07 03:35:46 +00:00
paths := make([]string, 0, len(values))
for _, value := range values {
paths = append(paths, value.Path)
2026-08-30 14:56:22 +00:00
}
owners, err := effectivePipelineOwners(cfg)
if err != nil {
return nil, err
}
2026-08-30 14:56:22 +00:00
families := ArtifactFamilies(cfg)
publishCount := 0
if cfg.Publish != nil {
publishCount = len(cfg.Publish.Outputs)
}
records := make([]EffectivePipelineSourceRecord, 0, len(paths)+publishCount)
for _, path := range paths {
if path == "publish.outputs" {
continue
}
if familyKey, ok := generatedArtifactFamilyForPath(path, families); ok {
records = appendGeneratedArtifactSources(records, path, familyKey, families, owners, party)
continue
}
records = appendPipelineOwners(records, path, owners[path], cfg)
}
records = appendPublishOutputSources(records, cfg, families, party, owners)
sort.Slice(records, func(left, right int) bool {
if records[left].Path != records[right].Path {
return records[left].Path < records[right].Path
}
if records[left].Role != records[right].Role {
return records[left].Role < records[right].Role
}
return records[left].Source < records[right].Source
})
return records, nil
}
// EffectiveCampaignSources projects selected campaign and party ownership
2026-09-02 12:04:35 +00:00
// without retaining or rendering campaign values. Players are derived from the
// canonical party source.
2026-08-30 14:56:22 +00:00
func EffectiveCampaignSources(campaignPath string, campaign *CampaignConfig, party ResolvedParty) []EffectivePipelineSourceRecord {
if campaign == nil {
return nil
}
fields := []string{"campaign_id", "inputs.autocorrect_file", "inputs.glossary_file", "inputs.speakers_file", "inputs.party_file"}
2026-08-30 14:56:22 +00:00
if strings.TrimSpace(campaign.Inputs.SpellCatalogFile) != "" {
fields = append(fields, "inputs.spell_catalog_file")
}
var records []EffectivePipelineSourceRecord
for _, field := range fields {
sources := campaignDefinitionSources(campaign, configkit.Keys(strings.Split(field, ".")...))
if len(sources) == 0 {
sources = []string{campaignPath}
}
for _, source := range sources {
records = append(records, EffectivePipelineSourceRecord{Path: "campaign." + field, Role: "campaign", Source: normalizedProvenancePath(source)})
}
2026-08-30 14:56:22 +00:00
}
2026-09-02 12:04:35 +00:00
partySource := normalizedProvenancePath(party.Source.Path)
records = append(records,
EffectivePipelineSourceRecord{Path: "campaign.inputs.party_file", Role: "party", Source: partySource},
EffectivePipelineSourceRecord{Path: "derived.players", Role: "party", Source: partySource},
)
2026-08-30 14:56:22 +00:00
sort.Slice(records, func(left, right int) bool {
if records[left].Path != records[right].Path {
return records[left].Path < records[right].Path
}
if records[left].Role != records[right].Role {
return records[left].Role < records[right].Role
}
return records[left].Source < records[right].Source
})
return records
}
func campaignDefinitionSources(campaign *CampaignConfig, path configkit.Path) []string {
if campaign.resolution == nil || campaign.resolution.campaign == nil {
return nil
}
result := campaign.resolution.campaign
var ids []string
add := func(origin configkit.Origin) {
for _, location := range origin.Locations {
ids = append(ids, location.SourceID)
}
for _, step := range origin.Inheritance {
for _, location := range step.Locations {
ids = append(ids, location.SourceID)
}
}
}
if info, ok := result.Metadata().Lookup(path); ok {
add(info.Origin)
}
for _, change := range result.Metadata().History(path) {
if change.Origin.Layer == configkit.LayerMain || change.Origin.Layer == configkit.LayerOverlay {
add(change.Origin)
}
}
var sources []string
for _, id := range nonEmptySortedStrings(ids) {
if source, ok := result.Source(id); ok {
name := source.Path
if name == "" {
name = source.Label
}
sources = append(sources, name)
}
}
return nonEmptySortedStrings(sources)
}
// MarshalEffectivePipeline renders the validated, normalized pipeline as one
// deterministic YAML document. Composition declarations and runtime-only
// resolution data are excluded. Artifact family declarations are also omitted
// because a resolved pipeline exposes their concrete artifacts instead.
func MarshalEffectivePipeline(cfg *PipelineConfig) ([]byte, error) {
if cfg == nil {
return nil, fmt.Errorf("pipeline config is required")
}
var snapshot *configkit.Result[effectivePipelineProjection]
if cfg.resolution != nil {
snapshot = cfg.resolution.inspection
}
if snapshot == nil {
var err error
snapshot, err = newPipelineInspection(cfg)
if err != nil {
return nil, err
}
}
var output bytes.Buffer
if err := snapshot.WriteEffective(&output); err != nil {
return nil, fmt.Errorf("serialize effective pipeline: %w", err)
}
return output.Bytes(), nil
}
func effectivePipelineOwners(cfg *PipelineConfig) (map[string][]string, error) {
2026-08-30 14:56:22 +00:00
owners := make(map[string][]string)
if cfg == nil || cfg.resolution == nil {
return owners, nil
2026-08-30 14:56:22 +00:00
}
paths, err := pipelineMetadataPaths(cfg)
if err != nil {
return nil, err
}
pathsByID := pipelineSourcePaths(cfg)
for _, value := range paths {
info, ok := cfg.resolution.configkitMetadata.Lookup(configkit.Keys(value.segments...))
sources := []string{pipelineDefaultOwnershipSource}
if ok {
sources = ownershipSources(info.Origin, pathsByID)
if info.Origin.Layer == configkit.LayerResolution {
for _, change := range cfg.resolution.configkitMetadata.History(configkit.Keys(value.segments...)) {
if change.Origin.Layer != configkit.LayerResolution {
continue
}
// Native Previous evidence identifies the input immediately before
// resolution, including composite and inherited origins.
for _, previous := range change.Previous {
if previous.Layer == configkit.LayerMain || previous.Layer == configkit.LayerOverlay {
sources = append(sources, ownershipSources(previous, pathsByID)...)
}
}
break
}
sources = nonEmptySortedStrings(sources)
}
}
owners[value.record.Path] = sources
2026-08-30 14:56:22 +00:00
}
2026-09-07 12:08:19 +00:00
if cfg.Scriptorium != nil {
for key, artifact := range cfg.Scriptorium.Artifacts {
paths := artifactDependencyOwnershipPaths(key, artifact)
if sources := sourcesForPipelinePaths(owners, paths); len(sources) != 0 {
sort.Strings(sources)
owners["scriptorium.artifacts."+key+".depends_on"] = sources
}
}
}
return owners, nil
2026-08-30 14:56:22 +00:00
}
2026-09-07 12:08:19 +00:00
func artifactDependencyOwnershipPaths(artifactKey string, artifact ScriptoriumArtifactConfig) []string {
var paths []string
for _, dependency := range artifact.DependsOn {
for _, origin := range artifact.dependencyOrigins[dependency] {
prefix := "scriptorium.artifacts." + artifactKey
if origin.family != "" {
prefix = "scriptorium.artifact_families." + origin.family
}
switch {
case origin.inputName != "":
paths = append(paths, prefix+".inputs."+origin.inputName+".source")
case origin.family != "":
paths = append(paths, prefix+".member_dependencies")
default:
paths = append(paths, prefix+".depends_on")
}
}
}
return paths
}
2026-08-30 14:56:22 +00:00
func generatedArtifactFamilyForPath(path string, families ArtifactFamilyCatalog) (string, bool) {
const prefix = "scriptorium.artifacts."
if !strings.HasPrefix(path, prefix) {
return "", false
}
memberPath := strings.TrimPrefix(path, prefix)
memberKey, _, _ := strings.Cut(memberPath, ".")
member, exists := families.Members[memberKey]
if !exists {
return "", false
}
_, exists = families.Families[member.Family]
return member.Family, exists
}
func appendGeneratedArtifactSources(records []EffectivePipelineSourceRecord, path, familyKey string, families ArtifactFamilyCatalog, owners map[string][]string, party ResolvedParty) []EffectivePipelineSourceRecord {
for _, source := range generatedArtifactSources(path, familyKey, families, owners) {
role := "family"
if source == pipelineDefaultOwnershipSource {
role = "default"
}
records = append(records, EffectivePipelineSourceRecord{Path: path, Role: role, Source: normalizedProvenanceSource(source)})
}
memberPath := strings.TrimPrefix(path, "scriptorium.artifacts.")
memberKey, _, _ := strings.Cut(memberPath, ".")
for _, source := range partyCharacterSources(party, families.Members[memberKey].CharacterID) {
records = append(records, EffectivePipelineSourceRecord{Path: path, Role: "party", Source: normalizedProvenancePath(source)})
2026-08-30 14:56:22 +00:00
}
return records
}
func generatedArtifactSources(path, familyKey string, families ArtifactFamilyCatalog, owners map[string][]string) []string {
const artifactPrefix = "scriptorium.artifacts."
memberPath := strings.TrimPrefix(path, artifactPrefix)
_, suffix, _ := strings.Cut(memberPath, ".")
familyPrefix := "scriptorium.artifact_families." + familyKey + "."
candidates := []string{familyPrefix + suffix}
switch {
case suffix == "output_path":
candidates = []string{familyPrefix + "output_path_pattern"}
case suffix == "depends_on":
2026-09-07 12:08:19 +00:00
candidates = []string{path, familyPrefix + "depends_on", familyPrefix + "member_dependencies"}
2026-08-30 14:56:22 +00:00
case strings.HasPrefix(suffix, "vars."):
variable := strings.TrimPrefix(suffix, "vars.")
candidates = []string{familyPrefix + "vars." + variable, familyPrefix + "member_vars." + variable}
}
sources := sourcesForPipelinePaths(owners, candidates)
if len(sources) != 0 {
return sources
}
if family, ok := families.Families[familyKey]; ok && len(family.Sources) != 0 {
return append([]string(nil), family.Sources...)
2026-08-30 14:56:22 +00:00
}
return []string{pipelineDefaultOwnershipSource}
}
func sourcesForPipelinePaths(owners map[string][]string, paths []string) []string {
seen := make(map[string]struct{})
var sources []string
for _, path := range paths {
for _, source := range owners[path] {
if _, exists := seen[source]; exists {
continue
}
seen[source] = struct{}{}
sources = append(sources, source)
}
}
return sources
}
func appendPipelineOwners(records []EffectivePipelineSourceRecord, path string, sources []string, cfg *PipelineConfig) []EffectivePipelineSourceRecord {
if len(sources) == 0 {
sources = []string{pipelineDefaultOwnershipSource}
}
for _, source := range sources {
records = append(records, EffectivePipelineSourceRecord{
Path: path, Role: pipelineSourceRole(cfg, source), Source: normalizedProvenanceSource(source),
})
}
return records
}
func appendPublishOutputSources(records []EffectivePipelineSourceRecord, cfg *PipelineConfig, families ArtifactFamilyCatalog, party ResolvedParty, owners map[string][]string) []EffectivePipelineSourceRecord {
if cfg == nil || cfg.Publish == nil {
return records
}
generated := make(map[string]string)
for familyKey, family := range families.Families {
if family.Publish == nil || !family.Publish.Enabled {
continue
}
for _, key := range family.Members {
generated["narratio.artifact."+key] = familyKey
}
}
for index, output := range cfg.Publish.Outputs {
path := fmt.Sprintf("publish.outputs[%d]", index)
if familyKey, ok := generated[strings.TrimSpace(output.Source)]; ok {
records = appendGeneratedPublishSources(records, path, familyKey, families, owners, party)
continue
}
records = appendPipelineOwners(records, path, owners["publish.outputs"], cfg)
}
return records
}
func appendGeneratedPublishSources(records []EffectivePipelineSourceRecord, path, familyKey string, families ArtifactFamilyCatalog, owners map[string][]string, party ResolvedParty) []EffectivePipelineSourceRecord {
familyPrefix := "scriptorium.artifact_families." + familyKey + ".publish."
sources := sourcesForPipelinePaths(owners, []string{familyPrefix + "enabled", familyPrefix + "required", familyPrefix + "dest_pattern"})
if len(sources) == 0 {
if family, ok := families.Families[familyKey]; ok && len(family.Sources) != 0 {
sources = append([]string(nil), family.Sources...)
2026-08-30 14:56:22 +00:00
} else {
sources = []string{pipelineDefaultOwnershipSource}
}
}
for _, source := range sources {
role := "family"
if source == pipelineDefaultOwnershipSource {
role = "default"
}
records = append(records, EffectivePipelineSourceRecord{Path: path, Role: role, Source: normalizedProvenanceSource(source)})
}
if source := normalizedProvenancePath(party.Source.Path); source != "" {
records = append(records, EffectivePipelineSourceRecord{Path: path, Role: "party", Source: source})
}
return records
}
func pipelineSourceRole(cfg *PipelineConfig, source string) string {
if source == pipelineDefaultOwnershipSource {
return "default"
}
2026-09-07 03:54:41 +00:00
if source == "resolution" {
return "resolution"
}
2026-08-30 14:56:22 +00:00
if cfg == nil || cfg.resolution == nil {
return "pipeline"
}
if source == cfg.resolution.rootPath {
return "root"
}
if cfg.resolution.selectedOverlay != nil && source == cfg.resolution.selectedOverlay.overlayPath {
return "overlay"
2026-08-30 14:56:22 +00:00
}
for _, imported := range cfg.resolution.imports {
if source == imported {
return "import"
}
}
return "pipeline"
}
func normalizedProvenanceSource(source string) string {
2026-09-07 03:54:41 +00:00
if source == pipelineDefaultOwnershipSource || source == "resolution" {
2026-08-30 14:56:22 +00:00
return source
}
return normalizedProvenancePath(source)
}
func normalizedProvenancePath(path string) string {
if strings.TrimSpace(path) == "" {
return ""
}
abs, err := filepath.Abs(path)
if err != nil {
return filepath.Clean(path)
}
return filepath.Clean(abs)
}
func campaignInputSourcePath(campaignPath, configuredPath string) string {
if filepath.IsAbs(configuredPath) {
return normalizedProvenancePath(configuredPath)
}
return normalizedProvenancePath(filepath.Join(filepath.Dir(campaignPath), configuredPath))
}