rulesync 8.4.0 → 8.6.0

package/dist/cli/index.js

@@ -10,6 +10,7 @@ import {
   ConsoleLogger,
   ErrorCodes,
   FETCH_CONCURRENCY_LIMIT,
+  GITIGNORE_DESTINATION_KEY,
   HooksProcessor,
   IgnoreProcessor,
   JsonLogger,
@@ -73,7 +74,7 @@ import {
   stringifyFrontmatter,
   toPosixPath,
   writeFileContent
-} from "../chunk-MMBSR2RA.js";
+} from "../chunk-ILMHM7BF.js";
 
 // src/cli/index.ts
 import { Command } from "commander";
@@ -1336,6 +1337,9 @@ var GITIGNORE_ENTRY_REGISTRY = [
     entry: "**/.rovodev/.rulesync/"
   },
   { target: "rovodev", feature: "skills", entry: "**/.agents/skills/" },
+  // Windsurf
+  { target: "windsurf", feature: "skills", entry: "**/.windsurf/skills/" },
+  { target: "windsurf", feature: "skills", entry: "**/.codeium/windsurf/skills/" },
   // Warp
   { target: "warp", feature: "rules", entry: "**/.warp/" },
   { target: "warp", feature: "rules", entry: "**/WARP.md" }
@@ -1415,13 +1419,14 @@ var warnInvalidFeatures = (features, logger5) => {
         }
       } else {
         for (const feature of Object.keys(targetFeatures)) {
+          if (feature === GITIGNORE_DESTINATION_KEY) continue;
           warnOnce(feature);
         }
       }
     }
   }
 };
