specli 0.0.1 → 0.0.2

package/src/cli/runtime/body-flags.ts

@@ -0,0 +1,176 @@
+/**
+ * Body flag generation and parsing utilities.
+ *
+ * Generates CLI flags from JSON schema properties and parses
+ * dot-notation flags back into nested objects.
+ */
+
+type JsonSchema = {
+	type?: string;
+	properties?: Record<string, JsonSchema>;
+	items?: JsonSchema;
+	required?: string[];
+	description?: string;
+};
+
+export type BodyFlagDef = {
+	flag: string; // e.g. "--name" or "--address.street"
+	path: string[]; // e.g. ["name"] or ["address", "street"]
+	type: "string" | "number" | "integer" | "boolean";
+	description: string;
+	required: boolean;
+};
+
+/**
+ * Generate flag definitions from a JSON schema.
+ * Recursively handles nested objects using dot notation.
+ */
+export function generateBodyFlags(
+	schema: JsonSchema | undefined,
+	reservedFlags: Set<string>,
+): BodyFlagDef[] {
+	if (!schema || schema.type !== "object" || !schema.properties) {
+		return [];
+	}
+
+	const flags: BodyFlagDef[] = [];
+	const requiredSet = new Set(schema.required ?? []);
+
+	collectFlags(schema.properties, [], requiredSet, flags, reservedFlags);
+
+	return flags;
+}
+
+function collectFlags(
+	properties: Record<string, JsonSchema>,
+	pathPrefix: string[],
+	requiredAtRoot: Set<string>,
+	out: BodyFlagDef[],
+	reservedFlags: Set<string>,
+): void {
+	for (const [name, propSchema] of Object.entries(properties)) {
+		if (!name || typeof name !== "string") continue;
+		if (!propSchema || typeof propSchema !== "object") continue;
+
+		const path = [...pathPrefix, name];
+		const flagName = `--${path.join(".")}`;
+
+		// Skip if this flag would conflict with an operation parameter
+		if (reservedFlags.has(flagName)) continue;
+
+		const t = propSchema.type;
+
+		if (t === "object" && propSchema.properties) {
+			// Recurse into nested object
+			const nestedRequired = new Set(propSchema.required ?? []);
+			collectFlags(
+				propSchema.properties,
+				path,
+				nestedRequired,
+				out,
+				reservedFlags,
+			);
+		} else if (
+			t === "string" ||
+			t === "number" ||
+			t === "integer" ||
+			t === "boolean"
+		) {
+			// Leaf property - generate a flag
+			const isRequired =
+				pathPrefix.length === 0 ? requiredAtRoot.has(name) : false;
+
+			out.push({
+				flag: flagName,
+				path,
+				type: t,
+				description: propSchema.description ?? `Body field '${path.join(".")}'`,
+				required: isRequired,
+			});
+		}
+		// Skip arrays and other complex types for now
+	}
+}
+
+/**
+ * Parse flag values with dot notation into a nested object.
+ *
+ * Example:
+ *   { "address.street": "123 Main", "address.city": "NYC", "name": "Ada" }
+ * Becomes:
+ *   { address: { street: "123 Main", city: "NYC" }, name: "Ada" }
+ */
+export function parseDotNotationFlags(
+	flagValues: Record<string, unknown>,
+	flagDefs: BodyFlagDef[],
+): Record<string, unknown> {
+	const result: Record<string, unknown> = {};
+
+	for (const def of flagDefs) {
+		// Commander keeps dots in option names: --address.street -> "address.street"
+		const dotKey = def.path.join(".");
+		const value = flagValues[dotKey];
+
+		if (value === undefined) continue;
+
+		setNestedValue(result, def.path, value, def.type);
+	}
+
+	return result;
+}
+
+/**
+ * Set a value at a nested path, creating intermediate objects as needed.
+ */
+function setNestedValue(
+	obj: Record<string, unknown>,
+	path: string[],
+	value: unknown,
+	type: string,
+): void {
+	let current = obj;
+
+	for (let i = 0; i < path.length - 1; i++) {
+		const key = path[i] as string;
+		if (!(key in current) || typeof current[key] !== "object") {
+			current[key] = {};
+		}
+		current = current[key] as Record<string, unknown>;
+	}
+
+	const finalKey = path[path.length - 1] as string;
+
+	// Coerce value based on type
+	if (type === "boolean") {
+		current[finalKey] = true;
+	} else if (type === "integer") {
+		current[finalKey] = Number.parseInt(String(value), 10);
+	} else if (type === "number") {
+		current[finalKey] = Number(String(value));
+	} else {
+		current[finalKey] = String(value);
+	}
+}
+
+/**
+ * Check if all required fields are present.
+ * Returns list of missing field paths.
+ */
+export function findMissingRequired(
+	flagValues: Record<string, unknown>,
+	flagDefs: BodyFlagDef[],
+): string[] {
+	const missing: string[] = [];
+
+	for (const def of flagDefs) {
+		if (!def.required) continue;
+
+		// Commander keeps dots in option names: --address.street -> "address.street"
+		const dotKey = def.path.join(".");
+		if (flagValues[dotKey] === undefined) {
+			missing.push(dotKey);
+		}
+	}
+
+	return missing;
+}

