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

package/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2025-present Manfred Kunze Dev
+
+All rights reserved.
+
+This software and associated documentation files (the "Software") are proprietary
+and confidential. No part of the Software may be reproduced, distributed, or
+transmitted in any form or by any means, including photocopying, recording, or
+other electronic or mechanical methods, without the prior written permission of
+the copyright holder.
+
+The Software is provided "as is", without warranty of any kind, express or implied,
+including but not limited to the warranties of merchantability, fitness for a
+particular purpose, and noninfringement. In no event shall the authors or copyright
+holders be liable for any claim, damages, or other liability, whether in an action
+of contract, tort, or otherwise, arising from, out of, or in connection with the
+Software or the use or other dealings in the Software.
+
+Usage of this Software is permitted only in accordance with the terms and conditions
+set forth by Manfred Kunze Dev.

package/dist/commands/ai.d.ts

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

package/dist/commands/ai.js

@@ -0,0 +1,72 @@
+import { Command } from "commander";
+import { getClient, runAction } from "../lib/client.js";
+import { isJsonOutput } from "../lib/config.js";
+import { formatList, withSpinner } from "../lib/output.js";
+import chalk from "chalk";
+export function makeAiCommand() {
+    const cmd = new Command("ai").description("AI gateway operations");
+    cmd
+        .command("chat")
+        .description("Send a chat completion request")
+        .requiredOption("-m, --model <model>", "Model (provider/model format)")
+        .requiredOption("--message <text>", "User message")
+        .option("--system <text>", "System message")
+        .option("--temperature <n>", "Temperature (0-2)")
+        .option("--max-tokens <n>", "Max tokens")
+        .option("--top-p <n>", "Top-p sampling")
+        .action(async (opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            const messages = [];
+            if (opts.system) {
+                messages.push({ role: "system", content: opts.system });
+            }
+            messages.push({ role: "user", content: opts.message });
+            const body = {
+                model: opts.model,
+                messages,
+                stream: false,
+                temperature: opts.temperature ? parseFloat(opts.temperature) : undefined,
+                max_tokens: opts.maxTokens ? parseInt(opts.maxTokens, 10) : undefined,
+                top_p: opts.topP ? parseFloat(opts.topP) : undefined,
+            };
+            const { data } = await withSpinner("Thinking...", () => client.POST("/v1/chat/completions", { body }));
+            // Response type is untyped in OpenAPI spec (OpenAI-compatible format)
+            const result = data;
+            const json = isJsonOutput(command);
+            if (json) {
+                console.log(JSON.stringify(result, null, 2));
+            }
+            else {
+                const choices = result?.choices;
+                const content = choices?.[0]?.message?.content;
+                if (content) {
+                    console.log(content);
+                }
+                const usage = result?.usage;
+                if (usage) {
+                    console.log(chalk.dim(`\n[${result?.model} | ${usage.prompt_tokens} in / ${usage.completion_tokens} out / ${usage.total_tokens} total tokens]`));
+                }
+            }
+        });
+    });
+    cmd
+        .command("models")
+        .description("List available AI models")
+        .action(async (_opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            const { data } = await client.GET("/v1/models");
+            const json = isJsonOutput(command);
+            if (json) {
+                console.log(JSON.stringify(data, null, 2));
+            }
+            else {
+                const models = data?.data ?? [];
+                formatList(models, command, ["id", "owned_by"]);
+            }
+        });
+    });
+    return cmd;
+}
+//# sourceMappingURL=ai.js.map

package/dist/commands/analytics.d.ts

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

package/dist/commands/analytics.js

