diff --git a/application/tests/harvester_test/__init__.py b/application/tests/harvester_test/__init__.py new file mode 100644 index 000000000..06b0f7440 --- /dev/null +++ b/application/tests/harvester_test/__init__.py @@ -0,0 +1,3 @@ +""" +tests for Module A configuration layer (empty for now) +""" diff --git a/application/tests/harvester_test/change_detector_test.py b/application/tests/harvester_test/change_detector_test.py new file mode 100644 index 000000000..a74590fd8 --- /dev/null +++ b/application/tests/harvester_test/change_detector_test.py @@ -0,0 +1,52 @@ +import unittest +from unittest.mock import MagicMock +from unittest.mock import patch + +from application.utils.harvester.change_detector import ( + ChangeDetector, +) + + +class ChangeDetectorTests(unittest.TestCase): + @patch("application.utils.harvester.change_detector.subprocess.run") + def test_get_modified_files_since(self, mock_run): + mock_run.return_value = MagicMock( + stdout="a.md\nb.md\na.md\n", + ) + + client = MagicMock() + detector = ChangeDetector(client) + + files = detector.get_modified_files_since("abc123") + + self.assertEqual( + files, + [ + "a.md", + "b.md", + ], + ) + + @patch("application.utils.harvester.change_detector.subprocess.run") + def test_get_commits_since(self, mock_run): + mock_run.return_value = MagicMock( + stdout="111\n222\n333\n", + ) + + client = MagicMock() + detector = ChangeDetector(client) + + commits = detector.get_commits_since("abc123") + + self.assertEqual( + commits, + [ + "111", + "222", + "333", + ], + ) + + +if __name__ == "__main__": + unittest.main() diff --git a/application/tests/harvester_test/checkpoint_store_test.py b/application/tests/harvester_test/checkpoint_store_test.py new file mode 100644 index 000000000..9859b1fed --- /dev/null +++ b/application/tests/harvester_test/checkpoint_store_test.py @@ -0,0 +1,92 @@ +import unittest +from datetime import datetime +from pathlib import Path + +from application.utils.harvester.checkpoint_store import ( + CheckpointStore, +) +from application.utils.harvester.models import ( + RepositoryCheckpoint, +) + + +class CheckpointStoreTests(unittest.TestCase): + def test_save_and_load_checkpoint(self): + tmp_dir = Path(self._testMethodName) + + try: + store = CheckpointStore( + tmp_dir / "checkpoints.json", + ) + + checkpoint = RepositoryCheckpoint( + repository_id="owasp-asvs", + last_processed_commit="abc123", + updated_at=datetime.now(), + ) + + store.save(checkpoint) + + loaded = store.load("owasp-asvs") + + if loaded is None: + self.fail("Checkpoint should have been loaded") + + self.assertEqual( + loaded.last_processed_commit, + "abc123", + ) + + finally: + if tmp_dir.exists(): + import shutil + + shutil.rmtree(tmp_dir) + + def test_load_missing_file(self): + tmp_dir = Path(self._testMethodName) + + try: + store = CheckpointStore( + tmp_dir / "missing.json", + ) + + self.assertIsNone( + store.load("repo"), + ) + + finally: + if tmp_dir.exists(): + import shutil + + shutil.rmtree(tmp_dir) + + def test_load_missing_repository(self): + tmp_dir = Path(self._testMethodName) + + try: + store = CheckpointStore( + tmp_dir / "checkpoint.json", + ) + + store.save( + RepositoryCheckpoint( + repository_id="repo-a", + last_processed_commit="abc123", + updated_at=datetime.now(), + ) + ) + + self.assertIsNone( + store.load("repo-b"), + ) + + finally: + if tmp_dir.exists(): + import shutil + + shutil.rmtree(tmp_dir) + + +if __name__ == "__main__": + unittest.main() diff --git a/application/tests/harvester_test/config_loader_test.py b/application/tests/harvester_test/config_loader_test.py new file mode 100644 index 000000000..01c404f18 --- /dev/null +++ b/application/tests/harvester_test/config_loader_test.py @@ -0,0 +1,63 @@ +from pathlib import Path +import unittest + +from application.utils.harvester.config_loader import ( + ConfigLoaderError, + ConfigFileNotFoundError, + load_repo_config, +) + +FIXTURES_DIR = Path(__file__).parent / "fixtures" + + +class ConfigLoaderTests(unittest.TestCase): + def test_load_valid_config(self): + config_path = FIXTURES_DIR / "valid_repos.yaml" + + config = load_repo_config(config_path) + + self.assertEqual(len(config.repositories), 1) + + repo = config.repositories[0] + + self.assertEqual(repo.id, "owasp-asvs") + self.assertEqual(repo.owner, "OWASP") + self.assertEqual(repo.repo, "ASVS") + + def test_missing_repository_id(self): + config_path = FIXTURES_DIR / "invalid_missing_id.yaml" + + with self.assertRaises(ConfigLoaderError): + load_repo_config(config_path) + + def test_invalid_chunk_size(self): + config_path = FIXTURES_DIR / "invalid_chunk_size.yaml" + + with self.assertRaisesRegex(ConfigLoaderError, "max_tokens"): + load_repo_config(config_path) + + def test_invalid_yaml_syntax(self): + config_path = FIXTURES_DIR / "invalid_yaml.yaml" + + with self.assertRaises(ConfigLoaderError): + load_repo_config(config_path) + + def test_missing_config_file(self): + with self.assertRaises(ConfigFileNotFoundError): + load_repo_config("does_not_exist.yaml") + + def test_invalid_polling_interval(self): + config_path = FIXTURES_DIR / "invalid_polling_interval.yaml" + + with self.assertRaises(ConfigLoaderError): + load_repo_config(config_path) + + def test_empty_include_paths(self): + config_path = FIXTURES_DIR / "empty_include_paths.yaml" + + with self.assertRaises(ConfigLoaderError): + load_repo_config(config_path) + + +if __name__ == "__main__": + unittest.main() diff --git a/application/tests/harvester_test/fixtures/duplicate_include_paths.yaml b/application/tests/harvester_test/fixtures/duplicate_include_paths.yaml new file mode 100644 index 000000000..5db642199 --- /dev/null +++ b/application/tests/harvester_test/fixtures/duplicate_include_paths.yaml @@ -0,0 +1,22 @@ +repositories: + - id: duplicate-includes + type: github + enabled: true + + owner: OWASP + repo: ASVS + branch: master + + paths: + include: + - "docs/**/*.md" + - "docs/**/*.md" + + chunking: + strategy: markdown_heading + max_tokens: 1200 + overlap_tokens: 100 + + polling: + mode: incremental + interval_minutes: 60 diff --git a/application/tests/harvester_test/fixtures/duplicate_repo_ids.yaml b/application/tests/harvester_test/fixtures/duplicate_repo_ids.yaml new file mode 100644 index 000000000..0cc4c1c1e --- /dev/null +++ b/application/tests/harvester_test/fixtures/duplicate_repo_ids.yaml @@ -0,0 +1,34 @@ +repositories: + - id: asvs + type: github + owner: OWASP + repo: ASVS + + paths: + include: + - "4.0/en/**/*.md" + + chunking: + strategy: markdown_heading + max_tokens: 1200 + + polling: + mode: incremental + interval_minutes: 60 + + - id: asvs + type: github + owner: OWASP + repo: CheatSheetSeries + + paths: + include: + - "cheatsheets/**/*.md" + + chunking: + strategy: markdown_heading + max_tokens: 1200 + + polling: + mode: incremental + interval_minutes: 60 diff --git a/application/tests/harvester_test/fixtures/duplicate_repositories.yaml b/application/tests/harvester_test/fixtures/duplicate_repositories.yaml new file mode 100644 index 000000000..41614d39c --- /dev/null +++ b/application/tests/harvester_test/fixtures/duplicate_repositories.yaml @@ -0,0 +1,34 @@ +repositories: + - id: asvs-1 + type: github + owner: OWASP + repo: ASVS + + paths: + include: + - "4.0/en/**/*.md" + + chunking: + strategy: markdown_heading + max_tokens: 1200 + + polling: + mode: incremental + interval_minutes: 60 + + - id: asvs-2 + type: github + owner: OWASP + repo: ASVS + + paths: + include: + - "4.0/en/**/*.md" + + chunking: + strategy: markdown_heading + max_tokens: 1200 + + polling: + mode: incremental + interval_minutes: 60 diff --git a/application/tests/harvester_test/fixtures/empty_include_paths.yaml b/application/tests/harvester_test/fixtures/empty_include_paths.yaml new file mode 100644 index 000000000..abe0bab41 --- /dev/null +++ b/application/tests/harvester_test/fixtures/empty_include_paths.yaml @@ -0,0 +1,16 @@ +repositories: + - id: asvs + type: github + owner: OWASP + repo: ASVS + + paths: + include: [] + + chunking: + strategy: markdown_heading + max_tokens: 1200 + + polling: + mode: incremental + interval_minutes: 60 diff --git a/application/tests/harvester_test/fixtures/empty_owner.yaml b/application/tests/harvester_test/fixtures/empty_owner.yaml new file mode 100644 index 000000000..8063a3f1b --- /dev/null +++ b/application/tests/harvester_test/fixtures/empty_owner.yaml @@ -0,0 +1,21 @@ +repositories: + - id: empty-owner + type: github + enabled: true + + owner: "" + repo: ASVS + branch: master + + paths: + include: + - "docs/**/*.md" + + chunking: + strategy: markdown_heading + max_tokens: 1200 + overlap_tokens: 100 + + polling: + mode: incremental + interval_minutes: 60 diff --git a/application/tests/harvester_test/fixtures/invalid_chunk_size.yaml b/application/tests/harvester_test/fixtures/invalid_chunk_size.yaml new file mode 100644 index 000000000..79d4cc8f0 --- /dev/null +++ b/application/tests/harvester_test/fixtures/invalid_chunk_size.yaml @@ -0,0 +1,18 @@ +repositories: + - id: owasp-asvs + + type: github + owner: OWASP + repo: ASVS + + paths: + include: + - "4.0/en/**/*.md" + + chunking: + strategy: markdown_heading + max_tokens: 0 + + polling: + mode: incremental + interval_minutes: 60 diff --git a/application/tests/harvester_test/fixtures/invalid_chunking_strategy.yaml b/application/tests/harvester_test/fixtures/invalid_chunking_strategy.yaml new file mode 100644 index 000000000..c4cb10905 --- /dev/null +++ b/application/tests/harvester_test/fixtures/invalid_chunking_strategy.yaml @@ -0,0 +1,21 @@ +repositories: + - id: invalid-strategy + type: github + enabled: true + + owner: OWASP + repo: ASVS + branch: master + + paths: + include: + - "docs/**/*.md" + + chunking: + strategy: invalid_strategy + max_tokens: 1200 + overlap_tokens: 100 + + polling: + mode: incremental + interval_minutes: 60 diff --git a/application/tests/harvester_test/fixtures/invalid_missing_id.yaml b/application/tests/harvester_test/fixtures/invalid_missing_id.yaml new file mode 100644 index 000000000..102e675b9 --- /dev/null +++ b/application/tests/harvester_test/fixtures/invalid_missing_id.yaml @@ -0,0 +1,17 @@ +repositories: + - type: github + + owner: OWASP + repo: ASVS + + paths: + include: + - "4.0/en/**/*.md" + + chunking: + strategy: markdown_heading + max_tokens: 1200 + + polling: + mode: incremental + interval_minutes: 60 diff --git a/application/tests/harvester_test/fixtures/invalid_polling_interval.yaml b/application/tests/harvester_test/fixtures/invalid_polling_interval.yaml new file mode 100644 index 000000000..3f34f8baa --- /dev/null +++ b/application/tests/harvester_test/fixtures/invalid_polling_interval.yaml @@ -0,0 +1,17 @@ +repositories: + - id: asvs + type: github + owner: OWASP + repo: ASVS + + paths: + include: + - "4.0/en/**/*.md" + + chunking: + strategy: markdown_heading + max_tokens: 1200 + + polling: + mode: incremental + interval_minutes: 0 diff --git a/application/tests/harvester_test/fixtures/invalid_polling_mode.yaml b/application/tests/harvester_test/fixtures/invalid_polling_mode.yaml new file mode 100644 index 000000000..0aead47ad --- /dev/null +++ b/application/tests/harvester_test/fixtures/invalid_polling_mode.yaml @@ -0,0 +1,21 @@ +repositories: + - id: invalid-polling + type: github + enabled: true + + owner: OWASP + repo: ASVS + branch: master + + paths: + include: + - "docs/**/*.md" + + chunking: + strategy: markdown_heading + max_tokens: 1200 + overlap_tokens: 100 + + polling: + mode: realtime + interval_minutes: 60 diff --git a/application/tests/harvester_test/fixtures/invalid_yaml.yaml b/application/tests/harvester_test/fixtures/invalid_yaml.yaml new file mode 100644 index 000000000..c60d3e23b --- /dev/null +++ b/application/tests/harvester_test/fixtures/invalid_yaml.yaml @@ -0,0 +1,4 @@ +repositories: + - id: broken + paths: + include: [unclosed diff --git a/application/tests/harvester_test/fixtures/valid_repos.yaml b/application/tests/harvester_test/fixtures/valid_repos.yaml new file mode 100644 index 000000000..fe52c8430 --- /dev/null +++ b/application/tests/harvester_test/fixtures/valid_repos.yaml @@ -0,0 +1,16 @@ +repositories: + - id: owasp-asvs + type: github + owner: OWASP + repo: ASVS + paths: + include: + - "4.0/en/**/*.md" + + chunking: + strategy: markdown_heading + max_tokens: 1200 + + polling: + mode: incremental + interval_minutes: 60 diff --git a/application/tests/harvester_test/git_repository_client_test.py b/application/tests/harvester_test/git_repository_client_test.py new file mode 100644 index 000000000..4f548a8be --- /dev/null +++ b/application/tests/harvester_test/git_repository_client_test.py @@ -0,0 +1,138 @@ +import unittest +from unittest.mock import patch + +from application.utils.harvester.git_repository_client import ( + GitRepositoryClient, +) + + +class GitRepositoryClientTests(unittest.TestCase): + def test_repository_url_generation(self): + client = GitRepositoryClient( + owner="OWASP", + repository="ASVS", + ) + + self.assertEqual( + client.repository_url, + "https://github.com/OWASP/ASVS.git", + ) + + def test_local_repository_path(self): + client = GitRepositoryClient( + owner="OWASP", + repository="ASVS", + ) + + self.assertEqual( + str(client.get_local_path()), + ".harvester_cache/owasp/asvs/main", + ) + + def test_repository_exists_locally_false(self): + client = GitRepositoryClient( + owner="OWASP", + repository="ASVS", + ) + + self.assertFalse(client.exists_locally()) + + def test_verify_repository_integrity_false(self): + client = GitRepositoryClient( + owner="OWASP", + repository="ASVS", + ) + + self.assertFalse(client.verify_repository_integrity()) + + def test_sync_clones_when_repository_missing(self): + client = GitRepositoryClient( + owner="OWASP", + repository="ASVS", + ) + + with ( + patch.object( + client, + "verify_repository_integrity", + return_value=False, + ), + patch.object(client, "clone") as mock_clone, + ): + client.sync() + + mock_clone.assert_called_once() + + def test_sync_fetches_when_repository_exists(self): + client = GitRepositoryClient( + owner="OWASP", + repository="ASVS", + ) + + with ( + patch.object( + client, + "verify_repository_integrity", + return_value=True, + ), + patch.object(client, "fetch") as mock_fetch, + ): + client.sync() + + mock_fetch.assert_called_once() + + @patch("application.utils.harvester.git_repository_client.subprocess.run") + def test_fetch_runs_git_command(self, mock_run): + client = GitRepositoryClient( + owner="OWASP", + repository="ASVS", + ) + + client.fetch() + + mock_run.assert_called_once() + + @patch("application.utils.harvester.git_repository_client.subprocess.run") + def test_checkout_runs_git_command(self, mock_run): + client = GitRepositoryClient( + owner="OWASP", + repository="ASVS", + ) + + client.checkout("main") + + mock_run.assert_called_once() + + @patch("application.utils.harvester.git_repository_client.subprocess.run") + def test_get_current_commit_sha_runs_git_command(self, mock_run): + mock_run.return_value.stdout = "abc123\n" + + client = GitRepositoryClient( + owner="OWASP", + repository="ASVS", + ) + + sha = client.get_current_commit_sha() + + self.assertEqual(sha, "abc123") + mock_run.assert_called_once() + + @patch("application.utils.harvester.git_repository_client.subprocess.run") + def test_clone_runs_git_command(self, mock_run): + client = GitRepositoryClient( + owner="OWASP", + repository="ASVS", + ) + + with patch.object( + client, + "verify_repository_integrity", + return_value=False, + ): + client.clone() + + mock_run.assert_called_once() + + +if __name__ == "__main__": + unittest.main() diff --git a/application/tests/harvester_test/repos_validator_test.py b/application/tests/harvester_test/repos_validator_test.py new file mode 100644 index 000000000..3e0347d41 --- /dev/null +++ b/application/tests/harvester_test/repos_validator_test.py @@ -0,0 +1,58 @@ +from pathlib import Path +import unittest + +from application.utils.harvester.config_loader import ( + load_repo_config, +) +from application.utils.harvester.repos_validator import ( + RepositoryValidationError, + validate_repositories, +) + +FIXTURES_DIR = Path(__file__).parent / "fixtures" + + +class ReposValidatorTests(unittest.TestCase): + def test_duplicate_repository_ids(self): + config_path = FIXTURES_DIR / "duplicate_repo_ids.yaml" + + config = load_repo_config(config_path) + + with self.assertRaisesRegex( + RepositoryValidationError, + "Duplicate repository id", + ): + validate_repositories(config) + + def test_duplicate_repositories(self): + config_path = FIXTURES_DIR / "duplicate_repositories.yaml" + + config = load_repo_config(config_path) + + with self.assertRaisesRegex( + RepositoryValidationError, + "Duplicate repository detected", + ): + validate_repositories(config) + + def test_duplicate_include_paths(self): + config_path = FIXTURES_DIR / "duplicate_include_paths.yaml" + + config = load_repo_config(config_path) + + with self.assertRaisesRegex( + RepositoryValidationError, + "duplicate include paths", + ): + validate_repositories(config) + + def test_validate_valid_repositories(self): + config_path = FIXTURES_DIR / "valid_repos.yaml" + + config = load_repo_config(config_path) + + validate_repositories(config) + + +if __name__ == "__main__": + unittest.main() diff --git a/application/tests/harvester_test/repository_cache_test.py b/application/tests/harvester_test/repository_cache_test.py new file mode 100644 index 000000000..a308239f1 --- /dev/null +++ b/application/tests/harvester_test/repository_cache_test.py @@ -0,0 +1,38 @@ +import unittest +from pathlib import Path + +from application.utils.harvester.repository_cache import ( + build_repository_cache_path, +) + + +class RepositoryCacheTests(unittest.TestCase): + def test_build_repository_cache_path(self): + path = build_repository_cache_path( + "OWASP", + "ASVS", + ) + + self.assertEqual( + path, + Path(".harvester_cache/owasp/asvs/main"), + ) + + def test_different_branches_have_different_cache_paths(self): + main_path = build_repository_cache_path( + owner="OWASP", + repository="ASVS", + branch="main", + ) + + dev_path = build_repository_cache_path( + owner="OWASP", + repository="ASVS", + branch="dev", + ) + + self.assertNotEqual(main_path, dev_path) + + +if __name__ == "__main__": + unittest.main() diff --git a/application/utils/harvester/__init__.py b/application/utils/harvester/__init__.py new file mode 100644 index 000000000..2ac608b3e --- /dev/null +++ b/application/utils/harvester/__init__.py @@ -0,0 +1,34 @@ +from .config_loader import ( + ConfigLoaderError, + load_repo_config, +) +from .repos_validator import ( + RepositoryValidationError, + validate_repositories, +) +from .schemas import ( + ChunkingConfig, + PathRules, + PollingConfig, + RepositoryConfig, + ReposFile, +) + +from .git_repository_client import GitRepositoryClient +from .repository_client import RepositoryClient +from .repository_cache import build_repository_cache_path + +__all__ = [ + "build_repository_cache_path", + "ChunkingConfig", + "ConfigLoaderError", + "GitRepositoryClient", + "PathRules", + "PollingConfig", + "RepositoryClient", + "RepositoryConfig", + "RepositoryValidationError", + "ReposFile", + "load_repo_config", + "validate_repositories", +] diff --git a/application/utils/harvester/change_detector.py b/application/utils/harvester/change_detector.py new file mode 100644 index 000000000..8b0153492 --- /dev/null +++ b/application/utils/harvester/change_detector.py @@ -0,0 +1,73 @@ +import logging +import subprocess + +from .git_repository_client import GitRepositoryClient + +logger = logging.getLogger(__name__) + + +class ChangeDetector: + def __init__(self, repository_client: GitRepositoryClient): + self.repository_client = repository_client + + def get_modified_files_since(self, commit_sha: str) -> list[str]: + logger.info( + "Detecting changes since commit %s", + commit_sha, + ) + + try: + result = subprocess.run( + [ + "git", + "-C", + str(self.repository_client.get_local_path()), + "diff", + "--name-only", + commit_sha, + "HEAD", + ], + capture_output=True, + text=True, + check=True, + timeout=60, + ) + except subprocess.CalledProcessError as exc: + logger.error("Git command failed: %s", exc.stderr) + raise + + files = [ + file_path for file_path in result.stdout.splitlines() if file_path.strip() + ] + + return sorted(set(files)) + + def get_commits_since(self, commit_sha: str) -> list[str]: + try: + result = subprocess.run( + [ + "git", + "-C", + str(self.repository_client.get_local_path()), + "log", + "--format=%H", + f"{commit_sha}..HEAD", + ], + capture_output=True, + text=True, + check=True, + timeout=60, + ) + except subprocess.CalledProcessError as exc: + logger.error("Git command failed: %s", exc.stderr) + raise + + commits = [sha for sha in result.stdout.splitlines() if sha.strip()] + + logger.info( + "Detected %s commits since %s", + len(commits), + commit_sha, + ) + + return commits diff --git a/application/utils/harvester/checkpoint_store.py b/application/utils/harvester/checkpoint_store.py new file mode 100644 index 000000000..1af13168c --- /dev/null +++ b/application/utils/harvester/checkpoint_store.py @@ -0,0 +1,64 @@ +import json +import os +from datetime import datetime +from pathlib import Path + +from .models import RepositoryCheckpoint + + +class CheckpointStore: + def __init__(self, checkpoint_file: Path): + self.checkpoint_file = checkpoint_file + + def load(self, repository_id: str) -> RepositoryCheckpoint | None: + if not self.checkpoint_file.exists(): + return None + + data = json.loads( + self.checkpoint_file.read_text( + encoding="utf-8", + ) + ) + + if repository_id not in data: + return None + + checkpoint = data[repository_id] + + return RepositoryCheckpoint( + repository_id=repository_id, + last_processed_commit=checkpoint["last_processed_commit"], + updated_at=datetime.fromisoformat( + checkpoint["updated_at"], + ), + ) + + def save(self, checkpoint: RepositoryCheckpoint) -> None: + data = {} + if self.checkpoint_file.exists(): + data = json.loads( + self.checkpoint_file.read_text( + encoding="utf-8", + ) + ) + + data[checkpoint.repository_id] = { + "last_processed_commit": checkpoint.last_processed_commit, + "updated_at": checkpoint.updated_at.isoformat(), + } + + self.checkpoint_file.parent.mkdir( + parents=True, + exist_ok=True, + ) + + temp_file = self.checkpoint_file.with_suffix(".tmp") + temp_file.write_text( + json.dumps( + data, + indent=2, + ), + encoding="utf-8", + ) + + os.replace(temp_file, self.checkpoint_file) diff --git a/application/utils/harvester/config_loader.py b/application/utils/harvester/config_loader.py new file mode 100644 index 000000000..db0431e11 --- /dev/null +++ b/application/utils/harvester/config_loader.py @@ -0,0 +1,32 @@ +from pathlib import Path +import yaml +from pydantic import ValidationError +from .schemas import ReposFile + + +class ConfigLoaderError(Exception): + """Base class for configuration loading errors.""" + + +class ConfigFileNotFoundError(ConfigLoaderError): + """Raised when the configuration file cannot be found.""" + + +def load_repo_config(path: str | Path) -> ReposFile: + config_path = Path(path) + + if not config_path.is_file(): + raise ConfigFileNotFoundError(f"Configuration file not found: {config_path}") + + try: + with config_path.open("r", encoding="utf-8") as file: + raw_config = yaml.safe_load(file) + except yaml.YAMLError as exc: + raise ConfigLoaderError(f"Invalid YAML syntax in {config_path}") from exc + + try: + return ReposFile.model_validate(raw_config) + except ValidationError as exc: + raise ConfigLoaderError( + f"Schema validation failed for {config_path}: {exc}" + ) from exc diff --git a/application/utils/harvester/exclude_patterns.txt b/application/utils/harvester/exclude_patterns.txt new file mode 100644 index 000000000..499850ae8 --- /dev/null +++ b/application/utils/harvester/exclude_patterns.txt @@ -0,0 +1,18 @@ +# Placeholder for repository-level exclude patterns. + +# This file will be consumed by the Week 4 noise-reduction pipeline + +# to filter non-documentation files during harvesting. + +**/.git/* +**/node_modules/** +**/__pycache__/** +**/.claude/** +**/.cursor/** +**/*.png +**/*.jpg +**/*.jpeg +**/*.svg +**/*.gif +**/*.pdf +**/archive/** diff --git a/application/utils/harvester/git_repository_client.py b/application/utils/harvester/git_repository_client.py new file mode 100644 index 000000000..eff7c17d6 --- /dev/null +++ b/application/utils/harvester/git_repository_client.py @@ -0,0 +1,185 @@ +import subprocess +from pathlib import Path + +from .repository_cache import build_repository_cache_path +from .repository_client import RepositoryClient +import logging + +logger = logging.getLogger(__name__) + + +class GitRepositoryClient(RepositoryClient): + def __init__(self, owner: str, repository: str, branch: str = "main") -> None: + self.owner = owner + self.repository = repository + self.branch = branch + + self.local_path = build_repository_cache_path( + owner, + repository, + branch, + ) + + @property + def repository_url(self) -> str: + return f"https://github.com/{self.owner}/{self.repository}.git" + + def clone(self) -> None: + if self.verify_repository_integrity(): + logger.warning( + "Repository %s/%s already exists locally", + self.owner, + self.repository, + ) + return + + logger.info( + "Cloning repository %s/%s", + self.owner, + self.repository, + ) + + self.local_path.parent.mkdir( + parents=True, + exist_ok=True, + ) + + try: + subprocess.run( + [ + "git", + "clone", + "--branch", + self.branch, + self.repository_url, + str(self.local_path), + ], + check=True, + capture_output=True, + text=True, + timeout=300, + ) + except subprocess.CalledProcessError as exc: + logger.error( + "Failed to clone repository %s/%s: %s", + self.owner, + self.repository, + exc.stderr, + ) + raise + + def fetch(self) -> None: + logger.info( + "Fetching repository %s/%s", + self.owner, + self.repository, + ) + + try: + subprocess.run( + [ + "git", + "-C", + str(self.local_path), + "fetch", + "--all", + ], + check=True, + capture_output=True, + text=True, + timeout=300, + ) + except subprocess.CalledProcessError as exc: + logger.error( + "Failed to fetch repository %s/%s: %s", + self.owner, + self.repository, + exc.stderr, + ) + raise + + def checkout(self, reference: str) -> None: + logger.info( + "Checking out %s in %s/%s", + reference, + self.owner, + self.repository, + ) + + try: + subprocess.run( + [ + "git", + "-C", + str(self.local_path), + "checkout", + "--", + reference, + ], + check=True, + capture_output=True, + text=True, + timeout=300, + ) + except subprocess.CalledProcessError as exc: + logger.error( + "Failed to checkout %s in %s/%s: %s", + reference, + self.owner, + self.repository, + exc.stderr, + ) + raise + + def get_local_path(self) -> Path: + return self.local_path + + def exists_locally(self) -> bool: + return self.local_path.exists() + + def sync(self) -> None: + logger.info( + "Synchronizing repository %s/%s", + self.owner, + self.repository, + ) + + if self.verify_repository_integrity(): + self.fetch() + else: + self.clone() + + def get_current_commit_sha(self) -> str: + try: + result = subprocess.run( + [ + "git", + "-C", + str(self.local_path), + "rev-parse", + "HEAD", + ], + check=True, + capture_output=True, + text=True, + timeout=300, + ) + except subprocess.CalledProcessError as exc: + logger.error( + "Failed to retrieve commit SHA for %s/%s: %s", + self.owner, + self.repository, + exc.stderr, + ) + raise + + return result.stdout.strip() + + def verify_repository_integrity(self) -> bool: + git_directory = self.local_path / ".git" + + return ( + self.local_path.exists() + and self.local_path.is_dir() + and git_directory.exists() + ) diff --git a/application/utils/harvester/models.py b/application/utils/harvester/models.py new file mode 100644 index 000000000..fe936535a --- /dev/null +++ b/application/utils/harvester/models.py @@ -0,0 +1,16 @@ +from dataclasses import dataclass +from datetime import datetime + + +@dataclass(slots=True) +class RepositoryCheckpoint: + repository_id: str + last_processed_commit: str | None + updated_at: datetime + + +@dataclass(slots=True) +class RepositoryChangeSet: + repository_id: str + commit_sha: str + modified_files: list[str] diff --git a/application/utils/harvester/repos.yaml b/application/utils/harvester/repos.yaml new file mode 100644 index 000000000..c448e5111 --- /dev/null +++ b/application/utils/harvester/repos.yaml @@ -0,0 +1,43 @@ +repositories: + - id: owasp-asvs + type: github + enabled: true + owner: OWASP + repo: ASVS + branch: master + paths: + include: + - "4.0/en/**/*.md" + + exclude: + - "**/archive/**" + + chunking: + strategy: markdown_heading + max_tokens: 1200 + overlap_tokens: 100 + + polling: + mode: incremental + interval_minutes: 60 + + - id: owasp-cheatsheets + type: github + enabled: true + + owner: OWASP + repo: CheatSheetSeries + branch: master + + paths: + include: + - "cheatsheets/**/*.md" + + chunking: + strategy: markdown_heading + max_tokens: 1000 + overlap_tokens: 100 + + polling: + mode: incremental + interval_minutes: 120 diff --git a/application/utils/harvester/repos_validator.py b/application/utils/harvester/repos_validator.py new file mode 100644 index 000000000..81cdc8273 --- /dev/null +++ b/application/utils/harvester/repos_validator.py @@ -0,0 +1,33 @@ +# as the name suggests +from .schemas import ReposFile + + +class RepositoryValidationError(Exception): + """Raised when repository configuration fails semantic validation.""" + + +def validate_repositories(config: ReposFile) -> None: + seen_ids: set[str] = set() + seen_repositories: set[tuple[str, str]] = set() + + for repository in config.repositories: + repo_id_key = repository.id.casefold() + if repo_id_key in seen_ids: + raise RepositoryValidationError( + f"Duplicate repository id found: {repository.id}" + ) + seen_ids.add(repo_id_key) + repository_key = ( + repository.owner.casefold(), + repository.repo.casefold(), + ) + if repository_key in seen_repositories: + raise RepositoryValidationError( + f"Duplicate repository detected: {repository.owner}/{repository.repo}" + ) + seen_repositories.add(repository_key) + include_patterns = set(repository.paths.include) + if len(include_patterns) != len(repository.paths.include): + raise RepositoryValidationError( + f"Repository '{repository.id}' has duplicate include paths" + ) diff --git a/application/utils/harvester/repository_cache.py b/application/utils/harvester/repository_cache.py new file mode 100644 index 000000000..418425681 --- /dev/null +++ b/application/utils/harvester/repository_cache.py @@ -0,0 +1,12 @@ +import os +from pathlib import Path + +CACHE_ROOT = Path(os.getenv("HARVESTER_CACHE_DIR", ".harvester_cache")) + + +def build_repository_cache_path( + owner: str, + repository: str, + branch: str = "main", +) -> Path: + return CACHE_ROOT / owner.casefold() / repository.casefold() / branch.casefold() diff --git a/application/utils/harvester/repository_client.py b/application/utils/harvester/repository_client.py new file mode 100644 index 000000000..c545cce42 --- /dev/null +++ b/application/utils/harvester/repository_client.py @@ -0,0 +1,36 @@ +from abc import ABC, abstractmethod +from pathlib import Path + + +class RepositoryClient(ABC): + @abstractmethod + def clone(self) -> None: + """Clone repository locally.""" + + @abstractmethod + def fetch(self) -> None: + """Fetch latest repository changes.""" + + @abstractmethod + def checkout(self, reference: str) -> None: + """Checkout a branch, tag, or commit.""" + + @abstractmethod + def get_local_path(self) -> Path: + """Return local repository path.""" + + @abstractmethod + def exists_locally(self) -> bool: + """Return whether repository exists locally.""" + + @abstractmethod + def sync(self) -> None: + """Clone if missing, otherwise fetch latest changes.""" + + @abstractmethod + def get_current_commit_sha(self) -> str: + """Return HEAD commit SHA.""" + + @abstractmethod + def verify_repository_integrity(self) -> bool: + """Verify local repository integrity.""" diff --git a/application/utils/harvester/schemas.py b/application/utils/harvester/schemas.py new file mode 100644 index 000000000..c65d62b60 --- /dev/null +++ b/application/utils/harvester/schemas.py @@ -0,0 +1,104 @@ +from typing import Literal +from pydantic import BaseModel, Field, ConfigDict, model_validator + + +# this will control which repo paths are included and excluded during ingestions +class PathRules(BaseModel): + model_config = ConfigDict(extra="forbid") + + include: list[str] = Field( + ..., + min_length=1, + description="Glob patterns to include during ingestions", + ) + exclude: list[str] = Field( + default_factory=list, description="Glob patterns to exclude during ingestions" + ) + + +# this will define how the harvested data should be chunked before downstream +class ChunkingConfig(BaseModel): + model_config = ConfigDict(extra="forbid") + + strategy: Literal["markdown_heading", "html_readability", "fixed_size"] = Field( + ..., + description="Chunking strategy used for text segmentation", + ) + + max_tokens: int = Field(..., gt=0, description="max token size per chunk") + + overlap_tokens: int = Field( + ge=0, + default=20, + description="token overlap between adjacent chunks", + ) + + @model_validator(mode="after") + def overlap_must_be_less_than_max(self) -> "ChunkingConfig": + if self.overlap_tokens >= self.max_tokens: + raise ValueError( + f"overlap_tokens ({self.overlap_tokens}) must be less than " + f"max_tokens ({self.max_tokens})" + ) + return self + + +# this one defines repository synchronize behaviour +class PollingConfig(BaseModel): + model_config = ConfigDict(extra="forbid") + + mode: Literal["full", "incremental"] = Field( + ..., description="repository sync mode" + ) + + interval_minutes: int = Field(..., gt=0, description="polling interval in minutes") + + +# top level repository ingestion configuration +class RepositoryConfig(BaseModel): + model_config = ConfigDict(extra="forbid") + + id: str = Field( + ..., + min_length=1, + description="unique repository identifier.", + ) + + type: Literal["github"] = Field( + ..., + description="repository source type.", + ) + enabled: bool = Field( + default=True, + description="whether ingestion is enabled for this repository.", + ) + owner: str = Field( + ..., + min_length=1, + description="repository organization.", + ) + repo: str = Field( + ..., + min_length=1, + description="repository name.", + ) + branch: str = Field( + default="main", + min_length=1, + description="Repository branch to ingest.", + ) + + paths: PathRules + chunking: ChunkingConfig + polling: PollingConfig + + +# Root configuration object loaded from repos.yaml. +class ReposFile(BaseModel): + model_config = ConfigDict(extra="forbid") + + repositories: list[RepositoryConfig] = Field( + ..., + min_length=1, + description="List of repositories configured for ingestion.", + )