memorix 0.3.8 → 0.4.0

package/README.md

@@ -2,21 +2,24 @@
 
 > Universal memory layer for AI coding agents via MCP
 
+[![npm version](https://img.shields.io/npm/v/memorix.svg)](https://www.npmjs.com/package/memorix)
+[![License](https://img.shields.io/badge/license-Apache%202.0-blue.svg)](LICENSE)
+
 ## What is Memorix?
 
-Memorix is a lightweight local MCP server that acts as a **universal memory layer** across AI coding agents. Your knowledge from Cursor, Claude Code, Codex, and Windsurf is stored once and shared everywhere.
+Memorix is a lightweight local MCP server that acts as a **universal memory layer** across AI coding agents. Your knowledge from **Windsurf, Cursor, Claude Code, Codex, and VS Code Copilot** is stored once and shared everywhere.
 
 ### The Problem
 
 - claude-mem only serves Claude Code
-- memU only serves OpenClaw
+- mcp-memory-service has no cross-agent workspace sync
 - Your architecture decisions in Cursor are invisible to Claude Code
 - Bug fix knowledge in Windsurf doesn't transfer to Codex
-- **No one does cross-agent memory**
+- **No one bridges memory AND workspace configs across agents**
 
 ### The Solution
 
-Memorix stores and indexes project knowledge (architecture decisions, bug fixes, code style preferences) and exposes it via MCP — so **any MCP-supporting agent** can access it.
+Memorix stores and indexes project knowledge (architecture decisions, bug fixes, code style preferences) and exposes it via MCP — so **any MCP-supporting agent** can access it. It also **syncs MCP configs, rules, skills, and workflows** across all your agents automatically.
 
 ## Features
 
@@ -39,18 +42,21 @@ Memorix stores and indexes project knowledge (architecture decisions, bug fixes,
 - **Graceful Degradation**: No fastembed? Falls back to BM25 fulltext automatically
 - **Token Budget**: `maxTokens` parameter trims results to fit context windows
 
-### P2 — Cross-Agent Sync
+### P2 — Cross-Agent Workspace Sync
 
+- **5 Agent Adapters**: Windsurf, Cursor, Claude Code, Codex, VS Code Copilot
+- **MCP Config Sync**: Detect and migrate MCP server configs across agents (merges into existing files — never overwrites)
 - **Rules Parser**: 4 format adapters (Cursor `.mdc`, Claude Code `CLAUDE.md`, Codex `SKILL.md`, Windsurf `.windsurfrules`)
 - **Rules Syncer**: Scan → Deduplicate → Conflict detection → Cross-format generation
-- **Workspace Sync**: MCP config migration + workflow sync across agents
-- **Skills Sync**: Scan `.codex/skills/`, `.cursor/skills/`, `.windsurf/skills/`, `.claude/skills/` → copy entire skill folders across agents (no format conversion needed — SKILL.md is a universal standard)
+- **Skills Sync**: Scan `.codex/skills/`, `.cursor/skills/`, `.windsurf/skills/`, `.claude/skills/` → copy entire skill folders across agents
+- **Sync Advisory**: On first `memorix_search`, auto-detects available configs/skills from other agents and prompts the user
+- **Selective Sync**: Sync specific items by name (e.g. `items=["figma-remote-mcp-server", "create-subagent"]`)
 - **Apply with Safety**: Backup → Atomic write → Auto-rollback on failure
 
 ### P3 — Auto-Memory Hooks
 
 - **Hook Events**: `user_prompt`, `post_response`, `post_edit`, `post_command`, `post_tool`, `session_end`
-- **Agent Normalizer**: Maps Windsurf/Cursor/Claude/Codex native events to unified hook events
+- **Agent Normalizer**: Maps Windsurf/Cursor/Claude Code/Codex native events to unified hook events
 - **Pattern Detection**: Auto-detects decisions, errors, gotchas, configurations, learnings, implementations
 - **Cooldown Filtering**: Prevents duplicate storage within configurable time windows
 - **Noise Filtering**: Skips trivial commands (`ls`, `cat`, `pwd`, etc.)
@@ -80,42 +86,63 @@ Memorix stores and indexes project knowledge (architecture decisions, bug fixes,
 ### Install
 
 ```bash
-npm install memorix
+npm install -g memorix
 ```
 
 ### Configure in your agent
 
-**Cursor** (`.cursor/mcp.json`):
+**Windsurf** (`~/.codeium/windsurf/mcp_config.json`):
 ```json
 {
   "mcpServers": {
     "memorix": {
-      "command": "node",
-      "args": ["node_modules/memorix/dist/index.js"]
+      "command": "memorix",
+      "args": ["serve"]
     }
   }
 }
 ```
 
-**Claude Code** (`claude_desktop_config.json`):
+**Cursor** (`.cursor/mcp.json`):
 ```json
 {
   "mcpServers": {
     "memorix": {
-      "command": "node",
-      "args": ["node_modules/memorix/dist/index.js"]
+      "command": "memorix",
+      "args": ["serve"]
     }
   }
 }
 ```
 
-**Windsurf** (`~/.codeium/windsurf/mcp_config.json`):
+**Claude Code** (`~/.claude.json`):
 ```json
 {
   "mcpServers": {
     "memorix": {
-      "command": "node",
-      "args": ["node_modules/memorix/dist/index.js"]
+      "command": "memorix",
+      "args": ["serve"]
+    }
+  }
+}
+```
+
+**Codex** (`~/.codex/config.toml`):
+```toml
+[mcp_servers.memorix]
+command = "memorix"
+args = ["serve"]
+```
+
+**VS Code Copilot** (VS Code `settings.json` or `.vscode/mcp.json`):
+```json
+{
+  "mcp": {
+    "servers": {
+      "memorix": {
+        "command": "memorix",
+        "args": ["serve"]
+      }
     }
   }
 }
@@ -154,7 +181,7 @@ npm install memorix
 ```
 ┌─────────────────────────────────────────────┐
 │                 MCP Clients                  │
-│   Cursor │ Claude Code │ Codex │ Windsurf   │
+│ Windsurf│Cursor│Claude Code│Codex│Copilot │
 └──────────────────┬──────────────────────────┘
                    │ stdio
 ┌──────────────────▼──────────────────────────┐
@@ -177,7 +204,7 @@ npm install memorix
 │                                              │
 │  ┌────────────────────────────────────┐     │
 │  │      Rules & Skills Syncer        │     │
-│  │  Cursor│Claude│Codex│Windsurf     │     │
+│  │  Cursor│Claude Code│Codex│Windsurf│Copilot│ │
 │  │  rules: scan→dedup→conflict→gen   │     │
 │  │  skills: scan→copy (no convert)   │     │
 │  └────────────────────────────────────┘     │
@@ -246,4 +273,4 @@ Memorix stands on the shoulders of these excellent projects:
 
 ## License
 
-MIT
+Apache 2.0 — see [LICENSE](LICENSE)

package/dist/cli/index.js

@@ -1520,6 +1520,93 @@ var init_windsurf = __esm({
   }
 });
 
+// src/rules/adapters/antigravity.ts
+import matter5 from "gray-matter";
+var AntigravityAdapter;
+var init_antigravity = __esm({
+  "src/rules/adapters/antigravity.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_utils();
+    AntigravityAdapter = class {
+      source = "antigravity";
+      filePatterns = [
+        "GEMINI.md",
+        ".agent/rules/*.md",
+        ".agent/skills/*/SKILL.md"
+      ];
+      parse(filePath, content) {
+        if (filePath.includes("SKILL.md")) {
+          return this.parseSkillMd(filePath, content);
+        }
+        if (filePath.includes(".agent/rules/")) {
+          return this.parseAgentRule(filePath, content);
+        }
+        if (filePath === "GEMINI.md" || filePath.endsWith("/GEMINI.md")) {
+          return this.parseGeminiMd(filePath, content);
+        }
+        return [];
+      }
+      generate(rules) {
+        const projectRules = rules.filter((r) => r.scope !== "path-specific");
+        const pathRules = rules.filter((r) => r.scope === "path-specific");
+        const files = [];
+        for (const rule of [...projectRules, ...pathRules]) {
+          const fm = {};
+          if (rule.description) fm.description = rule.description;
+          const fileName = rule.id.replace(/^antigravity:/, "").replace(/[^a-zA-Z0-9-_]/g, "-") || "rule";
+          const body = Object.keys(fm).length > 0 ? matter5.stringify(rule.content, fm) : rule.content;
+          files.push({
+            filePath: `.agent/rules/${fileName}.md`,
+            content: body
+          });
+        }
+        return files;
+      }
+      parseGeminiMd(filePath, content) {
+        const trimmed = content.trim();
+        if (!trimmed) return [];
+        return [{
+          id: generateRuleId("antigravity", filePath),
+          content: trimmed,
+          source: "antigravity",
+          scope: "global",
+          priority: 10,
+          hash: hashContent(trimmed)
+        }];
+      }
+      parseAgentRule(filePath, content) {
+        const { data, content: body } = matter5(content);
+        const trimmed = body.trim();
+        if (!trimmed) return [];
+        return [{
+          id: generateRuleId("antigravity", filePath),
+          content: trimmed,
+          description: data.description,
+          source: "antigravity",
+          scope: "project",
+          priority: 5,
+          hash: hashContent(trimmed)
+        }];
+      }
+      parseSkillMd(filePath, content) {
+        const { data, content: body } = matter5(content);
+        const trimmed = body.trim();
+        if (!trimmed) return [];
+        return [{
+          id: generateRuleId("antigravity", filePath),
+          content: trimmed,
+          description: data.description || void 0,
+          source: "antigravity",
+          scope: "project",
+          priority: 5,
+          hash: hashContent(trimmed)
+        }];
+      }
+    };
+  }
+});
+
 // src/rules/syncer.ts
 var syncer_exports = {};
 __export(syncer_exports, {
@@ -1536,6 +1623,7 @@ var init_syncer = __esm({
     init_claude_code();
     init_codex();
     init_windsurf();
+    init_antigravity();
     RulesSyncer = class {
       projectRoot;
       adapters;
@@ -1546,7 +1634,8 @@ var init_syncer = __esm({
           new CursorAdapter(),
           new ClaudeCodeAdapter(),
           new CodexAdapter(),
-          new WindsurfAdapter()
+          new WindsurfAdapter(),
+          new AntigravityAdapter()
         ];
         for (const a of all) {
           this.adapters.set(a.source, a);
@@ -2085,8 +2174,78 @@ var init_copilot = __esm({
   }
 });
 
+// src/workspace/mcp-adapters/antigravity.ts
+import { homedir as homedir6 } from "os";
+import { join as join6 } from "path";
+var AntigravityMCPAdapter;
+var init_antigravity2 = __esm({
+  "src/workspace/mcp-adapters/antigravity.ts"() {
+    "use strict";
+    init_esm_shims();
+    AntigravityMCPAdapter = class {
+      source = "antigravity";
+      parse(content) {
+        try {
+          const config = JSON.parse(content);
+          const servers = config.mcpServers ?? config.mcp_servers ?? {};
+          return Object.entries(servers).map(([name, entry]) => {
+            const result = {
+              name,
+              command: entry.command ?? "",
+              args: entry.args ?? []
+            };
+            if (entry.serverUrl) {
+              result.url = entry.serverUrl;
+            } else if (entry.url) {
+              result.url = entry.url;
+            }
+            if (entry.headers && typeof entry.headers === "object" && Object.keys(entry.headers).length > 0) {
+              result.headers = entry.headers;
+            }
+            if (entry.env && typeof entry.env === "object" && Object.keys(entry.env).length > 0) {
+              result.env = entry.env;
+            }
+            if (entry.disabled === true) {
+              result.disabled = true;
+            }
+            return result;
+          });
+        } catch {
+          return [];
+        }
+      }
+      generate(servers) {
+        const mcpServers = {};
+        for (const s of servers) {
+          const entry = {};
+          if (s.url) {
+            entry.url = s.url;
+            if (s.headers && Object.keys(s.headers).length > 0) {
+              entry.headers = s.headers;
+            }
+          } else {
+            entry.command = s.command;
+            entry.args = s.args;
+          }
+          if (s.env && Object.keys(s.env).length > 0) {
+            entry.env = s.env;
+          }
+          if (s.disabled === true) {
+            entry.disabled = true;
+          }
+          mcpServers[s.name] = entry;
+        }
+        return JSON.stringify({ mcpServers }, null, 2);
+      }
+      getConfigPath(_projectRoot) {
+        return join6(homedir6(), ".gemini", "antigravity", "mcp_config.json");
+      }
+    };
+  }
+});
+
 // src/workspace/workflow-sync.ts
-import matter5 from "gray-matter";
+import matter6 from "gray-matter";
 var WorkflowSyncer;
 var init_workflow_sync = __esm({
   "src/workspace/workflow-sync.ts"() {
@@ -2101,7 +2260,7 @@ var init_workflow_sync = __esm({
         let description = "";
         let content = raw;
         try {
-          const parsed = matter5(raw);
+          const parsed = matter6(raw);
           description = parsed.data?.description ?? "";
           content = parsed.content.trim();
         } catch {
@@ -2123,7 +2282,7 @@ var init_workflow_sync = __esm({
         if (wf.description) {
           fm.description = wf.description;
         }
-        const content = matter5.stringify(wf.content, fm);
+        const content = matter6.stringify(wf.content, fm);
         return {
           filePath: `.agents/skills/${safeName}/SKILL.md`,
           content
@@ -2140,7 +2299,7 @@ var init_workflow_sync = __esm({
         }
         fm.globs = "";
         fm.alwaysApply = "false";
-        const content = matter5.stringify(wf.content, fm);
+        const content = matter6.stringify(wf.content, fm);
         return {
           filePath: `.cursor/rules/${safeName}.mdc`,
           content
@@ -2328,8 +2487,8 @@ var init_applier = __esm({
 
 // src/workspace/engine.ts
 import { readFileSync as readFileSync2, readdirSync, existsSync as existsSync4, cpSync, mkdirSync as mkdirSync2 } from "fs";
-import { join as join7 } from "path";
-import { homedir as homedir6 } from "os";
+import { join as join8 } from "path";
+import { homedir as homedir7 } from "os";
 var WorkspaceSyncEngine;
 var init_engine2 = __esm({
   "src/workspace/engine.ts"() {
@@ -2340,6 +2499,7 @@ var init_engine2 = __esm({
     init_codex2();
     init_claude_code2();
     init_copilot();
+    init_antigravity2();
     init_workflow_sync();
     init_syncer();
     init_sanitizer();
@@ -2352,7 +2512,8 @@ var init_engine2 = __esm({
           ["cursor", new CursorMCPAdapter()],
           ["codex", new CodexMCPAdapter()],
           ["claude-code", new ClaudeCodeMCPAdapter()],
-          ["copilot", new CopilotMCPAdapter()]
+          ["copilot", new CopilotMCPAdapter()],
+          ["antigravity", new AntigravityMCPAdapter()]
         ]);
         this.workflowSyncer = new WorkflowSyncer();
         this.rulesSyncer = new RulesSyncer(projectRoot);
@@ -2369,7 +2530,8 @@ var init_engine2 = __esm({
           cursor: [],
           codex: [],
           "claude-code": [],
-          copilot: []
+          copilot: [],
+          antigravity: []
         };
         for (const [target, adapter] of this.adapters) {
           const configPath = adapter.getConfigPath(this.projectRoot);
@@ -2460,13 +2622,14 @@ var init_engine2 = __esm({
         cursor: [".cursor/skills", ".cursor/skills-cursor"],
         windsurf: [".windsurf/skills"],
         "claude-code": [".claude/skills"],
-        copilot: []
+        copilot: [],
+        antigravity: [".agent/skills", ".gemini/skills", ".gemini/antigravity/skills"]
       };
       /** Get the target skills directory for an agent (null if agent has no skills support) */
       getTargetSkillsDir(target) {
         const dirs = _WorkspaceSyncEngine.SKILLS_DIRS[target];
         if (!dirs || dirs.length === 0) return null;
-        return join7(this.projectRoot, dirs[0]);
+        return join8(this.projectRoot, dirs[0]);
       }
       /**
        * Scan all agent skills directories and collect unique skills.
@@ -2475,12 +2638,12 @@ var init_engine2 = __esm({
         const skills = [];
         const conflicts = [];
         const seen = /* @__PURE__ */ new Map();
-        const home = homedir6();
+        const home = homedir7();
         for (const [agent, dirs] of Object.entries(_WorkspaceSyncEngine.SKILLS_DIRS)) {
           for (const dir of dirs) {
             const paths = [
-              join7(this.projectRoot, dir),
-              join7(home, dir)
+              join8(this.projectRoot, dir),
+              join8(home, dir)
             ];
             for (const skillsRoot of paths) {
               if (!existsSync4(skillsRoot)) continue;
@@ -2488,7 +2651,7 @@ var init_engine2 = __esm({
                 const entries = readdirSync(skillsRoot, { withFileTypes: true });
                 for (const entry of entries) {
                   if (!entry.isDirectory()) continue;
-                  const skillMd = join7(skillsRoot, entry.name, "SKILL.md");
+                  const skillMd = join8(skillsRoot, entry.name, "SKILL.md");
                   if (!existsSync4(skillMd)) continue;
                   let description = "";
                   try {
@@ -2500,7 +2663,7 @@ var init_engine2 = __esm({
                   const newEntry = {
                     name: entry.name,
                     description,
-                    sourcePath: join7(skillsRoot, entry.name),
+                    sourcePath: join8(skillsRoot, entry.name),
                     sourceAgent: agent
                   };
                   const existing = seen.get(entry.name);
@@ -2537,7 +2700,7 @@ var init_engine2 = __esm({
         }
         for (const skill of skills) {
           if (skill.sourceAgent === target) continue;
-          const dest = join7(targetDir, skill.name);
+          const dest = join8(targetDir, skill.name);
           if (existsSync4(dest)) {
             skipped.push(`${skill.name} (already exists in ${target})`);
             continue;
@@ -2553,13 +2716,13 @@ var init_engine2 = __esm({
       }
       scanWorkflows() {
         const workflows = [];
-        const wfDir = join7(this.projectRoot, ".windsurf", "workflows");
+        const wfDir = join8(this.projectRoot, ".windsurf", "workflows");
         if (!existsSync4(wfDir)) return workflows;
         try {
           const files = readdirSync(wfDir).filter((f) => f.endsWith(".md"));
           for (const file of files) {
             try {
-              const content = readFileSync2(join7(wfDir, file), "utf-8");
+              const content = readFileSync2(join8(wfDir, file), "utf-8");
               workflows.push(this.workflowSyncer.parseWindsurfWorkflow(file, content));
             } catch {
             }
@@ -2646,7 +2809,8 @@ var init_engine2 = __esm({
           "claude-code": "claude-code",
           codex: "codex",
           windsurf: "windsurf",
-          copilot: "windsurf"
+          copilot: "windsurf",
+          antigravity: "antigravity"
         };
         return map[target] ?? null;
       }
@@ -3583,12 +3747,12 @@ Entity: ${entityName} | Type: ${type} | Project: ${project.id}${enrichment}`
       };
     }
   );
-  const RULE_SOURCES = ["cursor", "claude-code", "codex", "windsurf"];
+  const RULE_SOURCES = ["cursor", "claude-code", "codex", "windsurf", "antigravity"];
   server.registerTool(
     "memorix_rules_sync",
     {
       title: "Rules Sync",
-      description: "Scan project for agent rule files (Cursor, Claude Code, Codex, Windsurf), deduplicate, detect conflicts, and optionally generate rules for a target agent format. Without target: returns sync status report. With target: generates converted rule files.",
+      description: "Scan project for agent rule files (Cursor, Claude Code, Codex, Windsurf, Antigravity), deduplicate, detect conflicts, and optionally generate rules for a target agent format. Without target: returns sync status report. With target: generates converted rule files.",
       inputSchema: {
         action: z.enum(["status", "generate"]).describe('Action: "status" for report, "generate" to produce target files'),
         target: z.enum(RULE_SOURCES).optional().describe("Target agent format for generation (required when action=generate)")
@@ -3638,7 +3802,7 @@ Entity: ${entityName} | Type: ${type} | Project: ${project.id}${enrichment}`
       };
     }
   );
-  const AGENT_TARGETS = ["windsurf", "cursor", "claude-code", "codex", "copilot"];
+  const AGENT_TARGETS = ["windsurf", "cursor", "claude-code", "codex", "copilot", "antigravity"];
   server.registerTool(
     "memorix_workspace_sync",
     {
@@ -3882,7 +4046,8 @@ var init_sync = __esm({
       cursor: "Cursor (.cursor/rules/*.mdc, .cursorrules)",
       "claude-code": "Claude Code (CLAUDE.md, .claude/rules/*.md)",
       codex: "Codex (SKILL.md, AGENTS.md)",
-      windsurf: "Windsurf (.windsurfrules, .windsurf/rules/*.md)"
+      windsurf: "Windsurf (.windsurfrules, .windsurf/rules/*.md)",
+      antigravity: "Antigravity (.agent/rules/*.md, GEMINI.md)"
     };
     sync_default = defineCommand3({
       meta: {
@@ -3892,7 +4057,7 @@ var init_sync = __esm({
       args: {
         target: {
           type: "string",
-          description: "Target agent format (cursor, claude-code, codex, windsurf)",
+          description: "Target agent format (cursor, claude-code, codex, windsurf, antigravity)",
           required: false
         },
         dry: {
@@ -3935,11 +4100,11 @@ var init_sync = __esm({
         }
         let target = args.target;
         if (!target) {
-          const available = ["cursor", "claude-code", "codex", "windsurf"].filter(
+          const available = ["cursor", "claude-code", "codex", "windsurf", "antigravity"].filter(
             (t) => !sources.includes(t)
           );
           if (available.length === 0) {
-            available.push("cursor", "claude-code", "codex", "windsurf");
+            available.push("cursor", "claude-code", "codex", "windsurf", "antigravity");
           }
           const selected = await p2.select({
             message: "Generate rules for which agent?",
@@ -4706,7 +4871,7 @@ import { defineCommand as defineCommand9, runMain } from "citty";
 var main = defineCommand9({
   meta: {
     name: "memorix",
-    version: "0.3.8",
+    version: "0.3.9",
     description: "Cross-Agent Memory Bridge \u2014 Universal memory layer for AI coding agents via MCP"
   },
   subCommands: {