@lovrozagar/honey 0.1.0

package/src/cli-go/errors.go

@@ -0,0 +1,57 @@
+// Code generated by honey. DO NOT EDIT.
+package cli
+
+import (
+	"context"
+	"errors"
+	"net"
+)
+
+// ExitFor maps a CLI-level error to a process exit code.
+//
+// Codes:
+//
+//	0  success
+//	1  4xx client error (status < 500)
+//	2  5xx server error (status >= 500)
+//	3  network / transport failure or status == 0
+//	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
+	}
+	if errors.Is(err, context.DeadlineExceeded) || errors.Is(err, context.Canceled) {
+		return 3
+	}
+
+	var netErr net.Error
+	if errors.As(err, &netErr) {
+		return 3
+	}
+
+	var apiErr interface{ StatusCode() int }
+	if errors.As(err, &apiErr) {
+		return exitForStatus(apiErr.StatusCode())
+	}
+
+	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/src/cli-go/multipart.go

@@ -0,0 +1,55 @@
+// Code generated by honey. DO NOT EDIT.
+package cli
+
+import (
+	"bytes"
+	"fmt"
+	"io"
+	"mime/multipart"
+	"os"
+	"path/filepath"
+)
+
+// BuildMultipart assembles a multipart/form-data body.
+//
+// fields are written as plain form fields.
+// files are keyed by form-field-name → absolute-or-relative file path.
+//
+// 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) {
+	var buf bytes.Buffer
+	writer := multipart.NewWriter(&buf)
+
+	for name, val := range fields {
+		if err := writer.WriteField(name, val); err != nil {
+			return nil, "", fmt.Errorf("write field %q: %w", name, err)
+		}
+	}
+
+	for name, path := range files {
+		if path == "" {
+			return nil, "", fmt.Errorf("missing file path for field %q", name)
+		}
+		file, err := os.Open(path)
+		if err != nil {
+			return nil, "", fmt.Errorf("open file %s: %w", path, err)
+		}
+		part, err := writer.CreateFormFile(name, filepath.Base(path))
+		if err != nil {
+			file.Close()
+			return nil, "", fmt.Errorf("create form file %q: %w", name, err)
+		}
+		if _, err := io.Copy(part, file); err != nil {
+			file.Close()
+			return nil, "", fmt.Errorf("copy file %s: %w", path, err)
+		}
+		file.Close()
+	}
+
+	if err := writer.Close(); err != nil {
+		return nil, "", fmt.Errorf("close multipart writer: %w", err)
+	}
+
+	return &buf, writer.FormDataContentType(), nil
+}

package/src/cli-go/output.go

