@skaterqiang/protege-js 0.1.0

package/src/model/SWRL.js

@@ -0,0 +1,152 @@
+'use strict';
+
+// ---------------------------------------------------------------------------
+// SWRL — Semantic Web Rule Language (https://www.w3.org/Submission/SWRL/).
+// A SWRL rule has the form:  antecedent ⇒ consequent, where both sides are
+// conjunctions of atoms. Supported atoms:
+//   ClassAtom(classExpr, i-var)
+//   ObjectPropertyAtom(prop, i-var, i-var)
+//   DataPropertyAtom(prop, i-var, d-var)
+//   SameAsAtom(i-var, i-var)   DifferentFromAtom(i-var, i-var)
+//   BuiltInAtom(builtin, args...)   DataRangeAtom(d-var, dataRange)
+// Variables start with ?  (e.g. ?x). IRIs/prefixed names identify entities.
+// ---------------------------------------------------------------------------
+
+const { OWLClass, OWLObjectProperty, OWLDataProperty, OWLNamedIndividual } = require('../model/OWLEntity');
+const { IRI } = require('../model/IRI');
+const CE = require('../model/OWLClassExpression');
+
+const AtomType = Object.freeze({
+  CLASS: 'ClassAtom',
+  OBJECT_PROPERTY: 'ObjectPropertyAtom',
+  DATA_PROPERTY: 'DataPropertyAtom',
+  SAME_AS: 'SameAsAtom',
+  DIFFERENT_FROM: 'DifferentFromAtom',
+  BUILTIN: 'BuiltInAtom',
+  DATA_RANGE: 'DataRangeAtom'
+});
+
+class SWRLVariable {
+  constructor(iri) {
+    this.iri = iri instanceof IRI ? iri : IRI.create(iri);
+  }
+  toString() { return '?' + this.iri.getShortForm(); }
+}
+
+class SWRLClassAtom {
+  constructor(classExpression, arg) {
+    this.type = AtomType.CLASS;
+    this.classExpression = classExpression;
+    this.arg = arg; // SWRLVariable or OWLNamedIndividual
+  }
+  toString() { return `${this.classExpression}(${this.arg})`; }
+}
+
+class SWRLObjectPropertyAtom {
+  constructor(property, arg1, arg2) {
+    this.type = AtomType.OBJECT_PROPERTY;
+    this.property = property;
+    this.arg1 = arg1;
+    this.arg2 = arg2;
+  }
+  toString() { return `${this.property}(${this.arg1}, ${this.arg2})`; }
+}
+
+class SWRLDataPropertyAtom {
+  constructor(property, arg1, arg2) {
+    this.type = AtomType.DATA_PROPERTY;
+    this.property = property;
+    this.arg1 = arg1;
+    this.arg2 = arg2;
+  }
+  toString() { return `${this.property}(${this.arg1}, ${this.arg2})`; }
+}
+
+class SWRLSameAsAtom {
+  constructor(arg1, arg2) {
+    this.type = AtomType.SAME_AS;
+    this.arg1 = arg1;
+    this.arg2 = arg2;
+  }
+  toString() { return `sameAs(${this.arg1}, ${this.arg2})`; }
+}
+
+class SWRLDifferentFromAtom {
+  constructor(arg1, arg2) {
+    this.type = AtomType.DIFFERENT_FROM;
+    this.arg1 = arg1;
+    this.arg2 = arg2;
+  }
+  toString() { return `differentFrom(${this.arg1}, ${this.arg2})`; }
+}
+
+class SWRLBuiltInAtom {
+  constructor(builtinIRI, args) {
+    this.type = AtomType.BUILTIN;
+    this.builtin = builtinIRI instanceof IRI ? builtinIRI : IRI.create(builtinIRI);
+    this.args = args.slice();
+  }
+  toString() { return `${this.builtin.getShortForm()}(${this.args.join(', ')})`; }
+}
+
+class SWRLDataRangeAtom {
+  constructor(dataRange, arg) {
+    this.type = AtomType.DATA_RANGE;
+    this.dataRange = dataRange;
+    this.arg = arg;
+  }
+  toString() { return `${this.dataRange}(${this.arg})`; }
+}
+
+class SWRLRule {
+  constructor(body, head, iri = null, annotations = []) {
+    this.body = body.slice();   // antecedent atoms
+    this.head = head.slice();   // consequent atoms
+    this.iri = iri;
+    this.annotations = annotations;
+  }
+  toString() {
+    return `${this.body.join(' ^ ')} -> ${this.head.join(' ^ ')}`;
+  }
+}
+
+// Built-in namespace from the SWRL submission
+const SWRLB_NS = 'http://www.w3.org/2003/11/swrlb#';
+
+const SWRL_BUILTINS = [
+  // Comparison
+  'equal', 'notEqual', 'lessThan', 'lessThanOrEqual', 'greaterThan', 'greaterThanOrEqual',
+  // Math
+  'add', 'subtract', 'multiply', 'divide', 'integerDivide', 'mod',
+  'pow', 'abs', 'ceiling', 'floor', 'round', 'roundHalfToEven',
+  'sin', 'cos', 'tan', 'sqrt',
+  // String core
+  'stringConcat', 'substring', 'stringLength', 'normalizeSpace', 'upperCase', 'lowerCase',
+  'contains', 'startsWith', 'endsWith', 'matches', 'replace',
+  // String long-tail
+  'stringEqualIgnoreCase', 'translate', 'substringBefore', 'substringAfter',
+  // Date / time
+  'yearMonthDuration', 'dayTimeDuration', 'dateTime', 'date', 'time',
+  // anyURI
+  'anyURI', 'resolveURI',
+  // List operations
+  'listConcat', 'listIntersection', 'listSubtraction', 'member', 'length',
+  'first', 'rest', 'sublist', 'empty',
+  // Boolean
+  'booleanNot'
+].map(n => SWRLB_NS + n);
+
+module.exports = {
+  AtomType,
+  SWRLVariable,
+  SWRLClassAtom,
+  SWRLObjectPropertyAtom,
+  SWRLDataPropertyAtom,
+  SWRLSameAsAtom,
+  SWRLDifferentFromAtom,
+  SWRLBuiltInAtom,
+  SWRLDataRangeAtom,
+  SWRLRule,
+  SWRLB_NS,
+  SWRL_BUILTINS
+};

