From 0adf8ef5d9d5ec1a7dc9d03c0548c2e1a3d1ce50 Mon Sep 17 00:00:00 2001 From: Public Source Publisher Date: Thu, 1 Oct 2026 01:34:52 +0200 Subject: [PATCH] Initial curated RepoPulse source from 2524ccc3c1c27739996dccb2b7992989f88cd26d --- .dockerignore | 12 + .env.example | 40 + .gitignore | 28 + .gitleaks.toml | 9 + Dockerfile.unraid | 29 + PUBLIC_SOURCE_EXPORT.md | 3 + PUBLIC_SOURCE_MANIFEST.json | 446 +++ README.md | 90 + backend/Dockerfile | 19 + backend/app/__init__.py | 1 + backend/app/acquisition.py | 264 ++ backend/app/architecture.py | 340 ++ backend/app/git_analysis.py | 104 + backend/app/gitea.py | 314 ++ backend/app/jobs.py | 330 ++ backend/app/main.py | 491 +++ backend/app/models.py | 397 ++ backend/app/policy.py | 98 + backend/app/release_gate.py | 147 + backend/app/reporting.py | 75 + backend/app/rules.py | 83 + backend/app/scanner.py | 695 ++++ backend/app/signals.py | 494 +++ backend/app/store.py | 1527 ++++++++ backend/pyproject.toml | 23 + backend/tests/test_api.py | 122 + backend/tests/test_api_v11.py | 130 + backend/tests/test_architecture.py | 98 + backend/tests/test_gitea.py | 203 + backend/tests/test_jobs.py | 232 ++ backend/tests/test_maintenance.py | 175 + backend/tests/test_migrations.py | 86 + backend/tests/test_reporting.py | 12 + backend/tests/test_scanner.py | 223 ++ backend/tests/test_signals.py | 113 + backend/tests/test_signals_v11.py | 59 + backend/tests/test_store.py | 161 + compose.yaml | 80 + docker-compose.yml | 57 + docs/ARCHITECTURE.md | 100 + docs/screenshots/demo-explorer.png | Bin 0 -> 183006 bytes docs/screenshots/demo-portfolio.png | Bin 0 -> 785643 bytes frontend/Dockerfile | 12 + frontend/e2e/mock-api.mjs | 55 + frontend/e2e/repopulse.spec.ts | 45 + frontend/e2e/start-vite.mjs | 11 + frontend/index.html | 16 + frontend/nginx.conf | 23 + frontend/package-lock.json | 3336 +++++++++++++++++ frontend/package.json | 30 + frontend/playwright.config.ts | 36 + .../public/brand/repopulse-logo-light.svg | 7 + frontend/public/brand/repopulse-logo.svg | 7 + frontend/public/brand/repopulse-mark-mono.svg | 4 + frontend/public/brand/repopulse-mark.svg | 5 + frontend/public/favicon.svg | 5 + frontend/public/site.webmanifest | 9 + frontend/src/App.test.tsx | 128 + frontend/src/App.tsx | 179 + frontend/src/FindingsView.test.tsx | 112 + frontend/src/OverviewView.test.tsx | 50 + frontend/src/api.test.ts | 81 + frontend/src/api.ts | 386 ++ frontend/src/catalog.test.ts | 78 + frontend/src/catalog.ts | 118 + frontend/src/components/ArchitectureView.tsx | 42 + frontend/src/components/Brand.tsx | 32 + .../src/components/DashboardView.test.tsx | 32 + frontend/src/components/DashboardView.tsx | 104 + frontend/src/components/DependenciesView.tsx | 12 + frontend/src/components/FindingsView.tsx | 78 + frontend/src/components/HistoryView.tsx | 72 + frontend/src/components/HotspotsView.tsx | 37 + frontend/src/components/OverviewView.tsx | 71 + .../src/components/PortfolioAtlas.test.tsx | 25 + frontend/src/components/PortfolioAtlas.tsx | 75 + frontend/src/components/RemediationCenter.tsx | 49 + .../src/components/RepositoryVisual.test.tsx | 20 + frontend/src/components/RepositoryVisual.tsx | 100 + frontend/src/components/ScanRunsView.tsx | 5 + frontend/src/main.tsx | 10 + frontend/src/navigation.test.ts | 20 + frontend/src/navigation.ts | 32 + frontend/src/styles.css | 636 ++++ frontend/src/test-fixtures.ts | 155 + frontend/tsconfig.json | 20 + frontend/vite.config.ts | 22 + package-lock.json | 12 + package.json | 10 + requirements.txt | 1 + 90 files changed, 14315 insertions(+) create mode 100644 .dockerignore create mode 100644 .env.example create mode 100644 .gitignore create mode 100644 .gitleaks.toml create mode 100644 Dockerfile.unraid create mode 100644 PUBLIC_SOURCE_EXPORT.md create mode 100644 PUBLIC_SOURCE_MANIFEST.json create mode 100644 README.md create mode 100644 backend/Dockerfile create mode 100644 backend/app/__init__.py create mode 100644 backend/app/acquisition.py create mode 100644 backend/app/architecture.py create mode 100644 backend/app/git_analysis.py create mode 100644 backend/app/gitea.py create mode 100644 backend/app/jobs.py create mode 100644 backend/app/main.py create mode 100644 backend/app/models.py create mode 100644 backend/app/policy.py create mode 100644 backend/app/release_gate.py create mode 100644 backend/app/reporting.py create mode 100644 backend/app/rules.py create mode 100644 backend/app/scanner.py create mode 100644 backend/app/signals.py create mode 100644 backend/app/store.py create mode 100644 backend/pyproject.toml create mode 100644 backend/tests/test_api.py create mode 100644 backend/tests/test_api_v11.py create mode 100644 backend/tests/test_architecture.py create mode 100644 backend/tests/test_gitea.py create mode 100644 backend/tests/test_jobs.py create mode 100644 backend/tests/test_maintenance.py create mode 100644 backend/tests/test_migrations.py create mode 100644 backend/tests/test_reporting.py create mode 100644 backend/tests/test_scanner.py create mode 100644 backend/tests/test_signals.py create mode 100644 backend/tests/test_signals_v11.py create mode 100644 backend/tests/test_store.py create mode 100644 compose.yaml create mode 100644 docker-compose.yml create mode 100644 docs/ARCHITECTURE.md create mode 100644 docs/screenshots/demo-explorer.png create mode 100644 docs/screenshots/demo-portfolio.png create mode 100644 frontend/Dockerfile create mode 100644 frontend/e2e/mock-api.mjs create mode 100644 frontend/e2e/repopulse.spec.ts create mode 100644 frontend/e2e/start-vite.mjs create mode 100644 frontend/index.html create mode 100644 frontend/nginx.conf create mode 100644 frontend/package-lock.json create mode 100644 frontend/package.json create mode 100644 frontend/playwright.config.ts create mode 100644 frontend/public/brand/repopulse-logo-light.svg create mode 100644 frontend/public/brand/repopulse-logo.svg create mode 100644 frontend/public/brand/repopulse-mark-mono.svg create mode 100644 frontend/public/brand/repopulse-mark.svg create mode 100644 frontend/public/favicon.svg create mode 100644 frontend/public/site.webmanifest create mode 100644 frontend/src/App.test.tsx create mode 100644 frontend/src/App.tsx create mode 100644 frontend/src/FindingsView.test.tsx create mode 100644 frontend/src/OverviewView.test.tsx create mode 100644 frontend/src/api.test.ts create mode 100644 frontend/src/api.ts create mode 100644 frontend/src/catalog.test.ts create mode 100644 frontend/src/catalog.ts create mode 100644 frontend/src/components/ArchitectureView.tsx create mode 100644 frontend/src/components/Brand.tsx create mode 100644 frontend/src/components/DashboardView.test.tsx create mode 100644 frontend/src/components/DashboardView.tsx create mode 100644 frontend/src/components/DependenciesView.tsx create mode 100644 frontend/src/components/FindingsView.tsx create mode 100644 frontend/src/components/HistoryView.tsx create mode 100644 frontend/src/components/HotspotsView.tsx create mode 100644 frontend/src/components/OverviewView.tsx create mode 100644 frontend/src/components/PortfolioAtlas.test.tsx create mode 100644 frontend/src/components/PortfolioAtlas.tsx create mode 100644 frontend/src/components/RemediationCenter.tsx create mode 100644 frontend/src/components/RepositoryVisual.test.tsx create mode 100644 frontend/src/components/RepositoryVisual.tsx create mode 100644 frontend/src/components/ScanRunsView.tsx create mode 100644 frontend/src/main.tsx create mode 100644 frontend/src/navigation.test.ts create mode 100644 frontend/src/navigation.ts create mode 100644 frontend/src/styles.css create mode 100644 frontend/src/test-fixtures.ts create mode 100644 frontend/tsconfig.json create mode 100644 frontend/vite.config.ts create mode 100644 package-lock.json create mode 100644 package.json create mode 100644 requirements.txt diff --git a/.dockerignore b/.dockerignore new file mode 100644 index 0000000..a5a54e9 --- /dev/null +++ b/.dockerignore @@ -0,0 +1,12 @@ +.git +.gitea +.env +.venv +__pycache__ +.pytest_cache +node_modules +frontend/node_modules +frontend/dist +data +*.db +*.sqlite* diff --git a/.env.example b/.env.example new file mode 100644 index 0000000..fbabd2e --- /dev/null +++ b/.env.example @@ -0,0 +1,40 @@ +# RepoPulse UI port. The registered Unraid deployment publishes 1254 -> 8000. +REPOPULSE_PORT=1254 + +# Directory containing repositories. From a repository checkout, '..' scans sibling repositories. +# On the Unraid deploy runner this resolves to /mnt/cache/appdata/gitea-deploy-runners/sources. +REPOPULSE_SOURCE_ROOT=.. + +# Local Compose uses a checkout-relative bind mount. The production Compose +# deployment defaults to the named `repopulse_data` volume when this is unset, +# keeping SQLite state outside the exact-source tree that deployments replace. +REPOPULSE_DATA_ROOT=./data + +# Keep only one repository scan active per application process by default. +REPOPULSE_MAX_CONCURRENT_SCANS=1 +REPOPULSE_JOB_LEASE_SECONDS=900 + +# Transparent bounded analysis limits. Values are clamped by the backend. +REPOPULSE_SCAN_MAX_FILES=10000 +REPOPULSE_SCAN_MAX_TEXT_BYTES=2000000 +REPOPULSE_SCAN_MAX_TOTAL_TEXT_BYTES=50000000 +REPOPULSE_SCAN_MAX_FINDINGS=2000 +REPOPULSE_SCAN_MAX_SECRET_FINDINGS=20 + +# Retain compact history while limiting detailed report payload retention. +REPOPULSE_HISTORY_PER_REPOSITORY=200 +REPOPULSE_FULL_REPORTS_PER_REPOSITORY=30 +REPOPULSE_REPORT_RETENTION_DAYS=365 + +# Optional server-side Gitea connector. Never put this token in frontend code. +REPOPULSE_GITEA_URL= +REPOPULSE_GITEA_TOKEN= +REPOPULSE_GITEA_BRANCH_WORKERS=4 +REPOPULSE_GITEA_WEBHOOK_SECRET= +REPOPULSE_GITEA_SYNC_INTERVAL_SECONDS=300 +REPOPULSE_REPOSITORY_CACHE=/data/repos +REPOPULSE_MAX_QUEUED_SCANS=100 + +# Optional mutation boundary for deployments that are not already protected by +# an authenticated reverse proxy. Send the same value as X-RepoPulse-Token. +REPOPULSE_OPERATOR_TOKEN= diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..097a45a --- /dev/null +++ b/.gitignore @@ -0,0 +1,28 @@ +# Python +__pycache__/ +*.py[cod] +.venv/ +.pytest_cache/ +.ruff_cache/ + +# Node +node_modules/ +dist/ +.vite/ +test-results/ +playwright-report/ + +# Local scan state +*.db +*.sqlite +*.sqlite3 +data/*.bak +.env +.env.* +!.env.example + +# IDE / OS +.idea/ +.vscode/ +.DS_Store +Thumbs.db diff --git a/.gitleaks.toml b/.gitleaks.toml new file mode 100644 index 0000000..ede93a9 --- /dev/null +++ b/.gitleaks.toml @@ -0,0 +1,9 @@ +[extend] +useDefault = true + +[[allowlists]] +description = "Intentional credential detector fixture; not an operational credential" +condition = "AND" +paths = ['backend/tests/test_signals_v11\.py$'] +regexTarget = "line" +regexes = ['abcdefghijk1234'] diff --git a/Dockerfile.unraid b/Dockerfile.unraid new file mode 100644 index 0000000..921b3c6 --- /dev/null +++ b/Dockerfile.unraid @@ -0,0 +1,29 @@ +FROM node:22-alpine AS frontend-build + +WORKDIR /frontend +COPY frontend/package.json frontend/package-lock.json ./ +RUN npm ci --no-audit --no-fund +COPY frontend/ ./ +RUN npm run build + +FROM python:3.12-slim + +WORKDIR /app +ENV PYTHONDONTWRITEBYTECODE=1 \ + PYTHONUNBUFFERED=1 \ + REPOPULSE_DB=/data/repopulse.db \ + REPOPULSE_SCAN_ROOT=/scan \ + REPOPULSE_STATIC_DIR=/app/static + +RUN apt-get update \ + && apt-get install -y --no-install-recommends git \ + && rm -rf /var/lib/apt/lists/* + +COPY backend/pyproject.toml ./pyproject.toml +COPY backend/app ./app +RUN pip install --no-cache-dir . +COPY --from=frontend-build /frontend/dist ./static + +VOLUME ["/data", "/scan"] +EXPOSE 8000 +CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8000"] diff --git a/PUBLIC_SOURCE_EXPORT.md b/PUBLIC_SOURCE_EXPORT.md new file mode 100644 index 0000000..145102a --- /dev/null +++ b/PUBLIC_SOURCE_EXPORT.md @@ -0,0 +1,3 @@ +# Public source export + +This source snapshot was generated from the private canonical repository at revision `2524ccc3c1c27739996dccb2b7992989f88cd26d`. It contains no private Git history or operational evidence. Changes are published from the canonical repository. diff --git a/PUBLIC_SOURCE_MANIFEST.json b/PUBLIC_SOURCE_MANIFEST.json new file mode 100644 index 0000000..98c8280 --- /dev/null +++ b/PUBLIC_SOURCE_MANIFEST.json @@ -0,0 +1,446 @@ +{ + "schemaVersion": 1, + "sourceRevision": "2524ccc3c1c27739996dccb2b7992989f88cd26d", + "files": [ + { + "path": ".dockerignore", + "sha256": "fcd8146da6fd8900a8513541c5925d3a3efc71a7a0670e5f7fd0ccf947899bd4", + "bytes": 130 + }, + { + "path": ".env.example", + "sha256": "c42f86ef0802bff819144099a69f89c678905bd4af4c9da9b9e801b3bc06943f", + "bytes": 1694 + }, + { + "path": ".gitignore", + "sha256": "0e9ad55f2380d7bb57d8c72c99d79362a837eea9efb2c8c9530e7118cd94d9cb", + "bytes": 292 + }, + { + "path": ".gitleaks.toml", + "sha256": "14d325c51a68f2153ea45af0ef2b6aff7cd503c5540f4197d774d7d3db268495", + "bytes": 256 + }, + { + "path": "Dockerfile.unraid", + "sha256": "3d4e6da865479357527d88e2d766890d86a3c1877de7a004a037e5ef2cd139b0", + "bytes": 788 + }, + { + "path": "README.md", + "sha256": "daf72438ac9243a092c38f5d3b8d7131245142d4a800dae91ac84fe874ab4814", + "bytes": 5271 + }, + { + "path": "backend/Dockerfile", + "sha256": "b5ebf1f12895c50890cb533e09a7e213c2331717027821a2545f4fd0330403c7", + "bytes": 505 + }, + { + "path": "backend/app/__init__.py", + "sha256": "de10a39a27b9866c1f2ee16fadc50be1002d3edb151fdf74a1c7eb9e0f129a08", + "bytes": 34 + }, + { + "path": "backend/app/acquisition.py", + "sha256": "7c2cc8cb7b8ce7e14d47398b18135f30d486bd0bcfe28b0da8707cc5058b0f3b", + "bytes": 11052 + }, + { + "path": "backend/app/architecture.py", + "sha256": "37fc9680b7ae27638c88552696e9692dcdff180ab8b4b0dfe322acad60179161", + "bytes": 13252 + }, + { + "path": "backend/app/git_analysis.py", + "sha256": "e5fc4778c7288884837d3cb89ca74046308b70432f72742174b5bb2afdcb19ce", + "bytes": 3864 + }, + { + "path": "backend/app/gitea.py", + "sha256": "af5bc71c699c428b0c79a0c57ddda919838dbd37e2aa1c931b0e0c9ea4ce0061", + "bytes": 14276 + }, + { + "path": "backend/app/jobs.py", + "sha256": "0d845ff11cd5fc32fa7350eafeb4757a17d403e70bcc1312a295dc2793263dca", + "bytes": 12780 + }, + { + "path": "backend/app/main.py", + "sha256": "897a75de65118c978e2d861f535be2ac269ccb2bd81b658af54a44eb5736c352", + "bytes": 19644 + }, + { + "path": "backend/app/models.py", + "sha256": "6ac96bb4cf25d9e5851bc811569d5e896587c502b58b798aaf494b8fc3a46edd", + "bytes": 11240 + }, + { + "path": "backend/app/policy.py", + "sha256": "99d53303ae7bff2156bd748059885ce2621b651a96bb10b8b7f1783d01c88469", + "bytes": 3282 + }, + { + "path": "backend/app/release_gate.py", + "sha256": "1f17f8863956b6a52f880c20314bd8a5e2df2685494c4675b732873ef35cfca8", + "bytes": 5772 + }, + { + "path": "backend/app/reporting.py", + "sha256": "8e9e0e77df8c3950559d353021a6ac0622e4da2dd2c5a9e03c2ab8c80ef6938f", + "bytes": 5359 + }, + { + "path": "backend/app/rules.py", + "sha256": "031c62ba9875dfa2a371dfc8dae9b40890eae446a725b587854128e6fbe49242", + "bytes": 3484 + }, + { + "path": "backend/app/scanner.py", + "sha256": "9dfc2de46b49168d73bd9afeae30c104addd783eb1f310fc5dfcedc4434430e0", + "bytes": 26442 + }, + { + "path": "backend/app/signals.py", + "sha256": "c83e017a5a7c750c9ece3d53db2671a895c5d563fde5a9d2451381e633e822a6", + "bytes": 20351 + }, + { + "path": "backend/app/store.py", + "sha256": "01782cd4f171446b8e53a993cf8ef4b697941f4681d29fd2547de7f9410b5fac", + "bytes": 70318 + }, + { + "path": "backend/pyproject.toml", + "sha256": "2cf2e3f4fbf41cbc679de9ffe395109a40a8703a19e1095993d90385fb04d84f", + "bytes": 469 + }, + { + "path": "backend/tests/test_api.py", + "sha256": "c2b7a9c3c6b65e957a7aa55d4fa1aa5bca1ee24b9a7cea888346ad51523ef57f", + "bytes": 4895 + }, + { + "path": "backend/tests/test_api_v11.py", + "sha256": "c9d26544553a9282321d751c53c138b1f076e63ad1aefa37f3b5729a36e9c17c", + "bytes": 4940 + }, + { + "path": "backend/tests/test_architecture.py", + "sha256": "7ef1f1fbb92ead95e9e4be69a22b7d84a276bb5177a7f5929644bc290fa69437", + "bytes": 3749 + }, + { + "path": "backend/tests/test_gitea.py", + "sha256": "94e08c1ce45dc0a0c6890c51ede8e900f60a176b760fd3d27866265642b45629", + "bytes": 8220 + }, + { + "path": "backend/tests/test_jobs.py", + "sha256": "7e82af630918c523a1d9d6d0e64b924ff4bed335ce3a565ee76bb9150a8ba295", + "bytes": 9632 + }, + { + "path": "backend/tests/test_maintenance.py", + "sha256": "a83497cff1c9c4f06ec5da1e396bb2816974f36bfa0cbc7c77d63b8d7411c143", + "bytes": 7494 + }, + { + "path": "backend/tests/test_migrations.py", + "sha256": "e9bdf365e1c580b68e2f3f0426aed189869f7c8620b2eb17fdd36da96df0d76c", + "bytes": 2872 + }, + { + "path": "backend/tests/test_reporting.py", + "sha256": "6b91210461eb560a28515008fe35575f09fc12377fbf51bd430b6c760250ede3", + "bytes": 475 + }, + { + "path": "backend/tests/test_scanner.py", + "sha256": "8373156460d71990219cf0f73fa47ba7645c7643b874be0ab96ff09fc7b37630", + "bytes": 9852 + }, + { + "path": "backend/tests/test_signals.py", + "sha256": "c990c4002ee89c7fb0484fc2c54af75a0f8158b4f585dde8d4d0eb3ea1bb1842", + "bytes": 4351 + }, + { + "path": "backend/tests/test_signals_v11.py", + "sha256": "eaf0c0d852bbfa9cf58fa895c34fe7a30e6d44527bcb69c70e46432a45a31add", + "bytes": 3051 + }, + { + "path": "backend/tests/test_store.py", + "sha256": "c2594f5b86e0094434c16be28bf656c79320c0d216790cbc302b2057102ff09e", + "bytes": 6898 + }, + { + "path": "compose.yaml", + "sha256": "a168455adaf981152221e41e9efd57439c67df9838570ce22ae10afb08bada74", + "bytes": 3000 + }, + { + "path": "docker-compose.yml", + "sha256": "55077c9147f0d48a601b688bfd1a2690f3d252deae49811fb53a439cad814bb1", + "bytes": 2495 + }, + { + "path": "docs/ARCHITECTURE.md", + "sha256": "0f766e94aaeb1bc3b396599b549db2a82ffe882036c3a6f0fddab7ef36577f09", + "bytes": 13428 + }, + { + "path": "docs/screenshots/demo-explorer.png", + "sha256": "74d102b7ab96973a38e6c190f36fae7ffa546c14482f82c1e912ea2e03eac0e8", + "bytes": 183006 + }, + { + "path": "docs/screenshots/demo-portfolio.png", + "sha256": "95f22065e74ee3698e7f0ec9d8a6dbf0e4e37f7a9662353ca864febc459f5c6c", + "bytes": 785643 + }, + { + "path": "frontend/Dockerfile", + "sha256": "c22443a8c260bab6f73dfbb0db0fe84a63d0b05638bae07c0597b800409f297d", + "bytes": 320 + }, + { + "path": "frontend/e2e/mock-api.mjs", + "sha256": "d7d6edaa29df35e6bcb0607ee0371f7679dcfbce04f9d9d1c484a79a590f65cf", + "bytes": 8871 + }, + { + "path": "frontend/e2e/repopulse.spec.ts", + "sha256": "5676b76de5a4ac95ff7b619e43fa9fcc43ba0ab62946958ecead68570db3b28a", + "bytes": 2815 + }, + { + "path": "frontend/e2e/start-vite.mjs", + "sha256": "0189002d9a1da6ad5006f38d503588e419b2f4b0089ac59210a0da6532fd57b2", + "bytes": 462 + }, + { + "path": "frontend/index.html", + "sha256": "19bf66c0e00656b483b90ba07f616227aa9755a1109424b77c57dc5ff682493b", + "bytes": 668 + }, + { + "path": "frontend/nginx.conf", + "sha256": "c07a3ce7936beef0d3f124f18878b46c87693150e83cf571cebbf3f6f6635885", + "bytes": 520 + }, + { + "path": "frontend/package-lock.json", + "sha256": "43f9a45011d41977cca8eda3987ccbe2409f687db2e690105b01e90d9b088d9b", + "bytes": 116420 + }, + { + "path": "frontend/package.json", + "sha256": "c84753f99331918ce8f97115c7e6a800260ea15d774412fe468985a45cdde0c8", + "bytes": 754 + }, + { + "path": "frontend/playwright.config.ts", + "sha256": "f56a666f9b23c63e87add11d4c1dea994597a56c5e5a8f4d0a8d7dd0ced1934a", + "bytes": 1313 + }, + { + "path": "frontend/public/brand/repopulse-logo-light.svg", + "sha256": "86e97e67ec6371bf18400b0380d1a93880581ee06e3bc4cb8417caced1a4d414", + "bytes": 825 + }, + { + "path": "frontend/public/brand/repopulse-logo.svg", + "sha256": "a882e6d762a4019527b1e9cb8110afdd86549ca46e430507ca618cf67446765a", + "bytes": 825 + }, + { + "path": "frontend/public/brand/repopulse-mark-mono.svg", + "sha256": "140954a6d337e590adb0c8a8d455d34219f4776a26cb74b103fa43f451a03195", + "bytes": 426 + }, + { + "path": "frontend/public/brand/repopulse-mark.svg", + "sha256": "7492784108d6de42363ea2b767647d062eb45fd98020b8749e7123f5eb7ad293", + "bytes": 465 + }, + { + "path": "frontend/public/favicon.svg", + "sha256": "7492784108d6de42363ea2b767647d062eb45fd98020b8749e7123f5eb7ad293", + "bytes": 465 + }, + { + "path": "frontend/public/site.webmanifest", + "sha256": "5ced74fc20879c6f096730534aaf9331abe7b16a62c6274de548f976b2153977", + "bytes": 374 + }, + { + "path": "frontend/src/App.test.tsx", + "sha256": "108c3e2190aba3b7125e2c1911eb5b2fa708f95f989d2d25e6e32ee15c77199f", + "bytes": 5893 + }, + { + "path": "frontend/src/App.tsx", + "sha256": "83d9b1b0fe9d35b5ea75370105b80343aca7aecbe6f7dbd16cd103160e69c015", + "bytes": 46615 + }, + { + "path": "frontend/src/FindingsView.test.tsx", + "sha256": "86fdea7d89d3b0fa0e2f8edd93c98414d432b56fc7bc1b2a55e70bacea477ea6", + "bytes": 3996 + }, + { + "path": "frontend/src/OverviewView.test.tsx", + "sha256": "048e07c6691b6b8acd7623389d38298cc8c8cfba3169e188baf529c1a4b0eee4", + "bytes": 1612 + }, + { + "path": "frontend/src/api.test.ts", + "sha256": "361784096733107ed43281d0401baa208285de1edfd19ca62caaf3e85f3b474c", + "bytes": 2578 + }, + { + "path": "frontend/src/api.ts", + "sha256": "c74a07618e9fc27c60cad6707e481f87731423eb2265082cb9921f58bdff397e", + "bytes": 10726 + }, + { + "path": "frontend/src/catalog.test.ts", + "sha256": "7a1d9689a57a2cf9208f03770a86bf8c8ffc3bd0dfbbe4f42fd3c3d714d2a03e", + "bytes": 3201 + }, + { + "path": "frontend/src/catalog.ts", + "sha256": "97b3aa927261317aaceb2fc3072d42380c7968ca681011f7c967039d189ffce0", + "bytes": 5508 + }, + { + "path": "frontend/src/components/ArchitectureView.tsx", + "sha256": "c57e08a6ab7d8a60627ec57425b2f5c882d78ff9653a285b873e26016b4d528f", + "bytes": 4707 + }, + { + "path": "frontend/src/components/Brand.tsx", + "sha256": "2d97a7fec8d1ba55a19113a9d592a6c6b00378ab66c8f8028d259c8105031983", + "bytes": 1593 + }, + { + "path": "frontend/src/components/DashboardView.test.tsx", + "sha256": "32654d5c4db5475f451fd0fa90032d68b25d29d94909550aee9b3b19f8169b0b", + "bytes": 2404 + }, + { + "path": "frontend/src/components/DashboardView.tsx", + "sha256": "61548df575c977ac94deb81516c2e4281f9bb6eb52899689e7e5f8fdc781b9b7", + "bytes": 11005 + }, + { + "path": "frontend/src/components/DependenciesView.tsx", + "sha256": "cb0d4d855ba32794770c048e48c1788836dbbdc5cfcc7bc1fa19d301f02eca15", + "bytes": 1823 + }, + { + "path": "frontend/src/components/FindingsView.tsx", + "sha256": "16a6ebf6f19aa4141b0d025f5a517993ca90163965752287b079e5ca4b69b97d", + "bytes": 4358 + }, + { + "path": "frontend/src/components/HistoryView.tsx", + "sha256": "d17d7078d99de3103a6390927bf8daf0b096873df1eb253e24b80d18bcd2f592", + "bytes": 4304 + }, + { + "path": "frontend/src/components/HotspotsView.tsx", + "sha256": "829dc513d951744481ce2ddfa3ef9ef0478e16500bb1c486dd7dcbf24dbbbe52", + "bytes": 1714 + }, + { + "path": "frontend/src/components/OverviewView.tsx", + "sha256": "64d7fdd604f262418d3802e5a69ec4750e0c04c2a5cc310a73be2e2f8dec0072", + "bytes": 10146 + }, + { + "path": "frontend/src/components/PortfolioAtlas.test.tsx", + "sha256": "9befda03b64aff43f05b134c26633c5df54d3e8fb6db036abf5eb33509936324", + "bytes": 1252 + }, + { + "path": "frontend/src/components/PortfolioAtlas.tsx", + "sha256": "f647dc2405a4d6f049ce4cf6296774061ce60944ef3bdaa243445d785bce94e8", + "bytes": 5256 + }, + { + "path": "frontend/src/components/RemediationCenter.tsx", + "sha256": "60b1aaeae17a3b60ded5b3e76201663120ce86af35e6b7f1935ae86e4b69c715", + "bytes": 2338 + }, + { + "path": "frontend/src/components/RepositoryVisual.test.tsx", + "sha256": "68c1b2caf1dfb12ad6a2bdc0b8469afd0b18b0efe17a1c0eaf7c95904465d083", + "bytes": 961 + }, + { + "path": "frontend/src/components/RepositoryVisual.tsx", + "sha256": "ec830882de931e0c7d4314cf8f35e80a727fae5ed5fc1b92b3821aaa9e747266", + "bytes": 7330 + }, + { + "path": "frontend/src/components/ScanRunsView.tsx", + "sha256": "c8b857efe2492ef0460f77038a0f159a6c5a41f0ca83c619acf56f587c8900b6", + "bytes": 1357 + }, + { + "path": "frontend/src/main.tsx", + "sha256": "b3f023da133154adff448b24c256c554072536939e52291490a6128a9cfc82f7", + "bytes": 237 + }, + { + "path": "frontend/src/navigation.test.ts", + "sha256": "8afc1406f9642896b9d667e525c7c3d7ff12afc82451f2c41dcc138b2bc15fcd", + "bytes": 1026 + }, + { + "path": "frontend/src/navigation.ts", + "sha256": "693b8ff5c2319363bfcc4f8353cfd45ae4c5fad4e9ceae50cbf707aeda24a673", + "bytes": 1647 + }, + { + "path": "frontend/src/styles.css", + "sha256": "8cd3bbecd95b579e990c628fac58c00bdedecd66927235440eb01b516b3f7fdb", + "bytes": 97641 + }, + { + "path": "frontend/src/test-fixtures.ts", + "sha256": "1fdcd6a69bdcbe2df5ac8666295ea68f6c08e20c0222c477b1eecb5b6ffcce22", + "bytes": 5145 + }, + { + "path": "frontend/tsconfig.json", + "sha256": "9616ea859510ecae0cb8464fbe3bbd1448d66bb5a4ebf40d163e8f14fa8fff2b", + "bytes": 545 + }, + { + "path": "frontend/vite.config.ts", + "sha256": "f1adfcd5da9ab034690b135c5ba82e14df800296c15347a57549d3a5829e0464", + "bytes": 560 + }, + { + "path": "package-lock.json", + "sha256": "f3bfac56e6fd5d2b2752c0f03e3b4c6e71d3ce700c644be60ad3941435053b5b", + "bytes": 213 + }, + { + "path": "package.json", + "sha256": "76c07b9209f6c3eeebc34d6562d7f9dc3ade4165734065e267f94db4a2ea29b6", + "bytes": 256 + }, + { + "path": "requirements.txt", + "sha256": "c7d062f1bd7b5bd124a3153eab82308d6118a183241327c0b5e2da668e567b33", + "bytes": 19 + } + ] +} diff --git a/README.md b/README.md new file mode 100644 index 0000000..6991dab --- /dev/null +++ b/README.md @@ -0,0 +1,90 @@ +# RepoPulse + +**Explain repository health, maintenance risk and release readiness from local, deterministic evidence.** + +RepoPulse is a self-hosted Gitea repository intelligence dashboard. It scans exact revisions, keeps findings and history, and helps prioritize the next maintenance action. Source code is analyzed locally without sending it to an external model. + +```mermaid +flowchart LR + A[Gitea catalog / local path] --> B[Exact revision acquisition] + B --> C[Bounded deterministic scan] + C --> D[Findings and explainable scores] + D --> E[Portfolio / remediation / history] +``` + +## Capabilities + +- Read-only Gitea repository discovery, default-branch reconciliation and optional signed push webhooks. +- Durable SQLite job queue, revision deduplication, lease recovery and detached scan worktrees. +- Repository portfolio, triage, quick switch, architecture, hotspots, findings and history views. +- Language/LOC inventory, test/CI signals, dependency and lockfile analysis across common ecosystems. +- TODO debt, bounded churn, local import graphs and explainable hotspot ranking. +- Redacted credential-assignment warnings and backend-owned remediation guidance. +- Transparent scan budgets and truncation metadata instead of overstating scan coverage. +- Accepted-risk policies, release gates, finding deltas and standalone HTML/JSON reports. + +## Interface preview + +These screenshots show the deterministic browser-test fixture: fictional Alpha/Beta/Gamma repositories, not a private or live repository inventory. + +![Portfolio triage and recommended next action](docs/screenshots/demo-portfolio.png) + +![Repository explorer with health and revision filters](docs/screenshots/demo-explorer.png) + +## Deploy + +```bash +git clone https://gitea.itworx.tech/Jens/RepoPulse-Public.git +cd RepoPulse-Public +cp .env.example .env +# Select the intended repository directory and configure your Gitea connector. +docker compose up --build +``` + +Open `http://localhost:1254`. Compose runs a Python API and React frontend. `REPOPULSE_SOURCE_ROOT` defaults to the parent directory and is mounted read-only at `/scan`; narrow it to the repository collection you intend to inspect. The Advanced path flow accepts paths inside that boundary. + +`REPOPULSE_DATA_ROOT=./data` in the local template retains SQLite history, queue and repository mirrors. If unset, Compose uses the named `repopulse_data` volume. Keep persisted data outside a replaceable checkout and back it up before upgrades. The durable queue intentionally runs one active scan worker. + +## Connect Gitea + +Configure these values on the server, never in the frontend: + +```dotenv +REPOPULSE_GITEA_URL=https://gitea.example.test +REPOPULSE_GITEA_TOKEN= +REPOPULSE_OPERATOR_TOKEN= +``` + +Use only the repository-read permissions needed for the intended catalog and revisions. An optional `REPOPULSE_GITEA_WEBHOOK_SECRET` authenticates push notifications. RepoPulse discovers repositories, resolves revisions, queues stale work, scans exact SHAs and retains results by revision. Incomplete or failed discovery preserves existing evidence rather than silently declaring missing repositories unavailable. + +Protect deployment with an authenticated proxy or configure `REPOPULSE_OPERATOR_TOKEN`; the mutation API uses `X-RepoPulse-Token`. Limit network access and the scan mount. Direct development without `REPOPULSE_SCAN_ROOT` can read any path accessible to that process. + +## Interpret results + +Findings are deterministic observations with locations and severity. Health scores reflect documented deductions; release gates report **READY**, **READY WITH WARNINGS** or **BLOCKED** under repository policy. Remediation guidance explains confidence, priority and a suggested first action. RepoPulse never edits external repositories automatically. + +Heuristics are engineering guidance, not a substitute for review, runtime tests or specialized security audits. Truncated scans expose their limits. Credential warnings redact values but still require human investigation. Repository history and retained reports contain source-derived metadata, so treat the persisted store as sensitive. + +## Development + +```bash +python -m venv .venv +# Activate .venv for your shell. +pip install -r requirements.txt +uvicorn app.main:app --app-dir backend --reload --port 8000 +``` + +In another terminal: + +```bash +npm --prefix frontend ci +npm --prefix frontend run dev +``` + +Run `python -m pytest`, `npm --prefix frontend test`, `npm --prefix frontend run typecheck` and `npm --prefix frontend run build`. The browser test fixture uses deterministic API responses; it is not a live production portfolio. See [architecture](docs/ARCHITECTURE.md) for implementation detail. + +## Source distribution and licensing + +This is the curated public source edition of RepoPulse 1.5.0. Reviewed updates flow from the private canonical repository after merges to `main`, without private history, repository inventories, runtime stores or internal CI/deployment workflows. Configure the generic deployment templates for your own environment. + +No project-wide license is included. Public visibility does not grant reuse or redistribution rights; obtain the owner's terms and review third-party dependencies before redistribution. diff --git a/backend/Dockerfile b/backend/Dockerfile new file mode 100644 index 0000000..4ed2997 --- /dev/null +++ b/backend/Dockerfile @@ -0,0 +1,19 @@ +FROM python:3.12-slim + +WORKDIR /app +ENV PYTHONDONTWRITEBYTECODE=1 \ + PYTHONUNBUFFERED=1 \ + REPOPULSE_DB=/data/repopulse.db \ + REPOPULSE_SCAN_ROOT=/scan + +RUN apt-get update \ + && apt-get install -y --no-install-recommends git \ + && rm -rf /var/lib/apt/lists/* + +COPY backend/pyproject.toml ./pyproject.toml +COPY backend/app ./app +RUN pip install --no-cache-dir . + +VOLUME ["/data", "/scan"] +EXPOSE 8000 +CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8000"] diff --git a/backend/app/__init__.py b/backend/app/__init__.py new file mode 100644 index 0000000..917c235 --- /dev/null +++ b/backend/app/__init__.py @@ -0,0 +1 @@ +"""RepoPulse backend package.""" diff --git a/backend/app/acquisition.py b/backend/app/acquisition.py new file mode 100644 index 0000000..4d113db --- /dev/null +++ b/backend/app/acquisition.py @@ -0,0 +1,264 @@ +from __future__ import annotations + +import os +import re +import shutil +import subprocess +from dataclasses import dataclass +from pathlib import Path +from threading import Lock, RLock +from urllib.parse import urlsplit + +from .models import Repository + +SAFE_REVISION = re.compile(r"^[0-9a-fA-F]{7,64}$") +SAFE_BRANCH = re.compile(r"^[A-Za-z0-9._/-]+$") +SAFE_JOB_ID = re.compile(r"^[A-Za-z0-9-]+$") + + +class AcquisitionError(RuntimeError): + def __init__(self, code: str, detail: str) -> None: + super().__init__(detail) + self.code = code + self.detail = detail + + +@dataclass(frozen=True) +class AcquiredSource: + path: Path + actual_revision: str + branch: str + + +class GitAcquirer: + """Maintain bounded bare mirrors and scan detached exact-revision worktrees.""" + + def __init__( + self, + cache_root: str | Path | None = None, + token: str | None = None, + *, + timeout: int = 180, + allowed_clone_origin: str | None = None, + ) -> None: + raw_root = cache_root or os.getenv("REPOPULSE_REPOSITORY_CACHE", "data/repos") + self.cache_root = Path(raw_root).expanduser().resolve() + self.token = token if token is not None else os.getenv("REPOPULSE_GITEA_TOKEN", "") + self.timeout = max(10, timeout) + configured_origin = allowed_clone_origin or os.getenv("REPOPULSE_GITEA_URL", "") + self.allowed_clone_origin = self._origin(configured_origin) + self.mirrors_root = self.cache_root / "mirrors" + self.worktrees_root = self.cache_root / "worktrees" + self.mirrors_root.mkdir(parents=True, exist_ok=True) + self.worktrees_root.mkdir(parents=True, exist_ok=True) + self._lock_guard = Lock() + self._repository_locks: dict[str, RLock] = {} + + @staticmethod + def _origin(value: str) -> str | None: + if not value: + return None + try: + parsed = urlsplit(value) + if parsed.scheme not in {"http", "https"} or not parsed.hostname: + return None + port = parsed.port or (443 if parsed.scheme == "https" else 80) + except ValueError: + return None + return f"{parsed.scheme.casefold()}://{parsed.hostname.casefold()}:{port}" + + def _repository_lock(self, repository_id: str) -> RLock: + with self._lock_guard: + return self._repository_locks.setdefault(repository_id, RLock()) + + def _git_env(self) -> dict[str, str]: + env = os.environ.copy() + if self.token: + env.update( + { + "GIT_CONFIG_COUNT": "1", + "GIT_CONFIG_KEY_0": "http.extraHeader", + "GIT_CONFIG_VALUE_0": f"Authorization: token {self.token}", + } + ) + return env + + def _run(self, args: list[str]) -> str: + try: + result = subprocess.run( + args, + check=True, + capture_output=True, + text=True, + errors="replace", + timeout=self.timeout, + env=self._git_env(), + ) + except subprocess.TimeoutExpired as exc: + raise AcquisitionError("timeout", "Git source acquisition timed out") from exc + except (OSError, subprocess.CalledProcessError) as exc: + # Git stderr may contain remote URLs or server-specific details; do + # not persist or expose it because the job API is user-visible. + raise AcquisitionError("git_failed", "Git source acquisition failed") from exc + return result.stdout.strip() + + def _mirror_path(self, repository: Repository) -> Path: + identity = f"{repository.provider}-{repository.provider_repository_id}" + safe = re.sub(r"[^A-Za-z0-9._-]", "_", identity) + return self.mirrors_root / f"{safe}.git" + + def _worktree_path(self, job_id: str) -> Path: + if not SAFE_JOB_ID.fullmatch(job_id): + raise AcquisitionError("invalid_job", "Scan job identity is invalid") + return self.worktrees_root / job_id + + @staticmethod + def _validate_branch(branch: str) -> None: + if ( + not SAFE_BRANCH.fullmatch(branch) + or branch.startswith("-") + or ".." in branch + or branch.endswith(("/", ".")) + ): + raise AcquisitionError("invalid_branch", "Repository default branch is invalid") + + def _validate_clone_url(self, clone_url: str | None) -> str: + if not clone_url or "\x00" in clone_url: + raise AcquisitionError("missing_clone_url", "Repository clone URL is unavailable") + try: + parsed = urlsplit(clone_url) + if parsed.username or parsed.password or parsed.query or parsed.fragment: + raise AcquisitionError("unsafe_clone_url", "Repository clone URL contains unsafe credentials or metadata") + if parsed.scheme in {"http", "https"}: + origin = self._origin(clone_url) + if self.token and (self.allowed_clone_origin is None or origin != self.allowed_clone_origin): + raise AcquisitionError("unsafe_clone_url", "Repository clone URL is outside the configured Gitea origin") + elif parsed.scheme != "file": + raise AcquisitionError("unsafe_clone_url", "Repository clone URL uses an unsupported scheme") + except ValueError as exc: + raise AcquisitionError("unsafe_clone_url", "Repository clone URL is invalid") from exc + return clone_url + + def acquire( + self, + repository: Repository, + job_id: str, + requested_revision: str | None = None, + ) -> AcquiredSource: + with self._repository_lock(repository.id): + return self._acquire(repository, job_id, requested_revision) + + def _acquire( + self, + repository: Repository, + job_id: str, + requested_revision: str | None = None, + ) -> AcquiredSource: + branch = repository.default_branch or "main" + self._validate_branch(branch) + if requested_revision is not None and not SAFE_REVISION.fullmatch(requested_revision): + raise AcquisitionError("invalid_revision", "Requested revision is not a valid commit identifier") + clone_url = self._validate_clone_url(repository.clone_url) + mirror = self._mirror_path(repository) + if mirror.exists() and not self._mirror_is_usable(mirror): + self._remove_mirror_if_owned(mirror) + if not mirror.exists(): + self._run(["git", "clone", "--mirror", clone_url, str(mirror)]) + else: + self._run(["git", "--git-dir", str(mirror), "remote", "set-url", "origin", clone_url]) + self._run( + [ + "git", + "--git-dir", + str(mirror), + "fetch", + "--prune", + "--no-tags", + "origin", + f"+refs/heads/{branch}:refs/remotes/origin/{branch}", + ] + ) + if requested_revision: + try: + actual_revision = self._run( + ["git", "--git-dir", str(mirror), "rev-parse", f"{requested_revision}^{{commit}}"] + ) + except AcquisitionError as exc: + raise AcquisitionError("revision_unavailable", "Requested commit was not found in the mirror") from exc + if actual_revision.casefold() != requested_revision.casefold() and len(requested_revision) == 40: + raise AcquisitionError("revision_unavailable", "Requested commit was not found in the mirror") + else: + actual_revision = self._run( + [ + "git", + "--git-dir", + str(mirror), + "rev-parse", + f"refs/remotes/origin/{branch}^{{commit}}", + ] + ) + if not SAFE_REVISION.fullmatch(actual_revision): + raise AcquisitionError("invalid_revision", "Git did not return a usable commit identifier") + + worktree = self._worktree_path(job_id) + self._remove_worktree_if_owned(mirror, worktree) + try: + self._run( + [ + "git", + "--git-dir", + str(mirror), + "worktree", + "add", + "--detach", + str(worktree), + actual_revision, + ] + ) + except AcquisitionError: + self._remove_worktree_if_owned(mirror, worktree) + raise + return AcquiredSource(path=worktree, actual_revision=actual_revision, branch=branch) + + def cleanup(self, source: AcquiredSource, repository: Repository) -> None: + with self._repository_lock(repository.id): + mirror = self._mirror_path(repository) + self._remove_worktree_if_owned(mirror, source.path) + + def _mirror_is_usable(self, mirror: Path) -> bool: + try: + return self._run(["git", "--git-dir", str(mirror), "rev-parse", "--is-bare-repository"]) == "true" + except AcquisitionError: + return False + + def _remove_mirror_if_owned(self, mirror: Path) -> None: + try: + relative = mirror.resolve().relative_to(self.mirrors_root.resolve()) + except (OSError, RuntimeError, ValueError): + raise AcquisitionError("unsafe_mirror", "Repository mirror path escaped the repository cache") + if not relative.parts: + raise AcquisitionError("unsafe_mirror", "Repository mirror path is invalid") + if mirror.is_dir() and not mirror.is_symlink(): + shutil.rmtree(mirror) + elif mirror.exists() or mirror.is_symlink(): + mirror.unlink() + + def _remove_worktree_if_owned(self, mirror: Path, worktree: Path) -> None: + try: + relative = worktree.resolve().relative_to(self.worktrees_root.resolve()) + except (OSError, RuntimeError, ValueError): + raise AcquisitionError("unsafe_worktree", "Worktree path escaped the repository cache") + if not relative.parts: + raise AcquisitionError("unsafe_worktree", "Worktree path is invalid") + if worktree.exists(): + try: + self._run(["git", "--git-dir", str(mirror), "worktree", "remove", "--force", str(worktree)]) + except AcquisitionError: + # A stale registration must not prevent a safe bounded cleanup. + pass + if worktree.exists(): + shutil.rmtree(worktree) + try: + self._run(["git", "--git-dir", str(mirror), "worktree", "prune"]) + except AcquisitionError: + pass diff --git a/backend/app/architecture.py b/backend/app/architecture.py new file mode 100644 index 0000000..fbec4bb --- /dev/null +++ b/backend/app/architecture.py @@ -0,0 +1,340 @@ +from __future__ import annotations + +import ast +import json +import math +import os +import re +from collections import Counter +from pathlib import Path + +from .models import ArchitectureEdge, ArchitectureGraph, ArchitectureNode, Hotspot + +JS_IMPORT_RE = re.compile( + r"(?:\bfrom\s+|\bimport\s*|\brequire\(\s*|\bimport\(\s*)['\"](?P[^'\"]+)['\"]" +) +JS_EXTENSIONS = (".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs") +SOURCE_ROOTS = {"src", "app", "backend", "frontend", "lib", "packages"} +CONFIG_IGNORED_DIRS = {".git", ".venv", "node_modules", "dist", "build", "coverage", "target", "vendor"} + + +def _bounded_config_files(root: Path, names: set[str], *, maximum: int = 20) -> list[Path]: + files: list[Path] = [] + for current, directories, candidates in os.walk(root, followlinks=False): + directories[:] = [name for name in directories if name.casefold() not in CONFIG_IGNORED_DIRS] + for name in candidates: + if name in names: + files.append(Path(current) / name) + if len(files) >= maximum: + return sorted(files) + return sorted(files) + + +def _ts_path_aliases(root: Path) -> list[tuple[str, str]]: + """Read a small local subset of tsconfig paths without resolving packages or URLs.""" + + aliases: list[tuple[str, str]] = [] + root_resolved = root.resolve() + for config in _bounded_config_files(root, {"tsconfig.json", "jsconfig.json"}): + try: + if config.stat().st_size > 256_000: + continue + raw = config.read_text(encoding="utf-8") + # Most project tsconfigs are JSON. Comments are deliberately not + # interpreted as configuration to keep this scanner deterministic. + data = json.loads(raw) + options = data.get("compilerOptions", {}) + paths = options.get("paths", {}) if isinstance(options, dict) else {} + if not isinstance(paths, dict): + continue + base_url = options.get("baseUrl", ".") if isinstance(options, dict) else "." + base = (config.parent / str(base_url)).resolve() + if base != root_resolved and root_resolved not in base.parents: + continue + for alias, targets in paths.items(): + if not isinstance(alias, str) or not isinstance(targets, list): + continue + for target in targets[:5]: + if not isinstance(target, str) or target.startswith(("/", "\\")): + continue + resolved = (base / target.replace("*", "placeholder")).resolve() + if resolved != root_resolved and root_resolved not in resolved.parents: + continue + aliases.append((alias, str((base / target).relative_to(root_resolved)).replace("\\", "/"))) + except (OSError, ValueError, json.JSONDecodeError, TypeError): + continue + return aliases[:100] + + +def _workspace_packages(root: Path) -> dict[str, Path]: + packages: dict[str, Path] = {} + for manifest in _bounded_config_files(root, {"package.json"}, maximum=100): + try: + if manifest.stat().st_size > 256_000: + continue + data = json.loads(manifest.read_text(encoding="utf-8")) + name = data.get("name") if isinstance(data, dict) else None + if isinstance(name, str) and name and not name.startswith((".", "/")): + packages.setdefault(name, manifest.parent) + except (OSError, ValueError, json.JSONDecodeError, TypeError): + continue + return packages + + +def _module_names(path: str) -> list[str]: + parts = list(Path(path).with_suffix("").parts) + if parts and parts[-1] == "__init__": + parts = parts[:-1] + names: list[str] = [] + if parts: + names.append(".".join(parts)) + if parts[0] in SOURCE_ROOTS and len(parts) > 1: + names.append(".".join(parts[1:])) + if len(parts) > 2 and parts[1] in SOURCE_ROOTS: + names.append(".".join(parts[2:])) + return [name for name in names if name] + + +def _python_module_map(paths: list[str]) -> dict[str, str]: + result: dict[str, str] = {} + for path in paths: + if not path.endswith(".py"): + continue + for module in _module_names(path): + result.setdefault(module, path) + return result + + +def _resolve_python_target(module: str, module_map: dict[str, str]) -> str | None: + candidate = module + while candidate: + if candidate in module_map: + return module_map[candidate] + if "." not in candidate: + break + candidate = candidate.rsplit(".", 1)[0] + return None + + +def _python_imports(path: str, text: str, module_map: dict[str, str]) -> set[str]: + try: + tree = ast.parse(text) + except SyntaxError: + return set() + + current_names = _module_names(path) + current = current_names[0] if current_names else "" + current_parts = current.split(".") if current else [] + if not path.endswith("/__init__.py") and current_parts: + package_parts = current_parts[:-1] + else: + package_parts = current_parts + + imports: set[str] = set() + for node in ast.walk(tree): + if isinstance(node, ast.Import): + for alias in node.names: + target = _resolve_python_target(alias.name, module_map) + if target and target != path: + imports.add(target) + elif isinstance(node, ast.ImportFrom): + module = node.module or "" + if node.level: + trim = max(0, node.level - 1) + prefix = package_parts[:-trim] if trim else package_parts + absolute = ".".join([*prefix, *([module] if module else [])]) + else: + absolute = module + target = _resolve_python_target(absolute, module_map) + if target and target != path: + imports.add(target) + return imports + + +def _resolve_js_target( + root: Path, + source_path: str, + specifier: str, + known: set[str], + aliases: list[tuple[str, str]], + workspace_packages: dict[str, Path], +) -> str | None: + if specifier.startswith("."): + source_dir = (root / source_path).parent + base = (source_dir / specifier).resolve() + else: + base = None + for alias, target in aliases: + if alias.endswith("/*") and specifier.startswith(alias[:-1]): + base = (root / target.replace("*", specifier[len(alias) - 1 :])).resolve() + break + if alias == specifier: + base = (root / target).resolve() + break + if base is None: + package_name = next( + (name for name in workspace_packages if specifier == name or specifier.startswith(f"{name}/")), + None, + ) + if package_name: + package_root = workspace_packages[package_name] + suffix = specifier.removeprefix(package_name).lstrip("/") + base = package_root / suffix if suffix else package_root / "src" / "index" + if base is None: + return None + try: + relative_base = base.relative_to(root.resolve()).as_posix() + except ValueError: + return None + + candidates = [relative_base] + suffix = Path(relative_base).suffix.lower() + if suffix in JS_EXTENSIONS: + extensionless = relative_base[: -len(suffix)] + candidates.extend(extensionless + extension for extension in JS_EXTENSIONS) + candidates.extend(f"{extensionless}/index{extension}" for extension in JS_EXTENSIONS) + elif not suffix: + candidates.extend(relative_base + extension for extension in JS_EXTENSIONS) + candidates.extend(f"{relative_base}/index{extension}" for extension in JS_EXTENSIONS) + return next((candidate for candidate in candidates if candidate in known), None) + + +def _js_imports( + root: Path, + path: str, + text: str, + known: set[str], + aliases: list[tuple[str, str]], + workspace_packages: dict[str, Path], +) -> set[str]: + imports: set[str] = set() + for match in JS_IMPORT_RE.finditer(text): + target = _resolve_js_target(root, path, match.group("target"), known, aliases, workspace_packages) + if target and target != path: + imports.add(target) + return imports + + +def build_architecture( + root: Path, + source_texts: dict[str, str], + language_by_path: dict[str, str], + loc_by_path: dict[str, int], + debt_by_path: dict[str, int], + churn_by_path: dict[str, int], + *, + max_nodes: int = 160, + max_edges: int = 600, +) -> tuple[ArchitectureGraph, list[Hotspot]]: + max_nodes = max(1, max_nodes) + max_edges = max(0, max_edges) + known_paths = set(source_texts) + module_map = _python_module_map(list(known_paths)) + ts_aliases = _ts_path_aliases(root) + workspace_packages = _workspace_packages(root) + edge_pairs: set[tuple[str, str]] = set() + total_inbound: Counter[str] = Counter() + total_outbound: Counter[str] = Counter() + total_edges = 0 + truncated = len(known_paths) > max_nodes + + for path in sorted(source_texts): + text = source_texts[path] + language = language_by_path.get(path, "") + if language == "Python": + targets = _python_imports(path, text, module_map) + elif language in {"TypeScript", "JavaScript"}: + targets = _js_imports(root, path, text, known_paths, ts_aliases, workspace_packages) + else: + targets = set() + for target in sorted(targets): + if target not in known_paths: + continue + pair = (path, target) + total_edges += 1 + total_outbound[path] += 1 + total_inbound[target] += 1 + if len(edge_pairs) < max_edges: + edge_pairs.add(pair) + else: + truncated = True + + hotspots: list[Hotspot] = [] + for path in known_paths: + loc = loc_by_path.get(path, 0) + debt = debt_by_path.get(path, 0) + churn = churn_by_path.get(path, 0) + coupling = total_inbound[path] + total_outbound[path] + score = min( + 100, + round( + min(30, loc / 40) + + min(20, debt * 4) + + min(30, math.log10(churn + 1) * 10 if churn else 0) + + min(20, coupling * 2.5) + ), + ) + reasons: list[str] = [] + if loc >= 500: + reasons.append(f"large module ({loc} LOC)") + if debt: + reasons.append(f"{debt} debt markers") + if churn >= 300: + reasons.append(f"high recent churn ({churn} changed lines)") + if coupling >= 8: + reasons.append(f"high coupling ({coupling} local edges)") + if not reasons and score >= 30: + reasons.append("combined size, churn and coupling") + hotspots.append( + Hotspot( + path=path, + language=language_by_path.get(path, "Other"), + lines_of_code=loc, + debt_markers=debt, + churn=churn, + inbound=total_inbound[path], + outbound=total_outbound[path], + score=score, + reasons=reasons, + ) + ) + + hotspots.sort(key=lambda item: (-item.score, -item.churn, -item.lines_of_code, item.path)) + selected_paths = {item.path for item in hotspots[:max_nodes]} + graph_edges = [ + ArchitectureEdge(source=source, target=target) + for source, target in sorted(edge_pairs) + if source in selected_paths and target in selected_paths + ][:max_edges] + visible_inbound: Counter[str] = Counter() + visible_outbound: Counter[str] = Counter() + for edge in graph_edges: + visible_outbound[edge.source] += 1 + visible_inbound[edge.target] += 1 + hotspot_scores = {item.path: item.score for item in hotspots} + nodes = [ + ArchitectureNode( + id=path, + label=Path(path).name, + path=path, + language=language_by_path.get(path, "Other"), + inbound=total_inbound[path], + outbound=total_outbound[path], + visible_inbound=visible_inbound[path], + visible_outbound=visible_outbound[path], + hotspot_score=hotspot_scores[path], + ) + for path in sorted(selected_paths) + ] + clusters = Counter((Path(path).parts[0] if len(Path(path).parts) > 1 else "root") for path in selected_paths) + return ( + ArchitectureGraph( + nodes=nodes, + edges=graph_edges, + clusters=dict(clusters.most_common()), + truncated=truncated, + total_nodes=len(known_paths), + total_edges=total_edges, + ), + hotspots[:30], + ) diff --git a/backend/app/git_analysis.py b/backend/app/git_analysis.py new file mode 100644 index 0000000..891e361 --- /dev/null +++ b/backend/app/git_analysis.py @@ -0,0 +1,104 @@ +from __future__ import annotations + +import subprocess +from collections import Counter +from datetime import datetime +from pathlib import Path + +from .models import GitSignals + + +def _run(root: Path, *args: str, timeout: int = 8) -> str | None: + try: + result = subprocess.run( + ["git", "-C", str(root), *args], + check=True, + capture_output=True, + text=True, + errors="replace", + timeout=timeout, + ) + except (OSError, UnicodeError, subprocess.SubprocessError): + return None + return result.stdout + + +def analyze_git(root: Path) -> tuple[GitSignals, dict[str, int]]: + top_level = _run(root, "rev-parse", "--show-toplevel") + if not top_level: + return GitSignals(), {} + try: + if Path(top_level.strip()).resolve() != root.resolve(): + return GitSignals(), {} + except (OSError, RuntimeError, ValueError): + return GitSignals(), {} + + inside = _run(root, "rev-parse", "--is-inside-work-tree") + if not inside or inside.strip() != "true": + return GitSignals(), {} + + raw_count = _run(root, "rev-list", "--count", "HEAD") + raw_latest = _run(root, "log", "-1", "--format=%aI") + raw_authors = _run(root, "log", "--format=%aN%x00%aE", "-n", "2000") + raw_files = _run(root, "ls-files", "-z") + raw_churn = _run(root, "log", "--numstat", "--format=", "--find-renames=20%", "-n", "200") + raw_renames = _run(root, "log", "--name-status", "--format=", "--find-renames=20%", "-n", "200") + + contributors: set[str] = set() + if raw_authors: + for line in raw_authors.splitlines(): + if line.strip(): + contributors.add(line.strip()) + + churn: Counter[str] = Counter() + renamed_files: set[str] = set() + rename_map: dict[str, str] = {} + if raw_renames: + for line in raw_renames.splitlines(): + parts = line.split("\t") + if len(parts) >= 3 and parts[0].startswith("R"): + old_path, new_path = parts[-2:] + rename_map[old_path] = new_path + renamed_files.add(new_path) + if raw_churn: + for line in raw_churn.splitlines(): + parts = line.split("\t", 2) + if len(parts) != 3: + continue + additions, deletions, path = parts + churn_path = _rename_target(path) if " => " in path else rename_map.get(path, path) + if " => " in path: + renamed_files.add(churn_path) + if additions.isdigit(): + churn[churn_path] += int(additions) + if deletions.isdigit(): + churn[churn_path] += int(deletions) + + latest_commit_at = None + if raw_latest and raw_latest.strip(): + try: + latest_commit_at = datetime.fromisoformat(raw_latest.strip()) + except ValueError: + latest_commit_at = None + + return ( + GitSignals( + available=True, + commit_count=int(raw_count.strip()) if raw_count and raw_count.strip().isdigit() else None, + contributor_count=len(contributors) if contributors else None, + latest_commit_at=latest_commit_at, + tracked_files=len([item for item in raw_files.split("\0") if item]) if raw_files is not None else None, + renamed_files=sorted(renamed_files), + ), + dict(churn), + ) + + +def _rename_target(path: str) -> str: + """Normalize Git's brace-formatted rename path to the new path.""" + if "{" in path and "}" in path: + prefix, remainder = path.split("{", 1) + inner, suffix = remainder.split("}", 1) + if " => " in inner: + return f"{prefix}{inner.split(' => ', 1)[1]}{suffix}" + return path.rsplit(" => ", 1)[-1] diff --git a/backend/app/gitea.py b/backend/app/gitea.py new file mode 100644 index 0000000..7aeba73 --- /dev/null +++ b/backend/app/gitea.py @@ -0,0 +1,314 @@ +from __future__ import annotations + +import json +import os +import urllib.error +import urllib.parse +import urllib.request +from collections.abc import Callable +from concurrent.futures import ThreadPoolExecutor +from datetime import UTC, datetime +from typing import Any + +from .models import Repository, RepositoryPolicy, RepositorySyncResult + +JsonTransport = Callable[[str, dict[str, str]], tuple[int, bytes]] + + +class GiteaError(RuntimeError): + def __init__(self, code: str, detail: str, *, status_code: int | None = None) -> None: + super().__init__(detail) + self.code = code + self.detail = detail + self.status_code = status_code + + +def _parse_time(value: object) -> datetime | None: + if not isinstance(value, str) or not value: + return None + try: + parsed = datetime.fromisoformat(value) + except ValueError: + return None + return parsed.replace(tzinfo=UTC) if parsed.tzinfo is None else parsed + + +class GiteaClient: + """Small, read-only Gitea API client with bounded pagination and safe errors.""" + + def __init__( + self, + base_url: str | None = None, + token: str | None = None, + *, + timeout: float = 10.0, + page_size: int = 50, + max_pages: int = 20, + max_repositories: int = 500, + max_branch_workers: int | None = None, + transport: JsonTransport | None = None, + ) -> None: + self.base_url = (base_url or os.getenv("REPOPULSE_GITEA_URL", "")).rstrip("/") + self.token = token if token is not None else os.getenv("REPOPULSE_GITEA_TOKEN", "") + self.timeout = max(1.0, timeout) + self.page_size = max(1, min(page_size, 100)) + self.max_pages = max(1, max_pages) + self.max_repositories = max(1, max_repositories) + if max_branch_workers is None: + try: + configured_workers = int(os.getenv("REPOPULSE_GITEA_BRANCH_WORKERS", "4")) + except ValueError: + configured_workers = 4 + else: + configured_workers = max_branch_workers + self.max_branch_workers = min(8, max(1, configured_workers)) + self.transport = transport + self._listing_complete = True + + @property + def configured(self) -> bool: + return bool(self.base_url and self.token) + + def _request_json(self, path: str, params: dict[str, str | int] | None = None) -> Any: + if not self.base_url: + raise GiteaError("not_configured", "Gitea URL is not configured") + query = urllib.parse.urlencode(params or {}) + url = f"{self.base_url}/api/v1/{path.lstrip('/')}" + if query: + url = f"{url}?{query}" + headers = { + "Accept": "application/json", + "User-Agent": "RepoPulse/1.5", + } + if self.token: + headers["Authorization"] = f"token {self.token}" + try: + if self.transport: + status_code, raw = self.transport(url, headers) + if status_code >= 400: + self._raise_for_status(status_code) + else: + request = urllib.request.Request(url, headers=headers, method="GET") + with urllib.request.urlopen(request, timeout=self.timeout) as response: + status_code = int(response.status) + raw = response.read(2_000_001) + if status_code >= 400: + self._raise_for_status(status_code) + except GiteaError: + raise + except urllib.error.HTTPError as exc: + self._raise_for_status(exc.code) + except (urllib.error.URLError, TimeoutError, OSError) as exc: + raise GiteaError("unreachable", "Gitea could not be reached") from exc + if not isinstance(raw, bytes): + raise GiteaError("invalid_response", "Gitea returned an invalid response body") + if len(raw) > 2_000_000: + raise GiteaError("response_too_large", "Gitea response exceeded the configured bound") + try: + return json.loads(raw.decode("utf-8")) + except (UnicodeDecodeError, json.JSONDecodeError) as exc: + raise GiteaError("invalid_response", "Gitea returned invalid JSON") from exc + + @staticmethod + def _raise_for_status(status_code: int) -> None: + if status_code in {401, 403}: + raise GiteaError("authentication", "Gitea authentication was rejected", status_code=status_code) + if status_code == 404: + raise GiteaError("not_found", "The requested Gitea resource was not found", status_code=status_code) + if status_code == 429: + raise GiteaError("rate_limited", "Gitea rate-limited the request", status_code=status_code) + if status_code >= 500: + raise GiteaError("upstream", "Gitea returned a server error", status_code=status_code) + raise GiteaError("request_failed", "Gitea rejected the request", status_code=status_code) + + def _repository_from_payload(self, payload: object) -> Repository: + if not isinstance(payload, dict): + raise GiteaError("invalid_repository", "Gitea returned an invalid repository record") + raw_id = payload.get("id") + if isinstance(raw_id, bool) or not isinstance(raw_id, (int, str)) or not str(raw_id).isdigit(): + raise GiteaError("invalid_repository", "Gitea repository identity is invalid") + owner_payload = payload.get("owner") + owner = owner_payload.get("login") if isinstance(owner_payload, dict) else None + owner = owner or payload.get("owner_name") + name = payload.get("name") + full_name = payload.get("full_name") + if not isinstance(owner, str) or not isinstance(name, str): + if isinstance(full_name, str) and "/" in full_name: + owner, name = full_name.split("/", 1) + else: + raise GiteaError("invalid_repository", "Gitea repository name is invalid") + full_name = full_name if isinstance(full_name, str) else f"{owner}/{name}" + repository_id = str(raw_id) + # Do not trust a provider-supplied clone host when constructing the + # credential-bearing acquisition URL. The configured Gitea origin is + # the only network destination that may receive the server token. + clone_url = ( + f"{self.base_url}/{urllib.parse.quote(owner, safe='')}/" + f"{urllib.parse.quote(name, safe='')}.git" + ) + html_url = payload.get("html_url") + default_branch = payload.get("default_branch") or "main" + return Repository( + id=f"gitea:{repository_id}", + provider="gitea", + provider_repository_id=repository_id, + owner=owner, + name=name, + full_name=full_name, + description=payload.get("description") if isinstance(payload.get("description"), str) else None, + html_url=html_url if isinstance(html_url, str) else None, + clone_url=clone_url if isinstance(clone_url, str) else None, + default_branch=str(default_branch), + private=bool(payload.get("private", False)), + archived=bool(payload.get("archived", False)), + latest_revision_at=_parse_time(payload.get("updated_at")), + policy=RepositoryPolicy(), + ) + + def list_repositories(self) -> list[Repository]: + if not self.configured: + raise GiteaError("not_configured", "Gitea connector is not configured") + repositories: list[Repository] = [] + self._listing_complete = False + for page in range(1, self.max_pages + 1): + payload = self._request_json( + "user/repos", + {"limit": self.page_size, "page": page, "sort": "updated", "direction": "desc"}, + ) + if not isinstance(payload, list): + raise GiteaError("invalid_response", "Gitea repository listing was not a list") + for item in payload: + if len(repositories) >= self.max_repositories: + return repositories + repositories.append(self._repository_from_payload(item)) + if len(payload) < self.page_size: + self._listing_complete = True + break + return repositories + + def branch_revision(self, repository: Repository) -> str: + owner = urllib.parse.quote(repository.owner, safe="") + name = urllib.parse.quote(repository.name, safe="") + branch = urllib.parse.quote(repository.default_branch, safe="") + payload = self._request_json(f"repos/{owner}/{name}/branches/{branch}") + if not isinstance(payload, dict): + raise GiteaError("invalid_response", "Gitea branch response was invalid") + commit = payload.get("commit") + revision = None + if isinstance(commit, dict): + revision = commit.get("id") or commit.get("sha") + if ( + not isinstance(revision, str) + or not 7 <= len(revision) <= 64 + or not all(char in "0123456789abcdefABCDEF" for char in revision) + ): + raise GiteaError("invalid_revision", "Gitea did not return a usable branch revision") + return revision + + def discover_with_errors(self) -> tuple[list[Repository], list[tuple[Repository, str]], list[str]]: + """Resolve branch tips independently so one repository cannot abort a catalog sync.""" + + repositories = self.list_repositories() + + def resolve(repository: Repository) -> tuple[Repository, str | None, str | None]: + try: + return repository, self.branch_revision(repository), None + except GiteaError as exc: + return repository, None, f"{repository.full_name}: {exc.code}: {exc.detail}" + + with ThreadPoolExecutor(max_workers=min(self.max_branch_workers, len(repositories) or 1)) as executor: + outcomes = list(executor.map(resolve, repositories)) + discovered = [ + (repository.model_copy(update={"latest_revision": revision}), revision) + for repository, revision, error in outcomes + if revision is not None and error is None + ] + errors = [error for _, _, error in outcomes if error] + return repositories, discovered, errors + + def discover(self) -> list[tuple[Repository, str]]: + """Compatibility helper for callers needing only successfully resolved repositories.""" + + _, discovered, _ = self.discover_with_errors() + return discovered + + def sync(self, store) -> RepositorySyncResult: + synced_at = datetime.now(UTC) + try: + listed, discovered, branch_errors = self.discover_with_errors() + except GiteaError as exc: + error = f"{exc.code}: {exc.detail}" + for existing in store.list_repositories(limit=1000): + if existing.provider == "gitea" and existing.available: + store.update_repository_sync(existing, synced_at=synced_at, error=error) + result = RepositorySyncResult( + provider="gitea", + errors=[error], + synced_at=synced_at, + ) + store.record_sync_result(result) + return result + created = 0 + updated = 0 + listed_ids = {repository.id for repository in listed} + seen_ids: set[str] = set() + for repository, revision in discovered: + seen_ids.add(repository.id) + before = store.get_repository(repository.id) + merged = repository.model_copy( + update={ + "available": True, + "last_synced_at": synced_at, + "sync_error": None, + "latest_revision": revision, + "policy": before.policy if before else RepositoryPolicy(), + } + ) + store.upsert_repository(merged) + if before is None: + created += 1 + else: + updated += 1 + for repository in listed: + if repository.id in seen_ids: + continue + before = store.get_repository(repository.id) + error = next((item for item in branch_errors if item.startswith(f"{repository.full_name}:")), None) + merged = repository.model_copy( + update={ + "available": True, + "last_synced_at": synced_at, + "sync_error": error or "branch: revision could not be resolved", + "latest_revision": before.latest_revision if before else None, + "policy": before.policy if before else RepositoryPolicy(), + } + ) + store.upsert_repository(merged) + if before is None: + created += 1 + else: + updated += 1 + unavailable = 0 + if self._listing_complete: + for existing in store.list_repositories(limit=1000): + if existing.provider == "gitea" and existing.id not in listed_ids and existing.available: + store.update_repository_sync( + existing.model_copy(update={"available": False}), + synced_at=synced_at, + error="not_discovered", + ) + unavailable += 1 + result = RepositorySyncResult( + provider="gitea", + discovered=len(discovered), + created=created, + updated=updated, + unavailable=unavailable, + errors=branch_errors, + partial=bool(branch_errors) or not self._listing_complete, + branch_failures=len(branch_errors), + listing_complete=self._listing_complete, + synced_at=synced_at, + ) + store.record_sync_result(result) + return result diff --git a/backend/app/jobs.py b/backend/app/jobs.py new file mode 100644 index 0000000..f0c73fb --- /dev/null +++ b/backend/app/jobs.py @@ -0,0 +1,330 @@ +from __future__ import annotations + +import logging +import os +from datetime import UTC, datetime +from threading import Event, Lock, Thread, current_thread +from time import monotonic + +from .acquisition import AcquisitionError, GitAcquirer +from .gitea import GiteaClient +from .models import ( + Repository, + RepositorySyncResult, + ScanJob, + ScanJobStatus, + ScanSource, + ScanTrigger, + SourceOrigin, +) +from .scanner import scan_repository +from .store import MaintenanceModeError, QueueFullError, ScanStore, job_lease_seconds + +LOGGER = logging.getLogger(__name__) + + +def _positive_int(name: str, default: int, *, maximum: int | None = None) -> int: + try: + value = max(1, int(os.getenv(name, str(default)))) + except ValueError: + value = default + return min(value, maximum) if maximum else value + + +def _positive_float(name: str, default: float) -> float: + try: + return max(0.2, float(os.getenv(name, str(default)))) + except ValueError: + return default + + +class ScanJobRunner: + """Single-process durable worker and bounded Gitea scheduler.""" + + def __init__( + self, + store: ScanStore, + *, + gitea: GiteaClient | None = None, + acquirer: GitAcquirer | None = None, + poll_seconds: float = 0.5, + sync_interval_seconds: float | None = None, + max_queue: int | None = None, + ) -> None: + self.store = store + self.gitea = gitea or GiteaClient() + self.acquirer = acquirer or GitAcquirer() + self.poll_seconds = max(0.2, poll_seconds) + self.sync_interval_seconds = sync_interval_seconds or _positive_float( + "REPOPULSE_GITEA_SYNC_INTERVAL_SECONDS", 300.0 + ) + self.max_queue = max_queue or _positive_int("REPOPULSE_MAX_QUEUED_SCANS", 100, maximum=1000) + self._stop = Event() + self._thread: Thread | None = None + self._last_sync = float("-inf") + self._sync_lock = Lock() + + @property + def started(self) -> bool: + return self._thread is not None and self._thread.is_alive() + + def start(self) -> None: + if self.started: + return + self._stop.clear() + self._thread = Thread(target=self._run, name="repopulse-scan-worker", daemon=True) + self._thread.start() + + def stop(self) -> None: + self._stop.set() + thread = self._thread + if thread and thread is not current_thread(): + thread.join(timeout=5) + if thread is None or not thread.is_alive(): + self._thread = None + + def _run(self) -> None: + while not self._stop.is_set(): + try: + job = self._run_iteration() + except MaintenanceModeError: + job = None + except Exception: + self._last_sync = monotonic() + LOGGER.exception("RepoPulse worker loop recovered from an unexpected failure") + job = None + if job is None: + self._stop.wait(self.poll_seconds) + + def _run_iteration(self) -> ScanJob | None: + """Perform one scheduler pass unless durable maintenance has paused work.""" + + if self.store.maintenance_status()["enabled"]: + return None + if not self.store.touch_worker_heartbeat_if_active(datetime.now(UTC).isoformat()): + return None + if self.gitea.configured and monotonic() - self._last_sync >= self.sync_interval_seconds: + self.sync_now() + if self.store.maintenance_status()["enabled"]: + return None + return self.process_one() + + def sync_now(self) -> RepositorySyncResult: + with self._sync_lock: + if self.store.maintenance_status()["enabled"]: + raise MaintenanceModeError("RepoPulse is in maintenance mode") + if not self.gitea.configured: + result = RepositorySyncResult( + provider="gitea", + errors=["not_configured: Gitea connector is not configured"], + synced_at=datetime.now(UTC), + ) + self.store.record_sync_result(result) + self._last_sync = monotonic() + return result + try: + result = self.gitea.sync(self.store) + except Exception: + self._last_sync = monotonic() + raise + self._last_sync = monotonic() + if not result.errors: + self._schedule_changed_repositories() + return result + + def _schedule_changed_repositories(self) -> None: + if self.store.maintenance_status()["enabled"]: + return + for summary in self.store.list_repositories(limit=1000): + if summary.provider != "gitea" or summary.archived or not summary.latest_revision: + continue + if not summary.policy.auto_scan: + continue + if summary.last_scan_revision and summary.last_scan_revision == summary.latest_revision: + continue + try: + self.store.enqueue_job( + summary.id, + summary.latest_revision, + ScanTrigger.SCHEDULED, + max_queue=self.max_queue, + ) + except (MaintenanceModeError, QueueFullError, KeyError): + continue + + def set_maintenance_mode(self, enabled: bool) -> dict[str, object]: + """Serialize maintenance changes with catalog reconciliation and scan scheduling.""" + + with self._sync_lock: + return self.store.set_maintenance_mode(enabled) + + def enqueue( + self, + repository: Repository, + *, + force: bool = False, + trigger: ScanTrigger = ScanTrigger.MANUAL, + ) -> ScanJob: + requested_revision = repository.latest_revision + return self.store.enqueue_job( + repository.id, + requested_revision, + trigger, + force=force, + max_queue=self.max_queue, + ) + + def process_one(self) -> ScanJob | None: + job = self.store.claim_next_job() + if job is None: + return None + try: + self._process(job) + except Exception: + LOGGER.exception("RepoPulse scan job failed outside the isolated job handler") + try: + self.store.update_job( + job.id, + status=ScanJobStatus.FAILED, + phase="failed", + progress=100, + error_code="internal_error", + error_detail="Unexpected repository analysis failure", + message="Repository analysis failed", + ) + except Exception: + LOGGER.exception("RepoPulse could not persist an unexpected job failure") + return self.store.get_job(job.id) + + class _LeaseHeartbeat: + def __init__(self, store: ScanStore, job_id: str) -> None: + self.store = store + self.job_id = job_id + self.stop_event = Event() + self.thread = Thread(target=self._run, name=f"repopulse-lease-{job_id[:8]}", daemon=True) + + def start(self) -> None: + self.thread.start() + + def stop(self) -> None: + self.stop_event.set() + self.thread.join(timeout=2) + + def _run(self) -> None: + interval = max(1.0, job_lease_seconds() / 3) + while not self.stop_event.wait(interval): + try: + self.store.renew_job_lease(self.job_id) + except Exception: + LOGGER.warning("RepoPulse could not renew a scan-job lease", exc_info=True) + + def _process(self, job: ScanJob) -> None: + repository = self.store.get_repository(job.repository_id) + if repository is None: + self.store.update_job( + job.id, + status=ScanJobStatus.FAILED, + phase="failed", + progress=100, + error_code="repository_not_found", + error_detail="Repository catalog entry no longer exists", + ) + return + source_path = None + acquired = None + lease_heartbeat = self._LeaseHeartbeat(self.store, job.id) + lease_heartbeat.start() + try: + if repository.provider != "gitea": + source_path = self.store.get_repository_source_path(repository.id) + if not source_path: + raise AcquisitionError("source_unavailable", "Local repository source is unavailable") + actual_revision = job.requested_revision + branch = repository.default_branch + else: + acquired = self.acquirer.acquire(repository, job.id, job.requested_revision) + source_path = str(acquired.path) + actual_revision = acquired.actual_revision + branch = acquired.branch + self.store.update_job( + job.id, + status=ScanJobStatus.SCANNING, + phase="scanning", + progress=30, + actual_revision=actual_revision, + message="Running deterministic repository analysis", + ) + source = ScanSource( + origin=SourceOrigin.GITEA if repository.provider == "gitea" else SourceOrigin.LOCAL, + provider=repository.provider, + repository_id=repository.id, + repository_full_name=repository.full_name, + branch=branch, + requested_revision=job.requested_revision, + actual_revision=actual_revision, + trigger=job.trigger, + ) + report = scan_repository(source_path, source=source, display_name=repository.name) + self.store.update_job( + job.id, + status=ScanJobStatus.ANALYZING, + phase="analyzing", + progress=80, + message="Persisting report and comparison baseline", + ) + self.store.update_job( + job.id, + status=ScanJobStatus.PERSISTING, + phase="persisting", + progress=90, + message="Saving report and revision history", + ) + saved = self.store.save(report) + self.store.upsert_repository(repository.model_copy(update={"policy": saved.policy})) + self.store.update_job( + job.id, + status=ScanJobStatus.COMPLETED, + phase="completed", + progress=100, + actual_revision=saved.source.actual_revision, + scan_id=saved.id, + message="Scan completed", + ) + except AcquisitionError as exc: + self.store.update_job( + job.id, + status=ScanJobStatus.FAILED, + phase="failed", + progress=100, + error_code=exc.code, + error_detail=exc.detail, + message="Repository source acquisition failed", + ) + except (ValueError, PermissionError, OSError) as exc: + self.store.update_job( + job.id, + status=ScanJobStatus.FAILED, + phase="failed", + progress=100, + error_code="scan_failed", + error_detail=str(exc) if isinstance(exc, ValueError) else "Repository analysis failed", + message="Repository analysis failed", + ) + except Exception: + LOGGER.exception("RepoPulse scan job failed without exposing job details") + self.store.update_job( + job.id, + status=ScanJobStatus.FAILED, + phase="failed", + progress=100, + error_code="internal_error", + error_detail="Unexpected repository analysis failure", + message="Repository analysis failed", + ) + finally: + lease_heartbeat.stop() + if acquired is not None and repository is not None: + try: + self.acquirer.cleanup(acquired, repository) + except AcquisitionError: + LOGGER.warning("Unable to clean one RepoPulse worktree") diff --git a/backend/app/main.py b/backend/app/main.py new file mode 100644 index 0000000..64e0b97 --- /dev/null +++ b/backend/app/main.py @@ -0,0 +1,491 @@ +from __future__ import annotations + +import asyncio +import hashlib +import hmac +import json +import os +from contextlib import asynccontextmanager +from pathlib import Path +from threading import BoundedSemaphore, Lock + +from fastapi import FastAPI, HTTPException, Query, Request, Response, status +from fastapi.concurrency import run_in_threadpool +from fastapi.responses import JSONResponse +from fastapi.staticfiles import StaticFiles + +from .acquisition import GitAcquirer +from .gitea import GiteaClient +from .jobs import ScanJobRunner +from .models import ( + RepositoryDetail, + RepositoryScanRequest, + RepositorySummary, + RepositorySyncResult, + ScanComparison, + ScanJob, + ScanReport, + ScanRequest, + ScanSummary, + ScanTrigger, + TrendPoint, + WebhookResponse, +) +from .reporting import content_disposition, render_html_report, safe_report_filename +from .scanner import scan_repository +from .store import MaintenanceModeError, QueueFullError, ScanStore + +VERSION = "1.5.0" +store = ScanStore() +SCAN_ROOT = os.getenv("REPOPULSE_SCAN_ROOT") + + +def _positive_int_env(name: str, default: int) -> int: + try: + return max(1, int(os.getenv(name, str(default)))) + except ValueError: + return default + + +# The durable queue has one real worker. Keep direct legacy path scans at the +# same capacity rather than advertising concurrency that cannot be delivered. +REQUESTED_MAX_CONCURRENT_SCANS = _positive_int_env("REPOPULSE_MAX_CONCURRENT_SCANS", 1) +MAX_CONCURRENT_SCANS = 1 +SCAN_SLOTS = BoundedSemaphore(MAX_CONCURRENT_SCANS) +gitea_client = GiteaClient() +repository_acquirer = GitAcquirer() +job_runner: ScanJobRunner | None = None +_api_mutation_lock = Lock() +_MAINTENANCE_ENTER_PATH = "/api/v1/operator/maintenance/enter" +_MAINTENANCE_EXIT_PATH = "/api/v1/operator/maintenance/exit" + + +def _get_runner() -> ScanJobRunner: + global job_runner + if job_runner is None or job_runner.store is not store: + job_runner = ScanJobRunner( + store, + gitea=gitea_client, + acquirer=repository_acquirer, + ) + return job_runner + + +@asynccontextmanager +async def lifespan(_app: FastAPI): + runner = _get_runner() + runner.start() + try: + yield + finally: + runner.stop() + + +app = FastAPI(title="RepoPulse API", version=VERSION, lifespan=lifespan) + + +@app.middleware("http") +async def maintenance_mutation_gate(request: Request, call_next): + """Serialize external API writes with maintenance transitions and reject writes while paused.""" + + if not request.url.path.startswith("/api/v1/") or request.method in {"GET", "HEAD", "OPTIONS"}: + return await call_next(request) + if request.url.path in {_MAINTENANCE_ENTER_PATH, _MAINTENANCE_EXIT_PATH}: + return await call_next(request) + + await run_in_threadpool(_api_mutation_lock.acquire) + try: + if store.maintenance_status()["enabled"]: + return JSONResponse( + status_code=status.HTTP_423_LOCKED, + content={"detail": "RepoPulse is in maintenance mode"}, + headers={"Retry-After": "30"}, + ) + return await call_next(request) + finally: + _api_mutation_lock.release() + + +def _maintenance_snapshot() -> dict[str, object]: + mode = store.maintenance_status() + stats = store.queue_stats() + queued = int(stats["queued"]) + active = int(stats["active"]) + return { + **mode, + "queue_depth": queued, + "active_jobs": active, + "active_drained": active == 0, + "drained": queued == 0 and active == 0, + } + + +def _require_mutation_authorization(request: Request, *, strict: bool = False) -> None: + """Use an operator token when configured; deployment perimeter remains explicit otherwise.""" + + token = os.getenv("REPOPULSE_OPERATOR_TOKEN", "") + if strict: + token = os.getenv("REPOPULSE_MAINTENANCE_TOKEN", "") or token + if not token: + if strict: + raise HTTPException(status_code=503, detail="Operator token is not configured") + return + supplied = request.headers.get("x-repopulse-token", "") + if not hmac.compare_digest(supplied, token): + raise HTTPException(status_code=401, detail="Operator authorization is required") + + +def _resolve_scan_path(raw_path: str) -> Path: + supplied = Path(raw_path).expanduser() + if SCAN_ROOT: + root = Path(SCAN_ROOT).expanduser().resolve() + candidate = (root / supplied).resolve() if not supplied.is_absolute() else supplied.resolve() + if candidate != root and root not in candidate.parents: + raise ValueError(f"Path must be inside configured scan root {root}") + return candidate + return supplied.resolve() + + +@app.get("/health") +def health() -> dict[str, str]: + recovery = store.database_recovery_status() + status = "degraded" if recovery.get("status") == "degraded_recovered" else "ok" + return {"status": status} + + +@app.get("/api/v1/meta") +def meta() -> dict[str, object]: + stats = store.queue_stats() + repository_states = store.repository_state_counts() + last_sync = store.get_state("last_gitea_sync") + parsed_sync: object = None + if last_sync: + try: + parsed_sync = json.loads(last_sync) + except json.JSONDecodeError: + parsed_sync = last_sync + return { + "name": "RepoPulse", + "version": VERSION, + "stage": "v1.5.0", + "scan_root_restricted": bool(SCAN_ROOT), + "scan_root": SCAN_ROOT, + "max_concurrent_scans": MAX_CONCURRENT_SCANS, + "requested_max_concurrent_scans": REQUESTED_MAX_CONCURRENT_SCANS, + "repository_count": store.repository_count(), + "repository_states": repository_states, + "current_repositories": repository_states.get("current", 0), + "stale_repositories": repository_states.get("stale", 0), + "queue_depth": stats["queued"], + "active_jobs": stats["active"], + "completed_jobs": stats["completed"], + "failed_jobs": stats["failed"], + "worker_heartbeat": stats["worker_heartbeat"], + "gitea": { + "configured": gitea_client.configured, + "url": gitea_client.base_url or None, + "last_sync": parsed_sync, + }, + "storage": store.storage_stats(), + "database_recovery": store.database_recovery_status(), + "maintenance": _maintenance_snapshot(), + "mutation_authentication": "operator_token" if os.getenv("REPOPULSE_OPERATOR_TOKEN") else "perimeter_required", + } + + +@app.get("/api/v1/operator/maintenance") +def get_maintenance_status(request: Request) -> dict[str, object]: + _require_mutation_authorization(request, strict=True) + return _maintenance_snapshot() + + +@app.post("/api/v1/operator/maintenance/enter") +def enter_maintenance(request: Request) -> dict[str, object]: + _require_mutation_authorization(request, strict=True) + with _api_mutation_lock: + if store.maintenance_status()["enabled"]: + raise HTTPException(status_code=423, detail="RepoPulse is already in maintenance mode") + _get_runner().set_maintenance_mode(True) + return _maintenance_snapshot() + + +@app.post("/api/v1/operator/maintenance/exit") +def exit_maintenance(request: Request) -> dict[str, object]: + _require_mutation_authorization(request, strict=True) + with _api_mutation_lock: + _get_runner().set_maintenance_mode(False) + return _maintenance_snapshot() + + +@app.post("/api/v1/scans", response_model=ScanReport, status_code=status.HTTP_201_CREATED) +async def create_scan(payload: ScanRequest, request: Request) -> ScanReport: + _require_mutation_authorization(request) + try: + repository_path = _resolve_scan_path(payload.path) + except ValueError as exc: + raise HTTPException(status_code=422, detail=str(exc)) from exc + + if not SCAN_SLOTS.acquire(blocking=False): + raise HTTPException( + status_code=429, + detail="Repository scan capacity is currently in use; retry after the active scan completes", + headers={"Retry-After": "2"}, + ) + + try: + report = await asyncio.to_thread(scan_repository, str(repository_path)) + except ValueError as exc: + raise HTTPException(status_code=422, detail=str(exc)) from exc + except PermissionError as exc: + raise HTTPException(status_code=403, detail="Repository path cannot be read") from exc + except OSError as exc: + raise HTTPException(status_code=422, detail="Repository path cannot be scanned") from exc + finally: + SCAN_SLOTS.release() + return store.save(report) + + +@app.get("/api/v1/repositories", response_model=list[RepositorySummary]) +def list_repositories( + limit: int = Query(default=100, ge=1, le=1000), + offset: int = Query(default=0, ge=0, le=100_000), +) -> list[RepositorySummary]: + return store.list_repositories(limit, offset) + + +@app.post("/api/v1/repositories/sync", response_model=RepositorySyncResult) +async def sync_repositories(request: Request) -> RepositorySyncResult: + _require_mutation_authorization(request) + if not gitea_client.configured: + raise HTTPException(status_code=503, detail="Gitea connector is not configured") + try: + result = await asyncio.to_thread(_get_runner().sync_now) + except MaintenanceModeError as exc: + raise HTTPException(status_code=423, detail=str(exc), headers={"Retry-After": "30"}) from exc + if result.errors and result.branch_failures == 0: + raise HTTPException(status_code=502, detail=result.errors[0]) + return result + + +@app.get("/api/v1/repositories/{repository_id}", response_model=RepositoryDetail) +def get_repository(repository_id: str) -> RepositoryDetail: + repository = store.get_repository_detail(repository_id) + if repository is None: + raise HTTPException(status_code=404, detail="Repository not found") + return repository + + +@app.get("/api/v1/repositories/{repository_id}/scans", response_model=list[ScanSummary]) +def list_repository_scans( + repository_id: str, + limit: int = Query(default=50, ge=1, le=200), +) -> list[ScanSummary]: + if store.get_repository(repository_id) is None: + raise HTTPException(status_code=404, detail="Repository not found") + return store.repository_scans(repository_id, limit) + + +@app.get("/api/v1/repositories/{repository_id}/trend", response_model=list[TrendPoint]) +def repository_trend( + repository_id: str, + limit: int = Query(default=50, ge=1, le=200), +) -> list[TrendPoint]: + if store.get_repository(repository_id) is None: + raise HTTPException(status_code=404, detail="Repository not found") + return store.trend(repository_id, limit) + + +@app.post("/api/v1/repositories/{repository_id}/scans", response_model=ScanJob, status_code=202) +async def create_repository_scan( + request: Request, + repository_id: str, + payload: RepositoryScanRequest | None = None, +) -> ScanJob: + _require_mutation_authorization(request) + repository = store.get_repository(repository_id) + if repository is None: + raise HTTPException(status_code=404, detail="Repository not found") + if repository.archived: + raise HTTPException(status_code=409, detail="Archived repositories are not scanned") + if not repository.available: + raise HTTPException(status_code=409, detail="Repository is no longer available to the Gitea connector") + if repository.provider == "gitea" and not gitea_client.configured: + raise HTTPException(status_code=503, detail="Gitea connector is not configured") + try: + return _get_runner().enqueue(repository, force=bool(payload and payload.force)) + except MaintenanceModeError as exc: + raise HTTPException(status_code=423, detail=str(exc), headers={"Retry-After": "30"}) from exc + except QueueFullError as exc: + raise HTTPException( + status_code=429, + detail=str(exc), + headers={"Retry-After": "5"}, + ) from exc + + +@app.get("/api/v1/scan-jobs/{job_id}", response_model=ScanJob) +def get_scan_job(job_id: str) -> ScanJob: + job = store.get_job(job_id) + if job is None: + raise HTTPException(status_code=404, detail="Scan job not found") + return job + + +@app.get("/api/v1/repositories/{repository_id}/scans/{scan_id}", response_model=ScanReport) +def get_repository_scan(repository_id: str, scan_id: str) -> ScanReport: + report = store.get(scan_id) + if report is None or report.source.repository_id != repository_id: + raise HTTPException(status_code=404, detail="Repository scan not found") + return report + + +@app.post("/api/v1/webhooks/gitea", response_model=WebhookResponse) +async def gitea_webhook(request: Request) -> WebhookResponse: + secret = os.getenv("REPOPULSE_GITEA_WEBHOOK_SECRET", "") + if not secret: + raise HTTPException(status_code=404, detail="Gitea webhook integration is not configured") + body = await request.body() + if len(body) > 2_000_000: + raise HTTPException(status_code=413, detail="Webhook payload is too large") + signature = request.headers.get("x-gitea-signature", "").removeprefix("sha256=") + expected = hmac.new(secret.encode("utf-8"), body, hashlib.sha256).hexdigest() + if not signature or not hmac.compare_digest(signature.casefold(), expected.casefold()): + raise HTTPException(status_code=401, detail="Invalid webhook signature") + try: + payload = json.loads(body.decode("utf-8")) + except (UnicodeDecodeError, json.JSONDecodeError) as exc: + raise HTTPException(status_code=400, detail="Webhook payload is invalid JSON") from exc + if not isinstance(payload, dict): + raise HTTPException(status_code=400, detail="Webhook payload must be an object") + repository_payload = payload.get("repository") + if not isinstance(repository_payload, dict): + raise HTTPException(status_code=400, detail="Webhook repository is missing") + raw_id = repository_payload.get("id") + repository_id = f"gitea:{raw_id}" if str(raw_id).isdigit() else None + repository = store.get_repository(repository_id) if repository_id else None + if repository is None: + return WebhookResponse( + accepted=False, + message="Repository is not present in the synchronized catalog", + ) + event = request.headers.get("x-gitea-event", "push").casefold() + if event != "push": + return WebhookResponse( + accepted=True, + repository_id=repository.id, + message="Non-push webhook acknowledged without scheduling a scan", + ) + ref = payload.get("ref") + if ref != f"refs/heads/{repository.default_branch}": + return WebhookResponse( + accepted=True, + repository_id=repository.id, + message="Non-default branch push acknowledged without scheduling a scan", + ) + after = payload.get("after") + if ( + not isinstance(after, str) + or not 7 <= len(after) <= 64 + or not all(char in "0123456789abcdefABCDEF" for char in after) + or not set(after) - {"0"} + ): + return WebhookResponse( + accepted=True, + repository_id=repository.id, + message="Push acknowledged without a usable commit revision", + ) + if not gitea_client.configured: + raise HTTPException(status_code=503, detail="Gitea connector is not configured") + updated = repository.model_copy(update={"latest_revision": after, "sync_error": None}) + store.upsert_repository(updated) + try: + job = _get_runner().enqueue(updated, trigger=ScanTrigger.WEBHOOK) + except MaintenanceModeError as exc: + raise HTTPException(status_code=423, detail=str(exc), headers={"Retry-After": "30"}) from exc + except QueueFullError as exc: + raise HTTPException(status_code=429, detail=str(exc), headers={"Retry-After": "5"}) from exc + return WebhookResponse( + accepted=True, + repository_id=repository.id, + job_id=job.id, + message="Push accepted and scan scheduled", + ) + + +@app.post("/api/v1/operator/database-recovery/acknowledge", status_code=status.HTTP_204_NO_CONTENT) +def acknowledge_database_recovery(request: Request) -> Response: + _require_mutation_authorization(request, strict=True) + store.acknowledge_database_recovery() + return Response(status_code=status.HTTP_204_NO_CONTENT) + + +@app.get("/api/v1/scans", response_model=list[ScanReport]) +def list_scans(limit: int = Query(default=20, ge=1, le=100)) -> list[ScanReport]: + return store.recent(limit) + + +@app.get("/api/v1/scans/{scan_id}", response_model=ScanReport) +def get_scan(scan_id: str) -> ScanReport: + report = store.get(scan_id) + if report is None: + raise HTTPException(status_code=404, detail="Scan not found") + return report + + +@app.get("/api/v1/scans/{scan_id}/comparison", response_model=ScanComparison) +def get_scan_comparison(scan_id: str) -> ScanComparison: + report = store.get(scan_id) + if report is None: + raise HTTPException(status_code=404, detail="Scan not found") + return store.compare(report) + + +@app.get("/api/v1/scans/{scan_id}/delta") +def get_scan_delta(scan_id: str) -> dict[str, int | None]: + report = store.get(scan_id) + if report is None: + raise HTTPException(status_code=404, detail="Scan not found") + previous = store.previous_for_repository( + report.source.repository_id or report.repository_path, + report.id, + ) + return { + "previous_health_score": previous.health_score if previous else None, + "health_score_delta": report.health_score - previous.health_score if previous else None, + "previous_finding_count": len(previous.findings) if previous else None, + "finding_count_delta": len(report.findings) - len(previous.findings) if previous else None, + } + + +@app.get("/api/v1/trend", response_model=list[TrendPoint]) +def trend(path: str, limit: int = Query(default=30, ge=1, le=100)) -> list[TrendPoint]: + try: + resolved = _resolve_scan_path(path) + except ValueError as exc: + raise HTTPException(status_code=422, detail=str(exc)) from exc + return store.trend(str(resolved), limit) + + +@app.get("/api/v1/scans/{scan_id}/export") +def export_scan(scan_id: str, format: str = Query(default="html", pattern="^(html|json)$")) -> Response: + report = store.get(scan_id) + if report is None: + raise HTTPException(status_code=404, detail="Scan not found") + if format == "json": + filename = safe_report_filename(report.repository_name, "json") + return Response( + report.model_dump_json(indent=2), + media_type="application/json", + headers={"Content-Disposition": content_disposition(filename)}, + ) + filename = safe_report_filename(report.repository_name, "html") + return Response( + render_html_report(report), + media_type="text/html", + headers={"Content-Disposition": content_disposition(filename)}, + ) + + +static_dir = Path(os.getenv("REPOPULSE_STATIC_DIR", "/app/static")) +if static_dir.is_dir(): + app.mount("/", StaticFiles(directory=static_dir, html=True), name="frontend") diff --git a/backend/app/models.py b/backend/app/models.py new file mode 100644 index 0000000..4468eaa --- /dev/null +++ b/backend/app/models.py @@ -0,0 +1,397 @@ +from __future__ import annotations + +import re +from datetime import datetime +from enum import StrEnum +from hashlib import sha256 + +from pydantic import BaseModel, Field + + +class Severity(StrEnum): + INFO = "info" + WARNING = "warning" + BLOCKER = "blocker" + + +class GateState(StrEnum): + PASS = "pass" + WARN = "warn" + BLOCK = "block" + + +class SourceOrigin(StrEnum): + LOCAL = "local" + GITEA = "gitea" + + +class ScanTrigger(StrEnum): + MANUAL = "manual" + SCHEDULED = "scheduled" + WEBHOOK = "webhook" + LOCAL = "local" + + +class ScanJobStatus(StrEnum): + QUEUED = "queued" + ACQUIRING_SOURCE = "acquiring_source" + SCANNING = "scanning" + ANALYZING = "analyzing" + PERSISTING = "persisting" + COMPLETED = "completed" + FAILED = "failed" + CANCELLED = "cancelled" + SUPERSEDED = "superseded" + + +class RepositoryState(StrEnum): + NEVER_SCANNED = "never_scanned" + CURRENT = "current" + STALE = "stale" + QUEUED = "queued" + SCANNING = "scanning" + FAILED = "failed" + UNAVAILABLE = "unavailable" + ARCHIVED = "archived" + + +class RepositoryPolicy(BaseModel): + auto_scan: bool = True + min_health_score: int = Field(default=0, ge=0, le=100) + max_blockers: int = Field(default=0, ge=0) + require_tests: bool = False + require_ci: bool = False + suppressions: list[str] = Field(default_factory=list) + + +class RemediationSignal(BaseModel): + """A compact, redacted finding summary safe for catalog-level triage.""" + + code: str + category: str + severity: Severity + message: str + count: int = Field(default=1, ge=1) + guidance: FindingGuidance | None = None + + +class ScanSource(BaseModel): + origin: SourceOrigin = SourceOrigin.LOCAL + provider: str | None = None + repository_id: str | None = None + repository_full_name: str | None = None + branch: str | None = None + requested_revision: str | None = None + actual_revision: str | None = None + trigger: ScanTrigger = ScanTrigger.MANUAL + + +class Repository(BaseModel): + id: str + provider: str + provider_repository_id: str + owner: str + name: str + full_name: str + description: str | None = None + html_url: str | None = None + clone_url: str | None = None + default_branch: str = "main" + private: bool = False + archived: bool = False + available: bool = True + latest_revision: str | None = None + latest_revision_at: datetime | None = None + last_synced_at: datetime | None = None + sync_error: str | None = None + state: RepositoryState = RepositoryState.NEVER_SCANNED + stale: bool = False + active_job_id: str | None = None + last_scan_id: str | None = None + last_scan_at: datetime | None = None + last_scan_health: int | None = None + last_scan_readiness: str | None = None + last_scan_revision: str | None = None + policy: RepositoryPolicy = Field(default_factory=RepositoryPolicy) + + +class RepositorySummary(Repository): + """Catalog row intentionally contains no full scan report.""" + + last_scan_blockers: int = 0 + last_scan_warnings: int = 0 + last_scan_primary_signal: RemediationSignal | None = None + last_scan_health_delta: int | None = None + last_scan_added_findings: int = 0 + last_scan_resolved_findings: int = 0 + last_scan_priority: int = 0 + last_scan_priority_rationale: str | None = None + + +class RepositoryDetail(RepositorySummary): + latest_scan: ScanReport | None = None + + +class ScanJob(BaseModel): + id: str + repository_id: str + status: ScanJobStatus + trigger: ScanTrigger + requested_revision: str | None = None + actual_revision: str | None = None + phase: str = "queued" + progress: int = Field(default=0, ge=0, le=100) + message: str | None = None + created_at: datetime + started_at: datetime | None = None + updated_at: datetime + finished_at: datetime | None = None + duration_ms: float | None = None + scan_id: str | None = None + error_code: str | None = None + error_detail: str | None = None + attempt: int = 0 + deduplicated: bool = False + + +class RepositoryScanRequest(BaseModel): + force: bool = False + + +class RepositorySyncResult(BaseModel): + provider: str + discovered: int = 0 + created: int = 0 + updated: int = 0 + unavailable: int = 0 + errors: list[str] = Field(default_factory=list) + partial: bool = False + branch_failures: int = 0 + listing_complete: bool = True + synced_at: datetime + + +class WebhookResponse(BaseModel): + accepted: bool + repository_id: str | None = None + job_id: str | None = None + message: str + + +class FindingGuidance(BaseModel): + """Backend-owned, safe-to-display explanation of a deterministic rule.""" + + remediation_class: str + confidence: str + why: str + recommended_action: str + priority: int = Field(default=0, ge=0, le=1000) + priority_rationale: str + + +class Finding(BaseModel): + code: str + category: str + severity: Severity + message: str + path: str | None = None + line: int | None = None + deduction: int = Field(default=0, ge=0) + fingerprint: str | None = None + suppressed: bool = False + guidance: FindingGuidance | None = None + + +def finding_fingerprint(finding: Finding) -> str: + """Build a stable semantic identity that ignores line movement and counters.""" + normalized_message = re.sub(r"\b\d+(?:\.\d+)?\b", "#", finding.message.casefold()) + payload = "\0".join( + ( + finding.code, + finding.category, + finding.path or "", + normalized_message, + ) + ) + return sha256(payload.encode("utf-8")).hexdigest()[:32] + + +class RepositoryMetrics(BaseModel): + files: int = 0 + source_files: int = 0 + lines_of_code: int = 0 + test_files: int = 0 + todo: int = 0 + fixme: int = 0 + hack: int = 0 + xxx: int = 0 + dependency_manifests: int = 0 + declared_dependencies: int = 0 + large_files: int = 0 + large_source_files: int = 0 + + +class TestSignals(BaseModel): + frameworks: list[str] = Field(default_factory=list) + coverage_artifacts: list[str] = Field(default_factory=list) + ci_workflows: list[str] = Field(default_factory=list) + ci_validation_workflows: list[str] = Field(default_factory=list) + ci_build_workflows: list[str] = Field(default_factory=list) + ci_deploy_only_workflows: list[str] = Field(default_factory=list) + coverage_evidence: list[str] = Field(default_factory=list) + test_source_ratio: float | None = None + + +class GitSignals(BaseModel): + available: bool = False + commit_count: int | None = None + contributor_count: int | None = None + latest_commit_at: datetime | None = None + tracked_files: int | None = None + renamed_files: list[str] = Field(default_factory=list) + + +class DependencySignals(BaseModel): + manifests: list[str] = Field(default_factory=list) + lockfiles: list[str] = Field(default_factory=list) + declared_dependencies: int = 0 + unbounded_dependencies: int = 0 + unpinned_dependencies: int = 0 + duplicate_dependencies: list[str] = Field(default_factory=list) + included_requirements: list[str] = Field(default_factory=list) + + +class ArchitectureNode(BaseModel): + id: str + label: str + path: str + language: str + inbound: int = 0 + outbound: int = 0 + visible_inbound: int = 0 + visible_outbound: int = 0 + hotspot_score: int = Field(default=0, ge=0, le=100) + + +class ArchitectureEdge(BaseModel): + source: str + target: str + kind: str = "import" + + +class ArchitectureGraph(BaseModel): + nodes: list[ArchitectureNode] = Field(default_factory=list) + edges: list[ArchitectureEdge] = Field(default_factory=list) + clusters: dict[str, int] = Field(default_factory=dict) + truncated: bool = False + total_nodes: int = 0 + total_edges: int = 0 + + +class Hotspot(BaseModel): + path: str + language: str + lines_of_code: int + debt_markers: int = 0 + churn: int = 0 + inbound: int = 0 + outbound: int = 0 + score: int = Field(ge=0, le=100) + reasons: list[str] = Field(default_factory=list) + + +class GateCheck(BaseModel): + key: str + label: str + state: GateState + detail: str + + +class ReleaseGate(BaseModel): + status: str + checks: list[GateCheck] + + +class ScanLimits(BaseModel): + max_files: int = Field(default=10_000, ge=1, le=100_000) + max_text_bytes_per_file: int = Field(default=2_000_000, ge=1_024, le=10_000_000) + max_total_text_bytes: int = Field(default=50_000_000, ge=1_000_000, le=500_000_000) + max_findings: int = Field(default=2_000, ge=10, le=20_000) + max_secret_findings: int = Field(default=20, ge=1, le=500) + + +class ScanCoverage(BaseModel): + limits: ScanLimits + discovered_files: int = 0 + scanned_files: int = 0 + skipped_files_by_budget: int = 0 + skipped_files_by_size: int = 0 + skipped_files_by_text_budget: int = 0 + text_bytes_scanned: int = 0 + truncated: bool = False + notes: list[str] = Field(default_factory=list) + + +class ScanReport(BaseModel): + id: str + repository_path: str + repository_name: str + source: ScanSource = Field(default_factory=ScanSource) + policy: RepositoryPolicy = Field(default_factory=RepositoryPolicy) + scanned_at: datetime + duration_ms: float + metrics: RepositoryMetrics + languages: dict[str, int] + category_scores: dict[str, int] + health_score: int + release_readiness: str + findings: list[Finding] + tests: TestSignals = Field(default_factory=TestSignals) + git: GitSignals = Field(default_factory=GitSignals) + dependencies: DependencySignals = Field(default_factory=DependencySignals) + architecture: ArchitectureGraph = Field(default_factory=ArchitectureGraph) + hotspots: list[Hotspot] = Field(default_factory=list) + release_gate: ReleaseGate | None = None + coverage: ScanCoverage | None = None + compacted: bool = False + + +class ScanSummary(BaseModel): + id: str + repository_id: str + scanned_at: datetime + branch: str | None = None + requested_revision: str | None = None + actual_revision: str | None = None + trigger: ScanTrigger = ScanTrigger.MANUAL + health_score: int + release_readiness: str + findings: int + duration_ms: float + + +class ScanRequest(BaseModel): + path: str = Field(min_length=1) + + +class ScanComparison(BaseModel): + current_scan_id: str + previous_scan_id: str | None = None + health_score_delta: int | None = None + category_score_deltas: dict[str, int] = Field(default_factory=dict) + metric_deltas: dict[str, int] = Field(default_factory=dict) + added_findings: list[Finding] = Field(default_factory=list) + resolved_findings: list[Finding] = Field(default_factory=list) + + +class TrendPoint(BaseModel): + scan_id: str + scanned_at: datetime + health_score: int + findings: int + blockers: int + warnings: int + debt_markers: int + + +RepositoryDetail.model_rebuild() diff --git a/backend/app/policy.py b/backend/app/policy.py new file mode 100644 index 0000000..cbe1b77 --- /dev/null +++ b/backend/app/policy.py @@ -0,0 +1,98 @@ +from __future__ import annotations + +from pathlib import Path + +from .models import RepositoryPolicy + +POLICY_NAMES = (".repopulse.yml", ".repopulse.yaml") +MAX_POLICY_BYTES = 64_000 + + +def _scalar(value: str) -> bool | int | str: + normalized = value.strip().strip('"\'') + lowered = normalized.casefold() + if lowered in {"true", "yes", "on"}: + return True + if lowered in {"false", "no", "off"}: + return False + try: + return int(normalized) + except ValueError: + return normalized + + +def load_policy(root: Path) -> RepositoryPolicy: + policy_path = next((root / name for name in POLICY_NAMES if (root / name).is_file()), None) + if policy_path is None: + return RepositoryPolicy() + try: + if policy_path.stat().st_size > MAX_POLICY_BYTES: + return RepositoryPolicy() + lines = policy_path.read_text(encoding="utf-8", errors="replace").splitlines() + except OSError: + return RepositoryPolicy() + + values: dict[str, object] = {} + suppressions: list[str] = [] + in_suppressions = False + for raw_line in lines: + line = raw_line.split("#", 1)[0].rstrip() + if not line.strip(): + continue + stripped = line.strip() + if stripped == "suppressions:": + in_suppressions = True + continue + if in_suppressions and stripped.startswith("-"): + value = stripped[1:].strip().strip('"\'') + if value: + suppressions.append(value) + continue + in_suppressions = False + if ":" not in stripped: + continue + key, value = stripped.split(":", 1) + key = key.strip() + if key in {"auto_scan", "min_health_score", "max_blockers", "require_tests", "require_ci"}: + values[key] = _scalar(value) + values["suppressions"] = suppressions + try: + return RepositoryPolicy.model_validate(values) + except ValueError: + return RepositoryPolicy() + + +def apply_policy(report, policy: RepositoryPolicy): + findings = [ + item.model_copy( + update={ + "suppressed": item.suppressed or item.code in set(policy.suppressions), + } + ) + for item in report.findings + ] + active_findings = [item for item in findings if not item.suppressed] + scores = {category: 100 for category in report.category_scores} + for finding in active_findings: + scores[finding.category] = max(0, scores[finding.category] - finding.deduction) + health_score = round(sum(scores.values()) / len(scores)) if scores else 100 + from .release_gate import build_release_gate + + release_gate = build_release_gate( + health_score=health_score, + findings=findings, + metrics=report.metrics, + tests=report.tests, + dependencies=report.dependencies, + policy=policy, + ) + return report.model_copy( + update={ + "findings": findings, + "category_scores": scores, + "health_score": health_score, + "release_readiness": release_gate.status, + "release_gate": release_gate, + "policy": policy, + } + ) diff --git a/backend/app/release_gate.py b/backend/app/release_gate.py new file mode 100644 index 0000000..c49d5ec --- /dev/null +++ b/backend/app/release_gate.py @@ -0,0 +1,147 @@ +from __future__ import annotations + +from .models import ( + DependencySignals, + Finding, + GateCheck, + GateState, + ReleaseGate, + RepositoryMetrics, + RepositoryPolicy, + ScanCoverage, + Severity, + TestSignals, +) + + +def build_release_gate( + *, + health_score: int, + findings: list[Finding], + metrics: RepositoryMetrics, + tests: TestSignals, + dependencies: DependencySignals, + coverage: ScanCoverage | None = None, + policy: RepositoryPolicy | None = None, +) -> ReleaseGate: + policy = policy or RepositoryPolicy() + active_findings = [item for item in findings if not item.suppressed] + blockers = [item for item in active_findings if item.severity == Severity.BLOCKER] + warnings = [item for item in active_findings if item.severity == Severity.WARNING] + dependency_issues = dependencies.unbounded_dependencies + dependencies.unpinned_dependencies + checks = [ + GateCheck( + key="security", + label="Security basics", + state=GateState.BLOCK if len(blockers) > policy.max_blockers else GateState.PASS, + detail=( + f"{len(blockers)} blocker finding(s), policy allows {policy.max_blockers}" + if blockers + else "No blocker-level secret/environment findings" + ), + ), + GateCheck( + key="tests", + label="Tests" + (" (required)" if policy.require_tests else ""), + state=( + GateState.BLOCK + if policy.require_tests and not metrics.test_files + else GateState.PASS + if metrics.test_files + else GateState.WARN + ), + detail=( + f"{metrics.test_files} test file(s) detected" + if metrics.test_files + else "Tests are required by repository policy" + if policy.require_tests + else "No test files detected" + ), + ), + GateCheck( + key="ci", + label="Continuous integration" + (" (required)" if policy.require_ci else ""), + state=( + GateState.BLOCK + if policy.require_ci and not tests.ci_validation_workflows + else GateState.PASS + if tests.ci_validation_workflows + else GateState.WARN + ), + detail=( + f"{len(tests.ci_validation_workflows)} validation workflow(s) detected" + if tests.ci_validation_workflows + else f"{len(tests.ci_deploy_only_workflows)} deploy-only workflow(s) do not provide validation evidence" + if tests.ci_deploy_only_workflows + else "CI is required by repository policy" + if policy.require_ci + else "No validation workflow detected" + ), + ), + GateCheck( + key="coverage", + label="Coverage evidence", + state=( + GateState.PASS + if tests.coverage_evidence + else GateState.WARN + if metrics.test_files + else GateState.PASS + ), + detail=( + f"{len(tests.coverage_evidence)} coverage evidence source(s) detected" + if tests.coverage_evidence + else "Tests exist but no coverage-producing command or retained coverage output was detected" + if metrics.test_files + else "No test suite is present to produce coverage evidence" + ), + ), + GateCheck( + key="analysis_coverage", + label="Analysis coverage", + state=GateState.WARN if coverage and coverage.truncated else GateState.PASS, + detail=( + "; ".join(coverage.notes) if coverage and coverage.truncated else "Analysis completed within configured limits" + ), + ), + GateCheck( + key="dependencies", + label="Dependency hygiene", + state=GateState.WARN if dependency_issues else GateState.PASS, + detail=( + f"{dependencies.unbounded_dependencies} unbounded and {dependencies.unpinned_dependencies} unpinned declaration(s)" + if dependency_issues + else f"{dependencies.declared_dependencies} dependency declaration(s), no unbounded or unpinned versions" + ), + ), + GateCheck( + key="health", + label="Repository health", + state=( + GateState.PASS + if health_score >= max(85, policy.min_health_score) + else GateState.WARN + if health_score >= max(65, policy.min_health_score) + else GateState.BLOCK + ), + detail=( + f"Health score {health_score}/100" + if not policy.min_health_score + else f"Health score {health_score}/100; policy minimum {policy.min_health_score}" + ), + ), + GateCheck( + key="warnings", + label="Engineering warnings", + state=GateState.WARN if warnings else GateState.PASS, + detail=f"{len(warnings)} warning finding(s)" if warnings else "No warning-level findings", + ), + ] + + if any(check.state == GateState.BLOCK for check in checks): + status = "BLOCKED" + elif any(check.state == GateState.WARN for check in checks): + status = "READY WITH WARNINGS" + else: + status = "READY" + return ReleaseGate(status=status, checks=checks) diff --git a/backend/app/reporting.py b/backend/app/reporting.py new file mode 100644 index 0000000..e7254fa --- /dev/null +++ b/backend/app/reporting.py @@ -0,0 +1,75 @@ +from __future__ import annotations + +import re +import unicodedata +from html import escape +from urllib.parse import quote + +from .models import ScanReport + +INVALID_FILENAME_CHARS = re.compile(r'[\x00-\x1f\x7f<>:"/\\|?*]') + +REPORT_MARK = """""" + + +def safe_report_filename(repository_name: str, extension: str) -> str: + cleaned = INVALID_FILENAME_CHARS.sub("_", repository_name).strip(" .") + cleaned = cleaned[:100].rstrip(" .") or "repository" + return f"repopulse-{cleaned}.{extension}" + + +def content_disposition(filename: str) -> str: + fallback = unicodedata.normalize("NFKD", filename).encode("ascii", "ignore").decode("ascii") + fallback = INVALID_FILENAME_CHARS.sub("_", fallback).strip(" .") or "repopulse-report" + return f"attachment; filename=\"{fallback}\"; filename*=UTF-8''{quote(filename, safe='')}" + + +def render_html_report(report: ScanReport) -> str: + category_rows = "".join( + f"{escape(name)}{score}/100" + for name, score in report.category_scores.items() + ) + finding_rows = "".join( + "" + f"{escape(item.severity.value)}" + f"{escape(item.category)}" + f"{escape(item.message)}" + f"{escape(item.path or '')}{':' + str(item.line) if item.line else ''}" + "" + for item in report.findings + ) + hotspot_rows = "".join( + "" + f"{escape(item.path)}{escape(item.language)}" + f"{item.score}{item.lines_of_code}{item.churn}" + "" + for item in report.hotspots[:25] + ) + return f""" + + + + +RepoPulse report — {escape(report.repository_name)} + + + +
{REPORT_MARK}RepoPulseRepository intelligence
+

Deterministic repository intelligence report

{escape(report.repository_name)}

{escape(report.repository_path)} · {escape(report.scanned_at.isoformat())}

{report.health_score}
{escape(report.release_readiness)}
+
+
{report.metrics.source_files}
source files
+
{report.metrics.lines_of_code}
LOC
+
{report.metrics.test_files}
test files
+
{len(report.findings)}
findings
+
+

Category scores

{category_rows}
+

Hotspots

{hotspot_rows}
PathLanguageScoreLOCChurn
+

Findings

{finding_rows}
SeverityCategoryFindingLocation
+ +""" diff --git a/backend/app/rules.py b/backend/app/rules.py new file mode 100644 index 0000000..022b59a --- /dev/null +++ b/backend/app/rules.py @@ -0,0 +1,83 @@ +from .models import Finding, FindingGuidance, Severity + +_RULES: dict[str, tuple[str, str, str, str]] = { + "security.secret-assignment": ( + "security remediation", + "A credential-shaped assignment was found in tracked content.", + "Move the value to a secret store or runtime environment and rotate it if it was genuine.", + "high", + ), + "security.env-committed": ( + "security remediation", + "A live environment file is tracked, so its contents require deliberate review.", + "Remove the live file from version control and retain a sanitized .env.example template.", + "high", + ), + "testing.none-detected": ( + "test coverage", + "No conventionally named test source was detected for a repository with source files.", + "Add a focused deterministic smoke test, or record a repository policy that explains why tests do not apply.", + "medium", + ), + "testing.no-ci": ( + "delivery evidence", + "No repository workflow was found that contains a validation command.", + "Add a CI validation workflow that runs the repository's deterministic checks.", + "medium", + ), + "dependency.no-lockfile": ( + "dependency reproducibility", + "A JavaScript manifest was found without a lockfile in its package or workspace root.", + "Commit the package-manager lockfile used by the build.", + "high", + ), + "hygiene.missing-gitignore": ( + "repository hygiene", + "The repository has no root ignore policy.", + "Add a minimal .gitignore for generated files, local settings and build outputs.", + "high", + ), +} + + +def _default_rule(finding: Finding) -> tuple[str, str, str, str]: + if finding.code.startswith("dependency."): + return ( + "dependency hygiene", + "The dependency declaration has a deterministic hygiene signal.", + "Review the declared version and lockfile semantics, then make the smallest reproducible correction.", + "medium", + ) + if finding.code.startswith("architecture."): + return ( + "architecture review", + "The bounded static graph has a structural signal.", + "Inspect the affected module boundary before planning a contained refactor.", + "medium", + ) + return ( + "engineering hygiene", + "A deterministic repository rule produced this signal.", + "Review the retained evidence and make the smallest safe correction.", + "medium", + ) + + +def enrich_finding(finding: Finding) -> Finding: + remediation_class, why, action, confidence = _RULES.get(finding.code, _default_rule(finding)) + severity_weight = {Severity.BLOCKER: 700, Severity.WARNING: 400, Severity.INFO: 100}[finding.severity] + priority = min(1000, severity_weight + finding.deduction * 5) + rationale = f"{finding.severity.value.title()} signal; {finding.deduction} health-point impact." + guidance = FindingGuidance( + remediation_class=remediation_class, + confidence=confidence, + why=why, + recommended_action=action, + priority=priority, + priority_rationale=rationale, + ) + return finding.model_copy(update={"guidance": guidance}) + + +def enrich_findings(findings: list[Finding]) -> list[Finding]: + return [enrich_finding(item) for item in findings] diff --git a/backend/app/scanner.py b/backend/app/scanner.py new file mode 100644 index 0000000..444a89c --- /dev/null +++ b/backend/app/scanner.py @@ -0,0 +1,695 @@ +from __future__ import annotations + +import ast +import fnmatch +import os +import re +import subprocess +from collections import Counter +from datetime import UTC, datetime +from pathlib import Path +from time import perf_counter +from uuid import uuid4 + +from .architecture import build_architecture +from .git_analysis import analyze_git +from .models import ( + Finding, + RepositoryMetrics, + RepositoryPolicy, + ScanCoverage, + ScanLimits, + ScanReport, + ScanSource, + Severity, + finding_fingerprint, +) +from .policy import load_policy +from .release_gate import build_release_gate +from .rules import enrich_findings +from .signals import analyze_dependencies, detect_test_signals + +LANGUAGES = { + ".py": "Python", + ".ts": "TypeScript", + ".tsx": "TypeScript", + ".js": "JavaScript", + ".jsx": "JavaScript", + ".mjs": "JavaScript", + ".cjs": "JavaScript", + ".cs": "C#", + ".java": "Java", + ".go": "Go", + ".rs": "Rust", + ".cpp": "C++", + ".cc": "C++", + ".c": "C", + ".h": "C/C++ Header", + ".hpp": "C++ Header", + ".php": "PHP", + ".rb": "Ruby", + ".kt": "Kotlin", + ".swift": "Swift", + ".vue": "Vue", + ".svelte": "Svelte", + ".html": "HTML", + ".css": "CSS", + ".scss": "SCSS", + ".sh": "Shell", + ".ps1": "PowerShell", + ".sql": "SQL", +} + +IGNORED_DIRS = { + ".git", + ".idea", + ".vscode", + ".venv", + "venv", + "node_modules", + "dist", + "build", + "coverage", + ".next", + ".nuxt", + ".pytest_cache", + "__pycache__", + "vendor", + "target", + "bin", + "obj", +} + +MAX_TEXT_BYTES = 2_000_000 +MAX_SECRET_FINDINGS = 20 + +DEBT_PATTERN = re.compile(r"\b(TODO|FIXME|HACK|XXX)\b") +SECRET_PATTERN = re.compile( + r"""(?ix) + (?: + ^\s*(?:export\s+)?(?:(?:const|let|var|final|static|private|public|protected|internal)\s+)?(?:[A-Za-z_]\w*\.)* + |[,{]\s* + ) + [\"']?(?Papi[_-]?key|secret|password|passwd|token|access[_-]?key)[\"']? + \s*[:=]\s*[\"']?(?P[^\s\"']{8,}) + """ +) +PLACEHOLDER_SECRET_MARKERS = ("example", "placeholder", "dummy", "changeme", "not-a-real", "replace-me", "your-", "fake", "test-") +SECRET_REFERENCE_MARKERS = ( + "os.environ", + "os.getenv", + "getenv", + "process.env", + "env[", + "config.", + "settings.", +) +SECRET_SCAN_CONFIG_SUFFIXES = {".json", ".yaml", ".yml", ".toml", ".ini", ".cfg", ".conf", ".md", ".txt"} +CATEGORY_NAMES = ( + "Architecture", + "Testing", + "Maintainability", + "Documentation", + "Dependencies", + "Repository hygiene", + "Security basics", +) + + +def _ignored(relative: str) -> bool: + return any(part.casefold() in IGNORED_DIRS for part in Path(relative).parts) + + +def _is_env_template(name: str) -> bool: + return name == ".env.example" or (name.startswith(".env.") and name.endswith(".example")) + + +def _is_secret_scan_candidate(path_obj: Path, relative: str, language: str | None) -> bool: + return language is not None or path_obj.suffix.casefold() in SECRET_SCAN_CONFIG_SUFFIXES or path_obj.name.casefold().startswith(".env") + + +def _bounded_env_int(name: str, default: int, *, minimum: int, maximum: int) -> int: + try: + value = int(os.getenv(name, str(default))) + except ValueError: + value = default + return min(maximum, max(minimum, value)) + + +def scan_limits_from_environment() -> ScanLimits: + """Return bounded analysis limits; input cannot turn a scan into an unbounded job.""" + + return ScanLimits( + max_files=_bounded_env_int("REPOPULSE_SCAN_MAX_FILES", 10_000, minimum=1, maximum=100_000), + max_text_bytes_per_file=_bounded_env_int( + "REPOPULSE_SCAN_MAX_TEXT_BYTES", MAX_TEXT_BYTES, minimum=1_024, maximum=10_000_000 + ), + max_total_text_bytes=_bounded_env_int( + "REPOPULSE_SCAN_MAX_TOTAL_TEXT_BYTES", 50_000_000, minimum=1_000_000, maximum=500_000_000 + ), + max_findings=_bounded_env_int("REPOPULSE_SCAN_MAX_FINDINGS", 2_000, minimum=10, maximum=20_000), + max_secret_findings=_bounded_env_int( + "REPOPULSE_SCAN_MAX_SECRET_FINDINGS", MAX_SECRET_FINDINGS, minimum=1, maximum=500 + ), + ) + + +class _GitIgnoreMatcher: + """Bounded root/nested .gitignore support for non-Git directory scans.""" + + def __init__(self, root: Path) -> None: + self.rules: list[tuple[str, str, bool, bool, bool]] = [] + for current, dirs, names in os.walk(root, followlinks=False): + dirs[:] = [ + name + for name in dirs + if name.casefold() not in IGNORED_DIRS and not (Path(current) / name).is_symlink() + ] + if ".gitignore" not in names: + continue + ignore_file = Path(current) / ".gitignore" + try: + lines = ignore_file.read_text(encoding="utf-8", errors="replace").splitlines() + base_path = Path(current).relative_to(root) + base = "" if str(base_path) == "." else base_path.as_posix() + except (OSError, ValueError): + continue + for raw in lines: + pattern = raw.strip() + if not pattern or pattern.startswith("#"): + continue + negated = pattern.startswith("!") + if negated: + pattern = pattern[1:] + pattern = pattern.replace("\\", "/") + anchored = pattern.startswith("/") + pattern = pattern.lstrip("/") + dir_only = pattern.endswith("/") + pattern = pattern.rstrip("/") + if pattern: + self.rules.append((base, pattern, negated, dir_only, anchored)) + + def is_ignored(self, relative: str, *, is_dir: bool) -> bool: + normalized = relative.replace("\\", "/").strip("/") + ignored = False + for base, pattern, negated, dir_only, anchored in self.rules: + if dir_only and not is_dir: + continue + if base: + if normalized == base: + target = "" + elif normalized.startswith(f"{base}/"): + target = normalized[len(base) + 1 :] + else: + continue + else: + target = normalized + if not target: + continue + if "/" not in pattern: + matched = ( + fnmatch.fnmatch(target, pattern) + if anchored + else any(fnmatch.fnmatch(part, pattern) for part in target.split("/") + ) + ) + else: + matched = fnmatch.fnmatch(target, pattern) + if not matched and pattern.startswith("**/"): + matched = fnmatch.fnmatch(target, pattern[3:]) + if matched: + ignored = not negated + return ignored + + +def _git_worktree_root(root: Path) -> Path | None: + try: + result = subprocess.run( + ["git", "-C", str(root), "rev-parse", "--show-toplevel"], + check=True, + capture_output=True, + timeout=5, + ) + except (OSError, subprocess.SubprocessError): + return None + try: + return Path(result.stdout.decode("utf-8", errors="surrogateescape").strip()).resolve() + except (OSError, ValueError): + return None + + +def _safe_file(root: Path, candidate: Path) -> Path | None: + """Return a resolved regular file only when every path component is safe.""" + try: + relative = candidate.relative_to(root) + if _ignored(str(relative)): + return None + current = root + for part in Path(relative).parts: + current /= part + if current.is_symlink(): + return None + resolved = candidate.resolve(strict=True) + root_resolved = root.resolve() + if resolved == root_resolved or root_resolved not in resolved.parents: + return None + if not resolved.is_file(): + return None + except (OSError, RuntimeError, ValueError): + return None + return resolved + + +def _tracked_files(root: Path) -> list[Path] | None: + if _git_worktree_root(root) != root: + return None + try: + result = subprocess.run( + ["git", "-C", str(root), "ls-files", "-z"], + check=True, + capture_output=True, + timeout=5, + ) + except (OSError, subprocess.SubprocessError): + return None + + paths: list[Path] = [] + for raw in result.stdout.split(b"\0"): + if not raw: + continue + relative = raw.decode("utf-8", errors="surrogateescape") + relative_path = Path(relative) + if relative_path.is_absolute() or _ignored(relative): + continue + safe = _safe_file(root, root / relative_path) + if safe is not None: + paths.append(safe) + return paths + + +def _walk_files(root: Path) -> list[Path]: + files: list[Path] = [] + gitignore = _GitIgnoreMatcher(root) + for current, dirs, names in os.walk(root, followlinks=False): + current_path = Path(current) + dirs[:] = [ + name + for name in dirs + if name.casefold() not in IGNORED_DIRS + and not (current_path / name).is_symlink() + and not gitignore.is_ignored( + str((current_path / name).relative_to(root)), + is_dir=True, + ) + ] + for name in names: + candidate = current_path / name + try: + relative = str(candidate.relative_to(root)) + except (OSError, ValueError): + continue + if _ignored(relative): + continue + if gitignore.is_ignored(relative, is_dir=False): + continue + safe = _safe_file(root, candidate) + if safe is not None: + files.append(safe) + return files + + +def _read_text(path: Path, max_bytes: int = MAX_TEXT_BYTES) -> str | None: + try: + if path.stat().st_size > max_bytes: + return None + raw = path.read_bytes() + except OSError: + return None + if b"\0" in raw[:8192]: + return None + return raw.decode("utf-8", errors="replace") + + +def _is_test_file(relative: str) -> bool: + normalized = relative.replace("\\", "/").lower() + name = Path(normalized).name + return ( + "/tests/" in f"/{normalized}" + or "/test/" in f"/{normalized}" + or name.startswith("test_") + or ".test." in name + or ".spec." in name + or name.endswith(("tests.cs", "test.cs", "_test.go")) + ) + + +def _python_function_findings(relative: str, text: str) -> list[Finding]: + try: + tree = ast.parse(text) + except SyntaxError: + return [] + findings: list[Finding] = [] + branch_types = (ast.If, ast.For, ast.AsyncFor, ast.While, ast.Try, ast.Match, ast.BoolOp) + for node in ast.walk(tree): + if not isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)): + continue + end_line = getattr(node, "end_lineno", node.lineno) + length = max(1, end_line - node.lineno + 1) + branches = sum(1 for child in ast.walk(node) if isinstance(child, branch_types)) + if length >= 140: + findings.append( + Finding( + code="maintainability.long-function", + category="Maintainability", + severity=Severity.WARNING, + message=f"Function {node.name} spans {length} lines", + path=relative, + line=node.lineno, + deduction=4, + ) + ) + if branches >= 20: + findings.append( + Finding( + code="maintainability.branch-heavy-function", + category="Maintainability", + severity=Severity.WARNING, + message=f"Function {node.name} contains {branches} branch constructs", + path=relative, + line=node.lineno, + deduction=4, + ) + ) + return findings[:12] + + +def _is_placeholder_secret(match: re.Match[str]) -> bool: + value = match.group("value").casefold().strip("`$(){}[]<>") + exact_placeholder = value in {"", "none", "null", "undefined", "xxx", "xxxxx"} + obvious_placeholder = any(value.startswith(marker) for marker in PLACEHOLDER_SECRET_MARKERS) + return exact_placeholder or obvious_placeholder or any( + value.startswith(marker) for marker in SECRET_REFERENCE_MARKERS + ) + + +def scan_repository( + path: str, + *, + source: ScanSource | None = None, + display_name: str | None = None, + policy: RepositoryPolicy | None = None, + limits: ScanLimits | None = None, +) -> ScanReport: + started = perf_counter() + root = Path(path).expanduser().resolve() + if not root.exists() or not root.is_dir(): + raise ValueError("Repository path does not exist or is not a directory") + + limits = limits or scan_limits_from_environment() + tracked_files = _tracked_files(root) + all_files = _walk_files(root) if tracked_files is None else tracked_files + all_files.sort(key=lambda item: str(item.relative_to(root)).replace("\\", "/").casefold()) + files = all_files[: limits.max_files] + coverage = ScanCoverage( + limits=limits, + discovered_files=len(all_files), + skipped_files_by_budget=max(0, len(all_files) - len(files)), + truncated=len(all_files) > len(files), + notes=( + [f"File analysis limited to {limits.max_files} of {len(all_files)} discovered safe files."] + if len(all_files) > len(files) + else [] + ), + ) + languages: Counter[str] = Counter() + findings: list[Finding] = [] + metrics = RepositoryMetrics(files=len(all_files)) + files_by_name: dict[str, list[Path]] = {} + root_entries = {entry.name.lower() for entry in root.iterdir()} + text_by_path: dict[str, str] = {} + source_texts: dict[str, str] = {} + language_by_path: dict[str, str] = {} + loc_by_path: dict[str, int] = {} + debt_by_path: dict[str, int] = {} + secret_findings = 0 + secret_findings_truncated = False + text_budget_exhausted = False + + for path_obj in files: + try: + relative = str(path_obj.relative_to(root)).replace("\\", "/") + size = path_obj.stat().st_size + except (OSError, ValueError): + continue + + files_by_name.setdefault(path_obj.name, []).append(path_obj) + suffix = path_obj.suffix.lower() + language = LANGUAGES.get(suffix) + + if size >= 1_000_000: + metrics.large_files += 1 + findings.append( + Finding( + code="hygiene.large-file", + category="Repository hygiene", + severity=Severity.INFO, + message=f"Large tracked file ({size / 1_000_000:.1f} MB)", + path=relative, + deduction=1, + ) + ) + + name = path_obj.name.casefold() + if name == ".env" or (name.startswith(".env.") and not _is_env_template(name)): + findings.append( + Finding( + code="security.env-committed", + category="Security basics", + severity=Severity.BLOCKER, + message="Environment file is tracked; review it for credentials", + path=relative, + deduction=30, + ) + ) + + if size > limits.max_text_bytes_per_file: + coverage.skipped_files_by_size += 1 + continue + if coverage.text_bytes_scanned + size > limits.max_total_text_bytes: + coverage.skipped_files_by_text_budget += 1 + text_budget_exhausted = True + continue + text = _read_text(path_obj, limits.max_text_bytes_per_file) + if text is None: + continue + coverage.scanned_files += 1 + coverage.text_bytes_scanned += len(text.encode("utf-8", errors="replace")) + text_by_path[relative] = text + + if language: + loc = sum(1 for line in text.splitlines() if line.strip()) + metrics.source_files += 1 + metrics.lines_of_code += loc + languages[language] += loc + source_texts[relative] = text + language_by_path[relative] = language + loc_by_path[relative] = loc + if loc > 1000: + metrics.large_source_files += 1 + findings.append( + Finding( + code="maintainability.large-source", + category="Maintainability", + severity=Severity.WARNING, + message=f"Source file has {loc} non-empty lines", + path=relative, + deduction=5, + ) + ) + if language == "Python": + findings.extend(_python_function_findings(relative, text)) + + if _is_test_file(relative): + metrics.test_files += 1 + + debt = Counter(DEBT_PATTERN.findall(text)) + metrics.todo += debt["TODO"] + metrics.fixme += debt["FIXME"] + metrics.hack += debt["HACK"] + metrics.xxx += debt["XXX"] + debt_by_path[relative] = sum(debt.values()) + + if _is_secret_scan_candidate(path_obj, relative, language) and secret_findings < limits.max_secret_findings: + for line_number, line in enumerate(text.splitlines(), start=1): + match = SECRET_PATTERN.search(line) + if match is None or _is_placeholder_secret(match): + continue + findings.append( + Finding( + code="security.secret-assignment", + category="Security basics", + severity=Severity.BLOCKER, + message="Potential credential assignment detected; value intentionally redacted", + path=relative, + line=line_number, + deduction=20, + ) + ) + secret_findings += 1 + if secret_findings >= limits.max_secret_findings: + secret_findings_truncated = True + break + + if text_budget_exhausted: + coverage.truncated = True + coverage.notes.append( + f"Text analysis limited to {limits.max_total_text_bytes} bytes across repository files." + ) + + if secret_findings_truncated: + findings.append( + Finding( + code="security.secret-findings-truncated", + category="Security basics", + severity=Severity.INFO, + message=f"Potential credential findings are capped at {limits.max_secret_findings}", + deduction=0, + ) + ) + + if not any(name.startswith("readme") for name in root_entries): + findings.append(Finding(code="docs.missing-readme", category="Documentation", severity=Severity.WARNING, message="No root README detected", deduction=20)) + if not any(name.startswith(("license", "copying")) for name in root_entries): + findings.append(Finding(code="docs.missing-license", category="Documentation", severity=Severity.INFO, message="No root license file detected", deduction=5)) + if ".gitignore" not in root_entries: + findings.append(Finding(code="hygiene.missing-gitignore", category="Repository hygiene", severity=Severity.WARNING, message="No root .gitignore detected", deduction=15)) + if not any(_is_env_template(name) for name in root_entries) and any(name.startswith(".env") for name in root_entries): + findings.append(Finding(code="hygiene.missing-env-example", category="Repository hygiene", severity=Severity.INFO, message="Environment configuration exists without a root .env.example", deduction=3)) + + test_signals = detect_test_signals( + [str(path.relative_to(root)).replace("\\", "/") for path in files], + metrics.source_files, + metrics.test_files, + text_by_path, + ) + if metrics.source_files and metrics.test_files == 0: + findings.append(Finding(code="testing.none-detected", category="Testing", severity=Severity.WARNING, message="No test files detected", deduction=30)) + if not test_signals.ci_workflows: + findings.append(Finding(code="testing.no-ci", category="Testing", severity=Severity.WARNING, message="No recognized CI workflow detected", deduction=15)) + if metrics.test_files and not test_signals.coverage_artifacts: + findings.append(Finding(code="testing.no-coverage-artifact", category="Testing", severity=Severity.INFO, message="Tests are present but no coverage artifact is tracked", deduction=2)) + + common_source_roots = {"src", "app", "backend", "frontend", "lib", "packages"} + if metrics.source_files >= 10 and not (root_entries & common_source_roots): + findings.append(Finding(code="architecture.flat-layout", category="Architecture", severity=Severity.INFO, message="No conventional source root detected in a non-trivial repository", deduction=8)) + + debt_total = metrics.todo + metrics.fixme + metrics.hack + metrics.xxx + if debt_total: + findings.append(Finding(code="maintainability.debt-markers", category="Maintainability", severity=Severity.INFO, message=f"Detected {debt_total} TODO/FIXME/HACK/XXX markers", deduction=min(20, max(1, debt_total // 5)))) + + dependency_signals, dependency_findings = analyze_dependencies(root, files_by_name) + metrics.dependency_manifests = len(dependency_signals.manifests) + metrics.declared_dependencies = dependency_signals.declared_dependencies + findings.extend(dependency_findings) + + git_signals, churn_by_path = analyze_git(root) + architecture, hotspots = build_architecture( + root, + source_texts, + language_by_path, + loc_by_path, + debt_by_path, + churn_by_path, + ) + for hotspot in hotspots[:5]: + if hotspot.score >= 70: + findings.append( + Finding( + code="maintainability.hotspot", + category="Maintainability", + severity=Severity.WARNING, + message=f"Engineering hotspot score {hotspot.score}/100: {', '.join(hotspot.reasons) or 'combined risk signals'}", + path=hotspot.path, + deduction=4, + ) + ) + + if architecture.truncated: + findings.append( + Finding( + code="architecture.graph-truncated", + category="Architecture", + severity=Severity.INFO, + message="Architecture graph was bounded to keep analysis responsive", + deduction=0, + ) + ) + + severity_rank = {Severity.BLOCKER: 0, Severity.WARNING: 1, Severity.INFO: 2} + if len(findings) > limits.max_findings: + discarded = len(findings) - limits.max_findings + findings.sort(key=lambda item: (severity_rank[item.severity], item.category, item.path or "", item.line or 0)) + findings = findings[: limits.max_findings] + findings.append( + Finding( + code="analysis.findings-truncated", + category="Repository hygiene", + severity=Severity.INFO, + message=f"{discarded} lower-priority findings were omitted by the analysis finding budget", + deduction=0, + ) + ) + coverage.truncated = True + coverage.notes.append(f"Finding output limited to {limits.max_findings} deterministic signals.") + + policy = policy or load_policy(root) + suppressed_codes = set(policy.suppressions) + findings = [ + item.model_copy(update={"suppressed": item.suppressed or item.code in suppressed_codes}) + for item in findings + ] + scores = {category: 100 for category in CATEGORY_NAMES} + for finding in findings: + if not finding.suppressed: + scores[finding.category] = max(0, scores[finding.category] - finding.deduction) + + health_score = round(sum(scores.values()) / len(scores)) + release_gate = build_release_gate( + health_score=health_score, + findings=findings, + metrics=metrics, + tests=test_signals, + dependencies=dependency_signals, + coverage=coverage, + policy=policy, + ) + + findings.sort(key=lambda item: (severity_rank[item.severity], item.category, item.path or "", item.line or 0)) + findings = [ + item.model_copy(update={"fingerprint": item.fingerprint or finding_fingerprint(item)}) + for item in findings + ] + findings = enrich_findings(findings) + + return ScanReport( + id=str(uuid4()), + repository_path=str(root), + repository_name=display_name or root.name, + source=source or ScanSource(), + policy=policy, + scanned_at=datetime.now(UTC), + duration_ms=round((perf_counter() - started) * 1000, 2), + metrics=metrics, + languages=dict(languages.most_common()), + category_scores=scores, + health_score=health_score, + release_readiness=release_gate.status, + findings=findings, + tests=test_signals, + git=git_signals, + dependencies=dependency_signals, + architecture=architecture, + hotspots=hotspots, + release_gate=release_gate, + coverage=coverage, + ) diff --git a/backend/app/signals.py b/backend/app/signals.py new file mode 100644 index 0000000..ce54af2 --- /dev/null +++ b/backend/app/signals.py @@ -0,0 +1,494 @@ +from __future__ import annotations + +import json +import re +import tomllib +import xml.etree.ElementTree as ET +from collections import defaultdict +from pathlib import Path + +from .models import DependencySignals, Finding, Severity, TestSignals + +LOCKFILES = { + "package-lock.json", + "pnpm-lock.yaml", + "yarn.lock", + "bun.lock", + "bun.lockb", + "uv.lock", + "poetry.lock", + "Pipfile.lock", + "Cargo.lock", + "go.sum", +} +MANIFEST_MAX_BYTES = 2_000_000 +COVERAGE_NAMES = { + "coverage.xml", + "lcov.info", + "cobertura.xml", + ".coverage", + "jacoco.xml", +} +COVERAGE_NAMES_CASEFOLD = {item.casefold() for item in COVERAGE_NAMES} + + +def _python_dependency_name(declaration: str) -> str: + return re.split(r"[<>=!~ @;\[]", declaration, maxsplit=1)[0].strip() + + +def _python_constraint_kind(declaration: str) -> str: + """Classify the useful subset of Python version constraints without penalising bounded ranges.""" + + value = declaration.split(";", maxsplit=1)[0].strip().lower() + if " @ " in value or "==" in value: + return "pinned" + if "~=" in value or "^" in value: + return "bounded" + has_lower = ">" in value + has_upper = "<" in value + if has_lower and has_upper: + return "bounded" + return "unbounded" + + +def _python_dependency_finding(declaration: str, relative: str) -> Finding | None: + if _python_constraint_kind(declaration) != "unbounded": + return None + return Finding( + code="dependency.python-unbounded", + category="Dependencies", + severity=Severity.WARNING, + message=f"Python dependency has no bounded version range: {declaration.split(';')[0]}", + path=relative, + deduction=3, + ) + + +def detect_test_signals( + relative_paths: list[str], + source_files: int, + test_files: int, + text_by_path: dict[str, str], +) -> TestSignals: + frameworks: set[str] = set() + coverage: list[str] = [] + ci: list[str] = [] + ci_validation: list[str] = [] + ci_build: list[str] = [] + ci_deploy_only: list[str] = [] + coverage_evidence: list[str] = [] + + for path in relative_paths: + normalized = path.replace("\\", "/") + name = Path(normalized).name + name_lower = name.casefold() + lower = normalized.lower() + if name_lower in COVERAGE_NAMES_CASEFOLD or "/coverage/" in f"/{lower}": + coverage.append(normalized) + if lower.startswith((".github/workflows/", ".gitea/workflows/")) or name_lower in { + ".gitlab-ci.yml", + "jenkinsfile", + "azure-pipelines.yml", + }: + ci.append(normalized) + + if (name_lower.startswith("test_") or "/tests/" in f"/{lower}") and name_lower.endswith(".py"): + frameworks.add("pytest/unittest") + if (".test." in name_lower or ".spec." in name_lower) and name_lower.endswith( + (".ts", ".tsx", ".js", ".jsx") + ): + frameworks.add("JavaScript test runner") + if name_lower.endswith("_test.go"): + frameworks.add("go test") + if name_lower.endswith(("tests.cs", "test.cs")): + frameworks.add(".NET test") + + for path, text in text_by_path.items(): + name = Path(path).name + normalized = path.replace("\\", "/") + lowered_text = text.casefold() + if normalized in ci: + validates = any( + token in lowered_text + for token in ("pytest", "vitest", "jest", "npm test", "pnpm test", "go test", "dotnet test", "ruff", "eslint", "typecheck", "py_compile") + ) + builds = any( + token in lowered_text + for token in ("npm run build", "pnpm build", "docker build", "vite build", "cargo build", "go build", "dotnet build") + ) + deploys = any(token in lowered_text for token in ("deploy", "release", "publish", "kubectl apply")) + if validates: + ci_validation.append(normalized) + if builds: + ci_build.append(normalized) + if deploys and not validates: + ci_deploy_only.append(normalized) + if any(token in lowered_text for token in ("--cov", "coverage", "lcov", "codecov")): + coverage_evidence.append(normalized) + if name.casefold() in COVERAGE_NAMES_CASEFOLD: + coverage_evidence.append(normalized) + if name.casefold() == "package.json": + try: + data = json.loads(text) + except (TypeError, json.JSONDecodeError): + continue + if not isinstance(data, dict): + continue + deps: dict[object, object] = {} + for section_name in ( + "dependencies", + "devDependencies", + "peerDependencies", + "optionalDependencies", + ): + section = data.get(section_name, {}) + if isinstance(section, dict): + deps.update(section) + if "vitest" in deps: + frameworks.add("Vitest") + if "jest" in deps: + frameworks.add("Jest") + if "@playwright/test" in deps: + frameworks.add("Playwright") + if "cypress" in deps: + frameworks.add("Cypress") + elif name.casefold() == "pyproject.toml": + lowered = text.lower() + if "pytest" in lowered: + frameworks.add("pytest") + + ratio = round((test_files / source_files) * 100, 2) if source_files else None + return TestSignals( + frameworks=sorted(frameworks), + coverage_artifacts=sorted(set(coverage))[:30], + ci_workflows=sorted(set(ci))[:30], + ci_validation_workflows=sorted(set(ci_validation))[:30], + ci_build_workflows=sorted(set(ci_build))[:30], + ci_deploy_only_workflows=sorted(set(ci_deploy_only))[:30], + coverage_evidence=sorted(set(coverage_evidence))[:30], + test_source_ratio=ratio, + ) + + +def analyze_dependencies( + root: Path, + files_by_name: dict[str, list[Path]], +) -> tuple[DependencySignals, list[Finding]]: + findings: list[Finding] = [] + manifests: list[str] = [] + lockfiles: list[str] = [] + dependency_origins: dict[str, set[str]] = defaultdict(set) + declared = 0 + unbounded = 0 + unpinned = 0 + + for lock_name in sorted(LOCKFILES): + for path in files_by_name.get(lock_name, []): + lockfiles.append(str(path.relative_to(root)).replace("\\", "/")) + + for package_json in files_by_name.get("package.json", []): + relative = str(package_json.relative_to(root)).replace("\\", "/") + manifests.append(relative) + try: + if package_json.stat().st_size > MANIFEST_MAX_BYTES: + raise ValueError("package.json is too large to parse") + data = json.loads(package_json.read_text(encoding="utf-8")) + if not isinstance(data, dict): + raise TypeError("package.json root must be an object") + except (OSError, UnicodeDecodeError, json.JSONDecodeError, TypeError): + findings.append( + Finding( + code="dependency.invalid-package-json", + category="Dependencies", + severity=Severity.WARNING, + message="package.json could not be parsed safely", + path=relative, + deduction=8, + ) + ) + continue + deps: dict[str, object] = {} + invalid_sections = False + for section_name in ("dependencies", "devDependencies", "peerDependencies", "optionalDependencies"): + section = data.get(section_name, {}) + if section is None: + continue + if not isinstance(section, dict): + invalid_sections = True + continue + deps.update(section) + if invalid_sections: + findings.append( + Finding( + code="dependency.invalid-package-json", + category="Dependencies", + severity=Severity.WARNING, + message="One or more package dependency sections are not objects", + path=relative, + deduction=8, + ) + ) + declared += len(deps) + for name, version in deps.items(): + dependency_name = str(name) + dependency_origins[dependency_name.casefold()].add(relative) + raw = str(version).strip().lower() + if raw in {"*", "latest", "x"} and not raw.startswith("workspace:"): + unbounded += 1 + findings.append( + Finding( + code="dependency.unbounded", + category="Dependencies", + severity=Severity.WARNING, + message=f"Dependency {dependency_name} uses an unbounded version", + path=relative, + deduction=5, + ) + ) + parent = package_json.parent + package_roots = [parent, *[ancestor for ancestor in parent.parents if ancestor == root or root in ancestor.parents]] + if not any( + (package_root / lock).exists() + for package_root in package_roots + for lock in ("package-lock.json", "pnpm-lock.yaml", "yarn.lock", "bun.lock", "bun.lockb") + ): + findings.append(Finding(code="dependency.no-lockfile", category="Dependencies", severity=Severity.WARNING, message="JavaScript package has no recognized lockfile", path=relative, deduction=8)) + + requirement_paths = [ + path + for name, values in files_by_name.items() + if name.casefold().startswith("requirements") and name.casefold().endswith(".txt") + for path in values + ] + included_requirements: list[str] = [] + processed_requirements: set[Path] = set() + pending_requirements = list(requirement_paths) + while pending_requirements: + requirements = pending_requirements.pop(0) + try: + requirements = requirements.resolve(strict=True) + except OSError: + continue + if requirements in processed_requirements or requirements != root and root not in requirements.parents: + continue + processed_requirements.add(requirements) + relative = str(requirements.relative_to(root)).replace("\\", "/") + manifests.append(relative) + try: + lines = requirements.read_text(encoding="utf-8").splitlines() + except (OSError, UnicodeDecodeError): + findings.append( + Finding( + code="dependency.unreadable-requirements", + category="Dependencies", + severity=Severity.WARNING, + message="Python requirements file could not be read", + path=relative, + deduction=8, + ) + ) + continue + for line in lines: + stripped = line.strip() + if not stripped or stripped.startswith("#"): + continue + if stripped.startswith(("-r ", "--requirement ")): + include = stripped.split(maxsplit=1)[1].strip() + candidate = (requirements.parent / include).resolve() + if candidate == root or root in candidate.parents: + pending_requirements.append(candidate) + included_requirements.append(str(candidate.relative_to(root)).replace("\\", "/")) + continue + if stripped.startswith("-"): + continue + declared += 1 + name = _python_dependency_name(stripped) + if name: + dependency_origins[name.casefold()].add(relative) + finding = _python_dependency_finding(stripped, relative) + if finding: + unbounded += 1 + findings.append(finding) + + for pyproject in files_by_name.get("pyproject.toml", []): + relative = str(pyproject.relative_to(root)).replace("\\", "/") + manifests.append(relative) + try: + if pyproject.stat().st_size > MANIFEST_MAX_BYTES: + raise ValueError("pyproject.toml is too large to parse") + data = tomllib.loads(pyproject.read_text(encoding="utf-8")) + if not isinstance(data, dict): + raise TypeError("pyproject.toml root must be a table") + except (OSError, UnicodeDecodeError, tomllib.TOMLDecodeError, TypeError): + findings.append( + Finding( + code="dependency.invalid-pyproject", + category="Dependencies", + severity=Severity.WARNING, + message="pyproject.toml could not be parsed safely", + path=relative, + deduction=8, + ) + ) + continue + project = data.get("project", {}) + if not isinstance(project, dict): + findings.append( + Finding( + code="dependency.invalid-pyproject", + category="Dependencies", + severity=Severity.WARNING, + message="pyproject.toml project section is not a table", + path=relative, + deduction=8, + ) + ) + project = {} + project_deps = project.get("dependencies", []) + if isinstance(project_deps, list): + declared += len(project_deps) + for dependency in project_deps: + declaration = str(dependency) + name = _python_dependency_name(declaration) + if name: + dependency_origins[name.casefold()].add(relative) + finding = _python_dependency_finding(declaration, relative) + if finding: + unbounded += 1 + findings.append(finding) + elif project_deps is not None: + findings.append( + Finding( + code="dependency.invalid-pyproject", + category="Dependencies", + severity=Severity.WARNING, + message="pyproject.toml project.dependencies is not a list", + path=relative, + deduction=8, + ) + ) + + optional_deps = project.get("optional-dependencies", {}) + if isinstance(optional_deps, dict): + for dependencies in optional_deps.values(): + if not isinstance(dependencies, list): + continue + declared += len(dependencies) + for dependency in dependencies: + declaration = str(dependency) + name = _python_dependency_name(declaration) + if name: + dependency_origins[name.casefold()].add(relative) + finding = _python_dependency_finding(declaration, relative) + if finding: + unbounded += 1 + findings.append(finding) + elif optional_deps is not None: + findings.append( + Finding( + code="dependency.invalid-pyproject", + category="Dependencies", + severity=Severity.WARNING, + message="pyproject.toml project.optional-dependencies is not a table", + path=relative, + deduction=8, + ) + ) + + for go_mod in files_by_name.get("go.mod", []): + relative = str(go_mod.relative_to(root)).replace("\\", "/") + manifests.append(relative) + try: + text = go_mod.read_text(encoding="utf-8") + except (OSError, UnicodeDecodeError): + findings.append( + Finding( + code="dependency.unreadable-go-mod", + category="Dependencies", + severity=Severity.WARNING, + message="go.mod could not be read", + path=relative, + deduction=8, + ) + ) + continue + matches = list(re.finditer(r"(?m)^\s*([\w./-]+)\s+v\d[^\s]*", text)) + if "require" in text and not matches: + findings.append( + Finding( + code="dependency.invalid-go-mod", + category="Dependencies", + severity=Severity.WARNING, + message="go.mod contains no parseable versioned dependencies", + path=relative, + deduction=8, + ) + ) + for match in matches: + declared += 1 + dependency_origins[match.group(1).casefold()].add(relative) + + for cargo in files_by_name.get("Cargo.toml", []): + relative = str(cargo.relative_to(root)).replace("\\", "/") + manifests.append(relative) + try: + data = tomllib.loads(cargo.read_text(encoding="utf-8")) + except (OSError, UnicodeDecodeError, tomllib.TOMLDecodeError): + findings.append( + Finding( + code="dependency.invalid-cargo-toml", + category="Dependencies", + severity=Severity.WARNING, + message="Cargo.toml could not be parsed safely", + path=relative, + deduction=8, + ) + ) + continue + cargo_deps = data.get("dependencies", {}) + if isinstance(cargo_deps, dict): + declared += len(cargo_deps) + for name in cargo_deps: + dependency_origins[str(name).casefold()].add(relative) + + for pom in files_by_name.get("pom.xml", []): + relative = str(pom.relative_to(root)).replace("\\", "/") + manifests.append(relative) + try: + xml_root = ET.parse(pom).getroot() + except (OSError, UnicodeError, ET.ParseError): + findings.append( + Finding( + code="dependency.invalid-pom", + category="Dependencies", + severity=Severity.WARNING, + message="pom.xml could not be parsed safely", + path=relative, + deduction=8, + ) + ) + continue + dependencies = [element for element in xml_root.iter() if element.tag.split("}")[-1] == "dependency"] + declared += len(dependencies) + for dependency in dependencies: + artifact = next((child.text for child in dependency if child.tag.split("}")[-1] == "artifactId"), None) + if artifact: + dependency_origins[artifact.casefold()].add(relative) + + duplicates = sorted(name for name, origins in dependency_origins.items() if len(origins) > 1) + for name in duplicates[:25]: + origins = sorted(dependency_origins[name]) + findings.append(Finding(code="dependency.duplicate-manifest", category="Dependencies", severity=Severity.INFO, message=f"Dependency {name} is declared across multiple manifests", path=origins[0], deduction=1)) + + return ( + DependencySignals( + manifests=sorted(set(manifests)), + lockfiles=sorted(set(lockfiles)), + declared_dependencies=declared, + unbounded_dependencies=unbounded, + unpinned_dependencies=unpinned, + duplicate_dependencies=duplicates[:50], + included_requirements=sorted(set(included_requirements))[:50], + ), + findings, + ) diff --git a/backend/app/store.py b/backend/app/store.py new file mode 100644 index 0000000..fd5594c --- /dev/null +++ b/backend/app/store.py @@ -0,0 +1,1527 @@ +from __future__ import annotations + +import json +import os +import sqlite3 +from collections import Counter +from collections.abc import Iterator +from contextlib import contextmanager +from datetime import UTC, datetime, timedelta +from hashlib import sha256 +from pathlib import Path +from uuid import uuid4 + +from .models import ( + ArchitectureGraph, + RemediationSignal, + Repository, + RepositoryDetail, + RepositoryPolicy, + RepositoryState, + RepositorySummary, + RepositorySyncResult, + ScanComparison, + ScanJob, + ScanJobStatus, + ScanReport, + ScanSummary, + ScanTrigger, + Severity, + SourceOrigin, + TrendPoint, + finding_fingerprint, +) +from .rules import enrich_findings + +MAX_HISTORY_PER_REPOSITORY = 200 +SCHEMA_VERSION = 4 +JOB_LEASE_SECONDS = 900 +ACTIVE_JOB_STATUSES = ( + ScanJobStatus.QUEUED.value, + ScanJobStatus.ACQUIRING_SOURCE.value, + ScanJobStatus.SCANNING.value, + ScanJobStatus.ANALYZING.value, + ScanJobStatus.PERSISTING.value, +) + + +class QueueFullError(RuntimeError): + pass + + +class MaintenanceModeError(RuntimeError): + """Raised when a new scan is requested while durable maintenance is active.""" + + +def _now() -> datetime: + return datetime.now(UTC) + + +def _iso(value: datetime | None) -> str | None: + return value.isoformat() if value else None + + +def _datetime(value: str | None) -> datetime | None: + if not value: + return None + try: + parsed = datetime.fromisoformat(value) + except ValueError: + return None + return parsed.replace(tzinfo=UTC) if parsed.tzinfo is None else parsed + + +def local_repository_id(path: str) -> str: + resolved = str(Path(path).expanduser().resolve()) + return f"local:{sha256(resolved.encode('utf-8')).hexdigest()[:24]}" + + +def _bounded_setting(name: str, default: int, *, minimum: int, maximum: int) -> int: + try: + value = int(os.getenv(name, str(default))) + except ValueError: + value = default + return min(maximum, max(minimum, value)) + + +def history_per_repository() -> int: + return _bounded_setting("REPOPULSE_HISTORY_PER_REPOSITORY", MAX_HISTORY_PER_REPOSITORY, minimum=1, maximum=2_000) + + +def full_reports_per_repository() -> int: + return _bounded_setting("REPOPULSE_FULL_REPORTS_PER_REPOSITORY", 30, minimum=1, maximum=500) + + +def report_retention_days() -> int: + return _bounded_setting("REPOPULSE_REPORT_RETENTION_DAYS", 365, minimum=1, maximum=3_650) + + +def job_lease_seconds() -> int: + return _bounded_setting("REPOPULSE_JOB_LEASE_SECONDS", JOB_LEASE_SECONDS, minimum=30, maximum=3_600) + + +class ScanStore: + """SQLite-backed catalog, durable scan history and recoverable job queue.""" + + def __init__(self, db_path: str | None = None) -> None: + raw_path = db_path or os.getenv("REPOPULSE_DB", "data/repopulse.db") + self.path = Path(raw_path) + self.path.parent.mkdir(parents=True, exist_ok=True) + self.recovery_metadata: dict[str, str] | None = None + try: + self._validate_existing_database() + self._init_schema() + except sqlite3.DatabaseError as exc: + if not self._is_corruption_error(exc): + raise + backup = self._quarantine_corrupt_database() + self._init_schema() + self.recovery_metadata = { + "status": "degraded_recovered", + "detected_at": _now().isoformat(), + "quarantined_database": backup.name if backup else "unavailable", + "operator_action": "Verify the quarantined database, restore it if needed, then acknowledge recovery.", + } + self.set_state("database_recovery", self.recovery_metadata) + + @staticmethod + def _is_corruption_error(error: sqlite3.DatabaseError) -> bool: + message = str(error).casefold() + return "not a database" in message or "malformed" in message or "corrupt" in message + + def _quarantine_corrupt_database(self) -> Path | None: + if not self.path.exists(): + return None + stamp = _now().strftime("%Y%m%dT%H%M%S%fZ") + backup = self.path.with_name(f"{self.path.name}.corrupt-{stamp}-{uuid4().hex[:8]}") + self.path.replace(backup) + for suffix in ("-wal", "-shm"): + sidecar = Path(f"{self.path}{suffix}") + if sidecar.exists(): + sidecar.replace(Path(f"{backup}{suffix}")) + return backup + + def _validate_existing_database(self) -> None: + if not self.path.exists() or self.path.stat().st_size == 0: + return + connection = sqlite3.connect(self.path, timeout=5.0) + try: + row = connection.execute("PRAGMA quick_check").fetchone() + if row is None or str(row[0]).casefold() != "ok": + raise sqlite3.DatabaseError("database quick_check reported corruption") + finally: + connection.close() + + def _backup_before_migration(self, db: sqlite3.Connection, version: int) -> Path: + stamp = _now().strftime("%Y%m%dT%H%M%S%fZ") + backup = self.path.with_name(f"{self.path.name}.pre-v{version}-{stamp}.bak") + destination = sqlite3.connect(backup) + try: + db.backup(destination) + finally: + destination.close() + return backup + + def _connect(self) -> sqlite3.Connection: + connection = sqlite3.connect(self.path, timeout=5.0) + connection.row_factory = sqlite3.Row + connection.execute("PRAGMA busy_timeout = 5000") + return connection + + @contextmanager + def _connection(self) -> Iterator[sqlite3.Connection]: + connection = self._connect() + try: + yield connection + connection.commit() + except BaseException: + connection.rollback() + raise + finally: + connection.close() + + @staticmethod + def _columns(db: sqlite3.Connection, table: str) -> set[str]: + return {str(row[1]) for row in db.execute(f"PRAGMA table_info({table})").fetchall()} + + def _init_schema(self) -> None: + with self._connection() as db: + current_version = int(db.execute("PRAGMA user_version").fetchone()[0]) + migration_backup: Path | None = None + if current_version > SCHEMA_VERSION: + raise RuntimeError( + f"Database schema version {current_version} is newer than supported version {SCHEMA_VERSION}" + ) + if current_version and current_version < SCHEMA_VERSION: + migration_backup = self._backup_before_migration(db, current_version) + db.execute("PRAGMA journal_mode = WAL") + db.execute("PRAGMA synchronous = NORMAL") + db.execute( + """ + CREATE TABLE IF NOT EXISTS scans ( + id TEXT PRIMARY KEY, + repository_path TEXT NOT NULL, + repository_name TEXT NOT NULL, + scanned_at TEXT NOT NULL, + health_score INTEGER NOT NULL, + report_json TEXT NOT NULL + ) + """ + ) + scan_columns = self._columns(db, "scans") + additions = { + "repository_id": "TEXT", + "history_key": "TEXT", + "source_origin": "TEXT", + "provider": "TEXT", + "branch": "TEXT", + "requested_revision": "TEXT", + "actual_revision": "TEXT", + "trigger": "TEXT", + "finding_count": "INTEGER", + "blocker_count": "INTEGER", + "warning_count": "INTEGER", + "release_readiness": "TEXT", + "primary_signal_json": "TEXT", + "added_findings": "INTEGER", + "resolved_findings": "INTEGER", + "triage_priority": "INTEGER", + "triage_rationale": "TEXT", + "report_compacted": "INTEGER NOT NULL DEFAULT 0", + } + for name, definition in additions.items(): + if name not in scan_columns: + db.execute(f"ALTER TABLE scans ADD COLUMN {name} {definition}") + + db.execute( + """ + CREATE TABLE IF NOT EXISTS repositories ( + id TEXT PRIMARY KEY, + provider TEXT NOT NULL, + provider_repository_id TEXT NOT NULL, + owner TEXT NOT NULL, + name TEXT NOT NULL, + full_name TEXT NOT NULL, + description TEXT, + html_url TEXT, + clone_url TEXT, + default_branch TEXT NOT NULL DEFAULT 'main', + private INTEGER NOT NULL DEFAULT 0, + archived INTEGER NOT NULL DEFAULT 0, + latest_revision TEXT, + latest_revision_at TEXT, + last_synced_at TEXT, + sync_error TEXT, + policy_json TEXT NOT NULL DEFAULT '{}', + source_path TEXT, + UNIQUE(provider, provider_repository_id) + ) + """ + ) + repository_columns = self._columns(db, "repositories") + repository_additions = { + "description": "TEXT", + "available": "INTEGER NOT NULL DEFAULT 1", + } + for name, definition in repository_additions.items(): + if name not in repository_columns: + db.execute(f"ALTER TABLE repositories ADD COLUMN {name} {definition}") + db.execute( + """ + CREATE TABLE IF NOT EXISTS scan_jobs ( + id TEXT PRIMARY KEY, + repository_id TEXT NOT NULL, + status TEXT NOT NULL, + trigger TEXT NOT NULL, + requested_revision TEXT, + actual_revision TEXT, + phase TEXT NOT NULL, + progress INTEGER NOT NULL DEFAULT 0, + message TEXT, + created_at TEXT NOT NULL, + started_at TEXT, + updated_at TEXT NOT NULL, + finished_at TEXT, + duration_ms REAL, + scan_id TEXT, + error_code TEXT, + error_detail TEXT, + attempt INTEGER NOT NULL DEFAULT 0, + lease_until TEXT, + deduplicated INTEGER NOT NULL DEFAULT 0 + ) + """ + ) + job_columns = self._columns(db, "scan_jobs") + if "duration_ms" not in job_columns: + db.execute("ALTER TABLE scan_jobs ADD COLUMN duration_ms REAL") + db.execute( + """ + CREATE TABLE IF NOT EXISTS app_state ( + key TEXT PRIMARY KEY, + value TEXT NOT NULL, + updated_at TEXT NOT NULL + ) + """ + ) + if migration_backup: + db.execute( + """ + INSERT INTO app_state (key, value, updated_at) VALUES (?, ?, ?) + ON CONFLICT(key) DO UPDATE SET value = excluded.value, updated_at = excluded.updated_at + """, + ( + "last_schema_migration_backup", + json.dumps( + { + "from_version": current_version, + "to_version": SCHEMA_VERSION, + "backup_file": migration_backup.name, + "created_at": _now().isoformat(), + }, + separators=(",", ":"), + ), + _now().isoformat(), + ), + ) + db.execute( + "CREATE INDEX IF NOT EXISTS idx_scans_repository_time ON scans(repository_path, scanned_at DESC)" + ) + db.execute( + "CREATE INDEX IF NOT EXISTS idx_scans_repository_id_time ON scans(repository_id, scanned_at DESC)" + ) + db.execute( + "CREATE INDEX IF NOT EXISTS idx_scans_history_time ON scans(history_key, scanned_at DESC)" + ) + db.execute( + "CREATE INDEX IF NOT EXISTS idx_scans_repository_revision ON scans(repository_id, actual_revision)" + ) + db.execute( + "CREATE INDEX IF NOT EXISTS idx_jobs_queue ON scan_jobs(status, created_at)" + ) + db.execute( + "CREATE INDEX IF NOT EXISTS idx_jobs_repository ON scan_jobs(repository_id, created_at DESC)" + ) + self._backfill_legacy_catalog(db) + self._backfill_scan_summaries(db) + db.execute(f"PRAGMA user_version = {SCHEMA_VERSION}") + + def _backfill_legacy_catalog(self, db: sqlite3.Connection) -> None: + rows = db.execute( + """ + SELECT id, repository_path, repository_name, report_json, repository_id, history_key + FROM scans + WHERE repository_id IS NULL OR history_key IS NULL + """ + ).fetchall() + for row in rows: + repository_id = row["repository_id"] or local_repository_id(row["repository_path"]) + history_key = row["history_key"] or repository_id + self._upsert_local_repository_row( + db, + repository_id, + row["repository_name"], + row["repository_path"], + ) + db.execute( + """ + UPDATE scans + SET repository_id = ?, history_key = ?, source_origin = COALESCE(source_origin, 'local'), + provider = COALESCE(provider, 'local'), trigger = COALESCE(trigger, 'local') + WHERE id = ? + """, + (repository_id, history_key, row["id"]), + ) + + @staticmethod + def _summary_fields(report: ScanReport, previous: ScanReport | None = None) -> dict[str, object]: + report = report.model_copy(update={"findings": enrich_findings(report.findings)}) + active = [item for item in report.findings if not item.suppressed] + severity_rank = {Severity.BLOCKER: 0, Severity.WARNING: 1, Severity.INFO: 2} + primary = min( + active, + key=lambda item: (severity_rank[item.severity], -item.deduction, item.category, item.code), + default=None, + ) + primary_signal = ( + RemediationSignal( + code=primary.code, + category=primary.category, + severity=primary.severity, + message=primary.message, + count=sum(1 for item in active if item.code == primary.code), + guidance=primary.guidance, + ) + if primary + else None + ) + previous_active = [item for item in (previous.findings if previous else []) if not item.suppressed] + active_keys = {finding_fingerprint(item) for item in active} + previous_keys = {finding_fingerprint(item) for item in previous_active} + guidance = primary_signal.guidance if primary_signal else None + return { + "finding_count": len(active), + "blocker_count": sum(1 for item in active if item.severity == Severity.BLOCKER), + "warning_count": sum(1 for item in active if item.severity == Severity.WARNING), + "release_readiness": report.release_gate.status if report.release_gate else report.release_readiness, + "primary_signal_json": primary_signal.model_dump_json() if primary_signal else None, + "added_findings": len(active_keys - previous_keys) if previous else 0, + "resolved_findings": len(previous_keys - active_keys) if previous else 0, + "triage_priority": guidance.priority if guidance else 0, + "triage_rationale": guidance.priority_rationale if guidance else None, + } + + def _backfill_scan_summaries(self, db: sqlite3.Connection) -> None: + rows = db.execute( + "SELECT rowid AS scan_rowid, * FROM scans " + "WHERE finding_count IS NULL OR blocker_count IS NULL OR release_readiness IS NULL" + ).fetchall() + for row in rows: + report = self._report_from_row(row) + previous_row = db.execute( + """ + SELECT * FROM scans + WHERE history_key = ? AND ( + scanned_at < ? OR (scanned_at = ? AND rowid < ?) + ) + ORDER BY scanned_at DESC, rowid DESC LIMIT 1 + """, + (row["history_key"], row["scanned_at"], row["scanned_at"], row["scan_rowid"]), + ).fetchone() + previous = self._report_from_row(previous_row) if previous_row else None + fields = self._summary_fields(report, previous) + db.execute( + """ + UPDATE scans SET finding_count = ?, blocker_count = ?, warning_count = ?, release_readiness = ?, + primary_signal_json = ?, added_findings = ?, resolved_findings = ?, triage_priority = ?, + triage_rationale = ? WHERE id = ? + """, + (*fields.values(), row["id"]), + ) + + @staticmethod + def _upsert_local_repository_row( + db: sqlite3.Connection, + repository_id: str, + name: str, + source_path: str, + ) -> None: + db.execute( + """ + INSERT INTO repositories ( + id, provider, provider_repository_id, owner, name, full_name, + default_branch, source_path + ) VALUES (?, 'local', ?, 'local', ?, ?, 'main', ?) + ON CONFLICT(id) DO UPDATE SET + name = excluded.name, + full_name = excluded.full_name, + source_path = COALESCE(excluded.source_path, repositories.source_path) + """, + (repository_id, repository_id.removeprefix("local:"), name, f"local/{name}", source_path), + ) + + @staticmethod + def _upsert_repository_row( + db: sqlite3.Connection, + repository: Repository, + source_path: str | None = None, + ) -> None: + db.execute( + """ + INSERT INTO repositories ( + id, provider, provider_repository_id, owner, name, full_name, + description, html_url, clone_url, default_branch, private, archived, available, + latest_revision, latest_revision_at, last_synced_at, sync_error, + policy_json, source_path + ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) + ON CONFLICT(id) DO UPDATE SET + provider = excluded.provider, + provider_repository_id = excluded.provider_repository_id, + owner = excluded.owner, + name = excluded.name, + full_name = excluded.full_name, + description = excluded.description, + html_url = excluded.html_url, + clone_url = excluded.clone_url, + default_branch = excluded.default_branch, + private = excluded.private, + archived = excluded.archived, + available = excluded.available, + latest_revision = COALESCE(excluded.latest_revision, repositories.latest_revision), + latest_revision_at = COALESCE(excluded.latest_revision_at, repositories.latest_revision_at), + last_synced_at = COALESCE(excluded.last_synced_at, repositories.last_synced_at), + sync_error = excluded.sync_error, + policy_json = excluded.policy_json, + source_path = COALESCE(excluded.source_path, repositories.source_path) + """, + ( + repository.id, + repository.provider, + repository.provider_repository_id, + repository.owner, + repository.name, + repository.full_name, + repository.description, + repository.html_url, + repository.clone_url, + repository.default_branch, + int(repository.private), + int(repository.archived), + int(repository.available), + repository.latest_revision, + _iso(repository.latest_revision_at), + _iso(repository.last_synced_at), + repository.sync_error, + repository.policy.model_dump_json(), + source_path, + ), + ) + + def upsert_repository(self, repository: Repository, *, source_path: str | None = None) -> Repository: + with self._connection() as db: + self._upsert_repository_row(db, repository, source_path) + row = db.execute("SELECT * FROM repositories WHERE id = ?", (repository.id,)).fetchone() + return self._repository_from_row(row) if row else repository + + @staticmethod + def _repository_from_row(row: sqlite3.Row) -> Repository: + try: + policy = RepositoryPolicy.model_validate_json(row["policy_json"] or "{}") + except (TypeError, ValueError): + policy = RepositoryPolicy() + return Repository( + id=row["id"], + provider=row["provider"], + provider_repository_id=row["provider_repository_id"], + owner=row["owner"], + name=row["name"], + full_name=row["full_name"], + description=row["description"], + html_url=row["html_url"], + clone_url=row["clone_url"], + default_branch=row["default_branch"] or "main", + private=bool(row["private"]), + archived=bool(row["archived"]), + available=bool(row["available"]), + latest_revision=row["latest_revision"], + latest_revision_at=_datetime(row["latest_revision_at"]), + last_synced_at=_datetime(row["last_synced_at"]), + sync_error=row["sync_error"], + policy=policy, + ) + + def get_repository(self, repository_id: str) -> Repository | None: + with self._connection() as db: + row = db.execute("SELECT * FROM repositories WHERE id = ?", (repository_id,)).fetchone() + return self._repository_from_row(row) if row else None + + def get_repository_source_path(self, repository_id: str) -> str | None: + with self._connection() as db: + row = db.execute("SELECT source_path FROM repositories WHERE id = ?", (repository_id,)).fetchone() + return row["source_path"] if row else None + + def _repository_summary(self, db: sqlite3.Connection, row: sqlite3.Row) -> RepositorySummary: + repository = self._repository_from_row(row) + latest = db.execute( + """ + SELECT * FROM scans WHERE repository_id = ? + ORDER BY scanned_at DESC, rowid DESC LIMIT 1 + """, + (repository.id,), + ).fetchone() + active = db.execute( + """ + SELECT * FROM scan_jobs WHERE repository_id = ? AND status IN (?, ?, ?, ?, ?) + ORDER BY created_at DESC LIMIT 1 + """, + (repository.id, *ACTIVE_JOB_STATUSES), + ).fetchone() + last_job = db.execute( + "SELECT * FROM scan_jobs WHERE repository_id = ? ORDER BY created_at DESC LIMIT 1", + (repository.id,), + ).fetchone() + last_scan = self._report_from_row(latest) if latest else None + active_findings = [item for item in (last_scan.findings if last_scan else []) if not item.suppressed] + severity_rank = {Severity.BLOCKER: 0, Severity.WARNING: 1, Severity.INFO: 2} + primary_finding = min( + active_findings, + key=lambda item: (severity_rank[item.severity], -item.deduction, item.category, item.code), + default=None, + ) + primary_signal = ( + RemediationSignal( + code=primary_finding.code, + category=primary_finding.category, + severity=primary_finding.severity, + message=primary_finding.message, + count=sum(1 for item in active_findings if item.code == primary_finding.code), + ) + if primary_finding + else None + ) + previous_row = ( + db.execute( + """ + SELECT * FROM scans + WHERE repository_id = ? AND id != ? + ORDER BY scanned_at DESC, rowid DESC LIMIT 1 + """, + (repository.id, last_scan.id), + ).fetchone() + if last_scan + else None + ) + previous_scan = self._report_from_row(previous_row) if previous_row else None + previous_findings = [item for item in (previous_scan.findings if previous_scan else []) if not item.suppressed] + active_fingerprints = {self._finding_key(item) for item in active_findings} + previous_fingerprints = {self._finding_key(item) for item in previous_findings} + last_revision = ( + last_scan.source.actual_revision + if last_scan and last_scan.source.actual_revision + else (latest["actual_revision"] if latest else None) + ) + stale = bool(repository.latest_revision and last_revision and repository.latest_revision != last_revision) + if repository.archived: + state = RepositoryState.ARCHIVED + elif not repository.available: + state = RepositoryState.UNAVAILABLE + elif active: + state = ( + RepositoryState.QUEUED + if active["status"] == ScanJobStatus.QUEUED.value + else RepositoryState.SCANNING + ) + elif last_job and last_job["status"] == ScanJobStatus.FAILED.value: + last_job_at = _datetime(last_job["created_at"]) + if last_scan is None or (last_job_at and last_job_at > last_scan.scanned_at): + state = RepositoryState.FAILED + elif stale: + state = RepositoryState.STALE + else: + state = RepositoryState.CURRENT + elif last_scan is None: + state = RepositoryState.NEVER_SCANNED + elif stale: + state = RepositoryState.STALE + else: + state = RepositoryState.CURRENT + data = repository.model_dump() + data.update( + { + "state": state, + "stale": stale, + "active_job_id": active["id"] if active else None, + "last_scan_id": last_scan.id if last_scan else None, + "last_scan_at": last_scan.scanned_at if last_scan else None, + "last_scan_health": last_scan.health_score if last_scan else None, + "last_scan_readiness": last_scan.release_gate.status if last_scan and last_scan.release_gate else (last_scan.release_readiness if last_scan else None), + "last_scan_revision": last_revision, + "last_scan_blockers": sum(1 for item in active_findings if item.severity == Severity.BLOCKER), + "last_scan_warnings": sum(1 for item in active_findings if item.severity == Severity.WARNING), + "last_scan_primary_signal": primary_signal, + "last_scan_health_delta": (last_scan.health_score - previous_scan.health_score) if previous_scan and last_scan else None, + "last_scan_added_findings": len(active_fingerprints - previous_fingerprints) if previous_scan else 0, + "last_scan_resolved_findings": len(previous_fingerprints - active_fingerprints) if previous_scan else 0, + } + ) + return RepositorySummary(**data) + + def _catalog_rows( + self, db: sqlite3.Connection, *, limit: int, offset: int = 0, repository_id: str | None = None + ) -> list[sqlite3.Row]: + where = "WHERE r.id = ?" if repository_id else "" + params: tuple[object, ...] = (repository_id, limit, offset) if repository_id else (limit, offset) + return db.execute( + f""" + WITH ranked_scans AS ( + SELECT s.*, ROW_NUMBER() OVER ( + PARTITION BY s.repository_id ORDER BY s.scanned_at DESC, s.rowid DESC + ) AS scan_rank + FROM scans AS s WHERE s.repository_id IS NOT NULL + ), active_jobs AS ( + SELECT j.id, j.repository_id, j.status, ROW_NUMBER() OVER ( + PARTITION BY j.repository_id ORDER BY j.created_at DESC, j.rowid DESC + ) AS job_rank + FROM scan_jobs AS j + WHERE j.status IN ('queued', 'acquiring_source', 'scanning', 'analyzing', 'persisting') + ), last_jobs AS ( + SELECT j.repository_id, j.status, j.created_at, ROW_NUMBER() OVER ( + PARTITION BY j.repository_id ORDER BY j.created_at DESC, j.rowid DESC + ) AS job_rank + FROM scan_jobs AS j + ) + SELECT r.*, + latest.id AS summary_scan_id, latest.scanned_at AS summary_scanned_at, + latest.health_score AS summary_health, latest.release_readiness AS summary_readiness, + latest.actual_revision AS summary_revision, latest.finding_count AS summary_findings, + latest.blocker_count AS summary_blockers, latest.warning_count AS summary_warnings, + latest.primary_signal_json AS summary_primary_signal, + latest.added_findings AS summary_added, latest.resolved_findings AS summary_resolved, + latest.triage_priority AS summary_priority, latest.triage_rationale AS summary_rationale, + previous.health_score AS previous_health, + active.id AS active_job_id, active.status AS active_job_status, + last_job.status AS last_job_status, last_job.created_at AS last_job_created_at + FROM repositories AS r + LEFT JOIN ranked_scans AS latest ON latest.repository_id = r.id AND latest.scan_rank = 1 + LEFT JOIN ranked_scans AS previous ON previous.repository_id = r.id AND previous.scan_rank = 2 + LEFT JOIN active_jobs AS active ON active.repository_id = r.id AND active.job_rank = 1 + LEFT JOIN last_jobs AS last_job ON last_job.repository_id = r.id AND last_job.job_rank = 1 + {where} + ORDER BY r.archived ASC, r.full_name COLLATE NOCASE ASC + LIMIT ? OFFSET ? + """, + params, + ).fetchall() + + def _compact_repository_summary(self, row: sqlite3.Row) -> RepositorySummary: + repository = self._repository_from_row(row) + primary_signal = None + if row["summary_primary_signal"]: + try: + primary_signal = RemediationSignal.model_validate_json(row["summary_primary_signal"]) + except (TypeError, ValueError): + primary_signal = None + last_revision = row["summary_revision"] + stale = bool(repository.latest_revision and last_revision and repository.latest_revision != last_revision) + if repository.archived: + state = RepositoryState.ARCHIVED + elif not repository.available: + state = RepositoryState.UNAVAILABLE + elif row["active_job_id"]: + state = RepositoryState.QUEUED if row["active_job_status"] == ScanJobStatus.QUEUED.value else RepositoryState.SCANNING + elif row["last_job_status"] == ScanJobStatus.FAILED.value: + last_job_at = _datetime(row["last_job_created_at"]) + last_scan_at = _datetime(row["summary_scanned_at"]) + if last_scan_at is None or (last_job_at and last_job_at > last_scan_at): + state = RepositoryState.FAILED + else: + state = RepositoryState.STALE if stale else RepositoryState.CURRENT + elif row["summary_scan_id"] is None: + state = RepositoryState.NEVER_SCANNED + else: + state = RepositoryState.STALE if stale else RepositoryState.CURRENT + data = repository.model_dump() + data.update( + { + "state": state, + "stale": stale, + "active_job_id": row["active_job_id"], + "last_scan_id": row["summary_scan_id"], + "last_scan_at": _datetime(row["summary_scanned_at"]), + "last_scan_health": row["summary_health"], + "last_scan_readiness": row["summary_readiness"], + "last_scan_revision": last_revision, + "last_scan_blockers": int(row["summary_blockers"] or 0), + "last_scan_warnings": int(row["summary_warnings"] or 0), + "last_scan_primary_signal": primary_signal, + "last_scan_health_delta": ( + int(row["summary_health"]) - int(row["previous_health"]) + if row["summary_health"] is not None and row["previous_health"] is not None + else None + ), + "last_scan_added_findings": int(row["summary_added"] or 0), + "last_scan_resolved_findings": int(row["summary_resolved"] or 0), + "last_scan_priority": int(row["summary_priority"] or 0), + "last_scan_priority_rationale": row["summary_rationale"], + } + ) + return RepositorySummary(**data) + + def list_repositories(self, limit: int = 100, offset: int = 0) -> list[RepositorySummary]: + with self._connection() as db: + return [self._compact_repository_summary(row) for row in self._catalog_rows(db, limit=limit, offset=offset)] + + def repository_count(self) -> int: + with self._connection() as db: + return int(db.execute("SELECT COUNT(*) FROM repositories").fetchone()[0]) + + def repository_state_counts(self) -> dict[str, int]: + counts: Counter[str] = Counter() + for repository in self.list_repositories(limit=1000): + counts[repository.state.value] += 1 + return dict(counts) + + def get_repository_detail(self, repository_id: str) -> RepositoryDetail | None: + with self._connection() as db: + rows = self._catalog_rows(db, repository_id=repository_id, limit=1) + if not rows: + return None + summary = self._compact_repository_summary(rows[0]) + latest = db.execute( + "SELECT * FROM scans WHERE repository_id = ? ORDER BY scanned_at DESC, rowid DESC LIMIT 1", + (repository_id,), + ).fetchone() + return RepositoryDetail(**summary.model_dump(), latest_scan=self._report_from_row(latest) if latest else None) + + def repository_scans(self, repository_id: str, limit: int = 50) -> list[ScanSummary]: + with self._connection() as db: + rows = db.execute( + "SELECT * FROM scans WHERE repository_id = ? ORDER BY scanned_at DESC, rowid DESC LIMIT ?", + (repository_id, limit), + ).fetchall() + result: list[ScanSummary] = [] + for row in rows: + report = self._report_from_row(row) + result.append( + ScanSummary( + id=report.id, + repository_id=repository_id, + scanned_at=report.scanned_at, + branch=report.source.branch, + requested_revision=report.source.requested_revision, + actual_revision=report.source.actual_revision, + trigger=report.source.trigger, + health_score=report.health_score, + release_readiness=report.release_readiness, + findings=len(report.findings), + duration_ms=report.duration_ms, + ) + ) + return result + + def _report_from_row(self, row: sqlite3.Row | None) -> ScanReport: + if row is None: + raise ValueError("Scan row is required") + report = ScanReport.model_validate_json(row["report_json"]) + source_updates: dict[str, object] = {} + if row["repository_id"] and not report.source.repository_id: + source_updates["repository_id"] = row["repository_id"] + if row["source_origin"] and report.source.origin == SourceOrigin.LOCAL: + try: + source_updates["origin"] = SourceOrigin(str(row["source_origin"])) + except ValueError: + pass + if row["provider"] and not report.source.provider: + source_updates["provider"] = row["provider"] + for field in ("branch", "requested_revision", "actual_revision", "trigger"): + value = row[field] + if value is not None and getattr(report.source, field) in (None, ScanTrigger.MANUAL): + if field == "trigger": + try: + source_updates[field] = ScanTrigger(str(value)) + except ValueError: + continue + else: + source_updates[field] = value + if source_updates: + report = report.model_copy(update={"source": report.source.model_copy(update=source_updates)}) + return report.model_copy( + update={ + "findings": enrich_findings(report.findings), + "compacted": bool(row["report_compacted"]) if "report_compacted" in row else report.compacted, + } + ) + + def _normalise_report(self, report: ScanReport) -> ScanReport: + if report.source.repository_id: + return report + repository_id = local_repository_id(report.repository_path) + source = report.source.model_copy( + update={ + "origin": SourceOrigin.LOCAL, + "provider": "local", + "repository_id": repository_id, + "repository_full_name": f"local/{report.repository_name}", + "trigger": ScanTrigger.LOCAL, + } + ) + return report.model_copy(update={"source": source}) + + def save(self, report: ScanReport) -> ScanReport: + report = self._normalise_report(report) + report = report.model_copy(update={"findings": enrich_findings(report.findings)}) + source = report.source + history_key = source.repository_id or report.repository_path + with self._connection() as db: + if source.origin == SourceOrigin.LOCAL and source.repository_id: + self._upsert_local_repository_row(db, source.repository_id, report.repository_name, report.repository_path) + previous_row = db.execute( + """ + SELECT * FROM scans WHERE history_key = ? ORDER BY scanned_at DESC, rowid DESC LIMIT 1 + """, + (history_key,), + ).fetchone() + previous = self._report_from_row(previous_row) if previous_row else None + summary = self._summary_fields(report, previous) + db.execute( + """ + INSERT INTO scans ( + id, repository_path, repository_name, scanned_at, health_score, report_json, + repository_id, history_key, source_origin, provider, branch, + requested_revision, actual_revision, trigger, finding_count, blocker_count, + warning_count, release_readiness, primary_signal_json, added_findings, + resolved_findings, triage_priority, triage_rationale, report_compacted + ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) + """, + ( + report.id, + report.repository_path, + report.repository_name, + report.scanned_at.isoformat(), + report.health_score, + report.model_dump_json(), + source.repository_id, + history_key, + source.origin.value, + source.provider, + source.branch, + source.requested_revision, + source.actual_revision, + source.trigger.value, + summary["finding_count"], + summary["blocker_count"], + summary["warning_count"], + summary["release_readiness"], + summary["primary_signal_json"], + summary["added_findings"], + summary["resolved_findings"], + summary["triage_priority"], + summary["triage_rationale"], + 0, + ), + ) + self._apply_retention(db, history_key) + if source.repository_id: + db.execute( + """ + UPDATE repositories + SET latest_revision = COALESCE(?, latest_revision), + latest_revision_at = COALESCE(latest_revision_at, ?), + sync_error = NULL + WHERE id = ? AND provider = 'local' + """, + (source.actual_revision, _iso(report.scanned_at), source.repository_id), + ) + return report + + def _apply_retention(self, db: sqlite3.Connection, history_key: str) -> None: + db.execute( + """ + DELETE FROM scans + WHERE history_key = ? + AND rowid NOT IN ( + SELECT rowid FROM scans WHERE history_key = ? + ORDER BY scanned_at DESC, rowid DESC LIMIT ? + ) + """, + (history_key, history_key, history_per_repository()), + ) + cutoff = (_now() - timedelta(days=report_retention_days())).isoformat() + db.execute("DELETE FROM scans WHERE history_key = ? AND scanned_at < ?", (history_key, cutoff)) + rows = db.execute( + """ + SELECT * FROM scans WHERE history_key = ? AND report_compacted = 0 + ORDER BY scanned_at DESC, rowid DESC LIMIT -1 OFFSET ? + """, + (history_key, full_reports_per_repository()), + ).fetchall() + for row in rows: + report = self._report_from_row(row) + compact = report.model_copy( + update={"findings": [], "architecture": ArchitectureGraph(), "hotspots": [], "compacted": True} + ) + db.execute( + "UPDATE scans SET report_json = ?, report_compacted = 1 WHERE id = ?", + (compact.model_dump_json(), row["id"]), + ) + + def get(self, scan_id: str) -> ScanReport | None: + with self._connection() as db: + row = db.execute("SELECT * FROM scans WHERE id = ?", (scan_id,)).fetchone() + return self._report_from_row(row) if row else None + + def recent(self, limit: int = 20) -> list[ScanReport]: + with self._connection() as db: + rows = db.execute( + "SELECT * FROM scans ORDER BY scanned_at DESC, rowid DESC LIMIT ?", + (limit,), + ).fetchall() + return [self._report_from_row(row) for row in rows] + + def _history_candidates(self, repository_key: str) -> list[str]: + if repository_key.startswith(("local:", "gitea:")): + return [repository_key] + return [repository_key, local_repository_id(repository_key)] + + def recent_for_repository(self, repository_key: str, limit: int = 50) -> list[ScanReport]: + with self._connection() as db: + for candidate in self._history_candidates(repository_key): + rows = db.execute( + "SELECT * FROM scans WHERE history_key = ? ORDER BY scanned_at DESC, rowid DESC LIMIT ?", + (candidate, limit), + ).fetchall() + if rows: + return [self._report_from_row(row) for row in rows] + return [] + + def previous_for_repository(self, repository_key: str, exclude_id: str) -> ScanReport | None: + with self._connection() as db: + for candidate in self._history_candidates(repository_key): + row = db.execute( + """ + SELECT previous.* + FROM scans AS previous + JOIN scans AS current ON current.id = ? + WHERE previous.history_key = ? + AND previous.id != current.id + AND ( + previous.scanned_at < current.scanned_at + OR (previous.scanned_at = current.scanned_at AND previous.rowid < current.rowid) + ) + ORDER BY previous.scanned_at DESC, previous.rowid DESC + LIMIT 1 + """, + (exclude_id, candidate), + ).fetchone() + if row: + return self._report_from_row(row) + return None + + @staticmethod + def _finding_key(report_finding) -> str: + return report_finding.fingerprint or finding_fingerprint(report_finding) + + def compare(self, report: ScanReport) -> ScanComparison: + previous = self.previous_for_repository( + report.source.repository_id or report.repository_path, + report.id, + ) + if previous is None: + return ScanComparison(current_scan_id=report.id) + + current_metrics = report.metrics.model_dump() + previous_metrics = previous.metrics.model_dump() + metric_deltas = { + key: int(current_metrics[key]) - int(previous_metrics.get(key, 0)) + for key in current_metrics + } + category_deltas = { + category: report.category_scores.get(category, 0) - previous.category_scores.get(category, 0) + for category in set(report.category_scores) | set(previous.category_scores) + } + current_findings = {self._finding_key(item): item for item in report.findings} + previous_findings = {self._finding_key(item): item for item in previous.findings} + added = [current_findings[key] for key in current_findings.keys() - previous_findings.keys()] + resolved = [previous_findings[key] for key in previous_findings.keys() - current_findings.keys()] + + return ScanComparison( + current_scan_id=report.id, + previous_scan_id=previous.id, + health_score_delta=report.health_score - previous.health_score, + category_score_deltas=dict(sorted(category_deltas.items())), + metric_deltas=metric_deltas, + added_findings=sorted(added, key=lambda item: (item.category, item.path or "", item.line or 0)), + resolved_findings=sorted(resolved, key=lambda item: (item.category, item.path or "", item.line or 0)), + ) + + def trend(self, repository_key: str, limit: int = 50) -> list[TrendPoint]: + reports = list(reversed(self.recent_for_repository(repository_key, limit))) + points: list[TrendPoint] = [] + for report in reports: + blockers = sum(1 for item in report.findings if item.severity == Severity.BLOCKER) + warnings = sum(1 for item in report.findings if item.severity == Severity.WARNING) + debt = report.metrics.todo + report.metrics.fixme + report.metrics.hack + report.metrics.xxx + points.append( + TrendPoint( + scan_id=report.id, + scanned_at=report.scanned_at, + health_score=report.health_score, + findings=len(report.findings), + blockers=blockers, + warnings=warnings, + debt_markers=debt, + ) + ) + return points + + @staticmethod + def _job_from_row(row: sqlite3.Row) -> ScanJob: + return ScanJob( + id=row["id"], + repository_id=row["repository_id"], + status=row["status"], + trigger=row["trigger"], + requested_revision=row["requested_revision"], + actual_revision=row["actual_revision"], + phase=row["phase"], + progress=int(row["progress"]), + message=row["message"], + created_at=_datetime(row["created_at"]) or _now(), + started_at=_datetime(row["started_at"]), + updated_at=_datetime(row["updated_at"]) or _now(), + finished_at=_datetime(row["finished_at"]), + duration_ms=float(row["duration_ms"]) if row["duration_ms"] is not None else None, + scan_id=row["scan_id"], + error_code=row["error_code"], + error_detail=row["error_detail"], + attempt=int(row["attempt"]), + deduplicated=bool(row["deduplicated"]), + ) + + def _recover_expired_jobs(self, db: sqlite3.Connection, now: str) -> None: + placeholders = ",".join("?" for _ in ACTIVE_JOB_STATUSES[1:]) + db.execute( + f""" + UPDATE scan_jobs + SET status = 'queued', phase = 'queued', progress = 0, + message = 'Recovered after worker lease expiry', updated_at = ?, lease_until = NULL + WHERE status IN ({placeholders}) AND lease_until IS NOT NULL AND lease_until < ? + """, + (now, *ACTIVE_JOB_STATUSES[1:], now), + ) + + def enqueue_job( + self, + repository_id: str, + requested_revision: str | None, + trigger: ScanTrigger, + *, + force: bool = False, + max_queue: int = 100, + ) -> ScanJob: + now_dt = _now() + now = now_dt.isoformat() + with self._connection() as db: + db.execute("BEGIN IMMEDIATE") + if self._maintenance_enabled(db): + raise MaintenanceModeError("RepoPulse is in maintenance mode") + self._recover_expired_jobs(db, now) + repository = db.execute("SELECT id FROM repositories WHERE id = ?", (repository_id,)).fetchone() + if repository is None: + raise KeyError(repository_id) + active_rows = db.execute( + """ + SELECT * FROM scan_jobs + WHERE repository_id = ? AND status IN (?, ?, ?, ?, ?) + ORDER BY created_at DESC + """, + (repository_id, *ACTIVE_JOB_STATUSES), + ).fetchall() + if not force: + for row in active_rows: + if row["requested_revision"] == requested_revision: + return self._job_from_row(row).model_copy(update={"deduplicated": True}) + if requested_revision and not force: + completed = db.execute( + """ + SELECT * FROM scans + WHERE repository_id = ? AND actual_revision = ? + ORDER BY scanned_at DESC, rowid DESC LIMIT 1 + """, + (repository_id, requested_revision), + ).fetchone() + if completed: + existing = db.execute( + """ + SELECT * FROM scan_jobs WHERE repository_id = ? AND scan_id = ? + ORDER BY created_at DESC LIMIT 1 + """, + (repository_id, completed["id"]), + ).fetchone() + if existing: + return self._job_from_row(existing).model_copy(update={"deduplicated": True}) + job_id = str(uuid4()) + db.execute( + """ + INSERT INTO scan_jobs ( + id, repository_id, status, trigger, requested_revision, actual_revision, + phase, progress, message, created_at, updated_at, finished_at, scan_id, + deduplicated + ) VALUES (?, ?, 'completed', ?, ?, ?, 'completed', 100, + 'Existing revision already analyzed', ?, ?, ?, ?, 1) + """, + ( + job_id, + repository_id, + trigger.value, + requested_revision, + completed["actual_revision"], + now, + now, + completed["scanned_at"], + completed["id"], + ), + ) + row = db.execute("SELECT * FROM scan_jobs WHERE id = ?", (job_id,)).fetchone() + return self._job_from_row(row) + queued = db.execute( + "SELECT COUNT(*) FROM scan_jobs WHERE status = 'queued'" + ).fetchone()[0] + if int(queued) >= max(1, max_queue): + raise QueueFullError("Scan queue is full; retry after queued work completes") + if requested_revision: + for row in active_rows: + if row["status"] == ScanJobStatus.QUEUED.value and row["requested_revision"] != requested_revision: + db.execute( + """ + UPDATE scan_jobs + SET status = 'superseded', phase = 'superseded', progress = 100, + message = 'Superseded by a newer repository revision', + updated_at = ?, finished_at = ? + WHERE id = ? + """, + (now, now, row["id"]), + ) + job_id = str(uuid4()) + db.execute( + """ + INSERT INTO scan_jobs ( + id, repository_id, status, trigger, requested_revision, phase, + progress, message, created_at, updated_at + ) VALUES (?, ?, 'queued', ?, ?, 'queued', 0, 'Waiting for an available worker', ?, ?) + """, + (job_id, repository_id, trigger.value, requested_revision, now, now), + ) + row = db.execute("SELECT * FROM scan_jobs WHERE id = ?", (job_id,)).fetchone() + return self._job_from_row(row) + + def get_job(self, job_id: str) -> ScanJob | None: + with self._connection() as db: + row = db.execute("SELECT * FROM scan_jobs WHERE id = ?", (job_id,)).fetchone() + return self._job_from_row(row) if row else None + + def claim_next_job(self) -> ScanJob | None: + now_dt = _now() + now = now_dt.isoformat() + lease_until = (now_dt + timedelta(seconds=job_lease_seconds())).isoformat() + with self._connection() as db: + db.execute("BEGIN IMMEDIATE") + if self._maintenance_enabled(db): + return None + self._recover_expired_jobs(db, now) + row = db.execute( + """ + SELECT queued.* FROM scan_jobs AS queued + WHERE queued.status = 'queued' + ORDER BY COALESCE(( + SELECT MAX(served.started_at) FROM scan_jobs AS served + WHERE served.repository_id = queued.repository_id AND served.started_at IS NOT NULL + ), ''), queued.created_at, queued.rowid + LIMIT 1 + """ + ).fetchone() + if row is None: + return None + db.execute( + """ + UPDATE scan_jobs + SET status = 'acquiring_source', phase = 'acquiring_source', progress = 5, + message = 'Acquiring exact repository revision', started_at = COALESCE(started_at, ?), + updated_at = ?, attempt = attempt + 1, lease_until = ? + WHERE id = ? AND status = 'queued' + """, + (now, now, lease_until, row["id"]), + ) + claimed = db.execute("SELECT * FROM scan_jobs WHERE id = ?", (row["id"],)).fetchone() + return self._job_from_row(claimed) + + def renew_job_lease(self, job_id: str) -> ScanJob | None: + """Renew only an actively owned lease; terminal jobs are never resurrected.""" + + lease_until = (_now() + timedelta(seconds=job_lease_seconds())).isoformat() + placeholders = ",".join("?" for _ in ACTIVE_JOB_STATUSES[1:]) + with self._connection() as db: + db.execute( + f""" + UPDATE scan_jobs SET lease_until = ?, updated_at = ? + WHERE id = ? AND status IN ({placeholders}) + """, + (lease_until, _now().isoformat(), job_id, *ACTIVE_JOB_STATUSES[1:]), + ) + row = db.execute("SELECT * FROM scan_jobs WHERE id = ?", (job_id,)).fetchone() + return self._job_from_row(row) if row else None + + def update_job(self, job_id: str, **updates: object) -> ScanJob | None: + allowed = { + "status", + "actual_revision", + "phase", + "progress", + "message", + "started_at", + "finished_at", + "duration_ms", + "scan_id", + "error_code", + "error_detail", + "lease_until", + } + invalid = set(updates) - allowed + if invalid: + raise ValueError(f"Unsupported job fields: {sorted(invalid)}") + if not updates: + return self.get_job(job_id) + serialised: dict[str, object] = {} + for key, value in updates.items(): + if isinstance(value, datetime): + serialised[key] = _iso(value) + elif isinstance(value, (ScanJobStatus, ScanTrigger)): + serialised[key] = value.value + else: + serialised[key] = value + serialised["updated_at"] = _now().isoformat() + if serialised.get("status") in ACTIVE_JOB_STATUSES[1:] and "lease_until" not in serialised: + serialised["lease_until"] = (_now() + timedelta(seconds=job_lease_seconds())).isoformat() + if "status" in serialised and serialised["status"] in { + ScanJobStatus.COMPLETED.value, + ScanJobStatus.FAILED.value, + ScanJobStatus.CANCELLED.value, + ScanJobStatus.SUPERSEDED.value, + }: + with self._connection() as db: + existing = db.execute( + "SELECT started_at FROM scan_jobs WHERE id = ?", (job_id,) + ).fetchone() + if "duration_ms" not in serialised and existing and existing["started_at"]: + started = _datetime(existing["started_at"]) + if started: + serialised["duration_ms"] = max(0.0, (_now() - started).total_seconds() * 1000) + serialised.setdefault("finished_at", _now().isoformat()) + serialised.setdefault("lease_until", None) + columns = ", ".join(f"{key} = ?" for key in serialised) + with self._connection() as db: + db.execute( + f"UPDATE scan_jobs SET {columns} WHERE id = ?", + (*serialised.values(), job_id), + ) + row = db.execute("SELECT * FROM scan_jobs WHERE id = ?", (job_id,)).fetchone() + return self._job_from_row(row) if row else None + + @staticmethod + def _maintenance_enabled(db: sqlite3.Connection) -> bool: + row = db.execute("SELECT value FROM app_state WHERE key = 'maintenance_mode'").fetchone() + if row is None: + return False + try: + value = json.loads(row["value"]) + except (TypeError, json.JSONDecodeError): + # Fail closed if persisted control state cannot be interpreted. + return True + if isinstance(value, dict) and isinstance(value.get("enabled"), bool): + return value["enabled"] + return value is not False + + def maintenance_status(self) -> dict[str, object]: + with self._connection() as db: + row = db.execute( + "SELECT value FROM app_state WHERE key = 'maintenance_mode'" + ).fetchone() + if row is None: + return {"enabled": False, "changed_at": None} + try: + value = json.loads(row["value"]) + except (TypeError, json.JSONDecodeError): + return {"enabled": True, "changed_at": None, "state_error": "invalid_persisted_state"} + if isinstance(value, dict) and isinstance(value.get("enabled"), bool): + return { + "enabled": value["enabled"], + "changed_at": value.get("changed_at"), + } + if isinstance(value, bool): + return {"enabled": value, "changed_at": None} + return {"enabled": True, "changed_at": None, "state_error": "invalid_persisted_state"} + + def set_maintenance_mode(self, enabled: bool) -> dict[str, object]: + changed_at = _now().isoformat() + value = json.dumps({"enabled": enabled, "changed_at": changed_at}, separators=(",", ":")) + with self._connection() as db: + db.execute("BEGIN IMMEDIATE") + db.execute( + """ + INSERT INTO app_state (key, value, updated_at) VALUES ('maintenance_mode', ?, ?) + ON CONFLICT(key) DO UPDATE SET value = excluded.value, updated_at = excluded.updated_at + """, + (value, changed_at), + ) + return {"enabled": enabled, "changed_at": changed_at} + + def touch_worker_heartbeat_if_active(self, heartbeat: str) -> bool: + """Persist scheduler liveness only when maintenance is not active.""" + + with self._connection() as db: + db.execute("BEGIN IMMEDIATE") + if self._maintenance_enabled(db): + return False + db.execute( + """ + INSERT INTO app_state (key, value, updated_at) VALUES ('worker_heartbeat', ?, ?) + ON CONFLICT(key) DO UPDATE SET value = excluded.value, updated_at = excluded.updated_at + """, + (heartbeat, _now().isoformat()), + ) + return True + + def queue_stats(self) -> dict[str, int | str | None]: + with self._connection() as db: + rows = db.execute("SELECT status, COUNT(*) AS count FROM scan_jobs GROUP BY status").fetchall() + counts = {str(row["status"]): int(row["count"]) for row in rows} + heartbeat = db.execute("SELECT value FROM app_state WHERE key = 'worker_heartbeat'").fetchone() + sync = db.execute("SELECT value FROM app_state WHERE key = 'last_gitea_sync'").fetchone() + return { + "queued": counts.get(ScanJobStatus.QUEUED.value, 0), + "active": sum(counts.get(status, 0) for status in ACTIVE_JOB_STATUSES[1:]), + "completed": counts.get(ScanJobStatus.COMPLETED.value, 0), + "failed": counts.get(ScanJobStatus.FAILED.value, 0), + "worker_heartbeat": heartbeat["value"] if heartbeat else None, + "last_gitea_sync": sync["value"] if sync else None, + } + + @staticmethod + def _tree_stats(root: Path) -> tuple[int, int]: + """Return bounded managed-cache file count and bytes without following links.""" + + if not root.exists() or root.is_symlink(): + return 0, 0 + files = 0 + total_bytes = 0 + pending = [root] + while pending and files < 50_000: + current = pending.pop() + try: + entries = list(current.iterdir()) + except OSError: + continue + for entry in entries: + if entry.is_symlink(): + continue + try: + if entry.is_dir(): + pending.append(entry) + elif entry.is_file(): + files += 1 + total_bytes += entry.stat().st_size + except OSError: + continue + if files >= 50_000: + break + return files, total_bytes + + @staticmethod + def _managed_entry_count(root: Path) -> int: + try: + return sum(1 for entry in root.iterdir() if not entry.is_symlink()) + except OSError: + return 0 + + def storage_stats(self) -> dict[str, int | str | None]: + with self._connection() as db: + row = db.execute( + """ + SELECT COUNT(*) AS scan_count, + SUM(CASE WHEN report_compacted = 1 THEN 1 ELSE 0 END) AS compacted_scan_count, + MIN(scanned_at) AS oldest_scan_at, MAX(scanned_at) AS newest_scan_at + FROM scans + """ + ).fetchone() + migration_backup = db.execute( + "SELECT value FROM app_state WHERE key = 'last_schema_migration_backup'" + ).fetchone() + database_bytes = self.path.stat().st_size if self.path.exists() else 0 + journal = Path(f"{self.path}-wal") + journal_bytes = journal.stat().st_size if journal.exists() else 0 + cache_root = Path(os.getenv("REPOPULSE_REPOSITORY_CACHE", "data/repos")).expanduser() + mirrors_root = cache_root / "mirrors" + worktrees_root = cache_root / "worktrees" + _mirror_files, mirror_cache_bytes = self._tree_stats(mirrors_root) + mirror_count = self._managed_entry_count(mirrors_root) + worktree_count = self._managed_entry_count(worktrees_root) + return { + "database_bytes": database_bytes, + "journal_bytes": journal_bytes, + "mirror_count": mirror_count, + "mirror_cache_bytes": mirror_cache_bytes, + "worktree_count": worktree_count, + "scan_count": int(row["scan_count"] or 0), + "compacted_scan_count": int(row["compacted_scan_count"] or 0), + "oldest_scan_at": row["oldest_scan_at"], + "newest_scan_at": row["newest_scan_at"], + "history_per_repository": history_per_repository(), + "full_reports_per_repository": full_reports_per_repository(), + "report_retention_days": report_retention_days(), + "last_schema_migration_backup": migration_backup["value"] if migration_backup else None, + } + + def database_recovery_status(self) -> dict[str, object]: + stored = self.get_state("database_recovery") + if not stored: + return {"status": "healthy"} + try: + value = json.loads(stored) + except json.JSONDecodeError: + value = {"status": "unknown", "detail": "Recovery metadata could not be read"} + return value if isinstance(value, dict) else {"status": "unknown"} + + def acknowledge_database_recovery(self) -> None: + self.recovery_metadata = None + self.set_state("database_recovery", {"status": "acknowledged", "acknowledged_at": _now().isoformat()}) + + def set_state(self, key: str, value: object) -> None: + encoded = value if isinstance(value, str) else json.dumps(value, separators=(",", ":")) + with self._connection() as db: + db.execute( + """ + INSERT INTO app_state (key, value, updated_at) VALUES (?, ?, ?) + ON CONFLICT(key) DO UPDATE SET value = excluded.value, updated_at = excluded.updated_at + """, + (key, encoded, _now().isoformat()), + ) + + def get_state(self, key: str) -> str | None: + with self._connection() as db: + row = db.execute("SELECT value FROM app_state WHERE key = ?", (key,)).fetchone() + return row["value"] if row else None + + def update_repository_sync( + self, + repository: Repository, + *, + synced_at: datetime, + error: str | None = None, + ) -> None: + updated = repository.model_copy( + update={"last_synced_at": synced_at, "sync_error": error} + ) + self.upsert_repository(updated) + + def record_sync_result(self, result: RepositorySyncResult) -> None: + self.set_state("last_gitea_sync", result.model_dump_json()) diff --git a/backend/pyproject.toml b/backend/pyproject.toml new file mode 100644 index 0000000..a7a6852 --- /dev/null +++ b/backend/pyproject.toml @@ -0,0 +1,23 @@ +[project] +name = "repopulse-backend" +version = "1.5.0" +description = "RepoPulse repository intelligence API and deterministic analysis engine" +requires-python = ">=3.12" +dependencies = [ + "fastapi>=0.116,<1", + "uvicorn[standard]>=0.35,<1", + "pydantic>=2.11,<3", +] + +[project.optional-dependencies] +dev = [ + "pytest>=8.4,<9", + "ruff>=0.12,<1", + "httpx>=0.28,<1", +] + +[tool.pytest.ini_options] +pythonpath = ["."] + +[tool.ruff] +line-length = 100 diff --git a/backend/tests/test_api.py b/backend/tests/test_api.py new file mode 100644 index 0000000..05912e5 --- /dev/null +++ b/backend/tests/test_api.py @@ -0,0 +1,122 @@ +from pathlib import Path +from threading import BoundedSemaphore + +import pytest +from fastapi.testclient import TestClient + +from app import main as main_module +from app.store import ScanStore + + +def _repository(root: Path) -> Path: + repository = root / "repo" + repository.mkdir() + (repository / "README.md").write_text("# Demo\n", encoding="utf-8") + (repository / "LICENSE").write_text("MIT\n", encoding="utf-8") + (repository / ".gitignore").write_text(".env\n", encoding="utf-8") + (repository / "app.py").write_text("print('hello')\n", encoding="utf-8") + return repository + + +def test_scan_api_respects_root_and_exports_reports(tmp_path: Path) -> None: + repository = _repository(tmp_path) + main_module.SCAN_ROOT = str(tmp_path) + main_module.store = ScanStore(str(tmp_path / "history.db")) + main_module.SCAN_SLOTS = BoundedSemaphore(1) + client = TestClient(main_module.app) + + first_response = client.post("/api/v1/scans", json={"path": "repo"}) + assert first_response.status_code == 201 + first = first_response.json() + assert first["repository_path"] == str(repository.resolve()) + + html = client.get(f"/api/v1/scans/{first['id']}/export?format=html") + assert html.status_code == 200 + assert "RepoPulse report" in html.text + assert "repo" in html.text + + blocked = client.post("/api/v1/scans", json={"path": str(tmp_path.parent)}) + assert blocked.status_code == 422 + + +def test_scan_api_comparison_delta_and_trend(tmp_path: Path) -> None: + repository = _repository(tmp_path) + main_module.SCAN_ROOT = str(tmp_path) + main_module.store = ScanStore(str(tmp_path / "history.db")) + main_module.SCAN_SLOTS = BoundedSemaphore(1) + client = TestClient(main_module.app) + + first = client.post("/api/v1/scans", json={"path": "repo"}).json() + (repository / "tests").mkdir() + (repository / "tests" / "test_app.py").write_text("def test_ok():\n assert True\n", encoding="utf-8") + second = client.post("/api/v1/scans", json={"path": "repo"}).json() + + comparison = client.get(f"/api/v1/scans/{second['id']}/comparison") + assert comparison.status_code == 200 + assert comparison.json()["previous_scan_id"] == first["id"] + + delta = client.get(f"/api/v1/scans/{second['id']}/delta") + assert delta.status_code == 200 + assert delta.json()["previous_health_score"] == first["health_score"] + assert delta.json()["previous_finding_count"] == len(first["findings"]) + + trend = client.get(f"/api/v1/trend?path={repository}") + assert trend.status_code == 200 + assert [item["scan_id"] for item in trend.json()] == [first["id"], second["id"]] + + +def test_scan_api_rejects_when_scan_capacity_is_busy(tmp_path: Path) -> None: + _repository(tmp_path) + main_module.SCAN_ROOT = str(tmp_path) + main_module.store = ScanStore(str(tmp_path / "history.db")) + main_module.SCAN_SLOTS = BoundedSemaphore(1) + client = TestClient(main_module.app) + + assert main_module.SCAN_SLOTS.acquire(blocking=False) + try: + response = client.post("/api/v1/scans", json={"path": "repo"}) + finally: + main_module.SCAN_SLOTS.release() + + assert response.status_code == 429 + assert response.headers["retry-after"] == "2" + + +def test_scan_api_rejects_symlinked_repository_outside_root(tmp_path: Path) -> None: + outside = tmp_path.parent / f"{tmp_path.name}-outside-repository" + outside.mkdir() + (outside / "app.py").write_text("print('outside')\n", encoding="utf-8") + linked = tmp_path / "linked-repository" + try: + linked.symlink_to(outside, target_is_directory=True) + except (NotImplementedError, OSError): + pytest.skip("directory symlinks are unavailable in this environment") + + main_module.SCAN_ROOT = str(tmp_path) + main_module.store = ScanStore(str(tmp_path / "history.db")) + main_module.SCAN_SLOTS = BoundedSemaphore(1) + client = TestClient(main_module.app) + + response = client.post("/api/v1/scans", json={"path": "linked-repository"}) + + assert response.status_code == 422 + + +def test_mutating_api_requires_operator_token_only_when_configured(tmp_path: Path, monkeypatch) -> None: + _repository(tmp_path) + main_module.SCAN_ROOT = str(tmp_path) + main_module.store = ScanStore(str(tmp_path / "history.db")) + main_module.SCAN_SLOTS = BoundedSemaphore(1) + monkeypatch.setenv("REPOPULSE_OPERATOR_TOKEN", "test-operator-token") + client = TestClient(main_module.app) + + assert client.get("/api/v1/meta").status_code == 200 + denied = client.post("/api/v1/scans", json={"path": "repo"}) + assert denied.status_code == 401 + + allowed = client.post( + "/api/v1/scans", + json={"path": "repo"}, + headers={"X-RepoPulse-Token": "test-operator-token"}, + ) + assert allowed.status_code == 201 diff --git a/backend/tests/test_api_v11.py b/backend/tests/test_api_v11.py new file mode 100644 index 0000000..77c2341 --- /dev/null +++ b/backend/tests/test_api_v11.py @@ -0,0 +1,130 @@ +from __future__ import annotations + +import hashlib +import hmac +import json + +from fastapi.testclient import TestClient + +from app import main as main_module +from app.gitea import GiteaClient +from app.models import Repository +from app.store import ScanStore + + +def test_repository_catalog_and_durable_scan_job_contract(tmp_path) -> None: + main_module.store = ScanStore(str(tmp_path / "history.db")) + main_module.job_runner = None + main_module.gitea_client = GiteaClient("http://gitea.local", "test-token", transport=lambda *_: (500, b"")) + repository = Repository( + id="gitea:64", + provider="gitea", + provider_repository_id="64", + owner="Jens", + name="RepoPulse", + full_name="Jens/RepoPulse", + default_branch="main", + latest_revision="0123456789abcdef0123456789abcdef01234567", + ) + main_module.store.upsert_repository(repository) + client = TestClient(main_module.app) + + catalog = client.get("/api/v1/repositories") + assert catalog.status_code == 200 + assert catalog.json()[0]["id"] == "gitea:64" + assert "latest_scan" not in catalog.json()[0] + + queued = client.post("/api/v1/repositories/gitea%3A64/scans", json={"force": False}) + assert queued.status_code == 202 + job = queued.json() + assert job["repository_id"] == "gitea:64" + assert job["status"] == "queued" + + duplicate = client.post("/api/v1/repositories/gitea%3A64/scans", json={"force": False}) + assert duplicate.status_code == 202 + assert duplicate.json()["id"] == job["id"] + assert duplicate.json()["deduplicated"] is True + + detail = client.get("/api/v1/repositories/gitea%3A64") + assert detail.status_code == 200 + assert detail.json()["latest_scan"] is None + assert client.get(f"/api/v1/scan-jobs/{job['id']}").json()["status"] == "queued" + + +def test_signed_gitea_webhook_only_schedules_default_branch_push( + tmp_path, monkeypatch +) -> None: + main_module.store = ScanStore(str(tmp_path / "history.db")) + main_module.job_runner = None + main_module.gitea_client = GiteaClient("http://gitea.local", "test-token", transport=lambda *_: (500, b"")) + repository = Repository( + id="gitea:64", + provider="gitea", + provider_repository_id="64", + owner="Jens", + name="RepoPulse", + full_name="Jens/RepoPulse", + default_branch="main", + latest_revision="0123456789abcdef0123456789abcdef01234567", + ) + main_module.store.upsert_repository(repository) + monkeypatch.setenv("REPOPULSE_GITEA_WEBHOOK_SECRET", "webhook-secret") + payload = { + "repository": {"id": 64}, + "ref": "refs/heads/main", + "after": "abcdef0123456789abcdef0123456789abcdef01", + } + body = json.dumps(payload).encode() + signature = hmac.new(b"webhook-secret", body, hashlib.sha256).hexdigest() + client = TestClient(main_module.app) + + response = client.post( + "/api/v1/webhooks/gitea", + content=body, + headers={"X-Gitea-Signature": signature, "X-Gitea-Event": "push"}, + ) + assert response.status_code == 200 + assert response.json()["job_id"] + assert main_module.store.get_repository("gitea:64").latest_revision == payload["after"] + + wrong_signature = client.post( + "/api/v1/webhooks/gitea", + content=body, + headers={"X-Gitea-Signature": "0" * 64, "X-Gitea-Event": "push"}, + ) + assert wrong_signature.status_code == 401 + + feature_payload = payload | {"ref": "refs/heads/feature"} + feature_body = json.dumps(feature_payload).encode() + feature_signature = hmac.new(b"webhook-secret", feature_body, hashlib.sha256).hexdigest() + feature = client.post( + "/api/v1/webhooks/gitea", + content=feature_body, + headers={"X-Gitea-Signature": feature_signature, "X-Gitea-Event": "push"}, + ) + assert feature.status_code == 200 + assert feature.json()["job_id"] is None + + +def test_meta_exposes_operational_counts_without_connector_token(tmp_path) -> None: + main_module.store = ScanStore(str(tmp_path / "history.db")) + main_module.job_runner = None + main_module.gitea_client = GiteaClient("http://gitea.local", "never-return-this-token") + main_module.store.upsert_repository( + Repository( + id="gitea:64", + provider="gitea", + provider_repository_id="64", + owner="Jens", + name="RepoPulse", + full_name="Jens/RepoPulse", + latest_revision="0123456789abcdef0123456789abcdef01234567", + ) + ) + + response = TestClient(main_module.app).get("/api/v1/meta") + + assert response.status_code == 200 + assert response.json()["repository_count"] == 1 + assert response.json()["repository_states"]["never_scanned"] == 1 + assert "never-return-this-token" not in response.text diff --git a/backend/tests/test_architecture.py b/backend/tests/test_architecture.py new file mode 100644 index 0000000..9caa123 --- /dev/null +++ b/backend/tests/test_architecture.py @@ -0,0 +1,98 @@ +from pathlib import Path + +from app.architecture import build_architecture + + +def test_architecture_resolves_python_and_relative_typescript_imports(tmp_path: Path) -> None: + (tmp_path / "src").mkdir() + (tmp_path / "web").mkdir() + (tmp_path / "src" / "core.py").write_text("VALUE = 1\n", encoding="utf-8") + (tmp_path / "src" / "app.py").write_text("import src.core\n", encoding="utf-8") + (tmp_path / "web" / "util.ts").write_text("export const value = 1\n", encoding="utf-8") + (tmp_path / "web" / "app.ts").write_text("import { value } from './util'\n", encoding="utf-8") + (tmp_path / "web" / "side-effect.ts").write_text("import './util.js'\n", encoding="utf-8") + + source_texts = { + "src/core.py": "VALUE = 1\n", + "src/app.py": "import src.core\n", + "web/util.ts": "export const value = 1\n", + "web/app.ts": "import { value } from './util'\n", + "web/side-effect.ts": "import './util.js'\n", + } + languages = { + "src/core.py": "Python", + "src/app.py": "Python", + "web/util.ts": "TypeScript", + "web/app.ts": "TypeScript", + "web/side-effect.ts": "TypeScript", + } + loc = {path: 1 for path in source_texts} + + graph, hotspots = build_architecture( + tmp_path, + source_texts, + languages, + loc, + {path: 0 for path in source_texts}, + {"src/core.py": 100, "src/app.py": 200}, + ) + + pairs = {(edge.source, edge.target) for edge in graph.edges} + assert ("src/app.py", "src/core.py") in pairs + assert ("web/app.ts", "web/util.ts") in pairs + assert ("web/side-effect.ts", "web/util.ts") in pairs + assert {node.id for node in graph.nodes} == set(source_texts) + assert hotspots[0].path in {"src/app.py", "src/core.py"} + + +def test_architecture_edge_bound_is_explicit(tmp_path: Path) -> None: + source_texts = { + "src/a.py": "import src.b\n", + "src/b.py": "import src.c\n", + "src/c.py": "VALUE = 1\n", + } + languages = {path: "Python" for path in source_texts} + + graph, _ = build_architecture( + tmp_path, + source_texts, + languages, + {path: 1 for path in source_texts}, + {path: 0 for path in source_texts}, + {}, + max_edges=1, + ) + + assert len(graph.edges) == 1 + assert graph.truncated is True + + +def test_architecture_resolves_jsconfig_aliases_and_local_workspace_packages(tmp_path: Path) -> None: + (tmp_path / "src" / "components").mkdir(parents=True) + (tmp_path / "packages" / "shared" / "src").mkdir(parents=True) + (tmp_path / "jsconfig.json").write_text( + '{"compilerOptions":{"baseUrl":".","paths":{"@/*":["src/*"]}}}', + encoding="utf-8", + ) + (tmp_path / "package.json").write_text('{"name":"workspace-root"}', encoding="utf-8") + (tmp_path / "packages" / "shared" / "package.json").write_text( + '{"name":"@workspace/shared"}', encoding="utf-8" + ) + + source_texts = { + "src/app.ts": "import { Button } from '@/components/Button'\nimport { shared } from '@workspace/shared'\n", + "src/components/Button.ts": "export const Button = () => null\n", + "packages/shared/src/index.ts": "export const shared = true\n", + } + graph, _ = build_architecture( + tmp_path, + source_texts, + {path: "TypeScript" for path in source_texts}, + {path: 1 for path in source_texts}, + {path: 0 for path in source_texts}, + {}, + ) + + pairs = {(edge.source, edge.target) for edge in graph.edges} + assert ("src/app.ts", "src/components/Button.ts") in pairs + assert ("src/app.ts", "packages/shared/src/index.ts") in pairs diff --git a/backend/tests/test_gitea.py b/backend/tests/test_gitea.py new file mode 100644 index 0000000..b7f7585 --- /dev/null +++ b/backend/tests/test_gitea.py @@ -0,0 +1,203 @@ +from __future__ import annotations + +import json +from pathlib import Path + +import pytest + +from app.gitea import GiteaClient, GiteaError +from app.store import ScanStore + + +def _transport(url: str, headers: dict[str, str]) -> tuple[int, bytes]: + assert headers["Authorization"] == "token test-token" + if "/user/repos" in url: + return 200, json.dumps( + [ + { + "id": 64, + "name": "RepoPulse", + "full_name": "Jens/RepoPulse", + "owner": {"login": "Jens"}, + "description": "Repository intelligence", + "default_branch": "main", + "clone_url": "https://evil.example/Jens/RepoPulse.git", + "private": True, + } + ] + ).encode() + if "/branches/main" in url: + return 200, b'{"commit":{"id":"0123456789abcdef0123456789abcdef01234567"}}' + raise AssertionError(url) + + +def test_gitea_discovery_is_bounded_and_preserves_stable_identity() -> None: + client = GiteaClient( + "http://gitea.local", + "test-token", + transport=_transport, + ) + + discovered = client.discover() + + assert len(discovered) == 1 + repository, revision = discovered[0] + assert repository.id == "gitea:64" + assert repository.provider_repository_id == "64" + assert repository.full_name == "Jens/RepoPulse" + assert repository.clone_url == "http://gitea.local/Jens/RepoPulse.git" + assert repository.latest_revision == revision + + +def test_gitea_auth_errors_are_sanitized() -> None: + def rejected(_url: str, _headers: dict[str, str]) -> tuple[int, bytes]: + return 401, b"secret-bearing upstream response" + + client = GiteaClient("http://gitea.local", "test-token", transport=rejected) + + try: + client.list_repositories() + except GiteaError as exc: + assert exc.code == "authentication" + assert "test-token" not in str(exc) + assert "secret-bearing" not in str(exc) + else: + raise AssertionError("authentication error was not raised") + + +@pytest.mark.parametrize("status_code, error_code", [(401, "authentication"), (403, "authentication"), (404, "not_found"), (429, "rate_limited"), (500, "upstream")]) +def test_gitea_http_statuses_are_classified_without_upstream_body(status_code: int, error_code: str) -> None: + client = GiteaClient( + "http://gitea.local", + "test-token", + transport=lambda *_: (status_code, b"token=test-token upstream body"), + ) + + with pytest.raises(GiteaError) as raised: + client.list_repositories() + + assert raised.value.code == error_code + assert "test-token" not in str(raised.value) + assert "upstream body" not in str(raised.value) + + +def test_gitea_discovery_paginates_until_a_short_page() -> None: + calls: list[str] = [] + + def paginated(url: str, headers: dict[str, str]) -> tuple[int, bytes]: + calls.append(url) + assert headers["Authorization"] == "token test-token" + if "/user/repos" in url: + if "page=1" in url: + payload = [{"id": 64, "owner": {"login": "Jens"}, "name": "One", "default_branch": "main"}] + elif "page=2" in url: + payload = [{"id": 65, "owner": {"login": "Jens"}, "name": "Two", "default_branch": "trunk"}] + else: + payload = [] + return 200, json.dumps(payload).encode() + if "/branches/main" in url: + return 200, b'{"commit":{"id":"0123456789abcdef0123456789abcdef01234567"}}' + if "/branches/trunk" in url: + return 200, b'{"commit":{"sha":"abcdef0123456789abcdef0123456789abcdef01"}}' + raise AssertionError(url) + + client = GiteaClient("http://gitea.local", "test-token", page_size=1, max_pages=3, transport=paginated) + + discovered = client.discover() + + assert [repository.id for repository, _ in discovered] == ["gitea:64", "gitea:65"] + assert len([call for call in calls if "/user/repos" in call]) == 3 + + +@pytest.mark.parametrize( + "transport, error_code", + [ + (lambda *_: (200, b"not-json"), "invalid_response"), + (lambda *_: (_ for _ in ()).throw(TimeoutError()), "unreachable"), + ], +) +def test_gitea_malformed_and_timeout_responses_are_safe(transport, error_code: str) -> None: + client = GiteaClient("http://gitea.local", "test-token", transport=transport) + + with pytest.raises(GiteaError) as raised: + client.list_repositories() + + assert raised.value.code == error_code + + +def test_gitea_sync_creates_catalog_without_full_reports(tmp_path: Path) -> None: + store = ScanStore(str(tmp_path / "history.db")) + client = GiteaClient("http://gitea.local", "test-token", transport=_transport) + + result = client.sync(store) + + assert result.discovered == 1 + assert result.created == 1 + repository = store.get_repository("gitea:64") + assert repository is not None + assert repository.latest_revision == "0123456789abcdef0123456789abcdef01234567" + assert repository.description == "Repository intelligence" + assert store.repository_scans(repository.id) == [] + + +def test_gitea_outage_preserves_catalog_and_marks_sync_error(tmp_path: Path) -> None: + store = ScanStore(str(tmp_path / "history.db")) + healthy = GiteaClient("http://gitea.local", "test-token", transport=_transport) + healthy.sync(store) + + unavailable = GiteaClient( + "http://gitea.local", + "test-token", + transport=lambda *_: (503, b"upstream details must not escape"), + ) + result = unavailable.sync(store) + + assert result.errors == ["upstream: Gitea returned a server error"] + repository = store.get_repository("gitea:64") + assert repository is not None + assert repository.available is True + assert repository.latest_revision == "0123456789abcdef0123456789abcdef01234567" + assert repository.sync_error == "upstream: Gitea returned a server error" + + +def test_complete_sync_marks_missing_repository_unavailable_without_deleting_history(tmp_path: Path) -> None: + store = ScanStore(str(tmp_path / "history.db")) + GiteaClient("http://gitea.local", "test-token", transport=_transport).sync(store) + missing = GiteaClient("http://gitea.local", "test-token", transport=lambda *_: (200, b"[]")) + + result = missing.sync(store) + + assert result.unavailable == 1 + repository = store.get_repository("gitea:64") + assert repository is not None + assert repository.available is False + assert store.repository_scans(repository.id) == [] + + +def test_branch_resolution_failure_is_partial_and_preserves_other_catalog_entries(tmp_path: Path) -> None: + def partial_transport(url: str, _headers: dict[str, str]) -> tuple[int, bytes]: + if "/user/repos" in url: + return 200, json.dumps( + [ + {"id": 1, "owner": {"login": "Jens"}, "name": "Healthy", "default_branch": "main"}, + {"id": 2, "owner": {"login": "Jens"}, "name": "Broken", "default_branch": "main"}, + ] + ).encode() + if "/repos/Jens/Healthy/branches/main" in url: + return 200, b'{"commit":{"id":"0123456789abcdef0123456789abcdef01234567"}}' + if "/repos/Jens/Broken/branches/main" in url: + return 500, b"upstream details must remain private" + raise AssertionError(url) + + store = ScanStore(str(tmp_path / "history.db")) + result = GiteaClient("http://gitea.local", "test-token", transport=partial_transport).sync(store) + + assert result.discovered == 1 + assert result.partial is True + assert result.branch_failures == 1 + assert result.listing_complete is True + assert "Jens/Broken: upstream: Gitea returned a server error" in result.errors + assert store.get_repository("gitea:1").latest_revision + broken = store.get_repository("gitea:2") + assert broken is not None and broken.available is True + assert broken.sync_error == "Jens/Broken: upstream: Gitea returned a server error" diff --git a/backend/tests/test_jobs.py b/backend/tests/test_jobs.py new file mode 100644 index 0000000..d0d0eed --- /dev/null +++ b/backend/tests/test_jobs.py @@ -0,0 +1,232 @@ +from __future__ import annotations + +import subprocess +from concurrent.futures import ThreadPoolExecutor +from datetime import UTC, datetime, timedelta +from pathlib import Path + +import pytest + +from app.acquisition import AcquisitionError, GitAcquirer +from app.gitea import GiteaClient +from app.jobs import ScanJobRunner +from app.models import Repository, ScanJobStatus, ScanSource, ScanTrigger, SourceOrigin +from app.scanner import scan_repository +from app.store import ScanStore + + +def _git_repository(root: Path) -> tuple[Path, str]: + root.mkdir() + (root / "README.md").write_text("# Demo\n", encoding="utf-8") + (root / "app.py").write_text("print('hello')\n", encoding="utf-8") + subprocess.run(["git", "init", "--quiet", str(root)], check=True) + subprocess.run(["git", "-C", str(root), "config", "user.email", "test@example.com"], check=True) + subprocess.run(["git", "-C", str(root), "config", "user.name", "RepoPulse Test"], check=True) + subprocess.run(["git", "-C", str(root), "add", "."], check=True) + subprocess.run(["git", "-C", str(root), "commit", "--quiet", "-m", "initial"], check=True) + revision = subprocess.run( + ["git", "-C", str(root), "rev-parse", "HEAD"], + check=True, + capture_output=True, + text=True, + ).stdout.strip() + return root, revision + + +def _catalog_repository(source: Path, revision: str) -> Repository: + return Repository( + id="gitea:64", + provider="gitea", + provider_repository_id="64", + owner="Jens", + name="Demo", + full_name="Jens/Demo", + clone_url=source.as_uri(), + default_branch="master", + latest_revision=revision, + ) + + +def test_acquirer_scans_detached_exact_revision_and_cleans_up(tmp_path: Path) -> None: + source, revision = _git_repository(tmp_path / "source") + repository = _catalog_repository(source, revision) + acquirer = GitAcquirer(tmp_path / "cache", timeout=30) + + acquired = acquirer.acquire(repository, "job-1", revision) + + checked_out = subprocess.run( + ["git", "-C", str(acquired.path), "rev-parse", "HEAD"], + check=True, + capture_output=True, + text=True, + ).stdout.strip() + assert checked_out == revision + assert (acquired.path / "app.py").read_text(encoding="utf-8") == "print('hello')\n" + acquirer.cleanup(acquired, repository) + assert not acquired.path.exists() + + +def test_acquirer_recovers_a_corrupt_mirror_and_rejects_missing_sha(tmp_path: Path) -> None: + source, revision = _git_repository(tmp_path / "source") + repository = _catalog_repository(source, revision) + acquirer = GitAcquirer(tmp_path / "cache", timeout=30) + mirror = acquirer._mirror_path(repository) + mirror.parent.mkdir(parents=True, exist_ok=True) + mirror.write_text("corrupt mirror", encoding="utf-8") + + with pytest.raises(AcquisitionError, match="Requested commit was not found"): + acquirer.acquire(repository, "job-missing", "abcdef0123456789abcdef0123456789abcdef01") + + acquired = acquirer.acquire(repository, "job-recovered", revision) + assert acquired.actual_revision == revision + acquirer.cleanup(acquired, repository) + + +def test_durable_runner_completes_and_deduplicates_revision(tmp_path: Path) -> None: + source, revision = _git_repository(tmp_path / "source") + store = ScanStore(str(tmp_path / "history.db")) + repository = _catalog_repository(source, revision) + store.upsert_repository(repository) + runner = ScanJobRunner( + store, + gitea=GiteaClient("http://gitea.local", "test-token", transport=lambda *_: (500, b"")), + acquirer=GitAcquirer(tmp_path / "cache", timeout=30), + ) + + first = runner.enqueue(repository) + completed = runner.process_one() + reused = runner.enqueue(repository) + + assert completed is not None + assert completed.status == ScanJobStatus.COMPLETED + assert completed.scan_id is not None + assert reused.id == first.id + assert reused.deduplicated is True + report = store.get(completed.scan_id) + assert report is not None + assert report.source.actual_revision == revision + assert report.source.trigger == ScanTrigger.MANUAL + assert completed.duration_ms is not None + + +def test_expired_job_lease_is_recovered_for_another_claim(tmp_path: Path) -> None: + store = ScanStore(str(tmp_path / "history.db")) + repository = _catalog_repository(tmp_path, "0123456789abcdef0123456789abcdef01234567") + store.upsert_repository(repository) + queued = store.enqueue_job(repository.id, repository.latest_revision, ScanTrigger.SCHEDULED) + store.update_job( + queued.id, + status=ScanJobStatus.SCANNING, + phase="scanning", + lease_until=datetime.now(UTC) - timedelta(seconds=5), + ) + + claimed = store.claim_next_job() + + assert claimed is not None + assert claimed.id == queued.id + assert claimed.status == ScanJobStatus.ACQUIRING_SOURCE + assert claimed.attempt == 1 + assert claimed.message == "Acquiring exact repository revision" + + +def test_active_job_lease_renews_but_terminal_jobs_are_not_resurrected(tmp_path: Path) -> None: + store = ScanStore(str(tmp_path / "history.db")) + repository = _catalog_repository(tmp_path, "0123456789abcdef0123456789abcdef01234567") + store.upsert_repository(repository) + queued = store.enqueue_job(repository.id, repository.latest_revision, ScanTrigger.SCHEDULED) + claimed = store.claim_next_job() + + assert claimed is not None + with store._connection() as db: + initial_lease = db.execute("SELECT lease_until FROM scan_jobs WHERE id = ?", (queued.id,)).fetchone()[0] + assert initial_lease is not None + renewed = store.renew_job_lease(queued.id) + assert renewed is not None + with store._connection() as db: + renewed_lease = db.execute("SELECT lease_until FROM scan_jobs WHERE id = ?", (queued.id,)).fetchone()[0] + assert renewed_lease is not None and renewed_lease > initial_lease + + completed = store.update_job(queued.id, status=ScanJobStatus.COMPLETED, phase="completed", progress=100) + assert completed is not None + after_completion = store.renew_job_lease(queued.id) + assert after_completion is not None + with store._connection() as db: + terminal_lease = db.execute("SELECT lease_until FROM scan_jobs WHERE id = ?", (queued.id,)).fetchone()[0] + assert terminal_lease is None + + +def test_atomic_claim_allows_only_one_worker_to_own_a_queued_job(tmp_path: Path) -> None: + store = ScanStore(str(tmp_path / "history.db")) + repository = _catalog_repository(tmp_path, "0123456789abcdef0123456789abcdef01234567") + store.upsert_repository(repository) + store.enqueue_job(repository.id, repository.latest_revision, ScanTrigger.SCHEDULED) + + with ThreadPoolExecutor(max_workers=2) as workers: + claims = list(workers.map(lambda _unused: store.claim_next_job(), range(2))) + + successful = [claim for claim in claims if claim is not None] + assert len(successful) == 1 + assert successful[0].status == ScanJobStatus.ACQUIRING_SOURCE + + +def test_scheduler_queues_unscanned_and_changed_repositories_only(tmp_path: Path) -> None: + source, revision = _git_repository(tmp_path / "source") + store = ScanStore(str(tmp_path / "history.db")) + repository = _catalog_repository(source, revision) + store.upsert_repository(repository) + runner = ScanJobRunner(store, gitea=GiteaClient()) + + runner._schedule_changed_repositories() + first = store.claim_next_job() + assert first is not None + assert first.requested_revision == revision + store.update_job(first.id, status=ScanJobStatus.SUPERSEDED) + + report = scan_repository( + str(source), + source=ScanSource( + origin=SourceOrigin.GITEA, + provider="gitea", + repository_id=repository.id, + repository_full_name=repository.full_name, + branch=repository.default_branch, + requested_revision=revision, + actual_revision=revision, + trigger=ScanTrigger.MANUAL, + ), + ) + store.save(report) + runner._schedule_changed_repositories() + assert store.queue_stats()["queued"] == 0 + + changed = "abcdef0123456789abcdef0123456789abcdef01" + store.upsert_repository(repository.model_copy(update={"latest_revision": changed})) + runner._schedule_changed_repositories() + assert store.queue_stats()["queued"] == 1 + + disabled = repository.model_copy( + update={ + "id": "gitea:65", + "provider_repository_id": "65", + "latest_revision": "1234567890abcdef1234567890abcdef12345678", + "policy": repository.policy.model_copy(update={"auto_scan": False}), + } + ) + store.upsert_repository(disabled) + runner._schedule_changed_repositories() + assert store.queue_stats()["queued"] == 1 + + +def test_acquisition_rejects_token_bearing_clone_outside_gitea_origin(tmp_path: Path) -> None: + repository = _catalog_repository(tmp_path, "0123456789abcdef0123456789abcdef01234567").model_copy( + update={"clone_url": "https://evil.example/Jens/Demo.git"} + ) + acquirer = GitAcquirer( + tmp_path / "cache", + token="test-token", + allowed_clone_origin="https://gitea.local", + ) + + with pytest.raises(AcquisitionError, match="outside the configured Gitea origin"): + acquirer.acquire(repository, "job-1", repository.latest_revision) diff --git a/backend/tests/test_maintenance.py b/backend/tests/test_maintenance.py new file mode 100644 index 0000000..7e08dab --- /dev/null +++ b/backend/tests/test_maintenance.py @@ -0,0 +1,175 @@ +from __future__ import annotations + +from pathlib import Path + +import pytest +from fastapi.testclient import TestClient + +from app import main as main_module +from app.gitea import GiteaClient +from app.jobs import ScanJobRunner +from app.models import Repository, ScanJobStatus, ScanTrigger +from app.store import MaintenanceModeError, ScanStore + + +def _gitea_repository() -> Repository: + return Repository( + id="gitea:64", + provider="gitea", + provider_repository_id="64", + owner="Jens", + name="RepoPulse", + full_name="Jens/RepoPulse", + default_branch="main", + latest_revision="0123456789abcdef0123456789abcdef01234567", + ) + + +def test_maintenance_mode_is_durable_authenticated_and_exposes_drain_state(tmp_path: Path, monkeypatch) -> None: + database = tmp_path / "history.db" + main_module.store = ScanStore(str(database)) + main_module.job_runner = None + main_module.store.upsert_repository(_gitea_repository()) + queued = main_module.store.enqueue_job( + "gitea:64", + _gitea_repository().latest_revision, + ScanTrigger.MANUAL, + ) + monkeypatch.delenv("REPOPULSE_OPERATOR_TOKEN", raising=False) + monkeypatch.delenv("REPOPULSE_MAINTENANCE_TOKEN", raising=False) + client = TestClient(main_module.app) + assert client.post("/api/v1/operator/maintenance/enter").status_code == 503 + monkeypatch.setenv("REPOPULSE_MAINTENANCE_TOKEN", "operator-secret") + assert client.get("/api/v1/meta").json()["mutation_authentication"] == "perimeter_required" + + assert client.post("/api/v1/operator/maintenance/enter").status_code == 401 + assert client.get("/api/v1/operator/maintenance").status_code == 401 + headers = {"X-RepoPulse-Token": "operator-secret"} + entered = client.post("/api/v1/operator/maintenance/enter", headers=headers) + + assert entered.status_code == 200 + assert entered.json()["enabled"] is True + assert entered.json()["queue_depth"] == 1 + assert entered.json()["active_jobs"] == 0 + assert entered.json()["active_drained"] is True + assert entered.json()["drained"] is False + changed_at = entered.json()["changed_at"] + assert client.post("/api/v1/operator/maintenance/enter", headers=headers).status_code == 423 + assert main_module.store.maintenance_status()["changed_at"] == changed_at + assert client.get("/api/v1/operator/maintenance", headers=headers).json()["enabled"] is True + assert client.get("/api/v1/meta").json()["maintenance"]["enabled"] is True + + restarted = ScanStore(str(database)) + assert restarted.maintenance_status()["enabled"] is True + assert restarted.get_job(queued.id).status == ScanJobStatus.QUEUED + + assert client.post("/api/v1/operator/maintenance/exit").status_code == 401 + exited = client.post("/api/v1/operator/maintenance/exit", headers=headers) + assert exited.status_code == 200 + assert exited.json()["enabled"] is False + assert ScanStore(str(database)).maintenance_status()["enabled"] is False + + +def test_paused_mode_rejects_api_mutations_but_keeps_read_endpoints_available(tmp_path: Path, monkeypatch) -> None: + main_module.store = ScanStore(str(tmp_path / "history.db")) + main_module.job_runner = None + repository = _gitea_repository() + main_module.store.upsert_repository(repository) + queued = main_module.store.enqueue_job( + repository.id, + repository.latest_revision, + ScanTrigger.MANUAL, + ) + monkeypatch.delenv("REPOPULSE_OPERATOR_TOKEN", raising=False) + monkeypatch.setenv("REPOPULSE_MAINTENANCE_TOKEN", "operator-secret") + client = TestClient(main_module.app) + headers = {"X-RepoPulse-Token": "operator-secret"} + assert client.post("/api/v1/operator/maintenance/enter", headers=headers).status_code == 200 + + mutation_requests = [ + ("/api/v1/scans", {}), + ("/api/v1/repositories/sync", {}), + ("/api/v1/repositories/gitea%3A64/scans", {"json": {"force": True}}), + ("/api/v1/webhooks/gitea", {"content": b"not validated while paused"}), + ("/api/v1/operator/database-recovery/acknowledge", {}), + ] + for path, kwargs in mutation_requests: + response = client.post(path, **kwargs) + assert response.status_code == 423, (path, response.status_code, response.text) + + assert client.get("/api/v1/repositories").status_code == 200 + assert client.get("/api/v1/scan-jobs/" + queued.id).status_code == 200 + assert main_module.store.queue_stats()["queued"] == 1 + assert main_module.store.get_job(queued.id).status == ScanJobStatus.QUEUED + + +def test_paused_worker_makes_no_scheduler_writes_or_job_claims(tmp_path: Path) -> None: + store = ScanStore(str(tmp_path / "history.db")) + repository = _gitea_repository() + store.upsert_repository(repository) + queued = store.enqueue_job(repository.id, repository.latest_revision, ScanTrigger.SCHEDULED) + store.set_state("worker_heartbeat", "before-maintenance") + store.set_state("last_gitea_sync", "prior-sync") + store.set_maintenance_mode(True) + + class CountingGitea: + configured = True + + def __init__(self) -> None: + self.sync_calls = 0 + + def sync(self, _store): + self.sync_calls += 1 + raise AssertionError("scheduler must not sync in maintenance mode") + + gitea = CountingGitea() + runner = ScanJobRunner(store, gitea=gitea) # type: ignore[arg-type] + + assert runner._run_iteration() is None + assert gitea.sync_calls == 0 + assert store.get_state("worker_heartbeat") == "before-maintenance" + assert store.get_state("last_gitea_sync") == "prior-sync" + assert store.claim_next_job() is None + assert store.queue_stats()["queued"] == 1 + assert store.get_job(queued.id).status == ScanJobStatus.QUEUED + + +def test_already_claimed_job_can_finish_during_maintenance(tmp_path: Path) -> None: + source = tmp_path / "source" + source.mkdir() + (source / "README.md").write_text("# Existing work\n", encoding="utf-8") + (source / "app.py").write_text("print('ok')\n", encoding="utf-8") + store = ScanStore(str(tmp_path / "history.db")) + repository = Repository( + id="local:existing-job", + provider="local", + provider_repository_id="existing-job", + owner="local", + name="Existing job", + full_name="local/Existing job", + default_branch="main", + ) + store.upsert_repository(repository, source_path=str(source)) + store.enqueue_job(repository.id, None, ScanTrigger.MANUAL) + claimed = store.claim_next_job() + assert claimed is not None + runner = ScanJobRunner(store, gitea=GiteaClient()) + + store.set_maintenance_mode(True) + assert store.maintenance_status()["enabled"] is True + assert store.queue_stats()["active"] == 1 + runner._process(claimed) + + assert store.get_job(claimed.id).status == ScanJobStatus.COMPLETED + assert store.queue_stats()["active"] == 0 + assert store.maintenance_status()["enabled"] is True + + +def test_invalid_persisted_maintenance_state_fails_closed(tmp_path: Path) -> None: + store = ScanStore(str(tmp_path / "history.db")) + store.set_state("maintenance_mode", "not-json") + + assert store.maintenance_status()["enabled"] is True + with pytest.raises(MaintenanceModeError): + store.enqueue_job("missing", "revision", ScanTrigger.MANUAL) + diff --git a/backend/tests/test_migrations.py b/backend/tests/test_migrations.py new file mode 100644 index 0000000..6ce41f1 --- /dev/null +++ b/backend/tests/test_migrations.py @@ -0,0 +1,86 @@ +from __future__ import annotations + +import sqlite3 +from pathlib import Path + +from app.models import ( + DependencySignals, + RepositoryMetrics, + ScanReport, +) +from app.models import ( + TestSignals as SignalsModel, +) +from app.scanner import scan_repository +from app.store import SCHEMA_VERSION, ScanStore + + +def test_v1_scan_schema_is_migrated_and_legacy_history_is_cataloged(tmp_path: Path) -> None: + database = tmp_path / "history.db" + report = ScanReport( + id="legacy-scan", + repository_path=str((tmp_path / "repo").resolve()), + repository_name="repo", + scanned_at="2026-09-12T00:00:00+00:00", + duration_ms=1, + metrics=RepositoryMetrics(), + languages={}, + category_scores={}, + health_score=100, + release_readiness="READY", + findings=[], + tests=SignalsModel(), + dependencies=DependencySignals(), + ) + connection = sqlite3.connect(database) + connection.execute( + """ + CREATE TABLE scans ( + id TEXT PRIMARY KEY, + repository_path TEXT NOT NULL, + repository_name TEXT NOT NULL, + scanned_at TEXT NOT NULL, + health_score INTEGER NOT NULL, + report_json TEXT NOT NULL + ) + """ + ) + connection.execute( + "INSERT INTO scans VALUES (?, ?, ?, ?, ?, ?)", + (report.id, report.repository_path, report.repository_name, report.scanned_at.isoformat(), 100, report.model_dump_json()), + ) + connection.commit() + connection.close() + + store = ScanStore(str(database)) + + assert store.get_state("missing") is None + assert store.repository_count() == 1 + migrated = store.get("legacy-scan") + assert migrated is not None + assert migrated.source.provider == "local" + assert migrated.source.repository_id is not None + assert store.list_repositories()[0].last_scan_id == "legacy-scan" + connection = sqlite3.connect(database) + assert connection.execute("PRAGMA user_version").fetchone()[0] == SCHEMA_VERSION + connection.close() + + +def test_schema_upgrade_creates_a_timestamped_pre_migration_backup(tmp_path: Path) -> None: + database = tmp_path / "history.db" + repository = tmp_path / "repo" + repository.mkdir() + (repository / "README.md").write_text("# Demo\n", encoding="utf-8") + (repository / ".gitignore").write_text("*.db\n", encoding="utf-8") + + original = ScanStore(str(database)) + saved = original.save(scan_repository(str(repository))) + connection = sqlite3.connect(database) + connection.execute("PRAGMA user_version = 3") + connection.commit() + connection.close() + + migrated = ScanStore(str(database)) + + assert list(tmp_path.glob("history.db.pre-v3-*.bak")) + assert migrated.get(saved.id) is not None diff --git a/backend/tests/test_reporting.py b/backend/tests/test_reporting.py new file mode 100644 index 0000000..ee1923a --- /dev/null +++ b/backend/tests/test_reporting.py @@ -0,0 +1,12 @@ +from app.reporting import content_disposition, safe_report_filename + + +def test_report_filenames_are_safe_and_support_unicode() -> None: + filename = safe_report_filename('repo/evil\r\n"<é>', "html") + disposition = content_disposition(filename) + + assert filename.startswith("repopulse-repo_evil___") + assert "\r" not in disposition + assert "\n" not in disposition + assert 'filename="' in disposition + assert "filename*=UTF-8''" in disposition diff --git a/backend/tests/test_scanner.py b/backend/tests/test_scanner.py new file mode 100644 index 0000000..d720143 --- /dev/null +++ b/backend/tests/test_scanner.py @@ -0,0 +1,223 @@ +import json +import subprocess +from pathlib import Path + +import pytest + +from app.models import Severity +from app.scanner import scan_repository + + +def _write_good_repo(root: Path) -> None: + (root / "README.md").write_text("# Demo\n", encoding="utf-8") + (root / "LICENSE").write_text("MIT\n", encoding="utf-8") + (root / ".gitignore").write_text(".env\n", encoding="utf-8") + (root / "src").mkdir() + (root / "tests").mkdir() + (root / ".gitea" / "workflows").mkdir(parents=True) + (root / ".gitea" / "workflows" / "check.yml").write_text("name: check\n", encoding="utf-8") + (root / "src" / "core.py").write_text("def answer():\n return 42\n", encoding="utf-8") + (root / "src" / "app.py").write_text("import src.core\n\ndef run():\n return src.core.answer()\n", encoding="utf-8") + (root / "tests" / "test_app.py").write_text("def test_app():\n assert True\n", encoding="utf-8") + + +def _realistic_fixture_secret() -> str: + parts = ["production", "secret", "value", "123456"] + return "-".join(parts) + + +def test_scan_collects_v1_signals_and_architecture(tmp_path: Path) -> None: + _write_good_repo(tmp_path) + + report = scan_repository(str(tmp_path)) + + assert report.repository_name == tmp_path.name + assert report.metrics.source_files == 3 + assert report.metrics.test_files == 1 + assert report.languages["Python"] > 0 + assert report.tests.ci_workflows == [".gitea/workflows/check.yml"] + assert report.release_gate is not None + assert report.release_gate.status in {"READY", "READY WITH WARNINGS"} + assert any(edge.source == "src/app.py" and edge.target == "src/core.py" for edge in report.architecture.edges) + assert any(item.path == "src/app.py" for item in report.hotspots) + assert 0 <= report.health_score <= 100 + + +def test_scan_collects_debt_and_dependency_signals(tmp_path: Path) -> None: + _write_good_repo(tmp_path) + (tmp_path / "package.json").write_text( + '{"dependencies":{"react":"latest"},"devDependencies":{"vitest":"^3.0.0"}}', + encoding="utf-8", + ) + (tmp_path / "src" / "app.py").write_text( + "# TODO improve this\n# FIXME remove workaround\nprint('hello')\n", + encoding="utf-8", + ) + + report = scan_repository(str(tmp_path)) + + assert report.metrics.todo == 1 + assert report.metrics.fixme == 1 + assert report.dependencies.declared_dependencies == 2 + assert report.dependencies.unbounded_dependencies == 1 + assert any(item.code == "dependency.unbounded" for item in report.findings) + + +def test_potential_secret_is_redacted_and_blocks_release(tmp_path: Path) -> None: + (tmp_path / "README.md").write_text("# Demo\n", encoding="utf-8") + (tmp_path / ".gitignore").write_text("*.db\n", encoding="utf-8") + secret_name = "API_" + "KEY" + (tmp_path / "app.py").write_text( + f"{secret_name} = 'super-secret-value-123456'\n", + encoding="utf-8", + ) + + report = scan_repository(str(tmp_path)) + secret_findings = [item for item in report.findings if item.code == "security.secret-assignment"] + + assert report.release_readiness == "BLOCKED" + assert report.release_gate is not None + assert report.release_gate.status == "BLOCKED" + assert secret_findings + assert secret_findings[0].severity == Severity.BLOCKER + assert "super-secret-example-value" not in secret_findings[0].message + + +def test_secret_detection_scans_real_literals_in_tests_but_ignores_obvious_templates(tmp_path: Path) -> None: + _write_good_repo(tmp_path) + realistic_secret = _realistic_fixture_secret() + token_key = "to" + "ken" + (tmp_path / "src" / "settings.py").write_text( + "secret = os.getenv('APP_SECRET')\n" + f"api_key = '{realistic_secret}'\n", + encoding="utf-8", + ) + (tmp_path / "tests" / "test_transport.py").write_text( + token_key + ' = "' + realistic_secret + '"\nresponse = b"token=test-token upstream body"\n', + encoding="utf-8", + ) + (tmp_path / "README.md").write_text("# Demo\n\n`token=example-documentation-value`\n", encoding="utf-8") + (tmp_path / ".env.development.example").write_text("APP_SECRET=example-development-secret\n", encoding="utf-8") + + report = scan_repository(str(tmp_path)) + secret_findings = [item for item in report.findings if item.code == "security.secret-assignment"] + + assert len(secret_findings) == 2 + assert {item.path for item in secret_findings} == {"src/settings.py", "tests/test_transport.py"} + assert all(item.guidance and item.guidance.remediation_class == "security remediation" for item in secret_findings) + assert secret_findings[0].line == 2 + assert not any(item.code == "security.env-committed" for item in report.findings) + + +def test_scan_budget_reports_coverage_without_turning_truncation_into_a_blocker(tmp_path: Path) -> None: + _write_good_repo(tmp_path) + for index in range(4): + (tmp_path / f"module_{index}.py").write_text("print('ok')\n", encoding="utf-8") + + from app.models import ScanLimits + + report = scan_repository(str(tmp_path), limits=ScanLimits(max_files=2, max_text_bytes_per_file=2_000_000, max_findings=20, max_secret_findings=5)) + + assert report.coverage is not None and report.coverage.truncated is True + assert report.coverage.skipped_files_by_budget > 0 + assert any(check.key == "analysis_coverage" and check.state.value == "warn" for check in report.release_gate.checks) + assert any(item.code == "analysis.findings-truncated" for item in report.findings) is False + + +def test_configuration_literal_secret_remains_a_blocker(tmp_path: Path) -> None: + _write_good_repo(tmp_path) + realistic_secret = _realistic_fixture_secret() + token_key = "to" + "ken" + (tmp_path / "settings.json").write_text( + json.dumps({token_key: realistic_secret}) + "\n", + encoding="utf-8", + ) + + report = scan_repository(str(tmp_path)) + secret_findings = [item for item in report.findings if item.code == "security.secret-assignment"] + + assert report.release_readiness == "BLOCKED" + assert [(item.path, item.line) for item in secret_findings] == [("settings.json", 1)] + + +def test_member_literal_secret_remains_a_blocker(tmp_path: Path) -> None: + _write_good_repo(tmp_path) + (tmp_path / "src" / "client.py").write_text( + "class Client:\n def __init__(self):\n self.api_key = 'production-secret-value-123456'\n", + encoding="utf-8", + ) + + report = scan_repository(str(tmp_path)) + secret_findings = [item for item in report.findings if item.code == "security.secret-assignment"] + + assert report.release_readiness == "BLOCKED" + assert [(item.path, item.line) for item in secret_findings] == [("src/client.py", 3)] + + +def test_documentation_only_repository_does_not_require_test_files(tmp_path: Path) -> None: + (tmp_path / "README.md").write_text("# Catalog entry\n", encoding="utf-8") + (tmp_path / ".gitignore").write_text(".DS_Store\n", encoding="utf-8") + + report = scan_repository(str(tmp_path)) + + assert report.metrics.source_files == 0 + assert not any(item.code == "testing.none-detected" for item in report.findings) + + +def test_scan_skips_symlinked_files_outside_repository(tmp_path: Path) -> None: + _write_good_repo(tmp_path) + external = tmp_path.parent / f"{tmp_path.name}-outside.py" + external.write_text("API_KEY = 'outside-secret-example-value'\n", encoding="utf-8") + linked = tmp_path / "linked.py" + try: + linked.symlink_to(external) + except (NotImplementedError, OSError): + pytest.skip("symlinks are unavailable in this environment") + + report = scan_repository(str(tmp_path)) + + assert report.metrics.source_files == 3 + assert all(finding.path != "linked.py" for finding in report.findings) + + +def test_scan_skips_symlinked_directories_outside_repository(tmp_path: Path) -> None: + _write_good_repo(tmp_path) + external = tmp_path.parent / f"{tmp_path.name}-outside-dir" + external.mkdir() + (external / "outside.py").write_text("API_KEY = 'outside-secret-example-value'\n", encoding="utf-8") + linked = tmp_path / "linked" + try: + linked.symlink_to(external, target_is_directory=True) + except (NotImplementedError, OSError): + pytest.skip("directory symlinks are unavailable in this environment") + + report = scan_repository(str(tmp_path)) + + assert report.metrics.source_files == 3 + assert all(finding.path != "linked/outside.py" for finding in report.findings) + + +def test_malformed_dependency_manifests_are_reported_without_crashing(tmp_path: Path) -> None: + (tmp_path / "README.md").write_text("# Demo\n", encoding="utf-8") + (tmp_path / ".gitignore").write_text("\n", encoding="utf-8") + (tmp_path / "package.json").write_text("[]", encoding="utf-8") + (tmp_path / "pyproject.toml").write_text("[project]\ndependencies = \"invalid\"\n", encoding="utf-8") + (tmp_path / "pom.xml").write_text("", encoding="utf-8") + + report = scan_repository(str(tmp_path)) + codes = {finding.code for finding in report.findings} + + assert "dependency.invalid-package-json" in codes + assert "dependency.invalid-pyproject" in codes + assert "dependency.invalid-pom" in codes + + +def test_empty_git_repository_does_not_fallback_to_untracked_files(tmp_path: Path) -> None: + (tmp_path / "stray.py").write_text("print('not tracked')\n", encoding="utf-8") + subprocess.run(["git", "init", "--quiet", str(tmp_path)], check=True) + + report = scan_repository(str(tmp_path)) + + assert report.git.available is True + assert report.git.tracked_files == 0 + assert report.metrics.files == 0 + assert report.metrics.source_files == 0 diff --git a/backend/tests/test_signals.py b/backend/tests/test_signals.py new file mode 100644 index 0000000..2b53512 --- /dev/null +++ b/backend/tests/test_signals.py @@ -0,0 +1,113 @@ +from pathlib import Path + +from app.signals import analyze_dependencies, detect_test_signals + + +def test_dependency_analysis_handles_multiple_ecosystems(tmp_path: Path) -> None: + package = tmp_path / "package.json" + package.write_text('{"dependencies":{"react":"latest"}}', encoding="utf-8") + requirements = tmp_path / "requirements.txt" + requirements.write_text("fastapi>=0.100\n", encoding="utf-8") + lock = tmp_path / "package-lock.json" + lock.write_text("{}", encoding="utf-8") + + signals, findings = analyze_dependencies( + tmp_path, + { + "package.json": [package], + "requirements.txt": [requirements], + "package-lock.json": [lock], + }, + ) + + assert signals.declared_dependencies == 2 + assert signals.unbounded_dependencies == 2 + assert signals.unpinned_dependencies == 0 + assert "package-lock.json" in signals.lockfiles + assert any(item.code == "dependency.unbounded" for item in findings) + + +def test_python_dependency_ranges_only_flag_truly_unbounded_declarations(tmp_path: Path) -> None: + pyproject = tmp_path / "pyproject.toml" + pyproject.write_text( + """ +[project] +dependencies = [ + "exact==1.2.3", + "compatible~=2.0", + "bounded>=3.0,<4.0", + "open>=5.0", +] +optional-dependencies.dev = ["pytest~=8.0"] +""".strip(), + encoding="utf-8", + ) + + signals, findings = analyze_dependencies(tmp_path, {"pyproject.toml": [pyproject]}) + + assert signals.declared_dependencies == 5 + assert signals.unbounded_dependencies == 1 + assert [finding.code for finding in findings] == ["dependency.python-unbounded"] + + +def test_test_signals_detect_ci_coverage_and_frameworks() -> None: + text_by_path = { + "package.json": '{"devDependencies":{"vitest":"^3.0.0","@playwright/test":"^1.0.0"}}', + } + signals = detect_test_signals( + ["src/app.ts", "src/app.test.ts", ".gitea/workflows/ci.yml", "coverage/lcov.info"], + source_files=2, + test_files=1, + text_by_path=text_by_path, + ) + + assert "Vitest" in signals.frameworks + assert "Playwright" in signals.frameworks + assert signals.ci_workflows == [".gitea/workflows/ci.yml"] + assert signals.coverage_artifacts == ["coverage/lcov.info"] + assert signals.test_source_ratio == 50.0 + + +def test_test_signals_distinguish_validation_from_deploy_only_workflows() -> None: + signals = detect_test_signals( + [".gitea/workflows/validate.yml", ".gitea/workflows/deploy.yml"], + source_files=1, + test_files=1, + text_by_path={ + ".gitea/workflows/validate.yml": "steps:\n - run: pytest --cov\n - run: npm run build\n", + ".gitea/workflows/deploy.yml": "steps:\n - run: deploy production\n", + }, + ) + + assert signals.ci_validation_workflows == [".gitea/workflows/validate.yml"] + assert signals.ci_build_workflows == [".gitea/workflows/validate.yml"] + assert signals.ci_deploy_only_workflows == [".gitea/workflows/deploy.yml"] + assert signals.coverage_evidence == [".gitea/workflows/validate.yml"] + + +def test_dependency_analysis_follows_local_requirements_includes_and_workspace_locks(tmp_path: Path) -> None: + packages = tmp_path / "packages" / "web" + packages.mkdir(parents=True) + package = packages / "package.json" + package.write_text('{"dependencies":{"shared":"workspace:*"}}', encoding="utf-8") + lock = tmp_path / "pnpm-lock.yaml" + lock.write_text("lockfileVersion: '9.0'\n", encoding="utf-8") + requirements = tmp_path / "requirements.txt" + included = tmp_path / "requirements-prod.txt" + requirements.write_text("-r requirements-prod.txt\n", encoding="utf-8") + included.write_text("fastapi==0.116.0\n", encoding="utf-8") + + signals, findings = analyze_dependencies( + tmp_path, + { + "package.json": [package], + "pnpm-lock.yaml": [lock], + "requirements.txt": [requirements], + "requirements-prod.txt": [included], + }, + ) + + assert signals.unbounded_dependencies == 0 + assert signals.included_requirements == ["requirements-prod.txt"] + assert signals.declared_dependencies == 2 + assert not any(item.code == "dependency.no-lockfile" for item in findings) diff --git a/backend/tests/test_signals_v11.py b/backend/tests/test_signals_v11.py new file mode 100644 index 0000000..fe16b0d --- /dev/null +++ b/backend/tests/test_signals_v11.py @@ -0,0 +1,59 @@ +from __future__ import annotations + +import subprocess +from pathlib import Path + +from app.git_analysis import analyze_git +from app.scanner import _walk_files, scan_repository + + +def test_non_git_fallback_applies_root_gitignore_rules(tmp_path: Path) -> None: + (tmp_path / ".gitignore").write_text("ignored.py\nignored-dir/\n*.log\n!keep.log\n", encoding="utf-8") + (tmp_path / "kept.py").write_text("print('kept')\n", encoding="utf-8") + (tmp_path / "ignored.py").write_text("print('ignored')\n", encoding="utf-8") + (tmp_path / "keep.log").write_text("kept\n", encoding="utf-8") + (tmp_path / "drop.log").write_text("dropped\n", encoding="utf-8") + (tmp_path / "ignored-dir").mkdir() + (tmp_path / "ignored-dir" / "nested.py").write_text("print('nested')\n", encoding="utf-8") + + files = {path.relative_to(tmp_path).as_posix() for path in _walk_files(tmp_path)} + + assert "kept.py" in files + assert "keep.log" in files + assert "ignored.py" not in files + assert "drop.log" not in files + assert "ignored-dir/nested.py" not in files + + +def test_git_churn_attributes_renames_to_the_new_path(tmp_path: Path) -> None: + subprocess.run(["git", "init", "--quiet", str(tmp_path)], check=True) + subprocess.run(["git", "-C", str(tmp_path), "config", "user.email", "test@example.com"], check=True) + subprocess.run(["git", "-C", str(tmp_path), "config", "user.name", "RepoPulse Test"], check=True) + (tmp_path / "old.py").write_text("print('hello')\n", encoding="utf-8") + subprocess.run(["git", "-C", str(tmp_path), "add", "."], check=True) + subprocess.run(["git", "-C", str(tmp_path), "commit", "--quiet", "-m", "initial"], check=True) + subprocess.run(["git", "-C", str(tmp_path), "mv", "old.py", "new.py"], check=True) + subprocess.run(["git", "-C", str(tmp_path), "commit", "--quiet", "-m", "rename"], check=True) + (tmp_path / "new.py").write_text("print('hello world')\n", encoding="utf-8") + subprocess.run(["git", "-C", str(tmp_path), "commit", "--quiet", "-am", "edit after rename"], check=True) + + signals, churn = analyze_git(tmp_path) + + assert signals.renamed_files == ["new.py"] + assert churn.get("new.py", 0) > 0 + assert "old.py" not in churn + + +def test_policy_suppresses_accepted_risk_without_erasing_the_observation(tmp_path: Path) -> None: + (tmp_path / "README.md").write_text("# Demo\n", encoding="utf-8") + (tmp_path / ".gitignore").write_text("\n", encoding="utf-8") + (tmp_path / ".repopulse.yml").write_text("suppressions:\n - security.secret-assignment\n", encoding="utf-8") + (tmp_path / "app.py").write_text("api_key = 'abcdefghijk1234'\n", encoding="utf-8") + + report = scan_repository(str(tmp_path)) + finding = next(item for item in report.findings if item.code == "security.secret-assignment") + + assert finding.suppressed is True + assert report.category_scores["Security basics"] == 100 + assert report.release_gate is not None + assert report.release_gate.checks[0].state.value == "pass" diff --git a/backend/tests/test_store.py b/backend/tests/test_store.py new file mode 100644 index 0000000..14cd0c6 --- /dev/null +++ b/backend/tests/test_store.py @@ -0,0 +1,161 @@ +import json +from datetime import UTC, datetime, timedelta +from pathlib import Path + +import app.store as store_module +from app.scanner import scan_repository +from app.store import ScanStore + + +def test_scan_history_comparison_and_trend(tmp_path: Path) -> None: + repository = tmp_path / "repo" + repository.mkdir() + (repository / "README.md").write_text("# Demo\n", encoding="utf-8") + (repository / ".gitignore").write_text("*.db\n", encoding="utf-8") + + store = ScanStore(str(tmp_path / "repopulse.db")) + first = store.save(scan_repository(str(repository))) + + (repository / "app.py").write_text("print('hello')\n", encoding="utf-8") + (repository / "tests").mkdir() + (repository / "tests" / "test_app.py").write_text("def test_ok():\n assert True\n", encoding="utf-8") + second = store.save(scan_repository(str(repository))) + + assert store.get(second.id) == second + assert store.recent(1) == [second] + assert store.previous_for_repository(second.repository_path, second.id) == first + + comparison = store.compare(second) + assert comparison.previous_scan_id == first.id + assert comparison.health_score_delta == second.health_score - first.health_score + assert comparison.metric_deltas["source_files"] == 2 + + trend = store.trend(second.repository_path) + assert [item.scan_id for item in trend] == [first.id, second.id] + assert trend[-1].health_score == second.health_score + + +def test_comparison_uses_the_scan_before_the_selected_scan(tmp_path: Path) -> None: + repository = tmp_path / "repo" + repository.mkdir() + (repository / "README.md").write_text("# Demo\n", encoding="utf-8") + (repository / ".gitignore").write_text("*.db\n", encoding="utf-8") + + store = ScanStore(str(tmp_path / "repopulse.db")) + first = store.save(scan_repository(str(repository))) + second = store.save(scan_repository(str(repository))) + third = store.save(scan_repository(str(repository))) + + assert store.previous_for_repository(second.repository_path, second.id) == first + assert store.previous_for_repository(third.repository_path, third.id) == second + + +def test_repository_summary_exposes_compact_remediation_context(tmp_path: Path) -> None: + repository = tmp_path / "repo" + repository.mkdir() + (repository / "README.md").write_text("# Demo\n", encoding="utf-8") + (repository / ".gitignore").write_text(".env\n", encoding="utf-8") + (repository / ".env").write_text("TOKEN=actual-secret-value-123456\n", encoding="utf-8") + + store = ScanStore(str(tmp_path / "repopulse.db")) + store.save(scan_repository(str(repository))) + + (repository / ".env").unlink() + (repository / "app.py").write_text("api_key = 'actual-secret-value-123456'\n", encoding="utf-8") + store.save(scan_repository(str(repository))) + + summary = store.list_repositories()[0] + + assert summary.last_scan_blockers == 1 + assert summary.last_scan_primary_signal is not None + assert summary.last_scan_primary_signal.code == "security.secret-assignment" + assert summary.last_scan_primary_signal.count == 1 + assert summary.last_scan_added_findings >= 1 + assert summary.last_scan_resolved_findings == 1 + + +def test_corrupt_database_is_quarantined_and_recreated(tmp_path: Path) -> None: + database = tmp_path / "repopulse.db" + database.write_bytes(b"not a sqlite database") + + store = ScanStore(str(database)) + + assert store.recent() == [] + assert list(tmp_path.glob("repopulse.db.corrupt-*")) + assert store.database_recovery_status()["status"] == "degraded_recovered" + + +def test_schema_migration_records_the_durable_backup_artifact(tmp_path: Path) -> None: + database = tmp_path / "repopulse.db" + initial_store = ScanStore(str(database)) + with initial_store._connection() as db: + db.execute("PRAGMA user_version = 3") + + migrated_store = ScanStore(str(database)) + + recorded = migrated_store.get_state("last_schema_migration_backup") + assert recorded is not None + metadata = json.loads(recorded) + assert metadata["from_version"] == 3 + assert metadata["to_version"] == store_module.SCHEMA_VERSION + assert (tmp_path / metadata["backup_file"]).is_file() + assert migrated_store.storage_stats()["last_schema_migration_backup"] == recorded + + +def test_history_is_bounded_per_repository(tmp_path: Path, monkeypatch) -> None: + repository = tmp_path / "repo" + repository.mkdir() + (repository / "README.md").write_text("# Demo\n", encoding="utf-8") + + monkeypatch.setattr(store_module, "MAX_HISTORY_PER_REPOSITORY", 2) + store = ScanStore(str(tmp_path / "repopulse.db")) + first = store.save(scan_repository(str(repository))) + second = store.save(scan_repository(str(repository))) + third = store.save(scan_repository(str(repository))) + + assert [item.id for item in store.recent_for_repository(third.repository_path)] == [third.id, second.id] + assert store.get(first.id) is None + + +def test_retention_compacts_old_detailed_payloads_and_expires_old_snapshots(tmp_path: Path, monkeypatch) -> None: + repository = tmp_path / "repo" + repository.mkdir() + (repository / "README.md").write_text("# Demo\n", encoding="utf-8") + (repository / ".gitignore").write_text("*.db\n", encoding="utf-8") + monkeypatch.setenv("REPOPULSE_FULL_REPORTS_PER_REPOSITORY", "1") + monkeypatch.setenv("REPOPULSE_REPORT_RETENTION_DAYS", "30") + store = ScanStore(str(tmp_path / "repopulse.db")) + + first = store.save(scan_repository(str(repository))) + second = store.save(scan_repository(str(repository))) + compacted = store.get(first.id) + + assert compacted is not None and compacted.compacted is True + assert compacted.findings == [] + assert store.get(second.id) is not None + + expired = second.model_copy( + update={"id": "expired-scan", "scanned_at": datetime.now(UTC) - timedelta(days=31)} + ) + store.save(expired) + assert store.get("expired-scan") is None + + +def test_catalog_summary_uses_denormalized_fields_without_report_json_parsing(tmp_path: Path, monkeypatch) -> None: + repository = tmp_path / "repo" + repository.mkdir() + (repository / "README.md").write_text("# Demo\n", encoding="utf-8") + (repository / ".gitignore").write_text("*.db\n", encoding="utf-8") + store = ScanStore(str(tmp_path / "repopulse.db")) + store.save(scan_repository(str(repository))) + + def fail_if_called(_row): + raise AssertionError("catalog list must not parse report_json") + + monkeypatch.setattr(store, "_report_from_row", fail_if_called) + summary = store.list_repositories()[0] + assert summary.last_scan_id + storage = store.storage_stats() + assert storage["scan_count"] == 1 + assert storage["mirror_count"] >= 0 + assert storage["worktree_count"] >= 0 diff --git a/compose.yaml b/compose.yaml new file mode 100644 index 0000000..29a7f01 --- /dev/null +++ b/compose.yaml @@ -0,0 +1,80 @@ +name: repopulse + +services: + backend: + build: + context: . + dockerfile: backend/Dockerfile + container_name: repopulse-backend + restart: unless-stopped + environment: + REPOPULSE_SCAN_ROOT: /scan + REPOPULSE_DB: /data/repopulse.db + REPOPULSE_MAX_CONCURRENT_SCANS: "${REPOPULSE_MAX_CONCURRENT_SCANS:-1}" + REPOPULSE_JOB_LEASE_SECONDS: "${REPOPULSE_JOB_LEASE_SECONDS:-900}" + REPOPULSE_SCAN_MAX_FILES: "${REPOPULSE_SCAN_MAX_FILES:-10000}" + REPOPULSE_SCAN_MAX_TEXT_BYTES: "${REPOPULSE_SCAN_MAX_TEXT_BYTES:-2000000}" + REPOPULSE_SCAN_MAX_TOTAL_TEXT_BYTES: "${REPOPULSE_SCAN_MAX_TOTAL_TEXT_BYTES:-50000000}" + REPOPULSE_SCAN_MAX_FINDINGS: "${REPOPULSE_SCAN_MAX_FINDINGS:-2000}" + REPOPULSE_SCAN_MAX_SECRET_FINDINGS: "${REPOPULSE_SCAN_MAX_SECRET_FINDINGS:-20}" + REPOPULSE_GITEA_URL: "${REPOPULSE_GITEA_URL:-}" + REPOPULSE_GITEA_TOKEN: "${REPOPULSE_GITEA_TOKEN:-}" + REPOPULSE_GITEA_BRANCH_WORKERS: "${REPOPULSE_GITEA_BRANCH_WORKERS:-4}" + REPOPULSE_GITEA_WEBHOOK_SECRET: "${REPOPULSE_GITEA_WEBHOOK_SECRET:-}" + REPOPULSE_GITEA_SYNC_INTERVAL_SECONDS: "${REPOPULSE_GITEA_SYNC_INTERVAL_SECONDS:-300}" + REPOPULSE_REPOSITORY_CACHE: /data/repos + REPOPULSE_MAX_QUEUED_SCANS: "${REPOPULSE_MAX_QUEUED_SCANS:-100}" + REPOPULSE_HISTORY_PER_REPOSITORY: "${REPOPULSE_HISTORY_PER_REPOSITORY:-200}" + REPOPULSE_FULL_REPORTS_PER_REPOSITORY: "${REPOPULSE_FULL_REPORTS_PER_REPOSITORY:-30}" + REPOPULSE_REPORT_RETENTION_DAYS: "${REPOPULSE_REPORT_RETENTION_DAYS:-365}" + REPOPULSE_OPERATOR_TOKEN: "${REPOPULSE_OPERATOR_TOKEN:-}" + volumes: + - "${REPOPULSE_DATA_ROOT:-repopulse_data}:/data" + - "${REPOPULSE_SOURCE_ROOT:-..}:/scan:ro" + healthcheck: + test: ["CMD", "python", "-c", "import urllib.request; urllib.request.urlopen('http://127.0.0.1:8000/health', timeout=3).read()"] + interval: 20s + timeout: 5s + start_period: 10s + retries: 5 + labels: + net.unraid.docker.managed: "dockerman" + security_opt: + - no-new-privileges:true + logging: + driver: json-file + options: + max-size: "20m" + max-file: "3" + + frontend: + build: + context: . + dockerfile: frontend/Dockerfile + container_name: repopulse + restart: unless-stopped + depends_on: + backend: + condition: service_healthy + ports: + - "${REPOPULSE_PORT:-1254}:80" + healthcheck: + test: ["CMD-SHELL", "wget -qO- http://127.0.0.1/health >/dev/null || exit 1"] + interval: 20s + timeout: 5s + start_period: 10s + retries: 5 + labels: + net.unraid.docker.managed: "dockerman" + net.unraid.docker.webui: "http://127.0.0.1:${REPOPULSE_PORT:-1254}" + security_opt: + - no-new-privileges:true + logging: + driver: json-file + options: + max-size: "20m" + max-file: "3" + +volumes: + repopulse_data: + name: repopulse_data diff --git a/docker-compose.yml b/docker-compose.yml new file mode 100644 index 0000000..52e1160 --- /dev/null +++ b/docker-compose.yml @@ -0,0 +1,57 @@ +name: repopulse + +services: + repopulse: + build: + context: . + dockerfile: Dockerfile.unraid + container_name: repopulse + restart: unless-stopped + environment: + REPOPULSE_SCAN_ROOT: /scan + REPOPULSE_DB: /data/repopulse.db + REPOPULSE_STATIC_DIR: /app/static + REPOPULSE_MAX_CONCURRENT_SCANS: "${REPOPULSE_MAX_CONCURRENT_SCANS:-1}" + REPOPULSE_JOB_LEASE_SECONDS: "${REPOPULSE_JOB_LEASE_SECONDS:-900}" + REPOPULSE_SCAN_MAX_FILES: "${REPOPULSE_SCAN_MAX_FILES:-10000}" + REPOPULSE_SCAN_MAX_TEXT_BYTES: "${REPOPULSE_SCAN_MAX_TEXT_BYTES:-2000000}" + REPOPULSE_SCAN_MAX_TOTAL_TEXT_BYTES: "${REPOPULSE_SCAN_MAX_TOTAL_TEXT_BYTES:-50000000}" + REPOPULSE_SCAN_MAX_FINDINGS: "${REPOPULSE_SCAN_MAX_FINDINGS:-2000}" + REPOPULSE_SCAN_MAX_SECRET_FINDINGS: "${REPOPULSE_SCAN_MAX_SECRET_FINDINGS:-20}" + REPOPULSE_GITEA_URL: "${REPOPULSE_GITEA_URL:-}" + REPOPULSE_GITEA_TOKEN: "${REPOPULSE_GITEA_TOKEN:-}" + REPOPULSE_GITEA_BRANCH_WORKERS: "${REPOPULSE_GITEA_BRANCH_WORKERS:-4}" + REPOPULSE_GITEA_WEBHOOK_SECRET: "${REPOPULSE_GITEA_WEBHOOK_SECRET:-}" + REPOPULSE_GITEA_SYNC_INTERVAL_SECONDS: "${REPOPULSE_GITEA_SYNC_INTERVAL_SECONDS:-300}" + REPOPULSE_REPOSITORY_CACHE: /data/repos + REPOPULSE_MAX_QUEUED_SCANS: "${REPOPULSE_MAX_QUEUED_SCANS:-100}" + REPOPULSE_HISTORY_PER_REPOSITORY: "${REPOPULSE_HISTORY_PER_REPOSITORY:-200}" + REPOPULSE_FULL_REPORTS_PER_REPOSITORY: "${REPOPULSE_FULL_REPORTS_PER_REPOSITORY:-30}" + REPOPULSE_REPORT_RETENTION_DAYS: "${REPOPULSE_REPORT_RETENTION_DAYS:-365}" + REPOPULSE_OPERATOR_TOKEN: "${REPOPULSE_OPERATOR_TOKEN:-}" + REPOPULSE_MAINTENANCE_TOKEN: "${REPOPULSE_MAINTENANCE_TOKEN:-}" + volumes: + - "${REPOPULSE_DATA_ROOT:-repopulse_data}:/data" + - "${REPOPULSE_SOURCE_ROOT:-..}:/scan:ro" + ports: + - "${REPOPULSE_PORT:-1254}:8000" + healthcheck: + test: ["CMD", "python", "-c", "import urllib.request; urllib.request.urlopen('http://127.0.0.1:8000/health', timeout=3).read()"] + interval: 20s + timeout: 5s + start_period: 10s + retries: 5 + labels: + net.unraid.docker.managed: "dockerman" + net.unraid.docker.webui: "http://127.0.0.1:${REPOPULSE_PORT:-1254}" + security_opt: + - no-new-privileges:true + logging: + driver: json-file + options: + max-size: "20m" + max-file: "3" + +volumes: + repopulse_data: + name: repopulse_data diff --git a/docs/ARCHITECTURE.md b/docs/ARCHITECTURE.md new file mode 100644 index 0000000..d550c09 --- /dev/null +++ b/docs/ARCHITECTURE.md @@ -0,0 +1,100 @@ +# RepoPulse Architecture + +## Runtime shape + +RepoPulse is a Gitea-native deterministic analysis service. Source code is read by the backend only; the browser receives repository summaries, derived metrics, findings and bounded graph metadata. Gitea is a read-only provider, while SQLite remains the source of RepoPulse catalog and history state during provider outages. + +```text +Gitea (read-only API + Git) + │ catalog + default-branch SHA + ▼ +FastAPI ── SQLite catalog / durable job queue / scan history (/data) + │ │ + │ ├── bounded mirror cache (/data/repos/mirrors) + │ └── detached worktrees (/data/repos/worktrees) + │ │ + │ ▼ + ├── single-process worker → deterministic scanner → report persistence + │ + └── /api → Nginx / React repository cockpit + │ + └── Advanced local provider → read-only /scan +``` + +The worker starts and stops through FastAPI lifespan. SQLite claim transactions and leases make queued work restart-safe; the current deployment intentionally uses one worker and one active scan by default, without Redis or Celery. + +## Repository identity and lifecycle + +Gitea repositories are first-class records keyed by `id = gitea:` and constrained by `(provider, provider_repository_id)`. Owner/name, description, URLs, visibility, archive state, default branch and observed HEAD metadata are catalog attributes; filesystem paths are not primary identity. Local scans use a separate stable `local:` identity for v1 compatibility. + +Catalog synchronization is bounded and paginated. After a successful listing it resolves each default-branch HEAD independently with a bounded `REPOPULSE_GITEA_BRANCH_WORKERS` pool (default 4). A branch failure is persisted as a sanitized repository-specific `sync_error`, while every other repository is upserted and remains usable. A failed or truncated listing preserves all prior catalog/history rows; only a complete listing may mark an absent repository unavailable. Archived/unavailable records are retained and are not cascade-deleted. + +The computed repository state is one of `never_scanned`, `current`, `stale`, `queued`, `scanning`, `failed`, `unavailable` or `archived`. The scheduler reconciles `latest_revision` against `last_scan_revision`, respects `policy.auto_scan`, queues new/stale revisions, and retries after the next sync interval. It does not queue a repository whose observed HEAD already has a successful scan. + +## Exact source acquisition + +For a Gitea job, the requested SHA is captured at enqueue time. The acquirer uses the configured Gitea origin only, passes the token through a subprocess environment header rather than a URL, fetches the selected default branch into a provider-ID mirror, resolves the requested immutable commit, and creates a detached worktree under the managed cache. The scanner sees that one worktree only; cleanup removes it and prunes stale Git registrations. Corrupt mirrors are discarded only after a local bare-repository validation failure, so a remote outage does not erase a usable cache. + +## Scan boundary + +When `REPOPULSE_SCAN_ROOT` is configured, every local scan path is resolved and checked against that root before analysis. Compose sets the root to `/scan` and mounts the user-selected source directory read-only. The scanner then resolves every candidate file, rejects symlinked files and directories (including symlink ancestors), and requires the resolved file to remain below the scan root. This prevents the API from being used as a generic filesystem browser outside the configured analysis boundary. Gitea worktrees are acquired into `/data`, not `/scan`, and are controlled by repository-ID/job-ID validation. + +## Persistence and deployment boundary + +The exact-source deployment controller replaces the registered repository source directory on each deployment. SQLite history, the catalog, queue and mirror cache must therefore not live below that directory. Compose uses the Docker-managed named volume `repopulse_data` for `/data` when `REPOPULSE_DATA_ROOT` is unset (the production configuration); this volume is independent of source refreshes and container recreation. The checked-in `.env.example` opts local Compose into `REPOPULSE_DATA_ROOT=./data` for convenient checkout-local development. `/scan` remains the read-only source boundary and `/data` is the only writable application mount. + +The AppOps-managed runtime candidate is defined separately in `.itworx/deployment.yml` and built with `deploy/managed/Dockerfile`; the legacy root `docker-compose.yml` keeps its existing topology and now forwards the optional `REPOPULSE_MAINTENANCE_TOKEN` so the old writer can be authenticated and quiesced before cutover. `Dockerfile.unraid` remains unchanged pending cutover. The managed target uses the immutable controller-selected source revision to build image `repopulse-managed:production`, runs as UID/GID `10001:10001` with a read-only root filesystem and one existing NPM network, binds `/mnt/pool/appdata/repopulse/data` to writable `/data`, and binds only the existing controller-owned `repopulse` and `privatemuse` source directories read-only at `/scan/repopulse` and `/scan/privatemuse`. The fixed AppOps profile allows only these exact external source mounts and rejects other paths. Git mirrors and worktrees stay under `/data/repos`, while process scratch files use the bounded `/tmp` tmpfs. Runtime secrets are restricted to the fixed Gitea URL/token and a dedicated RepoPulse maintenance token in `deploy.managed.env`; the legacy `deploy.env` remains available for rollback. No Gitea webhook secret is configured. + +## Inventory pipeline and analysis coverage + +The scanner prefers `git ls-files` for a top-level worktree so ignored/untracked build artifacts do not distort results. An empty Git worktree remains empty rather than silently falling back. Non-Git directories use a filesystem traversal that excludes common generated/vendor directories and applies bounded root/nested `.gitignore` rules. Text files larger than the configured internal read threshold are not parsed as source, and binary files are skipped. + +Every report includes `ScanCoverage`: bounded file, per-file-text, total-text, finding and credential-finding limits plus the observed skipped counts. A limit produces a deterministic partial result and an analysis-coverage warning rather than an unqualified completeness claim or an artificial blocker. + +## Signals + +The v1 scan combines: + +- language and non-empty LOC inventory; +- test-file, test-framework, CI and coverage-artifact detection; +- dependency manifests and lockfiles across JavaScript, Python, Go, Rust and Maven; +- TODO/FIXME/HACK/XXX debt; +- large files/modules and Python function-size/branch heuristics; +- basic credential-assignment detection with values redacted; +- bounded recent Git commit/contributor/churn information. + +Malformed dependency manifests are represented as warning findings instead of aborting the complete scan. CI workflows are classified from supported commands as validation, build or deploy-only rather than file presence alone. Requirements includes and workspace-root lockfiles are handled safely and boundedly. Credential heuristics redact values, ignore obvious templates/environment references, and still flag real-looking fixture literals for review. + +Each finding is enriched by a backend rule definition with confidence, why-it-matters text, recommended action, remediation class and explainable priority. The browser renders retained intelligence; it does not duplicate rule knowledge or mutate external repositories. + +## Architecture graph + +Python imports are parsed using the standard-library AST. Local JavaScript and TypeScript relative imports, bounded `baseUrl`/`paths` aliases from `tsconfig.json`/`jsconfig.json`, and simple local workspace package imports are resolved against known source files. Only local edges are retained; this remains heuristic source analysis, not a TypeScript compiler. The displayed graph is bounded to 160 nodes and 600 edges to keep large repositories responsive; the response explicitly indicates truncation, reports total discovered nodes/edges and distinguishes visible coupling from total coupling used in hotspot ranking. Extensionless, index and `.js`-specifier-to-TypeScript resolution are supported. + +## Hotspot model + +Hotspot score is deterministic and combines source size, debt markers, recent changed-line churn and local inbound/outbound coupling. The UI surfaces both the score and reasons so it is not a black-box ranking. + +## Health and release gate + +Category scores start at 100 and are reduced only by findings with an explicit deduction. The overall health score is the average category score. The release gate separately evaluates blocker security findings, test presence, CI, dependency hygiene (including unbounded and unpinned declarations), repository health and engineering warnings, producing `READY`, `READY WITH WARNINGS` or `BLOCKED`. + +## History and comparison + +Every report is serialized as a snapshot in SQLite using WAL. Lightweight scan summary columns (readiness, counts, primary signal, deltas and triage priority) drive catalog CTE queries without deserializing full reports. Comparison calculates metric/category deltas and added/resolved findings against the chronological previous scan of the same repository identity. Findings carry stable semantic fingerprints so line movement does not appear as a new risk. Trend endpoints return bounded chronological snapshots for UI visualization. By default, up to 200 snapshots are retained per repository, the latest 30 remain detailed, older retained payloads compact to summary evidence, and snapshots older than 365 days are removed. v1 path history is backfilled into a local catalog identity and is never deleted solely for migration. + +## Reporting + +RepoPulse can export the complete JSON report or a standalone HTML report. HTML output escapes repository-derived text, export headers use sanitized RFC 5987 filenames, and neither format includes detected secret values or Gitea credentials. A root `.repopulse.yml`/`.yaml` may configure automatic scanning, minimum health, blocker allowance, required tests/CI and finding-code suppressions. Suppressed observations remain visible and are excluded from deductions and gate blockers. + +## Job state and failure isolation + +The persisted queue records repository, trigger, requested/actual revision, phase, progress, attempt, timestamps, resulting scan and sanitized error information. Claims use `BEGIN IMMEDIATE` plus a status guard, so two processes cannot own the same queued job. They move through `queued → acquiring_source → scanning → analyzing → persisting → completed` or an isolated `failed` outcome. A heartbeat renews each active lease; only a crashed worker’s expired lease returns work to `queued` for recovery. Older unstarted revisions become `superseded`; explicit cancellation states remain representable. One repository failure does not terminate the worker loop or affect other queued repositories. + +## Operator maintenance mode + +The `app_state` key `maintenance_mode` durably records whether operator maintenance is enabled; it uses the existing state table and does not change the SQLite schema version. Operator enter/exit endpoints require `REPOPULSE_MAINTENANCE_TOKEN` (or the existing general operator token on legacy installations). Entering is serialized against API mutations and catalog synchronization so an accepted external write completes before the pause is committed. While paused, mutation requests and webhooks return `423 Locked`; the scheduler skips heartbeat writes, Gitea synchronization, queue claims and new scan-job enqueue operations. Existing queued jobs remain queued for later resumption. A job claimed before the mode transition may complete and persist its result. Queue depth, active count, active-drain state and full-drain state are reported by the authenticated maintenance endpoint and the read-only meta endpoint. A malformed persisted maintenance value fails closed as paused. + +## Operational configuration + +`REPOPULSE_GITEA_URL` and `REPOPULSE_GITEA_TOKEN` enable the provider. `REPOPULSE_GITEA_SYNC_INTERVAL_SECONDS`, `REPOPULSE_GITEA_BRANCH_WORKERS`, `REPOPULSE_MAX_QUEUED_SCANS`, `REPOPULSE_JOB_LEASE_SECONDS`, scan-budget and retention variables, and `REPOPULSE_REPOSITORY_CACHE` bound reconciliation, queue depth, active leases, analysis and cache placement. The durable Gitea runner deliberately has one worker; `/api/v1/meta` exposes requested versus actual capacity. `REPOPULSE_GITEA_WEBHOOK_SECRET` enables signed default-branch push intake; non-push, non-default-branch, invalid and branch-deletion events are acknowledged without scheduling work. `REPOPULSE_OPERATOR_TOKEN` protects mutating endpoints when an authenticated proxy perimeter is not the selected boundary. `/api/v1/meta` exposes repository state counts, queue depth, storage/retention metrics, recovery status, worker heartbeat, connector URL (without token) and last sync result. diff --git a/docs/screenshots/demo-explorer.png b/docs/screenshots/demo-explorer.png new file mode 100644 index 0000000000000000000000000000000000000000..dbdbd88c69cbb80705445db6ab565c6c200be3d0 GIT binary patch literal 183006 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

oxO2jjP7;L(Bs<9UB^B&%~Zh|5}WX z_K#j&j~jgs9Ouid9@3IOXgZS7Qc^?^q{os?RW-h%*{2DlN~SQ~>%fc4I8Kz9DfRSN ztwu^IS_hz47!vN!Ct6UuGV@cYvo(hzWd^A&8ei3lyo$rIS` zPDMU71aX3KZ-dOq8v}%z%t670mo1@n&G?ABP^=>=`vShFU(ml0PsQ_x{4^wbjM6JM zGnDD7nEg&)TTkjopgQN;M=s8p(k(&6N;$q@vS*{stadf3g9>?Jj9`3PR2dig%GhuH zbCrAJ7mrmYKjr`}9BQIsxk1oa5{*)Njcjl}VMO%ykRmKb1&&;Xp~Gzk{>~T+J~$`#tKAp$vwa2p%_cW-jz^p6^~zYwACU zvjRE|84Ri$|EC2=)>{+D`B6FyVlDGG+Wh~Q{Mwa*w8i0n_1@%VUawfaR*xRn(AW4& z0(g~)sf*U1_{|%Aj$7Mjs^IBR3paXB;#2EB<@8G8Fw;%+`DY$-(etbgCv68AW!7v+ zWm%!+HnGQc_2ywsHS_ZZB~8)F;TuV87tJt+^A@22YVIaK6h) zTC6w{ESLclwK!#p9 zO!G)RM(;o`f|zmjwh`eFggCo`H?u<4f?-KSTh^*Z)JPP#C7Xqa6+rBKX0oUL{CQAR zE}Pk&&3E6!F5UjEH%ifF1v(%ab5W_}OI^u*S*4UaM0%M7$`?=K=4pOTdL@1eDzZ?? zm^2wVwIL}NI(6t(WhEPLDN8gs5_**6A>>?^N)F2F;;32SBy)q~60)-!d%3ab%ry_@ z+Scz|Q_PwLffR2ebyNA=1~$1hP~3H}74vDU=6~{Z^B?-NyBkr&)%F$w1m(=cL5*8w zY-r<3h`&OTH8HId2OU`Xv_?Q+fo6nxAxOozNtUMEoMqZS?RQZ`|5~r|2zj2Z2jw6Ryf~_SEPdM6GUGiI8&oQ|MNa1iE-gGi-3Z%I1EB!b z$gQNbzc6AxBVycUqZBEl%EU_QUKN2OvqBU_RI{0wa{^Wk21~?=whE95?pJ);80}QV z^!E_;pOz)Z4H6SfYvK^6%A_kKLw74e^Vb&pLTC}j_-vSu0bO)MIbf9I2^T18vA4+p zDb%F72zUD|*o>oS0o&z!ZsDpTskM@^$i@q~0-=RQg#3a612(yE-$j#%N0%cl$o~%hK^%9fv9k}e%!OC$mAD9*o_s%cPz~YgryW@V;hW%bnz*S zBOsI&Cv2@;AO9CUUbEF=U@viU6;qJ^A8nJIoD-Y5MFPBeE@4OUg16QAakZHspb81` zyY)~#ZX%@gDz4t2T4*GuH*F<5&XBEk}1e3rxXj)j}#DFzw1!gjEA{t>D(_htM`E5_Y!RQrJKQs@# zD5O}h?6O5cno9X`qvA}GQ6~)5rmBAv#CyDT3Nt*1H(++_3UVlY?n|q~MFCTu$k=3w z8XyU^+8dW3Gm21bF6H10(oa)potrzGP#CpB1s+P*>jnfZufmY95<_4CfK{>E?GKIu z!Mgdy%uqrwvsQj+p41a-d8S6>04YY+pVy^qtzdGBh)=V23fZ_-Ly}2z(JU7H zHu(B12RDs;8&_V=>EeRbA`3_Lin<+fmY`86tD2eZ!Y9l7UF&zJKRMqpzFj9R7ddJ) z7FK0t`C37>op|w=y<*$K)6!;5RC)Sc{~`VcAHmgDQ@5JH<|OSw}t7 zG{!ddDHzSLu^e{_(6yTR!&pGcg!Rjfwgy3dcn`!y=G2NM^Dgk~w2GeFfU72u7|QGy za}zu~vGn0J2ayWg62Nar@3+WaN0dR=As%kQTnx=CMn6Va5{#3t%rf2n22@@;{IA5} za%}^dM;Vhlf!>_&{Znyq9I$?AL8Q5)c#(#wlI(njIdPE^7gL&L|F)qkq52^FIfxSE zC#oXxc69*Kb&bF9uFwz>$8B;1kSwsJ0Wr)5HuV}dkunp#hw|;F{yp6xM+PQ1#o(^B z=7c%r7e-tcX`VPI>pVdY(qv4;t8zoZ_UU4Lw<(Xf+5-!`8cXw~OX8|=FWUqHbf0to z=+N(9NNnud#8;)baG=_icxXLpHlCtbBRhfSnQK}9&x_NUQT1go06+^QK==@3l=JOI zSbrK?kns9V1LUBEW}s6VTrR*JFv5*4EI{#-8TgxAhM$*AN3E-5R>UG2?zfQ{Lv?;B zsHV;7`>_CbuWm;l+cE&+l#jHdW(NhXhiOlEi4K_a?F27+eAr~=1?{+RF+vE!qz~7X z0jsyZCBg*A?#Xh=nzqO;hl)rH7vT>!O+dhe)^qO%l=e8(V`7iuE=FM3IXW^|g_!+G z`IU$J4t>;a+JuTQM}X32&XHvK3gXUU&|TsPkzH5$IX(n-O(-4A;j;CUJ$fLfE*;6P z*q+X`2NX1+w1?sTG55z!8x12zNGtuxA~L&F=-S3j^Ye;S++*>?v~f;e&E#!mKh@$M zvMN)sEbvx}<-cFhvVy2~HIu#~@gqzda@OBC!5voN}{q8J?VNY8JeZXUA z(_gR8|32r=!xb>Pn1>rPje&F2gNywf9jO{TD3g@+u3*i}Zky<*2Q0iL74N$RwqhY;`6Z%2(?#SC$XkK%8U7F`;%50 zQs$-dilq^2;V8t3u6*5WM@n5OpQAvrBDz^r&Sao&Has0a)TpxmMuuB(ua!~V;kbhl z;}bM42guzA$cOEOv=-3Zk6F&@4l?3SYVc3E2%ebz9J>5Ya>RjO7ho(-brij-6hPTD z6qDU1OEbu*9%@_(N+F=Q%9ik@>7@o1hZQkp!RIJLnIm7%fKfBxFLzZ6tPvG~@#AMEt=Gb|PUu{n?G+^YTMy$D`G*Fs2*8p-saCve*r1qoj)i4p z*R#JXfnb1OL=&SaF`fJf7h}negmjW#lM3o361er%X7WZE<`262xq-&X%Fs{WY_p+F zsI$Vh$N*RZ*GO2U(C^1INQcRdxrtbb9E|>+7XdaVWqn6+>bEOoT5GRH@4N z0h&}TfA|TR;jWee+=O&v0w^NWC==_}(8l6W1}N#slRI-SonJa+{}X*0m&o+slew7} zZi7uqw{iFOZ18;L<+H;x!?3F}Pm*wXM7umn^L}5@>WIky%?G#=;rG{$Ro54mmaGIC zhiVcH@JQJk-P@n#dz4=Nn7qZsq@*0jM$RdVSs&N!Ku=-xNFUjClxr!6qps7`Yva){Ug<4dZ{LD|JalaNEWmvw!?9@o&zO@S+B#A! zzTV&rYZ`lKa?2ul-et7XVjlBb*_^5wpPSk5Hina7rHi5UUrIM<+O#t;T>5SDe{)y$ z>REJV=I5Kn$_;B<08EmWeXtBHBuDaK>fBavn0iHO_>gj%^#O<+Wrjj+0YcOx&)_Miq zb^C9{A9V?7EZF+q^vQn@FbTXR4a&GO;`F@46;2N(LKXtw^i=4SyZH6266jNK7m_LE zd^4-r=p3v5-kDWujjAwt#EI7@h1OU7sSM=R%M!QTU+xKllk{Men9^*PQ7Z(;9*~yN zx5$*gjMvx#?xTm3a#fhvNqsBs^Fvbn_iOUNX~cu>(zfw=gm#Mm{x0p3b>VFu*UNOhCC^CPCjl)1>bXzQ7QW0If13+5U?pah_~1Dl8melpn_-sPR< zRhF4G90Z^<0$IENXdDYndH3%QK zh~AY8eSJ>09U|+xlk`GL(FFeEy}4)4cm`rswAtRb+jB4qY?^I@&C?l+R45lKQTd;Lfq_d6+=(oN8Iumnc46bE;0gXiMtlDMw1A4FonsrJSQ$Ju zyYasGL5cGpUaHX+xDAZawX7xbN6 z3N@LEAg*MJFeb*jm#M3_G>81kYF8pq0`ijqE(qv&Pwib0uKVB9l0+o!SV@v z3efr>PVb!(y9KBEgWB?)+i8?lUd)#oOobEGmhoMfyP91#pr89;YF5L%1yP^=KJy=+s z2WD#Jg6Qbe11HZ{zemCXICEKP$$&S`_~r>7X@-^0h4w`uX-O`nS%#WiQEWxZTq;M6 zu13vDMgqK`Ya~HhSZ3;GzgpeFSg8cKMci`VwB2-FAy^dNJ}-{}VA6Au(+)zZ}EpHVt3l7kr$)zA$t z2>gYEcYc-@d3uV=CSZAFnSbGy9~O7KCF}+~n6%}N@hFZ#g+z_@5VR#~gbmhK(*0?&Ey)jrYEXn_&$P3rE40!@~!DYoSD~`%ov^dq9W0JscDMVK}Dhtp;h2 zxvV`NNON`Stj{=lp5kI4M2!U=yq=a_lc;d!F4-tv8X_Z*?1wpiF5$ z&6YJ`(uSvF7~5`r%zA2b`ZmuC5zf5NpmN%;)xA?#WGFQq3BESDThJtzYk_LVm;K9# z2}tQrAg+og9NDqW4IiSqE9q2==w}?~6)8*?=6OONo$(Wdzq@0}!{HMwVn=;nBQ!>k zX8EmKO|L9SMiXyqq|Qi#r+1J%TCSAo*fw<)!ivFfbRaE^B+`wvl|r{djn~$Iiz0=v zjr36^gR0^Zrpo>bXT)t#Q|UtZ7dt1K90LkN$oL8W1qQ=QLwY@U1%z4BcU_!oevLbo zB1!*+dy#AoGxMlkb3 zX`BZp0hKY)VEyQ6{}n2h|6R5h~(5_Uy*Ql^jU8L+C|J_JMhB`btd-ATcq7A!936?W>9 zNP{m!%mGM07kXY-Oqp6^L~2cFXSlI$B*FU_y6Fb=h}2iDfd$p30wlz zh5)L8uxSV}FEgWbWye8Au5dlv0(fWozCNBeWrh`IRrNOtBwXvUT1HkD=p^k9jdju0 z{yOv~oCLHuLP`CCLYs}bnC)ZJr62IeQ5*;QMB`t_9GUlx4)<7(s0xN7;f-=;48Uf1 zCc40PBiOkS7V)VaV?E(ZSgHF(q=N;2pXLD>e%xXu`nj*fF!{x%50SG=R^HM^$X-TldW%w! z=GC&<^)r|Wx~kzhbQSmhmYEM%wzZg5+tiGQizS zY?xp$2}UdaM6#|XWN_tnN{=#R13?)aErE9oC}M!obkX9Sa_I1|7-k2)tt=bN{&Y++7rE>6S1s&c zX&tyURB9+j7sgG>MAu&D7aTY6V* zZ)VmY3dvHE9ZXL}=`(Dk_|_7ZR@@;Obm;*W&LA?sd%HY?J)U_aI2Olm(M|Hhwe#eS zv3LxwXT#m%U5cL*+x)1I5D`v5+Z|Lok}&OWz1lVL$(CpDs}H%hEnCAaR)3nj@W;WQ zYv;?BU~T~yUcL8UzXf%no<1Mp+^rMQCuBxmWAE1(e|7nu zz0>*HkfohQX{s%!B|`CvY}zwN0V zmg65c0E=b*O$3-uk^YGsL?wDRiQ(q=7^`vFlgyG7TC0$~6NK?+h@z_OhuhVAy(^lg zy)!zH1=h&Sa!h9C$@k(Wg=q`PL?$kI|-}>76dbgvTQm`j*fNzWI?&79VG z7zr3fPMe}(Kk@DT39{XB5c}y)ajZS-bMFgRbUCL7Pm?IZItP&>6L??e+c2_hRa}`2fJ|hn4%I^yVV35OhFA`7x z9LaG8N|>P@ddO~?NL&6M{jlPfW)$}Ws5vg;!?u^*3hGgNf@Bs|cy*E%Zk3R>z;JWA zSXtwy%Q0jd+AO{*Ch&e%W8J^zV~q+XLIG~D4J9~VO>>1DN5mvLgd`NaTezgn zW$3p-&7g}z>K*+(m`vUb;JfFVj7PlJn`+qaS8S<>blpU-t)cJv-Hj4F4b}@0uB&Ib zh}GFR={U!jC=}x~XqYbBRvGHhedKCHd zMe1AC_LVqcg89=W3Z_M$E=5fn$nveFxJ<+}xUb;O;ydau?lAFugK@`1;8vT|Y{>;zkU{spBqggvL_ zP||wM)5ACVfH(ROM2Q*AJiy3Nu?`FHuRUc7UU?R!*#;Y_}btSt3{Y1NzY&ak0L^^b1zl@Mu?#(44qkoe|cVwN-O;q z=rJq@ST$mw>+`Y^mr3g=4rEIa_y`!W7OwGyF8ZUyB2s$*XPnC#N$L4eW97AG^tZ4y zc`Z-`BPb0fz~2Z#N+1@~EIF9j+JLI%)W#|cJzU8Ycu{o8rJCoRCHT@Dks)g?$J%VhX&zz*v$&dNxo-m+ zDc9wYUY(a?qIVilt@!8XF~euRidSIw=e+9o=8wA9sx-V@L)7uro3O>Np1&xGkB#g8 zGPp+_J-3RQG?NCAMJOUBzwTXWeCI;<)AS~l`knvP3BYX?E{I63I29Rmo%Usl7p1*8 zP=d*>0$jUR+&B?3!b^P%UzlqbLQY>l*3-RuPmxvQUl8;p5c_0`XVUE$*xI?T3Fwt0 z+@)O)8z43k-xc28Ys(+&LNB#o?-qo(Cd=QH$F(D;Drmyo`kQO&^-K%D0@>Rdd|dbY zyS~iJ3}){yVO&JR5B9l!laXfCXCAB*t-IF;yLmrSV@TNYM4*}(v%KEDK_W+FJw-<( zJ_rb1oqsJ;WduD2&agsJzEOKQ73&El9E&^4_boj?>Rp4)!A$91yCI$>eb4HsR`3p^ zi*9%NY@kiqz!B#xz6Wu{2`oPTO9mm9MFmv>nPozQ$+P&!o|(r=?b$Dh%5Cr~%3rk8 zw06p==5JEsG%J9}A(jckDtE!7(H$iTEzF2w2oZAxzFs_KJA3Lf+hzXPb|*r49o+@i zF2VQds@|fpE^CxRv+N&te@9XQi+uG1)13$8PeaLNKUYr*d>uI_y01QPCCDQ^xQ0w@P#L13L zTmK&6W)^t5SoiI2d?9eFxb0nnl^jZ8yVjF&JkiF9Xyv&&g^%?*@26!d+YoiWD~b8= zrMC5QJP^tO$Y@o##OiuJvfZeGAJTgjND2MT{_`2*S>cREbTck%$EI&MLsLFLO3x;g z$tn1>!N>ie*EQcrsN?kdfDol)Vp#t1e_FtPhW+{Hkth-TgMH88SY%13#Pr+D+%^=a%tK_Dsw z%F5UKr|@Zq<7}0@`Hjeu?n0-Sq%mdjf48cZBd|iR59=jz0yp>Irwmr)U8>u4zs)Ru zqki+E4eU1G<%;AtL++|w8Ot7AR7>xnVNb6I7N%*mAFJ|dFett+NqK<{z+ zSW_55~A@(Z-fHrB_O?q**OQq4?cI_i{NE(y+)E+;-ZZaw z$U@9F`4xvxw;YK9#TT`(x3RU)98;8_0Wp2gF`UOl)h@^WeigRU4C#m5*DZ&o9#`eX zG{^xveCms9A*#Yh?wxZ)AO7M2>Ah4!mrU-%%J4^2J$_5OP(UCTH9QlR=81yK2^Q-k zA+Oc$)!mG5*XNS&^IjL19FN0B(*8D|8N+-yAVbpa`Gv^1(6chLXvyua9asGliya;# zZP7##Nkt#FDEp9}&TkoDfdpG8r|Z{&+mEXvn6KFP}nY*d3M-k$v1#}?N@nIVfIxt~9EXYXm#Ka>RLmKx@&v97TDx5McxF)n8gxR_4%MWnOVo6YzW<#)-gF5?w9 z`0gtTV1F+p;@#>T^|ZG5S<7*?^_no`|-=G1G2Pjc?{(7j1b-uo`)~c+3^HY+blNg3d%x?sq+&y z5tXt4_e(U6-Ypb$#aHF$;e1txO+P`KXQj;w{ASyKHPR$-($C@IZoapRuRKCZ_y;$L z%hY=);mPuyLLRk8)SGcv9+%1UOP7_>!yLoDPVYgVGN6q=pOR-KIC>3)3D=Q3>eY?kPo{R)*;z<@?EPhrs0Q;6sVePZo5i8{rASN_8BhE$%sQVy-(wIxN%64rC+`< z3(&N>$myDH8wfrN{V1>EwOtr&5YN4uNJ=HeqsK#u)pdGiJ7If{ttRx|6_r#ix>@^l zrz#Sq{pP^Q?{VG4L`BVOd-wTDSNWRQUU+sj1e@ULpR4O-%UTWCy>Iaay|@kkqaw_E z73v?f9x1Df+Mn1P5g0E=A$bU-7teK=T}XZTP!3IgjLEDQBBMBxL7F*=AG2#B%Jjgx*6ebioOj2seKKQh7LH zyY$mTz2rO()YMap>%JzK?d3HM#BwLUKdiD6F5orapy=Xh52Fe^C}=#7V~u_5X|39l zYkjCv-0N8cOtot3ONuwm%|`p`2mszh#uM7J?~x~u01lT}1xwUT*>{V7M'vloba5*o#e5-;w35-BHw@KT(LlqC#@RW!}w9vhU*ae$Uy%V z)#vGa4}7JUJ8f@j5L5jRFpq~JjpHN2+=hz!&TL9nduM@SXL+y23&s7?#QmTX@$jFZ zak{PV!}G{P<>FC^dH2WqbSfB4+h9lH(2{bp52-Yn=`i2PRVDIFCO7LV?_yVme=uu@&i zPPE6jQ)&m&%V_^4nE0JRfbahAnjzP__|cXwtF0X^&x5e1{#p#R4qx#|?q!#w6=SXO z@IT-4=cbnFWAX|v&tTn2lOt-6_o57i zvuyKZh$=C@^oO!Kk|DrjwB8^mbj3B}$iKUr@OrHDPCGQY zE+zOL(r6+FF@1k$bY><@MKkKgm~^Izp!3(J&I6{L>Ze(9NQzdX7`-}Bo8DB%J*{=$k@-UU>oJ8Pd9;N!Vg_HOtw?}%hH zmanRPU@tP5&;(A2u_> zUO8M&1Z=^|R0#%mAlcoU+GC;RzX{Y_AAU&cY&?Edt<5Z2 z_^2f&jk-475$J4Q1S(D@;4daE$sYpBsLYHWUQ-zt;#pQGa$+nn(cUm>&*||XYc7}L z=L4&$4wN(43bpT8rE+pBMSB^`xpDU@tncC zprA29#uR{ZSQVlVPZ5Bp8ZPhC}wZwZyn~*+T4A1$3&scgcR=oE!N$@M6`|djY zi@5GmLq7^N!Xj5=qbAM7qPrxLtUiWkDODgjkPMgG4>clb1-E`VVerk8Q z>BDJ@KhHlTcWKLba=g{Lr#l_yDx31@7LRh{kVFbWdQH1%X^QN-xC znw{04LKxM{Gq23zyzMy9M>>Vy^Fh3`cK`r0l#B40do|<8ZOZQGzKfc zFx-w_`G=%kbhvupxH${wNp_WoSfe6Ul)1 zi|h=DX>wduqt?k4y~V3QAKA!o#cbI&m4mop{ZG#Xj6>H80#IN)I=F9@S|BaNW7o{~ zCV1d~OVo{aVevTB5jQjVCv~@{6%bl=S%>uL{5H822(2&?j~gcrP6&m7!j6@)zHZDp zjpSU**p?K)M{sqfm2OV?S91J7eB7HYuYAGTa9M_I(eoZLxnC2lgd3xQ$jU`RX7InG z^~U$sEVe#!&D7Jrc!TP~g|gN|%wh!!{~hQ6ol~aNY|T~cvqD_E-l%l)JY~fE(B*Y? zcdPUKy|3bzJTv4u>dcWv<&BYleeq>}tCtPc$aZKJzJ37pxb38g;N#Ix zJA??q8};}L0nVBQGA(v-i<-#t&#OXArYit@Gu&@PMuOhnb7!j`mZ!f;nzog$TNMkN;9$=O+x(B>j6?$pX9Gwo;~qKC{pgNC>$ z89JV}28ED#Kxsei(uxyzJ~T;IN8kBpt*+rGee|sN$bpkoUV_#)&!MKLx&ce2;g8gR zn?41Ar_%AyV=I+r!)F$-Y>s|0l_V%qA!gxtIUM(0?GQ0jX5%TpnODpek0P;P%?}B1 z61|19jM-^5Uxs@RM*jvM4kj;=O~?$?zLd*>@vBg5r;ukJv?bj8i$hxCm8NYg@q|s2 zA>w{7(oOc5vEpquNUI>7uVT1AbTM2Q%B6q!se0D~V(z?Im*=^ciBwR2*va0DX2Pv6 zXuxZYUnu>`+0xRIrYwSe*cPVD-U&Kj6_bCzrPR3fC=mI|IA17D-_=?<> zAfI*4F|u$JB8;Z?7k{F)0kg}&r_gS=Y`Tso@VL)bOlc4|G>SVw%=JmLMTb%kK}n!A zPQL5ma8*2K1#8p$9`G^T>sBMhQt57%J~6RC7~D^qn=&8GpQE!_Yq`4Iqoe+=B|nc- z`~2@kV$X&1mH4HdL69BE+r|E8E2Dr@K&%0))9DNu(QDkT5IjOnt-295n;FN%6gQ9i z$=+7S6X4is3ALtkKPd9j*K&+ReZT`cg!So`B*lpv4h|LfE78)&iKyMMWovyvMxBgl z=xKG-qC@79|HC&+)7QIFZg@Vmgxz=4V_2KuH|tzz-ogSEBkZunvDH6Vw`%>PA6;@M zSy50M1vG3QTDLPTBQ6_vM*q_SgkTnNHh2yr{_I_PEKNxPssS(EV`(T%F+IDhm?a(V zxEJ>;Fln}K>1HR=0J}fVpDbvIm=NDsfP53YfyE!+EpQai#D@f{h*Bgau4kCaCX9;EOzR41oQz^mx%%ljFv+$x3Kq1T|a zK(#EwXsbc+F{%v0gYk-tYvB-a{%zk3`&Xh>=mN%YVP|Plqx--XM?xfA5wsG)vA+%`}m;(~aaE(7K|hJF)t_5czRVN3Q-t_q)pn@rL7Tk?%_rR|jg(OXJt6 z!Y$P?1H(R0CW^rMgvgfn2f(dP?8R{~?^gA{+h(IRYYar@W_)P&0+WMyI{a0tp6JKW3baQTiP^2`+XFSd4xb0xD+%awT|8nT3L*V-=zY6k5=5S?jhmubrK zNk}vVQ-Gx z=>JS}6dN24QUc|9D^d;0mXFEc$Ile>B^%7s_o+r^SBR&bV=}AxR=EB#1}`qyozCnH z`UYjJ!7%BJVRSw(s-MLNXy0qcdv@KOuDOnQod;}^+YsVh0oxe1?n{*$~eG;Ez9S!sHB6IPO6k5}-p%Mbiy+(X`73yrMk2rjv z*zR5r(?eNg^QlxkIr{uErD2$IACFMPqc1u>`;T&9ou!PGvumtvY+D$1OtzQBRIRl~ z85E3fsv{QJ3hOjLcm`2RZhqNBrVAP1T<=3NBwk%=Tvi9oX>zz2f97UlBY;joY}-&i za(FzIfO*Uva-ZMSi4k_MRmjpyd8j6YNWtlBDn8T*7sp{dugTJuG1ahMmIsa}JrIAE z-jVrcj`i`*@T56Rqhic9T#!?LQkan!1CkWF1Dz`BpF|P427ZA9yHkMVbrVC z#gMu9DNB6Zt)oNT1rzR2-q_?2B&{RCL81Y_vNVVdmrsBeA|@9-e3$bH8~%2YF{Ylu z$TR|P$bi9`xiRIC(X(ai6EPI^?0IMpmB3j_;6vIc?aeFKn@`QlP(UJNco}>NE30hW z{~B{YUz6r?e^-|{PlU+Dl)>Y>K8E~RF(~7?hfg0iJ`l@8_5BN?(PBU9BLRi^Plsa%kS#D*}3*w>&5XH z_t)nmp^t@+1nm$YU2Z2g()#X3@LAhY-TtMp_|)WUvyibK_tS(^MBU*x;%#pS8bhV$ z2~wCKBz-vipy}aW-U)v(f^e(&EkF^X?{$fRlGZF7Ba2f9xU{oQ%OIyh0E>fJvt%%- zsaj;4PWV7~UmmuQsLoJi2YKzwD&zwb$qE=eq~c2q(4E>#(cne0OX>E@hh#awp5bweQ%n0o1lRwKuN< z+?T5M_>7*u_^t=b6qkOBSQsbupKMsD;4{puo@h1Ae2k3bghrM*FUs**@BHbFg50Sj z)@9ho9$p?;s9VZtwcSK)R%PY(ox>rhmHCJCZmRfp&VTz zD(B}hq}G4suOmJGo676#U%%9tCh*s0?jl&J(XXqD>v+uC2uoV^@jT5VsB^}y9D2k| zrAnY?jf&Ge^BUZd&A!6M!3A&G*=C7RU0w9V_el{hr9qt#ZnO5lAlevLQ8YGlP8w;L{DPR*t3_no*1Hzn$UClY=&n=5V#d2!R+{U1>eJRsNxWe+VeR34*A;z z|9#=HvBcU#-)IB%@o)OBcAYa1^Y!Hm%@&oOcQGn>2me&p3r-RC%G4$q;pYpu)4F_V z=b!SGlcqZh0m?bw7i64=9y9;au|V^alUZfEw(~`cvli37wr>-^dy|F}0_XrxNpmX8W3w3#~fEUvZ4q_<&nQp#Irx0@~WrXaiy!dK9Q0Cw;f z6AH;`6BOMNKA~#K`f|J)=8Ca|<4f;aimo%-ukv1yezvyTf zl4T7VNag>oxWvHKu_9NV-QzRtj;z;mtj|z_u%&pYQgsL7WU}<_A26i0I!M7^(aJn> z%SW9c#Z^&%ua08Mq^2Jcf(5GPEaX+6c-uSg^z`t5Ih$`1OVrd$Ii;~2msJ?PBqsuy zxRyz`$a%@89DuYVX``AImBQLPQ#OdXD9dKLbyoWTLkY>(SQ}~b9NDQZImsl~2p?^u zg5#zQQkm)~DxQGhuB5MZ&V^sdDwFz#_CLWb~(lIgQ?VQ$vL!AhU#s}9&Jkj0AY z()sm#6EmTx$)6)pnC*l0c-Sfr5nt>1Uw=QS`y?kJ@jCHMQ&cLuHwDvY6aVYEc)NXr zug;IU{3PkkQ_S=Yt~J8E|JqA(U4PT+V;}ntJiVl&#pwMf#1Z@{#73^6oQ97NvVLu+ zK7J2VSxjI!FX>^LQFg6`6rN)Xn~qz{akncqV#_P-R(jov+=7V7-fWrdZ+`-Cbkzwe zo6O2MM}OekntQFYzh=4?N#N;r=2l?ijpEtnQh( zvk+}C+>?Ujm1?o?e0DXtoA#^2G86zl#d*}i>%6)gRe9Jg@ON2JqyjQ z=v+E5JARiB-@=3bq5VBRf*&H|sIAgU_xPA-d-(p>p`B?hFQJqwejhKh@<>f-aO~@u zRI>po_90T15lFSmZd-U=LR!wO!2k?j!8iwHQkaAf&69{X8;z4Zk@^_fO&5 zs8gLqy8-C-<$9Pgsyy9IZiscEdXFezIwlfao3Sta6-EEaDrXkr?@W5?M+13UrPP+L zzMmITN%`v+Hr%t}aHs)Gn~pI(*(#H25dr^c%#K@g5%L+8ne`Q;>v5s*oLqW7az?AQ z-QGLS2~A-(qQvfSc}jatG1JZ(P|U8RGi+7rUwFR$W!+K+4u3t)^F=ddwtIXrD5>bJ z=gzwpoMY_&-h`vxrxlgiQyjIxT6W@B861MgKj6j-h$PW&O-%l2IB@pSmF#v|J*@+` zW0iQnBhGAko6GoLko}n35>s-d&A@*%;{uDX4)qUnhv~3*xBlpB4OzhP*3Eok$TEY< zu5_$^cGwPCAG9b7Nwu$>e`On*C@AwBazAgpQJTP?h z?U)@diE4!a0-U5XVc@Gv%*~3vy;+BzvHwV^ z;t=RMEo$hn)o}ph9so>T7c;#$1RKsygrBS)h+b^@8&jfZ+|J!{d~Uv#ufn#JgdZk) zPVTl>U!2d~&-Gi7w=S%E+y{S8p0`2n+;yKTz6p)->Nu6}1y6NCo&v%eD}daV`AV|S zqeWA}kWs1KxTULsL!x*nc7r|n7cy;`s6T`oL85*SP33Zr^H`SCc>6{Vz8{7*&{=iD z_N&C<@b6|C)MYT}Z&~({pCy%?;ddVM&z?W2JSgS%qFQue`O^*>SGj+jQKd(P2ufLs z&SMuilWT%Mp%m`CR|@Ai%b1RSizBTg%4JXMiHWcTV@P92i(AoK^lS1B+0yqLjpQ#` zq*?3EoL@3!L({|@8P7vK@dOViBFvU(WCBfyEI0)Cj*e4HVVa9;^`Y2?)Xbsh}no>jGkC++@5@`~GVa#K+&;5WmRz1is zHSrM$cd!Ik(B*$u;jzoTDf^~u)SFHuzy>-BcL;gfha30JeuKifTUDL-|VuR^bTNCVjcQ7ZfW@bScU_IGvBIY~;~b;nIv|0n ztT7e|v72z$&nN5zdFR29^pKwA|my~;s&=ypI_mFDwQh% zDP&!`Vu8?Vh7K>PYqUeHtz+t~#y^k8)a4~m#)29#d_JK8@!&d)YgKj|>Y6mO@1?}o zqqX{KrZ>a=w46zvRRxOR$QG6B`DlmZA>6-%)1^pCfcG}W>8A~i|0zmqz4DzgAPe!@ zPJ!Xrht{~?okD~5j4Vsa@rznH19S_>{6hT&X?d-r|C&gK%=lIyclWQOK-_P$Tvb)Q z+@&d(U+`Drck)(ZrmF8Eh<;oqMq}q{=uuwlyR_~C&vAlLg$3ux)+NPdPjKw@YZ<3~ zVDn8=@KOOt4noNk@O=F8(z#oDR$J!A{|LXqjQ!^Z4zwMa8fG0K*?UOp{o`ukF3ZLs z?+p%&+5cx}5f|h=*VODP3l-45@)|@PfO0|m6>Dx0sDW6n3^|-d7IPF=bn>4ug9WFlbUZEoeowcZU0>z6K z!kTqkjGq-}+|~3eLtHFr`7%h>B}4W0qF8ad>o?;PdfbVMm60KVs7=B zdNYmXAmsmz%99phm$NrUB!`XjA}w*EDr!QlDor_Z9V2;peEn=t1}2b)4?Nr5M6B`U zq2`EARCED0WQ66o_E)GGdwntTc)mj*)`bJx?2&1iq2QgP$Zz5|{{kH@YoH+P!+B`?eF_Aosa$Hf|ERxM}WIOZ7< z#x(pKPK|?rSocWZZE+Bzz9JIEM`V&c9`U@cra>HgBfv-TUXK?{jK=ih85QzsQSt-w z!@754RNS zM19pikD3ih;mNEMXMD(6*Bp=ORy25phHhFa7R-6Yf1K1h;3Z<>4k1t+c6Rb|XhcWH zsakYsK(&=a;MvCcNsCxkTdVSSX9qv75^mVs?zZl$auI$cRH^i2xt{=|>hbqB#~i7| z;$*v9d5wMb*G8u3h{m@NI;?fGURd#WJ0vFg(+g?#r&_|+JInJIkYeAI4E;{e__XE8 zUL9a3v6*+=W1doW-9n|`TD5M(5I1+Ab8S4`;<~W;4R%WX!F;U!F1_I8VNL69A`RN~ zUBaK?;eY}(H{tc3b@P6v2flaTv%%>z<1Z>h^uU2LQgE*`+oAGC3EGQ?<$1GVxu0kwJDWQkwLE%H*$>_c7-dWFVb%P)i*LgU8XXs5iXRsm$k zm-;(mH@h^zF08nK^TKX;BkL&b{1B;I8P8%Up>Q}{l({Qw?85WkOMWUhQ0f-nZ&E+!@D;=3?7_kX(>_eq7etigYl*bQR6ud@s ziO?IJ@3f#Jv@AY>a{Sw{RtmBZ=e|6u7T3*p(C$|WemyFclT53QuQ$muMnsubgJ`W( zR#gyJI~PaLPzz<{-n}hYAB$@9aA0xL?x3eGA1wNE`?R=_<=fxhWFWfvO{?2+)!`vl z)@lE1jo+o3rl-@R0&kmp$JfaNTWkKST>0ADhYQHRBOF!#e?mU%E8CJ5VIE`mG67fH z?PWwU!1U_5`xf@63yqg|2Hhv#O~UYPey^!i`%e7g%$JI9hD3}b*SA=8Rr~kTJ=wyF zK2x7OL;a7^cEft3P4Txzv)4ELuayKi0?-*{`QU%yhNppRL~OSL93-Mj!Z}aLv$MOi z$8KO)7O#KD5oW4T$Rfc!Y49dhz+GPc5d^MI^u&evcLgc6)yV7=h&+p%qz^l7usvn& z*eWqXB&-pJ=iKSzT&}A4IZqME(Kc+ho_v~m6dDreMVEgTb66uJ=^w&n`1*6bT;dJT zr--F4YUAI>=N?S4v=~`=Y948m2&wr6aU773qdIc2@6{hkfmux@2l>iL(v`MZL}}~* znT%g6(2i@&6(_1t1_bwH9H~$WU{NOKC&s|7Wa(G#-4oiMLaU4hM^Sy!ZC1thKk+5R zv)2tCYPhCZEfN-3M2vniHCE(n`8!1QR_0YO0D!__YV_*bEJxRW7ucE>%rT+$b&5rK zK98hkY1q{e^=4UfC6F^*`~BNp7T__kNU&yqTRomJ@1uHEQ*d{^Y7X!FSSCCCK4PTH z(V@?HkiJU}mB-7Jp*_Pj!V-3plfkD*uXiH8F#}srIU|-8RFCfT<6n&$VqL6p#_QJJ zJYvs(MS-uz2R?p;!bOV;$PT&QT_2${nyQHv{E^q&$>D9=SH0|$1T`#H>$a$Ob6-te zgPSAVP3;8QVJjLnQU=;mFTn2V#ODUaNS}UG_@b(J<(crmqoi*eEyvMzX^B|QH=cFP z>$nV2X1GZPHA?nni0v-536pfUqpIPX-CI_l&-x2H_BC4?8rgUP?*CfMnRrdMH|c{u z%A8_y$vsyA&6)qt%AOl>WcVnln8hGkMu^A;a8qwkl9v+wVORj<$9*>u#NILaG>CA9DN@@|uNYKh0JqWzg#5&-u41Z?yYa_Oa+1NP~>jOdM(r3EuY` zv0P&nz0O)B#UioMv3oO-oURr$Uiq;V@BPc~$}N+DhOd~{&|yL>lWDg2Y{r` zKO9JkWFs$o1yW-oi!5KWDb$PqjW5!0{XKk1*pNnf1!d7uxO+V!+|77n1^pQSn~|eV z1sW4;p`7+A2}g-m3oUYwFNWm){!cJs{%-`RjW17y%n5{%Mg$luZp7A=*F&YWe)tU{6I*;OoitOb z^tPScS)h87{cD_?W{N+&lT7dsJ2djVsCIt8^4D!OrOS{9Y`J*Iaoyr_($7AkDdjR5 z8^ca{*&o7j5qdJ&D&(<2gmcCN?&QAO!UVT89nZmH3);a%%GD3E>3cb0u2!ipesBNY zwD25VksaL&BLRNd3o{vn9et?% zCCWr#!`>-)$`ZrRYq5aADO1d_4jrAr`Yi{~F4vYxlHc$PH4BOP{|+c7x@|X9bl!+J z#>z%$p(DiRC>2xzVUPgQ)ZcuScv#ex*&RsEj_LkjZs6*rXG(*JlQ90M@M4fKHbN}A zv>EU71=OR0Gyz>f-7@kVKcTX#81ZOtmt}BmZAzSkri4-=#*12|h)+9<+P;C($EKb4 zw>z~Kc9xbXUcp2(?W-oIz1IczSY1L%{`Ruqh*In3ZxHl#e*RC1ViX$sCo?99930!? zML8>>jk18i4s4(o{=1aR)2Lv0yOwJAwrxy=8c-juC8sh_PmP6o!JR%KSGk$7DQwj2=-hIb$*XpnakN z2_c8ohM z?v#}dy$)-U52A(r@6!bI;c(i1P^R!x&wkJ2?q1Gf=Zx8XNY1nbd{WMxRp8`^aMK8X zW>J)Wdz@=l?-OFvYPsU{yJcqHir=+AULLn&PghHPonSjJy1(h>bum_7=$&4iLqCnM ztrC4%LE3S}DW%N6JCP+acoNsO9tvf>SoZb)1u>I2QR(y|NtXN(^Z!~v51oJDw{KlI z6ap2S8%~??cBpKxHRSnK&h-+X4;y^h8#IJ9e2R)7GMJTH|M;)61*(PKS*Q14`~8~Z z&vYBvJI4-=1ee63E1CK)!)7jpfxMmWk2qgw{-Wyx;IS3*1n~uzsPGN?&w#r{N0bGZ z--AXG`{-#|oUg?A9@^N}`Af(MvXaD8i|rccn*E-9!5fpVEyExpPm75L5_`l436 z>Fit;JQxcki7mxJw3R)ULB#vmt1fmihG&N3Z4ltt!@VF_>th?$TSyLdHmCR#@{FjM z^0mDgaH-E&u!XQO%F_kIFgxn&v{i8<;?8QQFfx5uC*-pH+w@-`mT?MXDORw5lnr}w zl(YlckP73t3JL_$?f=BNA%-$ngblA1^uE9RZ1x^haAU*wGqwyxR1?RNKIglL{q5^F z6qAAg@YL$&55-AiuPbOg;xRQO+XsL`bC(Pfk)$%)nC*ZWnCdk5rg>{NVj?U$d)^&( zxOpkcg=UN=EsAZzvGcnr*%T!8G*X2M+jcHUWCfOA!0{}|NyIYI%d6iU4-TMPRvNa;9L{4nZwE8oJ4NXx7 z*DKc@0eY{B*c;a5J(4@MD}~PLVD+o*kkx^C2=Qppf$!x$D#wNQRpYmtjeFw>KN>F# z@oR^jp|ESW$M8RZTS>~qyEBKMC2)7db+m4>JB+-x#eMGO`RHo%Z(D;~fGasH;#6$j z{}4=iOID!(cVi`Y9`LjDo*v_Z4Sh%Gwzx#2DlzA`8}`V@6f*!hSZA8w)4ZF|YP#=F=)mvc0mq$dy2r4BJ72xCW#AcPSuE>9@ZR?1Ymy<9%MVehdFe~i_WDSL zma4f2U~INWK;ZS}(nzoCU(oX*mxn3Qvgx1G^}{VhRazd24A)=I=Kkx&HE83sYSXXT zG1m*3f(2@lt$%kbOH{1CM$+1AT4cIKv8#2sYA zA8Pi0wxBZZH^qLS0_1yoOv~^AA}P}h9$UAwwKDN{zw=H|#z)df9~rEol_OYb+|_F* zE*~ur^16Vha&I}`NcO$Am_oskVuI*5 zx3Y386^#~d*mGGnkW+=qgmDrViXy;2vZ{Jo*I*Y`0!pN{uZtrPBz3C)bjwD&YN>+~ zOEmaWWsv`9j269|&j+^CM>k&b`9#9#;mz zsa@DHN&~k!_VT=ULwXMGV?B3?XEy0r40_r&7Z_W$8xmtLHNU2oilEF)Q-~_mYW{z& zRcIC1Dw7x_T0RVJwG!oF?$P5xf=60FE!H=x{ZngyvOTxnCG&G%)S6}(ChexL%usGp z*(Q(_f=oqg!R1Wvb^KeO^WI*rbtB(>&FdcNk5zcYrAJVnW<{0#KbyjBz$>x^+mPPt zZp|kcV~6wd^L8^p_`2=%yeG`%k(sHu(-DTl&g9a(r%L6kxV-3@(VFS!)1r5?O6C6| zW_P6I;!LAKzqH{Nt?w=Diq>d;c2(ne0-C9+&n=}iaK zq;UxA!8!B2uWF2D&xz|D_RIBYXL{VI1U!E~Mfe}?wFiA;Uz_n4xwFM&nEZW>CvV<= zVYGgEDo|LZJLjnQa(fkAymDo@jZ-#{g0qj+u6~ok%C|~5p*?S1Yp6K~GEpY6zD#&L zv!kkaxPsnMc+3X{ecJ>Wd9@!nLBBCrF$Gs?d;%Cattat}={x@8a7_M2)v;e)@^c88 zCTz-=vZ0|BfA`^YE$v5_p;v!GJ0Fx$i}>{|vQK05O^P`=vX;Z61T@Dn+cb$H-|gXX zSzwF4!*+}m6EFIL0hW~!4t5liz&IX|r~?t$&5jh=J2l0E8yN6#%lVEQBb}c8aaE3ymDEe65 z`soX=J)Ph>!Hf0pW1FRyos#^V8EPsji*|)*Xv^`#!aBGBWfs zC~1j;zo{fbx{)2;Y;PKoNjmAR+k$>wkBjfHaXH1($rD|~r@V!T8V%C${cs!(H$~Y? zucKvPUs>@TF4CL%?-Z1#&wMVIy!dJIphbU$Ad}W;>Oq?keD$K$Rs~C781cXPFHI&4 zZ{(f)&Dt>NIkeGKe=wh#iC_K6{jEsYGef`V=F>!){qy5E!XqanXDL=iUov_wn6OaJ zKb>{IUI);4GL7cN6OVo|-~5U2$$5wNkDX&ca$+TOw%hyz_Vo2Xl%#h$^cdY`&ND0B zo^F26IT}B+&~toyps@aJzxrX-aQp+}7p}tIkY2}4Ph&YQpLlZT&FgKMsC4(I*|eMc z7nzu4-+SCBh+6K;;0{wG=@eX1=u}`QxO643;)5sfP99YF?31cEp$oi6R~QlyKe>}A z`@T51Cx{Z1RQCqkk)H10-&u9f`AZ`Y!AKQ!^X8ayQx?npbW)v?f4>8H)aU2F2)SKijegbbYuk8I&u#j08~X-Ul61n|=GRH87ef5utHf)bvH=!C`eDXT!S%{yMDj zSI0LKx>5}(gojR$Z={)(On9Za?H@51+m74*t?9pRU8cqVQzdhd{RK55qUe&@w$pH@#F8!=* zi+%U()bXtttscGWU0Q|RN#P=@BFGDpn!M)H6X;jNPgKIr=KTtgyWBCOm1|DfJW#3% z`=w;Jqvqih$L#A2ZJaFjiPws7@6(7Ci$iY~cU*gm!4|3gM5lsXMctEy^TyL8H8M^Z z#D1(@#g~I0Ft4=S%NRKMI;8$z@zfzlID470SdW+X(A);*ePK$f(X_*jV7=+3j-qHPg($o+c z_iH4((dNxU_WeE*C#t$OpX)@1N*q6s)q`?oo*V~m<6G{3q+lOQJX6G8OXn0T7Jb~2 z$jP-qmAaOkIqb3@AmGJUV{Fc0JTnpS%7ggC=1pG;!O81V+pF5W?<0LPdb0s^!DjrJ zs))rKb$~mVj(3b17P{=V==eUHg3$ssA{!TLEyovWk&yh~%DdE;QhfJf^L~`ri7K-t zjLCJgrOz^f=>)0`QLjh(iR0zQM+7rz*O!%iHLOwya-X@ptI(azql2E~*{MIMjBs%# zH9(wD!zxPfjEQxzpnvn!kV809IDNmDSwtNBhlYX;DV)wKehfLW8f(mc^c~y5ttn0Y zna#K&*7m#QI#dRudRLLT^T#n4;xE7;Dg4nCt7I*X(L4_fw%9?18xulaCB;y6hguPX z_{BI6&Aac-_DoA`mOP2eCQkNU;zpafp7^&?nE8CxaZX^ z=>w*xa~B`-_%%6_8abeytek~w-Gd^~Vu(ABJ%y8^fjPfJo`Teetdhf^vOnl=S-eMy z-9B+2GrhBGLaEVJl(hv29u9{V#bWUV#cm{X>qXd%xAhtljq7+b5VG?5T%*P*CY1GJBmy7 zS?%<;PsksrY`kE|maJ8f^O`T?Z?QG&EeSHeU3`f@FT@J&eY4>|Zp}Urt3bQBFTCNJ zp-=x&X7RP>qSkW*-?{u_Nk4X&e{eER*{0i)L6xz%9-0J9i(^9PS`pqf~g^Q8A5n@7=Y!z*bSW0SLA9D&1 z7A7ry4NwT+x8r70kDYyN)!s)ZZJb!|+HgCp%BP0OaxGt|OuA7xDU?NGZS zON5cgX2akObrTTNcnuT@K<5TC4ewyMXLfFf%FymH7+~*}zJrJR=prqrGhF;qo(yW0U+Nt#&VG9{{tEP|x|48FJ zd0ZL&UdfJ0PIZ3T`<(;x_&;|V*GGj{#&F{1h5^A{k6ngW_Yb4f);2k<(b;WY(epNZ z&@aBx7gSLuULUhbW|0AChX~-3NA?9YEsUx=1s{8KP}Ke4HY4xAm&U)j}-PQk7E)<5)C7T8yJu-65Dp zhnEL&xCAZzMnMM?kb81c{naW+nD6;nmpms7eajvyNOc!FP_UC`&Ra+nntQ-8*8qO* zJB5qFQG0niI5f!{ca!102D&4XP5j||1vu^@lXlH1;w%y0g_oakzkL6d z2;fbu?{-rO%VwZ@dpPFbK0(ua&NhTIqe~D0KID9HxxDDlovGhyk_*fB+s``}VyA-5 ze$&DxaV%SL7ww$ATu~_(dbx*GD|-g41mdTD#C*x=;(i@n-v0dJ$u0UjJ|_MZO~z~5 zpYIjF^AH6`T8p8+{-#=9wNoR>%GRWr{8%Bwx}pxNAjGZ8|4mR)mCpj#KtVA}9e*G2 zibm=;3yLJy^|QVIUDdU@jQQ}LNoQu;_5L`}d$QxM+j+8UQodr`;IxpsW!>Z^?a8{| zeOa`+UD}WHo+;xxD$^0@R8BSCx*e@YCR9+Jb=|lX-V66qOlz-&A8EdyJ9F%3uQ6`8 zFFJNN({s3{@Ga8N&|}BQsWNdIFpvo`RDFY;8UM;&>WP(6-zu9lQ-cbeF52vz9J<((4rZQeQly2N>~XDj8b> z?;=ZyiS1X_3$+xK6i%iL*H^a1RF)Kua8Zlz$C#NXk)rdWEt@OWL~BU4%_^FilZ!?^ zQ>)R_8zceo+&`O=PcwXu0`2~=WI+5 zNn_s&uX4;Tb5vijTC*YOj2bJhY$7%rmk-y>sGDRk=g}EI7=NfFpUJT_0fde-r1}Jz z@k5d>iHj0FN9aYHAKbX;J{q*K*<6#UV3XA7y2JHkMwqU#>1?VQp=JCDb2h}7oH|)5 z-So^nznV-J`s7mVTa|UIi!U^aSisY2ds7qO`XaO1UsB}S#2JJmOi`zwfZE)}02eE= z@p@-6>!kEmXDRfI+Z-(4*FaM`GZ=mtB}nM&N(t%mz*1TlYWrRG5N>Q95q%Kk{j4<^ z%w_-1IkbL@wO;v6r3!Xi`XLF5yq(*((4 z5FjZR1KX1-#<5Y?Yi+2RK;U0s1NOO@J*DPPie@;(J<43Lgf;cvuJ>lsdv)Ws!Bt`? zx7Sd~YSbiQRr^iAi{~K{Cx-EKY8ZRdkzrVty7z&s?|EvC zOvy}-G4wp={H6naZ;+*fkafv5^pui(^{{y{=R*!F4VrQISvH@)PLc0Xhh911%mTHE zzW><_`^(L+!EJeZl!58peBIx2R%>W)OU~0K{<8%;;9~7zR0HD?@ipUg6HnOeP~Pox zUNMTB-93A8Y^w7fOZ4-+@O0G6^~~|Na1y$6IZx%4I8jd>D8+C;GGDjI*)-H|F@2Ol zQJDs!GWNMYjntfSZoMb@c|MVgo2;_(-uOiM*O!m)!cI(QLZ#a2My)N)h+%uDDhJeY zO8Ylgjj0iGg8<(9c>Qug60p}8LF&m`WdTx zSPwR%0`sT>rfMp8U1)m-BU;K%37#_R33ah7W&Q1T^$GLoG%}+L?AIaW&eC5IFxgHs z-wtYst?7*EhIn&fW|)r|)%&3zy#3LQoCY~2duuEpRyyl$vmWFbmZ`LY;!HZ%QJkbi z^R6LZk?=aJdUAy~!wmXyx*P}A8WQAJ4;&AEbdduc&-&71#d~^3gNj7@R%?3A1G*k{ zW0H5p)H~$W`1QJSC&|NYx_Ku}hiU0LXm=?CUz>OWjLGO4lc-IshxkTpGJXju4U}z! zg0pF@VG7moz{GmrNYOYGc__2w`R?2>eTV*}A#i9qiUCF)CCdZnW!(MTr2B zzZON&cs#V4Mws0_(lfD3>yZU}R!48^1kGFHS!zMObB{~^72l(?CaFej{c!ED-X5Q> zm!Z!TY?(rYxZYY5=a{IX1IO2B>Ev?KM}ohrWD7SaMvy6sCijv2gou^B?INF70fk4o z!z^IeyqM=?fiH6EL!wvVa;eFeDLk2}rq)tke|-INbg@&kKf3AfSC7l?S@w$l2={`C)k%nr_#<9+2y%@73hnr`xg)`6Dd|>!pOQMj}{XPo@Q$6 zy=?hONS(dzNZpfwFt!PLtDq#?#Jc!<@V4^AK~j!dyrK0?eoz=Qr;(G@(R=VW`X0al zEYd-0T!UHa)bw*;g?=ud#@;ztyjI4}!#!Sh7rET8LENjG0J*N} zZs$rG{u=c%u73jX!*<`k^|FJX^naLF!?*WQ&LH#mAYexa<%=!~uvuGsgi8MTR7y@m z6XL2!wEi=U|DiXUKovNi>g_9~es=V=r<;E!(QL-d*YB^sxdlO58-`RWjVm7O8hT=xx zGC{$Z-dwvw_V@afHX^MiLK->x3YPKELuk>yz+9A$uh#yV zhunVOs4_~Jw!!|Nwd3he$J{`xucb|ui^Wwehq?ZFNtN1^=X&Oqfh`FUX>H$O9x?YL zndW-f^_tkxV}~Y}9>bLRdN-TB1r%WN@wtzF=4V`{u&6-1{g zjyh@?KrW6i4is?gymeT+cB`2f z=V*g)My6>`wSu|4J3!o;`**wfRDUm1?m<}}Fg3rjEPC5hGSN|f2C<@-#6<0W(*2S- zrHu-tBizJG%VZRhpvcOyj8>hK(-*CX*=U@`Va^zxq&F+}%T%`h#qIP-;F=7IlOzqP z1lh&!3g$hOk;G&jxo#i2Yx&dG#OPA&@J83SovCVV0EM0CXe23E0$j-A#W!&0>KFga zPAZ7=<&{B?ZY_T~dep)`;*!T(jIB|zT}GnZL3B<(Iz_YG zqJ5<=7Gc9+yJBHNn*W}!`FiLo@82H?kZ@_5p0S&Uq)zOYKF-yJO#cfFAKd8NJp_*4 zB$Vm+r1>sDC47MdXv@_g-2)$j*ZOYSoNQJ}xK=DM;5Bg5S$@%OvRjY5K3!{$P+fd& z;coxotFD*d-O{&0NWqo0<){AQ)+uT!*V#UPF|{km+{b@i1!!=e<)(_AUGA z_my$mYzdXznX&bPXYM_0rewD?ps#8!l1nkBnXa`dqJ>2k$&mI7bXD&QOx-_Mj)y9;TP13`iMs!xRnsLLbBemn zC0=#P7e(AZKn*+NDzb7CC%$b~^*jZ_eiNY}Jtd$X%MJD#)!Dlr0}clk^KqtssGA^< zC28WUzv8iAV5Zu40e%Bt4YWUHbR`Rx(aFmGA~O@ijh!}NcNSMa`XN2oz6B&NVoT#< zFd5NN5o-4`suWAHF$ab>TqhG>LA)+$z&#q}#04zR;t%ap2gu8L%pl-3tE-jbTpmw9 zSg34V!#btP5q&vc8~;;*twVGOFIZ^#ungkN!B*u^}blJ(_;W0aJ?K?^a1#W>9PYPy`{L&{^A$U4mK0PP&J{@8of15Z`p>W+ zXyt2UE12AZl%AuWE0F`d_iH}@FvO-NWR#-zjzo(Box9<4Gcvilvk@A7uj}^3v07FL zITU!E>8oTlm}efAngw3#Vq5a@)h(hl%XH+Li`wp)1(D31ixRtv*n-d##^eU^dsnM@U5oLFL&NQ|Ie1BO$|sA(1zDOB63snxBb51bAk#MtRuu~5HF?J&uj5DjpIbp?r-j0 zquwh{x$=tNmR03zza~*J`_sE@-M|)~;mEs*qSgoWNn5$GM$Lw$)>BT!yI5&NxudIar>x8mRgf8A9=NRfH6Ce!T>lpB;JJY4y5z^$QTe5FOQY?(C%33g%x2tC%auG_?RUVb~ z238eKIpAj(9LCiW;z!aAqsG77CT~vlRqLb_HaM;0NIct0g%eN5ef`>cK9Z4rx<=JZc&_u7t z;I!i%#9m`UzRY>t8|997irS5$vxBddr-b0*9d&b8lFoaTjL*vra^16+xDc7iQS8CH z%&G0U>F;MaK0=Q8%tA5jd%Hd}(ZIOixkPqAox;eX)5(=*4lfKOqY#{YHOO%4c$LtH z5fVtfPn;uYzyy)BNHRxoY)O0Q@F>=9y|W{=&$_jSC-hhw4#venWo+ZJ@Dy&Mz5nR!c!dm zUiQ7j2OyzaP_xis-K}fq)UBJXEhNR?N>#95!M$qS?P4aDIcZH;Vc?jEz0<@vQmNJe z@|e&Vm1766Khy(;UGw&%K*Kx*lu7@58szFh10Af9PwkRs6rGI>Lq5~=W)w6pm5Waf z%}jbkoyVLhx7@`(Megd4a&6}+Fu9o;WBp$`H_Yog-5ZG)NA`}Bi`v}swgr97-uf#F zAfJ|I?QGVADo`mrFk5^kZs5EC6NV)D;+&6eW!seFW1o7kx_h@%>c%KYYDqSXAHF06HiNN|%6i zch?M!bW1l#cXuNw&CuQ5AVaqZ!qDB_-3=ml{MG-x_rpCr4|C4m`>eCp+OcZKmaK7> zM}rdBm2BU*3`sQgkfJ1pn|%v;yP^&)b}r64b(0u@mopJn@Oq{1>Fx|R+A%wbzVucU z4ncJJFYHY+4DhJsZrS{zjaZZVKSh?+DQ&X()*uc@6j)~=}j`C@vcQ&*A`NYEb zD2TV^VPt@LKuqY=VEIm54JzU<;Wo8e`fK@+Ji{gh$1!f(p9?L`xLpbY$i0M7@7UrsLVEqT3T<0uQidovW{1sEE(zKqG%Ob6?tSbu8?uNCiR8UuT$;jQ3w9I z*ldnCA3MXkBY&u0|LdV5`TO8wfZzAT zEI=Wy#(V;4CM0C)Vh?wyFuf)qG=4i&|8A76vh{b-YTj(9MLY`1wOhVO;V;w7ZhgX< zxtc4=CNDE&o9TIG{qCBfe7HZI4b1xmW&7-WgbBzZ5*AY2d-pC7l~~G&2-xeN+Xn}M zB!$zk54JH|my1pl$|pSpp;Pc(v1KrqI|h^u9kSae*5gE)#CZP1qAR5s#w&Rgq&-bD zRd#YoWfFb7s8yV9Mk=p3>JsVk0INm^s5-P9sb84TV5$5*_})vIei*pv+75Cx`II=# zM_yTXY+|ejoJE?iFjqHi*9R8!ZrB_^Rp_5&)KT|0NjxL-`sGUJ25znoV-BW2QOI5v zD)gZnzj>FcYr?MisyJgvI;n5F$EPwRVY8CmlHHslq=wn8Dqw@!xq;oDf#F>1f~#bk zz~mz4l=hPN0-uPVC_D5QdVWyI>b5>RxbT=Uf{W_Z->^!=3SO&m2tD1t-b$ce9|NOk zM56?I|5Hm|cRe6OiQE0PZUF>>5MsB(d-^O!+?CKY*;VK+8_+iB8Nx%y*7#mxKBMX+Whmvxz> za{Y{8OUj*kEr5PO!D;>%-U_Q8`|RBIt_{RZv_?M@(Hq`m9Om zbIdG5npXmzvZWm3piJivOWy`j`r|GPlbf|Q>15Yy(59kN#1|vUsgIRNAqHm5o@QHJ z@xEoVf!gjpFqxtHW4CcNC@7Jl49V4Imr3oA92?oH{`;j|l%`612bA1ff$8UF<9tvz zBj2>KkBoxWDlz*M5Wl*@LYW;}VWmFbG9q-4plhmuO{D9{?C#bv)ymjN)?(9$7V0Or zS)hNDB_&RjAu~}bG4;gKHdWNF)&uUMu2d(wo$~s6;C=NGx$^T&+1YClgnPgZ4b^C> zKID>d(ZxXSu<|6^bcCm9M(_vqwykNsJ*3x+PZu|~@!D;>5SmpX`>Su4=VV^&mxsfx9mF{qh&P5@|Bf|1U-UfF;==-Qho=2o^IMq@>*M+zQ3kd&lD2dul6n;9iK@|_V@xsolVi} zWEAUZHZtje9Dl)2QF}jR?wX1O+a!f_EIZB69eI@&qJ|*Y?|SA&3EGJ-HeRxtS^0om zI)4CUNhG>T)*9>BwDJri)IRH{LPHw5`@9|9s5eJHhr{6Z*T*z4QBvBMwykBhj7D?Yvds(2< zU^-Qn)a>aa8@~NTHPu;~$+Rk}k@YhpCxxTK2Oc6?FfyI)^#lqDlI?MNTYt8dSnVot}LlFJgTnyWu%3rzGGu<9Ez7&3GsSA^3lOdkM%vU-%dNuRY7f# zM#Ah=bIY-l_azo&$NKu`Wx;f;ICZ()4SVWAgt5tei$jHEy3e-z{J@OUhRxtm3cKPo zS>M7fxpn;!WqdwNDuR>oRp1rwO;~E*ZD-kg7=4X@wXjwDZZF|f4NPf8ss#CjMkZ+C z9%-W#HW=MOh^h4c!p5^{vt2V(1F3F@Pf!m!bJ4C#w_YW7m{@+W=HS{lVWep)OV40> zT>GOwBxz$kFLoZLVZ#lV4(}3~HYnB{T30~WrXSe30=p-w=dXgRlJ=$DEXoUMRn3;f zch2$b6Rx#)q9FN24d3c5JswhwQJl=?KU!x{$FI~9NLVK=7)oNaJx~I{N0LPPD$c3t zCg8;B*h(vXL9VycG4?X`c{Pc~um8xQT;6ZE?5X6yw4PRxGcydA99owc#?*5*f;K=y z4Z-WwS!GZNa@Hw&brlu0kvS7Gu?sueE6+*;!?ue8&qJK(j`$(x3_~GQTQpRvY$!+~ zKt3#T7Sdhu)zzgBc}!I+jcN8`p1?7_IQyywu`i(^O3oysf81n+IvWUk#aa*M*UO-o zR&E7pG8t4Oxq-i?GN|NPGT!erb6wD4f%->EUG;cMlgwnMeOABIcFL7udQYD zZr4J^xJQ<2O5+r%Q#s4W%)`QzhUw!&e2fPccL{DzKY}S&IA7Yw^wX^xQm?x02xZu` zm52S}*Co90G)tQE;Ll$3xuM^om=JovbWXY!04{-VjmTQ$ymWRgNl@-rrXw;#T9q@Z z7%vm0lIGuJmpuII3-I7-88`{wF|uZ>fXG|TnwJ(@*uI?hVegk2XsD@Ts+H9_9@}ZX z!m!ESu&hQ=DZ4hcGKs&Isi~KPKzmnaax*#ALz@wjZ+yS?(>!{hG$bWj8zlA{!ha~j zKw_(>(;!wkeLI7J!Dq!jzz>RSlFR3kJ^q%DXz5QlC>0c|7QxwLH&46sx;W@&&V$t z=s;T_Tkr%u@omJ)v;+5jo4XEKsu$}{KST9r{J*T^bCBadrLVuyz(wsGD%|pfDE4zx zP0XHS;t#Gya96>4mc$_KVJSO7FPn8%6hs$^U$Fr~HGK$GXi%&?Y>{Tc+)No!MmhZ|Wx;^UO(SVJ(L#QDkABvA zeu@3;Tt4biVjj1+*vM>AlNmBKr%tfw6C(J7_L5rb)SAE8YD)M{nWCtyQoNguBHN*~ zh9~*f7g77T%g#o4g)0jA5U;n{3=}b>Wj#F3_kA&P!=$|(W}7R=)Ek*RPHFB4`jcWK z2QxhP1bP$hjUn<{Gz!VUOJaHPAg(Y5qGH#h5^~_h4lV3?yB&QFl{(<;{jQ2SB2_v&}Ak7lkf%vLaB|hMQf>wEb5K#LT2#)6>>MVuv_^ z&US^7Kz4=pkjg$LYFlx@1?;IG$mlBaz!>i+gvz~I!|b7mnsbndzKI=9DlO244+&CR)O(d-p32dG15@C}v3BrO2G=IV zn&jO?MpEfif>V4THzQ_RjfD5OUym5O?7n;=5>GMFLOQe%E2RyIjr@puLy^szPwi~A z*VoKiN(L6Sqw(yX8`Z{jyZ*tEPoz$*&YjT7wmp{+PXYXqD8!cEdKctP7>JtSKvb7b z#1<%eb-+b;W+oB>Jj}T((9$|)@suqirnqIhU`kj$Z9oVSN$Tt&=kSG8GG5bKtxB{- z+01#SbBr8YNFG3D_MHc2@x1Bshp=(x2iZsdINd4>D+f(thPM?ZwD<^W9~*u3K6<1s znQr?fx+gs;Zv{G<1()KouU$3mNa)EreT)mx(N8Y7m-P~AZg^ry2&FjbZ={G4uKLvlcMR&-(SVG zVV*}b=ktU;a*r{H`mS8kVNS=XPUEdTgHF}QeOpJxcj?89p7DArES2$$j|mM6qK;m6 zLLhZ@aqPbH;J2JJ#>KRJ&%| zz7$CyFeoJrGVtalOakSOyPz{87+g6fp1=I77oiayJy5E-h0#z>>_}s4Ee3TPn&vO{ zeXAuDb8Am#cc;Adl+e08sm<~Wn$2GJT;yyN-Fi1^m^|>+Dx>Qgi4s(9iPX|b7Jg9H=^EvxY8Oz^UFX8siEF?}CE|7$TCtlMGC;hlt$XIbNXP=LT2lis7 zq`Ahq%FCCcw8fRV7MPs}XQ`GFHN1{u@0-dor8Lvw>rEr44h$kfDeDYLMClyUlx!b9R|l zG^Z3VLoVm(iAsGB-`Bl6SpykPLtd66>;`?Hs@8@AF)x&Gh$|Xu-;}75*4rU0H^u2N zS((VMc&4&eus$Ix17@EuK`(*=n+eHRPf2ZLV*A;SAJJ(Pw1|Lc_ZdN`x|>D(#%L#s zxRB1bc{24UJsz+q;#bFBK~y?6Aqt=RyZK@>O>m7RL9?c^u})>fieKrdlf~um(~Cue zJ*O1a)AS6PsO8%(RrMWqS4Qex^3BvhhdM0JRRmiDt3fGJxv0MIiVB!VOU=pefwb;V_oxCC_*Jp2?M#alt(r)EM_qj$Tn;qzu~g78;ef3xkykJ?o_TPjzv@`MUakezm#3qBc!rfK7d5 zd%{u0FUf&9-KAA856c?{iUfs+aod*<7}??#D-iTfK1Z_e!~Q1i7jMj!tBqr)1%L@1 zF>;P@y?Ag=k^EDy-$-b&5UW$i+tj`U&12VWXF(Aqgj3>`QkCd?4M z_Z)20eBte@$@C@GS1|i`!E2rfNV!u4jyMex@0Sm4%WPY;@y>$tM8*S+&^*+K>z@ft z+jl+Nvb>_bK$R8E8wdXk0haAwm{k`n~wmI>xsxc!dX)SV743 zeaCslyO-6L)SPDVYE4cIZE=TB`vvH`C)B;n6c(`zz&^#SUZ*4&%*dbs63UAF zcGH<>CFhFNuG}6?0$qNgP&Ca#bclXQ^j-x)%mLjcM@1PS#4ke57cU;dfOn0E3O>>R zVS;*HG`)bXV&u=f8$&fOZ#V!jpJR{X`i<|H84i>_UM&eJrLjQ00N=YvxRS2;CPzKB zabReu%`+*BLWK~eIMMSXgFmDaNx(o5Kh@MJHnHVf{Pp}k`YV)6vkd7S(4!Vn$b(ar zB)F7iMAQAEmNn`gTT5n#keoVOx?f}m$9pZ+CyNdJkJ_VseI|!$A8#L9kBHj1`BQl# z)n_F`@rHeu$)JqO*$*$3e@ik>=B9rKs`2Gos?~>mJDw`LZR-+)I6KrQ%jPoEPos|N zotB!x#a+@AYK zetGXx%n4FGSS92SAx}g1C4(E)nn^w4kK%Zv^ZECQ1%f+kRbvSUz@I>t#6QKW+*FCPr2go#|y6QIWIEY)Jlp8^P0#<$8Yy0 zWh^_O8#$uXok^SB)gu+(s_03xXQ1^m-F<b?q@mT3s^YHXU-Ut_7au1 z=}EtsP++x+vU@629e2yG4HwA~LThfFV0yj(A&UvtK~yN|_GgPeY*l{tEyt9WrHUr8 zxv-sZu%(6xLtBWfPG#f4Op0J~g3TruR4XZBc+PzPILI*>#fjxqG0)bAn*FaR zkYS5~Z>K?Cyd%8yW5Zz1)KcO6BhAM)t)#dZ(>i04K0}T`C-4BLgkzlZG1Muvl1Pub z!L1@+(nyk}D1j*ReP0zf%;efrVsd8JEslD1;)uxmadU*|Ti3t7fc*eORQZrSv$9-K znf>o@7`h~O+6EN79p)NCFdAUn-}uW!H`mrJ%IMgxW?d%H z0tmF2o%7|~*yo{f4Kmq3E$^)aEIYrp=?E@fdNq=-G$A11SN^0-S1EcC1u>U}h2R#@ zz8+bxj&<|SV4D;9(s7BqQSeZ!9g9S-eX%Z)`emDnrRQ|_CdrtJjtB18SI^Sf$K2q!VzQmoFdE;n)qkOP{Y zzb;xSt|*w95ku+uhCam%|H6?Dn~W5AX`byggiiM>NBP=?*3~dZp08$cCL&W#uAS9& zoiZK4HTb?JhCPj}o7cP%#M6z8wySKQZ?fNLjX_AL;!bQr4n8tt5hzy1hdN2olVz1! zo2ND=4y&)5G2N7M$_}xq;n~lFwpFzu}cRPss@h){|c1@%c73R8Vm<9kL)B zX;Ih!!_3tfwX&$JroL!W?51N`e!S@XNDCNgnte^@8>QE2Oi@lXc<2P3xII5o>(<$X zO}|nbVU%S7hUn`Y&U;GCR0h^+A{JZPrZ0TIG)pCF|5i$TFJ*%N%CV~6@}QoHg3ZYE zrwmFBfz|OBJpYjTB9C;82uIa^&;U2xJoMl+uA^xGw?lNi6cPDL48ka}A8kO41fm%+ zE^8v73gPF6A%{wPGjEHm6yk*#r=u0Z0zxQ++~F$fPK%=+ zG}z%ZCQ1I#_`K}q+JzA0)!$m&gUxFR!sgyix%oja`AFyuPVHYG8Ygt~c0SwjAoR6I zwbXNm>P9Qj#S)K;))dN#48WZKk@a}7HX+{g=_;;Cz?Smx=3wBWG#eUs(QuM?owTzI z#-K^Q-(AV)o?@6Nh@<2^V;khhlE>=c#!6&YlqMxWvQL=m<2McC|L&QTI5k18rE+bl zV%LYaD51ziZ_hwrbbghj>wA#o{l}-?R@8%+BeLV775#w=H&0LLLJkhJfM*|zB2b?x z@C`%Y{LAJL?0A)4RquzC8imSy3S%qqawwz-7;^qnN9ABIHt{-^Qia8B`!u1c@W#GJeWt`BJn_jAs?;0@Z+Y|my68t>2GQ`7gffdoK$0Q zyut{3pMvT$O)iK`S468*_8NF?=&@omyk4)jkF-H&*yL0SqjG}ko8;LGGq{99VD{db z0iw#!u1})A%VF_-)&~lNJZN5v?LDmH?5LFqEh###&tOAlOV&t)%_I3~Or@*(M6|QIZzcR9AWvx?}PdIbs%LKI@+lrLc$ZCFv^uh*##H`fRNidCptE=g^ zsw@D2^hH`5L(ZOS=q4x1`J2>-Fgb*J)}}dMDgYp7W95g~ltQmZu!MEFDW+?2Y)t$M zK!AJC$6$1#YI~sHktS)SczT5!zLsrybW(OnrS!c35dKs`LBDUa&)T}2!LvAom8Khr z$BXVlx+mOUB8o{n4vS?R3>6$hfy!uKZNYu2zx$|H)xaE0tcb8uIV!RU)`u8+G8x7? zxJoiZ_~gHtbSGPJq{>8+4>p<2sYsipsw z)X)9}Z5WysQo*SuP}jA*I9rv&3eumfR*l2wDOR=lCX8_&{eS>fnwuHYq=bw`Sl@y` ziB;|+C~TiM(cY^AgeM&HZZy@l*N>LKmX(Vi$vN2anu{%F9qg-oHl#0P-lg zmY2^-=ACzxT5&;n7(SZwoP1>%Eck$!gPxW5b4A2D^iG1o?l(6QH1RRwN@#*E z@IauBQqv?$2@0<{s{sL9g;l@BV$j~4ypTbD6SlSnG>}kOIXC8l2LOs+gyEMsWtn=a zk8S#XnDY*hQh^MCd#MUbOaQ{hKl;?bZ1rALa&+Q%b#xFYc9{8${!aY&_5cYiK+F^( zIFNh(7`_;eD&UKlL!HbhV(|M9B8&=ffF6ZE#7l%gPu>C_eMT-b0nOm+{_eeOU|(w> z{0b9g$Q!^I|M~{~Vv&z3#1_dcYAvV4WHEt%K>7?DhcgX^GxZcY@;Oyc;Yg!2?1}* zONFuC0HoaB9~``7nxKWFqzvpPvFJh&{lj8Jc^+7}fY+mWF?z3qeBu$oNq<$L%4rH# zaZb=^)z>-q-)ZD_1h%}d*fn*c@fK+>j&#ODRU2sV-@oT{0|c1R;8~sBzf1sNVs)*f z!Pmec0M@2*_hI{TON8v5@Y5whCdVwWL8y5R zWN^SQ{t5t4V1flon3>%fF_u0%V5~-YG}D~Btp30b=<~)Y=6mPjmE&pD{+7Q8#z}o& ziX)t1Z)o&_&<9iuLShvNbUdcw2?m4{?ZunWwb1=9gu8=7rwKFE9F?vF{zf-MaDaa< zVQl!r!vpYa2EV$Vo?F13rrq;>)1%4DbMRVdf9p6e4NIeJboZlM=H0rKo~``1T=2hd z0%8d7URql2o%I_LD5t``Sokd&>=d8`49h*Wz{ zF!hxMpBxArNnR|JoOfSE|F59(7f~vm1y_OixJ~J@^KcmQvT?Di`wo_G{v(yN5D4j{ ztKp)WoF5AE>DST}|M&-PKubAr246BDr13vIfM3y1F8N%T zU{hgT&sr;KtgSzE(ULH2Tq3}@x0Sg<@qCpQ7IRy06r znMQx#wg-!;6%@Gj+8_8|E;*;NhoE+nQ8GOv2qfe{%nvuA*3_%xEa}23$`0K<{VFuU zrJ>*_y9}@4dm<+Gf4~*c-xuR1oIZj#B=3KpUhv|4bi#ripjmo|vhRJqCCg`7eZ!RA z=)v(>1+S}*lid372QH8LzfF&mLA$=cicjBmWVqFMfMXWBkZ2KTzQZu+hKYmvJRKR< zzBu*H|85J*xlB)yHbWjr!^ItY+%wL9vxa`++LxtL|LdnG)x}{4ZZx$+_#`t=P#O4p z>pyMF!mkdtD>OE88vAJLV_+GsT`J^oqSfDZd4Di#e)X`$uijpv-E|oMR!G3@ECW=& ztnk+tsCY1ryJE|#VumovfbJW2GRuG__93; zoM*h^ks}<}y4Soeir!(-F!sK3WqZJnbRiOO#bbIb+3>k;opOFJWCz9V1b1jEbZ@aF zcEobpqPzwE<~5&Vsa$Ar05|oB{+@Moznv^Mr&Bc_V(dUG0zWZPKX}_&%ybX#He5PRn z;jb(9{F=c4)oY0u{Czek;bWdBstsP-X;&=a zI>8fh%VrX>sWomJ+hOeimR9N$wI1*9tk#xmkK^Z^X^?-(LwR)LyGRo5dvL=LQ&psg zvDUZ8{P~H>B9B^uYoj=Omd7lHrMl4>yB~c9KANq^L-f4af@x1i^=`p_1t-^IHLH6o z2hFwNz3=?k9)CVdUbLU!JauFmcan(h%CeMtxUU=qUC2Lv8~44vIeta>uP;D`XC-wP zmssy^<2hcCeC5+Ba3j=DcFA)tb#Q0cPqCx5!|MW+Hz+)%?&H~izi46}ep&4-d?7N{ z>%QCHfhTfYqvG82cx>xkKDzH^))%GhH_O2%Tlx!PEFz*VFP-{mucSw5MF(47zhR;L zgcN+iNq&#|C7auTuYbzg$yGy1qVv*nJ>rtFu*Lm6!rSy2whm!WwkDqcKW;016x=QB z&s#LQYv;IW=XZ8r#m8zH_SvP_Wb-xW_gqP$Q>2`0#lYA1B|G;EmoZuWAN2ePDeF5kG;j4kTkE}N@vDms?@h}p9lzD>;;GSWC#ux#a3pc% zRq4PtOR7+vbXsOg336{kBh*=JX5@l#;8GaDcdopok`^Ze^g(- zaz(NYep>6TzLD;tR=&|VwM30=Up>hmT55POzwym2Y4lv~rJo#(3|vVy^ve{`L&%P= zu}>woRK8fj9gsv#N>DYe8%*}Uz|Sm4J(|?t*)>r=e!9tdw8t2cBM_RA4f7n-%zDi} zD%7b0>k?Ptn!ib&X8V7hscjyUrE&hpsIc|OFtis4T!n#BnLb1hn^;<4Te*16FGGR-K;b`yQJLo-D zCsA^(`+)P4<7m-BXnurnN5Qmt(yjhz;FUTD$8<=vCP()#UIwB?Go+5!-DN22VBfiW z&(sYbRV5+I)M$r=gXL!}c`f6@$m!abfsHjrT*NKUHh7Y)3W(j!Br;konqE+Nfb;I27 zE5GQ&^nb>suLN5urk%1!lYo>LsX0a$=_q;n)(NP=cr(`wptc`ws|edk*8vx6IF_vl zRwk6UGS}3m+ktg!JyULHRg&j+x)g8G2Omlq9wHy32(9x_n7BS*UHB1Pi=Q7 z_|Zfv?ner?B^2|3I4xL0@RTq~(sI)NL77x$V)E;AHS>Y021{E>we{>JB;YzHn%Kim zXZ?yNk*2Hw{d_SfAA_508Md9lrl+s}RA0=z>qNk$wR@$TPIjEAY*XG$oh7;4Nkm(NXz-Inv;#jkIVVe`)M`Y1ah+Je zWHr{N3N^UFk>^OSy|n1Ea5kg*1P3N=zm2HrXfQ;m-}tq%gTvc09i)>h>#pD6d8}$#SkQvbqVCeJ};t&aH>5V(&7jZEELY#6hk8 z(HjExN`yQoc5lo?D;}SJPZ;z~LT+!7svA2y*`8)_SAC98j#zMI)(IH0KB^ZT z`Q6XZ^{UbTnE&FeOdgue(KSd+*nj>DJGLDGZ8n=@Yj^hbJI2T28|*~q$wrpD4T4)V zGn^W4LJP(17~)2e{Nivltm%~pnGplG-Yr=gg^q+Cnl|P|ZQs&K%*2E09Urlc4&sY@ zYwnKL*p1IkxkYXZz6Ok|vve2rXsDeEk&0}`^|`+LAxQgaH4A3=j~yujk_NnFRm%Gr zg|^{j?MHR?#l`hFRHwuFu!fydR<(vcLdbm*)KjT%KKav1Tq?TKm#sxleETgDAX;0Uz<=Qz2h>ja>#7+97!~bS^@c z)n=2s_LlGo>Q+6wKD$S^ieljSeFYrO>S<{u#Q%fX?WIJ5 zoi6?jWnR#S3*xPYQxAt*)JvT#!BdGce(^%Ru2IU<-iqSJM55J(^QcioF4UES3yFKJz8~|%?x)_wy8lvN{^BaF0UK%YUo=Mk*(EgV%%vmr% z3=_2fUf?@j3Lv?kpA5Tz%DaCP0n$jP7Xy=$k+2Zde`$2lEciETh%>YIFD?I7IsgF) zADS}lrNYfCV*Z#SFw+UPyz~FqA>nmbLl3Y42fpWB7e+A(P+?{UenR_SN&x`naADXI zSL<>*nY_8+?%0CRwG!sV?8QQw|6`{>kC$p6#{6Vn=#m59JKCdWRnI-z`iYSIr;-bY zk9FkO|I8wqDgp8`Y~Xca#EWiun2OtO8{Pr`#Xlf{v{N!WEq}X@0Zm1&hpB}e{fU_H z9DD{;(jvRlZb50fJL}Lxp|L)+vJOOX{U3!}-$|roWk-?gY%&)M&0$}mDL1;Z(?r)r z84osuk26F=joM7ad2ApYf!UN<%gjsy-K#G~!T%XLabJTUS{@eC;_Ig$xhwN1DZcaU z=o9F#-NR0;%U=oL@&Z~t#08-K?MVE~jrYF?1vMf}Ipx1BV8EFK`<2$%=bV=!2r?gt zU}SN+$FclXKMs`m4~%=lfAXkuQDHf0dci|(|?L#vFa%NFHbr7u89=A>kog$ z;LQf#{Bf^QPQf09oe{hpV5w4MtSa*VD=+*jbjFt079L^g>JMbVkSf+6ubp(spO!Ip z^>+&iMI4&@lMG7&P?EqguU*PI5(XBF%1CD*tO2uToeC0mk1j+B=eHtg!s^O@o(23N z12$_cgI8*pz$H`y;l}e&9TcvraECX7?k%G%`Ip0!b$`vpR$C_k{&NGbr_0C4ys*!x z@I`Olbtaqink30b!E@HBEqWO33?=uIXwWuaH&;a4qIDMe(U14JgF%0> zHe}CLD)2Z(MGav^4a`4%{MjC&+7!Q)ezKVR(nU&{NOgQi4+0H?vvtMX7yi30)~bTW zRKLCtOu8jB0A~owf0_-7Y zUj+WoZ;TVE6^vM_6KMVi7>F^dEq3;FxpSBth`aMzr zR>RDHY8XHoDDYPUMt>EWl~XYOSEnHFupkGrYW%t9bVnBuk?BE6GGXb8u2P-{`t1CwVG|wl}gTS1Z;-#Wj4ey1BFyUcNS+S6e z@kyHKR$bO{5#P&>C#%CZ;cpcnH`Y!(wkxvoua5pqpM6+$weF;^e1j9|rn-~6bV%(k z_|3_H%X{gpoP?N2yXNHExku@3GU`Y|WnH-w9u?l)OD;YluN4=K6SJRnPIco&{CIoX zo!kfSCTu3gUwFgXo;s0sV}A)q`{b@+xttY27Cw$VF#lOklzzoy|JdmI`mFpEWc$vP|jP2kq%-mE=;<3qqy?QO9tw-Rc(s)81`4WH9!03m&nM1g=e4&gGh%M(FX zEn(wEezC@!Z->XVK|v57J{p$xzHEp8}WU zQ}a~l^{TU0qs_sMgS+8gZTsm}I)cgDX0;zt+h`P&_x*I@*&SCmU0t_JZu$*p3i}(y z22odnSOJ=)3BRH?GEG()Mdldhw%$IOZtpaTq3J39lwpv)MGxyk0-vD{uIkDKo#Km7 zfp*{A*zhVhm|yef%|{>%(!@r?lOhYS?EgL{7`3c4I$zAbX))JD-PWa8(64de@I+~6 zK?>~j@E*Tv3(wz0*~_ah3=}nS(O8E~EgLTWluB_y-|8|LeE(T2b{0Iq6F>D>-g^V5 z*WFNPH0XH+4d_@7z40OUK7?nvG+o|$DTw|XWP2u{`1aT&aU;miWNjJvRja1m$*Wp{ z(qp6KIrNggv7M4TZu0W?<&qWq^%TXxGdY?hg6`9q?Q+5|qw7zpSrdkfUST9heB0|Q z3^ThK6kN~)9lWtX57KDv>Bk}+zP9t79k}3g`pH@Qc@aHp6bVg1?dE&TMV*}t6=vMv zxAN0NFVNu{U{SRdH4@FU9fVCg-@AUs{W6`WWW~!mMDWYe_PUgU6fhhp!oasY2(ya} zdH7OY;AZ0WIqK!XxIlzs;b)25}!Wc|G0r1MD( z`Rm$GUCoo)&f`91OhmSv%ju02@aTJK<2~?$+MWY(h^mZ_n=@3S`B-)`wC?w1{k!g6EPhXWh?tNy}JU=$oMgKEJ>e_*}VHf{}!3f zf3qeURf;}?8{Fbn%tP$GFPu>03TXP+cD=VJ8(i(@Ek2r;QT?2M`*UEaX@dJ^>HLJ?KcEr3Z z@N3IrzfwR5(X2v&{w>R5#AMv+Z%N3|%frq}LPLI)efoX|4Slkz4X*i1N&8L%zvwgN zG$o;LYu(}dD#RUfnT_zIj3Cd-rz8*Zqo~w7QFFnLrgwQo}`gvXZ}LQdu7VI z6=+ZK`u8z>G9Z09&mQt2g^;ySPIw0tHDPI@kGYI+*iPrfRutkxD{XabeZbdHK; z-%tYH6RGG}t$zZcD5;|WVjRMM_FfjPz>cgTNZ!YZ5a8+;xb|Y=Dc6&f(6(Z5SjGgDh}cmPW%*gX7QN693DLRIzL*}fmvfBM6>j*@|Ug9 zHFPt3i9y5n8)f#6r26+;!yCker^)84)I)km_iBk7T&^ycCk>7L-VRW(^EpS#{OhRU z&#y?58NerFTc3 z;t0Oin@Vo!Xpw#axTuUCm+`Gd7S3E&NObktpv6}Vyx*djNtAz+w2s<&xK7I}DtKyQ zZ-3neP$IjAh0pm_eQLKXYMARGB6c za=Y-5cb$jZpy+suEh;}MWsM^G>WvuBloKAkl=4_cU;-fct?~=l!y6;csV_hNmMtYZivuMR_tyYHW@-D@eLXW z4&PfLzUN5q?TXFHoTcX|HX3z%k>l8ZxKiG55V}6#;^q(uV-@ z3(QZ2q*MX9e^U?`imXQ2g^KDQaYZPIo!1l>8}I&0Qy!jV4L;gfpSMbSOl*pnY4l`F z4gI|Wu?B>&imHn%D{KB;@Y^(a7(f6FApQRZ_~JCUEN8{M-Y#Crxo+v)wpGKfSmm6m zoA?i>k9{OSFpw?@rzJRb;e(Z-{AmYIFv&F7kLp)81gUr(Yw~|V}p0`K2uAwez-*lhE*{8pYmuG*ah&cs(%xUKJ$?v z3TDIp*J=TwU;p2auf+bCSbtxn+kcw~e?KV`8@!cpkW1^d+)Z+)-p6h(JIP)AXOf^iKuXM{B#b+&DLNePtWY1m zFEc-Uz%3Ca3w@ci+jl7l?ul+lPpFwfNGN)Ee=fIM@kCBD{^8N@zSV8pV5Wq)5kcbJ zO)6`$FugIC>iRaFSqbU1r40j)*Dl=s&(;e`V{~Nl+;J4wiM>3?1_a42Y*Xr@Ugy!J za|7=59`$r2%fT->7A*pE=S6(938!kWg3Bh{aC-0QLq7F2Igr|5rq$*Nc9!Qg5H|~P zEmg-p>u#=^#M8d3?dJa8X~eSF^;h2y&rZ*y@h~j=0+>?U*Vu7AqJALopzz{5g}NvX z{5ln^F43aw3&j+((>sq(?QQe(l$zLH5?j6y#W7#w25WYf?*e*c0M&mQ>KL}3|5br5 ze8`@Q?yaoX_e0nrX9mgP{szOHD#&9^H3-*)tt#Pzn8_^(1E(^v8olmeDK8Vgp|Xjo z56r{wx`&_l7iT9Xo$%#*H-1H0dAAfr#OLN=|9erd#pSo%ZC0UdlFBcPkj)5#^i~fB z9KD^cdOFX6U6$q2o=@pa!#3p?8YK-+=N4Rpc(s+pIlf|%T55vi2*P28Awz6M$vNk2 z_+@7_h(BbzJ|;72Nu1Ms5KWXD{FE_7iB|jJV1HY=NRkg5&0BH^TL^5%y>IElkhl@q zz?}ND5GTd&ShijoOerqX*{sVgK0H)V^EuR{f0V&CC#@f^jaa18Pd)n9#jXYeYvBuL zN3INq1KK1D&%4{bVhMcN!8BxUiY+|k$TuUnOp>+uRCWf|#`0!nh&_9iX&EgkKQW7P zvyW?#AhpaMx*vChNH~ToL>R_WC_{4Jx0=l;_*K6jJ(Yh=L6C0kyxUx;h6+2hlTCi? zx=*-F+~Jqsj~Gal(OBj_#O2ckU;c%L&~%}RlS%cOidV92UkSr;*B9%af>G zY#DojdV2o^2ORuWoT|C!T->dfzeS9{4th-d8obaDpxX{b2vE(dsQC5Zh~<7d&!8Lr z?Bn0{h_s5)M)2dSS9eob$iM*YN@y?*a$lI4|AFTK+hO3Z>p)k%^MJ7)v^iRQ{q;>9 zZ$+#SK{K61uY^Oj#g!Bx;GkDWmhod{d_`kZ$Q4GeN^`cEbn!7H#t!?GJG;ZwVcrKM zi7d$34lfU|F8P0md&{t@x~^>)6$$B3kPeY9>F!oKrKG#Nk?xZ221zMtke2SQO?NjN zHt#}jy{`Lt-uL)^e(MJZu;!X;t{G#FILA3dm)umYF`!pAW^CBtt>l`5CuBwF8SaIc zhI*b;yIOduDQiVv=Yy!f%1fVuJ$d>s`@?f#xnhy2(V4*SiI}T;Wk}U2CDM+jWVT+= zW;w~EnmYTR_0uKhFYz0q45^dXTD3N1hwAzn2w5s?TB%`$c`k_l zqHfdZI;n^_8S4xa1qpmpZpG%G+WBK^FiO$DdA*d6uZ`S^{a9nF(cC2o?`W7Wta0!#C)#v8A67f=4k z)r-^8=?*RBuLDae@jTaZJ(QSTRoB~5z$lZ9yEUIxRR(as1>=_=N!(~2rmBB@yZ*_y zLU9AsMrfI8-M`eFm&TPrcXu#ft6e8+Q6@3?Hiu2oP-E4juVS~qRjT>t`q0h9n(OS= z{WYj$|87aQY!)Dg9Z#r=m5XNhSX7x_?wr*GQLdBEjl|sO9dbV5)^n4E?0hj%S5u0_ zb?~a+Av4Bd7CM-#2|XsaCs^xVHeU+}6$-`qnkBs((`weTdzZ|k6TEJqoT6(I;Xxfd zgxnS|888=$FB#}Tg)%!jkPj1XoF~uBVxdkGZr|J(rqq!GyL2lL7T?%)n$U!wP!sEh z^A}aMRP?v{ipkW4pg*bp)~ehU9X7wzW4cZeo->oTDsWs#S7VC+sFnX&Za#rjQvluDgmQ_0=Qp~^sf zKG|^1&2iaHK2oX{wL5==>&w*SM9udCEe{Y765G-_uwvOGaJe9cD}pr~;;fowJ>7HDe;L(0mbk3q`dg6hDHG0e#Ti zbVOX4N<_iP$N*ltq9-nlsttpUD?f>+t?|SdQsCcy%#TcI%a7fdP5hkG%e$_p$szeH6QyZq)cxQ6?@K^2iH;A2y-pE0X{{FVW2_$! z<8+~5lI}VOWhcQj>DRJCBZn4AQ7dutJA(Urv2(sc=k!!M8JaVRTh?&R?Q6w@Hl?d2 zq3FW2w;yPNs%9N=zw>ctgB6Ou5o`C6XoRqZr8wWuz=N*{GdqFpQ$mfK1a{LyBAWYL z>;>05JS)B8Rrkj4_ZQ=}GqiGyq|#J#n)It$dk-U9?(gXZFo>~tXK=01UD3cpqy)m2 zh3%NSD6|k4K#0ex5$W_Xwl34&Y_#JwGTipI?t6vwv2r3irS6YFCC^S|qLnB{Fv*jg zZ5R;c7aGD=-<)k(wRq<`s3Q7oWfz$jQv@$z^w%wIyb|s{Jr#fz!GMvRshq>vxH-)}Ea83VeB8 zlw}s*gf7aZ6G6W>oAcg5N%bfWd*-{`0;psB2Rcj=I#9h{fLYx1B>HRgJ@mMUMK^q2 z%(mgfF{k4tBx*SC{Cu;AmAn*{(3nN^mw<7GZZA~xEZ{}V6TlLHPyQ+E|JvVkuYtTx z!>37#j@w2;#?C}eCyFwnF>AN*O0E8Yi(sL7@zA121-XC;RlK60@VAm3RVi*J5g(TM z)(B7-Trs^|pFfGh{6Qq(4)-{)zsuxO$CeLfYdme=o>*Y?p-$eIXqe$d=#X=JWToPlcJmXdnBJe;Hns>B$PJl*Xq2vb$Ju zAg^{f+$n@@$VkbLt}Bv*c;&rLg&hOSYQ*~Cz4M96-HwWcz>fx|78f+@?fC3qYa_f50u`=w+N9T|Mrc|a z_;iyWg)OyDI%MAlrEgf%22a!W7&rml@|K@rLN9KEyePttN1j2kx-e7Xn~5~Ocbv~# z=trBrVmUC&C%4Bfv?$6LRt)Gd@sGW984>>Xf^C_A;^FUOqk;&91X%F>Vf)HS_4q^F z1-pSBn`UD-AAJC`z059#_X>llfx|%_rb^e9i7f(WYXY= zCERrAIc!EI*HkaMbDl-?vaPJX`rn4Wu%({ni-D zto^obJ~3dwfZ3By$Ao_T1b&VG7|+=SN_$f~9J5ARtlSR+OtxgnfsPtj6EwbZ{6U-^`W*ypYiC z?Po|14oKN%YpSBs(xS@B2Nin6ezuR@Xwx3}pT`6~e*6gLHG*tUE37OAVWw{tN8-V= zP9PYFKb8x^-~|BGo%WBv|3GTx8_Bo09HFd53yR+)*Q;0Tn)+syhB+AFQM(&Hq zVf3Ket&NZDXmpMdQiSp$mZ{->os4X&oIac<1wBO8ehkG1lJ_SocryA5Ue`hYWp+(`RsK9GJyTg&sx>S*`f?uwD84Tng;4tJUAFyHP< z;9D~1$F2ZPY-NF$G$B5BS92v4M-k+M9{Ve}cthMy+qw0pNrAjfDh*0aItylY3Mc7| zbZB_(uXWF2Fz>U+1Gw^eNX0P<;I5WJy{hCxUssG5*r>;6eL>Du6TJA!TL z@L@J>4>$13ob7(Hv0}OVc~7v;PK*`7M?rY~-tk}_KH%#O`zw&D4pYC2+4Iw6oc~0U zfgJLLz%CNJmVO|xdC-v4qRcB$z(5b|B6|#_D|nM@9ovgj1~0vcSaYEjlXMx1kvVOg zTB{d#n7ty-RkRj2ENRlqld6>{Ft=seu*0A&UrBF(w-tj z7^{VjuLVv>sxsMUx;PBUlyLKV3%w8EpjSKo@{RgQHy-VyC zCy~J7ybOt3oxUV7+zS)I7@ZZ&N2I|c6hR=c?%Uy-9FtQ>`>|O91tfy>2%wVCzO3RP zf#q{wi=U2wYbRsMhukh4lRMG{j@ZbHmZxwy zSih2+oZ}l-b%6|+ArCm;N@df1NpI9$K39n!dp@pJ-_qzDp!v|G?rZ{y*8(0K{-Lq5 z=wLR#`N9ai?xW2;9a$)L72nH2KgPPy-4R%(G&g*)@%6pL<&Vb98bu!|aUSG~@*GNI7ic&D*a zWrZzs0fXdm+c6$VKrq!>e0oJf!%ep!2v*eugEJY1<}0q+hsbmzgY#8dag( zBEDZcy}2kKS=znptaD7s8-BrYWe>9O0(BO{#+N^&P^2xD?S0D_ek~f~wVveC-O+HF z-})ZBgJbhmoR9W=Ew4hv>{ZNhbH`4k(|fR}#=7l;FNO+lmDzq(Li8~%mXwr~C!}*k z##0F8D+ju~-xyATHYXssYCjM#pIHrDy?{g)liiE)+29Vw+2(H0W|$LN8=-$u!Pwt;>E z>OX=o-mh(~O8Du~t?(!+hthSo}xKmu&aUzXz1JJZG1klXEC zE-gcDJZUTS#ug;bZ|~QZ6<(z*aO`*{gH;Q>a0K}_rIROjI?RwY&bI2?U5re$1@7Ds z4&S&Q^ni~r@yRw7;L9oWREI*qJu>LL7c*U5Ro%q|U&Q+ajwSsbQ8CPd1a|_dwr_-p zB!IMl*Y}+z(Q)+L6pha|o6i;064^HZ(Z9&%uX$+We9+qI1K9+3#GOYwXS5m~3>Cxl z9R+K7x724Vg1cth8E*>$UJ&HxIeil;PYt}U>rfvs@=uje`SMa=c!lrICghxQaG1m@ zs={n@dB!-XSt>7KG2r|s?Kan5c|vb}SK7u=8uh~%Pq8C@y8Xx6Dw(|xDa%nFub1z1 zOnRl#hVuP!FC!Y4G~Uwe(`(+0ZbqwIp>9T19~q$Z)7BYH{csbfEOXhD+6;5s!~)~G z7yt-1Z-oq@y`$?LFET6sc{k+fnH}WT?SRYGz0agCw3oE=@V*~?+6j4x_(TEnRt66ybGhgLm-=e&QXS?1A;@pg#sZ*Ps+n>92$R!h&mrJ#qUB__F zc4o5GGcUZ;A33dM>z}GtZ-+Eac6B)BcojfTcGCZWEP>hN8~tNb{8;Y`nj2Hs`Qb+i z8JnC^$~u-bJ#+3357XUvDe}KwEwb(KoM`r<#LVBfU@bMvxHfKvVt*h1mTuY_<8GKN-%4Q(uCf2 zJ#OvTg|0^*ZWqA{Tp?(9p|MRz5qPe2*ijFL-!<9*o^)BmG3_5sHXPeM*4$WwXWlq{PxL zF9_a21v#8tC4|eq>G*KzW{o_0^TjCpm+Wr)qO57tRbUCYTYb))Z0sM@o)&)7qoBB6 zgFZY^<+8W09Y#aJ2ePRhs*>q1Er|^f$AHC5T*h=q;t>{EcDp zdb5-A%XWAM#4vAg3nmZ%_m>%YWADY=}$B|;8A5G2L zA(#4RH8tq+s%^Z6dA)=MCFjoBR*-MixCCKL8ozzksRYEcmwbPTX~FjT=0;qZb;6F$O3R z`hdb;Rdz%bs_QL5()5_E#lQRG?5?6iY<_)HmZ<|39i3@a=txkaYLN@L8MXRmTtPAB zwT-rnBzveA6Gjc7MH9V*gTbY0nIA{Q$2%cI6~~Z_0g6JQqPPPYoY4UeM2L@8kg+JV zZ(9c$7_L(^Qv@OF&10gX@nL7r^Ju)^b}ql9oYU#LQ@=_^A+IQrYh8S)IszGx*88txLyY+@ku(TF&=DS^A{4+ zn6H&7=>JiBe<_eZeUTl=Wv1fsZw}9Z`f%^XGy!lPu28KvJc5Zr8mu_vb^D4Fn3)r$BlJ z>Dxe9_t!u*{2?R@#f0S+A@dG&@PZLv1b*RP(JGdjdiGC)QhGYcd`K&JSh;Z?-}!j) z7kzoOscJ0IGxA|(th#xV24hF8nyPXVZr{pe^I@46CN#sIX#POYfJ4?2@l?}x$`%QI^*GOdUq4Xca#<$QVhz495sSK)q2aA~ z5OOCeqVd^Qet%o4WcIkKe_x-(%_euRE2tzUJdk6I+Co!020x$~KnFG^Y^z^doLZxE+h^^;NpUCQDk$|8rfD1rQ&4z)RYkKPnIH~79S2CH8 z6Dc)y?d{L3fLjcCQT>$9uIEzF01Thx*vwkrEg7Sy$nT5(mSbVrSH!8we^C9&7?A2$ zYDpYo)Gg)ZRma@MJ9qfZLpko8c-G1U{PGC0-LJ?gS}$&ac(6_1>(^$1=d z{q22k1$^yL{=F%SJ6`RswlU!K5Ptr?h)uP!eHa{RUSu#_gfT(i>OPDK&~i^u<5Uud z+N=w4_U)IRy30bcAEqF4V6c$D9@yXVkwUXA%INoh@FVSZ)y_uHVm`1=N zA2Iq{GX8PIMKN;<@4JD7vSej5vmp8hy>ogFJ z|Bk^*5Rcu2s}H|1l97!*SQ%>^$3WP5Ljo~x!m72l;nQ2^|0O~mh1R1yXhZl%AU*!? zSP(khuhW^0f^p+V!#np%*e+kEjue8_0-7qpb##vQdJinI6RM225wA%8Es?mPeu=?9 z#yKoKKkR9tFZr}6jT0!IQE@gp;%AH_~>%?EpmZHI(oM^%6S7E?z9nzkD8;38z+uooE>E?qeCwNRC_$`l# zwn5MTT{9e~GckvK5S^>f>Uze?0B7g?H1RdNd$hAGH{t6Q!I#6F&Jp9FCbuk-N#f7{ zA3gMx+zf3t&Grr3q|Q*z?x&wYpeijm=G7`wyft=`i8giSz#Z$gtF96uLGQn4jEV~apou@8AnJL`S+Ln zcTcm>K zi`#9u%eS!4gphCKk&isnqbxl2IlpmaKlE5P;SjXv;)xNQ)!Ymc=p zvoAk?B+dD=bpNb1;y8y)=bcY=N3SAcmJE(Mn{QsEp7tIrW!OE?g={z0DIYYz;Nno= zT(jd3fuDUgb_l}dZKcOVl>74Z|5n`-&fF5@RJZTTgm5s;3t&6UmlgYMZ6cd%QOGi8 zaZ6M@Il$iCj&gSMEXGd!f|`Z$&q)2xrUgAuNAdST^1;f1tOsM%usD#Lsu}sSJqX1v zA)zM}b{?+;x#Iy!Koa2TLwV_Ccwm#h#m*>57H{>qAOE`eD}P9FiCwdw-nb`Oa6vzX z?B;CLu!wCq@mv$?+M-$0&O5-fKvTN5bFl;b00RTPC@?o`H9erwKNUbFKl5qKad5?L z%_!!Tcg+4iw{;cha|j7c^Y-!yRizkPUceIjAR=qTY~jiCR2yS{=5pxI3CV2B3W+|s10Cxnro3c z`GM7;p!h!VrD@9Y*ZhW$p3?v9pUJd7b|6(H2Wc(xJuXZj5 ztFG`g$PGF$h;M`hyYuib8v+yqsyQ6Y$6UFm;^NSOAb@tI`XAyBdHf7MfafME3NE5^ z`|rmB_KbaI{wKCd>;gPnh}Z4FZizr5ERZA;r+H~@2E!u@b{I<*}3e1 zdR0*Pm+1k}3cq#EevV4~ou%}<7)~_%VH;XXPVQP_FxyLmqH@WEyQ7{I;jErI?eKlw z0dAwQ#T;oBl!exF6g#J0k}ulLCuuHHQu-Wj>%%=){ZXCCNLCLvg90}{%_RtIyXZyj zb*g3gR2hs<{UEcO<)7lR`bv+6gbfJ8{`dm46u;t85_a@Oq_WgjI!vW#I>UhjqvK{3>gh1M6%C#q5s;<_~4|Y47rrUoxIoZPM|k>~zW$ zjBS+DsESC^Yf}=M7{P?KVe{(ZVSD@Oa@pEpUrVT32w5^B9`GYG&FB?r@rrV`NPe~P zz4ta|h%bm3R2opORV>}l{5VvT+H;3?xsLvRJWHc>UqWAfEaF6YaT`t^U1$SmV9W%Y zXshZffR(&ruHX!dgUNY<>8eKEvA;1CUN~Z3A}CUuq@INR+|e48xc^}n`zHfI%-7Kc z4ALH?Su)j>k?L?x%?izmq!fl|%$q*X*Dxup-*(sdN-Fo>I`H{BE8Xd$o9NMa5NR== zr-~3-QK_Akm-1Lr;V@Tznr7QN|M|*O5c{Zm(qB;m3vwzT_~iwZ@pt{mrsR5+=o#j# zxDTw)#`mM2<)KN5MphwA;nCQb){2;OB5;ZFIh_4q6;4=YslT3_Er#!W-RyhlwGzd$ zYdx~-P&rZZg30UCw$}&y*EU@o#pc{g}Il7`np0dD@taWBYu~E0#iy3G6jpw@C7lPcXzOXQDgro#LgmBjvt8 zF(OO4rv1jx4_f7B_Rs}yrgZpw7=7R14(@wOv&PMYqqff#sNC{6XKYi{AC~7xdNt@% ze}4N$%gwrTUP}H#=vtsi_+o|7ue!%Sd+l=BHpkI=G+BN&;-xAF_gGx!4W*+;OHHyg zJ$H|*#)mFq-B!z}+z!cFla987t3ekBHI9SSGjRAsBrvx)NF#zf@D;3;oowoG*edz>K0S6&NsEBESJi%x^rqtNJq3j$oI-wnHNo&`cwGV`me^ZN@WczzoKqLfGSVo|Te_Q4-Lu$ebz;%pzJL@uGDC7(+4Ft`f0s`?^Kle06fiJE$lIi~Uh0S)499j=;c0~QS&d?vJliQXx0Ja$ z>R(I8bNhoDy%+^Ou|cy`aDTdya@PqCHt&Z3(Z5Ouz30&ZisRELI7 zf?TW?*`GxMtgSxd+a-*Zi)yhL_RLvp2SpIo$l+onQElR%G4Nlul`hrt1+&VXB+n}jDk>kiqEQskkFwa-sT zuJdJ2^4K(Px+OMkvEtVGJ?&KE&;r{>GVT+HQoa7I&KKZNU;AztDu zfaz~Q6zbOYlJuqh$=MK+C{^7Ho9mbZN~$=i>3B&q8q(b$$AcMq_Je@F3RBx}tA`)< z8EQ{cnkNZ{9jwR8BzND*%JFO534)z)xUq_rElZ-6ADOefu_Tg!{XRO$0^l(|3`-~cMmn|2@sS;Y8-O0q8647&<+OV)NoE%KvMESc5n zidl+ufVxGf9T6Ze{vKSe;8Pqvt^n+k-0j@mg60(mDzT|{IuGV6nqBI&bTIoQ5z>wv zizlu-H2iCsG|!?hpTu1j%f}b~)GTrvEV|exdn2ayx!v&f;E%fUmW>sBEm#;L$Ldd3 zE1n&Sr2{|82Rf9>RTCUBiV^2?pCkK`uf0Ka=#9jV5|L)<;@viVke8u;y3cECJ=#=j zvif0{gtUTX#y%c&KJgY`q(@oKtA8lE4;BA}a}YxayezN~`Q3I8xt;}e!6--Ch@?I7 z02vjW6xNB^*;ZpdO*Vm=YixaPnL5?1vJp)RZT|XxLNkr8Ghz_P3fIT{KsdQkPv#s2 zs4L9sBWT{vc5~}H2S$8>7O$GWEPg+@YOLjICCrN?)%q`lN*V=Ls4#vTKsNph5)l=P zNN_RWao}iKLd2=}X(%~^CnO1ADKIw7B!xQ3H@?;68@{nTkjqZLpZ9=(jUJ?bJX;}Q zr)VJhlLzw?ZtX+wKrffeD)giGueYluh749Z<#-M9oSd&G6R0bhbQ_MpiBi43Y`rOZ z`fAV9_H`5PlF4L)!{F$twV25M+HV~-_3DNHW12UAWo7v~f8_ZyCKa7XW1ubhzuIEH zafR=Ccf9og{_L%Sz77I?tl7gcHx61SU1=s(&HhI_ROhCViw+*>K?7l&7OMPKnSh_( z-K1lHW`+B=ptmT|J1ppbX=G8S!kBGORN($Tf)fshhxWOUfbOq)3Kd0TjYlqO4d={` z{SR*zl(Bw$BdLCEfXtF_M@r;h)f$Q@cmxmUmH^M@%!X*2Q7xltr%N{M$;9;I&bqGvdMsoG?xf`ktNs;|%iVYL4Ha;4QqP&B+zB-Pygfiph*15hHORbl;B zV5M}ZtX=-z{3?>u$b{Fy{m8;m?ABfcuR-wV9{*_+l#{6Wo;z#z`zQSSj+eDs!OSA8+7~uOWl?wmuo3Vi2K|w@N)@lv)3m)&As>h8HTE z#Gmvp;|CO!zWbnSMK?f7OF8?oVdbJ1lkIJ5b3?WM-l-81{VZO#`j!={t@3cIFOCA^ z?^b3T4wRr^4crEEY&|)OqG2n{uhk-FQ=vKmAyX zijXqDbutYN&PnEuTh065-GdWdH8(ayy2g7g8zMvJvN!iNRCtA4#>3hoEB365bI+*S zY3FBy(NTOV>Ae@z(Wo6$Zfbe|kVT_1ZzLuI3BKxCmmP+-ssI3i604R831{_Ln?L~9 zX7#fGFSC$(tyi~IDiE9fRJ73!+u|Eh6Y(oj$#dEh^1uzWL$Gm@V@$ zPgknkL=R!&D6M^eFl*}y4;+mNHAbCrvy`r<$#(j?xkOLSj}}@E>W$)foCfR6%3Vw~ z!6{wM9CS?&rDkW-Jk;x9xK$k5w(8h7^EuNYJ&}!C)@RbOEK@X^Q-ii z1J@UcIP4bexI*$<*#YXyAJn|U)<3zuzHBcRYTP%{Jr~h@g>#Rlwh`(-kYq+B!ci^` z9w@u&@{K!2xQjtoHB`%d}WbFnOa~Bp*s;7jkILhY^5)= z&T68|re7OHTV>mY-Mab@zZXtQOrEWIS3n+DMD@`^#!w%*#c1F1tCHdh&un0BN~FYS zsf!;pqF^<@5u2io734GSz>sq4>#?_NJ{=OFuhs7pp0eNwpqa@V-*JaTI7CWs*OXspFxWGD0+!oOPNw687|a!BbEB;a-aQKuvBS%Jim& zgnf+D{z&3P=tLm)Aft4X0uAqUIWm>d_1)Gb?{iagk*Q4e^cr*eK5jn$F3-3SoR{*k z86ssrb>4O%_?JT#i>Q9DiA?y!W*4KjpWwjI)kNH(oHQx664i#dp_esL)qi{exCO%M zclxOY!6Bd_c3b;E3M4|cH_i3NQW7h9kyi;z2M;OHr|2)+9OSR{9Mt-bd&+4j)VNZB zQ6>GX7y>dLE#8VMYg_Evz@$E7GoP&8)u88mM=&F6s~7o{(q|2gQhiQlVr6aEs~bjE zG0vjV0ixJ(nca7b>G2@v&^U58PCo9~fAhkUX12&Pq0R_)RDAyEr4YBPK9E0HV^8x0 zivPvh+S5|?>u0>DU`lL6RzIAGX$3em|F6hcs8o}~@Wdu*(0(Y9gv2RlgStylCYq2GLQFnl1oYf?7BCp=bj8D2+v*>cggnLL4%USJZgWOz? zBKJIA8=vljW|h@PSE*hHUDW=vtF3Vd)x4)r;v#pn&pxx7wDWvB{a8nieC|WA^hAcnX#JbReBG!lQomr18Tr+o&x&*K+=abK4%{ z0Zx|}P9&N4cw$g9r|YAp=QlIdRnpFS?SxcK!jQ2Kl@@PRhJu0w>c_sw&A zW0|OM=mW-z`@9-j4fOZ+0>5G~LL?5ywWg!lACku#FIXJfzFfq9!qGENobY?Oj50S6pFf}2k%00NrTpU?QH zT)hF|=GQU&e5`B!Q`S61U5V9Iw8vcaa8YUDQq_LSs+Sd}YYu-(^(PNshf>K}F72j= zJ9{-cE&FMy40-N)^X{;ri~)BG+Rqd#Pd|HK)5~DEzFbmOb#^t}Y)jTVdg%r3W}Eku z6Ak4D<@UA#RMp)c9<~NIjb!8LZVASBu{-B66n+MvnPp8+P;?S?F9I4qVsZ=;$^#sN zbqan5p_jp}i-m!j=GIehQZ@(958}nsklXAG8o5;bgN8-n^Gme@;Uk#6{hy{zuRde? z6(lxe^fti;@-+@4VWlM$44zMVTfHc06zP*z z?XoHL5LX^%>&#TOs4qPCcW3I?cU86KXiG@f&&E9Q5JR+utoaw-ecxX6SBFn63Uk@0 z5)k(1G3iPUS@CT+(qO+hz{WKE@8Yy2EaY>D^y-X1t1X-}wHxVLDAG{9uPu<&hPY#P3;r&1U4)4?zL zOTMJ4^#%}fg9K!No@2T4Dx^QIH{&Rw>5d?p-fHGpYPdw}V(E6wR8n(uVTpW9i59?7 zR9=6)*3Sa}bh}0H+-L!WQ*4`vP189J3ZkK45Lyt zZS63_+-du1$vmeDK5wgx%*m?;{r#gug13hu)lO~A?aVFg88XY8NEmAZrmfd!6aHyN z132Sx+lOjK$Q~=vSXZb)*cmckD{&DJK3FZPI_HBxvJn;9x$+~#jqc5(jajh!ik5Oz z8}I6q^=rk0T|w8B^x=K?yKzb7rIWnbFaRFs^pwJ;zo@UdOZa5I9zj^lkobPD){O4f zVRWUn+{8&~`sDoBuYz9cXaPLb9?Ybr%B%2VIq{^me`tzt;%wm(0XEXZYL1N&V)z27QwE9kxe(oQ`uZ{9+n83E;oAZzsSTOa+LaacnM2 zAb|!CH(P4Y${IX=ZeA%La8nuOV`+KGdCgsxPha7Y0@IB0$?#dKc0Go)RfdUctx`ng zQxPuF{CUvR+smW$J7gowk&L6{?@CRthj{qRcAA}<-_-MMf1s=~-VNJXQwh21)^r=E z9zWEiUSiT_@m#TEDnN@b?1bJ@FqGspNX&RKTjpRk&d6yLmV9wa5uo0Qe89hsS()k(#0N#01sDWpveMv`48Yx%Xv6BCIMqc@hl z)ow@Vkf|#-hdu+>%Mnk_&;;r%X6lC;|GAez(sX%(ET^K7!$ai$0=k8K_cvE}ja?r- zZw_^4UD87QTvg0m_WCU1pku-r%QfO!4X0+LU?Vl_9`|?L9IgALx-Z*Kgop$qGS_Zf zT-gJkYk36DJG0@9#NF(~Z(1QmlE)qz7rTSd$z+c*N!oEbf)CScs&YK9BXBFO?7FV* zI`GWx^6nNYARqXC00=AC;;oG;`Ow%rjpRF1+wxE(%oQ-WTvg6ptNlc7V&&y&A10DR zC>$!EAn_9U6qSc;(_T8{ex^45V6hl~?ffJT_bOtKEuCbUowfFie~=+eeK;aRkZ6{2 zp1O<+cf6Hrlnv0e2)4(iLw@$}F-tD^u5DVntQL=RE^>#=1;;e71-h%gb$o46mMaJi z>##Fb)3$szg?2CFc~M?7@z5=2bZypnIq*2EzY2GpxTa%S*@yCJw4V8v7fVv(NV6&u zvdiBcA#p7~gyb5~v@-?_yWjR=)#n&4e7z;}WEM(4IHFuY|57c~^O{au^;F1UI@+nd zAX*j22g$akrNv=ye=sF95|3wTL{{GAJiJt0dzQxX2eERoNuV4IqrP5FOHT;sXq!XV zliDwXZyH;RDLK?#VY>KvvUM8qHdsbmo)s z8&i^ILrnYpE6xm)F5H=HU zC|cgET0fyo2_s0Q6hAlCW9qqh``3-OS3Gvy;fvtG=h{c z|D@^RK@ro_88SS`;p-7P>!>)(u3XmnSudl-P1WBy41!iqP;(}g5>_U&t*5Jl@;f>_ zV$8X4UOSv`HgEkcCAd!}TxsTJ*t7Qjtq!L!l0Cz2)O^cY+v5DelB4^}%}*S~kLVU( z6D_iZNJ|Y^G0~O0ByfU<)tpVv;H*aj!E7b1Cs$4f=y$|9OV0kd_679V_&RK;Y0#Iu z9^mMfXDlJej8E|Q?T_JkBlv%OEWJQNGCUG(w>QT5SC|^L9{I%DdIm50shjo0zJ{{i zAkXDsyah0Qi8kQUjp3%AKl`Qk>g;Ct0H@!GYb2pdUP9pNh@2UvVT7J!$=|2eWzh@= z`T%Q2ks7K1Mu@Jps-tN7)eiX55syhncPLq{JV7=L6S2uo*NgGJ)r0(vxrbG&S?sm* z=iLuyOKKlUJTI!H8sW;RTa(HuGChTdE7H%hLuM;2r_%R+tA%u(> z|4*m}rQ$d)m+wSW(_bYw{%;< zrx|d+2j^8lrTl`G;Mp55zRlS*u3wvXe9Si;Gbd$dmZT~wGntOwZvX1f?XV+XZ@)Au z01!qR^{AQR1)`hEG2V?v%l{PHi7DXCnipYX<#C->>(|n}_N{ehW!W!1PeD@Scv;>o ztyl0}{e)Q4#U#Oe_g(3HfD3(@g%?)k=4k=o#_W9g1B>iD11SbkP*}$|d1>s>GJ&x%bsEYa zd5SkFD#w$TER0*@Hgs^Mx7Cn=L);4=zZ6PL0pFo zgP(pCar+KDX4d(w)<8amHzvMsc_^+Vt*RugGSlYgh6;Y#L;GIbs*x2vNK!Js`Fi(V zj3D<=@22Dg>JQ?CWxm2yd_$Iy!j*`c1*$oa8gJ|$Ux1Uz3Wp*|q5aN;z^PUA%&fdz z+-*pj>_#PkdBM2kp*9-#k{YV_@Ui{2a9`qM7yS=n%kSB5#N415tidr&m?Er_`<*VC zO6JDT*rwY2V~E&M5&BhE=H+bC*83(YM`cBiFN62|3lNreaaBCSBMSTp;uKO3k5F#z zR{?FQx3sA%QvPiR!1>1mULSDsA;%q~R7I#L6tne#0o7QxsW0EI!E-dezs%eDHuL!d z`Xg4)krU4Inf4E>J((!^j1Rm5bpU67MAnq%plC=bqCZYI<-S6H3g}DPq89cl^mUPhHGbq2BruHDgg4dzk>U zV4*?r@LE_wp1sAor+DuA5=UI9fG?D2p-(sJxJpc+}*vA#^rSKpINhK)>`|Tea_iupZdT>6-{^5+f}dJ zzvsChYIhmEALR^jKBg$%off0>fU{KcU8&M?vF!fDn3CZZu#nsJ!U}V1y7wHbd4;S8 z^$>;BSc~OiE=hjSh9xkOq0rPt!E`I{)#IY?Sqh`VRaK}dzdEDcF&7Uey~E;Jox?#$ z>uEZr1#xDZsON3Of!2T%7St!U4b4602uPiuKbh>|UzoJf+~R|^`IGn!@bF-^3K|}? zHE)RMh3_`-59sVu22rNAiY-da$NMYkO3-opYgwcg_&D=UxY&7oa~*=8@}c7r8g9`)HsY$OVF zO0PdFQdF0{frLZ;JuvT&#Q#AJe`GbbX~KSF$JF+|w?zm4@HIEYopAP_-3j~V$}d_p ziA7Qa0&)+W_B|hTpdt03YH&Xz|8tCNKz_3AgTpu~Ac-H@X{n_M1M1}_!<2f%=u_**{tpBMl8=7s+g zU&H^+e}YJ)W(g_yT@(H>`GZ^H|HDk~pPD?jhMSbye@orj_zfVp24a`}uMv}wFD7I+ zTV!~)oa&YS-%TMQt&qq2mofIA27#jb|ChnQpOgCceGXzOH2`+Y=l4nR<@va}SFkJ+A z?_JwEjQf6ANt8iI1wTi-#JG<#cf(hg_7}H>fqqz16qUa~QTIdR*cxacmiEqw>=L2E z=WE``FnnP05$y(U0?%I9%eRwce8Pk^UAl~@Z)n#^9YJ}NG4bV%5I!Vi5$!gR+W&Aw z@V5j2oD6&h+N0L>%>I|!&2z-yM}#xqqb>vNoVv@bIbKNy`lhP^rN)8&$L(U|`-*m# zL*gl>S|A(4&17_q<2ViNo&IuN=R%f60~>&IqdsUd8!*e~d4rZU1?typ4tZ|BEK3{5 zKq|T0Yz|{6iI!1_XO_{{F1!8#Vj{=6KG^SVnMOcF&Nr^X>r4k1 zxq!j-l~`HMt=v62Q$;-DA)-@Dt-l&uoVT{H!+F2W)7OzGfsFIhX?~|R%cm zgpmouqyJcoDALvU<;JQnm&8X*lWErD5E3>p(T>}FZWMxlFUT!@ZS#&k3^u}re|Y=x zWWqA>@>>Rv>H;&#RvXQMG0|nQGwbnNV-%SsM}Xwo?J=g)YSZ9FF+X0D*z<9%76Jq; zD3EvF{y|l;x6BzT;*g2ltK+V0(4$O_tB8|G5sjn=lKcw%e~+eormr9U`}35ql*H4V zLj7j=4bYfnoI_ZG~x*BBo5MX~5|k9}tbM{SbaCcsKad zKi*d=`y7ee@lVVVR4H7ca z@W6mT#J%fpu%%>-&(2%z1Su0C3-cNh2VMvz*9NINr}!$9GkUKcPpn}(;jsejc1{}C zB9l5hn&Z>DA57`qo8D=;1?>;If3Cs)MrX_qx=x*dP}G~Iin?v?2^yyL>xHZ7X1+Jb zz-wS7u8-8YXHJjsvWU~1GoNQ!J2>#W1o|T)LgqTDlD=T8 zXgg8)Ar)irKpu@IA{R$L-vc;!&o40VNGeB?^-d{EshTdT5fEX0pKm*nGuTe=Ylo8f zJGu_A_Rdd&DafNAOeHoJ1hU7IZFa_6lkfCz(j!R#E}<7yabnip=2FL)-W?Aikp^=w zfqYgIyYby95Y)H*91}$=E#G`D^8~3TAp)rx@krr`9Qhm=duSSap`sTUzes31fc)F} ziOvIzH_6u2+LUf+{2W}qNR9(M0*a9#TTwPw174wZ5m~<+fX?>>j7Vrph8kA5eM_FM zb09|3M)hht`Hlp1?FTKHeBa+8xgaYTCrsQ7ht`nY+5fHpib4oU)$1k%#jVLXggCcl z3KvfizVdAPDqrjqov^DSEToHNDG!gx0tJqh$6b7- zZjb8^?+WQt`M~A;g#7niA*9yKEeVULP@llR=Xhvs_LxXm=UZo$8Laf6Dd~2pFC1obNs)sAfD;FIP}vH zT#F-r3Y;PZr%L2A>_X@R%VRiji2taUo2|nnR)sZ)^P{w1fshd7Fi8) zWb+9%m^+2y{-vs|i}FIGum9Ve5Ar7Io7{}6h}fh3_ET&8Y5a@{?$Ail+jB%hNYR3j zLZ&;%^mm?8yNUM{*F(9SWr|@W$d5()uONNu2P6SZaZKBQAfNK}nvNB~wfPi(X+w_3 zc#UoNOS{5;)NAWWNPXbhdg_%^uk+{2DdT3h2^|J+$@A?RY!+@`=F9r}H#va_Z(hg$ zlxu40Y1+8UxYYE9lyDSKO=_=J{(iEq`Q|kRB2u)Uk*_O4JD2l@>UofQ^NFgg=cx`P z24NbzaS}JCttq69B>e;;u5Vdm{Fqn(fnxd~L6@A&hchTSuDKp3l??ZTs0+FFeW4m0 z6LpOT&(-m+B0dpmbvc=8c@oi@KDKmNR}G5g^?VeTUm*`=SuQ)$4I>X6<*1 zAf)>2ubQB?!0bJYr~B0c-gk^gSIZrZy88&Xolkq*8>51y9}(-Fj|+okeVy^>Qd}yX zpwr*8ApaEqd6rxXPC~&a#G8YZUgsqL%< zj|UB#Nric$2uUve03{(Rq})`&?LvZ@fs;||fP5C&+e(yay+L9pOU7oTduR1Q!9Y&4 zy1?-E$0-jc(lbVTt(}$Y!Kek-7ZLci4>ocxFHe(jo3-r!73YH#&MB1RF^}-OfX+eK zI@!_kVYd@EQEjaa#FWeQd>dB!@PfRG7(0!E*EK|UDL~cgG!JxtNNQKpu8@BA>fGMB z3H5UC3D)y40hip&CaeB#BjulS-4qCr+kmNk##@=NtE-D3SDw}R%V`oOf%{yn`$8lY zt5Rk)A@>td_9e9?wqUF&ykX}W`?Hp=dZx41UP;g1&B5JDy!m+IyQznsUJ8>F9lNuU z#7(Q0oh$2AMka#1>j(ikoq6}ZGNx|6yOr88ynEpAZ z5FNv#WLZu2l<6-=7Pas=PQ`Xh!Y_ut;hjrqT13DDZSpxz{O3cAz!TPwDM442YZcA= zb7CPc9R({YI{i~UXnh^D?T%+W2oz&(26xg_UPgT{^gLQG^5c$640ycPJLfkqmlVm7 zKM)lvwO&D`Q(F}m<*?LHR!&joka0xq=a!4RZ{kta81-kOWL0L;a|w+sIes+>WEjlK zQGDsCd3kg++66X3R^}7TQwWuv$CF5&&tUF9NQ*i&hUSLGwfo?NMdqwwNI~_7S^t0& zuD0M>#nrYeXYSY4Hp|rQya5RKdun%uYitrJTq8DtzsM^6EKA6MKUdH3q%)$S%zsS1 zLEyPtC*~RCxnd5o5k>d||8^Q!+h^!YgATBQ%H{ zX?<2&yj)bS_CIa6e1(XwMT$SJTtSR*MsVr~j(KmYa`?2W)-jOCug(f?xE#h5FVvKC zFdMw3G7=y2bIoO1Xf`PL?&EM~LnZ<;F4Luaq_W3znJ!CX;1*h4@n)>`wuOvKWW%nZ zH$ExQzO6o67Cq6ps437C>6QHCmywnNo?sIQE75~L?y@)RzgKy#_lsTIvP{f;EWJ0-I8G0FC?GzNV&-dJVfnLF4(0RvH+CnbEE~yjEX^p( zEDB?ajqx_pP?Q+oN_6_`yLoZxX`9;<9To3<1qFG{j;tAkQj4<^pH#`z)56Slsq`to zTi{(c+T&V~Qa@70`NQ%^`trzHh)4KZ(Sc&z?P!vBKlwgPMjw|_>XH>~q^@=@uO4N7{FhJKZ|xiiq$ z&djocoo((kg`3OaaGOsUlf&Q`{=MK+yT8ab%Kn_X<8w-!eMuhaj(B5VYG0g?5CoYZ z<%=+oF&xG$%BDVTNtDYFDy-}rW$MCvxFz=vgCG5HqBN8$Fii?%X5RxPX z{D6x?0C?zj4%J|&AkrBnPCTCq*UP$f7wq@N+)@p5yGM8|g&`|Wy8KGxYQ`S!hRaMZ zkn(!3@c51C4HRg7H7W+Z2J1zl`Z2nSqqK7w$nH}}1QkZ2Y$yM7U$C8aKWd(;QO-w0 zRw>>jDsct={RJdQ&5raw>&(UFf}w>CR@U;`cS&`vth2n+y}o|86n=D%LISI=`(FLT zu?p0*M|JLo0qZb03`D^e@YH6cS zhf$IBtvf)WCrOz96|6w{F7{`#HjAz1eK~6!e15H~M+REMaS_ijx8p!6)6CwSz zM&n`;K%9vL=ut$K1zi4;Jb+|+7YS8SQ<3z#h%&LJY#3M7EuEEfW_(|pu6D_4ybu(W z%i~VMl&NG;|3kMK`Y4LM>V!bnrV6eRCY($}FC1Xzdw|i`!*N#yrV9c>#_g0ODHvF` z(c_lP)6%x#A((2v+|M3UU?1m3bttH&#%S56@>cquw+FUs<%>$)1nejGS*I?|0IOyX zd@?J|l$6@|%JV^z1%aS`qlF}myi#6W&zL=<2Wr*5vXS($8w~Qqy1Ant1!S-Zk^JGZ z?Yd{1n+``VfZ1o7V}mI#waP}v%e0ceGRG z+b;*v8x5HRQtxBlFwIAFX^=a{4Yy{hCavrkg3gFMWKO49s5UcPGnL1~X=3rz0W#1bjrB zPa#7ME);YCF_DfKu-T&enBL;F28C=1-suh0ud@Ms1ElDV4{RKC^n&UwcPpoSVw#Rp z>JE~2_2>9)XO!K^qlJ|#Hp@pdu9YB(|S{{N-+_jK%!0{kEjO~%db5K z*io(1raL%%s)_9e7_S6vn-t~j9eX6<$5EjKeaRD$!TZN25hfKq?Y_^&?XWz&et1%X zvA)*N4LXIAmG8qcxNe=qN~wY^F$zoQ*Ia#*XhWT!Oh?%~)XUZ6UM{I$$f{{?uL`F2 z?lP_ju5Z?}J?Pe>ZSu6VjIC*$2@g*eeHTyk^98nBKR^?`6@DLx^^WO-;iq2Er{DXB zQ&^dZDU)UV2lY;>0CO>#2Xwv}F!Rgt5dBP>0NI3TK3Vew<#@u-3TJfY13uscOW zRt2%ftlSJ7p~uQG`I7HG6{6Gp(m$c=_d@Xdy?^-N^~4%foN!dQE?L>0=!UT1RAJze zFYY$n>H3H=WZ-gJBY%zhCP=PARe~4^Lo41`OQ6YLj)dg%m z>;oA`6uMO<(TJtEuc!ei^K8I-)XO0pw!^uB%9Td2`#Vig$nfI0I@LU_%N$%{Y~hh& zWVB2~yi&hL;40bPlKTn zSmQ+F%j47!x;52fvM8g-RGzcXJ|>ybXK7`h${Q$ol5ZkXTdm?@&7+|4TO&Vjpr|G* z!Oiqj^@!61q7!v|^xMUzQiew`DQ(HA!QFh-;~(Pds*Ib|CVq&=#z7R$e{@v+Cw*Z3 z>)380Szho%Vwk1wc*|R9NmD}0=KIgoB_H_>qUBrW5?N#C-XEzx*WxT7LhV~ZH~Eu% zq9>!1rPb0uYk;@tv>Ut7Q7bJ@BgFVT+L3Fke7Tg6a!4f(Ao%!XwYDt59ja=bm~-us zM30BY{;n8}=lnJb>y)2~$~vcNQg;KONtgtWO;)Bm0V>2uL^sjg`Gn4dw(^=BzA`8* zrIcGPIot5G6Ci5!lu#gSl_;*U(lI8`$IZP>r~)ipVt=DE|Z4;k;*EIDjrbCOzMn}+KcT!#dA@N6KhT-ij3Tv&jcTnq0Kk@KZEGa2T_($^688{{lvqyyHd=d`DrG05X z?yXmOJ2pljzn4IZvCCgA`J4l3kxbH&E(P_>^!OzDEB@rplU9=(pkdUYjLwZ1hCx@) zQ8Z4P`^;daN;sbwEIqB!Lp*DFFx9lhmab_`4U+B-Ot*ushH%R-jqk^~Sipea=c-?z zvX_$NEVj_xH@dULo}_hcNjaZjzB<@auO9=c>3p9$rGNGlseP1gLk5Od|IxGm*?B+kFWtL8d~`qA2y6Cd zPv9xF-Imq@kBmn;JsVjDFMeBbKLVkpV{GUDStms zFA)jZ@o!`bGV+PQ{N3e&lUMm4hZA@PGmM4tVTYaG353brZ){I5m@g93xh}{WTFyN` ze&Ul!y9!}Nfb{=@p?-fK5D4D<=Y7Zbw6^QC$qS!PHGkIv{?R^;1ivuwYOZen#m6O~T}AuDj7Cc!h(eT~S2>Y28oV~m z3gEm58izK?O3oBJB;luu$R3~wnA3PC6fKa0VL|Wq;)MDZ_*#UbDrJM}O2#YljI)6T zuO&Hp5lGD_VVDqw8m`tZH_-|fIpK|5$ppo>rwYYhto|sr!n{b*Ua1olOlQ*VF9OWGTo!A0tRf(1drvXa)S$OdZo;81X=oj4QVUFq znZgwBH&0FaB$Kjn|2X`uhuwx(j72x$?F2863>oj%?$(vpro*{BY&Q+in?sFC?OgHO z&ceY|#R)pncabj1*Ix@??XJgqH3gb-IOV6^s-xB?S;M7TjPNw+y=Y?T=WGqH5*2vU zd(lVop$v2MlGG(0OLm?)TI-;i9IysVZ)j{S-owv$syK~ncW#B z>al5(i&n|rK<-up*tA+lD}1kGL>a)93G-cD?NI%>E(qpDYvQR5ka}( z3@CIN43aqLw7X=Ss8&-NJtP*qN0s7TT~N7J{2bWdq;^zaiPInRZi|0$%$E*HJdT^D zz?xh$ji6M#5$}aK`g3*ZF6(#t!aZB)qf7R8()nhk2W0!6*13|G|31g;Cl8x*$xW?9bjOoF{OOe_gmAtQL#gwY2GVZ^7E7mrxd7lsx5U4ynxS< z2cueEv{`(arg*6pR%|wL)SSKj$ETJ|4HO~N(kxE!TL9VuOpLrNRB8r)R4beAA=7&| z^K{1Y;Oc=K4r^V?(Y5S%8hRE4o`&>C>kNl&jMQS{9pabvb!^^$A?F*_bKNm}y`;7e zb0uku7z|p7nj7xnl@%})9UqsKX=Qy3D#zQSJ2}r0%9)*D@M%hjOHr7Nf?FF_i*}`$ zNVp>*A85#J&vh6~0l;|*Si(UyT=~ZVKdgkutpuQ)|n-fg_H@K!(v_)+VPW&g* zxu^H@0-%dy@5<0AkfrMdGh)qh+?%%bdiW5u&j4+?TwS>@^T(5K;J#K zP11ET@zlG&#=z5I-zDu8i8a}Ra2TNYJd^hDk_c`$MaHx1db=_?bP&_JBQ?Iool7fO zH2%PZrf;bUVm?4nW4e7|5HRnmZ=T^zku*I2`Kg>ISnujh^x&V>xJ+Rp9cS%h;__XE z?wSGP2Pn>(@SBg7b=qsGsb5*DweqsED`Let-R z!n*8R^Sdvf8A|PW&p!1<+BVM$@`Y~t(Ssg`%MwY>SfleCVWVf|D;+& zQ}8hjheiZ?>U13L0B!lpNtj|F_TZZSDQT>D;@AS zG36BAD?M-h$|ByM4_?p!>=SKhL#9}uZ~gjlD<2^FGE)5fb>z#VIbG~sevT6_hM+63 zWs}>gu4AL+3f@>aw2Gbddr))UiVlMo?`oQd!8b_;4^v3g8l)4yA#sdH-q8zKSYrdG zS230RGUzyMOtqcG$SS=%eE(ocO2|H7r?%!?HneZNU@J#RO+Sa8_c$kXDC5Y?{D{C| zMML2xF6+>&t-h~)wHexrMd*9hCD5?^d=yq77d}6OM1k4-*r4K1!fP;fR7aws15~>m z1arq-cj*d)D}?}qmn zem1hQ+C`OI60@avw}4n3rZ0Fj?g&X}71m3;Yim4^T+3JtFjn50yxNR->F2e+h&t>f zq$_Wif;c;@4QAP+gfPB&@^F|>n{2Z`&E@S`b?efgf7pmnDpTN}7xO)e-qD?~bU-_> zTcqAVu=8!YfSTQAPI1%Jiveq;VNu#BKMu$GdeX_$JFdEb0JGG|gF$zkqC09@sP!v%$bgj%2F@sg;5@dgT7rzn}R;f9p3~jFCxD&6^NoLJ9Gbp;~6k72VP(M`qQjx98#B zSE^Fvf)vTX-lTJ z#Uj;Am0$@a_G_VU5GkvPK?G3CF)K#QV-QPIaYnBLkJpQL&-%9?Xu$>$*z)^ zqTuVI;#%OuU96I3*W|X)U#Cs738VJ9cpza3ra#>2D4()_eA$X%v0)$wP=%ziBdI*Q z$S#MrFkHs2K&D3MkWN^Z`5+A>ug8%#+trhgLRr9{GZ6=WztIc5gWpGO29QjR%>$*M z`go|oKZN79?>cwH(fLjnXx7T_V{-cO?`XkSjDPR%FtQb=Y3l7bDj;e-uS!qPry(QZ z%c?fNaB!_YAmJ)1KHpZsWd$7E^@LrRq<+AbMdzQqoID6nZlp`h`k_MgK*>!cx^HXm zkZ(M@hc7{RjwBj56eFvvZq0MZJ<;qKkhvstb&Z+DiFR8PCV zQa^#SmxbNL+(VE9`C`iA^EmaLIkGr9u=o-lQu*W-NQrH7XkFu{{lIj>*^@T6sl{jX zsNZRT00e82^OC6j!PT|oq`5?kK`9}k3ACaUcw3z&?vSkd-f9uREy4<&Y=!wo=nuZYyd;^aZ2l%09G=nk3<$2+&@d)vI81rPLX zT)1i)|7TiQAv9vl=&LrLL}Qu~9L+xJ+^3Zwiwsbp%tRF7xl)qz#Yb=h8ev}E$qx=l z10@Ba@p8!|-(uxJa2iB>>1xL%r24}2oM3o|Z(ytH+Z+HlObP7y zV`LDxdT~#G!+u<2_bjKDMRk1R<*m%ezO=x+lD^d~xcaCTL5z-m2>lge$eexQTdq1e zDrHl%ee&v;Ujki5=LFLQdA&yR(Hv!olysZvbDTiaWEBnqu1?jjmZT+O}hnqa*DTBU3Z;vt-IMk7saUO6WuBZWkc z?Twz{(Y^`y3Ka|eDdXbiK{ux zskGpFf|?V_W}bs989zKw;`3k%!RNng0YNedYI`H7l7hDQFO+HP)s*VkgSL^vwLv`D zBeEL;H_Pk#09pHK<0E;AzH|PNhCc`p+fBH^pK)q zZPi6^odYjZ_&wHqd`VaYaE4Ww0kzV*#L2FF<+QC628{BA?(1tJSEVgQ&_6EK{5rtqUKy=1D@zKK08%hctZ5h5Tjc$+a{w}Wc#?m z3<+|QfUX~B>m*9t_ugVePBF$zHn`l|$9Y5Pw}CZ~IqzHhFGC4D9`s=D)e&*(Ga3Xpp8PwNjX>!8DiG?N1QSA`Vmq#T}WEZ#BTuEO) zy(~Ujx5_5!Vx#gnf)2t}mEO-$%c|&foITTOd^oxvPqn!PcPNK)Gc*M`VP4Mk7z_NbVKM91eHt|GV$Uv=WBRR zS{{@|Pll^rQ+bpe89y&1>Qrd4ovE>8#o)N+*3p?Qq~-dc^Doy#1hIsqm*9Mv(408L z>@>5eFya*Ns|Vwm*jI zimSLN3Vy9HyNL?@-p4o7)yIugJe|Wuu0!_CYnpIXU3^d?K|5?x$v?tzCTe5&qujYZ zomx2aWlLqWy!guDxJnbU?P?MLu2{Dp>DRFRD+2Ub_7+1|mu6dsa0_(o2uXEAVYeiD zHgcWlGQ9FBt5Vg1QDt;8CxNnMkzL$m-c?4qdCFpL-``L*a?_chm+jugCd2? z<~c6YvbUk)qNqWBdv{D7KP?8cqWRVU(5-86iB28&p#C;ZyfJZHg&^6#%+hakJ>B0 zRF8PP#}v8$TFimKE5S1Z-PV8O#$S$Ydk5&&+q?0YaTNr zMoXZZG$ac?-E>kHhDndlz@sS@|n2r&+4>eT?P-kHkgE1 z@#F*>lITA?K8a$E9*dLsW z<88p|j#uio-Ck;Uzx{g8_jkenpR{wV*njEXVKDGwq`sRAM_q@nxPRaKD=Hi62j&Jn zbqk?-$f#_yKfG%`$2=jM^o%G;q|lCU~i z%p%MyG*5VrH4*v`D*T%Y^aKe0r~NO{emjWiJIt+jZ#D{RGfre(E|JHQ+~M2{J9>W1 zX$frP$}%rX@TIrCL96&LuSoFyUo^m>5v@l2r;~d5%8?y@($V+d7JGj-Jc8Zzzy12Z z7v#*TVc_*F^LqSB+fmPS!-xBiG4)T>!9TtRJoey@lJ(nzf(qDn`0uEGmM4TzyT6_MI*1YWzeF?t4z&0OsQCZt)qAgWy3SQ~^BYP!h;6yRsXMKbNA)TI zcCGSMf`Svd)!k0)-20`FBwPmZY}Hebzxd$Kw2RYI?}yqgx`tlUQy-q-Okx^#%}zlm zJNdDq^?emwy%?v$h8nrKnjMY{nv&Vt8J|!xW>oY(46*ocn+tBeZE?KBbKqR3_rDvB zm#h4wLyAT11C-zkdle0*$I9-YkSH5$LgU3^)Qkde^Mq;*5vd>%FZ(w(g-+0ha^^sh zLTwR$rGeDxmY#={Srf?pCnv$-{Um$C?p6%(ABpwTBs%_$3ZIS&E))nIGFkb!I#fCm z3i|NTIX_J}`8bvupWdsZLxODDu*yp8%cKix3CpaQ1Q2`C3uwDaWUz&o#Q7_8a|c(L z3RaFd^a*AuA)yy$_;q+g4Oq!dc)LeLMPf_+MMlOkkfc_-=lF86R@}Rn!k7vD?n@gE zDGb+hXc7a$)06}jx)D7tlTBTN{URrGUy9FRcd5|UvWQ8i(9)EVDcbX&(d8?BNo{z~ z^^?t$Ky-O!)#7va63^V2-Huc$!)~F{bw|@|RAq#>s?{=~YR9Mgp9SNp{JX{&DjYJN zy2UG5-><8mM66F*g7EG96!#ZBEG~y`I9hIzdS0&bOTVoOVd1)7SP;Q*&$q=|7@dcAQRA|n z4e8cQrX1=of!K4`2rIqEZ>1#45GSk}<}d8;UmtMFOrhpcv1n)crZ~*^MHQO$Sx$aR zH7zU-G+p+BWKwC<6C4V<RF{APu|l5gc;sZzad3qb z8lhCqYz>`|Qj|OF&5<4gw6v4g0#9$ z6caA68MWckB?HLx!t8#z$%;#}_rJp;;DO!F8H6x`(nZMH0}2WY1V2g3jG$c=Q+gE1 z277&C8UrJFfsb}MD!_`4+Mn?0JiDV`;9*{uu*39-%GqypqEt%@1EJwN8YN9P#$sil zA_AI0i&E*9{6iy`a8`KEp{m{s6)6EP#Szv+GR)NJ);Q8_H8QrdS; z(%lr(aH$s|@v6AiaM2{E{-8SCY51IB(+s`ULiY0UU1bT@UWFyMt!BeMF^1|i$N7D9 z!SJrJ-_ATX%O%T&5RIygAuz-ZZwvHsO8l>$G$H0DV=*JM*|5+(!e!52`AAuetz1zi zOriZ)E5mWbCyR>Ov!B1gXNQR?s5%K*y!iUY+_v4Ud9Jl}Dg={^{#LyN?*Q8zDni1m zfJTQL%58{K6{i0OijjZO&A&}ZXl=TwJ!sDI?Yrx6`iLV|>)f+heM9VXK> zyNl3??ubYGCuXnO&A)`R>-inO{r%0&EBv3NB-Ft+E{*hE`U`#>7fLcy5t4b-$cm)q zrDf41A6=UOWpk?Kg{#+3&iGV$lkqkuw=EXV%6Xph!YbbWRYJ793&(Wm-@ijAnP|d5 z?K_XjUJ%hUH?s_W`ND{Gg%64SRD`95$InPe&rnW5n_5^{Fxa2Qy$Tdo_*yv1p#g+@ z&^=E~N`7m*-08CBvmsJt|9RYh$Wm%=YK--;BIXI2VSM!_oD;Frg@R$~(=fifOuy+` zN84w0>p6?XVgURkd(6V%wT?cok44w)bVfGpfFA2M4aX3vL_kALg1*3huxbb*uhdK(}S<=XX@-$a!4ySEc$unq*|2clx(XB zV&42=3ZyQ7*8)hpcx%lW<})9`s7!Y`qiRZu91NyM@#4%YRzNpg%+g}HS5Wtn$JotY z^PjHq)iq7m!giP&6d;oK1}2}MkwelTq%P@{xiP{RtuL8tN9mj^7Nl@lblGM*kcMuq zv4A}FFzc>2i*V`mC%3xw(PaPbR~IBpR{(!7Fcp|&)MtFYF3TQQ%R9`WG0TIQH``#XH0JRni!L?Egg^&(hrIqI1t&|4@dFp)HPZ2~C9jL7HDJ=%L)k+V z_L@VvpT`Fvw9finvIY%c)f`V^4+*b4TX*jYgqafPAHDj$vAdX1dtdlZ6i#qQq!9Z& z(0KmGspeV38q;!zls8^auJC&u!`SNM;0P&K{IliuB{eRj^oT;rV5%4UeK`~-tDfUB zlB-xddI*7W8#1aIunCpsiY6l@)I>Wqnb1#L|Jl6n`!BOrpdU3S`P*CV$f`a>MoV8}&f*YR1Zq3k@C%08psjn*i~QTX_bmvitFTRbxEm!{G) zZdK!}n&ZYoWQ=4>c*WyvN1)g&@0f z)N6IgDgR9Nq>H)4-rVCH_+pgFe)k!?7Lzo)3JLq#KieK}3KhZf_u=C@mN8%Dyiv$B zux*3H)jWZKRI`+X$2pzO{SKA;Y!KCo(>f6Z(HRz_S^IhqDxM-?1Wq)XDLt92t~l(1xk}`Zp)I;_(1()Joc%#RHdFTR2rjqS z%frLm(iE<+?Ns!&jwPid_ap+w6PC>T0f-cCWYKo3GCZ2o&(qVo7giq+opwV_(=}yn zgcioOHVg6?))><63S*PxhTC>w=<@_8!X`=NIoHLa5))Ao}8+a;CMRIrFri6TQ6py0I2w= z<}?%8;FUa{j0|2qsku7~DA?|r-iwsL{)qyHtoJgzv2L^Anrqzxvpa0q%L77?G18>H zMRQ3ou6hccWv>mZ;7rQ=`6VSDGR<6q_ndBWW~g4s@&wF6s_ca=`ci`^p0kqDUsL=_ zs+-v<)7otdI(%s)iV7s6UK;iU9fH=NQ;h85C9)&0y!r}OhILZE2i#Pr3tq<-kdN8c zq0Nk{dOXYDawxW8W6Q2hiC0P$A}iqM7r;4cioIyL2oLD8X{0a16&LL6`wl;iTHRNQ z?21S3Wgz>ZxJY|D-h;hMH4GzMRnKh@)cU77W~eA=H_yt~deCM&jeeys2)+to)vIj5 z`jpOC80pK9N`aVH$pvtEfwhGc%UH8=J_82Vg?`BK{YBCTy8SKs1!5H;8*)Cz9KP`I zEsxSYK24dfo-H1K>@aJwcR%(QX`ZQ7J3R(t5nvd8`kw~Ljh2C9xChNBz*T|s2boX4 z75qBPELcGBgj{lu30P1&WGOmY*h0 z?<7HM0mkn$f@PWdCzf4Y^O9Afw=9OO?ft;jNa{=T*!cW@pJlF}pNB8F!wcNuQ`b4N zYsye&4-D0t5Wzo=HUb6O-l2Sk+?QQ->;oxYOWFEp}n9V=r-KoFI5ol#B zbUjvy&n8Aydpb5{A$Xe z-lej~S-pbiW{Zn+g!lCmj^&sD3$twEw>-RqS@kJSX39{AK9lXVpWi7623S*!KA-2! z7Q_^tUO3BD60H4P>dyBrRh;aF{rux93TZ2^>Osod6iPsG!eXkwsO=Fp^+U5=-X6G= zR!d>#7qcq%$(gJ`deIgb^WTO?T+Ym%j}*WQp6=DMX9vus+l*i+(y?er2E$=pUGSzNI0@p+SGC2EmCmn3&AXa4b|lCK=+zK=@hVAr!fO>b z((o)nSe)0c3(H2w_5I70g3}?`0~0e@tC6SXTF(GEZMW5n)G8Sn_kRf@ z1<4e2G5kNusA=bi4S_hD(#_!%!73~tap@%5+o*;6J`Q>uRfT2yl_#$0<*)iPDf|^G z4N^CZMNAqFK|-~qwdiKJcya2t(~^rJ3kLXO9Rt^C6PgEhbmVA;ZJe;)PXh>UZ$7k> zyB?;XpO5j#Q3vw}{?(^I-iuT7eP)LbBIfv#<*7?~T91bPSNLcbnd*!K(f`Fn8rtEm zJ@zxkP!grgWphM{(Od7L!m5EI*L&jDSB#95sFNzn>7^fsPjhzZaTRLH1tB%so}!mg zcGve26db2EUkB!=t(~kY<*_vek`=yD!(Hooh$i-0@VcjNZKFt}Uom2!$Z@~%j^53d zd}70|@_^t(IZ@ckxhB2(x14xM6HQXysudGPkUTF{6sW6U8ZbHsM_C>SVzPZ@%6umu zGq&1cw#&Wzu$SfGfHp@FYXtZ1qH=Vt;Yj%)k*JylHmkyn4QN-ssXVjua5^3jQ(f^= z*8CZ{6nuE#tGm-lngo-z>U7WBnXuaPOu(yL39~#Asi>^UTt{FB1IKdJi5G1&3fS|$M-QC@SySux)JHdmyySuxe4L#k{ z)6@OEGv7Jy$U0qrr7BrjCA)S#`?-JDb?4-=BNreQI34+|b6+=68($X_Up&xH69d1Q zk9pK+kUA=5Z^d25nNi%{0 zJb2r37o-6LWs&`vZW^(bcGL}iRyKD?Nw)h3e0S|FG4O3lrs6w$3jhjARRRG~04k zOR}YoH?&$fGQRIq$Ks<^oL_W|?e%Nsk>s)X`8&TYUz_o5NH_HtHQ$)~G0;152j33B5Zf#lDBqFWb1IM`L-C){;GCeHx(W zWKSv10=o61H8p83j)@O^D7QdtRB2$?L%jv;y`>rfR@0l-IRg9)K}4x(;#=OGRlkT3yp_yc90$ z{?^+skGmHjT5^^#X0qfJb1FT31$$>>Q;}t6hr-dhOA`HL6Cr|m%D@2cX~Q#xW>IB_ zgP1Rt8{3|pZNxc+>E2C*JVW1R1(X&_HZ}8%6c=Xq^o%kfQVfDn6l_GyC$L@x&`ob1 z$V2x=yrmeciLqV&9J&vOkzv6Wl|;Co0ioQHC)7JI_R6q=R86fOB?5`|_0^`4lQzZ4 zCJ1)P(?K;yM402p3(S7Fqkv-TDB&xvuHaS=gr3VNwkYyekSsZ_4IxcQGeZs%kQ3?(`Ucfi4qg??-(S9WcAp{oa!>e7NOqoQv~<%U*c# zd$EP*Gc>oXBIVZhlk?a*#hrB%DUs%*YWEoYQJtd61TS0C$0q{Z>;OvbxH`VCr(uEl z=SG=B6Omt$Cclc1{=E+u6%o;U*4UmV)Af`vA2GuJE@<-jBWC~u;5SDjf{Ji^Z zH8*>xcE0(OI(N^XeP?G#b4`;rbYK}ynC@m(?1^0XQIst=Aa(OTa*kI7RT`1cN{o45 z6fLvu={yUg^Uvl+bHB=sme1a9m5}@}HCV|ErLEk?bonVaQlaMRbd(g99s>hm_8;lUDgC&YE|U-s=Nw zd6vzUr$~2m7=)TLFqe&I+Fa_AT3~R8nE3kYP(*T=e%x7n1Y_w33M*W+qmmtRPS9mK zi6>5yzqDKWyH4z(W6cz2Mo2fcUQOJNfN@$Obe<0S5n)9e8l8CiAG>rqH?ZnnN36FX z6FXH;F#(9ErIhJp<3hnhXUQ3o)Qqx?{l+v}p#$GZ`>jRyJjz7vk!8t%Z@^7!H%dD4 za)ko`X$d!NXzQeDRwj zIAm>11UMxLq!}jwaZd*IFR6=U+AqB(rqT@#!mMVlbp0{EG~BD zi~7j|o_gSxT9Ct3#L~1qheASI^0JNS`ryh3dQzROAr!Mo(lOrE`2(^Y37ojz0J6m% zE;TFD-jrEod;FZr9fFp^44DN&89K>_6520iQ))e(ThQq%)Pi4wGkZ-O?=`zs(diOX z(Te!obP^LX;S+&2H9J<*8k_7FOA*VBae3i+HiX^ByQjJnR#4!*DJmbHeIEfPI(bjSa`VfdkL_~1qX7~+ow zD>ziY_NNs5wlpNsR=J_PIIuc&T4NgHa4TpFWt}^%fx)F#u}k%hu8C@f9*5fo35#`Q zE9GV1R$qi{qA}fp%U^X5Mp`;aC3g8B?+QoKKV`WA=N0hU0lhoySKx5iuGlfC^5sIC zDWcX4mRUaPFD#9s#9{7ekSlT=qj&m(dNE{muWu^jH7ZMCNHsKlD#KN~c8Ow2?W;(W zW$WZFE$MGQL6boDN!~&?kFl*Y^p9gCxtlnbhp)R$5Gl@IrVHsRNvGJK4vN{%8=*a+ z0fmy0dagQi_FT){)L5yU%(iT$^MZZ`t)>CQhz50R`KIIO=oXnC@N|iroAN59^4Xoa zxvf?|coYW`$-q;8YL|9A){zKO1Q2FTj67HML2nB7QTxaNtN|)mLFvl3RlGi{Jxi9x^I8{11bsA zA-7YmuAQil#2ULVo?*n8Y1=aFh4;sK&Mv?_D9tI!GnWxw?ZDhDx z*OJ?xXtsl8D2PkW>7FIfE*xSXLXg0PN^c3(4mU`ZnHl{~mh?a5NBWsJ?I0khlv7k@ zSHjR-xO25I->n5|@X&pTJ2F5)vsx{>2$@A>xu*T(@lDg+3IY`eXmv|ORF zpdhug)h)eab7v(}F|5=~?P&=^azg9$Tu6{=iB`#4w5cp}b(r8P$-uE-zTQ2;R16X95+Elc0sRER@$L(J&$U)=#Bo^0!462t5(xcPw7G;tAs)!A@5a@+i2XnhQ=j|(WI2n zVQ@SEsuT~_Y_`Agp2Yzc9vE@?Som#V%xap{WsI{DbI-t$?y-UgcU|(WydnO~M%`aS;N}IWVK}mK)(H z-Lt6pG2&%iS6qJb!toAgx5&?Dz*qC<#=PR0P7^}KrJhIpO6z|7>ileV zIm^`VGWgqM{A{~Lzp!L}XqAsi}&D>Zqs`a6Z#1yJ* z${p{UxO>A-Bb;t}a9NJYz(}(8VND?Eo_xj9%cg0zD5t~3<{fq;U=&<(FDV3VpfRkd z*MXEVPut_gJJU!$Y`kB^NA*Ev2(mCZp7Zmg3guF}g88*}ApTzkTTdmje0QiQYv zZ8~z+R*}Q^m`RQJuaECaW1OLMugZJ%l@>X!TT|UJQZ&b~&X)c2anaq61Aqu4QD>e| zC$@-@^1b%bjB@^^B#9*RX*CjvjhqB+)sT$!F&2a0=3(fh$cT6N1wLd1=9p#4LU`eu z(07$1=HEe=d&p85wDrpFsQmt5$dM<$AvmTm2Ud3Z~6dSY0S=AlADql4PBEc1v3;L4mH16bs>V!Ana z`w8p|P@>_2p@Gff(R_dCw5&GwOgrBT5aL*r2Vypp6Q^ACN+hIyy zwJpP?%1ecZ#1+X-1`2o0=5lSDVy_%VtI;zI*?Z}YM%*}K>>*tqJQ;7cJ1Jn$)~B6T?5g_C0V@rC+B5lP)l@^HxPvvGQ;yuy zu;(_{d z$4od{x^rwxITyA#+MHA}^YflDTDd3%LLVl(ln)`*mGwA=iA$vYkdbJCM`$Ut$f4LW z(^%6<(2}p9G|WupB|cw?aA%%A_cfbC1o(qyKZl_Egmv^C`qcGIP<={SypDbnPwuCS z!D1;f8+w}%{*+Il<17*<4c&C>i64&rlJZhp%;r*ke2>8ja3<51Wgu@b^oMc>6V;=s`mQUWn&lAu%2J3xouN+O%J|p@HqWoNskU9mZ~K~gotB2rGGgG@0(@) zH#&(S92vzbmAS-3b?>prNo+2yc`8)9{L=eH%@I;J%Nnubo)7`pO#{GFrB|&SQ@wtc zum3&W;=Cj>&p16*ZwX-?BEw#h?}cq&vC$e^UdSAXOCzldG5zypvEk*mQqXgwyySD} z4Uz@RirCsKQPt61rfY7RCYG3-L|2Pd)uDm&zJzo)oiQmwy&~{2m+E8`EdD?xTDyS8xA&H(gDqdS3Kfm5K=#gc(BoG)gA=-%A z`H?wB1{9uN&w~^$W|K8u2&C4UTehk%M@UGEwJn6FZGJYwFFKGpEtRY)1fmO?DlvDF z%1&rf=Ik2%AkPkT!_$ib&~^TR=p(_RDThKq zG4Iz6h3@TOLDy6kZEN8YB=dMsxfn%+k8W$Pxx!JCg^?Z~y_wbKv(G10J31^C zxVIgytN;LHtQWn_Lk*s;l*_FG-B)I~pOCvTEcWPf0^3eI)l6YwXXvc!F24s;A3;cO z7wF*u@5mM(FnsT^)w++wkX zvXYE%L@%17fOg;V{Nv7|q|!T*4M0iMP3pw0{hwQ;E8=(%}jEvkHxd>NT28 zo~|r0>k0Yt(C68J;jQQ|Ba*YjdrmZ%2^X>#=v0ksa>7Q=+h2qm16NDhUq{BnJK-+u z_qBqL9{iT+0DFuMT3!5qb9&ESv{7ggK+r3f-tBK?MtS-~K|mTHtVL}V`q$UyjT3*) z5p3xHMM^RP>rkd1cShLAt=CSJ39J7C*H^nw;_YX&-_2Hl4Cd4khJ<)1g>F(G+46q? ze13s&(AOA$8h7{&ee*bF`trXr(fQ{-{C_Y+F`S{rDrtJk>cIYA_{e0lY$6ZD9{GCU zJD*-LXRW&q^&Dh#0n7@Nr)Y*bCId_l7TVx<3q(f zbp(tJH}dgYVNeLRzJ~#m-9Ip#2j-&gQUWq*k{I$baD&7pW6eJ9zbTRzn12&`trv{A zy4?+>8*?^*l1u)Z;6$LOWk-*=Yu>NQ=J8`JE~T;DsMwHhxN&XAk93jYdSGEQeP+L# zC0)8w1yHkxMQt2GYpVQvQ?7-M?j71$Eb{%8(PilQ&Mp4>Hy%c6R&E)1x!_mz!Ev``tb3JnmDqQF_cs~4NKHjgkvBIA-x zOkmxc7Fu#)K+MMj>|83auw7nXZLBz@Ykh(~i0V&8Cg*h2yWN}>c|5~sY~00Eo8D;I zXqiMPao}X;knbuyymq*$)zvX4b+&s&S0Tsw5WVk6qRRy>t(QBD@&Fu5Dh|SP#4E z_Kuf{1zDq@v^+&dhLR+cYC_5R5YjqL@cf?y+_!`Z0y*~<)*&2;d~@X;@3Mkz4&(FH zca@O^>Vnvq7NON0_^y0WTY>PdkhPh*eL?z!D;Jfs-Ja_$plJJsfrJqWU~^;o6H`V= zew3BUy4~+e+Ex-2HOVx;*!bI5DBa|m-g=Yor|sQNs9Am9&X2B)(J{2k$C)#`^`n2= zUKl&V%+``e)KRk&+aDMCskU4abGrFH$9VY+Q!uKp=Xp;FmDalUs+&}PY@2UTW)Gf! z(HrL%YJNC;^4Eblp^t|MNcH~~mt%KwkJY0cw1MW8Nh}{ApAH3kL{WDm=fBsL0yP4Y z&~o|4Z;K0bE6csxFWH@xPTukFxEve}#~j;TpT9$M097<_o0V_3XXtd4J?2ozGt!f; zH=xn+*dT1IMUKCeGZ8PLzw&5cyLZSU>5 zNwI0Y9l;~Vr>xa#{0&DJY5~cG@M3hlCM8PEtcBc^D^-tjSHi(IU@3j^%mp{k#`uW8 z=d2*dXMG?LJB#dc(h7XMSx-KSl@`3*T&9lcn1W=Sq!NRQ)DPUc)F*yTwy~>pzUG}_ z;~w+7!G$|O6F;0_k!|I?YW!d@R8D=eIsK6?$8cculEn4f58YyG6|edAu+BTu%D)kT zU~N7hXzG#r1fcYd0(Y$nLw?Tnc|PfdW^+GNsNY3Ay+iWk-6;nB}U7Rc*=baa7rtKPHM zl&Eu^?yb0IViwY4EdPPN1%b9fh)HZr(!nE1p$I`2dv}c(5RMoR66}=jY&Msq6=0aA zS3TspbQUhdl_3D45&1GRbz7?yt*a!hLV6M{>W&UA(v)(=Q!Cftxz}+JVCDDB;9kAB zrxh^+_Hl)$b2%(B+%%+uWQ~{3y(9Pw+4na?!_#%Z+}K^hEgFg`1m|E8fmZ`zANmGs zH`Q(cO8iO6$WPr75+Sf0U+_`IS|Zb0g`EP-{tj{Awa| z9`e5)rC3D@$u0|E$7QCYILNqiZmWy7nlATdv~@vmy<;lyeIsF8&-Dh2!%`BFg`s%8 z7tFjFmd(xHR@Q54bw8P|UDHa)GD6mQHH*Yf5X`Z7>19#doBldo9>3|N*y*o{eH;n> z7)So%JzbwZ&e$rw@W!Y{=ljWg>SVKp9P+}gc z7aycnw$$M0Z>egMIm(mCwb?W!201LxHZV#n*7Il8}}_{PBOL-v&g(^zN=MwIwT*|z}9}2bVhMe^^m^O2Kv-7k6|ti zw1?9-giZ0rjKynz+g+w}&vMtVyLCoyOVQzax@2p`D2Gqb;_%6=QGotrx7fGBN)_zp z;fZYVAB{61LzccQ;j)k=u<}~Yh+RR-MU)1mB5=6hBNIr=X%&1*X^Jtll-Q~-nl_si zpQOM$>)V>Rfb?P%RMYKh89Tx=Vz*i`9hNXyWP_Gg45uwt;LeFrh%%b37c>7_=!8^&uvc4ADfCo|< z9zvWNF`iGaSg>GWzP@SMst7fK-Q*t1Og!`EqNo~2348_k?j4Aa6FO?xNq-Z|>pD&|DiBO=1H ze48#j90z(ZE@i)BFj=@a4bCmE#zqRq*Jzwrbet$D-M>i6_0#T5|CHHpFFXN;Z^Vx& zc!<|-9P>!7yhe#hZsY}A8aflcQ_7>hesse7WJ}l>)3JGieHHeZLV@v&wn2mKf~a-R zUx+vtExxvWc}+7O@2sT}PejPaFkDcQX{sRtNS|Few+6p<`CX?~hG{+6i0O~;NLXLh zW=RJbFB&d|+SDYniKGqDG5UA;-DOl#xnSq$RBWlYnZ2fdZ??ocup=#7nVOrTnNK;r zpqM=lDLjcdclm}*Q>Lxo5s9(M_1=xNlRLtxs(1tfmYv)~LJ-YnE`6Z?D-`MAYlVsqRhm*N} zp?j{X_3yfU_r^2Zac5O$bVZfp4w5NXw|J1PGBVhCjN1JXBhX!gBq&! zfCy19He03-tWBcW4k`IvD&TCDUrdoGfS>X0pw6T5vRO9 zR5o~^NGK7I4&MAI1Rbxwf=(!!{X!)v2=n&6P&cu$Qf`ZZ9{*P&A4;F)1V3A^F z(0=mdjNGw0sh>+WkkJR$j2;IAg_vS^^UD<}%Wq?PI_8FkP=l~~6-wTy0bz+LS zC(5KXh*L>6eY?yuom^E@Xx0?Y^Ed8QrGc$nfAc!A+q6D^^j3UNuu3T>X8^Evu0DJB z)6@ry3#x|O8Zh2xJ1a??4YjA;0OcY>ay&V+dD_zq}Ll&>T5#(1P z$U@piw+l?J%hIb;Nh@1nBE{NHC7~}T`!^VUoDtXhj4Eep&p;BrVU>zZoAh3p(37N@ zMqTGCq;&$Gy?h*y%~#Ufghoa(d`q&x`g~wjXjjhfXY~$>yt_WxZ%ECq72z@k? zA#(Ah^s!jA?B1S&dS_-V(;QL3sh~sBqE8E?{`Z!p{jO}I2hF&ouB1C1f)e3$dIxWE z3+e3#+?ctXd2N5!T;@eVAHuDe@4zH08bjcywJzMu%0-sgl4Vyf7H&D(V*yMx$xP}D z#byB|E{IgOo)6heyWMI>E47oJe<^XffBT{boxVrY>IAYySet1kVRs!n{?iHkv5+HA z(LnPMA4@*3BaZqv#&&`++MRX#fOmH9C8zkFJ*!Qfqr*{qdm#Z1#24vee(TW|5hBN; z&Nk}rKM)9-ec%@sMgD5MfYr9pNOe-{+$!~Z-m-nf!}Cqwxv90rF2Y<<4HBXwkqoGT z;f#*-o{)$%%UHv)?(!I4oPx<9Y4~HE8RBkBae)*maI#~TYwK9!{1xxmIOO~;jSy6( zGSs&ev@m~LvLLgF9ryK7W9BQaOmNI!+eXjHmb-Lk;Mh`<9{#LEl`nrapa&BM1_UlD z8;kFtyub4KA@m?m))lx;lf{=gOpNJmuk(0_mK|)OkKLYYWZFRuhj?+Z0YO11Y^tPu zMs`DD26U(UD~|0pA!a9B&pKfN{m+F)VI1^A3S2D7$CTMzf`&S zwCJm*ZW{Pp)$9@vm1hv$Wiw2=S)N4GFBlFlhx2jx?Z;0OspvLX-|8RaAbPFj@ld)K-P?3)VZcj7$#zTkuWE>B`%ti!E6shH~fIk@f@*5 zol_R!3>sT#Z7Sd`joprySMy*#fLC~UOo|LpHcpU;*HS9 zVxpD?;J20YvdbbgOk6ul*ROn5lgXz*@#e(sl-lrEV}xXPDy(nnRR^xwTnL<1n=dhI zZn>#i_jeW|8e>}}vmfk$f~=Y;EdMDAIXFxUfHwo37JrDUFk&`i|G^#{oEsf00GP-e z=N?UD)s}(bo`*4IjJ(W%jZCvW4{LaYyZ-)}p(61f5RBw{Jq07ygzKicw^hSo#~<4| zaY{{#r1lxHYc0SnFLHeVw1n5eQmDhGTym#+Yq^ndw-ra=QrVOewQ~tUYamev)Ahicey~ z`L6WQ$;hWP#YFNnUFYQ;>^LPZhxO^#ed}#a4(hYVrgrs{-GO1R4^9Q2%}ktKMd_NW z-O`EQ*E6xGa*dnLFHPwZT|4ih**f8wf=U_yNAF?xmCpkkd?Q~Js2KfA*W;6bYFpUj9JpyI>*$8 zm}}|iZt`S6lPby>>3^(;sgYDb2I^t-YD(gG#6`b{TcpIc&ZTXcuTWn3+qK$!1PB(y zVt02v*gVZ7$lJxowjiF}kM&S+Nk?<{Mob44-Qvs-HMmxvSe^;rHi7?gN_@)fRno$s z=I5~++1@vvpx-0jzS*VfmAo$dWva6O`^E#+iUFU(8XH!{JV(yyhfv|-_ zUU*HT#DPESb#FF`Oce!ddc3pBg2NX5+Yf?hYk5~{B~K|$?44@EgMF)W7;tL0z<$xg zZ?XC6JeCVnO8{Y$j5}IpV7a`ZwRp6)pGs-fwAd~tZ?|uU(qCNzr)qj zAY-L&Bf9Jw)J_Dm{kK}RaYYHR091r84cb?`N6agO7MgjceuWlc)bBsq_wL`<-JP$B zc<6fedr#2G1C=ejY?j|15W-a&A@hLRtEdjNjbjP@9P3}oXQs8LZ~F~;P%ImLsvx>h zbXfx{GY|GK1bT~~p1(KId=JBZPbkW=oTYf(@|v}B@wTbKo%Dn&f-w$>5RwFkzNAStLHK~`*Ul1 z?9OR6psy6rgjE}AV?vrvH-++pf>mW5`akH^P_t?`H5Zg8LO6&%ZH)&OumzptDPGn)}m-Mj zc5@`#Rb9`$xMpH{Iytzv&{ z75md9_U~1O{Xq)xFExq%TI+Qb`i3B@UuXnbx2DGmUcT;p1AI$&I-MZ0^>rOjC(tKIedZ^K4w$riq<60j_vH?Hd_t&|j6G ze-pF8_@l~5rE(ep+Y;C3J zkWeeWI9=h(s%T065O7a{4!OSJg<@=tD=->T^-ZyPXopr97AKb>x;|pUC_iwyE1)v; z)%#~qOC>4!KGz;_S;xEF0kK?XBe%=ePeI;*({V*)wMn##!VYSk-q4phsUYJnpyfV0u%?0>QXk_Ss_BYExJ z%w0QU$SbQ>+<8=47bYxqM^P*H3TN#)niildquk_AR$)+#dMtFXpu{@8CnZQ zeWr1)S^|om_2j#lM|)$-V4OuG?#!_vTMY~(NDu@P26vZK8Wli0#BB5&ie~T;zPQMi zV2xdA<;>jm^r&)w+3fMpvoJ&&)HcC+#Kh^E<7^L~QpTR*o_TAmfZR-4U0v5Ikw#ON zWDfsI31;Av1#X6dbGCa|k_U|{B|abCNewv<2rGQYy4i}@y)4*XLA)g{8C1887PGHR z*2hjcn$jJJEc>*+3$~L)zB28U5*IzELg-WRKDG~8o>fTs9cGrUoGZ1a=gtY4IP6UI z5n`W>;M*@JyVMbf{&7JgCq6yxoR|;p>2mLmNYI3G*Vr=w|C$Nc!3O! z4-$5ZDe_yUbZAL}BCwhZa)zh#gmBsa7Wwi!jWjHosgsEqx#WF=g#Oqi(Ml4*PW;*R z5d6iBkiH9cEB(cTtIMi zp397P-(-9uU{EFNqs(WcK9IFlY-d`v_ei-(*(5IK={Nfnfzl!Qg(*+&m=~>(3Egt! z!6>qK`sV)7`_db|R9HZldnM*i)D~g49OpNoAoxP&3uuI#=B!=GvU+zN5sc_F8^&M9 zCOi+*3Cg0HMCPyk@aJ;|@dLzVBupSqe5}gqEFr;qVCzGY^kS7Ha3pPm0kTNb5~HNL zl|`+gQjg_~HZfg+Ta`MZ zpavz$71LO1Z+<(y1AiRIv(vAmu z6ql0y8}#LfBS`RBrpw;KH&Bp8(XPah9V|uwr z=@O(W7kiJT%{J=n9KD)9gDn0anwPI1HgnY1OU=2D5x%`D*@Mk@8>=LBG=SCFD7La* zRhP+^HDJ(EK!)4bKw#)8a|qLHFlV23n6dqw+;js}17|R8iR|6~Sh$}`)zw`est`32 zn@P+$l70CiWJKlQJ8VNALC}q&!B+i1?Jt6J=0VUz=a>q!)r5`^i~a9IZ?`Rl;G9GF zK5mlFv7dLf4eI|i6O%%w9{kG66pc2!ZoF>K8m8(%47>9%`!#12ss>5j((bk$>xduOJ@!d?7hUdyQ+fG0=`)be&IHaKTo^5{Pj|XhjrmVHYJ!eo z>{mdwYj(ZJgi5%tR8Z~;m?G`Din;{TTXpl?$-dt$b-$1a>(N-&bz~VgHdITl7Cj>4 zyx*(%T+?ei(~K>fr+|;LzVbRk*-(~YEXkXIzNIxuJ%_ky=nHes(!u^z>K31s8@6Br zY*&ucC#Rki2prAVn8f;lKB#G;Joh2z*$5pF0d(!5uTmV`99e2Eb!Tx{HQvz@SW_gN z#38Tnk2-DNNlQt-27$3iQEK^oy(4W4r9KhT?ffdp%=`jMi`Y4aHuCcD;ep-i#kD1< z7rS(f@+2bN3fDnTd(xOf6zTn~4gCfcj`jf>h3UW?$J=ULocCL#3~^_Zp( zh(YRx$B1;qd!Iuz(4B8-UqIX6B_oL5MtnY`U&`YYlbbo}Z+qIHy$O@s%eZ`>=`7!K zI+#4&s*9~NwRVT*P?+}hM#_-Bx#)Z#1G`@P&@NcMlZ{{UMq8t!>|m9cD#@>ZTXqSA zH$EXlJd%E-Gm~%&6gzS;_*!PvB%a=!(Dayt@rO{J+Dl0+V^Mc65k({}Vc2|zvSx+i z)`3MOrEyip8m3J_)0hNtMa^;SD?&e|Fm`MM`etHN_YfiQm}iks2NXR-~7=d!TjGsxEc(rq8+-W|AIJ88^60m1ir zW{W`u#B_hdTC`?H<~E3|zq%nBBLl-|nqJ~+hQSnfyRnzk>IG0)51fn{yV8wYI34E< zn?PxVKi!2O(s+8&KnQPAsT20RE2$MD(#K_oyBj}FP z<;sWm~ z_6Z)3!DeGjz0KEA&NZeznP=lPgsO(yBkC0dZ48*+%JF2(%@2z7mb-&!O#^+sU46Ge z*TQ8$EGd%Dg29xvfveJ>Zah^+O`p~G&9TTCT1Wr#fVMo^R04aT%|l5#_X8QI#~0z` zN@AcTW*ft49KI74bBWBNioPau4X8kxVoo@!kBWNup0&L^MWO4La{_e9fAfhG<3V8N zJCa|&3fIJMXoIRLD9wIrzYt#~qmxA63^us6Dl92`3dOB!%{^!;x zxt0J$$VKPWCM-MNB|kbNba%B%QmDgH#hIf5=1vJW%I;?DbE#%1Koq9=b9-S=OF-?B`{W2_G59rjgsK)T2 zxo_=*2u5kQpG#h1&2*lEHQ2~KTmXDzQPH?U!`TTYr(x>=lkeL~#A8VMOI?})a-t(-@5hfn!!iaiTAV#qTMts%$p@! z8?sHZY@%3^FQgHHORb(TuO(WUEku0Kp<3zqYbVPvwh@c>Pb0i9-hoZ2)HrOuJL*Wq zzr}eF1{N%5BD_vuARrKKd|%ilPG!_=@VuLqVEQRz{1oQT%1d{-fn}KE>NjV&A$_x~ zM7}o%^(X0So1DLRPu$Yl7q@mMOpfXs){Q1=8RC(^vln$H5UZ@`u19LR4}Nw7f2q1ERpTihMU1)Gz6$X$>@81bm#5O2!3oapKvBFgH2%$ga^febzGEcVKlu zI2K_aOb9p^yPDIM2siyM~uLU@7^zX{N02m1cgXa$DzTGaIG`G zqKq;|eqy<)tj(Ols4H!0s~V%RdgVR`R=wGP;mTx9Tr?f&=7^sI%g~;y#>kg&bbFDjk>^3^B)}2_=-_dsi6Mbk z*GA^VeYzr)Atq$TsOQZXMCRLhgkaXt%?IGG+6N>>RcnlfzHr&PNxj(>HO+T-46M+R z)EOx0@dLmYZw@t(P4UN8t45>@m_gmkAFvZk1$E|Qa_6KN&Ex%81rSL&$?ydW>86I7 z_A=lVhk?Dr0~Dg^{XG|g0kx5eHjxGkjR7$bk!s#LGz9pQ3ofRXb>>qb!pSZt6X9m*)@=&r?SdHeNQhN+=8}<rgn+qh(DK@aM`$9)Z!go*n~BS-Bhmp1R(5+l_%u* zII{wZf;Bo@!Na){Kzn^N{@gr+TfovtE0I1p{pJM^;oQKQwy!;5OVm*=!il*hr+k55 zH0lADrpK!O%Rs8(hIHBANAD6hA!DFNNP_8Z^_RG>)q)kGoTkriIW}eNELt0p(X?wS`)VRJWhf~?OMHr9^7j$u1?WGg*Vp5 zo%l?O1|E1vPVrP>16z()!^vAm{IExViw1W4N35s4Evf>>f%1If?tU60(uK;B z*-~ZB=0t%Lq45Gx`_Y#mgA?&!_TW~VhDKXfO|gN$)U6U!v00`PDDxaoszCtYU{i?k z#ro2V?Tf#cSOIK1gjuPsTP&tH1&|zJI!l(# zfUtny$8mt5BoU3${TgI_@h`6f#LMeflz*ce*k-2j=TWT Xz^8S#{`}MQG~fR-S3j3^P6$z?rtIW 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�sC#OlP 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 z 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%0Dg@&a`Sr}C{sN;p# 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%0DGKS;^8S(8xosPv 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

auJRh!HXP)n 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

0K~(lY>5eRudD?#+{*>L?TE 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

Y}WQ5-OH3rN`G=Za`s|d0qr=^YRSA< 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 repository(`gitea:${index + 3}`, `Jens/Gamma-${String(index + 1).padStart(2, '0')}`)), +] +let jobPolls = 0 +const job = { id: 'job-alpha', repository_id: 'gitea:1', status: 'queued', trigger: 'manual', requested_revision: 'a'.repeat(40), actual_revision: null, phase: 'queued', progress: 0, message: 'Waiting for an available worker', created_at: now, started_at: null, updated_at: now, finished_at: null, duration_ms: null, scan_id: null, error_code: null, error_detail: null, attempt: 1, deduplicated: false } +function send(response, status, body, type = 'application/json') { response.writeHead(status, { 'Content-Type': type }); response.end(type === 'application/json' ? JSON.stringify(body) : body) } +createServer((request, response) => { + const url = new URL(request.url, 'http://127.0.0.1:8001') + const path = decodeURIComponent(url.pathname) + if (path === '/health') return send(response, 200, { status: 'ok' }) + if (path === '/api/v1/meta') return send(response, 200, { name: 'RepoPulse', version: '1.5.0', stage: 'v1.5.0', scan_root_restricted: true, scan_root: '/scan', max_concurrent_scans: 1, requested_max_concurrent_scans: 1, repository_count: repositories.length, repository_states: { current: 2 }, current_repositories: 2, stale_repositories: 0, queue_depth: 0, active_jobs: 0, completed_jobs: 1, failed_jobs: 0, worker_heartbeat: now, gitea: { configured: true, url: 'http://gitea.local', last_sync: { synced_at: now } }, storage: { database_bytes: 1024, journal_bytes: 0, mirror_count: 2, mirror_cache_bytes: 2048, worktree_count: 0, scan_count: 1, compacted_scan_count: 0, oldest_scan_at: now, newest_scan_at: now, history_per_repository: 200, full_reports_per_repository: 30, report_retention_days: 365 }, database_recovery: { status: 'healthy' }, mutation_authentication: 'perimeter_required' }) + if (path === '/api/v1/repositories' && request.method === 'GET') return send(response, 200, repositories) + if (path === '/api/v1/repositories/sync' && request.method === 'POST') return send(response, 200, { provider: 'gitea', discovered: 2, created: 0, updated: 2, unavailable: 0, errors: [], partial: false, branch_failures: 0, listing_complete: true, synced_at: now }) + if (path === '/api/v1/repositories/gitea:1' && request.method === 'GET') return send(response, 200, { ...repositories[0], latest_scan: report }) + if (path === '/api/v1/repositories/gitea:2' && request.method === 'GET') return send(response, 200, { ...repositories[1], latest_scan: null }) + if (path === '/api/v1/repositories/gitea:1/scans' && request.method === 'GET') return send(response, 200, [{ id: report.id, repository_id: 'gitea:1', scanned_at: now, branch: 'main', requested_revision: report.source.requested_revision, actual_revision: report.source.actual_revision, trigger: 'manual', health_score: 88, release_readiness: 'BLOCKED', findings: 1, duration_ms: 42 }]) + if (path === '/api/v1/repositories/gitea:2/scans' && request.method === 'GET') return send(response, 200, []) + if (path.endsWith('/trend')) return send(response, 200, [{ scan_id: report.id, scanned_at: now, health_score: 88, findings: 1, blockers: 1, warnings: 0, debt_markers: 0 }]) + if (path === '/api/v1/scans/scan-alpha/comparison') return send(response, 200, { current_scan_id: report.id, previous_scan_id: null, health_score_delta: null, category_score_deltas: {}, metric_deltas: {}, added_findings: [], resolved_findings: [] }) + if (path === '/api/v1/repositories/gitea:1/scans' && request.method === 'POST') { jobPolls = 0; return send(response, 202, job) } + if (path === '/api/v1/scan-jobs/job-alpha') { jobPolls += 1; if (jobPolls < 2) return send(response, 200, { ...job, status: 'scanning', phase: 'scanning', progress: 40, message: 'Running deterministic repository analysis' }); return send(response, 200, { ...job, status: 'completed', phase: 'completed', progress: 100, message: 'Scan completed', scan_id: report.id, actual_revision: report.source.actual_revision, finished_at: now, duration_ms: 42 }) } + if (path === '/api/v1/repositories/gitea:1/scans/scan-alpha') return send(response, 200, report) + if (path === '/api/v1/scans/scan-alpha/export') return send(response, 200, JSON.stringify(report), 'application/json') + return send(response, 404, { detail: `Unhandled mock endpoint: ${path}` }) +}).listen(8001, '127.0.0.1') diff --git a/frontend/e2e/repopulse.spec.ts b/frontend/e2e/repopulse.spec.ts new file mode 100644 index 0000000..9d5b759 --- /dev/null +++ b/frontend/e2e/repopulse.spec.ts @@ -0,0 +1,45 @@ +import { expect, test } from '@playwright/test' + +test('portfolio workflow covers navigation, remediation, a scan lifecycle and export', async ({ page }) => { + await page.goto('/') + await expect(page.getByRole('heading', { name: /portfolio signal/i })).toBeVisible() + await expect(page.getByRole('heading', { name: 'Remediation Center' })).toBeVisible() + await expect(page.getByText('A deterministic package-manager lockfile was not found for this workspace.')).toBeVisible() + await page.locator('.remediation-center').getByRole('button', { name: /Jens\/Alpha/ }).click() + await expect(page.getByRole('heading', { name: 'Jens/Alpha' })).toBeVisible() + await page.getByRole('link', { name: 'Dashboard', exact: true }).click() + + await page.getByRole('button', { name: /open repository explorer/i }).click() + await expect(page.getByText('25 matching 25 repositories')).toBeVisible() + await page.getByRole('button', { name: 'Visual grid' }).click() + await page.getByRole('button', { name: 'Pin Jens/Alpha' }).click() + await expect(page.getByRole('button', { name: 'Remove Jens/Alpha from pinned repositories' })).toBeVisible() + await page.getByRole('button', { name: 'Table' }).click() + await expect(page.getByText('Page 1 / 2')).toBeVisible() + await page.getByRole('button', { name: 'Next' }).click() + await expect(page.getByText('Page 2 / 2')).toBeVisible() + await page.getByLabel('Filter by readiness').selectOption('blocked') + await expect(page.getByText('1 matching 25 repositories')).toBeVisible() + await page.getByRole('link', { name: 'Open Jens/Alpha' }).click() + await expect(page.getByRole('heading', { name: 'Jens/Alpha' })).toBeVisible() + + await page.getByRole('link', { name: /findings/i }).click() + await expect(page.getByText('No lockfile was retained for the declared dependencies.')).toBeVisible() + await page.getByRole('link', { name: /architecture/i }).click() + await expect(page.getByText('Local import and dependency topology')).toBeVisible() + await page.getByRole('link', { name: /history/i }).click() + await expect(page.getByText('Repository health over time')).toBeVisible() + + await page.getByRole('button', { name: 'Scan now' }).click() + await expect(page.getByText('Repository analysis completed.')).toBeVisible({ timeout: 10_000 }) + await page.getByText('Reports').click() + const download = page.waitForEvent('download') + await page.getByRole('button', { name: 'Export JSON' }).click() + await expect(download).resolves.toBeTruthy() + + await page.keyboard.press('Control+k') + await page.getByPlaceholder('Search repositories…').fill('Beta') + await page.keyboard.press('ArrowDown') + await page.keyboard.press('Enter') + await expect(page.getByRole('heading', { name: 'Jens/Beta', exact: true })).toBeVisible() +}) diff --git a/frontend/e2e/start-vite.mjs b/frontend/e2e/start-vite.mjs new file mode 100644 index 0000000..81c4298 --- /dev/null +++ b/frontend/e2e/start-vite.mjs @@ -0,0 +1,11 @@ +import { spawn } from 'node:child_process' +import { fileURLToPath } from 'node:url' + +const vite = fileURLToPath(new URL('../node_modules/vite/bin/vite.js', import.meta.url)) +const child = spawn(process.execPath, [vite, '--host', '127.0.0.1', '--port', '4173'], { + cwd: new URL('..', import.meta.url), + env: { ...process.env, REPOPULSE_API_PROXY: 'http://127.0.0.1:8001' }, + stdio: 'inherit', +}) + +child.on('exit', (code) => process.exit(code ?? 0)) diff --git a/frontend/index.html b/frontend/index.html new file mode 100644 index 0000000..0fc001f --- /dev/null +++ b/frontend/index.html @@ -0,0 +1,16 @@ + + + + + + + + + + RepoPulse — Portfolio intelligence + + +

+ + + diff --git a/frontend/nginx.conf b/frontend/nginx.conf new file mode 100644 index 0000000..a524271 --- /dev/null +++ b/frontend/nginx.conf @@ -0,0 +1,23 @@ +server { + listen 80; + server_name _; + + root /usr/share/nginx/html; + index index.html; + + location /api/ { + proxy_pass http://backend:8000; + proxy_http_version 1.1; + proxy_set_header Host $host; + proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for; + proxy_set_header X-Forwarded-Proto $scheme; + } + + location = /health { + proxy_pass http://backend:8000/health; + } + + location / { + try_files $uri /index.html; + } +} diff --git a/frontend/package-lock.json b/frontend/package-lock.json new file mode 100644 index 0000000..06d27d7 --- /dev/null +++ b/frontend/package-lock.json @@ -0,0 +1,3336 @@ +{ + "name": "repopulse-frontend", + "version": "1.5.0", + "lockfileVersion": 3, + "requires": true, + "packages": { + "": { + "name": "repopulse-frontend", + "version": "1.5.0", + "dependencies": { + "@xyflow/react": "^12.8.5", + "react": "^19.1.1", + "react-dom": "^19.1.1" + }, + "devDependencies": { + "@playwright/test": "^1.55.0", + "@testing-library/dom": "^10.4.1", + "@testing-library/react": "^16.3.3", + "@types/react": "^19.1.12", + "@types/react-dom": "^19.1.9", + "@vitejs/plugin-react": "^5.0.2", + "jsdom": "^30.0.1", + "typescript": "^5.9.2", + "vite": "^7.1.5", + "vitest": "^3.2.4" + } + }, + "node_modules/@asamuzakjp/css-color": { + "version": "6.0.7", + "resolved": "https://registry.npmjs.org/@asamuzakjp/css-color/-/css-color-6.0.7.tgz", + "integrity": "sha512-vC/bk1Lz7Tn/EfU9/apOTBk80/8dyGyWMowPoV1tJ52muDGsDqt2HPT2klrFUiY60MQmQv9q8yIht15JnBgDGw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@csstools/css-calc": "^3.3.0", + "@csstools/css-color-parser": "^4.1.10", + "@csstools/css-parser-algorithms": "^4.0.0", + "@csstools/css-tokenizer": "^4.0.0", + "lru-cache": "^11.5.2" + }, + "engines": { + "node": "^22.13.0 || >=24.0.0" + } + }, + "node_modules/@asamuzakjp/css-color/node_modules/lru-cache": { + "version": "11.5.2", + "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-11.5.2.tgz", + "integrity": "sha512-4pfM1Ff0x50o0tQwb5ucw/RzNyD0/YJME6IVcStalZuMWxdt3sR3huStTtxz4PUmvZfRguvDejasvQ2kifR11g==", + "dev": true, + "license": "BlueOak-1.0.0", + "engines": { + "node": "20 || >=22" + } + }, + "node_modules/@asamuzakjp/dom-selector": { + "version": "8.3.2", + "resolved": "https://registry.npmjs.org/@asamuzakjp/dom-selector/-/dom-selector-8.3.2.tgz", + "integrity": "sha512-93Z1N+BQNXysodoicpOIyNh2drHfz/CTf9nnT0FEx72GJcIiwgydD7tGAr78j41LsYn3hlRn+LdGPuBLn1Bl8Q==", + "dev": true, + "license": "MIT", + "dependencies": { + "bidi-js": "^1.0.3", + "css-tree": "^3.2.1", + "is-potential-custom-element-name": "^1.0.1", + "lru-cache": "^11.5.2" + }, + "engines": { + "node": "^22.13.0 || >=24.0.0" + } + }, + "node_modules/@asamuzakjp/dom-selector/node_modules/lru-cache": { + "version": "11.5.2", + "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-11.5.2.tgz", + "integrity": "sha512-4pfM1Ff0x50o0tQwb5ucw/RzNyD0/YJME6IVcStalZuMWxdt3sR3huStTtxz4PUmvZfRguvDejasvQ2kifR11g==", + "dev": true, + "license": "BlueOak-1.0.0", + "engines": { + "node": "20 || >=22" + } + }, + "node_modules/@babel/code-frame": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.29.7.tgz", + "integrity": "sha512-Aup7aUOfpbAUg2ROOJN6Iw5f9DMBlzu0mIkm/malLQFN/YQgO48wCj0Kxa3sEHJvPVFg7siR+qRInwXd2qhQKw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-validator-identifier": "^7.29.7", + "js-tokens": "^4.0.0", + "picocolors": "^1.1.1" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/compat-data": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/compat-data/-/compat-data-7.29.7.tgz", + "integrity": "sha512-locTkQyKvwIEgBzVrn8693ebc97F2U8ZHjbXwDXJ5Fn2TCpNwTlKcaKLkdHop5c/icOFE7qt7Q9JC5hnKNa6Gg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/core": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/core/-/core-7.29.7.tgz", + "integrity": "sha512-RgHBCvtjbOK2gXSNBNIkNoEc9qoVEtau3hj8gEqKQuL3HZAibKarWFEI3Lfm6EYKkLalOh8eSrj9b+ch9H/VBA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/code-frame": "^7.29.7", + "@babel/generator": "^7.29.7", + "@babel/helper-compilation-targets": "^7.29.7", + "@babel/helper-module-transforms": "^7.29.7", + "@babel/helpers": "^7.29.7", + "@babel/parser": "^7.29.7", + "@babel/template": "^7.29.7", + "@babel/traverse": "^7.29.7", + "@babel/types": "^7.29.7", + "@jridgewell/remapping": "^2.3.5", + "convert-source-map": "^2.0.0", + "debug": "^4.1.0", + "gensync": "^1.0.0-beta.2", + "json5": "^2.2.3", + "semver": "^6.3.1" + }, + "engines": { + "node": ">=6.9.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/babel" + } + }, + "node_modules/@babel/generator": { + "version": "7.29.8", + "resolved": "https://registry.npmjs.org/@babel/generator/-/generator-7.29.8.tgz", + "integrity": "sha512-gZbepsdh3WDtgZKWL+vTPh71LSBrm/Y4/QDZBVCcYfmeTEEuoOYwlSy+G1StfJg+/Zy550u/3TATbm7qDbbMtg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/parser": "^7.29.8", + "@babel/types": "^7.29.8", + "@jridgewell/gen-mapping": "^0.3.12", + "@jridgewell/trace-mapping": "^0.3.28", + "jsesc": "^3.0.2" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-compilation-targets": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/helper-compilation-targets/-/helper-compilation-targets-7.29.7.tgz", + "integrity": "sha512-wem6WaBj4NaVYVdNhLPPVacES6ZJ+KBBfSkTMD3YZxbP3rm3Di85tJU5ljaUNhaOynt+Aj0xruhYuzQBt8n71g==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/compat-data": "^7.29.7", + "@babel/helper-validator-option": "^7.29.7", + "browserslist": "^4.24.0", + "lru-cache": "^5.1.1", + "semver": "^6.3.1" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-globals": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/helper-globals/-/helper-globals-7.29.7.tgz", + "integrity": "sha512-3nQVUAtvkKH9zahfWgw96Jc/uFOmjACE1kQz82E2lqWmHBgjzbNlsC22nuQTfahmWeQtTq5nQ/4Nnd2A1wj4zA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-module-imports": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/helper-module-imports/-/helper-module-imports-7.29.7.tgz", + "integrity": "sha512-ejHwrQQYcm9xnTivShn2IDOlIzInN34AXskvq9QicvCtEzq1Vzclu/tKF8Jq1Cg8JG2GL6/EmjgsCT7lXepE3g==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/traverse": "^7.29.7", + "@babel/types": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-module-transforms": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/helper-module-transforms/-/helper-module-transforms-7.29.7.tgz", + "integrity": "sha512-UPUVSyXbOh627KiCIGQSgwWzGeBKLkaJ9PJEdrngIwMSzxLR4jS4+f1f1jb7VzBbg8nFLaYotvVPFCTqdrmTAg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-module-imports": "^7.29.7", + "@babel/helper-validator-identifier": "^7.29.7", + "@babel/traverse": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0" + } + }, + "node_modules/@babel/helper-plugin-utils": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/helper-plugin-utils/-/helper-plugin-utils-7.29.7.tgz", + "integrity": "sha512-G7sHYigPY17oO5SYWnfD/0MTBwVR781S/JI643e/JhUYgVgWE/61SoW3NH9KWUKyKq5LVh3npif99Wkt6j86Jw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-string-parser": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/helper-string-parser/-/helper-string-parser-7.29.7.tgz", + "integrity": "sha512-Pb5ijPrZ89GDH8223L4UP8i6QApWxs04RbPQJTeWDV0/keR2E36MeKnyr6LYmUUvqRRI+Iv87SuF1W6ErINzYw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-validator-identifier": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.29.7.tgz", + "integrity": "sha512-qehxGkRj55h/ff8EMaJ+cYhyaKlHIxqYDn682wQD7RNp9UujOQsHog2uS0r2vzr4pW+sXf90NeeayjcNaX3fFg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-validator-option": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/helper-validator-option/-/helper-validator-option-7.29.7.tgz", + "integrity": "sha512-N9ZErrD+yW5geCDtBqnOoxmR8+tNKiGuxKlDpuJxfsqpa2dFcexaziGAE/qoHLiDDreVNMupxGmSoNlyvsA3gw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helpers": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/helpers/-/helpers-7.29.7.tgz", + "integrity": "sha512-1k2lAGRMfHTcwuNYcCNUmaUffmQv8KWMfh2iJUUeRlwlwH4FdNG7mfPI10NPfLHJFThE4Tyr4mv7kTNZOiPuBg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/template": "^7.29.7", + "@babel/types": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/parser": { + "version": "7.29.8", + "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.29.8.tgz", + "integrity": "sha512-E8lTAYNB1KW+FH+VGJuZM1ioAx2E6oVlvQFRrf5P8ZZmsiJXYAD9vTFV7yyEURNzgh1dFqMZuO6tUwcARbqFCA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/types": "^7.29.8" + }, + "bin": { + "parser": "bin/babel-parser.js" + }, + "engines": { + "node": ">=6.0.0" + } + }, + "node_modules/@babel/plugin-transform-react-jsx-self": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-react-jsx-self/-/plugin-transform-react-jsx-self-7.29.7.tgz", + "integrity": "sha512-TL0hMc9xzy86VD31nUiwzd5otRAcyEPcsegCxolO0PvcXuH1v0kECe/UIznYFihpkvU5wg/jk4v0TTEFfm53fw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-react-jsx-source": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-react-jsx-source/-/plugin-transform-react-jsx-source-7.29.7.tgz", + "integrity": "sha512-06IyK09H3wi4cGbhDBwp5gUGo0IKtnYa8tyTiephirPCK6fbobVGiXMMI5zLQ4aKEYP3wZ3ArU44o+8KMrSG/Q==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/runtime": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/runtime/-/runtime-7.29.7.tgz", + "integrity": "sha512-Nq8OhGWiZIZGV6hLHoyAKLLcJihP/xFeBMGJoUrxTX2psI8dCifzLhZISFb+VWS3wFMRDmCGw5R+dOySCqPLhw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/template": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/template/-/template-7.29.7.tgz", + "integrity": "sha512-puq+Gf35oI24FeN11LkoUQFqv9uwNeWpxXZi/Ji3rRIoKAzKnxRaZ+Gkj0vKS9ZCiTESfng1N9LyOyXvo+m+Gg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/code-frame": "^7.29.7", + "@babel/parser": "^7.29.7", + "@babel/types": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/traverse": { + "version": "7.29.8", + "resolved": "https://registry.npmjs.org/@babel/traverse/-/traverse-7.29.8.tgz", + "integrity": "sha512-I5z7H3bf/41ktsNVLtpN0wAa336HkqIHQ5BuPLEhTkt1jVSyZpeNKIzTgEWmlxjdg81R0IgUCcaE+Ok3NvrfZg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/code-frame": "^7.29.7", + "@babel/generator": "^7.29.8", + "@babel/helper-globals": "^7.29.7", + "@babel/parser": "^7.29.8", + "@babel/template": "^7.29.7", + "@babel/types": "^7.29.8", + "debug": "^4.3.1" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/types": { + "version": "7.29.8", + "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.29.8.tgz", + "integrity": "sha512-Vj1jF3cPfxg7OAfoI7QnVKLoILlm2JF9pnVHrX8qx7AHMiYWT+NDAA7jChlNgRS4WTLc/fD1lXLmPixluj+3Gg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-string-parser": "^7.29.7", + "@babel/helper-validator-identifier": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@bramus/specificity": { + "version": "2.4.2", + "resolved": "https://registry.npmjs.org/@bramus/specificity/-/specificity-2.4.2.tgz", + "integrity": "sha512-ctxtJ/eA+t+6q2++vj5j7FYX3nRu311q1wfYH3xjlLOsczhlhxAg2FWNUXhpGvAw3BWo1xBcvOV6/YLc2r5FJw==", + "dev": true, + "license": "MIT", + "dependencies": { + "css-tree": "^3.0.0" + }, + "bin": { + "specificity": "bin/cli.js" + } + }, + "node_modules/@csstools/color-helpers": { + "version": "6.1.1", + "resolved": "https://registry.npmjs.org/@csstools/color-helpers/-/color-helpers-6.1.1.tgz", + "integrity": "sha512-gLNsunvwf3mCi5u5o46/Z/JcJMnhbHSaZ69rkgPzNM3J4s8hWwpPUQB6/tt0EDFyCiWzxANlx+2LJwpYj4zS1w==", + "dev": true, + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/csstools" + }, + { + "type": "opencollective", + "url": "https://opencollective.com/csstools" + } + ], + "license": "MIT-0", + "engines": { + "node": ">=20.19.0" + } + }, + "node_modules/@csstools/css-calc": { + "version": "3.3.0", + "resolved": "https://registry.npmjs.org/@csstools/css-calc/-/css-calc-3.3.0.tgz", + "integrity": "sha512-c5ihYsPkdG6JCkU2zTMm4+k6r7RXuGxtWYhu5DHMIiF1FHzrfmHL5so11AoFpUv/tu61xfcmT4AmKoFfMPoqdQ==", + "dev": true, + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/csstools" + }, + { + "type": "opencollective", + "url": "https://opencollective.com/csstools" + } + ], + "license": "MIT", + "engines": { + "node": ">=20.19.0" + }, + "peerDependencies": { + "@csstools/css-parser-algorithms": "^4.0.0", + "@csstools/css-tokenizer": "^4.0.0" + } + }, + "node_modules/@csstools/css-color-parser": { + "version": "4.2.2", + "resolved": "https://registry.npmjs.org/@csstools/css-color-parser/-/css-color-parser-4.2.2.tgz", + "integrity": "sha512-3QKjR/vxyjcSXBLgb6lP0S3MGdvwbmqSsvLPbYdVORqPDc8FX1HAJ0Spk38bxaRXgvENTA47tlhhbb5Z2e8hEg==", + "dev": true, + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/csstools" + }, + { + "type": "opencollective", + "url": "https://opencollective.com/csstools" + } + ], + "license": "MIT", + "dependencies": { + "@csstools/color-helpers": "^6.1.1", + "@csstools/css-calc": "^3.3.0" + }, + "engines": { + "node": ">=20.19.0" + }, + "peerDependencies": { + "@csstools/css-parser-algorithms": "^4.0.0", + "@csstools/css-tokenizer": "^4.0.0" + } + }, + "node_modules/@csstools/css-parser-algorithms": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/@csstools/css-parser-algorithms/-/css-parser-algorithms-4.0.0.tgz", + "integrity": "sha512-+B87qS7fIG3L5h3qwJ/IFbjoVoOe/bpOdh9hAjXbvx0o8ImEmUsGXN0inFOnk2ChCFgqkkGFQ+TpM5rbhkKe4w==", + "dev": true, + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/csstools" + }, + { + "type": "opencollective", + "url": "https://opencollective.com/csstools" + } + ], + "license": "MIT", + "engines": { + "node": ">=20.19.0" + }, + "peerDependencies": { + "@csstools/css-tokenizer": "^4.0.0" + } + }, + "node_modules/@csstools/css-syntax-patches-for-csstree": { + "version": "1.1.13", + "resolved": "https://registry.npmjs.org/@csstools/css-syntax-patches-for-csstree/-/css-syntax-patches-for-csstree-1.1.13.tgz", + "integrity": "sha512-i9ZylF5QNhmNfPA9l0vHAWK4kPrbIp6g9lKgaiIFsIBz2F/WNB7OLrzlNNcCOm+h42bkaSD2v1PG+IBPHhc3ZA==", + "dev": true, + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/csstools" + }, + { + "type": "opencollective", + "url": "https://opencollective.com/csstools" + } + ], + "license": "MIT-0", + "peerDependencies": { + "css-tree": "^3.2.1" + }, + "peerDependenciesMeta": { + "css-tree": { + "optional": true + } + } + }, + "node_modules/@csstools/css-tokenizer": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/@csstools/css-tokenizer/-/css-tokenizer-4.0.0.tgz", + "integrity": "sha512-QxULHAm7cNu72w97JUNCBFODFaXpbDg+dP8b/oWFAZ2MTRppA3U00Y2L1HqaS4J6yBqxwa/Y3nMBaxVKbB/NsA==", + "dev": true, + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/csstools" + }, + { + "type": "opencollective", + "url": "https://opencollective.com/csstools" + } + ], + "license": "MIT", + "engines": { + "node": ">=20.19.0" + } + }, + "node_modules/@esbuild/aix-ppc64": { + "version": "0.28.2", + "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.28.2.tgz", + "integrity": "sha512-XExcO+dvLKvVtNTibSTBej1NCAbaGhWn9Ww1ZPx80qsahhPFe/8jgWP0IchNe0F3HwkU7n8ejhH8bjonqht8mQ==", + "cpu": [ + "ppc64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "aix" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/android-arm": { + "version": "0.28.2", + "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.28.2.tgz", + "integrity": "sha512-kXXoiPVVGQcnIYGOeaovwOURpniDBpSq4A03qkQ+BMQqtGG6HYap3xne9C1O1yo4TR3qxlCX5IqqmX6fFo2Lqg==", + "cpu": [ + "arm" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/android-arm64": { + "version": "0.28.2", + "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.28.2.tgz", + "integrity": "sha512-5YfKeeI8qWfBZIX+u2xZC3Zlb3Os/gLS2sbEKM+I4ZOcsWmHS2WLysCcQZDAFRslDUU5Oiq44gf6PYN1vGwG5A==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/android-x64": { + "version": "0.28.2", + "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.28.2.tgz", + "integrity": "sha512-O387ite7SzUyCcy3JQX4P4bLtEA7bLLkx+esve5JHnyYfNTxcVpXZo9jhdB0lTKN44gztELTdU7nS8Nr16Fs1Q==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/darwin-arm64": { + "version": "0.28.2", + "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.28.2.tgz", + "integrity": "sha512-n4KqkOQrraxHJcgjM1RvwbigfQKIKJVpM7xp+KsxiyUSrRdIXnt73VhrPAx0fV44hgfmIVKjxMN9J1t5jySVkw==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/darwin-x64": { + "version": "0.28.2", + "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.28.2.tgz", + "integrity": "sha512-uq6suIWYP37qzGddBKPw5QEQPi6HiLGsO7UmkpfyaYNQ3D+rN6w6WfwH+nuqcGXWvawGwxOEroO4YGnFh95azw==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/freebsd-arm64": { + "version": "0.28.2", + "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.28.2.tgz", + "integrity": "sha512-n+I0BTSRIoy+d6RPKnEVwql5UwBJolytvY4mAOIEJorKlqgPII8ix6slVVrfZ5Tnj7glIZvloylbB/EJPMWEXw==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "freebsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/freebsd-x64": { + "version": "0.28.2", + "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.28.2.tgz", + "integrity": "sha512-78XJTJkvPs0kz2w61301PJjXl4g7q3JqiYMZ/M/yVI73EHBrCRTgkhu9oqG7vPqq+a/yadEW8aD+agKlk5xrmg==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "freebsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-arm": { + "version": "0.28.2", + "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.28.2.tgz", + "integrity": "sha512-XlDnu2q5yoqems+xay6wSAcg9DDD7K9RLKZEBOMZm3ckNpJBvOX20tSfby8KfrrhINDyv9V2YVZKY/SpoGJI8w==", + "cpu": [ + "arm" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-arm64": { + "version": "0.28.2", + "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.28.2.tgz", + "integrity": "sha512-pW4AC0P3it8c7do9MVM4p51FzHzdM/TZrerurgRcHJ2WTa1VQ1CIq18xncfpBJw4ojkiZZrKW2yIBWBP92j6Ug==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-ia32": { + "version": "0.28.2", + "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.28.2.tgz", + "integrity": "sha512-CYbnj78HsIeA+DhgUKgFCfvNsTHFhMMrinUrMZpDXJXKN8T3XViTZ/+wtHeVxEWY8ewSzTFN+nRmSwO2tZaLUQ==", + "cpu": [ + "ia32" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-loong64": { + "version": "0.28.2", + "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.28.2.tgz", + "integrity": "sha512-buwkd8nsph4R+ajRvw0qM5Hja/TXQow3ptzWO2EbG/cqcIkHloRrdlBtQlshyYGTNFvfkfJ5tpPLVkY4DtsPfQ==", + "cpu": [ + "loong64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-mips64el": { + "version": "0.28.2", + "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.28.2.tgz", + "integrity": "sha512-ZVykbDyk7519VwiNb9Lcj9m8XM6v5V9uKPvrEMkkEedVewf+0itkhahp4HDpgERXhwLRpWFypsGbG/J8s0QjJA==", + "cpu": [ + "mips64el" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-ppc64": { + "version": "0.28.2", + "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.28.2.tgz", + "integrity": "sha512-CAXl+Dtd9UUuJd8pKKdwh6MLm3MUMiqMPmhZ3tTSXPqfyQ3vDl6R5hZdZ/kYojK4ofXtdfSv1tFq8XzWx3heNQ==", + "cpu": [ + "ppc64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-riscv64": { + "version": "0.28.2", + "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.28.2.tgz", + "integrity": "sha512-GeXCej4IQtU1B+QlDV8W/RRvbzI3O/Stss+/bCXv4lZls5WGRtu2a+3JkA3i4qIUlMXpcHebWpF8AkJhATowuA==", + "cpu": [ + "riscv64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-s390x": { + "version": "0.28.2", + "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.28.2.tgz", + "integrity": "sha512-3H1weTYZPxt/WOhByszQZybS9w5lKzUn1FDMsgEChbHWQwHYQQRfBxgCcZvPhjHfKyJjIievvMmEUawJrdY9Dg==", + "cpu": [ + "s390x" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-x64": { + "version": "0.28.2", + "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.28.2.tgz", + "integrity": "sha512-4xTZr1FUmSoQW4XIWmit3tzQrUTZM+N3P0XV8xROKYF50XfI7xeO90+1bZvNwxIufQ9hDQVRJH5YhgPVF8A/HQ==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/netbsd-arm64": { + "version": "0.28.2", + "resolved": "https://registry.npmjs.org/@esbuild/netbsd-arm64/-/netbsd-arm64-0.28.2.tgz", + "integrity": "sha512-sSATRjPeDBg3pdgHoQfoYBob11Kk1FGa9lui5RIHZCoCkJa9QKlvl3/vKz2usCmYYjs7ymJR/2Nnsqe+Hjt5nw==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "netbsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/netbsd-x64": { + "version": "0.28.2", + "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.28.2.tgz", + "integrity": "sha512-lqnzCV+mM0gIADaKihiCg6ifgfU2L3h5E33rNQBN1Y4MaVGnzryzmvvf7UHxprpQdE8hpqLolJ9Rl+SkIRDpyw==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "netbsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/openbsd-arm64": { + "version": "0.28.2", + "resolved": "https://registry.npmjs.org/@esbuild/openbsd-arm64/-/openbsd-arm64-0.28.2.tgz", + "integrity": "sha512-AL2qJILH7lNjrDmCQDvdxMfAUIv8KMNZOvrwAQ8i8//ntL9FflhOyMJ8OZSMBb8/AWXe3/5v5S20y3zCoZWKoQ==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "openbsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/openbsd-x64": { + "version": "0.28.2", + "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.28.2.tgz", + "integrity": "sha512-QtiuPytchRyC4rwUKhexJdQKvDuZ6hWloi3igqPQNUJCS1/v9EiO3UTOXR6A3FoMo4fnAKbWJdqaIwhOzh8qEw==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "openbsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/openharmony-arm64": { + "version": "0.28.2", + "resolved": "https://registry.npmjs.org/@esbuild/openharmony-arm64/-/openharmony-arm64-0.28.2.tgz", + "integrity": "sha512-WkhYDmpTjLvGlScA1rwjRUmhl4k8oXR3cIbtqWmELgU/dFeHHlEllxDvdWcNJV9rbzCexB5vz8gtNewWLgCT7Q==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "openharmony" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/sunos-x64": { + "version": "0.28.2", + "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.28.2.tgz", + "integrity": "sha512-GPMSkTOtMnv2U2F8gxe4Io6qmVs+YKyp832Etqqxr0hFngmXQ3rzwytelm3GIn7T4VviRUlf3sOgBOiTdvaf7g==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "sunos" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/win32-arm64": { + "version": "0.28.2", + "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.28.2.tgz", + "integrity": "sha512-PIhhEkE9uPBleRBrQEJpUn7MBnibZzbGzYWPmY3x+YoVg/95zbjB4CxPPOQ8l5tYYM4mMaCthF8/1DIfBQQyWQ==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/win32-ia32": { + "version": "0.28.2", + "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.28.2.tgz", + "integrity": "sha512-YmJbfTlvU7Sdn9BB+4PRES4oB6pxgS37MAONj+hBr/cpXS1aBPKXxNnDbu+QCWPj0o9dgyxeq79g6c5P8KeuYA==", + "cpu": [ + "ia32" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/win32-x64": { + "version": "0.28.2", + "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.28.2.tgz", + "integrity": "sha512-5ebpxr3nWMzrL/rnUI755Jkuee0bHL/Gq0WTF9lvcpv73wAp5eu8MfBUgWK9bhWvZjj7yX8etf/8tI8Ney695g==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@exodus/bytes": { + "version": "1.15.1", + "resolved": "https://registry.npmjs.org/@exodus/bytes/-/bytes-1.15.1.tgz", + "integrity": "sha512-S6mL0yNB/Abt9Ei4tq8gDhcczc4S3+vQ4ra7vxnAf+YHC02srtqxKKZghx2Dq6p0e66THKwR6r8N6P95wEty7Q==", + "dev": true, + "license": "MIT", + "engines": { + "node": "^20.19.0 || ^22.12.0 || >=24.0.0" + }, + "peerDependencies": { + "@noble/hashes": "^1.8.0 || ^2.0.0" + }, + "peerDependenciesMeta": { + "@noble/hashes": { + "optional": true + } + } + }, + "node_modules/@jridgewell/gen-mapping": { + "version": "0.3.13", + "resolved": "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.3.13.tgz", + "integrity": "sha512-2kkt/7niJ6MgEPxF0bYdQ6etZaA+fQvDcLKckhy1yIQOzaoKjBBjSj63/aLVjYE3qhRt5dvM+uUyfCg6UKCBbA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@jridgewell/sourcemap-codec": "^1.5.0", + "@jridgewell/trace-mapping": "^0.3.24" + } + }, + "node_modules/@jridgewell/remapping": { + "version": "2.3.5", + "resolved": "https://registry.npmjs.org/@jridgewell/remapping/-/remapping-2.3.5.tgz", + "integrity": "sha512-LI9u/+laYG4Ds1TDKSJW2YPrIlcVYOwi2fUC6xB43lueCjgxV4lffOCZCtYFiH6TNOX+tQKXx97T4IKHbhyHEQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@jridgewell/gen-mapping": "^0.3.5", + "@jridgewell/trace-mapping": "^0.3.24" + } + }, + "node_modules/@jridgewell/resolve-uri": { + "version": "3.1.2", + "resolved": "https://registry.npmjs.org/@jridgewell/resolve-uri/-/resolve-uri-3.1.2.tgz", + "integrity": "sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6.0.0" + } + }, + "node_modules/@jridgewell/sourcemap-codec": { + "version": "1.6.0", + "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.6.0.tgz", + "integrity": "sha512-T7jf+5zgsZHwNJ4lvQ7/aezbyk0nNX+zJVWpmHA7VYsEx7a7qr5Rg5IbtJFqkgze5Y2sruq1RUY8Q837Od7iFw==", + "dev": true, + "license": "MIT" + }, + "node_modules/@jridgewell/trace-mapping": { + "version": "0.3.31", + "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.31.tgz", + "integrity": "sha512-zzNR+SdQSDJzc8joaeP8QQoCQr8NuYx2dIIytl1QeBEZHJ9uW6hebsrYgbz8hJwUQao3TWCMtmfV8Nu1twOLAw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@jridgewell/resolve-uri": "^3.1.0", + "@jridgewell/sourcemap-codec": "^1.4.14" + } + }, + "node_modules/@napi-rs/lzma-linux-x64-gnu": { + "version": "1.5.1", + "resolved": "https://registry.npmjs.org/@napi-rs/lzma-linux-x64-gnu/-/lzma-linux-x64-gnu-1.5.1.tgz", + "integrity": "sha512-oTXEIha4SsuXdTA4Iyskj0kpdx2yVXdhd75c2v3xGrHFfVMsbhTPZU/nMPL4sWKo4pBHm3aucLaqGlF696dTyQ==", + "cpu": [ + "x64" + ], + "dev": true, + "libc": [ + "glibc" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": "^22.20 || ^24.12 || >=25" + } + }, + "node_modules/@playwright/test": { + "version": "1.55.0", + "resolved": "https://registry.npmjs.org/@playwright/test/-/test-1.55.0.tgz", + "integrity": "sha512-04IXzPwHrW69XusN/SIdDdKZBzMfOT9UNT/YiJit/xpy2VuAoB8NHc8Aplb96zsWDddLnbkPL3TsmrS04ZU2xQ==", + "dev": true, + "license": "Apache-2.0", + "dependencies": { + "playwright": "1.55.0" + }, + "bin": { + "playwright": "cli.js" + }, + "engines": { + "node": ">=18" + } + }, + "node_modules/@rolldown/pluginutils": { + "version": "1.0.0-rc.3", + "resolved": "https://registry.npmjs.org/@rolldown/pluginutils/-/pluginutils-1.0.0-rc.3.tgz", + "integrity": "sha512-eybk3TjzzzV97Dlj5c+XrBFW57eTNhzod66y9HrBlzJ6NsCrWCp/2kaPS3K9wJmurBC0Tdw4yPjXKZqlznim3Q==", + "dev": true, + "license": "MIT" + }, + "node_modules/@rollup/rollup-android-arm-eabi": { + "version": "4.63.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.63.1.tgz", + "integrity": "sha512-UZ8sUxPTiHWYX9QNdJedb1kDZSpS1t/VPWBWGSgqHNi9w3Cu6IXvu2mzbhiTiPvtrqgTQJ+zqiAq2iPIPilpaQ==", + "cpu": [ + "arm" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "android" + ] + }, + "node_modules/@rollup/rollup-android-arm64": { + "version": "4.63.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm64/-/rollup-android-arm64-4.63.1.tgz", + "integrity": "sha512-cQ4nFQABN5cDvDpbvJ7bMStCpnaVxynZrRMfUJYgxcIk9Sh54FIO1vtfkg0B69REjER77ioZ/ov+eAApx/KmLQ==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "android" + ] + }, + "node_modules/@rollup/rollup-darwin-arm64": { + "version": "4.63.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-arm64/-/rollup-darwin-arm64-4.63.1.tgz", + "integrity": "sha512-FQNqd1lRy/0QhDk3xeRIkSBiCpXCiDnZO3YLVdcDKN1UBiKToNftCzcXYNLshmPDUMlu2TdeS8tGcsU6f3YF1Q==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ] + }, + "node_modules/@rollup/rollup-darwin-x64": { + "version": "4.63.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-x64/-/rollup-darwin-x64-4.63.1.tgz", + "integrity": "sha512-pvD16V939D3CloK0+qikpGaxiPrDUXTe7Y5cWOMkMSy7m1cawa8EGy/kXYi/G/cKAC4HDAbSnzCIk1WmsoOKXg==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ] + }, + "node_modules/@rollup/rollup-freebsd-arm64": { + "version": "4.63.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-arm64/-/rollup-freebsd-arm64-4.63.1.tgz", + "integrity": "sha512-pcFGeL2345VwdTnJhA6zLbew+YgWB0qBG2+dMtXjCicf6+rm6kO6cOoh5VnTe0ZMrMRgRyuHmCJxZWrIdzYuOw==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "freebsd" + ] + }, + "node_modules/@rollup/rollup-freebsd-x64": { + "version": "4.63.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-x64/-/rollup-freebsd-x64-4.63.1.tgz", + "integrity": "sha512-mRJlqSRulVzcKq/LKA6ICSIc3K/l4fzlVn/gePn2nXIHy8seRi5z/eeRE0d/XMBxcMldiXtQTSpRj0tkkC3g8Q==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "freebsd" + ] + }, + "node_modules/@rollup/rollup-linux-arm-gnueabihf": { + "version": "4.63.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-gnueabihf/-/rollup-linux-arm-gnueabihf-4.63.1.tgz", + "integrity": "sha512-YDUNvVM85TI3g/1OpnqKP1h4NeW/j64DfWMf+G3M809xNk1bJSnpFp4sh83NpmVE5DXnkh8ULor4LTVZKoYLHw==", + "cpu": [ + "arm" + ], + "dev": true, + "libc": [ + "glibc" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-arm-musleabihf": { + "version": "4.63.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-musleabihf/-/rollup-linux-arm-musleabihf-4.63.1.tgz", + "integrity": "sha512-7Mcn71p9ZuQFAj+h+dhQXy/yeLePRS2yKRnmW1DijA9thKO5qap0GNOIQK4yQ6iP3SU0Mrb/yWo8h8vgRba8lw==", + "cpu": [ + "arm" + ], + "dev": true, + "libc": [ + "musl" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-arm64-gnu": { + "version": "4.63.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-gnu/-/rollup-linux-arm64-gnu-4.63.1.tgz", + "integrity": "sha512-4YiLQTX6U4CSl0L9cluep9A9W6UmTfqBDc2/CH6wlu54pl4E7Jn3cOD8oxzvBDEGk/JMKgJ47C8g+radF7mwvg==", + "cpu": [ + "arm64" + ], + "dev": true, + "libc": [ + "glibc" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-arm64-musl": { + "version": "4.63.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-musl/-/rollup-linux-arm64-musl-4.63.1.tgz", + "integrity": "sha512-2ra8F7w8OquwZN9z2/fKFnli69wa8PLwaVzRMIPGb13ByMJwC28Fbp8YcVGoUhlYMTt7j5j9bNgpysrN2UM+vw==", + "cpu": [ + "arm64" + ], + "dev": true, + "libc": [ + "musl" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-loong64-gnu": { + "version": "4.63.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loong64-gnu/-/rollup-linux-loong64-gnu-4.63.1.tgz", + "integrity": "sha512-Sy20ncyhjmBP0Ml+UvQbimjlk6VFgjW5uNP+qqwHB00mTE8Bl2C1TuHTlRwK2YoXeZbee5lP2XevBWVkAQAtSQ==", + "cpu": [ + "loong64" + ], + "dev": true, + "libc": [ + "glibc" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-loong64-musl": { + "version": "4.63.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loong64-musl/-/rollup-linux-loong64-musl-4.63.1.tgz", + "integrity": "sha512-noITLp8oNjYliPnGWmLyelIHwULGqbHloQHGw1rtxbWhTuWooRpnZarZQJ1y9EUC4szuCusCc+HEpUtxpIwYvA==", + "cpu": [ + "loong64" + ], + "dev": true, + "libc": [ + "musl" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-ppc64-gnu": { + "version": "4.63.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-ppc64-gnu/-/rollup-linux-ppc64-gnu-4.63.1.tgz", + "integrity": "sha512-hlxxXd+F1mWiAcaFR7Sv9ZQT6m6UfI8+Vy/kFJzztq2pDMU/0wZ9sish0iszNZvsQDo8Gc0i5yuFEOz5dDf6fA==", + "cpu": [ + "ppc64" + ], + "dev": true, + "libc": [ + "glibc" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-ppc64-musl": { + "version": "4.63.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-ppc64-musl/-/rollup-linux-ppc64-musl-4.63.1.tgz", + "integrity": "sha512-EF7OpqQTQ/BvGqLzUi4rEHuagCV9MugAUXSHemwPW5vxZ75RR+jxO/2j95Ph2dalMpFHSVECjRoioHZgA9zOYA==", + "cpu": [ + "ppc64" + ], + "dev": true, + "libc": [ + "musl" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-riscv64-gnu": { + "version": "4.63.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-gnu/-/rollup-linux-riscv64-gnu-4.63.1.tgz", + "integrity": "sha512-wQO3JesW9PRkwlabQ27y7sPfVOOTLRG73I4F2UYHG5PXun3J9U3y+b7ezVKSYbsvSKGQ1k1cq8Qlun4C9kLt3w==", + "cpu": [ + "riscv64" + ], + "dev": true, + "libc": [ + "glibc" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-riscv64-musl": { + "version": "4.63.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-musl/-/rollup-linux-riscv64-musl-4.63.1.tgz", + "integrity": "sha512-ouAGwhO6wHRXdnOVCOsB0tRFkA7nhNB2Nwax6oECXN0YiN8EYUTBAOudADOB1PI+yDL61TeNx/u7MVCzksNbkQ==", + "cpu": [ + "riscv64" + ], + "dev": true, + "libc": [ + "musl" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-s390x-gnu": { + "version": "4.63.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-s390x-gnu/-/rollup-linux-s390x-gnu-4.63.1.tgz", + "integrity": "sha512-q2R38Sn+1J8RxhfJ+T54wSWmyKXWec+9jgDfqO2AtArEqHO5R2aeayp5H5OYLr5UYDVGsVaZPEFUooMhYCdz5A==", + "cpu": [ + "s390x" + ], + "dev": true, + "libc": [ + "glibc" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-x64-gnu": { + "version": "4.63.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.63.1.tgz", + "integrity": "sha512-gfI5T24WLLuFfSKw7Go/zDXjAAV0fny0swTaDv+WjK7vqcw4cRhFfdsyKL1n+ukI+ooBxn3bVQnyrn06WpI50w==", + "cpu": [ + "x64" + ], + "dev": true, + "libc": [ + "glibc" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-x64-musl": { + "version": "4.63.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.63.1.tgz", + "integrity": "sha512-4h6XqthmB4Hspji84wvgk+ElodTsGj+dbZqHJHHtKxj4mYq0ANSEEPX9ys3moJueqsRjwpaJYH7874Itwnj2ow==", + "cpu": [ + "x64" + ], + "dev": true, + "libc": [ + "musl" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-openbsd-x64": { + "version": "4.63.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-openbsd-x64/-/rollup-openbsd-x64-4.63.1.tgz", + "integrity": "sha512-dlfCOa87o1VAYegLQ9EKilx2JCeRofiyPGhTCmqnuXZ6bMPiycO1rq1+sKoulAp7pGLIsTIw+1x5R+zgh5LhhA==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "openbsd" + ] + }, + "node_modules/@rollup/rollup-openharmony-arm64": { + "version": "4.63.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-openharmony-arm64/-/rollup-openharmony-arm64-4.63.1.tgz", + "integrity": "sha512-cjkLbOlfcm3QGhMM1J5zaZjsw1GggbN6rw9UTSSRrPrR1KkcXnN7Uq9rPw34xImQ9VOY9GN+6u2Zj80B9ptkcw==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "openharmony" + ] + }, + "node_modules/@rollup/rollup-win32-arm64-msvc": { + "version": "4.63.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-arm64-msvc/-/rollup-win32-arm64-msvc-4.63.1.tgz", + "integrity": "sha512-Li1KdUnWGE4N3e1F/B4RTB1ms+nG4WBgjByO46pkeBVX/2UBsY53xf5vK9WygVmnH3RwncIST7lkSdLSY6P9lg==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ] + }, + "node_modules/@rollup/rollup-win32-ia32-msvc": { + "version": "4.63.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-ia32-msvc/-/rollup-win32-ia32-msvc-4.63.1.tgz", + "integrity": "sha512-t4ZYOSoLTgwhuFMrmTMLx/+i1DQVK7HYqMc6kY46EApwi8X0nIVphzdNoThU3xt6n+N5urG1/gxBdCaKDLavfg==", + "cpu": [ + "ia32" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ] + }, + "node_modules/@rollup/rollup-win32-x64-gnu": { + "version": "4.63.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-gnu/-/rollup-win32-x64-gnu-4.63.1.tgz", + "integrity": "sha512-RgroPfMmKlD1RzSDxvwgcPiy2HNQKoYV7OmwIXDsk73uKW5t6B/V8KIy27SMv/FNXFo/oSBtWc9J0X7t91ezZg==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ] + }, + "node_modules/@rollup/rollup-win32-x64-msvc": { + "version": "4.63.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-msvc/-/rollup-win32-x64-msvc-4.63.1.tgz", + "integrity": "sha512-at8QVep6S3h5Y6gSbdGU06bRY5WJkf6WUduM9YtvYMbYhB1MOFfUgc6kehitQXzOtMSaT70q7f9ydPhpqu821w==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ] + }, + "node_modules/@testing-library/dom": { + "version": "10.4.1", + "resolved": "https://registry.npmjs.org/@testing-library/dom/-/dom-10.4.1.tgz", + "integrity": "sha512-o4PXJQidqJl82ckFaXUeoAW+XysPLauYI43Abki5hABd853iMhitooc6znOnczgbTYmEP6U6/y1ZyKAIsvMKGg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/code-frame": "^7.10.4", + "@babel/runtime": "^7.12.5", + "@types/aria-query": "^5.0.1", + "aria-query": "5.3.0", + "dom-accessibility-api": "^0.5.9", + "lz-string": "^1.5.0", + "picocolors": "1.1.1", + "pretty-format": "^27.0.2" + }, + "engines": { + "node": ">=18" + } + }, + "node_modules/@testing-library/react": { + "version": "16.3.3", + "resolved": "https://registry.npmjs.org/@testing-library/react/-/react-16.3.3.tgz", + "integrity": "sha512-Uo193NgQbPMz6lrrhtRQQFcMC6Re/ELLFbbuVL30WDlZxlpZf9/lMHTAVxPRLw1q1iu9OJmR1c2BLiENRstdBg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/runtime": "^7.12.5" + }, + "engines": { + "node": ">=18" + }, + "peerDependencies": { + "@testing-library/dom": "^10.0.0", + "@types/react": "^18.0.0 || ^19.0.0", + "@types/react-dom": "^18.0.0 || ^19.0.0", + "react": "^18.0.0 || ^19.0.0", + "react-dom": "^18.0.0 || ^19.0.0" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + }, + "@types/react-dom": { + "optional": true + } + } + }, + "node_modules/@types/aria-query": { + "version": "5.0.4", + "resolved": "https://registry.npmjs.org/@types/aria-query/-/aria-query-5.0.4.tgz", + "integrity": "sha512-rfT93uj5s0PRL7EzccGMs3brplhcrghnDoV26NqKhCAS1hVo+WdNsPvE/yb6ilfr5hi2MEk6d5EWJTKdxg8jVw==", + "dev": true, + "license": "MIT" + }, + "node_modules/@types/babel__core": { + "version": "7.20.5", + "resolved": "https://registry.npmjs.org/@types/babel__core/-/babel__core-7.20.5.tgz", + "integrity": "sha512-qoQprZvz5wQFJwMDqeseRXWv3rqMvhgpbXFfVyWhbx9X47POIA6i/+dXefEmZKoAgOaTdaIgNSMqMIU61yRyzA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/parser": "^7.20.7", + "@babel/types": "^7.20.7", + "@types/babel__generator": "*", + "@types/babel__template": "*", + "@types/babel__traverse": "*" + } + }, + "node_modules/@types/babel__generator": { + "version": "7.27.0", + "resolved": "https://registry.npmjs.org/@types/babel__generator/-/babel__generator-7.27.0.tgz", + "integrity": "sha512-ufFd2Xi92OAVPYsy+P4n7/U7e68fex0+Ee8gSG9KX7eo084CWiQ4sdxktvdl0bOPupXtVJPY19zk6EwWqUQ8lg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/types": "^7.0.0" + } + }, + "node_modules/@types/babel__template": { + "version": "7.4.4", + "resolved": "https://registry.npmjs.org/@types/babel__template/-/babel__template-7.4.4.tgz", + "integrity": "sha512-h/NUaSyG5EyxBIp8YRxo4RMe2/qQgvyowRwVMzhYhBCONbW8PUsg4lkFMrhgZhUe5z3L3MiLDuvyJ/CaPa2A8A==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/parser": "^7.1.0", + "@babel/types": "^7.0.0" + } + }, + "node_modules/@types/babel__traverse": { + "version": "7.28.0", + "resolved": "https://registry.npmjs.org/@types/babel__traverse/-/babel__traverse-7.28.0.tgz", + "integrity": "sha512-8PvcXf70gTDZBgt9ptxJ8elBeBjcLOAcOtoO/mPJjtji1+CdGbHgm77om1GrsPxsiE+uXIpNSK64UYaIwQXd4Q==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/types": "^7.28.2" + } + }, + "node_modules/@types/chai": { + "version": "5.2.3", + "resolved": "https://registry.npmjs.org/@types/chai/-/chai-5.2.3.tgz", + "integrity": "sha512-Mw558oeA9fFbv65/y4mHtXDs9bPnFMZAL/jxdPFUpOHHIXX91mcgEHbS5Lahr+pwZFR8A7GQleRWeI6cGFC2UA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/deep-eql": "*", + "assertion-error": "^2.0.1" + } + }, + "node_modules/@types/d3-color": { + "version": "3.1.3", + "resolved": "https://registry.npmjs.org/@types/d3-color/-/d3-color-3.1.3.tgz", + "integrity": "sha512-iO90scth9WAbmgv7ogoq57O9YpKmFBbmoEoCHDB2xMBY0+/KVrqAaCDyCE16dUspeOvIxFFRI+0sEtqDqy2b4A==", + "license": "MIT" + }, + "node_modules/@types/d3-drag": { + "version": "3.0.7", + "resolved": "https://registry.npmjs.org/@types/d3-drag/-/d3-drag-3.0.7.tgz", + "integrity": "sha512-HE3jVKlzU9AaMazNufooRJ5ZpWmLIoc90A37WU2JMmeq28w1FQqCZswHZ3xR+SuxYftzHq6WU6KJHvqxKzTxxQ==", + "license": "MIT", + "dependencies": { + "@types/d3-selection": "*" + } + }, + "node_modules/@types/d3-interpolate": { + "version": "3.0.4", + "resolved": "https://registry.npmjs.org/@types/d3-interpolate/-/d3-interpolate-3.0.4.tgz", + "integrity": "sha512-mgLPETlrpVV1YRJIglr4Ez47g7Yxjl1lj7YKsiMCb27VJH9W8NVM6Bb9d8kkpG/uAQS5AmbA48q2IAolKKo1MA==", + "license": "MIT", + "dependencies": { + "@types/d3-color": "*" + } + }, + "node_modules/@types/d3-selection": { + "version": "3.0.11", + "resolved": "https://registry.npmjs.org/@types/d3-selection/-/d3-selection-3.0.11.tgz", + "integrity": "sha512-bhAXu23DJWsrI45xafYpkQ4NtcKMwWnAC/vKrd2l+nxMFuvOT3XMYTIj2opv8vq8AO5Yh7Qac/nSeP/3zjTK0w==", + "license": "MIT" + }, + "node_modules/@types/d3-transition": { + "version": "3.0.9", + "resolved": "https://registry.npmjs.org/@types/d3-transition/-/d3-transition-3.0.9.tgz", + "integrity": "sha512-uZS5shfxzO3rGlu0cC3bjmMFKsXv+SmZZcgp0KD22ts4uGXp5EVYGzu/0YdwZeKmddhcAccYtREJKkPfXkZuCg==", + "license": "MIT", + "dependencies": { + "@types/d3-selection": "*" + } + }, + "node_modules/@types/d3-zoom": { + "version": "3.0.8", + "resolved": "https://registry.npmjs.org/@types/d3-zoom/-/d3-zoom-3.0.8.tgz", + "integrity": "sha512-iqMC4/YlFCSlO8+2Ii1GGGliCAY4XdeG748w5vQUbevlbDu0zSjH/+jojorQVBK/se0j6DUFNPBGSqD3YWYnDw==", + "license": "MIT", + "dependencies": { + "@types/d3-interpolate": "*", + "@types/d3-selection": "*" + } + }, + "node_modules/@types/deep-eql": { + "version": "4.0.2", + "resolved": "https://registry.npmjs.org/@types/deep-eql/-/deep-eql-4.0.2.tgz", + "integrity": "sha512-c9h9dVVMigMPc4bwTvC5dxqtqJZwQPePsWjPlpSOnojbor6pGqdk541lfA7AqFQr5pB1BRdq0juY9db81BwyFw==", + "dev": true, + "license": "MIT" + }, + "node_modules/@types/estree": { + "version": "1.0.9", + "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.9.tgz", + "integrity": "sha512-GhdPgy1el4/ImP05X05Uw4cw2/M93BCUmnEvWZNStlCzEKME4Fkk+YpoA5OiHNQmoS7Cafb8Xa3Pya8m1Qrzeg==", + "dev": true, + "license": "MIT" + }, + "node_modules/@types/react": { + "version": "19.3.0", + "resolved": "https://registry.npmjs.org/@types/react/-/react-19.3.0.tgz", + "integrity": "sha512-N0rFCuH9YoxG9/m61l9MfpJKfmLOVU0em7ipIz6TRgSSkvReLB9vL85GB+yr8Bs5leqpvg96JSwF4ZS1s4viQg==", + "devOptional": true, + "license": "MIT", + "dependencies": { + "csstype": "^3.2.2" + } + }, + "node_modules/@types/react-dom": { + "version": "19.3.0", + "resolved": "https://registry.npmjs.org/@types/react-dom/-/react-dom-19.3.0.tgz", + "integrity": "sha512-ZI7bU42mZXXKHn/qNLEw2IrbiINU7X5+vfgdixBHkCNpYWXjKgfQ/P+uyGb5CjOLB9UcnTeg3rylQtV2hym44Q==", + "devOptional": true, + "license": "MIT", + "peerDependencies": { + "@types/react": "^19.3.0" + } + }, + "node_modules/@vitejs/plugin-react": { + "version": "5.2.0", + "resolved": "https://registry.npmjs.org/@vitejs/plugin-react/-/plugin-react-5.2.0.tgz", + "integrity": "sha512-YmKkfhOAi3wsB1PhJq5Scj3GXMn3WvtQ/JC0xoopuHoXSdmtdStOpFrYaT1kie2YgFBcIe64ROzMYRjCrYOdYw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/core": "^7.29.0", + "@babel/plugin-transform-react-jsx-self": "^7.27.1", + "@babel/plugin-transform-react-jsx-source": "^7.27.1", + "@rolldown/pluginutils": "1.0.0-rc.3", + "@types/babel__core": "^7.20.5", + "react-refresh": "^0.18.0" + }, + "engines": { + "node": "^20.19.0 || >=22.12.0" + }, + "peerDependencies": { + "vite": "^4.2.0 || ^5.0.0 || ^6.0.0 || ^7.0.0 || ^8.0.0" + } + }, + "node_modules/@vitest/expect": { + "version": "3.2.7", + "resolved": "https://registry.npmjs.org/@vitest/expect/-/expect-3.2.7.tgz", + "integrity": "sha512-E8eBXaKibuvH2pSZErOjdVb5vF4PbKYcrnluBTYxEk1l/VhhwZg1kZQsdtjq+CsF5CFydf2Rdkz7jDHKSisi3w==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/chai": "^5.2.2", + "@vitest/spy": "3.2.7", + "@vitest/utils": "3.2.7", + "chai": "^5.2.0", + "tinyrainbow": "^2.0.0" + }, + "funding": { + "url": "https://opencollective.com/vitest" + } + }, + "node_modules/@vitest/mocker": { + "version": "3.2.7", + "resolved": "https://registry.npmjs.org/@vitest/mocker/-/mocker-3.2.7.tgz", + "integrity": "sha512-Trr0hYO9CM3Wj6ksWHRhK9IZpIY6wTMO5u/MqXurMxT57sWBaOPEtP3Oq60ihZuh5JsiagKfz95OcxdEP6dBrA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@vitest/spy": "3.2.7", + "estree-walker": "^3.0.3", + "magic-string": "^0.30.17" + }, + "funding": { + "url": "https://opencollective.com/vitest" + }, + "peerDependencies": { + "msw": "^2.4.9", + "vite": "^5.0.0 || ^6.0.0 || ^7.0.0-0" + }, + "peerDependenciesMeta": { + "msw": { + "optional": true + }, + "vite": { + "optional": true + } + } + }, + "node_modules/@vitest/pretty-format": { + "version": "3.2.7", + "resolved": "https://registry.npmjs.org/@vitest/pretty-format/-/pretty-format-3.2.7.tgz", + "integrity": "sha512-KUHlwqVu0sRlhCdyPdQ/wBoTfRahjUky1MubOmYw9fWfIZy1gNoHpuaaQBPAaMaVYdQYHJLurzj8ECCj5OwTqA==", + "dev": true, + "license": "MIT", + "dependencies": { + "tinyrainbow": "^2.0.0" + }, + "funding": { + "url": "https://opencollective.com/vitest" + } + }, + "node_modules/@vitest/runner": { + "version": "3.2.7", + "resolved": "https://registry.npmjs.org/@vitest/runner/-/runner-3.2.7.tgz", + "integrity": "sha512-sB9y4ovltoQP+WaUPwmSxO9WIg9Ig694Di5PalVPsYHklAdE027mehpWF2SQSVq+k6sFgaivbTjTJwZLSHbedA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@vitest/utils": "3.2.7", + "pathe": "^2.0.3", + "strip-literal": "^3.0.0" + }, + "funding": { + "url": "https://opencollective.com/vitest" + } + }, + "node_modules/@vitest/snapshot": { + "version": "3.2.7", + "resolved": "https://registry.npmjs.org/@vitest/snapshot/-/snapshot-3.2.7.tgz", + "integrity": "sha512-7C+MwShwtBSI5Buwoyg3s/iY1eHL9PKAf+O1wVh/TdnjXUtkoL/9YQtre90i4MtNXM6edP1wJ2zOBpfCyhIS7g==", + "dev": true, + "license": "MIT", + "dependencies": { + "@vitest/pretty-format": "3.2.7", + "magic-string": "^0.30.17", + "pathe": "^2.0.3" + }, + "funding": { + "url": "https://opencollective.com/vitest" + } + }, + "node_modules/@vitest/spy": { + "version": "3.2.7", + "resolved": "https://registry.npmjs.org/@vitest/spy/-/spy-3.2.7.tgz", + "integrity": "sha512-Q2eQGI6d2L/hBtZ0qNuKcAGid68XK6cv1xsoaIma6PaJhHPoqcEJhYpXZ/5myCMqkNgtP6UKuBhbc0nHKnrkuQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "tinyspy": "^4.0.3" + }, + "funding": { + "url": "https://opencollective.com/vitest" + } + }, + "node_modules/@vitest/utils": { + "version": "3.2.7", + "resolved": "https://registry.npmjs.org/@vitest/utils/-/utils-3.2.7.tgz", + "integrity": "sha512-x6BDOd7dyo3PFLY3I9/HJ25X/6OurhGXk2/B9gOZNPF7XDVjeBK4k01lQE5uvDpbuheErh91qYuE1E2OEjK3Rw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@vitest/pretty-format": "3.2.7", + "loupe": "^3.1.4", + "tinyrainbow": "^2.0.0" + }, + "funding": { + "url": "https://opencollective.com/vitest" + } + }, + "node_modules/@xyflow/react": { + "version": "12.11.6", + "resolved": "https://registry.npmjs.org/@xyflow/react/-/react-12.11.6.tgz", + "integrity": "sha512-9XsEJNHjatKYndszKTF/bsU7FOP9dJ6V/EQwzy3oMdtqgBuUq7BjKSwkEo+C7s4qHstHQfwwoHA3E8QfpPxZZQ==", + "license": "MIT", + "dependencies": { + "@xyflow/system": "0.0.82", + "classcat": "^5.0.3", + "zustand": "^4.4.0" + }, + "peerDependencies": { + "@types/react": ">=17", + "@types/react-dom": ">=17", + "react": ">=17", + "react-dom": ">=17" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + }, + "@types/react-dom": { + "optional": true + } + } + }, + "node_modules/@xyflow/system": { + "version": "0.0.82", + "resolved": "https://registry.npmjs.org/@xyflow/system/-/system-0.0.82.tgz", + "integrity": "sha512-4DKnL3CGtCGLRSmgDqaajRVgeksMXq/Yw4wPfdMfm7JvdIiWHGzVYOfFUztiATwdBXZqUU6HhehwUdbV9G23PQ==", + "license": "MIT", + "dependencies": { + "@types/d3-drag": "^3.0.7", + "@types/d3-interpolate": "^3.0.4", + "@types/d3-selection": "^3.0.10", + "@types/d3-transition": "^3.0.8", + "@types/d3-zoom": "^3.0.8", + "d3-drag": "^3.0.0", + "d3-interpolate": "^3.0.1", + "d3-selection": "^3.0.0", + "d3-zoom": "^3.0.0" + } + }, + "node_modules/ansi-regex": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz", + "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/ansi-styles": { + "version": "5.2.0", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-5.2.0.tgz", + "integrity": "sha512-Cxwpt2SfTzTtXcfOlzGEee8O+c+MmUgGrNiBcXnuWxuFJHe6a5Hz7qwhwe5OgaSYI0IJvkLqWX1ASG+cJOkEiA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/chalk/ansi-styles?sponsor=1" + } + }, + "node_modules/aria-query": { + "version": "5.3.0", + "resolved": "https://registry.npmjs.org/aria-query/-/aria-query-5.3.0.tgz", + "integrity": "sha512-b0P0sZPKtyu8HkeRAfCq0IfURZK+SuwMjY1UXGBU27wpAiTwQAIlq56IbIO+ytk/JjS1fMR14ee5WBBfKi5J6A==", + "dev": true, + "license": "Apache-2.0", + "dependencies": { + "dequal": "^2.0.3" + } + }, + "node_modules/assertion-error": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/assertion-error/-/assertion-error-2.0.1.tgz", + "integrity": "sha512-Izi8RQcffqCeNVgFigKli1ssklIbpHnCYc6AknXGYoB6grJqyeby7jv12JUQgmTAnIDnbck1uxksT4dzN3PWBA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=12" + } + }, + "node_modules/baseline-browser-mapping": { + "version": "2.11.22", + "resolved": "https://registry.npmjs.org/baseline-browser-mapping/-/baseline-browser-mapping-2.11.22.tgz", + "integrity": "sha512-pWc4w51fBFd7mav43/zKRC+RI6f4yfzQoVlfvE8dECePyfkn1bzLp01Fj0QACcyCZyFhiEMyD2qScfKRWgWibA==", + "dev": true, + "license": "Apache-2.0", + "bin": { + "baseline-browser-mapping": "dist/cli.cjs" + }, + "engines": { + "node": ">=6.0.0" + } + }, + "node_modules/bidi-js": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/bidi-js/-/bidi-js-1.1.0.tgz", + "integrity": "sha512-fX1Onk0tdVPC7obPWB5EbJ1z7NVhLq4m2xZLq2YXBkxzMXIGRpNMU88n0EPgWseKl12J7zXs7qrDxPK4sRs2fg==", + "dev": true, + "license": "MIT", + "dependencies": { + "require-from-string": "^2.0.2" + } + }, + "node_modules/browserslist": { + "version": "4.28.9", + "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.28.9.tgz", + "integrity": "sha512-EWazOblFYUvlGZcfGhPUPmYh3nikUxBVb+y9MJun5f3hBi812X+8MSQTujLBtgK3cf51fJWbWfOjyeO954d+Eg==", + "dev": true, + "funding": [ + { + "type": "opencollective", + "url": "https://opencollective.com/browserslist" + }, + { + "type": "tidelift", + "url": "https://tidelift.com/funding/github/npm/browserslist" + }, + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ], + "license": "MIT", + "dependencies": { + "baseline-browser-mapping": "^2.11.20", + "caniuse-lite": "^1.0.30001810", + "electron-to-chromium": "^1.5.420", + "node-releases": "^2.0.54", + "update-browserslist-db": "^1.3.2" + }, + "bin": { + "browserslist": "cli.js" + }, + "engines": { + "node": "^6 || ^7 || ^8 || ^9 || ^10 || ^11 || ^12 || >=13.7" + } + }, + "node_modules/cac": { + "version": "6.7.14", + "resolved": "https://registry.npmjs.org/cac/-/cac-6.7.14.tgz", + "integrity": "sha512-b6Ilus+c3RrdDk+JhLKUAQfzzgLEPy6wcXqS7f/xe1EETvsDP6GORG7SFuOs6cID5YkqchW/LXZbX5bc8j7ZcQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/caniuse-lite": { + "version": "1.0.30001810", + "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001810.tgz", + "integrity": "sha512-TITQPUkaz+aVk5GL6NhOdwk1aEaNTSDPsGFWrTuhKGtjTF70jL/Oht2W4c6rXUe5fu7Ie19VIahAXHIIiWWNeg==", + "dev": true, + "funding": [ + { + "type": "opencollective", + "url": "https://opencollective.com/browserslist" + }, + { + "type": "tidelift", + "url": "https://tidelift.com/funding/github/npm/caniuse-lite" + }, + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ], + "license": "CC-BY-4.0" + }, + "node_modules/chai": { + "version": "5.3.3", + "resolved": "https://registry.npmjs.org/chai/-/chai-5.3.3.tgz", + "integrity": "sha512-4zNhdJD/iOjSH0A05ea+Ke6MU5mmpQcbQsSOkgdaUMJ9zTlDTD/GYlwohmIE2u0gaxHYiVHEn1Fw9mZ/ktJWgw==", + "dev": true, + "license": "MIT", + "dependencies": { + "assertion-error": "^2.0.1", + "check-error": "^2.1.1", + "deep-eql": "^5.0.1", + "loupe": "^3.1.0", + "pathval": "^2.0.0" + }, + "engines": { + "node": ">=18" + } + }, + "node_modules/check-error": { + "version": "2.1.3", + "resolved": "https://registry.npmjs.org/check-error/-/check-error-2.1.3.tgz", + "integrity": "sha512-PAJdDJusoxnwm1VwW07VWwUN1sl7smmC3OKggvndJFadxxDRyFJBX/ggnu/KE4kQAB7a3Dp8f/YXC1FlUprWmA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 16" + } + }, + "node_modules/classcat": { + "version": "5.0.5", + "resolved": "https://registry.npmjs.org/classcat/-/classcat-5.0.5.tgz", + "integrity": "sha512-JhZUT7JFcQy/EzW605k/ktHtncoo9vnyW/2GspNYwFlN1C/WmjuV/xtS04e9SOkL2sTdw0VAZ2UGCcQ9lR6p6w==", + "license": "MIT" + }, + "node_modules/convert-source-map": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/convert-source-map/-/convert-source-map-2.0.0.tgz", + "integrity": "sha512-Kvp459HrV2FEJ1CAsi1Ku+MY3kasH19TFykTz2xWmMeq6bk2NU3XXvfJ+Q61m0xktWwt+1HSYf3JZsTms3aRJg==", + "dev": true, + "license": "MIT" + }, + "node_modules/css-tree": { + "version": "3.2.1", + "resolved": "https://registry.npmjs.org/css-tree/-/css-tree-3.2.1.tgz", + "integrity": "sha512-X7sjQzceUhu1u7Y/ylrRZFU2FS6LRiFVp6rKLPg23y3x3c3DOKAwuXGDp+PAGjh6CSnCjYeAul8pcT8bAl+lSA==", + "dev": true, + "license": "MIT", + "dependencies": { + "mdn-data": "2.27.1", + "source-map-js": "^1.2.1" + }, + "engines": { + "node": "^10 || ^12.20.0 || ^14.13.0 || >=15.0.0" + } + }, + "node_modules/csstype": { + "version": "3.2.3", + "resolved": "https://registry.npmjs.org/csstype/-/csstype-3.2.3.tgz", + "integrity": "sha512-z1HGKcYy2xA8AGQfwrn0PAy+PB7X/GSj3UVJW9qKyn43xWa+gl5nXmU4qqLMRzWVLFC8KusUX8T/0kCiOYpAIQ==", + "devOptional": true, + "license": "MIT" + }, + "node_modules/d3-color": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/d3-color/-/d3-color-3.1.0.tgz", + "integrity": "sha512-zg/chbXyeBtMQ1LbD/WSoW2DpC3I0mpmPdW+ynRTj/x2DAWYrIY7qeZIHidozwV24m4iavr15lNwIwLxRmOxhA==", + "license": "ISC", + "engines": { + "node": ">=12" + } + }, + "node_modules/d3-dispatch": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/d3-dispatch/-/d3-dispatch-3.0.1.tgz", + "integrity": "sha512-rzUyPU/S7rwUflMyLc1ETDeBj0NRuHKKAcvukozwhshr6g6c5d8zh4c2gQjY2bZ0dXeGLWc1PF174P2tVvKhfg==", + "license": "ISC", + "engines": { + "node": ">=12" + } + }, + "node_modules/d3-drag": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/d3-drag/-/d3-drag-3.0.0.tgz", + "integrity": "sha512-pWbUJLdETVA8lQNJecMxoXfH6x+mO2UQo8rSmZ+QqxcbyA3hfeprFgIT//HW2nlHChWeIIMwS2Fq+gEARkhTkg==", + "license": "ISC", + "dependencies": { + "d3-dispatch": "1 - 3", + "d3-selection": "3" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/d3-ease": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/d3-ease/-/d3-ease-3.0.1.tgz", + "integrity": "sha512-wR/XK3D3XcLIZwpbvQwQ5fK+8Ykds1ip7A2Txe0yxncXSdq1L9skcG7blcedkOX+ZcgxGAmLX1FrRGbADwzi0w==", + "license": "BSD-3-Clause", + "engines": { + "node": ">=12" + } + }, + "node_modules/d3-interpolate": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/d3-interpolate/-/d3-interpolate-3.0.1.tgz", + "integrity": "sha512-3bYs1rOD33uo8aqJfKP3JWPAibgw8Zm2+L9vBKEHJ2Rg+viTR7o5Mmv5mZcieN+FRYaAOWX5SJATX6k1PWz72g==", + "license": "ISC", + "dependencies": { + "d3-color": "1 - 3" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/d3-selection": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/d3-selection/-/d3-selection-3.0.0.tgz", + "integrity": "sha512-fmTRWbNMmsmWq6xJV8D19U/gw/bwrHfNXxrIN+HfZgnzqTHp9jOmKMhsTUjXOJnZOdZY9Q28y4yebKzqDKlxlQ==", + "license": "ISC", + "engines": { + "node": ">=12" + } + }, + "node_modules/d3-timer": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/d3-timer/-/d3-timer-3.0.1.tgz", + "integrity": "sha512-ndfJ/JxxMd3nw31uyKoY2naivF+r29V+Lc0svZxe1JvvIRmi8hUsrMvdOwgS1o6uBHmiz91geQ0ylPP0aj1VUA==", + "license": "ISC", + "engines": { + "node": ">=12" + } + }, + "node_modules/d3-transition": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/d3-transition/-/d3-transition-3.0.1.tgz", + "integrity": "sha512-ApKvfjsSR6tg06xrL434C0WydLr7JewBB3V+/39RMHsaXTOG0zmt/OAXeng5M5LBm0ojmxJrpomQVZ1aPvBL4w==", + "license": "ISC", + "dependencies": { + "d3-color": "1 - 3", + "d3-dispatch": "1 - 3", + "d3-ease": "1 - 3", + "d3-interpolate": "1 - 3", + "d3-timer": "1 - 3" + }, + "engines": { + "node": ">=12" + }, + "peerDependencies": { + "d3-selection": "2 - 3" + } + }, + "node_modules/d3-zoom": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/d3-zoom/-/d3-zoom-3.0.0.tgz", + "integrity": "sha512-b8AmV3kfQaqWAuacbPuNbL6vahnOJflOhexLzMMNLga62+/nh0JzvJ0aO/5a5MVgUFGS7Hu1P9P03o3fJkDCyw==", + "license": "ISC", + "dependencies": { + "d3-dispatch": "1 - 3", + "d3-drag": "2 - 3", + "d3-interpolate": "1 - 3", + "d3-selection": "2 - 3", + "d3-transition": "2 - 3" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/data-urls": { + "version": "7.0.0", + "resolved": "https://registry.npmjs.org/data-urls/-/data-urls-7.0.0.tgz", + "integrity": "sha512-23XHcCF+coGYevirZceTVD7NdJOqVn+49IHyxgszm+JIiHLoB2TkmPtsYkNWT1pvRSGkc35L6NHs0yHkN2SumA==", + "dev": true, + "license": "MIT", + "dependencies": { + "whatwg-mimetype": "^5.0.0", + "whatwg-url": "^16.0.0" + }, + "engines": { + "node": "^20.19.0 || ^22.12.0 || >=24.0.0" + } + }, + "node_modules/data-urls/node_modules/whatwg-url": { + "version": "16.0.1", + "resolved": "https://registry.npmjs.org/whatwg-url/-/whatwg-url-16.0.1.tgz", + "integrity": "sha512-1to4zXBxmXHV3IiSSEInrreIlu02vUOvrhxJJH5vcxYTBDAx51cqZiKdyTxlecdKNSjj8EcxGBxNf6Vg+945gw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@exodus/bytes": "^1.11.0", + "tr46": "^6.0.0", + "webidl-conversions": "^8.0.1" + }, + "engines": { + "node": "^20.19.0 || ^22.12.0 || >=24.0.0" + } + }, + "node_modules/debug": { + "version": "4.4.3", + "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz", + "integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==", + "dev": true, + "license": "MIT", + "dependencies": { + "ms": "^2.1.3" + }, + "engines": { + "node": ">=6.0" + }, + "peerDependenciesMeta": { + "supports-color": { + "optional": true + } + } + }, + "node_modules/decimal.js": { + "version": "10.6.0", + "resolved": "https://registry.npmjs.org/decimal.js/-/decimal.js-10.6.0.tgz", + "integrity": "sha512-YpgQiITW3JXGntzdUmyUR1V812Hn8T1YVXhCu+wO3OpS4eU9l4YdD3qjyiKdV6mvV29zapkMeD390UVEf2lkUg==", + "dev": true, + "license": "MIT" + }, + "node_modules/deep-eql": { + "version": "5.0.2", + "resolved": "https://registry.npmjs.org/deep-eql/-/deep-eql-5.0.2.tgz", + "integrity": "sha512-h5k/5U50IJJFpzfL6nO9jaaumfjO/f2NjK/oYB2Djzm4p9L+3T9qWpZqZ2hAbLPuuYq9wrU08WQyBTL5GbPk5Q==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6" + } + }, + "node_modules/dequal": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/dequal/-/dequal-2.0.3.tgz", + "integrity": "sha512-0je+qPKHEMohvfRTCEo3CrPG6cAzAYgmzKyxRiYSSDkS6eGJdyVJm7WaYA5ECaAD9wLB2T4EEeymA5aFVcYXCA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6" + } + }, + "node_modules/dom-accessibility-api": { + "version": "0.5.16", + "resolved": "https://registry.npmjs.org/dom-accessibility-api/-/dom-accessibility-api-0.5.16.tgz", + "integrity": "sha512-X7BJ2yElsnOJ30pZF4uIIDfBEVgF4XEBxL9Bxhy6dnrm5hkzqmsWHGTiHqRiITNhMyFLyAiWndIJP7Z1NTteDg==", + "dev": true, + "license": "MIT" + }, + "node_modules/electron-to-chromium": { + "version": "1.5.427", + "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.427.tgz", + "integrity": "sha512-n14zb3FdsChZ2BNobqNHAJMcP3ifFv4paox2LvCrfVAQcqGiSURgbJl+PfMpHVCNFkStnNc+RRVtPBTVW5PDgw==", + "dev": true, + "license": "ISC" + }, + "node_modules/entities": { + "version": "8.1.0", + "resolved": "https://registry.npmjs.org/entities/-/entities-8.1.0.tgz", + "integrity": "sha512-kxL7msIffSuh9aaFAMD7rxAIuTRMAHMeBtgHW2yUdWw732ZNh4MehkF2gdjvtdmikkaIP9bFDDJOPlsvm7avrA==", + "dev": true, + "license": "BSD-2-Clause", + "engines": { + "node": ">=20.19.0" + }, + "funding": { + "url": "https://github.com/fb55/entities?sponsor=1" + } + }, + "node_modules/es-module-lexer": { + "version": "1.7.0", + "resolved": "https://registry.npmjs.org/es-module-lexer/-/es-module-lexer-1.7.0.tgz", + "integrity": "sha512-jEQoCwk8hyb2AZziIOLhDqpm5+2ww5uIE6lkO/6jcOCusfk6LhMHpXXfBLXTZ7Ydyt0j4VoUQv6uGNYbdW+kBA==", + "dev": true, + "license": "MIT" + }, + "node_modules/esbuild": { + "version": "0.28.2", + "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.28.2.tgz", + "integrity": "sha512-HKVLS8dvII+xoKW9kmqxbRKrnWEXfJJr/FZhhJmiqIB0e053QNYFqOBouTMO/k5sID4MvCiUCvv8b9M4h32wIA==", + "dev": true, + "hasInstallScript": true, + "license": "MIT", + "bin": { + "esbuild": "bin/esbuild" + }, + "engines": { + "node": ">=18" + }, + "optionalDependencies": { + "@esbuild/aix-ppc64": "0.28.2", + "@esbuild/android-arm": "0.28.2", + "@esbuild/android-arm64": "0.28.2", + "@esbuild/android-x64": "0.28.2", + "@esbuild/darwin-arm64": "0.28.2", + "@esbuild/darwin-x64": "0.28.2", + "@esbuild/freebsd-arm64": "0.28.2", + "@esbuild/freebsd-x64": "0.28.2", + "@esbuild/linux-arm": "0.28.2", + "@esbuild/linux-arm64": "0.28.2", + "@esbuild/linux-ia32": "0.28.2", + "@esbuild/linux-loong64": "0.28.2", + "@esbuild/linux-mips64el": "0.28.2", + "@esbuild/linux-ppc64": "0.28.2", + "@esbuild/linux-riscv64": "0.28.2", + "@esbuild/linux-s390x": "0.28.2", + "@esbuild/linux-x64": "0.28.2", + "@esbuild/netbsd-arm64": "0.28.2", + "@esbuild/netbsd-x64": "0.28.2", + "@esbuild/openbsd-arm64": "0.28.2", + "@esbuild/openbsd-x64": "0.28.2", + "@esbuild/openharmony-arm64": "0.28.2", + "@esbuild/sunos-x64": "0.28.2", + "@esbuild/win32-arm64": "0.28.2", + "@esbuild/win32-ia32": "0.28.2", + "@esbuild/win32-x64": "0.28.2" + } + }, + "node_modules/escalade": { + "version": "3.2.0", + "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.2.0.tgz", + "integrity": "sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6" + } + }, + "node_modules/estree-walker": { + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/estree-walker/-/estree-walker-3.0.3.tgz", + "integrity": "sha512-7RUKfXgSMMkzt6ZuXmqapOurLGPPfgj6l9uRZ7lRGolvk0y2yocc35LdcxKC5PQZdn2DMqioAQ2NoWcrTKmm6g==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/estree": "^1.0.0" + } + }, + "node_modules/expect-type": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/expect-type/-/expect-type-1.4.0.tgz", + "integrity": "sha512-KfYbmpRm0VbLjEvVa9yGwCi9GI34xvi7A/HXYWQO65CSD2u3MczUJSuwXKFIxlGsgBQizV9q5J9NHj4VG0n+pA==", + "dev": true, + "license": "Apache-2.0", + "engines": { + "node": ">=12.0.0" + } + }, + "node_modules/fdir": { + "version": "6.5.0", + "resolved": "https://registry.npmjs.org/fdir/-/fdir-6.5.0.tgz", + "integrity": "sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=12.0.0" + }, + "peerDependencies": { + "picomatch": "^3 || ^4" + }, + "peerDependenciesMeta": { + "picomatch": { + "optional": true + } + } + }, + "node_modules/fsevents": { + "version": "2.3.3", + "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz", + "integrity": "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==", + "dev": true, + "hasInstallScript": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": "^8.16.0 || ^10.6.0 || >=11.0.0" + } + }, + "node_modules/gensync": { + "version": "1.0.0-beta.2", + "resolved": "https://registry.npmjs.org/gensync/-/gensync-1.0.0-beta.2.tgz", + "integrity": "sha512-3hN7NaskYvMDLQY55gnW3NQ+mesEAepTqlg+VEbj7zzqEMBVNhzcGYYeqFo/TlYz6eQiFcp1HcsCZO+nGgS8zg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/html-encoding-sniffer": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/html-encoding-sniffer/-/html-encoding-sniffer-6.0.0.tgz", + "integrity": "sha512-CV9TW3Y3f8/wT0BRFc1/KAVQ3TUHiXmaAb6VW9vtiMFf7SLoMd1PdAc4W3KFOFETBJUb90KatHqlsZMWV+R9Gg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@exodus/bytes": "^1.6.0" + }, + "engines": { + "node": "^20.19.0 || ^22.12.0 || >=24.0.0" + } + }, + "node_modules/is-potential-custom-element-name": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/is-potential-custom-element-name/-/is-potential-custom-element-name-1.0.1.tgz", + "integrity": "sha512-bCYeRA2rVibKZd+s2625gGnGF/t7DSqDs4dP7CrLA1m7jKWz6pps0LpYLJN8Q64HtmPKJ1hrN3nzPNKFEKOUiQ==", + "dev": true, + "license": "MIT" + }, + "node_modules/js-tokens": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-4.0.0.tgz", + "integrity": "sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==", + "dev": true, + "license": "MIT" + }, + "node_modules/jsdom": { + "version": "30.0.1", + "resolved": "https://registry.npmjs.org/jsdom/-/jsdom-30.0.1.tgz", + "integrity": "sha512-52v7mUVUfNQVYYqE1lcdaymWL0njO7lTLUog6ZvW2U5KsbiLk/GnZlVJ+qx0xfNJZ6Gn+KSpPNE52vurbxZwrA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@asamuzakjp/css-color": "^6.0.5", + "@asamuzakjp/dom-selector": "^8.3.0", + "@bramus/specificity": "^2.4.2", + "@csstools/css-syntax-patches-for-csstree": "^1.1.7", + "@exodus/bytes": "^1.15.1", + "css-tree": "^3.2.1", + "data-urls": "^7.0.0", + "decimal.js": "^10.6.0", + "html-encoding-sniffer": "^6.0.0", + "is-potential-custom-element-name": "^1.0.1", + "lru-cache": "^11.5.2", + "parse5": "^8.0.1", + "saxes": "^6.0.0", + "symbol-tree": "^3.2.4", + "tough-cookie": "^6.0.2", + "undici": "^8.9.0", + "w3c-xmlserializer": "^5.0.0", + "webidl-conversions": "^8.0.1", + "whatwg-mimetype": "^5.0.0", + "whatwg-url": "^17.1.0", + "xml-name-validator": "^5.0.0" + }, + "engines": { + "node": "^22.22.2 || ^24.15.0 || >=26.0.0" + }, + "peerDependencies": { + "canvas": "^3.2.3" + }, + "peerDependenciesMeta": { + "canvas": { + "optional": true + } + } + }, + "node_modules/jsdom/node_modules/lru-cache": { + "version": "11.5.2", + "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-11.5.2.tgz", + "integrity": "sha512-4pfM1Ff0x50o0tQwb5ucw/RzNyD0/YJME6IVcStalZuMWxdt3sR3huStTtxz4PUmvZfRguvDejasvQ2kifR11g==", + "dev": true, + "license": "BlueOak-1.0.0", + "engines": { + "node": "20 || >=22" + } + }, + "node_modules/jsesc": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/jsesc/-/jsesc-3.1.0.tgz", + "integrity": "sha512-/sM3dO2FOzXjKQhJuo0Q173wf2KOo8t4I8vHy6lF9poUp7bKT0/NHE8fPX23PwfhnykfqnC2xRxOnVw5XuGIaA==", + "dev": true, + "license": "MIT", + "bin": { + "jsesc": "bin/jsesc" + }, + "engines": { + "node": ">=6" + } + }, + "node_modules/json5": { + "version": "2.2.3", + "resolved": "https://registry.npmjs.org/json5/-/json5-2.2.3.tgz", + "integrity": "sha512-XmOWe7eyHYH14cLdVPoyg+GOH3rYX++KpzrylJwSW98t3Nk+U8XOl8FWKOgwtzdb8lXGf6zYwDUzeHMWfxasyg==", + "dev": true, + "license": "MIT", + "bin": { + "json5": "lib/cli.js" + }, + "engines": { + "node": ">=6" + } + }, + "node_modules/loupe": { + "version": "3.2.1", + "resolved": "https://registry.npmjs.org/loupe/-/loupe-3.2.1.tgz", + "integrity": "sha512-CdzqowRJCeLU72bHvWqwRBBlLcMEtIvGrlvef74kMnV2AolS9Y8xUv1I0U/MNAWMhBlKIoyuEgoJ0t/bbwHbLQ==", + "dev": true, + "license": "MIT" + }, + "node_modules/lru-cache": { + "version": "5.1.1", + "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-5.1.1.tgz", + "integrity": "sha512-KpNARQA3Iwv+jTA0utUVVbrh+Jlrr1Fv0e56GGzAFOXN7dk/FviaDW8LHmK52DlcH4WP2n6gI8vN1aesBFgo9w==", + "dev": true, + "license": "ISC", + "dependencies": { + "yallist": "^3.0.2" + } + }, + "node_modules/lz-string": { + "version": "1.5.0", + "resolved": "https://registry.npmjs.org/lz-string/-/lz-string-1.5.0.tgz", + "integrity": "sha512-h5bgJWpxJNswbU7qCrV0tIKQCaS3blPDrqKWx+QxzuzL1zGUzij9XCWLrSLsJPu5t+eWA/ycetzYAO5IOMcWAQ==", + "dev": true, + "license": "MIT", + "bin": { + "lz-string": "bin/bin.js" + } + }, + "node_modules/magic-string": { + "version": "0.30.21", + "resolved": "https://registry.npmjs.org/magic-string/-/magic-string-0.30.21.tgz", + "integrity": "sha512-vd2F4YUyEXKGcLHoq+TEyCjxueSeHnFxyyjNp80yg0XV4vUhnDer/lvvlqM/arB5bXQN5K2/3oinyCRyx8T2CQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@jridgewell/sourcemap-codec": "^1.5.5" + } + }, + "node_modules/mdn-data": { + "version": "2.27.1", + "resolved": "https://registry.npmjs.org/mdn-data/-/mdn-data-2.27.1.tgz", + "integrity": "sha512-9Yubnt3e8A0OKwxYSXyhLymGW4sCufcLG6VdiDdUGVkPhpqLxlvP5vl1983gQjJl3tqbrM731mjaZaP68AgosQ==", + "dev": true, + "license": "CC0-1.0" + }, + "node_modules/ms": { + "version": "2.1.3", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz", + "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==", + "dev": true, + "license": "MIT" + }, + "node_modules/nanoid": { + "version": "3.3.19", + "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.19.tgz", + "integrity": "sha512-Y2tUNy4ouw6tq5oDSKeQYGOyhkUBhNOcGV/02KC+6kd9eDGqdZd++mjMiIDilrBYvjEnCYvVtsuHCuP+okSfug==", + "dev": true, + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ], + "license": "MIT", + "bin": { + "nanoid": "bin/nanoid.cjs" + }, + "engines": { + "node": "^10 || ^12 || ^13.7 || ^14 || >=15.0.1" + } + }, + "node_modules/node-releases": { + "version": "2.0.55", + "resolved": "https://registry.npmjs.org/node-releases/-/node-releases-2.0.55.tgz", + "integrity": "sha512-mIrE/Cw9y+9Au6dS5vDKDhQza9YvG6w+ZrS6X+ZzA7yFW/soAeaups4Qzn1bL6g5FVy8WtP79+0j82oPIbqRjQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=18" + } + }, + "node_modules/parse5": { + "version": "8.0.1", + "resolved": "https://registry.npmjs.org/parse5/-/parse5-8.0.1.tgz", + "integrity": "sha512-z1e/HMG90obSGeidlli3hj7cbocou0/wa5HacvI3ASx34PecNjNQeaHNo5WIZpWofN9kgkqV1q5YvXe3F0FoPw==", + "dev": true, + "license": "MIT", + "dependencies": { + "entities": "^8.0.0" + }, + "funding": { + "url": "https://github.com/inikulin/parse5?sponsor=1" + } + }, + "node_modules/pathe": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/pathe/-/pathe-2.0.3.tgz", + "integrity": "sha512-WUjGcAqP1gQacoQe+OBJsFA7Ld4DyXuUIjZ5cc75cLHvJ7dtNsTugphxIADwspS+AraAUePCKrSVtPLFj/F88w==", + "dev": true, + "license": "MIT" + }, + "node_modules/pathval": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/pathval/-/pathval-2.0.1.tgz", + "integrity": "sha512-//nshmD55c46FuFw26xV/xFAaB5HF9Xdap7HJBBnrKdAd6/GxDBaNA1870O79+9ueg61cZLSVc+OaFlfmObYVQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 14.16" + } + }, + "node_modules/picocolors": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz", + "integrity": "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==", + "dev": true, + "license": "ISC" + }, + "node_modules/picomatch": { + "version": "4.0.7", + "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.7.tgz", + "integrity": "sha512-qcJu88Q2IWqJsDD529JKMdwGm/dvInW4HvQnRwiH9JtihJvzGOscDtHE3x1pBKeUOTysQ8kVmLnJ2kJu7yhcGA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/sponsors/jonschlinkert" + } + }, + "node_modules/playwright": { + "version": "1.55.0", + "resolved": "https://registry.npmjs.org/playwright/-/playwright-1.55.0.tgz", + "integrity": "sha512-sdCWStblvV1YU909Xqx0DhOjPZE4/5lJsIS84IfN9dAZfcl/CIZ5O8l3o0j7hPMjDvqoTF8ZUcc+i/GL5erstA==", + "dev": true, + "license": "Apache-2.0", + "dependencies": { + "playwright-core": "1.55.0" + }, + "bin": { + "playwright": "cli.js" + }, + "engines": { + "node": ">=18" + }, + "optionalDependencies": { + "fsevents": "2.3.2" + } + }, + "node_modules/playwright-core": { + "version": "1.55.0", + "resolved": "https://registry.npmjs.org/playwright-core/-/playwright-core-1.55.0.tgz", + "integrity": "sha512-GvZs4vU3U5ro2nZpeiwyb0zuFaqb9sUiAJuyrWpcGouD8y9/HLgGbNRjIph7zU9D3hnPaisMl9zG9CgFi/biIg==", + "dev": true, + "license": "Apache-2.0", + "bin": { + "playwright-core": "cli.js" + }, + "engines": { + "node": ">=18" + } + }, + "node_modules/playwright/node_modules/fsevents": { + "version": "2.3.2", + "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.2.tgz", + "integrity": "sha512-xiqMQR4xAeHTuB9uWm+fFRcIOgKBMiOBP+eXiyT7jsgVCq1bkVygt00oASowB7EdtpOHaaPgKt812P9ab+DDKA==", + "dev": true, + "hasInstallScript": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": "^8.16.0 || ^10.6.0 || >=11.0.0" + } + }, + "node_modules/postcss": { + "version": "8.5.28", + "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.5.28.tgz", + "integrity": "sha512-RRuzqDtt5Y9h3quz5hWhK+TPnsmVs6WwSU6LkJMeY4HstUEDuYTG8UJSdawMRzmzAtV+KEoG8N3Qg2qLy5vM/A==", + "dev": true, + "funding": [ + { + "type": "opencollective", + "url": "https://opencollective.com/postcss/" + }, + { + "type": "tidelift", + "url": "https://tidelift.com/funding/github/npm/postcss" + }, + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ], + "license": "MIT", + "dependencies": { + "nanoid": "^3.3.18", + "picocolors": "^1.1.1", + "source-map-js": "^1.2.1" + }, + "engines": { + "node": "^10 || ^12 || >=14" + } + }, + "node_modules/pretty-format": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/pretty-format/-/pretty-format-27.5.1.tgz", + "integrity": "sha512-Qb1gy5OrP5+zDf2Bvnzdl3jsTf1qXVMazbvCoKhtKqVs4/YK4ozX4gKQJJVyNe+cajNPn0KoC0MC3FUmaHWEmQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "ansi-regex": "^5.0.1", + "ansi-styles": "^5.0.0", + "react-is": "^17.0.1" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/punycode": { + "version": "2.3.1", + "resolved": "https://registry.npmjs.org/punycode/-/punycode-2.3.1.tgz", + "integrity": "sha512-vYt7UD1U9Wg6138shLtLOvdAu+8DsC/ilFtEVHcH+wydcSpNE20AfSOduf6MkRFahL5FY7X1oU7nKVZFtfq8Fg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6" + } + }, + "node_modules/react": { + "version": "19.3.0", + "resolved": "https://registry.npmjs.org/react/-/react-19.3.0.tgz", + "integrity": "sha512-E8LUcbtBWt20bbl2YoHfx4ZDBdxVTfOKtCZn9cDSJ4l6/nuoApcpIBcj47t2wZoVX8g2ZHuMHbiShgCR1T5Sog==", + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/react-dom": { + "version": "19.3.0", + "resolved": "https://registry.npmjs.org/react-dom/-/react-dom-19.3.0.tgz", + "integrity": "sha512-JDk8dgif51OjFoDE70+OT9ICyYr+69HlmihNwp1+Nsfbna3t5sIiCa9ZJktDmQ4/1b/rn26hIAR2uYXDMr5r0Q==", + "license": "MIT", + "dependencies": { + "scheduler": "^0.28.0" + }, + "peerDependencies": { + "react": "^19.3.0" + } + }, + "node_modules/react-is": { + "version": "17.0.2", + "resolved": "https://registry.npmjs.org/react-is/-/react-is-17.0.2.tgz", + "integrity": "sha512-w2GsyukL62IJnlaff/nRegPQR94C/XXamvMWmSHRJ4y7Ts/4ocGRmTHvOs8PSE6pB3dWOrD/nueuU5sduBsQ4w==", + "dev": true, + "license": "MIT" + }, + "node_modules/react-refresh": { + "version": "0.18.0", + "resolved": "https://registry.npmjs.org/react-refresh/-/react-refresh-0.18.0.tgz", + "integrity": "sha512-QgT5//D3jfjJb6Gsjxv0Slpj23ip+HtOpnNgnb2S5zU3CB26G/IDPGoy4RJB42wzFE46DRsstbW6tKHoKbhAxw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/require-from-string": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/require-from-string/-/require-from-string-2.0.2.tgz", + "integrity": "sha512-Xf0nWe6RseziFMu+Ap9biiUbmplq6S9/p+7w7YXP/JBHhrUDDUhwa+vANyubuqfZWTveU//DYVGsDG7RKL/vEw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/rollup": { + "version": "4.63.1", + "resolved": "https://registry.npmjs.org/rollup/-/rollup-4.63.1.tgz", + "integrity": "sha512-3Df9jsstwhccuEfmAMi9l8XUh/GOkVObmFTU7CCVBysEbcOZLl84jCtaAZMcPiMz2EGKsATzQcU+Xr3n/wU6cg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/estree": "1.0.9" + }, + "bin": { + "rollup": "dist/bin/rollup" + }, + "engines": { + "node": ">=18.0.0", + "npm": ">=8.0.0" + }, + "optionalDependencies": { + "@napi-rs/lzma-linux-x64-gnu": "1.5.1", + "@rollup/rollup-android-arm-eabi": "4.63.1", + "@rollup/rollup-android-arm64": "4.63.1", + "@rollup/rollup-darwin-arm64": "4.63.1", + "@rollup/rollup-darwin-x64": "4.63.1", + "@rollup/rollup-freebsd-arm64": "4.63.1", + "@rollup/rollup-freebsd-x64": "4.63.1", + "@rollup/rollup-linux-arm-gnueabihf": "4.63.1", + "@rollup/rollup-linux-arm-musleabihf": "4.63.1", + "@rollup/rollup-linux-arm64-gnu": "4.63.1", + "@rollup/rollup-linux-arm64-musl": "4.63.1", + "@rollup/rollup-linux-loong64-gnu": "4.63.1", + "@rollup/rollup-linux-loong64-musl": "4.63.1", + "@rollup/rollup-linux-ppc64-gnu": "4.63.1", + "@rollup/rollup-linux-ppc64-musl": "4.63.1", + "@rollup/rollup-linux-riscv64-gnu": "4.63.1", + "@rollup/rollup-linux-riscv64-musl": "4.63.1", + "@rollup/rollup-linux-s390x-gnu": "4.63.1", + "@rollup/rollup-linux-x64-gnu": "4.63.1", + "@rollup/rollup-linux-x64-musl": "4.63.1", + "@rollup/rollup-openbsd-x64": "4.63.1", + "@rollup/rollup-openharmony-arm64": "4.63.1", + "@rollup/rollup-win32-arm64-msvc": "4.63.1", + "@rollup/rollup-win32-ia32-msvc": "4.63.1", + "@rollup/rollup-win32-x64-gnu": "4.63.1", + "@rollup/rollup-win32-x64-msvc": "4.63.1", + "fsevents": "~2.3.2" + } + }, + "node_modules/saxes": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/saxes/-/saxes-6.0.0.tgz", + "integrity": "sha512-xAg7SOnEhrm5zI3puOOKyy1OMcMlIJZYNJY7xLBwSze0UjhPLnWfj2GF2EpT0jmzaJKIWKHLsaSSajf35bcYnA==", + "dev": true, + "license": "ISC", + "dependencies": { + "xmlchars": "^2.2.0" + }, + "engines": { + "node": ">=v12.22.7" + } + }, + "node_modules/scheduler": { + "version": "0.28.0", + "resolved": "https://registry.npmjs.org/scheduler/-/scheduler-0.28.0.tgz", + "integrity": "sha512-juorfCmIkIw8tT+p5BXSm6PJjQF/ycEYmKyzURCIt/RaZIhL+PulbQ9Yu2z1HdOJDdqDTlxA1+xKBmHXJsczAw==", + "license": "MIT" + }, + "node_modules/semver": { + "version": "6.3.1", + "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz", + "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==", + "dev": true, + "license": "ISC", + "bin": { + "semver": "bin/semver.js" + } + }, + "node_modules/siginfo": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/siginfo/-/siginfo-2.0.0.tgz", + "integrity": "sha512-ybx0WO1/8bSBLEWXZvEd7gMW3Sn3JFlW3TvX1nREbDLRNQNaeNN8WK0meBwPdAaOI7TtRRRJn/Es1zhrrCHu7g==", + "dev": true, + "license": "ISC" + }, + "node_modules/source-map-js": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/source-map-js/-/source-map-js-1.2.1.tgz", + "integrity": "sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==", + "dev": true, + "license": "BSD-3-Clause", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/stackback": { + "version": "0.0.2", + "resolved": "https://registry.npmjs.org/stackback/-/stackback-0.0.2.tgz", + "integrity": "sha512-1XMJE5fQo1jGH6Y/7ebnwPOBEkIEnT4QF32d5R1+VXdXveM0IBMJt8zfaxX1P3QhVwrYe+576+jkANtSS2mBbw==", + "dev": true, + "license": "MIT" + }, + "node_modules/std-env": { + "version": "3.10.0", + "resolved": "https://registry.npmjs.org/std-env/-/std-env-3.10.0.tgz", + "integrity": "sha512-5GS12FdOZNliM5mAOxFRg7Ir0pWz8MdpYm6AY6VPkGpbA7ZzmbzNcBJQ0GPvvyWgcY7QAhCgf9Uy89I03faLkg==", + "dev": true, + "license": "MIT" + }, + "node_modules/strip-literal": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/strip-literal/-/strip-literal-3.1.0.tgz", + "integrity": "sha512-8r3mkIM/2+PpjHoOtiAW8Rg3jJLHaV7xPwG+YRGrv6FP0wwk/toTpATxWYOW0BKdWwl82VT2tFYi5DlROa0Mxg==", + "dev": true, + "license": "MIT", + "dependencies": { + "js-tokens": "^9.0.1" + }, + "funding": { + "url": "https://github.com/sponsors/antfu" + } + }, + "node_modules/strip-literal/node_modules/js-tokens": { + "version": "9.0.1", + "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-9.0.1.tgz", + "integrity": "sha512-mxa9E9ITFOt0ban3j6L5MpjwegGz6lBQmM1IJkWeBZGcMxto50+eWdjC/52xDbS2vy0k7vIMK0Fe2wfL9OQSpQ==", + "dev": true, + "license": "MIT" + }, + "node_modules/symbol-tree": { + "version": "3.2.4", + "resolved": "https://registry.npmjs.org/symbol-tree/-/symbol-tree-3.2.4.tgz", + "integrity": "sha512-9QNk5KwDF+Bvz+PyObkmSYjI5ksVUYtjW7AU22r2NKcfLJcXp96hkDWU3+XndOsUb+AQ9QhfzfCT2O+CNWT5Tw==", + "dev": true, + "license": "MIT" + }, + "node_modules/tinybench": { + "version": "2.9.0", + "resolved": "https://registry.npmjs.org/tinybench/-/tinybench-2.9.0.tgz", + "integrity": "sha512-0+DUvqWMValLmha6lr4kD8iAMK1HzV0/aKnCtWb9v9641TnP/MFb7Pc2bxoxQjTXAErryXVgUOfv2YqNllqGeg==", + "dev": true, + "license": "MIT" + }, + "node_modules/tinyexec": { + "version": "0.3.2", + "resolved": "https://registry.npmjs.org/tinyexec/-/tinyexec-0.3.2.tgz", + "integrity": "sha512-KQQR9yN7R5+OSwaK0XQoj22pwHoTlgYqmUscPYoknOoWCWfj/5/ABTMRi69FrKU5ffPVh5QcFikpWJI/P1ocHA==", + "dev": true, + "license": "MIT" + }, + "node_modules/tinyglobby": { + "version": "0.2.17", + "resolved": "https://registry.npmjs.org/tinyglobby/-/tinyglobby-0.2.17.tgz", + "integrity": "sha512-wXR/dYpcqKmfWpEdZjiKJOwCNFndD0DMnrW/cYjVGttEkBfVgcLFHoNrlj47mjOVic9yyNu65alsgF4NQyTa2g==", + "dev": true, + "license": "MIT", + "dependencies": { + "fdir": "^6.5.0", + "picomatch": "^4.0.4" + }, + "engines": { + "node": ">=12.0.0" + }, + "funding": { + "url": "https://github.com/sponsors/SuperchupuDev" + } + }, + "node_modules/tinypool": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/tinypool/-/tinypool-1.1.1.tgz", + "integrity": "sha512-Zba82s87IFq9A9XmjiX5uZA/ARWDrB03OHlq+Vw1fSdt0I+4/Kutwy8BP4Y/y/aORMo61FQ0vIb5j44vSo5Pkg==", + "dev": true, + "license": "MIT", + "engines": { + "node": "^18.0.0 || >=20.0.0" + } + }, + "node_modules/tinyrainbow": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/tinyrainbow/-/tinyrainbow-2.0.0.tgz", + "integrity": "sha512-op4nsTR47R6p0vMUUoYl/a+ljLFVtlfaXkLQmqfLR1qHma1h/ysYk4hEXZ880bf2CYgTskvTa/e196Vd5dDQXw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=14.0.0" + } + }, + "node_modules/tinyspy": { + "version": "4.0.6", + "resolved": "https://registry.npmjs.org/tinyspy/-/tinyspy-4.0.6.tgz", + "integrity": "sha512-u8KszXvGfU68hVcZpRHKG28T0krMuv2G5nDhiHaMLen/gIuFEgIJhaJuO69qjnXg5paSrbPMFfx3brNuN8eVSg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=14.0.0" + } + }, + "node_modules/tldts": { + "version": "7.4.12", + "resolved": "https://registry.npmjs.org/tldts/-/tldts-7.4.12.tgz", + "integrity": "sha512-WylhSDKVeYnWXL3a+vKTaOxjnOeEGw938hImY8zoRWJjRRK/Jp1K+IihBzIONpUmW4e3WmXT6q5FW6vlESVZCA==", + "dev": true, + "license": "MIT", + "dependencies": { + "tldts-core": "^7.4.12" + }, + "bin": { + "tldts": "bin/cli.js" + } + }, + "node_modules/tldts-core": { + "version": "7.4.12", + "resolved": "https://registry.npmjs.org/tldts-core/-/tldts-core-7.4.12.tgz", + "integrity": "sha512-nYNzS2WRf4QJmjzFFgAxLOBjyBxAGRbCy9PVBPaglcYyYajh40VBn+v5Ngr96ZMc7oM0+aCJdtQnNejvdBnXMQ==", + "dev": true, + "license": "MIT" + }, + "node_modules/tough-cookie": { + "version": "6.0.2", + "resolved": "https://registry.npmjs.org/tough-cookie/-/tough-cookie-6.0.2.tgz", + "integrity": "sha512-exgYmnmL/sJpR3upZfXG5PoatXQii55xAiXGXzY+sROLZ/Y+SLcp9PgJNI9Vz37HpQ74WvDcLT8eqm+kV3FzrA==", + "dev": true, + "license": "BSD-3-Clause", + "dependencies": { + "tldts": "^7.0.5" + }, + "engines": { + "node": ">=16" + } + }, + "node_modules/tr46": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/tr46/-/tr46-6.0.0.tgz", + "integrity": "sha512-bLVMLPtstlZ4iMQHpFHTR7GAGj2jxi8Dg0s2h2MafAE4uSWF98FC/3MomU51iQAMf8/qDUbKWf5GxuvvVcXEhw==", + "dev": true, + "license": "MIT", + "dependencies": { + "punycode": "^2.3.1" + }, + "engines": { + "node": ">=20" + } + }, + "node_modules/typescript": { + "version": "5.9.3", + "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.9.3.tgz", + "integrity": "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw==", + "dev": true, + "license": "Apache-2.0", + "bin": { + "tsc": "bin/tsc", + "tsserver": "bin/tsserver" + }, + "engines": { + "node": ">=14.17" + } + }, + "node_modules/undici": { + "version": "8.10.2", + "resolved": "https://registry.npmjs.org/undici/-/undici-8.10.2.tgz", + "integrity": "sha512-/y4/bH9YNU5hi9NIrpOuvGXFcxrj3CMrV+/AYpowAYTpHn8gX/XPFjNy766FPoYY0miQhdW977JFWKGNhBdwyQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=22.19.0" + } + }, + "node_modules/update-browserslist-db": { + "version": "1.3.3", + "resolved": "https://registry.npmjs.org/update-browserslist-db/-/update-browserslist-db-1.3.3.tgz", + "integrity": "sha512-pJ2sYawQS0R/WI928Gj5GlPhTGzbMelq0+4INtSYNDV9ErKJcX6xjGWkoG/VnB3dpUm00zALaqkrUD77pO5TDQ==", + "dev": true, + "funding": [ + { + "type": "opencollective", + "url": "https://opencollective.com/browserslist" + }, + { + "type": "tidelift", + "url": "https://tidelift.com/funding/github/npm/browserslist" + }, + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ], + "license": "MIT", + "dependencies": { + "escalade": "^3.2.0", + "picocolors": "^1.1.1" + }, + "bin": { + "update-browserslist-db": "cli.js" + }, + "peerDependencies": { + "browserslist": ">= 4.21.0" + } + }, + "node_modules/use-sync-external-store": { + "version": "1.7.0", + "resolved": "https://registry.npmjs.org/use-sync-external-store/-/use-sync-external-store-1.7.0.tgz", + "integrity": "sha512-6L+EeigHMQhdaIPNIFUKwfWJSwWFQ8gJbJ2DLOs5sDIegTwR9fRxvnM3uciHKjIZhFz+KAv2emhWMRvDmMcY8A==", + "license": "MIT", + "peerDependencies": { + "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0" + } + }, + "node_modules/vite": { + "version": "7.3.6", + "resolved": "https://registry.npmjs.org/vite/-/vite-7.3.6.tgz", + "integrity": "sha512-4XP60spRGjSZFf1qYH+dJIkK2znL3zQfl9KkOV9MkkRR/3Dls0dxaBsQPTloEc5BLXWPL9vsOxopxyKoMmDueg==", + "dev": true, + "license": "MIT", + "dependencies": { + "esbuild": "^0.27.0 || ^0.28.0", + "fdir": "^6.5.0", + "picomatch": "^4.0.3", + "postcss": "^8.5.6", + "rollup": "^4.43.0", + "tinyglobby": "^0.2.15" + }, + "bin": { + "vite": "bin/vite.js" + }, + "engines": { + "node": "^20.19.0 || >=22.12.0" + }, + "funding": { + "url": "https://github.com/vitejs/vite?sponsor=1" + }, + "optionalDependencies": { + "fsevents": "~2.3.3" + }, + "peerDependencies": { + "@types/node": "^20.19.0 || >=22.12.0", + "jiti": ">=1.21.0", + "less": "^4.0.0", + "lightningcss": "^1.21.0", + "sass": "^1.70.0", + "sass-embedded": "^1.70.0", + "stylus": ">=0.54.8", + "sugarss": "^5.0.0", + "terser": "^5.16.0", + "tsx": "^4.8.1", + "yaml": "^2.4.2" + }, + "peerDependenciesMeta": { + "@types/node": { + "optional": true + }, + "jiti": { + "optional": true + }, + "less": { + "optional": true + }, + "lightningcss": { + "optional": true + }, + "sass": { + "optional": true + }, + "sass-embedded": { + "optional": true + }, + "stylus": { + "optional": true + }, + "sugarss": { + "optional": true + }, + "terser": { + "optional": true + }, + "tsx": { + "optional": true + }, + "yaml": { + "optional": true + } + } + }, + "node_modules/vite-node": { + "version": "3.2.4", + "resolved": "https://registry.npmjs.org/vite-node/-/vite-node-3.2.4.tgz", + "integrity": "sha512-EbKSKh+bh1E1IFxeO0pg1n4dvoOTt0UDiXMd/qn++r98+jPO1xtJilvXldeuQ8giIB5IkpjCgMleHMNEsGH6pg==", + "dev": true, + "license": "MIT", + "dependencies": { + "cac": "^6.7.14", + "debug": "^4.4.1", + "es-module-lexer": "^1.7.0", + "pathe": "^2.0.3", + "vite": "^5.0.0 || ^6.0.0 || ^7.0.0-0" + }, + "bin": { + "vite-node": "vite-node.mjs" + }, + "engines": { + "node": "^18.0.0 || ^20.0.0 || >=22.0.0" + }, + "funding": { + "url": "https://opencollective.com/vitest" + } + }, + "node_modules/vitest": { + "version": "3.2.7", + "resolved": "https://registry.npmjs.org/vitest/-/vitest-3.2.7.tgz", + "integrity": "sha512-KrxIJ62Fd89gfysR4WotlgZABiz2dqFPgqGzX7s+CwsqLFomRH7777ZcrOD6+WVAh7khPQP41A+BKbpcJFrdEg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/chai": "^5.2.2", + "@vitest/expect": "3.2.7", + "@vitest/mocker": "3.2.7", + "@vitest/pretty-format": "^3.2.7", + "@vitest/runner": "3.2.7", + "@vitest/snapshot": "3.2.7", + "@vitest/spy": "3.2.7", + "@vitest/utils": "3.2.7", + "chai": "^5.2.0", + "debug": "^4.4.1", + "expect-type": "^1.2.1", + "magic-string": "^0.30.17", + "pathe": "^2.0.3", + "picomatch": "^4.0.2", + "std-env": "^3.9.0", + "tinybench": "^2.9.0", + "tinyexec": "^0.3.2", + "tinyglobby": "^0.2.14", + "tinypool": "^1.1.1", + "tinyrainbow": "^2.0.0", + "vite": "^5.0.0 || ^6.0.0 || ^7.0.0-0", + "vite-node": "3.2.4", + "why-is-node-running": "^2.3.0" + }, + "bin": { + "vitest": "vitest.mjs" + }, + "engines": { + "node": "^18.0.0 || ^20.0.0 || >=22.0.0" + }, + "funding": { + "url": "https://opencollective.com/vitest" + }, + "peerDependencies": { + "@edge-runtime/vm": "*", + "@types/debug": "^4.1.12", + "@types/node": "^18.0.0 || ^20.0.0 || >=22.0.0", + "@vitest/browser": "3.2.7", + "@vitest/ui": "3.2.7", + "happy-dom": "*", + "jsdom": "*" + }, + "peerDependenciesMeta": { + "@edge-runtime/vm": { + "optional": true + }, + "@types/debug": { + "optional": true + }, + "@types/node": { + "optional": true + }, + "@vitest/browser": { + "optional": true + }, + "@vitest/ui": { + "optional": true + }, + "happy-dom": { + "optional": true + }, + "jsdom": { + "optional": true + } + } + }, + "node_modules/w3c-xmlserializer": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/w3c-xmlserializer/-/w3c-xmlserializer-5.0.0.tgz", + "integrity": "sha512-o8qghlI8NZHU1lLPrpi2+Uq7abh4GGPpYANlalzWxyWteJOCsr/P+oPBA49TOLu5FTZO4d3F9MnWJfiMo4BkmA==", + "dev": true, + "license": "MIT", + "dependencies": { + "xml-name-validator": "^5.0.0" + }, + "engines": { + "node": ">=18" + } + }, + "node_modules/webidl-conversions": { + "version": "8.0.1", + "resolved": "https://registry.npmjs.org/webidl-conversions/-/webidl-conversions-8.0.1.tgz", + "integrity": "sha512-BMhLD/Sw+GbJC21C/UgyaZX41nPt8bUTg+jWyDeg7e7YN4xOM05YPSIXceACnXVtqyEw/LMClUQMtMZ+PGGpqQ==", + "dev": true, + "license": "BSD-2-Clause", + "engines": { + "node": ">=20" + } + }, + "node_modules/whatwg-mimetype": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/whatwg-mimetype/-/whatwg-mimetype-5.0.0.tgz", + "integrity": "sha512-sXcNcHOC51uPGF0P/D4NVtrkjSU2fNsm9iog4ZvZJsL3rjoDAzXZhkm2MWt1y+PUdggKAYVoMAIYcs78wJ51Cw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=20" + } + }, + "node_modules/whatwg-url": { + "version": "17.1.1", + "resolved": "https://registry.npmjs.org/whatwg-url/-/whatwg-url-17.1.1.tgz", + "integrity": "sha512-ohjk1mdUebJVadRt3bAhQhx8lSnISq+GDttK79LFl8EHQkAPvzwctoasC4hs8tBt6kLAncBWWyq1N52qEfKvDw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@exodus/bytes": "^1.15.1", + "tr46": "^6.0.0", + "webidl-conversions": "^8.0.1" + }, + "engines": { + "node": "^22.14.0 || >=24.0.0" + } + }, + "node_modules/why-is-node-running": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/why-is-node-running/-/why-is-node-running-2.3.0.tgz", + "integrity": "sha512-hUrmaWBdVDcxvYqnyh09zunKzROWjbZTiNy8dBEjkS7ehEDQibXJ7XvlmtbwuTclUiIyN+CyXQD4Vmko8fNm8w==", + "dev": true, + "license": "MIT", + "dependencies": { + "siginfo": "^2.0.0", + "stackback": "0.0.2" + }, + "bin": { + "why-is-node-running": "cli.js" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/xml-name-validator": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/xml-name-validator/-/xml-name-validator-5.0.0.tgz", + "integrity": "sha512-EvGK8EJ3DhaHfbRlETOWAS5pO9MZITeauHKJyb8wyajUfQUenkIg2MvLDTZ4T/TgIcm3HU0TFBgWWboAZ30UHg==", + "dev": true, + "license": "Apache-2.0", + "engines": { + "node": ">=18" + } + }, + "node_modules/xmlchars": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/xmlchars/-/xmlchars-2.2.0.tgz", + "integrity": "sha512-JZnDKK8B0RCDw84FNdDAIpZK+JuJw+s7Lz8nksI7SIuU3UXJJslUthsi+uWBUYOwPFwW7W7PRLRfUKpxjtjFCw==", + "dev": true, + "license": "MIT" + }, + "node_modules/yallist": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/yallist/-/yallist-3.1.1.tgz", + "integrity": "sha512-a4UGQaWPH59mOXUYnAG2ewncQS4i4F43Tv3JoAM+s2VDAmS9NsK8GpDMLrCHPksFT7h3K6TOoUNn2pb7RoXx4g==", + "dev": true, + "license": "ISC" + }, + "node_modules/zustand": { + "version": "4.5.7", + "resolved": "https://registry.npmjs.org/zustand/-/zustand-4.5.7.tgz", + "integrity": "sha512-CHOUy7mu3lbD6o6LJLfllpjkzhHXSBlX8B9+qPddUsIfeF5S/UZ5q0kmCsnRqT1UHFQZchNFDDzMbQsuesHWlw==", + "license": "MIT", + "dependencies": { + "use-sync-external-store": "^1.2.2" + }, + "engines": { + "node": ">=12.7.0" + }, + "peerDependencies": { + "@types/react": ">=16.8", + "immer": ">=9.0.6", + "react": ">=16.8" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + }, + "immer": { + "optional": true + }, + "react": { + "optional": true + } + } + } + } +} diff --git a/frontend/package.json b/frontend/package.json new file mode 100644 index 0000000..3ced5d5 --- /dev/null +++ b/frontend/package.json @@ -0,0 +1,30 @@ +{ + "name": "repopulse-frontend", + "private": true, + "version": "1.5.0", + "type": "module", + "scripts": { + "dev": "vite", + "build": "tsc --noEmit && vite build", + "typecheck": "tsc --noEmit", + "test": "vitest run", + "test:e2e": "playwright test" + }, + "dependencies": { + "@xyflow/react": "^12.8.5", + "react": "^19.1.1", + "react-dom": "^19.1.1" + }, + "devDependencies": { + "@playwright/test": "^1.55.0", + "@testing-library/dom": "^10.4.1", + "@testing-library/react": "^16.3.3", + "@types/react": "^19.1.12", + "@types/react-dom": "^19.1.9", + "@vitejs/plugin-react": "^5.0.2", + "jsdom": "^30.0.1", + "typescript": "^5.9.2", + "vite": "^7.1.5", + "vitest": "^3.2.4" + } +} diff --git a/frontend/playwright.config.ts b/frontend/playwright.config.ts new file mode 100644 index 0000000..7598543 --- /dev/null +++ b/frontend/playwright.config.ts @@ -0,0 +1,36 @@ +import { defineConfig, devices } from '@playwright/test' + +export default defineConfig({ + testDir: './e2e', + timeout: 30_000, + fullyParallel: false, + workers: 6, + reporter: 'list', + use: { + baseURL: 'http://127.0.0.1:4173', + trace: 'retain-on-failure', + screenshot: 'only-on-failure', + }, + projects: [ + { name: '1920x1080', use: { ...devices['Desktop Chrome'], viewport: { width: 1920, height: 1080 } } }, + { name: '1680x900', use: { ...devices['Desktop Chrome'], viewport: { width: 1680, height: 900 } } }, + { name: '1440x900', use: { ...devices['Desktop Chrome'], viewport: { width: 1440, height: 900 } } }, + { name: '1366x768', use: { ...devices['Desktop Chrome'], viewport: { width: 1366, height: 768 } } }, + { name: '1024x768', use: { ...devices['Desktop Chrome'], viewport: { width: 1024, height: 768 } } }, + { name: '390x844', use: { ...devices['Desktop Chrome'], viewport: { width: 390, height: 844 } } }, + ], + webServer: [ + { + command: 'node e2e/mock-api.mjs', + url: 'http://127.0.0.1:8001/health', + reuseExistingServer: false, + timeout: 15_000, + }, + { + command: 'node e2e/start-vite.mjs', + url: 'http://127.0.0.1:4173', + reuseExistingServer: false, + timeout: 30_000, + }, + ], +}) diff --git a/frontend/public/brand/repopulse-logo-light.svg b/frontend/public/brand/repopulse-logo-light.svg new file mode 100644 index 0000000..b3bee10 --- /dev/null +++ b/frontend/public/brand/repopulse-logo-light.svg @@ -0,0 +1,7 @@ + + + + + RepoPulse + REPOSITORY INTELLIGENCE + diff --git a/frontend/public/brand/repopulse-logo.svg b/frontend/public/brand/repopulse-logo.svg new file mode 100644 index 0000000..cf9be93 --- /dev/null +++ b/frontend/public/brand/repopulse-logo.svg @@ -0,0 +1,7 @@ + + + + + RepoPulse + REPOSITORY INTELLIGENCE + diff --git a/frontend/public/brand/repopulse-mark-mono.svg b/frontend/public/brand/repopulse-mark-mono.svg new file mode 100644 index 0000000..a64a026 --- /dev/null +++ b/frontend/public/brand/repopulse-mark-mono.svg @@ -0,0 +1,4 @@ + + + + diff --git a/frontend/public/brand/repopulse-mark.svg b/frontend/public/brand/repopulse-mark.svg new file mode 100644 index 0000000..93f9f33 --- /dev/null +++ b/frontend/public/brand/repopulse-mark.svg @@ -0,0 +1,5 @@ + + + + + diff --git a/frontend/public/favicon.svg b/frontend/public/favicon.svg new file mode 100644 index 0000000..93f9f33 --- /dev/null +++ b/frontend/public/favicon.svg @@ -0,0 +1,5 @@ + + + + + diff --git a/frontend/public/site.webmanifest b/frontend/public/site.webmanifest new file mode 100644 index 0000000..7b15023 --- /dev/null +++ b/frontend/public/site.webmanifest @@ -0,0 +1,9 @@ +{ + "name": "RepoPulse — Repository Intelligence", + "short_name": "RepoPulse", + "description": "Portfolio-level repository intelligence from deterministic scans.", + "display": "standalone", + "background_color": "#07111c", + "theme_color": "#0d2130", + "icons": [{ "src": "/favicon.svg", "sizes": "any", "type": "image/svg+xml", "purpose": "any maskable" }] +} diff --git a/frontend/src/App.test.tsx b/frontend/src/App.test.tsx new file mode 100644 index 0000000..9e8b14d --- /dev/null +++ b/frontend/src/App.test.tsx @@ -0,0 +1,128 @@ +// @vitest-environment jsdom + +import { cleanup, fireEvent, render, screen, waitFor } from '@testing-library/react' +import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest' + +import App from './App' +import { api, type ScanJob } from './api' +import { testComparison, testDetail, testMeta, testRepository, testScans, testTrend } from './test-fixtures' + +const repository = testRepository() +const secondRepository = testRepository('gitea:65', 'Jens/AgentTestLab', { last_scan_health: 93, last_scan_readiness: 'READY' }) +const queuedJob: ScanJob = { + id: 'job-1', + repository_id: repository.id, + status: 'queued', + trigger: 'manual', + requested_revision: 'revision-1', + actual_revision: null, + phase: 'queued', + progress: 0, + message: 'Analysis queued', + created_at: '2026-09-12T20:00:00Z', + started_at: null, + updated_at: '2026-09-12T20:00:00Z', + finished_at: null, + duration_ms: null, + scan_id: null, + error_code: null, + error_detail: null, + attempt: 0, + deduplicated: false, +} + +let repositoriesMock: ReturnType + +beforeEach(() => { + window.history.replaceState({}, '', '/repositories') + window.localStorage.clear() + Object.defineProperty(window, 'scrollTo', { configurable: true, value: vi.fn() }) + Object.defineProperty(window, 'requestAnimationFrame', { configurable: true, value: (callback: FrameRequestCallback) => { callback(0); return 0 } }) + + repositoriesMock = vi.spyOn(api, 'repositories').mockResolvedValue([repository, secondRepository]) + vi.spyOn(api, 'meta').mockResolvedValue(testMeta) + vi.spyOn(api, 'repository').mockImplementation(async (id) => id === secondRepository.id ? testDetail(secondRepository) : testDetail(repository)) + vi.spyOn(api, 'repositoryScans').mockResolvedValue(testScans) + vi.spyOn(api, 'repositoryTrend').mockResolvedValue(testTrend) + vi.spyOn(api, 'comparison').mockResolvedValue(testComparison) + vi.spyOn(api, 'scanJob').mockResolvedValue(queuedJob) + vi.spyOn(api, 'enqueueRepositoryScan').mockResolvedValue(queuedJob) + vi.spyOn(api, 'exportReport').mockResolvedValue('report') +}) + +afterEach(() => { + cleanup() + vi.restoreAllMocks() +}) + +describe('RepoPulse workspace shell', () => { + it('searches, filters and opens a repository detail route', async () => { + render() + await screen.findByRole('heading', { name: /Repositories/ }) + + fireEvent.change(screen.getByPlaceholderText('Search name, owner or full name'), { target: { value: 'RepoPulse' } }) + expect(screen.getByRole('region', { name: 'Repository filters' }).textContent).toContain('1 matching 2 repositories') + fireEvent.change(screen.getByRole('combobox', { name: 'Filter by readiness' }), { target: { value: 'blocked' } }) + expect(screen.getByRole('link', { name: 'Open Jens/RepoPulse' })).toBeTruthy() + + fireEvent.click(screen.getByRole('link', { name: 'Open Jens/RepoPulse' })) + + expect(await screen.findByRole('heading', { name: 'Jens/RepoPulse' })).toBeTruthy() + expect(window.location.pathname).toBe('/repositories/gitea%3A64/overview') + expect(screen.getByRole('button', { name: 'Scan now' })).toBeTruthy() + }) + + it('persists pinned repositories and opens a recent quick-switch selection', async () => { + render() + await screen.findByRole('heading', { name: /Repositories/ }) + + fireEvent.click(screen.getByRole('button', { name: 'Pin Jens/RepoPulse' })) + await waitFor(() => expect(window.localStorage.getItem('repopulse:pinned-repositories')).toContain('gitea:64')) + + fireEvent.click(document.querySelector('.shortcut-button') as HTMLElement) + const switcher = await screen.findByPlaceholderText('Search repositories…') + fireEvent.change(switcher, { target: { value: 'AgentTestLab' } }) + fireEvent.keyDown(window, { key: 'Enter' }) + + expect(await screen.findByRole('heading', { name: 'Jens/AgentTestLab' })).toBeTruthy() + expect(window.location.pathname).toBe('/repositories/gitea%3A65/overview') + expect(window.localStorage.getItem('repopulse:recent-repositories')).toContain('gitea:65') + }) + + it('exposes compact scan and report actions on detail', async () => { + window.history.replaceState({}, '', '/repositories/gitea%3A64/overview') + render() + await screen.findByRole('button', { name: 'Scan now' }) + + fireEvent.click(screen.getByText('Reports', { exact: true })) + expect(screen.getByRole('button', { name: 'Export HTML' })).toBeTruthy() + expect(screen.getByRole('button', { name: 'Export JSON' })).toBeTruthy() + + fireEvent.click(screen.getByText('More', { exact: true })) + expect(screen.getByRole('button', { name: 'Force rescan' })).toBeTruthy() + expect(screen.getByRole('button', { name: 'View scan runs' })).toBeTruthy() + expect(screen.getByRole('button', { name: 'Advanced info' })).toBeTruthy() + + fireEvent.click(screen.getByRole('button', { name: 'Scan now' })) + await waitFor(() => expect(api.enqueueRepositoryScan).toHaveBeenCalledWith('gitea:64', false)) + }) + + it('shows an actionable empty detail state for an unscanned repository', async () => { + const emptyRepository = testRepository('gitea:66', 'Jens/EmptyRepo', { + state: 'never_scanned', + last_scan_id: null, + last_scan_at: null, + last_scan_health: null, + last_scan_readiness: null, + last_scan_revision: null, + }) + repositoriesMock.mockResolvedValue([emptyRepository]) + vi.mocked(api.repository).mockResolvedValue({ ...emptyRepository, latest_scan: null }) + window.history.replaceState({}, '', '/repositories/gitea%3A66/overview') + + render() + + expect(await screen.findByText('Jens/EmptyRepo has no persisted scan yet.')).toBeTruthy() + expect(screen.getByRole('button', { name: 'Scan repository' })).toBeTruthy() + }) +}) diff --git a/frontend/src/App.tsx b/frontend/src/App.tsx new file mode 100644 index 0000000..b89cb2d --- /dev/null +++ b/frontend/src/App.tsx @@ -0,0 +1,179 @@ +import { type FormEvent, useCallback, useEffect, useMemo, useRef, useState } from 'react' + +import { api, type AppMeta, type RepositorySummary, type ScanComparison, type ScanJob, type ScanReport, type ScanSummary, type TrendPoint } from './api' +import { filterRepositories, orderSwitcherRepositories, paginateRepositories, readinessLabel, repositoryReadiness, sortRepositories, stateLabel, type CatalogFilters, type CatalogSort, type CatalogSortKey, type Readiness } from './catalog' +import { ArchitectureView } from './components/ArchitectureView' +import { BrandLockup, BrandMark } from './components/Brand' +import { DashboardView } from './components/DashboardView' +import { DependenciesView } from './components/DependenciesView' +import { FindingsView } from './components/FindingsView' +import { HistoryView } from './components/HistoryView' +import { HotspotsView } from './components/HotspotsView' +import { OverviewView } from './components/OverviewView' +import { RepositoryVisual } from './components/RepositoryVisual' +import { ScanRunsView } from './components/ScanRunsView' +import { DETAIL_VIEWS, parseRoute, routePath, type DetailView, type Route } from './navigation' + +const ACTIVE_JOB_STATES: ScanJob['status'][] = ['queued', 'acquiring_source', 'scanning', 'analyzing', 'persisting'] +const PINNED_STORAGE_KEY = 'repopulse:pinned-repositories' +const RECENT_STORAGE_KEY = 'repopulse:recent-repositories' +const CATALOG_VIEW_STORAGE_KEY = 'repopulse:catalog-view' +const DEFAULT_FILTERS: CatalogFilters = { query: '', state: 'all', readiness: 'all', owner: 'all', branch: 'all', visibility: 'all', archived: 'active' } + +function readIdList(key: string) { + try { + const parsed = JSON.parse(window.localStorage.getItem(key) ?? '[]') + return Array.isArray(parsed) ? parsed.filter((value): value is string => typeof value === 'string') : [] + } catch { return [] } +} + +function readCatalogView(): 'table' | 'grid' { + try { return window.localStorage.getItem(CATALOG_VIEW_STORAGE_KEY) === 'grid' ? 'grid' : 'table' } catch { return 'table' } +} + +function writeIdList(key: string, ids: string[]) { try { window.localStorage.setItem(key, JSON.stringify(ids)) } catch { /* preferences are best effort */ } } +function shortRevision(revision: string | null) { return revision ? revision.slice(0, 10) : 'not acquired' } +function statusClass(value: string) { return value.replace(/_/g, '-') } +function formatDate(value: string | null) { if (!value) return 'Never'; const date = new Date(value); return Number.isNaN(date.getTime()) ? 'Unknown' : date.toLocaleString([], { dateStyle: 'medium', timeStyle: 'short' }) } +function formatRelativeDate(value: string | null) { if (!value) return 'Never scanned'; const difference = Date.now() - new Date(value).getTime(); if (Number.isNaN(difference)) return 'Unknown'; if (difference < 3_600_000) return `${Math.max(1, Math.floor(difference / 60_000))}m ago`; if (difference < 86_400_000) return `${Math.floor(difference / 3_600_000)}h ago`; return `${Math.floor(difference / 86_400_000)}d ago` } +function downloadText(filename: string, content: string, mime: string) { const url = URL.createObjectURL(new Blob([content], { type: mime })); const anchor = document.createElement('a'); anchor.href = url; anchor.download = filename; anchor.style.display = 'none'; document.body.appendChild(anchor); anchor.click(); window.setTimeout(() => { anchor.remove(); URL.revokeObjectURL(url) }, 0) } +function reportFilename(repositoryName: string, format: 'html' | 'json') { const safeName = repositoryName.replace(/[\u0000-\u001f\u007f<>:"/\\|?*]/g, '_').replace(/[ .]+$/g, '').slice(0, 100).replace(/[ .]+$/g, '') || 'repository'; return `repopulse-${safeName}.${format}` } +function detailViewLabel(view: DetailView, report: ScanReport | null) { if (view === 'overview') return 'Overview'; if (view === 'findings') return `Findings (${report?.findings.filter((finding) => !finding.suppressed).length ?? 0})`; if (view === 'architecture') return `Architecture (${report?.architecture.nodes.length ?? 0})`; if (view === 'hotspots') return `Hotspots (${report?.hotspots.length ?? 0})`; if (view === 'dependencies') return 'Dependencies'; if (view === 'history') return 'History'; return 'Scan runs' } + +export default function App() { + const [route, setRoute] = useState(() => parseRoute(window.location.pathname)) + const [repositories, setRepositories] = useState([]) + const [catalogLoading, setCatalogLoading] = useState(true) + const [selectedDetailsLoading, setSelectedDetailsLoading] = useState(false) + const [scanSummaries, setScanSummaries] = useState([]) + const [report, setReport] = useState(null) + const [comparison, setComparison] = useState(null) + const [trend, setTrend] = useState([]) + const [path, setPath] = useState('') + const [job, setJob] = useState(null) + const [meta, setMeta] = useState(null) + const [standaloneReport, setStandaloneReport] = useState(null) + const [pinnedIds, setPinnedIds] = useState(() => readIdList(PINNED_STORAGE_KEY)) + const [recentIds, setRecentIds] = useState(() => readIdList(RECENT_STORAGE_KEY)) + const [catalogFilters, setCatalogFilters] = useState(DEFAULT_FILTERS) + const [catalogSort, setCatalogSort] = useState({ key: 'name', direction: 'asc' }) + const [catalogPage, setCatalogPage] = useState(1) + const [catalogPageSize, setCatalogPageSize] = useState(24) + const [catalogView, setCatalogView] = useState<'table' | 'grid'>(readCatalogView) + const [busy, setBusy] = useState(false) + const [catalogBusy, setCatalogBusy] = useState(false) + const [error, setError] = useState(null) + const [notice, setNotice] = useState(null) + const [switcherOpen, setSwitcherOpen] = useState(false) + const [switcherQuery, setSwitcherQuery] = useState('') + const [switcherIndex, setSwitcherIndex] = useState(0) + const [advancedOpen, setAdvancedOpen] = useState(false) + const switcherInputRef = useRef(null) + + const selectedId = route.repositoryId ?? null + const selectedRepository = useMemo(() => repositories.find((repository) => repository.id === selectedId) ?? null, [repositories, selectedId]) + const activeJob = job && job.repository_id === selectedId && ACTIVE_JOB_STATES.includes(job.status) ? job : null + const navigate = useCallback((next: Route, replace = false) => { const href = routePath(next); if (window.location.pathname !== href) window.history[replace ? 'replaceState' : 'pushState']({}, '', href); setRoute(next); setAdvancedOpen(false); window.scrollTo?.({ top: 0, behavior: 'auto' }) }, []) + const handleNavigation = useCallback((event: React.MouseEvent, next: Route) => { if (event.button !== 0 || event.metaKey || event.ctrlKey || event.shiftKey || event.altKey) return; event.preventDefault(); navigate(next) }, [navigate]) + const refreshCatalog = useCallback(async () => { const next = await api.repositories(); setRepositories(next); return next }, []) + const refreshMeta = useCallback(async () => { try { setMeta(await api.meta()) } catch { /* catalog navigation must remain usable */ } }, []) + + useEffect(() => { + const onPopState = () => setRoute(parseRoute(window.location.pathname)) + window.addEventListener('popstate', onPopState) + void (async () => { setCatalogLoading(true); try { await refreshCatalog() } catch { try { const legacy = await api.recent(); setStandaloneReport(legacy[0] ?? null); setPath(legacy[0]?.repository_path ?? ''); setError(legacy.length ? 'Repository catalog is unavailable; showing the last local report in Settings.' : 'Could not load the repository catalog.') } catch (err) { setError(err instanceof Error ? err.message : 'Could not load the repository catalog.') } } finally { setCatalogLoading(false) } })() + void refreshMeta() + return () => window.removeEventListener('popstate', onPopState) + }, [refreshCatalog, refreshMeta]) + + useEffect(() => { document.title = route.page === 'dashboard' ? 'RepoPulse — Portfolio intelligence' : 'RepoPulse — Repository intelligence' }, [route.page]) + useEffect(() => { + if (!selectedId) { setReport(null); setScanSummaries([]); setTrend([]); setComparison(null); setSelectedDetailsLoading(false); return } + let live = true + setSelectedDetailsLoading(true); setReport(null); setComparison(null); setTrend([]) + void Promise.all([api.repository(selectedId), api.repositoryScans(selectedId), api.repositoryTrend(selectedId)]).then(([detail, summaries, nextTrend]) => { if (!live) return; setScanSummaries(summaries); setTrend(nextTrend); setReport(detail.latest_scan); setError(null); if (detail.latest_scan?.repository_path) setPath(detail.latest_scan.repository_path) }).catch((err) => { if (live) setError(err instanceof Error ? err.message : 'Could not load repository details.') }).finally(() => { if (live) setSelectedDetailsLoading(false) }) + return () => { live = false } + }, [selectedId]) + useEffect(() => { if (!report) { setComparison(null); return }; let live = true; void api.comparison(report.id).then((next) => { if (live) setComparison(next) }).catch(() => { if (live) setComparison(null) }); return () => { live = false } }, [report]) + useEffect(() => { if (!selectedRepository?.active_job_id || job?.id === selectedRepository.active_job_id) return; let live = true; void api.scanJob(selectedRepository.active_job_id).then((next) => { if (live) setJob(next) }).catch(() => undefined); return () => { live = false } }, [job?.id, selectedRepository]) + useEffect(() => { + const jobId = activeJob?.id + if (!jobId || !selectedId) return + let live = true + let failures = 0 + let timer: number | undefined + const poll = async () => { + try { + const next = await api.scanJob(jobId) + if (!live) return + failures = 0 + if (next.status === 'completed' && next.scan_id) { + const nextReport = await api.repositoryScan(next.repository_id, next.scan_id) + if (!live) return + const [summaries, nextTrend] = await Promise.all([api.repositoryScans(next.repository_id), api.repositoryTrend(next.repository_id)]) + if (!live) return + await refreshCatalog() + if (!live) return + setJob(next) + setReport(nextReport) + setScanSummaries(summaries) + setTrend(nextTrend) + setNotice(next.deduplicated ? 'The selected revision was already analyzed; showing the existing report.' : 'Repository analysis completed.') + return + } + setJob(next) + if (next.status === 'failed') { setError(next.error_detail || 'Repository analysis failed.'); return } + } catch (err) { + failures += 1 + if (!live) return + if (failures >= 5) { setError(err instanceof Error ? `${err.message} Progress polling paused after five failed attempts.` : 'Progress polling paused after five failed attempts.'); return } + } + if (live) timer = window.setTimeout(() => void poll(), 1500) + } + void poll() + return () => { live = false; if (timer) window.clearTimeout(timer) } + }, [activeJob?.id, refreshCatalog, selectedId]) + useEffect(() => { if (selectedId) setRecentIds((current) => [selectedId, ...current.filter((id) => id !== selectedId)].slice(0, 8)) }, [selectedId]) + useEffect(() => writeIdList(PINNED_STORAGE_KEY, pinnedIds), [pinnedIds]) + useEffect(() => writeIdList(RECENT_STORAGE_KEY, recentIds), [recentIds]) + useEffect(() => { try { window.localStorage.setItem(CATALOG_VIEW_STORAGE_KEY, catalogView) } catch { /* preference only */ } }, [catalogView]) + + const filteredRepositories = useMemo(() => filterRepositories(repositories, catalogFilters), [catalogFilters, repositories]) + const sortedRepositories = useMemo(() => sortRepositories(filteredRepositories, catalogSort), [catalogSort, filteredRepositories]) + const catalogWindow = useMemo(() => paginateRepositories(sortedRepositories, catalogPage, catalogPageSize), [catalogPage, catalogPageSize, sortedRepositories]) + const ownerOptions = useMemo(() => [...new Set(repositories.map((repository) => repository.owner))].sort(), [repositories]) + const branchOptions = useMemo(() => [...new Set(repositories.map((repository) => repository.default_branch))].sort(), [repositories]) + const switcherRepositories = useMemo(() => orderSwitcherRepositories(repositories, pinnedIds, recentIds, switcherQuery), [pinnedIds, recentIds, repositories, switcherQuery]) + const currentView = route.view ?? 'overview' + useEffect(() => { if (catalogPage !== catalogWindow.page) setCatalogPage(catalogWindow.page) }, [catalogPage, catalogWindow.page]) + useEffect(() => { if (switcherOpen) { setSwitcherIndex(0); window.requestAnimationFrame(() => switcherInputRef.current?.focus()) } }, [switcherOpen]) + useEffect(() => { const onKeyDown = (event: KeyboardEvent) => { if ((event.metaKey || event.ctrlKey) && event.key.toLowerCase() === 'k') { event.preventDefault(); setSwitcherOpen(true); return }; if (!switcherOpen) return; if (event.key === 'Escape') { event.preventDefault(); setSwitcherOpen(false) } else if (event.key === 'ArrowDown') { event.preventDefault(); setSwitcherIndex((index) => Math.min(index + 1, Math.max(0, switcherRepositories.length - 1))) } else if (event.key === 'ArrowUp') { event.preventDefault(); setSwitcherIndex((index) => Math.max(0, index - 1)) } else if (event.key === 'Enter' && switcherRepositories[switcherIndex]) { event.preventDefault(); selectRepository(switcherRepositories[switcherIndex]); setSwitcherOpen(false) } }; window.addEventListener('keydown', onKeyDown); return () => window.removeEventListener('keydown', onKeyDown) }, [switcherIndex, switcherOpen, switcherRepositories]) + + const selectRepository = (repository: RepositorySummary) => { setError(null); setNotice(null); navigate({ page: 'repositories', repositoryId: repository.id, view: 'overview' }) } + const togglePinned = (repositoryId: string) => setPinnedIds((current) => current.includes(repositoryId) ? current.filter((id) => id !== repositoryId) : [repositoryId, ...current]) + const exploreReadiness = (readiness: Readiness) => { setCatalogFilters({ ...DEFAULT_FILTERS, readiness }); setCatalogPage(1); navigate({ page: 'repositories' }) } + const updateCatalogFilter = (key: K, value: CatalogFilters[K]) => { setCatalogFilters((current) => ({ ...current, [key]: value })); setCatalogPage(1) } + const setCatalogSortKey = (key: CatalogSortKey) => { setCatalogSort((current) => current.key === key ? { key, direction: current.direction === 'asc' ? 'desc' : 'asc' } : { key, direction: key === 'name' || key === 'state' ? 'asc' : 'desc' }); setCatalogPage(1) } + const analyzeRepository = async (repository: RepositorySummary, force = false) => { try { setBusy(true); setError(null); setNotice(null); const next = await api.enqueueRepositoryScan(repository.id, force); setJob(next); setNotice(next.deduplicated ? 'This revision is already in the analysis history.' : 'Analysis queued. Progress will update here.'); if (next.status === 'completed' && next.scan_id) setReport(await api.repositoryScan(repository.id, next.scan_id)) } catch (err) { setError(err instanceof Error ? err.message : 'Could not queue repository analysis.') } finally { setBusy(false) } } + const syncCatalog = async () => { try { setCatalogBusy(true); setError(null); const result = await api.syncRepositories(); await Promise.all([refreshCatalog(), refreshMeta()]); setNotice(result.partial ? `Gitea catalog partially synchronized: ${result.discovered} resolved, ${result.branch_failures ?? 0} branch lookup failure(s). Existing repository evidence was preserved.` : `Gitea catalog synchronized: ${result.discovered} repositories discovered.`) } catch (err) { setError(err instanceof Error ? err.message : 'Gitea catalog synchronization failed.') } finally { setCatalogBusy(false) } } + const scanLocal = async (event: FormEvent) => { event.preventDefault(); try { setBusy(true); setError(null); setNotice(null); const next = await api.scan(path); setStandaloneReport(next); setPath(next.repository_path); await refreshCatalog(); setNotice(`Local analysis completed in ${next.duration_ms} ms. The result is available in Settings.`); navigate({ page: 'settings' }) } catch (err) { setError(err instanceof Error ? err.message : 'Local repository analysis failed.') } finally { setBusy(false) } } + const selectScan = async (summary: ScanSummary) => { try { setBusy(true); setError(null); setReport(await api.repositoryScan(summary.repository_id, summary.id)); navigate({ page: 'repositories', repositoryId: summary.repository_id, view: 'overview' }) } catch (err) { setError(err instanceof Error ? err.message : 'Could not load the selected scan.') } finally { setBusy(false) } } + const exportReport = async (format: 'html' | 'json') => { if (!report) return; try { downloadText(reportFilename(report.repository_name, format), await api.exportReport(report.id, format), format === 'html' ? 'text/html' : 'application/json') } catch (err) { setError(err instanceof Error ? err.message : 'Report export failed.') } } + + const renderGlobalNav = () => + const renderTopbar = () =>
handleNavigation(event, { page: 'dashboard' })} aria-label="RepoPulse dashboard">{renderGlobalNav()}
+ + const renderCatalogPage = () =>
Repository explorer

Repositories {repositories.length}

High-density catalog controls when you need breadth; switch to visual identity tiles when you need pattern recognition.

updateCatalogFilter('query', event.target.value)} placeholder="Search name, owner or full name" />⌘K
{filteredRepositories.length} matching {repositories.length} repositories
{catalogLoading ?
: catalogWindow.items.length ? <>{catalogView === 'table' ?
{catalogWindow.items.map((repository) => { const readiness = repositoryReadiness(repository); const pinned = pinnedIds.includes(repository.id); return selectRepository(repository)} onKeyDown={(event) => { if (event.key === 'Enter' || event.key === ' ') { event.preventDefault(); selectRepository(repository) } }}> })}
ReadinessBranch
{repository.full_name}{repository.private ? 'Private' : 'Public'} · {repository.provider} · {repository.archived ? 'Archived' : 'Active'}
{repository.default_branch}{formatRelativeDate(repository.last_scan_at)}{formatDate(repository.last_scan_at)}{repository.last_scan_health ?? '—'}
:
{catalogWindow.items.map((repository) => { const pinned = pinnedIds.includes(repository.id); const readiness = repositoryReadiness(repository); return