rulesync 3.4.3 → 3.5.0

package/README.md

@@ -62,7 +62,7 @@ Rulesync supports both **generation** and **import** for All of the major AI cod
 | Claude Code            |  ✅ 🌏   |  ✅   |  ✅ 🌏   |    ✅ 🌏     |    ✅ 🌏     |
 | Codex CLI              |  ✅ 🌏   |      |   🌏   |     🌏    |    🎮      |
 | Gemini CLI             |  ✅ 🌏  |   ✅   |      |     ✅ 🌏  |      🎮     |
-| GitHub Copilot         |  ✅    |       |  ✅    |    🎮      |    🎮      |
+| GitHub Copilot         |  ✅    |       |  ✅    |     ✅     |    🎮      |
 | Cursor                 |  ✅   |   ✅  |   ✅   |     ✅ 🌏  |     🎮     |
 | OpenCode               |  ✅   |       |       |         |          |
 | Cline                  |  ✅    |   ✅    |  ✅    |          |          |

package/dist/index.cjs

@@ -96,7 +96,7 @@ var import_es_toolkit2 = require("es-toolkit");
 
 // src/commands/commands-processor.ts
 var import_node_path12 = require("path");
-var import_mini8 = require("zod/mini");
+var import_mini9 = require("zod/mini");
 
 // src/utils/file.ts
 var import_node_fs = require("fs");
