@canonical/pragma-cli 0.31.0 → 0.32.0

package/src/domains/ontology/helpers/queryClasses.ts

@@ -1,66 +0,0 @@
-import type { Store } from "@canonical/ke";
-import { buildQuery } from "../../shared/buildQuery.js";
-import extractLocalName from "../../shared/extractLocalName.js";
-import { P } from "../../shared/prefixes.js";
-
-/** A class row as stored — full URIs, all superclass edges preserved. */
-export interface RawOntologyClass {
-  readonly uri: string;
-  readonly label: string;
-  readonly comment?: string;
-  readonly subClassOf: readonly string[];
-}
-
-/**
- * Queries all `owl:Class` definitions within a namespace, including their
- * `rdfs:comment` and **every** `rdfs:subClassOf` edge (multiple inheritance
- * is preserved; downstream renderers decide tree placement).
- *
- * @note Queries ke store
- *
- * @param store - The ke store to query.
- * @param namespace - The namespace URI to filter classes by.
- * @returns An array of {@link RawOntologyClass} entries, one per class.
- */
-export default async function queryClasses(
-  store: Store,
-  namespace: string,
-): Promise<RawOntologyClass[]> {
-  const result = await store.query(
-    buildQuery(`
-      SELECT ?class ?label ?comment ?superclass
-      WHERE {
-        ?class a ${P.owl}Class .
-        FILTER(STRSTARTS(STR(?class), "${namespace}"))
-        OPTIONAL { ?class ${P.rdfs}label ?label }
-        OPTIONAL { ?class ${P.rdfs}comment ?comment }
-        OPTIONAL { ?class ${P.rdfs}subClassOf ?superclass }
-      }
-      ORDER BY ?class ?superclass
-    `),
-  );
-
-  if (result.type !== "select") return [];
-
-  const seen = new Map<
-    string,
-    { label: string; comment?: string; supers: Set<string> }
-  >();
-  for (const b of result.bindings) {
-    const uri = b.class ?? "";
-    const entry = seen.get(uri) ?? {
-      label: b.label ?? extractLocalName(uri),
-      ...(b.comment ? { comment: b.comment } : {}),
-      supers: new Set<string>(),
-    };
-    if (b.superclass) entry.supers.add(b.superclass);
-    seen.set(uri, entry);
-  }
-
-  return [...seen.entries()].map(([uri, entry]) => ({
-    uri,
-    label: entry.label,
-    ...(entry.comment ? { comment: entry.comment } : {}),
-    subClassOf: [...entry.supers].sort(),
-  }));
-}

package/src/domains/ontology/helpers/queryProperties.ts

