rulesync 3.17.1 → 3.19.0

package/README.md

@@ -70,16 +70,38 @@ chmod +x rulesync
 sudo mv rulesync /usr/local/bin/
 ```
 
+#### Windows (x64)
+
+```powershell
+# PowerShell
+Invoke-WebRequest -Uri "https://github.com/dyoshikawa/rulesync/releases/latest/download/rulesync-windows-x64.exe" -OutFile "rulesync.exe"
+# Add to PATH or place in a directory already in PATH
+Move-Item rulesync.exe C:\Windows\System32\
+```
+
+Or using curl (if available):
+
+```bash
+curl -L https://github.com/dyoshikawa/rulesync/releases/latest/download/rulesync-windows-x64.exe -o rulesync.exe
+# Place the binary wherever set PATH
+```
+
 #### Verify checksums
 
 ```bash
 curl -L https://github.com/dyoshikawa/rulesync/releases/latest/download/SHA256SUMS -o SHA256SUMS
-sha256sum -c SHA256SUMS
-```
 
-#### Windows support?
+# Linux/macOS
+sha256sum -c SHA256SUMS
 
-Though Windows is not supported yet, we are positively considering it.
+# Windows (PowerShell)
+# Download SHA256SUMS file first, then verify:
+Get-FileHash rulesync.exe -Algorithm SHA256 | ForEach-Object {
+  $actual = $_.Hash.ToLower()
+  $expected = (Get-Content SHA256SUMS | Select-String "rulesync-windows-x64.exe").ToString().Split()[0]
+  if ($actual -eq $expected) { "✓ Checksum verified" } else { "✗ Checksum mismatch" }
+}
+```
 </details>
 
 ## Getting Started
@@ -535,6 +557,52 @@ Focus on the difference of MCP tools usage.
 So, in this case, approximately 92% reduction in MCP tools consumption!
 </details>
 
+## Rulesync MCP Server (Experimental)
+
+Rulesync provides an MCP (Model Context Protocol) server that enables AI agents to manage your Rulesync files. This allows AI agents to discover, read, create, update, and delete files dynamically.
+
+### Usage
+
+#### Starting the MCP Server
+
+```bash
+rulesync mcp
+```
+
+This starts an MCP server using stdio transport that AI agents can communicate with.
+
+#### Configuration
+
+Add the Rulesync MCP server to your `.rulesync/mcp.json`:
+
+```json
+{
+  "mcpServers": {
+    "rulesync-mcp": {
+      "type": "stdio",
+      "command": "npx",
+      "args": ["-y", "rulesync", "mcp"],
+      "env": {}
+    }
+  }
+}
+```
+
+For development, you can use:
+
+```json
+{
+  "mcpServers": {
+    "rulesync-mcp": {
+      "type": "stdio",
+      "command": "pnpm",
+      "args": ["dev", "mcp"],
+      "env": {}
+    }
+  }
+}
+```
+
 ## Contributing
 
 Issues and Pull Requests are welcome!

package/dist/index.cjs

@@ -37,6 +37,26 @@ var FeatureSchema = import_mini.z.enum(ALL_FEATURES);
 var FeaturesSchema = import_mini.z.array(FeatureSchema);
 var RulesyncFeaturesSchema = import_mini.z.array(import_mini.z.enum(ALL_FEATURES_WITH_WILDCARD));
 
+// src/utils/error.ts
+var import_zod = require("zod");
+function isZodErrorLike(error) {
+  return error !== null && typeof error === "object" && "issues" in error && Array.isArray(error.issues) && error.issues.every(
+    (issue) => issue !== null && typeof issue === "object" && "path" in issue && Array.isArray(issue.path) && "message" in issue && typeof issue.message === "string"
+  );
+}
+function formatError(error) {
+  if (error instanceof import_zod.ZodError || isZodErrorLike(error)) {
+    return error.issues.map((issue) => {
+      const path2 = issue.path.length > 0 ? `${issue.path.join(".")}: ` : "";
+      return `${path2}${issue.message}`;
+    }).join("; ");
+  }
+  if (error instanceof Error) {
+    return `${error.name}: ${error.message}`;
+  }
+  return String(error);
+}
+
 // src/utils/logger.ts
 var import_consola = require("consola");
 
