@google-cloud/kcmd 0.0.0-stage → 0.2.0

package/build/ts/kcmd/semantic/converters/owl/convert.js

@@ -0,0 +1,41 @@
+"use strict";
+// OWL -> OSI conversion orchestrator.
+//
+// The public entry point of the OWL converter: it wires the three steps --
+// parse Turtle (parse.ts) -> map to the IR (to_ir.ts) -> serialize to OSI YAML
+// (../../osi_converter, reused unchanged) -- and returns the YAML plus a small
+// summary the CLI reports. It adds no mapping policy of its own.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertOwlToOsi = convertOwlToOsi;
+const osi_converter_1 = require("../../osi_converter");
+const parse_1 = require("./parse");
+const to_ir_1 = require("./to_ir");
+/**
+ * Converts a Turtle (.ttl) OWL ontology to an OSI YAML document.
+ *
+ * `modelName` names the resulting semantic model (the CLI derives it from the
+ * source filename). The output is a purely LOGICAL model -- see to_ir.ts and
+ * the user guide -- with no physical binding; it loads and pushes to Knowledge
+ * Catalog as-is, and a graph deploy adds bindings on top.
+ *
+ * `opts.compactFlow` emits the compact flow YAML layout (the `owl import
+ * --compact` flag) instead of the default block layout; both parse identically.
+ *
+ * Throws only on malformed Turtle (the parser's error); mapping gaps are
+ * reported as warnings, not failures.
+ */
+function convertOwlToOsi(turtle, modelName, opts = {}) {
+    const owl = (0, parse_1.parseOwl)(turtle);
+    const { model, warnings: mapWarnings, stats } = (0, to_ir_1.owlToIr)(owl, modelName);
+    // An OWL import is always logical (no source/expression), so tell the
+    // serializer not to warn about the missing physical binding. `compactFlow`
+    // is opt-in (the `owl import --compact` flag): it emits the compact flow
+    // layout the semantic-model guides use so the shown output is reproducible;
+    // the default is the standard block layout.
+    const { yaml, warnings: serializeWarnings } = (0, osi_converter_1.serializeModel)(model, { logical: true, compactFlow: opts.compactFlow });
+    return {
+        yaml,
+        stats,
+        warnings: [...mapWarnings, ...serializeWarnings],
+    };
+}

package/build/ts/kcmd/semantic/converters/owl/model.d.ts

@@ -0,0 +1,98 @@
+/**
+ * Per-term annotations parsed from any class or property -- links to
+ * related/defining resources and lifecycle metadata. None has a native OSI
+ * home, and the importer is import-only, so none is carried into the model:
+ * they are dropped (the earlier custom-extension carriage was removed). Shared
+ * by OwlClass, OwlDatatypeProperty, and OwlObjectProperty.
+ */
+export interface OwlCommonAnnotations {
+    seeAlso: string[];
+    isDefinedBy: string[];
+    deprecated: boolean;
+    versionInfo?: string;
+}
+/** An `owl:Class` -- becomes an OSI dataset (entity). */
+export interface OwlClass extends OwlCommonAnnotations {
+    localName: string;
+    label?: string;
+    comment?: string;
+    synonyms: string[];
+    examples: string[];
+    keys: string[];
+    subClassOf: string[];
+    equivalentClass: string[];
+    disjointWith: string[];
+    oneOf: string[];
+}
+/**
+ * An `owl:DatatypeProperty` -- becomes a field on its domain class's dataset.
+ */
+export interface OwlDatatypeProperty extends OwlCommonAnnotations {
+    localName: string;
+    domains: string[];
+    rangeIri?: string;
+    label?: string;
+    comment?: string;
+    synonyms: string[];
+    examples: string[];
+    inverseFunctional: boolean;
+    functional: boolean;
+    subPropertyOf: string[];
+    equivalentProperty: string[];
+    propertyDisjointWith: string[];
+}
+/**
+ * An `owl:ObjectProperty` -- becomes a relationship (edge) between two
+ * classes.
+ */
+export interface OwlObjectProperty extends OwlCommonAnnotations {
+    localName: string;
+    domains: string[];
+    ranges: string[];
+    label?: string;
+    comment?: string;
+    synonyms: string[];
+    examples: string[];
+    subPropertyOf: string[];
+    inverseOf: string[];
+    equivalentProperty: string[];
+    propertyDisjointWith: string[];
+    propertyChain: string[][];
+    symmetric: boolean;
+    transitive: boolean;
+    functional: boolean;
+    reflexive: boolean;
+    irreflexive: boolean;
+    asymmetric: boolean;
+}
+/**
+ * The ontology header (an `owl:Ontology` node) -- becomes model-level metadata.
+ *
+ * A description (rdfs:comment / skos:definition / dcterms:/dc:description) ->
+ * the model `description`; labels -> `ai_context.synonyms`; skos:example ->
+ * `ai_context.examples`; owl:versionInfo -> appended to the description as
+ * provenance.
+ */
+export interface OwlOntology {
+    comment?: string;
+    synonyms: string[];
+    examples: string[];
+    version?: string;
+}
+/**
+ * A parsed OWL ontology, in declaration order.
+ *
+ * Order is preserved from the source document so the generated OSI (and its
+ * golden) is stable: entities appear in class-declaration order and each
+ * entity's fields in datatype-property-declaration order.
+ */
+export interface OwlModel {
+    baseIri?: string;
+    ontology?: OwlOntology;
+    classes: OwlClass[];
+    datatypeProperties: OwlDatatypeProperty[];
+    objectProperties: OwlObjectProperty[];
+    allDisjointClasses: string[][];
+    allDisjointProperties: string[][];
+    allDifferent: string[][];
+}

