Cleanup code

Author: kush-duolingo

sync_ai_rules/__main__.py

@@ -1,6 +1,7 @@
 #!/usr/bin/env python3
 """
-This script uses a plugin architecture to parse rules and generate documentation.
+Sync AI Rules - Plugin-based rule parser and documentation generator.
+Scans source directories, parses rules, and generates documentation sections.
 """
 
 import os
@@ -14,72 +15,55 @@
 
 
 def find_project_root() -> str:
-    """Find the project root by looking for key indicators."""
+    """Find project root by looking for .cursor/rules or .code_review directories."""
     current = Path.cwd()
 
-    # Look for .cursor/rules directory
     for path in [current] + list(current.parents):
-        if (path / ".cursor" / "rules").exists():
+        if (path / ".cursor" / "rules").exists() or (path / ".code_review").exists():
             return str(path)
 
-    # Fallback to current directory
     return str(current)
 
 
-def get_category(file_path: str, rules_dir: str) -> str:
-    """Get category name from file path."""
-    rel_path = os.path.relpath(file_path, rules_dir)
+def get_category(file_path: str, source_dir: str) -> str:
+    """Extract category from file path relative to source directory."""
+    rel_path = os.path.relpath(file_path, source_dir)
     folder = os.path.dirname(rel_path)
+    return folder if folder and folder != "." else "root"
 
-    if not folder or folder == ".":
-        return "root"
-
-    return folder
-
-
-def group_rules_by_category(rules: List[RuleMetadata]) -> Dict[str, List[RuleMetadata]]:
-    """Group rules by their category."""
-    groups = {}
 
+def group_by_category(rules: List[RuleMetadata]) -> Dict[str, List[RuleMetadata]]:
+    """Group rules by category."""
+    groups: Dict[str, List[RuleMetadata]] = {}
     for rule in rules:
-        category = rule.category
-        if category not in groups:
-            groups[category] = []
-        groups[category].append(rule)
-
+        groups.setdefault(rule.category, []).append(rule)
     return groups
 
 
-def scan_rules_directory(
-    rules_dir: str, project_root: str, plugin_manager: PluginManager
-) -> List[RuleMetadata]:
-    """Scan a directory for rules and parse them."""
+def scan_and_parse(parser, source_dir: str, project_root: str) -> List[RuleMetadata]:
+    """Scan directory and parse files with given parser."""
     rules = []
 
-    if not os.path.exists(rules_dir):
+    if not os.path.exists(source_dir):
         return rules
 
-    for root, dirs, files in os.walk(rules_dir):
-        # Skip generated and personal directories
+    for root, _, files in os.walk(source_dir):
+        # Skip generated/personal directories
         if "generated" in Path(root).parts or "personal" in Path(root).parts:
             continue
 
         for file in files:
             file_path = os.path.join(root, file)
 
-            # Find appropriate parser
-            parser = plugin_manager.get_parser_for_file(file_path)
-            if not parser:
+            if not parser.can_parse(file_path):
                 continue
 
-            # Create parsing context
             context = {
                 "project_root": project_root,
                 "relative_path": os.path.relpath(file_path, project_root),
-                "category": get_category(file_path, rules_dir),
+                "category": get_category(file_path, source_dir),
             }
 
-            # Parse the rule
             rule = parser.parse(file_path, context)
             if rule:
                 rules.append(rule)
@@ -88,76 +72,74 @@ def scan_rules_directory(
 
 
 def main():
-    """Main entry point."""
-    # Find project root
+    """Main orchestration: load plugins → parse → generate → update files."""
+    # Setup
     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)
-
-    # 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_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")
+    # Process each parser → generator pair
+    results = {}
+
+    for parser in plugin_manager.parsers.values():
+        # Get source directories from parser
+        source_dirs = parser.source_directories
+        if not source_dirs:
+            continue
+
+        all_rules = []
+        for rel_dir in source_dirs:
+            source_dir = os.path.join(project_root, rel_dir)
+            print(f"Scanning {rel_dir}...")
+            rules = scan_and_parse(parser, source_dir, project_root)
+            all_rules.extend(rules)
+
+        if not all_rules:
+            continue
+
+        # Group rules by category
+        grouped_rules = group_by_category(all_rules)
+
+        print(f"  Found {len(all_rules)} rules in {len(grouped_rules)} categories")
+
+        # Store for generator
+        results[parser.name] = grouped_rules
+
+    if not results:
+        print("Error: No rules found in any source directory")
         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
+    # Generate and update documentation
+    print("\nGenerating documentation...")
 
-    # Update output files (both generators use same target files)
+    # Get target files (all generators use same files)
+    first_generator = next(iter(plugin_manager.generators.values()))
     output_files = [
-        os.path.join(project_root, filename) for filename in dev_generator.default_filenames
+        os.path.join(project_root, filename) for filename in first_generator.default_filenames
     ]
 
