rulesync 0.4.0 → 0.9.0

package/README.md

@@ -8,9 +8,10 @@ A Node.js CLI tool that automatically generates configuration files for various
 ## Supported Tools
 
 - **GitHub Copilot Custom Instructions** (`.github/instructions/*.instructions.md`)
-- **Cursor Project Rules** (`.cursor/rules/*.md`) 
+- **Cursor Project Rules** (`.cursor/rules/*.mdc`) 
 - **Cline Rules** (`.clinerules/*.md`)
-- **Claude Code Memory** (`./CLAUDE.md`)
+- **Claude Code Memory** (`./CLAUDE.md` + `.claude/memories/*.md`)
+- **Roo Code Rules** (`.roo/rules/*.md`)
 
 ## Installation
 
@@ -22,6 +23,132 @@ pnpm add -g rulesync
 yarn global add rulesync
 ```
 
+## Getting Started
+
+### Quick Start Example
+
+1. **Initialize your project:**
+   ```bash
+   rulesync init
+   ```
+
+2. **Create an overview file** (`.rulesync/overview.md`):
+   ```markdown
+   ---
+   root: true
+   targets: ["*"]
+   description: "Project overview and development philosophy"
+   globs: ["src/**/*.ts", "src/**/*.js"]
+   ---
+
+   # Project Development Guidelines
+
+   This is a TypeScript/JavaScript project following clean architecture principles.
+   We prioritize code readability, maintainability, and type safety.
+
+   ## Tech Stack
+   - TypeScript for type safety
+   - Node.js runtime
+   - Modern ES6+ features
+   ```
+
+3. **Create detail rules** (`.rulesync/coding-rules.md`):
+   ```markdown
+   ---
+   root: false
+   targets: ["copilot", "cursor", "cline"]
+   description: "TypeScript coding standards and best practices"
+   globs: ["**/*.ts", "**/*.tsx", "**/*.js", "**/*.jsx"]
+   ---
+
+   # TypeScript Coding Rules
+
+   ## Code Style
+   - Use strict TypeScript configuration
+   - Prefer `const` over `let` when possible
+   - Use meaningful, descriptive variable names
+   - Write JSDoc comments for public APIs
+
+   ## Type Definitions
+   - Prefer interfaces over types for object shapes
+   - Use union types for controlled values
+   - Avoid `any` type - use `unknown` instead
+   - Define return types for functions explicitly
+
+   ## Error Handling
+   - Use Result pattern for error handling
+   - Throw errors only for unexpected conditions
+   - Validate input parameters at function boundaries
+   ```
+
+4. **Generate configuration files:**
+   ```bash
+   rulesync generate
+   ```
+
+5. **Optional: Add generated files to .gitignore:**
+   ```bash
+   rulesync gitignore
+   ```
+
+This will create tool-specific configuration files that your AI coding assistants can use automatically.
+
+## Why rulesync?
+
+### 🔧 **Tool Flexibility**
+Team members can freely choose their preferred AI coding tools. Whether it's GitHub Copilot, Cursor, Cline, or Claude Code, each developer can use the tool that maximizes their productivity.
+
+### 📈 **Future-Proof Development**
+AI development tools evolve rapidly with new tools emerging frequently. With rulesync, switching between tools doesn't require redefining your rules from scratch.
+
+### 🎯 **Multi-Tool Workflow**
+Enable hybrid development workflows combining multiple AI tools:
+- GitHub Copilot for code completion
+- Cursor for refactoring
+- Claude Code for architecture design
+- Cline for debugging assistance
+
+### 🔓 **No Vendor Lock-in**
+Avoid vendor lock-in completely. If you decide to stop using rulesync, you can continue using the generated rule files (`.github/instructions/`, `.cursor/rules/`, `.clinerules/`, `CLAUDE.md`, etc.) as-is.
+
+### 🎯 **Consistency Across Tools**
+Apply consistent rules across all AI tools, improving code quality and development experience for the entire team.
+
+## Claude Code Integration
+
+### Creating Custom Slash Commands
+
+Instead of using Claude Code's built-in `/init` command, we recommend creating a custom slash command specifically for rulesync.
+
+Refer to the [Claude Code slash commands documentation](https://docs.anthropic.com/en/docs/claude-code/slash-commands) and add the following custom command:
+
+**`.claude/commands/init-rulesync.md`**
+
+```markdown
+Review this project's content and update .rulesync/*.md files as needed.
+
+Steps:
+1. Analyze project structure and codebase
+2. Review existing .rulesync/ files
+3. Consider project's tech stack, architecture, and coding conventions
+4. Update .rulesync/*.md files if missing elements or improvements are found
+5. Run rulesync generate if necessary
+
+Project characteristics to consider:
+- Technology stack
+- Architecture patterns
+- Coding conventions
+- Security requirements
+- Performance considerations
+```
+
+### Integration Benefits
+
+- **Project-Specific Initialization**: Optimized rule configuration for each project
+- **Automatic Rule Updates**: Rules adapt to project changes automatically
+- **Team Standardization**: All members use the same rule set
+- **Continuous Improvement**: Rules evolve with project growth
+
 ## Usage
 
 ### 1. Initialize
@@ -38,8 +165,8 @@ Define metadata in front matter for each Markdown file:
 
 ```markdown
 ---
-ruleLevel: overview # or detail
-targets: ["*"] # or [copilot, cursor, cline, claudecode]
+root: true # or false
+targets: ["*"] # or [copilot, cursor, cline, claude, roo]
 description: "TypeScript coding rules"
 globs: ["**/*.ts", "**/*.tsx"]
 ---
@@ -52,12 +179,26 @@ globs: ["**/*.ts", "**/*.tsx"]
 
 ### Rule Levels
 
-- **overview**: Project-wide overview and policies (only one file allowed)
-- **detail**: Specific implementation rules and detailed guidelines (multiple files allowed)
+rulesync uses a two-level rule system:
+
+- **root: true**: Project-wide overview and policies
+  - Only **one** root file is allowed per project
+  - Contains high-level guidelines and project context
+- **root: false**: Specific implementation rules and detailed guidelines
+  - Multiple non-root files are allowed
+  - Contains specific coding rules, naming conventions, etc.
+
+#### Tool-Specific Behavior
+
+Each AI tool handles rule levels differently:
 
-Each tool handles rule levels differently:
-- **Claude Code**: overview → `CLAUDE.md`, detail → `.claude/memories/*.md`
-- **Cursor**: overview → `ruletype: always`, detail → `ruletype: autoattached`
+| Tool | Root Rules | Non-Root Rules | Special Behavior |
+|------|------------|----------------|------------------|
+| **Claude Code** | `./CLAUDE.md` | `.claude/memories/*.md` | CLAUDE.md includes `@filename` references to detail files |
+| **Cursor** | `ruletype: always` | `ruletype: autoattached` | Detail rules without globs use `ruletype: agentrequested` |
+| **GitHub Copilot** | Standard format | Standard format | All rules use same format with frontmatter |
+| **Cline** | Standard format | Standard format | All rules use plain Markdown format |
+| **Roo Code** | Standard format | Standard format | All rules use plain Markdown format with description header |
 
 ### 3. Generate Configuration Files
 
@@ -70,62 +211,125 @@ rulesync generate --copilot
 rulesync generate --cursor  
 rulesync generate --cline
 rulesync generate --claude
+rulesync generate --roo
+
+# Clean build (delete existing files first)
+rulesync generate --delete
+
+# Clean build for specific tools
+rulesync generate --copilot --cursor --delete
+
+# Verbose output
+rulesync generate --verbose
+rulesync generate --delete --verbose
 ```
 
+#### Generate Options
+
+- `--delete`: Remove all existing generated files before creating new ones
+- `--verbose`: Show detailed output during generation process
+- `--copilot`, `--cursor`, `--cline`, `--claude`, `--roo`: Generate only for specified tools
+
 ### 4. Other Commands
 
 ```bash
-# Validate configuration
+# Initialize project with sample files
+rulesync init
+
+# Validate rule files
 rulesync validate
 
-# Check current status
+# Check current status  
 rulesync status
 
 # Watch files and auto-generate
 rulesync watch
+
+# Add generated files to .gitignore
+rulesync gitignore
 ```
 
 ## Configuration File Structure
 
 ```
 .rulesync/
-├── coding-rules.md      # Coding rules
-├── naming-conventions.md # Naming conventions
-├── architecture.md      # Architecture guidelines
-├── security.md          # Security rules
-└── custom.md           # Project-specific rules
+├── overview.md          # Project overview (root: true, only one)
+├── coding-rules.md      # Coding rules (root: false)
+├── naming-conventions.md # Naming conventions (root: false)
+├── architecture.md      # Architecture guidelines (root: false)  
+├── security.md          # Security rules (root: false)
+└── custom.md           # Project-specific rules (root: false)
 ```
 
-## Generated Configuration Files
+### Frontmatter Schema
 
-| Tool | Output Path | Format |
-|------|------------|--------|
-| GitHub Copilot | `.github/instructions/*.instructions.md` | Front Matter + Markdown |
-| Cursor | `.cursor/rules/*.md` | MDC (YAML header + Markdown) |
-| Cline | `.clinerules/*.md` | Plain Markdown |
-| Claude Code | `./CLAUDE.md` (overview), `.claude/memories/*.md` (detail) | Plain Markdown |
+Each rule file must include frontmatter with the following fields:
 
-## Development
+```yaml
+---
+root: true | false               # Required: Rule level (true for overview, false for details)
+targets: ["*"]                   # Required: Target tools (* = all, or specific tools)
+description: "Brief description" # Required: Rule description
+globs: ["**/*.ts", "**/*.js"]    # Required: File patterns (can be empty array)
+---
+```
 
-```bash
-# Install dependencies
-pnpm install
+### Example Files
 
-# Development run
-pnpm dev
+**Root file** (`.rulesync/overview.md`):
+```markdown
+---
+root: true
+targets: ["*"]
+description: "Project overview and development philosophy"
+globs: ["src/**/*.ts"]
+---
 
