rulesync 0.47.0 → 0.49.0

package/dist/index.cjs

@@ -33,6 +33,8 @@ var init_tool_targets = __esm({
     "use strict";
     import_mini = require("zod/mini");
     ToolTargetSchema = import_mini.z.enum([
+      "augmentcode",
+      "augmentcode-legacy",
       "copilot",
       "cursor",
       "cline",
@@ -71,6 +73,63 @@ var init_mcp_helpers = __esm({
   }
 });
 
+// src/generators/mcp/augmentcode.ts
+function generateAugmentcodeMcp(config) {
+  const augmentSettings = {
+    mcpServers: []
+  };
+  const shouldInclude = (server) => {
+    return shouldIncludeServer(server, "augmentcode");
+  };
+  for (const [serverName, server] of Object.entries(config.mcpServers)) {
+    if (!shouldInclude(server)) continue;
+    const augmentServer = {
+      name: serverName
+    };
+    if (server.command) {
+      augmentServer.command = server.command;
+      if (server.args) {
+        augmentServer.args = server.args;
+      }
+    } else if (server.url || server.httpUrl) {
+      const url = server.httpUrl || server.url;
+      if (url) {
+        augmentServer.url = url;
+      }
+      if (server.httpUrl || server.transport === "http") {
+        augmentServer.transport = "http";
+      } else if (server.transport === "sse") {
+        augmentServer.transport = "sse";
+      }
+      if (server.env) {
+        augmentServer.headers = server.env;
+      }
+    }
+    if (server.env && server.command) {
+      augmentServer.env = server.env;
+    }
+    if (server.timeout) {
+      augmentServer.timeout = server.timeout;
+    }
+    if (server.disabled !== void 0) {
+      augmentServer.enabled = !server.disabled;
+    }
+    if (server.networkTimeout && server.networkTimeout > 0) {
+      augmentServer.retries = Math.max(1, Math.floor(server.networkTimeout / 3e4));
+    }
+    if (augmentSettings.mcpServers) {
+      augmentSettings.mcpServers.push(augmentServer);
+    }
+  }
+  return JSON.stringify(augmentSettings, null, 2);
+}
+var init_augmentcode = __esm({
+  "src/generators/mcp/augmentcode.ts"() {
+    "use strict";
+    init_mcp_helpers();
+  }
+});
+
 // src/generators/mcp/claudecode.ts
 function generateClaudeMcp(config) {
   const claudeSettings = {
@@ -411,6 +470,8 @@ function getDefaultConfig() {
   return {
     aiRulesDir: ".rulesync",
     outputPaths: {
+      augmentcode: ".",
+      "augmentcode-legacy": ".",
       copilot: ".github/instructions",
       cursor: ".cursor/rules",
       cline: ".clinerules",
@@ -420,7 +481,16 @@ function getDefaultConfig() {
       kiro: ".kiro/steering"
     },
     watchEnabled: false,
-    defaultTargets: ["copilot", "cursor", "cline", "claudecode", "roo", "geminicli", "kiro"]
+    defaultTargets: [
+      "augmentcode",
+      "copilot",
+      "cursor",
+      "cline",
+      "claudecode",
+      "roo",
+      "geminicli",
+      "kiro"
+    ]
   };
 }
 function resolveTargets(targets, config) {
@@ -467,13 +537,219 @@ async function addCommand(filename) {
   }
 }
 
-// src/generators/ignore/kiro.ts
+// src/generators/ignore/augmentcode.ts
 var import_node_path = require("path");
+async function generateAugmentCodeIgnoreFiles(rules, config, baseDir) {
+  const outputs = [];
+  const augmentignoreContent = generateAugmentignoreContent(rules);
+  const outputPath = baseDir || process.cwd();
+  const filepath = (0, import_node_path.join)(outputPath, ".augmentignore");
+  outputs.push({
+    tool: "augmentcode",
+    filepath,
+    content: augmentignoreContent
+  });
+  return outputs;
+}
+function generateAugmentignoreContent(rules) {
+  const lines = [
+    "# Generated by rulesync - AugmentCode ignore patterns",
+    "# AugmentCode uses a two-tier approach: .gitignore first, then .augmentignore",
+    "# This file provides Augment-specific exclusions and re-inclusions",
+    ""
+  ];
+  lines.push(
+    "# Security and Secrets (critical exclusions)",
+    "# Environment files",
+    ".env*",
+    "",
+    "# Private keys and certificates",
+    "*.pem",
+    "*.key",
+    "*.p12",
+    "*.crt",
+    "*.der",
+    "",
+    "# SSH keys",
+    "id_rsa*",
+    "id_dsa*",
+    "",
+    "# AWS credentials",
+    ".aws/",
+    "aws-exports.js",
+    "",
+    "# API keys and tokens",
+    "**/apikeys/",
+    "**/*_token*",
+    "**/*_secret*",
+    ""
+  );
+  lines.push(
+    "# Build Artifacts and Dependencies",
+    "# Build outputs",
+    "dist/",
+    "build/",
+    "out/",
+    "target/",
+    "",
+    "# Dependencies",
+    "node_modules/",
+    "venv/",
+    "*.egg-info/",
+    "",
+    "# Logs",
+    "*.log",
+    "logs/",
+    "",
+    "# Temporary files",
+    "*.tmp",
+    "*.swp",
+    "*.swo",
+    "*~",
+    ""
+  );
+  lines.push(
+    "# Large Files and Media",
+    "# Binary files",
+    "*.jar",
+    "*.png",
+    "*.jpg",
+    "*.jpeg",
+    "*.gif",
+    "*.mp4",
+    "*.avi",
+    "*.zip",
+    "*.tar.gz",
+    "*.rar",
+    "",
+    "# Database files",
+    "*.sqlite",
+    "*.db",
+    "*.mdb",
+    "",
+    "# Data files",
+    "*.csv",
+    "*.tsv",
+    "*.xlsx",
+    ""
+  );
+  lines.push(
+    "# Performance Optimization",
+    "# Exclude files that are too large for effective AI processing",
+    "**/*.{mp4,avi,mov,mkv}",
+    "**/*.{zip,tar,gz,rar}",
+    "**/*.{pdf,doc,docx}",
+    "**/logs/**/*.log",
+    "",
+    "# But include small configuration files",
+    "!**/config.{json,yaml,yml}",
+    ""
+  );
+  const rulePatterns = extractIgnorePatternsFromRules(rules);
+  if (rulePatterns.length > 0) {
+    lines.push("# Project-specific patterns from rulesync rules");
+    lines.push(...rulePatterns);
+    lines.push("");
+  }
+  lines.push(
+    "# Team Collaboration",
+    "# Exclude personal IDE settings",
+    ".vscode/settings.json",
+    ".idea/workspace.xml",
+    "",
+    "# But include shared team settings",
+    "!.vscode/extensions.json",
+    "!.idea/codeStyles/",
+    "",
+    "# Exclude test fixtures with sensitive data",
+    "tests/fixtures/real-data/**",
+    "",
+    "# Re-include important documentation",
+    "!vendor/*/README.md",
+    "!third-party/*/LICENSE",
+    ""
+  );
+  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 (shouldExcludeFromAugmentCode(glob)) {
+          patterns.push(`# Exclude: ${rule.frontmatter.description}`);
+          patterns.push(glob);
+        }
+      }
+    }
+    const contentPatterns = extractAugmentCodeIgnorePatternsFromContent(rule.content);
+    patterns.push(...contentPatterns);
+  }
+  return patterns;
+}
+function shouldExcludeFromAugmentCode(glob) {
+  const excludePatterns = [
+    // Large generated files that slow indexing
+    "**/assets/generated/**",
+    "**/public/build/**",
+    // Test fixtures with potentially sensitive data
+    "**/tests/fixtures/**",
+    "**/test/fixtures/**",
+    "**/*.fixture.*",
+    // Build outputs that provide little value for AI context
+    "**/dist/**",
+    "**/build/**",
+    "**/coverage/**",
+    // Configuration that might contain sensitive data
+    "**/config/production/**",
+    "**/config/secrets/**",
+    "**/deploy/prod/**",
+    // Internal documentation
+    "**/internal-docs/**",
+    "**/proprietary/**",
+    "**/personal-notes/**",
+    "**/private/**",
+    "**/confidential/**"
+  ];
+  return excludePatterns.some((pattern) => {
+    const regex = new RegExp(pattern.replace(/\*\*/g, ".*").replace(/\*/g, "[^/]*"));
+    return regex.test(glob);
+  });
+}
+function extractAugmentCodeIgnorePatternsFromContent(content) {
+  const patterns = [];
+  const lines = content.split("\n");
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith("# AUGMENT_IGNORE:") || trimmed.startsWith("# augmentignore:")) {
+      const pattern = trimmed.replace(/^# (AUGMENT_IGNORE|augmentignore):\s*/, "").trim();
+      if (pattern) {
+        patterns.push(pattern);
+      }
+    }
+    if (trimmed.startsWith("# AUGMENT_INCLUDE:") || trimmed.startsWith("# augmentinclude:")) {
+      const pattern = trimmed.replace(/^# (AUGMENT_INCLUDE|augmentinclude):\s*/, "").trim();
+      if (pattern) {
+        patterns.push(`!${pattern}`);
+      }
+    }
+    if (trimmed.includes("large file") || trimmed.includes("binary") || trimmed.includes("media")) {
+      const matches = trimmed.match(/['"`]([^'"`]+\.(mp4|avi|zip|tar\.gz|rar|pdf|doc|xlsx))['"`]/g);
+      if (matches) {
+        patterns.push(...matches.map((m) => m.replace(/['"`]/g, "")));
+      }
+    }
+  }
+  return patterns;
+}
+
+// src/generators/ignore/kiro.ts
+var import_node_path2 = 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");
+  const filepath = (0, import_node_path2.join)(outputPath, ".aiignore");
   outputs.push({
     tool: "kiro",
     filepath,
@@ -513,7 +789,7 @@ function generateAiignoreContent(rules) {
     ".env*",
     ""
   );
-  const rulePatterns = extractIgnorePatternsFromRules(rules);
+  const rulePatterns = extractIgnorePatternsFromRules2(rules);
   if (rulePatterns.length > 0) {
     lines.push("# Project-specific exclusions from rulesync rules");
     lines.push(...rulePatterns);
@@ -521,7 +797,7 @@ function generateAiignoreContent(rules) {
   }
   return lines.join("\n");
 }
-function extractIgnorePatternsFromRules(rules) {
+function extractIgnorePatternsFromRules2(rules) {
   const patterns = [];
   for (const rule of rules) {
     if (rule.frontmatter.globs && rule.frontmatter.globs.length > 0) {
@@ -582,23 +858,19 @@ function extractIgnorePatternsFromContent(content) {
   return patterns;
 }
 
-// src/generators/rules/claudecode.ts
-var import_node_path4 = require("path");
+// src/generators/rules/augmentcode.ts
+var import_node_path6 = require("path");
 
-// src/types/claudecode.ts
-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/generators/rules/shared-helpers.ts
+var import_node_path5 = require("path");
+
+// src/utils/ignore.ts
+var import_node_path4 = require("path");
+var import_micromatch = __toESM(require("micromatch"), 1);
 
 // src/utils/file.ts
 var import_promises2 = require("fs/promises");
-var import_node_path2 = require("path");
+var import_node_path3 = require("path");
 async function ensureDir(dirPath) {
   try {
     await (0, import_promises2.stat)(dirPath);
@@ -610,7 +882,7 @@ async function readFileContent(filepath) {
   return (0, import_promises2.readFile)(filepath, "utf-8");
 }
 async function writeFileContent(filepath, content) {
-  await ensureDir((0, import_node_path2.dirname)(filepath));
+  await ensureDir((0, import_node_path3.dirname)(filepath));
   await (0, import_promises2.writeFile)(filepath, content, "utf-8");
 }
 async function fileExists(filepath) {
@@ -624,7 +896,7 @@ async function fileExists(filepath) {
 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));
+    return files.filter((file) => file.endsWith(extension)).map((file) => (0, import_node_path3.join)(dir, file));
   } catch {
     return [];
   }
@@ -664,14 +936,12 @@ async function removeClaudeGeneratedFiles() {
 }
 
 // src/utils/ignore.ts
-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_path3.join)(baseDir, ".rulesyncignore");
+  const ignorePath = (0, import_node_path4.join)(baseDir, ".rulesyncignore");
   if (!await fileExists(ignorePath)) {
     cachedIgnorePatterns = { patterns: [] };
     return cachedIgnorePatterns;
@@ -714,29 +984,167 @@ function filterIgnoredFiles(files, ignorePatterns) {
   return files.filter((file) => !isFileIgnored(file, ignorePatterns));
 }
 
+// src/generators/rules/shared-helpers.ts
+function resolveOutputDir(config, tool, baseDir) {
+  return baseDir ? (0, import_node_path5.join)(baseDir, config.outputPaths[tool]) : config.outputPaths[tool];
+}
+function createOutputsArray() {
+  return [];
+}
+function addOutput(outputs, tool, config, baseDir, relativePath, content) {
+  const outputDir = resolveOutputDir(config, tool, baseDir);
+  outputs.push({
+    tool,
+    filepath: (0, import_node_path5.join)(outputDir, relativePath),
+    content
+  });
+}
+async function generateRulesConfig(rules, config, generatorConfig, baseDir) {
+  const outputs = [];
+  for (const rule of rules) {
+    const content = generatorConfig.generateContent(rule);
+    const outputDir = resolveOutputDir(config, generatorConfig.tool, baseDir);
+    const filepath = generatorConfig.pathResolver ? generatorConfig.pathResolver(rule, outputDir) : (0, import_node_path5.join)(outputDir, `${rule.filename}${generatorConfig.fileExtension}`);
+    outputs.push({
+      tool: generatorConfig.tool,
+      filepath,
+      content
+    });
+  }
+  const ignorePatterns = await loadIgnorePatterns(baseDir);
+  if (ignorePatterns.patterns.length > 0) {
+    const ignorePath = baseDir ? (0, import_node_path5.join)(baseDir, generatorConfig.ignoreFileName) : generatorConfig.ignoreFileName;
+    const ignoreContent = generateIgnoreFile(ignorePatterns.patterns, generatorConfig.tool);
+    outputs.push({
+      tool: generatorConfig.tool,
+      filepath: ignorePath,
+      content: ignoreContent
+    });
+  }
+  return outputs;
+}
+function generateIgnoreFile(patterns, tool) {
+  const lines = [
+    "# Generated by rulesync from .rulesyncignore",
+    "# This file is automatically generated. Do not edit manually."
+  ];
+  if (tool === "copilot") {
+    lines.push("# Note: .copilotignore is not officially supported by GitHub Copilot.");
+    lines.push("# This file is for use with community tools like copilotignore-vscode extension.");
+  }
+  lines.push("");
+  lines.push(...patterns);
+  return lines.join("\n");
+}
+async function generateComplexRulesConfig(rules, config, generatorConfig, baseDir) {
+  const unifiedConfig = {
+    tool: generatorConfig.tool,
+    fileExtension: generatorConfig.fileExtension,
+    ignoreFileName: generatorConfig.ignoreFileName,
+    generateContent: generatorConfig.generateContent,
+    pathResolver: generatorConfig.getOutputPath
+  };
+  return generateRulesConfig(rules, config, unifiedConfig, baseDir);
+}
+
+// src/generators/rules/augmentcode.ts
+async function generateAugmentcodeConfig(rules, config, baseDir) {
+  const outputs = createOutputsArray();
+  rules.forEach((rule) => {
+    addOutput(
+      outputs,
+      "augmentcode",
+      config,
+      baseDir,
+      (0, import_node_path6.join)(".augment", "rules", `${rule.filename}.md`),
+      generateRuleFile(rule)
+    );
+  });
+  return outputs;
+}
+function generateRuleFile(rule) {
+  const lines = [];
+  lines.push("---");
+  let ruleType = "manual";
+  let description = rule.frontmatter.description;
+  if (rule.filename.endsWith("-always")) {
+    ruleType = "always";
+    description = "";
+  } else if (rule.filename.endsWith("-auto")) {
+    ruleType = "auto";
+  }
+  lines.push(`type: ${ruleType}`);
+  lines.push(`description: "${description}"`);
+  if (rule.frontmatter.tags && Array.isArray(rule.frontmatter.tags) && rule.frontmatter.tags.length > 0) {
+    lines.push(`tags: [${rule.frontmatter.tags.map((tag) => `"${tag}"`).join(", ")}]`);
+  }
+  lines.push("---");
+  lines.push("");
+  lines.push(rule.content.trim());
+  return lines.join("\n");
+}
+
+// src/generators/rules/augmentcode-legacy.ts
+async function generateAugmentcodeLegacyConfig(rules, config, baseDir) {
+  const outputs = createOutputsArray();
+  if (rules.length > 0) {
+    addOutput(
+      outputs,
+      "augmentcode-legacy",
+      config,
+      baseDir,
+      ".augment-guidelines",
+      generateLegacyGuidelinesFile(rules)
+    );
+  }
+  return outputs;
+}
+function generateLegacyGuidelinesFile(allRules) {
+  const lines = [];
+  for (const rule of allRules) {
+    lines.push(rule.content.trim());
+    lines.push("");
+  }
+  return lines.join("\n").trim();
+}
+
+// src/generators/rules/claudecode.ts
+var import_node_path7 = require("path");
+
+// src/types/claudecode.ts
+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/generators/rules/claudecode.ts
 async function generateClaudecodeConfig(rules, config, baseDir) {
   const outputs = [];
   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 ? (0, import_node_path4.join)(baseDir, config.outputPaths.claudecode) : config.outputPaths.claudecode;
+  const claudeOutputDir = baseDir ? (0, import_node_path7.join)(baseDir, config.outputPaths.claudecode) : config.outputPaths.claudecode;
   outputs.push({
     tool: "claudecode",
-    filepath: (0, import_node_path4.join)(claudeOutputDir, "CLAUDE.md"),
+    filepath: (0, import_node_path7.join)(claudeOutputDir, "CLAUDE.md"),
     content: claudeMdContent
   });
   for (const rule of detailRules) {
     const memoryContent = generateMemoryFile(rule);
     outputs.push({
       tool: "claudecode",
-      filepath: (0, import_node_path4.join)(claudeOutputDir, ".claude", "memories", `${rule.filename}.md`),
+      filepath: (0, import_node_path7.join)(claudeOutputDir, ".claude", "memories", `${rule.filename}.md`),
       content: memoryContent
     });
   }
   const ignorePatterns = await loadIgnorePatterns(baseDir);
   if (ignorePatterns.patterns.length > 0) {
-    const settingsPath = baseDir ? (0, import_node_path4.join)(baseDir, ".claude", "settings.json") : (0, import_node_path4.join)(".claude", "settings.json");
+    const settingsPath = baseDir ? (0, import_node_path7.join)(baseDir, ".claude", "settings.json") : (0, import_node_path7.join)(".claude", "settings.json");
     await updateClaudeSettings(settingsPath, ignorePatterns.patterns);
   }
   return outputs;
@@ -800,70 +1208,38 @@ async function updateClaudeSettings(settingsPath, ignorePatterns) {
 }
 
 // src/generators/rules/cline.ts
-var import_node_path5 = require("path");
 async function generateClineConfig(rules, config, baseDir) {
-  const outputs = [];
-  for (const rule of rules) {
-    const content = generateClineMarkdown(rule);
-    const outputDir = baseDir ? (0, import_node_path5.join)(baseDir, config.outputPaths.cline) : config.outputPaths.cline;
-    const filepath = (0, import_node_path5.join)(outputDir, `${rule.filename}.md`);
-    outputs.push({
-      tool: "cline",
-      filepath,
-      content
-    });
-  }
-  const ignorePatterns = await loadIgnorePatterns(baseDir);
-  if (ignorePatterns.patterns.length > 0) {
-    const clineIgnorePath = baseDir ? (0, import_node_path5.join)(baseDir, ".clineignore") : ".clineignore";
-    const clineIgnoreContent = generateClineIgnore(ignorePatterns.patterns);
-    outputs.push({
+  return generateRulesConfig(
+    rules,
+    config,
+    {
       tool: "cline",
-      filepath: clineIgnorePath,
-      content: clineIgnoreContent
-    });
-  }
-  return outputs;
-}
-function generateClineMarkdown(rule) {
-  return rule.content.trim();
-}
-function generateClineIgnore(patterns) {
-  const lines = [
-    "# Generated by rulesync from .rulesyncignore",
-    "# This file is automatically generated. Do not edit manually.",
-    "",
-    ...patterns
-  ];
-  return lines.join("\n");
+      fileExtension: ".md",
+      ignoreFileName: ".clineignore",
+      generateContent: (rule) => rule.content.trim()
+    },
+    baseDir
+  );
 }
 
 // src/generators/rules/copilot.ts
-var import_node_path6 = require("path");
+var import_node_path8 = require("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 ? (0, import_node_path6.join)(baseDir, config.outputPaths.copilot) : config.outputPaths.copilot;
-    const filepath = (0, import_node_path6.join)(outputDir, `${baseFilename}.instructions.md`);
-    outputs.push({
-      tool: "copilot",
-      filepath,
-      content
-    });
-  }
-  const ignorePatterns = await loadIgnorePatterns(baseDir);
-  if (ignorePatterns.patterns.length > 0) {
-    const copilotIgnorePath = baseDir ? (0, import_node_path6.join)(baseDir, ".copilotignore") : ".copilotignore";
-    const copilotIgnoreContent = generateCopilotIgnore(ignorePatterns.patterns);
-    outputs.push({
+  return generateComplexRulesConfig(
+    rules,
+    config,
+    {
       tool: "copilot",
-      filepath: copilotIgnorePath,
-      content: copilotIgnoreContent
-    });
-  }
-  return outputs;
+      fileExtension: ".instructions.md",
+      ignoreFileName: ".copilotignore",
+      generateContent: generateCopilotMarkdown,
+      getOutputPath: (rule, outputDir) => {
+        const baseFilename = rule.filename.replace(/\.md$/, "");
+        return (0, import_node_path8.join)(outputDir, `${baseFilename}.instructions.md`);
+      }
+    },
+    baseDir
+  );
 }
 function generateCopilotMarkdown(rule) {
   const lines = [];
@@ -878,43 +1254,24 @@ function generateCopilotMarkdown(rule) {
   lines.push(rule.content);
   return lines.join("\n");
 }
-function generateCopilotIgnore(patterns) {
-  const lines = [
-    "# Generated by rulesync from .rulesyncignore",
-    "# This file is automatically generated. Do not edit manually.",
-    "# Note: .copilotignore is not officially supported by GitHub Copilot.",
-    "# This file is for use with community tools like copilotignore-vscode extension.",
-    "",
-    ...patterns
-  ];
-  return lines.join("\n");
-}
 
 // src/generators/rules/cursor.ts
-var import_node_path7 = require("path");
+var import_node_path9 = require("path");
 async function generateCursorConfig(rules, config, baseDir) {
-  const outputs = [];
-  for (const rule of rules) {
-    const content = generateCursorMarkdown(rule);
-    const outputDir = baseDir ? (0, import_node_path7.join)(baseDir, config.outputPaths.cursor) : config.outputPaths.cursor;
-    const filepath = (0, import_node_path7.join)(outputDir, `${rule.filename}.mdc`);
-    outputs.push({
-      tool: "cursor",
-      filepath,
-      content
-    });
-  }
-  const ignorePatterns = await loadIgnorePatterns(baseDir);
-  if (ignorePatterns.patterns.length > 0) {
-    const cursorIgnorePath = baseDir ? (0, import_node_path7.join)(baseDir, ".cursorignore") : ".cursorignore";
-    const cursorIgnoreContent = generateCursorIgnore(ignorePatterns.patterns);
-    outputs.push({
+  return generateComplexRulesConfig(
+    rules,
+    config,
+    {
       tool: "cursor",
-      filepath: cursorIgnorePath,
-      content: cursorIgnoreContent
-    });
-  }
-  return outputs;
+      fileExtension: ".mdc",
+      ignoreFileName: ".cursorignore",
+      generateContent: generateCursorMarkdown,
+      getOutputPath: (rule, outputDir) => {
+        return (0, import_node_path9.join)(outputDir, `${rule.filename}.mdc`);
+      }
+    },
+    baseDir
+  );
 }
 function generateCursorMarkdown(rule) {
   const lines = [];
@@ -968,26 +1325,17 @@ function determineCursorRuleType(frontmatter) {
   }
   return "intelligently";
 }
-function generateCursorIgnore(patterns) {
-  const lines = [
-    "# Generated by rulesync from .rulesyncignore",
-    "# This file is automatically generated. Do not edit manually.",
-    "",
-    ...patterns
-  ];
-  return lines.join("\n");
-}
 
 // src/generators/rules/geminicli.ts
-var import_node_path8 = require("path");
+var import_node_path10 = require("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 ? (0, import_node_path8.join)(baseDir, config.outputPaths.geminicli) : config.outputPaths.geminicli;
-    const filepath = (0, import_node_path8.join)(outputDir, `${rule.filename}.md`);
+    const outputDir = baseDir ? (0, import_node_path10.join)(baseDir, config.outputPaths.geminicli) : config.outputPaths.geminicli;
+    const filepath = (0, import_node_path10.join)(outputDir, `${rule.filename}.md`);
     outputs.push({
       tool: "geminicli",
       filepath,
@@ -995,7 +1343,7 @@ async function generateGeminiConfig(rules, config, baseDir) {
     });
   }
   const rootContent = generateGeminiRootMarkdown(rootRule, memoryRules, baseDir);
-  const rootFilepath = baseDir ? (0, import_node_path8.join)(baseDir, "GEMINI.md") : "GEMINI.md";
+  const rootFilepath = baseDir ? (0, import_node_path10.join)(baseDir, "GEMINI.md") : "GEMINI.md";
   outputs.push({
     tool: "geminicli",
     filepath: rootFilepath,
@@ -1003,7 +1351,7 @@ async function generateGeminiConfig(rules, config, baseDir) {
   });
   const ignorePatterns = await loadIgnorePatterns(baseDir);
   if (ignorePatterns.patterns.length > 0) {
-    const aiexcludePath = baseDir ? (0, import_node_path8.join)(baseDir, ".aiexclude") : ".aiexclude";
+    const aiexcludePath = baseDir ? (0, import_node_path10.join)(baseDir, ".aiexclude") : ".aiexclude";
     const aiexcludeContent = generateAiexclude(ignorePatterns.patterns);
     outputs.push({
       tool: "geminicli",
@@ -1051,13 +1399,13 @@ function generateAiexclude(patterns) {
 }
 
 // src/generators/rules/kiro.ts
-var import_node_path9 = require("path");
+var import_node_path11 = 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`);
+    const outputDir = baseDir ? (0, import_node_path11.join)(baseDir, config.outputPaths.kiro) : config.outputPaths.kiro;
+    const filepath = (0, import_node_path11.join)(outputDir, `${rule.filename}.md`);
     outputs.push({
       tool: "kiro",
       filepath,
@@ -1071,47 +1419,23 @@ function generateKiroMarkdown(rule) {
 }
 
 // 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_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,
-      content
-    });
-  }
-  const ignorePatterns = await loadIgnorePatterns(baseDir);
-  if (ignorePatterns.patterns.length > 0) {
-    const rooIgnorePath = baseDir ? (0, import_node_path10.join)(baseDir, ".rooignore") : ".rooignore";
-    const rooIgnoreContent = generateRooIgnore(ignorePatterns.patterns);
-    outputs.push({
+  return generateRulesConfig(
+    rules,
+    config,
+    {
       tool: "roo",
-      filepath: rooIgnorePath,
-      content: rooIgnoreContent
-    });
-  }
-  return outputs;
-}
-function generateRooMarkdown(rule) {
-  return rule.content.trim();
-}
-function generateRooIgnore(patterns) {
-  const lines = [
-    "# Generated by rulesync from .rulesyncignore",
-    "# This file is automatically generated. Do not edit manually.",
-    "",
-    ...patterns
-  ];
-  return lines.join("\n");
+      fileExtension: ".md",
+      ignoreFileName: ".rooignore",
+      generateContent: (rule) => rule.content.trim()
+    },
+    baseDir
+  );
 }
 
 // src/core/generator.ts
 async function generateConfigurations(rules, config, targetTools, baseDir) {
-  const outputs = [];
+  const outputs = createOutputsArray();
   const toolsToGenerate = targetTools || config.defaultTargets;
   const rootFiles = rules.filter((rule) => rule.frontmatter.root === true);
   if (rootFiles.length === 0) {
@@ -1140,6 +1464,20 @@ function filterRulesForTool(rules, tool, config) {
 }
 async function generateForTool(tool, rules, config, baseDir) {
   switch (tool) {
+    case "augmentcode": {
+      const augmentRulesOutputs = await generateAugmentcodeConfig(rules, config, baseDir);
+      const augmentIgnoreOutputs = await generateAugmentCodeIgnoreFiles(rules, config, baseDir);
+      return [...augmentRulesOutputs, ...augmentIgnoreOutputs];
+    }
+    case "augmentcode-legacy": {
+      const augmentLegacyRulesOutputs = await generateAugmentcodeLegacyConfig(
+        rules,
+        config,
+        baseDir
+      );
+      const augmentIgnoreOutputs = await generateAugmentCodeIgnoreFiles(rules, config, baseDir);
+      return [...augmentLegacyRulesOutputs, ...augmentIgnoreOutputs];
+    }
     case "copilot":
       return generateCopilotConfig(rules, config, baseDir);
     case "cursor":
@@ -1164,7 +1502,7 @@ async function generateForTool(tool, rules, config, baseDir) {
 }
 
 // src/core/parser.ts
-var import_node_path11 = require("path");
+var import_node_path12 = require("path");
 var import_gray_matter = __toESM(require("gray-matter"), 1);
 
 // src/types/config.ts
@@ -1217,7 +1555,8 @@ var RuleFrontmatterSchema = import_mini5.z.object({
   targets: RulesyncTargetsSchema,
   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"]))
+  cursorRuleType: import_mini5.z.optional(import_mini5.z.enum(["always", "manual", "specificFiles", "intelligently"])),
+  tags: import_mini5.z.optional(import_mini5.z.array(import_mini5.z.string()))
 });
 var ParsedRuleSchema = import_mini5.z.object({
   frontmatter: RuleFrontmatterSchema,
@@ -1276,7 +1615,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_path11.basename)(filepath, ".md");
+    const filename = (0, import_node_path12.basename)(filepath, ".md");
     return {
       frontmatter,
       content: parsed.content,
@@ -1344,6 +1683,7 @@ async function validateRule(rule) {
 var path3 = __toESM(require("path"), 1);
 
 // src/generators/mcp/index.ts
+init_augmentcode();
 init_claudecode();
 init_cline();
 init_copilot();
@@ -1388,6 +1728,16 @@ async function generateMcpConfigs(projectRoot, baseDir) {
     return results;
   }
   const generators = [
+    {
+      tool: "augmentcode-project",
+      path: path3.join(targetRoot, ".mcp.json"),
+      generate: () => generateAugmentcodeMcp(config)
+    },
+    {
+      tool: "augmentcode-legacy-project",
+      path: path3.join(targetRoot, ".mcp.json"),
+      generate: () => generateAugmentcodeMcp(config)
+    },
     {
       tool: "claude-project",
       path: path3.join(targetRoot, ".mcp.json"),
@@ -1428,7 +1778,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("kiro") || generator.tool.includes("roo")) {
+      if (generator.tool.includes("augmentcode") || 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,
@@ -1547,11 +1897,10 @@ Generating configurations for base directory: ${baseDir}`);
       console.warn("\u26A0\uFE0F  No configurations generated");
       return;
     }
-    console.log(`
-\u{1F389} Successfully generated ${totalOutputs} configuration file(s)!`);
     if (options.verbose) {
       console.log("\nGenerating MCP configurations...");
     }
+    let totalMcpOutputs = 0;
     for (const baseDir of baseDirs) {
       const mcpResults = await generateMcpConfigs(
         process.cwd(),
@@ -1566,6 +1915,7 @@ Generating configurations for base directory: ${baseDir}`);
       for (const result of mcpResults) {
         if (result.status === "success") {
           console.log(`\u2705 Generated ${result.tool} MCP configuration: ${result.path}`);
+          totalMcpOutputs++;
         } else if (result.status === "error") {
           console.error(`\u274C Failed to generate ${result.tool} MCP configuration: ${result.error}`);
         } else if (options.verbose && result.status === "skipped") {
@@ -1573,6 +1923,13 @@ Generating configurations for base directory: ${baseDir}`);
         }
       }
     }
+    const totalGenerated = totalOutputs + totalMcpOutputs;
+    if (totalGenerated > 0) {
+      console.log(
+        `
+\u{1F389} All done! Generated ${totalGenerated} file(s) total (${totalOutputs} configurations + ${totalMcpOutputs} MCP configurations)`
+      );
+    }
   } catch (error) {
     console.error("\u274C Failed to generate configurations:", error);
     process.exit(1);
@@ -1581,9 +1938,9 @@ Generating configurations for base directory: ${baseDir}`);
 
 // src/cli/commands/gitignore.ts
 var import_node_fs = require("fs");
-var import_node_path12 = require("path");
+var import_node_path13 = require("path");
 var gitignoreCommand = async () => {
-  const gitignorePath = (0, import_node_path12.join)(process.cwd(), ".gitignore");
+  const gitignorePath = (0, import_node_path13.join)(process.cwd(), ".gitignore");
   const rulesFilesToIgnore = [
     "# Generated by rulesync - AI tool configuration files",
     "**/.github/copilot-instructions.md",
@@ -1601,7 +1958,10 @@ var gitignoreCommand = async () => {
     "**/.gemini/memories/",
     "**/.aiexclude",
     "**/.aiignore",
+    "**/.augmentignore",
     "**/.kiro/steering/",
+    "**/.augment/rules/",
+    "**/.augment-guidelines",
     "**/.mcp.json",
     "!.rulesync/.mcp.json",
     "**/.cursor/mcp.json",
@@ -1639,35 +1999,273 @@ ${linesToAdd.join("\n")}
 };
 
 // src/core/importer.ts
-var import_node_path19 = require("path");
-var import_gray_matter4 = __toESM(require("gray-matter"), 1);
+var import_node_path18 = require("path");
+var import_gray_matter5 = __toESM(require("gray-matter"), 1);
 
-// src/parsers/claudecode.ts
-var import_node_path13 = require("path");
-async function parseClaudeConfiguration(baseDir = process.cwd()) {
+// src/parsers/augmentcode.ts
+var import_node_path14 = require("path");
+var import_gray_matter2 = __toESM(require("gray-matter"), 1);
+
+// src/utils/parser-helpers.ts
+function createParseResult() {
+  return { rules: [], errors: [] };
+}
+function addError(result, error) {
+  result.errors.push(error);
+}
+function addRule(result, rule) {
+  if (!result.rules) {
+    result.rules = [];
+  }
+  result.rules.push(rule);
+}
+function addRules(result, rules) {
+  if (!result.rules) {
+    result.rules = [];
+  }
+  result.rules.push(...rules);
+}
+function handleParseError(error, context) {
+  const errorMessage = error instanceof Error ? error.message : String(error);
+  return `${context}: ${errorMessage}`;
+}
+async function safeReadFile(operation, errorContext) {
+  try {
+    const result = await operation();
+    return { success: true, result };
+  } catch (error) {
+    return {
+      success: false,
+      error: handleParseError(error, errorContext)
+    };
+  }
+}
+
+// src/parsers/augmentcode.ts
+async function parseAugmentcodeConfiguration(baseDir = process.cwd()) {
+  const result = createParseResult();
+  const rulesDir = (0, import_node_path14.join)(baseDir, ".augment", "rules");
+  if (await fileExists(rulesDir)) {
+    const rulesResult = await parseAugmentRules(rulesDir);
+    addRules(result, rulesResult.rules);
+    result.errors.push(...rulesResult.errors);
+  } else {
+    addError(result, "No AugmentCode configuration found. Expected .augment/rules/ directory.");
+  }
+  return { rules: result.rules || [], errors: result.errors };
+}
+async function parseAugmentRules(rulesDir) {
+  const rules = [];
+  const errors = [];
+  try {
+    const { readdir: readdir2 } = await import("fs/promises");
+    const files = await readdir2(rulesDir);
+    for (const file of files) {
+      if (file.endsWith(".md") || file.endsWith(".mdc")) {
+        const filePath = (0, import_node_path14.join)(rulesDir, file);
+        try {
+          const rawContent = await readFileContent(filePath);
+          const parsed = (0, import_gray_matter2.default)(rawContent);
+          const frontmatterData = parsed.data;
+          const ruleType = frontmatterData.type || "manual";
+          const description = frontmatterData.description || "";
+          const tags = Array.isArray(frontmatterData.tags) ? frontmatterData.tags : void 0;
+          const isRoot = ruleType === "always";
+          const filename = (0, import_node_path14.basename)(file, file.endsWith(".mdc") ? ".mdc" : ".md");
+          const frontmatter = {
+            root: isRoot,
+            targets: ["augmentcode"],
+            description,
+            globs: ["**/*"],
+            // AugmentCode doesn't use specific globs in the same way
+            ...tags && { tags }
+          };
+          rules.push({
+            frontmatter,
+            content: parsed.content.trim(),
+            filename: `augmentcode-${ruleType}-${filename}`,
+            filepath: filePath
+          });
+        } catch (error) {
+          const errorMessage = error instanceof Error ? error.message : String(error);
+          errors.push(`Failed to parse ${filePath}: ${errorMessage}`);
+        }
+      }
+    }
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    errors.push(`Failed to read .augment/rules/ directory: ${errorMessage}`);
+  }
+  return { rules, errors };
+}
+
+// src/parsers/augmentcode-legacy.ts
+var import_node_path15 = require("path");
+async function parseAugmentcodeLegacyConfiguration(baseDir = process.cwd()) {
+  const result = createParseResult();
+  const guidelinesPath = (0, import_node_path15.join)(baseDir, ".augment-guidelines");
+  if (await fileExists(guidelinesPath)) {
+    const guidelinesResult = await parseAugmentGuidelines(guidelinesPath);
+    if (guidelinesResult.rule) {
+      addRule(result, guidelinesResult.rule);
+    }
+    result.errors.push(...guidelinesResult.errors);
+  } else {
+    addError(
+      result,
+      "No AugmentCode legacy configuration found. Expected .augment-guidelines file."
+    );
+  }
+  return { rules: result.rules || [], errors: result.errors };
+}
+async function parseAugmentGuidelines(guidelinesPath) {
+  const parseResult = await safeReadFile(async () => {
+    const content = await readFileContent(guidelinesPath);
+    if (content.trim()) {
+      const frontmatter = {
+        root: true,
+        // Legacy guidelines become root rules
+        targets: ["augmentcode-legacy"],
+        description: "Legacy AugmentCode guidelines",
+        globs: ["**/*"]
+      };
+      return {
+        frontmatter,
+        content: content.trim(),
+        filename: "augmentcode-legacy-guidelines",
+        filepath: guidelinesPath
+      };
+    }
+    return null;
+  }, "Failed to parse .augment-guidelines");
+  if (parseResult.success) {
+    return { rule: parseResult.result || null, errors: [] };
+  } else {
+    return { rule: null, errors: [parseResult.error || "Unknown error"] };
+  }
+}
+
+// src/parsers/shared-helpers.ts
+var import_node_path16 = require("path");
+var import_gray_matter3 = __toESM(require("gray-matter"), 1);
+async function parseConfigurationFiles(baseDir = process.cwd(), config) {
+  const errors = [];
+  const rules = [];
+  if (config.mainFile) {
+    const mainFilePath = (0, import_node_path16.join)(baseDir, config.mainFile.path);
+    if (await fileExists(mainFilePath)) {
+      try {
+        const rawContent = await readFileContent(mainFilePath);
+        let content;
+        let frontmatter;
+        if (config.mainFile.useFrontmatter) {
+          const parsed = (0, import_gray_matter3.default)(rawContent);
+          content = parsed.content.trim();
+          frontmatter = {
+            root: false,
+            targets: [config.tool],
+            description: config.mainFile.description,
+            globs: ["**/*"]
+          };
+        } else {
+          content = rawContent.trim();
+          frontmatter = {
+            root: false,
+            targets: [config.tool],
+            description: config.mainFile.description,
+            globs: ["**/*"]
+          };
+        }
+        if (content) {
+          rules.push({
+            frontmatter,
+            content,
+            filename: `${config.tool}-instructions`,
+            filepath: mainFilePath
+          });
+        }
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        errors.push(`Failed to parse ${config.mainFile.path}: ${errorMessage}`);
+      }
+    }
+  }
+  if (config.directories) {
+    for (const dirConfig of config.directories) {
+      const dirPath = (0, import_node_path16.join)(baseDir, dirConfig.directory);
+      if (await fileExists(dirPath)) {
+        try {
+          const { readdir: readdir2 } = await import("fs/promises");
+          const files = await readdir2(dirPath);
+          for (const file of files) {
+            if (file.endsWith(dirConfig.filePattern)) {
+              const filePath = (0, import_node_path16.join)(dirPath, file);
+              try {
+                const rawContent = await readFileContent(filePath);
+                let content;
+                if (dirConfig.filePattern === ".instructions.md") {
+                  const parsed = (0, import_gray_matter3.default)(rawContent);
+                  content = parsed.content.trim();
+                } else {
+                  content = rawContent.trim();
+                }
+                if (content) {
+                  const filename = file.replace(new RegExp(`\\${dirConfig.filePattern}$`), "");
+                  const frontmatter = {
+                    root: false,
+                    targets: [config.tool],
+                    description: `${dirConfig.description}: ${filename}`,
+                    globs: ["**/*"]
+                  };
+                  rules.push({
+                    frontmatter,
+                    content,
+                    filename: `${config.tool}-${filename}`,
+                    filepath: filePath
+                  });
+                }
+              } catch (error) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                errors.push(`Failed to parse ${filePath}: ${errorMessage}`);
+              }
+            }
+          }
+        } catch (error) {
+          const errorMessage = error instanceof Error ? error.message : String(error);
+          errors.push(`Failed to parse ${dirConfig.directory} files: ${errorMessage}`);
+        }
+      }
+    }
+  }
+  if (rules.length === 0) {
+    errors.push(config.errorMessage);
+  }
+  return { rules, errors };
+}
+async function parseMemoryBasedConfiguration(baseDir = process.cwd(), config) {
   const errors = [];
   const rules = [];
   let ignorePatterns;
   let mcpServers;
-  const claudeFilePath = (0, import_node_path13.join)(baseDir, "CLAUDE.md");
-  if (!await fileExists(claudeFilePath)) {
-    errors.push("CLAUDE.md file not found");
+  const mainFilePath = (0, import_node_path16.join)(baseDir, config.mainFileName);
+  if (!await fileExists(mainFilePath)) {
+    errors.push(`${config.mainFileName} file not found`);
     return { rules, errors };
   }
   try {
-    const claudeContent = await readFileContent(claudeFilePath);
-    const mainRule = parseClaudeMainFile(claudeContent, claudeFilePath);
+    const mainContent = await readFileContent(mainFilePath);
+    const mainRule = parseMainFile(mainContent, mainFilePath, config);
     if (mainRule) {
       rules.push(mainRule);
     }
-    const memoryDir = (0, import_node_path13.join)(baseDir, ".claude", "memories");
+    const memoryDir = (0, import_node_path16.join)(baseDir, config.memoryDirPath);
     if (await fileExists(memoryDir)) {
-      const memoryRules = await parseClaudeMemoryFiles(memoryDir);
+      const memoryRules = await parseMemoryFiles(memoryDir, config);
       rules.push(...memoryRules);
     }
-    const settingsPath = (0, import_node_path13.join)(baseDir, ".claude", "settings.json");
+    const settingsPath = (0, import_node_path16.join)(baseDir, config.settingsPath);
     if (await fileExists(settingsPath)) {
-      const settingsResult = await parseClaudeSettings(settingsPath);
+      const settingsResult = await parseSettingsFile(settingsPath, config.tool);
       if (settingsResult.ignorePatterns) {
         ignorePatterns = settingsResult.ignorePatterns;
       }
@@ -1676,9 +2274,18 @@ async function parseClaudeConfiguration(baseDir = process.cwd()) {
       }
       errors.push(...settingsResult.errors);
     }
+    if (config.additionalIgnoreFile) {
+      const additionalIgnorePath = (0, import_node_path16.join)(baseDir, config.additionalIgnoreFile.path);
+      if (await fileExists(additionalIgnorePath)) {
+        const additionalPatterns = await config.additionalIgnoreFile.parser(additionalIgnorePath);
+        if (additionalPatterns.length > 0) {
+          ignorePatterns = ignorePatterns ? [...ignorePatterns, ...additionalPatterns] : additionalPatterns;
+        }
+      }
+    }
   } catch (error) {
     const errorMessage = error instanceof Error ? error.message : String(error);
-    errors.push(`Failed to parse Claude configuration: ${errorMessage}`);
+    errors.push(`Failed to parse ${config.tool} configuration: ${errorMessage}`);
   }
   return {
     rules,
@@ -1687,7 +2294,7 @@ async function parseClaudeConfiguration(baseDir = process.cwd()) {
     ...mcpServers && { mcpServers }
   };
 }
-function parseClaudeMainFile(content, filepath) {
+function parseMainFile(content, filepath, config) {
   const lines = content.split("\n");
   let contentStartIndex = 0;
   if (lines.some((line) => line.includes("| Document | Description | File Patterns |"))) {
@@ -1704,38 +2311,38 @@ function parseClaudeMainFile(content, filepath) {
   }
   const frontmatter = {
     root: false,
-    targets: ["claudecode"],
-    description: "Main Claude Code configuration",
+    targets: [config.tool],
+    description: config.mainDescription,
     globs: ["**/*"]
   };
   return {
     frontmatter,
     content: mainContent,
-    filename: "claude-main",
+    filename: `${config.filenamePrefix}-main`,
     filepath
   };
 }
-async function parseClaudeMemoryFiles(memoryDir) {
+async function parseMemoryFiles(memoryDir, config) {
   const rules = [];
   try {
     const { readdir: readdir2 } = await import("fs/promises");
     const files = await readdir2(memoryDir);
     for (const file of files) {
       if (file.endsWith(".md")) {
-        const filePath = (0, import_node_path13.join)(memoryDir, file);
+        const filePath = (0, import_node_path16.join)(memoryDir, file);
         const content = await readFileContent(filePath);
         if (content.trim()) {
-          const filename = (0, import_node_path13.basename)(file, ".md");
+          const filename = (0, import_node_path16.basename)(file, ".md");
           const frontmatter = {
             root: false,
-            targets: ["claudecode"],
-            description: `Memory file: ${filename}`,
+            targets: [config.tool],
+            description: `${config.memoryDescription}: ${filename}`,
             globs: ["**/*"]
           };
           rules.push({
             frontmatter,
             content: content.trim(),
-            filename: `claude-memory-${filename}`,
+            filename: `${config.filenamePrefix}-memory-${filename}`,
             filepath: filePath
           });
         }
@@ -1745,14 +2352,14 @@ async function parseClaudeMemoryFiles(memoryDir) {
   }
   return rules;
 }
-async function parseClaudeSettings(settingsPath) {
+async function parseSettingsFile(settingsPath, tool) {
   const errors = [];
   let ignorePatterns;
   let mcpServers;
   try {
     const content = await readFileContent(settingsPath);
     const settings = JSON.parse(content);
-    if (typeof settings === "object" && settings !== null && "permissions" in settings) {
+    if (tool === "claudecode" && typeof settings === "object" && settings !== null && "permissions" in settings) {
       const permissions = settings.permissions;
       if (typeof permissions !== "object" || permissions === null) {
         return { ignorePatterns: [], errors: [] };
@@ -1784,151 +2391,62 @@ async function parseClaudeSettings(settingsPath) {
   };
 }
 
+// src/parsers/claudecode.ts
+async function parseClaudeConfiguration(baseDir = process.cwd()) {
+  return parseMemoryBasedConfiguration(baseDir, {
+    tool: "claudecode",
+    mainFileName: "CLAUDE.md",
+    memoryDirPath: ".claude/memories",
+    settingsPath: ".claude/settings.json",
+    mainDescription: "Main Claude Code configuration",
+    memoryDescription: "Memory file",
+    filenamePrefix: "claude"
+  });
+}
+
 // src/parsers/cline.ts
-var import_node_path14 = require("path");
 async function parseClineConfiguration(baseDir = process.cwd()) {
-  const errors = [];
-  const rules = [];
-  const clineFilePath = (0, import_node_path14.join)(baseDir, ".cline", "instructions.md");
-  if (await fileExists(clineFilePath)) {
-    try {
-      const content = await readFileContent(clineFilePath);
-      if (content.trim()) {
-        const frontmatter = {
-          root: false,
-          targets: ["cline"],
-          description: "Cline instructions",
-          globs: ["**/*"]
-        };
-        rules.push({
-          frontmatter,
-          content: content.trim(),
-          filename: "cline-instructions",
-          filepath: clineFilePath
-        });
-      }
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      errors.push(`Failed to parse .cline/instructions.md: ${errorMessage}`);
-    }
-  }
-  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_path14.join)(clinerulesDirPath, file);
-          try {
-            const content = await readFileContent(filePath);
-            if (content.trim()) {
-              const filename = file.replace(".md", "");
-              const frontmatter = {
-                root: false,
-                targets: ["cline"],
-                description: `Cline rule: ${filename}`,
-                globs: ["**/*"]
-              };
-              rules.push({
-                frontmatter,
-                content: content.trim(),
-                filename: `cline-${filename}`,
-                filepath: filePath
-              });
-            }
-          } catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            errors.push(`Failed to parse ${filePath}: ${errorMessage}`);
-          }
-        }
+  return parseConfigurationFiles(baseDir, {
+    tool: "cline",
+    mainFile: {
+      path: ".cline/instructions.md",
+      useFrontmatter: false,
+      description: "Cline instructions"
+    },
+    directories: [
+      {
+        directory: ".clinerules",
+        filePattern: ".md",
+        description: "Cline rule"
       }
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      errors.push(`Failed to parse .clinerules files: ${errorMessage}`);
-    }
-  }
-  if (rules.length === 0) {
-    errors.push("No Cline configuration files found (.cline/instructions.md or .clinerules/*.md)");
-  }
-  return { rules, errors };
+    ],
+    errorMessage: "No Cline configuration files found (.cline/instructions.md or .clinerules/*.md)"
+  });
 }
 
 // src/parsers/copilot.ts
-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_path15.join)(baseDir, ".github", "copilot-instructions.md");
-  if (await fileExists(copilotFilePath)) {
-    try {
-      const rawContent = await readFileContent(copilotFilePath);
-      const parsed = (0, import_gray_matter2.default)(rawContent);
-      const content = parsed.content.trim();
-      if (content) {
-        const frontmatter = {
-          root: false,
-          targets: ["copilot"],
-          description: "GitHub Copilot instructions",
-          globs: ["**/*"]
-        };
-        rules.push({
-          frontmatter,
-          content,
-          filename: "copilot-instructions",
-          filepath: copilotFilePath
-        });
-      }
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      errors.push(`Failed to parse copilot-instructions.md: ${errorMessage}`);
-    }
-  }
-  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_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_path15.basename)(file, ".instructions.md");
-            const frontmatter = {
-              root: false,
-              targets: ["copilot"],
-              description: `Copilot instruction: ${filename}`,
-              globs: ["**/*"]
-            };
-            rules.push({
-              frontmatter,
-              content,
-              filename: `copilot-${filename}`,
-              filepath: filePath
-            });
-          }
-        }
+  return parseConfigurationFiles(baseDir, {
+    tool: "copilot",
+    mainFile: {
+      path: ".github/copilot-instructions.md",
+      useFrontmatter: true,
+      description: "GitHub Copilot instructions"
+    },
+    directories: [
+      {
+        directory: ".github/instructions",
+        filePattern: ".instructions.md",
+        description: "Copilot instruction"
       }
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      errors.push(`Failed to parse .github/instructions files: ${errorMessage}`);
-    }
-  }
-  if (rules.length === 0) {
-    errors.push(
-      "No Copilot configuration files found (.github/copilot-instructions.md or .github/instructions/*.instructions.md)"
-    );
-  }
-  return { rules, errors };
+    ],
+    errorMessage: "No Copilot configuration files found (.github/copilot-instructions.md or .github/instructions/*.instructions.md)"
+  });
 }
 
 // src/parsers/cursor.ts
-var import_node_path16 = require("path");
-var import_gray_matter3 = __toESM(require("gray-matter"), 1);
+var import_node_path17 = require("path");
+var import_gray_matter4 = __toESM(require("gray-matter"), 1);
 var import_js_yaml = require("js-yaml");
 var import_mini6 = require("zod/mini");
 var customMatterOptions = {
@@ -2052,11 +2570,11 @@ async function parseCursorConfiguration(baseDir = process.cwd()) {
   const rules = [];
   let ignorePatterns;
   let mcpServers;
-  const cursorFilePath = (0, import_node_path16.join)(baseDir, ".cursorrules");
+  const cursorFilePath = (0, import_node_path17.join)(baseDir, ".cursorrules");
   if (await fileExists(cursorFilePath)) {
     try {
       const rawContent = await readFileContent(cursorFilePath);
-      const parsed = (0, import_gray_matter3.default)(rawContent, customMatterOptions);
+      const parsed = (0, import_gray_matter4.default)(rawContent, customMatterOptions);
       const content = parsed.content.trim();
       if (content) {
         const frontmatter = convertCursorMdcFrontmatter(parsed.data, "cursorrules");
@@ -2073,20 +2591,20 @@ async function parseCursorConfiguration(baseDir = process.cwd()) {
       errors.push(`Failed to parse .cursorrules file: ${errorMessage}`);
     }
   }
-  const cursorRulesDir = (0, import_node_path16.join)(baseDir, ".cursor", "rules");
+  const cursorRulesDir = (0, import_node_path17.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_path16.join)(cursorRulesDir, file);
+          const filePath = (0, import_node_path17.join)(cursorRulesDir, file);
           try {
             const rawContent = await readFileContent(filePath);
-            const parsed = (0, import_gray_matter3.default)(rawContent, customMatterOptions);
+            const parsed = (0, import_gray_matter4.default)(rawContent, customMatterOptions);
             const content = parsed.content.trim();
             if (content) {
-              const filename = (0, import_node_path16.basename)(file, ".mdc");
+              const filename = (0, import_node_path17.basename)(file, ".mdc");
               const frontmatter = convertCursorMdcFrontmatter(parsed.data, filename);
               rules.push({
                 frontmatter,
@@ -2109,7 +2627,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_path16.join)(baseDir, ".cursorignore");
+  const cursorIgnorePath = (0, import_node_path17.join)(baseDir, ".cursorignore");
   if (await fileExists(cursorIgnorePath)) {
     try {
       const content = await readFileContent(cursorIgnorePath);
@@ -2122,7 +2640,7 @@ async function parseCursorConfiguration(baseDir = process.cwd()) {
       errors.push(`Failed to parse .cursorignore: ${errorMessage}`);
     }
   }
-  const cursorMcpPath = (0, import_node_path16.join)(baseDir, ".cursor", "mcp.json");
+  const cursorMcpPath = (0, import_node_path17.join)(baseDir, ".cursor", "mcp.json");
   if (await fileExists(cursorMcpPath)) {
     try {
       const content = await readFileContent(cursorMcpPath);
@@ -2145,134 +2663,6 @@ async function parseCursorConfiguration(baseDir = process.cwd()) {
 }
 
 // src/parsers/geminicli.ts
-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_path17.join)(baseDir, "GEMINI.md");
-  if (!await fileExists(geminiFilePath)) {
-    errors.push("GEMINI.md file not found");
-    return { rules, errors };
-  }
-  try {
-    const geminiContent = await readFileContent(geminiFilePath);
-    const mainRule = parseGeminiMainFile(geminiContent, geminiFilePath);
-    if (mainRule) {
-      rules.push(mainRule);
-    }
-    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_path17.join)(baseDir, ".gemini", "settings.json");
-    if (await fileExists(settingsPath)) {
-      const settingsResult = await parseGeminiSettings(settingsPath);
-      if (settingsResult.ignorePatterns) {
-        ignorePatterns = settingsResult.ignorePatterns;
-      }
-      if (settingsResult.mcpServers) {
-        mcpServers = settingsResult.mcpServers;
-      }
-      errors.push(...settingsResult.errors);
-    }
-    const aiexcludePath = (0, import_node_path17.join)(baseDir, ".aiexclude");
-    if (await fileExists(aiexcludePath)) {
-      const aiexcludePatterns = await parseAiexclude(aiexcludePath);
-      if (aiexcludePatterns.length > 0) {
-        ignorePatterns = ignorePatterns ? [...ignorePatterns, ...aiexcludePatterns] : aiexcludePatterns;
-      }
-    }
-  } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : String(error);
-    errors.push(`Failed to parse Gemini configuration: ${errorMessage}`);
-  }
-  return {
-    rules,
-    errors,
-    ...ignorePatterns && { ignorePatterns },
-    ...mcpServers && { mcpServers }
-  };
-}
-function parseGeminiMainFile(content, filepath) {
-  const lines = content.split("\n");
-  let contentStartIndex = 0;
-  if (lines.some((line) => line.includes("| Document | Description | File Patterns |"))) {
-    const tableEndIndex = lines.findIndex(
-      (line, index) => index > 0 && line.trim() === "" && lines[index - 1]?.includes("|") && !lines[index + 1]?.includes("|")
-    );
-    if (tableEndIndex !== -1) {
-      contentStartIndex = tableEndIndex + 1;
-    }
-  }
-  const mainContent = lines.slice(contentStartIndex).join("\n").trim();
-  if (!mainContent) {
-    return null;
-  }
-  const frontmatter = {
-    root: false,
-    targets: ["geminicli"],
-    description: "Main Gemini CLI configuration",
-    globs: ["**/*"]
-  };
-  return {
-    frontmatter,
-    content: mainContent,
-    filename: "gemini-main",
-    filepath
-  };
-}
-async function parseGeminiMemoryFiles(memoryDir) {
-  const rules = [];
-  try {
-    const { readdir: readdir2 } = await import("fs/promises");
-    const files = await readdir2(memoryDir);
-    for (const file of files) {
-      if (file.endsWith(".md")) {
-        const filePath = (0, import_node_path17.join)(memoryDir, file);
-        const content = await readFileContent(filePath);
-        if (content.trim()) {
-          const filename = (0, import_node_path17.basename)(file, ".md");
-          const frontmatter = {
-            root: false,
-            targets: ["geminicli"],
-            description: `Memory file: ${filename}`,
-            globs: ["**/*"]
-          };
-          rules.push({
-            frontmatter,
-            content: content.trim(),
-            filename: `gemini-memory-${filename}`,
-            filepath: filePath
-          });
-        }
-      }
-    }
-  } catch {
-  }
-  return rules;
-}
-async function parseGeminiSettings(settingsPath) {
-  const errors = [];
-  let mcpServers;
-  try {
-    const content = await readFileContent(settingsPath);
-    const settings = JSON.parse(content);
-    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);
-    errors.push(`Failed to parse settings.json: ${errorMessage}`);
-  }
-  return {
-    errors,
-    ...mcpServers && { mcpServers }
-  };
-}
 async function parseAiexclude(aiexcludePath) {
   try {
     const content = await readFileContent(aiexcludePath);
@@ -2282,75 +2672,40 @@ async function parseAiexclude(aiexcludePath) {
     return [];
   }
 }
+async function parseGeminiConfiguration(baseDir = process.cwd()) {
+  return parseMemoryBasedConfiguration(baseDir, {
+    tool: "geminicli",
+    mainFileName: "GEMINI.md",
+    memoryDirPath: ".gemini/memories",
+    settingsPath: ".gemini/settings.json",
+    mainDescription: "Main Gemini CLI configuration",
+    memoryDescription: "Memory file",
+    filenamePrefix: "gemini",
+    additionalIgnoreFile: {
+      path: ".aiexclude",
+      parser: parseAiexclude
+    }
+  });
+}
 
 // src/parsers/roo.ts
-var import_node_path18 = require("path");
 async function parseRooConfiguration(baseDir = process.cwd()) {
-  const errors = [];
-  const rules = [];
-  const rooFilePath = (0, import_node_path18.join)(baseDir, ".roo", "instructions.md");
-  if (await fileExists(rooFilePath)) {
-    try {
-      const content = await readFileContent(rooFilePath);
-      if (content.trim()) {
-        const frontmatter = {
-          root: false,
-          targets: ["roo"],
-          description: "Roo Code instructions",
-          globs: ["**/*"]
-        };
-        rules.push({
-          frontmatter,
-          content: content.trim(),
-          filename: "roo-instructions",
-          filepath: rooFilePath
-        });
-      }
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      errors.push(`Failed to parse .roo/instructions.md: ${errorMessage}`);
-    }
-  }
-  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_path18.join)(rooRulesDir, file);
-          try {
-            const content = await readFileContent(filePath);
-            if (content.trim()) {
-              const filename = file.replace(".md", "");
-              const frontmatter = {
-                root: false,
-                targets: ["roo"],
-                description: `Roo rule: ${filename}`,
-                globs: ["**/*"]
-              };
-              rules.push({
-                frontmatter,
-                content: content.trim(),
-                filename: `roo-${filename}`,
-                filepath: filePath
-              });
-            }
-          } catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            errors.push(`Failed to parse ${filePath}: ${errorMessage}`);
-          }
-        }
+  return parseConfigurationFiles(baseDir, {
+    tool: "roo",
+    mainFile: {
+      path: ".roo/instructions.md",
+      useFrontmatter: false,
+      description: "Roo Code instructions"
+    },
+    directories: [
+      {
+        directory: ".roo/rules",
+        filePattern: ".md",
+        description: "Roo rule"
       }
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      errors.push(`Failed to parse .roo/rules files: ${errorMessage}`);
-    }
-  }
-  if (rules.length === 0) {
-    errors.push("No Roo Code configuration files found (.roo/instructions.md or .roo/rules/*.md)");
-  }
-  return { rules, errors };
+    ],
+    errorMessage: "No Roo Code configuration files found (.roo/instructions.md or .roo/rules/*.md)"
+  });
 }
 
 // src/core/importer.ts
@@ -2365,6 +2720,18 @@ async function importConfiguration(options) {
   }
   try {
     switch (tool) {
+      case "augmentcode": {
+        const augmentResult = await parseAugmentcodeConfiguration(baseDir);
+        rules = augmentResult.rules;
+        errors.push(...augmentResult.errors);
+        break;
+      }
+      case "augmentcode-legacy": {
+        const augmentLegacyResult = await parseAugmentcodeLegacyConfiguration(baseDir);
+        rules = augmentLegacyResult.rules;
+        errors.push(...augmentLegacyResult.errors);
+        break;
+      }
       case "claudecode": {
         const claudeResult = await parseClaudeConfiguration(baseDir);
         rules = claudeResult.rules;
@@ -2419,7 +2786,7 @@ async function importConfiguration(options) {
   if (rules.length === 0 && !ignorePatterns && !mcpServers) {
     return { success: false, rulesCreated: 0, errors };
   }
-  const rulesDirPath = (0, import_node_path19.join)(baseDir, rulesDir);
+  const rulesDirPath = (0, import_node_path18.join)(baseDir, rulesDir);
   try {
     const { mkdir: mkdir3 } = await import("fs/promises");
     await mkdir3(rulesDirPath, { recursive: true });
@@ -2433,7 +2800,7 @@ async function importConfiguration(options) {
     try {
       const baseFilename = `${tool}__${rule.filename}`;
       const filename = await generateUniqueFilename(rulesDirPath, baseFilename);
-      const filePath = (0, import_node_path19.join)(rulesDirPath, `${filename}.md`);
+      const filePath = (0, import_node_path18.join)(rulesDirPath, `${filename}.md`);
       const content = generateRuleFileContent(rule);
       await writeFileContent(filePath, content);
       rulesCreated++;
@@ -2448,7 +2815,7 @@ async function importConfiguration(options) {
   let ignoreFileCreated = false;
   if (ignorePatterns && ignorePatterns.length > 0) {
     try {
-      const rulesyncignorePath = (0, import_node_path19.join)(baseDir, ".rulesyncignore");
+      const rulesyncignorePath = (0, import_node_path18.join)(baseDir, ".rulesyncignore");
       const ignoreContent = `${ignorePatterns.join("\n")}
 `;
       await writeFileContent(rulesyncignorePath, ignoreContent);
@@ -2464,7 +2831,7 @@ async function importConfiguration(options) {
   let mcpFileCreated = false;
   if (mcpServers && Object.keys(mcpServers).length > 0) {
     try {
-      const mcpPath = (0, import_node_path19.join)(baseDir, rulesDir, ".mcp.json");
+      const mcpPath = (0, import_node_path18.join)(baseDir, rulesDir, ".mcp.json");
       const mcpContent = `${JSON.stringify({ mcpServers }, null, 2)}
 `;
       await writeFileContent(mcpPath, mcpContent);
@@ -2486,13 +2853,13 @@ async function importConfiguration(options) {
   };
 }
 function generateRuleFileContent(rule) {
-  const frontmatter = import_gray_matter4.default.stringify("", rule.frontmatter);
+  const frontmatter = import_gray_matter5.default.stringify("", rule.frontmatter);
   return frontmatter + rule.content;
 }
 async function generateUniqueFilename(rulesDir, baseFilename) {
   let filename = baseFilename;
   let counter = 1;
-  while (await fileExists((0, import_node_path19.join)(rulesDir, `${filename}.md`))) {
+  while (await fileExists((0, import_node_path18.join)(rulesDir, `${filename}.md`))) {
     filename = `${baseFilename}-${counter}`;
     counter++;
   }
@@ -2502,6 +2869,8 @@ async function generateUniqueFilename(rulesDir, baseFilename) {
 // src/cli/commands/import.ts
 async function importCommand(options = {}) {
   const tools = [];
+  if (options.augmentcode) tools.push("augmentcode");
+  if (options.augmentcodeLegacy) tools.push("augmentcode-legacy");
   if (options.claudecode) tools.push("claudecode");
   if (options.cursor) tools.push("cursor");
   if (options.copilot) tools.push("copilot");
@@ -2510,7 +2879,7 @@ async function importCommand(options = {}) {
   if (options.geminicli) tools.push("geminicli");
   if (tools.length === 0) {
     console.error(
-      "\u274C Please specify one tool to import from (--claudecode, --cursor, --copilot, --cline, --roo, --geminicli)"
+      "\u274C Please specify one tool to import from (--augmentcode, --augmentcodeLegacy, --claudecode, --cursor, --copilot, --cline, --roo, --geminicli)"
     );
     process.exit(1);
   }
@@ -2557,7 +2926,7 @@ async function importCommand(options = {}) {
 }
 
 // src/cli/commands/init.ts
-var import_node_path20 = require("path");
+var import_node_path19 = require("path");
 async function initCommand() {
   const aiRulesDir = ".rulesync";
   console.log("Initializing rulesync...");
@@ -2604,7 +2973,7 @@ globs: ["**/*"]
 - Follow single responsibility principle
 `
   };
-  const filepath = (0, import_node_path20.join)(aiRulesDir, sampleFile.filename);
+  const filepath = (0, import_node_path19.join)(aiRulesDir, sampleFile.filename);
   if (!await fileExists(filepath)) {
     await writeFileContent(filepath, sampleFile.content);
     console.log(`Created ${filepath}`);
@@ -2748,16 +3117,18 @@ 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.47.0");
+program.name("rulesync").description("Unified AI rules management CLI tool").version("0.49.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("--kiro", "Generate only for Kiro IDE").option("--delete", "Delete all existing files in output directories before generating").option(
+program.command("import").description("Import configurations from AI tools to rulesync format").option("--augmentcode", "Import from AugmentCode (.augment/rules/)").option("--augmentcodeLegacy", "Import from AugmentCode legacy format (.augment-guidelines)").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("--augmentcode", "Generate only for AugmentCode").option("--augmentcodeLegacy", "Generate only for AugmentCode legacy format").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) => {
   const tools = [];
+  if (options.augmentcode) tools.push("augmentcode");
+  if (options.augmentcodeLegacy) tools.push("augmentcode-legacy");
   if (options.copilot) tools.push("copilot");
   if (options.cursor) tools.push("cursor");
   if (options.cline) tools.push("cline");