specli 0.0.21 → 0.0.22

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "specli",
-	"version": "0.0.21",
+	"version": "0.0.22",
 	"type": "module",
 	"module": "./dist/index.js",
 	"types": "./dist/index.d.ts",
@@ -17,7 +17,8 @@
 		"bin",
 		"dist",
 		"README.md",
-		"package.json"
+		"package.json",
+		"!**/*.test.*"
 	],
 	"scripts": {
 		"build": "tsc",

package/dist/ai/tools.test.d.ts

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

package/dist/ai/tools.test.js

@@ -1,49 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { specli } from "./tools.js";
-const mockOptions = {
-    toolCallId: "test-call-id",
-    abortSignal: new AbortController().signal,
-    messages: [],
-};
-describe("specli tool", () => {
-    test("creates a tool with correct structure", async () => {
-        const tool = await specli({
-            spec: "https://petstore3.swagger.io/api/v3/openapi.json",
-        });
-        expect(tool).toHaveProperty("description");
-        expect(tool).toHaveProperty("inputSchema");
-        expect(tool).toHaveProperty("execute");
-        expect(typeof tool.execute).toBe("function");
-    });
-    test("list command returns resources", async () => {
-        const tool = await specli({
-            spec: "https://petstore3.swagger.io/api/v3/openapi.json",
-        });
-        const result = (await tool.execute?.({ command: "list" }, mockOptions));
-        expect(result).toHaveProperty("resources");
-        expect(Array.isArray(result.resources)).toBe(true);
-    });
-    test("help command returns action details", async () => {
-        const tool = await specli({
-            spec: "https://petstore3.swagger.io/api/v3/openapi.json",
-        });
-        const result = (await tool.execute?.({ command: "help", resource: "pets", action: "get" }, mockOptions));
-        expect(result).toHaveProperty("action");
-        expect(result.action).toBe("get");
-    });
-    test("help command with missing resource returns error", async () => {
-        const tool = await specli({
-            spec: "https://petstore3.swagger.io/api/v3/openapi.json",
-        });
-        const result = (await tool.execute?.({ command: "help" }, mockOptions));
-        expect(result).toHaveProperty("error");
-    });
-    test("exec command with missing args returns error", async () => {
-        const tool = await specli({
-            spec: "https://petstore3.swagger.io/api/v3/openapi.json",
-        });
-        const result = (await tool.execute?.({ command: "exec", resource: "pets", action: "get" }, mockOptions));
-        expect(result).toHaveProperty("error");
-        expect(result.error).toContain("Missing args");
-    });
-});

package/dist/cli/model/capabilities.test.d.ts

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

package/dist/cli/model/capabilities.test.js

@@ -1,84 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { deriveCapabilities } from "./capabilities.js";
-describe("deriveCapabilities", () => {
-    test("reports requestBody + server vars", () => {
-        const doc = {
-            openapi: "3.0.3",
-            security: [{ bearerAuth: [] }],
-        };
-        const servers = [
-            {
-                url: "https://{region}.api.example.com",
-                variables: [],
-                variableNames: ["region"],
-            },
-        ];
-        const authSchemes = [
-            { key: "bearerAuth", kind: "http-bearer" },
-        ];
-        const operations = [
-            {
-                key: "POST /contacts",
-                method: "POST",
-                path: "/contacts",
-                tags: [],
-                parameters: [],
-                requestBody: {
-                    required: true,
-                    contentTypes: ["application/json"],
-                    schemasByContentType: { "application/json": { type: "object" } },
-                },
-            },
-        ];
-        const commands = {
-            resources: [
-                {
-                    resource: "contacts",
-                    actions: [
-                        {
-                            id: "x",
-                            key: "POST /contacts",
-                            action: "create",
-                            pathArgs: [],
-                            method: "POST",
-                            path: "/contacts",
-                            tags: [],
-                            style: "rest",
-                            positionals: [],
-                            flags: [],
-                            params: [],
-                            auth: { alternatives: [] },
-                            requestBody: {
-                                required: true,
-                                content: [
-                                    {
-                                        contentType: "application/json",
-                                        required: true,
-                                        schemaType: "object",
-                                    },
-                                ],
-                                hasJson: true,
-                                hasFormUrlEncoded: false,
-                                hasMultipart: false,
-                                bodyFlags: ["--data", "--file"],
-                                preferredContentType: "application/json",
-                            },
-                        },
-                    ],
-                },
-            ],
-        };
-        const caps = deriveCapabilities({
-            doc,
-            servers,
-            authSchemes,
-            operations,
-            commands,
-        });
-        expect(caps.servers.hasVariables).toBe(true);
-        expect(caps.operations.hasRequestBodies).toBe(true);
-        expect(caps.commands.hasRequestBodies).toBe(true);
-        expect(caps.auth.hasSecurityRequirements).toBe(true);
-        expect(caps.auth.kinds).toEqual(["http-bearer"]);
-    });
-});

package/dist/cli/model/command-id.test.d.ts

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

package/dist/cli/model/command-id.test.js

@@ -1,27 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { buildCommandId } from "./command-id.js";
-describe("buildCommandId", () => {
-    test("includes spec/resource/action/op", () => {
-        expect(buildCommandId({
-            specId: "contacts-api",
-            resource: "contacts",
-            action: "get",
-            operationKey: "GET /contacts/{id}",
-        })).toBe("contacts-api:contacts:get:get-contacts-id");
-    });
-    test("disambiguates by operationKey", () => {
-        const a = buildCommandId({
-            specId: "x",
-            resource: "contacts",
-            action: "list",
-            operationKey: "GET /contacts",
-        });
-        const b = buildCommandId({
-            specId: "x",
-            resource: "contacts",
-            action: "list",
-            operationKey: "GET /contacts/search",
-        });
-        expect(a).not.toBe(b);
-    });
-});

package/dist/cli/model/command-model.test.d.ts

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

package/dist/cli/model/command-model.test.js

@@ -1,40 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { buildCommandModel } from "./command-model.js";
-describe("buildCommandModel", () => {
-    test("groups operations by resource", () => {
-        const planned = [
-            {
-                key: "GET /contacts",
-                method: "GET",
-                path: "/contacts",
-                tags: ["Contacts"],
-                parameters: [],
-                resource: "contacts",
-                action: "list",
-                canonicalAction: "list",
-                pathArgs: [],
-                style: "rest",
-            },
-            {
-                key: "GET /contacts/{id}",
-                method: "GET",
-                path: "/contacts/{id}",
-                tags: ["Contacts"],
-                parameters: [],
-                resource: "contacts",
-                action: "get",
-                canonicalAction: "get",
-                pathArgs: ["id"],
-                style: "rest",
-            },
-        ];
-        const model = buildCommandModel(planned, { specId: "contacts-api" });
-        expect(model.resources).toHaveLength(1);
-        expect(model.resources[0]?.resource).toBe("contacts");
-        expect(model.resources[0]?.actions).toHaveLength(2);
-        expect(model.resources[0]?.actions.map((a) => a.action)).toEqual([
-            "get",
-            "list",
-        ]);
-    });
-});

package/dist/cli/model/naming.test.d.ts

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

package/dist/cli/model/naming.test.js

@@ -1,75 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { planOperation } from "./naming.js";
-describe("planOperation", () => {
-    test("REST: GET /contacts -> contacts list", () => {
-        const op = {
-            key: "GET /contacts",
-            method: "GET",
-            path: "/contacts",
-            operationId: "Contacts.List",
-            tags: ["Contacts"],
-            parameters: [],
-        };
-        const planned = planOperation(op);
-        expect(planned.style).toBe("rest");
-        expect(planned.resource).toBe("contacts");
-        expect(planned.action).toBe("list");
-        expect(planned.pathArgs).toEqual([]);
-    });
-    test("REST: singleton /ping stays ping and prefers operationId action", () => {
-        const op = {
-            key: "GET /ping",
-            method: "GET",
-            path: "/ping",
-            operationId: "Ping.Get",
-            tags: [],
-            parameters: [],
-        };
-        const planned = planOperation(op);
-        expect(planned.style).toBe("rest");
-        expect(planned.resource).toBe("ping");
-        expect(planned.action).toBe("get");
-    });
-    test("REST: singular path pluralizes to contacts", () => {
-        const op = {
-            key: "GET /contact/{id}",
-            method: "GET",
-            path: "/contact/{id}",
-            tags: [],
-            parameters: [],
-        };
-        const planned = planOperation(op);
-        expect(planned.style).toBe("rest");
-        expect(planned.resource).toBe("contacts");
-        expect(planned.action).toBe("get");
-        expect(planned.pathArgs).toEqual(["id"]);
-    });
-    test("RPC: POST /Contacts.List -> contacts list", () => {
-        const op = {
-            key: "POST /Contacts.List",
-            method: "POST",
-            path: "/Contacts.List",
-            operationId: "Contacts.List",
-            tags: [],
-            parameters: [],
-        };
-        const planned = planOperation(op);
-        expect(planned.style).toBe("rpc");
-        expect(planned.resource).toBe("contacts");
-        expect(planned.action).toBe("list");
-    });
-    test("RPC: Retrieve canonicalizes to get", () => {
-        const op = {
-            key: "POST /Contacts.Retrieve",
-            method: "POST",
-            path: "/Contacts.Retrieve",
-            operationId: "Contacts.Retrieve",
-            tags: [],
-            parameters: [],
-        };
-        const planned = planOperation(op);
-        expect(planned.style).toBe("rpc");
-        expect(planned.resource).toBe("contacts");
-        expect(planned.action).toBe("get");
-    });
-});

package/dist/cli/parse/auth-requirements.test.d.ts

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

package/dist/cli/parse/auth-requirements.test.js

@@ -1,16 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { summarizeAuth } from "./auth-requirements.js";
-describe("summarizeAuth", () => {
-    test("uses operation-level security when present", () => {
-        const schemes = [{ key: "oauth", kind: "oauth2" }];
-        const summary = summarizeAuth([{ oauth: ["read:ping"] }], [{ oauth: ["read:other"] }], schemes);
-        expect(summary.alternatives).toEqual([
-            [{ key: "oauth", scopes: ["read:ping"] }],
-        ]);
-    });
-    test("empty operation security disables auth", () => {
-        const schemes = [{ key: "oauth", kind: "oauth2" }];
-        const summary = summarizeAuth([], [{ oauth: ["read:other"] }], schemes);
-        expect(summary.alternatives).toEqual([]);
-    });
-});

package/dist/cli/parse/auth-schemes.test.d.ts

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

package/dist/cli/parse/auth-schemes.test.js

@@ -1,56 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { listAuthSchemes } from "./auth-schemes.js";
-describe("listAuthSchemes", () => {
-    test("parses bearer + apiKey", () => {
-        const doc = {
-            openapi: "3.0.3",
-            components: {
-                securitySchemes: {
-                    bearerAuth: {
-                        type: "http",
-                        scheme: "bearer",
-                        bearerFormat: "JWT",
-                    },
-                    apiKeyAuth: {
-                        type: "apiKey",
-                        in: "header",
-                        name: "X-API-Key",
-                    },
-                },
-            },
-        };
-        const schemes = listAuthSchemes(doc);
-        expect(schemes).toHaveLength(2);
-        const bearer = schemes.find((s) => s.key === "bearerAuth");
-        expect(bearer?.kind).toBe("http-bearer");
-        const apiKey = schemes.find((s) => s.key === "apiKeyAuth");
-        expect(apiKey?.kind).toBe("api-key");
-        expect(apiKey?.in).toBe("header");
-        expect(apiKey?.name).toBe("X-API-Key");
-    });
-    test("parses oauth2 flows", () => {
-        const doc = {
-            openapi: "3.0.3",
-            components: {
-                securitySchemes: {
-                    oauth: {
-                        type: "oauth2",
-                        flows: {
-                            clientCredentials: {
-                                tokenUrl: "https://example.com/oauth/token",
-                                scopes: {
-                                    "read:ping": "read ping",
-                                },
-                            },
-                        },
-                    },
-                },
-            },
-        };
-        const schemes = listAuthSchemes(doc);
-        const oauth = schemes.find((s) => s.key === "oauth");
-        expect(oauth?.kind).toBe("oauth2");
-        expect(oauth?.oauthFlows?.clientCredentials?.tokenUrl).toBe("https://example.com/oauth/token");
-        expect(oauth?.oauthFlows?.clientCredentials?.scopes).toEqual(["read:ping"]);
-    });
-});

package/dist/cli/parse/operations.test.d.ts

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

package/dist/cli/parse/operations.test.js

@@ -1,51 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { indexOperations } from "./operations.js";
-describe("indexOperations", () => {
-    test("indexes basic operations", () => {
-        const doc = {
-            openapi: "3.0.3",
-            paths: {
-                "/contacts": {
-                    get: {
-                        operationId: "Contacts.List",
-                        tags: ["Contacts"],
-                        parameters: [
-                            {
-                                in: "query",
-                                name: "limit",
-                                schema: { type: "integer" },
-                            },
-                        ],
-                    },
-                },
-                "/contacts/{id}": {
-                    get: {
-                        operationId: "Contacts.Get",
-                        tags: ["Contacts"],
-                        parameters: [
-                            {
-                                in: "path",
-                                name: "id",
-                                required: true,
-                                schema: { type: "string" },
-                            },
-                        ],
-                    },
-                },
-            },
-        };
-        const ops = indexOperations(doc);
-        expect(ops).toHaveLength(2);
-        expect(ops[0]?.key).toBe("GET /contacts");
-        expect(ops[0]?.path).toBe("/contacts");
-        expect(ops[0]?.method).toBe("GET");
-        expect(ops[0]?.parameters).toHaveLength(1);
-        expect(ops[0]?.parameters[0]?.in).toBe("query");
-        expect(ops[1]?.key).toBe("GET /contacts/{id}");
-        expect(ops[1]?.path).toBe("/contacts/{id}");
-        expect(ops[1]?.method).toBe("GET");
-        expect(ops[1]?.parameters).toHaveLength(1);
-        expect(ops[1]?.parameters[0]?.in).toBe("path");
-        expect(ops[1]?.parameters[0]?.required).toBe(true);
-    });
-});

package/dist/cli/parse/params.test.d.ts

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

package/dist/cli/parse/params.test.js

@@ -1,62 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { deriveParamSpecs } from "./params.js";
-describe("deriveParamSpecs", () => {
-    test("derives basic types + flags", () => {
-        const op = {
-            key: "GET /contacts",
-            method: "GET",
-            path: "/contacts",
-            tags: [],
-            parameters: [
-                {
-                    in: "query",
-                    name: "limit",
-                    required: false,
-                    schema: {
-                        type: "integer",
-                        format: "int32",
-                        enum: ["1", "2"],
-                    },
-                },
-                {
-                    in: "header",
-                    name: "X-Request-Id",
-                    required: false,
-                    schema: { type: "string" },
-                },
-            ],
-        };
-        const specs = deriveParamSpecs(op);
-        expect(specs).toHaveLength(2);
-        const limit = specs.find((p) => p.name === "limit");
-        expect(limit?.kind).toBe("flag");
-        expect(limit?.flag).toBe("--limit");
-        expect(limit?.type).toBe("integer");
-        expect(limit?.format).toBe("int32");
-        expect(limit?.enum).toEqual(["1", "2"]);
-        const reqId = specs.find((p) => p.name === "X-Request-Id");
-        expect(reqId?.kind).toBe("flag");
-        expect(reqId?.flag).toBe("--x-request-id");
-        expect(reqId?.type).toBe("string");
-    });
-    test("derives array item types", () => {
-        const op = {
-            key: "GET /things",
-            method: "GET",
-            path: "/things",
-            tags: [],
-            parameters: [
-                {
-                    in: "query",
-                    name: "ids",
-                    required: false,
-                    schema: { type: "array", items: { type: "integer" } },
-                },
-            ],
-        };
-        const specs = deriveParamSpecs(op);
-        expect(specs).toHaveLength(1);
-        expect(specs[0]?.type).toBe("array");
-        expect(specs[0]?.itemType).toBe("integer");
-    });
-});

package/dist/cli/parse/positional.test.d.ts

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

package/dist/cli/parse/positional.test.js

@@ -1,60 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { deriveFlags, derivePositionals } from "./positional.js";
-describe("derivePositionals", () => {
-    test("returns ordered positionals from pathArgs", () => {
-        const action = {
-            pathArgs: ["id"],
-            params: [
-                {
-                    kind: "positional",
-                    in: "path",
-                    name: "id",
-                    flag: "--id",
-                    required: true,
-                    type: "string",
-                },
-            ],
-        };
-        const pos = derivePositionals(action);
-        expect(pos).toEqual([
-            {
-                name: "id",
-                required: true,
-                type: "string",
-                format: undefined,
-                enum: undefined,
-                description: undefined,
-            },
-        ]);
-    });
-});
-describe("deriveFlags", () => {
-    test("returns only flag params", () => {
-        const action = {
-            pathArgs: [],
-            params: [
-                {
-                    kind: "flag",
-                    in: "query",
-                    name: "limit",
-                    flag: "--limit",
-                    required: false,
-                    type: "integer",
-                },
-            ],
-        };
-        const flags = deriveFlags(action);
-        expect(flags.flags).toEqual([
-            {
-                in: "query",
-                name: "limit",
-                flag: "--limit",
-                required: false,
-                description: undefined,
-                type: "integer",
-                format: undefined,
-                enum: undefined,
-            },
-        ]);
-    });
-});

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

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

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

@@ -1,31 +0,0 @@
-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/cli/parse/servers.test.d.ts

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

package/dist/cli/parse/servers.test.js

@@ -1,49 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { listServers } from "./servers.js";
-describe("listServers", () => {
-    test("extracts server variables from template", () => {
-        const doc = {
-            openapi: "3.0.3",
-            servers: [
-                {
-                    url: "https://{region}.api.example.com/{basePath}",
-                    variables: {
-                        region: {
-                            default: "us",
-                            enum: ["us", "eu"],
-                        },
-                        basePath: {
-                            default: "v1",
-                        },
-                    },
-                },
-            ],
-        };
-        const servers = listServers(doc);
-        expect(servers).toHaveLength(1);
-        expect(servers[0]?.variableNames).toEqual(["region", "basePath"]);
-        expect(servers[0]?.variables.map((v) => v.name)).toEqual([
-            "region",
-            "basePath",
-        ]);
-        expect(servers[0]?.variables[0]?.enum).toEqual(["us", "eu"]);
-    });
-    test("includes servers defined on paths and operations", () => {
-        const doc = {
-            openapi: "3.0.3",
-            paths: {
-                "/v1/forecast": {
-                    servers: [{ url: "https://api.a.example.com" }],
-                    get: {
-                        servers: [{ url: "https://api.b.example.com" }],
-                    },
-                },
-            },
-        };
-        const servers = listServers(doc);
-        expect(servers.map((s) => s.url)).toEqual([
-            "https://api.a.example.com",
-            "https://api.b.example.com",
-        ]);
-    });
-});

package/dist/cli/runtime/body-flags.test.d.ts

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

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

@@ -1,192 +0,0 @@
-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/cli/runtime/request.test.d.ts

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

package/dist/cli/runtime/request.test.js

@@ -1,332 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { tmpdir } from "node:os";
-import { generateBodyFlags } from "./body-flags.js";
-import { buildRequest } from "./request.js";
-import { createAjv, formatAjvErrors } from "./validate/index.js";
-function makeAction(partial) {
-    return {
-        id: "test",
-        key: "POST /contacts",
-        action: "create",
-        pathArgs: [],
-        method: "POST",
-        path: "/contacts",
-        tags: [],
-        style: "rest",
-        positionals: [],
-        flags: [],
-        params: [],
-        auth: { alternatives: [] },
-        requestBody: {
-            required: true,
-            content: [
-                {
-                    contentType: "application/json",
-                    required: true,
-                    schemaType: "object",
-                },
-            ],
-            hasJson: true,
-            hasFormUrlEncoded: false,
-            hasMultipart: false,
-            bodyFlags: ["--data", "--file"],
-            preferredContentType: "application/json",
-            preferredSchema: undefined,
-        },
-        requestBodySchema: {
-            type: "object",
-            properties: {
-                name: { type: "string" },
-            },
-            required: ["name"],
-        },
-        ...partial,
-    };
-}
-describe("buildRequest (requestBody)", () => {
-    test("builds body from expanded body flags", async () => {
-        const prevHome = process.env.HOME;
-        const home = `${tmpdir()}/specli-test-${crypto.randomUUID()}`;
-        process.env.HOME = home;
-        try {
-            const action = makeAction();
-            const bodyFlagDefs = generateBodyFlags(action.requestBodySchema, new Set());
-            const { request, curl } = await buildRequest({
-                specId: "spec",
-                action,
-                positionalValues: [],
-                flagValues: { name: "A" }, // --name A
-                globals: {},
-                servers: [
-                    { url: "https://api.example.com", variables: [], variableNames: [] },
-                ],
-                authSchemes: [],
-                bodyFlagDefs,
-            });
-            expect(request.headers.get("Content-Type")).toBe("application/json");
-            expect(await request.clone().text()).toBe('{"name":"A"}');
-            expect(curl).toContain("--data");
-            expect(curl).toContain('{"name":"A"}');
-        }
-        finally {
-            process.env.HOME = prevHome;
-        }
-    });
-    test("throws when requestBody is required but missing", async () => {
-        const prevHome = process.env.HOME;
-        const home = `${tmpdir()}/specli-test-${crypto.randomUUID()}`;
-        process.env.HOME = home;
-        try {
-            const action = makeAction();
-            const bodyFlagDefs = generateBodyFlags(action.requestBodySchema, new Set());
-            await expect(() => buildRequest({
-                specId: "spec",
-                action,
-                positionalValues: [],
-                flagValues: {},
-                globals: {},
-                servers: [
-                    {
-                        url: "https://api.example.com",
-                        variables: [],
-                        variableNames: [],
-                    },
-                ],
-                authSchemes: [],
-                bodyFlagDefs,
-            })).toThrow("Required: --name");
-        }
-        finally {
-            process.env.HOME = prevHome;
-        }
-    });
-    test("throws friendly error for missing required expanded field", async () => {
-        const prevHome = process.env.HOME;
-        const home = `${tmpdir()}/specli-test-${crypto.randomUUID()}`;
-        process.env.HOME = home;
-        try {
-            // Schema with two fields, one required
-            const action = makeAction({
-                requestBodySchema: {
-                    type: "object",
-                    properties: {
-                        name: { type: "string" },
-                        email: { type: "string" },
-                    },
-                    required: ["name"],
-                },
-            });
-            const bodyFlagDefs = generateBodyFlags(action.requestBodySchema, new Set());
-            // Provide email but not name (the required one)
-            await expect(() => buildRequest({
-                specId: "spec",
-                action,
-                positionalValues: [],
-                flagValues: { email: "test@example.com" }, // --email (but missing --name)
-                globals: {},
-                servers: [
-                    {
-                        url: "https://api.example.com",
-                        variables: [],
-                        variableNames: [],
-                    },
-                ],
-                authSchemes: [],
-                bodyFlagDefs,
-            })).toThrow("Missing required fields: --name");
-        }
-        finally {
-            process.env.HOME = prevHome;
-        }
-    });
-    test("builds nested object from dot notation flags", async () => {
-        const prevHome = process.env.HOME;
-        const home = `${tmpdir()}/specli-test-${crypto.randomUUID()}`;
-        process.env.HOME = home;
-        try {
-            const action = makeAction({
-                requestBodySchema: {
-                    type: "object",
-                    properties: {
-                        name: { type: "string" },
-                        address: {
-                            type: "object",
-                            properties: {
-                                street: { type: "string" },
-                                city: { type: "string" },
-                            },
-                        },
-                    },
-                    required: ["name"],
-                },
-            });
-            const bodyFlagDefs = generateBodyFlags(action.requestBodySchema, new Set());
-            // Dot notation: --address.street and --address.city should create nested object
-            const { request } = await buildRequest({
-                specId: "spec",
-                action,
-                positionalValues: [],
-                flagValues: {
-                    name: "Ada",
-                    "address.street": "123 Main St", // Commander keeps dots in keys
-                    "address.city": "NYC",
-                },
-                globals: {},
-                servers: [
-                    { url: "https://api.example.com", variables: [], variableNames: [] },
-                ],
-                authSchemes: [],
-                bodyFlagDefs,
-            });
-            const body = JSON.parse(await request.clone().text());
-            expect(body).toEqual({
-                name: "Ada",
-                address: {
-                    street: "123 Main St",
-                    city: "NYC",
-                },
-            });
-        }
-        finally {
-            process.env.HOME = prevHome;
-        }
-    });
-});
-describe("buildRequest (query parameters)", () => {
-    test("builds query string from flag values", async () => {
-        const prevHome = process.env.HOME;
-        const home = `${tmpdir()}/specli-test-${crypto.randomUUID()}`;
-        process.env.HOME = home;
-        try {
-            const action = {
-                id: "test",
-                key: "GET /contacts",
-                action: "list",
-                pathArgs: [],
-                method: "GET",
-                path: "/contacts",
-                tags: [],
-                style: "rest",
-                positionals: [],
-                flags: [
-                    {
-                        flag: "--limit",
-                        name: "limit",
-                        in: "query",
-                        type: "integer",
-                        required: false,
-                    },
-                    {
-                        flag: "--name",
-                        name: "name",
-                        in: "query",
-                        type: "string",
-                        required: false,
-                    },
-                ],
-                params: [
-                    {
-                        kind: "flag",
-                        flag: "--limit",
-                        name: "limit",
-                        in: "query",
-                        required: false,
-                        type: "integer",
-                    },
-                    {
-                        kind: "flag",
-                        flag: "--name",
-                        name: "name",
-                        in: "query",
-                        required: false,
-                        type: "string",
-                    },
-                ],
-                auth: { alternatives: [] },
-            };
-            const { request } = await buildRequest({
-                specId: "spec",
-                action,
-                positionalValues: [],
-                flagValues: { limit: 10, name: "andrew" },
-                globals: {},
-                servers: [
-                    { url: "https://api.example.com", variables: [], variableNames: [] },
-                ],
-                authSchemes: [],
-            });
-            expect(request.method).toBe("GET");
-            expect(request.url).toBe("https://api.example.com/contacts?limit=10&name=andrew");
-        }
-        finally {
-            process.env.HOME = prevHome;
-        }
-    });
-    test("handles array query parameters", async () => {
-        const prevHome = process.env.HOME;
-        const home = `${tmpdir()}/specli-test-${crypto.randomUUID()}`;
-        process.env.HOME = home;
-        try {
-            const action = {
-                id: "test",
-                key: "GET /contacts",
-                action: "list",
-                pathArgs: [],
-                method: "GET",
-                path: "/contacts",
-                tags: [],
-                style: "rest",
-                positionals: [],
-                flags: [
-                    {
-                        flag: "--tag",
-                        name: "tag",
-                        in: "query",
-                        type: "array",
-                        itemType: "string",
-                        required: false,
-                    },
-                ],
-                params: [
-                    {
-                        kind: "flag",
-                        flag: "--tag",
-                        name: "tag",
-                        in: "query",
-                        required: false,
-                        type: "array",
-                    },
-                ],
-                auth: { alternatives: [] },
-            };
-            const { request } = await buildRequest({
-                specId: "spec",
-                action,
-                positionalValues: [],
-                flagValues: { tag: ["vip", "active"] },
-                globals: {},
-                servers: [
-                    { url: "https://api.example.com", variables: [], variableNames: [] },
-                ],
-                authSchemes: [],
-            });
-            expect(request.url).toBe("https://api.example.com/contacts?tag=vip&tag=active");
-        }
-        finally {
-            process.env.HOME = prevHome;
-        }
-    });
-});
-describe("formatAjvErrors", () => {
-    test("pretty prints required errors", () => {
-        const ajv = createAjv();
-        const validate = ajv.compile({
-            type: "object",
-            properties: { name: { type: "string" } },
-            required: ["name"],
-        });
-        validate({});
-        const msg = formatAjvErrors(validate.errors);
-        expect(msg).toBe("/ missing required property 'name'");
-    });
-});

package/dist/cli/runtime/validate/coerce.test.d.ts

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

package/dist/cli/runtime/validate/coerce.test.js

@@ -1,75 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { coerceArrayInput, coerceValue } from "./coerce.js";
-describe("coerceValue", () => {
-    test("returns string as-is for string type", () => {
-        expect(coerceValue("hello", "string")).toBe("hello");
-    });
-    test("returns string as-is for unknown type", () => {
-        expect(coerceValue("hello", "unknown")).toBe("hello");
-    });
-    test("parses integer type", () => {
-        expect(coerceValue("42", "integer")).toBe(42);
-        expect(coerceValue("-10", "integer")).toBe(-10);
-        expect(coerceValue("0", "integer")).toBe(0);
-    });
-    test("throws for invalid integer", () => {
-        expect(() => coerceValue("abc", "integer")).toThrow("Expected integer");
-    });
-    test("truncates decimal for integer type (parseInt behavior)", () => {
-        // parseInt("12.5", 10) returns 12 - this is expected JS behavior
-        expect(coerceValue("12.5", "integer")).toBe(12);
-    });
-    test("parses number type", () => {
-        expect(coerceValue("42", "number")).toBe(42);
-        expect(coerceValue("3.14", "number")).toBe(3.14);
-        expect(coerceValue("-0.5", "number")).toBe(-0.5);
-    });
-    test("throws for invalid number", () => {
-        expect(() => coerceValue("abc", "number")).toThrow("Expected number");
-    });
-    test("parses boolean type", () => {
-        expect(coerceValue("true", "boolean")).toBe(true);
-        expect(coerceValue("false", "boolean")).toBe(false);
-    });
-    test("throws for invalid boolean", () => {
-        expect(() => coerceValue("yes", "boolean")).toThrow("Expected boolean");
-        expect(() => coerceValue("1", "boolean")).toThrow("Expected boolean");
-    });
-    test("parses object type as JSON", () => {
-        expect(coerceValue('{"a":1}', "object")).toEqual({ a: 1 });
-    });
-    test("throws for invalid object JSON", () => {
-        expect(() => coerceValue("not json", "object")).toThrow("Expected JSON object");
-    });
-});
-describe("coerceArrayInput", () => {
-    test("parses comma-separated values", () => {
-        expect(coerceArrayInput("a,b,c", "string")).toEqual(["a", "b", "c"]);
-    });
-    test("trims whitespace in comma-separated values", () => {
-        expect(coerceArrayInput("a, b, c", "string")).toEqual(["a", "b", "c"]);
-    });
-    test("parses JSON array", () => {
-        expect(coerceArrayInput('["a","b","c"]', "string")).toEqual([
-            "a",
-            "b",
-            "c",
-        ]);
-    });
-    test("coerces array items to specified type", () => {
-        expect(coerceArrayInput("1,2,3", "integer")).toEqual([1, 2, 3]);
-        expect(coerceArrayInput('["1","2","3"]', "integer")).toEqual([1, 2, 3]);
-    });
-    test("returns empty array for empty string", () => {
-        expect(coerceArrayInput("", "string")).toEqual([]);
-        expect(coerceArrayInput("   ", "string")).toEqual([]);
-    });
-    test("throws for invalid JSON array", () => {
-        expect(() => coerceArrayInput("[invalid", "string")).toThrow("Expected JSON array");
-    });
-    test("treats non-array JSON as comma-separated string", () => {
-        // If it doesn't start with '[', it's treated as comma-separated
-        // '{"a":1}' doesn't start with '[', so it's treated as a single value
-        expect(coerceArrayInput('{"a":1}', "string")).toEqual(['{"a":1}']);
-    });
-});