@zvec/zvec-grep 0.1.4 → 0.1.6

package/dist/engine/collection/index.js

@@ -1,710 +0,0 @@
-import { ZVecCollectionSchema, ZVecCreateAndOpen, ZVecDataType, ZVecIndexType, ZVecOpen, } from "@zvec/zvec";
-import { randomUUID } from "node:crypto";
-import { existsSync, mkdirSync, rmSync } from "node:fs";
-import { basename, dirname, join } from "node:path";
-import { collectionDetail, detail, EngineError, errorDetails, } from "../errors/index.js";
-import { getCollectionIndexStatus, indexCollection, } from "../pipeline/indexing/index.js";
-import { fileBelongsToRootPath, validateRootPaths, } from "../pipeline/indexing/root-paths.js";
-import { diagnoseEntitySearch, diagnoseFileSearch, searchPlanCollection, } from "../pipeline/search/index.js";
-import { assertZvecStatus, initializeZvec, openZvecCollection, quoteFilterString, readNullableNumberFieldFromFields, readNullableStringFieldFromFields, readNumberFieldFromFields, readStringFieldFromFields, ZvecCollectionStorage, ZvecFileMetaStore, } from "../storage/zvec.js";
-import { CURRENT_INDEX_VERSION } from "../types.js";
-import { defaultHome, normalizePath } from "../utils/path.js";
-const COLLECTIONS_ZVEC = "collections.zvec";
-const FILES_ZVEC = "files.zvec";
-export class Collection {
-    info;
-    embeddingModel;
-    readOnly;
-    fileStorePath;
-    storage;
-    embedding;
-    constructor(info, embeddingModel, readOnly = false, fileStorePath = join(info.path, FILES_ZVEC)) {
-        this.info = info;
-        this.embeddingModel = embeddingModel;
-        this.readOnly = readOnly;
-        this.fileStorePath = fileStorePath;
-        this.embedding = requireIndexedEmbedding(info, "open");
-        this.validateIndexVersion();
-        if (this.embeddingModel) {
-            this.validateEmbeddingSchema(this.embeddingModel);
-        }
-        this.storage = new ZvecCollectionStorage(info.path, this.embedding, this.fileStorePath, info.id, readOnly);
-    }
-    get id() {
-        return this.info.id;
-    }
-    get name() {
-        return this.info.name;
-    }
-    index(options = {}) {
-        if (this.readOnly) {
-            throw new EngineError("Cannot index a read-only collection", {
-                code: "ZVEC_GREP.ENGINE.COLLECTION.READ_ONLY",
-                context: collectionOperationDetails(this.name, "index"),
-            });
-        }
-        const embeddingModel = this.requireEmbeddingModel("index");
-        return indexCollection({
-            collection: this.info,
-            embeddingModel,
-            storage: this.storage,
-            embeddingConcurrency: options.embeddingConcurrency,
-            onProgress: options.onProgress,
-        });
-    }
-    status() {
-        return getCollectionIndexStatus(this.info, this.storage.listFiles());
-    }
-    searchPlan(plan) {
-        return searchPlanCollection(plan, {
-            collection: this.info,
-            embeddingModel: this.embeddingModel,
-            storage: this.storage,
-        });
-    }
-    diagnoseFile(absolutePath) {
-        const path = normalizePath(absolutePath);
-        const file = this.storage.getFileByPath(path);
-        const matchedRootPath = this.info.rootPaths.find((rootPath) => fileBelongsToRootPath(path, rootPath));
-        return {
-            collectionId: this.id,
-            collectionName: this.name,
-            absolutePath: path,
-            belongsToCollection: matchedRootPath !== undefined,
-            matchedRootPath: matchedRootPath?.absolutePath,
-            file: file ?? undefined,
-            entityCount: file?.indexStatus?.entityCount ?? 0,
-            reason: file
-                ? undefined
-                : matchedRootPath
-                    ? "File belongs to this collection but has not been indexed"
-                    : "File is outside this collection roots or excluded by root patterns",
-        };
-    }
-    diagnoseEntitySearch(query, entityId) {
-        const embeddingModel = this.requireEmbeddingModel("diagnose");
-        return diagnoseEntitySearch(query, entityId, {
-            collection: this.info,
-            embeddingModel,
-            storage: this.storage,
-        });
-    }
-    diagnoseFileSearch(query, absolutePath) {
-        const embeddingModel = this.requireEmbeddingModel("diagnose");
-        return diagnoseFileSearch(query, absolutePath, {
-            collection: this.info,
-            embeddingModel,
-            storage: this.storage,
-        });
-    }
-    getFile(absolutePath) {
-        return this.storage.getFileByPath(absolutePath);
-    }
-    listEntitiesByFile(fileId, options = {}) {
-        return this.storage.listEntitiesByFile(fileId, options);
-    }
-    getEntity(entityId) {
-        return this.storage.getEntity(entityId);
-    }
-    close() {
-        this.storage.close();
-    }
-    validateIndexVersion() {
-        if (this.info.indexVersion !== CURRENT_INDEX_VERSION) {
-            throw new EngineError("Collection index version is not supported", {
-                code: "ZVEC_GREP.ENGINE.COLLECTION.INDEX_VERSION_MISMATCH",
-                context: errorDetails([
-                    collectionDetail(this.name),
-                    detail("expected", CURRENT_INDEX_VERSION),
-                    detail("actual", this.info.indexVersion),
-                ]),
-            });
-        }
-    }
-    validateEmbeddingSchema(current) {
-        this.validateIndexVersion();
-        const expected = this.embedding;
-        if (expected.provider !== current.ref.provider) {
-            throw new EngineError("Collection embedding provider does not match current model", {
-                code: "ZVEC_GREP.ENGINE.COLLECTION.EMBEDDING_PROVIDER_MISMATCH",
-                context: collectionMismatchDetails(this.name, expected.provider, current.ref.provider),
-            });
-        }
-        if (expected.model !== current.ref.model) {
-            throw new EngineError("Collection embedding model does not match current model", {
-                code: "ZVEC_GREP.ENGINE.COLLECTION.EMBEDDING_MODEL_MISMATCH",
-                context: collectionMismatchDetails(this.name, expected.model, current.ref.model),
-            });
-        }
-        if (expected.dimension !== current.dimension) {
-            throw new EngineError("Collection embedding dimension does not match current model", {
-                code: "ZVEC_GREP.ENGINE.COLLECTION.EMBEDDING_DIMENSION_MISMATCH",
-                context: collectionMismatchDetails(this.name, expected.dimension, current.dimension),
-            });
-        }
-        if (expected.metric !== current.metric) {
-            throw new EngineError("Collection embedding metric does not match current model", {
-                code: "ZVEC_GREP.ENGINE.COLLECTION.EMBEDDING_METRIC_MISMATCH",
-                context: collectionMismatchDetails(this.name, expected.metric, current.metric),
-            });
-        }
-    }
-    requireEmbeddingModel(operation) {
-        if (!this.embeddingModel) {
-            throw new EngineError("Collection operation requires an embedding model", {
-                code: "ZVEC_GREP.ENGINE.COLLECTION.EMBEDDING_MODEL_REQUIRED",
-                context: collectionOperationDetails(this.name, operation),
-            });
-        }
-        return this.embeddingModel;
-    }
-}
-function collectionOperationDetails(name, operation) {
-    return errorDetails([
-        collectionDetail(name),
-        detail("operation", operation),
-    ]);
-}
-function collectionMismatchDetails(name, expected, actual) {
-    return errorDetails([
-        collectionDetail(name),
-        detail("expected", expected),
-        detail("actual", actual),
-    ]);
-}
-export function isCollectionIndexed(info) {
-    return info?.embedding !== null
-        && info?.embedding !== undefined
-        && info.indexVersion !== null
-        && info.indexVersion !== undefined;
-}
-function requireIndexedEmbedding(info, operation) {
-    if (isCollectionIndexed(info)) {
-        return info.embedding;
-    }
-    throw new EngineError("Collection index has not been built", {
-        code: "ZVEC_GREP.ENGINE.COLLECTION.INDEX_MISSING",
-        context: errorDetails([
-            collectionDetail(info.name),
-            detail("operation", operation),
-            detail("hint", "Run zg --index to build this index."),
-        ]),
-    });
-}
-export class CollectionRegistry {
-    home;
-    embeddingModel;
-    readOnly;
-    meta;
-    collections = new Map();
-    constructor(home = defaultHome(), embeddingModel, readOnly = false) {
-        this.home = home;
-        this.embeddingModel = embeddingModel;
-        this.readOnly = readOnly;
-        if (!readOnly) {
-            mkdirSync(home, { recursive: true });
-        }
-        this.meta = new ZvecCollectionsMetaStore(collectionsMetaPath(home), readOnly);
-    }
-    list() {
-        return this.meta.list();
-    }
-    get(name) {
-        return this.meta.getByName(name);
-    }
-    has(name) {
-        return this.get(name) !== null;
-    }
-    remove(name) {
-        if (this.readOnly) {
-            throw new EngineError("Cannot remove a collection from a read-only registry", {
-                code: "ZVEC_GREP.ENGINE.COLLECTION.READ_ONLY",
-                context: collectionOperationDetails(name, "remove"),
-            });
-        }
-        const info = this.get(name);
-        if (!info) {
-            return false;
-        }
-        const cached = this.collections.get(name);
-        if (cached) {
-            cached.close();
-            this.collections.delete(name);
-        }
-        this.meta.remove(info.id);
-        const files = new ZvecFileMetaStore(filesMetaPath(this.home), false);
-        try {
-            files.deleteCollection(info.id);
-        }
-        finally {
-            files.close();
-        }
-        rmSync(info.path, { recursive: true, force: true });
-        return true;
-    }
-    rename(name, nextName) {
-        if (this.readOnly) {
-            throw new EngineError("Cannot rename a collection from a read-only registry", {
-                code: "ZVEC_GREP.ENGINE.COLLECTION.READ_ONLY",
-                context: collectionOperationDetails(name, "rename"),
-            });
-        }
-        const normalizedNextName = nextName.trim();
-        if (normalizedNextName.length === 0) {
-            throw new EngineError("Collection rename requires a non-empty name", {
-                code: "ZVEC_GREP.ENGINE.COLLECTION.EMPTY_NAME",
-                context: collectionOperationDetails(name, "rename"),
-            });
-        }
-        const info = this.get(name);
-        if (!info) {
-            return null;
-        }
-        if (this.has(normalizedNextName)) {
-            throw new EngineError("Collection already exists", {
-                code: "ZVEC_GREP.ENGINE.COLLECTION.ALREADY_EXISTS",
-                context: errorDetails([collectionDetail(normalizedNextName)]),
-            });
-        }
-        const cached = this.collections.get(name);
-        if (cached) {
-            cached.close();
-            this.collections.delete(name);
-        }
-        const updated = {
-            ...info,
-            name: normalizedNextName,
-            updatedTime: Date.now(),
-        };
-        this.meta.upsert(updated);
-        return updated;
-    }
-    async status(name) {
-        const info = this.get(name);
-        if (!info || !isCollectionIndexed(info) || info.indexPolicy === "disabled") {
-            return null;
-        }
-        return this.open(name).status();
-    }
-    create(name, rootPaths, path) {
-        if (this.readOnly) {
-            throw new EngineError("Cannot create a collection in a read-only registry", {
-                code: "ZVEC_GREP.ENGINE.COLLECTION.READ_ONLY",
-                context: collectionOperationDetails(name, "create"),
-            });
-        }
-        if (!this.embeddingModel) {
-            throw new EngineError("Creating a collection requires an embedding model", {
-                code: "ZVEC_GREP.ENGINE.COLLECTION.EMBEDDING_MODEL_REQUIRED",
-                context: collectionOperationDetails(name, "create"),
-            });
-        }
-        if (this.has(name)) {
-            throw new EngineError("Collection already exists", {
-                code: "ZVEC_GREP.ENGINE.COLLECTION.ALREADY_EXISTS",
-                context: errorDetails([collectionDetail(name)]),
-            });
-        }
-        const id = randomUUID();
-        const collectionPath = normalizePath(path ?? join(this.home, "collections", id));
-        const now = Date.now();
-        const normalizedRootPaths = validateRootPaths(rootPaths);
-        const info = {
-            id,
-            name,
-            path: collectionPath,
-            rootPaths: normalizedRootPaths,
-            indexPolicy: "enabled",
-            embedding: currentEmbeddingSchema(this.embeddingModel),
-            indexVersion: CURRENT_INDEX_VERSION,
-            createdTime: now,
-            updatedTime: now,
-        };
-        mkdirSync(collectionPath, { recursive: true });
-        this.meta.upsert(info);
-        return info;
-    }
-    prepareIndex(name, rootPaths, path) {
-        if (this.readOnly) {
-            throw new EngineError("Cannot prepare a collection in a read-only registry", {
-                code: "ZVEC_GREP.ENGINE.COLLECTION.READ_ONLY",
-                context: collectionOperationDetails(name, "prepareIndex"),
-            });
-        }
-        if (!this.embeddingModel) {
-            throw new EngineError("Preparing a collection requires an embedding model", {
-                code: "ZVEC_GREP.ENGINE.COLLECTION.EMBEDDING_MODEL_REQUIRED",
-                context: collectionOperationDetails(name, "prepareIndex"),
-            });
-        }
-        const existing = this.get(name);
-        if (!existing) {
-            return this.create(name, rootPaths, path);
-        }
-        const normalizedRootPaths = validateRootPaths(rootPaths);
-        const collectionPath = normalizePath(path ?? existing.path);
-        const cached = this.collections.get(name);
-        if (cached) {
-            cached.close();
-            this.collections.delete(name);
-        }
-        const updated = {
-            ...existing,
-            path: collectionPath,
-            rootPaths: normalizedRootPaths,
-            indexPolicy: "enabled",
-            embedding: currentEmbeddingSchema(this.embeddingModel),
-            indexVersion: CURRENT_INDEX_VERSION,
-            updatedTime: Date.now(),
-        };
-        mkdirSync(collectionPath, { recursive: true });
-        this.meta.upsert(updated);
-        return updated;
-    }
-    disableIndex(name, rootPaths, path) {
-        if (this.readOnly) {
-            throw new EngineError("Cannot disable a collection index in a read-only registry", {
-                code: "ZVEC_GREP.ENGINE.COLLECTION.READ_ONLY",
-                context: collectionOperationDetails(name, "disableIndex"),
-            });
-        }
-        const existing = this.get(name);
-        const normalizedRootPaths = validateRootPaths(rootPaths);
-        const now = Date.now();
-        if (existing) {
-            const cached = this.collections.get(name);
-            if (cached) {
-                cached.close();
-                this.collections.delete(name);
-            }
-            const updated = {
-                ...existing,
-                rootPaths: normalizedRootPaths,
-                path: normalizePath(path ?? existing.path),
-                indexPolicy: "disabled",
-                embedding: null,
-                indexVersion: null,
-                updatedTime: now,
-            };
-            this.meta.upsert(updated);
-            return updated;
-        }
-        const collectionPath = normalizePath(path ?? join(this.home, "collections", randomUUID()));
-        const info = {
-            id: randomUUID(),
-            name,
-            path: collectionPath,
-            rootPaths: normalizedRootPaths,
-            indexPolicy: "disabled",
-            embedding: null,
-            indexVersion: null,
-            createdTime: now,
-            updatedTime: now,
-        };
-        this.meta.upsert(info);
-        return info;
-    }
-    updateRootPaths(name, rootPaths) {
-        if (this.readOnly) {
-            throw new EngineError("Cannot update a collection from a read-only registry", {
-                code: "ZVEC_GREP.ENGINE.COLLECTION.READ_ONLY",
-                context: collectionOperationDetails(name, "updateRootPaths"),
-            });
-        }
-        const info = this.get(name);
-        if (!info) {
-            return null;
-        }
-        const normalizedRootPaths = validateRootPaths(rootPaths);
-        if (rootPathsEqual(info.rootPaths, normalizedRootPaths)) {
-            return info;
-        }
-        const cached = this.collections.get(name);
-        if (cached) {
-            cached.close();
-            this.collections.delete(name);
-        }
-        const updated = {
-            ...info,
-            rootPaths: normalizedRootPaths,
-            updatedTime: Date.now(),
-        };
-        this.meta.upsert(updated);
-        return updated;
-    }
-    open(name) {
-        const cached = this.collections.get(name);
-        if (cached) {
-            return cached;
-        }
-        const info = this.get(name);
-        if (!info) {
-            throw new EngineError("Collection not found", {
-                code: "ZVEC_GREP.ENGINE.COLLECTION.NOT_FOUND",
-                context: errorDetails([collectionDetail(name)]),
-            });
-        }
-        if (info.indexPolicy === "disabled") {
-            throw new EngineError("Collection index is disabled", {
-                code: "ZVEC_GREP.ENGINE.COLLECTION.INDEX_DISABLED",
-                context: errorDetails([
-                    collectionDetail(name),
-                    detail("hint", "Run zg --index to enable and build this index, or use zg --rg for no-index search."),
-                ]),
-            });
-        }
-        if (!isCollectionIndexed(info)) {
-            throw new EngineError("Collection index has not been built", {
-                code: "ZVEC_GREP.ENGINE.COLLECTION.INDEX_MISSING",
-                context: errorDetails([
-                    collectionDetail(name),
-                    detail("hint", "Run zg --index to build this index."),
-                ]),
-            });
-        }
-        const collection = new Collection(info, this.embeddingModel, this.readOnly, filesMetaPath(this.home));
-        this.collections.set(name, collection);
-        return collection;
-    }
-    close() {
-        for (const collection of this.collections.values()) {
-            collection.close();
-        }
-        this.collections.clear();
-        this.meta.close();
-    }
-}
-class ZvecCollectionsMetaStore {
-    path;
-    readOnly;
-    collection;
-    needsOptimize = false;
-    constructor(path, readOnly = false) {
-        this.path = path;
-        this.readOnly = readOnly;
-        initializeZvec();
-        if (!readOnly) {
-            mkdirSync(homeDirectoryForMetaPath(path), { recursive: true });
-        }
-        if (existsSync(path)) {
-            this.collection = openZvecCollection(path, readOnly, "open", () => ZVecOpen(path, { readOnly }));
-        }
-        else if (readOnly) {
-            this.collection = null;
-        }
-        else {
-            this.collection = openZvecCollection(path, readOnly, "create", () => ZVecCreateAndOpen(path, createCollectionsSchema()));
-        }
-    }
-    list() {
-        if (!this.collection) {
-            return [];
-        }
-        const topk = Math.max(this.collection.stats.docCount, 1);
-        return this.collection.querySync({ topk, includeVector: false })
-            .map((doc) => docToCollectionInfo(doc))
-            .sort((left, right) => left.name.localeCompare(right.name));
-    }
-    getByName(name) {
-        if (!this.collection) {
-            return null;
-        }
-        const [doc] = this.collection.querySync({
-            filter: `name = ${quoteFilterString(name)}`,
-            topk: 1,
-            includeVector: false,
-        });
-        return doc ? docToCollectionInfo(doc) : null;
-    }
-    upsert(info) {
-        this.assertWritable("upsert");
-        const collection = this.requireCollection();
-        const deleteStatus = collection.deleteSync(info.id);
-        assertZvecStatusOrNotFound(deleteStatus, "collection metadata replace", info.name);
-        const status = collection.upsertSync(collectionInfoToDoc(info));
-        assertZvecStatus(status, "collection metadata upsert", info.name);
-        this.needsOptimize = true;
-    }
-    remove(collectionId) {
-        this.assertWritable("remove");
-        const status = this.requireCollection().deleteByFilterSync(`collection_id = ${quoteFilterString(collectionId)}`);
-        assertZvecStatus(status, "collection metadata delete", collectionId);
-        this.needsOptimize = true;
-    }
-    close() {
-        if (!this.collection) {
-            return;
-        }
-        if (this.needsOptimize) {
-            this.collection.optimizeSync();
-            this.needsOptimize = false;
-        }
-        this.collection.closeSync();
-    }
-    requireCollection() {
-        if (!this.collection) {
-            throw new EngineError("zvec collection metadata storage is unavailable", {
-                code: "ZVEC_GREP.ENGINE.COLLECTION.META_UNAVAILABLE",
-                context: `path=${this.path}`,
-            });
-        }
-        return this.collection;
-    }
-    assertWritable(operation) {
-        if (this.readOnly) {
-            throw new EngineError("Cannot update read-only collection metadata storage", {
-                code: "ZVEC_GREP.ENGINE.COLLECTION.READ_ONLY",
-                context: `path=${this.path} operation=${operation}`,
-            });
-        }
-    }
-}
-function assertZvecStatusOrNotFound(status, operation, context) {
-    if (status.ok || status.code === "ZVEC_NOT_FOUND") {
-        return;
-    }
-    assertZvecStatus(status, operation, context);
-}
-function createCollectionsSchema() {
-    return new ZVecCollectionSchema({
-        name: "zvec_grep_collections",
-        fields: [
-            indexedStringField("collection_id"),
-            indexedStringField("name"),
-            indexedStringField("path"),
-            stringField("root_paths_json"),
-            indexedStringField("index_policy", true),
-            indexedStringField("embedding_provider", true),
-            indexedStringField("embedding_model", true),
-            {
-                name: "embedding_dimension",
-                dataType: ZVecDataType.INT32,
-                nullable: true,
-            },
-            indexedStringField("embedding_metric", true),
-            {
-                name: "index_version",
-                dataType: ZVecDataType.INT32,
-                nullable: true,
-            },
-            {
-                name: "created_time",
-                dataType: ZVecDataType.INT64,
-                nullable: false,
-            },
-            {
-                name: "updated_time",
-                dataType: ZVecDataType.INT64,
-                nullable: false,
-            },
-        ],
-    });
-}
-function collectionInfoToDoc(info) {
-    const fields = {
-        collection_id: info.id,
-        name: info.name,
-        path: info.path,
-        root_paths_json: JSON.stringify(info.rootPaths),
-        created_time: info.createdTime,
-        updated_time: info.updatedTime,
-    };
-    if (info.indexPolicy !== undefined) {
-        fields.index_policy = info.indexPolicy;
-    }
-    if (info.embedding) {
-        fields.embedding_provider = info.embedding.provider;
-        fields.embedding_model = info.embedding.model;
-        fields.embedding_dimension = info.embedding.dimension;
-        fields.embedding_metric = info.embedding.metric;
-    }
-    if (info.indexVersion !== null && info.indexVersion !== undefined) {
-        fields.index_version = info.indexVersion;
-    }
-    return {
-        id: info.id,
-        fields,
-    };
-}
-function docToCollectionInfo(doc) {
-    const fields = doc.fields;
-    const embedding = collectionEmbeddingFromFields(fields);
-    return {
-        id: readStringFieldFromFields(fields, "collection_id"),
-        name: readStringFieldFromFields(fields, "name"),
-        path: normalizePath(readStringFieldFromFields(fields, "path")),
-        rootPaths: parseRootPaths(readStringFieldFromFields(fields, "root_paths_json")),
-        indexPolicy: collectionIndexPolicyFromFields(fields),
-        embedding,
-        indexVersion: readNullableNumberFieldFromFields(fields, "index_version"),
-        createdTime: readNumberFieldFromFields(fields, "created_time"),
-        updatedTime: readNumberFieldFromFields(fields, "updated_time"),
-    };
-}
-function collectionEmbeddingFromFields(fields) {
-    const provider = readNullableStringFieldFromFields(fields, "embedding_provider");
-    const model = readNullableStringFieldFromFields(fields, "embedding_model");
-    const dimension = readNullableNumberFieldFromFields(fields, "embedding_dimension");
-    const metric = readNullableStringFieldFromFields(fields, "embedding_metric");
-    if (!provider || !model || !dimension || !metric) {
-        return null;
-    }
-    return {
-        provider,
-        model,
-        dimension,
-        metric,
-    };
-}
-function collectionIndexPolicyFromFields(fields) {
-    const policy = readNullableStringFieldFromFields(fields, "index_policy");
-    return policy === "enabled" || policy === "disabled" ? policy : undefined;
-}
-function parseRootPaths(value) {
-    try {
-        const parsed = JSON.parse(value);
-        return Array.isArray(parsed) ? validateRootPaths(parsed) : [];
-    }
-    catch {
-        return [];
-    }
-}
-function collectionsMetaPath(home) {
-    return join(home, COLLECTIONS_ZVEC);
-}
-function filesMetaPath(home) {
-    return join(home, FILES_ZVEC);
-}
-function homeDirectoryForMetaPath(path) {
-    return dirname(path);
-}
-function indexedStringField(name, nullable = false) {
-    return {
-        name,
-        dataType: ZVecDataType.STRING,
-        nullable,
-        indexParams: { indexType: ZVecIndexType.INVERT },
-    };
-}
-function stringField(name, nullable = false) {
-    return {
-        name,
-        dataType: ZVecDataType.STRING,
-        nullable,
-    };
-}
-export function defaultCollectionName(path) {
-    return basename(normalizePath(path));
-}
-function currentEmbeddingSchema(model) {
-    return {
-        provider: model.ref.provider,
-        model: model.ref.model,
-        dimension: model.dimension,
-        metric: model.metric,
-    };
-}
-function rootPathsEqual(left, right) {
-    return JSON.stringify(left) === JSON.stringify(right);
-}
-//# sourceMappingURL=index.js.map