reading-feed-mcp 0.1.0

package/.claude/skills/reading-feed/SKILL.md

@@ -0,0 +1,80 @@
+# /reading-feed — Search your reading queue from Claude Code
+
+Trigger: user says /reading-feed, "search my reading", "what did I save about X", "find that article I saved"
+
+## What this skill does
+
+Searches across all configured reading sources (Burn 451, Readwise, Karakeep, RSS, local markdown notes) using the `reading-feed-mcp` server.
+
+## Setup
+
+Install the MCP server once:
+```bash
+claude mcp add reading-feed -- npx reading-feed-mcp
+```
+
+Set env vars for whatever sources you use (at least one required):
+```bash
+export BURN_MCP_TOKEN=bmcp_xxx          # burn451.cloud
+export READWISE_TOKEN=xxx               # readwise.io/access_token
+export KARAKEEP_URL=https://xxx.app
+export KARAKEEP_TOKEN=xxx
+export READING_FEED_RSS="https://feed1,https://feed2"
+export READING_FEED_MARKDOWN_DIR=~/notes
+```
+
+## When to use
+
+- **Active research** — user asks about a topic they might have saved context on
+- **"That article I read..."** — user vaguely remembers something
+- **Before writing** — search their own knowledge before inventing from scratch
+- **Morning context load** — pull recent items as session context
+
+## Example prompts
+
+### Search everything
+```
+> Find articles I saved about MCP authentication
+
+Calls: search_reading(query="MCP authentication")
+Result: combined results from all 5 sources
+```
+
+### Restrict to specific source
+```
+> Show me the 10 most recent Readwise items
+
+Calls: list_recent(source="readwise", limit=10)
+```
+
+### Check what's configured
+```
+> What reading sources do I have set up?
+
+Calls: list_sources()
+```
+
+## Display format
+
+Return results as a compact table grouped by source:
+
+```markdown
+### 🔥 From Burn (3 matches)
+| Title | URL | Status | Summary |
+|---|---|---|---|
+| ... | ... | flame 2h | ... |
+
+### 📚 From Readwise (2 matches)
+...
+
+### 📡 From RSS feeds (1 match)
+...
+```
+
+Include the URL so user can click through. Always include the summary — it's the whole point (fast decision without opening each link).
+
+## Tips
+
+- If `search_reading` returns nothing, try broader keywords (single-word)
+- Burn results include `status` (flame = urgent, vault = kept, spark = read) — surface this
+- For "what's new", use `list_recent` per source instead of `search_reading`

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Fisher Hawking (@hawking520)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,161 @@
+<div align="center">
+
+# reading-feed-mcp
+
+**Your reading queue, searchable from Claude Code. Stop re-googling what you already saved.**
+
+[![npm version](https://img.shields.io/npm/v/reading-feed-mcp.svg)](https://www.npmjs.com/package/reading-feed-mcp)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![X: @hawking520](https://img.shields.io/twitter/follow/hawking520?style=social)](https://x.com/hawking520)
+
+One MCP server. Five reading sources. Zero vendor lock-in.
+
+</div>
+
+---
+
+## The problem
+
+Every Claude Code session starts amnesiac. You saved 300 articles this year. You remember reading something about the exact pattern you're implementing right now. But it's in Readwise. Or Pocket. Or Karakeep. Or Burn. Or that folder of markdown notes.
+
+So you re-google. Again.
+
+[claude-code#27298](https://github.com/anthropics/claude-code/issues/27298) has 22 comments about this. Readwise built [their own MCP](https://github.com/readwiseio/readwise-mcp) — but it only works if you use Readwise. Everyone else is stuck.
+
+## The fix
+
+`reading-feed-mcp` is a **vendor-neutral MCP server** that makes your reading queue queryable from any MCP client (Claude Code, Claude Desktop, Cursor, Windsurf).
+
+Configure one or more sources. Get three tools:
+
+- `search_reading(query)` — full-text search across everything
+- `list_recent(source)` — latest items from a source
+- `list_sources` — what you've wired up
+
+That's it. No new account. No cloud. No lock-in.
+
+## Supported sources
+
+| Source | What you need | Status |
+|---|---|---|
+| **[Burn 451](https://burn451.cloud)** | `BURN_MCP_TOKEN` | ✅ |
+| **[Readwise Reader](https://readwise.io)** | `READWISE_TOKEN` | ✅ |
+| **[Karakeep](https://karakeep.app)** (self-hosted) | `KARAKEEP_URL` + `KARAKEEP_TOKEN` | ✅ |
+| **RSS feeds** | `READING_FEED_RSS` (comma-separated URLs) | ✅ |
+| **Local markdown** | `READING_FEED_MARKDOWN_DIR` | ✅ |
+| Raindrop / Omnivore / Pocket export | — | 🔜 v0.2 |
+
+Configure any combination. Search spans all of them.
+
+## Setup (60 seconds)
+
+### 1. Install
+
+```bash
+claude mcp add reading-feed -- npx reading-feed-mcp@latest
+```
+
+### 2. Set sources via env vars
+
+At least one required. Use whichever you actually have:
+
+```bash
+# Burn 451 — get token at burn451.cloud/settings
+export BURN_MCP_TOKEN=bmcp_xxx
+
+# Readwise Reader — get token at readwise.io/access_token
+export READWISE_TOKEN=xxx
+
+# Karakeep (self-hosted)
+export KARAKEEP_URL=https://karakeep.your-domain.com
+export KARAKEEP_TOKEN=xxx
+
+# RSS feeds (comma-separated)
+export READING_FEED_RSS="https://simonwillison.net/atom/everything/,https://karpathy.bearblog.dev/feed/"
+
+# Local markdown notes
+export READING_FEED_MARKDOWN_DIR=~/notes
+```
+
+### 3. Use it
+
+In Claude Code, just ask:
+
+```
+> Find articles I saved about MCP authentication
+```
+
+Claude calls `search_reading(query="MCP authentication")` and returns matches across all your sources.
+
+## Example output
+
+```json
+{
+  "query": "MCP authentication",
+  "total": 4,
+  "results": [
+    {
+      "source": "burn",
+      "title": "MCP Auth Patterns in 2026",
+      "url": "https://example.com/mcp-auth",
+      "status": "active",
+      "summary": "Compares OAuth device flow, API keys, and JWT exchange for MCP servers..."
+    },
+    {
+      "source": "readwise",
+      "title": "Building Secure MCP Servers",
+      "url": "https://example.com/secure-mcp",
+      "status": "later",
+      "summary": "Step-by-step guide to token exchange..."
+    },
+    {
+      "source": "rss",
+      "title": "Simon Willison: MCP Server Deep Dive",
+      "url": "https://simonwillison.net/...",
+      "feed": "Simon Willison's Weblog"
+    }
+  ]
+}
+```
+
+## Why "vendor-neutral" matters
+
+Most reading tools want you to use their ecosystem. Readwise MCP is Readwise-only. Pocket is dead. Omnivore is dead. If your reading tool dies, your reading dies with it.
+
+`reading-feed-mcp` is the opposite: **bring your own source.** Switch services, keep the MCP. We don't store your data. We don't host anything. We're a thin query layer.
+
+## Best with Burn — but works with anything
+
+[Burn 451](https://burn451.cloud) is recommended because:
+- 24h countdown surfaces urgency (search result has `status: "active"` with time remaining)
+- AI summaries embedded in every article (search works on summaries, not just titles)
+- Free tier, no credit card
+
+But the whole point is you don't have to use Burn. If you live in Readwise, use Readwise. Live in markdown files? Point the MCP at your folder.
+
+## How it's built
+
+- Zero-dep Node.js (except `@modelcontextprotocol/sdk`)
+- Each source is one file (<100 lines) — add a new one via PR in 20 minutes
+- Stdio transport (standard MCP pattern)
+- Token caching (5-min TTL) so you don't thrash upstream APIs
+
+## Part of the Burn ecosystem
+
+| Tool | What it does |
+|---|---|
+| **reading-feed-mcp** (this) | Vendor-neutral MCP for any reading source |
+| [burn-mcp-server](https://github.com/Fisher521/burn-mcp-server) | Burn-specific MCP (26 tools, full control) |
+| [burn451 CLI](https://github.com/Fisher521/burn451-cli) | Terminal queue management |
+| [burn-claude-skill](https://github.com/Fisher521/burn-claude-skill) | /burn command for CC |
+| [burn-daily-triage](https://github.com/Fisher521/burn-daily-triage) | Daily CC Routine template |
+| [morning-brief](https://github.com/Fisher521/morning-brief) | Daily briefing CLI |
+| [reading-digest](https://github.com/Fisher521/reading-digest) | Weekly digest generator |
+
+## Contributing
+
+New source adapter? Each one lives in `src/sources/<name>.mjs`, exports `search({...})` and `listRecent({...})`. See `src/sources/burn.mjs` for the simplest example (~50 lines).
+
+## License
+
+MIT

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "reading-feed-mcp",
+  "version": "0.1.0",
+  "description": "Vendor-neutral MCP server: search your reading queue across Burn/Readwise/Karakeep/RSS/markdown from Claude Code or any MCP client.",
+  "type": "module",
+  "main": "src/index.mjs",
+  "bin": {
+    "reading-feed-mcp": "src/index.mjs"
+  },
+  "scripts": {
+    "start": "node src/index.mjs"
+  },
+  "keywords": [
+    "mcp",
+    "mcp-server",
+    "reading",
+    "bookmarks",
+    "claude",
+    "claude-code",
+    "anthropic",
+    "readwise",
+    "karakeep",
+    "burn",
+    "rss",
+    "read-later",
+    "knowledge-management",
+    "ai-tools"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Fisher521/reading-feed-mcp.git"
+  },
+  "homepage": "https://github.com/Fisher521/reading-feed-mcp",
+  "license": "MIT",
+  "author": "hawking520 <hawking520@gmail.com> (https://x.com/hawking520)",
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0"
+  }
+}

package/src/index.mjs

@@ -0,0 +1,125 @@
+#!/usr/bin/env node
+// reading-feed-mcp — Vendor-neutral MCP server for reading queues
+//
+// Exposes 3 tools:
+//   search_reading   — full-text search across all configured sources
+//   list_recent      — latest items from a specific source
+//   list_sources     — which sources are configured
+
+import { Server } from '@modelcontextprotocol/sdk/server/index.js'
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'
+import { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js'
+
+import * as burn from './sources/burn.mjs'
+import * as readwise from './sources/readwise.mjs'
+import * as karakeep from './sources/karakeep.mjs'
+import * as rss from './sources/rss.mjs'
+import * as markdown from './sources/markdown.mjs'
+
+// --- Build enabled-sources map from env ---
+function getConfig() {
+  const cfg = {}
+  if (process.env.BURN_MCP_TOKEN) {
+    cfg.burn = { token: process.env.BURN_MCP_TOKEN, adapter: burn }
+  }
+  if (process.env.READWISE_TOKEN) {
+    cfg.readwise = { token: process.env.READWISE_TOKEN, adapter: readwise }
+  }
+  if (process.env.KARAKEEP_URL && process.env.KARAKEEP_TOKEN) {
+    cfg.karakeep = { url: process.env.KARAKEEP_URL, token: process.env.KARAKEEP_TOKEN, adapter: karakeep }
+  }
+  if (process.env.READING_FEED_RSS) {
+    cfg.rss = { feeds: process.env.READING_FEED_RSS.split(',').map(s => s.trim()), adapter: rss }
+  }
+  if (process.env.READING_FEED_MARKDOWN_DIR) {
+    cfg.markdown = { dir: process.env.READING_FEED_MARKDOWN_DIR, adapter: markdown }
+  }
+  return cfg
+}
+
+const server = new Server(
+  { name: 'reading-feed-mcp', version: '0.1.0' },
+  { capabilities: { tools: {} } }
+)
+
+server.setRequestHandler(ListToolsRequestSchema, async () => ({
+  tools: [
+    {
+      name: 'search_reading',
+      description: 'Full-text search across all configured reading sources (Burn/Readwise/Karakeep/RSS/markdown). Returns matching articles with title, URL, source, summary.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          query: { type: 'string', description: 'Search query (keywords)' },
+          sources: { type: 'array', items: { type: 'string' }, description: 'Optional: restrict to specific sources (burn, readwise, karakeep, rss, markdown)' },
+          limit: { type: 'number', description: 'Max results per source (default 10)', default: 10 },
+        },
+        required: ['query'],
+      },
+    },
+    {
+      name: 'list_recent',
+      description: 'List the most recent articles from a specific source. Use this to see what is new in your reading queue.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          source: { type: 'string', description: 'Source name (burn, readwise, karakeep, rss, markdown)' },
+          limit: { type: 'number', description: 'Max results (default 20)', default: 20 },
+        },
+        required: ['source'],
+      },
+    },
+    {
+      name: 'list_sources',
+      description: 'List all configured reading sources. Use this to know what sources are available.',
+      inputSchema: { type: 'object', properties: {} },
+    },
+  ],
+}))
+
+server.setRequestHandler(CallToolRequestSchema, async (req) => {
+  const { name, arguments: args = {} } = req.params
+  const cfg = getConfig()
+
+  if (name === 'list_sources') {
+    return {
+      content: [{ type: 'text', text: JSON.stringify({ configured: Object.keys(cfg), available_env_vars: ['BURN_MCP_TOKEN', 'READWISE_TOKEN', 'KARAKEEP_URL+KARAKEEP_TOKEN', 'READING_FEED_RSS', 'READING_FEED_MARKDOWN_DIR'] }, null, 2) }],
+    }
+  }
+
+  if (name === 'search_reading') {
+    const { query, sources, limit = 10 } = args
+    const activeSources = sources && sources.length ? sources.filter(s => cfg[s]) : Object.keys(cfg)
+    if (activeSources.length === 0) {
+      return { content: [{ type: 'text', text: 'No sources configured. Set env vars (see list_sources).' }] }
+    }
+    const results = await Promise.all(activeSources.map(async s => {
+      try {
+        return await cfg[s].adapter.search({ ...cfg[s], query, limit })
+      } catch (e) {
+        return [{ source: s, error: e.message }]
+      }
+    }))
+    const flat = results.flat()
+    return { content: [{ type: 'text', text: JSON.stringify({ query, total: flat.length, results: flat }, null, 2) }] }
+  }
+
+  if (name === 'list_recent') {
+    const { source, limit = 20 } = args
+    if (!cfg[source]) {
+      return { content: [{ type: 'text', text: `Source "${source}" not configured. Available: ${Object.keys(cfg).join(', ') || 'none'}` }] }
+    }
+    try {
+      const items = await cfg[source].adapter.listRecent({ ...cfg[source], limit })
+      return { content: [{ type: 'text', text: JSON.stringify({ source, count: items.length, items }, null, 2) }] }
+    } catch (e) {
+      return { content: [{ type: 'text', text: `Error: ${e.message}` }] }
+    }
+  }
+
+  return { content: [{ type: 'text', text: `Unknown tool: ${name}` }], isError: true }
+})
+
+const transport = new StdioServerTransport()
+await server.connect(transport)
+console.error('[reading-feed-mcp] ready — stdio')

package/src/sources/burn.mjs

@@ -0,0 +1,71 @@
+// Burn 451 source — https://burn451.cloud
+// Requires BURN_MCP_TOKEN (burn451.cloud/settings → MCP Server)
+
+const EXCHANGE_URL = 'https://api.burn451.cloud/api/mcp-exchange'
+const SUPABASE_URL = 'https://juqtxylquemiuvvmgbej.supabase.co'
+const ANON_KEY = 'sb_publishable_reVgmmCC6ndIo6jFRMM2LQ_wujj5FrO'
+
+let cachedJwt = null
+let cachedUntil = 0
+
+async function getJwt(token) {
+  if (cachedJwt && Date.now() < cachedUntil) return cachedJwt
+  const resp = await fetch(EXCHANGE_URL, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ token }),
+  })
+  if (!resp.ok) throw new Error(`Burn token exchange failed: ${resp.status}`)
+  const { access_token } = await resp.json()
+  cachedJwt = access_token
+  cachedUntil = Date.now() + 270000 // 4.5 min
+  return access_token
+}
+
+export async function search({ token, query, limit = 20 }) {
+  if (!token) throw new Error('BURN_MCP_TOKEN required')
+  const jwt = await getJwt(token)
+  const headers = { apikey: ANON_KEY, Authorization: `Bearer ${jwt}` }
+
+  let path
+  if (query) {
+    const q = encodeURIComponent(`*${query}*`)
+    path = `/bookmarks?or=(title.ilike.${q},url.ilike.${q})&order=created_at.desc&limit=${limit}&select=id,title,url,status,created_at,countdown_expires_at,content_metadata`
+  } else {
+    path = `/bookmarks?order=created_at.desc&limit=${limit}&select=id,title,url,status,created_at,countdown_expires_at,content_metadata`
+  }
+
+  const resp = await fetch(`${SUPABASE_URL}/rest/v1${path}`, { headers })
+  if (!resp.ok) throw new Error(`Burn API ${resp.status}`)
+  const items = await resp.json()
+  return items.map(b => ({
+    source: 'burn',
+    id: b.id,
+    title: b.title || '(untitled)',
+    url: b.url,
+    status: b.status,
+    saved_at: b.created_at,
+    expires_at: b.countdown_expires_at,
+    summary: b.content_metadata?.ai_summary_en || b.content_metadata?.ai_summary || '',
+  }))
+}
+
+export async function listRecent({ token, status = 'active', limit = 20 }) {
+  if (!token) throw new Error('BURN_MCP_TOKEN required')
+  const jwt = await getJwt(token)
+  const headers = { apikey: ANON_KEY, Authorization: `Bearer ${jwt}` }
+  const path = `/bookmarks?status=eq.${status}&order=created_at.desc&limit=${limit}&select=id,title,url,status,created_at,countdown_expires_at,content_metadata`
+  const resp = await fetch(`${SUPABASE_URL}/rest/v1${path}`, { headers })
+  if (!resp.ok) throw new Error(`Burn API ${resp.status}`)
+  const items = await resp.json()
+  return items.map(b => ({
+    source: 'burn',
+    id: b.id,
+    title: b.title || '(untitled)',
+    url: b.url,
+    status: b.status,
+    saved_at: b.created_at,
+    expires_at: b.countdown_expires_at,
+    summary: b.content_metadata?.ai_summary_en || b.content_metadata?.ai_summary || '',
+  }))
+}

package/src/sources/karakeep.mjs

@@ -0,0 +1,30 @@
+// Karakeep source (self-hosted bookmarks, formerly Hoarder) — https://karakeep.app
+// Requires KARAKEEP_URL + KARAKEEP_TOKEN
+
+export async function search({ url, token, query, limit = 20 }) {
+  if (!url || !token) throw new Error('KARAKEEP_URL + KARAKEEP_TOKEN required')
+  const baseUrl = url.replace(/\/$/, '')
+  const endpoint = query
+    ? `${baseUrl}/api/v1/bookmarks/search?q=${encodeURIComponent(query)}&limit=${limit}`
+    : `${baseUrl}/api/v1/bookmarks?limit=${limit}`
+  const resp = await fetch(endpoint, {
+    headers: { Authorization: `Bearer ${token}` },
+  })
+  if (!resp.ok) throw new Error(`Karakeep API ${resp.status}`)
+  const data = await resp.json()
+  const items = data.bookmarks || data.results || data || []
+  return items.slice(0, limit).map(b => ({
+    source: 'karakeep',
+    id: b.id,
+    title: b.title || b.content?.title || '(untitled)',
+    url: b.content?.url || b.url || '',
+    status: b.archived ? 'archived' : 'active',
+    saved_at: b.createdAt,
+    summary: b.note || b.content?.description || b.summary || '',
+    tags: (b.tags || []).map(t => t.name || t),
+  }))
+}
+
+export async function listRecent({ url, token, limit = 20 }) {
+  return search({ url, token, query: null, limit })
+}

package/src/sources/markdown.mjs

@@ -0,0 +1,58 @@
+// Local markdown source — read URLs from a local markdown notes directory
+// Requires: dir (path to directory with .md files containing URLs)
+
+import { readFileSync, readdirSync, statSync } from 'node:fs'
+import { join } from 'node:path'
+
+export async function search({ dir, query, limit = 20 }) {
+  if (!dir) throw new Error('markdown.dir required')
+
+  const files = walkDir(dir).filter(f => f.endsWith('.md'))
+  const items = []
+
+  for (const file of files) {
+    try {
+      const content = readFileSync(file, 'utf8')
+      const stat = statSync(file)
+      const urls = content.match(/https?:\/\/[^\s)\]]+/g) || []
+      // Extract title from first heading or filename
+      const titleMatch = content.match(/^#\s+(.+)$/m)
+      const title = titleMatch ? titleMatch[1] : file.split('/').pop()
+
+      for (const url of urls) {
+        items.push({
+          source: 'markdown',
+          title,
+          url,
+          file: file.replace(dir, '').replace(/^\//, ''),
+          saved_at: stat.mtime.toISOString(),
+          summary: content.slice(0, 500),
+        })
+      }
+    } catch {}
+  }
+
+  const q = (query || '').toLowerCase()
+  const filtered = q
+    ? items.filter(i => i.title.toLowerCase().includes(q) || i.summary.toLowerCase().includes(q) || i.url.toLowerCase().includes(q))
+    : items
+  return filtered
+    .sort((a, b) => new Date(b.saved_at || 0) - new Date(a.saved_at || 0))
+    .slice(0, limit)
+}
+
+export async function listRecent(cfg) {
+  return search({ ...cfg, query: null })
+}
+
+function walkDir(dir, files = []) {
+  try {
+    for (const entry of readdirSync(dir)) {
+      const full = join(dir, entry)
+      const s = statSync(full)
+      if (s.isDirectory()) walkDir(full, files)
+      else files.push(full)
+    }
+  } catch {}
+  return files
+}

package/src/sources/readwise.mjs

@@ -0,0 +1,44 @@
+// Readwise source — https://readwise.io
+// Requires READWISE_TOKEN (readwise.io/access_token)
+
+const API_BASE = 'https://readwise.io/api/v3/list/'
+
+export async function search({ token, query, limit = 20 }) {
+  if (!token) throw new Error('READWISE_TOKEN required')
+  // Readwise Reader API doesn't have full-text search; fetch + filter client-side
+  const url = `${API_BASE}?pageSize=50`
+  const resp = await fetch(url, { headers: { Authorization: `Token ${token}` } })
+  if (!resp.ok) throw new Error(`Readwise API ${resp.status}`)
+  const data = await resp.json()
+  const docs = data.results || []
+  const q = (query || '').toLowerCase()
+  const filtered = q
+    ? docs.filter(d => (d.title || '').toLowerCase().includes(q) || (d.summary || '').toLowerCase().includes(q))
+    : docs
+  return filtered.slice(0, limit).map(d => ({
+    source: 'readwise',
+    id: d.id,
+    title: d.title || '(untitled)',
+    url: d.source_url || d.url || '',
+    status: d.location,
+    saved_at: d.saved_at,
+    summary: (d.summary || '').slice(0, 500),
+  }))
+}
+
+export async function listRecent({ token, location = 'later', limit = 20 }) {
+  if (!token) throw new Error('READWISE_TOKEN required')
+  const url = `${API_BASE}?location=${encodeURIComponent(location)}&pageSize=${limit}`
+  const resp = await fetch(url, { headers: { Authorization: `Token ${token}` } })
+  if (!resp.ok) throw new Error(`Readwise API ${resp.status}`)
+  const data = await resp.json()
+  return (data.results || []).map(d => ({
+    source: 'readwise',
+    id: d.id,
+    title: d.title || '(untitled)',
+    url: d.source_url || d.url || '',
+    status: d.location,
+    saved_at: d.saved_at,
+    summary: (d.summary || '').slice(0, 500),
+  }))
+}

package/src/sources/rss.mjs

@@ -0,0 +1,54 @@
+// RSS source — pull from any RSS feed URL
+// Requires: feeds array (strings)
+
+export async function search({ feeds = [], query, limit = 20 }) {
+  if (!Array.isArray(feeds) || feeds.length === 0) {
+    throw new Error('rss requires feeds array')
+  }
+  const all = []
+  await Promise.all(feeds.map(async feed => {
+    try {
+      const resp = await fetch(feed, { headers: { 'User-Agent': 'reading-feed-mcp/0.1' } })
+      if (!resp.ok) return
+      const xml = await resp.text()
+      const feedTitle = extractTag(xml.slice(0, 4000), 'title') || new URL(feed).hostname
+      for (const m of xml.matchAll(/<item[\s\S]*?<\/item>|<entry[\s\S]*?<\/entry>/gi)) {
+        const block = m[0]
+        const title = extractTag(block, 'title') || '(untitled)'
+        const linkMatch = block.match(/<link[^>]*href=["']([^"']+)["']/i) || block.match(/<link>([^<]+)<\/link>/i)
+        const link = linkMatch ? (linkMatch[1] || linkMatch[0]) : ''
+        const pubDate = extractTag(block, 'pubDate') || extractTag(block, 'updated') || extractTag(block, 'published')
+        const summary = stripHtml(extractTag(block, 'description') || extractTag(block, 'summary') || extractTag(block, 'content') || '')
+        all.push({
+          source: 'rss',
+          title,
+          url: link,
+          feed: feedTitle,
+          saved_at: pubDate,
+          summary: summary.slice(0, 500),
+        })
+      }
+    } catch {}
+  }))
+
+  const q = (query || '').toLowerCase()
+  const filtered = q
+    ? all.filter(i => i.title.toLowerCase().includes(q) || i.summary.toLowerCase().includes(q))
+    : all
+  return filtered
+    .sort((a, b) => new Date(b.saved_at || 0) - new Date(a.saved_at || 0))
+    .slice(0, limit)
+}
+
+export async function listRecent(cfg) {
+  return search({ ...cfg, query: null })
+}
+
+function extractTag(s, tag) {
+  const m = s.match(new RegExp(`<${tag}(?:\\s[^>]*)?>([\\s\\S]*?)<\\/${tag}>`, 'i'))
+  if (!m) return ''
+  return m[1].replace(/<!\[CDATA\[([\s\S]*?)\]\]>/g, '$1').trim()
+}
+function stripHtml(s) {
+  return s.replace(/<[^>]+>/g, '').replace(/\s+/g, ' ').trim()
+}