@manfred-kunze-dev/backbone-cli 2.6.0-dev.4

package/dist/commands/providers.js

@@ -0,0 +1,115 @@
+import { Command } from "commander";
+import { getClient, runAction } from "../lib/client.js";
+import { isJsonOutput } from "../lib/config.js";
+import { formatPage, formatDetail, formatList, formatSuccess } from "../lib/output.js";
+import { addPaginationOptions, paginationParams } from "../lib/pagination.js";
+export function makeProvidersCommand() {
+    const cmd = new Command("providers").description("Manage AI providers");
+    const list = new Command("list").description("List providers");
+    addPaginationOptions(list);
+    list.option("-s, --search <term>", "Filter by name");
+    list.action(async (opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            const { data } = await client.GET("/v1/providers", {
+                params: { query: { search: opts.search, ...paginationParams(opts) } },
+            });
+            formatPage(data, command, ["id", "name", "type", "enabled", "createdAt"]);
+        });
+    });
+    cmd.addCommand(list);
+    cmd
+        .command("get")
+        .description("Get a provider by ID")
+        .argument("<id>", "Provider ID")
+        .action(async (id, _opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            const { data } = await client.GET("/v1/providers/{id}", {
+                params: { path: { id } },
+            });
+            formatDetail(data, command);
+        });
+    });
+    cmd
+        .command("create")
+        .description("Create a new provider")
+        .requiredOption("-n, --name <name>", "Provider name")
+        .requiredOption("--type <type>", "Provider type (openai, azure, anthropic, vertex, ollama)")
+        .requiredOption("--api-key <key>", "Provider API key")
+        .option("-c, --config <json>", "Provider config as JSON")
+        .action(async (opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            const config = opts.config ? JSON.parse(opts.config) : {};
+            const { data } = await client.POST("/v1/providers", {
+                body: { name: opts.name, provider: opts.type.toUpperCase(), apiKey: opts.apiKey, config },
+            });
+            formatDetail(data, command);
+        });
+    });
+    cmd
+        .command("update")
+        .description("Update a provider")
+        .argument("<id>", "Provider ID")
+        .option("-n, --name <name>", "New name")
+        .option("--type <type>", "New type")
+        .option("--enabled <bool>", "Enable/disable")
+        .option("-c, --config <json>", "New config as JSON")
+        .action(async (id, opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            const body = {};
+            if (opts.name)
+                body.name = opts.name;
+            if (opts.type)
+                body.provider = opts.type.toUpperCase();
+            if (opts.enabled !== undefined)
+                body.enabled = opts.enabled === "true";
+            if (opts.config)
+                body.config = JSON.parse(opts.config);
+            const { data } = await client.PATCH("/v1/providers/{id}", {
+                params: { path: { id } },
+                body: body,
+            });
+            formatDetail(data, command);
+        });
+    });
+    cmd
+        .command("delete")
+        .description("Delete a provider")
+        .argument("<id>", "Provider ID")
+        .action(async (id, _opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            await client.DELETE("/v1/providers/{id}", {
+                params: { path: { id } },
+            });
+            formatSuccess(`Provider ${id} deleted.`, command);
+        });
+    });
+    cmd
+        .command("models")
+        .description("List available models across all providers")
+        .action(async (_opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            const { data } = await client.GET("/v1/providers/models");
+            const json = isJsonOutput(command);
+            if (json) {
+                console.log(JSON.stringify(data, null, 2));
+            }
+            else {
+                const models = data?.data ?? [];
+                formatList(models, command, [
+                    "id",
+                    "provider",
+                    "name",
+                    "capabilities",
+                ]);
+            }
+        });
+    });
+    return cmd;
+}
+//# sourceMappingURL=providers.js.map

package/dist/commands/schema-labels.d.ts

@@ -0,0 +1,3 @@
+import { Command } from "commander";
+export declare function makeSchemaLabelsCommand(): Command;
+//# sourceMappingURL=schema-labels.d.ts.map

package/dist/commands/schema-labels.js