@@ -0,0 +1,120 @@
+import { Command } from "commander";
+import { getClient, runAction } from "../lib/client.js";
+import { requireProjectId } from "../lib/context.js";
+import { formatDetail, formatList } from "../lib/output.js";
+function addDateOptions(cmd) {
+    return cmd
+        .option("--start <date>", "Start date (YYYY-MM-DD)")
+        .option("--end <date>", "End date (YYYY-MM-DD)");
+}
+export function makeAnalyticsCommand() {
+    const cmd = new Command("analytics").description("Project analytics");
+    const summary = new Command("summary").description("Get summary analytics");
+    addDateOptions(summary);
+    summary.action(async (opts, command) => {
+        await runAction(command, async () => {
+            const projectId = requireProjectId(command);
+            const client = getClient(command);
+            const { data } = await client.GET("/v1/projects/{projectId}/analytics/summary", {
+                params: {
+                    path: { projectId },
+                    query: { startDate: opts.start, endDate: opts.end },
+                },
+            });
+            formatDetail(data, command);
+        });
+    });
+    cmd.addCommand(summary);
+    const timeSeries = new Command("time-series").description("Get time-series data");
+    addDateOptions(timeSeries);
+    timeSeries.option("--group-by <interval>", "Group by: day, week, month", "day");
+    timeSeries.action(async (opts, command) => {
+        await runAction(command, async () => {
+            const projectId = requireProjectId(command);
+            const client = getClient(command);
+            const { data } = await client.GET("/v1/projects/{projectId}/analytics/time-series", {
+                params: {
+                    path: { projectId },
+                    query: {
+                        startDate: opts.start,
+                        endDate: opts.end,
+                        groupBy: opts.groupBy,
+                    },
+                },
+            });
+            formatList(data, command, ["date", "count", "successCount", "failedCount", "totalTokens"]);
+        });
+    });
+    cmd.addCommand(timeSeries);
+    const schemas = new Command("schemas").description("Schema usage statistics");
+    addDateOptions(schemas);
+    schemas.option("--limit <n>", "Max results", "10");
+    schemas.action(async (opts, command) => {
+        await runAction(command, async () => {
+            const projectId = requireProjectId(command);
+            const client = getClient(command);
+            const { data } = await client.GET("/v1/projects/{projectId}/analytics/schemas", {
+                params: {
+                    path: { projectId },
+                    query: {
+                        startDate: opts.start,
+                        endDate: opts.end,
+                        limit: parseInt(opts.limit, 10),
+                    },
+                },
+            });
+            formatList(data, command, ["schemaId", "schemaName", "extractionCount", "successCount", "totalTokens", "averageDurationMs"]);
+        });
+    });
+    cmd.addCommand(schemas);
+    const providers = new Command("providers").description("Provider usage statistics");
+    addDateOptions(providers);
+    providers.action(async (opts, command) => {
+        await runAction(command, async () => {
+            const projectId = requireProjectId(command);
+            const client = getClient(command);
+            const { data } = await client.GET("/v1/projects/{projectId}/analytics/providers", {
+                params: {
+                    path: { projectId },
+                    query: { startDate: opts.start, endDate: opts.end },
+                },
+            });
+            formatList(data, command, ["provider", "model", "extractionCount", "successCount", "totalTokens", "averageDurationMs"]);
+        });
+    });
+    cmd.addCommand(providers);
+    const errors = new Command("errors").description("Error statistics");
+    addDateOptions(errors);
+    errors.option("--limit <n>", "Max results", "10");
+    errors.action(async (opts, command) => {
+        await runAction(command, async () => {
+            const projectId = requireProjectId(command);
+            const client = getClient(command);
+            const { data } = await client.GET("/v1/projects/{projectId}/analytics/errors", {
+                params: {
+                    path: { projectId },
+                    query: {
+                        startDate: opts.start,
+                        endDate: opts.end,
+                        limit: parseInt(opts.limit, 10),
+                    },
+                },
+            });
+            formatList(data, command, ["errorType", "message", "count", "lastOccurrence"]);
+        });
+    });
+    cmd.addCommand(errors);
+    cmd
+        .command("status")
+        .description("Extraction status distribution")
+        .action(async (_opts, command) => {
+        await runAction(command, async () => {
+            const projectId = requireProjectId(command);
+            const client = getClient(command);
+            const { data } = await client.GET("/v1/projects/{projectId}/analytics/status-distribution", { params: { path: { projectId } } });
+            formatDetail(data, command);
+        });
+    });
+    return cmd;
+}
+//# sourceMappingURL=analytics.js.map

package/dist/commands/auth.d.ts

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

package/dist/commands/auth.js

