package app import ( "strings" "gitea.maximumdirect.net/eric/narratio/internal/artifactpolicy" "gitea.maximumdirect.net/eric/narratio/internal/artifacts" "gitea.maximumdirect.net/eric/narratio/internal/config" "gitea.maximumdirect.net/eric/narratio/internal/manifest" ) func buildHelperArtifactCatalog(cfg *config.Config, m *manifest.Manifest) (*artifacts.ArtifactCatalog, error) { configured := artifacts.ConfiguredArtifactDefinitions(nil) if cfg.Pipeline.Scriptorium != nil { configured = artifacts.ConfiguredArtifactDefinitions(cfg.ConcreteArtifacts()) } extractionDefinitions := artifacts.ExtractionDefinitionsFromConfig(cfg.Pipeline.Notarius) effective, err := artifacts.ResolveEffectiveArtifactSet(configured, nil) if err != nil { return nil, err } catalog, err := artifacts.BootstrapRuntimeCatalog(configured, effective, extractionDefinitions) if err != nil { return nil, err } paths := artifacts.NewLocalStore(cfg.Pipeline.Workspace.Root).SessionPathsFor(cfg.Session.Campaign, cfg.Session.SessionID) if cfg.Pipeline.Notarius != nil && cfg.Pipeline.Notarius.Enabled { catalog.HydrateExtractionArtifacts(paths, m, extractionDefinitions) } catalog.HydrateAnalyzeArtifacts(paths, m, configured) return catalog, nil } func remoteLockSourceSet(locks []artifacts.RemoteLock) map[string]struct{} { out := make(map[string]struct{}, len(locks)) for _, lock := range locks { out[lock.Source] = struct{}{} } return out } func committedPublishOutputOutcomes(m *manifest.Manifest) map[string]string { out := map[string]string{} if m == nil || m.Stages["publish"] == nil { return out } raw := m.Stages["publish"].Metadata["publish_output_outcomes"] appendOutcome := func(item map[string]any) { source, sourceOK := item["source"].(string) status, statusOK := item["status"].(string) if sourceOK && statusOK && isPublishOutputOutcome(status) { out[source] = status } } switch items := raw.(type) { case []any: for _, rawItem := range items { if item, ok := rawItem.(map[string]any); ok { appendOutcome(item) } } case []map[string]any: for _, item := range items { appendOutcome(item) } } return out } func isPublishOutputOutcome(status string) bool { switch status { case "published", "carried_locked", "locked_unpublished", "optional_missing", "unselected": return true default: return false } } func committedPublishedOutput(commit *artifacts.RemoteCommitManifest, source string) (artifacts.RemoteArtifact, bool) { if commit == nil { return artifacts.RemoteArtifact{}, false } for _, artifact := range commit.Artifacts { if artifact.Type == artifacts.RemoteArtifactTypePublishedOutput && artifact.Source == source { return artifact, true } } return artifacts.RemoteArtifact{}, false } func helperPublishedOutputDest(rule config.PublishOutputRule, catalog *artifacts.ArtifactCatalog) (string, bool, error) { source := strings.TrimSpace(rule.Source) normalized, err := artifactpolicy.ResolvePublishedDestinationWithExtractions( source, rule.Dest, helperConfiguredOutputPathMap(catalog), helperExtractionOutputSet(catalog), ) if err != nil { return "", false, err } entry, ok := catalog.Lookup(source) showDest := !ok || strings.TrimSpace(entry.CanonicalRelPath) != normalized return normalized, showDest, nil } func helperExtractionOutputSet(catalog *artifacts.ArtifactCatalog) map[string]struct{} { out := map[string]struct{}{} if catalog == nil { return out } for _, entry := range catalog.ListExtraction() { if strings.TrimSpace(entry.ExtractionKey) != "" { out[entry.ExtractionKey] = struct{}{} } } return out } func helperConfiguredOutputPathMap(catalog *artifacts.ArtifactCatalog) map[string]string { out := map[string]string{} if catalog == nil { return out } for _, entry := range catalog.ListConfigured() { if strings.TrimSpace(entry.ConfiguredKey) == "" { continue } out[entry.ConfiguredKey] = strings.TrimSpace(entry.CanonicalRelPath) } return out }