Expose native session planning and artifact catalogs
This commit is contained in:
180
internal/app/plan_command.go
Normal file
180
internal/app/plan_command.go
Normal file
@@ -0,0 +1,180 @@
|
||||
package app
|
||||
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"fmt"
|
||||
"time"
|
||||
|
||||
"gitea.maximumdirect.net/eric/narratio/internal/artifacts"
|
||||
"gitea.maximumdirect.net/eric/narratio/internal/config"
|
||||
"gitea.maximumdirect.net/eric/narratio/internal/stage"
|
||||
"go.maximumdirect.net/commandkit"
|
||||
)
|
||||
|
||||
type sessionPlanReport struct {
|
||||
Campaign string `json:"campaign"`
|
||||
SessionID string `json:"session_id"`
|
||||
Stages []plannedStage `json:"stages"`
|
||||
Publication []plannedPublication `json:"publication_actions"`
|
||||
}
|
||||
type plannedStage struct {
|
||||
Name string `json:"name"`
|
||||
Action string `json:"action"`
|
||||
Reason string `json:"reason"`
|
||||
Analysis *plannedAnalysis `json:"analysis,omitempty"`
|
||||
}
|
||||
type plannedAnalysis struct {
|
||||
Targets []string `json:"targets"`
|
||||
Prerequisites []plannedArtifact `json:"prerequisites"`
|
||||
Execute []plannedArtifact `json:"execute"`
|
||||
Reuse []plannedArtifact `json:"reuse"`
|
||||
}
|
||||
type plannedArtifact struct {
|
||||
Key string `json:"key"`
|
||||
Family string `json:"family,omitempty"`
|
||||
CharacterID string `json:"character_id,omitempty"`
|
||||
Role string `json:"role"`
|
||||
Reason string `json:"reason"`
|
||||
Forced bool `json:"forced"`
|
||||
}
|
||||
type plannedPublication struct {
|
||||
Source string `json:"source"`
|
||||
Destination string `json:"destination"`
|
||||
Required bool `json:"required"`
|
||||
Selected bool `json:"selected"`
|
||||
}
|
||||
|
||||
func analysisPlanReport(summary *stage.AnalyzeResumeSummary) *plannedAnalysis {
|
||||
convert := func(items []stage.AnalyzeResumeArtifact) []plannedArtifact {
|
||||
out := make([]plannedArtifact, 0, len(items))
|
||||
for _, item := range items {
|
||||
out = append(out, plannedArtifact{Key: item.Key, Family: item.Family, CharacterID: item.CharacterID, Role: item.Role, Reason: item.Reason, Forced: item.Forced})
|
||||
}
|
||||
return out
|
||||
}
|
||||
return &plannedAnalysis{Targets: append([]string(nil), summary.ExplicitTargets...), Prerequisites: convert(summary.PrerequisiteWork), Execute: convert(summary.ExecutionOrder), Reuse: convert(summary.ReusedCurrent)}
|
||||
}
|
||||
|
||||
func sessionPlanCommand(deps commandDependencies) commandkit.Command {
|
||||
spec := executionCommandSpec("plan", "Preview session work without executing it.", false)
|
||||
spec.Run = func(invocation commandkit.Invocation, input *executionInput) commandkit.Outcome {
|
||||
report, err := planSelectedPipeline(invocation.Context, input, deps)
|
||||
if report != nil {
|
||||
err = errors.Join(err, invocation.Reporter().Report(commandkit.Report{Value: report}))
|
||||
}
|
||||
return operationOutcome(err)
|
||||
}
|
||||
return commandkit.NewCommand(spec)
|
||||
}
|
||||
|
||||
func planSelectedPipeline(ctx context.Context, input *executionInput, deps commandDependencies) (report *sessionPlanReport, err error) {
|
||||
deps = normalizeCommandDependencies(deps)
|
||||
deps.secretsBootstrap = &secretsBootstrap{}
|
||||
acquired := newConfigurationAcquisition(input.Selection, deps)
|
||||
acquired.previousSessionID = input.PreviousSession.Value
|
||||
defer func() { err = errors.Join(err, acquired.Close()) }()
|
||||
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}
|
||||
}
|
||||
return buildSessionPlan(ctx, cfg, input, selected, effective)
|
||||
}
|
||||
|
||||
func buildSessionPlan(ctx context.Context, cfg *config.Config, input *executionInput, selectedArtifacts []string, effective artifacts.EffectiveArtifactSet) (*sessionPlanReport, error) {
|
||||
m, err := loadManifestIfPresent(ctx, cfg)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("plan: %w", err)
|
||||
}
|
||||
if err := validateBoundedPrerequisites(input.plan, m); err != nil {
|
||||
return nil, fmt.Errorf("plan: %w", err)
|
||||
}
|
||||
store := artifacts.NewLocalStore(cfg.Pipeline.Workspace.Root)
|
||||
model, err := cloneManifestForPlan(m, cfg)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("plan: clone session state: %w", err)
|
||||
}
|
||||
|
||||
stages := input.plan.Stages()
|
||||
stageEnv := &stage.Env{
|
||||
Config: cfg, SelectedArtifactKeys: append([]string(nil), selectedArtifacts...),
|
||||
EffectiveArtifacts: effective, ArtifactStore: store, Force: input.Force.Value,
|
||||
}
|
||||
|
||||
report := &sessionPlanReport{Campaign: config.CampaignID(cfg.Campaign), SessionID: cfg.Session.SessionID, Stages: []plannedStage{}, Publication: []plannedPublication{}}
|
||||
for _, selectedStage := range stages {
|
||||
semanticConfig, err := currentStageSemanticConfig(selectedStage, stageEnv)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("plan: fingerprint semantic configuration for stage %q: %w", selectedStage.Name(), err)
|
||||
}
|
||||
decision := decideStageExecution(recordedStageStatus(model, selectedStage.Name()), input.Force.Value, nil)
|
||||
var validation *stage.ResumeValidation
|
||||
if decision.action == stageActionSkip {
|
||||
checked, validationErr := evaluateStageResume(ctx, selectedStage, stageEnv, model, semanticConfig)
|
||||
if validationErr != nil {
|
||||
return nil, fmt.Errorf("plan: validate resume for stage %q: %w", selectedStage.Name(), validationErr)
|
||||
}
|
||||
validation = checked
|
||||
decision = decideStageExecution(recordedStageStatus(model, selectedStage.Name()), input.Force.Value, checked)
|
||||
}
|
||||
if _, err := applyPreExecutionDecision(model, selectedStage.Name(), decision, time.Now().UTC()); err != nil {
|
||||
return nil, fmt.Errorf("plan: model resume invalidation for stage %q: %w", selectedStage.Name(), err)
|
||||
}
|
||||
if decision.action == stageActionRun && selectedStage.Name() == "analyze" {
|
||||
if validator, ok := selectedStage.(stage.ResumeValidator); ok {
|
||||
checked, validationErr := validator.ValidateResume(ctx, stageEnv, model)
|
||||
if validationErr != nil {
|
||||
return nil, fmt.Errorf("plan: validate resume for stage %q: %w", selectedStage.Name(), validationErr)
|
||||
}
|
||||
checked = checked.Normalized()
|
||||
validation = &checked
|
||||
}
|
||||
}
|
||||
reason := decision.selectedStaleReason
|
||||
if reason == "" {
|
||||
switch {
|
||||
case input.Force.Value:
|
||||
reason = "forced"
|
||||
case decision.action == stageActionSkip:
|
||||
reason = "recorded result is reusable"
|
||||
default:
|
||||
reason = "no reusable successful result"
|
||||
}
|
||||
}
|
||||
entry := plannedStage{Name: selectedStage.Name(), Action: string(decision.action), Reason: reason}
|
||||
if validation != nil && validation.Analyze != nil {
|
||||
entry.Analysis = analysisPlanReport(validation.Analyze)
|
||||
}
|
||||
report.Stages = append(report.Stages, entry)
|
||||
if decision.action == stageActionRun {
|
||||
if err := modelPlannedStageRun(model, selectedStage, cfg, decision, semanticConfig); err != nil {
|
||||
return nil, fmt.Errorf("plan: model stage %q: %w", selectedStage.Name(), err)
|
||||
}
|
||||
}
|
||||
}
|
||||
if input.plan.Contains("publish") && cfg.Pipeline.Publish != nil && (cfg.Pipeline.Publish.Enabled == nil || *cfg.Pipeline.Publish.Enabled) {
|
||||
catalog, err := buildHelperArtifactCatalog(cfg, model)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
actions, err := stage.PlanPublicationOutputs(catalog, cfg.PublicationOutputs(), selectedArtifacts)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
for _, action := range actions {
|
||||
report.Publication = append(report.Publication, plannedPublication{Source: action.Source, Destination: action.Destination, Required: action.Required, Selected: action.Selected})
|
||||
}
|
||||
}
|
||||
return report, nil
|
||||
}
|
||||
Reference in New Issue
Block a user