@@ -222,26 +242,6 @@ var FeatureProcessor = class {
   }
 };
 
-// src/utils/error.ts
-var import_zod = require("zod");
-function isZodErrorLike(error) {
-  return error !== null && typeof error === "object" && "issues" in error && Array.isArray(error.issues) && error.issues.every(
-    (issue) => issue !== null && typeof issue === "object" && "path" in issue && Array.isArray(issue.path) && "message" in issue && typeof issue.message === "string"
-  );
-}
-function formatError(error) {
-  if (error instanceof import_zod.ZodError || isZodErrorLike(error)) {
-    return error.issues.map((issue) => {
-      const path2 = issue.path.length > 0 ? `${issue.path.join(".")}: ` : "";
-      return `${path2}${issue.message}`;
-    }).join("; ");
-  }
-  if (error instanceof Error) {
-    return `${error.name}: ${error.message}`;
-  }
-  return String(error);
-}
-
 // src/commands/agentsmd-command.ts
 var import_node_path4 = require("path");
 
@@ -7706,8 +7706,200 @@ Attention, again, you are just the planner, so though you can read any files and
   }
 }
 
+// src/cli/commands/mcp.ts
+var import_node_path68 = require("path");
+var import_fastmcp = require("fastmcp");
+var import_mini23 = require("zod/mini");
+var MAX_RULE_SIZE_BYTES = 1024 * 1024;
+var MAX_RULES_COUNT = 1e3;
+var RULES_DIR_PREFIX = ".rulesync/rules";
+function validateRulePath(relativePathFromCwd) {
+  const normalizedPath = relativePathFromCwd.replace(/\\/g, "/");
+  if (!normalizedPath.startsWith(`${RULES_DIR_PREFIX}/`)) {
+    throw new Error(`Invalid rule path: must be within ${RULES_DIR_PREFIX}/ directory`);
+  }
+  try {
+    resolvePath(normalizedPath, process.cwd());
+  } catch (error) {
+    throw new Error(`Path validation failed: ${formatError(error)}`, { cause: error });
+  }
+  const filename = (0, import_node_path68.basename)(normalizedPath);
+  if (!/^[a-zA-Z0-9_-]+\.md$/.test(filename)) {
+    throw new Error(
+      `Invalid filename: ${filename}. Must match pattern [a-zA-Z0-9_-]+.md (alphanumeric, hyphens, underscores only)`
+    );
+  }
+}
+async function listRules() {
+  const rulesDir = (0, import_node_path68.join)(process.cwd(), ".rulesync", "rules");
+  try {
+    const files = await listDirectoryFiles(rulesDir);
+    const mdFiles = files.filter((file) => file.endsWith(".md"));
+    const rules = await Promise.all(
+      mdFiles.map(async (file) => {
+        try {
+          const rule = await RulesyncRule.fromFile({
+            relativeFilePath: file,
+            validate: true
+          });
+          const frontmatter = rule.getFrontmatter();
+          return {
+            relativePathFromCwd: (0, import_node_path68.join)(".rulesync", "rules", file),
+            frontmatter
+          };
+        } catch (error) {
+          logger.error(`Failed to read rule file ${file}: ${formatError(error)}`);
+          return null;
+        }
+      })
+    );
+    return rules.filter((rule) => rule !== null);
+  } catch (error) {
+    logger.error(`Failed to read rules directory: ${formatError(error)}`);
+    return [];
+  }
+}
+async function getRule({ relativePathFromCwd }) {
+  validateRulePath(relativePathFromCwd);
+  const filename = (0, import_node_path68.basename)(relativePathFromCwd);
+  try {
+    const rule = await RulesyncRule.fromFile({
+      relativeFilePath: filename,
+      validate: true
+    });
+    return {
+      relativePathFromCwd: (0, import_node_path68.join)(".rulesync", "rules", filename),
+      frontmatter: rule.getFrontmatter(),
+      body: rule.getBody()
+    };
+  } catch (error) {
+    throw new Error(`Failed to read rule file ${relativePathFromCwd}: ${formatError(error)}`, {
+      cause: error
+    });
+  }
+}
+async function putRule({
+  relativePathFromCwd,
+  frontmatter,
+  body
+}) {
+  validateRulePath(relativePathFromCwd);
+  const filename = (0, import_node_path68.basename)(relativePathFromCwd);
+  const estimatedSize = JSON.stringify(frontmatter).length + body.length;
+  if (estimatedSize > MAX_RULE_SIZE_BYTES) {
+    throw new Error(
+      `Rule size ${estimatedSize} bytes exceeds maximum ${MAX_RULE_SIZE_BYTES} bytes (1MB)`
+    );
+  }
+  try {
+    const existingRules = await listRules();
+    const isUpdate = existingRules.some(
+      (rule2) => rule2.relativePathFromCwd === (0, import_node_path68.join)(".rulesync", "rules", filename)
+    );
+    if (!isUpdate && existingRules.length >= MAX_RULES_COUNT) {
+      throw new Error(`Maximum number of rules (${MAX_RULES_COUNT}) reached`);
+    }
+    const rule = new RulesyncRule({
+      baseDir: process.cwd(),
+      relativeDirPath: ".rulesync/rules",
+      relativeFilePath: filename,
+      frontmatter,
+      body,
+      validate: true
+    });
+    const rulesDir = (0, import_node_path68.join)(process.cwd(), ".rulesync", "rules");
+    await ensureDir(rulesDir);
+    await writeFileContent(rule.getFilePath(), rule.getFileContent());
+    return {
+      relativePathFromCwd: (0, import_node_path68.join)(".rulesync", "rules", filename),
+      frontmatter: rule.getFrontmatter(),
+      body: rule.getBody()
+    };
+  } catch (error) {
+    throw new Error(`Failed to write rule file ${relativePathFromCwd}: ${formatError(error)}`, {
+      cause: error
+    });
+  }
+}
+async function deleteRule({ relativePathFromCwd }) {
+  validateRulePath(relativePathFromCwd);
+  const filename = (0, import_node_path68.basename)(relativePathFromCwd);
+  const fullPath = (0, import_node_path68.join)(process.cwd(), ".rulesync", "rules", filename);
+  try {
+    await removeFile(fullPath);
+    return {
+      relativePathFromCwd: (0, import_node_path68.join)(".rulesync", "rules", filename)
+    };
+  } catch (error) {
+    throw new Error(`Failed to delete rule file ${relativePathFromCwd}: ${formatError(error)}`, {
+      cause: error
+    });
+  }
+}
+async function mcpCommand({ version }) {
+  const server = new import_fastmcp.FastMCP({
+    name: "rulesync-mcp-server",
+    // Type assertion is safe here because version comes from package.json which follows semver
+    // eslint-disable-next-line no-type-assertion/no-type-assertion
+    version
+  });
+  server.addTool({
+    name: "listRules",
+    description: "List all rules from .rulesync/rules/*.md with their frontmatter",
+    parameters: import_mini23.z.object({}),
+    execute: async () => {
+      const rules = await listRules();
+      const output = { rules };
+      return JSON.stringify(output, null, 2);
+    }
+  });
+  server.addTool({
+    name: "getRule",
+    description: "Get detailed information about a specific rule. relativePathFromCwd parameter is required.",
+    parameters: import_mini23.z.object({
+      relativePathFromCwd: import_mini23.z.string()
+    }),
+    execute: async (args) => {
+      const result = await getRule({ relativePathFromCwd: args.relativePathFromCwd });
+      return JSON.stringify(result, null, 2);
+    }
+  });
+  server.addTool({
+    name: "putRule",
+    description: "Create or update a rule (upsert operation). relativePathFromCwd, frontmatter, and body parameters are required.",
+    parameters: import_mini23.z.object({
+      relativePathFromCwd: import_mini23.z.string(),
+      frontmatter: RulesyncRuleFrontmatterSchema,
+      body: import_mini23.z.string()
+    }),
+    execute: async (args) => {
+      const result = await putRule({
+        relativePathFromCwd: args.relativePathFromCwd,
+        frontmatter: args.frontmatter,
+        body: args.body
+      });
+      return JSON.stringify(result, null, 2);
+    }
+  });
+  server.addTool({
+    name: "deleteRule",
+    description: "Delete a rule file. relativePathFromCwd parameter is required.",
+    parameters: import_mini23.z.object({
+      relativePathFromCwd: import_mini23.z.string()
+    }),
+    execute: async (args) => {
+      const result = await deleteRule({ relativePathFromCwd: args.relativePathFromCwd });
+      return JSON.stringify(result, null, 2);
+    }
+  });
+  logger.info("Rulesync MCP server started via stdio");
+  void server.start({
+    transportType: "stdio"
+  });
+}
+
 // src/cli/index.ts
