rulesync 0.57.0 → 0.58.0

package/dist/index.cjs

@@ -771,132 +771,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 +1200,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 +1411,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 +1687,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 +2275,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 +2342,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 +2351,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 +2359,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 +2379,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 +2400,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 +2442,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 +2495,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 +2571,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 +2651,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 +2691,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 +2727,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 +2994,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 +3049,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 +3084,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 +3103,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,
@@ -3262,12 +3406,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 +3424,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));
@@ -3350,11 +3496,37 @@ Generating configurations for base directory: ${baseDir}`);
         }
       }
     }
-    const totalGenerated = totalOutputs + totalMcpOutputs;
+    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 (commandResults.length === 0) {
+        if (config.verbose) {
+          console.log(`No commands found for ${baseDir}`);
+        }
+        continue;
+      }
+      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 + 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 +3537,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 +3550,7 @@ var gitignoreCommand = async () => {
     "**/.clineignore",
     "**/CLAUDE.md",
     "**/.claude/memories/",
+    "**/.claude/commands/",
     "**/codex.md",
     "**/.codexignore",
     "**/.roo/rules/",
@@ -3385,6 +3558,7 @@ var gitignoreCommand = async () => {
     "**/.copilotignore",
     "**/GEMINI.md",
     "**/.gemini/memories/",
+    "**/.gemini/commands/",
     "**/.aiexclude",
     "**/.aiignore",
     "**/.augmentignore",
@@ -3431,12 +3605,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 +3658,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 +3671,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 +3695,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 +3762,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 +3776,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 +3818,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 +3891,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 +3963,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 +3986,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 +4081,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 +4107,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 +4130,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 +4161,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 +4255,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 +4276,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 +4312,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 +4325,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 +4369,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 +4432,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 +4519,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 +4532,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 +4553,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 +4569,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 +4591,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 +4663,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 +4710,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 +4854,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.58.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);