-    for file_path in output_files:
-        # 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}")
+    # Generate content from each generator
+    for parser_name, grouped_rules in results.items():
+        # Get the generator for this parser
+        generator_name = plugin_manager.parser_to_generator.get(parser_name)
+        if not generator_name:
+            continue
+
+        generator = plugin_manager.generators.get(generator_name)
+        if not generator:
+            continue
+
+        content = generator.generate(grouped_rules, {})
 
-        # Update code review guidelines section
-        if review_content:
+        # Update all target files
+        for file_path in output_files:
             success, message = update_documentation_file(
-                file_path, review_content, review_generator.get_section_markers()
+                file_path, content, generator.get_section_markers()
             )
-            if success:
-                print(f"✓ Code review guidelines: {message}")
-            else:
-                print(f"✗ Code review guidelines: {message}")
+            status = "✓" if success else "✗"
+            print(f"{status} {generator.name}: {message}")
 
     print("\n✓ Rules synchronization completed!")
 

sync_ai_rules/core/interfaces.py

@@ -41,6 +41,15 @@ def name(self) -> str:
     def supported_extensions(self) -> List[str]:
         """File extensions this parser can handle."""
 
+    @property
+    def source_directories(self) -> List[str]:
+        """
+        Relative paths to directories this parser should scan.
+        Override in subclass if parser is specific to certain directories.
+        Returns empty list by default (scans all compatible files).
+        """
+        return []
+
     @abstractmethod
     def can_parse(self, file_path: str) -> bool:
         """Check if this parser can handle the given file."""

sync_ai_rules/core/plugin_manager.py

@@ -18,6 +18,7 @@ class PluginManager:
     def __init__(self):
         self.parsers: Dict[str, InputParser] = {}
         self.generators: Dict[str, OutputGenerator] = {}
+        self.parser_to_generator: Dict[str, str] = {}  # Maps parser name to generator name
 
     def load_plugins(self, base_path: str):
         """Load all plugins from plugins.yaml configuration file."""
@@ -34,6 +35,9 @@ def load_plugins(self, base_path: str):
             # Load parsers
             for parser_config in config.get("parsers", []):
                 self._load_parser(base_path, parser_config)
+                # Store parser -> generator mapping
+                if "generator" in parser_config:
+                    self.parser_to_generator[parser_config["name"]] = parser_config["generator"]
 
             # Load generators
             for generator_config in config.get("generators", []):

sync_ai_rules/generators/base_generator.py

@@ -0,0 +1,42 @@
+#!/usr/bin/env python3
+"""
+Base Generator - provides shared functionality for all generators.
+"""
+
+from abc import abstractmethod
+from typing import List
+
+from sync_ai_rules.core.interfaces import OutputGenerator, RuleMetadata
+
+
+class BaseGenerator(OutputGenerator):
+    """Base class for all generators with shared functionality."""
+
+    @property
+    def default_filenames(self) -> List[str]:
+        """Default target files for all generators."""
+        return [
+            "CLAUDE.md",
+            "AGENTS.md",
+            ".github/copilot-instructions.md",
+        ]
+
+    def _format_heading(self, category: str) -> str:
+        """Format category as heading."""
+        if category == "root":
+            return "Root Rules"
+
+        # Convert folder name to title case
+        return category.replace("-", " ").replace("_", " ").title()
+
+    def _sort_categories(self, categories: List[str]) -> List[str]:
+        """Sort categories with 'root' always last."""
+        return sorted(categories, key=lambda x: (x == "root", x))
+
+    def _sort_rules_by_title(self, rules: List[RuleMetadata]) -> List[RuleMetadata]:
+        """Sort rules alphabetically by title."""
+        return sorted(rules, key=lambda r: r.title)
+
+    @abstractmethod
+    def _format_rule(self, rule: RuleMetadata) -> List[str]:
+        """Format individual rule as markdown. Must be implemented by subclasses."""

sync_ai_rules/generators/code_review_guidelines_generator.py

@@ -5,24 +5,17 @@
 
 from typing import Any, Dict, List
 
-from sync_ai_rules.core.interfaces import OutputGenerator, RuleMetadata
+from sync_ai_rules.core.interfaces import RuleMetadata
+from sync_ai_rules.generators.base_generator import BaseGenerator
 
 
-class CodeReviewGuidelinesGenerator(OutputGenerator):
+class CodeReviewGuidelinesGenerator(BaseGenerator):
     """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 = [
@@ -34,7 +27,7 @@ def generate(self, rules: Dict[str, List[RuleMetadata]], config: Dict[str, Any])
         ]
 
         # Sort categories (root comes last)
-        sorted_categories = sorted(rules.keys(), key=lambda x: (x == "root", x))
+        sorted_categories = self._sort_categories(list(rules.keys()))
 
         for category in sorted_categories:
             category_rules = rules[category]
@@ -48,7 +41,7 @@ def generate(self, rules: Dict[str, List[RuleMetadata]], config: Dict[str, Any])
                 lines.append("")
 
             # Add each rule
-            for rule in sorted(category_rules, key=lambda r: r.title):
+            for rule in self._sort_rules_by_title(category_rules):
                 lines.extend(self._format_rule(rule))
                 lines.append("")
 
@@ -59,11 +52,6 @@ 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