Markitect schema-validation integration use case and fixture for Markdown proxy documents

src/kontextual_engine/adapters/memory/asset_registry.py

@@ -18,6 +18,8 @@ from kontextual_engine.core import (
     KnowledgeAsset,
     LifecycleState,
     MetadataRecord,
+    MetadataSchema,
+    MetadataSchemaAssignment,
     RepresentationKind,
 )
 from kontextual_engine.errors import NotFoundError, ValidationError
@@ -29,6 +31,8 @@ class InMemoryAssetRegistryRepository:
     assets: dict[str, KnowledgeAsset] = field(default_factory=dict)
     representations: dict[str, AssetRepresentation] = field(default_factory=dict)
     metadata_records: dict[str, list[MetadataRecord]] = field(default_factory=dict)
+    metadata_schemas: dict[str, MetadataSchema] = field(default_factory=dict)
+    metadata_schema_assignments: dict[str, MetadataSchemaAssignment] = field(default_factory=dict)
     context_entities: dict[str, ContextEntity] = field(default_factory=dict)
     relationships: dict[str, CoreRelationship] = field(default_factory=dict)
     versions: dict[str, list[AssetVersion]] = field(default_factory=dict)
@@ -105,6 +109,42 @@ class InMemoryAssetRegistryRepository:
         self.get_asset(asset_id)
         return list(self.metadata_records.get(asset_id, []))
 
+    def save_metadata_schema(self, schema: MetadataSchema) -> MetadataSchema:
+        self.metadata_schemas[schema.schema_id] = schema
+        return schema
+
+    def get_metadata_schema(self, schema_id: str) -> MetadataSchema:
+        try:
+            return self.metadata_schemas[schema_id]
+        except KeyError as exc:
+            raise NotFoundError("Metadata schema not found", details={"schema_id": schema_id}) from exc
+
+    def list_metadata_schemas(self) -> list[MetadataSchema]:
+        return sorted(self.metadata_schemas.values(), key=lambda schema: (schema.name, schema.schema_id))
+
+    def save_metadata_schema_assignment(
+        self,
+        assignment: MetadataSchemaAssignment,
+    ) -> MetadataSchemaAssignment:
+        self.get_metadata_schema(assignment.schema_id)
+        self.metadata_schema_assignments[assignment.assignment_id] = assignment
+        return assignment
+
+    def get_metadata_schema_assignment(self, assignment_id: str) -> MetadataSchemaAssignment:
+        try:
+            return self.metadata_schema_assignments[assignment_id]
+        except KeyError as exc:
+            raise NotFoundError(
+                "Metadata schema assignment not found",
+                details={"assignment_id": assignment_id},
+            ) from exc
+
+    def list_metadata_schema_assignments(self) -> list[MetadataSchemaAssignment]:
+        return sorted(
+            self.metadata_schema_assignments.values(),
+            key=lambda assignment: (assignment.priority, assignment.schema_id, assignment.assignment_id),
+        )
+
     def save_context_entity(self, entity: ContextEntity) -> ContextEntity:
         self.context_entities[entity.entity_id] = entity
         return entity

src/kontextual_engine/adapters/sqlite/asset_registry.py

@@ -20,6 +20,8 @@ from kontextual_engine.core import (
     KnowledgeAsset,
     LifecycleState,
     MetadataRecord,
+    MetadataSchema,
+    MetadataSchemaAssignment,
     RepresentationKind,
     RelationshipTargetKind,
 )
@@ -189,6 +191,74 @@ class SQLiteAssetRegistryRepository:
             self.get_asset(asset_id)
         return [MetadataRecord.from_dict(_loads(row["payload"])) for row in rows]
 
+    def save_metadata_schema(self, schema: MetadataSchema) -> MetadataSchema:
+        with self._connect() as conn:
+            conn.execute(
+                """
+                insert into metadata_schemas (id, name, version, payload)
+                values (?, ?, ?, ?)
+                on conflict(id) do update set
+                  name=excluded.name,
+                  version=excluded.version,
+                  payload=excluded.payload
+                """,
+                (schema.schema_id, schema.name, schema.version, _json(schema.to_dict())),
+            )
+        return schema
+
+    def get_metadata_schema(self, schema_id: str) -> MetadataSchema:
+        row = self._one("select payload from metadata_schemas where id = ?", (schema_id,))
+        if row is None:
+            raise NotFoundError("Metadata schema not found", details={"schema_id": schema_id})
+        return MetadataSchema.from_dict(_loads(row["payload"]))
+
+    def list_metadata_schemas(self) -> list[MetadataSchema]:
+        rows = self._all("select payload from metadata_schemas order by name, id", ())
+        return [MetadataSchema.from_dict(_loads(row["payload"])) for row in rows]
+
+    def save_metadata_schema_assignment(
+        self,
+        assignment: MetadataSchemaAssignment,
+    ) -> MetadataSchemaAssignment:
+        self.get_metadata_schema(assignment.schema_id)
+        with self._connect() as conn:
+            conn.execute(
+                """
+                insert into metadata_schema_assignments (id, schema_id, priority, payload)
+                values (?, ?, ?, ?)
+                on conflict(id) do update set
+                  schema_id=excluded.schema_id,
+                  priority=excluded.priority,
+                  payload=excluded.payload
+                """,
+                (
+                    assignment.assignment_id,
+                    assignment.schema_id,
+                    assignment.priority,
+                    _json(assignment.to_dict()),
+                ),
+            )
+        return assignment
+
+    def get_metadata_schema_assignment(self, assignment_id: str) -> MetadataSchemaAssignment:
+        row = self._one(
+            "select payload from metadata_schema_assignments where id = ?",
+            (assignment_id,),
+        )
+        if row is None:
+            raise NotFoundError(
+                "Metadata schema assignment not found",
+                details={"assignment_id": assignment_id},
+            )
+        return MetadataSchemaAssignment.from_dict(_loads(row["payload"]))
+
+    def list_metadata_schema_assignments(self) -> list[MetadataSchemaAssignment]:
+        rows = self._all(
+            "select payload from metadata_schema_assignments order by priority, schema_id, id",
+            (),
+        )
+        return [MetadataSchemaAssignment.from_dict(_loads(row["payload"])) for row in rows]
+
     def save_context_entity(self, entity: ContextEntity) -> ContextEntity:
         with self._connect() as conn:
             conn.execute(
@@ -457,6 +527,18 @@ class SQLiteAssetRegistryRepository:
                   key text not null,
                   payload text not null
                 );
+                create table if not exists metadata_schemas (
+                  id text primary key,
+                  name text not null,
+                  version text not null,
+                  payload text not null
+                );
+                create table if not exists metadata_schema_assignments (
+                  id text primary key,
+                  schema_id text not null references metadata_schemas(id) on delete cascade,
+                  priority integer not null,
+                  payload text not null
+                );
                 create table if not exists context_entities (
                   id text primary key,
                   entity_type text not null,
@@ -508,6 +590,7 @@ class SQLiteAssetRegistryRepository:
                 create index if not exists idx_assets_lifecycle on assets(lifecycle);
                 create index if not exists idx_representations_asset on representations(asset_id);
                 create index if not exists idx_metadata_asset on metadata_records(asset_id);
+                create index if not exists idx_schema_assignments_schema on metadata_schema_assignments(schema_id);
                 create index if not exists idx_entities_type on context_entities(entity_type);
                 create index if not exists idx_relationships_source on core_relationships(source_id);
                 create index if not exists idx_relationships_target on core_relationships(target_id);