specli 0.0.11 → 0.0.13

package/dist/cli/runtime/validate/ajv.js

@@ -0,0 +1,11 @@
+import { Ajv } from "ajv";
+import addFormats from "ajv-formats";
+export function createAjv() {
+    const ajv = new Ajv({
+        allErrors: true,
+        strict: false,
+        coerceTypes: false,
+    });
+    addFormats.default(ajv);
+    return ajv;
+}

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

@@ -1,4 +1,3 @@
 import type { ParamType } from "../../schema-shape.js";
 export declare function coerceValue(raw: string, type: ParamType): unknown;
 export declare function coerceArrayInput(raw: string, itemType: ParamType): unknown[];
-//# sourceMappingURL=coerce.d.ts.map

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

@@ -0,0 +1,63 @@
+import { InvalidArgumentError } from "commander";
+export function coerceValue(raw, type) {
+    if (type === "string" || type === "unknown")
+        return raw;
+    if (type === "boolean") {
+        // Commander boolean options are handled without a value; keep for completeness.
+        if (raw === "true")
+            return true;
+        if (raw === "false")
+            return false;
+        throw new InvalidArgumentError(`Expected boolean, got '${raw}'`);
+    }
+    if (type === "integer") {
+        const n = Number.parseInt(raw, 10);
+        if (!Number.isFinite(n))
+            throw new InvalidArgumentError(`Expected integer, got '${raw}'`);
+        return n;
+    }
+    if (type === "number") {
+        const n = Number(raw);
+        if (!Number.isFinite(n))
+            throw new InvalidArgumentError(`Expected number, got '${raw}'`);
+        return n;
+    }
+    // For now, accept objects as JSON strings.
+    if (type === "object") {
+        try {
+            return JSON.parse(raw);
+        }
+        catch {
+            throw new InvalidArgumentError(`Expected JSON object, got '${raw}'. Use --data/--file for complex bodies.`);
+        }
+    }
+    // Arrays should usually be passed as repeatable flags or comma-separated,
+    // but allow JSON arrays too.
+    if (type === "array") {
+        return coerceArrayInput(raw, "string");
+    }
+    return raw;
+}
+export function coerceArrayInput(raw, itemType) {
+    const trimmed = raw.trim();
+    if (!trimmed)
+        return [];
+    if (trimmed.startsWith("[")) {
+        let parsed;
+        try {
+            parsed = JSON.parse(trimmed);
+        }
+        catch {
+            throw new InvalidArgumentError(`Expected JSON array, got '${raw}'`);
+        }
+        if (!Array.isArray(parsed)) {
+            throw new InvalidArgumentError(`Expected JSON array, got '${raw}'`);
+        }
+        return parsed.map((v) => coerceValue(String(v), itemType));
+    }
+    return trimmed
+        .split(",")
+        .map((s) => s.trim())
+        .filter(Boolean)
+        .map((s) => coerceValue(s, itemType));
+}

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

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

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

@@ -0,0 +1,75 @@
+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}']);
+    });
+});

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

@@ -1,3 +1,2 @@
 import type { ErrorObject } from "ajv";
 export declare function formatAjvErrors(errors: ErrorObject[] | null | undefined): string;
-//# sourceMappingURL=error.d.ts.map

package/dist/cli/runtime/validate/error.js

@@ -0,0 +1,19 @@
+export function formatAjvErrors(errors) {
+    if (!errors?.length)
+        return "Invalid input";
+    return errors
+        .map((e) => {
+        const path = e.instancePath || e.schemaPath || "";
+        if (e.keyword === "required" &&
+            e.params &&
+            typeof e.params === "object" &&
+            "missingProperty" in e.params) {
+            const missing = String(e.params.missingProperty);
+            const where = e.instancePath || "/";
+            return `${where} missing required property '${missing}'`.trim();
+        }
+        const msg = e.message || "invalid";
+        return `${path} ${msg}`.trim();
+    })
+        .join("\n");
+}

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

