specli 0.0.11 → 0.0.13

package/src/cli/runtime/auth/resolve.ts

@@ -1,59 +0,0 @@
-import type { AuthScheme } from "../../auth-schemes.ts";
-
-export type AuthInputs = {
-	flagAuthScheme?: string;
-	profileAuthScheme?: string;
-	embeddedAuthScheme?: string;
-	hasStoredToken?: boolean;
-};
-
-const BEARER_COMPATIBLE_KINDS = new Set([
-	"http-bearer",
-	"oauth2",
-	"openIdConnect",
-]);
-
-export function resolveAuthScheme(
-	authSchemes: AuthScheme[],
-	required: import("../../auth-requirements.ts").AuthSummary,
-	inputs: AuthInputs,
-): string | undefined {
-	// Priority: CLI flag > profile > embedded default
-	if (inputs.flagAuthScheme) return inputs.flagAuthScheme;
-
-	if (
-		inputs.profileAuthScheme &&
-		authSchemes.some((s) => s.key === inputs.profileAuthScheme)
-	) {
-		return inputs.profileAuthScheme;
-	}
-
-	if (
-		inputs.embeddedAuthScheme &&
-		authSchemes.some((s) => s.key === inputs.embeddedAuthScheme)
-	) {
-		return inputs.embeddedAuthScheme;
-	}
-
-	// If operation requires exactly one scheme, choose it.
-	const alts = required.alternatives;
-	if (alts.length === 1 && alts[0]?.length === 1) return alts[0][0]?.key;
-
-	// Otherwise if there is only one scheme in spec, pick it.
-	if (authSchemes.length === 1) return authSchemes[0]?.key;
-
-	// If user has a stored token and operation accepts a bearer-compatible scheme,
-	// automatically pick the first one that matches.
-	if (inputs.hasStoredToken && alts.length > 0) {
-		for (const alt of alts) {
-			if (alt.length !== 1) continue;
-			const key = alt[0]?.key;
-			const scheme = authSchemes.find((s) => s.key === key);
-			if (scheme && BEARER_COMPATIBLE_KINDS.has(scheme.kind)) {
-				return key;
-			}
-		}
-	}
-
-	return undefined;
-}

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

@@ -1,176 +0,0 @@
-/**
- * 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/body.ts

@@ -1,24 +0,0 @@
-import { parseYamlContent, readFileText } from "./compat.ts";
-
-export type BodyInput =
-	| { kind: "none" }
-	| { kind: "data"; data: string }
-	| { kind: "file"; path: string };
-
-export async function loadBody(
-	input: BodyInput,
-): Promise<{ raw: string; json?: unknown } | undefined> {
-	if (input.kind === "none") return undefined;
-	if (input.kind === "data") return { raw: input.data };
-
-	const text = await readFileText(input.path);
-	return { raw: text };
-}
-
-export function parseBodyAsJsonOrYaml(text: string): unknown {
-	const trimmed = text.trimStart();
-	if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
-		return JSON.parse(text);
-	}
-	return parseYamlContent(text);
-}

package/src/cli/runtime/collect.ts

@@ -1,6 +0,0 @@
-export function collectRepeatable(
-	value: string,
-	previous: string[] | undefined,
-): string[] {
-	return [...(previous ?? []), value];
-}

package/src/cli/runtime/compat.ts

@@ -1,89 +0,0 @@
-/**
- * Cross-runtime compatibility utilities for Bun and Node.js
- *
- * This module provides abstractions over Bun-specific APIs to allow
- * the exec command to run in Node.js while compile remains Bun-only.
- */
-
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { parse as parseYaml } from "yaml";
-
-/**
- * Detect if we're running in Bun
- */
-export const isBun = typeof globalThis.Bun !== "undefined";
-
-/**
- * Read a file's text content - works in both Bun and Node.js
- */
-export async function readFileText(path: string): Promise<string> {
-	if (isBun) {
-		return Bun.file(path).text();
-	}
-	return readFileSync(path, "utf-8");
-}
-
-/**
- * Check if a file exists - works in both Bun and Node.js
- */
-export async function fileExists(path: string): Promise<boolean> {
-	if (isBun) {
-		return Bun.file(path).exists();
-	}
-	return existsSync(path);
-}
-
-/**
- * Write text to a file - works in both Bun and Node.js
- */
-export async function writeFileText(
-	path: string,
-	content: string,
-): Promise<void> {
-	if (isBun) {
-		await Bun.write(path, content);
-		return;
-	}
-	writeFileSync(path, content, "utf-8");
-}
-
-/**
- * Create directory recursively - works in both Bun and Node.js
- */
-export async function mkdirp(path: string): Promise<void> {
-	if (isBun) {
-		await Bun.$`mkdir -p ${path}`;
-		return;
-	}
-	mkdirSync(path, { recursive: true });
-}
-
-/**
- * Parse YAML content - works in both Bun and Node.js
- */
-export function parseYamlContent(text: string): unknown {
-	if (isBun) {
-		const { YAML } = globalThis.Bun;
-		return YAML.parse(text);
-	}
-	return parseYaml(text);
-}
-
-/**
- * Read from stdin - works in both Bun and Node.js
- */
-export async function readStdinText(): Promise<string> {
-	if (isBun) {
-		return Bun.stdin.text();
-	}
-	// Node.js stdin reading
-	return new Promise((resolve, reject) => {
-		let data = "";
-		process.stdin.setEncoding("utf8");
-		process.stdin.on("data", (chunk) => {
-			data += chunk;
-		});
-		process.stdin.on("end", () => resolve(data));
-		process.stdin.on("error", reject);
-	});
-}