-var getVersion = () => "3.17.1";
+var getVersion = () => "3.19.0";
 var main = async () => {
   const program = new import_commander.Command();
   const version = getVersion();
@@ -7745,7 +7937,15 @@ var main = async () => {
         experimentalGlobal: options.experimentalGlobal
       });
     } catch (error) {
-      logger.error(error instanceof Error ? error.message : String(error));
+      logger.error(formatError(error));
+      process.exit(1);
+    }
+  });
+  program.command("mcp").description("Start MCP server for rulesync").action(async () => {
+    try {
+      await mcpCommand({ version });
+    } catch (error) {
+      logger.error(formatError(error));
       process.exit(1);
     }
   });
@@ -7800,13 +8000,13 @@ var main = async () => {
         experimentalSimulateSubagents: options.experimentalSimulateSubagents
       });
     } catch (error) {
-      logger.error(error instanceof Error ? error.message : String(error));
+      logger.error(formatError(error));
       process.exit(1);
     }
   });
   program.parse();
 };
 main().catch((error) => {
-  logger.error(error instanceof Error ? error.message : String(error));
+  logger.error(formatError(error));
   process.exit(1);
 });

package/dist/index.js

@@ -14,6 +14,26 @@ var FeatureSchema = z.enum(ALL_FEATURES);
 var FeaturesSchema = z.array(FeatureSchema);
 var RulesyncFeaturesSchema = z.array(z.enum(ALL_FEATURES_WITH_WILDCARD));
 
