dsh-scholar-desk 0.1.0

package/dist/domain.js

@@ -0,0 +1,163 @@
+import { CARD_CATEGORIES, CARD_STATUSES } from './shared/types.js';
+import { newCardId, paperIdFor } from './store.js';
+import { parseArxivId } from './metadata.js';
+/**
+ * 归一化 arXiv id 变体（裸 id 带 v2 / arXiv: 前缀 / abs、pdf 链接 → 裸 id），
+ * 消掉同一论文因写法不同分裂成两条的去重漏洞；非 arXiv 形态原样返回。
+ */
+export function normalizeArxivId(input) {
+    const s = input?.trim();
+    if (!s)
+        return input;
+    return parseArxivId(s) ?? input;
+}
+/** Build a new Paper (id from arXiv id or title slug, timestamps filled). */
+export function createPaper(input, now = Date.now()) {
+    const title = (input.title ?? '').trim();
+    if (!title)
+        throw new Error('论文标题不能为空');
+    const tags = [...new Set((input.tags ?? []).map((t) => t.trim()).filter(Boolean))];
+    return {
+        id: paperIdFor(title, normalizeArxivId(input.arxivId)),
+        title,
+        authors: [...(input.authors ?? [])],
+        year: input.year,
+        venue: input.venue?.trim() || undefined,
+        arxivId: normalizeArxivId(input.arxivId)?.trim() || undefined,
+        doi: input.doi?.trim() || undefined,
+        url: input.url?.trim() || undefined,
+        abstract: input.abstract,
+        summary: input.summary,
+        tags,
+        importance: input.importance,
+        source: input.source,
+        notes: input.notes,
+        collectionIds: input.collectionIds?.length ? [...new Set(input.collectionIds)] : undefined,
+        createdAt: now,
+        updatedAt: now,
+    };
+}
+/** Merge only the provided fields onto an existing paper. */
+export function applyPaperPatch(existing, patch, now = Date.now()) {
+    const next = { ...existing, updatedAt: now };
+    if (patch.title !== undefined)
+        next.title = patch.title.trim();
+    if (patch.authors !== undefined)
+        next.authors = [...patch.authors];
+    if (patch.year !== undefined)
+        next.year = patch.year;
+    if (patch.venue !== undefined)
+        next.venue = patch.venue.trim() || undefined;
+    if (patch.arxivId !== undefined)
+        next.arxivId = normalizeArxivId(patch.arxivId)?.trim() || undefined;
+    if (patch.doi !== undefined)
+        next.doi = patch.doi.trim() || undefined;
+    if (patch.url !== undefined)
+        next.url = patch.url.trim() || undefined;
+    if (patch.abstract !== undefined)
+        next.abstract = patch.abstract;
+    if (patch.summary !== undefined)
+        next.summary = patch.summary;
+    if (patch.tags !== undefined)
+        next.tags = [...new Set(patch.tags.map((t) => t.trim()).filter(Boolean))];
+    if (patch.importance !== undefined)
+        next.importance = patch.importance;
+    if (patch.notes !== undefined)
+        next.notes = patch.notes;
+    if (patch.collectionIds !== undefined) {
+        const ids = [...new Set(patch.collectionIds.filter((x) => typeof x === 'string' && !!x))];
+        if (ids.length === 0)
+            delete next.collectionIds;
+        else
+            next.collectionIds = ids;
+    }
+    if (!next.title)
+        throw new Error('论文标题不能为空');
+    return next;
+}
+/** First duplicate hit by arXiv id (normalized), DOI, or normalized title. */
+export function findDuplicate(papers, patch) {
+    const titleKey = patch.title?.trim().toLowerCase();
+    const arxiv = normalizeArxivId(patch.arxivId)?.trim().toLowerCase();
+    const doi = patch.doi?.trim().toLowerCase();
+    for (const p of papers) {
+        if (arxiv && p.arxivId && p.arxivId.toLowerCase() === arxiv)
+            return p;
+        if (doi && p.doi && p.doi.toLowerCase() === doi)
+            return p;
+        if (titleKey && p.title.trim().toLowerCase() === titleKey)
+            return p;
+    }
+    return undefined;
+}
+function normalizeSteps(steps) {
+    if (!Array.isArray(steps))
+        return [];
+    return steps.map((x) => String(x).trim()).filter(Boolean);
+}
+export function createCard(input, now = Date.now()) {
+    const title = (input.title ?? '').trim();
+    const insight = (input.insight ?? '').trim();
+    if (!title)
+        throw new Error('卡片标题不能为空');
+    if (!insight)
+        throw new Error('卡片内容（创新点）不能为空');
+    const category = input.category && CARD_CATEGORIES.includes(input.category) ? input.category : 'other';
+    const status = input.status && CARD_STATUSES.includes(input.status) ? input.status : 'pending';
+    return {
+        id: newCardId(),
+        title,
+        insight,
+        paperId: input.paperId || undefined,
+        category,
+        tags: [...new Set((input.tags ?? []).map((t) => t.trim()).filter(Boolean))],
+        importance: input.importance ?? 3,
+        status,
+        notes: input.notes,
+        relatedCardIds: input.relatedCardIds?.length ? [...new Set(input.relatedCardIds)] : undefined,
+        plain: input.plain?.trim() || undefined,
+        steps: normalizeSteps(input.steps),
+        createdAt: now,
+        updatedAt: now,
+    };
+}
+export function applyCardPatch(existing, patch, now = Date.now()) {
+    const next = { ...existing, updatedAt: now };
+    if (patch.title !== undefined)
+        next.title = patch.title.trim();
+    if (patch.insight !== undefined)
+        next.insight = patch.insight.trim();
+    if (patch.paperId !== undefined)
+        next.paperId = patch.paperId || undefined;
+    if (patch.category !== undefined && CARD_CATEGORIES.includes(patch.category))
+        next.category = patch.category;
+    if (patch.tags !== undefined)
+        next.tags = [...new Set(patch.tags.map((t) => t.trim()).filter(Boolean))];
+    if (patch.importance !== undefined)
+        next.importance = patch.importance;
+    if (patch.status !== undefined && CARD_STATUSES.includes(patch.status))
+        next.status = patch.status;
+    if (patch.notes !== undefined)
+        next.notes = patch.notes;
+    if (patch.relatedCardIds !== undefined) {
+        const ids = [...new Set(patch.relatedCardIds.filter((x) => typeof x === 'string' && !!x))];
+        if (ids.length === 0)
+            delete next.relatedCardIds;
+        else
+            next.relatedCardIds = ids;
+    }
+    if (patch.plain !== undefined)
+        next.plain = patch.plain.trim() || undefined;
+    if (patch.steps !== undefined) {
+        const st = normalizeSteps(patch.steps);
+        if (st.length === 0)
+            delete next.steps;
+        else
+            next.steps = st;
+    }
+    if (!next.title)
+        throw new Error('卡片标题不能为空');
+    if (!next.insight)
+        throw new Error('卡片内容（创新点）不能为空');
+    return next;
+}