@@ -1,90 +0,0 @@
-import type { Store } from "@canonical/ke";
-import { buildQuery } from "../../shared/buildQuery.js";
-import extractLocalName from "../../shared/extractLocalName.js";
-import { P } from "../../shared/prefixes.js";
-
-/** A property row as stored — full URIs. */
-export interface RawOntologyProperty {
-  readonly uri: string;
-  readonly label: string;
-  readonly kind: "object" | "datatype";
-  readonly domain?: string;
-  readonly range?: string;
-  readonly functional: boolean;
-}
-
-/**
- * Queries all `owl:ObjectProperty` and `owl:DatatypeProperty` definitions
- * within a namespace, marking those also typed `owl:FunctionalProperty`.
- *
- * Deduplicates by property URI -- when a property has multiple `rdfs:domain`
- * or `rdfs:range` values, only the first encountered is kept.
- *
- * @note Queries ke store
- *
- * @param store - The ke store to query.
- * @param namespace - The namespace URI to filter properties by.
- * @returns An array of {@link RawOntologyProperty} entries.
- */
-export default async function queryProperties(
-  store: Store,
-  namespace: string,
-): Promise<RawOntologyProperty[]> {
-  const result = await store.query(
-    buildQuery(`
-      SELECT ?prop ?label ?domain ?range ?propType
-      WHERE {
-        ?prop a ?propType .
-        VALUES ?propType { ${P.owl}ObjectProperty ${P.owl}DatatypeProperty }
-        FILTER(STRSTARTS(STR(?prop), "${namespace}"))
-        OPTIONAL { ?prop ${P.rdfs}label ?label }
-        OPTIONAL { ?prop ${P.rdfs}domain ?domain }
-        OPTIONAL { ?prop ${P.rdfs}range ?range }
-      }
-      ORDER BY ?prop
-    `),
-  );
-
-  if (result.type !== "select") return [];
-
-  const functional = await queryFunctionalProperties(store, namespace);
-
-  const seen = new Map<string, RawOntologyProperty>();
-  for (const b of result.bindings) {
-    const uri = b.prop ?? "";
-    if (seen.has(uri)) continue;
-    seen.set(uri, {
-      uri,
-      label: b.label ?? extractLocalName(uri),
-      ...(b.domain ? { domain: b.domain } : {}),
-      ...(b.range ? { range: b.range } : {}),
-      kind: b.propType?.includes("ObjectProperty")
-        ? ("object" as const)
-        : ("datatype" as const),
-      functional: functional.has(uri),
-    });
-  }
-
-  return [...seen.values()];
-}
-
-/** URIs within the namespace typed `owl:FunctionalProperty`. */
-async function queryFunctionalProperties(
-  store: Store,
-  namespace: string,
-): Promise<Set<string>> {
-  const result = await store.query(
-    buildQuery(`
-      SELECT ?prop
-      WHERE {
-        ?prop a ${P.owl}FunctionalProperty .
-        FILTER(STRSTARTS(STR(?prop), "${namespace}"))
-      }
-    `),
-  );
-
-  if (result.type !== "select") return new Set();
-  return new Set(
-    result.bindings.map((b) => b.prop).filter((p): p is string => Boolean(p)),
-  );
-}

package/src/domains/ontology/helpers/queryTboxFacts.ts

