codex-dev-mcp-suite 1.5.1 → 1.7.0

package/project-memory/server.js

@@ -38,7 +38,7 @@ import { computeStats, formatText, formatJson } from "../lib/stats.js";
 
 const VAULT_ROOT =
   process.env.MEMORY_VAULT_DIR ||
-  path.join(os.homedir(), ".codex", "memories", "vault");
+  path.join(os.homedir(), ".ai-shared-memory", "vault");
 
 const MAX_CONTENT = 200_000;
 const MAX_TITLE = 200;
@@ -155,6 +155,103 @@ class ProjectMemoryServer {
     await fs.writeFile(p.indexFile, JSON.stringify(index, null, 2));
   }
 
+  // Ensure an Obsidian-friendly workspace exists so the vault can be opened
+  // directly in the Obsidian app (graph view, tag pages, MOC navigation).
+  async ensureObsidianFolder(p) {
+    const obsDir = path.join(p.projectDir, ".obsidian");
+    try { await fs.access(obsDir); return; } catch {}
+    await fs.mkdir(obsDir, { recursive: true });
+    await fs.writeFile(path.join(obsDir, "app.json"), JSON.stringify({
+      alwaysUpdateLinks: true,
+      newLinkFormat: "shortest",
+      useMarkdownLinks: false,
+      showViewHeader: true,
+    }, null, 2));
+    await fs.writeFile(path.join(obsDir, "workspace.json"), JSON.stringify({
+      _comment: "Auto-managed by codex-dev-mcp-suite (project-memory).",
+    }, null, 2));
+  }
+
+  // Build an Obsidian-style Map of Content (MOC) listing every note, its
+  // outgoing links, backlinks, and a #tag index. Refreshed on save/delete.
+  async writeMoc(p, index) {
+    const notes = Object.values(index.notes || {})
+      .sort((a, b) => (a.created < b.created ? 1 : -1));
+    if (notes.length === 0) return;
+    const tagMap = new Map();
+    for (const n of notes) {
+      for (const t of n.tags || []) {
+        if (!tagMap.has(t)) tagMap.set(t, []);
+        tagMap.get(t).push(n);
+      }
+    }
+    const lines = [
+      "# MOC — Map of Content",
+      "",
+      `> Auto-generated by project-memory for project \`${p.slug}\`. Do not edit by hand; it is regenerated on every save/delete.`,
+      "",
+      `**${notes.length} notes**`,
+      "",
+      "## Notes",
+    ];
+    for (const n of notes) {
+      const link = `[[${n.title}]]`;
+      const tags = (n.tags || []).length ? `  #${(n.tags || []).join(" #")}` : "";
+      lines.push(`- ${link} — *${n.kind || "note"}*${tags}`);
+    }
+    lines.push("", "## By tag");
+    if (tagMap.size === 0) lines.push("- (no tags yet)");
+    for (const [tag, ns] of [...tagMap.entries()].sort()) {
+      lines.push(`- #${tag}: ${ns.map((n) => `[[${n.title}]]`).join(", ")}`);
+    }
+    lines.push("", "## Graph (backlinks)");
+    for (const n of notes) {
+      const bl = (n.backlinks || []).map((b) => `[[${b.title}]]`).join(", ");
+      if (bl) lines.push(`- [[${n.title}]] <- ${bl}`);
+    }
+    lines.push("");
+    await fs.writeFile(path.join(p.projectDir, "MOC.md"), lines.join("\n"));
+    // Also emit a standalone #tag index page per tag (Obsidian-style tag pages).
+    await this.writeTagPages(p, tagMap);
+  }
+
+  // Emit one `tags/<tag>.md` page per tag, listing all notes carrying it.
+  async writeTagPages(p, tagMap) {
+    const tagDir = path.join(p.projectDir, "tags");
+    await fs.mkdir(tagDir, { recursive: true });
+    for (const [tag, ns] of tagMap.entries()) {
+      const body = [
+        `# Tag: ${tag}`,
+        "",
+        ns.map((n) => `- [[${n.title}]] — *${n.kind || "note"}*`).join("\n"),
+        "",
+      ].join("\n");
+      await fs.writeFile(path.join(tagDir, `${String(tag).replace(/[^a-zA-Z0-9._-]/g, "-")}.md`), body);
+    }
+    // prune tag pages with no notes left
+    let files = [];
+    try { files = await fs.readdir(tagDir); } catch { return; }
+    for (const f of files) {
+      if (!f.endsWith(".md")) continue;
+      const t = f.slice(0, -3);
+      if (!tagMap.has(t)) await fs.unlink(path.join(tagDir, f)).catch(() => {});
+    }
+  }
+
+  // Export the note graph (nodes + directed edges) for external graph views.
+  buildGraph(index) {
+    const nodes = Object.values(index.notes || {}).map((n) => ({
+      id: n.id, title: n.title, kind: n.kind || "note", tags: n.tags || [],
+    }));
+    const edges = [];
+    for (const n of Object.values(index.notes || {})) {
+      for (const link of n.links || []) {
+        edges.push({ from: n.id, raw: link.raw, ref: link.ref, kind: link.kind });
+      }
+    }
+    return { nodes, edges };
+  }
+
   setupHandlers() {
     this.server.setRequestHandler(ListToolsRequestSchema, () => ({
       tools: [
@@ -170,6 +267,7 @@ class ProjectMemoryServer {
               dir: { type: "string", description: "Project directory (defaults to CWD)" },
               tags: { type: "array", items: { type: "string" }, description: "Optional tags" },
               kind: { type: "string", description: "note | decision | task | log | snippet", default: "note" },
+              aliases: { type: "array", items: { type: "string" }, description: "Optional Obsidian-style aliases for the note (alt titles wikilinks can reference)" },
               created: { type: "string", description: "Optional ISO timestamp to backdate the note (e.g. original session time)" },
             },
             required: ["title", "content"],
@@ -288,6 +386,26 @@ class ProjectMemoryServer {
             },
           },
         },
+        {
+          name: "memory_moc",
+          description: "Generate / refresh the Obsidian-style Map of Content (MOC.md) for the project: lists every note with wikilinks, a #tag index, and backlink graph. Run after saves, or on demand to open the vault in Obsidian.",
+          inputSchema: {
+            type: "object",
+            properties: {
+              dir: { type: "string", description: "Project directory (defaults to CWD)" },
+            },
+          },
+        },
+        {
+          name: "memory_graph",
+          description: "Export the note graph (nodes + directed edges from [[wikilinks]]) as JSON, for external graph views or analysis. Backlinks are resolved via graph state.",
+          inputSchema: {
+            type: "object",
+            properties: {
+              dir: { type: "string", description: "Project directory (defaults to CWD)" },
+            },
+          },
+        },
       ],
     }));
 
