rulesync 1.2.6 → 2.0.0

package/dist/index.js

@@ -16,7 +16,18 @@ var RulesyncFeaturesSchema = z.array(z.enum(ALL_FEATURES_WITH_WILDCARD));
 
 // src/utils/logger.ts
 import { consola } from "consola";
+
+// src/utils/vitest.ts
 var isEnvTest = process.env.NODE_ENV === "test";
+function getVitestWorkerId() {
+  const vitestWorkerId = process.env.VITEST_WORKER_ID;
+  if (!vitestWorkerId) {
+    throw new Error("VITEST_WORKER_ID is not set");
+  }
+  return vitestWorkerId;
+}
+
+// src/utils/logger.ts
 var Logger = class {
   _verbose = false;
   console = consola.withDefaults({
@@ -57,9 +68,17 @@ var Logger = class {
 };
 var logger = new Logger();
 
+// src/cli/commands/generate.ts
+import { intersection } from "es-toolkit";
+
+// src/commands/commands-processor.ts
+import { basename as basename10, join as join10 } from "path";
+import { z as z8 } from "zod/mini";
+
 // src/utils/file.ts
 import { globSync } from "fs";
-import { mkdir, mkdtemp, readdir, readFile, rm, stat, writeFile } from "fs/promises";
+import { mkdir, readdir, readFile, rm, stat, writeFile } from "fs/promises";
+import os from "os";
 import { basename, dirname, join, relative, resolve } from "path";
 async function ensureDir(dirPath) {
   try {
@@ -112,47 +131,32 @@ async function removeFile(filepath) {
     logger.warn(`Failed to remove file ${filepath}:`, error);
   }
 }
-
-// src/cli/commands/config.ts
-async function configCommand(options) {
-  if (options.init) {
-    await initConfig();
-    return;
+function getHomeDirectory() {
+  if (isEnvTest) {
+    return join("./tmp", "tests", "home", getVitestWorkerId());
   }
-  logger.info(`Please run \`rulesync config --init\` to create a new configuration file`);
+  return os.homedir();
 }
-async function initConfig() {
-  logger.info("Initializing configuration...");
-  if (await fileExists("rulesync.jsonc")) {
-    logger.error("rulesync.jsonc already exists");
-    process.exit(1);
+function validateBaseDir(baseDir) {
+  if (baseDir.trim() === "") {
+    throw new Error("baseDir cannot be an empty string");
+  }
+  if (baseDir.includes("..")) {
+    throw new Error(`baseDir cannot contain directory traversal (..): ${baseDir}`);
+  }
+  if (baseDir.startsWith("/")) {
+    throw new Error(`baseDir must be a relative path. Absolute path not allowed: ${baseDir}`);
+  }
+  if (/^[a-zA-Z]:[/\\]/.test(baseDir)) {
+    throw new Error(`baseDir must be a relative path. Absolute path not allowed: ${baseDir}`);
+  }
+  const normalized = resolve(".", baseDir);
+  const rel = relative(".", normalized);
+  if (rel.startsWith("..")) {
+    throw new Error(`baseDir cannot contain directory traversal (..): ${baseDir}`);
   }
-  await writeFileContent(
-    "rulesync.jsonc",
-    JSON.stringify(
-      {
-        targets: ["copilot", "cursor", "claudecode", "codexcli"],
-        features: ["rules", "ignore", "mcp", "commands", "subagents"],
-        baseDirs: ["."],
-        delete: true,
-        verbose: false,
-        experimentalSimulateCommands: false,
-        experimentalSimulateSubagents: false
-      },
-      null,
-      2
-    )
-  );
-  logger.success("Configuration file created successfully!");
 }
 
-// src/cli/commands/generate.ts
-import { intersection } from "es-toolkit";
-
-// src/commands/commands-processor.ts
-import { basename as basename10, join as join10 } from "path";
-import { z as z8 } from "zod/mini";
-
 // src/types/feature-processor.ts
 var FeatureProcessor = class {
   baseDir;
@@ -240,7 +244,7 @@ import { basename as basename2, join as join2 } from "path";
 import { z as z3 } from "zod/mini";
 
 // src/types/ai-file.ts
-import path from "path";
+import path, { relative as relative2, resolve as resolve2 } from "path";
 var AiFile = class {
   /**
    * @example "."
@@ -258,17 +262,23 @@ var AiFile = class {
    * Whole raw file content
    */
   fileContent;
+  /**
+   * @example true
+   */
+  global;
   constructor({
     baseDir = ".",
     relativeDirPath,
     relativeFilePath,
     fileContent,
-    validate = true
+    validate = true,
+    global = false
   }) {
     this.baseDir = baseDir;
     this.relativeDirPath = relativeDirPath;
     this.relativeFilePath = relativeFilePath;
     this.fileContent = fileContent;
+    this.global = global;
     if (validate) {
       const result = this.validate();
       if (!result.success) {
@@ -289,7 +299,16 @@ var AiFile = class {
     return this.relativeFilePath;
   }
   getFilePath() {
-    return path.join(this.baseDir, this.relativeDirPath, this.relativeFilePath);
+    const fullPath = path.join(this.baseDir, this.relativeDirPath, this.relativeFilePath);
+    const resolvedFull = resolve2(fullPath);
+    const resolvedBase = resolve2(this.baseDir);
+    const rel = relative2(resolvedBase, resolvedFull);
+    if (rel.startsWith("..") || path.isAbsolute(rel)) {
+      throw new Error(
+        `Path traversal detected: Final path escapes baseDir. baseDir="${this.baseDir}", relativeDirPath="${this.relativeDirPath}", relativeFilePath="${this.relativeFilePath}"`
+      );
+    }
+    return fullPath;
   }
   getFileContent() {
     return this.fileContent;
@@ -1319,6 +1338,7 @@ var CommandsProcessor = class extends FeatureProcessor {
 };
 
 // src/config/config-resolver.ts
+import { join as join11 } from "path";
 import { loadConfig } from "c12";
 
 // src/config/config.ts
@@ -1328,6 +1348,7 @@ var Config = class {
   features;
   verbose;
   delete;
+  experimentalGlobal;
   experimentalSimulateCommands;
   experimentalSimulateSubagents;
   constructor({
@@ -1336,6 +1357,7 @@ var Config = class {
     features,
     verbose,
     delete: isDelete,
+    experimentalGlobal,
     experimentalSimulateCommands,
     experimentalSimulateSubagents
   }) {
@@ -1344,6 +1366,7 @@ var Config = class {
     this.features = features;
     this.verbose = verbose;
     this.delete = isDelete;
+    this.experimentalGlobal = experimentalGlobal;
     this.experimentalSimulateCommands = experimentalSimulateCommands;
     this.experimentalSimulateSubagents = experimentalSimulateSubagents;
   }
@@ -1368,6 +1391,9 @@ var Config = class {
   getDelete() {
     return this.delete;
   }
+  getExperimentalGlobal() {
+    return this.experimentalGlobal;
+  }
   getExperimentalSimulateCommands() {
     return this.experimentalSimulateCommands;
   }
@@ -1384,6 +1410,7 @@ var defaults = {
   delete: false,
   baseDirs: ["."],
   configPath: "rulesync.jsonc",
+  experimentalGlobal: false,
   experimentalSimulateCommands: false,
   experimentalSimulateSubagents: false
 };
@@ -1395,16 +1422,21 @@ var ConfigResolver = class {
     delete: isDelete,
     baseDirs,
     configPath = defaults.configPath,
+    experimentalGlobal,
     experimentalSimulateCommands,
     experimentalSimulateSubagents
   }) {
-    if (!fileExists(configPath)) {
+    if (!await fileExists(configPath)) {
       return new Config({
         targets: targets ?? defaults.targets,
         features: features ?? defaults.features,
         verbose: verbose ?? defaults.verbose,
         delete: isDelete ?? defaults.delete,
-        baseDirs: baseDirs ?? defaults.baseDirs,
+        baseDirs: getBaseDirsInLightOfGlobal({
+          baseDirs: baseDirs ?? defaults.baseDirs,
+          global: experimentalGlobal ?? false
+        }),
+        experimentalGlobal: experimentalGlobal ?? defaults.experimentalGlobal,
         experimentalSimulateCommands: experimentalSimulateCommands ?? defaults.experimentalSimulateCommands,
         experimentalSimulateSubagents: experimentalSimulateSubagents ?? defaults.experimentalSimulateSubagents
       });
@@ -1426,19 +1458,38 @@ var ConfigResolver = class {
       features: features ?? configByFile.features ?? defaults.features,
       verbose: verbose ?? configByFile.verbose ?? defaults.verbose,
       delete: isDelete ?? configByFile.delete ?? defaults.delete,
-      baseDirs: baseDirs ?? configByFile.baseDirs ?? defaults.baseDirs,
+      baseDirs: getBaseDirsInLightOfGlobal({
+        baseDirs: baseDirs ?? configByFile.baseDirs ?? defaults.baseDirs,
+        global: experimentalGlobal ?? false
+      }),
+      experimentalGlobal: experimentalGlobal ?? configByFile.experimentalGlobal ?? defaults.experimentalGlobal,
       experimentalSimulateCommands: experimentalSimulateCommands ?? configByFile.experimentalSimulateCommands ?? defaults.experimentalSimulateCommands,
       experimentalSimulateSubagents: experimentalSimulateSubagents ?? configByFile.experimentalSimulateSubagents ?? defaults.experimentalSimulateSubagents
     };
     return new Config(configParams);
   }
 };
+function getBaseDirsInLightOfGlobal({
+  baseDirs,
+  global
+}) {
+  if (isEnvTest) {
+    return baseDirs.map((baseDir) => join11(".", baseDir));
+  }
+  if (global) {
+    return [getHomeDirectory()];
+  }
+  baseDirs.forEach((baseDir) => {
+    validateBaseDir(baseDir);
+  });
+  return baseDirs;
+}
 
 // src/ignore/ignore-processor.ts
 import { z as z9 } from "zod/mini";
 
 // src/ignore/amazonqcli-ignore.ts
-import { join as join11 } from "path";
+import { join as join12 } from "path";
 
 // src/types/tool-file.ts
 var ToolFile = class extends AiFile {
@@ -1546,7 +1597,7 @@ var AmazonqcliIgnore = class _AmazonqcliIgnore extends ToolIgnore {
     validate = true
   }) {
     const fileContent = await readFileContent(
-      join11(
+      join12(
         baseDir,
         this.getSettablePaths().relativeDirPath,
         this.getSettablePaths().relativeFilePath
@@ -1563,7 +1614,7 @@ var AmazonqcliIgnore = class _AmazonqcliIgnore extends ToolIgnore {
 };
 
 // src/ignore/augmentcode-ignore.ts
-import { join as join12 } from "path";
+import { join as join13 } from "path";
 var AugmentcodeIgnore = class _AugmentcodeIgnore extends ToolIgnore {
   static getSettablePaths() {
     return {
@@ -1601,7 +1652,7 @@ var AugmentcodeIgnore = class _AugmentcodeIgnore extends ToolIgnore {
     validate = true
   }) {
     const fileContent = await readFileContent(
-      join12(
+      join13(
         baseDir,
         this.getSettablePaths().relativeDirPath,
         this.getSettablePaths().relativeFilePath
@@ -1618,7 +1669,7 @@ var AugmentcodeIgnore = class _AugmentcodeIgnore extends ToolIgnore {
 };
 
 // src/ignore/claudecode-ignore.ts
-import { join as join13 } from "path";
+import { join as join14 } from "path";
 import { uniq } from "es-toolkit";
 var ClaudecodeIgnore = class _ClaudecodeIgnore extends ToolIgnore {
   constructor(params) {
@@ -1654,7 +1705,7 @@ var ClaudecodeIgnore = class _ClaudecodeIgnore extends ToolIgnore {
     const fileContent = rulesyncIgnore.getFileContent();
     const patterns = fileContent.split(/\r?\n|\r/).map((line) => line.trim()).filter((line) => line.length > 0 && !line.startsWith("#"));
     const deniedValues = patterns.map((pattern) => `Read(${pattern})`);
-    const filePath = join13(
+    const filePath = join14(
       baseDir,
       this.getSettablePaths().relativeDirPath,
       this.getSettablePaths().relativeFilePath
@@ -1682,7 +1733,7 @@ var ClaudecodeIgnore = class _ClaudecodeIgnore extends ToolIgnore {
     validate = true
   }) {
     const fileContent = await readFileContent(
-      join13(
+      join14(
         baseDir,
         this.getSettablePaths().relativeDirPath,
         this.getSettablePaths().relativeFilePath
@@ -1699,7 +1750,7 @@ var ClaudecodeIgnore = class _ClaudecodeIgnore extends ToolIgnore {
 };
 
 // src/ignore/cline-ignore.ts
-import { join as join14 } from "path";
+import { join as join15 } from "path";
 var ClineIgnore = class _ClineIgnore extends ToolIgnore {
   static getSettablePaths() {
     return {
@@ -1736,7 +1787,7 @@ var ClineIgnore = class _ClineIgnore extends ToolIgnore {
     validate = true
   }) {
     const fileContent = await readFileContent(
-      join14(
+      join15(
         baseDir,
         this.getSettablePaths().relativeDirPath,
         this.getSettablePaths().relativeFilePath
@@ -1753,7 +1804,7 @@ var ClineIgnore = class _ClineIgnore extends ToolIgnore {
 };
 
 // src/ignore/codexcli-ignore.ts
-import { join as join15 } from "path";
+import { join as join16 } from "path";
 var CodexcliIgnore = class _CodexcliIgnore extends ToolIgnore {
   static getSettablePaths() {
     return {
@@ -1783,7 +1834,7 @@ var CodexcliIgnore = class _CodexcliIgnore extends ToolIgnore {
     validate = true
   }) {
     const fileContent = await readFileContent(
-      join15(
+      join16(
         baseDir,
         this.getSettablePaths().relativeDirPath,
         this.getSettablePaths().relativeFilePath
@@ -1800,7 +1851,7 @@ var CodexcliIgnore = class _CodexcliIgnore extends ToolIgnore {
 };
 
 // src/ignore/cursor-ignore.ts
-import { join as join16 } from "path";
+import { join as join17 } from "path";
 var CursorIgnore = class _CursorIgnore extends ToolIgnore {
   static getSettablePaths() {
     return {
@@ -1833,7 +1884,7 @@ var CursorIgnore = class _CursorIgnore extends ToolIgnore {
     validate = true
   }) {
     const fileContent = await readFileContent(
-      join16(
+      join17(
         baseDir,
         this.getSettablePaths().relativeDirPath,
         this.getSettablePaths().relativeFilePath
@@ -1850,7 +1901,7 @@ var CursorIgnore = class _CursorIgnore extends ToolIgnore {
 };
 
 // src/ignore/geminicli-ignore.ts
-import { join as join17 } from "path";
+import { join as join18 } from "path";
 var GeminiCliIgnore = class _GeminiCliIgnore extends ToolIgnore {
   static getSettablePaths() {
     return {
@@ -1877,7 +1928,7 @@ var GeminiCliIgnore = class _GeminiCliIgnore extends ToolIgnore {
     validate = true
   }) {
     const fileContent = await readFileContent(
-      join17(
+      join18(
         baseDir,
         this.getSettablePaths().relativeDirPath,
         this.getSettablePaths().relativeFilePath
@@ -1894,7 +1945,7 @@ var GeminiCliIgnore = class _GeminiCliIgnore extends ToolIgnore {
 };
 
 // src/ignore/junie-ignore.ts
-import { join as join18 } from "path";
+import { join as join19 } from "path";
 var JunieIgnore = class _JunieIgnore extends ToolIgnore {
   static getSettablePaths() {
     return {
@@ -1921,7 +1972,7 @@ var JunieIgnore = class _JunieIgnore extends ToolIgnore {
     validate = true
   }) {
     const fileContent = await readFileContent(
-      join18(
+      join19(
         baseDir,
         this.getSettablePaths().relativeDirPath,
         this.getSettablePaths().relativeFilePath
@@ -1938,7 +1989,7 @@ var JunieIgnore = class _JunieIgnore extends ToolIgnore {
 };
 
 // src/ignore/kiro-ignore.ts
-import { join as join19 } from "path";
+import { join as join20 } from "path";
 var KiroIgnore = class _KiroIgnore extends ToolIgnore {
   static getSettablePaths() {
     return {
@@ -1965,7 +2016,7 @@ var KiroIgnore = class _KiroIgnore extends ToolIgnore {
     validate = true
   }) {
     const fileContent = await readFileContent(
-      join19(
+      join20(
         baseDir,
         this.getSettablePaths().relativeDirPath,
         this.getSettablePaths().relativeFilePath
@@ -1982,7 +2033,7 @@ var KiroIgnore = class _KiroIgnore extends ToolIgnore {
 };
 
 // src/ignore/qwencode-ignore.ts
-import { join as join20 } from "path";
+import { join as join21 } from "path";
 var QwencodeIgnore = class _QwencodeIgnore extends ToolIgnore {
   static getSettablePaths() {
     return {
@@ -2009,7 +2060,7 @@ var QwencodeIgnore = class _QwencodeIgnore extends ToolIgnore {
     validate = true
   }) {
     const fileContent = await readFileContent(
-      join20(
+      join21(
         baseDir,
         this.getSettablePaths().relativeDirPath,
         this.getSettablePaths().relativeFilePath
@@ -2026,7 +2077,7 @@ var QwencodeIgnore = class _QwencodeIgnore extends ToolIgnore {
 };
 
 // src/ignore/roo-ignore.ts
-import { join as join21 } from "path";
+import { join as join22 } from "path";
 var RooIgnore = class _RooIgnore extends ToolIgnore {
   static getSettablePaths() {
     return {
@@ -2053,7 +2104,7 @@ var RooIgnore = class _RooIgnore extends ToolIgnore {
     validate = true
   }) {
     const fileContent = await readFileContent(
-      join21(
+      join22(
         baseDir,
         this.getSettablePaths().relativeDirPath,
         this.getSettablePaths().relativeFilePath
@@ -2070,7 +2121,7 @@ var RooIgnore = class _RooIgnore extends ToolIgnore {
 };
 
 // src/ignore/windsurf-ignore.ts
-import { join as join22 } from "path";
+import { join as join23 } from "path";
 var WindsurfIgnore = class _WindsurfIgnore extends ToolIgnore {
   static getSettablePaths() {
     return {
@@ -2097,7 +2148,7 @@ var WindsurfIgnore = class _WindsurfIgnore extends ToolIgnore {
     validate = true
   }) {
     const fileContent = await readFileContent(
-      join22(
+      join23(
         baseDir,
         this.getSettablePaths().relativeDirPath,
         this.getSettablePaths().relativeFilePath
@@ -2307,10 +2358,10 @@ var IgnoreProcessor = class extends FeatureProcessor {
 import { z as z11 } from "zod/mini";
 
 // src/mcp/amazonqcli-mcp.ts
-import { join as join24 } from "path";
+import { join as join25 } from "path";
 
 // src/mcp/rulesync-mcp.ts
-import { join as join23 } from "path";
+import { join as join24 } from "path";
 import { z as z10 } from "zod/mini";
 var McpTransportTypeSchema = z10.enum(["stdio", "sse", "http"]);
 var McpServerBaseSchema = z10.object({
@@ -2361,7 +2412,7 @@ var RulesyncMcp = class _RulesyncMcp extends RulesyncFile {
   }
   static async fromFile({ validate = true }) {
     const fileContent = await readFileContent(
-      join23(this.getSettablePaths().relativeDirPath, this.getSettablePaths().relativeFilePath)
+      join24(this.getSettablePaths().relativeDirPath, this.getSettablePaths().relativeFilePath)
     );
     return new _RulesyncMcp({
       baseDir: ".",
@@ -2428,7 +2479,7 @@ var AmazonqcliMcp = class _AmazonqcliMcp extends ToolMcp {
     validate = true
   }) {
     const fileContent = await readFileContent(
-      join24(
+      join25(
         baseDir,
         this.getSettablePaths().relativeDirPath,
         this.getSettablePaths().relativeFilePath
@@ -2464,7 +2515,7 @@ var AmazonqcliMcp = class _AmazonqcliMcp extends ToolMcp {
 };
 
 // src/mcp/claudecode-mcp.ts
-import { join as join25 } from "path";
+import { join as join26 } from "path";
 var ClaudecodeMcp = class _ClaudecodeMcp extends ToolMcp {
   static getSettablePaths() {
     return {
@@ -2477,7 +2528,7 @@ var ClaudecodeMcp = class _ClaudecodeMcp extends ToolMcp {
     validate = true
   }) {
     const fileContent = await readFileContent(
-      join25(
+      join26(
         baseDir,
         this.getSettablePaths().relativeDirPath,
         this.getSettablePaths().relativeFilePath
@@ -2513,7 +2564,7 @@ var ClaudecodeMcp = class _ClaudecodeMcp extends ToolMcp {
 };
 
 // src/mcp/cline-mcp.ts
-import { join as join26 } from "path";
+import { join as join27 } from "path";
 var ClineMcp = class _ClineMcp extends ToolMcp {
   static getSettablePaths() {
     return {
@@ -2526,7 +2577,7 @@ var ClineMcp = class _ClineMcp extends ToolMcp {
     validate = true
   }) {
     const fileContent = await readFileContent(
-      join26(
+      join27(
         baseDir,
         this.getSettablePaths().relativeDirPath,
         this.getSettablePaths().relativeFilePath
@@ -2562,7 +2613,7 @@ var ClineMcp = class _ClineMcp extends ToolMcp {
 };
 
 // src/mcp/copilot-mcp.ts
-import { join as join27 } from "path";
+import { join as join28 } from "path";
 var CopilotMcp = class _CopilotMcp extends ToolMcp {
   static getSettablePaths() {
     return {
@@ -2575,7 +2626,7 @@ var CopilotMcp = class _CopilotMcp extends ToolMcp {
     validate = true
   }) {
     const fileContent = await readFileContent(
-      join27(
+      join28(
         baseDir,
         this.getSettablePaths().relativeDirPath,
         this.getSettablePaths().relativeFilePath
@@ -2611,7 +2662,7 @@ var CopilotMcp = class _CopilotMcp extends ToolMcp {
 };
 
 // src/mcp/cursor-mcp.ts
-import { join as join28 } from "path";
+import { join as join29 } from "path";
 var CursorMcp = class _CursorMcp extends ToolMcp {
   static getSettablePaths() {
     return {
@@ -2624,7 +2675,7 @@ var CursorMcp = class _CursorMcp extends ToolMcp {
     validate = true
   }) {
     const fileContent = await readFileContent(
-      join28(
+      join29(
         baseDir,
         this.getSettablePaths().relativeDirPath,
         this.getSettablePaths().relativeFilePath
@@ -2671,7 +2722,7 @@ var CursorMcp = class _CursorMcp extends ToolMcp {
 };
 
 // src/mcp/roo-mcp.ts
-import { join as join29 } from "path";
+import { join as join30 } from "path";
 var RooMcp = class _RooMcp extends ToolMcp {
   static getSettablePaths() {
     return {
@@ -2684,7 +2735,7 @@ var RooMcp = class _RooMcp extends ToolMcp {
     validate = true
   }) {
     const fileContent = await readFileContent(
-      join29(
+      join30(
         baseDir,
         this.getSettablePaths().relativeDirPath,
         this.getSettablePaths().relativeFilePath
@@ -2895,14 +2946,6 @@ import { basename as basename16, join as join54 } from "path";
 import { XMLBuilder } from "fast-xml-parser";
 import { z as z20 } from "zod/mini";
 
-// src/constants/paths.ts
-import { join as join30 } from "path";
-var RULESYNC_DIR = ".rulesync";
-var RULESYNC_RULES_DIR = join30(".rulesync", "rules");
-var RULESYNC_RULES_DIR_LEGACY = ".rulesync";
-var RULESYNC_MCP_FILE = join30(".rulesync", ".mcp.json");
-var RULESYNC_SUBAGENTS_DIR = join30(".rulesync", "subagents");
-
 // src/subagents/simulated-subagent.ts
 import { basename as basename11, join as join31 } from "path";
 import { z as z12 } from "zod/mini";
@@ -3202,7 +3245,7 @@ var RulesyncSubagent = class _RulesyncSubagent extends RulesyncFile {
   static async fromFile({
     relativeFilePath
   }) {
-    const fileContent = await readFileContent(join32(RULESYNC_SUBAGENTS_DIR, relativeFilePath));
+    const fileContent = await readFileContent(join32(".rulesync/subagents", relativeFilePath));
     const { frontmatter, body: content } = parseFrontmatter(fileContent);
     const result = RulesyncSubagentFrontmatterSchema.safeParse(frontmatter);
     if (!result.success) {
@@ -3736,6 +3779,12 @@ var ToolRule = class extends ToolFile {
     this.description = description;
     this.globs = globs;
   }
+  static getSettablePaths() {
+    throw new Error("Please implement this method in the subclass.");
+  }
+  static getSettablePathsGlobal() {
+    throw new Error("Please implement this method in the subclass.");
+  }
   static async fromFile(_params) {
     throw new Error("Please implement this method in the subclass.");
   }
@@ -3747,16 +3796,32 @@ var ToolRule = class extends ToolFile {
     rulesyncRule,
     validate = true,
     rootPath = { relativeDirPath: ".", relativeFilePath: "AGENTS.md" },
-    nonRootPath = { relativeDirPath: ".agents/memories" }
+    nonRootPath
   }) {
     const fileContent = rulesyncRule.getBody();
+    const isRoot = rulesyncRule.getFrontmatter().root ?? false;
+    if (isRoot) {
+      return {
+        baseDir,
+        relativeDirPath: rootPath.relativeDirPath,
+        relativeFilePath: rootPath.relativeFilePath,
+        fileContent,
+        validate,
+        root: true,
+        description: rulesyncRule.getFrontmatter().description,
+        globs: rulesyncRule.getFrontmatter().globs
+      };
+    }
+    if (!nonRootPath) {
+      throw new Error("nonRootPath is not set");
+    }
     return {
       baseDir,
-      relativeDirPath: rulesyncRule.getFrontmatter().root ? rootPath.relativeDirPath : nonRootPath.relativeDirPath,
-      relativeFilePath: rulesyncRule.getFrontmatter().root ? rootPath.relativeFilePath : rulesyncRule.getRelativeFilePath(),
+      relativeDirPath: nonRootPath.relativeDirPath,
+      relativeFilePath: rulesyncRule.getRelativeFilePath(),
       fileContent,
       validate,
-      root: rulesyncRule.getFrontmatter().root ?? false,
+      root: false,
       description: rulesyncRule.getFrontmatter().description,
       globs: rulesyncRule.getFrontmatter().globs
     };
@@ -3785,7 +3850,7 @@ var ToolRule = class extends ToolFile {
   toRulesyncRuleDefault() {
     return new RulesyncRule({
       baseDir: this.getBaseDir(),
-      relativeDirPath: RULESYNC_RULES_DIR,
+      relativeDirPath: ".rulesync/rules",
       relativeFilePath: this.getRelativeFilePath(),
       frontmatter: {
         root: this.isRoot(),
@@ -3961,7 +4026,7 @@ var AugmentcodeLegacyRule = class _AugmentcodeLegacyRule extends ToolRule {
       baseDir: this.getBaseDir(),
       frontmatter: rulesyncFrontmatter,
       body: this.getFileContent(),
-      relativeDirPath: RULESYNC_RULES_DIR,
+      relativeDirPath: ".rulesync/rules",
       relativeFilePath: this.getRelativeFilePath(),
       validate: true
     });
@@ -4086,39 +4151,68 @@ var ClaudecodeRule = class _ClaudecodeRule extends ToolRule {
         relativeFilePath: "CLAUDE.md"
       },
       nonRoot: {
-        relativeDirPath: ".claude/memories"
+        relativeDirPath: join41(".claude", "memories")
+      }
+    };
+  }
+  static getSettablePathsGlobal() {
+    return {
+      root: {
+        relativeDirPath: ".claude",
+        relativeFilePath: "CLAUDE.md"
       }
     };
   }
   static async fromFile({
     baseDir = ".",
     relativeFilePath,
-    validate = true
+    validate = true,
+    global = false
   }) {
-    const isRoot = relativeFilePath === this.getSettablePaths().root.relativeFilePath;
-    const relativePath = isRoot ? this.getSettablePaths().root.relativeFilePath : join41(this.getSettablePaths().nonRoot.relativeDirPath, relativeFilePath);
+    const paths = global ? this.getSettablePathsGlobal() : this.getSettablePaths();
+    const isRoot = relativeFilePath === paths.root.relativeFilePath;
+    if (isRoot) {
+      const relativePath2 = paths.root.relativeFilePath;
+      const fileContent2 = await readFileContent(
+        join41(baseDir, paths.root.relativeDirPath, relativePath2)
+      );
+      return new _ClaudecodeRule({
+        baseDir,
+        relativeDirPath: paths.root.relativeDirPath,
+        relativeFilePath: paths.root.relativeFilePath,
+        fileContent: fileContent2,
+        validate,
+        root: true
+      });
+    }
+    if (!paths.nonRoot) {
+      throw new Error("nonRoot path is not set");
+    }
+    const relativePath = join41(paths.nonRoot.relativeDirPath, relativeFilePath);
     const fileContent = await readFileContent(join41(baseDir, relativePath));
     return new _ClaudecodeRule({
       baseDir,
-      relativeDirPath: isRoot ? this.getSettablePaths().root.relativeDirPath : this.getSettablePaths().nonRoot.relativeDirPath,
-      relativeFilePath: isRoot ? this.getSettablePaths().root.relativeFilePath : relativeFilePath,
+      relativeDirPath: paths.nonRoot.relativeDirPath,
+      relativeFilePath,
       fileContent,
       validate,
-      root: isRoot
+      root: false
     });
   }
   static fromRulesyncRule({
     baseDir = ".",
     rulesyncRule,
-    validate = true
+    validate = true,
+    global = false
   }) {
+    const paths = global ? this.getSettablePathsGlobal() : this.getSettablePaths();
     return new _ClaudecodeRule(
       this.buildToolRuleParamsDefault({
         baseDir,
         rulesyncRule,
         validate,
-        rootPath: this.getSettablePaths().root,
-        nonRootPath: this.getSettablePaths().nonRoot
+        rootPath: paths.root,
+        nonRootPath: paths.nonRoot
       })
     );
   }
@@ -4208,35 +4302,64 @@ var CodexcliRule = class _CodexcliRule extends ToolRule {
       }
     };
   }
+  static getSettablePathsGlobal() {
+    return {
+      root: {
+        relativeDirPath: ".codex",
+        relativeFilePath: "AGENTS.md"
+      }
+    };
+  }
   static async fromFile({
     baseDir = ".",
     relativeFilePath,
-    validate = true
+    validate = true,
+    global = false
   }) {
-    const isRoot = relativeFilePath === "AGENTS.md";
-    const relativePath = isRoot ? "AGENTS.md" : join43(this.getSettablePaths().nonRoot.relativeDirPath, relativeFilePath);
+    const paths = global ? this.getSettablePathsGlobal() : this.getSettablePaths();
+    const isRoot = relativeFilePath === paths.root.relativeFilePath;
+    if (isRoot) {
+      const relativePath2 = paths.root.relativeFilePath;
+      const fileContent2 = await readFileContent(
+        join43(baseDir, paths.root.relativeDirPath, relativePath2)
+      );
+      return new _CodexcliRule({
+        baseDir,
+        relativeDirPath: paths.root.relativeDirPath,
+        relativeFilePath: paths.root.relativeFilePath,
+        fileContent: fileContent2,
+        validate,
+        root: true
+      });
+    }
+    if (!paths.nonRoot) {
+      throw new Error("nonRoot path is not set");
+    }
+    const relativePath = join43(paths.nonRoot.relativeDirPath, relativeFilePath);
     const fileContent = await readFileContent(join43(baseDir, relativePath));
     return new _CodexcliRule({
       baseDir,
-      relativeDirPath: isRoot ? this.getSettablePaths().root.relativeDirPath : this.getSettablePaths().nonRoot.relativeDirPath,
-      relativeFilePath: isRoot ? "AGENTS.md" : relativeFilePath,
+      relativeDirPath: paths.nonRoot.relativeDirPath,
+      relativeFilePath,
       fileContent,
       validate,
-      root: isRoot
+      root: false
     });
   }
   static fromRulesyncRule({
     baseDir = ".",
     rulesyncRule,
-    validate = true
+    validate = true,
+    global = false
   }) {
+    const paths = global ? this.getSettablePathsGlobal() : this.getSettablePaths();
     return new _CodexcliRule(
       this.buildToolRuleParamsAgentsmd({
         baseDir,
         rulesyncRule,
         validate,
-        rootPath: this.getSettablePaths().root,
-        nonRootPath: this.getSettablePaths().nonRoot
+        rootPath: paths.root,
+        nonRootPath: paths.nonRoot
       })
     );
   }
@@ -4301,7 +4424,7 @@ var CopilotRule = class _CopilotRule extends ToolRule {
       baseDir: this.getBaseDir(),
       frontmatter: rulesyncFrontmatter,
       body: this.body,
-      relativeDirPath: RULESYNC_RULES_DIR,
+      relativeDirPath: ".rulesync/rules",
       relativeFilePath: this.getRelativeFilePath(),
       validate: true
     });
@@ -5084,18 +5207,22 @@ var rulesProcessorToolTargets = [
   "windsurf"
 ];
 var RulesProcessorToolTargetSchema = z20.enum(rulesProcessorToolTargets);
+var rulesProcessorToolTargetsGlobal = ["claudecode", "codexcli"];
 var RulesProcessor = class extends FeatureProcessor {
   toolTarget;
   simulateCommands;
   simulateSubagents;
+  global;
   constructor({
-    baseDir = process.cwd(),
+    baseDir = ".",
     toolTarget,
     simulateCommands = false,
-    simulateSubagents = false
+    simulateSubagents = false,
+    global = false
   }) {
     super({ baseDir });
     this.toolTarget = RulesProcessorToolTargetSchema.parse(toolTarget);
+    this.global = global;
     this.simulateCommands = simulateCommands;
     this.simulateSubagents = simulateSubagents;
   }
@@ -5148,7 +5275,8 @@ var RulesProcessor = class extends FeatureProcessor {
           return ClaudecodeRule.fromRulesyncRule({
             baseDir: this.baseDir,
             rulesyncRule,
-            validate: true
+            validate: true,
+            global: this.global
           });
         case "cline":
           if (!ClineRule.isTargetedByRulesyncRule(rulesyncRule)) {
@@ -5166,7 +5294,8 @@ var RulesProcessor = class extends FeatureProcessor {
           return CodexcliRule.fromRulesyncRule({
             baseDir: this.baseDir,
             rulesyncRule,
-            validate: true
+            validate: true,
+            global: this.global
           });
         case "copilot":
           if (!CopilotRule.isTargetedByRulesyncRule(rulesyncRule)) {
@@ -5404,14 +5533,28 @@ var RulesProcessor = class extends FeatureProcessor {
    * Load and parse rulesync rule files from .rulesync/rules/ directory
    */
   async loadRulesyncFiles() {
-    const files = await findFilesByGlobs(join54(RULESYNC_RULES_DIR, "*.md"));
+    const files = await findFilesByGlobs(join54(".rulesync/rules", "*.md"));
     logger.debug(`Found ${files.length} rulesync files`);
-    return Promise.all(
+    const rulesyncRules = await Promise.all(
       files.map((file) => RulesyncRule.fromFile({ relativeFilePath: basename16(file) }))
     );
+    const rootRules = rulesyncRules.filter((rule) => rule.getFrontmatter().root);
+    if (rootRules.length > 1) {
+      throw new Error("Multiple root rulesync rules found");
+    }
+    if (this.global) {
+      const nonRootRules = rulesyncRules.filter((rule) => !rule.getFrontmatter().root);
+      if (nonRootRules.length > 0) {
+        logger.warn(
+          `${nonRootRules.length} non-root rulesync rules found, but it's in global mode, so ignoring them`
+        );
+      }
+      return rootRules;
+    }
+    return rulesyncRules;
   }
   async loadRulesyncFilesLegacy() {
-    const legacyFiles = await findFilesByGlobs(join54(RULESYNC_RULES_DIR_LEGACY, "*.md"));
+    const legacyFiles = await findFilesByGlobs(join54(".rulesync", "*.md"));
     logger.debug(`Found ${legacyFiles.length} legacy rulesync files`);
     return Promise.all(
       legacyFiles.map((file) => RulesyncRule.fromFileLegacy({ relativeFilePath: basename16(file) }))
@@ -5484,7 +5627,8 @@ var RulesProcessor = class extends FeatureProcessor {
         rootFilePaths.map(
           (filePath) => root.fromFile({
             baseDir: this.baseDir,
-            relativeFilePath: basename16(filePath)
+            relativeFilePath: basename16(filePath),
+            global: this.global
           })
         )
       );
@@ -5501,7 +5645,8 @@ var RulesProcessor = class extends FeatureProcessor {
         nonRootFilePaths.map(
           (filePath) => nonRoot.fromFile({
             baseDir: this.baseDir,
-            relativeFilePath: basename16(filePath)
+            relativeFilePath: basename16(filePath),
+            global: this.global
           })
         )
       );
@@ -5590,18 +5735,20 @@ var RulesProcessor = class extends FeatureProcessor {
    * Load Claude Code rule configuration from CLAUDE.md file
    */
   async loadClaudecodeRules() {
-    const settablePaths = ClaudecodeRule.getSettablePaths();
-    return await this.loadToolRulesDefault({
+    const settablePaths = this.global ? ClaudecodeRule.getSettablePathsGlobal() : ClaudecodeRule.getSettablePaths();
+    return this.loadToolRulesDefault({
       root: {
         relativeDirPath: settablePaths.root.relativeDirPath,
         relativeFilePath: settablePaths.root.relativeFilePath,
         fromFile: (params) => ClaudecodeRule.fromFile(params)
       },
-      nonRoot: {
-        relativeDirPath: settablePaths.nonRoot.relativeDirPath,
-        fromFile: (params) => ClaudecodeRule.fromFile(params),
-        extension: "md"
-      }
+      ...settablePaths.nonRoot ? {
+        nonRoot: {
+          relativeDirPath: settablePaths.nonRoot.relativeDirPath,
+          fromFile: (params) => ClaudecodeRule.fromFile(params),
+          extension: "md"
+        }
+      } : {}
     });
   }
   /**
@@ -5621,18 +5768,20 @@ var RulesProcessor = class extends FeatureProcessor {
    * Load OpenAI Codex CLI rule configuration from AGENTS.md and .codex/memories/*.md files
    */
   async loadCodexcliRules() {
-    const settablePaths = CodexcliRule.getSettablePaths();
+    const settablePaths = this.global ? CodexcliRule.getSettablePathsGlobal() : CodexcliRule.getSettablePaths();
     return await this.loadToolRulesDefault({
       root: {
         relativeDirPath: settablePaths.root.relativeDirPath,
         relativeFilePath: settablePaths.root.relativeFilePath,
         fromFile: (params) => CodexcliRule.fromFile(params)
       },
-      nonRoot: {
-        relativeDirPath: settablePaths.nonRoot.relativeDirPath,
-        fromFile: (params) => CodexcliRule.fromFile(params),
-        extension: "md"
-      }
+      ...settablePaths.nonRoot ? {
+        nonRoot: {
+          relativeDirPath: settablePaths.nonRoot.relativeDirPath,
+          fromFile: (params) => CodexcliRule.fromFile(params),
+          extension: "md"
+        }
+      } : {}
     });
   }
   /**
@@ -5784,6 +5933,9 @@ var RulesProcessor = class extends FeatureProcessor {
   static getToolTargets() {
     return rulesProcessorToolTargets;
   }
+  static getToolTargetsGlobal() {
+    return rulesProcessorToolTargetsGlobal;
+  }
   generateXmlReferencesSection(toolRules) {
     const toolRulesWithoutRoot = toolRules.filter((rule) => !rule.isRoot());
     if (toolRulesWithoutRoot.length === 0) {
@@ -5888,52 +6040,76 @@ async function generateCommand(options) {
     process.exit(1);
   }
   logger.info(`Base directories: ${config.getBaseDirs().join(", ")}`);
+  const totalRulesOutputs = await generateRules(config);
+  const totalIgnoreOutputs = await generateIgnore(config);
+  const totalMcpOutputs = await generateMcp(config);
+  const totalCommandOutputs = await generateCommands(config);
+  const totalSubagentOutputs = await generateSubagents(config);
+  const totalGenerated = totalRulesOutputs + totalMcpOutputs + totalCommandOutputs + totalIgnoreOutputs + totalSubagentOutputs;
+  if (totalGenerated === 0) {
+    const enabledFeatures = config.getFeatures().join(", ");
+    logger.warn(`\u26A0\uFE0F  No files generated for enabled features: ${enabledFeatures}`);
+    return;
+  }
+  if (totalGenerated > 0) {
+    const parts = [];
+    if (totalRulesOutputs > 0) parts.push(`${totalRulesOutputs} rules`);
+    if (totalIgnoreOutputs > 0) parts.push(`${totalIgnoreOutputs} ignore files`);
+    if (totalMcpOutputs > 0) parts.push(`${totalMcpOutputs} MCP files`);
+    if (totalCommandOutputs > 0) parts.push(`${totalCommandOutputs} commands`);
+    if (totalSubagentOutputs > 0) parts.push(`${totalSubagentOutputs} subagents`);
+    logger.success(`\u{1F389} All done! Generated ${totalGenerated} file(s) total (${parts.join(" + ")})`);
+  }
+}
+async function generateRules(config) {
+  if (!config.getFeatures().includes("rules")) {
+    logger.debug("Skipping rule generation (not in --features)");
+    return 0;
+  }
   let totalRulesOutputs = 0;
-  if (config.getFeatures().includes("rules")) {
-    logger.info("Generating rule files...");
-    for (const baseDir of config.getBaseDirs()) {
-      for (const toolTarget of intersection(config.getTargets(), RulesProcessor.getToolTargets())) {
-        const processor = new RulesProcessor({
-          baseDir,
-          toolTarget,
-          simulateCommands: config.getExperimentalSimulateCommands(),
-          simulateSubagents: config.getExperimentalSimulateSubagents()
-        });
-        if (config.getDelete()) {
-          const oldToolFiles = await processor.loadToolFilesToDelete();
-          await processor.removeAiFiles(oldToolFiles);
-        }
-        let rulesyncFiles = await processor.loadRulesyncFiles();
-        if (rulesyncFiles.length === 0) {
-          rulesyncFiles = await processor.loadRulesyncFilesLegacy();
-        }
-        const toolFiles = await processor.convertRulesyncFilesToToolFiles(rulesyncFiles);
-        const writtenCount = await processor.writeAiFiles(toolFiles);
-        totalRulesOutputs += writtenCount;
-        logger.success(`Generated ${writtenCount} ${toolTarget} rule(s) in ${baseDir}`);
+  logger.info("Generating rule files...");
+  const toolTargets = config.getExperimentalGlobal() ? intersection(config.getTargets(), RulesProcessor.getToolTargetsGlobal()) : intersection(config.getTargets(), RulesProcessor.getToolTargets());
+  for (const baseDir of config.getBaseDirs()) {
+    for (const toolTarget of toolTargets) {
+      const processor = new RulesProcessor({
+        baseDir,
+        toolTarget,
+        global: config.getExperimentalGlobal(),
+        simulateCommands: config.getExperimentalSimulateCommands(),
+        simulateSubagents: config.getExperimentalSimulateSubagents()
+      });
+      if (config.getDelete()) {
+        const oldToolFiles = await processor.loadToolFilesToDelete();
+        await processor.removeAiFiles(oldToolFiles);
+      }
+      let rulesyncFiles = await processor.loadRulesyncFiles();
+      if (rulesyncFiles.length === 0) {
+        rulesyncFiles = await processor.loadRulesyncFilesLegacy();
       }
+      const toolFiles = await processor.convertRulesyncFilesToToolFiles(rulesyncFiles);
+      const writtenCount = await processor.writeAiFiles(toolFiles);
+      totalRulesOutputs += writtenCount;
+      logger.success(`Generated ${writtenCount} ${toolTarget} rule(s) in ${baseDir}`);
     }
-  } else {
-    logger.info("Skipping rule generation (not in --features)");
   }
-  let totalMcpOutputs = 0;
-  if (config.getFeatures().includes("mcp")) {
-    logger.info("Generating MCP files...");
-    const supportedMcpTargets = [
-      "amazonqcli",
-      "claudecode",
-      "cline",
-      "copilot",
-      "cursor",
-      "roo"
-    ];
-    const mcpSupportedTargets = config.getTargets().filter((target) => {
-      return supportedMcpTargets.some((supportedTarget) => supportedTarget === target);
-    });
+  return totalRulesOutputs;
+}
+async function generateIgnore(config) {
+  if (!config.getFeatures().includes("ignore")) {
+    logger.debug("Skipping ignore file generation (not in --features)");
+    return 0;
+  }
+  if (config.getExperimentalGlobal()) {
+    logger.debug("Skipping ignore file generation (not supported in global mode)");
+    return 0;
+  }
+  let totalIgnoreOutputs = 0;
+  logger.info("Generating ignore files...");
+  for (const toolTarget of intersection(config.getTargets(), IgnoreProcessor.getToolTargets())) {
     for (const baseDir of config.getBaseDirs()) {
-      for (const toolTarget of intersection(mcpSupportedTargets, McpProcessor.getToolTargets())) {
-        const processor = new McpProcessor({
-          baseDir,
+      try {
+        const processor = new IgnoreProcessor({
+          baseDir: baseDir === process.cwd() ? "." : baseDir,
           toolTarget
         });
         if (config.getDelete()) {
@@ -5941,117 +6117,133 @@ async function generateCommand(options) {
           await processor.removeAiFiles(oldToolFiles);
         }
         const rulesyncFiles = await processor.loadRulesyncFiles();
-        const toolFiles = await processor.convertRulesyncFilesToToolFiles(rulesyncFiles);
-        const writtenCount = await processor.writeAiFiles(toolFiles);
-        totalMcpOutputs += writtenCount;
-        logger.success(
-          `Generated ${writtenCount} ${toolTarget} MCP configuration(s) in ${baseDir}`
+        if (rulesyncFiles.length > 0) {
+          const toolFiles = await processor.convertRulesyncFilesToToolFiles(rulesyncFiles);
+          const writtenCount = await processor.writeAiFiles(toolFiles);
+          totalIgnoreOutputs += writtenCount;
+          logger.success(`Generated ${writtenCount} ${toolTarget} ignore file(s) in ${baseDir}`);
+        }
+      } catch (error) {
+        logger.warn(
+          `Failed to generate ${toolTarget} ignore files for ${baseDir}:`,
+          error instanceof Error ? error.message : String(error)
         );
+        continue;
       }
     }
-  } else {
-    logger.info("Skipping MCP configuration generation (not in --features)");
   }
-  let totalCommandOutputs = 0;
-  if (config.getFeatures().includes("commands")) {
-    logger.info("Generating command files...");
-    for (const baseDir of config.getBaseDirs()) {
-      for (const toolTarget of intersection(
-        config.getTargets(),
-        CommandsProcessor.getToolTargets({
-          includeSimulated: config.getExperimentalSimulateCommands()
-        })
-      )) {
-        const processor = new CommandsProcessor({
-          baseDir,
-          toolTarget
-        });
-        if (config.getDelete()) {
-          const oldToolFiles = await processor.loadToolFilesToDelete();
-          await processor.removeAiFiles(oldToolFiles);
-        }
-        const rulesyncFiles = await processor.loadRulesyncFiles();
-        const toolFiles = await processor.convertRulesyncFilesToToolFiles(rulesyncFiles);
-        const writtenCount = await processor.writeAiFiles(toolFiles);
-        totalCommandOutputs += writtenCount;
-        logger.success(`Generated ${writtenCount} ${toolTarget} command(s) in ${baseDir}`);
+  return totalIgnoreOutputs;
+}
+async function generateMcp(config) {
+  if (!config.getFeatures().includes("mcp")) {
+    logger.debug("Skipping MCP configuration generation (not in --features)");
+    return 0;
+  }
+  if (config.getExperimentalGlobal()) {
+    logger.debug("Skipping MCP configuration generation (not supported in global mode)");
+    return 0;
+  }
+  let totalMcpOutputs = 0;
+  logger.info("Generating MCP files...");
+  const supportedMcpTargets = [
+    "amazonqcli",
+    "claudecode",
+    "cline",
+    "copilot",
+    "cursor",
+    "roo"
+  ];
+  const mcpSupportedTargets = config.getTargets().filter((target) => {
+    return supportedMcpTargets.some((supportedTarget) => supportedTarget === target);
+  });
+  for (const baseDir of config.getBaseDirs()) {
+    for (const toolTarget of intersection(mcpSupportedTargets, McpProcessor.getToolTargets())) {
+      const processor = new McpProcessor({
+        baseDir,
+        toolTarget
+      });
+      if (config.getDelete()) {
+        const oldToolFiles = await processor.loadToolFilesToDelete();
+        await processor.removeAiFiles(oldToolFiles);
       }
+      const rulesyncFiles = await processor.loadRulesyncFiles();
+      const toolFiles = await processor.convertRulesyncFilesToToolFiles(rulesyncFiles);
+      const writtenCount = await processor.writeAiFiles(toolFiles);
+      totalMcpOutputs += writtenCount;
+      logger.success(`Generated ${writtenCount} ${toolTarget} MCP configuration(s) in ${baseDir}`);
     }
-  } else {
-    logger.info("Skipping command file generation (not in --features)");
   }
-  let totalIgnoreOutputs = 0;
-  if (config.getFeatures().includes("ignore")) {
-    logger.info("Generating ignore files...");
-    for (const toolTarget of intersection(config.getTargets(), IgnoreProcessor.getToolTargets())) {
-      for (const baseDir of config.getBaseDirs()) {
-        try {
-          const processor = new IgnoreProcessor({
-            baseDir: baseDir === process.cwd() ? "." : baseDir,
-            toolTarget
-          });
-          if (config.getDelete()) {
-            const oldToolFiles = await processor.loadToolFilesToDelete();
-            await processor.removeAiFiles(oldToolFiles);
-          }
-          const rulesyncFiles = await processor.loadRulesyncFiles();
-          if (rulesyncFiles.length > 0) {
-            const toolFiles = await processor.convertRulesyncFilesToToolFiles(rulesyncFiles);
-            const writtenCount = await processor.writeAiFiles(toolFiles);
-            totalIgnoreOutputs += writtenCount;
-            logger.success(`Generated ${writtenCount} ${toolTarget} ignore file(s) in ${baseDir}`);
-          }
-        } catch (error) {
-          logger.warn(
-            `Failed to generate ${toolTarget} ignore files for ${baseDir}:`,
-            error instanceof Error ? error.message : String(error)
-          );
-          continue;
-        }
+  return totalMcpOutputs;
+}
+async function generateCommands(config) {
+  if (!config.getFeatures().includes("commands")) {
+    logger.debug("Skipping command file generation (not in --features)");
+    return 0;
+  }
+  if (config.getExperimentalGlobal()) {
+    logger.debug("Skipping command file generation (not supported in global mode)");
+    return 0;
+  }
+  let totalCommandOutputs = 0;
+  logger.info("Generating command files...");
+  for (const baseDir of config.getBaseDirs()) {
+    for (const toolTarget of intersection(
+      config.getTargets(),
+      CommandsProcessor.getToolTargets({
+        includeSimulated: config.getExperimentalSimulateCommands()
+      })
+    )) {
+      const processor = new CommandsProcessor({
+        baseDir,
+        toolTarget
+      });
+      if (config.getDelete()) {
+        const oldToolFiles = await processor.loadToolFilesToDelete();
+        await processor.removeAiFiles(oldToolFiles);
       }
+      const rulesyncFiles = await processor.loadRulesyncFiles();
+      const toolFiles = await processor.convertRulesyncFilesToToolFiles(rulesyncFiles);
+      const writtenCount = await processor.writeAiFiles(toolFiles);
+      totalCommandOutputs += writtenCount;
+      logger.success(`Generated ${writtenCount} ${toolTarget} command(s) in ${baseDir}`);
     }
   }
+  return totalCommandOutputs;
+}
+async function generateSubagents(config) {
+  if (!config.getFeatures().includes("subagents")) {
+    logger.debug("Skipping subagent file generation (not in --features)");
+    return 0;
+  }
+  if (config.getExperimentalGlobal()) {
+    logger.debug("Skipping subagent file generation (not supported in global mode)");
+    return 0;
+  }
   let totalSubagentOutputs = 0;
-  if (config.getFeatures().includes("subagents")) {
-    logger.info("Generating subagent files...");
-    for (const baseDir of config.getBaseDirs()) {
-      for (const toolTarget of intersection(
-        config.getTargets(),
-        SubagentsProcessor.getToolTargets({
-          includeSimulated: config.getExperimentalSimulateSubagents()
-        })
-      )) {
-        const processor = new SubagentsProcessor({
-          baseDir,
-          toolTarget
-        });
-        if (config.getDelete()) {
-          const oldToolFiles = await processor.loadToolFilesToDelete();
-          await processor.removeAiFiles(oldToolFiles);
-        }
-        const rulesyncFiles = await processor.loadRulesyncFiles();
-        const toolFiles = await processor.convertRulesyncFilesToToolFiles(rulesyncFiles);
-        const writtenCount = await processor.writeAiFiles(toolFiles);
-        totalSubagentOutputs += writtenCount;
-        logger.success(`Generated ${writtenCount} ${toolTarget} subagent(s) in ${baseDir}`);
+  logger.info("Generating subagent files...");
+  for (const baseDir of config.getBaseDirs()) {
+    for (const toolTarget of intersection(
+      config.getTargets(),
+      SubagentsProcessor.getToolTargets({
+        includeSimulated: config.getExperimentalSimulateSubagents()
+      })
+    )) {
+      const processor = new SubagentsProcessor({
+        baseDir,
+        toolTarget
+      });
+      if (config.getDelete()) {
+        const oldToolFiles = await processor.loadToolFilesToDelete();
+        await processor.removeAiFiles(oldToolFiles);
       }
+      const rulesyncFiles = await processor.loadRulesyncFiles();
+      const toolFiles = await processor.convertRulesyncFilesToToolFiles(rulesyncFiles);
+      const writtenCount = await processor.writeAiFiles(toolFiles);
+      totalSubagentOutputs += writtenCount;
+      logger.success(`Generated ${writtenCount} ${toolTarget} subagent(s) in ${baseDir}`);
     }
   }
-  const totalGenerated = totalRulesOutputs + totalMcpOutputs + totalCommandOutputs + totalIgnoreOutputs + totalSubagentOutputs;
-  if (totalGenerated === 0) {
-    const enabledFeatures = config.getFeatures().join(", ");
-    logger.warn(`\u26A0\uFE0F  No files generated for enabled features: ${enabledFeatures}`);
-    return;
-  }
-  if (totalGenerated > 0) {
-    const parts = [];
-    if (totalRulesOutputs > 0) parts.push(`${totalRulesOutputs} rules`);
-    if (totalIgnoreOutputs > 0) parts.push(`${totalIgnoreOutputs} ignore files`);
-    if (totalMcpOutputs > 0) parts.push(`${totalMcpOutputs} MCP files`);
-    if (totalCommandOutputs > 0) parts.push(`${totalCommandOutputs} commands`);
-    if (totalSubagentOutputs > 0) parts.push(`${totalSubagentOutputs} subagents`);
-    logger.success(`\u{1F389} All done! Generated ${totalGenerated} file(s) total (${parts.join(" + ")})`);
-  }
+  return totalSubagentOutputs;
 }
 
 // src/cli/commands/gitignore.ts
@@ -6148,116 +6340,186 @@ async function importCommand(options) {
   const config = await ConfigResolver.resolve(options);
   logger.setVerbose(config.getVerbose());
   const tool = config.getTargets()[0];
-  let rulesCreated = 0;
-  if (config.getFeatures().includes("rules")) {
-    if (RulesProcessor.getToolTargets().includes(tool)) {
-      const rulesProcessor = new RulesProcessor({
-        baseDir: ".",
-        toolTarget: tool
-      });
-      const toolFiles = await rulesProcessor.loadToolFiles();
-      if (toolFiles.length > 0) {
-        const rulesyncFiles = await rulesProcessor.convertToolFilesToRulesyncFiles(toolFiles);
-        const writtenCount = await rulesProcessor.writeAiFiles(rulesyncFiles);
-        rulesCreated = writtenCount;
-      }
-      if (config.getVerbose() && rulesCreated > 0) {
-        logger.success(`Created ${rulesCreated} rule files`);
-      }
-    }
+  await importRules(config, tool);
+  await importIgnore(config, tool);
+  await importMcp(config, tool);
+  await importCommands(config, tool);
+  await importSubagents(config, tool);
+}
+async function importRules(config, tool) {
+  if (!config.getFeatures().includes("rules")) {
+    return 0;
+  }
+  if (!RulesProcessor.getToolTargets().includes(tool)) {
+    return 0;
+  }
+  const global = config.getExperimentalGlobal();
+  if (global && !RulesProcessor.getToolTargetsGlobal().includes(tool)) {
+    logger.error(`${tool} is not supported in global mode`);
+    return 0;
+  }
+  const rulesProcessor = new RulesProcessor({
+    baseDir: ".",
+    toolTarget: tool,
+    global
+  });
+  const toolFiles = await rulesProcessor.loadToolFiles();
+  if (toolFiles.length === 0) {
+    return 0;
   }
-  let ignoreFileCreated = 0;
-  if (config.getFeatures().includes("ignore")) {
-    if (IgnoreProcessor.getToolTargets().includes(tool)) {
-      const ignoreProcessor = new IgnoreProcessor({
-        baseDir: ".",
-        toolTarget: tool
-      });
-      const toolFiles = await ignoreProcessor.loadToolFiles();
-      if (toolFiles.length > 0) {
-        const rulesyncFiles = await ignoreProcessor.convertToolFilesToRulesyncFiles(toolFiles);
-        const writtenCount = await ignoreProcessor.writeAiFiles(rulesyncFiles);
-        ignoreFileCreated = writtenCount;
-        if (config.getVerbose()) {
-          logger.success(
-            `Created ignore files from ${toolFiles.length} tool ignore configurations`
-          );
-        }
-      }
-    }
-    if (config.getVerbose() && ignoreFileCreated > 0) {
-      logger.success(`Created ${ignoreFileCreated} ignore files`);
-    }
+  const rulesyncFiles = await rulesProcessor.convertToolFilesToRulesyncFiles(toolFiles);
+  const writtenCount = await rulesProcessor.writeAiFiles(rulesyncFiles);
+  if (config.getVerbose() && writtenCount > 0) {
+    logger.success(`Created ${writtenCount} rule files`);
   }
-  let mcpCreated = 0;
-  if (config.getFeatures().includes("mcp")) {
-    if (McpProcessor.getToolTargets().includes(tool)) {
-      const mcpProcessor = new McpProcessor({
-        baseDir: ".",
-        toolTarget: tool
-      });
-      const toolFiles = await mcpProcessor.loadToolFiles();
-      if (toolFiles.length > 0) {
-        const rulesyncFiles = await mcpProcessor.convertToolFilesToRulesyncFiles(toolFiles);
-        const writtenCount = await mcpProcessor.writeAiFiles(rulesyncFiles);
-        mcpCreated = writtenCount;
-      }
-    }
+  return writtenCount;
+}
+async function importIgnore(config, tool) {
+  if (!config.getFeatures().includes("ignore")) {
+    return 0;
   }
-  if (config.getVerbose() && mcpCreated > 0) {
-    logger.success(`Created ${mcpCreated} MCP files`);
+  if (config.getExperimentalGlobal()) {
+    logger.debug("Skipping ignore file import (not supported in global mode)");
+    return 0;
   }
-  let subagentsCreated = 0;
-  if (config.getFeatures().includes("subagents")) {
-    const supportedTargets = SubagentsProcessor.getToolTargets({ includeSimulated: false });
-    if (supportedTargets.includes(tool)) {
-      const subagentsProcessor = new SubagentsProcessor({
-        baseDir: ".",
-        toolTarget: tool
-      });
-      const toolFiles = await subagentsProcessor.loadToolFiles();
-      if (toolFiles.length > 0) {
-        const rulesyncFiles = await subagentsProcessor.convertToolFilesToRulesyncFiles(toolFiles);
-        const writtenCount = await subagentsProcessor.writeAiFiles(rulesyncFiles);
-        subagentsCreated += writtenCount;
-      }
-    }
-    if (config.getVerbose() && subagentsCreated > 0) {
-      logger.success(`Created ${subagentsCreated} subagent files`);
-    }
+  if (!IgnoreProcessor.getToolTargets().includes(tool)) {
+    return 0;
   }
-  let commandsCreated = 0;
-  if (config.getFeatures().includes("commands")) {
-    const supportedTargets = CommandsProcessor.getToolTargets({ includeSimulated: false });
-    if (supportedTargets.includes(tool)) {
-      const commandsProcessor = new CommandsProcessor({
-        baseDir: ".",
-        toolTarget: tool
-      });
-      const toolFiles = await commandsProcessor.loadToolFiles();
-      if (toolFiles.length > 0) {
-        const rulesyncFiles = await commandsProcessor.convertToolFilesToRulesyncFiles(toolFiles);
-        const writtenCount = await commandsProcessor.writeAiFiles(rulesyncFiles);
-        commandsCreated = writtenCount;
-      }
-    }
-    if (config.getVerbose() && commandsCreated > 0) {
-      logger.success(`Created ${commandsCreated} command files`);
-    }
+  const ignoreProcessor = new IgnoreProcessor({
+    baseDir: ".",
+    toolTarget: tool
+  });
+  const toolFiles = await ignoreProcessor.loadToolFiles();
+  if (toolFiles.length === 0) {
+    return 0;
+  }
+  const rulesyncFiles = await ignoreProcessor.convertToolFilesToRulesyncFiles(toolFiles);
+  const writtenCount = await ignoreProcessor.writeAiFiles(rulesyncFiles);
+  if (config.getVerbose()) {
+    logger.success(`Created ignore files from ${toolFiles.length} tool ignore configurations`);
+  }
+  if (config.getVerbose() && writtenCount > 0) {
+    logger.success(`Created ${writtenCount} ignore files`);
+  }
+  return writtenCount;
+}
+async function importMcp(config, tool) {
+  if (!config.getFeatures().includes("mcp")) {
+    return 0;
+  }
+  if (config.getExperimentalGlobal()) {
+    logger.debug("Skipping MCP file import (not supported in global mode)");
+    return 0;
+  }
+  if (!McpProcessor.getToolTargets().includes(tool)) {
+    return 0;
+  }
+  const mcpProcessor = new McpProcessor({
+    baseDir: ".",
+    toolTarget: tool
+  });
+  const toolFiles = await mcpProcessor.loadToolFiles();
+  if (toolFiles.length === 0) {
+    return 0;
   }
+  const rulesyncFiles = await mcpProcessor.convertToolFilesToRulesyncFiles(toolFiles);
+  const writtenCount = await mcpProcessor.writeAiFiles(rulesyncFiles);
+  if (config.getVerbose() && writtenCount > 0) {
+    logger.success(`Created ${writtenCount} MCP files`);
+  }
+  return writtenCount;
+}
+async function importCommands(config, tool) {
+  if (!config.getFeatures().includes("commands")) {
+    return 0;
+  }
+  if (config.getExperimentalGlobal()) {
+    logger.debug("Skipping command file import (not supported in global mode)");
+    return 0;
+  }
+  const supportedTargets = CommandsProcessor.getToolTargets({ includeSimulated: false });
+  if (!supportedTargets.includes(tool)) {
+    return 0;
+  }
+  const commandsProcessor = new CommandsProcessor({
+    baseDir: ".",
+    toolTarget: tool
+  });
+  const toolFiles = await commandsProcessor.loadToolFiles();
+  if (toolFiles.length === 0) {
+    return 0;
+  }
+  const rulesyncFiles = await commandsProcessor.convertToolFilesToRulesyncFiles(toolFiles);
+  const writtenCount = await commandsProcessor.writeAiFiles(rulesyncFiles);
+  if (config.getVerbose() && writtenCount > 0) {
+    logger.success(`Created ${writtenCount} command files`);
+  }
+  return writtenCount;
+}
+async function importSubagents(config, tool) {
+  if (!config.getFeatures().includes("subagents")) {
+    return 0;
+  }
+  if (config.getExperimentalGlobal()) {
+    logger.debug("Skipping subagent file import (not supported in global mode)");
+    return 0;
+  }
+  const supportedTargets = SubagentsProcessor.getToolTargets({ includeSimulated: false });
+  if (!supportedTargets.includes(tool)) {
+    return 0;
+  }
+  const subagentsProcessor = new SubagentsProcessor({
+    baseDir: ".",
+    toolTarget: tool
+  });
+  const toolFiles = await subagentsProcessor.loadToolFiles();
+  if (toolFiles.length === 0) {
+    return 0;
+  }
+  const rulesyncFiles = await subagentsProcessor.convertToolFilesToRulesyncFiles(toolFiles);
+  const writtenCount = await subagentsProcessor.writeAiFiles(rulesyncFiles);
+  if (config.getVerbose() && writtenCount > 0) {
+    logger.success(`Created ${writtenCount} subagent files`);
+  }
+  return writtenCount;
 }
 
 // src/cli/commands/init.ts
 import { join as join56 } from "path";
 async function initCommand() {
   logger.info("Initializing rulesync...");
-  await ensureDir(RULESYNC_DIR);
+  await ensureDir(".rulesync");
   await createSampleFiles();
+  await createConfigFile();
   logger.success("rulesync initialized successfully!");
   logger.info("Next steps:");
-  logger.info(`1. Edit rule files in ${RULESYNC_RULES_DIR}/`);
+  logger.info(`1. Edit rule files in .rulesync/rules/`);
   logger.info("2. Run 'rulesync generate' to create configuration files");
 }
+async function createConfigFile() {
+  if (await fileExists("rulesync.jsonc")) {
+    logger.info("Skipped rulesync.jsonc (already exists)");
+    return;
+  }
+  await writeFileContent(
+    "rulesync.jsonc",
+    JSON.stringify(
+      {
+        targets: ["copilot", "cursor", "claudecode", "codexcli"],
+        features: ["rules", "ignore", "mcp", "commands", "subagents"],
+        baseDirs: ["."],
+        delete: true,
+        verbose: false,
+        experimentalGlobal: false,
+        experimentalSimulateCommands: false,
+        experimentalSimulateSubagents: false
+      },
+      null,
+      2
+    )
+  );
+  logger.success("Created rulesync.jsonc");
+}
 async function createSampleFiles() {
   const sampleFile = {
     filename: "overview.md",
@@ -6294,10 +6556,10 @@ globs: ["**/*"]
 - Follow single responsibility principle
 `
   };
-  const filepath = join56(RULESYNC_RULES_DIR, sampleFile.filename);
-  await ensureDir(RULESYNC_RULES_DIR);
+  const filepath = join56(".rulesync/rules", sampleFile.filename);
+  await ensureDir(".rulesync/rules");
   await ensureDir(RulesyncCommand.getSettablePaths().relativeDirPath);
-  await ensureDir(RULESYNC_SUBAGENTS_DIR);
+  await ensureDir(".rulesync/subagents");
   if (!await fileExists(filepath)) {
     await writeFileContent(filepath, sampleFile.content);
     logger.success(`Created ${filepath}`);
@@ -6307,7 +6569,7 @@ globs: ["**/*"]
 }
 
 // src/cli/index.ts
-var getVersion = () => "1.2.5";
+var getVersion = () => "2.0.0";
 var main = async () => {
   const program = new Command();
   const version = getVersion();
@@ -6331,7 +6593,7 @@ var main = async () => {
     (value) => {
       return value.split(",").map((f) => f.trim());
     }
-  ).option("-V, --verbose", "Verbose output").action(async (options) => {
+  ).option("-V, --verbose", "Verbose output").option("-g, --experimental-global", "Import for global(user scope) configuration files").action(async (options) => {
     try {
       await importCommand({
         targets: options.targets,
@@ -6344,7 +6606,7 @@ var main = async () => {
       process.exit(1);
     }
   });
-  program.command("generate").description("Generate configuration files for AI tools").option("--all", "[DEPRECATED] Generate for all supported AI tools (use --targets * instead)").option(
+  program.command("generate").description("Generate configuration files for AI tools").option(
     "-t, --targets <tools>",
     "Comma-separated list of tools to generate for (e.g., 'copilot,cursor,cline' or '*' for all)",
     (value) => {
@@ -6359,7 +6621,7 @@ var main = async () => {
   ).option("--delete", "Delete all existing files in output directories before generating").option(
     "-b, --base-dir <paths>",
     "Base directories to generate files (comma-separated for multiple paths)"
-  ).option("-V, --verbose", "Verbose output").option("-c, --config <path>", "Path to configuration file").option(
+  ).option("-V, --verbose", "Verbose output").option("-c, --config <path>", "Path to configuration file").option("-g, --experimental-global", "Generate for global(user scope) configuration files").option(
     "--experimental-simulate-commands",
     "Generate simulated commands (experimental feature). This feature is only available for copilot, cursor and codexcli."
   ).option(
@@ -6374,6 +6636,7 @@ var main = async () => {
         delete: options.delete,
         baseDirs: options.baseDirs,
         configPath: options.config,
+        experimentalGlobal: options.experimentalGlobal,
         experimentalSimulateCommands: options.experimentalSimulateCommands,
         experimentalSimulateSubagents: options.experimentalSimulateSubagents
       });
@@ -6382,7 +6645,6 @@ var main = async () => {
       process.exit(1);
     }
   });
-  program.command("config").description("Show or initialize rulesync configuration").option("--init", "Initialize a new configuration file").action(configCommand);
   program.parse();
 };
 main().catch((error) => {