@minhpnq1807/contextos 0.5.42 → 0.5.44

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

@@ -10,6 +10,15 @@ const DEFAULT_EMBEDDING_CANDIDATES = 120;
 const DEFAULT_SEMANTIC_CATALOG_LIMIT = 300;
 const SCAN_CACHE_TTL_MS = 5 * 60 * 1000;
 const MAX_DESCRIPTION_CHARS = 500;
+const GENERIC_SKILL_TOKENS = new Set([
+  "active", "agent", "agents", "code", "config", "configuration", "create", "development",
+  "environment", "file", "files", "graph", "install", "integration", "local", "node", "package",
+  "project", "refresh", "rebuild", "setup", "skill", "skills", "sync", "tool", "tools", "using",
+  "build", "production", "https", "http", "com", "www"
+]);
+const SPECIALIZED_SKILL_TOKENS = new Set([
+  "android", "cicd", "eas", "expo", "ios", "postgres", "postgresql", "react-native"
+]);
 
 const scanCache = new Map();
 
@@ -154,13 +163,14 @@ export async function suggestSkills({
   prompt = "",
   skills = [],
   dataDir,
+  cwd = process.cwd(),
   limit = DEFAULT_LIMIT,
   timeoutMs = Number(process.env.CONTEXTOS_SKILL_EMBEDDING_TIMEOUT_MS || process.env.CONTEXTOS_EMBEDDING_TIMEOUT_MS || 800)
 } = {}) {
   if (!String(prompt || "").trim() || !skills.length) return [];
-  const base = scoreSkillsByKeyword({ prompt, skills });
+  const base = scoreSkillsByKeyword({ prompt, skills, projectHints: projectSkillHints({ cwd }) });
   if (skills.length > DEFAULT_SEMANTIC_CATALOG_LIMIT) {
-    return finalizeSkillScores(base, limit);
+    return finalizeSkillScores(base, limit, { minimumKeywordScore: 0.5 });
   }
 
   const embeddingCandidates = selectEmbeddingCandidates(base);
@@ -176,8 +186,9 @@ export async function suggestSkills({
   return finalizeSkillScores(embedding.rules, limit);
 }
 
-function finalizeSkillScores(skills, limit) {
-  return skills
+function finalizeSkillScores(skills, limit, { minimumKeywordScore = 0.35 } = {}) {
+  const ranked = skills
+    .filter((rule) => rule.domainEligible !== false)
     .map((rule) => ({
       name: rule.name,
       description: rule.description,
@@ -188,11 +199,23 @@ function finalizeSkillScores(skills, limit) {
       embeddingScore: rule.embeddingScore,
       reasons: rule.reasons || []
     }))
-    .filter((skill) => Number(skill.keywordScore || 0) >= 0.35 || Number(skill.embeddingScore || 0) >= 0.62)
-    .sort((a, b) => b.score - a.score || a.name.localeCompare(b.name))
+    .filter((skill) => Number(skill.keywordScore || 0) >= minimumKeywordScore || Number(skill.embeddingScore || 0) >= 0.62)
+    .sort((a, b) => b.score - a.score || scopePriority(b.scope) - scopePriority(a.scope) || a.name.localeCompare(b.name));
+  const seen = new Set();
+  return ranked
+    .filter((skill) => {
+      const key = normalize(skill.name);
+      if (seen.has(key)) return false;
+      seen.add(key);
+      return true;
+    })
     .slice(0, limit);
 }
 
+function scopePriority(scope) {
+  return scope === "project" ? 1 : 0;
+}
+
 function selectEmbeddingCandidates(skills) {
   if (skills.length <= DEFAULT_EMBEDDING_CANDIDATES) return skills;
   return [...skills]
@@ -217,21 +240,30 @@ export async function warmSkillEmbeddings({
   });
 }
 
-function scoreSkillsByKeyword({ prompt, skills }) {
-  const normalizedPrompt = normalize(prompt);
+function scoreSkillsByKeyword({ prompt, skills, projectHints = [] }) {
+  const normalizedPrompt = normalizePrompt(prompt);
   const promptTokens = new Set(normalizedPrompt.split(/\s+/).filter(Boolean));
+  const projectTokens = new Set(projectHints);
   return skills.map((skill, index) => {
     const enriched = skill.searchTokens ? skill : enrichSkill(skill);
     const name = String(enriched.name || "");
     const description = truncateDescription(enriched.description || "");
     const content = `${name} ${description}`;
-    const matches = enriched.searchTokens.filter((token) => promptTokens.has(token) && token.length > 2);
+    const matches = filterSkillMatches(
+      enriched.searchTokens.filter((token) => promptTokens.has(token) && token.length > 2 && !GENERIC_SKILL_TOKENS.has(token)),
+      { normalizedPrompt, enriched }
+    );
+    const projectMatches = enriched.searchTokens.filter((token) => projectTokens.has(token) && SPECIALIZED_SKILL_TOKENS.has(token));
     const normalizedName = enriched.normalizedName;
     const nameTokens = enriched.nameTokens;
     const nameHit = normalizedPrompt.includes(normalizedName);
     const nameTokenHit = nameTokens.length > 1 && nameTokens.every((token) => promptTokens.has(token));
     const scopeBonus = enriched.scope === "project" ? 0.08 : 0;
-    const score = Math.min(1, (matches.length ? 0.25 + matches.length * 0.08 : 0) + (nameHit ? 0.2 : 0) + (nameTokenHit ? 0.18 : 0) + scopeBonus);
+    const intentBonus = skillIntentBonus(normalizedPrompt, enriched);
+    const domainEligible = isSkillDomainEligible(normalizedPrompt, enriched);
+    const matchScore = matches.reduce((sum, token) => sum + (SPECIALIZED_SKILL_TOKENS.has(token) ? 0.2 : 0.08), 0);
+    const projectBonus = matches.length && intentBonus ? Math.min(0.16, projectMatches.length * 0.04) : 0;
+    const score = Math.min(1, (matches.length ? 0.25 + matchScore : 0) + projectBonus + intentBonus + (nameHit ? 0.2 : 0) + (nameTokenHit ? 0.18 : 0) + scopeBonus);
     return {
       id: `skill-${index + 1}`,
       name,
@@ -241,8 +273,11 @@ function scoreSkillsByKeyword({ prompt, skills }) {
       content,
       score,
       keywordScore: score,
+      domainEligible,
       reasons: [
         ...(matches.length ? [`keyword:${matches.slice(0, 4).join(",")}`] : []),
+        ...(projectBonus ? [`project:${projectMatches.slice(0, 4).join(",")}`] : []),
+        ...(intentBonus ? ["intent-match"] : []),
         ...(nameHit || nameTokenHit ? ["name-match"] : [])
       ],
       originalOrder: index
@@ -250,6 +285,67 @@ function scoreSkillsByKeyword({ prompt, skills }) {
   });
 }
 
+function filterSkillMatches(matches, { normalizedPrompt, enriched }) {
+  if (!/\beas\b/.test(normalizedPrompt)) return matches;
+  const skillText = normalize(`${enriched.name} ${enriched.description}`);
+  if (/\b(eas|expo|cicd)\b/.test(skillText)) return matches;
+  return matches.filter((token) => token !== "android" && token !== "ios");
+}
+
+function isSkillDomainEligible(normalizedPrompt, enriched) {
+  if (!/\beas\b/.test(normalizedPrompt)) return true;
+  const skillText = normalize(`${enriched.name} ${enriched.description}`);
+  if (!/\b(android|ios)\b/.test(skillText)) return true;
+  return /\b(eas|expo|cicd)\b/.test(skillText);
+}
+
+function skillIntentBonus(normalizedPrompt, enriched) {
+  const skillText = normalize(`${enriched.name} ${enriched.description}`);
+  if (/\beas\b/.test(normalizedPrompt)
+    && /\b(eas|expo)\b/.test(skillText)
+    && /\b(cicd|workflow|workflows|build|deploy|deployment|pipeline|pipelines)\b/.test(skillText)) {
+    return 0.28;
+  }
+  return 0;
+}
+
+export function projectSkillHints({ cwd = process.cwd() } = {}) {
+  const hints = new Set();
+  const packagePaths = [path.join(cwd, "package.json")];
+  const rootPackage = readJson(path.join(cwd, "package.json"));
+  for (const workspace of rootPackage?.workspaces || []) {
+    if (typeof workspace !== "string" || workspace.includes("*")) continue;
+    packagePaths.push(path.join(cwd, workspace, "package.json"));
+  }
+
+  for (const packagePath of packagePaths) {
+    const packageDir = path.dirname(packagePath);
+    const packageJson = readJson(packagePath);
+    addHintText(hints, JSON.stringify({
+      name: packageJson?.name,
+      description: packageJson?.description,
+      dependencies: Object.keys(packageJson?.dependencies || {}),
+      devDependencies: Object.keys(packageJson?.devDependencies || {})
+    }));
+    for (const fileName of ["app.json", "app.config.js", "app.config.ts", "eas.json"]) {
+      if (fs.existsSync(path.join(packageDir, fileName))) addHintText(hints, fileName);
+    }
+  }
+  return [...hints];
+}
+
+function readJson(filePath) {
+  try {
+    return JSON.parse(fs.readFileSync(filePath, "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+function addHintText(hints, value) {
+  for (const token of normalize(value).split(/\s+/).filter(Boolean)) hints.add(token);
+}
+
 function enrichSkill(skill) {
   const name = String(skill.name || "");
   const description = truncateDescription(skill.description || "");
@@ -268,3 +364,7 @@ function enrichSkill(skill) {
 function normalize(value) {
   return String(value || "").toLowerCase().replace(/[^a-z0-9]+/g, " ").trim();
 }
+
+function normalizePrompt(value) {
+  return normalize(String(value || "").replace(/https?:\/\/\S+/gi, " "));
+}

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

@@ -4,6 +4,7 @@ import path from "node:path";
 import readline from "node:readline/promises";
 import { stdin as input, stdout as output } from "node:process";
 import { execFileSync, execSync, spawn } from "node:child_process";
+import { shellInvocation } from "./shell-runner.js";
 
 const DEFAULT_AGENTS = ["codex", "claude", "antigravity", "copilot"];
 const INSTALL_SH_URL = "https://raw.githubusercontent.com/runkids/skillshare/main/install.sh";
@@ -141,7 +142,8 @@ export async function installSkillshare({
     if (osName === "windows") {
       await spawnShellStreaming("powershell", ["-NoProfile", "-ExecutionPolicy", "Bypass", "-Command", `irm ${INSTALL_PS_URL} | iex`]);
     } else {
-      await spawnShellStreaming("sh", ["-c", `curl -fsSL ${INSTALL_SH_URL} | sh`]);
+      const shell = shellInvocation(`curl -fsSL ${INSTALL_SH_URL} | sh`, { platform: process.platform });
+      await spawnShellStreaming(shell.command, shell.args);
     }
   }
 
@@ -206,14 +208,52 @@ export function detectExistingSkills({ cwd = process.cwd(), home = os.homedir()
     .filter((entry) => entry.count > 0);
 }
 
+export function repairSkillSymlinks({
+  cwd = process.cwd(),
+  home = os.homedir(),
+  roots = skillRoots({ cwd, home }),
+  dryRun = false
+} = {}) {
+  const repaired = [];
+  const removedBroken = [];
+  for (const root of roots) {
+    let entries = [];
+    try {
+      entries = fs.readdirSync(root, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      if (!entry.isSymbolicLink()) continue;
+      const linkPath = path.join(root, entry.name);
+      const real = safeRealpath(linkPath);
+      if (!real) {
+        if (!dryRun) fs.rmSync(linkPath, { force: true, recursive: true });
+        removedBroken.push(linkPath);
+        continue;
+      }
+      if (!dryRun) {
+        fs.rmSync(linkPath, { force: true, recursive: true });
+        const stat = fs.statSync(real);
+        if (stat.isDirectory()) copyDirectory(real, linkPath);
+        else if (stat.isFile()) fs.copyFileSync(real, linkPath);
+      }
+      repaired.push(linkPath);
+    }
+  }
+  return { repaired: [...new Set(repaired)], removedBroken: [...new Set(removedBroken)] };
+}
+
 function skillRoots({ cwd, home }) {
   return uniquePaths([
     path.join(home, ".claude", "skills"),
     path.join(home, ".codex", "skills"),
+    path.join(home, ".agents", "skills"),
     path.join(home, ".gemini", "antigravity", "skills"),
     path.join(home, ".gemini", "antigravity-cli", "skills"),
     path.join(cwd, ".claude", "skills"),
     path.join(cwd, ".codex", "skills"),
+    path.join(cwd, ".agents", "skills"),
     path.join(cwd, ".gemini", "antigravity", "skills"),
     path.join(cwd, ".gemini", "antigravity-cli", "skills"),
     ...discoverSkillRoots({ cwd, home })
@@ -236,9 +276,11 @@ export function discoverSkillRoots({ cwd = process.cwd(), home = os.homedir() }
     path.join(home, ".gemini"),
     path.join(home, ".codex"),
     path.join(home, ".claude"),
+    path.join(home, ".agents"),
     path.join(cwd, ".gemini"),
     path.join(cwd, ".codex"),
-    path.join(cwd, ".claude")
+    path.join(cwd, ".claude"),
+    path.join(cwd, ".agents")
   ]) {
     findSkillRoots(base, 0, roots);
   }
@@ -436,6 +478,13 @@ export async function syncSkills({
   }
 
   if (!options.noCollect) {
+    const repaired = repairSkillSymlinks({ cwd, home, dryRun: options.dryRun });
+    if (repaired.repaired.length || repaired.removedBroken.length) {
+      logger(statusLine("Repairing skill symlinks...", options.dryRun
+        ? `dry-run (${repaired.repaired.length} would copy, ${repaired.removedBroken.length} broken)`
+        : `✓ ${repaired.repaired.length} copied, ${repaired.removedBroken.length} broken removed`));
+    }
+
     const legacy = collectAntigravityLegacySkills({ cwd, home, dryRun: options.dryRun });
     if (legacy.copied.length || legacy.skipped.length) {
       const value = options.dryRun

package/plugins/ctx/lib/stop-hook.js

@@ -2,7 +2,7 @@ import fs from "node:fs";
 
 import { appendJsonLine, readJsonFile, writeJsonFile } from "./fs-utils.js";
 import { readGitSnapshot, checkCompliance } from "./measure.js";
-import { buildReport, formatReport } from "./reporter.js";
+import { buildReport } from "./reporter.js";
 import { loadRuntimeEvidence } from "./telemetry.js";
 import { filterActionableRules } from "./analyzer.js";
 import { resolveHookCwd } from "./hook-io.js";
@@ -54,7 +54,6 @@ export function handleStopPayload(payload, { contextPath, reportPath, historyPat
   if (historyPath) appendJsonLine(historyPath, report);
 
   return {
-    continue: true,
-    systemMessage: formatReport(report)
+    continue: true
   };
 }

package/plugins/ctx/lib/toml-config.js

@@ -0,0 +1,116 @@
+import { parse } from "smol-toml";
+
+export function readMcpServersFromToml(content) {
+  const config = parseToml(content);
+  const servers = config.mcp_servers && typeof config.mcp_servers === "object"
+    ? config.mcp_servers
+    : {};
+
+  return Object.entries(servers)
+    .filter(([, server]) => server && typeof server.command === "string")
+    .map(([name, server]) => ({
+      name,
+      command: server.command,
+      args: Array.isArray(server.args) ? server.args.map(String) : []
+    }));
+}
+
+export function updateMcpServerFields(content, name, fields) {
+  parseToml(content);
+  const lines = String(content || "").split(/\r?\n/);
+  const section = findMcpServerSection(lines, name);
+  if (!section) return content;
+
+  let body = lines.slice(section.start + 1, section.end);
+  for (const [key, value] of Object.entries(fields)) {
+    body = replaceOrInsertField(body, key, formatTomlValue(value));
+  }
+  lines.splice(section.start + 1, section.end - section.start - 1, ...body);
+  return lines.join("\n");
+}
+
+export function formatTomlValue(value) {
+  if (Array.isArray(value)) return `[${value.map((item) => JSON.stringify(String(item))).join(", ")}]`;
+  return JSON.stringify(String(value));
+}
+
+function parseToml(content) {
+  return parse(String(content || ""));
+}
+
+function findMcpServerSection(lines, name) {
+  for (let index = 0; index < lines.length; index += 1) {
+    const sectionName = mcpServerNameFromHeader(lines[index]);
+    if (sectionName !== name) continue;
+    let end = lines.length;
+    for (let cursor = index + 1; cursor < lines.length; cursor += 1) {
+      if (/^\s*\[/.test(lines[cursor])) {
+        end = cursor;
+        break;
+      }
+    }
+    return { start: index, end };
+  }
+  return null;
+}
+
+function mcpServerNameFromHeader(line) {
+  const match = String(line || "").match(/^\s*\[mcp_servers\.([^\]]+)\]\s*(?:#.*)?$/);
+  if (!match || match[1].includes(".tools.")) return null;
+  const raw = match[1].trim();
+  if (!raw.startsWith('"')) return raw;
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+
+function replaceOrInsertField(body, key, value) {
+  const next = [...body];
+  const start = next.findIndex((line) => new RegExp(`^\\s*${escapeRegExp(key)}\\s*=`).test(line));
+  const line = `${key} = ${value}`;
+  if (start < 0) {
+    next.unshift(line);
+    return next;
+  }
+
+  let end = start + 1;
+  if (valueForField(next[start]).trimStart().startsWith("[")) {
+    while (end < next.length && !isBalancedTomlArray(next.slice(start, end).join("\n"))) end += 1;
+  }
+  next.splice(start, Math.max(1, end - start), line);
+  return next;
+}
+
+function valueForField(line) {
+  return String(line || "").slice(String(line || "").indexOf("=") + 1);
+}
+
+function isBalancedTomlArray(value) {
+  let depth = 0;
+  let quoted = false;
+  let escaped = false;
+  for (const char of String(value || "")) {
+    if (escaped) {
+      escaped = false;
+      continue;
+    }
+    if (char === "\\" && quoted) {
+      escaped = true;
+      continue;
+    }
+    if (char === '"') {
+      quoted = !quoted;
+      continue;
+    }
+    if (quoted) continue;
+    if (char === "[") depth += 1;
+    if (char === "]") depth -= 1;
+  }
+  return depth <= 0;
+}
+
+function escapeRegExp(value) {
+  return String(value).replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}

package/plugins/ctx/mcp/server.js

@@ -6,7 +6,7 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 
 import { isModelCacheReady, modelCacheDir } from "../lib/embedding-scorer.js";
 import { scoreContext } from "../lib/score-context.js";
-import { ctxMcpSocketPath } from "../lib/ctx-mcp-client.js";
+import { CTX_MCP_BRIDGE_REVISION, ctxMcpSocketPath } from "../lib/ctx-mcp-client.js";
 import { defaultDataRoot } from "../lib/workspace-data.js";
 import { createContextOSMcpServer } from "./contextos-server.js";
 
@@ -33,6 +33,9 @@ function startBridge() {
   fs.rmSync(socketPath, { force: true });
   const bridge = net.createServer((socket) => {
     let raw = "";
+    socket.on("error", () => {
+      // Clients may time out and close while scoring is still in progress.
+    });
     socket.on("data", (chunk) => {
       raw += chunk.toString("utf8");
       if (raw.includes("\n")) handleBridgeRequest(socket, raw);
@@ -68,9 +71,10 @@ async function handleBridgeRequest(socket, raw) {
       skills: payload.skills,
       workflows: payload.workflows
     });
-    socket.end(JSON.stringify(result));
+    socket.end(JSON.stringify({ ...result, bridgeRevision: CTX_MCP_BRIDGE_REVISION }));
   } catch (error) {
     socket.end(JSON.stringify({
+      bridgeRevision: CTX_MCP_BRIDGE_REVISION,
       error: error?.message || String(error),
       scoredRules: [],
       suggestedFiles: [],