@@ -0,0 +1,109 @@
+// Code generated by honey. DO NOT EDIT.
+package cli
+
+import (
+	"encoding/json"
+	"fmt"
+	"io"
+	"sort"
+	"strings"
+	"text/tabwriter"
+
+	"sigs.k8s.io/yaml"
+)
+
+// 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)
+		fmt.Fprintln(tw, strings.Join(keys, "\t"))
+		for _, row := range rows {
+			cols := make([]string, len(keys))
+			for i, k := range keys {
+				cols[i] = fmt.Sprintf("%v", 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%v\n", k, v[k])
+		}
+		return tw.Flush()
+	default:
+		_, err := fmt.Fprintln(w, 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/src/cli-go/root.go

@@ -0,0 +1,30 @@
+// 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)")
+	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/src/cli-go/stream.go

@@ -0,0 +1,88 @@
+// 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/src/cli-go/version.go

@@ -0,0 +1,5 @@
+// Code generated by honey. DO NOT EDIT.
+package cli
+
+// Version is overridable at build time via -ldflags.
+const Version = "dev"

package/src/cli.ts

@@ -0,0 +1,204 @@
+#!/usr/bin/env bun
+import { existsSync, statSync, watch } from "node:fs"
+import { dirname, resolve } from "node:path"
+import { parseInitFlags, runInit } from "./init.ts"
+import type { HoneyGoCliConfig, HoneyVitePluginConfig } from "./plugin.ts"
+import { generateAndWrite, type getLastHoneyConfig, resolveHoneyConfig } from "./plugin.ts"
+
+const USAGE =
+	"Usage: honey generate [--watch] [--config <path>] [--app <path>] [flags]\n" +
+	"       honey init [--cf] [--force]"
+
+type CliFlags = {
+	app?: string
+	cli?: boolean
+	cliBinaryName?: string
+	cliConfigName?: string
+	cliDefaultBaseUrl?: string
+	cliEnvPrefix?: string
+	cliModulePath?: string
+	cliOut?: string
+	cliSdkModulePath?: string
+	config?: string
+	manifest?: boolean
+	mergeTree?: string
+	sdk?: boolean
+	tree?: boolean
+	types?: boolean
+	watch?: boolean
+}
+
+const BOOLEAN_FLAGS = new Set(["cli", "manifest", "sdk", "tree", "types", "watch"])
+
+function parseArgs(args: string[]): CliFlags {
+	const parsed: Record<string, string> = {}
+	for (let i = 0; i < args.length; i++) {
+		const arg = args[i]
+		if (!arg.startsWith("--")) continue
+		const key = arg.slice(2)
+		if (BOOLEAN_FLAGS.has(key)) {
+			parsed[key] = "true"
+		} else if (i + 1 < args.length) {
+			parsed[key] = args[i + 1]
+			i++
+		}
+	}
+
+	return {
+		app: parsed.app,
+		cli: parsed.cli !== undefined,
+		cliBinaryName: parsed["cli-binary-name"],
+		cliConfigName: parsed["cli-config-name"],
+		cliDefaultBaseUrl: parsed["cli-default-base-url"],
+		cliEnvPrefix: parsed["cli-env-prefix"],
+		cliModulePath: parsed["cli-module-path"],
+		cliOut: parsed["cli-out"],
+		cliSdkModulePath: parsed["cli-sdk-module-path"],
+		config: parsed.config,
+		manifest: parsed.manifest !== undefined,
+		mergeTree: parsed["merge-tree"],
+		sdk: parsed.sdk !== undefined,
+		tree: parsed.tree !== undefined,
+		types: parsed.types !== undefined,
+		watch: parsed.watch !== undefined,
+	}
+}
+
+async function loadConfigFromVite(configPath: string): Promise<HoneyVitePluginConfig | undefined> {
+	if (!existsSync(configPath)) return undefined
+
+	const { createJiti } = await import("jiti")
+	const jiti = createJiti(configPath, { fsCache: false, interopDefault: true, moduleCache: false })
+
+	/* importing the config executes honey() which stashes config */
+	await jiti.import(configPath)
+
+	/* read stashed config from the same module graph */
+	const pluginMod = (await jiti.import("honey/plugin")) as Record<string, unknown>
+	const getter = pluginMod.getLastHoneyConfig as typeof getLastHoneyConfig | undefined
+	return getter?.()
+}
+
+function applyCodegenFlags(target: HoneyVitePluginConfig, flags: CliFlags): void {
+	if (!target.codegen) target.codegen = {}
+	const cg = target.codegen
+	if (flags.mergeTree) cg.mergeTree = flags.mergeTree
+	if (flags.manifest) cg.manifest = true
+	if (flags.sdk) cg.sdk = true
+	if (flags.tree) cg.tree = true
+	if (flags.types) cg.types = true
+	const cliOverride = buildCliConfigFromFlags(flags)
+	if (cliOverride) cg.cli = cliOverride
+}
+
+function mergeCliOverrides(base: HoneyVitePluginConfig, flags: CliFlags): HoneyVitePluginConfig {
+	const merged = { ...base }
+	if (flags.app) merged.app = flags.app
+	applyCodegenFlags(merged, flags)
+	return merged
+}
+
+function buildCliConfigFromFlags(flags: CliFlags): HoneyGoCliConfig | undefined {
+	if (!flags.cli && !flags.cliOut && !flags.cliBinaryName) return undefined
+	if (!flags.cliOut || !flags.cliBinaryName) {
+		throw new Error("--cli requires --cli-out and --cli-binary-name")
+	}
+	return {
+		binaryName: flags.cliBinaryName,
+		configName: flags.cliConfigName,
+		defaultBaseURL: flags.cliDefaultBaseUrl,
+		envPrefix: flags.cliEnvPrefix,
+		modulePath: flags.cliModulePath,
+		out: flags.cliOut,
+		sdkModulePath: flags.cliSdkModulePath,
+	}
+}
+
+function configFromFlags(flags: CliFlags): HoneyVitePluginConfig | undefined {
+	if (!flags.app) return undefined
+	const config: HoneyVitePluginConfig = { app: flags.app }
+	applyCodegenFlags(config, flags)
+	return config
+}
+
+const GEN_IGNORE_RE = /(_gen[/\\]|\.gen\.(tsx?|json|d\.ts)$)/
+
+async function main() {
+	const args = process.argv.slice(2)
+	const command = args[0]
+
+	if (command === "init") {
+		runInit(process.cwd(), parseInitFlags(args.slice(1)))
+		return
+	}
+
+	if (command !== "generate") {
+		console.error(USAGE)
+		process.exit(1)
+	}
+
+	const flags = parseArgs(args.slice(1))
+	const cwd = process.cwd()
+
+	/* resolve config: vite.config.ts → CLI flags fallback */
+	const configPath = resolve(cwd, flags.config ?? "vite.config.ts")
+	let rawConfig: HoneyVitePluginConfig | undefined
+
+	const viteConfig = await loadConfigFromVite(configPath)
+	if (viteConfig) {
+		rawConfig = mergeCliOverrides(viteConfig, flags)
+	} else {
+		rawConfig = configFromFlags(flags)
+	}
+
+	if (!rawConfig) {
+		console.error("No config found. Provide a vite.config.ts with honey() or use --app flag.")
+		process.exit(1)
+	}
+
+	const resolved = resolveHoneyConfig(rawConfig)
+
+	async function generate(): Promise<void> {
+		try {
+			await generateAndWrite(resolved, cwd)
+			console.log("honey: generated")
+		} catch (err) {
+			console.error("honey: generation failed", err)
+			if (!flags.watch) process.exit(1)
+		}
+	}
+
+	await generate()
+
+	if (flags.watch) {
+		if (!resolved.app) throw new Error("watch mode requires --app or a vite honey() config")
+		const appAbs = resolve(cwd, resolved.app)
+		const srcDir = dirname(appAbs)
+		let debounceTimer: ReturnType<typeof setTimeout> | undefined
+		let lastMtime = existsSync(appAbs) ? statSync(appAbs).mtimeMs : 0
+
+		const schedule = (): void => {
+			clearTimeout(debounceTimer)
+			debounceTimer = setTimeout(() => generate(), 100)
+		}
+
+		console.log(`honey: watching ${srcDir}`)
+		watch(srcDir, { recursive: true }, (_event, filename) => {
+			if (!filename || GEN_IGNORE_RE.test(String(filename))) return
+			schedule()
+		})
+		watch(appAbs, schedule)
+		setInterval(() => {
+			if (!existsSync(appAbs)) return
+			const mtime = statSync(appAbs).mtimeMs
+			if (mtime === lastMtime) return
+			lastMtime = mtime
+			schedule()
+		}, 250)
+	}
+}
+
+main().catch((err) => {
+	console.error(err)
+	process.exit(1)
+})

package/src/client/error.ts

@@ -0,0 +1,27 @@
+export type ClientErrorInit<TBody = unknown> = {
+	body: TBody
+	message: string
+	response: Response
+	status: number
+}
+
+export class ClientError<TBody = unknown> extends Error {
+	readonly body: TBody
+	readonly response: Response
+	readonly status: number
+
+	constructor(init: ClientErrorInit<TBody>) {
+		super(init.message)
+		if (typeof Error.captureStackTrace === "function") {
+			Error.captureStackTrace(this, ClientError)
+		}
+		this.name = "ClientError"
+		this.body = init.body
+		this.response = init.response
+		this.status = init.status
+	}
+}
+
+export function isClientError<T = unknown>(e: unknown): e is ClientError<T> {
+	return e instanceof ClientError
+}