@@ -0,0 +1,72 @@
+import { Command } from "commander";
+import { getClient, runAction } from "../lib/client.js";
+import { requireProjectId } from "../lib/context.js";
+import { formatList, formatDetail, formatSuccess } from "../lib/output.js";
+export function makeSchemaLabelsCommand() {
+    const cmd = new Command("labels").description("Manage schema labels");
+    cmd
+        .command("list")
+        .description("List labels for a schema")
+        .requiredOption("--schema <id>", "Schema ID")
+        .action(async (opts, command) => {
+        await runAction(command, async () => {
+            const projectId = requireProjectId(command);
+            const client = getClient(command);
+            const { data } = await client.GET("/v1/projects/{projectId}/schemas/{schemaId}/labels", { params: { path: { projectId, schemaId: opts.schema } } });
+            formatList(data, command, [
+                "name",
+                "schemaVersionId",
+                "createdAt",
+            ]);
+        });
+    });
+    cmd
+        .command("create")
+        .description("Create a label for a schema version")
+        .requiredOption("--schema <id>", "Schema ID")
+        .requiredOption("-n, --name <name>", "Label name")
+        .requiredOption("--version-id <id>", "Schema version ID to label")
+        .action(async (opts, command) => {
+        await runAction(command, async () => {
+            const projectId = requireProjectId(command);
+            const client = getClient(command);
+            const { data } = await client.POST("/v1/projects/{projectId}/schemas/{schemaId}/labels", {
+                params: { path: { projectId, schemaId: opts.schema } },
+                body: { name: opts.name, schemaVersionId: opts.versionId },
+            });
+            formatDetail(data, command);
+        });
+    });
+    cmd
+        .command("update")
+        .description("Update a label to point to a different version")
+        .argument("<labelName>", "Label name")
+        .requiredOption("--schema <id>", "Schema ID")
+        .requiredOption("--version-id <id>", "New schema version ID")
+        .action(async (labelName, opts, command) => {
+        await runAction(command, async () => {
+            const projectId = requireProjectId(command);
+            const client = getClient(command);
+            const { data } = await client.PUT("/v1/projects/{projectId}/schemas/{schemaId}/labels/{labelName}", {
+                params: { path: { projectId, schemaId: opts.schema, labelName } },
+                body: { schemaVersionId: opts.versionId },
+            });
+            formatDetail(data, command);
+        });
+    });
+    cmd
+        .command("delete")
+        .description("Delete a schema label")
+        .argument("<labelName>", "Label name")
+        .requiredOption("--schema <id>", "Schema ID")
+        .action(async (labelName, opts, command) => {
+        await runAction(command, async () => {
+            const projectId = requireProjectId(command);
+            const client = getClient(command);
+            await client.DELETE("/v1/projects/{projectId}/schemas/{schemaId}/labels/{labelName}", { params: { path: { projectId, schemaId: opts.schema, labelName } } });
+            formatSuccess(`Label "${labelName}" deleted.`, command);
+        });
+    });
+    return cmd;
+}
+//# sourceMappingURL=schema-labels.js.map

package/dist/commands/schema-versions.d.ts

@@ -0,0 +1,3 @@
+import { Command } from "commander";
+export declare function makeSchemaVersionsCommand(): Command;
+//# sourceMappingURL=schema-versions.d.ts.map

package/dist/commands/schema-versions.js

