@minhpnq1807/contextos 0.5.50 → 0.5.52

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

@@ -244,6 +244,106 @@ export function repairSkillSymlinks({
   return { repaired: [...new Set(repaired)], removedBroken: [...new Set(removedBroken)] };
 }
 
+export function dedupeAgentVisibleSkills({
+  cwd = process.cwd(),
+  home = os.homedir(),
+  agents = DEFAULT_AGENTS,
+  dryRun = false
+} = {}) {
+  const roots = visibleSkillRootsForAgents({ cwd, home, agents });
+  const seen = new Map();
+  const kept = [];
+  const removed = [];
+
+  for (const root of roots) {
+    for (const skill of listSkillsInRoot(root)) {
+      const previous = seen.get(skill.key);
+      if (!previous) {
+        seen.set(skill.key, skill);
+        kept.push(skill.path);
+        continue;
+      }
+
+      const previousReal = safeRealpath(previous.path);
+      const currentReal = safeRealpath(skill.path);
+      if (previousReal && currentReal && previousReal === currentReal) {
+        if (!dryRun) fs.rmSync(skill.path, { force: true, recursive: true });
+        removed.push(skill.path);
+        continue;
+      }
+
+      if (!dryRun) fs.rmSync(skill.path, { force: true, recursive: true });
+      removed.push(skill.path);
+    }
+  }
+
+  return { kept: [...new Set(kept)], removed: [...new Set(removed)], roots };
+}
+
+function visibleSkillRootsForAgents({ cwd, home, agents }) {
+  const normalizedAgents = normalizeAgentList(agents);
+  const roots = [];
+  const addShared = () => {
+    roots.push(path.join(home, ".agents", "skills"));
+    roots.push(path.join(cwd, ".agents", "skills"));
+  };
+
+  addShared();
+  if (normalizedAgents.includes("codex")) {
+    roots.push(path.join(home, ".codex", "skills"));
+    roots.push(path.join(cwd, ".codex", "skills"));
+  }
+  if (normalizedAgents.includes("claude")) {
+    roots.push(path.join(home, ".claude", "skills"));
+    roots.push(path.join(cwd, ".claude", "skills"));
+  }
+  if (normalizedAgents.includes("antigravity")) {
+    roots.push(path.join(home, ".gemini", "skills"));
+    roots.push(path.join(home, ".gemini", "antigravity", "skills"));
+    roots.push(path.join(home, ".gemini", "antigravity-cli", "skills"));
+    roots.push(path.join(cwd, ".gemini", "skills"));
+    roots.push(path.join(cwd, ".gemini", "antigravity", "skills"));
+    roots.push(path.join(cwd, ".gemini", "antigravity-cli", "skills"));
+  }
+
+  return uniquePaths(roots);
+}
+
+function listSkillsInRoot(root) {
+  return findSkillFiles(root)
+    .map((skillFile) => {
+      const skillDir = path.dirname(skillFile);
+      const name = readSkillName(skillFile) || path.basename(skillDir);
+      return {
+        name,
+        key: normalizeSkillName(name),
+        path: skillDir,
+        root
+      };
+    })
+    .filter((skill) => skill.key)
+    .sort((a, b) => a.path.localeCompare(b.path));
+}
+
+function readSkillName(skillFile) {
+  try {
+    const content = fs.readFileSync(skillFile, "utf8");
+    return content.match(/^\s*name:\s*(.+?)\s*$/m)?.[1]
+      ?.replace(/^["']|["']$/g, "")
+      .trim() || "";
+  } catch {
+    return "";
+  }
+}
+
+function normalizeSkillName(name) {
+  return String(name || "")
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9._-]+/g, "-")
+    .replace(/^-+|-+$/g, "");
+}
+
 function skillRoots({ cwd, home }) {
   return uniquePaths([
     path.join(home, ".claude", "skills"),
@@ -503,6 +603,18 @@ export async function syncSkills({
   const syncedCount = countSkillFiles(skillshareSourceDir({ home }));
   logger(statusLine("Running skillshare sync...", options.dryRun ? "dry-run" : `✓ ${syncedCount} skills → ${options.agents.join(", ")}`));
 
+  const deduped = dedupeAgentVisibleSkills({
+    cwd,
+    home,
+    agents: options.agents,
+    dryRun: options.dryRun
+  });
+  if (deduped.removed.length) {
+    logger(statusLine("Deduping agent-visible skills...", options.dryRun
+      ? `dry-run (${deduped.removed.length} duplicates)`
+      : `✓ ${deduped.removed.length} duplicates removed`));
+  }
+
   let embeddings = { count: 0, cachePath: null, skipped: options.dryRun || options.noEmbeddings };
   if (options.noEmbeddings) {
     logger(statusLine("Rebuilding skill embeddings...", "skipped by --no-embeddings"));

package/plugins/ctx/lib/workflow-discoverer.js

@@ -128,12 +128,14 @@ export async function suggestWorkflows({
   workflows = [],
   dataDir,
   limit = DEFAULT_LIMIT,
-  timeoutMs = Number(process.env.CONTEXTOS_WORKFLOW_EMBEDDING_TIMEOUT_MS || process.env.CONTEXTOS_EMBEDDING_TIMEOUT_MS || 800)
+  timeoutMs = Number(process.env.CONTEXTOS_WORKFLOW_EMBEDDING_TIMEOUT_MS || process.env.CONTEXTOS_EMBEDDING_TIMEOUT_MS || 800),
+  embeddingsEnabled = true
 } = {}) {
   if (!String(prompt || "").trim() || !workflows.length) return [];
   const base = scoreWorkflowsByKeyword({ prompt, workflows });
   const embeddingCandidates = selectWorkflowEmbeddingCandidates(base);
   if (!embeddingCandidates.length) return [];
+  if (!embeddingsEnabled) return finalizeWorkflowScores(embeddingCandidates, limit);
 
   const embedding = await enhanceRuleScoresWithEmbeddings(embeddingCandidates, prompt, {
     dataDir,

package/plugins/ctx/mcp/contextos-server.js

@@ -4,12 +4,32 @@ import { z } from "zod";
 import { scoreContext } from "../lib/score-context.js";
 import { scheduleContext } from "../lib/scheduler.js";
 
-export function createContextOSMcpServer({ dataDir }) {
+export function createContextOSMcpServer({ dataDir, getHealth = defaultHealth }) {
   const server = new McpServer({
     name: "ctx-mcp",
     version: "0.1.0"
   });
 
+  server.registerTool("ctx_health", {
+    title: "ContextOS health",
+    description: "Reports ContextOS MCP bridge and embedding model readiness.",
+    inputSchema: {},
+    outputSchema: {
+      model_cache_ready: z.boolean(),
+      embedding_pipeline_loaded: z.boolean(),
+      bridge_ready: z.boolean(),
+      preload_status: z.string().optional(),
+      loaded_at: z.number().optional(),
+      error: z.string().optional()
+    }
+  }, async () => {
+    const health = getHealth();
+    return {
+      content: [{ type: "text", text: JSON.stringify(health) }],
+      structuredContent: health
+    };
+  });
+
   server.registerTool("ctx_score_context", {
     title: "Score ContextOS prompt context",
     description: "Scores AGENTS.md rules and suggests files/skills for an agent prompt.",
@@ -90,3 +110,11 @@ export function createContextOSMcpServer({ dataDir }) {
   return server;
 }
 
+function defaultHealth() {
+  return {
+    model_cache_ready: false,
+    embedding_pipeline_loaded: false,
+    bridge_ready: false,
+    preload_status: "unknown"
+  };
+}

package/plugins/ctx/mcp/server.js

@@ -4,7 +4,7 @@ import net from "node:net";
 
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 
-import { isModelCacheReady, modelCacheDir } from "../lib/embedding-scorer.js";
+import { isModelCacheReady, modelCacheDir, preloadEmbeddingPipeline } from "../lib/embedding-scorer.js";
 import { scoreContext } from "../lib/score-context.js";
 import { CTX_MCP_BRIDGE_REVISION, ctxMcpSocketPath } from "../lib/ctx-mcp-client.js";
 import { defaultDataRoot } from "../lib/workspace-data.js";
@@ -12,23 +12,51 @@ import { createContextOSMcpServer } from "./contextos-server.js";
 
 const dataDir = defaultDataRoot();
 const socketPath = ctxMcpSocketPath(dataDir);
+const modelState = {
+  modelCacheReady: false,
+  embeddingPipelineLoaded: false,
+  bridgeReady: false,
+  preloadStatus: "starting",
+  loadedAt: null,
+  error: null
+};
 
 fs.mkdirSync(dataDir, { recursive: true });
 await ensureModelReady();
 if (process.env.CONTEXTOS_DISABLE_BRIDGE !== "1") startBridge();
+preloadEmbeddingModel();
 const keepAlive = setInterval(() => {}, 2 ** 31 - 1);
 
-const server = createContextOSMcpServer({ dataDir });
+const server = createContextOSMcpServer({ dataDir, getHealth: bridgeHealth });
 console.error("ctx-mcp ready");
 await server.connect(new StdioServerTransport());
 
 async function ensureModelReady() {
   const modelDir = modelCacheDir(dataDir);
-  if (!fs.existsSync(modelDir) || !isModelCacheReady(dataDir)) {
+  modelState.modelCacheReady = fs.existsSync(modelDir) && isModelCacheReady(dataDir);
+  if (!modelState.modelCacheReady) {
     throw new Error(`ContextOS model cache missing: ${modelDir}. Run ctx install first.`);
   }
 }
 
+async function preloadEmbeddingModel() {
+  modelState.preloadStatus = "loading";
+  const result = await preloadEmbeddingPipeline({
+    dataDir,
+    allowRemote: false,
+    warmText: "contextos warmup"
+  });
+  modelState.embeddingPipelineLoaded = Boolean(result.loaded);
+  modelState.preloadStatus = result.status;
+  modelState.loadedAt = result.loaded ? Date.now() : null;
+  modelState.error = result.error || null;
+  if (result.loaded) {
+    console.error(`ctx-mcp embedding model hot (${result.elapsedMs}ms)`);
+  } else {
+    console.error(`ctx-mcp embedding preload failed: ${result.error || result.status}`);
+  }
+}
+
 function startBridge() {
   fs.rmSync(socketPath, { force: true });
   const bridge = net.createServer((socket) => {
@@ -42,9 +70,12 @@ function startBridge() {
     });
   });
   bridge.on("error", (error) => {
+    modelState.bridgeReady = false;
     console.error(`ctx-mcp bridge disabled: ${error?.message || String(error)}`);
   });
-  bridge.listen(socketPath);
+  bridge.listen(socketPath, () => {
+    modelState.bridgeReady = true;
+  });
   process.on("exit", () => {
     clearInterval(keepAlive);
     fs.rmSync(socketPath, { force: true });
@@ -60,6 +91,10 @@ async function handleBridgeRequest(socket, raw) {
   socket.pause();
   try {
     const payload = JSON.parse(raw.trim() || "{}");
+    if (payload.type === "health") {
+      socket.end(JSON.stringify({ bridgeRevision: CTX_MCP_BRIDGE_REVISION, health: bridgeHealth() }));
+      return;
+    }
     const result = await scoreContext({
       cwd: payload.cwd || process.cwd(),
       prompt: payload.prompt || "",
@@ -84,3 +119,14 @@ async function handleBridgeRequest(socket, raw) {
     }));
   }
 }
+
+function bridgeHealth() {
+  return {
+    model_cache_ready: Boolean(modelState.modelCacheReady),
+    embedding_pipeline_loaded: Boolean(modelState.embeddingPipelineLoaded),
+    bridge_ready: Boolean(modelState.bridgeReady),
+    preload_status: modelState.preloadStatus,
+    loaded_at: modelState.loadedAt || undefined,
+    error: modelState.error || undefined
+  };
+}