@memvid/sdk 2.0.113

package/dist/error.js

@@ -0,0 +1,203 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CorruptFileError = exports.VecIndexDisabledError = exports.FrameNotFoundError = exports.MemoryAlreadyBoundError = exports.ApiKeyRequiredError = exports.LockedError = exports.VerificationFailedError = exports.TimeIndexMissingError = exports.LexIndexDisabledError = exports.TicketReplayError = exports.TicketInvalidError = exports.CapacityExceededError = exports.MemvidError = void 0;
+exports.wrapNativeError = wrapNativeError;
+/**
+ * Structured error class for Memvid SDK operations.
+ *
+ * All errors from the Memvid SDK are instances of this class,
+ * providing consistent error handling with:
+ * - `.code`: Machine-readable error code (e.g., "MV001")
+ * - `.message`: Human-readable error message
+ * - `.details`: Optional structured details object
+ *
+ * @example
+ * ```typescript
+ * import { use, MemvidError } from "@memvid/sdk";
+ *
+ * try {
+ *   const mem = await use("basic", "file.mv2");
+ *   await mem.put({ title: "Doc", label: "test", text: "..." });
+ * } catch (err) {
+ *   if (err instanceof MemvidError) {
+ *     switch (err.code) {
+ *       case "MV001":
+ *         console.error("Capacity exceeded:", err.message);
+ *         break;
+ *       case "MV007":
+ *         console.error("File locked:", err.details?.owner);
+ *         break;
+ *       default:
+ *         console.error(`Error ${err.code}: ${err.message}`);
+ *     }
+ *   }
+ * }
+ * ```
+ */
+class MemvidError extends Error {
+    constructor(code, message, details) {
+        super(message);
+        this.name = "MemvidError";
+        this.code = code;
+        this.details = details;
+        // Maintains proper stack trace for where error was thrown (V8 only)
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, MemvidError);
+        }
+    }
+    /**
+     * Create a MemvidError from a native error string.
+     * Parses the "MV001: message" format from the Rust binding.
+     */
+    static fromNative(err) {
+        const match = err.message.match(/^(MV\d{3}):\s*(.+)$/);
+        if (match) {
+            const code = match[1];
+            const message = match[2];
+            return new MemvidError(code, message);
+        }
+        // Unknown error format, wrap as MV999
+        return new MemvidError("MV999", err.message);
+    }
+    /**
+     * Check if an error is a MemvidError.
+     */
+    static isMemvidError(err) {
+        return err instanceof MemvidError;
+    }
+    /**
+     * Convert to JSON for logging/serialization.
+     */
+    toJSON() {
+        return {
+            code: this.code,
+            message: this.message,
+            ...(this.details && { details: this.details }),
+        };
+    }
+}
+exports.MemvidError = MemvidError;
+// Named error subclasses for specific error types
+class CapacityExceededError extends MemvidError {
+    constructor(message, details) {
+        super("MV001", message, details);
+        this.name = "CapacityExceededError";
+    }
+}
+exports.CapacityExceededError = CapacityExceededError;
+class TicketInvalidError extends MemvidError {
+    constructor(message, details) {
+        super("MV002", message, details);
+        this.name = "TicketInvalidError";
+    }
+}
+exports.TicketInvalidError = TicketInvalidError;
+class TicketReplayError extends MemvidError {
+    constructor(message, details) {
+        super("MV003", message, details);
+        this.name = "TicketReplayError";
+    }
+}
+exports.TicketReplayError = TicketReplayError;
+class LexIndexDisabledError extends MemvidError {
+    constructor(message, details) {
+        super("MV004", message, details);
+        this.name = "LexIndexDisabledError";
+    }
+}
+exports.LexIndexDisabledError = LexIndexDisabledError;
+class TimeIndexMissingError extends MemvidError {
+    constructor(message, details) {
+        super("MV005", message, details);
+        this.name = "TimeIndexMissingError";
+    }
+}
+exports.TimeIndexMissingError = TimeIndexMissingError;
+class VerificationFailedError extends MemvidError {
+    constructor(message, details) {
+        super("MV006", message, details);
+        this.name = "VerificationFailedError";
+    }
+}
+exports.VerificationFailedError = VerificationFailedError;
+class LockedError extends MemvidError {
+    constructor(message, details) {
+        super("MV007", message, details);
+        this.name = "LockedError";
+    }
+}
+exports.LockedError = LockedError;
+class ApiKeyRequiredError extends MemvidError {
+    constructor(message, details) {
+        super("MV008", message, details);
+        this.name = "ApiKeyRequiredError";
+    }
+}
+exports.ApiKeyRequiredError = ApiKeyRequiredError;
+class MemoryAlreadyBoundError extends MemvidError {
+    constructor(message, details) {
+        super("MV009", message, details);
+        this.name = "MemoryAlreadyBoundError";
+    }
+}
+exports.MemoryAlreadyBoundError = MemoryAlreadyBoundError;
+class FrameNotFoundError extends MemvidError {
+    constructor(message, details) {
+        super("MV010", message, details);
+        this.name = "FrameNotFoundError";
+    }
+}
+exports.FrameNotFoundError = FrameNotFoundError;
+class VecIndexDisabledError extends MemvidError {
+    constructor(message, details) {
+        super("MV011", message, details);
+        this.name = "VecIndexDisabledError";
+    }
+}
+exports.VecIndexDisabledError = VecIndexDisabledError;
+class CorruptFileError extends MemvidError {
+    constructor(message, details) {
+        super("MV012", message, details);
+        this.name = "CorruptFileError";
+    }
+}
+exports.CorruptFileError = CorruptFileError;
+/**
+ * Wrap a native error into the appropriate MemvidError subclass.
+ */
+function wrapNativeError(err) {
+    const match = err.message.match(/^(MV\d{3}):\s*(.+)$/);
+    if (!match) {
+        return new MemvidError("MV999", err.message);
+    }
+    const code = match[1];
+    const message = match[2];
+    switch (code) {
+        case "MV001":
+            return new CapacityExceededError(message);
+        case "MV002":
+            return new TicketInvalidError(message);
+        case "MV003":
+            return new TicketReplayError(message);
+        case "MV004":
+            return new LexIndexDisabledError(message);
+        case "MV005":
+            return new TimeIndexMissingError(message);
+        case "MV006":
+            return new VerificationFailedError(message);
+        case "MV007":
+            return new LockedError(message);
+        case "MV008":
+            return new ApiKeyRequiredError(message);
+        case "MV009":
+            return new MemoryAlreadyBoundError(message);
+        case "MV010":
+            return new FrameNotFoundError(message);
+        case "MV011":
+            return new VecIndexDisabledError(message);
+        case "MV012":
+            return new CorruptFileError(message);
+        default:
+            return new MemvidError("MV999", message);
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,53 @@
+import type { ApiKey, Kind, Memvid, UseDoctorOptions, UseOptions, UseVerifyOptions } from "./types";
+import "./adapters/basic";
+import "./adapters/langchain";
+import "./adapters/llamaindex";
+import "./adapters/crewai";
+import "./adapters/vercel_ai";
+import "./adapters/openai";
+import "./adapters/autogen";
+import "./adapters/haystack";
+import "./adapters/langgraph";
+import "./adapters/semantic_kernel";
+import "./adapters/google_adk";
+import "./adapters/mcp";
+export * as clip from "./clip";
+export * as entities from "./entities";
+export { getClipProvider, LocalClip, OpenAIClip, GeminiClip } from "./clip";
+export { getEntityExtractor, LocalNER, OpenAIEntities, ClaudeEntities, GeminiEntities } from "./entities";
+type UseFunction = {
+    (kind: Kind, filename: string, apiKey?: ApiKey, options?: UseOptions): Promise<Memvid>;
+    verify(path: string, options?: UseVerifyOptions): Promise<unknown>;
+    doctor(path: string, options?: UseDoctorOptions): Promise<unknown>;
+};
+declare const useImpl: UseFunction;
+export declare const use: UseFunction;
+export default useImpl;
+export declare function create(filename: string, kind?: Kind, apiKey?: ApiKey): Promise<Memvid>;
+export type { Kind, ApiKey, Memvid, UseOptions, FindInput, AskInput, TimelineInput, PutInput, PutManyInput, PutManyOptions, MemvidErrorCode, MemvidErrorDetails, HeatmapEntry, HeatmapResponse, } from "./types";
+export { MemvidError, CapacityExceededError, TicketInvalidError, TicketReplayError, LexIndexDisabledError, TimeIndexMissingError, VerificationFailedError, LockedError, ApiKeyRequiredError, MemoryAlreadyBoundError, FrameNotFoundError, VecIndexDisabledError, CorruptFileError, } from "./error";
+export { EmbeddingProvider, OpenAIEmbeddings, OpenAIEmbeddingsConfig, CohereEmbeddings, CohereEmbeddingsConfig, VoyageEmbeddings, VoyageEmbeddingsConfig, getEmbedder, MODEL_DIMENSIONS, } from "./embeddings";
+/**
+ * Mask PII (Personally Identifiable Information) in text.
+ *
+ * Detects and replaces common PII patterns with placeholder tokens:
+ * - Email addresses → [EMAIL]
+ * - US Social Security Numbers → [SSN]
+ * - Phone numbers → [PHONE]
+ * - Credit card numbers → [CREDIT_CARD]
+ * - IPv4 addresses → [IP_ADDRESS]
+ * - API keys/tokens → [API_KEY]
+ *
+ * @param text - The text to mask
+ * @returns Text with PII replaced by placeholder tokens
+ *
+ * @example
+ * ```typescript
+ * import { maskPii } from 'memvid-sdk';
+ *
+ * const text = "Contact john@example.com at 555-123-4567";
+ * const masked = maskPii(text);
+ * console.log(masked); // "Contact [EMAIL] at [PHONE]"
+ * ```
+ */
+export declare function maskPii(text: string): string;