@@ -2,4 +2,3 @@ export * from "./ajv.js";
 export * from "./coerce.js";
 export * from "./error.js";
 export * from "./schema.js";
-//# sourceMappingURL=index.d.ts.map

package/dist/cli/runtime/validate/index.js

@@ -0,0 +1,4 @@
+export * from "./ajv.js";
+export * from "./coerce.js";
+export * from "./error.js";
+export * from "./schema.js";

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

@@ -6,4 +6,3 @@ export type ValidationSchemas = {
     cookieSchema?: JsonSchema;
 };
 export declare function deriveValidationSchemas(action: CommandAction): ValidationSchemas;
-//# sourceMappingURL=schema.d.ts.map

package/dist/cli/runtime/validate/schema.js

@@ -0,0 +1,38 @@
+export function deriveValidationSchemas(action) {
+    // We validate only simple containers for now.
+    // Deep style/encoding differences for OpenAPI params are out of scope for v1.
+    const query = { type: "object", properties: {}, required: [] };
+    const header = { type: "object", properties: {}, required: [] };
+    const cookie = { type: "object", properties: {}, required: [] };
+    for (const p of action.params) {
+        if (p.kind !== "flag")
+            continue;
+        const target = p.in === "query"
+            ? query
+            : p.in === "header"
+                ? header
+                : p.in === "cookie"
+                    ? cookie
+                    : undefined;
+        if (!target)
+            continue;
+        const schema = p.schema ?? (p.type === "unknown" ? {} : { type: p.type });
+        target.properties[p.name] = schema;
+        if (p.required) {
+            if (!target.required)
+                target.required = [];
+            target.required.push(p.name);
+        }
+    }
+    if (!query.required?.length)
+        delete query.required;
+    if (!header.required?.length)
+        delete header.required;
+    if (!cookie.required?.length)
+        delete cookie.required;
+    return {
+        querySchema: Object.keys(query.properties).length ? query : undefined,
+        headerSchema: Object.keys(header.properties).length ? header : undefined,
+        cookieSchema: Object.keys(cookie.properties).length ? cookie : undefined,
+    };
+}

package/dist/{src/cli → cli}/schema-shape.d.ts

@@ -2,4 +2,3 @@ export type ParamType = "string" | "number" | "integer" | "boolean" | "array" |
 export declare function getSchemaType(schema: unknown): ParamType;
 export declare function getSchemaFormat(schema: unknown): string | undefined;
 export declare function getSchemaEnumStrings(schema: unknown): string[] | undefined;
-//# sourceMappingURL=schema-shape.d.ts.map

package/dist/cli/schema-shape.js

@@ -0,0 +1,34 @@
+export function getSchemaType(schema) {
+    if (!schema || typeof schema !== "object")
+        return "unknown";
+    const t = schema.type;
+    if (t === "string")
+        return "string";
+    if (t === "number")
+        return "number";
+    if (t === "integer")
+        return "integer";
+    if (t === "boolean")
+        return "boolean";
+    if (t === "array")
+        return "array";
+    if (t === "object")
+        return "object";
+    return "unknown";
+}
+export function getSchemaFormat(schema) {
+    if (!schema || typeof schema !== "object")
+        return undefined;
+    const f = schema.format;
+    return typeof f === "string" ? f : undefined;
+}
+export function getSchemaEnumStrings(schema) {
+    if (!schema || typeof schema !== "object")
+        return undefined;
+    const e = schema.enum;
+    if (!Array.isArray(e))
+        return undefined;
+    // We only surface string enums for now (enough for flag docs + completion).
+    const values = e.filter((v) => typeof v === "string");
+    return values.length ? values : undefined;
+}

package/dist/{src/cli → cli}/schema.d.ts

