@lovrozagar/honey 0.7.2 → 1.0.0-rc.1

package/dist/cli-go/config.go

@@ -1,192 +0,0 @@
-// Code generated by honey. DO NOT EDIT.
-package cli
-
-import (
-	"errors"
-	"fmt"
-	"io"
-	"io/fs"
-	"os"
-	"path/filepath"
-	"runtime"
-
-	"github.com/pelletier/go-toml/v2"
-	"github.com/spf13/pflag"
-)
-
-// Config holds resolved runtime values for the CLI binary.
-//
-// Precedence (high → low) — see LoadConfig below:
-//
-//  1. --api-key / --base-url / --output / … flag set on the command line.
-//  2. Env var: <ENV_PREFIX>_API_KEY / _BASE_URL / _OUTPUT / …
-//  3. Config file from --config, $<ENV_PREFIX>_CONFIG, $XDG_CONFIG_HOME/<name>/config.toml,
-//     $HOME/.config/<name>/config.toml, os.UserConfigDir()/<name>/config.toml.
-//  4. Built-in defaults.
-//  5. (missing api-key → ErrMissingAPIKey, mapped to exit 4).
-type Config struct {
-	APIKey     string
-	BaseURL    string
-	Output     string
-	Timeout    string
-	Verbose    bool
-	ConfigPath string
-}
-
-type tomlConfig struct {
-	APIKey  string `toml:"api_key"`
-	BaseURL string `toml:"base_url"`
-	Output  string `toml:"output"`
-	Timeout string `toml:"timeout"`
-}
-
-// LoadConfig merges flag values, env vars, and a TOML config file into a Config.
-//
-// The resolution order matches the Config doc-comment precedence list.
-func LoadConfig(flags *pflag.FlagSet, envPrefix, configName string) (Config, error) {
-	var cfg Config
-
-	cfgPath := ""
-	explicit := false
-	if flags.Changed("config") {
-		v, _ := flags.GetString("config")
-		cfgPath = v
-		explicit = true
-	} else if v := os.Getenv(envPrefix + "_CONFIG"); v != "" {
-		cfgPath = v
-		explicit = true
-	} else {
-		cfgPath = defaultConfigPath(configName)
-	}
-
-	var fromFile tomlConfig
-	if cfgPath != "" {
-		data, err := os.ReadFile(cfgPath)
-		switch {
-		case err == nil:
-			if err := toml.Unmarshal(data, &fromFile); err != nil {
-				return cfg, Usage(fmt.Errorf("parse config %s: %w", cfgPath, err))
-			}
-			warnIfReadableByOthers(cfgPath, fromFile.APIKey != "")
-		case explicit || !errors.Is(err, fs.ErrNotExist):
-			/* a config the user named must exist; only the default path may be absent */
-			return cfg, Usage(fmt.Errorf("read config %s: %w", cfgPath, err))
-		}
-	}
-	cfg.ConfigPath = cfgPath
-
-	cfg.APIKey = fromFile.APIKey
-	if v := os.Getenv(envPrefix + "_API_KEY"); v != "" {
-		cfg.APIKey = v
-	}
-	if flags.Changed("api-key") {
-		v, _ := flags.GetString("api-key")
-		cfg.APIKey = v
-	}
-
-	cfg.BaseURL = fromFile.BaseURL
-	if v := os.Getenv(envPrefix + "_BASE_URL"); v != "" {
-		cfg.BaseURL = v
-	}
-	if flags.Changed("base-url") {
-		v, _ := flags.GetString("base-url")
-		cfg.BaseURL = v
-	}
-
-	cfg.Output = fromFile.Output
-	if v := os.Getenv(envPrefix + "_OUTPUT"); v != "" {
-		cfg.Output = v
-	}
-	if flags.Changed("output") {
-		v, _ := flags.GetString("output")
-		cfg.Output = v
-	}
-	if cfg.Output == "" {
-		cfg.Output = "json"
-	}
-
-	cfg.Timeout = fromFile.Timeout
-	if v := os.Getenv(envPrefix + "_TIMEOUT"); v != "" {
-		cfg.Timeout = v
-	}
-	if flags.Changed("timeout") {
-		v, _ := flags.GetString("timeout")
-		cfg.Timeout = v
-	}
-	if cfg.Timeout == "" {
-		cfg.Timeout = "30s"
-	}
-
-	if flags.Changed("verbose") {
-		v, _ := flags.GetBool("verbose")
-		cfg.Verbose = v
-	}
-
-	return cfg, nil
-}
-
-// warnIfReadableByOthers warns when a config file holding an API key can be
-// read by group or other users.
-func warnIfReadableByOthers(path string, hasKey bool) {
-	if !hasKey || runtime.GOOS == "windows" {
-		return
-	}
-	info, err := os.Stat(path)
-	if err != nil {
-		return
-	}
-	if info.Mode().Perm()&0o077 != 0 {
-		fmt.Fprintf(os.Stderr, "warning: %s holds an API key and is readable by other users; run: chmod 600 %s\n", path, path)
-	}
-}
-
-func defaultConfigPath(configName string) string {
-	if configName == "" {
-		return ""
-	}
-	if xdg := os.Getenv("XDG_CONFIG_HOME"); xdg != "" {
-		return filepath.Join(xdg, configName, "config.toml")
-	}
-	if home := os.Getenv("HOME"); home != "" {
-		return filepath.Join(home, ".config", configName, "config.toml")
-	}
-	if dir, err := os.UserConfigDir(); err == nil {
-		return filepath.Join(dir, configName, "config.toml")
-	}
-	return ""
-}
-
-// readDataFlag resolves the value of a --data flag into raw bytes.
-//
-// Rules:
-//   - "@path"        → reads file at path.
-//   - "-"            → reads os.Stdin.
-//   - ""             → returns nil, nil (caller decides whether required).
-//   - anything else  → treats val as literal JSON.
-//
-// Exported as ReadDataFlag for use from cmd/*.go.
-func ReadDataFlag(val string) ([]byte, error) {
-	return readDataFlag(val)
-}
-
-func readDataFlag(val string) ([]byte, error) {
-	if val == "" {
-		return nil, nil
-	}
-	if val == "-" {
-		data, err := io.ReadAll(os.Stdin)
-		if err != nil {
-			return nil, fmt.Errorf("read stdin: %w", err)
-		}
-		return data, nil
-	}
-	if val[0] == '@' {
-		path := val[1:]
-		data, err := os.ReadFile(path)
-		if err != nil {
-			return nil, fmt.Errorf("read data file %s: %w", path, err)
-		}
-		return data, nil
-	}
-	return []byte(val), nil
-}