@@ -1,160 +0,0 @@
-/**
- * Supplementary TBox queries for `ontology show` — instance counts, SHACL
- * shape summaries, the owl:Ontology header, and per-class sample instances.
- *
- * Kept together because each is a single small SELECT feeding the one
- * {@link OntologyDetailed} structure the show operation assembles.
- *
- * @note Every function queries the ke store.
- */
-
-import type { Store } from "@canonical/ke";
-import { buildQuery } from "../../shared/buildQuery.js";
-import { P } from "../../shared/prefixes.js";
-
-const SH = "http://www.w3.org/ns/shacl#";
-
-/**
- * Count instances per class within a namespace.
- *
- * One `GROUP BY ?type` query for the whole namespace — never per class.
- *
- * @returns Map from full class URI to instance count.
- */
-export async function queryInstanceCounts(
-  store: Store,
-  namespace: string,
-): Promise<ReadonlyMap<string, number>> {
-  const result = await store.query(
-    buildQuery(`
-      SELECT ?type (COUNT(?s) AS ?n)
-      WHERE {
-        ?s a ?type .
-        FILTER(STRSTARTS(STR(?type), "${namespace}"))
-      }
-      GROUP BY ?type
-    `),
-  );
-
-  if (result.type !== "select") return new Map();
-
-  const counts = new Map<string, number>();
-  for (const b of result.bindings) {
-    if (b.type && b.n) counts.set(b.type, Number(b.n));
-  }
-  return counts;
-}
-
-/** A SHACL node-shape summary row — full URIs. */
-export interface RawConstraint {
-  readonly shape: string;
-  readonly targetClass?: string;
-  readonly propertyCount: number;
-}
-
-/**
- * Summarize `sh:NodeShape`s whose shape or target class lives in the
- * namespace: target class and number of property constraints.
- */
-export async function queryConstraints(
-  store: Store,
-  namespace: string,
-): Promise<RawConstraint[]> {
-  const result = await store.query(
-    buildQuery(`
-      SELECT ?shape ?target (COUNT(?p) AS ?n)
-      WHERE {
-        ?shape a <${SH}NodeShape> .
-        OPTIONAL { ?shape <${SH}targetClass> ?target }
-        OPTIONAL { ?shape <${SH}property> ?p }
-        FILTER(
-          STRSTARTS(STR(?shape), "${namespace}") ||
-          STRSTARTS(STR(?target), "${namespace}")
-        )
-      }
-      GROUP BY ?shape ?target
-      ORDER BY ?shape
-    `),
-  );
-
-  if (result.type !== "select") return [];
-
-  return result.bindings
-    .filter((b) => Boolean(b.shape))
-    .map((b) => ({
-      shape: b.shape as string,
-      ...(b.target ? { targetClass: b.target } : {}),
-      propertyCount: Number(b.n ?? 0),
-    }));
-}
-
-/** owl:Ontology header row — full URIs. */
-export interface RawOntologyMeta {
-  readonly title?: string;
-  readonly version?: string;
-  readonly imports: readonly string[];
-}
-
-/**
- * Read the `owl:Ontology` header declared in a namespace, when present:
- * title (rdfs:label), version (owl:versionInfo), and owl:imports.
- */
-export async function queryOntologyMeta(
-  store: Store,
-  namespace: string,
-): Promise<RawOntologyMeta | undefined> {
-  const result = await store.query(
-    buildQuery(`
-      SELECT ?ont ?title ?version ?import
-      WHERE {
-        ?ont a ${P.owl}Ontology .
-        FILTER(STRSTARTS(STR(?ont), "${namespace}"))
-        OPTIONAL { ?ont ${P.rdfs}label ?title }
-        OPTIONAL { ?ont ${P.owl}versionInfo ?version }
-        OPTIONAL { ?ont ${P.owl}imports ?import }
-      }
-      ORDER BY ?ont
-    `),
-  );
-
-  if (result.type !== "select" || result.bindings.length === 0) {
-    return undefined;
-  }
-
-  const first = result.bindings[0] as (typeof result.bindings)[number];
-  const imports = [
-    ...new Set(
-      result.bindings
-        .map((b) => b.import)
-        .filter((i): i is string => Boolean(i)),
-    ),
-  ].sort();
-
-  return {
-    ...(first.title ? { title: first.title } : {}),
-    ...(first.version ? { version: first.version } : {}),
-    imports,
-  };
-}
-
-/**
- * Fetch up to `limit` instance URIs of a class, as concrete entry points
- * for `graph inspect` and domain lookups.
- */
-export async function querySampleInstances(
-  store: Store,
-  classUri: string,
-  limit = 3,
-): Promise<string[]> {
-  const result = await store.query(
-    buildQuery(`
-      SELECT ?s
-      WHERE { ?s a <${classUri}> }
-      ORDER BY ?s
-      LIMIT ${limit}
-    `),
-  );
-
-  if (result.type !== "select") return [];
-  return result.bindings.map((b) => b.s).filter((s): s is string => Boolean(s));
-}

package/src/domains/ontology/helpers/resolvePrefix.ts

@@ -1,45 +0,0 @@
-import { PragmaError } from "#error";
-
-/**
- * Resolves a prefix string or full namespace URI to both prefix and namespace.
- *
- * Accepts either a short prefix (e.g. `ds`) or a full namespace URI
- * (e.g. `https://ds.canonical.com/`) and returns the matching pair.
- *
- * @param prefixOrUri - A short prefix or full namespace URI.
- * @param prefixes - Registered prefix-to-namespace mapping from the store.
- * @returns An object with `prefix` and `namespace` strings.
- * @throws PragmaError.invalidInput if the prefix or namespace is unknown.
- */
-export default function resolvePrefix(
-  prefixOrUri: string,
-  prefixes: Readonly<Record<string, string>>,
-): { prefix: string; namespace: string } {
-  if (prefixOrUri.startsWith("http://") || prefixOrUri.startsWith("https://")) {
-    const entry = Object.entries(prefixes).find(([, ns]) => ns === prefixOrUri);
-    if (entry) return { prefix: entry[0], namespace: entry[1] };
-
-    throw PragmaError.invalidInput("namespace", prefixOrUri, {
-      validOptions: Object.values(prefixes),
-      recovery: {
-        message: "List loaded ontology namespaces.",
-        cli: "pragma ontology list",
-        mcp: { tool: "ontology_list" },
-      },
-    });
-  }
-
-  const namespace = prefixes[prefixOrUri];
-  if (namespace === undefined) {
-    throw PragmaError.invalidInput("prefix", prefixOrUri, {
-      validOptions: Object.keys(prefixes),
-      recovery: {
-        message: "List loaded ontologies.",
-        cli: "pragma ontology list",
-        mcp: { tool: "ontology_list" },
-      },
-    });
-  }
-
-  return { prefix: prefixOrUri, namespace };
-}

