Files
narratio/internal/config/effective_pipeline.go

483 lines
16 KiB
Go
Raw Normal View History

package config
import (
"fmt"
2026-08-30 14:56:22 +00:00
"path/filepath"
"sort"
"strings"
configkit "go.maximumdirect.net/configkit"
"gopkg.in/yaml.v3"
)
// 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.
2026-08-30 14:56:22 +00:00
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 _, source := range result.Sources() {
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))
}
// EffectivePipelineSources projects pipeline ownership after resolution.
// It never includes effective values or raw secret
2026-08-30 14:56:22 +00:00
// 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
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
}
records = appendPipelineOwners(records, path, owners[path], cfg)
}
records = appendPublishOutputSources(records, cfg, owners)
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, 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 materializes completed configuration for persistence.
// Credentials retain reference names; domain catalogs remain separate.
func MarshalEffectivePipeline(cfg *PipelineConfig) ([]byte, error) {
if cfg == nil {
return nil, fmt.Errorf("pipeline config is required")
}
canonical, err := projectionJSON(projectEffectivePipeline(cfg))
if err != nil {
return nil, err
}
var document yaml.Node
if err := yaml.Unmarshal(canonical, &document); err != nil {
return nil, fmt.Errorf("decode pipeline materialization: %w", err)
}
var blockStyle func(*yaml.Node)
blockStyle = func(node *yaml.Node) {
node.Style = 0
for _, child := range node.Content {
blockStyle(child)
}
}
blockStyle(&document)
output, err := yaml.Marshal(&document)
if err != nil {
return nil, fmt.Errorf("serialize effective pipeline: %w", err)
}
return output, nil
}
func effectivePipelineOwners(cfg *PipelineConfig) (map[string][]string, error) {
2026-08-30 14:56:22 +00:00
owners := make(map[string][]string)
if cfg.ConfigKitResult() == 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)
metadata := cfg.ConfigKitResult().Metadata()
for _, value := range paths {
info, ok := metadata.Lookup(configkit.Keys(value.segments...))
sources := []string{pipelineDefaultOwnershipSource}
if ok {
sources = ownershipSources(info.Origin, pathsByID)
if info.Origin.Layer == configkit.LayerResolution {
for _, change := range metadata.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, partySources func(string) []string) []EffectivePipelineSourceRecord {
2026-08-30 14:56:22 +00:00
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 partySources(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, owners map[string][]string) []EffectivePipelineSourceRecord {
2026-08-30 14:56:22 +00:00
if cfg == nil || cfg.Publish == nil {
return records
}
for index := range cfg.Publish.Outputs {
2026-08-30 14:56:22 +00:00
path := fmt.Sprintf("publish.outputs[%d]", index)
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))
}