@@ -27,4 +27,3 @@ export type SchemaOutput = {
 export type MinimalSchemaOutput = Pick<SchemaOutput, "schemaVersion" | "openapi" | "spec" | "capabilities" | "commands">;
 export declare function buildSchemaOutput(loaded: LoadedSpec, operations: NormalizedOperation[], planned: PlannedOperation[] | undefined, servers: ServerInfo[], authSchemes: AuthScheme[], commands: CommandModel | undefined, commandsIndex: import("./command-index.js").CommandsIndex | undefined, capabilities: Capabilities): SchemaOutput;
 export declare function toMinimalSchemaOutput(output: SchemaOutput): MinimalSchemaOutput;
-//# sourceMappingURL=schema.d.ts.map

package/dist/cli/schema.js

@@ -0,0 +1,31 @@
+export function buildSchemaOutput(loaded, operations, planned, servers, authSchemes, commands, commandsIndex, capabilities) {
+    return {
+        schemaVersion: 1,
+        openapi: {
+            version: loaded.doc.openapi,
+            title: loaded.doc.info?.title,
+            infoVersion: loaded.doc.info?.version,
+        },
+        spec: {
+            id: loaded.id,
+            fingerprint: loaded.fingerprint,
+            source: loaded.source,
+        },
+        capabilities,
+        servers,
+        authSchemes,
+        operations,
+        planned,
+        commands,
+        commandsIndex,
+    };
+}
+export function toMinimalSchemaOutput(output) {
+    return {
+        schemaVersion: output.schemaVersion,
+        openapi: output.openapi,
+        spec: output.spec,
+        capabilities: output.capabilities,
+        commands: output.commands,
+    };
+}

package/dist/{src/cli → cli}/server.d.ts

@@ -13,4 +13,3 @@ export type ServerInfo = {
 };
 export declare function listServers(doc: OpenApiDoc): ServerInfo[];
 export declare function getDefaultServerUrl(doc: OpenApiDoc): string | undefined;
-//# sourceMappingURL=server.d.ts.map

package/dist/cli/server.js

@@ -0,0 +1,130 @@
+import { getSchemaEnumStrings } from "./schema-shape.js";
+const HTTP_METHODS = [
+    "get",
+    "post",
+    "put",
+    "patch",
+    "delete",
+    "options",
+    "head",
+    "trace",
+];
+function extractVariableNames(url) {
+    const names = [];
+    const re = /\{([^}]+)\}/g;
+    while (true) {
+        const match = re.exec(url);
+        if (!match)
+            break;
+        names.push(match[1] ?? "");
+    }
+    return names.map((n) => n.trim()).filter(Boolean);
+}
+function parseServer(raw) {
+    const s = raw;
+    if (!s || typeof s !== "object")
+        return undefined;
+    if (typeof s.url !== "string")
+        return undefined;
+    const variableNames = extractVariableNames(s.url);
+    const variables = [];
+    const rawVars = s.variables &&
+        typeof s.variables === "object" &&
+        !Array.isArray(s.variables)
+        ? s.variables
+        : {};
+    for (const name of variableNames) {
+        const v = rawVars[name];
+        const def = v?.default;
+        const desc = v?.description;
+        variables.push({
+            name,
+            default: typeof def === "string" ? def : undefined,
+            enum: getSchemaEnumStrings(v),
+            description: typeof desc === "string" ? desc : undefined,
+        });
+    }
+    return {
+        url: s.url,
+        description: typeof s.description === "string" ? s.description : undefined,
+        variables,
+        variableNames,
+    };
+}
+function mergeServers(a, b) {
+    const variableNames = [...a.variableNames];
+    for (const n of b.variableNames) {
+        if (!variableNames.includes(n))
+            variableNames.push(n);
+    }
+    const byName = new Map();
+    for (const v of a.variables)
+        byName.set(v.name, { ...v });
+    for (const v of b.variables) {
+        const existing = byName.get(v.name);
+        if (!existing) {
+            byName.set(v.name, { ...v });
+            continue;
+        }
+        byName.set(v.name, {
+            name: v.name,
+            default: existing.default ?? v.default,
+            enum: existing.enum ?? v.enum,
+            description: existing.description ?? v.description,
+        });
+    }
+    return {
+        url: a.url,
+        description: a.description ?? b.description,
+        variableNames,
+        variables: variableNames
+            .map((n) => byName.get(n))
+            .filter(Boolean),
+    };
+}
+export function listServers(doc) {
+    const rawServers = [];
+    // OpenAPI 3.x allows servers at the root, per-path-item, and per-operation.
+    if (Array.isArray(doc.servers))
+        rawServers.push(...doc.servers);
+    const paths = doc.paths;
+    if (paths && typeof paths === "object" && !Array.isArray(paths)) {
+        for (const rawPathItem of Object.values(paths)) {
+            if (!rawPathItem || typeof rawPathItem !== "object")
+                continue;
+            const pathItem = rawPathItem;
+            if (Array.isArray(pathItem.servers))
+                rawServers.push(...pathItem.servers);
+            for (const method of HTTP_METHODS) {
+                const op = pathItem[method];
+                if (!op || typeof op !== "object")
+                    continue;
+                const opObj = op;
+                if (Array.isArray(opObj.servers))
+                    rawServers.push(...opObj.servers);
+            }
+        }
+    }
+    const out = [];
+    const byUrl = new Map();
+    for (const raw of rawServers) {
+        const parsed = parseServer(raw);
+        if (!parsed)
+            continue;
+        const existing = byUrl.get(parsed.url);
+        if (!existing) {
+            byUrl.set(parsed.url, parsed);
+            out.push(parsed);
+            continue;
+        }
+        const merged = mergeServers(existing, parsed);
+        byUrl.set(parsed.url, merged);
+        const idx = out.findIndex((s) => s.url === parsed.url);
+        if (idx !== -1)
+            out[idx] = merged;
+    }
+    return out;
+}
+export function getDefaultServerUrl(doc) {
+    return listServers(doc)[0]?.url;
+}

