package cli import ( "errors" "fmt" "sync" "gitea.maximumdirect.net/eric/audita/v3/internal/core/normalization" "gitea.maximumdirect.net/eric/audita/v3/internal/core/outputschema" "gitea.maximumdirect.net/eric/audita/v3/internal/core/reporting" "gitea.maximumdirect.net/eric/audita/v3/internal/core/schema" "gitea.maximumdirect.net/eric/audita/v3/internal/framework/llm" "gitea.maximumdirect.net/eric/audita/v3/internal/framework/preflight" "gitea.maximumdirect.net/eric/audita/v3/internal/framework/runner" "go.maximumdirect.net/ckconfig" commandkit "go.maximumdirect.net/commandkit" ck "go.maximumdirect.net/configkit" ) // processResult carries the runner's transcript and ordinary report facts. type processResult struct { Transcript *schema.Transcript Snapshot reporting.Snapshot } func runProcess(inv commandkit.Invocation, input processInput) commandkit.Outcome { loaded, err := loadProcessInputs(inv.Context, input, inv.ReportingMode()) if err != nil { if canceled := inv.Context.Err(); canceled != nil && !errors.Is(err, canceled) { err = errors.Join(err, canceled) } var loadErr *ck.LoadError if errors.As(err, &loadErr) { _, explanation := ckconfig.AdaptDiagnostics("Application configuration:\n", loadErr.Sources(), loadErr.Diagnostics()) if ckconfig.ClassifyConfigurationError(err) == commandkit.OutcomeUsage { return commandkit.Usage(loadErr.Error(), explanation.Details...).WithCause(err) } return commandkit.Failure(loadErr.Error(), explanation.Details...).WithCause(err) } if inv.Context.Err() != nil || llm.IsAssetError(err) { return commandkit.Failure("Could not prepare processing.").WithCause(err) } return commandkit.Usage(err.Error()).WithCause(err) } prepared, err := prepareProcess(inv.Context, input, loaded, inv.Reporter().Output()) if err != nil { var selection *preflight.SelectionError if inv.Context.Err() == nil && errors.As(err, &selection) { return commandkit.Usage(err.Error()).WithCause(err) } return commandkit.Failure(err.Error()).WithCause(err) } defer prepared.Prepared.Output.Close() var warningsMu sync.Mutex warn := func(err error) { if err == nil { return } warningsMu.Lock() prepared.Prepared.Warnings = append(prepared.Prepared.Warnings, err) warningsMu.Unlock() } debug := prepared.Prepared.Debug if debug != nil { warn(debug.WriteSourceTranscript(loaded.Source, loaded.RawTranscript)) } loaded.RawTranscript = nil cfg := &loaded.Configuration.Config normalizer := normalization.NewNormalizer(normalization.NormalizationConfig{ MaxSegmentGap: cfg.Normalization.MaxSegmentGap, EllipsisGap: cfg.Normalization.EllipsisGap, MaxSegmentDuration: cfg.Normalization.MaxSegmentDuration, MaxSegmentTokens: cfg.Normalization.MaxSegmentTokens, }) transcript := loaded.Source.Canonical() loaded.Source = nil normalized, summary := normalizer.Normalize(transcript) if debug != nil { warn(debug.WriteNormalizedTranscript(normalized)) warn(debug.WriteNormalizationSummary(summary)) } if err := inv.Context.Err(); err != nil { return finishProcess(inv, input, prepared, reporting.Snapshot{}, nil, &runner.ExecutionFailure{Phase: "normalization", Cause: err}) } reporter := inv.Reporter() result, runErr := executePipeline(inv.Context, loaded, prepared, normalized, warn, func(message string) { _ = reporter.Progress(message) }) if runErr != nil { return finishProcess(inv, input, prepared, result.Snapshot, nil, runErr) } encoder, err := outputschema.Resolve(cfg.Output.Schema) if err != nil { return finishProcess(inv, input, prepared, result.Snapshot, nil, &runner.ExecutionFailure{Phase: "encoding", Cause: err}) } if result.Transcript == nil { return finishProcess(inv, input, prepared, result.Snapshot, nil, &runner.ExecutionFailure{Phase: "encoding", Cause: fmt.Errorf("processing returned no transcript")}) } payload, err := encoder.Encoder(result.Transcript) if err != nil { return finishProcess(inv, input, prepared, result.Snapshot, nil, &runner.ExecutionFailure{Phase: "encoding", Cause: err}) } return finishProcess(inv, input, prepared, result.Snapshot, payload, nil) } // DebugPath returns the retained artifact directory, if its preparation succeeded. func (p *preparedProcess) DebugPath() string { if p == nil || p.Prepared == nil || p.Prepared.Debug == nil { return "" } return p.Prepared.Debug.Path() }