rulesync 6.6.3 → 6.7.1

package/README.md

@@ -118,26 +118,29 @@ Get-FileHash rulesync.exe -Algorithm SHA256 | ForEach-Object {
 ## Getting Started
 
 ```bash
+# Install rulesync globally
+npm install -g rulesync
+
 # Create necessary directories, sample rule files, and configuration file
-npx rulesync init
+rulesync init
 
 # Install official skills (recommended)
-npx rulesync fetch dyoshikawa/rulesync --features skills
+rulesync fetch dyoshikawa/rulesync --features skills
 ```
 
 On the other hand, if you already have AI tool configurations:
 
 ```bash
 # Import existing files (to .rulesync/**/*)
-npx rulesync import --targets claudecode    # From CLAUDE.md
-npx rulesync import --targets cursor        # From .cursorrules
-npx rulesync import --targets copilot       # From .github/copilot-instructions.md
-npx rulesync import --targets claudecode --features rules,mcp,commands,subagents
+rulesync import --targets claudecode    # From CLAUDE.md
+rulesync import --targets cursor        # From .cursorrules
+rulesync import --targets copilot       # From .github/copilot-instructions.md
+rulesync import --targets claudecode --features rules,mcp,commands,subagents
 
 # And more tool supports
 
 # Generate unified configurations with all features
-npx rulesync generate --targets "*" --features "*"
+rulesync generate --targets "*" --features "*"
 ```
 
 ## Supported Tools and Features
@@ -211,46 +214,46 @@ Rulesync is trusted by leading companies and recognized by the industry:
 
 ```bash
 # Initialize new project (recommended: organized rules structure)
-npx rulesync init
+rulesync init
 
 # Import existing configurations (to .rulesync/rules/ by default)
-npx rulesync import --targets claudecode --features rules,ignore,mcp,commands,subagents,skills
+rulesync import --targets claudecode --features rules,ignore,mcp,commands,subagents,skills
 
 # Fetch configurations from a Git repository
-npx rulesync fetch owner/repo
-npx rulesync fetch owner/repo@v1.0.0 --features rules,commands
-npx rulesync fetch https://github.com/owner/repo --conflict skip
+rulesync fetch owner/repo
+rulesync fetch owner/repo@v1.0.0 --features rules,commands
+rulesync fetch https://github.com/owner/repo --conflict skip
 
 # Generate all features for all tools (new preferred syntax)
-npx rulesync generate --targets "*" --features "*"
+rulesync generate --targets "*" --features "*"
 
 # Generate specific features for specific tools
-npx rulesync generate --targets copilot,cursor,cline --features rules,mcp
-npx rulesync generate --targets claudecode --features rules,subagents
+rulesync generate --targets copilot,cursor,cline --features rules,mcp
+rulesync generate --targets claudecode --features rules,subagents
 
 # Generate only rules (no MCP, ignore files, commands, or subagents)
-npx rulesync generate --targets "*" --features rules
+rulesync generate --targets "*" --features rules
 
 # Generate simulated commands and subagents
-npx rulesync generate --targets copilot,cursor,codexcli --features commands,subagents --simulate-commands --simulate-subagents
+rulesync generate --targets copilot,cursor,codexcli --features commands,subagents --simulate-commands --simulate-subagents
 
 # Dry run: show changes without writing files
-npx rulesync generate --dry-run --targets claudecode --features rules
+rulesync generate --dry-run --targets claudecode --features rules
 
 # Check if files are up to date (for CI/CD pipelines)
-npx rulesync generate --check --targets "*" --features "*"
+rulesync generate --check --targets "*" --features "*"
 
 # Add generated files to .gitignore
-npx rulesync gitignore
+rulesync gitignore
 
 # Update rulesync to the latest version (single-binary installs)
-npx rulesync update
+rulesync update
 
 # Check for updates without installing
-npx rulesync update --check
+rulesync update --check
 
 # Force update even if already at latest version
-npx rulesync update --force
+rulesync update --force
 ```
 
 ## Dry Run
@@ -262,7 +265,7 @@ Rulesync provides two dry run options for the `generate` command that allow you
 Show what would be written or deleted without actually writing any files. Changes are displayed with a `[DRY RUN]` prefix.
 
 ```bash
-npx rulesync generate --dry-run --targets claudecode --features rules
+rulesync generate --dry-run --targets claudecode --features rules
 ```
 
 ### `--check`
@@ -271,7 +274,7 @@ Same as `--dry-run`, but exits with code 1 if files are not up to date. This is
 
 ```bash
 # In your CI pipeline
-npx rulesync generate --check --targets "*" --features "*"
+rulesync generate --check --targets "*" --features "*"
 echo $?  # 0 if up to date, 1 if changes needed
 ```
 
@@ -291,20 +294,20 @@ The `fetch` command allows you to fetch configuration files directly from a Git
 
 ```bash
 # Full URL format
-npx rulesync fetch https://github.com/owner/repo
-npx rulesync fetch https://github.com/owner/repo/tree/branch
-npx rulesync fetch https://github.com/owner/repo/tree/branch/path/to/subdir
-npx rulesync fetch https://gitlab.com/owner/repo  # GitLab (planned)
+rulesync fetch https://github.com/owner/repo
+rulesync fetch https://github.com/owner/repo/tree/branch
+rulesync fetch https://github.com/owner/repo/tree/branch/path/to/subdir
+rulesync fetch https://gitlab.com/owner/repo  # GitLab (planned)
 
 # Prefix format
-npx rulesync fetch github:owner/repo
-npx rulesync fetch gitlab:owner/repo              # GitLab (planned)
+rulesync fetch github:owner/repo
+rulesync fetch gitlab:owner/repo              # GitLab (planned)
 
 # Shorthand format (defaults to GitHub)
-npx rulesync fetch owner/repo
-npx rulesync fetch owner/repo@ref        # Specify branch/tag/commit
-npx rulesync fetch owner/repo:path       # Specify subdirectory
-npx rulesync fetch owner/repo@ref:path   # Both ref and path
+rulesync fetch owner/repo
+rulesync fetch owner/repo@ref        # Specify branch/tag/commit
+rulesync fetch owner/repo:path       # Specify subdirectory
+rulesync fetch owner/repo@ref:path   # Both ref and path
 ```
 
 ### Options
@@ -323,27 +326,27 @@ npx rulesync fetch owner/repo@ref:path   # Both ref and path
 
 ```bash
 # Fetch skills from external repositories
-npx rulesync fetch vercel-labs/agent-skills --features skills
-npx rulesync fetch anthropics/skills --features skills
+rulesync fetch vercel-labs/agent-skills --features skills
+rulesync fetch anthropics/skills --features skills
 
 # Fetch all features from a public repository
-npx rulesync fetch dyoshikawa/rulesync --path .rulesync
+rulesync fetch dyoshikawa/rulesync --path .rulesync
 
 # Fetch only rules and commands from a specific tag
-npx rulesync fetch owner/repo@v1.0.0 --features rules,commands
+rulesync fetch owner/repo@v1.0.0 --features rules,commands
 
 # Fetch from a private repository (uses GITHUB_TOKEN env var)
 export GITHUB_TOKEN=ghp_xxxx
-npx rulesync fetch owner/private-repo
+rulesync fetch owner/private-repo
 
 # Or use GitHub CLI to get the token
-GITHUB_TOKEN=$(gh auth token) npx rulesync fetch owner/private-repo
+GITHUB_TOKEN=$(gh auth token) rulesync fetch owner/private-repo
 
 # Preserve existing files (skip conflicts)
-npx rulesync fetch owner/repo --conflict skip
+rulesync fetch owner/repo --conflict skip
 
 # Fetch from a monorepo subdirectory
-npx rulesync fetch owner/repo:packages/my-package
+rulesync fetch owner/repo:packages/my-package
 ```
 
 ## Configuration
@@ -695,7 +698,7 @@ Currently, supports rules and commands generation for Claude Code. Import for gl
 2. Initialize files for global files in the directory.
    ```bash
    cd ~/.aiglobal
-   npx rulesync init
+   rulesync init
    ```
 3. Edit `~/.aiglobal/rulesync.jsonc` to enable global mode.
    ```jsonc
@@ -718,7 +721,7 @@ Currently, supports rules and commands generation for Claude Code. Import for gl
 5. Generate rules for global settings.
    ```bash
    # Run in the `~/.aiglobal` directory
-   npx rulesync generate
+   rulesync generate
    ```
 
 > [!NOTE]
@@ -735,7 +738,7 @@ Simulated commands, subagents and skills allow you to generate simulated feature
 1. Prepare `.rulesync/commands/*.md`, `.rulesync/subagents/*.md` and `.rulesync/skills/*/SKILL.md` for your purposes.
 2. Generate simulated commands, subagents and skills for specific tools that are included in cursor, codexcli and etc.
    ```bash
-   npx rulesync generate \
+   rulesync generate \
      --targets copilot,cursor,codexcli \
      --features commands,subagents,skills \
      --simulate-commands \
@@ -762,7 +765,7 @@ Rulesync supports compressing tokens consumed by MCP servers [d-kimuson/modular-
 
 ```bash
 # Enable modular-mcp via CLI
-npx rulesync generate --targets claudecode --features mcp --modular-mcp
+rulesync generate --targets claudecode --features mcp --modular-mcp
 
 # Or via configuration file
 {
@@ -906,7 +909,7 @@ So, in this case, approximately 92% reduction in MCP tools consumption!
 Rulesync provides official skills that you can install using the fetch command:
 
 ```bash
-npx rulesync fetch dyoshikawa/rulesync --features skills
+rulesync fetch dyoshikawa/rulesync --features skills
 ```
 
 This will install the Rulesync documentation skill to your project.

package/dist/index.cjs

@@ -321,16 +321,22 @@ var FeatureProcessor = class {
    * Returns the number of files written.
    */
   async writeAiFiles(aiFiles) {
+    let changedCount = 0;
     for (const aiFile of aiFiles) {
       const filePath = aiFile.getFilePath();
+      const contentWithNewline = addTrailingNewline(aiFile.getFileContent());
+      const existingContent = await readFileContentOrNull(filePath);
+      if (existingContent === contentWithNewline) {
+        continue;
+      }
       if (this.dryRun) {
         logger.info(`[DRY RUN] Would write: ${filePath}`);
       } else {
-        const contentWithNewline = addTrailingNewline(aiFile.getFileContent());
         await writeFileContent(filePath, contentWithNewline);
       }
+      changedCount++;
     }
-    return aiFiles.length;
+    return changedCount;
   }
   async removeAiFiles(aiFiles) {
     for (const aiFile of aiFiles) {
@@ -352,6 +358,7 @@ var FeatureProcessor = class {
         await removeFile(filePath);
       }
     }
+    return orphanFiles.length;
   }
 };
 
@@ -5445,7 +5452,7 @@ var OpencodeMcp = class _OpencodeMcp extends ToolMcp {
   static getSettablePaths({ global } = {}) {
     if (global) {
       return {
-        relativeDirPath: ".",
+        relativeDirPath: (0, import_node_path48.join)(".config", "opencode"),
         relativeFilePath: "opencode.json"
       };
     }
@@ -6422,37 +6429,71 @@ var DirFeatureProcessor = class {
   /**
    * Once converted to rulesync/tool dirs, write them to the filesystem.
    * Returns the number of directories written.
+   *
+   * Note: This method uses directory-level change detection. If any file within
+   * a directory has changed, ALL files in that directory are rewritten. This is
+   * an intentional design decision to ensure consistency within directory units.
    */
   async writeAiDirs(aiDirs) {
+    let changedCount = 0;
     for (const aiDir of aiDirs) {
       const dirPath = aiDir.getDirPath();
+      let dirHasChanges = false;
+      const mainFile = aiDir.getMainFile();
+      let mainFileContent;
+      if (mainFile) {
+        const mainFilePath = (0, import_node_path56.join)(dirPath, mainFile.name);
+        const content = stringifyFrontmatter(mainFile.body, mainFile.frontmatter);
+        mainFileContent = addTrailingNewline(content);
+        const existingContent = await readFileContentOrNull(mainFilePath);
+        if (existingContent !== mainFileContent) {
+          dirHasChanges = true;
+        }
+      }
+      const otherFiles = aiDir.getOtherFiles();
+      const otherFileContents = [];
+      for (const file of otherFiles) {
+        const contentWithNewline = addTrailingNewline(file.fileBuffer.toString("utf-8"));
+        otherFileContents.push(contentWithNewline);
+        if (!dirHasChanges) {
+          const filePath = (0, import_node_path56.join)(dirPath, file.relativeFilePathToDirPath);
+          const existingContent = await readFileContentOrNull(filePath);
+          if (existingContent !== contentWithNewline) {
+            dirHasChanges = true;
+          }
+        }
+      }
+      if (!dirHasChanges) {
+        continue;
+      }
       if (this.dryRun) {
         logger.info(`[DRY RUN] Would create directory: ${dirPath}`);
-        const mainFile = aiDir.getMainFile();
         if (mainFile) {
           logger.info(`[DRY RUN] Would write: ${(0, import_node_path56.join)(dirPath, mainFile.name)}`);
         }
-        for (const file of aiDir.getOtherFiles()) {
+        for (const file of otherFiles) {
           logger.info(`[DRY RUN] Would write: ${(0, import_node_path56.join)(dirPath, file.relativeFilePathToDirPath)}`);
         }
       } else {
         await ensureDir(dirPath);
-        const mainFile = aiDir.getMainFile();
-        if (mainFile) {
+        if (mainFile && mainFileContent) {
           const mainFilePath = (0, import_node_path56.join)(dirPath, mainFile.name);
-          const content = stringifyFrontmatter(mainFile.body, mainFile.frontmatter);
-          const contentWithNewline = addTrailingNewline(content);
-          await writeFileContent(mainFilePath, contentWithNewline);
+          await writeFileContent(mainFilePath, mainFileContent);
         }
-        const otherFiles = aiDir.getOtherFiles();
-        for (const file of otherFiles) {
+        for (const [i, file] of otherFiles.entries()) {
           const filePath = (0, import_node_path56.join)(dirPath, file.relativeFilePathToDirPath);
-          const contentWithNewline = addTrailingNewline(file.fileBuffer.toString("utf-8"));
-          await writeFileContent(filePath, contentWithNewline);
+          const content = otherFileContents[i];
+          if (content === void 0) {
+            throw new Error(
+              `Internal error: content for file ${file.relativeFilePathToDirPath} is undefined. This indicates a synchronization issue between otherFiles and otherFileContents arrays.`
+            );
+          }
+          await writeFileContent(filePath, content);
         }
       }
+      changedCount++;
     }
-    return aiDirs.length;
+    return changedCount;
   }
   async removeAiDirs(aiDirs) {
     for (const aiDir of aiDirs) {
@@ -6474,6 +6515,7 @@ var DirFeatureProcessor = class {
         await removeDirectory(dirPath);
       }
     }
+    return orphanDirs.length;
   }
 };
 
@@ -14701,19 +14743,13 @@ async function generateRulesCore(params) {
       });
       const rulesyncFiles = await processor.loadRulesyncFiles();
       const toolFiles = await processor.convertRulesyncFilesToToolFiles(rulesyncFiles);
-      if (isPreviewMode) {
-        const fileDiff = await detectFileDiff(toolFiles);
-        if (fileDiff) hasDiff = true;
-      }
       const writtenCount = await processor.writeAiFiles(toolFiles);
       totalCount += writtenCount;
+      if (writtenCount > 0) hasDiff = true;
       if (config.getDelete()) {
         const existingToolFiles = await processor.loadToolFiles({ forDeletion: true });
-        if (isPreviewMode) {
-          const orphanDiff = await detectOrphanFileDiff(existingToolFiles, toolFiles);
-          if (orphanDiff) hasDiff = true;
-        }
-        await processor.removeOrphanAiFiles(existingToolFiles, toolFiles);
+        const orphanCount = await processor.removeOrphanAiFiles(existingToolFiles, toolFiles);
+        if (orphanCount > 0) hasDiff = true;
       }
     }
   }
@@ -14741,26 +14777,18 @@ async function generateIgnoreCore(params) {
         const rulesyncFiles = await processor.loadRulesyncFiles();
         if (rulesyncFiles.length > 0) {
           const toolFiles = await processor.convertRulesyncFilesToToolFiles(rulesyncFiles);
-          if (isPreviewMode) {
-            const fileDiff = await detectFileDiff(toolFiles);
-            if (fileDiff) hasDiff = true;
-          }
           const writtenCount = await processor.writeAiFiles(toolFiles);
           totalCount += writtenCount;
+          if (writtenCount > 0) hasDiff = true;
           if (config.getDelete()) {
             const existingToolFiles = await processor.loadToolFiles({ forDeletion: true });
-            if (isPreviewMode) {
-              const orphanDiff = await detectOrphanFileDiff(existingToolFiles, toolFiles);
-              if (orphanDiff) hasDiff = true;
-            }
-            await processor.removeOrphanAiFiles(existingToolFiles, toolFiles);
+            const orphanCount = await processor.removeOrphanAiFiles(existingToolFiles, toolFiles);
+            if (orphanCount > 0) hasDiff = true;
           }
         } else if (config.getDelete()) {
           const existingToolFiles = await processor.loadToolFiles({ forDeletion: true });
-          if (isPreviewMode && existingToolFiles.length > 0) {
-            hasDiff = true;
-          }
-          await processor.removeOrphanAiFiles(existingToolFiles, []);
+          const orphanCount = await processor.removeOrphanAiFiles(existingToolFiles, []);
+          if (orphanCount > 0) hasDiff = true;
         }
       } catch (error) {
         logger.warn(
@@ -14795,19 +14823,13 @@ async function generateMcpCore(params) {
       });
       const rulesyncFiles = await processor.loadRulesyncFiles();
       const toolFiles = await processor.convertRulesyncFilesToToolFiles(rulesyncFiles);
-      if (isPreviewMode) {
-        const fileDiff = await detectFileDiff(toolFiles);
-        if (fileDiff) hasDiff = true;
-      }
       const writtenCount = await processor.writeAiFiles(toolFiles);
       totalCount += writtenCount;
+      if (writtenCount > 0) hasDiff = true;
       if (config.getDelete()) {
         const existingToolFiles = await processor.loadToolFiles({ forDeletion: true });
-        if (isPreviewMode) {
-          const orphanDiff = await detectOrphanFileDiff(existingToolFiles, toolFiles);
-          if (orphanDiff) hasDiff = true;
-        }
-        await processor.removeOrphanAiFiles(existingToolFiles, toolFiles);
+        const orphanCount = await processor.removeOrphanAiFiles(existingToolFiles, toolFiles);
+        if (orphanCount > 0) hasDiff = true;
       }
     }
   }
@@ -14838,19 +14860,13 @@ async function generateCommandsCore(params) {
       });
       const rulesyncFiles = await processor.loadRulesyncFiles();
       const toolFiles = await processor.convertRulesyncFilesToToolFiles(rulesyncFiles);
-      if (isPreviewMode) {
-        const fileDiff = await detectFileDiff(toolFiles);
-        if (fileDiff) hasDiff = true;
-      }
       const writtenCount = await processor.writeAiFiles(toolFiles);
       totalCount += writtenCount;
+      if (writtenCount > 0) hasDiff = true;
       if (config.getDelete()) {
         const existingToolFiles = await processor.loadToolFiles({ forDeletion: true });
-        if (isPreviewMode) {
-          const orphanDiff = await detectOrphanFileDiff(existingToolFiles, toolFiles);
-          if (orphanDiff) hasDiff = true;
-        }
-        await processor.removeOrphanAiFiles(existingToolFiles, toolFiles);
+        const orphanCount = await processor.removeOrphanAiFiles(existingToolFiles, toolFiles);
+        if (orphanCount > 0) hasDiff = true;
       }
     }
   }
@@ -14881,19 +14897,13 @@ async function generateSubagentsCore(params) {
       });
       const rulesyncFiles = await processor.loadRulesyncFiles();
       const toolFiles = await processor.convertRulesyncFilesToToolFiles(rulesyncFiles);
-      if (isPreviewMode) {
-        const fileDiff = await detectFileDiff(toolFiles);
-        if (fileDiff) hasDiff = true;
-      }
       const writtenCount = await processor.writeAiFiles(toolFiles);
       totalCount += writtenCount;
+      if (writtenCount > 0) hasDiff = true;
       if (config.getDelete()) {
         const existingToolFiles = await processor.loadToolFiles({ forDeletion: true });
-        if (isPreviewMode) {
-          const orphanDiff = await detectOrphanFileDiff(existingToolFiles, toolFiles);
-          if (orphanDiff) hasDiff = true;
-        }
-        await processor.removeOrphanAiFiles(existingToolFiles, toolFiles);
+        const orphanCount = await processor.removeOrphanAiFiles(existingToolFiles, toolFiles);
+        if (orphanCount > 0) hasDiff = true;
       }
     }
   }
@@ -14930,19 +14940,13 @@ async function generateSkillsCore(params) {
         }
       }
       const toolDirs = await processor.convertRulesyncDirsToToolDirs(rulesyncDirs);
-      if (isPreviewMode) {
-        const dirDiff = await detectDirDiff(toolDirs);
-        if (dirDiff) hasDiff = true;
-      }
       const writtenCount = await processor.writeAiDirs(toolDirs);
       totalCount += writtenCount;
+      if (writtenCount > 0) hasDiff = true;
       if (config.getDelete()) {
         const existingToolDirs = await processor.loadToolDirsToDelete();
-        if (isPreviewMode) {
-          const orphanDiff = await detectOrphanDirDiff(existingToolDirs, toolDirs);
-          if (orphanDiff) hasDiff = true;
-        }
-        await processor.removeOrphanAiDirs(existingToolDirs, toolDirs);
+        const orphanCount = await processor.removeOrphanAiDirs(existingToolDirs, toolDirs);
+        if (orphanCount > 0) hasDiff = true;
       }
     }
   }
@@ -14972,77 +14976,24 @@ async function generateHooksCore(params) {
       if (rulesyncFiles.length === 0) {
         if (config.getDelete()) {
           const existingToolFiles = await processor.loadToolFiles({ forDeletion: true });
-          if (isPreviewMode && existingToolFiles.length > 0) {
-            hasDiff = true;
-          }
-          await processor.removeOrphanAiFiles(existingToolFiles, []);
+          const orphanCount = await processor.removeOrphanAiFiles(existingToolFiles, []);
+          if (orphanCount > 0) hasDiff = true;
         }
         continue;
       }
       const toolFiles = await processor.convertRulesyncFilesToToolFiles(rulesyncFiles);
-      if (isPreviewMode) {
-        const fileDiff = await detectFileDiff(toolFiles);
-        if (fileDiff) hasDiff = true;
-      }
       const writtenCount = await processor.writeAiFiles(toolFiles);
       totalCount += writtenCount;
+      if (writtenCount > 0) hasDiff = true;
       if (config.getDelete()) {
         const existingToolFiles = await processor.loadToolFiles({ forDeletion: true });
-        if (isPreviewMode) {
-          const orphanDiff = await detectOrphanFileDiff(existingToolFiles, toolFiles);
-          if (orphanDiff) hasDiff = true;
-        }
-        await processor.removeOrphanAiFiles(existingToolFiles, toolFiles);
+        const orphanCount = await processor.removeOrphanAiFiles(existingToolFiles, toolFiles);
+        if (orphanCount > 0) hasDiff = true;
       }
     }
   }
   return { count: totalCount, hasDiff };
 }
-async function detectFileDiff(aiFiles) {
-  for (const aiFile of aiFiles) {
-    const filePath = aiFile.getFilePath();
-    const newContent = addTrailingNewline(aiFile.getFileContent());
-    const existingContent = await readFileContentOrNull(filePath);
-    if (existingContent !== newContent) {
-      return true;
-    }
-  }
-  return false;
-}
-async function detectOrphanFileDiff(existingFiles, generatedFiles) {
-  const generatedPaths = new Set(generatedFiles.map((f) => f.getFilePath()));
-  const orphanFiles = existingFiles.filter((f) => !generatedPaths.has(f.getFilePath()));
-  return orphanFiles.length > 0;
-}
-async function detectDirDiff(aiDirs) {
-  for (const aiDir of aiDirs) {
-    const mainFile = aiDir.getMainFile();
-    if (mainFile) {
-      const mainFilePath = (0, import_node_path109.join)(aiDir.getDirPath(), mainFile.name);
-      const newContent = addTrailingNewline(
-        stringifyFrontmatter(mainFile.body, mainFile.frontmatter)
-      );
-      const existingContent = await readFileContentOrNull(mainFilePath);
-      if (existingContent !== newContent) {
-        return true;
-      }
-    }
-    for (const file of aiDir.getOtherFiles()) {
-      const filePath = (0, import_node_path109.join)(aiDir.getDirPath(), file.relativeFilePathToDirPath);
-      const newContent = addTrailingNewline(file.fileBuffer.toString("utf-8"));
-      const existingContent = await readFileContentOrNull(filePath);
-      if (existingContent !== newContent) {
-        return true;
-      }
-    }
-  }
-  return false;
-}
-async function detectOrphanDirDiff(existingDirs, generatedDirs) {
-  const generatedPaths = new Set(generatedDirs.map((d) => d.getDirPath()));
-  const orphanDirs = existingDirs.filter((d) => !generatedPaths.has(d.getDirPath()));
-  return orphanDirs.length > 0;
-}
 
 // src/utils/result.ts
 function calculateTotalCount(result) {
@@ -15054,9 +15005,9 @@ function logFeatureResult(params) {
   const { count, featureName, isPreview, modePrefix } = params;
   if (count > 0) {
     if (isPreview) {
-      logger.info(`${modePrefix} Would generate ${count} ${featureName}`);
+      logger.info(`${modePrefix} Would write ${count} ${featureName}`);
     } else {
-      logger.success(`Generated ${count} ${featureName}`);
+      logger.success(`Written ${count} ${featureName}`);
     }
   }
 }
@@ -15151,7 +15102,7 @@ async function generateCommand(options) {
   const totalGenerated = calculateTotalCount(result);
   if (totalGenerated === 0) {
     const enabledFeatures = features.join(", ");
-    logger.warn(`\u26A0\uFE0F  No files generated for enabled features: ${enabledFeatures}`);
+    logger.info(`\u2713 All files are up to date (${enabledFeatures})`);
     return;
   }
   const parts = [];
@@ -15163,11 +15114,9 @@ async function generateCommand(options) {
   if (result.skillsCount > 0) parts.push(`${result.skillsCount} skills`);
   if (result.hooksCount > 0) parts.push(`${result.hooksCount} hooks`);
   if (isPreview) {
-    logger.info(
-      `${modePrefix} Would generate ${totalGenerated} file(s) total (${parts.join(" + ")})`
-    );
+    logger.info(`${modePrefix} Would write ${totalGenerated} file(s) total (${parts.join(" + ")})`);
   } else {
-    logger.success(`\u{1F389} All done! Generated ${totalGenerated} file(s) total (${parts.join(" + ")})`);
+    logger.success(`\u{1F389} All done! Written ${totalGenerated} file(s) total (${parts.join(" + ")})`);
   }
   if (check) {
     if (result.hasDiff) {
@@ -17593,7 +17542,7 @@ async function updateCommand(currentVersion, options) {
 }
 
 // src/cli/index.ts
-var getVersion = () => "6.6.3";
+var getVersion = () => "6.7.1";
 var main = async () => {
   const program = new import_commander.Command();
   const version = getVersion();

package/dist/index.js

@@ -298,16 +298,22 @@ var FeatureProcessor = class {
    * Returns the number of files written.
    */
   async writeAiFiles(aiFiles) {
+    let changedCount = 0;
     for (const aiFile of aiFiles) {
       const filePath = aiFile.getFilePath();
+      const contentWithNewline = addTrailingNewline(aiFile.getFileContent());
+      const existingContent = await readFileContentOrNull(filePath);
+      if (existingContent === contentWithNewline) {
+        continue;
+      }
       if (this.dryRun) {
         logger.info(`[DRY RUN] Would write: ${filePath}`);
       } else {
-        const contentWithNewline = addTrailingNewline(aiFile.getFileContent());
         await writeFileContent(filePath, contentWithNewline);
       }
+      changedCount++;
     }
-    return aiFiles.length;
+    return changedCount;
   }
   async removeAiFiles(aiFiles) {
     for (const aiFile of aiFiles) {
@@ -329,6 +335,7 @@ var FeatureProcessor = class {
         await removeFile(filePath);
       }
     }
+    return orphanFiles.length;
   }
 };
 
@@ -5422,7 +5429,7 @@ var OpencodeMcp = class _OpencodeMcp extends ToolMcp {
   static getSettablePaths({ global } = {}) {
     if (global) {
       return {
-        relativeDirPath: ".",
+        relativeDirPath: join47(".config", "opencode"),
         relativeFilePath: "opencode.json"
       };
     }
@@ -6399,37 +6406,71 @@ var DirFeatureProcessor = class {
   /**
    * Once converted to rulesync/tool dirs, write them to the filesystem.
    * Returns the number of directories written.
+   *
+   * Note: This method uses directory-level change detection. If any file within
+   * a directory has changed, ALL files in that directory are rewritten. This is
+   * an intentional design decision to ensure consistency within directory units.
    */
   async writeAiDirs(aiDirs) {
+    let changedCount = 0;
     for (const aiDir of aiDirs) {
       const dirPath = aiDir.getDirPath();
+      let dirHasChanges = false;
+      const mainFile = aiDir.getMainFile();
+      let mainFileContent;
+      if (mainFile) {
+        const mainFilePath = join55(dirPath, mainFile.name);
+        const content = stringifyFrontmatter(mainFile.body, mainFile.frontmatter);
+        mainFileContent = addTrailingNewline(content);
+        const existingContent = await readFileContentOrNull(mainFilePath);
+        if (existingContent !== mainFileContent) {
+          dirHasChanges = true;
+        }
+      }
+      const otherFiles = aiDir.getOtherFiles();
+      const otherFileContents = [];
+      for (const file of otherFiles) {
+        const contentWithNewline = addTrailingNewline(file.fileBuffer.toString("utf-8"));
+        otherFileContents.push(contentWithNewline);
+        if (!dirHasChanges) {
+          const filePath = join55(dirPath, file.relativeFilePathToDirPath);
+          const existingContent = await readFileContentOrNull(filePath);
+          if (existingContent !== contentWithNewline) {
+            dirHasChanges = true;
+          }
+        }
+      }
+      if (!dirHasChanges) {
+        continue;
+      }
       if (this.dryRun) {
         logger.info(`[DRY RUN] Would create directory: ${dirPath}`);
-        const mainFile = aiDir.getMainFile();
         if (mainFile) {
           logger.info(`[DRY RUN] Would write: ${join55(dirPath, mainFile.name)}`);
         }
-        for (const file of aiDir.getOtherFiles()) {
+        for (const file of otherFiles) {
           logger.info(`[DRY RUN] Would write: ${join55(dirPath, file.relativeFilePathToDirPath)}`);
         }
       } else {
         await ensureDir(dirPath);
-        const mainFile = aiDir.getMainFile();
-        if (mainFile) {
+        if (mainFile && mainFileContent) {
           const mainFilePath = join55(dirPath, mainFile.name);
-          const content = stringifyFrontmatter(mainFile.body, mainFile.frontmatter);
-          const contentWithNewline = addTrailingNewline(content);
-          await writeFileContent(mainFilePath, contentWithNewline);
+          await writeFileContent(mainFilePath, mainFileContent);
         }
-        const otherFiles = aiDir.getOtherFiles();
-        for (const file of otherFiles) {
+        for (const [i, file] of otherFiles.entries()) {
           const filePath = join55(dirPath, file.relativeFilePathToDirPath);
-          const contentWithNewline = addTrailingNewline(file.fileBuffer.toString("utf-8"));
-          await writeFileContent(filePath, contentWithNewline);
+          const content = otherFileContents[i];
+          if (content === void 0) {
+            throw new Error(
+              `Internal error: content for file ${file.relativeFilePathToDirPath} is undefined. This indicates a synchronization issue between otherFiles and otherFileContents arrays.`
+            );
+          }
+          await writeFileContent(filePath, content);
         }
       }
+      changedCount++;
     }
-    return aiDirs.length;
+    return changedCount;
   }
   async removeAiDirs(aiDirs) {
     for (const aiDir of aiDirs) {
@@ -6451,6 +6492,7 @@ var DirFeatureProcessor = class {
         await removeDirectory(dirPath);
       }
     }
+    return orphanDirs.length;
   }
 };
 
@@ -14678,19 +14720,13 @@ async function generateRulesCore(params) {
       });
       const rulesyncFiles = await processor.loadRulesyncFiles();
       const toolFiles = await processor.convertRulesyncFilesToToolFiles(rulesyncFiles);
-      if (isPreviewMode) {
-        const fileDiff = await detectFileDiff(toolFiles);
-        if (fileDiff) hasDiff = true;
-      }
       const writtenCount = await processor.writeAiFiles(toolFiles);
       totalCount += writtenCount;
+      if (writtenCount > 0) hasDiff = true;
       if (config.getDelete()) {
         const existingToolFiles = await processor.loadToolFiles({ forDeletion: true });
-        if (isPreviewMode) {
-          const orphanDiff = await detectOrphanFileDiff(existingToolFiles, toolFiles);
-          if (orphanDiff) hasDiff = true;
-        }
-        await processor.removeOrphanAiFiles(existingToolFiles, toolFiles);
+        const orphanCount = await processor.removeOrphanAiFiles(existingToolFiles, toolFiles);
+        if (orphanCount > 0) hasDiff = true;
       }
     }
   }
@@ -14718,26 +14754,18 @@ async function generateIgnoreCore(params) {
         const rulesyncFiles = await processor.loadRulesyncFiles();
         if (rulesyncFiles.length > 0) {
           const toolFiles = await processor.convertRulesyncFilesToToolFiles(rulesyncFiles);
-          if (isPreviewMode) {
-            const fileDiff = await detectFileDiff(toolFiles);
-            if (fileDiff) hasDiff = true;
-          }
           const writtenCount = await processor.writeAiFiles(toolFiles);
           totalCount += writtenCount;
+          if (writtenCount > 0) hasDiff = true;
           if (config.getDelete()) {
             const existingToolFiles = await processor.loadToolFiles({ forDeletion: true });
-            if (isPreviewMode) {
-              const orphanDiff = await detectOrphanFileDiff(existingToolFiles, toolFiles);
-              if (orphanDiff) hasDiff = true;
-            }
-            await processor.removeOrphanAiFiles(existingToolFiles, toolFiles);
+            const orphanCount = await processor.removeOrphanAiFiles(existingToolFiles, toolFiles);
+            if (orphanCount > 0) hasDiff = true;
           }
         } else if (config.getDelete()) {
           const existingToolFiles = await processor.loadToolFiles({ forDeletion: true });
-          if (isPreviewMode && existingToolFiles.length > 0) {
-            hasDiff = true;
-          }
-          await processor.removeOrphanAiFiles(existingToolFiles, []);
+          const orphanCount = await processor.removeOrphanAiFiles(existingToolFiles, []);
+          if (orphanCount > 0) hasDiff = true;
         }
       } catch (error) {
         logger.warn(
@@ -14772,19 +14800,13 @@ async function generateMcpCore(params) {
       });
       const rulesyncFiles = await processor.loadRulesyncFiles();
       const toolFiles = await processor.convertRulesyncFilesToToolFiles(rulesyncFiles);
-      if (isPreviewMode) {
-        const fileDiff = await detectFileDiff(toolFiles);
-        if (fileDiff) hasDiff = true;
-      }
       const writtenCount = await processor.writeAiFiles(toolFiles);
       totalCount += writtenCount;
+      if (writtenCount > 0) hasDiff = true;
       if (config.getDelete()) {
         const existingToolFiles = await processor.loadToolFiles({ forDeletion: true });
-        if (isPreviewMode) {
-          const orphanDiff = await detectOrphanFileDiff(existingToolFiles, toolFiles);
-          if (orphanDiff) hasDiff = true;
-        }
-        await processor.removeOrphanAiFiles(existingToolFiles, toolFiles);
+        const orphanCount = await processor.removeOrphanAiFiles(existingToolFiles, toolFiles);
+        if (orphanCount > 0) hasDiff = true;
       }
     }
   }
@@ -14815,19 +14837,13 @@ async function generateCommandsCore(params) {
       });
       const rulesyncFiles = await processor.loadRulesyncFiles();
       const toolFiles = await processor.convertRulesyncFilesToToolFiles(rulesyncFiles);
-      if (isPreviewMode) {
-        const fileDiff = await detectFileDiff(toolFiles);
-        if (fileDiff) hasDiff = true;
-      }
       const writtenCount = await processor.writeAiFiles(toolFiles);
       totalCount += writtenCount;
+      if (writtenCount > 0) hasDiff = true;
       if (config.getDelete()) {
         const existingToolFiles = await processor.loadToolFiles({ forDeletion: true });
-        if (isPreviewMode) {
-          const orphanDiff = await detectOrphanFileDiff(existingToolFiles, toolFiles);
-          if (orphanDiff) hasDiff = true;
-        }
-        await processor.removeOrphanAiFiles(existingToolFiles, toolFiles);
+        const orphanCount = await processor.removeOrphanAiFiles(existingToolFiles, toolFiles);
+        if (orphanCount > 0) hasDiff = true;
       }
     }
   }
@@ -14858,19 +14874,13 @@ async function generateSubagentsCore(params) {
       });
       const rulesyncFiles = await processor.loadRulesyncFiles();
       const toolFiles = await processor.convertRulesyncFilesToToolFiles(rulesyncFiles);
-      if (isPreviewMode) {
-        const fileDiff = await detectFileDiff(toolFiles);
-        if (fileDiff) hasDiff = true;
-      }
       const writtenCount = await processor.writeAiFiles(toolFiles);
       totalCount += writtenCount;
+      if (writtenCount > 0) hasDiff = true;
       if (config.getDelete()) {
         const existingToolFiles = await processor.loadToolFiles({ forDeletion: true });
-        if (isPreviewMode) {
-          const orphanDiff = await detectOrphanFileDiff(existingToolFiles, toolFiles);
-          if (orphanDiff) hasDiff = true;
-        }
-        await processor.removeOrphanAiFiles(existingToolFiles, toolFiles);
+        const orphanCount = await processor.removeOrphanAiFiles(existingToolFiles, toolFiles);
+        if (orphanCount > 0) hasDiff = true;
       }
     }
   }
@@ -14907,19 +14917,13 @@ async function generateSkillsCore(params) {
         }
       }
       const toolDirs = await processor.convertRulesyncDirsToToolDirs(rulesyncDirs);
-      if (isPreviewMode) {
-        const dirDiff = await detectDirDiff(toolDirs);
-        if (dirDiff) hasDiff = true;
-      }
       const writtenCount = await processor.writeAiDirs(toolDirs);
       totalCount += writtenCount;
+      if (writtenCount > 0) hasDiff = true;
       if (config.getDelete()) {
         const existingToolDirs = await processor.loadToolDirsToDelete();
-        if (isPreviewMode) {
-          const orphanDiff = await detectOrphanDirDiff(existingToolDirs, toolDirs);
-          if (orphanDiff) hasDiff = true;
-        }
-        await processor.removeOrphanAiDirs(existingToolDirs, toolDirs);
+        const orphanCount = await processor.removeOrphanAiDirs(existingToolDirs, toolDirs);
+        if (orphanCount > 0) hasDiff = true;
       }
     }
   }
@@ -14949,77 +14953,24 @@ async function generateHooksCore(params) {
       if (rulesyncFiles.length === 0) {
         if (config.getDelete()) {
           const existingToolFiles = await processor.loadToolFiles({ forDeletion: true });
-          if (isPreviewMode && existingToolFiles.length > 0) {
-            hasDiff = true;
-          }
-          await processor.removeOrphanAiFiles(existingToolFiles, []);
+          const orphanCount = await processor.removeOrphanAiFiles(existingToolFiles, []);
+          if (orphanCount > 0) hasDiff = true;
         }
         continue;
       }
       const toolFiles = await processor.convertRulesyncFilesToToolFiles(rulesyncFiles);
-      if (isPreviewMode) {
-        const fileDiff = await detectFileDiff(toolFiles);
-        if (fileDiff) hasDiff = true;
-      }
       const writtenCount = await processor.writeAiFiles(toolFiles);
       totalCount += writtenCount;
+      if (writtenCount > 0) hasDiff = true;
       if (config.getDelete()) {
         const existingToolFiles = await processor.loadToolFiles({ forDeletion: true });
-        if (isPreviewMode) {
-          const orphanDiff = await detectOrphanFileDiff(existingToolFiles, toolFiles);
-          if (orphanDiff) hasDiff = true;
-        }
-        await processor.removeOrphanAiFiles(existingToolFiles, toolFiles);
+        const orphanCount = await processor.removeOrphanAiFiles(existingToolFiles, toolFiles);
+        if (orphanCount > 0) hasDiff = true;
       }
     }
   }
   return { count: totalCount, hasDiff };
 }
-async function detectFileDiff(aiFiles) {
-  for (const aiFile of aiFiles) {
-    const filePath = aiFile.getFilePath();
-    const newContent = addTrailingNewline(aiFile.getFileContent());
-    const existingContent = await readFileContentOrNull(filePath);
-    if (existingContent !== newContent) {
-      return true;
-    }
-  }
-  return false;
-}
-async function detectOrphanFileDiff(existingFiles, generatedFiles) {
-  const generatedPaths = new Set(generatedFiles.map((f) => f.getFilePath()));
-  const orphanFiles = existingFiles.filter((f) => !generatedPaths.has(f.getFilePath()));
-  return orphanFiles.length > 0;
-}
-async function detectDirDiff(aiDirs) {
-  for (const aiDir of aiDirs) {
-    const mainFile = aiDir.getMainFile();
-    if (mainFile) {
-      const mainFilePath = join108(aiDir.getDirPath(), mainFile.name);
-      const newContent = addTrailingNewline(
-        stringifyFrontmatter(mainFile.body, mainFile.frontmatter)
-      );
-      const existingContent = await readFileContentOrNull(mainFilePath);
-      if (existingContent !== newContent) {
-        return true;
-      }
-    }
-    for (const file of aiDir.getOtherFiles()) {
-      const filePath = join108(aiDir.getDirPath(), file.relativeFilePathToDirPath);
-      const newContent = addTrailingNewline(file.fileBuffer.toString("utf-8"));
-      const existingContent = await readFileContentOrNull(filePath);
-      if (existingContent !== newContent) {
-        return true;
-      }
-    }
-  }
-  return false;
-}
-async function detectOrphanDirDiff(existingDirs, generatedDirs) {
-  const generatedPaths = new Set(generatedDirs.map((d) => d.getDirPath()));
-  const orphanDirs = existingDirs.filter((d) => !generatedPaths.has(d.getDirPath()));
-  return orphanDirs.length > 0;
-}
 
 // src/utils/result.ts
 function calculateTotalCount(result) {
@@ -15031,9 +14982,9 @@ function logFeatureResult(params) {
   const { count, featureName, isPreview, modePrefix } = params;
   if (count > 0) {
     if (isPreview) {
-      logger.info(`${modePrefix} Would generate ${count} ${featureName}`);
+      logger.info(`${modePrefix} Would write ${count} ${featureName}`);
     } else {
-      logger.success(`Generated ${count} ${featureName}`);
+      logger.success(`Written ${count} ${featureName}`);
     }
   }
 }
@@ -15128,7 +15079,7 @@ async function generateCommand(options) {
   const totalGenerated = calculateTotalCount(result);
   if (totalGenerated === 0) {
     const enabledFeatures = features.join(", ");
-    logger.warn(`\u26A0\uFE0F  No files generated for enabled features: ${enabledFeatures}`);
+    logger.info(`\u2713 All files are up to date (${enabledFeatures})`);
     return;
   }
   const parts = [];
@@ -15140,11 +15091,9 @@ async function generateCommand(options) {
   if (result.skillsCount > 0) parts.push(`${result.skillsCount} skills`);
   if (result.hooksCount > 0) parts.push(`${result.hooksCount} hooks`);
   if (isPreview) {
-    logger.info(
-      `${modePrefix} Would generate ${totalGenerated} file(s) total (${parts.join(" + ")})`
-    );
+    logger.info(`${modePrefix} Would write ${totalGenerated} file(s) total (${parts.join(" + ")})`);
   } else {
-    logger.success(`\u{1F389} All done! Generated ${totalGenerated} file(s) total (${parts.join(" + ")})`);
+    logger.success(`\u{1F389} All done! Written ${totalGenerated} file(s) total (${parts.join(" + ")})`);
   }
   if (check) {
     if (result.hasDiff) {
@@ -17570,7 +17519,7 @@ async function updateCommand(currentVersion, options) {
 }
 
 // src/cli/index.ts
-var getVersion = () => "6.6.3";
+var getVersion = () => "6.7.1";
 var main = async () => {
   const program = new Command();
   const version = getVersion();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rulesync",
-  "version": "6.6.3",
+  "version": "6.7.1",
   "description": "Unified AI rules management CLI tool that generates configuration files for various AI development tools",
   "keywords": [
     "ai",