@2kw/ai 4.0.0-dev.2

package/dist/commands/config.js

@@ -0,0 +1,90 @@
+import { Command } from "commander";
+import chalk from "chalk";
+import { store, isJsonOutput, getActiveContext, getActiveContextName, getContextCount, setContext, DEFAULT_BASE_URL, } from "../lib/config.js";
+const ALLOWED_KEYS = ["apiKey", "baseUrl"];
+const KEY_ALIASES = {
+    "api-key": "apiKey",
+    "base-url": "baseUrl",
+};
+function validateKey(key) {
+    if (key === "project") {
+        throw new Error('The "project" config key is no longer supported — resources are scoped by organization.');
+    }
+    const normalized = KEY_ALIASES[key] ?? key;
+    if (!ALLOWED_KEYS.includes(normalized)) {
+        throw new Error(`Unknown config key: "${key}". Allowed keys: ${ALLOWED_KEYS.join(", ")}`);
+    }
+    return normalized;
+}
+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);
+        // Update the active context
+        const contextName = getActiveContextName();
+        const ctx = getActiveContext() ?? {
+            apiKey: "",
+            baseUrl: DEFAULT_BASE_URL,
+        };
+        ctx[validKey] = value;
+        setContext(contextName, ctx);
+        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 ctx = getActiveContext();
+        const value = ctx?.[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 ctx = getActiveContext();
+        const values = {
+            apiKey: ctx?.apiKey,
+            baseUrl: ctx?.baseUrl,
+        };
+        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}`);
+            }
+            if (getContextCount() > 1) {
+                console.log(chalk.dim(`\nContext: ${getActiveContextName()} (use "backbone context list" to see all)`));
+            }
+            console.log(chalk.dim(`\nConfig file: ${store.path}`));
+        }
+    });
+    return cmd;
+}
+//# sourceMappingURL=config.js.map

package/dist/commands/context.d.ts

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

package/dist/commands/context.js

@@ -0,0 +1,149 @@
+import { Command } from "commander";
+import chalk from "chalk";
+import Table from "cli-table3";
+import { createInterface } from "node:readline/promises";
+import { store, isJsonOutput, getAllContexts, getActiveContextName, getContextCount, setContext, deleteContext, renameContext, setActiveContext, validateContextName, DEFAULT_BASE_URL, } from "../lib/config.js";
+function maskApiKey(key) {
+    if (key.length <= 11)
+        return "****";
+    return key.slice(0, 7) + "..." + key.slice(-4);
+}
+export function makeContextCommand() {
+    const cmd = new Command("context").description("Manage CLI contexts for multiple environments");
+    cmd
+        .command("list")
+        .description("List all contexts")
+        .action((_opts, command) => {
+        const contexts = getAllContexts();
+        const activeName = getActiveContextName();
+        if (isJsonOutput(command)) {
+            console.log(JSON.stringify({ activeContext: activeName, contexts }, null, 2));
+            return;
+        }
+        const names = Object.keys(contexts);
+        if (names.length === 0) {
+            console.log(chalk.dim('No contexts configured. Run "backbone auth login" to get started.'));
+            return;
+        }
+        const table = new Table({
+            head: ["", "NAME", "BASE URL", "API KEY"].map((h) => chalk.cyan(h)),
+        });
+        for (const name of names) {
+            const ctx = contexts[name];
+            table.push([
+                name === activeName ? chalk.green("*") : "",
+                name,
+                ctx.baseUrl,
+                maskApiKey(ctx.apiKey),
+            ]);
+        }
+        console.log(table.toString());
+    });
+    cmd
+        .command("use")
+        .description("Switch active context")
+        .argument("<name>", "Context name")
+        .action((name, _opts, command) => {
+        setActiveContext(name);
+        if (isJsonOutput(command)) {
+            console.log(JSON.stringify({ activeContext: name }));
+        }
+        else {
+            console.log(chalk.green(`Switched to context "${name}".`));
+        }
+    });
+    cmd
+        .command("create")
+        .description("Create a new context")
+        .argument("<name>", "Context name")
+        .option("--base-url <url>", "Base URL")
+        .option("--api-key <key>", "API key")
+        .action(async (name, opts) => {
+        validateContextName(name);
+        const contexts = getAllContexts();
+        if (contexts[name]) {
+            throw new Error(`Context "${name}" already exists. Delete it first or choose a different name.`);
+        }
+        let baseUrl = opts.baseUrl;
+        let apiKey = opts.apiKey;
+        if (!baseUrl || !apiKey) {
+            const rl = createInterface({
+                input: process.stdin,
+                output: process.stdout,
+            });
+            try {
+                if (!baseUrl) {
+                    baseUrl = await rl.question(`Base URL [${DEFAULT_BASE_URL}]: `);
+                    if (!baseUrl)
+                        baseUrl = DEFAULT_BASE_URL;
+                }
+                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);
+        }
+        const entry = { baseUrl, apiKey };
+        setContext(name, entry);
+        // Auto-set as active if it's the first context
+        if (getContextCount() === 1) {
+            setActiveContext(name);
+        }
+        console.log(chalk.green(`Context "${name}" created.`));
+        console.log(chalk.dim(`Config stored at: ${store.path}`));
+    });
+    cmd
+        .command("current")
+        .description("Show the active context")
+        .action((_opts, command) => {
+        const name = getActiveContextName();
+        const contexts = getAllContexts();
+        const ctx = contexts[name];
+        if (isJsonOutput(command)) {
+            console.log(JSON.stringify({ name, ...(ctx ?? {}) }, null, 2));
+            return;
+        }
+        if (!ctx) {
+            console.log(chalk.yellow('No active context configured. Run "backbone auth login" to get started.'));
+            return;
+        }
+        console.log(`${chalk.cyan("Context")}: ${name}`);
+        console.log(`${chalk.cyan("Base URL")}: ${ctx.baseUrl}`);
+        console.log(`${chalk.cyan("API Key")}:  ${maskApiKey(ctx.apiKey)}`);
+    });
+    cmd
+        .command("delete")
+        .description("Delete a context")
+        .argument("<name>", "Context name")
+        .action((name, _opts, command) => {
+        deleteContext(name);
+        if (isJsonOutput(command)) {
+            console.log(JSON.stringify({ deleted: name }));
+        }
+        else {
+            console.log(chalk.green(`Context "${name}" deleted.`));
+        }
+    });
+    cmd
+        .command("rename")
+        .description("Rename a context")
+        .argument("<old>", "Current name")
+        .argument("<new>", "New name")
+        .action((oldName, newName, _opts, command) => {
+        renameContext(oldName, newName);
+        if (isJsonOutput(command)) {
+            console.log(JSON.stringify({ from: oldName, to: newName }));
+        }
+        else {
+            console.log(chalk.green(`Context "${oldName}" renamed to "${newName}".`));
+        }
+    });
+    return cmd;
+}
+//# sourceMappingURL=context.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,291 @@
+import { Command } from "commander";
+import { readFileSync, writeFileSync } from "node:fs";
+import chalk from "chalk";
+import { getClient, runAction } from "../lib/client.js";
+import { resolveConfig, isJsonOutput } from "../lib/config.js";
+import { BackboneApiError } from "../lib/errors.js";
+import { formatDetail, withSpinner } from "../lib/output.js";
+import { fileToBlob, 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();
+}
+/**
+ * Extract the primary content from a document based on the requested formats.
+ * Prefers markdown > text > html.
+ */
+function getPrimaryContent(doc, formats) {
+    const upper = formats.map((f) => f.toUpperCase());
+    if (upper.includes("MD") && doc.mdContent)
+        return doc.mdContent;
+    if (upper.includes("TEXT") && doc.textContent)
+        return doc.textContent;
+    if (upper.includes("HTML") && doc.htmlContent)
+        return doc.htmlContent;
+    if (upper.includes("JSON") && doc.jsonContent)
+        return JSON.stringify(doc.jsonContent.content ?? doc.jsonContent, null, 2);
+    return doc.mdContent ?? doc.textContent ?? doc.htmlContent ?? "";
+}
+function formatBytes(bytes) {
+    if (bytes < 1024)
+        return `${bytes} B`;
+    if (bytes < 1024 * 1024)
+        return `${(bytes / 1024).toFixed(1)} KB`;
+    return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+/**
+ * Output conversion result: --json, --output, or human-readable.
+ */
+function outputConvertResult(data, command, opts) {
+    if (isJsonOutput(command)) {
+        console.log(JSON.stringify(data, null, 2));
+        return;
+    }
+    const result = data;
+    const docs = result.documents ?? [];
+    const formats = opts.format.map(mapFormat);
+    // --output: write content to file
+    if (opts.output) {
+        // For JSON format, produce a valid JSON array instead of ---‑separated objects
+        const isJson = formats.some((f) => f.toUpperCase() === "JSON");
+        let content;
+        if (isJson) {
+            const jsonParts = docs
+                .map((doc) => doc.jsonContent?.content ?? doc.jsonContent)
+                .filter(Boolean);
+            content = JSON.stringify(jsonParts.length === 1 ? jsonParts[0] : jsonParts, null, 2);
+        }
+        else {
+            const parts = docs.map((doc) => getPrimaryContent(doc, formats));
+            content = parts.join("\n\n---\n\n");
+        }
+        writeFileSync(opts.output, content, "utf-8");
+        const size = Buffer.byteLength(content, "utf-8");
+        console.error(chalk.green(`Wrote ${formatBytes(size)} to ${opts.output}`));
+        return;
+    }
+    // Human-readable output
+    const timeStr = result.processingTime
+        ? ` (${result.processingTime.toFixed(1)}s)`
+        : "";
+    const count = docs.length;
+    console.log(chalk.green(`Converted ${count} document${count !== 1 ? "s" : ""}${timeStr}`));
+    if (result.errors?.length) {
+        for (const err of result.errors) {
+            console.log(chalk.yellow(`  Warning: ${err.filename ?? "unknown"} — ${err.errorMessage ?? "error"}`));
+        }
+    }
+    for (const doc of docs) {
+        const content = getPrimaryContent(doc, formats);
+        const size = formatBytes(Buffer.byteLength(content, "utf-8"));
+        console.log(chalk.dim(`\n--- ${doc.filename ?? "document"} (${size}) ---\n`));
+        console.log(content);
+    }
+}
+/**
+ * Poll an async task until terminal status, then fetch and return the result.
+ */
+async function waitForTask(client, taskId, waitSeconds) {
+    const terminalStatuses = new Set(["SUCCESS", "PARTIAL_SUCCESS", "FAILURE", "COMPLETED", "FAILED"]);
+    // Poll until done
+    let status;
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+        const { data } = await client.GET("/v1/convert/tasks/{taskId}", {
+            params: {
+                path: { taskId },
+                query: { wait: waitSeconds },
+            },
+        });
+        status = data;
+        if (status?.taskStatus && terminalStatuses.has(status.taskStatus.toUpperCase())) {
+            break;
+        }
+    }
+    // Fetch final result
+    const { data } = await client.GET("/v1/convert/tasks/{taskId}/result", {
+        params: { path: { taskId } },
+    });
+    return data;
+}
+function buildFormData(paths, opts) {
+    const formData = new FormData();
+    const outputFormats = opts.format.map(mapFormat);
+    for (const p of paths) {
+        if (p === "-") {
+            const name = opts.filename ?? "document";
+            const buffer = readFileSync(0);
+            const blob = new Blob([buffer], { type: getMimeType(name) });
+            formData.append("files", blob, name);
+        }
+        else {
+            const { blob, filename } = fileToBlob(p);
+            formData.append("files", blob, filename);
+        }
+    }
+    const pipelineOptions = { outputFormats };
+    if (opts.imageMode)
+        pipelineOptions.imageExportMode = opts.imageMode;
+    formData.append("options", new Blob([JSON.stringify(pipelineOptions)], { type: "application/json" }));
+    return formData;
+}
+async function multipartConvert(command, formData, endpoint, pipeline) {
+    const config = resolveConfig(command);
+    const baseUrl = config.baseUrl.replace(/\/+$/, "");
+    const url = pipeline
+        ? `${baseUrl}${endpoint}?pipeline=${encodeURIComponent(pipeline)}`
+        : `${baseUrl}${endpoint}`;
+    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 (await res.json());
+}
+export function makeConvertCommand() {
+    const cmd = new Command("convert").description("Convert documents");
+    cmd
+        .command("file")
+        .description("Convert local files (use - to read from stdin)")
+        .argument("<paths...>", "File paths to convert (use - for stdin)")
+        .option("--format <formats...>", "Output formats (md, text, html, json)", ["md"])
+        .option("--pipeline <name>", "Pipeline: fast (default), ocr, vlm. For compound files (MSG/EML), applies to attachments; email body is always plain text")
+        .option("--image-mode <mode>", "Image export mode (placeholder, embedded)")
+        .option("-o, --output <path>", "Write content to file instead of stdout")
+        .option("--filename <name>", "Filename for MIME detection when reading from stdin")
+        .option("--async", "Run asynchronously")
+        .option("-w, --wait [seconds]", "With --async: wait for completion (default: 30s)", parseFloat)
+        .action(async (paths, opts, command) => {
+        await runAction(command, async () => {
+            const formData = buildFormData(paths, opts);
+            if (opts.async) {
+                const data = await withSpinner("Submitting conversion...", () => multipartConvert(command, formData, "/v1/convert/file/async", opts.pipeline));
+                if (opts.wait !== undefined) {
+                    const waitSeconds = opts.wait === true ? 30 : opts.wait;
+                    const taskId = data?.taskId;
+                    if (!taskId)
+                        throw new Error("No taskId returned from async submission");
+                    const client = getClient(command);
+                    const result = await withSpinner("Waiting for completion...", () => waitForTask(client, taskId, waitSeconds));
+                    outputConvertResult(result, command, opts);
+                }
+                else {
+                    formatDetail(data, command);
+                }
+            }
+            else {
+                const data = await withSpinner("Converting...", () => multipartConvert(command, formData, "/v1/convert/file", opts.pipeline));
+                outputConvertResult(data, command, opts);
+            }
+        });
+    });
+    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: fast (default), ocr, vlm. For compound files (MSG/EML), applies to attachments; email body is always plain text")
+        .option("--image-mode <mode>", "Image export mode (placeholder, embedded)")
+        .option("-o, --output <path>", "Write content to file instead of stdout")
+        .option("--async", "Run asynchronously")
+        .option("-w, --wait [seconds]", "With --async: wait for completion (default: 30s)", parseFloat)
+        .action(async (urls, opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            const sources = urls.map((url) => ({
+                kind: "http",
+                url,
+            }));
+            const outputFormats = opts.format.map(mapFormat);
+            const body = {
+                sources,
+                options: {
+                    pipeline: opts.pipeline,
+                    options: {
+                        outputFormats,
+                        ...(opts.imageMode && { imageExportMode: opts.imageMode }),
+                    },
+                },
+            };
+            if (opts.async) {
+                const { data } = await withSpinner("Submitting conversion...", () => 
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                client.POST("/v1/convert/source/async", { body }));
+                if (opts.wait !== undefined) {
+                    const waitSeconds = opts.wait === true ? 30 : opts.wait;
+                    const taskId = data?.taskId;
+                    if (!taskId)
+                        throw new Error("No taskId returned from async submission");
+                    const result = await withSpinner("Waiting for completion...", () => waitForTask(client, taskId, waitSeconds));
+                    outputConvertResult(result, command, opts);
+                }
+                else {
+                    formatDetail(data, command);
+                }
+            }
+            else {
+                const { data } = await withSpinner("Converting...", () => 
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                client.POST("/v1/convert/source", { body }));
+                outputConvertResult(data, command, opts);
+            }
+        });
+    });
+    cmd
+        .command("status")
+        .description("Check async conversion task status")
+        .argument("<taskId>", "Task ID")
+        .option("-w, --wait [seconds]", "Wait for completion (default: 30s)", parseFloat)
+        .action(async (taskId, opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            const wait = opts.wait === true ? 30 : opts.wait;
+            const { data } = await client.GET("/v1/convert/tasks/{taskId}", {
+                params: {
+                    path: { taskId },
+                    query: { wait },
+                },
+            });
+            formatDetail(data, command);
+        });
+    });
+    cmd
+        .command("result")
+        .description("Get async conversion task result")
+        .argument("<taskId>", "Task ID")
+        .option("-o, --output <path>", "Write content to file instead of stdout")
+        .option("--format <formats...>", "Preferred format for --output (md, text, html)", ["md"])
+        .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 } },
+            });
+            outputConvertResult(data, command, opts);
+        });
+    });
+    return cmd;
+}
+//# sourceMappingURL=convert.js.map

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

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

package/dist/commands/dataset-versions.js

@@ -0,0 +1,90 @@
+import { Command } from "commander";
+import { getClient, runAction } from "../lib/client.js";
+import { resolveLatestVersionId } from "../lib/datasets.js";
+import { formatPage, formatDetail } from "../lib/output.js";
+import { addPaginationOptions, paginationParams } from "../lib/pagination.js";
+export function makeDatasetVersionsCommand() {
+    const cmd = new Command("versions").description("Manage dataset versions");
+    const list = new Command("list").description("List versions of a dataset");
+    addPaginationOptions(list);
+    list.requiredOption("--dataset <id>", "Dataset ID");
+    list.action(async (opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            const { data } = await client.GET("/v1/datasets/{id}/versions", {
+                params: {
+                    path: { id: opts.dataset },
+                    query: paginationParams(opts),
+                },
+            });
+            formatPage(data, command, ["id", "versionNumber", "itemCount", "changeDescription", "createdAt"]);
+        });
+    });
+    cmd.addCommand(list);
+    cmd
+        .command("get")
+        .description("Get a specific dataset version")
+        .argument("<versionId>", "Version ID")
+        .requiredOption("--dataset <id>", "Dataset ID")
+        .action(async (versionId, opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            const { data } = await client.GET("/v1/datasets/{id}/versions/{versionId}", {
+                params: {
+                    path: { id: opts.dataset, versionId },
+                },
+            });
+            formatDetail(data, command);
+        });
+    });
+    cmd
+        .command("create")
+        .description("Create a new dataset version")
+        .requiredOption("--dataset <id>", "Dataset ID")
+        .option("-m, --message <text>", "Change description")
+        .action(async (opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            const { data } = await client.POST("/v1/datasets/{id}/versions", {
+                params: { path: { id: opts.dataset } },
+                body: { changeDescription: opts.message },
+            });
+            formatDetail(data, command);
+        });
+    });
+    cmd
+        .command("latest")
+        .description("Get the latest version of a dataset")
+        .requiredOption("--dataset <id>", "Dataset ID")
+        .action(async (opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            const { data } = await client.GET("/v1/datasets/{id}/versions/latest", {
+                params: {
+                    path: { id: opts.dataset },
+                },
+            });
+            formatDetail(data, command);
+        });
+    });
+    const items = new Command("items").description("List items in a dataset version (defaults to latest version)");
+    addPaginationOptions(items);
+    items.requiredOption("--dataset <id>", "Dataset ID");
+    items.option("--version-id <id>", "Version ID (defaults to latest)");
+    items.action(async (opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            const versionId = opts.versionId ?? (await resolveLatestVersionId(client, opts.dataset));
+            const { data } = await client.GET("/v1/datasets/{id}/versions/{versionId}/items", {
+                params: {
+                    path: { id: opts.dataset, versionId },
+                    query: paginationParams(opts),
+                },
+            });
+            formatPage(data, command, ["id", "input", "expectedOutput", "tags", "createdAt"]);
+        });
+    });
+    cmd.addCommand(items);
+    return cmd;
+}
+//# sourceMappingURL=dataset-versions.js.map

package/dist/commands/datasets.d.ts

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