diff --git a/docs/roadmap/implementation.md b/docs/roadmap/implementation.md index 99a2214..8929177 100644 --- a/docs/roadmap/implementation.md +++ b/docs/roadmap/implementation.md @@ -426,6 +426,17 @@ declarations expose no field overrides; comparison results do not mutate inputs. ## Stage 10: Replace run and regeneration command wiring +**Completed.** Native run and artifacts-regenerate declarations use typed +selectors and the shared bounded planner/execution operation. Single-stage +selection rejects explicit range flags before bootstrap; regeneration fixes +forced extract-through-analyze without argv construction. Native reports expose +identities, selected/executed/skipped work, artifact targets, and completion +after acquisition cleanup. Removed the synthetic regeneration implementation; +obsolete routes and duplicate session identity flags are absent from the native +tree. Focused native execution, regeneration, selection, inspection, and bounded +family composition checks, builds, and diff checks pass with Go 1.27.4. Detailed +partial-run accounting remains assigned to Stage 15. + Read: `internal/app/run.go`, `bounded_run.go`, `regenerate_artifacts.go`, `planner.go`, analysis-selection helpers, and the roadmap command tree. diff --git a/internal/app/analyze_artifacts.go b/internal/app/analyze_artifacts.go index 1643cf6..adae2da 100644 --- a/internal/app/analyze_artifacts.go +++ b/internal/app/analyze_artifacts.go @@ -23,13 +23,17 @@ func (f *artifactSelectionFlag) Set(value string) error { } func (f *artifactSelectionFlag) Normalize() ([]string, error) { - if len(f.values) == 0 { + return normalizeArtifactNames(f.values) +} + +func normalizeArtifactNames(values []string) ([]string, error) { + if len(values) == 0 { return nil, nil } seen := map[string]struct{}{} - out := make([]string, 0, len(f.values)) - for _, raw := range f.values { + out := make([]string, 0, len(values)) + for _, raw := range values { for _, part := range strings.Split(raw, ",") { name := strings.TrimSpace(part) if name == "" { diff --git a/internal/app/command_outcome.go b/internal/app/command_outcome.go index 75c94a1..f4fa578 100644 --- a/internal/app/command_outcome.go +++ b/internal/app/command_outcome.go @@ -8,7 +8,12 @@ import ( // inputError identifies an invalid Narratio request independently of native // configuration diagnostics. Operational errors retain their own classification. -type inputError struct{ message string } +type inputError struct { + message string + cause error +} + +func (e *inputError) Unwrap() error { return e.cause } func (e *inputError) Error() string { return e.message } diff --git a/internal/app/commands.go b/internal/app/commands.go index 20e5b69..5caccd8 100644 --- a/internal/app/commands.go +++ b/internal/app/commands.go @@ -17,7 +17,8 @@ func newApplication(deps commandDependencies, executor pipelineExecutor) (*comma return commandkit.New( commandkit.Identity{Name: "narratio", Version: buildinfo.Version}, configurationCommand(deps), - commandkit.Group("artifacts", "Inspect and regenerate configured artifacts."), + executionCommand("run", "Execute a session pipeline.", false, deps, executor), + commandkit.Group("artifacts", "Inspect and regenerate configured artifacts.", executionCommand("regenerate", "Rebuild extraction and analysis artifacts.", true, deps, executor)), commandkit.Group("session", "Manage and inspect sessions."), ) } diff --git a/internal/app/execution_command.go b/internal/app/execution_command.go new file mode 100644 index 0000000..34713d7 --- /dev/null +++ b/internal/app/execution_command.go @@ -0,0 +1,136 @@ +package app + +import ( + "context" + "errors" + "fmt" + + "gitea.maximumdirect.net/eric/narratio/internal/config" + "go.maximumdirect.net/commandkit" +) + +type executionInput struct { + Selection configurationSelection + From, Through, Stage commandkit.Supplied[string] + Force commandkit.Supplied[bool] + Artifacts commandkit.Supplied[[]string] + PreviousSession commandkit.Supplied[string] + plan BoundedPlan + selectedArtifacts []string +} + +type runReport struct { + Campaign string `json:"campaign"` + SessionID string `json:"session_id"` + RunID string `json:"run_id"` + Stages []string `json:"stages"` + Executed []string `json:"executed"` + Skipped []string `json:"skipped"` + ArtifactTargets []string `json:"artifact_targets"` + Complete bool `json:"complete"` +} + +func checkExecutionInput(input *executionInput) error { + if err := checkConfigurationSelection(input.Selection); err != nil { + return err + } + if input.Stage.Set && (input.From.Set || input.Through.Set) { + return fmt.Errorf("--stage cannot be combined with --from or --through") + } + for _, field := range []struct { + name string + value commandkit.Supplied[string] + }{{"stage", input.Stage}, {"from", input.From}, {"through", input.Through}} { + if field.value.Set && field.value.Value == "" { + return fmt.Errorf("--%s requires a stage name", field.name) + } + } + from, through := input.From.Value, input.Through.Value + if input.Stage.Set { + from, through = input.Stage.Value, input.Stage.Value + } + plan, err := BuildBoundedPlan(from, through) + if err != nil { + return err + } + selected, err := normalizeArtifactNames(input.Artifacts.Value) + if err != nil { + return err + } + if len(selected) > 0 && !plan.Contains("analyze") && !plan.Contains("publish") { + return fmt.Errorf("--artifacts requires a selected range containing analyze or publish") + } + input.plan, input.selectedArtifacts = plan, selected + return nil +} + +func executionCommand(name, summary string, regenerate bool, deps commandDependencies, executor pipelineExecutor) commandkit.Command { + common := newConfigurationFlags(func(input **executionInput) *configurationSelection { return &(*input).Selection }) + flags := []commandkit.Flag[*executionInput]{common.Config, common.Overlay, common.Campaign, common.CampaignFile, common.SessionFile, common.PartyFile, common.SecretsDir, + commandkit.ValueFlag(commandkit.FlagMeta{Name: "previous-session-id", Usage: "Assert the previous session identity."}, nil, stringValue, func(input **executionInput, value commandkit.Supplied[string]) { (*input).PreviousSession = value }), + commandkit.RepeatFlag(commandkit.FlagMeta{Name: "artifacts", Usage: "Analysis artifact or family targets (repeatable or comma-separated)."}, []string(nil), stringValue, func(input **executionInput, value commandkit.Supplied[[]string]) { (*input).Artifacts = value }), + } + if !regenerate { + flags = append(flags, + commandkit.ValueFlag(commandkit.FlagMeta{Name: "stage", Usage: "Select one canonical pipeline stage."}, nil, stringValue, func(input **executionInput, value commandkit.Supplied[string]) { (*input).Stage = value }), + commandkit.ValueFlag(commandkit.FlagMeta{Name: "from", Usage: "First pipeline stage, inclusive."}, nil, stringValue, func(input **executionInput, value commandkit.Supplied[string]) { (*input).From = value }), + commandkit.ValueFlag(commandkit.FlagMeta{Name: "through", Usage: "Last pipeline stage, inclusive."}, nil, stringValue, func(input **executionInput, value commandkit.Supplied[string]) { (*input).Through = value }), + commandkit.BoolFlag(commandkit.FlagMeta{Name: "force", Usage: "Rerun selected stages."}, false, func(input **executionInput, value commandkit.Supplied[bool]) { (*input).Force = value }), + ) + } + return commandkit.NewCommand(commandkit.CommandSpec[*executionInput]{ + Name: name, Summary: summary, NewInput: func() *executionInput { return &executionInput{} }, Flags: flags, + Arguments: []commandkit.Argument[*executionInput]{commandkit.ValueArgument(commandkit.ArgumentMeta{Name: "SESSION", Usage: "Session identity."}, true, stringValue, func(input **executionInput, value commandkit.Supplied[string]) { (*input).Selection.Session = value })}, + CheckInput: func(input *executionInput) error { + if regenerate { + input.From = commandkit.Supplied[string]{Value: "extract", Set: true} + input.Through = commandkit.Supplied[string]{Value: "analyze", Set: true} + input.Force = commandkit.Supplied[bool]{Value: true, Set: true} + } + return checkExecutionInput(input) + }, + Run: func(invocation commandkit.Invocation, input *executionInput) commandkit.Outcome { + report, err := executeSelectedPipeline(invocation.Context, input, deps, executor) + if report != nil { + err = errors.Join(err, invocation.Reporter().Report(commandkit.Report{Value: report})) + } + return operationOutcome(err) + }, + }) +} + +func executeSelectedPipeline(ctx context.Context, input *executionInput, deps commandDependencies, executor pipelineExecutor) (report *runReport, err error) { + invocationDeps := normalizeCommandDependencies(deps) + invocationDeps.secretsBootstrap = &secretsBootstrap{} + acquired := newConfigurationAcquisition(input.Selection, invocationDeps) + acquired.previousSessionID = input.PreviousSession.Value + defer func() { + err = errors.Join(err, acquired.Close()) + if report != nil { + report.Complete = err == nil + } + }() + cfg, err := acquired.Domain(ctx) + if err != nil { + return nil, err + } + if err := config.Validate(cfg); err != nil { + return nil, err + } + selected, err := normalizeArtifactSelection(cfg, input.selectedArtifacts) + if err != nil { + return nil, &inputError{message: err.Error(), cause: err} + } + effective, err := resolveEffectiveArtifacts(cfg, selected) + if err != nil { + return nil, &inputError{message: err.Error(), cause: err} + } + summary, err := executor(ctx, cfg, input.plan, RunOptions{Force: input.Force.Value, SelectedArtifacts: selected, EffectiveArtifacts: effective}) + if summary == nil { + if err == nil { + err = fmt.Errorf("pipeline execution returned no run summary") + } + return nil, err + } + return &runReport{Campaign: config.CampaignID(cfg.Campaign), SessionID: summary.SessionID, RunID: summary.RunID, Stages: input.plan.Names(), Executed: summary.Executed, Skipped: summary.Skipped, ArtifactTargets: effective.Keys(), Complete: err == nil}, err +} diff --git a/internal/app/execution_command_test.go b/internal/app/execution_command_test.go new file mode 100644 index 0000000..013875f --- /dev/null +++ b/internal/app/execution_command_test.go @@ -0,0 +1,103 @@ +package app + +import ( + "bytes" + "context" + "encoding/json" + "reflect" + "testing" + + "gitea.maximumdirect.net/eric/narratio/internal/config" + "go.maximumdirect.net/commandkit" + configkit "go.maximumdirect.net/configkit" +) + +func TestExecutionCommandsUseTypedBoundedPlans(t *testing.T) { + pipeline, campaign, session := writeValidConfigFiles(t, t.TempDir()) + full, err := BuildBoundedPlan("", "") + if err != nil { + t.Fatal(err) + } + for _, test := range []struct { + name string + args, want []string + force bool + }{ + {"full", []string{"run", "2026-05-03"}, full.Names(), false}, + {"single", []string{"run", "2026-05-03", "--stage", "analyze"}, []string{"analyze"}, false}, + {"forced single", []string{"run", "2026-05-03", "--stage", "publish", "--force"}, []string{"publish"}, true}, + {"range", []string{"run", "2026-05-03", "--from", "extract", "--through", "analyze"}, []string{"extract", "analyze"}, false}, + {"regenerate", []string{"artifacts", "regenerate", "2026-05-03"}, []string{"extract", "analyze"}, true}, + } { + t.Run(test.name, func(t *testing.T) { + calls := 0 + executor := func(_ context.Context, cfg *config.Config, plan BoundedPlan, options RunOptions) (*RunSummary, error) { + calls++ + if !reflect.DeepEqual(plan.Names(), test.want) || options.Force != test.force { + t.Fatalf("plan=%v force=%v", plan.Names(), options.Force) + } + if cfg.Session.SessionID != "2026-05-03" || !options.EffectiveArtifacts.Resolved() { + t.Fatal("missing resolved execution inputs") + } + return &RunSummary{SessionID: cfg.Session.SessionID, RunID: "synthetic-run", Executed: plan.Names()}, nil + } + app, err := newApplication(commandDependencies{}, executor) + if err != nil { + t.Fatal(err) + } + args := append(append([]string{}, test.args...), "--config", pipeline, "--campaign-file", campaign, "--session-file", session, "--format", "json") + var out, diagnostic bytes.Buffer + outcome := app.Execute(context.Background(), args, commandkit.Streams{Out: &out, Err: &diagnostic}) + if outcome.Status != 0 || calls != 1 { + t.Fatalf("status=%d calls=%d diagnostics=%s", outcome.Status, calls, diagnostic.String()) + } + var report runReport + if err := json.Unmarshal(out.Bytes(), &report); err != nil { + t.Fatal(err) + } + if !report.Complete || report.Campaign != "sample-campaign" || !reflect.DeepEqual(report.Executed, test.want) { + t.Fatalf("report=%#v", report) + } + }) + } +} + +func TestExecutionCommandsRejectInvalidSelectionBeforeBootstrap(t *testing.T) { + app, err := newApplication(commandDependencies{ + loadSecretsDir: func(string) (*configkit.SecretsReport, error) { + t.Fatal("invalid input bootstrapped secrets") + return nil, nil + }, + loadPipelineConfig: func(string, config.PipelineLoadOptions) (*config.PipelineConfig, error) { + t.Fatal("invalid input loaded config") + return nil, nil + }, + }, func(context.Context, *config.Config, BoundedPlan, RunOptions) (*RunSummary, error) { + t.Fatal("invalid input executed pipeline") + return nil, nil + }) + if err != nil { + t.Fatal(err) + } + for _, args := range [][]string{ + {"run"}, {"run", "session", "--stage", "analyze", "--from", "analyze"}, + {"run", "session", "--stage", "analyze", "--through", "analyze"}, + {"run", "session", "--from", "publish", "--through", "prepare"}, + {"run", "session", "--stage", "missing"}, + {"run", "session", "--stage", "prepare", "--artifacts", "recap"}, + {"artifacts", "regenerate", "session", "--force=false"}, + {"artifacts", "regenerate", "session", "--through", "publish"}, + {"run", "session", "--session-id", "session"}, + {"run", "session", "--set", `/whisperx/language="fr"`}, + {"run-stage", "analyze", "session"}, + {"analyze", "session"}, + {"publish", "session"}, + {"regenerate-artifacts", "session"}, + } { + var out, diagnostic bytes.Buffer + outcome := app.Execute(context.Background(), args, commandkit.Streams{Out: &out, Err: &diagnostic}) + if outcome.Status != 2 { + t.Fatalf("%v: status=%d diagnostics=%s", args, outcome.Status, diagnostic.String()) + } + } +} diff --git a/internal/app/regenerate_artifacts.go b/internal/app/regenerate_artifacts.go deleted file mode 100644 index 9e6a406..0000000 --- a/internal/app/regenerate_artifacts.go +++ /dev/null @@ -1,51 +0,0 @@ -package app - -import ( - "context" - "fmt" - "io" -) - -// RegenerateArtifacts expands the convenience command into its canonical run -// invocation. The run command remains the sole owner of parsing and execution. -func RegenerateArtifacts(ctx context.Context, args []string, out io.Writer) error { - return regenerateArtifactsWithDependencies(ctx, args, out, executePlan, commandDependencies{}) -} - -func regenerateArtifactsWithPipelineExecutor(ctx context.Context, args []string, out io.Writer, executor pipelineExecutor) error { - return regenerateArtifactsWithDependencies(ctx, args, out, executor, commandDependencies{}) -} - -func regenerateArtifactsWithDependencies(ctx context.Context, args []string, out io.Writer, executor pipelineExecutor, deps commandDependencies) error { - if containsHelpOption(args) { - printRegenerateArtifactsHelp(out) - return nil - } - - expanded := make([]string, 0, len(args)+5) - if len(args) > 0 && !isCLIFlagToken(args[0]) { - expanded = append(expanded, args[0]) - args = args[1:] - } - expanded = append(expanded, "--force", "--from", "extract", "--through", "analyze") - expanded = append(expanded, args...) - return runWithDependencies(ctx, expanded, out, executor, deps) -} - -func containsHelpOption(args []string) bool { - for _, arg := range args { - if arg == "-h" || arg == "--help" { - return true - } - } - return false -} - -func printRegenerateArtifactsHelp(out io.Writer) { - _, _ = fmt.Fprintln(out, "Usage: narratio regenerate-artifacts [--artifacts ] [common config flags]") - _, _ = fmt.Fprintln(out) - _, _ = fmt.Fprintln(out, "Exactly equivalent to:") - _, _ = fmt.Fprintln(out, " narratio run --force --from extract --through analyze [caller options]") - _, _ = fmt.Fprintln(out) - _, _ = fmt.Fprintln(out, "Extraction always runs; selected analysis artifacts and their required prerequisites are rebuilt. Publish and notify never run.") -} diff --git a/internal/app/regenerate_artifacts_test.go b/internal/app/regenerate_artifacts_test.go index ddc8a23..a3e2a81 100644 --- a/internal/app/regenerate_artifacts_test.go +++ b/internal/app/regenerate_artifacts_test.go @@ -24,12 +24,12 @@ func TestRegenerateArtifactsForwardsCanonicalPipelineRequest(t *testing.T) { } code := executeWithPipelineExecutor([]string{ - "regenerate-artifacts", "2026-05-03", + "artifacts", "regenerate", "2026-05-03", "--artifacts", "session_recap,player_handout", "--artifacts=player_handout", "--config", pipelinePath, "--campaign-file", campaignPath, - "--session", sessionPath, + "--session-file", sessionPath, "--overlay", "testing", }, io.Discard, io.Discard, executor) if code != 0 { @@ -46,31 +46,6 @@ func TestRegenerateArtifactsForwardsCanonicalPipelineRequest(t *testing.T) { } } -func TestRegenerateArtifactsForwardsSessionIDCompatibilityFlag(t *testing.T) { - workspaceRoot := t.TempDir() - pipelinePath, campaignPath, sessionPath := writeValidConfigFilesWithScriptoriumArtifacts(t, workspaceRoot) - var capturedSessionID string - executor := func(_ context.Context, cfg *config.Config, _ BoundedPlan, _ RunOptions) (*RunSummary, error) { - capturedSessionID = cfg.Session.SessionID - return &RunSummary{SessionID: cfg.Session.SessionID, ManifestPath: "manifest.json"}, nil - } - - code := executeWithPipelineExecutor([]string{ - "regenerate-artifacts", - "--config", pipelinePath, - "--campaign-file", campaignPath, - "--session", sessionPath, - "--session-id", "2026-05-03", - "--artifacts", "session_recap", - }, io.Discard, io.Discard, executor) - if code != 0 { - t.Fatalf("executeWithPipelineExecutor() code = %d, want 0", code) - } - if capturedSessionID != "2026-05-03" { - t.Fatalf("session id = %q, want compatibility flag value", capturedSessionID) - } -} - func TestRegenerateArtifactsHelpDoesNotInvokeRun(t *testing.T) { called := false executor := func(context.Context, *config.Config, BoundedPlan, RunOptions) (*RunSummary, error) { @@ -80,16 +55,16 @@ func TestRegenerateArtifactsHelpDoesNotInvokeRun(t *testing.T) { var stdout bytes.Buffer var stderr bytes.Buffer - if code := executeWithPipelineExecutor([]string{"regenerate-artifacts", "--help"}, &stdout, &stderr, executor); code != 0 { + if code := executeWithPipelineExecutor([]string{"artifacts", "regenerate", "--help"}, &stdout, &stderr, executor); code != 0 { t.Fatalf("executeForTest() code = %d, stderr = %q", code, stderr.String()) } if called { t.Fatal("help invoked canonical run handler") } for _, detail := range []string{ - "narratio run --force --from extract --through analyze", - "Extraction always runs", - "Publish and notify never run", + "regenerate", + "--artifacts", + "--session-file", } { if !strings.Contains(stdout.String(), detail) { t.Fatalf("help = %q, want %q", stdout.String(), detail) @@ -99,37 +74,3 @@ func TestRegenerateArtifactsHelpDoesNotInvokeRun(t *testing.T) { t.Fatalf("stderr = %q, want empty", stderr.String()) } } - -func TestRegenerateArtifactsOwnedOptionsFailThroughRunParser(t *testing.T) { - for _, test := range []struct { - name string - args []string - owned string - }{ - {name: "force", args: []string{"--force"}, owned: "force"}, - {name: "from", args: []string{"--from=render"}, owned: "from"}, - {name: "through", args: []string{"--through", "publish"}, owned: "through"}, - } { - t.Run(test.name, func(t *testing.T) { - args := []string{"regenerate-artifacts", "2026-05-03"} - args = append(args, test.args...) - var stderr bytes.Buffer - if code := executeForTest(args, io.Discard, &stderr); code == 0 { - t.Fatalf("executeForTest(%#v) code = 0", args) - } - if !strings.Contains(stderr.String(), "--"+test.owned+" may be specified only once") { - t.Fatalf("stderr = %q, want shared duplicate %s error", stderr.String(), test.owned) - } - }) - } -} - -func TestRegenerateArtifactsRejectsUnknownOptionsThroughRunParser(t *testing.T) { - var stderr bytes.Buffer - if code := executeForTest([]string{"regenerate-artifacts", "2026-05-03", "--regenerate-only"}, io.Discard, &stderr); code == 0 { - t.Fatal("executeForTest() code = 0") - } - if !strings.Contains(stderr.String(), "flag provided but not defined") || !strings.Contains(stderr.String(), "regenerate-only") { - t.Fatalf("stderr = %q, want canonical parser unknown-option error", stderr.String()) - } -}