package/src/cli/runtime/context.ts

@@ -1,62 +0,0 @@
-import { listAuthSchemes } from "../auth-schemes.ts";
-import { deriveCapabilities } from "../capabilities.ts";
-import { buildCommandsIndex } from "../command-index.ts";
-import { buildCommandModel } from "../command-model.ts";
-import { planOperations } from "../naming.ts";
-import { indexOperations } from "../operations.ts";
-import { buildSchemaOutput } from "../schema.ts";
-import { listServers } from "../server.ts";
-import { loadSpec } from "../spec-loader.ts";
-
-export type BuildRuntimeContextOptions = {
-	spec?: string;
-	embeddedSpecText?: string;
-};
-
-export async function buildRuntimeContext(options: BuildRuntimeContextOptions) {
-	const loaded = await loadSpec({
-		spec: options.spec,
-		embeddedSpecText: options.embeddedSpecText,
-	});
-
-	const operations = indexOperations(loaded.doc);
-	const servers = listServers(loaded.doc);
-	const authSchemes = listAuthSchemes(loaded.doc);
-	const planned = planOperations(operations);
-	const commands = buildCommandModel(planned, {
-		specId: loaded.id,
-		globalSecurity: loaded.doc.security,
-		authSchemes,
-	});
-	const commandsIndex = buildCommandsIndex(commands);
-	const capabilities = deriveCapabilities({
-		doc: loaded.doc,
-		servers,
-		authSchemes,
-		operations,
-		commands,
-	});
-
-	const schema = buildSchemaOutput(
-		loaded,
-		operations,
-		planned,
-		servers,
-		authSchemes,
-		commands,
-		commandsIndex,
-		capabilities,
-	);
-
-	return {
-		loaded,
-		operations,
-		servers,
-		authSchemes,
-		planned,
-		commands,
-		commandsIndex,
-		capabilities,
-		schema,
-	};
-}

package/src/cli/runtime/execute.ts

