specli 0.0.11 → 0.0.13

package/src/cli/command-model.ts

@@ -1,128 +0,0 @@
-import type { AuthSummary } from "./auth-requirements.ts";
-import { summarizeAuth } from "./auth-requirements.ts";
-import type { AuthScheme } from "./auth-schemes.ts";
-import { buildCommandId } from "./command-id.ts";
-import type { PlannedOperation } from "./naming.ts";
-import type { ParamSpec } from "./params.ts";
-import { deriveParamSpecs } from "./params.ts";
-import { deriveFlags, derivePositionals } from "./positional.ts";
-import type { RequestBodyInfo } from "./request-body.ts";
-import { deriveRequestBodyInfo } from "./request-body.ts";
-import type { SecurityRequirement } from "./types.ts";
-
-export type CommandAction = {
-	id: string;
-	key: string;
-	action: string;
-	// Derived path arguments. These become positionals later.
-	pathArgs: string[];
-	method: string;
-	path: string;
-	operationId?: string;
-	tags: string[];
-	summary?: string;
-	description?: string;
-	deprecated?: boolean;
-	style: PlannedOperation["style"];
-
-	// Derived CLI shape (Phase 1 output; Phase 2 will wire these into commander)
-	positionals: Array<import("./positional.ts").PositionalArg>;
-	flags: Array<
-		Pick<
-			import("./params.ts").ParamSpec,
-			| "in"
-			| "name"
-			| "flag"
-			| "required"
-			| "description"
-			| "type"
-			| "format"
-			| "enum"
-			| "itemType"
-			| "itemFormat"
-			| "itemEnum"
-		>
-	>;
-
-	// Full raw params list (useful for debugging and future features)
-	params: ParamSpec[];
-
-	auth: AuthSummary;
-	requestBody?: RequestBodyInfo;
-	requestBodySchema?: import("./types.ts").JsonSchema;
-};
-
-export type CommandResource = {
-	resource: string;
-	actions: CommandAction[];
-};
-
-export type CommandModel = {
-	resources: CommandResource[];
-};
-
-export type BuildCommandModelOptions = {
-	specId: string;
-	globalSecurity?: SecurityRequirement[];
-	authSchemes?: AuthScheme[];
-};
-
-export function buildCommandModel(
-	planned: PlannedOperation[],
-	options: BuildCommandModelOptions,
-): CommandModel {
-	const byResource = new Map<string, CommandAction[]>();
-
-	for (const op of planned) {
-		const list = byResource.get(op.resource) ?? [];
-		const params = deriveParamSpecs(op);
-		const positionals = derivePositionals({ pathArgs: op.pathArgs, params });
-		const flags = deriveFlags({ pathArgs: op.pathArgs, params });
-
-		list.push({
-			id: buildCommandId({
-				specId: options.specId,
-				resource: op.resource,
-				action: op.action,
-				operationKey: op.key,
-			}),
-			key: op.key,
-			action: op.action,
-			pathArgs: op.pathArgs,
-			method: op.method,
-			path: op.path,
-			operationId: op.operationId,
-			tags: op.tags,
-			summary: op.summary,
-			description: op.description,
-			deprecated: op.deprecated,
-			style: op.style,
-			params,
-			positionals,
-			flags: flags.flags,
-			auth: summarizeAuth(
-				op.security,
-				options.globalSecurity,
-				options.authSchemes ?? [],
-			),
-			requestBody: deriveRequestBodyInfo(op),
-			requestBodySchema: deriveRequestBodyInfo(op)?.preferredSchema,
-		});
-		byResource.set(op.resource, list);
-	}
-
-	const resources: CommandResource[] = [];
-
-	for (const [resource, actions] of byResource.entries()) {
-		actions.sort((a, b) => {
-			if (a.action !== b.action) return a.action.localeCompare(b.action);
-			if (a.path !== b.path) return a.path.localeCompare(b.path);
-			return a.method.localeCompare(b.method);
-		});
-		resources.push({ resource, actions });
-	}
-
-	resources.sort((a, b) => a.resource.localeCompare(b.resource));
-
-	return { resources };
-}

package/src/cli/compile.ts