@@ -891,40 +891,111 @@ var CodexcliCommand = class _CodexcliCommand extends ToolCommand {
 
 // src/commands/copilot-command.ts
 var import_node_path8 = require("path");
-var CopilotCommand = class _CopilotCommand extends SimulatedCommand {
+var import_mini6 = require("zod/mini");
+var CopilotCommandFrontmatterSchema = import_mini6.z.object({
+  mode: import_mini6.z.literal("agent"),
+  description: import_mini6.z.string()
+});
+var CopilotCommand = class _CopilotCommand extends ToolCommand {
+  frontmatter;
+  body;
+  constructor({ frontmatter, body, ...rest }) {
+    if (rest.validate) {
+      const result = CopilotCommandFrontmatterSchema.safeParse(frontmatter);
+      if (!result.success) {
+        throw new Error(
+          `Invalid frontmatter in ${(0, import_node_path8.join)(rest.relativeDirPath, rest.relativeFilePath)}: ${result.error.message}`
+        );
+      }
+    }
+    super({
+      ...rest,
+      fileContent: stringifyFrontmatter(body, frontmatter)
+    });
+    this.frontmatter = frontmatter;
+    this.body = body;
+  }
   static getSettablePaths() {
     return {
-      relativeDirPath: ".github/commands"
+      relativeDirPath: (0, import_node_path8.join)(".github", "prompts")
+    };
+  }
+  getBody() {
+    return this.body;
+  }
+  getFrontmatter() {
+    return this.frontmatter;
+  }
+  toRulesyncCommand() {
+    const rulesyncFrontmatter = {
+      targets: ["*"],
+      description: this.frontmatter.description
     };
+    return new RulesyncCommand({
+      baseDir: ".",
+      frontmatter: rulesyncFrontmatter,
+      body: this.body,
+      relativeDirPath: RulesyncCommand.getSettablePaths().relativeDirPath,
+      relativeFilePath: this.relativeFilePath,
+      fileContent: this.getFileContent(),
+      validate: true
+    });
+  }
+  validate() {
+    if (!this.frontmatter) {
+      return { success: true, error: null };
+    }
+    const result = CopilotCommandFrontmatterSchema.safeParse(this.frontmatter);
+    if (result.success) {
+      return { success: true, error: null };
+    } else {
+      return {
+        success: false,
+        error: new Error(
+          `Invalid frontmatter in ${(0, import_node_path8.join)(this.relativeDirPath, this.relativeFilePath)}: ${result.error.message}`
+        )
+      };
+    }
   }
   static fromRulesyncCommand({
     baseDir = ".",
     rulesyncCommand,
     validate = true
   }) {
-    return new _CopilotCommand(
-      this.fromRulesyncCommandDefault({ baseDir, rulesyncCommand, validate })
-    );
+    const paths = this.getSettablePaths();
+    const rulesyncFrontmatter = rulesyncCommand.getFrontmatter();
+    const copilotFrontmatter = {
+      mode: "agent",
+      description: rulesyncFrontmatter.description
+    };
+    const body = rulesyncCommand.getBody();
+    const originalFilePath = rulesyncCommand.getRelativeFilePath();
+    const relativeFilePath = originalFilePath.replace(/\.md$/, ".prompt.md");
+    return new _CopilotCommand({
+      baseDir,
+      frontmatter: copilotFrontmatter,
+      body,
+      relativeDirPath: paths.relativeDirPath,
+      relativeFilePath,
+      validate
+    });
   }
   static async fromFile({
     baseDir = ".",
     relativeFilePath,
     validate = true
   }) {
-    const filePath = (0, import_node_path8.join)(
-      baseDir,
-      _CopilotCommand.getSettablePaths().relativeDirPath,
-      relativeFilePath
-    );
+    const paths = this.getSettablePaths();
+    const filePath = (0, import_node_path8.join)(baseDir, paths.relativeDirPath, relativeFilePath);
     const fileContent = await readFileContent(filePath);
     const { frontmatter, body: content } = parseFrontmatter(fileContent);
-    const result = SimulatedCommandFrontmatterSchema.safeParse(frontmatter);
+    const result = CopilotCommandFrontmatterSchema.safeParse(frontmatter);
     if (!result.success) {
       throw new Error(`Invalid frontmatter in ${filePath}: ${result.error.message}`);
     }
     return new _CopilotCommand({
       baseDir,
-      relativeDirPath: _CopilotCommand.getSettablePaths().relativeDirPath,
+      relativeDirPath: paths.relativeDirPath,
       relativeFilePath: (0, import_node_path8.basename)(relativeFilePath),
       frontmatter: result.data,
       body: content.trim(),
@@ -1018,10 +1089,10 @@ var CursorCommand = class _CursorCommand extends ToolCommand {
 // src/commands/geminicli-command.ts
 var import_node_path10 = require("path");
 var import_smol_toml = require("smol-toml");
-var import_mini6 = require("zod/mini");
-var GeminiCliCommandFrontmatterSchema = import_mini6.z.object({
-  description: import_mini6.z.optional(import_mini6.z.string()),
-  prompt: import_mini6.z.string()
+var import_mini7 = require("zod/mini");
+var GeminiCliCommandFrontmatterSchema = import_mini7.z.object({
+  description: import_mini7.z.optional(import_mini7.z.string()),
+  prompt: import_mini7.z.string()
 });
 var GeminiCliCommand = class _GeminiCliCommand extends ToolCommand {
   frontmatter;
@@ -1142,10 +1213,10 @@ ${geminiFrontmatter.prompt}
 
 // src/commands/roo-command.ts
 var import_node_path11 = require("path");
-var import_mini7 = require("zod/mini");
-var RooCommandFrontmatterSchema = import_mini7.z.object({
-  description: import_mini7.z.string(),
-  "argument-hint": (0, import_mini7.optional)(import_mini7.z.string())
+var import_mini8 = require("zod/mini");
+var RooCommandFrontmatterSchema = import_mini8.z.object({
+  description: import_mini8.z.string(),
+  "argument-hint": (0, import_mini8.optional)(import_mini8.z.string())
 });
 var RooCommand = class _RooCommand extends ToolCommand {
   frontmatter;
@@ -1270,11 +1341,11 @@ var commandsProcessorToolTargets = [
   "copilot",
   "cursor"
 ];
-var CommandsProcessorToolTargetSchema = import_mini8.z.enum(
+var CommandsProcessorToolTargetSchema = import_mini9.z.enum(
   // codexcli is not in the list of tool targets but we add it here because it is a valid tool target for global mode generation
   commandsProcessorToolTargets.concat("codexcli")
 );
-var commandsProcessorToolTargetsSimulated = ["agentsmd", "copilot"];
+var commandsProcessorToolTargetsSimulated = ["agentsmd"];
 var commandsProcessorToolTargetsGlobal = [
   "claudecode",
   "cursor",
@@ -1494,13 +1565,13 @@ var CommandsProcessor = class extends FeatureProcessor {
     });
   }
   /**
-   * Load Copilot command configurations from .github/commands/ directory
+   * Load Copilot command configurations from .github/prompts/ directory
    */
   async loadCopilotCommands() {
     return await this.loadToolCommandDefault({
       toolTarget: "copilot",
       relativeDirPath: CopilotCommand.getSettablePaths().relativeDirPath,
-      extension: "md"
+      extension: "prompt.md"
     });
   }
   /**
@@ -1728,7 +1799,7 @@ function getBaseDirsInLightOfGlobal({
 }
 
 // src/ignore/ignore-processor.ts
-var import_mini9 = require("zod/mini");
+var import_mini10 = require("zod/mini");
 
 // src/ignore/amazonqcli-ignore.ts
 var import_node_path14 = require("path");
@@ -2373,7 +2444,7 @@ var ignoreProcessorToolTargets = [
   "roo",
   "windsurf"
 ];
-var IgnoreProcessorToolTargetSchema = import_mini9.z.enum(ignoreProcessorToolTargets);
+var IgnoreProcessorToolTargetSchema = import_mini10.z.enum(ignoreProcessorToolTargets);
 var IgnoreProcessor = class extends FeatureProcessor {
   toolTarget;
   constructor({
@@ -2548,39 +2619,39 @@ var IgnoreProcessor = class extends FeatureProcessor {
 };
 
 // src/mcp/mcp-processor.ts
-var import_mini11 = require("zod/mini");
+var import_mini12 = require("zod/mini");
 
 // src/mcp/amazonqcli-mcp.ts
 var import_node_path26 = require("path");
 
 // src/mcp/rulesync-mcp.ts
 var import_node_path25 = require("path");
-var import_mini10 = require("zod/mini");
-var McpTransportTypeSchema = import_mini10.z.enum(["stdio", "sse", "http"]);
-var McpServerBaseSchema = import_mini10.z.object({
-  type: import_mini10.z.optional(import_mini10.z.enum(["stdio", "sse", "http"])),
-  command: import_mini10.z.optional(import_mini10.z.union([import_mini10.z.string(), import_mini10.z.array(import_mini10.z.string())])),
-  args: import_mini10.z.optional(import_mini10.z.array(import_mini10.z.string())),
-  url: import_mini10.z.optional(import_mini10.z.string()),
-  httpUrl: import_mini10.z.optional(import_mini10.z.string()),
-  env: import_mini10.z.optional(import_mini10.z.record(import_mini10.z.string(), import_mini10.z.string())),
-  disabled: import_mini10.z.optional(import_mini10.z.boolean()),
-  networkTimeout: import_mini10.z.optional(import_mini10.z.number()),
-  timeout: import_mini10.z.optional(import_mini10.z.number()),
-  trust: import_mini10.z.optional(import_mini10.z.boolean()),
-  cwd: import_mini10.z.optional(import_mini10.z.string()),
-  transport: import_mini10.z.optional(McpTransportTypeSchema),
-  alwaysAllow: import_mini10.z.optional(import_mini10.z.array(import_mini10.z.string())),
-  tools: import_mini10.z.optional(import_mini10.z.array(import_mini10.z.string())),
-  kiroAutoApprove: import_mini10.z.optional(import_mini10.z.array(import_mini10.z.string())),
-  kiroAutoBlock: import_mini10.z.optional(import_mini10.z.array(import_mini10.z.string())),
-  headers: import_mini10.z.optional(import_mini10.z.record(import_mini10.z.string(), import_mini10.z.string()))
+var import_mini11 = require("zod/mini");
+var McpTransportTypeSchema = import_mini11.z.enum(["stdio", "sse", "http"]);
+var McpServerBaseSchema = import_mini11.z.object({
+  type: import_mini11.z.optional(import_mini11.z.enum(["stdio", "sse", "http"])),
+  command: import_mini11.z.optional(import_mini11.z.union([import_mini11.z.string(), import_mini11.z.array(import_mini11.z.string())])),
+  args: import_mini11.z.optional(import_mini11.z.array(import_mini11.z.string())),
+  url: import_mini11.z.optional(import_mini11.z.string()),
+  httpUrl: import_mini11.z.optional(import_mini11.z.string()),
+  env: import_mini11.z.optional(import_mini11.z.record(import_mini11.z.string(), import_mini11.z.string())),
+  disabled: import_mini11.z.optional(import_mini11.z.boolean()),
+  networkTimeout: import_mini11.z.optional(import_mini11.z.number()),
+  timeout: import_mini11.z.optional(import_mini11.z.number()),
+  trust: import_mini11.z.optional(import_mini11.z.boolean()),
+  cwd: import_mini11.z.optional(import_mini11.z.string()),
+  transport: import_mini11.z.optional(McpTransportTypeSchema),
+  alwaysAllow: import_mini11.z.optional(import_mini11.z.array(import_mini11.z.string())),
+  tools: import_mini11.z.optional(import_mini11.z.array(import_mini11.z.string())),
+  kiroAutoApprove: import_mini11.z.optional(import_mini11.z.array(import_mini11.z.string())),
+  kiroAutoBlock: import_mini11.z.optional(import_mini11.z.array(import_mini11.z.string())),
+  headers: import_mini11.z.optional(import_mini11.z.record(import_mini11.z.string(), import_mini11.z.string()))
 });
-var RulesyncMcpServersSchema = import_mini10.z.extend(McpServerBaseSchema, {
-  targets: import_mini10.z.optional(RulesyncTargetsSchema)
+var RulesyncMcpServersSchema = import_mini11.z.extend(McpServerBaseSchema, {
+  targets: import_mini11.z.optional(RulesyncTargetsSchema)
 });
-var RulesyncMcpConfigSchema = import_mini10.z.object({
-  mcpServers: import_mini10.z.record(import_mini10.z.string(), RulesyncMcpServersSchema)
+var RulesyncMcpConfigSchema = import_mini11.z.object({
+  mcpServers: import_mini11.z.record(import_mini11.z.string(), RulesyncMcpServersSchema)
 });
 var RulesyncMcp = class _RulesyncMcp extends RulesyncFile {
   json;
@@ -3132,7 +3203,7 @@ var mcpProcessorToolTargets = [
   "cursor",
   "roo"
 ];
-var McpProcessorToolTargetSchema = import_mini11.z.enum(
+var McpProcessorToolTargetSchema = import_mini12.z.enum(
   // codexcli is not in the list of tool targets but we add it here because it is a valid tool target for global mode generation
   mcpProcessorToolTargets.concat("codexcli")
 );
@@ -3336,11 +3407,11 @@ var McpProcessor = class extends FeatureProcessor {
 // src/rules/rules-processor.ts
 var import_node_path56 = require("path");
 var import_fast_xml_parser = require("fast-xml-parser");
-var import_mini20 = require("zod/mini");
+var import_mini21 = require("zod/mini");
 
 // src/subagents/simulated-subagent.ts
 var import_node_path33 = require("path");
-var import_mini12 = require("zod/mini");
+var import_mini13 = require("zod/mini");
 
 // src/subagents/tool-subagent.ts
 var ToolSubagent = class extends ToolFile {
@@ -3375,9 +3446,9 @@ var ToolSubagent = class extends ToolFile {
 };
 
 // src/subagents/simulated-subagent.ts
-var SimulatedSubagentFrontmatterSchema = import_mini12.z.object({
-  name: import_mini12.z.string(),
-  description: import_mini12.z.string()
+var SimulatedSubagentFrontmatterSchema = import_mini13.z.object({
+  name: import_mini13.z.string(),
+  description: import_mini13.z.string()
 });
 var SimulatedSubagent = class extends ToolSubagent {
   frontmatter;
@@ -3606,22 +3677,22 @@ var RooSubagent = class _RooSubagent extends SimulatedSubagent {
 
 // src/subagents/subagents-processor.ts
 var import_node_path36 = require("path");
-var import_mini15 = require("zod/mini");
+var import_mini16 = require("zod/mini");
 
 // src/subagents/claudecode-subagent.ts
 var import_node_path35 = require("path");
-var import_mini14 = require("zod/mini");
+var import_mini15 = require("zod/mini");
 
 // src/subagents/rulesync-subagent.ts
 var import_node_path34 = require("path");
-var import_mini13 = require("zod/mini");
-var RulesyncSubagentModelSchema = import_mini13.z.enum(["opus", "sonnet", "haiku", "inherit"]);
-var RulesyncSubagentFrontmatterSchema = import_mini13.z.object({
+var import_mini14 = require("zod/mini");
+var RulesyncSubagentModelSchema = import_mini14.z.enum(["opus", "sonnet", "haiku", "inherit"]);
+var RulesyncSubagentFrontmatterSchema = import_mini14.z.object({
   targets: RulesyncTargetsSchema,
-  name: import_mini13.z.string(),
-  description: import_mini13.z.string(),
-  claudecode: import_mini13.z.optional(
-    import_mini13.z.object({
+  name: import_mini14.z.string(),
+  description: import_mini14.z.string(),
+  claudecode: import_mini14.z.optional(
+    import_mini14.z.object({
       model: RulesyncSubagentModelSchema
     })
   )
@@ -3693,10 +3764,10 @@ var RulesyncSubagent = class _RulesyncSubagent extends RulesyncFile {
 };
 
 // src/subagents/claudecode-subagent.ts
-var ClaudecodeSubagentFrontmatterSchema = import_mini14.z.object({
-  name: import_mini14.z.string(),
-  description: import_mini14.z.string(),
-  model: import_mini14.z.optional(import_mini14.z.enum(["opus", "sonnet", "haiku", "inherit"]))
+var ClaudecodeSubagentFrontmatterSchema = import_mini15.z.object({
+  name: import_mini15.z.string(),
+  description: import_mini15.z.string(),
+  model: import_mini15.z.optional(import_mini15.z.enum(["opus", "sonnet", "haiku", "inherit"]))
 });
 var ClaudecodeSubagent = class _ClaudecodeSubagent extends ToolSubagent {
   frontmatter;
@@ -3847,7 +3918,7 @@ var subagentsProcessorToolTargetsSimulated = [
   "roo"
 ];
 var subagentsProcessorToolTargetsGlobal = ["claudecode"];
-var SubagentsProcessorToolTargetSchema = import_mini15.z.enum(subagentsProcessorToolTargets);
+var SubagentsProcessorToolTargetSchema = import_mini16.z.enum(subagentsProcessorToolTargets);
 var SubagentsProcessor = class extends FeatureProcessor {
   toolTarget;
   global;
@@ -4132,23 +4203,23 @@ var import_node_path38 = require("path");
 
 // src/rules/rulesync-rule.ts
 var import_node_path37 = require("path");
-var import_mini16 = require("zod/mini");
-var RulesyncRuleFrontmatterSchema = import_mini16.z.object({
-  root: import_mini16.z.optional(import_mini16.z.optional(import_mini16.z.boolean())),
-  targets: import_mini16.z.optional(RulesyncTargetsSchema),
-  description: import_mini16.z.optional(import_mini16.z.string()),
-  globs: import_mini16.z.optional(import_mini16.z.array(import_mini16.z.string())),
-  agentsmd: import_mini16.z.optional(
-    import_mini16.z.object({
+var import_mini17 = require("zod/mini");
+var RulesyncRuleFrontmatterSchema = import_mini17.z.object({
+  root: import_mini17.z.optional(import_mini17.z.optional(import_mini17.z.boolean())),
+  targets: import_mini17.z.optional(RulesyncTargetsSchema),
+  description: import_mini17.z.optional(import_mini17.z.string()),
+  globs: import_mini17.z.optional(import_mini17.z.array(import_mini17.z.string())),
+  agentsmd: import_mini17.z.optional(
+    import_mini17.z.object({
       // @example "path/to/subproject"
-      subprojectPath: import_mini16.z.optional(import_mini16.z.string())
+      subprojectPath: import_mini17.z.optional(import_mini17.z.string())
     })
   ),
-  cursor: import_mini16.z.optional(
-    import_mini16.z.object({
-      alwaysApply: import_mini16.z.optional(import_mini16.z.boolean()),
-      description: import_mini16.z.optional(import_mini16.z.string()),
-      globs: import_mini16.z.optional(import_mini16.z.array(import_mini16.z.string()))
+  cursor: import_mini17.z.optional(
+    import_mini17.z.object({
+      alwaysApply: import_mini17.z.optional(import_mini17.z.boolean()),
+      description: import_mini17.z.optional(import_mini17.z.string()),
+      globs: import_mini17.z.optional(import_mini17.z.array(import_mini17.z.string()))
     })
   )
 });
@@ -4729,9 +4800,9 @@ var ClaudecodeRule = class _ClaudecodeRule extends ToolRule {
 
 // src/rules/cline-rule.ts
 var import_node_path44 = require("path");
-var import_mini17 = require("zod/mini");
-var ClineRuleFrontmatterSchema = import_mini17.z.object({
-  description: import_mini17.z.string()
+var import_mini18 = require("zod/mini");
+var ClineRuleFrontmatterSchema = import_mini18.z.object({
+  description: import_mini18.z.string()
 });
 var ClineRule = class _ClineRule extends ToolRule {
   static getSettablePaths() {
@@ -4876,10 +4947,10 @@ var CodexcliRule = class _CodexcliRule extends ToolRule {
 
 // src/rules/copilot-rule.ts
 var import_node_path46 = require("path");
-var import_mini18 = require("zod/mini");
-var CopilotRuleFrontmatterSchema = import_mini18.z.object({
-  description: import_mini18.z.optional(import_mini18.z.string()),
-  applyTo: import_mini18.z.optional(import_mini18.z.string())
+var import_mini19 = require("zod/mini");
+var CopilotRuleFrontmatterSchema = import_mini19.z.object({
+  description: import_mini19.z.optional(import_mini19.z.string()),
+  applyTo: import_mini19.z.optional(import_mini19.z.string())
 });
 var CopilotRule = class _CopilotRule extends ToolRule {
   frontmatter;
@@ -5038,11 +5109,11 @@ var CopilotRule = class _CopilotRule extends ToolRule {
 
 // src/rules/cursor-rule.ts
 var import_node_path47 = require("path");
-var import_mini19 = require("zod/mini");
-var CursorRuleFrontmatterSchema = import_mini19.z.object({
-  description: import_mini19.z.optional(import_mini19.z.string()),
-  globs: import_mini19.z.optional(import_mini19.z.string()),
-  alwaysApply: import_mini19.z.optional(import_mini19.z.boolean())
+var import_mini20 = require("zod/mini");
+var CursorRuleFrontmatterSchema = import_mini20.z.object({
+  description: import_mini20.z.optional(import_mini20.z.string()),
+  globs: import_mini20.z.optional(import_mini20.z.string()),
+  alwaysApply: import_mini20.z.optional(import_mini20.z.boolean())
 });
 var CursorRule = class _CursorRule extends ToolRule {
   frontmatter;
@@ -5746,7 +5817,7 @@ var rulesProcessorToolTargets = [
   "warp",
   "windsurf"
 ];
-var RulesProcessorToolTargetSchema = import_mini20.z.enum(rulesProcessorToolTargets);
+var RulesProcessorToolTargetSchema = import_mini21.z.enum(rulesProcessorToolTargets);
 var rulesProcessorToolTargetsGlobal = [
   "claudecode",
   "codexcli",
@@ -6795,6 +6866,7 @@ var gitignoreCommand = async () => {
     "**/.amazonq/",
     "**/.github/copilot-instructions.md",
     "**/.github/instructions/",
+    "**/.github/prompts/",
     "**/.cursor/",
     "**/.cursorignore",
     "**/.clinerules/",
@@ -7100,7 +7172,7 @@ globs: ["**/*"]
 }
 
 // src/cli/index.ts
-var getVersion = () => "3.4.3";
+var getVersion = () => "3.5.0";
 var main = async () => {
   const program = new import_commander.Command();
   const version = getVersion();

package/dist/index.js

@@ -73,7 +73,7 @@ import { intersection } from "es-toolkit";
 
 // src/commands/commands-processor.ts
 import { basename as basename11, join as join11 } from "path";
-import { z as z8 } from "zod/mini";
+import { z as z9 } from "zod/mini";
 
 // src/utils/file.ts
 import { globSync } from "fs";
@@ -868,40 +868,111 @@ var CodexcliCommand = class _CodexcliCommand extends ToolCommand {
 
 // src/commands/copilot-command.ts
 import { basename as basename7, join as join7 } from "path";
-var CopilotCommand = class _CopilotCommand extends SimulatedCommand {
+import { z as z6 } from "zod/mini";
+var CopilotCommandFrontmatterSchema = z6.object({
+  mode: z6.literal("agent"),
+  description: z6.string()
+});
+var CopilotCommand = class _CopilotCommand extends ToolCommand {
+  frontmatter;
+  body;
+  constructor({ frontmatter, body, ...rest }) {
+    if (rest.validate) {
+      const result = CopilotCommandFrontmatterSchema.safeParse(frontmatter);
+      if (!result.success) {
+        throw new Error(
+          `Invalid frontmatter in ${join7(rest.relativeDirPath, rest.relativeFilePath)}: ${result.error.message}`
+        );
+      }
+    }
+    super({
+      ...rest,
+      fileContent: stringifyFrontmatter(body, frontmatter)
+    });
+    this.frontmatter = frontmatter;
+    this.body = body;
+  }
   static getSettablePaths() {
     return {
-      relativeDirPath: ".github/commands"
+      relativeDirPath: join7(".github", "prompts")
+    };
+  }
+  getBody() {
+    return this.body;
+  }
+  getFrontmatter() {
+    return this.frontmatter;
+  }
+  toRulesyncCommand() {
+    const rulesyncFrontmatter = {
+      targets: ["*"],
+      description: this.frontmatter.description
     };
+    return new RulesyncCommand({
+      baseDir: ".",
+      frontmatter: rulesyncFrontmatter,
+      body: this.body,
+      relativeDirPath: RulesyncCommand.getSettablePaths().relativeDirPath,
+      relativeFilePath: this.relativeFilePath,
+      fileContent: this.getFileContent(),
+      validate: true
+    });
+  }
+  validate() {
+    if (!this.frontmatter) {
+      return { success: true, error: null };
+    }
+    const result = CopilotCommandFrontmatterSchema.safeParse(this.frontmatter);
+    if (result.success) {
+      return { success: true, error: null };
+    } else {
+      return {
+        success: false,
+        error: new Error(
+          `Invalid frontmatter in ${join7(this.relativeDirPath, this.relativeFilePath)}: ${result.error.message}`
+        )
+      };
+    }
   }
   static fromRulesyncCommand({
     baseDir = ".",
     rulesyncCommand,
     validate = true
   }) {
-    return new _CopilotCommand(
-      this.fromRulesyncCommandDefault({ baseDir, rulesyncCommand, validate })
-    );
+    const paths = this.getSettablePaths();
+    const rulesyncFrontmatter = rulesyncCommand.getFrontmatter();
+    const copilotFrontmatter = {
+      mode: "agent",
+      description: rulesyncFrontmatter.description
+    };
+    const body = rulesyncCommand.getBody();
+    const originalFilePath = rulesyncCommand.getRelativeFilePath();
+    const relativeFilePath = originalFilePath.replace(/\.md$/, ".prompt.md");
+    return new _CopilotCommand({
+      baseDir,
+      frontmatter: copilotFrontmatter,
+      body,
+      relativeDirPath: paths.relativeDirPath,
+      relativeFilePath,
+      validate
+    });
   }
   static async fromFile({
     baseDir = ".",
     relativeFilePath,
     validate = true
   }) {
-    const filePath = join7(
-      baseDir,
-      _CopilotCommand.getSettablePaths().relativeDirPath,
-      relativeFilePath
-    );
+    const paths = this.getSettablePaths();
+    const filePath = join7(baseDir, paths.relativeDirPath, relativeFilePath);
     const fileContent = await readFileContent(filePath);
     const { frontmatter, body: content } = parseFrontmatter(fileContent);
-    const result = SimulatedCommandFrontmatterSchema.safeParse(frontmatter);
+    const result = CopilotCommandFrontmatterSchema.safeParse(frontmatter);
     if (!result.success) {
       throw new Error(`Invalid frontmatter in ${filePath}: ${result.error.message}`);
     }
     return new _CopilotCommand({
       baseDir,
-      relativeDirPath: _CopilotCommand.getSettablePaths().relativeDirPath,
+      relativeDirPath: paths.relativeDirPath,
       relativeFilePath: basename7(relativeFilePath),
       frontmatter: result.data,
       body: content.trim(),
@@ -995,10 +1066,10 @@ var CursorCommand = class _CursorCommand extends ToolCommand {
 // src/commands/geminicli-command.ts
 import { basename as basename9, join as join9 } from "path";
 import { parse as parseToml } from "smol-toml";
-import { z as z6 } from "zod/mini";
-var GeminiCliCommandFrontmatterSchema = z6.object({
-  description: z6.optional(z6.string()),
-  prompt: z6.string()
+import { z as z7 } from "zod/mini";
+var GeminiCliCommandFrontmatterSchema = z7.object({
+  description: z7.optional(z7.string()),
+  prompt: z7.string()
 });
 var GeminiCliCommand = class _GeminiCliCommand extends ToolCommand {
   frontmatter;
@@ -1119,10 +1190,10 @@ ${geminiFrontmatter.prompt}
 
 // src/commands/roo-command.ts
 import { basename as basename10, join as join10 } from "path";
-import { optional, z as z7 } from "zod/mini";
-var RooCommandFrontmatterSchema = z7.object({
-  description: z7.string(),
-  "argument-hint": optional(z7.string())
+import { optional, z as z8 } from "zod/mini";
+var RooCommandFrontmatterSchema = z8.object({
+  description: z8.string(),
+  "argument-hint": optional(z8.string())
 });
 var RooCommand = class _RooCommand extends ToolCommand {
   frontmatter;
@@ -1247,11 +1318,11 @@ var commandsProcessorToolTargets = [
   "copilot",
   "cursor"
 ];
-var CommandsProcessorToolTargetSchema = z8.enum(
+var CommandsProcessorToolTargetSchema = z9.enum(
   // codexcli is not in the list of tool targets but we add it here because it is a valid tool target for global mode generation
   commandsProcessorToolTargets.concat("codexcli")
 );
-var commandsProcessorToolTargetsSimulated = ["agentsmd", "copilot"];
+var commandsProcessorToolTargetsSimulated = ["agentsmd"];
 var commandsProcessorToolTargetsGlobal = [
   "claudecode",
   "cursor",
@@ -1471,13 +1542,13 @@ var CommandsProcessor = class extends FeatureProcessor {
     });
   }
   /**
-   * Load Copilot command configurations from .github/commands/ directory
+   * Load Copilot command configurations from .github/prompts/ directory
    */
   async loadCopilotCommands() {
     return await this.loadToolCommandDefault({
       toolTarget: "copilot",
       relativeDirPath: CopilotCommand.getSettablePaths().relativeDirPath,
-      extension: "md"
+      extension: "prompt.md"
     });
   }
   /**
@@ -1705,7 +1776,7 @@ function getBaseDirsInLightOfGlobal({
 }
 
 // src/ignore/ignore-processor.ts
-import { z as z9 } from "zod/mini";
+import { z as z10 } from "zod/mini";
 
 // src/ignore/amazonqcli-ignore.ts
 import { join as join13 } from "path";
@@ -2350,7 +2421,7 @@ var ignoreProcessorToolTargets = [
   "roo",
   "windsurf"
 ];
-var IgnoreProcessorToolTargetSchema = z9.enum(ignoreProcessorToolTargets);
+var IgnoreProcessorToolTargetSchema = z10.enum(ignoreProcessorToolTargets);
 var IgnoreProcessor = class extends FeatureProcessor {
   toolTarget;
   constructor({
@@ -2525,39 +2596,39 @@ var IgnoreProcessor = class extends FeatureProcessor {
 };
 
 // src/mcp/mcp-processor.ts
-import { z as z11 } from "zod/mini";
+import { z as z12 } from "zod/mini";
 
 // src/mcp/amazonqcli-mcp.ts
 import { join as join25 } from "path";
 
 // src/mcp/rulesync-mcp.ts
 import { join as join24 } from "path";
-import { z as z10 } from "zod/mini";
-var McpTransportTypeSchema = z10.enum(["stdio", "sse", "http"]);
-var McpServerBaseSchema = z10.object({
-  type: z10.optional(z10.enum(["stdio", "sse", "http"])),
-  command: z10.optional(z10.union([z10.string(), z10.array(z10.string())])),
-  args: z10.optional(z10.array(z10.string())),
-  url: z10.optional(z10.string()),
-  httpUrl: z10.optional(z10.string()),
-  env: z10.optional(z10.record(z10.string(), z10.string())),
-  disabled: z10.optional(z10.boolean()),
-  networkTimeout: z10.optional(z10.number()),
-  timeout: z10.optional(z10.number()),
-  trust: z10.optional(z10.boolean()),
-  cwd: z10.optional(z10.string()),
-  transport: z10.optional(McpTransportTypeSchema),
-  alwaysAllow: z10.optional(z10.array(z10.string())),
-  tools: z10.optional(z10.array(z10.string())),
-  kiroAutoApprove: z10.optional(z10.array(z10.string())),
-  kiroAutoBlock: z10.optional(z10.array(z10.string())),
-  headers: z10.optional(z10.record(z10.string(), z10.string()))
+import { z as z11 } from "zod/mini";
+var McpTransportTypeSchema = z11.enum(["stdio", "sse", "http"]);
+var McpServerBaseSchema = z11.object({
+  type: z11.optional(z11.enum(["stdio", "sse", "http"])),
+  command: z11.optional(z11.union([z11.string(), z11.array(z11.string())])),
+  args: z11.optional(z11.array(z11.string())),
+  url: z11.optional(z11.string()),
+  httpUrl: z11.optional(z11.string()),
+  env: z11.optional(z11.record(z11.string(), z11.string())),
+  disabled: z11.optional(z11.boolean()),
+  networkTimeout: z11.optional(z11.number()),
+  timeout: z11.optional(z11.number()),
+  trust: z11.optional(z11.boolean()),
+  cwd: z11.optional(z11.string()),
+  transport: z11.optional(McpTransportTypeSchema),
+  alwaysAllow: z11.optional(z11.array(z11.string())),
+  tools: z11.optional(z11.array(z11.string())),
+  kiroAutoApprove: z11.optional(z11.array(z11.string())),
+  kiroAutoBlock: z11.optional(z11.array(z11.string())),
+  headers: z11.optional(z11.record(z11.string(), z11.string()))
 });
-var RulesyncMcpServersSchema = z10.extend(McpServerBaseSchema, {
-  targets: z10.optional(RulesyncTargetsSchema)
+var RulesyncMcpServersSchema = z11.extend(McpServerBaseSchema, {
+  targets: z11.optional(RulesyncTargetsSchema)
 });
-var RulesyncMcpConfigSchema = z10.object({
-  mcpServers: z10.record(z10.string(), RulesyncMcpServersSchema)
+var RulesyncMcpConfigSchema = z11.object({
+  mcpServers: z11.record(z11.string(), RulesyncMcpServersSchema)
 });
 var RulesyncMcp = class _RulesyncMcp extends RulesyncFile {
   json;
@@ -3109,7 +3180,7 @@ var mcpProcessorToolTargets = [
   "cursor",
   "roo"
 ];
-var McpProcessorToolTargetSchema = z11.enum(
+var McpProcessorToolTargetSchema = z12.enum(
   // codexcli is not in the list of tool targets but we add it here because it is a valid tool target for global mode generation
   mcpProcessorToolTargets.concat("codexcli")
 );
@@ -3313,11 +3384,11 @@ var McpProcessor = class extends FeatureProcessor {
 // src/rules/rules-processor.ts
 import { basename as basename17, join as join55 } from "path";
 import { XMLBuilder } from "fast-xml-parser";
-import { z as z20 } from "zod/mini";
+import { z as z21 } from "zod/mini";
 
 // src/subagents/simulated-subagent.ts
 import { basename as basename12, join as join32 } from "path";
-import { z as z12 } from "zod/mini";
+import { z as z13 } from "zod/mini";
 
 // src/subagents/tool-subagent.ts
 var ToolSubagent = class extends ToolFile {
@@ -3352,9 +3423,9 @@ var ToolSubagent = class extends ToolFile {
 };
 
 // src/subagents/simulated-subagent.ts
-var SimulatedSubagentFrontmatterSchema = z12.object({
-  name: z12.string(),
-  description: z12.string()
+var SimulatedSubagentFrontmatterSchema = z13.object({
+  name: z13.string(),
+  description: z13.string()
 });
 var SimulatedSubagent = class extends ToolSubagent {
   frontmatter;
@@ -3583,22 +3654,22 @@ var RooSubagent = class _RooSubagent extends SimulatedSubagent {
 
 // src/subagents/subagents-processor.ts
 import { basename as basename14, join as join35 } from "path";
-import { z as z15 } from "zod/mini";
+import { z as z16 } from "zod/mini";
 
 // src/subagents/claudecode-subagent.ts
 import { join as join34 } from "path";
-import { z as z14 } from "zod/mini";
+import { z as z15 } from "zod/mini";
 
 // src/subagents/rulesync-subagent.ts
 import { basename as basename13, join as join33 } from "path";
-import { z as z13 } from "zod/mini";
-var RulesyncSubagentModelSchema = z13.enum(["opus", "sonnet", "haiku", "inherit"]);
-var RulesyncSubagentFrontmatterSchema = z13.object({
+import { z as z14 } from "zod/mini";
+var RulesyncSubagentModelSchema = z14.enum(["opus", "sonnet", "haiku", "inherit"]);
+var RulesyncSubagentFrontmatterSchema = z14.object({
   targets: RulesyncTargetsSchema,
-  name: z13.string(),
-  description: z13.string(),
-  claudecode: z13.optional(
-    z13.object({
+  name: z14.string(),
+  description: z14.string(),
+  claudecode: z14.optional(
+    z14.object({
       model: RulesyncSubagentModelSchema
     })
   )
@@ -3670,10 +3741,10 @@ var RulesyncSubagent = class _RulesyncSubagent extends RulesyncFile {
 };
 
 // src/subagents/claudecode-subagent.ts
-var ClaudecodeSubagentFrontmatterSchema = z14.object({
-  name: z14.string(),
-  description: z14.string(),
-  model: z14.optional(z14.enum(["opus", "sonnet", "haiku", "inherit"]))
+var ClaudecodeSubagentFrontmatterSchema = z15.object({
+  name: z15.string(),
+  description: z15.string(),
+  model: z15.optional(z15.enum(["opus", "sonnet", "haiku", "inherit"]))
 });
 var ClaudecodeSubagent = class _ClaudecodeSubagent extends ToolSubagent {
   frontmatter;
@@ -3824,7 +3895,7 @@ var subagentsProcessorToolTargetsSimulated = [
   "roo"
 ];
 var subagentsProcessorToolTargetsGlobal = ["claudecode"];
-var SubagentsProcessorToolTargetSchema = z15.enum(subagentsProcessorToolTargets);
+var SubagentsProcessorToolTargetSchema = z16.enum(subagentsProcessorToolTargets);
 var SubagentsProcessor = class extends FeatureProcessor {
   toolTarget;
   global;
@@ -4109,23 +4180,23 @@ import { join as join37 } from "path";
 
 // src/rules/rulesync-rule.ts
 import { basename as basename15, join as join36 } from "path";
-import { z as z16 } from "zod/mini";
-var RulesyncRuleFrontmatterSchema = z16.object({
-  root: z16.optional(z16.optional(z16.boolean())),
-  targets: z16.optional(RulesyncTargetsSchema),
-  description: z16.optional(z16.string()),
-  globs: z16.optional(z16.array(z16.string())),
-  agentsmd: z16.optional(
-    z16.object({
+import { z as z17 } from "zod/mini";
+var RulesyncRuleFrontmatterSchema = z17.object({
+  root: z17.optional(z17.optional(z17.boolean())),
+  targets: z17.optional(RulesyncTargetsSchema),
+  description: z17.optional(z17.string()),
+  globs: z17.optional(z17.array(z17.string())),
+  agentsmd: z17.optional(
+    z17.object({
       // @example "path/to/subproject"
-      subprojectPath: z16.optional(z16.string())
+      subprojectPath: z17.optional(z17.string())
     })
   ),
-  cursor: z16.optional(
-    z16.object({
-      alwaysApply: z16.optional(z16.boolean()),
-      description: z16.optional(z16.string()),
-      globs: z16.optional(z16.array(z16.string()))
+  cursor: z17.optional(
+    z17.object({
+      alwaysApply: z17.optional(z17.boolean()),
+      description: z17.optional(z17.string()),
+      globs: z17.optional(z17.array(z17.string()))
     })
   )
 });
@@ -4706,9 +4777,9 @@ var ClaudecodeRule = class _ClaudecodeRule extends ToolRule {
 
 // src/rules/cline-rule.ts
 import { join as join43 } from "path";
-import { z as z17 } from "zod/mini";
-var ClineRuleFrontmatterSchema = z17.object({
-  description: z17.string()
+import { z as z18 } from "zod/mini";
+var ClineRuleFrontmatterSchema = z18.object({
+  description: z18.string()
 });
 var ClineRule = class _ClineRule extends ToolRule {
   static getSettablePaths() {
@@ -4853,10 +4924,10 @@ var CodexcliRule = class _CodexcliRule extends ToolRule {
 
 // src/rules/copilot-rule.ts
 import { join as join45 } from "path";
-import { z as z18 } from "zod/mini";
-var CopilotRuleFrontmatterSchema = z18.object({
-  description: z18.optional(z18.string()),
-  applyTo: z18.optional(z18.string())
+import { z as z19 } from "zod/mini";
+var CopilotRuleFrontmatterSchema = z19.object({
+  description: z19.optional(z19.string()),
+  applyTo: z19.optional(z19.string())
 });
 var CopilotRule = class _CopilotRule extends ToolRule {
   frontmatter;
@@ -5015,11 +5086,11 @@ var CopilotRule = class _CopilotRule extends ToolRule {
 
 // src/rules/cursor-rule.ts
 import { basename as basename16, join as join46 } from "path";
-import { z as z19 } from "zod/mini";
-var CursorRuleFrontmatterSchema = z19.object({
-  description: z19.optional(z19.string()),
-  globs: z19.optional(z19.string()),
-  alwaysApply: z19.optional(z19.boolean())
+import { z as z20 } from "zod/mini";
+var CursorRuleFrontmatterSchema = z20.object({
+  description: z20.optional(z20.string()),
+  globs: z20.optional(z20.string()),
+  alwaysApply: z20.optional(z20.boolean())
 });
 var CursorRule = class _CursorRule extends ToolRule {
   frontmatter;
@@ -5723,7 +5794,7 @@ var rulesProcessorToolTargets = [
   "warp",
   "windsurf"
 ];
-var RulesProcessorToolTargetSchema = z20.enum(rulesProcessorToolTargets);
+var RulesProcessorToolTargetSchema = z21.enum(rulesProcessorToolTargets);
 var rulesProcessorToolTargetsGlobal = [
   "claudecode",
   "codexcli",
@@ -6772,6 +6843,7 @@ var gitignoreCommand = async () => {
     "**/.amazonq/",
     "**/.github/copilot-instructions.md",
     "**/.github/instructions/",
+    "**/.github/prompts/",
     "**/.cursor/",
     "**/.cursorignore",
     "**/.clinerules/",
@@ -7077,7 +7149,7 @@ globs: ["**/*"]
 }
 
 // src/cli/index.ts
-var getVersion = () => "3.4.3";
+var getVersion = () => "3.5.0";
 var main = async () => {
   const program = new Command();
   const version = getVersion();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rulesync",
-  "version": "3.4.3",
+  "version": "3.5.0",
   "description": "Unified AI rules management CLI tool that generates configuration files for various AI development tools",
   "keywords": [
     "ai",
@@ -57,7 +57,7 @@
     "@types/js-yaml": "4.0.9",
     "@types/micromatch": "4.0.9",
     "@types/node": "24.7.2",
-    "@typescript/native-preview": "7.0.0-dev.20251011.1",
+    "@typescript/native-preview": "7.0.0-dev.20251012.1",
     "@vitest/coverage-v8": "3.2.4",
     "cspell": "9.2.1",
     "eslint": "9.37.0",