Update plugins config

Author: kush-duolingo

sync_ai_rules/__main__.py

@@ -72,74 +72,55 @@ def scan_and_parse(parser, source_dir: str, project_root: str) -> List[RuleMetad
 
 
 def main():
-    """Main orchestration: load plugins → parse → generate → update files."""
+    """Main orchestration: load pipelines → parse → generate → update files."""
     # Setup
     project_root = find_project_root()
     script_dir = os.path.dirname(os.path.abspath(__file__))
 
     plugin_manager = PluginManager()
     plugin_manager.load_plugins(script_dir)
 
-    # Process each parser → generator pair
-    results = {}
+    if not plugin_manager.pipelines:
+        print("Error: No pipelines configured")
+        sys.exit(1)
 
-    for parser in plugin_manager.parsers.values():
-        # Get source directories from parser
-        source_dirs = parser.source_directories
-        if not source_dirs:
-            continue
+    # Get target files (all generators use same files)
+    first_generator = plugin_manager.pipelines[0].generator
+    output_files = [
+        os.path.join(project_root, filename) for filename in first_generator.default_filenames
+    ]
 
+    # Process each pipeline
+    print()
+    for pipeline in plugin_manager.pipelines:
+        print(f"Processing pipeline: {pipeline.name}")
+
+        # Scan and parse using pipeline's parser
         all_rules = []
-        for rel_dir in source_dirs:
+        for rel_dir in pipeline.parser.source_directories:
             source_dir = os.path.join(project_root, rel_dir)
-            print(f"Scanning {rel_dir}...")
-            rules = scan_and_parse(parser, source_dir, project_root)
+            print(f"  Scanning {rel_dir}...")
+            rules = scan_and_parse(pipeline.parser, source_dir, project_root)
             all_rules.extend(rules)
 
         if not all_rules:
+            print("  No rules found, skipping")
             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 and update documentation
-    print("\nGenerating documentation...")
-
-    # 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 first_generator.default_filenames
-    ]
-
-    # 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, {})
+        # Generate content using pipeline's generator
+        content = pipeline.generator.generate(grouped_rules, {})
 
         # Update all target files
         for file_path in output_files:
             success, message = update_documentation_file(
-                file_path, content, generator.get_section_markers()
+                file_path, content, pipeline.generator.get_section_markers()
             )
             status = "✓" if success else "✗"
-            print(f"{status} {generator.name}: {message}")
+            print(f"  {status} {message}")
 
     print("\n✓ Rules synchronization completed!")
 

sync_ai_rules/core/interfaces.py

@@ -6,7 +6,10 @@
 
 from abc import ABC, abstractmethod
 from dataclasses import dataclass
-from typing import Any, Dict, List, Optional
+from typing import TYPE_CHECKING, Any, Dict, List, Optional
+
+if TYPE_CHECKING:
+    from .interfaces import InputParser, OutputGenerator
 
 
 @dataclass
@@ -28,6 +31,16 @@ def __post_init__(self):
             self.metadata = {}
 
 
+@dataclass
+class Pipeline:
+    """Represents a parser-generator pipeline."""
+
+    name: str
+    description: str
+    parser: "InputParser"
+    generator: "OutputGenerator"
+
+
 class InputParser(ABC):
     """Abstract base class for all input parsers."""
 

sync_ai_rules/core/plugin_manager.py

@@ -1,27 +1,25 @@
 #!/usr/bin/env python3
 """
-Plugin manager for loading parsers and generators from explicit configuration.
+Plugin manager for loading parser-generator pipelines from configuration.
 """
 
 import importlib.util
 from pathlib import Path
-from typing import Dict, Optional
+from typing import List
 
 import yaml
 
-from .interfaces import InputParser, OutputGenerator
+from .interfaces import InputParser, OutputGenerator, Pipeline
 
 
 class PluginManager:
-    """Loads and manages parser and generator plugins from configuration."""
+    """Loads and manages parser-generator pipelines from configuration."""
 
     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
+        self.pipelines: List[Pipeline] = []
 
     def load_plugins(self, base_path: str):
-        """Load all plugins from plugins.yaml configuration file."""
+        """Load all pipelines from plugins.yaml configuration file."""
         config_path = Path(base_path) / "plugins.yaml"
 
         if not config_path.exists():
@@ -32,65 +30,55 @@ def load_plugins(self, base_path: str):
             with open(config_path) as f:
                 config = yaml.safe_load(f)
 
-            # 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", []):
-                self._load_generator(base_path, generator_config)
+            # Load pipelines
+            for pipeline_config in config.get("pipelines", []):
+                pipeline = self._load_pipeline(base_path, pipeline_config)
+                if pipeline:
+                    self.pipelines.append(pipeline)
+                    print(f"✓ Loaded pipeline: {pipeline.name} - {pipeline.description}")
 
         except Exception as e:
             print(f"✗ Failed to load plugin configuration: {e}")
 