package/src/cli/runtime/execute.ts

@@ -1,6 +1,7 @@
 import type { CommandAction } from "../command-model.ts";
 
-import { buildRequest } from "./request.ts";
+import type { BodyFlagDef } from "./body-flags.ts";
+import { buildRequest, type EmbeddedDefaults } from "./request.ts";
 
 export type ExecuteInput = {
 	action: CommandAction;
@@ -10,6 +11,8 @@ export type ExecuteInput = {
 	servers: import("../server.ts").ServerInfo[];
 	authSchemes: import("../auth-schemes.ts").AuthScheme[];
 	specId: string;
+	embeddedDefaults?: EmbeddedDefaults;
+	bodyFlagDefs?: BodyFlagDef[];
 };
 
 export async function executeAction(input: ExecuteInput): Promise<void> {
@@ -22,14 +25,16 @@ export async function executeAction(input: ExecuteInput): Promise<void> {
 			globals: input.globals,
 			servers: input.servers,
 			authSchemes: input.authSchemes,
+			embeddedDefaults: input.embeddedDefaults,
+			bodyFlagDefs: input.bodyFlagDefs,
 		});
 
-		if (input.globals.curl || input.globals.ocCurl) {
+		if (input.globals.curl) {
 			process.stdout.write(`${curl}\n`);
 			return;
 		}
 
-		if (input.globals.dryRun || input.globals.ocDryRun) {
+		if (input.globals.dryRun) {
 			process.stdout.write(`${request.method} ${request.url}\n`);
 			for (const [k, v] of request.headers.entries()) {
 				process.stdout.write(`${k}: ${v}\n`);
@@ -43,9 +48,7 @@ export async function executeAction(input: ExecuteInput): Promise<void> {
 
 		const timeoutMs = input.globals.timeout
 			? Number(input.globals.timeout)
-			: input.globals.ocTimeout
-				? Number(input.globals.ocTimeout)
-				: undefined;
+			: undefined;
 		let timeout: Timer | undefined;
 		let controller: AbortController | undefined;
 		if (timeoutMs && Number.isFinite(timeoutMs) && timeoutMs > 0) {
@@ -77,10 +80,9 @@ export async function executeAction(input: ExecuteInput): Promise<void> {
 						`${JSON.stringify({
 							status,
 							body,
-							headers:
-								input.globals.headers || input.globals.ocHeaders
-									? Object.fromEntries(res.headers.entries())
-									: undefined,
+							headers: input.globals.headers
+								? Object.fromEntries(res.headers.entries())
+								: undefined,
 						})}\n`,
 					);
 				} else {
@@ -95,19 +97,12 @@ export async function executeAction(input: ExecuteInput): Promise<void> {
 
 			if (input.globals.json) {
 				const payload: unknown =
-					input.globals.status ||
-					input.globals.headers ||
-					input.globals.ocStatus ||
-					input.globals.ocHeaders
+					input.globals.status || input.globals.headers
 						? {
-								status:
-									input.globals.status || input.globals.ocStatus
-										? status
-										: undefined,
-								headers:
-									input.globals.headers || input.globals.ocHeaders
-										? Object.fromEntries(res.headers.entries())
-										: undefined,
+								status: input.globals.status ? status : undefined,
+								headers: input.globals.headers
+									? Object.fromEntries(res.headers.entries())
+									: undefined,
 								body,
 							}
 						: body;

package/src/cli/runtime/generated.ts

@@ -4,8 +4,10 @@ import type { AuthScheme } from "../auth-schemes.ts";
 import type { CommandModel } from "../command-model.ts";
 import type { ServerInfo } from "../server.ts";
 
+import { type BodyFlagDef, generateBodyFlags } from "./body-flags.ts";
 import { collectRepeatable } from "./collect.ts";
 import { executeAction } from "./execute.ts";
+import type { EmbeddedDefaults } from "./request.ts";
 import { coerceArrayInput, coerceValue } from "./validate/index.ts";
 
 export type GeneratedCliContext = {
@@ -13,6 +15,7 @@ export type GeneratedCliContext = {
 	authSchemes: AuthScheme[];
 	commands: CommandModel;
 	specId: string;
+	embeddedDefaults?: EmbeddedDefaults;
 };
 
 export function addGeneratedCommands(
@@ -47,7 +50,8 @@ export function addGeneratedCommands(
 
 				const isArray = flag.type === "array";
 				const itemType = flag.itemType ?? "string";
-				const parser = (raw: string) => coerceValue(raw, itemType);
+				const flagType = isArray ? itemType : flag.type;
+				const parser = (raw: string) => coerceValue(raw, flagType);
 
 				if (isArray) {
 					const key = `${opt} <value>`;
@@ -77,22 +81,7 @@ export function addGeneratedCommands(
 			const reservedFlags = new Set(action.flags.map((f) => f.flag));
 
 			// Common curl-replacement options.
-			// Some APIs have parameters like `accept`, `timeout`, etc. We always add
-			// namespaced variants (`--oc-*`) and only add the short versions when they
-			// do not conflict with operation flags.
-			cmd
-				.option(
-					"--oc-header <header>",
-					"Extra header (repeatable)",
-					collectRepeatable,
-				)
-				.option("--oc-accept <type>", "Override Accept header")
-				.option("--oc-status", "Include status in --json output")
-				.option("--oc-headers", "Include headers in --json output")
-				.option("--oc-dry-run", "Print request without sending")
-				.option("--oc-curl", "Print curl command without sending")
-				.option("--oc-timeout <ms>", "Request timeout in milliseconds");
-
+			// Only add flags that don't conflict with operation flags.
 			if (!reservedFlags.has("--header")) {
 				cmd.option(
 					"--header <header>",
@@ -119,15 +108,10 @@ export function addGeneratedCommands(
 				cmd.option("--timeout <ms>", "Request timeout in milliseconds");
 			}
 
-			if (action.requestBody) {
-				cmd
-					.option("--oc-data <data>", "Inline request body")
-					.option("--oc-file <path>", "Request body from file")
-					.option(
-						"--oc-content-type <type>",
-						"Override Content-Type (defaults from OpenAPI)",
-					);
+			// Track body flag definitions for this action
+			let bodyFlagDefs: BodyFlagDef[] = [];
 
+			if (action.requestBody) {
 				if (!reservedFlags.has("--data")) {
 					cmd.option("--data <data>", "Inline request body");
 				}
@@ -141,28 +125,17 @@ export function addGeneratedCommands(
 					);
 				}
 
-				// Expanded JSON body flags (only for simple object bodies).
-				const schema = action.requestBodySchema;
-				if (schema && schema.type === "object" && schema.properties) {
-					for (const [name, propSchema] of Object.entries(schema.properties)) {
-						if (!name || typeof name !== "string") continue;
-						if (!propSchema || typeof propSchema !== "object") continue;
-						const t = (propSchema as { type?: unknown }).type;
-						if (
-							t !== "string" &&
-							t !== "number" &&
-							t !== "integer" &&
-							t !== "boolean"
-						) {
-							continue;
-						}
-
-						const flagName = `--body-${name}`;
-						if (t === "boolean") {
-							cmd.option(flagName, `Body field '${name}'`);
-						} else {
-							cmd.option(`${flagName} <value>`, `Body field '${name}'`);
-						}
+				// Generate body flags from schema (recursive with dot notation)
+				bodyFlagDefs = generateBodyFlags(
+					action.requestBodySchema,
+					reservedFlags,
+				);
+
+				for (const def of bodyFlagDefs) {
+					if (def.type === "boolean") {
+						cmd.option(def.flag, def.description);
+					} else {
+						cmd.option(`${def.flag} <value>`, def.description);
 					}
 				}
 			}
@@ -179,20 +152,16 @@ export function addGeneratedCommands(
 				const globals = command.optsWithGlobals();
 				const local = command.opts();
 
-				const bodyFlags: Record<string, unknown> = {};
-				for (const key of Object.keys(local)) {
-					if (!key.startsWith("body")) continue;
-					bodyFlags[key] = local[key];
-				}
-
 				await executeAction({
 					action,
 					positionalValues,
-					flagValues: { ...local, __body: bodyFlags },
+					flagValues: local,
 					globals,
 					servers: context.servers,
 					authSchemes: context.authSchemes,
 					specId: context.specId,
+					embeddedDefaults: context.embeddedDefaults,
+					bodyFlagDefs,
 				});
 			});
 		}

package/src/cli/runtime/profile/secrets.ts

@@ -6,7 +6,7 @@ export type SecretKey = {
 };
 
 export function secretServiceForSpec(specId: string): string {
-	return `opencli:${specId}`;
+	return `specli:${specId}`;
 }
 
 export function tokenSecretKey(specId: string, profile: string): SecretKey {

package/src/cli/runtime/profile/store.ts

@@ -17,7 +17,7 @@ function configDir(): string {
 	// Keep it simple (v1). We can move to env-paths later.
 	const home = process.env.HOME;
 	if (!home) throw new Error("Missing HOME env var");
-	return `${home}/.config/opencli`;
+	return `${home}/.config/specli`;
 }
 
 function configPathJson(): string {

package/src/cli/runtime/request.ts

@@ -19,7 +19,7 @@ export type RuntimeGlobals = {
 	server?: string;
 	serverVar?: string[];
 
-	// Common runtime flags (may conflict with operation flags).
+	// Common runtime flags.
 	header?: string[];
 	accept?: string;
 	contentType?: string;
@@ -31,18 +31,6 @@ export type RuntimeGlobals = {
 	status?: boolean;
 	headers?: boolean;
 
-	// Namespaced variants for the runtime flags above.
-	ocHeader?: string[];
-	ocAccept?: string;
-	ocContentType?: string;
-	ocData?: string;
-	ocFile?: string;
-	ocTimeout?: string;
-	ocDryRun?: boolean;
-	ocCurl?: boolean;
-	ocStatus?: boolean;
-	ocHeaders?: boolean;
-
 	json?: boolean;
 
 	auth?: string;
@@ -159,6 +147,12 @@ function applyAuth(
 	return { headers, url };
 }
 
+export type EmbeddedDefaults = {
+	server?: string;
+	serverVars?: string[];
+	auth?: string;
+};
+
 export type BuildRequestInput = {
 	specId: string;
 	action: CommandAction;
@@ -167,6 +161,8 @@ export type BuildRequestInput = {
 	globals: RuntimeGlobals;
 	servers: import("../server.ts").ServerInfo[];
 	authSchemes: AuthScheme[];
+	embeddedDefaults?: EmbeddedDefaults;
+	bodyFlagDefs?: import("./body-flags.ts").BodyFlagDef[];
 };
 
 export async function buildRequest(
@@ -174,10 +170,16 @@ export async function buildRequest(
 ): Promise<{ request: Request; curl: string }> {
 	const profilesFile = await readProfiles();
 	const profile = getProfile(profilesFile, input.globals.profile);
+	const embedded = input.embeddedDefaults;
+
+	// Merge server vars: CLI flags override embedded defaults
+	const embeddedServerVars = parseKeyValuePairs(embedded?.serverVars);
+	const cliServerVars = parseKeyValuePairs(input.globals.serverVar);
+	const serverVars = { ...embeddedServerVars, ...cliServerVars };
 
-	const serverVars = parseKeyValuePairs(input.globals.serverVar);
+	// Priority: CLI flag > profile > embedded default
 	const serverUrl = resolveServerUrl({
-		serverOverride: input.globals.server ?? profile?.server,
+		serverOverride: input.globals.server ?? profile?.server ?? embedded?.server,
 		servers: input.servers,
 		serverVars,
 	});
@@ -205,7 +207,7 @@ export async function buildRequest(
 	);
 
 	const headers = new Headers();
-	const accept = input.globals.accept ?? input.globals.ocAccept;
+	const accept = input.globals.accept;
 	if (accept) headers.set("Accept", accept);
 
 	// Collect declared params for validation.
@@ -271,43 +273,36 @@ export async function buildRequest(
 		headers.set("Cookie", existing ? `${existing}; ${part}` : part);
 	}
 
-	const extraHeaders = [
-		...(input.globals.header ?? []),
-		...(input.globals.ocHeader ?? []),
-	].map(parseHeaderInput);
+	const extraHeaders = (input.globals.header ?? []).map(parseHeaderInput);
 	for (const { name, value } of extraHeaders) {
 		headers.set(name, value);
 	}
 
 	let body: string | undefined;
 	if (input.action.requestBody) {
-		const data = input.globals.data ?? input.globals.ocData;
-		const file = input.globals.file ?? input.globals.ocFile;
+		const data = input.globals.data;
+		const file = input.globals.file;
 
 		const hasData = typeof data === "string";
 		const hasFile = typeof file === "string";
 
-		const rawBodyFlags =
-			typeof input.flagValues.__body === "object" && input.flagValues.__body
-				? (input.flagValues.__body as Record<string, unknown>)
-				: {};
-
-		const bodyFlags: Record<string, unknown> = Object.fromEntries(
-			Object.entries(rawBodyFlags).filter(
-				([, v]) => typeof v !== "undefined" && v !== false,
-			),
-		);
-
-		const hasExpandedBody = Object.keys(bodyFlags).length > 0;
+		// Check if any body flags were provided using the flag definitions
+		const bodyFlagDefs = input.bodyFlagDefs ?? [];
+		const hasExpandedBody = bodyFlagDefs.some((def) => {
+			// Commander keeps dots in option names: --address.street -> "address.street"
+			const dotKey = def.path.join(".");
+			return input.flagValues[dotKey] !== undefined;
+		});
 
 		if (hasData && hasFile) throw new Error("Use only one of --data or --file");
 		if (hasExpandedBody && (hasData || hasFile)) {
-			throw new Error("Use either --data/--file or --body-* flags (not both)");
+			throw new Error(
+				"Use either --data/--file or body field flags (not both)",
+			);
 		}
 
 		const contentType =
 			input.globals.contentType ??
-			input.globals.ocContentType ??
 			input.action.requestBody.preferredContentType;
 		if (contentType) headers.set("Content-Type", contentType);
 
@@ -316,57 +311,29 @@ export async function buildRequest(
 		if (!hasExpandedBody && !hasData && !hasFile) {
 			if (input.action.requestBody.required) {
 				throw new Error(
-					"Missing request body. Provide --data, --file, or --body-* flags.",
+					"Missing request body. Provide --data, --file, or body field flags.",
 				);
 			}
 		} else if (hasExpandedBody) {
 			if (!contentType?.includes("json")) {
 				throw new Error(
-					"Expanded body flags are only supported for JSON request bodies. Use --content-type application/json or --data/--file.",
+					"Body field flags are only supported for JSON request bodies. Use --content-type application/json or --data/--file.",
 				);
 			}
 
-			// Friendly "missing required field" errors for expanded flags.
-			if (schema?.required && Array.isArray(schema.required)) {
-				for (const name of schema.required) {
-					const n = String(name);
-					const key = `body${n[0]?.toUpperCase()}${n.slice(1)}`;
-					if (!(key in bodyFlags)) {
-						throw new Error(
-							`Missing required body field '${n}'. Provide --body-${n} or use --data/--file.`,
-						);
-					}
-				}
+			// Check for missing required fields
+			const { findMissingRequired, parseDotNotationFlags } = await import(
+				"./body-flags.ts"
+			);
+			const missing = findMissingRequired(input.flagValues, bodyFlagDefs);
+			if (missing.length > 0) {
+				throw new Error(
+					`Missing required body field '${missing[0]}'. Provide --${missing[0]} or use --data/--file.`,
+				);
 			}
 
-			const built: Record<string, unknown> = {};
-			for (const [k, v] of Object.entries(bodyFlags)) {
-				if (!k.startsWith("body")) continue;
-				const name = k.slice("body".length);
-				const propName = name.length
-					? name[0]?.toLowerCase() + name.slice(1)
-					: "";
-				if (!propName) continue;
-
-				const propSchema =
-					schema && schema.type === "object" && schema.properties
-						? (schema.properties as Record<string, unknown>)[propName]
-						: undefined;
-				const t =
-					propSchema && typeof propSchema === "object"
-						? (propSchema as { type?: unknown }).type
-						: "string";
-
-				if (t === "boolean") {
-					built[propName] = true;
-				} else if (t === "integer") {
-					built[propName] = Number.parseInt(String(v), 10);
-				} else if (t === "number") {
-					built[propName] = Number(String(v));
-				} else {
-					built[propName] = String(v);
-				}
-			}
+			// Build nested object from dot-notation flags
+			const built = parseDotNotationFlags(input.flagValues, bodyFlagDefs);
 
 			if (schema) {
 				const validate = ajv.compile(schema);
@@ -413,20 +380,21 @@ export async function buildRequest(
 		}
 	} else {
 		if (
-			typeof (input.globals.data ?? input.globals.ocData) === "string" ||
-			typeof (input.globals.file ?? input.globals.ocFile) === "string"
+			typeof input.globals.data === "string" ||
+			typeof input.globals.file === "string"
 		) {
 			throw new Error("This operation does not accept a request body");
 		}
 	}
 
-	// Profile-aware auth resolution (flags override profile).
+	// Auth resolution priority: CLI flag > profile > embedded default
 	const resolvedAuthScheme = resolveAuthScheme(
 		input.authSchemes,
 		input.action.auth,
 		{
 			flagAuthScheme: input.globals.auth,
 			profileAuthScheme: profile?.authScheme,
+			embeddedAuthScheme: embedded?.auth,
 		},
 	);
 

package/src/cli/stable-json.ts

@@ -10,7 +10,7 @@ function sort(value: unknown, visiting: WeakSet<object>): unknown {
 	if (value === null) return null;
 
 	if (Array.isArray(value)) {
-		if (visiting.has(value)) return { __opencli_circular: true };
+		if (visiting.has(value)) return { __specli_circular: true };
 		visiting.add(value);
 		const out = value.map((v) => sort(v, visiting));
 		visiting.delete(value);
@@ -18,7 +18,7 @@ function sort(value: unknown, visiting: WeakSet<object>): unknown {
 	}
 
 	if (typeof value === "object") {
-		if (visiting.has(value)) return { __opencli_circular: true };
+		if (visiting.has(value)) return { __specli_circular: true };
 		visiting.add(value);
 
 		const obj = value as Record<string, unknown>;