@getmegabrain/cli 0.1.8 → 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/kernel_driver.py

@@ -13,9 +13,14 @@ cell are visible in the next.
 import contextlib
 import io
 import json
+import os
 import sys
 import traceback
 
+# Render matplotlib to a non-interactive backend so plt.show() never blocks; we capture
+# figures ourselves after each cell (see emit_figures). Set before any user import.
+os.environ.setdefault("MPLBACKEND", "Agg")
+
 # Persistent namespace shared across all cells in this session.
 NAMESPACE: dict = {"__name__": "__mb_science__"}
 
@@ -25,6 +30,30 @@ def emit(frame: dict) -> None:
     sys.stdout.flush()
 
 
+def emit_figures(cell_id: str) -> int:
+    """Emit any open matplotlib figures as base64 PNG image frames, then close them.
+
+    This is what makes plots appear inline in the transcript (a science-notebook staple).
+    No-op if matplotlib hasn't been used in this session."""
+    pyplot = sys.modules.get("matplotlib.pyplot")
+    if pyplot is None:
+        return 0
+    import base64
+
+    count = 0
+    try:
+        for num in pyplot.get_fignums():
+            buf = io.BytesIO()
+            pyplot.figure(num).savefig(buf, format="png", bbox_inches="tight", dpi=110)
+            data = base64.b64encode(buf.getvalue()).decode("ascii")
+            emit({"type": "image", "cellId": cell_id, "mime": "image/png", "data": data})
+            count += 1
+        pyplot.close("all")
+    except Exception:  # noqa: BLE001 - figure capture is best-effort
+        pass
+    return count
+
+
 def run_cell(cell_id: str, code: str) -> None:
     emit({"type": "status", "cellId": cell_id, "state": "busy"})
     stdout, stderr = io.StringIO(), io.StringIO()
@@ -41,6 +70,11 @@ def run_cell(cell_id: str, code: str) -> None:
         emit({"type": "stream", "cellId": cell_id, "kind": "stdout", "data": out})
     if err:
         emit({"type": "stream", "cellId": cell_id, "kind": "stderr", "data": err})
+    figures = emit_figures(cell_id)
+    if figures:
+        # A note in stdout so the (text-only) model knows a figure was produced.
+        emit({"type": "stream", "cellId": cell_id, "kind": "stdout",
+              "data": f"[{figures} figure(s) displayed]\n"})
     emit({"type": "status", "cellId": cell_id, "state": "idle"})
 
 

package/dist/science/pages.js

@@ -307,6 +307,8 @@ export function sessionPage(projectId, sessionId) {
         white-space:pre-wrap; overflow-x:auto; border-top:1px solid var(--border); }
       .step .out { color:var(--muted); background:var(--bg); }
       .step .out.err { color:#c0392b; }
+      img.figure { max-width:calc(100% - 24px); border-radius:8px; margin:10px 12px; display:block;
+        background:#fff; border:1px solid var(--border); }
       /* Composer */
       .composer { flex-shrink:0; border-top:1px solid var(--border); padding:14px 20px; }
       .composer-inner { max-width:760px; margin:0 auto; display:flex; gap:10px; align-items:flex-end;

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/dist/science/session-client.js

@@ -64,6 +64,18 @@
     if (stderr) out.classList.add('err');
     scroll();
   }
+  // Inline a rendered figure (matplotlib PNG) under the current step, or on its own if none.
+  function addFigure(mime, data) {
+    var img = el('img', 'figure');
+    img.src = 'data:' + mime + ';base64,' + data;
+    if (lastCard) lastCard.appendChild(img);
+    else {
+      var row = el('div', 'msg agent');
+      row.appendChild(img);
+      transcript.appendChild(row);
+    }
+    scroll();
+  }
 
   function setRunning(on) {
     sendBtn.disabled = on;
@@ -112,6 +124,7 @@
       if (m.channel === 'kernel') {
         var f = m.payload;
         if (f.type === 'status') kstate.textContent = f.state === 'busy' ? 'running' : f.state;
+        else if (f.type === 'image') addFigure(f.mime, f.data);
         return;
       }
       var p = m.payload;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getmegabrain/cli",
-  "version": "0.1.8",
+  "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",