rulesync 7.15.2 → 7.16.0

package/dist/cli/index.cjs

@@ -408,6 +408,7 @@ var import_node_path5 = require("path");
 
 // src/utils/frontmatter.ts
 var import_gray_matter = __toESM(require("gray-matter"), 1);
+var import_js_yaml = require("js-yaml");
 function isPlainObject(value) {
   if (value === null || typeof value !== "object") return false;
   const prototype = Object.getPrototypeOf(value);
@@ -446,8 +447,55 @@ function deepRemoveNullishObject(obj) {
   }
   return result;
 }
-function stringifyFrontmatter(body, frontmatter) {
-  const cleanFrontmatter = deepRemoveNullishObject(frontmatter);
+function deepFlattenStringsValue(value) {
+  if (value === null || value === void 0) {
+    return void 0;
+  }
+  if (typeof value === "string") {
+    return value.replace(/\n+/g, " ").trim();
+  }
+  if (Array.isArray(value)) {
+    const cleanedArray = value.map((item) => deepFlattenStringsValue(item)).filter((item) => item !== void 0);
+    return cleanedArray;
+  }
+  if (isPlainObject(value)) {
+    const result = {};
+    for (const [key, val] of Object.entries(value)) {
+      const cleaned = deepFlattenStringsValue(val);
+      if (cleaned !== void 0) {
+        result[key] = cleaned;
+      }
+    }
+    return result;
+  }
+  return value;
+}
+function deepFlattenStringsObject(obj) {
+  if (!obj || typeof obj !== "object") {
+    return {};
+  }
+  const result = {};
+  for (const [key, val] of Object.entries(obj)) {
+    const cleaned = deepFlattenStringsValue(val);
+    if (cleaned !== void 0) {
+      result[key] = cleaned;
+    }
+  }
+  return result;
+}
+function stringifyFrontmatter(body, frontmatter, options) {
+  const { avoidBlockScalars = false } = options ?? {};
+  const cleanFrontmatter = avoidBlockScalars ? deepFlattenStringsObject(frontmatter) : deepRemoveNullishObject(frontmatter);
+  if (avoidBlockScalars) {
+    return import_gray_matter.default.stringify(body, cleanFrontmatter, {
+      engines: {
+        yaml: {
+          parse: (input) => (0, import_js_yaml.load)(input) ?? {},
+          stringify: (data) => (0, import_js_yaml.dump)(data, { lineWidth: -1 })
+        }
+      }
+    });
+  }
   return import_gray_matter.default.stringify(body, cleanFrontmatter);
 }
 function parseFrontmatter(content, filePath) {
@@ -1599,7 +1647,7 @@ var CursorCommand = class _CursorCommand extends ToolCommand {
     }
     super({
       ...rest,
-      fileContent: stringifyFrontmatter(body, frontmatter)
+      fileContent: stringifyFrontmatter(body, frontmatter, { avoidBlockScalars: true })
     });
     this.frontmatter = frontmatter;
     this.body = body;
@@ -6025,12 +6073,26 @@ var CursorMcp = class _CursorMcp extends ToolMcp {
   json;
   constructor(params) {
     super(params);
-    this.json = this.fileContent !== void 0 ? JSON.parse(this.fileContent) : {};
+    if (this.fileContent !== void 0) {
+      try {
+        this.json = JSON.parse(this.fileContent);
+      } catch (error) {
+        throw new Error(
+          `Failed to parse Cursor MCP config at ${(0, import_node_path46.join)(this.relativeDirPath, this.relativeFilePath)}: ${formatError(error)}`,
+          { cause: error }
+        );
+      }
+    } else {
+      this.json = {};
+    }
   }
   getJson() {
     return this.json;
   }
-  static getSettablePaths() {
+  isDeletable() {
+    return !this.global;
+  }
+  static getSettablePaths(_options) {
     return {
       relativeDirPath: ".cursor",
       relativeFilePath: "mcp.json"
@@ -6038,41 +6100,62 @@ var CursorMcp = class _CursorMcp extends ToolMcp {
   }
   static async fromFile({
     baseDir = process.cwd(),
-    validate = true
+    validate = true,
+    global = false
   }) {
-    const fileContent = await readFileContent(
-      (0, import_node_path46.join)(
-        baseDir,
-        this.getSettablePaths().relativeDirPath,
-        this.getSettablePaths().relativeFilePath
-      )
-    );
+    const paths = this.getSettablePaths({ global });
+    const filePath = (0, import_node_path46.join)(baseDir, paths.relativeDirPath, paths.relativeFilePath);
+    const fileContent = await readFileContentOrNull(filePath) ?? '{"mcpServers":{}}';
+    let json;
+    try {
+      json = JSON.parse(fileContent);
+    } catch (error) {
+      throw new Error(
+        `Failed to parse Cursor MCP config at ${(0, import_node_path46.join)(paths.relativeDirPath, paths.relativeFilePath)}: ${formatError(error)}`,
+        { cause: error }
+      );
+    }
+    const newJson = { ...json, mcpServers: json.mcpServers ?? {} };
     return new _CursorMcp({
       baseDir,
-      relativeDirPath: this.getSettablePaths().relativeDirPath,
-      relativeFilePath: this.getSettablePaths().relativeFilePath,
-      fileContent,
-      validate
+      relativeDirPath: paths.relativeDirPath,
+      relativeFilePath: paths.relativeFilePath,
+      fileContent: JSON.stringify(newJson, null, 2),
+      validate,
+      global
     });
   }
-  static fromRulesyncMcp({
+  static async fromRulesyncMcp({
     baseDir = process.cwd(),
     rulesyncMcp,
-    validate = true
+    validate = true,
+    global = false
   }) {
-    const json = rulesyncMcp.getJson();
-    const mcpServers = isMcpServers(json.mcpServers) ? json.mcpServers : {};
+    const paths = this.getSettablePaths({ global });
+    const fileContent = await readOrInitializeFileContent(
+      (0, import_node_path46.join)(baseDir, paths.relativeDirPath, paths.relativeFilePath),
+      JSON.stringify({ mcpServers: {} }, null, 2)
+    );
+    let json;
+    try {
+      json = JSON.parse(fileContent);
+    } catch (error) {
+      throw new Error(
+        `Failed to parse Cursor MCP config at ${(0, import_node_path46.join)(paths.relativeDirPath, paths.relativeFilePath)}: ${formatError(error)}`,
+        { cause: error }
+      );
+    }
+    const rulesyncJson = rulesyncMcp.getJson();
+    const mcpServers = isMcpServers(rulesyncJson.mcpServers) ? rulesyncJson.mcpServers : {};
     const transformedServers = convertEnvToCursorFormat(mcpServers);
-    const cursorConfig = {
-      mcpServers: transformedServers
-    };
-    const fileContent = JSON.stringify(cursorConfig, null, 2);
+    const cursorConfig = { ...json, mcpServers: transformedServers };
     return new _CursorMcp({
       baseDir,
-      relativeDirPath: this.getSettablePaths().relativeDirPath,
-      relativeFilePath: this.getSettablePaths().relativeFilePath,
-      fileContent,
-      validate
+      relativeDirPath: paths.relativeDirPath,
+      relativeFilePath: paths.relativeFilePath,
+      fileContent: JSON.stringify(cursorConfig, null, 2),
+      validate,
+      global
     });
   }
   toRulesyncMcp() {
@@ -6096,14 +6179,16 @@ var CursorMcp = class _CursorMcp extends ToolMcp {
   static forDeletion({
     baseDir = process.cwd(),
     relativeDirPath,
-    relativeFilePath
+    relativeFilePath,
+    global = false
   }) {
     return new _CursorMcp({
       baseDir,
       relativeDirPath,
       relativeFilePath,
       fileContent: "{}",
-      validate: false
+      validate: false,
+      global
     });
   }
 };
@@ -6932,7 +7017,7 @@ var toolMcpFactories = /* @__PURE__ */ new Map([
       class: CursorMcp,
       meta: {
         supportsProject: true,
-        supportsGlobal: false,
+        supportsGlobal: true,
         supportsEnabledTools: false,
         supportsDisabledTools: false
       }
@@ -7645,9 +7730,15 @@ var import_node_path59 = require("path");
 var DirFeatureProcessor = class {
   baseDir;
   dryRun;
-  constructor({ baseDir = process.cwd(), dryRun = false }) {
+  avoidBlockScalars;
+  constructor({
+    baseDir = process.cwd(),
+    dryRun = false,
+    avoidBlockScalars = false
+  }) {
     this.baseDir = baseDir;
     this.dryRun = dryRun;
+    this.avoidBlockScalars = avoidBlockScalars;
   }
   /**
    * Return tool targets that this feature supports.
@@ -7673,7 +7764,9 @@ var DirFeatureProcessor = class {
       let mainFileContent;
       if (mainFile) {
         const mainFilePath = (0, import_node_path59.join)(dirPath, mainFile.name);
-        const content = stringifyFrontmatter(mainFile.body, mainFile.frontmatter);
+        const content = stringifyFrontmatter(mainFile.body, mainFile.frontmatter, {
+          avoidBlockScalars: this.avoidBlockScalars
+        });
         mainFileContent = addTrailingNewline(content);
         const existingContent = await readFileContentOrNull(mainFilePath);
         if (existingContent !== mainFileContent) {
@@ -10412,7 +10505,7 @@ var SkillsProcessor = class extends DirFeatureProcessor {
     getFactory = defaultGetFactory4,
     dryRun = false
   }) {
-    super({ baseDir, dryRun });
+    super({ baseDir, dryRun, avoidBlockScalars: toolTarget === "cursor" });
     const result = SkillsProcessorToolTargetSchema.safeParse(toolTarget);
     if (!result.success) {
       throw new Error(
@@ -11493,7 +11586,7 @@ var CursorSubagent = class _CursorSubagent extends ToolSubagent {
       ...cursorSection
     };
     const body = rulesyncSubagent.getBody();
-    const fileContent = stringifyFrontmatter(body, cursorFrontmatter);
+    const fileContent = stringifyFrontmatter(body, cursorFrontmatter, { avoidBlockScalars: true });
     const paths = this.getSettablePaths({ global });
     return new _CursorSubagent({
       baseDir,
@@ -16932,13 +17025,22 @@ var import_jsonc_parser2 = require("jsonc-parser");
 // src/config/config.ts
 var import_node_path117 = require("path");
 var import_mini59 = require("zod/mini");
-function hasControlCharacters(value) {
+
+// src/utils/validation.ts
+function findControlCharacter(value) {
   for (let i = 0; i < value.length; i++) {
     const code = value.charCodeAt(i);
-    if (code >= 0 && code <= 31 || code === 127) return true;
+    if (code >= 0 && code <= 31 || code === 127) {
+      return { position: i, hex: `0x${code.toString(16).padStart(2, "0")}` };
+    }
   }
-  return false;
+  return null;
 }
+function hasControlCharacters(value) {
+  return findControlCharacter(value) !== null;
+}
+
+// src/config/config.ts
 var SourceEntrySchema = import_mini59.z.object({
   source: import_mini59.z.string().check((0, import_mini59.minLength)(1, "source must be a non-empty string")),
   skills: (0, import_mini59.optional)(import_mini59.z.array(import_mini59.z.string())),
@@ -18458,17 +18560,8 @@ var import_node_path122 = require("path");
 var import_node_util = require("util");
 var execFileAsync = (0, import_node_util.promisify)(import_node_child_process.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 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 });
@@ -18524,6 +18617,7 @@ async function resolveDefaultRef(url) {
     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}`);
+    validateRef(ref);
     return { ref, sha };
   } catch (error) {
     if (error instanceof GitClientError) throw error;
@@ -18550,6 +18644,17 @@ async function fetchSkillFiles(params) {
   const { url, ref, skillsPath } = params;
   validateGitUrl(url);
   validateRef(ref);
+  if (skillsPath.split(/[/\\]/).includes("..") || (0, import_node_path122.isAbsolute)(skillsPath)) {
+    throw new GitClientError(
+      `Invalid skillsPath "${skillsPath}": must be a relative path without ".."`
+    );
+  }
+  const ctrl = findControlCharacter(skillsPath);
+  if (ctrl) {
+    throw new GitClientError(
+      `skillsPath contains control character ${ctrl.hex} at position ${ctrl.position}`
+    );
+  }
   await checkGitAvailable();
   const tmpDir = await createTempDirectory("rulesync-git-");
   try {
@@ -18584,7 +18689,9 @@ async function fetchSkillFiles(params) {
   }
 }
 var MAX_WALK_DEPTH = 20;
-async function walkDirectory(dir, baseDir, depth = 0) {
+var MAX_TOTAL_FILES = 1e4;
+var MAX_TOTAL_SIZE = 100 * 1024 * 1024;
+async function walkDirectory(dir, baseDir, depth = 0, ctx = { totalFiles: 0, totalSize: 0 }) {
   if (depth > MAX_WALK_DEPTH) {
     throw new GitClientError(
       `Directory tree exceeds max depth of ${MAX_WALK_DEPTH}: "${dir}". Aborting to prevent resource exhaustion.`
@@ -18599,7 +18706,7 @@ async function walkDirectory(dir, baseDir, depth = 0) {
       continue;
     }
     if (await directoryExists(fullPath)) {
-      results.push(...await walkDirectory(fullPath, baseDir, depth + 1));
+      results.push(...await walkDirectory(fullPath, baseDir, depth + 1, ctx));
     } else {
       const size = await getFileSize(fullPath);
       if (size > MAX_FILE_SIZE) {
@@ -18608,8 +18715,20 @@ async function walkDirectory(dir, baseDir, depth = 0) {
         );
         continue;
       }
+      ctx.totalFiles++;
+      ctx.totalSize += size;
+      if (ctx.totalFiles >= MAX_TOTAL_FILES) {
+        throw new GitClientError(
+          `Repository exceeds max file count of ${MAX_TOTAL_FILES}. Aborting to prevent resource exhaustion.`
+        );
+      }
+      if (ctx.totalSize >= MAX_TOTAL_SIZE) {
+        throw new GitClientError(
+          `Repository exceeds max total size of ${MAX_TOTAL_SIZE / 1024 / 1024}MB. Aborting to prevent resource exhaustion.`
+        );
+      }
       const content = await readFileContent(fullPath);
-      results.push({ relativePath: fullPath.substring(baseDir.length + 1), content, size });
+      results.push({ relativePath: (0, import_node_path122.relative)(baseDir, fullPath), content, size });
     }
   }
   return results;
@@ -18625,7 +18744,7 @@ var LockedSkillSchema = import_mini60.z.object({
 });
 var LockedSourceSchema = import_mini60.z.object({
   requestedRef: (0, import_mini60.optional)(import_mini60.z.string()),
-  resolvedRef: import_mini60.z.string(),
+  resolvedRef: import_mini60.z.string().check((0, import_mini60.refine)((v) => /^[0-9a-f]{40}$/.test(v), "resolvedRef must be a 40-character hex SHA")),
   resolvedAt: (0, import_mini60.optional)(import_mini60.z.string()),
   skills: import_mini60.z.record(import_mini60.z.string(), LockedSkillSchema)
 });
@@ -18828,6 +18947,8 @@ async function resolveAndFetchSources(params) {
       logger.error(`Failed to fetch source "${sourceEntry.source}": ${formatError(error)}`);
       if (error instanceof GitHubClientError) {
         logGitHubAuthHints(error);
+      } else if (error instanceof GitClientError) {
+        logGitClientHints(error);
       }
     }
   }
@@ -18848,6 +18969,13 @@ async function resolveAndFetchSources(params) {
   }
   return { fetchedSkillCount: totalSkillCount, sourcesProcessed: sources.length };
 }
+function logGitClientHints(error) {
+  if (error.message.includes("not installed")) {
+    logger.info("Hint: Install git and ensure it is available on your PATH.");
+  } else {
+    logger.info("Hint: Check your git credentials (SSH keys, credential helper, or access token).");
+  }
+}
 async function checkLockedSkillsExist(curatedDir, skillNames) {
   if (skillNames.length === 0) return true;
   for (const name of skillNames) {
@@ -18857,9 +18985,88 @@ async function checkLockedSkillsExist(curatedDir, skillNames) {
   }
   return true;
 }
+async function cleanPreviousCuratedSkills(curatedDir, lockedSkillNames) {
+  const resolvedCuratedDir = (0, import_node_path124.resolve)(curatedDir);
+  for (const prevSkill of lockedSkillNames) {
+    const prevDir = (0, import_node_path124.join)(curatedDir, prevSkill);
+    if (!(0, import_node_path124.resolve)(prevDir).startsWith(resolvedCuratedDir + import_node_path124.sep)) {
+      logger.warn(
+        `Skipping removal of "${prevSkill}": resolved path is outside the curated directory.`
+      );
+      continue;
+    }
+    if (await directoryExists(prevDir)) {
+      await removeDirectory(prevDir);
+    }
+  }
+}
+function shouldSkipSkill(params) {
+  const { skillName, sourceKey, localSkillNames, alreadyFetchedSkillNames } = params;
+  if (skillName.includes("..") || skillName.includes("/") || skillName.includes("\\")) {
+    logger.warn(
+      `Skipping skill with invalid name "${skillName}" from ${sourceKey}: contains path traversal characters.`
+    );
+    return true;
+  }
+  if (localSkillNames.has(skillName)) {
+    logger.debug(
+      `Skipping remote skill "${skillName}" from ${sourceKey}: local skill takes precedence.`
+    );
+    return true;
+  }
+  if (alreadyFetchedSkillNames.has(skillName)) {
+    logger.warn(
+      `Skipping duplicate skill "${skillName}" from ${sourceKey}: already fetched from another source.`
+    );
+    return true;
+  }
+  return false;
+}
+async function writeSkillAndComputeIntegrity(params) {
+  const { skillName, files, curatedDir, locked, resolvedSha, sourceKey } = params;
+  const written = [];
+  for (const file of files) {
+    checkPathTraversal({
+      relativePath: file.relativePath,
+      intendedRootDir: (0, import_node_path124.join)(curatedDir, skillName)
+    });
+    await writeFileContent((0, import_node_path124.join)(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 ${sourceKey}: expected "${lockedSkillEntry.integrity}", got "${integrity}". Content may have been tampered with.`
+    );
+  }
+  return { integrity };
+}
+function buildLockUpdate(params) {
+  const { lock, sourceKey, fetchedSkills, locked, requestedRef, resolvedSha } = params;
+  const fetchedNames = Object.keys(fetchedSkills);
+  const mergedSkills = { ...fetchedSkills };
+  if (locked) {
+    for (const [skillName, skillEntry] of Object.entries(locked.skills)) {
+      if (!(skillName in mergedSkills)) {
+        mergedSkills[skillName] = skillEntry;
+      }
+    }
+  }
+  const updatedLock = setLockedSource(lock, sourceKey, {
+    requestedRef,
+    resolvedRef: resolvedSha,
+    resolvedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    skills: mergedSkills
+  });
+  logger.info(
+    `Fetched ${fetchedNames.length} skill(s) from ${sourceKey}: ${fetchedNames.join(", ") || "(none)"}`
+  );
+  return { updatedLock, fetchedNames };
+}
 async function fetchSource(params) {
   const { sourceEntry, client, baseDir, localSkillNames, alreadyFetchedSkillNames, updateSources } = params;
-  let { lock } = params;
+  const { lock } = params;
   const parsed = parseSource(sourceEntry.source);
   if (parsed.provider === "gitlab") {
     logger.warn(`GitLab sources are not yet supported. Skipping "${sourceEntry.source}".`);
@@ -18912,37 +19119,15 @@ async function fetchSource(params) {
   const semaphore = new import_promise2.Semaphore(FETCH_CONCURRENCY_LIMIT);
   const fetchedSkills = {};
   if (locked) {
-    const resolvedCuratedDir = (0, import_node_path124.resolve)(curatedDir);
-    for (const prevSkill of lockedSkillNames) {
-      const prevDir = (0, import_node_path124.join)(curatedDir, prevSkill);
-      if (!(0, import_node_path124.resolve)(prevDir).startsWith(resolvedCuratedDir + import_node_path124.sep)) {
-        logger.warn(
-          `Skipping removal of "${prevSkill}": resolved path is outside the curated directory.`
-        );
-        continue;
-      }
-      if (await directoryExists(prevDir)) {
-        await removeDirectory(prevDir);
-      }
-    }
+    await cleanPreviousCuratedSkills(curatedDir, lockedSkillNames);
   }
   for (const skillDir of filteredDirs) {
-    if (skillDir.name.includes("..") || skillDir.name.includes("/") || skillDir.name.includes("\\")) {
-      logger.warn(
-        `Skipping skill with invalid name "${skillDir.name}" from ${sourceKey}: contains path traversal characters.`
-      );
-      continue;
-    }
-    if (localSkillNames.has(skillDir.name)) {
-      logger.debug(
-        `Skipping remote skill "${skillDir.name}" from ${sourceKey}: local skill takes precedence.`
-      );
-      continue;
-    }
-    if (alreadyFetchedSkillNames.has(skillDir.name)) {
-      logger.warn(
-        `Skipping duplicate skill "${skillDir.name}" from ${sourceKey}: already fetched from another source.`
-      );
+    if (shouldSkipSkill({
+      skillName: skillDir.name,
+      sourceKey,
+      localSkillNames,
+      alreadyFetchedSkillNames
+    })) {
       continue;
     }
     const allFiles = await listDirectoryRecursive({
@@ -18965,55 +19150,39 @@ async function fetchSource(params) {
     const skillFiles = [];
     for (const file of files) {
       const relativeToSkill = file.path.substring(skillDir.path.length + 1);
-      const localFilePath = (0, import_node_path124.join)(curatedDir, skillDir.name, relativeToSkill);
-      checkPathTraversal({
-        relativePath: relativeToSkill,
-        intendedRootDir: (0, import_node_path124.join)(curatedDir, skillDir.name)
-      });
       const content = await withSemaphore(
         semaphore,
         () => client.getFileContent(parsed.owner, parsed.repo, file.path, ref)
       );
-      await writeFileContent(localFilePath, content);
-      skillFiles.push({ path: relativeToSkill, content });
+      skillFiles.push({ relativePath: relativeToSkill, content });
     }
-    const integrity = computeSkillIntegrity(skillFiles);
-    const lockedSkillEntry = locked?.skills[skillDir.name];
-    if (lockedSkillEntry && lockedSkillEntry.integrity && lockedSkillEntry.integrity !== integrity && resolvedSha === locked?.resolvedRef) {
-      logger.warn(
-        `Integrity mismatch for skill "${skillDir.name}" from ${sourceKey}: expected "${lockedSkillEntry.integrity}", got "${integrity}". Content may have been tampered with.`
-      );
-    }
-    fetchedSkills[skillDir.name] = { integrity };
+    fetchedSkills[skillDir.name] = await writeSkillAndComputeIntegrity({
+      skillName: skillDir.name,
+      files: skillFiles,
+      curatedDir,
+      locked,
+      resolvedSha,
+      sourceKey
+    });
     logger.debug(`Fetched skill "${skillDir.name}" from ${sourceKey}`);
   }
-  const fetchedNames = Object.keys(fetchedSkills);
-  const mergedSkills = { ...fetchedSkills };
-  if (locked) {
-    for (const [skillName, skillEntry] of Object.entries(locked.skills)) {
-      if (!(skillName in mergedSkills)) {
-        mergedSkills[skillName] = skillEntry;
-      }
-    }
-  }
-  lock = setLockedSource(lock, sourceKey, {
+  const result = buildLockUpdate({
+    lock,
+    sourceKey,
+    fetchedSkills,
+    locked,
     requestedRef,
-    resolvedRef: resolvedSha,
-    resolvedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    skills: mergedSkills
+    resolvedSha
   });
-  logger.info(
-    `Fetched ${fetchedNames.length} skill(s) from ${sourceKey}: ${fetchedNames.join(", ") || "(none)"}`
-  );
   return {
-    skillCount: fetchedNames.length,
-    fetchedSkillNames: fetchedNames,
-    updatedLock: lock
+    skillCount: result.fetchedNames.length,
+    fetchedSkillNames: result.fetchedNames,
+    updatedLock: result.updatedLock
   };
 }
 async function fetchSourceViaGit(params) {
   const { sourceEntry, baseDir, localSkillNames, alreadyFetchedSkillNames, updateSources, frozen } = params;
-  let { lock } = params;
+  const { lock } = params;
   const url = sourceEntry.source;
   const locked = getLockedSource(lock, url);
   const lockedSkillNames = locked ? getLockedSkillNames(locked) : [];
@@ -19069,68 +19238,35 @@ async function fetchSourceViaGit(params) {
   const allNames = [...skillFileMap.keys()];
   const filteredNames = isWildcard ? allNames : allNames.filter((n) => skillFilter.includes(n));
   if (locked) {
-    const base = (0, import_node_path124.resolve)(curatedDir);
-    for (const prev of lockedSkillNames) {
-      const dir = (0, import_node_path124.join)(curatedDir, prev);
-      if ((0, import_node_path124.resolve)(dir).startsWith(base + import_node_path124.sep) && await directoryExists(dir)) {
-        await removeDirectory(dir);
-      }
-    }
+    await cleanPreviousCuratedSkills(curatedDir, lockedSkillNames);
   }
   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.`
-      );
+    if (shouldSkipSkill({ skillName, sourceKey: url, localSkillNames, alreadyFetchedSkillNames })) {
       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: (0, import_node_path124.join)(curatedDir, skillName)
-      });
-      await writeFileContent((0, import_node_path124.join)(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;
-    }
+    fetchedSkills[skillName] = await writeSkillAndComputeIntegrity({
+      skillName,
+      files: skillFileMap.get(skillName) ?? [],
+      curatedDir,
+      locked,
+      resolvedSha,
+      sourceKey: url
+    });
   }
-  lock = setLockedSource(lock, url, {
+  const result = buildLockUpdate({
+    lock,
+    sourceKey: url,
+    fetchedSkills,
+    locked,
     requestedRef,
-    resolvedRef: resolvedSha,
-    resolvedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    skills: mergedSkills
+    resolvedSha
   });
-  logger.info(
-    `Fetched ${fetchedNames.length} skill(s) from ${url}: ${fetchedNames.join(", ") || "(none)"}`
-  );
-  return { skillCount: fetchedNames.length, fetchedSkillNames: fetchedNames, updatedLock: lock };
+  return {
+    skillCount: result.fetchedNames.length,
+    fetchedSkillNames: result.fetchedNames,
+    updatedLock: result.updatedLock
+  };
 }
 
 // src/cli/commands/install.ts
@@ -20946,7 +21082,7 @@ async function updateCommand(currentVersion, options) {
 }
 
 // src/cli/index.ts
-var getVersion = () => "7.15.2";
+var getVersion = () => "7.16.0";
 var main = async () => {
   const program = new import_commander.Command();
   const version = getVersion();