feat: enhance registry validator with repository consistency checks

Add repository consistency validation to detect project directories that exist in the repository but are missing from the registry.

Improve project discovery by scanning repository project directories and comparing them against registered entries.

Enhance validation reporting with repository consistency information in both human-readable and JSON output.

Add comprehensive unit tests covering:
- Repository consistency validation
- Unregistered project detection
- Successful consistency validation
- Existing registry validation behavior

This helps maintainers keep projects_registry.json synchronized with the repository structure.

Author: jyotish6699

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: