specli 0.0.1 → 0.0.3

package/src/cli/runtime/request.ts

@@ -2,8 +2,6 @@ import type { AuthScheme } from "../auth-schemes.ts";
 import type { CommandAction } from "../command-model.ts";
 
 import { resolveAuthScheme } from "./auth/resolve.ts";
-import { loadBody, parseBodyAsJsonOrYaml } from "./body.ts";
-import { parseHeaderInput } from "./headers.ts";
 import { getToken } from "./profile/secrets.ts";
 import { getProfile, readProfiles } from "./profile/store.ts";
 import { resolveServerUrl } from "./server-url.ts";
@@ -19,30 +17,7 @@ export type RuntimeGlobals = {
 	server?: string;
 	serverVar?: string[];
 
-	// Common runtime flags (may conflict with operation flags).
-	header?: string[];
-	accept?: string;
-	contentType?: string;
-	data?: string;
-	file?: string;
-	timeout?: string;
-	dryRun?: boolean;
 	curl?: boolean;
-	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 +134,12 @@ function applyAuth(
 	return { headers, url };
 }
 
+export type EmbeddedDefaults = {
+	server?: string;
+	serverVars?: string[];
+	auth?: string;
+};
+
 export type BuildRequestInput = {
 	specId: string;
 	action: CommandAction;
@@ -167,6 +148,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 +157,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,8 +194,6 @@ export async function buildRequest(
 	);
 
 	const headers = new Headers();
-	const accept = input.globals.accept ?? input.globals.ocAccept;
-	if (accept) headers.set("Accept", accept);
 
 	// Collect declared params for validation.
 	const queryValues: Record<string, unknown> = {};
@@ -271,102 +258,45 @@ export async function buildRequest(
 		headers.set("Cookie", existing ? `${existing}; ${part}` : part);
 	}
 
-	const extraHeaders = [
-		...(input.globals.header ?? []),
-		...(input.globals.ocHeader ?? []),
-	].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 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;
-
-		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)");
-		}
-
-		const contentType =
-			input.globals.contentType ??
-			input.globals.ocContentType ??
-			input.action.requestBody.preferredContentType;
+		// Check if any body flags were provided using the flag definitions
+		const bodyFlagDefs = input.bodyFlagDefs ?? [];
+		const hasBodyFlags = bodyFlagDefs.some((def) => {
+			// Commander keeps dots in option names: --address.street -> "address.street"
+			const dotKey = def.path.join(".");
+			return input.flagValues[dotKey] !== undefined;
+		});
+
+		const contentType = input.action.requestBody.preferredContentType;
 		if (contentType) headers.set("Content-Type", contentType);
 
 		const schema = input.action.requestBodySchema;
 
-		if (!hasExpandedBody && !hasData && !hasFile) {
+		if (!hasBodyFlags) {
 			if (input.action.requestBody.required) {
-				throw new Error(
-					"Missing request body. Provide --data, --file, or --body-* flags.",
-				);
+				throw new Error("Missing required request body fields.");
 			}
-		} else if (hasExpandedBody) {
+		} else {
 			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.",
 				);
 			}
 
-			// 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]}.`,
+				);
 			}
 
-			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);
@@ -376,57 +306,17 @@ export async function buildRequest(
 			}
 
 			body = JSON.stringify(built);
