rulesync 0.42.0 → 0.44.0

package/dist/index.js

@@ -1,30 +1,34 @@
 #!/usr/bin/env node
 import {
   generateClaudeMcp
-} from "./chunk-HMMPZV7X.js";
+} from "./chunk-22GWBUIP.js";
 import {
   generateClineMcp
-} from "./chunk-X3FEMISQ.js";
+} from "./chunk-BD37M3ZH.js";
 import {
   generateCopilotMcp
-} from "./chunk-SXEFNT27.js";
+} from "./chunk-ZORSPGDD.js";
 import {
   generateCursorMcp
-} from "./chunk-D3YGI36J.js";
+} from "./chunk-FAZT3ILF.js";
 import {
   generateGeminiCliMcp
-} from "./chunk-2SPL7QTK.js";
+} from "./chunk-DCSO5MY7.js";
 import {
   generateRooMcp
-} from "./chunk-3NRSCDLQ.js";
-import "./chunk-6YNGMPAL.js";
+} from "./chunk-PJUNIIF4.js";
+import {
+  RulesyncTargetsSchema,
+  ToolTargetSchema,
+  ToolTargetsSchema
+} from "./chunk-I5XVU7C6.js";
 
 // src/cli/index.ts
 import { Command } from "commander";
 
 // src/cli/commands/add.ts
 import { mkdir, writeFile } from "fs/promises";
