hf-papers-mcp 1.0.0 → 1.1.0

package/README.md

@@ -2,41 +2,40 @@
   <img src="./assets/header.svg" alt="hf-papers-mcp — Hugging Face Papers, inside your assistant" width="100%">
 </p>
 
+<p align="center"><a href="https://github.com/QEbellavita/hf-papers-mcp/actions/workflows/test.yml"><img src="https://github.com/QEbellavita/hf-papers-mcp/actions/workflows/test.yml/badge.svg" alt="tests"></a></p>
+
 An MCP server that lets your assistant read Hugging Face Papers — search them, pull the
 daily curated list, fetch metadata, and generate citations.
 
 Ask *"what shipped on speculative decoding this week?"* and get real papers with upvote
 counts and abstracts, instead of whatever was in the model's training data.
 
-## Install
+![Demo: daily papers, keyword search, and BibTeX citation over MCP](assets/demo.gif)
 
-Clone it, then point your MCP client (Claude Desktop, Claude Code, or any MCP host) at
-`server.js`:
+*(Recorded with [vhs](https://github.com/charmbracelet/vhs) via `vhs demo.tape` — the
+session runs `bin/demo.js`, a real MCP client against the live API.)*
 
-```bash
-git clone https://github.com/QEbellavita/hf-papers-mcp
-```
+## Install
+
+Point your MCP client (Claude Desktop, Claude Code, or any MCP host) at it:
 
 ```json
 {
   "mcpServers": {
     "hf-papers": {
-      "command": "node",
-      "args": ["/absolute/path/to/hf-papers-mcp/server.js"]
+      "command": "npx",
+      "args": ["-y", "hf-papers-mcp"]
     }
   }
 }
 ```
 
-Not on npm — use the clone above rather than `npx hf-papers-mcp`.
-
-**Requires [uv](https://github.com/astral-sh/uv).** The Python side declares its
-dependencies inline (PEP 723), so `uv run` resolves them on first call — no virtualenv to
-create or `pip install` to remember. Without uv it falls back to bare `python3`, which
-lacks `huggingface_hub` and will return degraded results rather than pretending
-everything is fine.
+Or from source: `git clone https://github.com/QEbellavita/hf-papers-mcp` and point
+`command: node, args: [/absolute/path/to/hf-papers-mcp/server.js]` at the checkout.
 
-No API key needed for reads. Set `HF_TOKEN` only if you want `link` or `claim`.
+Pure Node (>= 18), one dependency (`@modelcontextprotocol/sdk`), no Python. No API key
+needed — everything is a public read. If `HF_TOKEN` is set (or you're logged in via
+`hf auth login`), it's sent along, which helps with rate limits.
 
 ## Tools
 
@@ -85,9 +84,20 @@ the JSON stream and silently degrade structured responses into raw strings.
 
 ## Notes
 
-Everything runs as a fresh subprocess per call — no daemon, no cached state, nothing
-persisted beyond the optional `bin/daily.js` run marker. Diagnostics go to stderr, since
-stdout is the MCP transport and anything else written there breaks the protocol.
+Every call is a direct HTTPS request to the public Hugging Face / arXiv APIs — no
+daemon, no cached state, nothing persisted beyond the optional `bin/daily.js` run
+marker. Diagnostics go to stderr, since stdout is the MCP transport and anything else
+written there breaks the protocol.
+
+Earlier versions shelled out to a Python sidecar (`scripts/paper_manager.py` via `uv`);
+v1.1.0 ported the six exposed operations to native Node, so cold-start latency dropped
+from ~12s to nothing and the uv/Python requirement is gone.
+
+## Citing
+
+If this server is useful in your research workflow, cite it via the repo's
+[CITATION.cff](CITATION.cff) (GitHub's "Cite this repository" button), or the
+Zenodo DOI once archived.
 
 ## Licence
 

package/bin/demo.js

@@ -0,0 +1,54 @@
+#!/usr/bin/env node
+'use strict';
+
+// Minimal example MCP client: spawns the server over stdio, calls three tools,
+// pretty-prints the results. Used to record the README demo GIF, and useful as
+// a smoke test / starting point for writing your own client.
+
+const path = require('path');
+const { Client } = require('@modelcontextprotocol/sdk/client/index.js');
+const { StdioClientTransport } = require('@modelcontextprotocol/sdk/client/stdio.js');
+
+const ROOT = path.resolve(__dirname, '..');
+const dim = (s) => `\x1b[2m${s}\x1b[0m`;
+const bold = (s) => `\x1b[1m${s}\x1b[0m`;
+const cyan = (s) => `\x1b[36m${s}\x1b[0m`;
+const yellow = (s) => `\x1b[33m${s}\x1b[0m`;
+
+async function call(client, name, args) {
+  console.log(`\n${cyan('▸')} ${bold(name)} ${dim(JSON.stringify(args))}`);
+  const res = await client.callTool({ name, arguments: args });
+  return JSON.parse(res.content[0].text);
+}
+
+(async () => {
+  const transport = new StdioClientTransport({
+    command: process.execPath,
+    args: [path.join(ROOT, 'server.js')],
+    cwd: ROOT,
+  });
+  const client = new Client({ name: 'demo', version: '1.0.0' }, { capabilities: {} });
+  await client.connect(transport);
+
+  const { tools } = await client.listTools();
+  console.log(`${bold('hf-papers-mcp')} ${dim('—')} ${tools.length} tools: ${dim(tools.map((t) => t.name.replace('hf_papers_', '')).join(', '))}`);
+
+  const daily = await call(client, 'hf_papers_daily', { limit: 3 });
+  for (const p of daily) {
+    console.log(`  ${yellow(`▲ ${String(p.upvotes).padStart(3)}`)}  ${p.title}`);
+    console.log(`         ${dim(p.url)}`);
+  }
+
+  const found = await call(client, 'hf_papers_search', { query: 'speculative decoding', limit: 3 });
+  for (const p of found) {
+    console.log(`  ${yellow(`▲ ${String(p.upvotes).padStart(3)}`)}  ${p.title}`);
+  }
+
+  const cite = await call(client, 'hf_papers_citation', { arxiv_id: '1706.03762', format: 'bibtex' });
+  console.log(cite.result.split('\n').map((l) => `  ${l}`).join('\n'));
+
+  await client.close();
+})().catch((err) => {
+  console.error('demo failed:', err.message);
+  process.exit(1);
+});

package/package.json

@@ -1,22 +1,15 @@
 {
   "name": "hf-papers-mcp",
-  "version": "1.0.0",
-  "description": "MCP server for Hugging Face papers \u2014 search, daily digests, metadata, citations, and indexing",
+  "version": "1.1.0",
+  "description": "MCP server for Hugging Face papers — search, daily digests, metadata, citations, and indexing. Pure Node, no Python required.",
   "license": "MIT",
   "type": "commonjs",
   "main": "server.js",
-  "bin": {
-    "hf-papers-mcp": "server.js"
-  },
-  "files": [
-    "server.js",
-    "src/",
-    "scripts/",
-    "bin/"
-  ],
+  "bin": { "hf-papers-mcp": "server.js" },
+  "files": ["server.js", "src/", "bin/"],
   "scripts": {
     "start": "node server.js",
-    "test": "node --test \"test/**/*.test.js\"",
+    "test": "node --test",
     "daily": "node bin/daily.js",
     "prepublishOnly": "npm test"
   },

package/server.js

@@ -3,9 +3,8 @@
 
 // Standalone MCP server exposing the Hugging Face papers tools over stdio.
 //
-// The tool definitions live in src/papers.js, which shells out to
-// scripts/paper_manager.py. Nothing here holds state: every call is a fresh
-// subprocess against the public Hugging Face API.
+// The tool definitions live in src/papers.js; src/hf.js talks to the public
+// Hugging Face / arXiv APIs directly over fetch. Nothing here holds state.
 
 const { Server } = require('@modelcontextprotocol/sdk/server/index.js');
 const { StdioServerTransport } = require('@modelcontextprotocol/sdk/server/stdio.js');

package/src/hf.js

@@ -0,0 +1,322 @@
+'use strict';
+
+// Native port of scripts/paper_manager.py — the six operations the MCP server
+// exposes, reimplemented on global fetch (node >= 18) so the server has no
+// Python/uv dependency and no per-call subprocess.
+//
+// Contract notes preserved from the Python side:
+//  - daily() with a bad date returns [ { error } ] (an array), matching the CLI.
+//  - check() with a bad arXiv id returns { exists: false, error }.
+//  - citation() returns a raw string; the tool handler wraps it as { result }.
+//  - Text pulled from arXiv/HF is sanitized before it can reach Markdown/YAML.
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const HF_API_BASE = 'https://huggingface.co/api';
+const TIMEOUT_MS = 15_000;
+
+const ARXIV_ID_MODERN = /^\d{4}\.\d{4,5}(v\d+)?$/;
+const ARXIV_ID_LEGACY = /^[a-zA-Z-]+\/\d{7}(v\d+)?$/;
+
+// ------------------------------------------------------------------
+// Pure helpers (unit-tested offline)
+// ------------------------------------------------------------------
+
+function cleanArxivId(raw) {
+  let id = String(raw ?? '').trim();
+  id = id.replace(/^arxiv:/i, '');
+  id = id.replace(/^https?:\/\/arxiv\.org\/(abs|pdf)\//, '');
+  id = id.replace(/\.pdf$/, '');
+  if (!ARXIV_ID_MODERN.test(id) && !ARXIV_ID_LEGACY.test(id)) {
+    throw new Error(
+      `Invalid arXiv ID: ${JSON.stringify(String(raw))}. ` +
+      'Expected format: YYMM.NNNNN[vN] or category/YYMMNNN[vN]'
+    );
+  }
+  return id;
+}
+
+function sanitizeText(text) {
+  let out = String(text);
+  out = out.replace(/[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]/g, '');
+  out = out.replace(/[^\S\n]+/g, ' ');
+  out = out.replace(/\n{3,}/g, '\n\n');
+  out = out.replace(/```/g, '\\`\\`\\`');
+  out = out.replace(/^---/gm, '\\---');
+  return out.trim();
+}
+
+function decodeXmlEntities(text) {
+  return String(text)
+    .replace(/&lt;/g, '<')
+    .replace(/&gt;/g, '>')
+    .replace(/&quot;/g, '"')
+    .replace(/&#39;|&apos;/g, "'")
+    .replace(/&amp;/g, '&');
+}
+
+// arXiv's Atom feed is flat and small; targeted regexes match the Python port's
+// approach and avoid an XML-parser dependency.
+function parseArxivAtom(xml, arxivId) {
+  // First <title> is the feed's own title — the paper title is the second.
+  const titles = [...xml.matchAll(/<title>([\s\S]*?)<\/title>/g)].map((m) => m[1]);
+  const authors = [...xml.matchAll(/<name>([\s\S]*?)<\/name>/g)].map((m) => m[1]);
+  const summary = /<summary>([\s\S]*?)<\/summary>/.exec(xml);
+
+  const rawTitle = titles.length > 1 ? titles[1].trim() : null;
+  const rawAbstract = summary ? summary[1].trim() : null;
+
+  return {
+    arxiv_id: arxivId,
+    title: rawTitle ? sanitizeText(decodeXmlEntities(rawTitle)) : null,
+    authors: authors.map((a) => sanitizeText(decodeXmlEntities(a))),
+    abstract: rawAbstract ? sanitizeText(decodeXmlEntities(rawAbstract)) : null,
+    arxiv_url: `https://arxiv.org/abs/${arxivId}`,
+    pdf_url: `https://arxiv.org/pdf/${arxivId}.pdf`,
+  };
+}
+
+function arxivYear(arxivId) {
+  // Modern ids embed YYMM; legacy ids (cs/0701001) embed YY after the slash.
+  const numeric = arxivId.includes('/') ? arxivId.split('/')[1] : arxivId;
+  const yy = parseInt(numeric.slice(0, 2), 10);
+  if (Number.isNaN(yy)) return null;
+  return yy < 50 ? `20${String(yy).padStart(2, '0')}` : `19${yy}`;
+}
+
+function formatCitation(info, fmt = 'bibtex') {
+  const authors = info.authors && info.authors.length ? info.authors : ['Unknown'];
+  const title = info.title || 'Untitled';
+  const arxivId = info.arxiv_id;
+  const year = arxivYear(arxivId) || 'n.d.';
+
+  if (fmt === 'bibtex') {
+    const key = `arxiv${arxivId.replace(/[./]/g, '_')}`;
+    const escape = (s) => s.replace(/\{/g, '\\{').replace(/\}/g, '\\}');
+    return (
+      `@article{${key},\n` +
+      `  title={${escape(title)}},\n` +
+      `  author={${escape(authors.join(' and '))}},\n` +
+      `  journal={arXiv preprint arXiv:${arxivId}},\n` +
+      `  year={${year}}\n` +
+      `}`
+    );
+  }
+
+  if (fmt === 'apa') {
+    let authorStr;
+    if (authors.length > 7) {
+      authorStr = `${authors.slice(0, 6).join(', ')}, ... ${authors[authors.length - 1]}`;
+    } else if (authors.length > 1) {
+      authorStr = `${authors.slice(0, -1).join(', ')}, & ${authors[authors.length - 1]}`;
+    } else {
+      authorStr = authors[0];
+    }
+    return `${authorStr} (${year}). ${title}. arXiv preprint arXiv:${arxivId}.`;
+  }
+
+  if (fmt === 'mla') {
+    let authorStr;
+    if (authors.length > 2) authorStr = `${authors[0]}, et al.`;
+    else if (authors.length === 2) authorStr = `${authors[0]}, and ${authors[1]}`;
+    else authorStr = authors[0];
+    // The Python port appended "." unconditionally, yielding "et al.." — don't.
+    const sep = authorStr.endsWith('.') ? '' : '.';
+    return `${authorStr}${sep} "${title}." arXiv preprint arXiv:${arxivId} (${year}).`;
+  }
+
+  return `Format '${fmt}' not supported. Use bibtex, apa, or mla.`;
+}
+
+function mapSearchEntry(entry) {
+  const paper = entry.paper || entry;
+  return {
+    arxiv_id: paper.id,
+    title: paper.title,
+    upvotes: paper.upvotes || 0,
+    summary: String(paper.ai_summary || paper.summary || '').slice(0, 200),
+    authors: (paper.authors || []).map((a) => a.name).slice(0, 5),
+    url: `https://huggingface.co/papers/${paper.id}`,
+  };
+}
+
+function mapDailyEntry(entry) {
+  const paper = entry.paper || entry;
+  return {
+    arxiv_id: paper.id,
+    title: paper.title || entry.title,
+    upvotes: paper.upvotes || 0,
+    summary: String(paper.ai_summary || paper.summary || '').slice(0, 200),
+    num_comments: entry.numComments || 0,
+    submitted_by: (entry.submittedBy || {}).name ?? null,
+    url: `https://huggingface.co/papers/${paper.id}`,
+  };
+}
+
+// ------------------------------------------------------------------
+// Auth + fetch
+// ------------------------------------------------------------------
+
+function readToken() {
+  if (process.env.HF_TOKEN) return process.env.HF_TOKEN;
+  // Same fallback huggingface_hub's get_token() uses.
+  const candidates = [
+    process.env.HF_TOKEN_PATH,
+    path.join(process.env.HF_HOME || path.join(os.homedir(), '.cache', 'huggingface'), 'token'),
+  ].filter(Boolean);
+  for (const file of candidates) {
+    try {
+      const token = fs.readFileSync(file, 'utf8').trim();
+      if (token) return token;
+    } catch { /* not logged in — reads work anonymously */ }
+  }
+  return null;
+}
+
+async function fetchJson(url, params) {
+  const target = new URL(url);
+  for (const [k, v] of Object.entries(params || {})) {
+    if (v !== undefined && v !== null) target.searchParams.set(k, String(v));
+  }
+  const headers = {};
+  const token = readToken();
+  if (token) headers.Authorization = `Bearer ${token}`;
+  const resp = await fetch(target, { headers, signal: AbortSignal.timeout(TIMEOUT_MS) });
+  return resp;
+}
+
+// ------------------------------------------------------------------
+// Operations (one per MCP tool)
+// ------------------------------------------------------------------
+
+async function getPaper(arxivId) {
+  const resp = await fetchJson(`${HF_API_BASE}/papers/${arxivId}`);
+  if (resp.status === 404) {
+    return { error: 'not_found', message: `Paper ${arxivId} not indexed on HF` };
+  }
+  if (!resp.ok) throw new Error(`HF API ${resp.status} for papers/${arxivId}`);
+  return resp.json();
+}
+
+async function searchPapers(query, limit = 20) {
+  const resp = await fetchJson(`${HF_API_BASE}/papers/search`, { q: query });
+  if (!resp.ok) throw new Error(`HF API ${resp.status} for papers/search`);
+  const papers = await resp.json();
+  return papers.slice(0, limit).map(mapSearchEntry);
+}
+
+async function dailyPapers(dateStr, limit = 30) {
+  const params = {};
+  if (dateStr) {
+    // Round-trip check: Date rolls calendar-invalid dates (2026-02-30) over
+    // instead of rejecting them, unlike Python's strptime.
+    const parsed = new Date(`${dateStr}T00:00:00Z`);
+    if (
+      !/^\d{4}-\d{2}-\d{2}$/.test(dateStr) ||
+      Number.isNaN(parsed.getTime()) ||
+      parsed.toISOString().slice(0, 10) !== dateStr
+    ) {
+      return [{ error: `Invalid date format: ${dateStr}. Use YYYY-MM-DD` }];
+    }
+    params.date = dateStr;
+  }
+  const resp = await fetchJson(`${HF_API_BASE}/daily_papers`, params);
+  if (!resp.ok) throw new Error(`HF API ${resp.status} for daily_papers`);
+  const papers = await resp.json();
+  return papers.slice(0, limit).map(mapDailyEntry);
+}
+
+async function checkPaper(rawId) {
+  let arxivId;
+  try {
+    arxivId = cleanArxivId(rawId);
+  } catch (err) {
+    return { exists: false, error: err.message };
+  }
+  const data = await getPaper(arxivId);
+  if (data.error) {
+    return {
+      exists: false,
+      arxiv_id: arxivId,
+      index_url: `https://huggingface.co/papers/${arxivId}`,
+      message: 'Visit the URL to index this paper',
+    };
+  }
+  return {
+    exists: true,
+    arxiv_id: arxivId,
+    title: data.title,
+    upvotes: data.upvotes || 0,
+    authors: (data.authors || []).map((a) => a.name),
+    url: `https://huggingface.co/papers/${arxivId}`,
+    arxiv_url: `https://arxiv.org/abs/${arxivId}`,
+  };
+}
+
+async function indexPaper(rawId) {
+  let arxivId;
+  try {
+    arxivId = cleanArxivId(rawId);
+  } catch (err) {
+    return { status: 'error', message: err.message };
+  }
+  const paperUrl = `https://huggingface.co/papers/${arxivId}`;
+  try {
+    // GET the paper page — HF indexes on first visit.
+    const resp = await fetch(paperUrl, { signal: AbortSignal.timeout(TIMEOUT_MS) });
+    if (resp.ok) return { status: 'indexed', url: paperUrl, arxiv_id: arxivId };
+    return { status: 'not_indexed', url: paperUrl, action: 'visit_url' };
+  } catch (err) {
+    return { status: 'error', message: err.message };
+  }
+}
+
+async function getArxivInfo(rawId) {
+  let arxivId;
+  try {
+    arxivId = cleanArxivId(rawId);
+  } catch (err) {
+    return { error: err.message };
+  }
+  try {
+    const resp = await fetch(
+      `https://export.arxiv.org/api/query?id_list=${encodeURIComponent(arxivId)}`,
+      { signal: AbortSignal.timeout(TIMEOUT_MS) }
+    );
+    if (!resp.ok) throw new Error(`arXiv API ${resp.status}`);
+    return parseArxivAtom(await resp.text(), arxivId);
+  } catch (err) {
+    return { error: err.message };
+  }
+}
+
+async function generateCitation(rawId, fmt = 'bibtex') {
+  let arxivId;
+  try {
+    arxivId = cleanArxivId(rawId);
+  } catch (err) {
+    return `Error: ${err.message}`;
+  }
+  const info = await getArxivInfo(arxivId);
+  if (info.error) return `Error fetching paper info: ${info.error}`;
+  return formatCitation(info, fmt);
+}
+
+module.exports = {
+  // operations
+  searchPapers,
+  dailyPapers,
+  checkPaper,
+  indexPaper,
+  getArxivInfo,
+  generateCitation,
+  // pure helpers, exported for tests
+  cleanArxivId,
+  sanitizeText,
+  parseArxivAtom,
+  formatCitation,
+  mapSearchEntry,
+  mapDailyEntry,
+};

package/src/papers.js

@@ -1,66 +1,16 @@
 'use strict';
 
-const { execFile } = require('child_process');
-const path = require('path');
+const hf = require('./hf.js');
 
-const SCRIPT = path.resolve(__dirname, '..', 'scripts', 'paper_manager.py');
-// A warm `uv run` already takes ~12.5s; the first (cold) call also resolves the
-// PEP 723 dependency set, which can take far longer. The old 15s budget timed
-// out on cold starts and silently degraded to a depless python3 — so allow real
-// headroom here.
-const TIMEOUT_MS = 60_000;
-
-/**
- * Shell out to paper_manager.py and return parsed JSON.
- * Prefers `uv run` (auto-resolves PEP 723 deps). Falls back to `python3` ONLY
- * when uv is genuinely absent — a uv timeout or runtime failure is surfaced
- * rather than masked, because python3 here lacks huggingface_hub and would
- * return misleading/empty data.
- *
- * IMPORTANT: --json must come BEFORE the subcommand (argparse global flag).
- */
-function runPaperManager(args) {
-  return new Promise((resolve) => {
-    const tryRun = (cmd, cmdArgs) => {
-      execFile(cmd, cmdArgs, {
-        timeout: TIMEOUT_MS,
-        maxBuffer: 1024 * 1024,
-      }, (err, stdout, stderr) => {
-        if (err && cmd === 'uv' && err.code === 'ENOENT') {
-          // uv binary not installed — fall back to python3
-          tryRun('python3', [SCRIPT, '--json', ...args]);
-          return;
-        }
-        if (err) {
-          // Surface real failures (timeout, runtime error) instead of degrading.
-          const reason = err.killed ? `timed out after ${TIMEOUT_MS}ms` : err.message;
-          resolve({ error: reason, stderr: stderr?.trim() || '' });
-          return;
-        }
-        // The python3 path has no huggingface_hub, so anything it does return is
-        // partial. Label it rather than let it read as a complete answer.
-        const degraded = cmd === 'python3'
-          ? { degraded: 'uv not installed; ran bare python3 without huggingface_hub — results may be incomplete' }
-          : {};
-        try {
-          const parsed = JSON.parse(stdout);
-          // search/daily/index return arrays. Object-spreading an array yields
-          // {0:…,1:…}, so the caller receives a map keyed by index instead of a
-          // list. Keep arrays intact; only wrap when there is a label to attach.
-          if (Array.isArray(parsed)) {
-            resolve(degraded.degraded ? { results: parsed, ...degraded } : parsed);
-            return;
-          }
-          resolve({ ...parsed, ...degraded });
-        } catch {
-          // Output wasn't JSON — return raw text (e.g., citation command)
-          resolve({ result: stdout.trim(), ...degraded });
-        }
-      });
-    };
-    // Try uv first (auto-resolves PEP 723 dependencies), then python3
-    tryRun('uv', ['run', SCRIPT, '--json', ...args]);
-  });
+// Handlers resolve to { error } instead of rejecting, matching the contract of
+// the old Python-subprocess bridge: callers always get JSON, never an MCP-level
+// exception, for expected failures (network down, bad id, API error).
+async function safely(op) {
+  try {
+    return await op();
+  } catch (err) {
+    return { error: err.message };
+  }
 }
 
 module.exports = {
@@ -84,9 +34,7 @@ module.exports = {
             required: ['query'],
           },
         },
-        handler: async (args) => {
-          return runPaperManager(['search', '--query', args.query, '--limit', String(args.limit || 10)]);
-        },
+        handler: (args) => safely(() => hf.searchPapers(args.query, args.limit || 10)),
       },
       {
         def: {
@@ -100,11 +48,7 @@ module.exports = {
             },
           },
         },
-        handler: async (args) => {
-          const cmdArgs = ['daily', '--limit', String(args.limit || 15)];
-          if (args.date) cmdArgs.push('--date', args.date);
-          return runPaperManager(cmdArgs);
-        },
+        handler: (args) => safely(() => hf.dailyPapers(args.date, args.limit || 15)),
       },
       {
         def: {
@@ -118,9 +62,7 @@ module.exports = {
             required: ['arxiv_id'],
           },
         },
-        handler: async (args) => {
-          return runPaperManager(['info', '--arxiv-id', args.arxiv_id]);
-        },
+        handler: (args) => safely(() => hf.getArxivInfo(args.arxiv_id)),
       },
       {
         def: {
@@ -135,9 +77,9 @@ module.exports = {
             required: ['arxiv_id'],
           },
         },
-        handler: async (args) => {
-          return runPaperManager(['citation', '--arxiv-id', args.arxiv_id, '--format', args.format || 'bibtex']);
-        },
+        handler: (args) => safely(async () => ({
+          result: await hf.generateCitation(args.arxiv_id, args.format || 'bibtex'),
+        })),
       },
       {
         def: {
@@ -151,9 +93,7 @@ module.exports = {
             required: ['arxiv_id'],
           },
         },
-        handler: async (args) => {
-          return runPaperManager(['check', '--arxiv-id', args.arxiv_id]);
-        },
+        handler: (args) => safely(() => hf.checkPaper(args.arxiv_id)),
       },
       {
         def: {
@@ -167,9 +107,7 @@ module.exports = {
             required: ['arxiv_id'],
           },
         },
-        handler: async (args) => {
-          return runPaperManager(['index', '--arxiv-id', args.arxiv_id]);
-        },
+        handler: (args) => safely(() => hf.indexPaper(args.arxiv_id)),
       },
     ];
   },