package app import ( "context" "encoding/json" "errors" "flag" "fmt" "io" "strings" "gitea.maximumdirect.net/eric/narratio/internal/config" configkit "go.maximumdirect.net/configkit" "gopkg.in/yaml.v3" ) type configDiffFlags struct { pipelinePath singletonStringFlag campaignPath singletonStringFlag campaignFilePath singletonStringFlag secretsDir singletonStringFlag } type configDiffRequest struct { leftOverlay string rightOverlay string flags configDiffFlags } type configDiffResolved struct { left *inspectionConfig right *inspectionConfig } // ConfigDiff compares two explicitly selected overlays through the same // read-only configuration resolution boundary used by config validate, show, // and sources. Differences describe normalized effective values rather than // the layout of root, import, or overlay files. func ConfigDiff(ctx context.Context, args []string, out io.Writer) error { return configDiffWithDependencies(ctx, args, out, commandDependencies{}) } func configDiffWithDependencies(_ context.Context, args []string, out io.Writer, deps commandDependencies) error { request, err := parseConfigDiffRequest(args, out) if err != nil { if errors.Is(err, flag.ErrHelp) { return nil } return err } resolved, err := resolveConfigDiff(request, deps) if err != nil { return fmt.Errorf("config diff: %w", err) } differences, err := config.DiffEffectivePipelines(resolved.left.Pipeline, resolved.right.Pipeline) if err != nil { return fmt.Errorf("config diff: %w", err) } if len(differences) == 0 { _, err := fmt.Fprintln(out, "no differences") return err } for _, difference := range differences { kind := "changed" if !difference.Left.Present { kind = "added" } if !difference.Right.Present { kind = "removed" } fields := []string{kind, difference.Path.String()} if difference.Left.Present { value, err := compactSnapshot(difference.Left) if err != nil { return err } fields = append(fields, value) } if difference.Right.Present { value, err := compactSnapshot(difference.Right) if err != nil { return err } fields = append(fields, value) } if difference.HiddenChanged { fields = append(fields, "hidden_changed=true") } if _, err := fmt.Fprintln(out, strings.Join(fields, "\t")); err != nil { return err } } return nil } func parseConfigDiffRequest(args []string, out io.Writer) (configDiffRequest, error) { overlays, flagArgs := splitConfigDiffArguments(args) fs := flag.NewFlagSet("config diff", flag.ContinueOnError) fs.SetOutput(out) var request configDiffRequest request.flags.pipelinePath.name = "config" request.flags.campaignPath.name = "campaign" request.flags.campaignFilePath.name = "campaign-file" request.flags.secretsDir.name = "secrets-dir" fs.Var(&request.flags.pipelinePath, "config", "path to pipeline.yml (optional; defaults searched)") fs.Var(&request.flags.campaignPath, "campaign", "campaign ID") fs.Var(&request.flags.campaignFilePath, "campaign-file", "path to campaign.yml") fs.Var(&request.flags.secretsDir, "secrets-dir", "secrets directory (optional; defaults to /usr/local/etc/narratio/secrets)") fs.Usage = func() { fmt.Fprintln(out, "Usage: narratio config diff [--config ] [--campaign | --campaign-file ] [--secrets-dir ]") fmt.Fprintln(out) fmt.Fprintln(out, "Compares fully resolved overlays without a session, workspace, manifest, adapters, or external services.") fmt.Fprintln(out) fmt.Fprintln(out, "Flags:") fs.PrintDefaults() } if err := fs.Parse(flagArgs); err != nil { return configDiffRequest{}, fmt.Errorf("config diff: invalid flags: %w", err) } overlays = append(overlays, fs.Args()...) if len(overlays) != 2 || strings.TrimSpace(overlays[0]) == "" || strings.TrimSpace(overlays[1]) == "" { return configDiffRequest{}, fmt.Errorf("config diff: exactly two non-empty overlay names are required") } if overlays[0] == overlays[1] { return configDiffRequest{}, fmt.Errorf("config diff: overlay names must differ") } if request.flags.campaignPath.set && request.flags.campaignFilePath.set { return configDiffRequest{}, fmt.Errorf("config diff: --campaign and --campaign-file are mutually exclusive") } request.leftOverlay = overlays[0] request.rightOverlay = overlays[1] return request, nil } // splitConfigDiffArguments accepts the documented positional-first syntax and // also permits flags before or between overlay names. Values belonging to the // supported string flags stay with their flag so they are not mistaken for // overlay names. func splitConfigDiffArguments(args []string) (overlays, flagArgs []string) { for index := 0; index < len(args); index++ { argument := args[index] if !strings.HasPrefix(argument, "-") || argument == "-" { overlays = append(overlays, argument) continue } flagArgs = append(flagArgs, argument) name, hasValue := strings.CutPrefix(argument, "--") if !hasValue { continue } name, _, hasInlineValue := strings.Cut(name, "=") if hasInlineValue || !configDiffStringFlag(name) || index+1 >= len(args) { continue } index++ flagArgs = append(flagArgs, args[index]) } return overlays, flagArgs } func configDiffStringFlag(name string) bool { switch name { case "config", "campaign", "campaign-file", "secrets-dir": return true default: return false } } func resolveConfigDiff(request configDiffRequest, deps commandDependencies) (*configDiffResolved, error) { deps = normalizeCommandDependencies(deps) pipelinePath, leftPipeline, err := loadPipelineConfigWithDependencies(request.flags.pipelinePath.value, config.PipelineLoadOptions{Overlay: &request.leftOverlay}, request.flags.secretsDir.pointer(), deps) if err != nil { return nil, fmt.Errorf("load left pipeline overlay: %w", err) } _, rightPipeline, err := loadPipelineConfigWithDependencies(pipelinePath, config.PipelineLoadOptions{Overlay: &request.rightOverlay}, request.flags.secretsDir.pointer(), deps) if err != nil { return nil, fmt.Errorf("load right pipeline overlay: %w", err) } needsCampaign := pipelineHasArtifactFamilies(leftPipeline) || pipelineHasArtifactFamilies(rightPipeline) hasCampaignSelection := request.flags.campaignPath.set || request.flags.campaignFilePath.set if !needsCampaign && !hasCampaignSelection { if err := validateInspectionPipeline(pipelinePath, leftPipeline); err != nil { return nil, err } if err := validateInspectionPipeline(pipelinePath, rightPipeline); err != nil { return nil, err } return &configDiffResolved{ left: &inspectionConfig{PipelinePath: pipelinePath, Pipeline: leftPipeline}, right: &inspectionConfig{PipelinePath: pipelinePath, Pipeline: rightPipeline}, }, nil } campaignPath, err := resolveSharedDiffCampaignPath(leftPipeline, rightPipeline, request.flags) if err != nil { if needsCampaign { return nil, fmt.Errorf("pipeline.scriptorium.artifact_families requires one shared campaign: %w", err) } return nil, err } campaign, err := config.LoadCampaign(campaignPath) if err != nil { return nil, err } if request.flags.campaignPath.set && !request.flags.campaignFilePath.set { if got := config.CampaignID(campaign); got != request.flags.campaignPath.value { return nil, fmt.Errorf("campaign config %q invalid: campaign_id %q does not match selected campaign %q", campaignPath, got, request.flags.campaignPath.value) } } leftLoaded, err := config.LoadPipelineCampaign(pipelinePath, leftPipeline, campaignPath, campaign) if err != nil { return nil, err } rightLoaded, err := config.LoadPipelineCampaignWithParty(pipelinePath, rightPipeline, campaignPath, campaign, leftLoaded.Party) if err != nil { return nil, err } if err := validateInspectionPipeline(leftLoaded.PipelinePath, leftLoaded.Pipeline); err != nil { return nil, err } if err := validateInspectionPipeline(rightLoaded.PipelinePath, rightLoaded.Pipeline); err != nil { return nil, err } if err := validateInspectionCampaign(campaignPath, campaign); err != nil { return nil, err } return &configDiffResolved{ left: &inspectionConfig{ PipelinePath: leftLoaded.PipelinePath, Pipeline: leftLoaded.Pipeline, CampaignPath: leftLoaded.CampaignPath, Campaign: campaign, Party: leftLoaded.Party, }, right: &inspectionConfig{ PipelinePath: rightLoaded.PipelinePath, Pipeline: rightLoaded.Pipeline, CampaignPath: rightLoaded.CampaignPath, Campaign: campaign, Party: rightLoaded.Party, }, }, nil } func resolveSharedDiffCampaignPath(left, right *config.PipelineConfig, flags configDiffFlags) (string, error) { leftPath, leftErr := resolveCampaignConfigPath(left, flags.campaignPath.value, flags.campaignFilePath.value) if leftErr != nil { return "", leftErr } rightPath, rightErr := resolveCampaignConfigPath(right, flags.campaignPath.value, flags.campaignFilePath.value) if rightErr != nil { return "", rightErr } if leftPath != rightPath { return "", fmt.Errorf("overlay selections resolve different campaign files; specify --campaign-file to compare one campaign") } return leftPath, nil } func compactSnapshot(snapshot configkit.ValueSnapshot) (string, error) { var value any if err := yaml.Unmarshal([]byte(snapshot.YAML), &value); err != nil { return "", fmt.Errorf("decode safe diff value: %w", err) } encoded, err := json.Marshal(value) if err != nil { return "", fmt.Errorf("encode safe diff value: %w", err) } return string(encoded), nil }