specli 0.0.11 → 0.0.13

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

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

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

@@ -0,0 +1,27 @@
+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/{src/cli → cli}/command-index.d.ts

@@ -3,4 +3,3 @@ export type CommandsIndex = {
     byId: Record<string, CommandAction>;
 };
 export declare function buildCommandsIndex(commands: CommandModel | undefined): CommandsIndex;
-//# sourceMappingURL=command-index.d.ts.map

package/dist/cli/command-index.js

@@ -0,0 +1,9 @@
+export function buildCommandsIndex(commands) {
+    const byId = {};
+    for (const resource of commands?.resources ?? []) {
+        for (const action of resource.actions) {
+            byId[action.id] = action;
+        }
+    }
+    return { byId };
+}

package/dist/{src/cli → cli}/command-model.d.ts

@@ -37,4 +37,3 @@ export type BuildCommandModelOptions = {
     authSchemes?: AuthScheme[];
 };
 export declare function buildCommandModel(planned: PlannedOperation[], options: BuildCommandModelOptions): CommandModel;
-//# sourceMappingURL=command-model.d.ts.map

package/dist/cli/command-model.js

@@ -0,0 +1,53 @@
+import { summarizeAuth } from "./auth-requirements.js";
+import { buildCommandId } from "./command-id.js";
+import { deriveParamSpecs } from "./params.js";
+import { deriveFlags, derivePositionals } from "./positional.js";
+import { deriveRequestBodyInfo } from "./request-body.js";
+export function buildCommandModel(planned, options) {
+    const byResource = new Map();
+    for (const op of planned) {
+        const list = byResource.get(op.resource) ?? [];
+        const params = deriveParamSpecs(op);
+        const positionals = derivePositionals({ pathArgs: op.pathArgs, params });
+        const flags = deriveFlags({ pathArgs: op.pathArgs, params });
+        list.push({
+            id: buildCommandId({
+                specId: options.specId,
+                resource: op.resource,
+                action: op.action,
+                operationKey: op.key,
+            }),
+            key: op.key,
+            action: op.action,
+            pathArgs: op.pathArgs,
+            method: op.method,
+            path: op.path,
+            operationId: op.operationId,
+            tags: op.tags,
+            summary: op.summary,
+            description: op.description,
+            deprecated: op.deprecated,
+            style: op.style,
+            params,
+            positionals,
+            flags: flags.flags,
+            auth: summarizeAuth(op.security, options.globalSecurity, options.authSchemes ?? []),
+            requestBody: deriveRequestBodyInfo(op),
+            requestBodySchema: deriveRequestBodyInfo(op)?.preferredSchema,
+        });
+        byResource.set(op.resource, list);
+    }
+    const resources = [];
+    for (const [resource, actions] of byResource.entries()) {
+        actions.sort((a, b) => {
+            if (a.action !== b.action)
+                return a.action.localeCompare(b.action);
+            if (a.path !== b.path)
+                return a.path.localeCompare(b.path);
+            return a.method.localeCompare(b.method);
+        });
+        resources.push({ resource, actions });
+    }
+    resources.sort((a, b) => a.resource.localeCompare(b.resource));
+    return { resources };
+}

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

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

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

@@ -0,0 +1,40 @@
+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/{src/cli → cli}/compile.d.ts

@@ -12,4 +12,3 @@ export type CompileOptions = {
     auth?: string;
 };
 export declare function compileCommand(spec: string, options: CompileOptions): Promise<void>;
-//# sourceMappingURL=compile.d.ts.map

package/dist/cli/compile.js

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

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

@@ -1,2 +1 @@
 export declare function sha256Hex(text: string): Promise<string>;
-//# sourceMappingURL=crypto.d.ts.map

package/dist/cli/crypto.js

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

package/dist/{src/cli → cli}/derive-name.d.ts

@@ -6,4 +6,3 @@
  *   3. Fallback to "specli"
  */
 export declare function deriveBinaryName(spec: string): Promise<string>;
-//# sourceMappingURL=derive-name.d.ts.map

package/dist/cli/derive-name.js

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

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

@@ -11,4 +11,3 @@ export type ExecOptions = {
     json?: boolean;
 };
 export declare function execCommand(spec: string, options: ExecOptions, commandArgs: string[]): Promise<void>;
-//# sourceMappingURL=exec.d.ts.map

package/dist/cli/exec.js

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

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

@@ -7,4 +7,3 @@ type MainOptions = {
 };
 export declare function main(argv: string[], options?: MainOptions): Promise<void>;
 export {};
-//# sourceMappingURL=main.d.ts.map

package/dist/cli/main.js

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

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

@@ -9,4 +9,3 @@ export type PlannedOperation = NormalizedOperation & {
 };
 export declare function planOperation(op: NormalizedOperation): PlannedOperation;
 export declare function planOperations(ops: NormalizedOperation[]): PlannedOperation[];
-//# sourceMappingURL=naming.d.ts.map