@theronap/cortex-mcp 0.9.36 → 0.9.38

package/lib/server.mjs

@@ -167,21 +167,27 @@ export async function runServer(version) {
         const body = await res.text()
         throw new Error(classify(res.status, res.headers.get('content-type'), body, res.headers.get('x-vercel-id')).message)
       }
-      const { people = [], records = [] } = await res.json()
+      const { people = [], records = [], brains = [] } = await res.json()
       if (!people.length && !records.length) return { content: [{ type: 'text', text: `No visible results for "${query}".` }] }
+      // Multi-brain: tag each hit with its brain only when results span more than one (single-brain
+      // callers see no noise). `brains` also carries any brain that errored (fail-soft).
+      const multi = brains.filter((b) => b.ok).length > 1
+      const tag = (brain) => (multi && brain ? `  · ${brain}` : '')
       const lines = []
       if (people.length) {
         lines.push('People:')
         for (const p of people) {
           const meta = [p.title, p.company].filter(Boolean).join(', ')
-          lines.push(`- ${p.name}${meta ? ` (${meta})` : ''} — mentioned in ${p.mentions} record${p.mentions === 1 ? '' : 's'}`)
+          lines.push(`- ${p.name}${meta ? ` (${meta})` : ''} — mentioned in ${p.mentions} record${p.mentions === 1 ? '' : 's'}${tag(p.brain)}`)
         }
       }
       if (records.length) {
         if (lines.length) lines.push('')
         lines.push('Activity:')
-        for (const r of records) lines.push(`- [${r.source}] ${r.title}${r.project ? ` (${r.project})` : ''}`)
+        for (const r of records) lines.push(`- [${r.source}] ${r.title}${r.project ? ` (${r.project})` : ''}${tag(r.brain)}`)
       }
+      const failed = brains.filter((b) => !b.ok)
+      if (failed.length) lines.push('', `(couldn't reach ${failed.length} brain${failed.length === 1 ? '' : 's'}: ${failed.map((b) => b.name).join(', ')})`)
       return { content: [{ type: 'text', text: `Results for "${query}":\n${lines.join('\n')}` }] }
     },
   )
@@ -224,14 +230,24 @@ export async function runServer(version) {
           { headers: { Authorization: `Bearer ${TOKEN}` } })
         if (res.ok) {
           const page = await res.json()
-          if (page?.authored && Array.isArray(page.tiers) && page.tiers.length) {
+          // Multi-brain: /api/brain/page returns matches[] (one per brain that has the page).
+          let matches = Array.isArray(page?.matches) ? page.matches.filter((m) => m.authored && Array.isArray(m.tiers) && m.tiers.length) : []
+          // Rollout back-compat: adapt an older server's single-page shape to one match.
+          if (!matches.length && page?.authored && Array.isArray(page.tiers) && page.tiers.length) {
+            matches = [{ brain: null, authored: true, title: page.title, tiers: page.tiers }]
+          }
+          if (matches.length) {
             const day = (d) => (d ? String(d).slice(0, 10) : '')
-            const blocks = page.tiers.map((t) => {
-              const secs = (t.sections ?? []).map((s) => `### ${s.heading}\n${s.body}`).join('\n\n')
-              const head = `[${t.tier}${day(t.updated_at) ? ` · authored ${day(t.updated_at)}` : ''}${t.validity && t.validity !== 'current' ? ` · ${t.validity}` : ''}]`
-              return [head, t.summary, secs].filter(Boolean).join('\n')
-            })
-            return { content: [{ type: 'text', text: `# ${page.title ?? key} (authored page)\n\n${blocks.join('\n\n---\n\n')}` }] }
+            const renderMatch = (m) => {
+              const blocks = m.tiers.map((t) => {
+                const secs = (t.sections ?? []).map((s) => `### ${s.heading}\n${s.body}`).join('\n\n')
+                const head = `[${t.tier}${day(t.updated_at) ? ` · authored ${day(t.updated_at)}` : ''}${t.validity && t.validity !== 'current' ? ` · ${t.validity}` : ''}]`
+                return [head, t.summary, secs].filter(Boolean).join('\n')
+              })
+              const brainTag = matches.length > 1 ? ` · brain: ${m.brain}` : ''
+              return `# ${m.title ?? key} (authored page${brainTag})\n\n${blocks.join('\n\n---\n\n')}`
+            }
+            return { content: [{ type: 'text', text: matches.map(renderMatch).join('\n\n═══\n\n') }] }
           }
         }
       } catch { /* fall through to the records-derived line */ }
