feat: new registry

## Description

The old architecture used a monolithic `main()` with a custom arg parser, an event-emitter-based runtime, and a plugin system for optional features.
This PR rewrites the CLI and internal architecture to be modular, extensible, and built around a registry of interchangeable components.

- Replace custom CLI arg parsing with Cobra subcommands (`convert`, `reduce`, `engine list`).
- Introduce a registry system (`internal/registry`) for marshalers, codecs, and engines, with BFS-based conversion path resolution.
- Add type-erased adapter layer (`internal/cli`) with `Repr`, `Engine`, `Process`, `Marshaler`, and `Conversion` interfaces wrapping generic `pkg/` types.
- Replace the event-emitter-based `Runtime` with a simpler `Engine`/`Process` model (`pkg/engine`).
- Add generic `Codec[T, U]` and `Marshaler[T]` interfaces (`pkg/codec`).
- Merge `saccharine/token` sub-package into `saccharine` and rename scanner functions from `parse*` to `scan*`.
- Make saccharine-to-lambda conversion bidirectional (encode and decode).
- Add `lambda.Marshaler` and `saccharine.Marshaler` implementing `codec.Marshaler`.
- Remove old infrastructure: `pkg/runtime`, `pkg/expr`, `internal/plugins`, `internal/statistics`.
- Add `make lint` target and update golangci-lint config.

### Decisions

- Cobra was chosen for the CLI framework to support nested subcommands and standard flag handling.
- The registry uses BFS to find conversion paths between representations, allowing multi-hop conversions without hardcoding routes.
- Type erasure via `cli.Repr` (wrapping `any`) enables the registry to work with heterogeneous types while keeping `pkg/` generics type-safe.
- The old plugin/event system was removed entirely rather than adapted, since the new `Process` model can support hooks differently in the future.

## Benefits

- Subcommands make the CLI self-documenting and easier to extend with new functionality.
- The registry pattern decouples representations, conversions, and engines, making it trivial to add new ones.
- BFS conversion routing means adding a single codec automatically enables transitive conversions.
- Simpler `Engine`/`Process` model reduces complexity compared to the event-emitter runtime.
- Consolidating the `token` sub-package reduces import depth and package sprawl.

## Checklist

- [x] Code follows conventional commit format.
- [x] Branch follows naming convention (`<type>/<description>`). Always use underscores.
- [ ] Tests pass (if applicable).
- [ ] Documentation updated (if applicable).

Reviewed-on: #41
Co-authored-by: M.V. Hutz <git@maximhutz.me>
Co-committed-by: M.V. Hutz <git@maximhutz.me>

cmd/lambda/lambda.go

@@ -1,10 +1,8 @@
 package main
 
 import (
-	"fmt"
 	"os"
 
-	"git.maximhutz.com/max/lambda/internal/config"
 	"github.com/spf13/cobra"
 )
 
@@ -13,74 +11,14 @@ func Lambda() *cobra.Command {
 		Use:   "lambda",
 		Short: "Lambda calculus interpreter",
 		Long:  "A lambda calculus interpreter supporting multiple representations.",
-		RunE: func(cmd *cobra.Command, args []string) error {
-			// Legacy behavior when no subcommand is given.
-			options, err := config.FromArgs()
-			if err != nil {
-				return err
-			}
-
-			logger := options.GetLogger()
-			logger.Info("using program arguments", "args", os.Args)
-			logger.Info("parsed CLI options", "options", options)
-
-			r := GetRegistry()
-
-			// Get input.
-			input, err := options.Source.Extract()
-			if err != nil {
-				return err
-			}
-
-			// Parse code into syntax tree.
-			repr, err := r.Unmarshal(input, "saccharine")
-			if err != nil {
-				return err
-			}
-			logger.Info("parsed syntax tree", "tree", repr)
-
-			// Compile expression to lambda calculus.
-			compiled, err := r.ConvertTo(repr, "lambda")
-			if err != nil {
-				return err
-			}
-			logger.Info("compiled λ expression", "tree", compiled)
-
-			// Create reducer with the compiled expression.
-			engine, err := r.GetDefaultEngine("lambda")
-			if err != nil {
-				return err
-			}
-
-			process := engine.Load()
-			err = process.Set(compiled)
-			if err != nil {
-				return err
-			}
-
-			// Run reduction.
-			for process.Step(1) {
-			}
-
-			// Return the final reduced result.
-			result, err := process.Get()
-			if err != nil {
-				return err
-			}
-
-			output, err := r.Marshal(result)
-			if err != nil {
-				return err
-			}
-
-			return options.Destination.Write(output)
+		RunE: func(cmd *cobra.Command, _ []string) error {
+			return cmd.Help()
 		},
 	}
 
-	cmd.PersistentFlags().BoolP("verbose", "v", false, "Enable verbose output")
-
 	cmd.AddCommand(LambdaConvert())
 	cmd.AddCommand(LambdaEngine())
+	cmd.AddCommand(LambdaReduce())
 
 	return cmd
 }
