specli 0.0.11 → 0.0.13

package/dist/{src/cli → cli}/request-body.d.ts

@@ -17,4 +17,3 @@ export type RequestBodyInfo = {
     preferredSchema?: JsonSchema;
 };
 export declare function deriveRequestBodyInfo(op: NormalizedOperation): RequestBodyInfo | undefined;
-//# sourceMappingURL=request-body.d.ts.map

package/dist/cli/request-body.js

@@ -0,0 +1,44 @@
+import { getSchemaEnumStrings, getSchemaFormat, getSchemaType, } from "./schema-shape.js";
+import { isJsonSchema } from "./types.js";
+function getRequestBody(op) {
+    return op.requestBody;
+}
+export function deriveRequestBodyInfo(op) {
+    const rb = getRequestBody(op);
+    if (!rb)
+        return undefined;
+    const content = [];
+    for (const contentType of rb.contentTypes) {
+        const schema = rb.schemasByContentType[contentType];
+        content.push({
+            contentType,
+            required: rb.required,
+            schemaType: getSchemaType(schema),
+            schemaFormat: getSchemaFormat(schema),
+            schemaEnum: getSchemaEnumStrings(schema),
+        });
+    }
+    content.sort((a, b) => a.contentType.localeCompare(b.contentType));
+    const hasJson = content.some((c) => c.contentType.includes("json"));
+    const hasFormUrlEncoded = content.some((c) => c.contentType === "application/x-www-form-urlencoded");
+    const hasMultipart = content.some((c) => c.contentType.startsWith("multipart/"));
+    const bodyFlags = ["--data", "--file"]; // always available when requestBody exists
+    const preferredContentType = content.find((c) => c.contentType === "application/json")?.contentType ??
+        content.find((c) => c.contentType.includes("json"))?.contentType ??
+        content[0]?.contentType;
+    const preferredSchema = preferredContentType
+        ? rb.schemasByContentType[preferredContentType]
+        : undefined;
+    return {
+        required: rb.required,
+        content,
+        hasJson,
+        hasFormUrlEncoded,
+        hasMultipart,
+        bodyFlags,
+        preferredContentType,
+        preferredSchema: isJsonSchema(preferredSchema)
+            ? preferredSchema
+            : undefined,
+    };
+}

package/dist/cli/request-body.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cli/request-body.test.js

@@ -0,0 +1,31 @@
+import { describe, expect, test } from "bun:test";
+import { deriveRequestBodyInfo } from "./request-body.js";
+describe("deriveRequestBodyInfo", () => {
+    test("summarizes content types and convenience flags", () => {
+        const op = {
+            key: "POST /contacts",
+            method: "POST",
+            path: "/contacts",
+            tags: [],
+            parameters: [],
+            requestBody: {
+                required: true,
+                contentTypes: ["application/x-www-form-urlencoded", "application/json"],
+                schemasByContentType: {
+                    "application/json": { type: "object" },
+                    "application/x-www-form-urlencoded": { type: "object" },
+                },
+            },
+        };
+        const info = deriveRequestBodyInfo(op);
+        expect(info?.required).toBe(true);
+        expect(info?.hasJson).toBe(true);
+        expect(info?.hasFormUrlEncoded).toBe(true);
+        expect(info?.hasMultipart).toBe(false);
+        expect(info?.content.map((c) => c.contentType)).toEqual([
+            "application/json",
+            "application/x-www-form-urlencoded",
+        ]);
+        expect(info?.preferredSchema).toEqual({ type: "object" });
+    });
+});

package/dist/{src/cli → cli}/runtime/argv.d.ts

@@ -1,3 +1,2 @@
 export declare function getArgValue(argv: string[], key: string): string | undefined;
 export declare function hasAnyArg(argv: string[], names: string[]): boolean;
-//# sourceMappingURL=argv.d.ts.map

package/dist/cli/runtime/argv.js