package/dist/cli-go/errors.go

@@ -1,75 +0,0 @@
-// Code generated by honey. DO NOT EDIT.
-package cli
-
-import (
-	"context"
-	"errors"
-	"net"
-)
-
-// UsageError marks bad flags, bad config and invalid input; it maps to exit 4.
-type UsageError struct{ Err error }
-
-func (e *UsageError) Error() string { return e.Err.Error() }
-func (e *UsageError) Unwrap() error { return e.Err }
-
-// Usage wraps err as a UsageError.
-func Usage(err error) error {
-	if err == nil {
-		return nil
-	}
-	return &UsageError{Err: err}
-}
-
-// ExitFor maps a CLI-level error to a process exit code.
-//
-// Codes:
-//
-//	0  success
-//	1  4xx client error
-//	2  5xx server error
-//	3  network / transport failure or timeout
-//	4  bad flags / bad config / missing api key
-//	5  3xx unexpected redirect
-func ExitFor(err error) int {
-	if err == nil {
-		return 0
-	}
-	if errors.Is(err, ErrMissingAPIKey) {
-		return 4
-	}
-	var usage *UsageError
-	if errors.As(err, &usage) {
-		return 4
-	}
-
-	/* SDK errors expose Status() (APIError) */
-	var apiErr interface{ Status() int }
-	if errors.As(err, &apiErr) {
-		return exitForStatus(apiErr.Status())
-	}
-
-	if errors.Is(err, context.DeadlineExceeded) || errors.Is(err, context.Canceled) {
-		return 3
-	}
-	var netErr net.Error
-	if errors.As(err, &netErr) {
-		return 3
-	}
-	return 3
-}
-
-func exitForStatus(status int) int {
-	switch {
-	case status == 0:
-		return 3
-	case status >= 300 && status < 400:
-		return 5
-	case status >= 400 && status < 500:
-		return 1
-	case status >= 500 && status < 600:
-		return 2
-	default:
-		return 1
-	}
-}