@@ -0,0 +1,71 @@
+import { Command } from "commander";
+import { getClient, runAction } from "../lib/client.js";
+import { requireProjectId } from "../lib/context.js";
+import { formatPage, formatDetail } from "../lib/output.js";
+import { addPaginationOptions, paginationParams } from "../lib/pagination.js";
+export function makeSchemaVersionsCommand() {
+    const cmd = new Command("versions").description("Manage schema versions");
+    const list = new Command("list").description("List versions of a schema");
+    addPaginationOptions(list);
+    list.requiredOption("--schema <id>", "Schema ID");
+    list.action(async (opts, command) => {
+        await runAction(command, async () => {
+            const projectId = requireProjectId(command);
+            const client = getClient(command);
+            const { data } = await client.GET("/v1/projects/{projectId}/schemas/{schemaId}/versions", {
+                params: {
+                    path: { projectId, schemaId: opts.schema },
+                    query: paginationParams(opts),
+                },
+            });
+            formatPage(data, command, ["id", "version", "active", "changeDescription", "createdAt"]);
+        });
+    });
+    cmd.addCommand(list);
+    cmd
+        .command("get")
+        .description("Get a specific schema version")
+        .argument("<versionId>", "Version ID")
+        .requiredOption("--schema <id>", "Schema ID")
+        .action(async (versionId, opts, command) => {
+        await runAction(command, async () => {
+            const projectId = requireProjectId(command);
+            const client = getClient(command);
+            const { data } = await client.GET("/v1/projects/{projectId}/schemas/{schemaId}/versions/{versionId}", { params: { path: { projectId, schemaId: opts.schema, versionId } } });
+            formatDetail(data, command);
+        });
+    });
+    cmd
+        .command("create")
+        .description("Create a new schema version")
+        .requiredOption("--schema <id>", "Schema ID")
+        .requiredOption("-c, --content <json>", "JSON Schema content")
+        .option("-m, --message <text>", "Change description")
+        .action(async (opts, command) => {
+        await runAction(command, async () => {
+            const projectId = requireProjectId(command);
+            const client = getClient(command);
+            const content = JSON.parse(opts.content);
+            const { data } = await client.POST("/v1/projects/{projectId}/schemas/{schemaId}/versions", {
+                params: { path: { projectId, schemaId: opts.schema } },
+                body: { jsonSchema: content, changeDescription: opts.message },
+            });
+            formatDetail(data, command);
+        });
+    });
+    cmd
+        .command("activate")
+        .description("Activate a schema version")
+        .argument("<versionId>", "Version ID")
+        .requiredOption("--schema <id>", "Schema ID")
+        .action(async (versionId, opts, command) => {
+        await runAction(command, async () => {
+            const projectId = requireProjectId(command);
+            const client = getClient(command);
+            const { data } = await client.PUT("/v1/projects/{projectId}/schemas/{schemaId}/versions/{versionId}/activate", { params: { path: { projectId, schemaId: opts.schema, versionId } } });
+            formatDetail(data, command);
+        });
+    });
+    return cmd;
+}
+//# sourceMappingURL=schema-versions.js.map

package/dist/commands/schemas.d.ts

@@ -0,0 +1,3 @@
+import { Command } from "commander";
+export declare function makeSchemasCommand(): Command;
+//# sourceMappingURL=schemas.d.ts.map

package/dist/commands/schemas.js

