@2kw/ai 4.0.0-dev.2

package/dist/lib/multipart.js

@@ -0,0 +1,59 @@
+import { readFileSync } from "node:fs";
+import { basename, extname } from "node:path";
+const MIME_TYPES = {
+    ".pdf": "application/pdf",
+    ".doc": "application/msword",
+    ".docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+    ".xls": "application/vnd.ms-excel",
+    ".xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+    ".ppt": "application/vnd.ms-powerpoint",
+    ".pptx": "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+    ".odt": "application/vnd.oasis.opendocument.text",
+    ".ods": "application/vnd.oasis.opendocument.spreadsheet",
+    ".odp": "application/vnd.oasis.opendocument.presentation",
+    ".rtf": "application/rtf",
+    ".csv": "text/csv",
+    ".tsv": "text/tab-separated-values",
+    ".txt": "text/plain",
+    ".md": "text/markdown",
+    ".html": "text/html",
+    ".xml": "application/xml",
+    ".json": "application/json",
+    ".yaml": "application/yaml",
+    ".yml": "application/yaml",
+    ".png": "image/png",
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".gif": "image/gif",
+    ".bmp": "image/bmp",
+    ".tiff": "image/tiff",
+    ".webp": "image/webp",
+    ".svg": "image/svg+xml",
+    ".eml": "message/rfc822",
+    ".msg": "application/vnd.ms-outlook",
+    ".epub": "application/epub+zip",
+    ".flac": "audio/flac",
+    ".mp3": "audio/mpeg",
+    ".mp4": "audio/mp4",
+    ".m4a": "audio/mp4",
+    ".ogg": "audio/ogg",
+    ".wav": "audio/wav",
+    ".webm": "audio/webm",
+    ".dxf": "image/vnd.dxf",
+    ".geo": "application/vnd.trumpf.geo",
+};
+export function getMimeType(filename) {
+    const ext = extname(filename).toLowerCase();
+    return MIME_TYPES[ext] ?? "application/octet-stream";
+}
+/**
+ * Read a local file and return a Blob suitable for FormData.
+ */
+export function fileToBlob(filePath) {
+    const buffer = readFileSync(filePath);
+    const filename = basename(filePath);
+    const mimeType = getMimeType(filename);
+    const blob = new Blob([buffer], { type: mimeType });
+    return { blob, filename, mimeType };
+}
+//# sourceMappingURL=multipart.js.map

package/dist/lib/output.d.ts

@@ -0,0 +1,29 @@
+import type { Command } from "commander";
+type AnyRecord = Record<string, any>;
+/**
+ * Format and display a paginated list (Spring Data Page<T>).
+ */
+export declare function formatPage(page: {
+    content?: AnyRecord[];
+    totalElements?: number;
+    number?: number;
+    totalPages?: number;
+} | undefined, command: Command, columns: string[]): void;
+/**
+ * Format and display a single record as key-value pairs.
+ */
+export declare function formatDetail(record: AnyRecord | undefined, command: Command): void;
+/**
+ * Format and display a list of records (non-paginated).
+ */
+export declare function formatList(items: AnyRecord[] | undefined, command: Command, columns: string[]): void;
+/**
+ * Display a success message.
+ */
+export declare function formatSuccess(message: string, command: Command): void;
+/**
+ * Run an async action with a spinner.
+ */
+export declare function withSpinner<T>(text: string, action: () => Promise<T>): Promise<T>;
+export {};
+//# sourceMappingURL=output.d.ts.map

package/dist/lib/output.js

