go-cli-flag-overrides

Answer

Gap (UHLP U-GAP-002): the spec promised --port, --docker-sock, and --log-level; the CLI only had --config, so operators could not override YAML settings at launch. The naive fix (defaults of 0/"" applied unconditionally) would clobber YAML values with zero sentinels on every run.

Fix — explicit-pass-only overrides via flag.Visit. flag.Visit invokes its callback only for flags actually present on the command line, so absent flags never touch the config. The sentinel guards (port != 0, strings != "") additionally make even an explicit --port 0 / --docker-sock "" a no-op instead of a wipe. The log level is threaded through framework.New(cfg, logLevel) with info as the final fallback, keeping the CLI the single source of truth.

// Flag registration — full spec surface, sentinel defaults (0 / "" = unset).
func defineFlags(fs *flag.FlagSet, cfgPath *string) (port *int, dockerSock *string, logLevel *string) {
    fs.StringVar(cfgPath, "config", "config.yaml", "path to configuration file")
    port = fs.Int("port", 0, "override config port (0 = keep config value)")
    dockerSock = fs.String("docker-sock", "", "override docker socket path (empty = keep config value)")
    logLevel = fs.String("log-level", "", "override log level (empty = keep config value)")
    return port, dockerSock, logLevel
}

// Merge: explicit flags only, sentinels never clobber YAML.
func applyOverrides(cfg *framework.Config, fs *flag.FlagSet, port *int, dockerSock *string, logLevel *string) error {
    fs.Visit(func(f *flag.Flag) {          // callback fires only for passed flags
        switch f.Name {
        case "port":
            if *port != 0 { cfg.Port = *port }
        case "docker-sock":
            if *dockerSock != "" { cfg.DockerSock = *dockerSock }
        case "log-level":
            if *logLevel != "" { cfg.LogLevel = *logLevel }
        }
    })
    return nil
}

// Defaulting: config file value, else "info". (An explicit flag has already
// overwritten cfg.LogLevel before this runs.)
func resolveLogLevel(cfg *framework.Config) string {
    if cfg.LogLevel != "" { return cfg.LogLevel }
    return "info"
}

// Wiring — single framework.New(cfg, logLevel) call site (low-risk signature change).
func run(args []string) error {
    fs := flag.NewFlagSet("cli", flag.ContinueOnError)
    var cfgPath string
    port, dockerSock, logLevel := defineFlags(fs, &cfgPath)
    if err := fs.Parse(args); err != nil { return err }

    cfg, err := loadFileConfig(cfgPath)               // YAML/JSON load
    if err != nil { return err }
    if err := applyOverrides(cfg, fs, port, dockerSock, logLevel); err != nil { return err }

    fw, err := framework.New(cfg, resolveLogLevel(cfg)) // log level threaded in
    if err != nil { return err }
    return fw.Serve()
}

framework.New accepts the resolved level directly and falls back to "info" only if still empty — the constructor no longer re-derives policy.