paper-manager 0.8.1 → 0.10.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/dep.js

@@ -0,0 +1,48 @@
+import chalk from "chalk";
+import { Command } from "commander";
+import { checkOpendataLoaderStatus } from "../extractor/markdown.js";
+import { log } from "../logger.js";
+const KNOWN_DEPS = new Set(["opendataloader"]);
+export function createDepCommand() {
+    const dep = new Command("dep").description("Manage external dependencies");
+    dep
+        .command("check <dep>")
+        .description("Check if an external dependency is available")
+        .action(async (depName) => {
+        if (!KNOWN_DEPS.has(depName)) {
+            log.error(`Unknown dependency: ${depName}`);
+            log.step(`Available: ${[...KNOWN_DEPS].join(", ")}`);
+            process.exit(1);
+        }
+        if (depName === "opendataloader") {
+            await checkOpendataLoader();
+        }
+    });
+    return dep;
+}
+async function checkOpendataLoader() {
+    log.info("Checking opendataloader-pdf...");
+    const status = await checkOpendataLoaderStatus();
+    const pkgIcon = status.packageInstalled ? chalk.green("✔") : chalk.red("✖");
+    const javaIcon = status.javaAvailable ? chalk.green("✔") : chalk.red("✖");
+    log.plain(`  ${pkgIcon} @opendataloader/pdf package`);
+    if (status.javaAvailable) {
+        log.plain(`  ${javaIcon} Java runtime (${status.javaVersion})`);
+    }
+    else {
+        log.plain(`  ${javaIcon} Java runtime (not found)`);
+    }
+    log.newline();
+    if (status.packageInstalled && status.javaAvailable) {
+        log.success("opendataloader-pdf is ready.");
+    }
+    else {
+        log.error("opendataloader-pdf is not available.");
+        if (!status.packageInstalled) {
+            log.step("Install: pnpm add @opendataloader/pdf");
+        }
+        if (!status.javaAvailable) {
+            log.step("Install Java 11+: https://adoptium.net/");
+        }
+    }
+}

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";
@@ -10,8 +9,10 @@ import * as projectLit from "../db/project/literatures.js";
 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 { convertPdfToMarkdown, isOpendataLoaderAvailable } from "../extractor/markdown.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)
@@ -94,13 +95,17 @@ export function createLiteratureCommand() {
         const ext = path.extname(litPath);
         fs.mkdirSync(filesDir, { recursive: true });
         fs.copyFileSync(absolutePath, path.join(filesDir, `${literature.id}${ext}`));
+        // Convert PDF to Markdown if opendataloader is available
+        if (isPdf && (await isOpendataLoaderAvailable())) {
+            const markdown = await convertPdfToMarkdown(absolutePath);
+            if (markdown) {
+                fs.writeFileSync(path.join(filesDir, `${literature.id}.md`), markdown, "utf-8");
+                log.step("Converted to Markdown via opendataloader-pdf.");
+            }
+        }
         // 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 +120,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);
@@ -136,6 +138,40 @@ export function createLiteratureCommand() {
         if (literature.keywords.length > 0)
             log.label("Keywords:", literature.keywords.join(", "));
     });
+    // ─── lit convert ────────────────────────────────────────────
+    lit
+        .command("convert <id>")
+        .description("Convert an existing literature PDF to Markdown via opendataloader-pdf")
+        .action(async (id) => {
+        const found = findLiteratureWithScope(id);
+        if (!found) {
+            log.error(`Literature not found: ${id}`);
+            process.exit(1);
+        }
+        const filesDir = getFilesDir(getBaseDir(found.scope));
+        const pdfFile = findLiteratureFiles(filesDir, id).find((f) => f.endsWith(".pdf"));
+        if (!pdfFile) {
+            log.error(`No PDF file found for literature: ${id}`);
+            process.exit(1);
+        }
+        const mdPath = path.join(filesDir, `${id}.md`);
+        if (fs.existsSync(mdPath)) {
+            log.error("Markdown file already exists. Delete it first to reconvert.");
+            process.exit(1);
+        }
+        if (!(await isOpendataLoaderAvailable())) {
+            log.error("opendataloader-pdf is not available. Run `paper dep check opendataloader` for details.");
+            process.exit(1);
+        }
+        log.info("Converting PDF to Markdown...");
+        const markdown = await convertPdfToMarkdown(path.join(filesDir, pdfFile));
+        if (!markdown) {
+            log.error("Conversion failed.");
+            process.exit(1);
+        }
+        fs.writeFileSync(mdPath, markdown, "utf-8");
+        log.success(`Markdown saved: ${id}.md`);
+    });
     // ─── lit remove ────────────────────────────────────────────
     lit
         .command("remove <knowledge-base-id> <id>")
@@ -211,7 +247,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,14 +257,26 @@ 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;
         }
+        const filesDir = getFilesDir(getBaseDir(resolved.scope));
         for (const l of literatures) {
             log.header(l.id);
             log.label("Title:", l.title);
             if (l.author)
                 log.label("Author:", l.author);
+            const files = findLiteratureFiles(filesDir, l.id);
+            log.label("Files:", files.length > 0 ? files.join(", ") : "(none)");
             log.label("Created:", l.createdAt.toISOString());
             log.newline();
         }
