feat: replace config validate with doctor command

Add extensible health check system with styled output.
Config validation is now the first check under `hive doctor`.

Author: hay-kot

internal/commands/cmd_config_validate.go

@@ -0,0 +1,106 @@
+package commands
+
+import (
+	"context"
+	"encoding/json"
+
+	"github.com/hay-kot/hive/internal/commands/doctor"
+	"github.com/hay-kot/hive/internal/printer"
+	"github.com/urfave/cli/v3"
+)
+
+type DoctorCmd struct {
+	flags  *Flags
+	format string
+}
+
+func NewDoctorCmd(flags *Flags) *DoctorCmd {
+	return &DoctorCmd{flags: flags}
+}
+
+func (cmd *DoctorCmd) Register(app *cli.Command) *cli.Command {
+	app.Commands = append(app.Commands, &cli.Command{
+		Name:        "doctor",
+		Usage:       "Run health checks on your hive setup",
+		UsageText:   "hive doctor [options]",
+		Description: "Runs diagnostic checks on configuration, environment, and dependencies.",
+		Flags: []cli.Flag{
+			&cli.StringFlag{
+				Name:        "format",
+				Usage:       "output format (text, json)",
+				Value:       "text",
+				Destination: &cmd.format,
+			},
+		},
+		Action: cmd.run,
+	})
+	return app
+}
+
+func (cmd *DoctorCmd) run(ctx context.Context, c *cli.Command) error {
+	checks := []doctor.Check{
+		doctor.NewConfigCheck(cmd.flags.Config, cmd.flags.ConfigPath),
+	}
+
+	results := doctor.RunAll(ctx, checks)
+
+	if cmd.format == "json" {
+		return cmd.outputJSON(c, results)
+	}
+
+	return cmd.outputText(ctx, results)
+}
+
+func (cmd *DoctorCmd) outputJSON(c *cli.Command, results []doctor.Result) error {
+	passed, warned, failed := doctor.Summary(results)
+
+	out := struct {
+		Healthy bool            `json:"healthy"`
+		Summary summaryJSON     `json:"summary"`
+		Checks  []doctor.Result `json:"checks"`
+	}{
+		Healthy: failed == 0,
+		Summary: summaryJSON{Passed: passed, Warned: warned, Failed: failed},
+		Checks:  results,
+	}
+
+	enc := json.NewEncoder(c.Root().Writer)
+	enc.SetIndent("", "  ")
+	return enc.Encode(out)
+}
+
+type summaryJSON struct {
+	Passed int `json:"passed"`
+	Warned int `json:"warned"`
+	Failed int `json:"failed"`
+}
+
+func (cmd *DoctorCmd) outputText(ctx context.Context, results []doctor.Result) error {
+	p := printer.Ctx(ctx)
+
+	for _, result := range results {
+		p.Section(result.Name)
+
+		for _, item := range result.Items {
+			switch item.Status {
+			case doctor.StatusPass:
+				p.CheckItem(item.Label, item.Detail)
+			case doctor.StatusWarn:
+				p.WarnItem(item.Label, item.Detail)
+			case doctor.StatusFail:
+				p.FailItem(item.Label, item.Detail)
+			}
+		}
+
+		p.Printf("")
+	}
+
+	passed, warned, failed := doctor.Summary(results)
+	p.Printf("Summary: %d passed, %d warnings, %d failed", passed, warned, failed)
+
+	if failed > 0 {
+		return cli.Exit("", 1)
+	}
+
+	return nil
+}

internal/commands/cmd_doctor.go

@@ -0,0 +1,91 @@
+package doctor
+
+import (
+	"context"
+	"errors"
+
+	"github.com/hay-kot/criterio"
+	"github.com/hay-kot/hive/internal/core/config"
+)
+
+// ConfigCheck validates the configuration file.
+type ConfigCheck struct {
+	config     *config.Config
+	configPath string
+}
+
+// NewConfigCheck creates a new configuration check.
+func NewConfigCheck(cfg *config.Config, configPath string) *ConfigCheck {
+	return &ConfigCheck{
+		config:     cfg,
+		configPath: configPath,
+	}
+}
+
+func (c *ConfigCheck) Name() string {
+	return "Configuration"
+}
+
+func (c *ConfigCheck) Run(ctx context.Context) Result {
+	result := Result{Name: c.Name()}
+
+	if c.config == nil {
+		result.Items = append(result.Items, CheckItem{
+			Label:  "Config loaded",
+			Status: StatusFail,
+			Detail: "configuration not loaded",
+		})
+		return result
+	}
+
+	err := c.config.ValidateDeep(c.configPath)
+	warnings := c.config.Warnings()
+
+	// If no errors and no warnings, report success
+	if err == nil && len(warnings) == 0 {
+		result.Items = append(result.Items, CheckItem{
+			Label:  "Config valid",
+			Status: StatusPass,
+		})
+		return result
+	}
+
+	// Extract and report errors
+	if err != nil {
+		var fieldErrs criterio.FieldErrors
+		if errors.As(err, &fieldErrs) {
+			for _, fe := range fieldErrs {
+				label := fe.Field
+				if label == "" {
+					label = "validation"
+				}
+				result.Items = append(result.Items, CheckItem{
+					Label:  label,
+					Status: StatusFail,
+					Detail: fe.Err.Error(),
+				})
+			}
+		} else {
+			result.Items = append(result.Items, CheckItem{
+				Label:  "validation",
+				Status: StatusFail,
+				Detail: err.Error(),
+			})
+		}
+	}
+
+	// Extract and report warnings
+	for _, w := range warnings {
+		label := w.Category
+		if w.Item != "" {
+			label += " (" + w.Item + ")"
+		}
+		result.Items = append(result.Items, CheckItem{
+			Label:  label,
+			Status: StatusWarn,
+			Detail: w.Message,
+		})
+	}
+
+	return result
+}