@getmegabrain/cli 0.1.9 → 0.1.10

package/dist/science/agent/agent.js

@@ -19,8 +19,10 @@ export function pythonTool(bridge) {
 const SYSTEM_PROMPT = `You are the MegaBrain Science research agent. You work in a live
 notebook, sharing one Python kernel with the user — variables and imports persist across
 cells and everything runs locally on the user's machine. Use run_python to write and run
-code and iterate on its output. Prefer small, verifiable steps. When you have the answer,
-stop calling tools and give a concise final summary of what you did and found.`;
+code and iterate on its output, and search_literature to find and cite real papers (arXiv,
+OpenAlex, PubMed) when the task calls for surveying prior work. Prefer small, verifiable
+steps. When you have the answer, stop calling tools and give a concise final summary of
+what you did and found.`;
 const MAX_TURNS = 16;
 export class AgentSession {
     model;

package/dist/science/agent/literature.js

@@ -0,0 +1,116 @@
+function firstMatch(block, re) {
+    const m = re.exec(block);
+    return m ? m[1].replace(/\s+/g, ' ').trim() : '';
+}
+/** Parse an arXiv Atom feed into papers (tolerant, entry-by-entry). */
+export function parseArxivAtom(xml) {
+    const papers = [];
+    const entryRe = /<entry>([\s\S]*?)<\/entry>/g;
+    let entry = entryRe.exec(xml);
+    while (entry !== null) {
+        const block = entry[1];
+        const authors = [];
+        const nameRe = /<name>([\s\S]*?)<\/name>/g;
+        let name = nameRe.exec(block);
+        while (name !== null) {
+            authors.push(name[1].trim());
+            name = nameRe.exec(block);
+        }
+        papers.push({
+            title: firstMatch(block, /<title>([\s\S]*?)<\/title>/),
+            id: firstMatch(block, /<id>([\s\S]*?)<\/id>/),
+            published: firstMatch(block, /<published>([\s\S]*?)<\/published>/),
+            summary: firstMatch(block, /<summary>([\s\S]*?)<\/summary>/),
+            authors,
+        });
+        entry = entryRe.exec(xml);
+    }
+    return papers;
+}
+export function formatPapers(papers) {
+    if (papers.length === 0)
+        return 'No papers found.';
+    return papers
+        .map((p, i) => {
+        const year = p.published.slice(0, 4);
+        const who = p.authors.slice(0, 3).join(', ') + (p.authors.length > 3 ? ', et al.' : '');
+        return `${i + 1}. ${p.title} (${year}) — ${who} [${p.id}]`;
+    })
+        .join('\n');
+}
+export class ArxivClient {
+    endpoint;
+    constructor(endpoint = 'https://export.arxiv.org/api/query') {
+        this.endpoint = endpoint;
+    }
+    async search(query, maxResults) {
+        const url = `${this.endpoint}?search_query=${encodeURIComponent(`all:${query}`)}&max_results=${maxResults}`;
+        const response = await fetch(url);
+        if (!response.ok) {
+            throw new Error(`arXiv request failed (${response.status})`);
+        }
+        return parseArxivAtom(await response.text());
+    }
+}
+/** Dedupe papers by normalized title, preserving order. */
+export function dedupePapers(papers) {
+    const seen = new Set();
+    const out = [];
+    for (const paper of papers) {
+        const key = paper.title.toLowerCase().replace(/\s+/g, ' ').trim();
+        if (key && !seen.has(key)) {
+            seen.add(key);
+            out.push(paper);
+        }
+    }
+    return out;
+}
+/**
+ * Queries several sources concurrently and merges the results. Resilient: a source that
+ * throws is dropped, not fatal — so one database being down doesn't break search.
+ */
+export class MultiSourceClient {
+    sources;
+    constructor(sources) {
+        this.sources = sources;
+    }
+    async search(query, maxResults) {
+        const settled = await Promise.allSettled(this.sources.map(source => source.search(query, maxResults)));
+        const merged = settled.flatMap(result => (result.status === 'fulfilled' ? result.value : []));
+        return dedupePapers(merged).slice(0, maxResults);
+    }
+}
+function strOf(value) {
+    return typeof value === 'string' ? value : '';
+}
+/** The search_literature tool. */
+export function literatureTool(client) {
+    return {
+        definition: {
+            name: 'search_literature',
+            description: 'Search the scientific literature (arXiv + OpenAlex + PubMed) for papers relevant to a query. Returns titles, authors, years, and ids (DOI/PMID/arXiv) you can cite.',
+            input_schema: {
+                type: 'object',
+                properties: {
+                    query: { type: 'string', description: 'Search terms.' },
+                    maxResults: { type: 'number', description: 'How many papers to return (default 5).' },
+                },
+                required: ['query'],
+            },
+        },
+        describe(input) {
+            return `search_literature: ${strOf(input.query)}`;
+        },
+        async run(input) {
+            const query = strOf(input.query);
+            const maxResults = Number(input.maxResults ?? 5) || 5;
+            try {
+                const papers = await client.search(query, maxResults);
+                return { stdout: formatPapers(papers), stderr: '' };
+            }
+            catch (error) {
+                return { stdout: '', stderr: error instanceof Error ? error.message : String(error) };
+            }
+        },
+    };
+}

package/dist/science/agent/openalex.js

@@ -0,0 +1,27 @@
+/** Parse an OpenAlex /works response into papers. */
+export function parseOpenAlex(json) {
+    const results = json?.results;
+    if (!Array.isArray(results))
+        return [];
+    return results.map(work => ({
+        title: work.title ?? work.display_name ?? '(untitled)',
+        authors: (work.authorships ?? []).map(a => a.author?.display_name ?? '').filter(Boolean),
+        id: work.doi ?? work.id ?? '',
+        published: work.publication_year ? String(work.publication_year) : '',
+        summary: '',
+    }));
+}
+export class OpenAlexClient {
+    endpoint;
+    constructor(endpoint = 'https://api.openalex.org/works') {
+        this.endpoint = endpoint;
+    }
+    async search(query, maxResults) {
+        const url = `${this.endpoint}?search=${encodeURIComponent(query)}&per_page=${maxResults}`;
+        const response = await fetch(url);
+        if (!response.ok) {
+            throw new Error(`OpenAlex request failed (${response.status})`);
+        }
+        return parseOpenAlex(await response.json());
+    }
+}

package/dist/science/agent/pubmed.js

@@ -0,0 +1,62 @@
+/**
+ * PubMed connector — the marquee biomedical database (NCBI E-utilities, no key). Two
+ * steps: esearch returns PMIDs for a query, efetch returns the article records as XML.
+ * Implements the same LiteratureClient interface, so it joins the multi-source search.
+ */
+const ESEARCH = 'https://eutils.ncbi.nlm.nih.gov/entrez/eutils/esearch.fcgi';
+const EFETCH = 'https://eutils.ncbi.nlm.nih.gov/entrez/eutils/efetch.fcgi';
+/** Parse the esearch JSON into a list of PMIDs. */
+export function parseEsearchIds(json) {
+    const ids = json?.esearchresult?.idlist;
+    return Array.isArray(ids) ? ids.filter(id => typeof id === 'string') : [];
+}
+function firstMatch(block, re) {
+    const m = re.exec(block);
+    return m ? m[1].replace(/\s+/g, ' ').trim() : '';
+}
+/** Parse an efetch PubmedArticleSet into papers (tolerant, article-by-article). */
+export function parsePubmedXml(xml) {
+    const papers = [];
+    const articleRe = /<PubmedArticle>([\s\S]*?)<\/PubmedArticle>/g;
+    let article = articleRe.exec(xml);
+    while (article !== null) {
+        const block = article[1];
+        const pmid = firstMatch(block, /<PMID[^>]*>(\d+)<\/PMID>/);
+        const authors = [];
+        const authorRe = /<Author[^>]*>([\s\S]*?)<\/Author>/g;
+        let author = authorRe.exec(block);
+        while (author !== null) {
+            const last = firstMatch(author[1], /<LastName>([\s\S]*?)<\/LastName>/);
+            const fore = firstMatch(author[1], /<ForeName>([\s\S]*?)<\/ForeName>/);
+            const name = [fore, last].filter(Boolean).join(' ');
+            if (name)
+                authors.push(name);
+            author = authorRe.exec(block);
+        }
+        papers.push({
+            title: firstMatch(block, /<ArticleTitle>([\s\S]*?)<\/ArticleTitle>/),
+            id: pmid ? `PMID:${pmid}` : '',
+            published: firstMatch(block, /<PubDate>[\s\S]*?<Year>(\d{4})<\/Year>/),
+            summary: '',
+            authors,
+        });
+        article = articleRe.exec(xml);
+    }
+    return papers;
+}
+export class PubMedClient {
+    async search(query, maxResults) {
+        const searchUrl = `${ESEARCH}?db=pubmed&retmode=json&retmax=${maxResults}&term=${encodeURIComponent(query)}`;
+        const searchRes = await fetch(searchUrl);
+        if (!searchRes.ok)
+            throw new Error(`PubMed esearch failed (${searchRes.status})`);
+        const ids = parseEsearchIds(await searchRes.json());
+        if (ids.length === 0)
+            return [];
+        const fetchUrl = `${EFETCH}?db=pubmed&retmode=xml&id=${ids.join(',')}`;
+        const fetchRes = await fetch(fetchUrl);
+        if (!fetchRes.ok)
+            throw new Error(`PubMed efetch failed (${fetchRes.status})`);
+        return parsePubmedXml(await fetchRes.text());
+    }
+}

package/dist/science/server.js

@@ -9,6 +9,9 @@ import { homePage, loginPage, nonceInvalidPage, nonceLandingPage, projectPage, s
 import { FEATURED_CONNECTORS, NETWORK_CATEGORIES, WorkspaceStore } from './store.js';
 import { KernelManager } from './kernel.js';
 import { AgentSession, pythonTool } from './agent/agent.js';
+import { ArxivClient, literatureTool, MultiSourceClient } from './agent/literature.js';
+import { OpenAlexClient } from './agent/openalex.js';
+import { PubMedClient } from './agent/pubmed.js';
 import { GatewayModel } from './agent/model.js';
 /**
  * The `megabrain science` local daemon's HTTP server. Serves the sign-in hand-off on
@@ -264,7 +267,10 @@ export async function startScienceServer(host = '127.0.0.1') {
                 const project = session ? store.getProject(session.projectId) : null;
                 store.touchSession(sid, session && !session.summary ? { summary: prompt } : undefined);
                 fanout(sid, 'agent', { type: 'user', text: prompt });
-                const agent = new AgentSession(new GatewayModel({ apiKey: creds.token }), [pythonTool(kernels.get(sid))], evt => fanout(sid, 'agent', evt), project?.agentContext ?? '', store.getMessages(sid));
+                const agent = new AgentSession(new GatewayModel({ apiKey: creds.token }), [
+                    pythonTool(kernels.get(sid)),
+                    literatureTool(new MultiSourceClient([new ArxivClient(), new OpenAlexClient(), new PubMedClient()])),
+                ], evt => fanout(sid, 'agent', evt), project?.agentContext ?? '', store.getMessages(sid));
                 // Persist the full history when the turn ends, so the session remembers it and the
                 // transcript survives a refresh.
                 void agent.run(prompt).finally(() => store.setMessages(sid, agent.getMessages()));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getmegabrain/cli",
-  "version": "0.1.9",
+  "version": "0.1.10",
   "description": "MegaBrain CLI — sign in once, then code from your terminal via OpenCode wired to the MegaBrain Gateway, or run `megabrain science` for the local research workbench.",
   "license": "MIT",
   "type": "module",