@minhpnq1807/contextos 0.5.3 → 0.5.5

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## 0.5.5
+
+- Discovers all skill roots containing `SKILL.md` under global/project `.gemini`, `.codex`, and `.claude` directories before `ctx sync --skills`.
+- Skips temporary/cache directories such as `.tmp`, `.git`, and `node_modules` while discovering skill roots.
+
+## 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.

package/package.json

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

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 } = {}) {
@@ -107,7 +122,7 @@ export function detectExistingSkills({ cwd = process.cwd(), home = os.homedir()
 }
 
 function skillRoots({ cwd, home }) {
-  return [
+  return uniquePaths([
     path.join(home, ".claude", "skills"),
     path.join(home, ".codex", "skills"),
     path.join(home, ".gemini", "antigravity", "skills"),
@@ -115,8 +130,67 @@ function skillRoots({ cwd, home }) {
     path.join(cwd, ".claude", "skills"),
     path.join(cwd, ".codex", "skills"),
     path.join(cwd, ".gemini", "antigravity", "skills"),
-    path.join(cwd, ".gemini", "antigravity-cli", "skills")
-  ];
+    path.join(cwd, ".gemini", "antigravity-cli", "skills"),
+    ...discoverSkillRoots({ cwd, home })
+  ]);
+}
+
+function antigravityLegacyRoots({ cwd, home }) {
+  return uniquePaths([
+    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"),
+    ...discoverSkillRoots({ cwd, home })
+  ]);
+}
+
+export function discoverSkillRoots({ cwd = process.cwd(), home = os.homedir() } = {}) {
+  const roots = [];
+  for (const base of [
+    path.join(home, ".gemini"),
+    path.join(home, ".codex"),
+    path.join(home, ".claude"),
+    path.join(cwd, ".gemini"),
+    path.join(cwd, ".codex"),
+    path.join(cwd, ".claude")
+  ]) {
+    findSkillRoots(base, 0, roots);
+  }
+  return uniquePaths(roots);
+}
+
+function findSkillRoots(directory, depth, roots) {
+  if (depth > 5) return;
+  let entries = [];
+  try {
+    entries = fs.readdirSync(directory, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  if (entries.some((entry) => entry.isFile() && entry.name === "SKILL.md")) {
+    roots.push(path.dirname(directory));
+    return;
+  }
+  for (const entry of entries) {
+    if (!entry.isDirectory() && !entry.isSymbolicLink()) continue;
+    if (entry.name === ".git" || entry.name === ".tmp" || entry.name === "node_modules") continue;
+    const fullPath = path.join(directory, entry.name);
+    if (entry.isSymbolicLink() && !safeStat(fullPath)?.isDirectory()) continue;
+    findSkillRoots(fullPath, depth + 1, roots);
+  }
+}
+
+function uniquePaths(paths) {
+  const seen = new Set();
+  const result = [];
+  for (const item of paths) {
+    const normalized = path.resolve(item);
+    if (seen.has(normalized)) continue;
+    seen.add(normalized);
+    result.push(item);
+  }
+  return result;
 }
 
 function countSkillFiles(root) {
@@ -158,6 +232,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 +340,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(","));