@@ -253,10 +269,28 @@ export async function runServer(version) {
         kind: z.enum(['project', 'person', 'org', 'user']).optional().describe('node kind (default project; pass person/org for people/teams)'),
         expand: z.boolean().optional().describe('identifier names only: also list recent visible timeline events for this identifier (default: home + count)'),
         history: z.boolean().optional().describe('node names only: return the node\'s TIMELINE (events joined via its [[repo:…]] stamps, reverse-chron, viewer-visible) instead of the page body. The page is the present; this is the history.'),
+        version: z.string().optional().describe('read a HISTORICAL version of this page instead of the current one: a rev_no (e.g. "3") or a content_hash from page_history. Use page_history first to see the versions, then rollback_page to restore one.'),
       },
     },
-    async ({ name, kind, expand, history }) => {
+    async ({ name, kind, expand, history, version }) => {
       const k = kind ?? 'project'
+      // PAGE HISTORY (Part A): a specific version reads one historical body, resolved within this page's
+      // own history. Not for identifier-shaped names (those are join keys, handled below).
+      if (version && !/^[a-z][a-z0-9_-]*:.+/i.test(name)) {
+        try {
+          const qs = new URLSearchParams({ kind: k, key: name, version })
+          const vr = await fetchCortex(`${BASE}/api/brain/page?${qs}`, { headers: { Authorization: `Bearer ${TOKEN}` } })
+          if (vr.status === 404) return { content: [{ type: 'text', text: `No version "${version}" for "${name}" (or you can't see it). Use page_history "${name}" to list its versions.` }] }
+          if (!vr.ok) {
+            const d = classify(vr.status, vr.headers.get('content-type'), await vr.text(), vr.headers.get('x-vercel-id'))
+            return { content: [{ type: 'text', text: `Could not read version "${version}" of "${name}": ${d.message}` }] }
+          }
+          const v = await vr.json()
+          return { content: [{ type: 'text', text: `# ${name} — historical version (rev ${v.revNo} · ${v.op} · ${String(v.createdAt).slice(0, 10)} · ${v.tier})\nversion: ${v.version}\n\n${v.body}\n\n— This is a HISTORICAL snapshot, not the current page. \`read_page "${name}"\` (no version) shows what's live; \`rollback_page\` restores this one as a new version.` }] }
+        } catch (e) {
+          return { content: [{ type: 'text', text: `Could not read version "${version}" of "${name}": ${e.message}` }] }
+        }
+      }
       // PER-NODE TIMELINE (slice 4): history = the projection over the node's identifier stamps.
       if (history && !/^[a-z][a-z0-9_-]*:.+/i.test(name)) {
         try {
@@ -327,29 +361,113 @@ export async function runServer(version) {
         return { content: [{ type: 'text', text: `Could not read "${name}": ${d.message}` }] }
       }
       const page = await res.json()
-      if (!page?.authored || !Array.isArray(page.tiers) || !page.tiers.length) {
-        return { content: [{ type: 'text', text: `"${name}" (${k}) exists but has no authored page yet — nothing to read. \`grep\` for mentions, or author it if you hold first-hand knowledge worth capturing.` }] }
+      // Multi-brain (decision 3A): /api/brain/page returns matches[] — one entry per brain that has a
+      // page under this name. One match (the common case) reads exactly as before, plus a brain tag only
+      // when >1 brain matches — never silently one brain's version.
+      let matches = Array.isArray(page?.matches) ? page.matches.filter((m) => m.authored && Array.isArray(m.tiers) && m.tiers.length) : []
+      // Rollout back-compat: an older server returns the single-page shape ({authored, tiers}) with no
+      // matches[]; adapt it to one match so this build works against both old and new deployments.
+      if (!matches.length && page?.authored && Array.isArray(page.tiers) && page.tiers.length) {
+        matches = [{ brain: null, authored: true, ref: page.ref, title: page.title, tiers: page.tiers }]
+      }
+      if (!matches.length) {
+        return { content: [{ type: 'text', text: `No authored ${k} page named "${name}" in any of your brains. If it's a person or team, pass kind (person/org). Otherwise \`grep "${name}"\` to locate it — it may be a red-link (a wanted page that isn't authored yet).` }] }
       }
       const day = (d) => (d ? String(d).slice(0, 10) : '')
-      const blocks = page.tiers.map((t) => {
-        const secs = (t.sections ?? []).map((s) => `### ${s.heading}\n${s.body}`).join('\n\n')
-        // ADR-0018: a null version isn't "nothing to show" — it means this variant predates content-
-        // hash tracking (a 2026-06-29 import scar) and CANNOT be re-authored via base_version until an
-        // admin backfills it. Silently omitting the line here is exactly what sent callers into an
-        // unrecoverable base_version guessing loop; say so explicitly instead.
-        const versionLine = t.version
-          ? `\nversion: ${t.version}`
-          : `\nversion: none (this variant predates content-hash tracking — base_version writes will always fail here; ask an admin about the ADR-0018 backfill)`
-        const head = `[${t.tier}${day(t.updated_at) ? ` · authored ${day(t.updated_at)}` : ''}${t.validity && t.validity !== 'current' ? ` · ${t.validity}` : ''}${versionLine}]`
-        return [head, t.summary, secs].filter(Boolean).join('\n')
+      const renderMatch = (m, tagBrain) => {
+        const blocks = m.tiers.map((t) => {
+          const secs = (t.sections ?? []).map((s) => `### ${s.heading}\n${s.body}`).join('\n\n')
+          // ADR-0018: a null version isn't "nothing to show" — it means this variant predates content-
+          // hash tracking (a 2026-06-29 import scar) and CANNOT be re-authored via base_version until an
+          // admin backfills it. Silently omitting the line here is exactly what sent callers into an
+          // unrecoverable base_version guessing loop; say so explicitly instead.
+          const versionLine = t.version
+            ? `\nversion: ${t.version}`
+            : `\nversion: none (this variant predates content-hash tracking — base_version writes will always fail here; ask an admin about the ADR-0018 backfill)`
+          const head = `[${t.tier}${day(t.updated_at) ? ` · authored ${day(t.updated_at)}` : ''}${t.validity && t.validity !== 'current' ? ` · ${t.validity}` : ''}${versionLine}]`
+          return [head, t.summary, secs].filter(Boolean).join('\n')
+        })
+        let footer = `— Follow any [[links]] above with read_page to go deeper.\n— If you hold fresher FIRST-HAND truth than this page — something you established THIS session (ran the command, made the change, hold the artifact) that a section here gets concretely wrong — re-author just those sections now with \`author\` (any node you are permitted to edit; concise; a material contradiction, not merely extra detail). Pass this page's \`version\` as base_version when you re-author — if the save comes back stale, the page changed under you: re-read, then re-author. Reading a stale page you can fix IS the trigger to fix it.`
+        // slice 4: when the page carries identifier stamps, the history projection is one flag away.
+        const allBody = m.tiers.flatMap((t) => (t.sections ?? []).map((s) => s.body)).join('\n')
+        const stamps = [...new Set((allBody.match(/\[\[repo:[a-z0-9][a-z0-9-]*\/[a-z0-9_.-]+\]\]/gi) ?? []).map((s) => s.toLowerCase()))]
+        if (stamps.length) footer += `\n— This page carries ${stamps.join(', ')} — \`read_page "${name}"\` with history: true for its event timeline (page = present, timeline = history).`
+        const brainTag = tagBrain ? `  ·  brain: ${m.brain}` : ''
+        return `# ${m.title ?? name} (full authored page${brainTag})\n\n${blocks.join('\n\n---\n\n')}\n\n${footer}`
+      }
+      if (matches.length === 1) {
+        return { content: [{ type: 'text', text: renderMatch(matches[0], false) }] }
+      }
+      const header = `"${name}" is authored in ${matches.length} of your brains — all shown (each tagged with its brain, newest tier first):`
+      return { content: [{ type: 'text', text: [header, ...matches.map((m) => renderMatch(m, true))].join('\n\n═══════════════════\n\n') }] }
+    },
+  )
+
+  server.registerTool(
+    'page_history',
+    {
+      title: 'See a wiki page\'s edit history',
+      description: 'Show the VERSION history of an authored wiki page — every prior version, who changed it and when, newest first. This is how you see "what changed on this page and by whom", and it includes privacy changes (re-tiers). Then use `read_page` with a version to view an old body, or `rollback_page` to restore one. (Distinct from read_page\'s `history: true`, which is the raw event timeline via [[repo:…]] stamps.) RLS-scoped: you see history only for pages you may read.',
+      inputSchema: {
+        name: z.string().describe('the canonical node name exactly as written (e.g. "Cortex", "Ben")'),
+        kind: z.enum(['project', 'person', 'org', 'user']).optional().describe('node kind (default project)'),
+        limit: z.number().int().optional().describe('how many recent versions to show (default 20, max 200)'),
+      },
+    },
+    async ({ name, kind, limit }) => {
+      const k = kind ?? 'project'
+      let res
+      try {
+        const qs = new URLSearchParams({ kind: k, key: name, ...(limit ? { limit: String(limit) } : {}) })
+        res = await fetchCortex(`${BASE}/api/brain/page-history?${qs}`, { headers: { Authorization: `Bearer ${TOKEN}` } })
+      } catch (e) {
+        return { content: [{ type: 'text', text: `Could not read history for "${name}": ${e.message}` }] }
+      }
+      if (res.status === 404) return { content: [{ type: 'text', text: `No ${k} named "${name}". Pass kind (person/org) if it isn't a project.` }] }
+      if (!res.ok) {
+        const d = classify(res.status, res.headers.get('content-type'), await res.text(), res.headers.get('x-vercel-id'))
+        return { content: [{ type: 'text', text: `Could not read history for "${name}": ${d.message}` }] }
+      }
+      const out = await res.json()
+      const revs = out.revisions ?? []
+      if (!revs.length) return { content: [{ type: 'text', text: `"${name}" (${k}) has no recorded version history yet.` }] }
+      const lines = revs.map((r) => {
+        const who = r.actor_name ? ` · ${r.actor_name}` : ''
+        const why = r.reason ? ` — ${r.reason}` : ''
+        return `- rev ${r.rev_no} · ${String(r.created_at).slice(0, 10)} · ${r.op} · ${r.tier}${who}${why}\n    version: ${r.content_hash}`
       })
-      let footer = `— Follow any [[links]] above with read_page to go deeper.\n— If you hold fresher FIRST-HAND truth than this page — something you established THIS session (ran the command, made the change, hold the artifact) that a section here gets concretely wrong — re-author just those sections now with \`author\` (any node you are permitted to edit; concise; a material contradiction, not merely extra detail). Pass this page's \`version\` as base_version when you re-author — if the save comes back stale, the page changed under you: re-read, then re-author. Reading a stale page you can fix IS the trigger to fix it.`
-      // slice 4: when the page carries identifier stamps, the history projection is one flag away.
-      // (client-side shape check — the acknowledged registry copy of identifiers.ts)
-      const allBody = page.tiers.flatMap((t) => (t.sections ?? []).map((s) => s.body)).join('\n')
-      const stamps = [...new Set((allBody.match(/\[\[repo:[a-z0-9][a-z0-9-]*\/[a-z0-9_.-]+\]\]/gi) ?? []).map((s) => s.toLowerCase()))]
-      if (stamps.length) footer += `\n— This page carries ${stamps.join(', ')} — \`read_page "${name}"\` with history: true for its event timeline (page = present, timeline = history).`
-      return { content: [{ type: 'text', text: `# ${page.title ?? name} (full authored page)\n\n${blocks.join('\n\n---\n\n')}\n\n${footer}` }] }
+      return { content: [{ type: 'text', text: `# ${name} — page history (newest first)\n${lines.join('\n')}\n\n— \`read_page "${name}"\` with version:<rev_no|version> to view an old body; \`rollback_page\` to restore one.` }] }
+    },
+  )
+
+  server.registerTool(
+    'rollback_page',
+    {
+      title: 'Roll a wiki page back to a prior version',
+      description: 'Restore a wiki page to an earlier version from its page_history — a forward, non-destructive write (the old versions are kept; a new "rollback" version is recorded). Use this to undo a mistaken or bad edit. You may only roll back a page you are allowed to edit. Find the target version with page_history first.',
+      inputSchema: {
+        name: z.string().describe('the exact page name'),
+        kind: z.enum(['project', 'person', 'org', 'user']).optional().describe('node kind (default project)'),
+        to_version: z.string().describe('which version to restore: a rev_no (e.g. "3") or a content_hash, from page_history'),
+        tier: z.enum(['accessible', 'scoped', 'confidential']).optional().describe('which tier variant to roll back, if the node has more than one'),
+        reason: z.string().optional().describe('optional note recorded on the new rollback version (why you rolled back)'),
+      },
+    },
+    async ({ name, kind, to_version, tier, reason }) => {
+      const k = kind ?? 'project'
+      let res
+      try {
+        res = await fetchCortex(`${BASE}/api/brain/rollback`, {
+          method: 'POST',
+          headers: { Authorization: `Bearer ${TOKEN}`, 'Content-Type': 'application/json' },
+          body: JSON.stringify({ kind: k, name, to_version, ...(tier ? { tier } : {}), ...(reason ? { reason } : {}) }),
+        })
+      } catch (e) {
+        return { content: [{ type: 'text', text: `Could not roll back "${name}": ${e.message}` }] }
+      }
+      const out = await res.json().catch(() => null)
+      if (!res.ok) return { content: [{ type: 'text', text: `Could not roll back "${name}": ${out?.error ?? res.status}` }] }
+      return { content: [{ type: 'text', text: `Done — "${name}" ${out.note}. \`read_page "${name}"\` to confirm the current content.` }] }
     },
   )
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@theronap/cortex-mcp",
-  "version": "0.9.36",
+  "version": "0.9.38",
   "description": "Connect your AI assistant to Cortex — your org's projects, activity, gaps, and directives, scoped to you.",
   "type": "module",
   "bin": {