package/dist/cli/server.test.d.ts

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

package/dist/cli/server.test.js

@@ -0,0 +1,49 @@
+import { describe, expect, test } from "bun:test";
+import { listServers } from "./server.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/{src/cli → cli}/spec-id.d.ts

@@ -1,3 +1,2 @@
 import type { LoadedSpec } from "./types.js";
 export declare function getSpecId(loaded: Pick<LoadedSpec, "doc" | "fingerprint">): string;
-//# sourceMappingURL=spec-id.d.ts.map

package/dist/cli/spec-id.js

@@ -0,0 +1,8 @@
+import { kebabCase } from "./strings.js";
+export function getSpecId(loaded) {
+    const title = loaded.doc.info?.title;
+    const fromTitle = title ? kebabCase(title) : "";
+    if (fromTitle)
+        return fromTitle;
+    return loaded.fingerprint.slice(0, 12);
+}

package/dist/{src/cli → cli}/spec-loader.d.ts

@@ -4,4 +4,3 @@ export type LoadSpecOptions = {
     embeddedSpecText?: string;
 };
 export declare function loadSpec(options: LoadSpecOptions): Promise<LoadedSpec>;
-//# sourceMappingURL=spec-loader.d.ts.map

package/dist/cli/spec-loader.js

@@ -0,0 +1,40 @@
+import SwaggerParser from "@apidevtools/swagger-parser";
+import { sha256Hex } from "./crypto.js";
+import { parseYamlContent } from "./runtime/compat.js";
+import { getSpecId } from "./spec-id.js";
+import { stableStringify } from "./stable-json.js";
+function isProbablyUrl(input) {
+    return /^https?:\/\//i.test(input);
+}
+function parseSpecText(text) {
+    const trimmed = text.trimStart();
+    if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
+        return JSON.parse(text);
+    }
+    return parseYamlContent(text);
+}
+export async function loadSpec(options) {
+    const { spec, embeddedSpecText } = options;
+    let source;
+    let inputForParser;
+    if (typeof embeddedSpecText === "string") {
+        source = "embedded";
+        inputForParser = parseSpecText(embeddedSpecText);
+    }
+    else if (spec) {
+        source = isProbablyUrl(spec) ? "url" : "file";
+        inputForParser = spec;
+    }
+    else {
+        throw new Error("Missing spec. Provide --spec <url|path> or build with an embedded spec.");
+    }
+    const doc = (await SwaggerParser.dereference(
+    // biome-ignore lint/suspicious/noExplicitAny: unknown
+    inputForParser));
+    if (!doc || typeof doc !== "object" || typeof doc.openapi !== "string") {
+        throw new Error("Loaded spec is not a valid OpenAPI document");
+    }
+    const fingerprint = await sha256Hex(stableStringify(doc));
+    const id = getSpecId({ doc, fingerprint });
+    return { source, id, fingerprint, doc };
+}