package/src/model/event/OWLModelManagerEvent.js

@@ -0,0 +1,33 @@
+'use strict';
+
+// ---------------------------------------------------------------------------
+// event — mirrors org.protege.editor.owl.model.event
+// ---------------------------------------------------------------------------
+
+const EventType = Object.freeze({
+  ACTIVE_ONTOLOGY_CHANGED: 'ACTIVE_ONTOLOGY_CHANGED',
+  ONTOLOGY_LOADED: 'ONTOLOGY_LOADED',
+  ONTOLOGY_RELOADED: 'ONTOLOGY_RELOADED',
+  ONTOLOGY_SAVED: 'ONTOLOGY_SAVED',
+  ONTOLOGY_CREATED: 'ONTOLOGY_CREATED',
+  ONTOLOGY_VISIBILITY_CHANGED: 'ONTOLOGY_VISIBILITY_CHANGED',
+  REASONER_CHANGED: 'REASONER_CHANGED',
+  ABOUT_TO_CLASSIFY: 'ABOUT_TO_CLASSIFY',
+  ONTOLOGY_CLASSIFIED: 'ONTOLOGY_CLASSIFIED',
+  ENTITY_RENDERER_CHANGED: 'ENTITY_RENDERER_CHANGED',
+  ENTITY_RENDERING_CHANGED: 'ENTITY_RENDERING_CHANGED',
+  WORKSPACE_LOADED: 'WORKSPACE_LOADED',
+  ENTITY_SELECTION_CHANGED: 'ENTITY_SELECTION_CHANGED'
+});
+
+class OWLModelManagerChangeEvent {
+  constructor(type, payload = null) {
+    this.type = type;
+    this.payload = payload;
+  }
+  getType() { return this.type; }
+  getPayload() { return this.payload; }
+  isType(t) { return this.type === t; }
+}
+
+module.exports = { EventType, OWLModelManagerChangeEvent };

