@theronap/cortex-mcp 0.9.46 → 0.9.47

package/lib/grep_cli.mjs

@@ -33,7 +33,14 @@ export function parseGrepArgs(argv = []) {
 // Pure: render a /api/grep payload to readable ASCII text.
 export function formatGrepHits(payload, query) {
   const hits = (payload && payload.hits) || []
-  if (!hits.length) return `No matches for "${query}".`
+  if (!hits.length) {
+    // Reactive red-link hint — ONLY when the query looks like a page NAME (short, no code/operators), so
+    // code and typo searches don't get nagged. read_page carries the full triage (node / new / alias).
+    const nameish = /^[\w .'-]{2,40}$/.test(query) && query.split(/\s+/).length <= 5
+    return nameish
+      ? `No matches for "${query}". If you expected a page here, it may be an unauthored red-link — \`read_page "${query}"\` to triage it (author it, or alias it to an existing page).`
+      : `No matches for "${query}".`
+  }
   const lines = [`${hits.length} match${hits.length === 1 ? '' : 'es'} for "${query}":`, '']
   for (const h of hits) {
     const head = h.heading ? ` > ${h.heading}` : ''

package/lib/server.mjs

@@ -10,6 +10,29 @@ import { runSendImessage } from './imessage_send.mjs'
 import { formatGrepHits } from './grep_cli.mjs'
 import { runCodeGraphQuery } from './code_graph_cli.mjs'
 
+// Reactive red-link triage (Mechanism 2). On a read_page miss, ask the server whether the name is a
+// tracked wanted page and whether a bare node exists for it, and turn that into an actionable 3-way
+// prompt (author-for-node / author-new / alias). Returns '' on any error so a miss never gets worse.
+async function redLinkTriage(BASE, TOKEN, name) {
+  try {
+    const r = await fetchCortex(`${BASE}/api/brain/red-link?name=${encodeURIComponent(name)}`, {
+      headers: { Authorization: `Bearer ${TOKEN}` },
+    })
+    if (!r.ok) return ''
+    const t = await r.json()
+    const refs = t.tracked
+      ? ` It's referenced by ${t.refCount} page${t.refCount === 1 ? '' : 's'}${t.isSteward ? ' and is routed to YOU as its most-likely steward' : ''}.`
+      : ''
+    const aliasHint = `if it's really an existing page under another title, \`grep "${name}"\` to find it, then \`alias_page name="${name}" target_name="<that page>"\``
+    if (t.category === 'node') {
+      return `\n\n[[${name}]] is a wanted page — a ${t.isPerson ? 'person' : 'node'} exists but has no page yet.${refs} Either author it now with \`author\`, or ${aliasHint}.`
+    }
+    return `\n\n"${name}" isn't authored anywhere yet.${refs} Either author a new page with \`author\`, or ${aliasHint}.`
+  } catch {
+    return ''
+  }
+}
+
 // The Cortex MCP server (stdio). Serves the signed-in employee's scoped org
 // context to their AI assistant. CORTEX_TOKEN identifies the user + org.
 
@@ -444,7 +467,7 @@ export async function runServer(version) {
         return { content: [{ type: 'text', text: `Could not read "${name}": ${e.message}` }] }
       }
       if (res.status === 404) {
-        return { content: [{ type: 'text', text: `No ${k} page named "${name}". 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).` }] }
+        return { content: [{ type: 'text', text: `No ${k} page named "${name}". If it's a person or team, pass kind (person/org).${await redLinkTriage(BASE, TOKEN, name)}` }] }
       }
       if (!res.ok) {
         const d = classify(res.status, res.headers.get('content-type'), await res.text(), res.headers.get('x-vercel-id'))
@@ -461,7 +484,7 @@ export async function runServer(version) {
         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).` }] }
+        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).${await redLinkTriage(BASE, TOKEN, name)}` }] }
       }
       const day = (d) => (d ? String(d).slice(0, 10) : '')
       const renderMatch = (m, tagBrain) => {
@@ -812,6 +835,63 @@ export async function runServer(version) {
     },
   )
 
+  server.registerTool(
+    'alias_page',
+    {
+      title: 'Point a wanted name at an existing page',
+      description: 'Record that a red-link — a [[Name]] referenced in the wiki but never authored — actually MEANS an existing authored page under a different title. After this, read_page and [[links]] for that name resolve to the target page, and the name leaves the org\'s wanted-page backlog. Use this when read_page says a name is a wanted page but you recognize it as an existing page (e.g. [[tto]] -> "BYU TTO — Technology Transfer Office"). To CREATE a genuinely new page instead, use `author`.',
+      inputSchema: {
+        name: z.string().describe('the wanted [[Name]] to redirect (the red-link)'),
+        target_name: z.string().describe('the exact title of the existing authored page it should resolve to'),
+        target_kind: z.enum(['project', 'person', 'org', 'user']).optional().describe('disambiguate the target if two pages share a title'),
+      },
+    },
+    async ({ name, target_name, target_kind }) => {
+      let res
+      try {
+        res = await fetchCortex(`${BASE}/api/brain/alias`, {
+          method: 'POST',
+          headers: { Authorization: `Bearer ${TOKEN}`, 'Content-Type': 'application/json' },
+          body: JSON.stringify({ name, target_name, ...(target_kind ? { target_kind } : {}) }),
+        })
+      } catch (e) {
+        return { content: [{ type: 'text', text: `Could not alias: ${e.message}` }] }
+      }
+      const out = await res.json().catch(() => null)
+      if (!res.ok) return { content: [{ type: 'text', text: `Could not alias "${name}": ${out?.error ?? res.status}` }] }
+      if (!out) return { content: [{ type: 'text', text: `Aliased "${name}", but the server returned no body — re-read the page to confirm.` }] }
+      return { content: [{ type: 'text', text: `Done — [[${out.alias}]] now resolves to "${out.target}" (${out.target_kind}). It's out of the wanted-page backlog.` }] }
+    },
+  )
+
+  server.registerTool(
+    'snooze_red_link',
+    {
+      title: 'Defer a wanted page routed to you',
+      description: 'Stop a wanted page (a red-link the org routed to you as its most-likely steward) from surfacing in your context for a while. Use when you can\'t author it right now but it is genuinely yours to write. It comes back after the snooze passes. To dismiss it permanently, author it (`author`) or alias it to an existing page (`alias_page`).',
+      inputSchema: {
+        name: z.string().describe('the wanted page name to snooze (as shown in "Pages the org needs you to author")'),
+        days: z.number().int().positive().optional().describe('how many days to defer (default 7)'),
+      },
+    },
+    async ({ name, days }) => {
+      let res
+      try {
+        res = await fetchCortex(`${BASE}/api/brain/red-link/snooze`, {
+          method: 'POST',
+          headers: { Authorization: `Bearer ${TOKEN}`, 'Content-Type': 'application/json' },
+          body: JSON.stringify({ name, ...(days ? { days } : {}) }),
+        })
+      } catch (e) {
+        return { content: [{ type: 'text', text: `Could not snooze: ${e.message}` }] }
+      }
+      const out = await res.json().catch(() => null)
+      if (!res.ok) return { content: [{ type: 'text', text: `Could not snooze "${name}": ${out?.error ?? res.status}` }] }
+      if (!out) return { content: [{ type: 'text', text: `Snoozed "${name}", but the server returned no body.` }] }
+      return { content: [{ type: 'text', text: `Snoozed "${out.name}" for ${out.days} day${out.days === 1 ? '' : 's'} — it won't surface until then.` }] }
+    },
+  )
+
   server.registerTool(
     'set_page_privacy',
     {

package/package.json

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