rulesync 0.57.0 → 0.59.0

package/dist/index.js

@@ -1,38 +1,16 @@
 #!/usr/bin/env node
-import {
-  generateJunieMcp
-} from "./chunk-VNT6AHHO.js";
-import {
-  generateKiroMcp
-} from "./chunk-LXTA7DBA.js";
-import {
-  generateRooMcp
-} from "./chunk-PCATT4UZ.js";
-import {
-  generateWindsurfMcp
-} from "./chunk-7E4U4YAB.js";
-import {
-  generateAugmentcodeMcp
-} from "./chunk-YTU3SCQO.js";
-import {
-  generateClaudeMcp
-} from "./chunk-VKNCBVZF.js";
-import {
-  generateClineMcp
-} from "./chunk-W2WU253H.js";
-import {
-  generateCodexMcp
-} from "./chunk-7UBF4OLN.js";
-import {
-  generateCopilotMcp
-} from "./chunk-KUGTKMNW.js";
-import {
-  generateCursorMcp
-} from "./chunk-OA473EXZ.js";
-import {
-  generateGeminiCliMcp
-} from "./chunk-WAX2UANS.js";
-import "./chunk-J3TBR5EP.js";
+import "./chunk-S3GB3VQK.js";
+import "./chunk-LXTA7DBA.js";
+import "./chunk-PCATT4UZ.js";
+import "./chunk-3YQ42A7G.js";
+import "./chunk-YTU3SCQO.js";
+import "./chunk-EG7LNNMW.js";
+import "./chunk-VYO76WDU.js";
+import "./chunk-DJWXF2WO.js";
+import "./chunk-KUGTKMNW.js";
+import "./chunk-LIV53UU5.js";
+import "./chunk-5SRMJNDW.js";
+import "./chunk-OCK47GE7.js";
 import {
   ALL_TOOL_TARGETS,
   RulesyncTargetsSchema,
@@ -129,128 +107,137 @@ var ClaudeSettingsSchema = z.looseObject({
   )
 });
 
-// src/types/config.ts
+// src/types/commands.ts
 import { z as z2 } from "zod/mini";