+// src/utils/error.ts
+import { ZodError } from "zod";
+function isZodErrorLike(error) {
+  return error !== null && typeof error === "object" && "issues" in error && Array.isArray(error.issues) && error.issues.every(
+    (issue) => issue !== null && typeof issue === "object" && "path" in issue && Array.isArray(issue.path) && "message" in issue && typeof issue.message === "string"
+  );
+}
+function formatError(error) {
+  if (error instanceof ZodError || isZodErrorLike(error)) {
+    return error.issues.map((issue) => {
+      const path2 = issue.path.length > 0 ? `${issue.path.join(".")}: ` : "";
+      return `${path2}${issue.message}`;
+    }).join("; ");
+  }
+  if (error instanceof Error) {
+    return `${error.name}: ${error.message}`;
+  }
+  return String(error);
+}
+
 // src/utils/logger.ts
 import { consola } from "consola";
 
@@ -199,26 +219,6 @@ var FeatureProcessor = class {
   }
 };
 
-// src/utils/error.ts
-import { ZodError } from "zod";
-function isZodErrorLike(error) {
-  return error !== null && typeof error === "object" && "issues" in error && Array.isArray(error.issues) && error.issues.every(
-    (issue) => issue !== null && typeof issue === "object" && "path" in issue && Array.isArray(issue.path) && "message" in issue && typeof issue.message === "string"
-  );
-}
-function formatError(error) {
-  if (error instanceof ZodError || isZodErrorLike(error)) {
-    return error.issues.map((issue) => {
-      const path2 = issue.path.length > 0 ? `${issue.path.join(".")}: ` : "";
-      return `${path2}${issue.message}`;
-    }).join("; ");
-  }
-  if (error instanceof Error) {
-    return `${error.name}: ${error.message}`;
-  }
-  return String(error);
-}
-
 // src/commands/agentsmd-command.ts
 import { basename as basename3, join as join3 } from "path";
 
@@ -7683,8 +7683,200 @@ Attention, again, you are just the planner, so though you can read any files and
   }
 }
 