@@ -88,7 +26,6 @@ func Lambda() *cobra.Command {
 func main() {
 	lambda := Lambda()
 	if err := lambda.Execute(); err != nil {
-		fmt.Fprintln(os.Stderr, err)
 		os.Exit(1)
 	}
 }

cmd/lambda/lambda_convert.go

@@ -6,17 +6,15 @@ import (
 	"path/filepath"
 	"strings"
 
-	"git.maximhutz.com/max/lambda/internal/cli"
 	"github.com/spf13/cobra"
-	"github.com/spf13/viper"
 )
 
 // inferReprFromPath returns the repr type based on file extension.
 func inferReprFromPath(path string) (string, error) {
 	switch ext := strings.ToLower(filepath.Ext(path)); ext {
-	case ".lam", ".lambda":
+	case ".lambda", ".lam", ".lc":
 		return "lambda", nil
-	case ".sac", ".saccharine":
+	case ".saccharine", ".sch":
 		return "saccharine", nil
 	default:
 		return "", fmt.Errorf("unknown file extension '%s'", ext)
@@ -24,24 +22,34 @@ func inferReprFromPath(path string) (string, error) {
 }
 
 func LambdaConvert() *cobra.Command {
-	cmd := &cobra.Command{
-		Use:   "convert <input> <output>",
-		Short: "Convert between lambda calculus representations",
-		Args:  cobra.ExactArgs(2),
-		RunE: func(cmd *cobra.Command, args []string) error {
-			inputPath := args[0]
-			outputPath := args[1]
+	var inputReprFlag, outputReprFlag string
 
-			// Infer repr types from extensions.
-			inputRepr, err := inferReprFromPath(inputPath)
-			if err != nil {
-				return fmt.Errorf("input file: %w", err)
+	cmd := &cobra.Command{
+		Use:          "convert <input-file> <output-file>",
+		Short:        "Convert between lambda calculus representations",
+		SilenceUsage: true,
+		RunE: func(cmd *cobra.Command, args []string) error {
+			if len(args) != 2 {
+				return cmd.Help()
 			}
 
-			outputRepr, err := inferReprFromPath(outputPath)
-			if err != nil {
+			var err error
+			inputPath, outputPath := args[0], args[1]
+
+			// Use flag if provided, otherwise infer from extension.
+			inputRepr := inputReprFlag
+			if inputRepr == "" {
+				if inputRepr, err = inferReprFromPath(inputPath); err != nil {
+					return fmt.Errorf("input file: %w", err)
+				}
+			}
+
+			outputRepr := outputReprFlag
+			if outputRepr == "" {
+				if outputRepr, err = inferReprFromPath(outputPath); err != nil {
 					return fmt.Errorf("output file: %w", err)
 				}
+			}
 
 			// Read input file.
 			input, err := os.ReadFile(inputPath)
@@ -57,29 +65,16 @@ func LambdaConvert() *cobra.Command {
 				return fmt.Errorf("parsing input: %w", err)
 			}
 
-			if viper.GetBool("verbose") {
-				fmt.Fprintf(os.Stderr, "Parsed %s from %s\n", inputRepr, inputPath)
-			}
-
 			// Convert to output repr if different.
-			var result cli.Repr
-			if inputRepr != outputRepr {
-				result, err = r.ConvertTo(repr, outputRepr)
+			result, err := r.ConvertTo(repr, outputRepr)
 			if err != nil {
 				return fmt.Errorf("converting %s to %s: %w", inputRepr, outputRepr, err)
 			}
 
-				if viper.GetBool("verbose") {
-					fmt.Fprintf(os.Stderr, "Converted to %s\n", outputRepr)
-				}
-			} else {
-				result = repr
-			}
-
 			// Marshal output.
 			output, err := r.Marshal(result)
 			if err != nil {
-				return fmt.Errorf("marshaling output: %w", err)
+				return fmt.Errorf("unmarshaling output: %w", err)
 			}
 
 			// Write output file.
@@ -88,13 +83,12 @@ func LambdaConvert() *cobra.Command {
 				return fmt.Errorf("writing output file: %w", err)
 			}
 
-			if viper.GetBool("verbose") {
-				fmt.Fprintf(os.Stderr, "Wrote %s to %s\n", outputRepr, outputPath)
-			}
-
 			return nil
 		},
 	}
 
+	cmd.Flags().StringVar(&inputReprFlag, "from", "", "Input representation (inferred from extension if unset)")
+	cmd.Flags().StringVar(&outputReprFlag, "to", "", "Output representation (inferred from extension if unset)")
+
 	return cmd
 }

cmd/lambda/lambda_reduce.go

@@ -0,0 +1,109 @@
+package main
+
+import (
+	"fmt"
+
+	"github.com/spf13/cobra"
+
+	"git.maximhutz.com/max/lambda/internal/cli"
+	"git.maximhutz.com/max/lambda/internal/config"
+)
+
+func LambdaReduce() *cobra.Command {
+	var inputReprFlag string
+	var engineFlag string
+
+	cmd := &cobra.Command{
+		Use:          "reduce <input-file>",
+		Short:        "Reduce a lambda calculus expression",
+		SilenceUsage: true,
+		Aliases:      []string{"run"},
+		RunE: func(cmd *cobra.Command, args []string) error {
+			var err error
+			if len(args) != 1 {
+				return cmd.Help()
+			}
+
+			inputPath := args[0]
+
+			// Get input source.
+			var source config.Source
+			if inputPath == "-" {
+				source = config.StdinSource{}
+			} else {
+				source = config.FileSource{Path: inputPath}
+			}
+
+			destination := config.StdoutDestination{}
+
+			r := GetRegistry()
+
+			// Get input.
+			input, err := source.Extract()
+			if err != nil {
+				return err
+			}
+
+			// Use flag if provided, otherwise infer from extension.
+			inputRepr := inputReprFlag
+			if inputRepr == "" {
+				if inputRepr, err = inferReprFromPath(inputPath); err != nil {
+					return fmt.Errorf("input file: %w", err)
+				}
+			}
+
+			// Find engine.
+			var engine cli.Engine
+			if engineFlag == "" {
+				if engine, err = r.GetDefaultEngine(inputRepr); err != nil {
+					return err
+				}
+			} else {
+				if engine, err = r.GetEngine(engineFlag); err != nil {
+					return err
+				}
+			}
+
+			// Parse code into syntax tree.
+			repr, err := r.Unmarshal(input, inputRepr)
+			if err != nil {
+				return err
+			}
+
+			// Compile expression to lambda calculus.
+			compiled, err := r.ConvertTo(repr, "lambda")
+			if err != nil {
+				return err
+			}
+
+			// Create process.
+			process := engine.Load()
+			err = process.Set(compiled)
+			if err != nil {
+				return err
+			}
+
+			// Run reduction.
+			for process.Step(1) {
+			}
+
+			// Return the final reduced result.
+			result, err := process.Get()
+			if err != nil {
+				return err
+			}
+
+			output, err := r.Marshal(result)
+			if err != nil {
+				return err
+			}
+
+			return destination.Write(output)
+		},
+	}
+
+	cmd.Flags().StringVar(&inputReprFlag, "from", "", "Input representation (inferred from extension if unset)")
+	cmd.Flags().StringVarP(&engineFlag, "engine", "e", "", "Reduction engine (inferred from '--input' if unset)")
+
+	return cmd
+}

go.mod

@@ -2,25 +2,9 @@ module git.maximhutz.com/max/lambda
 
 go 1.25.5
 
-require github.com/stretchr/testify v1.11.1
+require github.com/spf13/cobra v1.10.2
 
 require (
-	github.com/davecgh/go-spew v1.1.1 // indirect
-	github.com/fsnotify/fsnotify v1.9.0 // indirect
-	github.com/go-viper/mapstructure/v2 v2.4.0 // indirect
 	github.com/inconshreveable/mousetrap v1.1.0 // indirect
-	github.com/pelletier/go-toml/v2 v2.2.4 // indirect
-	github.com/pmezard/go-difflib v1.0.0 // indirect
-	github.com/sagikazarmark/locafero v0.11.0 // indirect
-	github.com/sourcegraph/conc v0.3.1-0.20240121214520-5f936abd7ae8 // indirect
-	github.com/spf13/afero v1.15.0 // indirect
-	github.com/spf13/cast v1.10.0 // indirect
-	github.com/spf13/cobra v1.10.2 // indirect
 	github.com/spf13/pflag v1.0.10 // indirect
-	github.com/spf13/viper v1.21.0 // indirect
-	github.com/subosito/gotenv v1.6.0 // indirect
-	go.yaml.in/yaml/v3 v3.0.4 // indirect
-	golang.org/x/sys v0.29.0 // indirect
-	golang.org/x/text v0.28.0 // indirect
-	gopkg.in/yaml.v3 v3.0.1 // indirect
 )

go.sum

@@ -1,42 +1,11 @@
 github.com/cpuguy83/go-md2man/v2 v2.0.6/go.mod h1:oOW0eioCTA6cOiMLiUPZOpcVxMig6NIQQ7OS05n1F4g=
-github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
-github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/fsnotify/fsnotify v1.9.0 h1:2Ml+OJNzbYCTzsxtv8vKSFD9PbJjmhYF14k/jKC7S9k=
-github.com/fsnotify/fsnotify v1.9.0/go.mod h1:8jBTzvmWwFyi3Pb8djgCCO5IBqzKJ/Jwo8TRcHyHii0=
-github.com/go-viper/mapstructure/v2 v2.4.0 h1:EBsztssimR/CONLSZZ04E8qAkxNYq4Qp9LvH92wZUgs=
-github.com/go-viper/mapstructure/v2 v2.4.0/go.mod h1:oJDH3BJKyqBA2TXFhDsKDGDTlndYOZ6rGS0BRZIxGhM=
 github.com/inconshreveable/mousetrap v1.1.0 h1:wN+x4NVGpMsO7ErUn/mUI3vEoE6Jt13X2s0bqwp9tc8=
 github.com/inconshreveable/mousetrap v1.1.0/go.mod h1:vpF70FUmC8bwa3OWnCshd2FqLfsEA9PFc4w1p2J65bw=
-github.com/pelletier/go-toml/v2 v2.2.4 h1:mye9XuhQ6gvn5h28+VilKrrPoQVanw5PMw/TB0t5Ec4=
-github.com/pelletier/go-toml/v2 v2.2.4/go.mod h1:2gIqNv+qfxSVS7cM2xJQKtLSTLUE9V8t9Stt+h56mCY=
-github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
-github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
-github.com/sagikazarmark/locafero v0.11.0 h1:1iurJgmM9G3PA/I+wWYIOw/5SyBtxapeHDcg+AAIFXc=
-github.com/sagikazarmark/locafero v0.11.0/go.mod h1:nVIGvgyzw595SUSUE6tvCp3YYTeHs15MvlmU87WwIik=
-github.com/sourcegraph/conc v0.3.1-0.20240121214520-5f936abd7ae8 h1:+jumHNA0Wrelhe64i8F6HNlS8pkoyMv5sreGx2Ry5Rw=
-github.com/sourcegraph/conc v0.3.1-0.20240121214520-5f936abd7ae8/go.mod h1:3n1Cwaq1E1/1lhQhtRK2ts/ZwZEhjcQeJQ1RuC6Q/8U=
-github.com/spf13/afero v1.15.0 h1:b/YBCLWAJdFWJTN9cLhiXXcD7mzKn9Dm86dNnfyQw1I=
-github.com/spf13/afero v1.15.0/go.mod h1:NC2ByUVxtQs4b3sIUphxK0NioZnmxgyCrfzeuq8lxMg=
-github.com/spf13/cast v1.10.0 h1:h2x0u2shc1QuLHfxi+cTJvs30+ZAHOGRic8uyGTDWxY=
-github.com/spf13/cast v1.10.0/go.mod h1:jNfB8QC9IA6ZuY2ZjDp0KtFO2LZZlg4S/7bzP6qqeHo=
 github.com/spf13/cobra v1.10.2 h1:DMTTonx5m65Ic0GOoRY2c16WCbHxOOw6xxezuLaBpcU=
 github.com/spf13/cobra v1.10.2/go.mod h1:7C1pvHqHw5A4vrJfjNwvOdzYu0Gml16OCs2GRiTUUS4=
 github.com/spf13/pflag v1.0.9/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
 github.com/spf13/pflag v1.0.10 h1:4EBh2KAYBwaONj6b2Ye1GiHfwjqyROoF4RwYO+vPwFk=
 github.com/spf13/pflag v1.0.10/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
-github.com/spf13/viper v1.21.0 h1:x5S+0EU27Lbphp4UKm1C+1oQO+rKx36vfCoaVebLFSU=
-github.com/spf13/viper v1.21.0/go.mod h1:P0lhsswPGWD/1lZJ9ny3fYnVqxiegrlNrEmgLjbTCAY=
-github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
-github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
-github.com/subosito/gotenv v1.6.0 h1:9NlTDc1FTs4qu0DDq7AEtTPNw6SVm7uBMsUCUjABIf8=
-github.com/subosito/gotenv v1.6.0/go.mod h1:Dk4QP5c2W3ibzajGcXpNraDfq2IrhjMIvMSWPKKo0FU=
-go.yaml.in/yaml/v3 v3.0.4 h1:tfq32ie2Jv2UxXFdLJdh3jXuOzWiL1fo0bu/FbuKpbc=
 go.yaml.in/yaml/v3 v3.0.4/go.mod h1:DhzuOOF2ATzADvBadXxruRBLzYTpT36CKvDb3+aBEFg=
-golang.org/x/sys v0.29.0 h1:TPYlXGxvx1MGTn2GiZDhnjPA9wZzZeGKHHmKhHYvgaU=
-golang.org/x/sys v0.29.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
-golang.org/x/text v0.28.0 h1:rhazDwis8INMIwQ4tpjLDzUhx6RlXqZNPEM0huQojng=
-golang.org/x/text v0.28.0/go.mod h1:U8nCwOR8jO/marOQ0QbDiOngZVEBB7MAiitBuMjXiNU=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
-gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

internal/cli/conversion.go

@@ -21,7 +21,7 @@ type forwardCodec[T, U any] struct {
 func (c forwardCodec[T, U]) Run(r Repr) (Repr, error) {
 	t, ok := r.Data().(T)
 	if !ok {
-		return nil, fmt.Errorf("could not parse '%v' as '%s'", t, c.outType)
+		return nil, fmt.Errorf("could not parse '%v' as '%s'", t, c.inType)
 	}
 
 	u, err := c.codec.Encode(t)
@@ -29,7 +29,7 @@ func (c forwardCodec[T, U]) Run(r Repr) (Repr, error) {
 		return nil, err
 	}
 
-	return NewRepr(c.inType, u), nil
+	return NewRepr(c.outType, u), nil
 }
 
 func (c forwardCodec[T, U]) InType() string { return c.inType }
@@ -44,7 +44,7 @@ type backwardCodec[T, U any] struct {
 func (c backwardCodec[T, U]) Run(r Repr) (Repr, error) {
 	u, ok := r.Data().(U)
 	if !ok {
-		return nil, fmt.Errorf("could not parse '%v' as '%s'", r, c.inType)
+		return nil, fmt.Errorf("could not parse '%v' as '%s'", r, c.outType)
 	}
 
 	t, err := c.codec.Decode(u)
@@ -52,7 +52,7 @@ func (c backwardCodec[T, U]) Run(r Repr) (Repr, error) {
 		return nil, err
 	}
 
-	return NewRepr(c.outType, t), nil
+	return NewRepr(c.inType, t), nil
 }
 
 func (c backwardCodec[T, U]) InType() string { return c.outType }

internal/cli/marshaler.go

@@ -2,6 +2,7 @@ package cli
 
 import (
 	"fmt"
+	"reflect"
 
 	"git.maximhutz.com/max/lambda/pkg/codec"
 )
@@ -29,7 +30,9 @@ func (c convertedMarshaler[T]) Decode(s string) (Repr, error) {
 func (c convertedMarshaler[T]) Encode(r Repr) (string, error) {
 	t, ok := r.Data().(T)
 	if !ok {
-		return "", fmt.Errorf("could not parse '%v' as 'string'", t)
+		dataType := reflect.TypeOf(r.Data())
+		allowedType := reflect.TypeFor[T]()
+		return "", fmt.Errorf("marshaler for '%s' cannot parse '%s'", allowedType, dataType)
 	}
 
 	return c.codec.Encode(t)

internal/registry_new/conversion.go

@@ -0,0 +1,9 @@
+package registrynew
+
+// Conversion
+type Conversion interface {
+	InRepr() string
+	OutRepr() string
+
+	Run(Expr) (Expr, error)
+}

internal/registry_new/engine.go

@@ -0,0 +1,12 @@
+package registrynew
+
+type Process interface {
+	Get() (Expr, error)
+	Step(int) bool
+}
+
+type Engine interface {
+	Load(Expr) Process
+	Name() string
+	InRepr() string
+}

internal/registry_new/expr.go

@@ -0,0 +1,7 @@
+package registrynew
+
+type Expr interface {
+	Repr() string
+
+	Data() any
+}

internal/registry_new/marshaler.go

@@ -0,0 +1,5 @@
+package registrynew
+
+type Marshaler interface {
+	InType() string
+}

internal/registry_new/registry.go

@@ -0,0 +1,10 @@
+package registrynew
+
+import "iter"
+
+type Registry interface {
+	ListEngines() iter.Seq[string]
+	GetEngine(name string) (Engine, error)
+
+	ListReprs() iter.Seq[string]
+}

internal/registry_new/repr.go

@@ -0,0 +1,4 @@
+package registrynew
+
+type Repr interface {
+}