audita/internal/cli/process_command.go

package cli

import (
	"fmt"
	"strconv"

	commandkit "go.maximumdirect.net/commandkit"
	ck "go.maximumdirect.net/configkit"
)

type processInput struct {
	Config     commandkit.Supplied[string]
	Overlay    commandkit.Supplied[string]
	Transcript string
	Output     commandkit.Supplied[string]
	Debug      commandkit.Supplied[bool]
	Overrides  []ck.Override
}

func processCommand() commandkit.Command {
	stringValue := func(s string) (string, error) { return s, nil }
	flags := []commandkit.Flag[processInput]{
		commandkit.ValueFlag(commandkit.FlagMeta{Name: "config", Usage: "Application configuration file."}, (*string)(nil), stringValue, func(in *processInput, v commandkit.Supplied[string]) { in.Config = v }),
		commandkit.ValueFlag(commandkit.FlagMeta{Name: "overlay", Usage: "Configuration overlay."}, (*string)(nil), stringValue, func(in *processInput, v commandkit.Supplied[string]) { in.Overlay = v }),
		commandkit.ValueFlag(commandkit.FlagMeta{Name: "output", Usage: "Transcript output file."}, (*string)(nil), stringValue, func(in *processInput, v commandkit.Supplied[string]) { in.Output = v }),
		commandkit.BoolFlag(commandkit.FlagMeta{Name: "debug", Usage: "Capture diagnostic artifacts."}, false, func(in *processInput, v commandkit.Supplied[bool]) { in.Debug = v }),
	}
	for _, item := range []struct {
		name string
		path ck.Path
	}{
		{"proposal-profile", ck.Keys("llm", "proposal_profile")}, {"validation-profile", ck.Keys("llm", "validation_profile")},
		{"output-schema", ck.Keys("output", "schema")}, {"transcript-description", ck.Keys("context", "description")},
		{"report-dir", ck.Keys("reporting", "stdout_dir")}, {"work-dir", ck.Keys("diagnostics", "work_dir")},
	} {
		name, path := item.name, item.path
		flags = append(flags, commandkit.ValueFlag(commandkit.FlagMeta{Name: name, Usage: "Override application setting."}, (*string)(nil), stringValue,
			func(in *processInput, v commandkit.Supplied[string]) {
				if v.Set {
					in.Overrides = append(in.Overrides, ck.Override{Path: path, Value: v.Value, Flag: "--" + name})
				}
			}))
	}
	for _, item := range []struct {
		name string
		path ck.Path
	}{
		{"validation-max-prompt-tokens", ck.Keys("validation", "max_prompt_tokens")}, {"target-sections", ck.Keys("chunking", "target_sections")},
		{"max-section-tokens", ck.Keys("chunking", "max_section_tokens")}, {"min-section-tokens", ck.Keys("chunking", "min_section_tokens")},
		{"normalize-max-segment-tokens", ck.Keys("normalization", "max_segment_tokens")},
	} {
		name, path := item.name, item.path
		flags = append(flags, commandkit.ValueFlag(commandkit.FlagMeta{Name: name, Usage: "Override application setting."}, (*int)(nil), strconv.Atoi,
			func(in *processInput, v commandkit.Supplied[int]) {
				if v.Set {
					in.Overrides = append(in.Overrides, ck.Override{Path: path, Value: v.Value, Flag: "--" + name})
				}
			}))
	}
	for _, item := range []struct {
		name string
		path ck.Path
	}{
		{"normalize-max-segment-gap", ck.Keys("normalization", "max_segment_gap")}, {"normalize-ellipsis-gap", ck.Keys("normalization", "ellipsis_gap")},
		{"normalize-max-segment-duration", ck.Keys("normalization", "max_segment_duration")}, {"glossary-confidence-threshold", ck.Keys("thresholds", "glossary")},
		{"homophones-confidence-threshold", ck.Keys("thresholds", "homophones")}, {"spoken-word-confidence-threshold", ck.Keys("thresholds", "spoken_word")},
		{"grammar-confidence-threshold", ck.Keys("thresholds", "grammar")},
	} {
		name, path := item.name, item.path
		flags = append(flags, commandkit.ValueFlag(commandkit.FlagMeta{Name: name, Usage: "Override application setting."}, (*float64)(nil), func(s string) (float64, error) { return strconv.ParseFloat(s, 64) },
			func(in *processInput, v commandkit.Supplied[float64]) {
				if v.Set {
					in.Overrides = append(in.Overrides, ck.Override{Path: path, Value: v.Value, Flag: "--" + name})
				}
			}))
	}
	for _, item := range []struct {
		name string
		path ck.Path
	}{
		{"glossaries", ck.Keys("glossaries")}, {"protected-terms", ck.Keys("protected_terms")},
	} {
		name, path := item.name, item.path
		flags = append(flags, commandkit.ValueFlag(commandkit.FlagMeta{Name: name, Usage: "JSON array of collection names, or null."}, (*any)(nil), parseCollectionNames,
			func(in *processInput, value commandkit.Supplied[any]) {
				if value.Set {
					in.Overrides = append(in.Overrides, ck.Override{Path: path, Value: value.Value, Flag: "--" + name})
				}
			}))
	}
	flags = append(flags, commandkit.BoolFlag(commandkit.FlagMeta{Name: "reporting", Usage: "Enable ordinary reports."}, false,
		func(in *processInput, v commandkit.Supplied[bool]) {
			if v.Set {
				in.Overrides = append(in.Overrides, ck.Override{Path: ck.Keys("reporting", "enabled"), Value: v.Value, Flag: "--reporting"})
			}
		}))
	return commandkit.NewCommand(commandkit.CommandSpec[processInput]{Name: "process", Summary: "Polish a transcript.", Flags: flags, Run: runProcess,
		Arguments: []commandkit.Argument[processInput]{commandkit.ValueArgument(commandkit.ArgumentMeta{Name: "transcript", Usage: "Transcript JSON file."}, true, stringValue, func(in *processInput, v commandkit.Supplied[string]) { in.Transcript = v.Value })},
	})
}

func parseCollectionNames(raw string) (any, error) {
	value, err := commandkit.ParseCLIJSON(raw)
	if err != nil {
		return nil, err
	}
	if value == nil {
		return nil, nil
	}
	names, ok := value.([]any)
	if !ok {
		return nil, fmt.Errorf("expected a JSON array of collection names or null")
	}
	for _, name := range names {
		if _, ok := name.(string); !ok {
			return nil, fmt.Errorf("collection names must be strings")
		}
	}
	return names, nil
}