package/src/domains/ontology/index.ts

@@ -1,26 +0,0 @@
-/**
- * @module Ontology domain barrel.
- *
- * Provides ontology listing, detailed schema inspection, and raw triple retrieval.
- */
-
-import type { CommandDefinition } from "@canonical/cli-core";
-import type { PragmaContext } from "../shared/context.js";
-import { listCommand, showCommand } from "./commands/index.js";
-
-/**
- * Returns all command definitions for the ontology domain.
- *
- * @param ctx - Pragma runtime context.
- * @returns An array of command definitions (`ontology list`, `ontology show`).
- */
-export function commands(ctx: PragmaContext): CommandDefinition[] {
-  return [listCommand(ctx), showCommand(ctx)];
-}
-
-export { specs as mcpSpecs } from "./mcp/index.js";
-export {
-  listOntologies,
-  showOntology,
-  showOntologyRaw,
-} from "./operations/index.js";

package/src/domains/ontology/mcp/index.ts

@@ -1,2 +0,0 @@
-/** @module Ontology domain MCP barrel — ontology_list, ontology_show. */
-export { default as specs } from "./specs.js";

package/src/domains/ontology/mcp/specs.ts

@@ -1,16 +0,0 @@
-/**
- * MCP tool specs for the ontology domain — ontology_list and
- * ontology_show, compiled from the ontology read stories in
- * `../stories.ts` so both surfaces share formatters and resolution.
- */
-
-import { compileReadTool } from "../../shared/stories/index.js";
-import type { ToolSpec } from "../../shared/ToolSpec.js";
-import { ontologyListStory, ontologyShowStory } from "../stories.js";
-
-const specs: readonly ToolSpec[] = [
-  compileReadTool(ontologyListStory),
-  compileReadTool(ontologyShowStory),
-];
-
-export default specs;

package/src/domains/ontology/operations/index.ts

@@ -1,5 +0,0 @@
-/** @module Barrel for ontology operations. */
-
-export { default as listOntologies } from "./listOntologies.js";
-export { default as showOntology } from "./showOntology.js";
-export { default as showOntologyRaw } from "./showOntologyRaw.js";

package/src/domains/ontology/operations/listOntologies.test.ts

