specli 0.0.1 → 0.0.3

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,109 +25,56 @@ 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) {
-			process.stdout.write(`${request.method} ${request.url}\n`);
-			for (const [k, v] of request.headers.entries()) {
-				process.stdout.write(`${k}: ${v}\n`);
-			}
-			if (request.body) {
-				const text = await request.clone().text();
-				if (text) process.stdout.write(`\n${text}\n`);
-			}
-			return;
-		}
-
-		const timeoutMs = input.globals.timeout
-			? Number(input.globals.timeout)
-			: input.globals.ocTimeout
-				? Number(input.globals.ocTimeout)
-				: undefined;
-		let timeout: Timer | undefined;
-		let controller: AbortController | undefined;
-		if (timeoutMs && Number.isFinite(timeoutMs) && timeoutMs > 0) {
-			controller = new AbortController();
-			timeout = setTimeout(() => controller?.abort(), timeoutMs);
-		}
+		const res = await fetch(request);
+		const contentType = res.headers.get("content-type") ?? "";
+		const status = res.status;
 
-		try {
-			const res = await fetch(request, { signal: controller?.signal });
-			const contentType = res.headers.get("content-type") ?? "";
-			const status = res.status;
+		const text = await res.text();
+		let body: unknown = text;
+		let parsedJson: unknown | undefined;
 
-			const text = await res.text();
-			let body: unknown = text;
-			let parsedJson: unknown | undefined;
-
-			if (contentType.includes("json")) {
-				try {
-					parsedJson = text ? JSON.parse(text) : null;
-					body = parsedJson;
-				} catch {
-					// keep as text
-				}
-			}
-
-			if (!res.ok) {
-				if (input.globals.json) {
-					process.stdout.write(
-						`${JSON.stringify({
-							status,
-							body,
-							headers:
-								input.globals.headers || input.globals.ocHeaders
-									? Object.fromEntries(res.headers.entries())
-									: undefined,
-						})}\n`,
-					);
-				} else {
-					process.stderr.write(`HTTP ${status}\n`);
-					process.stderr.write(
-						`${typeof body === "string" ? body : JSON.stringify(body, null, 2)}\n`,
-					);
-				}
-				process.exitCode = 1;
-				return;
+		if (contentType.includes("json")) {
+			try {
+				parsedJson = text ? JSON.parse(text) : null;
+				body = parsedJson;
+			} catch {
+				// keep as text
 			}
+		}
 
+		if (!res.ok) {
 			if (input.globals.json) {
-				const payload: unknown =
-					input.globals.status ||
-					input.globals.headers ||
-					input.globals.ocStatus ||
-					input.globals.ocHeaders
-						? {
-								status:
-									input.globals.status || input.globals.ocStatus
-										? status
-										: undefined,
-								headers:
-									input.globals.headers || input.globals.ocHeaders
-										? Object.fromEntries(res.headers.entries())
-										: undefined,
-								body,
-							}
-						: body;
-
-				process.stdout.write(`${JSON.stringify(payload)}\n`);
-				return;
-			}
-
-			// default (human + agent readable)
-			if (typeof parsedJson !== "undefined") {
-				process.stdout.write(`${JSON.stringify(parsedJson, null, 2)}\n`);
+				process.stdout.write(`${JSON.stringify({ status, body })}\n`);
 			} else {
-				process.stdout.write(text);
-				if (!text.endsWith("\n")) process.stdout.write("\n");
+				process.stderr.write(`HTTP ${status}\n`);
+				process.stderr.write(
+					`${typeof body === "string" ? body : JSON.stringify(body, null, 2)}\n`,
+				);
 			}
-		} finally {
-			if (timeout) clearTimeout(timeout);
+			process.exitCode = 1;
+			return;
+		}
+
+		if (input.globals.json) {
+			process.stdout.write(`${JSON.stringify(body)}\n`);
+			return;
+		}
+
+		// default (human + agent readable)
+		if (typeof parsedJson !== "undefined") {
+			process.stdout.write(`${JSON.stringify(parsedJson, null, 2)}\n`);
+		} else {
+			process.stdout.write(text);
+			if (!text.endsWith("\n")) process.stdout.write("\n");
 		}
 	} catch (err) {
 		const message = err instanceof Error ? err.message : String(err);

package/src/cli/runtime/generated.ts

@@ -4,8 +4,9 @@ import type { AuthScheme } from "../auth-schemes.ts";
 import type { CommandModel } from "../command-model.ts";
 import type { ServerInfo } from "../server.ts";
 
-import { collectRepeatable } from "./collect.ts";
+import { type BodyFlagDef, generateBodyFlags } from "./body-flags.ts";
 import { executeAction } from "./execute.ts";
+import type { EmbeddedDefaults } from "./request.ts";
 import { coerceArrayInput, coerceValue } from "./validate/index.ts";
 
 export type GeneratedCliContext = {
@@ -13,6 +14,7 @@ export type GeneratedCliContext = {
 	authSchemes: AuthScheme[];
 	commands: CommandModel;
 	specId: string;
+	embeddedDefaults?: EmbeddedDefaults;
 };
 
 export function addGeneratedCommands(
@@ -47,7 +49,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>`;
@@ -74,95 +77,31 @@ export function addGeneratedCommands(
 				else cmd.option(key, desc, parser);
 			}
 
-			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");
-
-			if (!reservedFlags.has("--header")) {
-				cmd.option(
-					"--header <header>",
-					"Extra header (repeatable)",
-					collectRepeatable,
-				);
-			}
-			if (!reservedFlags.has("--accept")) {
-				cmd.option("--accept <type>", "Override Accept header");
-			}
-			if (!reservedFlags.has("--status")) {
-				cmd.option("--status", "Include status in --json output");
-			}
-			if (!reservedFlags.has("--headers")) {
-				cmd.option("--headers", "Include headers in --json output");
-			}
-			if (!reservedFlags.has("--dry-run")) {
-				cmd.option("--dry-run", "Print request without sending");
-			}
-			if (!reservedFlags.has("--curl")) {
+			// Collect reserved flags: operation params + --curl
+			const operationFlags = new Set(action.flags.map((f) => f.flag));
+			const reservedFlags = new Set([...operationFlags, "--curl"]);
+
+			// Only --curl is a built-in flag (for debugging)
+			if (!operationFlags.has("--curl")) {
 				cmd.option("--curl", "Print curl command without sending");
 			}
-			if (!reservedFlags.has("--timeout")) {
-				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 (!reservedFlags.has("--data")) {
-					cmd.option("--data <data>", "Inline request body");
-				}
-				if (!reservedFlags.has("--file")) {
-					cmd.option("--file <path>", "Request body from file");
-				}
-				if (!reservedFlags.has("--content-type")) {
-					cmd.option(
-						"--content-type <type>",
-						"Override Content-Type (defaults from OpenAPI)",
-					);
-				}
+			if (action.requestBody) {
+				// Generate body flags from schema (recursive with dot notation)
+				// Pass reserved flags to avoid conflicts with operation params and --curl
+				bodyFlagDefs = generateBodyFlags(
+					action.requestBodySchema,
+					reservedFlags,
+				);
 
-				// 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}'`);
-						}
+				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 +118,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 {