package/dist/cli-go/multipart.go

@@ -1,79 +0,0 @@
-// Code generated by honey. DO NOT EDIT.
-package cli
-
-import (
-	"fmt"
-	"io"
-	"mime/multipart"
-	"os"
-	"path/filepath"
-	"sort"
-)
-
-// BuildMultipart streams a multipart/form-data body: files are read as the
-// request is sent, not buffered in memory.
-//
-// fields are written as plain form fields; files are keyed by form-field-name →
-// file path. Every file is opened up front so a bad path fails before sending.
-//
-// Returns the body reader, the Content-Type header value (including boundary),
-// and any error.
-func BuildMultipart(fields map[string]string, files map[string]string) (io.Reader, string, error) {
-	fieldNames := sortedNames(fields)
-	fileNames := sortedNames(files)
-
-	opened := make(map[string]*os.File, len(files))
-	for _, name := range fileNames {
-		path := files[name]
-		if path == "" {
-			closeAll(opened)
-			return nil, "", fmt.Errorf("missing file path for field %q", name)
-		}
-		f, err := os.Open(path)
-		if err != nil {
-			closeAll(opened)
-			return nil, "", Usage(fmt.Errorf("open file %s: %w", path, err))
-		}
-		opened[name] = f
-	}
-
-	pr, pw := io.Pipe()
-	writer := multipart.NewWriter(pw)
-	go func() {
-		defer closeAll(opened)
-		for _, name := range fieldNames {
-			if err := writer.WriteField(name, fields[name]); err != nil {
-				pw.CloseWithError(fmt.Errorf("write field %q: %w", name, err))
-				return
-			}
-		}
-		for _, name := range fileNames {
-			part, err := writer.CreateFormFile(name, filepath.Base(files[name]))
-			if err != nil {
-				pw.CloseWithError(fmt.Errorf("create form file %q: %w", name, err))
-				return
-			}
-			if _, err := io.Copy(part, opened[name]); err != nil {
-				pw.CloseWithError(fmt.Errorf("copy file %s: %w", files[name], err))
-				return
-			}
-		}
-		pw.CloseWithError(writer.Close())
-	}()
-	return pr, writer.FormDataContentType(), nil
-}
-
-func sortedNames(m map[string]string) []string {
-	names := make([]string, 0, len(m))
-	for k := range m {
-		names = append(names, k)
-	}
-	sort.Strings(names)
-	return names
-}
-
-func closeAll(files map[string]*os.File) {
-	for _, f := range files {
-		f.Close()
-	}
-}

package/dist/cli-go/output.go