@@ -0,0 +1,168 @@
+import { Command } from "commander";
+import { getClient, runAction } from "../lib/client.js";
+import { isJsonOutput } from "../lib/config.js";
+import { requireProjectId } from "../lib/context.js";
+import { formatPage, formatDetail, formatSuccess } from "../lib/output.js";
+import { addPaginationOptions, paginationParams } from "../lib/pagination.js";
+import { makeSchemaVersionsCommand } from "./schema-versions.js";
+import { makeSchemaLabelsCommand } from "./schema-labels.js";
+export function makeSchemasCommand() {
+    const cmd = new Command("schemas").description("Manage schemas");
+    const list = new Command("list").description("List schemas");
+    addPaginationOptions(list);
+    list.option("-s, --search <term>", "Filter by name");
+    list.action(async (opts, command) => {
+        await runAction(command, async () => {
+            const projectId = requireProjectId(command);
+            const client = getClient(command);
+            const { data } = await client.GET("/v1/projects/{projectId}/schemas", {
+                params: {
+                    path: { projectId },
+                    query: { search: opts.search, ...paginationParams(opts) },
+                },
+            });
+            formatPage(data, command, ["id", "name", "description", "activeVersionId", "createdAt"]);
+        });
+    });
+    cmd.addCommand(list);
+    cmd
+        .command("get")
+        .description("Get a schema by ID")
+        .argument("<id>", "Schema ID")
+        .action(async (id, _opts, command) => {
+        await runAction(command, async () => {
+            const projectId = requireProjectId(command);
+            const client = getClient(command);
+            const { data } = await client.GET("/v1/projects/{projectId}/schemas/{id}", {
+                params: { path: { projectId, id } },
+            });
+            formatDetail(data, command);
+        });
+    });
+    cmd
+        .command("create")
+        .description("Create a new schema")
+        .requiredOption("-n, --name <name>", "Schema name")
+        .option("-d, --description <text>", "Schema description")
+        .action(async (opts, command) => {
+        await runAction(command, async () => {
+            const projectId = requireProjectId(command);
+            const client = getClient(command);
+            const { data } = await client.POST("/v1/projects/{projectId}/schemas", {
+                params: { path: { projectId } },
+                body: { name: opts.name, description: opts.description },
+            });
+            formatDetail(data, command);
+        });
+    });
+    cmd
+        .command("update")
+        .description("Update a schema")
+        .argument("<id>", "Schema ID")
+        .option("-n, --name <name>", "New name")
+        .option("-d, --description <text>", "New description")
+        .action(async (id, opts, command) => {
+        await runAction(command, async () => {
+            const projectId = requireProjectId(command);
+            const client = getClient(command);
+            const body = {};
+            if (opts.name)
+                body.name = opts.name;
+            if (opts.description !== undefined)
+                body.description = opts.description;
+            const { data } = await client.PUT("/v1/projects/{projectId}/schemas/{id}", {
+                params: { path: { projectId, id } },
+                body: body,
+            });
+            formatDetail(data, command);
+        });
+    });
+    cmd
+        .command("delete")
+        .description("Delete a schema")
+        .argument("<id>", "Schema ID")
+        .action(async (id, _opts, command) => {
+        await runAction(command, async () => {
+            const projectId = requireProjectId(command);
+            const client = getClient(command);
+            await client.DELETE("/v1/projects/{projectId}/schemas/{id}", {
+                params: { path: { projectId, id } },
+            });
+            formatSuccess(`Schema ${id} deleted.`, command);
+        });
+    });
+    cmd
+        .command("validate")
+        .description("Validate a JSON schema without saving")
+        .argument("<schemaId>", "Schema ID")
+        .requiredOption("-c, --content <json>", "JSON Schema content")
+        .action(async (schemaId, opts, command) => {
+        await runAction(command, async () => {
+            const projectId = requireProjectId(command);
+            const client = getClient(command);
+            const content = JSON.parse(opts.content);
+            const { data } = await client.POST("/v1/projects/{projectId}/schemas/{schemaId}/validate", {
+                params: { path: { projectId, schemaId } },
+                body: { jsonSchema: content },
+            });
+            if (isJsonOutput(command)) {
+                console.log(JSON.stringify(data, null, 2));
+            }
+            else if (data?.valid) {
+                formatSuccess("Schema is valid.", command);
+                if (data.warnings?.length) {
+                    console.log(`Warnings: ${data.warnings.join(", ")}`);
+                }
+            }
+            else {
+                console.error("Schema is invalid:");
+                for (const err of data?.errors ?? [])
+                    console.error(`  - ${err}`);
+            }
+        });
+    });
+    cmd
+        .command("test")
+        .description("Test a schema with sample text")
+        .argument("<schemaId>", "Schema ID")
+        .requiredOption("-t, --text <text>", "Sample text to extract from")
+        .requiredOption("-m, --model <model>", "Model to use (provider/model)")
+        .option("--version-id <id>", "Schema version ID")
+        .option("-l, --label <name>", "Schema label")
+        .action(async (schemaId, opts, command) => {
+        await runAction(command, async () => {
+            const projectId = requireProjectId(command);
+            const client = getClient(command);
+            const { data } = await client.POST("/v1/projects/{projectId}/schemas/{schemaId}/test", {
+                params: { path: { projectId, schemaId } },
+                body: {
+                    sampleText: opts.text,
+                    model: opts.model,
+                },
+            });
+            formatDetail(data, command);
+        });
+    });
+    cmd
+        .command("resolve")
+        .description("Resolve schema content (latest or by label)")
+        .argument("<schemaId>", "Schema ID")
+        .option("-l, --label <name>", "Label to resolve")
+        .action(async (schemaId, opts, command) => {
+        await runAction(command, async () => {
+            const projectId = requireProjectId(command);
+            const client = getClient(command);
+            const { data } = await client.GET("/v1/projects/{projectId}/schemas/{schemaId}/resolve", {
+                params: {
+                    path: { projectId, schemaId },
+                    query: { label: opts.label },
+                },
+            });
+            formatDetail(data, command);
+        });
+    });
+    cmd.addCommand(makeSchemaVersionsCommand());
+    cmd.addCommand(makeSchemaLabelsCommand());
+    return cmd;
+}
+//# sourceMappingURL=schemas.js.map

