Graph-Native Infrastructure for Context and Accountable AI Systems
Python agent-memoryaiai-governanceai-infrastructureartificial-intelligencecontext-engineeringcontext-graphsdata-engineeringdecision-intelligencedeveloper-toolsexplainable-aigenerative-aigraph-ragknowledge-graphllmontologyprovenancepythonreasoningsemantic-search
fix(explorer): load registered schemas in Ontology Editor (#1278)
Wei Taodd1e65404707
diff --git a/explorer/package.json b/explorer/package.jsonindex 98a53773..d37815a9 100644--- a/explorer/package.json+++ b/explorer/package.json@@ -9,7 +9,7 @@"lint": "eslint .","preview": "vite preview","test:graph-store": "node --test tests/graphStore.multi-edge.test.mjs",- "test:graph-workspace": "node --import tsx --test tests/markdownContentViewer.test.ts tests/graphSceneState.display.test.ts tests/temporalLifecycle.test.ts tests/deterministicExplorerRendering.test.ts tests/smallGraphLayout.test.ts tests/realtimeGraphAttributes.test.ts",+ "test:graph-workspace": "node --import tsx --test tests/markdownContentViewer.test.ts tests/graphSceneState.display.test.ts tests/temporalLifecycle.test.ts tests/deterministicExplorerRendering.test.ts tests/smallGraphLayout.test.ts tests/realtimeGraphAttributes.test.ts tests/ontologyEditorModel.test.ts","test:deterministic-e2e": "node --import tsx --test tests/deterministicExplorerRendering.e2e.ts","test:plugin-registry": "node --import tsx --test tests/pluginRegistry.temporal.test.mjs"},diff --git a/explorer/src/App.tsx b/explorer/src/App.tsxindex 8f94d477..75a95c2d 100644--- a/explorer/src/App.tsx+++ b/explorer/src/App.tsx@@ -93,6 +93,18 @@ const navItems: NavItem[] = [{ id: 'ontology-hub', label: 'Ontology Hub', hint: 'Schema governance, registry, and vocabulary management', icon: GitMerge },];+function readInitialWorkspace(): WorkspaceId {+ try {+ const params = new URLSearchParams(window.location.search);+ if (params.has("ontologyTab") || params.has("ontologyEntity")) {+ return "ontology-hub";+ }+ } catch {+ // Default to the welcome screen when URL state is unavailable.+ }+ return "welcome";+}+const shellStyles = `:root {--app-bg: #07111f;@@ -1773,7 +1785,7 @@ function WelcomeScreen({}export default function App() {- const [activeWorkspace, setActiveWorkspace] = useState<WorkspaceId>('welcome');+ const [activeWorkspace, setActiveWorkspace] = useState<WorkspaceId>(readInitialWorkspace);const [exploreView, setExploreView] = useState<ExploreView>('graph');const [analyzeView, setAnalyzeView] = useState<AnalyzeView>('reasoning');const [enrichView, setEnrichView] = useState<EnrichView>('import');diff --git a/explorer/src/workspaces/OntologyWorkspace/OntologyEditor.tsx b/explorer/src/workspaces/OntologyWorkspace/OntologyEditor.tsxindex c84f814b..c4965748 100644--- a/explorer/src/workspaces/OntologyWorkspace/OntologyEditor.tsx+++ b/explorer/src/workspaces/OntologyWorkspace/OntologyEditor.tsx@@ -8,8 +8,10 @@ import {useNodesState,useEdgesState,MarkerType,+ Handle,+ Position,} from "@xyflow/react";-import type { Connection, Edge, Node } from "@xyflow/react";+import type { Connection, Edge, Node, ReactFlowInstance } from "@xyflow/react";import "@xyflow/react/dist/style.css";import {Plus,@@ -22,10 +24,20 @@ import {Pencil,Trash2,} from "lucide-react";+import { loadOntologyEntityOwner, loadOntologyGraph } from "./api";+import type { OntologyGraphEdge, OntologyGraphNode } from "./api";+import {+ classifyNodeType,+ inferOntologyUri,+ isEditableEntityType,+ ONTOLOGY_MINIMAP_THEME,+} from "./ontologyEditorModel";+import type { EditorEntityType, RegistryEntry } from "./ontologyEditorModel";type OntologyNodeData = {label?: string;type?: string;+ entityType?: EditorEntityType;};type OntologyNode = Node<OntologyNodeData>;@@ -34,12 +46,57 @@ type OntologyEdge = Edge<Record<string, unknown>>;const nodeTypes = {classNode: ({ data }: { data: OntologyNodeData }) => (<div style={classNodeStyle}>+ <Handle type="target" position={Position.Left} style={handleStyle} /><div style={classNodeHeader}>{data.label}</div><div style={classNodeSub}>{data.type}</div>+ <Handle type="source" position={Position.Right} style={handleStyle} /></div>),};+const handleStyle: React.CSSProperties = {+ width: 8,+ height: 8,+ border: "1px solid rgba(235, 243, 255, 0.8)",+ background: "#4aa3ff",+};++const ontologyFlowThemeCss = `+ .ontology-editor-flow .react-flow__controls {+ overflow: hidden;+ border: 1px solid rgba(127, 208, 255, 0.2);+ border-radius: 9px;+ background: rgba(6, 13, 26, 0.96);+ box-shadow: 0 8px 24px rgba(0, 0, 0, 0.38);+ }++ .ontology-editor-flow .react-flow__controls-button {+ width: 30px;+ height: 30px;+ background: transparent;+ border-bottom-color: rgba(127, 208, 255, 0.14);+ color: #8fa8c6;+ transition: color 140ms ease, background 140ms ease;+ }++ .ontology-editor-flow .react-flow__controls-button:hover {+ background: rgba(74, 163, 255, 0.14);+ color: #ebf3ff;+ }++ .ontology-editor-flow .react-flow__controls-button:focus-visible {+ position: relative;+ z-index: 1;+ outline: 2px solid #7fd0ff;+ outline-offset: -2px;+ }++ .ontology-editor-flow .react-flow__controls-button:disabled {+ background: rgba(3, 9, 18, 0.32);+ color: #40566f;+ }+`;+const classNodeStyle: React.CSSProperties = {padding: "12px 16px",borderRadius: "8px",@@ -79,17 +136,95 @@ interface DraftDiff {annotation_changes: Record<string, Record<string, any>>;}-interface RegistryEntry {- uri: string;- name: string;+function requestedEntityUri(): string {+ try {+ return new URLSearchParams(window.location.search).get("ontologyEntity") || "";+ } catch {+ return "";+ }+}++function nodeLabel(node: OntologyGraphNode): string {+ const explicit = String(node.content || node.properties?.["rdfs:label"] || "").trim();+ if (explicit && explicit !== node.id) {+ return explicit;+ }+ const trimmed = node.id.replace(/[/#]+$/, "");+ return trimmed.split("#").pop() || trimmed.split("/").pop() || node.id;+}++function classifyEditorNode(node: OntologyGraphNode): OntologyNodeData["entityType"] {+ return classifyNodeType(node.type);+}++function layoutEditorNodes(inputNodes: OntologyNode[]): OntologyNode[] {+ const properties = inputNodes.filter((node) => node.data.entityType === "property");+ const targets = inputNodes.filter((node) => (+ node.data.entityType === "class" || node.data.entityType === "external"+ ));+ const context = inputNodes.filter((node) => (+ node.data.entityType !== "property"+ && node.data.entityType !== "class"+ && node.data.entityType !== "external"+ ));+ const height = Math.max(360, Math.max(properties.length, targets.length) * 180);+ const positions = new Map<string, { x: number; y: number }>();++ properties.forEach((node, index) => {+ positions.set(node.id, { x: 0, y: ((index + 1) * height) / (properties.length + 1) });+ });+ targets.forEach((node, index) => {+ positions.set(node.id, { x: 600, y: ((index + 1) * height) / (targets.length + 1) });+ });+ context.forEach((node, index) => {+ positions.set(node.id, { x: 300 + index * 220, y: height + 120 });+ });++ return inputNodes.map((node) => ({+ ...node,+ position: positions.get(node.id) || node.position,+ }));+}++function buildEditorElements(apiNodes: OntologyGraphNode[], apiEdges: OntologyGraphEdge[]) {+ const sortedNodes = [...apiNodes].sort((left, right) => {+ const typeDelta = left.type.localeCompare(right.type);+ return typeDelta || left.id.localeCompare(right.id);+ });+ const nodes = layoutEditorNodes(sortedNodes.map((node) => ({+ id: node.id,+ type: "classNode",+ position: { x: 0, y: 0 },+ data: {+ label: nodeLabel(node),+ type: node.type,+ entityType: classifyEditorNode(node),+ },+ })));+ const edges: OntologyEdge[] = apiEdges.map((edge, index) => ({+ id: edge.id || `${edge.source}:${edge.type}:${edge.target}:${index}`,+ source: edge.source,+ target: edge.target,+ label: edge.type,+ type: "default",+ markerEnd: { type: MarkerType.ArrowClosed },+ style: { stroke: "rgba(127, 208, 255, 0.72)", strokeWidth: 1.5 },+ labelStyle: { fill: "#c8dcf5", fontSize: 11, fontWeight: 600 },+ labelBgStyle: { fill: "#07111f", fillOpacity: 0.9 },+ }));+ return { nodes, edges };}export function OntologyEditor() {const [nodes, setNodes, onNodesChange] = useNodesState<OntologyNode>([]);const [edges, setEdges, onEdgesChange] = useEdgesState<OntologyEdge>([]);const [selectedElement, setSelectedElement] = useState<OntologyNode | OntologyEdge | null>(null);+ const hasDetailPanel = selectedElement !== null;const [registry, setRegistry] = useState<RegistryEntry[]>([]);const [ontologyUri, setOntologyUri] = useState<string>("");+ const [flowInstance, setFlowInstance] = useState<ReactFlowInstance<OntologyNode, OntologyEdge> | null>(null);+ const [isLoadingGraph, setIsLoadingGraph] = useState(false);+ const [graphError, setGraphError] = useState("");const [draftDiff, setDraftDiff] = useState<DraftDiff>({added_classes: [],removed_classes: [],@@ -108,12 +243,18 @@ export function OntologyEditor() {useEffect(() => {let cancelled = false;- fetch("/api/ontology/registry")- .then((response) => (response.ok ? response.json() : []))- .then((entries: RegistryEntry[]) => {+ const requested = requestedEntityUri();+ Promise.all([+ fetch("/api/ontology/registry").then((response) => (response.ok ? response.json() : [])),+ requested+ ? loadOntologyEntityOwner(requested).catch(() => undefined)+ : Promise.resolve(undefined),+ ])+ .then(([entries, explicitOwner]: [RegistryEntry[], string | undefined]) => {if (cancelled) return;setRegistry(entries);- setOntologyUri((current) => current || entries[0]?.uri || "");+ const inferredOntology = inferOntologyUri(entries, requested, explicitOwner);+ setOntologyUri((current) => current || inferredOntology || entries[0]?.uri || "");}).catch((error) => {console.error("Failed to load ontology registry:", error);@@ -123,6 +264,47 @@ export function OntologyEditor() {};}, []);+ useEffect(() => {+ if (!ontologyUri) {+ setNodes([]);+ setEdges([]);+ setSelectedElement(null);+ return;+ }++ const controller = new AbortController();+ setIsLoadingGraph(true);+ setGraphError("");+ loadOntologyGraph(ontologyUri, controller.signal)+ .then((payload) => {+ const elements = buildEditorElements(payload.nodes, payload.edges);+ setNodes(elements.nodes);+ setEdges(elements.edges);+ const requested = requestedEntityUri();+ setSelectedElement(elements.nodes.find((node) => node.id === requested) || null);+ })+ .catch((error) => {+ if (controller.signal.aborted) return;+ setNodes([]);+ setEdges([]);+ setSelectedElement(null);+ setGraphError(error instanceof Error ? error.message : "Failed to load ontology graph");+ })+ .finally(() => {+ if (!controller.signal.aborted) setIsLoadingGraph(false);+ });++ return () => controller.abort();+ }, [ontologyUri, setEdges, setNodes]);++ useEffect(() => {+ if (!flowInstance || nodes.length === 0) return;+ const frame = window.requestAnimationFrame(() => {+ void flowInstance.fitView({ padding: 0.22, duration: 320, maxZoom: 1.25 });+ });+ return () => window.cancelAnimationFrame(frame);+ }, [flowInstance, hasDetailPanel, nodes.length, ontologyUri]);+const onConnect = useCallback((params: Connection) => setEdges((eds) => addEdge({ ...params, markerEnd: { type: MarkerType.ArrowClosed } }, eds)),[setEdges]@@ -134,7 +316,7 @@ export function OntologyEditor() {id: newId,type: "classNode",position: { x: Math.random() * 400, y: Math.random() * 300 },- data: { label: "NewClass", type: "owl:Class" },+ data: { label: "NewClass", type: "owl:Class", entityType: "class" },};setNodes((nds) => [...nds, newNode]);setDraftDiff((prev) => ({@@ -170,7 +352,7 @@ export function OntologyEditor() {id: newId,type: "classNode",position: { x: Math.random() * 400, y: Math.random() * 300 },- data: { label: "NewIndividual", type: "owl:NamedIndividual" },+ data: { label: "NewIndividual", type: "owl:NamedIndividual", entityType: "external" },};setNodes((nds) => [...nds, newNode]);}, [setNodes]);@@ -190,13 +372,21 @@ export function OntologyEditor() {}, []);const autoLayout = useCallback(() => {- const layoutNodes = nodes.map((node, index) => ({- ...node,- position: { x: (index % 4) * 200, y: Math.floor(index / 4) * 150 },- }));- setNodes(layoutNodes);+ setNodes(layoutEditorNodes(nodes));}, [nodes, setNodes]);+ const selectNode = useCallback((node: OntologyNode) => {+ setSelectedElement(node);+ try {+ const params = new URLSearchParams(window.location.search);+ params.set("ontologyTab", "editor");+ params.set("ontologyEntity", node.id);+ window.history.replaceState(null, "", `?${params.toString()}`);+ } catch {+ // URL state is optional; the editor selection still works without it.+ }+ }, []);+const saveDraft = useCallback(async () => {if (!ontologyUri) {alert("Please select an ontology first");@@ -247,12 +437,11 @@ export function OntologyEditor() {...prev,removed_properties: [...prev.removed_properties, target.id],}));- } else {+ } else if (isEditableEntityType(target.data.entityType)) {setNodes((nds) => nds.filter((n) => n.id !== target.id));- setDraftDiff((prev) => ({- ...prev,- removed_classes: [...prev.removed_classes, target.id],- }));+ setDraftDiff((prev) => target.data.entityType === "property"+ ? { ...prev, removed_properties: [...prev.removed_properties, target.id] }+ : { ...prev, removed_classes: [...prev.removed_classes, target.id] });}setSelectedElement(null);}@@ -261,16 +450,21 @@ export function OntologyEditor() {const renameSelected = useCallback(() => {const target = showContext?.element ?? selectedElement;- if (target && !("source" in target)) {+ if (target && !("source" in target) && isEditableEntityType(target.data.entityType)) {const newLabel = prompt("Enter new name:", String(target.data.label ?? ""));if (newLabel) {setNodes((nds) =>nds.map((n) => (n.id === target.id ? { ...n, data: { ...n.data, label: newLabel } } : n)));- setDraftDiff((prev) => ({- ...prev,- modified_classes: { ...prev.modified_classes, [target.id]: { label: newLabel } },- }));+ setDraftDiff((prev) => target.data.entityType === "property"+ ? {+ ...prev,+ modified_properties: { ...prev.modified_properties, [target.id]: { label: newLabel } },+ }+ : {+ ...prev,+ modified_classes: { ...prev.modified_classes, [target.id]: { label: newLabel } },+ });}}setShowContext(null);@@ -339,11 +533,10 @@ export function OntologyEditor() {};const detailPanelStyle: React.CSSProperties = {- position: "absolute",- right: 0,- top: 0,- bottom: 0,+ flex: "0 0 320px",width: "320px",+ minWidth: "320px",+ boxSizing: "border-box",background: "rgba(9, 19, 34, 0.95)",borderLeft: "1px solid rgba(140, 192, 255, 0.12)",padding: "20px",@@ -353,11 +546,24 @@ export function OntologyEditor() {return (<div style={{ display: "flex", flexDirection: "column", height: "100%", background: "#07111f" }}>+ <style>{ontologyFlowThemeCss}</style><div style={toolbarStyle}><selectaria-label="Active ontology"value={ontologyUri}- onChange={(event) => setOntologyUri(event.target.value)}+ onChange={(event) => {+ setOntologyUri(event.target.value);+ setSelectedElement(null);+ try {+ // Drop the previous ontology's entity from the URL, or a reload+ // would resolve the stale ID and jump back to that ontology.+ const params = new URLSearchParams(window.location.search);+ params.delete("ontologyEntity");+ window.history.replaceState(null, "", `?${params.toString()}`);+ } catch {+ // URL state is optional; switching ontologies still works.+ }+ }}style={selectStyle}><option value="">Select ontology...</option>@@ -398,43 +604,75 @@ export function OntologyEditor() {</button></div>- <div style={{ flex: 1, position: "relative" }}>- <ReactFlow- nodes={nodes}- edges={edges}- onNodesChange={onNodesChange}- onEdgesChange={onEdgesChange}- onConnect={onConnect}- onNodeClick={(_, node) => setSelectedElement(node)}- onEdgeClick={(_, edge) => setSelectedElement(edge)}- onNodeContextMenu={handleNodeContextMenu}- onEdgeContextMenu={handleEdgeContextMenu}- nodeTypes={nodeTypes}- fitView- style={{ background: "#07111f" }}- >- <Background color="#1a2d3d" gap={20} />- <Controls />- <MiniMap nodeColor="#4aa3ff" maskColor="rgba(0,0,0,0.6)" />- </ReactFlow>-- {showContext && (- <div style={{ ...contextMenuStyle, left: showContext.x, top: showContext.y }}>- <div style={contextItemStyle} onClick={renameSelected}>- <Pencil size={14} />- Rename- </div>- <div style={contextItemStyle} onClick={deleteSelected}>- <Trash2 size={14} />- Delete+ <div style={{ display: "flex", flex: 1, minHeight: 0, minWidth: 0 }}>+ <div style={{ flex: 1, minHeight: 0, minWidth: 0, position: "relative" }}>+ <ReactFlow+ className="ontology-editor-flow"+ nodes={nodes}+ edges={edges}+ onNodesChange={onNodesChange}+ onEdgesChange={onEdgesChange}+ onConnect={onConnect}+ onInit={setFlowInstance}+ onNodeClick={(_, node) => selectNode(node)}+ onEdgeClick={(_, edge) => setSelectedElement(edge)}+ onNodeContextMenu={handleNodeContextMenu}+ onEdgeContextMenu={handleEdgeContextMenu}+ nodeTypes={nodeTypes}+ fitView+ style={{ background: "#07111f" }}+ >+ <Background color="#1a2d3d" gap={20} />+ <Controls />+ <MiniMap {...ONTOLOGY_MINIMAP_THEME} />+ </ReactFlow>++ {isLoadingGraph && (+ <div style={canvasMessageStyle}>Loading ontology structure…</div>+ )}+ {!isLoadingGraph && graphError && (+ <div style={{ ...canvasMessageStyle, color: "#ff9a8d" }}>{graphError}</div>+ )}+ {!isLoadingGraph && !graphError && ontologyUri && nodes.length === 0 && (+ <div style={canvasMessageStyle}>This ontology has no editable classes or properties.</div>+ )}++ {showContext && (+ <div style={{ ...contextMenuStyle, left: showContext.x, top: showContext.y }}>+ {"source" in showContext.element || isEditableEntityType(showContext.element.data.entityType) ? (+ <>+ {!("source" in showContext.element) && (+ <div style={contextItemStyle} onClick={renameSelected}>+ <Pencil size={14} />+ Rename+ </div>+ )}+ <div style={contextItemStyle} onClick={deleteSelected}>+ <Trash2 size={14} />+ Delete+ </div>+ </>+ ) : (+ <div style={{ ...contextItemStyle, cursor: "default", color: "#8fa8c6" }}>+ This term is read-only+ </div>+ )}</div>- </div>- )}+ )}+ </div>{selectedElement && (<div style={detailPanelStyle}><h3 style={{ margin: "0 0 16px", color: "#ebf3ff", fontSize: "16px" }}>- {"source" in selectedElement ? "Property Details" : "Class Details"}+ {"source" in selectedElement+ ? "Relationship Details"+ : selectedElement.data.entityType === "property"+ ? "Property Details"+ : selectedElement.data.entityType === "ontology"+ ? "Ontology Details"+ : selectedElement.data.entityType === "external"+ ? "External Term Details"+ : "Class Details"}</h3><div style={{ marginBottom: "12px" }}><label style={{ display: "block", color: "#8fa8c6", fontSize: "12px", marginBottom: "4px" }}>@@ -453,7 +691,9 @@ export function OntologyEditor() {<inputtype="text"value={String(selectedElement.data.label ?? "")}+ readOnly={!isEditableEntityType(selectedElement.data.entityType)}onChange={(e) => {+ if (!isEditableEntityType(selectedElement.data.entityType)) return;setNodes((nds) =>nds.map((n) =>n.id === selectedElement.id@@ -463,10 +703,19 @@ export function OntologyEditor() {);setDraftDiff((prev) => ({...prev,- modified_classes: {- ...prev.modified_classes,- [selectedElement.id]: { label: e.target.value },- },+ ...(selectedElement.data.entityType === "property"+ ? {+ modified_properties: {+ ...prev.modified_properties,+ [selectedElement.id]: { label: e.target.value },+ },+ }+ : {+ modified_classes: {+ ...prev.modified_classes,+ [selectedElement.id]: { label: e.target.value },+ },+ }),}));}}style={{@@ -496,3 +745,17 @@ export function OntologyEditor() {</div>);}++const canvasMessageStyle: React.CSSProperties = {+ position: "absolute",+ left: "50%",+ top: "50%",+ transform: "translate(-50%, -50%)",+ padding: "10px 14px",+ borderRadius: "8px",+ border: "1px solid rgba(127, 208, 255, 0.18)",+ background: "rgba(3, 9, 18, 0.9)",+ color: "#8fa8c6",+ fontSize: "13px",+ pointerEvents: "none",+};diff --git a/explorer/src/workspaces/OntologyWorkspace/api.ts b/explorer/src/workspaces/OntologyWorkspace/api.tsindex 9ad6a353..520f45f7 100644--- a/explorer/src/workspaces/OntologyWorkspace/api.ts+++ b/explorer/src/workspaces/OntologyWorkspace/api.ts@@ -9,6 +9,32 @@ import type {ShaclValidationResponse,} from "./types";+export type OntologyGraphNode = {+ id: string;+ type: string;+ content?: string;+ properties?: Record<string, unknown>;+};++export type OntologyGraphEdge = {+ id?: string;+ source: string;+ target: string;+ type: string;+ weight?: number;+ properties?: Record<string, unknown>;+};++export type OntologyGraphResponse = {+ uri: string;+ nodes: OntologyGraphNode[];+ edges: OntologyGraphEdge[];+};++export type OntologyEntityOwner = {+ source_ontology?: string;+};+async function parseResponse<T>(response: Response): Promise<T> {if (!response.ok) {let detail = `Request failed with status ${response.status}`;@@ -31,6 +57,18 @@ export async function loadOntologyRegistry(): Promise<OntologyEntry[]> {return parseResponse<OntologyEntry[]>(await fetch("/api/ontology/registry"));}+export async function loadOntologyGraph(uri: string, signal?: AbortSignal): Promise<OntologyGraphResponse> {+ return parseResponse<OntologyGraphResponse>(+ await fetch(`/api/ontology/graph?uri=${encodeURIComponent(uri)}`, { signal }),+ );+}++export async function loadOntologyEntityOwner(uri: string): Promise<string | undefined> {+ const response = await fetch(`/api/ontology/entity/${encodeURIComponent(uri)}`);+ if (!response.ok) return undefined;+ return (await response.json() as OntologyEntityOwner).source_ontology;+}+export async function loadAlignments(uri?: string): Promise<OntologyAlignment[]> {const query = uri ? `?uri=${encodeURIComponent(uri)}` : "";return parseResponse<OntologyAlignment[]>(await fetch(`/api/ontology/alignments${query}`));diff --git a/explorer/src/workspaces/OntologyWorkspace/index.tsx b/explorer/src/workspaces/OntologyWorkspace/index.tsxindex d5e457e8..70d4d719 100644--- a/explorer/src/workspaces/OntologyWorkspace/index.tsx+++ b/explorer/src/workspaces/OntologyWorkspace/index.tsx@@ -38,6 +38,7 @@ function readTabParam(): OntologyHubTab {const params = new URLSearchParams(window.location.search);const raw = params.get(TAB_PARAM);if (raw && TABS.some((t) => t.id === raw)) return raw as OntologyHubTab;+ if (params.get("ontologyEntity")) return "editor";} catch {// ignore}@@ -116,4 +117,3 @@ export function OntologyWorkspace({ onJumpToGraphNode }: OntologyWorkspaceProps)</div>);}-diff --git a/explorer/src/workspaces/OntologyWorkspace/ontologyEditorModel.ts b/explorer/src/workspaces/OntologyWorkspace/ontologyEditorModel.tsnew file mode 100644index 00000000..75eadf12--- /dev/null+++ b/explorer/src/workspaces/OntologyWorkspace/ontologyEditorModel.ts@@ -0,0 +1,70 @@+export type EditorEntityType = "ontology" | "class" | "property" | "external";++export type RegistryEntry = {+ uri: string;+ name: string;+};++export const ONTOLOGY_MINIMAP_THEME = {+ bgColor: "#0b1625",+ maskColor: "rgba(7, 17, 31, 0.72)",+ maskStrokeColor: "#5faeff",+ maskStrokeWidth: 2,+ nodeColor: "#2d7fd3",+ nodeStrokeColor: "#9acbff",+ nodeStrokeWidth: 1,+ style: {+ border: "1px solid #29435c",+ borderRadius: 6,+ boxShadow: "0 4px 16px rgba(0, 0, 0, 0.32)",+ },+} as const;++// The backend emits node types in compact (owl:Class) or full IRI+// (http://www.w3.org/2002/07/owl#Class) form; classification must accept both.+const FULL_IRI_PREFIXES: Array<[string, string]> = [+ ["http://www.w3.org/2002/07/owl#", "owl:"],+ ["http://www.w3.org/2000/01/rdf-schema#", "rdfs:"],+ ["http://www.w3.org/2004/02/skos/core#", "skos:"],+];++export function compactNodeType(type: string): string {+ for (const [iri, prefix] of FULL_IRI_PREFIXES) {+ if (type.startsWith(iri)) {+ return `${prefix}${type.slice(iri.length)}`;+ }+ }+ return type;+}++export function classifyNodeType(rawType: string): EditorEntityType {+ const type = compactNodeType(rawType);+ if (type === "owl:Ontology") return "ontology";+ if (type === "owl:Class" || type === "rdfs:Class") return "class";+ if (type.includes("Property")) return "property";+ return "external";+}++function ownsByNamespace(entityUri: string, ontologyUri: string): boolean {+ const stem = ontologyUri.replace(/[/#]+$/, "");+ return entityUri === ontologyUri+ || entityUri.startsWith(`${stem}#`)+ || entityUri.startsWith(`${stem}/`);+}++export function inferOntologyUri(+ entries: RegistryEntry[],+ entityUri: string,+ explicitOwner?: string,+): string | undefined {+ if (explicitOwner && entries.some((entry) => entry.uri === explicitOwner)) {+ return explicitOwner;+ }+ return [...entries]+ .filter((entry) => ownsByNamespace(entityUri, entry.uri))+ .sort((left, right) => right.uri.length - left.uri.length)[0]?.uri;+}++export function isEditableEntityType(entityType?: EditorEntityType): boolean {+ return entityType === "class" || entityType === "property";+}diff --git a/explorer/tests/ontologyEditorModel.test.ts b/explorer/tests/ontologyEditorModel.test.tsnew file mode 100644index 00000000..a4e1e84f--- /dev/null+++ b/explorer/tests/ontologyEditorModel.test.ts@@ -0,0 +1,66 @@+import assert from "node:assert/strict";+import test from "node:test";++import {+ classifyNodeType,+ compactNodeType,+ inferOntologyUri,+ isEditableEntityType,+ ONTOLOGY_MINIMAP_THEME,+} from "../src/workspaces/OntologyWorkspace/ontologyEditorModel";++const registry = [+ { uri: "https://example.test/foo", name: "Foo" },+ { uri: "https://example.test/foo/nested", name: "Nested" },+];++test("ontology inference requires a URI delimiter and prefers the closest namespace", () => {+ assert.equal(inferOntologyUri(registry, "https://example.test/foobar/Class"), undefined);+ assert.equal(+ inferOntologyUri(registry, "https://example.test/foo/nested#Class"),+ "https://example.test/foo/nested",+ );+});++test("explicit scheme ownership wins when an entity uses another namespace", () => {+ assert.equal(+ inferOntologyUri(registry, "https://vocabulary.test/Class", "https://example.test/foo"),+ "https://example.test/foo",+ );+});++test("only draft-supported class and property nodes are editable", () => {+ assert.equal(isEditableEntityType("class"), true);+ assert.equal(isEditableEntityType("property"), true);+ assert.equal(isEditableEntityType("ontology"), false);+ assert.equal(isEditableEntityType("external"), false);+});++test("the ontology minimap has an explicit dark, high-contrast theme", () => {+ assert.equal(ONTOLOGY_MINIMAP_THEME.bgColor, "#0b1625");+ assert.equal(ONTOLOGY_MINIMAP_THEME.maskStrokeColor, "#5faeff");+ assert.equal(ONTOLOGY_MINIMAP_THEME.nodeStrokeColor, "#9acbff");+ assert.match(ONTOLOGY_MINIMAP_THEME.style.border, /#29435c/);+});++test("node types classify identically in compact and full IRI form", () => {+ const cases: Array<[string, string, string]> = [+ ["owl:Ontology", "http://www.w3.org/2002/07/owl#Ontology", "ontology"],+ ["owl:Class", "http://www.w3.org/2002/07/owl#Class", "class"],+ ["rdfs:Class", "http://www.w3.org/2000/01/rdf-schema#Class", "class"],+ ["owl:ObjectProperty", "http://www.w3.org/2002/07/owl#ObjectProperty", "property"],+ ["owl:DatatypeProperty", "http://www.w3.org/2002/07/owl#DatatypeProperty", "property"],+ ["owl:AnnotationProperty", "http://www.w3.org/2002/07/owl#AnnotationProperty", "property"],+ ];+ for (const [compact, fullIri, expected] of cases) {+ assert.equal(classifyNodeType(compact), expected, compact);+ assert.equal(classifyNodeType(fullIri), expected, fullIri);+ }+ assert.equal(classifyNodeType("owl:NamedIndividual"), "external");+ assert.equal(classifyNodeType("http://www.w3.org/2004/02/skos/core#Concept"), "external");+});++test("compactNodeType leaves unknown namespaces untouched", () => {+ assert.equal(compactNodeType("https://example.org/custom#Thing"), "https://example.org/custom#Thing");+ assert.equal(compactNodeType("owl:Class"), "owl:Class");+});diff --git a/semantica/explorer/routes/ontology.py b/semantica/explorer/routes/ontology.pyindex 81877e50..e723d166 100644--- a/semantica/explorer/routes/ontology.py+++ b/semantica/explorer/routes/ontology.py@@ -234,6 +234,12 @@ class EntityDetailResponse(BaseModel):properties: Dict[str, Any] = Field(default_factory=dict)+class OntologyGraphResponse(BaseModel):+ uri: str+ nodes: List[Dict[str, Any]] = Field(default_factory=list)+ edges: List[Dict[str, Any]] = Field(default_factory=list)++class SKOSScheme(BaseModel):uri: strtitle: str@@ -664,6 +670,7 @@ def _convert_ontology_to_graph(ontology_dict: Dict[str, Any]) -> Tuple[List[Dict"rdfs:label": cls.get("label", cls.get("name", "")),"rdfs:comment": cls.get("description", ""),"uri": cls_uri,+ "scheme_uri": ontology_uri,},}nodes.append(node)@@ -680,14 +687,21 @@ def _convert_ontology_to_graph(ontology_dict: Dict[str, Any]) -> Tuple[List[Dict# Add property nodes and edgesfor prop in ontology_dict.get("properties", []):prop_uri = prop.get("uri", f"temp:prop:{uuid.uuid4().hex[:12]}")+ property_type = {+ "object": "owl:ObjectProperty",+ "data": "owl:DatatypeProperty",+ "datatype": "owl:DatatypeProperty",+ "annotation": "owl:AnnotationProperty",+ }.get(str(prop.get("type", "object")).lower(), "owl:ObjectProperty")node = {"id": prop_uri,- "type": f"owl:{prop.get('type', 'Object').title()}Property",+ "type": property_type,"content": prop.get("name", prop.get("label", "")),"properties": {"rdfs:label": prop.get("label", prop.get("name", "")),"rdfs:comment": prop.get("description", ""),"uri": prop_uri,+ "scheme_uri": ontology_uri,},}nodes.append(node)@@ -748,14 +762,38 @@ def _node_source_ontology(node: Dict[str, Any]) -> Optional[str]:)-def _node_belongs_to_ontology(node: Dict[str, Any], ontology_uri: str) -> bool:+def _node_belongs_to_ontology(+ node: Dict[str, Any],+ ontology_uri: str,+ known_ontology_uris: Optional[set[str]] = None,+) -> bool:nid = node.get("id", "")if nid == ontology_uri:return True- if _node_source_ontology(node) == ontology_uri:- return True+ owner = _node_source_ontology(node)+ if owner:+ return owner == ontology_uri+ if known_ontology_uris:+ namespace_owners = [+ candidate+ for candidate in known_ontology_uris+ if nid == candidate+ or nid.startswith(+ (candidate.rstrip("#/") + "#", candidate.rstrip("#/") + "/")+ )+ ]+ if namespace_owners and max(namespace_owners, key=len) != ontology_uri:+ return Falsestem = ontology_uri.rstrip("#/")- return nid.startswith((stem + "#", stem + "/"))+ if not nid.startswith((stem + "#", stem + "/")):+ return False+ # Prefix ownership only extends to names minted directly in the+ # ontology's namespace (<stem>#Term or <stem>/Term). Any further+ # delimiter marks a nested vocabulary (<stem>/child#Term,+ # <stem>/child/Term), which must not be absorbed into the parent+ # until it is registered or carries an explicit owner.+ local_name = nid[len(stem) + 1 :]+ return "#" not in local_name and "/" not in local_namedef _is_ontology_entity(node: Dict[str, Any]) -> bool:@@ -1221,7 +1259,8 @@ def _parse_rdf_sync(content: bytes, fmt: str) -> tuple:metadata.setdefault("description", str(obj))break- if "uri" not in metadata:+ synthetic_uri = "uri" not in metadata+ if synthetic_uri:metadata["uri"] = f"urn:semantica:onto:{uuid.uuid4().hex[:8]}"metadata.setdefault("name", metadata["uri"].rsplit("/", 1)[-1].rsplit("#", 1)[-1] or "Unnamed")metadata["triple_count"] = len(g)@@ -1268,6 +1307,20 @@ def _parse_rdf_sync(content: bytes, fmt: str) -> tuple:"weight": 1.0,})+ if synthetic_uri:+ # No owl:Ontology / skos:ConceptScheme declaration exists, so the+ # synthetic registry URI shares no namespace with any node. Ownership+ # must be recorded explicitly, and the editor needs a matching graph+ # node, or the registered ontology resolves to an empty core and 404s.+ for node in nodes:+ node["properties"].setdefault("scheme_uri", metadata["uri"])+ nodes.append({+ "id": metadata["uri"],+ "type": "owl:Ontology",+ "content": metadata["name"],+ "properties": {"rdfs:label": metadata["name"], "uri": metadata["uri"]},+ })+return nodes, edges, metadata@@ -1768,6 +1821,107 @@ async def search_entities(return results[email protected]("/graph", response_model=OntologyGraphResponse)+async def get_ontology_graph(+ request: Request,+ uri: str = Query(..., min_length=1),+ session: GraphSession = Depends(get_session),+):+ """Return the editable schema subgraph for one registered ontology."""+ registry = _get_registry(request)+ ontology_nodes: List[Dict[str, Any]] = []+ for node_type in _ONTOLOGY_TYPES:+ nodes, _ = await asyncio.to_thread(+ session.get_nodes, node_type=node_type, skip=0, limit=2**63 - 1+ )+ ontology_nodes.extend(nodes)+ known_ontology_uris = set(registry) | {+ str(node.get("id", "")) for node in ontology_nodes if node.get("id")+ }+ if uri not in known_ontology_uris:+ raise HTTPException(status_code=404, detail="Ontology not found in registry.")++ schema_types = _CLASS_TYPES | _PROPERTY_TYPES | _CONCEPT_TYPES | _ONTOLOGY_TYPES+ candidates_by_id: Dict[str, Dict[str, Any]] = {}+ for node_type in schema_types:+ nodes, _ = await asyncio.to_thread(+ session.get_nodes, node_type=node_type, skip=0, limit=2**63 - 1+ )+ candidates_by_id.update(+ (str(node.get("id", "")), node) for node in nodes if node.get("id")+ )++ core_node_ids = {+ str(node.get("id", ""))+ for node in candidates_by_id.values()+ if _node_belongs_to_ontology(node, uri, known_ontology_uris)+ }+ if not core_node_ids:+ raise HTTPException(status_code=404, detail="Ontology graph not found.")++ structure_edge_types = {+ "rdf:type",+ "rdfs:subClassOf",+ "rdfs:domain",+ "rdfs:range",+ "owl:disjointWith",+ "owl:equivalentClass",+ "owl:equivalentProperty",+ "owl:inverseOf",+ "skos:broader",+ "skos:narrower",+ "skos:related",+ }+ selected_edges: List[Dict[str, Any]] = []+ for edge_type in structure_edge_types:+ edges, _ = await asyncio.to_thread(+ session.get_edges,+ edge_type=edge_type,+ skip=0,+ limit=2**63 - 1,+ )+ # Keep only edges whose source is a core node: the requested ontology+ # may reference outward (e.g. rdfs:range to an external vocabulary),+ # but an unrelated ontology's property pointing at a core class must+ # not leak inward.+ selected_edges.extend(+ edge for edge in edges+ if str(edge.get("source", "")) in core_node_ids+ )+ if (+ len(core_node_ids) > _MAX_ANALYSIS_NODES+ or len(selected_edges) > _MAX_ANALYSIS_NODES+ ):+ raise HTTPException(+ status_code=413,+ detail=(+ "Ontology editor graph exceeds the maximum size "+ f"({_MAX_ANALYSIS_NODES} nodes or edges)."+ ),+ )++ selected_node_ids = set(core_node_ids)+ for edge in selected_edges:+ selected_node_ids.add(str(edge.get("source", "")))+ selected_node_ids.add(str(edge.get("target", "")))++ selected_nodes = [candidates_by_id[node_id] for node_id in core_node_ids]+ for node_id in selected_node_ids - core_node_ids:+ external = await asyncio.to_thread(session.get_node, node_id)+ if external is not None:+ selected_nodes.append(external)+ selected_nodes.sort(key=lambda node: str(node.get("id", "")))+ selected_edges.sort(+ key=lambda edge: (+ str(edge.get("source", "")),+ str(edge.get("type", "")),+ str(edge.get("target", "")),+ str(edge.get("id", "")),+ )+ )+ return OntologyGraphResponse(uri=uri, nodes=selected_nodes, edges=selected_edges)++@router.get("/entity/{entity_uri:path}", response_model=EntityDetailResponse)async def get_entity_detail(entity_uri: str,diff --git a/tests/explorer/test_ontology_subissue3.py b/tests/explorer/test_ontology_subissue3.pyindex 66a660b0..b24d596a 100644--- a/tests/explorer/test_ontology_subissue3.py+++ b/tests/explorer/test_ontology_subissue3.py@@ -12,7 +12,11 @@ from semantica.context.context_graph import ContextGraphpytest.importorskip("fastapi")from semantica.explorer.app import create_app # noqa: E402-from semantica.explorer.routes.ontology import OntologyEntry # noqa: E402+from semantica.explorer.routes.ontology import ( # noqa: E402+ OntologyEntry,+ _convert_ontology_to_graph,+ _node_belongs_to_ontology,+)from semantica.explorer.session import GraphSession # noqa: E402from starlette.testclient import TestClient # noqa: E402@@ -131,6 +135,181 @@ def test_health_returns_dimensions_and_issues(client):assert isinstance(payload["issues"], list)+def test_ontology_graph_returns_editable_schema_nodes_and_edges(client):+ response = client.get(+ "/api/ontology/graph",+ params={"uri": "http://example.org/onto-a"},+ )++ assert response.status_code == 200+ payload = response.json()+ node_ids = {node["id"] for node in payload["nodes"]}+ assert "http://example.org/onto-a" in node_ids+ assert "http://example.org/onto-a#Person" in node_ids+ assert "http://example.org/onto-a#name" in node_ids+ assert any(+ edge["source"] == "http://example.org/onto-a#name"+ and edge["target"] == "http://example.org/onto-a#Person"+ and edge["type"] == "rdfs:domain"+ for edge in payload["edges"]+ )+++def test_ontology_graph_rejects_unregistered_namespace(client):+ response = client.get(+ "/api/ontology/graph",+ params={"uri": "http://example.org"},+ )++ assert response.status_code == 404+++def test_ontology_graph_excludes_separately_registered_nested_ontology(client):+ graph = client.app.state.session.graph+ nested = "http://example.org/onto-a/nested"+ nested_class = f"{nested}#PrivateClass"+ graph.add_node(nested, node_type="owl:Ontology", content="Nested Ontology")+ graph.add_node(nested_class, node_type="owl:Class", content="Private Class")++ response = client.get(+ "/api/ontology/graph",+ params={"uri": "http://example.org/onto-a"},+ )++ assert response.status_code == 200+ node_ids = {node["id"] for node in response.json()["nodes"]}+ assert nested not in node_ids+ assert nested_class not in node_ids+++def test_ontology_graph_prefers_explicit_ownership_over_uri_namespace(client):+ graph = client.app.state.session.graph+ explicit_member = "http://unrelated.example/Person"+ graph.add_node(+ explicit_member,+ node_type="owl:Class",+ content="Explicit Member",+ scheme_uri="http://example.org/onto-a",+ )++ response = client.get(+ "/api/ontology/graph",+ params={"uri": "http://example.org/onto-a"},+ )++ assert response.status_code == 200+ assert explicit_member in {node["id"] for node in response.json()["nodes"]}+++def test_ontology_graph_excludes_inward_edges_from_other_ontologies(client):+ graph = client.app.state.session.graph+ foreign_prop = "http://example.org/onto-b#recordOf"+ graph.add_node(+ foreign_prop,+ node_type="owl:ObjectProperty",+ content="record of",+ scheme_uri="http://example.org/onto-b",+ )+ # onto-b's property points its domain at onto-a's class: an inward+ # reference that must not pull the foreign property into onto-a's graph.+ graph.add_edge(foreign_prop, "http://example.org/onto-a#Person", edge_type="rdfs:domain")++ response = client.get(+ "/api/ontology/graph",+ params={"uri": "http://example.org/onto-a"},+ )++ assert response.status_code == 200+ payload = response.json()+ assert foreign_prop not in {node["id"] for node in payload["nodes"]}+ assert all(edge["source"] != foreign_prop for edge in payload["edges"])+++def test_ontology_graph_excludes_unregistered_nested_namespace(client):+ graph = client.app.state.session.graph+ nested_class = "http://example.org/onto-a/vocab#Term"+ graph.add_node(nested_class, node_type="owl:Class", content="Nested Term")++ response = client.get(+ "/api/ontology/graph",+ params={"uri": "http://example.org/onto-a"},+ )++ assert response.status_code == 200+ assert nested_class not in {node["id"] for node in response.json()["nodes"]}+++def test_node_belongs_to_ontology_nested_namespace_matrix():+ parent = "http://example.org/onto-a"+ child = "http://example.org/onto-a/nested"++ def node(node_id):+ return {"id": node_id, "properties": {}}++ assert _node_belongs_to_ontology(node(f"{parent}#Person"), parent, {parent})+ assert _node_belongs_to_ontology(node(f"{parent}/Person"), parent, {parent})+ # An unregistered nested namespace is not absorbed into the parent,+ # whether fragment-based or path-based+ assert not _node_belongs_to_ontology(node(f"{child}#Term"), parent, {parent})+ assert not _node_belongs_to_ontology(node(f"{child}/Term"), parent, {parent})+ # Once registered, the nested namespace owns its nodes+ assert not _node_belongs_to_ontology(node(f"{child}#Term"), parent, {parent, child})+ assert _node_belongs_to_ontology(node(f"{child}#Term"), child, {parent, child})+ assert _node_belongs_to_ontology(node(f"{child}/Term"), child, {parent, child})+++def test_load_fallback_import_without_declaration_is_editable(client):+ turtle = """+@prefix ex: <http://data.example.org/people#> .+@prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .+@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .++ex:Employee a rdfs:Class ;+ rdfs:label "Employee" .+ex:manager a rdf:Property ;+ rdfs:label "manager" .+"""+ with patch(+ "semantica.ingest.ontology_ingestor.OntologyIngestor.ingest_ontology",+ side_effect=RuntimeError("force fallback parser"),+ ):+ loaded = client.post(+ "/api/ontology/load",+ json={"content": turtle, "format": "turtle"},+ )+ assert loaded.status_code == 200+ uri = loaded.json()["uri"]+ assert uri.startswith("urn:semantica:onto:")++ response = client.get("/api/ontology/graph", params={"uri": uri})+ assert response.status_code == 200+ payload = response.json()+ node_ids = {node["id"] for node in payload["nodes"]}+ assert uri in node_ids+ assert "http://data.example.org/people#Employee" in node_ids+++def test_ontology_graph_ignores_unrelated_data_when_enforcing_size_limit(client):+ graph = client.app.state.session.graph+ for index in range(5_001):+ graph.add_node(+ f"urn:unrelated:{index}",+ node_type="owl:Class",+ content="Unrelated",+ scheme_uri="http://example.org/onto-b",+ )++ response = client.get(+ "/api/ontology/graph",+ params={"uri": "http://example.org/onto-a"},+ )++ assert response.status_code == 200+ assert "http://example.org/onto-a#Person" in {+ node["id"] for node in response.json()["nodes"]+ }++def test_shacl_generate_and_shapes(client):response = client.post("/api/ontology/shacl/generate",@@ -696,6 +875,29 @@ def test_ontology_load_does_not_swallow_422_from_ingestor_success_path(client):fallback_parse.assert_not_called()+def test_convert_ontology_uses_standard_property_types_and_scheme_uri():+ ontology_uri = "http://example.org/onto"+ nodes, _ = _convert_ontology_to_graph(+ {+ "uri": ontology_uri,+ "name": "Example Ontology",+ "classes": [+ {"uri": f"{ontology_uri}#Person", "name": "Person"},+ ],+ "properties": [+ {"uri": f"{ontology_uri}#name", "name": "name", "type": "data"},+ {"uri": f"{ontology_uri}#knows", "name": "knows", "type": "object"},+ ],+ }+ )++ by_id = {node["id"]: node for node in nodes}+ assert by_id[f"{ontology_uri}#Person"]["properties"]["scheme_uri"] == ontology_uri+ assert by_id[f"{ontology_uri}#name"]["type"] == "owl:DatatypeProperty"+ assert by_id[f"{ontology_uri}#knows"]["type"] == "owl:ObjectProperty"+ assert by_id[f"{ontology_uri}#name"]["properties"]["scheme_uri"] == ontology_uri++# ---------------------------------------------------------------------------# refresh_ontology — single combined add_nodes_and_edges() coverage (#775)# ---------------------------------------------------------------------------@@ -789,5 +991,3 @@ def test_refresh_ontology_missing_source_url_returns_422(client):response = client.post(f"/api/ontology/{encoded_uri}/refresh")assert response.status_code == 422assert "source url" in response.json()["detail"].lower()--