rulesync 0.45.0 → 0.47.0

package/dist/index.cjs

@@ -27,22 +27,23 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 
 // src/types/tool-targets.ts
-var import_v4_mini, ToolTargetSchema, ToolTargetsSchema, WildcardTargetSchema, RulesyncTargetsSchema;
+var import_mini, ToolTargetSchema, ToolTargetsSchema, WildcardTargetSchema, RulesyncTargetsSchema;
 var init_tool_targets = __esm({
   "src/types/tool-targets.ts"() {
     "use strict";
-    import_v4_mini = require("zod/v4-mini");
-    ToolTargetSchema = import_v4_mini.z.enum([
+    import_mini = require("zod/mini");
+    ToolTargetSchema = import_mini.z.enum([
       "copilot",
       "cursor",
       "cline",
       "claudecode",
       "roo",
-      "geminicli"
+      "geminicli",
+      "kiro"
     ]);
-    ToolTargetsSchema = import_v4_mini.z.array(ToolTargetSchema);
-    WildcardTargetSchema = import_v4_mini.z.tuple([import_v4_mini.z.literal("*")]);
-    RulesyncTargetsSchema = import_v4_mini.z.union([ToolTargetsSchema, WildcardTargetSchema]);
+    ToolTargetsSchema = import_mini.z.array(ToolTargetSchema);
+    WildcardTargetSchema = import_mini.z.tuple([import_mini.z.literal("*")]);
+    RulesyncTargetsSchema = import_mini.z.union([ToolTargetsSchema, WildcardTargetSchema]);
   }
 });
 
@@ -294,6 +295,57 @@ var init_geminicli = __esm({
   }
 });
 
+// src/generators/mcp/kiro.ts
+function generateKiroMcp(config) {
+  const kiroConfig = {
+    mcpServers: {}
+  };
+  for (const [serverName, server] of Object.entries(config.mcpServers)) {
+    if (!shouldIncludeServer(server, "kiro")) continue;
+    const kiroServer = {};
+    if (server.command) {
+      kiroServer.command = server.command;
+      if (server.args) kiroServer.args = server.args;
+    } else if (server.url || server.httpUrl) {
+      const url = server.httpUrl || server.url;
+      if (url) {
+        kiroServer.url = url;
+      }
+      if (server.httpUrl || server.transport === "http") {
+        kiroServer.transport = "streamable-http";
+      } else if (server.transport === "sse" || server.type === "sse") {
+        kiroServer.transport = "sse";
+      }
+    }
+    if (server.env) {
+      kiroServer.env = server.env;
+    }
+    if (server.timeout) {
+      kiroServer.timeout = server.timeout;
+    }
+    if (server.disabled !== void 0) {
+      kiroServer.disabled = server.disabled;
+    }
+    if (server.transport) {
+      kiroServer.transport = server.transport;
+    }
+    if (server.kiroAutoApprove) {
+      kiroServer.autoApprove = server.kiroAutoApprove;
+    }
+    if (server.kiroAutoBlock) {
+      kiroServer.autoBlock = server.kiroAutoBlock;
+    }
+    kiroConfig.mcpServers[serverName] = kiroServer;
+  }
+  return JSON.stringify(kiroConfig, null, 2);
+}
+var init_kiro = __esm({
+  "src/generators/mcp/kiro.ts"() {
+    "use strict";
+    init_mcp_helpers();
+  }
+});
+
 // src/generators/mcp/roo.ts
 function generateRooMcp(config) {
   const rooConfig = {
@@ -364,10 +416,11 @@ function getDefaultConfig() {
       cline: ".clinerules",
       claudecode: ".",
       roo: ".roo/rules",
-      geminicli: ".gemini/memories"
+      geminicli: ".gemini/memories",
+      kiro: ".kiro/steering"
     },
     watchEnabled: false,
-    defaultTargets: ["copilot", "cursor", "cline", "claudecode", "roo", "geminicli"]
+    defaultTargets: ["copilot", "cursor", "cline", "claudecode", "roo", "geminicli", "kiro"]
   };
 }
 function resolveTargets(targets, config) {
@@ -414,27 +467,138 @@ async function addCommand(filename) {
   }
 }
 
+// src/generators/ignore/kiro.ts
+var import_node_path = require("path");
+async function generateKiroIgnoreFiles(rules, config, baseDir) {
+  const outputs = [];
+  const aiignoreContent = generateAiignoreContent(rules);
+  const outputPath = baseDir || process.cwd();
+  const filepath = (0, import_node_path.join)(outputPath, ".aiignore");
+  outputs.push({
+    tool: "kiro",
+    filepath,
+    content: aiignoreContent
+  });
+  return outputs;
+}
+function generateAiignoreContent(rules) {
+  const lines = [
+    "# Generated by rulesync - Kiro AI-specific exclusions",
+    "# This file excludes files that can be in Git but shouldn't be read by the AI",
+    ""
+  ];
+  lines.push(
+    "# Data files AI shouldn't process",
+    "*.csv",
+    "*.tsv",
+    "*.sqlite",
+    "*.db",
+    "",
+    "# Large binary files",
+    "*.zip",
+    "*.tar.gz",
+    "*.rar",
+    "",
+    "# Sensitive documentation",
+    "internal-docs/",
+    "confidential/",
+    "",
+    "# Test data that might confuse AI",
+    "test/fixtures/large-*.json",
+    "benchmark-results/",
+    "",
+    "# Reinforce critical exclusions from .gitignore",
+    "*.pem",
+    "*.key",
+    ".env*",
+    ""
+  );
+  const rulePatterns = extractIgnorePatternsFromRules(rules);
+  if (rulePatterns.length > 0) {
+    lines.push("# Project-specific exclusions from rulesync rules");
+    lines.push(...rulePatterns);
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function extractIgnorePatternsFromRules(rules) {
+  const patterns = [];
+  for (const rule of rules) {
+    if (rule.frontmatter.globs && rule.frontmatter.globs.length > 0) {
+      for (const glob of rule.frontmatter.globs) {
+        if (shouldExcludeFromAI(glob)) {
+          patterns.push(`# Exclude: ${rule.frontmatter.description}`);
+          patterns.push(glob);
+        }
+      }
+    }
+    const contentPatterns = extractIgnorePatternsFromContent(rule.content);
+    patterns.push(...contentPatterns);
+  }
+  return patterns;
+}
+function shouldExcludeFromAI(glob) {
+  const excludePatterns = [
+    // Test and fixture files that might be large or confusing
+    "**/test/fixtures/**",
+    "**/tests/fixtures/**",
+    "**/*.fixture.*",
+    // Build and generated files
+    "**/dist/**",
+    "**/build/**",
+    "**/coverage/**",
+    // Configuration that might contain sensitive data
+    "**/config/production/**",
+    "**/config/prod/**",
+    "**/*.prod.*",
+    // Documentation that might be sensitive
+    "**/internal/**",
+    "**/private/**",
+    "**/confidential/**"
+  ];
+  return excludePatterns.some((pattern) => {
+    const regex = new RegExp(pattern.replace(/\*\*/g, ".*").replace(/\*/g, "[^/]*"));
+    return regex.test(glob);
+  });
+}
+function extractIgnorePatternsFromContent(content) {
+  const patterns = [];
+  const lines = content.split("\n");
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith("# IGNORE:") || trimmed.startsWith("# aiignore:")) {
+      const pattern = trimmed.replace(/^# (IGNORE|aiignore):\s*/, "").trim();
+      if (pattern) {
+        patterns.push(pattern);
+      }
+    }
+    if (trimmed.includes("exclude") || trimmed.includes("ignore")) {
+      const matches = trimmed.match(/['"`]([^'"`]+\.(log|tmp|cache|temp))['"`]/g);
+      if (matches) {
+        patterns.push(...matches.map((m) => m.replace(/['"`]/g, "")));
+      }
+    }
+  }
+  return patterns;
+}
+
 // src/generators/rules/claudecode.ts
 var import_node_path4 = require("path");
 
 // src/types/claudecode.ts