@@ -0,0 +1,115 @@
+import { Command } from "commander";
+import chalk from "chalk";
+import { store, resolveConfig } from "../lib/config.js";
+import { getClient, runAction } from "../lib/client.js";
+import { isJsonOutput } from "../lib/config.js";
+import { createInterface } from "node:readline/promises";
+export function makeAuthCommand() {
+    const cmd = new Command("auth").description("Manage authentication");
+    cmd
+        .command("login")
+        .description("Configure API credentials")
+        .option("--api-key <key>", "API key")
+        .option("--base-url <url>", "Base URL")
+        .action(async (opts) => {
+        let apiKey = opts.apiKey;
+        let baseUrl = opts.baseUrl;
+        if (!apiKey || !baseUrl) {
+            const rl = createInterface({
+                input: process.stdin,
+                output: process.stdout,
+            });
+            try {
+                if (!baseUrl) {
+                    baseUrl = await rl.question(`Base URL [${store.get("baseUrl") ?? "https://backbone.manfred-kunze.dev/api"}]: `);
+                    if (!baseUrl)
+                        baseUrl = store.get("baseUrl") ?? "https://backbone.manfred-kunze.dev/api";
+                }
+                if (!apiKey) {
+                    apiKey = await rl.question("API Key (sk_...): ");
+                }
+            }
+            finally {
+                rl.close();
+            }
+        }
+        if (!apiKey) {
+            console.error(chalk.red("API key is required."));
+            process.exit(1);
+        }
+        store.set("apiKey", apiKey);
+        store.set("baseUrl", baseUrl);
+        console.log(chalk.green("Credentials saved successfully."));
+        console.log(chalk.dim(`Config stored at: ${store.path}`));
+    });
+    cmd
+        .command("logout")
+        .description("Clear stored credentials")
+        .action(() => {
+        store.delete("apiKey");
+        store.delete("baseUrl");
+        store.delete("project");
+        console.log(chalk.green("Credentials cleared."));
+    });
+    cmd
+        .command("status")
+        .description("Show current authentication status")
+        .action(async (_opts, command) => {
+        await runAction(command, async () => {
+            const json = isJsonOutput(command);
+            let config;
+            try {
+                config = resolveConfig(command);
+            }
+            catch {
+                if (json) {
+                    console.log(JSON.stringify({ authenticated: false }));
+                }
+                else {
+                    console.log(chalk.yellow("Not authenticated."));
+                    console.log(chalk.dim('Run "backbone auth login" to configure.'));
+                }
+                return;
+            }
+            const { apiKey, baseUrl } = config;
+            const keyPreview = apiKey.slice(0, 7) + "..." + apiKey.slice(-4);
+            // Try to validate by listing models (lightweight call)
+            try {
+                const client = getClient(command);
+                const { data } = await client.GET("/v1/models");
+                const modelCount = data?.data?.length ?? 0;
+                if (json) {
+                    console.log(JSON.stringify({
+                        authenticated: true,
+                        baseUrl,
+                        apiKeyPreview: keyPreview,
+                        modelCount,
+                    }));
+                }
+                else {
+                    console.log(chalk.green("Authenticated"));
+                    console.log(`  Base URL:  ${baseUrl}`);
+                    console.log(`  API Key:   ${keyPreview}`);
+                    console.log(`  Models:    ${modelCount} available`);
+                }
+            }
+            catch {
+                if (json) {
+                    console.log(JSON.stringify({
+                        authenticated: false,
+                        baseUrl,
+                        apiKeyPreview: keyPreview,
+                        error: "Failed to validate credentials",
+                    }));
+                }
+                else {
+                    console.log(chalk.yellow("Credentials configured but validation failed."));
+                    console.log(`  Base URL:  ${baseUrl}`);
+                    console.log(`  API Key:   ${keyPreview}`);
+                }
+            }
+        });
+    });
+    return cmd;
+}
+//# sourceMappingURL=auth.js.map

package/dist/commands/billing.d.ts

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

package/dist/commands/billing.js