@@ -1,101 +0,0 @@
-import { deriveBinaryName } from "./derive-name.ts";
-
-export type CompileOptions = {
-	name?: string;
-	outfile?: string;
-	target?: string;
-	minify?: boolean;
-	bytecode?: boolean;
-	dotenv?: boolean; // --no-dotenv sets this to false
-	bunfig?: boolean; // --no-bunfig sets this to false
-	define?: string[];
-	server?: string;
-	serverVar?: string[];
-	auth?: string;
-};
-
-function parseKeyValue(input: string): { key: string; value: string } {
-	const idx = input.indexOf("=");
-	if (idx === -1)
-		throw new Error(`Invalid --define '${input}', expected key=value`);
-	const key = input.slice(0, idx).trim();
-	const value = input.slice(idx + 1).trim();
-	if (!key) throw new Error(`Invalid --define '${input}', missing key`);
-	return { key, value };
-}
-
-export async function compileCommand(
-	spec: string,
-	options: CompileOptions,
-): Promise<void> {
-	// Derive name from spec if not provided
-	const name = options.name ?? (await deriveBinaryName(spec));
-	const outfile = options.outfile ?? `./dist/${name}`;
-
-	const target = options.target
-		? (options.target as Bun.Build.Target)
-		: (`bun-${process.platform}-${process.arch}` as Bun.Build.Target);
-
-	// Parse --define pairs
-	const define: Record<string, string> = {};
-	if (options.define) {
-		for (const pair of options.define) {
-			const { key, value } = parseKeyValue(pair);
-			define[key] = JSON.stringify(value);
-		}
-	}
-
-	// Build command args
-	const buildArgs = [
-		"build",
-		"--compile",
-		`--outfile=${outfile}`,
-		`--target=${target}`,
-	];
-
-	if (options.minify) buildArgs.push("--minify");
-	if (options.bytecode) buildArgs.push("--bytecode");
-
-	for (const [k, v] of Object.entries(define)) {
-		buildArgs.push("--define", `${k}=${v}`);
-	}
-
-	if (options.dotenv === false) buildArgs.push("--no-compile-autoload-dotenv");
-	if (options.bunfig === false) buildArgs.push("--no-compile-autoload-bunfig");
-
-	buildArgs.push("./src/compiled.ts");
-
-	// Only set env vars that have actual values - avoid empty strings
-	// because the macros will embed them and they will override defaults.
-	const buildEnv: Record<string, string> = {
-		...process.env,
-		SPECLI_SPEC: spec,
-		SPECLI_NAME: name,
-	};
-	if (options.server) buildEnv.SPECLI_SERVER = options.server;
-	if (options.serverVar?.length)
-		buildEnv.SPECLI_SERVER_VARS = options.serverVar.join(",");
-	if (options.auth) buildEnv.SPECLI_AUTH = options.auth;
-
-	const proc = Bun.spawn({
-		cmd: ["bun", ...buildArgs],
-		stdout: "pipe",
-		stderr: "pipe",
-		env: buildEnv,
-	});
-
-	const output = await new Response(proc.stdout).text();
-	const error = await new Response(proc.stderr).text();
-	const code = await proc.exited;
-
-	if (output) process.stdout.write(output);
-	if (error) process.stderr.write(error);
-	if (code !== 0) {
-		process.exitCode = code;
-		return;
-	}
-
-	process.stdout.write(`ok: built ${outfile}\n`);
-	process.stdout.write(`target: ${target}\n`);
-	process.stdout.write(`name: ${name}\n`);
-}

package/src/cli/crypto.ts

@@ -1,9 +0,0 @@
-export async function sha256Hex(text: string): Promise<string> {
-	const data = new TextEncoder().encode(text);
-	const hash = await crypto.subtle.digest("SHA-256", data);
-	const bytes = new Uint8Array(hash);
-
-	let out = "";
-	for (const b of bytes) out += b.toString(16).padStart(2, "0");
-	return out;
-}

package/src/cli/derive-name.ts