-var import_v4_mini2 = require("zod/v4-mini");
-var ClaudeSettingsSchema = import_v4_mini2.z.looseObject({
-  permissions: import_v4_mini2.z._default(
-    import_v4_mini2.z.looseObject({
-      deny: import_v4_mini2.z._default(import_v4_mini2.z.array(import_v4_mini2.z.string()), [])
+var import_mini2 = require("zod/mini");
+var ClaudeSettingsSchema = import_mini2.z.looseObject({
+  permissions: import_mini2.z._default(
+    import_mini2.z.looseObject({
+      deny: import_mini2.z._default(import_mini2.z.array(import_mini2.z.string()), [])
     }),
     { deny: [] }
   )
 });
 
 // src/utils/file.ts
-var import_promises3 = require("fs/promises");
-var import_node_path3 = require("path");
-
-// src/utils/file-ops.ts
 var import_promises2 = require("fs/promises");
-var import_node_path = require("path");
+var import_node_path2 = require("path");
 async function ensureDir(dirPath) {
   try {
     await (0, import_promises2.stat)(dirPath);
@@ -446,7 +610,7 @@ async function readFileContent(filepath) {
   return (0, import_promises2.readFile)(filepath, "utf-8");
 }
 async function writeFileContent(filepath, content) {
-  await ensureDir((0, import_node_path.dirname)(filepath));
+  await ensureDir((0, import_node_path2.dirname)(filepath));
   await (0, import_promises2.writeFile)(filepath, content, "utf-8");
 }
 async function fileExists(filepath) {
@@ -457,16 +621,57 @@ async function fileExists(filepath) {
     return false;
   }
 }
+async function findFiles(dir, extension = ".md") {
+  try {
+    const files = await (0, import_promises2.readdir)(dir);
+    return files.filter((file) => file.endsWith(extension)).map((file) => (0, import_node_path2.join)(dir, file));
+  } catch {
+    return [];
+  }
+}
+async function removeDirectory(dirPath) {
+  const dangerousPaths = [".", "/", "~", "src", "node_modules"];
+  if (dangerousPaths.includes(dirPath) || dirPath === "") {
+    console.warn(`Skipping deletion of dangerous path: ${dirPath}`);
+    return;
+  }
+  try {
+    if (await fileExists(dirPath)) {
+      await (0, import_promises2.rm)(dirPath, { recursive: true, force: true });
+    }
+  } catch (error) {
+    console.warn(`Failed to remove directory ${dirPath}:`, error);
+  }
+}
+async function removeFile(filepath) {
+  try {
+    if (await fileExists(filepath)) {
+      await (0, import_promises2.rm)(filepath);
+    }
+  } catch (error) {
+    console.warn(`Failed to remove file ${filepath}:`, error);
+  }
+}
+async function removeClaudeGeneratedFiles() {
+  const filesToRemove = ["CLAUDE.md", ".claude/memories"];
+  for (const fileOrDir of filesToRemove) {
+    if (fileOrDir.endsWith("/memories")) {
+      await removeDirectory(fileOrDir);
+    } else {
+      await removeFile(fileOrDir);
+    }
+  }
+}
 
 // src/utils/ignore.ts
-var import_node_path2 = require("path");
+var import_node_path3 = require("path");
 var import_micromatch = __toESM(require("micromatch"), 1);
 var cachedIgnorePatterns = null;
 async function loadIgnorePatterns(baseDir = process.cwd()) {
   if (cachedIgnorePatterns) {
     return cachedIgnorePatterns;
   }
-  const ignorePath = (0, import_node_path2.join)(baseDir, ".rulesyncignore");
+  const ignorePath = (0, import_node_path3.join)(baseDir, ".rulesyncignore");
   if (!await fileExists(ignorePath)) {
     cachedIgnorePatterns = { patterns: [] };
     return cachedIgnorePatterns;
@@ -509,53 +714,6 @@ function filterIgnoredFiles(files, ignorePatterns) {
   return files.filter((file) => !isFileIgnored(file, ignorePatterns));
 }
 
-// src/utils/file.ts
-async function findFiles(dir, extension = ".md", ignorePatterns) {
-  try {
-    const files = await (0, import_promises3.readdir)(dir);
-    const filtered = files.filter((file) => file.endsWith(extension)).map((file) => (0, import_node_path3.join)(dir, file));
-    if (ignorePatterns && ignorePatterns.length > 0) {
-      return filterIgnoredFiles(filtered, ignorePatterns);
-    }
-    return filtered;
-  } catch {
-    return [];
-  }
-}
-async function removeDirectory(dirPath) {
-  const dangerousPaths = [".", "/", "~", "src", "node_modules"];
-  if (dangerousPaths.includes(dirPath) || dirPath === "") {
-    console.warn(`Skipping deletion of dangerous path: ${dirPath}`);
-    return;
-  }
-  try {
-    if (await fileExists(dirPath)) {
-      await (0, import_promises3.rm)(dirPath, { recursive: true, force: true });
-    }
-  } catch (error) {
-    console.warn(`Failed to remove directory ${dirPath}:`, error);
-  }
-}
-async function removeFile(filepath) {
-  try {
-    if (await fileExists(filepath)) {
-      await (0, import_promises3.rm)(filepath);
-    }
-  } catch (error) {
-    console.warn(`Failed to remove file ${filepath}:`, error);
-  }
-}
-async function removeClaudeGeneratedFiles() {
-  const filesToRemove = ["CLAUDE.md", ".claude/memories"];
-  for (const fileOrDir of filesToRemove) {
-    if (fileOrDir.endsWith("/memories")) {
-      await removeDirectory(fileOrDir);
-    } else {
-      await removeFile(fileOrDir);
-    }
-  }
-}
-
 // src/generators/rules/claudecode.ts
 async function generateClaudecodeConfig(rules, config, baseDir) {
   const outputs = [];
@@ -892,14 +1050,34 @@ function generateAiexclude(patterns) {
   return lines.join("\n");
 }
 
-// src/generators/rules/roo.ts
+// src/generators/rules/kiro.ts
 var import_node_path9 = require("path");
+async function generateKiroConfig(rules, config, baseDir) {
+  const outputs = [];
+  for (const rule of rules) {
+    const content = generateKiroMarkdown(rule);
+    const outputDir = baseDir ? (0, import_node_path9.join)(baseDir, config.outputPaths.kiro) : config.outputPaths.kiro;
+    const filepath = (0, import_node_path9.join)(outputDir, `${rule.filename}.md`);
+    outputs.push({
+      tool: "kiro",
+      filepath,
+      content
+    });
+  }
+  return outputs;
+}
+function generateKiroMarkdown(rule) {
+  return rule.content.trim();
+}
+
+// src/generators/rules/roo.ts
+var import_node_path10 = require("path");
 async function generateRooConfig(rules, config, baseDir) {
   const outputs = [];
   for (const rule of rules) {
     const content = generateRooMarkdown(rule);
-    const outputDir = baseDir ? (0, import_node_path9.join)(baseDir, config.outputPaths.roo) : config.outputPaths.roo;
-    const filepath = (0, import_node_path9.join)(outputDir, `${rule.filename}.md`);
+    const outputDir = baseDir ? (0, import_node_path10.join)(baseDir, config.outputPaths.roo) : config.outputPaths.roo;
+    const filepath = (0, import_node_path10.join)(outputDir, `${rule.filename}.md`);
     outputs.push({
       tool: "roo",
       filepath,
@@ -908,7 +1086,7 @@ async function generateRooConfig(rules, config, baseDir) {
   }
   const ignorePatterns = await loadIgnorePatterns(baseDir);
   if (ignorePatterns.patterns.length > 0) {
-    const rooIgnorePath = baseDir ? (0, import_node_path9.join)(baseDir, ".rooignore") : ".rooignore";
+    const rooIgnorePath = baseDir ? (0, import_node_path10.join)(baseDir, ".rooignore") : ".rooignore";
     const rooIgnoreContent = generateRooIgnore(ignorePatterns.patterns);
     outputs.push({
       tool: "roo",
@@ -974,6 +1152,11 @@ async function generateForTool(tool, rules, config, baseDir) {
       return generateRooConfig(rules, config, baseDir);
     case "geminicli":
       return generateGeminiConfig(rules, config, baseDir);
+    case "kiro": {
+      const kiroRulesOutputs = await generateKiroConfig(rules, config, baseDir);
+      const kiroIgnoreOutputs = await generateKiroIgnoreFiles(rules, config, baseDir);
+      return [...kiroRulesOutputs, ...kiroIgnoreOutputs];
+    }
     default:
       console.warn(`Unknown tool: ${tool}`);
       return null;
@@ -981,74 +1164,76 @@ async function generateForTool(tool, rules, config, baseDir) {
 }
 
 // src/core/parser.ts
-var import_node_path10 = require("path");
+var import_node_path11 = require("path");
 var import_gray_matter = __toESM(require("gray-matter"), 1);
 
 // src/types/config.ts
-var import_v4_mini3 = require("zod/v4-mini");
+var import_mini3 = require("zod/mini");
 init_tool_targets();
-var ConfigSchema = import_v4_mini3.z.object({
-  aiRulesDir: import_v4_mini3.z.string(),
-  outputPaths: import_v4_mini3.z.record(ToolTargetSchema, import_v4_mini3.z.string()),
-  watchEnabled: import_v4_mini3.z.boolean(),
+var ConfigSchema = import_mini3.z.object({
+  aiRulesDir: import_mini3.z.string(),
+  outputPaths: import_mini3.z.record(ToolTargetSchema, import_mini3.z.string()),
+  watchEnabled: import_mini3.z.boolean(),
   defaultTargets: ToolTargetsSchema
 });
 
 // src/types/mcp.ts
-var import_v4_mini4 = require("zod/v4-mini");
+var import_mini4 = require("zod/mini");
 init_tool_targets();
-var McpTransportTypeSchema = import_v4_mini4.z.enum(["stdio", "sse", "http"]);
-var McpServerBaseSchema = import_v4_mini4.z.object({
-  command: import_v4_mini4.z.optional(import_v4_mini4.z.string()),
-  args: import_v4_mini4.z.optional(import_v4_mini4.z.array(import_v4_mini4.z.string())),
-  url: import_v4_mini4.z.optional(import_v4_mini4.z.string()),
-  httpUrl: import_v4_mini4.z.optional(import_v4_mini4.z.string()),
-  env: import_v4_mini4.z.optional(import_v4_mini4.z.record(import_v4_mini4.z.string(), import_v4_mini4.z.string())),
-  disabled: import_v4_mini4.z.optional(import_v4_mini4.z.boolean()),
-  networkTimeout: import_v4_mini4.z.optional(import_v4_mini4.z.number()),
-  timeout: import_v4_mini4.z.optional(import_v4_mini4.z.number()),
-  trust: import_v4_mini4.z.optional(import_v4_mini4.z.boolean()),
-  cwd: import_v4_mini4.z.optional(import_v4_mini4.z.string()),
-  transport: import_v4_mini4.z.optional(McpTransportTypeSchema),
-  type: import_v4_mini4.z.optional(import_v4_mini4.z.enum(["sse", "streamable-http"])),
-  alwaysAllow: import_v4_mini4.z.optional(import_v4_mini4.z.array(import_v4_mini4.z.string())),
-  tools: import_v4_mini4.z.optional(import_v4_mini4.z.array(import_v4_mini4.z.string()))
+var McpTransportTypeSchema = import_mini4.z.enum(["stdio", "sse", "http"]);
+var McpServerBaseSchema = import_mini4.z.object({
+  command: import_mini4.z.optional(import_mini4.z.string()),
+  args: import_mini4.z.optional(import_mini4.z.array(import_mini4.z.string())),
+  url: import_mini4.z.optional(import_mini4.z.string()),
+  httpUrl: import_mini4.z.optional(import_mini4.z.string()),
+  env: import_mini4.z.optional(import_mini4.z.record(import_mini4.z.string(), import_mini4.z.string())),
+  disabled: import_mini4.z.optional(import_mini4.z.boolean()),
+  networkTimeout: import_mini4.z.optional(import_mini4.z.number()),
+  timeout: import_mini4.z.optional(import_mini4.z.number()),
+  trust: import_mini4.z.optional(import_mini4.z.boolean()),
+  cwd: import_mini4.z.optional(import_mini4.z.string()),
+  transport: import_mini4.z.optional(McpTransportTypeSchema),
+  type: import_mini4.z.optional(import_mini4.z.enum(["sse", "streamable-http"])),
+  alwaysAllow: import_mini4.z.optional(import_mini4.z.array(import_mini4.z.string())),
+  tools: import_mini4.z.optional(import_mini4.z.array(import_mini4.z.string())),
+  kiroAutoApprove: import_mini4.z.optional(import_mini4.z.array(import_mini4.z.string())),
+  kiroAutoBlock: import_mini4.z.optional(import_mini4.z.array(import_mini4.z.string()))
 });
-var RulesyncMcpServerSchema = import_v4_mini4.z.extend(McpServerBaseSchema, {
-  targets: import_v4_mini4.z.optional(RulesyncTargetsSchema)
+var RulesyncMcpServerSchema = import_mini4.z.extend(McpServerBaseSchema, {
+  targets: import_mini4.z.optional(RulesyncTargetsSchema)
 });
-var McpConfigSchema = import_v4_mini4.z.object({
-  mcpServers: import_v4_mini4.z.record(import_v4_mini4.z.string(), McpServerBaseSchema)
+var McpConfigSchema = import_mini4.z.object({
+  mcpServers: import_mini4.z.record(import_mini4.z.string(), McpServerBaseSchema)
 });
-var RulesyncMcpConfigSchema = import_v4_mini4.z.object({
-  mcpServers: import_v4_mini4.z.record(import_v4_mini4.z.string(), RulesyncMcpServerSchema)
+var RulesyncMcpConfigSchema = import_mini4.z.object({
+  mcpServers: import_mini4.z.record(import_mini4.z.string(), RulesyncMcpServerSchema)
 });
 
 // src/types/rules.ts
-var import_v4_mini5 = require("zod/v4-mini");
+var import_mini5 = require("zod/mini");
 init_tool_targets();
-var RuleFrontmatterSchema = import_v4_mini5.z.object({
-  root: import_v4_mini5.z.boolean(),
+var RuleFrontmatterSchema = import_mini5.z.object({
+  root: import_mini5.z.boolean(),
   targets: RulesyncTargetsSchema,
-  description: import_v4_mini5.z.string(),
-  globs: import_v4_mini5.z.array(import_v4_mini5.z.string()),
-  cursorRuleType: import_v4_mini5.z.optional(import_v4_mini5.z.enum(["always", "manual", "specificFiles", "intelligently"]))
+  description: import_mini5.z.string(),
+  globs: import_mini5.z.array(import_mini5.z.string()),
+  cursorRuleType: import_mini5.z.optional(import_mini5.z.enum(["always", "manual", "specificFiles", "intelligently"]))
 });
-var ParsedRuleSchema = import_v4_mini5.z.object({
+var ParsedRuleSchema = import_mini5.z.object({
   frontmatter: RuleFrontmatterSchema,
-  content: import_v4_mini5.z.string(),
-  filename: import_v4_mini5.z.string(),
-  filepath: import_v4_mini5.z.string()
+  content: import_mini5.z.string(),
+  filename: import_mini5.z.string(),
+  filepath: import_mini5.z.string()
 });
-var GeneratedOutputSchema = import_v4_mini5.z.object({
+var GeneratedOutputSchema = import_mini5.z.object({
   tool: ToolTargetSchema,
-  filepath: import_v4_mini5.z.string(),
-  content: import_v4_mini5.z.string()
+  filepath: import_mini5.z.string(),
+  content: import_mini5.z.string()
 });
-var GenerateOptionsSchema = import_v4_mini5.z.object({
-  targetTools: import_v4_mini5.z.optional(ToolTargetsSchema),
-  outputDir: import_v4_mini5.z.optional(import_v4_mini5.z.string()),
-  watch: import_v4_mini5.z.optional(import_v4_mini5.z.boolean())
+var GenerateOptionsSchema = import_mini5.z.object({
+  targetTools: import_mini5.z.optional(ToolTargetsSchema),
+  outputDir: import_mini5.z.optional(import_mini5.z.string()),
+  watch: import_mini5.z.optional(import_mini5.z.boolean())
 });
 
 // src/types/index.ts
@@ -1057,7 +1242,8 @@ init_tool_targets();
 // src/core/parser.ts
 async function parseRulesFromDirectory(aiRulesDir) {
   const ignorePatterns = await loadIgnorePatterns();
-  const ruleFiles = await findFiles(aiRulesDir, ".md", ignorePatterns.patterns);
+  const allRuleFiles = await findFiles(aiRulesDir, ".md");
+  const ruleFiles = filterIgnoredFiles(allRuleFiles, ignorePatterns.patterns);
   const rules = [];
   const errors = [];
   if (ignorePatterns.patterns.length > 0) {
@@ -1090,7 +1276,7 @@ async function parseRuleFile(filepath) {
   const parsed = (0, import_gray_matter.default)(content);
   try {
     const frontmatter = RuleFrontmatterSchema.parse(parsed.data);
-    const filename = (0, import_node_path10.basename)(filepath, ".md");
+    const filename = (0, import_node_path11.basename)(filepath, ".md");
     return {
       frontmatter,
       content: parsed.content,
@@ -1163,6 +1349,7 @@ init_cline();
 init_copilot();
 init_cursor();
 init_geminicli();
+init_kiro();
 init_roo();
 
 // src/core/mcp-parser.ts
@@ -1226,6 +1413,11 @@ async function generateMcpConfigs(projectRoot, baseDir) {
       path: path3.join(targetRoot, ".gemini", "settings.json"),
       generate: () => generateGeminiCliMcp(config)
     },
+    {
+      tool: "kiro-project",
+      path: path3.join(targetRoot, ".kiro", "mcp.json"),
+      generate: () => generateKiroMcp(config)
+    },
     {
       tool: "roo-project",
       path: path3.join(targetRoot, ".roo", "mcp.json"),
@@ -1236,7 +1428,7 @@ async function generateMcpConfigs(projectRoot, baseDir) {
     try {
       const content = generator.generate();
       const parsed = JSON.parse(content);
-      if (generator.tool.includes("claude") || generator.tool.includes("cline") || generator.tool.includes("cursor") || generator.tool.includes("gemini") || generator.tool.includes("roo")) {
+      if (generator.tool.includes("claude") || generator.tool.includes("cline") || generator.tool.includes("cursor") || generator.tool.includes("gemini") || generator.tool.includes("kiro") || generator.tool.includes("roo")) {
         if (!parsed.mcpServers || Object.keys(parsed.mcpServers).length === 0) {
           results.push({
             tool: generator.tool,
@@ -1322,6 +1514,9 @@ async function generateCommand(options = {}) {
           case "geminicli":
             deleteTasks.push(removeDirectory(config.outputPaths.geminicli));
             break;
+          case "kiro":
+            deleteTasks.push(removeDirectory(config.outputPaths.kiro));
+            break;
         }
       }
       await Promise.all(deleteTasks);
@@ -1386,9 +1581,9 @@ Generating configurations for base directory: ${baseDir}`);
 
 // src/cli/commands/gitignore.ts
 var import_node_fs = require("fs");
-var import_node_path11 = require("path");
+var import_node_path12 = require("path");
 var gitignoreCommand = async () => {
-  const gitignorePath = (0, import_node_path11.join)(process.cwd(), ".gitignore");
+  const gitignorePath = (0, import_node_path12.join)(process.cwd(), ".gitignore");
   const rulesFilesToIgnore = [
     "# Generated by rulesync - AI tool configuration files",
     "**/.github/copilot-instructions.md",
@@ -1405,6 +1600,8 @@ var gitignoreCommand = async () => {
     "**/GEMINI.md",
     "**/.gemini/memories/",
     "**/.aiexclude",
+    "**/.aiignore",
+    "**/.kiro/steering/",
     "**/.mcp.json",
     "!.rulesync/.mcp.json",
     "**/.cursor/mcp.json",
@@ -1442,17 +1639,17 @@ ${linesToAdd.join("\n")}
 };
 
 // src/core/importer.ts
-var import_node_path18 = require("path");
+var import_node_path19 = require("path");
 var import_gray_matter4 = __toESM(require("gray-matter"), 1);
 
 // src/parsers/claudecode.ts
-var import_node_path12 = require("path");
+var import_node_path13 = require("path");
 async function parseClaudeConfiguration(baseDir = process.cwd()) {
   const errors = [];
   const rules = [];
   let ignorePatterns;
   let mcpServers;
-  const claudeFilePath = (0, import_node_path12.join)(baseDir, "CLAUDE.md");
+  const claudeFilePath = (0, import_node_path13.join)(baseDir, "CLAUDE.md");
   if (!await fileExists(claudeFilePath)) {
     errors.push("CLAUDE.md file not found");
     return { rules, errors };
@@ -1463,12 +1660,12 @@ async function parseClaudeConfiguration(baseDir = process.cwd()) {
     if (mainRule) {
       rules.push(mainRule);
     }
-    const memoryDir = (0, import_node_path12.join)(baseDir, ".claude", "memories");
+    const memoryDir = (0, import_node_path13.join)(baseDir, ".claude", "memories");
     if (await fileExists(memoryDir)) {
       const memoryRules = await parseClaudeMemoryFiles(memoryDir);
       rules.push(...memoryRules);
     }
-    const settingsPath = (0, import_node_path12.join)(baseDir, ".claude", "settings.json");
+    const settingsPath = (0, import_node_path13.join)(baseDir, ".claude", "settings.json");
     if (await fileExists(settingsPath)) {
       const settingsResult = await parseClaudeSettings(settingsPath);
       if (settingsResult.ignorePatterns) {
@@ -1525,10 +1722,10 @@ async function parseClaudeMemoryFiles(memoryDir) {
     const files = await readdir2(memoryDir);
     for (const file of files) {
       if (file.endsWith(".md")) {
-        const filePath = (0, import_node_path12.join)(memoryDir, file);
+        const filePath = (0, import_node_path13.join)(memoryDir, file);
         const content = await readFileContent(filePath);
         if (content.trim()) {
-          const filename = (0, import_node_path12.basename)(file, ".md");
+          const filename = (0, import_node_path13.basename)(file, ".md");
           const frontmatter = {
             root: false,
             targets: ["claudecode"],
@@ -1588,11 +1785,11 @@ async function parseClaudeSettings(settingsPath) {
 }
 
 // src/parsers/cline.ts
-var import_node_path13 = require("path");
+var import_node_path14 = require("path");
 async function parseClineConfiguration(baseDir = process.cwd()) {
   const errors = [];
   const rules = [];
-  const clineFilePath = (0, import_node_path13.join)(baseDir, ".cline", "instructions.md");
+  const clineFilePath = (0, import_node_path14.join)(baseDir, ".cline", "instructions.md");
   if (await fileExists(clineFilePath)) {
     try {
       const content = await readFileContent(clineFilePath);
@@ -1615,14 +1812,14 @@ async function parseClineConfiguration(baseDir = process.cwd()) {
       errors.push(`Failed to parse .cline/instructions.md: ${errorMessage}`);
     }
   }
-  const clinerulesDirPath = (0, import_node_path13.join)(baseDir, ".clinerules");
+  const clinerulesDirPath = (0, import_node_path14.join)(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 = (0, import_node_path13.join)(clinerulesDirPath, file);
+          const filePath = (0, import_node_path14.join)(clinerulesDirPath, file);
           try {
             const content = await readFileContent(filePath);
             if (content.trim()) {
@@ -1658,12 +1855,12 @@ async function parseClineConfiguration(baseDir = process.cwd()) {
 }
 
 // src/parsers/copilot.ts
-var import_node_path14 = require("path");
+var import_node_path15 = require("path");
 var import_gray_matter2 = __toESM(require("gray-matter"), 1);
 async function parseCopilotConfiguration(baseDir = process.cwd()) {
   const errors = [];
   const rules = [];
-  const copilotFilePath = (0, import_node_path14.join)(baseDir, ".github", "copilot-instructions.md");
+  const copilotFilePath = (0, import_node_path15.join)(baseDir, ".github", "copilot-instructions.md");
   if (await fileExists(copilotFilePath)) {
     try {
       const rawContent = await readFileContent(copilotFilePath);
@@ -1688,19 +1885,19 @@ async function parseCopilotConfiguration(baseDir = process.cwd()) {
       errors.push(`Failed to parse copilot-instructions.md: ${errorMessage}`);
     }
   }
-  const instructionsDir = (0, import_node_path14.join)(baseDir, ".github", "instructions");
+  const instructionsDir = (0, import_node_path15.join)(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 = (0, import_node_path14.join)(instructionsDir, file);
+          const filePath = (0, import_node_path15.join)(instructionsDir, file);
           const rawContent = await readFileContent(filePath);
           const parsed = (0, import_gray_matter2.default)(rawContent);
           const content = parsed.content.trim();
           if (content) {
-            const filename = (0, import_node_path14.basename)(file, ".instructions.md");
+            const filename = (0, import_node_path15.basename)(file, ".instructions.md");
             const frontmatter = {
               root: false,
               targets: ["copilot"],
@@ -1730,10 +1927,10 @@ async function parseCopilotConfiguration(baseDir = process.cwd()) {
 }
 
 // src/parsers/cursor.ts
-var import_node_path15 = require("path");
+var import_node_path16 = require("path");
 var import_gray_matter3 = __toESM(require("gray-matter"), 1);
 var import_js_yaml = require("js-yaml");
-var import_v4_mini6 = require("zod/v4-mini");
+var import_mini6 = require("zod/mini");
 var customMatterOptions = {
   engines: {
     yaml: {
@@ -1761,7 +1958,7 @@ var customMatterOptions = {
   }
 };
 function convertCursorMdcFrontmatter(cursorFrontmatter, _filename) {
-  const FrontmatterSchema = import_v4_mini6.z.record(import_v4_mini6.z.string(), import_v4_mini6.z.unknown());
+  const FrontmatterSchema = import_mini6.z.record(import_mini6.z.string(), import_mini6.z.unknown());
   const parseResult = FrontmatterSchema.safeParse(cursorFrontmatter);
   if (!parseResult.success) {
     return {
@@ -1855,7 +2052,7 @@ async function parseCursorConfiguration(baseDir = process.cwd()) {
   const rules = [];
   let ignorePatterns;
   let mcpServers;
-  const cursorFilePath = (0, import_node_path15.join)(baseDir, ".cursorrules");
+  const cursorFilePath = (0, import_node_path16.join)(baseDir, ".cursorrules");
   if (await fileExists(cursorFilePath)) {
     try {
       const rawContent = await readFileContent(cursorFilePath);
@@ -1876,20 +2073,20 @@ async function parseCursorConfiguration(baseDir = process.cwd()) {
       errors.push(`Failed to parse .cursorrules file: ${errorMessage}`);
     }
   }
-  const cursorRulesDir = (0, import_node_path15.join)(baseDir, ".cursor", "rules");
+  const cursorRulesDir = (0, import_node_path16.join)(baseDir, ".cursor", "rules");
   if (await fileExists(cursorRulesDir)) {
     try {
       const { readdir: readdir2 } = await import("fs/promises");
       const files = await readdir2(cursorRulesDir);
       for (const file of files) {
         if (file.endsWith(".mdc")) {
-          const filePath = (0, import_node_path15.join)(cursorRulesDir, file);
+          const filePath = (0, import_node_path16.join)(cursorRulesDir, file);
           try {
             const rawContent = await readFileContent(filePath);
             const parsed = (0, import_gray_matter3.default)(rawContent, customMatterOptions);
             const content = parsed.content.trim();
             if (content) {
-              const filename = (0, import_node_path15.basename)(file, ".mdc");
+              const filename = (0, import_node_path16.basename)(file, ".mdc");
               const frontmatter = convertCursorMdcFrontmatter(parsed.data, filename);
               rules.push({
                 frontmatter,
@@ -1912,7 +2109,7 @@ async function parseCursorConfiguration(baseDir = process.cwd()) {
   if (rules.length === 0) {
     errors.push("No Cursor configuration files found (.cursorrules or .cursor/rules/*.mdc)");
   }
-  const cursorIgnorePath = (0, import_node_path15.join)(baseDir, ".cursorignore");
+  const cursorIgnorePath = (0, import_node_path16.join)(baseDir, ".cursorignore");
   if (await fileExists(cursorIgnorePath)) {
     try {
       const content = await readFileContent(cursorIgnorePath);
@@ -1925,7 +2122,7 @@ async function parseCursorConfiguration(baseDir = process.cwd()) {
       errors.push(`Failed to parse .cursorignore: ${errorMessage}`);
     }
   }
-  const cursorMcpPath = (0, import_node_path15.join)(baseDir, ".cursor", "mcp.json");
+  const cursorMcpPath = (0, import_node_path16.join)(baseDir, ".cursor", "mcp.json");
   if (await fileExists(cursorMcpPath)) {
     try {
       const content = await readFileContent(cursorMcpPath);
@@ -1948,13 +2145,13 @@ async function parseCursorConfiguration(baseDir = process.cwd()) {
 }
 
 // src/parsers/geminicli.ts
-var import_node_path16 = require("path");
+var import_node_path17 = require("path");
 async function parseGeminiConfiguration(baseDir = process.cwd()) {
   const errors = [];
   const rules = [];
   let ignorePatterns;
   let mcpServers;
-  const geminiFilePath = (0, import_node_path16.join)(baseDir, "GEMINI.md");
+  const geminiFilePath = (0, import_node_path17.join)(baseDir, "GEMINI.md");
   if (!await fileExists(geminiFilePath)) {
     errors.push("GEMINI.md file not found");
     return { rules, errors };
@@ -1965,12 +2162,12 @@ async function parseGeminiConfiguration(baseDir = process.cwd()) {
     if (mainRule) {
       rules.push(mainRule);
     }
-    const memoryDir = (0, import_node_path16.join)(baseDir, ".gemini", "memories");
+    const memoryDir = (0, import_node_path17.join)(baseDir, ".gemini", "memories");
     if (await fileExists(memoryDir)) {
       const memoryRules = await parseGeminiMemoryFiles(memoryDir);
       rules.push(...memoryRules);
     }
-    const settingsPath = (0, import_node_path16.join)(baseDir, ".gemini", "settings.json");
+    const settingsPath = (0, import_node_path17.join)(baseDir, ".gemini", "settings.json");
     if (await fileExists(settingsPath)) {
       const settingsResult = await parseGeminiSettings(settingsPath);
       if (settingsResult.ignorePatterns) {
@@ -1981,7 +2178,7 @@ async function parseGeminiConfiguration(baseDir = process.cwd()) {
       }
       errors.push(...settingsResult.errors);
     }
-    const aiexcludePath = (0, import_node_path16.join)(baseDir, ".aiexclude");
+    const aiexcludePath = (0, import_node_path17.join)(baseDir, ".aiexclude");
     if (await fileExists(aiexcludePath)) {
       const aiexcludePatterns = await parseAiexclude(aiexcludePath);
       if (aiexcludePatterns.length > 0) {
@@ -2034,10 +2231,10 @@ async function parseGeminiMemoryFiles(memoryDir) {
     const files = await readdir2(memoryDir);
     for (const file of files) {
       if (file.endsWith(".md")) {
-        const filePath = (0, import_node_path16.join)(memoryDir, file);
+        const filePath = (0, import_node_path17.join)(memoryDir, file);
         const content = await readFileContent(filePath);
         if (content.trim()) {
-          const filename = (0, import_node_path16.basename)(file, ".md");
+          const filename = (0, import_node_path17.basename)(file, ".md");
           const frontmatter = {
             root: false,
             targets: ["geminicli"],
@@ -2087,11 +2284,11 @@ async function parseAiexclude(aiexcludePath) {
 }
 
 // src/parsers/roo.ts
-var import_node_path17 = require("path");
+var import_node_path18 = require("path");
 async function parseRooConfiguration(baseDir = process.cwd()) {
   const errors = [];
   const rules = [];
-  const rooFilePath = (0, import_node_path17.join)(baseDir, ".roo", "instructions.md");
+  const rooFilePath = (0, import_node_path18.join)(baseDir, ".roo", "instructions.md");
   if (await fileExists(rooFilePath)) {
     try {
       const content = await readFileContent(rooFilePath);
@@ -2114,14 +2311,14 @@ async function parseRooConfiguration(baseDir = process.cwd()) {
       errors.push(`Failed to parse .roo/instructions.md: ${errorMessage}`);
     }
   }
-  const rooRulesDir = (0, import_node_path17.join)(baseDir, ".roo", "rules");
+  const rooRulesDir = (0, import_node_path18.join)(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 = (0, import_node_path17.join)(rooRulesDir, file);
+          const filePath = (0, import_node_path18.join)(rooRulesDir, file);
           try {
             const content = await readFileContent(filePath);
             if (content.trim()) {
@@ -2222,7 +2419,7 @@ async function importConfiguration(options) {
   if (rules.length === 0 && !ignorePatterns && !mcpServers) {
     return { success: false, rulesCreated: 0, errors };
   }
-  const rulesDirPath = (0, import_node_path18.join)(baseDir, rulesDir);
+  const rulesDirPath = (0, import_node_path19.join)(baseDir, rulesDir);
   try {
     const { mkdir: mkdir3 } = await import("fs/promises");
     await mkdir3(rulesDirPath, { recursive: true });
@@ -2236,7 +2433,7 @@ async function importConfiguration(options) {
     try {
       const baseFilename = `${tool}__${rule.filename}`;
       const filename = await generateUniqueFilename(rulesDirPath, baseFilename);
-      const filePath = (0, import_node_path18.join)(rulesDirPath, `${filename}.md`);
+      const filePath = (0, import_node_path19.join)(rulesDirPath, `${filename}.md`);
       const content = generateRuleFileContent(rule);
       await writeFileContent(filePath, content);
       rulesCreated++;
@@ -2251,7 +2448,7 @@ async function importConfiguration(options) {
   let ignoreFileCreated = false;
   if (ignorePatterns && ignorePatterns.length > 0) {
     try {
-      const rulesyncignorePath = (0, import_node_path18.join)(baseDir, ".rulesyncignore");
+      const rulesyncignorePath = (0, import_node_path19.join)(baseDir, ".rulesyncignore");
       const ignoreContent = `${ignorePatterns.join("\n")}
 `;
       await writeFileContent(rulesyncignorePath, ignoreContent);
@@ -2267,7 +2464,7 @@ async function importConfiguration(options) {
   let mcpFileCreated = false;
   if (mcpServers && Object.keys(mcpServers).length > 0) {
     try {
-      const mcpPath = (0, import_node_path18.join)(baseDir, rulesDir, ".mcp.json");
+      const mcpPath = (0, import_node_path19.join)(baseDir, rulesDir, ".mcp.json");
       const mcpContent = `${JSON.stringify({ mcpServers }, null, 2)}
 `;
       await writeFileContent(mcpPath, mcpContent);
@@ -2281,7 +2478,7 @@ async function importConfiguration(options) {
     }
   }
   return {
-    success: rulesCreated > 0 || ignoreFileCreated || mcpFileCreated,
+    success: errors.length === 0 && (rulesCreated > 0 || ignoreFileCreated || mcpFileCreated),
     rulesCreated,
     errors,
     ignoreFileCreated,
@@ -2295,7 +2492,7 @@ function generateRuleFileContent(rule) {
 async function generateUniqueFilename(rulesDir, baseFilename) {
   let filename = baseFilename;
   let counter = 1;
-  while (await fileExists((0, import_node_path18.join)(rulesDir, `${filename}.md`))) {
+  while (await fileExists((0, import_node_path19.join)(rulesDir, `${filename}.md`))) {
     filename = `${baseFilename}-${counter}`;
     counter++;
   }
@@ -2360,7 +2557,7 @@ async function importCommand(options = {}) {
 }
 
 // src/cli/commands/init.ts
-var import_node_path19 = require("path");
+var import_node_path20 = require("path");
 async function initCommand() {
   const aiRulesDir = ".rulesync";
   console.log("Initializing rulesync...");
@@ -2407,7 +2604,7 @@ globs: ["**/*"]
 - Follow single responsibility principle
 `
   };
-  const filepath = (0, import_node_path19.join)(aiRulesDir, sampleFile.filename);
+  const filepath = (0, import_node_path20.join)(aiRulesDir, sampleFile.filename);
   if (!await fileExists(filepath)) {
     await writeFileContent(filepath, sampleFile.content);
     console.log(`Created ${filepath}`);
@@ -2551,12 +2748,12 @@ async function watchCommand() {
 
 // src/cli/index.ts
 var program = new import_commander.Command();
-program.name("rulesync").description("Unified AI rules management CLI tool").version("0.45.0");
+program.name("rulesync").description("Unified AI rules management CLI tool").version("0.47.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);
 program.command("import").description("Import configurations from AI tools to rulesync format").option("--claudecode", "Import from Claude Code (CLAUDE.md)").option("--cursor", "Import from Cursor (.cursorrules)").option("--copilot", "Import from GitHub Copilot (.github/copilot-instructions.md)").option("--cline", "Import from Cline (.cline/instructions.md)").option("--roo", "Import from Roo Code (.roo/instructions.md)").option("--geminicli", "Import from Gemini CLI (GEMINI.md)").option("-v, --verbose", "Verbose output").action(importCommand);
-program.command("generate").description("Generate configuration files for AI tools").option("--copilot", "Generate only for GitHub Copilot").option("--cursor", "Generate only for Cursor").option("--cline", "Generate only for Cline").option("--claudecode", "Generate only for Claude Code").option("--roo", "Generate only for Roo Code").option("--geminicli", "Generate only for Gemini CLI").option("--delete", "Delete all existing files in output directories before generating").option(
+program.command("generate").description("Generate configuration files for AI tools").option("--copilot", "Generate only for GitHub Copilot").option("--cursor", "Generate only for Cursor").option("--cline", "Generate only for Cline").option("--claudecode", "Generate only for Claude Code").option("--roo", "Generate only for Roo Code").option("--geminicli", "Generate only for Gemini CLI").option("--kiro", "Generate only for Kiro IDE").option("--delete", "Delete all existing files in output directories before generating").option(
   "-b, --base-dir <paths>",
   "Base directories to generate files (comma-separated for multiple paths)"
 ).option("-v, --verbose", "Verbose output").action(async (options) => {
@@ -2567,6 +2764,7 @@ program.command("generate").description("Generate configuration files for AI too
   if (options.claudecode) tools.push("claudecode");
   if (options.roo) tools.push("roo");
   if (options.geminicli) tools.push("geminicli");
+  if (options.kiro) tools.push("kiro");
   const generateOptions = {
     verbose: options.verbose,
     delete: options.delete