package/dist/index.js

@@ -0,0 +1,75 @@
+import z from 'schemastery';
+import { PaperStore } from './store.js';
+import { registerScholarRoutes } from './routes.js';
+import { registerScholarTools } from './tools.js';
+export const name = 'dsh-scholar';
+/** Host services this plugin waits for (settings registry, http carrier, tool registry, prompt assembly). */
+export const inject = ['settings', 'webServer', 'tools', 'systemPrompt'];
+// 0.1.5 起 dsh-settings 移除了 settingsNamespace 包装:命名空间直接以字面量传入
+const NS = 'scholar';
+function defaultPaperDir() {
+    const home = process.env.USERPROFILE ?? process.env.HOME ?? process.cwd();
+    return `${home}/Documents/ResearchPapers`;
+}
+const ScholarConfigSchema = z.object({
+    paperDir: z.string().required(),
+    defaultTags: z.array(z.string()).default([]),
+    fetchProxy: z.string().default(''),
+});
+export function apply(ctx) {
+    // 科研精读动线：把 保存 → 精读 → 沉淀 串成 agent 的默认工作方式
+    ctx.effect(() => ctx.systemPrompt.section({
+        name: 'dsh-scholar-workflow',
+        order: 151,
+        text: [
+            '科研论文动线（用户要求保存、精读、沉淀论文时严格遵守）：',
+            '1) 保存：用 paper_save 入库；参数带 arxivId 时会自动从 arXiv 下载 PDF 归档，无需手动处理；',
+            '   非 arXiv 来源会返回 pdfWarning，转告用户在论文详情页手动上传。',
+            '2) 精读：先 paper_search / paper_get 找到该论文的 pdfPath，然后用 deepread 工具读该 PDF 路径；',
+            '   科研论文默认 map 模式（每个重要主张给出证据、出处与置信度），完成后导出 html，',
+            '   并调用 paper_save_report 把报告 html 内容存回论文库。',
+            '3) 沉淀：从精读结论提取 1-3 条创新点，用 idea_card_create 建卡并标注来源论文；',
+            '   再用 paper_update 将该论文的 summary 更新为精读核心结论。',
+            '用户提到的论文尚未入库时，先 paper_save 再走上述流程。',
+        ].join('\n'),
+    }), 'dsh-scholar: workflow prompt');
+    const scope = ctx.settings.register(NS, ScholarConfigSchema, {});
+    const getConfig = () => {
+        const cfg = scope.get();
+        return {
+            paperDir: cfg?.paperDir?.trim() || defaultPaperDir(),
+            defaultTags: cfg?.defaultTags ?? [],
+            fetchProxy: cfg?.fetchProxy?.trim() || '',
+        };
+    };
+    // Lazy singleton store, re-created when the configured directory changes.
+    let storePromise = null;
+    let storeDir = '';
+    const getStore = () => {
+        const dir = getConfig().paperDir;
+        if (!storePromise || storeDir !== dir) {
+            // 目录热切换：旧 store 打 disposed 标记，在途请求的后续写操作会显式失败
+            // （而不是"写旧目录成功但新库里没有"）
+            storePromise?.then((old) => old.dispose()).catch(() => { });
+            storeDir = dir;
+            const store = new PaperStore(dir);
+            storePromise = store.init()
+                .then(() => {
+                const s = store.stats();
+                console.log(`[dsh-scholar] 论文库就绪: ${dir}（${s.papers} 篇论文 / ${s.cards} 张卡片 / 图谱 ${s.nodes} 节点 ${s.edges} 边）`);
+                return store;
+            })
+                .catch((err) => {
+                storePromise = null;
+                throw err;
+            });
+        }
+        return storePromise;
+    };
+    const updateConfig = async (patch) => {
+        await scope.update({ ...getConfig(), ...patch });
+    };
+    registerScholarRoutes(ctx, getStore, getConfig, updateConfig);
+    const toolCount = registerScholarTools(ctx, getStore, getConfig);
+    console.log(`[dsh-scholar] host half ready: settings ns + /scholar/* routes + ${toolCount} agent tools`);
+}

