@coreviz/sdk 1.0.0

package/README.md

@@ -0,0 +1,24 @@
+# @coreviz/sdk
+
+CoreViz SDK - A JavaScript/Node.js interface for CoreViz's Vision AI APIs.
+
+## Installation
+
+```bash
+npm install @coreviz/sdk
+```
+
+## Usage
+
+```js
+const coreviz = require('@coreviz/sdk');
+coreviz();
+```
+
+## Development
+
+This is currently a placeholder package. The actual API functionality will be implemented soon.
+
+## License
+
+MIT 

package/dist/describe.d.ts

@@ -0,0 +1 @@
+export declare function describe(image: string): Promise<string | undefined>;

package/dist/describe.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.describe = describe;
+const resize_1 = require("./resize");
+async function describe(image) {
+    try {
+        const resizedImage = await (0, resize_1.resize)(image);
+        const response = await fetch(`https://lab.coreviz.io/api/ai/describe`, {
+            method: 'POST',
+            headers: {
+                'x-api-key': process.env.COREVIZ_API_KEY || "",
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({ image: resizedImage }),
+        });
+        if (!response.ok) {
+            throw new Error(`Failed to describe image (${response.status})`);
+        }
+        const data = await response.json();
+        if (data.error) {
+            throw new Error(data.error);
+        }
+        return data.description;
+    }
+    catch (err) {
+        console.error('Error in describeImage:', err);
+        throw err instanceof Error ? err : new Error("An unexpected error occurred.");
+    }
+}

package/dist/edit.d.ts

@@ -0,0 +1,7 @@
+export interface EditOptions {
+    prompt: string;
+    aspectRatio?: 'match_input_image' | '1:1' | '16:9' | '9:16' | '4:3' | '3:4';
+    outputFormat?: 'jpg' | 'png';
+    model?: 'flux-kontext-max' | 'google/nano-banana' | 'seedream-4';
+}
+export declare function edit(image: string, options: EditOptions): Promise<string | undefined>;

package/dist/edit.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.edit = edit;
+const resize_1 = require("./resize");
+async function edit(image, options) {
+    try {
+        const resizedImage = await (0, resize_1.resize)(image);
+        const response = await fetch(`https://lab.coreviz.io/api/ai/edit`, {
+            method: 'POST',
+            headers: {
+                'x-api-key': process.env.COREVIZ_API_KEY || "",
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({
+                image: resizedImage,
+                prompt: options.prompt,
+                aspectRatio: options.aspectRatio || 'match_input_image',
+                outputFormat: options.outputFormat || 'jpg',
+                model: options.model || 'flux-kontext-max',
+            }),
+        });
+        if (!response.ok) {
+            throw new Error(`Failed to edit image (${response.status})`);
+        }
+        const data = await response.json();
+        if (data.error) {
+            throw new Error(data.error);
+        }
+        return data.result;
+    }
+    catch (err) {
+        console.error('Error in editImage:', err);
+        throw err instanceof Error ? err : new Error("An unexpected error occurred.");
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+import { describe } from './describe';
+import { resize } from './resize';
+import { edit, EditOptions } from './edit';
+import { tag, TagOptions, TagResponse } from './tag';
+export { describe, resize, edit, tag };
+export type { EditOptions, TagOptions, TagResponse };

package/dist/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tag = exports.edit = exports.resize = exports.describe = void 0;
+const describe_1 = require("./describe");
+Object.defineProperty(exports, "describe", { enumerable: true, get: function () { return describe_1.describe; } });
+const resize_1 = require("./resize");
+Object.defineProperty(exports, "resize", { enumerable: true, get: function () { return resize_1.resize; } });
+const edit_1 = require("./edit");
+Object.defineProperty(exports, "edit", { enumerable: true, get: function () { return edit_1.edit; } });
+const tag_1 = require("./tag");
+Object.defineProperty(exports, "tag", { enumerable: true, get: function () { return tag_1.tag; } });

package/dist/resize.d.ts

@@ -0,0 +1 @@
+export declare function resize(input: string | File, maxWidth?: number, maxHeight?: number): Promise<string>;

package/dist/resize.js

@@ -0,0 +1,161 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resize = resize;
+const isBrowser = typeof window !== 'undefined';
+async function resize(input, maxWidth = 1920, maxHeight = 1080) {
+    if (isBrowser) {
+        return clientResize(input, maxWidth, maxHeight);
+    }
+    else {
+        if (typeof input !== 'string') {
+            throw new Error("Server-side resizing only supports base64 strings or URLs.");
+        }
+        return serverResize(input, maxWidth, maxHeight);
+    }
+}
+async function clientResize(input, maxWidth, maxHeight) {
+    return new Promise((resolve, reject) => {
+        const img = new window.Image();
+        const handleLoad = () => {
+            let width = img.width;
+            let height = img.height;
+            if (width > height) {
+                if (width > maxWidth) {
+                    height *= maxWidth / width;
+                    width = maxWidth;
+                }
+            }
+            else {
+                if (height > maxHeight) {
+                    width *= maxHeight / height;
+                    height = maxHeight;
+                }
+            }
+            const canvas = document.createElement('canvas');
+            canvas.width = width;
+            canvas.height = height;
+            const ctx = canvas.getContext('2d');
+            if (!ctx) {
+                reject(new Error("Could not get canvas context"));
+                return;
+            }
+            ctx.drawImage(img, 0, 0, width, height);
+            // Attempt to determine format from input if possible, defaulting to jpeg for efficiency/compatibility
+            // If input was a file, we can use its type. If string, we can try to parse.
+            let mimeType = 'image/jpeg';
+            if (input instanceof File) {
+                mimeType = input.type;
+            }
+            else if (typeof input === 'string') {
+                const match = input.match(/^data:(image\/\w+);base64,/);
+                if (match)
+                    mimeType = match[1];
+            }
+            resolve(canvas.toDataURL(mimeType));
+        };
+        img.onload = handleLoad;
+        img.onerror = (error) => reject(error);
+        if (input instanceof File) {
+            const reader = new FileReader();
+            reader.onload = (e) => {
+                if (e.target?.result) {
+                    img.src = e.target.result;
+                }
+            };
+            reader.onerror = reject;
+            reader.readAsDataURL(input);
+        }
+        else {
+            img.src = input;
+        }
+        // For base64 strings, we don't need to wait for reader, but we do need to wait for img.onload which is handled above.
+        // If input is string, setting src triggers load.
+    });
+}
+async function serverResize(inputStr, maxWidth, maxHeight) {
+    // If running in browser context, do not attempt to load sharp or Buffer
+    if (typeof window !== 'undefined') {
+        throw new Error("serverResize called in browser environment");
+    }
+    try {
+        // Dynamic import to prevent bundling sharp on the client
+        const sharpModule = await Promise.resolve().then(() => __importStar(require('sharp')));
+        const sharp = sharpModule.default;
+        let buffer;
+        let mimeType = 'image/jpeg';
+        if (inputStr.startsWith('http://') || inputStr.startsWith('https://')) {
+            const response = await fetch(inputStr);
+            if (!response.ok) {
+                throw new Error(`Failed to fetch image from URL: ${response.statusText}`);
+            }
+            const arrayBuffer = await response.arrayBuffer();
+            buffer = Buffer.from(arrayBuffer);
+            mimeType = response.headers.get('content-type') || 'image/jpeg';
+        }
+        else {
+            // Remove data URL prefix if present
+            const base64Data = inputStr.replace(/^data:image\/\w+;base64,/, "");
+            // Buffer is a Node global, ensure it exists
+            if (typeof Buffer === 'undefined') {
+                throw new Error("Buffer is not defined");
+            }
+            buffer = Buffer.from(base64Data, 'base64');
+            mimeType = inputStr.match(/^data:(image\/\w+);base64,/)?.[1] || 'image/jpeg';
+        }
+        // Get image metadata
+        const metadata = await sharp(buffer).metadata();
+        if (metadata.width && metadata.height && (metadata.width > maxWidth || metadata.height > maxHeight)) {
+            const resizedBuffer = await sharp(buffer)
+                .resize({
+                width: maxWidth,
+                height: maxHeight,
+                fit: 'inside', // Maintain aspect ratio, fit inside dimensions
+                withoutEnlargement: true
+            })
+                .toBuffer();
+            return `data:${mimeType};base64,${resizedBuffer.toString('base64')}`;
+        }
+        // If input was a URL, return the fetched content as base64 to ensure downstream availability
+        if (inputStr.startsWith('http://') || inputStr.startsWith('https://')) {
+            return `data:${mimeType};base64,${buffer.toString('base64')}`;
+        }
+        return inputStr;
+    }
+    catch (error) {
+        console.warn("Failed to resize image on server:", error);
+        return inputStr; // Fallback to original
+    }
+}

package/dist/tag.d.ts

@@ -0,0 +1,10 @@
+export interface TagOptions {
+    prompt: string;
+    options?: string[];
+    multiple?: boolean;
+}
+export interface TagResponse {
+    tags: string[];
+    raw?: unknown;
+}
+export declare function tag(image: string, options: TagOptions): Promise<TagResponse>;

package/dist/tag.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tag = tag;
+const resize_1 = require("./resize");
+async function tag(image, options) {
+    try {
+        const resizedImage = await (0, resize_1.resize)(image);
+        const response = await fetch("https://lab.coreviz.io/api/ai/tag", {
+            method: 'POST',
+            headers: {
+                'x-api-key': process.env.COREVIZ_API_KEY || "",
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({
+                image: resizedImage,
+                prompt: options.prompt,
+                options: options.options && options.options.length > 0 ? options.options : undefined,
+                multiple: options.multiple ?? true,
+            }),
+        });
+        if (!response.ok) {
+            throw new Error(`Failed to tag image (${response.status})`);
+        }
+        const data = await response.json();
+        if (data.error) {
+            throw new Error(data.error);
+        }
+        const tags = Array.isArray(data.tags)
+            ? data.tags
+            : Array.isArray(data.result)
+                ? data.result
+                : typeof data.tag === 'string'
+                    ? [data.tag]
+                    : [];
+        return {
+            tags,
+            raw: data,
+        };
+    }
+    catch (err) {
+        console.error('Error in tagImage:', err);
+        throw err instanceof Error ? err : new Error("An unexpected error occurred.");
+    }
+}

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@coreviz/sdk",
+  "version": "1.0.0",
+  "description": "CoreViz SDK",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/coreviz/sdk.git"
+  },
+  "keywords": [
+    "api",
+    "coreviz"
+  ],
+  "author": "CoreViz Team",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/coreviz/sdk/issues"
+  },
+  "homepage": "https://github.com/coreviz/sdk#readme",
+  "devDependencies": {
+    "@types/node": "^24.10.1",
+    "typescript": "^5.9.3"
+  },
+  "dependencies": {
+    "sharp": "^0.34.5"
+  }
+}