@@ -1,122 +0,0 @@
-import type { Store } from "@canonical/ke";
-import { afterAll, beforeAll, describe, expect, it } from "vitest";
-import { createTestStore, DS_ALL_TTL } from "#testing";
-import { DEFAULT_PREFIX_MAP } from "../../shared/prefixes.js";
-import listOntologies from "./listOntologies.js";
-
-let store: Store;
-let cleanup: () => void;
-
-beforeAll(async () => {
-  const result = await createTestStore({ ttl: DS_ALL_TTL });
-  store = result.store;
-  cleanup = result.cleanup;
-});
-
-afterAll(() => cleanup());
-
-describe("listOntologies", () => {
-  it("returns loaded namespaces with counts", async () => {
-    const result = await listOntologies(store);
-    expect(result.length).toBeGreaterThan(0);
-
-    const ds = result.find((o) => o.prefix === "ds");
-    expect(ds).toBeDefined();
-    expect(ds?.namespace).toBe(DEFAULT_PREFIX_MAP.ds);
-    expect(ds?.classCount).toBeGreaterThan(0);
-    expect(ds?.relationCount).toBeGreaterThan(0);
-    expect(ds?.attributeCount).toBeGreaterThan(0);
-    expect(ds?.anatomyCount).toBeGreaterThan(0);
-  });
-
-  it("splits relations from attributes", async () => {
-    const result = await listOntologies(store);
-    const ds = result.find((o) => o.prefix === "ds");
-    // ds:tier is an object property; ds:name is a datatype property.
-    expect(ds?.relationCount).toBeGreaterThan(0);
-    expect(ds?.attributeCount).toBeGreaterThan(0);
-  });
-
-  it("carries the owl:Ontology header and SHACL shape count", async () => {
-    const result = await listOntologies(store);
-    const ds = result.find((o) => o.prefix === "ds");
-    expect(ds?.title).toBe("Design System Ontology");
-    expect(ds?.version).toBe("0.1.0-test");
-    expect(ds?.shapeCount).toBeGreaterThan(0);
-  });
-
-  it("omits header fields for namespaces without an owl:Ontology node", async () => {
-    const result = await listOntologies(store);
-    const cs = result.find((o) => o.prefix === "cs");
-    expect(cs?.title).toBeUndefined();
-    expect(cs?.version).toBeUndefined();
-  });
-
-  it("includes cs namespace", async () => {
-    const result = await listOntologies(store);
-    const cs = result.find((o) => o.prefix === "cs");
-    expect(cs).toBeDefined();
-    expect(cs?.classCount).toBeGreaterThan(0);
-    expect(cs?.anatomyCount).toBe(0);
-  });
-
-  it("lists namespaces without a registered prefix", async () => {
-    const scoped = await createTestStore({
-      ttl: `@prefix owl: <http://www.w3.org/2002/07/owl#> .
-<http://unprefixed.example.org/ontology#Widget> a owl:Class .
-<http://unprefixed.example.org/ontology#partOf> a owl:ObjectProperty .`,
-    });
-    try {
-      const result = await listOntologies(scoped.store);
-      const anon = result.find(
-        (o) => o.namespace === "http://unprefixed.example.org/ontology#",
-      );
-      expect(anon).toBeDefined();
-      expect(anon?.prefix).toBe("");
-      expect(anon?.classCount).toBe(1);
-      expect(anon?.relationCount).toBe(1);
-    } finally {
-      scoped.cleanup();
-    }
-  });
-
-  it("derives namespaces from short path-only URIs", async () => {
-    const scoped = await createTestStore({
-      ttl: `@prefix owl: <http://www.w3.org/2002/07/owl#> .
-<http://a/b> a owl:Class .`,
-    });
-    try {
-      const result = await listOntologies(scoped.store);
-      expect(result.find((o) => o.namespace === "http://a/")?.classCount).toBe(
-        1,
-      );
-    } finally {
-      scoped.cleanup();
-    }
-  });
-
-  it("lists a namespace that only contributes SHACL shapes", async () => {
-    const scoped = await createTestStore({
-      ttl: `@prefix sh: <http://www.w3.org/ns/shacl#> .
-<http://shapes.example.org/ontology#OnlyShape> a sh:NodeShape .`,
-    });
-    try {
-      const result = await listOntologies(scoped.store);
-      const shapeOnly = result.find(
-        (o) => o.namespace === "http://shapes.example.org/ontology#",
-      );
-      expect(shapeOnly).toBeDefined();
-      expect(shapeOnly?.shapeCount).toBe(1);
-      expect(shapeOnly?.classCount).toBe(0);
-    } finally {
-      scoped.cleanup();
-    }
-  });
-
-  it("returns sorted by prefix", async () => {
-    const result = await listOntologies(store);
-    const prefixes = result.map((o) => o.prefix);
-    const sorted = [...prefixes].sort();
-    expect(prefixes).toEqual(sorted);
-  });
-});