package/src/model/hierarchy/HierarchyProvider.js

@@ -0,0 +1,214 @@
+'use strict';
+
+const { AxiomType } = require('../OWLAxiom');
+const { OWL, OWLClass, OWLObjectProperty, OWLDataProperty } = require('../OWLEntity');
+const { isNamedClass } = require('../OWLClassExpression');
+
+// ---------------------------------------------------------------------------
+// hierarchy — mirrors org.protege.editor.owl.model.hierarchy
+// AssertedClassHierarchyProvider: builds a tree from SubClassOf axioms.
+// ---------------------------------------------------------------------------
+
+class OWLObjectHierarchyProvider {
+  constructor(ontology) {
+    this._ontology = ontology;
+    this._roots = new Set();
+    this._parents = new Map(); // child iri -> Set<parent iri>
+    this._children = new Map(); // parent iri -> Set<child iri>
+    this._nodes = new Map();    // iri -> entity
+    this._listeners = new Set();
+  }
+
+  setOntology(ontology) {
+    this._ontology = ontology;
+    this.rebuild();
+  }
+
+  addListener(l) { this._listeners.add(l); }
+  removeListener(l) { this._listeners.delete(l); }
+  _fireChanged() { for (const l of this._listeners) l(); }
+
+  rebuild() {
+    this._roots.clear();
+    this._parents.clear();
+    this._children.clear();
+    this._nodes.clear();
+    this._build();
+    this._fireChanged();
+  }
+
+  /** @abstract */
+  _build() { throw new Error('override _build'); }
+
+  _addNode(entity) {
+    this._nodes.set(entity.getIRI().toString(), entity);
+  }
+
+  _addEdge(parent, child) {
+    if (parent.equals(child)) return; // ignore self-loops
+    this._addNode(parent);
+    this._addNode(child);
+    const pKey = parent.getIRI().toString();
+    const cKey = child.getIRI().toString();
+    if (!this._children.has(pKey)) this._children.set(pKey, new Set());
+    this._children.get(pKey).add(cKey);
+    if (!this._parents.has(cKey)) this._parents.set(cKey, new Set());
+    this._parents.get(cKey).add(pKey);
+  }
+
+  getRoots() {
+    return [...this._roots].map(k => this._nodes.get(k)).filter(Boolean);
+  }
+
+  getChildren(entity) {
+    const keys = this._children.get(entity.getIRI().toString());
+    if (!keys) return [];
+    return [...keys].map(k => this._nodes.get(k)).filter(Boolean);
+  }
+
+  getParents(entity) {
+    const keys = this._parents.get(entity.getIRI().toString());
+    if (!keys) return [];
+    return [...keys].map(k => this._nodes.get(k)).filter(Boolean);
+  }
+
+  getDescendants(entity) {
+    const seen = new Set();
+    const stack = [entity];
+    const out = [];
+    while (stack.length) {
+      const cur = stack.pop();
+      const key = cur.getIRI().toString();
+      if (seen.has(key)) continue;
+      seen.add(key);
+      if (cur !== entity) out.push(cur);
+      stack.push(...this.getChildren(cur));
+    }
+    return out;
+  }
+
+  getAncestors(entity) {
+    const seen = new Set();
+    const stack = [entity];
+    const out = [];
+    while (stack.length) {
+      const cur = stack.pop();
+      const key = cur.getIRI().toString();
+      if (seen.has(key)) continue;
+      seen.add(key);
+      if (cur !== entity) out.push(cur);
+      stack.push(...this.getParents(cur));
+    }
+    return out;
+  }
+
+  contains(entity) {
+    return this._nodes.has(entity.getIRI().toString());
+  }
+
+  /** Tree as plain nested objects, for JSON serialization to the UI. */
+  toTree() {
+    const build = (entity, visited) => {
+      const key = entity.getIRI().toString();
+      const node = { iri: key, name: entity.getShortForm(), children: [] };
+      if (visited.has(key)) return node; // cycle guard
+      visited.add(key);
+      for (const child of this.getChildren(entity)) {
+        node.children.push(build(child, new Set(visited)));
+      }
+      node.children.sort((a, b) => a.name.localeCompare(b.name));
+      return node;
+    };
+    return this.getRoots()
+      .map(r => build(r, new Set()))
+      .sort((a, b) => a.name.localeCompare(b.name));
+  }
+}
+
+// ---------------------------------------------------------------------------
+// AssertedClassHierarchyProvider — roots at owl:Thing.
+// ---------------------------------------------------------------------------
+
+class AssertedClassHierarchyProvider extends OWLObjectHierarchyProvider {
+  _build() {
+    const thing = OWL.THING;
+    this._addNode(thing);
+    this._roots.add(thing.getIRI().toString());
+
+    if (!this._ontology) return;
+    const classes = this._ontology.getClassesInSignature();
+    const withParent = new Set();
+
+    for (const ax of this._ontology.getAxiomsOfType(AxiomType.SUBCLASS_OF)) {
+      const sub = ax.subClass;
+      const sup = ax.superClass;
+      if (isNamedClass(sub) && isNamedClass(sup)) {
+        this._addEdge(sup, sub);
+        withParent.add(sub.getIRI().toString());
+      }
+    }
+
+    // Classes with no asserted superclass hang directly under owl:Thing.
+    for (const cls of classes) {
+      const key = cls.getIRI().toString();
+      if (!withParent.has(key) && !thing.equals(cls)) {
+        this._addEdge(thing, cls);
+      }
+    }
+  }
+}
+
+// ---------------------------------------------------------------------------
+// AbstractOWLPropertyHierarchyProvider — shared by object/data properties.
+// ---------------------------------------------------------------------------
+
+class OWLPropertyHierarchyProvider extends OWLObjectHierarchyProvider {
+  constructor(ontology, rootEntity, subAxiomType) {
+    super(ontology);
+    this._rootEntity = rootEntity;
+    this._subAxiomType = subAxiomType;
+  }
+
+  _build() {
+    const root = this._rootEntity;
+    this._addNode(root);
+    this._roots.add(root.getIRI().toString());
+
+    if (!this._ontology) return;
+    const props = this._subAxiomType === AxiomType.SUB_OBJECT_PROPERTY_OF
+      ? this._ontology.getObjectPropertiesInSignature()
+      : this._ontology.getDataPropertiesInSignature();
+    const withParent = new Set();
+
+    for (const ax of this._ontology.getAxiomsOfType(this._subAxiomType)) {
+      this._addEdge(ax.superProperty, ax.subProperty);
+      withParent.add(ax.subProperty.getIRI().toString());
+    }
+
+    for (const p of props) {
+      const key = p.getIRI().toString();
+      if (!withParent.has(key) && !root.equals(p)) {
+        this._addEdge(root, p);
+      }
+    }
+  }
+}
+
+class OWLObjectPropertyHierarchyProvider extends OWLPropertyHierarchyProvider {
+  constructor(ontology) {
+    super(ontology, OWL.TOP_OBJECT_PROPERTY, AxiomType.SUB_OBJECT_PROPERTY_OF);
+  }
+}
+
+class OWLDataPropertyHierarchyProvider extends OWLPropertyHierarchyProvider {
+  constructor(ontology) {
+    super(ontology, OWL.TOP_DATA_PROPERTY, AxiomType.SUB_DATA_PROPERTY_OF);
+  }
+}
+
+module.exports = {
+  OWLObjectHierarchyProvider,
+  AssertedClassHierarchyProvider,
+  OWLObjectPropertyHierarchyProvider,
+  OWLDataPropertyHierarchyProvider
+};

