refactor: Centralize Application Metadata in AppContext

Migrating from hardcoded constants to a context-driven architecture
where `AppContext` serves as the single source of truth for application
metadata.

Assisted-by: Claude

Author: otaviof

cmd/tssc/main.go

@@ -5,8 +5,8 @@ import (
 	"os"
 
 	"github.com/redhat-appstudio/tssc-cli/installer"
+	"github.com/redhat-appstudio/tssc-cli/pkg/api"
 	"github.com/redhat-appstudio/tssc-cli/pkg/chartfs"
-	"github.com/redhat-appstudio/tssc-cli/pkg/constants"
 	"github.com/redhat-appstudio/tssc-cli/pkg/framework"
 	"github.com/redhat-appstudio/tssc-cli/pkg/subcmd"
 )
@@ -34,22 +34,26 @@ func main() {
 	ofs := chartfs.NewOverlayFS(tfs, os.DirFS(cwd))
 	cfs := chartfs.New(ofs)
 
-	// Compute TSSC-specific MCP server image based on build-time commit ID
+	// Create TSSC-specific application context (metadata/configuration).
+	appCtx := api.NewAppContext(
+		"tssc",
+		api.WithVersion(version),
+		api.WithCommitID(commitID),
+		api.WithShortDescription("Trusted Software Supply Chain CLI"),
+	)
+
+	// TSSC-specific MCP server image based on build-time commit ID.
 	mcpImage := "quay.io/redhat-user-workloads/rhtap-shared-team-tenant/tssc-cli"
 	if commitID == "" {
 		mcpImage = fmt.Sprintf("%s:latest", mcpImage)
 	} else {
 		mcpImage = fmt.Sprintf("%s:%s", mcpImage, commitID)
 	}
 
-	// Creating a new TSSC application instance using all standard integration
-	// modules.
+	// Create application runtime with context and dependencies.
 	app, err := framework.NewApp(
-		constants.AppName,
+		appCtx,
 		cfs,
-		framework.WithVersion(version),
-		framework.WithCommitID(commitID),
-		framework.WithShortDescription("Trusted Software Supply Chain CLI"),
 		framework.WithIntegrations(subcmd.StandardModules()...),
 		framework.WithMCPImage(mcpImage),
 	)

pkg/api/appcontext.go

@@ -0,0 +1,99 @@
+package api
+
+import (
+	"fmt"
+)
+
+// AppContext holds immutable application metadata.
+// This is passed throughout the component tree as the single source of truth
+// for application identity, versioning, and organizational information.
+//
+// AppContext is separated from App to distinguish between configuration
+// (what the app is) and runtime (how the app runs).
+type AppContext struct {
+	Name      string // application name
+	Version   string // application version
+	CommitID  string // git commit ID
+	Namespace string // default installation namespace
+	OrgName   string // organization name
+	Domain    string // organization domain
+	Short     string // short description for CLI
+	Long      string // long description for CLI
+}
+
+// RepoURI returns the reverse repository URI.
+func (a *AppContext) RepoURI() string {
+	return fmt.Sprintf("%s.%s.%s", a.Name, a.OrgName, a.Domain)
+}
+
+// ContextOption is a functional option for configuring AppContext.
+type ContextOption func(*AppContext)
+
+// WithNamespace sets the default installation namespace.
+func WithNamespace(namespace string) ContextOption {
+	return func(a *AppContext) {
+		a.Namespace = namespace
+	}
+}
+
+// WithOrganization sets the organization name.
+func WithOrganization(org string) ContextOption {
+	return func(a *AppContext) {
+		a.OrgName = org
+	}
+}
+
+// WithDomain sets the domain.
+func WithDomain(domain string) ContextOption {
+	return func(a *AppContext) {
+		a.Domain = domain
+	}
+}
+
+// WithVersion sets the application version.
+func WithVersion(version string) ContextOption {
+	return func(a *AppContext) {
+		a.Version = version
+	}
+}
+
+// WithCommitID sets the git commit ID.
+func WithCommitID(commitID string) ContextOption {
+	return func(a *AppContext) {
+		a.CommitID = commitID
+	}
+}
+
+// WithShortDescription sets the short CLI description.
+func WithShortDescription(short string) ContextOption {
+	return func(a *AppContext) {
+		a.Short = short
+	}
+}
+
+// WithLongDescription sets the long CLI description.
+func WithLongDescription(long string) ContextOption {
+	return func(a *AppContext) {
+		a.Long = long
+	}
+}
+
+// NewAppContext creates a new application context with sensible defaults.
+// The only required parameter is the application name; all other fields
+// can be configured via functional options.
+func NewAppContext(name string, opts ...ContextOption) *AppContext {
+	appCtx := &AppContext{
+		Name:      name,
+		Namespace: name,
+		Domain:    "github.com",
+		OrgName:   "redhat-appstudio",
+		Version:   "v0.0.0-SNAPSHOT",
+		CommitID:  "unknown",
+		Short:     "",
+		Long:      "",
+	}
+	for _, opt := range opts {
+		opt(appCtx)
+	}
+	return appCtx
+}

pkg/api/constants.go

@@ -0,0 +1,15 @@
+package api
+
+const (
+	// ConfigFilename is the installer configuration file (framework contract).
+	// All installers using this framework must provide this file.
+	ConfigFilename = "config.yaml"
+
+	// ValuesFilename is the values template file (framework contract).
+	// All installers using this framework must provide this file.
+	ValuesFilename = "values.yaml.tpl"
+
+	// InstructionsFilename is the MCP instructions file (framework convention).
+	// This file provides instructions for the Model Context Protocol server.
+	InstructionsFilename = "instructions.md"
+)

pkg/api/types.go

@@ -18,6 +18,11 @@ type IntegrationModule struct {
 	Init func(*slog.Logger, *k8s.Kube) integration.Interface
 
 	// Command creates the CLI subcommand for this integration.
-	// It receives the initialized integration wrapper (which handles Secrets).
-	Command func(*slog.Logger, *k8s.Kube, *integration.Integration) SubCommand
+	// It receives the application context and initialized integration wrapper.
+	Command func(
+		*AppContext,
+		*slog.Logger,
+		*k8s.Kube,
+		*integration.Integration,
+	) SubCommand
 }

pkg/chartfs/chartfs_test.go

@@ -4,8 +4,6 @@ import (
 	"os"
 	"testing"
 
-	"github.com/redhat-appstudio/tssc-cli/pkg/constants"
-
 	o "github.com/onsi/gomega"
 )
 
@@ -16,7 +14,7 @@ func TestNewChartFS(t *testing.T) {
 	g.Expect(c).ToNot(o.BeNil())
 
 	t.Run("ReadFile", func(t *testing.T) {
-		valuesTmplBytes, err := c.ReadFile(constants.ValuesFilename)
+		valuesTmplBytes, err := c.ReadFile("values.yaml.tpl")
 		g.Expect(err).To(o.Succeed())
 		g.Expect(valuesTmplBytes).ToNot(o.BeEmpty())
 	})

pkg/constants/constants.go

@@ -1,31 +1,15 @@
 package constants
 
-import "fmt"
-
 const (
-	// AppName is the name of the application.
-	AppName = "tssc"
-
-	// Namespace is the default namespace for the application.
-	Namespace = "tssc"
-
-	// OrgName is the name of the organization.
-	OrgName = "redhat-appstudio"
-
-	// Domain organization domain.
-	Domain = "github.com"
-
-	// ConfigFilename is the name of the configuration file.
+	// ConfigFilename is the installer configuration file (framework contract).
+	// All installers using this framework must provide this file.
 	ConfigFilename = "config.yaml"
 
-	// ValuesFilename is the name of the values template file.
+	// ValuesFilename is the values template file (framework contract).
+	// All installers using this framework must provide this file.
 	ValuesFilename = "values.yaml.tpl"
 
-	// InstructionsFilename is the name of the instructions file.
+	// InstructionsFilename is the MCP instructions file (framework convention).
+	// This file provides instructions for the Model Context Protocol server.
 	InstructionsFilename = "instructions.md"
 )
-
-var (
-	// RepoURI is the reverse repository URI for the application.
-	RepoURI = fmt.Sprintf("%s.%s.%s", AppName, OrgName, Domain)
-)

pkg/framework/app.go

@@ -15,14 +15,12 @@ import (
 	"github.com/spf13/cobra"
 )
 
-// App represents the installer application.
+// App represents the installer application runtime.
+// It holds runtime dependencies and coordinates the execution of commands.
+// Application metadata (name, version, etc.) is stored in AppCtx.
 type App struct {
-	Name     string           // application name
-	Version  string           // application version
-	CommitID string           // application commit ID
-	Short    string           // short description
-	Long     string           // long description
-	ChartFS  *chartfs.ChartFS // installer filesystem
+	AppCtx  *api.AppContext  // application metadata (single source of truth)
+	ChartFS *chartfs.ChartFS // installer filesystem
 
 	integrations       []api.IntegrationModule // supported integrations
 	integrationManager *integrations.Manager   // integrations manager
@@ -47,15 +45,15 @@ func (a *App) Run() error {
 // setupRootCmd instantiates the Cobra Root command with subcommand, description,
 // Kubernetes API client instance and more.
 func (a *App) setupRootCmd() error {
-	short := a.Short
+	short := a.AppCtx.Short
 	if short == "" {
-		short = a.Name + " installer"
+		short = a.AppCtx.Name + " installer"
 	}
 
 	a.rootCmd = &cobra.Command{
-		Use:          a.Name,
+		Use:          a.AppCtx.Name,
 		Short:        short,
-		Long:         a.Long,
+		Long:         a.AppCtx.Long,
 		SilenceUsage: true,
 	}
 
@@ -65,7 +63,8 @@ func (a *App) setupRootCmd() error {
 	// Handle version flag and help.
 	a.rootCmd.RunE = func(cmd *cobra.Command, args []string) error {
 		if a.flags.Version {
-			a.flags.ShowVersion(a.Name, a.Version, a.CommitID)
+			a.flags.ShowVersion(
+				a.AppCtx.Name, a.AppCtx.Version, a.AppCtx.CommitID)
 			return nil
 		}
 		return cmd.Help()
@@ -76,14 +75,14 @@ func (a *App) setupRootCmd() error {
 	// Loading informed integrations into the manager.
 	a.integrationManager = integrations.NewManager()
 	if err := a.integrationManager.LoadModules(
-		a.Name, logger, a.kube, a.integrations,
+		a.AppCtx.Name, logger, a.kube, a.integrations,
 	); err != nil {
 		return fmt.Errorf("failed to load modules: %w", err)
 	}
 
 	// Register standard subcommands.
 	a.rootCmd.AddCommand(subcmd.NewIntegration(
-		a.Name, logger, a.kube, a.ChartFS, a.integrationManager,
+		a.AppCtx, logger, a.kube, a.ChartFS, a.integrationManager,
 	))
 
 	// Use default builder if none provided.
@@ -100,32 +99,67 @@ func (a *App) setupRootCmd() error {
 
 	// Other subcommands via api.Runner.
 	subs := []api.SubCommand{
-		subcmd.NewConfig(logger, a.flags, a.ChartFS, a.kube),
-		subcmd.NewDeploy(logger, a.flags, a.ChartFS, a.kube, a.integrationManager),
-		subcmd.NewInstaller(a.flags),
+		subcmd.NewConfig(
+			a.AppCtx,
+			logger,
+			a.flags,
+			a.ChartFS,
+			a.kube,
+		),
+		subcmd.NewDeploy(
+			a.AppCtx,
+			logger,
+			a.flags,
+			a.ChartFS,
+			a.kube,
+			a.integrationManager,
+		),
+		subcmd.NewInstaller(
+			a.AppCtx,
+			a.flags,
+		),
 		subcmd.NewMCPServer(
-			a.Name,
+			a.AppCtx,
 			a.flags,
 			a.ChartFS,
 			a.kube,
 			a.integrationManager,
 			mcpBuilder,
 			a.mcpImage,
 		),
-		subcmd.NewTemplate(logger, a.flags, a.ChartFS, a.kube),
-		subcmd.NewTopology(logger, a.ChartFS, a.kube),
+		subcmd.NewTemplate(
+			a.AppCtx,
+			logger,
+			a.flags,
+			a.ChartFS,
+			a.kube,
+		),
+		subcmd.NewTopology(
+			a.AppCtx,
+			logger,
+			a.ChartFS,
+			a.kube,
+		),
 	}
 	for _, sub := range subs {
 		a.rootCmd.AddCommand(api.NewRunner(sub).Cmd())
 	}
 	return nil
 }
 
-// NewApp creates a new installer application. It automatically sets up the Cobra
-// Root Command and standard subcommands (Config, Integration, Deploy).
-func NewApp(name string, cfs *chartfs.ChartFS, opts ...Option) (*App, error) {
+// NewApp creates a new installer application runtime.
+// It automatically sets up the Cobra Root Command and standard subcommands.
+//
+// The appCtx parameter provides application metadata (name, version, etc.).
+// The cfs parameter provides access to the installer filesystem (charts, config).
+// Additional runtime options can be passed via functional options.
+func NewApp(
+	appCtx *api.AppContext,
+	cfs *chartfs.ChartFS,
+	opts ...Option,
+) (*App, error) {
 	app := &App{
-		Name:    name,
+		AppCtx:  appCtx,
 		ChartFS: cfs,
 		flags:   flags.NewFlags(),
 	}

pkg/framework/constants.go

@@ -0,0 +1,15 @@
+package framework
+
+const (
+	// ConfigFilename is the installer configuration file (framework contract).
+	// All installers using this framework must provide this file.
+	ConfigFilename = "config.yaml"
+
+	// ValuesFilename is the values template file (framework contract).
+	// All installers using this framework must provide this file.
+	ValuesFilename = "values.yaml.tpl"
+
+	// InstructionsFilename is the MCP instructions file (framework convention).
+	// This file provides instructions for the Model Context Protocol server.
+	InstructionsFilename = "instructions.md"
+)