rulesync 5.9.1 → 6.1.0

package/README.md

@@ -272,6 +272,30 @@ Example:
 }
 ```
 
+### Local Configuration
+
+Rulesync supports a local configuration file (`rulesync.local.jsonc`) for machine-specific or developer-specific settings. This file is automatically added to `.gitignore` by `rulesync gitignore` and should not be committed to the repository.
+
+**Configuration Priority** (highest to lowest):
+
+1. CLI options
+2. `rulesync.local.jsonc`
+3. `rulesync.jsonc`
+4. Default values
+
+Example usage:
+
+```jsonc
+// rulesync.local.jsonc (not committed to git)
+{
+  "$schema": "https://raw.githubusercontent.com/dyoshikawa/rulesync/refs/heads/main/config-schema.json",
+  // Override targets for local development
+  "targets": ["claudecode"],
+  // Enable verbose output for debugging
+  "verbose": true,
+}
+```
+
 ### Target Order and File Conflicts
 
 When multiple targets write to the same output file, **the last target in the array wins**. This is the "last-wins" behavior.

package/dist/index.cjs

@@ -118,14 +118,29 @@ var logger = new Logger();
 
 // src/config/config-resolver.ts
 var import_jsonc_parser = require("jsonc-parser");
-var import_node_path2 = require("path");
+var import_node_path3 = require("path");
+
+// src/constants/rulesync-paths.ts
+var import_node_path = require("path");
+var RULESYNC_CONFIG_RELATIVE_FILE_PATH = "rulesync.jsonc";
+var RULESYNC_LOCAL_CONFIG_RELATIVE_FILE_PATH = "rulesync.local.jsonc";
+var RULESYNC_RELATIVE_DIR_PATH = ".rulesync";
+var RULESYNC_RULES_RELATIVE_DIR_PATH = (0, import_node_path.join)(RULESYNC_RELATIVE_DIR_PATH, "rules");
+var RULESYNC_COMMANDS_RELATIVE_DIR_PATH = (0, import_node_path.join)(RULESYNC_RELATIVE_DIR_PATH, "commands");
+var RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH = (0, import_node_path.join)(RULESYNC_RELATIVE_DIR_PATH, "subagents");
+var RULESYNC_MCP_RELATIVE_FILE_PATH = (0, import_node_path.join)(RULESYNC_RELATIVE_DIR_PATH, "mcp.json");
+var RULESYNC_AIIGNORE_FILE_NAME = ".aiignore";
+var RULESYNC_AIIGNORE_RELATIVE_FILE_PATH = (0, import_node_path.join)(RULESYNC_RELATIVE_DIR_PATH, ".aiignore");
+var RULESYNC_IGNORE_RELATIVE_FILE_PATH = ".rulesyncignore";
+var RULESYNC_OVERVIEW_FILE_NAME = "overview.md";
+var RULESYNC_SKILLS_RELATIVE_DIR_PATH = (0, import_node_path.join)(RULESYNC_RELATIVE_DIR_PATH, "skills");
 
 // src/utils/file.ts
 var import_es_toolkit = require("es-toolkit");
 var import_globby = require("globby");
 var import_promises = require("fs/promises");
 var import_node_os = __toESM(require("os"), 1);
-var import_node_path = require("path");
+var import_node_path2 = require("path");
 async function ensureDir(dirPath) {
   try {
     await (0, import_promises.stat)(dirPath);
@@ -137,7 +152,7 @@ async function readOrInitializeFileContent(filePath, initialContent = "") {
   if (await fileExists(filePath)) {
     return await readFileContent(filePath);
   } else {
-    await ensureDir((0, import_node_path.dirname)(filePath));
+    await ensureDir((0, import_node_path2.dirname)(filePath));
     await writeFileContent(filePath, initialContent);
     return initialContent;
   }
@@ -150,16 +165,16 @@ function checkPathTraversal({
   if (segments.includes("..")) {
     throw new Error(`Path traversal detected: ${relativePath}`);
   }
-  const resolved = (0, import_node_path.resolve)(intendedRootDir, relativePath);
-  const rel = (0, import_node_path.relative)(intendedRootDir, resolved);
-  if (rel.startsWith("..") || (0, import_node_path.resolve)(resolved) !== resolved) {
+  const resolved = (0, import_node_path2.resolve)(intendedRootDir, relativePath);
+  const rel = (0, import_node_path2.relative)(intendedRootDir, resolved);
+  if (rel.startsWith("..") || (0, import_node_path2.resolve)(resolved) !== resolved) {
     throw new Error(`Path traversal detected: ${relativePath}`);
   }
 }
 function resolvePath(relativePath, baseDir) {
   if (!baseDir) return relativePath;
   checkPathTraversal({ relativePath, intendedRootDir: baseDir });
-  return (0, import_node_path.resolve)(baseDir, relativePath);
+  return (0, import_node_path2.resolve)(baseDir, relativePath);
 }
 async function directoryExists(dirPath) {
   try {
@@ -185,7 +200,7 @@ function addTrailingNewline(content) {
 }
 async function writeFileContent(filepath, content) {
   logger.debug(`Writing file: ${filepath}`);
-  await ensureDir((0, import_node_path.dirname)(filepath));
+  await ensureDir((0, import_node_path2.dirname)(filepath));
   await (0, import_promises.writeFile)(filepath, content, "utf-8");
 }
 async function fileExists(filepath) {
@@ -413,7 +428,7 @@ var getDefaults = () => ({
   verbose: false,
   delete: false,
   baseDirs: [process.cwd()],
-  configPath: "rulesync.jsonc",
+  configPath: RULESYNC_CONFIG_RELATIVE_FILE_PATH,
   global: false,
   silent: false,
   simulateCommands: false,
@@ -421,6 +436,36 @@ var getDefaults = () => ({
   simulateSkills: false,
   modularMcp: false
 });
+var loadConfigFromFile = async (filePath) => {
+  if (!await fileExists(filePath)) {
+    return {};
+  }
+  try {
+    const fileContent = await readFileContent(filePath);
+    const jsonData = (0, import_jsonc_parser.parse)(fileContent);
+    const parsed = ConfigFileSchema.parse(jsonData);
+    const { $schema: _schema, ...configParams } = parsed;
+    return configParams;
+  } catch (error) {
+    logger.error(`Failed to load config file "${filePath}": ${formatError(error)}`);
+    throw error;
+  }
+};
+var mergeConfigs = (baseConfig, localConfig) => {
+  return {
+    targets: localConfig.targets ?? baseConfig.targets,
+    features: localConfig.features ?? baseConfig.features,
+    verbose: localConfig.verbose ?? baseConfig.verbose,
+    delete: localConfig.delete ?? baseConfig.delete,
+    baseDirs: localConfig.baseDirs ?? baseConfig.baseDirs,
+    global: localConfig.global ?? baseConfig.global,
+    silent: localConfig.silent ?? baseConfig.silent,
+    simulateCommands: localConfig.simulateCommands ?? baseConfig.simulateCommands,
+    simulateSubagents: localConfig.simulateSubagents ?? baseConfig.simulateSubagents,
+    simulateSkills: localConfig.simulateSkills ?? baseConfig.simulateSkills,
+    modularMcp: localConfig.modularMcp ?? baseConfig.modularMcp
+  };
+};
 var ConfigResolver = class {
   static async resolve({
     targets,
@@ -437,19 +482,11 @@ var ConfigResolver = class {
     modularMcp
   }) {
     const validatedConfigPath = resolvePath(configPath, process.cwd());
-    let configByFile = {};
-    if (await fileExists(validatedConfigPath)) {
-      try {
-        const fileContent = await readFileContent(validatedConfigPath);
-        const jsonData = (0, import_jsonc_parser.parse)(fileContent);
-        const parsed = ConfigFileSchema.parse(jsonData);
-        const { $schema: _schema, ...configParams2 } = parsed;
-        configByFile = configParams2;
-      } catch (error) {
-        logger.error(`Failed to load config file: ${formatError(error)}`);
-        throw error;
-      }
-    }
+    const baseConfig = await loadConfigFromFile(validatedConfigPath);
+    const configDir = (0, import_node_path3.dirname)(validatedConfigPath);
+    const localConfigPath = (0, import_node_path3.join)(configDir, RULESYNC_LOCAL_CONFIG_RELATIVE_FILE_PATH);
+    const localConfig = await loadConfigFromFile(localConfigPath);
+    const configByFile = mergeConfigs(baseConfig, localConfig);
     const resolvedGlobal = global ?? configByFile.global ?? getDefaults().global;
     const resolvedSimulateCommands = simulateCommands ?? configByFile.simulateCommands ?? getDefaults().simulateCommands;
     const resolvedSimulateSubagents = simulateSubagents ?? configByFile.simulateSubagents ?? getDefaults().simulateSubagents;
@@ -480,7 +517,7 @@ function getBaseDirsInLightOfGlobal({
   if (global) {
     return [getHomeDirectory()];
   }
-  const resolvedBaseDirs = baseDirs.map((baseDir) => (0, import_node_path2.resolve)(baseDir));
+  const resolvedBaseDirs = baseDirs.map((baseDir) => (0, import_node_path3.resolve)(baseDir));
   resolvedBaseDirs.forEach((baseDir) => {
     validateBaseDir(baseDir);
   });
@@ -491,20 +528,6 @@ function getBaseDirsInLightOfGlobal({
 var import_es_toolkit4 = require("es-toolkit");
 var import_node_path98 = require("path");
 
-// src/constants/rulesync-paths.ts
-var import_node_path3 = require("path");
-var RULESYNC_CONFIG_RELATIVE_FILE_PATH = "rulesync.jsonc";
-var RULESYNC_RELATIVE_DIR_PATH = ".rulesync";
-var RULESYNC_RULES_RELATIVE_DIR_PATH = (0, import_node_path3.join)(RULESYNC_RELATIVE_DIR_PATH, "rules");
-var RULESYNC_COMMANDS_RELATIVE_DIR_PATH = (0, import_node_path3.join)(RULESYNC_RELATIVE_DIR_PATH, "commands");
-var RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH = (0, import_node_path3.join)(RULESYNC_RELATIVE_DIR_PATH, "subagents");
-var RULESYNC_MCP_RELATIVE_FILE_PATH = (0, import_node_path3.join)(RULESYNC_RELATIVE_DIR_PATH, "mcp.json");
-var RULESYNC_AIIGNORE_FILE_NAME = ".aiignore";
-var RULESYNC_AIIGNORE_RELATIVE_FILE_PATH = (0, import_node_path3.join)(RULESYNC_RELATIVE_DIR_PATH, ".aiignore");
-var RULESYNC_IGNORE_RELATIVE_FILE_PATH = ".rulesyncignore";
-var RULESYNC_OVERVIEW_FILE_NAME = "overview.md";
-var RULESYNC_SKILLS_RELATIVE_DIR_PATH = (0, import_node_path3.join)(RULESYNC_RELATIVE_DIR_PATH, "skills");
-
 // src/features/commands/commands-processor.ts
 var import_node_path19 = require("path");
 var import_mini12 = require("zod/mini");
@@ -938,9 +961,6 @@ var RulesyncFile = class extends AiFile {
   static async fromFile(_params) {
     throw new Error("Please implement this method in the subclass.");
   }
-  static async fromFileLegacy(_params) {
-    throw new Error("Please implement this method in the subclass.");
-  }
 };
 
 // src/features/commands/rulesync-command.ts
@@ -4321,6 +4341,46 @@ var CopilotMcp = class _CopilotMcp extends ToolMcp {
 
 // src/features/mcp/cursor-mcp.ts
 var import_node_path39 = require("path");
+var CURSOR_ENV_VAR_PATTERN = /\$\{env:([^}]+)\}/g;
+function isMcpServers(value) {
+  return value !== void 0 && value !== null && typeof value === "object";
+}
+function convertEnvFromCursorFormat(mcpServers) {
+  return Object.fromEntries(
+    Object.entries(mcpServers).map(([name, config]) => [
+      name,
+      {
+        ...config,
+        ...config.env && {
+          env: Object.fromEntries(
+            Object.entries(config.env).map(([k, v]) => [
+              k,
+              v.replace(CURSOR_ENV_VAR_PATTERN, "${$1}")
+            ])
+          )
+        }
+      }
+    ])
+  );
+}
+function convertEnvToCursorFormat(mcpServers) {
+  return Object.fromEntries(
+    Object.entries(mcpServers).map(([name, config]) => [
+      name,
+      {
+        ...config,
+        ...config.env && {
+          env: Object.fromEntries(
+            Object.entries(config.env).map(([k, v]) => [
+              k,
+              v.replace(/\$\{(?!env:)([^}:]+)\}/g, "${env:$1}")
+            ])
+          )
+        }
+      }
+    ])
+  );
+}
 var CursorMcp = class _CursorMcp extends ToolMcp {
   json;
   constructor(params) {
@@ -4361,8 +4421,10 @@ var CursorMcp = class _CursorMcp extends ToolMcp {
     validate = true
   }) {
     const json = rulesyncMcp.getJson();
+    const mcpServers = isMcpServers(json.mcpServers) ? json.mcpServers : {};
+    const transformedServers = convertEnvToCursorFormat(mcpServers);
     const cursorConfig = {
-      mcpServers: json.mcpServers || {}
+      mcpServers: transformedServers
     };
     const fileContent = JSON.stringify(cursorConfig, null, 2);
     return new _CursorMcp({
@@ -4374,11 +4436,17 @@ var CursorMcp = class _CursorMcp extends ToolMcp {
     });
   }
   toRulesyncMcp() {
+    const mcpServers = isMcpServers(this.json.mcpServers) ? this.json.mcpServers : {};
+    const transformedServers = convertEnvFromCursorFormat(mcpServers);
+    const transformedJson = {
+      ...this.json,
+      mcpServers: transformedServers
+    };
     return new RulesyncMcp({
       baseDir: this.baseDir,
       relativeDirPath: this.relativeDirPath,
       relativeFilePath: "rulesync.mcp.json",
-      fileContent: this.fileContent,
+      fileContent: JSON.stringify(transformedJson),
       validate: true
     });
   }
@@ -9025,47 +9093,6 @@ var RulesyncRule = class _RulesyncRule extends RulesyncFile {
       };
     }
   }
-  static async fromFileLegacy({
-    relativeFilePath,
-    validate = true
-  }) {
-    const legacyPath = (0, import_node_path75.join)(
-      process.cwd(),
-      this.getSettablePaths().legacy.relativeDirPath,
-      relativeFilePath
-    );
-    const recommendedPath = (0, import_node_path75.join)(
-      this.getSettablePaths().recommended.relativeDirPath,
-      relativeFilePath
-    );
-    logger.warn(
-      `\u26A0\uFE0F  Using deprecated path "${legacyPath}". Please migrate to "${recommendedPath}"`
-    );
-    const fileContent = await readFileContent(legacyPath);
-    const { frontmatter, body: content } = parseFrontmatter(fileContent);
-    const result = RulesyncRuleFrontmatterSchema.safeParse(frontmatter);
-    if (!result.success) {
-      throw new Error(`Invalid frontmatter in ${legacyPath}: ${formatError(result.error)}`);
-    }
-    const validatedFrontmatter = {
-      root: result.data.root ?? false,
-      localRoot: result.data.localRoot ?? false,
-      targets: result.data.targets ?? ["*"],
-      description: result.data.description ?? "",
-      globs: result.data.globs ?? [],
-      agentsmd: result.data.agentsmd,
-      cursor: result.data.cursor
-    };
-    const filename = (0, import_node_path75.basename)(legacyPath);
-    return new _RulesyncRule({
-      baseDir: process.cwd(),
-      relativeDirPath: this.getSettablePaths().recommended.relativeDirPath,
-      relativeFilePath: filename,
-      frontmatter: validatedFrontmatter,
-      body: content.trim(),
-      validate
-    });
-  }
   static async fromFile({
     relativeFilePath,
     validate = true
@@ -9090,11 +9117,10 @@ var RulesyncRule = class _RulesyncRule extends RulesyncFile {
       agentsmd: result.data.agentsmd,
       cursor: result.data.cursor
     };
-    const filename = (0, import_node_path75.basename)(filePath);
     return new _RulesyncRule({
       baseDir: process.cwd(),
       relativeDirPath: this.getSettablePaths().recommended.relativeDirPath,
-      relativeFilePath: filename,
+      relativeFilePath,
       frontmatter: validatedFrontmatter,
       body: content.trim(),
       validate
@@ -9927,7 +9953,7 @@ var ClaudecodeRule = class _ClaudecodeRule extends ToolRule {
     }
     return {
       root: {
-        relativeDirPath: ".claude",
+        relativeDirPath: ".",
         relativeFilePath: "CLAUDE.md"
       },
       nonRoot: {
@@ -10634,7 +10660,7 @@ var CursorRule = class _CursorRule extends ToolRule {
     return new _CursorRule({
       baseDir,
       relativeDirPath: this.getSettablePaths().nonRoot.relativeDirPath,
-      relativeFilePath: (0, import_node_path86.basename)(relativeFilePath),
+      relativeFilePath,
       frontmatter: result.data,
       body: content.trim(),
       validate
@@ -11803,7 +11829,7 @@ var RulesProcessor = class extends FeatureProcessor {
   }
   /**
    * Handle localRoot rule generation based on tool target.
-   * - Claude Code: generates `.claude/CLAUDE.local.md`
+   * - Claude Code: generates `./CLAUDE.local.md`
    * - Claude Code Legacy: generates `./CLAUDE.local.md`
    * - Other tools: appends content to the root file with one blank line separator
    */
@@ -11904,10 +11930,17 @@ var RulesProcessor = class extends FeatureProcessor {
    * Load and parse rulesync rule files from .rulesync/rules/ directory
    */
   async loadRulesyncFiles() {
-    const files = await findFilesByGlobs((0, import_node_path97.join)(RULESYNC_RULES_RELATIVE_DIR_PATH, "*.md"));
+    const rulesyncBaseDir = (0, import_node_path97.join)(this.baseDir, RULESYNC_RULES_RELATIVE_DIR_PATH);
+    const files = await findFilesByGlobs((0, import_node_path97.join)(rulesyncBaseDir, "**", "*.md"));
     logger.debug(`Found ${files.length} rulesync files`);
     const rulesyncRules = await Promise.all(
-      files.map((file) => RulesyncRule.fromFile({ relativeFilePath: (0, import_node_path97.basename)(file) }))
+      files.map((file) => {
+        const relativeFilePath = (0, import_node_path97.relative)(rulesyncBaseDir, file);
+        checkPathTraversal({ relativePath: relativeFilePath, intendedRootDir: rulesyncBaseDir });
+        return RulesyncRule.fromFile({
+          relativeFilePath
+        });
+      })
     );
     const rootRules = rulesyncRules.filter((rule) => rule.getFrontmatter().root);
     if (rootRules.length > 1) {
@@ -11941,13 +11974,6 @@ var RulesProcessor = class extends FeatureProcessor {
     }
     return rulesyncRules;
   }
-  async loadRulesyncFilesLegacy() {
-    const legacyFiles = await findFilesByGlobs((0, import_node_path97.join)(RULESYNC_RELATIVE_DIR_PATH, "*.md"));
-    logger.debug(`Found ${legacyFiles.length} legacy rulesync files`);
-    return Promise.all(
-      legacyFiles.map((file) => RulesyncRule.fromFileLegacy({ relativeFilePath: (0, import_node_path97.basename)(file) }))
-    );
-  }
   /**
    * Implementation of abstract method from FeatureProcessor
    * Load tool-specific rule configurations and parse them into ToolRule instances
@@ -12017,27 +12043,35 @@ var RulesProcessor = class extends FeatureProcessor {
         if (!settablePaths.nonRoot) {
           return [];
         }
+        const nonRootBaseDir = (0, import_node_path97.join)(this.baseDir, settablePaths.nonRoot.relativeDirPath);
         const nonRootFilePaths = await findFilesByGlobs(
-          (0, import_node_path97.join)(this.baseDir, settablePaths.nonRoot.relativeDirPath, `*.${factory.meta.extension}`)
+          (0, import_node_path97.join)(nonRootBaseDir, "**", `*.${factory.meta.extension}`)
         );
         if (forDeletion) {
-          return nonRootFilePaths.map(
-            (filePath) => factory.class.forDeletion({
+          return nonRootFilePaths.map((filePath) => {
+            const relativeFilePath = (0, import_node_path97.relative)(nonRootBaseDir, filePath);
+            checkPathTraversal({
+              relativePath: relativeFilePath,
+              intendedRootDir: nonRootBaseDir
+            });
+            return factory.class.forDeletion({
               baseDir: this.baseDir,
               relativeDirPath: settablePaths.nonRoot?.relativeDirPath ?? ".",
-              relativeFilePath: (0, import_node_path97.basename)(filePath),
+              relativeFilePath,
               global: this.global
-            })
-          ).filter((rule) => rule.isDeletable());
+            });
+          }).filter((rule) => rule.isDeletable());
         }
         return await Promise.all(
-          nonRootFilePaths.map(
-            (filePath) => factory.class.fromFile({
+          nonRootFilePaths.map((filePath) => {
+            const relativeFilePath = (0, import_node_path97.relative)(nonRootBaseDir, filePath);
+            checkPathTraversal({ relativePath: relativeFilePath, intendedRootDir: nonRootBaseDir });
+            return factory.class.fromFile({
               baseDir: this.baseDir,
-              relativeFilePath: (0, import_node_path97.basename)(filePath),
+              relativeFilePath,
               global: this.global
-            })
-          )
+            });
+          })
         );
       })();
       logger.debug(`Found ${nonRootToolRules.length} non-root tool rule files`);
@@ -12548,6 +12582,7 @@ var RULESYNC_IGNORE_ENTRIES = [
   // Others
   "**/modular-mcp.json",
   ".rulesync/rules/*.local.md",
+  "rulesync.local.jsonc",
   "!.rulesync/.aiignore"
 ];
 var isRulesyncHeader = (line) => {
@@ -12829,6 +12864,7 @@ async function createConfigFile() {
         baseDirs: ["."],
         delete: true,
         verbose: false,
+        silent: false,
         global: false,
         simulateCommands: false,
         simulateSubagents: false,
@@ -14244,7 +14280,7 @@ async function mcpCommand({ version }) {
 }
 
 // src/cli/index.ts
-var getVersion = () => "5.9.1";
+var getVersion = () => "6.1.0";
 var main = async () => {
   const program = new import_commander.Command();
   const version = getVersion();