@@ -305,6 +423,8 @@ class ProjectMemoryServer {
           case "memory_global_recall": return await this.globalRecall(args || {});
           case "memory_dedup": return await this.dedup(args || {});
           case "memory_stats": return await this.stats(args || {});
+          case "memory_moc": return await this.moc(args || {});
+          case "memory_graph": return await this.graph(args || {});
           default: throw new Error(`Unknown tool: ${name}`);
         }
       } catch (error) {
@@ -349,22 +469,23 @@ class ProjectMemoryServer {
     });
   }
 
-  async save({ title, content, dir, tags, kind = "note", created: createdArg }) {
+  async save({ title, content, dir, tags, kind = "note", aliases, created: createdArg }) {
     title = limit(title, "title", MAX_TITLE);
     content = limit(content, "content", MAX_CONTENT);
     const tagList = Array.isArray(tags) ? tags.map((t) => String(t).trim()).filter(Boolean) : [];
+    const aliasList = Array.isArray(aliases) ? aliases.map((t) => String(t).trim()).filter(Boolean) : [];
     const p = this.paths(dir);
     await fs.mkdir(p.notesDir, { recursive: true });
 
     const id = genId();
     const created = (createdArg && /^\d{4}-\d{2}-\d{2}/.test(String(createdArg))) ? String(createdArg) : nowIso();
-    const meta = { id, title, kind, tags: tagList, created, dir: path.resolve(dir || process.cwd()) };
+    const meta = { id, title, kind, tags: tagList, aliases: aliasList, created, dir: path.resolve(dir || process.cwd()) };
     const file = path.join(p.notesDir, `${id}.md`);
     await fs.writeFile(file, buildFrontmatter(meta) + `# ${title}\n\n${content}\n`);
 
     const index = await this.loadIndex(p);
     const keywords = [...new Set([...tokenize(title), ...tokenize(content), ...tagList.map((t) => t.toLowerCase())])];
-    const note = { id, title, kind, tags: tagList, created, keywords, file: path.relative(p.projectDir, file) };
+    const note = { id, title, kind, tags: tagList, aliases: aliasList, created, keywords, file: path.relative(p.projectDir, file) };
 
     const vec = await embedOne(`${title}\n\n${content}`);
     let embedded = false;
@@ -372,8 +493,19 @@ class ProjectMemoryServer {
 
     index.notes[id] = note;
     await this.saveIndex(p, index);
+    await this.ensureObsidianFolder(p);
+    // Resolve [[wikilinks]] + backlinks immediately so the graph is fresh on save.
+    const ensured = await ensureGraphState({
+      vaultRoot: VAULT_ROOT,
+      projectDir: p.projectDir,
+      slug: p.slug,
+      index,
+      noteLoader: loadNoteBody,
+    });
+    if (ensured.changed) await this.saveIndex(p, ensured.index);
+    await this.writeMoc(p, ensured.index);
 
-    return { content: [{ type: "text", text: `Saved note ${id} → ${p.slug}\nFile: ${file}\nKeywords indexed: ${keywords.length}${embedded ? " (semantic embedding stored)" : " (keyword-only; embeddings unavailable)"}` }] };
+    return { content: [{ type: "text", text: `Saved note ${id} → ${p.slug}\nFile: ${file}\nKeywords indexed: ${keywords.length}${embedded ? " (semantic embedding stored)" : " (keyword-only; embeddings unavailable)"}\nMOC refreshed: ${path.join(p.projectDir, "MOC.md")}` }] };
   }
 
   async recall({ query, dir, limit: lim = 5, full = false, mode: requestedMode = "auto" }) {
@@ -572,6 +704,7 @@ class ProjectMemoryServer {
     await fs.unlink(path.join(p.projectDir, meta.file)).catch(() => {});
     delete index.notes[id];
     await this.saveIndex(p, index);
+    await this.writeMoc(p, index);
     return { content: [{ type: "text", text: `Deleted note ${id} from ${p.slug}` }] };
   }
 
@@ -647,12 +780,37 @@ class ProjectMemoryServer {
             ? path.dirname(process.env.JOURNAL_DIR)
             : process.env.CHECKPOINT_DIR
               ? path.dirname(process.env.CHECKPOINT_DIR)
-              : path.join(os.homedir(), ".codex", "memories"));
+              : path.join(os.homedir(), ".ai-shared-memory"));
     const stats = computeStats({ root, topLimit: top });
     const text = json ? formatJson(stats) : formatText(stats);
     return { content: [{ type: "text", text }] };
   }
 
+  async moc({ dir } = {}) {
+    const p = this.paths(dir);
+    await this.ensureObsidianFolder(p);
+    const index = await this.loadIndex(p);
+    await this.writeMoc(p, index);
+    const mocFile = path.join(p.projectDir, "MOC.md");
+    const count = Object.keys(index.notes || {}).length;
+    return { content: [{ type: "text", text: `MOC refreshed for ${p.slug}: ${count} notes → ${mocFile}\nOpen the project folder in Obsidian to see the graph + tag pages.` }] };
+  }
+
+  async graph({ dir } = {}) {
+    const p = this.paths(dir);
+    const index = await this.loadIndex(p);
+    const ensured = await ensureGraphState({
+      vaultRoot: VAULT_ROOT,
+      projectDir: p.projectDir,
+      slug: p.slug,
+      index,
+      noteLoader: loadNoteBody,
+    });
+    if (ensured.changed) await this.saveIndex(p, ensured.index);
+    const g = this.buildGraph(ensured.index);
+    return { content: [{ type: "text", text: JSON.stringify(g, null, 2) }] };
+  }
+
   async run() {
     const transport = new StdioServerTransport();
     await this.server.connect(transport);

package/run-tests.mjs

@@ -0,0 +1,54 @@
+#!/usr/bin/env node
+/**
+ * Runs every server's test.mjs and any top-level tests/*.test.mjs,
+ * then prints a combined summary. Usage: node run-tests.mjs
+ */
+import { spawn } from "child_process";
+import path from "path";
+import { fileURLToPath } from "url";
+import fs from "fs";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const SERVERS = ["project-memory", "checkpoint", "context-pack", "devjournal"];
+const EXTRA_TESTS = fs.existsSync("tests")
+  ? fs.readdirSync("tests").filter((f) => f.endsWith(".test.mjs")).map((f) => `tests/${f}`)
+  : [];
+
+/** Run a single test file by absolute path. */
+function runFile(absPath) {
+  return new Promise((resolve) => {
+    const proc = spawn("node", [absPath], { stdio: ["ignore", "pipe", "pipe"] });
+    let out = "";
+    proc.stdout.on("data", (d) => (out += d));
+    proc.stderr.on("data", (d) => (out += d));
+    proc.on("close", (code) => resolve({ name: path.basename(path.dirname(absPath)) || absPath, code, out }));
+  });
+}
+
+const results = [];
+
+for (const s of SERVERS) {
+  console.log(`\n=== ${s} ===`);
+  const r = await runFile(path.join(__dirname, s, "test.mjs"));
+  process.stdout.write(r.out);
+  results.push({ ...r, name: s });
+}
+
+for (const t of EXTRA_TESTS) {
+  console.log(`\n=== ${t} ===`);
+  const r = await runFile(path.join(__dirname, t));
+  process.stdout.write(r.out);
+  results.push({ ...r, name: t });
+}
+
+console.log("\n================ SUMMARY ================");
+let anyFail = false;
+for (const r of results) {
+  const ok = r.code === 0;
+  if (!ok) anyFail = true;
+  const m = r.out.match(/(\d+) passed, (\d+) failed/);
+  const stat = m ? `${m[1]} passed, ${m[2]} failed` : (ok ? "ok" : "FAILED");
+  console.log(`  ${ok ? "✓" : "✗"} ${r.name.padEnd(28)} ${stat}`);
+}
+console.log("========================================");
+process.exit(anyFail ? 1 : 0);