diff --git a/docs/roadmap/implementation.md b/docs/roadmap/implementation.md index bfa02b5..99a2214 100644 --- a/docs/roadmap/implementation.md +++ b/docs/roadmap/implementation.md @@ -391,6 +391,16 @@ result. Scope discovery and help cause no bootstrap, loading, or storage calls. ## Stage 9: Add independent comparisons and app inspection overrides +**Completed.** Native comparisons expose independent campaign/session/party +selectors and load each side separately with normal defaults. App-only native +overrides flow directly into ConfigKit; neither comparison sides nor later +invocations share overridden results. Removed the custom comparison parser, +renderer, same-campaign restrictions, and overlay-pair helper. Tests cover +independent root defaults, campaign/session files, explicit and default rosters, +one-time bootstrap, detailed differences/status 3, hidden credentials, and +unsupported-scope overrides. Configuration, stage, and artifact suites, focused +native/composition checks, builds, and diff checks pass with Go 1.27.4. + Read: upstream `ComparisonSide`, `Selector.AgainstName`, native override/diff contracts, and Narratio's old `config_diff.go`. diff --git a/internal/app/assembled_workflow_test.go b/internal/app/assembled_workflow_test.go index 19ea644..77fe48e 100644 --- a/internal/app/assembled_workflow_test.go +++ b/internal/app/assembled_workflow_test.go @@ -255,14 +255,9 @@ func TestAssembledSplitBundleCommandsUseOneEffectiveFamilyConfiguration(t *testi for _, operation := range []string{"validate", "show", "sources"} { nativeInspectionForTest(t, []string{"config", operation, "--config", pipelinePath, "--overlay", "testing"}) } - var diff bytes.Buffer - if err := ConfigDiff(context.Background(), []string{ - "default", "testing", "--config", pipelinePath, "--campaign-file", campaignPath, - }, &diff); err != nil { - t.Fatalf("compare profiles: %v", err) - } - if !strings.Contains(diff.String(), "/audita/proposal_profile") || !strings.Contains(diff.String(), "/character_items_arannis/profile_id") { - t.Fatalf("profile diff = %q, want proposal profile and expanded family changes", diff.String()) + diff := nativeInspectionForTest(t, []string{"config", "diff", "--details", "--config", pipelinePath, "--against-config", pipelinePath, "--against-overlay", "testing", "--format", "json"}) + if !strings.Contains(diff, "/audita/proposal_profile") || !strings.Contains(diff, "/scriptorium/artifact_families/character_items/profile_id") { + t.Fatalf("profile diff = %q, want authored profile changes", diff) } common := []string{ diff --git a/internal/app/config_commands_test.go b/internal/app/config_commands_test.go index 1c56e95..3f50eeb 100644 --- a/internal/app/config_commands_test.go +++ b/internal/app/config_commands_test.go @@ -10,7 +10,6 @@ import ( "testing" "gitea.maximumdirect.net/eric/narratio/internal/config" - configkit "go.maximumdirect.net/configkit" ) func TestExecuteConfigUsesInvocationPipelineLoader(t *testing.T) { @@ -45,186 +44,6 @@ func TestExecuteConfigUsesInvocationPipelineLoader(t *testing.T) { } } -func TestConfigDiffReportsSemanticOverlayChanges(t *testing.T) { - workspaceRoot := t.TempDir() - pipelinePath, _, _ := writeValidConfigFiles(t, workspaceRoot) - writeInspectionOverlays(t, pipelinePath, `workspace: - cleanup_after_publish: true -publish: - upload_run: true -whisperx: - language: en -audita: - modules: [glossary, grammar] -scriptorium: - artifacts: - production_only: - enabled: false - output_path: artifacts/production.md -`, `workspace: - cleanup_after_publish: false -whisperx: - language: fr -audita: - modules: [] -scriptorium: - artifacts: - testing_only: - enabled: false - output_path: artifacts/testing.md -`) - - args := []string{"production", "testing", "--config", pipelinePath} - var first, second bytes.Buffer - if err := ConfigDiff(context.Background(), args, &first); err != nil { - t.Fatalf("ConfigDiff() error = %v", err) - } - if err := ConfigDiff(context.Background(), args, &second); err != nil { - t.Fatalf("second ConfigDiff() error = %v", err) - } - if first.String() != second.String() { - t.Fatalf("diff output is not deterministic:\nfirst=%q\nsecond=%q", first.String(), second.String()) - } - output := first.String() - for _, want := range []string{ - "changed\t/audita/modules\t[\"glossary\",\"grammar\"]\t[]\n", - "changed\t/workspace/cleanup_after_publish\ttrue\tfalse\n", - "changed\t/whisperx/language\t\"en\"\t\"fr\"\n", - "removed\t/scriptorium/artifacts/production_only\t{", - "added\t/scriptorium/artifacts/testing_only\t{", - } { - if !strings.Contains(output, want) { - t.Fatalf("diff output missing %q:\n%s", want, output) - } - } - if strings.Index(output, "/audita/modules") > strings.Index(output, "/workspace/cleanup_after_publish") { - t.Fatalf("diff records are not sorted by path:\n%s", output) - } - var reversed bytes.Buffer - if err := ConfigDiff(context.Background(), []string{"testing", "production", "--config", pipelinePath}, &reversed); err != nil { - t.Fatalf("reversed ConfigDiff() error = %v", err) - } - if !strings.Contains(reversed.String(), "changed\t/whisperx/language\t\"fr\"\t\"en\"\n") { - t.Fatalf("reversed diff did not independently resolve overlays:\n%s", reversed.String()) - } -} - -func TestConfigDiffComparesExpandedFamiliesAndPublishRules(t *testing.T) { - pipelinePath, campaignPath := writeInspectionFamilyConfig(t) - writeInspectionOverlays(t, pipelinePath, `scriptorium: - artifact_families: - character_note: - enabled: false - member_vars: - character_name: character.name - publish: - enabled: true - required: false -`, `scriptorium: - artifact_families: - character_note: - enabled: true - prompt_id: dnd.character_note - member_vars: - character_name: character.class_summary - publish: - enabled: true - required: true -`) - - var out bytes.Buffer - if err := ConfigDiff(context.Background(), []string{ - "production", "testing", "--config", pipelinePath, "--campaign-file", campaignPath, - }, &out); err != nil { - t.Fatalf("ConfigDiff() error = %v", err) - } - output := out.String() - for _, want := range []string{ - "changed\t/scriptorium/artifacts/character_note_arannis/enabled\tfalse\ttrue\n", - "changed\t/scriptorium/artifacts/character_note_arannis/vars/character_name\t\"Arannis\"\t\"wizard\"\n", - "changed\t/publish/outputs\t", - } { - if !strings.Contains(output, want) { - t.Fatalf("family diff output missing %q:\n%s", want, output) - } - } -} - -func TestConfigDiffReportsEqualityAndRejectsInvalidInput(t *testing.T) { - workspaceRoot := t.TempDir() - pipelinePath, campaignPath, _ := writeValidConfigFiles(t, workspaceRoot) - writeInspectionOverlays(t, pipelinePath, "whisperx:\n language: en\n", "whisperx:\n language: en\n") - - var equal bytes.Buffer - if err := ConfigDiff(context.Background(), []string{"production", "testing", "--config", pipelinePath}, &equal); err != nil { - t.Fatalf("ConfigDiff() equal overlays error = %v", err) - } - if got := equal.String(); got != "no differences\n" { - t.Fatalf("equal diff output = %q", got) - } - - for _, args := range [][]string{ - {"production", "testing", "extra", "--config", pipelinePath}, - {"production", "--config", pipelinePath}, - {"production", "production", "--config", pipelinePath}, - {"unknown", "testing", "--config", pipelinePath}, - {"production", "testing", "--config", pipelinePath, "--overlay", "production"}, - {"production", "testing", "--config", pipelinePath, "--config", pipelinePath}, - {"production", "testing", "--config", pipelinePath, "--campaign", "sample-campaign", "--campaign-file", campaignPath}, - } { - if err := ConfigDiff(context.Background(), args, io.Discard); err == nil { - t.Fatalf("ConfigDiff(%q) succeeded, want error", args) - } - } -} - -func TestConfigDiffBootstrapsSecretsOnceForBothOverlays(t *testing.T) { - workspaceRoot := t.TempDir() - pipelinePath, _, _ := writeValidConfigFiles(t, workspaceRoot) - writeInspectionOverlays(t, pipelinePath, "whisperx:\n language: en\n", "whisperx:\n language: fr\n") - secretsDir := t.TempDir() - const secretName = "NARRATIO_DIFF_BOOTSTRAP_REPORT" - restoreEnvAfterTest(t, secretName) - if err := os.Unsetenv(secretName); err != nil { - t.Fatal(err) - } - mustWriteSecretFile(t, filepath.Join(secretsDir, secretName), "diff-secret-must-not-appear\n") - bootstrapCalls := 0 - var loadedPaths []string - var diagnostics bytes.Buffer - deps := commandDependencies{loadSecretsDir: func(got string) (*configkit.SecretsReport, error) { - bootstrapCalls++ - if got != secretsDir { - t.Fatalf("secrets directory = %q, want %q", got, secretsDir) - } - return configkit.LoadSecretsIntoEnvironment(got) - }, diagnostics: &diagnostics} - search := configkit.SearchPaths(pipelinePath) - deps.pipelineSearch = &search - deps.loadPipelineConfig = func(path string, opts config.PipelineLoadOptions) (*config.PipelineConfig, error) { - loadedPaths = append(loadedPaths, path) - return config.LoadPipelineWithOptions(path, opts) - } - - if err := configDiffWithDependencies(context.Background(), []string{ - "production", "testing", "--secrets-dir", secretsDir, - }, io.Discard, deps); err != nil { - t.Fatalf("config diff: %v", err) - } - if bootstrapCalls != 1 { - t.Fatalf("bootstrap calls = %d, want 1", bootstrapCalls) - } - if len(loadedPaths) != 2 || loadedPaths[0] != "" || loadedPaths[1] != pipelinePath { - t.Fatalf("pipeline load paths = %q, want discovery then selected root %q", loadedPaths, pipelinePath) - } - if got := diagnostics.String(); strings.Count(got, `name="`+secretName+`"`) != 1 { - t.Fatalf("bootstrap report count = %d, want 1; diagnostics = %q", strings.Count(got, `name="`+secretName+`"`), got) - } - if strings.Contains(diagnostics.String(), "diff-secret-must-not-appear") { - t.Fatalf("bootstrap diagnostics exposed secret value: %q", diagnostics.String()) - } -} - func writeInspectionOverlays(t *testing.T, pipelinePath, production, testing string) { t.Helper() overlaysDir := filepath.Join(filepath.Dir(pipelinePath), "overlays") @@ -335,13 +154,9 @@ func TestNativeBundleInspectionAndExecutionAgree(t *testing.T) { if !strings.Contains(catalog.String(), "character_meta_arannis") { t.Fatal("domain catalog omitted concrete family member") } - var diff bytes.Buffer - args := append([]string{"default", "testing"}, common...) - if err := ConfigDiff(context.Background(), args, &diff); err != nil { - t.Fatal(err) - } - if !strings.Contains(diff.String(), "/audita/proposal_profile") || strings.Contains(diff.String(), secretValue) { - t.Fatalf("unexpected diff: %s", diff.String()) + diff := nativeInspectionForTest(t, []string{"config", "diff", "--details", "--against-overlay", "testing", "--secrets-dir", secrets, "--format", "json"}) + if !strings.Contains(diff, "/audita/proposal_profile") || strings.Contains(diff, secretValue) { + t.Fatalf("unexpected diff: %s", diff) } workspace := filepath.Join(root, "conf.d", "workspace") if _, err := os.Stat(workspace); !os.IsNotExist(err) { diff --git a/internal/app/config_diff.go b/internal/app/config_diff.go deleted file mode 100644 index d55360c..0000000 --- a/internal/app/config_diff.go +++ /dev/null @@ -1,271 +0,0 @@ -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 -} diff --git a/internal/app/config_native_inspection_test.go b/internal/app/config_native_inspection_test.go deleted file mode 100644 index 74817cf..0000000 --- a/internal/app/config_native_inspection_test.go +++ /dev/null @@ -1,25 +0,0 @@ -package app - -import ( - "bytes" - "context" - "path/filepath" - "strings" - "testing" -) - -func TestConfigDiffUsesEscapedPointersAndAtomicLists(t *testing.T) { - dir := t.TempDir() - root := filepath.Join(dir, "pipeline.yml") - mustWriteTestFile(t, root, "whisperx: {transcribe_url: 'https://example.test/transcribe'}\nscriptorium:\n artifacts:\n recap:\n enabled: false\n output_path: artifacts/recap.md\n vars: {'a/b~c': before}\naudita: {modules: [glossary, grammar]}\n") - mustWriteTestFile(t, filepath.Join(dir, "overlays", "changed.yml"), "scriptorium:\n artifacts:\n recap:\n vars: {'a/b~c': after}\naudita: {modules: [glossary, homophones]}\n") - var output bytes.Buffer - if err := ConfigDiff(context.Background(), []string{"default", "changed", "--config", root}, &output); err != nil { - t.Fatal(err) - } - for _, want := range []string{"changed\t/audita/modules\t[\"glossary\",\"grammar\"]\t[\"glossary\",\"homophones\"]", "changed\t/scriptorium/artifacts/recap/vars/a~1b~0c\t\"before\"\t\"after\""} { - if !strings.Contains(output.String(), want) { - t.Fatalf("diff lacks %q: %s", want, output.String()) - } - } -} diff --git a/internal/app/configuration_acquisition.go b/internal/app/configuration_acquisition.go index e2bcfc7..200d63b 100644 --- a/internal/app/configuration_acquisition.go +++ b/internal/app/configuration_acquisition.go @@ -9,6 +9,7 @@ import ( "gitea.maximumdirect.net/eric/narratio/internal/config" "go.maximumdirect.net/commandkit" + configkit "go.maximumdirect.net/configkit" ) // configurationAcquisition belongs to one parsed selection, including one side @@ -24,6 +25,7 @@ type configurationAcquisition struct { session *acquiredSession previousSessionID string domain *config.Config + pipelineOverrides []configkit.Override } func newConfigurationAcquisition(selection configurationSelection, deps commandDependencies) *configurationAcquisition { @@ -77,7 +79,7 @@ func (a *configurationAcquisition) Pipeline(ctx context.Context) (*config.Pipeli return a.pipeline, nil } path, cfg, err := loadPipelineConfigWithDependencies(a.selection.Config.Value, - config.PipelineLoadOptions{Overlay: selectedString(a.selection.Overlay)}, + config.PipelineLoadOptions{Overlay: selectedString(a.selection.Overlay), Overrides: a.pipelineOverrides}, selectedString(a.selection.SecretsDir), a.deps) if err != nil { return nil, err diff --git a/internal/app/configuration_commands.go b/internal/app/configuration_commands.go index d561334..7eefd5c 100644 --- a/internal/app/configuration_commands.go +++ b/internal/app/configuration_commands.go @@ -12,11 +12,17 @@ import ( type configurationInspectionState struct { deps commandDependencies + independent bool acquisitions map[configurationSelection]*configurationAcquisition } func (s *configurationInspectionState) acquisition(selection ckconfig.Selection, input configurationSelection) *configurationAcquisition { input.Config, input.Overlay = selection.Config, selection.Overlay + if s.independent || len(selection.Overrides) != 0 { + acquired := newConfigurationAcquisition(input, s.deps) + acquired.pipelineOverrides = append([]configkit.Override(nil), selection.Overrides...) + return acquired + } acquired := s.acquisitions[input] if acquired == nil { acquired = newConfigurationAcquisition(input, s.deps) @@ -35,6 +41,7 @@ func configurationCommand(deps commandDependencies) commandkit.Command { } return cfg.ConfigKitResult(), nil }) + app.Features.Overrides = true campaign := ckconfig.FromConfigKit("campaign", "Campaign configuration.", func(ctx context.Context, selection ckconfig.Selection, input configurationSelection, state *configurationInspectionState) (*configkit.Result[config.CampaignConfig], error) { acquired := state.acquisition(selection, input) cfg, err := acquired.Campaign(ctx) @@ -60,6 +67,16 @@ func configurationCommand(deps commandDependencies) commandkit.Command { } return cfg.Canonical.ConfigKitResult(), nil }) + scopes := []ckconfig.Scope[configurationSelection, *configurationInspectionState]{app, campaign, session, party} + // Comparison sides share bootstrap services, but always load their own results. + for index := range scopes { + compare := scopes[index].Compare + scopes[index].Compare = func(ctx context.Context, request ckconfig.ComparisonRequest[configurationSelection], state *configurationInspectionState) (commandkit.Acquired[[]configkit.Difference], error) { + separate := *state + separate.independent = true + return compare(ctx, request, &separate) + } + } return ckconfig.Command(ckconfig.Suite[configurationSelection, *configurationInspectionState]{ NewState: func() *configurationInspectionState { invocationDeps := normalizeCommandDependencies(deps) @@ -71,13 +88,13 @@ func configurationCommand(deps commandDependencies) commandkit.Command { return checkConfigurationSelection(input) }, Selectors: []ckconfig.Selector[configurationSelection]{ - {Binding: flags.Campaign, Scopes: []string{"campaign", "session", "party"}}, - {Binding: flags.CampaignFile, Scopes: []string{"campaign", "session", "party"}}, - {Binding: flags.Session, Scopes: []string{"session"}}, - {Binding: flags.SessionFile, Scopes: []string{"session"}}, - {Binding: flags.PartyFile, Scopes: []string{"party"}}, + {Binding: flags.Campaign, AgainstName: "against-campaign", Scopes: []string{"campaign", "session", "party"}}, + {Binding: flags.CampaignFile, AgainstName: "against-campaign-file", Scopes: []string{"campaign", "session", "party"}}, + {Binding: flags.Session, AgainstName: "against-session", Scopes: []string{"session"}}, + {Binding: flags.SessionFile, AgainstName: "against-session-file", Scopes: []string{"session"}}, + {Binding: flags.PartyFile, AgainstName: "against-party-file", Scopes: []string{"party"}}, {Binding: flags.SecretsDir, Scopes: []string{"app", "campaign", "session", "party"}}, }, - Scopes: []ckconfig.Scope[configurationSelection, *configurationInspectionState]{app, campaign, session, party}, + Scopes: scopes, }) } diff --git a/internal/app/configuration_comparison_test.go b/internal/app/configuration_comparison_test.go new file mode 100644 index 0000000..a538a99 --- /dev/null +++ b/internal/app/configuration_comparison_test.go @@ -0,0 +1,142 @@ +package app + +import ( + "bytes" + "context" + "os" + "path/filepath" + "strings" + "testing" + + "gitea.maximumdirect.net/eric/narratio/internal/config" + "go.maximumdirect.net/commandkit" + configkit "go.maximumdirect.net/configkit" +) + +func TestConfigurationComparisonUsesIndependentRootDefaults(t *testing.T) { + left, _, _ := writeValidConfigFiles(t, t.TempDir()) + right, _, _ := writeValidConfigFiles(t, t.TempDir()) + search := configkit.SearchPaths(right) + loads, bootstrap := 0, 0 + app, err := newApplication(commandDependencies{ + pipelineSearch: &search, + loadPipelineConfig: func(path string, options config.PipelineLoadOptions) (*config.PipelineConfig, error) { + loads++ + return config.LoadPipelineWithOptions(path, options) + }, + loadSecretsDir: func(string) (*configkit.SecretsReport, error) { bootstrap++; return nil, nil }, + }, executePlan) + if err != nil { + t.Fatal(err) + } + var out, diagnostic bytes.Buffer + outcome := app.Execute(context.Background(), []string{"config", "diff", "--details", "--config", left, "--check", "--format", "json", "--secrets-dir", t.TempDir()}, commandkit.Streams{Out: &out, Err: &diagnostic}) + if outcome.Status != 3 || loads != 2 || bootstrap != 1 || !strings.Contains(out.String(), "/workspace/root") { + t.Fatalf("status=%d loads=%d bootstrap=%d output=%s diagnostics=%s", outcome.Status, loads, bootstrap, out.String(), diagnostic.String()) + } +} + +func TestConfigurationComparisonAndShowApplyOnlyAppOverrides(t *testing.T) { + pipeline, campaign, _ := writeValidConfigFiles(t, t.TempDir()) + before, err := os.ReadFile(pipeline) + if err != nil { + t.Fatal(err) + } + var out, diagnostic bytes.Buffer + args := []string{"config", "diff", "--details", "--config", pipeline, "--against-config", pipeline, "--set", `/whisperx/language="fr"`, "--against-set", `/whisperx/language="de"`, "--check", "--format", "json"} + outcome := Execute(context.Background(), args, commandkit.Streams{Out: &out, Err: &diagnostic}) + if outcome.Status != 3 || !strings.Contains(out.String(), "/whisperx/language") || !strings.Contains(out.String(), "fr") || !strings.Contains(out.String(), "de") { + t.Fatalf("status=%d output=%s diagnostics=%s", outcome.Status, out.String(), diagnostic.String()) + } + shown := nativeInspectionForTest(t, []string{"config", "show", "--config", pipeline, "--set", `/whisperx/language="fr"`, "--path", "/whisperx/language", "--format", "json"}) + if !strings.Contains(shown, "fr") { + t.Fatalf("override not applied: %s", shown) + } + shown = nativeInspectionForTest(t, []string{"config", "show", "--config", pipeline, "--path", "/whisperx/language", "--format", "json"}) + if strings.Contains(shown, "fr") { + t.Fatalf("override persisted into later invocation: %s", shown) + } + after, err := os.ReadFile(pipeline) + if err != nil || !bytes.Equal(before, after) { + t.Fatal("inspection modified source file") + } + for _, scope := range []string{"campaign", "session", "party", "all"} { + out.Reset() + diagnostic.Reset() + outcome := Execute(context.Background(), []string{"config", "show", "--scope", scope, "--config", pipeline, "--campaign-file", campaign, "--set", `/whisperx/language="fr"`}, commandkit.Streams{Out: &out, Err: &diagnostic}) + if outcome.Status != 2 { + t.Fatalf("scope %s accepted unsupported overrides: status=%d diagnostics=%s", scope, outcome.Status, diagnostic.String()) + } + } +} + +func TestConfigurationComparisonSeparatesCampaignSessionAndRoster(t *testing.T) { + _, leftCampaign, leftSession := writeValidConfigFiles(t, t.TempDir()) + _, rightCampaign, rightSession := writeValidConfigFiles(t, t.TempDir()) + rightBytes, err := os.ReadFile(rightCampaign) + if err != nil { + t.Fatal(err) + } + mustWriteTestFile(t, rightCampaign, strings.ReplaceAll(string(rightBytes), "sample-campaign", "other-campaign")) + mustWriteTestFile(t, rightSession, "session_id: 2026-05-03\ntitle: Independent right session\ninputs: {audio_dir: ./audio}\n") + campaignCfg, err := config.LoadCampaign(rightCampaign) + if err != nil { + t.Fatal(err) + } + party, err := config.ResolveParty(rightCampaign, campaignCfg, nil) + if err != nil { + t.Fatal(err) + } + mustWriteTestFile(t, party.Source.Path, "schema_version: narratio.party.v1\ncharacters:\n other_character:\n player: {name: Synthetic Player}\n character: {name: Synthetic Character, classes: [{name: ranger}]}\n") + leftCfg, err := config.LoadCampaign(leftCampaign) + if err != nil { + t.Fatal(err) + } + leftParty, err := config.ResolveParty(leftCampaign, leftCfg, nil) + if err != nil { + t.Fatal(err) + } + cases := []struct { + scope, path string + selectors []string + }{ + {"campaign", "/campaign_id", []string{"--campaign-file", leftCampaign, "--against-campaign-file", rightCampaign}}, + {"session", "/title", []string{"--campaign-file", leftCampaign, "--session", "2026-05-03", "--session-file", leftSession, "--against-campaign-file", rightCampaign, "--against-session", "2026-05-03", "--against-session-file", rightSession}}, + {"party", "/characters", []string{"--party-file", leftParty.Source.Path, "--against-campaign-file", rightCampaign}}, + {"party", "/characters", []string{"--party-file", leftParty.Source.Path, "--against-party-file", party.Source.Path}}, + } + for _, test := range cases { + var out, diagnostic bytes.Buffer + args := append([]string{"config", "diff", "--details", "--scope", test.scope, "--check", "--format", "json"}, test.selectors...) + outcome := Execute(context.Background(), args, commandkit.Streams{Out: &out, Err: &diagnostic}) + if outcome.Status != 3 || !strings.Contains(out.String(), test.path) { + t.Fatalf("scope=%s status=%d output=%s diagnostics=%s", test.scope, outcome.Status, out.String(), diagnostic.String()) + } + } + // An omitted right-side party selector uses normal campaign discovery, never + // the left side's exact party file. + defaultRoot := filepath.Join(t.TempDir(), "pipeline.yml") + mustWriteTestFile(t, defaultRoot, "whisperx: {transcribe_url: https://transcription.example.test/transcribe}\ncampaigns:\n root: "+filepath.Dir(filepath.Dir(rightCampaign))+"\n default_campaign_id: sample-campaign\n") + nativeInspectionForTest(t, []string{"config", "diff", "--details", "--scope", "party", "--party-file", leftParty.Source.Path, "--against-config", defaultRoot, "--format", "json"}) +} + +func TestConfigurationComparisonKeepsCredentialValuesHidden(t *testing.T) { + const leftSecret, rightSecret = "synthetic-left-comparison-secret", "synthetic-right-comparison-secret" + t.Setenv("NARRATIO_COMPARE_LEFT", leftSecret) + t.Setenv("NARRATIO_COMPARE_RIGHT", rightSecret) + left := filepath.Join(t.TempDir(), "left.yml") + right := filepath.Join(t.TempDir(), "right.yml") + base := "whisperx: {transcribe_url: https://transcription.example.test/transcribe}\n" + mustWriteTestFile(t, left, base+"audita: {credentials: [NARRATIO_COMPARE_LEFT]}\n") + mustWriteTestFile(t, right, base+"audita: {credentials: [NARRATIO_COMPARE_RIGHT]}\n") + var out, diagnostic bytes.Buffer + outcome := Execute(context.Background(), []string{"config", "diff", "--config", left, "--against-config", right, "--check", "--details", "--format", "json"}, commandkit.Streams{Out: &out, Err: &diagnostic}) + if outcome.Status != 3 { + t.Fatalf("status=%d output=%s diagnostics=%s", outcome.Status, out.String(), diagnostic.String()) + } + for _, secret := range []string{leftSecret, rightSecret} { + if strings.Contains(out.String()+diagnostic.String(), secret) { + t.Fatal("comparison exposed resolved credentials") + } + } +} diff --git a/internal/config/effective_digest.go b/internal/config/effective_digest.go index 7b8211a..6c8a44d 100644 --- a/internal/config/effective_digest.go +++ b/internal/config/effective_digest.go @@ -4,8 +4,6 @@ import ( "crypto/sha256" "encoding/hex" "fmt" - - configkit "go.maximumdirect.net/configkit" ) const ( @@ -61,11 +59,3 @@ func recomputePipelineEffectiveDigest(cfg *PipelineConfig) error { cfg.resolution.effectiveDigest = hex.EncodeToString(digest[:]) return nil } - -// DiffEffectivePipelines compares the authoritative native load results. -func DiffEffectivePipelines(left, right *PipelineConfig) ([]configkit.Difference, error) { - if left == nil || right == nil || left.ConfigKitResult() == nil || right.ConfigKitResult() == nil { - return nil, fmt.Errorf("resolved pipelines are required") - } - return configkit.Diff(left.ConfigKitResult(), right.ConfigKitResult()) -} diff --git a/internal/config/load.go b/internal/config/load.go index 2d258c9..4447161 100644 --- a/internal/config/load.go +++ b/internal/config/load.go @@ -18,8 +18,9 @@ func LoadPipeline(path string) (*PipelineConfig, error) { // PipelineLoadOptions carries an optional explicit overlay selection. Nil, // empty, and the exact name "default" select the base configuration. type PipelineLoadOptions struct { - Overlay *string - Search *configkit.Search + Overlay *string + Search *configkit.Search + Overrides []configkit.Override } // LoadPipelineWithOptions loads pipeline configuration with strict field @@ -32,24 +33,6 @@ func LoadPipelineWithOptions(path string, opts PipelineLoadOptions) (*PipelineCo return finalizeLoadedPipeline(cfg) } -// LoadPipelineOverlayPair resolves two overlays as independent ConfigKit loads. -func LoadPipelineOverlayPair(path, leftOverlay, rightOverlay string) (*PipelineConfig, *PipelineConfig, error) { - if leftOverlay == rightOverlay { - return nil, nil, fmt.Errorf("load pipeline overlays: left and right overlay selections must differ") - } - leftOptions := PipelineLoadOptions{Overlay: &leftOverlay} - rightOptions := PipelineLoadOptions{Overlay: &rightOverlay} - left, err := LoadPipelineWithOptions(path, leftOptions) - if err != nil { - return nil, nil, fmt.Errorf("load left pipeline overlay: %w", err) - } - right, err := LoadPipelineWithOptions(path, rightOptions) - if err != nil { - return nil, nil, fmt.Errorf("load right pipeline overlay: %w", err) - } - return left, right, nil -} - func finalizeLoadedPipeline(cfg *PipelineConfig) (*PipelineConfig, error) { if err := finalizePipelineResolution(cfg); err != nil { return nil, fmt.Errorf("load pipeline config: %w", err) diff --git a/internal/config/pipeline_configkit.go b/internal/config/pipeline_configkit.go index 297a325..01ade9c 100644 --- a/internal/config/pipeline_configkit.go +++ b/internal/config/pipeline_configkit.go @@ -46,7 +46,7 @@ func loadPipelineWithConfigKit(path string, opts PipelineLoadOptions) (*Pipeline } source = configkit.SearchConfig("narratio", search, configkit.SearchOptions{Required: true}) } - result, err := loadPipelineConfigKitResult(source, overlay) + result, err := loadPipelineConfigKitResult(source, overlay, opts.Overrides) if err != nil { return nil, describePipelineLoadError(err) } @@ -55,14 +55,15 @@ func loadPipelineWithConfigKit(path string, opts PipelineLoadOptions) (*Pipeline return cfg, nil } -func loadPipelineConfigKitResult(source configkit.Source, overlay string) (*configkit.Result[PipelineConfig], error) { +func loadPipelineConfigKitResult(source configkit.Source, overlay string, overrides []configkit.Override) (*configkit.Result[PipelineConfig], error) { invocationDir, err := os.Getwd() if err != nil { return nil, fmt.Errorf("capture invocation directory: %w", err) } return configkit.Load(source, configkit.Options[PipelineConfig]{ - Imports: true, - Overlay: overlay, + Imports: true, + Overrides: overrides, + Overlay: overlay, Definition: configkit.Definition[PipelineConfig]{ Defaults: pipelineConfigDefaults, Resolve: func(cfg *PipelineConfig, resolution *configkit.Resolution) error {