@minhpnq1807/contextos 0.5.1 → 0.5.3

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## 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.
+- Writes the sql.js embedding cache with atomic temp-file rename to avoid partial DB files during concurrent hook/MCP writes.
+
 ## 0.5.1
 
 - Fixes `ctx sync --skills` first-run ordering by running `skillshare init` before `skillshare backup`, matching skillshare's config requirement.

package/package.json

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

package/plugins/ctx/lib/embedding-scorer.js

@@ -158,21 +158,11 @@ async function getCachedEmbedding({ cache, embedder, text, sources }) {
   return embedding;
 }
 
-async function openEmbeddingCache(dataDir) {
+export async function openEmbeddingCache(dataDir) {
   fs.mkdirSync(dataDir, { recursive: true });
   const cachePath = path.join(dataDir, "embeddings.db");
   const SQL = await getSql();
-  const buffer = fs.existsSync(cachePath) ? fs.readFileSync(cachePath) : null;
-  const db = buffer?.length ? new SQL.Database(buffer) : new SQL.Database();
-
-  db.run(`
-    CREATE TABLE IF NOT EXISTS embeddings (
-      key TEXT PRIMARY KEY,
-      model TEXT NOT NULL,
-      vector TEXT NOT NULL,
-      updated_at TEXT NOT NULL
-    )
-  `);
+  const db = initializeEmbeddingDatabase(SQL, cachePath);
 
   return {
     path: cachePath,
@@ -191,15 +181,79 @@ async function openEmbeddingCache(dataDir) {
         "INSERT OR REPLACE INTO embeddings (key, model, vector, updated_at) VALUES (?, ?, ?, ?)",
         [key, DEFAULT_MODEL, JSON.stringify(vector), new Date().toISOString()]
       );
-      fs.writeFileSync(cachePath, Buffer.from(db.export()));
+      writeDatabaseAtomically(cachePath, db);
     },
     close() {
-      fs.writeFileSync(cachePath, Buffer.from(db.export()));
+      writeDatabaseAtomically(cachePath, db);
       db.close();
     }
   };
 }
 
+function initializeEmbeddingDatabase(SQL, cachePath) {
+  let db = openSqlDatabase(SQL, cachePath);
+  try {
+    ensureEmbeddingSchema(db);
+    return db;
+  } catch (error) {
+    try {
+      db.close();
+    } catch {
+      // Ignore close failures while recovering a corrupt cache.
+    }
+    quarantineMalformedCache(cachePath, error);
+    db = new SQL.Database();
+    ensureEmbeddingSchema(db);
+    writeDatabaseAtomically(cachePath, db);
+    return db;
+  }
+}
+
+function ensureEmbeddingSchema(db) {
+  db.run(`
+    CREATE TABLE IF NOT EXISTS embeddings (
+      key TEXT PRIMARY KEY,
+      model TEXT NOT NULL,
+      vector TEXT NOT NULL,
+      updated_at TEXT NOT NULL
+    )
+  `);
+}
+
+function openSqlDatabase(SQL, cachePath) {
+  if (!fs.existsSync(cachePath)) return new SQL.Database();
+  const buffer = fs.readFileSync(cachePath);
+  if (!buffer.length) return new SQL.Database();
+  try {
+    return new SQL.Database(buffer);
+  } catch (error) {
+    quarantineMalformedCache(cachePath, error);
+    return new SQL.Database();
+  }
+}
+
+function quarantineMalformedCache(cachePath, error) {
+  const stamp = new Date().toISOString().replace(/[:.]/g, "-");
+  const corruptPath = `${cachePath}.corrupt-${stamp}-${process.pid}`;
+  try {
+    fs.renameSync(cachePath, corruptPath);
+    console.warn(`[ctx] Embedding cache was malformed and has been moved to ${corruptPath}: ${error?.message || error}`);
+  } catch {
+    try {
+      fs.rmSync(cachePath, { force: true });
+      console.warn(`[ctx] Embedding cache was malformed and has been reset: ${error?.message || error}`);
+    } catch {
+      // The caller will recreate the cache if the old file could not be moved.
+    }
+  }
+}
+
+function writeDatabaseAtomically(cachePath, db) {
+  const tmpPath = `${cachePath}.tmp-${process.pid}-${Date.now()}-${Math.random().toString(16).slice(2)}`;
+  fs.writeFileSync(tmpPath, Buffer.from(db.export()));
+  fs.renameSync(tmpPath, cachePath);
+}
+
 async function getSql() {
   if (!sqlPromise) {
     sqlPromise = (async () => {

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 } = {}) {