| |
| import type { TLBinding, TLRecord, TLShape, TLShapeId } from '@tldraw/tlschema' |
| import assert from 'node:assert/strict' |
| import { mkdtempSync, rmSync } from 'node:fs' |
| import { tmpdir } from 'node:os' |
| import { join } from 'node:path' |
| import { after, test } from 'node:test' |
| import { linkShapeId, paperShapeId } from '../shared/ids.ts' |
| import { CARD_SIZE, type PaperCardShape } from '../shared/shapes.ts' |
| import { |
| addNote, |
| addPapers, |
| addQuote, |
| getBoard, |
| linkPapers, |
| markWorking, |
| setCard, |
| setScores, |
| ToolError, |
| type ToolContext, |
| } from './canvasTools.ts' |
| import { isFree, shapeBoxes } from './layout.ts' |
| import type { PapersClient } from './papersClient.ts' |
| import { closeBoardDb, setBoardDbPath } from './boardDb.ts' |
| import { closeAllRooms, patchShapes, putShapes, readRoom, setRoomsDir, writeRoom } from './rooms.ts' |
|
|
| const dir = mkdtempSync(join(tmpdir(), 'canvas-tools-')) |
| setRoomsDir(dir) |
| setBoardDbPath(join(dir, 'board.db')) |
| after(async () => { |
| |
| await new Promise((resolve) => setTimeout(resolve, 1100)) |
| closeAllRooms() |
| closeBoardDb() |
| rmSync(dir, { recursive: true, force: true }) |
| }) |
|
|
| const ABSTRACT = 'We profiled 4,645 single cells from 19 melanomas.\n Malignant cells showed\ntwo transcriptional programs.' |
| let papersDown = false |
| const papers: PapersClient = { |
| url: 'http://papers.test/mcp', |
| close: async () => {}, |
| async getPaper(paperId) { |
| if (papersDown) throw new Error('The papers MCP at http://papers.test/mcp is unreachable (ECONNREFUSED)') |
| return { paperId, title: 'Melanoma atlas', abstract: ABSTRACT, url: 'https://pubmed.ncbi.nlm.nih.gov/27124452/' } |
| }, |
| } |
|
|
| let boards = 0 |
| const newCtx = (over: Partial<ToolContext> = {}): ToolContext => ({ |
| boardId: `board${++boards}`, |
| onBehalfOf: 'm_ana', |
| runId: 'run_0123456789ab', |
| model: 'nvidia/Nemotron-3.5-Super-VL', |
| papers, |
| ...over, |
| }) |
|
|
| const all = (ctx: ToolContext) => readRoom(ctx.boardId, (txn) => [...txn.values()]) as TLRecord[] |
| const card = (ctx: ToolContext, paperId: string) => |
| readRoom(ctx.boardId, (txn) => txn.get(paperShapeId(paperId))) as PaperCardShape |
| const paper = (paperId: string, extra = {}) => ({ paperId, title: `Paper ${paperId}`, ...extra }) |
| const rejects = (fn: () => unknown, pattern: RegExp) => |
| assert.rejects(async () => fn(), (e: Error) => e instanceof ToolError && pattern.test(e.message)) |
|
|
| |
| function assertApart(records: TLRecord[]) { |
| const boxes = [...shapeBoxes(records).values()] |
| boxes.forEach((b, i) => assert.ok(isFree(boxes.slice(0, i), b), `box ${i} overlaps an earlier one`)) |
| } |
|
|
| test('add_papers creates cards beside their neighbour, with defaults and attribution', () => { |
| const ctx = newCtx() |
| const first = addPapers(ctx, { |
| papers: [paper('pmid:1', { authors: ['Itay Tirosh'], year: 2016, type: 'journal-article', foundBy: ['pubmed'] })], |
| }) |
| assert.deepEqual(first, { added: ['pmid:1'], updated: [], skipped: [] }) |
| const result = addPapers(ctx, { |
| papers: [ |
| paper('pmid:2', { near: 'pmid:1' }), |
| paper('pmid:3', { near: 'pmid:1', kind: 'seed' }), |
| paper('pmid:4', { near: 'pmid:1' }), |
| paper('pmid:5', { retracted: true }), |
| ], |
| }) |
| assert.deepEqual(result.added, ['pmid:2', 'pmid:3', 'pmid:4']) |
| assert.deepEqual(result.skipped, [{ paperId: 'pmid:5', reason: 'retracted' }]) |
|
|
| const c1 = card(ctx, 'pmid:1') |
| assert.equal(c1.props.type, 'article') |
| assert.equal(c1.props.typeRaw, 'journal-article') |
| assert.deepEqual(c1.props.foundBy, ['pubmed']) |
| assert.equal(c1.props.kind, 'suggestion') |
| assert.equal(c1.props.status, 'new') |
| assert.equal(c1.props.working, true) |
| assert.equal(c1.props.w, 48) |
| assert.equal(card(ctx, 'pmid:3').props.kind, 'seed') |
| assert.deepEqual(c1.meta, { createdBy: 'agent', onBehalfOf: 'm_ana', runId: 'run_0123456789ab', paperId: 'pmid:1' }) |
|
|
| |
| assertApart(all(ctx)) |
| for (const id of ['pmid:2', 'pmid:3', 'pmid:4']) { |
| const c = card(ctx, id) |
| assert.ok(Math.abs(Math.hypot(c.x - c1.x, c.y - c1.y) - 212) < 1, `${id} is beside pmid:1`) |
| } |
| }) |
|
|
| test('add_papers without near rings a run’s papers around its first card, not in a row', () => { |
| const ctx = newCtx() |
| addPapers(ctx, { papers: [paper('first')] }) |
| addPapers(ctx, { papers: [paper('b'), paper('c')] }) |
| addPapers(ctx, { papers: [paper('d'), paper('e')] }) |
| const first = card(ctx, 'first') |
| for (const id of ['b', 'c', 'd', 'e']) { |
| const c = card(ctx, id) |
| assert.ok(Math.abs(Math.hypot(c.x - first.x, c.y - first.y) - 212) < 1, `${id} is on the first ring`) |
| } |
| |
| const other = { ...ctx, runId: 'run_ba9876543210' } |
| addPapers(other, { papers: [paper('o1')] }) |
| addPapers(other, { papers: [paper('o2')] }) |
| const o1 = card(ctx, 'o1') |
| assert.ok(o1.x > Math.max(...['b', 'c', 'd', 'e'].map((id) => card(ctx, id).x))) |
| assert.ok(Math.abs(Math.hypot(card(ctx, 'o2').x - o1.x, card(ctx, 'o2').y - o1.y) - 212) < 1) |
| assertApart(all(ctx)) |
| }) |
|
|
| test('add_papers updates its own cards in place and skips what people touched', () => { |
| const ctx = newCtx() |
| addPapers(ctx, { papers: [paper('a'), paper('b'), paper('c'), paper('seed', { kind: 'seed' })] }) |
| const before = card(ctx, 'a') |
| const again = addPapers(ctx, { papers: [paper('a', { title: 'New title', year: 2020, venue: null })] }) |
| assert.deepEqual(again, { added: [], updated: ['a'], skipped: [] }) |
| const after = card(ctx, 'a') |
| assert.equal(after.props.title, 'New title') |
| assert.equal(after.props.year, 2020) |
| assert.deepEqual([after.x, after.y, after.index], [before.x, before.y, before.index]) |
| assert.equal(after.props.working, true) |
|
|
| patchShapes(ctx.boardId, [ |
| { id: card(ctx, 'b').id, x: 999, y: 999, meta: { pinnedByHuman: true } }, |
| { id: card(ctx, 'c').id, meta: { editedByHuman: true } }, |
| ]) |
| putShapes(ctx.boardId, [{ id: paperShapeId('mine'), type: 'paper-card', props: { ...card(ctx, 'a').props, paperId: 'mine' }, meta: { author: 'm_bo' } }]) |
| const touched = addPapers(ctx, { papers: ['b', 'c', 'seed', 'mine'].map((id) => paper(id, { title: 'Changed' })) }) |
| assert.deepEqual(touched.skipped, [ |
| { paperId: 'b', reason: 'moved by a person' }, |
| { paperId: 'c', reason: 'edited by a person' }, |
| { paperId: 'seed', reason: 'a seed already on the board' }, |
| { paperId: 'mine', reason: 'made by a person' }, |
| ]) |
| assert.equal(card(ctx, 'b').x, 999) |
| assert.equal(card(ctx, 'b').props.title, 'Paper b') |
| }) |
|
|
| test('set_scores merges per goal and checks the goals', async () => { |
| const ctx = newCtx() |
| addPapers(ctx, { papers: [paper('a')] }) |
| assert.deepEqual(setScores(ctx, { paperId: 'a', scores: { 'new-findings': { score: 0.9, fit: 'high', why: 'Same cells' } } }), { ok: true }) |
| setScores(ctx, { paperId: 'a', scores: { methods: { score: 0.2, fit: 'low', why: 'Other method' } } }) |
| assert.deepEqual(Object.keys(card(ctx, 'a').props.scores), ['new-findings', 'methods']) |
| await rejects(() => setScores(ctx, { paperId: 'a', scores: { vibes: { score: 1, fit: 'high', why: '' } } }), /Not a goal/) |
| await rejects(() => setScores(ctx, { paperId: 'zzz', scores: { methods: { score: 1, fit: 'high', why: '' } } }), /No card for zzz/) |
| patchShapes(ctx.boardId, [{ id: card(ctx, 'a').id, meta: { editedByHuman: true } }]) |
| assert.deepEqual(setScores(ctx, { paperId: 'a', scores: { methods: { score: 1, fit: 'high', why: '' } } }), { |
| ok: false, |
| skipped: 'edited by a person', |
| }) |
| }) |
|
|
| test('add_quote checks the abstract verbatim and returns stable IDs', async () => { |
| const ctx = newCtx() |
| addPapers(ctx, { papers: [paper('pmid:27124452', { url: 'https://pubmed.ncbi.nlm.nih.gov/27124452/' })] }) |
| const q = await addQuote(ctx, { paperId: 'pmid:27124452', text: 'Malignant cells showed two transcriptional programs.' }) |
| assert.deepEqual(q, { quoteId: 'q1' }) |
| const [quote] = card(ctx, 'pmid:27124452').props.quotes |
| assert.equal(quote.text, 'Malignant cells showed two transcriptional programs.') |
| assert.equal(quote.source, 'abstract') |
| assert.equal(quote.verified, true) |
| assert.match(quote.url, /^https:\/\/pubmed\.ncbi\.nlm\.nih\.gov\/27124452\/#:~:text=Malignant%20cells%20showed/) |
| assert.deepEqual(await addQuote(ctx, { paperId: 'pmid:27124452', text: ' Malignant cells showed two transcriptional programs. ' }), { quoteId: 'q1' }) |
| assert.deepEqual(await addQuote(ctx, { paperId: 'pmid:27124452', text: 'from 19 melanomas' }), { quoteId: 'q2' }) |
|
|
| await rejects(() => addQuote(ctx, { paperId: 'pmid:27124452', text: 'Malignant cells showed three programs.' }), /isn't in the abstract/) |
| papersDown = true |
| await rejects(() => addQuote(ctx, { paperId: 'pmid:27124452', text: 'from 19 melanomas' }), /unreachable.*nothing was written/) |
| papersDown = false |
| await rejects(() => addQuote(ctx, { paperId: 'nope', text: 'x' }), /No card for nope/) |
| assert.equal(card(ctx, 'pmid:27124452').props.quotes.length, 2) |
| }) |
|
|
| test('set_card fills the card field by field, checks quote IDs and records provenance', async () => { |
| const ctx = newCtx() |
| addPapers(ctx, { papers: [paper('p')] }) |
| await addQuote(ctx, { paperId: 'p', text: 'from 19 melanomas' }) |
| const oneLine = 'Profiles the same melanoma cells as three of your seeds.' |
| assert.deepEqual(setCard(ctx, { paperId: 'p', oneLine }), { ok: true, written: ['oneLine'] }) |
| const glance = [ |
| { label: 'Samples', text: '19 melanomas', quoteId: 'q1', relation: 'same' as const }, |
| { label: 'Method', text: 'scRNA-seq', quoteId: null, relation: 'adds' as const }, |
| { label: 'Finding', text: 'Two programs', quoteId: null, relation: null }, |
| ] |
| const claims = [ |
| { text: 'same melanoma cells', evidence: ['q1'] }, |
| { text: 'three of your seeds', evidence: ['seeds'] }, |
| ] |
| const figure = { imageUrl: 'https://cdn.ncbi.nlm.nih.gov/fig3.jpg', label: 'Fig. 3', caption: 'UMAP', captionByAi: false } |
| assert.deepEqual(setCard({ ...ctx, model: 'nvidia/other' }, { paperId: 'p', claims, glance, figure, gaps: ['No full text'] }), { |
| ok: true, |
| written: ['claims', 'glance', 'figure', 'gaps'], |
| }) |
| const p = card(ctx, 'p').props |
| assert.equal(p.oneLine, oneLine) |
| assert.deepEqual(p.glance, glance) |
| assert.deepEqual(p.claims, claims) |
| assert.equal(p.figure?.label, 'Fig. 3') |
| assert.equal(p.provenance.oneLine.model, 'nvidia/Nemotron-3.5-Super-VL') |
| assert.equal(p.provenance.glance.model, 'nvidia/other') |
| assert.ok(p.provenance.glance.at >= p.provenance.oneLine.at) |
|
|
| await rejects(() => setCard(ctx, { paperId: 'p', claims: [{ text: 'same melanoma cells', evidence: ['q9'] }] }), /q9: no such quote/) |
| await rejects(() => setCard(ctx, { paperId: 'p', claims: [{ text: 'not in the line', evidence: ['q1'] }] }), /word for word in oneLine/) |
| await rejects(() => setCard(ctx, { paperId: 'p', glance: glance.map((s) => ({ ...s, quoteId: 'q7' })) }), /q7/) |
| await rejects(() => setCard(ctx, { paperId: 'p' }), /Nothing to set/) |
| |
| setCard(ctx, { paperId: 'p', oneLine: 'Three of your seeds? No: same melanoma cells.' }) |
| assert.deepEqual(card(ctx, 'p').props.claims, [claims[0]]) |
| }) |
|
|
| test('link_papers draws bound arrows once, never resizes or moves a card, and respects citations, removed and hidden links', () => { |
| const ctx = newCtx() |
| addPapers(ctx, { papers: [paper('a'), paper('b', { near: 'a' }), paper('c', { near: 'a' }), paper('s', { kind: 'seed', near: 'a' })] }) |
| const places = () => ['a', 'b', 'c', 's'].map((id) => card(ctx, id)).map((c) => [c.x, c.y, c.props.w, c.props.h]) |
| const before = places() |
| const result = linkPapers(ctx, { |
| links: [ |
| { from: 'a', to: 'b', kind: 'cites' }, |
| { from: 'a', to: 'c', kind: 'similar' }, |
| { from: 'a', to: 's', kind: 'cites' }, |
| { from: 'a', to: 'a', kind: 'similar' }, |
| { from: 'a', to: 'nope', kind: 'cites' }, |
| { from: 'b', to: 'a', kind: 'similar' }, |
| ], |
| }) |
| assert.equal(result.linked.length, 3) |
| assert.deepEqual(result.skipped.map((s) => s.reason), [ |
| 'a paper can’t link to itself', |
| 'no card for nope', |
| 'already linked by a citation', |
| ]) |
| assert.equal(all(ctx).some((r) => r.id === linkShapeId('b', 'a', 'similar') || r.id === linkShapeId('a', 'b', 'similar')), false) |
|
|
| const records = all(ctx) |
| const arrowId = linkShapeId('a', 'b', 'cites') as TLShapeId |
| const arrow = records.find((r) => r.id === arrowId) as TLShape |
| assert.equal(arrow.type, 'arrow') |
| assert.deepEqual(arrow.meta, { |
| createdBy: 'agent', |
| onBehalfOf: 'm_ana', |
| runId: 'run_0123456789ab', |
| kind: 'cites', |
| label: '', |
| by: 'pubmed', |
| hiddenByHuman: false, |
| }) |
| const bindings = records.filter((r): r is TLBinding => r.typeName === 'binding' && r.fromId === arrowId) |
| assert.deepEqual( |
| bindings.map((b) => [b.type, b.type === 'arrow' && b.props.terminal, b.toId]).sort(), |
| [ |
| ['arrow', 'end', card(ctx, 'b').id], |
| ['arrow', 'start', card(ctx, 'a').id], |
| ] |
| ) |
| |
| assert.deepEqual(places(), before) |
|
|
| |
| const count = all(ctx).length |
| const again = linkPapers(ctx, { |
| links: [ |
| { from: 'a', to: 'b', kind: 'cites' }, |
| { from: 'c', to: 'a', kind: 'similar' }, |
| { from: 'a', to: 's', kind: 'similar' }, |
| ], |
| }) |
| assert.equal(again.linked.length, 2) |
| assert.deepEqual(again.skipped, [{ from: 'a', to: 's', kind: 'similar', reason: 'already linked by a citation' }]) |
| assert.equal(all(ctx).length, count) |
|
|
| |
| const similarId = linkShapeId('a', 'c', 'similar') |
| writeRoom(ctx.boardId, (txn) => { |
| for (const r of [...txn.values()]) if (r.id === similarId || (r.typeName === 'binding' && r.fromId === similarId)) txn.delete(r.id) |
| }) |
| patchShapes(ctx.boardId, [{ id: arrowId, meta: { hiddenByHuman: true } }]) |
| const blocked = linkPapers(ctx, { links: [{ from: 'c', to: 'a', kind: 'similar' }, { from: 'a', to: 'b', kind: 'cites' }] }) |
| assert.deepEqual(blocked.skipped.map((s) => s.reason), ['removed by a person', 'hidden by a person']) |
| assert.deepEqual(getBoard(ctx).removedLinks, [{ from: 'a', to: 'c', kind: 'similar' }]) |
| }) |
|
|
| test('link_papers records where a citation comes from', () => { |
| const ctx = newCtx() |
| addPapers(ctx, { papers: [paper('a'), paper('b', { near: 'a' }), paper('c', { near: 'a' })] }) |
| const result = linkPapers(ctx, { |
| links: [ |
| { from: 'a', to: 'b', kind: 'cites', source: 'openalex' }, |
| { from: 'b', to: 'c', kind: 'cites', source: 'pubmed' }, |
| { from: 'c', to: 'a', kind: 'cites' }, |
| ], |
| }) |
| assert.equal(result.linked.length, 3) |
| const by = (from: string, to: string) => |
| (all(ctx).find((r) => r.id === linkShapeId(from, to, 'cites')) as TLShape).meta.by |
| assert.deepEqual([by('a', 'b'), by('b', 'c'), by('c', 'a')], ['openalex', 'pubmed', 'pubmed']) |
| assert.deepEqual( |
| getBoard(ctx) |
| .links.map((l) => [l.from, l.to, l.by]) |
| .sort(), |
| [ |
| ['a', 'b', 'openalex'], |
| ['b', 'c', 'pubmed'], |
| ['c', 'a', 'pubmed'], |
| ] |
| ) |
| }) |
|
|
| test('link_papers records a similar link as the agent’s, even when given a source', () => { |
| const ctx = newCtx() |
| addPapers(ctx, { papers: [paper('a'), paper('b', { near: 'a' })] }) |
| linkPapers(ctx, { links: [{ from: 'a', to: 'b', kind: 'similar', source: 'openalex' }] }) |
| assert.deepEqual(getBoard(ctx).links.map((l) => l.by), ['agent']) |
| }) |
|
|
| test('mark_working turns the ring on and off', () => { |
| const ctx = newCtx() |
| addPapers(ctx, { papers: [paper('a'), paper('b')] }) |
| assert.deepEqual(markWorking(ctx, { paperIds: ['a', 'b', 'x'], on: false }), { |
| ok: true, |
| skipped: [{ paperId: 'x', reason: 'no card on this board' }], |
| }) |
| assert.equal(card(ctx, 'a').props.working, false) |
| markWorking(ctx, { paperIds: ['a'], on: true }) |
| assert.equal(card(ctx, 'a').props.working, true) |
| }) |
|
|
| test('add_note writes a note, pinned beside its paper with a note-pin binding', async () => { |
| const ctx = newCtx({ runId: null }) |
| addPapers(ctx, { papers: [paper('a')] }) |
| const pinned = addNote(ctx, { text: 'Check the cohort size', paperId: 'a' }) |
| const loose = addNote(ctx, { text: 'Two programs\nworth a look' }) |
| const second = addNote(ctx, { text: 'Another', paperId: 'a' }) |
| const records = all(ctx) |
| const note = records.find((r) => r.id === pinned.shapeId) as TLShape & { props: { richText: unknown } } |
| assert.equal(note.type, 'note') |
| assert.deepEqual(note.props.richText, { type: 'doc', content: [{ type: 'paragraph', content: [{ type: 'text', text: 'Check the cohort size' }] }] }) |
| assert.deepEqual(note.meta, { createdBy: 'agent', onBehalfOf: 'm_ana', runId: null, paperId: 'a' }) |
| |
| const c = card(ctx, 'a') |
| const drawn = { x: c.x + c.props.w / 2 - CARD_SIZE.w / 2, y: c.y + c.props.h / 2 - CARD_SIZE.h / 2 } |
| assert.deepEqual([note.x, note.y], [drawn.x + CARD_SIZE.w + 24, drawn.y]) |
| const pin = records.find((r): r is TLBinding => r.typeName === 'binding' && r.fromId === pinned.shapeId) |
| assert.equal(pin?.type, 'note-pin') |
| assert.equal(pin?.toId, c.id) |
| assert.deepEqual(pin?.props, { dx: note.x - c.x, dy: note.y - c.y }) |
|
|
| assertApart(records) |
| const board = getBoard(ctx) |
| assert.deepEqual( |
| board.notes.map((n) => [n.shapeId, n.text, n.author, n.pinnedTo]), |
| [ |
| [pinned.shapeId, 'Check the cohort size', 'agent', 'a'], |
| [loose.shapeId, 'Two programs\nworth a look', 'agent', null], |
| [second.shapeId, 'Another', 'agent', 'a'], |
| ] |
| ) |
| assert.equal(board.papers[0].pinnedNotes, 2) |
| await rejects(() => addNote(ctx, { text: 'x', paperId: 'nope' }), /No card for nope/) |
| }) |
|
|
| test('get_board is a compact summary', () => { |
| const ctx = newCtx() |
| addPapers(ctx, { papers: [paper('a', { authors: ['Ana Ibáñez-Molero'], year: 2026 }), paper('s', { kind: 'seed' })] }) |
| setScores(ctx, { paperId: 'a', scores: { methods: { score: 0.5, fit: 'medium', why: 'Partly' } } }) |
| linkPapers(ctx, { links: [{ from: 'a', to: 's', kind: 'similar' }] }) |
| patchShapes(ctx.boardId, [{ id: card(ctx, 'a').id, props: { status: 'discarded' } }]) |
| const board = getBoard(ctx) |
| assert.deepEqual(board.goals, ['new-findings', 'methods']) |
| assert.deepEqual(board.papers.map((p) => p.paperId), ['s', 'a']) |
| assert.deepEqual(board.papers[1], { |
| paperId: 'a', |
| label: 'Ibáñez-Molero 2026', |
| title: 'Paper a', |
| year: 2026, |
| type: 'other', |
| kind: 'suggestion', |
| status: 'discarded', |
| scores: { methods: { score: 0.5, fit: 'medium' } }, |
| working: true, |
| cluster: null, |
| humanTouched: false, |
| pinnedNotes: 0, |
| }) |
| assert.deepEqual(board.links, [{ from: 'a', to: 's', kind: 'similar', label: '', by: 'agent' }]) |
| assert.deepEqual(board.discardedIds, ['a']) |
| }) |
|
|