package/src/profiles/OWL2Profiles.js

@@ -0,0 +1,185 @@
+'use strict';
+
+// ---------------------------------------------------------------------------
+// profiles/OWL2Profiles — structural conformance checkers for the three
+// OWL 2 profiles (W3C §Profiles): RL, QL, EL.
+//
+// Each checker returns a list of violations:
+//   { profile, rule, message, axiom }
+// An ontology belongs to a profile iff the violation list is empty.
+//
+// These checkers implement the *syntactic* restrictions of each profile,
+// not full expressivity analysis. They are intentionally conservative.
+// ---------------------------------------------------------------------------
+
+const { AxiomType: A } = require('../model/OWLAxiom');
+const { ClassExpressionType: T } = require('../model/OWLClassExpression');
+
+// ---------------------------------------------------------------------------
+// Shared helpers
+// ---------------------------------------------------------------------------
+
+function isNamedClass(e) {
+  return e && e.getIRI && e.getEntityType && e.getEntityType() === 'Class';
+}
+
+function walk(expr, fn, acc = []) {
+  if (!expr) return acc;
+  fn(expr, acc);
+  for (const k of ['operand', 'filler']) {
+    if (expr[k]) walk(expr[k], fn, acc);
+  }
+  if (Array.isArray(expr.operands)) for (const o of expr.operands) walk(o, fn, acc);
+  return acc;
+}
+
+function hasType(expr, typeSet) {
+  let found = false;
+  walk(expr, (e) => { if (e.type && typeSet.has(e.type)) found = true; });
+  return found;
+}
+
+// ---------------------------------------------------------------------------
+// OWL 2 RL — subclass side must not use ObjectUnionOf / ObjectComplementOf /
+// ObjectAllValuesFrom / ObjectMaxCardinality / ObjectExactCardinality /
+// ObjectHasSelf; superclass side must not use ObjectMinCardinality /
+// ObjectExactCardinality / ObjectHasSelf / ObjectComplementOf.
+// (Simplified from W3C §RL profile definition.)
+// ---------------------------------------------------------------------------
+
+const RL_SUBCLASS_FORBIDDEN = new Set([
+  T.OBJECT_UNION_OF, T.OBJECT_COMPLEMENT_OF, T.OBJECT_ALL_VALUES_FROM,
+  T.OBJECT_MAX_CARDINALITY, T.OBJECT_EXACT_CARDINALITY, T.OBJECT_HAS_SELF
+]);
+const RL_SUPERCLASS_FORBIDDEN = new Set([
+  T.OBJECT_MIN_CARDINALITY, T.OBJECT_EXACT_CARDINALITY,
+  T.OBJECT_HAS_SELF, T.OBJECT_COMPLEMENT_OF
+]);
+
+function checkRL(ont) {
+  const violations = [];
+  const v = (rule, message, axiom) => violations.push({ profile: 'RL', rule, message, axiom });
+
+  for (const ax of ont.getAxiomsOfType(A.SUBCLASS_OF)) {
+    if (hasType(ax.subClass, RL_SUBCLASS_FORBIDDEN)) {
+      v('RL-subclass', 'SubClassOf LHS uses a construct disallowed in OWL 2 RL subclass position', ax);
+    }
+    if (hasType(ax.superClass, RL_SUPERCLASS_FORBIDDEN)) {
+      v('RL-superclass', 'SubClassOf RHS uses a construct disallowed in OWL 2 RL superclass position', ax);
+    }
+  }
+  // FunctionalDataProperty + FunctionalObjectProperty are allowed;
+  // owl:hasSelf is disallowed entirely in RL.
+  for (const ax of ont.getAxiomsOfType(A.EQUIVALENT_CLASSES)) {
+    for (const ce of ax.classExpressions) {
+      if (hasType(ce, new Set([T.OBJECT_HAS_SELF]))) {
+        v('RL-hasSelf', 'ObjectHasSelf is not allowed in OWL 2 RL', ax);
+      }
+    }
+  }
+  return violations;
+}
+
+// ---------------------------------------------------------------------------
+// OWL 2 QL — subclass side: named class or ObjectSomeValuesFrom with named
+// filler only; superclass side: named class, ObjectSomeValuesFrom(named),
+// ObjectIntersectionOf of superclass-expressions, ObjectHasValue.
+// No cardinality > 1, no ObjectUnionOf/ComplementOf/AllValuesFrom on RHS.
+// (Simplified.)
+// ---------------------------------------------------------------------------
+
+function qlSubClassOK(e) {
+  if (isNamedClass(e)) return true;
+  if (e.type === T.OBJECT_SOME_VALUES_FROM) return isNamedClass(e.filler) || isOWLThing(e.filler);
+  return false;
+}
+function qlSuperClassOK(e) {
+  if (isNamedClass(e)) return true;
+  if (e.type === T.OBJECT_SOME_VALUES_FROM) return isNamedClass(e.filler) || isOWLThing(e.filler);
+  if (e.type === T.OBJECT_INTERSECTION_OF) return e.operands.every(qlSuperClassOK);
+  if (e.type === T.OBJECT_HAS_VALUE) return true;
+  return false;
+}
+function isOWLThing(e) {
+  return isNamedClass(e) && e.getIRI().toString() === 'http://www.w3.org/2002/07/owl#Thing';
+}
+
+function checkQL(ont) {
+  const violations = [];
+  const v = (rule, message, axiom) => violations.push({ profile: 'QL', rule, message, axiom });
+
+  for (const ax of ont.getAxiomsOfType(A.SUBCLASS_OF)) {
+    if (!qlSubClassOK(ax.subClass)) {
+      v('QL-subclass', 'SubClassOf LHS not in QL form (named class or ∃P.Thing)', ax);
+    }
+    if (!qlSuperClassOK(ax.superClass)) {
+      v('QL-superclass', 'SubClassOf RHS not in QL form', ax);
+    }
+  }
+  // No FunctionalObjectProperty, no TransitiveObjectProperty, no cardinality
+  for (const t of [A.FUNCTIONAL_OBJECT_PROPERTY, A.TRANSITIVE_OBJECT_PROPERTY,
+                   A.SYMMETRIC_OBJECT_PROPERTY, A.REFLEXIVE_OBJECT_PROPERTY]) {
+    for (const ax of ont.getAxiomsOfType(t)) {
+      v('QL-' + t, `${t} is not allowed in OWL 2 QL`, ax);
+    }
+  }
+  return violations;
+}
+
+// ---------------------------------------------------------------------------
+// OWL 2 EL — no ObjectComplementOf, no ObjectAllValuesFrom, no
+// DisjointClasses with > 2 operands allowed (binary allowed), no
+// IrreflexiveObjectProperty, no AsymmetricObjectProperty, no
+// NegativePropertyAssertion, no ObjectOneOf with > 1 individual (EL++ allows
+// nominals in some profiles but standard EL does not).
+// (Simplified.)
+// ---------------------------------------------------------------------------
+
+const EL_FORBIDDEN = new Set([
+  T.OBJECT_COMPLEMENT_OF, T.OBJECT_ALL_VALUES_FROM, T.OBJECT_UNION_OF
+]);
+
+function checkEL(ont) {
+  const violations = [];
+  const v = (rule, message, axiom) => violations.push({ profile: 'EL', rule, message, axiom });
+
+  for (const ax of ont.getAxiomsOfType(A.SUBCLASS_OF)) {
+    if (hasType(ax.subClass, EL_FORBIDDEN) || hasType(ax.superClass, EL_FORBIDDEN)) {
+      v('EL-expr', 'ObjectComplementOf / ObjectAllValuesFrom / ObjectUnionOf not allowed in OWL 2 EL', ax);
+    }
+  }
+  for (const t of [A.IRREFLEXIVE_OBJECT_PROPERTY, A.ASYMMETRIC_OBJECT_PROPERTY,
+                   A.FUNCTIONAL_OBJECT_PROPERTY, A.INVERSE_FUNCTIONAL_OBJECT_PROPERTY,
+                   A.NEGATIVE_OBJECT_PROPERTY_ASSERTION, A.NEGATIVE_DATA_PROPERTY_ASSERTION]) {
+    for (const ax of ont.getAxiomsOfType(t)) {
+      v('EL-' + t, `${t} is not allowed in OWL 2 EL`, ax);
+    }
+  }
+  return violations;
+}
+
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+
+const Profiles = Object.freeze({ RL: 'RL', QL: 'QL', EL: 'EL' });
+
+/**
+ * Check an ontology against a profile.
+ * @param {OWLOntology} ont
+ * @param {'RL'|'QL'|'EL'} profile
+ * @returns {Array<{profile:string, rule:string, message:string, axiom:Object}>}
+ */
+function checkProfile(ont, profile) {
+  if (profile === 'RL') return checkRL(ont);
+  if (profile === 'QL') return checkQL(ont);
+  if (profile === 'EL') return checkEL(ont);
+  throw new Error('Unknown profile: ' + profile);
+}
+
+/** True iff the ontology is in the given profile. */
+function isInProfile(ont, profile) {
+  return checkProfile(ont, profile).length === 0;
+}
+
+module.exports = { Profiles, checkProfile, isInProfile, checkRL, checkQL, checkEL };