-var ConfigSchema = z2.object({
-  aiRulesDir: z2.string(),
-  outputPaths: z2.record(ToolTargetSchema, z2.string()),
-  watchEnabled: z2.boolean(),
-  defaultTargets: ToolTargetsSchema
+var CommandFrontmatterSchema = z2.object({
+  description: z2.optional(z2.string())
 });
 
-// src/types/config-options.ts
+// src/types/config.ts
 import { z as z3 } from "zod/mini";
-var OutputPathsSchema = z3.object({
-  augmentcode: z3.optional(z3.string()),
-  "augmentcode-legacy": z3.optional(z3.string()),
-  copilot: z3.optional(z3.string()),
-  cursor: z3.optional(z3.string()),
-  cline: z3.optional(z3.string()),
-  claudecode: z3.optional(z3.string()),
-  codexcli: z3.optional(z3.string()),
-  roo: z3.optional(z3.string()),
-  geminicli: z3.optional(z3.string()),
-  kiro: z3.optional(z3.string()),
-  junie: z3.optional(z3.string()),
-  windsurf: z3.optional(z3.string())
+var ConfigSchema = z3.object({
+  aiRulesDir: z3.string(),
+  outputPaths: z3.record(ToolTargetSchema, z3.string()),
+  watchEnabled: z3.boolean(),
+  defaultTargets: ToolTargetsSchema,
+  claudecodeCommands: z3.optional(z3.string()),
+  geminicliCommands: z3.optional(z3.string())
+});
+
+// src/types/config-options.ts
+import { z as z4 } from "zod/mini";
+var OutputPathsSchema = z4.object({
+  augmentcode: z4.optional(z4.string()),
+  "augmentcode-legacy": z4.optional(z4.string()),
+  copilot: z4.optional(z4.string()),
+  cursor: z4.optional(z4.string()),
+  cline: z4.optional(z4.string()),
+  claudecode: z4.optional(z4.string()),
+  codexcli: z4.optional(z4.string()),
+  roo: z4.optional(z4.string()),
+  geminicli: z4.optional(z4.string()),
+  kiro: z4.optional(z4.string()),
+  junie: z4.optional(z4.string()),
+  windsurf: z4.optional(z4.string())
 });
-var ConfigOptionsSchema = z3.object({
-  aiRulesDir: z3.optional(z3.string()),
-  outputPaths: z3.optional(OutputPathsSchema),
-  watchEnabled: z3.optional(z3.boolean()),
-  defaultTargets: z3.optional(ToolTargetsSchema),
-  targets: z3.optional(z3.array(ToolTargetSchema)),
-  exclude: z3.optional(z3.array(ToolTargetSchema)),
-  verbose: z3.optional(z3.boolean()),
-  delete: z3.optional(z3.boolean()),
-  baseDir: z3.optional(z3.union([z3.string(), z3.array(z3.string())])),
-  watch: z3.optional(
-    z3.object({
-      enabled: z3.optional(z3.boolean()),
-      interval: z3.optional(z3.number()),
-      ignore: z3.optional(z3.array(z3.string()))
+var ConfigOptionsSchema = z4.object({
+  aiRulesDir: z4.optional(z4.string()),
+  outputPaths: z4.optional(OutputPathsSchema),
+  watchEnabled: z4.optional(z4.boolean()),
+  defaultTargets: z4.optional(ToolTargetsSchema),
+  targets: z4.optional(z4.array(ToolTargetSchema)),
+  exclude: z4.optional(z4.array(ToolTargetSchema)),
+  verbose: z4.optional(z4.boolean()),
+  delete: z4.optional(z4.boolean()),
+  baseDir: z4.optional(z4.union([z4.string(), z4.array(z4.string())])),
+  watch: z4.optional(
+    z4.object({
+      enabled: z4.optional(z4.boolean()),
+      interval: z4.optional(z4.number()),
+      ignore: z4.optional(z4.array(z4.string()))
     })
   )
 });
-var MergedConfigSchema = z3.object({
-  aiRulesDir: z3.string(),
-  outputPaths: z3.record(ToolTargetSchema, z3.string()),
-  watchEnabled: z3.boolean(),
+var MergedConfigSchema = z4.object({
+  aiRulesDir: z4.string(),
+  outputPaths: z4.record(ToolTargetSchema, z4.string()),
+  watchEnabled: z4.boolean(),
   defaultTargets: ToolTargetsSchema,
-  targets: z3.optional(z3.array(ToolTargetSchema)),
-  exclude: z3.optional(z3.array(ToolTargetSchema)),
-  verbose: z3.optional(z3.boolean()),
-  delete: z3.optional(z3.boolean()),
-  baseDir: z3.optional(z3.union([z3.string(), z3.array(z3.string())])),
-  configPath: z3.optional(z3.string()),
-  watch: z3.optional(
-    z3.object({
-      enabled: z3.optional(z3.boolean()),
-      interval: z3.optional(z3.number()),
-      ignore: z3.optional(z3.array(z3.string()))
+  targets: z4.optional(z4.array(ToolTargetSchema)),
+  exclude: z4.optional(z4.array(ToolTargetSchema)),
+  verbose: z4.optional(z4.boolean()),
+  delete: z4.optional(z4.boolean()),
+  baseDir: z4.optional(z4.union([z4.string(), z4.array(z4.string())])),
+  configPath: z4.optional(z4.string()),
+  watch: z4.optional(
+    z4.object({
+      enabled: z4.optional(z4.boolean()),
+      interval: z4.optional(z4.number()),
+      ignore: z4.optional(z4.array(z4.string()))
     })
   )
 });
 
 // src/types/mcp.ts
-import { z as z4 } from "zod/mini";
-var McpTransportTypeSchema = z4.enum(["stdio", "sse", "http"]);
-var McpServerBaseSchema = z4.object({
-  command: z4.optional(z4.string()),
-  args: z4.optional(z4.array(z4.string())),
-  url: z4.optional(z4.string()),
-  httpUrl: z4.optional(z4.string()),
-  env: z4.optional(z4.record(z4.string(), z4.string())),
-  disabled: z4.optional(z4.boolean()),
-  networkTimeout: z4.optional(z4.number()),
-  timeout: z4.optional(z4.number()),
-  trust: z4.optional(z4.boolean()),
-  cwd: z4.optional(z4.string()),
-  transport: z4.optional(McpTransportTypeSchema),
-  type: z4.optional(z4.enum(["sse", "streamable-http"])),
-  alwaysAllow: z4.optional(z4.array(z4.string())),
-  tools: z4.optional(z4.array(z4.string())),
-  kiroAutoApprove: z4.optional(z4.array(z4.string())),
-  kiroAutoBlock: z4.optional(z4.array(z4.string())),
-  headers: z4.optional(z4.record(z4.string(), z4.string()))
+import { z as z5 } from "zod/mini";
+var McpTransportTypeSchema = z5.enum(["stdio", "sse", "http"]);
+var McpServerBaseSchema = z5.object({
+  command: z5.optional(z5.string()),
+  args: z5.optional(z5.array(z5.string())),
+  url: z5.optional(z5.string()),
+  httpUrl: z5.optional(z5.string()),
+  env: z5.optional(z5.record(z5.string(), z5.string())),
+  disabled: z5.optional(z5.boolean()),
+  networkTimeout: z5.optional(z5.number()),
+  timeout: z5.optional(z5.number()),
+  trust: z5.optional(z5.boolean()),
+  cwd: z5.optional(z5.string()),
+  transport: z5.optional(McpTransportTypeSchema),
+  type: z5.optional(z5.enum(["sse", "streamable-http"])),
+  alwaysAllow: z5.optional(z5.array(z5.string())),
+  tools: z5.optional(z5.array(z5.string())),
+  kiroAutoApprove: z5.optional(z5.array(z5.string())),
+  kiroAutoBlock: z5.optional(z5.array(z5.string())),
+  headers: z5.optional(z5.record(z5.string(), z5.string()))
 });
-var RulesyncMcpServerSchema = z4.extend(McpServerBaseSchema, {
-  targets: z4.optional(RulesyncTargetsSchema)
+var RulesyncMcpServerSchema = z5.extend(McpServerBaseSchema, {
+  targets: z5.optional(RulesyncTargetsSchema)
 });
-var McpConfigSchema = z4.object({
-  mcpServers: z4.record(z4.string(), McpServerBaseSchema)
+var McpConfigSchema = z5.object({
+  mcpServers: z5.record(z5.string(), McpServerBaseSchema)
 });
-var RulesyncMcpConfigSchema = z4.object({
-  mcpServers: z4.record(z4.string(), RulesyncMcpServerSchema)
+var RulesyncMcpConfigSchema = z5.object({
+  mcpServers: z5.record(z5.string(), RulesyncMcpServerSchema)
 });
 
 // src/types/rules.ts
-import { z as z5 } from "zod/mini";
-var RuleFrontmatterSchema = z5.object({
-  root: z5.optional(z5.boolean()),
-  targets: z5.optional(RulesyncTargetsSchema),
-  description: z5.optional(z5.string()),
-  globs: z5.optional(z5.array(z5.string())),
-  cursorRuleType: z5.optional(z5.enum(["always", "manual", "specificFiles", "intelligently"])),
-  windsurfActivationMode: z5.optional(z5.enum(["always", "manual", "model-decision", "glob"])),
-  windsurfOutputFormat: z5.optional(z5.enum(["single-file", "directory"])),
-  tags: z5.optional(z5.array(z5.string()))
+import { z as z6 } from "zod/mini";
+var RuleFrontmatterSchema = z6.object({
+  root: z6.optional(z6.boolean()),
+  targets: z6.optional(RulesyncTargetsSchema),
+  description: z6.optional(z6.string()),
+  globs: z6.optional(z6.array(z6.string())),
+  cursorRuleType: z6.optional(z6.enum(["always", "manual", "specificFiles", "intelligently"])),
+  windsurfActivationMode: z6.optional(z6.enum(["always", "manual", "model-decision", "glob"])),
+  windsurfOutputFormat: z6.optional(z6.enum(["single-file", "directory"])),
+  tags: z6.optional(z6.array(z6.string()))
 });
-var ParsedRuleSchema = z5.object({
+var ParsedRuleSchema = z6.object({
   frontmatter: RuleFrontmatterSchema,
-  content: z5.string(),
-  filename: z5.string(),
-  filepath: z5.string()
+  content: z6.string(),
+  filename: z6.string(),
+  filepath: z6.string(),
+  type: z6.optional(z6.enum(["rule", "command"]))
 });
-var GeneratedOutputSchema = z5.object({
+var GeneratedOutputSchema = z6.object({
   tool: ToolTargetSchema,
-  filepath: z5.string(),
-  content: z5.string()
+  filepath: z6.string(),
+  content: z6.string()
 });
-var GenerateOptionsSchema = z5.object({
-  targetTools: z5.optional(ToolTargetsSchema),
-  outputDir: z5.optional(z5.string()),
-  watch: z5.optional(z5.boolean())
+var GenerateOptionsSchema = z6.object({
+  targetTools: z6.optional(ToolTargetsSchema),
+  outputDir: z6.optional(z6.string()),
+  watch: z6.optional(z6.boolean())
 });
 
 // src/utils/config-loader.ts
@@ -542,28 +529,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) {
@@ -775,10 +740,165 @@ export default config;
 }
 
 // src/cli/commands/generate.ts
-import { join as join11 } from "path";
+import { join as join14 } from "path";
 
-// src/generators/ignore/shared-factory.ts
+// src/core/command-generator.ts
+import { join as join5 } from "path";
+
+// src/generators/commands/claudecode.ts
 import { join as join3 } from "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 join3(baseDir, ".claude", "commands", `${flattenedName}.md`);
+  }
+};
+
+// src/generators/commands/geminicli.ts
+import { join as join4 } from "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 join4(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
+import { basename } from "path";
+import matter from "gray-matter";
+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 = matter(content);
+  try {
+    const validatedData = CommandFrontmatterSchema.parse(parsed.data);
+    const filename = 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 = join5(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
+import { join as join6 } from "path";
 
 // src/generators/ignore/shared-helpers.ts
 function extractIgnorePatternsFromRules(rules) {
@@ -896,7 +1016,7 @@ function generateIgnoreFile(rules, config, ignoreConfig, baseDir) {
   const outputs = [];
   const content = generateIgnoreContent(rules, ignoreConfig);
   const outputPath = baseDir || process.cwd();
-  const filepath = join3(outputPath, ignoreConfig.filename);
+  const filepath = join6(outputPath, ignoreConfig.filename);
   outputs.push({
     tool: ignoreConfig.tool,
     filepath,
@@ -1484,20 +1604,20 @@ function generateWindsurfIgnore(rules, config, baseDir) {
 }
 
 // src/generators/rules/augmentcode.ts
-import { join as join6 } from "path";
+import { join as join9 } from "path";
 
 // src/generators/rules/shared-helpers.ts
-import { join as join5 } from "path";
+import { join as join8 } from "path";
 
 // src/utils/ignore.ts
-import { join as join4 } from "path";
+import { join as join7 } from "path";
 import micromatch from "micromatch";
 var cachedIgnorePatterns = null;
 async function loadIgnorePatterns(baseDir = process.cwd()) {
   if (cachedIgnorePatterns) {
     return cachedIgnorePatterns;
   }
-  const ignorePath = join4(baseDir, ".rulesyncignore");
+  const ignorePath = join7(baseDir, ".rulesyncignore");
   if (!await fileExists(ignorePath)) {
     cachedIgnorePatterns = { patterns: [] };
     return cachedIgnorePatterns;
@@ -1551,7 +1671,7 @@ function addOutput(outputs, tool, config, baseDir, relativePath, content) {
   const outputDir = resolveOutputDir(config, tool, baseDir);
   outputs.push({
     tool,
-    filepath: join5(outputDir, relativePath),
+    filepath: join8(outputDir, relativePath),
     content
   });
 }
@@ -1560,7 +1680,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) : join5(outputDir, `${rule.filename}${generatorConfig.fileExtension}`);
+    const filepath = generatorConfig.pathResolver ? generatorConfig.pathResolver(rule, outputDir) : join8(outputDir, `${rule.filename}${generatorConfig.fileExtension}`);
     outputs.push({
       tool: generatorConfig.tool,
       filepath,
@@ -1568,7 +1688,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({
@@ -1588,7 +1708,7 @@ async function generateComplexRules(rules, config, generatorConfig, baseDir) {
     for (const rule of detailRules) {
       const content = generatorConfig.generateDetailContent(rule);
       const filepath = resolvePath(
-        join5(generatorConfig.detailSubDir, `${rule.filename}.md`),
+        join8(generatorConfig.detailSubDir, `${rule.filename}.md`),
         baseDir
       );
       outputs.push({
@@ -1609,13 +1729,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,
@@ -1649,7 +1771,7 @@ async function generateAugmentcodeConfig(rules, config, baseDir) {
       "augmentcode",
       config,
       baseDir,
-      join6(".augment", "rules", `${rule.filename}.md`),
+      join9(".augment", "rules", `${rule.filename}.md`),
       generateRuleFile(rule)
     );
   });
@@ -1702,19 +1824,19 @@ function generateLegacyGuidelinesFile(allRules) {
 }
 
 // src/generators/rules/claudecode.ts
-import { join as join7 } from "path";
+import { join as join10 } from "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(join7(".claude", "settings.json"), baseDir2);
+      const settingsPath = resolvePath(join10(".claude", "settings.json"), baseDir2);
       await updateClaudeSettings(settingsPath, ignorePatterns);
       return [];
     }
@@ -1778,7 +1900,7 @@ async function updateClaudeSettings(settingsPath, ignorePatterns) {
 }
 
 // src/generators/rules/generator-registry.ts
-import { join as join8 } from "path";
+import { join as join11 } from "path";
 function determineCursorRuleType(frontmatter) {
   if (frontmatter.cursorRuleType) {
     return frontmatter.cursorRuleType;
@@ -1858,7 +1980,7 @@ var GENERATOR_REGISTRY = {
     },
     pathResolver: (rule, outputDir) => {
       const baseFilename = rule.filename.replace(/\.md$/, "");
-      return join8(outputDir, `${baseFilename}.instructions.md`);
+      return join11(outputDir, `${baseFilename}.instructions.md`);
     }
   },
   cursor: {
@@ -1898,7 +2020,7 @@ var GENERATOR_REGISTRY = {
       return lines.join("\n");
     },
     pathResolver: (rule, outputDir) => {
-      return join8(outputDir, `${rule.filename}.mdc`);
+      return join11(outputDir, `${rule.filename}.mdc`);
     }
   },
   codexcli: {
@@ -1934,10 +2056,10 @@ var GENERATOR_REGISTRY = {
     pathResolver: (rule, outputDir) => {
       const outputFormat = rule.frontmatter.windsurfOutputFormat || "directory";
       if (outputFormat === "single-file") {
-        return join8(outputDir, ".windsurf-rules");
+        return join11(outputDir, ".windsurf-rules");
       } else {
-        const rulesDir = join8(outputDir, ".windsurf", "rules");
-        return join8(rulesDir, `${rule.filename}.md`);
+        const rulesDir = join11(outputDir, ".windsurf", "rules");
+        return join11(rulesDir, `${rule.filename}.md`);
       }
     }
   },
@@ -2201,7 +2323,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) {
@@ -2256,8 +2378,8 @@ async function generateForTool(tool, rules, config, baseDir) {
 }
 
 // src/core/parser.ts
-import { basename } from "path";
-import matter from "gray-matter";
+import { basename as basename2 } from "path";
+import matter2 from "gray-matter";
 async function parseRulesFromDirectory(aiRulesDir) {
   const ignorePatterns = await loadIgnorePatterns();
   const allRuleFiles = await findFiles(aiRulesDir, ".md");
@@ -2291,7 +2413,7 @@ ${errors.join("\n")}`);
 }
 async function parseRuleFile(filepath) {
   const content = await readFileContent(filepath);
-  const parsed = matter(content);
+  const parsed = matter2(content);
   try {
     const validatedData = RuleFrontmatterSchema.parse(parsed.data);
     const frontmatter = {
@@ -2310,7 +2432,7 @@ async function parseRuleFile(filepath) {
       },
       ...validatedData.tags !== void 0 && { tags: validatedData.tags }
     };
-    const filename = basename(filepath, ".md");
+    const filename = basename2(filepath, ".md");
     return {
       frontmatter,
       content: parsed.content,
@@ -2405,125 +2527,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 import("./augmentcode-HIZIQG2W.js")).generateAugmentcodeMcpConfiguration(
+      servers,
+      dir
+    ),
+    "augmentcode-legacy": async (servers, dir) => (await import("./augmentcode-HIZIQG2W.js")).generateAugmentcodeMcpConfiguration(
+      servers,
+      dir
+    ),
+    claudecode: async (servers, dir) => (await import("./claudecode-CRSXMPS5.js")).generateClaudeMcpConfiguration(
+      servers,
+      dir
+    ),
+    copilot: async (servers, dir) => (await import("./copilot-MOR3HHJX.js")).generateCopilotMcpConfiguration(servers, dir),
+    cursor: async (servers, dir) => (await import("./cursor-EXX2Q5MB.js")).generateCursorMcpConfiguration(servers, dir),
+    cline: async (servers, dir) => (await import("./cline-O67TEUFW.js")).generateClineMcpConfiguration(servers, dir),
+    codexcli: async (servers, dir) => (await import("./codexcli-S7VDKBI2.js")).generateCodexMcpConfiguration(servers, dir),
+    roo: async (servers, dir) => (await import("./roo-L3QTTIPO.js")).generateRooMcpConfiguration(servers, dir),
+    geminicli: async (servers, dir) => (await import("./geminicli-K3FKXDKP.js")).generateGeminiCliMcpConfiguration(
+      servers,
+      dir
+    ),
+    kiro: async (servers, dir) => (await import("./kiro-YDHXY2MA.js")).generateKiroMcpConfiguration(servers, dir),
+    junie: async (servers, dir) => (await import("./junie-4SNWC452.js")).generateJunieMcpConfiguration(servers, dir),
+    windsurf: async (servers, dir) => (await import("./windsurf-NVCRKFHF.js")).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
@@ -2600,12 +2648,12 @@ async function generateCommand(options = {}) {
       for (const tool of targetTools) {
         switch (tool) {
           case "augmentcode":
-            deleteTasks.push(removeDirectory(join11(".augment", "rules")));
-            deleteTasks.push(removeDirectory(join11(".augment", "ignore")));
+            deleteTasks.push(removeDirectory(join14(".augment", "rules")));
+            deleteTasks.push(removeDirectory(join14(".augment", "ignore")));
             break;
           case "augmentcode-legacy":
             deleteTasks.push(removeClaudeGeneratedFiles());
-            deleteTasks.push(removeDirectory(join11(".augment", "ignore")));
+            deleteTasks.push(removeDirectory(join14(".augment", "ignore")));
             break;
           case "copilot":
             deleteTasks.push(removeDirectory(config.outputPaths.copilot));
@@ -2618,12 +2666,14 @@ async function generateCommand(options = {}) {
             break;
           case "claudecode":
             deleteTasks.push(removeClaudeGeneratedFiles());
+            deleteTasks.push(removeDirectory(join14(".claude", "commands")));
             break;
           case "roo":
             deleteTasks.push(removeDirectory(config.outputPaths.roo));
             break;
           case "geminicli":
             deleteTasks.push(removeDirectory(config.outputPaths.geminicli));
+            deleteTasks.push(removeDirectory(join14(".gemini", "commands")));
             break;
           case "kiro":
             deleteTasks.push(removeDirectory(config.outputPaths.kiro));
@@ -2666,33 +2716,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) {
@@ -2703,9 +2789,9 @@ Generating configurations for base directory: ${baseDir}`);
 
 // src/cli/commands/gitignore.ts
 import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
-import { join as join12 } from "path";
+import { join as join15 } from "path";
 var gitignoreCommand = async () => {
-  const gitignorePath = join12(process.cwd(), ".gitignore");
+  const gitignorePath = join15(process.cwd(), ".gitignore");
   const rulesFilesToIgnore = [
     "# Generated by rulesync - AI tool configuration files",
     "**/.github/copilot-instructions.md",
@@ -2716,6 +2802,7 @@ var gitignoreCommand = async () => {
     "**/.clineignore",
     "**/CLAUDE.md",
     "**/.claude/memories/",
+    "**/.claude/commands/",
     "**/codex.md",
     "**/.codexignore",
     "**/.roo/rules/",
@@ -2723,6 +2810,7 @@ var gitignoreCommand = async () => {
     "**/.copilotignore",
     "**/GEMINI.md",
     "**/.gemini/memories/",
+    "**/.gemini/commands/",
     "**/.aiexclude",
     "**/.aiignore",
     "**/.augmentignore",
@@ -2769,12 +2857,12 @@ ${linesToAdd.join("\n")}
 };
 
 // src/core/importer.ts
-import { join as join19 } from "path";
-import matter6 from "gray-matter";
+import { join as join22 } from "path";
+import matter7 from "gray-matter";
 
 // src/parsers/augmentcode.ts
-import { basename as basename2, join as join13 } from "path";
-import matter2 from "gray-matter";
+import { basename as basename3, join as join16 } from "path";
+import matter3 from "gray-matter";
 
 // src/utils/parser-helpers.ts
 function createParseResult() {
@@ -2822,7 +2910,7 @@ async function parseAugmentcodeLegacyConfiguration(baseDir = process.cwd()) {
 async function parseUnifiedAugmentcode(baseDir, config) {
   const result = createParseResult();
   if (config.rulesDir) {
-    const rulesDir = join13(baseDir, config.rulesDir);
+    const rulesDir = join16(baseDir, config.rulesDir);
     if (await fileExists(rulesDir)) {
       const rulesResult = await parseAugmentRules(rulesDir, config);
       addRules(result, rulesResult.rules);
@@ -2835,7 +2923,7 @@ async function parseUnifiedAugmentcode(baseDir, config) {
     }
   }
   if (config.legacyFilePath) {
-    const legacyPath = join13(baseDir, config.legacyFilePath);
+    const legacyPath = join16(baseDir, config.legacyFilePath);
     if (await fileExists(legacyPath)) {
       const legacyResult = await parseAugmentGuidelines(legacyPath, config);
       if (legacyResult.rule) {
@@ -2859,16 +2947,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 = join13(rulesDir, file);
+        const filePath = join16(rulesDir, file);
         try {
           const rawContent = await readFileContent(filePath);
-          const parsed = matter2(rawContent);
+          const parsed = matter3(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 = basename2(file, file.endsWith(".mdc") ? ".mdc" : ".md");
+          const filename = basename3(file, file.endsWith(".mdc") ? ".mdc" : ".md");
           const frontmatter = {
             root: isRoot,
             targets: [config.targetName],
@@ -2926,8 +3014,8 @@ async function parseAugmentGuidelines(guidelinesPath, config) {
 }
 
 // src/parsers/shared-helpers.ts
-import { basename as basename3, join as join14 } from "path";
-import matter3 from "gray-matter";
+import { basename as basename4, join as join17 } from "path";
+import matter4 from "gray-matter";
 async function parseConfigurationFiles(baseDir = process.cwd(), config) {
   const errors = [];
   const rules = [];
@@ -2940,7 +3028,7 @@ async function parseConfigurationFiles(baseDir = process.cwd(), config) {
         let content;
         let frontmatter;
         if (mainFile.useFrontmatter) {
-          const parsed = matter3(rawContent);
+          const parsed = matter4(rawContent);
           content = parsed.content.trim();
           const parsedFrontmatter = parsed.data;
           frontmatter = {
@@ -2982,14 +3070,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 = join14(dirPath, file);
+              const filePath = join17(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 = matter3(rawContent);
+                  const parsed = matter4(rawContent);
                   content = parsed.content.trim();
                   const parsedFrontmatter = parsed.data;
                   frontmatter = {
@@ -3055,6 +3143,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);
@@ -3120,10 +3215,10 @@ async function parseMemoryFiles(memoryDir, config) {
     const files = await readdir2(memoryDir);
     for (const file of files) {
       if (file.endsWith(".md")) {
-        const filePath = join14(memoryDir, file);
+        const filePath = join17(memoryDir, file);
         const content = await readFileContent(filePath);
         if (content.trim()) {
-          const filename = basename3(file, ".md");
+          const filename = basename4(file, ".md");
           const frontmatter = {
             root: false,
             targets: [config.tool],
@@ -3143,6 +3238,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 = join17(commandsDir, file);
+        const content = await readFileContent(filePath);
+        if (content.trim()) {
+          const filename = basename4(file, ".md");
+          let frontmatter;
+          let ruleContent;
+          try {
+            const parsed = matter4(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;
@@ -3190,7 +3333,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"
   });
 }
 
@@ -3215,7 +3359,7 @@ async function parseClineConfiguration(baseDir = process.cwd()) {
 }
 
 // src/parsers/codexcli.ts
-import { join as join15 } from "path";
+import { join as join18 } from "path";
 
 // src/parsers/copilot.ts
 async function parseCopilotConfiguration(baseDir = process.cwd()) {
@@ -3238,10 +3382,10 @@ async function parseCopilotConfiguration(baseDir = process.cwd()) {
 }
 
 // src/parsers/cursor.ts
-import { basename as basename4, join as join16 } from "path";
-import matter4 from "gray-matter";
+import { basename as basename5, join as join19 } from "path";
+import matter5 from "gray-matter";
 import { DEFAULT_SCHEMA, FAILSAFE_SCHEMA, load } from "js-yaml";
-import { z as z6 } from "zod/mini";
+import { z as z7 } from "zod/mini";
 var customMatterOptions = {
   engines: {
     yaml: {
@@ -3269,7 +3413,7 @@ var customMatterOptions = {
   }
 };
 function convertCursorMdcFrontmatter(cursorFrontmatter, _filename) {
-  const FrontmatterSchema = z6.record(z6.string(), z6.unknown());
+  const FrontmatterSchema = z7.record(z7.string(), z7.unknown());
   const parseResult = FrontmatterSchema.safeParse(cursorFrontmatter);
   if (!parseResult.success) {
     return {
@@ -3363,11 +3507,11 @@ async function parseCursorConfiguration(baseDir = process.cwd()) {
   const rules = [];
   let ignorePatterns;
   let mcpServers;
-  const cursorFilePath = join16(baseDir, ".cursorrules");
+  const cursorFilePath = join19(baseDir, ".cursorrules");
   if (await fileExists(cursorFilePath)) {
     try {
       const rawContent = await readFileContent(cursorFilePath);
-      const parsed = matter4(rawContent, customMatterOptions);
+      const parsed = matter5(rawContent, customMatterOptions);
       const content = parsed.content.trim();
       if (content) {
         const frontmatter = convertCursorMdcFrontmatter(parsed.data, "cursorrules");
@@ -3384,20 +3528,20 @@ async function parseCursorConfiguration(baseDir = process.cwd()) {
       errors.push(`Failed to parse .cursorrules file: ${errorMessage}`);
     }
   }
-  const cursorRulesDir = join16(baseDir, ".cursor", "rules");
+  const cursorRulesDir = join19(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 = join16(cursorRulesDir, file);
+          const filePath = join19(cursorRulesDir, file);
           try {
             const rawContent = await readFileContent(filePath);
-            const parsed = matter4(rawContent, customMatterOptions);
+            const parsed = matter5(rawContent, customMatterOptions);
             const content = parsed.content.trim();
             if (content) {
-              const filename = basename4(file, ".mdc");
+              const filename = basename5(file, ".mdc");
               const frontmatter = convertCursorMdcFrontmatter(parsed.data, filename);
               rules.push({
                 frontmatter,
@@ -3420,7 +3564,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 = join16(baseDir, ".cursorignore");
+  const cursorIgnorePath = join19(baseDir, ".cursorignore");
   if (await fileExists(cursorIgnorePath)) {
     try {
       const content = await readFileContent(cursorIgnorePath);
@@ -3433,7 +3577,7 @@ async function parseCursorConfiguration(baseDir = process.cwd()) {
       errors.push(`Failed to parse .cursorignore: ${errorMessage}`);
     }
   }
-  const cursorMcpPath = join16(baseDir, ".cursor", "mcp.json");
+  const cursorMcpPath = join19(baseDir, ".cursor", "mcp.json");
   if (await fileExists(cursorMcpPath)) {
     try {
       const content = await readFileContent(cursorMcpPath);
@@ -3477,16 +3621,17 @@ async function parseGeminiConfiguration(baseDir = process.cwd()) {
     additionalIgnoreFile: {
       path: ".aiexclude",
       parser: parseAiexclude
-    }
+    },
+    commandsDirPath: ".gemini/commands"
   });
 }
 
 // src/parsers/junie.ts
-import { join as join17 } from "path";
+import { join as join20 } from "path";
 async function parseJunieConfiguration(baseDir = process.cwd()) {
   const errors = [];
   const rules = [];
-  const guidelinesPath = join17(baseDir, ".junie", "guidelines.md");
+  const guidelinesPath = join20(baseDir, ".junie", "guidelines.md");
   if (!await fileExists(guidelinesPath)) {
     errors.push(".junie/guidelines.md file not found");
     return { rules, errors };
@@ -3539,8 +3684,8 @@ async function parseRooConfiguration(baseDir = process.cwd()) {
 
 // src/parsers/windsurf.ts
 import { readFile as readFile2 } from "fs/promises";
-import { join as join18 } from "path";
-import matter5 from "gray-matter";
+import { join as join21 } from "path";
+import matter6 from "gray-matter";
 
 // src/core/importer.ts
 async function importConfiguration(options) {
@@ -3626,7 +3771,7 @@ async function importConfiguration(options) {
   if (rules.length === 0 && !ignorePatterns && !mcpServers) {
     return { success: false, rulesCreated: 0, errors };
   }
-  const rulesDirPath = join19(baseDir, rulesDir);
+  const rulesDirPath = join22(baseDir, rulesDir);
   try {
     const { mkdir: mkdir3 } = await import("fs/promises");
     await mkdir3(rulesDirPath, { recursive: true });
@@ -3639,8 +3784,13 @@ async function importConfiguration(options) {
   for (const rule of rules) {
     try {
       const baseFilename = rule.filename;
-      const filename = await generateUniqueFilename(rulesDirPath, baseFilename);
-      const filePath = join19(rulesDirPath, `${filename}.md`);
+      let targetDir = rulesDirPath;
+      if (rule.type === "command") {
+        targetDir = join22(rulesDirPath, "commands");
+        const { mkdir: mkdir3 } = await import("fs/promises");
+        await mkdir3(targetDir, { recursive: true });
+      }
+      const filePath = join22(targetDir, `${baseFilename}.md`);
       const content = generateRuleFileContent(rule);
       await writeFileContent(filePath, content);
       rulesCreated++;
@@ -3655,7 +3805,7 @@ async function importConfiguration(options) {
   let ignoreFileCreated = false;
   if (ignorePatterns && ignorePatterns.length > 0) {
     try {
-      const rulesyncignorePath = join19(baseDir, ".rulesyncignore");
+      const rulesyncignorePath = join22(baseDir, ".rulesyncignore");
       const ignoreContent = `${ignorePatterns.join("\n")}
 `;
       await writeFileContent(rulesyncignorePath, ignoreContent);
@@ -3671,7 +3821,7 @@ async function importConfiguration(options) {
   let mcpFileCreated = false;
   if (mcpServers && Object.keys(mcpServers).length > 0) {
     try {
-      const mcpPath = join19(baseDir, rulesDir, ".mcp.json");
+      const mcpPath = join22(baseDir, rulesDir, ".mcp.json");
       const mcpContent = `${JSON.stringify({ mcpServers }, null, 2)}
 `;
       await writeFileContent(mcpPath, mcpContent);
@@ -3693,17 +3843,16 @@ async function importConfiguration(options) {
   };
 }
 function generateRuleFileContent(rule) {
-  const frontmatter = matter6.stringify("", rule.frontmatter);
-  return frontmatter + rule.content;
-}
-async function generateUniqueFilename(rulesDir, baseFilename) {
-  let filename = baseFilename;
-  let counter = 1;
-  while (await fileExists(join19(rulesDir, `${filename}.md`))) {
-    filename = `${baseFilename}-${counter}`;
-    counter++;
+  if (rule.type === "command") {
+    const simplifiedFrontmatter = {
+      description: rule.frontmatter.description,
+      targets: rule.frontmatter.targets
+    };
+    const frontmatter2 = matter7.stringify("", simplifiedFrontmatter);
+    return frontmatter2 + rule.content;
   }
-  return filename;
+  const frontmatter = matter7.stringify("", rule.frontmatter);
+  return frontmatter + rule.content;
 }
 
 // src/cli/commands/import.ts
@@ -3766,7 +3915,7 @@ async function importCommand(options = {}) {
 }
 
 // src/cli/commands/init.ts
-import { join as join20 } from "path";
+import { join as join23 } from "path";
 async function initCommand() {
   const aiRulesDir = ".rulesync";
   console.log("Initializing rulesync...");
@@ -3813,7 +3962,7 @@ globs: ["**/*"]
 - Follow single responsibility principle
 `
   };
-  const filepath = join20(aiRulesDir, sampleFile.filename);
+  const filepath = join23(aiRulesDir, sampleFile.filename);
   if (!await fileExists(filepath)) {
     await writeFileContent(filepath, sampleFile.content);
     console.log(`Created ${filepath}`);
@@ -3957,7 +4106,7 @@ async function watchCommand() {
 
 // src/cli/index.ts
 var program = new 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);