@@ -0,0 +1,100 @@
+import { Command } from "commander";
+import { getClient, runAction } from "../lib/client.js";
+import { isJsonOutput } from "../lib/config.js";
+import { formatDetail, formatList } from "../lib/output.js";
+import chalk from "chalk";
+export function makeBillingCommand() {
+    const cmd = new Command("billing").description("Billing and subscription management");
+    cmd
+        .command("tiers")
+        .description("List available subscription tiers")
+        .action(async (_opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            const { data } = await client.GET("/v1/billing/tiers");
+            formatList(data, command, ["name", "displayName", "maxProjects", "maxSchemas", "monthlyExtractionCredits", "monthlyGatewayTokens"]);
+        });
+    });
+    cmd
+        .command("tier")
+        .description("Show current organization tier")
+        .action(async (_opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            const { data } = await client.GET("/v1/billing/tier");
+            formatDetail(data, command);
+        });
+    });
+    cmd
+        .command("limits")
+        .description("Show current usage and limits")
+        .action(async (_opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            const { data } = await client.GET("/v1/billing/limits");
+            if (isJsonOutput(command)) {
+                console.log(JSON.stringify(data, null, 2));
+            }
+            else {
+                console.log(chalk.cyan(`Tier: ${data?.tier ?? "unknown"}`));
+                console.log();
+                if (data?.resources?.length) {
+                    console.log(chalk.bold("Resources:"));
+                    for (const r of data.resources) {
+                        const label = r.displayName ?? r.resourceType;
+                        const bar = r.limit === -1
+                            ? chalk.green("unlimited")
+                            : `${r.used ?? 0} / ${r.limit ?? 0} (${r.remaining ?? 0} remaining)`;
+                        console.log(`  ${chalk.bold(String(label))}: ${bar}`);
+                    }
+                    console.log();
+                }
+                console.log(chalk.bold("Usage:"));
+                console.log(`  Projects:     ${data?.currentProjects ?? 0} / ${data?.maxProjects ?? 0}`);
+                console.log(`  Schemas:      ${data?.currentSchemas ?? 0} / ${data?.maxSchemas ?? 0}`);
+                console.log(`  Prompts:      ${data?.currentPrompts ?? 0} / ${data?.maxPrompts ?? 0}`);
+                console.log(`  Team members: ${data?.currentTeamMembers ?? 0} / ${data?.maxTeamMembers ?? 0}`);
+                console.log();
+                console.log(chalk.bold("Features:"));
+                console.log(`  BYOK:             ${data?.byokEnabled ? chalk.green("yes") : chalk.dim("no")}`);
+                console.log(`  Priority support: ${data?.prioritySupport ? chalk.green("yes") : chalk.dim("no")}`);
+                if (data?.periodStart || data?.periodEnd) {
+                    console.log();
+                    console.log(chalk.dim(`Period: ${data.periodStart?.slice(0, 10) ?? "?"} \u2192 ${data.periodEnd?.slice(0, 10) ?? "?"}`));
+                }
+            }
+        });
+    });
+    cmd
+        .command("check")
+        .description("Check if a resource can be created")
+        .argument("<resource>", "Resource type: project, schema, prompt, team-member")
+        .action(async (resource, _opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            const endpoints = {
+                project: "/v1/billing/can-create-project",
+                schema: "/v1/billing/can-create-schema",
+                prompt: "/v1/billing/can-create-prompt",
+                "team-member": "/v1/billing/can-add-team-member",
+            };
+            const endpoint = endpoints[resource];
+            if (!endpoint) {
+                throw new Error(`Unknown resource: "${resource}". Use: project, schema, prompt, team-member`);
+            }
+            const { data } = await client.GET(endpoint);
+            const result = data?.result;
+            if (isJsonOutput(command)) {
+                console.log(JSON.stringify({ resource, canCreate: result }));
+            }
+            else if (result) {
+                console.log(chalk.green(`You can create a new ${resource}.`));
+            }
+            else {
+                console.log(chalk.yellow(`You cannot create a new ${resource}. Upgrade your tier or check limits.`));
+            }
+        });
+    });
+    return cmd;
+}
+//# sourceMappingURL=billing.js.map

package/dist/commands/config.d.ts

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

package/dist/commands/config.js

@@ -0,0 +1,70 @@
+import { Command } from "commander";
+import chalk from "chalk";
+import { store, isJsonOutput } from "../lib/config.js";
+const ALLOWED_KEYS = ["apiKey", "baseUrl", "project"];
+function validateKey(key) {
+    if (!ALLOWED_KEYS.includes(key)) {
+        throw new Error(`Unknown config key: "${key}". Allowed keys: ${ALLOWED_KEYS.join(", ")}`);
+    }
+    return key;
+}
+export function makeConfigCommand() {
+    const cmd = new Command("config").description("Manage CLI configuration");
+    cmd
+        .command("set")
+        .description("Set a configuration value")
+        .argument("<key>", `Config key (${ALLOWED_KEYS.join(", ")})`)
+        .argument("<value>", "Config value")
+        .action((key, value, _opts, command) => {
+        const validKey = validateKey(key);
+        store.set(validKey, value);
+        if (isJsonOutput(command)) {
+            console.log(JSON.stringify({ key: validKey, value }));
+        }
+        else {
+            console.log(chalk.green(`Set ${validKey} = ${validKey === "apiKey" ? "****" : value}`));
+        }
+    });
+    cmd
+        .command("get")
+        .description("Get a configuration value")
+        .argument("<key>", `Config key (${ALLOWED_KEYS.join(", ")})`)
+        .action((key, _opts, command) => {
+        const validKey = validateKey(key);
+        const value = store.get(validKey);
+        if (isJsonOutput(command)) {
+            console.log(JSON.stringify({ key: validKey, value: value ?? null }));
+        }
+        else if (value) {
+            console.log(validKey === "apiKey" ? "****" : value);
+        }
+        else {
+            console.log(chalk.dim("(not set)"));
+        }
+    });
+    cmd
+        .command("list")
+        .description("Show all configuration values")
+        .action((_opts, command) => {
+        const values = {};
+        for (const key of ALLOWED_KEYS) {
+            values[key] = store.get(key);
+        }
+        if (isJsonOutput(command)) {
+            console.log(JSON.stringify(values, null, 2));
+        }
+        else {
+            for (const [key, value] of Object.entries(values)) {
+                const display = !value
+                    ? chalk.dim("(not set)")
+                    : key === "apiKey"
+                        ? value.slice(0, 7) + "..." + value.slice(-4)
+                        : value;
+                console.log(`${chalk.cyan(key)}: ${display}`);
+            }
+            console.log(chalk.dim(`\nConfig file: ${store.path}`));
+        }
+    });
+    return cmd;
+}
+//# sourceMappingURL=config.js.map

