from __future__ import annotations
import json
from typing import Any
from ..config import Settings
from ..docs_repository import DocsRepository
from ..freshness import build_freshness_report
from ..inventory import InventoryRepository
from ..relationships import build_relationships
from ..validation import validate_repository
from .db import Database
from .db_repositories import PostgresDocsRepository, PostgresInventoryRepository
from .freshness import build_freshness_report_db
from .importer import normalize_scalars
from .validation import validate_database
DEFAULT_QUERIES = ("gnexus", "host", "GitBucket")
def _canonical(value: Any) -> str:
return json.dumps(normalize_scalars(value), sort_keys=True, ensure_ascii=False, default=str)
def _preview(value: Any, limit: int = 400) -> Any:
text = _canonical(value)
if len(text) <= limit:
return value
return text[:limit] + "..."
def _difference(kind: str, key: str, file_value: Any, db_value: Any) -> dict[str, Any]:
return {
"kind": kind,
"key": key,
"file": _preview(file_value),
"db": _preview(db_value),
}
def _normalized_report(report: dict[str, Any]) -> dict[str, Any]:
return {
"status": report.get("status"),
"issue_count": report.get("issue_count"),
"document_count": report.get("document_count"),
"issues": sorted(
(
issue.get("path"),
issue.get("severity"),
issue.get("code"),
issue.get("message"),
)
for issue in report.get("issues", [])
),
}
def compare_repositories(
settings: Settings,
database: Database,
queries: list[str] | None = None,
) -> dict[str, Any]:
file_settings = Settings(repo_root=settings.repo_root, storage_backend="file")
file_docs = DocsRepository(file_settings)
db_docs = PostgresDocsRepository(database)
file_inventory = InventoryRepository(file_settings)
db_inventory = PostgresInventoryRepository(database)
differences: list[dict[str, Any]] = []
file_doc_list = file_docs.list_docs()
db_doc_list = db_docs.list_docs()
if _canonical(file_doc_list) != _canonical(db_doc_list):
differences.append(
_difference("docs.list", "all", file_doc_list, db_doc_list)
)
file_paths = [str(doc["path"]) for doc in file_doc_list]
db_paths = [str(doc["path"]) for doc in db_doc_list]
if file_paths != db_paths:
differences.append(
_difference("docs.paths", "all", file_paths, db_paths)
)
for path in sorted(set(file_paths) & set(db_paths)):
file_doc = file_docs.read_doc(path)
db_doc = db_docs.read_doc(path)
for field in ("path", "frontmatter", "body", "raw"):
if _canonical(file_doc.get(field)) != _canonical(db_doc.get(field)):
differences.append(
_difference(f"docs.read.{field}", path, file_doc.get(field), db_doc.get(field))
)
for query in queries or list(DEFAULT_QUERIES):
file_results = file_docs.search(query)
db_results = db_docs.search(query)
if _canonical(file_results) != _canonical(db_results):
differences.append(
_difference("docs.search", query, file_results, db_results)
)
file_types = file_inventory.list_types()
db_types = db_inventory.list_types()
if file_types != db_types:
differences.append(
_difference("inventory.types", "all", file_types, db_types)
)
for type_name in sorted(set(file_types) & set(db_types)):
file_parsed = normalize_scalars(file_inventory.read_parsed(type_name))
db_parsed = normalize_scalars(db_inventory.read_parsed(type_name))
if _canonical(file_parsed) != _canonical(db_parsed):
differences.append(
_difference("inventory.parsed", type_name, file_parsed, db_parsed)
)
for item in file_parsed if isinstance(file_parsed, list) else []:
if not isinstance(item, dict):
continue
item_id = item.get("id")
if not isinstance(item_id, str) or not item_id:
continue
file_item = file_inventory.read_item(type_name, item_id)
db_item = db_inventory.read_item(type_name, item_id)
if _canonical(file_item) != _canonical(db_item):
differences.append(
_difference(
"inventory.item",
f"{type_name}/{item_id}",
file_item,
db_item,
)
)
file_validation = _normalized_report(validate_repository(file_settings))
db_validation = _normalized_report(validate_database(database))
if _canonical(file_validation) != _canonical(db_validation):
differences.append(
_difference("validation", "all", file_validation, db_validation)
)
file_freshness = _normalized_report(build_freshness_report(file_settings))
db_freshness = _normalized_report(build_freshness_report_db(database))
if _canonical(file_freshness) != _canonical(db_freshness):
differences.append(
_difference("freshness", "all", file_freshness, db_freshness)
)
file_relationships = build_relationships(file_inventory)
db_relationships = build_relationships(db_inventory)
if _canonical(file_relationships) != _canonical(db_relationships):
differences.append(
_difference(
"relationships", "all", file_relationships, db_relationships
)
)
return {
"ok": not differences,
"queries": list(queries or DEFAULT_QUERIES),
"difference_count": len(differences),
"validation": {
"file": file_validation["status"],
"database": db_validation["status"],
},
"freshness": {
"file": file_freshness["status"],
"database": db_freshness["status"],
},
"differences": differences,
}