package/src/server/public/app.js

@@ -0,0 +1,97 @@
+'use strict';
+
+let currentKind = 'class';
+
+async function api(path, opts) {
+  const res = await fetch(path, opts);
+  return res.json();
+}
+
+function renderNode(node) {
+  const div = document.createElement('div');
+  div.className = 'node';
+  const row = document.createElement('div');
+  row.className = 'row';
+  const twisty = document.createElement('span');
+  twisty.className = 'twisty';
+  const hasChildren = node.children && node.children.length > 0;
+  twisty.textContent = hasChildren ? '▾' : '·';
+  if (hasChildren) {
+    twisty.onclick = () => {
+      div.classList.toggle('collapsed');
+      twisty.textContent = div.classList.contains('collapsed') ? '▸' : '▾';
+    };
+  }
+  row.appendChild(twisty);
+  const name = document.createElement('span');
+  name.textContent = node.name;
+  name.title = node.iri;
+  row.appendChild(name);
+  if (hasChildren) {
+    const badge = document.createElement('span');
+    badge.className = 'badge';
+    badge.textContent = `(${node.children.length})`;
+    row.appendChild(badge);
+  }
+  div.appendChild(row);
+  if (hasChildren) {
+    const ch = document.createElement('div');
+    ch.className = 'children';
+    for (const c of node.children) ch.appendChild(renderNode(c));
+    div.appendChild(ch);
+  }
+  return div;
+}
+
+async function refreshTree() {
+  const wrap = document.getElementById('tree-wrap');
+  const data = await api('/api/tree?kind=' + encodeURIComponent(currentKind));
+  wrap.innerHTML = '';
+  if (!data.ok) {
+    wrap.innerHTML = '<div id="empty">尚未加载本体。</div>';
+    return;
+  }
+  if (!data.tree.length) {
+    wrap.innerHTML = '<div id="empty">该层级为空。</div>';
+    return;
+  }
+  for (const root of data.tree) wrap.appendChild(renderNode(root));
+}
+
+async function refreshStats() {
+  const s = await api('/api/stats');
+  const el = document.getElementById('stats');
+  if (!s.loaded) { el.textContent = ''; return; }
+  el.textContent = `公理 ${s.axiomCount} · 类 ${s.classes} · 对象属性 ${s.objectProperties} · 数据属性 ${s.dataProperties} · 个体 ${s.individuals}`;
+}
+
+async function loadOntology() {
+  const filePath = document.getElementById('filePath').value.trim();
+  const msg = document.getElementById('msg');
+  if (!filePath) { msg.textContent = '请输入文件路径'; return; }
+  msg.textContent = '加载中…';
+  const r = await api('/api/load', {
+    method: 'POST',
+    headers: { 'content-type': 'application/json' },
+    body: JSON.stringify({ filePath })
+  });
+  if (r.error) { msg.textContent = '加载失败: ' + r.error; return; }
+  msg.textContent = '已加载: ' + r.ontology.id;
+  await refreshStats();
+  await refreshTree();
+}
+
+document.getElementById('btn-load').addEventListener('click', loadOntology);
+document.getElementById('filePath').addEventListener('keydown', (e) => {
+  if (e.key === 'Enter') loadOntology();
+});
+document.querySelectorAll('nav .tab').forEach(tab => {
+  tab.addEventListener('click', async () => {
+    document.querySelectorAll('nav .tab').forEach(t => t.classList.remove('active'));
+    tab.classList.add('active');
+    currentKind = tab.dataset.kind;
+    await refreshTree();
+  });
+});
+
+refreshStats();