feat: add recipes

cmd/sloctl/main.go

@@ -5,8 +5,14 @@
 // example configuration file can be found in this repository samples/config.toml.
 package main
 
-import "github.com/nobl9/sloctl/internal"
+import (
+	"os"
+
+	"github.com/nobl9/sloctl/internal"
+)
 
 func main() {
-	internal.Execute()
+	if err := internal.Execute(); err != nil {
+		os.Exit(1)
+	}
 }

cspell.json

@@ -44,6 +44,7 @@
     "golangci",
     "gosec",
     "govulncheck",
+    "govy",
     "ldflags",
     "nobl",
     "openslo",
@@ -58,6 +59,7 @@
     "unmarshalling",
     "vuln",
     "vulns",
-    "wrapf"
+    "wrapf",
+    "yamlenc"
   ]
 }

internal/builtin_recipes.yaml

@@ -0,0 +1,32 @@
+object-names:
+  description: Fetch object names
+  args: [get]
+  example: |
+    # Fetch SLO object names
+    sloctl recipe object-names slo
+  validators:
+    atLeastArgs: [kind]
+  jq: .[].metadata.name
+prometheus-slos:
+  args:
+    - get
+    - slo
+  description: Fetch all prometheus SLOs
+  jq: |
+    [ .[] | select(
+      .spec.objectives[] |
+      (.rawMetric and .rawMetric.query["prometheus"])
+      or
+      (.countMetrics and .countMetrics.total["prometheus"])
+    )]
+unique-integrations:
+  args:
+    - get
+    - slo
+    - -A
+  description: Display unique integration types for all SLOs
+  jq: |
+    [.[] |
+    first(.. | (.query? // .total?) |
+    select(type == "object") |
+    keys[0])] | unique[]

internal/convert.go

@@ -19,6 +19,7 @@ import (
 	"github.com/nobl9/nobl9-go/sdk"
 	"github.com/nobl9/nobl9-openslo/pkg/openslotonobl9"
 
+	"github.com/nobl9/sloctl/internal/jsonbuffer"
 	"github.com/nobl9/sloctl/internal/printer"
 )
 
@@ -123,7 +124,7 @@ func (c ConvertCmd) convertOpenSLODefinitions(cmd *cobra.Command) ([]manifest.Ob
 
 func (c ConvertCmd) readOpenSLODefinitionsFromSource(def *sdk.RawDefinition) ([]openslo.Object, error) {
 	format := openslosdk.FormatYAML
-	if isJSONBuffer(def.Definition) {
+	if jsonbuffer.IsJSON(def.Definition) {
 		format = openslosdk.FormatJSON
 	}
 	objects, err := openslosdk.Decode(bytes.NewReader(def.Definition), format)
@@ -164,15 +165,6 @@ func (c ConvertCmd) setManifestSourceForOpenSLOObject(object []byte, basePath, s
 	return object, nil
 }
 
-var jsonBufferRegex = regexp.MustCompile(`^\s*\[?\s*{`)
-
-// isJSONBuffer scans the provided buffer, looking for an open brace indicating this is JSON.
-// While a simple list like ["a", "b", "c"] is still a valid JSON,
-// it does not really concern us when processing complex objects.
-func isJSONBuffer(buf []byte) bool {
-	return jsonBufferRegex.Match(buf)
-}
-
 var opensloAPIVersionRegex = regexp.MustCompile(`"?apiVersion"?\s*:\s*"?openslo`)
 
 func (c ConvertCmd) filterOpenSLORawDefinitions(definitions []*sdk.RawDefinition) ([]*sdk.RawDefinition, error) {

internal/jq/jq.go

@@ -11,8 +11,8 @@ import (
 	"github.com/itchyny/gojq"
 )
 
-func NewExpressionRunner(config Config) *ExpressionRunner {
-	return &ExpressionRunner{config: config}
+func NewExpressionRunner(config Config) ExpressionRunner {
+	return ExpressionRunner{config: config}
 }
 
 type ExpressionRunner struct {
@@ -23,13 +23,13 @@ type Config struct {
 	Expression string
 }
 
-func (e *ExpressionRunner) ShouldRun() bool {
+func (e ExpressionRunner) ShouldRun() bool {
 	return e.config.Expression != ""
 }
 
 // Evaluate parses, compiles and runs jq expressions.
 // It returns an iterator which yields jq expression result and error (if any).
-func (e *ExpressionRunner) Evaluate(v any) (iter.Seq2[any, error], error) {
+func (e ExpressionRunner) Evaluate(v any) (iter.Seq2[any, error], error) {
 	query, err := gojq.Parse(e.config.Expression)
 	if err != nil {
 		var parseErr *gojq.ParseError

internal/jsonbuffer/json.go

@@ -0,0 +1,14 @@
+// Package jsonbuffer is a small utility package which helps identify JSON buffers.
+package jsonbuffer
+
+import "regexp"
+
+var jsonBufferRegex = regexp.MustCompile(`^\s*\[?\s*{`)
+
+// IsJSON scans the provided buffer, looking for an open brace indicating this is JSON.
+//
+// While a simple list like ["a", "b", "c"] is still a valid JSON,
+// it does not really concern us when processing complex objects.
+func IsJSON(buf []byte) bool {
+	return jsonBufferRegex.Match(buf)
+}

internal/jsonbuffer/json_test.go

@@ -0,0 +1,136 @@
+package jsonbuffer
+
+import "testing"
+
+func TestIsJSON(t *testing.T) {
+	tests := []struct {
+		name     string
+		input    []byte
+		expected bool
+	}{
+		{
+			name:     "valid json object",
+			input:    []byte(`{"key": "value"}`),
+			expected: true,
+		},
+		{
+			name:     "valid json object with leading whitespace",
+			input:    []byte(`  {"key": "value"}`),
+			expected: true,
+		},
+		{
+			name:     "valid json object with tabs",
+			input:    []byte(`	{"key": "value"}`),
+			expected: true,
+		},
+		{
+			name:     "valid json array of objects",
+			input:    []byte(`[{"key": "value"}]`),
+			expected: true,
+		},
+		{
+			name:     "valid json array of objects with whitespace",
+			input:    []byte(`  [  {"key": "value"}]`),
+			expected: true,
+		},
+		{
+			name:     "valid json array of objects with mixed whitespace",
+			input:    []byte(`	 [ 	{"key": "value"}]`),
+			expected: true,
+		},
+		{
+			name:     "simple json array",
+			input:    []byte(`["a", "b", "c"]`),
+			expected: false,
+		},
+		{
+			name:     "simple json array with whitespace",
+			input:    []byte(`  ["a", "b", "c"]`),
+			expected: false,
+		},
+		{
+			name:     "empty json object",
+			input:    []byte(`{}`),
+			expected: true,
+		},
+		{
+			name:     "empty json array",
+			input:    []byte(`[]`),
+			expected: false,
+		},
+		{
+			name:     "plain text",
+			input:    []byte(`this is not json`),
+			expected: false,
+		},
+		{
+			name:     "empty buffer",
+			input:    []byte(``),
+			expected: false,
+		},
+		{
+			name:     "only whitespace",
+			input:    []byte(`   `),
+			expected: false,
+		},
+		{
+			name:     "json string",
+			input:    []byte(`"hello world"`),
+			expected: false,
+		},
+		{
+			name:     "json number",
+			input:    []byte(`42`),
+			expected: false,
+		},
+		{
+			name:     "json boolean",
+			input:    []byte(`true`),
+			expected: false,
+		},
+		{
+			name:     "json null",
+			input:    []byte(`null`),
+			expected: false,
+		},
+		{
+			name:     "malformed json starting with brace",
+			input:    []byte(`{invalid json`),
+			expected: true,
+		},
+		{
+			name:     "nested json object",
+			input:    []byte(`{"outer": {"inner": "value"}}`),
+			expected: true,
+		},
+		{
+			name:     "complex json object",
+			input:    []byte(`{"name": "test", "items": [{"id": 1}, {"id": 2}]}`),
+			expected: true,
+		},
+		{
+			name:     "array starting with object",
+			input:    []byte(`[{"first": true}, "second", 3]`),
+			expected: true,
+		},
+		{
+			name:     "newlines and spaces",
+			input:    []byte("  \n  \t  {\n  \"key\": \"value\"\n}"),
+			expected: true,
+		},
+		{
+			name:     "newlines before array with object",
+			input:    []byte("  \n  [\n  {\"key\": \"value\"}\n]"),
+			expected: true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result := IsJSON(tt.input)
+			if result != tt.expected {
+				t.Errorf("IsJSON(%q) = %v, expected %v", string(tt.input), result, tt.expected)
+			}
+		})
+	}
+}

internal/printer/flags.go

@@ -1,6 +1,9 @@
 package printer
 
 import (
+	"fmt"
+	"strings"
+
 	"github.com/spf13/cobra"
 
 	"github.com/nobl9/sloctl/internal/csv"
@@ -11,7 +14,7 @@ func (o *Printer) MustRegisterFlags(cmd *cobra.Command) {
 		&o.config.OutputFormat,
 		"output",
 		"o",
-		`Output format: one of yaml|json|csv.`,
+		fmt.Sprintf("Output format: one of %s.", strings.Join(validFormatStrings, "|")),
 	)
 
 	cmd.PersistentFlags().StringVarP(

internal/printer/printer.go

@@ -5,6 +5,7 @@ import (
 	"fmt"
 	"io"
 	"os"
+	"slices"
 
 	"github.com/nobl9/sloctl/internal/csv"
 	"github.com/nobl9/sloctl/internal/jq"
@@ -37,7 +38,7 @@ func NewPrinter(config Config) *Printer {
 
 type Printer struct {
 	config Config
-	jq     *jq.ExpressionRunner
+	jq     jq.ExpressionRunner
 }
 
 func (o *Printer) Print(v any) error {
@@ -69,6 +70,18 @@ func (o *Printer) Print(v any) error {
 	return nil
 }
 
+func (o *Printer) WithOutput(out io.Writer) *Printer {
+	cp := *o
+	cp.config.Output = out
+	return &cp
+}
+
+var validFormatStrings = []string{
+	YAMLFormat.String(),
+	JSONFormat.String(),
+	CSVFormat.String(),
+}
+
 // All supported output formats by [Printer].
 const (
 	YAMLFormat Format = "yaml"
@@ -79,18 +92,16 @@ const (
 // Format represents supported printing outputs.
 type Format string
 
-func (f *Format) String() string {
-	return string(*f)
+func (f Format) String() string {
+	return string(f)
 }
 
 func (f *Format) Set(value string) error {
-	switch value {
-	case "yaml", "json", "csv":
-		*f = Format(value)
-		return nil
-	default:
+	if !slices.Contains(validFormatStrings, value) {
 		return fmt.Errorf("invalid value for Format: %s", value)
 	}
+	*f = Format(value)
+	return nil
 }
 
 func (f *Format) Type() string {

internal/printer/yaml.go

@@ -3,9 +3,10 @@ package printer
 import (
 	"io"
 
-	"github.com/goccy/go-yaml"
 	"github.com/nobl9/nobl9-go/manifest"
 	"github.com/nobl9/nobl9-go/sdk"
+
+	"github.com/nobl9/sloctl/internal/yamlenc"
 )
 
 type yamlPrinter struct {
@@ -17,11 +18,7 @@ func (p *yamlPrinter) Print(content any) error {
 	case []manifest.Object:
 		return sdk.PrintObjects(v, p.out, manifest.ObjectFormatYAML)
 	default:
-		b, err := yaml.Marshal(content)
-		if err != nil {
-			return err
-		}
-		_, err = p.out.Write(b)
-		return err
+		enc := yamlenc.NewEncoder(p.out)
+		return enc.Encode(content)
 	}
 }