@@ -0,0 +1,107 @@
+import chalk from "chalk";
+import Table from "cli-table3";
+import ora from "ora";
+import { isJsonOutput } from "./config.js";
+/**
+ * Format and display a paginated list (Spring Data Page<T>).
+ */
+export function formatPage(page, command, columns) {
+    if (!page) {
+        console.error(chalk.yellow("No data returned."));
+        return;
+    }
+    if (isJsonOutput(command)) {
+        console.log(JSON.stringify(page, null, 2));
+        return;
+    }
+    if (!page.content || page.content.length === 0) {
+        console.log(chalk.dim("No results found."));
+        return;
+    }
+    const table = new Table({
+        head: columns.map((c) => chalk.cyan(c)),
+        wordWrap: true,
+    });
+    for (const item of page.content) {
+        table.push(columns.map((col) => formatValue(item[col])));
+    }
+    console.log(table.toString());
+    console.log(chalk.dim(`Page ${(page.number ?? 0) + 1} of ${page.totalPages ?? 0} (${page.totalElements ?? 0} total)`));
+}
+/**
+ * Format and display a single record as key-value pairs.
+ */
+export function formatDetail(record, command) {
+    if (!record) {
+        console.error(chalk.yellow("No data returned."));
+        return;
+    }
+    if (isJsonOutput(command)) {
+        console.log(JSON.stringify(record, null, 2));
+        return;
+    }
+    const table = new Table();
+    for (const [key, value] of Object.entries(record)) {
+        table.push({ [chalk.cyan(key)]: formatValue(value) });
+    }
+    console.log(table.toString());
+}
+/**
+ * Format and display a list of records (non-paginated).
+ */
+export function formatList(items, command, columns) {
+    if (!items) {
+        console.error(chalk.yellow("No data returned."));
+        return;
+    }
+    if (isJsonOutput(command)) {
+        console.log(JSON.stringify(items, null, 2));
+        return;
+    }
+    if (items.length === 0) {
+        console.log(chalk.dim("No results found."));
+        return;
+    }
+    const table = new Table({
+        head: columns.map((c) => chalk.cyan(c)),
+        wordWrap: true,
+    });
+    for (const item of items) {
+        table.push(columns.map((col) => formatValue(item[col])));
+    }
+    console.log(table.toString());
+}
+/**
+ * Display a success message.
+ */
+export function formatSuccess(message, command) {
+    if (isJsonOutput(command)) {
+        console.log(JSON.stringify({ success: true, message }));
+    }
+    else {
+        console.log(chalk.green(message));
+    }
+}
+/**
+ * Run an async action with a spinner.
+ */
+export async function withSpinner(text, action) {
+    const spinner = ora(text).start();
+    try {
+        const result = await action();
+        spinner.succeed();
+        return result;
+    }
+    catch (err) {
+        spinner.fail();
+        throw err;
+    }
+}
+function formatValue(value) {
+    if (value === null || value === undefined)
+        return chalk.dim("—");
+    if (typeof value === "object")
+        return JSON.stringify(value);
+    return String(value);
+}
+//# sourceMappingURL=output.js.map

package/dist/lib/pagination.d.ts

@@ -0,0 +1,21 @@
+import type { Command } from "commander";
+/**
+ * Add standard pagination options to a command.
+ * Spring Data uses page (0-indexed), size, and sort.
+ */
+export declare function addPaginationOptions(cmd: Command): Command;
+/** Parse pagination options into query params.
+ * Spring Data accepts flat page/size/sort params directly. We cast to satisfy
+ * the generated types which expect a nested `pageable` object. */
+export declare function paginationParams(opts: {
+    page?: string;
+    size?: string;
+    sort?: string[];
+}): {
+    pageable: {
+        page?: number;
+        size?: number;
+        sort?: string[];
+    };
+};
+//# sourceMappingURL=pagination.d.ts.map

package/dist/lib/pagination.js

@@ -0,0 +1,21 @@
+/**
+ * Add standard pagination options to a command.
+ * Spring Data uses page (0-indexed), size, and sort.
+ */
+export function addPaginationOptions(cmd) {
+    return cmd
+        .option("-p, --page <number>", "Page number (0-indexed)", "0")
+        .option("--size <number>", "Page size", "20")
+        .option("--sort <fields...>", "Sort fields (e.g., name,asc)");
+}
+/** Parse pagination options into query params.
+ * Spring Data accepts flat page/size/sort params directly. We cast to satisfy
+ * the generated types which expect a nested `pageable` object. */
+export function paginationParams(opts) {
+    return {
+        page: opts.page !== undefined ? parseInt(opts.page, 10) : undefined,
+        size: opts.size !== undefined ? parseInt(opts.size, 10) : undefined,
+        sort: opts.sort,
+    };
+}
+//# sourceMappingURL=pagination.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/dist/lib/update-notifier.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Check for updates in the background. Call early so the fetch
+ * runs concurrently with the actual command, then call `notify()`
+ * after the command finishes to print the message (if any).
+ */
+export declare function checkForUpdates(currentVersion: string): {
+    notify: () => void;
+};
+//# sourceMappingURL=update-notifier.d.ts.map

package/dist/lib/update-notifier.js

