@minhpnq1807/contextos 0.5.0 → 0.5.2

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 # Changelog
 
+## 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.
+
 ## 0.5.0
 
 - Adds `ctx sync --skills` for skillshare-backed skill sync across Codex, Claude Code, and Antigravity.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@minhpnq1807/contextos",
-  "version": "0.5.0",
+  "version": "0.5.2",
   "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/skillshare-sync.js

@@ -199,10 +199,6 @@ export async function syncSkills({
       for (const entry of existing) {
         logger(`      ${entry.path.padEnd(44)} ${entry.count} skills`);
       }
-      if (!options.noCollect) {
-        run("skillshare", ["backup"], { cwd, stdio: "inherit", dryRun: options.dryRun });
-        logger(statusLine("Backing up...", options.dryRun ? "dry-run" : "✓ backup created"));
-      }
     } else {
       logger("[ctx] No existing skills found.");
     }
@@ -211,6 +207,8 @@ export async function syncSkills({
     logger(statusLine("Initializing skillshare...", options.dryRun ? "dry-run" : "✓ initialized"));
 
     if (existing.length && !options.noCollect) {
+      run("skillshare", ["backup"], { cwd, stdio: "inherit", dryRun: options.dryRun });
+      logger(statusLine("Backing up...", options.dryRun ? "dry-run" : "✓ backup created"));
       run("skillshare", ["collect", "--all"], { cwd, stdio: "inherit", dryRun: options.dryRun });
       const collected = countSkillFiles(skillshareSourceDir({ home }));
       logger(statusLine("Collecting from all agents...", options.dryRun ? "dry-run" : `✓ ${collected} skills collected`));