package/build/ts/kcmd/semantic/converters/owl/model.js

@@ -0,0 +1,30 @@
+"use strict";
+// The OWL intermediate model: a thin, parser-facing view of an ontology.
+//
+// This is deliberately NOT the semantic-model IR (see ../../ir.ts). It is a
+// small staging shape that the Turtle parser (parse.ts) fills from RDF triples
+// and the mapper (to_ir.ts) reads to produce the IR. Keeping the two apart lets
+// the parser stay a mechanical triples-to-structs step while all of the OWL ->
+// OSI mapping policy lives in one place (to_ir.ts).
+//
+// Scope: the OWL constructs the converter maps to native OSI today -- classes,
+// datatype/object properties, their human annotations (rdfs:label / comment,
+// skos labels / definition / example, dcterms/dc description), datatype ranges,
+// keys (owl:hasKey, owl:InverseFunctionalProperty), class hierarchy
+// (rdfs:subClassOf -> extends), and ontology-header metadata -- PLUS the
+// constructs with no native home that ride along verbatim as custom extensions:
+// property inheritance (rdfs:subPropertyOf), inverse/equivalence/disjointness
+// cross-references (owl:inverseOf, owl:equivalentClass, owl:disjointWith,
+// owl:equivalentProperty, owl:propertyDisjointWith), the full set of property
+// characteristics (symmetric / transitive / functional / reflexive /
+// irreflexive / asymmetric), per-term annotations (rdfs:seeAlso,
+// rdfs:isDefinedBy, owl:deprecated, owl:versionInfo), enumerations
+// (owl:oneOf), property chains (owl:propertyChainAxiom), and the set-level
+// axioms that hang off an anonymous node rather than a named term
+// (owl:AllDisjointClasses, owl:AllDisjointProperties, owl:AllDifferent -> the
+// model). A carried cross-reference keeps the FULL referent IRI; the mapper
+// shortens it to a local name only when it lives in this ontology's own
+// namespace (see to_ir.refValue). Richer OWL still absent (SHACL, cardinality
+// restrictions, individuals); see the "What is not covered yet" note in the
+// guide.
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/ts/kcmd/semantic/converters/owl/parse.d.ts

@@ -0,0 +1,11 @@
+import { OwlModel } from './model';
+export declare function localName(iri: string): string;
+export declare function namespace(iri: string): string | undefined;
+/**
+ * Parses a Turtle document into an OwlModel.
+ *
+ * Synchronous: `n3`'s Parser returns the full quad array when called without a
+ * callback, which suits a one-shot file import. Throws on malformed Turtle (the
+ * parser's own error), which the CLI surfaces.
+ */
+export declare function parseOwl(turtle: string): OwlModel;