Breakup interfaces, remove unnecessary defensiveness

Author: kush-duolingo

sync_ai_rules/__main__.py

@@ -9,8 +9,8 @@
 from pathlib import Path
 from typing import Dict, List
 
-from sync_ai_rules.core.interfaces import RuleMetadata
 from sync_ai_rules.core.plugin_manager import PluginManager
+from sync_ai_rules.core.rule_metadata import RuleMetadata
 from sync_ai_rules.file_updater import update_documentation_file
 
 

sync_ai_rules/core/generator_interface.py

@@ -0,0 +1,31 @@
+#!/usr/bin/env python3
+"""
+Output generator interface.
+"""
+
+from abc import ABC, abstractmethod
+from typing import Any, Dict, List
+
+from sync_ai_rules.core.rule_metadata import RuleMetadata
+
+
+class OutputGenerator(ABC):
+    """Abstract base class for all output generators."""
+
+    @property
+    @abstractmethod
+    def name(self) -> str:
+        """Unique name for this generator."""
+
+    @property
+    @abstractmethod
+    def default_filenames(self) -> List[str]:
+        """Default output filenames."""
+
+    @abstractmethod
+    def generate(self, rules: Dict[str, List[RuleMetadata]], config: Dict[str, Any]) -> str:
+        """Generate output content from grouped rules."""
+
+    @abstractmethod
+    def get_section_markers(self) -> tuple[str, str]:
+        """Return start and end markers for auto-generated section."""

sync_ai_rules/core/interfaces.py

@@ -0,0 +1,40 @@
+#!/usr/bin/env python3
+"""
+Input parser interface.
+"""
+
+from abc import ABC, abstractmethod
+from typing import Any, Dict, List, Optional
+
+from sync_ai_rules.core.rule_metadata import RuleMetadata
+
+
+class InputParser(ABC):
+    """Abstract base class for all input parsers."""
+
+    @property
+    @abstractmethod
+    def name(self) -> str:
+        """Unique name for this parser."""
+
+    @property
+    @abstractmethod
+    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."""
+
+    @abstractmethod
+    def parse(self, file_path: str, context: Dict[str, Any]) -> Optional[RuleMetadata]:
+        """Parse a file and return standardized metadata."""

sync_ai_rules/core/parser_interface.py

@@ -0,0 +1,21 @@
+#!/usr/bin/env python3
+"""
+Pipeline data model for parser-generator pairs.
+"""
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from sync_ai_rules.core.generator_interface import OutputGenerator
+    from sync_ai_rules.core.parser_interface import InputParser
+
+
+@dataclass
+class Pipeline:
+    """Represents a parser-generator pipeline."""
+
+    name: str
+    description: str
+    parser: "InputParser"
+    generator: "OutputGenerator"

sync_ai_rules/core/pipeline.py

@@ -9,7 +9,9 @@
 
 import yaml
 
-from .interfaces import InputParser, OutputGenerator, Pipeline
+from sync_ai_rules.core.generator_interface import OutputGenerator
+from sync_ai_rules.core.parser_interface import InputParser
+from sync_ai_rules.core.pipeline import Pipeline
 
 
 class PluginManager:
@@ -22,46 +24,33 @@ def load_plugins(self, base_path: str):
         """Load all pipelines from plugins.yaml configuration file."""
         config_path = Path(base_path) / "plugins.yaml"
 
-        if not config_path.exists():
-            print(f"✗ Plugin configuration not found: {config_path}")
-            return
+        with open(config_path) as f:
+            config = yaml.safe_load(f)
 
-        try:
-            with open(config_path) as f:
-                config = yaml.safe_load(f)
-
-            # 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}")
+        # 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}")
 
     def _load_pipeline(self, base_path: str, config: dict) -> Pipeline:
         """Load a single parser-generator pipeline."""
-        try:
-            # 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,
-            )
-
-        except Exception as e:
-            print(f"✗ Failed to load pipeline {config.get('name', 'unknown')}: {e}")
-            return None
+        # 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,
+        )
 
     def _load_parser(self, base_path: str, config: dict) -> InputParser:
         """Load a parser from configuration."""

sync_ai_rules/core/plugin_manager.py

@@ -0,0 +1,26 @@
+#!/usr/bin/env python3
+"""
+Rule metadata data model.
+"""
+
+from dataclasses import dataclass
+from typing import Any, Dict, List
+
+
+@dataclass
+class RuleMetadata:
+    """Universal rule representation, format-agnostic."""
+
+    file_path: str
+    relative_path: str
+    title: str
+    description: str
+    scope_patterns: List[str]
+    always_apply: bool
+    category: str
+    raw_content: str
+    metadata: Dict[str, Any] = None
+
+    def __post_init__(self):
+        if self.metadata is None:
+            self.metadata = {}

sync_ai_rules/core/rule_metadata.py

@@ -71,8 +71,8 @@ def update_documentation_file(
             else:
                 # No existing section, append to end
                 if content and not content.endswith("\n"):
-                    content += "\n"
-                if content:
+                    content += "\n\n"
+                elif content:
                     content += "\n"
                 updated_content = content + new_section
                 operation = "added"
@@ -90,5 +90,5 @@ def update_documentation_file(
 
         return True, f"Successfully {operation} rules section in {file_path}"
 
-    except Exception as e:
+    except (FileNotFoundError, PermissionError, UnicodeDecodeError, OSError) as e:
         return False, f"Failed to update {file_path}: {e}"

sync_ai_rules/file_updater.py

@@ -6,7 +6,8 @@
 from abc import abstractmethod
 from typing import List
 
-from sync_ai_rules.core.interfaces import OutputGenerator, RuleMetadata
+from sync_ai_rules.core.generator_interface import OutputGenerator
+from sync_ai_rules.core.rule_metadata import RuleMetadata
 
 
 class BaseGenerator(OutputGenerator):

sync_ai_rules/generators/base_generator.py

@@ -5,7 +5,7 @@
 
 from typing import Any, Dict, List
 
-from sync_ai_rules.core.interfaces import RuleMetadata
+from sync_ai_rules.core.rule_metadata import RuleMetadata
 from sync_ai_rules.generators.base_generator import BaseGenerator