-# Build
-pnpm build
+# Project Development Guidelines
 
-# Test
-pnpm test
+This project follows TypeScript-first development with clean architecture principles.
+```
 
-# Code quality checks
-pnpm lint
-pnpm format
-pnpm secretlint
+**Non-root file** (`.rulesync/coding-rules.md`):
+```markdown
+---
+root: false
+targets: ["copilot", "cursor", "roo"]
+description: "TypeScript coding standards"
+globs: ["**/*.ts", "**/*.tsx"]
+---
+
+# TypeScript Coding Rules
+
+- Use strict TypeScript configuration
+- Prefer interfaces over types for object shapes
+- Use meaningful variable names
+```
+
+## Generated Configuration Files
+
+| Tool | Output Path | Format | Rule Level Handling |
+|------|------------|--------|-------------------|
+| **GitHub Copilot** | `.github/instructions/*.instructions.md` | Front Matter + Markdown | Both levels use same format |
+| **Cursor** | `.cursor/rules/*.mdc` | MDC (YAML header + Markdown) | Root: `ruletype: always`<br>Non-root: `ruletype: autoattached`<br>Non-root without globs: `ruletype: agentrequested` |
+| **Cline** | `.clinerules/*.md` | Plain Markdown | Both levels use same format |
+| **Claude Code** | `./CLAUDE.md` (root)<br>`.claude/memories/*.md` (non-root) | Plain Markdown | Root goes to CLAUDE.md<br>Non-root go to separate memory files<br>CLAUDE.md includes `@filename` references |
+| **Roo Code** | `.roo/rules/*.md` | Plain Markdown | Both levels use same format with description header |
+
+## Validation
+
+rulesync validates your rule files and provides helpful error messages:
+
+```bash
+rulesync validate
 ```
 
+Common validation rules:
+- Only one root file (root: true) is allowed per project
+- All frontmatter fields are required and properly formatted
+- File patterns (globs) use valid syntax
+- Target tools are recognized values
+
 ## License
 
 MIT License
@@ -134,4 +338,4 @@ MIT License
 
 Issues and Pull Requests are welcome!
 
-For detailed specifications, see [SPECIFICATION.md](./SPECIFICATION.md).
+For development setup and contribution guidelines, see [CONTRIBUTING.md](./CONTRIBUTING.md).

package/dist/index.js

@@ -30,9 +30,9 @@ var import_commander = require("commander");
 var import_node_path = require("path");
 async function generateClaudeConfig(rules, config) {
   const outputs = [];
-  const overviewRules = rules.filter((r) => r.frontmatter.ruleLevel === "overview");
-  const detailRules = rules.filter((r) => r.frontmatter.ruleLevel === "detail");
-  const claudeMdContent = generateClaudeMarkdown(overviewRules, detailRules);
+  const rootRules = rules.filter((r) => r.frontmatter.root === true);
+  const detailRules = rules.filter((r) => r.frontmatter.root === false);
+  const claudeMdContent = generateClaudeMarkdown(rootRules, detailRules);
   outputs.push({
     tool: "claude",
     filepath: (0, import_node_path.join)(config.outputPaths.claude, "CLAUDE.md"),
@@ -48,11 +48,13 @@ async function generateClaudeConfig(rules, config) {
   }
   return outputs;
 }
-function generateClaudeMarkdown(overviewRules, detailRules) {
+function generateClaudeMarkdown(rootRules, detailRules) {
   const lines = [];
   if (detailRules.length > 0) {
+    lines.push("Please also reference the following documents as needed:");
+    lines.push("");
     for (const rule of detailRules) {
-      lines.push(`@${rule.filename}`);
+      lines.push(`@.claude/memories/${rule.filename}.md`);
     }
     lines.push("");
   }
@@ -62,8 +64,8 @@ function generateClaudeMarkdown(overviewRules, detailRules) {
     "Generated from rulesync configuration. These instructions guide Claude Code's behavior for this project."
   );
   lines.push("");
-  if (overviewRules.length > 0) {
-    for (const rule of overviewRules) {
+  if (rootRules.length > 0) {
+    for (const rule of rootRules) {
       lines.push(...formatRuleForClaude(rule));
     }
   }
@@ -87,10 +89,6 @@ function formatRuleForClaude(rule) {
 }
 function generateMemoryFile(rule) {
   const lines = [];
-  lines.push("Please also refer to the following files as needed:");
-  lines.push("");
-  lines.push("---");
-  lines.push("");
   lines.push(`# ${rule.filename}`);
   lines.push("");
   if (rule.frontmatter.description) {
@@ -158,7 +156,6 @@ function generateCopilotMarkdown(rule) {
     lines.push('applyTo: "**"');
   }
   lines.push("---");
-  lines.push("");
   lines.push(rule.content);
   return lines.join("\n");
 }
@@ -169,7 +166,7 @@ async function generateCursorConfig(rules, config) {
   const outputs = [];
   for (const rule of rules) {
     const content = generateCursorMarkdown(rule);
-    const filepath = (0, import_node_path4.join)(config.outputPaths.cursor, `${rule.filename}.md`);
+    const filepath = (0, import_node_path4.join)(config.outputPaths.cursor, `${rule.filename}.mdc`);
     outputs.push({
       tool: "cursor",
       filepath,
@@ -186,15 +183,37 @@ function generateCursorMarkdown(rule) {
     lines.push(`globs: [${rule.frontmatter.globs.map((g) => `"${g}"`).join(", ")}]`);
   }
   let ruletype;
-  if (rule.frontmatter.ruleLevel === "overview") {
+  if (rule.frontmatter.root === true) {
     ruletype = "always";
-  } else if (rule.frontmatter.ruleLevel === "detail" && rule.frontmatter.globs.length === 0) {
+  } else if (rule.frontmatter.root === false && rule.frontmatter.globs.length === 0) {
     ruletype = "agentrequested";
   } else {
     ruletype = "autoattached";
   }
   lines.push(`ruletype: ${ruletype}`);
   lines.push("---");
+  lines.push(rule.content);
+  return lines.join("\n");
+}
+
+// src/generators/roo.ts
+var import_node_path5 = require("path");
+async function generateRooConfig(rules, config) {
+  const outputs = [];
+  for (const rule of rules) {
+    const content = generateRooMarkdown(rule);
+    const filepath = (0, import_node_path5.join)(config.outputPaths.roo, `${rule.filename}.md`);
+    outputs.push({
+      tool: "roo",
+      filepath,
+      content
+    });
+  }
+  return outputs;
+}
+function generateRooMarkdown(rule) {
+  const lines = [];
+  lines.push(`# ${rule.frontmatter.description}`);
   lines.push("");
   lines.push(rule.content);
   return lines.join("\n");
@@ -208,10 +227,11 @@ function getDefaultConfig() {
       copilot: ".github/instructions",
       cursor: ".cursor/rules",
       cline: ".clinerules",
-      claude: "."
+      claude: ".",
+      roo: ".roo/rules"
     },
     watchEnabled: false,
-    defaultTargets: ["copilot", "cursor", "cline", "claude"]
+    defaultTargets: ["copilot", "cursor", "cline", "claude", "roo"]
   };
 }
 function resolveTargets(targets, config) {
@@ -223,7 +243,7 @@ function resolveTargets(targets, config) {
 
 // src/utils/file.ts
 var import_promises = require("fs/promises");
-var import_node_path5 = require("path");
+var import_node_path6 = require("path");
 async function ensureDir(dirPath) {
   try {
     await (0, import_promises.stat)(dirPath);
@@ -235,13 +255,13 @@ async function readFileContent(filepath) {
   return (0, import_promises.readFile)(filepath, "utf-8");
 }
 async function writeFileContent(filepath, content) {
-  await ensureDir((0, import_node_path5.dirname)(filepath));
+  await ensureDir((0, import_node_path6.dirname)(filepath));
   await (0, import_promises.writeFile)(filepath, content, "utf-8");
 }
 async function findFiles(dir, extension = ".md") {
   try {
     const files = await (0, import_promises.readdir)(dir);
-    return files.filter((file) => file.endsWith(extension)).map((file) => (0, import_node_path5.join)(dir, file));
+    return files.filter((file) => file.endsWith(extension)).map((file) => (0, import_node_path6.join)(dir, file));
   } catch {
     return [];
   }
@@ -255,6 +275,11 @@ async function fileExists(filepath) {
   }
 }
 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_promises.rm)(dirPath, { recursive: true, force: true });
@@ -263,6 +288,25 @@ async function removeDirectory(dirPath) {
     console.warn(`Failed to remove directory ${dirPath}:`, error);
   }
 }
+async function removeFile(filepath) {
+  try {
+    if (await fileExists(filepath)) {
+      await (0, import_promises.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/core/generator.ts
 async function generateConfigurations(rules, config, targetTools) {
@@ -297,6 +341,8 @@ async function generateForTool(tool, rules, config) {
       return generateClineConfig(rules, config);
     case "claude":
       return await generateClaudeConfig(rules, config);
+    case "roo":
+      return generateRooConfig(rules, config);
     default:
       console.warn(`Unknown tool: ${tool}`);
       return null;
@@ -304,7 +350,7 @@ async function generateForTool(tool, rules, config) {
 }
 
 // src/core/parser.ts
-var import_node_path6 = require("path");
+var import_node_path7 = require("path");
 var import_gray_matter = __toESM(require("gray-matter"));
 async function parseRulesFromDirectory(aiRulesDir) {
   const ruleFiles = await findFiles(aiRulesDir);
@@ -324,7 +370,7 @@ async function parseRuleFile(filepath) {
   const parsed = (0, import_gray_matter.default)(content);
   validateFrontmatter(parsed.data, filepath);
   const frontmatter = parsed.data;
-  const filename = (0, import_node_path6.basename)(filepath, ".md");
+  const filename = (0, import_node_path7.basename)(filepath, ".md");
   return {
     frontmatter,
     content: parsed.content,
@@ -337,8 +383,8 @@ function validateFrontmatter(data, filepath) {
     throw new Error(`Invalid frontmatter in ${filepath}: must be an object`);
   }
   const obj = data;
-  if (!obj.ruleLevel || !["overview", "detail"].includes(obj.ruleLevel)) {
-    throw new Error(`Invalid ruleLevel in ${filepath}: must be "overview" or "detail"`);
+  if (typeof obj.root !== "boolean") {
+    throw new Error(`Invalid root in ${filepath}: must be a boolean`);
   }
   if (!Array.isArray(obj.targets)) {
     throw new Error(`Invalid targets in ${filepath}: must be an array`);
@@ -375,9 +421,11 @@ async function validateRules(rules) {
     }
     filenames.add(rule.filename);
   }
-  const overviewRules = rules.filter((rule) => rule.frontmatter.ruleLevel === "overview");
-  if (overviewRules.length > 1) {
-    errors.push(`Multiple overview rules found: ${overviewRules.map((r) => r.filename).join(", ")}. Only one overview rule is allowed.`);
+  const rootRules = rules.filter((rule) => rule.frontmatter.root === true);
+  if (rootRules.length > 1) {
+    errors.push(
+      `Multiple root rules found: ${rootRules.map((r) => r.filename).join(", ")}. Only one root rule is allowed.`
+    );
   }
   for (const rule of rules) {
     const ruleValidation = await validateRule(rule);
@@ -450,7 +498,10 @@ async function generateCommand(options = {}) {
             deleteTasks.push(removeDirectory(config.outputPaths.cline));
             break;
           case "claude":
-            deleteTasks.push(removeDirectory(config.outputPaths.claude));
+            deleteTasks.push(removeClaudeGeneratedFiles());
+            break;
+          case "roo":
+            deleteTasks.push(removeDirectory(config.outputPaths.roo));
             break;
         }
       }
@@ -478,15 +529,18 @@ async function generateCommand(options = {}) {
 
 // src/cli/commands/gitignore.ts
 var import_node_fs = require("fs");
-var import_node_path7 = require("path");
+var import_node_path8 = require("path");
 var gitignoreCommand = async () => {
-  const gitignorePath = (0, import_node_path7.join)(process.cwd(), ".gitignore");
+  const gitignorePath = (0, import_node_path8.join)(process.cwd(), ".gitignore");
   const rulesFilesToIgnore = [
     "# Generated by rulesync - AI tool configuration files",
+    ".github/copilot-instructions.md",
     ".github/instructions/",
     ".cursor/rules/",
     ".clinerules/",
-    "CLAUDE.md"
+    "CLAUDE.md",
+    ".claude/memories/",
+    ".roo/rules/"
   ];
   let gitignoreContent = "";
   if ((0, import_node_fs.existsSync)(gitignorePath)) {
@@ -517,7 +571,7 @@ ${linesToAdd.join("\n")}
 };
 
 // src/cli/commands/init.ts
-var import_node_path8 = require("path");
+var import_node_path9 = require("path");
 async function initCommand() {
   const aiRulesDir = ".rulesync";
   console.log("Initializing rulesync...");
@@ -607,7 +661,7 @@ globs: ["src/**/*.ts"]
     }
   ];
   for (const file of sampleFiles) {
-    const filepath = (0, import_node_path8.join)(aiRulesDir, file.filename);
+    const filepath = (0, import_node_path9.join)(aiRulesDir, file.filename);
     if (!await fileExists(filepath)) {
       await writeFileContent(filepath, file.content);
       console.log(`Created ${filepath}`);

package/dist/index.mjs

@@ -7,9 +7,9 @@ import { Command } from "commander";
 import { join } from "path";
 async function generateClaudeConfig(rules, config) {
   const outputs = [];
-  const overviewRules = rules.filter((r) => r.frontmatter.ruleLevel === "overview");
-  const detailRules = rules.filter((r) => r.frontmatter.ruleLevel === "detail");
-  const claudeMdContent = generateClaudeMarkdown(overviewRules, detailRules);
+  const rootRules = rules.filter((r) => r.frontmatter.root === true);
+  const detailRules = rules.filter((r) => r.frontmatter.root === false);
+  const claudeMdContent = generateClaudeMarkdown(rootRules, detailRules);
   outputs.push({
     tool: "claude",
     filepath: join(config.outputPaths.claude, "CLAUDE.md"),
@@ -25,11 +25,13 @@ async function generateClaudeConfig(rules, config) {
   }
   return outputs;
 }
-function generateClaudeMarkdown(overviewRules, detailRules) {
+function generateClaudeMarkdown(rootRules, detailRules) {
   const lines = [];
   if (detailRules.length > 0) {
+    lines.push("Please also reference the following documents as needed:");
+    lines.push("");
     for (const rule of detailRules) {
-      lines.push(`@${rule.filename}`);
+      lines.push(`@.claude/memories/${rule.filename}.md`);
     }
     lines.push("");
   }
@@ -39,8 +41,8 @@ function generateClaudeMarkdown(overviewRules, detailRules) {
     "Generated from rulesync configuration. These instructions guide Claude Code's behavior for this project."
   );
   lines.push("");
-  if (overviewRules.length > 0) {
-    for (const rule of overviewRules) {
+  if (rootRules.length > 0) {
+    for (const rule of rootRules) {
       lines.push(...formatRuleForClaude(rule));
     }
   }
@@ -64,10 +66,6 @@ function formatRuleForClaude(rule) {
 }
 function generateMemoryFile(rule) {
   const lines = [];
-  lines.push("Please also refer to the following files as needed:");
-  lines.push("");
-  lines.push("---");
-  lines.push("");
   lines.push(`# ${rule.filename}`);
   lines.push("");
   if (rule.frontmatter.description) {
@@ -135,7 +133,6 @@ function generateCopilotMarkdown(rule) {
     lines.push('applyTo: "**"');
   }
   lines.push("---");
-  lines.push("");
   lines.push(rule.content);
   return lines.join("\n");
 }
@@ -146,7 +143,7 @@ async function generateCursorConfig(rules, config) {
   const outputs = [];
   for (const rule of rules) {
     const content = generateCursorMarkdown(rule);
-    const filepath = join4(config.outputPaths.cursor, `${rule.filename}.md`);
+    const filepath = join4(config.outputPaths.cursor, `${rule.filename}.mdc`);
     outputs.push({
       tool: "cursor",
       filepath,
@@ -163,15 +160,37 @@ function generateCursorMarkdown(rule) {
     lines.push(`globs: [${rule.frontmatter.globs.map((g) => `"${g}"`).join(", ")}]`);
   }
   let ruletype;
-  if (rule.frontmatter.ruleLevel === "overview") {
+  if (rule.frontmatter.root === true) {
     ruletype = "always";
-  } else if (rule.frontmatter.ruleLevel === "detail" && rule.frontmatter.globs.length === 0) {
+  } else if (rule.frontmatter.root === false && rule.frontmatter.globs.length === 0) {
     ruletype = "agentrequested";
   } else {
     ruletype = "autoattached";
   }
   lines.push(`ruletype: ${ruletype}`);
   lines.push("---");
+  lines.push(rule.content);
+  return lines.join("\n");
+}
+
+// src/generators/roo.ts
+import { join as join5 } from "path";
+async function generateRooConfig(rules, config) {
+  const outputs = [];
+  for (const rule of rules) {
+    const content = generateRooMarkdown(rule);
+    const filepath = join5(config.outputPaths.roo, `${rule.filename}.md`);
+    outputs.push({
+      tool: "roo",
+      filepath,
+      content
+    });
+  }
+  return outputs;
+}
+function generateRooMarkdown(rule) {
+  const lines = [];
+  lines.push(`# ${rule.frontmatter.description}`);
   lines.push("");
   lines.push(rule.content);
   return lines.join("\n");
@@ -185,10 +204,11 @@ function getDefaultConfig() {
       copilot: ".github/instructions",
       cursor: ".cursor/rules",
       cline: ".clinerules",
-      claude: "."
+      claude: ".",
+      roo: ".roo/rules"
     },
     watchEnabled: false,
-    defaultTargets: ["copilot", "cursor", "cline", "claude"]
+    defaultTargets: ["copilot", "cursor", "cline", "claude", "roo"]
   };
 }
 function resolveTargets(targets, config) {
@@ -200,7 +220,7 @@ function resolveTargets(targets, config) {
 
 // src/utils/file.ts
 import { mkdir, readdir, readFile, rm, stat, writeFile } from "fs/promises";
-import { dirname, join as join5 } from "path";
+import { dirname, join as join6 } from "path";
 async function ensureDir(dirPath) {
   try {
     await stat(dirPath);
@@ -218,7 +238,7 @@ async function writeFileContent(filepath, content) {
 async function findFiles(dir, extension = ".md") {
   try {
     const files = await readdir(dir);
-    return files.filter((file) => file.endsWith(extension)).map((file) => join5(dir, file));
+    return files.filter((file) => file.endsWith(extension)).map((file) => join6(dir, file));
   } catch {
     return [];
   }
@@ -232,6 +252,11 @@ async function fileExists(filepath) {
   }
 }
 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 rm(dirPath, { recursive: true, force: true });
@@ -240,6 +265,25 @@ async function removeDirectory(dirPath) {
     console.warn(`Failed to remove directory ${dirPath}:`, error);
   }
 }
+async function removeFile(filepath) {
+  try {
+    if (await fileExists(filepath)) {
+      await 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/core/generator.ts
 async function generateConfigurations(rules, config, targetTools) {
@@ -274,6 +318,8 @@ async function generateForTool(tool, rules, config) {
       return generateClineConfig(rules, config);
     case "claude":
       return await generateClaudeConfig(rules, config);
+    case "roo":
+      return generateRooConfig(rules, config);
     default:
       console.warn(`Unknown tool: ${tool}`);
       return null;
@@ -314,8 +360,8 @@ function validateFrontmatter(data, filepath) {
     throw new Error(`Invalid frontmatter in ${filepath}: must be an object`);
   }
   const obj = data;
-  if (!obj.ruleLevel || !["overview", "detail"].includes(obj.ruleLevel)) {
-    throw new Error(`Invalid ruleLevel in ${filepath}: must be "overview" or "detail"`);
+  if (typeof obj.root !== "boolean") {
+    throw new Error(`Invalid root in ${filepath}: must be a boolean`);
   }
   if (!Array.isArray(obj.targets)) {
     throw new Error(`Invalid targets in ${filepath}: must be an array`);
@@ -352,9 +398,11 @@ async function validateRules(rules) {
     }
     filenames.add(rule.filename);
   }
-  const overviewRules = rules.filter((rule) => rule.frontmatter.ruleLevel === "overview");
-  if (overviewRules.length > 1) {
-    errors.push(`Multiple overview rules found: ${overviewRules.map((r) => r.filename).join(", ")}. Only one overview rule is allowed.`);
+  const rootRules = rules.filter((rule) => rule.frontmatter.root === true);
+  if (rootRules.length > 1) {
+    errors.push(
+      `Multiple root rules found: ${rootRules.map((r) => r.filename).join(", ")}. Only one root rule is allowed.`
+    );
   }
   for (const rule of rules) {
     const ruleValidation = await validateRule(rule);
@@ -427,7 +475,10 @@ async function generateCommand(options = {}) {
             deleteTasks.push(removeDirectory(config.outputPaths.cline));
             break;
           case "claude":
-            deleteTasks.push(removeDirectory(config.outputPaths.claude));
+            deleteTasks.push(removeClaudeGeneratedFiles());
+            break;
+          case "roo":
+            deleteTasks.push(removeDirectory(config.outputPaths.roo));
             break;
         }
       }
@@ -455,15 +506,18 @@ async function generateCommand(options = {}) {
 
 // src/cli/commands/gitignore.ts
 import { existsSync, readFileSync, writeFileSync } from "fs";
-import { join as join6 } from "path";
+import { join as join7 } from "path";
 var gitignoreCommand = async () => {
-  const gitignorePath = join6(process.cwd(), ".gitignore");
+  const gitignorePath = join7(process.cwd(), ".gitignore");
   const rulesFilesToIgnore = [
     "# Generated by rulesync - AI tool configuration files",
+    ".github/copilot-instructions.md",
     ".github/instructions/",
     ".cursor/rules/",
     ".clinerules/",
-    "CLAUDE.md"
+    "CLAUDE.md",
+    ".claude/memories/",
+    ".roo/rules/"
   ];
   let gitignoreContent = "";
   if (existsSync(gitignorePath)) {
@@ -494,7 +548,7 @@ ${linesToAdd.join("\n")}
 };
 
 // src/cli/commands/init.ts
-import { join as join7 } from "path";
+import { join as join8 } from "path";
 async function initCommand() {
   const aiRulesDir = ".rulesync";
   console.log("Initializing rulesync...");
@@ -584,7 +638,7 @@ globs: ["src/**/*.ts"]
     }
   ];
   for (const file of sampleFiles) {
-    const filepath = join7(aiRulesDir, file.filename);
+    const filepath = join8(aiRulesDir, file.filename);
     if (!await fileExists(filepath)) {
       await writeFileContent(filepath, file.content);
       console.log(`Created ${filepath}`);

package/package.json

@@ -1,71 +1,72 @@
 {
-  "name": "rulesync",
-  "version": "0.4.0",
-  "description": "Unified AI rules management CLI tool that generates configuration files for various AI development tools",
-  "main": "dist/index.js",
-  "module": "dist/index.mjs",
-  "types": "dist/index.d.ts",
-  "bin": {
-    "rulesync": "dist/index.js"
-  },
-  "files": [
-    "dist"
-  ],
-  "engines": {
-    "node": ">=20.0.0"
-  },
-  "keywords": [
-    "ai",
-    "rules",
-    "cli",
-    "copilot",
-    "cursor",
-    "cline",
-    "configuration",
-    "development"
-  ],
-  "author": "dyoshikawa",
-  "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/dyoshikawa/rulesync.git"
-  },
-  "bugs": {
-    "url": "https://github.com/dyoshikawa/rulesync/issues"
-  },
-  "homepage": "https://github.com/dyoshikawa/rulesync#readme",
-  "publishConfig": {
-    "access": "public"
-  },
-  "packageManager": "pnpm@7.33.7",
-  "devDependencies": {
-    "@biomejs/biome": "2.0.0",
-    "@secretlint/secretlint-rule-preset-recommend": "10.1.0",
-    "@tsconfig/node24": "24.0.1",
-    "@types/node": "24.0.3",
-    "@vitest/coverage-v8": "3.2.4",
-    "secretlint": "10.1.0",
-    "tsup": "8.5.0",
-    "tsx": "4.20.3",
-    "typescript": "5.8.3",
-    "vitest": "3.2.4"
-  },
-  "dependencies": {
-    "chokidar": "4.0.3",
-    "commander": "14.0.0",
-    "gray-matter": "4.0.3",
-    "marked": "15.0.12"
-  },
-  "scripts": {
-    "dev": "tsx src/cli/index.ts",
-    "build": "tsup src/cli/index.ts --format cjs,esm --dts --clean",
-    "lint": "biome lint src/",
-    "format": "biome format --write src/",
-    "format:check": "biome format src/",
-    "check": "biome check src/",
-    "secretlint": "secretlint \"**/*\"",
-    "test": "vitest",
-    "test:watch": "vitest --watch",
-    "test:coverage": "vitest --coverage"
-  }
-}
+	"name": "rulesync",
+	"version": "0.9.0",
+	"description": "Unified AI rules management CLI tool that generates configuration files for various AI development tools",
+	"main": "dist/index.js",
+	"module": "dist/index.mjs",
+	"types": "dist/index.d.ts",
+	"bin": {
+		"rulesync": "dist/index.js"
+	},
+	"files": [
+		"dist"
+	],
+	"scripts": {
+		"dev": "tsx src/cli/index.ts",
+		"build": "tsup src/cli/index.ts --format cjs,esm --dts --clean",
+		"lint": "biome lint src/",
+		"format": "biome format --write src/",
+		"format:check": "biome format src/",
+		"check": "biome check src/",
+		"secretlint": "secretlint \"**/*\"",
+		"test": "vitest",
+		"test:watch": "vitest --watch",
+		"test:coverage": "vitest --coverage",
+		"prepublishOnly": "pnpm build"
+	},
+	"engines": {
+		"node": ">=20.0.0"
+	},
+	"keywords": [
+		"ai",
+		"rules",
+		"cli",
+		"copilot",
+		"cursor",
+		"cline",
+		"configuration",
+		"development"
+	],
+	"author": "dyoshikawa",
+	"license": "MIT",
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/dyoshikawa/rulesync.git"
+	},
+	"bugs": {
+		"url": "https://github.com/dyoshikawa/rulesync/issues"
+	},
+	"homepage": "https://github.com/dyoshikawa/rulesync#readme",
+	"publishConfig": {
+		"access": "public"
+	},
+	"packageManager": "pnpm@7.33.7",
+	"devDependencies": {
+		"@biomejs/biome": "2.0.0",
+		"@secretlint/secretlint-rule-preset-recommend": "10.1.0",
+		"@tsconfig/node24": "24.0.1",
+		"@types/node": "24.0.3",
+		"@vitest/coverage-v8": "3.2.4",
+		"secretlint": "10.1.0",
+		"tsup": "8.5.0",
+		"tsx": "4.20.3",
+		"typescript": "5.8.3",
+		"vitest": "3.2.4"
+	},
+	"dependencies": {
+		"chokidar": "4.0.3",
+		"commander": "14.0.0",
+		"gray-matter": "4.0.3",
+		"marked": "15.0.12"
+	}
+}