@minhpnq1807/contextos 0.5.2 → 0.5.4

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## 0.5.4
+
+- Bridges legacy Antigravity skill directories (`~/.gemini/antigravity/skills` and `~/.gemini/antigravity-cli/skills`) into the skillshare source before `ctx sync --skills`.
+- Reads custom `sources.skills` from `~/.config/skillshare/config.yaml` so ContextOS writes to the actual skillshare source path.
+
+## 0.5.3
+
+- Skips project MCP imports whose command is an absolute path that does not exist, preventing placeholder paths such as `/home/user/.cargo/bin/mcp-rtk` from reaching Antigravity.
+- Sanitizes Antigravity MCP config files during `ctx sync --rules` by removing existing MCP entries with missing absolute command paths.
+
 ## 0.5.2
 
 - Recovers automatically from malformed `embeddings.db` files by moving the corrupt cache aside and recreating it.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@minhpnq1807/contextos",
-  "version": "0.5.2",
+  "version": "0.5.4",
   "description": "Task-aware AGENTS.md context injection and compliance reporting for Codex, Claude Code, and Antigravity.",
   "type": "module",
   "bin": {

package/plugins/ctx/lib/ruler-sync.js

@@ -196,6 +196,7 @@ export function readProjectMcpJsonServers({ cwd = process.cwd(), configPath = pa
   const mcpServers = config.mcpServers && typeof config.mcpServers === "object" ? config.mcpServers : {};
   return Object.entries(mcpServers)
     .filter(([, server]) => server && typeof server.command === "string")
+    .filter(([, server]) => isRunnableMcpCommand(server.command))
     .map(([name, server]) => ({
       name,
       command: server.command,
@@ -203,6 +204,11 @@ export function readProjectMcpJsonServers({ cwd = process.cwd(), configPath = pa
     }));
 }
 
+function isRunnableMcpCommand(command) {
+  if (!path.isAbsolute(command)) return true;
+  return fs.existsSync(command);
+}
+
 function mergeMcpServers(...groups) {
   const merged = new Map();
   for (const group of groups) {
@@ -253,12 +259,21 @@ function writeJsonFile(filePath, value) {
 }
 
 export function syncAntigravityMcpFromRuler({ tomlPath, configPaths = antigravityMcpConfigPaths(), dryRun = false } = {}) {
-  const servers = readRulerMcpServers({ tomlPath });
-  if (!servers.length) return { changed: false, servers: [], configPaths };
+  const allServers = readRulerMcpServers({ tomlPath });
+  const servers = allServers.filter((server) => isRunnableMcpCommand(server.command));
+  const skipped = allServers.filter((server) => !isRunnableMcpCommand(server.command)).map((server) => server.name);
+  if (!servers.length && !skipped.length) return { changed: false, servers: [], skipped, removed: [], configPaths };
 
+  const removed = [];
   for (const configPath of configPaths) {
     const config = readJsonFile(configPath, {});
     if (!config.mcpServers || typeof config.mcpServers !== "object") config.mcpServers = {};
+    for (const [name, server] of Object.entries(config.mcpServers)) {
+      if (server?.command && !isRunnableMcpCommand(server.command)) {
+        delete config.mcpServers[name];
+        removed.push(name);
+      }
+    }
     for (const server of servers) {
       config.mcpServers[server.name] = {
         command: server.command,
@@ -268,7 +283,7 @@ export function syncAntigravityMcpFromRuler({ tomlPath, configPaths = antigravit
     if (!dryRun) writeJsonFile(configPath, config);
   }
 
-  return { changed: true, servers: servers.map((server) => server.name), configPaths };
+  return { changed: true, servers: servers.map((server) => server.name), skipped, removed: [...new Set(removed)], configPaths };
 }
 
 export function buildCtxMcpToml({ mcpServerPath, agents = DEFAULT_AGENTS } = {}) {

package/plugins/ctx/lib/skillshare-sync.js

@@ -50,7 +50,22 @@ export function skillshareConfigDir({ home = os.homedir() } = {}) {
 }
 
 export function skillshareSourceDir({ home = os.homedir() } = {}) {
-  return path.join(skillshareConfigDir({ home }), "skills");
+  return readSkillshareSourceDir({ home }) || path.join(skillshareConfigDir({ home }), "skills");
+}
+
+function readSkillshareSourceDir({ home = os.homedir() } = {}) {
+  const configPath = path.join(skillshareConfigDir({ home }), "config.yaml");
+  if (!fs.existsSync(configPath)) return null;
+  const content = fs.readFileSync(configPath, "utf8");
+  const match = content.match(/^\s{2}skills:\s*(.+?)\s*$/m);
+  if (!match) return null;
+  return expandHome(match[1].replace(/^["']|["']$/g, ""), home);
+}
+
+function expandHome(value, home) {
+  if (value === "~") return home;
+  if (value.startsWith("~/")) return path.join(home, value.slice(2));
+  return value;
 }
 
 export function checkSkillshareInstalled({ run = runCommand } = {}) {
@@ -119,6 +134,15 @@ function skillRoots({ cwd, home }) {
   ];
 }
 
+function antigravityLegacyRoots({ cwd, home }) {
+  return [
+    path.join(home, ".gemini", "antigravity", "skills"),
+    path.join(home, ".gemini", "antigravity-cli", "skills"),
+    path.join(cwd, ".gemini", "antigravity", "skills"),
+    path.join(cwd, ".gemini", "antigravity-cli", "skills")
+  ];
+}
+
 function countSkillFiles(root) {
   return findSkillFiles(root).length;
 }
@@ -158,6 +182,57 @@ function safeStat(filePath) {
   }
 }
 
+function safeRealpath(filePath) {
+  try {
+    return fs.realpathSync(filePath);
+  } catch {
+    return null;
+  }
+}
+
+function copyDirectory(sourceDir, targetDir) {
+  fs.mkdirSync(targetDir, { recursive: true });
+  for (const entry of fs.readdirSync(sourceDir, { withFileTypes: true })) {
+    const source = path.join(sourceDir, entry.name);
+    const target = path.join(targetDir, entry.name);
+    if (entry.isDirectory()) {
+      copyDirectory(source, target);
+    } else if (entry.isSymbolicLink()) {
+      const link = fs.readlinkSync(source);
+      fs.symlinkSync(link, target);
+    } else if (entry.isFile()) {
+      fs.copyFileSync(source, target);
+    }
+  }
+}
+
+export function collectAntigravityLegacySkills({
+  cwd = process.cwd(),
+  home = os.homedir(),
+  sourceDir = skillshareSourceDir({ home }),
+  dryRun = false
+} = {}) {
+  const sourceReal = safeRealpath(sourceDir);
+  const copied = [];
+  const skipped = [];
+  for (const root of antigravityLegacyRoots({ cwd, home })) {
+    const rootReal = safeRealpath(root);
+    if (!rootReal || rootReal === sourceReal) continue;
+    for (const skillFile of findSkillFiles(root)) {
+      const skillDir = path.dirname(skillFile);
+      const name = path.basename(skillDir);
+      const targetDir = path.join(sourceDir, name);
+      if (fs.existsSync(targetDir)) {
+        skipped.push(name);
+        continue;
+      }
+      if (!dryRun) copyDirectory(skillDir, targetDir);
+      copied.push(name);
+    }
+  }
+  return { copied: [...new Set(copied)], skipped: [...new Set(skipped)], sourceDir };
+}
+
 export function isSkillshareInitialized({ home = os.homedir() } = {}) {
   return fs.existsSync(skillshareConfigDir({ home }));
 }
@@ -215,6 +290,16 @@ export async function syncSkills({
     }
   }
 
+  if (!options.noCollect) {
+    const legacy = collectAntigravityLegacySkills({ cwd, home, dryRun: options.dryRun });
+    if (legacy.copied.length || legacy.skipped.length) {
+      const value = options.dryRun
+        ? `dry-run (${legacy.copied.length} would copy, ${legacy.skipped.length} already present)`
+        : `✓ ${legacy.copied.length} copied, ${legacy.skipped.length} already present`;
+      logger(statusLine("Collecting Antigravity legacy skills...", value));
+    }
+  }
+
   const syncArgs = ["sync"];
   if (options.dryRun) syncArgs.push("--dry-run");
   if (options.agents.length) syncArgs.push("--agents", options.agents.join(","));