-    def _load_parser(self, base_path: str, config: dict):
-        """Load a specific parser from configuration."""
-        try:
-            module_path = Path(base_path) / "parsers" / f"{config['module']}.py"
-            spec = importlib.util.spec_from_file_location(
-                f"parsers.{config['module']}", module_path
-            )
-            module = importlib.util.module_from_spec(spec)
-            spec.loader.exec_module(module)
-
-            # Get the specified class
-            parser_class = getattr(module, config["class"])
-            parser = parser_class()
-            self.parsers[parser.name] = parser
-            print(f"✓ Loaded parser: {parser.name} ({config['description']})")
-
-        except Exception as e:
-            print(f"✗ Failed to load parser {config['name']}: {e}")
-
-    def _load_generator(self, base_path: str, config: dict):
-        """Load a specific generator from configuration."""
+    def _load_pipeline(self, base_path: str, config: dict) -> Pipeline:
+        """Load a single parser-generator pipeline."""
         try:
-            module_path = Path(base_path) / "generators" / f"{config['module']}.py"
-            spec = importlib.util.spec_from_file_location(
-                f"generators.{config['module']}", module_path
+            # Load parser
+            parser_config = config["parser"]
+            parser = self._load_parser(base_path, parser_config)
+
+            # Load generator
+            generator_config = config["generator"]
+            generator = self._load_generator(base_path, generator_config)
+
+            # Create pipeline
+            return Pipeline(
+                name=config["name"],
+                description=config["description"],
+                parser=parser,
+                generator=generator,
             )
-            module = importlib.util.module_from_spec(spec)
-            spec.loader.exec_module(module)
-
-            # Get the specified class
-            generator_class = getattr(module, config["class"])
-            generator = generator_class()
-            self.generators[generator.name] = generator
-            print(f"✓ Loaded generator: {generator.name} ({config['description']})")
 
         except Exception as e:
-            print(f"✗ Failed to load generator {config['name']}: {e}")
-
-    def get_parser_for_file(self, file_path: str) -> Optional[InputParser]:
-        """Get appropriate parser for a file."""
-        for parser in self.parsers.values():
-            if parser.can_parse(file_path):
-                return parser
-        return None
-
-    def get_generator(self, name: str) -> Optional[OutputGenerator]:
-        """Get generator by name."""
-        return self.generators.get(name)
+            print(f"✗ Failed to load pipeline {config.get('name', 'unknown')}: {e}")
+            return None
+
+    def _load_parser(self, base_path: str, config: dict) -> InputParser:
+        """Load a parser from configuration."""
+        module_path = Path(base_path) / "parsers" / f"{config['module']}.py"
+        spec = importlib.util.spec_from_file_location(f"parsers.{config['module']}", module_path)
+        module = importlib.util.module_from_spec(spec)
+        spec.loader.exec_module(module)
+
+        parser_class = getattr(module, config["class"])
+        return parser_class()
+
+    def _load_generator(self, base_path: str, config: dict) -> OutputGenerator:
+        """Load a generator from configuration."""
+        module_path = Path(base_path) / "generators" / f"{config['module']}.py"
+        spec = importlib.util.spec_from_file_location(f"generators.{config['module']}", module_path)
+        module = importlib.util.module_from_spec(spec)
+        spec.loader.exec_module(module)
+
+        generator_class = getattr(module, config["class"])
+        return generator_class()

sync_ai_rules/plugins.yaml

@@ -1,29 +1,22 @@
 # Plugin configuration for sync_ai_rules
-# This file explicitly lists which parsers and generators to load,
-# making the plugin system more traceable and explicit.
+# Define rule processing pipelines: each pipeline has a parser and generator.
+# Parsers and generators can be reused across multiple pipelines.
 
-parsers:
-  - name: mdc
-    module: mdc_parser
-    class: MDCParser
-    description: Parse MDC files with YAML frontmatter
-    generator: development-rules # Which generator uses this parser's output
-
-  - name: code-review
-    module: code_review_parser
-    class: CodeReviewParser
-    description: Parse code review markdown files from .code_review/
-    generator: code-review-guidelines # Which generator uses this parser's output
-
-generators:
+pipelines:
   - name: development-rules
-    module: development_rules_generator
-    class: DevelopmentRulesGenerator
     description: Generate development rules documentation from .cursor/rules/
-    parser: mdc # Which parser provides input for this generator
+    parser:
+      module: mdc_parser
+      class: MDCParser
+    generator:
+      module: development_rules_generator
+      class: DevelopmentRulesGenerator
 
   - name: code-review-guidelines
-    module: code_review_guidelines_generator
-    class: CodeReviewGuidelinesGenerator
     description: Generate code review guidelines documentation from .code_review/
-    parser: code-review # Which parser provides input for this generator
+    parser:
+      module: code_review_parser
+      class: CodeReviewParser
+    generator:
+      module: code_review_guidelines_generator
+      class: CodeReviewGuidelinesGenerator