package/dist/metadata.js

@@ -0,0 +1,296 @@
+/**
+ * dsh-scholar — outbound paper-metadata lookup (host half).
+ *
+ * `fetchMetadata(input)` accepts an arXiv id, arXiv abs/pdf URL, DOI or
+ * doi.org URL and returns normalized paper fields. Sources: the official
+ * arXiv Atom API and api.crossref.org. Zero dependencies; when HTTPS_PROXY /
+ * HTTP_PROXY is set, requests tunnel through it via a CONNECT agent.
+ */
+import http from 'node:http';
+import https from 'node:https';
+import tls from 'node:tls';
+/** 与直连路径一致的 UA（代理路径也带上，避免被数据源按默认 UA 拦截）。 */
+const USER_AGENT = 'dsh-scholar/0.1 (paper library)';
+const MAX_TEXT_BYTES = 5 * 1024 * 1024;
+const MAX_PDF_BYTES = 50 * 1024 * 1024;
+const MAX_REDIRECTS = 5;
+/* ---------- input classification ---------- */
+const ARXIV_NEW = /^(\d{4}\.\d{4,5})(v\d+)?$/i;
+/** Try to read an arXiv id out of arbitrary user input; null if not arXiv-ish. */
+export function parseArxivId(input) {
+    const s = input.trim();
+    if (!s)
+        return null;
+    // bare new-style id (with optional version)
+    let m = ARXIV_NEW.exec(s);
+    if (m)
+        return m[1];
+    try {
+        const u = new URL(s.startsWith('http') ? s : `https://${s}`);
+        if (!/arxiv\.org$/i.test(u.hostname))
+            return null;
+        m = /\/abs\/([^/?#]+)/i.exec(u.pathname) ?? /\/pdf\/([^/?#]+?)(?:\.pdf)?$/i.exec(u.pathname);
+        if (!m)
+            return null;
+        const raw = decodeURIComponent(m[1]).replace(/^arxiv:/i, '');
+        const n = ARXIV_NEW.exec(raw);
+        return n ? n[1] : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Read a bare or doi.org-wrapped DOI; null if not DOI-ish. */
+export function parseDoi(input) {
+    let s = input.trim();
+    if (!s)
+        return null;
+    s = s.replace(/^https?:\/\/(dx\.)?doi\.org\//i, '');
+    if (/^10\.\d{4,9}\/\S+$/.test(s))
+        return s;
+    return null;
+}
+/* ---------- proxy-aware https helpers ---------- */
+const proxyUrl = () => process.env.HTTPS_PROXY ?? process.env.https_proxy ?? process.env.HTTP_PROXY ?? process.env.http_proxy;
+/** 代理 URL 带用户名/密码时生成 Proxy-Authorization 头（Basic）。 */
+function proxyAuthHeader(pu) {
+    if (!pu.username && !pu.password)
+        return {};
+    const cred = `${decodeURIComponent(pu.username)}:${decodeURIComponent(pu.password)}`;
+    return { 'proxy-authorization': `Basic ${Buffer.from(cred).toString('base64')}` };
+}
+/** 经代理建立 CONNECT 隧道（带超时，无响应即销毁而不是永久挂起）。 */
+function connectViaProxy(pu, targetHost, timeoutMs) {
+    return new Promise((resolve, reject) => {
+        const setup = http.request({
+            host: pu.hostname,
+            port: Number(pu.port || 443),
+            method: 'CONNECT',
+            path: `${targetHost}:443`,
+            headers: {
+                host: `${targetHost}:443`,
+                ...proxyAuthHeader(pu),
+            },
+        });
+        setup.setTimeout(timeoutMs, () => setup.destroy(new Error('代理 CONNECT 超时')));
+        setup.once('connect', (res, socket) => {
+            if (res.statusCode !== 200) {
+                socket.destroy();
+                reject(new Error(`代理 CONNECT 失败 (${res.statusCode})`));
+                return;
+            }
+            resolve(socket);
+        });
+        setup.once('error', reject);
+        setup.end();
+    });
+}
+/** 在已建立的隧道上发一次 GET（不跟重定向），响应体流式累计、超限即断开。 */
+function tunneledGetOnce(u, socket, timeoutMs, accept, maxBytes) {
+    return new Promise((resolve, reject) => {
+        const req = https.request({
+            hostname: u.hostname,
+            path: `${u.pathname}${u.search}`,
+            method: 'GET',
+            headers: { host: u.host, accept, 'user-agent': USER_AGENT },
+            signal: AbortSignal.timeout(timeoutMs),
+            createConnection: () => tls.connect({ socket, servername: u.hostname }),
+        }, (r) => {
+            const chunks = [];
+            let total = 0;
+            r.on('data', (c) => {
+                total += c.length;
+                if (total > maxBytes) {
+                    req.destroy(); // 超限立刻断流，而不是全量入内存后再检查
+                    reject(new Error(`响应体超过大小上限（${Math.floor(maxBytes / 1024 / 1024)}MB）`));
+                    return;
+                }
+                chunks.push(c);
+            });
+            r.on('end', () => resolve({
+                status: r.statusCode ?? 500,
+                location: typeof r.headers.location === 'string' ? r.headers.location : undefined,
+                body: Buffer.concat(chunks),
+            }));
+        });
+        req.once('error', reject);
+        req.end();
+    });
+}
+/**
+ * 代理路径 GET（CONNECT 隧道 + 手动跟随 3xx，≤5 跳）。我们只发 GET，
+ * 301/302/303 的"改写为 GET"语义天然满足；每跳重建隧道以支持跨 host 重定向。
+ */
+async function proxyGet(url, timeoutMs, proxy, accept, maxBytes) {
+    let current = new URL(url);
+    if (current.protocol !== 'https:')
+        throw new Error('仅支持 https 数据源');
+    const pu = new URL(proxy);
+    for (let hop = 0; hop <= MAX_REDIRECTS; hop++) {
+        const socket = await connectViaProxy(pu, current.host, timeoutMs);
+        let res;
+        try {
+            res = await tunneledGetOnce(current, socket, timeoutMs, accept, maxBytes);
+        }
+        catch (err) {
+            socket.destroy();
+            throw err;
+        }
+        socket.destroy();
+        if (res.status >= 300 && res.status < 400 && res.location) {
+            if (hop === MAX_REDIRECTS)
+                throw new Error(`重定向超过 ${MAX_REDIRECTS} 跳`);
+            const next = new URL(res.location, current);
+            if (next.protocol !== 'https:')
+                throw new Error('重定向目标不是 https，已停止跟随');
+            current = next;
+            continue;
+        }
+        if (res.status >= 400)
+            throw new Error(`HTTP ${res.status}`);
+        return res.body;
+    }
+    throw new Error(`重定向超过 ${MAX_REDIRECTS} 跳`);
+}
+/** 直连 fetch 的流式读取 + 大小上限（与代理路径同语义，超限即取消下载）。 */
+async function fetchBodyWithLimit(res, maxBytes) {
+    const reader = res.body?.getReader();
+    if (!reader)
+        return Buffer.from(await res.arrayBuffer());
+    const chunks = [];
+    let total = 0;
+    for (;;) {
+        const { done, value } = await reader.read();
+        if (done)
+            break;
+        total += value.byteLength;
+        if (total > maxBytes) {
+            await reader.cancel().catch(() => { });
+            throw new Error(`响应体超过大小上限（${Math.floor(maxBytes / 1024 / 1024)}MB）`);
+        }
+        chunks.push(Buffer.from(value));
+    }
+    return Buffer.concat(chunks);
+}
+/**
+ * GET an https resource as text. Proxy resolution order: explicit argument
+ * (plugin setting) → HTTPS_PROXY/HTTP_PROXY env → direct fetch.
+ */
+async function getText(url, timeoutMs = 15000, proxyOverride) {
+    const signal = AbortSignal.timeout(timeoutMs);
+    const proxy = proxyOverride || proxyUrl();
+    if (!proxy) {
+        const res = await fetch(url, { signal, headers: { 'user-agent': USER_AGENT } });
+        if (!res.ok)
+            throw new Error(`HTTP ${res.status}`);
+        const body = await fetchBodyWithLimit(res, MAX_TEXT_BYTES);
+        return body.toString('utf8');
+    }
+    const body = await proxyGet(url, timeoutMs, proxy, '*/*', MAX_TEXT_BYTES);
+    return body.toString('utf8');
+}
+const decodeEntities = (s) => s.replace(/&amp;/g, '&').replace(/&lt;/g, '<').replace(/&gt;/g, '>')
+    .replace(/&quot;/g, '"').replace(/&#39;|&apos;|&#x27;/g, "'")
+    .replace(/&#x([0-9a-f]+);/gi, (_, n) => String.fromCodePoint(Number.parseInt(n, 16)))
+    .replace(/&#(\d+);/g, (_, n) => String.fromCharCode(Number(n)))
+    .replace(/\s+/g, ' ').trim();
+/**
+ * GET an https resource as raw bytes (PDF download). Same proxy resolution
+ * as getText: explicit argument (plugin setting) -> env proxy -> direct.
+ */
+export async function fetchPdf(url, timeoutMs = 60000, proxyOverride) {
+    const signal = AbortSignal.timeout(timeoutMs);
+    const proxy = proxyOverride || proxyUrl();
+    if (!proxy) {
+        const res = await fetch(url, { signal, headers: { 'user-agent': USER_AGENT } });
+        if (!res.ok)
+            throw new Error(`HTTP ${res.status}`);
+        return fetchBodyWithLimit(res, MAX_PDF_BYTES);
+    }
+    return proxyGet(url, timeoutMs, proxy, 'application/pdf,*/*', MAX_PDF_BYTES);
+}
+/** Minimal Atom entry reader for the arXiv API response. */
+export function parseArxivFeed(xml) {
+    const entry = /<entry>([\s\S]*?)<\/entry>/.exec(xml)?.[1];
+    if (!entry)
+        throw new Error('arXiv 返回中没有条目（id 可能无效）');
+    const tag = (name) => {
+        const m = new RegExp(`<${name}[^>]*>([\\s\\S]*?)</${name}>`).exec(entry);
+        return m ? decodeEntities(m[1]) : '';
+    };
+    const title = tag('title');
+    if (!title)
+        throw new Error('arXiv 条目缺少标题');
+    const authors = [...entry.matchAll(/<author>[\s\S]*?<name>([\s\S]*?)<\/name>[\s\S]*?<\/author>/g)]
+        .map((m) => decodeEntities(m[1]));
+    const published = tag('published');
+    const year = Number(published.slice(0, 4)) || undefined;
+    const journalRef = tag('arxiv:journal_ref');
+    const idAttr = /<id>http:\/\/arxiv\.org\/abs\/([^<]+)<\/id>/.exec(entry)?.[1] ?? '';
+    const abstract = tag('summary');
+    return {
+        title,
+        authors,
+        year,
+        venue: journalRef || 'arXiv',
+        arxivId: ARXIV_NEW.exec(idAttr)?.[1] ?? idAttr.replace(/v\d+$/i, ''),
+        abstract,
+    };
+}
+/** 仅 429/网络类瞬态错误（限流、超时、断连、代理失败）值得重试；解析失败等确定性错误直接抛。 */
+function isTransientError(err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return /429|timeout|timed out|abort|ECONN|socket|network|fetch failed|代理/i.test(msg);
+}
+async function fetchArxiv(arxivId, proxy) {
+    const url = `https://export.arxiv.org/api/query?id_list=${encodeURIComponent(arxivId)}&max_results=1`;
+    // arXiv asks for ~3s between API hits and answers 429 when a burst arrives;
+    // retry once after a polite pause before giving up (仅限流/网络类瞬态错误).
+    try {
+        return parseArxivFeed(await getText(url, 20000, proxy));
+    }
+    catch (err) {
+        if (!isTransientError(err))
+            throw err;
+        await new Promise((r) => setTimeout(r, 3500));
+        return parseArxivFeed(await getText(url, 20000, proxy));
+    }
+}
+/** CrossRef JSON → common shape; exported for tests (pure). */
+export function crossrefToMeta(body) {
+    const msg = body.message ?? {};
+    const title = msg.title?.[0]?.trim();
+    if (!title)
+        throw new Error('CrossRef 条目缺少标题');
+    const year = msg.issued?.['date-parts']?.[0]?.[0] ??
+        msg['published-print']?.['date-parts']?.[0]?.[0];
+    const authors = (msg.author ?? []).map((a) => ([a.given, a.family].filter(Boolean).join(' ') || a.name || '')).filter(Boolean);
+    const jats = msg.abstract ?? '';
+    const abstract = decodeEntities(jats.replace(/<[^>]+>/g, '')).replace(/^Abstract\s*[:.]?\s*/i, '') || undefined;
+    return {
+        title,
+        authors,
+        year: typeof year === 'number' ? year : undefined,
+        venue: msg['container-title']?.[0] || undefined,
+        doi: msg.DOI,
+        url: msg.URL || (msg.DOI ? `https://doi.org/${msg.DOI}` : undefined),
+        abstract,
+    };
+}
+async function fetchDoi(doi, proxy) {
+    const text = await getText(`https://api.crossref.org/works/${encodeURIComponent(doi)}`, 15000, proxy);
+    return crossrefToMeta(JSON.parse(text));
+}
+/** Main entry: classify input then query the matching source. */
+export async function fetchMetadata(input, proxy) {
+    const s = input.trim();
+    if (!s)
+        throw new Error('请输入 arXiv 链接/编号或 DOI');
+    const arxiv = parseArxivId(s);
+    if (arxiv)
+        return fetchArxiv(arxiv, proxy);
+    const doi = parseDoi(s);
+    if (doi)
+        return fetchDoi(doi, proxy);
+    throw new Error('无法识别的输入：请提供 arXiv 链接/编号（如 2106.09685）或 DOI');
+}