@theronap/cortex-mcp 0.7.0 → 0.9.0

package/lib/setup.mjs

@@ -14,6 +14,34 @@ import { installSkills } from './skills.mjs'
 
 const PKG = '@theronap/cortex-mcp'
 
+// Merge the Cortex MCP server into a Codex config.toml. Pure + idempotent: strips any existing
+// [mcp_servers.cortex] / [mcp_servers.cortex.env] tables (so re-runs update in place rather than
+// duplicating — a duplicate TOML table would break Codex's parser), preserves every other table,
+// and appends a fresh block. Only touches the cortex tables; never rewrites the user's config.
+export function mergeCodexToml(text, spec, token) {
+  const targets = new Set(['[mcp_servers.cortex]', '[mcp_servers.cortex.env]'])
+  const kept = []
+  let skipping = false
+  for (const line of (text || '').split('\n')) {
+    const t = line.trim()
+    if (t.startsWith('[') && t.endsWith(']')) skipping = targets.has(t)
+    if (!skipping) kept.push(line)
+  }
+  while (kept.length && kept[kept.length - 1].trim() === '') kept.pop() // drop trailing blanks
+  const block = [
+    '',
+    '[mcp_servers.cortex]',
+    'command = "npx"',
+    `args = ["-y", "${spec}"]`,
+    'startup_timeout_sec = 60', // first npx fetch can be slow; don't time out the server on cold start
+    '',
+    '[mcp_servers.cortex.env]',
+    `CORTEX_TOKEN = "${token}"`,
+    '',
+  ]
+  return [...kept, ...block].join('\n')
+}
+
 function readJson(path) {
   if (!existsSync(path)) return {}
   const raw = readFileSync(path, 'utf8').trim()
@@ -77,6 +105,22 @@ export async function runSetup(argv, version) {
     process.exit(1)
   }
 
+  // ── 1b. MCP server in Codex (~/.codex/config.toml), only if Codex is installed ──
+  // Codex gets the same Cortex context tools as Claude Code. Non-fatal: a Codex hiccup must
+  // never block the primary Claude wiring. Capture/skills self-heal stay Claude-driven for now.
+  const codexDir = join(home, '.codex')
+  if (existsSync(codexDir)) {
+    try {
+      const codexToml = join(codexDir, 'config.toml')
+      const existing = existsSync(codexToml) ? readFileSync(codexToml, 'utf8') : ''
+      const bak = backup(codexToml)
+      writeFileSync(codexToml, mergeCodexToml(existing, spec, token))
+      log(`  ✓ MCP server → ${codexToml}${bak ? ' (backup saved)' : ''}`)
+    } catch (e) {
+      log(`  ⚠ Codex MCP wiring skipped: ${e.message} (Claude wiring unaffected)`)
+    }
+  }
+
   // ── 2. Capture Stop hook in ~/.claude/settings.json ──────────────────────
   try {
     let s
@@ -134,7 +178,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.7.0",
+  "version": "0.9.0",
   "description": "Connect your AI assistant to Cortex — your org's projects, activity, gaps, and directives, scoped to you.",
   "type": "module",
   "bin": {