package/dist/commands/transcribe.d.ts

@@ -0,0 +1,3 @@
+import { Command } from "commander";
+export declare function makeTranscribeCommand(): Command;
+//# sourceMappingURL=transcribe.d.ts.map

package/dist/commands/transcribe.js

@@ -0,0 +1,65 @@
+import { Command } from "commander";
+import { resolveConfig, isJsonOutput } from "../lib/config.js";
+import { handleError } from "../lib/errors.js";
+import { formatDetail, withSpinner } from "../lib/output.js";
+import { fileToBlob } from "../lib/multipart.js";
+import { BackboneApiError } from "../lib/errors.js";
+export function makeTranscribeCommand() {
+    const cmd = new Command("transcribe")
+        .description("Transcribe an audio file")
+        .argument("<file>", "Audio file path")
+        .requiredOption("-m, --model <model>", "Model (e.g., openai/whisper-1)")
+        .option("--language <code>", "Language code (e.g., en, de)")
+        .option("--prompt <text>", "Optional prompt to guide transcription")
+        .option("--format <fmt>", "Response format (json, text, srt, verbose_json, vtt)")
+        .option("--temperature <n>", "Temperature")
+        .action(async (file, opts, command) => {
+        const json = isJsonOutput(command);
+        try {
+            const config = resolveConfig(command);
+            const { blob, filename } = fileToBlob(file);
+            const formData = new FormData();
+            formData.append("file", blob, filename);
+            formData.append("model", opts.model);
+            if (opts.language)
+                formData.append("language", opts.language);
+            if (opts.prompt)
+                formData.append("prompt", opts.prompt);
+            if (opts.format)
+                formData.append("response_format", opts.format);
+            if (opts.temperature)
+                formData.append("temperature", opts.temperature);
+            const baseUrl = config.baseUrl.replace(/\/+$/, "");
+            const url = `${baseUrl}/v1/audio/transcriptions`;
+            const data = await withSpinner("Transcribing...", async () => {
+                const res = await fetch(url, {
+                    method: "POST",
+                    headers: { Authorization: `Bearer ${config.apiKey}` },
+                    body: formData,
+                });
+                if (!res.ok) {
+                    let body;
+                    try {
+                        body = await res.json();
+                    }
+                    catch {
+                        body = {
+                            error: res.statusText,
+                            message: `HTTP ${res.status}: ${res.statusText}`,
+                            status: res.status,
+                            timestamp: new Date().toISOString(),
+                        };
+                    }
+                    throw new BackboneApiError(body);
+                }
+                return res.json();
+            });
+            formatDetail(data, command);
+        }
+        catch (err) {
+            handleError(err, json);
+        }
+    });
+    return cmd;
+}
+//# sourceMappingURL=transcribe.js.map

package/dist/index.d.ts

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

package/dist/index.js

