feature(cli): add discussion write commands (submit, update, delete)

Restructure comment write operations into a dedicated cmd/discussions
sub-package with a proper service layer, extracting RunE closures into
standalone named functions. Context helpers moved to internal/cmdctx to
avoid circular imports between cmd and cmd/discussions.

Also fixes the logging stderr filter to mirror the configured level
(not just errors) and corrects the corresponding tests.

Author: CodeLieutenant

cli/cmd/context.go

@@ -6,145 +6,76 @@ import (
 	"github.com/rs/zerolog"
 	"github.com/scylladb/argus/cli/internal/api"
 	"github.com/scylladb/argus/cli/internal/cache"
+	"github.com/scylladb/argus/cli/internal/cmdctx"
 	"github.com/scylladb/argus/cli/internal/config"
 	"github.com/scylladb/argus/cli/internal/logging"
 	"github.com/scylladb/argus/cli/internal/output"
 )
 
-// outputterKey is the context key used to store the [output.Outputter].
-type outputterKey struct{}
+// ---------------------------------------------------------------------------
+// Thin wrappers that delegate to the shared cmdctx package.
+//
+// The unexported contextWith* functions are kept for backward compatibility
+// with existing tests that export them via export_test.go.  New sub-command
+// packages (e.g. cmd/discussions) should import cmdctx directly.
+// ---------------------------------------------------------------------------
 
 // contextWithOutputter returns a copy of ctx carrying out.
 func contextWithOutputter(ctx context.Context, out output.Outputter) context.Context {
-	if ctx == nil {
-		ctx = context.Background()
-	}
-
-	return context.WithValue(ctx, outputterKey{}, out)
+	return cmdctx.WithOutputter(ctx, out)
 }
 
-// OutputterFrom retrieves the [output.Outputter] stored in cmd's context.
-// It panics if no Outputter is present, which indicates that the command was
-// registered without going through the root PersistentPreRun chain.
+// OutputterFrom retrieves the [output.Outputter] stored in ctx.
 func OutputterFrom(ctx context.Context) output.Outputter {
-	out, ok := ctx.Value(outputterKey{}).(output.Outputter)
-	if !ok {
-		panic("cmd: no output.Outputter in context; ensure PersistentPreRun propagates from root")
-	}
-
-	return out
+	return cmdctx.OutputterFrom(ctx)
 }
 
-// apiClientKey is the context key used to store the [api.Client].
-type apiClientKey struct{}
-
 // contextWithAPIClient returns a copy of ctx carrying client.
 func contextWithAPIClient(ctx context.Context, client *api.Client) context.Context {
-	if ctx == nil {
-		ctx = context.Background()
-	}
-
-	return context.WithValue(ctx, apiClientKey{}, client)
+	return cmdctx.WithAPIClient(ctx, client)
 }
 
-// APIClientFrom retrieves the [api.Client] stored in cmd's context.
-// It panics if no client is present, which indicates that the command was
-// registered without going through the root PersistentPreRun chain.
+// APIClientFrom retrieves the [api.Client] stored in ctx.
 func APIClientFrom(ctx context.Context) *api.Client {
-	client, ok := ctx.Value(apiClientKey{}).(*api.Client)
-	if !ok {
-		panic("cmd: no api.Client in context; ensure PersistentPreRun propagates from root")
-	}
-
-	return client
+	return cmdctx.APIClientFrom(ctx)
 }
 
-// configKey is the context key used to store the [config.Config].
-type configKey struct{}
-
 // contextWithConfig returns a copy of ctx carrying cfg.
 func contextWithConfig(ctx context.Context, cfg *config.Config) context.Context {
-	if ctx == nil {
-		ctx = context.Background()
-	}
-
-	return context.WithValue(ctx, configKey{}, cfg)
+	return cmdctx.WithConfig(ctx, cfg)
 }
 
-// ConfigFrom retrieves the [config.Config] stored in cmd's context.
-// It panics if no Config is present, which indicates that the command was
-// registered without going through the root PersistentPreRun chain.
+// ConfigFrom retrieves the [config.Config] stored in ctx.
 func ConfigFrom(ctx context.Context) *config.Config {
-	cfg, ok := ctx.Value(configKey{}).(*config.Config)
-	if !ok {
-		panic("cmd: no config.Config in context; ensure PersistentPreRun propagates from root")
-	}
-
-	return cfg
+	return cmdctx.ConfigFrom(ctx)
 }
 
-// loggerKey is the context key used to store the root [zerolog.Logger].
-type loggerKey struct{}
-
 // contextWithLogger returns a copy of ctx carrying logger.
 func contextWithLogger(ctx context.Context, logger zerolog.Logger) context.Context {
-	if ctx == nil {
-		ctx = context.Background()
-	}
-
-	return context.WithValue(ctx, loggerKey{}, logger)
+	return cmdctx.WithLogger(ctx, logger)
 }
 
 // LoggerFrom retrieves the [zerolog.Logger] stored in ctx.
-// It panics if no logger is present, which indicates that the command was
-// registered without going through the root PersistentPreRun chain.
 func LoggerFrom(ctx context.Context) zerolog.Logger {
-	logger, ok := ctx.Value(loggerKey{}).(zerolog.Logger)
-	if !ok {
-		panic("cmd: no zerolog.Logger in context; ensure PersistentPreRun propagates from root")
-	}
-
-	return logger
+	return cmdctx.LoggerFrom(ctx)
 }
 
-// cleanupKey is the context key used to store the logging [logging.CleanupFunc].
-type cleanupKey struct{}
-
 // contextWithCleanup returns a copy of ctx carrying cleanup.
 func contextWithCleanup(ctx context.Context, cleanup logging.CleanupFunc) context.Context {
-	if ctx == nil {
-		ctx = context.Background()
-	}
-
-	return context.WithValue(ctx, cleanupKey{}, cleanup)
+	return cmdctx.WithCleanup(ctx, cleanup)
 }
 
 // CleanupFrom retrieves the [logging.CleanupFunc] stored in ctx.
-// Returns a no-op if none is present (e.g. when logging setup failed or in
-// tests that bypass PersistentPreRun).
 func CleanupFrom(ctx context.Context) logging.CleanupFunc {
-	if fn, ok := ctx.Value(cleanupKey{}).(logging.CleanupFunc); ok {
-		return fn
-	}
-	return func() {}
+	return cmdctx.CleanupFrom(ctx)
 }
 
-// cacheKey is the context key used to store the [cache.Cache].
-type cacheKey struct{}
-
 // contextWithCache returns a copy of ctx carrying c.
 func contextWithCache(ctx context.Context, c *cache.Cache) context.Context {
-	if ctx == nil {
-		ctx = context.Background()
-	}
-	return context.WithValue(ctx, cacheKey{}, c)
+	return cmdctx.WithCache(ctx, c)
 }
 
 // CacheFrom retrieves the [cache.Cache] stored in ctx.
-// Returns a disabled cache if none is present so callers never need to nil-check.
 func CacheFrom(ctx context.Context) *cache.Cache {
-	if c, ok := ctx.Value(cacheKey{}).(*cache.Cache); ok {
-		return c
-	}
-	return cache.New("", cache.WithDisabled(true))
+	return cmdctx.CacheFrom(ctx)
 }