+// src/cli/commands/mcp.ts
+import { basename as basename18, join as join66 } from "path";
+import { FastMCP } from "fastmcp";
+import { z as z23 } from "zod/mini";
+var MAX_RULE_SIZE_BYTES = 1024 * 1024;
+var MAX_RULES_COUNT = 1e3;
+var RULES_DIR_PREFIX = ".rulesync/rules";
+function validateRulePath(relativePathFromCwd) {
+  const normalizedPath = relativePathFromCwd.replace(/\\/g, "/");
+  if (!normalizedPath.startsWith(`${RULES_DIR_PREFIX}/`)) {
+    throw new Error(`Invalid rule path: must be within ${RULES_DIR_PREFIX}/ directory`);
+  }
+  try {
+    resolvePath(normalizedPath, process.cwd());
+  } catch (error) {
+    throw new Error(`Path validation failed: ${formatError(error)}`, { cause: error });
+  }
+  const filename = basename18(normalizedPath);
+  if (!/^[a-zA-Z0-9_-]+\.md$/.test(filename)) {
+    throw new Error(
+      `Invalid filename: ${filename}. Must match pattern [a-zA-Z0-9_-]+.md (alphanumeric, hyphens, underscores only)`
+    );
+  }
+}
+async function listRules() {
+  const rulesDir = join66(process.cwd(), ".rulesync", "rules");
+  try {
+    const files = await listDirectoryFiles(rulesDir);
+    const mdFiles = files.filter((file) => file.endsWith(".md"));
+    const rules = await Promise.all(
+      mdFiles.map(async (file) => {
+        try {
+          const rule = await RulesyncRule.fromFile({
+            relativeFilePath: file,
+            validate: true
+          });
+          const frontmatter = rule.getFrontmatter();
+          return {
+            relativePathFromCwd: join66(".rulesync", "rules", file),
+            frontmatter
+          };
+        } catch (error) {
+          logger.error(`Failed to read rule file ${file}: ${formatError(error)}`);
+          return null;
+        }
+      })
+    );
+    return rules.filter((rule) => rule !== null);
+  } catch (error) {
+    logger.error(`Failed to read rules directory: ${formatError(error)}`);
+    return [];
+  }
+}
+async function getRule({ relativePathFromCwd }) {
+  validateRulePath(relativePathFromCwd);
+  const filename = basename18(relativePathFromCwd);
+  try {
+    const rule = await RulesyncRule.fromFile({
+      relativeFilePath: filename,
+      validate: true
+    });
+    return {
+      relativePathFromCwd: join66(".rulesync", "rules", filename),
+      frontmatter: rule.getFrontmatter(),
+      body: rule.getBody()
+    };
+  } catch (error) {
+    throw new Error(`Failed to read rule file ${relativePathFromCwd}: ${formatError(error)}`, {
+      cause: error
+    });
+  }
+}
+async function putRule({
+  relativePathFromCwd,
+  frontmatter,
+  body
+}) {
+  validateRulePath(relativePathFromCwd);
+  const filename = basename18(relativePathFromCwd);
+  const estimatedSize = JSON.stringify(frontmatter).length + body.length;
+  if (estimatedSize > MAX_RULE_SIZE_BYTES) {
+    throw new Error(
+      `Rule size ${estimatedSize} bytes exceeds maximum ${MAX_RULE_SIZE_BYTES} bytes (1MB)`
+    );
+  }
+  try {
+    const existingRules = await listRules();
+    const isUpdate = existingRules.some(
+      (rule2) => rule2.relativePathFromCwd === join66(".rulesync", "rules", filename)
+    );
+    if (!isUpdate && existingRules.length >= MAX_RULES_COUNT) {
+      throw new Error(`Maximum number of rules (${MAX_RULES_COUNT}) reached`);
+    }
+    const rule = new RulesyncRule({
+      baseDir: process.cwd(),
+      relativeDirPath: ".rulesync/rules",
+      relativeFilePath: filename,
+      frontmatter,
+      body,
+      validate: true
+    });
+    const rulesDir = join66(process.cwd(), ".rulesync", "rules");
+    await ensureDir(rulesDir);
+    await writeFileContent(rule.getFilePath(), rule.getFileContent());
+    return {
+      relativePathFromCwd: join66(".rulesync", "rules", filename),
+      frontmatter: rule.getFrontmatter(),
+      body: rule.getBody()
+    };
+  } catch (error) {
+    throw new Error(`Failed to write rule file ${relativePathFromCwd}: ${formatError(error)}`, {
+      cause: error
+    });
+  }
+}
+async function deleteRule({ relativePathFromCwd }) {
+  validateRulePath(relativePathFromCwd);
+  const filename = basename18(relativePathFromCwd);
+  const fullPath = join66(process.cwd(), ".rulesync", "rules", filename);
+  try {
+    await removeFile(fullPath);
+    return {
+      relativePathFromCwd: join66(".rulesync", "rules", filename)
+    };
+  } catch (error) {
+    throw new Error(`Failed to delete rule file ${relativePathFromCwd}: ${formatError(error)}`, {
+      cause: error
+    });
+  }
+}
+async function mcpCommand({ version }) {
+  const server = new FastMCP({
+    name: "rulesync-mcp-server",
+    // Type assertion is safe here because version comes from package.json which follows semver
+    // eslint-disable-next-line no-type-assertion/no-type-assertion
+    version
+  });
+  server.addTool({
+    name: "listRules",
+    description: "List all rules from .rulesync/rules/*.md with their frontmatter",
+    parameters: z23.object({}),
+    execute: async () => {
+      const rules = await listRules();
+      const output = { rules };
+      return JSON.stringify(output, null, 2);
+    }
+  });
+  server.addTool({
+    name: "getRule",
+    description: "Get detailed information about a specific rule. relativePathFromCwd parameter is required.",
+    parameters: z23.object({
+      relativePathFromCwd: z23.string()
+    }),
+    execute: async (args) => {
+      const result = await getRule({ relativePathFromCwd: args.relativePathFromCwd });
+      return JSON.stringify(result, null, 2);
+    }
+  });
+  server.addTool({
+    name: "putRule",
+    description: "Create or update a rule (upsert operation). relativePathFromCwd, frontmatter, and body parameters are required.",
+    parameters: z23.object({
+      relativePathFromCwd: z23.string(),
+      frontmatter: RulesyncRuleFrontmatterSchema,
+      body: z23.string()
+    }),
+    execute: async (args) => {
+      const result = await putRule({
+        relativePathFromCwd: args.relativePathFromCwd,
+        frontmatter: args.frontmatter,
+        body: args.body
+      });
+      return JSON.stringify(result, null, 2);
+    }
+  });
+  server.addTool({
+    name: "deleteRule",
+    description: "Delete a rule file. relativePathFromCwd parameter is required.",
+    parameters: z23.object({
+      relativePathFromCwd: z23.string()
+    }),
+    execute: async (args) => {
+      const result = await deleteRule({ relativePathFromCwd: args.relativePathFromCwd });
+      return JSON.stringify(result, null, 2);
+    }
+  });
+  logger.info("Rulesync MCP server started via stdio");
+  void server.start({
+    transportType: "stdio"
+  });
+}
+
 // src/cli/index.ts
