rulesync 7.13.0 → 7.15.0

package/dist/cli/index.js

@@ -50,8 +50,10 @@ import {
   findFilesByGlobs,
   formatError,
   generate,
+  getFileSize,
   getLocalSkillDirNames,
   importFromTool,
+  isSymlink,
   listDirectoryFiles,
   logger,
   readFileContent,
@@ -60,7 +62,7 @@ import {
   removeTempDirectory,
   stringifyFrontmatter,
   writeFileContent
-} from "../chunk-JGRHJWG5.js";
+} from "../chunk-L5AQUWUM.js";
 
 // src/cli/index.ts
 import { Command } from "commander";
@@ -1205,6 +1207,8 @@ var RULESYNC_IGNORE_ENTRIES = [
   // Junie
   "**/.junie/guidelines.md",
   "**/.junie/mcp.json",
+  "**/.junie/skills/",
+  "**/.junie/agents/",
   // Kilo Code
   "**/.kilocode/rules/",
   "**/.kilocode/skills/",
@@ -1609,12 +1613,175 @@ async function initCommand() {
 }
 
 // src/lib/sources.ts
-import { join as join5, resolve, sep } from "path";
+import { join as join6, resolve, sep } from "path";
 import { Semaphore as Semaphore2 } from "es-toolkit/promise";
 
+// src/lib/git-client.ts
+import { execFile } from "child_process";
+import { join as join4 } from "path";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
+var GIT_TIMEOUT_MS = 6e4;
+var ALLOWED_URL_SCHEMES = /^(https?:\/\/|ssh:\/\/|git:\/\/|file:\/\/\/|[a-zA-Z0-9_.+-]+@[a-zA-Z0-9.-]+:[a-zA-Z0-9_.+/~-]+)/;
+var INSECURE_URL_SCHEMES = /^(git:\/\/|http:\/\/)/;
+function findControlCharacter(value) {
+  for (let i = 0; i < value.length; i++) {
+    const code = value.charCodeAt(i);
+    if (code >= 0 && code <= 31 || code === 127) {
+      return { position: i, hex: `0x${code.toString(16).padStart(2, "0")}` };
+    }
+  }
+  return null;
+}
+var GitClientError = class extends Error {
+  constructor(message, cause) {
+    super(message, { cause });
+    this.name = "GitClientError";
+  }
+};
+function validateGitUrl(url) {
+  const ctrl = findControlCharacter(url);
+  if (ctrl) {
+    throw new GitClientError(
+      `Git URL contains control character ${ctrl.hex} at position ${ctrl.position}`
+    );
+  }
+  if (!ALLOWED_URL_SCHEMES.test(url)) {
+    throw new GitClientError(
+      `Unsupported or unsafe git URL: "${url}". Use https, ssh, git, or file schemes.`
+    );
+  }
+  if (INSECURE_URL_SCHEMES.test(url)) {
+    logger.warn(
+      `URL "${url}" uses an unencrypted protocol. Consider using https:// or ssh:// instead.`
+    );
+  }
+}
+function validateRef(ref) {
+  if (ref.startsWith("-")) {
+    throw new GitClientError(`Ref must not start with "-": "${ref}"`);
+  }
+  const ctrl = findControlCharacter(ref);
+  if (ctrl) {
+    throw new GitClientError(
+      `Ref contains control character ${ctrl.hex} at position ${ctrl.position}`
+    );
+  }
+}
+var gitChecked = false;
+async function checkGitAvailable() {
+  if (gitChecked) return;
+  try {
+    await execFileAsync("git", ["--version"], { timeout: GIT_TIMEOUT_MS });
+    gitChecked = true;
+  } catch {
+    throw new GitClientError("git is not installed or not found in PATH");
+  }
+}
+async function resolveDefaultRef(url) {
+  validateGitUrl(url);
+  await checkGitAvailable();
+  try {
+    const { stdout } = await execFileAsync("git", ["ls-remote", "--symref", "--", url, "HEAD"], {
+      timeout: GIT_TIMEOUT_MS
+    });
+    const ref = stdout.match(/^ref: refs\/heads\/(.+)\tHEAD$/m)?.[1];
+    const sha = stdout.match(/^([0-9a-f]{40})\tHEAD$/m)?.[1];
+    if (!ref || !sha) throw new GitClientError(`Could not parse default branch from: ${url}`);
+    return { ref, sha };
+  } catch (error) {
+    if (error instanceof GitClientError) throw error;
+    throw new GitClientError(`Failed to resolve default ref for ${url}`, error);
+  }
+}
+async function resolveRefToSha(url, ref) {
+  validateGitUrl(url);
+  validateRef(ref);
+  await checkGitAvailable();
+  try {
+    const { stdout } = await execFileAsync("git", ["ls-remote", "--", url, ref], {
+      timeout: GIT_TIMEOUT_MS
+    });
+    const sha = stdout.match(/^([0-9a-f]{40})\t/m)?.[1];
+    if (!sha) throw new GitClientError(`Ref "${ref}" not found in ${url}`);
+    return sha;
+  } catch (error) {
+    if (error instanceof GitClientError) throw error;
+    throw new GitClientError(`Failed to resolve ref "${ref}" for ${url}`, error);
+  }
+}
+async function fetchSkillFiles(params) {
+  const { url, ref, skillsPath } = params;
+  validateGitUrl(url);
+  validateRef(ref);
+  await checkGitAvailable();
+  const tmpDir = await createTempDirectory("rulesync-git-");
+  try {
+    await execFileAsync(
+      "git",
+      [
+        "clone",
+        "--depth",
+        "1",
+        "--branch",
+        ref,
+        "--no-checkout",
+        "--filter=blob:none",
+        "--",
+        url,
+        tmpDir
+      ],
+      { timeout: GIT_TIMEOUT_MS }
+    );
+    await execFileAsync("git", ["-C", tmpDir, "sparse-checkout", "set", "--", skillsPath], {
+      timeout: GIT_TIMEOUT_MS
+    });
+    await execFileAsync("git", ["-C", tmpDir, "checkout"], { timeout: GIT_TIMEOUT_MS });
+    const skillsDir = join4(tmpDir, skillsPath);
+    if (!await directoryExists(skillsDir)) return [];
+    return await walkDirectory(skillsDir, skillsDir);
+  } catch (error) {
+    if (error instanceof GitClientError) throw error;
+    throw new GitClientError(`Failed to fetch skill files from ${url}`, error);
+  } finally {
+    await removeTempDirectory(tmpDir);
+  }
+}
+var MAX_WALK_DEPTH = 20;
+async function walkDirectory(dir, baseDir, depth = 0) {
+  if (depth > MAX_WALK_DEPTH) {
+    throw new GitClientError(
+      `Directory tree exceeds max depth of ${MAX_WALK_DEPTH}: "${dir}". Aborting to prevent resource exhaustion.`
+    );
+  }
+  const results = [];
+  for (const name of await listDirectoryFiles(dir)) {
+    if (name === ".git") continue;
+    const fullPath = join4(dir, name);
+    if (await isSymlink(fullPath)) {
+      logger.warn(`Skipping symlink "${fullPath}".`);
+      continue;
+    }
+    if (await directoryExists(fullPath)) {
+      results.push(...await walkDirectory(fullPath, baseDir, depth + 1));
+    } else {
+      const size = await getFileSize(fullPath);
+      if (size > MAX_FILE_SIZE) {
+        logger.warn(
+          `Skipping file "${fullPath}" (${(size / 1024 / 1024).toFixed(2)}MB exceeds ${MAX_FILE_SIZE / 1024 / 1024}MB limit).`
+        );
+        continue;
+      }
+      const content = await readFileContent(fullPath);
+      results.push({ relativePath: fullPath.substring(baseDir.length + 1), content, size });
+    }
+  }
+  return results;
+}
+
 // src/lib/sources-lock.ts
 import { createHash } from "crypto";
-import { join as join4 } from "path";
+import { join as join5 } from "path";
 import { optional, z as z4 } from "zod/mini";
 var LOCKFILE_VERSION = 1;
 var LockedSkillSchema = z4.object({
@@ -1658,7 +1825,7 @@ function createEmptyLock() {
   return { lockfileVersion: LOCKFILE_VERSION, sources: {} };
 }
 async function readLockFile(params) {
-  const lockPath = join4(params.baseDir, RULESYNC_SOURCES_LOCK_RELATIVE_FILE_PATH);
+  const lockPath = join5(params.baseDir, RULESYNC_SOURCES_LOCK_RELATIVE_FILE_PATH);
   if (!await fileExists(lockPath)) {
     logger.debug("No sources lockfile found, starting fresh.");
     return createEmptyLock();
@@ -1686,7 +1853,7 @@ async function readLockFile(params) {
   }
 }
 async function writeLockFile(params) {
-  const lockPath = join4(params.baseDir, RULESYNC_SOURCES_LOCK_RELATIVE_FILE_PATH);
+  const lockPath = join5(params.baseDir, RULESYNC_SOURCES_LOCK_RELATIVE_FILE_PATH);
   const content = JSON.stringify(params.lock, null, 2) + "\n";
   await writeFileContent(lockPath, content);
   logger.debug(`Wrote sources lockfile to ${lockPath}`);
@@ -1792,15 +1959,30 @@ async function resolveAndFetchSources(params) {
   const allFetchedSkillNames = /* @__PURE__ */ new Set();
   for (const sourceEntry of sources) {
     try {
-      const { skillCount, fetchedSkillNames, updatedLock } = await fetchSource({
-        sourceEntry,
-        client,
-        baseDir,
-        lock,
-        localSkillNames,
-        alreadyFetchedSkillNames: allFetchedSkillNames,
-        updateSources: options.updateSources ?? false
-      });
+      const transport = sourceEntry.transport ?? "github";
+      let result;
+      if (transport === "git") {
+        result = await fetchSourceViaGit({
+          sourceEntry,
+          baseDir,
+          lock,
+          localSkillNames,
+          alreadyFetchedSkillNames: allFetchedSkillNames,
+          updateSources: options.updateSources ?? false,
+          frozen: options.frozen ?? false
+        });
+      } else {
+        result = await fetchSource({
+          sourceEntry,
+          client,
+          baseDir,
+          lock,
+          localSkillNames,
+          alreadyFetchedSkillNames: allFetchedSkillNames,
+          updateSources: options.updateSources ?? false
+        });
+      }
+      const { skillCount, fetchedSkillNames, updatedLock } = result;
       lock = updatedLock;
       totalSkillCount += skillCount;
       for (const name of fetchedSkillNames) {
@@ -1833,7 +2015,7 @@ async function resolveAndFetchSources(params) {
 async function checkLockedSkillsExist(curatedDir, skillNames) {
   if (skillNames.length === 0) return true;
   for (const name of skillNames) {
-    if (!await directoryExists(join5(curatedDir, name))) {
+    if (!await directoryExists(join6(curatedDir, name))) {
       return false;
     }
   }
@@ -1864,7 +2046,7 @@ async function fetchSource(params) {
     ref = resolvedSha;
     logger.debug(`Resolved ${sourceKey} ref "${requestedRef}" to SHA: ${resolvedSha}`);
   }
-  const curatedDir = join5(baseDir, RULESYNC_CURATED_SKILLS_RELATIVE_DIR_PATH);
+  const curatedDir = join6(baseDir, RULESYNC_CURATED_SKILLS_RELATIVE_DIR_PATH);
   if (locked && resolvedSha === locked.resolvedRef && !updateSources) {
     const allExist = await checkLockedSkillsExist(curatedDir, lockedSkillNames);
     if (allExist) {
@@ -1896,7 +2078,7 @@ async function fetchSource(params) {
   if (locked) {
     const resolvedCuratedDir = resolve(curatedDir);
     for (const prevSkill of lockedSkillNames) {
-      const prevDir = join5(curatedDir, prevSkill);
+      const prevDir = join6(curatedDir, prevSkill);
       if (!resolve(prevDir).startsWith(resolvedCuratedDir + sep)) {
         logger.warn(
           `Skipping removal of "${prevSkill}": resolved path is outside the curated directory.`
@@ -1947,10 +2129,10 @@ async function fetchSource(params) {
     const skillFiles = [];
     for (const file of files) {
       const relativeToSkill = file.path.substring(skillDir.path.length + 1);
-      const localFilePath = join5(curatedDir, skillDir.name, relativeToSkill);
+      const localFilePath = join6(curatedDir, skillDir.name, relativeToSkill);
       checkPathTraversal({
         relativePath: relativeToSkill,
-        intendedRootDir: join5(curatedDir, skillDir.name)
+        intendedRootDir: join6(curatedDir, skillDir.name)
       });
       const content = await withSemaphore(
         semaphore,
@@ -1993,6 +2175,127 @@ async function fetchSource(params) {
     updatedLock: lock
   };
 }
+async function fetchSourceViaGit(params) {
+  const { sourceEntry, baseDir, localSkillNames, alreadyFetchedSkillNames, updateSources, frozen } = params;
+  let { lock } = params;
+  const url = sourceEntry.source;
+  const locked = getLockedSource(lock, url);
+  const lockedSkillNames = locked ? getLockedSkillNames(locked) : [];
+  let resolvedSha;
+  let requestedRef;
+  if (locked && !updateSources) {
+    resolvedSha = locked.resolvedRef;
+    requestedRef = locked.requestedRef;
+    if (requestedRef) {
+      validateRef(requestedRef);
+    }
+  } else if (sourceEntry.ref) {
+    requestedRef = sourceEntry.ref;
+    resolvedSha = await resolveRefToSha(url, requestedRef);
+  } else {
+    const def = await resolveDefaultRef(url);
+    requestedRef = def.ref;
+    resolvedSha = def.sha;
+  }
+  const curatedDir = join6(baseDir, RULESYNC_CURATED_SKILLS_RELATIVE_DIR_PATH);
+  if (locked && resolvedSha === locked.resolvedRef && !updateSources) {
+    if (await checkLockedSkillsExist(curatedDir, lockedSkillNames)) {
+      return { skillCount: 0, fetchedSkillNames: lockedSkillNames, updatedLock: lock };
+    }
+  }
+  if (!requestedRef) {
+    if (frozen) {
+      throw new Error(
+        `Frozen install failed: lockfile entry for "${url}" is missing requestedRef. Run 'rulesync install' to update the lockfile.`
+      );
+    }
+    const def = await resolveDefaultRef(url);
+    requestedRef = def.ref;
+    resolvedSha = def.sha;
+  }
+  const skillFilter = sourceEntry.skills ?? ["*"];
+  const isWildcard = skillFilter.length === 1 && skillFilter[0] === "*";
+  const remoteFiles = await fetchSkillFiles({
+    url,
+    ref: requestedRef,
+    skillsPath: sourceEntry.path ?? "skills"
+  });
+  const skillFileMap = /* @__PURE__ */ new Map();
+  for (const file of remoteFiles) {
+    const idx = file.relativePath.indexOf("/");
+    if (idx === -1) continue;
+    const name = file.relativePath.substring(0, idx);
+    const inner = file.relativePath.substring(idx + 1);
+    const arr = skillFileMap.get(name) ?? [];
+    arr.push({ relativePath: inner, content: file.content });
+    skillFileMap.set(name, arr);
+  }
+  const allNames = [...skillFileMap.keys()];
+  const filteredNames = isWildcard ? allNames : allNames.filter((n) => skillFilter.includes(n));
+  if (locked) {
+    const base = resolve(curatedDir);
+    for (const prev of lockedSkillNames) {
+      const dir = join6(curatedDir, prev);
+      if (resolve(dir).startsWith(base + sep) && await directoryExists(dir)) {
+        await removeDirectory(dir);
+      }
+    }
+  }
+  const fetchedSkills = {};
+  for (const skillName of filteredNames) {
+    if (skillName.includes("..") || skillName.includes("/") || skillName.includes("\\")) {
+      logger.warn(
+        `Skipping skill with invalid name "${skillName}" from ${url}: contains path traversal characters.`
+      );
+      continue;
+    }
+    if (localSkillNames.has(skillName)) {
+      logger.debug(
+        `Skipping remote skill "${skillName}" from ${url}: local skill takes precedence.`
+      );
+      continue;
+    }
+    if (alreadyFetchedSkillNames.has(skillName)) {
+      logger.warn(
+        `Skipping duplicate skill "${skillName}" from ${url}: already fetched from another source.`
+      );
+      continue;
+    }
+    const files = skillFileMap.get(skillName) ?? [];
+    const written = [];
+    for (const file of files) {
+      checkPathTraversal({
+        relativePath: file.relativePath,
+        intendedRootDir: join6(curatedDir, skillName)
+      });
+      await writeFileContent(join6(curatedDir, skillName, file.relativePath), file.content);
+      written.push({ path: file.relativePath, content: file.content });
+    }
+    const integrity = computeSkillIntegrity(written);
+    const lockedSkillEntry = locked?.skills[skillName];
+    if (lockedSkillEntry?.integrity && lockedSkillEntry.integrity !== integrity && resolvedSha === locked?.resolvedRef) {
+      logger.warn(`Integrity mismatch for skill "${skillName}" from ${url}.`);
+    }
+    fetchedSkills[skillName] = { integrity };
+  }
+  const fetchedNames = Object.keys(fetchedSkills);
+  const mergedSkills = { ...fetchedSkills };
+  if (locked) {
+    for (const [k, v] of Object.entries(locked.skills)) {
+      if (!(k in mergedSkills)) mergedSkills[k] = v;
+    }
+  }
+  lock = setLockedSource(lock, url, {
+    requestedRef,
+    resolvedRef: resolvedSha,
+    resolvedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    skills: mergedSkills
+  });
+  logger.info(
+    `Fetched ${fetchedNames.length} skill(s) from ${url}: ${fetchedNames.join(", ") || "(none)"}`
+  );
+  return { skillCount: fetchedNames.length, fetchedSkillNames: fetchedNames, updatedLock: lock };
+}
 
 // src/cli/commands/install.ts
 async function installCommand(options) {
@@ -2036,12 +2339,12 @@ import { FastMCP } from "fastmcp";
 import { z as z13 } from "zod/mini";
 
 // src/mcp/commands.ts
-import { basename, join as join6 } from "path";
+import { basename, join as join7 } from "path";
 import { z as z5 } from "zod/mini";
 var maxCommandSizeBytes = 1024 * 1024;
 var maxCommandsCount = 1e3;
 async function listCommands() {
-  const commandsDir = join6(process.cwd(), RULESYNC_COMMANDS_RELATIVE_DIR_PATH);
+  const commandsDir = join7(process.cwd(), RULESYNC_COMMANDS_RELATIVE_DIR_PATH);
   try {
     const files = await listDirectoryFiles(commandsDir);
     const mdFiles = files.filter((file) => file.endsWith(".md"));
@@ -2057,7 +2360,7 @@ async function listCommands() {
           });
           const frontmatter = command.getFrontmatter();
           return {
-            relativePathFromCwd: join6(RULESYNC_COMMANDS_RELATIVE_DIR_PATH, file),
+            relativePathFromCwd: join7(RULESYNC_COMMANDS_RELATIVE_DIR_PATH, file),
             frontmatter
           };
         } catch (error) {
@@ -2085,7 +2388,7 @@ async function getCommand({ relativePathFromCwd }) {
       relativeFilePath: filename
     });
     return {
-      relativePathFromCwd: join6(RULESYNC_COMMANDS_RELATIVE_DIR_PATH, filename),
+      relativePathFromCwd: join7(RULESYNC_COMMANDS_RELATIVE_DIR_PATH, filename),
       frontmatter: command.getFrontmatter(),
       body: command.getBody()
     };
@@ -2114,7 +2417,7 @@ async function putCommand({
   try {
     const existingCommands = await listCommands();
     const isUpdate = existingCommands.some(
-      (command2) => command2.relativePathFromCwd === join6(RULESYNC_COMMANDS_RELATIVE_DIR_PATH, filename)
+      (command2) => command2.relativePathFromCwd === join7(RULESYNC_COMMANDS_RELATIVE_DIR_PATH, filename)
     );
     if (!isUpdate && existingCommands.length >= maxCommandsCount) {
       throw new Error(
@@ -2131,11 +2434,11 @@ async function putCommand({
       fileContent,
       validate: true
     });
-    const commandsDir = join6(process.cwd(), RULESYNC_COMMANDS_RELATIVE_DIR_PATH);
+    const commandsDir = join7(process.cwd(), RULESYNC_COMMANDS_RELATIVE_DIR_PATH);
     await ensureDir(commandsDir);
     await writeFileContent(command.getFilePath(), command.getFileContent());
     return {
-      relativePathFromCwd: join6(RULESYNC_COMMANDS_RELATIVE_DIR_PATH, filename),
+      relativePathFromCwd: join7(RULESYNC_COMMANDS_RELATIVE_DIR_PATH, filename),
       frontmatter: command.getFrontmatter(),
       body: command.getBody()
     };
@@ -2151,11 +2454,11 @@ async function deleteCommand({ relativePathFromCwd }) {
     intendedRootDir: process.cwd()
   });
   const filename = basename(relativePathFromCwd);
-  const fullPath = join6(process.cwd(), RULESYNC_COMMANDS_RELATIVE_DIR_PATH, filename);
+  const fullPath = join7(process.cwd(), RULESYNC_COMMANDS_RELATIVE_DIR_PATH, filename);
   try {
     await removeFile(fullPath);
     return {
-      relativePathFromCwd: join6(RULESYNC_COMMANDS_RELATIVE_DIR_PATH, filename)
+      relativePathFromCwd: join7(RULESYNC_COMMANDS_RELATIVE_DIR_PATH, filename)
     };
   } catch (error) {
     throw new Error(`Failed to delete command file ${relativePathFromCwd}: ${formatError(error)}`, {
@@ -2180,7 +2483,7 @@ var commandToolSchemas = {
 var commandTools = {
   listCommands: {
     name: "listCommands",
-    description: `List all commands from ${join6(RULESYNC_COMMANDS_RELATIVE_DIR_PATH, "*.md")} with their frontmatter.`,
+    description: `List all commands from ${join7(RULESYNC_COMMANDS_RELATIVE_DIR_PATH, "*.md")} with their frontmatter.`,
     parameters: commandToolSchemas.listCommands,
     execute: async () => {
       const commands = await listCommands();
@@ -2307,11 +2610,11 @@ var generateTools = {
 };
 
 // src/mcp/ignore.ts
-import { join as join7 } from "path";
+import { join as join8 } from "path";
 import { z as z7 } from "zod/mini";
 var maxIgnoreFileSizeBytes = 100 * 1024;
 async function getIgnoreFile() {
-  const ignoreFilePath = join7(process.cwd(), RULESYNC_AIIGNORE_RELATIVE_FILE_PATH);
+  const ignoreFilePath = join8(process.cwd(), RULESYNC_AIIGNORE_RELATIVE_FILE_PATH);
   try {
     const content = await readFileContent(ignoreFilePath);
     return {
@@ -2328,7 +2631,7 @@ async function getIgnoreFile() {
   }
 }
 async function putIgnoreFile({ content }) {
-  const ignoreFilePath = join7(process.cwd(), RULESYNC_AIIGNORE_RELATIVE_FILE_PATH);
+  const ignoreFilePath = join8(process.cwd(), RULESYNC_AIIGNORE_RELATIVE_FILE_PATH);
   const contentSizeBytes = Buffer.byteLength(content, "utf8");
   if (contentSizeBytes > maxIgnoreFileSizeBytes) {
     throw new Error(
@@ -2352,8 +2655,8 @@ async function putIgnoreFile({ content }) {
   }
 }
 async function deleteIgnoreFile() {
-  const aiignorePath = join7(process.cwd(), RULESYNC_AIIGNORE_RELATIVE_FILE_PATH);
-  const legacyIgnorePath = join7(process.cwd(), RULESYNC_IGNORE_RELATIVE_FILE_PATH);
+  const aiignorePath = join8(process.cwd(), RULESYNC_AIIGNORE_RELATIVE_FILE_PATH);
+  const legacyIgnorePath = join8(process.cwd(), RULESYNC_IGNORE_RELATIVE_FILE_PATH);
   try {
     await Promise.all([removeFile(aiignorePath), removeFile(legacyIgnorePath)]);
     return {
@@ -2481,7 +2784,7 @@ var importTools = {
 };
 
 // src/mcp/mcp.ts
-import { join as join8 } from "path";
+import { join as join9 } from "path";
 import { z as z9 } from "zod/mini";
 var maxMcpSizeBytes = 1024 * 1024;
 async function getMcpFile() {
@@ -2489,7 +2792,7 @@ async function getMcpFile() {
     const rulesyncMcp = await RulesyncMcp.fromFile({
       validate: true
     });
-    const relativePathFromCwd = join8(
+    const relativePathFromCwd = join9(
       rulesyncMcp.getRelativeDirPath(),
       rulesyncMcp.getRelativeFilePath()
     );
@@ -2527,7 +2830,7 @@ async function putMcpFile({ content }) {
     const paths = RulesyncMcp.getSettablePaths();
     const relativeDirPath = paths.recommended.relativeDirPath;
     const relativeFilePath = paths.recommended.relativeFilePath;
-    const fullPath = join8(baseDir, relativeDirPath, relativeFilePath);
+    const fullPath = join9(baseDir, relativeDirPath, relativeFilePath);
     const rulesyncMcp = new RulesyncMcp({
       baseDir,
       relativeDirPath,
@@ -2535,9 +2838,9 @@ async function putMcpFile({ content }) {
       fileContent: content,
       validate: true
     });
-    await ensureDir(join8(baseDir, relativeDirPath));
+    await ensureDir(join9(baseDir, relativeDirPath));
     await writeFileContent(fullPath, content);
-    const relativePathFromCwd = join8(relativeDirPath, relativeFilePath);
+    const relativePathFromCwd = join9(relativeDirPath, relativeFilePath);
     return {
       relativePathFromCwd,
       content: rulesyncMcp.getFileContent()
@@ -2555,15 +2858,15 @@ async function deleteMcpFile() {
   try {
     const baseDir = process.cwd();
     const paths = RulesyncMcp.getSettablePaths();
-    const recommendedPath = join8(
+    const recommendedPath = join9(
       baseDir,
       paths.recommended.relativeDirPath,
       paths.recommended.relativeFilePath
     );
-    const legacyPath = join8(baseDir, paths.legacy.relativeDirPath, paths.legacy.relativeFilePath);
+    const legacyPath = join9(baseDir, paths.legacy.relativeDirPath, paths.legacy.relativeFilePath);
     await removeFile(recommendedPath);
     await removeFile(legacyPath);
-    const relativePathFromCwd = join8(
+    const relativePathFromCwd = join9(
       paths.recommended.relativeDirPath,
       paths.recommended.relativeFilePath
     );
@@ -2617,12 +2920,12 @@ var mcpTools = {
 };
 
 // src/mcp/rules.ts
-import { basename as basename2, join as join9 } from "path";
+import { basename as basename2, join as join10 } from "path";
 import { z as z10 } from "zod/mini";
 var maxRuleSizeBytes = 1024 * 1024;
 var maxRulesCount = 1e3;
 async function listRules() {
-  const rulesDir = join9(process.cwd(), RULESYNC_RULES_RELATIVE_DIR_PATH);
+  const rulesDir = join10(process.cwd(), RULESYNC_RULES_RELATIVE_DIR_PATH);
   try {
     const files = await listDirectoryFiles(rulesDir);
     const mdFiles = files.filter((file) => file.endsWith(".md"));
@@ -2635,7 +2938,7 @@ async function listRules() {
           });
           const frontmatter = rule.getFrontmatter();
           return {
-            relativePathFromCwd: join9(RULESYNC_RULES_RELATIVE_DIR_PATH, file),
+            relativePathFromCwd: join10(RULESYNC_RULES_RELATIVE_DIR_PATH, file),
             frontmatter
           };
         } catch (error) {
@@ -2664,7 +2967,7 @@ async function getRule({ relativePathFromCwd }) {
       validate: true
     });
     return {
-      relativePathFromCwd: join9(RULESYNC_RULES_RELATIVE_DIR_PATH, filename),
+      relativePathFromCwd: join10(RULESYNC_RULES_RELATIVE_DIR_PATH, filename),
       frontmatter: rule.getFrontmatter(),
       body: rule.getBody()
     };
@@ -2693,7 +2996,7 @@ async function putRule({
   try {
     const existingRules = await listRules();
     const isUpdate = existingRules.some(
-      (rule2) => rule2.relativePathFromCwd === join9(RULESYNC_RULES_RELATIVE_DIR_PATH, filename)
+      (rule2) => rule2.relativePathFromCwd === join10(RULESYNC_RULES_RELATIVE_DIR_PATH, filename)
     );
     if (!isUpdate && existingRules.length >= maxRulesCount) {
       throw new Error(
@@ -2708,11 +3011,11 @@ async function putRule({
       body,
       validate: true
     });
-    const rulesDir = join9(process.cwd(), RULESYNC_RULES_RELATIVE_DIR_PATH);
+    const rulesDir = join10(process.cwd(), RULESYNC_RULES_RELATIVE_DIR_PATH);
     await ensureDir(rulesDir);
     await writeFileContent(rule.getFilePath(), rule.getFileContent());
     return {
-      relativePathFromCwd: join9(RULESYNC_RULES_RELATIVE_DIR_PATH, filename),
+      relativePathFromCwd: join10(RULESYNC_RULES_RELATIVE_DIR_PATH, filename),
       frontmatter: rule.getFrontmatter(),
       body: rule.getBody()
     };
@@ -2728,11 +3031,11 @@ async function deleteRule({ relativePathFromCwd }) {
     intendedRootDir: process.cwd()
   });
   const filename = basename2(relativePathFromCwd);
-  const fullPath = join9(process.cwd(), RULESYNC_RULES_RELATIVE_DIR_PATH, filename);
+  const fullPath = join10(process.cwd(), RULESYNC_RULES_RELATIVE_DIR_PATH, filename);
   try {
     await removeFile(fullPath);
     return {
-      relativePathFromCwd: join9(RULESYNC_RULES_RELATIVE_DIR_PATH, filename)
+      relativePathFromCwd: join10(RULESYNC_RULES_RELATIVE_DIR_PATH, filename)
     };
   } catch (error) {
     throw new Error(`Failed to delete rule file ${relativePathFromCwd}: ${formatError(error)}`, {
@@ -2757,7 +3060,7 @@ var ruleToolSchemas = {
 var ruleTools = {
   listRules: {
     name: "listRules",
-    description: `List all rules from ${join9(RULESYNC_RULES_RELATIVE_DIR_PATH, "*.md")} with their frontmatter.`,
+    description: `List all rules from ${join10(RULESYNC_RULES_RELATIVE_DIR_PATH, "*.md")} with their frontmatter.`,
     parameters: ruleToolSchemas.listRules,
     execute: async () => {
       const rules = await listRules();
@@ -2799,7 +3102,7 @@ var ruleTools = {
 };
 
 // src/mcp/skills.ts
-import { basename as basename3, dirname, join as join10 } from "path";
+import { basename as basename3, dirname, join as join11 } from "path";
 import { z as z11 } from "zod/mini";
 var maxSkillSizeBytes = 1024 * 1024;
 var maxSkillsCount = 1e3;
@@ -2823,9 +3126,9 @@ function extractDirName(relativeDirPathFromCwd) {
   return dirName;
 }
 async function listSkills() {
-  const skillsDir = join10(process.cwd(), RULESYNC_SKILLS_RELATIVE_DIR_PATH);
+  const skillsDir = join11(process.cwd(), RULESYNC_SKILLS_RELATIVE_DIR_PATH);
   try {
-    const skillDirPaths = await findFilesByGlobs(join10(skillsDir, "*"), { type: "dir" });
+    const skillDirPaths = await findFilesByGlobs(join11(skillsDir, "*"), { type: "dir" });
     const skills = await Promise.all(
       skillDirPaths.map(async (dirPath) => {
         const dirName = basename3(dirPath);
@@ -2836,7 +3139,7 @@ async function listSkills() {
           });
           const frontmatter = skill.getFrontmatter();
           return {
-            relativeDirPathFromCwd: join10(RULESYNC_SKILLS_RELATIVE_DIR_PATH, dirName),
+            relativeDirPathFromCwd: join11(RULESYNC_SKILLS_RELATIVE_DIR_PATH, dirName),
             frontmatter
           };
         } catch (error) {
@@ -2864,7 +3167,7 @@ async function getSkill({ relativeDirPathFromCwd }) {
       dirName
     });
     return {
-      relativeDirPathFromCwd: join10(RULESYNC_SKILLS_RELATIVE_DIR_PATH, dirName),
+      relativeDirPathFromCwd: join11(RULESYNC_SKILLS_RELATIVE_DIR_PATH, dirName),
       frontmatter: skill.getFrontmatter(),
       body: skill.getBody(),
       otherFiles: skill.getOtherFiles().map(aiDirFileToMcpSkillFile)
@@ -2898,7 +3201,7 @@ async function putSkill({
   try {
     const existingSkills = await listSkills();
     const isUpdate = existingSkills.some(
-      (skill2) => skill2.relativeDirPathFromCwd === join10(RULESYNC_SKILLS_RELATIVE_DIR_PATH, dirName)
+      (skill2) => skill2.relativeDirPathFromCwd === join11(RULESYNC_SKILLS_RELATIVE_DIR_PATH, dirName)
     );
     if (!isUpdate && existingSkills.length >= maxSkillsCount) {
       throw new Error(
@@ -2915,9 +3218,9 @@ async function putSkill({
       otherFiles: aiDirFiles,
       validate: true
     });
-    const skillDirPath = join10(process.cwd(), RULESYNC_SKILLS_RELATIVE_DIR_PATH, dirName);
+    const skillDirPath = join11(process.cwd(), RULESYNC_SKILLS_RELATIVE_DIR_PATH, dirName);
     await ensureDir(skillDirPath);
-    const skillFilePath = join10(skillDirPath, SKILL_FILE_NAME);
+    const skillFilePath = join11(skillDirPath, SKILL_FILE_NAME);
     const skillFileContent = stringifyFrontmatter(body, frontmatter);
     await writeFileContent(skillFilePath, skillFileContent);
     for (const file of otherFiles) {
@@ -2925,15 +3228,15 @@ async function putSkill({
         relativePath: file.name,
         intendedRootDir: skillDirPath
       });
-      const filePath = join10(skillDirPath, file.name);
-      const fileDir = join10(skillDirPath, dirname(file.name));
+      const filePath = join11(skillDirPath, file.name);
+      const fileDir = join11(skillDirPath, dirname(file.name));
       if (fileDir !== skillDirPath) {
         await ensureDir(fileDir);
       }
       await writeFileContent(filePath, file.body);
     }
     return {
-      relativeDirPathFromCwd: join10(RULESYNC_SKILLS_RELATIVE_DIR_PATH, dirName),
+      relativeDirPathFromCwd: join11(RULESYNC_SKILLS_RELATIVE_DIR_PATH, dirName),
       frontmatter: skill.getFrontmatter(),
       body: skill.getBody(),
       otherFiles: skill.getOtherFiles().map(aiDirFileToMcpSkillFile)
@@ -2955,13 +3258,13 @@ async function deleteSkill({
     intendedRootDir: process.cwd()
   });
   const dirName = extractDirName(relativeDirPathFromCwd);
-  const skillDirPath = join10(process.cwd(), RULESYNC_SKILLS_RELATIVE_DIR_PATH, dirName);
+  const skillDirPath = join11(process.cwd(), RULESYNC_SKILLS_RELATIVE_DIR_PATH, dirName);
   try {
     if (await directoryExists(skillDirPath)) {
       await removeDirectory(skillDirPath);
     }
     return {
-      relativeDirPathFromCwd: join10(RULESYNC_SKILLS_RELATIVE_DIR_PATH, dirName)
+      relativeDirPathFromCwd: join11(RULESYNC_SKILLS_RELATIVE_DIR_PATH, dirName)
     };
   } catch (error) {
     throw new Error(
@@ -2994,7 +3297,7 @@ var skillToolSchemas = {
 var skillTools = {
   listSkills: {
     name: "listSkills",
-    description: `List all skills from ${join10(RULESYNC_SKILLS_RELATIVE_DIR_PATH, "*", SKILL_FILE_NAME)} with their frontmatter.`,
+    description: `List all skills from ${join11(RULESYNC_SKILLS_RELATIVE_DIR_PATH, "*", SKILL_FILE_NAME)} with their frontmatter.`,
     parameters: skillToolSchemas.listSkills,
     execute: async () => {
       const skills = await listSkills();
@@ -3037,12 +3340,12 @@ var skillTools = {
 };
 
 // src/mcp/subagents.ts
-import { basename as basename4, join as join11 } from "path";
+import { basename as basename4, join as join12 } from "path";
 import { z as z12 } from "zod/mini";
 var maxSubagentSizeBytes = 1024 * 1024;
 var maxSubagentsCount = 1e3;
 async function listSubagents() {
-  const subagentsDir = join11(process.cwd(), RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH);
+  const subagentsDir = join12(process.cwd(), RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH);
   try {
     const files = await listDirectoryFiles(subagentsDir);
     const mdFiles = files.filter((file) => file.endsWith(".md"));
@@ -3055,7 +3358,7 @@ async function listSubagents() {
           });
           const frontmatter = subagent.getFrontmatter();
           return {
-            relativePathFromCwd: join11(RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, file),
+            relativePathFromCwd: join12(RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, file),
             frontmatter
           };
         } catch (error) {
@@ -3086,7 +3389,7 @@ async function getSubagent({ relativePathFromCwd }) {
       validate: true
     });
     return {
-      relativePathFromCwd: join11(RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, filename),
+      relativePathFromCwd: join12(RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, filename),
       frontmatter: subagent.getFrontmatter(),
       body: subagent.getBody()
     };
@@ -3115,7 +3418,7 @@ async function putSubagent({
   try {
     const existingSubagents = await listSubagents();
     const isUpdate = existingSubagents.some(
-      (subagent2) => subagent2.relativePathFromCwd === join11(RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, filename)
+      (subagent2) => subagent2.relativePathFromCwd === join12(RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, filename)
     );
     if (!isUpdate && existingSubagents.length >= maxSubagentsCount) {
       throw new Error(
@@ -3130,11 +3433,11 @@ async function putSubagent({
       body,
       validate: true
     });
-    const subagentsDir = join11(process.cwd(), RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH);
+    const subagentsDir = join12(process.cwd(), RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH);
     await ensureDir(subagentsDir);
     await writeFileContent(subagent.getFilePath(), subagent.getFileContent());
     return {
-      relativePathFromCwd: join11(RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, filename),
+      relativePathFromCwd: join12(RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, filename),
       frontmatter: subagent.getFrontmatter(),
       body: subagent.getBody()
     };
@@ -3150,11 +3453,11 @@ async function deleteSubagent({ relativePathFromCwd }) {
     intendedRootDir: process.cwd()
   });
   const filename = basename4(relativePathFromCwd);
-  const fullPath = join11(process.cwd(), RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, filename);
+  const fullPath = join12(process.cwd(), RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, filename);
   try {
     await removeFile(fullPath);
     return {
-      relativePathFromCwd: join11(RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, filename)
+      relativePathFromCwd: join12(RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, filename)
     };
   } catch (error) {
     throw new Error(
@@ -3182,7 +3485,7 @@ var subagentToolSchemas = {
 var subagentTools = {
   listSubagents: {
     name: "listSubagents",
-    description: `List all subagents from ${join11(RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, "*.md")} with their frontmatter.`,
+    description: `List all subagents from ${join12(RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, "*.md")} with their frontmatter.`,
     parameters: subagentToolSchemas.listSubagents,
     execute: async () => {
       const subagents = await listSubagents();
@@ -3807,7 +4110,7 @@ async function updateCommand(currentVersion, options) {
 }
 
 // src/cli/index.ts
-var getVersion = () => "7.13.0";
+var getVersion = () => "7.15.0";
 var main = async () => {
   const program = new Command();
   const version = getVersion();