package/dist/{src/cli → cli}/stable-json.d.ts

@@ -1,4 +1,3 @@
 export declare function stableStringify(value: unknown, options?: {
     space?: number;
 }): string;
-//# sourceMappingURL=stable-json.d.ts.map

package/dist/cli/stable-json.js

@@ -0,0 +1,29 @@
+export function stableStringify(value, options) {
+    const visiting = new WeakSet();
+    return JSON.stringify(sort(value, visiting), null, options?.space);
+}
+function sort(value, visiting) {
+    if (value === null)
+        return null;
+    if (Array.isArray(value)) {
+        if (visiting.has(value))
+            return { __specli_circular: true };
+        visiting.add(value);
+        const out = value.map((v) => sort(v, visiting));
+        visiting.delete(value);
+        return out;
+    }
+    if (typeof value === "object") {
+        if (visiting.has(value))
+            return { __specli_circular: true };
+        visiting.add(value);
+        const obj = value;
+        const out = {};
+        for (const key of Object.keys(obj).sort()) {
+            out[key] = sort(obj[key], visiting);
+        }
+        visiting.delete(value);
+        return out;
+    }
+    return value;
+}

package/dist/{src/cli → cli}/strings.d.ts

@@ -1,3 +1,2 @@
 export declare function kebabCase(input: string): string;
 export declare function titleCase(input: string): string;
-//# sourceMappingURL=strings.d.ts.map

package/dist/cli/strings.js

@@ -0,0 +1,20 @@
+export function kebabCase(input) {
+    const trimmed = input.trim();
+    if (!trimmed)
+        return "";
+    // Convert spaces/underscores/dots to dashes, split camelCase.
+    return trimmed
+        .replace(/([a-z0-9])([A-Z])/g, "$1-$2")
+        .replace(/[\s_.:/]+/g, "-")
+        .replace(/[^a-zA-Z0-9-]/g, "-")
+        .replace(/-+/g, "-")
+        .replace(/^-|-$/g, "")
+        .toLowerCase();
+}
+export function titleCase(input) {
+    return input
+        .split(/\s+/g)
+        .filter(Boolean)
+        .map((w) => w[0]?.toUpperCase() + w.slice(1))
+        .join(" ");
+}

package/dist/{src/cli → cli}/types.d.ts

@@ -50,4 +50,3 @@ export type LoadedSpec = {
     fingerprint: string;
     doc: OpenApiDoc;
 };
-//# sourceMappingURL=types.d.ts.map

package/dist/cli/types.js

@@ -0,0 +1,3 @@
+export function isJsonSchema(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}

package/dist/cli.d.ts

@@ -1,3 +1,2 @@
 #!/usr/bin/env node
 export {};
-//# sourceMappingURL=cli.d.ts.map