@@ -0,0 +1,38 @@
+#!/usr/bin/env node
+import { Command } from "commander";
+import { makeAuthCommand } from "./commands/auth.js";
+import { makeConfigCommand } from "./commands/config.js";
+import { makeProjectsCommand } from "./commands/projects.js";
+import { makeSchemasCommand } from "./commands/schemas.js";
+import { makePromptsCommand } from "./commands/prompts.js";
+import { makeExtractionsCommand } from "./commands/extractions.js";
+import { makeConvertCommand } from "./commands/convert.js";
+import { makeAiCommand } from "./commands/ai.js";
+import { makeTranscribeCommand } from "./commands/transcribe.js";
+import { makeProvidersCommand } from "./commands/providers.js";
+import { makeAnalyticsCommand } from "./commands/analytics.js";
+import { makeBillingCommand } from "./commands/billing.js";
+const program = new Command();
+program
+    .name("backbone")
+    .description("CLI for the Backbone AI platform")
+    .version("1.0.0")
+    .option("--api-key <key>", "API key (overrides config)")
+    .option("--base-url <url>", "Base URL (overrides config)")
+    .option("--project <id>", "Project ID (overrides config)")
+    .option("--json", "Output as JSON")
+    .option("--no-color", "Disable colored output");
+program.addCommand(makeAuthCommand());
+program.addCommand(makeConfigCommand());
+program.addCommand(makeProjectsCommand());
+program.addCommand(makeSchemasCommand());
+program.addCommand(makePromptsCommand());
+program.addCommand(makeExtractionsCommand());
+program.addCommand(makeConvertCommand());
+program.addCommand(makeAiCommand());
+program.addCommand(makeTranscribeCommand());
+program.addCommand(makeProvidersCommand());
+program.addCommand(makeAnalyticsCommand());
+program.addCommand(makeBillingCommand());
+program.parse();
+//# sourceMappingURL=index.js.map

package/dist/lib/client.d.ts

@@ -0,0 +1,12 @@
+import type { paths } from "../generated/openapi.js";
+import type { Command } from "commander";
+/**
+ * Create a typed openapi-fetch client from the resolved config.
+ * Attaches Bearer auth and error middleware automatically.
+ */
+export declare function getClient(command: Command): import("openapi-fetch").Client<paths, `${string}/${string}`>;
+/**
+ * Convenience: run an async action with consistent error handling.
+ */
+export declare function runAction(command: Command, action: () => Promise<void>): Promise<void>;
+//# sourceMappingURL=client.d.ts.map

package/dist/lib/client.js

@@ -0,0 +1,52 @@
+import createClient from "openapi-fetch";
+import { resolveConfig, isJsonOutput } from "./config.js";
+import { BackboneApiError, handleError } from "./errors.js";
+/**
+ * Error-handling middleware: intercepts non-ok responses and throws BackboneApiError.
+ */
+const errorMiddleware = {
+    async onResponse({ response }) {
+        if (response.ok)
+            return undefined;
+        let body;
+        try {
+            body = await response.clone().json();
+        }
+        catch {
+            body = {};
+        }
+        throw new BackboneApiError({
+            status: body.status ?? response.status,
+            error: body.error ?? response.statusText,
+            message: body.message ?? `HTTP ${response.status}: ${response.statusText}`,
+            timestamp: body.timestamp ?? new Date().toISOString(),
+        });
+    },
+};
+/**
+ * Create a typed openapi-fetch client from the resolved config.
+ * Attaches Bearer auth and error middleware automatically.
+ */
+export function getClient(command) {
+    const config = resolveConfig(command);
+    const client = createClient({
+        baseUrl: config.baseUrl.replace(/\/+$/, ""),
+        headers: {
+            Authorization: `Bearer ${config.apiKey}`,
+        },
+    });
+    client.use(errorMiddleware);
+    return client;
+}
+/**
+ * Convenience: run an async action with consistent error handling.
+ */
+export async function runAction(command, action) {
+    try {
+        await action();
+    }
+    catch (err) {
+        handleError(err, isJsonOutput(command));
+    }
+}
+//# sourceMappingURL=client.js.map

package/dist/lib/config.d.ts

@@ -0,0 +1,20 @@
+import Conf from "conf";
+import type { Command } from "commander";
+export interface BackboneConfig {
+    apiKey: string;
+    baseUrl: string;
+    project?: string;
+}
+declare const store: Conf<Partial<BackboneConfig>>;
+export { store };
+/**
+ * Resolve configuration with priority:
+ *   1. CLI flags (--api-key, --base-url, --project)
+ *   2. Environment variables (BACKBONE_API_KEY, BACKBONE_BASE_URL, BACKBONE_PROJECT)
+ *   3. Local .backbone file
+ *   4. Config store (~/.config/backbone/config.json)
+ */
+export declare function resolveConfig(command: Command): BackboneConfig;
+/** Check if --json flag is set on root command */
+export declare function isJsonOutput(command: Command): boolean;
+//# sourceMappingURL=config.d.ts.map