paper-manager 0.9.0 → 0.10.0

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/literature.js

@@ -9,6 +9,7 @@ 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 { splitDocuments } from "../text-splitter.js";
 import { addDocuments, createVectorStore } from "../vector-store/index.js";
@@ -94,6 +95,14 @@ 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 splitDocs = splitDocuments(docs, { chunkSize: 1000, chunkOverlap: 200 });
@@ -129,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>")
@@ -226,11 +269,14 @@ export function createLiteratureCommand() {
             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();
         }
@@ -313,7 +359,8 @@ export function createLiteratureCommand() {
             log.plain(JSON.stringify(literature, null, 2));
             return;
         }
-        printLiterature(literature);
+        const filesDir = getFilesDir(getBaseDir(resolved.scope));
+        printLiterature(literature, filesDir);
     });
     // ─── lit note ──────────────────────────────────────────────
     const note = lit.command("note").description("Manage literature notes");
@@ -386,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)
@@ -405,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);

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/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,6 +15,7 @@ program.hook("preAction", () => {
     startup();
 });
 program.addCommand(createConfigCommand());
+program.addCommand(createDepCommand());
 program.addCommand(createKnowledgeBaseCommand());
 program.addCommand(createLiteratureCommand());
 program.addCommand(createUtilCommand());

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "paper-manager",
-  "version": "0.9.0",
+  "version": "0.10.0",
   "description": "A paper management system.",
   "keywords": [],
   "homepage": "https://github.com/EurFelux/paper-manager",
@@ -46,6 +46,9 @@
     "typescript": "^5.9.3",
     "vitest": "^4.0.18"
   },
+  "optionalDependencies": {
+    "@opendataloader/pdf": "^2.2.1"
+  },
   "engines": {
     "node": ">=24"
   },