468 lines
15 KiB
Go
468 lines
15 KiB
Go
package cli
|
|
|
|
import (
|
|
"context"
|
|
"flag"
|
|
"fmt"
|
|
"io"
|
|
"os"
|
|
"path/filepath"
|
|
|
|
"gitea.maximumdirect.net/eric/weatherreporter/internal/app"
|
|
"gitea.maximumdirect.net/eric/weatherreporter/internal/buildinfo"
|
|
"gitea.maximumdirect.net/eric/weatherreporter/internal/comparison"
|
|
"gitea.maximumdirect.net/eric/weatherreporter/internal/config"
|
|
"gitea.maximumdirect.net/eric/weatherreporter/internal/report"
|
|
"gitea.maximumdirect.net/eric/weatherreporter/internal/timeutil"
|
|
)
|
|
|
|
const helpText = `weatherreporter prepares weather reports from normalized forecast data.
|
|
|
|
Usage:
|
|
weatherreporter --help
|
|
weatherreporter --version
|
|
weatherreporter generate daily --date YYYY-MM-DD [--config PATH] [--units VALUE] [--tz NAME] [--out PATH] [--llm-debug-dir PATH] [--quiet]
|
|
weatherreporter generate today [--config PATH] [--units VALUE] [--tz NAME] [--out PATH] [--date YYYY-MM-DD] [--llm-debug-dir PATH] [--quiet]
|
|
weatherreporter generate tomorrow [--config PATH] [--units VALUE] [--tz NAME] [--out PATH] [--llm-debug-dir PATH] [--quiet]
|
|
weatherreporter generate hourly [--config PATH] [--units VALUE] [--tz NAME] [--out PATH] [--llm-debug-dir PATH] [--quiet]
|
|
weatherreporter run morning [--config PATH] [--units VALUE] [--tz NAME] [--out-dir PATH] [--llm-debug-dir PATH] [--quiet]
|
|
weatherreporter run evening [--config PATH] [--units VALUE] [--tz NAME] [--out-dir PATH] [--llm-debug-dir PATH] [--quiet]
|
|
weatherreporter compare REPORT --profile PROFILE --profile PROFILE [--config PATH] [--units VALUE] [--tz NAME] [--date YYYY-MM-DD] [--out-dir PATH] [--replace] [--llm-debug-dir PATH] [--quiet]
|
|
|
|
Options:
|
|
-h, --help Show this help message.
|
|
--version Show the Weatherreporter version.
|
|
--config PATH Load configuration from PATH instead of /usr/local/etc/weatherreporter/config.yml.
|
|
--units VALUE Override weather API units.
|
|
--tz NAME Override weather API timezone.
|
|
--out PATH Write the generated Markdown report to PATH.
|
|
--llm-debug-dir PATH Write sensitive prompt debug artifacts under PATH.
|
|
--profile PROFILE Select a prompt profile for compare; repeat for every profile.
|
|
--date YYYY-MM-DD Required for generate/compare daily; optional for generate/compare today.
|
|
--out-dir PATH Write generated Markdown reports beneath PATH for run commands, or select the exact comparison directory.
|
|
--replace Authorize replacement of a recognized comparison bundle.
|
|
--quiet Suppress action summaries and routine batch status output.
|
|
`
|
|
|
|
type Runner struct {
|
|
Clock timeutil.Clock
|
|
ExecutorFactory ExecutorFactory
|
|
Version string
|
|
WorkingDir string
|
|
generateDetailed func(context.Context, app.GenerateRequest) (*app.ReportResult, error)
|
|
runBatchDetailed func(context.Context, app.BatchRequest) (*app.BatchResult, error)
|
|
compareDetailed func(context.Context, app.ComparisonRequest) (*app.ComparisonResult, error)
|
|
}
|
|
|
|
func Run(ctx context.Context, args []string, stdout io.Writer, stderr io.Writer) error {
|
|
return Runner{Clock: timeutil.SystemClock{}}.Run(ctx, args, stdout, stderr)
|
|
}
|
|
|
|
func (r Runner) Run(ctx context.Context, args []string, stdout io.Writer, stderr io.Writer) error {
|
|
if r.Clock == nil {
|
|
r.Clock = timeutil.SystemClock{}
|
|
}
|
|
if len(args) == 0 || args[0] == "--help" || args[0] == "-h" {
|
|
_, err := fmt.Fprint(stdout, helpText)
|
|
return err
|
|
}
|
|
if len(args) == 2 && args[0] == "compare" && (args[1] == "--help" || args[1] == "-h") {
|
|
_, err := fmt.Fprint(stdout, helpText)
|
|
return err
|
|
}
|
|
if args[0] == "--version" {
|
|
if len(args) != 1 {
|
|
return fmt.Errorf("--version does not accept arguments")
|
|
}
|
|
version := r.Version
|
|
if version == "" {
|
|
version = buildinfo.Version
|
|
}
|
|
_, err := fmt.Fprintf(stdout, "weatherreporter %s\n", version)
|
|
return err
|
|
}
|
|
|
|
switch args[0] {
|
|
case "generate":
|
|
req, opts, err := r.resolveGenerateAction(args[1:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
generateDetailed := r.generateDetailed
|
|
if generateDetailed == nil {
|
|
generateDetailed = app.GenerateDetailed
|
|
}
|
|
result, err := generateDetailed(ctx, req)
|
|
if result != nil {
|
|
summary := newGenerateSummary(result, err)
|
|
if encodeErr := writeActionResult(stdout, stderr, summary, outputOptions{Quiet: opts.Quiet}, nil); encodeErr != nil {
|
|
return encodeErr
|
|
}
|
|
}
|
|
return err
|
|
case "run":
|
|
req, opts, err := r.resolveRunAction(args[1:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
runBatchDetailed := r.runBatchDetailed
|
|
if runBatchDetailed == nil {
|
|
runBatchDetailed = app.RunBatchDetailed
|
|
}
|
|
result, err := runBatchDetailed(ctx, req)
|
|
if result != nil {
|
|
summary := newBatchSummary(result, err)
|
|
if encodeErr := writeActionResult(stdout, stderr, summary, outputOptions{Quiet: opts.Quiet}, func(w io.Writer) {
|
|
writeBatchStatus(w, result)
|
|
}); encodeErr != nil {
|
|
return encodeErr
|
|
}
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if summary.Status == summaryStatusFailed {
|
|
return app.BatchError{Result: result}
|
|
}
|
|
}
|
|
return err
|
|
case "compare":
|
|
req, opts, err := r.resolveComparisonAction(args[1:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
compareDetailed := r.compareDetailed
|
|
if compareDetailed == nil {
|
|
compareDetailed = app.CompareDetailed
|
|
}
|
|
result, err := compareDetailed(ctx, req)
|
|
if result != nil {
|
|
summary := newComparisonSummary(result, err)
|
|
if encodeErr := writeActionResult(stdout, stderr, summary, outputOptions{Quiet: opts.Quiet}, nil); encodeErr != nil {
|
|
return encodeErr
|
|
}
|
|
}
|
|
return err
|
|
default:
|
|
return fmt.Errorf("unknown command %q", args[0])
|
|
}
|
|
}
|
|
|
|
type commonOptions struct {
|
|
ConfigPath string
|
|
Units string
|
|
Timezone string
|
|
Output string
|
|
OutputDir string
|
|
LLMDebugDir string
|
|
Quiet bool
|
|
}
|
|
|
|
type generateOptions struct {
|
|
commonOptions
|
|
Date string
|
|
}
|
|
|
|
type comparisonOptions struct {
|
|
commonOptions
|
|
Date string
|
|
ProfileIDs profileValues
|
|
Replace bool
|
|
}
|
|
|
|
type profileValues []string
|
|
|
|
func (values *profileValues) String() string {
|
|
return ""
|
|
}
|
|
|
|
func (values *profileValues) Set(value string) error {
|
|
*values = append(*values, value)
|
|
return nil
|
|
}
|
|
|
|
func (r Runner) resolveGenerate(args []string) (app.GenerateRequest, error) {
|
|
req, _, err := r.resolveGenerateAction(args)
|
|
return req, err
|
|
}
|
|
|
|
func (r Runner) resolveGenerateAction(args []string) (app.GenerateRequest, commonOptions, error) {
|
|
if r.Clock == nil {
|
|
r.Clock = timeutil.SystemClock{}
|
|
}
|
|
if len(args) == 0 {
|
|
return app.GenerateRequest{}, commonOptions{}, fmt.Errorf("generate requires a report name")
|
|
}
|
|
if _, err := report.IDForCommandName(args[0]); err != nil {
|
|
return app.GenerateRequest{}, commonOptions{}, fmt.Errorf("unknown generate report %q", args[0])
|
|
}
|
|
reportKind := app.ReportKind(args[0])
|
|
|
|
opts, err := parseGenerateFlags(reportKind, args[1:])
|
|
if err != nil {
|
|
return app.GenerateRequest{}, commonOptions{}, err
|
|
}
|
|
if reportKind == app.ReportDaily && opts.Date == "" {
|
|
return app.GenerateRequest{}, commonOptions{}, fmt.Errorf("generate daily requires --date YYYY-MM-DD")
|
|
}
|
|
cfg, err := config.Load(config.LoadOptions{
|
|
Path: opts.ConfigPath,
|
|
Units: opts.Units,
|
|
Timezone: opts.Timezone,
|
|
})
|
|
if err != nil {
|
|
return app.GenerateRequest{}, commonOptions{}, err
|
|
}
|
|
location, err := timeutil.LoadLocation(cfg.WeatherAPI.Timezone)
|
|
if err != nil {
|
|
return app.GenerateRequest{}, commonOptions{}, err
|
|
}
|
|
now := r.Clock.Now()
|
|
req := app.GenerateRequest{
|
|
Config: cfg,
|
|
Report: reportKind,
|
|
LLMDebugDir: opts.LLMDebugDir,
|
|
Now: now,
|
|
}
|
|
|
|
switch reportKind {
|
|
case app.ReportDaily:
|
|
req.Date, err = timeutil.ParseLocalDate(opts.Date, location)
|
|
if err != nil {
|
|
return app.GenerateRequest{}, commonOptions{}, err
|
|
}
|
|
case app.ReportToday:
|
|
if opts.Date == "" {
|
|
req.Date = timeutil.LocalDate(now, location)
|
|
} else {
|
|
req.Date, err = timeutil.ParseLocalDate(opts.Date, location)
|
|
if err != nil {
|
|
return app.GenerateRequest{}, commonOptions{}, err
|
|
}
|
|
}
|
|
}
|
|
|
|
workingDir, err := r.workingDir()
|
|
if err != nil {
|
|
return app.GenerateRequest{}, commonOptions{}, err
|
|
}
|
|
outputPath, err := resolveOutputOverride(workingDir, opts.Output)
|
|
if err != nil {
|
|
return app.GenerateRequest{}, commonOptions{}, err
|
|
}
|
|
req.WorkingDir, req.OutputPath = workingDir, outputPath
|
|
executor, err := r.promptExecutor(cfg.Promptkit)
|
|
if err != nil {
|
|
return app.GenerateRequest{}, commonOptions{}, err
|
|
}
|
|
req.Executor = executor
|
|
|
|
return req, opts.commonOptions, nil
|
|
}
|
|
|
|
func (r Runner) resolveRun(args []string) (app.BatchRequest, error) {
|
|
req, _, err := r.resolveRunAction(args)
|
|
return req, err
|
|
}
|
|
|
|
func (r Runner) resolveComparisonAction(args []string) (app.ComparisonRequest, commonOptions, error) {
|
|
if r.Clock == nil {
|
|
r.Clock = timeutil.SystemClock{}
|
|
}
|
|
if len(args) == 0 {
|
|
return app.ComparisonRequest{}, commonOptions{}, fmt.Errorf("compare requires a report name")
|
|
}
|
|
if _, err := report.IDForCommandName(args[0]); err != nil {
|
|
return app.ComparisonRequest{}, commonOptions{}, fmt.Errorf("unknown compare report %q", args[0])
|
|
}
|
|
reportKind := app.ReportKind(args[0])
|
|
opts, err := parseComparisonFlags(reportKind, args[1:])
|
|
if err != nil {
|
|
return app.ComparisonRequest{}, commonOptions{}, err
|
|
}
|
|
if err := comparison.ValidateProfileIDs(opts.ProfileIDs); err != nil {
|
|
return app.ComparisonRequest{}, commonOptions{}, err
|
|
}
|
|
cfg, err := config.Load(config.LoadOptions{
|
|
Path: opts.ConfigPath,
|
|
Units: opts.Units,
|
|
Timezone: opts.Timezone,
|
|
})
|
|
if err != nil {
|
|
return app.ComparisonRequest{}, commonOptions{}, err
|
|
}
|
|
location, err := timeutil.LoadLocation(cfg.WeatherAPI.Timezone)
|
|
if err != nil {
|
|
return app.ComparisonRequest{}, commonOptions{}, err
|
|
}
|
|
workingDir, err := r.workingDir()
|
|
if err != nil {
|
|
return app.ComparisonRequest{}, commonOptions{}, err
|
|
}
|
|
outputDir, err := resolveOutputOverride(workingDir, opts.OutputDir)
|
|
if err != nil {
|
|
return app.ComparisonRequest{}, commonOptions{}, err
|
|
}
|
|
|
|
req := app.ComparisonRequest{
|
|
Config: cfg, Report: reportKind, ProfileIDs: append([]string(nil), opts.ProfileIDs...),
|
|
WorkingDir: workingDir, OutputDir: outputDir, Replace: opts.Replace, LLMDebugDir: opts.LLMDebugDir, Clock: r.Clock,
|
|
}
|
|
switch reportKind {
|
|
case app.ReportDaily:
|
|
if opts.Date == "" {
|
|
return app.ComparisonRequest{}, commonOptions{}, fmt.Errorf("compare daily requires --date YYYY-MM-DD")
|
|
}
|
|
req.Date, err = timeutil.ParseLocalDate(opts.Date, location)
|
|
case app.ReportToday:
|
|
if opts.Date == "" {
|
|
req.Date = timeutil.LocalDate(r.Clock.Now(), location)
|
|
} else {
|
|
req.Date, err = timeutil.ParseLocalDate(opts.Date, location)
|
|
}
|
|
}
|
|
if err != nil {
|
|
return app.ComparisonRequest{}, commonOptions{}, err
|
|
}
|
|
|
|
promptkitConfig := cfg.Promptkit
|
|
promptkitConfig.Profile = ""
|
|
executor, err := r.promptExecutor(promptkitConfig)
|
|
if err != nil {
|
|
return app.ComparisonRequest{}, commonOptions{}, err
|
|
}
|
|
req.Executor = executor
|
|
return req, opts.commonOptions, nil
|
|
}
|
|
|
|
func (r Runner) resolveRunAction(args []string) (app.BatchRequest, commonOptions, error) {
|
|
if r.Clock == nil {
|
|
r.Clock = timeutil.SystemClock{}
|
|
}
|
|
if len(args) == 0 {
|
|
return app.BatchRequest{}, commonOptions{}, fmt.Errorf("run requires a batch name")
|
|
}
|
|
if _, err := report.BatchForCommandName(args[0]); err != nil {
|
|
return app.BatchRequest{}, commonOptions{}, fmt.Errorf("unknown run batch %q", args[0])
|
|
}
|
|
batch := app.BatchKind(args[0])
|
|
opts, err := parseRunFlags(args[1:])
|
|
if err != nil {
|
|
return app.BatchRequest{}, commonOptions{}, err
|
|
}
|
|
cfg, err := config.Load(config.LoadOptions{
|
|
Path: opts.ConfigPath,
|
|
Units: opts.Units,
|
|
Timezone: opts.Timezone,
|
|
})
|
|
if err != nil {
|
|
return app.BatchRequest{}, commonOptions{}, err
|
|
}
|
|
executor, err := r.promptExecutor(cfg.Promptkit)
|
|
if err != nil {
|
|
return app.BatchRequest{}, commonOptions{}, err
|
|
}
|
|
workingDir, err := r.workingDir()
|
|
if err != nil {
|
|
return app.BatchRequest{}, commonOptions{}, err
|
|
}
|
|
outputDir, err := resolveOutputOverride(workingDir, opts.OutputDir)
|
|
if err != nil {
|
|
return app.BatchRequest{}, commonOptions{}, err
|
|
}
|
|
return app.BatchRequest{Config: cfg, Batch: batch, Now: r.Clock.Now(), WorkingDir: workingDir, OutputDir: outputDir, LLMDebugDir: opts.LLMDebugDir, Executor: executor}, opts, nil
|
|
}
|
|
|
|
func resolveRun(args []string) (app.BatchRequest, error) {
|
|
return Runner{Clock: timeutil.SystemClock{}}.resolveRun(args)
|
|
}
|
|
|
|
func parseGenerateFlags(report app.ReportKind, args []string) (generateOptions, error) {
|
|
fs := flag.NewFlagSet("generate "+string(report), flag.ContinueOnError)
|
|
fs.SetOutput(io.Discard)
|
|
opts := generateOptions{}
|
|
addCommonFlags(fs, &opts.commonOptions, true)
|
|
fs.BoolVar(&opts.Quiet, "quiet", false, "suppress action summaries and routine batch status output")
|
|
if report == app.ReportDaily || report == app.ReportToday {
|
|
fs.StringVar(&opts.Date, "date", "", "report date in YYYY-MM-DD")
|
|
}
|
|
if err := fs.Parse(args); err != nil {
|
|
return generateOptions{}, err
|
|
}
|
|
if fs.NArg() > 0 {
|
|
return generateOptions{}, fmt.Errorf("unexpected argument %q", fs.Arg(0))
|
|
}
|
|
return opts, nil
|
|
}
|
|
|
|
func parseRunFlags(args []string) (commonOptions, error) {
|
|
fs := flag.NewFlagSet("run", flag.ContinueOnError)
|
|
fs.SetOutput(io.Discard)
|
|
opts := commonOptions{}
|
|
addCommonFlags(fs, &opts, false)
|
|
fs.StringVar(&opts.OutputDir, "out-dir", "", "generated Markdown report directory")
|
|
fs.BoolVar(&opts.Quiet, "quiet", false, "suppress action summaries and routine batch status output")
|
|
if err := fs.Parse(args); err != nil {
|
|
return commonOptions{}, err
|
|
}
|
|
if fs.NArg() > 0 {
|
|
return commonOptions{}, fmt.Errorf("unexpected argument %q", fs.Arg(0))
|
|
}
|
|
return opts, nil
|
|
}
|
|
|
|
func parseComparisonFlags(report app.ReportKind, args []string) (comparisonOptions, error) {
|
|
fs := flag.NewFlagSet("compare "+string(report), flag.ContinueOnError)
|
|
fs.SetOutput(io.Discard)
|
|
opts := comparisonOptions{}
|
|
addCommonFlags(fs, &opts.commonOptions, false)
|
|
fs.StringVar(&opts.OutputDir, "out-dir", "", "comparison bundle directory")
|
|
fs.BoolVar(&opts.Replace, "replace", false, "replace a recognized comparison bundle")
|
|
fs.BoolVar(&opts.Quiet, "quiet", false, "suppress action summaries and routine batch status output")
|
|
fs.Var(&opts.ProfileIDs, "profile", "prompt profile ID")
|
|
if report == app.ReportDaily || report == app.ReportToday {
|
|
fs.StringVar(&opts.Date, "date", "", "report date in YYYY-MM-DD")
|
|
}
|
|
if err := fs.Parse(args); err != nil {
|
|
return comparisonOptions{}, err
|
|
}
|
|
if fs.NArg() > 0 {
|
|
return comparisonOptions{}, fmt.Errorf("unexpected argument %q", fs.Arg(0))
|
|
}
|
|
return opts, nil
|
|
}
|
|
|
|
func addCommonFlags(fs *flag.FlagSet, opts *commonOptions, includeOutput bool) {
|
|
fs.StringVar(&opts.ConfigPath, "config", "", "configuration file path")
|
|
fs.StringVar(&opts.Units, "units", "", "weather API units")
|
|
fs.StringVar(&opts.Timezone, "tz", "", "weather API timezone")
|
|
fs.StringVar(&opts.LLMDebugDir, "llm-debug-dir", "", "write sensitive prompt debug artifacts under PATH")
|
|
if includeOutput {
|
|
fs.StringVar(&opts.Output, "out", "", "generated Markdown report path")
|
|
}
|
|
}
|
|
|
|
func (r Runner) workingDir() (string, error) {
|
|
workingDir := r.WorkingDir
|
|
if workingDir == "" {
|
|
var err error
|
|
workingDir, err = os.Getwd()
|
|
if err != nil {
|
|
return "", fmt.Errorf("get working directory: %w", err)
|
|
}
|
|
}
|
|
if !filepath.IsAbs(workingDir) {
|
|
return "", fmt.Errorf("working directory %q must be absolute", workingDir)
|
|
}
|
|
return filepath.Clean(workingDir), nil
|
|
}
|
|
|
|
func resolveOutputOverride(workingDir, value string) (string, error) {
|
|
if value == "" {
|
|
return "", nil
|
|
}
|
|
if !filepath.IsAbs(value) {
|
|
value = filepath.Join(workingDir, value)
|
|
}
|
|
return filepath.Clean(value), nil
|
|
}
|