@@ -0,0 +1,15 @@
+export function getArgValue(argv, key) {
+    for (let i = 0; i < argv.length; i++) {
+        const a = argv[i];
+        if (!a)
+            continue;
+        if (a === key)
+            return argv[i + 1];
+        if (a.startsWith(`${key}=`))
+            return a.slice(key.length + 1);
+    }
+    return undefined;
+}
+export function hasAnyArg(argv, names) {
+    return argv.some((a) => a && names.includes(a));
+}

package/dist/{src/cli → cli}/runtime/auth/resolve.d.ts

@@ -6,4 +6,3 @@ export type AuthInputs = {
     hasStoredToken?: boolean;
 };
 export declare function resolveAuthScheme(authSchemes: AuthScheme[], required: import("../../auth-requirements.js").AuthSummary, inputs: AuthInputs): string | undefined;
-//# sourceMappingURL=resolve.d.ts.map

package/dist/cli/runtime/auth/resolve.js

@@ -0,0 +1,39 @@
+const BEARER_COMPATIBLE_KINDS = new Set([
+    "http-bearer",
+    "oauth2",
+    "openIdConnect",
+]);
+export function resolveAuthScheme(authSchemes, required, inputs) {
+    // 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/dist/{src/cli → cli}/runtime/body-flags.d.ts

@@ -38,4 +38,3 @@ export declare function parseDotNotationFlags(flagValues: Record<string, unknown
  */
 export declare function findMissingRequired(flagValues: Record<string, unknown>, flagDefs: BodyFlagDef[]): string[];
 export {};
-//# sourceMappingURL=body-flags.d.ts.map

package/dist/cli/runtime/body-flags.js

@@ -0,0 +1,117 @@
+/**
+ * Body flag generation and parsing utilities.
+ *
+ * Generates CLI flags from JSON schema properties and parses
+ * dot-notation flags back into nested objects.
+ */
+/**
+ * Generate flag definitions from a JSON schema.
+ * Recursively handles nested objects using dot notation.
+ */
+export function generateBodyFlags(schema, reservedFlags) {
+    if (!schema || schema.type !== "object" || !schema.properties) {
+        return [];
+    }
+    const flags = [];
+    const requiredSet = new Set(schema.required ?? []);
+    collectFlags(schema.properties, [], requiredSet, flags, reservedFlags);
+    return flags;
+}
+function collectFlags(properties, pathPrefix, requiredAtRoot, out, reservedFlags) {
+    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, flagDefs) {
+    const result = {};
+    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, path, value, type) {
+    let current = obj;
+    for (let i = 0; i < path.length - 1; i++) {
+        const key = path[i];
+        if (!(key in current) || typeof current[key] !== "object") {
+            current[key] = {};
+        }
+        current = current[key];
+    }
+    const finalKey = path[path.length - 1];
+    // 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, flagDefs) {
+    const missing = [];
+    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/dist/cli/runtime/body-flags.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cli/runtime/body-flags.test.js

@@ -0,0 +1,192 @@
+import { describe, expect, test } from "bun:test";
+import { findMissingRequired, generateBodyFlags, parseDotNotationFlags, } from "./body-flags.js";
+describe("generateBodyFlags", () => {
+    test("generates flags for simple properties", () => {
+        const flags = generateBodyFlags({
+            type: "object",
+            properties: {
+                name: { type: "string" },
+                age: { type: "integer" },
+                active: { type: "boolean" },
+            },
+            required: ["name"],
+        }, new Set());
+        expect(flags).toHaveLength(3);
+        expect(flags.find((f) => f.flag === "--name")).toEqual({
+            flag: "--name",
+            path: ["name"],
+            type: "string",
+            description: "Body field 'name'",
+            required: true,
+        });
+        expect(flags.find((f) => f.flag === "--age")).toEqual({
+            flag: "--age",
+            path: ["age"],
+            type: "integer",
+            description: "Body field 'age'",
+            required: false,
+        });
+    });
+    test("generates dot-notation flags for nested objects", () => {
+        const flags = generateBodyFlags({
+            type: "object",
+            properties: {
+                name: { type: "string" },
+                address: {
+                    type: "object",
+                    properties: {
+                        street: { type: "string" },
+                        city: { type: "string" },
+                        zip: { type: "string" },
+                    },
+                },
+            },
+        }, new Set());
+        expect(flags).toHaveLength(4);
+        expect(flags.find((f) => f.flag === "--name")).toBeDefined();
+        expect(flags.find((f) => f.flag === "--address.street")).toEqual({
+            flag: "--address.street",
+            path: ["address", "street"],
+            type: "string",
+            description: "Body field 'address.street'",
+            required: false,
+        });
+    });
+    test("handles deeply nested objects", () => {
+        const flags = generateBodyFlags({
+            type: "object",
+            properties: {
+                user: {
+                    type: "object",
+                    properties: {
+                        profile: {
+                            type: "object",
+                            properties: {
+                                bio: { type: "string" },
+                            },
+                        },
+                    },
+                },
+            },
+        }, new Set());
+        expect(flags.find((f) => f.flag === "--user.profile.bio")).toEqual({
+            flag: "--user.profile.bio",
+            path: ["user", "profile", "bio"],
+            type: "string",
+            description: "Body field 'user.profile.bio'",
+            required: false,
+        });
+    });
+    test("skips reserved flags", () => {
+        const flags = generateBodyFlags({
+            type: "object",
+            properties: {
+                name: { type: "string" },
+                data: { type: "string" }, // --data is reserved
+            },
+        }, new Set(["--data"]));
+        expect(flags).toHaveLength(1);
+        expect(flags[0]?.flag).toBe("--name");
+    });
+    test("skips --curl builtin flag", () => {
+        const reservedFlags = new Set(["--curl"]);
+        const flags = generateBodyFlags({
+            type: "object",
+            properties: {
+                name: { type: "string" },
+                curl: { type: "boolean" }, // conflicts with --curl builtin
+                email: { type: "string" }, // no conflict
+            },
+        }, reservedFlags);
+        expect(flags).toHaveLength(2);
+        expect(flags.map((f) => f.flag).sort()).toEqual(["--email", "--name"]);
+    });
+    test("uses description from schema", () => {
+        const flags = generateBodyFlags({
+            type: "object",
+            properties: {
+                email: { type: "string", description: "User email address" },
+            },
+        }, new Set());
+        expect(flags[0]?.description).toBe("User email address");
+    });
+});
+describe("parseDotNotationFlags", () => {
+    test("parses flat flags", () => {
+        const flagDefs = generateBodyFlags({
+            type: "object",
+            properties: {
+                name: { type: "string" },
+                age: { type: "integer" },
+            },
+        }, new Set());
+        const result = parseDotNotationFlags({ name: "Ada", age: "30" }, flagDefs);
+        expect(result).toEqual({
+            name: "Ada",
+            age: 30,
+        });
+    });
+    test("parses nested flags into objects", () => {
+        const flagDefs = generateBodyFlags({
+            type: "object",
+            properties: {
+                name: { type: "string" },
+                address: {
+                    type: "object",
+                    properties: {
+                        street: { type: "string" },
+                        city: { type: "string" },
+                    },
+                },
+            },
+        }, new Set());
+        // Commander keeps dots: --address.street -> "address.street"
+        const result = parseDotNotationFlags({
+            name: "Ada",
+            "address.street": "123 Main",
+            "address.city": "NYC",
+        }, flagDefs);
+        expect(result).toEqual({
+            name: "Ada",
+            address: {
+                street: "123 Main",
+                city: "NYC",
+            },
+        });
+    });
+    test("handles boolean flags", () => {
+        const flagDefs = generateBodyFlags({
+            type: "object",
+            properties: {
+                active: { type: "boolean" },
+            },
+        }, new Set());
+        const result = parseDotNotationFlags({ active: true }, flagDefs);
+        expect(result).toEqual({ active: true });
+    });
+});
+describe("findMissingRequired", () => {
+    test("finds missing required fields", () => {
+        const flagDefs = generateBodyFlags({
+            type: "object",
+            properties: {
+                name: { type: "string" },
+                email: { type: "string" },
+            },
+            required: ["name", "email"],
+        }, new Set());
+        const missing = findMissingRequired({ name: "Ada" }, flagDefs);
+        expect(missing).toEqual(["email"]);
+    });
+    test("returns empty when all required fields present", () => {
+        const flagDefs = generateBodyFlags({
+            type: "object",
+            properties: {
+                name: { type: "string" },
+            },
+            required: ["name"],
+        }, new Set());
+        const missing = findMissingRequired({ name: "Ada" }, flagDefs);
+        expect(missing).toEqual([]);
+    });
+});

package/dist/{src/cli → cli}/runtime/body.d.ts

@@ -12,4 +12,3 @@ export declare function loadBody(input: BodyInput): Promise<{
     json?: unknown;
 } | undefined>;
 export declare function parseBodyAsJsonOrYaml(text: string): unknown;
-//# sourceMappingURL=body.d.ts.map

package/dist/cli/runtime/body.js

@@ -0,0 +1,16 @@
+import { parseYamlContent, readFileText } from "./compat.js";
+export async function loadBody(input) {
+    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) {
+    const trimmed = text.trimStart();
+    if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
+        return JSON.parse(text);
+    }
+    return parseYamlContent(text);
+}

package/dist/{src/cli → cli}/runtime/collect.d.ts

@@ -1,2 +1 @@
 export declare function collectRepeatable(value: string, previous: string[] | undefined): string[];
-//# sourceMappingURL=collect.d.ts.map

package/dist/cli/runtime/collect.js

@@ -0,0 +1,3 @@
+export function collectRepeatable(value, previous) {
+    return [...(previous ?? []), value];
+}

package/dist/{src/cli → cli}/runtime/compat.d.ts

@@ -32,4 +32,3 @@ export declare function parseYamlContent(text: string): unknown;
  * Read from stdin - works in both Bun and Node.js
  */
 export declare function readStdinText(): Promise<string>;
-//# sourceMappingURL=compat.d.ts.map

package/dist/cli/runtime/compat.js

@@ -0,0 +1,78 @@
+/**
+ * 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) {
+    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) {
+    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, content) {
+    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) {
+    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) {
+    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() {
+    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/dist/{src/cli → cli}/runtime/context.d.ts

@@ -13,4 +13,3 @@ export declare function buildRuntimeContext(options: BuildRuntimeContextOptions)
     capabilities: import("../capabilities.js").Capabilities;
     schema: import("../schema.js").SchemaOutput;
 }>;
-//# sourceMappingURL=context.d.ts.map

package/dist/cli/runtime/context.js

@@ -0,0 +1,44 @@
+import { listAuthSchemes } from "../auth-schemes.js";
+import { deriveCapabilities } from "../capabilities.js";
+import { buildCommandsIndex } from "../command-index.js";
+import { buildCommandModel } from "../command-model.js";
+import { planOperations } from "../naming.js";
+import { indexOperations } from "../operations.js";
+import { buildSchemaOutput } from "../schema.js";
+import { listServers } from "../server.js";
+import { loadSpec } from "../spec-loader.js";
+export async function buildRuntimeContext(options) {
+    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/dist/{src/cli → cli}/runtime/execute.d.ts

@@ -30,4 +30,3 @@ export declare function execute(input: Omit<ExecuteInput, "resourceName">): Prom
  * This is the CLI-facing wrapper around execute().
  */
 export declare function executeAction(input: ExecuteInput): Promise<void>;
-//# sourceMappingURL=execute.d.ts.map