All checks were successful
ci/woodpecker/tag/release Pipeline was successful
111 lines
4.3 KiB
Go
111 lines
4.3 KiB
Go
package cli
|
|
|
|
import (
|
|
"errors"
|
|
"fmt"
|
|
"sync"
|
|
|
|
"gitea.maximumdirect.net/eric/audita/v4/internal/core/normalization"
|
|
"gitea.maximumdirect.net/eric/audita/v4/internal/core/outputschema"
|
|
"gitea.maximumdirect.net/eric/audita/v4/internal/core/reporting"
|
|
"gitea.maximumdirect.net/eric/audita/v4/internal/core/schema"
|
|
"gitea.maximumdirect.net/eric/audita/v4/internal/framework/llm"
|
|
"gitea.maximumdirect.net/eric/audita/v4/internal/framework/preflight"
|
|
"gitea.maximumdirect.net/eric/audita/v4/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()
|
|
}
|