diff --git a/desktop/electron/e2e/app.spec.ts b/desktop/electron/e2e/app.spec.ts index 1d6ddbaf..4d280749 100644 --- a/desktop/electron/e2e/app.spec.ts +++ b/desktop/electron/e2e/app.spec.ts @@ -731,6 +731,179 @@ test('read: Cite keeps Scholar and OpenAlex provenance separate', async () => { } }); +test('read: Discovery uses contextual saved and recent search navigation', async () => { + await dismissConnectModal(); + const originals = await page.evaluate(() => { + const libraryKey = 'termipod.library.v1'; + const historyKey = 'termipod.discover.history.v1'; + const originalLibrary = localStorage.getItem(libraryKey); + const originalHistory = localStorage.getItem(historyKey); + localStorage.setItem(libraryKey, JSON.stringify({ + references: [{ + id: 'ref-discovery-rail', + type: 'article', + title: 'Library rail fixture', + authors: ['TermiPod'], + tags: ['library-only-tag'], + collectionIds: ['collection-only'], + notes: '', + addedAt: Date.now(), + dirty: false, + attachments: [], + }], + collections: [{ id: 'collection-only', name: 'Library-only collection' }], + })); + localStorage.setItem(historyKey, JSON.stringify({ + version: 1, + saved: [{ + id: 'saved-e2e', + name: 'Saved core query', + query: 'saved discovery query', + sourceId: 'core', + authorFilter: 'Researcher', + yearFrom: '2024', + yearTo: '', + sort: 'newest', + findPdfs: false, + savedAt: Date.now() - 2000, + }], + recent: [{ + id: 'recent-e2e', + query: 'recent discovery query', + sourceId: 'openalex', + authorFilter: '', + yearFrom: '', + yearTo: '', + sort: 'relevance', + findPdfs: true, + ranAt: Date.now() - 1000, + resultCount: 17, + }], + })); + return { originalLibrary, originalHistory }; + }); + + try { + await page.reload({ waitUntil: 'domcontentloaded' }); + await dismissConnectModal(); + await page.locator('[data-job="read"]').click(); + await page.getByRole('button', { name: 'Discover', exact: true }).click(); + + const rail = page.locator('.discover-nav'); + await expect(rail).toBeVisible(); + await expect(rail.getByText('Saved core query', { exact: true })).toBeVisible(); + await expect(rail.getByText('recent discovery query', { exact: true })).toBeVisible(); + await expect(rail.getByText('Recent searches', { exact: true })).toBeVisible(); + await expect(page.getByText('Library-only collection', { exact: true })).toHaveCount(0); + await expect(page.getByText('library-only-tag', { exact: true })).toHaveCount(0); + + await rail.locator('.discover-nav-row').filter({ hasText: 'Saved core query' }).locator('.discover-nav-main').click(); + await expect(page.locator('.discover-input')).toHaveValue('saved discovery query'); + await expect(page.locator('.discover-src.active')).toHaveText('CORE'); + await expect(page.getByRole('button', { name: 'Remove saved search', exact: true })).toBeVisible(); + + await page.locator('.discover-input').fill('a newly saved query'); + await page.locator('.discover-save-search').click(); + await expect(rail.getByText('a newly saved query', { exact: true })).toBeVisible(); + await expect(page.locator('.discover-save-search')).toHaveAttribute( + 'aria-label', + 'Remove saved search', + ); + await page.locator('.discover-save-search').click(); + await expect(rail.getByText('a newly saved query', { exact: true })).toHaveCount(0); + + await rail.getByRole('button', { name: 'Clear', exact: true }).click(); + await expect(rail.getByText('recent discovery query', { exact: true })).toHaveCount(0); + const persisted = await page.evaluate(() => JSON.parse(localStorage.getItem('termipod.discover.history.v1') ?? '{}')); + expect(persisted.recent).toEqual([]); + expect(persisted.saved).toHaveLength(1); + } finally { + await page.evaluate(({ originalLibrary, originalHistory }) => { + if (originalLibrary === null) localStorage.removeItem('termipod.library.v1'); + else localStorage.setItem('termipod.library.v1', originalLibrary); + if (originalHistory === null) localStorage.removeItem('termipod.discover.history.v1'); + else localStorage.setItem('termipod.discover.history.v1', originalHistory); + }, originals); + await page.reload({ waitUntil: 'domcontentloaded' }); + } +}); + +test('read: Discovery monitoring exposes updates, subscriptions, schedules, and collection recommendations', async () => { + await dismissConnectModal(); + const originals = await page.evaluate(() => { + const keys = ['termipod.library.v1', 'termipod.discover.history.v1', 'termipod.discover.monitor.v1']; + const values = Object.fromEntries(keys.map((key) => [key, localStorage.getItem(key)])); + localStorage.setItem('termipod.library.v1', JSON.stringify({ + collections: [{ id: 'collection-monitor', name: 'Graph research' }], + references: [{ + id: 'reference-monitor', type: 'article', title: 'Graph learning for molecules', authors: ['Ada Researcher'], + venue: 'Graph Journal', rating: 5, topics: ['Graph learning'], tags: ['molecules'], + collectionIds: ['collection-monitor'], notes: '', addedAt: Date.now(), dirty: false, attachments: [], + }], + })); + localStorage.setItem('termipod.discover.history.v1', JSON.stringify({ + version: 1, + recent: [], + saved: [{ + id: 'saved-monitor', name: 'Saved graph query', query: 'graph learning', sourceId: 'openalex', + authorFilter: '', yearFrom: '', yearTo: '', sort: 'newest', findPdfs: false, savedAt: Date.now(), + }], + })); + localStorage.setItem('termipod.discover.monitor.v1', JSON.stringify({ + version: 1, + subscriptions: [{ + id: 'subscription-monitor', kind: 'topic', label: 'Graph learning', value: 'graph learning', + sourceId: 'openalex', cadence: 'weekly', createdAt: Date.now(), + }], + updates: [{ + id: 'update-monitor', originType: 'subscription', originId: 'subscription-monitor', + originLabel: 'Graph learning', arrivedAt: Date.now(), + paper: { paperId: 'paper-monitor', title: 'A new graph paper', authors: ['A. Author'], year: 2026, venue: 'Graph Journal' }, + }], + runs: { + 'subscription:subscription-monitor': { lastRunAt: Date.now(), seen: ['id:paper-monitor'] }, + }, + lastRefreshAt: Date.now(), + })); + return values; + }); + + try { + await page.reload({ waitUntil: 'domcontentloaded' }); + await dismissConnectModal(); + await page.locator('[data-job="read"]').click(); + await page.getByRole('button', { name: 'Discover', exact: true }).click(); + + const rail = page.locator('.discover-nav'); + await expect(rail.getByRole('button', { name: /Updates/ })).toContainText('1'); + await rail.getByRole('button', { name: /Updates/ }).click(); + await expect(page.getByRole('heading', { name: 'Updates' })).toBeVisible(); + await expect(page.getByText('A new graph paper', { exact: true })).toBeVisible(); + await page.getByRole('button', { name: 'Mark read', exact: true }).click(); + await expect(rail.locator('.discover-nav-count')).toHaveCount(0); + + await rail.getByRole('button', { name: 'Following', exact: true }).click(); + await expect(page.getByText('Graph learning', { exact: true })).toBeVisible(); + await page.getByRole('button', { name: 'Monitors', exact: true }).click(); + await expect(page.getByRole('heading', { name: 'Scheduled saved searches' })).toBeVisible(); + await expect(page.getByText('Saved graph query', { exact: true })).toBeVisible(); + + await rail.getByRole('button', { name: 'For you', exact: true }).click(); + await page.getByLabel('Seed collection').selectOption('collection-monitor'); + await expect(page.getByText('Seeded by 1 collection items', { exact: true })).toBeVisible(); + await expect(page.locator('.discovery-recommend-explain')).toContainText('graph'); + await expect(page.locator('.discovery-recommend-explain')).toContainText('molecules'); + } finally { + await page.evaluate((values) => { + for (const [key, value] of Object.entries(values)) { + if (value === null) localStorage.removeItem(key); + else localStorage.setItem(key, value); + } + }, originals); + await page.reload({ waitUntil: 'domcontentloaded' }); + } +}); + test('read: PDF frequent actions stay visible and the outline folds by level', async () => { await dismissConnectModal(); const fixture = await page.evaluate(async ({ bytes }) => { diff --git a/desktop/electron/src/ipc/discovery.test.ts b/desktop/electron/src/ipc/discovery.test.ts index 72a609f9..5e05c885 100644 --- a/desktop/electron/src/ipc/discovery.test.ts +++ b/desktop/electron/src/ipc/discovery.test.ts @@ -1,6 +1,6 @@ import assert from 'node:assert/strict'; import { test } from 'node:test'; -import { discoveryHandlers } from './discovery.ts'; +import { discoveryHandlers, fetchPublicJson, socialUrl } from './discovery.ts'; test('SerpAPI transport fixes the Scholar endpoint and returns structured JSON', async () => { const originalFetch = globalThis.fetch; @@ -82,3 +82,94 @@ test('SerpAPI citations transport rejects malformed ids before network access', /valid cites id is required/, ); }); + +test('RSS transport accepts a public HTTP feed and returns bounded text', async () => { + const originalFetch = globalThis.fetch; + let requested = ''; + globalThis.fetch = (async (input) => { + requested = String(input); + return new Response('Research', { status: 200 }); + }) as typeof fetch; + try { + const out = await discoveryHandlers.discovery_fetch_feed( + { url: 'https://93.184.216.34/research.xml', proxy: null }, + {} as never, + ); + assert.equal(requested, 'https://93.184.216.34/research.xml'); + assert.deepEqual(out, { + url: 'https://93.184.216.34/research.xml', + text: 'Research', + }); + } finally { + globalThis.fetch = originalFetch; + } +}); + +test('RSS transport refuses loopback and private-network URLs before fetch', async () => { + let fetched = false; + const originalFetch = globalThis.fetch; + globalThis.fetch = (async () => { + fetched = true; + return new Response('unexpected'); + }) as typeof fetch; + try { + for (const url of ['http://127.0.0.1/feed', 'http://10.0.0.2/rss', 'file:///tmp/feed.xml']) { + await assert.rejects( + async () => discoveryHandlers.discovery_fetch_feed({ url, proxy: null }, {} as never), + /not allowed|only HTTP/, + ); + } + assert.equal(fetched, false); + } finally { + globalThis.fetch = originalFetch; + } +}); + +test('RSS transport revalidates redirects so a public feed cannot bounce into loopback', async () => { + const originalFetch = globalThis.fetch; + let requests = 0; + globalThis.fetch = (async () => { + requests += 1; + return new Response(null, { status: 302, headers: { location: 'http://127.0.0.1/private-feed' } }); + }) as typeof fetch; + try { + await assert.rejects( + async () => discoveryHandlers.discovery_fetch_feed({ url: 'https://93.184.216.34/feed', proxy: null }, {} as never), + /private hosts are not allowed/, + ); + assert.equal(requests, 1); + } finally { + globalThis.fetch = originalFetch; + } +}); + +test('social connector URLs keep X credentials out of the query and apply monitor filters', () => { + const x = socialUrl('x-author', '@researcher', 'en', true); + assert.ok(x !== null); + assert.equal(x.origin + x.pathname, 'https://api.x.com/2/tweets/search/recent'); + assert.equal(x.searchParams.get('query'), 'from:researcher -is:retweet lang:en'); + assert.equal(x.searchParams.has('api_key'), false); + + const bluesky = socialUrl('bluesky-query', 'agent memory', 'zh', true); + assert.ok(bluesky !== null); + assert.equal(bluesky.searchParams.get('q'), 'agent memory'); + assert.equal(bluesky.searchParams.get('lang'), 'zh'); +}); + +test('credentialed social fetch refuses a cross-origin redirect before leaking the bearer token', async () => { + const originalFetch = globalThis.fetch; + let requests = 0; + globalThis.fetch = (async () => { + requests += 1; + return new Response(null, { status: 302, headers: { location: 'https://198.51.100.1/steal' } }); + }) as typeof fetch; + try { + await assert.rejects( + async () => fetchPublicJson('https://93.184.216.34/posts', null, 'social', { Authorization: 'Bearer secret' }), + /cross-origin redirect refused/, + ); + assert.equal(requests, 1); + } finally { + globalThis.fetch = originalFetch; + } +}); diff --git a/desktop/electron/src/ipc/discovery.ts b/desktop/electron/src/ipc/discovery.ts index ebb7ff2c..9c10046b 100644 --- a/desktop/electron/src/ipc/discovery.ts +++ b/desktop/electron/src/ipc/discovery.ts @@ -5,9 +5,79 @@ import { serpApiCitationsUrl, serpApiSearchUrl } from '../../../src/discovery/serpApiCore.ts'; import type { Handler } from './dispatch'; import { proxyFetch } from './net.ts'; +import { isIP } from 'node:net'; +import { lookup } from 'node:dns/promises'; const RESPONSE_CAP = 5 * 1024 * 1024; const TIMEOUT_MS = 45_000; +const FEED_RESPONSE_CAP = 3 * 1024 * 1024; + +function privateAddress(address: string): boolean { + const normalized = address.toLocaleLowerCase(); + if (normalized === '::1' || normalized === '::' || normalized.startsWith('fe80:') || normalized.startsWith('fc') || normalized.startsWith('fd')) return true; + const parts = normalized.split('.').map(Number); + if (parts.length !== 4 || parts.some((part) => !Number.isInteger(part))) return false; + return parts[0] === 10 || + parts[0] === 127 || + parts[0] === 0 || + (parts[0] === 169 && parts[1] === 254) || + (parts[0] === 172 && (parts[1] ?? 0) >= 16 && (parts[1] ?? 0) <= 31) || + (parts[0] === 192 && parts[1] === 168) || + (parts[0] === 100 && (parts[1] ?? 0) >= 64 && (parts[1] ?? 0) <= 127) || + parts[0] >= 224; +} + +async function publicFeedUrl(raw: string): Promise { + let url: URL; + try { + url = new URL(raw); + } catch { + throw new Error('discovery_fetch_feed: valid URL is required'); + } + if (url.protocol !== 'https:' && url.protocol !== 'http:') throw new Error('discovery_fetch_feed: only HTTP(S) is allowed'); + const hostname = url.hostname.toLocaleLowerCase(); + if (hostname === 'localhost' || hostname.endsWith('.localhost') || hostname.endsWith('.local')) { + throw new Error('discovery_fetch_feed: private hosts are not allowed'); + } + if (isIP(hostname) !== 0) { + if (privateAddress(hostname)) throw new Error('discovery_fetch_feed: private hosts are not allowed'); + } else { + const addresses = await lookup(hostname, { all: true }); + if (addresses.length === 0 || addresses.some(({ address }) => privateAddress(address))) { + throw new Error('discovery_fetch_feed: private hosts are not allowed'); + } + } + url.hash = ''; + return url.toString(); +} + +async function fetchPublicFeed( + rawUrl: string, + proxy: string | null, + headers: Record = { Accept: 'application/atom+xml, application/rss+xml, application/xml, text/xml, */*;q=0.2' }, +): Promise<{ response: Response; url: string }> { + let url = rawUrl; + for (let redirects = 0; redirects <= 5; redirects += 1) { + url = await publicFeedUrl(url); + const requestOrigin = new URL(url).origin; + const response = await proxyFetch(url, { + method: 'GET', + headers, + redirect: 'manual', + signal: AbortSignal.timeout(TIMEOUT_MS), + }, proxy); + if (response.status < 300 || response.status >= 400) return { response, url }; + const location = response.headers.get('location'); + await response.body?.cancel().catch(() => undefined); + if (location === null) throw new Error('discovery_fetch_feed: redirect has no location'); + const redirected = new URL(location, url); + if (headers.Authorization !== undefined && redirected.origin !== requestOrigin) { + throw new Error('discovery_social_fetch: credentialed cross-origin redirect refused'); + } + url = redirected.toString(); + } + throw new Error('discovery_fetch_feed: too many redirects'); +} async function fetchSerpApiJson(url: string, proxy: string | null, operation: string): Promise { const res = await proxyFetch( @@ -35,7 +105,150 @@ async function fetchSerpApiJson(url: string, proxy: string | null, operation: st } } +export async function fetchPublicJson( + rawUrl: string, + proxy: string | null, + operation: string, + headers: Record = {}, +): Promise { + const { response: res } = await fetchPublicFeed(rawUrl, proxy, { + Accept: 'application/json', + ...headers, + }); + const declared = Number(res.headers.get('content-length') ?? '0'); + if (Number.isFinite(declared) && declared > RESPONSE_CAP) { + await res.body?.cancel().catch(() => undefined); + throw new Error(`${operation}: response exceeds 5 MB`); + } + const bytes = new Uint8Array(await res.arrayBuffer()); + if (bytes.byteLength > RESPONSE_CAP) throw new Error(`${operation}: response exceeds 5 MB`); + if (!res.ok) throw new Error(`${operation}: HTTP ${res.status}`); + try { + return JSON.parse(new TextDecoder().decode(bytes)) as unknown; + } catch { + throw new Error(`${operation}: invalid JSON response`); + } +} + +function mastodonTarget(raw: string, kind: 'author' | 'tag'): { origin: string; value: string } { + const value = raw.trim(); + try { + const url = new URL(value); + if (url.protocol !== 'https:' && url.protocol !== 'http:') throw new Error('protocol'); + const parts = url.pathname.split('/').filter(Boolean); + if (kind === 'author') { + const handle = parts.find((part) => part.startsWith('@'))?.slice(1); + if (handle !== undefined && handle !== '') return { origin: url.origin, value: handle }; + } else { + const tagIndex = parts.findIndex((part) => part === 'tags'); + const tag = tagIndex >= 0 ? parts[tagIndex + 1] : undefined; + if (tag !== undefined && tag !== '') return { origin: url.origin, value: tag.replace(/^#/, '') }; + } + } catch { + // Fall through to the compact user@instance / tag@instance syntax. + } + const compact = value.replace(/^[@#]/, ''); + const split = compact.lastIndexOf('@'); + if (split <= 0 || split === compact.length - 1) { + throw new Error(`discovery_social_fetch: Mastodon ${kind} must include its instance`); + } + return { origin: `https://${compact.slice(split + 1)}`, value: compact.slice(0, split) }; +} + +export function socialUrl(provider: string, value: string, language: string, excludeReposts: boolean): URL | null { + if (provider === 'bluesky-author') { + const url = new URL('https://public.api.bsky.app/xrpc/app.bsky.feed.getAuthorFeed'); + url.searchParams.set('actor', value.replace(/^@/, '')); + url.searchParams.set('filter', excludeReposts ? 'posts_no_replies' : 'posts_with_replies'); + url.searchParams.set('limit', '50'); + return url; + } + if (provider === 'bluesky-feed') { + const url = new URL('https://public.api.bsky.app/xrpc/app.bsky.feed.getFeed'); + url.searchParams.set('feed', value); + url.searchParams.set('limit', '50'); + return url; + } + if (provider === 'bluesky-query') { + const url = new URL('https://public.api.bsky.app/xrpc/app.bsky.feed.searchPosts'); + url.searchParams.set('q', value); + if (language !== '') url.searchParams.set('lang', language); + url.searchParams.set('limit', '50'); + return url; + } + if (provider === 'x-author' || provider === 'x-query') { + const url = new URL('https://api.x.com/2/tweets/search/recent'); + const base = provider === 'x-author' ? `from:${value.replace(/^@/, '')}` : value; + const parts = [base]; + if (excludeReposts) parts.push('-is:retweet'); + if (language !== '') parts.push(`lang:${language}`); + url.searchParams.set('query', parts.join(' ')); + url.searchParams.set('max_results', '50'); + url.searchParams.set('expansions', 'author_id'); + url.searchParams.set('tweet.fields', 'author_id,created_at,lang,public_metrics,entities,referenced_tweets'); + url.searchParams.set('user.fields', 'id,name,username,profile_image_url'); + return url; + } + return null; +} + export const discoveryHandlers: Record = { + discovery_fetch_feed: async (args): Promise => { + const rawUrl = typeof args.url === 'string' ? args.url.trim() : ''; + const proxy = typeof args.proxy === 'string' && args.proxy !== '' ? args.proxy : null; + const { response: res, url } = await fetchPublicFeed(rawUrl, proxy); + const declared = Number(res.headers.get('content-length') ?? '0'); + if (Number.isFinite(declared) && declared > FEED_RESPONSE_CAP) { + await res.body?.cancel().catch(() => undefined); + throw new Error('discovery_fetch_feed: response exceeds 3 MB'); + } + const bytes = new Uint8Array(await res.arrayBuffer()); + if (bytes.byteLength > FEED_RESPONSE_CAP) throw new Error('discovery_fetch_feed: response exceeds 3 MB'); + if (!res.ok) throw new Error(`discovery_fetch_feed: HTTP ${res.status}`); + return { url: res.url || url, text: new TextDecoder().decode(bytes) }; + }, + discovery_social_fetch: async (args): Promise => { + const provider = typeof args.provider === 'string' ? args.provider : ''; + const value = typeof args.value === 'string' ? args.value.trim() : ''; + const language = typeof args.language === 'string' ? args.language.trim().toLocaleLowerCase() : ''; + const excludeReposts = args.excludeReposts !== false; + const proxy = typeof args.proxy === 'string' && args.proxy !== '' ? args.proxy : null; + const apiKey = typeof args.apiKey === 'string' ? args.apiKey.trim() : ''; + if (value === '') throw new Error('discovery_social_fetch: target is required'); + + const url = socialUrl(provider, value, language, excludeReposts); + if (url !== null) { + const headers: Record = {}; + if (provider.startsWith('x-')) { + if (apiKey === '') throw new Error('discovery_social_fetch: X bearer token is required'); + headers.Authorization = `Bearer ${apiKey}`; + } + return fetchPublicJson(url.toString(), proxy, 'discovery_social_fetch', headers); + } + + if (provider === 'mastodon-author') { + const target = mastodonTarget(value, 'author'); + const lookupUrl = new URL('/api/v1/accounts/lookup', target.origin); + lookupUrl.searchParams.set('acct', target.value); + const account = await fetchPublicJson(lookupUrl.toString(), proxy, 'discovery_social_fetch') as Record; + const id = typeof account.id === 'string' ? account.id : ''; + if (id === '') throw new Error('discovery_social_fetch: Mastodon account not found'); + const statusesUrl = new URL(`/api/v1/accounts/${encodeURIComponent(id)}/statuses`, target.origin); + statusesUrl.searchParams.set('limit', '40'); + statusesUrl.searchParams.set('exclude_reblogs', excludeReposts ? 'true' : 'false'); + statusesUrl.searchParams.set('exclude_replies', 'true'); + const statuses = await fetchPublicJson(statusesUrl.toString(), proxy, 'discovery_social_fetch'); + return { account, statuses }; + } + if (provider === 'mastodon-tag') { + const target = mastodonTarget(value, 'tag'); + const timelineUrl = new URL(`/api/v1/timelines/tag/${encodeURIComponent(target.value)}`, target.origin); + timelineUrl.searchParams.set('limit', '40'); + const statuses = await fetchPublicJson(timelineUrl.toString(), proxy, 'discovery_social_fetch'); + return { tag: target.value, statuses }; + } + throw new Error('discovery_social_fetch: unsupported provider'); + }, serpapi_search: async (args): Promise => { const query = typeof args.query === 'string' ? args.query.trim() : ''; const apiKey = typeof args.apiKey === 'string' ? args.apiKey.trim() : ''; diff --git a/desktop/src/App.tsx b/desktop/src/App.tsx index d3c22dd0..36d596c4 100644 --- a/desktop/src/App.tsx +++ b/desktop/src/App.tsx @@ -1,5 +1,7 @@ +import { useEffect } from 'react'; import { useApplyAppearance } from './state/appearance'; import { useApplyTheme } from './state/theme'; +import { startDiscoveryScheduler } from './state/discoveryMonitor'; import { AppShell } from './ui/AppShell'; /// The shell renders always — even without a hub connection — so the terminal, @@ -9,5 +11,6 @@ import { AppShell } from './ui/AppShell'; export function App(): JSX.Element { useApplyTheme(); useApplyAppearance(); + useEffect(() => startDiscoveryScheduler(), []); return ; } diff --git a/desktop/src/discovery/index.ts b/desktop/src/discovery/index.ts index 29fcb0e2..30666778 100644 --- a/desktop/src/discovery/index.ts +++ b/desktop/src/discovery/index.ts @@ -1,7 +1,7 @@ import { searchArxiv } from './arxiv'; import { CORE_KEY, searchCore } from './core'; import { searchCrossref } from './crossref'; -import { searchOpenAlex } from './openAlex'; +import { loadOpenAlexCitations, searchOpenAlex } from './openAlex'; import { searchPubmed } from './pubmed'; import { loadGoogleScholarCitations, searchGoogleScholar } from './serpApi'; import { S2_KEY, searchSemanticScholar } from './semanticScholar'; @@ -20,6 +20,7 @@ export { enrichWithUnpaywall } from './unpaywall'; export { scrapeMetadata, detectIdentifier, type ScrapePatch, type ScrapeSeed } from './scrape'; export { isLikelySameWork } from './scrapeMatch'; export { loadGoogleScholarCitations, searchGoogleScholar }; +export { loadOpenAlexCitations }; /// The discovery source registry — the single source of truth the Read/Discover /// picker renders. OpenAlex is first (free, keyless, most generous → the default); diff --git a/desktop/src/discovery/openAlex.ts b/desktop/src/discovery/openAlex.ts index 63ddf922..b8344bdf 100644 --- a/desktop/src/discovery/openAlex.ts +++ b/desktop/src/discovery/openAlex.ts @@ -47,6 +47,28 @@ function mapWork(w: Record): DiscoveryPaper { }; } +async function resolveOpenAlexWorkId(seed: string): Promise { + const trimmed = seed.trim(); + const direct = trimmed.match(/(?:https?:\/\/openalex\.org\/)?(W\d+)/i)?.[1]; + if (direct !== undefined) return direct.toLocaleUpperCase(); + const doi = trimmed.replace(/^https?:\/\/(?:dx\.)?doi\.org\//i, ''); + if (doi === '') throw new Error('citation-subscription-needs-id'); + const url = `https://api.openalex.org/works/${encodeURIComponent(`https://doi.org/${doi}`)}?mailto=${CONTACT}`; + const work = (await getJson(url)) as Record; + const id = typeof work.id === 'string' ? work.id.match(/W\d+$/i)?.[0] : undefined; + if (id === undefined) throw new Error('citation-subscription-not-found'); + return id.toLocaleUpperCase(); +} + +export async function loadOpenAlexCitations(seed: string, limit: number): Promise { + const workId = await resolveOpenAlexWorkId(seed); + const filter = encodeURIComponent(`cites:${workId}`); + const url = `https://api.openalex.org/works?filter=${filter}&sort=publication_date:desc&per-page=${limit}&mailto=${CONTACT}`; + const json = (await getJson(url)) as Record; + const results = Array.isArray(json.results) ? json.results : []; + return results.map((work) => mapWork(work as Record)).filter((paper) => paper.title !== ''); +} + export async function searchOpenAlex(query: string, limit: number): Promise { const url = `https://api.openalex.org/works?search=${encodeURIComponent(query)}&per-page=${limit}&mailto=${CONTACT}`; const j = (await getJson(url)) as Record; diff --git a/desktop/src/discovery/rss.ts b/desktop/src/discovery/rss.ts new file mode 100644 index 00000000..f040834b --- /dev/null +++ b/desktop/src/discovery/rss.ts @@ -0,0 +1,130 @@ +import { invoke, isShell } from '../bridge'; +import { proxyForConnection } from '../state/proxy'; +import type { DiscoveryPaper } from './types'; + +interface FeedPayload { + url: string; + text: string; +} + +export interface ParsedDiscoveryFeed { + title: string; + url: string; + papers: DiscoveryPaper[]; +} + +function child(element: Element, localName: string): Element | undefined { + return [...element.children].find((candidate) => candidate.localName.toLocaleLowerCase() === localName); +} + +function children(element: Element, localName: string): Element[] { + return [...element.children].filter((candidate) => candidate.localName.toLocaleLowerCase() === localName); +} + +function text(element: Element, ...names: string[]): string | undefined { + for (const name of names) { + const value = child(element, name)?.textContent?.replace(/\s+/g, ' ').trim(); + if (value !== undefined && value !== '') return value; + } + return undefined; +} + +function plainText(value: string | undefined): string | undefined { + if (value === undefined || value === '') return undefined; + const parsed = new DOMParser().parseFromString(value, 'text/html').body.textContent?.replace(/\s+/g, ' ').trim(); + return parsed === undefined || parsed === '' ? undefined : parsed; +} + +function year(value: string | undefined): number | undefined { + if (value === undefined) return undefined; + const timestamp = Date.parse(value); + return Number.isFinite(timestamp) ? new Date(timestamp).getUTCFullYear() : undefined; +} + +function publishedAt(value: string | undefined): number | undefined { + if (value === undefined) return undefined; + const parsed = Date.parse(value); + return Number.isFinite(parsed) ? parsed : undefined; +} + +function atomLink(entry: Element): string | undefined { + const links = children(entry, 'link'); + const preferred = links.find((link) => (link.getAttribute('rel') ?? 'alternate') === 'alternate') ?? links[0]; + return preferred?.getAttribute('href') ?? preferred?.textContent?.trim() ?? undefined; +} + +function rssAuthors(entry: Element): string[] { + const values = [text(entry, 'author'), text(entry, 'creator')].filter((value): value is string => value !== undefined); + return values.flatMap((value) => value.split(/\s*[,;]\s*/)).filter(Boolean); +} + +function atomAuthors(entry: Element): string[] { + return children(entry, 'author') + .map((author) => text(author, 'name') ?? author.textContent?.trim() ?? '') + .filter(Boolean); +} + +export function parseDiscoveryFeed(xml: string, feedUrl: string): ParsedDiscoveryFeed { + const doc = new DOMParser().parseFromString(xml, 'application/xml'); + if (doc.querySelector('parsererror') !== null) throw new Error('Invalid RSS or Atom feed'); + const root = doc.documentElement; + const atom = root.localName.toLocaleLowerCase() === 'feed'; + const container = atom ? root : child(root, 'channel') ?? root; + const feedTitle = text(container, 'title') ?? new URL(feedUrl).hostname; + const entries = atom ? children(container, 'entry') : children(container, 'item'); + const papers = entries.map((entry): DiscoveryPaper | null => { + const title = text(entry, 'title') ?? ''; + if (title === '') return null; + const url = atom ? atomLink(entry) : text(entry, 'link'); + const nativeId = text(entry, 'id', 'guid') ?? url ?? title; + const published = text(entry, 'published', 'updated', 'pubdate', 'date'); + const summary = plainText(text(entry, 'summary', 'description', 'content')); + return { + paperId: `rss:${nativeId}`, + title, + authors: atom ? atomAuthors(entry) : rssAuthors(entry), + year: year(published), + publishedAt: publishedAt(published), + venue: feedTitle, + abstract: summary, + url, + }; + }).filter((paper): paper is DiscoveryPaper => paper !== null); + return { title: feedTitle, url: feedUrl, papers }; +} + +export async function fetchDiscoveryFeed(url: string): Promise { + const fetchPayload = async (target: string): Promise => { + if (isShell()) { + return invoke('discovery_fetch_feed', { + url: target, + proxy: proxyForConnection('discovery') ?? null, + }); + } + const response = await fetch(target, { + headers: { Accept: 'application/atom+xml, application/rss+xml, application/xml, text/xml, text/html;q=0.8' }, + signal: AbortSignal.timeout(45_000), + }); + if (!response.ok) throw new Error(`RSS: HTTP ${response.status}`); + return { url: response.url || target, text: await response.text() }; + }; + + let payload: FeedPayload; + payload = await fetchPayload(url); + try { + return parseDiscoveryFeed(payload.text, payload.url); + } catch (error) { + // Accept a normal website URL in the subscription form and discover its + // advertised RSS/Atom feed. The second request still goes through the + // native SSRF/redirect checks used by direct feeds. + const html = new DOMParser().parseFromString(payload.text, 'text/html'); + const link = [...html.querySelectorAll('link[rel~="alternate"]')].find((candidate) => { + const type = candidate.type.toLocaleLowerCase(); + return type.includes('rss') || type.includes('atom') || type.includes('xml'); + }); + if (link?.href === undefined || link.href === '') throw error; + const discoveredUrl = new URL(link.getAttribute('href') ?? link.href, payload.url).toString(); + const discovered = await fetchPayload(discoveredUrl); + return parseDiscoveryFeed(discovered.text, discovered.url); + } +} diff --git a/desktop/src/discovery/social.ts b/desktop/src/discovery/social.ts new file mode 100644 index 00000000..528e7115 --- /dev/null +++ b/desktop/src/discovery/social.ts @@ -0,0 +1,204 @@ +import { invoke } from '../bridge'; +import { isShell } from '../platform'; +import { getXBearerToken } from '../state/discoverySecrets'; +import { proxyForConnection } from '../state/proxy'; +import type { + DiscoveryResult, + DiscoverySocialPost, + DiscoverySubscription, + DiscoverySubscriptionGroup, + DiscoverySubscriptionKind, +} from '../state/discoveryMonitorCore'; +import { fetchDiscoveryFeed } from './rss'; + +type Row = Record; + +function row(value: unknown): Row { + return value !== null && typeof value === 'object' ? value as Row : {}; +} + +function rows(value: unknown): Row[] { + return Array.isArray(value) ? value.filter((entry): entry is Row => entry !== null && typeof entry === 'object') : []; +} + +function str(value: unknown): string | undefined { + return typeof value === 'string' && value.trim() !== '' ? value.trim() : undefined; +} + +function num(value: unknown): number | undefined { + return typeof value === 'number' && Number.isFinite(value) ? value : undefined; +} + +function timestamp(value: unknown): number | undefined { + const parsed = typeof value === 'string' ? Date.parse(value) : NaN; + return Number.isFinite(parsed) ? parsed : undefined; +} + +function plainText(value: string): string { + return value + .replace(//gi, '\n') + .replace(/<[^>]+>/g, '') + .replace(/ /gi, ' ') + .replace(/&/gi, '&') + .replace(/</gi, '<') + .replace(/>/gi, '>') + .replace(/"/gi, '"') + .replace(/'/gi, "'") + .trim(); +} + +function blueskyPosts(payload: unknown): DiscoverySocialPost[] { + return rows(row(payload).feed).flatMap((entry) => { + const post = row(entry.post); + const author = row(post.author); + const record = row(post.record); + const id = str(post.uri); + const text = str(record.text); + const handle = str(author.handle); + if (id === undefined || text === undefined || handle === undefined) return []; + const rkey = id.split('/').at(-1) ?? ''; + return [{ + id, + platform: 'bluesky' as const, + author: str(author.displayName) ?? handle, + handle: `@${handle}`, + text, + url: `https://bsky.app/profile/${handle}/post/${rkey}`, + publishedAt: timestamp(record.createdAt), + language: Array.isArray(record.langs) ? str(record.langs[0]) : undefined, + avatarUrl: str(author.avatar), + engagement: { likes: num(post.likeCount), reposts: num(post.repostCount), replies: num(post.replyCount) }, + }]; + }); +} + +function mastodonPosts(payload: unknown): DiscoverySocialPost[] { + const root = row(payload); + const defaultAccount = row(root.account); + return rows(root.statuses).flatMap((status) => { + const account = Object.keys(row(status.account)).length > 0 ? row(status.account) : defaultAccount; + const id = str(status.id); + const url = str(status.url); + const content = str(status.content); + if (id === undefined || url === undefined || content === undefined) return []; + const handle = str(account.acct); + return [{ + id, + platform: 'mastodon' as const, + author: str(account.display_name) ?? handle ?? 'Mastodon', + handle: handle === undefined ? undefined : `@${handle}`, + text: plainText(content), + url, + publishedAt: timestamp(status.created_at), + language: str(status.language), + avatarUrl: str(account.avatar_static) ?? str(account.avatar), + tags: rows(status.tags).map((tag) => str(tag.name)).filter((tag): tag is string => tag !== undefined), + engagement: { likes: num(status.favourites_count), reposts: num(status.reblogs_count), replies: num(status.replies_count) }, + }]; + }); +} + +function xPosts(payload: unknown): DiscoverySocialPost[] { + const root = row(payload); + const users = new Map(rows(row(root.includes).users).map((user) => [str(user.id) ?? '', user])); + return rows(root.data).flatMap((post) => { + const id = str(post.id); + const text = str(post.text); + const author = users.get(str(post.author_id) ?? ''); + const username = str(author?.username); + if (id === undefined || text === undefined || username === undefined) return []; + const metrics = row(post.public_metrics); + const hashtags = rows(row(post.entities).hashtags).map((tag) => str(tag.tag)).filter((tag): tag is string => tag !== undefined); + return [{ + id, + platform: 'x' as const, + author: str(author?.name) ?? username, + handle: `@${username}`, + text, + url: `https://x.com/${username}/status/${id}`, + publishedAt: timestamp(post.created_at), + language: str(post.lang), + avatarUrl: str(author?.profile_image_url), + tags: hashtags, + engagement: { + likes: num(metrics.like_count), + reposts: num(metrics.retweet_count), + replies: num(metrics.reply_count), + }, + }]; + }); +} + +function terms(value: string | undefined): string[] { + return (value ?? '').split(',').map((entry) => entry.trim().toLocaleLowerCase()).filter(Boolean); +} + +function engagement(post: DiscoverySocialPost): number { + return (post.engagement?.likes ?? 0) + (post.engagement?.reposts ?? 0) + (post.engagement?.replies ?? 0); +} + +function filterPosts(posts: DiscoverySocialPost[], subscription: DiscoverySubscription): DiscoverySocialPost[] { + const include = terms(subscription.filters?.include); + const exclude = terms(subscription.filters?.exclude); + const language = subscription.filters?.language?.trim().toLocaleLowerCase() ?? ''; + const minimum = subscription.filters?.minEngagement ?? 0; + return posts.filter((post) => { + const content = `${post.title ?? ''} ${post.text} ${(post.tags ?? []).join(' ')}`.toLocaleLowerCase(); + return (include.length === 0 || include.some((term) => content.includes(term))) && + !exclude.some((term) => content.includes(term)) && + (language === '' || post.language?.toLocaleLowerCase().startsWith(language) === true) && + engagement(post) >= minimum; + }); +} + +export function subscriptionGroup(kind: DiscoverySubscriptionKind): DiscoverySubscriptionGroup { + if (kind === 'rss' || kind === 'bluesky-feed') return 'feeds'; + if (kind === 'bluesky-query' || kind === 'mastodon-tag' || kind === 'x-query') return 'monitors'; + if (kind === 'bluesky-author' || kind === 'mastodon-author' || kind === 'youtube-channel' || kind === 'x-author') return 'social'; + return 'research'; +} + +function youtubeFeedUrl(value: string): string { + const trimmed = value.trim(); + const match = trimmed.match(/(?:youtube\.com\/channel\/)?(UC[\w-]{20,})/i); + const channelId = match?.[1] ?? trimmed; + if (!/^UC[\w-]{20,}$/i.test(channelId)) throw new Error('youtube-channel-id-required'); + return `https://www.youtube.com/feeds/videos.xml?channel_id=${encodeURIComponent(channelId)}`; +} + +export async function fetchSocialSubscription(subscription: DiscoverySubscription): Promise { + if (subscription.kind === 'youtube-channel') { + const feed = await fetchDiscoveryFeed(youtubeFeedUrl(subscription.value)); + const posts: DiscoverySocialPost[] = feed.papers.map((paper) => ({ + id: paper.paperId, + platform: 'youtube', + author: paper.authors[0] ?? feed.title, + title: paper.title, + text: paper.abstract ?? '', + url: paper.url ?? paper.paperId, + publishedAt: paper.publishedAt, + })); + return filterPosts(posts, subscription).map((social) => ({ social })); + } + if (!isShell()) throw new Error('social-connectors-shell-required'); + const needsX = subscription.kind === 'x-author' || subscription.kind === 'x-query'; + const apiKey = needsX ? await getXBearerToken() : ''; + if (needsX && apiKey === '') throw new Error('x-needs-key'); + const payload = await invoke('discovery_social_fetch', { + provider: subscription.kind, + value: subscription.value, + language: subscription.filters?.language ?? '', + excludeReposts: subscription.filters?.excludeReposts ?? true, + apiKey, + proxy: proxyForConnection('discovery') ?? null, + }); + const posts = subscription.kind.startsWith('bluesky-') + ? blueskyPosts(payload) + : subscription.kind.startsWith('mastodon-') ? mastodonPosts(payload) : xPosts(payload); + return filterPosts(posts, subscription).map((social) => ({ social })); +} + +export const SOCIAL_KINDS = new Set([ + 'bluesky-author', 'bluesky-feed', 'bluesky-query', 'mastodon-author', 'mastodon-tag', + 'youtube-channel', 'x-author', 'x-query', +]); diff --git a/desktop/src/discovery/types.ts b/desktop/src/discovery/types.ts index 2581381f..645cceb2 100644 --- a/desktop/src/discovery/types.ts +++ b/desktop/src/discovery/types.ts @@ -6,6 +6,7 @@ export interface DiscoveryPaper { title: string; authors: string[]; year?: number; + publishedAt?: number; // precise feed timestamp when a provider exposes one venue?: string; abstract?: string; tldr?: string; // Semantic Scholar one-line summary diff --git a/desktop/src/i18n/index.ts b/desktop/src/i18n/index.ts index ef2e617d..1e4e775b 100644 --- a/desktop/src/i18n/index.ts +++ b/desktop/src/i18n/index.ts @@ -811,9 +811,11 @@ const en: Dict = { 'vault.tpWsS3': 'Author workspace · S3', 'vault.tpVoice': 'Voice input · DashScope', 'vault.tpSerpApi': 'Literature discovery · SerpAPI (Google Scholar)', + 'vault.tpXApi': 'Social monitoring · X API', 'vault.tpBackend': 'Active backend', 'vault.tpModel': 'Model', 'vault.tpApiKey': 'API key', + 'vault.tpBearerToken': 'Bearer token', 'vault.tpNotSet': 'not set', 'theme.dark': 'Dark', 'theme.light': 'Light', @@ -1458,6 +1460,118 @@ const en: Dict = { 'read.copy': 'Copy', // discover 'read.discoverPlaceholder': 'Search papers — e.g. "chain-of-thought reasoning"', + 'read.discoverExplore': 'Explore', + 'read.savedSearches': 'Saved searches', + 'read.savedSearchesEmpty': 'Save a useful query to keep it here.', + 'read.recentSearches': 'Recent searches', + 'read.recentSearchesEmpty': 'Successful searches will appear here.', + 'read.saveSearch': 'Save this search', + 'read.searchSaved': 'Search saved', + 'read.removeSavedSearch': 'Remove saved search', + 'read.removeSearch': 'Remove from this list', + 'read.clearSearchHistory': 'Clear', + 'read.searchHistoryPrivacy': 'Recent searches stay on this device.', + 'read.monitorUpdates': 'Updates', + 'read.monitorPrivacy': 'Monitoring data stays on this device.', + 'read.monitorUpdatesHint': 'New research and social posts from everything you follow.', + 'read.monitorForYou': 'For you', + 'read.monitorForYouHint': 'Recommendations seeded by a collection you curate.', + 'read.monitorSubscriptions': 'Following', + 'read.monitorSubscriptionsHint': 'Follow research, people, social feeds, and persistent monitors.', + 'read.monitorTrends': 'Trends', + 'read.monitorTrendsHint': 'Accelerating topics backed by independent evidence from your updates.', + 'read.monitorNoTrends': 'No reliable trends yet', + 'read.monitorNoTrendsHint': 'Refresh several sources over time. Trends require at least two matching updates.', + 'read.monitorTrendEvidence': '{items} items · {authors} authors · {sources} sources', + 'read.monitorTrendDrilldown': 'Underlying evidence', + 'read.monitorConfidence.low': 'Early', + 'read.monitorConfidence.medium': 'Growing', + 'read.monitorConfidence.high': 'Strong', + 'read.monitorRefresh': 'Check now', + 'read.monitorRefreshing': 'Checking…', + 'read.monitorMarkAllRead': 'Mark all read', + 'read.monitorAll': 'All', + 'read.monitorUnread': 'Unread', + 'read.monitorClearRead': 'Clear read', + 'read.monitorLastChecked': 'Last checked {time}', + 'read.monitorSomeFailed': '{n} sources could not be refreshed. Open Following for details.', + 'read.monitorNoUnread': 'You are caught up', + 'read.monitorNoUpdates': 'No updates yet', + 'read.monitorNoUpdatesHint': 'Schedule a saved search or add a subscription, then check for updates.', + 'read.monitorMarkRead': 'Mark read', + 'read.monitorOpen': 'Open', + 'read.monitorCitations': 'cited', + 'read.monitorCadence.daily': 'Daily', + 'read.monitorCadence.weekly': 'Weekly', + 'read.monitorCadence.monthly': 'Monthly', + 'read.monitorKind.author': 'Author', + 'read.monitorKind.journal': 'Journal', + 'read.monitorKind.topic': 'Topic', + 'read.monitorKind.citation': 'Citations', + 'read.monitorKind.rss': 'RSS', + 'read.monitorKind.bluesky-author': 'Bluesky author', + 'read.monitorKind.bluesky-feed': 'Bluesky feed', + 'read.monitorKind.bluesky-query': 'Bluesky search', + 'read.monitorKind.mastodon-author': 'Mastodon author', + 'read.monitorKind.mastodon-tag': 'Mastodon hashtag', + 'read.monitorKind.youtube-channel': 'YouTube channel', + 'read.monitorKind.x-author': 'X author', + 'read.monitorKind.x-query': 'X search', + 'read.monitorPlaceholder.author': 'Author name', + 'read.monitorPlaceholder.journal': 'Journal or conference', + 'read.monitorPlaceholder.topic': 'Research topic', + 'read.monitorPlaceholder.citation': 'Work', + 'read.monitorPlaceholder.rss': 'Website or feed URL', + 'read.monitorPlaceholder.bluesky-author': '@handle.bsky.social', + 'read.monitorPlaceholder.bluesky-feed': 'at://…/app.bsky.feed.generator/…', + 'read.monitorPlaceholder.bluesky-query': 'Keywords or phrase', + 'read.monitorPlaceholder.mastodon-author': '@author@instance.social or profile URL', + 'read.monitorPlaceholder.mastodon-tag': '#topic@instance.social or hashtag URL', + 'read.monitorPlaceholder.youtube-channel': 'YouTube channel ID or channel URL', + 'read.monitorPlaceholder.x-author': '@username', + 'read.monitorPlaceholder.x-query': 'X query, hashtag, or phrase', + 'read.monitorGroup.research': 'Research', + 'read.monitorGroup.social': 'People', + 'read.monitorGroup.monitors': 'Monitors', + 'read.monitorGroup.feeds': 'Feeds', + 'read.monitorFilters': 'Noise controls', + 'read.monitorInclude': 'Must include (comma separated)', + 'read.monitorExclude': 'Exclude (comma separated)', + 'read.monitorLanguage': 'Language, e.g. en', + 'read.monitorMinEngagement': 'Minimum engagement', + 'read.monitorExcludeReposts': 'Exclude reposts', + 'read.monitorPause': 'Pause updates', + 'read.monitorResume': 'Resume updates', + 'read.monitorPaused': 'Paused', + 'read.monitorContentType': 'Update type', + 'read.monitorAllSources': 'Research + social', + 'read.monitorResearch': 'Research', + 'read.monitorSocial': 'Social', + 'read.monitorWhyMatched': 'Matched: {reason}', + 'read.monitorEngagement': 'engagement', + 'read.monitorSave': 'Save', + 'read.monitorMuteSource': 'Mute source', + 'read.monitorXKeyHint': 'X uses the official API. Add a bearer token in Settings → Vault → TermiPod.', + 'read.monitorOptionalName': 'Name (optional)', + 'read.monitorProvider': 'Provider', + 'read.monitorSchedule': 'Schedule', + 'read.monitorSubscribe': 'Subscribe', + 'read.monitorCitationWork': 'Work to monitor', + 'read.monitorChooseWork': 'Choose a library work…', + 'read.monitorScheduledSearches': 'Scheduled saved searches', + 'read.monitorOff': 'Off', + 'read.monitorNoSubscriptions': 'No subscriptions yet.', + 'read.monitorRefreshOne': 'Refresh this subscription', + 'read.monitorUnsubscribe': 'Unsubscribe', + 'read.monitorRecommend': 'Find recommendations', + 'read.monitorSeedCollection': 'Seed collection', + 'read.monitorChooseCollection': 'Choose a collection…', + 'read.monitorChooseCollectionHint': 'For You learns from the papers, ratings, topics, and tags in one collection.', + 'read.monitorSeededBy': 'Seeded by {n} collection items', + 'read.monitorEmptyCollection': 'This collection is empty', + 'read.monitorEmptyCollectionHint': 'Add several relevant papers before asking for recommendations.', + 'read.monitorReadyRecommend': 'Ready to find related work', + 'read.monitorReadyRecommendHint': 'TermiPod uses the collection’s strongest topics, tags, venues, and rated titles as the query.', 'read.discoverSource': 'Semantic Scholar — 200M+ papers, TLDR summaries', 'read.search': 'Search', 'read.searching': 'Searching…', @@ -3111,9 +3225,11 @@ const zh: Dict = { 'vault.tpWsS3': '写作工作区 · S3', 'vault.tpVoice': '语音输入 · DashScope', 'vault.tpSerpApi': '文献发现 · SerpAPI（Google Scholar）', + 'vault.tpXApi': '社交监测 · X API', 'vault.tpBackend': '当前后端', 'vault.tpModel': '模型', 'vault.tpApiKey': 'API 密钥', + 'vault.tpBearerToken': 'Bearer 令牌', 'vault.tpNotSet': '未设置', 'theme.dark': '深色', 'theme.light': '浅色', @@ -3745,6 +3861,118 @@ const zh: Dict = { 'read.scrapeFailed': '数据丰富失败 — 数据源可能繁忙，请重试。', 'read.copy': '复制', 'read.discoverPlaceholder': '搜索论文 — 例如「chain-of-thought reasoning」', + 'read.discoverExplore': '探索', + 'read.savedSearches': '已保存搜索', + 'read.savedSearchesEmpty': '保存有用的查询后会显示在这里。', + 'read.recentSearches': '最近搜索', + 'read.recentSearchesEmpty': '成功的搜索会显示在这里。', + 'read.saveSearch': '保存此搜索', + 'read.searchSaved': '已保存搜索', + 'read.removeSavedSearch': '移除已保存搜索', + 'read.removeSearch': '从列表中移除', + 'read.clearSearchHistory': '清除', + 'read.searchHistoryPrivacy': '最近搜索仅保存在此设备。', + 'read.monitorUpdates': '更新', + 'read.monitorPrivacy': '监测数据仅保存在此设备。', + 'read.monitorUpdatesHint': '来自所有关注对象的新研究和社交动态。', + 'read.monitorForYou': '为你推荐', + 'read.monitorForYouHint': '根据你维护的一个文集生成推荐。', + 'read.monitorSubscriptions': '关注', + 'read.monitorSubscriptionsHint': '关注研究、人物、社交订阅源和持续监测。', + 'read.monitorTrends': '趋势', + 'read.monitorTrendsHint': '基于更新中独立证据识别正在加速的主题。', + 'read.monitorNoTrends': '暂无可靠趋势', + 'read.monitorNoTrendsHint': '请持续刷新多个来源；趋势至少需要两条匹配更新。', + 'read.monitorTrendEvidence': '{items} 条 · {authors} 位作者 · {sources} 个来源', + 'read.monitorTrendDrilldown': '原始证据', + 'read.monitorConfidence.low': '早期', + 'read.monitorConfidence.medium': '增长中', + 'read.monitorConfidence.high': '强趋势', + 'read.monitorRefresh': '立即检查', + 'read.monitorRefreshing': '正在检查…', + 'read.monitorMarkAllRead': '全部标为已读', + 'read.monitorAll': '全部', + 'read.monitorUnread': '未读', + 'read.monitorClearRead': '清除已读', + 'read.monitorLastChecked': '上次检查 {time}', + 'read.monitorSomeFailed': '{n} 个来源无法刷新。请在订阅中查看详情。', + 'read.monitorNoUnread': '已全部读完', + 'read.monitorNoUpdates': '暂无更新', + 'read.monitorNoUpdatesHint': '为已保存搜索设置计划或添加订阅，然后检查更新。', + 'read.monitorMarkRead': '标为已读', + 'read.monitorOpen': '打开', + 'read.monitorCitations': '次引用', + 'read.monitorCadence.daily': '每天', + 'read.monitorCadence.weekly': '每周', + 'read.monitorCadence.monthly': '每月', + 'read.monitorKind.author': '作者', + 'read.monitorKind.journal': '期刊', + 'read.monitorKind.topic': '主题', + 'read.monitorKind.citation': '引用', + 'read.monitorKind.rss': 'RSS', + 'read.monitorKind.bluesky-author': 'Bluesky 作者', + 'read.monitorKind.bluesky-feed': 'Bluesky 订阅源', + 'read.monitorKind.bluesky-query': 'Bluesky 搜索', + 'read.monitorKind.mastodon-author': 'Mastodon 作者', + 'read.monitorKind.mastodon-tag': 'Mastodon 话题标签', + 'read.monitorKind.youtube-channel': 'YouTube 频道', + 'read.monitorKind.x-author': 'X 作者', + 'read.monitorKind.x-query': 'X 搜索', + 'read.monitorPlaceholder.author': '作者姓名', + 'read.monitorPlaceholder.journal': '期刊或会议', + 'read.monitorPlaceholder.topic': '研究主题', + 'read.monitorPlaceholder.citation': '论文', + 'read.monitorPlaceholder.rss': '网站或订阅源 URL', + 'read.monitorPlaceholder.bluesky-author': '@handle.bsky.social', + 'read.monitorPlaceholder.bluesky-feed': 'at://…/app.bsky.feed.generator/…', + 'read.monitorPlaceholder.bluesky-query': '关键词或短语', + 'read.monitorPlaceholder.mastodon-author': '@作者@实例.social 或个人页 URL', + 'read.monitorPlaceholder.mastodon-tag': '#主题@实例.social 或话题 URL', + 'read.monitorPlaceholder.youtube-channel': 'YouTube 频道 ID 或频道 URL', + 'read.monitorPlaceholder.x-author': '@用户名', + 'read.monitorPlaceholder.x-query': 'X 查询、话题标签或短语', + 'read.monitorGroup.research': '研究', + 'read.monitorGroup.social': '人物', + 'read.monitorGroup.monitors': '监测', + 'read.monitorGroup.feeds': '订阅源', + 'read.monitorFilters': '降噪规则', + 'read.monitorInclude': '必须包含（逗号分隔）', + 'read.monitorExclude': '排除（逗号分隔）', + 'read.monitorLanguage': '语言，例如 en', + 'read.monitorMinEngagement': '最低互动量', + 'read.monitorExcludeReposts': '排除转发', + 'read.monitorPause': '暂停更新', + 'read.monitorResume': '恢复更新', + 'read.monitorPaused': '已暂停', + 'read.monitorContentType': '更新类型', + 'read.monitorAllSources': '研究 + 社交', + 'read.monitorResearch': '研究', + 'read.monitorSocial': '社交', + 'read.monitorWhyMatched': '匹配原因：{reason}', + 'read.monitorEngagement': '互动', + 'read.monitorSave': '保存', + 'read.monitorMuteSource': '静音来源', + 'read.monitorXKeyHint': 'X 使用官方 API。请在“设置 → 保险库 → TermiPod”中添加 Bearer 令牌。', + 'read.monitorOptionalName': '名称（可选）', + 'read.monitorProvider': '数据源', + 'read.monitorSchedule': '计划', + 'read.monitorSubscribe': '订阅', + 'read.monitorCitationWork': '要监测的论文', + 'read.monitorChooseWork': '选择文库中的论文…', + 'read.monitorScheduledSearches': '定时的已保存搜索', + 'read.monitorOff': '关闭', + 'read.monitorNoSubscriptions': '暂无订阅。', + 'read.monitorRefreshOne': '刷新此订阅', + 'read.monitorUnsubscribe': '取消订阅', + 'read.monitorRecommend': '查找推荐', + 'read.monitorSeedCollection': '种子文集', + 'read.monitorChooseCollection': '选择文集…', + 'read.monitorChooseCollectionHint': '“为你推荐”会学习一个文集中的论文、评分、主题和标签。', + 'read.monitorSeededBy': '基于文集中的 {n} 篇文献', + 'read.monitorEmptyCollection': '此文集为空', + 'read.monitorEmptyCollectionHint': '先添加几篇相关论文，再获取推荐。', + 'read.monitorReadyRecommend': '可以查找相关工作', + 'read.monitorReadyRecommendHint': 'TermiPod 会使用文集中最相关的主题、标签、来源和高评分标题构造查询。', 'read.discoverSource': 'Semantic Scholar — 2 亿+ 论文，TLDR 摘要', 'read.search': '搜索', 'read.searching': '搜索中…', diff --git a/desktop/src/state/appIntegrations.ts b/desktop/src/state/appIntegrations.ts index 6df41ab9..3f30ae34 100644 --- a/desktop/src/state/appIntegrations.ts +++ b/desktop/src/state/appIntegrations.ts @@ -3,12 +3,13 @@ import { secretGet, secretSetMany } from './persist'; import { loadWebdavConfig, loadZoteroBackend, loadZoteroS3Config } from './webdav'; import { loadS3Config, loadSyncBackend, loadWorkspaceSyncConfig } from './workspaceSync'; import { getVoiceModel } from '../voice/settings'; -import { SERPAPI_KEY } from './discoverySecrets'; +import { SERPAPI_KEY, X_BEARER_TOKEN } from './discoverySecrets'; /// TermiPod's own integration config + secrets, gathered in one place so they can /// be (a) surfaced/managed in the Vault's "TermiPod" tab and (b) sealed into the /// synced vault bundle — so setting up a new machine restores the WebDAV/S3 sync -/// endpoints, voice API key, and discovery API key along with everything else. +/// endpoints, voice API key, and discovery/social API credentials along with +/// everything else. /// /// These integrations (each secret already lives in the consolidated keychain /// item via `persist`): @@ -17,6 +18,7 @@ import { SERPAPI_KEY } from './discoverySecrets'; /// • Author workspace — S3 / S3-compatible (workspaceSync.ts / s3.rs) /// • Voice input — DashScope realtime ASR (voice/settings.ts) /// • Literature discovery — Google Scholar through SerpAPI +/// • Social monitoring — X through its official API /// Non-secret config that seals into / restores from the vault. Snapshotting the /// raw localStorage strings keeps it trivially forward-compatible (e.g. `voice.model` @@ -51,6 +53,7 @@ export const APP_SECRET_KEYS = [ 'termipod.workspacesync.s3.secret', 'voice_dashscope_api_key', SERPAPI_KEY, + X_BEARER_TOKEN, ] as const; // ── UI descriptors (Vault → TermiPod tab) ─────────────────────────────────── @@ -143,6 +146,13 @@ export function listAppIntegrations(): AppIntegration[] { info: [], secrets: [{ slot: SERPAPI_KEY, labelKey: 'vault.tpApiKey' }], }, + { + id: 'x-api', + titleKey: 'vault.tpXApi', + icon: 'globe', + info: [], + secrets: [{ slot: X_BEARER_TOKEN, labelKey: 'vault.tpBearerToken' }], + }, ]; } diff --git a/desktop/src/state/discoveryHistory.ts b/desktop/src/state/discoveryHistory.ts new file mode 100644 index 00000000..7808b5de --- /dev/null +++ b/desktop/src/state/discoveryHistory.ts @@ -0,0 +1,136 @@ +import { create } from 'zustand'; +import type { DiscoverySourceId } from '../discovery/types'; +import type { DiscoverySort } from './discoverySearch'; +import type { DiscoveryCadence } from './discoveryMonitorCore'; +import { + discoveryQueryKey, + upsertRecentSearch, + upsertSavedSearch, + type DiscoveryQuerySpec, + type RecentDiscoverySearch, + type SavedDiscoverySearch, +} from './discoveryHistoryCore'; + +const LS_KEY = 'termipod.discover.history.v1'; + +interface PersistedDiscoveryHistory { + version: 1; + recent: RecentDiscoverySearch[]; + saved: SavedDiscoverySearch[]; +} + +interface DiscoveryHistoryState { + recent: RecentDiscoverySearch[]; + saved: SavedDiscoverySearch[]; + record: (spec: DiscoveryQuerySpec, resultCount: number) => void; + save: (spec: DiscoveryQuerySpec, name?: string) => string; + removeRecent: (id: string) => void; + removeSaved: (id: string) => void; + setSavedSchedule: (id: string, cadence: DiscoveryCadence | undefined) => void; + clearRecent: () => void; +} + +const SOURCES = new Set([ + 'openalex', + 'semanticscholar', + 'google-scholar', + 'crossref', + 'arxiv', + 'pubmed', + 'core', +]); +const SORTS = new Set(['relevance', 'newest', 'oldest', 'citations', 'title']); +const CADENCES = new Set(['daily', 'weekly', 'monthly']); + +function isSpec(value: unknown): value is DiscoveryQuerySpec { + if (value === null || typeof value !== 'object') return false; + const row = value as Record; + return ( + typeof row.query === 'string' && + typeof row.sourceId === 'string' && + SOURCES.has(row.sourceId as DiscoverySourceId) && + typeof row.authorFilter === 'string' && + typeof row.yearFrom === 'string' && + typeof row.yearTo === 'string' && + typeof row.sort === 'string' && + SORTS.has(row.sort as DiscoverySort) && + typeof row.findPdfs === 'boolean' + ); +} + +function load(): Pick { + try { + const parsed = JSON.parse(localStorage.getItem(LS_KEY) ?? '') as Partial; + const recent = Array.isArray(parsed.recent) + ? parsed.recent.filter( + (entry): entry is RecentDiscoverySearch => + isSpec(entry) && typeof entry.id === 'string' && typeof entry.ranAt === 'number' && typeof entry.resultCount === 'number', + ) + : []; + const saved = Array.isArray(parsed.saved) + ? parsed.saved.filter( + (entry): entry is SavedDiscoverySearch => + isSpec(entry) && + typeof entry.id === 'string' && + typeof entry.name === 'string' && + typeof entry.savedAt === 'number' && + (entry.schedule === undefined || + (typeof entry.schedule === 'string' && CADENCES.has(entry.schedule as DiscoveryCadence))), + ) + : []; + return { recent: recent.slice(0, 20), saved }; + } catch { + return { recent: [], saved: [] }; + } +} + +function persist(recent: RecentDiscoverySearch[], saved: SavedDiscoverySearch[]): void { + try { + const payload: PersistedDiscoveryHistory = { version: 1, recent, saved }; + localStorage.setItem(LS_KEY, JSON.stringify(payload)); + } catch (error) { + console.error(`[discovery] failed to persist "${LS_KEY}"`, error); + } +} + +function id(prefix: string): string { + return `${prefix}${crypto.randomUUID()}`; +} + +export { discoveryQueryKey }; +export type { DiscoveryQuerySpec, RecentDiscoverySearch, SavedDiscoverySearch }; + +export const useDiscoveryHistory = create((set, get) => ({ + ...load(), + record: (spec, resultCount) => { + const recent = upsertRecentSearch(get().recent, spec, resultCount, Date.now(), id('search')); + set({ recent }); + persist(recent, get().saved); + }, + save: (spec, name) => { + const before = get().saved; + const saved = upsertSavedSearch(before, spec, Date.now(), id('saved-search'), name); + set({ saved }); + persist(get().recent, saved); + return saved.find((entry) => discoveryQueryKey(entry) === discoveryQueryKey(spec))?.id ?? ''; + }, + removeRecent: (searchId) => { + const recent = get().recent.filter((entry) => entry.id !== searchId); + set({ recent }); + persist(recent, get().saved); + }, + removeSaved: (searchId) => { + const saved = get().saved.filter((entry) => entry.id !== searchId); + set({ saved }); + persist(get().recent, saved); + }, + setSavedSchedule: (searchId, schedule) => { + const saved = get().saved.map((entry) => (entry.id === searchId ? { ...entry, schedule } : entry)); + set({ saved }); + persist(get().recent, saved); + }, + clearRecent: () => { + set({ recent: [] }); + persist([], get().saved); + }, +})); diff --git a/desktop/src/state/discoveryHistoryCore.test.ts b/desktop/src/state/discoveryHistoryCore.test.ts new file mode 100644 index 00000000..06a76f6c --- /dev/null +++ b/desktop/src/state/discoveryHistoryCore.test.ts @@ -0,0 +1,50 @@ +import assert from 'node:assert/strict'; +import { test } from 'node:test'; +import { + discoveryQueryKey, + MAX_RECENT_SEARCHES, + upsertRecentSearch, + upsertSavedSearch, + type DiscoveryQuerySpec, +} from './discoveryHistoryCore.ts'; + +const base: DiscoveryQuerySpec = { + query: 'graph learning', + sourceId: 'openalex', + authorFilter: '', + yearFrom: '', + yearTo: '', + sort: 'relevance', + findPdfs: true, +}; + +test('query identity includes provider and filters but normalizes whitespace and case', () => { + assert.equal(discoveryQueryKey(base), discoveryQueryKey({ ...base, query: ' Graph Learning ' })); + assert.notEqual(discoveryQueryKey(base), discoveryQueryKey({ ...base, sourceId: 'google-scholar' })); + assert.notEqual(discoveryQueryKey(base), discoveryQueryKey({ ...base, yearFrom: '2024' })); +}); + +test('recent searches deduplicate, move to the top, and stay bounded', () => { + let recent = upsertRecentSearch([], base, 4, 10, 'one'); + recent = upsertRecentSearch(recent, { ...base, query: ' Graph Learning ' }, 9, 20, 'two'); + assert.equal(recent.length, 1); + assert.equal(recent[0]?.id, 'one'); + assert.equal(recent[0]?.resultCount, 9); + assert.equal(recent[0]?.ranAt, 20); + for (let i = 0; i < MAX_RECENT_SEARCHES + 5; i += 1) { + recent = upsertRecentSearch(recent, { ...base, query: `query ${i}` }, i, 30 + i, `id-${i}`); + } + assert.equal(recent.length, MAX_RECENT_SEARCHES); + assert.equal(recent[0]?.query, `query ${MAX_RECENT_SEARCHES + 4}`); +}); + +test('saving the same search is idempotent and preserves its chosen name', () => { + let saved = upsertSavedSearch([], base, 10, 'saved-one', 'My topic'); + saved = [{ ...saved[0]!, schedule: 'weekly' }]; + saved = upsertSavedSearch(saved, { ...base, query: 'GRAPH LEARNING' }, 20, 'saved-two'); + assert.equal(saved.length, 1); + assert.equal(saved[0]?.id, 'saved-one'); + assert.equal(saved[0]?.name, 'My topic'); + assert.equal(saved[0]?.savedAt, 10); + assert.equal(saved[0]?.schedule, 'weekly'); +}); diff --git a/desktop/src/state/discoveryHistoryCore.ts b/desktop/src/state/discoveryHistoryCore.ts new file mode 100644 index 00000000..6d0b6017 --- /dev/null +++ b/desktop/src/state/discoveryHistoryCore.ts @@ -0,0 +1,85 @@ +import type { DiscoverySourceId } from '../discovery/types.ts'; +import type { DiscoverySort } from './discoverySearch.ts'; +import type { DiscoveryCadence } from './discoveryMonitorCore.ts'; + +export interface DiscoveryQuerySpec { + query: string; + sourceId: DiscoverySourceId; + authorFilter: string; + yearFrom: string; + yearTo: string; + sort: DiscoverySort; + findPdfs: boolean; +} + +export interface RecentDiscoverySearch extends DiscoveryQuerySpec { + id: string; + ranAt: number; + resultCount: number; +} + +export interface SavedDiscoverySearch extends DiscoveryQuerySpec { + id: string; + name: string; + savedAt: number; + schedule?: DiscoveryCadence; +} + +export const MAX_RECENT_SEARCHES = 20; + +export function normalizeDiscoveryQuery(query: string): string { + return query.trim().replace(/\s+/g, ' '); +} + +export function discoveryQueryKey(spec: DiscoveryQuerySpec): string { + return JSON.stringify([ + normalizeDiscoveryQuery(spec.query).toLocaleLowerCase(), + spec.sourceId, + spec.authorFilter.trim().toLocaleLowerCase(), + spec.yearFrom.trim(), + spec.yearTo.trim(), + spec.sort, + spec.findPdfs, + ]); +} + +export function upsertRecentSearch( + existing: RecentDiscoverySearch[], + spec: DiscoveryQuerySpec, + resultCount: number, + ranAt: number, + id: string, +): RecentDiscoverySearch[] { + const normalized = { ...spec, query: normalizeDiscoveryQuery(spec.query) }; + const key = discoveryQueryKey(normalized); + const previous = existing.find((entry) => discoveryQueryKey(entry) === key); + const entry: RecentDiscoverySearch = { + ...normalized, + id: previous?.id ?? id, + ranAt, + resultCount: Math.max(0, Math.trunc(resultCount)), + }; + return [entry, ...existing.filter((item) => discoveryQueryKey(item) !== key)] + .sort((a, b) => b.ranAt - a.ranAt) + .slice(0, MAX_RECENT_SEARCHES); +} + +export function upsertSavedSearch( + existing: SavedDiscoverySearch[], + spec: DiscoveryQuerySpec, + savedAt: number, + id: string, + name?: string, +): SavedDiscoverySearch[] { + const normalized = { ...spec, query: normalizeDiscoveryQuery(spec.query) }; + const key = discoveryQueryKey(normalized); + const previous = existing.find((entry) => discoveryQueryKey(entry) === key); + const entry: SavedDiscoverySearch = { + ...normalized, + id: previous?.id ?? id, + name: name?.trim() || previous?.name || normalized.query, + savedAt: previous?.savedAt ?? savedAt, + schedule: previous?.schedule, + }; + return [entry, ...existing.filter((item) => discoveryQueryKey(item) !== key)].sort((a, b) => b.savedAt - a.savedAt); +} diff --git a/desktop/src/state/discoveryMonitor.ts b/desktop/src/state/discoveryMonitor.ts new file mode 100644 index 00000000..e8f10c62 --- /dev/null +++ b/desktop/src/state/discoveryMonitor.ts @@ -0,0 +1,361 @@ +import { create } from 'zustand'; +import { + enrichWithUnpaywall, + loadGoogleScholarCitations, + loadOpenAlexCitations, + sourceById, + type DiscoveryPaper, + type DiscoverySourceId, +} from '../discovery'; +import { fetchDiscoveryFeed } from '../discovery/rss'; +import { fetchSocialSubscription, SOCIAL_KINDS } from '../discovery/social'; +import { useDiscoveryHistory } from './discoveryHistory'; +import type { DiscoveryQuerySpec } from './discoveryHistoryCore'; +import { + mergeTargetItems, + targetDue, + type DiscoveryCadence, + type DiscoveryMonitorFilters, + type DiscoveryResult, + type DiscoverySocialPost, + type DiscoverySubscription, + type DiscoverySubscriptionKind, + type DiscoveryTargetRun, + type DiscoveryUpdate, +} from './discoveryMonitorCore'; + +const LS_KEY = 'termipod.discover.monitor.v1'; + +interface PersistedDiscoveryMonitor { + version: 1; + subscriptions: DiscoverySubscription[]; + updates: DiscoveryUpdate[]; + runs: Record; + lastRefreshAt?: number; +} + +interface AddSubscription { + kind: DiscoverySubscriptionKind; + label: string; + value: string; + sourceId?: DiscoverySourceId; + cadence: DiscoveryCadence; + referenceId?: string; + filters?: DiscoveryMonitorFilters; +} + +interface DiscoveryMonitorState { + subscriptions: DiscoverySubscription[]; + updates: DiscoveryUpdate[]; + runs: Record; + lastRefreshAt?: number; + refreshing: boolean; + addSubscription: (input: AddSubscription) => string; + removeSubscription: (id: string) => void; + setSubscriptionCadence: (id: string, cadence: DiscoveryCadence) => void; + setSubscriptionPaused: (id: string, paused: boolean) => void; + markRead: (id: string) => void; + markAllRead: () => void; + removeUpdate: (id: string) => void; + clearRead: () => void; +} + +const KINDS = new Set([ + 'author', 'journal', 'topic', 'citation', 'rss', + 'bluesky-author', 'bluesky-feed', 'bluesky-query', + 'mastodon-author', 'mastodon-tag', 'youtube-channel', 'x-author', 'x-query', +]); +const CADENCES = new Set(['daily', 'weekly', 'monthly']); +const SOURCES = new Set([ + 'openalex', 'semanticscholar', 'google-scholar', 'crossref', 'arxiv', 'pubmed', 'core', +]); + +function isSubscription(value: unknown): value is DiscoverySubscription { + if (value === null || typeof value !== 'object') return false; + const row = value as Record; + return typeof row.id === 'string' && + typeof row.kind === 'string' && KINDS.has(row.kind as DiscoverySubscriptionKind) && + typeof row.label === 'string' && typeof row.value === 'string' && + (row.sourceId === undefined || (typeof row.sourceId === 'string' && SOURCES.has(row.sourceId as DiscoverySourceId))) && + typeof row.cadence === 'string' && CADENCES.has(row.cadence as DiscoveryCadence) && + typeof row.createdAt === 'number' && + (row.referenceId === undefined || typeof row.referenceId === 'string') && + (row.filters === undefined || (row.filters !== null && typeof row.filters === 'object')) && + (row.paused === undefined || typeof row.paused === 'boolean'); +} + +function isPaper(value: unknown): value is DiscoveryPaper { + if (value === null || typeof value !== 'object') return false; + const row = value as Record; + return typeof row.paperId === 'string' && typeof row.title === 'string' && Array.isArray(row.authors); +} + +function isUpdate(value: unknown): value is DiscoveryUpdate { + if (value === null || typeof value !== 'object') return false; + const row = value as Record; + return typeof row.id === 'string' && + (row.originType === 'saved-search' || row.originType === 'subscription') && + typeof row.originId === 'string' && typeof row.originLabel === 'string' && + typeof row.arrivedAt === 'number' && (isPaper(row.paper) || isSocialPost(row.social)) && + (row.readAt === undefined || typeof row.readAt === 'number'); +} + +function isSocialPost(value: unknown): value is DiscoverySocialPost { + if (value === null || typeof value !== 'object') return false; + const row = value as Record; + return typeof row.id === 'string' && + (row.platform === 'bluesky' || row.platform === 'mastodon' || row.platform === 'youtube' || row.platform === 'x') && + typeof row.author === 'string' && typeof row.text === 'string' && typeof row.url === 'string'; +} + +function load(): Pick { + try { + const parsed = JSON.parse(localStorage.getItem(LS_KEY) ?? '') as Partial; + const subscriptions = Array.isArray(parsed.subscriptions) ? parsed.subscriptions.filter(isSubscription) : []; + const updates = Array.isArray(parsed.updates) ? parsed.updates.filter(isUpdate).slice(0, 500) : []; + const runs: Record = {}; + if (parsed.runs !== null && typeof parsed.runs === 'object') { + for (const [key, run] of Object.entries(parsed.runs)) { + if (run !== null && typeof run === 'object' && typeof run.lastRunAt === 'number' && Array.isArray(run.seen)) { + runs[key] = { + lastRunAt: run.lastRunAt, + lastError: typeof run.lastError === 'string' ? run.lastError : undefined, + seen: run.seen.filter((entry): entry is string => typeof entry === 'string').slice(0, 250), + }; + } + } + } + return { + subscriptions, + updates, + runs, + lastRefreshAt: typeof parsed.lastRefreshAt === 'number' ? parsed.lastRefreshAt : undefined, + }; + } catch { + return { subscriptions: [], updates: [], runs: {}, lastRefreshAt: undefined }; + } +} + +function persist(state: Pick): void { + try { + const payload: PersistedDiscoveryMonitor = { + version: 1, + subscriptions: state.subscriptions, + updates: state.updates, + runs: state.runs, + lastRefreshAt: state.lastRefreshAt, + }; + localStorage.setItem(LS_KEY, JSON.stringify(payload)); + } catch (error) { + console.error(`[discovery] failed to persist "${LS_KEY}"`, error); + } +} + +function commit(partial: Partial): void { + useDiscoveryMonitor.setState(partial); + const state = useDiscoveryMonitor.getState(); + persist(state); +} + +function newId(prefix: string): string { + return `${prefix}${crypto.randomUUID()}`; +} + +export const useDiscoveryMonitor = create((set, get) => ({ + ...load(), + refreshing: false, + addSubscription: (input) => { + const id = newId('subscription'); + const subscription: DiscoverySubscription = { + id, + kind: input.kind, + label: input.label.trim() || input.value.trim(), + value: input.value.trim(), + sourceId: input.sourceId, + cadence: input.cadence, + createdAt: Date.now(), + referenceId: input.referenceId, + filters: input.filters, + }; + const subscriptions = [subscription, ...get().subscriptions]; + set({ subscriptions }); + persist({ ...get(), subscriptions }); + return id; + }, + removeSubscription: (id) => { + const subscriptions = get().subscriptions.filter((entry) => entry.id !== id); + const runs = { ...get().runs }; + delete runs[`subscription:${id}`]; + set({ subscriptions, runs }); + persist({ ...get(), subscriptions, runs }); + }, + setSubscriptionCadence: (id, cadence) => { + const subscriptions = get().subscriptions.map((entry) => entry.id === id ? { ...entry, cadence } : entry); + set({ subscriptions }); + persist({ ...get(), subscriptions }); + }, + setSubscriptionPaused: (id, paused) => { + const subscriptions = get().subscriptions.map((entry) => entry.id === id ? { ...entry, paused } : entry); + set({ subscriptions }); + persist({ ...get(), subscriptions }); + }, + markRead: (id) => { + const updates = get().updates.map((entry) => entry.id === id && entry.readAt === undefined ? { ...entry, readAt: Date.now() } : entry); + set({ updates }); + persist({ ...get(), updates }); + }, + markAllRead: () => { + const now = Date.now(); + const updates = get().updates.map((entry) => entry.readAt === undefined ? { ...entry, readAt: now } : entry); + set({ updates }); + persist({ ...get(), updates }); + }, + removeUpdate: (id) => { + const updates = get().updates.filter((entry) => entry.id !== id); + set({ updates }); + persist({ ...get(), updates }); + }, + clearRead: () => { + const updates = get().updates.filter((entry) => entry.readAt === undefined); + set({ updates }); + persist({ ...get(), updates }); + }, +})); + +function filterSpecResults(papers: DiscoveryPaper[], spec: DiscoveryQuerySpec): DiscoveryPaper[] { + const author = spec.authorFilter.trim().toLocaleLowerCase(); + const from = spec.yearFrom === '' ? undefined : Number(spec.yearFrom); + const to = spec.yearTo === '' ? undefined : Number(spec.yearTo); + const filtered = papers.filter((paper) => + (author === '' || paper.authors.some((name) => name.toLocaleLowerCase().includes(author))) && + (from === undefined || !Number.isFinite(from) || (paper.year !== undefined && paper.year >= from)) && + (to === undefined || !Number.isFinite(to) || (paper.year !== undefined && paper.year <= to)), + ); + if (spec.sort === 'relevance') return filtered; + return [...filtered].sort((a, b) => { + if (spec.sort === 'title') return a.title.localeCompare(b.title); + if (spec.sort === 'citations') return (b.citationCount ?? -1) - (a.citationCount ?? -1); + if (a.year === undefined) return b.year === undefined ? 0 : 1; + if (b.year === undefined) return -1; + return spec.sort === 'newest' ? b.year - a.year : a.year - b.year; + }); +} + +async function runSavedSearch(spec: DiscoveryQuerySpec): Promise { + const source = sourceById(spec.sourceId); + let papers: DiscoveryPaper[] = (await source.search(spec.query, 25)).map((paper) => ({ ...paper, source: source.id })); + if (spec.findPdfs) papers = await enrichWithUnpaywall(papers); + return filterSpecResults(papers, spec).map((paper) => ({ paper })); +} + +async function runSubscription(subscription: DiscoverySubscription): Promise { + if (SOCIAL_KINDS.has(subscription.kind)) { + return fetchSocialSubscription(subscription); + } + if (subscription.kind === 'rss') { + return (await fetchDiscoveryFeed(subscription.value)).papers.map((paper) => ({ paper })); + } + if (subscription.kind === 'citation') { + if (subscription.sourceId === 'google-scholar') { + return (await loadGoogleScholarCitations(subscription.value, 0, 25)).papers.map((paper) => ({ paper: { + ...paper, + source: 'google-scholar' as const, + } })); + } + return (await loadOpenAlexCitations(subscription.value, 25)).map((paper) => ({ paper: { ...paper, source: 'openalex' as const } })); + } + const source = sourceById(subscription.sourceId ?? 'openalex'); + let papers = (await source.search(subscription.value, 25)).map((paper) => ({ ...paper, source: source.id })); + const needle = subscription.value.toLocaleLowerCase(); + if (subscription.kind === 'author') { + papers = papers.filter((paper) => paper.authors.some((author) => author.toLocaleLowerCase().includes(needle))); + } else if (subscription.kind === 'journal') { + papers = papers.filter((paper) => paper.venue?.toLocaleLowerCase().includes(needle) === true); + } + return papers.map((paper) => ({ paper })); +} + +let refreshPromise: Promise | null = null; + +export function refreshDiscoveryTargets(options: { force?: boolean; targetKey?: string } = {}): Promise { + if (refreshPromise !== null) return refreshPromise.then(() => refreshDiscoveryTargets(options)); + refreshPromise = (async () => { + const now = Date.now(); + commit({ refreshing: true }); + let totalAdded = 0; + const saved = useDiscoveryHistory.getState().saved.filter((entry) => entry.schedule !== undefined); + const subscriptions = useDiscoveryMonitor.getState().subscriptions.filter((entry) => entry.paused !== true); + const targets: Array<{ + key: string; + cadence: DiscoveryCadence; + origin: Pick; + run: () => Promise; + }> = [ + ...saved.map((entry) => ({ + key: `saved-search:${entry.id}`, + cadence: entry.schedule!, + origin: { originType: 'saved-search' as const, originId: entry.id, originLabel: entry.name }, + run: () => runSavedSearch(entry), + })), + ...subscriptions.map((entry) => ({ + key: `subscription:${entry.id}`, + cadence: entry.cadence, + origin: { originType: 'subscription' as const, originId: entry.id, originLabel: entry.label }, + run: () => runSubscription(entry), + })), + ]; + for (const target of targets) { + if (options.targetKey !== undefined && target.key !== options.targetKey) continue; + const state = useDiscoveryMonitor.getState(); + const previousRun = state.runs[target.key]; + if (options.force !== true && !targetDue(target.cadence, previousRun, now)) continue; + try { + const results = await target.run(); + const merged = mergeTargetItems( + state.updates, + previousRun, + results, + target.origin, + Date.now(), + results.map(() => newId('update')), + ); + totalAdded += merged.added; + commit({ + updates: merged.updates, + runs: { ...useDiscoveryMonitor.getState().runs, [target.key]: merged.run }, + }); + } catch (error) { + const latest = useDiscoveryMonitor.getState(); + commit({ + runs: { + ...latest.runs, + [target.key]: { + lastRunAt: Date.now(), + lastError: error instanceof Error ? error.message : String(error), + seen: previousRun?.seen ?? [], + }, + }, + }); + } + } + commit({ refreshing: false, lastRefreshAt: Date.now() }); + return totalAdded; + })().finally(() => { + refreshPromise = null; + if (useDiscoveryMonitor.getState().refreshing) commit({ refreshing: false }); + }); + return refreshPromise; +} + +export function startDiscoveryScheduler(): () => void { + const refresh = (): void => { + void refreshDiscoveryTargets(); + }; + refresh(); + const timer = window.setInterval(refresh, 5 * 60 * 1000); + window.addEventListener('focus', refresh); + return () => { + window.clearInterval(timer); + window.removeEventListener('focus', refresh); + }; +} diff --git a/desktop/src/state/discoveryMonitorCore.test.ts b/desktop/src/state/discoveryMonitorCore.test.ts new file mode 100644 index 00000000..d16678af --- /dev/null +++ b/desktop/src/state/discoveryMonitorCore.test.ts @@ -0,0 +1,65 @@ +import assert from 'node:assert/strict'; +import { test } from 'node:test'; +import { + buildDiscoveryTrends, + buildRecommendationSeed, + mergeTargetItems, + mergeTargetResults, + paperFingerprint, + targetDue, +} from './discoveryMonitorCore.ts'; + +test('target cadence is due initially and again only after its interval', () => { + assert.equal(targetDue('daily', undefined, 1), true); + assert.equal(targetDue('daily', { lastRunAt: 100, seen: [] }, 100 + 86_399_999), false); + assert.equal(targetDue('daily', { lastRunAt: 100, seen: [] }, 100 + 86_400_000), true); + assert.equal(targetDue('weekly', { lastRunAt: 100, seen: [], lastError: 'offline' }, 100 + 899_999), false); + assert.equal(targetDue('weekly', { lastRunAt: 100, seen: [], lastError: 'offline' }, 100 + 900_000), true); +}); + +test('social updates dedupe by provider id and contribute transparent trend evidence', () => { + const now = 8 * 24 * 60 * 60 * 1000; + const first = mergeTargetItems([], undefined, [{ social: { + id: 'post-1', platform: 'bluesky', author: 'Alice', text: 'Agent memory systems are improving', + url: 'https://bsky.app/profile/alice/post/1', publishedAt: now - 60_000, + } }], { originType: 'subscription', originId: 's1', originLabel: 'Alice' }, now, ['u1']); + const second = mergeTargetItems(first.updates, undefined, [{ social: { + id: 'post-2', platform: 'mastodon', author: 'Bob', text: 'New benchmarks for agent memory systems', + url: 'https://example.social/@bob/2', publishedAt: now - 120_000, + } }], { originType: 'subscription', originId: 's2', originLabel: 'Agent watch' }, now, ['u2']); + assert.equal(first.added, 1); + assert.equal(second.added, 1); + const memory = buildDiscoveryTrends(second.updates, now).find((trend) => trend.term === 'memory'); + assert.ok(memory !== undefined); + assert.equal(memory.evidenceIds.length, 2); + assert.equal(memory.authors, 2); + assert.equal(memory.sources, 2); +}); + +test('updates dedupe by DOI and remember earlier target results', () => { + const papers = [ + { paperId: 'one', doi: '10.1/ABC', title: 'First', authors: [] }, + { paperId: 'two', doi: '10.1/abc', title: 'Duplicate', authors: [] }, + ]; + assert.equal(paperFingerprint(papers[0]!), 'doi:10.1/abc'); + const first = mergeTargetResults([], undefined, papers, { + originType: 'subscription', originId: 'sub', originLabel: 'Topic', + }, 10, ['u1', 'u2']); + assert.equal(first.added, 1); + const second = mergeTargetResults(first.updates, first.run, papers, { + originType: 'subscription', originId: 'sub', originLabel: 'Topic', + }, 20, ['u3', 'u4']); + assert.equal(second.added, 0); +}); + +test('recommendations favor curated topics and tags from one collection', () => { + const seed = buildRecommendationSeed('c1', [{ id: 'c1', name: 'Reading' }], [{ + id: 'r1', type: 'article', title: 'Graph neural networks for molecules', authors: [], tags: ['drug discovery'], + topics: ['Graph learning'], collectionIds: ['c1'], notes: '', addedAt: 1, rating: 5, + }]); + assert.ok(seed !== null); + assert.equal(seed.collection.name, 'Reading'); + assert.ok(seed.query.includes('graph')); + assert.ok(seed.query.includes('learning')); + assert.equal(seed.references.length, 1); +}); diff --git a/desktop/src/state/discoveryMonitorCore.ts b/desktop/src/state/discoveryMonitorCore.ts new file mode 100644 index 00000000..d1e384e6 --- /dev/null +++ b/desktop/src/state/discoveryMonitorCore.ts @@ -0,0 +1,310 @@ +import type { DiscoveryPaper, DiscoverySourceId } from '../discovery/types.ts'; +import type { Collection, Reference } from './library.ts'; + +export type DiscoveryCadence = 'daily' | 'weekly' | 'monthly'; +export type DiscoverySubscriptionKind = + | 'author' + | 'journal' + | 'topic' + | 'citation' + | 'rss' + | 'bluesky-author' + | 'bluesky-feed' + | 'bluesky-query' + | 'mastodon-author' + | 'mastodon-tag' + | 'youtube-channel' + | 'x-author' + | 'x-query'; + +export type DiscoverySubscriptionGroup = 'research' | 'social' | 'monitors' | 'feeds'; + +export interface DiscoveryMonitorFilters { + include?: string; + exclude?: string; + language?: string; + excludeReposts?: boolean; + minEngagement?: number; +} + +export interface DiscoverySubscription { + id: string; + kind: DiscoverySubscriptionKind; + label: string; + value: string; + sourceId?: DiscoverySourceId; + cadence: DiscoveryCadence; + createdAt: number; + referenceId?: string; + filters?: DiscoveryMonitorFilters; + paused?: boolean; +} + +export interface DiscoveryTargetRun { + lastRunAt: number; + lastError?: string; + seen: string[]; +} + +export interface DiscoverySocialPost { + id: string; + platform: 'bluesky' | 'mastodon' | 'youtube' | 'x'; + author: string; + handle?: string; + text: string; + title?: string; + url: string; + publishedAt?: number; + language?: string; + avatarUrl?: string; + tags?: string[]; + engagement?: { + likes?: number; + reposts?: number; + replies?: number; + }; +} + +interface DiscoveryUpdateBase { + id: string; + originType: 'saved-search' | 'subscription'; + originId: string; + originLabel: string; + arrivedAt: number; + readAt?: number; +} + +export type DiscoveryUpdate = DiscoveryUpdateBase & ( + | { paper: DiscoveryPaper; social?: never } + | { paper?: never; social: DiscoverySocialPost } +); + +export type DiscoveryResult = { paper: DiscoveryPaper } | { social: DiscoverySocialPost }; + +export const MAX_UPDATES = 500; +export const MAX_SEEN_PER_TARGET = 250; + +function compactPaper(paper: DiscoveryPaper): DiscoveryPaper { + return { + ...paper, + authors: paper.authors.slice(0, 20), + abstract: paper.abstract?.slice(0, 4_000), + tldr: paper.tldr?.slice(0, 1_000), + }; +} + +function compactSocial(post: DiscoverySocialPost): DiscoverySocialPost { + return { + ...post, + author: post.author.slice(0, 240), + handle: post.handle?.slice(0, 240), + title: post.title?.slice(0, 500), + text: post.text.slice(0, 8_000), + tags: post.tags?.slice(0, 30), + }; +} + +const CADENCE_MS: Record = { + daily: 24 * 60 * 60 * 1000, + weekly: 7 * 24 * 60 * 60 * 1000, + monthly: 30 * 24 * 60 * 60 * 1000, +}; + +export function targetDue(cadence: DiscoveryCadence, run: DiscoveryTargetRun | undefined, now: number): boolean { + if (run === undefined) return true; + const retryAfter = run.lastError === undefined ? CADENCE_MS[cadence] : 15 * 60 * 1000; + return now - run.lastRunAt >= retryAfter; +} + +export function paperFingerprint(paper: Pick): string { + const doi = paper.doi?.trim().toLocaleLowerCase(); + if (doi !== undefined && doi !== '') return `doi:${doi}`; + const nativeId = paper.paperId.trim().toLocaleLowerCase(); + if (nativeId !== '') return `id:${nativeId}`; + return `title:${paper.title.trim().replace(/\s+/g, ' ').toLocaleLowerCase()}|${paper.year ?? ''}`; +} + +export function socialFingerprint(post: Pick): string { + const id = post.id.trim().toLocaleLowerCase(); + if (id !== '') return `social:${post.platform}:${id}`; + return `social:${post.platform}:${post.url.trim().toLocaleLowerCase()}`; +} + +export function resultFingerprint(result: DiscoveryResult): string { + return 'paper' in result ? paperFingerprint(result.paper) : socialFingerprint(result.social); +} + +export function updateFingerprint(update: DiscoveryUpdate): string { + return update.paper !== undefined ? paperFingerprint(update.paper) : socialFingerprint(update.social); +} + +export function mergeTargetItems( + existingUpdates: DiscoveryUpdate[], + previousRun: DiscoveryTargetRun | undefined, + results: DiscoveryResult[], + origin: Pick, + now: number, + ids: string[], +): { updates: DiscoveryUpdate[]; run: DiscoveryTargetRun; added: number } { + const oldSeen = new Set(previousRun?.seen ?? []); + const batchSeen = new Set(); + const additions: DiscoveryUpdate[] = []; + for (let index = 0; index < results.length; index += 1) { + const result = results[index]!; + const fingerprint = resultFingerprint(result); + if (batchSeen.has(fingerprint)) continue; + batchSeen.add(fingerprint); + if (oldSeen.has(fingerprint)) continue; + const base = { + id: ids[index] ?? `${origin.originId}:${fingerprint}`, + ...origin, + arrivedAt: now, + }; + additions.push('paper' in result + ? { ...base, paper: compactPaper(result.paper) } + : { ...base, social: compactSocial(result.social) }); + } + const seen = [...batchSeen, ...(previousRun?.seen ?? [])].filter( + (value, index, all) => all.indexOf(value) === index, + ).slice(0, MAX_SEEN_PER_TARGET); + return { + updates: [...additions, ...existingUpdates].slice(0, MAX_UPDATES), + run: { lastRunAt: now, seen }, + added: additions.length, + }; +} + +export function mergeTargetResults( + existingUpdates: DiscoveryUpdate[], + previousRun: DiscoveryTargetRun | undefined, + papers: DiscoveryPaper[], + origin: Pick, + now: number, + ids: string[], +): { updates: DiscoveryUpdate[]; run: DiscoveryTargetRun; added: number } { + return mergeTargetItems(existingUpdates, previousRun, papers.map((paper) => ({ paper })), origin, now, ids); +} + +const STOP_WORDS = new Set([ + 'about', 'after', 'among', 'based', 'between', 'from', 'into', 'model', 'models', 'paper', 'study', + 'their', 'these', 'this', 'through', 'toward', 'using', 'with', 'without', +]); + +function words(value: string): string[] { + return value + .toLocaleLowerCase() + .replace(/[^\p{L}\p{N}-]+/gu, ' ') + .split(/\s+/) + .filter((word) => word.length >= 3 && !STOP_WORDS.has(word)); +} + +export interface DiscoveryTrend { + term: string; + evidenceIds: string[]; + recentCount: number; + previousCount: number; + velocity: number; + authors: number; + sources: number; + days: number[]; + confidence: 'low' | 'medium' | 'high'; +} + +function updateWords(update: DiscoveryUpdate): string[] { + if (update.paper !== undefined) { + return words(`${update.paper.title} ${update.paper.abstract ?? ''} ${(update.paper.authors ?? []).join(' ')} ${update.paper.venue ?? ''}`); + } + return words(`${update.social.title ?? ''} ${update.social.text} ${(update.social.tags ?? []).join(' ')}`); +} + +/// Builds transparent local trend signals from the monitoring inbox. A trend is +/// acceleration plus independent evidence, not simply the most popular post. +export function buildDiscoveryTrends(updates: DiscoveryUpdate[], now: number): DiscoveryTrend[] { + const dayMs = 24 * 60 * 60 * 1000; + const recentCutoff = now - dayMs; + const historyCutoff = now - 7 * dayMs; + const rows = new Map; + sources: Set; + days: number[]; + }>(); + for (const update of updates) { + const timestamp = update.social?.publishedAt ?? update.arrivedAt; + if (timestamp < historyCutoff || timestamp > now + dayMs) continue; + const author = update.paper !== undefined ? update.paper.authors[0] ?? '' : update.social.author; + const source = update.paper?.source ?? update.social?.platform ?? update.originLabel; + const dayIndex = Math.max(0, Math.min(6, 6 - Math.floor((now - timestamp) / dayMs))); + for (const term of new Set(updateWords(update))) { + if (term.length < 4 || /^\d+$/.test(term)) continue; + const row = rows.get(term) ?? { + evidenceIds: [], recent: 0, previous: 0, authors: new Set(), sources: new Set(), days: Array(7).fill(0) as number[], + }; + row.evidenceIds.push(update.id); + if (timestamp >= recentCutoff) row.recent += 1; + else row.previous += 1; + if (author !== '') row.authors.add(author.toLocaleLowerCase()); + row.sources.add(String(source)); + row.days[dayIndex] = (row.days[dayIndex] ?? 0) + 1; + rows.set(term, row); + } + } + return [...rows.entries()] + .filter(([, row]) => row.evidenceIds.length >= 2 && row.recent >= 1) + .map(([term, row]) => { + const baseline = row.previous / 6; + const velocity = (row.recent + 0.5) / (baseline + 0.5); + const independent = Math.min(row.authors.size, row.sources.size + 1); + const confidence: DiscoveryTrend['confidence'] = row.evidenceIds.length >= 6 && independent >= 3 + ? 'high' + : row.evidenceIds.length >= 3 && independent >= 2 ? 'medium' : 'low'; + return { + term, + evidenceIds: row.evidenceIds, + recentCount: row.recent, + previousCount: row.previous, + velocity, + authors: row.authors.size, + sources: row.sources.size, + days: row.days, + confidence, + }; + }) + .sort((a, b) => (b.velocity * Math.log2(b.evidenceIds.length + 1)) - (a.velocity * Math.log2(a.evidenceIds.length + 1))) + .slice(0, 30); +} + +export interface RecommendationSeed { + collection: Collection; + references: Reference[]; + query: string; + terms: string[]; +} + +export function buildRecommendationSeed( + collectionId: string, + collections: Collection[], + references: Reference[], +): RecommendationSeed | null { + const collection = collections.find((candidate) => candidate.id === collectionId); + if (collection === undefined) return null; + const members = references.filter((reference) => reference.collectionIds.includes(collectionId)); + if (members.length === 0) return { collection, references: [], query: '', terms: [] }; + const scored = new Map(); + const add = (value: string, weight: number): void => { + for (const word of words(value)) scored.set(word, (scored.get(word) ?? 0) + weight); + }; + for (const reference of members) { + for (const topic of reference.topics ?? []) add(topic, 5); + for (const tag of reference.tags) add(tag, 4); + if (reference.venue !== undefined) add(reference.venue, 2); + add(reference.title, reference.rating !== undefined ? 1 + reference.rating / 2 : 1); + } + const terms = [...scored] + .sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0])) + .slice(0, 6) + .map(([term]) => term); + return { collection, references: members, terms, query: terms.join(' ') }; +} diff --git a/desktop/src/state/discoverySearch.ts b/desktop/src/state/discoverySearch.ts index fcd05df3..43977b52 100644 --- a/desktop/src/state/discoverySearch.ts +++ b/desktop/src/state/discoverySearch.ts @@ -1,13 +1,13 @@ import { create } from 'zustand'; -import type { DiscoveryPaper } from '../discovery'; +import type { DiscoveryPaper, DiscoverySourceId } from '../discovery'; +import type { DiscoveryQuerySpec } from './discoveryHistoryCore'; /// The Read surface's Discover pane state, lifted out of the component so it /// survives an unmount — the pane unmounts when the user switches to the Library /// mode or opens a reader/web tab, and a fresh mount would otherwise drop the -/// last search. In-memory only (results can be large; this is session state, not -/// something to persist to disk): the query + its results come back exactly as -/// left when the pane remounts. `sourceId` keeps its own localStorage -/// persistence in the component; the transient bits (busy/error/showKey) reset. +/// last search. Results remain in-memory because they can be large, while the +/// source and PDF-enrichment preference are small device-local preferences. +/// Busy/error/key-prompt state remains transient in the component. interface DiscoverySearchState { query: string; @@ -16,17 +16,60 @@ interface DiscoverySearchState { yearFrom: string; yearTo: string; sort: DiscoverySort; + sourceId: DiscoverySourceId; + findPdfs: boolean; + runRequest: number; setQuery: (q: string) => void; setResults: (r: DiscoveryPaper[]) => void; setAuthorFilter: (author: string) => void; setYearFrom: (year: string) => void; setYearTo: (year: string) => void; setSort: (sort: DiscoverySort) => void; + setSourceId: (source: DiscoverySourceId) => void; + setFindPdfs: (find: boolean) => void; + restoreAndRun: (spec: DiscoveryQuerySpec) => void; clearFilters: () => void; } export type DiscoverySort = 'relevance' | 'newest' | 'oldest' | 'citations' | 'title'; +const SOURCE_LS = 'termipod.discover.source'; +const FIND_PDFS_LS = 'termipod.discover.findPdfs'; +const SOURCES = new Set([ + 'openalex', + 'semanticscholar', + 'google-scholar', + 'crossref', + 'arxiv', + 'pubmed', + 'core', +]); + +function loadSource(): DiscoverySourceId { + try { + const value = localStorage.getItem(SOURCE_LS); + return value !== null && SOURCES.has(value as DiscoverySourceId) ? (value as DiscoverySourceId) : 'openalex'; + } catch { + return 'openalex'; + } +} + +function loadFindPdfs(): boolean { + try { + return localStorage.getItem(FIND_PDFS_LS) !== 'false'; + } catch { + return true; + } +} + +function persist(key: string, value: string): void { + try { + localStorage.setItem(key, value); + } catch { + /* device-local preference; ignore storage denial */ + } +} + export const useDiscoverySearch = create((set) => ({ query: '', results: [], @@ -34,11 +77,37 @@ export const useDiscoverySearch = create((set) => ({ yearFrom: '', yearTo: '', sort: 'relevance', + sourceId: loadSource(), + findPdfs: loadFindPdfs(), + runRequest: 0, setQuery: (q) => set({ query: q }), setResults: (r) => set({ results: r }), setAuthorFilter: (author) => set({ authorFilter: author }), setYearFrom: (year) => set({ yearFrom: year }), setYearTo: (year) => set({ yearTo: year }), setSort: (sort) => set({ sort }), + setSourceId: (sourceId) => { + set({ sourceId }); + persist(SOURCE_LS, sourceId); + }, + setFindPdfs: (findPdfs) => { + set({ findPdfs }); + persist(FIND_PDFS_LS, String(findPdfs)); + }, + restoreAndRun: (spec) => { + set((state) => ({ + query: spec.query, + authorFilter: spec.authorFilter, + yearFrom: spec.yearFrom, + yearTo: spec.yearTo, + sort: spec.sort, + sourceId: spec.sourceId, + findPdfs: spec.findPdfs, + results: [], + runRequest: state.runRequest + 1, + })); + persist(SOURCE_LS, spec.sourceId); + persist(FIND_PDFS_LS, String(spec.findPdfs)); + }, clearFilters: () => set({ authorFilter: '', yearFrom: '', yearTo: '' }), })); diff --git a/desktop/src/state/discoverySecrets.ts b/desktop/src/state/discoverySecrets.ts index 6a123f5b..becb52ff 100644 --- a/desktop/src/state/discoverySecrets.ts +++ b/desktop/src/state/discoverySecrets.ts @@ -4,7 +4,12 @@ import { secretGet } from './persist'; /// Keeping this out of localStorage prevents the SerpAPI credential from being /// exposed alongside ordinary renderer preferences. export const SERPAPI_KEY = 'termipod.discovery.serpapi.api_key'; +export const X_BEARER_TOKEN = 'termipod.discovery.x.bearer_token'; export async function getSerpApiKey(): Promise { return (await secretGet(SERPAPI_KEY))?.trim() ?? ''; } + +export async function getXBearerToken(): Promise { + return (await secretGet(X_BEARER_TOKEN))?.trim() ?? ''; +} diff --git a/desktop/src/styles/partials/04-library-nav.css b/desktop/src/styles/partials/04-library-nav.css index f2210dfc..ff568435 100644 --- a/desktop/src/styles/partials/04-library-nav.css +++ b/desktop/src/styles/partials/04-library-nav.css @@ -158,6 +158,198 @@ border-color: var(--accent-line); } +/* Discovery owns a contextual navigator. Library collections/tags are useful + destinations while browsing the library, but become unrelated chrome around + a literature search; recents and explicitly saved searches replace them. */ +.discover-nav { + display: flex; + flex-direction: column; + min-height: 0; + height: 100%; + overflow: hidden; + color: var(--text-secondary); +} +.discover-nav-primary { + display: grid; + gap: var(--spacing-s2); + flex: 0 0 auto; + padding: var(--spacing-s8); + border-bottom: 1px solid var(--border); +} +.discover-nav-destination { + display: flex; + align-items: center; + gap: var(--spacing-s8); + width: 100%; + padding: var(--spacing-s8); + border: none; + border-radius: var(--radius-sm); + background: transparent; + color: var(--text-secondary); + text-align: left; +} +.discover-nav-destination.active { + background: var(--accent-tint); + color: var(--text); + font-weight: 600; +} +.discover-nav-destination > span:nth-child(2) { + min-width: 0; + overflow: hidden; + text-overflow: ellipsis; + white-space: nowrap; +} +.discover-nav-count { + display: grid; + place-items: center; + min-width: 20px; + height: 20px; + margin-left: auto; + padding: 0 var(--spacing-s4); + border-radius: 10px; + background: var(--accent); + color: var(--accent-ink); + font-size: 10px; + font-variant-numeric: tabular-nums; +} +.discover-nav-spacer { + flex: 1 1 auto; +} +.discover-nav-section { + flex: 0 1 auto; + min-height: 72px; + max-height: 42%; + overflow-y: auto; + padding-bottom: var(--spacing-s8); + border-bottom: 1px solid var(--border); +} +.discover-nav-section.grow { + flex: 1 1 auto; + max-height: none; +} +.discover-nav-heading { + position: sticky; + top: 0; + z-index: 1; + display: flex; + align-items: center; + justify-content: space-between; + gap: var(--spacing-s8); + min-height: 30px; + padding: var(--spacing-s8) var(--spacing-s12) var(--spacing-s4); + background: var(--glass-pane); + color: var(--text-muted); + font-size: var(--font-size-label); + font-weight: 600; + letter-spacing: 0.06em; + text-transform: uppercase; +} +.discover-nav-clear { + padding: 0; + border: 0; + background: transparent; + color: var(--text-muted); + font-size: 10px; + letter-spacing: normal; + text-transform: none; +} +.discover-nav-clear:hover { + color: var(--text); + background: transparent; +} +.discover-nav-row { + display: flex; + align-items: center; + min-width: 0; + padding: 0 var(--spacing-s4) 0 var(--spacing-s8); + border-left: 2px solid transparent; +} +.discover-nav-row:hover { + background: var(--hover); +} +.discover-nav-row:focus-within { + border-left-color: var(--accent); + background: var(--hover); +} +.discover-nav-main { + display: flex; + flex: 1 1 auto; + flex-direction: column; + align-items: flex-start; + min-width: 0; + padding: var(--spacing-s6) var(--spacing-s4); + border: 0; + background: transparent; + color: var(--text-secondary); + text-align: left; +} +.discover-nav-query { + display: block; + width: 100%; + overflow: hidden; + color: var(--text); + font-size: var(--font-size-body-small); + line-height: 1.3; + text-overflow: ellipsis; + white-space: nowrap; +} +.discover-nav-meta { + display: block; + width: 100%; + overflow: hidden; + color: var(--text-muted); + font-size: 10px; + font-variant-numeric: tabular-nums; + line-height: 1.35; + text-overflow: ellipsis; + white-space: nowrap; +} +.discover-nav-actions { + display: flex; + flex: 0 0 auto; + align-items: center; + opacity: 0; +} +.discover-nav-row:hover .discover-nav-actions, +.discover-nav-row:focus-within .discover-nav-actions { + opacity: 1; +} +.discover-nav-action { + display: grid; + place-items: center; + width: 24px; + height: 24px; + padding: 0; + border: 0; + background: transparent; + color: var(--text-muted); +} +.discover-nav-action:hover:not(:disabled) { + background: var(--raised); + color: var(--text); +} +.discover-nav-action.active { + color: var(--warning, var(--accent)); +} +.discover-nav-action:disabled { + opacity: 1; +} +.discover-nav-empty { + padding: var(--spacing-s4) var(--spacing-s12) var(--spacing-s8); + color: var(--text-muted); + font-size: var(--font-size-label); + line-height: 1.4; +} +.discover-nav-privacy { + display: flex; + flex: 0 0 auto; + align-items: center; + gap: var(--spacing-s6); + padding: var(--spacing-s8) var(--spacing-s12); + color: var(--text-muted); + font-size: 10px; +} + /* --- items list --- */ .read-list-col { flex: 1; @@ -724,6 +916,407 @@ min-height: var(--control-md); padding-block: 0; } +.discover-save-search { + flex: 0 0 var(--control-md); + width: var(--control-md); + padding: 0; + color: var(--text-muted); +} +.discover-save-search.active { + color: var(--warning, var(--accent)); + background: var(--raised); +} + +/* Discovery monitoring workspace: the header and tool row follow the same + compact vertical rhythm as Explore, while each long list owns its scroller. */ +.discovery-workspace-pane { + display: flex; + flex: 1 1 auto; + flex-direction: column; + min-width: 0; + min-height: 0; + height: 100%; + background: var(--glass-pane); +} +.discovery-workspace-header { + display: flex; + flex: 0 0 auto; + align-items: center; + gap: var(--spacing-s16); + min-height: 72px; + padding: var(--spacing-s12) var(--spacing-s16); + border-bottom: 1px solid var(--border); +} +.discovery-workspace-header > div:first-child { + min-width: 0; +} +.discovery-workspace-header h2, +.discovery-monitor-section h3 { + margin: 0; + color: var(--text); +} +.discovery-workspace-header h2 { + font-size: var(--font-size-title); +} +.discovery-workspace-header p { + margin: var(--spacing-s2) 0 0; + color: var(--text-muted); + font-size: var(--font-size-body-small); +} +.discovery-workspace-actions { + display: flex; + flex: 0 0 auto; + gap: var(--spacing-s6); + margin-left: auto; +} +.discovery-workspace-actions button, +.discovery-workspace-header > button { + display: inline-flex; + align-items: center; + gap: var(--spacing-s6); + min-height: var(--control-md); +} +.discovery-workspace-toolbar { + display: flex; + flex: 0 0 auto; + align-items: center; + gap: var(--spacing-s12); + min-height: 50px; + padding: var(--spacing-s8) var(--spacing-s16); + border-bottom: 1px solid var(--border); +} +.discovery-workspace-toolbar .seg.compact, +.discovery-subscribe-kind.seg.compact { + padding: 2px; +} +.discovery-workspace-toolbar .seg-btn, +.discovery-subscribe-kind .seg-btn { + min-height: 30px; + padding: 0 var(--spacing-s8); +} +.discovery-monitor-warning { + display: flex; + align-items: center; + gap: var(--spacing-s6); + padding: var(--spacing-s8) var(--spacing-s16); + border-bottom: 1px solid color-mix(in srgb, var(--warning) 42%, transparent); + background: color-mix(in srgb, var(--warning) 10%, transparent); + color: var(--warning); + font-size: var(--font-size-body-small); +} +.discovery-workspace-empty { + display: flex; + flex-direction: column; + align-items: center; + justify-content: center; + gap: var(--spacing-s8); + min-height: 220px; + padding: var(--spacing-s24); + color: var(--text-muted); + text-align: center; +} +.discovery-workspace-empty strong { + color: var(--text-secondary); +} +.workspace-paper-card { + position: relative; +} +.workspace-paper-card.unread { + border-left: 3px solid var(--accent); +} +.workspace-paper-origin { + display: flex; + align-items: center; + margin-bottom: var(--spacing-s6); + color: var(--accent); + font-size: var(--font-size-label); + font-weight: 600; +} +.workspace-paper-origin span:last-child { + color: var(--text-muted); + font-weight: 400; +} +.workspace-paper-abstract { + display: -webkit-box; + overflow: hidden; + margin-top: var(--spacing-s8); + color: var(--text-secondary); + font-size: var(--font-size-body-small); + line-height: 1.45; + -webkit-box-orient: vertical; + -webkit-line-clamp: 3; +} +.workspace-social-card { + gap: var(--spacing-s6); +} +.workspace-platform { + padding: 2px var(--spacing-s6); + border-radius: var(--radius-pill); + background: color-mix(in srgb, var(--accent) 14%, transparent); + font-size: 10px; + letter-spacing: 0.04em; + text-transform: uppercase; +} +.workspace-social-author { + display: flex; + align-items: center; + gap: var(--spacing-s6); + margin-bottom: var(--spacing-s6); +} +.workspace-social-author img { + width: 24px; + height: 24px; + border-radius: 50%; + object-fit: cover; +} +.workspace-social-author span { + color: var(--text-muted); + font-size: var(--font-size-label); +} +.workspace-social-text { + margin: var(--spacing-s6) 0 var(--spacing-s8); + color: var(--text-secondary); + line-height: 1.5; + white-space: pre-wrap; +} +.discovery-subscribe-card { + flex: 0 0 auto; + padding: var(--spacing-s12) var(--spacing-s16); + border-bottom: 1px solid var(--border); + background: var(--glass-surface); +} +.discovery-subscribe-kind { + display: inline-flex; + max-width: 100%; + overflow-x: auto; + margin-bottom: var(--spacing-s12); +} +.discovery-follow-groups { + display: inline-flex; + margin: 0 var(--spacing-s12) var(--spacing-s12) 0; + padding: 2px; +} +.discovery-monitor-filters { + margin-top: var(--spacing-s8); + color: var(--text-muted); + font-size: var(--font-size-body-small); +} +.discovery-monitor-filters summary { + width: max-content; + cursor: pointer; +} +.discovery-monitor-filters > div { + display: grid; + grid-template-columns: repeat(4, minmax(120px, 1fr)) auto; + align-items: center; + gap: var(--spacing-s8); + margin-top: var(--spacing-s8); +} +.discovery-monitor-filters input:not([type='checkbox']) { + min-width: 0; + min-height: var(--control-md); +} +.discovery-monitor-filters label { + display: flex; + align-items: center; + gap: var(--spacing-s6); + white-space: nowrap; +} +.discovery-credential-hint { + display: flex; + align-items: center; + gap: var(--spacing-s6); + margin-top: var(--spacing-s8); + color: var(--text-muted); + font-size: var(--font-size-label); +} +.discovery-subscribe-form { + display: grid; + grid-template-columns: minmax(180px, 1fr) minmax(120px, auto) minmax(100px, auto) auto; + gap: var(--spacing-s8); +} +.discovery-subscribe-form input, +.discovery-subscribe-form select, +.discovery-subscribe-form button, +.discovery-monitor-row select, +.discovery-recommend-seed select { + min-height: var(--control-md); +} +.discovery-subscribe-form .primary { + display: inline-flex; + align-items: center; + justify-content: center; + gap: var(--spacing-s6); +} +.discovery-monitor-section { + flex: 0 1 auto; + min-height: 0; + padding: var(--spacing-s12) var(--spacing-s16); + overflow-y: auto; + border-bottom: 1px solid var(--border); +} +.discovery-monitor-section.grow { + flex: 1 1 auto; +} +.discovery-monitor-section h3 { + margin-bottom: var(--spacing-s8); + color: var(--text-muted); + font-size: var(--font-size-label); + letter-spacing: 0.06em; + text-transform: uppercase; +} +.discovery-monitor-row { + display: flex; + flex-wrap: wrap; + align-items: center; + gap: var(--spacing-s8); + min-height: 48px; + padding: var(--spacing-s6) 0; + border-bottom: 1px solid var(--border); +} +.discovery-monitor-row-main { + display: flex; + flex: 1 1 auto; + flex-direction: column; + min-width: 0; +} +.discovery-monitor-row > .discovery-monitor-row-main { + min-width: 180px; +} +.discovery-monitor-row-main strong, +.discovery-monitor-row-main span { + overflow: hidden; + text-overflow: ellipsis; + white-space: nowrap; +} +.discovery-monitor-row-main span { + color: var(--text-muted); + font-size: var(--font-size-label); +} +.discovery-monitor-error { + color: var(--danger); +} +.discovery-recommend-seed { + display: flex; + flex: 0 0 auto; + align-items: center; + gap: var(--spacing-s16); + padding: var(--spacing-s12) var(--spacing-s16); + border-bottom: 1px solid var(--border); + background: var(--glass-surface); +} +.discovery-recommend-seed label { + display: flex; + align-items: center; + gap: var(--spacing-s8); + color: var(--text-muted); + font-size: var(--font-size-body-small); +} +.discovery-recommend-explain { + display: flex; + flex: 1 1 auto; + align-items: center; + justify-content: flex-end; + gap: var(--spacing-s8); + color: var(--text-muted); + font-size: var(--font-size-label); +} +.discovery-recommend-explain > div { + display: flex; + flex-wrap: wrap; + justify-content: flex-end; + gap: var(--spacing-s4); +} +.discovery-trends-layout { + display: grid; + flex: 1 1 auto; + grid-template-columns: minmax(280px, 34%) minmax(0, 1fr); + min-height: 0; +} +.discovery-trend-list { + min-width: 0; + padding: var(--spacing-s12); + overflow-y: auto; + border-right: 1px solid var(--border); +} +.discovery-trend-card { + display: grid; + width: 100%; + grid-template-columns: minmax(0, 1fr) auto auto; + align-items: center; + gap: var(--spacing-s6); + margin-bottom: var(--spacing-s6); + padding: var(--spacing-s12); + border-color: transparent; + background: transparent; + text-align: left; +} +.discovery-trend-card:hover, +.discovery-trend-card.active { + border-color: var(--border-strong); + background: var(--raised); +} +.discovery-trend-name { + overflow: hidden; + color: var(--text); + font-weight: 650; + text-overflow: ellipsis; +} +.discovery-trend-velocity { + color: var(--accent); + font-variant-numeric: tabular-nums; +} +.discovery-trend-card > .small, +.discovery-trend-spark { + grid-column: 1 / -1; +} +.discovery-trend-spark { + display: flex; + height: 24px; + align-items: flex-end; + gap: 3px; +} +.discovery-trend-spark i { + flex: 1 1 0; + min-height: 2px; + border-radius: 2px 2px 0 0; + background: color-mix(in srgb, var(--accent) 60%, var(--text-muted)); +} +.discovery-trend-evidence { + min-width: 0; + overflow-y: auto; +} +.discovery-trend-evidence > .discovery-workspace-toolbar { + position: sticky; + z-index: 1; + top: 0; + background: var(--glass-pane); +} +.trend-high { + color: var(--success); +} +.trend-medium { + color: var(--warning); +} +@media (max-width: 940px) { + .discovery-subscribe-form { + grid-template-columns: minmax(160px, 1fr) minmax(110px, auto); + } + .discovery-recommend-seed, + .discovery-recommend-explain { + align-items: flex-start; + flex-direction: column; + } + .discovery-recommend-explain > div { + justify-content: flex-start; + } + .discovery-monitor-filters > div { + grid-template-columns: repeat(2, minmax(140px, 1fr)); + } + .discovery-trends-layout { + grid-template-columns: minmax(220px, 42%) minmax(0, 1fr); + } +} .discover-source { padding: 0 var(--spacing-s8) var(--spacing-s8); border-bottom: 1px solid var(--border); diff --git a/desktop/src/surfaces/DiscoveryWorkspace.tsx b/desktop/src/surfaces/DiscoveryWorkspace.tsx new file mode 100644 index 00000000..1628a06f --- /dev/null +++ b/desktop/src/surfaces/DiscoveryWorkspace.tsx @@ -0,0 +1,603 @@ +import { useMemo, useState } from 'react'; +import { sourceById, type DiscoveryPaper, type DiscoverySourceId } from '../discovery'; +import { subscriptionGroup } from '../discovery/social'; +import { useT } from '../i18n'; +import { useDiscoveryHistory } from '../state/discoveryHistory'; +import { + refreshDiscoveryTargets, + useDiscoveryMonitor, +} from '../state/discoveryMonitor'; +import { + buildRecommendationSeed, + buildDiscoveryTrends, + paperFingerprint, + type DiscoveryCadence, + type DiscoverySocialPost, + type DiscoverySubscriptionGroup, + type DiscoverySubscriptionKind, + type DiscoveryUpdate, +} from '../state/discoveryMonitorCore'; +import { useLibrary } from '../state/library'; +import { Icon } from '../ui/Icon'; +import { useOpenLink } from '../ui/OpenLinkContext'; + +export type DiscoveryWorkspaceView = 'explore' | 'updates' | 'subscriptions' | 'trends' | 'for-you'; + +function cadenceLabel(cadence: DiscoveryCadence, t: ReturnType): string { + return t(`read.monitorCadence.${cadence}`); +} + +function timeLabel(timestamp: number | undefined): string { + if (timestamp === undefined) return '—'; + return new Date(timestamp).toLocaleString([], { dateStyle: 'medium', timeStyle: 'short' }); +} + +function WorkspacePaperCard({ + paper, + update, + onAdd, + onInspect, +}: { + paper: DiscoveryPaper; + update?: DiscoveryUpdate; + onAdd: (paper: DiscoveryPaper) => string; + onInspect: (id: string) => void; +}): JSX.Element { + const t = useT(); + const openLink = useOpenLink(); + const references = useLibrary((state) => state.references); + const markRead = useDiscoveryMonitor((state) => state.markRead); + const removeUpdate = useDiscoveryMonitor((state) => state.removeUpdate); + const fingerprint = paperFingerprint(paper); + const imported = references.find((reference) => + (paper.doi !== undefined && reference.doi?.toLocaleLowerCase() === paper.doi.toLocaleLowerCase()) || + (paper.paperId !== '' && reference.externalId === paper.paperId) || + paperFingerprint({ paperId: reference.externalId ?? '', doi: reference.doi, title: reference.title, year: reference.year }) === fingerprint, + ); + return ( +
+ {update !== undefined && ( +
+ {update.originLabel} + + {timeLabel(update.arrivedAt)} +
+ )} +
{paper.title}
+
+ {paper.authors.slice(0, 4).join(', ')} + {paper.authors.length > 4 ? ' et al.' : ''} + {paper.year !== undefined ? ` · ${paper.year}` : ''} + {paper.venue !== undefined ? ` · ${paper.venue}` : ''} + {paper.citationCount !== undefined ? ` · ${paper.citationCount} ${t('read.monitorCitations')}` : ''} +
+ {paper.abstract !== undefined &&
{paper.abstract}
} +
+ + {paper.url !== undefined && ( + + )} + {update !== undefined && update.readAt === undefined && ( + + )} + {update !== undefined && ( + + )} +
+
+ ); +} + +function socialToPaper(post: DiscoverySocialPost): DiscoveryPaper { + const title = post.title?.trim() || post.text.replace(/\s+/g, ' ').slice(0, 140); + return { + paperId: `social:${post.platform}:${post.id}`, + title, + authors: [post.author], + year: post.publishedAt === undefined ? undefined : new Date(post.publishedAt).getUTCFullYear(), + venue: post.platform === 'x' ? 'X' : post.platform[0]!.toLocaleUpperCase() + post.platform.slice(1), + abstract: post.text, + url: post.url, + }; +} + +function WorkspaceSocialCard({ + update, + onAdd, + onInspect, +}: { + update: DiscoveryUpdate & { social: DiscoverySocialPost }; + onAdd: (paper: DiscoveryPaper) => string; + onInspect: (id: string) => void; +}): JSX.Element { + const t = useT(); + const openLink = useOpenLink(); + const markRead = useDiscoveryMonitor((state) => state.markRead); + const removeUpdate = useDiscoveryMonitor((state) => state.removeUpdate); + const setPaused = useDiscoveryMonitor((state) => state.setSubscriptionPaused); + const post = update.social; + const total = (post.engagement?.likes ?? 0) + (post.engagement?.reposts ?? 0) + (post.engagement?.replies ?? 0); + return ( +
+
+ {post.platform === 'x' ? 'X' : post.platform} + {update.originLabel} + + {timeLabel(post.publishedAt ?? update.arrivedAt)} +
+
+ {post.avatarUrl !== undefined && } + {post.author} + {post.handle !== undefined && {post.handle}} +
+ {post.title !== undefined &&
{post.title}
} +
{post.text}
+
+ {t('read.monitorWhyMatched').replace('{reason}', update.originLabel)} + {total > 0 ? ` · ${total} ${t('read.monitorEngagement')}` : ''} +
+
+ + + {update.readAt === undefined && } + {update.originType === 'subscription' && ( + + )} + +
+
+ ); +} + +function WorkspaceUpdateCard({ + update, + onAdd, + onInspect, +}: { + update: DiscoveryUpdate; + onAdd: (paper: DiscoveryPaper) => string; + onInspect: (id: string) => void; +}): JSX.Element { + if (update.paper !== undefined) { + return ; + } + return ; +} + +export function DiscoveryUpdatesPanel({ + onAdd, + onInspect, +}: { + onAdd: (paper: DiscoveryPaper) => string; + onInspect: (id: string) => void; +}): JSX.Element { + const t = useT(); + const updates = useDiscoveryMonitor((state) => state.updates); + const refreshing = useDiscoveryMonitor((state) => state.refreshing); + const lastRefreshAt = useDiscoveryMonitor((state) => state.lastRefreshAt); + const markAllRead = useDiscoveryMonitor((state) => state.markAllRead); + const clearRead = useDiscoveryMonitor((state) => state.clearRead); + const runs = useDiscoveryMonitor((state) => state.runs); + const [unreadOnly, setUnreadOnly] = useState(false); + const [contentType, setContentType] = useState<'all' | 'research' | 'social'>('all'); + const unread = updates.filter((entry) => entry.readAt === undefined).length; + const shown = updates.filter((entry) => + (!unreadOnly || entry.readAt === undefined) && + (contentType === 'all' || (contentType === 'research' ? entry.paper !== undefined : entry.social !== undefined)), + ); + const errors = Object.values(runs).filter((run) => run.lastError !== undefined); + return ( +
+
+
+

{t('read.monitorUpdates')}

+

{t('read.monitorUpdatesHint')}

+
+
+ + +
+
+
+
+ + +
+ + {t('read.monitorLastChecked').replace('{time}', timeLabel(lastRefreshAt))} + + +
+ {errors.length > 0 && ( +
+ {t('read.monitorSomeFailed').replace('{n}', String(errors.length))} +
+ )} +
+ {shown.length === 0 ? ( +
+ + {unreadOnly ? t('read.monitorNoUnread') : t('read.monitorNoUpdates')} + {t('read.monitorNoUpdatesHint')} +
+ ) : shown.map((update) => )} +
+
+ ); +} + +const KINDS_BY_GROUP: Record = { + research: ['author', 'journal', 'topic', 'citation'], + social: ['bluesky-author', 'mastodon-author', 'youtube-channel', 'x-author'], + monitors: ['bluesky-query', 'mastodon-tag', 'x-query'], + feeds: ['rss', 'bluesky-feed'], +}; +const GROUPS: DiscoverySubscriptionGroup[] = ['research', 'social', 'monitors', 'feeds']; +const CADENCES: DiscoveryCadence[] = ['daily', 'weekly', 'monthly']; + +function subscriptionIcon(kind: DiscoverySubscriptionKind): 'globe' | 'link' | 'star' | 'search' | 'book' { + if (kind === 'rss' || kind === 'youtube-channel' || kind === 'bluesky-feed') return 'globe'; + if (kind === 'citation') return 'link'; + if (kind.endsWith('-query') || kind === 'mastodon-tag' || kind === 'topic') return 'search'; + if (kind === 'journal') return 'book'; + return 'star'; +} + +export function DiscoverySubscriptionsPanel(): JSX.Element { + const t = useT(); + const references = useLibrary((state) => state.references); + const saved = useDiscoveryHistory((state) => state.saved); + const setSavedSchedule = useDiscoveryHistory((state) => state.setSavedSchedule); + const subscriptions = useDiscoveryMonitor((state) => state.subscriptions); + const runs = useDiscoveryMonitor((state) => state.runs); + const addSubscription = useDiscoveryMonitor((state) => state.addSubscription); + const removeSubscription = useDiscoveryMonitor((state) => state.removeSubscription); + const setCadence = useDiscoveryMonitor((state) => state.setSubscriptionCadence); + const setPaused = useDiscoveryMonitor((state) => state.setSubscriptionPaused); + const [group, setGroup] = useState('research'); + const [kind, setKind] = useState('topic'); + const [value, setValue] = useState(''); + const [label, setLabel] = useState(''); + const [sourceId, setSourceId] = useState('openalex'); + const [cadence, setNewCadence] = useState('weekly'); + const [referenceId, setReferenceId] = useState(''); + const [include, setInclude] = useState(''); + const [exclude, setExclude] = useState(''); + const [language, setLanguage] = useState(''); + const [minEngagement, setMinEngagement] = useState('0'); + const [excludeReposts, setExcludeReposts] = useState(true); + + const suggestions = useMemo(() => { + if (kind === 'author') return [...new Set(references.flatMap((reference) => reference.authors))].sort(); + if (kind === 'journal') return [...new Set(references.map((reference) => reference.venue).filter((item): item is string => item !== undefined && item !== ''))].sort(); + if (kind === 'topic') return [...new Set(references.flatMap((reference) => [...(reference.topics ?? []), ...reference.tags]))].sort(); + return []; + }, [kind, references]); + + function reset(nextKind: DiscoverySubscriptionKind): void { + setKind(nextKind); + setValue(''); + setLabel(''); + setReferenceId(''); + } + + function changeGroup(nextGroup: DiscoverySubscriptionGroup): void { + setGroup(nextGroup); + reset(KINDS_BY_GROUP[nextGroup][0]!); + } + + function submit(): void { + let targetValue = value.trim(); + let targetLabel = label.trim() || targetValue; + if (kind === 'citation') { + const reference = references.find((entry) => entry.id === referenceId); + if (reference === undefined) return; + const scholarCitesId = reference.scholar?.citesId; + const externalOpenAlex = reference.externalId !== undefined && /openalex\.org\/W\d+/i.test(reference.externalId) + ? reference.externalId + : undefined; + targetValue = scholarCitesId ?? reference.openAlexId ?? externalOpenAlex ?? reference.doi ?? ''; + targetLabel = reference.title; + } + if (targetValue === '') return; + const citationReference = kind === 'citation' ? references.find((entry) => entry.id === referenceId) : undefined; + const targetSource = citationReference?.scholar?.citesId !== undefined ? 'google-scholar' : sourceId; + const social = group === 'social' || group === 'monitors'; + const id = addSubscription({ + kind, + label: targetLabel, + value: targetValue, + sourceId: group === 'research' ? targetSource : undefined, + cadence, + referenceId: referenceId || undefined, + filters: social ? { + include: include.trim() || undefined, + exclude: exclude.trim() || undefined, + language: language.trim() || undefined, + excludeReposts, + minEngagement: Math.max(0, Number(minEngagement) || 0), + } : undefined, + }); + setValue(''); + setLabel(''); + setReferenceId(''); + void refreshDiscoveryTargets({ force: true, targetKey: `subscription:${id}` }); + } + + return ( +
+
+

{t('read.monitorSubscriptions')}

{t('read.monitorSubscriptionsHint')}

+
+
+
+ {GROUPS.map((entry) => ( + + ))} +
+
+ {KINDS_BY_GROUP[group].map((entry) => ( + + ))} +
+
+ {kind === 'citation' ? ( + + ) : ( + <> + 0 ? 'discovery-subscription-values' : undefined} + placeholder={t(`read.monitorPlaceholder.${kind}`)} + onChange={(event) => setValue(event.target.value)} + /> + {suggestions.map((entry) => + + )} + {(group !== 'research' || kind === 'rss') && setLabel(event.target.value)} />} + {group === 'research' && kind !== 'citation' && ( + + )} + + +
+ {(group === 'social' || group === 'monitors') && ( +
+ {t('read.monitorFilters')} +
+ setInclude(event.target.value)} /> + setExclude(event.target.value)} /> + setLanguage(event.target.value)} /> + setMinEngagement(event.target.value)} /> + +
+
+ )} + {kind.startsWith('x-') &&
{t('read.monitorXKeyHint')}
} +
+ + {group === 'monitors' &&
+

{t('read.monitorScheduledSearches')}

+ {saved.length === 0 ?

{t('read.savedSearchesEmpty')}

: saved.map((search) => { + const run = runs[`saved-search:${search.id}`]; + return ( +
+ +
{search.name}{sourceById(search.sourceId).label} · {timeLabel(run?.lastRunAt)}
+ {run?.lastError !== undefined && } + +
+ ); + })} +
} + +
+

{t('read.monitorSubscriptions')}

+ {subscriptions.filter((subscription) => subscriptionGroup(subscription.kind) === group).length === 0 ?

{t('read.monitorNoSubscriptions')}

: subscriptions.filter((subscription) => subscriptionGroup(subscription.kind) === group).map((subscription) => { + const run = runs[`subscription:${subscription.id}`]; + return ( +
+ +
+ {subscription.label} + {t(`read.monitorKind.${subscription.kind}`)} · {subscription.paused === true ? t('read.monitorPaused') : timeLabel(run?.lastRunAt)} +
+ {run?.lastError !== undefined && } + + + + +
+ ); + })} +
+
+ ); +} + +export function DiscoveryTrendsPanel({ + onAdd, + onInspect, +}: { + onAdd: (paper: DiscoveryPaper) => string; + onInspect: (id: string) => void; +}): JSX.Element { + const t = useT(); + const updates = useDiscoveryMonitor((state) => state.updates); + const trends = useMemo(() => buildDiscoveryTrends(updates, Date.now()), [updates]); + const [selected, setSelected] = useState(null); + const active = trends.find((trend) => trend.term === selected) ?? trends[0]; + const evidence = active === undefined ? [] : active.evidenceIds + .map((id) => updates.find((update) => update.id === id)) + .filter((update): update is DiscoveryUpdate => update !== undefined); + return ( +
+
+

{t('read.monitorTrends')}

{t('read.monitorTrendsHint')}

+
+ {trends.length === 0 ? ( +
{t('read.monitorNoTrends')}{t('read.monitorNoTrendsHint')}
+ ) : ( +
+
+ {trends.map((trend) => { + const max = Math.max(1, ...trend.days); + return ( + + ); + })} +
+
+
+ {active?.term} + {t('read.monitorTrendDrilldown')} +
+ {evidence.map((update) => )} +
+
+ )} +
+ ); +} + +function storedCollection(): string { + try { return localStorage.getItem('termipod.discover.forYouCollection') ?? ''; } catch { return ''; } +} + +export function DiscoveryForYouPanel({ + onAdd, + onInspect, +}: { + onAdd: (paper: DiscoveryPaper) => string; + onInspect: (id: string) => void; +}): JSX.Element { + const t = useT(); + const references = useLibrary((state) => state.references); + const collections = useLibrary((state) => state.collections); + const [collectionId, setCollectionId] = useState(storedCollection); + const [results, setResults] = useState([]); + const [busy, setBusy] = useState(false); + const [error, setError] = useState(null); + const seed = useMemo(() => buildRecommendationSeed(collectionId, collections, references), [collectionId, collections, references]); + + async function refresh(): Promise { + if (seed === null || seed.query === '') return; + setBusy(true); + setError(null); + try { + const existing = new Set(references.map((reference) => paperFingerprint({ + paperId: reference.externalId ?? '', doi: reference.doi, title: reference.title, year: reference.year, + }))); + const papers = (await sourceById('openalex').search(seed.query, 40)) + .map((paper) => ({ ...paper, source: 'openalex' as const })) + .filter((paper) => !existing.has(paperFingerprint(paper))) + .slice(0, 25); + setResults(papers); + } catch (cause) { + setError(cause instanceof Error ? cause.message : String(cause)); + setResults([]); + } finally { + setBusy(false); + } + } + + return ( +
+
+

{t('read.monitorForYou')}

{t('read.monitorForYouHint')}

+ +
+
+ + {seed !== null && ( +
+ {t('read.monitorSeededBy').replace('{n}', String(seed.references.length))} +
{seed.terms.map((term) => {term})}
+
+ )} +
+ {error !== null &&
{error}
} +
+ {collectionId === '' ? ( +
{t('read.monitorChooseCollection')}{t('read.monitorChooseCollectionHint')}
+ ) : seed?.references.length === 0 ? ( +
{t('read.monitorEmptyCollection')}{t('read.monitorEmptyCollectionHint')}
+ ) : results.length === 0 && !busy ? ( +
{t('read.monitorReadyRecommend')}{t('read.monitorReadyRecommendHint')}
+ ) : results.map((paper) => )} +
+
+ ); +} diff --git a/desktop/src/surfaces/ReadSurface.tsx b/desktop/src/surfaces/ReadSurface.tsx index 79967fcc..8d5770e6 100644 --- a/desktop/src/surfaces/ReadSurface.tsx +++ b/desktop/src/surfaces/ReadSurface.tsx @@ -34,6 +34,13 @@ import { } from '../state/attachments'; import { syncLibrary } from '../state/librarySync'; import { useDiscoverySearch, type DiscoverySort } from '../state/discoverySearch'; +import { + discoveryQueryKey, + useDiscoveryHistory, + type DiscoveryQuerySpec, + type RecentDiscoverySearch, + type SavedDiscoverySearch, +} from '../state/discoveryHistory'; import { syncAnnotations } from '../state/annotationSync'; import { useReadTabs } from '../state/readTabs'; import { useSession } from '../state/session'; @@ -49,6 +56,7 @@ import { SOURCES, sourceById, type DiscoveryPaper, + type DiscoverySourceId, type ScrapePatch, type ScrapeSeed, } from '../discovery'; @@ -77,6 +85,14 @@ import { useContextMenu } from '../ui/ContextMenu'; import { WebdavModal } from '../ui/WebdavModal'; import { HeaderPaneToggle, WorkbenchSurface } from '../ui/WorkbenchSurface'; import { PopoverMenu } from '../ui/PopoverMenu'; +import { + DiscoveryForYouPanel, + DiscoverySubscriptionsPanel, + DiscoveryTrendsPanel, + DiscoveryUpdatesPanel, + type DiscoveryWorkspaceView, +} from './DiscoveryWorkspace'; +import { useDiscoveryMonitor } from '../state/discoveryMonitor'; const clamp = (n: number, lo: number, hi: number): number => Math.min(hi, Math.max(lo, n)); @@ -1979,7 +1995,180 @@ function ReaderView({ // ---- Discover -------------------------------------------------------------- -const SOURCE_LS = 'termipod.discover.source'; +function discoverySourceLabel(id: DiscoverySourceId): string { + return SOURCES.find((source) => source.id === id)?.label ?? id; +} + +function discoverySearchDate(timestamp: number): string { + const date = new Date(timestamp); + const now = new Date(); + if (date.toDateString() === now.toDateString()) { + return date.toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' }); + } + return date.toLocaleDateString([], { month: 'short', day: 'numeric' }); +} + +function DiscoverySearchRow({ + entry, + saved, + onRun, + onSave, + onRemove, +}: { + entry: RecentDiscoverySearch | SavedDiscoverySearch; + saved: boolean; + onRun: () => void; + onSave?: () => void; + onRemove: () => void; +}): JSX.Element { + const t = useT(); + const isRecent = 'ranAt' in entry; + const label = 'name' in entry ? entry.name : entry.query; + return ( +
+ + + {onSave !== undefined && ( + + )} + + +
+ ); +} + +function DiscoveryRail({ + view, + onView, +}: { + view: DiscoveryWorkspaceView; + onView: (view: DiscoveryWorkspaceView) => void; +}): JSX.Element { + const t = useT(); + const recent = useDiscoveryHistory((state) => state.recent); + const saved = useDiscoveryHistory((state) => state.saved); + const save = useDiscoveryHistory((state) => state.save); + const removeRecent = useDiscoveryHistory((state) => state.removeRecent); + const removeSaved = useDiscoveryHistory((state) => state.removeSaved); + const clearRecent = useDiscoveryHistory((state) => state.clearRecent); + const restoreAndRun = useDiscoverySearch((state) => state.restoreAndRun); + const unreadUpdates = useDiscoveryMonitor((state) => state.updates.filter((entry) => entry.readAt === undefined).length); + const savedKeys = useMemo(() => new Set(saved.map(discoveryQueryKey)), [saved]); + return ( +
+
+ + + + + +
+ + {view === 'explore' ? ( + <> +
+
+ {t('read.savedSearches')} + {saved.length} +
+ {saved.length === 0 ? ( +
{t('read.savedSearchesEmpty')}
+ ) : ( + saved.map((entry) => ( + { + onView('explore'); + restoreAndRun(entry); + }} + onRemove={() => removeSaved(entry.id)} + /> + )) + )} +
+ +
+
+ {t('read.recentSearches')} + {recent.length > 0 && ( + + )} +
+ {recent.length === 0 ? ( +
{t('read.recentSearchesEmpty')}
+ ) : ( + recent.map((entry) => { + const isSaved = savedKeys.has(discoveryQueryKey(entry)); + return ( + { + onView('explore'); + restoreAndRun(entry); + }} + onSave={() => save(entry)} + onRemove={() => removeRecent(entry.id)} + /> + ); + }) + )} +
+ + ) :
} + +
+ + {view === 'explore' ? t('read.searchHistoryPrivacy') : t('read.monitorPrivacy')} +
+
+ ); +} function DiscoverPanel({ selectedId, @@ -2010,11 +2199,14 @@ function DiscoverPanel({ const setYearTo = useDiscoverySearch((s) => s.setYearTo); const setResultSort = useDiscoverySearch((s) => s.setSort); const clearFilters = useDiscoverySearch((s) => s.clearFilters); + const sourceId = useDiscoverySearch((s) => s.sourceId); + const setSourceId = useDiscoverySearch((s) => s.setSourceId); + const findPdfs = useDiscoverySearch((s) => s.findPdfs); + const setFindPdfs = useDiscoverySearch((s) => s.setFindPdfs); + const runRequest = useDiscoverySearch((s) => s.runRequest); const [busy, setBusy] = useState(false); const [err, setErr] = useState(null); - const [sourceId, setSourceId] = useState(() => localStorage.getItem(SOURCE_LS) ?? 'openalex'); const [showKey, setShowKey] = useState(false); - const [findPdfs, setFindPdfs] = useState(true); // When the query is a bare DOI / arXiv id / OpenAlex id, offer a direct // scrape-and-add instead of a keyword search. const idSeed = useMemo(() => detectIdentifier(q), [q]); @@ -2024,9 +2216,20 @@ function DiscoverPanel({ const [pdfErr, setPdfErr] = useState<{ id: string; msg: string } | null>(null); const [filtersOpen, setFiltersOpen] = useState(false); const filtersAnchorRef = useRef(null); + const handledRunRequest = useRef(0); + const savedSearches = useDiscoveryHistory((state) => state.saved); + const saveSearch = useDiscoveryHistory((state) => state.save); + const removeSavedSearch = useDiscoveryHistory((state) => state.removeSaved); + const recordSearch = useDiscoveryHistory((state) => state.record); const source = sourceById(sourceId); const [key, setKey] = useState(() => (source.keyKey !== undefined ? lsGet(source.keyKey) : '')); + useEffect(() => { + const nextSource = sourceById(sourceId); + setKey(nextSource.keyKey !== undefined ? lsGet(nextSource.keyKey) : ''); + setShowKey(false); + setErr(null); + }, [sourceId]); const importedByExternalId = useMemo( () => @@ -2060,35 +2263,43 @@ function DiscoverPanel({ }); }, [authorFilter, resultSort, results, yearFrom, yearTo]); const activeFilterCount = Number(authorFilter.trim() !== '') + Number(yearFrom !== '') + Number(yearTo !== ''); + const currentSpec: DiscoveryQuerySpec = { + query: q, + sourceId, + authorFilter, + yearFrom, + yearTo, + sort: resultSort, + findPdfs, + }; + const currentSaved = + q.trim() === '' ? undefined : savedSearches.find((entry) => discoveryQueryKey(entry) === discoveryQueryKey(currentSpec)); - function pickSource(id: string): void { + function pickSource(id: DiscoverySourceId): void { setSourceId(id); - try { - localStorage.setItem(SOURCE_LS, id); - } catch { - /* ignore */ - } - const s = sourceById(id); - setKey(s.keyKey !== undefined ? lsGet(s.keyKey) : ''); - setShowKey(false); - setErr(null); } async function run(): Promise { if (q.trim() === '') return; + const spec = { ...currentSpec, query: q.trim() }; + const selectedSource = sourceById(spec.sourceId); setBusy(true); setErr(null); try { - let res: DiscoveryPaper[] = (await source.search(q, 25)).map((paper) => ({ ...paper, source: source.id })); + let res: DiscoveryPaper[] = (await selectedSource.search(spec.query, 25)).map((paper) => ({ + ...paper, + source: selectedSource.id, + })); // Backfill open-access PDF links (Unpaywall) for results with a DOI but no // PDF — more "PDF" badges appear regardless of which source was used. - if (findPdfs) res = await enrichWithUnpaywall(res); + if (spec.findPdfs) res = await enrichWithUnpaywall(res); setResults(res); + recordSearch(spec, res.length); } catch (e) { const msg = e instanceof Error ? e.message : ''; if (msg === 'needs-key') { - setShowKey(source.keyManagedInVault !== true); - setErr(source.keyManagedInVault === true ? t('read.needsVaultKey') : t('read.needsKey')); + setShowKey(selectedSource.keyManagedInVault !== true); + setErr(selectedSource.keyManagedInVault === true ? t('read.needsVaultKey') : t('read.needsKey')); } else if (msg === 'serpapi-shell-required') { setErr(t('read.serpApiDesktopOnly')); } else { @@ -2100,6 +2311,12 @@ function DiscoverPanel({ } } + useEffect(() => { + if (runRequest === 0 || handledRunRequest.current === runRequest) return; + handledRunRequest.current = runRequest; + void run(); + }, [runRequest]); + function importPaper(p: DiscoveryPaper): void { // Discovery is a batch workflow: save the result in place and let the card // update to “In library” without discarding the search or scroll position. @@ -2186,6 +2403,18 @@ function DiscoverPanel({ placeholder={t('read.discoverPlaceholder')} autoFocus /> + @@ -2430,6 +2659,7 @@ export function ReadSurface(): JSX.Element { const storagePath = useZoteroStorage((s) => s.path); const [mode, setMode] = useState('library'); + const [discoveryView, setDiscoveryView] = useState('explore'); const [collection, setCollection] = useState(ALL); const [tag, setTag] = useState(null); const [tagFilter, setTagFilter] = useState(''); @@ -3206,6 +3436,10 @@ export function ReadSurface(): JSX.Element { {!railCollapsed ? ( <>
+ + )} - {mode === 'discover' ? ( + {mode === 'discover' && discoveryView === 'explore' ? ( { @@ -3349,6 +3585,32 @@ export function ReadSurface(): JSX.Element { setSelected(id); }} /> + ) : mode === 'discover' && discoveryView === 'updates' ? ( + addReference(paperToRef(paper))} + onInspect={(id) => { + setSelected(id); + foldInsp(false); + }} + /> + ) : mode === 'discover' && discoveryView === 'subscriptions' ? ( + + ) : mode === 'discover' && discoveryView === 'trends' ? ( + addReference(paperToRef(paper))} + onInspect={(id) => { + setSelected(id); + foldInsp(false); + }} + /> + ) : mode === 'discover' ? ( + addReference(paperToRef(paper))} + onInspect={(id) => { + setSelected(id); + foldInsp(false); + }} + /> ) : (