@@ -1,163 +0,0 @@
-// Code generated by honey. DO NOT EDIT.
-package cli
-
-import (
-	"bytes"
-	"encoding/json"
-	"fmt"
-	"io"
-	"sort"
-	"strings"
-	"text/tabwriter"
-	"unicode"
-
-	"sigs.k8s.io/yaml"
-)
-
-// DecodeJSON decodes a response body keeping numbers exact (json.Number), so a
-// 64-bit id is printed as sent instead of as a rounded float.
-func DecodeJSON(body []byte) (any, error) {
-	if len(body) == 0 {
-		return nil, nil
-	}
-	dec := json.NewDecoder(bytes.NewReader(body))
-	dec.UseNumber()
-	var out any
-	if err := dec.Decode(&out); err != nil {
-		return nil, err
-	}
-	return out, nil
-}
-
-// Sanitize drops control characters (ESC, CR, tabs, …) so server-controlled
-// text cannot drive the terminal or break table layout.
-func Sanitize(s string) string {
-	return strings.Map(func(r rune) rune {
-		if r == '\n' {
-			return ' '
-		}
-		if unicode.IsControl(r) {
-			return -1
-		}
-		return r
-	}, s)
-}
-
-func cell(v any) string {
-	switch t := v.(type) {
-	case nil:
-		return ""
-	case string:
-		return Sanitize(t)
-	case json.Number:
-		return t.String()
-	case map[string]any, []any:
-		enc, err := json.Marshal(t)
-		if err != nil {
-			return Sanitize(fmt.Sprint(t))
-		}
-		return Sanitize(string(enc))
-	default:
-		return Sanitize(fmt.Sprint(t))
-	}
-}
-
-// Emit writes data to w in the requested mode.
-//
-// Supported modes: json (pretty, 2-space indent), ndjson, yaml, table.
-// Unknown modes return an error that ExitFor maps to exit code 4.
-func Emit(data any, mode string, w io.Writer) error {
-	if data == nil {
-		return nil
-	}
-	switch mode {
-	case "", "json":
-		enc, err := json.MarshalIndent(data, "", "  ")
-		if err != nil {
-			return err
-		}
-		_, err = fmt.Fprintln(w, string(enc))
-		return err
-	case "ndjson":
-		enc, err := json.Marshal(data)
-		if err != nil {
-			return err
-		}
-		_, err = fmt.Fprintln(w, string(enc))
-		return err
-	case "yaml":
-		enc, err := yaml.Marshal(data)
-		if err != nil {
-			return err
-		}
-		_, err = w.Write(enc)
-		return err
-	case "table":
-		return printTable(data, w)
-	default:
-		return fmt.Errorf("unknown output mode %q: valid modes are json, ndjson, yaml, table", mode)
-	}
-}
-
-// printTable renders data as an aligned table when possible, or falls back to raw print.
-func printTable(data any, w io.Writer) error {
-	switch v := data.(type) {
-	case []any:
-		if len(v) == 0 {
-			return nil
-		}
-		rows := make([]map[string]any, 0, len(v))
-		for _, row := range v {
-			if m, ok := row.(map[string]any); ok {
-				rows = append(rows, m)
-			} else {
-				fmt.Fprintln(w, row)
-				return nil
-			}
-		}
-		keys := collectKeys(rows)
-		tw := tabwriter.NewWriter(w, 0, 0, 2, ' ', 0)
-		header := make([]string, len(keys))
-		for i, k := range keys {
-			header[i] = Sanitize(k)
-		}
-		fmt.Fprintln(tw, strings.Join(header, "\t"))
-		for _, row := range rows {
-			cols := make([]string, len(keys))
-			for i, k := range keys {
-				cols[i] = cell(row[k])
-			}
-			fmt.Fprintln(tw, strings.Join(cols, "\t"))
-		}
-		return tw.Flush()
-	case map[string]any:
-		keys := make([]string, 0, len(v))
-		for k := range v {
-			keys = append(keys, k)
-		}
-		sort.Strings(keys)
-		tw := tabwriter.NewWriter(w, 0, 0, 2, ' ', 0)
-		for _, k := range keys {
-			fmt.Fprintf(tw, "%s\t%s\n", Sanitize(k), cell(v[k]))
-		}
-		return tw.Flush()
-	default:
-		_, err := fmt.Fprintln(w, cell(data))
-		return err
-	}
-}
-
-func collectKeys(rows []map[string]any) []string {
-	seen := map[string]bool{}
-	keys := []string{}
-	for _, row := range rows {
-		for k := range row {
-			if !seen[k] {
-				seen[k] = true
-				keys = append(keys, k)
-			}
-		}
-	}
-	sort.Strings(keys)
-	return keys
-}

package/dist/cli-go/root.go

