Merge pull request steam-bell-92#1856 from jyotish6699/feat/bidirectional-registry-validation

feat: add bidirectional repository consistency validation to registry validator

Author: steam-bell-92

tests/test_registry_validator.py

@@ -188,7 +188,11 @@ def test_missing_project_file(tmp_path):
     validator = RegistryValidator(registry)
     validator.validate()
 
-    assert any("missing project file" in e.lower() for e in validator.errors)
+    assert any(
+        "registered project not found in repository"
+        in e.lower()
+        for e in validator.errors
+    )
 
 def test_invalid_json(tmp_path):
     registry = tmp_path / "projects_registry.json"
@@ -300,7 +304,79 @@ def test_json_report(tmp_path, capsys):
 
     output = json.loads(captured.out)
 
+    assert "repository_consistency" in output
+
+    assert output["repository_consistency"] == {
+        "unregistered_projects": []
+    }
+
     assert output["projects"] == 1
     assert output["errors"] == 0
     assert output["warnings"] == 0
-    assert output["status"] == "passed"
+    assert output["status"] == "passed"
+
+
+def test_unregistered_repository_project(tmp_path):
+    """Repository project should be reported if missing from registry."""
+
+    utilities = tmp_path / "utilities"
+    utilities.mkdir()
+
+    project = utilities / "DemoProject"
+    project.mkdir()
+
+    (project / "DemoProject.py").write_text(
+        "print('hello')",
+        encoding="utf-8",
+    )
+
+    registry = write_registry(tmp_path, [])
+
+    validator = RegistryValidator(registry)
+
+    validator.validate()
+
+    assert "utilities/DemoProject" in validator.unregistered_projects
+
+    assert any(
+        "missing from registry" in error.lower()
+        for error in validator.errors
+    )
+
+
+def test_repository_consistency_passes(tmp_path):
+    """Registry and repository should be fully synchronized."""
+
+    utilities = tmp_path / "utilities"
+    utilities.mkdir()
+
+    project = utilities / "DemoProject"
+    project.mkdir()
+
+    (project / "DemoProject.py").write_text(
+        "print('hello')",
+        encoding="utf-8",
+    )
+
+    registry = write_registry(
+        tmp_path,
+        [
+            {
+                "name": "Demo",
+                "emoji": "🔥",
+                "category": "utilities",
+                "difficulty": "beginner",
+                "description": "Demo project",
+                "keywords": ["demo"],
+                "path": "utilities/DemoProject/DemoProject.py",
+            }
+        ],
+    )
+
+    validator = RegistryValidator(registry)
+
+    validator.validate()
+
+    assert validator.unregistered_projects == []
+
+

utils/registry_validator.py

@@ -42,6 +42,7 @@ def __init__(self, registry_path: str = "projects_registry.json"):
         self.registry_path = Path(registry_path)
         self.errors = []
         self.warnings = []
+        self.unregistered_projects = []
         self.projects = []
         self.validation_status = "PENDING"
 
@@ -156,9 +157,26 @@ def validate_project_paths(self):
 
             if not project_file.exists():
                 self.errors.append(
-                    f"Missing project file: {path}"
+                    f"Registered project not found in repository: {path}"
                 )
 
+    def validate_repository_consistency(self):
+        """Validate repository and registry consistency."""
+
+        registry_dirs = self.get_registry_project_directories()
+        discovered_dirs = self.discover_repository_projects()
+
+        unregistered_projects = sorted(
+            discovered_dirs - registry_dirs
+        )
+
+        self.unregistered_projects = unregistered_projects
+
+        for project in self.unregistered_projects:
+            self.errors.append(
+                f"Project exists in repository but is missing from registry: {project}"
+            )
+
     def validate_keywords(self):
         """Validate keywords field."""
 
@@ -177,6 +195,76 @@ def validate_keywords(self):
                     f"{project['name']} has no keywords."
                 )
 
+    def get_scan_directories(self):
+        """Return repository roots that contain projects."""
+
+        root = self.registry_path.parent
+
+        return {
+            directory.name
+            for directory in root.iterdir()
+            if directory.is_dir()
+            and directory.name != "__pycache__"
+            and not directory.name.startswith(".")
+        }
+
+    def get_registry_project_directories(self):
+        """Return project directories defined in the registry."""
+
+        registry_dirs = set()
+
+        for project in self.projects:
+            path = project.get("path")
+
+            if not path:
+                continue
+
+            registry_dirs.add(
+                Path(path).parent.as_posix()
+            )
+
+        return registry_dirs
+
+    def discover_repository_projects(self):
+        """Discover project directories from the repository."""
+
+        root = self.registry_path.parent
+        discovered_projects = set()
+
+        for directory_name in self.get_scan_directories():
+            directory = root / directory_name
+
+            if (
+                not directory.exists()
+                or not directory.is_dir()
+            ):
+                continue
+
+            # Standalone project (e.g. expression_parser)
+            if directory_name == "expression_parser":
+                if any(directory.glob("*.py")):
+                    discovered_projects.add(
+                        directory.relative_to(root).as_posix()
+                    )
+                continue
+
+            # Category containing project folders
+            for project_dir in directory.iterdir():
+                if not project_dir.is_dir():
+                    continue
+
+                if project_dir.name == "__pycache__":
+                    continue
+
+                # Only consider directories that contain at least one
+                # top-level Python file.
+                if any(project_dir.glob("*.py")):
+                    discovered_projects.add(
+                        project_dir.relative_to(root).as_posix()
+                    )
+
+        return discovered_projects
+
     def validate(self):
         """Run all validation checks."""
 
@@ -191,6 +279,7 @@ def validate(self):
         self.validate_duplicate_names()
         self.validate_duplicate_paths()
         self.validate_project_paths()
+        self.validate_repository_consistency()
         self.validate_keywords()
 
         if self.errors:
@@ -207,6 +296,9 @@ def report(self, json_output=False):
                         "errors": len(self.errors),
                         "warnings": len(self.warnings),
                         "status": self.validation_status.lower(),
+                        "repository_consistency": {
+                            "unregistered_projects": self.unregistered_projects,
+                        },
                     },
                     indent=2,
                 )
@@ -238,9 +330,23 @@ def report(self, json_output=False):
 
         if self.errors:
             print("\nErrors:")
+
             for error in self.errors:
+                if error.startswith(
+                    "Project exists in repository but is missing from registry:"
+                ):
+                    continue
+
                 print(f"  - {error}")
 
+        if self.unregistered_projects:
+            print("\nRepository Consistency:")
+
+            print("\n  Unregistered projects:")
+
+            for project in self.unregistered_projects:
+                print(f"    - {project}")
+
         if self.warnings:
             print("\nWarnings:")
             for warning in self.warnings: