@theronap/cortex-mcp 0.6.0 → 0.8.0

package/lib/server.mjs

@@ -52,13 +52,32 @@ export async function runServer(version) {
     {
       title: 'Search the org',
       description: 'Search your visible work activity and projects by keyword.',
-      inputSchema: { query: z.string().describe('keyword to search for') },
+      inputSchema: { query: z.string().describe('keyword to search for — people or work activity') },
     },
     async ({ query }) => {
-      const text = await fetchContext()
-      const q = query.toLowerCase()
-      const lines = text.split('\n').filter((l) => l.toLowerCase().includes(q))
-      return { content: [{ type: 'text', text: lines.length ? `Matches for "${query}":\n${lines.join('\n')}` : `No visible results for "${query}".` }] }
+      // Real search via /api/search: records (RLS-scoped retrieve) + graph entities (people),
+      // instead of substring-grepping the cached context. People were previously invisible to search.
+      const res = await fetchCortex(`${BASE}/api/search?q=${encodeURIComponent(query)}`, { headers: { Authorization: `Bearer ${TOKEN}` } })
+      if (!res.ok) {
+        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()
+      if (!people.length && !records.length) return { content: [{ type: 'text', text: `No visible results for "${query}".` }] }
+      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'}`)
+        }
+      }
+      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})` : ''}`)
+      }
+      return { content: [{ type: 'text', text: `Results for "${query}":\n${lines.join('\n')}` }] }
     },
   )
 

package/lib/setup.mjs

@@ -134,7 +134,7 @@ export async function runSetup(argv, version) {
     process.exit(1)
   }
 
