paper-manager 0.8.0 → 0.9.0

package/dist/ai/embed.js

@@ -29,4 +29,3 @@ export async function embedMany(config, texts) {
     }
     return embeddings;
 }
-//# sourceMappingURL=embed.js.map

package/dist/ai/index.js

@@ -1,3 +1,2 @@
 export { embed, embedMany } from "./embed.js";
 export { createEmbeddingModel } from "./provider.js";
-//# sourceMappingURL=index.js.map

package/dist/ai/provider.js

@@ -6,4 +6,3 @@ export function createEmbeddingModel(config) {
     });
     return openai.embedding(config.model);
 }
-//# sourceMappingURL=provider.js.map

package/dist/commands/config.js

@@ -80,4 +80,3 @@ export function createConfigCommand() {
     });
     return config;
 }
-//# sourceMappingURL=config.js.map

package/dist/commands/knowledge-base.js

@@ -57,6 +57,7 @@ export function createKnowledgeBaseCommand() {
         .description("List knowledge bases")
         .option("--user", "List user knowledge bases only")
         .option("--all", "List all knowledge bases (default)")
+        .option("--json", "Output as JSON")
         .action((options) => {
         let results = [];
         if (options.user) {
@@ -68,7 +69,16 @@ export function createKnowledgeBaseCommand() {
             results = [...projectKbs, ...userKbs];
         }
         if (results.length === 0) {
-            log.info("No knowledge bases found.");
+            if (options.json) {
+                log.plain("[]");
+            }
+            else {
+                log.info("No knowledge bases found.");
+            }
+            return;
+        }
+        if (options.json) {
+            log.plain(JSON.stringify(results, null, 2));
             return;
         }
         for (const kb of results) {
@@ -151,6 +161,7 @@ export function createKnowledgeBaseCommand() {
     kb.command("query <id> <query-text>")
         .description("Query a knowledge base")
         .option("-k, --top-k <number>", "Number of results", "5")
+        .option("--json", "Output as JSON")
         .action(async (id, queryText, options) => {
         const resolved = resolveKnowledgeBase(id);
         if (!resolved) {
@@ -168,7 +179,19 @@ export function createKnowledgeBaseCommand() {
         const k = parseInt(options.topK, 10);
         const results = await queryVectorStore(modelConfig, vectorDir, queryText, k);
         if (results.length === 0) {
-            log.info("No results found.");
+            if (options.json) {
+                log.plain("[]");
+            }
+            else {
+                log.info("No results found.");
+            }
+            return;
+        }
+        if (options.json) {
+            const output = results
+                .filter((doc) => doc != null)
+                .map((doc) => ({ pageContent: doc.pageContent, metadata: doc.metadata }));
+            log.plain(JSON.stringify(output, null, 2));
             return;
         }
         for (let i = 0; i < results.length; i++) {
@@ -185,4 +208,3 @@ export function createKnowledgeBaseCommand() {
     });
     return kb;
 }
-//# sourceMappingURL=knowledge-base.js.map

package/dist/commands/literature.js

@@ -1,6 +1,5 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { RecursiveCharacterTextSplitter } from "@langchain/textsplitters";
 import chalk from "chalk";
 import cliProgress from "cli-progress";
 import { Command } from "commander";
@@ -11,7 +10,8 @@ import * as userKb from "../db/user/knowledge-bases.js";
 import * as userLit from "../db/user/literatures.js";
 import { extractContent, extractPdfMetadata } from "../extractor/index.js";
 import { log } from "../logger.js";
-import { createVectorStore, loadVectorStore } from "../vector-store/index.js";
+import { splitDocuments } from "../text-splitter.js";
+import { addDocuments, createVectorStore } from "../vector-store/index.js";
 function resolveKnowledgeBase(id) {
     const pkb = projectKb.getKnowledgeBase(id);
     if (pkb)
@@ -96,11 +96,7 @@ export function createLiteratureCommand() {
         fs.copyFileSync(absolutePath, path.join(filesDir, `${literature.id}${ext}`));
         // Split text and add to vector store
         log.info("Splitting text...");
-        const splitter = new RecursiveCharacterTextSplitter({
-            chunkSize: 1000,
-            chunkOverlap: 200,
-        });
-        const splitDocs = await splitter.splitDocuments(docs);
+        const splitDocs = splitDocuments(docs, { chunkSize: 1000, chunkOverlap: 200 });
         log.step(`Created ${String(splitDocs.length)} chunks.`);
         // Add literature ID metadata to each chunk
         for (const doc of splitDocs) {
@@ -115,12 +111,9 @@ export function createLiteratureCommand() {
         const hasIndex = fs.existsSync(path.join(vectorDir, "faiss.index")) &&
             fs.existsSync(path.join(vectorDir, "docstore.json"));
         if (hasIndex) {
-            const store = await loadVectorStore(modelConfig, vectorDir);
-            await store.addDocuments(splitDocs);
-            await store.save(vectorDir);
+            await addDocuments(splitDocs, modelConfig, vectorDir);
         }
         else {
-            fs.mkdirSync(vectorDir, { recursive: true });
             await createVectorStore(splitDocs, modelConfig, vectorDir);
         }
         bar.update(splitDocs.length);
@@ -211,7 +204,8 @@ export function createLiteratureCommand() {
     lit
         .command("list <knowledge-base-id>")
         .description("List literatures in a knowledge base")
-        .action((kbId) => {
+        .option("--json", "Output as JSON")
+        .action((kbId, options) => {
         const resolved = resolveKnowledgeBase(kbId);
         if (!resolved) {
             log.error(`Knowledge base not found: ${kbId}`);
@@ -220,7 +214,16 @@ export function createLiteratureCommand() {
         const litOps = getLitOps(resolved.scope);
         const literatures = litOps.listLiteratures(kbId);
         if (literatures.length === 0) {
-            log.info("No literatures found.");
+            if (options.json) {
+                log.plain("[]");
+            }
+            else {
+                log.info("No literatures found.");
+            }
+            return;
+        }
+        if (options.json) {
+            log.plain(JSON.stringify(literatures, null, 2));
             return;
         }
         for (const l of literatures) {
@@ -233,11 +236,68 @@ export function createLiteratureCommand() {
         }
         log.count(literatures.length, literatures.length === 1 ? "literature" : "literatures");
     });
+    // ─── lit search ────────────────────────────────────────────
+    lit
+        .command("search <knowledge-base-id>")
+        .description("Search literatures in a knowledge base by metadata")
+        .option("-t, --title <title>", "Title substring")
+        .option("-a, --author <author>", "Author substring")
+        .option("-k, --keyword <keyword>", "Keyword substring")
+        .option("--doi <doi>", "DOI substring")
+        .option("--json", "Output as JSON")
+        .action((kbId, options) => {
+        const resolved = resolveKnowledgeBase(kbId);
+        if (!resolved) {
+            log.error(`Knowledge base not found: ${kbId}`);
+            process.exit(1);
+        }
+        if (options.title === undefined &&
+            options.author === undefined &&
+            options.keyword === undefined &&
+            options.doi === undefined) {
+            log.error("At least one filter (--title, --author, --keyword, --doi) is required.");
+            process.exit(1);
+        }
+        const litOps = getLitOps(resolved.scope);
+        const results = litOps.searchLiteratures(kbId, {
+            title: options.title,
+            author: options.author,
+            keyword: options.keyword,
+            doi: options.doi,
+        });
+        if (results.length === 0) {
+            if (options.json) {
+                log.plain("[]");
+            }
+            else {
+                log.info("No literatures found.");
+            }
+            return;
+        }
+        if (options.json) {
+            log.plain(JSON.stringify(results, null, 2));
+            return;
+        }
+        for (const l of results) {
+            log.header(l.id);
+            log.label("Title:", l.title);
+            if (l.author)
+                log.label("Author:", l.author);
+            if (l.doi)
+                log.label("DOI:", l.doi);
+            if (l.keywords.length > 0)
+                log.label("Keywords:", l.keywords.join(", "));
+            log.label("Created:", l.createdAt.toISOString());
+            log.newline();
+        }
+        log.count(results.length, results.length === 1 ? "literature" : "literatures");
+    });
     // ─── lit show ──────────────────────────────────────────────
     lit
         .command("show <knowledge-base-id> <id>")
         .description("Show literature details")
-        .action((kbId, id) => {
+        .option("--json", "Output as JSON")
+        .action((kbId, id, options) => {
         const resolved = resolveKnowledgeBase(kbId);
         if (!resolved) {
             log.error(`Knowledge base not found: ${kbId}`);
@@ -249,6 +309,10 @@ export function createLiteratureCommand() {
             log.error(`Literature not found: ${id}`);
             process.exit(1);
         }
+        if (options.json) {
+            log.plain(JSON.stringify(literature, null, 2));
+            return;
+        }
         printLiterature(literature);
     });
     // ─── lit note ──────────────────────────────────────────────
@@ -256,12 +320,17 @@ export function createLiteratureCommand() {
     note
         .command("list <literature-id>")
         .description("List all notes for a literature")
-        .action((litId) => {
+        .option("--json", "Output as JSON")
+        .action((litId, options) => {
         const literature = findLiterature(litId);
         if (!literature) {
             log.error(`Literature not found: ${litId}`);
             process.exit(1);
         }
+        if (options.json) {
+            log.plain(JSON.stringify(literature.notes, null, 2));
+            return;
+        }
         const entries = Object.entries(literature.notes);
         if (entries.length === 0) {
             log.info("No notes found.");
@@ -346,4 +415,3 @@ function printLiterature(lit) {
         }
     }
 }
-//# sourceMappingURL=literature.js.map

package/dist/commands/util.js

@@ -60,4 +60,3 @@ export function createUtilCommand() {
     });
     return util;
 }
-//# sourceMappingURL=util.js.map

package/dist/config/index.js

@@ -104,4 +104,3 @@ export function getDefaultModelConfig() {
     }
     return getModelConfig(defaultId);
 }
-//# sourceMappingURL=index.js.map

package/dist/config/init.js

@@ -52,4 +52,3 @@ export function initScope(options) {
     }
     return { baseDir, items };
 }
-//# sourceMappingURL=init.js.map

package/dist/db/index.js

@@ -3,7 +3,7 @@ import * as path from "node:path";
 import Database from "better-sqlite3";
 import { drizzle } from "drizzle-orm/better-sqlite3";
 import { getProjectDataDir, getUserDataDir } from "../config/index.js";
-import { CREATE_KNOWLEDGE_BASES_TABLE, CREATE_LITERATURES_TABLE } from "./schema.js";
+import { CREATE_KNOWLEDGE_BASES_TABLE, CREATE_LITERATURES_KB_INDEX, CREATE_LITERATURES_TABLE, } from "./schema.js";
 // ─── Database Connection ────────────────────────────────────
 export function openDatabase(dbPath) {
     const dir = path.dirname(dbPath);
@@ -16,6 +16,7 @@ export function openDatabase(dbPath) {
 export function initializeDatabase(db) {
     db.exec(CREATE_KNOWLEDGE_BASES_TABLE);
     db.exec(CREATE_LITERATURES_TABLE);
+    db.exec(CREATE_LITERATURES_KB_INDEX);
     migrateDatabase(db);
 }
 // ─── Migrations ─────────────────────────────────────────────
@@ -27,6 +28,10 @@ const MIGRATIONS = [
             db.exec("ALTER TABLE literatures ADD COLUMN doi TEXT");
         }
     },
+    // v1 → v2: add index on literatures.knowledge_base_id for faster KB-scoped lookups
+    (db) => {
+        db.exec(CREATE_LITERATURES_KB_INDEX);
+    },
 ];
 function migrateDatabase(db) {
     const currentVersion = db.pragma("user_version", { simple: true }) ?? 0;
@@ -60,4 +65,3 @@ export function getProjectDb() {
     }
     return projectDb;
 }
-//# sourceMappingURL=index.js.map

package/dist/db/operations/knowledge-bases.js

@@ -48,4 +48,3 @@ export function deleteKnowledgeBase(db, id) {
     const result = db.delete(knowledgeBases).where(eq(knowledgeBases.id, id)).run();
     return result.changes > 0;
 }
-//# sourceMappingURL=knowledge-bases.js.map

package/dist/db/operations/literatures.js

@@ -1,5 +1,5 @@
 import * as crypto from "node:crypto";
-import { desc, eq } from "drizzle-orm";
+import { and, desc, eq, like } from "drizzle-orm";
 import { literatures } from "../schema.js";
 export function createLiterature(db, input) {
     const id = crypto.randomUUID();
@@ -39,6 +39,24 @@ export function listLiteratures(db, knowledgeBaseId) {
         .orderBy(desc(literatures.createdAt))
         .all();
 }
+export function searchLiteratures(db, knowledgeBaseId, filters) {
+    const conditions = [eq(literatures.knowledgeBaseId, knowledgeBaseId)];
+    if (filters.title)
+        conditions.push(like(literatures.title, `%${filters.title}%`));
+    if (filters.author)
+        conditions.push(like(literatures.author, `%${filters.author}%`));
+    if (filters.doi)
+        conditions.push(like(literatures.doi, `%${filters.doi}%`));
+    // keywords stored as JSON text; LIKE over raw text matches substrings
+    if (filters.keyword)
+        conditions.push(like(literatures.keywords, `%${filters.keyword}%`));
+    return db
+        .select()
+        .from(literatures)
+        .where(and(...conditions))
+        .orderBy(desc(literatures.createdAt))
+        .all();
+}
 export function updateLiterature(db, id, input) {
     const updates = {};
     if (input.title !== undefined)
@@ -81,4 +99,3 @@ export function deleteLiteraturesByKnowledgeBaseId(db, knowledgeBaseId) {
 export function getLiteraturesByKnowledgeBaseId(db, knowledgeBaseId) {
     return listLiteratures(db, knowledgeBaseId);
 }
-//# sourceMappingURL=literatures.js.map

package/dist/db/project/knowledge-bases.js

@@ -15,4 +15,3 @@ export function updateKnowledgeBase(id, input) {
 export function deleteKnowledgeBase(id) {
     return ops.deleteKnowledgeBase(getProjectDb(), id);
 }
-//# sourceMappingURL=knowledge-bases.js.map

package/dist/db/project/literatures.js

@@ -18,7 +18,9 @@ export function deleteLiterature(id) {
 export function deleteLiteraturesByKnowledgeBaseId(knowledgeBaseId) {
     return ops.deleteLiteraturesByKnowledgeBaseId(getProjectDb(), knowledgeBaseId);
 }
+export function searchLiteratures(knowledgeBaseId, filters) {
+    return ops.searchLiteratures(getProjectDb(), knowledgeBaseId, filters);
+}
 export function getLiteraturesByKnowledgeBaseId(knowledgeBaseId) {
     return ops.getLiteraturesByKnowledgeBaseId(getProjectDb(), knowledgeBaseId);
 }
-//# sourceMappingURL=literatures.js.map

package/dist/db/schema.js

@@ -1,4 +1,4 @@
-import { integer, sqliteTable, text } from "drizzle-orm/sqlite-core";
+import { index, integer, sqliteTable, text } from "drizzle-orm/sqlite-core";
 // ─── Drizzle Table Definitions ──────────────────────────────
 export const knowledgeBases = sqliteTable("knowledge_bases", {
     id: text("id").primaryKey(),
@@ -24,7 +24,7 @@ export const literatures = sqliteTable("literatures", {
     }),
     createdAt: integer("created_at", { mode: "timestamp_ms" }).notNull(),
     updatedAt: integer("updated_at", { mode: "timestamp_ms" }).notNull(),
-});
+}, (t) => [index("idx_literatures_knowledge_base_id").on(t.knowledgeBaseId)]);
 // ─── Bootstrap SQL ──────────────────────────────────────────
 export const CREATE_KNOWLEDGE_BASES_TABLE = `
 CREATE TABLE IF NOT EXISTS knowledge_bases (
@@ -52,4 +52,6 @@ CREATE TABLE IF NOT EXISTS literatures (
     updated_at INTEGER NOT NULL,
     FOREIGN KEY (knowledge_base_id) REFERENCES knowledge_bases(id) ON DELETE SET NULL
 )`;
-//# sourceMappingURL=schema.js.map
+export const CREATE_LITERATURES_KB_INDEX = `
+CREATE INDEX IF NOT EXISTS idx_literatures_knowledge_base_id
+    ON literatures(knowledge_base_id)`;

package/dist/db/test-utils.js

@@ -9,4 +9,3 @@ export function createTestDb() {
     initializeDatabase(client);
     return drizzle(client);
 }
-//# sourceMappingURL=test-utils.js.map

package/dist/db/user/knowledge-bases.js

@@ -15,4 +15,3 @@ export function updateKnowledgeBase(id, input) {
 export function deleteKnowledgeBase(id) {
     return ops.deleteKnowledgeBase(getUserDb(), id);
 }
-//# sourceMappingURL=knowledge-bases.js.map

package/dist/db/user/literatures.js

@@ -18,7 +18,9 @@ export function deleteLiterature(id) {
 export function deleteLiteraturesByKnowledgeBaseId(knowledgeBaseId) {
     return ops.deleteLiteraturesByKnowledgeBaseId(getUserDb(), knowledgeBaseId);
 }
+export function searchLiteratures(knowledgeBaseId, filters) {
+    return ops.searchLiteratures(getUserDb(), knowledgeBaseId, filters);
+}
 export function getLiteraturesByKnowledgeBaseId(knowledgeBaseId) {
     return ops.getLiteraturesByKnowledgeBaseId(getUserDb(), knowledgeBaseId);
 }
-//# sourceMappingURL=literatures.js.map

package/dist/extractor/index.js

@@ -20,4 +20,3 @@ export async function extractContent(filePath) {
     const ext = filePath.split(".").pop() ?? "unknown";
     throw new Error(`Unsupported file type: .${ext} (${String(mimeType)})`);
 }
-//# sourceMappingURL=index.js.map

package/dist/extractor/pdf.js

@@ -1,44 +1,43 @@
 import { readFile } from "node:fs/promises";
-import { Document } from "@langchain/core/documents";
-import { PDFParse } from "pdf-parse";
+import { extractText, getMeta } from "unpdf";
 export async function extractPdfContent(pdfPath) {
-    const data = await readFile(pdfPath);
-    const parser = new PDFParse({ data });
-    const result = await parser.getText();
-    await parser.destroy();
-    return result.pages.map((page) => new Document({
-        pageContent: page.text,
+    const data = new Uint8Array(await readFile(pdfPath));
+    const result = await extractText(data, { mergePages: false });
+    return result.text.map((pageText, i) => ({
+        pageContent: pageText,
         metadata: {
             source: pdfPath,
-            pdf: { totalPages: result.total },
-            loc: { pageNumber: page.num },
+            pdf: { totalPages: result.totalPages },
+            loc: { pageNumber: i + 1 },
         },
     }));
 }
 export async function extractPdfMetadata(pdfPath) {
-    const data = await readFile(pdfPath);
-    const parser = new PDFParse({ data });
-    const result = await parser.getInfo();
-    await parser.destroy();
-    const info = result.info;
-    const custom = info?.["Custom"];
-    const title = nonEmptyStringOrNull(info?.["Title"]);
-    const author = nonEmptyStringOrNull(info?.["Author"]);
-    const subject = nonEmptyStringOrNull(info?.["Subject"]);
-    const creator = nonEmptyStringOrNull(info?.["Creator"]);
-    const creationDate = parsePdfDate(nonEmptyStringOrNull(info?.["CreationDate"]));
-    const modDate = parsePdfDate(nonEmptyStringOrNull(info?.["ModDate"]));
-    const rawKeywords = nonEmptyStringOrNull(info?.["Keywords"]);
+    const data = new Uint8Array(await readFile(pdfPath));
+    const { info } = await getMeta(data);
+    const custom = getRecord(info["Custom"]);
+    const title = nonEmptyStringOrNull(info["Title"]);
+    const author = nonEmptyStringOrNull(info["Author"]);
+    const subject = nonEmptyStringOrNull(info["Subject"]);
+    const creator = nonEmptyStringOrNull(info["Creator"]);
+    const creationDate = parsePdfDate(nonEmptyStringOrNull(info["CreationDate"]));
+    const modDate = parsePdfDate(nonEmptyStringOrNull(info["ModDate"]));
+    const rawKeywords = nonEmptyStringOrNull(info["Keywords"]);
     const keywords = rawKeywords
         ? rawKeywords
             .split(/[,;]/)
             .map((k) => k.trim())
             .filter(Boolean)
         : [];
-    // DOI can appear in Custom fields (case-insensitive lookup)
     const doi = findCustomField(custom, "doi");
     return { title, author, subject, keywords, doi, creator, creationDate, modDate };
 }
+function getRecord(value) {
+    if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+        return value;
+    }
+    return undefined;
+}
 function nonEmptyStringOrNull(value) {
     if (typeof value === "string" && value.trim().length > 0) {
         return value.trim();
@@ -53,7 +52,6 @@ function parsePdfDate(value) {
     if (!value)
         return null;
     const cleaned = value.replace(/^D:/, "");
-    // Extract components: YYYY[MM[DD[HH[mm[SS]]]]]
     const match = /^(\d{4})(\d{2})?(\d{2})?(\d{2})?(\d{2})?(\d{2})?/.exec(cleaned);
     if (!match)
         return null;
@@ -66,9 +64,6 @@ function parsePdfDate(value) {
     const date = new Date(`${year}-${month}-${day}T${hour}:${min}:${sec}Z`);
     return Number.isNaN(date.getTime()) ? null : date;
 }
-/**
- * Case-insensitive lookup in the Custom fields dictionary.
- */
 function findCustomField(custom, key) {
     if (!custom)
         return null;
@@ -80,4 +75,3 @@ function findCustomField(custom, key) {
     }
     return null;
 }
-//# sourceMappingURL=pdf.js.map

package/dist/extractor/text.js

@@ -1,5 +1,4 @@
 import { readFile, stat } from "node:fs/promises";
-import { Document } from "@langchain/core/documents";
 const MAX_FILE_SIZE = 10 * 1024 * 1024; // 10 MB
 export async function extractTextContent(filePath) {
     const fileStats = await stat(filePath);
@@ -8,10 +7,9 @@ export async function extractTextContent(filePath) {
     }
     const content = await readFile(filePath, "utf-8");
     return [
-        new Document({
+        {
             pageContent: content,
             metadata: { source: filePath },
-        }),
+        },
     ];
 }
-//# sourceMappingURL=text.js.map

package/dist/index.js

@@ -18,4 +18,3 @@ program.addCommand(createKnowledgeBaseCommand());
 program.addCommand(createLiteratureCommand());
 program.addCommand(createUtilCommand());
 program.parse();
-//# sourceMappingURL=index.js.map

package/dist/lifecycle.js

@@ -4,4 +4,3 @@ export function startup() {
     migratePdfsToFiles(getUserDataDir());
     migratePdfsToFiles(getProjectDataDir());
 }
-//# sourceMappingURL=lifecycle.js.map

package/dist/logger.js

@@ -41,4 +41,3 @@ export const log = {
         console.log(chalk.dim(`Total: ${n} ${label}`));
     },
 };
-//# sourceMappingURL=logger.js.map

package/dist/migrations.js

@@ -25,4 +25,3 @@ export function migratePdfsToFiles(baseDir) {
         fs.rmSync(legacyPdfsDir, { recursive: true, force: true });
     }
 }
-//# sourceMappingURL=migrations.js.map

package/dist/text-splitter.js

@@ -0,0 +1,56 @@
+const DEFAULT_SEPARATORS = ["\n\n", "\n", " ", ""];
+export function splitDocuments(docs, options) {
+    if (options.chunkOverlap >= options.chunkSize) {
+        throw new Error("chunkOverlap must be less than chunkSize");
+    }
+    const result = [];
+    for (const doc of docs) {
+        const chunks = splitText(doc.pageContent, options.chunkSize, options.chunkOverlap);
+        for (const chunk of chunks) {
+            result.push({ pageContent: chunk, metadata: { ...doc.metadata } });
+        }
+    }
+    return result;
+}
+function splitText(text, chunkSize, chunkOverlap) {
+    return recursiveSplit(text, DEFAULT_SEPARATORS, chunkSize, chunkOverlap);
+}
+function recursiveSplit(text, separators, chunkSize, chunkOverlap) {
+    if (text.length <= chunkSize)
+        return [text];
+    const separator = separators[0] ?? "";
+    const remaining = separators.slice(1);
+    const parts = separator === "" ? [...text] : text.split(separator);
+    const chunks = [];
+    let current = "";
+    for (const part of parts) {
+        const piece = current.length === 0 ? part : current + separator + part;
+        if (piece.length > chunkSize && current.length > 0) {
+            chunks.push(current);
+            // Overlap: keep the tail of the current chunk
+            if (chunkOverlap > 0 && current.length > chunkOverlap) {
+                current = current.slice(-chunkOverlap) + separator + part;
+            }
+            else {
+                current = part;
+            }
+        }
+        else {
+            current = piece;
+        }
+    }
+    if (current.length > 0) {
+        chunks.push(current);
+    }
+    // Recursively split any chunks that are still too large
+    const finalChunks = [];
+    for (const chunk of chunks) {
+        if (chunk.length > chunkSize && remaining.length > 0) {
+            finalChunks.push(...recursiveSplit(chunk, remaining, chunkSize, chunkOverlap));
+        }
+        else {
+            finalChunks.push(chunk);
+        }
+    }
+    return finalChunks;
+}

package/dist/types/index.js

@@ -33,4 +33,3 @@ export const ConfigSchema = z.object({
     embeddingModels: z.record(z.string().min(1), EmbeddingModelConfigSchema).default({}),
     defaultEmbeddingModelId: z.string().min(1).optional(),
 });
-//# sourceMappingURL=index.js.map

package/dist/vector-store/embeddings.js

@@ -13,4 +13,3 @@ export class AiSdkEmbeddings extends Embeddings {
         return embedMany(this.config, documents);
     }
 }
-//# sourceMappingURL=embeddings.js.map