-var filterGitignoreEntries = (params) => {
+var resolveGitignoreEntries = (params) => {
   const { targets, features, logger: logger5 } = params ?? {};
   if (targets && targets.length > 0) {
     warnInvalidTargets(targets, logger5);
@@ -1437,7 +1442,11 @@ var filterGitignoreEntries = (params) => {
     if (!isFeatureSelected(tag.feature, selectedTagTargets, features)) continue;
     if (seen.has(tag.entry)) continue;
     seen.add(tag.entry);
-    result.push(tag.entry);
+    result.push({
+      entry: tag.entry,
+      target: selectedTagTargets,
+      feature: tag.feature
+    });
   }
   return result;
 };
@@ -1494,48 +1503,129 @@ var removeExistingRulesyncEntries = (content) => {
   }
   return result;
 };
+var groupEntriesByDestination = ({
+  entries,
+  resolveDestination
+}) => {
+  const gitignore = /* @__PURE__ */ new Set();
+  const gitattributes = /* @__PURE__ */ new Set();
+  for (const entry of entries) {
+    const selectedToolTargets = entry.target.filter(
+      (target) => target !== "common"
+    );
+    const destinations = /* @__PURE__ */ new Set();
+    for (const target of selectedToolTargets) {
+      if (entry.feature === "general") {
+        destinations.add(resolveDestination(target));
+      } else {
+        destinations.add(resolveDestination(target, entry.feature));
+      }
+    }
+    if (destinations.has("gitattributes")) {
+      gitattributes.add(entry.entry);
+    }
+    if (destinations.size === 0 || destinations.has("gitignore")) {
+      gitignore.add(entry.entry);
+    }
+  }
+  return {
+    gitignore: [...gitignore],
+    gitattributes: [...gitattributes]
+  };
+};
 var gitignoreCommand = async (logger5, options) => {
   const gitignorePath = join2(process.cwd(), ".gitignore");
-  let gitignoreContent = "";
-  if (await fileExists(gitignorePath)) {
-    gitignoreContent = await readFileContent(gitignorePath);
-  }
-  const cleanedContent = removeExistingRulesyncEntries(gitignoreContent);
-  const filteredEntries = filterGitignoreEntries({
+  const gitattributesPath = join2(process.cwd(), ".gitattributes");
+  const config = await ConfigResolver.resolve({});
+  const resolvedEntries = resolveGitignoreEntries({
     targets: options?.targets,
     features: options?.features,
     logger: logger5
   });
-  const existingEntries = new Set(
-    gitignoreContent.split("\n").map((line) => line.trim()).filter((line) => line !== "" && !isRulesyncHeader(line))
-  );
-  const alreadyExistedEntries = filteredEntries.filter((entry) => existingEntries.has(entry));
-  const entriesToAdd = filteredEntries.filter((entry) => !existingEntries.has(entry));
-  const rulesyncBlock = [RULESYNC_HEADER, ...filteredEntries].join("\n");
-  const newContent = cleanedContent.trim() ? `${cleanedContent.trimEnd()}
+  const { gitignore: gitignoreEntries, gitattributes: gitattributesEntries } = groupEntriesByDestination({
+    entries: resolvedEntries,
+    resolveDestination: (target, feature) => {
+      if (feature === void 0 || feature === "general") {
+        return config.getGitignoreDestination(target);
+      }
+      return config.getGitignoreDestination(target, feature);
+    }
+  });
+  const updateRulesyncFile = async ({
+    filePath,
+    entries
+  }) => {
+    let content = "";
+    if (await fileExists(filePath)) {
+      content = await readFileContent(filePath);
+    }
+    const cleanedContent = removeExistingRulesyncEntries(content);
+    const existingEntries = new Set(
+      content.split("\n").map((line) => line.trim()).filter((line) => line !== "" && !isRulesyncHeader(line))
+    );
+    const alreadyExistedEntries = entries.filter((entry) => existingEntries.has(entry));
+    const entriesToAdd = entries.filter((entry) => !existingEntries.has(entry));
+    const rulesyncBlock = [RULESYNC_HEADER, ...entries].join("\n");
+    const newContent = entries.length === 0 ? cleanedContent.trim() ? `${cleanedContent.trimEnd()}
+` : "" : cleanedContent.trim() ? `${cleanedContent.trimEnd()}
 
 ${rulesyncBlock}
 ` : `${rulesyncBlock}
 `;
-  if (gitignoreContent === newContent) {
+    if (content === newContent) {
+      return { updated: false, alreadyExistedEntries, entriesToAdd: [] };
+    }
+    await writeFileContent(filePath, newContent);
+    return { updated: true, alreadyExistedEntries, entriesToAdd };
+  };
+  const gitignoreResult = await updateRulesyncFile({
+    filePath: gitignorePath,
+    entries: gitignoreEntries
+  });
+  const gitattributesResult = await updateRulesyncFile({
+    filePath: gitattributesPath,
+    entries: gitattributesEntries
+  });
+  if (!gitignoreResult.updated && !gitattributesResult.updated) {
     if (logger5.jsonMode) {
       logger5.captureData("entriesAdded", []);
       logger5.captureData("gitignorePath", gitignorePath);
-      logger5.captureData("alreadyExisted", filteredEntries);
+      logger5.captureData("gitattributesPath", gitattributesPath);
+      logger5.captureData("alreadyExisted", [...gitignoreEntries, ...gitattributesEntries]);
     }
-    logger5.success(".gitignore is already up to date");
+    logger5.success(".gitignore / .gitattributes are already up to date");
     return;
   }
-  await writeFileContent(gitignorePath, newContent);
   if (logger5.jsonMode) {
-    logger5.captureData("entriesAdded", entriesToAdd);
+    logger5.captureData("entriesAdded", [
+      ...gitignoreResult.entriesToAdd,
+      ...gitattributesResult.entriesToAdd
+    ]);
     logger5.captureData("gitignorePath", gitignorePath);
-    logger5.captureData("alreadyExisted", alreadyExistedEntries);
+    logger5.captureData("gitattributesPath", gitattributesPath);
+    logger5.captureData("alreadyExisted", [
+      ...gitignoreResult.alreadyExistedEntries,
+      ...gitattributesResult.alreadyExistedEntries
+    ]);
+  }
+  if (gitignoreResult.updated) {
+    logger5.success("Updated .gitignore with rulesync entries:");
+  } else {
+    logger5.success(".gitignore is already up to date");
   }
-  logger5.success("Updated .gitignore with rulesync entries:");
-  for (const entry of filteredEntries) {
+  for (const entry of gitignoreEntries) {
     logger5.info(`  ${entry}`);
   }
+  if (gitattributesEntries.length > 0) {
+    if (gitattributesResult.updated) {
+      logger5.success("Updated .gitattributes with rulesync entries:");
+    } else {
+      logger5.success(".gitattributes is already up to date");
+    }
+    for (const entry of gitattributesEntries) {
+      logger5.info(`  ${entry}`);
+    }
+  }
   logger5.info("");
   logger5.info(
     "\u{1F4A1} If you're using Google Antigravity, note that rules, workflows, and skills won't load if they're gitignored."
@@ -2580,6 +2670,18 @@ async function fetchSourceViaGit(params) {
     arr.push({ relativePath: inner, content: file.content });
     skillFileMap.set(name, arr);
   }
+  if (skillFileMap.size === 0 && !isWildcard && skillFilter.length === 1) {
+    const [singleSkillName] = skillFilter;
+    if (singleSkillName !== void 0) {
+      const rootFiles = remoteFiles.filter((f) => f.relativePath.indexOf("/") === -1);
+      if (rootFiles.length > 0) {
+        skillFileMap.set(
+          singleSkillName,
+          rootFiles.map((f) => ({ relativePath: f.relativePath, content: f.content }))
+        );
+      }
+    }
+  }
   const allNames = [...skillFileMap.keys()];
   const filteredNames = isWildcard ? allNames : allNames.filter((n) => skillFilter.includes(n));
   if (locked) {
@@ -4523,7 +4625,7 @@ function wrapCommand({
 }
 
 // src/cli/index.ts
-var getVersion = () => "8.4.0";
+var getVersion = () => "8.6.0";
 function wrapCommand2(name, errorCode, handler) {
   return wrapCommand({ name, errorCode, handler, getVersion });
 }