-  // ── 3. Managed skills repository (~/.claude/skills/cortex/) ──────────────
+  // ── 3. Managed skills — installed flat into every agent CLI present (Claude + Codex) ──
   try {
     installSkills({ quiet: false })
   } catch (e) {

package/lib/skills.mjs

@@ -3,24 +3,32 @@ import { homedir } from 'os'
 import { join, dirname } from 'path'
 import { fileURLToPath } from 'url'
 
-// Managed Cortex skills repository.
+// Managed Cortex skills.
 //
-// Cortex owns a namespace under the user's Claude skills dir: ~/.claude/skills/cortex/
-//   cortex/
-//     README.md                  ← explains the namespace is Cortex-managed
-//     .cortex-manifest.json       ← what's managed + content hashes (machine-readable)
-//     core/<name>/SKILL.md        ← MANDATORY, self-healing skills shipped in this package
-//     (org/ and shared/ are reserved for server-synced skills — not yet populated)
+// Cortex ships mandatory, self-healing skills (e.g. cortex-log) and installs them into EVERY agent
+// CLI present on the machine, at the flat layout each one discovers:
+//   ~/.claude/skills/<name>/SKILL.md   (Claude Code)
+//   ~/.codex/skills/<name>/SKILL.md    (OpenAI Codex CLI — only if ~/.codex exists)
 //
-// "Inalterable" in practice: the bundled core skills are the source of truth. On every install AND
-// on every session start (the SessionStart --repair hook), any core skill whose on-disk content
-// drifted from the bundled source is RESTORED — the user's version is backed up to <file>.user-bak
-// first, so nothing is lost, but the canonical skill always wins. Idempotent: identical content is a
-// no-op (no backup, no write, no churn).
+// IMPORTANT: skills MUST be one level under <cli>/skills/ — both Claude Code and Codex discover
+// skills as <cli>/skills/<name>/SKILL.md. An earlier layout nested them under skills/cortex/core/,
+// which is installed but INVISIBLE to discovery (the skill never appears as a slash command).
+//
+// "Inalterable" in practice: the bundled skills are the source of truth. On every install AND on
+// every Claude session start (the SessionStart --repair hook), any managed skill whose on-disk
+// content drifted is RESTORED — the user's version is backed up to SKILL.md.user-bak first, so
+// nothing is lost, but the canonical skill always wins. Identical content is a no-op.
 
 const HERE = dirname(fileURLToPath(import.meta.url))
 const BUNDLED = join(HERE, '..', 'skills') // packages/cortex-mcp/skills/<name>/SKILL.md
 
+// Agent CLIs we install skills into. Claude is primary; Codex is included whenever it's present.
+// Both use the same flat <cli>/skills/<name>/SKILL.md discovery layout.
+const CLIS = [
+  { id: 'Claude Code', dir: join(homedir(), '.claude') },
+  { id: 'Codex', dir: join(homedir(), '.codex') },
+]
+
 // djb2 — tiny, dependency-free content fingerprint for the manifest (drift detection, not security).
 function hash(s) {
   let h = 5381
@@ -32,90 +40,100 @@ function ensureDir(path) {
   if (!existsSync(path)) mkdirSync(path, { recursive: true })
 }
 
-// Discover bundled core skills: each subdir of skills/ that contains a SKILL.md.
+// The invocation name (slash command) comes from the SKILL.md `name:` frontmatter, not the folder.
+// Use it as the install directory so the layout matches what the user types (/cortex-log).
+function frontmatterName(source, fallback) {
+  const m = source.match(/^---[\s\S]*?\bname:\s*([^\n#]+)/)
+  return m ? m[1].trim() : fallback
+}
+
+// Discover bundled skills: each subdir of skills/ that contains a SKILL.md.
 function bundledSkills() {
   if (!existsSync(BUNDLED)) return []
   return readdirSync(BUNDLED, { withFileTypes: true })
     .filter((d) => d.isDirectory() && existsSync(join(BUNDLED, d.name, 'SKILL.md')))
-    .map((d) => ({ name: d.name, src: join(BUNDLED, d.name, 'SKILL.md') }))
+    .map((d) => {
+      const src = join(BUNDLED, d.name, 'SKILL.md')
+      const source = readFileSync(src, 'utf8')
+      return { name: frontmatterName(source, d.name), src, source }
+    })
 }
 
-const README = `# Cortex-managed skills
-
-This folder is owned by Cortex (\`@theronap/cortex-mcp\`). Skills under \`core/\` are **mandatory and
-self-healing**: if you edit or delete one, Cortex restores it on your next Claude session (your edited
-copy is saved as \`SKILL.md.user-bak\` first). To change a core skill, change it upstream in Cortex.
-
-- \`core/\`   — required Cortex skills, shipped and repaired by this package
-- \`org/\`    — your organization's skills (reserved; synced from Cortex)
-- \`shared/\` — skills shared across the org (reserved; synced from Cortex)
-
-Managed by: \`npx -y @theronap/cortex-mcp skills\`  ·  repaired automatically each session.
-`
-
-/**
- * Install / repair the managed Cortex skills.
- * @param {{ quiet?: boolean }} opts  quiet → only emit on actual change (for the SessionStart hook)
- * @returns {{ installed: string[], repaired: string[], unchanged: string[] }}
- */
-export function installSkills(opts = {}) {
-  const quiet = !!opts.quiet
-  const root = join(homedir(), '.claude', 'skills', 'cortex')
-  const coreDir = join(root, 'core')
-  const log = (m) => { if (!quiet) process.stdout.write(m + '\n') }
-
-  const skills = bundledSkills()
+// Install/repair all bundled skills into one CLI's skills root. Returns per-CLI change lists.
+function installInto(skillsRoot, skills) {
+  ensureDir(skillsRoot)
   const result = { installed: [], repaired: [], unchanged: [] }
-  if (!skills.length) return result // nothing bundled (shouldn't happen) — never error
-
-  ensureDir(coreDir)
-  // Reserved namespaces so the structure is discoverable even before server sync exists.
-  ensureDir(join(root, 'org'))
-  ensureDir(join(root, 'shared'))
-  writeFileSync(join(root, 'README.md'), README)
-
   const manifest = { managed: [], updated_by: 'cortex-mcp', skills: {} }
 
   for (const sk of skills) {
-    const source = readFileSync(sk.src, 'utf8')
-    const dest = join(coreDir, sk.name, 'SKILL.md')
-    manifest.managed.push(`core/${sk.name}/SKILL.md`)
-    manifest.skills[sk.name] = hash(source)
+    const dest = join(skillsRoot, sk.name, 'SKILL.md')
+    manifest.managed.push(`${sk.name}/SKILL.md`)
+    manifest.skills[sk.name] = hash(sk.source)
 
     if (!existsSync(dest)) {
       ensureDir(dirname(dest))
-      writeFileSync(dest, source)
+      writeFileSync(dest, sk.source)
       result.installed.push(sk.name)
       continue
     }
     const current = readFileSync(dest, 'utf8')
-    if (current === source) { result.unchanged.push(sk.name); continue }
+    if (current === sk.source) { result.unchanged.push(sk.name); continue }
 
     // Drift: preserve the user's version, then restore canonical.
     try { copyFileSync(dest, `${dest}.user-bak`) } catch { /* best-effort backup */ }
-    writeFileSync(dest, source)
+    writeFileSync(dest, sk.source)
     result.repaired.push(sk.name)
   }
 
-  writeFileSync(join(root, '.cortex-manifest.json'), JSON.stringify(manifest, null, 2))
+  writeFileSync(join(skillsRoot, '.cortex-skills.json'), JSON.stringify(manifest, null, 2))
+  return result
+}
+
+/**
+ * Install / repair the managed Cortex skills into every agent CLI present on the machine.
+ * @param {{ quiet?: boolean }} opts  quiet → only emit on actual change (for the SessionStart hook)
+ * @returns {{ installed: string[], repaired: string[], unchanged: string[], targets: string[] }}
+ */
+export function installSkills(opts = {}) {
+  const quiet = !!opts.quiet
+  const log = (m) => { if (!quiet) process.stdout.write(m + '\n') }
+
+  const skills = bundledSkills()
+  const summary = { installed: [], repaired: [], unchanged: [], targets: [] }
+  if (!skills.length) return summary // nothing bundled (shouldn't happen) — never error
+
+  const targets = CLIS.filter((c) => existsSync(c.dir))
+  if (!targets.length) return summary // no agent CLI on this machine
+
+  for (const cli of targets) {
+    const skillsRoot = join(cli.dir, 'skills')
+    const r = installInto(skillsRoot, skills)
+    summary.targets.push(cli.id)
+    summary.installed.push(...r.installed)
+    summary.repaired.push(...r.repaired)
+    summary.unchanged.push(...r.unchanged)
+    const changed = [...r.installed, ...r.repaired]
+    if (changed.length) log(`  ✓ ${cli.id}: ${changed.join(', ')} → ${skillsRoot}`)
+  }
 
-  if (result.installed.length) log(`  ✓ Cortex skills installed: ${result.installed.join(', ')} → ${coreDir}`)
-  if (result.repaired.length) log(`  ✓ Cortex skills restored (backed up your copy): ${result.repaired.join(', ')}`)
-  if (quiet && (result.installed.length || result.repaired.length)) {
+  if (quiet && (summary.installed.length || summary.repaired.length)) {
     // SessionStart surfaces one line in Claude Code so a silent self-heal isn't invisible.
-    process.stdout.write(`Cortex: synced ${result.installed.length + result.repaired.length} managed skill(s).\n`)
+    process.stdout.write(`Cortex: synced managed skill(s) into ${summary.targets.join(' + ')}.\n`)
   }
-  return result
+  return summary
 }
 
 // CLI entry: `cortex-mcp skills [--repair] [--quiet]`. (--repair and plain install are the same
 // idempotent operation; --repair is just the name the SessionStart hook uses for intent.)
 export async function runSkills(argv = []) {
   const quiet = argv.includes('--quiet')
-  if (!quiet) process.stdout.write('\nCortex skills — installing managed repository…\n')
+  if (!quiet) process.stdout.write('\nCortex skills — installing managed skills…\n')
   const r = installSkills({ quiet })
-  if (!quiet && !r.installed.length && !r.repaired.length) {
-    process.stdout.write(`  ✓ Up to date (${r.unchanged.join(', ') || 'none'}).\n`)
+  if (!quiet) {
+    if (!r.targets.length) process.stdout.write('  ! No agent CLI found (~/.claude or ~/.codex). Nothing to install.\n')
+    else if (!r.installed.length && !r.repaired.length) {
+      process.stdout.write(`  ✓ Up to date in ${r.targets.join(' + ')} (${[...new Set(r.unchanged)].join(', ') || 'none'}).\n`)
+    }
   }
   return 0
 }

package/package.json

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