@manfred-kunze-dev/backbone-cli 2.9.0-dev.2 → 2.10.0-dev.1

package/dist/commands/config.js

@@ -2,11 +2,16 @@ import { Command } from "commander";
 import chalk from "chalk";
 import { store, isJsonOutput } from "../lib/config.js";
 const ALLOWED_KEYS = ["apiKey", "baseUrl", "project"];
+const KEY_ALIASES = {
+    "api-key": "apiKey",
+    "base-url": "baseUrl",
+};
 function validateKey(key) {
-    if (!ALLOWED_KEYS.includes(key)) {
+    const normalized = KEY_ALIASES[key] ?? key;
+    if (!ALLOWED_KEYS.includes(normalized)) {
         throw new Error(`Unknown config key: "${key}". Allowed keys: ${ALLOWED_KEYS.join(", ")}`);
     }
-    return key;
+    return normalized;
 }
 export function makeConfigCommand() {
     const cmd = new Command("config").description("Manage CLI configuration");

package/dist/commands/convert.js

@@ -1,7 +1,9 @@
 import { Command } from "commander";
-import { readFileSync } from "node:fs";
+import { readFileSync, writeFileSync } from "node:fs";
 import { basename } from "node:path";
+import chalk from "chalk";
 import { getClient, runAction } from "../lib/client.js";
+import { isJsonOutput } from "../lib/config.js";
 import { formatDetail, withSpinner } from "../lib/output.js";
 import { getMimeType } from "../lib/multipart.js";
 function mapFormat(format) {
@@ -15,30 +17,130 @@ function mapFormat(format) {
     };
     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;
+    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) {
+        const parts = docs.map((doc) => getPrimaryContent(doc, formats));
+        const 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 buildSources(paths, filename) {
+    return paths.map((p) => {
+        if (p === "-") {
+            const name = filename ?? "document";
+            const buffer = readFileSync(0);
+            return {
+                kind: "base64",
+                content: buffer.toString("base64"),
+                filename: name,
+                mimeType: getMimeType(name),
+            };
+        }
+        const buffer = readFileSync(p);
+        const name = basename(p);
+        return {
+            kind: "base64",
+            content: buffer.toString("base64"),
+            filename: name,
+            mimeType: getMimeType(name),
+        };
+    });
+}
 export function makeConvertCommand() {
     const cmd = new Command("convert").description("Convert documents");
     cmd
         .command("file")
-        .description("Convert local files")
-        .argument("<paths...>", "File paths to convert")
+        .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 client = getClient(command);
-            // Build base64 sources from local files
-            const sources = paths.map((p) => {
-                const buffer = readFileSync(p);
-                const filename = basename(p);
-                return {
-                    kind: "base64",
-                    content: buffer.toString("base64"),
-                    filename,
-                    mimeType: getMimeType(filename),
-                };
-            });
+            const sources = buildSources(paths, opts.filename);
             const outputFormats = opts.format.map(mapFormat);
             const body = {
                 sources,
@@ -52,11 +154,21 @@ export function makeConvertCommand() {
             };
             if (opts.async) {
                 const { data } = await withSpinner("Submitting conversion...", () => client.POST("/v1/convert/source/async", { body }));
-                formatDetail(data, command);
+                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...", () => client.POST("/v1/convert/source", { body }));
-                formatDetail(data, command);
+                outputConvertResult(data, command, opts);
             }
         });
     });
@@ -67,7 +179,9 @@ export function makeConvertCommand() {
         .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);
@@ -88,11 +202,21 @@ export function makeConvertCommand() {
             };
             if (opts.async) {
                 const { data } = await withSpinner("Submitting conversion...", () => client.POST("/v1/convert/source/async", { body }));
-                formatDetail(data, command);
+                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...", () => client.POST("/v1/convert/source", { body }));
-                formatDetail(data, command);
+                outputConvertResult(data, command, opts);
             }
         });
     });
@@ -118,13 +242,15 @@ export function makeConvertCommand() {
         .command("result")
         .description("Get async conversion task result")
         .argument("<taskId>", "Task ID")
-        .action(async (taskId, _opts, command) => {
+        .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 } },
             });
-            formatDetail(data, command);
+            outputConvertResult(data, command, opts);
         });
     });
     return cmd;

package/dist/commands/extractions.js

@@ -29,8 +29,8 @@ export function makeExtractionsCommand() {
         .description("Create a new extraction")
         .requiredOption("--schema <id>", "Schema ID")
         .requiredOption("-m, --model <model>", "Model to use (provider/model)")
-        .option("-t, --text <text>", "Input text")
-        .option("-f, --file <path>", "Read input text from file")
+        .option("-t, --text <text>", "Input text (use - for stdin)")
+        .option("-f, --file <path>", "Read input text from file (use - for stdin)")
         .option("--images <paths...>", "Image file paths")
         .option("--version-id <id>", "Schema version ID")
         .option("-l, --label <name>", "Schema label")
@@ -39,9 +39,9 @@ export function makeExtractionsCommand() {
         await runAction(command, async () => {
             const projectId = requireProjectId(command);
             const client = getClient(command);
-            let text = opts.text;
+            let text = opts.text === "-" ? readFileSync(0, "utf-8") : opts.text;
             if (opts.file) {
-                text = readFileSync(opts.file, "utf-8");
+                text = opts.file === "-" ? readFileSync(0, "utf-8") : readFileSync(opts.file, "utf-8");
             }
             const images = opts.images ? readImages(opts.images) : undefined;
             const body = {

package/package.json

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