rulesync 0.57.0 → 0.59.0

package/dist/index.cjs

@@ -9,6 +9,10 @@ var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __esm = (fn, res) => function __init() {
   return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
 };
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
     for (let key of __getOwnPropNames(from))
@@ -82,6 +86,11 @@ var init_mcp_helpers = __esm({
 });
 
 // src/generators/mcp/augmentcode.ts
+var augmentcode_exports = {};
+__export(augmentcode_exports, {
+  generateAugmentcodeMcp: () => generateAugmentcodeMcp,
+  generateAugmentcodeMcpConfiguration: () => generateAugmentcodeMcpConfiguration
+});
 function generateAugmentcodeMcp(config) {
   const augmentSettings = {
     mcpServers: []
@@ -131,6 +140,58 @@ function generateAugmentcodeMcp(config) {
   }
   return JSON.stringify(augmentSettings, null, 2);
 }
+function generateAugmentcodeMcpConfiguration(mcpServers, baseDir = "") {
+  const filepath = baseDir ? `${baseDir}/.mcp.json` : ".mcp.json";
+  const settings = {
+    mcpServers: {}
+  };
+  for (const [serverName, server] of Object.entries(mcpServers)) {
+    if (!shouldIncludeServer(server, "augmentcode")) {
+      continue;
+    }
+    const { targets: _, ...serverConfig } = server;
+    const augmentServer = {};
+    if (serverConfig.command) {
+      augmentServer.command = serverConfig.command;
+      if (serverConfig.args) {
+        augmentServer.args = serverConfig.args;
+      }
+      if (serverConfig.env) {
+        augmentServer.env = serverConfig.env;
+      }
+    } else if (serverConfig.url || serverConfig.httpUrl) {
+      const url = serverConfig.httpUrl || serverConfig.url;
+      if (url) {
+        augmentServer.url = url;
+      }
+      if (serverConfig.httpUrl || serverConfig.transport === "http") {
+        augmentServer.transport = "http";
+      } else if (serverConfig.transport === "sse") {
+        augmentServer.transport = "sse";
+      }
+      if (serverConfig.env) {
+        augmentServer.headers = serverConfig.env;
+      }
+    }
+    if (serverConfig.timeout) {
+      augmentServer.timeout = serverConfig.timeout;
+    }
+    if (serverConfig.disabled !== void 0) {
+      augmentServer.enabled = !serverConfig.disabled;
+    }
+    if (serverConfig.networkTimeout && serverConfig.networkTimeout > 0) {
+      augmentServer.retries = Math.max(1, Math.floor(serverConfig.networkTimeout / 3e4));
+    }
+    settings.mcpServers[serverName] = augmentServer;
+  }
+  return [
+    {
+      filepath,
+      content: `${JSON.stringify(settings, null, 2)}
+`
+    }
+  ];
+}
 var init_augmentcode = __esm({
   "src/generators/mcp/augmentcode.ts"() {
     "use strict";
@@ -148,6 +209,20 @@ function generateMcpConfig(config, toolConfig) {
   const finalConfig = toolConfig.configWrapper(servers);
   return JSON.stringify(finalConfig, null, 2);
 }
+function generateMcpConfigurationFiles(mcpServers, toolConfig, baseDir = "") {
+  const configs = [];
+  const rulesyncConfig = { mcpServers };
+  for (const configPath of toolConfig.configPaths) {
+    const filepath = baseDir ? `${baseDir}/${configPath}` : configPath;
+    const content = generateMcpConfig(rulesyncConfig, toolConfig);
+    configs.push({
+      filepath,
+      content: `${content}
+`
+    });
+  }
+  return configs;
+}
 function generateMcpFromRegistry(tool, config) {
   const generatorConfig = MCP_GENERATOR_REGISTRY[tool];
   if (!generatorConfig) {
@@ -155,6 +230,58 @@ function generateMcpFromRegistry(tool, config) {
   }
   return generateMcpConfig(config, generatorConfig);
 }
+function generateMcpConfigurationFilesFromRegistry(tool, mcpServers, baseDir = "") {
+  const generatorConfig = MCP_GENERATOR_REGISTRY[tool];
+  if (!generatorConfig) {
+    throw new Error(`No MCP generator configuration found for tool: ${tool}`);
+  }
+  if (tool === "junie") {
+    return generateJunieMcpConfigurationFiles(mcpServers, baseDir);
+  }
+  const customTools = ["copilot", "augmentcode", "roo", "codexcli", "kiro", "geminicli"];
+  if (customTools.includes(tool)) {
+    throw new Error(
+      `Tool ${tool} uses custom configuration logic - use its specific generator function instead`
+    );
+  }
+  return generateMcpConfigurationFiles(mcpServers, generatorConfig, baseDir);
+}
+function generateJunieMcpConfigurationFiles(mcpServers, baseDir = "") {
+  const filepath = baseDir ? `${baseDir}/.junie/mcp-config.json` : ".junie/mcp-config.json";
+  const config = {
+    mcpServers: {}
+  };
+  for (const [serverName, server] of Object.entries(mcpServers)) {
+    if (!shouldIncludeServer(server, "junie")) {
+      continue;
+    }
+    const { targets: _, transport, cwd, ...serverConfig } = server;
+    const junieServer = {
+      ...serverConfig,
+      name: serverName
+    };
+    if (cwd) {
+      junieServer.workingDirectory = cwd;
+    }
+    if (transport) {
+      if (String(transport) === "streamable-http") {
+        junieServer.transport = "http";
+      } else if (transport === "stdio" || transport === "http" || transport === "sse") {
+        junieServer.transport = transport;
+      }
+    } else if (serverConfig.command) {
+      junieServer.transport = "stdio";
+    }
+    config.mcpServers[serverName] = junieServer;
+  }
+  return [
+    {
+      filepath,
+      content: `${JSON.stringify(config, null, 2)}
+`
+    }
+  ];
+}
 var serverTransforms, configWrappers, MCP_GENERATOR_REGISTRY;
 var init_shared_factory = __esm({
   "src/generators/mcp/shared-factory.ts"() {
@@ -231,7 +358,7 @@ var init_shared_factory = __esm({
     MCP_GENERATOR_REGISTRY = {
       claudecode: {
         target: "claudecode",
-        configPaths: [".claude/settings.json"],
+        configPaths: [".mcp.json"],
         serverTransform: (server) => {
           const claudeServer = {};
           if (server.command) {
@@ -361,9 +488,17 @@ var init_shared_factory = __esm({
 });
 
 // src/generators/mcp/claudecode.ts
+var claudecode_exports = {};
+__export(claudecode_exports, {
+  generateClaudeMcp: () => generateClaudeMcp,
+  generateClaudeMcpConfiguration: () => generateClaudeMcpConfiguration
+});
 function generateClaudeMcp(config) {
   return generateMcpFromRegistry("claudecode", config);
 }
+function generateClaudeMcpConfiguration(mcpServers, baseDir = "") {
+  return generateMcpConfigurationFilesFromRegistry("claudecode", mcpServers, baseDir);
+}
 var init_claudecode = __esm({
   "src/generators/mcp/claudecode.ts"() {
     "use strict";
@@ -372,9 +507,17 @@ var init_claudecode = __esm({
 });
 
 // src/generators/mcp/cline.ts
+var cline_exports = {};
+__export(cline_exports, {
+  generateClineMcp: () => generateClineMcp,
+  generateClineMcpConfiguration: () => generateClineMcpConfiguration
+});
 function generateClineMcp(config) {
   return generateMcpFromRegistry("cline", config);
 }
+function generateClineMcpConfiguration(mcpServers, baseDir = "") {
+  return generateMcpConfigurationFilesFromRegistry("cline", mcpServers, baseDir);
+}
 var init_cline = __esm({
   "src/generators/mcp/cline.ts"() {
     "use strict";
@@ -383,6 +526,11 @@ var init_cline = __esm({
 });
 
 // src/generators/mcp/codexcli.ts
+var codexcli_exports = {};
+__export(codexcli_exports, {
+  generateCodexMcp: () => generateCodexMcp,
+  generateCodexMcpConfiguration: () => generateCodexMcpConfiguration
+});
 function generateCodexMcp(config) {
   return generateMcpConfig(config, {
     target: "codexcli",
@@ -442,6 +590,81 @@ function generateCodexMcp(config) {
     })
   });
 }
+function generateCodexMcpConfiguration(mcpServers, baseDir = "") {
+  return generateMcpConfigurationFiles(
+    mcpServers,
+    {
+      target: "codexcli",
+      configPaths: [".codex/mcp-config.json"],
+      serverTransform: (server) => {
+        const { targets: _, transport, ...serverConfig } = server;
+        const codexServer = {};
+        if (serverConfig.command !== void 0) codexServer.command = serverConfig.command;
+        if (serverConfig.args !== void 0) codexServer.args = serverConfig.args;
+        if (serverConfig.url !== void 0) codexServer.url = serverConfig.url;
+        if (serverConfig.httpUrl !== void 0) codexServer.httpUrl = serverConfig.httpUrl;
+        if (serverConfig.env !== void 0) codexServer.env = serverConfig.env;
+        if (serverConfig.disabled !== void 0) codexServer.disabled = serverConfig.disabled;
+        if (serverConfig.networkTimeout !== void 0)
+          codexServer.networkTimeout = serverConfig.networkTimeout;
+        if (serverConfig.timeout !== void 0) codexServer.timeout = serverConfig.timeout;
+        if (serverConfig.trust !== void 0) codexServer.trust = serverConfig.trust;
+        if (serverConfig.cwd !== void 0) codexServer.cwd = serverConfig.cwd;
+        if (serverConfig.type !== void 0) codexServer.type = serverConfig.type;
+        if (serverConfig.alwaysAllow !== void 0)
+          codexServer.alwaysAllow = serverConfig.alwaysAllow;
+        if (serverConfig.tools !== void 0) codexServer.tools = serverConfig.tools;
+        if (serverConfig.kiroAutoApprove !== void 0)
+          codexServer.autoApprove = serverConfig.kiroAutoApprove;
+        if (serverConfig.kiroAutoBlock !== void 0)
+          codexServer.autoBlock = serverConfig.kiroAutoBlock;
+        if (serverConfig.headers !== void 0) codexServer.headers = serverConfig.headers;
+        if (serverConfig.httpUrl !== void 0) {
+          codexServer.url = serverConfig.httpUrl;
+          delete codexServer.httpUrl;
+        }
+        if (transport) {
+          codexServer.transport = transport;
+        } else if (serverConfig.url && !serverConfig.httpUrl) {
+          codexServer.transport = "sse";
+        } else {
+          codexServer.transport = "stdio";
+        }
+        if (serverConfig.env) {
+          codexServer.env = { ...serverConfig.env };
+          if (!codexServer.env.CODEX_DEFAULT_MODEL) {
+            codexServer.env.CODEX_DEFAULT_MODEL = "gpt-4o-mini";
+          }
+        }
+        if (serverConfig.cwd) {
+          codexServer.cwd = serverConfig.cwd;
+          codexServer.workingDirectory = serverConfig.cwd;
+        }
+        if (serverConfig.timeout) {
+          codexServer.timeout = serverConfig.timeout;
+        }
+        if (serverConfig.headers) {
+          codexServer.headers = serverConfig.headers;
+        }
+        return codexServer;
+      },
+      configWrapper: (servers) => ({
+        // Configuration format for MCP wrapper servers that integrate with Codex CLI
+        servers,
+        _comment: "Configuration for MCP wrapper servers like openai-codex-mcp that integrate with Codex CLI",
+        _usage: "Use with third-party MCP servers that expose Codex CLI functionality to other MCP clients",
+        _examples: {
+          python_server: "python -m mcp_server or uvicorn codex_server:app",
+          nodejs_server: "node dist/server.js or npm start",
+          docker_server: "docker run -i --rm custom/codex-mcp:latest"
+        },
+        _security_note: "Store API keys in environment variables, not in this configuration file",
+        _supported_transports: ["stdio", "sse", "http"]
+      })
+    },
+    baseDir
+  );
+}
 var init_codexcli = __esm({
   "src/generators/mcp/codexcli.ts"() {
     "use strict";
@@ -450,6 +673,11 @@ var init_codexcli = __esm({
 });
 
 // src/generators/mcp/copilot.ts
+var copilot_exports = {};
+__export(copilot_exports, {
+  generateCopilotMcp: () => generateCopilotMcp,
+  generateCopilotMcpConfiguration: () => generateCopilotMcpConfiguration
+});
 function generateCopilotMcp(config, target) {
   const servers = {};
   const inputs = [];
@@ -501,6 +729,23 @@ function generateCopilotMcp(config, target) {
     return JSON.stringify(config2, null, 2);
   }
 }
+function generateCopilotMcpConfiguration(mcpServers, baseDir = "") {
+  const configs = [];
+  const rulesyncConfig = { mcpServers };
+  const editorContent = generateCopilotMcp(rulesyncConfig, "editor");
+  configs.push({
+    filepath: baseDir ? `${baseDir}/.vscode/mcp.json` : ".vscode/mcp.json",
+    content: `${editorContent}
+`
+  });
+  const codingAgentContent = generateCopilotMcp(rulesyncConfig, "codingAgent");
+  configs.push({
+    filepath: baseDir ? `${baseDir}/.copilot/mcp.json` : ".copilot/mcp.json",
+    content: `${codingAgentContent}
+`
+  });
+  return configs;
+}
 var init_copilot = __esm({
   "src/generators/mcp/copilot.ts"() {
     "use strict";
@@ -509,9 +754,17 @@ var init_copilot = __esm({
 });
 
 // src/generators/mcp/cursor.ts
+var cursor_exports = {};
+__export(cursor_exports, {
+  generateCursorMcp: () => generateCursorMcp,
+  generateCursorMcpConfiguration: () => generateCursorMcpConfiguration
+});
 function generateCursorMcp(config) {
   return generateMcpFromRegistry("cursor", config);
 }
+function generateCursorMcpConfiguration(mcpServers, baseDir = "") {
+  return generateMcpConfigurationFilesFromRegistry("cursor", mcpServers, baseDir);
+}
 var init_cursor = __esm({
   "src/generators/mcp/cursor.ts"() {
     "use strict";
@@ -520,6 +773,11 @@ var init_cursor = __esm({
 });
 
 // src/generators/mcp/geminicli.ts
+var geminicli_exports = {};
+__export(geminicli_exports, {
+  generateGeminiCliMcp: () => generateGeminiCliMcp,
+  generateGeminiCliMcpConfiguration: () => generateGeminiCliMcpConfiguration
+});
 function generateGeminiCliMcp(config) {
   return generateMcpConfig(config, {
     target: "geminicli",
@@ -550,6 +808,25 @@ function generateGeminiCliMcp(config) {
     configWrapper: configWrappers.mcpServers
   });
 }
+function generateGeminiCliMcpConfiguration(mcpServers, baseDir = "") {
+  return generateMcpConfigurationFiles(
+    mcpServers,
+    {
+      target: "geminicli",
+      configPaths: [".gemini/settings.json"],
+      serverTransform: (server) => {
+        const { targets: _, ...serverConfig } = server;
+        const geminiServer = { ...serverConfig };
+        if (server.env) {
+          geminiServer.env = server.env;
+        }
+        return geminiServer;
+      },
+      configWrapper: configWrappers.mcpServers
+    },
+    baseDir
+  );
+}
 var init_geminicli = __esm({
   "src/generators/mcp/geminicli.ts"() {
     "use strict";
@@ -558,9 +835,17 @@ var init_geminicli = __esm({
 });
 
 // src/generators/mcp/junie.ts
+var junie_exports = {};
+__export(junie_exports, {
+  generateJunieMcp: () => generateJunieMcp,
+  generateJunieMcpConfiguration: () => generateJunieMcpConfiguration
+});
 function generateJunieMcp(config) {
   return generateMcpFromRegistry("junie", config);
 }
+function generateJunieMcpConfiguration(mcpServers, baseDir = "") {
+  return generateMcpConfigurationFilesFromRegistry("junie", mcpServers, baseDir);
+}
 var init_junie = __esm({
   "src/generators/mcp/junie.ts"() {
     "use strict";
@@ -569,6 +854,11 @@ var init_junie = __esm({
 });
 
 // src/generators/mcp/kiro.ts
+var kiro_exports = {};
+__export(kiro_exports, {
+  generateKiroMcp: () => generateKiroMcp,
+  generateKiroMcpConfiguration: () => generateKiroMcpConfiguration
+});
 function generateKiroMcp(config) {
   const kiroConfig = {
     mcpServers: {}
@@ -612,6 +902,39 @@ function generateKiroMcp(config) {
   }
   return JSON.stringify(kiroConfig, null, 2);
 }
+function generateKiroMcpConfiguration(mcpServers, baseDir = "") {
+  const filepath = baseDir ? `${baseDir}/.kiro/mcp.json` : ".kiro/mcp.json";
+  const config = {
+    mcpServers: {}
+  };
+  for (const [serverName, server] of Object.entries(mcpServers)) {
+    if (!shouldIncludeServer(server, "kiro")) {
+      continue;
+    }
+    const { targets: _targets, ...serverConfig } = server;
+    const kiroServer = { ...serverConfig };
+    if (serverConfig.httpUrl !== void 0) {
+      kiroServer.url = serverConfig.httpUrl;
+      delete kiroServer.httpUrl;
+    }
+    if (serverConfig.kiroAutoApprove !== void 0) {
+      kiroServer.autoApprove = serverConfig.kiroAutoApprove;
+      delete kiroServer.kiroAutoApprove;
+    }
+    if (serverConfig.kiroAutoBlock !== void 0) {
+      kiroServer.autoBlock = serverConfig.kiroAutoBlock;
+      delete kiroServer.kiroAutoBlock;
+    }
+    config.mcpServers[serverName] = kiroServer;
+  }
+  return [
+    {
+      filepath,
+      content: `${JSON.stringify(config, null, 2)}
+`
+    }
+  ];
+}
 var init_kiro = __esm({
   "src/generators/mcp/kiro.ts"() {
     "use strict";
@@ -620,6 +943,11 @@ var init_kiro = __esm({
 });
 
 // src/generators/mcp/roo.ts
+var roo_exports = {};
+__export(roo_exports, {
+  generateRooMcp: () => generateRooMcp,
+  generateRooMcpConfiguration: () => generateRooMcpConfiguration
+});
 function generateRooMcp(config) {
   const rooConfig = {
     mcpServers: {}
@@ -664,6 +992,30 @@ function generateRooMcp(config) {
   }
   return JSON.stringify(rooConfig, null, 2);
 }
+function generateRooMcpConfiguration(mcpServers, baseDir = "") {
+  const filepath = baseDir ? `${baseDir}/.roo/mcp.json` : ".roo/mcp.json";
+  const config = {
+    mcpServers: {}
+  };
+  for (const [serverName, server] of Object.entries(mcpServers)) {
+    if (!shouldIncludeServer(server, "roo")) {
+      continue;
+    }
+    const { targets: _targets, ...serverConfig } = server;
+    const rooServer = { ...serverConfig };
+    if (serverConfig.httpUrl !== void 0 && serverConfig.url !== void 0) {
+      rooServer.url = serverConfig.httpUrl;
+    }
+    config.mcpServers[serverName] = rooServer;
+  }
+  return [
+    {
+      filepath,
+      content: `${JSON.stringify(config, null, 2)}
+`
+    }
+  ];
+}
 var init_roo = __esm({
   "src/generators/mcp/roo.ts"() {
     "use strict";
@@ -672,9 +1024,17 @@ var init_roo = __esm({
 });
 
 // src/generators/mcp/windsurf.ts
+var windsurf_exports = {};
+__export(windsurf_exports, {
+  generateWindsurfMcp: () => generateWindsurfMcp,
+  generateWindsurfMcpConfiguration: () => generateWindsurfMcpConfiguration
+});
 function generateWindsurfMcp(config) {
   return generateMcpFromRegistry("windsurf", config);
 }
+function generateWindsurfMcpConfiguration(mcpServers, baseDir = "") {
+  return generateMcpConfigurationFilesFromRegistry("windsurf", mcpServers, baseDir);
+}
 var init_windsurf = __esm({
   "src/generators/mcp/windsurf.ts"() {
     "use strict";
@@ -771,132 +1131,141 @@ var ClaudeSettingsSchema = import_mini2.z.looseObject({
   )
 });
 
-// src/types/config.ts
+// src/types/commands.ts
 var import_mini3 = require("zod/mini");
+var CommandFrontmatterSchema = import_mini3.z.object({
+  description: import_mini3.z.optional(import_mini3.z.string())
+});
+
+// src/types/config.ts
+var import_mini4 = require("zod/mini");
 init_tool_targets();
-var ConfigSchema = import_mini3.z.object({
-  aiRulesDir: import_mini3.z.string(),
-  outputPaths: import_mini3.z.record(ToolTargetSchema, import_mini3.z.string()),
-  watchEnabled: import_mini3.z.boolean(),
-  defaultTargets: ToolTargetsSchema
+var ConfigSchema = import_mini4.z.object({
+  aiRulesDir: import_mini4.z.string(),
+  outputPaths: import_mini4.z.record(ToolTargetSchema, import_mini4.z.string()),
+  watchEnabled: import_mini4.z.boolean(),
+  defaultTargets: ToolTargetsSchema,
+  claudecodeCommands: import_mini4.z.optional(import_mini4.z.string()),
+  geminicliCommands: import_mini4.z.optional(import_mini4.z.string())
 });
 
 // src/types/config-options.ts
-var import_mini4 = require("zod/mini");
+var import_mini5 = require("zod/mini");
 init_tool_targets();
-var OutputPathsSchema = import_mini4.z.object({
-  augmentcode: import_mini4.z.optional(import_mini4.z.string()),
-  "augmentcode-legacy": import_mini4.z.optional(import_mini4.z.string()),
-  copilot: import_mini4.z.optional(import_mini4.z.string()),
-  cursor: import_mini4.z.optional(import_mini4.z.string()),
-  cline: import_mini4.z.optional(import_mini4.z.string()),
-  claudecode: import_mini4.z.optional(import_mini4.z.string()),
-  codexcli: import_mini4.z.optional(import_mini4.z.string()),
-  roo: import_mini4.z.optional(import_mini4.z.string()),
-  geminicli: import_mini4.z.optional(import_mini4.z.string()),
-  kiro: import_mini4.z.optional(import_mini4.z.string()),
-  junie: import_mini4.z.optional(import_mini4.z.string()),
-  windsurf: import_mini4.z.optional(import_mini4.z.string())
+var OutputPathsSchema = import_mini5.z.object({
+  augmentcode: import_mini5.z.optional(import_mini5.z.string()),
+  "augmentcode-legacy": import_mini5.z.optional(import_mini5.z.string()),
+  copilot: import_mini5.z.optional(import_mini5.z.string()),
+  cursor: import_mini5.z.optional(import_mini5.z.string()),
+  cline: import_mini5.z.optional(import_mini5.z.string()),
+  claudecode: import_mini5.z.optional(import_mini5.z.string()),
+  codexcli: import_mini5.z.optional(import_mini5.z.string()),
+  roo: import_mini5.z.optional(import_mini5.z.string()),
+  geminicli: import_mini5.z.optional(import_mini5.z.string()),
+  kiro: import_mini5.z.optional(import_mini5.z.string()),
+  junie: import_mini5.z.optional(import_mini5.z.string()),
+  windsurf: import_mini5.z.optional(import_mini5.z.string())
 });
-var ConfigOptionsSchema = import_mini4.z.object({
-  aiRulesDir: import_mini4.z.optional(import_mini4.z.string()),
-  outputPaths: import_mini4.z.optional(OutputPathsSchema),
-  watchEnabled: import_mini4.z.optional(import_mini4.z.boolean()),
-  defaultTargets: import_mini4.z.optional(ToolTargetsSchema),
-  targets: import_mini4.z.optional(import_mini4.z.array(ToolTargetSchema)),
-  exclude: import_mini4.z.optional(import_mini4.z.array(ToolTargetSchema)),
-  verbose: import_mini4.z.optional(import_mini4.z.boolean()),
-  delete: import_mini4.z.optional(import_mini4.z.boolean()),
-  baseDir: import_mini4.z.optional(import_mini4.z.union([import_mini4.z.string(), import_mini4.z.array(import_mini4.z.string())])),
-  watch: import_mini4.z.optional(
-    import_mini4.z.object({
-      enabled: import_mini4.z.optional(import_mini4.z.boolean()),
-      interval: import_mini4.z.optional(import_mini4.z.number()),
-      ignore: import_mini4.z.optional(import_mini4.z.array(import_mini4.z.string()))
+var ConfigOptionsSchema = import_mini5.z.object({
+  aiRulesDir: import_mini5.z.optional(import_mini5.z.string()),
+  outputPaths: import_mini5.z.optional(OutputPathsSchema),
+  watchEnabled: import_mini5.z.optional(import_mini5.z.boolean()),
+  defaultTargets: import_mini5.z.optional(ToolTargetsSchema),
+  targets: import_mini5.z.optional(import_mini5.z.array(ToolTargetSchema)),
+  exclude: import_mini5.z.optional(import_mini5.z.array(ToolTargetSchema)),
+  verbose: import_mini5.z.optional(import_mini5.z.boolean()),
+  delete: import_mini5.z.optional(import_mini5.z.boolean()),
+  baseDir: import_mini5.z.optional(import_mini5.z.union([import_mini5.z.string(), import_mini5.z.array(import_mini5.z.string())])),
+  watch: import_mini5.z.optional(
+    import_mini5.z.object({
+      enabled: import_mini5.z.optional(import_mini5.z.boolean()),
+      interval: import_mini5.z.optional(import_mini5.z.number()),
+      ignore: import_mini5.z.optional(import_mini5.z.array(import_mini5.z.string()))
     })
   )
 });
-var MergedConfigSchema = import_mini4.z.object({
-  aiRulesDir: import_mini4.z.string(),
-  outputPaths: import_mini4.z.record(ToolTargetSchema, import_mini4.z.string()),
-  watchEnabled: import_mini4.z.boolean(),
+var MergedConfigSchema = import_mini5.z.object({
+  aiRulesDir: import_mini5.z.string(),
+  outputPaths: import_mini5.z.record(ToolTargetSchema, import_mini5.z.string()),
+  watchEnabled: import_mini5.z.boolean(),
   defaultTargets: ToolTargetsSchema,
-  targets: import_mini4.z.optional(import_mini4.z.array(ToolTargetSchema)),
-  exclude: import_mini4.z.optional(import_mini4.z.array(ToolTargetSchema)),
-  verbose: import_mini4.z.optional(import_mini4.z.boolean()),
-  delete: import_mini4.z.optional(import_mini4.z.boolean()),
-  baseDir: import_mini4.z.optional(import_mini4.z.union([import_mini4.z.string(), import_mini4.z.array(import_mini4.z.string())])),
-  configPath: import_mini4.z.optional(import_mini4.z.string()),
-  watch: import_mini4.z.optional(
-    import_mini4.z.object({
-      enabled: import_mini4.z.optional(import_mini4.z.boolean()),
-      interval: import_mini4.z.optional(import_mini4.z.number()),
-      ignore: import_mini4.z.optional(import_mini4.z.array(import_mini4.z.string()))
+  targets: import_mini5.z.optional(import_mini5.z.array(ToolTargetSchema)),
+  exclude: import_mini5.z.optional(import_mini5.z.array(ToolTargetSchema)),
+  verbose: import_mini5.z.optional(import_mini5.z.boolean()),
+  delete: import_mini5.z.optional(import_mini5.z.boolean()),
+  baseDir: import_mini5.z.optional(import_mini5.z.union([import_mini5.z.string(), import_mini5.z.array(import_mini5.z.string())])),
+  configPath: import_mini5.z.optional(import_mini5.z.string()),
+  watch: import_mini5.z.optional(
+    import_mini5.z.object({
+      enabled: import_mini5.z.optional(import_mini5.z.boolean()),
+      interval: import_mini5.z.optional(import_mini5.z.number()),
+      ignore: import_mini5.z.optional(import_mini5.z.array(import_mini5.z.string()))
     })
   )
 });
 
 // src/types/mcp.ts
-var import_mini5 = require("zod/mini");
+var import_mini6 = require("zod/mini");
 init_tool_targets();
-var McpTransportTypeSchema = import_mini5.z.enum(["stdio", "sse", "http"]);
-var McpServerBaseSchema = import_mini5.z.object({
-  command: import_mini5.z.optional(import_mini5.z.string()),
-  args: import_mini5.z.optional(import_mini5.z.array(import_mini5.z.string())),
-  url: import_mini5.z.optional(import_mini5.z.string()),
-  httpUrl: import_mini5.z.optional(import_mini5.z.string()),
-  env: import_mini5.z.optional(import_mini5.z.record(import_mini5.z.string(), import_mini5.z.string())),
-  disabled: import_mini5.z.optional(import_mini5.z.boolean()),
-  networkTimeout: import_mini5.z.optional(import_mini5.z.number()),
-  timeout: import_mini5.z.optional(import_mini5.z.number()),
-  trust: import_mini5.z.optional(import_mini5.z.boolean()),
-  cwd: import_mini5.z.optional(import_mini5.z.string()),
-  transport: import_mini5.z.optional(McpTransportTypeSchema),
-  type: import_mini5.z.optional(import_mini5.z.enum(["sse", "streamable-http"])),
-  alwaysAllow: import_mini5.z.optional(import_mini5.z.array(import_mini5.z.string())),
-  tools: import_mini5.z.optional(import_mini5.z.array(import_mini5.z.string())),
-  kiroAutoApprove: import_mini5.z.optional(import_mini5.z.array(import_mini5.z.string())),
-  kiroAutoBlock: import_mini5.z.optional(import_mini5.z.array(import_mini5.z.string())),
-  headers: import_mini5.z.optional(import_mini5.z.record(import_mini5.z.string(), import_mini5.z.string()))
+var McpTransportTypeSchema = import_mini6.z.enum(["stdio", "sse", "http"]);
+var McpServerBaseSchema = import_mini6.z.object({
+  command: import_mini6.z.optional(import_mini6.z.string()),
+  args: import_mini6.z.optional(import_mini6.z.array(import_mini6.z.string())),
+  url: import_mini6.z.optional(import_mini6.z.string()),
+  httpUrl: import_mini6.z.optional(import_mini6.z.string()),
+  env: import_mini6.z.optional(import_mini6.z.record(import_mini6.z.string(), import_mini6.z.string())),
+  disabled: import_mini6.z.optional(import_mini6.z.boolean()),
+  networkTimeout: import_mini6.z.optional(import_mini6.z.number()),
+  timeout: import_mini6.z.optional(import_mini6.z.number()),
+  trust: import_mini6.z.optional(import_mini6.z.boolean()),
+  cwd: import_mini6.z.optional(import_mini6.z.string()),
+  transport: import_mini6.z.optional(McpTransportTypeSchema),
+  type: import_mini6.z.optional(import_mini6.z.enum(["sse", "streamable-http"])),
+  alwaysAllow: import_mini6.z.optional(import_mini6.z.array(import_mini6.z.string())),
+  tools: import_mini6.z.optional(import_mini6.z.array(import_mini6.z.string())),
+  kiroAutoApprove: import_mini6.z.optional(import_mini6.z.array(import_mini6.z.string())),
+  kiroAutoBlock: import_mini6.z.optional(import_mini6.z.array(import_mini6.z.string())),
+  headers: import_mini6.z.optional(import_mini6.z.record(import_mini6.z.string(), import_mini6.z.string()))
 });
-var RulesyncMcpServerSchema = import_mini5.z.extend(McpServerBaseSchema, {
-  targets: import_mini5.z.optional(RulesyncTargetsSchema)
+var RulesyncMcpServerSchema = import_mini6.z.extend(McpServerBaseSchema, {
+  targets: import_mini6.z.optional(RulesyncTargetsSchema)
 });
-var McpConfigSchema = import_mini5.z.object({
-  mcpServers: import_mini5.z.record(import_mini5.z.string(), McpServerBaseSchema)
+var McpConfigSchema = import_mini6.z.object({
+  mcpServers: import_mini6.z.record(import_mini6.z.string(), McpServerBaseSchema)
 });
-var RulesyncMcpConfigSchema = import_mini5.z.object({
-  mcpServers: import_mini5.z.record(import_mini5.z.string(), RulesyncMcpServerSchema)
+var RulesyncMcpConfigSchema = import_mini6.z.object({
+  mcpServers: import_mini6.z.record(import_mini6.z.string(), RulesyncMcpServerSchema)
 });
 
 // src/types/rules.ts
-var import_mini6 = require("zod/mini");
+var import_mini7 = require("zod/mini");
 init_tool_targets();
-var RuleFrontmatterSchema = import_mini6.z.object({
-  root: import_mini6.z.optional(import_mini6.z.boolean()),
-  targets: import_mini6.z.optional(RulesyncTargetsSchema),
-  description: import_mini6.z.optional(import_mini6.z.string()),
-  globs: import_mini6.z.optional(import_mini6.z.array(import_mini6.z.string())),
-  cursorRuleType: import_mini6.z.optional(import_mini6.z.enum(["always", "manual", "specificFiles", "intelligently"])),
-  windsurfActivationMode: import_mini6.z.optional(import_mini6.z.enum(["always", "manual", "model-decision", "glob"])),
-  windsurfOutputFormat: import_mini6.z.optional(import_mini6.z.enum(["single-file", "directory"])),
-  tags: import_mini6.z.optional(import_mini6.z.array(import_mini6.z.string()))
+var RuleFrontmatterSchema = import_mini7.z.object({
+  root: import_mini7.z.optional(import_mini7.z.boolean()),
+  targets: import_mini7.z.optional(RulesyncTargetsSchema),
+  description: import_mini7.z.optional(import_mini7.z.string()),
+  globs: import_mini7.z.optional(import_mini7.z.array(import_mini7.z.string())),
+  cursorRuleType: import_mini7.z.optional(import_mini7.z.enum(["always", "manual", "specificFiles", "intelligently"])),
+  windsurfActivationMode: import_mini7.z.optional(import_mini7.z.enum(["always", "manual", "model-decision", "glob"])),
+  windsurfOutputFormat: import_mini7.z.optional(import_mini7.z.enum(["single-file", "directory"])),
+  tags: import_mini7.z.optional(import_mini7.z.array(import_mini7.z.string()))
 });
-var ParsedRuleSchema = import_mini6.z.object({
+var ParsedRuleSchema = import_mini7.z.object({
   frontmatter: RuleFrontmatterSchema,
-  content: import_mini6.z.string(),
-  filename: import_mini6.z.string(),
-  filepath: import_mini6.z.string()
+  content: import_mini7.z.string(),
+  filename: import_mini7.z.string(),
+  filepath: import_mini7.z.string(),
+  type: import_mini7.z.optional(import_mini7.z.enum(["rule", "command"]))
 });
-var GeneratedOutputSchema = import_mini6.z.object({
+var GeneratedOutputSchema = import_mini7.z.object({
   tool: ToolTargetSchema,
-  filepath: import_mini6.z.string(),
-  content: import_mini6.z.string()
+  filepath: import_mini7.z.string(),
+  content: import_mini7.z.string()
 });
-var GenerateOptionsSchema = import_mini6.z.object({
-  targetTools: import_mini6.z.optional(ToolTargetsSchema),
-  outputDir: import_mini6.z.optional(import_mini6.z.string()),
-  watch: import_mini6.z.optional(import_mini6.z.boolean())
+var GenerateOptionsSchema = import_mini7.z.object({
+  targetTools: import_mini7.z.optional(ToolTargetsSchema),
+  outputDir: import_mini7.z.optional(import_mini7.z.string()),
+  watch: import_mini7.z.optional(import_mini7.z.boolean())
 });
 
 // src/types/index.ts
@@ -1191,28 +1560,6 @@ async function removeClaudeGeneratedFiles() {
   }
 }
 
-// src/utils/rules.ts
-function isToolSpecificRule(rule, targetTool) {
-  const filename = rule.filename;
-  const toolPatterns = {
-    "augmentcode-legacy": /^specification-augmentcode-legacy-/i,
-    augmentcode: /^specification-augmentcode-/i,
-    copilot: /^specification-copilot-/i,
-    cursor: /^specification-cursor-/i,
-    cline: /^specification-cline-/i,
-    claudecode: /^specification-claudecode-/i,
-    roo: /^specification-roo-/i,
-    geminicli: /^specification-geminicli-/i,
-    kiro: /^specification-kiro-/i
-  };
-  for (const [tool, pattern] of Object.entries(toolPatterns)) {
-    if (pattern.test(filename)) {
-      return tool === targetTool;
-    }
-  }
-  return true;
-}
-
 // src/cli/commands/config.ts
 async function configCommand(options = {}) {
   if (options.init) {
@@ -1424,10 +1771,165 @@ export default config;
 }
 
 // src/cli/commands/generate.ts
-var import_node_path10 = require("path");
+var import_node_path14 = require("path");
 
-// src/generators/ignore/shared-factory.ts
+// src/core/command-generator.ts
+var import_node_path6 = require("path");
+
+// src/generators/commands/claudecode.ts
 var import_node_path3 = require("path");
+var ClaudeCodeCommandGenerator = class {
+  generate(command, outputDir) {
+    const filepath = this.getOutputPath(command.filename, outputDir);
+    const frontmatter = ["---"];
+    if (command.frontmatter.description) {
+      frontmatter.push(`description: ${command.frontmatter.description}`);
+    }
+    frontmatter.push("---");
+    const content = `${frontmatter.join("\n")}
+
+${command.content.trim()}
+`;
+    return {
+      tool: "claudecode",
+      filepath,
+      content
+    };
+  }
+  getOutputPath(filename, baseDir) {
+    const flattenedName = filename.replace(/\//g, "-");
+    return (0, import_node_path3.join)(baseDir, ".claude", "commands", `${flattenedName}.md`);
+  }
+};
+
+// src/generators/commands/geminicli.ts
+var import_node_path4 = require("path");
+var GeminiCliCommandGenerator = class {
+  generate(command, outputDir) {
+    const filepath = this.getOutputPath(command.filename, outputDir);
+    const convertedContent = this.convertSyntax(command.content);
+    const tomlLines = [];
+    if (command.frontmatter.description) {
+      tomlLines.push(`description = "${this.escapeTomlString(command.frontmatter.description)}"`);
+      tomlLines.push("");
+    }
+    tomlLines.push(`prompt = """${convertedContent}"""`);
+    const content = tomlLines.join("\n") + "\n";
+    return {
+      tool: "geminicli",
+      filepath,
+      content
+    };
+  }
+  getOutputPath(filename, baseDir) {
+    const tomlFilename = filename.replace(/\.md$/, ".toml");
+    const filenameWithExt = tomlFilename.endsWith(".toml") ? tomlFilename : `${tomlFilename}.toml`;
+    return (0, import_node_path4.join)(baseDir, ".gemini", "commands", filenameWithExt);
+  }
+  convertSyntax(content) {
+    let converted = content;
+    converted = converted.replace(/\$ARGUMENTS/g, "{{args}}");
+    converted = converted.replace(/!`([^`]+)`/g, "!{$1}");
+    const atSyntaxMatches = converted.match(/@[^\s]+/g);
+    if (atSyntaxMatches) {
+      console.warn(
+        `\u26A0\uFE0F  Warning: @ syntax found (${atSyntaxMatches.join(", ")}). Gemini CLI does not support file content injection. Consider using shell commands or remove these references.`
+      );
+    }
+    return converted.trim();
+  }
+  escapeTomlString(str) {
+    return str.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/\t/g, "\\t");
+  }
+};
+
+// src/generators/commands/index.ts
+var commandGenerators = {
+  claudecode: new ClaudeCodeCommandGenerator(),
+  geminicli: new GeminiCliCommandGenerator()
+};
+function getCommandGenerator(tool) {
+  return commandGenerators[tool];
+}
+
+// src/core/command-parser.ts
+var import_node_path5 = require("path");
+var import_gray_matter = __toESM(require("gray-matter"), 1);
+async function parseCommandsFromDirectory(commandsDir) {
+  const commandFiles = await findFiles(commandsDir, ".md");
+  const commands = [];
+  const errors = [];
+  for (const filepath of commandFiles) {
+    try {
+      const command = await parseCommandFile(filepath);
+      commands.push(command);
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      errors.push(`Failed to parse command file ${filepath}: ${errorMessage}`);
+    }
+  }
+  if (errors.length > 0) {
+    console.warn(`\u26A0\uFE0F  Command parsing errors:
+${errors.join("\n")}`);
+  }
+  return commands;
+}
+async function parseCommandFile(filepath) {
+  const content = await readFileContent(filepath);
+  const parsed = (0, import_gray_matter.default)(content);
+  try {
+    const validatedData = CommandFrontmatterSchema.parse(parsed.data);
+    const filename = (0, import_node_path5.basename)(filepath, ".md");
+    return {
+      frontmatter: {
+        description: validatedData.description
+      },
+      content: parsed.content,
+      filename,
+      filepath
+    };
+  } catch (error) {
+    throw new Error(
+      `Invalid frontmatter in ${filepath}: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+
+// src/core/command-generator.ts
+async function generateCommands(projectRoot, baseDir, targets) {
+  const commandsDir = (0, import_node_path6.join)(projectRoot, ".rulesync", "commands");
+  if (!await fileExists(commandsDir)) {
+    return [];
+  }
+  const commands = await parseCommandsFromDirectory(commandsDir);
+  if (commands.length === 0) {
+    return [];
+  }
+  const outputs = [];
+  const outputDir = baseDir || projectRoot;
+  const supportedTargets = targets.filter((target) => ["claudecode", "geminicli"].includes(target));
+  for (const target of supportedTargets) {
+    const generator = getCommandGenerator(target);
+    if (!generator) {
+      continue;
+    }
+    for (const command of commands) {
+      try {
+        const output = generator.generate(command, outputDir);
+        outputs.push(output);
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        console.error(
+          `\u274C Failed to generate ${target} command for ${command.filename}: ${errorMessage}`
+        );
+      }
+    }
+  }
+  return outputs;
+}
+
+// src/generators/ignore/shared-factory.ts
+var import_node_path7 = require("path");
 
 // src/generators/ignore/shared-helpers.ts
 function extractIgnorePatternsFromRules(rules) {
@@ -1545,7 +2047,7 @@ function generateIgnoreFile(rules, config, ignoreConfig, baseDir) {
   const outputs = [];
   const content = generateIgnoreContent(rules, ignoreConfig);
   const outputPath = baseDir || process.cwd();
-  const filepath = (0, import_node_path3.join)(outputPath, ignoreConfig.filename);
+  const filepath = (0, import_node_path7.join)(outputPath, ignoreConfig.filename);
   outputs.push({
     tool: ignoreConfig.tool,
     filepath,
@@ -2133,20 +2635,20 @@ function generateWindsurfIgnore(rules, config, baseDir) {
 }
 
 // src/generators/rules/augmentcode.ts
-var import_node_path6 = require("path");
+var import_node_path10 = require("path");
 
 // src/generators/rules/shared-helpers.ts
-var import_node_path5 = require("path");
+var import_node_path9 = require("path");
 
 // src/utils/ignore.ts
-var import_node_path4 = require("path");
+var import_node_path8 = require("path");
 var import_micromatch = __toESM(require("micromatch"), 1);
 var cachedIgnorePatterns = null;
 async function loadIgnorePatterns(baseDir = process.cwd()) {
   if (cachedIgnorePatterns) {
     return cachedIgnorePatterns;
   }
-  const ignorePath = (0, import_node_path4.join)(baseDir, ".rulesyncignore");
+  const ignorePath = (0, import_node_path8.join)(baseDir, ".rulesyncignore");
   if (!await fileExists(ignorePath)) {
     cachedIgnorePatterns = { patterns: [] };
     return cachedIgnorePatterns;
@@ -2200,7 +2702,7 @@ function addOutput(outputs, tool, config, baseDir, relativePath, content) {
   const outputDir = resolveOutputDir(config, tool, baseDir);
   outputs.push({
     tool,
-    filepath: (0, import_node_path5.join)(outputDir, relativePath),
+    filepath: (0, import_node_path9.join)(outputDir, relativePath),
     content
   });
 }
@@ -2209,7 +2711,7 @@ async function generateRulesConfig(rules, config, generatorConfig, baseDir) {
   for (const rule of rules) {
     const content = generatorConfig.generateContent(rule);
     const outputDir = resolveOutputDir(config, generatorConfig.tool, baseDir);
-    const filepath = generatorConfig.pathResolver ? generatorConfig.pathResolver(rule, outputDir) : (0, import_node_path5.join)(outputDir, `${rule.filename}${generatorConfig.fileExtension}`);
+    const filepath = generatorConfig.pathResolver ? generatorConfig.pathResolver(rule, outputDir) : (0, import_node_path9.join)(outputDir, `${rule.filename}${generatorConfig.fileExtension}`);
     outputs.push({
       tool: generatorConfig.tool,
       filepath,
@@ -2217,7 +2719,7 @@ async function generateRulesConfig(rules, config, generatorConfig, baseDir) {
     });
   }
   const ignorePatterns = await loadIgnorePatterns(baseDir);
-  if (ignorePatterns.patterns.length > 0) {
+  if (ignorePatterns.patterns.length > 0 && generatorConfig.ignoreFileName) {
     const ignorePath = resolvePath(generatorConfig.ignoreFileName, baseDir);
     const ignoreContent = generateIgnoreFile2(ignorePatterns.patterns, generatorConfig.tool);
     outputs.push({
@@ -2237,7 +2739,7 @@ async function generateComplexRules(rules, config, generatorConfig, baseDir) {
     for (const rule of detailRules) {
       const content = generatorConfig.generateDetailContent(rule);
       const filepath = resolvePath(
-        (0, import_node_path5.join)(generatorConfig.detailSubDir, `${rule.filename}.md`),
+        (0, import_node_path9.join)(generatorConfig.detailSubDir, `${rule.filename}.md`),
         baseDir
       );
       outputs.push({
@@ -2258,13 +2760,15 @@ async function generateComplexRules(rules, config, generatorConfig, baseDir) {
   }
   const ignorePatterns = await loadIgnorePatterns(baseDir);
   if (ignorePatterns.patterns.length > 0) {
-    const ignorePath = resolvePath(generatorConfig.ignoreFileName, baseDir);
-    const ignoreContent = generateIgnoreFile2(ignorePatterns.patterns, generatorConfig.tool);
-    outputs.push({
-      tool: generatorConfig.tool,
-      filepath: ignorePath,
-      content: ignoreContent
-    });
+    if (generatorConfig.ignoreFileName) {
+      const ignorePath = resolvePath(generatorConfig.ignoreFileName, baseDir);
+      const ignoreContent = generateIgnoreFile2(ignorePatterns.patterns, generatorConfig.tool);
+      outputs.push({
+        tool: generatorConfig.tool,
+        filepath: ignorePath,
+        content: ignoreContent
+      });
+    }
     if (generatorConfig.updateAdditionalConfig) {
       const additionalOutputs = await generatorConfig.updateAdditionalConfig(
         ignorePatterns.patterns,
@@ -2298,7 +2802,7 @@ async function generateAugmentcodeConfig(rules, config, baseDir) {
       "augmentcode",
       config,
       baseDir,
-      (0, import_node_path6.join)(".augment", "rules", `${rule.filename}.md`),
+      (0, import_node_path10.join)(".augment", "rules", `${rule.filename}.md`),
       generateRuleFile(rule)
     );
   });
@@ -2351,19 +2855,19 @@ function generateLegacyGuidelinesFile(allRules) {
 }
 
 // src/generators/rules/claudecode.ts
-var import_node_path7 = require("path");
+var import_node_path11 = require("path");
 async function generateClaudecodeConfig(rules, config, baseDir) {
   const generatorConfig = {
     tool: "claudecode",
     fileExtension: ".md",
-    ignoreFileName: ".aiignore",
+    // ignoreFileName omitted - Claude Code uses settings.json permissions.deny instead of ignore files
     generateContent: generateMemoryFile,
     generateRootContent: generateClaudeMarkdown,
     rootFilePath: "CLAUDE.md",
     generateDetailContent: generateMemoryFile,
     detailSubDir: ".claude/memories",
     updateAdditionalConfig: async (ignorePatterns, baseDir2) => {
-      const settingsPath = resolvePath((0, import_node_path7.join)(".claude", "settings.json"), baseDir2);
+      const settingsPath = resolvePath((0, import_node_path11.join)(".claude", "settings.json"), baseDir2);
       await updateClaudeSettings(settingsPath, ignorePatterns);
       return [];
     }
@@ -2427,7 +2931,7 @@ async function updateClaudeSettings(settingsPath, ignorePatterns) {
 }
 
 // src/generators/rules/generator-registry.ts
-var import_node_path8 = require("path");
+var import_node_path12 = require("path");
 function determineCursorRuleType(frontmatter) {
   if (frontmatter.cursorRuleType) {
     return frontmatter.cursorRuleType;
@@ -2507,7 +3011,7 @@ var GENERATOR_REGISTRY = {
     },
     pathResolver: (rule, outputDir) => {
       const baseFilename = rule.filename.replace(/\.md$/, "");
-      return (0, import_node_path8.join)(outputDir, `${baseFilename}.instructions.md`);
+      return (0, import_node_path12.join)(outputDir, `${baseFilename}.instructions.md`);
     }
   },
   cursor: {
@@ -2547,7 +3051,7 @@ var GENERATOR_REGISTRY = {
       return lines.join("\n");
     },
     pathResolver: (rule, outputDir) => {
-      return (0, import_node_path8.join)(outputDir, `${rule.filename}.mdc`);
+      return (0, import_node_path12.join)(outputDir, `${rule.filename}.mdc`);
     }
   },
   codexcli: {
@@ -2583,10 +3087,10 @@ var GENERATOR_REGISTRY = {
     pathResolver: (rule, outputDir) => {
       const outputFormat = rule.frontmatter.windsurfOutputFormat || "directory";
       if (outputFormat === "single-file") {
-        return (0, import_node_path8.join)(outputDir, ".windsurf-rules");
+        return (0, import_node_path12.join)(outputDir, ".windsurf-rules");
       } else {
-        const rulesDir = (0, import_node_path8.join)(outputDir, ".windsurf", "rules");
-        return (0, import_node_path8.join)(rulesDir, `${rule.filename}.md`);
+        const rulesDir = (0, import_node_path12.join)(outputDir, ".windsurf", "rules");
+        return (0, import_node_path12.join)(rulesDir, `${rule.filename}.md`);
       }
     }
   },
@@ -2850,7 +3354,7 @@ function filterRulesForTool(rules, tool, config) {
     if (!targets.includes(tool)) {
       return false;
     }
-    return isToolSpecificRule(rule, tool);
+    return true;
   });
 }
 async function generateForTool(tool, rules, config, baseDir) {
@@ -2905,8 +3409,8 @@ async function generateForTool(tool, rules, config, baseDir) {
 }
 
 // src/core/parser.ts
-var import_node_path9 = require("path");
-var import_gray_matter = __toESM(require("gray-matter"), 1);
+var import_node_path13 = require("path");
+var import_gray_matter2 = __toESM(require("gray-matter"), 1);
 async function parseRulesFromDirectory(aiRulesDir) {
   const ignorePatterns = await loadIgnorePatterns();
   const allRuleFiles = await findFiles(aiRulesDir, ".md");
@@ -2940,7 +3444,7 @@ ${errors.join("\n")}`);
 }
 async function parseRuleFile(filepath) {
   const content = await readFileContent(filepath);
-  const parsed = (0, import_gray_matter.default)(content);
+  const parsed = (0, import_gray_matter2.default)(content);
   try {
     const validatedData = RuleFrontmatterSchema.parse(parsed.data);
     const frontmatter = {
@@ -2959,7 +3463,7 @@ async function parseRuleFile(filepath) {
       },
       ...validatedData.tags !== void 0 && { tags: validatedData.tags }
     };
-    const filename = (0, import_node_path9.basename)(filepath, ".md");
+    const filename = (0, import_node_path13.basename)(filepath, ".md");
     return {
       frontmatter,
       content: parsed.content,
@@ -3067,125 +3571,51 @@ function parseMcpConfig(projectRoot) {
 }
 
 // src/core/mcp-generator.ts
-async function generateMcpConfigs(projectRoot, baseDir, targetTools) {
-  const results = [];
-  const targetRoot = baseDir || projectRoot;
-  const config = parseMcpConfig(projectRoot);
-  if (!config) {
-    return results;
-  }
-  const generators = [
-    {
-      tool: "augmentcode-project",
-      path: path4.join(targetRoot, ".mcp.json"),
-      generate: () => generateAugmentcodeMcp(config)
-    },
-    {
-      tool: "augmentcode-legacy-project",
-      path: path4.join(targetRoot, ".mcp.json"),
-      generate: () => generateAugmentcodeMcp(config)
-    },
-    {
-      tool: "claude-project",
-      path: path4.join(targetRoot, ".mcp.json"),
-      generate: () => generateClaudeMcp(config)
-    },
-    {
-      tool: "copilot-editor",
-      path: path4.join(targetRoot, ".vscode", "mcp.json"),
-      generate: () => generateCopilotMcp(config, "editor")
-    },
-    {
-      tool: "cursor-project",
-      path: path4.join(targetRoot, ".cursor", "mcp.json"),
-      generate: () => generateCursorMcp(config)
-    },
-    {
-      tool: "cline-project",
-      path: path4.join(targetRoot, ".cline", "mcp.json"),
-      generate: () => generateClineMcp(config)
-    },
-    {
-      tool: "codexcli-project",
-      path: path4.join(targetRoot, ".codex", "mcp-config.json"),
-      generate: () => generateCodexMcp(config)
-    },
-    {
-      tool: "gemini-project",
-      path: path4.join(targetRoot, ".gemini", "settings.json"),
-      generate: () => generateGeminiCliMcp(config)
-    },
-    {
-      tool: "junie-project",
-      path: path4.join(targetRoot, ".junie", "mcp-config.json"),
-      generate: () => generateJunieMcp(config)
-    },
-    {
-      tool: "kiro-project",
-      path: path4.join(targetRoot, ".kiro", "mcp.json"),
-      generate: () => generateKiroMcp(config)
-    },
-    {
-      tool: "roo-project",
-      path: path4.join(targetRoot, ".roo", "mcp.json"),
-      generate: () => generateRooMcp(config)
-    },
-    {
-      tool: "windsurf-project",
-      path: path4.join(targetRoot, "mcp_config.json"),
-      generate: () => generateWindsurfMcp(config)
-    }
-  ];
-  const filteredGenerators = targetTools ? generators.filter((g) => {
-    const baseTool = g.tool.split("-")[0];
-    if (!isToolTarget(baseTool)) {
-      return false;
-    }
-    if (baseTool === "augmentcode") {
-      return targetTools.includes("augmentcode") || targetTools.includes("augmentcode-legacy");
-    }
-    return targetTools.includes(baseTool);
-  }) : generators;
-  for (const generator of filteredGenerators) {
-    try {
-      const content = generator.generate();
-      const parsed = JSON.parse(content);
-      if (generator.tool.includes("augmentcode") || generator.tool.includes("claude") || generator.tool.includes("cline") || generator.tool.includes("codexcli") || generator.tool.includes("cursor") || generator.tool.includes("gemini") || generator.tool.includes("junie") || generator.tool.includes("kiro") || generator.tool.includes("roo") || generator.tool.includes("windsurf")) {
-        if (!parsed.mcpServers || Object.keys(parsed.mcpServers).length === 0) {
-          results.push({
-            tool: generator.tool,
-            path: generator.path,
-            status: "skipped"
-          });
-          continue;
-        }
-      } else if (generator.tool.includes("copilot")) {
-        const key = generator.tool.includes("codingAgent") ? "mcpServers" : "servers";
-        if (!parsed[key] || Object.keys(parsed[key]).length === 0) {
-          results.push({
-            tool: generator.tool,
-            path: generator.path,
-            status: "skipped"
-          });
-          continue;
+async function generateMcpConfigurations(mcpConfig, baseDir, targetTools) {
+  const outputs = [];
+  const toolMap = {
+    augmentcode: async (servers, dir) => (await Promise.resolve().then(() => (init_augmentcode(), augmentcode_exports))).generateAugmentcodeMcpConfiguration(
+      servers,
+      dir
+    ),
+    "augmentcode-legacy": async (servers, dir) => (await Promise.resolve().then(() => (init_augmentcode(), augmentcode_exports))).generateAugmentcodeMcpConfiguration(
+      servers,
+      dir
+    ),
+    claudecode: async (servers, dir) => (await Promise.resolve().then(() => (init_claudecode(), claudecode_exports))).generateClaudeMcpConfiguration(
+      servers,
+      dir
+    ),
+    copilot: async (servers, dir) => (await Promise.resolve().then(() => (init_copilot(), copilot_exports))).generateCopilotMcpConfiguration(servers, dir),
+    cursor: async (servers, dir) => (await Promise.resolve().then(() => (init_cursor(), cursor_exports))).generateCursorMcpConfiguration(servers, dir),
+    cline: async (servers, dir) => (await Promise.resolve().then(() => (init_cline(), cline_exports))).generateClineMcpConfiguration(servers, dir),
+    codexcli: async (servers, dir) => (await Promise.resolve().then(() => (init_codexcli(), codexcli_exports))).generateCodexMcpConfiguration(servers, dir),
+    roo: async (servers, dir) => (await Promise.resolve().then(() => (init_roo(), roo_exports))).generateRooMcpConfiguration(servers, dir),
+    geminicli: async (servers, dir) => (await Promise.resolve().then(() => (init_geminicli(), geminicli_exports))).generateGeminiCliMcpConfiguration(
+      servers,
+      dir
+    ),
+    kiro: async (servers, dir) => (await Promise.resolve().then(() => (init_kiro(), kiro_exports))).generateKiroMcpConfiguration(servers, dir),
+    junie: async (servers, dir) => (await Promise.resolve().then(() => (init_junie(), junie_exports))).generateJunieMcpConfiguration(servers, dir),
+    windsurf: async (servers, dir) => (await Promise.resolve().then(() => (init_windsurf(), windsurf_exports))).generateWindsurfMcpConfiguration(
+      servers,
+      dir
+    )
+  };
+  const tools = targetTools || Object.keys(toolMap).filter(isToolTarget);
+  const seenPaths = /* @__PURE__ */ new Set();
+  for (const tool of tools) {
+    if (tool in toolMap) {
+      const results = await toolMap[tool](mcpConfig.mcpServers || {}, baseDir);
+      for (const result of results) {
+        if (!seenPaths.has(result.filepath)) {
+          seenPaths.add(result.filepath);
+          outputs.push({ ...result, tool });
         }
       }
-      await writeFileContent(generator.path, content);
-      results.push({
-        tool: generator.tool,
-        path: generator.path,
-        status: "success"
-      });
-    } catch (error) {
-      results.push({
-        tool: generator.tool,
-        path: generator.path,
-        status: "error",
-        error: error instanceof Error ? error.message : String(error)
-      });
     }
   }
-  return results;
+  return outputs;
 }
 
 // src/cli/commands/generate.ts
@@ -3262,12 +3692,12 @@ async function generateCommand(options = {}) {
       for (const tool of targetTools) {
         switch (tool) {
           case "augmentcode":
-            deleteTasks.push(removeDirectory((0, import_node_path10.join)(".augment", "rules")));
-            deleteTasks.push(removeDirectory((0, import_node_path10.join)(".augment", "ignore")));
+            deleteTasks.push(removeDirectory((0, import_node_path14.join)(".augment", "rules")));
+            deleteTasks.push(removeDirectory((0, import_node_path14.join)(".augment", "ignore")));
             break;
           case "augmentcode-legacy":
             deleteTasks.push(removeClaudeGeneratedFiles());
-            deleteTasks.push(removeDirectory((0, import_node_path10.join)(".augment", "ignore")));
+            deleteTasks.push(removeDirectory((0, import_node_path14.join)(".augment", "ignore")));
             break;
           case "copilot":
             deleteTasks.push(removeDirectory(config.outputPaths.copilot));
@@ -3280,12 +3710,14 @@ async function generateCommand(options = {}) {
             break;
           case "claudecode":
             deleteTasks.push(removeClaudeGeneratedFiles());
+            deleteTasks.push(removeDirectory((0, import_node_path14.join)(".claude", "commands")));
             break;
           case "roo":
             deleteTasks.push(removeDirectory(config.outputPaths.roo));
             break;
           case "geminicli":
             deleteTasks.push(removeDirectory(config.outputPaths.geminicli));
+            deleteTasks.push(removeDirectory((0, import_node_path14.join)(".gemini", "commands")));
             break;
           case "kiro":
             deleteTasks.push(removeDirectory(config.outputPaths.kiro));
@@ -3328,33 +3760,69 @@ Generating configurations for base directory: ${baseDir}`);
     }
     let totalMcpOutputs = 0;
     for (const baseDir of baseDirs) {
-      const mcpResults = await generateMcpConfigs(
+      try {
+        const mcpConfig = parseMcpConfig(process.cwd());
+        if (!mcpConfig || !mcpConfig.mcpServers || Object.keys(mcpConfig.mcpServers).length === 0) {
+          if (config.verbose) {
+            console.log(`No MCP configuration found for ${baseDir}`);
+          }
+          continue;
+        }
+        const mcpResults = await generateMcpConfigurations(
+          mcpConfig,
+          baseDir === process.cwd() ? "." : baseDir,
+          config.defaultTargets
+        );
+        if (mcpResults.length === 0) {
+          if (config.verbose) {
+            console.log(`No MCP configurations generated for ${baseDir}`);
+          }
+          continue;
+        }
+        for (const result of mcpResults) {
+          await writeFileContent(result.filepath, result.content);
+          console.log(`\u2705 Generated ${result.tool} MCP configuration: ${result.filepath}`);
+          totalMcpOutputs++;
+        }
+      } catch (error) {
+        if (config.verbose) {
+          console.error(
+            `\u274C Failed to generate MCP configurations: ${error instanceof Error ? error.message : String(error)}`
+          );
+        }
+      }
+    }
+    if (config.verbose) {
+      console.log("\nGenerating command files...");
+    }
+    let totalCommandOutputs = 0;
+    for (const baseDir of baseDirs) {
+      const commandResults = await generateCommands(
         process.cwd(),
         baseDir === process.cwd() ? void 0 : baseDir,
         config.defaultTargets
       );
-      if (mcpResults.length === 0) {
+      if (commandResults.length === 0) {
         if (config.verbose) {
-          console.log(`No MCP configuration found for ${baseDir}`);
+          console.log(`No commands found for ${baseDir}`);
         }
         continue;
       }
-      for (const result of mcpResults) {
-        if (result.status === "success") {
-          console.log(`\u2705 Generated ${result.tool} MCP configuration: ${result.path}`);
-          totalMcpOutputs++;
-        } else if (result.status === "error") {
-          console.error(`\u274C Failed to generate ${result.tool} MCP configuration: ${result.error}`);
-        } else if (config.verbose && result.status === "skipped") {
-          console.log(`\u23ED\uFE0F  Skipped ${result.tool} MCP configuration (no servers configured)`);
-        }
+      for (const result of commandResults) {
+        await writeFileContent(result.filepath, result.content);
+        console.log(`\u2705 Generated ${result.tool} command: ${result.filepath}`);
+        totalCommandOutputs++;
       }
     }
-    const totalGenerated = totalOutputs + totalMcpOutputs;
+    const totalGenerated = totalOutputs + totalMcpOutputs + totalCommandOutputs;
     if (totalGenerated > 0) {
+      const parts = [];
+      if (totalOutputs > 0) parts.push(`${totalOutputs} configurations`);
+      if (totalMcpOutputs > 0) parts.push(`${totalMcpOutputs} MCP configurations`);
+      if (totalCommandOutputs > 0) parts.push(`${totalCommandOutputs} commands`);
       console.log(
         `
-\u{1F389} All done! Generated ${totalGenerated} file(s) total (${totalOutputs} configurations + ${totalMcpOutputs} MCP configurations)`
+\u{1F389} All done! Generated ${totalGenerated} file(s) total (${parts.join(" + ")})`
       );
     }
   } catch (error) {
@@ -3365,9 +3833,9 @@ Generating configurations for base directory: ${baseDir}`);
 
 // src/cli/commands/gitignore.ts
 var import_node_fs2 = require("fs");
-var import_node_path11 = require("path");
+var import_node_path15 = require("path");
 var gitignoreCommand = async () => {
-  const gitignorePath = (0, import_node_path11.join)(process.cwd(), ".gitignore");
+  const gitignorePath = (0, import_node_path15.join)(process.cwd(), ".gitignore");
   const rulesFilesToIgnore = [
     "# Generated by rulesync - AI tool configuration files",
     "**/.github/copilot-instructions.md",
@@ -3378,6 +3846,7 @@ var gitignoreCommand = async () => {
     "**/.clineignore",
     "**/CLAUDE.md",
     "**/.claude/memories/",
+    "**/.claude/commands/",
     "**/codex.md",
     "**/.codexignore",
     "**/.roo/rules/",
@@ -3385,6 +3854,7 @@ var gitignoreCommand = async () => {
     "**/.copilotignore",
     "**/GEMINI.md",
     "**/.gemini/memories/",
+    "**/.gemini/commands/",
     "**/.aiexclude",
     "**/.aiignore",
     "**/.augmentignore",
@@ -3431,12 +3901,12 @@ ${linesToAdd.join("\n")}
 };
 
 // src/core/importer.ts
-var import_node_path18 = require("path");
-var import_gray_matter6 = __toESM(require("gray-matter"), 1);
+var import_node_path22 = require("path");
+var import_gray_matter7 = __toESM(require("gray-matter"), 1);
 
 // src/parsers/augmentcode.ts
-var import_node_path12 = require("path");
-var import_gray_matter2 = __toESM(require("gray-matter"), 1);
+var import_node_path16 = require("path");
+var import_gray_matter3 = __toESM(require("gray-matter"), 1);
 
 // src/utils/parser-helpers.ts
 function createParseResult() {
@@ -3484,7 +3954,7 @@ async function parseAugmentcodeLegacyConfiguration(baseDir = process.cwd()) {
 async function parseUnifiedAugmentcode(baseDir, config) {
   const result = createParseResult();
   if (config.rulesDir) {
-    const rulesDir = (0, import_node_path12.join)(baseDir, config.rulesDir);
+    const rulesDir = (0, import_node_path16.join)(baseDir, config.rulesDir);
     if (await fileExists(rulesDir)) {
       const rulesResult = await parseAugmentRules(rulesDir, config);
       addRules(result, rulesResult.rules);
@@ -3497,7 +3967,7 @@ async function parseUnifiedAugmentcode(baseDir, config) {
     }
   }
   if (config.legacyFilePath) {
-    const legacyPath = (0, import_node_path12.join)(baseDir, config.legacyFilePath);
+    const legacyPath = (0, import_node_path16.join)(baseDir, config.legacyFilePath);
     if (await fileExists(legacyPath)) {
       const legacyResult = await parseAugmentGuidelines(legacyPath, config);
       if (legacyResult.rule) {
@@ -3521,16 +3991,16 @@ async function parseAugmentRules(rulesDir, config) {
     const files = await readdir2(rulesDir);
     for (const file of files) {
       if (file.endsWith(".md") || file.endsWith(".mdc")) {
-        const filePath = (0, import_node_path12.join)(rulesDir, file);
+        const filePath = (0, import_node_path16.join)(rulesDir, file);
         try {
           const rawContent = await readFileContent(filePath);
-          const parsed = (0, import_gray_matter2.default)(rawContent);
+          const parsed = (0, import_gray_matter3.default)(rawContent);
           const frontmatterData = parsed.data;
           const ruleType = frontmatterData.type || "manual";
           const description = frontmatterData.description || "";
           const tags = Array.isArray(frontmatterData.tags) ? frontmatterData.tags : void 0;
           const isRoot = ruleType === "always";
-          const filename = (0, import_node_path12.basename)(file, file.endsWith(".mdc") ? ".mdc" : ".md");
+          const filename = (0, import_node_path16.basename)(file, file.endsWith(".mdc") ? ".mdc" : ".md");
           const frontmatter = {
             root: isRoot,
             targets: [config.targetName],
@@ -3588,8 +4058,8 @@ async function parseAugmentGuidelines(guidelinesPath, config) {
 }
 
 // src/parsers/shared-helpers.ts
-var import_node_path13 = require("path");
-var import_gray_matter3 = __toESM(require("gray-matter"), 1);
+var import_node_path17 = require("path");
+var import_gray_matter4 = __toESM(require("gray-matter"), 1);
 async function parseConfigurationFiles(baseDir = process.cwd(), config) {
   const errors = [];
   const rules = [];
@@ -3602,7 +4072,7 @@ async function parseConfigurationFiles(baseDir = process.cwd(), config) {
         let content;
         let frontmatter;
         if (mainFile.useFrontmatter) {
-          const parsed = (0, import_gray_matter3.default)(rawContent);
+          const parsed = (0, import_gray_matter4.default)(rawContent);
           content = parsed.content.trim();
           const parsedFrontmatter = parsed.data;
           frontmatter = {
@@ -3644,14 +4114,14 @@ async function parseConfigurationFiles(baseDir = process.cwd(), config) {
           const files = await readdir2(dirPath);
           for (const file of files) {
             if (file.endsWith(dirConfig.filePattern)) {
-              const filePath = (0, import_node_path13.join)(dirPath, file);
+              const filePath = (0, import_node_path17.join)(dirPath, file);
               const fileResult = await safeAsyncOperation(async () => {
                 const rawContent = await readFileContent(filePath);
                 let content;
                 let frontmatter;
                 const filename = file.replace(new RegExp(`\\${dirConfig.filePattern}$`), "");
                 if (dirConfig.filePattern === ".instructions.md") {
-                  const parsed = (0, import_gray_matter3.default)(rawContent);
+                  const parsed = (0, import_gray_matter4.default)(rawContent);
                   content = parsed.content.trim();
                   const parsedFrontmatter = parsed.data;
                   frontmatter = {
@@ -3717,6 +4187,13 @@ async function parseMemoryBasedConfiguration(baseDir = process.cwd(), config) {
       const memoryRules = await parseMemoryFiles(memoryDir, config);
       rules.push(...memoryRules);
     }
+    if (config.commandsDirPath) {
+      const commandsDir = resolvePath(config.commandsDirPath, baseDir);
+      if (await fileExists(commandsDir)) {
+        const commandsRules = await parseCommandsFiles(commandsDir, config);
+        rules.push(...commandsRules);
+      }
+    }
     const settingsPath = resolvePath(config.settingsPath, baseDir);
     if (await fileExists(settingsPath)) {
       const settingsResult = await parseSettingsFile(settingsPath, config.tool);
@@ -3782,10 +4259,10 @@ async function parseMemoryFiles(memoryDir, config) {
     const files = await readdir2(memoryDir);
     for (const file of files) {
       if (file.endsWith(".md")) {
-        const filePath = (0, import_node_path13.join)(memoryDir, file);
+        const filePath = (0, import_node_path17.join)(memoryDir, file);
         const content = await readFileContent(filePath);
         if (content.trim()) {
-          const filename = (0, import_node_path13.basename)(file, ".md");
+          const filename = (0, import_node_path17.basename)(file, ".md");
           const frontmatter = {
             root: false,
             targets: [config.tool],
@@ -3805,6 +4282,54 @@ async function parseMemoryFiles(memoryDir, config) {
   }
   return rules;
 }
+async function parseCommandsFiles(commandsDir, config) {
+  const rules = [];
+  try {
+    const { readdir: readdir2 } = await import("fs/promises");
+    const files = await readdir2(commandsDir);
+    for (const file of files) {
+      if (file.endsWith(".md")) {
+        const filePath = (0, import_node_path17.join)(commandsDir, file);
+        const content = await readFileContent(filePath);
+        if (content.trim()) {
+          const filename = (0, import_node_path17.basename)(file, ".md");
+          let frontmatter;
+          let ruleContent;
+          try {
+            const parsed = (0, import_gray_matter4.default)(content);
+            ruleContent = parsed.content.trim();
+            const parsedFrontmatter = parsed.data;
+            frontmatter = {
+              root: false,
+              targets: [config.tool],
+              description: parsedFrontmatter.description || `Command: ${filename}`,
+              globs: ["**/*"]
+            };
+          } catch {
+            ruleContent = content.trim();
+            frontmatter = {
+              root: false,
+              targets: [config.tool],
+              description: `Command: ${filename}`,
+              globs: ["**/*"]
+            };
+          }
+          if (ruleContent) {
+            rules.push({
+              frontmatter,
+              content: ruleContent,
+              filename,
+              filepath: filePath,
+              type: "command"
+            });
+          }
+        }
+      }
+    }
+  } catch {
+  }
+  return rules;
+}
 async function parseSettingsFile(settingsPath, tool) {
   const errors = [];
   let ignorePatterns;
@@ -3852,7 +4377,8 @@ async function parseClaudeConfiguration(baseDir = process.cwd()) {
     settingsPath: ".claude/settings.json",
     mainDescription: "Main Claude Code configuration",
     memoryDescription: "Memory file",
-    filenamePrefix: "claude"
+    filenamePrefix: "claude",
+    commandsDirPath: ".claude/commands"
   });
 }
 
@@ -3877,7 +4403,7 @@ async function parseClineConfiguration(baseDir = process.cwd()) {
 }
 
 // src/parsers/codexcli.ts
-var import_node_path14 = require("path");
+var import_node_path18 = require("path");
 
 // src/parsers/copilot.ts
 async function parseCopilotConfiguration(baseDir = process.cwd()) {
@@ -3900,10 +4426,10 @@ async function parseCopilotConfiguration(baseDir = process.cwd()) {
 }
 
 // src/parsers/cursor.ts
-var import_node_path15 = require("path");
-var import_gray_matter4 = __toESM(require("gray-matter"), 1);
+var import_node_path19 = require("path");
+var import_gray_matter5 = __toESM(require("gray-matter"), 1);
 var import_js_yaml = require("js-yaml");
-var import_mini7 = require("zod/mini");
+var import_mini8 = require("zod/mini");
 var customMatterOptions = {
   engines: {
     yaml: {
@@ -3931,7 +4457,7 @@ var customMatterOptions = {
   }
 };
 function convertCursorMdcFrontmatter(cursorFrontmatter, _filename) {
-  const FrontmatterSchema = import_mini7.z.record(import_mini7.z.string(), import_mini7.z.unknown());
+  const FrontmatterSchema = import_mini8.z.record(import_mini8.z.string(), import_mini8.z.unknown());
   const parseResult = FrontmatterSchema.safeParse(cursorFrontmatter);
   if (!parseResult.success) {
     return {
@@ -4025,11 +4551,11 @@ async function parseCursorConfiguration(baseDir = process.cwd()) {
   const rules = [];
   let ignorePatterns;
   let mcpServers;
-  const cursorFilePath = (0, import_node_path15.join)(baseDir, ".cursorrules");
+  const cursorFilePath = (0, import_node_path19.join)(baseDir, ".cursorrules");
   if (await fileExists(cursorFilePath)) {
     try {
       const rawContent = await readFileContent(cursorFilePath);
-      const parsed = (0, import_gray_matter4.default)(rawContent, customMatterOptions);
+      const parsed = (0, import_gray_matter5.default)(rawContent, customMatterOptions);
       const content = parsed.content.trim();
       if (content) {
         const frontmatter = convertCursorMdcFrontmatter(parsed.data, "cursorrules");
@@ -4046,20 +4572,20 @@ async function parseCursorConfiguration(baseDir = process.cwd()) {
       errors.push(`Failed to parse .cursorrules file: ${errorMessage}`);
     }
   }
-  const cursorRulesDir = (0, import_node_path15.join)(baseDir, ".cursor", "rules");
+  const cursorRulesDir = (0, import_node_path19.join)(baseDir, ".cursor", "rules");
   if (await fileExists(cursorRulesDir)) {
     try {
       const { readdir: readdir2 } = await import("fs/promises");
       const files = await readdir2(cursorRulesDir);
       for (const file of files) {
         if (file.endsWith(".mdc")) {
-          const filePath = (0, import_node_path15.join)(cursorRulesDir, file);
+          const filePath = (0, import_node_path19.join)(cursorRulesDir, file);
           try {
             const rawContent = await readFileContent(filePath);
-            const parsed = (0, import_gray_matter4.default)(rawContent, customMatterOptions);
+            const parsed = (0, import_gray_matter5.default)(rawContent, customMatterOptions);
             const content = parsed.content.trim();
             if (content) {
-              const filename = (0, import_node_path15.basename)(file, ".mdc");
+              const filename = (0, import_node_path19.basename)(file, ".mdc");
               const frontmatter = convertCursorMdcFrontmatter(parsed.data, filename);
               rules.push({
                 frontmatter,
@@ -4082,7 +4608,7 @@ async function parseCursorConfiguration(baseDir = process.cwd()) {
   if (rules.length === 0) {
     errors.push("No Cursor configuration files found (.cursorrules or .cursor/rules/*.mdc)");
   }
-  const cursorIgnorePath = (0, import_node_path15.join)(baseDir, ".cursorignore");
+  const cursorIgnorePath = (0, import_node_path19.join)(baseDir, ".cursorignore");
   if (await fileExists(cursorIgnorePath)) {
     try {
       const content = await readFileContent(cursorIgnorePath);
@@ -4095,7 +4621,7 @@ async function parseCursorConfiguration(baseDir = process.cwd()) {
       errors.push(`Failed to parse .cursorignore: ${errorMessage}`);
     }
   }
-  const cursorMcpPath = (0, import_node_path15.join)(baseDir, ".cursor", "mcp.json");
+  const cursorMcpPath = (0, import_node_path19.join)(baseDir, ".cursor", "mcp.json");
   if (await fileExists(cursorMcpPath)) {
     try {
       const content = await readFileContent(cursorMcpPath);
@@ -4139,16 +4665,17 @@ async function parseGeminiConfiguration(baseDir = process.cwd()) {
     additionalIgnoreFile: {
       path: ".aiexclude",
       parser: parseAiexclude
-    }
+    },
+    commandsDirPath: ".gemini/commands"
   });
 }
 
 // src/parsers/junie.ts
-var import_node_path16 = require("path");
+var import_node_path20 = require("path");
 async function parseJunieConfiguration(baseDir = process.cwd()) {
   const errors = [];
   const rules = [];
-  const guidelinesPath = (0, import_node_path16.join)(baseDir, ".junie", "guidelines.md");
+  const guidelinesPath = (0, import_node_path20.join)(baseDir, ".junie", "guidelines.md");
   if (!await fileExists(guidelinesPath)) {
     errors.push(".junie/guidelines.md file not found");
     return { rules, errors };
@@ -4201,8 +4728,8 @@ async function parseRooConfiguration(baseDir = process.cwd()) {
 
 // src/parsers/windsurf.ts
 var import_promises3 = require("fs/promises");
-var import_node_path17 = require("path");
-var import_gray_matter5 = __toESM(require("gray-matter"), 1);
+var import_node_path21 = require("path");
+var import_gray_matter6 = __toESM(require("gray-matter"), 1);
 
 // src/core/importer.ts
 async function importConfiguration(options) {
@@ -4288,7 +4815,7 @@ async function importConfiguration(options) {
   if (rules.length === 0 && !ignorePatterns && !mcpServers) {
     return { success: false, rulesCreated: 0, errors };
   }
-  const rulesDirPath = (0, import_node_path18.join)(baseDir, rulesDir);
+  const rulesDirPath = (0, import_node_path22.join)(baseDir, rulesDir);
   try {
     const { mkdir: mkdir3 } = await import("fs/promises");
     await mkdir3(rulesDirPath, { recursive: true });
@@ -4301,8 +4828,13 @@ async function importConfiguration(options) {
   for (const rule of rules) {
     try {
       const baseFilename = rule.filename;
-      const filename = await generateUniqueFilename(rulesDirPath, baseFilename);
-      const filePath = (0, import_node_path18.join)(rulesDirPath, `${filename}.md`);
+      let targetDir = rulesDirPath;
+      if (rule.type === "command") {
+        targetDir = (0, import_node_path22.join)(rulesDirPath, "commands");
+        const { mkdir: mkdir3 } = await import("fs/promises");
+        await mkdir3(targetDir, { recursive: true });
+      }
+      const filePath = (0, import_node_path22.join)(targetDir, `${baseFilename}.md`);
       const content = generateRuleFileContent(rule);
       await writeFileContent(filePath, content);
       rulesCreated++;
@@ -4317,7 +4849,7 @@ async function importConfiguration(options) {
   let ignoreFileCreated = false;
   if (ignorePatterns && ignorePatterns.length > 0) {
     try {
-      const rulesyncignorePath = (0, import_node_path18.join)(baseDir, ".rulesyncignore");
+      const rulesyncignorePath = (0, import_node_path22.join)(baseDir, ".rulesyncignore");
       const ignoreContent = `${ignorePatterns.join("\n")}
 `;
       await writeFileContent(rulesyncignorePath, ignoreContent);
@@ -4333,7 +4865,7 @@ async function importConfiguration(options) {
   let mcpFileCreated = false;
   if (mcpServers && Object.keys(mcpServers).length > 0) {
     try {
-      const mcpPath = (0, import_node_path18.join)(baseDir, rulesDir, ".mcp.json");
+      const mcpPath = (0, import_node_path22.join)(baseDir, rulesDir, ".mcp.json");
       const mcpContent = `${JSON.stringify({ mcpServers }, null, 2)}
 `;
       await writeFileContent(mcpPath, mcpContent);
@@ -4355,17 +4887,16 @@ async function importConfiguration(options) {
   };
 }
 function generateRuleFileContent(rule) {
-  const frontmatter = import_gray_matter6.default.stringify("", rule.frontmatter);
-  return frontmatter + rule.content;
-}
-async function generateUniqueFilename(rulesDir, baseFilename) {
-  let filename = baseFilename;
-  let counter = 1;
-  while (await fileExists((0, import_node_path18.join)(rulesDir, `${filename}.md`))) {
-    filename = `${baseFilename}-${counter}`;
-    counter++;
+  if (rule.type === "command") {
+    const simplifiedFrontmatter = {
+      description: rule.frontmatter.description,
+      targets: rule.frontmatter.targets
+    };
+    const frontmatter2 = import_gray_matter7.default.stringify("", simplifiedFrontmatter);
+    return frontmatter2 + rule.content;
   }
-  return filename;
+  const frontmatter = import_gray_matter7.default.stringify("", rule.frontmatter);
+  return frontmatter + rule.content;
 }
 
 // src/cli/commands/import.ts
@@ -4428,7 +4959,7 @@ async function importCommand(options = {}) {
 }
 
 // src/cli/commands/init.ts
-var import_node_path19 = require("path");
+var import_node_path23 = require("path");
 async function initCommand() {
   const aiRulesDir = ".rulesync";
   console.log("Initializing rulesync...");
@@ -4475,7 +5006,7 @@ globs: ["**/*"]
 - Follow single responsibility principle
 `
   };
-  const filepath = (0, import_node_path19.join)(aiRulesDir, sampleFile.filename);
+  const filepath = (0, import_node_path23.join)(aiRulesDir, sampleFile.filename);
   if (!await fileExists(filepath)) {
     await writeFileContent(filepath, sampleFile.content);
     console.log(`Created ${filepath}`);
@@ -4619,7 +5150,7 @@ async function watchCommand() {
 
 // src/cli/index.ts
 var program = new import_commander.Command();
-program.name("rulesync").description("Unified AI rules management CLI tool").version("0.57.0");
+program.name("rulesync").description("Unified AI rules management CLI tool").version("0.59.0");
 program.command("init").description("Initialize rulesync in current directory").action(initCommand);
 program.command("add <filename>").description("Add a new rule file").action(addCommand);
 program.command("gitignore").description("Add generated files to .gitignore").action(gitignoreCommand);