-var getVersion = () => "3.17.1";
+var getVersion = () => "3.19.0";
 var main = async () => {
   const program = new Command();
   const version = getVersion();
@@ -7722,7 +7914,15 @@ var main = async () => {
         experimentalGlobal: options.experimentalGlobal
       });
     } catch (error) {
-      logger.error(error instanceof Error ? error.message : String(error));
+      logger.error(formatError(error));
+      process.exit(1);
+    }
+  });
+  program.command("mcp").description("Start MCP server for rulesync").action(async () => {
+    try {
+      await mcpCommand({ version });
+    } catch (error) {
+      logger.error(formatError(error));
       process.exit(1);
     }
   });
@@ -7777,13 +7977,13 @@ var main = async () => {
         experimentalSimulateSubagents: options.experimentalSimulateSubagents
       });
     } catch (error) {
-      logger.error(error instanceof Error ? error.message : String(error));
+      logger.error(formatError(error));
       process.exit(1);
     }
   });
   program.parse();
 };
 main().catch((error) => {
-  logger.error(error instanceof Error ? error.message : String(error));
+  logger.error(formatError(error));
   process.exit(1);
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rulesync",
-  "version": "3.17.1",
+  "version": "3.19.0",
   "description": "Unified AI rules management CLI tool that generates configuration files for various AI development tools",
   "keywords": [
     "ai",
@@ -37,6 +37,7 @@
   },
   "dependencies": {
     "@kimuson/modular-mcp": "0.0.5",
+    "fastmcp": "^3.22.0",
     "chokidar": "4.0.3",
     "commander": "14.0.2",
     "consola": "3.4.2",