@@ -1,147 +0,0 @@
-import type { CommandAction } from "../command-model.ts";
-
-import type { BodyFlagDef } from "./body-flags.ts";
-import { buildRequest, type EmbeddedDefaults } from "./request.ts";
-
-export type ExecuteInput = {
-	action: CommandAction;
-	positionalValues: string[];
-	flagValues: Record<string, unknown>;
-	globals: import("./request.ts").RuntimeGlobals;
-	servers: import("../server.ts").ServerInfo[];
-	authSchemes: import("../auth-schemes.ts").AuthScheme[];
-	specId: string;
-	embeddedDefaults?: EmbeddedDefaults;
-	bodyFlagDefs?: BodyFlagDef[];
-	/** Resource name for error messages (e.g. "plans") */
-	resourceName?: string;
-};
-
-export type ExecuteResult = {
-	ok: boolean;
-	status: number;
-	body: unknown;
-	curl: string;
-};
-
-/**
- * Format an error message with a help hint.
- */
-function formatError(
-	message: string,
-	resourceName: string | undefined,
-	actionName: string,
-): string {
-	const helpCmd = resourceName
-		? `${resourceName} ${actionName} --help`
-		: `${actionName} --help`;
-	return `${message}\n\nRun '${helpCmd}' to see available options.`;
-}
-
-/**
- * Execute an action and return the result as data.
- * This is the core execution function used by both CLI and programmatic API.
- */
-export async function execute(
-	input: Omit<ExecuteInput, "resourceName">,
-): Promise<ExecuteResult> {
-	const { request, curl } = await buildRequest({
-		specId: input.specId,
-		action: input.action,
-		positionalValues: input.positionalValues,
-		flagValues: input.flagValues,
-		globals: input.globals,
-		servers: input.servers,
-		authSchemes: input.authSchemes,
-		embeddedDefaults: input.embeddedDefaults,
-		bodyFlagDefs: input.bodyFlagDefs,
-	});
-
-	const res = await fetch(request);
-	const contentType = res.headers.get("content-type") ?? "";
-
-	const text = await res.text();
-	let body: unknown = text;
-
-	if (contentType.includes("json") && text) {
-		try {
-			body = JSON.parse(text);
-		} catch {
-			// keep as text
-		}
-	}
-
-	return {
-		ok: res.ok,
-		status: res.status,
-		body,
-		curl,
-	};
-}
-
-/**
- * Execute an action and write output to stdout/stderr.
- * This is the CLI-facing wrapper around execute().
- */
-export async function executeAction(input: ExecuteInput): Promise<void> {
-	const actionName = input.action.action;
-	const resourceName = input.resourceName;
-
-	try {
-		if (input.globals.curl) {
-			const { curl } = await buildRequest({
-				specId: input.specId,
-				action: input.action,
-				positionalValues: input.positionalValues,
-				flagValues: input.flagValues,
-				globals: input.globals,
-				servers: input.servers,
-				authSchemes: input.authSchemes,
-				embeddedDefaults: input.embeddedDefaults,
-				bodyFlagDefs: input.bodyFlagDefs,
-			});
-			process.stdout.write(`${curl}\n`);
-			return;
-		}
-
-		const result = await execute(input);
-
-		if (!result.ok) {
-			if (input.globals.json) {
-				process.stdout.write(
-					`${JSON.stringify({ status: result.status, body: result.body })}\n`,
-				);
-			} else {
-				process.stderr.write(`HTTP ${result.status}\n`);
-				process.stderr.write(
-					`${typeof result.body === "string" ? result.body : JSON.stringify(result.body, null, 2)}\n`,
-				);
-			}
-			process.exitCode = 1;
-			return;
-		}
-
-		if (input.globals.json) {
-			process.stdout.write(`${JSON.stringify(result.body)}\n`);
-			return;
-		}
-
-		// default (human + agent readable)
-		if (typeof result.body === "string") {
-			process.stdout.write(result.body);
-			if (!result.body.endsWith("\n")) process.stdout.write("\n");
-		} else {
-			process.stdout.write(`${JSON.stringify(result.body, null, 2)}\n`);
-		}
-	} catch (err) {
-		const rawMessage = err instanceof Error ? err.message : String(err);
-		const message = formatError(rawMessage, resourceName, actionName);
-
-		if (input.globals.json) {
-			process.stdout.write(`${JSON.stringify({ error: rawMessage })}\n`);
-		} else {
-			process.stderr.write(`error: ${message}\n`);
-		}
-		process.exitCode = 1;
-	}
-}