@@ -1,101 +0,0 @@
-const RESERVED_NAMES = [
-	"exec",
-	"compile",
-	"profile",
-	"auth",
-	"help",
-	"version",
-];
-
-/**
- * Derives a clean binary name from an OpenAPI spec.
- * Priority:
- *   1. info.title (kebab-cased, sanitized)
- *   2. Host from spec URL (if URL provided)
- *   3. Fallback to "specli"
- */
-export async function deriveBinaryName(spec: string): Promise<string> {
-	try {
-		// Load spec to extract title
-		const text = await loadSpecText(spec);
-		const doc = parseSpec(text);
-
-		const title = doc?.info?.title;
-		if (title && typeof title === "string") {
-			const name = sanitizeName(title);
-			if (name) return name;
-		}
-	} catch {
-		// Fall through to URL-based derivation
-	}
-
-	// Try to derive from URL host
-	if (/^https?:\/\//i.test(spec)) {
-		try {
-			const url = new URL(spec);
-			const hostParts = url.hostname.split(".");
-			// Use first meaningful segment (skip www, api prefixes)
-			const meaningful = hostParts.find(
-				(p) => p !== "www" && p !== "api" && p.length > 2,
-			);
-			if (meaningful) {
-				const name = sanitizeName(meaningful);
-				if (name) return name;
-			}
-		} catch {
-			// Invalid URL, fall through
-		}
-	}
-
-	// Fallback
-	return "specli";
-}
-
-async function loadSpecText(spec: string): Promise<string> {
-	if (/^https?:\/\//i.test(spec)) {
-		const res = await fetch(spec);
-		if (!res.ok) throw new Error(`Failed to fetch: ${res.status}`);
-		return res.text();
-	}
-	return Bun.file(spec).text();
-}
-
-function parseSpec(text: string): { info?: { title?: string } } | null {
-	try {
-		const trimmed = text.trimStart();
-		if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
-			return JSON.parse(text);
-		}
-		// Use Bun's YAML parser
-		const { YAML } = globalThis.Bun ?? {};
-		if (YAML?.parse) {
-			return YAML.parse(text) as { info?: { title?: string } };
-		}
-		// Fallback: only JSON supported
-		return null;
-	} catch {
-		return null;
-	}
-}
-
-/**
- * Convert title to valid binary name:
- * - kebab-case
- * - lowercase
- * - remove invalid chars
- * - max 32 chars
- * - avoid reserved names
- */
-function sanitizeName(input: string): string {
-	let name = input
-		.toLowerCase()
-		.replace(/[^a-z0-9]+/g, "-") // Replace non-alphanumeric with dash
-		.replace(/^-+|-+$/g, "") // Trim leading/trailing dashes
-		.slice(0, 32); // Limit length
-
-	if (RESERVED_NAMES.includes(name)) {
-		name = `${name}-cli`;
-	}
-
-	return name;
-}

package/src/cli/exec.ts

@@ -1,72 +0,0 @@
-import { main } from "./main.ts";
-
-export type ExecOptions = {
-	server?: string;
-	serverVar?: string[];
-	auth?: string;
-	bearerToken?: string;
-	oauthToken?: string;
-	username?: string;
-	password?: string;
-	apiKey?: string;
-	profile?: string;
-	json?: boolean;
-};
-
-export async function execCommand(
-	spec: string,
-	options: ExecOptions,
-	commandArgs: string[],
-): Promise<void> {
-	// commandArgs includes the spec as first element, filter it out
-	// to get the remaining args (resource, action, etc.)
-	const remainingArgs = commandArgs.slice(1);
-
-	// Reconstruct argv for main():
-	// [node, script, --spec, <spec>, ...options, ...remainingArgs]
-	const argv = [
-		process.argv[0] ?? "bun",
-		process.argv[1] ?? "specli",
-		"--spec",
-		spec,
-	];
-
-	// Add common options back as flags
-	if (options.server) {
-		argv.push("--server", options.server);
-	}
-	if (options.serverVar) {
-		for (const v of options.serverVar) {
-			argv.push("--server-var", v);
-		}
-	}
-	if (options.auth) {
-		argv.push("--auth", options.auth);
-	}
-	if (options.bearerToken) {
-		argv.push("--bearer-token", options.bearerToken);
-	}
-	if (options.oauthToken) {
-		argv.push("--oauth-token", options.oauthToken);
-	}
-	if (options.username) {
-		argv.push("--username", options.username);
-	}
-	if (options.password) {
-		argv.push("--password", options.password);
-	}
-	if (options.apiKey) {
-		argv.push("--api-key", options.apiKey);
-	}
-	if (options.profile) {
-		argv.push("--profile", options.profile);
-	}
-	if (options.json) {
-		argv.push("--json");
-	}
-
-	// Append remaining args (subcommand + its args)
-	argv.push(...remainingArgs);
-
-	await main(argv);
-}