-		} else if (hasData) {
-			if (contentType?.includes("json")) {
-				const parsed = parseBodyAsJsonOrYaml(data as string);
-
-				if (schema) {
-					const validate = ajv.compile(schema);
-					if (!validate(parsed)) {
-						throw new Error(formatAjvErrors(validate.errors));
-					}
-				}
-
-				body = JSON.stringify(parsed);
-			} else {
-				body = data as string;
-			}
-		} else if (hasFile) {
-			const loaded = await loadBody({
-				kind: "file",
-				path: file as string,
-			});
-			if (contentType?.includes("json")) {
-				const parsed = parseBodyAsJsonOrYaml(loaded?.raw ?? "");
-
-				if (schema) {
-					const validate = ajv.compile(schema);
-					if (!validate(parsed)) {
-						throw new Error(formatAjvErrors(validate.errors));
-					}
-				}
-
-				body = JSON.stringify(parsed);
-			} else {
-				body = loaded?.raw;
-			}
-		}
-	} else {
-		if (
-			typeof (input.globals.data ?? input.globals.ocData) === "string" ||
-			typeof (input.globals.file ?? input.globals.ocFile) === "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>;

package/src/compiled.ts

@@ -5,19 +5,17 @@ import { env, envRequired } from "./macros/env.ts" with { type: "macro" };
 import { loadSpec } from "./macros/spec.ts" with { type: "macro" };
 
 // This entrypoint is intended to be compiled.
-// The spec is embedded via Bun macro at bundle-time.
-const embeddedSpecText = await loadSpec(envRequired("OPENCLI_EMBED_SPEC"));
+// All values are embedded via Bun macros at bundle-time.
+const embeddedSpecText = await loadSpec(envRequired("SPECLI_SPEC"));
+const cliName = env("SPECLI_NAME");
+const server = env("SPECLI_SERVER");
+const serverVars = env("SPECLI_SERVER_VARS");
+const auth = env("SPECLI_AUTH");
 
-// CLI name is also embedded at bundle-time.
-const cliName = env("OPENCLI_CLI_NAME");
-
-// Use embedded `execArgv` as default CLI args.
-// We insert them before user-provided args so user flags win.
-const argv = [
-	process.argv[0] ?? cliName ?? "opencli",
-	process.argv[1] ?? cliName ?? "opencli",
-	...(process.execArgv ?? []),
-	...process.argv.slice(2),
-];
-
-await main(argv, { embeddedSpecText, cliName });
+await main(process.argv, {
+	embeddedSpecText,
+	cliName,
+	server,
+	serverVars: serverVars ? serverVars.split(",") : undefined,
+	auth,
+});

package/src/macros/env.ts

@@ -1,10 +1,6 @@
 /**
  * Bun macro: reads an environment variable at bundle-time.
  * Returns undefined if the env var is not set.
- *
- * Usage:
- *   import { env } from "./macros/env.ts" with { type: "macro" };
- *   const value = env("MY_VAR");
  */
 export function env(name: string): string | undefined {
 	if (!name) throw new Error("env macro: missing variable name");

package/CLAUDE.md

@@ -1,111 +0,0 @@
----
-description: Use Bun instead of Node.js, npm, pnpm, or vite.
-globs: "*.ts, *.tsx, *.html, *.css, *.js, *.jsx, package.json"
-alwaysApply: false
----
-
-Default to using Bun instead of Node.js.
-
-- Use `bun <file>` instead of `node <file>` or `ts-node <file>`
-- Use `bun test` instead of `jest` or `vitest`
-- Use `bun build <file.html|file.ts|file.css>` instead of `webpack` or `esbuild`
-- Use `bun install` instead of `npm install` or `yarn install` or `pnpm install`
-- Use `bun run <script>` instead of `npm run <script>` or `yarn run <script>` or `pnpm run <script>`
-- Use `bunx <package> <command>` instead of `npx <package> <command>`
-- Bun automatically loads .env, so don't use dotenv.
-
-## APIs
-
-- `Bun.serve()` supports WebSockets, HTTPS, and routes. Don't use `express`.
-- `bun:sqlite` for SQLite. Don't use `better-sqlite3`.
-- `Bun.redis` for Redis. Don't use `ioredis`.
-- `Bun.sql` for Postgres. Don't use `pg` or `postgres.js`.
-- `WebSocket` is built-in. Don't use `ws`.
-- Prefer `Bun.file` over `node:fs`'s readFile/writeFile
-- Bun.$`ls` instead of execa.
-
-## Testing
-
-Use `bun test` to run tests.
-
-```ts#index.test.ts
-import { test, expect } from "bun:test";
-
-test("hello world", () => {
-  expect(1).toBe(1);
-});
-```
-
-## Frontend
-
-Use HTML imports with `Bun.serve()`. Don't use `vite`. HTML imports fully support React, CSS, Tailwind.
-
-Server:
-
-```ts#index.ts
-import index from "./index.html"
-
-Bun.serve({
-  routes: {
-    "/": index,
-    "/api/users/:id": {
-      GET: (req) => {
-        return new Response(JSON.stringify({ id: req.params.id }));
-      },
-    },
-  },
-  // optional websocket support
-  websocket: {
-    open: (ws) => {
-      ws.send("Hello, world!");
-    },
-    message: (ws, message) => {
-      ws.send(message);
-    },
-    close: (ws) => {
-      // handle close
-    }
-  },
-  development: {
-    hmr: true,
-    console: true,
-  }
-})
-```
-
-HTML files can import .tsx, .jsx or .js files directly and Bun's bundler will transpile & bundle automatically. `<link>` tags can point to stylesheets and Bun's CSS bundler will bundle.
-
-```html#index.html
-<html>
-  <body>
-    <h1>Hello, world!</h1>
-    <script type="module" src="./frontend.tsx"></script>
-  </body>
-</html>
-```
-
-With the following `frontend.tsx`:
-
-```tsx#frontend.tsx
-import React from "react";
-import { createRoot } from "react-dom/client";
-
-// import .css files directly and it works
-import './index.css';
-
-const root = createRoot(document.body);
-
-export default function Frontend() {
-  return <h1>Hello, world!</h1>;
-}
-
-root.render(<Frontend />);
-```
-
-Then, run index.ts
-
-```sh
-bun --hot ./index.ts
-```
-
-For more information, read the Bun API docs in `node_modules/bun-types/docs/**.mdx`.