@shipdit/cli 0.4.1 → 0.5.0

package/README.md

@@ -12,3 +12,24 @@ shipd types gen
 ```
 
 `shipd login` stores a scoped management API key. Use `SHIPD_API_KEY` for CI — keys carry org/project/environment metadata.
+
+## Go projects
+
+The CLI reads `shipd.config.go` directly. Declare an exported
+`var Config = config.ShipdConfig{...}` using
+`github.com/alasti-company/useshipd.com/sdks/go/config`. Go 1.23+ and Node.js 22.12+
+are needed for CLI commands; the application runtime only needs Go.
+
+```bash
+shipd diff
+shipd push
+shipd types gen
+shipd pull
+```
+
+Go input automatically selects Go output in `internal/flags/flags_gen.go`.
+Generation emits per-flag accessors, key and variant constants, and `Defaults()`.
+Pull writes Go definitions back to `shipd.config.go`. No JSON flag file is needed.
+The definition file is evaluated on its own inside the Go module: imports and
+helpers declared in that file work; sibling files are not loaded. Do not define
+`main` in it. See `examples/go-examples` for a complete example.

package/dist/index.mjs

@@ -5,7 +5,27 @@ import os from "node:os";
 import path from "node:path";
 import { z } from "zod";
 import { createJiti } from "jiti";
+import { spawn } from "node:child_process";
 
+//#region src/lib/errors.ts
+var CliError = class extends Error {
+	code;
+	exitCode;
+	details;
+	constructor(code, message, options) {
+		super(message);
+		this.name = "CliError";
+		this.code = code;
+		this.exitCode = options?.exitCode ?? 1;
+		this.details = options?.details;
+	}
+};
+function exitCodeForError(error) {
+	if (error instanceof CliError) return error.exitCode;
+	return 1;
+}
+
+//#endregion
 //#region src/lib/config.ts
 /** Hosted control plane. Used when no flag, env, project, global, or credential URL is set. */
 const DEFAULT_API_URL = "https://api.useshipd.com";
@@ -44,7 +64,7 @@ function clearCredentials() {
 function findProjectRoot(start = process.cwd()) {
 	let current = path.resolve(start);
 	while (true) {
-		if (fs.existsSync(path.join(current, "shipd.config.ts")) || fs.existsSync(path.join(current, ".shipd", "config.json"))) return current;
+		if (fs.existsSync(path.join(current, "shipd.config.ts")) || fs.existsSync(path.join(current, "shipd.config.go")) || fs.existsSync(path.join(current, "shipd.config.json")) || fs.existsSync(path.join(current, ".shipd", "config.json"))) return current;
 		const parent = path.dirname(current);
 		if (parent === current) return process.cwd();
 		current = parent;
@@ -60,7 +80,14 @@ function resolveRuntimeConfig(flags, options) {
 	const globalConfig = loadGlobalConfig();
 	const credentials = loadCredentials();
 	const ci = flags.ci === true || flags.yes === true || process.env.CI === "1" || process.env.CI === "true" || process.env.SHIPD_CI === "1";
-	const defaultConfigFile = fs.existsSync(path.join(projectRoot, "shipd.config.ts")) ? path.join(projectRoot, "shipd.config.ts") : path.join(cwd, "shipd.config.ts");
+	const defaultConfigFile = path.join(projectRoot, [
+		"shipd.config.ts",
+		"shipd.config.go",
+		"shipd.config.json"
+	].find((file) => fs.existsSync(path.join(projectRoot, file))) ?? "shipd.config.ts");
+	const configFile = flags.flagsConfig ? path.resolve(flags.flagsConfig) : projectConfig.configFile ?? defaultConfigFile;
+	const typesLanguage = projectConfig.typesLanguage ?? (path.extname(configFile) === ".go" ? "go" : "typescript");
+	if (typesLanguage !== "typescript" && typesLanguage !== "go") throw new CliError("validation_error", "typesLanguage must be typescript or go");
 	return {
 		apiUrl: flags.apiUrl ?? process.env.SHIPD_API_URL ?? projectConfig.apiUrl ?? globalConfig.apiUrl ?? credentials.apiUrl ?? options?.defaultApiUrl ?? "https://api.useshipd.com",
 		appUrl: process.env.SHIPD_APP_URL ?? projectConfig.appUrl ?? globalConfig.appUrl ?? "http://localhost:5173",
@@ -68,8 +95,10 @@ function resolveRuntimeConfig(flags, options) {
 		org: flags.org ?? process.env.SHIPD_ORG ?? projectConfig.org ?? globalConfig.org,
 		project: flags.project ?? process.env.SHIPD_PROJECT ?? projectConfig.project ?? globalConfig.project,
 		env: flags.env ?? process.env.SHIPD_ENV ?? projectConfig.env ?? globalConfig.env,
-		configFile: flags.flagsConfig ? path.resolve(flags.flagsConfig) : projectConfig.configFile ?? defaultConfigFile,
-		typesOut: projectConfig.typesOut ?? "src/generated/flags.ts",
+		configFile,
+		typesOut: projectConfig.typesOut ?? (typesLanguage === "go" ? "internal/flags/flags_gen.go" : "src/generated/flags.ts"),
+		typesLanguage,
+		typesPackage: projectConfig.typesPackage ?? "flags",
 		yes: ci,
 		json: flags.json === true,
 		cwd,
@@ -4200,25 +4229,6 @@ const f$1 = (e) => createAuthClient({
 	plugins: d$1(e)
 });
 
-//#endregion
-//#region src/lib/errors.ts
-var CliError = class extends Error {
-	code;
-	exitCode;
-	details;
-	constructor(code, message, options) {
-		super(message);
-		this.name = "CliError";
-		this.code = code;
-		this.exitCode = options?.exitCode ?? 1;
-		this.details = options?.details;
-	}
-};
-function exitCodeForError(error) {
-	if (error instanceof CliError) return error.exitCode;
-	return 1;
-}
-
 //#endregion
 //#region src/lib/client.ts
 const AUTH_BASE_PATH = "/api/v1/auth";
@@ -4621,6 +4631,7 @@ const w = z.object({
 	});
 });
 const T = z.object({
+	expectedVersion: z.number().int().positive().optional(),
 	flagId: z.string().min(1),
 	key: o.optional(),
 	name: z.string().min(1).optional(),
@@ -4633,6 +4644,7 @@ const E = z.object({ flagId: z.string().min(1) });
 const D = z.object({ projectId: z.string().min(1) });
 const O = z.object({ flagId: z.string().min(1) });
 const k = z.object({
+	expectedVersion: z.number().int().positive().optional(),
 	flagId: z.string().min(1),
 	environmentId: z.string().min(1),
 	enabled: z.boolean().optional(),
@@ -4640,6 +4652,7 @@ const k = z.object({
 	fallthrough: u.optional()
 });
 const A = z.object({
+	expectedVersion: z.number().int().positive().optional(),
 	flagId: z.string().min(1),
 	environmentId: z.string().min(1),
 	enabled: z.boolean()
@@ -4785,6 +4798,188 @@ const J = z.object({
 	approvalRequests: z.array(z.string()).default([])
 });
 
+//#endregion
+//#region src/lib/go-string.ts
+/** Go strings cannot represent JavaScript's unpaired UTF-16 surrogates. */
+function goString(value) {
+	for (const character of value) {
+		const code = character.charCodeAt(0);
+		if (character.length === 1 && code >= 55296 && code <= 57343) throw new CliError("validation_error", `Cannot generate Go for a string containing an unpaired Unicode surrogate: ${JSON.stringify(value)}`);
+	}
+	return JSON.stringify(value);
+}
+
+//#endregion
+//#region src/lib/go-config.ts
+/** Read the package clause after leading whitespace and comments, not comment text. */
+function goPackageClause(source) {
+	let offset = 0;
+	const skipTrivia = () => {
+		while (offset < source.length) {
+			const trivia = /^(?:\s+|\/\/[^\n]*(?:\n|$)|\/\*[\s\S]*?\*\/)/u.exec(source.slice(offset));
+			if (!trivia) break;
+			offset += trivia[0].length;
+		}
+	};
+	skipTrivia();
+	if (!/^package\b/u.test(source.slice(offset))) throw new Error("Go config must have a package declaration");
+	offset += 7;
+	skipTrivia();
+	const name = /^[_\p{L}][_\p{L}\p{Nd}]*/u.exec(source.slice(offset))?.[0];
+	if (!name) throw new Error("Go config must have a package name");
+	return {
+		name,
+		start: offset,
+		end: offset + name.length
+	};
+}
+/** Evaluate a self-contained Go definition file within its own module. */
+async function loadGoConfig(file) {
+	const source = fs.readFileSync(file, "utf8");
+	const clause = goPackageClause(source);
+	const directory = fs.mkdtempSync(path.join(path.dirname(file), ".shipd-go-"));
+	const cleanup = () => fs.rmSync(directory, {
+		recursive: true,
+		force: true
+	});
+	process.once("exit", cleanup);
+	let interrupted;
+	let terminate;
+	const interrupt = () => {
+		interrupted = 130;
+		terminate?.();
+	};
+	const shutdown = () => {
+		interrupted = 143;
+		terminate?.();
+	};
+	process.once("SIGINT", interrupt);
+	process.once("SIGTERM", shutdown);
+	try {
+		fs.writeFileSync(path.join(directory, ".gitignore"), "*\n");
+		fs.writeFileSync(path.join(directory, "definitions.go"), source.slice(0, clause.start) + "main" + source.slice(clause.end));
+		fs.writeFileSync(path.join(directory, "main.go"), `package main
+import (
+  "encoding/json"
+  "fmt"
+  "os"
+)
+func main() {
+  file, err := os.Create(os.Args[1])
+  if err == nil {
+    err = json.NewEncoder(file).Encode(Config)
+    if closeErr := file.Close(); err == nil { err = closeErr }
+  }
+  if err != nil { fmt.Fprintln(os.Stderr, err); os.Exit(1) }
+}
+`);
+		const output = path.join(directory, "config.json");
+		try {
+			await new Promise((resolve, reject) => {
+				const grouped = process.platform !== "win32";
+				const child = spawn("go", [
+					"run",
+					".",
+					output
+				], {
+					cwd: directory,
+					detached: grouped,
+					stdio: [
+						"ignore",
+						"ignore",
+						"pipe"
+					]
+				});
+				let stderr = "";
+				let failure;
+				const kill = (signal) => {
+					if (!child.pid) return;
+					try {
+						if (grouped) process.kill(-child.pid, signal);
+						else child.kill(signal);
+					} catch (error) {
+						if (error.code !== "ESRCH") throw error;
+					}
+				};
+				let killTimer;
+				terminate = () => {
+					kill("SIGTERM");
+					killTimer = setTimeout(() => kill("SIGKILL"), 1e3);
+				};
+				const timer = setTimeout(() => {
+					failure = /* @__PURE__ */ new Error("Go config evaluation timed out");
+					kill("SIGKILL");
+				}, 12e4);
+				child.stderr.on("data", (chunk) => {
+					stderr += chunk.toString();
+					if (stderr.length > 8388608) {
+						failure = /* @__PURE__ */ new Error("Go compiler output exceeds 8 MiB");
+						kill("SIGKILL");
+					}
+				});
+				child.once("error", (error) => {
+					failure = error;
+				});
+				child.once("close", (code) => {
+					clearTimeout(timer);
+					clearTimeout(killTimer);
+					terminate = void 0;
+					if (failure || code !== 0) reject(Object.assign(failure ?? /* @__PURE__ */ new Error(`go run exited with code ${code}`), { stderr }));
+					else resolve();
+				});
+			});
+		} catch (error) {
+			throw goRunError(error, path.basename(file));
+		}
+		return JSON.parse(fs.readFileSync(output, "utf8"));
+	} finally {
+		process.removeListener("SIGINT", interrupt);
+		process.removeListener("SIGTERM", shutdown);
+		process.removeListener("exit", cleanup);
+		cleanup();
+		if (interrupted !== void 0) process.exit(interrupted);
+	}
+}
+function goRunError(error, configName) {
+	if (error.code === "ENOENT") return /* @__PURE__ */ new Error("Go 1.23+ is required to load Go flag definitions, but `go` was not found on PATH. Install Go from https://go.dev/dl and try again.");
+	const stderr = String(error.stderr ?? "").replace(/(?:\.\/)?definitions\.go/g, configName).trim();
+	const hint = /\bundefined:/.test(stderr) ? `\n${configName} must be self-contained: the CLI compiles only this file, not sibling Go files. Move helper declarations into it or import them from another package.` : "";
+	return new Error(stderr ? `go run failed:\n${stderr}${hint}` : String(error));
+}
+function goNumber(value) {
+	const literal = JSON.stringify(value);
+	return Number.isSafeInteger(value) || /[.eE]/.test(literal) ? literal : `${literal}.0`;
+}
+function goValue(value) {
+	if (value === null) return "nil";
+	if (typeof value === "number") return goNumber(value);
+	if (typeof value === "string") return goString(value);
+	if (Array.isArray(value)) return `[]any{${value.map(goValue).join(", ")}}`;
+	if (typeof value === "object") return `map[string]any{${Object.entries(value).map(([key, entry]) => `${goString(key)}: ${goValue(entry)}`).join(", ")}}`;
+	return JSON.stringify(value);
+}
+/** Emits gofmt-clean Go: one block per flag, field values aligned as gofmt does. */
+function generateGoConfigSource(flags, packageName = "main") {
+	const entries = flags.map((flag) => {
+		const fields = [["Type", goString(flag.type)], ["Default", goValue(flag.default)]];
+		if (flag.variants) fields.push(["Variants", `[]string{${flag.variants.map((v) => goString(v)).join(", ")}}`]);
+		if (flag.description !== void 0) fields.push(["Description", goString(flag.description)]);
+		if (flag.tags.length) fields.push(["Tags", `[]string{${flag.tags.map((v) => goString(v)).join(", ")}}`]);
+		if (flag.lifecycle === "deprecated") fields.push(["Deprecated", "true"]);
+		if (flag.disabled) fields.push(["Disabled", "true"]);
+		const width = Math.max(...fields.map(([name]) => name.length)) + 1;
+		const lines = fields.map(([name, value]) => `\t\t${`${name}:`.padEnd(width)} ${value},`);
+		return `\t${goString(flag.key)}: {\n${lines.join("\n")}\n\t},`;
+	});
+	return `// Generated by shipd pull. Pull replaces this file; review changes before committing.
+package ${packageName}
+
+import "github.com/alasti-company/useshipd.com/sdks/go/config"
+
+var Config = config.ShipdConfig${entries.length ? `{\n${entries.join("\n")}\n}` : "{}"}
+`;
+}
+
 //#endregion
 //#region src/lib/local-config.ts
 const localFlagsArraySchema = z.array(R).superRefine((flags, ctx) => {
@@ -4801,23 +4996,32 @@ const localFlagsArraySchema = z.array(R).superRefine((flags, ctx) => {
 async function loadLocalFlags(configFile) {
 	const absolute = path.resolve(configFile);
 	if (!fs.existsSync(absolute)) throw new CliError("not_found", `Config file not found: ${absolute}`);
-	const jiti = createJiti(import.meta.url, { interopDefault: true });
-	let loaded;
+	let config;
 	try {
-		loaded = await jiti.import(absolute);
+		if (path.extname(absolute) === ".json") {
+			config = JSON.parse(fs.readFileSync(absolute, "utf8"));
+			if (config?.version !== 1) throw new Error("JSON flag config must have version: 1");
+		} else if (path.extname(absolute) === ".go") config = await loadGoConfig(absolute);
+		else {
+			const loaded = await createJiti(import.meta.url, { interopDefault: true }).import(absolute);
+			config = loaded.default ?? loaded;
+		}
 	} catch (error) {
 		const message = error instanceof Error ? error.message : String(error);
 		throw new CliError("validation_error", `Failed to load config ${absolute}: ${message}`);
 	}
-	const config = loaded.default ?? loaded;
-	if (!config.flags || typeof config.flags !== "object") throw new CliError("validation_error", "shipd.config.ts must export defineFlags(...) result");
+	if (!config?.flags || typeof config.flags !== "object" || Array.isArray(config.flags)) throw new CliError("validation_error", "Flag config must contain a flags object (defineFlags result or version-1 JSON)");
+	for (const [key, flag] of Object.entries(config.flags)) {
+		if (!flag || typeof flag !== "object" || Array.isArray(flag)) throw new CliError("validation_error", `Invalid definition for flag ${JSON.stringify(key)}`);
+		if ("deprecated" in flag && typeof flag.deprecated !== "boolean") throw new CliError("validation_error", `Flag ${JSON.stringify(key)} deprecated must be a boolean`);
+	}
 	const candidates = Object.entries(config.flags).map(([key, flag]) => ({
 		key,
 		type: flag.type,
 		default: flag.default,
 		description: flag.description,
 		tags: flag.tags ?? [],
-		lifecycle: flag.lifecycle ?? "active",
+		lifecycle: flag.lifecycle ?? (flag.deprecated === true ? "deprecated" : "active"),
 		variants: flag.variants,
 		disabled: flag.disabled
 	}));
@@ -4904,6 +5108,14 @@ function serializeTypeLiteral(value) {
 	if (value === null) return "null";
 	return JSON.stringify(value);
 }
+/** Pull preserves JSON config workflows rather than introducing a TS dependency. */
+function generateJSONConfigSource(flags) {
+	const entries = flags.map(({ key, ...definition }) => [key, definition]);
+	return `${JSON.stringify({
+		version: 1,
+		flags: Object.fromEntries(entries)
+	}, null, 2)}\n`;
+}
 
 //#endregion
 //#region src/lib/plan.ts
@@ -5166,24 +5378,100 @@ function registerProjectsCommands(program) {
 	});
 }
 
+//#endregion
+//#region src/lib/go-typegen.ts
+const GO_KEYWORDS = new Set("break default func interface select case defer go map struct chan else goto package switch const fallthrough if range type continue for import return var".split(" "));
+function goName(value) {
+	let name = (value.normalize("NFC").match(/[\p{L}\p{Nd}]+/gu) ?? []).map((word) => word[0].toUpperCase() + word.slice(1)).join("");
+	if (!/^\p{Lu}/u.test(name)) name = `Flag${name}`;
+	return name;
+}
+function generateGoTypesSource(flags, packageName = "flags") {
+	if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(packageName) || packageName === "_" || GO_KEYWORDS.has(packageName)) throw new CliError("validation_error", `Invalid Go package name ${JSON.stringify(packageName)}`);
+	const used = /* @__PURE__ */ new Set(["Defaults"]);
+	const claim = (name, key) => {
+		if (used.has(name)) throw new CliError("validation_error", `Go identifier ${name} collides for flag ${JSON.stringify(key)}; rename the flag or variant`);
+		used.add(name);
+		return name;
+	};
+	const declarations = flags.map((flag) => {
+		const name = claim(goName(flag.key), flag.key);
+		const keyName = claim(`${name}Key`, flag.key);
+		const lines = [`const ${keyName} = ${goString(flag.key)}`];
+		let returnType;
+		let expression;
+		switch (flag.type) {
+			case "boolean":
+				returnType = "bool";
+				expression = `client.IsEnabled(${keyName}, context)`;
+				break;
+			case "number":
+				returnType = "float64";
+				expression = `client.GetNumber(${keyName}, context)`;
+				break;
+			case "json":
+				returnType = "any";
+				expression = `client.GetJSON(${keyName}, context)`;
+				break;
+			case "variant":
+				returnType = claim(`${name}Variant`, flag.key);
+				lines.push(`type ${returnType} string`);
+				for (const variant of flag.variants ?? []) {
+					const constant = claim(`${name}${goName(variant)}`, flag.key);
+					lines.push(`const ${constant} ${returnType} = ${goString(variant)}`);
+				}
+				expression = `${returnType}(client.GetVariant(${keyName}, context))`;
+		}
+		lines.push(`func ${name}(client *shipd.Client, context shipd.EvaluationContext) ${returnType} {\n\treturn ${expression}\n}`);
+		return lines.join("\n\n");
+	}).join("\n\n");
+	const defaults = Object.fromEntries(flags.map((flag) => [flag.key, flag.default]));
+	return `// Code generated by shipd types gen --language go; DO NOT EDIT.
+package ${packageName}
+
+import (
+\t"encoding/json"
+${flags.length ? "	shipd \"github.com/alasti-company/useshipd.com/sdks/go\"\n" : ""})
+
+// Defaults returns a fresh map of the config's defaults for shipd.Options.
+func Defaults() map[string]any {
+\tvar defaults map[string]any
+\t_ = json.Unmarshal([]byte(${JSON.stringify(JSON.stringify(defaults))}), &defaults)
+\treturn defaults
+}
+
+${declarations}
+`.trimEnd() + "\n";
+}
+
 //#endregion
 //#region src/lib/typegen.ts
-async function runTypegen(runtime, outPath = runtime.typesOut) {
-	const flags = await loadLocalFlags(runtime.configFile);
+async function runTypegen(runtime, outPath = runtime.typesOut, options = {}) {
+	return writeTypegen(prepareTypegen(runtime, await loadLocalFlags(runtime.configFile), outPath, options));
+}
+function prepareTypegen(runtime, flags, outPath = runtime.typesOut, options = {}) {
 	const absolute = path.resolve(outPath);
-	const source = generateTypesSource(flags);
-	fs.mkdirSync(path.dirname(absolute), { recursive: true });
-	fs.writeFileSync(absolute, source);
+	const language = options.language ?? runtime.typesLanguage ?? "typescript";
+	if (language !== "go" && language !== "typescript") throw new CliError("validation_error", "Type generation language must be typescript or go");
 	return {
+		source: language === "go" ? generateGoTypesSource(flags, options.packageName ?? runtime.typesPackage ?? "flags") : generateTypesSource(flags),
 		written: absolute,
 		flagCount: flags.length
 	};
 }
+function writeTypegen(prepared) {
+	fs.mkdirSync(path.dirname(prepared.written), { recursive: true });
+	fs.writeFileSync(prepared.written, prepared.source);
+	return {
+		written: prepared.written,
+		flagCount: prepared.flagCount
+	};
+}
 
 //#endregion
 //#region src/commands/pull.ts
 function registerPullCommand(program) {
-	program.command("pull").description("Regenerate shipd.config.ts from the server and run typegen").action(async (_opts, command) => {
+	program.command("pull").description("Regenerate the flag config from the server and run typegen").action(async (_opts, command) => {
 		const runtime = getRuntime(command);
 		const client = await createCliApiClient(runtime);
 		const { projectId, environmentId } = await resolveIds(client, runtime);
@@ -5200,11 +5488,13 @@ function registerPullCommand(program) {
 			variants: flag.variants,
 			disabled: flag.disabled
 		}));
-		const source = generateShipdConfigSource(localFlags);
+		const packageName = path.extname(runtime.configFile) === ".go" && fs.existsSync(runtime.configFile) ? goPackageClause(fs.readFileSync(runtime.configFile, "utf8")).name : "main";
+		const source = path.extname(runtime.configFile) === ".json" ? generateJSONConfigSource(localFlags) : path.extname(runtime.configFile) === ".go" ? generateGoConfigSource(localFlags, packageName) : generateShipdConfigSource(localFlags);
+		const preparedTypes = prepareTypegen(runtime, localFlags);
 		const outPath = path.resolve(runtime.configFile);
 		fs.mkdirSync(path.dirname(outPath), { recursive: true });
 		fs.writeFileSync(outPath, source);
-		const types = await runTypegen(runtime);
+		const types = writeTypegen(preparedTypes);
 		printResult(runtime, {
 			written: outPath,
 			flagCount: localFlags.length,
@@ -5259,6 +5549,7 @@ function registerPushCommand(program) {
 		}
 		if (planHasDefinitionChanges(plan) && !runtime.json) console.error("Note: definition/ownership changes apply to all environments (requires production permission).");
 		if (!await confirm(runtime, "Apply this plan?")) throw new CliError("validation_error", "Push cancelled (pass --yes or --ci to apply non-interactively)");
+		const preparedTypes = prepareTypegen(runtime, localFlags);
 		const expectedVersions = expectedVersionsFromChanges(planned.changes);
 		const applied = await client.flag.push({
 			projectId,
@@ -5271,7 +5562,7 @@ function registerPushCommand(program) {
 			expectedVersions
 		}).catch(mapApiError);
 		const appliedPlan = buildSyncPlan(applied.changes);
-		const types = await runTypegen(runtime);
+		const types = writeTypegen(preparedTypes);
 		const approvalRequests = applied.approvalRequests ?? [];
 		printResult(runtime, {
 			plan: appliedPlan,
@@ -5366,9 +5657,14 @@ function registerSnapshotsCommands(program) {
 //#endregion
 //#region src/commands/types.ts
 function registerTypesCommands(program) {
-	program.command("types").description("Type generation helpers").command("gen").description("Generate TypeScript types from shipd.config.ts").option("-o, --out <path>", "Output file path").action(async (opts, command) => {
+	program.command("types").description("Type generation helpers").command("gen").description("Generate TypeScript types or Go accessors from the local flag config").addOption(new Option("--language <language>", "Output language").choices(["typescript", "go"])).option("--package <name>", "Go package name (default: flags)").option("-o, --out <path>", "Output file path").action(async (opts, command) => {
 		const runtime = getRuntime(command);
-		const result = await runTypegen(runtime, opts.out ?? runtime.typesOut);
+		const language = opts.language ?? runtime.typesLanguage ?? "typescript";
+		const defaultOutput = language === (runtime.typesLanguage ?? "typescript") ? runtime.typesOut : language === "go" ? "internal/flags/flags_gen.go" : "src/generated/flags.ts";
+		const result = await runTypegen(runtime, opts.out ?? defaultOutput, {
+			language,
+			packageName: opts.package
+		});
 		printResult(runtime, result, `Wrote types for ${result.flagCount} flag(s) to ${result.written}`);
 	});
 }
@@ -5377,7 +5673,7 @@ function registerTypesCommands(program) {
 //#region src/index.ts
 /** Detected before parse so usage errors can suppress Commander text under `--json`. */
 const jsonRequested = process.argv.includes("--json");
-const program = new Command().name("shipd").description("shipd CLI — flags as code").option("--json", "Machine-readable JSON output", false).option("--yes", "Skip confirmation prompts", false).option("--ci", "Non-interactive mode (same as --yes / CI=1)", false).option("--api-url <url>", `API origin (default: ${DEFAULT_API_URL})`).option("--org <slug>", "Organization slug (session: select; API key: must match)").option("--project <slug>", "Project slug").option("--env <slug>", "Environment slug").option("--config <path>", "Project settings JSON (.shipd/config.json shape)").option("--flags-config <path>", "Path to shipd.config.ts").exitOverride().showHelpAfterError(!jsonRequested);
+const program = new Command().name("shipd").description("shipd CLI — flags as code").option("--json", "Machine-readable JSON output", false).option("--yes", "Skip confirmation prompts", false).option("--ci", "Non-interactive mode (same as --yes / CI=1)", false).option("--api-url <url>", `API origin (default: ${DEFAULT_API_URL})`).option("--org <slug>", "Organization slug (session: select; API key: must match)").option("--project <slug>", "Project slug").option("--env <slug>", "Environment slug").option("--config <path>", "Project settings JSON (.shipd/config.json shape)").option("--flags-config <path>", "Path to shipd.config.ts, shipd.config.go, or shipd.config.json").exitOverride().showHelpAfterError(!jsonRequested);
 if (jsonRequested) program.configureOutput({
 	writeErr: () => {},
 	writeOut: () => {}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shipdit/cli",
-  "version": "0.4.1",
+  "version": "0.5.0",
   "description": "shipd's command-line interface",
   "homepage": "https://docs.useshipd.com",
   "bugs": {
@@ -18,7 +18,7 @@
   "dependencies": {
     "commander": "^15.0.0",
     "jiti": "^2.5.1",
-    "shipdit": "0.3.1",
+    "shipdit": "0.4.0",
     "zod": "^4.6.5"
   },
   "devDependencies": {