package/src/cli/main.ts

@@ -1,231 +0,0 @@
-import { Command } from "commander";
-
-import { getArgValue, hasAnyArg } from "./runtime/argv.ts";
-import { collectRepeatable } from "./runtime/collect.ts";
-import { readStdinText } from "./runtime/compat.ts";
-import { buildRuntimeContext } from "./runtime/context.ts";
-import { addGeneratedCommands } from "./runtime/generated.ts";
-import { deleteToken, getToken, setToken } from "./runtime/profile/secrets.ts";
-import {
-	readProfiles,
-	upsertProfile,
-	writeProfiles,
-} from "./runtime/profile/store.ts";
-import { toMinimalSchemaOutput } from "./schema.ts";
-import { stableStringify } from "./stable-json.ts";
-
-type MainOptions = {
-	embeddedSpecText?: string;
-	cliName?: string;
-	server?: string;
-	serverVars?: string[];
-	auth?: string;
-};
-
-export async function main(argv: string[], options: MainOptions = {}) {
-	const program = new Command();
-
-	program
-		.name(options.cliName ?? "specli")
-		.description("Generate a CLI from an OpenAPI spec")
-		.option("--spec <urlOrPath>", "OpenAPI URL or file path")
-		.option("--server <url>", "Override server/base URL")
-		.option(
-			"--server-var <name=value>",
-			"Server URL template variable (repeatable)",
-			collectRepeatable,
-		)
-		.option("--auth <scheme>", "Select auth scheme by key")
-		.option("--bearer-token <token>", "Bearer token (Authorization: Bearer)")
-		.option("--oauth-token <token>", "OAuth token (alias of bearer)")
-		.option("--username <username>", "Basic auth username")
-		.option("--password <password>", "Basic auth password")
-		.option("--api-key <key>", "API key value")
-		.option("--json", "Machine-readable output")
-		.showHelpAfterError();
-
-	// If user asks for help and we have no embedded spec and no --spec, show minimal help.
-	const spec = getArgValue(argv, "--spec");
-	const wantsHelp = hasAnyArg(argv, ["-h", "--help"]);
-	if (!spec && !options.embeddedSpecText && wantsHelp) {
-		program.addHelpText(
-			"after",
-			"\nTo see generated commands, run with --spec <url|path>.\n",
-		);
-		program.parse(argv);
-		return;
-	}
-
-	const ctx = await buildRuntimeContext({
-		spec,
-		embeddedSpecText: options.embeddedSpecText,
-	});
-
-	// Simple auth commands
-	const defaultProfileName = "default";
-
-	program
-		.command("login [token]")
-		.description("Store a bearer token for authentication")
-		.action(async (tokenArg: string | undefined, _opts, command) => {
-			const globals = command.optsWithGlobals() as { json?: boolean };
-
-			let token = tokenArg;
-
-			// If no token argument, try to read from stdin (for piping)
-			if (!token) {
-				const isTTY = process.stdin.isTTY;
-				if (isTTY) {
-					// Interactive mode - prompt user
-					process.stdout.write("Enter token: ");
-					const reader = process.stdin;
-					const chunks: Buffer[] = [];
-					for await (const chunk of reader) {
-						chunks.push(chunk);
-						// Read one line only
-						if (chunk.includes(10)) break; // newline
-					}
-					token = Buffer.concat(chunks).toString().trim();
-				} else {
-					// Piped input - use cross-runtime stdin reading
-					const text = await readStdinText();
-					token = text.trim();
-				}
-			}
-
-			if (!token) {
-				throw new Error(
-					"No token provided. Usage: login <token> or echo $TOKEN | login",
-				);
-			}
-
-			// Ensure default profile exists
-			const file = await readProfiles();
-			if (!file.profiles.find((p) => p.name === defaultProfileName)) {
-				const updated = upsertProfile(file, { name: defaultProfileName });
-				await writeProfiles({ ...updated, defaultProfile: defaultProfileName });
-			} else if (!file.defaultProfile) {
-				await writeProfiles({ ...file, defaultProfile: defaultProfileName });
-			}
-
-			await setToken(ctx.loaded.id, defaultProfileName, token);
-
-			if (globals.json) {
-				process.stdout.write(`${JSON.stringify({ ok: true })}\n`);
-				return;
-			}
-			process.stdout.write("ok: logged in\n");
-		});
-
-	program
-		.command("logout")
-		.description("Clear stored authentication token")
-		.action(async (_opts, command) => {
-			const globals = command.optsWithGlobals() as { json?: boolean };
-
-			const deleted = await deleteToken(ctx.loaded.id, defaultProfileName);
-
-			if (globals.json) {
-				process.stdout.write(`${JSON.stringify({ ok: deleted })}\n`);
-				return;
-			}
-			process.stdout.write(
-				deleted ? "ok: logged out\n" : "ok: not logged in\n",
-			);
-		});
-
-	program
-		.command("whoami")
-		.description("Show current authentication status")
-		.action(async (_opts, command) => {
-			const globals = command.optsWithGlobals() as { json?: boolean };
-
-			const token = await getToken(ctx.loaded.id, defaultProfileName);
-			const hasToken = Boolean(token);
-
-			// Mask the token for display (show first 8 and last 4 chars)
-			let maskedToken: string | null = null;
-			if (token && token.length > 16) {
-				maskedToken = `${token.slice(0, 8)}...${token.slice(-4)}`;
-			} else if (token) {
-				maskedToken = `${token.slice(0, 4)}...`;
-			}
-
-			if (globals.json) {
-				process.stdout.write(
-					`${JSON.stringify({ authenticated: hasToken, token: maskedToken })}\n`,
-				);
-				return;
-			}
-
-			if (hasToken) {
-				process.stdout.write(`authenticated: yes\n`);
-				process.stdout.write(`token: ${maskedToken}\n`);
-			} else {
-				process.stdout.write(`authenticated: no\n`);
-				process.stdout.write(`Run 'login <token>' to authenticate.\n`);
-			}
-		});
-
-	program
-		.command("__schema")
-		.description("Print indexed operations (machine-readable when --json)")
-		.option("--pretty", "Pretty-print JSON when used with --json")
-		.option("--min", "Minimal JSON output (commands + metadata only)")
-		.action(async (_opts, command) => {
-			const flags = command.optsWithGlobals() as {
-				json?: boolean;
-				pretty?: boolean;
-				min?: boolean;
-			};
-
-			if (flags.json) {
-				const pretty = Boolean(flags.pretty);
-				const payload = flags.min
-					? toMinimalSchemaOutput(ctx.schema)
-					: ctx.schema;
-				const text = stableStringify(payload, { space: pretty ? 2 : 0 });
-				process.stdout.write(`${text}\n`);
-				return;
-			}
-
-			process.stdout.write(`${ctx.schema.openapi.title ?? "(untitled)"}\n`);
-			process.stdout.write(`OpenAPI: ${ctx.schema.openapi.version}\n`);
-			process.stdout.write(
-				`Spec: ${ctx.schema.spec.id} (${ctx.schema.spec.source})\n`,
-			);
-			process.stdout.write(`Fingerprint: ${ctx.schema.spec.fingerprint}\n`);
-			process.stdout.write(`Servers: ${ctx.schema.servers.length}\n`);
-			process.stdout.write(`Auth Schemes: ${ctx.schema.authSchemes.length}\n`);
-			process.stdout.write(`Operations: ${ctx.schema.operations.length}\n`);
-
-			for (const op of ctx.schema.operations) {
-				const id = op.operationId ? ` (${op.operationId})` : "";
-				process.stdout.write(`- ${op.method} ${op.path}${id}\n`);
-			}
-
-			if (ctx.schema.planned?.length) {
-				process.stdout.write("\nPlanned commands:\n");
-				for (const op of ctx.schema.planned) {
-					const args = op.pathArgs.length
-						? ` ${op.pathArgs.map((a) => `<${a}>`).join(" ")}`
-						: "";
-					process.stdout.write(`- specli ${op.resource} ${op.action}${args}\n`);
-				}
-			}
-		});
-
-	addGeneratedCommands(program, {
-		servers: ctx.servers,
-		authSchemes: ctx.authSchemes,
-		commands: ctx.commands,
-		specId: ctx.loaded.id,
-		embeddedDefaults: {
-			server: options.server,
-			serverVars: options.serverVars,
-			auth: options.auth,
-		},
-	});
-
-	await program.parseAsync(argv);
-}