@@ -0,0 +1,96 @@
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { readFileSync, writeFileSync, mkdirSync } from "node:fs";
+import chalk from "chalk";
+const PKG_NAME = "@manfred-kunze-dev/backbone-cli";
+const CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000; // 1 day
+const CACHE_DIR = join(homedir(), ".config", "backbone");
+const CACHE_FILE = join(CACHE_DIR, "update-check.json");
+function readCache() {
+    try {
+        return JSON.parse(readFileSync(CACHE_FILE, "utf-8"));
+    }
+    catch {
+        return null;
+    }
+}
+function writeCache(data) {
+    try {
+        mkdirSync(CACHE_DIR, { recursive: true });
+        writeFileSync(CACHE_FILE, JSON.stringify(data));
+    }
+    catch {
+        // Ignore write errors
+    }
+}
+async function fetchLatestVersion() {
+    try {
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), 3000);
+        const res = await fetch(`https://registry.npmjs.org/${PKG_NAME}/latest`, { signal: controller.signal });
+        clearTimeout(timeout);
+        if (!res.ok)
+            return null;
+        const data = (await res.json());
+        return data.version ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+function compareVersions(current, latest) {
+    const parse = (v) => v.replace(/^v/, "").split(".").map(Number);
+    const [cMaj, cMin, cPat] = parse(current);
+    const [lMaj, lMin, lPat] = parse(latest);
+    if (lMaj !== cMaj)
+        return lMaj > cMaj;
+    if (lMin !== cMin)
+        return lMin > cMin;
+    return lPat > cPat;
+}
+/**
+ * Check for updates in the background. Call early so the fetch
+ * runs concurrently with the actual command, then call `notify()`
+ * after the command finishes to print the message (if any).
+ */
+export function checkForUpdates(currentVersion) {
+    let message = null;
+    // Skip for pre-release versions
+    if (currentVersion.includes("-")) {
+        return { notify: () => { } };
+    }
+    const cache = readCache();
+    const now = Date.now();
+    // Use cached result if recent enough
+    if (cache && now - cache.lastCheck < CHECK_INTERVAL_MS) {
+        if (compareVersions(currentVersion, cache.latestVersion)) {
+            message = formatMessage(currentVersion, cache.latestVersion);
+        }
+        return { notify: () => message && console.error(message) };
+    }
+    // Fire off the check in the background
+    const pending = fetchLatestVersion().then((latest) => {
+        if (latest) {
+            writeCache({ lastCheck: now, latestVersion: latest });
+            if (compareVersions(currentVersion, latest)) {
+                message = formatMessage(currentVersion, latest);
+            }
+        }
+    });
+    return {
+        notify: async () => {
+            await pending;
+            if (message)
+                console.error(message);
+        },
+    };
+}
+function formatMessage(current, latest) {
+    return [
+        "",
+        chalk.yellow(`Update available: ${chalk.dim(current)} → ${chalk.green(latest)}`),
+        chalk.yellow(`Run ${chalk.cyan(`npm i -g ${PKG_NAME}`)} to update`),
+        "",
+    ].join("\n");
+}
+//# sourceMappingURL=update-notifier.js.map

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@2kw/ai",
+  "version": "4.0.0-dev.2",
+  "description": "CLI for the 2kw.ai platform (engineering name: Backbone)",
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": {
+    "2kw": "dist/index.js",
+    "backbone": "dist/index.js",
+    "bb": "dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "start": "node dist/index.js",
+    "generate:spec": "tsx --env-file=.env openapi/scripts/fetch-spec.ts",
+    "generate:types": "openapi-typescript openapi/openapi.json -o src/generated/openapi.d.ts",
+    "generate": "npm run generate:spec && npm run generate:types",
+    "check:spec": "tsx --env-file=.env openapi/scripts/check-drift.ts",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "chalk": "^5.6.2",
+    "cli-table3": "^0.6.5",
+    "commander": "^13.1.0",
+    "conf": "^13.1.0",
+    "openapi-fetch": "^0.13.5",
+    "ora": "^8.2.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.19.17",
+    "openapi-typescript": "^7.13.0",
+    "tsx": "^4.21.0",
+    "typescript": "^5.9.3"
+  },
+  "engines": {
+    "node": ">=18.20.8"
+  },
+  "license": "SEE LICENSE IN LICENSE",
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org",
+    "access": "public"
+  },
+  "homepage": "https://2kw.ai",
+  "files": [
+    "dist/**/*.js",
+    "dist/**/*.d.ts"
+  ]
+}