-import path from "path";
+import * as path from "path";
 
 // src/utils/config.ts
 function getDefaultConfig() {
@@ -35,19 +39,19 @@ function getDefaultConfig() {
       cursor: ".cursor/rules",
       cline: ".clinerules",
       claudecode: ".",
-      claude: ".",
       roo: ".roo/rules",
       geminicli: ".gemini/memories"
     },
     watchEnabled: false,
-    defaultTargets: ["copilot", "cursor", "cline", "claudecode", "claude", "roo", "geminicli"]
+    defaultTargets: ["copilot", "cursor", "cline", "claudecode", "roo", "geminicli"]
   };
 }
 function resolveTargets(targets, config) {
-  if (targets[0] === "*") {
+  if (targets.length === 1 && targets[0] === "*") {
     return config.defaultTargets;
   }
-  return targets;
+  const validatedTargets = ToolTargetsSchema.parse(targets);
+  return validatedTargets;
 }
 
 // src/cli/commands/add.ts
@@ -87,11 +91,22 @@ async function addCommand(filename) {
 }
 
 // src/generators/rules/claudecode.ts
-import { join as join3 } from "path";
+import { join as join4 } from "path";
+
+// src/types/claudecode.ts
+import { z } from "zod/v4-mini";
+var ClaudeSettingsSchema = z.looseObject({
+  permissions: z._default(
+    z.looseObject({
+      deny: z._default(z.array(z.string()), [])
+    }),
+    { deny: [] }
+  )
+});
 
 // src/utils/file.ts
 import { readdir, rm } from "fs/promises";
-import { join as join2 } from "path";
+import { join as join3 } from "path";
 
 // src/utils/file-ops.ts
 import { mkdir as mkdir2, readFile, stat, writeFile as writeFile2 } from "fs/promises";
@@ -120,14 +135,14 @@ async function fileExists(filepath) {
 }
 
 // src/utils/ignore.ts
-import { join } from "path";
+import { join as join2 } from "path";
 import micromatch from "micromatch";
 var cachedIgnorePatterns = null;
 async function loadIgnorePatterns(baseDir = process.cwd()) {
   if (cachedIgnorePatterns) {
     return cachedIgnorePatterns;
   }
-  const ignorePath = join(baseDir, ".rulesyncignore");
+  const ignorePath = join2(baseDir, ".rulesyncignore");
   if (!await fileExists(ignorePath)) {
     cachedIgnorePatterns = { patterns: [] };
     return cachedIgnorePatterns;
@@ -174,7 +189,7 @@ function filterIgnoredFiles(files, ignorePatterns) {
 async function findFiles(dir, extension = ".md", ignorePatterns) {
   try {
     const files = await readdir(dir);
-    const filtered = files.filter((file) => file.endsWith(extension)).map((file) => join2(dir, file));
+    const filtered = files.filter((file) => file.endsWith(extension)).map((file) => join3(dir, file));
     if (ignorePatterns && ignorePatterns.length > 0) {
       return filterIgnoredFiles(filtered, ignorePatterns);
     }
@@ -223,23 +238,23 @@ async function generateClaudecodeConfig(rules, config, baseDir) {
   const rootRules = rules.filter((r) => r.frontmatter.root === true);
   const detailRules = rules.filter((r) => r.frontmatter.root === false);
   const claudeMdContent = generateClaudeMarkdown(rootRules, detailRules);
-  const claudeOutputDir = baseDir ? join3(baseDir, config.outputPaths.claudecode) : config.outputPaths.claudecode;
+  const claudeOutputDir = baseDir ? join4(baseDir, config.outputPaths.claudecode) : config.outputPaths.claudecode;
   outputs.push({
     tool: "claudecode",
-    filepath: join3(claudeOutputDir, "CLAUDE.md"),
+    filepath: join4(claudeOutputDir, "CLAUDE.md"),
     content: claudeMdContent
   });
   for (const rule of detailRules) {
     const memoryContent = generateMemoryFile(rule);
     outputs.push({
       tool: "claudecode",
-      filepath: join3(claudeOutputDir, ".claude", "memories", `${rule.filename}.md`),
+      filepath: join4(claudeOutputDir, ".claude", "memories", `${rule.filename}.md`),
       content: memoryContent
     });
   }
   const ignorePatterns = await loadIgnorePatterns(baseDir);
   if (ignorePatterns.patterns.length > 0) {
-    const settingsPath = baseDir ? join3(baseDir, ".claude", "settings.json") : join3(".claude", "settings.json");
+    const settingsPath = baseDir ? join4(baseDir, ".claude", "settings.json") : join4(".claude", "settings.json");
     await updateClaudeSettings(settingsPath, ignorePatterns.patterns);
   }
   return outputs;
@@ -249,12 +264,10 @@ function generateClaudeMarkdown(rootRules, detailRules) {
   if (detailRules.length > 0) {
     lines.push("Please also reference the following documents as needed:");
     lines.push("");
-    lines.push("| Document | Description | File Patterns |");
-    lines.push("|----------|-------------|---------------|");
     for (const rule of detailRules) {
-      const globsText = rule.frontmatter.globs.length > 0 ? rule.frontmatter.globs.join(", ") : "-";
+      const globsText = rule.frontmatter.globs.length > 0 ? rule.frontmatter.globs.join(", ") : "";
       lines.push(
-        `| @.claude/memories/${rule.filename}.md | ${rule.frontmatter.description} | ${globsText} |`
+        `@.claude/memories/${rule.filename}.md ${rule.frontmatter.description} ${globsText}`.trim()
       );
     }
     lines.push("");
@@ -271,51 +284,46 @@ function generateMemoryFile(rule) {
   return rule.content.trim();
 }
 async function updateClaudeSettings(settingsPath, ignorePatterns) {
-  let settings = {};
+  let rawSettings = {};
   if (await fileExists(settingsPath)) {
     try {
       const content = await readFileContent(settingsPath);
-      settings = JSON.parse(content);
+      rawSettings = JSON.parse(content);
     } catch {
       console.warn(`Failed to parse existing ${settingsPath}, creating new settings`);
-      settings = {};
+      rawSettings = {};
     }
   }
-  if (typeof settings !== "object" || settings === null) {
-    settings = {};
-  }
-  const settingsObj = settings;
-  if (!settingsObj.permissions || typeof settingsObj.permissions !== "object" || settingsObj.permissions === null) {
-    settingsObj.permissions = {};
+  const parseResult = ClaudeSettingsSchema.safeParse(rawSettings);
+  const settings = parseResult.success ? parseResult.data : ClaudeSettingsSchema.parse({});
+  const readDenyRules = ignorePatterns.map((pattern) => `Read(${pattern})`);
+  if (!settings.permissions) {
+    settings.permissions = { deny: [] };
   }
-  const permissions = settingsObj.permissions;
-  if (!Array.isArray(permissions.deny)) {
-    permissions.deny = [];
+  if (!Array.isArray(settings.permissions.deny)) {
+    settings.permissions.deny = [];
   }
-  const readDenyRules = ignorePatterns.map((pattern) => `Read(${pattern})`);
-  const denyArray = permissions.deny;
-  const filteredDeny = denyArray.filter((rule) => {
-    if (typeof rule !== "string") return false;
+  const filteredDeny = settings.permissions.deny.filter((rule) => {
     if (!rule.startsWith("Read(")) return true;
     const match = rule.match(/^Read\((.*)\)$/);
     if (!match) return true;
     return !ignorePatterns.includes(match[1] ?? "");
   });
   filteredDeny.push(...readDenyRules);
-  permissions.deny = [...new Set(filteredDeny)];
-  const jsonContent = JSON.stringify(settingsObj, null, 2);
+  settings.permissions.deny = Array.from(new Set(filteredDeny));
+  const jsonContent = JSON.stringify(settings, null, 2);
   await writeFileContent(settingsPath, jsonContent);
   console.log(`\u2705 Updated Claude Code settings: ${settingsPath}`);
 }
 
 // src/generators/rules/cline.ts
-import { join as join4 } from "path";
+import { join as join5 } from "path";
 async function generateClineConfig(rules, config, baseDir) {
   const outputs = [];
   for (const rule of rules) {
     const content = generateClineMarkdown(rule);
-    const outputDir = baseDir ? join4(baseDir, config.outputPaths.cline) : config.outputPaths.cline;
-    const filepath = join4(outputDir, `${rule.filename}.md`);
+    const outputDir = baseDir ? join5(baseDir, config.outputPaths.cline) : config.outputPaths.cline;
+    const filepath = join5(outputDir, `${rule.filename}.md`);
     outputs.push({
       tool: "cline",
       filepath,
@@ -324,7 +332,7 @@ async function generateClineConfig(rules, config, baseDir) {
   }
   const ignorePatterns = await loadIgnorePatterns(baseDir);
   if (ignorePatterns.patterns.length > 0) {
-    const clineIgnorePath = baseDir ? join4(baseDir, ".clineignore") : ".clineignore";
+    const clineIgnorePath = baseDir ? join5(baseDir, ".clineignore") : ".clineignore";
     const clineIgnoreContent = generateClineIgnore(ignorePatterns.patterns);
     outputs.push({
       tool: "cline",
@@ -348,14 +356,14 @@ function generateClineIgnore(patterns) {
 }
 
 // src/generators/rules/copilot.ts
-import { join as join5 } from "path";
+import { join as join6 } from "path";
 async function generateCopilotConfig(rules, config, baseDir) {
   const outputs = [];
   for (const rule of rules) {
     const content = generateCopilotMarkdown(rule);
     const baseFilename = rule.filename.replace(/\.md$/, "");
-    const outputDir = baseDir ? join5(baseDir, config.outputPaths.copilot) : config.outputPaths.copilot;
-    const filepath = join5(outputDir, `${baseFilename}.instructions.md`);
+    const outputDir = baseDir ? join6(baseDir, config.outputPaths.copilot) : config.outputPaths.copilot;
+    const filepath = join6(outputDir, `${baseFilename}.instructions.md`);
     outputs.push({
       tool: "copilot",
       filepath,
@@ -364,7 +372,7 @@ async function generateCopilotConfig(rules, config, baseDir) {
   }
   const ignorePatterns = await loadIgnorePatterns(baseDir);
   if (ignorePatterns.patterns.length > 0) {
-    const copilotIgnorePath = baseDir ? join5(baseDir, ".copilotignore") : ".copilotignore";
+    const copilotIgnorePath = baseDir ? join6(baseDir, ".copilotignore") : ".copilotignore";
     const copilotIgnoreContent = generateCopilotIgnore(ignorePatterns.patterns);
     outputs.push({
       tool: "copilot",
@@ -400,13 +408,13 @@ function generateCopilotIgnore(patterns) {
 }
 
 // src/generators/rules/cursor.ts
-import { join as join6 } from "path";
+import { join as join7 } from "path";
 async function generateCursorConfig(rules, config, baseDir) {
   const outputs = [];
   for (const rule of rules) {
     const content = generateCursorMarkdown(rule);
-    const outputDir = baseDir ? join6(baseDir, config.outputPaths.cursor) : config.outputPaths.cursor;
-    const filepath = join6(outputDir, `${rule.filename}.mdc`);
+    const outputDir = baseDir ? join7(baseDir, config.outputPaths.cursor) : config.outputPaths.cursor;
+    const filepath = join7(outputDir, `${rule.filename}.mdc`);
     outputs.push({
       tool: "cursor",
       filepath,
@@ -415,7 +423,7 @@ async function generateCursorConfig(rules, config, baseDir) {
   }
   const ignorePatterns = await loadIgnorePatterns(baseDir);
   if (ignorePatterns.patterns.length > 0) {
-    const cursorIgnorePath = baseDir ? join6(baseDir, ".cursorignore") : ".cursorignore";
+    const cursorIgnorePath = baseDir ? join7(baseDir, ".cursorignore") : ".cursorignore";
     const cursorIgnoreContent = generateCursorIgnore(ignorePatterns.patterns);
     outputs.push({
       tool: "cursor",
@@ -488,15 +496,15 @@ function generateCursorIgnore(patterns) {
 }
 
 // src/generators/rules/geminicli.ts
-import { join as join7 } from "path";
+import { join as join8 } from "path";
 async function generateGeminiConfig(rules, config, baseDir) {
   const outputs = [];
   const rootRule = rules.find((rule) => rule.frontmatter.root === true);
   const memoryRules = rules.filter((rule) => rule.frontmatter.root === false);
   for (const rule of memoryRules) {
     const content = generateGeminiMemoryMarkdown(rule);
-    const outputDir = baseDir ? join7(baseDir, config.outputPaths.geminicli) : config.outputPaths.geminicli;
-    const filepath = join7(outputDir, `${rule.filename}.md`);
+    const outputDir = baseDir ? join8(baseDir, config.outputPaths.geminicli) : config.outputPaths.geminicli;
+    const filepath = join8(outputDir, `${rule.filename}.md`);
     outputs.push({
       tool: "geminicli",
       filepath,
@@ -504,7 +512,7 @@ async function generateGeminiConfig(rules, config, baseDir) {
     });
   }
   const rootContent = generateGeminiRootMarkdown(rootRule, memoryRules, baseDir);
-  const rootFilepath = baseDir ? join7(baseDir, "GEMINI.md") : "GEMINI.md";
+  const rootFilepath = baseDir ? join8(baseDir, "GEMINI.md") : "GEMINI.md";
   outputs.push({
     tool: "geminicli",
     filepath: rootFilepath,
@@ -512,7 +520,7 @@ async function generateGeminiConfig(rules, config, baseDir) {
   });
   const ignorePatterns = await loadIgnorePatterns(baseDir);
   if (ignorePatterns.patterns.length > 0) {
-    const aiexcludePath = baseDir ? join7(baseDir, ".aiexclude") : ".aiexclude";
+    const aiexcludePath = baseDir ? join8(baseDir, ".aiexclude") : ".aiexclude";
     const aiexcludeContent = generateAiexclude(ignorePatterns.patterns);
     outputs.push({
       tool: "geminicli",
@@ -560,13 +568,13 @@ function generateAiexclude(patterns) {
 }
 
 // src/generators/rules/roo.ts
-import { join as join8 } from "path";
+import { join as join9 } from "path";
 async function generateRooConfig(rules, config, baseDir) {
   const outputs = [];
   for (const rule of rules) {
     const content = generateRooMarkdown(rule);
-    const outputDir = baseDir ? join8(baseDir, config.outputPaths.roo) : config.outputPaths.roo;
-    const filepath = join8(outputDir, `${rule.filename}.md`);
+    const outputDir = baseDir ? join9(baseDir, config.outputPaths.roo) : config.outputPaths.roo;
+    const filepath = join9(outputDir, `${rule.filename}.md`);
     outputs.push({
       tool: "roo",
       filepath,
@@ -575,7 +583,7 @@ async function generateRooConfig(rules, config, baseDir) {
   }
   const ignorePatterns = await loadIgnorePatterns(baseDir);
   if (ignorePatterns.patterns.length > 0) {
-    const rooIgnorePath = baseDir ? join8(baseDir, ".rooignore") : ".rooignore";
+    const rooIgnorePath = baseDir ? join9(baseDir, ".rooignore") : ".rooignore";
     const rooIgnoreContent = generateRooIgnore(ignorePatterns.patterns);
     outputs.push({
       tool: "roo",
@@ -650,6 +658,72 @@ async function generateForTool(tool, rules, config, baseDir) {
 // src/core/parser.ts
 import { basename } from "path";
 import matter from "gray-matter";
+
+// src/types/config.ts
+import { z as z2 } from "zod/v4-mini";
+var ConfigSchema = z2.object({
+  aiRulesDir: z2.string(),
+  outputPaths: z2.record(ToolTargetSchema, z2.string()),
+  watchEnabled: z2.boolean(),
+  defaultTargets: ToolTargetsSchema
+});
+
+// src/types/mcp.ts
+import { z as z3 } from "zod/v4-mini";
+var McpTransportTypeSchema = z3.enum(["stdio", "sse", "http"]);
+var McpServerBaseSchema = z3.object({
+  command: z3.optional(z3.string()),
+  args: z3.optional(z3.array(z3.string())),
+  url: z3.optional(z3.string()),
+  httpUrl: z3.optional(z3.string()),
+  env: z3.optional(z3.record(z3.string(), z3.string())),
+  disabled: z3.optional(z3.boolean()),
+  networkTimeout: z3.optional(z3.number()),
+  timeout: z3.optional(z3.number()),
+  trust: z3.optional(z3.boolean()),
+  cwd: z3.optional(z3.string()),
+  transport: z3.optional(McpTransportTypeSchema),
+  type: z3.optional(z3.enum(["sse", "streamable-http"])),
+  alwaysAllow: z3.optional(z3.array(z3.string())),
+  tools: z3.optional(z3.array(z3.string()))
+});
+var RulesyncMcpServerSchema = z3.extend(McpServerBaseSchema, {
+  targets: z3.optional(RulesyncTargetsSchema)
+});
+var McpConfigSchema = z3.object({
+  mcpServers: z3.record(z3.string(), McpServerBaseSchema)
+});
+var RulesyncMcpConfigSchema = z3.object({
+  mcpServers: z3.record(z3.string(), RulesyncMcpServerSchema)
+});
+
+// src/types/rules.ts
+import { z as z4 } from "zod/v4-mini";
+var RuleFrontmatterSchema = z4.object({
+  root: z4.boolean(),
+  targets: RulesyncTargetsSchema,
+  description: z4.string(),
+  globs: z4.array(z4.string()),
+  cursorRuleType: z4.optional(z4.enum(["always", "manual", "specificFiles", "intelligently"]))
+});
+var ParsedRuleSchema = z4.object({
+  frontmatter: RuleFrontmatterSchema,
+  content: z4.string(),
+  filename: z4.string(),
+  filepath: z4.string()
+});
+var GeneratedOutputSchema = z4.object({
+  tool: ToolTargetSchema,
+  filepath: z4.string(),
+  content: z4.string()
+});
+var GenerateOptionsSchema = z4.object({
+  targetTools: z4.optional(ToolTargetsSchema),
+  outputDir: z4.optional(z4.string()),
+  watch: z4.optional(z4.boolean())
+});
+
+// src/core/parser.ts
 async function parseRulesFromDirectory(aiRulesDir) {
   const ignorePatterns = await loadIgnorePatterns();
   const ruleFiles = await findFiles(aiRulesDir, ".md", ignorePatterns.patterns);
@@ -683,84 +757,20 @@ ${errors.join("\n")}`);
 async function parseRuleFile(filepath) {
   const content = await readFileContent(filepath);
   const parsed = matter(content);
-  validateFrontmatter(parsed.data, filepath);
-  const frontmatter = parsed.data;
-  const filename = basename(filepath, ".md");
-  return {
-    frontmatter,
-    content: parsed.content,
-    filename,
-    filepath
-  };
-}
-function validateFrontmatter(data, filepath) {
-  if (!data || typeof data !== "object") {
-    if (!data) {
-      throw new Error(
-        `Missing frontmatter in ${filepath}: file must contain YAML frontmatter with required fields (root, targets, description, globs)`
-      );
-    }
-    throw new Error(`Invalid frontmatter in ${filepath}: frontmatter must be a valid YAML object`);
-  }
-  const obj = data;
-  if (Object.keys(obj).length === 0) {
-    throw new Error(
-      `Missing frontmatter in ${filepath}: file must contain YAML frontmatter with required fields (root, targets, description, globs)`
-    );
-  }
-  if (obj.root === void 0) {
-    throw new Error(`Missing required field "root" in ${filepath}: must be true or false`);
-  }
-  if (typeof obj.root !== "boolean") {
-    throw new Error(
-      `Invalid "root" field in ${filepath}: must be a boolean (true or false), got ${typeof obj.root}`
-    );
-  }
-  if (obj.targets === void 0) {
-    throw new Error(
-      `Missing required field "targets" in ${filepath}: must be an array like ["*"] or ["copilot", "cursor"]`
-    );
-  }
-  if (!Array.isArray(obj.targets)) {
-    throw new Error(
-      `Invalid "targets" field in ${filepath}: must be an array, got ${typeof obj.targets}`
-    );
-  }
-  const validTargets = ["copilot", "cursor", "cline", "claudecode", "roo", "geminicli", "*"];
-  for (const target of obj.targets) {
-    if (typeof target !== "string" || !validTargets.includes(target)) {
-      throw new Error(
-        `Invalid target "${target}" in ${filepath}: must be one of ${validTargets.join(", ")}`
-      );
-    }
-  }
-  if (obj.description === void 0) {
-    throw new Error(
-      `Missing required field "description" in ${filepath}: must be a descriptive string`
-    );
-  }
-  if (typeof obj.description !== "string") {
-    throw new Error(
-      `Invalid "description" field in ${filepath}: must be a string, got ${typeof obj.description}`
-    );
-  }
-  if (obj.globs === void 0) {
-    throw new Error(
-      `Missing required field "globs" in ${filepath}: must be an array of file patterns like ["**/*.ts"]`
-    );
-  }
-  if (!Array.isArray(obj.globs)) {
+  try {
+    const frontmatter = RuleFrontmatterSchema.parse(parsed.data);
+    const filename = basename(filepath, ".md");
+    return {
+      frontmatter,
+      content: parsed.content,
+      filename,
+      filepath
+    };
+  } catch (error) {
     throw new Error(
-      `Invalid "globs" field in ${filepath}: must be an array, got ${typeof obj.globs}`
+      `Invalid frontmatter in ${filepath}: ${error instanceof Error ? error.message : String(error)}`
     );
   }
-  for (const glob of obj.globs) {
-    if (typeof glob !== "string") {
-      throw new Error(
-        `Invalid glob pattern in ${filepath}: all globs must be strings, got ${typeof glob}`
-      );
-    }
-  }
 }
 
 // src/core/validator.ts
@@ -814,11 +824,11 @@ async function validateRule(rule) {
 }
 
 // src/core/mcp-generator.ts
-import path3 from "path";
+import * as path3 from "path";
 
 // src/core/mcp-parser.ts
-import fs from "fs";
-import path2 from "path";
+import * as fs from "fs";
+import * as path2 from "path";
 function parseMcpConfig(projectRoot) {
   const mcpPath = path2.join(projectRoot, ".rulesync", ".mcp.json");
   if (!fs.existsSync(mcpPath)) {
@@ -831,13 +841,11 @@ function parseMcpConfig(projectRoot) {
       rawConfig.mcpServers = rawConfig.servers;
       delete rawConfig.servers;
     }
-    if (!rawConfig.mcpServers || typeof rawConfig.mcpServers !== "object") {
-      throw new Error("Invalid mcp.json: 'mcpServers' field must be an object");
-    }
     if (rawConfig.tools) {
       delete rawConfig.tools;
     }
-    return { mcpServers: rawConfig.mcpServers };
+    const validatedConfig = RulesyncMcpConfigSchema.parse(rawConfig);
+    return validatedConfig;
   } catch (error) {
     throw new Error(
       `Failed to parse mcp.json: ${error instanceof Error ? error.message : String(error)}`
@@ -1038,10 +1046,10 @@ Generating configurations for base directory: ${baseDir}`);
 }
 
 // src/cli/commands/gitignore.ts
-import { existsSync, readFileSync, writeFileSync } from "fs";
-import { join as join9 } from "path";
+import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync } from "fs";
+import { join as join12 } from "path";
 var gitignoreCommand = async () => {
-  const gitignorePath = join9(process.cwd(), ".gitignore");
+  const gitignorePath = join12(process.cwd(), ".gitignore");
   const rulesFilesToIgnore = [
     "# Generated by rulesync - AI tool configuration files",
     "**/.github/copilot-instructions.md",
@@ -1067,8 +1075,8 @@ var gitignoreCommand = async () => {
     "**/.roo/mcp.json"
   ];
   let gitignoreContent = "";
-  if (existsSync(gitignorePath)) {
-    gitignoreContent = readFileSync(gitignorePath, "utf-8");
+  if (existsSync2(gitignorePath)) {
+    gitignoreContent = readFileSync2(gitignorePath, "utf-8");
   }
   const linesToAdd = [];
   for (const rule of rulesFilesToIgnore) {
@@ -1095,17 +1103,17 @@ ${linesToAdd.join("\n")}
 };
 
 // src/core/importer.ts
-import { join as join16 } from "path";
+import { join as join19 } from "path";
 import matter4 from "gray-matter";
 
 // src/parsers/claudecode.ts
-import { basename as basename2, join as join10 } from "path";
+import { basename as basename2, join as join13 } from "path";
 async function parseClaudeConfiguration(baseDir = process.cwd()) {
   const errors = [];
   const rules = [];
   let ignorePatterns;
   let mcpServers;
-  const claudeFilePath = join10(baseDir, "CLAUDE.md");
+  const claudeFilePath = join13(baseDir, "CLAUDE.md");
   if (!await fileExists(claudeFilePath)) {
     errors.push("CLAUDE.md file not found");
     return { rules, errors };
@@ -1116,12 +1124,12 @@ async function parseClaudeConfiguration(baseDir = process.cwd()) {
     if (mainRule) {
       rules.push(mainRule);
     }
-    const memoryDir = join10(baseDir, ".claude", "memories");
+    const memoryDir = join13(baseDir, ".claude", "memories");
     if (await fileExists(memoryDir)) {
       const memoryRules = await parseClaudeMemoryFiles(memoryDir);
       rules.push(...memoryRules);
     }
-    const settingsPath = join10(baseDir, ".claude", "settings.json");
+    const settingsPath = join13(baseDir, ".claude", "settings.json");
     if (await fileExists(settingsPath)) {
       const settingsResult = await parseClaudeSettings(settingsPath);
       if (settingsResult.ignorePatterns) {
@@ -1178,7 +1186,7 @@ async function parseClaudeMemoryFiles(memoryDir) {
     const files = await readdir2(memoryDir);
     for (const file of files) {
       if (file.endsWith(".md")) {
-        const filePath = join10(memoryDir, file);
+        const filePath = join13(memoryDir, file);
         const content = await readFileContent(filePath);
         if (content.trim()) {
           const filename = basename2(file, ".md");
@@ -1210,6 +1218,9 @@ async function parseClaudeSettings(settingsPath) {
     const settings = JSON.parse(content);
     if (typeof settings === "object" && settings !== null && "permissions" in settings) {
       const permissions = settings.permissions;
+      if (typeof permissions !== "object" || permissions === null) {
+        return { ignorePatterns: [], errors: [] };
+      }
       if (permissions && "deny" in permissions && Array.isArray(permissions.deny)) {
         const readPatterns = permissions.deny.filter(
           (rule) => typeof rule === "string" && rule.startsWith("Read(") && rule.endsWith(")")
@@ -1222,11 +1233,9 @@ async function parseClaudeSettings(settingsPath) {
         }
       }
     }
-    if (typeof settings === "object" && settings !== null && "mcpServers" in settings) {
-      const servers = settings.mcpServers;
-      if (servers && typeof servers === "object" && Object.keys(servers).length > 0) {
-        mcpServers = servers;
-      }
+    const parseResult = RulesyncMcpConfigSchema.safeParse(settings);
+    if (parseResult.success && Object.keys(parseResult.data.mcpServers).length > 0) {
+      mcpServers = parseResult.data.mcpServers;
     }
   } catch (error) {
     const errorMessage = error instanceof Error ? error.message : String(error);
@@ -1240,11 +1249,11 @@ async function parseClaudeSettings(settingsPath) {
 }
 
 // src/parsers/cline.ts
-import { join as join11 } from "path";
+import { join as join14 } from "path";
 async function parseClineConfiguration(baseDir = process.cwd()) {
   const errors = [];
   const rules = [];
-  const clineFilePath = join11(baseDir, ".cline", "instructions.md");
+  const clineFilePath = join14(baseDir, ".cline", "instructions.md");
   if (await fileExists(clineFilePath)) {
     try {
       const content = await readFileContent(clineFilePath);
@@ -1267,14 +1276,14 @@ async function parseClineConfiguration(baseDir = process.cwd()) {
       errors.push(`Failed to parse .cline/instructions.md: ${errorMessage}`);
     }
   }
-  const clinerulesDirPath = join11(baseDir, ".clinerules");
+  const clinerulesDirPath = join14(baseDir, ".clinerules");
   if (await fileExists(clinerulesDirPath)) {
     try {
       const { readdir: readdir2 } = await import("fs/promises");
       const files = await readdir2(clinerulesDirPath);
       for (const file of files) {
         if (file.endsWith(".md")) {
-          const filePath = join11(clinerulesDirPath, file);
+          const filePath = join14(clinerulesDirPath, file);
           try {
             const content = await readFileContent(filePath);
             if (content.trim()) {
@@ -1310,12 +1319,12 @@ async function parseClineConfiguration(baseDir = process.cwd()) {
 }
 
 // src/parsers/copilot.ts
-import { basename as basename3, join as join12 } from "path";
+import { basename as basename3, join as join15 } from "path";
 import matter2 from "gray-matter";
 async function parseCopilotConfiguration(baseDir = process.cwd()) {
   const errors = [];
   const rules = [];
-  const copilotFilePath = join12(baseDir, ".github", "copilot-instructions.md");
+  const copilotFilePath = join15(baseDir, ".github", "copilot-instructions.md");
   if (await fileExists(copilotFilePath)) {
     try {
       const rawContent = await readFileContent(copilotFilePath);
@@ -1340,14 +1349,14 @@ async function parseCopilotConfiguration(baseDir = process.cwd()) {
       errors.push(`Failed to parse copilot-instructions.md: ${errorMessage}`);
     }
   }
-  const instructionsDir = join12(baseDir, ".github", "instructions");
+  const instructionsDir = join15(baseDir, ".github", "instructions");
   if (await fileExists(instructionsDir)) {
     try {
       const { readdir: readdir2 } = await import("fs/promises");
       const files = await readdir2(instructionsDir);
       for (const file of files) {
         if (file.endsWith(".instructions.md")) {
-          const filePath = join12(instructionsDir, file);
+          const filePath = join15(instructionsDir, file);
           const rawContent = await readFileContent(filePath);
           const parsed = matter2(rawContent);
           const content = parsed.content.trim();
@@ -1382,19 +1391,28 @@ async function parseCopilotConfiguration(baseDir = process.cwd()) {
 }
 
 // src/parsers/cursor.ts
-import { basename as basename4, join as join13 } from "path";
+import { basename as basename4, join as join16 } from "path";
 import matter3 from "gray-matter";
 import { DEFAULT_SCHEMA, FAILSAFE_SCHEMA, load } from "js-yaml";
+import { z as z5 } from "zod/v4-mini";
 var customMatterOptions = {
   engines: {
     yaml: {
       parse: (str) => {
         try {
-          let preprocessed = str.replace(/^(\s*globs:\s*)\*\s*$/gm, '$1"*"').replace(/^(\s*globs:\s*)([^\s"'[\n][^"'[\n]*?)(\s*)$/gm, '$1"$2"$3');
-          return load(preprocessed, { schema: DEFAULT_SCHEMA });
+          const preprocessed = str.replace(/^(\s*globs:\s*)\*\s*$/gm, '$1"*"').replace(/^(\s*globs:\s*)([^\s"'[\n][^"'[\n]*?)(\s*)$/gm, '$1"$2"$3');
+          const result = load(preprocessed, { schema: DEFAULT_SCHEMA });
+          if (typeof result === "object" && result !== null) {
+            return result;
+          }
+          throw new Error("Failed to parse YAML: result is not an object");
         } catch (error) {
           try {
-            return load(str, { schema: FAILSAFE_SCHEMA });
+            const result = load(str, { schema: FAILSAFE_SCHEMA });
+            if (typeof result === "object" && result !== null) {
+              return result;
+            }
+            throw new Error("Failed to parse YAML: result is not an object");
           } catch {
             throw error;
           }
@@ -1404,7 +1422,18 @@ var customMatterOptions = {
   }
 };
 function convertCursorMdcFrontmatter(cursorFrontmatter, _filename) {
-  const frontmatter = cursorFrontmatter;
+  const FrontmatterSchema = z5.record(z5.string(), z5.unknown());
+  const parseResult = FrontmatterSchema.safeParse(cursorFrontmatter);
+  if (!parseResult.success) {
+    return {
+      root: false,
+      targets: ["*"],
+      description: "",
+      globs: [],
+      cursorRuleType: "manual"
+    };
+  }
+  const frontmatter = parseResult.data;
   const description = normalizeValue(frontmatter?.description);
   const globs = normalizeGlobsValue(frontmatter?.globs);
   const alwaysApply = frontmatter?.alwaysApply === true || frontmatter?.alwaysApply === "true";
@@ -1439,7 +1468,7 @@ function convertCursorMdcFrontmatter(cursorFrontmatter, _filename) {
     return {
       root: false,
       targets: ["*"],
-      description,
+      description: description || "",
       globs: [],
       cursorRuleType: "intelligently"
     };
@@ -1487,7 +1516,7 @@ async function parseCursorConfiguration(baseDir = process.cwd()) {
   const rules = [];
   let ignorePatterns;
   let mcpServers;
-  const cursorFilePath = join13(baseDir, ".cursorrules");
+  const cursorFilePath = join16(baseDir, ".cursorrules");
   if (await fileExists(cursorFilePath)) {
     try {
       const rawContent = await readFileContent(cursorFilePath);
@@ -1508,14 +1537,14 @@ async function parseCursorConfiguration(baseDir = process.cwd()) {
       errors.push(`Failed to parse .cursorrules file: ${errorMessage}`);
     }
   }
-  const cursorRulesDir = join13(baseDir, ".cursor", "rules");
+  const cursorRulesDir = join16(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 = join13(cursorRulesDir, file);
+          const filePath = join16(cursorRulesDir, file);
           try {
             const rawContent = await readFileContent(filePath);
             const parsed = matter3(rawContent, customMatterOptions);
@@ -1544,7 +1573,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 = join13(baseDir, ".cursorignore");
+  const cursorIgnorePath = join16(baseDir, ".cursorignore");
   if (await fileExists(cursorIgnorePath)) {
     try {
       const content = await readFileContent(cursorIgnorePath);
@@ -1557,13 +1586,14 @@ async function parseCursorConfiguration(baseDir = process.cwd()) {
       errors.push(`Failed to parse .cursorignore: ${errorMessage}`);
     }
   }
-  const cursorMcpPath = join13(baseDir, ".cursor", "mcp.json");
+  const cursorMcpPath = join16(baseDir, ".cursor", "mcp.json");
   if (await fileExists(cursorMcpPath)) {
     try {
       const content = await readFileContent(cursorMcpPath);
       const mcp = JSON.parse(content);
-      if (mcp.mcpServers && Object.keys(mcp.mcpServers).length > 0) {
-        mcpServers = mcp.mcpServers;
+      const parseResult = RulesyncMcpConfigSchema.safeParse(mcp);
+      if (parseResult.success && Object.keys(parseResult.data.mcpServers).length > 0) {
+        mcpServers = parseResult.data.mcpServers;
       }
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
@@ -1579,13 +1609,13 @@ async function parseCursorConfiguration(baseDir = process.cwd()) {
 }
 
 // src/parsers/geminicli.ts
-import { basename as basename5, join as join14 } from "path";
+import { basename as basename5, join as join17 } from "path";
 async function parseGeminiConfiguration(baseDir = process.cwd()) {
   const errors = [];
   const rules = [];
   let ignorePatterns;
   let mcpServers;
-  const geminiFilePath = join14(baseDir, "GEMINI.md");
+  const geminiFilePath = join17(baseDir, "GEMINI.md");
   if (!await fileExists(geminiFilePath)) {
     errors.push("GEMINI.md file not found");
     return { rules, errors };
@@ -1596,12 +1626,12 @@ async function parseGeminiConfiguration(baseDir = process.cwd()) {
     if (mainRule) {
       rules.push(mainRule);
     }
-    const memoryDir = join14(baseDir, ".gemini", "memories");
+    const memoryDir = join17(baseDir, ".gemini", "memories");
     if (await fileExists(memoryDir)) {
       const memoryRules = await parseGeminiMemoryFiles(memoryDir);
       rules.push(...memoryRules);
     }
-    const settingsPath = join14(baseDir, ".gemini", "settings.json");
+    const settingsPath = join17(baseDir, ".gemini", "settings.json");
     if (await fileExists(settingsPath)) {
       const settingsResult = await parseGeminiSettings(settingsPath);
       if (settingsResult.ignorePatterns) {
@@ -1612,7 +1642,7 @@ async function parseGeminiConfiguration(baseDir = process.cwd()) {
       }
       errors.push(...settingsResult.errors);
     }
-    const aiexcludePath = join14(baseDir, ".aiexclude");
+    const aiexcludePath = join17(baseDir, ".aiexclude");
     if (await fileExists(aiexcludePath)) {
       const aiexcludePatterns = await parseAiexclude(aiexcludePath);
       if (aiexcludePatterns.length > 0) {
@@ -1665,7 +1695,7 @@ async function parseGeminiMemoryFiles(memoryDir) {
     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 = basename5(file, ".md");
@@ -1694,8 +1724,9 @@ async function parseGeminiSettings(settingsPath) {
   try {
     const content = await readFileContent(settingsPath);
     const settings = JSON.parse(content);
-    if (settings.mcpServers && Object.keys(settings.mcpServers).length > 0) {
-      mcpServers = settings.mcpServers;
+    const parseResult = RulesyncMcpConfigSchema.safeParse(settings);
+    if (parseResult.success && Object.keys(parseResult.data.mcpServers).length > 0) {
+      mcpServers = parseResult.data.mcpServers;
     }
   } catch (error) {
     const errorMessage = error instanceof Error ? error.message : String(error);
@@ -1717,11 +1748,11 @@ async function parseAiexclude(aiexcludePath) {
 }
 
 // src/parsers/roo.ts
-import { join as join15 } from "path";
+import { join as join18 } from "path";
 async function parseRooConfiguration(baseDir = process.cwd()) {
   const errors = [];
   const rules = [];
-  const rooFilePath = join15(baseDir, ".roo", "instructions.md");
+  const rooFilePath = join18(baseDir, ".roo", "instructions.md");
   if (await fileExists(rooFilePath)) {
     try {
       const content = await readFileContent(rooFilePath);
@@ -1744,14 +1775,14 @@ async function parseRooConfiguration(baseDir = process.cwd()) {
       errors.push(`Failed to parse .roo/instructions.md: ${errorMessage}`);
     }
   }
-  const rooRulesDir = join15(baseDir, ".roo", "rules");
+  const rooRulesDir = join18(baseDir, ".roo", "rules");
   if (await fileExists(rooRulesDir)) {
     try {
       const { readdir: readdir2 } = await import("fs/promises");
       const files = await readdir2(rooRulesDir);
       for (const file of files) {
         if (file.endsWith(".md")) {
-          const filePath = join15(rooRulesDir, file);
+          const filePath = join18(rooRulesDir, file);
           try {
             const content = await readFileContent(filePath);
             if (content.trim()) {
@@ -1852,7 +1883,7 @@ async function importConfiguration(options) {
   if (rules.length === 0 && !ignorePatterns && !mcpServers) {
     return { success: false, rulesCreated: 0, errors };
   }
-  const rulesDirPath = join16(baseDir, rulesDir);
+  const rulesDirPath = join19(baseDir, rulesDir);
   try {
     const { mkdir: mkdir3 } = await import("fs/promises");
     await mkdir3(rulesDirPath, { recursive: true });
@@ -1866,7 +1897,7 @@ async function importConfiguration(options) {
     try {
       const baseFilename = `${tool}__${rule.filename}`;
       const filename = await generateUniqueFilename(rulesDirPath, baseFilename);
-      const filePath = join16(rulesDirPath, `${filename}.md`);
+      const filePath = join19(rulesDirPath, `${filename}.md`);
       const content = generateRuleFileContent(rule);
       await writeFileContent(filePath, content);
       rulesCreated++;
@@ -1881,7 +1912,7 @@ async function importConfiguration(options) {
   let ignoreFileCreated = false;
   if (ignorePatterns && ignorePatterns.length > 0) {
     try {
-      const rulesyncignorePath = join16(baseDir, ".rulesyncignore");
+      const rulesyncignorePath = join19(baseDir, ".rulesyncignore");
       const ignoreContent = `${ignorePatterns.join("\n")}
 `;
       await writeFileContent(rulesyncignorePath, ignoreContent);
@@ -1897,7 +1928,7 @@ async function importConfiguration(options) {
   let mcpFileCreated = false;
   if (mcpServers && Object.keys(mcpServers).length > 0) {
     try {
-      const mcpPath = join16(baseDir, rulesDir, ".mcp.json");
+      const mcpPath = join19(baseDir, rulesDir, ".mcp.json");
       const mcpContent = `${JSON.stringify({ mcpServers }, null, 2)}
 `;
       await writeFileContent(mcpPath, mcpContent);
@@ -1925,7 +1956,7 @@ function generateRuleFileContent(rule) {
 async function generateUniqueFilename(rulesDir, baseFilename) {
   let filename = baseFilename;
   let counter = 1;
-  while (await fileExists(join16(rulesDir, `${filename}.md`))) {
+  while (await fileExists(join19(rulesDir, `${filename}.md`))) {
     filename = `${baseFilename}-${counter}`;
     counter++;
   }
@@ -1990,7 +2021,7 @@ async function importCommand(options = {}) {
 }
 
 // src/cli/commands/init.ts
-import { join as join17 } from "path";
+import { join as join20 } from "path";
 async function initCommand() {
   const aiRulesDir = ".rulesync";
   console.log("Initializing rulesync...");
@@ -2120,7 +2151,7 @@ globs: ["src/api/**/*.ts", "src/services/**/*.ts", "src/models/**/*.ts"]
     }
   ];
   for (const file of sampleFiles) {
-    const filepath = join17(aiRulesDir, file.filename);
+    const filepath = join20(aiRulesDir, file.filename);
     if (!await fileExists(filepath)) {
       await writeFileContent(filepath, file.content);
       console.log(`Created ${filepath}`);
@@ -2155,9 +2186,11 @@ async function statusCommand() {
       for (const rule of rules) {
         const targets = rule.frontmatter.targets[0] === "*" ? config.defaultTargets : rule.frontmatter.targets;
         for (const target of targets) {
-          if (target in targetCounts) {
-            targetCounts[target]++;
-          }
+          if (target === "copilot") targetCounts.copilot++;
+          else if (target === "cursor") targetCounts.cursor++;
+          else if (target === "cline") targetCounts.cline++;
+          else if (target === "claudecode") targetCounts.claudecode++;
+          else if (target === "roo") targetCounts.roo++;
         }
       }
       console.log("\n\u{1F3AF} Target tool coverage:");
@@ -2263,7 +2296,7 @@ async function watchCommand() {
 
 // src/cli/index.ts
 var program = new Command();
-program.name("rulesync").description("Unified AI rules management CLI tool").version("0.42.0");
+program.name("rulesync").description("Unified AI rules management CLI tool").version("0.44.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);