package/dist/commands/convert.d.ts

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

package/dist/commands/convert.js

@@ -0,0 +1,123 @@
+import { Command } from "commander";
+import { readFileSync } from "node:fs";
+import { basename } from "node:path";
+import { getClient, runAction } from "../lib/client.js";
+import { formatDetail, withSpinner } from "../lib/output.js";
+import { getMimeType } from "../lib/multipart.js";
+function mapFormat(format) {
+    const map = {
+        markdown: "MD",
+        md: "MD",
+        text: "TEXT",
+        txt: "TEXT",
+        json: "JSON",
+        html: "HTML",
+    };
+    return map[format.toLowerCase()] ?? format.toUpperCase();
+}
+export function makeConvertCommand() {
+    const cmd = new Command("convert").description("Convert documents");
+    cmd
+        .command("file")
+        .description("Convert local files")
+        .argument("<paths...>", "File paths to convert")
+        .option("--format <formats...>", "Output formats (md, text, html, json)", ["md"])
+        .option("--pipeline <name>", "Pipeline (standard, vlm)")
+        .option("--async", "Run asynchronously")
+        .action(async (paths, opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            // Build base64 sources from local files
+            const sources = paths.map((p) => {
+                const buffer = readFileSync(p);
+                const filename = basename(p);
+                return {
+                    kind: "Base64Source",
+                    content: buffer.toString("base64"),
+                    filename,
+                    mimeType: getMimeType(filename),
+                };
+            });
+            const toFormats = opts.format.map(mapFormat);
+            const body = {
+                sources,
+                options: {
+                    toFormats,
+                    pipeline: opts.pipeline,
+                },
+            };
+            if (opts.async) {
+                const { data } = await withSpinner("Submitting conversion...", () => client.POST("/v1/convert/source/async", { body }));
+                formatDetail(data, command);
+            }
+            else {
+                const { data } = await withSpinner("Converting...", () => client.POST("/v1/convert/source", { body }));
+                formatDetail(data, command);
+            }
+        });
+    });
+    cmd
+        .command("url")
+        .description("Convert documents from URLs")
+        .argument("<urls...>", "URLs to convert")
+        .option("--format <formats...>", "Output formats (md, text, html, json)", ["md"])
+        .option("--pipeline <name>", "Pipeline (standard, vlm)")
+        .option("--async", "Run asynchronously")
+        .action(async (urls, opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            const sources = urls.map((url) => ({
+                kind: "HttpSource",
+                url,
+            }));
+            const toFormats = opts.format.map(mapFormat);
+            const body = {
+                sources,
+                options: {
+                    toFormats,
+                    pipeline: opts.pipeline,
+                },
+            };
+            if (opts.async) {
+                const { data } = await withSpinner("Submitting conversion...", () => client.POST("/v1/convert/source/async", { body }));
+                formatDetail(data, command);
+            }
+            else {
+                const { data } = await withSpinner("Converting...", () => client.POST("/v1/convert/source", { body }));
+                formatDetail(data, command);
+            }
+        });
+    });
+    cmd
+        .command("status")
+        .description("Check async conversion task status")
+        .argument("<taskId>", "Task ID")
+        .option("-w, --wait", "Wait for completion")
+        .action(async (taskId, opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            const { data } = await client.GET("/v1/convert/tasks/{taskId}", {
+                params: {
+                    path: { taskId },
+                    query: { wait: opts.wait },
+                },
+            });
+            formatDetail(data, command);
+        });
+    });
+    cmd
+        .command("result")
+        .description("Get async conversion task result")
+        .argument("<taskId>", "Task ID")
+        .action(async (taskId, _opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            const { data } = await client.GET("/v1/convert/tasks/{taskId}/result", {
+                params: { path: { taskId } },
+            });
+            formatDetail(data, command);
+        });
+    });
+    return cmd;
+}
+//# sourceMappingURL=convert.js.map

package/dist/commands/extractions.d.ts

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