@@ -241,6 +290,7 @@ export function createLiteratureCommand() {
         .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) {
@@ -262,7 +312,16 @@ export function createLiteratureCommand() {
             doi: options.doi,
         });
         if (results.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(results, null, 2));
             return;
         }
         for (const l of results) {
@@ -283,7 +342,8 @@ export function createLiteratureCommand() {
     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}`);
@@ -295,19 +355,29 @@ export function createLiteratureCommand() {
             log.error(`Literature not found: ${id}`);
             process.exit(1);
         }
-        printLiterature(literature);
+        if (options.json) {
+            log.plain(JSON.stringify(literature, null, 2));
+            return;
+        }
+        const filesDir = getFilesDir(getBaseDir(resolved.scope));
+        printLiterature(literature, filesDir);
     });
     // ─── lit note ──────────────────────────────────────────────
     const note = lit.command("note").description("Manage literature notes");
     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.");
@@ -363,7 +433,15 @@ function findLiteratureWithScope(id) {
         return { literature: uLit, scope: "user" };
     return null;
 }
-function printLiterature(lit) {
+function findLiteratureFiles(filesDir, id) {
+    if (!fs.existsSync(filesDir))
+        return [];
+    return fs
+        .readdirSync(filesDir)
+        .filter((name) => name.startsWith(`${id}.`))
+        .sort();
+}
+function printLiterature(lit, filesDir) {
     log.header(lit.id);
     log.label("Title:", lit.title);
     if (lit.titleTranslation)
@@ -382,6 +460,8 @@ function printLiterature(lit) {
         log.label("DOI:", lit.doi);
     if (lit.knowledgeBaseId)
         log.label("Knowledge Base:", lit.knowledgeBaseId);
+    const files = findLiteratureFiles(filesDir, lit.id);
+    log.label("Files:", files.length > 0 ? files.join(", ") : "(none)");
     log.label("Created:", lit.createdAt.toISOString());
     log.label("Updated:", lit.updatedAt.toISOString());
     const noteEntries = Object.entries(lit.notes);
@@ -392,4 +472,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

@@ -65,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

@@ -99,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

@@ -24,4 +24,3 @@ export function searchLiteratures(knowledgeBaseId, filters) {
 export function getLiteraturesByKnowledgeBaseId(knowledgeBaseId) {
     return ops.getLiteraturesByKnowledgeBaseId(getProjectDb(), knowledgeBaseId);
 }
-//# sourceMappingURL=literatures.js.map

package/dist/db/schema.js

@@ -55,4 +55,3 @@ CREATE TABLE IF NOT EXISTS literatures (
 export const CREATE_LITERATURES_KB_INDEX = `
 CREATE INDEX IF NOT EXISTS idx_literatures_knowledge_base_id
     ON literatures(knowledge_base_id)`;
-//# sourceMappingURL=schema.js.map

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

@@ -24,4 +24,3 @@ export function searchLiteratures(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/markdown.js

@@ -0,0 +1,88 @@
+import { execFile } from "node:child_process";
+import { mkdirSync, readdirSync, readFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import * as path from "node:path";
+/**
+ * Check whether opendataloader-pdf is available (package installed + Java runtime).
+ * Result is cached after the first call.
+ */
+export async function isOpendataLoaderAvailable() {
+    if (cachedAvailability !== undefined)
+        return cachedAvailability;
+    cachedAvailability = await detectAvailability();
+    return cachedAvailability;
+}
+/**
+ * Convert a PDF file to Markdown using opendataloader-pdf.
+ * Returns the markdown content on success, or null on failure.
+ */
+export async function convertPdfToMarkdown(pdfPath) {
+    const outDir = path.join(tmpdir(), `odl-${Date.now()}`);
+    mkdirSync(outDir, { recursive: true });
+    try {
+        const { convert } = await import("@opendataloader/pdf");
+        await convert([pdfPath], {
+            outputDir: outDir,
+            format: "markdown",
+            quiet: true,
+        });
+        const mdFile = readdirSync(outDir).find((f) => f.endsWith(".md"));
+        if (!mdFile)
+            return null;
+        return readFileSync(path.join(outDir, mdFile), "utf-8");
+    }
+    catch {
+        return null;
+    }
+    finally {
+        rmSync(outDir, { recursive: true, force: true });
+    }
+}
+// ─── Internal ────────────────────────────────────────────
+let cachedAvailability;
+async function detectAvailability() {
+    const [hasPackage, hasJava] = await Promise.all([checkPackage(), checkJava()]);
+    return hasPackage && hasJava;
+}
+async function checkPackage() {
+    try {
+        await import("@opendataloader/pdf");
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+// execFile is safe — arguments are passed as an array, no shell interpolation.
+async function checkJava() {
+    return new Promise((resolve) => {
+        execFile("java", ["-version"], (error) => {
+            resolve(!error);
+        });
+    });
+}
+/**
+ * Detailed availability check for the `dep check` command.
+ */
+export async function checkOpendataLoaderStatus() {
+    const [packageInstalled, javaResult] = await Promise.all([checkPackage(), getJavaVersion()]);
+    return {
+        packageInstalled,
+        javaAvailable: javaResult !== null,
+        javaVersion: javaResult,
+    };
+}
+// execFile is safe — arguments are passed as an array, no shell interpolation.
+function getJavaVersion() {
+    return new Promise((resolve) => {
+        execFile("java", ["-version"], (error, _stdout, stderr) => {
+            if (error) {
+                resolve(null);
+                return;
+            }
+            // Java prints version to stderr
+            const match = /version\s+"([^"]+)"/.exec(stderr);
+            resolve(match?.[1] ?? null);
+        });
+    });
+}

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

@@ -2,6 +2,7 @@
 import { createRequire } from "node:module";
 import { Command } from "commander";
 import { createConfigCommand } from "./commands/config.js";
+import { createDepCommand } from "./commands/dep.js";
 import { createKnowledgeBaseCommand } from "./commands/knowledge-base.js";
 import { createLiteratureCommand } from "./commands/literature.js";
 import { createUtilCommand } from "./commands/util.js";
@@ -14,8 +15,8 @@ program.hook("preAction", () => {
     startup();
 });
 program.addCommand(createConfigCommand());
+program.addCommand(createDepCommand());
 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