@manfred-kunze-dev/backbone-cli 2.7.0-dev.1 → 2.7.0-dev.3

package/dist/commands/convert.js

@@ -32,7 +32,7 @@ export function makeConvertCommand() {
                 const buffer = readFileSync(p);
                 const filename = basename(p);
                 return {
-                    kind: "Base64Source",
+                    kind: "base64",
                     content: buffer.toString("base64"),
                     filename,
                     mimeType: getMimeType(filename),
@@ -67,7 +67,7 @@ export function makeConvertCommand() {
         await runAction(command, async () => {
             const client = getClient(command);
             const sources = urls.map((url) => ({
-                kind: "HttpSource",
+                kind: "http",
                 url,
             }));
             const toFormats = opts.format.map(mapFormat);

package/dist/commands/docs.d.ts

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

package/dist/commands/docs.js

@@ -0,0 +1,166 @@
+import { Command } from "commander";
+import { runAction } from "../lib/client.js";
+import { resolveConfig, isJsonOutput } from "../lib/config.js";
+/* eslint-enable @typescript-eslint/no-explicit-any */
+/**
+ * Fetch the OpenAPI spec from the backend.
+ */
+async function fetchSpec(baseUrl, apiKey) {
+    const specUrl = `${baseUrl.replace(/\/+$/, "")}/v3/api-docs`;
+    const res = await fetch(specUrl, {
+        headers: { Authorization: `Bearer ${apiKey}` },
+    });
+    if (!res.ok) {
+        if (res.status === 404 || res.status === 403) {
+            throw new Error("API documentation is not available. Enable it by setting SPRINGDOC_ENABLED=true on the backend.");
+        }
+        throw new Error(`Failed to fetch API docs: ${res.status} ${res.statusText}`);
+    }
+    return (await res.json());
+}
+/**
+ * Collect all $ref strings from an object tree.
+ */
+function collectRefs(obj, refs) {
+    if (obj === null || obj === undefined || typeof obj !== "object")
+        return;
+    if (Array.isArray(obj)) {
+        for (const item of obj)
+            collectRefs(item, refs);
+        return;
+    }
+    const record = obj;
+    if (typeof record["$ref"] === "string") {
+        refs.add(record["$ref"]);
+    }
+    for (const value of Object.values(record)) {
+        collectRefs(value, refs);
+    }
+}
+/**
+ * Recursively resolve schema refs — the initial set plus any schemas they reference.
+ */
+function resolveSchemas(refPaths, allSchemas) {
+    const resolved = {};
+    const queue = [...refPaths];
+    const visited = new Set();
+    while (queue.length > 0) {
+        const ref = queue.pop();
+        if (visited.has(ref))
+            continue;
+        visited.add(ref);
+        const prefix = "#/components/schemas/";
+        if (!ref.startsWith(prefix))
+            continue;
+        const name = ref.slice(prefix.length);
+        const schema = allSchemas[name];
+        if (!schema)
+            continue;
+        resolved[name] = schema;
+        const nested = new Set();
+        collectRefs(schema, nested);
+        for (const n of nested) {
+            if (!visited.has(n))
+                queue.push(n);
+        }
+    }
+    return resolved;
+}
+export function makeDocsCommand() {
+    const cmd = new Command("docs").description("Browse API documentation");
+    cmd
+        .command("sections")
+        .description("List available API documentation sections")
+        .action(async (_opts, command) => {
+        await runAction(command, async () => {
+            const config = resolveConfig(command);
+            const spec = await fetchSpec(config.baseUrl, config.apiKey);
+            const tags = spec.tags ?? [];
+            const paths = spec.paths ?? {};
+            // Count endpoints per tag
+            const tagCounts = new Map();
+            for (const methods of Object.values(paths)) {
+                for (const operation of Object.values(methods)) {
+                    if (operation?.tags) {
+                        for (const tag of operation.tags) {
+                            tagCounts.set(tag, (tagCounts.get(tag) ?? 0) + 1);
+                        }
+                    }
+                }
+            }
+            if (isJsonOutput(command)) {
+                const data = tags.map((t) => ({
+                    name: t.name,
+                    description: t.description ?? null,
+                    endpoints: tagCounts.get(t.name) ?? 0,
+                }));
+                console.log(JSON.stringify(data, null, 2));
+            }
+            else {
+                const info = spec.info ?? {};
+                console.log(`${info.title ?? "API"} v${info.version ?? "?"}\n`);
+                console.log("Available sections:");
+                for (const t of tags) {
+                    const count = tagCounts.get(t.name) ?? 0;
+                    const desc = t.description ? ` — ${t.description}` : "";
+                    console.log(`  ${t.name} (${count} endpoint${count !== 1 ? "s" : ""})${desc}`);
+                }
+            }
+        });
+    });
+    cmd
+        .command("get")
+        .description("Get API documentation for a section")
+        .argument("<section>", "Section/tag name (e.g. Projects, Extractions)")
+        .action(async (section, _opts, command) => {
+        await runAction(command, async () => {
+            const config = resolveConfig(command);
+            const spec = await fetchSpec(config.baseUrl, config.apiKey);
+            const allTags = spec.tags ?? [];
+            const tagNames = allTags.map((t) => t.name);
+            if (!tagNames.includes(section)) {
+                throw new Error(`Section "${section}" not found. Available: ${tagNames.join(", ")}`);
+            }
+            const allPaths = spec.paths ?? {};
+            const allSchemas = spec.components?.schemas ?? {};
+            // Filter paths to only operations matching the requested tag
+            const filteredPaths = {};
+            const refs = new Set();
+            for (const [path, methods] of Object.entries(allPaths)) {
+                const filteredMethods = {};
+                for (const [method, operation] of Object.entries(methods)) {
+                    const op = operation;
+                    if (op?.tags?.includes(section)) {
+                        filteredMethods[method] = operation;
+                        collectRefs(operation, refs);
+                    }
+                }
+                if (Object.keys(filteredMethods).length > 0) {
+                    filteredPaths[path] = filteredMethods;
+                }
+            }
+            // Resolve referenced schemas (including transitive refs)
+            const referencedSchemas = resolveSchemas(refs, allSchemas);
+            if (isJsonOutput(command)) {
+                console.log(JSON.stringify({ paths: filteredPaths, schemas: referencedSchemas }, null, 2));
+            }
+            else {
+                // Human-readable summary
+                console.log(`\n${section}\n${"=".repeat(section.length)}\n`);
+                for (const [path, methods] of Object.entries(filteredPaths)) {
+                    for (const [method, operation] of Object.entries(methods)) {
+                        const op = operation;
+                        const label = op.summary ?? op.operationId ?? "";
+                        console.log(`  ${method.toUpperCase().padEnd(7)} ${path}`);
+                        if (label)
+                            console.log(`          ${label}`);
+                    }
+                }
+                console.log(`\nReferenced schemas: ${Object.keys(referencedSchemas).join(", ") || "(none)"}`);
+                console.log("\nUse --json for full endpoint and schema details.");
+            }
+        });
+    });
+    return cmd;
+}
+//# sourceMappingURL=docs.js.map

package/dist/commands/prompts.js

@@ -44,7 +44,7 @@ export function makePromptsCommand() {
         .description("Create a new prompt")
         .requiredOption("-n, --name <name>", "Prompt name")
         .option("-d, --description <text>", "Prompt description")
-        .option("--type <type>", "Prompt type")
+        .option("--type <type>", "Prompt type (TEXT or CHAT)", "TEXT")
         .action(async (opts, command) => {
         await runAction(command, async () => {
             const projectId = requireProjectId(command);

package/dist/commands/schemas.js

@@ -4,6 +4,7 @@ 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 { ensureOpenAiCompatible } from "../lib/schema-compat.js";
 import { makeSchemaVersionsCommand } from "./schema-versions.js";
 import { makeSchemaLabelsCommand } from "./schema-labels.js";
 export function makeSchemasCommand() {
@@ -127,15 +128,33 @@ export function makeSchemasCommand() {
         .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")
+        .option("-c, --content <json>", "JSON Schema content (overrides stored version)")
+        .option("-l, --label <name>", "Schema label to resolve")
         .action(async (schemaId, opts, command) => {
         await runAction(command, async () => {
             const projectId = requireProjectId(command);
             const client = getClient(command);
+            let jsonSchema;
+            if (opts.content) {
+                jsonSchema = JSON.parse(opts.content);
+            }
+            else {
+                // Resolve the schema content from the active version (or by label)
+                const { data: resolved } = await client.GET("/v1/projects/{projectId}/schemas/{schemaId}/resolve", {
+                    params: {
+                        path: { projectId, schemaId },
+                        query: { label: opts.label },
+                    },
+                });
+                jsonSchema = resolved?.jsonSchema;
+                if (!jsonSchema) {
+                    throw new Error("No active schema version found. Create a version first or pass --content.");
+                }
+            }
             const { data } = await client.POST("/v1/projects/{projectId}/schemas/{schemaId}/test", {
                 params: { path: { projectId, schemaId } },
                 body: {
+                    jsonSchema: ensureOpenAiCompatible(jsonSchema),
                     sampleText: opts.text,
                     model: opts.model,
                 },

package/dist/index.js

@@ -12,6 +12,7 @@ import { makeTranscribeCommand } from "./commands/transcribe.js";
 import { makeProvidersCommand } from "./commands/providers.js";
 import { makeAnalyticsCommand } from "./commands/analytics.js";
 import { makeBillingCommand } from "./commands/billing.js";
+import { makeDocsCommand } from "./commands/docs.js";
 const program = new Command();
 program
     .name("backbone")
@@ -34,5 +35,6 @@ program.addCommand(makeTranscribeCommand());
 program.addCommand(makeProvidersCommand());
 program.addCommand(makeAnalyticsCommand());
 program.addCommand(makeBillingCommand());
+program.addCommand(makeDocsCommand());
 program.parse();
 //# sourceMappingURL=index.js.map

package/dist/lib/schema-compat.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Sanitize a JSON Schema to be compatible with OpenAI's structured output requirements.
+ *
+ * OpenAI requires:
+ * - Every object type must have `additionalProperties: false`
+ * - Every object must list all properties in `required`
+ *
+ * This function recursively walks the schema and applies these constraints.
+ */
+export declare function ensureOpenAiCompatible(schema: unknown): unknown;
+//# sourceMappingURL=schema-compat.d.ts.map

package/dist/lib/schema-compat.js

@@ -0,0 +1,51 @@
+/**
+ * Sanitize a JSON Schema to be compatible with OpenAI's structured output requirements.
+ *
+ * OpenAI requires:
+ * - Every object type must have `additionalProperties: false`
+ * - Every object must list all properties in `required`
+ *
+ * This function recursively walks the schema and applies these constraints.
+ */
+export function ensureOpenAiCompatible(schema) {
+    if (schema === null || schema === undefined || typeof schema !== "object") {
+        return schema;
+    }
+    if (Array.isArray(schema)) {
+        return schema.map(ensureOpenAiCompatible);
+    }
+    const obj = schema;
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+        if (key === "properties" && typeof value === "object" && value !== null) {
+            // Recurse into each property definition
+            const props = {};
+            for (const [propName, propValue] of Object.entries(value)) {
+                props[propName] = ensureOpenAiCompatible(propValue);
+            }
+            result[key] = props;
+        }
+        else if (key === "items") {
+            // Recurse into array items
+            result[key] = ensureOpenAiCompatible(value);
+        }
+        else if (key === "anyOf" || key === "oneOf" || key === "allOf") {
+            // Recurse into combinators
+            result[key] = Array.isArray(value) ? value.map(ensureOpenAiCompatible) : value;
+        }
+        else {
+            result[key] = value;
+        }
+    }
+    // If this node is an object type with properties, enforce OpenAI constraints
+    if (obj.type === "object" && obj.properties && typeof obj.properties === "object") {
+        result.additionalProperties = false;
+        // Ensure all properties are in required
+        const propNames = Object.keys(obj.properties);
+        const existing = Array.isArray(obj.required) ? obj.required : [];
+        const merged = [...new Set([...existing, ...propNames])];
+        result.required = merged;
+    }
+    return result;
+}
+//# sourceMappingURL=schema-compat.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@manfred-kunze-dev/backbone-cli",
-  "version": "2.7.0-dev.1",
+  "version": "2.7.0-dev.3",
   "description": "CLI for the Backbone AI platform",
   "type": "module",
   "main": "dist/index.js",