(feature): Add support for changing output format

supporting both Markdown and JSON output formats.

Signed-off-by: everettraven <everettraven@gmail.com>

Author: everettraven

pkg/cmd/root.go

@@ -6,6 +6,7 @@ import (
 
 	"github.com/everettraven/synkr/pkg/builtins"
 	"github.com/everettraven/synkr/pkg/engine"
+	"github.com/everettraven/synkr/pkg/printers"
 	"github.com/spf13/cobra"
 	"go.starlark.net/starlark"
 	"go.starlark.net/syntax"
@@ -14,31 +15,42 @@ import (
 func NewSynkrCommand() *cobra.Command {
 	eng := &engine.Engine{}
 	var configFile string
+	var outputFormat string
 
 	cmd := &cobra.Command{
-		Use:   "synkr [-c configFile]",
+		Use:   "synkr",
 		Short: "synkr is an engine for syncing work items based on a Starlark configuration",
 		Args:  cobra.ExactArgs(0),
 		RunE: func(cmd *cobra.Command, args []string) error {
-			return run(cmd.Context(), eng, configFile)
+			return run(cmd.Context(), eng, configFile, outputFormat)
 		},
 	}
 
 	cmd.Flags().StringVarP(&configFile, "config", "c", "synkr.star", "configures the Starlark file to be processed for configuration")
+	cmd.Flags().StringVarP(&outputFormat, "output", "o", "markdown", "configures the output format. Allowed values are [markdown, json]")
 
 	return cmd
 }
 
-func run(ctx context.Context, eng *engine.Engine, configFile string) error {
-	thread, err := configureEngine(eng, configFile)
+func run(ctx context.Context, eng *engine.Engine, configFile, output string) error {
+	thread, err := configureEngine(eng, configFile, output)
 	if err != nil {
 		return fmt.Errorf("configuring engine: %w", err)
 	}
 
 	return eng.Run(ctx, thread)
 }
 
-func configureEngine(eng *engine.Engine, configFile string) (*starlark.Thread, error) {
+func configureEngine(eng *engine.Engine, configFile, output string) (*starlark.Thread, error) {
+	switch output {
+	case "markdown":
+		eng.SetPrinter(&printers.Markdown{})
+	case "json":
+		eng.SetPrinter(&printers.JSON{})
+	default:
+		return nil, fmt.Errorf("unknown output format %q", output)
+	}
+
 	globals := starlark.StringDict{}
 
 	builtins.Github(globals, eng)

pkg/engine/engine.go

@@ -2,7 +2,6 @@ package engine
 
 import (
 	"context"
-	"encoding/json"
 	"fmt"
 	"strings"
 
@@ -11,6 +10,7 @@ import (
 
 type Engine struct {
 	sources []Source
+	printer Printer
 }
 
 type Source interface {
@@ -19,21 +19,25 @@ type Source interface {
 	Project() string
 }
 
-type output struct {
+type Printer interface {
+	Print(SourceResult) (string, error)
+}
+
+type SourceResult struct {
 	Source  string `json:"source"`
 	Project string `json:"project"`
 	Items   []any  `json:"items"`
 }
 
 func (e *Engine) Run(ctx context.Context, thread *starlark.Thread) error {
-	outputs := []output{}
+	outputs := []SourceResult{}
 	for _, source := range e.sources {
 		items, err := source.Fetch(ctx, thread)
 		if err != nil {
 			return err
 		}
 
-		outputs = append(outputs, output{
+		outputs = append(outputs, SourceResult{
 			Source:  source.Name(),
 			Project: source.Project(),
 			Items:   items,
@@ -42,12 +46,11 @@ func (e *Engine) Run(ctx context.Context, thread *starlark.Thread) error {
 
 	outs := []string{}
 	for _, output := range outputs {
-		outBytes, err := json.Marshal(output)
+		out, err := e.printer.Print(output)
 		if err != nil {
-			return fmt.Errorf("marshalling output %v to json: %w", output, err)
+			return fmt.Errorf("printing source result %v: %w", output, err)
 		}
-
-		outs = append(outs, string(outBytes))
+		outs = append(outs, out)
 	}
 
 	fmt.Print(strings.Join(outs, "\n"))
@@ -57,3 +60,7 @@ func (e *Engine) Run(ctx context.Context, thread *starlark.Thread) error {
 func (e *Engine) AddSource(source Source) {
 	e.sources = append(e.sources, source)
 }
+
+func (e *Engine) SetPrinter(printer Printer) {
+	e.printer = printer
+}

pkg/printers/json.go

@@ -0,0 +1,18 @@
+package printers
+
+import (
+	"encoding/json"
+
+	"github.com/everettraven/synkr/pkg/engine"
+)
+
+type JSON struct{}
+
+func (j *JSON) Print(result engine.SourceResult) (string, error) {
+	outBytes, err := json.Marshal(result)
+	if err != nil {
+		return "", err
+	}
+
+	return string(outBytes), nil
+}

pkg/printers/markdown.go

@@ -0,0 +1,48 @@
+package printers
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/everettraven/synkr/pkg/engine"
+	"github.com/everettraven/synkr/pkg/sources/github"
+)
+
+type Markdown struct{}
+
+func (md *Markdown) Print(result engine.SourceResult) (string, error) {
+	var out strings.Builder
+	out.WriteString(fmt.Sprintf("# %s - %s\n", result.Source, result.Project))
+
+	for _, item := range result.Items {
+		switch item := item.(type) {
+		case github.RepoItem:
+			out.WriteString(md.PrintGitHubRepoItem(item))
+		default:
+			out.WriteString(fmt.Sprintf("%v", item))
+		}
+
+		out.WriteString("\n")
+	}
+
+	return out.String(), nil
+}
+
+func (md *Markdown) PrintGitHubRepoItem(item github.RepoItem) string {
+	var out strings.Builder
+
+	out.WriteString(fmt.Sprintf("## [%s][%s]: %s \n", item.Type, item.State, item.Title))
+	out.WriteString(fmt.Sprintf("**URL**: %s\n", item.URL))
+	out.WriteString(fmt.Sprintf("**Author**: *%s*\n", item.Author))
+	out.WriteString(fmt.Sprintf("**Assignees**: %s\n", strings.Join(item.Assignees, ",")))
+
+	out.WriteString("\n")
+	labelStrs := []string{}
+	for _, label := range item.Labels {
+		labelStrs = append(labelStrs, fmt.Sprintf("`%s`", label))
+	}
+	out.WriteString(fmt.Sprintf("%s\n\n", strings.Join(labelStrs, " ")))
+	out.WriteString(fmt.Sprintf("%s\n", item.Body))
+
+	return out.String()
+}