Code review generator

Author: kush-duolingo

sync_ai_rules/__main__.py

@@ -50,25 +50,15 @@ def group_rules_by_category(rules: List[RuleMetadata]) -> Dict[str, List[RuleMet
     return groups
 
 
-def main():
-    """Main entry point."""
-    # Find project root
-    project_root = find_project_root()
-    rules_dir = os.path.join(project_root, ".cursor", "rules")
+def scan_rules_directory(
+    rules_dir: str, project_root: str, plugin_manager: PluginManager
+) -> List[RuleMetadata]:
+    """Scan a directory for rules and parse them."""
+    rules = []
 
     if not os.path.exists(rules_dir):
-        print(f"Error: Rules directory not found: {rules_dir}")
-        sys.exit(1)
-
-    print(f"Syncing rules from: {rules_dir}")
+        return rules
 
-    # Initialize plugin manager
-    script_dir = os.path.dirname(os.path.abspath(__file__))
-    plugin_manager = PluginManager()
-    plugin_manager.load_plugins(script_dir)
-
-    # Scan for rules using available parsers
-    rules = []
     for root, dirs, files in os.walk(rules_dir):
         # Skip generated and personal directories
         if "generated" in Path(root).parts or "personal" in Path(root).parts:
@@ -84,6 +74,7 @@ def main():
 
             # Create parsing context
             context = {
+                "project_root": project_root,
                 "relative_path": os.path.relpath(file_path, project_root),
                 "category": get_category(file_path, rules_dir),
             }
@@ -93,40 +84,80 @@ def main():
             if rule:
                 rules.append(rule)
 
-    if not rules:
-        print("No rules found to sync")
-        return
+    return rules
 
-    # Group rules by category
-    grouped_rules = group_rules_by_category(rules)
 
-    # Get markdown generator
-    generator = plugin_manager.get_generator("markdown")
-    if not generator:
-        print("Error: Markdown generator not found")
+def main():
+    """Main entry point."""
+    # Find project root
+    project_root = find_project_root()
+    cursor_rules_dir = os.path.join(project_root, ".cursor", "rules")
+    code_review_dir = os.path.join(project_root, ".code_review")
+
+    if not os.path.exists(cursor_rules_dir) and not os.path.exists(code_review_dir):
+        print("Error: Neither .cursor/rules nor .code_review directory found")
         sys.exit(1)
 
-    # Generate content
-    content = generator.generate(grouped_rules, {})
+    # Initialize plugin manager
+    script_dir = os.path.dirname(os.path.abspath(__file__))
+    plugin_manager = PluginManager()
+    plugin_manager.load_plugins(script_dir)
+
+    # Scan development rules (.cursor/rules/)
+    print(f"Scanning development rules from: {cursor_rules_dir}")
+    dev_rules = scan_rules_directory(cursor_rules_dir, project_root, plugin_manager)
+    grouped_dev_rules = group_rules_by_category(dev_rules)
+
+    # Scan code review guidelines (.code_review/)
+    print(f"Scanning code review guidelines from: {code_review_dir}")
+    review_rules = scan_rules_directory(code_review_dir, project_root, plugin_manager)
+    grouped_review_rules = group_rules_by_category(review_rules)
 
     # Print summary
-    total_rules = sum(len(rules) for rules in grouped_rules.values())
-    print(f"\nFound {total_rules} rules in {len(grouped_rules)} categories")
+    total_dev_rules = sum(len(rules) for rules in grouped_dev_rules.values())
+    total_review_rules = sum(len(rules) for rules in grouped_review_rules.values())
+    print(f"\nFound {total_dev_rules} development rules in {len(grouped_dev_rules)} categories")
+    print(
+        f"Found {total_review_rules} code review guidelines in {len(grouped_review_rules)} categories"
+    )
+
+    # Get generators
+    dev_generator = plugin_manager.get_generator("development-rules")
+    review_generator = plugin_manager.get_generator("code-review-guidelines")
+
+    if not dev_generator or not review_generator:
+        print("Error: Required generators not found")
+        sys.exit(1)
+
+    # Generate content for both sections
+    dev_content = dev_generator.generate(grouped_dev_rules, {}) if dev_rules else None
+    review_content = review_generator.generate(grouped_review_rules, {}) if review_rules else None
 
-    # Update output files using generator's default filenames
+    # Update output files (both generators use same target files)
     output_files = [
-        os.path.join(project_root, filename) for filename in generator.default_filenames
+        os.path.join(project_root, filename) for filename in dev_generator.default_filenames
     ]
 
     for file_path in output_files:
-        success, message = update_documentation_file(
-            file_path, content, generator.get_section_markers()
-        )
-
-        if success:
-            print(f"✓ {message}")
-        else:
-            print(f"✗ {message}")
+        # Update development rules section
+        if dev_content:
+            success, message = update_documentation_file(
+                file_path, dev_content, dev_generator.get_section_markers()
+            )
+            if success:
+                print(f"✓ Development rules: {message}")
+            else:
+                print(f"✗ Development rules: {message}")
+
+        # Update code review guidelines section
+        if review_content:
+            success, message = update_documentation_file(
+                file_path, review_content, review_generator.get_section_markers()
+            )
+            if success:
+                print(f"✓ Code review guidelines: {message}")
+            else:
+                print(f"✗ Code review guidelines: {message}")
 
     print("\n✓ Rules synchronization completed!")
 

sync_ai_rules/generators/code_review_guidelines_generator.py

@@ -0,0 +1,76 @@
+#!/usr/bin/env python3
+"""
+Code Review Guidelines Generator plugin - generates review guidelines for Codex.
+"""
+
+from typing import Any, Dict, List
+
+from sync_ai_rules.core.interfaces import OutputGenerator, RuleMetadata
+
+
+class CodeReviewGuidelinesGenerator(OutputGenerator):
+    """Generate code review guidelines documentation from .code_review/ rules."""
+
+    @property
+    def name(self) -> str:
+        return "code-review-guidelines"
+
+    @property
+    def default_filenames(self) -> List[str]:
+        return [
+            "CLAUDE.md",
+            "AGENTS.md",
+            ".github/copilot-instructions.md",
+        ]
+
+    def generate(self, rules: Dict[str, List[RuleMetadata]], config: Dict[str, Any]) -> str:
+        """Generate review guidelines content with XML tags."""
+        lines = [
+            "<code-review-guidelines>",
+            "<!-- DO NOT EDIT THIS SECTION - Auto-generated from .code_review/ -->",
+            "",
+            "## Review guidelines",
+            "",
+        ]
+
+        # Sort categories (root comes last)
+        sorted_categories = sorted(rules.keys(), key=lambda x: (x == "root", x))
+
+        for category in sorted_categories:
+            category_rules = rules[category]
+            if not category_rules:
+                continue
+
+            # Add category heading (skip for root or if only one category)
+            if category != "root" and len(sorted_categories) > 1:
+                heading = self._format_heading(category)
+                lines.append(f"### {heading}")
+                lines.append("")
+
+            # Add each rule
+            for rule in sorted(category_rules, key=lambda r: r.title):
+                lines.extend(self._format_rule(rule))
+                lines.append("")
+
+        lines.append("</code-review-guidelines>")
+        return "\n".join(lines)
+
+    def get_section_markers(self) -> tuple[str, str]:
+        """Return XML tags for the auto-generated section."""
+        return ("<code-review-guidelines>", "</code-review-guidelines>")
+
+    def _format_heading(self, category: str) -> str:
+        """Format category as heading."""
+        # Convert folder name to title case
+        return category.replace("-", " ").title()
+
+    def _format_rule(self, rule: RuleMetadata) -> List[str]:
+        """Format individual rule as markdown."""
+        # Use @ prefix for rule path
+        rule_path = f"@{rule.relative_path}"
+
+        return [
+            f"**{rule.title}** → `{rule_path}`",
+            "",
+            f"- **Description**: {rule.description or 'No description provided'}",
+        ]

…i_rules/generators/markdown_generator.py …enerators/development_rules_generator.pysync_ai_rules/generators/markdown_generator.py renamed to sync_ai_rules/generators/development_rules_generator.py sync_ai_rules/generators/markdown_generator.py renamed to sync_ai_rules/generators/development_rules_generator.py

@@ -1,19 +1,19 @@
 #!/usr/bin/env python3
 """
-Markdown Generator plugin - generates markdown documentation with XML tags.
+Development Rules Generator plugin - generates development rules documentation with XML tags.
 """
 
 from typing import Any, Dict, List
 
 from sync_ai_rules.core.interfaces import OutputGenerator, RuleMetadata
 
 
-class MarkdownGenerator(OutputGenerator):
-    """Generate markdown documentation from rules."""
+class DevelopmentRulesGenerator(OutputGenerator):
+    """Generate development rules documentation from .cursor/rules/."""
 
     @property
     def name(self) -> str:
-        return "markdown"
+        return "development-rules"
 
     @property
     def default_filenames(self) -> List[str]:

sync_ai_rules/parsers/code_review_parser.py

@@ -0,0 +1,97 @@
+#!/usr/bin/env python3
+"""
+Code Review Parser plugin - parses code review markdown files with HTML comment frontmatter.
+"""
+
+import re
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+from sync_ai_rules.core.interfaces import InputParser, RuleMetadata
+
+
+class CodeReviewParser(InputParser):
+    """Parse code review markdown files from .code_review/ directory."""
+
+    @property
+    def name(self) -> str:
+        return "code-review"
+
+    @property
+    def supported_extensions(self) -> list[str]:
+        return [".md"]
+
+    def can_parse(self, file_path: str) -> bool:
+        """Check if this parser can handle the given file."""
+        return ".code_review" in file_path and file_path.endswith(".md")
+
+    def parse(self, file_path: str, context: Dict[str, Any]) -> Optional[RuleMetadata]:
+        """Parse a code review markdown file and extract metadata."""
+        try:
+            with open(file_path, encoding="utf-8") as f:
+                content = f.read()
+
+            # Extract HTML comment frontmatter
+            metadata = self._parse_frontmatter(content)
+            if not metadata:
+                return None
+
+            # Extract category from directory structure
+            path = Path(file_path)
+            category = self._extract_category(path, context.get("project_root"))
+
+            # Get relative path from project root
+            project_root = Path(context.get("project_root", "."))
+            relative_path = path.relative_to(project_root)
+
+            return RuleMetadata(
+                file_path=file_path,
+                relative_path=str(relative_path),
+                title=metadata.get("name", path.stem.replace("-", " ").title()),
+                description=metadata.get("description", ""),
+                scope_patterns=[],  # Code review rules don't have file scope
+                always_apply=False,  # Code review rules are always contextual
+                category=category,
+                raw_content=content,
+                metadata=metadata,
+            )
+
+        except Exception as e:
+            print(f"Error parsing {file_path}: {e}")
+            return None
+
+    def _parse_frontmatter(self, content: str) -> Dict[str, str]:
+        """Parse HTML comment frontmatter from markdown content."""
+        # Match HTML comment block at start of file
+        # Pattern: <!--\nname: ...\ndescription: ...\n-->
+        pattern = r"^<!--\s*\n(.*?)\n-->"
+        match = re.search(pattern, content, re.MULTILINE | re.DOTALL)
+
+        if not match:
+            return {}
+
+        frontmatter_text = match.group(1)
+        metadata = {}
+
+        # Parse key: value pairs
+        for line in frontmatter_text.split("\n"):
+            line = line.strip()
+            if ":" in line:
+                key, value = line.split(":", 1)
+                metadata[key.strip()] = value.strip()
+
+        return metadata
+
+    def _extract_category(self, file_path: Path, project_root: Optional[str]) -> str:
+        """Extract category from directory structure."""
+        # Find .code_review in the path
+        parts = file_path.parts
+        try:
+            code_review_idx = parts.index(".code_review")
+            # Category is the directory immediately after .code_review
+            if code_review_idx + 1 < len(parts) - 1:  # -1 because last part is filename
+                return parts[code_review_idx + 1]
+        except (ValueError, IndexError):
+            pass
+
+        return "root"

sync_ai_rules/plugins.yaml

@@ -8,8 +8,18 @@ parsers:
     class: MDCParser
     description: Parse MDC files with YAML frontmatter
 
+  - name: code-review
+    module: code_review_parser
+    class: CodeReviewParser
+    description: Parse code review markdown files from .code_review/
+
 generators:
-  - name: markdown
-    module: markdown_generator
-    class: MarkdownGenerator
-    description: Generate markdown documentation with XML tags
+  - name: development-rules
+    module: development_rules_generator
+    class: DevelopmentRulesGenerator
+    description: Generate development rules documentation from .cursor/rules/
+
+  - name: code-review-guidelines
+    module: code_review_guidelines_generator
+    class: CodeReviewGuidelinesGenerator
+    description: Generate code review guidelines documentation from .code_review/