@@ -1,30 +0,0 @@
-// Code generated by honey. DO NOT EDIT.
-package cli
-
-import (
-	"github.com/spf13/cobra"
-)
-
-// NewRoot constructs a cobra root command with the standard persistent flags.
-//
-// Flags (all persistent, inherited by subcommands):
-//
-//	--api-key    API key (overrides env + config file)
-//	--base-url   Override API base URL
-//	--output     Output mode: json|ndjson|yaml|table (default json)
-//	--verbose    Print request metadata to stderr
-//	--config     Path to config file
-//	--timeout    Go duration string, e.g. "30s"
-func NewRoot(binaryName, version string) *cobra.Command {
-	root := &cobra.Command{
-		Use:     binaryName,
-		Version: version,
-	}
-	root.PersistentFlags().String("api-key", "", "API key (overrides env + config file; visible to other local users in the process list, prefer the env var)")
-	root.PersistentFlags().String("base-url", "", "Override API base URL")
-	root.PersistentFlags().String("output", "json", "Output mode: json|ndjson|yaml|table")
-	root.PersistentFlags().Bool("verbose", false, "Print request metadata to stderr")
-	root.PersistentFlags().String("config", "", "Path to config file")
-	root.PersistentFlags().String("timeout", "30s", "Request timeout (Go duration)")
-	return root
-}

package/dist/cli-go/stream.go

@@ -1,88 +0,0 @@
-// Code generated by honey. DO NOT EDIT.
-package cli
-
-import (
-	"encoding/json"
-	"fmt"
-	"io"
-	"iter"
-	"os"
-
-	"sigs.k8s.io/yaml"
-)
-
-// SSEEvent is the concrete SSE event type consumed by StreamSSE. The CLI's
-// generated cmd/*.go files wrap the SDK's iterator into a Seq2[SSEEvent, error]
-// before passing it in, so this runtime stays SDK-agnostic. Go generics do not
-// support struct-field access through a type parameter, so this is a plain
-// concrete struct rather than a constrained generic.
-type SSEEvent struct {
-	Data  string
-	Event string
-	ID    string
-	Retry int
-}
-
-// streamEvent is the on-wire shape that gets emitted for each SSE event.
-type streamEvent struct {
-	Event string          `json:"event,omitempty"`
-	ID    string          `json:"id,omitempty"`
-	Data  json.RawMessage `json:"data"`
-	Retry int             `json:"retry,omitempty"`
-}
-
-// StreamSSE consumes an iter.Seq2 of SSE events and writes them to w.
-//
-// --output modes:
-//
-//	ndjson (default for streams) → one JSON object per line.
-//	yaml                         → YAML documents separated by "---\n".
-//	table                        → falls back to ndjson; prints a warning to os.Stderr.
-//	json                         → treated as ndjson (no way to represent a live stream as one object).
-func StreamSSE(it iter.Seq2[SSEEvent, error], w io.Writer, mode string) error {
-	if mode == "table" {
-		fmt.Fprintln(os.Stderr, "warning: --output=table is not supported for streaming endpoints; falling back to ndjson")
-		mode = "ndjson"
-	}
-	for ev, err := range it {
-		if err != nil {
-			return err
-		}
-		out := streamEvent{
-			Event: ev.Event,
-			ID:    ev.ID,
-			Retry: ev.Retry,
-		}
-		if ev.Data == "" {
-			out.Data = json.RawMessage("null")
-		} else if json.Valid([]byte(ev.Data)) {
-			out.Data = json.RawMessage(ev.Data)
-		} else {
-			enc, _ := json.Marshal(ev.Data)
-			out.Data = enc
-		}
-
-		switch mode {
-		case "yaml":
-			enc, err := yaml.Marshal(out)
-			if err != nil {
-				return err
-			}
-			if _, err := w.Write(enc); err != nil {
-				return err
-			}
-			if _, err := fmt.Fprint(w, "---\n"); err != nil {
-				return err
-			}
-		default:
-			enc, err := json.Marshal(out)
-			if err != nil {
-				return err
-			}
-			if _, err := fmt.Fprintln(w, string(enc)); err != nil {
-				return err
-			}
-		}
-	}
-	return nil
-}

package/dist/cli-go/version.go

@@ -1,5 +0,0 @@
-// Code generated by honey. DO NOT EDIT.
-package cli
-
-// Version is set at build time: go build -ldflags "-X <module>/internal/cli.Version=1.2.3".
-var Version = "dev"

package/dist/cli.d.ts

@@ -1,3 +0,0 @@
-#!/usr/bin/env node
-export {};
-//# sourceMappingURL=cli.d.ts.map

package/dist/cli.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":""}